3571460938021609https://smlouvy.gov.cz/smlouva/380216092026-05-19T13:28:23+02:00jwaeuenKrajská nemocnice Liberec, a.s.27283933Husova 1430/34, 46001 Liberec, CZSOITRON s.r.o.27270599Plzeňská 3351/19 PrahaKupní smlouva "Dodávka licencí pro ochranu koncových stanic KNL, a.s."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32be5ded223f9a1fdde091a8ec43f4967860759327baa93fed9933a5b86b6a84[A] S20260041900 Kupní smlouva Dodávka licencí pro ochranu koncových stanic KNL, a.s..txt2026-07-05T10:08:15+02:00148977316d9fea5a44ef81e96ca8f3b0bf2f20124569ace8b2980a50dab10ca9e