1642102717682719https://smlouvy.gov.cz/smlouva/176827192021-09-07T15:25:29+02:00jwaeuenKrajská nemocnice Liberec, a.s.27283933Husova 357/10, 46001 Liberec, CZPROFITERM PROCZECH s.r.o.03543749Michálkovická 2055/86, OstravaSmlouva o poskytování servisních služeb "Pneumatický dopravní systém"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98f142044b3a0be5550b6dcf962fa11b3a6c09c601166697cb588895ef23c02fS20210054500_TXT.txt2026-07-04T19:16:26+02:001a09977a0757740b4e4369331e976f08a262b809e780baee0c96d0d391ecadfa4