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