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