2380904325504675https://smlouvy.gov.cz/smlouva/255046752023-08-22T13:42:23+02:00jwaeuenKrajská nemocnice Liberec, a.s.27283933Husova 357/10, 46001 Liberec, CZMedtronic Czechia s.r.o.64583562Prosecká 852/66, PrahaSmlouva o grantu na vzdělávání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e0e92b25efb971e3af53d1be8cc8ca076e40c2b34c62a868b36b72c99dac611cS20230065300_TXT.txt2026-05-15T04:18:40+02:0017de4ef853dee9517c78971ca3e54dd442b5076e732acbc8ce2bf9ca2e23ec9f7