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