3032060032379408https://smlouvy.gov.cz/smlouva/323794082025-03-05T09:41:05+01:00jwaeuenKrajská nemocnice Liberec, a.s.27283933Husova 1430/34, 46001 Liberec, CZBMT Medical Technology,s.r.o.46346996Cejl 157/50 Brno-ZábrdoviceVybavení centr. sterilizace KNL, a.s.-č 2-Mycí automaty a rozvod detergentů-poskytování serv.služ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e2d7e6d83af7bdcaf6557cdd35458339f00891d94f9917812bd5207da8c5db9b[A] S20250008200 Vybavení centr. sterilizace KNL, a.s.-č 2-Mycí automaty a rozvod detergentů-poskytování serv.služeb.txt2026-07-05T18:00:28+02:001ec9660412540f8919349e8f37e2b2e3ad464cc1eebbc7526d8ab6acab04f1cd6