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