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