81412158788711https://smlouvy.gov.cz/smlouva/87887112019-04-16T11:22:05+02:00jwaeuenKrajská nemocnice Liberec, a.s.27283933Husova 357/10, 46001 Liberec, CZoaza - net spol. s r.o.47282711Dr. M. Horákové čp. 81/117, LIBEREC 6Kupní smlouva _ Dodávka IT infrastruktury pro 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7d4361e5a377ca2c4e83e3185b5aa74c4156348c295e0f1965dc799bb8415ee8S20180075003_TXT.txt2026-06-29T18:26:14+02:000093402aa90d6cc2ce0c75409450e3888f8e981c004e45869c1f111a4b43fb7c1