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