14504381566758https://smlouvy.gov.cz/smlouva/15667582017-03-28T13:21:29+02:00jwaeuenKrajská nemocnice Liberec, a.s.27283933Husova 357/10, 46001 Liberec, CZDOLLANO CARE s.r.o.04845196Na Dvorcích 1989/14, PrahaKupní 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effa96a4537427b94868a3ab510ae9d0bbc526fbc133b645972827ac83d436d1313226_TXT.txt2026-07-07T15:23:07+02:001c271d5bf3af9dcfbf8a44872e238987f76f4ee89f8a3dca47d3499c0d0b423ec