3596689338283952https://smlouvy.gov.cz/smlouva/382839522026-06-05T15:04:46+02:00jwaeuenKrajská nemocnice Liberec, a.s.27283933Husova 1430/34, 46001 Liberec, CZPPS Kania s.r.o.26821940Nivnická 665/10 OstravaSoD - Zpracování PD "Projekt rozšíření, rekonstrukce a přestavby Urg. příjmu NsP Česká Lípa, a.s."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[A] S20260041300 SoD - Zpracování PD Projekt rozšíření, rekonstrukce a přestavby Urg. příjmu NsP Česká Lípa, a.s..txt2026-06-10T04:34:03+02:0015d2d8b4422060c482d482503b1724477360f0f7d08e064a142ebe55e635d2d65