2243460924058325https://smlouvy.gov.cz/smlouva/240583252023-04-12T09:58:47+02:00jwaeuenKrajská nemocnice Liberec, a.s.27283933Husova 357/10, 46001 Liberec, CZZdravotnická záchranná služba Libereckého kraje, příspěvková organizace46744991Klášterní 954/5, LiberecSmlouva o spolupráci2023-03-27S2023/00292/00byBTUE9MVVBSw4FDSQoKMS4gU21sdXZuw60gc3RyYW55CgpQb3NreXRvdmF0ZWwgemRyYXZvdG7DrWNoIHNsdcW+ZWIgQQoKbsOhemV2OiBaZHJhdm90bmlja8OhIHrDoWNocmFubsOhIHNsdcW+YmEgTGliZXJlY2vDqWhvIGtyYWplLCBwxZnDrXNwxJt2a292w6Egb3JnYW5pemFjZQpzw61kbG86IEtsw6HFoXRlcm7DrTk1NC81LCBMaWJlcmVjIEnigJRTdGFyw6kgTcSbc3RvLCA0NjAgMDEgTGliZXJlYwoKc3RhdHV0w6FybsOtIHrDoXN0dXBjZTogxZllZGl0ZWwKCknEjE86IDQ2NyA0NCA5OTEKCnNwaXNvdsOhIHpuYcSNa2E6IFByIDczOCB2ZWRlbsOhIHUgS3JhanNrw6lobyBzb3VkdSB2IMOac3TDrSBuYWQgTGFiZW0KCklEIGRhdG92w6kgc2NocsOhbmt5OiBiZ3BtdnNCCgpkw6FsZSB0YWvDqSBqYWtvIOKAnlpaUyBMVywgbmEgc3RyYW7Em2plZG7DqQoKYQoKUG9za3l0b3ZhdGVsIHpkcmF2b3Ruw61jaCBzbHXFvmViIEIKCm7DoXpldjogS3JhanNrw6EgbmVtb2NuaWNlIExpYmVyZWMsIGEucy4KCnPDrWRsbzogSHVzb3ZhIDM1Ny8xMCwgTGliZXJlYyBJLVN0YXLDqSBNxJtzdG8sIDQ2MCAwMSBMaWJlcmVjCgpzdGF0dXTDoXJuw616w6FzdHVwY2U6IHDFmWVkc2VkYSBwxZllZHN0YXZlbnN0dmEgLwptw61zdG9wxZllZHNlZGEgcMWZZWRzdGF2ZW5zdHZhCgpJxIxPOiAyNzIgODMgOTMzCgpzcGlzb3bDoSB6bmHEjWthOiBCIDE2NTEgdmVkZW7DoSB1IEtyYWpza8OpaG8gc291ZHUgdiDDmnN0w60gbmFkIExhYmVtCgpJRCBkYXRvdsOpIHNjaHLDoW5reTogandhZXVlbgoKZMOhbGUgdGFrw6lqYWtvIOKAnktOTOKAnCwgbmEgc3RyYW7EmyBkcnVow6kKCk8KCnV6YXbDrXJhasOtCgp2IHNvdWxhZHUgcyB1c3Rhbm92ZW7DrW0gNSAxNzQ2IG9kc3QuIDIgYSBzb3V2aXNlasOtY8OtbWkgdXN0YW5vdmVuw61taSB6w6Frb25hIMSNLiA4OS8yMDEyIFNiLiwKYsSNYW5za8O9IHrDoWtvbsOtaywgdiBwbGF0bsOpbSB6bsSbbsOtLCBuw63FvmUgdXZlZGVuw6lobyBkbmUsIG3Em3PDrWNlIGEgcm9rdSB0dXRvIHNtbG91dnUgbyBzcG9sdXByw6FjaS4KCjIuIMOadm9kbsOtIHVzdGFub3ZlbsOtCgooMSkKCmEpCgoyMjMgTEsgcHJvaGxhxaF1amUsIMW9ZSBzcGzFiHVqZSB2ZcWha2Vyw6kgcG9kbcOtbmt5IGEgbcOhIHZlxaFrZXLDoSBwb3TFmWVibsOhIG9wcsOhdm7Em27DrSB2eWRhbsOhIG9kYm9yZW0KemRyYXZvdG5pY3R2w60gS3JhanNrw6lobyDDusWZYWR1IExpYmVyZWNrw6lobyBrcmFqZSAoZMOhbGUgamVuIOKAnnpwxa9zb2JpbMO9IHBvc2t5dG92YXRlfOKAnCksIGEgdG8gemVqbS4gawpwb3NreXRvdsOhbsOtemRyYXZvdG7DrWNoIHNsdcW+ZWIgbsOtxb5lIHV2ZWRlbsO9Y2ggdiBww61zbS4gYSkgYcW+IGMpOgoKemRyYXZvdG5pY2vDqSB6w6FjaHJhbm7DoSBzbHXFvmJhIChkw6FsZWplbiDigJ5aWlMiKSB2ZSBzbXlzbHUgNSAyIG9kc3QuIDIgcMOtc20uIGQpIHrDoWtvbmEgxI0uIDM3Mi8yMDExClNiLiwgbyB6ZHJhdm90bsOtY2ggc2x1xb5iw6FjaCBhIHBvZG3DrW5rw6FjaCBqZWppY2ggcG9za3l0b3bDoW7DrSAoZMOhbGUgamVuIOKAnnrDoWtvbiBvIHpkcmF2b3Ruw61jaApzbHXFvmLDoWNoKeKAnCwgYSB6w6Frb25hIMSNLiAzNzQvMjAxMSBTYi4sIG8gemRyYXZvdG5pY2vDqSB6w6FjaHJhbm7DqSBzbHXFvmLEmywKCnDFmWVwcmF2YSBwYWNpZW50xa8gbmVvZGtsYWRuw6kgcMOpxI1lIChkw6FsZSBqZW4g4oCeUFBOUOKAnCkgdmUgc215c2x1IF84LCAyIG9kc3QuIDIgcMOtc20uIGYpIHrDoWtvbmEgbwp6ZHJhdm90bsOtY2ggc2x1xb5iw6FjaCwKCnpkcmF2b3RuaWNrw6EgZG9wcmF2bsOtIHNsdcW+YmEsIHJlc3AuIHJ5Y2hsw6EgcMWZZXByYXZhIHpkcmF2b3RuaWNrw71jaCBwcmFjb3ZubcWvIGsgemFiZXpwZcSNZW7DrQpuZW9ka2xhZG7DqSBww6nEjWUgdSBwb3NreXRvdmF0ZWxlIHZlIHNteXNsdSBnIDIgb2RzdC4gMiBww61zbS4gZSkgYm9kIDIgesOha29uYSDEjS4gMzcyLzIwMTEgU2IuLCBvCnpkcmF2b3Ruw61jaCBzbHXFvmLDoWNoLCBhIG5lb2RrbGFkbsOhIHDFmWVwcmF2YSB0a8OhbsOtYSBidW7Em2sgdXLEjWVuw71jaCBrIHBvdcW+aXTDrSB1IMSNbG92xJtrYSwgcMWZZXByYXZhCmzDqcSNaXbDvWNoIHDFmcOtcHJhdmvFrywga3J2ZSBhIGplasOtY2ggc2xvxb5layBhIHpkcmF2b3RuaWNrw71jaCBwcm9zdMWZZWRrxa8gbmV6Ynl0bsO9Y2ggcHJvIHBvc2t5dG51dMOtCm5lb2RrbGFkbsOpIHDDqcSNZSBuZWJvIHDFmWVwcmF2YSBkYWzFocOtaG8gYmlvbG9naWNrw6lobyBtYXRlcmnDoWx1IHZlIHNteXNsdSBnIDIgb2RzdC4gMiBww61zbS4gOSkgYm9kCjMgesOha29uYSDEjS4gMzcyLzIwMTEgU2IuLCAoKSB6ZHJhdm90bsOtY2ggc2x1xb5iw6FjaC4KCiAKCi8KClNNTE9VVkEgbyBTUE9MVVBSw4FDSQoKKDIpIFpaUyBMSyBvZHBvdsOtZMOhIHYgcm96c2FodSBwbGF0bsOpIHrFmWl6b3ZhY8OtIGxpc3RpbnkgbWouIHphIHphYmV6cGXEjW92w6Fuw60gw7prb2zFryBwxZllZG5lbW9jbmnEjW7DrQpuZW9ka2xhZG7DqSBww6nEjWUgKGTDoWxlIGplbiDigJ5QTlAiKSBhIFBQTlAgdsSNLiBzb3V2aXNlasOtY8OtIG9yZ2FuaXphY2UsIHbDvXN0YXZieSBhIHVkcsW+b3bDoW7DrWZ1bmvEjW7DrQpzw610xJsgemRyYXZvdG5pY2vDqWhvIHphxZnDrXplbsOtIHpkcmF2b3RuaWNrw6kgesOhY2hyYW5uw6kgc2x1xb5ieSBhIHBvc2t5dG92YXRlbGUgUFBOUCBuYSDDunplbcOtCkxpYmVyZWNrw6lobyBrcmFqZS4KCigzKSBLTkwgcHJvaGxhxaF1amUsIMW+ZWplIG1qLiBwb3NreXRvdmF0ZWxlbSB6ZHJhdm90bsOtY2ggc2x1xb5lYiB2ZSBzbXlzbHUgNSAyIG9kc3QuIDIgcMOtc20uIGEpIGHFviBvKSBhIDkpCmHFviBpKSB6w6Frb25hIMSNLjM3Mi8yMDExIFNiLiwgbyB6ZHJhdm90bsOtY2ggc2x1xb5iw6FjaCwgYSBkw6FsZSBwcm9obGHFoXVqZSwgxb5lIHNwbMWIdWplIHZlxaFrZXLDqSBwb2Rtw61ua3kKYSBtw6EgdmXFoWtlcsOhIHBvdMWZZWJuw6Egb3Byw6F2bsSbbsOtIHZ5ZGFuw6Egb2Rib3JlbSB6ZHJhdm90bmljdHbDrSBLcmFqc2vDqWhvIMO6xZlhZHUgTGliZXJlY2vDqWhvIGtyYWplCihkw6FsZSBqZW4g4oCeenDFr3NvYmlsw70gcG9za3l0b3ZhdGVs4oCcKSwgYSB0byB6ZWptLiBrIHBvc2t5dG92w6Fuw60gemRyYXZvdG7DrWNoIHNsdcW+ZWIgbsOtxb5lIHV2ZWRlbsO9Y2gKdiBww61zbS4gYSkgYSBiKToKYSkgemRyYXZvdG5pY2vDoSBkb3ByYXZuw61zbHXFvmJhLCByZXNwLiBwxZllcHJhdmEgcGFjaWVudMWvIG1lemkgcG9za3l0b3ZhdGVsaSBuZWJvIGsgcG9za3l0b3ZhdGVsaSBhIHpwxJt0CmRvIHZsYXN0bsOtaG8gc29jacOhbG7DrWhvIHByb3N0xZllZMOtLCBqZeKAlEnDrSB0byBuZXpieXRuw6kgayB6YWppxaF0xJtuw60gcG9za3l0bnV0w616ZHJhdm90bsOtY2ggc2x1xb5lYiAoZMOhbGVqZW4K4oCeWkRT4oCcKSwgdmUgc215c2x1IDUgMiBvZHN0LiAyIHDDrXNtLiBlKSBib2QgMSB6w6Frb25hIG8gemRyYXZvdG7DrWNoIHNsdcW+YsOhY2gsIGEKCmIpIFBQTlAgdmUgc215c2x1IDUgMiBvZHN0LiAyIHDDrXNtLiBmKSB6w6Frb25hIG8gemRyYXZvdG7DrWNoIHNsdcW+YsOhY2guCgooNCkgU21sdXZuw61zdHJhbnkgc291aGxhc27EmyBwcm9obGHFoXVqw60sIMW+ZSBtYWrDrXrDoWplbSBzcG9sdXByYWNvdmF0IHDFmcOtIHBvc2t5dG92w6Fuw616ZHJhdm90bsOtY2ggc2x1xb5lYgpkw6FsZSB1dmVkZW7DvWNoIHYgxI1sLiAzIHphIHBvZG3DrW5layB2eW1lemVuw71jaCB0b3V0byBzbWxvdXZvdS4KCjMuIFDFmWVkbcSbdCBzbWxvdXZ5CgooMSkgUMWZZWRtxJt0ZW0gdMOpdG8gc21sb3V2eSBqZSBkb2hvZGEgbyB2esOhamVtbsOpIHNwb2x1cHLDoWNpIG1lemkgc21sdXZuw61taSBzdHJhbmFtaSB2IHNvdXZpc2xvc3RpIHMKcG9za3l0b3bDoW7DrW0gbsOhc2xlZHVqw61jw61jaCB6ZHJhdm90bsOtY2ggc2x1xb5lYjoKCmEpIHDFmWVwcmF2YSBwYWNpZW50xa8gbmVvZGtsYWRuw6kgcMOpxI1lCgoxLiBzb3V2aXNlasOtY8OtIHMgw7p6ZW3DrW0gTGliZXJlY2vDqWhvIGtyYWplLCBqZWRuw6HigJRsaSBzZSBvIHRyYW5zcG9ydHkgdiByZcW+aW11IHJ5Y2hsw6kgemRyYXZvdG5pY2vDqQpwb21vY2kgKGTDoWxlamVuIOKAnlJaUOKAnCkgemFqacWhxaVvdmFuw6kgS05MLAoKMi4gc291dmlzZWrDrWPDrSBzIEtOTCwgamVkbsOhIiBzZSBvIHRyYW5zcG9ydHkgdiByZcW+aW11IHJ5Y2hsw6kgbMOpa2HFmXNrw6kgcG9tb2NpIChkw6FsZSBqZW4g4oCeUkxQIikKemFqacWhxaVvdmFuw6kgS05MLAoKYikgemRyYXZvdG5pY2vDoSBkb3ByYXZuw61zbHXFvmJhLCBhIHRvCgoxLiBwxZllcHJhdmEgcGFjaWVudMWvIG1lemkgcG9za3l0b3ZhdGVsaSBuZWJvIHogdmxhc3Ruw61obyBzb2Npw6FsbsOtaG8gcHJvc3TFmWVkw60gayBwb3NreXRvdmF0ZWxpLGplLXxpIHRvCm5lemJ5dG7DqSBrIHphamnFoXTEm27DrSBwb3NreXRudXTDrXpkcmF2b3Ruw61jaCBzbHXFvmViIChkw6FsZWplbiDigJ50cmFuc3BvcnR5IFpEUy1wxZllcHJhdmEgcGFjaWVudMWv4oCcKSwKc291dmlzZWrDrWPDrXMgw7p6ZW3DrW0gb2tyZXN1IExpYmVyZWMgYSDDunplbcOtbSBva3Jlc3UgU2VtaWx5LCB6YWppxaHFpW92YW7DoSBLTkwsCgoyLiByeWNobMOhIHDFmWVwcmF2YSB6ZHJhdm90bmlja8O9Y2ggcHJhY292bsOta8WvIGsgemFiZXpwZcSNZW7DrSBuZW9ka2xhZG7DqSBww6nEjWUgdSBwb3NreXRvdmF0ZWxlIGEKZMOhbGUgdGFrw6kgbmVvZGtsYWRuw6EgcMWZZXByYXZhIHRrw6Fuw60gYSBidW7Em2sgdXLEjWVuw71jaCBrIHBvdcW+aXTDrSB1IMSNbG92xJtrYSwgcMWZZXByYXZhIGzDqcSNaXbDvWNoCnDFmcOtcHJhdmvFrywga3J2ZSBhIGplasOtY2ggc2xvxb5layBhIHpkcmF2b3RuaWNrw71jaCBwcm9zdMWZZWRrxa8gbmV6Ynl0bsO9Y2ggcHJvIHBvc2t5dG51dMOtIG5lb2RrbGFkbsOpCnDDqcSNZSBuZWJvIHDFmWVwcmF2YSBkYWzFocOtaG8gYmlvbG9naWNrw6lobyBtYXRlcmnDoWx1IChkw6FsZSBqZW4g4oCedHJhbnNwb3J0eSBaRFPigJRwxZllcHJhdmEga3J2ZeKAnCkKc291dmlzZWrDrWPDrXMgS05MLCB6YWppxaHFpW92YW7DoSBaWlMgTEssCgpjKSB6ZHJhdm90bmlja8OhIHrDoWNocmFubsOhIHNsdcW+YmEsIHJlc3AuIHDFmWVkbmVtb2NuacSNbsOtIG5lb2RrbGFkbsOhIHDDqcSNZSBwb3NreXRvdmFuw6EgWlpTIExLIHYKYXJlw6FsdSB6ZHJhdm90bmlja8OpaG8gemHFmcOtemVuw60gS05MLCBhIHRvIHZlIHbDvWppbWXEjW7DvWNoIHDFmcOtcGFkZWNoIHphIHNpdHVhY2UgYWt0dcOhbG7DrSBuZWRvc3R1cG5vc3RpCgp2bGFzdG7DrWNoIGthcGFjaXQgS05MIHBybyDFmWXFoWVuw60gbmVvZGtsYWRuw71jaCBzw610dWFjw61zcG9qZW7DvWNoIHMgcMWZw61tw71tIG9ocm/FvmVuw61tIMW+aXZvdGEgYS9uZWJvCnNlbGjDoW7DrW0gdsOtdMOhbG7DrW9oIGZ1bmtjw60sCgpkKSBwxZllZG5lbW9jbmnEjW7DrSBhIG5lbW9jbmnEjW7DrSBuZW9ka2xhZG7DoSBww6nEjWUgcMWZaSBtaW1vxZnDoWRuw71jaCB1ZMOhbG9zdGVjaCwgaHJvbWFkbsO9Y2gKbmVob2TDoWNoIG5lYm8gb3RyYXbDoWNoLCBwcsWvbXlzbG92w71jaCBoYXbDoXJpw61jaCBhL25lYm8gcMWZw61yb2Ruw61jaCBrYXRhc3Ryb2bDoWNoIHphamnFocWlb3ZhbsOhIG9ixJttYQpwb3NreXRvdmF0ZWxpIHYgc291bGFkdSBzIHVzdGFub3ZlbsOtbSDFoSA0NiBvZHN0LiAxIHDDrXNtLiBlKSB6w6Frb25hIMSNLiAzNzIvMjAxMSBTYi4sIG8gemRyYXZvdG7DrWNoCnNsdcW+YsOhY2guLi4KCigyKSBEw6FsZWplIHDFmWVkbcSbdGVtIHTDqXRvIHNtbG91dnkgc3Rhbm92ZW7DrXZ6w6FqZW1uw6kgw7pocmFkeSB6YSBzbHXFvmJ5IHBvc2t5dG92YW7DqSBkbGUgdMOpdG8gc21sb3V2eSwKa3RlcsOpIG5lanNvdSBocmF6ZW55IHogcHJvc3TFmWVka8WvIHZlxZllam7DqWhvIHpkcmF2b3Ruw61obyBwb2ppxaF0xJtuw60gbmFwxZkuIG5lcG9qacWhdMSbbsO9IHBhY2llbnQgxI1pCmhvc3BpdGFsaXpvdmFuw70gcGFjaWVudCBwxZlpIHZuaXRyb25lbW9jbmnEjW7DrW0gdHJhbnNwb3J0dS4KCigzKSBTbWx1dm7DrXN0cmFueSBwcm8gdnlsb3XEjWVuw612xaFlY2ggcG9jaHlibm9zdMOtc3RhdsOtIG5hamlzdG8sIMW+ZQphKSBwcm8gcG90xZllYnkgdMOpdG8gc21sb3V2eSBzZSBzbWx1dm7DrXN0cmFueSBkb2hvZGx5LCDFvmUKCiAKCj0yLzEwOgoKLC4KCi8KClNNTE9VVkEgMCBTUE9MVVBSw4FDSQoKMS4gVHJhbnNwb3J0eSBQUE5QIHYgcmXFvmltdSBSWlAgYnVkb3UgemFqacWhxaVvdmF0CgpaWlMgTEsgdiByZcW+aW11IDI0LzcsIHBva3VkIHTDrW0gbmVidWRlIG9ocm/FvmVubyBwb3NreXRvdsOhbsOtIHpkcmF2b3RuaWNrw6kgesOhY2hyYW5uw6kKc2x1xb5ieSBuZWJvIG5lYnVkb3Ugb2hyb8W+ZW55IMSNaW5ub3N0aSBrIHDFmWlwcmF2ZW5vc3RpIG5hIG1pbW/FmcOhZG7DqSB1ZMOhbG9zdGkgbmVibyBrcml6b3bDqQpzaXR1YWNlICh6ZWptLiBha3V0bsOtIOKAlCBkbyAyMCBtaW4uICYgcGzDoW5vdmFuw6kg4oCUIGRsZSBwb8W+YWRhdmt1IGEgc2l0dWFjZSkgYQoKS05MIHZyZcW+aW11IHBvLXDDoSA3LDAwLTE1LDMwICh0cmFuc3BvcnR5IGRsZSBvZHN0LiAxIHDDrXNtLiBhKSBib2R1IDEsIHRqLiBzb3V2aXNlasOtY8OtCnMgw7p6ZW3DrW0gTGliZXJlY2vDqWhvIGtyYWplLCB6ZWptLiBwbMOhbm92YW7DqSksIHDFmWnEjWVtxb4gcMWZZXByYXZvdSBzb3V2aXNlasOtY8OtIHMgw7p6ZW3DrW0KTGliZXJlY2vDqWhvIGtyYWplIHNlIHJvenVtw60gcMWZZXByYXZhLCBrdGVyw6EgamUgemFow6FqZW5hIGEvbmVibyB1a29uxI1lbmEgbmEgw7p6ZW3DrQpMaWJlcmVja8OpaG8ga3JhamUsIHJlc3AuIG3DrXN0byBwxZlldnpldMOtcGFjaWVudGEgayB0cmFuc3BvcnR1IGEvbmVibyBtw61zdG8gcMWZZWTDoW7DrXBhY2llbnRhCmPDrWxvdsOpbXUgcG9za3l0b3ZhdGVsaSB6ZHJhdm90bsOtY2ggc2x1xb5lYiAoZMOhbGUgamVuIOKAnnBvc2t5dG92YXRlbOKAnCkgc2UgbmFjaMOhesOtIG5hIMO6emVtw60KTGliZXJlY2vDqWhvIGtyYWplLgoKMi4gVHJhbnNwb3J0eSBaRFMgYnVkZSB6YWppxaHFpW92YXQKCktOTCwgamVkbsOhwrsgbGkgc2UgKCkgdHJhbnNwb3J0eSBaRFPCuyDCu3DFmWVwcmF2YSBwYWNpZW50xa8gc291dmlzZWpsbSBzIMO6emVtw61tIG9rcmVzdSBMaWJlcmVjIGEKw7p6ZW3DrW0gb2tyZXN1IFNlbWlseSBkbGUgb2RzdC4gMSBwbHNtLiBiKSBib2R1IDEsIGEgdG8gbmEgdsO9enZ1IFpPUyBaWlMgTEsgKHDFmWlwcmF2ZW5vc3QKa3DFmWlqZXTDrSB2w716dnkgdnJlxb5pbXUgMjQvNywgemFow6FqZW7DrSBwxZllcHJhdnkgZG8gNjAgbWluLiBvZCBwxZlpamV0w60gdsO9enZ5KSwgcMWZacSNZW3FvgpwxZllcHJhdm91IHNvdXZpc2Vqw61jw61zIMO6emVtw61tIG9rcmVzdSBMaWJlcmVjL1NlbWlseSBzZSByb3p1bcOtIHDFmWVwcmF2YSwga3RlcsOhIGplIHphaMOhamVuYQpuYSDDunplbcOtb2tyZXN1IExpYmVyZWMvU2VtaWx5LCByZXNwLiBtw61zdG8gcMWZZXZ6ZXTDrSBwYWNpZW50YSBrIHRyYW5zcG9ydHUgc2UgbmFjaMOhesOtIG5hCsO6emVtw60gb2tyZXN1IExpYmVyZWMvU2VtaWx5LCBhIGt0ZXLDoSBqZSB1a29uxI1lbmEgcMWZZWTDoW7DrW0gcGFjaWVudGEgdmUgemRyYXZvdG5pY2vDqW0KemHFmcOtemVuw60gS05MLCBbcMWZacSNZW3FviBwxZllcHJhdm91IHNvdXZpc2Vqw61jw60gcyDDunplbcOtbSBva3Jlc3UgTGliZXJlYyBhIMO6emVtw61tIG9rcmVzdQpTZW1pbHkgc2Ugcm96dW3DrSBwxZllcHJhdmEsIGt0ZXLDoSBqZSB6YWjDoWplbmEgYS9uZWJvIHVrb27EjWVuYSBuYSDDunplbcOtIG9rcmVzdSBMaWJlcmVjCmEvbmVibyDDunplbcOtIG9rcmVzdSBTZW1pbHksIHJlc3AuIG3DrXN0byBwxZlldnpldMOtIHBhY2llbnRhIGt0cmFuc3BvcnR1IGEvbmVibyBtw61zdG8KcMWZZWTDoW7DrSBwYWNpZW50YSBjw61sb3bDqW11IHBvc2t5dG92YXRlbGkgc2UgbmFjaMOhesOtIG5hIMO6emVtw61va3Jlc3UgTGliZXJlYyBhL25lYm8gw7p6ZW3DrQpva3Jlc3UgU2VtaWx5OyB6YWjDoWplbsOtbSBwxZllcHJhdnkgc2Ugcm96dW3DrSB2w71qZXpkIHNhbml0bsOtaG8gdm96aWRsYSB6ZSBzdGFub3ZpxaF0xJsgbmVibwp6IG3DrXN0YSB1a29uxI1lbsOtIHDFmWVkY2hvesOtaG8gdHJhbnNwb3J0dSwgbmlrb2xpIG5hbG/FvmVuw60gcGFjaWVudGEgZG8gdm96aWRsYV0sICYKClpaUyBMSywgamVkbsOh4oCUSWkgc2UgKCkgdHJhbnNwb3J0eSBaRFPigJRwxZllcHJhdmEga3J2ZSBkbGUgb2RzdC4gMSBww61zbS4gYikgYm9kdSAyLCBhIHRvIG5hCnrDoWtsYWTEmyBwb8W+YWRhdmt1IEtOTCwgdiByZcW+aW11IDI0LzcgKHphaMOhamVuw610cmFuc3BvcnR1IGRvIDE1IG1pbiBvZCBwxZlpamV0w60gcG/FvmFkYXZrdQpLTkwsIHDFmWnEjWVtxb4gemFow6FqZW7DrW0gcMWZZXByYXZ5IHNlIHJvenVtw60gdsO9amV6ZCB2b3ppZGxhIHplIHN0YW5vdmnFoXTEmyBuZWJvIHptw61zdGEKdWtvbsSNZW7DrSBwxZllZGNob3ptbyB0cmFuc3BvcnR1LCBuaWtvbGkgcMWZZXZ6ZXTDrSBwxZllZG3Em3R1IHRyYW5zcG9ydHUgxZlpZGnEjWVtIHZvemlkbGEuCgozLiBUcmFuc3BvcnR5IFBQTlAgdiByZcW+aW11IFJMUCwgdGouIHMgbMOpa2HFmWVtLCBidWRvdSB6YWppxaHFpW92YXQKClpaUyBMSyB2IHJlxb5pbXUgMjQvNywgcG9rdWQgdMOtbSBuZWJ1ZGUgb2hyb8W+ZW5vIHBvc2t5dG92w6Fuw60gemRyYXZvdG5pY2vDqSB6w6FjaHJhbm7DqQpzbHXFvmJ5IG5lYm8gbmVidWRvdSBvaHJvxb5lbnkgxI1pbm5vc3RpIGsgcMWZaXByYXZlbm9zdGkgbmEgbWltb8WZw6FkbsOpIHVkw6Fsb3N0aSBuZWJvIGtyaXpvdsOpCnNpdHVhY2UgKHplam0uIGFrdXRuw60g4oCUIGRvIDIwIG1pbi4gYSBwbMOhbm92YW7DqSDigJQgZGxlIHNpdHVhY2UpIGEKCktOTCB2IHJlxb5pbXUgcG8tcMOhIDfCuzE1LDMwIFJMUCAodHJhbnNwb3J0eSBkbGUgb2RzdC4gMSBww61zbS4gJikgYm9kdSAyLCB0ai4gIm5hIHNlYmUiIGEgIm9kCnNlYmUiLCByZXNwLiBzb3V2aXNlasOtY8OtIHMgS05MKSwgcMWZacSNZW3FviBwxZllcHJhdm91IHNvdXZpc2Vqw61jw60gcyBLTkwgamUgcMWZZXByYXZhLCBrdGVyw6EgamUKemFow6FqZW5hIGEvbmVibyB1a29uxI1lbmEsIHJlc3AuIHDFmWV2emV0w60gbmVibyBwxZllZMOhbsOtIHDFmWVwcmF2b3ZhbsOpIG9zb2J5IG5lYm8KcMWZZXByYXZvdmFuw6lobyBtYXRlcmnDoWx1amUgemFow6FqZW5vL3Vrb27EjWVubyB2ZSB6ZHJhdm90bmlja8OpbSB6YcWZw616ZW7DrSBLTkw7CgpiKSBwxZllZG3Em3RlbSBzcG9sdXByw6FjZSBzbWx1dm7DrWNoIHN0cmFuIG5lbsOtIHBvc2t5dG92w6Fuw60gemRyYXZvdG5pY2vDqSB6w6FjaHJhbm7DqSBzbHXFvmJ5LCB2eWptYQpzaXR1YWPDrWEgdWTDoWxvc3TDrWRsZSBvZHN0LiAxIHDDrXNtLiBjKSBhIGQpOwoKYykgdnrDoWplbW7DoSBzcG9sdXByw6FjZSAmIHNvdcSNaW5ub3N0IHDFmWkgcG9za3l0b3bDoW7DrSB6ZHJhdm90bsOtY2ggc2x1xb5lYiB0b3V0byBzbWxvdXZvdSBuZXVwcmF2ZW7DqQpzZSDFmcOtZMOtb2JlY27EmyBwbGF0bsO9bWkgcHJhdmlkbHkgdXByYXZ1asOtY8OtbWkgdnrDoWplbW7DqSB2enRhaHkgcG9za3l0b3ZhdGVsxa8gYSB2IHDFmWltxJvFmWVuw6ltIHJvenNhaHUKdGFrw6kgdnp0YWh5IHBvc2t5dG92YXRlbMWvIHNlIHpkcmF2b3Ruw61taSBwb2ppxaHFpW92bmFtaSwgcG9za3l0b3ZhdGVsxa8gcyBvcmfDoW55IHZlxZllam7DqSBtb2NpIGEKcG9za3l0b3ZhdGVsxa8gcyBwYWNpZW50eTsKCjQuIFDFmWVwcmF2YSBwYWNpZW50xa8gbmVvZGtsYWRuw6kgcMOpxI1lCgooMSkgMjI4IExLLCByZXNwLiAyMDgsIGplIGdhcmFudGVtIGEga29vcmRpbsOhdG9yZW0gdsO9a29udSBQUE5QIG5hIMO6emVtw60gTGliZXJlY2vDqWhvIGtyYWplIHZlIHNteXNsdQpwxZnDrWptdSwgdnlob2Rub2NlbsOtIGEgesOhem5hbXUgcG/FvmFkYXZrdSBuYSByZWFsaXphY2kgUFBOUCB6ZSB6ZHJhdm90bmlja8OpaG8gemHFmcOtemVuw60KcG9za3l0b3ZhdGVsZSBsxa/FvmtvdsOpIHDDqcSNZSBuYSDDunplbcOtIExpYmVyZWNrw6lobyBrcmFqZSwgb2RrdWQgamUgcGFjaWVudCB0cmFuc3BvcnRvdsOhbiAoZMOhbGUgamVuCuKAnm9kZXPDrWxhasOtY8OtIHBvc2t5dG92YXRlfCIpIGsgY8OtbG92w6ltdSBwb3NreXRvdmF0ZWxpLgoKIAoKZ3MvbG87CgooMikKCig1KQoKYSkKCmIpCgpTTUxPVVZBIG8gU1BPTFVQUsOBQ0kKClBQTiBQLCBrdGVyb3Ugc2UgdiBzb3VsYWR1IHMgdXN0YW5vdmVuw61tICYgMiBvZHN0LiAyIHDDrXNtLiBmKSB6w6Frb25hIG8gemRyYXZvdG7DrWNoIHNsdcW+YsOhY2ggcm96dW3DrQpqZWppY2ggcMWZZXByYXZhIG1lemkgcG9za3l0b3ZhdGVsaSB2w71ocmFkbsSbIHphIHBvZG3DrW5layBzb3VzdGF2bsOpaG8gcG9za3l0b3bDoW7DrSBuZW9ka2xhZG7DqSBww6nEjWUKYsSbaGVtIHDFmWVwcmF2eSwgKGTFmcOtdmUgdHp2LiBzZWt1bmTDoXJuw60gcMWZZXZvenkpLCBpbmRpa3VqZSBsw6lrYcWZIG9kZXPDrWxhasOtY2ZobyBwb3NreXRvdmF0ZWxlIGzFr8W+a292w6kKcMOpxI1lLCBvZGt1ZCBqZSBwYWNpZW50IHRyYW5zcG9ydG92w6FuIChkw6FsZSBqZW4g4oCeb2Rlc8OtbGFqw61jw60gcG9za3l0b3ZhdGV84oCcKSBrIGPDrWxvdsOpbXUgcG9za3l0b3ZhdGVsaS4KWmRyYXZvdG5pY2vDqSB6YcWZw616ZW7DrSBvZGVzw61sYWrDrWPDrWhvIHBvc2t5dG92YXRlbGUgbmEgw7p6ZW3DrSBMaWJlcmVja8OpaG8ga3JhamUgdnpuw6HFocOtIHBvxb5hZGF2ZWsgbmEKemFqacWhdMSbbsOtIFBQTlAgdsO9aHJhZG7EmyB0ZWxlZm9uaWNreSBuYSB6ZHJhdm90bmlja8OpIG9wZXJhxI1uw60gc3TFmWVkaXNrbyAoZMOhbGVqZW4g4oCeWk9T4oCcKSBaWlMgTEssIGEgdG8KWnByYXZpZGxhIGRvIDE1LjAwIGhvZCBwcmFjb3Zuw61obyBkbmUgcMWZZWRjaMOhemVqw61jw61obyBkbmkgdHJhbnNwb3J0dSBhIGJleiBvaGxlZHUgbmEgcG9za3l0b3ZhdGVsZSwKa3RlcsO9IGJ1ZGUgdHJhbnNwb3J0IHJlYWxpem92YXQuCgpOYSB6w6FrbGFkxJsgdnlob2Rub2NlbsOtIHBvxb5hZGF2a3Ugcm96aG9kdWplIG9wZXLDoXRvciAyMDUgbyBqZWhvIG9wcsOhdm7Em25vc3RpIGEgZMOhbGUgbwpuZWp2aG9kbsSbasWhw61tIHpwxa9zb2J1IHphamnFoXTEm27DrSBQUE5QIHNwxZlpaGzDqWRudXTDrW0ga2UgemRyYXZvdG7DrW11IHN0YXZ1IHBhY2llbnRhLCBzdHVwbmkKbmFsw6loYXZvc3RpIHphaMOhamVuw610cmFuc3BvcnR1LCBha3R1w6FsbsOtc2l0dWFvaSB2IG9wZXJhxI1uw61tIMWZw616ZW7DrXbDvWplemRvdsO9Y2ggc2t1cGluIFpaUyBMS2EgcG9wxZkuCmRhbMWhw61jaCBzdWJqZWt0xa8gesO6xI1hc3RuxJtuw71jaCBwxZlpIHphasOtxaF0J292w6Fuw61aWlMgYSBQUE5QIG5hIMO6emVtw60gTGliZXJlY2vDqWhvIGtyYWplOyBvcGVyw6F0b3IgZMOhbGUKb2JqZWRuYXZhdGVsw60gcG90dnJkw60sIHBvcMWZLiBwbyBkb2hvZMSbIHNvYmplZG5hdmF0ZWxlbSB1cHJhdsOtIHBvxb5hZG92YW7DvSB0ZXJtw61uIHphaMOhamVuw60KdHJhbnNwb3J0dS4gSW5kaWthY8OtIGsgdHJhbnNwb3J0dSB2IHJlxb5pbXUgUkxQIHNjaHZhbHVqZSB2xb5keSB2ZWRvdWPDrWzDqWthxZlzbcSbbnkgWlpTIExLLgoKWk9TIFpaUyBMSyB6YWTDoXbDoSByZWFsaXphY2kgdHJhbnNwb3J0xa8gUFBOUCBwb2t5bmVtIGt2w71qZXpkdSB2bGFzdG7DrW0gdsO9amV6ZG92w71tIHNrdXBpbsOhbQpQUE5QIGF2w71qZXpkb3bDvW0gc2t1cGluw6FtIFBQTlAgZGFsxaHDrWNoIHpwxa9zb2JpbMO9Y2ggcG9za3l0b3ZhdGVsxa8sIHbEjS4gS05MIFBvc2t5dG92YXRlbMOpCnV2ZWRlbsOtIHZlIHbEm3TEmyBwcnZuw60gcmVhbGl6dWrDrSB0cmFuc3BvcnR5IFBQTlAgdsO9aHJhZG7EmyBuYSB6w6FrbGFkxJsgcG9reW51IGsgdsO9amV6ZHUgcMWZZWRhbsOpaG8KemRyYXZvdG5pY2vDvW0gb3BlcmHEjW7DrW0gc3TFmWVkaXNrZW0gWlpTIExLLCAmIHRvIHYgcmXFvmltdSByeWNobMOpIGzDqWthxZlza8OpIHBvbW9jaSBuZWJvIHJ5Y2hsw6kKemRyYXZvdG5pY2vDqSBwb21vY2kuCgpWIHTDqSBzb3V2aXNsb3N0w60gc2UgS05MIGTDoWxlIHphdmF6dWplCgppbmZvcm1vdmF0IFpPUyBwcm9zdMWZZWRuaWN0dsOtbSBzdGF0dXNvdmHEjWUsIHBvcMWZLiBjZXN0b3UgZGlzcGXEjWlua3UgS05MIG8gxI1pbm5vc3RpIHN2xJsgcG9zw6Fka3kKUFBOUCBuYSDDunplbcOtIExpYmVyZWNrw6lobyBrcmFqZSwgemVqbS4gbyB6YWjDoWplbsOtIHbDvWplemR1LCBkb3Nhxb5lbsOtIG9kZXPDrWxhasOtY8OtaG8gbmVibyBjw61sb3bDqWhvCnphxZnDrXplbsOtYSBvIHVrb27EjWVuw610cmFuc3BvcnR1IHDFmWVkw6Fuw61tIHBhY2llbnRhLAoKayBwxZlpcHJhdmVub3N0aSBuZXDFmWV0csW+aXTEmyBwxZlpasOtbWF0IHBva3luIGsgcmVhbGl6YWNpIFBQTlAgc2Ugc3Rhbm92ZW7DvW0gcG/FvmFkYXZrZW0gbmEgdGVybcOtbgpyZWFsaXphY2UgdHJhbnNwb3J0dSBwxZlpcGFkYWrDrWPDrSBuYSB2xaFlZG7DrWRlbiBuYSBkb2J1IG9kIDcuMDAgZG8gMTUuMzAgaG9kLjsKCnBvc2t5dG92YXQgemRyYXZvdG7DrXNsdcW+YnkgdiBzb3V2aXNsb3N0aSBzZSB6YWppxaHFpW92w6Fuw61tIFBQTlAKCjEuIHByb3N0xZllZG5pY3R2w61tIHBvc8OhZGVrIFBQTlAsIGplamljaMW+IMSNbGVub3bDqSBzcGzFiHVqw60gcG/FvmFkYXZreSBuYSBwZXJzb27DoWxuw60gemFiZXpwZcSNZW7DrQpQUE5QIGRsZSBib2R1IDEuMS4gcMWZw61sb2h5IMSNLiA3IHZ5aGzDocWha3kgxI0uIDk5LzIwMTIgU2IuLCBvIHBvxb5hZGF2Y8OtY2ggbmEgbWluaW3DoWxuw61wZXJzb27DoWxuw60KemFiZXpwZcSNZW7DrSB6ZHJhdm90bsOtY2ggc2x1xb5lYiwgdiBwbGF0bsOpbSB6bsSbbsOtLiBQb8W+YWRhdmt5IG5hIHBlcnNvbsOhbG7DrSB6YWJlenBlxI1lbsOtanNvdQp1dmVkZW55IG7DrcW+ZSB2IGthcC41IG9kc3QgMi4KCjIuIHZlIHpkcmF2b3RuaWNrw6ltIHphxZnDrXplbsOtLCBqZWhvxb4gdGVjaG5pY2vDqSBhIHbEm2NuxJsgdnliYXZlbsOtIG9kcG92w61kw6EgcG/FvmFkYXZrxa9tIHN0YW5vdmVuw71tCnDFmcOtbG9oYW1pIMSNLiAxIGEgOCB2eWhsw6HFoWt5IMSNLiA5Mi8yMDEyIFNiLiwgbyBwb8W+YWRhdmPDrWNoIG5hIG1pbmltw6FsbsOtIHRlY2huaWNrw6kgYSB2xJtjbsSbCnZ5YmF2ZW7DrSB6ZHJhdm90bmlja8O9Y2ggemHFmcOtemVuw60gYSBrb250YWt0bsOtY2ggcHJhY292acWhxaUgZG9tw6Fjw60gcMOpxI1lLCB2IHBsYXRuw6ltIHpuxJtuw60uIEFkcmVzYQpwcmFjb3ZpxaF0xJtqZSB1dmVkZW5hIG7DrcW+ZSwKCjMuIHMgdnl1xb5pdMOtbSBkb3ByYXZuw61jaCBwcm9zdMWZZWRrxa8gb2Rwb3bDrWRhasOtY8OtY2ggcG/FvmFkYXZrxa9tIHV2ZWRlbsO9bSB2IMSNw6FzdGkgSWxsLiBwxZnDrWxvaHkgawp2eWhsw6HFoWNlIMSNLiAyOTYvMjAxMiBTYi4sIG8gcG/FvmFkYXZjw61jaCBuYSB2eWJhdmVuw60gcG9za3l0b3ZhdGVsZSB6ZHJhdm90bmlja8OpIGRvcHJhdm7DrQpzbHXFvmJ5LCBwb3NreXRvdmF0ZWxlIHpkcmF2b3RuaWNrw6kgesOhY2hyYW5uw6kgc2x1xb5ieSBhIHBvc2t5dG92YXRlbGUgcMWZZXByYXZ5IHBhY2llbnTFrwpuZW9ka2xhZG7DqSBww6nEjWUgZG9wcmF2bsOtbWkgcHJvc3TFmWVka3kgYSBvIHBvxb5hZGF2Y8OtY2ggbmEgdHl0byBkb3ByYXZuw60gcHJvc3TFmWVka3ksIHYgcGxhdG7DqW0Kem7Em27DrS4gQmFydmEgc2FuaXR5IGJ1ZGUgYsOtbMOhICh6w6Fsb8W+bsOtc2FuaXRhIGplIMW+bHV0w6EpLgoKZG9wbG5pdCBiZXogb2hsZWR1IG5hIHBvc2t5dG92YXRlbGUgUFBOUCB2w71qZXpkb3ZvdSBza3VwaW51IFJaUAoKMS4gemRyYXZvdG5pY2vDvW0gesOhY2hyYW7DocWZZW0gbmVibyBzZXN0cm91IHBybyBpbnRlbnppdm7DrSBww6nEjWkgZGxlIGthcC41IHDDrXNtLiBhKSBib2QgMSwKemHFoWtvbGVuw71taSB2IG9ic2x1emUgaW5rdWLDoXRvcnUsIGtkeWtvbGkgc2VqZWRuw6EgbyBwxZllcHJhdnUgcGFjaWVudGEgdiBpbmt1YsOhdG9ydSBzb3V2aXNlasOtY8OtCnMgS05MLCBuZWJvCgoyLiBsw6lrYcWZZW0gZGxlIGthcC41IHDDrXNtLiBiKSBib2QgMSB6cMWvc29iaWzDqWhvIGsgemF2w6FkxJtuw61hIHVkcsW+b3bDoW7DrWzDqcSNYnkgemFocm51asOtY8OtaW50cmFhb3J0w6FsbsOtCmJhbG9ub3ZvdSBrb250cmFwdWx6YWNpIChkw6FsZSBqZW4g4oCeSUFCS+KAnCkgYS9uZWJvIG1pbW90xJtsbsOtIG1lbWJyw6Fub3ZvdSBveHlnZW5hY2kgYQptaW1vdMSbbG7DrW9ixJtoIChkw6FsZSBqZW4g4oCeRUNNTyIpLCBrZHlrb2xpIGplZG7DoS1JaSBzZSBvIHDFmWVwcmF2dSBwYWNpZW50YSBzZSB6YXZlZGVub3UgSUFCSwphL25lYm8gRUNNTwoKJyA0LzEwCgpfLQoKLyAtCgpTTUxPVVZBIDAgU1BPTFVQUsOBQ0kKCigxKQoKYSkKCigyKQphKQoKYikKCsKpCgooMykKCig0KQoKbmVkb21sdXZIaSBzZSBvZGVzw61sYWrDrWPDrSB6ZHJhdm90bmlja8OpIHByYWNvdmnFoXTEmyBLTkwgcyBwb3NreXRvdmF0ZWxlbSBQUE5QamluYWsuIFBvc3R1cCBtdXPDrQpiw710IHNjaHbDoWxlbiB2ZWRvdWPDrW0gbMOpa2HFmWVtIDIwOCBhIHZlZG91Y8OtbSB2w71qZXpkb3bDqSBza3VwaW55LCBrdGVyw70gbcOhIHRyYW5zcG9ydCByZWFsaXpvdmF0LgpWZWRvdWPDrSB2w71qZXpkb3bDqSBza3VwaW55IG3Fr8W+ZSB1cGxhdG5pdCB1c3Rhbm92ZW7DrSB6w6Frb24gYSAzNzQvMjAxMSBTYi4sIG8gemRyYXZvdG5pY2vDqQp6w6FjaHJhbm7DqSBzbHXFvmLEmyB2IHBsYXRuw6ltIHpuxJtuw60sIHYgxaEgMTkgb2RzdC4gMyBww61zbS4gYikgYSB2ZcWha2Vyw6EgZG9ob2RhIHRhayBwYWTDoSBhIG7DoWhyYWRuw60KxZllxaFlbsOtIG11c8OtIHphamlzdGl0IDIwNS4KCjUuIFBvxb5hZGF2a3kgbmEgcGVyc29uw6FsbsOtIHphYmV6cGXEjWVuw60gYSB0ZWNobmlja8OpIHphamnFoXTEm27DrSBQUE5QCgpQb8W+YWRhdmt5IG5hIHBlcnNvbsOhbG7DrSB6YWJlenBlxI1lbsOtIFBQTlAKdiByZcW+aW11IHJ5Y2hsw6kgemRyYXZvdG5pY2vDqSBwb21vY2kganNvdSBuw6FzaWVkdWrDrWPDrToKCjEuIHpkcmF2b3RuaWNrw70gesOhY2hyYW7DocWZIHpwxa9zb2JpbMO9IGsgdsO9a29udSBwb3ZvbMOhbsOtIGJleiBvZGJvcm7DqWhvIGRvaGxlZHUgbmVibyBzZXN0cmEgcHJvCmludGVueml2bsOtIHDDqcSNaSB6cMWvc29iaWzDoSBrIHbDvWtvbnUgcG92b2zDoW7DrSBiZXogb2Rib3Juw6lobyBkb2hsZWR1LAoKMi4gxZlpZGnEjSB2b3ppZGxhIHpkcmF2b3RuaWNrw6kgesOhY2hyYW5uw6kgc2x1xb5ieSBuZWJvIHpkcmF2b3RuaWNrw70gesOhY2hyYW7DocWZIGEKCjMuIGRvc3R1cG5vc3QgbMOpa2HFmWUgc2Ugc3BlY2lhbGl6b3Zhbm91IHpwxa9zb2JpbG9zdMOtLCB6dmzDocWhdG7DrSBvZGJvcm5vdSB6cMWvc29iaWxvc3TDrSBuZWJvIHp2bMOhxaF0bsOtCnNwZWNpYWxpem92YW5vdSB6cMWvc29iaWxvc3TDrSB2IG9ib3J1LCB2IG7Em23FviBqZSBwb3NreXRvdsOhbmEgcMOpxI1lIHBhY2llbnRvdmksIGt0ZXLDoSBqZSB6YWppxaF0xJtuYQp0ZWxlZm9uaWNreS4KCjQuIFYgcmXFvmltdSByeWNobMOpIGzDqWthxZlza8OpIHBvbW9jaWpzb3UgbsOhc2xlZHVqw61jw606Cgo1LiBsw6lrYcWZIHNlIHNwZWNpYWxpem92YW5vdSB6cMWvc29iaWxvc3TDrSwgenZsw6HFoXRuw60gb2Rib3Jub3UgenDFr3NvYmlsb3N0w60gbmVibyB6dmzDocWhdG7DrQpzcGVjaWFsaXpvdmFub3UgenDFr3NvYmlsb3N0w60gdiBvYm9ydSwgdiBuxJttxb4gamUgcG9za3l0b3bDoW5hIHDDqcSNZSBwYWNpZW50b3ZpLCBwxZnDrXRvbW7DvSB2ZQp2w71qZXpkb3bDqSBza3VwaW7EmyBixJtoZW0gdHJhbnNwb3J0dSwKCjYsIHpkcmF2b3RuaWNrw70gesOhY2hyYW7DocWZLCBzZXN0cmEgcHJvIGludGVueml2bsOtIHDDqcSNaSBuZWJvIHbFoWVvYmVjbsOhIHNlc3RyYSB6cMWvc29iaWzDoSBrIHbDvWtvbnUKcG92b2zDoW7DrSBiZXogb2Rib3Juw6lobyBkb2hsZWR1LCBwb3DFmS4gemRyYXZvdG5pY2vDvSBwcmFjb3ZubSB1dmVkZW7DvSB2w73FoWUgdiBww61zbS4gYSkgYm9kIDEsCgo3LiDFmWlkacSNIHZvemlkbGEgemRyYXZvdG5pY2vDqSB6w6FjaHJhbm7DqSBzbHXFvmJ5IG5lYm8gemRyYXZvdG5pY2vDvSB6w6FjaHJhbsOhxZkuCktOTCBzZSB6YXZhenVqZSBwxZllZGF0IFpaUyBMSwoKc2V6bmFtIHphbcSbc3RuYW5jxa8gemFqacWhxaV1asOtY8OtY2ggdHJhbnNwb3J0eSBQUE5QIHZlIMSNbGVuxJtuw60gbMOpa2HFmSwgemRyYXZvdG5pY2vDvSB6w6FjaHJhbsOhxZkgYSDFmWlkacSNCnZvemlkbGEgWlpTLCBhIHRvIGRvIGR2b3UgdMO9ZG7FryBvZCBwb2RwaXN1IHTDqXRvIHNtbG91dnksCgp2IGxpc3Rpbm7DqSDEjWkgZWxla3Ryb25pY2vDqSBwb2RvYsSbIGtvcGlpIGRva2xhZMWvIG8gZG9zYcW+ZW7DqSB6cMWvc29iaWxvc3RpIHphbcSbc3RuYW5jxa8gdXZlZGVuw71jaAp2IHNlem5hbXUgZGxlIHDDrXNtLiBhKSwgYSB0byBzcG9sZcSNbsSbIHMgdMOtbXRvIHNlem5hbWVtLAoKYWt0dWFsaXpvdmFuw70gc2V6bmFtIGRsZSBww61zbS4gYSkgc3BvbGXEjW7EmyBza29wacOtIHNvdXZpc2Vqw61jw61jaCBkb2tsYWTFryBkbGUgcMOtc20uIGIpIG5vdsSbCnphxZlhemVuw71jaCB6YW3Em3N0bmFuY8WvLCBkb2pkZS1saSBrZSB6bcSbbsSbIHYgcGVyc29uw6FsbsOtbSB6YWJlenBlxI1lbsOtIHRyYW5zcG9ydMWvIFBQTlAsIGEgdG8KbmVqcG96ZMSbamkgZHZhIHTDvWRueSBwxZllZCBqZWppY2ggemHFmWF6ZW7DrW0gayB2w71rb251IFBQTlAuLAoKWlpTIExLIHrFmcOtZMOtIHDFmcOtc3R1cHkgZG8gaW5mb3JtYcSNbsWZaG8gc3lzdMOpbXUgcHJvIHZlZGVuw60gemRyYXZvdG5pY2vDqSBkb2t1bWVudGFjZSBzb3V2aXNlasOtY8OtCnMgUFBOUCBwcm8gemFtxJtzdG5hbmNlIEtOTCB1dmVkZW7DqSBuYSBzZXpuYW11IHBvZGxlIG9kc3QuIDIgcMOtc20uIGEpIGEgYykgKGTDoWxlamVuIOKAnnNlem5hbeKAnCkKZG8gZHZvdSB0w71kbsWvIG9kIHDFmWVkw6Fuw61zZXpuYW11IGRvcGxuxJtuw6lobyBkb2tsYWR5IGRsZSBww61zbS4gYikuCgpQcmFjb3ZpxaF0xJsgS05MIHBybyBrb211bmlrYWNpIHNlIHpkcmF2b3RuaWNrw71tIG9wZXJhxI1uw61tIHN0xZllZGlza2VtIHBvc2t5dG92YXRlbGUgWlpTLCBzIGRhbMWhw61taQpwb3NreXRvdmF0ZWxpIHpkcmF2b3Ruw61jaCBzbHXFvmViIGEgdmxhc3Ruw61taSBkb3ByYXZuw61taSBwcm9zdMWZZWRreSBwxZlpcG9qZW7DqSBrIHBldm7DqSB0ZWxlZm9ubsOtIHPDrXRpCmxpbmtvdSDEjS4gayBtb2JpbG7DrXRlbGVmb25uw61zw610aSBsaW5rb3UgxI0uIChkaXNwZcSNaW5rKSwgcG9wxZkuCih6w6FjaHJhbsOhxZkpLCB6YWppxaHFpXVqw61jw60gcmFkaW92w6kgc3BvamVuw61zIHZsYXN0bsOtbWkgZG9wcmF2bsOtbWkgcHJvc3TFmWVka3kgcyB2eXXFvml0w61tIHZvbGFjw60gem5hxI1reQoKYSB2eWJhdmVuw6kgbmFocsOhdmFjw61tIHphxZnDrXplbsOtbSByw6FkaW92w71jaCBhIHRlbGVmb25uw61jaCByZWxhY8OtIHMgxI1hc292w71tIMO6ZGFqZW0gJiBkYWzFocOtbQp2eWJhdmVuw61tIGRsZSBwxZnDrWxvaHkgxI0uIDggdnlobMOhxaFreSDEjS4gOTIvMjAxMiBTYi4gc2UgbmFjaMOhesOtIG5hIGFkcmVzZSBKYWJsb25lY2vDoSAxMzQ0LzE0LAo0NjAgMDEgTGliZXJlYy4KCjYuIERhbMWhw60gdWplZG7DoW7DrSBvIHNwb2x1cHLDoWNpIHDFmWkgemFqacWhxaVvdsOhbsOtIFBQTlAKKDEpIEtOTCBzZSB6YXZhenVqZSBwbG5pdCB6w6F2YXpreSBwbHlub3Vjw60geiB0w6l0byBzbWxvdXZ5LCB6ZWptLiB6YWppxaHFpW92YXQgdsO9a29ueSBQUE5QIGluZGlrb3ZhbsOhCnpkcmF2b3RuaWNrw71tIHphxZnDrXplbsOtbSBsxa/FvmtvdsOpIHDDqcSNZSBuYSDDunplbcOtIExpYmVyZWNrw6lobyBrcmFqZSwgb2RrdWQgbmVibyBrYW0gbcOhIGLDvXQKCnBhY2llbnQgdHJhbnNwb3J0b3bDoW4gKGTDoWxlIGplbiDigJ5vZGVzw61sYWrDrWPFmScgYSDigJ5jbm92w6kgemHFmcOtemVuxZknKSwgYSB0byB2w71ocmFkbsSbIG5hIHrDoWtsYWTEmyBwb2t5bnUKcMWZZWRhbsOpaG8gWk9TIGRpc3BlxI1pbmt1IEtOTC4gS05MIHNlIGTDoWxlIHphdmF6dWplIHByb3N0xZllZG5pY3R2w61tIGRpc3BlxI1pbmt1IEtOTCBpbmZvcm1vdmF0CgogCgpneW07CgphKQoKXSkKClNNTE9VVkEgbyBTUE9MVVBSw4FDSQoKMjA1IG8gxI1pbm5vc3RpIHN2w6kgcG9zw6Fka3kgUFBOUCBuYSDDunplbcOtIExpYmVyZWNrw6lobyBrcmFqZSwgemVqbS4gbyBkb3Nhxb5lbsOtb2Rlc8OtbGFqw61jw61obyBuZWJvCmPDrWxvdsOpaG8gemHFmcOtemVuw61hIG8gdWtvbsSNZW7DrXRyYW5zcG9ydHUgcMWZZWTDoW7DrW0gcGFjaWVudGEsIHYgcMWZw61wYWTEmyB2w71rb27FryBQUE5QIGluZGlrb3ZhbsO9Y2gKemRyYXZvdG5pY2vDvW0gemHFmcOtemVuw61tIGzFr8W+a292w6kgcMOpxI1lIG1pbW8gw7p6ZW3DrSBMaWJlcmVja8OpaG8ga3JhamUuCgpWIHDFmcOtcGFkxJssIMW+ZSBLTkwgbmVidWRlIHNjaG9wbmEgemFqaXN0aXQgbmFwbG7Em27DrXbDvXp2eSBwxZllZGFuw6kgb2QgMjA1IHogcHJvdm96bsOtY2ggxI1pIGthcGFjaXRuw61jaApkxa92b2TFrywgemF2YXp1amUgc2UgcG9za3l0b3ZhdGVsIHbDvXp2dSBuZXDFmWlqbW91dCwgYSB0byBixJtoZW0gdGVsZWZvbmlja8OpaG8gaG92b3J1LCBrdGVyw71tIFpPUwpwxZllZMOhdsOhIHbDvXp2dSBkaXNwZcSNaW5rdSBLTkwKClNwb2plbsOtIG1lemkgMjA4IGEgZGlzcGXEjWlua2VtIEtOTCAmIG1lemkgMjA4IGEgcG9zw6Fka2FtaSBQUE5QIGJ1ZGUgcHJvYsOtaGF0IHByb3N0xZllZG5pY3R2w61tCkdTTSB0ZWxlZm9udSBzZSB6w6F6bmFtZW0gaG92b3J1IG5hIHN0cmFuxJsgWk9TLgoKS05MIHNlIHphdmF6dWplIGluZm9ybW92YXQgMjA4IG8gcG96aWNpLCB0cmFzZSBhIHDFmWlibGnFvm7DqW0gxI1hc292w6ltIHLDoW1jaSBwb2h5YnUgYWtjZXNjaG9wbsOpCnBvc8OhZGt5IFBQTlAsIHBvcMWZLiBwb3PDoWRlaywgbmEgw7p6ZW3DrSBMaWJlcmVja8OpaG8ga3JhamUsIGEgdG8gbmVqcG96ZMSbamkgcMWZZWQgemFow6FqZW7DrW0gasOtemR5Cm5ldnl0w63FvmVuw6EgcG9zw6Fka3kgenDEm3QuCgpLTkwgc2UgemF2YXp1amUgc3Bsbml0IHBva3luIG9wZXLDoXRvcmEgWk9TIGsgcmVhbGl6YWNpIHRyYW5zcG9ydHUsIGEgdG8gemFow6FqZW7DrW0gcmVhbGl6YWNlCnRyYW5zcG9ydHUgZG8gNjAgbWludXQgb2QgcMWZZWTDoW7DrSBwb2t5bnUgZGlzcGXEjWlua3UgS05MLCBuZW7DreKAlEnDrSBvcGVyw6F0b3JlbSBaT1MgdXLEjWVubyB6YWjDoWplbsOtCnJlYWxpemFjZSB0cmFuc3BvcnR1IHYgZGVsxaHDrW0gxI1hc292w6ltIG9kc3R1cHUuCgpTbWx1dm7DrXN0cmFueSBuZXBvdmHFvnVqw616YSBwb3J1xaFlbsOtesOhdmF6a8O6IGEgcG92aW5ub3N0w60sIGRvamRlZWxpIGsgbmVzcGxuxJtuw60gcG9reW51IGsgcmVhbGl6YWNpClBQTlAgbmEgesOha2xhZMSbIG1pbW/FmcOhZG7DvWNoIGEgbmVuYWTDoWzDvWNoIHVkw6Fsb3N0w60sIGt0ZXLDqSB2em5pa2Fqw60gbmV6w6F2aXNsZSBuYSB2xa9saSDEjWxvdsSba2EgYSBuZW7DrQptb8W+bsOpIGplIMW+w6FkbsO9bSB6cMWvc29iZW0gb3ZsaXZuaXQgKG5hcMWZLiBwb3J1Y2hhIHZvemlkbGEsIGRvcHJhdm7DrSBuZWhvZGEsIG1ldGVvcm9sb2dpY2vDqQpwb2Rtw61ua3ksIG9ocm/FvmVuw60gcG9zw6Fka3ksIHZpcyBtYWpvciBhai4pLgoKUG92aW5ub3N0w60gS05MamUgbmVwcm9kbGVuxJsKCjEuIGluZm9ybW92YXQgWk9TIG8gdnpuaWt1IHVkw6Fsb3N0aSB1dmVkZW7DqSB2IHDDrXNtZW51IGUpOwoKMi4gcG9za3l0bm91dCB2ZcWha2Vyb3UgbW/Fvm5vdSBzb3XEjWlubm9zdCBrZSB6bcOtcm7Em27DrSBkb3BhZMWvIHRha292w6kgdWTDoWxvc3RpIG5hIGRvc3R1cG5vc3QgYQpwbHludWxvc3QgcMWZaSBwb3NreXRvdsOhbsOtIHpkcmF2b3Ruw61jaCBzbHXFvmViIHBvc2t5dG92YXRlbGVtIFpaUyBMSywgemVqbS4gemRyYXZvdG5pY2vDqQp6w6FjaHJhbm7DqSBzbHXFvmJ5IGEgUFBOUDsKCjMuIHNlIHYgcMWZaW3Em8WZZW7DqW0gcm96c2FodSBwb2TDrWxldCBuYSB6YWppxaF0xJtuw60gbsOhaHJhZG7DrWNoIMWZZcWhZW7DrSBrIHphamnFoXTEm27DrSByZWFsaXphY2UgdHJhbnNwb3J0xa8KUFBOUCBkb3TEjWVuw71jaCB1ZMOhbG9zdMOtIHV2ZWRlbm91IHYgcMOtc21lbnUgZSkuCgpWIHDFmcOtcGFkxJsgcG9ydcWhZW7DrXTEm2NodG8gcG92aW5ub3N0w60gb2Rwb3bDrWTDoSBLTkwgemEgdnpuaWtsb3UgxaFrb2R1LgoKU21sdXZuw60gc3RyYW55IHByb2hsYcWhdWrDrSwgxb5lIHZlxaFrZXLDqSB0ZWxlZm9uaWNrw6kgaG92b3J5IDIwNSDEjWkgZGlzcGXEjWlua3UganNvdSBtb25pdG9yb3bDoW55IGEgamUgegpuaWNoIHBvxZlpem92w6FuIHrDoXpuYW0sIGNvxb4gdnrDoWplbW7EmyBiZXJvdSBuYSB2xJtkb23DrWEgc291aGxhc8OtcyBtb25pdG9yaW5nZW0gdnrDoWplbW7DvWNoIGhvdm9yxa8KYSBwb8WZaXpvdsOhbsOtbSB6w6F6bmFtxa8geiB0xJtjaHRvIGhvdm9yxa8uCgpLTkwgcMWZZWTDoSBaWlMgTEsgam1lbm7DvSBzZXpuYW0gb3NvYiBzIGRvbG/FvmVuw61tIG9kYm9ybsOpIHpwxa9zb2JpbG9zdGkgcHJvIHbDvWtvbiB0cmFuc3BvcnTFrwp2cmXFvsOtbXUgUFBOUCB2c291bGFkdSBzVnlobMOhxaFrb3UgOTkvMjAxMiBTYi4gbyBwb8W+YWRhdmPDrWNoIG5hIG1pbmltw6FsbsOtIHBlcnNvbsOhbG7DrQp6YWJlenBlxI1lbsOtemRyYXZvdG7DrWNoIHNsdcW+ZWIsIGt0ZXLDqSBzZSBidWRvdSBwb2TDrWxldCBuYSBwxZllcHJhdsSbIHBhY2llbnTFryBuZW9ka2xhZG7DqSBww6nEjWUsIGEKc291xI1hc27EmyBzcGVjaWZpa2FjaSB2b3ppZGVsIHVyxI1lbsO9Y2ggayBwxZllcHJhdsSbIHBhY2llbnTFryBuZW9ka2xhZG7DqSBww6nEjWUgZGxlIHTDqXRvIHNtbG91dnkuCgpaWlMgTEsgemFqaXN0w60gcMWZw61zdHVweSBkbyBwcm9ncmFtdSBFS1AgcHJvIHByYWNvdm7DrWt5IEtOTCB2IHJlxb5pbXUgUFBOUC4gTW9iaWxuw610YWJsZXQgYnVkZQpwxZllZMOhbiBvcHJvdGkgcG9kcGlzdSBwxZllZMOhdmFjw61obyBwcm90b2tvbHUgdmVkb3Vjw61tdSBkb3ByYXZ5IEtOTCBkbyAxIG3Em3PDrWNlIG9kIGRvbG/FvmVuw612xaFlY2gKdsO9xaFlIHV2ZWRlbsO9Y2ggbsOhbGXFvsOtdG9zdMOtc291dmlzZWrDrWPDrWNoIHMga3ZhbGlmaWthY8Otb3NvYiBwb2TDrWxlasOtY8OtY2ggc2UgbmEgUFBOIFAuCgpTbWx1dm7DrXN0cmFueSB2esOhamVtbsSbIHpvZHBvdsOtZGFqw616YSB6YWNob3bDoW7DrSBtbMSNZW5saXZvc3RpICYgb2NocmFueSBvc29ibsOtY2ggw7pkYWrFryBzb3V2aXNlasOtY8OtCnN2w71rb25lbSBzbWx1dm7EmyB1amVkbmFuw71jaCDEjWlubm9zdMOtIGEgdmXFoWtlcsO9Y2ggc2t1dGXEjW5vc3TDrSwga3RlcsOpIHNvdXZpc8OtIHNlIHZ6w6FqZW1ub3UKc3BvbHVwcmFjw60uCgpQb23Em3IgdHJhbnNwb3J0xa8gUFBOUCByZWFsaXpvdmFuw71jaCB2w71qZXpkb3bDvW3DrSBza3VwaW5hbWkgWlpTIExLIGEgcMWZZWRhbsO9Y2ggayByZWFsaXphY2kgamluw71tCnBvc2t5dG92YXRlbMWvbSwgdsSNLiBLTkwsIGplIGTDoW4gYWt0dcOhbG7DrXNpdHVhY8OtdiBvcGVyYcSNbsOtbSDFmcOtemVuw61tIFpaUyBhIFBQTlAgbmEgw7p6ZW3DrSBrcmFqZS4KClRyYW5zcG9ueSByZWFsaXpvdmFuw6kgemUgemRyYXZvdG5pY2vDvWNoIHphxZnDrXplbsOtIEtyYWpza8OpIG5lbW9jbmljZSBMaWJlcmVjIChOZW1vY25pY2UgTGliZXJlYywKTmVtb2NuaWNlIFR1cm5vdiwgTmVtb2NuaWNlIEZyw71kbGFudCksIHDFmcOtcGFkbsSbIGRvIHpkcmF2b3RuaWNrw71jaCB6YcWZw616ZW7DrSBLcmFqc2vDqSBuZW1vY25pY2UKTGliZXJlYyBidWRvdSBwcmltw6FybsSbIHJlYWxpem92w6FueSBwb3PDoWRrb3UgS05MLCBwb2t1ZCBuZWJ1ZGUgdnl0w63FvmVuYSBqaW7DvW0gdsO9amV6ZGVtLgoKWiBwb2hsZWR1IMSNYXNvdsOpIG5hbMOpaGF2b3N0aSBuYSB6YWjDoWplbsOtIHJlYWxpemFjZSB0cmFuc3BvcnR1IG9kIHDFmcWvbXUgcG/FvmFkYXZrdSBaT1Mgc2UgenByYXZpZGxhCnJvemxpxaF1asOtdHJhbnNwb3J0eToKCjEuIG9ka2xhZG7DqSxqZWrDrWNoxb4gemFow6FqZW7DrSBsemUgb2Rsb8W+aXQgdsOtY2UgbmXFviA2MCBtaW4uIG9kIHDFmWlqZXTDrSBwb8W+YWRhdmt1OwoKIAoK4oCeJ2UvMTA7CgpTTUxPVVZBIG8gU1BPTFVQUsOBQ0kKCjIuIGFrdXRuw60sIGplamljaMW+IHphaMOhamVuw61qZSBwb8W+YWRvdsOhbm8gZG8gNjAgbWluLiBvZCBwxZlpamV0w60gcG/FvmFkYXZrdTsKCjMuIG5lb2RrbGFkbsOpLCBqZWppY2jFviB6YWjDoWplbsOtamUgcG/FvmFkb3bDoW5vIGRvIDIwIG1pbi4gb2QgcMWZaWpldMOtIHBvxb5hZGF2a3UuCgpaYWjDoWplbsOtbSByZWFsaXphY2UgdHJhbnNwb3J0dSBzZSByb3p1bcOtZG9zYcW+ZW7DrW9kZXPDrWxhasOtY8OtaG8gemRyYXZvdG5pY2vDqWhvIHphxZnDrXplbsOtcG9zw6Fka291IFBQTlAuCgpuKQoKUykKClYgcsOhbWNpIHNwb2x1cHLDoWNlIHVyxI1lbsOpIHRvdXRvIHNtbG91dm91IHNlIGRpc3BlxI1pbmt1IEtOTCBwxZllZMOhdmFqw60gcMWZZWRldsWhw61tIHBvxb5hZGF2a3kgbmEKcmVhbGl6YWNpIHRyYW5zcG9ydMWvIG9ka2xhZG7DvWNoIGEgYWt1dG7DrWNoLCB2w71qaW1lxI1uxJsgaSB0cmFuc3BvcnTFryBuZW9ka2xhZG7DvWNoLCBrdGVyw6kgc2UgWnByYXZpZGxhCnJlYWxpenVqbCB2w71rb25lbSB6ZHJhdm90bmlja8OpIHrDoWNocmFubsOpIHNsdcW+YnkuIFMgcG9reW5lbSBrIHJlYWxpemFjaSB0cmFuc3BvcnR1IHDFmWVkw6F2w6EKZGlzcGXEjWlua3UgS05MIG9wZXLDoXRvciAyMDg6CgoxLiDDumRhamUgbyDEjWFzb3bDqSBuYWzDqWhhdm9zdGkgdHJhbnNwb3J0dSBhIHUgb2RrbGFkbsO9Y2ggdHJhbnNwb3J0xa8gdGFrw6kgcG/FvmFkYXZlayBuYSDEjWFzCnphaMOhamVuw610cmFuc3BvcnR1OwoKMi4gw7pkYWplIG8gcGFjaWVudG92aSwgbWluaW3DoWxuxJsgdiByb3pzYWh1IGptw6lubyBhIHDFmcWvbWVuw60sIHbEm2sgYSB6w6FrbGFkbsOtIGRpYWduw7N6YTsKCjMuIHBvxb5hZGF2a3kgbmEgcGVyc29uw6FsbsOtYSB0ZWNobmlja8OpIHphamnFoXTEm27DrXRyYW5zcG9ydHUgKHDFmcOtdG9tbm9zdCBsw6lrYcWZZSwgdnliYXZlbsOtIHBvc8OhZGt5CmFwb2QuKTsKCjQuIMO6ZGFqZSBvIG9kZXPDrWxhasOtY8OtbSBhIGPDrWxvdsOpbSB6ZHJhdm90bmlja8OpbSB6YcWZw616ZW7DrSAobsOhemV2IHBvc2t5dG92YXRlbGUsIGFkcmVzYQp6ZHJhdm90bmlja8OpaG8gemHFmcOtemVuw60sIG9kZMSbbGVuw60sIHN0YW5pY2UgYXBvZC4pOwoKNS4gZGFsxaHDrSDDumRhamUgcG9kc3RhdG7DqSBwcm8gcmVhbGl6YWNpIHRyYW5zcG9ydHUsIG5hcMWZLiBobW90bm9zdCBwYWNpZW50YSBwxZllc2FodWrDrWPDrSAxNDAga2csCnBvdMWZZWJhIHp2w73FoWVuw6kgb2NocmFueSBwb3PDoWRreSBwxZllZCBiaW9sb2dpY2vDvW0gcml6aWtlbSBhcG9kLgoKWlpTIExLIG5lb2Rwb3bDrWTDoSB6YSBwxZnDrXBhZG7DqSBuw6FtaXRreSBwbMOhdGPFryB2c291dmlzbG9zdGkgcyDDumhyYWRvdSBwb3NreXRudXTDvWNoIHpkcmF2b3Ruw61jaApzbHXFvmViIHogcHJvc3TFmWVka8WvIHZlxZllam7DqWhvIHpkcmF2b3RuxZlobyBwb2ppxaF0xJtuw60gdsWvxI1pIHRyYW5zcG9ydMWvbSByZWFsaXpvdmFuw71tIEtOTCBkbGUgdMOpdG8Kc21sb3V2eSB6IGTFr3ZvZMWvIHBvY2h5Ym5vc3RpIG8gZG9kcsW+ZW7DrSBwcmF2aWRlbCBob3Nwb2TDoXJub3N0aSBwxZlpIHJlYWxpemFjaSB0cmFuc3BvcnR1IFBQTlAKcG9za3l0b3ZhdGVsZW0gS05MCgpQb3NreXRudXTDrSBzb3XEjWlubm9zdGkgZHJ1aMOpIHNtbHV2bsOtIHN0cmFuxJssIHplam0uIHZ5dMSbxb5vdsOhbmwgZHJ1aMOpIHNtbHV2bsOtIHN0cmFueSBramluw71tIMO6xI1lbMWvbSwKbmXFvmplIHNqZWRuw6FubyB2IHTDqXRvIHNtbG91dsSbLCBuZXNtw60gdsOpc3QgayBuYXJ1xaFlbsOtIHNhbW9zdGF0bsOpaG8gcG9za3l0b3bDoW7DrSB6ZHJhdm90bsOtY2ggc2x1xb5lYgpqZWRub3RsaXbDvW1pIHNtbHV2bmxtaSBzdHJhbmFtaTsgemFqacWhdMSbbsOtIGRvc3R1cG5vc3RpIHpkcmF2b3RuaWNrw6kgesOhY2hyYW5uw6kgc2x1xb5ieSBuYSDDunplbcOtCkxpYmVyZWNrw6lobyBrcmFqZSBqZSBwcmlvcml0bsOtLgoKS29udGFrdG7DrW1pIMO6ZGFqaSBLTkwgcHJvIHBvdMWZZWJ5IHTDqXRvIHNtbG91dnlqc291IMO6ZGFqZSB1dmVkZW7DqSB2IGthcC4gMSwgYSBkw6FsZToKCjEuIGRpc3BlxI1pbms6IGRpc3BlxI1pbmtqZSBwcm92b3pvdsOhbiBuZXDFmWV0csW+aXTEmzsKCjIuIHRlbC46IGXigJRtYWlsOiB2ZSB2xJtjZWNoCnRlY2huaWNrw71jaDsKCjMuIHRlbC46IGXigJRtYWlsOiB2ZSB2xJtjZWNoIHNtbHV2bsOtY2g7Cgo0LiB2b2xhY8Otem5hazoKS29udGFrdG7DrW1pIMO6ZGFqaSBaWlMgTEsgcHJvIHBvdMWZZWJ5IHTDqXRvIHNtbG91dnlqc291IMO6ZGFqZSB1dmVkZW7DqSB2IGthcC4gMS4gYSBkw6FsZToKCjEuIDIyOCBMSywgemRyYXZvdG5pY2vDqSBvcGVyYcSNbsOtIHN0xZllZGlza28sIEtsw6HFoXRlcm7DrSA5NTQvNSwgTGliZXJlYyBJLVN0YXLDqSBNxJtzdG8sIDQ2MCAwMQoKTGliZXJlYywgcMWZxa9lbSBwb8W+YWRhdmvFryBuYSByZWFsaXphY2kgdHJhbnNwb3J0xa8gUFBOUCBuYSB0ZWwuIMSNw61zbGVjaCAmCmXigJRtYWlsOiB2b2xhY8OtIHpuYWsgMjA4IGplIHByb3Zvem92w6FubwpuZXDFmWV0csW+aXTEmzsKMi4gdmVkb3Vjw60gb3BlcsOhdG9yIFpPUyBaWlMgTEssIHRlbC4gR1NNCmUtbWFpbDoKMy4gdmVkb3Vjw60gZG9wcmF2eSBaWlMgTEssIHRlbC4gZcK7bWFpbDoKCnZlIHbEm2NlY2ggdMO9a2Fqw61jw61jaCBzZSB2b3ppZGVsIHVyxI1lbsO9Y2ggcHJvIHBvc2t5dG92w6Fuw60gUFBOUDsKNC4gc3RhdHV0w6FybsOtIHrDoXN0dXBjZSBaWlMgTEsgdmUgdsSbY2VjaCBzbWx1dm7DrWNoLgoKNS4gVmXFoWtlcsOpIHptxJtueSBrb250YWt0bsOtY2ggw7pkYWrFryBqZSBzbWx1dm7DrSBzdHJhbmEsIGrDrcW+IHNlIHptxJtuYSB0w71rw6EsIHBvdmlubmEgb3puw6FtaXQKcMOtc2VtbsSbIGRydWjDqSBzbWx1dm7DrXN0cmFuxJsgcyB0w61tLCDFvWUgem3Em25hIGtvbnRha3Ruw61jaCDDumRhasWvIG5hYsO9dsOhIMO6xI1pbm5vc3RpIHZlIHZ6dGFodSBrCmRydWjDqSBzbWx1dm7DrXN0cmFuxJsgZG9ydcSNZW7DrW0gdG9ob3RvIG96bsOhbWVuw60uCgpaWlMgTEsgc2UgemF2YXp1amUgemFwbGF0aXQgcG9za3l0b3ZhdGVsaSB6IGthxb5kw6kgZmFrdHVyb3ZhbsOhIMSNw6FzdGt5IHplIHN0cmFueSBLTkwgOTQgJSB0YWt0bwoKJyA3LzEw4oCcCgogCgpcIEkKCiAKCmEpCgpiKQoKU01MT1VWQSBvIFNQT0xVUFLDgUNJCgpvcHLDoXZuxJtuxJsgZmFrdHVyb3ZhbsOhIMSNw6FzdGt5LiBaYsO9dmFqw61jw61jaCA2ICUgZmFrdHVyb3ZhbsOhIMSNw6FzdGt5IHNpIHBvbmVjaMOhIFpaUyBMSyBqYWtvxb50bwpuw6FocmFkdSB6YSBwcm92b3puw61hIHJlxb5pam7DrSBuw6FrbGFkeSB2IHNvdXZpc2xvc3RpIHNlIHNwb2x1cHJhY8OtIGRsZSB0w6l0byBzbWxvdXZ5Ll82JSBzcsOhxb5rYSBidWRlCnV2ZWRlbmEgamnFviBuYSBmYWt0dcWZZSB2eXN0YXZlbsOpIEtOTC4KCk5hIHrDoWtsYWTEmyByZWFsaXpvdmFuw6kgw7pocmFkeSBvZCBwb2ppxaHFpW92ZW4sIGJ1ZGUgS05MIHZ5enbDoW5hIGsgdnlzdGF2ZW7DrWZla3R1cnksIHpwcmF2aWRsYWplZG5vdQptxJtzw63EjW7Emy4KClBvc2t5dG92YXRlbCBzZSB2IHTDqXRvIHNvdXZpc2xvc3RpIHphdmF6dWplIHYga2HFvmTDqW0gamVkbm90bGl2w6ltIHDFmcOtcGFkxJsgcMWZZXByYXZ5IHBhY2llbnTFrwpuZW9ka2xhZG7DqSBww6nEjWUgxZnDoWRuxJsgdnlwbG5pdCBaw6F6bmFtIG8gdsO9amV6ZHUsIGEgdG8gdiBJUyBaWlMgTEsgKE1aRC9FS1ApIGEgamVkbm91IHTDvWRuxJsKcMWZZWTDoXZhdGplZG5vIHZ5aG90b3ZlbsOtdG9ob3RvIHrDoXpuYW11IHYgbGlzdGlubsOpIHBvZG9ixJsgcyBwb3R2cnplbsOtbSBjw61sb3bDqWhvIHBvc2t5dG92YXRlbGUgbwpwxZlldnpldMOtIHBhY2llbnRhIGRvcGxuxJtuw6kgMCBrb3BpZSBkYWzFocOtIHpkcmF2LiBkb2suLCBhIGTDoWxlIFDFmMONS0FaIEtFIFpEUkFWT1ROw41NVSBUUkFOU1BPUlRVCnZlIGR2b3Ugdnlob3RvdmVuw61jaCwgeiBuaWNoxb4gYWxlc3BvxYggamVkbm9qZSBvcmlnaW7DoWwuCgpEZXRhaWxuw61taSBwb2Rtw61ua2FtaSBzZSByb3p1bcOtIHplam3DqW5hIGtvbmtyw6l0bsOtIHRlY2huaWNrw6kgcG9kbcOtbmt5IGtvbXVuaWthY2UgbWV6aQpwb3NreXRvdmF0ZWxlbSBhIFpaUyBMSywgcG9kbcOtbmt5IGV2aWRlbmNlIGplZG5vdGxpdsO9Y2ggdsO9a29uxa8gcMWZZXByYXZ5IHBhY2llbnTFryBuZW9ka2xhZG7DqQpww6nEjWUgYSBwb2Rtw61ua3kgcMWZw61wcmF2eSB2ecO6xI10b3bDoW7DrSBwb3NreXRudXTDvWNoIHNsdcW+ZWIuCgpLTkwgc2UgemF2YXp1amUgb2JqZWRuw6F2YXQgdHJhbnNwb3J0eSBwcmltw6FybsSbIGRvIDE1LjAwLCBwb2t1ZCB0byB2ZcWha2Vyw6kgZGFsxaHDrSBva29sbm9zdMOtCnMgb2hsZWRlbSBuYSB6ZHJhdm90bsOtc3RhdiBwYWNpZW50YSBhIGRvc3R1cG5vc3Qgc291dmlzZWrDrWPDrWNoIHpkcmF2b3Ruw61jaCBzbHXFvmViIGRvdm9sdWrDrS4KCjcuIFNwb2x1cHLDoWNlIHDFmWkgemFqacWhdMSbbsOtdHJhbnNwb3J0dSBwYWNpZW50xa8gdiByZcW+aW11IHpkcmF2b3RuaWNrw6kgZG9wcmF2bsOtc2x1xb5ieSAoWkRTKQoKWlpTIExLIHByb3N0xZllZG5pY3R2w61tIGRpc3BlxI1lcsWvIFpPUyB6b2Rwb3bDrWTDoSB6YSBzcHLDoXZub3UgaW5kaWthY2kgcG90xZllYnkgdHJhbnNwb3J0dSB2IHJlxb5pbXUKWkRTIChkxZnDrXZlIHpuw6Ftb2pha28gZG9wcmF2YSByYW7Em27DvWNoLCBuZW1vY27DvWNoIGEgcm9kacSNZWspLgoKWk9TIFpaUyBMSyBuYSB6w6FrbGFkxJsgaW5mb3JtYWPDrSBvZCBLTkwgKGRvcHJhdmNlKSBwcm92w6Fkw60gb2Rwb3bDrWRhasOtY8OtIG9wYXTFmWVuw612IHDFmcOtcGFkZWNoLCBrZHkKc2UgZGlhZ27Ds3phIHYgcHLFr2LEm2h1IHDFr3NvYm5vc3RpIGRvcHJhdmNlIHptxJtuw60uIG5hcMWZLiB2eXNsw6Fuw61tIHbDvWplemRvdsOpIHNrdXBpbnkgWlpTIExLCgpQb3Zpbm5vc3RpIEtOTCAoZG9wcmF2Y2UpOgoKMS4gUG8gY2Vsb3UgZG9idSBwbGF0bm9zdGkgdMOpdG8gc21sb3V2eSBwcm92b3pvdmF0IERpc3BlxI1pbmsgcyBuZXDFmWV0csW+aXRvdSAyNGhvZGlub3ZvdSBzbHXFvmJvdQo6OyBtb8W+bm9zdMOtc3BvamVuw61uYSBtw61uaW3DoWxuxJtqZWRub20gbW9iaWxuw61tIHRlbGVmb251IGFqZWRuw6kgcGV2bsOpIGxpbmNlLgoKMi4gRMOtc3Bvbm92YXQgdm96b3bDvW0gcGFya2VtIChzYW5pdGFtw60pIGtvbnN0cnVvdmFuw71tIGEgdnliYXZlbsO9bSB2IHNvdWxhZHUgcyDEjWwuIDMuMy4xIMSMU04KRU4gMTc4OStBMSBwcm8gcMWZZXZveiB0xJtjaCBwYWNpZW50xa8sIHUga3RlcsO9Y2ggc2UgbmVwxZllZHBva2zDoWTDoSwgxb5lIGJ5IHNlIHN0YWxpIHBhY2llbnR5CnYgb2hyb8W+ZW7DrSDFvml2b3RhICh0eXAgQTEsIHJlc3AuIEEyKS4KCjMuIFphamlzdGl0IG5lcMWZZXRyxb5pdMO9IHByb3ZveiBqZWRub2hvIHNhbml0bsOtaG8gdm96aWRsYSBzIHBvc8OhZGtvdSBqZWRub2hvIMWZaWRpxI1lIFpEUyBzIMSNYXNlbQpwxZlpc3RhdmVuw60gbmEgbcOtc3RvIHVyxI1lbsOtZGxlIHBvxb5hZGF2a3UgWk9TIFpaUyBMSyBkbyA2MCBtaW51dCBvZCBwxZllZMOhbsOtIHbDvXp2eS4KCjQuIFphamlzdGl0IHBvaG90b3Zvc3Ruw60gcHJvdm96IGRydWjDqWhvIHNhbml0bsOtaG8gdm96aWRsYSBzIHBvc8OhZGtvdSBqZWRub2hvIMWZaWRpxI1lIFpEUwpzIGRvc3R1cG5vc3TDrWRvIDYwIG1pbnV0IG9kIHDFmWV2emV0w60gcG/FvmFkYXZrdSBvZCAyMDUgWlpTIExLLgoKNS4gViBwxZnDrXBhZMSbIHRyYW5zcG9ydHUgcGFjaWVudGEgcyBobW90bm9zdMOtbmFkIDE0MCBrZyByZcW+aW11IFpEUyB6YWppc3TDrSBLTkx0cmFuc3BvcnQgc2FuaXRuw61tCnZvemlkbGVtIHNvZHBvdsOtZGFqw61jw60gdsO9YmF2b3UgYSB6YWJlenBlxI3DrWplaiBkdm91cG9zw6Fka291LCBidWRl4oCUSWkgdHJhbnNwb3J0IG9iamVkbsOhbgphbGVzcG/FiCAxMiBob2RpbiBwxZllZGVtLgoKYykgVHJhbnNwb3J0eSByZWFsaXpvdmFuw6kgZG8gemRyYXZvdG5pY2vDvWNoIHphxZnDrXplbsOtIEtyYWpza8OpIG5lbW9jbsOtY2UgTGliZXJlYyAoTmVtb2NuaWNlIExpYmVyZWMsCgpOZW1vY25pY2UgVHVybm92LCBOZW1vY25pY2UgRnLDvWRsYW50KSBidWRvdSBwcmltw6FybsSbIHJlYWxpem92w6FueSBwb3PDoWRrb3UgS05MLCBwb2t1ZCBuZWJ1ZGUKdnl0w63FvmVuYWrDrW7DvW0gdsO9amV6ZGVtLgoKOC4gUG9za3l0b3bDoW7DrSAyMjUgdiBhcmXDoWx1IEtOTAoKViBwxZnDrXBhZMSbIGtyYWpuw60gbm91emUgKHbFoWVjaG55IG1lZGljw61uc2vDqSB0w71teSBwb3NreXR1asOtIG5lb2RrbGFkbm91IHDDqcSNw60gdiByw6FtY2kgYXJlw6FsdSBLTkwsIG3Fr8W+ZQpvZHBvdsSbZG7DvSBsw6lrYcWZIG9kZMSbbGVuw61DQVJsTSBwb8W+w6FkYXQgWk9TIFpaUyBMSyBvIHNvdcSNaW5ub3N0IHDFmWkgcG9za3l0b3bDoW7DrSBuZW9ka2xhZG7DqSBww6nEjWUgYQpLUFIgbmEgcHJhY292acWhdMOtY2ggYSB2IGFyZcOhbHUgS05MOyBaWlMgTEsgbmVnYXJhbnR1amUsIMW+ZSBidWRlIGFrdHXDoWxuxJsgZGlzcG9ub3ZhdCB2aG9kbm91CnbDvWplemRvdm91IHNrdXBpbm91LCBwb3DFmS4gc2t1cGluYW1pLCBhIGplIHTFmWViYSBwb8SNw610YXQgcyBtb8W+bm9zdMOtLCDFvmUgYnVkZSBudXRuw6kgdnlzbGF0IGRydWhvc2xlZG92b3UKVlMgWlpTIExLIChuYXDFmS4geiBKYWJsb25jZSBuLiBOaXMpIHMgb2Rwb3bDrWRhasOtY8OtbSBkb2plemRlbSBuYSBtw61zdG8gdWTDoWxvc3RpLgoKIAoKIAoKU01MT1VWQSBvIFNQT0xVUFLDgUNJCgpaWlMgTEsgbmVyZWFsaXp1amUgcMWZZXZvenkgcGFjaWVudMWvIHYgcsOhbWNpIGFyZcOhbHUgS05MIChuYXDFmS4gMiBuZWJvIG5hIG9wZXJhxI1uw60gc8OhbCwga3Z5xaFldMWZZW7DrSwKayBob3NwaXRhbGl6YWNpIG5hIGppbsOpbSBvZGQgYXBvZC4sIHZ5am1hIHBhY2llbnTFrywga3RlcsO9bSBieWxhIHbDvWplemRvdsO9bcOtIHNrdXBpbmFtaSBaWlMgcG9za3l0bnV0YQpuZW9ka2xhZG7DoSBww6nEjWUgcG9kbGUgcMWZZWRjaG96w61obyBvZHN0YXZjZS4KCjkuIEtyaXpvdsOhIHDFmWlwcmF2ZW5vc3QKClYgc291bGFkdSBzIHBvxb5hZGF2a3kgbmEgemFqacWhdMSbbsOtIHDFmWlwcmF2ZW5vc3RpIHBvc2t5dG92YXRlbGUgemRyYXZvdG5pY2vDqSB6w6FjaHJhbm7DqSBzbHXFvmJ5IG5hIMWZZcWhZW7DrQptaW1vxZnDoWRuw71jaCB1ZMOhbG9zdMOtYSBrcml6b3bDvWNoIHNpdHVhY8OtLCB6ZWptLiBwcm92w6FkxJtuw616w6FjaHJhbm7DvWNoIGEgbGlrdmlkYcSNbsOtY2ggcHJhY8OtdiBzb3V2aXNsb3N0aQpzIHbDvXNreXRlbSBocm9tYWRuw6lobyBwb3N0acW+ZW7DrXpkcmF2w60sIHNlIEtOTCB6YXZhenVqZSBwb3NreXRub3V0IG5hIHbDvXp2dSBaT1Mgdmxhc3Ruw60gZG9zdHVwbsOpIHPDrWx5CmEgcHJvc3TFmWVka3kgZGlzbG9rb3ZhbsOpIG5hIMO6emVtw60gTGliZXJlY2vDqWhvIGtyYWplIHBybyBwbG7Em27DrSDDumtvbMWvIFpaUyBMSywgemVqbS4gdiBzb3V2aXNsb3N0aSBzCnBvxb5hZGF2a3kgbmEgbmF2w73FoWVuw60gcMWZZXByYXZuw61jaCBrYXBhY2l0LCBhIHRvIHbEjWV0bsSbIHBvdMWZZWJ5IHphamnFoXTEm27DrSBldmFrdWFjZSB6ZHJhdm90bmlja8O9Y2gKemHFmcOtemVuw60gcG9za3l0b3ZhdGVsxa8gbMWvxb5rb3bDqSBww6nEjWUuCgoxMC4gRGFsxaHDrSBwcsOhdmEgYSBwb3Zpbm5vc3RpIHNtbHV2bsOtY2ggc3RyYW4KCmEpIEtOTCBwcm9obGHFoXVqZSwgxb5lIGtlIGRuaSBwb2RwaXN1IHTDqXRvIHNtbG91dnkgb2LEm21hIHNtbHV2bsOtbWkgc3RyYW5hbWkgamUgcm96aG9kbnV0aWUgb3Byw6F2bsSbbsOtCmsgcG9za3l0b3bDoW7DrSBQUE5QLCB1dmVkZW7DqSB2IMO6dm9kbsOtbSB1c3Rhbm92ZW7DrXTDqXRvIHNtbG91dnksIHBsYXRuw6ksIGEgZMOhbGUgc2UgemF2YXp1amUgb3puw6FtaXQKWlpTIExLIHbFoWVjaG55IHptxJtueSB0w71rYWrDrWPDrSBzZSDDumRhasWvIHV2ZWRlbsO9Y2ggdiB0b210byByb3pob2RudXTDrSBhbmVibyB2IGRva2xhZGVjaApwxZllZGtsw6FkYW7DvWNoIHNlIMW9w6Fkb3N0w60gbyB1ZMSbbGVuw60gb3Byw6F2bsSbbsOtIG5hIHrDoWtsYWTEmyB0b2hvdG8gcm96aG9kbnV0w60sIGEgbyB0xJtjaHRvIHptxJtuw6FjaApwxZllZGxvxb5pdCBaWlMgTEsgZG9rbGFkeSBkbGUga2FwLiA3cGwnc21lbm8gZyksIGEgdG8gZG8gMTUgZG7FryBvZGUgZG5lLCBrZHkgc2UgbyB0xJtjaHRvIHptxJtuw6FjaApkb3p2xJtkxJtsLgoKYikgS05MIGplIHBvdmlubmEgcG9za3l0b3ZhdCB6ZHJhdm90bsOtIHNsdcW+YnksIHplam0uIFBQTlAsIG5hIG7DoWxlxb5pdMOpIG9kYm9ybsOpIMO6cm92bmksIHYgc291bGFkdSBzCnBsYXRuw71taSBsZWdpc2xhdGl2bsOtbWkgcG/FvmFkYXZreSBuYSBwZXJzb27DoWxuw61hIHbEm2Nuw6kgdnliYXZlbsOtc3Rhbm92ZW7DvW1pIHBybyBwb3NreXRvdsOhbsOtUFBOUCwKamFramUgdXZlZGVubyB2IGthcGl0b2zDoWNoIHbDvcWhZSB0w6l0byBzbWxvdXZ5LiBaWlMgTEsgc2kgdnlocmF6dWplIHByw6F2byBrb250cm9seSBuYXBsxYhvdsOhbsOtdMSbY2h0bwpwb8W+YWRhdmvFry4gUG9ydcWhZW7DrSB0xJtjaHRvIHBvdmlubm9zdMOtIHNlIHBvdmHFvnVqZSB6YSBocnViw6kgcG9ydcWhZW7DrSB0w6l0byBzbWxvdXZ5IGEgbcWvxb5lIGLDvXQKc3BvamVubyBzIHZlxaFrZXJvdSBvZHBvdsSbZG5vc3TDrXogdGFrb3bDqWhvIHBvcnXFoWVuw612eXBsw712YWrDrWPDrS4KCmMpIFphIHBvcnXFoWVuw60gcG92aW5ub3N0w612eXBsw712YWrDrWPDrWNoIHogdMOpdG8gc21sb3V2eSBzZSBkw6FsZSBwb3Zhxb51amUgb3Bha292YW7DqSBwb3J1xaFvdsOhbsOtIHVqZWRuw6Fuw60sCm5lbmFwbMWIb3bDoW7DrSB6w6F2YXprxa8gYSBzbWx1dm7DrWNoIHBvdmlubm9zdMOtIGEgemUgc3RyYW55IEtOTCB0YWvDqSBvcGFrb3ZhbsOpIG5lc3BsbsSbbsOtIHBva3ludQpvcGVyw6F0b3JhIFpPUyBaWlMgTEsgayByZWFsaXphY2kgdHJhbnNwb3J0dSBiZXogdWTDoW7DrXrDoXZhxb5uxJtobyBkxa92b2R1LiBaYSBvcGFrb3ZhbsOpIHBvcnXFoW92w6Fuw60Kc2UgcHJvIMO6xI1lfHkgdMOpdG8gc21sb3V2eSBwb3Zhxb51asOtYWxlc3BvxYggdMWZaSBww61zZW1uw6EgdXBvem9ybsSbbsOtZHJ1aMOpIHN0cmFuxJsgYsSbaGVtIDI2IHTDvWRuxa8uCgpjbCkgWmEgxaBrb2R5IHpwxa9zb2JlbsOpIHDFmWkgcG9za3l0b3bDoW7DrSB6ZHJhdm90bsOtY2ggc2x1xb5lYiwgdnpuaWtsw6kgbmEgesOha2xhZMSbIHVqZWRuw6Fuw60gdnlwbMO9dmFqw61jw61jaCB6CnTDqXRvIHNtbG91dnksIG9kcG92w61kw6EgcG9za3l0b3ZhdGVsIHpkcmF2b3Ruw61jaCBzbHXFvmViLCBrdGVyw70gemRyYXZvdG7DrSBzbHXFvmJ5IHBvc2t5dG92YWwuCgplKSBLTkwgc2UgemF2YXp1amUgcG9za3l0b3ZhdCBzb3XEjWlubm9zdCBaT1MgWlpTIExLIHDFmWVkw6F2w6Fuw61tIGluZm9ybWFjw60gcG90xZllYm7DvWNoIHBybyBvcGVyYcSNbsOtCsWZw616ZW7DrSwgemVqbS4gaGzDocWhZW7DrSBwb2xvaHksIHRyYXN5IGEgc3RhdnUgYWtjZXNjaG9wbm9zdMOtIHBvc8OhZGVrIGEgdm96aWRlbCBuYSDDunplbcOtIExpYmVyZWNrw6lobwprcmFqZS4KCmYpIEtOTCBzZSB6YXZhenVqZSBwxZllZGF0IFpaUyBMSyBzZXpuYW0gZG9wcmF2bsOtY2ggcHJvc3TFmWVka8WvIHZ5dcW+w612YW7DvWNoIGsgcGxuxJtuw610w6l0byBzbWxvdXZ5LCBhCnRvIGRvIDE1IGRuxa8gb2QgcG9kcGlzdSB0w6l0byBzbWxvdXZ5IG9ixJttYSBzbWx1dm7DrW1pIHN0cmFuYW1pLCBhIHRlbnRvIHNlem5hbSBha3R1YWxpem92YXQgZGxlCnBvdMWZZWJ5LCBtaW5pbcOhbG7EmyB2xaFha2plZGVua3LDoXQgcm/EjW7Emy4KCmcpIEtOTCBzZSB6YXZhenVqZSBvem7DoW1pdCBaWlMgTEsgdmXFoWtlcsOpIHptxJtueSBhIHDFmWVrw6HFvmt5IHZ6bmlrbMOpIHYgcHLFr2LEm2h1IHRydsOhbsOtIHTDqXRvIHNtbG91dnksCmt0ZXLDqSBwb2RzdGF0bsO9bSB6cMWvc29iZW0gb3ZsaXbFiHVqw60gc21sdXZuw60gdnp0YWggdG91dG8gc21sb3V2b3UgemFsb8W+ZW7DvSwgYSB0byBuZXByb2RsZW7Emwp0ZWxlZm9uaWNreSAmIHDDrXNlbW7EmyBuZWpwb3pkxJtqaSBkbyAxNSBkbsWvIG9kZSBkbmUsIGtkeSBzZSBvIHTEm2NodG8gem3Em27DoWNoIGFuZWJvIHDFmWVrw6HFvmvDoWNoCmRvenbEm2TEm2xhLgoKMTEuIFVrb27EjWVuw61zbWx1dm7DrWhvIHZ6dGFodQpUYXRvIHNtbG91dmEgbcWvxb5lIGLDvXQgdWtvbsSNZW5hOgphKSBww61zZW1ub3UgZG9ob2RvdSBzbWx1dm7DrWNoIHN0cmFuOwpiKSB2w71wb3bEm2TDrSBuxJtrdGVyw6kgemUgc21sdXZuw61jaCBzdHJhbiwgYSB0byBpIGJleiB1ZMOhbsOtZMWvdm9kdTsKCmMpIHbDvXBvdsSbZMOtIG7Em2t0ZXLDqSB6ZSBzbWx1dm7DrWNoIHN0cmFuIHpkxa92b2R1IGhydWLDqWhvIHBvcnXFoWVuw60gcG92aW5ub3N0w60sIGEgdG8gemVqbcOpbmEKcG9ydcWhZW7DrSB1c3Rhbm92ZW7DrSBrYXBpdG9seSA1LiBvZHN0LiAxIHNtbG91dnkgKFBvxb5hZGF2a3kgbmEgcGVyc29uw6FsbsOtIHphYmV6cGXEjWVuw60gUFBOUCkgYQoKIAoKOjkvMTAgOwoKU01MT1VWQSBPIFNQT0xVUFLDgUNJCgpwb3J1xaFlbsOtIHBvdsOtbm5vc3TDrWRsZSBrYXBpdG9seSAxMC4gcMOtc20uIGIpIGEgYykgc21sb3V2eS4KClbDvXBvdsSbZG7DrSBsaMWvdGEgZGxlIHDDrXNtLiBiKSBzZSBzdGFub3Z1amUgbmEgZHZhbsOhY3QgbcSbc8OtY8WvIGEgcG/EjcOtbsOhIGLEm8W+ZXQgcHJ2bsOtbSBkbmVtIG7DoXNsZWR1asOtY8OtaG8KbcSbc8OtY2UsIHBvIGRvcnXEjWVuw612w71wb3bEm2TDrSBkcnVow6kgc21sdXZuw61zdHJhbsSbLiBCxJtoIHbDvXBvdsSbZG7DrSBsaMWvdHkgbmVtw6EgdmxpdiBuYSBwbG7Em27DrSBwb3Zpbm5vc3TDrQp2eXBsw712YWrDrWPDrSB6IHTDqXRvIHNtbG91dnkuCgpWw71wb3bEm2Ruw60gbGjFr3RhIGRsZSBww61zbS4gYykgxI1pbsOtIGR2YSBtxJtzw61jZSBhIHBvxI3DrW7DoSBixJvFvmV0IHBydm7DrW0gZG5lbSBuw6FzbGVkdWrDrWPDrWhvIG3Em3PDrWNlIHBvCmRvcnXEjWVuw612w71wb3bEm2RpIGRydWjDqSBzbWx1dm7DrXN0cmFuxJsuIELEm2ggdsO9cG92xJtkbsOtIGxoxa90eSBuZW3DoSB2bGl2IG5hIHBsbsSbbsOtIHBvdsOtbm5vc3TDrXZ5cGzDvXZhasOtY8Otegp0w6l0byBzbWxvdXZ5LgoKMTIuIFrDoXbEm3JlxI1uw6EgdXN0YW5vdmVuw60gYSBwcm9obMOhxaFlbsOtCgphKQoKYikKClRhdG8gc21sb3V2YSBuYWLDvXbDoSBwbGF0bm9zdGkgZG5lbSBqZWrDrWhvIHBvZHBpc3Ugb2LEm21hIHNtbHV2bsOtbWkgc3RyYW5hbWkgYSB6dmXFmWVqbsSbbsOtbQp2IHJlZ2lzdHJ1IHNtbHV2LgoKT2LEmyBzbWx1dm7DrSBzdHJhbnkganNvdSBzcm96dW3Em255LCDFvmUgcHJvIHZ6w6FqZW1ub3Uga29tdW5pa2FjaSBhIHNwb2x1cHLDoWNpIHYgc291dmlzbG9zdGkgcwp0b3V0byBzbWxvdXZvdSBwbGF0w60ga29udGFrdG7DrSDDumRhamUgdXZlZGVuw6kgdiBrYXAuNCBww61zbS4gZykgYSBoKS4gdMOpdG8gc21sb3V2eS4gVmXFoWtlcsOhCnDDrXNlbW7DoSBrb211bmlrYWNlIG1lemkgc21sdXZuw61taSBzdHJhbmFtaSBidWRlIHByb2LDrWhhdCB2w71ocmFkbsSbIGRhdG92b3Ugc2NocsOhbmtvdSwKb3NvYm7DrW0gZG9ydcSNZW7DrW0sIHBvxaF0b3UgbmVibyBrdXLDvXJuw61zbHXFvmJvdSBuYSBhZHJlc3kgdXZlZGVuw6kgdiBrYXAuIDEuIHTDqXRvIHNtbG91dnkuCgpUYXRvIHNtbG91dmEgc2UgdXphdsOtcsOhIG5hIGRvYnUgbmV1csSNaXRvdS4KClZlxaFrZXLDqSB6bcSbbnkgdMOpdG8gc21sb3V2eSBtb2hvdSBiw710IG1lemkgc21sdXZuw61taSBzdHJhbmFtaSBwxZlpamF0eSBwbyB2esOhamVtbsOpIGRvaG9kxJsKZm9ybW91IHDDrXNlbW7DvWNoIGRvZGF0a8WvLCBrdGVyw6kgc2UgcG8gamVqaWNoIHBvZHBpc3Ugc21sdXZuw61taSBzdHJhbmFtaSBzdMOhdmFqw60gbmVkw61sbm91CnNvdcSNw6FzdMOtdMOpdG8gc21sb3V2eSBhIMWZw61kw61zZWplasOtbSBwcsOhdm7DrW0gcmXFvmltZW0uCgpUYXRvIHNtbG91dmEgc2Ugdnlob3RvdnVqZSB2ZSB0xZllY2ggc3Rlam5vcGlzZWNoLCB6IG5pY2jFviBkdmEgb2JkcsW+w61aWlMgTEsgYSBqZWRlbiBLTkwuCgpTbWx1dm7DrXN0cmFueWpzb3Ugc2kgdsSbZG9teSwgxb5lIMO6cGxuw70gdGV4dCB0w6l0byBzbWxvdXZ5IGJ1ZGUgenZlxZllam7Em24gdiBzb3VsYWR1IHNlIHrDoWtvbmVtCm8gcmVnaXN0cnUgc21sdXYgYSBzb3VobGFzw61zIHTDrW0uIFp2ZcWZZWpuxJtuw60gcHJvdmVkZSBLTkwgemEgcG9tb2NpIGF1dG9tYXRpY2vDqWhvIHN0cm9qb3bDqWhvCnDFmWV2b2R1IHRleHR1LgoKU21sdXZuw60gc3RyYW55IHByb2hsYcWhdWrDrSwgxb5lIHDFmWVkIHBvZHBpc2VtIHTDqXRvIHNtbG91dnkgc21sb3V2dSDEjWV0bHkgYSBzZXpuw6FtaWx5IHNlIHMgamVqw61tCm9ic2FoZW0sIGt0ZXLDqW11IHJvenVtw61hIHNlIGt0ZXLDvW0gc291aGxhc8OtLCDFvmUgc21sb3V2dSB1emF2w61yYWrDrSBuYSB6w6FrbGFkxJsgc3ZvYm9kbsOpIHbFr2xlLApuaWtvbGl2IHTDrXNuaSBhbmVibyB6YSBwb2Rtw61uZWsgbmV2w71ob2Ruw71jaCBwcm8gamVkbnUgemUgc21sdXZuw61jaCBzdHJhbiwgcG9wxZkuIGplZG51IHNtbHV2bsOtCnN0cmFudSBuZXDFmWltxJvFmWVuxJsgenbDvWhvZMWIdWrDrWPDrWNoLCBhIMW+ZSBwb2RwaXMgc21sb3V2eSBqZSBwcm9qZXZlbSBqZWppY2ggdsOhxb5uw6kgdsWvbGUgdHV0bwpzbWxvdXZ1IHV6YXbFmcOtdC4KClRvdXRvIHNtbG91dm91IHNlIHJ1xaHDrToKClNtbG91dnUgeiByb2t1IDYuMTAuMjAxNyAoUzIwMTcvMDA1MDYpLAoKU21sb3V2YSBvIHZ6w6FqZW1uw6kgc3BvbHVwcsOhY2kgbmEgc2VrdW5kw6FybsOtdHJhbnNwb3J0eSB6IDEuOC4yMDA1IOKAlCBUMjAxNC8wMDEwMQpEb2hvZGEgbyBzcG9sdXByw6FjaSBkb3ByYXZhIHYga8OzZHUgNjAgeiA3LiA0LiAyMDA4IFQyMDE0LzAwMTAwCgpEb2hvZGEgbyBzcG9sdXByw6FjaSB0cmFuc3BvcnQgdiBrw7NkdSA2MCB6IDcuNC4yMDA4IFQgMjAxNC8wMDA5OAoKU21sb3V2dSBuYSB0cmFuc3BvcnQgdiBrw7NkdSA2MCB1emF2xZllbGEgcyBaWlMgTEsgaSBLTkwgMTUuNS4yMDA4IFMgMjAwOC8wMDE3NC4KClpkcmF2b3RuaWNrw6EgesOhY2hyYW5uw6Egc2x1xb5iYSBMaWJlcmVja8OpaG8ga3JhamUsIHAuby4gS3JhanNrw6EgbmVtb2Nuw61jZSBMaWJlcmVjLCBhLnMuCgrigJ4mJi9aTSAoMjQzXzIwMjMKCnYgTGliZXJjaSBkbmUgdiBMaWJlcMSNw63EjW5lIOKAngoKIAoKNDEwLzEwOwoK2be670cd8084afdd105d54ffa3879224b2295a638758fc5631f07ff86c40b3c8S20230029200 Smlouva o spolupráci_TXT.txt2026-06-23T20:21:00+02:00113de7762d4762715e51e90ef7d20eca0aea333d3d69787245d5a0a4c584f7736