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