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