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