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