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