70816597992351https://smlouvy.gov.cz/smlouva/79923512019-01-24T10:17:44+01:00jwaeuenKrajská nemocnice Liberec, a.s.27283933Husova 357/10, 46001 Liberec, CZBioVendor - Laboratorní medicína a.s.63471507Karásek 1767/1, BrnoKupní smlouva NP II. kombinace č. 2 a 10, č.10 - Hmotnostní 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7176f091fbdd155f652c60f69afc1cf2c05b3cc2f5c1a894cfb7557b169aab04S20180090800_TXT.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7176f091fbdd155f652c60f69afc1cf2c05b3cc2f5c1a894cfb7557b169aab04S20180090800_TXT.txt2026-06-15T15:46:06+02:001334337c72168715dc2b09845dad30929ddbb93676f0f67ce2d6e3a37ea2c9855