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