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