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