3453351736790349https://smlouvy.gov.cz/smlouva/367903492026-02-13T10:14:56+01:00jwaeuenKrajská nemocnice Liberec, a.s.27283933Husova 1430/34, 46001 Liberec, CZPfizer Inc.xHudson Boulevard East 66 New YorkSmlouva o provedení klinického hodnocení2026-02-12S2026/00114/00940698.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994d34a697683ae9ea1cb120f68312a3729fbe76006381a89a4691ff9f21716c[A] S20260011400 Smlouva o provedení klinického hodnocení.txt2026-06-03T04:14:01+02:001565f6e94ea9a04a8bd431c2e5dc4c8cf0e35f268e2f76632cbe4065c21919443