3217237334320593https://smlouvy.gov.cz/smlouva/343205932025-08-04T10:46:47+02:00jwaeuenKrajská nemocnice Liberec, a.s.27283933Husova 1430/34, 46001 Liberec, CZMedtronic Czechia s.r.o.64583562Prosecká 852/66 PrahaSmlouva o grantu na vzdělávání2025-08-01S2025/00625/0017000077u/RURVQ0FUSU9OQUwgR1JBTlQgQUdSRUVNRU5UCgpUV1MgQWdyZWVtZW50IFxTIGVudGVyZWQgbXRvIGJldHdlZW4gTWVkdHJvbWMgYW5kIHRoZSBcblNVdHF1biBvbiB0aGUKCkFncmVlbWVudCBEYXRlCgoxLiBCQUNLR1JPVU5ECgpNZWR0cm9tYydzIE1cc3N3b24gdG8gYUhldndhdGUgcGFtLCByZXN0b3JlIGhlYWtoLCBhbmQgZXh0ZW5kIGhmZSB3cwpwcm9tb3RlZCBieSBTdXBwb3J0bWcgbWFueSBzdGFrZWhvd2RlcnMgbSBoZWFraGNhcmUgdGhyb3VnaApmbWFuZWF3IFN1cHBvcnRmb3IgZWR1Y2F0d29uxI8gcHVycG9TZVMgQTUgcGFydCBvZiBcdHMgcm9cZSBhbmQgbQpDb25mdHJtYWhvbiBvZnRoZSBcblNVdHF1bidTIHJlcXVlU3QgZGF0ZWQgMjltIG9mIEFwcncgMjAyNSwKTWVkdHJvbWMgYWdyZWVTIHRvIHByb3dkZSwgYW5kIHRoZSBcblNVdHF1biBXdFNoZVMgdG8gYWNjZXB0LCB0aGUKR3JhbnQgZm9yIHRoZSBwdXJwb1NlIHN0YXRlZCBiZWJ3LCBTdWJqZWN0IHRvIHRoZSBBZ3JlZW1lbnQgRGV0YXdzCgphbmQgVGVybVMgYW5kIENvbmRtb25TIHNldCBvdXQgbSB0dGhBZ3JlZW1lbnQKCjIuIEFHUkVFTUVOVCBERVRBSUxTCgpTTUxPVVZBIG8gR1JBTlRVIE5BIFZaRMSaTMOBVsOBTsONCgpUYXRvIFNtYnV2YSBTZSB1emF2dHLDoSBtZcW+dCA1cG9cZcSNbjA1dCggTWVkdHJvbWMgJiBaZHJhdm90bWNrw71tIMW+YWjFvmVodG0KCmsgRGFtIHV6YXbFmWVodHNtd293eQoKMS4gdsOdY25vesOtIFNJVFVBQ0UKClBvc1zDoW4oIDVwb1xlxI1uMDV0XCBNZWR0cm9tYywgdGVkeSDigJ5NZXZvdmF0IG9kIGJvXGU1dFwsIG9ibm92b3ZhdCB6ZHJhdnQgJgpwcm9kbcW+b3ZhdCDFvnd2b3QiLCByZWFoenVqZW1lIEhtLCDFvmUgcG9za3l0dWplbWUgaG5hbsOpbSBwb2Rwb3J1IHBybwp2emTEm1zDoXZhYyggw7rEjWVceSBTcG9cZcSNbm9zdCBNZWR0cm9tYyA1XCBKYWtvIHNvdcSNw6FzdCBzdsOpIHJvXGUgYWpha28gcG90dnJ6ZW0Kxb7DoWRvc3R3IFpkcmF2b3RtY2vDqWhvIMW+YWjFvmVtIMW+ZSBkbmUgMjkgZHVibmEsIDIwMjUgcMWZZWplIHBvc2t5dG5vdXQgLCAmClpkcmF2b3RtY2vDqSDFvmFoxb5lbSBzb3VoXGFzKCA1IG1tLCDFvmUgcMWZVW1lICwgR3JhbnQgcHJvIMO6xI1lXCBkb2hvZG51dMO9IG3FvmUsCiYgdG8gZFxlIFBvZHJvYm7DvWNoIMO6ZGFqxa8gKCkgNW1cb3V2xJsgJiDFvmEgcG9kbW1layB2dMOpdG8gU21idXbEmwoKc3Rhbm92ZW7DvWNoCgogCgoyIFBPRFJPQk7DiSDDmkRBSkUgbyBTTUxPVVbEmgoKIAoKQWdyZWVtZW50IERhdGUgLyBEYXR1bSB1emF2xZllbsOtIHNtbG91dnkKCkFzIG9mIHRoZSBkYXRlIG9mIG1nbW5nIHR0aCBBZ3JlZW1lbnQgYnkgYm90aCBwYW1lUyAvIGRhdHVtIHBvZHByc3UgdMOpdG8gc21sb3V2eSBvYsSbbWEgc3RyYW7DoW0hCgogCgpNZWR0cm9uaWMgZW50aXR5CihQcm92aWRpbmcgdGhlIEdyYW50KSAvClN1Ympla3QgTWVkdHJvbmk6Cihwb3NreXR1asOtY8OtIEdyYW50KQoKTmFtZSAvIE7DoXpldjoKCk1lZHRyb21jIEN6ZWNod2EgcyByICgpCgogCgpDb20gcGFueSBOdW1iZXIgLyDEjMOtc2xvIHNwby9lxaFoIG9zbjoKClZBVCBDMjY5OTAwNTYxOCwgXEQgNjQ1ODM1NjIKCiAKCkFkZHJlc3MgLyBBZHJlc2E6CgpQcm9TZWNrw6EgODUyLzY2LCAxOTAgMDAsIFByYWhhIDkKCiAKCkNvbnRhY3QgcGVyU29uIC8gS29udGFrdG7DrSBvc29iYToKCiAKCkluc3RpdHV0aW8gIgoKKFJlY2VpdmluZyB0aGUgR3JhbnQpIC8KWmRyYXZvdG5pY2vDqSB6YcWZw616ZW7DrQoocMWZaWrDrW1hasOtY8OtCgpHcmFudCkKClR5cGUgb2YgSW5zdGl0dXRpb24gcmVjZWkKCiAKCiduZyB0aGUgR3JhbnQgLwoKVHlwIHpkcmF2b3RuaWNrw6lobyB6YcWZw616ZW7DrSBwxZlpasOtbWFqw61jw61obyBHcmFudDoKCiAKCltdIEhlYWtoIENhcmUgUHJvZmVTU3dvbsSPIEFTU09VYW5uIC8gU29jd2V0eSAvIFtdIFJlbmd0ZXJlZAoKT3JnYW1zYXRtIChIQ08pIC8gT2Rib3Juw6EgYXNvY3JhY2UgLzVwby9lxI1ub3N0IENoYW50eSAvClpkcmF2b3JtY2vDoSBEZWJtYWhow6EKb3JnYW16YWNlIHNwb2xlxI1uIG9zdAoKIAoKIAoKIAoKTmFtZSAvIE7DoXpldjoKCktyYWpza8OhIG5lbW9jbWNlIHdhZXJlYywgJiA1CgogCgpDb20gcGFueSBOdW1iZXIgLyDEjMOtc2xvIHNwby9lxaFoIG9zbjoKClxDbzogMjcyODM5MzMsIFZBVC9EXMSMOiBDWjI3MjgzOTMzCgogCgpBZGRyZXNzIC8gQWRyZXNhOgoKSHVTb3ZhIDE0MzAvMzQ7IHdhZXJlY2YgU3RhcsOpIE3Em3N0bywgNDYwIDAxCgogCgp3aGVyZSByZXF1cnJlZCwgbG5zbXV0cm9uIHByb3ZyZGVkIG1wZWcgb2ZyaGUgaGNlbnNlIC9hbWMvZXMgb2Zhc3NvY3JhdHJvbi9vdGhlciBnb3Zlcm5tZW50YWwKVmVyaWZpY2F0aW9uIG9mIHRoZSBsbnNtdXRyb25zJyBsZWdhbCBzdGF0dXMKUG9rdWQgc2UgdG8gcG/FvmFkdWplLCBwb3NreXRsbyBaZHJhdm90bWNrw6kgemHFmcOtemVuw60ga29wcmUgaGNlbmNlIC81dGFub3YvXW0gw6lobyDDusWZZWRuw61obyBwcsOhdm7DrWhvCgpzdGF0dXR1IFpkcmF2b3JtY2tlJ2hvIHphxZnDrXplbsOtCgogCgpDb250YWN0IFBlcnNvbiAvIEtvbnRha3Ruw60gb3NvYmE6CgogCgogCgpHcmFudAoKR3JhbnQKCiAKCltdIEVkdWNhdG1hdyBFdmVudCBhcnJhbmdlZCBieSBcblN0d3R1dHdvbiAvIFZ6ZMSbbMOhdmFjxZlha2NlIHBvxZnDoWRhbsOhIFpkcmF2b3RtY2vDvW0gemHFmcOtemVuw61tCgpIQ1AgQXR0ZW5kIGFuY2UgYXQgVGh3cmQgUGFydHkgRXZlbnQgLyDDmsSNYXN0IHpkcmF2b3RtY2vDqWhvIG9kYm9ybsOta2EgbmEgQWtjciBwb8WZw6FkYW7DqSB0xZllcsWZbXIKCm9zb2JhbSEKW10gU2Nob1xhcjVoXHAgb3IgRmVIb3dTV1AgL1N0dWRyXW7FmW5lYm8gdsSbZGVja8OpIHN0aXBlbmRpdW0KW10gVHJhbW1nIGFuZCBFZHVjYXRtYXcgTWF0ZWhhd3MgWyh3aHdjaCBtYXkgbWR1ZGUgTWVkdHJvbWMgb3Igbm9uck1lZHRyb21jIEVxbXBtZWh0biAvCgrFoGtvaGPFmWEgdnpkxJtsw6F2YWPDrSBtYXRlaMOhZnkgWyhrdGVyw6kgbW9ob3UgWmFobSBvdmF0IFZ5YmF2ZW7FmXNwby9lxI1uIGVzbiBNZWRybW1jIG5lYm8g4oCebmUnIFZ5YmF2ZW7DrQoKaGXFviBzcG9sZcSNbiBlc24gTWVkcm1tYyldCgogCgpFZHVjYXRpb25hbCBHcmFudCBBZ3JlZW1lbkxBcHJpbCAyMDI0Ck9OSVQgbnVtYmVyIDQwMjQ0MTU4CgpQYWdlIDEgb00zCgogCgogCgogCgpHcmFudApEZXRhaWxzIC8KR3JhbnQKClBvZHJvYm7DqSBpbmZvcm1hY2UKClR5cGUgb2YgR3JhbnQgLyBUeXAgR3JhbnR1IEN1cnJlbmN5IC8gTcSbbmEgVG90YWwgQW1vdW50IC8KCkNlbGtvdmEgxI3DoXN0a2EKCiAKCk1vbmV0YXJ5LyBGbWFoxaFoZnBtc3RmZWRreSBDWksgMTcwIDAwMCBjej48CltdIFRyYW1tZyBhbmQgRWR1Y2F0bWF3IE1hdGVoYXdzCih3aHRjaCBtYXkgbWR1ZGUgRXFtcG1lbnQpLwoKxaBrb2hjxZlhIHZ6ZMSbbMOhdmFjw60gbWF0ZW7DoWx5IChrYW0KCiAKCiAKCiAKCm3Fr8W+ZSBwYXTFmXIhICwgVnliYXZlbsOtKQoKIAoKVGljayB0aGlzIGJveCB0byBjb25maXJtIHRoYXQgdGhpcyBHcmFudCB3aWxsIGluY2x1ZGUgRXF1aXBtZW50IC8gUG9rdWQgdGVudG8gR3JhbnQgemFocm51amUgVnliYXZlbsOtLCBwb3R2csSPdGUgdHV0byBza3V0ZcSNbm9zdCB6YcWha3J0bnV0w61tIHRvaG90bwoKcG9sw63EjWthIFtdCgpFcSBtcG1lbnQgcHJvbWVkIC8gUG9za3l0bnV0w6kgVnliYXZlbsOtOiBEZXNjbmJlIC8gcG9wcsWhdGUKCiAKClRpY2sgdGhpcyBib3ggdG8gY29uZmlybSB0aGF0IHRoaXMgR3JhbnQgd2lsbCBub3QgYmUgdXNlZCBmb3IgYWN0CgogCgplcyB0YWtpbmcgcGxhY2UgaW4gYSBzYW5jdGlvbmVkIGNvdW50cnkgYW5kISBvciBjb3ZlciBIQ09zIGZyb20gYSBzYW5jdGlvbmVkIGNvdW50cnkKCihzZWUgc2VjdGlvbiA2IGluIHRoZSBUZXJtcyBhbmQgQ29uZGl0aW9ucykuIC8gWmHFoWtydG7Em3RlIHRvdG8gcG9sw63EjWtvIHBybyBwb3R2cnplbsOtLCDFvmUgdGVudG8gR3JhbnQgbmVidWRlIHBvdcW+w610IG5hIGFrY2UsIGt0ZXLDqSBzZSBrb25hasOtIHYgemVtaSBwb2Rsw6loYWrDrWPDrQoKc2Fua2PDrW0gYS9uZWJvIHBybyBaZHJhdm90bmlja291IG9yZ2FuaXphY2kgemUgemVtxJsgcG9kbMOpaGFqw61jw60gc2Fua2PDrW0gKHZpeiDEjWzDoW5layA2IFBvZG3DrW5laykuCgogCgogCgpFRFVDQVRJT05BTCBHUkFOVCAvIEdSQU5UIE5BIFZaRMSaTMOBVsOBTsONCgogCgogCgpFZCB1Y2F0dG9uYXcKR3JhbnQgUHVycG9TZSAvCsOaxI1lbCBHcmFudHUgbmEKCnZ6ZMSbbMOhdsOhbsOtCgpUaWNrIHRoaXMgYm94IHRvIGNvbmZpcm0gdGhhdCB0aGlzIEdyYW50IHdpbGwgY292ZXIgSGVhbHRoIENhcmUgUHJvZmVzc2lvbmFsIChIQ1ApIGF0dGVuZGFuY2UgY29zdHMgYXQgYSBUaGlyZCBQYXJ0eSBFdmVudC4gLwpaYcWha3J0bsSbdGUgdG90byBwb2zDrcSNa28gamFrbyBwb3R2cnplbsOtLCDFvmUgdGVudG8gR3JhbnQgYnVkZSBwb3XFvml0IG5hIMO6aHJhZHUgbsOha2xhZMWvIG5hIMO6xI1hc3QgemRyYXZvdG5pY2vDqWhvIG9kYm9ybsOta2EKCm5hIEFrY2kgcG/FmcOhZGFuw6kgdMWZZXTDrW1pIG9zb2JhbWkuCgogCgpBdCBub2htZSB3d0ggTWVkdHJvbWMgYmUgbXZvV2VkIG0gdGhlIDVlXGVjdFxvbiBvZiBtZHd2d2R1bSBiZW5lZndjd2FuZXNXQ1BzKSBvZiB0aGUgR3JhbnQgLyBTcG9sZcSNbm9zdCBNZWR0bW1jIHNlCgpta2R5IG5lemFwb2p1amUgZG8gdsO9YsSbcnUvZWRub3RodsO9Y2ggb3NvYiAsIHpkcmF2b3JtY2vDvWNoIG9kYm9ybsOta8WvICwgxI1lcnBhasWZY8WZY2ggcG9kcG9ydSB2IHLDoW1jaSBHcmFucnUKCkVkdWNhdGlvbmFsIEV2ZW50IG9yZ2FuaXNlZCBieSBUaGlyZCBQYXJ0eSAvCgpWemTEm2zDoXZhY8OtIGFrY2UgcG/FmcOhZGFuw6EgdMWZZXTDrW1pIG9zb2JhbWkKCi0tIEVTQyBDb25ncmVzcyAyMDI1IC0gTWFkcmlkLCAyOSBBdWd1c3QgLSAxIFNlcHRlbWJlciAyMDI1CgpUaGUgR3JhbnQgXFN0byBTdXBwb3J0IG1lZFxjYVwgdHJhbW1nIGFuZCBlZHVjYXRtIG9mIEhlYVx0aENhcmUgUHJvZmVzc3R0bWF3cyAoSENQUykgY2FyZHdvYmd5LCBwcm9tb3RtZyBTbWVudG1jCmtub01lZGdlLCB0aCBvcmRlciB0byBkZWh2ZXIgZWZmZWN0d3ZlIGFuZCBjb250bXVvdVMgaGVhXHRoY2FyZSBhbmQgd20gbWR1ZGUgYXR0ZW5kYW5jZSBhdFRod3JkIFBhcnR5IEV2ZW50cywgNTAgXG9uZyBhUwp0aGV5IGFyZSB0aCBjb21waGFoY2UgdGhoIHRoZSBNZWRUZWNoIENvZGUgYW5kIE1lZHRyb21jIEJ1c21lc3MgQ29uZHVjdCBTdGFuZGFyZHMgKHRoZSAiRXZlbnTigJwpIC8KCkdyYW50cy9vdcW+xZluYSBwb2Rwb3J1IGzDqWthxZlza8OpaG8gdnpkxJtsw6F2w6FuxZlhIMWha29sZW7DrXZ6ZMSbbMOhdsOhbsOtWmRyYXZvdG1ja8O9Y2ggb2Rib3Juw61rxa8ga2FyZHJvL29ncmUsIG5hIHBvZHBvcnUgdsSbZGVja8O9Y2gKem5hbG9zdMWZYSBwb3NreXRvdsOhbsWZZWZla3Jydm7Em2rFocWZYSB0cnZhbMOpIHpkcmF2b3Ruw60gcMOpxI1lLCBhIHNwYWTDoSBkbyBoZSwgw7rEjWFzdCBuYSBBa2NyIHBvxZnDoWRhbsOpIHTFmWV0w61tISBvc29iYW1yLCBvdsWhZW0gcG91emUKdiByb3pzYWh1LCB2IGhlbcW+LGUgdiBzb3VsYWR1IHMgS29kZXhlbSBNZWRyZWNoIGEgU3RhbmRhcmR5IG9iY2hvZG7DrWhvICxlZGjDoWhmc3BlL2XEjWggZXNuIE1lZHRtbWMgKGTDoWxlIG96bmHEjW92YW7DoSAsZWgKCmpha28g4oCeQWtjZScpCgpXaGVyZSBhcHBoY2FiXGUsIHRoZSBFdmVudCBtdVN0IGJlIGFwcHJvdmVkIGJ5IHRoZSBjdnMgcG5vciB0byBhbnkgb2YgdGhlIEdyYW50IGJlbWcgdXNlZCBmb3IgdGhlIEV2ZW50IFRoZSBcblNVdHF1bgp1bmRlcnRha2VzIHRvIHN1IGJtXHQgdGhlIEV2ZW50IGZvciB0aGUgYVNTZVNTbWVudCB1bmRlciB0aGUgY3ZzIC8gVnDFmcWZcy91xaFuw71jaCBwxZnDrXBhZGVjaCBtdXPFmWLDvXRBa2NlIHDFmWVkIHZ5dcW+bW0gXWFrw71jaGtvaAoKcHJvc3TFmWVka8WvIHogR3JhbnJ1IGhhIEFrY3Igc2NoIHbDoWxlbmEgdiByw6FtY2kgY3ZzIFpkcmF2b3JtY2tlJyB6YcWZw616ZW7FmXNlIHphdmF6dWplIHDFmWVkbG/FvnJyQWtjciBrIHBvc291emVuw60gdiByw6FtY2kgY3ZzCgpXZWFzZSByZWZlciB0byBTY2hlZHRIZSAxIGF0dGFjaGVkIGZvcnF1IGRldGFucyBcbmR1ZG1nIGFIb3dhYlxlIEhDUCBFeHBlblNlUyB0aGF0IHRoZSBHcmFudCBtYXkgY292ZXIgQW55IHByb3Zhd29uIG9mCjVlXGVjdFxvbiBjbnRlbmEgKFxmcmVcZXZhbnQpIHRvIHdod2NoIHRoZSBcbmV0dHR1dHRvbiBhZ3JlZVMgdG8gdGggdGhlIFNwZWN0YXcgQ29uZG1vblMgc2hhSCBoIOKAnjAgd2F5IHBlcm1cdCBtZHd0ZHVhdyBIQ1BzIHRvIGJlCjVlXGVjdGVkIGJ5IE1lZHRyb21jIC8KClZQxZnFmS9vemUgNSAxIGpzb3UgdXZlZGVueSBrb21wbGV0bsOtIHBvZHJvYm7DqSBtZm1tYWNlLCB2xI1ldG7EmyB2eWRhbSBoYSB6ZHJhdm9ybWNrZSdobyBvZGJvcm7DrWthLCBdZWpyY2jFviBwb2tyeXTDrXogR3JhbnR1IGplCnDFmcOtcHVzdG7DqSBKYWtla29oIHphZMOhbSB2w71ixJtyb3bDvWNoIG1laHIgKHBva3VkIHNlIHZ6dGFodWrDrSksIF1lanJjaMW+IHVwbGF0bsSbbsOtIFpkcmF2b3JtY2tlJyB6YcWZw616ZW7DrSBvZHNvdWhsYXPFmSB2ZSBadmzDocWhdG7DrW0KCnBvZG3FmW4ga8OhY2gsIHYgxb7DoWRuw6ltIHDFmcOtcGFkxJsgbmV1bW/FvsWIdWplLCBhYnkgdsO9YsSbci9lZG5vcmh2w71jaCB6ZHJhdm9ybWNrw71jaCBvZGJvcm7DrWvFryBwcm92ZWRsYSBzcG9sZcSNbm9zdCBNZWR0bW1jCgogCgpERUxJVkVSQUJMRVM6IFDFmEVETcSaVFkgUExOxJpOw406CgogCgogCgpUaGUgXG5zdHd0dXR3b24gd3dILCBtIGNvbnN3ZGVyYXR3b24gZm9yIHRoZSBHcmFudCwgYW5kIGF0IG5vIGFkZHd0d29ubSBjb3N0IG9yIGV4cGVuc2UgdG8gTWVkdHJvbWMgLyBaZHJhdm9ybWNrZScgemHFmcOtemVuw60KcG9za3l0bmUgdsO9bcSbbm91IHphIEdyYW50YSBiZXogZG9kYXRlxI1uw71jaCBuw6FrbGFkxa8gbmVibyB2w71kYWrFryBwcm8gc3BvbGXEjW5vc3QgTWVkcm1tYyBkw6FsZSB1dmVkZW7DqToKCkVkdWNhdGlvbmFsIEV2ZW50IChvcmdhbmlzZWQgYnkgSW5zdGl0dXRpb24gb3IgVGhpcmQgUGFydHkpIC8KClZ6ZMSbbMOhdmFjw60gYWtjZSAocG/FmcOhZGFuw6kgemRyYXZvdG5pY2vDvW0gemHFmcOtemVuw61tIG5lYm8gdMWZZXTDrSBvc29ib3UpCgouIGVuU3VyZSB0aGF0IHRoZSBTdWJqZWN0IG1hdHRlciBvZiB0aGUgXG5TVXR1VU9uJ1MvVGh1J2QgUGFydHkncyBtZWR0Y20gdHJhbW1nIGFuZCBlZHVjYXR0b24gXDUgbSBhaGdubWVudCB3dHRoIHRoZQpHcmFudCBQdXJwb1NlIC8gemFqcnN0xZksIGFieSBwxZllZG3Em3QgbMOpa2HFmXNrw6lobyB2emTEm2zDoXbDoW7FmWEgxaFrb2xlbsWZcG/FmcOhZGFuZSdobyBaZHJhdm9ybWNrw71tIHphxZnDrXplbsWZbS9UxZllcsWZb3NvYm91CmJ5ISB2IHNvdWxhZHUgcyDDmsSNZWxlbSBHcmFudHU7CgouIHNlXGVjdCB0aGUgYXJlYSBvZlNwZWNcYVx0eSBhcyBtZHRjYXRlZCBtIHRoZSBHcmFudCBQdXJwb1NlIGFuZCBkZXRlcm1tZSB0aGUgYXBwcm9wbmF0ZSBcbmRcdlxkdWFcNXRvIGRldmVcb3AgYW5kCm1hbmFnZSB0aGUgXG5TdHd0dXR3b24nUyBwcm9ncmFtbWVTIC8genZvbMOtIG9ibGFzdCBzcGVjcmFoemFjZSB0YWssIGphayBqZSB1dmVkZW5hIHYgw5rEjWVsdSBHcmFucnUsIGEgdXZlZGUgcMWZw61zbHXFoW7DqQoKb3NvYnksIGt0ZXLDqSBidWRvdSBzZXN0YXZvdmF0IGEgxZnFmWRydCBwcm9ncmFteSBaZHJhdm9ybWNrZSdobyB6YcWZw616ZW7DrTsKCiAKCkVkdWNhdGlvbmFsIEdyYW50QWdyZWVtZW50X0Fwcml8IDIwMjQgUGFnZSAyIG9mIDEgMwoKT05JVCBudW1iZXIKCiAKCiAKCnN1cHBvcnQgMiBvZiBIQ1BzIHRvIGF0dGVuZCB0cmFtbWcgYXQgdGhlIEV2ZW50IGFueSBtYXkgbWR1ZGUgZXhwZW5zZXMgYXMgc2V0IG91dCBtIFNjaGVkTWUgMSAoIkV4cGVuNWU14oCcKSAvCnBlZHBlZmZ6IHpkcmF2b3RtY2tlJyBvZGJvcm7DrWt5LCBrcmXFmcWZc2Ugw7rEjWFzdG7FmcWha29sZW7FmXYgcsOhbWNyQWtjZSAmIF1lanJjaCB2w71kYWplIGJ1ZG91IGhyYXplbnkgcmFrLCBdYWsvZSB1dmVkZW5vCnYgUGlmL2XFvmUgNSAxIChkw6FsZSAsZWgg4oCednkvZWh5J3U7CgpyZWNvbmdlIE1lZHRyb21jJ3MgU3VwcG9ydCBtIGFIIHBybXRlZCwgZVxlY3Ryb21jIGFuZCBwdWJoc2hlZCBtYXRlaGF3cyByZWthdG1nIHRvIHRoZSBtZWR0Y8SPIHRyYW1tZyBhbmQKZWR1Y2F0d29uIGFjdHR2bWVTIHN1cHBvcnRlZCBieSB0aGUgR3JhbnQgLyB1dmVkZSBwb2Rwb3J1IHBvc2t5dG51dG91IHNwb2xlxI1ub3N0w60gTWVkdHJvbWMgdmUgdsWhZWNoIHJyxaFyxJtuw71jaCwKCmVsZWt0cm9tY2vDvWNoIGEgcHViaGtvdmFuw71jaCBtYXJlbsOhbGVjaCwga3RlcsOpIHNlIHTDvWthasWZbGUna2HFmXNrZSdobyB2emTEm2zDoXbDoW7FmWEgxaFrb2hjxZljaCBha3Jyd3QgcG9kcG/FmWVuw71jaCB2IHLDoW1jcgoKIAoKIAoKIAoKIAoKR3JhbnR1ClBBWU1FTlQvIMOaSFJBREEKUGF5bWVudCBUZXJtcyAvIFBheW1lbnQgd3dIIGJlIG1hZGUgd3d0aG0gNjAgZGF5cyBvZiB0aGUgZGF0ZSBvZiB0aGUgU3RnbW5nIG9mdGhlIEFncmVlbWVudCBieSBhSCBwYXJ0d2VzIC8gUGxhdGJhIGJ1ZGUgcHJvdmVkZW5hIGRvIDYwClBsYXRlYm7DrXBvZG3DrW5reSBkbsWvIG9kIGRhdGEgcG9kcHJzdSB0ZSd0byBTbWxvdXZ5IHbFoWVtISBzbWx1dm7FmW1yIHN0cmFuYW1yClRoZSBcbnN0d3R1dHdvbiBhZ3JlZXMgdGhhdCBcdCBzaGFIIGVcdGhlciAvIFpkcmF2b3RtY2tlJyB6YcWZw616ZW7FmXNvdWhsYXPFmXMgdMOtbSwgxb5lIGJ1xI86Ci4gZW5TdXJlIHRoYXQgYW55IHJlU3RkdcSPIG9yIGV4Y2VzcyBtb21lcyB0aGF0IGFyZSBub3QgdXNlZCBmb3IgdGhlIEdyYW50IFB1cnBvU2UgYXJlIHVzZWQgbSAmIG1hbm5lciBDb25TdFN0ZW50IHRoaAp0aGUgR3JhbnQgUHVycG9TZSBvciBhcmUgdXNlZCBmb3IgYW5vdGhlciBldmVudCBtIGhuZSB3dHRoIHRoZSBUZXJtUyBhbmQgQ29uZHR0dG9uUyBvZiB0aHdzIEFncmVlbWVudC8gemFqcnN0xZksIGFieQpdYWvDvWtvaCB6Ynl0ZWsgbmVibyBwxZllYnl0ZWsgZm1hbsSNbsWZY2ggcHJvc3TFmWVka8WvLCBrdGVyw70gbmVidWRlIHZ5dcW+cnIgaGEgw5rEjWVsIEdyYW50dSwgYnkhIHZ5dcW+cnR6cMWvc29iZW0sIGt0ZXLDvWplCnYgc291bGFkdSBzIMOaxI1lbGVtIEdyYW50dSwgbmVibyBieSEgcG91xb5ydCBoYSBkYWzFocWZYWtjciB2IHBvxZlhZMOtIHYgc291bGFkdSBzIFBvZG3FmW4ga2FtISB0w6l0byBTbWxvdXZ5Ci4gcmVwYXkgdG8gTWVkdHJvbWMgdGhlIGV4Y2VTUyBtb21lUyBub3QgdXNlZCBmb3IgdGhlIEV2ZW50IC8gd8OhdGYgc3BvbGXEjW5vc3QhIE1lZHJtbWMgcMWZZWJ5dGVrIGZtYWjEjWhmZWgKcHJvc3TFmWVka8WvLCBrdGVyw6kgbmVieWx5IG5hIEFrY3IgcG91xb5ydHkKUmVjaXBpZW50IGFuZCBQYXltZW50IHVuZGVyIHRoZSBHcmFudCB3d0ggYmUgcGF3ZCBieSBlXGVjdHJvbWMgZnVuZHMgdHJhbnNmZXIgbXRvIHRoZSBcblN0dHR1dHRvbidTIGRlc3dnbmF0ZWQgYWNjb3VudCBhcyBmb0hvd3MgLyBQbGF0YmEKTWV0aG9kIG9mIFBheW1lbnQgdiByw6FtY3IgR3JhbnR1IGJ1ZGUgdWhyYXplbmEgZWxla3Ryb21ja8O9bSBwxZlldm9kZW0gbmEgdXLEjWVuw70gw7rEjWV0WmRyYXZvdG5yY2tlJ2hvIHphaMW+ZW5mdGFrbToKCi8gUMWZw61qZW1jZSBhIHpwxa9zb2IKCsO6aHJhZHkgSW5zdGl0dXRpb24ncyBCYW5rIEFjY291bnQgRGV0YWlscyAvIFBvZHJvYm7DqSDDumRhamUgbyBiYW5rb3Zuw61tIMO6xI10dSB6ZHJhdm90bmlja8OpaG8gemHFmcOtemVuw60KQWNjb3VudCBob1xkZXI6IEtyYUpTa8OhIG5lbW9jbWNlIEx0YmVyZWMsICYgNQpCYW5rOiBLb21lcsSNbnQgYmFua2EsIGEgcwpBY2NvdW50TnVtYmVyOiAzNjYzMTQ2MS8wMTAwClZhbmFiXGUgU3ltYm9oIDIzMDA0CgpTb3J0L1NXSMONVCBDb2RlOiBLT01CQ1pQUAoKIAoKIAoKIAoKIAoKIAoKXEJBTjogQ1o5NjAxMDAwMDAwMDAwMDM2NjMxNDYxClNwZWNpYWwgQ29uZGl0aW9ucyAvIE5vbmUvIE5FSlNPVQpadmzDocWhdG7DrSBwb2Rtw61ua3kKVGVycml0b3J5IC8gw5p6ZW3DrSBDemVjaCBSZXB1IGJoYwpFeGVjdXRpb24gLyBQb2RwaXN5CgpUaGUgdW5kZXJTdGduZWQgcmVwcmVzZW50YXR3ZSByZXByZVNlbnRTIGFuZCB3YXJyYW50UyB0aGF0IGhlL3NoZSBcNSBxdXkgYXV0aG9uc2VkIHRvIGFjdCBvbiBiZWhhdGYgb2YgdGhlIFxuU3R0dHV0dG9uIHRoaCByZWdhcmQgdG8gdGhlCgpBZ3JlZW1lbnQgYW5kIFx0UyBTdWJqZWN0IG1hdHRlciwgd3d0aG91dCBmdXJ0aGVyIGFwcHJvdmF3IC8gTsOtxb5lIHBvZGVwc2Fuw70gesOhc3R1cGNlIHByb2hsYcWhdWplIGEg4oCe4oCeYS9lLCDFvmUgamUgcGxuxJsgT3Byw6F2bsWhbi9hIGJleiBkYWzFocOtY2gKCnNjaHbDoWxlbsWZamVkbmF0IHZlIHZ6dGFodSBrIHTDqXRvIFNtbG91dsSbIGEgamVqw61tdSBwxZllZG3Em3R1IHYgemFzdG91cGVuxZl6ZHJhdm90bnJja2UnaG8gemHFmcOtemVuw60KCiAKClN0Z25hdHVyZSAvIFBvZHByczogKgoKTmFtZSAvSm1lJ25vOgoKRGF0ZSAvIERhdHVtOgoKIAoKdGh0ZSAvIEZ1biBrY2U6CgpLcmFqc2vDoSBuZW1vY25pY2UgTGliZXJlYywgYQoKLnMuIE1lZHRyb25pYyBDemVjaGlhIHMuci5vIF8gRMOtZ2l0YWxseSBzaWduZWQKYnkKLCDigJ4gU3dnbmF0dXJlL1BvZHByczoKQnRncnTigJRhaGVwb2RlcHNhbCBEYXRlOgoyMDI1MDcyMwoKTmFtZSAvIEptw6luIG86ClRhbW7DrTogMjAyNTA4MDEgMjE6MDM6MTUgKzAyJzAwJwoxNDozMzowMCArMDIwMAoKRGF0ZSAvIERhdHVtOgoKIAoKIAoKdGh0ZSAvIEZ1bmtjZTogUHJva3VyYQoKIAoKXG4gdGh0UyBBZ3JlZW1lbnQgcmVmZXJlbmNlIHRvIHRoZSAiCgpNZWRUZWNoIENvZGXigJwgc2hhSCBtZWFuIHRoZSBNZWRUZWNoIEV1cm9wZSBDb2RlIG9mIEJ1c21lc3MgUHJhY3R0Y2UgYW5kICJDVlMiIHNoYUggbWVhbiB0aGUgRXRod2NhdAoKTWVkVGVjaCBDb25mZXJlbmNlIFZldHRtZyBTeXN0ZW0gTWVkVGVjaCBFdXJvcGUsIENvZGUgb2YgQnVzbWVzcyBQcmFjdHRjZSBodHRnczovL3d3dyBtZWR0ZWNoZXVyb2dlIG9yZy93Z3IKCmNvbnRlbnQvdXBcb2FkUy8yMDE3L0/Dsy9jb2Rlcm1hcjcyMDI0IHBkZiBFdGh3Y2F0IE1lZFRlY2ggQ29uZmVyZW5jZSBWZXR0bWcgU3lzdGVtIGh0dHA6Ly93d3cgZXRod2NhdG1lZHRlY2ggZXUgLwoKVnRlJ3RvIFNtbG91dsSbIG9ka2F6IG5hIOKAnktvZGV4IE1lCgpkcmVjaCAiem5hbWVuw6EgS29kZXggcG0gb2JjaG9kbsWZcG9zdHVweSBzcG9sZcSNbm9zdCEgTWVkVGVjaCBFdXJvcGUgYSDigJ5DVlMiWm5hbWVuw6EgRXJocmNhISBNZWRUZWNoCgpDb25mZXJlbmNlIFZlbW5nIFN5c3RlbSBzcG9sZcSNbiBlc24gTWVkVGVjaCBFdXJvcGUsIEtvZGV4IHBybyBvYmNob2Ruw60gcG9zdHVweSBodHRnczovL3d3dyBtZWR0ZWNoZXVtZ2UgbWcvd2dlCmNlbnRlaHQvdWdyZWFkcy96bzE3LzDDsy9lZWRlZW1haHpvejQgUWRmIEVyaHJjYSEgTWVkVGVjaCBDb25mZXJlbmNlIFZlbW5nIFN5c3RlbSBobmd3d3d3IGVyaHJjYWxtZWRyZWNoIGV1IC8KCkVkdWNhdGlvbmFsIEdyYW50QWdyZWVtZW50X0Fwcml8IDIwMjQKT05JVCBudW1iZXIKCkZhZ2Uzb20zCgogCgogCgogCgozLiBURVJNUyBBTkQgQ09ORElUSU9OUyAzLiBQT0RNw41OS1kKXHQgXFMgYWdyZWVkIGFzZm9Ib3dzOiBVSmVkaMOheWFoIFNlIHR5dG8gcG9kbW1reToKMS4gR3JhbnQgUHVycG9zZSAxIC4gJyDEjWVsIEdyYW50dQoxIDEgVGhlIEdyYW50IFxTIHBhcnQgb2YgTWVkdHJvbWMncyBvbmdvbWcgU3VwcG9ydCBvZiBtZGVwZW5kZW50LCAxIDEgR3JhbnR5ZSBTb3XEjcOhU0ggcHLFr2LEm8W+bsOpIHBvZHBvcnlTcG9cZcSNbm9TdFwgTWVkdHJvbWMgcG9Ta3l0b3ZhbsOpCmVkdWNhdG1hdyBhbmQgc2VlaHRtYyBwdXJwb1NlU3dod2NoIHByZW1ldGVzZWVodHRmdGMga25vd1xlZGdlLCBoYSBoZXrDoXl0c3dlLCB2emTEm1zDoXZhYyggJiB2xJtkZWNrw6kgw7rEjWVceSwga3RlcmUgcG9kcG9taCB2xJtkZWNrw6kKbWVkXGNhXCBhZHZhbmNlbWVudCBhbmQgZGVodmVyeSBvZiBlZmZlY3R3dmUgaGVhXHRoY2FyZSBhbmQgbWF5IHBvem5hdGt5LCBtZWR0Y21za3kgcG9rcm9rICYgcG9za3l0b3bDoW0gZWZla3R0eWh0IHpkcmF2b3RtIHDDqcSNZSwgJgptZHVkZSBIQ1AgYXR0ZW5kYW5jZSBjb3N0cyBtxa/FvmUgemFocm5vdmF0IG7DoWtcYWR5IG5hIMO6xI1hc3QgemRyYXZvdG1ja2VobyBvZCBib3JtL2thIG5hIGFrZGNoCjEgMiBUaGUgXG5zdHd0dXR3b24gd3dIIG1ha2UgYW4gbWRlcGVuZGVudGFuZCBcbXBhcnRtIGRlY3dzd29uIGFzdG90aGUgMSAyIFpkcmF2b3RtY2tlIHphxZl3L3plbS8gdcSNbXQgbmV6w6F2bWUgYSBuZXN0cmFubsOpIHJvemhvZG51dHcvICgpIHDFmXdkxJtcZW4oCmFob2NhdG0gb2YgdGhlIEdyYW50IGZvciB0aGUgR3JhbnQgUHVycG9TZSBhbmQgdGhlIFNlXGVjdFxvbiBvZiBhbnkgcHJvc3TFmWVka8WvIHogR3JhbnR1IHBybyDDmsSNZVwgR3JhbnR1ICYgb3bDvWLEm3J1IHlha3knY2hrZWggb3NvYiwgdnllaGNoxb4KYmVuZWhtYXJ5IG9mIHRoZSBHcmFudCwgdGhoIOKAnjAgcGFtbXBhaG9uIG9yIFxuSHVlbmNlIGJ5IE9yIGVuIHByb1NwxJtjaCBidWRlR3JhbnR2eXXFvXd0LCBhdG8gYmV6IMO6xI1hc3R3IMSNdHloeXUgNXBvXGXEjW4wNXRcIE1lZHRyb21jCmJlaGFIb2YgTWVkdHJvbWMsIG0gYW55IGRlY3RzdHRtIGFzIHRvIHdod2NoIG1kdHdkdWF3cyBvZiBhbnkpIG1heSBuZWJvIOKAnmVobSB6YVN0b3VwZW0gcGggSmFrw6lta29oIHJvemhvZG51dHQgKCkgcGhwYWRoeWNoCmJlaGVmdHRmcmVtIHRoZSBHcmFudCBKZWRub3RodmRjaCwga3RlSCBtb2hvdSB6IEdyYW50dSDEjWVycGF0CjEgMyBUaGUgZm1haGVhdyBzdXBwb3J0IFxTIHByb3dkZWQgdW5kZXIgdGhlIHVuZGVyU3RhbmRtZyB0aGF0OiAxIDMgRm1haMSNbSBwb2Rwb3JhIFNlIHBvc2t5dHV5ZSBoYSB6w6FsZGFkxJsgdXllZGjDoWh0b3RvbSwgxb5lOgouIFxuZXR0dHV0dG9uIFxTIGVudHdkZWQgdG8gcmVjZXR5ZXRodHNmbWFoY3RhdyBTdXBwb3J0OyAuIFpkcmF2b3RtY2vDqSB6YWh6ZWh0eWUgZXByw6F5aGVob3R1dGVmbWFoxI1tIHBvZHBvcnUgb2JkcsW+ZXQ7Ci4gdGhlIEdyYW50Y29tcGhlUyB0aGggdGhlIFxoc3R0dHV0bSdzb2J5ZWN0dHllcyBkZXNjbmJlZCBtdGhlIC4gR3JhbnRzcHdodXllIGNIZVpkcmF2b3RtY2vDqWhvIHphaHplaHRwZXBzYWhlIHZlc3Rhbm92w6FjaDsKQW1kZXMgb2YgQXNzb2N3YXR3b247Ci4gXFMgc29cZVx5IGRlZHdjYXRlZCB0byBTdXBwb3J0IHRoZSBHcmFudCBQdXJwb1NlOyAuIHllIHVyxI1lbmEgdsO9aHJhZG7EmyBuYSByZWFoemFlIMOaxI1lbSBHcmFudHU7Ci4gXFMgaGV0IGNvbm5lY3RlZCB0byB0aGUgcHVyY2hhU2Ugb2YgTWVkdHJvbWMgcHJvZHVjdFM7IC4gbmVzb3V5dHN0cyBuw6FrdXBlbSBwcm9kdWt0xa8gNXBvXGXEjW4wNXRcIE1lZHRyb21jOwouIFxTIGhldCB1c2VkIGZvciBhbnkgcGVyU29uYVwgb3IgbXllc3RtZWh0IHB1cnBvU2VTIG9yIG0gYW55IHdheSAuIGhlaHR5eXXFvnR0YSBwcm8gxb7DoWRuZSBvU29ibSBhbSBteWVzdHTEjW0gw7rEjWVceSBhbSDFvsOhZG7DvW0g4oCebsO9bQp0aGF0IFxTIGhldCBtIGRccmVjdGZ1cnRoZXJhbmNlIG9mIHRoZSBHcmFudCBQdXJwb1NlOyBhbmQgenDFr1NvYmVtLCBrdGVyw70gbmVodHkgcGhtZW0gc29NYWR1IDUgw5rEjWVcZW0gR3JhbnR1OyAmCi4gXHQgd20gaGV0IGJoaGcgYmVoZWZ0dHMgdG8gYW55b25lIHRoYXQgXFMgcHJvaFxiXHRlZCB1bmRlciBhbnkgLiBuZXDFmW1lU2UgcHJvU3DEm2NoIG1rb211LCBrZG8gcGF0aCBwb8SPZSB5YWtlaGVrb2gKYXBwXFxjYWJcZSBcYXdzIHJvemhvZG7DqWhvIHByw6F2YSBrIHpha8OhemFuw71tIHN1Ynlla3RhbQoxIDQgTWVkdHJvbWMgc2hhSCBub3QgYmUgaGFiXGUgZm9yIGFueSB0YXhlcyBtIHJlXGF0XG9uIHRvIHRoZSBHcmFudCBcZiAxIDQgU3BvXGXEjW4wNXQgTWVkdHJvbWMgbmVuZXNlIG9kcG92xJtkbm9zdCB6YSDFvsOhZG5lIGRhbsSbIHTDvWthaGN0IFNlCk1lZHRyb21jdHNyZXFtcmVkIGJ5XGF3dG8gcGF5dGhldGF4ZXMgT3J0byB3dHRoaG9oaSBhbnkgYW1vdW50UyBHcmFudHUgSmVzdGjFvmUgeWUgc3BvXGXEjW5vc3QgTWVkdHJvbWMgemUgesOha29uYSBwb3ZtbmEgemFtYXR0dApmcm9tIHRoZSBHcmFudHRvIHBheXRvd2FyZFNhbnlTdWNoIHRheGVzLCB0aGUgXG5ldHR0dXR0b24gYWdyZWVzdGhhdCB6R3JhbnR1IGRhbsSbIG5lYm8gU3LDocW+ZXQgem5leSBKYWtla29oIMSNw6FzdGt5IG5hIHBla3J5dHQgeWFreSdjaGtlaApNZWR0cm9tYyBtYXkgdGhoaGV3ZCBzdWNoIHRheGVzIGZyb20gdGhlIHBheW1lbnQgb2Z0aGUgR3JhbnQgdGFrb3bDvWNoIGRhbSwgc291aHdhc3QgWmRyYXZvdG1ja2UgemHFmXcvemVtLyBzdHRtLCDFvmUgeWUgNXBvXGXEjW4wNXQKTWVkdHJvbWMgb3Byw6F2bsSbbmEgU3Jhend0dGFrb3bDqSBkYW7EmyB6IHZ5cGthY2Vuw6lobyBHcmFudHUKMSA1IEFueSBHcmFudCBwcm93ZGVkIGJ5IE1lZHRyb21jIG1heSBlaHd5IGJlIHVzZWQgdG8gY292ZXIgcGF5bWVudFMgMSA1IEpha8O9a29oIEdyYW50IHBvc2t5dG51dMO9IDVwb1xlxI1uMDV0KCBNZWR0cm9tYyB5ZSBtb8W+bsOpIHBldcW+dHQgcG91emUKd2h3Y2ggYXJlIG0gYWNjb3JkYW5jZSB0aGggdGh0cyBBZ3JlZW1lbnQgYW5kIG1heSBub3QgYmUgdXNlZCB0byBwcm8gcG9rcnl0dCBwXGF0ZWIsIGt0ZXJleXNvdSB2c29NYWR1IHN0b3V0byBTbWttdm91LCAmIGhlaHRtZcW+aGV5ZXkKcHJvd2RlIGFueSB1bmR1ZSBiZWhlZnR0cyB0byBhbnlvbmUgcG91xb50dCBoYSBwZXNreXRudXR0eWFreSdjaGtvaCBoZXBhdGjEjWh5J2NoIGJlbmVodMWvIEpha2Vrb2ggb3NvYsSbCjIuIFRyYW5zcGFyZW5jeSAyLiBUcmFuc3BhcmVudG5vc3QKMjEgTWVkdHJvbWMgd3dIIGNvbXBceSB3d3RoIGFIIGFwcGhjYXTDumUgXGF3cywgcmVnTWF0d29ucyBhbmQgMjEgU3BvXGXEjW5vc3RNZWR0cm9tYyBidWRlIGRvZHLFvm92YXR2xaFlY2hueSBwxZl0c03FoW7DqXrDoWtvbnksIHDFmWVkcHdzeQphcHBcXGNhYlxlIGdvdmVybm1lbnQgb3IgbWR1c3RyeSBnbWRlaG5lUyB0aGggcmVnYXJkIHRvICYgdnp0YWh1aGN0IFNlIHN0w6F0bnQgbmVibyBvYm9yb3bDqSBTbcSbcm1jZSB2ZSB2enRhaHUgayB0cmFuU3BhcmVudG5vU1UKdHJhblNwYXJlbmN5IG9mIHBheW1lbnQsIG1kdWRtZyB0aGUgTWVkVGVjaCBDb2RlIChoZXJlYWZ0ZXIsIHBcYXRlYix2xI1ldG7EmyBLb2RleHUgTWVkVGVjaChkw6FcZSBlem5hxI1veWFoZXllaHlha2XigJ5Qb8W+YWRhdmt5IGhhCiJUcmFuU3BhcmVuQ3kgUmVxbXJlbWVudMSPKSBcbmV0dHR1dHRvbiB0aGVyZWZvcmUgYWdyZWVTIHRoYXQgdHJhblNwYXJlbnRub1N0IikgWmRyYXZvdG1ja2UgemHFmXcvemVtLyBwcm90b3NvdWh3YXN0c3R0bWllc3Bld2XEjWhlc3QKTWVkdHJvbWMgbWF5IGRcU2RvU2UgbWZvcm1haG9uIHJla2F0bWcgdG8gdGhlIEFncmVlbWVudCB0byB0aGUgTWVkdHJvbWMgeWUgb3Byw6F2bsSbbmEgZWRoYWh0IG1mb3JtYWNlIHTDvWthaGQgU2UgdGV0byBTbWJ1dnkKZXh0ZW50IHJlcW1yZWQgdW5kZXIgdGhlIGFwcFxcY2FiXGUgVHJhblNwYXJlbmN5IFJlcW1yZW1lbnRTLCB2cm96c2FodSBwb3Zhxb5vdmFuw6ltIHBvZFxlIHBIU03FoW7DvWNoIFBvxb5hZGF2a8WvIG5hdHJhblNwYXJlbnRub1N0LAptZHVkbWcgZFxTZG9TdXJlIG9uIHRoZSBFdGh3Y2FcIE1lZFRlY2ggd2Vic3d0ZSBTdWNoIG1mb3JtYWhvbiB2xI1ldG7EmyB1dmXFmWV5aGVodCBuYSB3ZWJvdsO9Y2ggc3Ryw6Fua8OhY2ggRXRod2NhXCBNZWRUZWNoIFR5dG8KbWF5IG1kdWRlIHd3dGhvdXQgaG13dGF0d29uLCBcbnN0d3R1dHdvbidzIG5hbWUsIHZhaGplIG9mIGFtb3VudHMgbWZvcm1hY2UgbW9ob3UgemFocm5vdmF0IHplam1lbmEgbsOhemV2IFpkcmF2b3RtY2tlaG8gemHFmXcvemVudCwKdHJhblNmZXJyZWQsIGFuZCBuYXR1cmUgb2YgdGhlIGZtYWhjdGF3IFN1cHBvcnQgaG9kbm90dSBwxZlldsOhZMSbbsO9Y2ggxI3DoXN0ZWsgJiBjaGFyYWt0ZXJmbWFoxI1tIHBvZHBvcnkKMiAyIFxuU1V0cXVuU2hhSCwgcHJvd2RlYUggbmVjZXNzYXJ5bWZlcm1hdHRlaCBhbmQgZG9jdW1lbnRhdHRlaCB0byAyIDIgWmRyYXZvdG1ja2UgemHFmXcvemVtLyBwb3NreXRuZSB2xaFlY2hueSBwb3TFmWVibsOpIG1mb3JtYWNlICYKYUhvdyBNZWR0cm9tY3RvIGNvbXB3IHRoaHRoZWFwcGhjYWJ3ZSBcZWdhXCByZXFtcmVtZWh0c3lodGhtIGRva3VtZW50ZW0sIGt0ZXJlIDVwb1xlxI1uMDV0XCBNZWR0cm9tYyB1bW/Fvmh0IG5hcGh3dCBwxZkoNVx1xaFuw6kKdGhlIFVtZWhuZVMgZGVzY25iZWQgbSBTY2hlZE1lIDIgWsOha29ubsOpIHBvxb5hZGF2a3kgdmUgXGjFr3TDoWNoIHBvcFNhbsO9Y2ggdiBQxZlIb3plIMSNIDIKMjMgVGhlXG5TdHd0dXR3b25tdVN0a2VlcHRyYW5TcGFyZW50LGFjY3VyYXRlIGFuZCBjb21wXGV0ZXJlY29yZDUwZiAyIDMgWmRyYXZvdG1ja2UgemHFmXcvemVtLyB5ZSBwb3Ztbm8gdmVzdCB0cmFuc3BhcmVodG0sIHByYXZkd8OpICYgdXB3aGUKCkVkdWNhdGlvbmFsIEdyYW50QWdyZWVtZW50X0Fwcml8IDIwMjQKT05JVCBudW1iZXIgNDAyNDQxNTgKCiAKCkZhZ2U0ZW0zCgoyNAoKMjUKCjI2Cgp0aGUgR3JhbnQsIHRoZSBhcHBoY2Ftb24gb2YgdGhlIEdyYW50IGFuZCBhbnkgZXhwZW5kMXR1cmUgdVNtZyB0aGUKR3JhbnQgd2gxY2ggbXVTdCBiZSBtIGFjY29yZGFuY2UgdzF0aCB0aGUgTWVkdHJvbWMgQnVzbWVzcwoKQ29uZHVjdCBTdGFuZGFyZHMgYXMgc2V0IG91dCBtIFNjaGVkdXRlIDMKCkFmdGVyIHRoZSBFdmVudCwgdGhlIFxuNXQxdHV0MW9uIHNoYUgsIG0gYWNjb3JkYW5jZSB3MXRoIHRoZSBNZWR0ZWNoCkNvZGUgYW5kIGFwcFwxY2FiXGVUcmFuNXBhcmVuY3kgUmVxdTFyZW1lbnQ1LHByb3YxZGUgdG8gTWVkdHJvbWMKb25lIDUxbmdcZSByZXBvcnQgZGV0YW1uZyBwZXIgYXR0ZW5kZWUgdGhlIHVzZSBvZiB0aGUgR3JhbnQgYW5kCmFkZXF1YXRlIGRvY3VtZW50YXQxb24oZSBnIGNvbWVzIG9mIGJvb2ttZyBkb2N1bWVudDU7Y29wMWVzIG9mCnRyYW5zcG9ydCB0MWNrZXRzLCBjb25ncmVTUyByZWcxNXRyYXQxb24pdmVyMWZ5MW5nIHRoYXQgdGhlIEdyYW50IHdhcyB1c2VkCgptIGFjY29yZGFuY2UgdzF0aCB0aGUgdGVybVMgYW5kIGNvbmRtb25zIG9mIHRoMXMgQWdyZWVtZW50CgpUbyB0aGUgZXh0ZW50IHRoYXQgTWVkdHJvbWMgMTUgcmVxbXJlZCBieSBhbnkgYXBwXDFjYWJcZSBcYXdzIG9yCmF1dGhvcjF0MWVzLG9yIGFueSBvZjF0czFudGVybmFcIHJlZ3VcYXRvcnksdGF4IG9yIGF1ZG1oZyBvYmhnYW1vbnN0bwpzaG93IHRoYXQgdGhlIEdyYW50IDE1IG1hZGUgbSBhY2NvcmRhbmNlIHcxdGggYXBwXDFjYWJcZSBcYXdzLAptZHVkbWcgTWVkVGVjaCBDb2RlLCB0aGVuIFxuNXQxdHV0MW9uIHNoYUggcHJvd2RlIE1lZHRyb21jIG9yMXQ1CmFwcG9tdGVkIHRoMXJkIHBhcnR5IGFnZW50UywgcG9TdCBFdmVudCByZXdldyBhbmQgdmVyMWYxY2F0MW9uIGF1ZDF0Cm5naHRzIG0gcmVcYXQxb24gdG8gRXhwZW5TZVMgbWN1cnJlZCBhbmQgL29yIHRoZSB1c2Ugb2YgdGhlIEdyYW50Cgpjb25zMXN0ZW50MXkgdzF0aCB0aGUgR3JhbnQgUHVycG9zZQoKVGhlIFxuc3QxdHV0MW9uIFNoYUggY29tcDF5IHcxdGggYUggcmVhU29uYWJcZSByZXF1ZTV0NSxkMXJlY3Qxb241IGFuZAptb210b3JtZyByZXFtcmVtZW50UyBvZiBNZWR0cm9tYyBhbmQgU2hhSCBnZW5lcmFIeSBjb29wZXJhdGUKdzF0aCBhbmQgYXNzZXQgTWVkdHJvbWMgbSBzdWNoIHJld2V3cyBNZWR0cm9tYyBTaGFIIHByb3dkZSBhdApcZWFzdCB0aDFydHkgKDMwKSBkYXlzJyBub3QxY2UgdG8gdGhlIFxuc3QxdDB0MW9uIG9mIGFueSByZXdldyB1bmRlciB0aGUKCkFtZGUgdGhhdDF0IHBcYW41IHRvIENvbmR1Y3QKClNlcGFyYXRpb24gcHJpbmNpcGxlCgoyNAoKMjUKCjI2Cgp6w6F6bmFteSAoKSBHcmFudHUsIEplaG8gdnl1xb4xdDEgJiBKYWvDvWNoa29oIHbDvWRhaGNoIGhyYXplbsO9Y2gKCnpncmFudG92w71jaCBwcm9zdMWZZWRrxa8sIGt0ZXLDqSBtdTUxIGLDvXQgdnNvTWFkdSBTZSBTdGFuZGFyZHkKCm9iY2hvZGh0aG1lZGjDoWh0c3A2MWXEjWhvc3QxIE1lZHRyb21jIDV0YW5vdmVuw71tMSB2IFDFmUhvemUgxI0gMwoKUG8ga29uw6FudCBBa2NlIFpkcmF2b3RtY2vDqSDFvmFoxb5lbSB2c29NYWR1IDUgS29kZXhlbSBNZWR0ZWNoICYKcMWZMTVcdcWhbsO9bTEgUG/FvmFkYXZreSBuYSB0cmFuU3BhcmVudG5vU3QgcG9Ta3l0bmUgNXBvXGXEjW4wNXQxIE1lZHRyb21jCkplZG51IHpwcsOhdnUgdXbDoWTEm2hjdCBwb2Ryb2Juw6kgw5pkYWplICgpIHZ5MMW+MXQxIEdyYW50dSBoYSBKZWRub3RodsOpCsO6xI1hc3RudGt5ICYgcEhTbcWhbm91IGRva3VtZW50YWMxKG5hcMWZIGtvcDFlIHJlxb5ld2HEjWh0Y2ggZG9rdW1lbnTFrzsKa29wMWUgw7rEjXRlbmVrICYgSnR6ZGVuZWsga2Nlc3Rvdm7DqW11OyByZWcxNXRyYWMxIGhhIGtvbmdyZVMpLCBKZcW+Cgpkb2t0w6Fkw6EsIMW+ZSBieTEgR3JhbnR2eXXFvjF0diBzb01hZHUgNSBwb2RtbWthdyB0ZXRvIHNtMTYwdnkKClZyb3pzYWh1LCB2bsSbbcW+IEpha2Vrb2ggYsWZZW1lbmUgesOha29ueSBuZWJvIMO6xZlhZHkgbmVibyBrdGVyw6lrb2gKxb4xZTExY2ggbXRlcm50Y2gsIHJlZ3VcYcSNbjFjaCwgZGHFiG92w71jaCBuZWJvIGF1ZDF0b3I1a8O9Y2ggcG92bW5vU0gKcG/FvmFkdWp0LCBhYnkgc3A2MWXEjWhvc3QgTWVkdHJvbWMgcHJva8Ohxb5hYiwgxb5lIFNlIEdyYW50IHBvc2t5dHVqZQp2c29NYWR1IHNwxZkxNVx1xaFuw71tMSB6w6Frb255ICYgcMWZZWRwMTV5LCB2xI1ldG7EmyBLb2RleHUgTWVkVGVjaCwKcG9za3l0bmUgWmRyYXZvdG1ja8OpIMW+YWjFvmVtIDVwb1xlxI1uMDV0MSBNZWR0cm9tYyBuZWJvIDExIEptZW5vdmFuw71tCnTFmWV0dG0gb3NvYsOhbSB2IHBvejFjMSB6w6FzdHVwY8WvIHByw6F2YSDigJ5hIGtvbnRyb20gJiBvdmXFmWVodCBwbyBBa28gdmUKdnp0YWh1IGtlIFbFvm1tw71tIHbDvWRhasWvbSBhL25lYm8gdnkwxb4xdDEgR3JhbnR1IHZzb01hZHUgNSDDmsSNZTFlbQoKR3JhbnR1CgpaZHJhdm90bWNrZSDFvmFoxb5lbSBzcHcgdsWhZWNobnkgb2TFr3ZvZG7Em27DqSDFvsOhZG9zdDEsIHBva3lueSBhCnBvxb5hZGF2a3kg4oCeYSBtb210b3JtZyA1cG9cZcSNbjA1dDEgTWVkdHJvbWMgJiB2xaFlb2JlY27EmyBidWRlIFNlCnNwNjFlxI1ob3N0MU1lZHRyb21jIHDFmTFrb250cm9cw6FjaCBTcG9tUHJhY292YXQgJiBidWRlanRuw6Fwb21vY25vCjVwNjFlxI1ob3N0IE1lZHRyb21jIHBvc2t5dG5lIFpkcmF2b3RtY2vDqW11IMW+YWjFvmVtIG96bsOhbWVodCAoKQpKYWtla29oIGtvbnRybWUgcDY2MWUgdG9ob3RvIGHDoWhrdSwga3Rlcm91IG3DoW1lIHByb3bDqVN0LCBhMWVzcDZoCgp0xZkxY2V0KDMwKWRuMXDFmWVkZW0KClrDoXNhZGEgc2Ftb3N0YXRub3N0aQoKIAoKMzEKCjMyCgozMwoKVGhlIHBhbWVzIGFja25vTWVkZ2UgYW5kIGFncmVlIHRoYXQgdGhlIEdyYW50IGFuZCB0aDFzIEFncmVlbWVudAoKZG8gbm90IGFuZCBhcmUgbm90IG10ZW5kZWQgdG86CgooYSkgY29uc3QxdHV0ZSBhbnkgbWR1Y2VtZW50IHRvIG9idGFtIG9yIHJldGFtIGJ1NTFuZTU1LG9yIGd3ZSDigJ5zZQp0byBhbnkgb2JoZ2F0bSwgZm9yIHRoZSBcbjV0MXR1dDFvbiB0byAob3IgY3JlYXRlIGFueSBleHBlY3RhdG1oCnRoYXQgdGhlIFxuNXQxdHV0MW9uIHcxSCkgcHVyY2hhc2UsIFxlYVNlLCByZWNvbW1lbmQgb3IgdWdlIChvcgphcnJhbmdlIGZvciB0aGUgcHVyY2hhU2UsIFxlYXNlLCByZWNvbW1lbmRhaG9uIG9yIHVTZSBvZikgYW55Ck1lZHRyb21jIHByb2R1Y3RTIG9yIFNlcndjZVMgb3Igb3RoZXJ3MXNlIHRvIGVudGVyIG10byBvciBleHRlbmQKYW55IGJ1U21lU1MgdHJhblNhY3Qxb24obm93IG9yIG0gdGhlIGZ1dHVyZSkgdzF0aCBNZWR0cm9tYyBvcgoKYW55IG9mIDF0NSByZVxhdGVkIGVudDF0MWU1OyBvcgoKKGIpIFxuSHVlbmNlIG0gYW55IHdheSBhbnkgcHJvY2VTUyBvciBkZWMxczFvbiBieSB0aGUgXG41dDF0dXQxb24KCnJla2F0bWcgdG8gYW55IHBvdGVudDFhXCBwdXJjaGFTZSwgXGVhc2UKCihjKSByZWNvbW1lbmRhaG9uIG9yIHVzZSBvZiBhbnkgTWVkdHJvbWMgcHJvZHVjdFMgb3Igc2Vyd2NlcywKbWR1ZG1nIGFueSBwcm9jdXJlbWVudCBwcm9jZWR1cmUgb3IgcG5jZSBTdHJ1Y3R0bW5nCgphcnJhbmdlbWVudAoKQW55IG1mb3JtYW1vbiByZWdhcmRtZyBwcm9kdWN0UyBtYW51ZmFjdHVyZWQgYnkgTWVkdHJvbWMgb3IgYnkKb3RoZXIgbWFudWZhY3R1cmVyUyBTaGFIIGJlIG9iamVjdHdldyBwcmVTZW50ZWQgYW5kIHNlMWVjdGVkLCB3MXRoCmZhdm91cmFiXGUgYW5kIHVuZmF2b3VyYWJcZSBtZm9ybWFtb24gbWR1ZG1nICYgZFxTY3VTbW9uCnJlZ2FyZG1nIGFIIOKAnjVrcyBhbmQgYmVuZWYxdDUsIGFrbWcgdzF0aCBiYVxhbmNlZCBkXHNjdXNzbW4gb2YKcHJldmFtbmcgbWZvcm1hdG1uIG9uIFN1Y2ggcHJvZHVjdFMgYW5kIGFcdGVybmF0MXZlcyBMMW0xdGF0MW9uNSBvbgpyZVN0TXRTIHByZVNlbnRlZCBTaGFIIGJlIDFkZW50MWYxZWQsIGVnLCBvbmdvbWcgcmVTZWFyY2gsIG10ZWhtCmFoYTF5c2VzLCBwcmVobW1hcnkgZGF0YSwgb3IgdGh1cHBvcnRlZCBvcDFuMW9uIEFueSB1bmFwcHJvdmVkCgp1U2VTIG9mIHByb2R1Y3RTIFNoYW4gYmUxZGVudDFmMWVkIGFTIHN1Y2gKCk1lZHRyb21jIGhhcyBhZG9wdGVkIG9iamVjdHdlIGNudGVuYSBtIGRlb2RtZyB0byBtYWtlIHRoZSBHcmFudAoKdGhhdCBkbyBub3QgdGFrZSBtdG8gYWNjb3VudCB0aGUgdm9tbWUgb3IgdmExMGUgb2YgYW55IHB1cmNoYVNlUyBvZgoKRWR1Y2F0aW9uYWwgR3JhbnRBZ3JlZW1lbkxBcHJpbCAyMDI0Ck9OSVQgbnVtYmVyCgogCgozMQoKU210dXZudCBzdHJhbnkgYmVyb3UgbmEgdsSbZG9tdCBhIHNvdWh0YXN0IHMgSG0sIMW+ZSBHcmFudCBhIHRhdG8gU210b3V2YQoKbmVwxZllZHN0YXZ1aCAmIG5lbWFoIHDFmWVkc3Rhdm92YXQ6CgooYSkgxb7DoWRub3UgcG9idGRrdSBrenRza8OhbnQgbmVibyB1ZHLFvmVudCA1MSBvYmNob2RudCBwxZlIZcW+MXRvc3QxCgpuZWJvIFZ6bWt1IEpha8OpaG9rb2ggesOhdmF6a3UsIGFieSBaZHJhdm90bWNrZSDFvmFoxb5lbQpuYWt1cG92YWspLCBwcm9uYW1hYiwgZG9wb3J1xI1vdmFrKSBuZWJvIHA2MMW+MXZhMTYgSmFrZWtvaApwcm9kdWt0eSBuZWJvIHNtxb5ieSA1cG9cZcSNbjA1dDEgTWVkdHJvbWMgbmVibyB1emF2xZllaykgbmVibwpwcm9kYnXFvm5vcGtvdWtvaCBvYmNob2RtbWhzYWtlIFNlIHNwbzFlxI1ub2V0MU1lZHRyb21jCm5lYm8g4oCeYWvDvXdrb2ggbW0gcXVlaMO9dyBzdWJqZWt0eSwgYcWlIOKAnsW+IG15bTsgbmVibwp2YnVkb3VjbnUsIHBocGFkaGUgYWJ5IMW+YWhzdG5vIEplcGNoIG7DoWt1cCwgcHJvbsOhamVtLApkb3BvcnXEjWVtIG5lYm8gcG91xb50dsOhbSwgbmVibyBhYnkgVsW+bW1vIG/EjWVrw6F2w6FtLCDFvmUgdGFrCgpaZHJhdm90bWNrZSB6YcWZdHplbnQgdcSNbXQ7IG5lYm8KCihiKSBKYWtla29oIDZ2MTFWaGVoMTFha2VoNms2MTEgcHJvY2VTdSBuZWJvIHJvemhvZG51dHQgemUgc3RyYW55ClpkcmF2b3RtY2tlaG8gxb5haMW+ZW0gdiBzb3V3c2JzbSDigJ5ha8O9bWtvaCBwb3Rlbm/DoW10bQpuw6FrdXBlbSBhIHByb27DoWptZW07IG5lYm8KCihjKSBwb3NreXRudXR0IGRvcG9ydcSNZWh0IG5lYm8gMMW+MXbDoW4xIEpha8O9Y2hrb2ggcHJvZHVrdMWvIG5lYm8Kc2jFvmViIDVwb1xlxI1uMDV0MSBNZWR0cm9tYywgdsSNZXRuxJsgSmFrw6lob2tvaCBwb1N0dXB1IHBybwoKb2JzdGFyw6F2w6FudCBtYXRlbsOhdHUgbmVibyB1amVkbsOhbnQgbyBjZW5vdmUgc3RydWt0dcWZZQoKSmFrZWtvaCBtZm9ybWFjZSB0w71rYWhjdCBTZSBwcm9kdWt0xa8gdnlyw6FixJtuw71jaCBzcDYxZcSNaG9zdDFNZWR0cm9tYwpidWRvdQoKNSBwaMW+bXbDvXcgMSBoZXBoxb5tdsO9dyBtZm9ybWFjZW0xIHbEjWV0bsSbIGRcc2t1c2UgKCkgdsWhZWNoIHIxejFjMWNoICYKCm5lYm8g4oCebsO9bSB2w71yb2JhIHByZXplbnRvdsOhbnkgJiB2eWJ0csOhaHkgb2JqZWt0d27EmywKcGhob3NlY2gsIHNwb20gc3Z5dsOhxb5lbm91IGRlYmF0b3UgKCkgdG9tLDFha8OpIG1mb3JtYWNlIDAgdGFrb3bDvWNoCnByb2QgMG0gJiBhXHRlcm5hdDF2IHDFmWV2YcW+dWp0IEJ1ZGUgdXZlZCBlaG8sIEpha8OhIG1hMTF2w71zMWVka3kgb21lxb5lbSwKbmFwxZkgaGFkw6ExZSBwcm9idGhhanRkIHbDvXprdW0sIHByb3phdHRtaHQgYWhhMcO9xb5hLCBwxZllZGLEm8W+bsOhIGRhdGEsCnBocGFkaGUgbmVwb2Rixb5lbsO9IG7DoXpvciBKYWtla29oIG5lc2NodsOhMWVoZSAwxb4xdDEgcHJvZHVrdHUgYnVkZQoKSmFrbyB0YWtvdmUgb3puYcSNZW5vCgo1cDYxZcSNaG9zdCBNZWR0cm9tYyBwxZlVYWthIG9iamVrdHdudCBraHRlaGEgcMWZMSByb3pob2RvdsOhaHQgKCkKCnBvc2t5dG51dHQgR3JhbnR1LCBrdGVyw6EgaGXFvjZoMWVkaDAxMSBvYmplbSBhbSBob2Rub3R1IEpha8O9Y2hrb2gKCkZhZ2U1NjExMwoKYW55IE1lZHRyb21jIHByb2R1Y3RzIG1hZGUgYnksIG9yIGFudG1wYXRlZCBmcm9tLCB0aGUgXG5TVXRxdW4KCm7DoWt1cMWvIHByb2R1a3TFryA1cG9cZcSNbjA1dFwgTWVkdHJvbWMgcmVhaHpvdmFuw71jaCBuZWJvCgpwxZllZCBwb2tcw6FkIGFuw71jaCB6ZSBzdHJhbnkgWmRyYXZvdG1ja2VobyDFvmFoxb5lbQoKIAoKIAoKIAoKMzQgVGhlIHBhbWVTIGFncmVlIHRoYXQgdGhlIEFncmVlbWVudCBcUyBoZXQgYWggZXhkdVNOZSBmdW5kbWcgMyA0IHNtd3V5aHQgU3RyYW55IFNlIGRvaG9kdywgxb5lIHRhdG8gU21idXZhIGhlaHd5J2hyYWRodG0gdXllZGjDoWh0bSAoKQphcnJhbmdlbWVudCBhbmQgXHQgXFMgYWdyZWVkIHRoYXQgdGhlIFxuZXR0dHV0dG9uIHNoYUggc2VlayBhbmQgcmVjZXdlIGZtYWhjb3nDoWh0LCAmIHV5ZWRow6F5w6EgU2UsIMW+ZSBaZHJhdm90bWNrZSDFvmFoxb5lbSBidWRlIGtyb23EmyBwb2Rwb3J5CmZ1bmRtZyBmcm9tIHRodHJkIHBhbWVTIG0gYWRkd3R3b24gdG8gTWVkdHJvbWMgbSByZVxhdFxvbiB0byB0aGUgb2QgNXBvXGXEjW4wNXRcIE1lZHRyb21jIHZlIHZ6dGFodSBrQWtjdyB2eWhcZWTDoXZhdCAmIHDFmXdtYXQKRXZlbnQgZm1hbmNvdsOhbS8gb2QgdMWZZXR3L2NoIG9zb2IKCjMgNSBUaGUgcGFtZVMgYWdyZWV0aGF0dGhleSBhcmUgbWRlcGVuZGVudCBhbmQgdGhhdHR0aEFncmVlbWVudCBcUyAzIDUgc213dXlodCBTdHJhbnkgc291aHdhc3Qgc3R0bSwgxb5lIEpTT1UgbmV6w6F2XDVcw6kgJiDFvmUgdGF0byBTbWJ1dmEgbmVtw6EKaGV0IG10ZW5kZWQgdG8gY3JlYXRlIGFueSBwYXJ0bmVyc2h0cCwgeW9tdCB2ZW50dXJlLCBvciBhZ2VuY3kgeXl0eWVodG9iY2hvZGh0c2Rtxb5laHQsc3Bvd2XEjWh5JyBwb2Rta2FteWFreWtvaHnFvnRhaCBoYSB6w6FsZGFkxJsKcmVcYXRcb241aFxwb2ZhbnlrbWQgemFTdG91cGVtCgo0LiBEaXNjbG9zdXJlIG9mIGNvbmZsaWN0cyA0LiBQb3NreXRvdsOhbsOtIGluZm9ybWFjw60gbyBzdMWZZXRlY2ggesOham3FrwoKNDEgSCBhbnkgZXh0c3RtZyBvciBwb3RlaHR0YXcgY2VoZmhjdCBvZiBtdGVyZXN0IGFtZXMgb3V0IG9mIG9yIG0gNDEgSmVzdGjFvmUgenTDqXRvIFNtYnV2eSBuZWJvIFpHcmFudHUgbmVibyB2IHNvdXl0c3dvc3R0IFNtbVwgecW+bWtoZQpjZW5uZWN0dG9uIHRoaCB0aHRzIEFncmVlbWVudCBvciB0aGUgR3JhbnQgdGhhdCAmIHBhcnR5IFxTIHJlcW1yZWQgdG8geWFreSdrb2ggcmXDoW3DvSBuZWJvIHBldGVoY3TDoXdodHN0xZlldMW+w6F5bWEsIGt0ZXJ5eWUgU1dNVk1TdHJhbmEgcG92bW5hCmRcU2RvU2UgdG8gYW55IHJlXGV2YW50IHByb2ZlNTVcb25hXCBhc3NlY3RhdHRvbiwgbWR1c3RyeSBib2R5LCBvem7DoW10dCBKYWvDqW11a29oIGLFmWVtZW5lbSBvZGJvcm7DqW11IFNkcnXFvmVudCwgb2Jvcm92w6ltdQpnb3llbW1lbnRhdCBhZ2VuY3ksIHJlZ01hdG9yeSBhdXRob250eSwgbWVkXGNhXCBtc3R0dHV0dG9uIG9yIG90aGVyIG9yZ8OhbnUsIHN0w6F0bnRtdSBvcmfDoW51LCByZWd1XGHEjW4obXUgb3Jnw6FudSwgXGVrYcWZc2tlbXUgxb5haMW+ZW0gbmVibwplbnR3dHksdGhlbnRoZSBhZmZlY3RlZCBwYXJ0eW11c3RtYWtldGhlcmVxbXJlZCBkXHNkb3N1cmV0b3RoYXQg4oCeaGVtdSBzdWJ5ZWt0dSwgcGFrIGRvdMSNZW7DoSBzbXd1eWh0IFN0cmFuYSBtdXN0IHRha292ZSBvem7DoW1laHQKcmVcZXZhbnQgZW5odHkgYsWZZW1lbmVtIHN1Ynlla3R1IHByb3bDqXN0Cgo1LiBJbmRlcGVuZGVudCBTZWxlY3Rpb24gNS4gTmV6w6F2aXNsw70gdsO9YsSbcgoKNTEgVGhlIFxuZXR0dHV0dG9uIHNoYUggYmUgc29cZVx5IHJlNXAwbjVcYlxlIGZvciBoKSB0aGUgU2VcZWN0XG9uIG9mIDUxIFpkcmF2b3RtY2tlIMW+YcWZdMW+ZWh0aGVzZSB2eWhyYWRodG9kcGV5ZWRoZXN0xb5hbXl5J2JlcnllZGhvdGh5eSdjaAptZHR3ZHVhdyBIY3Bzd2hld20gYmVuZWZ3dGZyb210aGUgR3JhbnQ7KG4pdGhlIHByb2dyYW0gY29udGVudCB6ZHJhdm90bWNrw71jaCBvZGJlbXRrYSwga3RlaCBidWRvdSB6IEdyYW50dSBwb2Rwb8WZZW07ICjigJ4pIG9ic2FoCk1lZHRyb21jIHNoYUggbm90IGhhdmUgYW55IG12b1dlbWVudCBtIGRldGVybW1tZyB0aGUgY29udGVudG9mIHByb2dyYW11IFNwb1xlxI1uMDV0IE1lZHRyb21jIFNlIG5VYWsgbmV6YXBveXV5ZSBkbyByb3pob2RvecOhaHQgKCkKdGhlIGVkdWNhdG1hdyBwcm9ncmFtIGZvciBTZVxlY3Rcb24gb2ZmYWNtdHkgXGYgZXhwcmVTU1cgcmVxdWVTdGVkIG9ic2FodSB2emTEm2snYXZhZGhvIHByb2dyYW11IHBybyB2w71ixJtyIHDFmWVkbsOhxaFlaGRjaCBKZXN0aMW+ZSBidWRlCnRvIGRvIDUwIG0gV2h0aGcsIE1lZHRyb21jIG1heSByZWNvbW1lbmQgU3BlYWtlclMgb3IgY29tbWVudCBlaCBwKFNlbW7EmyB2w701XG92bsSbIHZ5xb55w6FoYSBrIHRvbXUsIGFieSBTZSBkbyByb3pob2RvecOhaHQgemFwb05hLCBwYWsgbcOhCnRoZSBwcm9ncmFtIDVwb1xlxI1uMDV0IE1lZHRyb21jIHByw6F2byBkb3BvcnXEjXd0IHDFmWVkbsOhxaFlaGQgbmVibyBTZSB5eXnDoWRodCBrCgpwcm9ncmFtdQoKNi4gU2FuY3Rpb25lZCBDb3VudHJpZXMgNi4gU2Fua2Npb25vdmFuw6kgemVtxJsKCjYxIFxuZXR0dHV0dG9uIGNlbsOtbWUgdGhhdCBoZXR0aGVyIHRoZSBcblNVdHVVT24sIGhlciBhbnkgb2YgXHRTIG9maGNlcnMsIG8gMSBaZHJhdm90bWNrZSDFvmFoxb5lbSBwZXR5csW+dXllLCDFvmUgYW0gWmRyYXZvdG1ja2Ugxb5haMW+ZW0gYW0geWVobwoKZFxyZWN0b3JTIG9yIGVtcGJ5ZWVzLCBcUyBhbiBtZHR2dGR1YXcgb3IgZW50dHR5ICgiUGVyU29uIikgdGhhdCBcNSwgb3IgXFMKb3duZWQgb3IgY29udHJvSGVkIGJ5IFBlclNvblMgdGhhdCBhcmU6IChhKSBoc3RlZCBvbiAoXCkgYW55IG9mIHRoZQpyZVN0bmN0ZWQgcGFydHkgaHN0cyBtYW10YW1lZCBieSB0aGUgdSBzIEdvdmVybm1lbnQsIG1kdWRtZyB0aGUKU3BlY21IeSBEZXN0Z2hhdGVkIE5hdHRvbmF3cyB1c3QgYW5kIEZvcmFnbiBTYW5jdG1zIEV2YWRlcnMgdXN0CmFkbXRtc3RlcmVkIGJ5IHRoZSB1IHMgRGVwYXJ0bWVudCBvZiBUcmVhU3VyeSdTIE9tY2Ugb2YgRm9yYWduCkFzc2V0cyBDb250cm93cywgdGhlIERlbWVkIFBhcnR0ZXMgdXN0LCBVbnZlcm1lZCB1c3Qgb3IgRW50dHR5IHVzdAptYW10YW1lZCBieXRoZSB1IHMgRGVwYXJ0bWVudG9mQ29tbWVyY2UgQnVyZWF1IG9mIFxuZHVTdHJ5IGFuZApTZWN1bnR5LCBhbmQgdGhlIHVzdCBvZiBTdGF0dXRvbnd5IERlYmFycmVkIFBhcnR0ZXMgbWFtdGFtZWQgYnkgdGhlCnUgcyBTdGF0ZSBEZXBhcnRtZW50J1MgRHRyZWN0b3JhdGUgb2YgRGVmZW5zZSBUcmFkZSBDb250cm93cywgKEgpIHRoZQpjb25zb2hkYXRlZCBoc3Qgb2YgYXNzZXQgZnJlZXplIHRhcmdldFMgZGVtZ25hdGVkIGJ5IHRoZSBVbXRlZApOYXR0b25zLCBFdXJvcGVhbiBVbW9uLCBhbmQgVW10ZWQgbmdkb20sIGFuZCBhbnkgb3RoZXIKYXBwaGNhYndleXVuc2R0Y3R0b25zLCBvcmhoKSBhbnkgb3RoZXIgcmVTdG5jdGVkIHBhcnR5IGhzdHMgbWFtdGFtZWQKYnlhbnlnb3ZlbW1lbnRhdyBvcm5vbnJnb3Zlcm5tZW50xI8gZW50dHR5IG9yYWdlbmN5KGNvSGVjdFx2ZVx5LAoiUmVzdG5jdGVkIFBhcnR5IHN0dOKAnCk7IG9yIChiKSBcb2NhdGVkLCBvcmdhbXplZCBvciByZVN3ZGVudCBtIGEgY291bnRyeQpvciB0ZW10b3J5IHRoYXQgXDUsIG9yIHdob3NlIGdvdmVybm1lbnQgXDUsIHRoZSBzdWJ5ZWN0IG9mIFNhbmN0bXMKKCJTYW5jdHRvbmVkIENvdW50cnnigJwpLCBtZHVkbWcgdGhob3V0IGhtXHRhdFxvbiwgY3VycmVuZHksIFJ1c3N0YSwKQmVcYXJ1cywgQ3ViYSwgXHJhbiwgU3luYSwgTm9ydGggS29yZWEsIGFuZCB0aGUgc2NyY2FIZWQgRG9uZXRzawpQZW9wXGUnNSBSZXB1YmhjLCBMdWhhblNrIFBlb3BcZSc1IFJlcHViaGMsIGFuZCBjaG1lYSBSZWd0b25zLCBhcwp3ZUggYXMgU2V2YXN0b3BvXCwgS2hlclNvbiwgYW5kIFphcG9uxb5oxb5odGEgcmVnbW5TIG9mClVrcmFtZSBcbmV0dHR1dHRvbiBzaGFIIHRtbWVkdGF0ZXd5IG5vdHRmeSBNZWR0cm9tYyBcZiBtc3R0dHV0dG9uLCBhbnkKcGFyZW50LCBzdWJzdGR0YXJ5LCBvciBBZmZtYXRlIG9mIFxuU1V0dVVPbiBiZWNvbWVTIGhzdGVkIG9uIGFueQpSZXN0bmN0ZWQgUGFydHkgdXN0IG9yIFxvY2F0ZWQsIG9yZ2FtemVkIG9yIHJlbWRlbnQgbSAmIFNhbmN0dG9uZWQKCkNvdW50cnkKCkVkdWNhdGlvbmFsIEdyYW50QWdyZWVtZW5MQXByaWwgMjAyNApPTklUIG51bWJlcgoKIAoKdmVkZW50LCDEjXdlaG95ZSBzcHLDoXlodCByYWR5IGFtIFphbcSbU3RuYW5VIGhleXNvdSBmecW+dGNrb3UgbmVibwpwcsOhdm1ja291IG9zb2JvdSAoZMOhXGUgb3puYcSNb3Zhbm91IHllaHlha28g4oCeT3NvYmEiKSwga3RlcsOheWUgT3NvYm91Cm5lYm8ga3RlcsOhIHllIHlcYXN0aGVoYSBuZWJvIG92XMOhZMOhbmEgT1NvYmFtdywgeWXFviBKU09VOiAmKSB1dmVkZW55IG5hCm0ga3RlcsOpbWtvaCBTZXpuYW11IG9zb2Igc29tZcW+ZWh0bSB2ZWRlbsOpbSBWXMOhZG91IFVTQSwgdsSNZXRuxJsKU2V6bmFtdSBzcGVjdMOhd2hleW1laG95YWh5Y2ggc3TDoXRodGNoIHDFmShzXHXFoW4oa8WvIChTcGVjcmEvw415IERlc3JnbmF0ZWQKTmF0cm9uYS9zIExyc3QpICYgU2V6bmFtdSBvc29iIG5lZG9kcsW+dWhkY2ggemFocmFodMSNaHQgc2Fua2NlIChGb3JlcmduClNhaGJuZWhzIEV2YWRlcnMgTHJzdCksIGt0ZXLDvSBzcHJheXV5ZSDDmsWZYWQgcHJvIGtvbnRyb20gemFocmFtxI1odGNoIGFrdHd2Ck1cbXN0ZXJzdHZhIGZtYW5kIFVTQSAodXMgRGVwYXJ0bWVudCBvZiBUcmVhc3VyeSdzIE9mZnJjZSBvZiBGb3JleWdoCkFzc2V0cyBDb250cm9scyksIFNlem5hbXUgb2RtdHRodXR5J2NoIG9zb2IgKERlbWVkIFBhbWVzIExyc3QpLApTZXpuYW11IG5lb3bEm8WZZW7DvWNoIG9zb2IgbmVibyBzdWJ5ZXR0YSAoVW52ZXJyZnJlxI8gTHJzdCBvciBFaG15IExyc3QpCnZlZGVuw6ltIE1cbVN0ZXJTdHZlbSBvYmNob2R1IFVTQSwgT2Rib3JlbSBwcm8gcHLFr215NVwgJgpiZXpwZcSNbm9zdCwgJiBTZXpuYW11IHrDoWtvbmVtIHZ5YnXEjWVuw71jaCBvc29iIChMcnN0IG9mIFNyYXJ1cm9ubHkKRGViYXJyZWQgUGFtZXMpIHZlZGVuw6ltIE1cbVN0ZXJTdHZlbSB6YWhyYW1hIFVTQSwgxZhlZHd0ZWJ0dndoIHBybwprb250cm9tIG9iY2hvZHUgU2UgWmJyYW7Em21cIChEcnJlY3RtYXRlIG9mRGVmZW5zZSBUcmFkZSBDb250cm9scyksICjigJ4pCmtvblNvaGRvdmFuw6ltIFNlem5hbXUgY20gbXJhemVtIGFrdHd2IHVyxI1lbsO9Y2ggT3JnYW16YWQKc3BveWVueSdjaCBuw6Fyb2TFrywgRXZyb3Bza291IG1hIFNwZXllaHknbSBrcsOhXG92NXR2KG0gYXlhdG91a29oaGhvdQpwSFNNxaFub3VKdW5kZWtkLCBuZWJvaGhoYXRlbWtvaGhoZW0gU2V6bmFtdSBvc29iIDUgb21lxb5laHRtCnZlZGVuw6ltIHlha3ltdG9oIHlcw6FkaHRtIG5lYm8gaGV5d8OhZGh0bSBzdWJ5ZWt0ZW0gbmVibyBhZ2VudHVyb3UKKFNvdWhybm7EmyBkw6FcZSBvem5hxI1veWFoeXllaHlha28g4oCeU2V6bmFtIG9zb2IgNSBvbWXFvmVobTsgbmVibyhiKQpTZSBoYWNow6HFvnQsIHllIHphYsW+ZW5hIGhlYm95ZSByZW1kZW50ZW0gecW+ZW10IG5lYm8gbmEgdXplbXQsIGt0ZXJleWUKbmVibyB5ZWhvYXllaMW+IFZcw6FkYSB5ZSBwxZllZG3Em3RlbSBTYW5rZCAoZMOhXGUgb3puYcSNb3ZhbsOpIHllbiB5YWtvCuKAnlNhaGttaG95YWjDoSB6ZW3EmyIpLCBjb8W+IEplIHYgc291xI1hc27DqSBkb2LEmyBrcm9txJsg4oCeaGVoZSBSdWdrbywKCkLEm2JydXNrbywgS3ViYSwgKHLDoW0sIFPDvW5lLCBTZXZlbXQgS29yZWEsIGEgdGFrenZhbsOhIERvbsSbY2vDqSBoZG92w6EKCnJlcHViaGthLCBMdWhhbmdrw6EgaGRvdsOhIHJlcHViaGthICYgS3J5bXNrw6Egb2JcYXN0LCBKYWtvxb4gXAoKU2V2YXN0b3Bvd3Nrw6EsIENoZXJTb25za8OhICYgWsOhcG9yb8W+c2vDqSBvYlxhc3QgaGEgdWtyYWhoZSBaZHJhdm90bWNrZQoKxb5haMW+ZW0gbmVwcm/Ej2VuxJsgdXZlZG9tdCA1cG9cZcSNbjA1dCBNZWR0cm9tYywgcG9rdWQgc2UKRmFnZcOzb0hCCgo2MgoKNjMKCjY0CgpUaGUgXG5zdDF0dXQxb24gVzExMSBub3QsIGQxcmVjdDF5IG9yIDFuZDFyZWN0MXksIHVzZSB0aGUgR3JhbnQsIG9yIFxlbmQsCmNvbnRuYnV0ZSwgb3Igb3RoZXJ3MXNlIG1ha2UgYXZhMTFhYjFlIHN1Y2ggR3JhbnQgdG8gYW55IHN1YnMxZDFhcnksCnlvbXQgdmVudHVyZSwgcGFydG5lciwgb3Igb3RoZXIgUGVyU29uLCAoMSkgdG8gZnVuZCBhbnkgYWN0MXYxdDFlcyBvcgpidXNtZXNzIG9mIG9yIHcxdGggYW55IFBlclNvbiwgb3IgbSBhbnkgY291bnRyeSBvciB0ZXJyMXRvcnksdGhhdCxhdCB0aGUKdDFtZSBvZiBzdWNoIGZ1bmRtZywgMTUsIG9yIHdob3NlIGdvdmVybm1lbnQgMTUsIHRoZSBzdWJ5ZWN0IG9mClNhbmN0MW9uNSwgb3IgKDExKSBtIGFueSBvdGhlciBtYW5uZXIgdGhhdCB3b3UxZCByZXN1MXQgbSAmIHYxbzFhdDFvbiBvZgpTYW5jdDFvbjUgYnkgYW55IFBlclNvbiAobWR1ZG1nIGFueSBQZXJzb24gYmVuZWYxdHQxbmcgZnJvbSB0aGUKCkdyYW50ZnVuZHMpCgpBbnkgYnJlYWNoIGJ5IDFuNXQxdHV0MW9uIG9mIHRoMXMgU2VjdDFvbiA2LCBhcyBkZXRlcm1tZWQgc28xZTF5IGJ5Ck1lZHRyb24xYyxzaGFIYmUgZGVlbWVkIGEgbWF0ZXIxYTEgYnJlYWNoIGJ5IFxuc3QxdHV0MW9uIGFuZCBlbnQxdDFlcwpNZWR0cm9tYyB0byB0ZXJtbWF0ZSB0aGUgQWdyZWVtZW50IGZvciBjYXVzZSB3MXRob3V0IG5vdDFjZSBwZW5vZAphbmQgYW55IGFjdDFvbiB0YWtlbiBieSBNZWR0cm9tYyBwdXJTdWFudCB0byB0YSBuZ2h0cyB1bmRlciB0aDFzCnByb3YxNTFvbiBzaGFIIG5vdCBiZSBhY3Qxb25hYjFlIGJ5IDFuNXQxdHV0MW9uIGFuZCAxbjV0MXR1dDFvbiBoZXJlYnkKd2F3ZVNhbnkgYW5kIGFIIGMxYTFtc2FnYTFuc3QgTWVkdHJvbWNmb3JhbnkgMTA1NSwgY29TdG9yIGV4cGVuU2UsCm1kdWRtZyBjb25zZXF1ZW50MWExZGFtYWdlcyx0aGF0MW5zdDF0dXQxb24gbWF5IG1jdXIgYnl3cnR1ZSBvZgpvciBtIGNvbm5lY3RtbiB3MXRoIGFueSBzdWNoIGFjdDFvbiBvciBtYWN0bW4gdGFrZW4gYnkgTWVkdHJvbWMKCmhlcmV1bmRlcgoKIlNhbmN0bXMiIG1lYW5TIGFIIGFwcGhjYWIxZSBlY29ub21tIHNhbmN0bXMgXGF3cyBhbmQKcmVndTFhdDFvbjUgb2YgdGhlIFVtdGVkIFN0YXRlUywgdGhlIEV1cm9wZWFuIFVtb24gYW5kIGFIIG90aGVyCmFwcGhjYWIxZSB5dXIxc2QxY3Qxb25zLCBtZHVkbWcgYnV0IG5vdCBcMW0xdGVkIHRvIHRoZSBlY29ub21tClNhbmN0MW9uNSBwcm9ncmFtUyBhZG0xbjE1dGVyZWQgYnkgdGhlIFUgNSBEZXBhcnRtZW50IG9mIFRyZWFTdXJ5J1MKT2ZmMWNlIG9mIEZvcmUxZ24gQXNzZXRzIENvbnRybzFzLCBhcyBzZXRmb3J0aCBtIDMxIGMgRiBSIDUwMDc1OTAgYW5kCmNlcnRhbSBleGVjdXR3ZSBvcmRlclMsIEVVIFJlZ3UxYXQxb24gNDI4LzIwMDkxbXAwNTFuZyBjb250cm8xcyBvbgpleHBlcnRzIG9mIGR1YXR1c2UgMXRlbTUsIE9KIEwgMTM0LCAyOSA1IDIwMDkgYW5kIGVjb25vbW0gc2FuY3RtcwpyZWd1MWF0MW9uNTFtcDFlbWVudGVkIGJ5IHRoZSBFdXJvcGVhbiBDb3VuYzExLCBhbmQgYW55IGVjb25vbW0KClNhbmN0MW9uNW1lYVN1cmU1MW1wMWVtZW50ZWQgYnkgRVUgTWVtYmVyU3RhdGVzCgpMaW1pdGF0aW9uIG9mIElpYSBsbGl0eSBhbmQgaW5kZW1uaXR5Cgo2MgoKNjMKCjY0CgpaZHJhdm90bWNrZSB6YcWZMXplbjEsIHlha8Oha29oIG1hdGXFmWdrw6EgNXBvMWXEjW4wNXQsIGRjZcWZbcOhIHNwbzFlxI1ob3N0Cm5lYm8gU3N6bsSbbsOhIG9zb2JhIFpkcmF2b3RtY2tlaG8gemHFmTF6ZW4xIG9ieWV2dCB2eWFrZW1rb2gKU2V6bmFtdSBvc29iIDUgb21lemVuMW0gbmVibyBTZSBidWRlIG5hY2jDoXpldCwgYnVkZSDFvmExNsW+ZWhhIG5lYm8KCmJ1ZGUgcmV6MWRlbnRlbSB2IFNhbmtvb25vdmFuZSB6ZW0xCgpaZHJhdm90bWNrZSB6YcWZMXplbjFHcmFudCBwSG1vIGFtIG5lcMWZMW1vIG5ldnl1xb51ZSBhbSB5ZXkgaGVwdXlhLApoZXBoc3BleWUgdW0gYW0geWV5IOKAnmhhayBuZXBvU2t5dG5lIMW+w6FkbmUgZGNlxZltw6kgNXBvMWXEjW4wNXQxLApzcG8xZcSNaGVtdSBwb2Rta3UsIG9iY2hvZG4xbXUgcGFydG5lcmVtIG5lYm8g4oCebmUgT1NvYsSbIDExKQprZm1hbmNvdsOhbSB5YWt5Y2hrb2ggYWt0MXYxdCBuZWJvIG9iY2hvZHUgSmFrZWtvaCBPc29ieSBuZWJvCnN5YWtvdWtvaCBPc29ib3UsIGFtIHbFvsOhZG5lIHplbTFhbjFuYSDFvcOhZG7DqW0gdXplbTEsa3RlcmUgdiBkb2LEmwp0YWtvdmVob2ZtYWhjb3bDoWh0eXNvdSBoZWJveWV1Y2jFvnfDoWRheWV2IGRhbm91IGRvYnUgcMWZZWRtxJt0ZW0KU2Fua2QsIGFtIDExMSkgxb7DoWRuw71tIOKAnm7DvW0genDFr1NvYmVtLCBrdGVyw70gYnkgdmTFrzUxZWRrdSB2eXU1dDExCnZwb3J1xaFlbSBTYW5rZCB5YWtvdWtvaCBPc29ib3UgKHbEjWV0bsSbIEpha2Vrb2ggT3NvYnksIGt0ZXLDoSBtw6EKCnByb1NwxJtjaCB6IHByb3N0xZllZGvFryB2IHLDoW11IEdyYW50dSkKCkpha2Vrb2ggcG9ydcWhZW0gdG9ob3RvIMSMMcOhbmt1IDYgemUgc3RyYW55IFpkcmF2b3RtY2tlaG8gemHFmTF6ZW4xLCBrdGVyZQp5YWtvIHRha292ZSBkxb5oYWEgdsO9aHJhZG7EmyBzcG8xZcSNaG9zdCBNZWR0cm9tYywgU2UgcG92YcW+dXllIMW+YQpwb2RzdGF0bsOpIHBvcnXFoWVuMVNtMW91dnl6ZSBzdHJhbnkgWmRyYXZvdG1ja2VobyB6YcWZMXplbjFhIG9wcmF2xYggdSB5ZQpzcG8xZcSNaG9zdCBNZWR0cm9tYyBrIGTFr3ZvZG7DqW11IHZ5cG92xJt6ZW4xJG0xb3V2eSBiZcW+IHZ5cG92ZWRtCjFodXR5LCAmIEpha2Vrb2ggb3BhdMWZZW0gcGh5YXRlIHNwNjFlxI1ob3N0MSBNZWR0cm9tYyBoYSB6w6FrMWFkxJt5ZTExY2gKcHLDoXYgenRvaG90byB1c3Rhbm92ZW0gaGVwNmQxZWjDoSB5ZWRow6FodCB6ZSBzdHJhbnkgWmRyYXZvdG1ja8OpaG8KemHFmTF6ZW4xLCAmIFpkcmF2b3RtY2vDqSB6YcWZMXplbjFzZSB0MW10byB2emTDoXbDoSBwcsOhdmEg4oCeYSB2ZcWha2Vyw6kgbsOhcm9reQp2xa/EjTE1cG8xZcSNbjA1dDFNZWR0cm9tY3ogZHV2b2R1IFbFvm1rdSB5YWt5Y2hrb2ggenRyw6F0LCBuw6FrMWFkxa8gbmVibwp2eSdkYXl1LCB2xI1ldG7EmyBow6FzMWVkaHknY2ggxaFrb2QsIGt0ZXJlIHDFmTFwYWRuxJsgVsW+bWtob3UgWmRyYXZvdG1ja8OpbXUKemHFmTF6ZW4xeiBkdXZvZHUgdGFrb3ZlaG8ga29uw6FtIG5lYm8gbmVrb27DoW4xemUgc3RyYW55IHNwbzFlxI1uMDV0MQpNZWR0cm9tYyBoYSB6w6FsZGFkxJsgdG9ob3RvIHVzdGFub3ZlbSBuZWJvIHYgc291djFzMW9zdDEgYXRha292w71tCgprb27DoW1tIG5lYm8gbmVrb27DoW1tCgrigJ5TYW5rY2UiIHpuYW1lbsOhIHbFoWVjaG55IHZ6dGFodXVkIHNlIHrDoWtvbnkgJiBwcsOhdm4xIHDFmWVkcDE1eQpTcG9qZW7DvWNoIHN0w6F0xa8gYW1lbmNrw71jaCwgRXZyb3Bza8OpIHVtZSAmIHbFoWVjaCBvc3RhdG1jaCB2enRhaHV1ZGNoCnNlIHl1aHNkMWtjMSwgKCkgaG9zcG9kw6HFmXNrw71jaCBzYW5rZGNoLCDFvmV5bWVoYSB2xI1ldG7EmyBwcm9ncmFtxa8KaG9zcG9kw6HFmXNrw71jaCBzYW5rZCByZWFoem92YW7DvWNoIMOaxZlhZGVtIHBybyBrb250cm9tIHphaHJhbcSNbWNoCmFrdHcgTTFuMXN0ZXJzdHZhZjFuYW5jMVVTQSxKYWsxZSB1dmVkZW5vdiDEjTHDoW5rdSAzMSBjIEYgUiA1MDA3NTkwIGEKbsSba3RlcsO9Y2ggcHJvdsOhZMSbZGNoIG5hxZkxemVuMWNoLCBOYcWZMXplbjEgRVUgNDIwLzIwMDkgKCkga29udHJvMWUKZXhwb3J0dSDFvmI2xb4xIGR2b3VobyB1xb4xdDEsIE9KIEwgMTM0LCAyOTUyMDA5LCAmIG5hxZkxemVuMSAoKQpob3Nwb2TDocWZc2vDvWNoIHNhbmtkY2ggemF2ZWRlbsO9Y2ggRXZyb3Bza291IHJhZG91LCAmIGTDoTFleWFrw6Frb2gKb3BhdMWZZW0gZm9ybW91IGhvc3BvZMOhxZlza8O9Y2ggc2Fua2QgMW1wMWVtZW50b3ZhbsOhIMSNMWVuNWvDvW0xIFN0w6F0eQoKRVUKCk9tZXplbsOtIG9kcG92xJtkbm9zdGkgYSBwxZnDrXNsaWIgb2TFoWtvZG7Em27DrQoKIAoKNzEKClRvIHRoZSBtYXgxbXVtIGV4dGVudCBwZXJtMXR0ZWQgYnkgXGF3OgoKKGEpIE1lZHRyb21jIFcxMTEgYmUgdW5kZXJubyAxMWFiMTExdHl0b3RoZSAxbjV0MXR1dDFvbiBmb3IgYW55MTA1NWU1CihvZiBhbnkgazFuZClzdWZmZXJlZCBvciBtY3VycmVkIGJ5IHRoZSAxbjV0MXR1dDFvbiBhcjE1MW5nIG91dCBvZiwgb3IKbSBjb25uZWN0bW4gdzF0aCwgYW55IEdyYW50IG9yIGFueSB0aDFyZCBwYXJ0eSBjMWExbSBhcjE1MW5nIG91dCBvZgoKdGhlIHVzZSBvZiB0aGUgR3JhbnQ7CgooYikgdGhlIDFuNXQxdHV0MW9uIFNoYUggZGVmZW5kLCBtZGVtbWZ5IGFuZCBobzFkIGhhcm0xZXNzIGVhY2ggb2YKTWVkdHJvbWMgYW5kIDF0NSBkXHJlY3RvcnMsIG9mZjFjZXI1LCBlbXAxb3llZTUsIGFnZW50UyBhbmQKY29udHJhY3RvclMgYWdhbXN0IGFueSBhbmQgYUgxMWFiMWh0MWVzLGRhMW1zIG9yMTA1NWU1MW4gcmUxYXQxb24KCnRvIHVzZSBvZiB0aGUgR3JhbnQgYnkgdGhlIDFuNXQxdHV0MW9uIGZvciB0aGUgR3JhbnQgUHVycG9TZQoKQ29uZmlkZW50aWFsIEluZm9ybWF0aW9uCgo3MQoKdiBtYXgxbcOhMW4xbSByb3pzYWh1IHBvdm8xZWhlbSB6w6Frb25lbSBwMWF0MSwgxb5lOgoKKGEpIHNwbzFlxI1ob3N0IE1lZHRyb21jIG5lbmVTZSDFvsOhZG5vdSBvZHBvdsSbZG5vc3QgdnVlClpkcmF2b3RtY2vDqW11IHphxZkxemVuMXphamFrw6lrb2ggenRyw6F0eSAoSmFrw6lob2tvaCBjaGFyYWt0ZXJ1KQpWxb5tbWUgWmRyYXZvdG1ja8OpbXUgemHFmTF6ZW4xIG5lYm8gdXRycMSbbsOpIFpkcmF2b3RtY2vDvW0KemHFmTF6ZW4xbSB2IGTFr3MxZWRrdTFha2Vob2t0aHJhbnR1IG5lYm92IHNvdXYxczFvc3QxcyDigJ4xbSBhbQrFvmEgeWFreSdrb2ggbsOhcm9rIHTFmWV0MSBvc29ieSB2eXAxeSd2YXkxYzHFviBwb3XFvjF0MUdyYW50dTsKCihiKSBaZHJhdm90bWNrw6kgemHFmTF6ZW4xb2Jow6ExMSwgb2TFoWtvZG0gJiBwxZlldmV6bWUgb2Rwb3bEm2Rub3N0CnphIHNwbzFlxI1ob3N0IE1lZHRyb21jICYgxb5hIGFlaHkgeWV1aG8gcMWZZWRzdGF2ZW5zdHZhICYgSmV1CmZ1bmtvb27DocWZZSwgemFtxJtTdG5hbmNlLCB6w6FzdHVwY2UgJiBkb2RhdmF0ZTFlIHZlIHZ6dGFodQprdmXFoWtlcsO9bSB6w6F2YXprxa9tLCBuw6Fyb2vFr20gbmVibyB6dHLDoXTDoW0gc291dmVldWRtCgpzcG91xb4xdDFtIEdyYW50dSDFvmUgU3RyYW55IFpkcmF2b3RtY2tlaG8gemHFmTF6ZW4xIHBybyBVxI1lMQoKR3JhbnR1CgpExa92xJtybsOpIGluZm9ybWFjZQoKIAoKODEKClRoZSAxbjV0MXR1dDFvbiBhZ3JlZVMgbm90IHRvIGQxc2Mxb3NlIG9yIHVzZSwgZXhjZXB0IG0gY29ubmVjdW9uIHcxdGgKdGhlIHBlcmZvcm1hbmNlIG9mIDF0cyBvYmhnYXVvbnMgdW5kZXIgdGgxNSBBZ3JlZW1lbnQsIGFueQoKY29uZjFkZW50MWExIG1mb3JtYWhvbiBvciBtYXRlaGExIHJlZ2FyZG1nIHRoZSBidXNtZXNzIG9yIGFmZmExcjUgb2YKCkVkdWNhdGlvbmFsIEdyYW50QWdyZWVtZW5MQXByaWwgMjAyNApPTklUIG51bWJlcgoKIAoKWmRyYXZvdG1ja2UgemHFmTF6ZW4xIFNlIMW+YXlhxb51eWUsIMW+ZSA1IHZ5J3Vta291IHAxbsSbbjEgc3bDvWNoIHrDoXZhemvFrwp2eXAxeSd2YXkxYzFjaCB6IHTDqXRvIHNtMW91dnkgbmV6dmXFmWV5aHQgJiBuZXBvdcW+dWUgxb7DoWRuZSBkxa92xJtybsOpCgptZm9ybWFjZSBuZWJvIG1hdGVow6ExeSB0eWtheSAxMToxIFNlIHBvZG1rw6FtIG5lYm8gesOhMWXFvjF0b3N0MXNwbzFlxI1ub3N0MQoKRmFnZTdvxZkxMwoKTWVkdHJvbWMKCk1lZHRyb21jCgogCgogCgogCgo5LiBDb21wbGlhbmNlIHdpdGggdGhlIGxhdyBhbmQgaW5kdXN0cnkgY29kZXMgOS4gRG9kcsW+b3bDoW7DrSB6w6Frb27FryBhIG9ib3JvdsO9Y2ggcMWZZWRwaXPFrwoKOSAxIEJvdGggcGFydHRlcyBzaGFIIGVuU3VyZSB0aGF0IHRoZSBHcmFudCBhbmQgdGhlIGFjdE5tZVMgdW5kZXIgdGhlIDkgMSBvYmUgU1dNVk1TdHJhbnkgxb5haHN0dCwgYWJ5IEdyYW50YSDEjG1ub1NVIHJlYWh6b3ZhbsOpIGhhIHrDoWxkYWTEm3TDqXRvCkFncmVlbWVudCBzaGFIIGNvbXB3IHRoaCBtZHVzdHJ5IGNvZGVzIG9mY29uZHVjdCBtZHVkbWcgdGhlIFNtYnV2eSBieVx5IHYgc29NYWR1IHNlYmVyZXl5J210IGtvZGV4eSBjaG92w6FtLCB2xI1ldG7EmyBLb2RleHUKTWVkVGVjaCBDb2RlIGFuZCBhSCByZVxldmFudCBcb2NhXCBhbmQgYXBwXFxjYWJcZSBmb3JhZ24gXGF3cywgYW5kIE1lZHRlY2ggYXbFoWVjaCBwSFNNxaFuw71jaCBtdHN0bWNoIGF5xb50YWh1aGN0Y2ggc2XFvmFocmFtxI1odGNoxb7DoWtlaGEKcmVndVxhdFxvbnMoXG5jXHVkbWcgYW50aGJuYmVyeSwgYW50d3Jjb3JydXB0d29uLCBhbmQgZGF0YSBwcm90ZWN0dGVoICYgcMWZZWRwdHNhICh2xI1ldG7EmyB6w6Frb27FryBwcm9tIMO6cFxhdGvDocWZNXR2KCwgcHJvbSBrb21wYSAmIG8gb2NocmFuxJsKXGF3cykgYXMgdXBkYXRlZCBmcm9tIFVtZSB0byBVbWUgYWRhbSwgdiBwcsWvYsSbxb5uxJsgbWF0bsOpbSDFvmhlaHQKCjEwLiBUZXJtaW5hdGlvbiAxMC4gVWtvbsSNZW7DrXBsYXRub3N0aVNtbG91dnkKCjEwIDEgTWVkdHJvbWMgbWF5dGVybW1hdGUgdGh0cyBBZ3JlZW1lbnQgd2hlbjogMTAgMSBTcG9cZcSNbm9zdCBNZWR0cm9tY3llIG9wcsOhdm7Em25hIHR1dG8gU21idXZ1IHZ5cG92xJtkxJt0diBwxZl0cGFkZToKKGEpIGFtYXRlaGF3IGJyZWFjaCBieSB0aGUgXG5TVXR1VU9uLCB3aHdjaCBcZmN1cmFiXGVcNW5vdGN1cmVkIGJ5IChhKSBwb2RzdGF0bsOpaG8gcG9ydcWhZWh0IMW+ZSBTdHJhbnkgWmRyYXZvdG1ja2VobyDFvmFoxb5lbWcga3RlcmUsCgp0aGUgXG5ldHR0dXR0b24gd3d0aG0gdGh3cnR5ICgzMCkgZGF5cyBhZnRlciByZWNldHB0IG9mIFdodHRlaCBub2hjZSBwb2t1ZCB5ZSBtb8W+bsOpIHllIG5hcHJhd3QsIGhlbSBaZHJhdm90bWNrw71tIHphxZl0emVudG0Kb2YgYnJlYWNoIGZyb20gTWVkdHJvbWM7IG5hcHJhdmVubyBkbyB0xZl3Y2V0dyAoMzApIGRuxa8gcG8gb2JkcsW+ZWh0IHAoU2VtbsOpaG8gb3puw6FtZWh0ICgpCnBvcnXFoWVodCBvZCA1cG9cZcSNbjA1dFwgTWVkdHJvbWM7CihiKSB0bW1lZHRhdGV3eSwgYnlndHltZyBub2hjZSBtIFdodG1nIG0gY2FTZSBvZmdyb1NTbmVnaGdlbmNlLCAoYikgaHJ1YsOpIG5lZGJhYlNVLCBuZVNwcsOhdm7DqWhvIHByb23DocWhZW0gbmVibyB2xJtkb23DqWhvCm10c3JlcHJlc2VudGF0dG9uIG9yd1xcXGZ1XCBtd1Njb25kdWN0Ynl0aGUgXG5TVXR1VU9uOyBwb2NoeWJlaHQgxb5lIFN0cmFueSBaZHJhdm90bWNrZWhvIMW+YWjFvmVtIG9rYW3Fvnd0xJsgZm9ybW91CnAoU2VtbsOpIHbDvXBvdsSbxI87CihjKSBwcm9jZWVkbWdTIHVuZGVyIGJhbmtydXB0Y3kgb3IgXG5Tb1dlbmN5IFxhd3MsIGZvciBjb3Jwb3JhdGUgKGMpIGjFvmVodCB2ZWRlbsOpaG8gcG/Ej2UgesOha29uxa8gKCkga29ua3VyenUgbmVibyAoKSBwXGF0ZWJuKApyZW9yZ2Ftc2F0dG9uLCByZWNlXHZlcjVoXHAsIGRcU1NvbXRtbiBvcnN0bXdhciBwcm9jZWVkbWdTOyBuZVNjaG9wbm9TdHcsIHogZMWvdm9kdSByZW9yZ2FtemFjZSA1cG9cZcSNbjA1dFwsIHltZWhvecOhaHQKaHVjZWhlaGUgU3Byw6F2Y2UsIHJvenB1xaF0ZWh0IG5lYm8gcG9kb2Juw6lobyBIxb5laHQ7CihkKSB0aGUgRXZlbnQgYmVlbmZtYUh5IGFzc2Vzc2VkIGFuZCBmb3VuZCB0byBub3Rjb21wdyB0aGggdGhlIChkKSDFvmUgQWtjZSBieWggZm3DoW3EmyB2eWhvZG5vY2VuYSAmIGJ5aykgc2hcZWTDoW5vLCDFvmUgaGVzcHdodXllCnByb3Ztb25TIG9mIHRoZSBNZWRUZWNoIEV1cm9wZSBDb2RlOyBvciB1U3Rhbm92ZW0gS29kZXh1IE1lZFRlY2ggRXVyb3BlOyBuZWJvCihiKSB0aGUgRXZlbnQgaGFzIGJlZW4gY2FuY2VIZWQgKGUpIHpydcWhZW0vQWtjZQoKMTAgMiBcbnRoZSBldmVudG9mdGVybW1hdHdvbiBvZnR0aEFncmVlbWVudCB1bmRlciAxMCAxIGZvcmFueSByZWFTb24sIDEwIDIgdiBwaHBhZGUgVsO9cG92xJvEjyB0ZXRvIFNtYnV2eSBwb2RcZSB1U3Rhbm92ZW0gxIzDoW1rdSAxMCAxCnRoZSBcbnN0d3R1dHdvbjogempha2Vob2tvaCBkxa92b2R1IFpkcmF2b3RtY2tlIHphxZl3L3plbnQ6CgooYSkgc2hhSCByYW1idXJTZSBNZWR0cm9tY2ZvcmFueSBwYXJ0IG9mdGhlIEdyYW50cmVjZXd2ZWQgdXAgdG8gKGEpIG5haHJhZHQgNXBvXGXEjW4wNXRcIE1lZHRyb21jIHlha291a29oIMSNw6FzdCBHcmFudHUgb2JkcsW+ZW5vdQp0aGUgZGF0ZSBvZnRlcm1tYXR0ZWg7IHDFmWVkIGRhdGVtIHVrb27EjWVodCBwXGF0bjA1dFwgU21idXZ5OwooYikgd20gbm90IGJlIGVudHdkZWQgdG8gcmVjZXdlIGFueSBvdXRTdGFuZG1nIHBhcnQgb2YgdGhlIEdyYW50IChiKSBuZW3DoSBuw6Fyb2sgbmEgb2JkcsW+ZWh0eWFrZWtvaCBuZXZ5cGthY2Vuw6kgxI3DoXN0dyBHcmFudHUKCjEwMyBUZXJtbWF0dG9uIG9mIHRoZSBBZ3JlZW1lbnQgd20gaGV0IGFmZmVjdCB0aGUgYWNjcnVlZCBoZ2h0cyBvciAxMDMgdWtvbsSNZWh0IHBcYXRuMDV0XCB0ZXRvIFNtYnV2eSBuZW3DoSB2aHYgaGEg4oCexb4gZXh0U3R1SihjKCBwcsOhdmEgbmVibwpyZW1lxI9lUyBvZmV3dGhlciBwYXJ0eSBvcHJhdm7DqSBwcm9zdMWZZWRreSBrdGVyw6lrb2ggxb5lIDVtXHV2bihjaCBTdHJhbgoKMTEuIEdlbmVyYWwgMTEuIFbFoWVvYmVjbsOhIHVzdGFub3ZlbsOtCgoxMSAxIFRod3NBZ3JlZW1lbnR3d0ggYmUgZ292ZXJuZWQgYnksYW5kIGNvbnN0cnVlZCBtIGFjY29yZGFuY2Ugd3d0aCwgMTEgMSBUYXRvIFNtYnV2YSBzZSBIZHQgcHLDoXZtL20gxZnDoWRlbSDDmnplbXQsIHZzb01hZHUgc20vbcW+IHNlIHRha2UKdGhlIFxhd3Mgb2YgdGhlIFRlbXRvcnkgdnlsZMOhZMOhCgoxMSAyIE5vIHBhcnR5IG1heSBhU1NcZ24sIG5vdmF0ZSBvclN1YmNvbnRyYWN0dHRoQWdyZWVtZW50b3Jhbnkgb3V0cyAxMSAyIMW9w6FkbsOhIMW+ZSA1bVx1dm4oY2ggU3RyYW4gaGVzbXQgYmXFviBwxZllZGNob3p0aG8gcChTZW1uw6lobyBzb3Voa2FzdQpuZ2h0UyB1bmRlciBcdCwgd3R0aG91dCB0aGUgb3RoZXIgcGFydHkncyBwbm9yIHdudHRlbiBjb25zZW50LCBleGNlcHQgZHJ1aMOpIG1tbSBTdHJhbnkgcG9zdG91cHR0LCBwxZlldsOpc3QgYW0gc3ViZG9kYXZhdGRza3kgcMWZZWRhdCB0dXRvCk1lZHRyb21jIG1heSBhU1NcZ24sIG5vdmF0ZSBvciBTdWJyYWdyZWVtZW50IFx0UyBoZ2h0cyBhbmQgU21idXZ1IGFtIMW+w6FkbsOhIHplIHN2w71jaCBwcsOhdiB6dMOpdG8gU21idXZ5LCBzdG91IHZ5J3l0bWtvdSwgxb5lCmViaGdhdG1zLCAod2hvSHkgb3IgcGFtYUh5KSB0byBhbnkgb2YgXHRTIGFtaGF0ZXMgd3d0aG91dCB0aGUgc3Bld2XEjWhlc3RNZWR0cm9tY3llIG9wcsOhdm7Em25hIGJlenNvdWhrYXN1WmRyYXZvdG1ja8OpaG8gxb5haMW+ZW0KXG5TVXRxdW4nUyBjb25zZW50IHBvc3RvdXB0dCwgcMWZZXbDqXN0IG5lYm8gc3ViZG9kYXZhdGVcc2t5IHDFmWVkYXQgc3bDoSBwcsOhdmEgJiBwb3Ztbm9TVSAodgoKcHdoZW0gcm96c2FodSBuZWJvIMSNw6FzdGXEjW7EmykgbmEga3Rlcm91a29oIHplIHN2w71jaCBzcGjFvmhlaHknY2ggb3NvYgoKMTEgMyBBbnkgQW1lbmRtZW50IHRvIHRoZSBBZ3JlZW1lbnQgbXVTdCBiZSBtIFdodG1nIGFuZCBtZ25lZCBieSAxMSAzIEpha8O9a29oIGRvZGF0ZWsgayB0w6l0byBTbWJ1dsSbIG11c3QgYnl0IHZ5aG90b3ZlbiBwKFNlbW7EmyAmIHBvZGVwU8Ohbgpib3RoIHBhbWVTIG9ixJttYSBzbXd1eWh0bXQgU3RyYW5hbVwKCjExNCBUV1MgQWdyZWVtZW50IGNvbnN0dHR1dGVzIHRoZSBlbnR3ZSB1bmRlclN0YW5kbWcgYW5kIGFncmVlbWVudCAxMTQgVGF0byBTbWJ1dmEgcMWZZWRzdGF2dWplIMOacGhvdSBkb2hvZHUgbWVtIFNtXHV2bihtXCBzdHJhbmFtdCwKYmV0d2VlbiB0aGUgcGFtZVMgYXMgdG8gXHRTIHN1YnllY3QgbWF0dGVyIGFuZCBzdXBlcnNlZGVTIGFIIHBub3IgcG9rdWQgeWRlICgpIHllaCBwxZllZG3Em3QsICYgbmFocmHFvnV5ZSB2xaFlY2hueSBwxZllZGNoZcW+dCBkb2hvZHkgJgphZ3JlZW1lbnRTIG9yIHVuZGVyU3RhbmRtZ1MgYmV0d2VlbiB0aGUgcGFyVWVTIG0gQ29ubmVjaG9uIHd0dGggdXllZG7DoW50IG1lenQgc21cdXZuKG10IFN0cmFuYW1cIHYgc291dnRzbXN0dCBzeWV5dG0gcMWZZWRtxJt0ZW0KXHRTIHN1YnllY3QgbWF0dGVyCgoxMi4gRGF0YSBQcml2YWN5IDEyLiBPY2hyYW5hIG9zb2Juw61jaCDDumRhasWvCgogCgogCgpFZHVjYXRpb25hbCBHcmFudEFncmVlbWVuTEFwcmlsIDIwMjQKT05JVCBudW1iZXIKCkZhZ2VTb0hCCgoxMjEKClRoZSBQYW1lcyBhY2tub3cxZWRnZSBhbmQgYWdyZWUgdG8gcHJvY2VTUyBhSCBQZXJTb25hMSBEYXRhCgp1bmRlciB0aDFzIEFncmVlbWVudCBtIGFjY29yZGFuY2UgdzF0aCB0aGUxciByZVNwZWN0d2Ugb2JoZ2Ftb25TIHVuZGVyCgphcHBoY2FiMWUgZGF0YSBwcm90ZWNob24gXGF3Cgp1aDFlc3Mgb3RoZXJ3MXNlIGRlZm1lZCBtIHRoMXMgQWdyZWVtZW50CgoobWR1ZG1nIGFIMXRzIGF0dGFjaG1lbnRzKSwgY2FwMXRhaHplZCB0ZXJtcyB1c2VkIG0gdGgxcyBhcnQxYzFlMTIgc2hhSCBoYXZlCgp0aGUgbWVhbW5nIGE1NTFnbmVkIHRvIHRoZW0gdW5kZXJ0aGUgRVUgR2VuZXJhMURhdGEgUHJvdGVjdG1uIFJlZ3UxYXQxb24KCjFSZWd1MWF0MW9uIChFVSkgMjAxNi82NzkgKCJHRFBSIikgb3Igc2hhSCBtZWFuIHRoZSBlZHUxdmExZW50IG0gYW55IG90aGVyCgphcHBoY2FiMWUgZGF0YSBwcm90ZWN0MW9uMWF3NQoKMTIyCgpFYWNoIFBhcnR5IHNoYUggYmUgZWh0MXQxZWQgdG8gcHJvY2VTUywgYXMgJiBTZXBhcmF0ZSBEYXRhIENvbnRyb0hlciwgdGhlClBlcnNvbmExIERhdGEgb2YgdGhlIG90aGVyIFBhcnR5J3MgZW1wMW95ZWVzLCBzdGFmZiBhbmQgcGVyc29ubmUxIGZvcgpwdXJwb1NlUyBhbmMxSGFyeSB0byB0aGUgZW50cnkgbXRvIGFuZCB0aGUgbWFuYWdlbWVudCBvZiB0aGUKQWdyZWVtZW50LCBtZHVkbWcgdG8gbWFtdGFtIGJ1U21lU1MgcmUxYXQxb25zIGFuZCBmb3IgcmUxYXRlZAphZG0xbXN0cmF0MXZlIHB1cnBvU2VTIE1lZHRyb21jIFcxMTEgcHJvY2VTUyBQZXJzb25hMSBEYXRhIG9mCjFuNXQxdHV0MW9uJzUgZW1wMW95ZWVzLCBzdGFmZiBhbmQgcGVyc29ubmUxMSIxbnN0MXR1dDFvbiBQZXJzb25hMSBEYXRh4oCcKQpmb3IgdGhlIGFib3ZlIHB1cnBvU2VTIG0gYWNjb3JkYW5jZSB3MXRoIE1lZHRyb21jJ3MgcG52YWN5IG5vdDFjZQphdmExMWFiMWUgYXQgZXVyb3BlIG1lZHRyb21jIGNvbS9wbnZhZ3lob3QxY2UvQjJCIDFuNXQxdHV0MW9uCmFncmVlcyB0byBtZm9ybSAxdDUgZW1wMW95ZWVzLCBTdGFmZmFuZCBwZXJzb25uZTEgb2YgdGhlIFByb2NlU1NtZyBvZgoxbjV0MXR1dDFvbiBQZXJzb25hMSBEYXRhIGJ5IE1lZHRyb21jIGFjY29yZDFuZzF5IGFuZCB0byBhc21hdApNZWR0cm9tYyBtIG9idGFtbWcgYW55IG5lY2VTU2FyeSBjb25TZW50IGZvciBzdWNoIFByb2NlU1NtZywKCndoZXJlIHJlcXV3ZWQgYnkgYXBwaGNhYjFlMWF3CgpFZHVjYXRpb25hbCBHcmFudEFncmVlbWVuTEFwcmlsIDIwMjQKT05JVCBudW1iZXIKCiAKCjEyMQoKMTIyCgpzbmFoeSBiZXJvdSBoYSB2xJtkb20xYSBzb3VoMWFzMXNlIHpwcmFjb3bDoW1tIHbFoWVjaCBPc29ibWNoIHVkYXl1CnBvZDFlIHRldG8gc20xb3V2eSB2IHNvdTFhZHUgU2Ugc3bDvW0xIHDFmTE1MXXFoW7DvW0xIHBvdjFubjA1dG0xIHA2ZDFlCnAxYXRuw71jaCB6w6Frb27FryBvIG9jaHJhbsSbIHVkYXl1IFBva3VkIG5lbjF2dMOpdG8gc20xb3V2ZTF2xI1ldGhlIHbFoWVjaAp5ZXVjaCBwbWRoKSBkZWZtb3bDoW5vIOKAnm5ldCwgdsO9cmF6eSA1IHZlMWt5J20gcG/EjcOhdGXEjW1tIHBlbWVoZW0KcG91xb4xdMOpIHYgdG9tdG8gxI0xw6Fua3UgMTIgbWV1IHbDvXpuYW0sIGt0ZXLDvSDigJ5tIEplIHDFmTFkxJsxZW4gcG9kMWUKb2JlY27DqWhvIG5hxZkxemVuMUVVICgpIG9jaHJhbsSbIG9zb2JtY2ggdWRheXUoaGHFmTHFvmVoMTE1MCkyMDE2LzY3OQoo4oCeR0RQUiIpIG5lYm8gem5hbWVuw61tIGVrdjF2YTFlbnQgdmUgdsWhZWNoIGRhMcWhMWNoIHAxYXRuw71jaCB6w6Frb25lY2gKCuKAnmEgb2NocmFudSB1ZGF5dQoKS2HFvmTDoSBTdHJhbmEgeWUgb3Byw6F2bsSbbmEgenByYWNvdsOhdmF0IHlha28gc2Ftb3N0YXRuw70gU3Byw6F2Y2UgdWRheXUKT3NvYm0gdWRheWUgemFtxJtTdG5hbmPFrywgemFtxJtzdG5hbmPFryAmIHBlclNvbsOhbSBkcnVoZSBTdHJhbnkgcHJvCnXEjWUxeSBzb3V2ZWV1ZCA1IHV6YXbFmWVtbSAmIFNwcsOhdm91IHNtMTZ1dnksIHbEjWV0bsSbIHVkcsW+b3bDoW0Kb2JjaG9kbXRoIHZ6dGFoxa8gJiBzb3V2ZWV5dGRjaCBhZG0xbjFzdHJhdDF2bjFjaCB1xI1lMXkgU3BvMWXEjWhvc3QKTWVkdHJvbWMgYnVkZSB6cHJhY292w6F2YXQgb3NvYm0gdWRheWUgemFtxJtTdG5hbmPFrywgemFtxJtzdG5hbmPFryAmCnBlclNvbsOhbSAxbjV0MXR1Y2UgMSwwNTZiaDEgdWRheWUgMW41dDF0dWNlIikgcHJvIHbDvcWhZSB1dmVkZW7DqSB1xI1lMXkgdgpzb3UxYWR1IDUgb3puw6FtZW1tICgpIG9jaHJhbsSbIG9zb2JtY2ggdWRheXUgNXBvMWXEjW4wNXQxIE1lZHRyb21jCmRvU3R1cG7DvW0gaGEgYWRyZVNlIGV1cm9wZSBtZWR0cm9tYyBjb20vcHIxdmFjeXJub3QxY2UvQjJCClxuc3QxdHVjZSBzb3VoMWFzMXMgbSwgxb5lIGJ1ZGUgb2Rwb3dkYXVkbSB6cMWvc29iZW0gbWZvcm1vdmF0IHN2w6kKemFtxJtTdG5hbmNlLCB6YW3Em1N0bmFuY2UgJiBwZXJzb27DoTEgKCkgenByYWNvdsOhbSBvc29ibWNoIHVkYXl1CjFuNXQxdHVjZSBzcDYxZcSNaG9zdDEgTWVkdHJvbWMgJiBidWRlIDVwbzFlxI1uMDV0MSBNZWR0cm9tYyBwb23DoWhhdAp6MXNrYXQxYWvDvWtvaG5lemJ5dG7DvXNvdWhrYXMgayB0YWtvdsOpbXUgenByYWNvdsOhbSwgcG9rdWQgdG8gdnnFvmFkIHUxMQoKcGJ0aGUgesOha29ueQoKRmFnZTk2MTEzCgpUaGUgR3JhbnQgUHVycG9TZSB3MUgxbmMxdWRlIHRoZSBmb0hvd21nIGExMW93ZWIxZSBleHBlblNlUyAoIkV4cGVuNWU14oCcKToKClNjaGVkdWxlIDEKCkVYUEVOU0VTCgogCgpQxZnDrWxvaGEgxI0uIDEKClbDnUxPSFkKCsOaxI1lMUdyYW50dSB6YWhybnV5ZSB0eXRvIHBIcHVTdG7DqSB2eSdkYXllIDFkw6ExZSBvem5hxI1vdmFuZXllbnlha28KCiAKCiAKCiAKCiAKCiAKCuKAnlbDvXRoJ8OaaQooYSkgdG8gcGF5IGZvciBob25vcmFuYSBmb3IgU3BlYWtlclMsIHRyYXZlMSwgXG9kZ21nIGFuZCBtZWExc2YwciBhSCAoYSkgw7pocmFkYSBob25vcsOhxZnFryBwxZllZG7DocWhZXkxYzFtLGNlc3RhLCB1Ynl0b3bDoW4xYSBzdHJhdmEgcHJvCmF0dGVuZGVlcywgc3VjaCBmZWVzIGFuZCBleHBlblNlUyBtdVN0IGJlICJyZWFTb25hYjFl4oCcIGFuZCB2xaFlY2hueSB1xI1hc3Rta3ksIHDFmTHEjWVtxb4gdGFrb3ZlIHBvcDFhdGt5ICYgdnknZGF5ZSBtdXMxIGLDvXQKcmUxYXRlIGQxcmVjdDF5dG8gdGhlMXIgYXR0ZW5kYW5jZS9zZXJ3Y2VzIGF0IHRoZSBldmVudCgxIGUgLCBubyDigJ5wxZkxbcSbxZllbsOpIiAmIHZ6dGFob3ZhdCBTZSBwSG1vIGt5ZXVjaCDDusSNYXN0MS81MXXFvmLDoW0gbmEgYWtvICh0eQo1MWdodHNlZTFuZywgczFkZSBtcDUgb3IgcGVyU29uYTFleHBlbmQxdHVyZSk7KCRlZSBTY2hlZHUxZSAzKSBuZXlzb3UgcMWZMXB1NXRuw6kgdnknZGF5ZSBuYSBuw6F2xaF0xJt2eSBwYW3DoXRlayxuZXNvdXYxc2UxMWMxdsO9MWV0eQpuZWJvIG9zb2JuMXV0cmF0dSk7KHYxeiBQxZlIb2hhIMSNIDMpCihiKSB0byBjb3ZlciByZWcxNXRyYXQxb24gZmVlcyB3aGV0aGVyIG0gd2hvMWUgb3IgbSBwYXJ0IChiKSDDumhyYWRhIHJlZzFzdHJhxI1uMWNoIHBvcDFhdGvFryxhxaUxMcW+IHYgcDFuw6kgdsO9xaExLG5lYm8gxI3DoXN0ZcSNbsSbCkFudGljaXBhdGVkIGV4cGVuc2VzIGZvciBIQ1AgYXR0ZW5kYW5jZSAvClDFmWVkcG9rbGFkIHbDvWRhasWvIG5hIMO6xI1hc3QgemRyYXZvdG5pY2vDqWhvIG9kYm9ybsOta2EKQ291bnRyeSAvIHplbcSbIFJlZzFzdHJhdDFvbiBmZWUgLyBUcmFuc3BvcnRhbW9uIENvc3QgLyBIb3RlMSBwZXIgbWcgaHQgLyBDZW5hIHphIE51bWJlciBvZiBtZ2h0cyAvCnJlZ3JzdHJhxI1uxZkgcG9wbGF0ZWsgbsOha2xhZHkgbmEgZG9wcmF2dSBob3JlISB6YSBub2MgcG/EjWV0IGhkZWYKTWFkbmQgMjcgNjAwIENaSyAvIHBlciBwZXJTb24gMjAgMDAwIENaSyAvIHBlciBwZXJTb24gMzcgNDAwIGN6PjwvIHBlciBwZXJTb24gNCBtZ2h0cwoKIAoKIAoKIAoKIAoKIAoKRWR1Y2F0aW9uYWwgR3JhbnRBZ3JlZW1lbkxBcHJpbCAyMDI0Ck9OSVQgbnVtYmVyIDQwMjQ0MTU4CgpGYWdlMTAwxZkxMwoKIAoKU2NoZWR1bGUgMgoKU3BlY2lmaWMgY291bnRyeSBjb21wbGlhbmNlIHByb2NlZHVyZXMgYW5kIFBvc3QgRXZlbnQgUmVwb3J0aW5nIHNjb3BlCgphbmQgZGVhZGxpbmVzCgpQxZnDrWxvaGEgxI0uIDIKClNwZWNpZmlja8OpIHBvc3R1cHkgcHJvIGtvbmtyw6l0bsOtIHplbcSbIGEgcm96c2FoIGEgbGjFr3R5IHBybyBwb2TDoXbDoW7DrQoKenByw6F2IHBvIGFrY2kKCiAKCiAKCiAKCiAKCiAKCiAKCiAKCiAKCiAKCiAKCiAKCiAKCiAKCiAKCkNvdW50cnkgLyBMaXN0IG9mIERldGFpbAp6ZW3EmyBhdHRlbmRlZXMgKyBFc3RpbWEgZWQgXwpQcmxvcgppbnN0aXR1dGlvbnMgTGlzdCBvZiB0ZWQgZXhwZW4gXyBfIF8Kbm90bGZsYXRsCnByaW9yIHRvIHRoZSBhdHRlbmRlZXMgKyB0ZXN0cyBzZXMgcGVyCm9uIHRvIFBvc3QgZXZlbnQKRXZlbnQgLyBpbnN0aXR1dGlvbnMgcGVyIGF0dGVuZCBTcGVjaWZpYwpfIGxvY2FsIHRyYW5zcGFyZW5jeQpzZXpuYW0gcG9zdCBFdmVudCAvIGF0dGVuZCBlZSAvIHJlcXVscmVtZSBfIF8gXwphdXRob3JsdGwgcmVxdWxyZW1lbnRzIC8Kw7rEjWFzdG7DrWvFryArIHNlem5hbSBlZSAvIHBvZHJvIG50cyAvCl8gXyBfIF8gZXMgLyBwb8W+YWRhdmt5IG5hCnpkcmF2YXRtZWvDvTogw7rEjWFzdG7DrWt1ICsgb2RoYWQgYm7DvSBzcGV1ZmzDumUnIF8KXyBfIGF6bmFtZW4gdHJhbnNwYXJlbnRuYXMKaCB6YcWZw616ZW7DrSB6ZHJhdmF0bWNrw70gbsOha2xhZCByb3pwbHMgcG/FvmFkYXZreSBfCl8gXyBfXyBfIF8gXyDDrSBwxZllZGVtICEgcGEgYWt1CnByZWQgQWt1IDpoIHphbnplbSB1IG5hIG5ha2xhZApfIG3DrXN0bsOtbQpwYSBBa3Ugw7rEjWFzdG7DrSB0aSBuYSBfIF8KXyBfXyBfIG9yZ2FudW0Ka2EgdWNhc3RubAprYQpGcmFuY2UgLyA2MCBkYXlTIGJlZm9yZSA5MCAzMCBYIFggKSgKRnJhbmNyZSB0aGUgRXZlbnQgLyA2MCBkYXlzIGRheXMKZG7FmXDFmWVkIEFrY8OtIGJlZm9yZSBhZnRlcgozMCBkYXlzIGFmdGVyCnRoZSB0aGUKdGhlIEV2ZW50LyAzMApFdmVudCAvIEV2ZW50IC8KZG7DrSBwbyBBa2NyCjkwIGRuw60gMzAgZG7DrQpwxZllZCBwbyBBa2NyCkFrY8OtClR1cmtleSAvIDYwIGRheXMgYmVmb3JlIDMwIGRheXMgYWZ0ZXIgNjAgMzAgPjwgPjwKVHVyZWNrbyB0aGUgRXZlbnQgLyA2MCB0aGUgRXZlbnQgLyAzMCBkYXlzIGRheXMKZG7DrSBwxZllZCBBa2PDrSBkbsOtIHBvIEFrY3IgYmVmb3JlIGFmdGVyCnRoZSB0aGUKRXZlbnQgLyBFdmVudCAvCjYwIGRuw60gMzAgZG7DrQpwxZllZCBwbyBBa2NyCkFrY8OtClBvcnR1Z2F3IC8gTkEvIDE1IGRheXMgYWZ0ZXIgTkEvIE5BLyA+PApQb3J0dWdhbHNrbyBuZXZ6dGFodWplIHNlIHRoZSBFdmVudC8gMTUgbmV2enRhIG5ldnp0YQpkbsWZcERBa2NyIGh1amUgc2UgaHVqZSBzZQpCZVxnXHVtIEZtYWhlYXcgU3VwcG9ydC9TUE9IU09ybWcgYnkgTWVkdHJvbWMsIChhIG1lbWJlciBvZiBiZU1lZFRlY2gpIG9mIGhlYVx0aGNhcmUgcHJvZmVzc3RlaGF3cyB0byBhdHRlbmQgdGh3cmRycGFydHkgb3JnYW16ZWQgc2VlaHRtYwphbmQgZWR1Y2F0dG9uYXcgZXZlbnRzIFw1IG5vIFxvbmdlciBhSG93ZWQgYXMgb2YgSmFudWFyeSAxc3QsIDIwMjIKCiAKCiEgV2hlbiBpbnZpdGluZyBIQ1AncyBmcm9tIEZyYW5jZToKOTAgZGF5cyBiZWZvcmUgdGhlIGV2ZW50IHRyYW41bVw1NVxvbiB0byBNZWR0cm9tYyBvZiB0aGUgaHN0IG9mIHRoZSBIQ1BzCndobyB3bSBhdHRlbmQgdGhlIG1lZXRtZywgbWR1ZG1nIG5hbWUgU3VybmFtZSBSUFBTIGhuYWhkIGVTdHdtYXRlZAoKXG9kZ21nIHRyYXZlXCBhbmQgcmVnbXRyYWhvbiBDb1N0UyBBIG5vdG1jYWhvbiBTaGFIIGJlIGRvbmUgdG8gdGhlCkZyZW5jaCBtZWR0ZWF0IGJvYXJkIG9mIHBoeW1tYW4gYnkgTWVkdHJvbWMKCiAKCjMwIGRheXMgYWZ0ZXIgdGhlIGV2ZW50LCB0cmFuNW1cNTVcb24gdG8gTWVkdHJvbWMgb2YgdGhlIGhzdCBvZiB0aGUgSENQcyB3aG8KYXR0ZW5kZWQgdGhlIGV2ZW50IHd3dGggYUggZGV0YcO6ZWQgYW5kIGFjY3VyYXRlIGV4cGVuc2VzIHRha2VuIG0gY2hhcmFlClRoZVNlIGFtb3VudFMgd20gYmUgZFxTZG9TZWQgb24gdGhlIEZyZW5jaCB0cmFuU3BhcmVuY3kgd2Vic3d0ZQoKU3BlY21jIHJlcW1yZW1lbnRTIGZvciBcb2RnbWc6IE1heCBjYXRlZ29yeSBhSG93ZWQgXFMgNOKAlCAsIDI1MCDigqwKCm1heHdtdW0gcGVybWdodCwgYnJlYWtmYXN0YW5kIHRheGVzIG1kdWRlZAoKISBXaGVuIEludml0aW5nIGFuIEhDUCBmcm9tIFR1cmtleToKNjAgZGF5cyBiZWZvcmUgdGhlIGV2ZW50LCB0cmFuNW1cNTVcb24gdG8gTWVkdHJvbWMgb2YgdGhlIGhzdCBvZiB0aGUgVHVya3dzaApIQ1BzIHdobyB3bSBhdHRlbmQgdGhlIG1lZXRtZywgbWR1ZG1nIG1TVXRxdW4gbmFtZSBvZyBkZWdhcnRtZW50CgpuYW1lIHR3ZGUgb2ZIQ1AgbmFtZSBTdXJuYW1lIFxEIG51bWJlciwgYW5kIGV4cGVuU2VTIGNvdmVyZWQgKHRyYXZlXCwKCiAKCkVkdWNhdGlvbmFsIEdyYW50QWdyZWVtZW5MQXByaWwgMjAyNApPTklUIG51bWJlcgoKISBQxZlpIHBvenbDoW7DrSB6ZHJhdm90bmlja8O9Y2ggb2Rib3Juw61rxa8geiBGcmFuY2llOgoKOTAgZG7DrXDFmWVkIGFrY8OtLCB6YVNcw6FuKCBTZXpuYW11IHpkcmF2b3RtY2vDvWNoIG9kIGJvcm5rxa8sIGt0ZUggU2UgYnVkb3UKc2V0a8OhbSDDusSNYXN0bXQsIDVwb1xlxI1uMDV0XCBNZWR0cm9tYywgcGjEjWVtxb4gdiBTZXpuYW11IGJ1ZGUgdXZlZGVubwp0YWtlIG1laG8gbW1tIMSNIFJQUFMgJiBvZGhhZCBuw6FrXGFkxa8gaGEgdWJ5dG92w6FNIGNlc3R1ICYgcmVtU3RyYVUKU3BvXGXEjW4wNXQgTWVkdHJvbWMgemHFoVxlIG96bsOhbWVoKGhhaGNvdcW+c2tlIFxla2HFmXNrZSByYWTEmywgcG9kIGh0xb4gZGFuw70KClxla2HFmXNwYWTDoQoKMzAgZG7DrWJvIGFrY2ksIHphU1zDoW4oIFNlem5hbXUgemRyYXZvdG1jaydjaCBvZGJvbXRtIGt0ZUggU2UgYWtjZQp6w7rEjWFzdG1oIFNlIFbFoWVtXCBib2Ryb2JoJ210ICYgRMWZZVNuxJsgYXN3ZWgnbXQgaHJhxb5laCdtdCAnXG9oYW1cCjVwb1xlxI1uMDV0XCBNZWR0cm9tYyBUeXRvIMSNw6FzdGt5IGJ1ZG91IHV2ZWRlbnkgbmEgZnJhbmNvdXpza8O9Y2gKd2Vib3bDvWNoIHN0csOhbmvDoWNoIHBybyDFvmF5dMWhdGVoKCB0cmFuU3BhcmVudG5vU1UKClNwZWNtY2tlIHBvxb5hZGF2a3kgbmEgdWJ5dG92w6FoaCBNYXhcbcOhXG4oIGRvdm9cZW7DoSB0YXRlZ29uZXllIDTigJQKCnJtYW1tw6FtxJsgMjUwIOKCrCB6YSBub2MsIHbEjWV0bsSbIFNudGRhbsSbICYgZGFodnBvcHdhdGt1CgohIFDFmWkgcG96dsOhbsOtIHpkcmF2b3RuaWNrw71jaCBvZGJvcm7DrWvFryB6IFR1cmVja2E6CgphbyBkbsOtZ8WZZWQgYWtjw60sIHphU1zDoW4oIFNlem5hbXUgemRyYXZvdG1ja8O9Y2ggb2QgYm9tdG0gelR1cmVja2EsIGt0ZUgKU2UgYnVkb3Ugc2V0a8OhbSDDusSNYXN0bXQsIDVwb1xlxI1uMDV0XCBNZWR0cm9tYywgcGjEjWVtxb4gdiBTZXpuYW11IGJ1ZGUKCnV2ZWRlbiB0YWvDqSBuw6F6ZXYgemRyYXZvdG1ja2VobyB6YUh6ZU0gbcSbc3RvIG7DoXpldiBvZGTEm1xlbiggdHd0bQoKIAoKRmFnZUggZE0zCgogCgogCgphY2NvbW1vZGF0bWgsIHJlbmd0cmF0d29uKSAuIEEgbmN0bWNhaGNuIFNoYWggYmUgZG9uZSB0byBNXG1TdFZ5IG9mCgpIZWFcdGggKE1PSCkgYnkgTWVkdHJvbWMKCjMwIGRheXMgYWZ0ZXIgdGhlIGV2ZW50LCB0cmFoZ210Z21vaCB0byBNZWR0cm9tYyBvZiB0aGUgXFxTdCBvZiB0aGUgVHUgcmt3NWgKSENQNSB3aG8gYXR0ZW5kZWQgdGhlIGVWZW50V1x0aCBhSCBkZXRhw7plZCBhbmQgYWNjdXJhdGUgZXhwZW5TZVMgY292ZXJlZAoodHJhdmVcLCBhY2NvbW1vZCBhbWVuLCByZW5ndHJhdHdvbikuIENvcHkgb2YgYUggbXZvd2NlUyByZVxhdG1nIHRvIFR1cmthaApIQ1A1IG11U3QgYmUgcHJvdndkZWQgdG8gTWVkdHJvbWMuIFRoZVNlIGFtb3VudFMgYW5kIG12b3djZVMgd3dIIGJlCgpkXFNkb1NlZCB0byB0aGUgTVxtU3RyeSBvZiBIZWFcdGguIChNT0gpCgohIFdoZW4gSW52aXRpbmcgYW4gSENQIGZyb20gUG9ydHVnYWw6CgoxIDUgZGF5cyBhZnRlciB0aGUgZGF0ZSBvZiB0aGUgZXZlbnQsIHRyYWhnbXRnZ3dvaCB0byBNZWR0cm9tYyBvZiB0aGUgXFxTdCBvZgp0aGUgUG9ydHVndWVmxaFlIEhDUCdTd2hvIGF0dGVuZGVkIHRoZSBFdmVudCBtY21kbWc6IG5hbWVTIG9mdGhlIEhDUCdTCmFuZCBuYW1lUyBvZiB0aGV3ciBcblN0d3R1dHdvblMuIFRodTsgXFxTdCBcNSBuZWVkZWQgZm9yIG5vdHRmdGNhdHdvbiB0byBcTkZBUk1FRAooTmF0cm9uYWxBdXRob250eSBvZk1lZHJjbWVzIGFuZCBIZWFsdGggUHJvZHVjdHMpIOKAnmhkIGVyIHRoZSBQb3J0dWcgdWVTZQoKdHJhblNwYXJlbmN5IHJlcW1yZW1lbnRmxaEuCgpUaGUgXFxTdCBtdVN0IGJlIGRlaHZlcmVkIHRvIE1lZHRyY21jIGJ5IGVtYW4gdG86CgpFZHVjYXRpb25hbCBHcmFudEFncmVlbWVuTEFwcmlJIDIwMjQKT05JVCBudW1iZXIKCiAKCnpkcmF2b3RtY2vDqWhvIG9kIGJvcm7DrWthIHRlaG8gXG3DqW5vIGVtbWVodCBhIHRkZWh0dGZ0a2HEjWh0xI10ZXRlIGEgZMOhXGUKaHJhemVuw6kgdsO9XG9oeSAoY2VTdGEsIHUgYnl0b3bDoW7DrSwgcmVuZ3RyYWNlKS4gU3BvXGXEjW4wNXQgTWVkdHJvbWMgemHFoVxlCgpvem7DoW1lbsOtIG0gXG1TdGVyU3R2dSBaZCByYXZvdG1jdHbDrS4KCjMwIGRuw60gcG8gYWtjaSwgemFkw6Fuw60gU2V6bmFtdSB6ZCByYXZvdG1jayAnY2ggb2Rib3Juw61rxa8geiBUdSByZWNrYSBrdGXFmcOtIDVlCgpTZXRrw6Fuw616w7rEjWFmxaF0bWggU3BkZcSNbm9TVSBNZWR0cm9tYyB2xI1ldG7EmyBwxZllU27DqWhvIFNlem5hbXUgYSBwxZllU27DqQoxNTIgxaFlIHbFoWVjaCBocmF6ZW7DvWNoIHbDvVxvaCAoY2VTdGEsIHVieXRvdsOhbsOtLCByZWcgXFN0cmFjZSkuIFNwb1xlxI1uMDV0XApNZWR0cm9tYyBidWRvdSBwb1NreXRudXR5IGtvcHdlIHbFoWVjaCBmYWt0dXJ2enRhaHVqw61jw61jaCBTZSBrZQp6ZHJhdm90bWNrw71tIG9kIGJlcm7DrWvFr20geiBUdXJlY2thLiBUeXRvIMSNw6FndGt5IGEgZmFrdHVyeSBidWRvdSBwb1NreXRudXR5CgptIFxtU3RlclN0dnUgWmRyYXZvdG1jdHbDrS4KCi8gUMWZaSBwb3p2w6Fuw60gemRyYXZvdG5pY2vDvWNoIG9kYm9ybsOta8WvIHogUG9ydHVnYWxza2E6CjE1IGRuw60gZ28gYWtjaSwgemFkw6Fuw60gU2V6bmFtdSB6ZHJhdm90bWNrw71jaCBvZGJvcm7DrWvFryB6IFBvcnR1Z2Fia2EsIGt0ZcWZw60KU2UgQWtjZSB6dMOtIMSNYTV0bWgsIDVwb1xlxI1uMDV0XCBNZWR0cm9tYywgdsSNZXRuxJs6IG1lbiB6ZHJhdm90bWNrw71jaAoKb2Rib3Juw61rxa8gYSBuw6F6dsWvIGUgXENoIHpkcmF2b3RtY2vDvWNoIHphxZnDrXplbsOtLiBUZW50byBTZXpuYW0gSmUgcG90xZllYmEKa3bFr2ggdnlyb3p1bcSbbsOtIHBybyBcTkZBUk1FRCAoTsOhcm9kbsOtIMO6xZlhZCBwcm8gIcOpxI1ydmEgJiB6ZHJhdm90bWNrw6kKCnbDvXJvYmt5KSBwb2RcZSBwb3J0dWdhXDVrw71jaCBwb8W+YWRhdmvFryBuYSB0cmFuU3BhcmVudG5vU3QuCgpTZXpuYW0gU2UgZG9ydcSNdWplIDVwb1xlxI1uMDV0XCBNZWR0cm9tYyBlcm1hw7plbSBuYSBhZHJlc3UKCkZhZ2V3em9mbQoKU2RuZHVsb2EKCkJVU0lOIEVTUyBDRE4gRFVDSScgU1RBTkRBUkRTCgpNZWRpY2FsIENvbmZvcmNuY2NzLiBDb25ncmVzc3UgJiBwcm9mZXNzaW9uYWwgTXV0aW5ncwoKUMWZw61sb2hhIMSNLiAzCgpTVEFOREFSRFkgT0JDSE9ETsONSE8gSkVETsOBTsONCgpMw6lrYcWZc2vDqSBrb25mZXJlbmNpLiBrb25ncmVzeWEgb2Rib3Juw6Egc2V0a8OhbsOtCgogCgpDb25mZXJlbmNlcywgY29uZ3Jlc3NlcywgYW5kIHByb2Zlc3Npb25hbCBtZWV0aW5ncyB3aGljaCBNZWR0cm9uaWMgc3VwcG9ydHMgc2hvdWxkCmdlbmVyYWxseSBiZSByZWNvZ25pemVkIGFuZCByZXNwZWFlZCB3aXRoaW4gdGhlIG1lZGljYWwgY29tbXVuaXR5IGFuZCBoYXZlIGEgY2xvc2UKcmVsYXRpb25zaGlwIHRvIE1lZHRyb25pYyBwcm9kdWN0cyB0aGF0IGFyZSBkaXJlY3RseSByZWxldmFudHRvdGhlIG1lZGljYWwgY2FyZQpwcm9mZXNzaW9uYWwgJ3MgcHJhY3RpY2UuIFRoZSBmZWVzIHdoaWNoIHRoZXkgYXJlIHBhaWQgdG8gbWVkaWNhbCBjYXJlIHByb2Zlc3Npb25hbHMgZm9yCm1ha2luZyBwcmVzZW50YXRpb25zIGFuZCB0aGUgY29zdHMgZm9yd2hpY2ggbWVkaWNhbCBjYXJlIHByb2Zlc3Npb25hbHMgYXJlIHJlaW1idXJzZWQgaW4KY29ubmVjdGlvbiB3aXRoIHN1Y2ggZXh0ZXJuYWxseSBvcmdhbml6ZWQgbWVldGluZ3MgYW5kIHNoYWxsIGJlIHJlYXNvbmFibGUgYW5kIGNvbnNpc3RlbnQKd2l0aCB0aGVpciBwcmltYXJ5IGVkdWNhdGlvbmFsIHB1cnBvc2UuIE92ZXJhbGwgbW9kZXN0eSBpcyBhZHZpc2VkLiBFeHBlbnNlcyBtYXkgYmUKcmVpbWJ1cnNlZCBmb3IgdGhlIG1lZGljYWwgY2FyZSBwcm9mZXNzaW9uYWwgb25seS4gKEZheW1lbnRzZm9yIHNwb3VzZXMgYXJlIG5vdAoKcGVybWl0dGVkLikKClRyYWluaW5nIGFuZCBlZHVjYXRpb24gbXVzdCBnZW5lcmFsbHkgY29uc3RpdHV0ZSBhIHN1YnN0YW50aWFsIG1ham9yaXR5IG9mdGhlIHByb2dyYW0gZGF5LgpJbiB0aGUgZXZlbnQgb2ZhIG11bHRpcGxlIGRheSBwcm9ncmFtLCBzdWJzdGFudGlhbCB0cmFpbmluZyBhbmQgZWR1Y2F0aW9uIG11c3QgYmUKCmNvbmR1Y3RlZCBvbiBlYWNoIHByb2dyYW0gZGF5LgoKVGhlIGxvY2F0aW9uIHNlbGVjdGVkIGZvcnRyYWluaW5nIHNlc3Npb25zIHNoYWxsIGJlIHNlbGVjdGVkIGJhc2VkIHVwb24gcHJvZ3JhbQpyZXF1aXJlbWVudHMgYW5kIENvbnZlbmllbmNlIG9mYXR0ZW5kZWVzLiBMb2NhdGlvbnMgc2hvdWxkIGdlbmVyYWxseSBiZSBzZWxlY3RlZCBiYXNlZApvbiB0aGUgcXVhbGl0eSBvZnRoZWlyIGNvbmZlcmVuY2UgZmFjaWxpdGllcywgdGhlIHJlYXNvbmFibGVuZXNzIG9mdGhlaXIgcHJpY2UsIGFuZCB0aGUKCmNvbnZlbmllbmNlIG9mdGhlIGxvY2F0aW9uLgoKVGhlIGNvc3RzIGluY3VycmVkIGluIHByb3ZpZGluZyB0cmFpbmluZyBzZXNzaW9uc2ZvciBtZWRpY2FsIGNhcmUgcHJvZmVzc2lvbmFscyBzaGFsbCBiZQpjb21tZW5zdXJhdGUgd2l0aCB0aGUgZWR1Y2F0aW9uYWwgY29udGVudCBvZnRoZSBwcm9ncmFtLiBBbnkgc29jaWFsIGFjdGl2aXRpZXMgdGhhdCBhcmUKcmVpbWJ1cnNlZCBtdXN0IGJlIG1vZGVzdCBpbiBuYXR1cmUgYW5kIGNvc3QsIGFuZCBiZSBpbmNpZGVudGFsIHRvdGhlIHRyYWluaW5nIHNlc3Npb24KYW5kIG5vdHRoZSBwcmltYXJ5IHB1cnBvc2Vmb3IgaXQuIEdpZnRzIHRvIGluZGl2aWR1YWwgbWVkaWNhbCBjYXJlIHByb2Zlc3Npb25hbHMgZHVyaW5nIHRoZQoKY291cnNlIG9mdGhlIHRyYWluaW5nIHNlc3Npb24gYXJlIG5vdCBwZXJtaXR0ZWQuCgpUaGUgZm9sbG93aW5nIGFyZSBpbmNsdWRlZCBhbW9uZyB0aG9zZSBpdGVtcyBmb3J3aGljaCByZWFzb25hYmxlIGNvc3RzIG1heSBnZW5lcmFsbHkgYmUKcGFpZArigJ4gTG9kZ2luZywgbWVhbHMsIHRyYXZlbC4gQXMgYSBnZW5lcmFsIHJ1bGUsIGVjb25vbXkgY2xhc3MgdHJhdmVsIHNob3VsZCBiZSB1c2VkIG9uIGFsbAoKZmxpZ2h0cy4KKiBSZWdpc3RyYXRpb24gZmVlcy4KKiBSZWNlcHRpb24gYW5kIHByb2dyYW0gYmFucXVldC4KCiogRWR1Y2F0aW9uYWwgb3IgbGVjdHVyZSBtYXRlcmlhbCAoYm9va3MsIFNsaWRlcywgY29waWVzLCBkZW1vcykKCldoZW5ldmVyIHBvc3NpYmxlIGFuZCBwcmFjdGljYWwsIHRyYXZlbCBleHBlbnNlcyAoZWcuLCBsb2RnaW5nLCBtZWFscywgYW5kIHRyYW5zcG9ydGF0aW9uKQpzaG91bGQgYmUgcGFpZCBkaXJlY3RseXRvdGhlIGhvdGVsLCBhaXJsaW5lIGFuZCB0cmF2ZWwgYWdlbmN5LCB0aGUgb3JnYW5pemF0aW9uIGluIGNoYXJnZSBvZgp0aGUgY29uZ3Jlc3MuIElmbm90IHBhaWQgZGlyZWN0bHksIGFueSBwYXltZW50cyBzaG91bGQgYmUgc3VwcG9ydGVkIGJ5IG9yaWdpbmFsIHJlY2VpcHRzIG9yCgpvdGhlciBzdXBwb3J0aW5nIGRvY3VtZW50YXRpb24uCgpFeHBlbnNlcyBpbmN1cnJlZCBieSBtZWRpY2FsIGNhcmUgcHJvZmVzc2lvbmFscyBzaGFsbCBvbmx5IGJlIHJlaW1idXJzZWQgYXMgbmVjZXNzYXJ5IGFuZAppbmNpZGVudGFsIHRvIGF0dGVuZGluZyB0aGUgbWVldGluZy4gSG93ZXZlciwgd2hlbiBwcm9ncmFtIHNjaGVkdWxpbmcgbWFrZXMgcmV0dXJuaW5nCmhvbWUgb24gdGhlIGxhc3QgcHJvZ3JhbSBkYXkgZGlmZmljdWx0IG9yIHN0YXlpbmcgb3Zlcm5pZ2h0IHJlZHVjZXMgdGhlIGNvc3Qgb2YgYWlyZmFyZSwgYQptb2Rlc3QgZXh0ZW5zaW9uIGlzIGFsbG93ZWQuIChPbmx5IGV4dHJhIGhvdGVsIGFjY29tbW9kYXRpb24gYW5kIHJlYXNvbmFibGUgbWVhbAoKZXhwZW5zZXMgZHVyaW5nIHRoZSBleHRlbmRlZCBwZXJpb2Qgc2hhbGwgYmUgcGFpZCBpbiB0aGVzZSBjaXJjdW1zdGFuY2VzKS4KCkFJSSBleHBlbnNlcyBwYWlkIHVuZGVyIHRoZXNlIHN0YW5kYXJkcyBzaGFsbCBoYXZlIGFkZXF1YXRlIGRvY3VtZW50YXRpb24gaW5jbHVkaW5nIGEKd3JpdHRlbiBjb25ncmVzcy9tZWV0aW5nIGF0dGVuZGFuY2Ugb3IgaG9ub3Jhcml1bSBsZXR0ZXIgc2lnbmVkIGJ5IHRoZSBtZWRpY2FsIGNhcmUKCnByb2Zlc3Npb25hbCwgYW4gYWdlbmRhIGFuZCBhbiBlbnVtZXJhdGlvbiBvZnRoZSBjb3N0cywgcGFydGljaXBhbnRzLCBhbmQgZmFjdWx0eS4KClRoZXNlIHJlcXVpcmVtZW50cyBtdXN0IGJlIGZ1bMWIbGxlZCBwcmlvcnRvdGhlIHRyYWluaW5nIHNlc3Npb250byB3aGljaCBhIHBoeXNpZGFuIGlzCmludml0ZWQgYW5kL29yIGF0d2hpY2ggaGUgb3Igc2hlIHdpSUkgc3BlYWsgYW5kIGZvcndoaWNoIHRoZSBwaHlzaWNpYW4gaGFzIG9idGFpbmVkIGFueQoKbmVjZXNzYXJ5IGFwcHJvdmFsIGZyb20gaGlzL2hlciBtZWRpY2FsIGluc3RpdHV0aW9uLgoKRWR1Y2F0aW9uYWwgR3JhbnRBZ3JlZW1lbnRfQXByaXwgMjAyNApPTklUIG51bWJlcjoKCiAKCk9iZWNuxJsgcGxhdMOtLCDFvmUga29uZmVyZW5jZSwga29uZ3Jlc3kgYSBvZGJvcm7DoSBzZXRrw6Fuw60sIGt0ZXLDqSBzcG9sZcSNbm9zdCBNZWR0cm9uaWMKcG9kcG9ydWplLCBieSBtxJtseSBiw710IHYgcsOhbWNpIHpkcmF2b3RuaWNrw6kgb2JjZSB1em7DoXZhbsOpIGEgcmVzcGVrdG92YW7DqSBhIG3Em2x5IGJ5IG3DrXQKw7p6a8O9IHZ6dGFoIGsgdsO9cm9ia8WvbSBzcG9sZcSNbm9zdGkgTWVkdHJvbmljLCBrdGVyw6kgbWFqw60gcMWZw61tw70gdsO9em5hbSBwcm8gcHJheGkKcHJvZmVzaW9uw6FsbsOtY2ggemRyYXZvdG7DrWvFry4gb2QgbWVueSwga3RlcsOpIHNlIHByb2Zlc2lvbsOhbG7DrW0gemRyYXZvdG7DrWvFr20gcG9za3l0dWrDrSB6YQpwxZllZG5lc2Vuw60gcHJlemVudGFjw60sIGEgdsO9bG9oeSwga3RlcsOpIHNlIHByb2Zlc2lvbsOhbG7DrW0gemRyYXZvdG7DrWvFr20gaHJhZMOtIHYgc291dmlzbG9zdGkgcwp0xJttaXRvIGV4dGVybsSbIHBvxZnDoWRhbsO9bWkgc2V0a8OhbsOtbWksIG11c2kgYnl0IHDFmWltxJvFmWVuw6kgYSBvZHBvdsOtZGF0IHN2w6ltdSBobGF2bsOtbXUKdnpkIMSbbMOhdmFjw61tdSDDusSNZWx1LiBEb3BvcnUgxI11IGplIHNlIGNlbGtvdsOhIHVtw61ybsSbbm9zdC4gVsO9bG9oeSBqZSBkb3ZvbGVubyBocmFkaXQgcG91emUKCnByb2Zlc2lvbsOhbG7DrW0gemRyYXZvdG7DrWvFr20uIChQbGF0aXQgxb5hIG1hbsW+ZUllL21hbsW+ZWxreSBuZW7DrSBwxZnDrXB1c3Ruw6kuKQoKT2JlY27EmyBwbGF0w60sIMW+ZSDFoWtvbGVuw60gYSB2emTEm2zDoXbDoW7DrSBtdXPDrXR2b8WZaXQgcG9kc3RhdG5vdSB2xJt0xaFpbnUgcHJvZ3JhbW92w6lobyBkbmUuIHYKcMWZw61wYWTEmyB2w61jZWRlbm7DrWhvIHByb2dyYW11IG11c8OtIHBvZHN0YXRuw6kgxaFrb2xlbsOtIGEgdnpkxJtsw6F2w6Fuw60gcHJvYsOtaGF0IHYga2HFvmTDqW0gZG51Cgpwcm9ncmFtdS4KCk3DrXN0YSBrb27DoW7DrSDFoWtvbGljw61jaCBha2PDrSBqZSBudXRuw6kgdm9saXQgcG9kbGUgcHJvZ3JhbW92w71jaCBwb8W+YWRhdmvFryBhIHZob2Rub3N0aSBwcm8Kw7rEjWFzdG7DrWt5LiBPYmVjbsSbIHBsYXTDrSwgxb5lIG3DrXN0YSBrb27DoW7DrSBieSBzZSBtxJtsYSB2eWLDrXJhdCBwb2RsZSBrdmFsaXR5IGtvbmZlcmVuxI1uw61obwoKdnliYXZlbsOtLCBjZW5vdsOpIHDFmWltxJvFmWVub3N0aSBhIHZob2Rub3N0aSBkYW7DqWhvIG3DrXN0YS4KCnbDvWxvaHksIGt0ZXLDqSBwxZlpIHBvxZnDoWRhbmwnIMWha29saWPDrWNoIGFrY8OtIHBybyBwcm9mZXNpb27DoWxudMW+ZHJhdm90bnRreSB2em5pa25vdSwgbXVzaSBieXQKw7ptxJtybsOpIHZ6ZMSbbMOhdmFjw61tdSBvYnNhaHUgcHJvZ3JhbXUuIEpha8Opa29saSBocmF6ZW7DqSBzcG9sZcSNZW5za8OpIGFrdGl2aXR5IG11c2kgYnl0CnN2w71tIGNoYXJha3RlcmVtIGkgY2Vub3UgdW3DrXJuxJtuw6kgYSBiw710IHBvdXplIHZlZGxlasWhw60gc291xI3DoXN0w60gxaFrb2xpY8OtIGFrY2UsIGEgbmlrb2xpIGplasOtbQpobGF2bsOtbSDDusSNZWxlbS4gT2JkYXJvdsOhdmF0amVkbm90bGl2w6kgcHJvZmVzaW9uw6FsbsOtIHpkcmF2b3Ruw61reSB2IHByxa9ixJtodSDFoWtvbGljw60gYWtjZQoKbmVuw60gcMWZw61wdXN0bsOpLgoKSyBwb2xvxb5rw6FtLCBrdGVyw6kgamUgb2JlY27EmyBkb3ZvbGVubyB2IHDFmWltxJvFmWVuw6kgdsO9xaFpIGhyYWRpdCwgcGF0xZnDrQoKKiBVYnl0b3bDoW7DrSwgc3RyYXZhLCBjZXN0YS4gT2JlY27EmyBwbGF0w60sIMW+ZSBwxZlpIHZlxaFrZXLDvWNoIGxldGVjaCBieSBzZSBtxJtsYSB2eXXFvsOtdmF0Cgpla29ub21pY2vDoSBjZXN0b3Zuw60gdMWZw61kIGEuCiogUmVnaXN0cmHEjW7DrSBwb3BsYXRreS4KKiBVdsOtdGFjw60gYSBwcm9ncmFtb3bDvSBiYW5rZXQuCgrigJxWemTEm2zDoXZhY8OtIG5lYm8gcMWZZWRuw6HFoWtvdsOpIG1hdGVyacOhfHkoa25paHksIGRpYXBveml0aXZ5LCBrb3BpZSwgdWvDoXpreSkKCktkeWtvbGkgamUgdG8gbW/Fvm7DqSBhIHByYWt0aWNrw6ksIG3Em2x5IGJ5IHNlIGNlc3Rvdm7DrXbDvWxvaHkgKG5hcMWZLiB1Ynl0b3bDoW7DrSwgc3RyYXZhIGEKZG9wcmF2YSkgaHJhZGl0IHDFmcOtbW8gaG90ZWx1LCBhZXJvbGluacOtbSBhIGNlc3Rvdm7DrW0ga2FuY2Vsw6HFmcOtbSwgb3JnYW5pemFjaSB6YSBrb25ncmVzCm9kcG92xJtkbsOpLiBOZWhyYWR0emxpIHNlIHDFmcOtbW8sIG3Em2x5IGJ5IGLDvXQgdmXFoWtlcsOpIHBsYXRieSBwb2Rsb8W+ZW55IG9yaWdpbsOhbHkgw7rEjXRlbmVrCm5lYm8gamluw71taSBwb2RrbGFkeS4KClbDvWxvaHkgdnpuaWtsZSBwcm9mZXNpb27DoWxuw61tIHpkcmF2b3Ruw61rxa9tIGplIGRvdm9sZW5vIGhyYWRpdCBwb3V6ZSB2IG51dG5lbSByb3pzYWh1IGEgdgpzb3V2aXNsb3N0aSBzIMO6xI1hc3TDrSBuYSBzZXRrw6Fuw60uIFBva3VkIGplIHbFoWFrIHogZMWvdm9kdSDEjWFzb3bDqWhvIHJvenZyxb5lbsOtIHByb2dyYW11IG7DoXZyYXQKZG9txa8gdiBwb3NsZWRuw60gcHJvZ3JhbW92w70gZGVuIG9idMOtxb5uw70gbmVibyBwb2t1ZCBzZSBwxZllbm9jb3bDoW7DrW0gc27DrcW+w60gY2VuYSBsZXRlbmt5LApqZSBkb3ZvbGVubyBwb2J5dCBtw61ybsSbIHByb2Rsb3XFvml0LiAoWmEgdXZlZGVuw71jaCBva29sbm9zdMOtIGplIHYgcHLFr2LEm2h1IHRha3RvCnByb2Rsb3XFvmVuw6lobyBwb2J5dHUgZG92b2xlbm8gaHJhZGl0IG5hdsOtYyBwb3V6ZSB1Ynl0b3bDoW7DrXYgaG90ZWx1IGEgdsO9ZGFqZSBuYSBzdHJhdnUgdgoKcMWZaSBtxJvFmWVuw6kgdsO9xaFpLikKClZlxaFrZXLDqSB2w71sb2h5LCBrdGVyw6kgc2UgbmEgesOha2xhZMSbIHTEm2NodG8gc3RhbmRhcmTFryBocmFkw60sIG11c2kgYnl0IG9kcG92w61kYWrDrWPDrW0KenDFr3NvYmVtIHpkb2t1bWVudG92w6FueSwgdsSNZXRuxJsgcMOtc2VtbsOpIMO6xI1hc3RpIG5hIGtvbmdyZXN1L3NldGvDoW7DrSBuZWJvIHNkxJtsZW7DrSAoKQpob25vcsOhxZlpIHMgcG9kcGlzZW0gcHJvZmVzaW9uw6FsbsOtaG8gemRyYXZvdG7DrWvFrywgcHJvZ3JhbXUga29uZ3Jlc3Uvc2V0a8OhbsOtIGEgcMWZZWhsZWR1Cgpuw6FrbGFkxa8sIMO6xI1hc3Ruw61rxa8gYSBwxZllZG7DocWhZWrDrWPDrWNoLgoKVHl0byBwb8W+YWRhdmt5IGplIG51dG5lIHNwbG5pdCBwxZllZCBrb27DoW7DrW0gdnpkxJtsw6F2YWPDrSBha2NlLCBuYSBrdGVyb3UgamUgbMOpa2HFmSBwb3p2w6FuCmEvbmVibyBuYSBrdGVyw6kgYnVkZSBob3ZvxZlpdCBhIHYgc291dmlzbG9zdGkgcyBuw63FviB0ZW50byBsZWthxZl6w61za2FsIGpha8O9a29saSBuZXpieXRuw70gc291aGxhcwoKc3bDqWhvIHpkIHJhdm90bmlja8OpaG8gemHFmcOtemVuw60uCgpQYWdlMTNlZjEzCgo=d42e64f5e83fc8892ae7f298a6d17d29baf2b9e9dca5b5cbfdf945d4f5ccd5d5[A] S20250062500 Smlouva o grantu na vzdělávání.txt2026-06-17T12:47:15+02:00169063c241b950259efee88bd142cf3dec0bac7c12d30b7fda499d892502bb3ba