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