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