1198282412865356https://smlouvy.gov.cz/smlouva/128653562020-06-03T15:34:00+02:00jwaeuenKrajská nemocnice Liberec, a.s.27283933Husova 357/10, 46001 Liberec, CZOKAY PLAST spol. s r.o.60935294Špálova 368, SobotkaVýměna oken na Interním oddělení III,Nemocnice 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ae27147b86384ad5d6ae9c301f4019707a17cfd15e3b4a60024998b0266986bdS20200031100_TXT.txt2026-05-21T07:33:10+02:001b7ede8e5bf4fc749bd09a5722309b9368417128539108cef57e2736f7ea8d0f3