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