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