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