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