77281438344419https://smlouvy.gov.cz/smlouva/83444192019-02-28T15:55:00+01:00jwaeuenKrajská nemocnice Liberec, a.s.27283933Husova 357/10, 46001 Liberec, CZTRW Automotive Czech s.r.o.26706342Na Roli 2405/26, Jablonec nad NisouSmlouva o poskytování služeb závodního stravování a o poskytování dalších souvisejících služeb č.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3ef12996be7421df53b31992347078e59dcd5894a80cf319b2dc7f643e6bd10dS20180019000_TXT.txt2026-05-24T14:45:14+02:001c9169a2eb2ba888ffb2f4460ab4850819f1eee94ae99b7227c2644b89e81c85d