3570804538014733https://smlouvy.gov.cz/smlouva/380147332026-05-19T09:41:28+02:00jwaeuenKrajská nemocnice Liberec, a.s.27283933Husova 1430/34, 46001 Liberec, CZBRAINOMIX EUROPE LIMITED6830491 CASTLEWOOD AVENUE, RATHMINES DUBLIN 6Kupní smlouva na SW pro záchyt CMP2026-05-07S2026/00301/0048750077u/QnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRDAyLCBYMzYxIElyZWxhbmQKCiAKClNPRlRXQVJFIEFTIFNFUlZJQ0UgQUdSRUVNRU5UIG5vLiBDWlNPR09TLVpSCgpTTUxPVVZBIE8gUE9TS1lUTlVUw40gU09GVFdBUkUgSkFLTyBTTFXFvUJZIMWZLi4gQ1pTT0dPUy1aUgoKIAoKQ29udHJhY3RpbmcgcGEgcnRpZXMKCkJSQUlOT01JWCBFVVJPUEUgTElNSVRFRAoKUmVnaXN0ZXJlZCBvZmZpY2U6IFN1aXRlIDEwMzgwLCAyNi8yNyB1cHBlciBQZW1icm9rZSBTdHJlZXQsCkR1YmxpbiAyIEQwMiwgWDM2MXxyZXxhbmQKCklEIG51bWJlcjogNjgzMDQ5LCBUYXggSUQ6IHxFMzczNzMxMkpICgpSZXByZXNlbnRlZCBieToKCihoZXJlaW5hZnRlciByZWZlcnJlZCB0byBhc3RoZSAiQnJhaW5vbWl4IiBvciAiUHJvdmlkZXIiKQoKYW5kCgpLcmFqc2vDoSBuZW1vY25pY2UgTGliZXJlYywgYS5zLgpSZWdpc3RlcmVkIG9mZmljZTogSHVzb3ZhIDE0MzAvMzQsIDQ2MCAwMSBMaWJlcmVjIHzigJQgU3RhcsOpIE3Em3N0bywKQ3plY2ggUmVwdWJsaWMKSUQgbnVtYmVyOiAyNzI4MzkzMwpUYXggSUQ6IEMyMjcyODM5MzMKUmVwcmVzZW50ZWQgYnk6ICwKdmljZXJjaGFpcm1hbiBvZiB0aGUKYm9hcmQKCkNvbXBhbnkgcmVnaXN0ZXJlZCBpbiB0aGUgQ29tbWVyY2lhbCBSZWdpc3RlciBtYWludGFpbmVkIGJ5IHRoZQpSZWdpb25hbCBDb3VydGluIMOac3TDrSBuYWQgTGFiZW0sIFNlY3Rpb24gQiwgSW5zZXJ0IDE2NTEKCihoZXJlaW5hZnRlciByZWZlcnJlZCB0byBhc3RoZSAidGhlIEhvc3BpdGFsIiBvciAiQ2xpZW50IikKCmVudGVyIGludG8gdGhpcyBhZ3JlZW1lbnQgYXMgb2YgdGhlIGRhdGUgb2Z0aGUgbGFzdCBzaWduYXR1cmUgYmVsb3cgLAppbiBsaW5lIHdpdGggcHJvdmlzaW9uIG9mQXJ0LiAxNzQ2IHNlYy4gMSBhbmQgQXJ0LiAyMzU4IG9mIEN6ZWNoIEFjdApOby4gODkvMjAxMiBDb2xsLiwgQ2l2aWwgQ29kZSwgYXMgYW1lbmRlZCAoaGVyZWluYWZ0ZXIgcmVmZXJyZWQgdG8gYXMKdGhlICJDaXZpbCBjb2RlIikKClNtbHV2bsOtIHN0cmEgbnkKCkJSQUlOT01JWCBFVVJPUEUgTElNSVRFRAoKc2Ugc8OtZGxlbTogU3VpdGUgMTAzODAsIDI2LzI3IFVwcGVyIFBlbWJyb2tlIFN0cmVldCwgRHVibGluIDIgRDAyLApYMzYxIElyc2tvCgpJxIxPOiA2ODMwNDksIERJxIw6IHxFMzczNzMxMkpICgp6YXN0b3UgcGUgbsOhOiB2w71rb25uw70gxZllZGl0ZWwKCihkw6FsZSBqZW4gIkJyYWlub21peCIgbmVibyDigJ5Qb3NreXRvdmF0ZXwiKQoKS3JhanNrw6EgbmVtb2NuaWNlIExpYmVyZWMsIGEucy4KClNlIHPDrWRsZW06IEh1c292YSAxNDMwLzM0LCA0NjAgMDEgTGliZXJlYyB8IOKAlCBTdGFyw6kgTcSbc3RvLArEjGVza8OhcmVwdWJsaWthCgpJxIxPOiAyNzI4MzkzMwoKREnEjDogQ1oyNzI4MzkzMwoKemFzdG91cGVuw6E6ICwgXyBfIF8KbSDDrXN0b3DFmWVkc2VkYSBwxZllZHN0YXZlbnN0dmEKCnNwb2xlxI1ub3N0IHphcHNhbsOhIHYgb2JjaG9kbsOtbSByZWpzdMWZw61rdSB2ZWRlbsOpbSBLcmFqc2vDvW0gc291ZGVtIHYKw5pzdMOtIG5hZCBMYWJlbSwgb2Rkw61sIEIsIHZsb8W+a2EgMTY1MQoKKGTDoWxlIGplbiAiTmVtb2NuaWNlIiBuZWJvIOKAnk9iamVkbmF0ZWwiKQp1emF2w61yYWrDrSBkbmUgdHV0byBzbWxvdXZ1IGtlIGRuaSBwb3NsZWRuw61obyBwb2RwaXN1IG7DrcW+ZSB2IHNvdWxhZHUgcwoKdXN0LiAmIDE3NDYgb2RzdC4gMSBhIDUgMjM1OCDEjWVza8OpaG8gesOha29uYSDEjS4gODkvMjAxMiBTYi4sIG9ixI1hbnNrw70KesOha29uw61rLCB2ZSB6bsSbbsOtIHBvemTEm2rFocOtY2ggcMWZZWRwaXPFryAoZMOhbGUgamVuIOKAnk9ixI1hbnNrw70gesOha29uw61rIikKCiAKCjEuIFNjb3BlCgoxLiBSb3pzYWgKCiAKCjEuMS4gVGhpcyBBZ3JlZW1lbnQgZ292ZXJucyB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZm9yIHRoZQpwcm92aXNpb24gb2Z0aGUgQWNjZXNzIHRvIHRoZSBTZXJ2aWNlIGFuZCB0aGUgc3VwcGx5IGFuZCB1c2UKb2Z0aGUgU2VydmljZXMsIGNvbXByaXNpbmcgdGhlIFNwZWNpZmljYXRpb24gb2Z0aGUgQWNjZXNzIHRvCnRoZSBTZXJ2aWNlYW5kIHRoZSBTZXJ2aWNlcyBhcyBpdHMgQXBwZW5kaXggMS4gRGF0YQpQcm9jZXNzaW5nIFRlcm1zIGFzIGl0cyBBcHBlbmRpeCAyIGFuZCB0aGUgU2VydmljZSBMZXZlbApBZ3JlZW1lbnQgYXMgaXRzIEFwcGVuZGl4IDMgQWdyZWVtZW50IChhcyBkZWZsbmVkIGluCmNsYXVzZSAyIGJlbG93KSwgYXMgd2VsbCBhcyBUZWNobmljYWwgU3BlY2lmaWNhdGlvbiBvZiB0aGUKQnJhaW5vbWl4IDM2MCBhcyBpdHMgQXBwZW5kaXggNCwgdG8gdGhlIGV4Y2x1c2lvbiBvZiBhbnkKdGVybXMgdGhhdCB0aGUgSG9zcGl0YWwgb3IgQnJhaW5vbWl4IHNlZWtzIHRvIGltcG9zZSBvcgppbmNvcnBvcmF0ZSBpbiB0aGUgQWdyZWVtZW50LCBvciB0aGF0IGFyZSBpbXBsaWVkIGJ5IHRyYWRlLApjdXN0b20sIHByYWN0aWNlLCBjb3Vyc2Ugb2ZkZWFsaW5nIG9yIGluIGFueSBvdGhlciB3YXkuCgoxLjEgVGF0byBTbWxvdXcgdXByYXZ1amUgcG9kbcOtbmt5IFDFmcOtc3R1cHUga2UgU2x1xb5ixJsgYSBkw6FsZQpwb3NreXRudXTDrSBhIHXFvml0w60gU2x1xb5lYi4gU291xI3DoXN0w60gc21sb3V2eSBqc291IHTDqcW+IFNwZWNpZmlrYWNlClDFmcOtc3R1cHUga2UgU2x1xb5ixJsgYSBTbHXFvmViIHV2ZWRlbsOpIHZwxZnDrWxvemUgxI0uIDEsIFBvZG3DrW5reQp6cHJhY292w6Fuw60gb3NvYm7DrWNoIMO6ZGFqxa8gdXZlZGVuw6kgdnDFmcOtbG96ZSDEjS4gMiwgRG9ob2RhIDAKw7pyb3Zuw60gc2x1xb5lYiB1dmVkZW7DoSB2IHDFmcOtbG96ZSDEjS4gMyAoamFrIGpzb3UgdHl0byBkZWZpbm92YW7DqSB2CsSNbC4gMiBuw63FvmUpIFRlY2huaWNrw70gcG9waXMgxZkgZW7DrSBCcmFpbm9taXggMzYwIGpha28gcMWZw61sb2hhIMSNLiA0LgpOYSBTbWxvdXZ1IHNlIG5ldnp0YWh1amwgamFrw6lrb2xpIGRhbMWhw60gb2JjaG9kbsOtIHBvZG3DrW5reQpOZW1vY25pY2UgbmVibyBCcmFpbm9taXgsIG9iY2hvZG7DrSB6dnlrbG9zdGksIHByYXhlIHphdmVkZW7DoQptZXppIHN0cmFuYW1pIG5lYm8gamFrw6lrb2xpIGRhbMWhw60gcG9kbcOtbmt5LgoKICAgCgogCgoxLjIuIFRoZSBBZ3JlZW1lbnQgc3VwZXJzZWRlcyBhbGwgZWFybGllciBhZ3JlZW1lbnRzLAphcnJhbmdlbWVudHMgYW5kIHVuZGVyc3RhbmRpbmdzIGJldHdlZW4gdGhlIHBhcnRpZXMgaW4KcmVzcGVjdCBvZiBpdHMgc3ViamVjdCBtYXR0ZXIuIHx0IGNvbnN0aXR1dGVzIHRoZSBjb21wbGV0ZQphZ3JlZW1lbnQgYmV0d2VlbiB0aGUgcGFydGllcyByZWxhdGluZyB0byB0aGF0IHN1YmplY3QKbWF0dGVyLiBObyBtb2RpZmljYXRpb24gb3J2YXJpYXRpb24gb2Z0aGVBZ3JlZW1lbnQgd2lsbCBiZQplZmZlY3RpdmUgdW5sZXNzIGl0IGlzIGFkb3B0ZWQgdGhyb3VnaCBhIHdyaXR0ZW4gYW1lbmRtZW50CnRvIHRoaXMgQWdyZWVtZW50LCBudW1iZXJlZCBhbmQgZXhlY3V0ZWQgYnkgYm90aCBwYXJ0aWVzLgpUaGlzIHByb3Zpc2lvbiBjb25jZXJuaW5nIGFtZW5kbWVudHMgdG8gdGhlIEFncmVlbWVudAptYXkgaXRzZWxmIGJlIGFsdGVyZWQgb25seSBpbiB3cml0aW5nLCBhbmQgbm90IG9yYWxseSBvciBieQpjb25kdWN0CgoxLjIgU21sb3V2YSBuYWhyYXp1amUgdsWhZWNobnkgcMWZZWRjaG96w60gZG9ob2R5IMSNaSB1amVkbsOhbsOtIG1lemkKc3RyYW5hbWkgdmUgdsSbY2kgcMWZZWRtxJt0dSBTbWxvdXZ5IGEgdHZvxZnDrSDDunBsbm91IGRvaG9kdSBtZXppCnN0cmFuYW1pIG9obGVkbsSbIHDFmWVkbcSbdHUgU21sb3V2eS4gw5pwcmF2eSBhIHptxJtueSBTbWxvdXZ5CmJ1ZG91IMO6xI1pbm7DqSwgcG91emUgcG9rdWQgYnVkb3UgdcSNaW7Em255IGZvcm1vdSBww61zZW1uw71jaApkb2RhdGvFryBrdMOpdG8gU21sb3V2xJssIHZ6ZXN0dXBuxJsgxI3DrXNsb3ZhbsO9Y2ggYSBwb2RlcHNhbsO9Y2gKb2LEm21hIHN0cmFuYW1pLiBUb3RvIHVqZWRuw6Fuw60gb2hsZWRuxJsgem3Em24gU21sb3V2eSBsemUgbcSbbml0CnRha3TDqcW+IHBvdXplIHDDrXNlbW7Emywgbmlrb2xpdiDDunN0bsSbIMSNaSBrb25rbHVkZW50bsSbLgoKIAoKIAoKMS4zLiBUaGUgUGFydGllcyBleHByZXNzbHkgYWNrbm93bGVkZ2UgYW5kIGFncmVlIHRoYXQgdGhlCnByaW1hcnkgcHVycG9zZSBhbmQgc3ViamVjdCBtYXR0ZXIgb2YgdGhpcyBBZ3JlZW1lbnQgaXMgdGhlCnByb3Zpc2lvbiBvZiBzZXJ2aWNlcyBjb25zaXN0aW5nIGluIHRoZSBwcm9jZXNzaW5nIGFuZApldmFsdWF0aW9uIG9mIGNsaW5pY2FsIGRhdGEuIEFueSBhY2Nlc3MgdG8gc29mdHdhcmUgdG9vbHMgaXMKc29sZWx5IGFuY2lsbGFyeSwgdGVjaG5pY2FsIGFuZCBuZWNlc3NhcnkgZm9yIHRoZSBwcm92aXNpb24gb2YKc3VjaCBzZXJ2aWNlcwoKIAoKMS4zIFNtbHV2bsOtIHN0cmFueSB2w71zbG92bsSbIHV6bsOhdmFqw60gYSBzb3VobGFzw60gcyB0w61tLCDFvmUgcHJpbcOhcm7DrW0Kw7rEjWVsZW0gYSBwxZllZG3Em3RlbSB0w6l0byBTbWxvdXZ5IGplIHBvc2t5dG92w6Fuw60gc2x1xb5lYgpzcG/EjcOtdmFqw61jw61jaCB2ZSB6cHJhY292w6Fuw60gYSB2eWhvZG5vY292w6Fuw60ga2xpbmlja8O9Y2ggw7pkYWrFry4KSmFrw71rb2xpIHDFmcOtc3R1cCBrIHNvZnR3YXJvdsO9bSBuw6FzdHJvasWvbSBqZSBwb3V6ZSBkb3BsxYhrb3bDvSwKdGVjaG5pY2vDvSBhIG5lemJ5dG7DvSBwcm8gcG9za3l0b3bDoW7DrXTEm2NodG8gc2x1xb5lYi4KCiAKCiAKCkJyYWlub21peCBFdXJvcGUgTGltaXRlZApTdWl0ZSAxMDM4MAoKMjYvMjcgVXBwZXIgUGVtYnJva2UgU3RyZWV0CkR1YmxpbiAyIERPWiwgWDM2MSBJcmVsYW5kCgogCgogCgpEZWZpbmljZQoKIAoKSW4gdGhlIEFncmVlbWVudCB0aGUgZm9sbG93aW5nIGV4cHJlc3Npb25zIGhhdmUgdGhlCm1lYW5pbmdzIHNldCBvcHBvc2l0ZToKCk7DrcW+ZSB1dmVkZW7DqSB2w71yYXp5IG1hasOtIHZlIFNtbG91dsSbIHbDvXpuYW0sIGt0ZXLDvSBqZSBkZWZpbm92w6FuCnZ0b210byDEjWzDoW5rdToKCiAKCnRoZSBBY3RpdmF0aW9uIERhdGUgbWVhbnMgdGhlIGRhdGUgb24gd2hpY2ggQnJhaW5vbWl4CnByb3ZpZGVzIHRoZSBBY2Nlc3MgdG8gU2VydmljZSBiYXNlZCBvbiB0aGUgc2lnbmluZyBvZiB0aGUKYWNjZXB0YW5jZSBmb3JtOwoKRGF0dW0gYWt0aXZhY2UgamUgZGF0dW0sIGsgbsSbbXXFviBCcmFpbm9taXggcG9za3l0bmUgUMWZw61zdHVwIGtlCnNsdcW+YsSbIG5hIHrDoWtsYWTEmyBwb2RwaXN1IGFrY2VwdGHEjW7DrWhvIHByb3Rva29sdTsKCiAKCkJyYWlub21peCBVSyBtZWFucyBCcmFpbm9taXggTGltaXRlZCwgYSBjb21wYW55CnJlZ2lzdGVyZWQgaW4gRW5nbGFuZCB1bmRlciBudW1iZXIgMDc0MjY0MDYgd2hvc2UKcmVnaXN0ZXJlZCBvZmZpY2UgaXMgYXQgbHN0IEZsb29yLCBTZWFjb3VydCBUb3dlciwgV2VzdCBXYXksCk94Zm9yZCwgT1haIDAxMSwgVUssIHdoaWNoIGlzIGEgU3VicHJvY2Vzc29yIGZvciB0aGUKcGVyZm9ybWFjZSBvZiB0aGlzIEFncmVlbWVudDsKCkJyYWlub21peCBVSyBqZSBCcmFpbm9taXggTGltaXRlZCwgc3BvbGXEjW5vc3QgemFwc2Fuw6EgdiBBbmdsaWkKcG9kIMSNw61zbGVtIDA3NDI2NDA2LCBzZSBzw61kbGVtIG5hIGFkcmVzZSBsc3QgRmxvb3IsIFNlYWNvdXJ0ClRvd2VyLCBXZXN0IFdheSwgT3hmb3JkLCBPWFogMDExLCBVSywgU3BvamVuw6kga3LDoWxvdnN0dsOtLCBrdGVyw6kKamUgRMOtbMSNw61tIHpwcmFjb3ZhdGVsZW0gcHJvIHBsbsSbbsOtdMOpdG8gU21sb3V2eTsKCiAKCnRoZSBjaGFyZ2VzIG1lYW5zIHRoZSBjaGFyZ2VzIGZvciB0aGUgU2VydmljZSBhbmQgdGhlClNlcnZpY2VzIGFuZCBhbnkgZXhwZW5zZXMgcGF5YWJsZSBieXRoZSBIb3NwaXRhbCwgYXMgc2V0IG91dAppbiBBcHBlbmRpeCAxOwoKT2RtxJtuYSBqZSBvZG3Em25hIHphIFNsdcW+YnUgYSBTbHXFvmJ5IGEgamFrw6lrb2xpIHbDvWRhJ2UsIGt0ZXLDqSBtw6EKTmVtb2NuaWNlIHVocmFkaXQgZGxlIHTDqXRvIFNtbG91dnksIGEgdG8gdmUgdsO9xaFpIHV2ZWRlbsOpCnYgcMWZw61sb3plIMSNLiAxIHTDqXRvIFNtbG91dnk7CgogCgpDbGluaWNhbCBQYXRpZW50IENhcmUgbWVhbnMgY3xpbmljYXwgdXNlIGZvciBkaWFnbm9zaW5nLAp0cmVhdGluZyBvciBtYW5hZ2luZyB0aGUgaGVhfHRoIG9mIGFuIGluZGl2aWR1YWwsIGJ1dCBleGNsdWRlcwphbnkgdXNlIGZvciByZXNlYXJjaCBleGNlcHQgd2hlcmUgQnJhaW5vbWl4IGhhcyBnaXZlbiBpdHMKd3JpdHRlbiBjb25zZW50IHRvIHRoZSB1c2Ugb2YgU29mdHdhcmUgYW5kIHRoZSBTZXJ2aWNlIGZvcgp0aGF0IHJlc2VhcmNoOwoKIAoKS0kgaWNrw6EgcMOpxI1lIG8gcGFjaWVudHkgamUga2xpbmlja8OpIHZ5dcW+aXTDrSBrIGRpYWdub3N0aWNlLCBsw6nEjWLEmwpuZWJvIHDDqcSNaSBvIHpkcmF2w60gZnl6aWNrw6kgb3NvYnksIGF2xaFhayBzIHZ5bG91xI1lbsOtbSB2w716a3VtbsOpaG8KdcW+aXTDrSwgbGVkYcW+ZSBzcG9sZcSNbm9zdCBCcmFpbm9taXggZGFsYSBww61zZW1uw70gc291aGxhcyBrIHXFvml0w60KU29mdHdhcnUgYSBTbHXFvmJ5IHBybyBrb25rcsOpdG7DrXbDvXprdW1uw70gcHJvamVrdDsKCiAKCiAKCnRoZSBBZ3JlZW1lbnQgbWVhbnMgdGhpcyBhZ3JlZW1lbnQgYmV0d2VlbiBCcmFpbm9taXgKRXVyb3BlIExpbWl0ZWQsIGEgY29tcGFueSByZWdpc3RlcmVkIGluIHRoZSBSZXB1YmxpYyBvZgpJcmVsYW5kIHVuZGVyIG51bWJlciA2ODMwNDkgd2hvc2UgcmVnaXN0ZXJlZCBvZmZpY2UgaXMgYXQKU3VpdGUgMTAzODAsIDI2LzI3IHVwcGVyIFBlbWJyb2tlIFN0cmVldCwgRHVibGluIDIgRDAyLApYMzYxIElyZWxhbmQgKEJyYWlub21peCBvciBQcm92aWRlcikgYW5kIHRoZSBIb3NwaXRhbGZvcnRoZQpwcm92aXNpb24gb2YgdGhlIEFjY2VzcyB0byBTZXJ2aWNlIGFuZCB0aGUgc3VwcGx5IG9mIHRoZQpTZXJ2aWNlcywgQ29tcHJpc2luZyB0aGUgU3BlY2lmaWNhdGlvbiBvZiB0aGUgQWNjZXNzIHRvClNlcnZpY2UgYW5kIHRoZSBTZXJ2aWNlcyBpbiBBcHBlbmRpeCAxLCB0aGUgRGF0YSBQcm9jZXNzaW5nClRlcm1zIGluIEFwcGVuZGl4IDIgYW5kIHRoZSBTZXJ2aWNlIExldmVsIEFncmVlbWVudCBpbgpBcHBlbmRpeCAzLCBhbmQgUmVtb3RlIEFjY2VzcyBjb25kaXRpb25zIGluIEFwcGVuZGl4IDQKZWFjaCBhcyBhbWVuZGVkIGZyb20gdGltZSB0byB0aW1lIGluIGFjY29yZGFuY2Ugd2l0aApjbGF1c2UgMS4yIGFib3ZlOwoKU21sb3V2YSBqZSB0YXRvIHNtbG91dmEgbWV6aSBCcmFpbm9taXggRXVyb3BlIExpbWl0ZWQsCnNwb2xlxI1ub3N0IHphcHNhbsOhIHYgSXJza8OpIHJlcHVibGljZSBwb2QgxI3DrXNsZW0gNjgzMDQ5LCBzZSBzw61kbGVtCm5hIGFkcmVzZSBTdWl0ZSAxMDM4MCwgMjYvMjcgVXBwZXIgUGVtYnJva2UgU3RyZWV0LCBEdWJsaW4gMgpEMDIsIFgzNjEgSXJza28gKGTDoWxlIGplbiDigJ5CcmFpbm9taXgiIG5lYm8g4oCeUG9za3l0b3ZhdGV8IikgYQpOZW1vY25pY8OtIG8gcG9za3l0bnV0w60gUMWZw61zdHVwdSBrZSBTbHXFvmLEmyBhIGRvZMOhdmvDoWNoIFNsdcW+ZWIsCmplasOtxb4gc291xI1hc3TDrWpzb3UgU3BlY2lmaWthY2UgUMWZw61zdHVwdSBrZSBTbHXFvmLEmyBhIFNsdcW+ZWIgdiBwxZnDrWxvemUKxI0uIDEsIGTDoWxlIHTDqcW+IFBvZG3DrW5reSB6cHJhY292w6Fuw60gb3NvYm7DrWNoIMO6ZGFqxa8gdiBwxZnDrWxvemUgxI0uIDIsCkRvaG9kYSBvIMO6cm92bmkgc2x1xb5lYiB2cMWZw61sb3plIMSNLiAzIGEgw7pwcmF2YSBwb2Rtw61uZWsKVnpkw6FsZW7DqWhvIHDFmcOtc3R1cHUgamFrbyBwxZnDrWxvaGEgxI0uIDQsIHbFoWUgdmUgem7Em27DrSBwxZnDrXBhZG7DvWNoCnBvemTEm2rFocOtY2ggw7pwcmF2IHDFmWlqYXTDvWNoIHYgc291bGFkdSBzIHVzdGFub3ZlbsOtbSDEjWwuIDEuMiB0w6l0bwpTbWxvdXZ5OwoKIAoKQ29uZmlkZW50aWFsIEluZm9ybWF0aW9uIG1lYW5zIGluZm9ybWF0aW9uIG9yIGRhdGEgb2YgYQpjb25maWRlbnRpYWwgbmF0dXJlLCBpbmNsdWRpbmcgKHdpdGhvdXQgbGltaXRhdGlvbikgYW55IGFuZCBhbGwKaW5mb3JtYXRpb24gd2hpY2ggcmV8YXRlcyB0byBhbnkgb2YgdGhlIGZvbGxvd2luZzogYSBwYXJ0eSdzCnBhdGllbnRzLCBjdXN0b21lcnMsIHN1cHBsaWVycywgdGVjaG5vbG9neSwgYWN0aXZpdGllcwoocmVnYXJkbGVzcyBvZiB0aGUgZm9ybSBpbiB3aGljaCB0aGF0IGluZm9ybWF0aW9uIG9yIGRhdGEgaXMKc3RvcmVkIG9yIGNvbW11bmljYXRlZCkuIEJyYWlub21peCdzIENvbmZpZGVudGlhbApJbmZvcm1hdGlvbiBpbmNsdWRlcyAod2l0aG91dCB8aW1pdGF0aW9uKTogYW55IGFuZCBhbGwKaW5mb3JtYXRpb24gcmVsYXRpbmcgdG8gYW55IG9mIHRoZSBmb2xsb3dpbmc6IHRoZSBTb2Z0d2FyZSBhbmQKdGhlIFNlcnZpY2UuIFRoZSBIb3NwaXRhbCdzIENvbmZpZGVudGlhbCBJbmZvcm1hdGlvbiBpbmNsdWRlcwood2l0aG91dCBsaW1pdGF0aW9uKSB0aGUgSG9zcGl0YWwgRGF0YSBhbmQgdGhlIEhvc3BpdGFsClJlc3VsdHM7CgpExa92xJtybmUnIGluZm9ybWFjZSBqc291IGluZm9ybWFjZSBuZWJvIMO6ZGFqZSBkxa92xJtybsOpIHBvdmFoeSwKemVqbcOpbmEgdsWhZWNobnkgaW5mb3JtYWNlIHTDvWthasOtY8OtIHNlIHBhY2llbnTFrywgesOha2F6bsOta8WvLApkb2RhdmF0ZWzFrywgdGVjaG5vbG9naWUgbmVibyDEjWlubm9zdGkgbsSba3RlcsOpIHNtbHV2bsOtIHN0cmFueQooYmV6IG9obGVkdSBuYSBmb3JtdSwgdiBuIHNvdSBkb3R5xI1uw6kgaW5mb3JtYWNlIG5lYm8gw7pkYWplCnVsb8W+ZW55IG5lYm8gc2TEm2xvdmFueSkuIETFr3bEm3Juw71taSBpbmZvcm1hY2VtaSBCcmFpbm9taXgganNvdQp6ZWptw6luYSB2ZcWha2Vyw6kgaW5mb3JtYWNlIHTDvWthasOtY8OtIHNlIFNvZnR3YXJ1IGFuZWJvIFNsdcW+YnkuCkTFr3bEm3Juw71taSBpbmZvcm1hY2VtaSBOZW1vY25pY2UganNvdSB6ZWptw6luYSDDmmRhamUKTmVtb2NuaWNlIGEgVsO9c2xlZGt5IE5lbW9jbmljZTsKCiAKCiAKCnRoZSBEYXRhIFByb2Nlc3NpbmcgVGVybXMgbWVhbnMgQnJhaW5vbWl4J3MgRGF0YQoKUHJvY2Vzc2luZyBUZXJtcyBpbiBBcHBlbmRpeCAyOwoKUG9kbcOtbmt5IHpwcmFjb3bDoW7DrSBvc29ibsOtY2ggw7pkYWrFryBqc291IFBvZG3DrW5reSB6cHJhY292w6Fuw60Kb3NvYm7DrWNoIMO6ZGFqxa8gdiBwxZnDrWxvemUgxI0uIDIgdMOpdG8gU21sb3V2eTsKCiAKCiAKCnRoZSBIb3NwaXRhbCBtZWFucyB0aGUgcGEgcnR5IHRvIHRoaXMgQWdyZWVtZW50OwoKIAoKTmVtb2NuaWNlIGplIHNtbHV2bsOtIHN0cmFuYSB0w6l0byBTbWxvdXZ5OwoKIAoKIAoKQnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRDAyLCBYMzYxIElyZWxhbmQKCiAKCnRoZSBIb3NwaXRhbCBEYXRhIG1lYW5zIENUIGFuZCBNUiBzY2FubmVyIGRhdGEgYW5kIGFueQpvdGhlciBkYXRhIHdoaWNoIHRoZSBIb3NwaXRhbCBvciBhbnkgVXNlciBpbnB1dHMgaW50byB0aGUKU29mdHdhcmUgb3IgdGhlIFNlcnZpY2UgZm9yIHRoZSBwdXJwb3NlIG9mIHVzaW5nIHRoZSBTb2Z0d2FyZQpvcnRoZSBTZXJ2aWNlOwoKw5pkYWplIE5lbW9jbmljZSBqc291IGRhdGEgemUgc2tlbmVydSBDVCBhIE1SIGEgdsWhZWNobmEgb3N0YXRuw60KZGF0YSwga3RlcsOhIE5lbW9jbmljZSBuZWJvIFXFvml2YXRlbCB2bG/FvsOtIGRvIFNvZnR3YXJ1IG5lYm8KClNsdcW+YnkgemEgw7rEjWVsZW0gcG91emwKCiAgIAoKJ27DrSBTb2Z0d2FydSBuZWJvIFNsdcW+Ynk7CgogCgp0aGUgSG9zcGl0YWwgUmVzdWx0cyBtZWFucyBhbGwgZGF0YSwgaW5mb3JtYXRpb24gYW5kIHJlc3VsdHMKZ2VuZXJhdGVkIGJ5IHRoZSBIb3NwaXRhbCBpbiB0aGUgY291cnNlIG9mIHVzaW5nIHRoZSBTb2Z0d2FyZQphbmQgdGhlIFNlcnZpY2U7CgpWw71zbGVka3kgTmVtb2NuaWNlIGpzb3UgdsWhZWNobmEgZGF0YSwgaW5mb3JtYWNlIGEgdsO9c2xlZGt5LCBqZcW+Ck5lbW9jbmljZSB2eXR2b8WZw60gcMWZaSBwb3XFvsOtdsOhbsOtIFNvZnR3YXJ1IDMgU2x1xb5ieTsKCiAKCkludGVsbGVjdHVhbCBQcm9wZXJ0eSBSaWdodHMgbWVhbnMgYW55IHBhdGVudCwgY29weXJpZ2h0LAp0cmFkZW1hcmssIHRyYWRlIG5hbWUsIHNlcnZpY2UgbWFyaywgcmVnaXN0ZXJlZCBkZXNpZ24sCmRlc2lnbiByaWdodCAocmVnaXN0ZXJlZCBhbmQgdW5yZWdpc3RlcmVkKSwga25vd2lob3csIHJpZ2h0Cm9mIGNvbmZpZGVuY2UsIHRyYWRlIHNlY3JldCwgcmlnaHQgdG8gZXh0cmFjdCBhbmQgZXhwbG9pdCBkYXRhLApkYXRhYmFzZSByaWdodCwgYW55IHNpbWlsYXIgcmlnaHRzIHByb3RlY3RlZCBpbiBhbnkKanVyaXNkaWN0aW9uLCB3aGV0aGVyIG5vdyBleGlzdGluZyBvciBjb21pbmcgaW50byBleGlzdGVuY2UKYXQgc29tZSBmdXR1cmUgZGF0ZSwgYW55IGFwcGxpY2F0aW9uIGZvciBhbnkgb2YgdGhlIGFib3ZlLAphbmQgYW55IGFjY3J1ZWQgcmlnaHRzIG9mIGFjdGlvbiBpbiByZXNwZWN0IG9mIGFueSBvZiB0aGUKYWJvdmU7CgpQcsOhdmEgZHXFoWV2bsOtaG8gdmxhc3RuaWN0dsOtIGplIGthxb5kw70gcGF0ZW50LCBhdXRvcnNrw6kgcHLDoXZvLApvY2hyYW5uw6Egem7DoW1rYSwgb2JjaG9kbsOtIG7DoXpldiwgem5hxI1rYSBzbHXFvmJ5LCB6YXBzYW7DvQoocHLFr215c2xvdsO9KSB2em9yLCBwcsOhdm8gayhwcsWvbXlzfG92w6ltdSkgdnpvcnUgKHphcHNhbsOpIF0KbmV6YXBzYW7DqSksIGtub3dpaG93LCBwcsOhdm8gbmEgemFjaG92w6Fuw60gbWzEjWVubGl2b3N0aSwKb2JjaG9kbsOtIHRhamVtc3R2w60sIHByw6F2byBleHRyYWhvdmF0IGEgdnl1xb7DrXZhdCBkYXRhLCBwcsOhdm8Ka2RhdGFiw6F6aSwgcG9kb2Juw6EgcHLDoXZhIGNocsOhbsSbbsOhIHYgbsSba3RlcsOpIGp1cmlzZGlrY2ksIGHFpSBqacW+CmV4aXN0dWrDrSBueW7DrSBuZWJvIHZ6bmlrbm91IHYgYnVkb3Vjbm9zdGksIGTDoWxlIGthxb5kw6kgdXBsYXRuxJtuw60KbsSba3RlcsOpaG8geiB2w73FoWUgdXZlZGVuw71jaCBwcsOhdiBuZWJvIHVwbGF0bsSbbsOtIG7DoXJva8WvCnBseW5vdWPDrWNoIHogdsO9xaFlIHV2ZWRlbsO9Y2ggcHLDoXY7CgogCgpNYWx3YXJlIG1lYW5zIGFueSB2aXJ1cywgd29ybSwgdGltZSBib21iIG9yIHRpbWUgbG9jayBvcgphbnl0aGluZyBlbHNlIHRoYXQgbWlnaHQgZGlzcnVwdCwgZGlzYWJsZSwgaGFybSBvciBpbXBlZGUKdGhlIG9wZXJhdGlvbiBvZiBhbnkgaW5mb3JtYXRpb24gc3lzdGVtLCBvciB0aGF0IG1pZ2h0CmNvbnVwdCwgZGFtYWdlLCBkZXN0cm95IG9yIHJlbmRlciBpbmFjY2Vzc2libGUgYW55CnNvZnR3YXJlLCBkYXRhIG9yIGZpbGUgb24sIG9yIHRoYXQgbWF5IGFsbG93IGFueQp1bmF1dGhvcmlzZWQgcGVyc29uIHRvIGdhaW4gYWNjZXNzIHRvLCBhbnkgaW5mb3JtYXRpb24Kc3lzdGVtIG9yIGFueSBzb2Z0d2FyZSwgZGF0YSBvciBmJ2xsZSBvbiBpdDsKCsWga29kbGl2w70gc29mdHdhcmUgamUgcG/EjcOtdGHEjW92w70gdmlydXMsIMSNZXJ2LCDEjWFzb3ZhbsOhIGJvbWJhCm5lYm8gxI1hc292w70gesOhbWVrIG5lYm8gY29rb2xpIGppbsOpaG8sIGNvIG3Fr8W+ZSBwxZllcnXFoWl0LAp6bmVtb8W+bml0LCBwb8Wha29kaXQgbmVibyBibG9rb3ZhdCBwcm92b3ogaW5mb3JtYcSNbsOtaG8Kc3lzdMOpbXUgbmVibyBjbyBtxa/FvmUgbmFydcWhaXQsIHBvxaFrb2RpdCwgem5pxI1pdCBuZWJvCnpuZXDFmcOtc3R1cG4ncnQgc29mdHdhcmUsIGRhdGEgbmVibyBzb3Vib3IgdmluZm9ybWHEjW7DrW0Kc3lzdMOpbXUgbmVibyBtxa/FvmUgbmVvcHLDoXZuxJtuw6kgb3NvYsSbIHVtb8W+bml0IHDFmcOtc3R1cCBrCmluZm9ybWHEjW7DrW11IHN5c3TDqW11LCBzb2Z0d2FydSwgZGF0xa9tIG5lYm8gc291Ym9ydTsKCiAKClBlcnNvbmFsIERhdGEgaGFzIHRoZSBtZWFuaW5nIGdpdmVuIHRvIHRoYXQgZXhwcmVzc2lvbiBpbgp0aGUgRGF0YSBQcm9jZXNzaW5nIFRlcm1zOwoKT3NvYm7DrSDDumRhamUgamUgcG9qZW0gbWFqw61jw612w716bmFtIGRlZmlub3ZhbsO9diBQb2Rtw61ua8OhY2gKenByYWNvdsOhbsOtIG9zb2Juw61jaCDDumRhasWvOwoKIAoKYSBUcmlhbCBtZWFucyBhIHRyaWFsIG9mIHRoZSBTb2Z0d2FyZSBhbmQgdGhlIFNlcnZpY2UgYnkgdGhlCkhvc3BpdGFsIGZvciB0aGUgcGVyaW9kIHNldCBvdXQgaW4gQXBwZW5kaXggMTsKClprdcWhZWJuw60gZsOhemUgamUgemt1xaFlYm7DrSBwcm92b3pvdsOhbsOtIFNvZnR3YXJ1IDMgU2x1xb5ieQpOZW1vY25pY2kgcG8gZG9idSBzdGFub3Zlbm91IHYgcMWZw61sb3plIMSNLiAxIHTDqXRvIFNtbG91dnk7CgogCgp0byBQcm9jZXNzIFBlcnNvbmFsIERhdGEgaGFzIHRoZSBtZWFuaW5nIGdpdmVuIHRvIHRoYXQKZXhwcmVzc2lvbiBpbiB0aGUgRGF0YSBQcm9jZXNzaW5nIFRlcm1zOwoKWnByYWNvdsOhdmF0IG9zb2Juw63DumRhamUgbcOhIHbDvXpuYW0gZGXFiG5vdmFuw70gdiBQb2Rtw61ua8OhY2gKenByYWNvdsOhbsOtIG9zb2Juw61jaCDDumRhasWvOwoKIAoKdGhlIFByb2Zlc3Npb25hbCBTZW1pY2VzIG1lYW5zIHRoZSBpbnN0YWxsYXRpb24sCmNvbmZpZ3VyYXRpb24sIHRyYWluaW5nIGFuZCBhbnkgb3RoZXIgc2VydmljZXMgKGV4Y2VwdCB0aGUKU2VydmljZSBhbmQgdGhlIFN1cHBvcnQgU2VydmljZXMpIHRvIGJlIHByb3ZpZGVkIGJ5CkJyYWlub21peCB0byB0aGUgZXh0ZW50IHNldCBvdXQgaW4gQXBwZW5kaXggMTsKClByb2Zlc2lvbsOhbG7DrXNsdcW+YnkganNvdSBpbnN0YWxhY2UsIGtvbsWIZ3VyYWNlLCB2ecWha29sZW7DrSBhIGRhbMWhw60Kc2x1xb5ieSAoa3JvbcSbIFNsdcW+YnkgYSBTbHXFvmViIHBvZHBteSksIGt0ZXLDqSBtw6EgQnJhaW5vbWl4CnBvc2t5dG5vdXR2IHJvenNhaHUgdXZlZGVuw6ltIHYgcMWZw61sb3plIMSNLiAxIHTDqXRvIFNtbG91dnk7CgogCgp0aGUgUmVsZXZhbnQgUGVyaW9kIG1lYW5zIHRoZSBwZXJpb2Qgb2YgdGhlIEFncmVlbWVudCBzZXQKb3V0aW4gQXBwZW5kaXggMTsKClJvemhvZG7DqSBvYmRvYsOtIGplIG9iZG9iw60gdHJ2w6Fuw60gU21sb3V2eSBzdGFub3ZlbsOpIHYgcMWZw61sb3plCsSNLiAxIHTDqXRvIFNtbG91dnk7CgogCgogCgp0aGUgU2VydmljZSBtZWFucyBCcmFpbm9taXggMzYwIFN0cm9rZSBzZXJ2aWNlIGZvcgpldmFsdWF0aW5nIHN0cm9rZSBkYW1hZ2Ugb24gYnJhaW4gQ1Qgb3IgTVIgc2NhbnMgYXMKc3BlY2lmaWVkIGluIEFwcGVuZGl4IDE7CgpUaGUgaW5kaXZpZHVhbCBtb2R1bGVzIG9mIHRoZSBTZXJ2aWNlIGFyZSByZWdpc3RlcmVkIGFzIDMKU29mdHdhcmUgTWVkaWNhbCBEZXZpY2UgKFNhTUQpIENsYXNzIHx8YiB0aGF0IGlzIGEgZGVjaXNpb24Kc3VwcG9ydCB0b29sLCB0aGF0LCBob3dldmVyLCBkb2VzIG5vdCByZXBsYWNlIGEgcHJvZmVzc2lvbmFsCmp1ZGdlbWVudCBvZiBhIGNsaW5pY2lhbiBpbiBhbnkgd2F5LiBUaGUgU2VydmljZSBpcyB3aXRoIGEKaGlnaCBwcm9iYWJpbGl0eSBjYXBhYmxlIHRvIHByZWRpY3QgaG93IGEgYnJhaW4gbWF5IGFsdGVyCmFmdGVyIGEgc3Ryb2tlLiBBbnkgcHJlZGljdGlvbiBpbiB0aGlzIHJlc3BlY3QsIGhvd2V2ZXIsIG1heQpub3QgYmUgZ3VhcmFudGVlZCBkdWUgdG8gaW5oZXJlbnQgcHJvcGVydGllcyBvZiBhIHNvZnR3YXJlCndvcmtpbmcgd2l0aCBtZXJlIG1lYXN1cmUgb2YgcHJvYmFiaWxpdHksIHdpdGhvdXQgdGhpcwoKIAoKU2x1xb5iYSBqZSBzbHXFvmJhIEJyYWlub21peCAzNjAgU3Ryb2tlLCB1csSNZW7DoSBrdnlob2Rub2NvdsOhbsOtCnBvxaFrb3plbsOtIHpwxa9zb2JlbsOpaG8gY8Opdm7DrSBtb3prb3ZvdSBwxZnDrWhvZG91LCBhIHRvIG5hCnrDoWtsYWTEmyBDVCBuZWJvIE1SIHNrZW7FryBtb3prdSwgcG9kbGUgc3BlY2lmaWthY8OtCnV2ZWRlbsO9Y2ggdiBwxZnDrWxvemUgxI0uIDEgdMOpdG8gU21sb3V2eTsKCkplZG5vdGxpdsOpIG1vZHVseSBTbHXFvmJ5IGpzb3UgcmVnaXN0cm92YW7DqSBqYWtvIHNvZnR3YXJvdsO9CnpkcmF2b3RuaWNrw70gcHJvc3TFmWVkZWsgKFNhTUQpIHTFmcOtZHkgfHxiIGEgamFrbyBuw6FzdHJvaiBuYQpwb2Rwb3J1IHJvemhvZG92w6Fuw60sIGt0ZXLDvSB2xaFhayB2xb7DoWRuw6ltIG9obGVkdSBuZW5haHJhenVqZQpvZGJvcm7DvSDDunN1ZGVrIG9kcG92xJtkbsOpaG8gbMOpa2HFmWUuIFNsdcW+YmEgamUgenDFr3NvYmlsw6EKc3ZlbGtvdSBtw61yb3UgcHJhdmTEm3BvZG9ibm9zdGkgcMWZZWRwb3bEm2TEm3QsIGpha8O9bQp6cMWvc29iZW0gc2UgYnVkZSBtb3playBwbyBwxZlla29uYW7DqSBjw6l2bsOtIG1vemtvdsOpIHDFmcOtaG9kxJsKdnl2w61qZXQuIEpha8Oha29saSBwxZllZHBvdsSbxI8gdnRvbXRvIHNtxJtydSB2xaFhayB6ZSBzdsOpIHBvdmFoeQoKIAoKIAoKQnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRE9aLCBYMzYxIElyZWxhbmQKCiAKCmJlaW5nIGNsYXNzaWZpZWQgYXMgYSBmYXVsdCBvZiB0aGUgU29mdHdhcmUgb3IgdGhlIFNlcnZpY2U7Cgoodnl1xb5pdMOtIHNvZnR3YXJ1LCBrdGVyw70gcHJhY3VqZSB0b3xpa28gcyBtw61yb3UKcHJhdmTEm3BvZG9ibm9zdGkpIG5lbcWvxb5lIGLDvXQgemFydcSNZW5hLCBhbmnFviBieSBzZSB2xaFhawpqZWRuYWxvIG8gZmFrdGlja291IHZhZHUgU29mdHdhcnUgbmVibyBTbHXFvmJ5OwoKIAoKdGhlIFNlcnZpY2UgUHJvdmlkZXIgbWVhbnMgQnJhaW5vbWl4IG9yIGFueSBvZiBpdHMKZGlzdHJpYnV0b3JzIG9yIFN1YnByb2Nlc3NvcnMgKGFzIG1heSBiZSBhcHBsaWNhYmxlKQpwcm92aWRpbmcgYXx8IG9yIHBhcnQgb2YgdGhlIFN1cHBvcnQgU2VydmljZXMuCgpQb3NreXRvdmF0ZWwgU2x1xb5ieSBqZSBzcG9sZcSNbm9zdCBCcmFpbm9taXggbmVibyBqZWrDrQpkaXN0cmlidXRvciBuZWJvIHDFmcOtcGFkbsO9IETDrWzEjcOtIHpwcmFjb3ZhdGVsLCBrdGVyw70gcG9za3l0dWplClNsdcW+YnkgcG9kcG9yeSBuZWJvIGplamljaCDEjcOhc3Q7CgogCgp0aGUgU2VtaWNlIExldmVsIEFncmVlbWVudCBtZWFucyBCcmFpbm9taXgncyBTZXJ2aWNlCkxldmVJQWdyZWVtZW50aW4gQXBwZW5kaXgzOwoKRG9ob2RhIDAgw7pyb3Zuw60gc2x1xb5lYiBqZSB1amVkbsOhbsOtIG8gw7pyb3ZuaSBzbHXFvmViIHNwb2xlxI1ub3N0aQpCcmFpbm9taXggb2JzYcW+ZW7DqSB2IHDFmcOtbG96ZSDEjS4gMyBrdMOpdG8gU21sb3V2xJs7CgogCgp0aGUgU2VydmljZXMgbWVhbnMgdGhlIFNlcnZpY2UsIHRoZSBTdXBwb3J0IFNlcnZpY2VzIGFuZAp0aGUgUHJvZmVzc2lvbmFsIFNlcnZpY2VzIChvciBhbnkgb2YgdGhlbSkgYW5kIGFueSBvdGhlcgpzZXJ2aWNlIHByb3ZpZGVkIGJ5IEJyYWlub21peCB0byB0aGUgSG9zcGl0YWwgYmFzZWQgb24gdGhpcwpBZ3JlZW1lbnQ7CgpTbHXFvmJ5IGpzb3UgU2x1xb5iYSwgU2x1xb5ieSBwb2Rwb3J5IGEgUHJvZmVzaW9uw6FsbsOtIHNsdcW+YnkKKHNwb2xlxI1uxJsgbmVibyBqZWRub3RsaXbEmykgYSB2xaFlY2hueSBvc3RhdG7DrSBzbHXFvmJ5LCBrdGVyw6kKQnJhaW5vbWl4IGJ1ZGUgTmVtb2NuaWNpIG5hIHrDoWtsYWTEmyB0w6l0byBTbWxvdXZ5IHBvc2t5dG92YXQ7CgogCgp0aGUgU2l0ZSBtZWFucyB0aGUgfG9jYXRpb24ocykgb3IgcHJlbWlzZXMgb2YgdGhlIEhvc3BpdGFsCnNwZWNpZmllZCBpbiBBcHBlbmRpeCAxIHRvIHdoaWNoIHRoZSBTZXJ2aWNlIGlzIHByb3ZpZGVkOwoKUHJhY292acWhdMSbIGplIGplZG5vIG5lYm8gdsOtY2UgcHJvdm96b3ZlbiAoemRyYXZvdG5pY2vDvWNoCnphIHplbsOtKSBOZW1vY25pY2UsIHNwZWNpZmlrb3ZhbsO9Y2ggdiBwxZnDrWxvemUgxI0uIDEgdMOpdG8gU21sb3V2eSwKamltxb4gamUgcG9za3l0b3bDoW5hIFNsdcW+YmE7CgogCgp0aGUgU29mdHdhcmUgbWVhbnMgdGhlIHNvZnR3YXJlIGFwcGxpY2F0aW9ucyBtYWRlCmF2YWlsYSBibGUgYnkgQnJhaW5vbWl4IHRvIHRoZSBIb3NwaXRhbCBzb2xlbHkgZm9yIHRoZSBwdXJwb3NlCm9mIGVuYWJsaW5nIHRoZSBwcm92aXNpb24gb2YgdGhlIFNlcnZpY2UsIGluY2x1ZGluZyAod2l0aG91dApsaW1pdGF0aW9uKSBhbnkgYXNzb2NpYXRlZCB1c2VyIGRvY3VtZW50YXRpb24sIGFzIHNwZWNpZmllZAppbkFwcGVuZGl4IDE7CgpTb2Z0d2FyZSBqc291IHNvZnR3YXJvdsOpIGFwbGlrYWNlLCBrdGVyw6kgQnJhaW5vbWl4IHpwxZnDrXN0dXDFiHVqZQpOZW1vY25pY2kgdsO9bHXEjW7EmyB6YSDDusSNZWxlbSB1bW/Fvm7Em27DrSBwb3NreXRvdmFuw61TSXXFvmJ54oCeCnbEjWV0bsSbIHDFmcOtcGFkbsOpIHNvdXZpc2Vqw61jw60gdcW+aXZhdGVsc2vDqSBkb2t1bWVudGFjZSwgcG9kbGUKc3BlY2lmaWthY8OtIHV2ZWRlbsO9Y2ggdiBwxZnDrWxvemUgxI0uIDEga3TDqXRvIFNtbG91dsSbOwoKIAoKYW4gQWNjZXNzIHRvIHRoZSBTZW1pY2UgbWVhbnMgcHJvdmlkaW5nIHRlY2huaWNhbCBhY2Nlc3MKY3JlZGVudGlhbCAoc3VjaCBhcyBhIGtleSBvciBjb2RlKSBlbmFibGluZyB0aGUgSG9zcGl0YWwKYWNjZXNzIHRvIHRoZSBTZXJ2aWNlIGFuZCB0aGUgU29mdHdhcmUgc29sZWx5IGZvciB0aGUKcHVycG9zZSBvZiByZWNlaXZpbmcgdGhlIFNlcnZpY2UgZHVyaW5nIHRoZSBSZWxldmFudCBQZXJpb2QsCnN1YmplY3QgdG8gZWFyfGllciB0ZXJtaW5hdGlvbiB1bmRlciBjbGF1c2UgMy40IG9yIDEyLjIgb3IKMTUuNCBiZWxvdzsgRm9yIHRoZSBhdm9pZGFuY2Ugb2YgZG91YnQsIHN1Y2ggYWNjZXNzIGRvZXMKbm90IGdyYW50IHRoZSBIb3NwaXRhbCBhbnkgcmlnaHQgdG8gaW5kZXBlbmRlbnRseSBleHBsb2l0CnRoZSBTb2Z0d2FyZSBvciBhbnkgaW50ZWxsZWN0dWFsIHByb3BlcnR5IG9mIEJyYWlub21peDsKClDFmcOtc3R1cCBrZSBzbHXFvmLEmyB6bmFtZW5hIHBvc2t5dG51dMOtIHRlY2huaWNrw6lobwpwxZnDrXN0dXBvdsOpaG8gw7pkYWplIChuYXDFmcOta2xhZCBrbMOtxI1lIG5lYm8ga8OzZHUpLCB1bW/FvsWIdSfDrWPDrWhvCk5lbW9jbmljaSBwxZnDrXN0dXAga2UgU2x1xb5ixJthIGtTb2Z0d2FydSB2w71sdcSNbsSbIHphIMO6IGVsZW0KxI1lcnDDoW7DrSBTbHXFvmJ5IHYgUm96aG9kbsOpbSBvYmRvYsOtLCBsZWRhxb5lIGRvamRlIGsgZMWZw612ZWrFocOtbXUKdWtvbsSNZW7DrSBwb2RsZSDEjWwuIDMuNCBuZWJvIDEyLjIgxI1pIDE1LjQgdMOpdG8gU21sb3V2eTsgUHJvCnZ5bG91xI1lbsOtIHBvY2h5Ym5vc3TDrSBzZSB0w61tdG8gTmVtb2NuaWNpIG5lcG9za3l0dWplIMW+w6FkbsOpCnByw6F2byBrIHNhbW9zdGF0bsOpbXUgdnl1xb7DrXZhbsOtIG5lYm8gaG9zcG9kw6HFmXNrw6ltdQp6aG9kbm9jb3bDoW7DrSBTb2Z0d2FydSBhbmkgamluw71jaCBwcsOhdiBkdcWhZXZuw61obyB2bGFzdG5pY3R2w60KQnJhaW5vbWl4OwoKIAoKdGhlIFN1cHBvcnQgU2VydmljZXMgbWVhbnMgdGhlIHNlcnZpY2VzIHNldCBvdXQgaW4KQXBwZW5kaXggMzsKClNsdcW+YnkgcG9kcG9yeSBqc291IHNsdcW+YnkgdXZlZGVuw6kgdiBwxZnDrWxvemUgxI0uIDMga3TDqXRvClNtbG91dsSbOwoKIAoKYSBVc2VyIG1lYW5zIGFueSBpbmRpdmlkdWFsIGVtcGxveWVkIG9yIGVuZ2FnZWQgYnkgdGhlCkhvc3BpdGFsIG9yIG90aGVyIGluZGl2aWR1YWwgYXV0aG9yaXNlZCBieSB0aGUgSG9zcGl0YWwgdG8KdXNlIHRoZSBTZXJ2aWNlIG9yIHRoZSBTb2Z0d2FyZSwgYW5kIGFueSBwZXJzb24gd2hvIGdhaW5zCmFjY2VzcyB0byB0aGUgU29mdHdhcmUgb3IgdGhlIFNlcnZpY2UgYnkgdXNpbmcgYW55IG9mIHRoZQpwYXNzd29yZHMsIG1lYW5zIG9mIGlkZW50aWZpY2F0aW9uLCBhdXRoZW50aWNhdGlvbiBvcgp2ZXJpZmljYXRpb24gaXNzdWVkIHRvIGFueSBpbmRpdmlkdWFsIGVtcGxveWVkIG9yIGVuZ2FnZWQKYnkgdGhlIEhvc3BpdGFsIG9yIGF1dGhvcmlzZWQgYnkgdGhlIEhvc3BpdGFsIHRvIHVzZSB0aGUKU2VydmljZSBvciB0aGUgU29mdHdhcmU7IGFuZAoKVcW+aXZhdGVsIGplIGZ5emlja8OhIG9zb2JhLCBrdGVyb3UgTmVtb2NuaWNlIG5hIHrDoWtsYWTEmyBqZWrDrWhvCnByYWNvdm7Em3Byw6F2bsOtaG8gbmVibyBvYmRvYm7DqWhvIHBvbcSbcnUgayBOZW1vY25pY2kgbmVibyB6CmppbsOpaG8gdGl0dWx1IGF1dG9yaXpvdmFsYSBrIHXFvsOtdsOhbsOtIFNsdcW+YnkgbmVibyBTb2Z0d2FydSwgYSBkw6FsZQprYcW+ZMOhIG9zb2JhLCBrdGVyw6EgesOtc2vDoSBwxZnDrXN0dXAgayBTb2Z0d2FydSBuZWJvIGtlIHNsdcW+YsSbIG5hCnrDoWtsYWTEmyBwb3XFvml0w60gbsSba3RlcsOpaG8gaGVzbGEsIGlkZW50aWZpa2HEjW7DrWNoIG5lYm8Kb3bEm8WZb3ZhY8OtY2ggcHJvc3TFmWVka8WvLCBqZcW+IE5lbW9jbmljZSB2eWRhbGEgZnl6aWNrw6kgb3NvYsSbIG5hCnrDoWtsYWTEmyBqZWrDrWhvIHphbcSbc3RuYW5lY2vDqWhvIG5lYm8gb2Jkb2Juw6lobyBwb23Em3J1IGsKTmVtb2NuaWNpIG5lYm8gbmEgesOha2xhZMSbIGppbsOpaG8gdGl0dWx1LCBwcm8gbsSbasW+IGppIE5lbW9jbmljZQpvcHLDoXZuaWxhIGsgdcW+w612w6Fuw60gU2x1xb5ieSBuZWJvIFNvZnR3YXJ1OyBhCgogCgphIFdvcmtpbmcgRGF5IG1lYW5zIGFueSBkYXkgTW9uZGF5IHRvIEZyaWRheSwgKGJvdGgKaW5jbHVzaXZlKSBleGNsdWRpbmcgQ3plY2ggYmFuayBob2xpZGF5cyBhbmQgcHVibGljCmhvbGlkYXlzLgoKUHJhY292bsOtZGVuIGplIGthxb5kw70gZGVuIG9kIHBvbmTEm2zDrSBkbyBww6F0a3UgKHbEjWV0bsSbKSwga3JvbcSbCmRuxa8gcHJhY292bsOtaG8ga2xpZHUgYSBzdMOhdG7DrWNoIHN2w6F0a8WvIHYgxIxlc2vDqSByZXB1YmxpY2UuCgogCgphIFdvcmtpbmcgSG91ciBtZWFucyB0aGUgdGltZSBiZXR3ZWVuIDk6MDAgYW0uIGFuZAo1OjAwIHBtLiB8b2NhfCB0aW1lIG9uIGEgV29ya2luZyBEYXksIGV4Y2x1ZGluZyBDemVjaApiYW5rIGhvbGlkYXlzIGFuZCBwdWJsaWMgaG9saWRheXMuCgpQcmFjb3Zuw60gaG9kaW5hIGplIMSNYXMgbWV6aSA5OjAwIGEgMTc6MDAgaG9kaW5vdSBtw61zdG7DrWhvIMSNYXN1CnYgUHJhY292bsOtIGRlbiBrcm9txJsgZG7FryBwcmFjb3Zuw61obyBrbGlkdSBhIHN0w6F0bsOtY2ggc3bDoXRrxa8gdgrEjGVza8OpIHJlcHVibGljZS4KCiAKCiAKClN1YmplY3QgdG8gdGhlIEFncmVlbWVudCBhbmQgdGhlIEFjY2VzcyB0byB0aGUgU2VydmljZQoKIAoKUMWZZWRtxJt0IFNtbG91dnkgYSBQxZnDrXN0dXAga2Ugc2x1xb5ixJsKCiAKCiAKCkJyYWlub21peCBFdXJvcGUgTGltaXRlZApTdWl0ZSAxMDM4MAoKMjYvMjcgVXBwZXIgUGVtYnJva2UgU3RyZWV0CkR1YmxpbiAyIEQwMiwgWDM2MSBJcmVsYW5kCgogCgozLjEKCkJyYWlub21peCBoZXJlYnkgdW5kZXJ0YWtlcyB0byBwcm92aWRlIHRoZSBIb3NwaXRhbCB3aXRoCnRoZSBBY2Nlc3MgdG8gdGhlIFNlcnZpY2UgYW5kIHRvIHN1cHBseSBpdCB3aXRoIFNlcnZpY2VzIGluCmR1bHkgYW5kIHRpbWVseSBtYW5uZXIgYW5kIHdpdGggZXhlcmNpc2luZyBwcm9mZXNzaW9uYWwKY2FyZSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgc2V0IG91dCBpbiB0aGlzCkFncmVlbWVudCBhbmQgdGhlIEhvc3BpdGFsIGhlcmVieSB1bmRlcnRha2VzIHRvIHByb3ZpZGUKQnJhaW5vbWl4IHdpdGggZHVlIGNvb3BlcmF0aW9uIGFuZCB0byBwYXkgdGhlIGNoYXJnZXMKdW5kZXJ0aGUgdGVybXMgYW5kIGNvbmRpdGlvbiBzZXQgb3V0IGluIHRoaXMgQWdyZWVtZW50LgoKMy4xCgpTcG9sZcSNbm9zdCBCcmFpbm9taXggc2UgdG91dG8gU21sb3V2b3UgemF2YXp1amUgcG9za3l0bm91dApOZW1vY25pY2kgUMWZw61zdHVwIGtlIFNsdcW+YsSbIGEgcG9za3l0b3ZhdCBqIGRuxJssIHbEjWFzIHDFmWkKdnluYWxvxb5lbsOtIG9kYm9ybsOpIHDDqcSNZSBTbHXFvmJ5IGRsZSBwb2Rtw61uZWsgdMOpdG8gU21sb3V2eSBhCk5lbW9jbmljZSBzZSB6YXZhenVqZSBwb3NreXRvdmF0IHNwb2xlxI1ub3N0aSBCcmFpbm9taXgKc291xI1pbm5vc3QgYSBocmFkaXRqw60gT2RtxJtudSBkbGUgcG9kbcOtbmVrIHTDqXRvIFNtbG91dnkuCgogCgogCgozLjIKCkJyYWlub21peCBncmFudHMgdG8gdGhlIEhvc3BpdGFsIGEgbm9ucmV4Y2x1c2l2ZSwgbm9uZQp0cmFuc2ZlcmFibGUgQWNjZXNzIHRvIFNlcnZpY2UgdG8gcGVybWl0IFVzZXJzIHRvIHVzZSB0aGUKU29mdHdhcmUgYW5kIHRoZSBTZXJ2aWNlIGF0IHRoZSBTaXRlIHNvbGVseSBmb3IgQ2xpbmljYWwKUGF0aWVudCBDYXJlIGR1cmluZyB0aGUgUmVsZXZhbnQgUGVyaW9kLCBhcyBpdCBpcyBzcGVjacWIZWQgaW4KZGV0YWlsIGluIEFwcGVuZGl4IDEsIHN1YmplY3QgdG8gYW55IHJlc3RyaWN0aW9ucyBzZXQgb3V0IGluCnRoZSBBZ3JlZW1lbnQgYW5kIHN1YmplY3QgdG8gZWFybGllciB0ZXJtaW5hdGlvbiB1bmRlcgpjbGF1c2UgMy40IG9yIDEyLjIgb3IgMTUuNCBiZWxvdy4KCjMuMgoKQnJhaW5vbWl4IHBvc2t5dHVqZSBOZW1vY25pY2kgbmV2w71ocmFkbsSbLCBuZXDFmWVub3Nuw6kKUMWZw61zdHVwIGtlIFNsdcW+YsSbLCB6YSDDusSNZWxlbSB1bW/Fvm7Em27DrSBVxb5pdmF0ZWzFr20gdcW+w612YXQKU29mdHdhcmUgYSBTbHXFvmJ1IG5hIGRhbsOpbSBQcmFjb3ZpxaF0aSwgYSB0byB2w71ocmFkbsSbIHBybyDDusSNZWx5CktsaW5pY2vDqSBww6nEjWUgbyBwYWNpZW50eSBixJtoZW0gUm96aG9kbsOpaG8gb2Jkb2LDrSwgamFrIGplCnBvZHJvYm7EmyBzcGVjaWZpa292YW7DqSB2cMWZw61sb3plIMSNLiAxIHTDqXRvIFNtbG91dnksIHMKcMWZw61wYWRuw71taSBvbWV6ZW7DrW1pIHV2ZWRlbsO9bWkgdiB0w6l0byBTbWxvdXbEmyBhIHMgbW/Fvm5vc3TDrQpwxZllZMSNYXNuw6lobyB1a29uxI1lbsOtIHBvZGxlIMSNbC4gMy40IG5lYm8gMTIuMiDEjWkgMTUuNCB0w6l0bwpTbWxvdXZ5LgoKIAoKMy4zCgpBdCB0aGUgZGF0ZSBvZiB0aGUgYmVnaW5uaW5nIG9mIHRoZSBSZWxldmFudCBQZXJpb2QgdGhlCkhvc3BpdGFsIHdpbGwgYmUgZ2l2ZW4gYW4gQWNjZXNzIHRvIFNlcnZpY2UgcHJvdmlkaW5nIGFjY2Vzcwp0byB0aGUgU29mdHdhcmUgYW5kIHRoZSBTZXJ2aWNlLiBUaGF0IEFjY2VzcyB0byBTZXJ2aWNlIGFuZAp0aGUgcmlnaHQgdG8gYWNjZXNzIHRoZSBTb2Z0d2FyZSBhbmQgdGhlIFNlcnZpY2Ugd2lsbAp0ZXJtaW5hdGUgYXV0b21hdGljYWxseSB3aGVuIHRoZSBSZWxldmFudCBQZXJpb2QgZXhwaXJlcwp3aXRob3V0IHJlbmV3YWwgb3IgdGhlIEFncmVlbWVudCB0ZXJtaW5hdGVzLgoKMy4zCgpLZSBkbmkgcG/EjcOhdGt1IFJvemhvZG7DqWhvIG9iZG9iw60gb2JkcsW+w60gTmVtb2NuaWNlIFDFmcOtc3R1cAprZSBTbHXFvmLEmywgbmEgamVob8W+IHrDoWtsYWTEmyB6w61za8OhIHDFmcOtc3R1cCBrIFNvZnR3YXJ1IGEga2UgU2x1xb5ixJsuClDFmcOtc3R1cCBrZSBTbHXFvmLEmyBhIHByw6F2byBwxZnDrXN0dXB1IGtTb2Z0d2FydSBhIGtlIFNsdcW+YsSbIGJ1ZG91CmF1dG9tYXRpY2t5IHVrb27EjWVueSBwbyB1YsSbaG51dMOtIFJvemhvZG7DqWhvIG9iZG9iw60gYmV6CnByb2Rsb3XFvmVuw60gbmVibyBwxZlpIHVrb27EjWVuw60gU21sb3V2eS4KCiAKCjMuNAoKQWNjZXNzIHRvIHRoZSBTb2Z0d2FyZSBhbmQgdGhlIFNlcnZpY2Ugd2lsbCBiZSB0ZXJtaW5hdGVkCmJ5IEJyYWlub21peCBpZiB0aGUgSG9zcGl0YWwgdXNlcyB0aGUgU29mdHdhcmUgb3IgdGhlClNlcnZpY2VzIGFueXdoZXJlIGV4Y2VwdCBhdCB0aGUgU2l0ZSBhbmQgdGhlIEhvc3BpdGFsIGRvZXMKbm90IGFjcXVpcmUgZnJvbSBCcmFpbm9taXggYW4gZXh0ZW5zaW9uIHdoaWNoIGFsbG93cyB0aGUKSG9zcGl0YWwgdG8gdXNlIHRoZSBTb2Z0d2FyZSBhbmQgdGhlIFNlcnZpY2UgYXQgYW5vdGhlciBTaXRlLgpCcmFpbm9taXggbWF5IGluIHN1Y2ggYSBjYXNlIHRlcm1pbmF0ZSB0aGUgQWdyZWVtZW50CndpdGggaW1tZWRpYXRlIGVmZmVjdCBieSBnaXZpbmcgd3JpdHRlbiBub3RpY2UgdG8gdGhlCkhvc3BpdGFsLgoKMy40CgpQxZnDrXN0dXB5IGsgU29mdHdhcnUgYSBrZSBTbHXFvmLEmyBidWRvdSB6ZSBzdHJhbnkgc3BvbGXEjW5vc3RpCkJyYWlub21peCB1a29uxI1lbnksIHBva3VkIE5lbW9jbmljZSBidWRlIFNvZnR3YXJlIG5lYm8KU2x1xb5idSB1xb7DrXZhdCBqaW5kZSBuZcW+IG5hIHVyxI1lbsOpbSBQcmFjb3ZpxaF0aSBhIG5lb2JzdGFyw6Egc2kgb2QKc3BvbGXEjW5vc3RpIEJyYWlub21peCBwxZllZHTDrW0sIG5lxb4gemHEjW5lIFNvZnR3YXJlIGEgU2x1xb5idQp1xb7DrXZhdCBuYSBqaW7DqW0gUHJhY292acWhdGksIHJvesWhw63FmWVuw60sIGt0ZXLDqSBqw60gdW1vxb5uw60gdcW+w612YXQKU29mdHdhcmUgYSBTbHXFvmJ1IG5hIGppbsOpbSBQcmFjb3ZpxaF0aS4gU3BvbGXEjW5vc3QgQnJhaW5vbWl4IG3DoQp2dMSbY2h0byBwxZnDrXBhZGVjaCBwcsOhdm8gdWtvbsSNaXQgdHV0byBTbWxvdXZ1IHbDvXBvdsSbZMOtIGJlegp2w71wb3bEm2Ruw60gZG9ieS4KCiAKClVzZSBvZiB0aGUgU29mdHdhcmUgYW5kIHRoZSBTZW1pY2UKClXFvsOtdsOhbsOtIFNvZnR3YXJ1IDMgU2x1xb5ieQoKIAoKNC4xLgoKVGhlIEhvc3BpdGFsIG11c3Qgbm90OgoKNC4xLgoKTmVtb2NuaWNlIG5lbsOtb3Byw6F2bsSbbsOhOgoKIAoKIAoKIAoKIAoKNC4xLjEuIG1ha2UgdGhlIFNvZnR3YXJlIG9yIGFueSBvZiB0aGUgU2VydmljZXMgYXZhaWxhYmxlIDQuMS4xLiB6cMWZw61zdHVwxYhvdmF0IFNvZnR3YXJlIGFuaSDFvsOhZG5vdSBTbHXFvmJ1IHTFmWV0w61tCnRvIGFueSB0aGlyZCBwYXJ0eSwgb24gYSBjb21tZXJjaWFsIGJhc2lzLCBmcmVlIG9mIG9zb2LDoW0sIGEgdG8gemEgw7pwbGF0dSwgYmV6cGxhdG7EmywgZm9ybW91IHBvZGxpY2VuY2UKY2hhcmdlLCBieSBzdWJsaWNlbmNlIG9yIG90aGVyd2lzZSBvciAoZXhjZXB0IGZvciBhbmkgamluYWsgKHMgdsO9amlta291IHRvaG8sIMW+ZSBtxa/FvmUgVcW+aXZhdGVsxa9tIHVtb8W+bml0CmFsbG93aW5nIFVzZXJzIHRvIHVzZSB0aGUgU29mdHdhcmUgYW5kIHRoZSBTZXJ2aWNlIHXFvmx2w6Fuw60gU29mdHdhcnUgYSBTbHXFvmJ5diBzb3VsYWR1IHNlIFNtbG91dm91KSwgbmVzbcOtCmluIGFjY29yZGFuY2Ugd2l0aCB0aGUgQWdyZWVtZW50KSwgc2hhcmUgdGhlIHVzZSBzZMOtbGV0IHXFvsOtdsOhbsOtIFNvZnR3YXJ1LCBTbHXFvmJ5IChuZWJvIG9ib2rDrWhvKSBzIGppbm91Cm9mLCBvciBncmFudCBhbnkgc3VicmxpY2VuY2UgdG8gdXNlLCB0aGUgU29mdHdhcmUgb3Igb3NvYm91IGFuaSBuZXNtw60gbmEgamVqaWNoIHXFvml0w60gcG9za3l0bm91dCBqaW7DqSBvc29ixJsKdGhlIFNlcnZpY2UgKG9yIGJvdGgpIHRvIGFueSBwZXJzb247IHBvZGxpY2VuY2k7Cgo0LjEuMi4gdXNlIHRoZSBTZXJ2aWNlIG9yIHRoZSBTb2Z0d2FyZSBleGNlcHQgdG8gYW5hbHlzZSA0LjEuMi4gdcW+w612YXQgU2x1xb5idSBuZWJvIFNvZnR3YXJlIGppbmFrIG5lxb4gayBhbmFsw716ZSDDmmRhasWvCnRoZSBIb3NwaXRhbCBEYXRhIGFuZCBnZW5lcmF0ZSB0aGUgSG9zcGl0YWwgUmVzdWx0cywgTmVtb2NuaWNlIGEga2UgZ2VuZXJvdsOhbsOtIFbDvXNsZWRrxa8gTmVtb2NuaWNlLCB6YQpzdWJqZWN0IHRvIGFueSBjb25kaXRpb25zIHNldCBvdXQgaW4gQXBwZW5kaXggMTsgcG9kbcOtbmVrIHN0YW5vdmVuw71jaCB2IHTDqXRvIFNtbG91dsSbOwoKNC4xLjMuIGV4Y2VwdHRvIHRoZSBleHRlbnQgcGVybWl0dGVkIGJ5YW55IGFwcGxpY2FibGUgbGF3IDQuMS4zLiBkZWtvbXBpbG92YXQgU29mdHdhcmUsIHJvemtsw6FkYXQgamVqLCB6cMSbdG7EmyBhbmFseXpvdmF0Cgp3aGljaCB0aGUgcGFydGllcyBjYW5ub3QgZXhjbHVkZSBieSBhZ3JlZW1lbnQsCnJldmVyc2UgY29tcGlsZSwgZGlzYXNzZW1ibGUsIHJldmVyc2UgZW5naW5lZXIgb3IKcmVkdWNlIHRvIGh1bWFucnJlYWRhYmxlIGZvcm0gYWxsIG9yIGFueSBvZiB0aGUKU29mdHdhcmU7CgogCgpuZWJvIHDFmWV2w6FkxJt0IG5hIMSNbG92xJtrZW0gxI1pdGVsbm91IGZvcm11LCBsZWRhxb5lIHRvIHYKdXLEjWl0w6ltIHJvenNhaHUgdW1vxb7FiHVqw60gcGxhdG7DqSBwcsOhdm7DrSBwxZllZHBpc3ksIGplamljaMW+CnVwbGF0bsSbbsOtIHN0cmFueSBuZW1vaG91IHNtbHV2bsSbIHZ5bG91xI1pdDsKCiAKCiAKCkJyYWlub21peCBFdXJvcGUgTGltaXRlZApTdWl0ZSAxMDM4MAoKMjYvMjcgVXBwZXIgUGVtYnJva2UgU3RyZWV0CkR1YmxpbiAyIEQwMiwgWDM2MSBJcmVsYW5kCgogCgp1c2UgdGhlIFNlcnZpY2UsIHRoZSBTb2Z0d2FyZSBvciB0aGUgSG9zcGl0YWwgUmVzdWx0cwp0byBjcmVhdGUgYSBwcm9kdWN0IG9yIHNlcnZpY2Ugd2hpY2ggY29tcGV0ZXMgd2l0aAp0aGUgU2VydmljZSBvciB0aGUgU29mdHdhcmUgb3IgdG8gY29tcGFyZSB0aGUKU2VydmljZSBvciB0aGUgU29mdHdhcmUgdG8gYSBwcm9kdWN0IG9yIHNlcnZpY2UKd2hpY2ggY29tcGV0ZXMgd2l0aCB0aGUgU2VydmljZSBvciB0aGUgU29mdHdhcmU7Ck9mCgo0LjEuNC4gdcW+w610IFNsdcW+YnUsIFNvZnR3YXJlIG5lYm8gVsO9c2xlZGt5IE5lbW9jbmljZSBrCnZ5dHZvxZllbsOtIHByb2R1a3R1IG5lYm8gc2x1xb5ieSBrb25rdXJ1asOtY8OtY2ggU2x1xb5ixJsKbmVibyBTb2Z0d2FydSBuZWJvIGsgcG9yb3Zuw6Fuw60gU2x1xb5ieSBuZWJvIFNvZnR3YXJ1IHMKcHJvZHVrdGVtIG5lYm8gc2x1xb5ib3UsIGplxb4ga29ua3VydWrDrSBTbHXFvmLEmyBuZWJvClNvZnR3YXJ1OyBuZWJvCgogCgp3aXRob3V0IGZpcnN0IG9idGFpbmluZyBCcmFpbm9taXgncyB3cml0dGVuIGNvbnNlbnQsCnVzZSB0aGUgU29mdHdhcmUgb3J0aGUgU2VydmljZSBmb3IgcmVzZWFyY2guCgo0LjEuNS4gYmV6IHDFmWVkY2hvesOtaG8gcMOtc2VtbsOpaG8gc291aGxhc3Ugc3BvbGXEjW5vc3RpCkJyYWlub21peCB1xb7DrXZhdCBTb2Z0d2FyZSBuZWJvIFNsdcW+YnUga3bDvXprdW11LgoKIAoKNC4yLiBUaGUgSG9zcGl0YWwgYWdyZWVzdGhhdDoKCjQuMi4gTmVtb2NuaWNlIHNlIHphd3p1amUgayBuw6FzbGVkdWrDrWPDrW11OgoKIAoKIAoKIAoKIAoKIAoKIAoKIAoKIAoKNC4yLjEgaXQgd2lsbCB1c2UgYXx8IHJlYXNvbmFibGUgZW5kZWF2b3VycyB0byBwcmV2ZW50IGFueSA0LjIuMSBwxZlpam1vdXQgdmXFoWtlcsOhIHDFmWltxJvFmWVuw6Egb3BhdMWZZW7DrSwgYWJ5IHphYnJhIHx8YQp1bmF1dGhvcmlzZWQgYWNjZXNzIHRvLCBhbmQgYW55IHVuYXV0aG9yaXNlZCB1c2Ugb2YsIG5lb3Byw6F2bsSbbsOpbXUgcMWZw61zdHVwdSBrIFNvZnR3YXJ1IGEgU2x1xb5ixJsgYSBqZWppY2gKdGhlIFNvZnRybXJlYW5kdGhlU2VydmljZSBhbmQgd2lsbCBub3RpZnkgQnJhaW5vbWl4IG5lb3Byw6F2bsSbbsOpbXUgdcW+aXTDrSwgYSBuZXByb2RsZW7EmyBpbmZvcm1vdmF0CmltbWVkaWF0ZWx5IGlmIGl0IGJlY29tZXMgYXdhcmUgb2YgYW55IHN1Y2ggc3BvbGXEjW5vc3QgQnJhaW5vbWl4LCBwb2t1ZCBzZSBvIHRha292w6ltCnVuYXV0aG9yaXNlZCBhY2Nlc3Mgb3IgdXNlOyBuZW9wcsOhdm7Em27DqW0gcMWZw61zdHVwdSBuZWJvIHXFvml0w60gZG96dsOtOwoKNC4yLjIgYXx8IFVzZXJzIGF1dGhvcmlzZWQgYnkgdGhlIEhvc3BpdGFsIHRvIHVzZSB0aGUgNC4yLjIgdsWhaWNobmkgVcW+aXZhdGVsw6kgb3Byw6F2bsSbbsOtIE5lbW9jbmljw60gayB1xb7DrXbDoW7DrQpTb2Z0d2FyZSBhbmQgdGhlIFNlcnZpY2Ugd2l8fCB1c2UgYSBzdHJvbmcgcGFzc3dvcmQgU29mdHdhcnUgYSBTbHXFvmJ5IGJ1ZG91IHBybyBwxZnDrXN0dXAgayBTb2Z0d2FydSBhIGtlCmZvciBhY2Nlc3MgdG8gdGhlIFNvZnR3YXJlIGFuZCB0aGUgU2VydmljZSwgd2l8fCBrZWVwIFNsdcW+YsSbIHBvdcW+w612YXQgc2lsbsOpIGhlc2xvLCBidWRvdSB6YWNob3bDoXZhdAp0aGVpciBwYXNzd29yZCBhbmQgYW55IG90aGVyIG1lYW5zIG9mIG1sxI1lbmxpdm9zdCBvIHN2w6ltIGhlc2xlIGEgb3N0YXRuw61jaCBwcm9zdMWZZWRjw61jaAppZGVudGlmaWNhdGlvbiwgYXV0aGVudGljYXRpb24gb3IgdmVyaWZpY2F0aW9uIGlzc3VlZCBpZGVudGlmaWthY2UgYSBvdsSbxZllbsOtLCBrdGVyw6kgb2JkcsW+w60sIGJ1ZG91IGRiw6F0IG5hIGplamljaAp0byB0aGVtIHNlY3VyZSBhbmQgY29uZmlkZW50aWFsIGFuZCBub3Qgc2hhcmUgaXQgemFiZXpwZcSNZW7DrWEgbmVidWRvdWplIHNkxJtsb3ZhdGppbsO9bSBvc29iYW07CndpdGggYW55IG90aGVyIHBlcnNvbjsKCjQuMi4zIGl0IHdpbGwgaW5mb3JtIEJyYWlub21peCB3aXRob3V0IGRlbGF5IGlmIHRoZSBIb3NwaXRhbCA0LjIuMyBuZXByb2RsZW7EmyBpbmZvcm1vdmF0IHNwb2xlxI1ub3N0IEJyYWlub21peCwgamVzdGxpxb5lCmNlYXNlcyB0byBlbXBsb3kgYSBVc2VyIG9yIGNlYXNlcyB0byBhdXRob3Jpc2UgYSBuxJtrdGVyw70gVcW+aXZhdGVsIHDFmWVzdGFuZSBiw710IHphbcSbc3RuYW5jZW0KVXNlciB0byBhY2Nlc3MgdGhlIFNvZnR3YXJlIGFuZCB0aGVTZXJ2aWNlLCBOZW1vY25pY2UgbmVibyBtdSBidWRlIG9kZWJyYW5vIG9wcsOhdm7Em27DrSBwxZnDrXN0dXB1CgprIFNvZnR3YXJ1IGEga2UgU2x1xb5ixJs7Ci4gLiAuIC4gLiA0LjIuNCB2w6lzdCBha3R1YWxpem92YW7DvSBzZXpuYW0gc3TDoXZhasOtY8OtY2ggVcW+aXZhdGVsxa8gYQoKNC4yLjQgfHR3cnx8IG1hcm50YXJudmFudXBydG9yZGF0ZWxyc3RvZmNucnJlbnQgVXNlcnMgYW5kIHBvc2t5dG5vdXQgaG8gc3BvbGXEjW5vc3RpIEJyYWlub21peCBrIG5haGzDqWRudXTDrSBkbwptYWtlIHRoaXMgYXZhcnZsYWJsZXZ0byBCcmFybm9tcnggd3J0aHJuIDUgV29ya2luZyA1IHByYWNvdm7DrWNoIGRuxa8sIGtkeWtvbGkgb3RvIEJyYWlub21peCBwb8W+w6Fkw6E7CgpEYXlzIGFmdGVyIEJyYXJub21yeCByZXF1ZXN0cyB0byBzZWUgdGhhdCBsaXN0IGZyb20KdGltZSB0byB0aW1lOwoKNC4yLjUgaXQgd2lsbCBhbGxvdyBCcmFpbm9taXggdG8gYXVkaXQgdGhlIHVzZSBvZiB0aGUgNC4yLjUgdW1vxb5uaXQgc3BvbGXEjW5vc3RpIEJyYWlub21peCBhdWRpdCB1xb7DrXZhbsOtU29mdHdhcnUgYQpTb2Z0d2FyZSBhbmQgdGhlIFNlcnZpY2UgdG8gZGlzY292ZXIgd2hldGhlcjogdGhlIFNsdcW+YnkgemEgw7rEjWVsZW0ga29udHJvbHksIHpkYSBOZW1vY25pY2UgYSBVxb5pdmF0ZWzDqQpIb3NwaXRhbCBhbmQgVXNlcnMgYXJlIGNvbXBseWluZyB3aXRoIHRoZSBqZWRuYWrDrSB2IHNvdWxhZHUgc2UgU21sb3V2b3UsIGEga29udHJvbHksIHpkYSBoZXNsbwpBZ3JlZW1lbnQ7IGFuZCBhbnkgcGVyc29uIG5vdCBhdXRob3Jpc2VkIHRvIHVzZSBuZWJvIGppbsO9IHByb3N0xZllZGVrIGlkZW50aWZpa2FjZSBuZWJvIG92xJvFmWVuw60gbmVtYQp0aGUgU29mdHdhcmUgYW5kIHRoZSBTZXJ2aWNlIGhhcyBhIHBhc3N3b3JkIG90aGVyIG9zb2JhLCBrdGVyw6EgbmVuw60gb3Byw6F2bsSbbmEgdcW+w612YXQgU29mdHdhcmUgYSBTbHXFvmJ1LAptZWFucyBvZiBpZGVudGlmaWNhdGlvbiwgYXV0aGVudGljYXRpb24gb3IgYWJ5IGJ5bG8gbW/Fvm5vIHRha292w6kgaGVzbG8gxI1pIHByb3N0xZllZGt5IGlkZW50aWZpa2FjZQp2ZXJpZmljYXRpb24gc28gdGhlc2UgY2FuIGJlIGJ8b2NrZWQgaW1tZWRpYXRlbHk7IG9rYW3Fvml0xJsgemFibG9rb3ZhdDsgdGFrb3bDvSBhdWRpdCB2xaFhayBuZXNtw60KcHJvdmlkZWQsIGhvd2V2ZXIsIHRoYXQgYW55IHN1Y2ggYXVkaXQgc2hhbGwgbm90IG5lcMWZaW3Em8WZZW7EmyBuYXJ1xaFpdCBuZWJvIG9tZXppdCBwcm92b3ogTmVtb2NuaWNlLiBWCnVucmVhc29uYWJseSBkaXNydXB0IG9yIGludGVyZmVyZSB3aXRoIHRoZSBwxZnDrXBhZMSbLCDFvmUgYnkgYXVkaXQgbmFydcWhb3ZhbCBuZWJvIG9tZXpvdmFsIHByb3ZvegpvcGVyYXRpb24gb2YgdGhlIEhvc3BpdGFsLiBJbiB0aGUgZXZlbnQgdGhhdCB0aGUgTmVtb2NuaWNlLCBqZSBOZW1vY25pY2Ugb3Byw6F2bsSbbmEgYXVkaXQgcMWZZXJ1xaFpdAphdWRpdCBkaXNydXB0cyBvciBpbnRlcmZlcmVzIHdpdGggdGhlIEhvc3BpdGFsJ3MgbmVibyB1a29uxI1pdCwgYSB0byBwbyBwxZllZGNob3rDrW0gdXBvem9ybsSbbsOtCm9wZXJhdGlvbnMsIHRoZSBIb3NwaXRhbCBzaGFsbCBiZSBlbnRpdGxlZCB0byBzdXNwZW5kIHNwb2xlxI1ub3N0aSBCcmFpbm9taXguCm9yIHRlcm1pbmF0ZSB0aGUgYXVkaXQsIGZvbGxvd2luZyBwcmlvciBub3RpY2UgdG8gdGhlCkNvbXBhbnkuCgo0LjIuNiBpdCB3aWxsIGVuc3VyZSB0aGF0IHRoZSBVc2VycyBjb21wbHkgd2l0aCBhbGwgcnVsZXMsIDQuMi42IHphamlzdGl0LCBhYnkgVcW+aXZhdGVsw6kgZG9kcsW+b3ZhbGkgdsWhZWNobmEgcHJhdmlkbGEsCgpyZWd1bGF0aW9ucywgc3RhbmRhcmRzLCBwcm90b2NvbHMgYW5kIHByb2NlZHVyZXMKQnJhaW5vbWl4IGlzc3VlcyBmcm9tIHRpbWUgdG8gdGltZSBmb3IgdGhlIHVzZSBvcgpzZWN1cml0eSBvZnRoZVNvZnR3YXJlb3J0aGVTZXJ2aWNlKG9yYm90aCk7YW5kCgogCgpwxZllZHBpc3ksIHN0YW5kYXJkeSwgcHJvdG9rb2x5IGFwb3N0dXB5IHZ5ZGFuw6kKc3BvbGXEjW5vc3TDrSBCcmFpbm9taXggdnNvdXZpc2xvc3RpIHMgdcW+w612w6Fuw61tIG5lYm8KemFiZXpwZcSNZW7DrW0gU29mdHdhcnUgYS9uZWJvIFNsdcW+Ynk7IGEKCiAKCiAKCkJyYWlub21peCBFdXJvcGUgTGltaXRlZApTdWl0ZSAxMDM4MAoKMjYvMjcgVXBwZXIgUGVtYnJva2UgU3RyZWV0CkR1YmxpbiAyIEQwMiwgWDM2MSBJcmVsYW5kCgogCgo0LjIuNyBpdCB3aWxsIGJlIGxpYWJsZSBmb3IgdGhlIGFjdHMgYW5kIGVtaXNzaW9ucyBvZiBlYWNoClVzZXIsIGFzIHRob3VnaCB0aG9zZSBhY3RzIGFuZCBlbWlzc2lvbnMgd2VyZQp0aG9zZSBvZnRoZSBIb3NwaXRhbC4KCjQuMi43IG7DqXN0IG9kcG92xJtkbm9zdCB6YSBqZWRuYW7DrSDEjWlvcG9tZW51dMOtIGthxb5kw6lobwpVxb5pdmF0ZWxlLCBqYWtvIGJ5IHNlIGplZG5hbG8gbyBqZWrDrSB2bGFzdG7DrSBqZWRuYW7DrSDEjWkKb3BvbWVudXTDrS4KCiAKCiAKCiAKCiAKCiAKCiAKCiAKCiAKCiAKCjQuMyBJbiB0aGUgY2FzZXMgc3BlY2lmaWVkIGJlbG93LCBCcmFpbm9taXggc2hhbGwgcmVxdWVzdCB0aGUg4oCeICcg4oCeIC4gLiAuIC4KSG9zcGl0YWwgdG8gcmVtZWR5IHRoZSBzaXR1YXRpb24uIFRoZSBIb3NwaXRhbCBtdXN0LCA0LjMgViBWbnJ6ZSDigJx1dmVkZW55Y2ggcHJycGEnZGVjaCDigJx2eXp2ZSBCcmFybm9tcnggTmVybm9jbnJlcgp3aXRoaW4gdGVuICgxMCkgYnVzaW5lc3MgZGF5cywgaW52ZXN0aWdhdGUgdGhlIGlkZW50aWZpZWQga25hcHJhdmUuICdcZmUnw5pPQ1AnQ2UgbXVzcid2ZSB8aHV0ZTEwWyhkZXNldCl3cHJhY3Zvdm58Y2h5ZG51CnN1c3BpY2lvbnMgYW5kLCBpZiBzdWNoIHN1c3BpY2lvbnMgYXJlIGNvbmZpcm1lZCwgcHJvdmVzdCBwcm9zZXRyZW5yIG5hbGV6ZW55Y2ggcG9kZXpyZW5yIGEgdi1wci1ycGFkZSBwcm9rYcW+YW5yCmltcGxlbWVudCB0aGUgbmVjZXNzYXJ5IG1lYXN1cmVzIHRvIGVsaW1pbmF0ZSB0aGVtLiBwb2RlenJlbnIgemEndmVzdHYgcG9pdHZyZWJuYXYgb3BhdHJlbnIgcHJvdiBKZUrDjUNoIG9kc3RyYW5lbnIuCk90aGV3dmlzZSwgb3IgaWYgdGhlIG1lYXN1cmVzIGFyZSBpbnN1ZmZyY2llbnQsIEJyYWlub21peCBWIG9wYWNuZXJuIHBycmJhZGUgcm51emUgQnJhcm5kcm5yeCBwb3phJ3N0YXZydCBwcmpldHVwIGsgU29mdHdhcnUKbWF5IHN1c3BlbmQgYWNjZXNzIHRvIHRoZSBTb2Z0d2FyZSBhbmQgdGhlIFNlcnZpY2UgYSBrZSBTbHV6YmUsIGFubHogYnl0bG0gTmVtb2NubGNsIG9kcG92bGRhbGEgemEgdWptdToKd2l0aG91dCBiZWluZyB8aWFifGUgdG8gdGhlIEhvc3BpdGFsIGZvciBhbnkgZGFtYWdlCnRoZXJlYnkgaW5jdXJyZWQ6Cgo0LjMuMSB0aGVyZSBoYXMgYmVlbiwgb3IgdGhlcmUgaXMgYSByZWFzb25hYmxlIHN1c3BpY2lvbiA0LjMuMSBkb8WhbG8sIG5lYm8gZXhpc3R1amUgZMWvdm9kbsOpIHBvZGV6xZllbsOtLCDFvmUgZG/FoWxvLCBrCnRoYXQgdGhlcmUgbWF5IGhhdmUgYmVlbiwgYSBicmVhY2ggb2Ygc2VjdXJpdHksIG9yIGEgUG9ydcWhZW7DrSB6YWJlenBlxI1lbsOtIG5lYm8gayBwb3J1xaFlbsOtIHphcnVreSDEjWkgemF2YXprdQpicmVhY2ggb2YgYW55IHdhcnJhbnR5IG9yIHVuZGVydGFraW5nIGdpdmVuIGJ5IHRoZSBkYW7DvWNoIE5lbW9jbmljaSB2ZSBTbWxvdXbEmywgbmVibyBkb8WhbG8gawpIb3NwaXRhbGluIHRoZSBBZ3JlZW1lbnQsIG9yYW55dW5sYXdmdWxvcmlsbGVnYWwgcHJvdGlwcsOhdm7DrW11IG5lYm8gbmVsZWfDoWxuw61tdSB1xb5pdMOtIFNvZnR3YXJ1IG5lYm8KdXNlIG9mIHRoZSBTb2Z0d2FyZSBvciB0aGUgU2VydmljZSBieSB0aGUgSG9zcGl0YWwsIFNsdcW+YnkgTmVtb2NuaWNpLCBVxb5pdmF0ZWxlbSBuZWJvIGppbm91IG9zb2JvdTsKYnkgYW55IFVzZXIgb3IgYnkgYW55IG90aGVyIHBlcnNvbjsKNC4zLjIgQnJhaW5vbWl4IGtub3dzIG9yIHN1c3BlY3RzIHRoYXQgTWFsd2FyZSBoYXMgNC4zLjIgQnJhaW5vbWl4IHbDrSBuZWJvIG3DoSBwb2RlesWZZW7DrSwgxb5lIGRvIFNvZnR3YXJ1IG5lYm8KYmVlbiBpbnRyb2R1Y2VkIGludG90aGUgU29mdHdhcmUgb3IgdGhlIFNlcnZpY2U7IG9yIFNsdcW+YnkgcHJvbmlrbCDFoGtvZGxpdsO9IHNvZnR3YXJlOyBuZWJvCjQuMy4zIEJyYWlub21peCBrbm93cyBvciBzdXNwZWN0cyB0aGF0IGFueSBIb3NwaXRhbCBEYXRhIDQuMy4zIEJyYWlub21peCB2w60gbmVibyBtw6EgcG9kZXrFmWVuw60sIMW+ZSBuxJtrdGVyw6kgw5pkYWplCm9yIGFueSBIb3NwaXRhbCBSZXN1bHQgaW5mcmluZ2VzIHRoZSBJbnRlbGxlY3R1YWwgTmVtb2NuaWNlIG5lYm8gVsO9c2xlZGt5IE5lbW9jbmljZSBwb3J1xaF1asOtIHByYXZhClByb3BlcnR5IFJpZ2h0cyBvciBvdGhlciByaWdodHMgb2YgYW55IHRoaXJkIHBhcnR5LCBvciBkdcWhZXZuw61obyB2bGFzdG5pY3R2w60gbmVibyBqaW7DoSBwcmF2YSB0xZlldMOtY2ggb3NvYiBuZWJvCmFyZSBpbiBhbnkgd2F5IHVufGF3ZnV8LiBqc291IGpha2tvbGkgdiByb3pwb3J1IHMgcHLDoXZuw61taSBwxZllZHBpc3kuCjUuIEluc3RhbGxhdGlvbiwgQ29uZmlndXJhdGlvbiBhbmQgVHJhaW5pbmcgNS4gSW5zdGFsYWNlLCBrb25maWd1cmFjZSBhIMWha29sZW7DrQpCcmFpbm9taXggd2lsbCBpbnN0YWxsIGFuZCBjb25maWd1cmUgdGhlIFNvZnR3YXJlIGl0c2VsZiBvciBTcG9sZcSNbm9zdCBCcmFpbm9taXggcHJvdmVkZSBpbnN0YWxhY2kgYSBrb25maWd1cmFjaSBTb2Z0d2FydQp1c2luZyBhIHRoaXJkIHBhcnR5IHN1YmplY3QgdG8gdGhlIHNhbWUgY29uZnJkZW50aWFsaXR5IHNhbWEgbmVibyBwcm9zdMWZZWRuaWN0dsOtbSB0xZlldMOtaG8gc3ViamVrdHUgdsOhemFuw6lobyBzdGVqbm91Cm9ibGlnYXRpb3MgYXMgQnJhaW5vbWl4LiBCcmFpbm9taXggd2lsbCBwcm92aWRlIHRoZSBIb3NwaXRhbCBwb3Zpbm5vc3TDrSB6YWNob3ZhbsOtIGTFr3bEm3Jub3N0aSDDumRhasWvLCBqYWtvIEJyYWlub21peC4Kd2l0aCB0cmFpbmluZyBpbiB0aGUgdXNlIG9mIHRoZSBTb2Z0d2FyZSBhbmQgdGhlIFNlcnZpY2UgYXMgQnJhaW5vbWl4IHBvc2t5dG5lIE5lbW9jbmljaSDFoWtvbGVuw60gdiB1xb7DrXbDoW7DrSBTb2Z0d2FydSBhCnNldCBvdXQgaW4gQXBwZW5kaXggMS4gU2x1xb5ieSB0YWssIGphayBqZSB1dmVkZW5vdiBwxZnDrWxvemUgxI0uIDEgdMOpdG8gU21sb3V2eS4KNi4gb2JsaWdhdGlvbnMgb2YgdGhlIFBhcnRpZXMgNi4gUG92aW5ub3N0aSBzbWx1dm7DrWNoIHN0cmFuCjYuMS4gVGhlIEhvc3BpdGFsIHdpbGwgZW5zdXJlIHRoYXQgYXx8IGVxdWlwbWVudCwgZGV2aWNlcywgdGhpcmQgNi4xIE5lbW9jbmljZSB6YWppc3TDrSwgYWJ5IHZlxaFrZXLDqSB2eWJhdmVuw60sIHphxZnDrXplbsOtLCBzb2Z0d2FyZQpwYXJ0eSBzb2Z0d2FyZSwgdGVsZWNvbW11bmljYXRpb25zIGZhY2lsaXRpZXMgYW5kIG5ldHdvcmsgdMWZZXTDrWNoIHN0cmFuLCB0ZWxla29tdW5pa2HEjW7DrSB6YcWZw616ZW7DrSBhIHPDrcWlb3bDqSBzeXN0w6lteSwga3RlcsOpCnN5c3RlbXMgdGhhdCB0aGUgSG9zcGl0YWwgbmVlZHMgaW4gb3JkZXIgdG8gYWxsb3cgdGhlIHBvdMWZZWJ1amUga3RvbXUsYWJ5c2FtYSBuZWJvamVqw61vcHJhdm7Em27DrVXFvml2YXRlbMOpIG1vaGxpCkhvc3BpdGFsIGFuZCBpdHMgYXV0aG9yaXNlZCBVc2VycyB0byB1c2UgdGhlIFNvZnR3YXJlIG9yIGFueSB1xb7DrXZhdCBTb2Z0d2FyZSBuZWJvIG7Em2t0ZXJvdSBTbHXFvmJ1LCBieWx5IGluc3RhbG92w6FueSBhIHBsbsSbCm9mIHRoZSBTZXJ2aWNlcyBhcmUgaW5zdGFsbGVkIGFuZCBmdWxseSBvcGVyYXRpb25hbCBiZWZvcmUgenByb3Zvem7Em255IHDFmWVkdMOtbSwgbmXFviBCcmFpbm9taXggcG9za3l0bmUgU29mdHdhcmUgYQpCcmFpbm9taXggcHJvdmlkZXMgdGhlIFNvZnR3YXJlIGFuZCB0aGF0IFNlcnZpY2UuIFRoZSBwxZnDrXNsdcWhbm91IFNsdcW+YnUuIE5lbW9jbmljZSBvZHBvdsOtZMOhIHphIHphdmVkZW7DrQpIb3NwaXRhbCBpcyByZXNwb25zaWJsZSBmb3IgaW1wbGVtZW50aW5nIHN1ZmZyY2llbnQgc2VjdXJpdHkgZG9zdGF0ZcSNbsO9Y2ggYmV6cGXEjW5vc3Ruw61jaCBvcGF0xZllbsOtIGsgemFiZXpwZcSNZW7DrSB2w73FoWUKbWVhc3VyZXMgdG8gZW5zdXJlIHRoZSBzZWN1cml0eSBvZiBzdWNoIGVxdWlwbWVudCwgdXZlZGVuw6lobyB2eWJhdmVuw60sIHphxZnDrXplbsOtLCBzb2Z0d2FydSB0xZlldMOtY2ggc3RyYW4sCmRldmljZXMsIHRoaXJkIHBhcnR5IHNvZnR3YXJlLCB0ZWxlY29tbXVuaWNhdGlvbnMgZmFjaWxpdGllcyB0ZWxla29tdW5pa2HEjW7DrWNoIHphxZnDrXplbsOtIGEgc8OtxaVvdsO9Y2ggc3lzdMOpbcWvIGEgZGF0LCBrdGVyw6EgbmEKYW5kIG5ldHdvcmsgc3lzdGVtcyBhbmQgdGhlIGRhdGEgaGV8ZCBvbiBvciB0cmFuc2ZlcnJlZCBuaWNoIGJ1ZG91IHVsb8W+ZW5hIG5lYm8gcMWZZXMgbsSbIGJ1ZG91IHDFmWVuw6HFoWVuYS4KdGhyb3VnaCB0aGVtLgo2LjIuIFRoZSBIb3NwaXRhbCB3aWxsIGVuc3VyZSB0aGF0IHRoZSBTb2Z0d2FyZSBpcyBvcGVyYXRlZCBvbmx5IDYuMiBOZW1vY25pY2UgemFqaXN0w60sIGFieSBTb2Z0d2FyZSBwcm92b3pvdmFsIHbDvWhyYWRuxJsgxZlhZG7EmwoKYnkgYWRlcXVhdGVseSB0cmFpbmVkIGFuZCBxdWFsaWZpZWQgc3RhZmYgaW4gYWNjb3JkYW5jZSB3aXRoCnRoZSB1c2VyIGRvY3VtZW50YXRpb24gcHJvdmlkZWQgYnkgQnJhaW5vbWl4LgoKdnnFoWtvbGVuw70gYSBrdmFsaWZpa292YW7DvSBwZXJzb27DoWwsIGt0ZXLDvSBzZSBwxZlpdG9tIGJ1ZGUgxZnDrWRpdAp1xb5pdmF0ZWxza291IGRva3VtZW50YWPDrSBkb2Rhbm91IHNwb2xlxI1ub3N0w60gQnJhaW5vbWl4LgoKIAoKIAoKIAoKIAoKIAoKQnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRDAyLCBYMzYxIElyZWxhbmQKCiAKCjYuMy4KClRoZSBIb3NwaXRhbCB3aXx8IHRha2UgYXBwcm9wcmlhdGUgc3RlcHMgdG8gZW5zdXJlIHRoYXQgbm8KTWFsd2FyZSBpcyBpbnRyb2R1Y2VkIGludG8gdGhlIFNvZnR3YXJlIG9yIHRoZSBTZXJ2aWNlLiBUaGUKSG9zcGl0YWwgd2l8fCBrZWVwIGF8fCBlcXVpcG1lbnQsIGNvbm5lY3Rpb25zLCBwZXJpcGhlcmFscywKc29mdHdhcmUsIHRlfGVjb21tdW5pY2F0aW9ucyBzeXN0ZW1zIGFuZCBuZXR3b3JrCmNvbm5lY3Rpb25zIGZyZWUgZnJvbSBhbnkgTWFsd2FyZSBhbmQgdXNlIHVwIHRvIGRhdGUgYW5kCmFkZXF1YXRlIGFudGlydmlydXMgc29mdHdhcmUgYW5kIGZpcmV3YWxscyBhbmQgd2lsbAppbXBsZW1lbnQgcmVhc29uYWJsZSBzZWN1cml0eSBwYXRjaGVzLCB1cGdyYWRlcywgdXBkYXRlcywKcmV2aXNpb25zLCB2ZXJzaW9ucywgZXJyb3IgY29ycmVjdGlvbnMgYW5kIG1vZGlmaWNhdGlvbnMgdG8KYXZlcnQgb3IgcmVtZWR5IHRoZSBlZmZlY3RzIG9mIGFueSBNYWx3YXJlIGFzIHNvb24gYXMKcmVhc29uYWJseSBwb3NzaWJsZS4KCjYuMwoKTmVtb2NuaWNlIHDFmWlqbWUgdmhvZG5hIHByZXZlbnRpdm7DrSBvcGF0xZllbsOtIHByb3RpIHphdmxlxI1lbsOtCsWga29kbGl2w6lobyBzb2Z0d2FydSBkbyBTb2Z0d2FydSBuZWJvIGRvIFNsdcW+YnkuIE5lbW9jbmljZQpidWRlIGRiYXQsIGFieSBzZSB2IHphxZnDrXplbsOtY2gsIHDFmWlwb2plbsOtY2gsIHBlcmlmZXJpw61jaCwgc29mdHdhcnUsCnRlbGVrb211bmlrYcSNbsOtY2ggc3lzdMOpbWVjaCBhIHPDrcWlb3bDvWNoIHDFmWlwb2plbsOtY2ggbmV2eXNreXRsCsWga29kbGl2w70gc29mdHdhcmUsIGJ1ZGUgcG91xb7DrXZhdCBha3R1YWxpem92YW7DvSwgdmhvZG7DvQphbnRpdmlyb3bDvSBzb2Z0d2FyZSBhIGZpcmV3YWxseSBhIGJ1ZGUgY28gbmVqZMWZw612ZSwgamFrbWlsZSB0bwpidWRlIHByYWt0aWNreSBwcm92ZWRpdGVsbsOpLCBpbXBsZW1lbnRvdmF0IHDFmWltxJvFmWVuw6kKYmV6cGXEjW5vc3Ruw60gesOhcGxhdHksIHZ5bGVwxaFlbsOpIHZlcnplLCBha3R1YWxpemFjZSwgcmV2aXplLCBub3bDqQp2ZXJ6ZSwgb3ByYXZ5IGNoeWIgYSDDunByYXZ5LCBqZSBoxb4gw7rEjWVsZW0gYnVkZSBvZHZyYXRpdCBuZWJvCm5hcHJhdml0IG5hc2xlZGt5IHDFr3NvYmVuw60gxaBrb2RsaXbDqWhvIHNvZnR3YXJ1LgoKIAoKNi40LgoKSWYgZGlzcG9zaW5nIG9mIG9yIGRlY29tbWlzc2lvbmluZyBhbnkgaGFyZHdhcmUgb3IgZGV2aWNlIG9uCndoaWNoIHRoZSBTb2Z0d2FyZSBoYXMgYmVlbiBpbnN0YWxsZWQsIHRoZSBIb3NwaXRhbCB3aXx8CmVuc3VyZSB0aGF0IGF8fCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlIGhhdmUgYmVlbiBkZXxldGVkCmZyb20gdGhhdCBoYXJkd2FyZSBvciBkZXZpY2UgYmVmb3JlIHNlbGxpbmcgb3IgZGlzcG9zaW5nIG9mIGl0LgoKNi40CgpQxZlpIHDFmcOtcGFkbsOpIGxpa3ZpZGFjaSBuZWJvIHZ5xZlhemVuw60gaGFyZHdhcnUgbmVibyB6YcWZw616ZW7DrSwgbmEKbsSbbcW+IGJ5bCBpbnN0YWxvdsOhbiBTb2Z0d2FyZSwgTmVtb2NuaWNlIHphamlzdMOtLCBhYnkgeiBkYW7DqWhvCmhhcmR3YXJ1IHDFmWVkIGplaG8gcHJvZGVqZW0gbmVibyBsaWt2aWRhY8OtIGJ5bHkgdnltYXrDoW55CnbFoWVjaCBueSBrb3BpZSBTb2Z0d2FydS4KCiAKCjYuNS4KClRoZSBIb3NwaXRhbCBoYXMgYSBkdXR5IHRvIGFzc2lzdCBpbiBlbnN1cmluZyB0aGUgU2VydmljZSBpcwpzdWNjZXNzZnVsLCB3aGljaCBpbiBwYXJ0aWN1bGFyIG1lYW5zIHByb3ZpZGluZyBCcmFpbm9taXgKZnJlZSBvZiBjaGFyZ2Ugd2l0aCBhbGwgaW5mb3JtYXRpb24sIHNvZnR3YXJlLCBtYXRlcmlhbHMsCnRlY2huaWNhbCBkb2N1bWVudHMsIHJlc291cmNlcyBhbmQgZmFjaWxpdGllcyB3aGljaApCcmFpbm9taXggbWF5IHJlYXNvbmFibHkgcmVxdWlyZSwgc28gdGhhdCBCcmFpbm9taXggY2FuCmZ1bGZpbGwgaXRzIG9ibGlnYXRpb25zIGFuZCBwcm92aWRlIHRoZSBTb2Z0d2FyZSBhbmQgdGhlClNlcnZpY2UgdG8gdGhlIEhvc3BpdGFsIGluIHRoZSBuZWNlc3NhcnkgZXh0ZW50IFRoZSBIb3NwaXRhbAp3aXx8IGVuc3VyZSB0aGF0IGl0cyBzdGFmZiwgY29udHJhY3RvcnMgYW5kIG90aGVyIHN1cHBsaWVycwpjb29wZXJhdGUgZnVsbHkgd2l0aCBCcmFpbm9taXggaW4gZGlhZ25vc2luZyBwcm9ibGVtcyBpbgpjb25uZWN0aW9uIHdpdGggdGhlIHVzZSBvZiB0aGUgU29mdHdhcmUgb3IgdGhlIFNlcnZpY2UgKG9yCmJvdGgpIGFuZCBkbyBub3QgY2F1c2UgYW55IGRlbGF5LiBJZiBCcmFpbm9taXggbmVlZHMgdGhlCkhvc3BpdGFsIHRvIGNvb3BlcmF0ZSBpbiB0aGlzIGNvbnRleHQsIHRoZSBIb3NwaXRhbCB3aXx8IGRvIHNvCmltbWVkaWF0ZWx5IHRvIHByZXZlbnQgYW55IGRlbGF5LgoKNi41CgpOZW1vY25pY2UgamUgcG92aW5uYSBwb3NreXRub3V0IHNvdcSNaW5ub3N0IHDFmWkgemFqacWhxaVvdsOhbsOtCsO6c3DEm8WhbsOpaG8gcHLFr2LEm2h1IFNsdcW+YnksIMSNw61txb4gc2UgemVqbS4gcm96dW3DrSBiZXpwbGF0bsOpCnBvc2t5dG51dMOtIHZlxaFrZXLDvWNoIGluZm9ybWFjw60sIHNvZnR3YXJlLCBtYXRlcmlhbHUsIHRlY2huaWNrw6kKZG9rdW1lbnRhY2UsIHpkcm9qxa8gYSB6YcWZw616ZW7DrSwga3RlcsOpIGJ1ZGUgc3BvbGXEjW5vc3QgQnJhaW5vbWl4CmTFr3ZvZG7EmyBwb8W+YWRvdmF0LCB0YWsgYWJ5IG1vaGwgQnJhaW5vbWl4IHNwbG5pdCBzdsOpIHrDoXZhemt5IGEKcG9za3l0bm91dCBOZW1vY25pY2kgU29mdHdhcmUgYSBTbHXFvmJ1LiBOZW1vY25pY2UgemFqaXN0w60sIGFieQpqZWrDrSBwZXJzb25hbCwgZXh0ZXJuw60gcHJhY292bsOtY2kgYSBvc3RhdG7DrSBkb2RhdmF0ZWzDqSBwb3NreXRsaQpzcG9sZcSNbm9zdGkgQnJhaW5vbWl4IHBsbm91IHNvdcSNaW5ub3N0IHDFmWkgZGlhZ25vc3Rpa292YW7DrQpwcm9ibMOpbcWvIHNwb2plbsO9Y2ggcyB1xb7DrXbDoW7DrW0gU29mdHdhcnUgbmVibyBTbHXFvmJ5IChuZWJvCm9ib3UpIGEgYWJ5IG5lenDFr3NvYm92YWxpIHpwb8W+ZMSbbsOtLiBQb8W+YWRhcmxpIEJyYWlub21peApOZW1vY25pY2kgbyBzb3XEjWlubm9zdCwgTmVtb2NuaWNlIHRhayBuZXByb2RsZW7EmyB1xI1pbsOtLCBhYnkKbmVkb2Now6F6ZWxvIGtlIHpwb8W+ZMSbbsOtbS4KCiAKCjYuNi4KClRoZSBIb3NwaXRhbCB3aXx8IG5vbWluYXRlIGEgcmVwcmVzZW50YXRpdmUgYW5kIGEgZGVwdXR5IGZvcgpldmVyeSBTaXRlIHdoZXJlIHRoZSBTb2Z0d2FyZSBpcyBpbnN0YWxsZWQsIHRvIGFjdCBhcyBhCmNvbXBldGVudCBwb2ludCBvZiBjb250YWN0IGZvciBCcmFpbm9taXggaW4gY29ubmVjdGlvbiB3aXRoCnRoZSBTb2Z0d2FyZSBhbmQgdGhlIFNlcnZpY2VzIGFuZCB3aWxsIGltbWVkaWF0ZWx5IGdpdmUKQnJhaW5vbWl4IG5vdGljZSBvZiBhbnkgY2hhbmdlcyB0byB0aG9zZSBpbmRpdmlkdWFscyBvciB0aGVpcgpjb250YWN0IGRldGFpbHMuCgpUaGUgY29udGFjdCBwZXJzb24gb2YgdGhlIEhvc3BpdGFsIGlzCgp0ZXw6IG1vYjogZXJtYWlsOgoKNi42CgpOZW1vY25pY2UgdXLEjcOtIHN2w6lobyB6w6FzdHVwY2UgemEga2HFvmTDqSBQcmFjb3ZpxaF0xJssIG5hIGt0ZXLDqW0KYnVkZSBTb2Z0d2FyZSBpbnN0YWxvdmFuLCBhIGplaG8gesOhc3R1cGNlLCBrdGXFmcOtIGJ1ZG91IHbFr8SNaQpzcG9sZcSNbm9zdGkgQnJhaW5vbWl4IHYgesOhbGXFvml0b3N0ZWNoIFNvZnR3YXJ1IGEgU2x1xb5lYiBqZWRuYXQKamFrbyBrb21wZXRlbnRuw60ga29udGFrdG7DrSBvc29iYSwgYSBidWRlIHNwb2xlxI1ub3N0IEJyYWlub21peApuZXByb2RsZW7EmyBpbmZvcm1vdmF0IG8ga2HFvmTDqSB6bcSbbsSbIHRha3RvIHVyxI1lbsO9Y2ggb3NvYiBuZWJvCmplamljaCBrb250YWt0bsOtY2ggw7pkYWrFry4KCktvbnRha3Ruw60gb3NvYm91IE5lbW9jbmljZSBqZToKCnRlfDogbW9iOgplcm1haWw6CgogCgo2LjcKCkJyYWlub21peCBpcyByZXNwb25zaWJsZSBmb3IgZW5zdXJpbmcgdGhhdCB0aGUgU29mdHdhcmUsClNlcnZpY2UgYW5kIFNlcnZpY2VzIGFyZSBmdWxseSBmdW5jdGlvbmFsIGFuZCBlbGlnaWJsZSBmb3IKaW5zdGFsbGF0aW9uIG9uIHRoZSBIb3NwaXRhbCdzIGluZnJhc3RydWN0dXJlLiBCcmFpbm9taXgKZGVjbGFyZXMgdGhhdCBpdCBpcyBhdXRob3JpemVkIHRvIGdyYW50IGFuIEFjY2VzcyB0byBTZXJ2aWNlIHRvCnRoZSBIb3NwaXRhbCBmb3IgdGhlIHB1cnBvc2VzIG9mIHRoaXMgQWdyZWVtZW50IGFuZCB0aGUKaW5zdGFsbGF0aW9uIG9mIHRoZSBBY2Nlc3MgdG8gU2VydmljZSwgcHJvdmlzaW9uIG9mIHRoZQpTZXJ2aWNlcyBhbmQgdGhlIFNlcnZpY2Ugd2lsbCBub3QgaW5mcmluZ2UgdGhlIHJpZ2h0cyBvZiBhbnkKdGhpcmQgcGFydHkKCjYuNy4KCkJyYWlub21peCBvZHBvdsOtZMOhIHphIHRvLCDFvmUgU29mdHdhcmUsIFNsdcW+YmEgYSBTbHXFvmJ5anNvdSBwbG7EmwpmdW5rxI1uw60gYSB6cMWvc29iaWzDqSBrIHBvdcW+aXTDrSBkbGUgdMOpdG8gU21sb3V2eS4gQnJhaW5vbWl4CnByb2hsYcWhdWplLCDFvmUgamUgb3Byw6F2bsSbbiB1ZMSbbGl0IE5lbW9jbmljaSBQxZnDrXN0dXAga2UgU2x1xb5ixJsgcHJvCsO6xI1lbHkgdMOpdG8gU21sb3V2eSBhIGluc3RhbGFjw60gUMWZw61zdHVwdSBrZSBTbHXFvmLEmywgcG9za3l0bnV0w61tClNsdcW+ZWIgYSBTbHXFvmJ5IG5lZG9qZGUgayBuZW9wcsOhdm7Em27DqW11IHrDoXNhaHUgZG8gcHJhdiB0xZlldMOtY2gKb3NvYi4KCiAKCjYuOAoKSWYgYSBkZWZlY3Qgb2NjdXJzIGR1cmluZyB0aGUgcGVyaW9kIG9mIG5vcm1hbCB1c2Ugb2YgdGhlClNvZnR3YXJlICwgQnJhaW5vbWl4IHdpfHwgdXNlIGl0cyBiZXN0IGVmZm9ydHMgdG8gcmVtZWR5IHRoZQpkZWZlY3QgYW5kIHRoZSBIb3NwaXRhbCB3aXx8IHByb3ZpZGUgYXx8IG5lY2Vzc2FyeSBhc3Npc3RhbmNlLgoKNi44LgoKVnlza3l0bmVybGkgc2UgcG8gZG9idSDFmcOhZG7DqWhvIHXFvsOtdmFuw60gU29mdHdhcnUgdmFkYSwgQnJhaW5vbWl4CnZ5bmFsb8W+w60gdmXFoWtlcsOpIMO6c2lsw60gayBqZWrDrW11IG9kc3RyYW7Em27DrSBhIE5lbW9jbmljZSBtdQpwb3NreXRuZSB2ZcWha2Vyb3UgcG90xZllYm5vdSBzb3XEjWlubm9zdC4KCiAKCjYuOQoKQnJhaW5vbWl4IHNoYWxsIGVuc3VyZSB0aGF0IGl0cyBwZXJzb25uZWwsIGV4dGVybmFsIHBlcnNvbm5lbAphbmQgb3RoZXIgc3VwcGxpZXJzIHByb3ZpZGUgZnV8fCBjb29wZXJhdGlvbiB0byB0aGUgSG9zcGl0YWwKaW4gZGlhZ25vc2luZyBwcm9ibGVtcyBhc3NvY2lhdGVkIHdpdGggdGhlIHVzZSBvZiB0aGUKU29mdHdhcmUgb3IgdGhlIFNlcnZpY2UgKG9yIGJvdGgpIGFuZCBkbyBub3QgY2F1c2UgZGVsYXlzLiBJZgpIb3NwaXRhbCByZXF1ZXN0cyBhc3Npc3RhbmNlIGZyb20gQnJhaW5vbWl4LCBCcmFpbm9taXgKc2hhbGwgcHJvbXB0bHkgZG8gc28gdG8gYXZvaWQgZGVsYXlzLgoKNi45LgoKU3BvbGXEjW5vc3QgQnJhaW5vbWl4IHphamlzdMOtLCBhYnkgamVqw60gcGVyc29uYWwsIGV4dGVybsOtIHByYWNvdm7DrWNpCmEgb3N0YXRuw60gZG9kYXZhdGVsw6kgcG9za3l0bGkgTmVtb2NuaWNpIHBsbm91IHNvdcSNaW5ub3N0IHDFmWkKZGlhZ25vc3Rpa292YW7DrSBwcm9ibMOpbcWvIHNwb2plbsO9Y2ggcyB1xb7DrXbDoW7DrW0gU29mdHdhcnUgbmVibwpTbHXFvmJ5IChuZWJvIG9ib3UpIGEgYWJ5IG5lenDFr3NvYm92YWxpIHpwb8W+ZMSbbsOtLiBQb8W+YWRhcmxpCk5lbW9jbmljZSBCcmFpbm9taXggbyBzb3XEjWlubm9zdCwgQnJhaW5vbWl4IHRhayBuZXByb2RsZW7Emwp1xI1pbsOtLCBhYnkgbmVkb2Now6F6ZWxvIGtlIHpwb8W+ZMSbbsOtbS4KCiAKClNlbWljZSBBdmFpbGFiaWxpdHkgYW5kIFN1cHBvcnQKCkRvc3R1cG5vc3Qgc2x1xb5ieSBhIHBvZHBvcmEKCiAKCiAKCjcuMQoKU3ViamVjdCB0byBjbGF1c2UgNC4zIGFib3ZlLCBCcmFpbm9taXggdW5kZXJ0YWtlcyB0byBtYWtlCnRoZSBTZXJ2aWNlIGF2YWlsYWJsZSBpbiBhY2NvcmRhbmNlIHdpdGggQXBwZW5kaXggMyBkdXJpbmcKCiAKCjcuMQoKUyB2w71qaW1rb3UgcMWZw61wYWTFryB1dmVkZW7DvWNoIHYgxI18LjQuMyB0w6l0byBTbWxvdXZ5IHNlCnNwb2xlxI1ub3N0IEJyYWlub21peCB6YXZhenVqZSB6YWppc3RpdCBkb3N0dXBub3N0IFNsdcW+YnkgcG9kbGUKCiAKCiAKCkJyYWlub21peCBFdXJvcGUgTGltaXRlZApTdWl0ZSAxMDM4MAoKMjYvMjcgVXBwZXIgUGVtYnJva2UgU3RyZWV0CkR1YmxpbiAyIEQwMiwgWDM2MSBJcmVsYW5kCgogCgp0aGUgUmVsZXZhbnQgUGVyaW9kIChzdWJqZWN0IHRvIHRlcm1pbmF0aW9uIHVuZGVyIGNsYXVzZSAzLjQKYWJvdmUgb3IgMTIuMiBvciAxNS40IGJlbG93KSBleGNlcHQgKHRvIHRoZSBleHRlbnQgbmVjZXNzYXJ5CmFuZCBhZnRlciBwcmlvciB0aW1lbHkgbm90aWZpY2F0aW9uIHRvIHRoZSBIb3NwaXRhbCkgd2hlbiB0aGUKcmVwYWlyLCB1cGdyYWRlIG9yIG1haW50ZW5hbmNlIG9mIGFueSBzeXN0ZW0gdXNlZCBieQpCcmFpbm9taXggb3IgaXRzIHNlcnZpY2UgcHJvdmlkZXJzIHRvIHByb3ZpZGUgdGhlIFNlcnZpY2VzCihpbmNsdWRpbmcsIHdpdGhvdXQgbGltaXRhdGlvbiwgYW55IHRlbGVjb21tdW5pY2F0aW9ucwpmYWNpbGl0eSBhbmQgbmV0d29yayBzeXN0ZW0pIGlzIGJlaW5nIGNhcnJpZWQgb3V0LCBvciB3aGVuCmFueSB1cGRhdGUsIHNlY3VyaXR5IHBhdGNoLCB1cGdyYWRlLCByZXZpc2lvbiwgbmV3IHZlcnNpb24sCmVycm9yIGNvcnJlY3Rpb24gb3IgbW9kaWZyY2F0aW9uIHRvIGFueSBzb2Z0d2FyZSB1c2VkIGJ5CkJyYWlub21peCBvciBpdHMgc2VydmljZSBwcm92aWRlcnMgdG8gcHJvdmlkZSB0aGUgU2VydmljZXMgaXMKYmVpbmcgaW1wbGVtZW50ZWQgb3IgdGVzdGVkLgoKcMWZw61sb2h5IMSNLiAzIGt0w6l0byBTbWxvdXbEmyBwbyBjZWzDqSBSb3pob2Ruw6kgb2Jkb2LDrSAocMWZacSNZW3FvgpwbGF0w60gbW/Fvm5vc3QgdWtvbsSNZW7DrSBwb2RsZSDEjWwuIDMuNCBuZWJvIMSNbC4gMTIuMiDEjWkgMTUuNCB0w6l0bwpTbWxvdXZ5KSwgcyB2w71qaW1rb3UgcMWZw61wYWTFryAodiBuZXpieXRuw6ltIHJvenNhaHUgYSBwbwpwxZllZGNob3rDrW0gdsSNYXNuw6ltIHZ5cm96dW3Em27DrSBOZW1vY25pY2UpLCBrZHkgamUgcHJvdsOhZMSbbmEKb3ByYXZhLCBha3R1YWxpemFjZSBuZWJvIMO6ZHLFvmJhIGpha8OpaG9rb2xpIHN5c3TDqW11LCBrdGVyw70KQnJhaW5vbWl4IG5lYm8gamVqw60gcG9kZG9kYXZhdGVsw6kgcG91xb7DrXZhasOtIGtwb3NreXRvdmFuw60KU2x1xb5lYiAodMO9a8OhIHNlIHplam3DqW5hIHRlbGVrb211bmlrYcSNbsOtY2ggemHFmcOtemVuw60gYSBzw63FpW92w71jaApzeXN0w6ltxa8pLCBuZWJvIHDFmcOtcGFkxa8sIGtkeSBwcm9iw61oYSBpbXBsZW1lbnRhY2UgbmVibwp0ZXN0b3ZhbsOtIGpha8Opa29saSBha3R1YWxpemFjZSwgYmV6cGXEjW5vc3Ruw60gesOhcGxhdHksIHZ5bGVwxaFlbsOpCnZlcnplLCByZXZpemUsIG5vdsOpIHZlcnplLCBvcHJhdnkgY2h5YiBuZWJvIG1vZGlmaWthY2Ugc29mdHdhcnUKdcW+w612YW7DqWhvIHNwb2xlxI1ub3N0w60gQnJhaW5vbWl4IG5lYm8gamVqw61taSBwb2Rkb2RhdmF0ZWxpIGsKcG9za3l0b3ZhbsOtU0l1xb5lYi4KCiAKCjcuMgoKQnJhaW5vbWl4IHdpbGwgcHJvdmlkZSB0aGUgU3VwcG9ydCBTZXJ2aWNlcyB0byB0aGUgSG9zcGl0YWwKaW4gYWNjb3JkYW5jZSB3aXRoIEFwcGVuZGl4IDMuCgo3LjIKCkJyYWlub21peCBqZSBwb3ZpbmVuIE5lbW9jbmljaSBwb3NreXRvdmF0IFNsdcW+YnkgcG9kcG9yeQp2IHNvdWxhZHUgcyBwxZnDrWxvaG91IMSNLiAzIGt0w6l0byBTbWxvdXbEmy4KCiAKCjcuMwoKVGhlIEhvc3BpdGFsIHdpbGwgbWFrZSBhfHwgcmVxdWVzdHMgZm9yIHRoZSBTdXBwb3J0IFNlcnZpY2VzCmluIGFjY29yZGFuY2Ugd2l0aCBBcHBlbmRpeCAzIGFuZCB3aWxsIGNvbXBseSB3aXRoIGl0cwpvYmxpZ2F0aW9ucyBzZXQgb3V0IGluIEFwcGVuZGl4IDMuIFRoZSBCcmFpbm9taXggaGVscGRlc2sKd2lsbCBwcm92aWRlIHRoZSBIb3NwaXRhbCB3aXRoIGFuIGluY2lkZW50IG51bWJlciB3aGljaApwcm92aWRlcyBhIHJlY29yZCBvZnRoZSByZXF1ZXN0IGZvciB0aGVTdXBwb3J0IFNlcnZpY2VzLgoKNy4zCgpOZW1vY25pY2UgYnVkZSBwb8W+YWRhdmt5IG5hIHBvc2t5dG51dMOtIFNsdcW+ZWIgcG9kcG9yeQpwb2TDoXZhdCB2IHNvdWxhZHUgcyBwxZnDrWxvaG91IMSNLiAzIGt0w6l0byBTbWxvdXbEmyBhIGJ1ZGUgcGxuaXQgc3bDqQp6w6F2YXpreSBzdGFub3ZlbsOpIHYgcMWZw61sb3plIMSNLiAzIGt0w6l0byBTbWxvdXbEmy4gU3TFmWVkaXNrbwpwb2Rwb3J5IHNwb2xlxI1ub3N0aSBCcmFpbm9taXggb3puw6Ftw60gTmVtb2NuaWNpIMSNw61zbG8KaW5jaWRlbnR1LCBrdGVyw6kgYnVkZSBzbG91xb5pdCBqYWtvIHrDoXpuYW0gbyDFvsOhZG9zdGkgbyBwb3NreXRudXTDrQpTbHXFvmViIHBvZHBvcnkuCgogCgpJbnRlbGxlY3R1YWwgUHJvcGVydHkgUmlnaHRzCgpQcsOhdmEgZHXFoWV2bnJobyB2bGFzdG5pY3R2w60KCiAKCjguMQoKVGhlIEhvc3BpdGFsIGlzIGdyYW50ZWQgbm8gbGljZW5jZSBvciBhbnkgSW50ZWxsZWN0dWFsClByb3BlcnR5IFJpZ2h0cyBpbiByZWxhdGlvbiB0byB0aGUgU29mdHdhcmUgb3IgdGhlIFNlcnZpY2VzCmV4Y2VwdCBmb3IgdGhlIHJpZ2h0IGZvciB0aGUgSG9zcGl0YWwgdG8gdXNlIHRoZSBTb2Z0d2FyZQphbmQgdGhlIFNlcnZpY2UgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBBZ3JlZW1lbnQuCgo4LjEKCk5lbW9jbmljZSBuZXrDrXNrYXZhIHZlIHZ6dGFodSBrIFNvZnR3YXJ1IG5lYm8gU2x1xb5iYW0Kxb5hZG5vdSBsaWNlbmNpIGFuaSDFvsOhZG7DoSBwcsOhdmEgZHXFoWV2bsOtaG8gdmxhc3RuaWN0dsOtLCBrcm9txJsKcHJhdmEgdcW+w612YXQgU29mdHdhcmUgYSBTbHXFvmJ1IHYgc291bGFkdSBzZSBTbWxvdXZvdS4KCiAKCjguMgoKOC4zCgpUaGUgSG9zcGl0YWwgd2lsbCBvd24gYXx8IEludGVsbGVjdHVhbCBQcm9wZXJ0eSBSaWdodHMgaW4gdGhlCkhvc3BpdGFsIERhdGEuIFRoZSBIb3NwaXRhbCBpcyB0aGUgc29sZSBvd25lciBvZiBhbGwgSG9zcGl0YWwKUmVzdWx0cyBnZW5lcmF0ZWQgYXMgYSByZXN1bHQgb2YgdXNpbmcgdGhlIFNlcnZpY2UuCkJyYWlub21peCBkb2VzIG5vdCBhY3F1aXJlIGFueSBvd25lcnNoaXAgb3IgbGljZW5zaW5nCnJpZ2h0cyB0byB0aGVzZSBIb3NwaXRhbCBSZXN1bHRzLCB3aXRoIHRoZSBleGNlcHRpb24gb2YgYQpub25yZXhjbHVzaXZlLCB0aW1lcmxpbWl0ZWQsIGFuZCB0ZWNobmljYWxseSBuZWNlc3NhcnkKYXV0aG9yaXphdGlvbiB0byBwcm9jZXNzIHRoZW0gc29sZWx5IGZvciB0aGUgcHVycG9zZSBvZgpwcm92aWRpbmd0aGUgU2VydmljZSB1bmRlciB0aGlzIEFncmVlbWVudC4KCjguMgoKTmVtb2NuaWNpIG5hbGXFvmVqw60gdsWhZWNobmEgcHLDoXZhIGR1xaFldm7DrWhvIHZsYXN0bmljdHbDrSBrCsOaZGFqxa9tIE5lbW9jbmljZS4gTmVtb2NuaWNlIGplIHbDvWx1xI1uw71tIHZsYXN0bsOta2VtIHbFoWVjaApWw71zbGVka8WvIE5lbW9jbmljZSB2em5pa2zDvWNoIHYgZMWvc2xlZGt1IHZ5dcW+w612YW7DrSBTbHXFvmJ5LgpCcmFpbm9taXggayB0xJttdG8gdsO9c2xlZGvFr20gTmVtb2NuaWNlIG5lesOtc2thdmEgxb5hZG5hCnZsYXN0bmlja8OhIGFuaSBsaWNlbsSNbsOtIHByw6F2YSwgcyB2w71qaW1rb3UgbmV2w71ocmFkbsOtaG8sIMSNYXNvdsSbCm9tZXplbsOpaG8gYSB0ZWNobmlja3kgbmV6Ynl0bsOpaG8gb3Byw6F2bsSbbsOtIGsgamVqaWNoCnpwcmFjb3bDoW7DrSB2w71sdcSNbsSbIHphIMO6xI1lbGVtIHBvc2t5dG92YW7DrSBTbHXFvmJ5IHBvZGxlIHTDqXRvClNtbG91dnkuCgogCgpIb3NwaXRhbCBEYXRhCgrDmmRhamUgTmVtb2NuaWNlCgogCgo5LjEKCkJyYWlub21peCBpcyBub3QgcmVzcG9uc2libGUgZm9yIHRoZSBjb250ZW50IG9yIGxvc3Mgb2YgYW55Cm9mIHRoZSBIb3NwaXRhbCBEYXRhIG9yIHRoZSBIb3NwaXRhbCBSZXN1bHRzLCB1bmxlc3MgdGhleQpoYXZlIGJlZW4gYWZmZWN0ZWQgYnkgYSBkZWZlY3Qgb3IgZXJyb3IgaW4gdGhlIFNvZnR3YXJlIG9yIGEKZGVmZWN0IG9yIGVycm9yIGluIHRoZSBTZXJ2aWNlcy4KCjkuMS4KCkJyYWlub21peCBuZW9kcG92w61kw6EgemEgb2JzYWggYW5pIHphIHp0cmF0eSDDmmRhasWvIE5lbW9jbmljZQpuZWJvIFbDvXNsZWRrxa8gTmVtb2NuaWNlLCB8ZWRhxb5lIGRvxaFsbyBrIGplamljaCBvdmxpdm7Em27DrSB2CmTFr3NsZWRrdSB2YWR5IMSNaSBjaHlieSBTb2Z0d2FyZSBuZWJvIHZhZHkgxI1pIGNoeWJ5CnBvc2t5dG92YW7DvWNoIFNsdcW+ZWIuCgogCgo5LjIKClRoZSBIb3NwaXRhbCBpcyByZXNwb25zaWJsZSBmb3Igc2V0dGluZyB0aGUgY29udHJvbHMgc28gdGhhdApwYXJ0aWN1bGFyIEhvc3BpdGFsIERhdGEgYW5kIEhvc3BpdGFsIFJlc3VsdHMgYXJlIGFjY2Vzc2libGUKb25seSBieSwgYW5kIG1heSBiZSBjaGFuZ2VkIG9ubHkgYnksIHRob3NlIHBlb3BsZSB3aG9tCnRoZSBIb3NwaXRhbCBpbnRlbmRzIHRvIGhhdmUgYWNjZXNzIHRvIG9yIHRvIGJlIGFibGUgdG8KY2hhIG5nZSB0aGF0IGRhdGEgb3IgdGhvc2UgcmVzdWx0cy4KCjkuMi4KCk5lbW9jbmljZSBqZSBwb3Zpbm5hIG5hc3Rhdml0IGtvbnRyb2xuw60gbWVjaGFuaXNteSB0YWssIGFieQprZSBrb25rcsOpdG7DrW0gw5pkYWrFr20gTmVtb2NuaWNlIGEgdsO9c2xlZGvFr20gTmVtb2NuaWNlCm1vaGx5IHDFmWlzdHVwb3ZhdCBhIG3Em25pdCBqZSBwb3V6ZSBvc29ieSwga3RlcsOpIHBvZGxlIHrDoW3Em3J1Ck5lbW9jbmljZSBtYWrDrSBtw610IGt0xJttdG8gw7pkYWrFr20gbmVibyB2w71zbGVka8WvbSBwxZnDrXN0dXAKbmVibyBtYWrDrSBtw610IG1vxb5ub3N0amUgbcSbbml0LgoKIAoKIAoKOS4zCgpUaGUgSG9zcGl0YWwgd2lsbCBhbGxvdyBCcmFpbm9taXggdG8gbW9uaXRvciBob3cgaXQgYW5kClVzZXJzIHVzZSB0aGUgU29mdHdhcmUgYW5kIHRoZSBTZXJ2aWNlLCBidXQgQnJhaW5vbWl4IGlzCm5vdCBvYmxpZ2VkIHRvIGRvIHNvLiBUaGUgbW9uaXRvcmluZyBtYXkgYmUgY2FycmllZCBvdXQKd2hpbGUgcmVzcGVjdGluZyB0aGUgSG9zcGl0YWwncyBsZWdhbCBvYmxpZ2F0aW9ucywgZXNwZWNpYWxseQoKIAoKOS4zLgoKTmVtb2NuaWNlIHVtb8W+bsOtIHNwb2xlxI1ub3N0aSBCcmFpbm9taXgsIGFieSBtb25pdG9yb3ZhbGEsCmpha8O9bSB6cMWvc29iZW0gTmVtb2NuaWNlIGEgVcW+aXZhdGVsw6kgdcW+w612YWrDrSBTb2Z0d2FyZSBhClNsdcW+YnUuIEJyYWlub21peCB2xaFhayBuZW3DoSBwb3Zpbm5vc3QgdG90byBtb25pdG9yb3bDoW7DrQpwcm92w6FkxJt0LiBNb25pdG9yb3bDoW7DrSBtxa/FvmUgYsO9dCBwcm92w6FkxJtubyBwxZlpIHJlc3Bla3RvdsOhbsOtCgogCgogCgpCcmFpbm9taXggRXVyb3BlIExpbWl0ZWQKU3VpdGUgMTAzODAKCjI2LzI3IFVwcGVyIFBlbWJyb2tlIFN0cmVldApEdWJsaW4gMiBEMDIsIFgzNjEgSXJlbGFuZAoKIAoKdGhlIGNvbmZpZGVudGlhbGl0eSBvYmxpZ2F0aW9uLCB0aGUgSG9zcGl0YWwncyBidXNpbmVzcwpzZWNyZXRzIGFuZCB0aGUgcHJvdGVjdGlvbiBvZiBwZXJzb25hbCBkYXRhLCB3aGlsZSB0aGUKSG9zcGl0YWwgaXMgZW50aXRsZWQgdG8gcmVzdHJpY3QgYWNjZXNzIHRvIGRvY3VtZW50cyAocmVjb3JkcywKZGF0YSkgc28gYXMgdG8gcHJldmVudCB0aGUgdmlvbGF0aW9uIG9mIHRoZSBwcm90ZWN0aW9uIG9mCnBlcnNvbmFsIGRhdGEgb2YgdGhpcmQgcGFydGllcyBvciBpdHMgYnVzaW5lc3Mgc2VjcmV0cy4KQnJhaW5vbWl4IGlzIG9ibGlnZWQgdG8gb2JsaWdlIGF8fCBwZXJzb25zIGludm9sdmVkIGluCm1vbml0b3JpbmcgdW5kZXIgdGhpcyBhcnRpY2xlIG9mIHRoZSBBZ3JlZW1lbnQgdG8gbWFpbnRhaW4KdGhlIG9ibGlnYXRpb24gb2YgY29uZmlkZW50aWFsaXR5LiBXaGVuIGNvbmR1Y3RpbmcKbW9uaXRvcmluZyBhdCB0aGUgSG9zcGl0YWwsIEJyYWlub21peCBhbmQgaXRzIGRlc2lnbmVlcwpzaGFsbCByZXNwZWN0IHRoZSBIb3NwaXRhbCdzIG9wZXJhdGluZyBjb25kaXRpb25zLCBwcm92aWRlZAp0aGF0IHRoZSBsb2NhdGlvbiBhbmQgdGltZSBvZiB0aGUgbW9uaXRvcmluZyBzaGFsbCBiZQpkZXRlcm1pbmVkIGJ5IHRoZSBIb3NwaXRhbCBieSBtdXR1YWwgYWdyZWVtZW50IHdpdGgKQnJhaW5vbWl4LgoKesOha29ubsO9Y2ggcG92aW5ub3N0w60gTmVtb2NuaWNlLCBwxZllZGV2xaHDrW0gcG92aW5ub3N0aQptbMSNZW5saXZvc3RpLCBvYmNob2Ruw61obyB0YWplbXN0dsOtIE5lbW9jbmljZSBhIG9jaHJhbnkKb3NvYm7DrWNoIMO6ZGFqxa8sIHDFmWnEjWVtxb4gamUgTmVtb2NuaWNlIG9wcsOhdm7Em25hIG9tZXppdApwxZnDrXN0dXAgayBkb2t1bWVudMWvbSAoesOhem5hbcWvbSwgw7pkYWrFr20pIHRhaywgYWJ5IHphbWV6aWxhCnBvcnXFoWVuw60gb2NocmFueSBvc29ibsOtY2ggw7pkYWrFryB0xZlldMOtY2ggb3NvYiBuZWJvIHN2w6lobwpvYmNob2Ruw61obyB0YWplbXN0dsOtLiBCcmFpbm9taXggamUgcG92aW5lbiB6YXbDoXphdCB2ZcWha2Vyw6kKb3NvYnkgcG9kw61sZWrDrWPDrSBzZSBuYSBtb25pdG9yb3bDoW7DrSBkfGUgdG9ob3RvIMSNbMOhbmt1IFNtbG91dnkgawp6YWNob3bDoXbDoW7DrSBwb3Zpbm5vc3RpIG1sxI1lbmxpdm9zdGkuIFDFmWkgcHJvdsOhZMSbbsOtCm1vbml0b3JvdmFuw612IE5lbW9jbmljaSBqZSBCcmFpbm9taXggYSBqw61tIGEgcG92xJvFmWVuw6kgb3NvYnkKcG92aW5uaSByZXNwZWt0b3ZhdCBwcm92b3puw60gcG9kbcOtbmt5IE5lbW9jbmljZSBzIHTDrW0sIMW+ZQptw61zdG8gYSDEjWFzIGtvbnRyb2x5IHN0YW5vdnVqZSBOZW1vY25pY2UgcG8gdnrDoWplbW7DqQpkb21sdXbEmyBzIEJyYWlub21peC4KCiAKCiAKCiAKCiAKCiAKCjkuNCBJZiwgaW4gdGhlIGNvdXJzZSBvZnRoZSBwcm92aWRpbmcgYW55IFNlcnZpY2UgdG8gdGhlIEhvc3BpdGFsLCA5LjQuIFYgcMWZw61wYWTEmywgxb5lIHNwb2xlxI1ub3N0IEJyYWlub21peCBidWRlIHDFmWkgcG9za3l0b3bDoW7DrSBTbHXFvmViCkJyYWlub21peCBQcm9jZXNzZXMgYW55IFBlcnNvbmFsIERhdGEgZm9yIHRoZSBIb3NwaXRhbCBQYXJ0IE5lbW9jbmljaSB6cHJhY292w6F2YXQgcHJvIE5lbW9jbmljaSBvc29ibsOtIMO6ZGFqZSwgdXBsYXRuw60gc2UKMSBvZiB0aGUgRGF0YSBQcm9jZXNzaW5nIFRlcm1zIHdpfHwgYXBwbHkuIMSNw6FzdCAxIFBvZG3DrW5layB6cHJhY292w6Fuw60gb3NvYm7DrWNoIMO6ZGFqxa8uCgoxMC4gY2hhcmdlcyBhbmQgUGF5bWVudCAxMC4gT2RtxJtuYSBhamVqw60gw7pocmFkYQoKMTAuMSBUaGUgSG9zcGl0YWwgdW5kZXJ0YWtlcyB0byBwYXkgdGhlIGNoYXJnZXMgZm9yIHRoZSAxMC4xLiBOZW1vY25pY2Ugc2UgemEgcG9za3l0bnV0w60gUMWZw61zdHVwdSBrZSBTbHXFvmLEmyBhIHphIFNsdcW+YnkKcHJvdmlzaW9uIG9mIHRoZSBBY2Nlc3MgdG8gU2VydmljZSBhbmQgZm9yIHRoZSBTZXJ2aWNlcywgemF2YXp1amUgaHJhZGl0IHNwb2wuIEJyYWlub21peCBPZG3Em251LCBzdnlqw61ta291IFprdcWhZWJuw60KZXhjZXB0IHRoZSBUcmlhbCBhbmQgYXMgc2V0IG91dCBpbiBBcHBlbmRpeCAxIG9mIHRoaXMgZmF6ZSBhdG92c291bGFkdSBzcMWZw61sb2hvdSDEjS4xIHTDqXRvIFNtbG91dnkuIE5lZG9ob2Rub3VybGkKQWdyZWVtZW50LiBVbmxlc3Mgb3RoZXJ3aXNlIGFncmVlZCBpbiB3cml0aW5nLCBwYXltZW50IG9mIHNlIHN0cmFueSBww61zZW1uxJsgamluYWssIE5lbW9jbmljZSBidWRlIE9kbcSbbnUgc3BvbGXEjW5vc3RpCnRoZSBjaGFyZ2VzIHdpbGwgYmUgbWFkZSBieSB0aGUgSG9zcGl0YWwgdG8gQnJhaW5vbWl4IGluIEJyYWlub21peCBocmFkaXQgdm3Em27EmyBDWksgbmEgemFrbGFkZSBmYWt0dXJ5IHZ5c3RhdmVuw6kKZnV8fCBpbiBDWksgY3VycmVuY3kgYmFzZWQgb24gYW4gaW52b2ljZSBpc3N1ZWQgYnkgc3BvbGXEjW5vc3TDrSBCcmFpbm9taXgsIHbFvmR5IG5lanBvemTEm2ppIGRvIDMwICh0xZlpY2V0aSkgZG7FryBvZApCcmFpbm9taXgsIG5vIHxhdGVyIHRoYW4gdGhpcnR5ICgzMCkgZGF5cyBhZnRlciB0aGUgZGF0ZSBvZiBkYXRhIHZ5c3RhdmVuw60gcMWZw61zbHXFoW7DqSBmYWt0dXJ5LiBWeXN0YXZlbmEgZmFrdHVyYSBtdXPDrQp0aGF0aW52b2ljZS4gb2JzYWhvdmF0IHZlxaFrZXLDqSBuw6FsZcW+aXRvc3RpIHN0YW5vdmVuw6kgcMWZw61zbHXFoW7DvW1pIHByw6F2bsOtbWkKVGhlIGlzc3VlZCBpbnZvaWNlIHNoYWxsIGNvbnRhaW4gYXx8IHBhcnRpY3VsYXJzIHJlcXVpcmVkIHDFmWVkcGlzeSwgemVqbS4gesOha29uYSDEjS4gMjM1LzIwMDQgU2IuLCBvIGRhbmkgeiBwxZlpZGFuw6kKdW5kZXIgdGhlIGFwcGxpY2FibGUgbGVnYWwgcmVndWxhdGlvbnMsIGluIHBhcnRpY3VsYXIgdW5kZXIgaG9kbm90eSBhIHrDoWtvbmEgxI0uIDU2My8xOTkxIFNiLiwgbyDDusSNZXRuaWN0dsOtLiBCcmFpbm9taXggc2UKQWN0IE5vLiAyMzUvMjAwNCBDb2xsLiwgb24gVmFsdWUgQWRkZWQgVGF4LCBhbmQgQWN0IE5vLiB6YXZhenVqZSB2eXN0YXZpdCBmYWt0dXJ1IHZlbGVrdHJvbmlja2UgZm9ybcSbLCB2ZSBmb3Jtw6F0dSBQREYsCjU2My8xOTkxIENvbGwuLCBvbiBBY2NjdW50aW5nLSBCcmFpbm9taXggdW5kZXJ0YWtlcyB0byBhIHZ0w6l0byBmb3JtxJsgZmFrdHVydSBkb3J1xI1pdCBOZW1vY25pY2kgbmEgZW1haWxvdm91Cmlzc3VlIHRoZSBpbnZvaWNlIGluIGVsZWN0cm9uaWMgZm9ybSwgaW4gUERGIGZvcm1hdCwgYW5kIHRvIGFkcmVzdTogbmVqcG96ZMSbamkgbsOhc3xlZHVqw61jw60gcHJhY292bsOtCmR0aGUnIFNVQ2ggaW52b2ljZSB0byB0aGUgSE9TUMONdGFsIGJ5IGVtYWlsIHRvIGRlbiBwbyBqZWrDrW0gdnlzdGF2ZW7DrS4gTmVidWRlcmxpIGZha3R1cmEgdnlzdGF2ZW5hIGEgemFzbMOhbmEKCiIwIHxhdGVyIHRoYW4gdGhlIGYwfHwwV8ONaGzFoSBCdXNpbmVzcyB2ZSBzdGFub3ZlbsOpIGZvcm3EmywgbmVidWRlcmxpIG9ic2Fob3ZhdCBzdGFub3ZlbsOpIG7DoWxlxb5pdG9zdGksCgpEYXkgYWZ0ZXJ0aGUgZGF0ZSBvZiBpdHMgaXNzdWFuY2UuIGxmdGhlaW52b2ljZSBpcyBub3QgaXNzdWVkIG5lYnVkb3UgdiBuw60gc23DoXZuxJsgdXZlZGVuw6kgw7pkYWplIGR8ZSBTbWxvdXZ5LCBqZQphbmQgZHRoZSdlZCBpaCB0aGUgUGZlU0Mnw41iZWQgZm9ybSwgZG9lcyBub3QgY29udGFpbiB0aGUgTmVtb2NuaWNlIG9wcsOhdm7Em25hIGZha3R1cnUgdnJhdGl0IEJyYWlub21peCB2ZSBsaMWvdMSbIG9zbWkgKDgpCnJlcXVpcmVkIHBhcnRpY3VsYXJzLCBvciBjb250YWlucyBpbmZvcm1hdGlvbiB0aGF0IGlzIGRuxa8gb2QgamVqw61obyBkb3J1xI1lbsOtLiBWZSB2csOhY2Vuw6ltIGRva2xhZHUgbXVzw60gdnl6bmHEjWl0CmluY29ycmVjdCBvciBpbmNvbnNpc3RlbnQgd2l0aCB0aGlzIEFncmVlbWVudCwgdGhlIEhvc3BpdGFsIGTFr3ZvZCBtw6FnZW0gRG8gZG9ieSB2eXN0YXZlbsOtIMWZw6FkbsOpIChvcG12ZW7DqSkgZmFrdHVyeSBhCnNoYWxsIGJlIGVudGl0bGVkIHRvIHJldHVybiB0aGUgaW52b2ljZSB0byBCcmFpbm9taXggd2l0aGluIHVwbHludXTDrSBsaMWvdHkgamVqw60gc3BsYXRub3N0aSBuZW7DrSBOZW1vY25pY2UgdiBwcm9kbGVuw60gcwplaWdodCAoOCkgZGF5cyBvZiBpdHMgcmVjZWlwdCwgc3RhdGluZyB0aGUgcmVhc29uIGZvciBzdWNoIMO6aHJhZG91IE9kbcSbbnkuIE5vdmEgbGjFr3RhIHNwbGF0bm9zdGkgemHEjcOtbsOhIGLEm8W+ZXQgZG5lbQpyZXR1cm4gT2ggdGhlIHJldHVybmVkIGRvY3VtZW50LiBkb3J1xI1lbsOtIG5vdsOpIGJlenZhZG7DqSBmYWt0dXJ5IE5lbW9jbmljZS4KVW50aWwgYSBkdXx5IGlzc3VlZCAoY29ycmVjdGVkKSBpbnZvaWNlIGhhcyBiZWVuIGRlbGl2ZXJlZCB0bwp0aGUgSG9zcGl0YWwgYW5kIHRoZSBwZXJpb2QgZm9yIGl0cyBwYXltZW50IGhhcyBleHBpcmVkLCB0aGUKSG9zcGl0YWwgc2hhbGwgbm90IGJlIGluIGRlZmF1bHQgd2l0aCB0aGUgcGF5bWVudCBvZiB0aGUKRmVlLiBUaGUgcGF5bWVudCBwZXJpb2Qgc2hhbGwgY29tbWVuY2UgYW5ldyBvbiB0aGUgZGF0ZQpvZiBkZWxpdmVyeSBvZiBhIG5ldywgZXJyb3JyZnJlZSBpbnZvaWNlIHRvIHRoZSBIb3NwaXRhbC4KCjEwLjIgQXx8IGNoYXJnZXMgYXJlIGV4Y2x1c2l2ZSBvZiBWQVQgYW5kIHRoZSBIb3NwaXRhbCB3aXx8IHBheSAxMC4yLiBPZG3Em25hIGplIHV2w6FkxJtuYSBiZXogRFBILiBOZW1vY25pY2UgamUgcG92aW5uYSB1aHJhZGl0CmFueSBhbmQgYUlJVkFULiBwxZnDrXNsdcWhbm91IERQSC4KCjEwLjMgSWYgdGhlIEhvc3BpdGFsIGRvZXMgbm90IHBheSBhbnkgb2YgdGhlIGNoYXJnZXMgYnkgdGhlIGR1ZSAxMC4zLiBOZXVocmFkw61ybGkgTmVtb2NuaWNlIE9kbcSbbnUgdmUgbGjFr3TEmyBzcGxhdG5vc3RpLCBzcG9sZcSNbm9zdAoKZGF0ZSBCcmFpbm9taXggd2lsbCBiZSBlbnRpdGxlZCwgd2l0aG91dCBwcmVqdWRpY2UgdG8gYW55Cm90aGVyIHJpZ2h0cyBhbmQgcmVtZWRpZXMgaXQgbWF5IGhhdmUsIHRvIGRvIGFueSBvbmUgb3IKbW9yZSBvZnRoZSBmb2xsb3dpbmc6CgpCcmFpbm9taXggbcWvxb5lIHVwbGF0bml0IG7DrcW+ZSB1dmVkZW7DqSBwcmF2YSwgYW5pxb4gYnkgdMOtbSBieWxhCmRvdMSNZW5hIHDFmcOtcGFkbsOhIGplasOtIGRhbMWhw60gcHLDoXZhIGEgbW/Fvm5vc3RpIHVwbGF0bsSbbsOtIGppbsO9Y2gKcHJvc3TFmWVka8WvIG5hcHJhdnk6CgogCgoxMC4zLjEgdG8gc3VzcGVuZCBhbnkgb3IgYWxsIG9mIHRoZSBTZXJ2aWNlcyBhbmQgdGhlCkhvc3BpdGFsJ3MgcmlnaHQgdG8gdXNlIHRoZSBTb2Z0d2FyZTsKCjEwLjMuMSBwb3phc3Rhdml0IFNsdcW+YnkgbmVibwpOZW1vY25pY2UgdcW+w612YXQgU29mdHdhcmU7CgpqZWppY2ggxI3DoXN0LCBqYWtvxb4gaSBwcsOhdm8KCiAKCiAKCjEwLjMuMiB0byB0ZXJtaW5hdGUgdGhlIEFncmVlbWVudCB1bmRlciBjbGF1c2UgMTIuMgoKIAoKMTAuMy4yIHZ5cG92xJtkxJt0IFNtbG91dnUgdiBzb3VsYWR1IHMgxI0uIDEyLjIgdMOpdG8gU21sb3V2eTsKCiAKCiAKCkJyYWlub21peCBFdXJvcGUgTGltaXRlZApTdWl0ZSAxMDM4MAoKMjYvMjcgVXBwZXIgUGVtYnJva2UgU3RyZWV0CkR1YmxpbiAyIEQwMiwgWDM2MSBJcmVsYW5kCgogCgpiZWxvdzsKCiAKCjEwLjMuMwoKdG8gbGV2eSBhIHNlcnZpY2UgY2hhcmdlIHRvIGNvdmVyIGFkbWluaXN0cmF0aXZlIGFuZApvdGhlciBhc3NvY2lhdGVkIGNvc3RzIGluIHJlbGF0aW9uIHRvIHRoZSB1bnBhaWQKaW52b2ljZSBhdCB0aGUgcmF0ZSBvZiAzICUgcGVyIG1vbnRoIG9uIGF8fCBpbnZvaWNlcwpub3QgcGFpZCBpbiBmdWxsOyBhbmQKCjEwLjMuMwoKcG/FvmFkb3ZhdCDDumhyYWR1IHNlcnZpc27DrWhvIHBvcGxhdGt1IG5hIHVocmF6ZW7DrQphZG1pbmlzdHJhdGl2bsOtY2ggYSBvc3RhdG7DrWNoIG7DoWtsYWTFryBzcG9qZW7DvWNoIHMKZmFrdHVyb3UgcG8gc3BsYXRub3N0aSwgcMWZacSNZW3FviBzYXpiYSB0b2hvdG8gcG9wbGF0a3UKxI1pbsOtIDMgJSBtxJsgxJsgemUgdsWhZWNoIGZha3R1ciwgamXFviBuZWJ5fHkgdWhyYXplbnkgdgpwbG7DqSB2w73FoWk7IGEKCiAgCgogCgoxMC4zLjQgdG8gY2hhcmdlIGludGVyZXN0IHNldCBvdXQgYnkgdGhlIHJlc3BlY3RpdmUgbGF3IG9uCgphbnkgb3V0c3RhbmRpbmcgYW1vdW50IGFjY3J1aW5nIG9uIGEgZGFpbiBiYXNpcwphbmQgQnJhaW5vbWl4J3MgcmVhc29uYWJsZSBleHBlbnNlcyBvbiBhbgppbmRlbW5pdHkgYmFzaXMgKGluY2x1ZGluZywgd2l0aG91dCB8aW1pdGF0aW9uLCBsZWdhbApleHBlbnNlcyBhbmQgdGhlIGNvc3RzIG9mIGNvbGxlY3Rpb24pIGluY3VycmVkIGluCmNvbm5lY3Rpb24gd2l0aCB0aGUgSG9zcGl0YWwncyBmYWl8dXJlIHRvIHBheSBhbnkKYW1vdW50IHdoZW4gZHVlLgoKMTAuMy40Cgpwb8W+YWRvdmF0IMO6aHJhZHUgw7pyb2t1IHogcHJvZGxlbsOtIHN0YW5vdmVuw6lobwpwcsOhdm7DrW1pIHDFmWVkcGlzeSB6IG5ldWhyYXplbsOpIMSNw6FzdGt5LCBhIHRvIHphIGthxb5kw70gZGVuCnByb2RsZW7DrSwgYSBkw6FsZSBwb8W+YWRvdmF0IG5haHJhZHUgcMWZaW3Em8WZZW7DvWNoIHbDvWRhasWvCih2xI1ldG7EmyBwcsOhdm7DrWNoIHbDvWxvaCBhIG7DoWtsYWTFryBzcG9qZW7DvWNoIHMgdnltYWhhbsOtbQpkbHXFvm7DqSDEjcOhc3RreSksIGt0ZXLDqSBzcG9sZcSNbm9zdGkgQnJhaW5vbWl4IHZ6bmlrbHkgdgpzb3V2aXNsb3N0aSBzIHByb2RsZW7DrW0gTmVtb2NuaWNlIHDFmWkgw7pocmFkxJsgc3BsYXRuw71jaArEjcOhc3Rlay4KCiAKCiAKCiAKCiAKCjEwLjQgVGhlIEhvc3BpdGFsIHdpbGwgaGF2ZSBubyByaWdodCB0byBzZXQgb2ZmIGFueSBhbW91bnRzIDEwLjQuIE5lbW9jbmljZSBuZXNtw60gamVkbm9zdHJhbm7EmyB6YXBvxI3DrXTDoXZhdCBwxZnDrXBhZG7DqSBzdsOpCm93aW5nIHRvIGl0IGJ5IEJyYWlub21peCBhZ2FpbnN0IGFtb3VudHMgcGF5YWJsZSB0byBwb2hsZWTDoXZreSB6YSBzcG9sZcSNbm9zdMOtIEJyYWlub21peCBvcHJvdGkgcG9obGVkYXZrYW0KQnJhaW5vbWl4LiBzcG9sZcSNbm9zdGkgQnJhaW5vbWl4IHphIE5lbW9jbmljw60uCgoxMS4gQ29uZmlkZW50aWFsaXR5IDExLiBNbMSNZW5saXZvc3QKCjExLjEgQnJhaW5vbWl4IGFuZCB0aGUgSG9zcGl0YWwgZWFjaCBhZ3JlZSB0byBrZWVwIHRoZSBvdGhlcidzIDExLjEgSmFrIEJyYWlub21peCwgdGFrIE5lbW9jbmljZSBzZSB6YXZhenVqw60gemFjaG92w6F2YXQgbWzEjWVubGl2b3N0CkNvbmZpZGVudGlhbCBJbmZvcm1hdGlvbiBjb25maWRlbnRpYXwgYW5kLCBleGNlcHQgYXMgbyBExa92xJtybsO9Y2ggaW5mb3JtYWPDrWNoIGRydWjDqSBzdHJhbnkgYW5lc2TEm2xvdmF0IGplIGppbsO9bQpwZXJtaXR0ZWQgZWxzZXdoZXJlIGluIHRoZSBBZ3JlZW1lbnQsIG5vdCBkaXNjbG9zZSB0aGF0IG9zb2JhbSwgbmVwb3XFvsOtdCBqZSBwcm8gxb5hZG7DvSDDusSNZWwga3JvbcSbIHbDvWtvbnUgc3bDvWNoIHByw6F2CmluZm9ybWF0aW9uIHRvIGFueSBvdGhlciBwZXJzb24sIG9yIHVzZSBpdCBmb3IgYW55IHB1cnBvc2UgbmVibyBwbG7Em27DrSBzdsO9Y2ggcG92aW5ub3N0w60gcG9kbGUgdMOpdG8gU21sb3V2eSwgbGVkYcW+ZSBieSB0YXRvCmV4Y2VwdCB0aGUgZXhlcmNpc2Ugb2YgaXRzIHJpZ2h0cywgb3IgdGhlIHBlcmZvcm1hbmNlIG9mIGl0cyBTbWxvdXZhIHVtb8W+xYhvdmFsYSBuxJtjb2ppbsOpaG8uCm9ibGlnYXRpb25zLCB1bmRlciB0aGUgQWdyZWVtZW50LgoKMTEuMiBOb3RoaW5naW4gY2xhdXNlIDExLjEgYWJvdmU6IDExLjIgxb3DoWRuw6kgdXN0YW5vdmVuw63EjWwuIDExLjEgdMOpdG8gU21sb3V2eToKCiAKCjExLjIuMSB3aXx8IHByZXZlbnQgQnJhaW5vbWl4IGZyb20gZGlzY2xvc2luZyB0byBhbnkgb2YgaXRzCgpTdWJwcm9jZXNzb3JzIGFueSBvZiB0aGUgSG9zcGl0YWwncyBDb25maWRlbnRpYWwKSW5mb3JtYXRpb24gdG8gd2hpY2ggdGhleSBuZWVkIGFjY2VzcyB0byBpbiBvcmRlciB0bwpwZXJmb3JtIHRoZWlyIG9ibGlnYXRpb25zdG8gQnJhaW5vbWl4OyBpbiBzdWNoIGEgY2FzZSwKQnJhaW5vbWl4IHNoYWxsIHJlcXVpcmUgdGhlIFN1YnJQcm9jZXNzb3IgdG8KdW5kZXJ0YWtlIGNvbmZpZGVudGlhfGl0eSBvYmxpZ2F0aW9ucyBubyBsZXNzIHN0cmluZ2VuZAp0aGFuIHRob3NlIGltcG9zZWQgb24gQnJhaW5vbWl4IGZyb20gdGhpcwpBZ3JlZW1lbnQ7CgoxMS4yLjEKCm5lYnJhbsOtIHNwb2xlxI1ub3N0aSBCcmFpbm9taXgsIGFieSBzdsOpbXUgRMOtbMSNw61tdQp6cHJhY292YXRlbGkgc2TEm2xpbGEgRMWvdsSbcm7DqSBpbmZvcm1hY2UgTmVtb2NuaWNlLCBrIG5pbcW+CkTDrWzEjcOtIHpwcmFjb3ZhdGVsIHBvdMWZZWJ1amUgbcOtdCBwxZnDrXN0dXAsIGFieSBtb2hsIHBsbml0IHN2w6kKcG92aW5ub3N0aSB2xa/EjWkgc3BvbGXEjW5vc3RpIEJyYWlub21peDsgdiB0YWtvdsOpbSBwxZnDrXBhZMSbCmplIHNwb2xlxI1ub3N0IEJyYWlub21peCBwb3Zpbm5hIHphdsOhemF0IETDrWzEjcOtaG8KenByYWNvdmF0ZWxlIHBvdmlubm9zdMOtIG1sxI1lbmxpdm9zdGkgYWxlc3BvxYggdGFrb3ZvdSwgamFrw70KdnlwbMO9dsOhIHBybyBzcG9sZcSNbm9zdCBCcmFpbm9taXggeiB0w6l0byBTbWxvdXZ5OwoKIAoKMTEuMi4yCgp3aXx8IHByZXZlbnQgZWl0aGVyIHBhcnR5IGZyb20gZGlzY2xvc2luZyBvciByZXRhaW5pbmcKYW55IG9mIHRoZSBvdGhlcidzIENvbmZpZGVudGlhbCBJbmZvcm1hdGlvbiBpbiBvcmRlciB0bwpjb21wbHkgd2l0aCB0aGUgbGF3IG9yIGFueSByZWd1bGF0aW9uIHRvIHdoaWNoIGl0IGlzCnN1YmplY3QsIG9yIHRoZSBvcmRlciBvZiBhbnkgY291cnQgb3Igb2YgYW55IGNvbXBldGVudAphdXRob3JpdHk7CgoxMS4yLjIKCm5lYnJhbsOtIGt0ZXLDqWtvbGkgemUgc3RyYW4gc2TEm2xpdCBuZWJvIHVjaG92YXZhdCBExa92xJtybsOpCmluZm9ybWFjZSBkcnVow6kgc3RyYW55IHBybyDDusSNZWx5IHBsbsSbbsOtIHByw6F2bsOtY2gKcMWZZWRwaXPFrywgamXFviBzZSBuYSBkb3R5xI1ub3Ugc3RyYW51IHZ6dGFodWrDrSwgbmVibyBwcm8Kw7rEjWVseSBwbG7Em27DrSBuYcWZw616ZW7DrSBzb3VkdSBuZWJvIGppbsOpaG8ga29tcGV0ZW50bsOtaG8Kb3JnYW51OwoKIAoKMTEuMi4zCgphcHBsaWVzIHRvIGFueSBvZiB0aGUgb3RoZXIgcGFydHkncyBpbmZvcm1hdGlvbiB0aGF0IGlzCm9yIGNvbWVzIGludG8gdGhlIHB1YmxpYyBkb21haW4gdGhyb3VnaCBubyBicmVhY2ggb2YKY2xhdXNlIDExLjEsIG9yIHRoYXQgYnkgaXRzIG5hdHVyZSBjYW5ub3QgYmUKY29uZmlkZW50aWFsOyBvcgoKMTEuMi4zCgpzZSBuZXZ6dGFodWplIG5hIHR5IGluZm9ybWFjZSBkcnVow6kgc3RyYW55LCBrdGVyw6kganNvdQpuZWJvIHNlIHN0YW5vdSB2ZcWZZWpuxJsgem5hbWUgamluYWsgbmXFviBwb3J1xaFlbsOtbQrEjWwuIDExLjEgdMOpdG8gU21sb3V2eSwgbmVibyBrdGVyw6kgemUgc3bDqSBwb3ZhaHkgbmVtb2hvdQpiw710IGTFr3bEm3Juw6k7CgogCgogCgogCgoxMS4zCgpFYWNoIHBhcnR5IHdpfHwgbm90aWZ5IHRoZSBvdGhlciBpbW1lZGlhdGVseSBpZiBpdCBiZWNvbWVzCmF3YXJlIG9mIGFueSBicmVhY2ggb2YgY29uZmlkZW5jZSBpbiByZWxhdGlvbiB0byB0aGUgb3RoZXIncwpDb25maWRlbnRpYWwgSW5mb3JtYXRpb24sIGFuZCBpdCB3aWxsIGdpdmUgdGhlIG90aGVyIGFueQoKIAoKMTEuMyBLYcW+ZMOhIHplIHN0cmFuIGJ1ZGUgZHJ1aG91IHN0cmFudSBuZXByb2RsZW7EmyBpbmZvcm1vdmF0LApqZXN0bGnFvmUgc2UgZG96dsOtIG8gcG9ydcWhZW7DrSBtbMSNZW5saXZvc3RpIHZlIHZ6dGFodSBrIETFr3bEm3Juw71tCmluZm9ybWFjw61tIGRydWjDqSBzdHJhbnksIGEgcG9za3l0bmUgasOtIHNvdcSNaW5ub3N0LCBrdGVyb3UgZHJ1aGEKCiAKCiAKCkJyYWlub21peCBFdXJvcGUgTGltaXRlZApTdWl0ZSAxMDM4MAoKMjYvMjcgVXBwZXIgUGVtYnJva2UgU3RyZWV0CkR1YmxpbiAyIEQwMiwgWDM2MSBJcmVsYW5kCgogCgphc3Npc3RhbmNlIHJlYXNvbmFibHkgcmVxdWlyZWQgaW4gY29ubmVjdGlvbiB3aXRoIGFueSBhY3Rpb24KCm9yIHByb2NlZWRpbmdzIHdoaWNoIHRoZSBvdGhlciBtYXkgaW5zdGl0dXRlIGFnYWluc3QgYW55Cgp0aGlyZCBwYXJ0eSBmb3IgYnJlYWNoIG9mIGNvbmZpZGVuY2UuCgpzdHJhbmEgYnVkZSBwxZlpbcSbxZllbsSbIHBvxb5hZG92YXQgdiBzb3V2aXNsb3N0aSA1IGtyb2t5IG5lYm8KxZnDrXplbsOtbSwgamXFviBwxZnDrXBhZG7EmyB6YWhhasOtIHByb3RpIHTFmWV0w60gb3NvYsSbIHBybyBwb3J1xaFlbsOtCnBvdmlubm9zdGkgbWzEjWVubGl2b3N0aS4KCiAKCiAKCiAKCiAKCiAKCiAKCiAKCiAKCiAKCiAKCiAKCjQuMi43IChsaWFiaWxpdHkgZm9yIFVzZXJzKSwgMTAuMy40IChpbnRlcmVzdCksIDEuNCAoc2V0IG9mZiksIDgKKHxudGV8fGVjdHVhfCBQcm9wZXJ0eSBSaWdodHMpLCA5IChIb3NwaXRhbCBEYXRhKSwgMTEKKENvbmZpZGVudGlhbGl0eSksIDEzIChFZmZlY3RzIG9mIFRlcm1pbmF0aW9uKSwgMTQgKFdhcnJhbnRpZXMKYW5kIExpYWJpbGl0eSksIDE1IChUaGlyZCBQYXJ0eSBDbGFpbXMpIGFuZCAxNiAoR2VuZXJhbCkgd2l8fApzdXJ2aXZlIHRoZSBleHBpcnkgb3IgdGVybWluYXRpb24gb2YgdGhlIEFncmVlbWVudCBhbmQKY29udGludWUgaW4gZnV8fCBmb3JjZSBhbmQgZWZmZWN0IHdpdGhvdXQgbGltaXQgaW4gdGltZS4gUGFydCAxCm9mIHRoZSBEYXRhIFByb2Nlc3NpbmcgVGVybXMgd2l8fCBjb250aW51ZSBpbiBmdXx8IGZvcmNlIGFuZAplZmZlY3QgZm9yIHNvIGxvbmcgYXMgQnJhaW5vbWl4IG9yIGFueSBvZiBpdHMgU3VicHJvY2Vzc29ycwoKIAoKMTIuIFRlcm0gYW5kIFRlcm1pbmF0aW9uIDEyLiBUcnbDoW7DrSBhIHVrb27EjWVuw60gU21sb3V2eQoKMTIuMSBUaGUgQWdyZWVtZW50IGlzIGNvbmNsdWRlZCBmb3IgdGhlIGZpeGVkIFJlbGV2YW50IFBlcmlvZCwgMTIuMSBUYXRvIFNtbG91dmEgc2UgdXphdsOtcsOhIG5hIGRvYnUgdXLEjWl0b3UsIGEgdG8gbmEgUm96aG9kbsOpCnN1YmplY3QgdG8gZWFyfGllciB0ZXJtaW5hdGlvbiB1bmRlciBjbGF1c2UgMy40IGFib3ZlIG9yIG9iZG9iw60sIG5lYnVkZXJsaSBwxZllZMSNYXNuxJsgdWtvbsSNZW5hIHBvZGxlIMSNbC4gMy40IG5lYm8gxI1sLiAxMi4yCmNsYXVzZSAxMi4yIG9yIDE1LjQgYmVsb3cuIMSNaS4gMTUuNCB0w6l0byBTbWxvdXZ5LgoKMTIuMiBFaXRoZXIgcGFydHkgbWF5IHRlcm1pbmF0ZSB0aGUgQWdyZWVtZW50IHdpdGhvdXQgYW55IDEyLjIgS3RlcmFrb2xpIHN0cmFuYSBtxa/FvmUgU21sb3V2dSB2eXBvdsSbZMSbdCBiZXogdsO9cG92xJtkbsOtIGRvYnkKbm90aWNlIHBlcmlvZCAoYXMgb2YgdGhlIGRhdGUgb2YgZGVsaXZlcnkgdG8gdGhlIG90aGVyIHBhcnR5KSAoa2UgZG5pIGRvcnXEjWVuw60gZHJ1aMOpIHNtbHV2bsOtIHN0cmFuxJspIHDDrXNlbW7DvW0gb3puw6FtZW7DrW0KYnkgZ2l2aW5nIHdyaXR0ZW4gbm90aWNlIHRvIHRoZSBvdGhlciBpZiB0aGUgb3RoZXI6IHphc2xhbsO9bSBkcnVow6kgc3RyYW7EmywgamVzdGxpxb5lOgoKMTIuMi4xIGNvbW1pdHMgYSBtYXRlcmlhbCBvciByZXBlYXRlZCAoYXQgbGVhc3QgMyB0aW1lcykgMTIuMi4xIGRydWjDoSBzdHJhbmEgcG9kc3RhdG7DvW0genDFr3NvYmVtIGFuZWJvIG9wYWtvdmFuxJsKYnJlYWNoIG9mIGFueSB3YXJyYW50eSwgY29uZGl0aW9uIG9yIHVuZGVydGFraW5nIGluIChhbGVzcG/FiCAza3JhdCkgcG9ydcWhdWplIHphcnVrdSwgcG9kbcOtbmt1IG5lYm8gesOhdmF6ZWsKdGhlIEFncmVlbWVudGFuZCx3aGVyZXRoZSBicmVhY2hpc3JlbWVkaWFibGUsIHBseW5vdWPDrSB6IHTDqXRvIFNtbG91dnksIGEgamVsaSBwb3J1xaFlbsOtIHpob2ppdGVsbsOpLAp0aGUgYnJlYWNoIGlzIG5vdCByZW1lZGllZCB3aXRoaW4gdGhlIHBlcmlvZCBmb3IgbmV6amVkbmEgbmFwcmF2dSB2ZSBsaMWvdMSbIHV2ZWRlbsOpIHZlIHbDvXp2xJsgayBuw6FwcmF2xJsKcmVtZWR5IHNwZWNpZmllZCBpbiB0aGUgbm90aWNlIGRlbGl2ZXJlZCBieSB0aGUgb3RoZXIgZG9ydcSNZW7DqSBkcnVob3Ugc3RyYW5vdSwgcMWZacSNZW3FviBsaMWvdGEgbmVzbcOtIGLDvXQga3JhdMWhw60KcGFydHkgKHRoYXQgcGVyaW9kIGJlaW5nIG5vdCBsZXNzIHRoYW4gZmlmdGVlbiAoMTUpIG5lxb4gMTUgKHBhdG7DoWN0KSBkbsWvIG9kIGRvcnXEjWVuw612w716dnk7CmRheXMpIGFmdGVyIHJlY2VpcHQgb2Ygbm90aWNlIG9mIHRoZSBicmVhY2g7CgoxMi4yLjIgaGFzIGFuIGluc29sdmVuY3kgcHJvY2VlZGluZ2luaXRpYXRlZCBvdmVyYWxsb3JhbnkgMTIuMi4yIG9obGVkbsSbIG1hamV0a3UgbmVibyBwb2RuaWt1IGRydWjDqSBzdHJhbnkgbmVibyBqZWppY2gKb2YgaXRzIGFzc2V0cyBvciB1bmRlcnRha2luZyBvciwgZXhjZXB0IGZvciB0aGUgxI1hc3RpIGJ5bG8gemFow6FqZW5vIGluc29sdmVuxI1uw60gxZnDrXplbsOtIGFuZWJvamVzdGxpxb5lIGRydWhhCnB1cnBvc2VzIG9mIGEgc29sdmVudCBhbWFsZ2FtYXRpb24gb3Igc3RyYW5hIHZzdG91cGlsYSBkbyBsaWt2aWRhY2UgKHMgdsO9amlta291IHDFmcOtcGFkxa8gcMWZZW3Em255CnJlY29uc3RydWN0aW9uLCBlbnRlcnMgaW50byBsaXF1aWRhdGlvbiwgZW50ZXJzIGludG8gcGxhdGVibsSbIHNjaG9wbsOpaG8gcG9kbmlrdSksIHV6YXbFmWVsYSBkb2hvZHUKYW55IGNvbXBvc2l0aW9uIG9yIGFycmFuZ2VtZW50IHdpdGggb3IgZm9yIHRoZSBvdnlwb8WZYWRhbsOtIHNlIHN2w71taSB2xJvFmWl0ZWxpIMSNaSB2amVqaWNoIHByb3NwxJtjaCBuZWJvCmJlbmVmaXQgb2YgaXRzIGNyZWRpdG9ycywgb3IgZXF1aXZhbGVudCBjaXJjdW1zdGFuY2VzIHBva3VkIG5hc3RhbHkgb2Jkb2Juw6kgb2tvbG5vc3RpIGR8ZSBwcsOhdm7DrWhvIMWZw6FkdSwKb2NjdXIgaW4gYW55IG9mIHRoZSBqdXJpc2RpY3Rpb25zIHRoZSBwYXJ0aWVzIHVuZGVybGllLCBrdGVyw6ltdSBzdHJhbnkgcG9kbMOpaGFqw60sIG5lYm8gcG9rdWQgZHJ1aMOhIHN0cmFuYQpvciBjZWFzZXMgdG8gY2Fycnkgb24gYnVzaW5lc3MuIHVrb27EjWlsYSDEjWlubm9zdC4KCjEzLiBFZmZlY3RzIG9mIFRlcm1pbmF0aW9uIDEzLiDDmsSNaW5reSB1a29uxI1lbsOtCgoxMy4xLiBPbiB0aGUgdGVybWluYXRpb24gZm9yIGFueSByZWFzb24gb3IgZXhwaXJ5IHdpdGhvdXQgMTMuMSBVa29uxI1lbsOtbSBTbWxvdXZ5empha8OpaG9rb2xpZMWvdm9kdSBuZWJvIHVwbHludXTDrW0gZG9ieSwKcmVuZXdhbCBvZnRoZSBBZ3JlZW1lbnQ6IG5hIGt0ZXJvdSBieWxhIFNtbG91dmEgc2plZG7DoW5hLCBuYXN0YW5vdSBuYXNsZWR1asOtY8OtIMO6xI1pbmt5OgoKMTMuMS4xIGFsbCByaWdodHMgZ3JhbnRlZCB0byB0aGUgSG9zcGl0YWwgdG8gdXNlIHRoZSBTb2Z0d2FyZSAxMy4xLjEgYXV0b21hdGlja8OpIHVrb27EjWVuw60gdsWhZWNoIHByw6F2LCBrdGVyw6EgYnlsYSBOZW1vY25pY2kKYW5kIHRoZSBTZXJ2aWNlIHdpfHwgYXV0b21hdGljYWxseXRlcm1pbmF0ZTsgdWTEm2xlbmEgbmEgdcW+w612YW7DrSBTb2Z0d2FydSBhIFNsdcW+Ynk7CgoxMy4xLjIgdGhlIEhvc3BpdGFsIG11c3QgdW5pbnN0YWxsIHRoZSBTb2Z0d2FyZSB3aXRob3V0IDEzLjEuMiBOZW1vY25pY2UgamUgcG92aW5uYSBuZXByb2RsZW7EmyBvZGluc3RhbG92YXQgU29mdHdhcmUKZGVsYXkgYW5kIChhdCBCcmFpbm9taXgncyBvcHRpb24pIG11c3QgZGVzdHJveSBvciBhIChwb2RsZSB1csSNZW7DrSBzcG9sZcSNbm9zdGkgQnJhaW5vbWl4KSBtdXPDrSB6bmnEjWl0IG5lYm8KcmV0dXJuIGF8fCBjb3BpZXMgb2YgdGhlIFNvZnR3YXJlIGFuZCB0aGUgdXNlciB2cmF0aXQgdsWhZWNobnkga29waWUgU29mdHdhcnUgYSB1xb5pdmF0ZWxza8OpCmRvY3VtZW50YXRpb24gdGhhdCB0aGUgSG9zcGl0YWwgaGFzIGluIGl0cyBkb2t1bWVudGFjZSwga3RlcsOpIG3DoSB2IGRyxb5lbsOtIG5lYm8gdmUgc3bDqSBkaXNwb3ppY2ksIGEKcG9zc2Vzc2lvbiBvciBjb250cm9sIGFuZCBjb25maXJtIHRvIEJyYWlub21peCBpbiBww61zZW1uxJsgc3BvbGXEjW5vc3RpIEJyYWlub21peCBwb3R2cmRpdCwgxb5lIHNpCndyaXRpbmcgdGhhdCB0aGUgSG9zcGl0YWwgaGFzIG5vdCBrZXB0IGFueSBjb3BpZXMgb2YgbmVwb25lY2hhbGEgxb5hZG7DqSBrb3BpZSBTb2Z0d2FydSBhbmkgdcW+aXZhdGVsc2vDqQp0aGUgU29mdHdhcmUgb3J0aGUgdXNlciBkb2N1bWVudGF0aW9uLiBkb2t1bWVudGFjZS4KCjEzLjIgY2xhdXNlczoxKFNjb3BlKSwyKERlZmluaXRpb25zKSw0LjEuNChjb21wZXRpbmdzZXJ2aWNlKSwgMTMuMiBVc3Rhbm92ZW7DrSDEjWzDoW5rxa86IDEgKFJvenNhaCksIDIgKERlZmluaWNlKSwgNC4xLjQoa29ua3VyZW7EjW7DrQoKc2x1xb5iYSksIDQuMi43IChvZHBvdsSbZG5vc3QgemEgVcW+aXZhdGVsZSksIDEwLjMuNCAow7pyb2spLCAxLjQKKHphcG/EjXRlbsOtKSwgOCAoUHLDoXZhIGR1xaFldm7DrWhvIHZsYXN0bmljdHbDrSksIDkgKMOaZGFqZSBOZW1vY25pY2UpLAoxMShNfMSNZW58aXZvc3QpLCAxMyAow5rEjWlua3kgdWtvbsSNZW7DrSksIDE0IChaw6FydWt5CmEgb2Rwb3bEm2Rub3N0KSwgMTUgKE5hcm9reSB0xZlldMOtY2ggc3RyYW4pIGEgMTYgKFbFoWVvYmVjbsOhCnVzdGFub3Zlbm8gesWvc3RhdmFqw60gcGxhdG5hIGEgw7rEjWlubsOhIGkgcG8gdWtvbsSNZW7DrSBTbWxvdXZ5LCBhIHRvCmJleiDEjWFzb3bDqWhvIG9tZXplbsOtLiDEjGFzdDEgUG9kbcOtbmVrIHpwcmFjb3bDoW7DrSBvc29ibsOtY2gKw7pkYWrFryB6xa9zdGFuZSBwbGF0bmEgYSDDusSNaW5uw6EgcG8gZG9idSwgcG8ga3Rlcm91IHNwb2xlxI1ub3N0CkJyYWlub21peCBuZWJvIG7Em2t0ZXLDvSBqZWrDrSBEw61sxI3DrSB6cHJhY292YXRlbCB6cHJhY292w6F2YWrDrSBwcm8KCiAKCiAKCkJyYWlub21peCBFdXJvcGUgTGltaXRlZApTdWl0ZSAxMDM4MAoKMjYvMjcgVXBwZXIgUGVtYnJva2UgU3RyZWV0CkR1YmxpbiAyIEQwMiwgWDM2MSBJcmVsYW5kCgogCgpQcm9jZXNzZXMgYW55IFBlcnNvbmFsIERhdGEgZm9yIHRoZSBIb3NwaXRhbCwgYnV0IGNsYXVzZXMgMTcKNyAoYm90aCBpbmNsdXNpdmUpIG9mIHRoZSBEYXRhIFByb2Nlc3NpbmcgVGVybXMgYW5kIHRoZQppbmRlbW5pdGllcyBpbiB0aGUgRGF0YSBQcm9jZXNzaW5nIFRlcm1zIHdpfHwgc3Vydml2ZSB0aGUKZXhwaXJ5IG9yIHRlcm1pbmF0aW9uIG9mIHRoZSBBZ3JlZW1lbnQgYW5kIGNvbnRpbnVlIGluIGZ1fHwKZm9yY2UgYW5kIGVmZmVjdCB3aXRob3V0IHxpbWl0IGluIHRpbWUuCgpOZW1vY25pY2kgT3NvYm7DrSDDumRhamUsIGF2xaFhayDEjWzDoW5reSAxIGHFviA3ICh2xI1ldG7EmykgUG9kbcOtbmVrCnpwcmFjb3bDoW7DrSBvc29ibsOtY2ggw7pkYWrFryBhIHVzdGFub3ZlbsOtIG8gbmFocmFkxJsgw7pqbXkKb2JzYcW+ZW5hIHYgUG9kbcOtbmthY2ggenByYWNvdsOhbsOtIG9zb2Juw61jaCDDumRhasWvIHrFr3N0YW5vdQpwbGF0bmEgYSDDusSNaW5uw6EgaSBwbyB1a29uxI1lbsOtIFNtbG91dnkgYmV6IMSNYXNvdsOpaG8gb21lemVuw60uCgogCgogCgogCgogCgogCgogCgoxNC4gV2FycmFudGllcyBhbmQgTGlhYmlsaXR5IDE0LiBaw6FydWt5IGEgb2Rwb3bEm2Rub3N0CgoxNC4xIEJyYWlub21peCB1bmRlcnRha2VzIHRvIHN1cHBseSB0aGUgU2VydmljZXMgaW4gZHV8eSBhbmQgMTQuMSBTcG9sZcSNbm9zdCBCcmFpbm9taXggc2UgemF3enVqZSBwb3NreXRvdmF0IFNsdcW+YnkgxZnDoWRuxJsgYQp0aW1lciBtYW5uZXIsIHdpdGggZHVlIHByb2Zlc3Npb25hbCBjYXJlLCBpbiB0aGUgcXVhbGl0eSB2xI1hcywgc29kYm9ybm91IHDDqcSNw60sIHZrdmFsaXTEmyBhIGRsZSBzdGFuZGFyZHUgYSBwb2Rtw61uZWsKYW5kIHN0YW5kYXJkIGFuZCB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgc2V0IG91dCBpbiB1amVkbmFuw71jaCB2dMOpdG8gU21sb3V2xJsuIFNwb2xlxI1ub3N0IEJyYWlub21peCBuZXBvc2t5dHVqZQp0aGlzIEFncmVlbWVudC4gQnJhaW5vbWl4IGRvZXMgbm90IG1ha2Ugb3IgZ2l2ZSBhbnkgamFrw6lrb2xpIHphcnVreSwga3RlcsOpIG5lanNvdSB2w71zbG92bsSbIHN0YW5vdmVueXZ0w6l0byBTbWxvdXbEmwp3YXJyYW50aWVzLCByZXByZXNlbnRhdGlvbnMsIG9yIGNvbmRpdGlvbnMgb2YgYW55IGtpbmQsIHRoYXQgbmVibyB6IG7DrSBpbXBsaWNpdG7EmyBuZXZ5cGzDvXZhasOtLCBwxZnDrXBhZG7EmyBrdGVyw6kgbmV2eXBsw712YWrDrSB6ZQphcmUgbm90IHN0YXRlZCBpbiBvciBpbXBsaWVkIGZyb20gdGhpcyBBZ3JlZW1lbnQgb3IgemFrb25hLiBKYWvDqWtvbGkgemFydWt5LCB6w6F2YXpreSBhIHBvdmlubm9zdGkgc3BvbGXEjW5vc3RpCmFsdGVybmF0aXZlbHksIHRob3NlIHRoYXQgZG8gbm90IGFyaXNlIGZyb20gdGhlIGxhdy4gLiBBbnkgQnJhaW5vbWl4LCBrdGVyw6kgYnkgcGx5bnVseSBaIE9iQ2hPZG7DrUNoIFpWVmtJT1N0w60nIHphdmVkZW7DqQphbmQgYWxsIHdhcnJhbnRpZXMsIHJlcHJlc2VudGF0aW9ucywgY29uZGl0aW9ucywgdGVybXMsIHByYXhldXN0cidhbiBuZWJvIGppbmFrLCBzZSB0w61tdG8gVlZJVcSMVUrDjSB2cm96c2FodSwgVixuxJttLMW9IHRvCnVuZGVydGFraW5ncyBhbmQgb2JsaWdhdGlvbnMgb24gdGhlIHBhcnQgb2YgQnJhaW5vbWl4IHVtb3pudWppIHByYcO9bnIgcHJlZHByc3l2KMWhJzU1OCBvZHN0LjIwYmNhbnNrZWhvIHpha29uaWt1KS4KaW1wbGllZCBieSB0cmFkZSB1c2FnZSwgZXN0YWJsaXNoZWQgcHJhY3RpY2UgYmV0d2VlbiB0aGUgVGltICduZW5yIGRvdGNlJ25vIHVscGxhdG5lbnIgcG92cm5ub3N0ciBzcG9sZWNub3N0cmxCcmFybm9tcngsClBhcnRpZXMgb3Igb3RoZXJ3aXNlIGFyZSBoZXJlYnkgZXhjbHVkZWQgdG8gdGhlIGV4dGVudCBrdGVyZXZ5eXBseXZhanIgcHJpbW8gWiBrb2dlbnRucmNoIHVzdGFub3ZlbmkgcHJhdm5pY2gKcGVybWl0dGVkIGJ5IGxhdyAoaW4gcGFydGljdWxhciBhcyBhbGxvd2VkIHVuZGVyIFNlY3Rpb24gcHJlZHBpc3UuICwg4oCeICwgLCBfCjU1OCgyKSBvZnRoZSBDaXZpbCBDb2RlKS4gRm9yIHRoZSBhdm9pZGFuY2Ugb2YgZG91YnQsIHRoaXMgVlpoJ2VkZW0gLCDigJxpICxQb3ZhemUsIFNQZnRXw4kn4oCcICciZm8nbWHFmW4nNmgsIFNWU0ZlJ0Z1cgpleGNsdXNpb24gZG9lcyBub3QgYWZmZWN0IGFueSBvYmxpZ2F0aW9ucyBvZiBCcmFpbm9taXggdGhhdCB0ZWxla29tdS1ubGthY25sY3ZoICdzeXN0ZW11IGEgfG50ZXJoZXR1IEJyYXJub21yayB6ZWptZW5hCmFyaXNlIGRpcmVjdGx5IGZyb20gbWFuZGF0b3J5IHByb3Zpc2lvbnMgb2ZhcHBsaWNhYmxlIGxhdy4uIG5lemFydWN1amUsdnplICLDjSdWxZlmbicgNm9mdHdhcnUgYSBTbHV6YnkgYnVkZSBiZXogcHJlcnVzZW5yIDAKbG4gcGFydGljdWxhciwgYmVjYXVzZSBvZiB0aGUgbmF0dXJlIG9mIHNvZnR3YXJlLCBiZXogemF2YWQsIHplIGthemRhIHphdmFkYSwgY2h5YmEgbmVibyBuZWRvc3RhdGVrIFNvZnR3YXJ1CmluZm9ybWF0aW9uIHN5c3RlbXMsIHRlfGVjb21tdW5pY2F0aW9ucyBzeXN0ZW1zIGFuZCB0aGUgbmVibyBTSVVaUFYgV28iIG9kc3RyYW5ydGVsaGUgbmVibyDFmWUgU29mdHdhcmUgbmVibyBTbHXFvmJhCmludGVybmV0LCBCcmFpbm9taXggZG9lcyBub3Qgd2FycmFudCB0aGF0IHRoZSB1c2Ugb2YgdGhlIGJ1ZG91IFpQRlNPYidJZSBrIHByb3BvamVuaSBTSk0iIGFwbCdrxZljxaUgTmVtb2NuaWNlIG5lYm8gemUKU29mdHdhcmUgYW5kIHRoZSBTZXJ2aWNlIHdpbGwgYmUgdW5pbnRlcnJ1cHRlZCBvciBlcnJvcnIgYnVkb3UgU2pybm91IGFwbCdrYWMnIE5lbW9jbmljZSBrb21wYXQnYidsbQpmcmVlOyBub3IgdGhhdCBldmVyeSBkZWZlY3QsIGVycm9yIG9yIGRlZmljaWVuY3kgaW4gdGhlClNvZnR3YXJlIG9yIHRoZSBTZXJ2aWNlIGNhbiBiZSByZWN0aWZpZWQsIG9yIHRoYXQgdGhlClNvZnR3YXJlIG9yIHRoZSBTZXJ2aWNlIGlzIGNhcGFibGUgb2YgYmVpbmcgaW50ZXJmYWNlZCB3aXRoLApvciBpcyBvciB3aWxsIGJlIGNvbXBhdGlibGUgd2l0aCwgYW55IGFwcGxpY2F0aW9uIG9mIHRoZQpIb3NwaXRhbC4KCjE0LjIgQnJhaW5vbWl4IHdpbGwgbm90IGJlIHxpYWJ8ZSBmb3IgYW55IHByb2JsZW0gd2l0aCwgb3IgYW55IDE0LjIgQnJhaW5vbWl4IG5lb2Rwb3bDrWTDoSB6YSBwcm9ibMOpbXkgc2UgU29mdHdhcmVtIG5lYm8KZGV8YXkgb3IgaW50ZXJydXB0aW9uIGluIHRoZSBTb2Z0d2FyZSBvciB0aGUgU2VydmljZSBvciBmb3IgU2x1xb5ib3UsIHphIHpwb8W+ZMSbbsOtIMSNaSB2w71wYWRreSBTb2Z0d2FydSBuZWJvIFNsdcW+YnksIGFuaSB6YQphbnkgbG9zcyBvciBkYW1hZ2UgcmVzdWx0aW5nIGZyb20gdGhlIHRyYW5zZmVyIG9mIGRhdGEgKG9yIHp0cmF0eSDEjWkgw7pqbXUsIHBva3VkIGpzb3UgdHl0byB6cMWvc29iZW7DqSBwxZllbm9zZW0gZGF0IChuZWJvCnRoZSBmYWlsdXJlIHRvIHRyYW5zZmVyIGRhdGEpIG92ZXIgdGhlIEhvc3BpdGFsJ3MgbmV0d29yayBzZWxoYW7DrW0gcMWZZW5vc3UgZGF0KSBwxZllcyBzw63FpW92w6EgcMWZaXBvamVuw60gTmVtb2NuaWNlIG5lYm8KY29ubmVjdGlvbnMgb3IgdGV8ZWNvbW11bmljYXRpb25zIGxpbmtzIGFuZCB0aGUgaW50ZXJuZXQsIHDFmWVzIHRlbGVrb211bmlrYcSNbsOtIHDFmWlwb2plbsOtIGEgcMWZZXMgaW50ZXJuZXQuIE5lbW9jbmljZSBiZXJlCmFuZCB0aGUgSG9zcGl0YWwgYWNrbm93bGVkZ2VzIHRoYXQgdGhlIFNvZnR3YXJlIGFuZCB0aGUgbmEgdsSbZG9tw60sIMW+ZSBwxZlpIHBvdcW+w612w6Fuw60gU29mdHdhcnUgbmVibyBTbHXFvmJ5IG1vaG91ClNlcnZpY2UgbWF5IGJlIHN1YmplY3QgdG8gfGltaXRhdGlvbnMsIGRlfGF5cyBhbmQgb3RoZXIgdnpuaWthdCBvbWV6ZW7DrSwgenBvxb5kxJtuw61uZWJvamluw6kgcHJvYmzDqW15LCBrdGVyw6kgb2J2eWtsZSBwxZlpCnByb2JsZW1zIGluaGVyZW50IGluIHRoZSB1c2Ugb2Ygc3VjaCBjb21tdW5pY2F0aW9ucyB2eXXFvml0w610YWtvdsO9Y2gga29tdW5pa2HEjW7DrWNoIHPDrXTDrWF6YcWZw616ZW7DrXZ6bmlrYWrDrS4KbmV0d29ya3NhbmQgZmFjaWxpdGllcy4KCjE0LjMgVGhlIEhvc3BpdGFsIGFja25vd2xlZGdlcyB0aGF0IHRoZSBiZW5lZml0cyBvZiB1c2luZyB0aGUgMTQuMyBOZW1vY25pY2UgYmVyZSBuYSB2xJtkb23DrSwgxb5lIHDFmcOtbm9zIHogdcW+w612w6Fuw60gU29mdHdhcnUgYQpTb2Z0d2FyZSBhbmQgdGhlIFNlcnZpY2UgYXJlIGRlcGVuZGVudCBvbiB0aGUgSG9zcGl0YWwgU2x1xb5ieWplIHrDoXZpc2zDvSBuYSB0b20sIHpkYSBOZW1vY25pY2UgYSBVxb5pdmF0ZWzDqSBwxZlpIHphZMOhdsOhbsOtCmFuZCBVc2VycyBleGVyY2lzaW5nIHByb3BlciBwcm9mZXNzaW9uYWwgc2tpbGwsIGNhcmUgYW5kIMOaZGFqxa8gTmVtb2NuaWNlIGEgcMWZaSBpbnRlcnByZXRhY2kgVsO9c2xlZGvFryBOZW1vY25pY2UgYQpqdWRnZW1lbnQgaW4gaW5wdXR0aW5nIHRoZSBIb3NwaXRhbCBEYXRhIGFuZCBpbiBkYWzFocOtY2ggaW5mb3JtYWPDrSBhIGRhdCB0w71jaCBwcm9zdMWZZWRuaWN0dsOtbSBTb2Z0d2FydSBhCmludGVycHJldGluZ3RoZSBIb3NwaXRhbFJlc3VJdHNhbmQgb3RoZXJpbmZvcm1hdGlvbiBhbmQgU2x1xb5ieSDFmWFkbsSbIHVwbGF0bsOtIHBvdMWZZWJuw6kgb2Rib3Juw6kgZG92ZWRub3N0aSwgcMOpxI1pIGEKZGF0YSByZWNlaXZlZCB2aWEgdGhlIFNvZnR3YXJlIGFuZCB0aGUgU2VydmljZS4gQnJhaW5vbWl4IMO6c3VkZWsuIEJyYWlub21peCBuZW9kcG92w61kw6EgemEgY2h5YnkgYW5pIHphIG5lw7pwbG5vc3Qgw5pkYWrFrwp3aWxsIG5vdCBiZSB8aWFifGUgZm9yIGFueSBlcnJvciBvciBpbmNvbXBsZXRlbmVzcyBpbiB0aGUgTmVtb2NuaWNlIG5lYm8gVsO9c2xlZGvFryBOZW1vY25pY2UgYW5pIHphIG5hc2xlZGt5Ckhvc3BpdGFsIERhdGEgb3IgdGhlIEhvc3BpdGFsIFJlc3VsdHMgb3IgdGhlIGNvbnNlcXVlbmNlcyBqYWvDqWhva29saSByb3pob2RudXTDrSwga3RlcsOpIE5lbW9jbmljZSwgVcW+aXZhdGVsIG5lYm8gamluw6EKb2YgYW55IGRlY2lzaW9uIHRha2VuIGJ5IHRoZSBIb3NwaXRhbCwgYW55IFVzZXIsIG9yIGFueSBvc29iYSB1xI1pbsOtIG5hIHrDoWtsYWTEmyB0YWtvdsO9Y2ggaW5mb3JtYWPDrSwgZGF0IG5lYm8gdsO9c2xlZGvFrywKb3RoZXIgcGVyc29uLCBvbiB0aGUgYmFzaXMgb2YgdGhhdCBpbmZvcm1hdGlvbiBvciBkYXRhIG9yIHBva3VkIHNlIG5lamVkbsOhIG8gemF2aW7Em27DrSBCcmFpbm9taXggbmVibyBjaHlidSDEjWkgdmFkeQp0aG9zZSByZXN1bHRzIHVubGVzcyBpdCBpcyBCcmFpbm9taXgncyBmYXV8dCBvciBhbiBlcnJvciBvciBTb2Z0d2FyZSBuZWJvIFNsdcW+YnkuCmRlZmVjdCBpbiB0aGUgU29mdHdhcmUgb3IgU2VydmljZXMuCgoxNC40IFN1YmplY3QgdG8gY2xhdXNlIDE0LjcgYmVsb3csIEJyYWlub21peCB3aWxsIG5vdCBiZSB8aWFifGUgMTQuNCBTIHbDvWppbWtvdSBwxZnDrXBhZMWvIHN0YW5vdmVuw71jaCB2IMSNbC4gMTQuNyB0w6l0byBTbWxvdXZ5IHBsYXTDrSwgxb5lCgpmb3IgY2F1c2VkIGRhbWFnZSB0byB0aGUgZXh0ZW50IHRoYXQgZGFtYWdlIGlzIGNhdXNlZCBieToKCkJyYWlub21peCBuZW9kcG92w61kw6EgemEgw7pqbXUgdiByb3pzYWh1LCB2IG7Em23FvjoKCiAKCiAKCjE0LjQuMSB0aGUgdXNlIG9mdGhlIFNvZnR3YXJlIG9yIHRoZSBTZXJ2aWNlIGJ5IHRoZSBIb3NwaXRhbApvciBhbnkgVXNlciBjb250cmFyeSB0byBCcmFpbm9taXgncyB3cml0dGVuCgogCgoxNC40LjEgTmVtb2NuaWNlIG5lYm8gVcW+aXZhdGVsIHXFvml8aSBTb2Z0d2FyZSBuZWJvIFNsdcW+YnUgdgpyb3pwb3J1IHMgcMOtc2VtbsO9bWkgcG9reW55IHNwb2xlxI1ub3N0aSBCcmFpbm9taXggbmVibwoKIAoKIAoKQnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRDAyLCBYMzYxIElyZWxhbmQKCiAKCmluc3RydWN0aW9ucyBvciB0aGUgdGVybXMgb2YgdGhlIEFncmVlbWVudDsKCnYgcm96cG9ydSBzIHBvZG3DrW5rYW1pIFNtbG91dnk7CgogCgoxNC40LjIgYW55IGRlbGF5IG9yIGZhaWx1cmUgb24gdGhlIHBhcnQgb2YgdGhlIEhvc3BpdGFsIG9yIGFueQpVc2VyIGluIHByb3ZpZGluZyBhbnkgaW5mb3JtYXRpb24gb3IgZGF0YSB0bwpCcmFpbm9taXggYXMgc3RhdGVkIGluIHRoaXMgQWdyZWVtZW50IG9yIHRvIG5vdGlmeQpCcmFpbm9taXggb2YgYW55IGVycm9yIGluIHRoZSBIb3NwaXRhbCBEYXRhIG9yIG9mIGFueQphY3R1YWwgb3Igc3VzcGVjdGVkIGRlZmVjdCBvciBvZiBhbnkgZmFpbHVyZSBvZiwgb3IKZmF1bHQsIGVycm9yIG9yIGJ1ZyBpbiwgYW55IGVxdWlwbWVudCwgc29mdHdhcmUsCm5ldHdvcmsgb3IgdGV8ZWNvbW11bmljYXRpb25zIHN5c3RlbTsgb3IgYW55IG90aGVyCnVufGF3ZnV8IGFjdCBvciBvbWlzc2lvbiBvbiB0aGUgcGFydCBvZiB0aGUgSG9zcGl0YWwKb3IgYW55IFVzZXI7IG9yCgoxNC40LjIKCk5lbW9jbmljZSBuZWJvIFXFvml2YXRlbCBieWxpIHYgcHJvZGxlbsOtIHMgcG9za3l0bnV0w61tCmluZm9ybWFjw60gbmVibyBkYXQgZGxlIHTDqXRvIFNtbG91dnkgbmVibyB0eXRvIG5lcG9za3l0bGkKc3BvbGXEjW5vc3RpIEJyYWlub21peCB2xa9iZWMgbmVibyBuZWluZm9ybW92YWxpCnNwb2xlxI1ub3N0IEJyYWlub21peCBvIGNoeWLEmyB2w5pkYWrDrWNoIE5lbW9jbmljZSwgbwp6w6F2YWTEmyBuZWJvIG9wb2RlesWZZW7DrSBuYSB6w6F2YWR1LCBvIHNlbGjDoW7DrSwKcHJvZ3JhbcOhdG9yc2vDqSBuZWJvIGppbsOpIGNoeWLEmyB2amFrw6lta29saSB6YcWZw616ZW7DrSwKc29mdHdhcnUsIHNpdGkgbmVibyB0ZWxla29tdW5pa2HEjW7DrW0gc3lzdMOpbXU7IG5lYm8KZG/FoWxvIGsgamluw6ltdSBwcm90aXByw6F2bsOtbXUgamVkbsOhbsOtIG5lYm8gb3BvbWVudXTDrQpuYSBzdHJhbsSbIE5lbW9jbmljZSBuZWJvIFXFvml2YXRlbGU7IG5lYm8KCiAKCjE0LjQuMyB0aGUgbW9kaWZpY2F0aW9uIG9yIGF8dGVyYXRpb24gb2Z0aGUgU29mdHdhcmUgb3IgdGhlClNlcnZpY2UgYnkgYW55b25lIGV4Y2VwdCBCcmFpbm9taXggb3IgQnJhaW5vbWl4J3MKc3VwcGxpZXJzLgoKMTQuNC4zCgpTb2Z0d2FyZSBuZWJvIFNsdcW+YmEgYnlseSB1cHJhdmVueSBuZWJvIHBvem3Em27Em255Cmppbm91IG9zb2JvdSBuZcW+IHNwb2xlxI1ub3N0w60gQnJhaW5vbWl4IG5lYm8gamVqw61tCnBvZG9kYXZhdGVsZW0uCgogCgoxNC41IFN1YmplY3QgdG8gY2xhdXNlIDE0LjcgYmVsb3csIEJyYWlub21peCdzIHRvdGFsIGxpYWJpbGl0eSBpbgpjb25uZWN0aW9uIHdpdGggdGhlIEFncmVlbWVudCwgd2hldGhlciBpbiBjb250cmFjdCwgb3IgdG9ydAooaW5jbHVkaW5nLCB3aXRob3V0IGxpbWl0YXRpb24sIG5lZ2xpZ2VuY2UpIG9yIGFyaXNpbmcgaW4gYW55Cm90aGVyIHdheSwgd2lsbCBub3QgZXhjZWVkIHRoZSBjaGFyZ2VzIHBhaWQgYnl0aGUgSG9zcGl0YWwKd2l0aGluIHRoZSBkdXJhdGlvbiBvZnRoZSBBZ3JlZW1lbnQuCgoxNC41CgpTIHbDvWppbWtvdSBwxZnDrXBhZMWvIHN0YW5vdmVuw71jaCB2IMSNbC4gMTQuNyB0w6l0byBTbWxvdXZ5IHBsYXTDrSwgxb5lCmNlbGtvdmEgdsO9xaFlIMO6am15LCB6YSBuw63FviBzcG9sZcSNbm9zdCBCcmFpbm9taXggb2Rwb3bDrWTDoSBuYQp6w6FrbGFkxJsgdMOpdG8gU21sb3V2eSwgYcWlIGppxb4gemEgcG9ydcWhZW7DrSBzbWxvdXZ5IG5lYm8gcHLDoXZuw61jaApwxZllZHBpc8WvIChhIHRvIGkgeiBuZWRiYWxvc3RpKSBuZWJvIHZ6bmlrbMOpIGppbmFrLCBuZXNtw60KcMWZZXPDoWhub3V0IHbDvcWhaSBPZG3Em255IHVocmF6ZW7DqSBOZW1vY25pY8OtIHphIGRvYnUgdHJ2w6Fuw60KU21sb3V2eS4KCiAKCiAKCiAKCiAKCjE0LjYgU3ViamVjdCB0byBjbGF1c2UgMTQuNyBiZWxvdywgYnV0IG90aGVyd2lzZSBkZXNwaXRlIDE0LjYgUyB2w71qaW1rb3UgcMWZw61wYWTFryBzdGFub3ZlbsO9Y2ggdiDEjWwuIDE0LjcgdMOpdG8gU21sb3V2eSwgYXbFoWFrCmFueXRoaW5nIGVsc2UgY29udGFpbmVkIGluIHRoaXMgQWdyZWVtZW50LCBCcmFpbm9taXggd2l8fCBiZXogb2hsZWR1IG5hIGpha8Opa29saSBkYWzFocOtIHVzdGFub3ZlbsOtIHTDqXRvIFNtbG91dnksIHBsYXTDrSwgxb5lCm5vdCBiZSB8aWFifGUgdG8gdGhlIEhvc3BpdGFsIGZvciBhbnkgbG9zcyBvZiBwcm9maXQsIGxvc3Mgb2YgQnJhaW5vbWl4IG5lbmVzZSB2xa/EjWkgTmVtb2NuaWNpIG9kcG92xJtkbm9zdCB6YSBqYWvDvWtvbGkgdcWhbMO9CnJldmVudWUsIGxvc3Mgb2Ygc2F2aW5ncywgbG9zcyBvciBzcG9pbGluZyBvZiBkYXRhIChpLmUuIHppc2ssIHp0cmF0dSB2w71ub3PFrywgenRyYXR1IMO6c3BvciwgenRyYXR1IG5lYm8gcG/FoWtvemVuw60gZGF0Ckhvc3BpdGFsIERhdGEgb3IgSG9zcGl0YWwgUmVzdWx0cykgc3RvcmVkIG9yIHByb2Nlc3NlZCAow5pkYWrFryBOZW1vY25pY2UgbmVibyBWw71zbGVka8WvIE5lbW9jbmljZSkgdWtsYWRhbsO9Y2ggxI1pCnRocm91Z2ggdGhlIFNvZnR3YXJlIG9yIHRoZSBTZXJ2aWNlLCBleGNlcHQgaW4gY2FzZXMgdW5kZXIgenByYWNvdsOhdmFuw71jaCBwcm9zdMWZZWRuaWN0dsOtbSBTb2Z0d2FydSBuZWJvIFNsdcW+YnksIG5lamRlcmxpCmNsYXVzZXMgNy4xIGFuZCAxNC43LCBsb3NzIG9mIG9wcG9ydHVuaXR5LCBsb3NzIG9mIHVzZSwgbG9zcyBvZiBvIHDFmcOtcGFkeSBkbGUgxI1sLiA3LjEgYSAxNC43LCB6dHJhdHUgcMWZw61sZcW+aXRvc3RpLCB6dHJhdHUgdcW+aXTDrSwgdcWhbMO9CmJ1c2luZXNzIG9yIGxvc3Mgb2YgZ29vZHdpbGwgKGluIGVhY2ggY2FzZSB3aGV0aGVyIGRpcmVjdCBvciBvYmNob2QgbmVibyBwb8Wha296ZW7DrSBkb2Jyw6lobyBqbcOpbmEgKHUga2HFvmTDqSB6IHV2ZWRlbsO9Y2gKaW5kaXJlY3QpIG9yIGZvciBhbnkgaW5kaXJlY3Qgb3IgY29uc2VxdWVudGlhbCBsb3NzLCB3aGljaCB2w71sdWsgYmV6IG9obGVkdSBuYSB0bywgemRhIGplIHDFmcOtbcOhIG5lYm8gbmVwxZnDrW3DoSksIGFuaSB6YQphcmlzZXMgb3V0IG9mIG9yIGluIGNvbm5lY3Rpb24gd2l0aCB1c2Ugb2YsIG9yIHRoZSBzdXBwbHkgb3Igc2VrdW5kw6FybsOtIMSNaSBuw6FzbGVkbm91IMO6am11LCBrdGVyw6kgdnpuaWtub3UgMSBuZWJvCmZhaWx1cmUgdG8gc3VwcGx5LCB0aGUgU29mdHdhcmUgb3IgYW55IG9mIHRoZSBTZXJ2aWNlcyBvciBpbiB2c291dmlzbG9zdGkgcyB1xb5pdMOtbSwgZG9kYW7DrW0gbmVibyBuZWRvZGEgw61tIFNvZnR3YXJ1IG5lYm8KYW55IG90aGVyIHdheSBpbiBjb25uZWN0aW9uIHdpdGggdGhlIHN1YmplY3QgbWF0dGVyIG9mIHRoZSBTbHXFvmJ5IG5lYm8gdiBzb3V2aXNsb3N0aSBzIHDFmWVkbcSbdGVtIHTDqXRvIFNtbG91dnkgKGHFpSBqacW+CkFncmVlbWVudCAod2hldGhlciBpbiBjb250cmFjdCwgb3J0b3J0IChpbmNsdWRpbmcsIHdpdGhvdXQgcG9ydcWhZW7DrW0gc21sdXZuw60gcG92aW5ub3N0aSDEjWkgcG92aW5ub3N0aSBzdGFub3ZlbsOpCmxpbWl0YXRpb24sIG5lZ2xpZ2VuY2UpIG9yIGFyaXNpbmcgaW4gYW55IG90aGVyIHdheSksIGV2ZW4gaWYgdiBwcsOhdm7DrWNoIHDFmWVkcGlzZWNoLCBhIHRvIGkgeiBuZWRiYWxvc3RpLCBuZWJvIGppbmFrKSwgYSB0byBpdgpCcmFpbm9taXggaGFkIGJlZW4gYWR2aXNlZCBvZiwgb3Iga25ldyBvZiwgdGhlIHxpa2V8aWhvb2QgcMWZw61wYWTEmywgxb5lIHNwb2xlxI1ub3N0IEJyYWlub21peCBieWxhIHDFmWVkZW0gdXBvem9ybsSbbmEgbmEKb2YgdGhhdCBsb3NzIG9yIHR5cGUgb2YgbG9zcyBhcmlzaW5nKS4gcHJhdmTEm3BvZG9ibm9zdCB2em5pa3UgdGFrb3bDqSDDumpteSBuZWJvIHRha292w6lobyB0eXB1IMO6am15CgpuZWJvIG8gcHJhdmTEm3BvZG9ibm9zdGkgamVqw61obyB2em5pa3UgdsSbZMSbbGEuCgoxNC43IE5vdGhpbmcgaW4gdGhlIEFncmVlbWVudCBsaW1pdHMgb3IgZXhjbHVkZXMgQnJhaW5vbWl4J3MgMTQuNyBOaWMgdmUgU21sb3V2xJsgbmVvbWV6dWplIGFuaSBuZXZ5bHXEjXVqZSBvZHBvdsSbZG5vc3QKbGlhYmlsaXR5IGZvciBmcmF1ZCwgaW50ZW50aW9uIG9yIGdyb3NzIG5lZ2xpZ2VuY2Ugb3IgYW55IGxvc3Mgc3BvbGXEjW5vc3RpIEJyYWlub21peCB2IHDFmcOtcGFkxJsgcG9kdm9kbsOpaG8gamVkbmFuw60sIMO6am15Cm9mIGRhbWFnZSBjYXVzZWQgYnkgaW5mcmluZ2luZyB0aGUgbmF0dXJhbCByaWdodHMgb2YgYSB6cMWvc29iZW7DqSDDum15c2xuxJsgxI1pIHpocnViw6kgbmVkYmFsb3N0aSwgw7pqbXkgenDFr3NvYmVuw6kKbmF0dXJhbCBwZXJzb24gb3IgZm9yIGFueSBvdGhlciBsaWFiaWxpdHkgd2hpY2ggbWF5IG5vdCwgYnkgesOhc2FoZW0gZG8gcMWZaXJvemVuw71jaCBwcmF2IGZ5emlja8OpIG9zb2J5LCBhbmkgamlub3UKbGF3LCBiZSBsaW1pdGVkIG9yIGV4Y2x1ZGVkLiBvZHBvdsSbZG5vc3QsIGt0ZXJvdSB6ZSB6w6Frb25hIG5lbHplIG9tZXppdCBuZWJvIHZ5bG91xI1pdC4KCjE1LiBUaGlyZCBQYXJ0eSBDbGFpbXMgMTUuIE7DoXJva3kgdMWZZXTDrWNoIHN0cmFuCgoxNS4xIFRoZSBIb3NwaXRhbCB3aXx8IGluZGVtbmlmeSBCcmFpbm9taXggYW5kIEJyYWlub21peCBVSyAxNS4xIE5lbW9jbmljZSBzZSB6YXZhenVqZSBuYWhyYWRpdCBzcG9sZcSNbm9zdGkgQnJhaW5vbWl4IMO6am11LAoKYWdhaW5zdCBhbnkgYW5kIGFsbCBjb3N0cywgbG9zc2VzIGFuZCBleHBlbnNlcyB0aGF0CnxuZGVtbmlmaWVkIFBlcnNvbiBzdWZmZXJzIG9yIGluY3VycyBhcyBhIHJlc3VsdCBvZiBhbnkgY2xhaW0Kb3IgcHJvY2VlZGluZ3MgYnJvdWdodCBieSBhbnkgdGhpcmQgcGFydHk6CgprdGVyw6EgasOtIHZ6bmlrbmUgdmTFr3NsZWRrdSBuYXJva3Ugw7pzcMSbxaFuxJsgdXBsYXRuxJtuw6lobyB0xZlldMOtCm9zb2JvdSB2cmFtY2kgc291ZG7DrWhvIMWZw616ZW7DrSwgcG9rdWQgcG92aW5ub3N0IGtuYWhyYWTEmwp0YWtvdsOpIMO6am15IHZ5cGzDvXbDoSBwcm8gTmVtb2NuaWNpIHDFmcOtbW8gemUgesOha29uYSwgYSB0bzoKCiAKCiAKCjE1LjEuMSB0byB0aGUgZWZmZWN0IHRoYXQgdGhlIEhvc3BpdGFsIERhdGEgb3IgdGhlIEhvc3BpdGFsClJlc3VsdHMgKG9yIGJvdGgpIGJyZWFjaCBvciBpbmZyaW5nZSBhbnkgdGhpcmRycGFydHkKcmlnaHRzOyBvcgoKIAoKMTUuMS4xIHYgcMWZw61wYWTEmywgxb5lIMOaZGFqaSBOZW1vY25pY2UgbmVibyBWw71zbGVka3kgTmVtb2NuaWNlCihuZWJvIG9ib2rDrW0pIGJ1ZG91IHBvcnXFoWVuYSBwcmF2YSB0xZlldMOtY2ggb3NvYjsgbmVibwoKIAoKIAoKQnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRDAyLCBYMzYxIElyZWxhbmQKCiAKCjE1LjEuMiBhcmlzaW5nIGZyb20gdGhlIEhvc3BpdGFsJ3MgdXNlIG9mIHRoZSBTb2Z0d2FyZSBvciB0aGUKU2VydmljZSAob3IgYm90aCkgaW4gYnJlYWNoIG9mIHRoZSBBZ3JlZW1lbnQgb3IgdGhlCmxhdwoKKGVhY2ggYmVpbmcgYW4gSW5kZW1uaWZpZWQgQ2xhaW0pLgoKMTUuMS4ydnDFmcOtcGFkxJssIMW+ZSBOZW1vY25pY2UgdcW+w612YSBTb2Z0d2FyZSBuZWJvIFNsdcW+YnUKCihuZWJvIG9ib2rDrSkgdiByb3pwb3J1IHNlIFNtbG91dm91IG5lYm8gcyBwcsOhdm7DrW1pCnDFmWVkcGlzeQoKKGTDoWxlIGplbiDigJ51cGxhdG7Em27DvSBuw6Fyb2siKS4KCiAKCiAKCiAKCjE1LjIgQnJhaW5vbWl4IHdpfHwgdXNlIGF8fGVuZGVhdm91cnMgdG8gZGVmZW5kIGFueXxuZGVtbmlmaWVkIDE1LjIgQnJhaW5vbWl4IHZ5dmluZSB2ZcWha2Vyw6kgdSBpfMOtIGJyw6FuaXQgc2UgcHJvdGkga2HFvmTDqW11CkNsYWltIG1hZGUgYWdhaW5zdCBpdCBhbmQgdG8gbWl0aWdhdGUgaXRzIGxvc3NlcywgfGlhYml8aXRpZXMsIHVwbGF0bsSbbsOpbXUgbmFyb2t1LCBrdGVyw70gdsWvxI1pIG7DrSBidWRlIHZ6bmVzZW4sIGEgY28gbmVqdsOtY2UKY29zdHMsYW5kIGV4cGVuc2VzYXJpc2luZyBmcm9tIGFueXxuZGVtbmlmaWVkIENsYWltLiBvbWV6aXQgc3bDqSB6dHJhdHksIHrDoXZhemt5LCBuw6FrbGFkeSBhIHbDvWRhamUsIGplxb4gYnkgegoKdXBsYXRuxJtuw6lobyBuYXJva3UgdnlwbHludWx5LgoKMTUuMyB8ZiBCcmFpbm9taXgsIGluIGV4ZXJjaXNpbmcgcHJvZmVzc2lvbmFsIHBydWRlbmNlLCBiZWxpZXZlcyAxNS4zIFBva3VkIHNlIEJyYWlub21peCBwxZlpIHVwbGF0bsSbbsOtIHByb2Zlc2lvbmFsbsOtIG3DrXJ5Cgp0aGF0dGhlIFNvZnR3YXJlIG9yIHRoZSBTZXJ2aWNlIGluZnJpbmdlcyBvciBtYXkgaW5mcmluZ2UgdGhlCnJpZ2h0cyBvZiBhbnkgdGhpcmQgcGFydHksIG9yIGlmIEJyYWlub21peCBiZWNvbWVzIGF3YXJlIG9mCmFueSBjfGFpbSBvciBwb3RlbnRpYWwgY3xhaW0gdGhhdCB0aGUgU29mdHdhcmUgb3IgdGhlIFNlcnZpY2UKaW5mcmluZ2VzIHRoZSByaWdodHMgb2YgYW55IHRoaXJkIHBhcnR5LCBCcmFpbm9taXggd2lsbCBiZQplbnRpdHxlZCB0bzoKCm9iZXrFmWV0bm9zdGkgZG9tbsOtdsOhLCDFvmUgU29mdHdhcmUgbmVibyBTbHXFvmJhIHBvcnXFoXVqw60gbmVibyBieQptb2hseSBwb3J1xaFpdCBwcmF2YSB0xZlldMOtIG9zb2J5LCBuZWJvIHBva3VkIHNlIGRvenbDrSBvIG5hcm9rdQpuZWJvIHBvdGVuY2nDoWxuw61tIG5hcm9rdSB2eXBsw712YWrDrWPDrW0geiB0b2hvLCDFvmUgU29mdHdhcmUgbmVibwpTbHXFvmJhIHBvcnXFoXVqw60gcHJhdmEgdMWZZXTDrSBvc29ieSwgbcWvxb5lIHXEjWluaXQgbmFzbGVkdWrDrWPDrToKCiAKCjE1LjMuMSBwcm9jdXJlIHRoZSByaWdodCBmb3IgdGhlIEhvc3BpdGFsIHRvIGNvbnRpbnVlIHVzaW5nCnRoZSBTb2Z0d2FyZSBhbmQgdGhlIFNlcnZpY2U7CgoxNS4zLjEKCm9ic3RhcmF0IHBybyBOZW1vY25pY2kKU29mdHdhcnUgYSBTbHXFvmJ5OwoKcHJhdm8gcG9rcmHEjW92YXQgdnXFvsOtdmFuw60KCiAKCjE1LjMuMiBtYWtlIHN1Y2ggYXx0ZXJhdGlvbnMsIG1vZGlmaWNhdGlvbnMgb3IgYWRqdXN0bWVudHMKdG8gdGhlIFNvZnR3YXJlIG9yIHRoZSBTZXJ2aWNlIChvciBib3RoKSBzbyB0aGF0IHRoZQpTb2Z0d2FyZSBhbmQgdGhlIFNlcnZpY2UgYmVjb21lIG5vbnJpbmZyaW5naW5nCndpdGhvdXQgZW50YWl8aW5nIGEgbWF0ZXJpYXwgZGltaW51dGlvbiBpbgoKcGVyZm9ybWFuY2Ugb3IgZnVuY3Rpb25hbGl0eTsgb3IKCjE1LjMuMgoKcHJvdsOpc3QgdiBTb2Z0d2FydSBuZWJvIHZlIFNsdcW+YsSbIChuZWJvIHYgb2JvdSkgem3Em255LArDunByYXZ5IG5lYm8gcMWZaXpwxa9zb2JlbsOtIHRhaywgYWJ5IFNvZnR3YXJlIGEgU2x1xb5iYQpwxZllc3RhbHkgcG9ydcWhb3ZhdCBwcmF2YSB0xZlldMOtIG9zb2J5LCBwxZlpxI1lbcW+IGJ1ZGUgZGJhdCwKYWJ5IG5lZG/FoWxvIGsgesOhc2FkbsOtbXUgc27DrcW+ZW7DrSBqZWppY2ggdsO9a29udSBuZWJvCmZ1bmvEjW5vc3RpOyBuZWJvCgogCgoxNS4zLjMgcmVwbGFjZSB0aGUgU29mdHdhcmUgb3IgdGhlIFNlcnZpY2UgKG9yIGJvdGgpIHdpdGgKbm9ucmluZnJpbmdpbmcgc3Vic3RpdHV0ZXMgcHJvdmlkZWQgdGhhdCBzdWNoCnN1YnN0aXR1dGVzIGRvIG5vdCBlbnRhaXwgYSBtYXRlcmlhfCBkaW1pbnV0aW9uIGluCgpwZXJmb3JtYW5jZSBvciBmdW5jdGlvbmFsaXR5LgoKMTUuMy4zCgpuYWhyYWRpdCBTb2Z0d2FyZSBuZWJvIFNsdcW+YnUgKG5lYm8gb2JvasOtKSBqaW7DvW1pLCBrdGVyw6kKbmVidWRvdSBwb3J1xaFvdmF0IHByYXZhIHTFmWV0w60gb3NvYnksIHDFmWnEjWVtxb4gdsWhYWsgdGFrb3ZhCm5haHJhZGEgbmVidWRlIG3DrXQgemEgbsOhc2xlZGVrIHrDoXNhZG7DrSBzbsOtxb5lbsOtIGplamljaAp2w71rb251IG5lYm8gZnVua8SNbm9zdGkuCgogCgogCgogCgogCgogCgoxNS40IEluIHRoZSBjYXNlcyBzcGVjaWZpZWQgaW4gQ2xhdXNlIDE1LjMgb2YgdGhpcyBBZ3JlZW1lbnQsIHRoZSAxNS40IFYgcMWZw61wYWRlY2ggdXZlZGVuw71jaCB2IHVzdGFub3ZlbsOtIDE1LjMgdMOpdG8gU21sb3V2eSBtYQpIb3NwaXRhbCBzaGFsbCBoYXZlIHRoZSByaWdodCB0byB0ZXJtaW5hdGUgdGhpcyBBZ3JlZW1lbnQgYnkgTmVtb2NuaWNlIG1vxb5ub3N0IHVrb27EjWl0IHR1dG8gU21sb3V2dSBww61zZW1ub3UgdsO9cG92xJtkw60sCndyaXR0ZW4gbm90aWNlIGlmIEJyYWlub21peCBmYWlscyB0byBpbXBsZW1lbnQgb25lIG9mIHRoZSBwb2t1ZCBCcmFpbm9taXggdmUgbGjFr3TEmyAzMCAodMWZaWNldGkpIGRuxa8gb2QgZG9ydcSNZW7DrQpyZW1lZGllcyBzZXQgb3V0IGluIENsYXVzZSAxNS4zIHdpdGhpbiB0aGlydHkgKDMwKSBkYXlzIGZyb20gcMOtc2VtbsOpaG8gb3puYW1lbsOtIE5lbW9jbmljZSBuZXVwbGF0bsOtIG5lYm8gbmVwcm92ZWRlCnJlY2VpcHQgb2YgdGhlIEhvc3BpdGFsJ3Mgd3JpdHRlbiBub3RpY2UuIFN1Y2ggdGVybWluYXRpb24gbsSba3RlcsOpIHogb3BhdMWZZW7DrSB1dmVkZW7DvWNoIHYgdXN0YW5vdmVuw60gMTUuMy4gVsO9cG92xJtkJwpzaGFsbCB0YWtlIGVmZmVjdCBvbiB0aGUgZGF0ZSB0aGUgbm90aWNlIGlzIGRlbGl2ZXJlZCB0byBuYWLDvXbDoSDDusSNaW5ub3N0aSBrZSBkbmlkb3J1xI1lbsOtc3BvbGXEjW5vc3RpIEJyYWlub21peC4KQnJhaW5vbWl4LgoKMTYuIEdlbmVyYWwgMTYuIFbFoWVvYmVjbsOhIHVzdGFub3ZlbsOtCgoxNi4xIFNldmVyYWJpbGl0eSDigJQgaWYgYW55IHByb3Zpc2lvbiBvZiB0aGlzIEFncmVlbWVudCBpcyBvciB3aXx8IDE2LjEgT2RkxJtsaXRlbG5vc3Qg4oCUIGplcmxpIG5lYm8gc3RhbmVybGkgc2UgbsSba3RlcsOpIHVzdGFub3ZlbsOtIHTDqXRvCmJlY29tZSBpbnZhbGlkIG9yIHVuZW5mb3JjZWFiSWUsIGl0IHNoYWxsIG5vdCBhZmZlY3Qgb3RoZXIgU21sb3V2eSBuZXBsYXRuw6kgxI1pIG5lw7rEjWlubsOpLCBuZWJ1ZGUgdG8gbcOtdCB2bGl2IG5hIG9zdGF0bsOtCnByb3Zpc2lvbnMgb2YgdGhpcyBBZ3JlZW1lbnQgdGhhdCBzaGFsbCByZW1haW4gdmFsaWQgYW5kIHVzdGFub3ZlbsOtIHTDqXRvIFNtbG91dnksIGt0ZXJhIHrFr3N0YXZhasOtIHBsYXRuYSBhIMO6xI1pbm7DoS4KZWZmZWN0aXZlLiBUaGUgcGFydGllcyB1bmRlcnRha2UgdG8gcmVwbGFjZSB0aGUgaW52YWxpZCBvciBTbWx1dm7DrSBzdHJhbnkgc2UgdnRvbXRvIHDFmcOtcGFkxJsgemF2YXp1asOtIGRvaG9kb3UgbmFocmFkaXQKaW5lZmZlY3RpdmUgcHJvdmlzaW9uIGJ5IGEgbmV3IHZhbGlkIGFuZCBlZmZlY3RpdmUgcHJvdmlzaW9uIHVzdGFub3ZlbsOtIG5lcGxhdG7DqSDEjWkgbmXDusSNaW5uw6kgbm92w71tIHVzdGFub3ZlbsOtbSBwbGF0bsO9bSBhCnRoYXQgY29ycmVzcG9uZHMgYXQgYmVzdCB0byB0aGUgb3JpZ2luYWwgcHVycG9zZSBvZiB0aGUgw7rEjWlubsO9bSwga3RlcsOpIG5lamzDqXBlIG9kcG92w61kYSBwxa92b2RuxJsgemFtw73FoWxlbsOpbXUgw7rEjWVsdQppbnZhbGlkIG9yIGluZWZmZWN0aXZlIHByb3Zpc2lvbi4gVW50aWwgdGhlbiwgdGhlIGdlbmVyYWxseSB1c3Rhbm92ZW7DrSBuZXBsYXRuw6lobyBhIG5lw7rEjWlubsOpaG8uIERvIHTDqSBkb2J5IHBsYXTDrQpiaW5kaW5nIGxlZ2lzbGF0aW9uIG9mdGhlIEN6ZWNoIFJlcHVibGljIHNoYWxsIGJlIGFwcGxpZWQuIG9kcG92w61kYWrDrWPDrSDDunByYXZhIHBsYXRuw71jaCBvYmVjbsSbIHrDoXZhem7DvWNoIHByw6F2bsOtY2gKCnDFmWVkcGlzxa8gxIxlc2vDqSByZXB1Ymxpa3kuCjE2LjIgRG9ydcSNb3bDoW7DrSDigJQgdmXFoWtlcsOhIHNkxJtsZW7DrSDEjWluxJtuYSBkfGUgU21sb3V2eSBtdXNlasOtIGLDvXQgdgoKMTYuMiBOb3RpY2VzICwgYXx8IG5vdGljZXMgYW5kIGNvbW11bmljYXRpb25zIG1hZGUgdW5kZXIgdGhpcwoKQWdyZWVtZW50IG11c3QgYmUgaW4gd3JpdGluZyBhbmQgc2VudCB0byB0aGUgcmVjaXBpZW50J3MKYWRkcmVzcyBzcGVjaWZpZWQgYmVsb3csIG9yIHRvIGFueSBvdGhlciBhZGRyZXNzCnN1YnNlcXVlbnRseSBkZXNpZ25hdGVkIGJ5IHRoZSBpbnRlbmRlZCByZWNpcGllbnQgaW4KYWNjb3JkYW5jZSB3aXRoIEFydGljbGUgMTYuMiBvZiB0aGlzIEFncmVlbWVudC4gU3VjaApub3RpY2VzIHNoYWxsIGJlIGRlbGl2ZXJlZCBpbiBwZXJzb24sIGJ5IGNvdXJpZXIsIGJ5IHByZXBhaWQKCiAKCnDDrXNlbW7DqSBwb2RvYsSbIGEgb2Rlc2zDoW5hIG5hIG7DrcW+ZSB1dmVkZW5vdSBhZHJlc3UgcMWZw61qZW1jZQoKbmVibwoKbmEgamlub3UgYWRyZXN1LCBrdGVyb3UgemFtw73FoWxlbsO9IHDFmcOtamVtY2UgcMWZw61wYWRuxJsKCnBvemTEm2ppIHVyxI3DrSB2IHNvdWxhZHUgcyB0w61tdG8gxI1sLiAxNi4yLiBTZMSbbGVuw60gbXVzZWrDrSBiw710CmRvcnXEjWVuYSBvc29ibsSbLCBrdXLDvXJlbSwgdnlwbGFjZW5vdSBwb8WhdG92bsOtIHphc2lsa291IG5lYm8KZXJtYWlsZW0gYSBidWRvdSBwb3Zhxb5vdsOhbmEgemEgZG9ydcSNZW5hIGJ1ZCcgb3NvYm7DrW0KCiAKCiAKCkJyYWlub21peCBFdXJvcGUgTGltaXRlZApTdWl0ZSAxMDM4MAoKMjYvMjcgVXBwZXIgUGVtYnJva2UgU3RyZWV0CkR1YmxpbiAyIEQwMiwgWDM2MSBJcmVsYW5kCgogCgpwb3N0YWwgc2VydmljZSwgb3IgYnkgZW1haWwsIGFuZCBzaGFsbCBiZSBkZWVtZWQgZHV8eQpkZWxpdmVyZWQgZWl0aGVyIHVwb24gcGVyc29uYWwgZGVsaXZlcnkgb3IsIGluIHRoZSBjYXNlIG9mCnBvc3RhbCBkZWxpdmVyeSwgdXBvbiBkZWxpdmVyeSBvZiB0aGUgcG9zdGFsIGl0ZW0uIEEgcG9zdGFsCml0ZW0gc2hhbGwgYmUgZGVlbWVkIGRlbGl2ZXJlZCB0byB0aGUgb3RoZXIgY29udHJhY3RpbmcKcGFydHkgaWYgc2VudCB0byB0aGUgYWRkcmVzcyBvZiBzdWNoIHBhcnR5IGFzIHN0YXRlZCBpbiB0aGUKaGVhZGluZyBvZiB0aGlzIEFncmVlbWVudC4gSWYgdGhlIGFkZHJlc3NlZSBpcyBub3QgYXZhaWxhYmxlCmF0IHRoZSBhZ3JlZWQgYWRkcmVzcyAoYW5kIHRoZSBkb2N1bWVudCBpcyByZXR1cm5lZCBieXRoZQpwb3N0YWwgc2VydmljZSBtYXJrZWQgYXMgdW5kZXxpdmVyYWJ8ZSBvciB0aGF0IHRoZQphZGRyZXNzZWUgd2FzIG5vdCByZWFjaGVkKSwgdGhlIGRlbGl2ZXJ5IHNoYWxsIGJlIGRlZW1lZAplZmZlY3RpdmUgb24gdGhlIGRhdGUgdGhlIHJlZ2lzdGVyZWQgfGV0dGVyIHdpdGgKYWNrbm93bGVkZ21lbnQgb2YgcmVjZWlwdCBpcyByZXR1cm5lZCB0byB0aGUgc2VuZGVyIGJ5IHRoZQpwb3N0YWwgc2VydmljZS4gfG4gY2FzZSBvZiBkb3VidCwgYW55IGRvY3VtZW50IHNlbnQgYnkKcmVnaXN0ZXJlZCBtYWlsIHNoYWxsIGJlIGRlZW1lZCB0byBoYXZlIGJlZW4gZGVsaXZlcmVkIG9uCnRoZSB0aGlyZCAoM3JkKSBkYXkgZm9sbG93aW5nIHRoZSBkYXRlIG9mIGRpc3BhdGNoLiBJbiB0aGUKY2FzZSBvZiBlcm1haWwgY29tbXVuaWNhdGlvbiwgZGVsaXZlcnkgc2hhbGwgYmUgZGVlbWVkCmVmZmVjdGl2ZSBvbiB0aGUgZGF5IG9mIHNlbmRpbmcgKGlmIHNlbnQgbm8gfGF0ZXIgdGhhbiA0OjAwCnBtLiB8b2NhfCB0aW1lIG9mIHRoZSBzZW5kZXIgb24gYSBidXNpbmVzcyBkYXkpIG9yIG9uIHRoZQpuZXh0IGJ1c2luZXNzIGRheSBmb2xsb3dpbmcgdGhlIGRheSBvZiBzZW5kaW5nLCB1bmxlc3MgdGhlCnNlbmRlciByZWNlaXZlcyBhIG5vdGlmaWNhdGlvbiBvZiBmYWlsZWQgZGVsaXZlcnkuCgpwxZllZMOhbsOtbSwgdiBwxZnDrXBhZMSbIHBvxaF0b3Zuw60gemFzaWxreSBkb3J1xI1lbsOtbSBwb8WhdG92bsOtIHphc2lsa3kKKHBvxaF0b3Zuw60gesOhc2lsa2EgamUgcG92YcW+b3bDoW5hIHphIGRvcnXEjWVub3UgZHJ1aMOpIHNtbHV2bsOtCnN0cmFuxJssIGJ1ZGVybGkgZG9ydcSNZW5hIG5hIGFkcmVzdSB1dmVkZW5vdSB1IGRhbsOpIHNtbHV2bsOtCnN0cmFueSB2IHrDoWhsYXbDrSBTbWxvdXZ5KS4gUG9rdWQgbmEgdGFrdG8gZG9ob2RudXTDvWNoCmFkcmVzw6FjaCBuZWJ1ZGUgYWRyZXNhdCB6YXN0acW+ZW4gKGxpc3RpbmEgYnVkZSB2csOhY2VuYSBwb8WhdG91IHMKb3puYcSNZW7DrW0sIMW+ZSBkcnVow6kgc21sdXZuw60gc3RyYW5hIG5lYnlsYSB6YXN0acW+ZW5hKSwgc3TDoXbDoSBzZQpkb3J1xI1lbsOtdMOpdG8gbGlzdGlueSDDusSNaW5uw71tIGtlIGRuaSwga2R5IGJ5bCBkb3BvcnXEjWVuw70gZG9waXMgcwpkb3J1xI1lbmtvdSBwb8WhdG91IHZyYWNlbiBkcnVow6kgc21sdXZuw60gc3RyYW7Emy4gViBwxZnDrXBhZMSbCnBvY2h5Ym5vc3TDrSBzZSBtw6EgemEgdG8sIMW+ZSBww61zZW1ub3N0IHphc2xhbsOhIGRvcG9ydcSNZW5vdQpwb8WhdG92bsOtIHDFmWVwcmF2b3UgYnlsYSBkb3J1xI1lbmEgdMWZZXTDrSAoMy4pIGRlbiBwbyBkbmkgb2Rlc2zDoW7DrQpww61zZW1ub3N0aSwgdnDFmcOtcGFkxJsgZXJtYWlsdSBwxZlpIG9kZXNsw6Fuw60gZXJtYWlsb3bDqSB6cHJhdnkKbmVqcG96ZMSbamkgZG8gMTY6MDAgbcOtc3Ruw61obyDEjWFzdSBvZGVzw61sYXRlbGUpIHYgcHJhY292bsOtIGRlbgpvZGVzbMOhbsOtIG5lYm8gdiBuw6FzbGVkdWrDrWPDrSBwcmFjb3Zuw60gZGVuIHBvIG9kZXNsw6Fuw60gZXJtYWlsb3bDqQp6cHJhdnksIGxlZGHFvmUgYnkgb2Rlc8OtbGF0ZWwgb2JkcsW+ZXwgenByw6F2dSwgxb5lIHNlIGRvcnXEjWVuw60KbmV6ZGHFmWlsby4KCiAKCkJyYWlub21peCdzIGFkZHJlc3MgZm9yIG5vdGljZXM6CgpCcmFpbm9taXggRXVyb3BlIExpbWl0ZWQsCjEgQ2FzdGxld29vZCBBdmVudWUsIER1YmxpbiA2IEQwNgpINjg1IElyZWxhbmQsIFJhdGhtaW5lcwoKQWRyZXNhIHNwb2xlxI1ub3N0aSBCcmFpbm9taXggcHJvIGRvcnXEjW92w6Fuw606CgpCcmFpbm9taXggRXVyb3BlIExpbWl0ZWQsCjEgQ2FzdGxld29vZCBBdmVudWUsIER1YmxpbiA2IEQwNgpINjg1IHxyc2tvLFJhdGhtaW5lcwoKRHVibGluLCBEdWJsaW4sCnxyZXxhbmQgSXJza28KRm9ydGhlIGF0dGVudGlvbiBvZiBrIHJ1a8OhbToKZXJtYWlsOiBlcm1haWw6CgpUaGUgSG9zcGl0YWwncyBhZGRyZXNzIGZvciBub3RpY2VzOgpLcmFqc2vDoSBuZW1vY25pY2UgTGliZXJlYywgYS5zLgpIdXNvdmEgMTQzMC8zNCwgNDYwIDAxIExpYmVyZWMgfCDigJQgU3RhcsOpIE3Em3N0bywgQ3plY2gKCiAKCkFkcmVzYSBOZW1vY25pY2UgcHJvIGRvcnXEjW92w6Fuw606CktyYWpza8OhIG5lbW9jbmljZSBMaWJlcmVjLCBhLnMuClNlIHPDrWRsZW06IEh1c292YSAxNDMwLzM0LCA0NjAgMDEgTGliZXJlYyB8IOKAlCBTdGFyw6kgTcSbc3RvLAoKIAoKIAoKIAoKIAoKUmVwdWJsaWMgxIxlc2vDoSByZXB1Ymxpa2EKZXJtYScgZXJtYWlsOgoKMTYuMyBBc3NpZ25tZW50IOKAlCBUaGUgQ29udHJhY3RpbmcgcGFydGllcyBtYXkgbm90IGFzc2lnbiwgMTYuMyBQb3N0b3VwZW7DrSDigJQgU21sdXZuw60gc3RyYW55IG5lc23DrSBwb3N0b3VwaXQsIHphc3Rhdml0LCBqaW5hawptb3J0Z2FnZSwgY2hhcmdlIG9yIGRpc3Bvc2Ugb2YgYW55IG9mIGl0cyByaWdodHMgb3IgemF0w63Fvml0IGFuaSB6Y2l6aXQgdHV0byBTbWxvdXZ1IGpha28gY2VsZWssIGFuaSDFvsOhZG7DoSBqZWRub3RsaXZhCm9ibGlnYXRpb25zIHVuZGVyIHRoZSBBZ3JlZW1lbnQsIGluIHdob2xlIG9yIGluIHBhcnQsIHByYXZhIGFuaSBwb3Zpbm5vc3RpIHplIFNtbG91dnkgcGx5bm91Y8OtLCBsZWRhxb5lIGJ5IGsgdG9tdQp3aXRob3V0IGZpcnN0IG9idGFpbmluZyB3cml0dGVuIGNvbnNlbnQgb2YgdGhlIG90aGVyIG3Em2xhIHDFmWVkY2hvesOtcMOtc2VtbsO9c291aGxhcyBkcnVow6kgc21sdXZuw61zdHJhbnkuCmNvbnRyYWN0aW5nIHBhcnR5LgoKMTYuNCBXYWl2ZXIgLCBubyB3YWl2ZXIgb2YgYW55IGJyZWFjaCBvciBhbnkgcmlnaHQgd2l8fCBvcGVyYXRlIDE2LjQgVnpkw6Fuw60gc2UgcHLDoXYg4oCUVnpkYW7DrSBzZSBuw6Fyb2vFryBwxZlpIHBvcnXFoWVuw60gU21sb3V2eSDEjWkgdnpkYW7DrQphcyBhIHdhaXZlciBvZiBhbnkgc3Vic2VxdWVudCBicmVhY2ggb3Igb3RoZXIgcmlnaHQuIE5vIHNlIGpha8OpaG9rb2xpIHByYXZhIGt0ZXJvdWtvbGkgc3RyYW5vdSBuZWJ1ZGUgbcOtdCDDusSNaW5reSB2emRhbsOtCnJpZ2h0IG9yIHJlbWVkeSBnaXZlbiB0byBlaXRoZXIgcGFydHkgaW4gdGhlIEFncmVlbWVudCBzZSB0YWtvdsO9Y2ggbsOhcm9rxa8gxI1pIHByYXYgaSBkbyBidWRvdWNuYS4gVXBsYXRuxJtuw60gamFrw6lob2tvbGkKcHJlY2x1ZGVzIHRoYXQgcGFydHkgZXhlcmNpc2luZyBhbnkgb3RoZXIgcmlnaHQgb3IgcmVtZWR5IHByw6F2YSBuZWJvIHByb3N0xZllZGt1IG5hcHJhdnksIGplxb4gbmVrdGVyYSBzdHJhbmEgbcWvxb5lIG5hCmF2YWlsYWJsZSB0byBpdCB1bmRlciB0aGUgQWdyZWVtZW50IG9yIGF0IGxhdy4gesOha2xhZMSbIHTDqXRvIFNtbG91dnkgdXBsYXRuaXQsIG5ldnlsdcSNdWplIHVwbGF0bsSbbsOtIGppbsOpaG8gcHLDoXZhCgpuZWJvIHByb3N0xZllZGt1LCBwb2t1ZCBqZSBkb3R5xI1uw6Egc3RyYW5hIG3Fr8W+ZSB1cGxhdG5pdCBuYQp6w6FrbGFkxJsgU21sb3V2eSDEjWkgcHLDoXZuw61jaCBwxZllZHBpc8WvLgoKMTYuNSBUaGlyZCBQYXJ0eSBSaWdodHMg4oCUIE5vIHRoaXJkIHBhcnR5IHdpbGwgaGF2ZSB0aGUgYmVuZWZpdCBvZiAxNi41IFByw6F2YSB0xZlldMOtY2ggc3RyYW4g4oCUVGF0byBTbWxvdXZhIG5lbsOtIHV6YXbFmWVuYSB2ZSBwcm9zcMSbY2gKdGhlIEFncmVlbWVudCBvciB0aGUgcmlnaHQgdG8gZW5mb3JjZSBpdC4gVGhlIGNvbnNlbnQgb2YgamFrw6lrb2xpIHTFmWV0w60gb3NvYnksIGFuaSDFvsOhZG7DqSB0xZlldMOtIG9zb2LEmyBuZXBseW5vdSB6IHTDqXRvCkJyYWlub21peCBVSyB3aWxsIG5vdCBiZSBuZWNlc3NhcnkgZm9yIHRoZSB2YXJpYXRpb24gb3IgU21sb3V2eWpha8Opa29saW5hcm9reS4KdGVybWluYXRpb24gb2Z0aGUgQWdyZWVtZW50LgoKMTYuNiBMYXcgYW5kIEp1cmlzZGljdGlvYW5oZSBBZ3JlZW1lbnQgc2hhbGwgYmUgZ292ZXJuZWQgYnkgMTYuNiBSb3pob2RuZSBwcsOhdm8gYSBqdXJpc2Rpa2NlIOKAlCBTbWxvdXZhIHNlIMWZw61kw60gcHLDoXZuw61taQoKcMWZZWRwaXN5IMSMZXNrw6kgcmVwdWJsaWt5LCB6ZWptw6luYSBPYsSNYW5za8O9bSB6w6Frb27DrWtlbSwgYQpidWRlIHZ5a2xhZGFuYSB2IHNvdWxhZHUgcyBuaW1pLCBiZXogb2hsZWR1IG5hIGtvbGl6bsOtIG5vcm15Cm1lemluw6Fyb2Ruw61obyBwcsOhdmEgc291a3JvbcOpaG8uIFZlxaFrZXLDqSBzcG9yeSwgbmFyb2t5IG5lYm8KxZnDrXplbsOtIHBseW5vdWPDrSB6ZSBTbWxvdXZ5IG5lYm8gcyBuw60gc291dmlzZWrDrWPDrSwgdsSNZXRuxJsgbsOhcm9rxa8KemFsb8W+ZW7DvWNoIG5hIG1pbW9zbWx1dm7DrSBvZHBvdsSbZG5vc3RpLCBwb2Rsw6loYWrDrSB2w71ocmFkbsOtCnJvemhvZG92YWPDrSBwcmF2b21vY2kgc291ZMWvIMSMZXNrw6kgcmVwdWJsaWt5LiBTbWx1dm7DrSBzdHJhbnkKcHJvIHByb2plZG7DoW7DrSBhIHJvemhvZG51dMOtc3BvcsWvIG1lemkgbmltaSB2eXBsw712IGPDrWNoIHogdMOpdG8KCmFuZCBjb25zdHJ1ZWQgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBsYXdzIG9mIHRoZSBDemVjaApSZXB1YmxpYywgaW4gcGFydGljdWxhciBieSB0aGUgQ2l2aWwgQ29kZSwgd2l0aG91dCByZWdhcmQgdG8KaXRzIGNvbmZsaWN0cm9mcmxhdyBydWxlcy4gQW55IGRpc3B1dGUsIGNsYWltIG9yIHByb2NlZWRpbmdzCmFyaXNpbmcgZnJvbSBvciBpbiBjb25uZWN0aW9uIHdpdGggdGhlIEFncmVlbWVudCwgaW5jbHVkaW5nCih3aXRob3V0IGxpbWl0YXRpb24pIGNsYWltcyBiYXNlZCBvbiBub25yY29udHJhY3R1YWwKbGlhYmlsaXR5LCB3aWxsIGJlIHN1YmplY3QgdG8gdGhlIGV4Y2x1c2l2ZSBqdXJpc2RpY3Rpb24gb2YgdGhlCkN6ZWNoIGNvdSBydHMuCgogCgogCgogCgpCcmFpbm9taXggRXVyb3BlIExpbWl0ZWQKU3VpdGUgMTAzODAKCjI2LzI3IFVwcGVyIFBlbWJyb2tlIFN0cmVldApEdWJsaW4gMiBEMDIsIFgzNjEgSXJlbGFuZAoKIAoKVGhlIFBhcnRpZXMgYWdyZWUgdG8gdGhlIGV4Y2x1c2l2ZSBqdXJpc2RpY3Rpb24gYW5kIHZlbnVlIG9mCnRoZSBjb3VydHMgb2YgdGhlIEN6ZWNoIFJlcHVibGljIHRvIGhlYXIgYW5kIGRldGVybWluZQpkaXNwdXRlcyBiZXR3ZWVuIHRoZW0gYXJpc2luZyBvdXQgb2YgdGhpcyBBZ3JlZW1lbnQuIHxuCmFjY29yZGFuY2Ugd2l0aCA1IDU1OCBwYXJhZ3JhcGggMiBvZiB0aGUgQ2l2aWwgQ29kZSwgdGhlCmNvbnRyYWN0aW5nIHBhcnRpZXMgZXhwcmVzc2x5IGV4Y2x1ZGUgdGhlIHVzZSBvZiBidXNpbmVzcwpwcmFjdGljZXMgaW4gdGhlaXIgbGVnYWwgcmVsYXRpb25zIGluIGNvbm5lY3Rpb24gd2l0aCB0aGlzCgpTbWxvdXZ5IHNqZWRuw6F2YWrDrSB2w71sdcSNbm91IHByYXZvbW9jIGEgcMWZw61zbHXFoW5vc3Qgc291ZMWvCsSMZXNrw6kgcmVwdWJsaWt5LiBTbWx1dm7DrSBzdHJhbnkgdiBzb3VsYWR1IHMgNSA1NTggb2RzdC4gMgpPYsSNYW5za8OpaG8gesOha29uw61rdSB2w71zbG92bsSbIHZ5bHXEjXVqw60gcG91xb5pdMOtIG9iY2hvZG7DrWNoCnp2eWtsb3N0w60gdmUgc3bDqW0gcHJhdm7DrW0gc3R5a3UgdiBzb3V2aXNsb3N0aSBzIHRvdXRvIFNtbG91dm91LgoKIAoKQWdyZWVtZW50LgoKMTYuNyBMYW5ndWFnZSBvZiB0aGUgQWdyZWVtZW50IOKAlCB0aGlzIEFncmVlbWVudCBpcyBleGVjdXRlZCAxNi43IFJvemhvZG7DqSBqYXp5a292w6EgdmVyemUg4oCUdGF0byBTbWxvdXZhIGplIHZ5aG90b3ZlbmEgdiDEjWVza8OpCmluIEN6ZWNoIGFuZCBFbmdsaXNoIHZlcnNpb24uIHxuIGNhc2Ugb2YgYW55IGRpc2NyZXBhbmN5IGEgYW5nbGlja8OpIHZlcnppLiBWIHDFmcOtcGFkxJtqYWvDvWNoa29saSBuZXNyb3ZuYWxvc3TDrSBtZXppIG9ixJttYQpiZXR3ZWVuIHRoZSB0d28gdmVyc2lvbnMsIHRoZSBDemVjaCB2ZXJzaW9uIHNoYWxsIHByZXZhaWwuIHZlcnplbWkgamUgcm96aG9kdWrDrWPDrSDEjWVza8OpIGphenlrb3bDqSB6bsSbbsOtLgoKIAoKMTYuOCBUaGlzIEFncmVlbWVudCBpcyBleGVjdXRlZCBpbiBlbGVjdHJvbmljIGZvcm0gYW5kIGl0IHNoYWxsIGJlIDE2LjggVGF0byBTbWxvdXZhIGplIHZ5aG90b3ZlbmEgdiBlbGVrdHJvbmlja8OpIHBvZG9ixJsgYSBqZWRuYSBzZSBvCgphIHNpbmdsZSBjb3B5IHdpdGggZXxlY3Ryb25pYyBzaWduYXR1cmVzIG9mIHRoZSBwYXJ0aWVzIGluIGplZG5vICgxKSB2eWhvdG92ZW7DrSBzIGVsZWt0cm9uaWNrw71taSBwb2RwaXN5IE5lbW9jbmljZSBpCgphY2NvcmRhbmNlIHdpdGggYWN0IG5vLiAyOTcvMjAxOSBjb3x8LiBvbiB0cnVzdCBzZXJ2aWNlcyBmb3IgQnJhaW5vbWl4IHYgc291bGFkdSBzZSB6w6Frb25lbSDEjS4gMjk3LzIwMTYgU2IuLCBvIHNsdcW+YsOhY2gKZXxlY3Ryb25pYyB0cmFuc2FjdGlvbnMgYW5kIGFtZW5kZWQuCgp2eXR2w6HFmWVqw61jw61jaCBkxa92xJtydSBwcm8gZWxla3Ryb25pY2vDqSB0cmFuc2FrY2UsIHZlIHpuxJtuw60KcG96ZMSbasWhw61jaCBwxZllZHBpc8WvLgoKIAoKMTYuOSBUaGlzIEFncmVlbWVudCBiZWNvbWVzIHZhbGlkIG9uIHRoZSBkYXRlIG9mIHNpZ25hdHVyZSBvZiAxNi45IFRhdG8gU21sb3V2YSBuYWLDvXZhIHBsYXRub3N0aSBkbmVtIHBvZHBpc3UgcG9zbGVkbsOtIHplCnRoZSBsYXN0IG9mdGhlIGNvbnRyYWN0aW5nIHBhcnRpZXMgYW5kIGJlY29tZXMgZWZmZWN0aXZlIG9uIHNtbHV2bsOtY2ggc3RyYW4gYSDDusSNaW5ub3N0aSBkbmVtIHV2ZcWZZWpuxJtuw60gdiByZWdpc3RydSBzbWx1diB2CnRoZSBkYXRlIG9mIHB1YmxpY2F0aW9uIGluIHRoZSByZWdpc3RlciBvZiBjb250cmFjdHMgaW4gc291bGFkdSBzZSB6w6Frb25lbSDEjS4gMzQwLyAyMDE1IFNiLiwgbyByZWdpc3RydSBzbWx1diwgdmUgem7Em27DrQphY2NvcmRhbmNlIHdpdGggQWN0IE5vLiAzNDAvMjAxNSBDb2xsLiwgb24gdGhlIHJlZ2lzdGVyIG9mIHBvemQgaCBwxZllZHBpc8WvLiBVdmXFmWVqbsSbbsOtIFNtbG91dnkgdiByZWdpc3RydSBzbWx1dgoKY29udHJhY3RzLCBhcyBwcm92ZWRlIE5lbW9jbmljZS4KYW1lbmRlZC4gVGhlIEhvc3BpdGFsIHdpfHwgcHVibGlzaCB0aGUgQ29udHJhY3QgaW4gdGhlCnJlZ2lzdGVyIG9mIGNvbnRyYWN0cy4KCiAKCiAKCjE2LjE4IEFwcGVuZGljZXMgdG8gdGhlIEFncmVlbWVudCAxOC4gUMWZw61sb2h5IFNtbG91dnkKQXBwZW5kaXggMSDigJQgU3BlY2lmaWNhdGlvbiBvZiB0aGUgQWNjZXNzIHRvIFNlcnZpY2UgYW5kIHRoZSBQxZnDrWxvaGEgxI0uIDEg4oCUIFNwZWNpZmlrYWNlIFDFmcOtc3R1cHUga2UgU2x1xb5ixJsgYSBTbHXFvmViClNlcnZpY2VzIFDFmcOtbG9oYSDEjS4gMiDigJQgUG9kbcOtbmt5IHpwcmFjb3bDoW7DrSBvc29ibsOtY2ggw7pkYWrFryAoT2JzYWh1amUKQXBwZW5kaXggMiDigJQgRGF0YSBQcm9jZXNzaW5nIFRlcm1zICh8bmN8dWRlcyBzdWJyIGTDrWzEjcOtIHDFmcOtbG9oeSAyYSBhIDJiKQphcHBlbmRpY2VzIDJhIGFuZCAyYikgUMWZw61sb2hhIMSNIDMg4oCUIERvaG9kYSBvIMO6cm92bmkgc2x1xb5lYgoKQXBwZW5kaXggMyDigJQgU2VydmljZSBMZXZlbCBBZ3JlZW1lbnQKClDFmcOtbG9oYSDEjS4gNCDigJRUZWNobmlja8O9IHBvcGlzIMWZZcWhZW7DrSBCcmFpbm9taXggMzYwCkFwcGVuZGl4IDQg4oCUIFRlY2huaWNhbCBTcGVjaWZpY2F0aW9uIG9mIHRoZSBCcmFpbm9taXggMzYwCgogCgpPbiBhdCDigJTigJQgRG5lIF/igJRWX+KAlOKAlApEcmdydGFsbHkgc3JnbmVkIGJ5IERpZ2l0w6FsbsSbcG9kZXBtCkRhdGU6IDIwMjYuMDQyMyBEYXR1bTogem96ZS5vcy5vNwoxNTExMjA1NCArMDExMDAxIDA5OjUwOjEzICtPWicwMCcKCkJSQUlOT01JWCBFVVJPUEUgTElNSVRFRCBLcmFqc2vDoSBuZW1vY25pY2UgTGliZXJlYywgYS5zLgpDRU8vxZllZGl0ZWwKCiAKCm0gw61zdG9wxZllZHNlZGEgcMWZZWRzdGF2ZW5zdHZhCgogCgogCgogCgpCcmFpbm9taXggRXVyb3BlIExpbWl0ZWQKU3VpdGUgMTAzODAKCjI2LzI3IFVwcGVyIFBlbWJyb2tlIFN0cmVldApEdWJsaW4gMiBEMDIsIFgzNjEgSXJlbGFuZAoKQXBwZW5kaXggMSAvIFDFmcOtbG9oYSDEjS4gMQpTcGVjaWZpY2F0aW9uIG9mIHRoZSBBY2Nlc3MgdG8gU2VtaWNlIGFuZCB0aGUgU2VydmljZXMgLyBTcGVjaWZpa2FjZSBQxZnDrXN0dXB1IGtlIHNsdcW+YsSbIGEgU2x1xb5lYgoKUG9kbcOtbmt5IHBvc2t5dG92w6Fuw60gcMWZw61zdHVwdToKClBvdcW+aXTDrSBzbHXFvmJ5IEJSQUlOT01JWCAzNjAgU3Ryb2tlIGt2eWhvZG5vY2Vuw60gQ1QgdnnFoWV0xZllbsOtIHBhY2llbnTFryBzIENNUCBwxZlpamF0w71jaCBuYSBuw6FzbGVkdWrDrWPDrSBQcmFjb3ZpxaF0xJs6IEtyYWpza8OhIE5lbW9jbmljZSBMaWJlcmVjCgpPZG3Em25hIHphIExpY2VuY2kgYSBTbHXFvmJ1ClNwZWNpZmlrYWNlIHBvc2t5dG92YW7DqSBmdW5rxI1ub3N0aToKCjEgOTUwIDAwMCBDWksKCkRhbMWhw60gc2x1xb5ieQpJbnN0YWxhY2UgYSB6YcWha29sZW7DrQouIEluc3RhbGFjZSDFmWXFoWVuw60gbmEgdmlydHVhbG7DrSBzZXJ2ZXIgKGJsacW+xaHDrSBzcGVjaWZpa2FjZSBhIHBvxb5hZGF2a3kgbmEgSVQgcMWZaXByYXZlbm9zdCB2aXouIGFrdHVhbG7DrSBCcmFpbm9taXggMzYwIFYgY2VuxJsgc2x1xb5ieQpUZWNobmljYWwgRGF0YXNoZWV0KQouIE5hc3RhdmVuw60ga29tcGxldG7DrWhvIGRhdGEgd29ya2Zsb3cg4oCUIENUckJyYWlub21peCAzNjA3UEFDUywgbmFzdGF2ZW7DrSB1c2VyIG1hbmFnZW1lbnR1IGEgcMWZw61zdHVwdSBuYQp3ZWJVbCwgbmFzdGF2ZW7DrSBub3RpZmlrYWPDrQrDmnZvZG7DrSwgcGxuw6kgemHFoWtvbGVuw60gdcW+aXZhdGVsxa8vb2JzbHVoeSBzeXN0w6ltdSB2IG3DrXN0xJsgaW5zdGFsYWNlCkJyYWlub21peCAzNjAsIHNvZnR3YXJvdsOhIHBvZHBvcmEgcG8gZG9idSBwb3NreXRvdsOhbsOtIHDFmcOtc3R1cHUKLiBUZWxlZm9uaWNrYSBhIGVtYWlsb3bDoSBwb2Rwb3JhLCB2aXouIERPSE9EQSBvIMOaUk9WTkkgUE9TS1lUT1ZBTsOdQ0ggU0xVxb1FQiAoU0xBKSB2IGNlbsSbIHNsdcW+YnkKCiAgCgouIFbFoWVjaG55IHBvxb5hZG92YW7DqSBzb2Z0d2Fyb3bDqSB6w6FwbGF0eSwgYWt0dWFsaXphY2UgYSBub3bDqSBmdW5rY2UgdiByw6FtY2kgMSAidCdvdmFuw71jaCBtb2R1bMWvIOKAlCBCcmFpbm9taXggc2UKemF2YXp1amUgemFqaXN0aXQsIGFieSBTb2Z0d2FyZSBieWwgcG9za3l0b3bDoW4gYSB1ZHLFvm92w6FuIHZqZWhvIG5lamFrdHXDoWxuxJtqxaHDrXZlcnppLgpUYXRvIHBvdmlubm9zdCB6YWhybnVqZSB6ZWptw6luYSBiZXpwbGF0bsOpIHpwxZnDrXN0dXBuxJtuw612xaFlY2ggYWt0dWFsaXphY8OtLCB1cGdyYWTFrywgcGF0Y2jFryBhIG5vdsO9Y2ggdmVyesOtClNvZnR3YXJlIHYgcmFtY2kgb2JzYcW+ZW7DvWNoIG1vZHVsxa8sIGEgdG8gYmV6IHpieXRlxI1uw6lobyBvZGtsYWR1IHBvdMOpLCBjbyBidWRvdSB2w71yb2JjZW0gdnlkYW7DvSwKbmVkb2hvZG5vdXJsaSBzZSBzbWx1dm7DrSBzdHJhbnl2IGtvbmtyw6l0bsOtbSBwxZnDrXBhZMSbIGppbmFrLgoKIAoKUG96bi46IFByYSB6YWppxaEgbSdwYWRwYXJ5IEJyYWluYW1peCAzNTBqZSBudXRuw70gdnpkw6FsZW7DvSBwxZnDrXN0dXAgcMWZZXMKVlBOIG5lYmEgQSBXUyBTU00KCkNlbGtvdsOhIGJleiBEUEgqIDEgOTUwIDAwMCBDWksKCipEUEggYnVkZSBwxZllZG3Em3RlbSBwxZllbmVzZW7DqSBkYcWIb3bDqSBwb3Zpbm5vc3RpCgpDZW5hIGEgUGxhdGVibsOtIHBvZG3DrW5reToKMS4gQ2Vsa292w6EgdsO9xaFlIHV2ZWRlbsOpIE9kbcSbbnkgemEgUMWZw61zdHVwIGtlIFNsdcW+YsSbIGEgU2x1xb5ieSBqZSBkb2hvZG51dGEgamFrbyBuZWp2w73FoWUgcMWZw61wdXN0bsOhIGEgbmVsemUgamkgcMWZZWtyb8SNaXQuCgoyLiBSb3pzYWggUMWZw61zdHVwdSBrZSBTbHXFvmLEmyBzdGFub3ZlbsO9IHRvdXRvIFNtbG91dm91IG3Fr8W+ZSBiw710IGRvZGF0ZcSNbsSbIHVwcmF2ZW4gcG91emUgbmEgemFrbGFkZSBww61zZW1uw6lobyBkb2RhdGt1IGtlIFNtbG91dsSbLgpDZW5hIHphIHDFmcOtcGFkbsOpIHJvesWhw63FmWVuw60gTGljZW5jZSBidWRlIFXFvml2YXRlbGkgw7rEjXRvdsOhbmEgdiBzb3VsYWR1IHMgcG9kbcOtbmthbWkgdXZlZGVuw71taSB2IHDFmcOtc2x1xaFuw6ltIGRvZGF0a3UuIE9kbcSbbmEgZGxlIHTDqXRvClNtbG91dnkgYnVkZSB1aHJhemVuYSB2ZSA0ICjEjXR5xZllY2gpIHBsYXRiYWNoIG5hIHpha2xhZGUgdnlzdGF2ZW7DqSBmYWt0dXJ5OgoKYSkgUHJ2bsOtIHBsYXRiYSB2ZSB2w73FoWkgNDg3LjUwMCwgLCBLxI0gYmV6IERQSCwgZmFrdHVyb3ZhbsOhIGJlenByb3N0xZllZG7EmyBwbyBkYXR1IHBvxI3DoXRrdSBSb3pob2Ruw6lobyBvYmRvYsOtCgpiKSBEYWzFocOtY2ggMyAodMWZaSkgcGxhdGJ5LCBrYcW+ZMOhIHZlIHbDvcWhaSA0ODcuNTAwLCAsIGJleiBEUEgsIGZha3R1cm92YW7DqSBrZSBrYcW+ZMOpbXUgbsOhc2xlZHVqw61jw61tdSByb8SNbsOtbXUgdsO9cm/EjcOtIHBvxI3DoXRrdSBSb3pob2Ruw6lobwpvYmRvYsOtIGEgc3BsYXRuw6kgZGxlIHBvZG3DrW5layB0w6l0byBTbWxvdXZ5CgpBcHBlbmRpeCAyIC8gUMWZw61sb2hhIMSNLiAyCkRhdGEgUHJvY2Vzc2luZyBUZXJtcyAvIFBvZG3DrW5reSB6cHJhY292w6Fuw60gb3NvYm7DrWNoIMO6ZGFqxa8KCkJyYWlub21peCBFdXJvcGUgTGltaXRlZApTdWl0ZSAxMDM4MAoKMjYvMjcgVXBwZXIgUGVtYnJva2UgU3RyZWV0CkR1YmxpbiAyIEQwMiwgWDM2MSBJcmVsYW5kCgogCgpEQVRBIFBST0NFU1NJTkcgVEVSTVMKClBPRE3DjU5LWSBaUFJBQ09Ww4FOw40gT1NPQk7DjUNIIMOaREFKw5oKCiAKCiAKCiAgIAoKIAoKIAoKIAoKIAoKMS4gVGhlc2UgdGVybXMgKHRoZXNlIFRlcm1zKSBhcmUgcGFydCBvZiB0aGUgQWdyZWVtZW50LiAxLiBUeXRvIHBvZG3DrW5reSAoZMOhbGUgamVuIOKAnlBvZG3DrW5reeKAnCkganNvdSBzb3XEjcOhc3TDrQpTbWxvdXZ5LgoKMi4gY2xhdXNlcyAxLCAzLCA0LCA1IGFuZCA2IGFuZCBQYXJ0IDEgb2YgdGhlc2UgVGVybXMgYXBwbHkgMi4gVXN0YW5vdmVuIG5rxa8gMSwgMywgNCwgNSBhIDYgYSDEjSBzdGkgMSB0xJtjaHRvIFBvZG3DrW5lawp3aGVuLCBpbiB0aGUgY291cnNlIG9mIHByb3ZpZGluZyBhbnkgc2VydmljZXMgdG8gdGhlIHNlIHVwbGF0bsOtdiBwxZnDrXBhZMSbLCDFvmUgQnJhaW5vbWl4IHDFmWkgcG9za3l0b3bDoW7DrSBzbHXFvmViCkhvc3BpdGFsLCBCcmFpbm9taXggUHJvY2Vzc2VzIGFueSBQZXJzb25hbCBEYXRhIGZvciB0aGUgTmVtb2NuaWNpIGJ1ZGUgcHJvIE5lbW9jbmljaSB6cHJhY292w6F2YXQgb3NvYm7DrcO6ZGFqZS4KSG9zcGl0YWwuCgozLiBUaGUgcGFydGllcyBhY2tub3dsZWRnZSB0aGF0IHRoZXJlIGFyZSBsaWtlbHkgdG8gYmUgMy4gU3RyYW55IGJlcm91IG5hIHbEm2RvbcOtLCDFvmUgcHJhdmTEm3BvZG9ibsSbIGRvamRlIGtlCmNoYW5nZXMgdG8gdGhlIERhdGEgUHJvdGVjdGlvbiBMZWdpc2xhdGlvbiBhbmQgdG8gem3Em27DoW0gcHLDoXZuw61jaCBwxZllZHBpc8WvIG8gb2NocmFuxJsgb3NvYm7DrWNoIMO6ZGFqxa8gYSBrZQpndWlkYW5jZSBhbmQgY29kZXMgb2YgcHJhY3RpY2UgaXNzdWVkIGluIGNvbm5lY3Rpb24gd2l0aCB6bcSbbsOhbSBtZXRvZGlja8O9Y2ggcG9reW7FryBhIGtvZGV4xa8gY2hvdmFuw60KdGhhdCBsZWdpc2xhdGlvbiBhbmQgYWdyZWUgdGhhdCwgYXQgdGhlIGluc3RpZ2F0aW9uIG9mIGVpdGhlciB2eWRhdmFuw71jaCB2c291dmlzbG9zdGkgcyBuw63FvmUgdXZlZGVuw71taSBwcmF2bsOtbWkKcGFydHksIHRoZXNlIFRlcm1zIHdpbGwgYmUgYW1lbmRlZCBmcm9tIHRpbWUgdG8gdGltZSB0byBwxZllZHBpc3ksIGEgc291aGxhc8OtLCDFvmUgdHl0byBQb2Rtw61ua3kgbW9ob3UgcMWZw61wYWRuxJsKYXx8b3cgdGhlIHBhcnRpZXMgdG8gY29tcGx5IHdpdGggdGhlIERhdGEgUHJvdGVjdGlvbiBiw710IG5hIHBvZG7Em3Qga3RlcsOpa29saSB6ZSBzdHJhbiBtxJtuxJtueSB0YWssIGFieSBzdHJhbnkKTGVnaXNsYXRpb24gYXMgaXQgZXZvfHZlcyBhbmQgc3VjaCBndWlkYW5jZSBhbmQgY29kZXMgb2YgbW9ofHkgcGxuaXQgcG92aW5ub3N0aSBzdGFub3ZlbsOpIGFrdHXDoWxuxJsgcGxhdG7DvW1pCnByYWN0aWNlLiBwcsOhdm7DrW1pIHDFmWVkcGlzeSBvIG9jaHJhbsSbIG9zb2Juw61jaCDDumRhasWvLCBuYXZhenVqw61jw61taQoKbWV0b2RpY2vDvW1pIHBva3lueSBhIGtvZGV4eSBjaG92YW7DrS4KCjQuIEVhY2ggcGFydHkgd2l8fCBwcm92aWRlIHRoZSBvdGhlciB3aXRoIHRoZSBjb250YWN0IGRldGFpbHMgNC4gS2HFvmTDoSB6ZSBzdHJhbiBwb3NreXRuZSBkcnVow6kgc3RyYW7EmyBrb250YWt0bsOtIMO6ZGFqZQpvZiBpdHMgRGF0YSBQcm90ZWN0aW9uIE9mZmljZXIgYW5kIGl0cyBSZXByZXNlbnRhdGl2ZSAoaWYgc3bDqWhvIHBvdsSbxZllbmNlIHBybyBvY2hyYW51IG9zb2Juw61jaCDDumRhasWvIGEgc3bDqWhvCmFueSkgYW5kIHdpbGwga2VlcCB0aG9zZSBkZXRhaWxzIHVwdG8gZGF0ZS4gemFzdHVwY2UgKGJ1ZGVybGkgdXLEjWVuKSBhIGJ1ZGUgdHl0byDDumRhamUgcG9kbGUgcG90xZllYnkKCmFrdHVhbGl6b3ZhdC4KVGhlIEhvc3BpdGFsJ3MgcGVyc29uYWwgZGF0YSBwcm90ZWN0aW9uIG9mZmljZXIgaXMgUG92xJvFmWVuZWMgcHJvIG9jaHJhbnUgb3NvYm7DrWNoIMO6ZGFqxa8gTmVtb2NuaWNlIGplClRoZSBCcmFpbm9taXjigJxzIHBlcnNvbmFsIGRhdGEgcHJvdGVjdGlvbiBvZmZpY2VyIGlzCgpQb3bEm8WZZW5jZW0gcHJvIG9jaHJhbnUgb3NvYm7DrWNoIMO6ZGFqxa8gQnJhaW5vbWl4IGplCgo1LiBUaGUgcHJvdmlzaW9ucyBpbiB0aGVzZSBUZXJtcyBhcmUgaW4gYWRkaXRpb24gdG8sIGFuZCBkbyA1LiBVc3Rhbm92ZW7DrSB0xJtjaHRvIFBvZG3DrW5layB0dm/FmcOtIGRvcGxuxJtuw60gcG92aW5ub3N0w60Kbm90IHJlfGlldmUsIHJlbW92ZSBvciByZXBsYWNlLCBlaXRoZXIgcGFydHkncyBvYmxpZ2F0aW9ucyBzbWx1dm7DrWNoIHN0cmFuIHBseW5vdWPDrWNoIHogcHLDoXZuw61jaCBwxZllZHBpc8WvCnVuZGVydGhlIERhdGEgUHJvdGVjdGlvbiBMZWdpc2xhdGlvbi4gb29jaHJhbsSbIG9zb2Juw61jaCDDumRhasWvLCBhbmnFviBieSB2xaFhayBzbWx1dm7DrSBzdHJhbnkKCnp1dmVkZW7DvWNoIHBvdmlubm9zdMOtIHZ5asOtbWFJeSwgdnl2YXpvdmFseSBuZWJvIHR5dG8KcG92aW5ub3N0aSBuYWhyYXpvdmFseS4KNi4gRGVmaW5pdGlvbnMKCjYuIERlZmluaWNlCgogCgogCgo2LjEgRXhwcmVzc2lvbnMgdGhhdCBhcmUgZGVmaW5lZCBpbiB0aGUgQWdyZWVtZW50IGhhdmUgdGhlCgogCgo2LjEgVsO9cmF6eSwga3RlcsOpIGpzb3UgZGVmaW5vdsOhbnkgdiBTbWxvdXbEmywgbWFqw60gcMWZaQoKIAoKIAoKQnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRDAyLCBYMzYxIElyZWxhbmQKCiAKCnNhbWUgbWVhbmluZyB3aGVuIHRoZXkgYXJlIHVzZWQgaW4gdGhlc2UgVGVybXMgdW5sZXNzCnRoZXkgYXJlIGFtZW5kZWQgYnkgdGhlc2UgVGVybXMsIGFuZCBpbiB0aGF0IGNhc2UgdGhlCmRlZmluaXRpb24gaW4gdGhlc2UgVGVybXMgd2l8fCBhcHBseS4gSW4gYWRkaXRpb24sIHRoZQpmb2xsb3dpbmcgZXhwcmVzc2lvbnMgaGF2ZXRoZSBtZWFuaW5ncyBzZXQgb3Bwb3NpdGU6Cgpwb3XFvml0w60gdnTEm2NodG8gUG9kbcOtbmvDoWNoIHN0ZWpuw70gdsO9em5hbSwgbmVqc291cmxpCnTEm21pdG8gUG9kbcOtbmthbWkgdXByYXZlbnkgamluYWsuIFZ0YWtvdsOpbQpwxZnDrXBhZMSbIHNlIHVwbGF0bsOtIGRlZmluaWNlIG9ic2HFvmVuYSB2IHTEm2NodG8KUG9kbcOtbmvDoWNoLiBOw63FvmUgdXZlZGVuw6kgdsO9cmF6eSBtYWrDrSB2w716bmFtLAprdGVyw71qZWRlZmlub3ZhbnZ0b210b8SNbGFua3U6CgogCgpBcHByb3ByaWF0ZSBTYWZlZ3VhcmRzIG1lYW5zIHRoZSBtZWFzdXJlcyBzZXQgb3V0IGluCkFydGljbGUgNDYgb2YgdGhlIEdEUFIsIGluY2x1ZGluZyBidXQgbm90IGxpbWl0ZWQgdG8gdGhlClN0YW5kYXJkIENvbnRyYWN0dWFsIGNsYXVzZXMsIGJpbmRpbmcgY29ycG9yYXRlIHJ1bGVzLCBvcgphbnkgb3RoZXIgbW9kZWwgY2xhdXNlcyBvciB0cmFuc2ZlciBtZWNoYW5pc20gYXBwcm92ZWQKYnkgdGhlIERhdGEgUHJvdGVjdGlvbiBDb21taXNzaW9uIG9yIHRoZSBPZmZpY2UgZm9yIHRoZQpQZXJzb25hbCBEYXRhIFByb3RlY3Rpb24sIGFuZCBhbnkgcmlzayBhc3Nlc3NtZW50IGFuZApzdXBwbGVtZW50YXJ5IG1lYXN1cmVzIHJlcXVpcmVkIHRvIGVuc3VyZSB0aGUKZWZmZWN0aXZlbmVzcyBvZiBzdWNoIG1lYXN1cmVzOwoKVmhvZG5lJyB6w6FydWt5IGpzb3Ugb3BhdMWZZW7DrSBzdGFub3ZlbsOhIHYgxI18LjQ2IEdEUFIsCnplam3DqW5hIFN0YW5kYXJkbsOtIHNtbHV2bsOtIGRvbG/Fvmt5LCB6YXZhem5hIHBvZG5pa292w6EKcHJhdmlkbGEgbmVibyBqaW7DoSB2em9yb3bDoSB1c3Rhbm92ZW7DrSBuZWJvIHpwxa9zb2J5CnDFmWVkw6F2w6Fuw60gc2NodsOhbGVuw6kgS29taXPDrSBwcm8gb2NocmFudSBvc29ibsOtY2ggw7pkYWrFrwpuZWJvIMOaxZlhZGVtIHBybyBvY2hyYW51IG9zb2Juw61jaCDDumRhasWvLCBhIGTDoWxlIG9wYXTFmWVuw60KcHJvIHBvc291emVuw60gcml6aWsgYSBkYWzFocOtIG9wYXTFmWVuw60gbmV6Ynl0bsOhIHBybyB6YWppxaF0xJtuw60Kw7rEjWlubm9zdGkgdMSbY2h0byBvcGF0xZllbsOtOwoKIAoKQnJhaW5vbWl4J3MgUGVyc29ubmVsIG1lYW5zIEJyYWlub21peCdzIGVtcGxveWVlcywKc3RhZmYsIHdvcmtlcnMsIGNvbnRyYWN0IHN0YWZmIGFuZCBvZmZpY2VyczsKClBlcnNvbsOhbCBCcmFpbm9taXgganNvdSB6YW3Em3N0bmFuY2kgc3BvbGXEjW5vc3RpCkJyYWlub21peCwgZGFsxaEgamVqw60gcHJhY292bsOtY2kgdsSNZXRuxJsgZXh0ZXJuw61jaCBwcmFjb3Zuw61rxa8KYSDEjWxlbm92w6kgamVqw61jaCDFmcOtZMOtY8OtY2ggYSBzdGF0dXTDoXJuw61jaCBvcmdhbnU7CgogCgpDb25zZW50IG1lYW5zIGNvbnNlbnQsIHBlcm1pc3Npb24sIGFncmVlbWVudCBvcgphcHByb3ZhbCB0aGF0IG1lZXRzIHRoZSByZXF1aXJlbWVudHMgb2YgdGhlIERhdGEKUHJvdGVjdGlvbiBMZWdpc2xhdGlvbiBmb3IgY29uc2VudDsKClNvdWhsYXMgamUgc291aGxhcywgcG92b2xlbsOtLCB1amVkbmFuw60gbmVibyBzdm9sZW7DrQpzcGzFiHVqw61jw60gcMWZw61zbHXFoW7DqSBwb8W+YWRhdmt5IHByw6F2bsOtY2ggcMWZZWRwaXPFryBvIG9jaHJhbsSbCm9zb2Juw61jaCDDumRhasWvOwoKIAoKYSBDb250cm9sbGVyIGhhcyB0aGUgbWVhbmluZyBnaXZlbiB0byB0aGF0IGV4cHJlc3Npb24gaW4KdGhlIERhdGEgUHJvdGVjdGlvbiBMZWdpc2xhdGlvbjsKClNwcsOhdmNlIMO6ZGFqxa8gbcOhIHbDvXpuYW0gZGVmaW5vdmFuw70gcHLDoXZuw61taSBwxZllZHBpc3kKbyBvY2hyYW7EmyBvc29ibsOtY2ggw7pkYWrFrzsKCiAKCnRoZSBEYXRhIFByb3RlY3Rpb24gQ29tbWlzc2lvbiBtZWFucyB0aGUgRGF0YQpQcm90ZWN0aW9uIENvbW1pc3Npb24sIENhbmFsIEhvdXNlLCBTdGF0aW9uIFJvYWQsClBvcnRhcmxpbmd0b24sIENvLiBMYW9pcywgUjMyIEFQMjMsIElyZWxhbmQsIG9yIGFueQpyZXBsYWNlbWVudCBzdXBlcnZpc29yeSBhdXRob3JpdHkgdW5kZXIgdGhlIERhdGEKUHJvdGVjdGlvbiBMZWdpc2xhdGlvbiwgYXBwb2ludGVkIGZyb20gdGltZSB0byB0aW1lIGluCklyZWxhbmQ7CgpLb21pc2UgcHJvIG9jaHJhbnUgb3NvYm7DrWNoIMO6ZGFqxa8gamUgS29taXNlIHBybwpvY2hyYW51IG9zb2Juw61jaCDDumRhasWvIChEYXRhIFByb3RlY3Rpb24gQ29tbWlzc2lvbiksCkNhbmFsIEhvdXNlLCBTdGF0aW9uIFJvYWQsIFBvcnRhcmxpbmd0b24sIENvLiBMYW9pcywgUjMyCkFQMjMsIElyc2tvLCBwxZnDrXBhZG7EmyBqaW7DvSBkb3pvcm92w70gw7rFmWFkLCBrdGVyw70gamkgdiBJcnNrdQpuYWhyYWTDrSBuYSB6YWtsYWRlIFByw6F2bsOtY2ggcMWZZWRwaXPFryBvIG9jaHJhbsSbIG9zb2Juw61jaArDumRhasWvOwoKIAoKVGhlIE9mZmljZSBmb3IgUGVyc29uYWwgRGF0YSBQcm90ZWN0aW9uIG1lYW5zIHRoZSBPZmZpY2UKZm9yIFBlcnNvbmFsIERhdGEgUHJvdGVjdGlvbiwgaGF2aW5nIGl0cyByZWdpc3RlcmVkIG9mZmljZSBhdApQcGxrLiBTb2Nob3JhIDI3LCAxNzAgMDAgUHJhZ3VlIDcsIEN6ZWNoIFJlcHVibGljLAplc3RhYmxpc2hlZCBpbiAyMDAwIGJ5IEFjdCBOby4gMTAxLzIwMDAgQ29sbC4sIG9uIHRoZQpQcm90ZWN0aW9uIG9mIFBlcnNvbmFsIERhdGEgYW5kIG9uIEFtZW5kbWVudHMgdG8gQ2VydGFpbgpBY3RzLCB3aG9zZSBjdXJyZW50IHN0YXR1cyBhbmQgcG93ZXJzIGFyZSBnb3Zlcm5lZCBieSBBY3QKTm8uIDExMC8yMDE5IENvbGwuLCBvbiB0aGUgUHJvY2Vzc2luZyBvZiBQZXJzb25hbCBEYXRhLCBvcgphbnkgb3RoZXIgc3VwZXJ2aXNvcnkgYXV0aG9yaXR5IHRoYXQgcmVwbGFjZXMgaXQgaW4gdGhlCkN6ZWNoIFJlcHVibGljIHB1cnN1YW50IHRvIHRoZSBEYXRhIFByb3RlY3Rpb24gTGF3cy4KCsOaxZlhZCBwcm8gb2NocmFudSBvc29ibsOtY2ggw7pkYWrFryBqZSDDmsWZYWQgcHJvIG9jaHJhbnUKb3NvYm7DrWNoIMO6ZGFqxa8sIFBwbGsuIFNvY2hvcmEgMjcsIDE3MCAwMCBQcmFoYSA3LCDEjGVza8OhCnJlcHVibGlrYSwgYnlsIHYgcm9jZSAyMDAwIHrFmcOtemVuIHrDoWtvbmVtIMSNLiAxMDEvMjAwMCBTYi4sCm8gb2NocmFuxJsgb3NvYm7DrWNoIMO6ZGFqxa8gYSBvIHptxJtuxJsgbsSba3RlcsO9Y2ggesOha29uxa8uLApqZWhvxb4gcG9zdGF2ZW7DrSBhIHDFr3NvYm5vc3QganNvdSB2IHNvdcSNYXNub3N0aSB1cHJhdmVueQp6w6Frb25lbSDEjS4gMTEwLzIwMTkgU2IuLCBvIHpwcmFjb3bDoW7DrSBvc29ibsOtY2ggw7pkYWrFrywKcMWZw61wYWRuxJsgamluw70gZG96b3JvdsO9IMO6xZlhZCwga3RlcsO9IGplaiB2xIxlc2vDqSByZXB1YmxpY2UKbmFocmFkw60gbmEgemFrbGFkZSBQcsOhdm7DrWNoIHDFmWVkcGlzxa8gbyBvY2hyYW7EmyBvc29ibsOtY2gKw7pkYWrFrzsKCiAKCmEgRGF0YSBQcm90ZWN0aW9uIEltcGFjdCBBc3Nlc3NtZW50IGhhcyB0aGUgbWVhbmluZwpnaXZlbiB0byB0aGF0IGV4cHJlc3Npb24gaW4gdGhlIERhdGEgUHJvdGVjdGlvbiBMZWdpc2xhdGlvbjsKClBvc291emVuw60gdmxpdnUgbmEgb2NocmFudSBvc29ibsOtY2ggw7pkYWrFryBtw6EgdsO9em5hbQpkZWZpbm92YW7DvSBwcsOhdm7DrW1pIHDFmWVkcGlzeSBvIG9jaHJhbsSbIG9zb2Juw61jaCDDumRhasWvOwoKIAoKIAoKdGhlIERhdGEgUHJvdGVjdGlvbiBMZWdpc2xhdGlvbiBtZWFucyBhbnkgbGF3IG9yCnJlZ3VsYXRpb24sIGFzIGlzIHN1cHBsZW1lbnRlZCwgYW1lbmRlZCwgcmV2aXNlZCBvcgpyZXBsYWNlZCBmcm9tIHRpbWUgdG8gdGltZSwgcmVsYXRpbmcgdG8gdGhlIFByb2Nlc3Npbmcgb2YKUGVyc29uYWwgRGF0YSB0byB3aGljaCwgcmVzcGVjdGl2ZWx5LCB0aGUgSG9zcGl0YWwgb3IKQnJhaW5vbWl4IGlzIHN1YmplY3QgYXQgdGhlIHJlbGV2YW50IHRpbWUgaW4gcmVzcGVjdCBvZiB0aGUKUHJvY2Vzc2luZyBvZnRoZSBIb3NwaXRhbCBQZXJzb25hbCBEYXRhLCBpbmNsdWRpbmcgKHdpdGhvdXQKbGltaXRhdGlvbikgUmVndWxhdGlvbiAoRVUpIDIwMTYvNjc5IG9mIHRoZSBFdXJvcGVhbgpQYXJsaWFtZW50IGFuZCBvZiB0aGUgQ291bmNpbCBvZiAyNyBBcHJpbCAyMDE2IG9uIHRoZQpwcm90ZWN0aW9uIG9mIG5hdHVyYWwgcGVyc29ucyB3aXRoIHJlZ2FyZCB0byB0aGUgcHJvY2Vzc2luZwpvZiBwZXJzb25hbCBkYXRhIGFuZCBvbiB0aGUgZnJlZSBtb3ZlbWVudCBvZiBzdWNoIGRhdGEKKHRoZSBHRFBSKSwgdGhlIElyaXNoIERhdGEgUHJvdGVjdGlvbiBBY3RzIDE5ODggdG8gMjAxOAoKIAoKUHLDoXZuw60gcMWZZWRwaXN5IG8gb2NocmFuxJsgb3NvYm7DrWNoIMO6ZGFqxa8ganNvdSB2xaFlY2hueQp6w6Frb255IGEgZGFsxaHDrSBwcsOhdm7DrSBwxZllZHBpc3ksIHZlIHpuxJtuw60gcG96ZMSbJ+KAnMOtY2gKcMWZZWRwaXPFryBuZWJvIG5haHJhenVqw61jw61jaCBwxZllZHBpc8WvLCBrdGVyw6kgc2UgdMO9a2Fqw60KWnByYWNvdmFuw61vc29ibsOtY2ggw7pkYWrFryBhIGt0ZXLDvW0gYnVkJ05lbW9jbmljZSwgbmVibwpCcmFpbm9taXggcG9kbMOpaMOhIHYgcm96aG9kbsOpIGRvYsSbIHBybyBacHJhY292w6Fuw60Kb3NvYm7DrWNoIMO6ZGFqxa8gTmVtb2NuaWNlLCB0ai4gemVqbcOpbmEgbmHFmcOtemVuw60KRXZyb3Bza8OpaG8gcGFybGFtZW50dSBhUmFkeSAoRVUpIDIwMTYvNjc5IHplIGRuZQoyNy4gZHVibmEgMjAxNiBvIG9jaHJhbsSbIGZ5emlja8O9Y2ggb3NvYiB2IHNvdXZpc2xvc3RpIHNlClpwcmFjb3ZhbsOtbSBvc29ibsOtY2ggw7pkYWrFryBhIG8gdm9sbsOpbSBwb2h5YnUgdMSbY2h0bwrDumRhasWvIChkw6FsZSBqZW4gR0RQUiksIHpha29ueSBJcnNrw6kgcmVwdWJsaWt5IG8gb2NocmFuxJsKb3NvYm7DrWNoIMO6ZGFqxa8geiBsZXQgMTk4OCBhxb4gMjAxOCBhIMSNZXNrw70gesOha29uIMSNLgoKIAoKIAoKQnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRDAyLCBYMzYxIElyZWxhbmQKCiAKCmFuZCBDemVjaCBBY3QgTm8uIDExMC8yMDE5IENvbGwuLCBvbiBwZXJzb25hbCBkYXRhCnByb2Nlc3Npbmc7CgoxMTAvMjAxOSBTYi4sIG8genByYWNvdsOhbsOtIG9zb2Juw61jaCDDumRhasWvOwoKIAoKYSBEYXRhIFByb3RlY3Rpb24gT2ZmaWNlciBtZWFucyBhIHBlcnNvbiBkZXNpZ25hdGVkIGFzCnN1Y2ggYnkgZWl0aGVyIHBhcnR5IGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgcmVxdWlyZW1lbnRzCm9mdGhlIERhdGEgUHJvdGVjdGlvbiBMZWdpc2xhdGlvbjsKClBvdsSbxZllbmU6IHBybyBvY2hyYW51IG9zb2Juw61jaCDDumRhasWvIGplIG9zb2JhLCBrdGVyb3UKc21sdXZuw60gc3RyYW5hIGsgdG9tdXRvIMO6xI1lbHUgdXLEjWlsYSB2IHNvdWxhZHUKc3VzdGFub3ZlbsOtbWkgcHLDoXZuw61jaCBwxZllZHBpc8WvIG8gb2NocmFuxJsgb3NvYm7DrWNoCsO6ZGFqxa87CgogCgphIERhdGEgU3ViamVjdCBoYXMgdGhlIG1lYW5pbmcgZ2l2ZW4gdG8gdGhhdCBleHByZXNzaW9uIGluCnRoZSBEYXRhIFByb3RlY3Rpb24gTGVnaXNsYXRpb247CgpTdWJqZWt0IMO6ZGFqxa8gbcOhIHbDvXpuYW0gZGVmaW5vdmFuw70gcHLDoXZuw61taSBwxZllZHBpc3kKbyBvY2hyYW7EmyBvc29ibsOtY2ggw7pkYWrFrzsKCiAKCnRoZSBFVS1VSyBUcmFkZSBBZ3JlZW1lbnQgbWVhbnMgdGhlIFRyYWRlIGFuZApDb29wZXJhdGlvbiBBZ3JlZW1lbnQgMDEgfC4gNDQ0LCAzMS4xMi4yMDIwLCBwcC4gMTTigJQxNDYyLApiZXR3ZWVuIHRoZSBFdXJvcGVhbiBVbmlvbiBhbmQgdGhlIEV1cm9wZWFuIEF0b21pYwpFbmVyZ3kgQ29tbXVuaXR5LCBvZiB0aGUgb25lIHBhcnQsIGFuZCB0aGUgVW5pdGVkCktpbmdkb20gb2YgR3JlYXQgQnJpdGFpbiBhbmQgTm9ydGhlcm4gSXJlbGFuZCwgb2Z0aGUgb3RoZXIKcGFydDsKCk9iY2hvZG7DrSBkb2hvZGEgRVUtVUsgamUgRG9ob2RhIG8gb2JjaG9kdSBhCnNwb2x1cHLDoWNpICjDmsWZIHbEm3N0LiBMIDQ0NCwgMzEuMTIuMjAyMCwgNS4gMTQ3MTQ2MikgbWV6aQpFdnJvcHNrb3UgdW5paSBhIEV2cm9wc2vDvW0gc3BvbGXEjWVuc3R2w61tIHBybyBhdG9tb3ZvdQplbmVyZ2lpIG5hIGplZG7DqSBzdHJhbsSbIGEgU3BvamVuw71tIGtyw6Fsb3ZzdHbDrW0gVmVsa8OpCkJyaXTDoW5pZSBhIFNldmVybsOtaG8gSXJza2EgbmEgc3RyYW7EmyBkcnVow6k7CgogCgp0aGUgSG9zcGl0YWwgUGVyc29uYWwgRGF0YSBtZWFucyBhbnkgUGVyc29uYWwgRGF0YSB0aGF0CkJyYWlub21peCBQcm9jZXNzZXMgZm9yIHRoZSBIb3NwaXRhbCBmcm9tIHRpbWUgdG8gdGltZQpwdXJzdWFudHRvIHRoZSBBZ3JlZW1lbnQ7CgpPc29ibsOtIMO6ZGFqZSBOZW1vY25pY2UganNvdSB2xaFlY2hueSBvc29ibsOtIMO6ZGFqZSwga3RlcsOpCkJyYWlub21peCB2IGxpYm92b2xuw6ltIG9rYW3FvmlrdSBwcm8gTmVtb2NuaWNpCnpwcmFjb3ZhdmEgbmEgesOha2xhZMSbIFNtbG91dnk7CgogCgpQZXJzb25hbCBEYXRhIGhhcyB0aGUgbWVhbmluZyBnaXZlbiB0byB0aGF0IGV4cHJlc3Npb24gaW4KdGhlIERhdGEgUHJvdGVjdGlvbiBMZWdpc2xhdGlvbjsKCk9zb2Juw60gw7pkYWplIG3DoSB2w716bmFtIGRlZmlub3ZhbsO9IHByw6F2bsOtbWkgcMWZZWRwaXN5Cm8gb2NocmFuxJsgb3NvYm7DrWNoIMO6ZGFqxa87CgogCgphIFBlcnNvbmFsIERhdGEgQnJlYXRoIGhhcyB0aGUgbWVhbmluZyBnaXZlbiB0byB0aGF0CmV4cHJlc3Npb24gaW4gdGhlIERhdGEgUHJvdGVjdGlvbiBMZWdpc2xhdGlvbjsKClBvcnXFoWVuw60gemFiZXpwZcSNZW7DrSBvc29ibsOtY2ggw7pkYWrFryBtw6EgdsO9em5hbQpkZWZpbm92YW7DvSBwcsOhdm7DrW1pIHDFmWVkcGlzeSBvIG9jaHJhbsSbIG9zb2Juw61jaCDDumRhasWvOwoKIAoKdG8gUHJvY2VzcyBoYXMgdGhlIG1lYW5pbmcgZ2l2ZW4gdG8gdGhhdCBleHByZXNzaW9uIGluIHRoZQpEYXRhIFByb3RlY3Rpb24gTGVnaXNsYXRpb247CgpacHJhY292w6F2YXQgbcOhIHbDvXpuYW0gZGVmaW5vdmFuw70gcHLDoXZuw61taSBwxZllZHBpc3kKbyBvY2hyYW7EmyBvc29ibsOtY2ggw7pkYWrFrzsKCiAKCmEgUHJvY2Vzc29yIGhhcyB0aGUgbWVhbmluZyBnaXZlbiB0byB0aGF0IGV4cHJlc3Npb24gaW4gdGhlCkRhdGEgUHJvdGVjdGlvbiBMZWdpc2xhdGlvbjsKClpwcmFjb3ZhdGVsIG3DoSB2w716bmFtIGRlZmlub3ZhbsO9IHByw6F2bsOtbWkgcMWZZWRwaXN5Cm8gb2NocmFuxJsgb3NvYm7DrWNoIMO6ZGFqxa87CgogCgphIFJlcHJlc2VudGF0aXZlIG1lYW5zIGEgcGVyc29uIGRlc2lnbmF0ZWQgYXMgc3VjaCBieQp0aGUgSG9zcGl0YWwgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSByZXF1aXJlbWVudHMgb2YgdGhlCkRhdGEgUHJvdGVjdGlvbiBMZWdpc2xhdGlvbjsKClrDoXN0dXBjZSBqZSBvc29iYSwga3Rlcm91IE5lbW9jbmljZSBrIHRvbXV0byDDusSNZWx1CnVyxI1pbGEKCnYgc291bGFkdSBzIHVzdGFub3ZlbsOtbWkgcHLDoXZuw61jaCBwxZllZHBpc8WvIG9vY2hyYW7Emwpvc29ibsOtY2ggw7pkYWrFrzsKCiAKClNwZWNpYWwgQ2F0ZWdvcnkgUGVyc29uYWwgRGF0YSBoYXMgdGhlIG1lYW5pbmcgZ2l2ZW4gdG8KdGhhdCBleHByZXNzaW9uIGluIHRoZSBEYXRhIFByb3RlY3Rpb24gTGVnaXNsYXRpb247CgpadmzDocWhdG7DrSBrYXRlZ29yaWUgb3NvYm7DrWNoIMO6ZGFqxa8gbcOhIHbDvXpuYW0gZGVmaW5vdmFuw70KcHLDoXZuw61taSBwxZllZHBpc3kgbyBvY2hyYW7EmyBvc29ibsOtY2ggw7pkYWrFrzsKCiAKCiAKClN0YW5kYXJkIENvbnRyYWN0dWFsIGNsYXVzZXMgbWVhbnM6IGEpIGluIHRoZSBjYXNlIG9mIHRoZQp0cmFuc2ZlciBvZiBhbnkgb2YgdGhlIEhvc3BpdGFsIFBlcnNvbmFsIERhdGEgZnJvbSB3aXRoaW4KdGhlIEV1cm9wZWFuIEVjb25vbWljIEFyZWEgdG8gYSBjb3VudHJ5IG9yIGludGVybmF0aW9uYWwKb3JnYW5pc2F0aW9uIG91dHNpZGUgdGhlIEV1cm9wZWFuIEVjb25vbWljIEFyZWEsCnN0YW5kYXJkIGNvbnRyYWN0dWFsIGNsYXVzZXMgYXBwcm92ZWQgYnkgdGhlIEV1cm9wZWFuCkNvbW1pc3Npb24sIHRoZSBEYXRhIFByb3RlY3Rpb24gQ29tbWlzc2lvbiwgdGhlIE9mZmljZQpmb3IgdGhlIFBlcnNvbmFsIERhdGEgUHJvdGVjdGlvbiBvciBhbiBlcXVpdmFsZW50CnN1cGVydmlzb3J5IGF1dGhvcml0eSB1bmRlciB0aGUgRGF0YSBQcm90ZWN0aW9uIExlZ2lzbGF0aW9uCmZyb20gdGltZSB0byB0aW1lIGZvciB0aGF0IHB1cnBvc2U7IGFuZCBiKSBpbiB0aGUgY2FzZSBvZgoKIAoKU3RhbmRhcmRuw60gc21sdXZuw60gZG9sb8W+a3kganNvdTogYSkgdiBwxZnDrXBhZMSbIHDFmWVkw6F2w6Fuw60Kb3NvYm7DrWNoIMO6ZGFqxa8gTmVtb2NuaWNlIHogw7p6ZW3DrSBFdnJvcHNrw6lobwpob3Nwb2TDocWZc2vDqWhvIHByb3N0b3J1IGRvIHplbcSbIG5lYm8gbWV6aW7DoXJvZG7DrQpvcmdhbml6YWNpIHZuxJsgRXZyb3Bza8OpaG8gaG9zcG9kw6HFmXNrw6lobyBwcm9zdG9ydSwKc3RhbmRhcmRuw60gc21sdXZuw60gZG98b8W+a3kgc2NodsOhbGVuw6kgcHJvIHRlbnRvIMO6xI1lbApFdnJvcHNrb3Uga29taXPDrSwgS29taXPDrSBwcm8gb2NocmFudSBvc29ibsOtY2ggw7pkYWrFrywKw5rFmWFkZW0gcHJvIG9jaHJhbnUgb3NvYm7DrWNoIMO6ZGFqxa8gbmVibyBqaW7DvW0Kb2Rwb3bEm2Ruw71tIGRvem9yb3bDvW0gw7rFmWFkZW0gdiBzb3VsYWR1IHNwcsOhdm7DrW1pCnDFmWVkcGlzeSBvIG9jaHJhbsSbIG9zb2Juw61jaCDDumRhasWvOyBhIGIpIHZwxZnDrXBhZMSbCgogCgogCgpCcmFpbm9taXggRXVyb3BlIExpbWl0ZWQKU3VpdGUgMTAzODAKCjI2LzI3IFVwcGVyIFBlbWJyb2tlIFN0cmVldApEdWJsaW4gMiBEMDIsIFgzNjEgSXJlbGFuZAoKIAoKdGhlIHRyYW5zZmVyIG9mIGFueSBvZiB0aGUgSG9zcGl0YWwgUGVyc29uYWwgRGF0YSBmcm9tCndpdGhpbiB0aGUgVW5pdGVkIEtpbmdkb20gdG8gYSBjb3VudHJ5IG9yIGludGVybmF0aW9uYWwKb3JnYW5pc2F0aW9uIG91dHNpZGUgdGhlIFVuaXRlZCBLaW5nZG9tLCBzdGFuZGFyZApjb250cmFjdHVhbCBjbGF1c2VzIGFwcHJvdmVkIGZyb20gdGltZSB0byB0aW1lIGJ5IHRoZQpVbml0ZWQgS2luZ2RvbSBJbmZvcm1hdGlvbiBDb21taXNzaW9uZXIgZm9yIHRoYXQKcHVycG9zZSwgYW5kIGFueSByaXNrIGFzc2Vzc21lbnQgYW5kIHN1cHBsZW1lbnRhcnkKbWVhc3VyZXMgcmVxdWlyZWQgdG8gZW5zdXJlIHRoZSBlZmZlY3RpdmVuZXNzIG9mIHRoZQptZWFzdXJlcyBzZXQgb3V0IGF0IGEpIGFuZCBiKTsKCnDFmWVkw6F2w6Fuw60gb3NvYm7DrWNoIMO6ZGFqxa8gTmVtb2NuaWNlIHplIFNwb2plbsOpaG8Ka3LDoWxvdnN0dsOtIGRvIHplbcSbIG5lYm8gbWV6aW7DoXJvZG7DrSBvcmdhbml6YWNpIHZuxJsKU3BvamVuw6lobyBrcsOhbG92c3R2w60sIHN0YW5kYXJkbsOtIHNtbHV2bsOtIGRvbG/Fvmt5CnNjaHbDoWxlbsOpIHBybyB0ZW50byDDusSNZWwgw5rFmWFkZW0ga29taXNhxZllIHBybyBpbmZvcm1hY2UKU3BvamVuw6lobyBrcsOhbG92c3R2w60sIGEgZMOhbGUgb3BhdMWZZW7DrSBwcm8gcG9zb3V6ZW7DrSByaXppayBhCmRhbMWhw60gb3BhdMWZZW7DrSBuZXpieXRuw6EgcHJvIHphamnFoXTEm27DrSDDusSNaW5ub3N0aSBvcGF0xZllbsOtCnBvZGxlIGJvZHUgYSkgYSBiKTsKCiAKCmEgU3VicHJvY2Vzc29yIG1lYW5zIGEgcGVyc29uIGVuZ2FnZWQgYnkgQnJhaW5vbWl4CihleGNlcHQgYSBtZW1iZXIgb2YgQnJhaW5vbWl4J3MgUGVyc29ubmVsKSB0byBQcm9jZXNzIGFueQpvZnRoZSBIb3NwaXRhbCBQZXJzb25hbCBEYXRhLgoKRMOtbMSNw60genByYWNvdmF0ZWwgamUgb3NvYmEgKGtyb23EmyBwZXJzb27DoWx1IEJyYWlub21peCksCmt0ZXJvdSBzcG9sZcSNbm9zdCBCcmFpbm9taXggcG92xJvFmWlsYSBacHJhY292YW7DrW0Kb3NvYm7DrWNoIMO6ZGFqxa8gTmVtb2NuaWNlLgoKIAoKNi4yCgpBbnkgY2FwaXRhbGl6ZWQgdGVybXMgbm90IGRlZmluZWQgaGVyZWluIGhhdmUgdGhlIG1lYW5pbmcKZ2l2ZW4gdG8gc3VjaCB0ZXJtcyBpbiB0aGUgQWdyZWVtZW50LiBUZXJtc3RoYXQgYXJlCmRlZmluZWQgaW4gdGhlc2UgVGVybXMgc2hhbGwgYXBwbHkgd2hldGhlcnRoZXkgYXJlCmhlcmVpbmFmdGVyIGNhcGl0YWxpemVkIG9yIG5vdC4KCjYuMgoKVGVybcOtbnksIGt0ZXLDqSBuZWpzb3UgZGVmaW5vdsOhbnkgdiB0xJtjaHRvIFBvZG3DrW5rw6FjaCwKbWFqw60gdsO9em5hbSwga3RlcsO9IGplIGppbSBwxZlpxZlhemVuIFNtbG91dm91LiBUZXJtw61ueSwKa3RlcsOpIGpzb3UgZGVmaW5vdsOhbnkgdnTEm2NodG8gcG9kbcOtbmvDoWNoLCBzZSBwb3XFvmlqw60gYmV6Cm9obGVkdSBuYSB0bywgemRhIGpzb3UgZMOhbGUgdXZlZGVueSBzIHZlbGvDvW0gbmVibwptYWzDvW0gcG/EjcOhdGXEjW7DrW0gcMOtc21lbmVtLgoKIAoKUEFSVCAxIOKAlCBCUkFJTk9NSVggUFJPQ0VTU0VTIEhPU1BJVEFMIFBFUlNPTkFMIERBVEEKRk9SIFRIRSBIT1NQSVRBTAoKxI3DgXNyIDEg4oCUIEJSQUlOT01JWCBzekFjb3bDgXbDgSBQUk8gTkVNT0NOSUNJIE9TT0JOw40Kw5pEQUpFIE5FTU9DTklDRQoKIAoKIAoKVGhlIHN1YmplY3QgbWF0dGVyIGFuZCBkdXJhdGlvbiBvZiB0aGUgUHJvY2Vzc2luZywgdGhlCm5hdHVyZSBhbmQgcHVycG9zZSBvZiB0aGUgUHJvY2Vzc2luZywgdGhlIHR5cGVzIG9mClBlcnNvbmFsIERhdGEgUHJvY2Vzc2VkIGFuZCB0aGUgY2F0ZWdvcmllcyBvZiBEYXRhClN1IGJqZWN0cyBhcmUgYXMgZm9sbG93czoKCiAKClN1YmplY3QgTWF0dGVyIG9mIFBlcnNvbmFsIERhdGEgaW5jbHVkZWQgaW4gdGhlCnRoZSBIb3NwaXRhbCBEYXRhIG9yIHRoZSBIb3NwaXRhbApQcm9jZXNzaW5nIFJlc3VsdHMuCgogCgpEdXJhdGlvbiBvZiB0aGUgVGhlIGR1cmF0aW9uIG9mIHRoZSBBZ3JlZW1lbnQKCiAKCiAKClByb2Nlc3NpbmcgYW5kIGFmdGVyd2FyZHMgdW50aXwgQnJhaW5vbWl4Cm5vIGxvbmdlciBQcm9jZXNzZXMgYW55ClBlcnNvbmFsIERhdGEgZm9yIHRoZSBIb3NwaXRhbC4KCk5hdHVyZWFuZCB8biBvcmRlciB0byBwcm92aWRlIHNlcnZpY2VzCgpQdXJwb3NlIG9mdGhlIHVuZGVyIHRoZSBBZ3JlZW1lbnQgdG8gdGhlCgpQcm9jZXNzaW5nIEhvc3BpdGFsLgoKQ2F0ZWdvcmllcyBvZiBQYXRpZW50cwoKRGF0YSBTdWJqZWN0cyBJbWFnaW5nIGRhdGEgZnJvbSBtb2RhbGl0aWVzCgphbmRUeXBlc29mIChDVCBhbmQgTVJJKSBhbmQvb3IgUEFDUwoKUGVyc29uYWwgRGF0YSBzeXN0ZW1zLCBhbmQgYXNzb2NpYXRlZAoKbWV0YWRhdGEgYXMgc3RvcmVkIGluIERJQ09NCmZpZWxkcywgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZAp0bzogbmFtZSwgZGF0ZSBvZiBiaXJ0aCwgYW5kIHNleDsKClByb2Nlc3NlZAoKUGVyc29uYWwgRGF0YSBQcm9jZXNzZWQKYXV0b21hdGljYWxseSBieSB0aGUgU29mdHdhcmUKb24gYSBzZXJ2ZXIgaW5zdGFsbGVkIGF0dGhlIFNpdGU7CgpQc2V1ZG9ueW1pc2VkIGFuZCBlbmNyeXB0ZWQKUGVyc29uYWwgRGF0YSBQcm9jZXNzZWQKYXV0b21hdGljYWxseSBpbiB0aGUgJ2NJb3VkJzsgYW5kCgogCgogCgogCgogCgo3LgoKUMWZZWRtxJt0IGEgZG9iYSB0cnbDoW7DrSBacHJhY292w6Fuw60sIHBvdmFoYSBhIMO6xI1lbApacHJhY292w6Fuw60sIHR5cHkgenByYWNvdsOhdmFuw71jaCBvc29ibsOtY2ggw7pkYWrFrwphIGthdGVnb3JpZSBzdWJqZWt0xa8gw7pkYWrFryBqc291IHVwcmF2ZW55IG7DoXNsZWRvdm7EmzoKCiAKCiAKClDFmWVkbcSbdCBPc29ibsOtIMO6ZGFqZSBvYnNhxb5lbsOpIHZlClpwcmFjb3bDoW7DrSB6ZHJhdm90bmlja8OpIGRva3VtZW50YWNpCk5lbW9jbmljZSBuZWJvIHZlIHbDvXNsZWRjw61jaAp2ecWhZXTFmWVuw60gcGFjaWVudMWvIHYgTmVtb2NuaWNpLgpEb2JhIHRydsOhbsOtIERvYmEgdHJ2w6Fuw60gU21sb3V2eSBhClpwcmFjb3bDoW7DrSBuYXNsZWR1asOtY8OtIG9iZG9iw60gYcW+IGRvCm9rYW3FvmlrdSwga2R5IEJyYWlub21peCBqacW+CgpuZWJ1ZGUgenByYWNvdsOhdmF0IMW+w6FkbsOpIGRhbMWhw60Kb3NvYm7DrSDDumRhamUgcHJvIE5lbW9jbmljaS4KCiAKClBvdmFoYWHDusSNZWwgUG9za3l0b3bDoW7DrSBzbHXFvmViIE5lbW9jbmljaQoKIAoKWnByYWNvdsOhbsOtIG5hIHrDoWtsYWTEmyBTbWxvdXZ5LgoKS2F0ZWdvcmllIFBhY2llbnRpCgpzdWJqZWt0xa8gw7pkYWrFryBhIFpvYnJhem92YWPDrSBkYXRhIHogbW9kYWxpdCAoQ2wnCgp0eXB5IGEgTVJJKSBhL25lYm8gc3lzdMOpbcWvIFBBQ1MKCnpwcmFjb3bDoXZhbsO9Y2ggYSBzb3V2aXNlasOtY8OtIG1ldGFkYXRhCgpvc29ibsOtY2ggw7pkYWrFryB1Y2hvdsOhdmFuYSB2IHBvbMOtY2ggRElDT00sCnplam3DqW5hOiBqbcOpbm8sIGRhdHVtCgpuYXJvemVuw60sIHJvZG7DqSDEjcOtc2xvIGEgcG9obGF2w607Cgpvc29ibsOtIMO6ZGFqZSB6cHJhY292w6F2YW7DqQphdXRvbWF0aWNreSBTb2Z0d2FyZW0gbmEKc2VydmVydSBpbnN0YWxvdmFuw6ltIG5hIGRhbsOpbQpQcmFjb3ZpxaF0aTsKCiAKCiAKCiAKCnBzZXVkb255bWl6b3ZhIG7DqQoKIAoKIAoKIAoKQnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRDAyLCBYMzYxIElyZWxhbmQKCiAKClRoZSBzYW1lIGNhdGVnb3JpZXMgb2YgUGVyc29uYWwKRGF0YSB0byB3aGljaCBCcmFpbm9taXgncwp0ZWNobmljYXwgc3VwcG9ydCBzdGFmZiBtYXkgaGF2ZQpvY2Nhc2lvbmFsIGFjY2VzcyBkdXJpbmcKaW5zdGFsbGF0aW9uIGFuZCB0aGUgcHJvdmlzaW9uIG9mCnRlY2huaWNhfCBzdXBwb3J0LgoKYSB6YcWhaWZyb3ZhbsOpIG9zb2Juw60gw7pkYWplCnpwcmFjb3bDoXZhbsOpIGF1dG9tYXRpY2t5CnYg4oCeY2xvdWR1IjsgYQoKdHl0w6nFviBvc29ibsOtIMO6ZGFqZSwgayBuaW3Fvgptb2hvdSBtw610IHByYWNvdm7DrWNpIHRlY2huaWNrw6kKcG9kcG9yeSBCcmFpbm9taXggcMWZw61sZcW+aXRvc3Ruw70KcMWZw61zdHVwIGLEm2hlbSBpbnN0YWxhY2UgYQpwb3NreXRvdsOhbsOtIHRlY2huaWNrw6kgcG9kIHBvcnkuCgogCgpIb3NwaXRhbCBzdGFmZiBhbmQgcGh5c2ljaWFucwpOYW1lIGFuZCBlbWFpbCBhZGRyZXNzIGZvcgpyb3V0aW5lIHByb2Nlc3NpbmcgYnkgdGhlCmF1dG9tYXRlZCBzeXN0ZW0gKHRoZQpTb2Z0d2FyZSBzZW5kcyBvdXQgcmVzdWx0Cm5vdGlmaWNhdGlvbnMgdG8gbGlzdHMgb2YgVXNlcnMKcHJlcnBvcHVsYXRlZCBieSB0aGUgSG9zcGl0YWwncwp8VGFkbWluaXN0cmF0b3JzKTsKCk5hbWUsIGVtYWlsIGFkZHJlc3MgYW5kCnBob25lIG51bWJlciBmb3IgY29tcGxhaW50cwpoYW5kbGluZyBhbmQgdGhlIHByb3Zpc2lvbiBvZgp0aGUgU3VwcG9ydCBTZXJ2aWNlczsgYW5kCgpuYW1lIGFuZCBlbWFpbCBhZGRyZXNzIGZvcgpwcm9yYWN0aXZlIHByb2R1Y3QgZmVlZGJhY2sKc3VydmV5cyAodG8gZ2V0IGZlYXR1cmUgYW5kCnBlcmZvcm1hbmNlIGZlZWRiYWNrIOKAlCBub3QKbWFya2V0aW5nIHN1cnZleXMpLgoKIAoKIAoKIAoKQ2F0ZWdvcmllcyBvZgpQcm9jZXNzaW5nCk9wZXJhdGlvbnMKCiAKCkJyYWlub21peCBwcm9jZXNzZXMgcGVyc29uYWwKZGF0YSBvbiBiZWhhfGYgb2YgdGhlIENvbnRyb2xsZXIKaW4gcGFydGljdWxhciB0aHJvdWdoIHRoZQpmb2xsb3dpbmcgY2F0ZWdvcmllcyBvZgpwcm9jZXNzaW5nIG9wZXJhdGlvbnM6CgonIGNvbGxlY3Rpb24sIHJlY29yZGluZywKYW5kIG9yZ2FuaXNhdGlvbiBvZgpwZXJzb25hbCBkYXRhIChpLmUuCmNvbGxlY3Rpb24gYW5kIHJlY2VpcHQKb2YgcGVyc29uYWwgZGF0YSBmcm9tCgptZWRpY2FsIGltYWdpbmcKc3lzdGVtcyBhbmQgcmVsYXRlZApzb3VyY2VzKTsKCicgc3RvcmFnZSwgcmV0ZW50aW9uLCBhbmQKc3RydWN0dXJpbmcgb2YgcGVyc29uYWwKZGF0YSB3aXRoaW4gdGhlCkNvbnRyb2xsZXIncyBzeXN0ZW1zCmFuZCwgd2hlcmUgYXBwbGljYWJsZSwKY3xvdWQgZW52aXJvbm1lbnRzOwoKJyBhZGFwdGF0aW9uLAptb2RpZmljYXRpb24sIGFuZCBvdGhlcgpwcm9jZXNzaW5nIG9mIHBlcnNvbmFsCmRhdGEsIGluY2x1ZGluZyBhbmFseXNpcwphbmQgdGhlIGNyZWF0aW9uIG9mCmRlcml2ZWQgZGF0YSAoaS5lLgphdXRvbWF0ZWQgcHJvY2Vzc2luZwphbmQgYW5hbHlzaXMgb2YgZGF0YSwKaW5jbHVkaW5nIHRoZSBjcmVhdGlvbgpvZiBkZXJpdmVkIGRhdGEsCmFubm90YXRpb25zLCBhbmQKZW5yaWNoZWQgbWV0YWRhdGEpOwoKJyByZXRyaWV2YWwsIGNvbnN1bHRhdGlvbiwKYW5kIHVzZSBvZiBwZXJzb25hbApkYXRhIGJ5IGF1dGhvcmlzZWQKcGVyc29uczsKCicgZGlzY2xvc3VyZSBvZiBwZXJzb25hbApkYXRhIGJ5IHRyYW5zbWlzc2lvbiwKZGlzc2VtaW5hdGlvbiwgb3IKClBlcnNvbsOhbCBhIGzDqWthxZlpIE5lbW9jbmljZQpqbcOpbm8gYSBlbWFpbG92w6EgYWRyZXNhIHBybwpydXRpbm7DrSB6cHJhY292YW7DrQphdXRvbWF0aXpvdmFuw71tIHN5c3TDqW1lbQooU29mdHdhcmUgb2Rlc8OtbGEgb3puYW1lbsOtCm92w71zbGVkY8OtY2ggZG8gc2V6bmFtxa8KdcW+aXZhdGVsxa8gcMWZZWRlbSB2eXBsbsSbbsO9Y2gKc3ByYXZjaSBJVCBOZW1vY25pY2UpOwoKam3DqW5vLCBlbWFpbG92w6EgYWRyZXNhCmEgdGVsZWZvbm7DrSDEjcOtc2xvIHBybyDDusSNZWx5CnpwcmFjb3ZhbsOtIHN0w63Fvm5vc3TDrQoKYSBwb3NreXRvdmEgbsOtIFNsdcW+ZWIgcG9kIHBvcnk7CgpqbcOpbm8gYSBlbWFpbG92w6EgYWRyZXNhIHBybwrDusSNZWx5IHByb2FrdGl2bsOtY2ggcHLFr3prdW3Frwp6cMSbdG7DqSB2YXpieSBrIHByb2R1a3R1Cih6w61za8OhbsOtIHpwxJt0bsOpIHZhemJ5Cm9mdW5rxI1ub3N0aSBhIHbDvWtvbm5vc3RpIOKAlCBuZQptYXJrZXRpbmdvdsOpIHByxa96a3VteSkuCgogCgogCgogCgogCgpLYXRlZ29yaWUKenByYWNvdmF0ZWxza8O9Y2gKb3BlcmFjw60KCiAKCkJyYWlub21peCB6cHJhY292YXZhIG9zb2Juw60Kw7pkYWplIHBybyBzcHLDoXZjZSB6ZWptw6luYQpwcm9zdMWZZWRuaWN0dsOtbSBuw6FzbGVkdWrDrWPDrWNoCmthdGVnb3Jpw60genByYWNvdmF0ZWxza8O9Y2gKb3BlcmFjw606CgonIHNocm9tYcW+ZCdvdmFuw60sCnphem5hbWVuw6F2w6Fuw60gYQpvcmdhbml6YWNlIG9zb2Juw61jaArDumRhasWvICh6ZWptLgpzaHJvbWHFvsSPb3bDoW7DrSBhCnDFmcOtamVtIG9zb2Juw61jaCDDumRhasWvCnogbWVkaWPDrW5za8O9Y2gKem9icmF6b3ZhY8OtY2ggc3lzdMOpbcWvCmEgc291dmlzZWrDrWPDrWNoIHpkcm9qxa8pOwoKJyB1a2zDoWRhbsOtLCB1Y2hvdsOhdsOhbsOtIGEKc3RydWt0dXJvdsOhbsOtIG9zb2Juw61jaArDumRhasWvIHYgcmFtY2kgc3lzdMOpbcWvCnNwcsOhdmNlIGEgcMWZw61wYWRuxJsKY2xvdWRvdsO9Y2ggcHJvc3TFmWVkw607CgonIHDFmWl6cMWvc29iZW7DrSwgw7pwcmF2YSBhCmppbsOpIHpwcmFjb3bDoW7DrQpvc29ibsOtY2ggw7pkYWrFrywgdsSNZXRuxJsKamVqaWNoIGFuYWzDvXp5IGEKdnl0dsOhxZllbsOtIG9kdm96ZW7DvWNoCsO6ZGFqxa8gKHplam0uCmF1dG9tYXRpem92YW7DqQp6cHJhY292w6Fuw60gYSBhbmFsw716YQpkYXQsIHbEjWV0bsSbIHZ5dHbDocWZZW7DrQpvZHZvemVuw71jaCBkYXQsCmFub3RhY8OtIGEgcm96IGVuw71jaAptZXRhZGF0KTsKCicgdnlobGVkw6F2YW7DrSwgbmFobMOtxb5lbsOtCmEgcG91xb7DrXbDoW7DrSBvc29ibsOtY2gKw7pkYWrFryBvcHLDoXZuxJtuw71taQpvc29iYW1pOwoKJyB6cMWZw61zdHVwbsSbbsOtIG9zb2Juw61jaArDumRhasWvIHDFmWVub3NlbSwKCiAKCiAKCiAKCiAKCkJyYWlub21peCBFdXJvcGUgTGltaXRlZApTdWl0ZSAxMDM4MAoKMjYvMjcgVXBwZXIgUGVtYnJva2UgU3RyZWV0CkR1YmxpbiAyIEQwMiwgWDM2MSBJcmVsYW5kCgogCgogCgpvdGhlcndpc2UgbWFraW5nIGRhdGEKYXdpbGFibGUgd2l0aGluIHRoZQoKJyBwc2V1ZG9ueW1pc2F0aW9uIG9mCnBlcnNvbmFsIGRhdGEgYW5kIHRoZWlyCgpzZWN1cml0eSBtYW5hZ2VtZW50OwonIHJldGVudGlvbiBhbmQgYXJjaGl2aW5nCm9mIHBlcnNvbmFsIGRhdGEgaW4KCmEgbmQgZGV8ZXRpb24gb3IKCnByb2Nlc3NpbmcgbmVjZXNzYXJ5IGZvciBzeXN0ZW0KYWRtaW5pc3RyYXRpb24sIG1haW50ZW5hbmNlLApzdXBwb3J0LCBhbmQgZW5zdXJpbmcgc2VjdXJpdHkKYW5kIHByb3BlciBvcGVyYXRpb24gb2YgdGhlClNlcnZpY2VzLgoKIAoKIAoKIAoKxaHDrcWZZW7DrW0gbmVibyBqaW7DvW0KenDFr3NvYmVtIHpwxZnDrXN0dXBuxJtuw60KCkNvbnRyb2xsZXIncyBzeXN0ZW1zIHYgcmFtY2kgc3lzdMOpbcWvCmFuZCB0byBhdXRob3Jpc2VkIHNwcsOhdmNlIGEgb3Byw6F2bsSbbsO9bQpyZWNpcGllbnRzOyBwxZnDrWplbWPFr207CgonIHBzZXVkb255bWl6YWNlCm9zb2Juw61jaCDDumRhasWvIGEgamVqaWNoCgp0cmFuc2ZlciB0byBvdGhlciBwxZllbm9zIGRvIGRhbMWhw61jaApzeXN0ZW1zIG9yIHNlcnZpY2VzOyBzeXN0w6ltxa8gbmVibyBzbHXFvmViOwoKJyByZXN0cmljdGlvbiBvZiAnIG9tZXplbsOtIHpwcmFjb3ZhbsOtLApwcm9jZXNzaW5nLCBpbmNsdWRpbmcgdsSNZXRuxJsgxZnDrXplbsOtCmFjY2VzcyBjb250cm9sIGFuZCBwxZnDrXN0dXBvdsO9Y2ggcHLDoXYgYQoKemFiZXpwZcSNZW7DrTsKJyB1Y2hvdsOhdsOhbsOtIGEgYXJjaGl2YWNlCm9zb2Juw61jaCDDumRhasWvIHBvCgphY2NvcmRhbmNlIHdpdGggdGhlIGRvYnUgc3Rhbm92ZW5vdQoKQ29udHJvbGxlcidzIHNwcmF2Y2VtOwoKaW5zdHJ1Y3Rpb25zOyAnIHVjaG92w6F2w6Fuw60sIGFyY2hpdmFjZQonIHJldGVudGlvbiwgYXJjaGl2aW5nLCBhIHbDvW1heiBuZWJvCgphIG5vbnltaXphY2Ugb3NvYm4gw61jaAoKYW5vbnltaXNhdGlvbiBvZiDDumRhasWvIHYgc291bGFkdSBzCnBlcnNvbmFsIGRhdGEgaW4gcG9reW55IHNwcmF2Y2U7CmFjY29yZGFuY2Ugd2l0aCB0aGUgJyB6cHJhY292YW7DrSDDumRhasWvCkNvbnRyb2xsZXIncyBzb3V2aXNlasOtY8OtY2ggcwppbnN0cnVjdGlvbnM7IHByb3ZvemVtIGEKJyBwcm9jZXNzaW5nIG5lY2Vzc2FyeSB6YWJlenBlxI1lbsOtbQoKZm9yIGVuc3VyaW5nIHN5c3RlbSBzeXN0w6ltxa8sIHbEjWV0bsSbCm9wZXJhdGlvbiBhbmQgc2VjdXJpdHksIGxvZ292w6Fuw60sIG1vbml0b3Jpbmd1CmluY2x1ZGluZyBsb2dnaW5nLCBhIGF1ZGl0dTsKCm1vbml0b3JpbmcsIGFuZCB6cHJhY292YW7DrSBuZXpieXRuw6kgcHJvIHNwcsOhdnUKYXVkaXRpbmc7IHN5c3TDqW11LCDDumRyxb5idSwgcG9kcG9ydSBhCgp6YWppxaF0xJtuw60gYmV6cGXEjW5vc3RpIGEgxZnDoWRuw6lobwpmdW5nb3ZhbsOtU0l1xb5lYi4KCiAKCiAKCiAKClRoZSBwYXJ0aWVzIGFja25vd2xlZGdlIHRoYXQsIGZvciB0aGUgcHVycG9zZXMgb2YgdGhlCkRhdGEgUHJvdGVjdGlvbiBMZWdpc2xhdGlvbiwgdGhlIEhvc3BpdGFsIHdpbGwgYmUgdGhlCkNvbnRyb2xsZXIgYW5kIEJyYWlub21peCB3aWxsIGJlIHRoZSBQcm9jZXNzb3IgaW4gcmVsYXRpb24KdG8gYW55IEhvc3BpdGFsIFBlcnNvbmFsIERhdGEuCgpTdHJhbnkgYmVyb3UgbmEgdsSbZG9tw60sIMW+ZSBwcm8gw7rEjWVseSBwcsOhdm7DrWNoIHDFmWVkcGlzxa8Kb29jaHJhbsSbIG9zb2Juw61jaCDDumRhasWvIGplIE5lbW9jbmljZSB2ZSB2enRhaHUKa29zb2Juw61tIMO6ZGFqxa9tIE5lbW9jbmljZSBzcHJhdmNlbSBhIEJyYWlub21peCBqZQp6cHJhY292YXRlbGVtIHTEm2NodG8gw7pkYWrFry4KCiAKClRoZSBIb3NwaXRhbCB3aXx8IGNvbXBseSB3aXRoIGFsbCB0aGUgZHV0aWVzIGFuZApvYmxpZ2F0aW9ucyBpbXBvc2VkIGZyb20gdGltZSB0byB0aW1lIG9uIENvbnRyb2xsZXJzIGJ5CnRoZSBEYXRhIFByb3RlY3Rpb24gTGVnaXNsYXRpb24gYW5kLCB3aXRob3V0IHByZWp1ZGljZSB0bwp0aGUgZm9yZWdvaW5nLCB0aGUgSG9zcGl0YWwgd2lsbDoKCk5lbW9jbmljZSBidWRlIHBsbml0IHbFoWVjaG55IHBvdmlubm9zdGksIGt0ZXLDqQpzcHLDoXZjxa9tIMO6ZGFqxa8gdWtsYWRhasOtIHBsYXRuw6kgcHLDoXZuw60gcMWZZWRwaXN5IG8gb2NocmFuxJsKb3NvYm7DrWNoIMO6ZGFqxa8uIEFuacW+IGJ5IGJ5bG8gZG90xI1lbm8gdXN0YW5vdmVuw60KcMWZZWRjaG96w612xJt0eSwgTmVtb2NuaWNlOgoKIAoKIAoKIAoKOS4xLiBlc3RhYmxpc2ggYW5kIGRvY3VtZW50IHRoZSBsZWdhbCBiYXNpcyBhbmQsIGluIHRoZSA5LjEuIHN0YW5vdsOtIGEgemFjaHl0w60gdiBwxZnDrXNsdcWhbsOpIGRva3VtZW50YWNpIHByYXZuw60KY2FzZSBvZiBTcGVjaWFsIENhdGVnb3J5IFBlcnNvbmFsIERhdGEsIHRoZSB6w6FrbGFkIHBybyBacHJhY292w6Fuw60gw7pkYWrFrywgcHJvIFp2bMOhxaF0bsOtCmFkZGl0aW9uYWwgY29uZGl0aW9uIG9uIHdoaWNoIHRoZSBIb3NwaXRhbCBrYXRlZ29yaWUgb3NvYm7DrWNoIMO6ZGFqxa8gcGFrIGtyb23EmyB0b2hvIHRha8OpClByb2Nlc3NlcyBhbnkgYW5kIGFsbCBvZiB0aGUgSG9zcGl0YWwgUGVyc29uYWwgZGFsxaHDrSBwb2Rtw61ua3ksIHphIG5pY2jFviBOZW1vY25pY2Ugb3NvYm7DrSDDumRhamUKRGF0YTsgenByYWNvdsOhdsOhOwoKOS4yLiBwcm92aWRlIERhdGEgU3ViamVjdHMgd2l0aCBhbGwgaW5mb3JtYXRpb24gOS4yLiBwb3NreXRuZSBTdWJqZWt0xa9tIMO6ZGFqxa8gdsWhZWNobnkgaW5mb3JtYWNlCgpuZWNlc3NhcnkgdG8sIGFuZCBvYnRhaW4gYW55IGFuZCBhbGwgQ29uc2VudHMgZnJvbQpEYXRhIFN1YmplY3RzICh3aGVyZSByZXF1aXJlZCBieSBhcHBsaWNhYmxlIGxhdykKbmVjZXNzYXJ5IHRvLCBhfHxvdyB0aGUgSG9zcGl0YWwgdG86IFByb2Nlc3MgdGhlaXIKUGVyc29uYWwgRGF0YTsgdHJhbnNmZXIgdGhlaXIgUGVyc29uYWwgRGF0YSB0bwpCcmFpbm9taXggZm9yIFByb2Nlc3NpbmcgYnkgQnJhaW5vbWl4IGFuZCBpdHMKCiAKCmEgb2JzdGFyYSBzaSBvZCBTdWJqZWt0xa8gw7pkYWrFryB2xaFlY2hueSBzb3VobGFzeQoocG9rdWQganNvdSB2ecW+YWRvdsOhbnkgcHLDoXZuw61taSBwxZllZHBpc3kpCm5lemJ5dG7DqSBrIHRvbXUsIGFieSBtb2hsYTogenByYWNvdsOhdmF0IGplamljaApvc29ibsOtIMO6ZGFqZTsgcMWZZWTDoXZhdCBqZSIgaCBvc29ibsOtIMO6ZGFqZQpzcG9sZcSNbm9zdGkgQnJhaW5vbWl4IGEgamVqw61tIETDrWzEjcOtbSB6cHJhY292YXRlbMWvbQoKIAoKIAoKIAoKQnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRDAyLCBYMzYxIElyZWxhbmQKCiAKCiAKCiAKCiAKCiAKCiAKCiAKClN1YnByb2Nlc3NvcnMgdW5kZXIgUGFydCAxIG9mIHRoZXNlIFRlcm1zOyBhbmQga2UgWnByYWNvdmFuw612IHNvdWxhZHUgcyDEjcOhc3TDrSAxIHTEm2NodG8gUG9kbcOtbmVrCmhhdmUgQnJhaW5vbWl4IGFuZCBpdHMgU3VicHJvY2Vzc29ycyBQcm9jZXNzIHRoZWlyIGEgbmVjaGF2YXQgamVqaWNoIG9zb2Juw60gw7pkYWplIHpwcmFjb3bDoXZhdApQZXJzb25hbCBEYXRhIGluIGFjY29yZGFuY2Ugd2l0aCBQYXJ0IDEgb2YgdGhlc2Ugc3BvbGXEjW5vc3TDrSBCcmFpbm9taXggYSBqZWrDrW1pIETDrWzEjcOtbWkgenByYWNvdmF0ZWxpClRlcm1zLCBpbmNsdWRpbmcgKHdpdGhvdXQgfGltaXRhdGlvbikgYW55IHZzb3VsYWR1IHMgxI1hc3TDrTEgdMSbY2h0byBQb2Rtw61uZWssIGEgdG8gdsSNZXRuxJsKYXV0b21hdGVkIGRlY2lzaW9uIG1ha2luZyBvciBwcm9maWxpbmcgY2FycmllZCBvdXQgYXV0b21hdGlja8O9Y2ggcm96aG9kb3ZhY8OtY2ggcHJvY2Vzxa8gbmVibwpieSBCcmFpbm9taXggb3IgaXRzIFN1YnByb2Nlc3NvcnMgb24gdGhlIEhvc3BpdGFsJ3MgcHJvZmlsb3bDoW7DrSB2eWtvbmF2YW7DvWNoIHNwb2xlxI1ub3N0w60gQnJhaW5vbWl4Cmluc3RydWN0aW9ucyBvciBhdCB0aGUgSG9zcGl0YWwncyByZXF1ZXN0OyBuZWJvIGplasOtbWkgRMOtbMSNw61taSB6cHJhY292YXRlbGkgbmEgcG9reW4gbmVibyBuYQrFvsOhZG9zdCBOZW1vY25pY2U7Cgo5LjMuIHByb3ZpZGUgQXMgdGhlIGNvbnRyb3x8ZXIgb2YgcGVyc29uYWwgZGF0YSwgaXQgaXMgOS4zLiBqYWtvIHNwcsOhdmNlIG9zb2Juw61jaCDDumRhasWvIG9kcG92w61kw6EgemEgdXLEjWVuw60KcmVzcG9uc2libGUgZm9yIGRldGVybWluaW5nIHRoZSBsZWdhbCBiYXNpcyBmb3IgcHJhdm7DrWhvIHpha2xhZHUgenByYWNvdmFuw60gcG9kbGUgR0RQUiBhIHphCnByb2Nlc3NpbmcgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBHRFBSIGFuZCwgcG9kbcOtbmVrIHN0YW5vdmVuw71jaCBwcsOhdm7DrW1pIHDFmWVkcGlzeSBtYQp1bmRlciB0aGUgY29uZGl0aW9ucyBzZXQgb3V0IGluIHRoZSBsZWdpc2xhdGlvbiwgaXQgaXMgcG92aW5ub3N0IHByb2vDoXphdCBzcGxuxJtuw60gdMSbY2h0byBwb3Zpbm5vc3TDrSB2xa/EjWkKb2JsaWdlZCB0byBkZW1vbnN0cmF0ZSBjb21wbGlhbmNlIHdpdGggdGhlc2UgZG96b3JvdsOpbXUgb3Jnw6FudSBhIHphdmF6dWplIHNlIG5lZGF2YXQKb2JsaWdhdGlvbnMgdG8gdGhlIHN1cGVydmlzb3J5IGF1dGhvcml0eSBhbmQgenByYWNvdmF0ZWxpIHRha292w6kgcG9reW55LCBrdGVyw6kgYnkgYnlseSB2CnVuZGVydGFrZXMgbm90IHRvIGdpdmUgdGhlIHByb2Nlc3NvciBhbnkgcm96cG9ydSBzIHDFmcOtc2x1xaFuw71taSBwcsOhdm7DrW1pIHDFmWVkcGlzeS4KaW5zdHJ1Y3Rpb25zIHRoYXQgd291bGQgYmUgY29udHJhcnkgdG8gdGhlIHJlfGV2YW50IE5lbW9jbmljZSBuZW7DrSBwb3Zpbm5hIHBvc2t5dG92YXQgc3BvbGXEjW5vc3RpCmxlZ2lzbGF0aW9uLiBUaGUgaG9zcGl0YWwgaXMgbm90IG9ibGlnZWQgdG8gcHJvdmlkZSBCcmFpbm9taXgga29waWUgc291aGxhc3Ugc3ViamVrdMWvIMO6ZGFqxa8gYW5pIGppbsOpCkJyYWlub21peCB3aXRoIGNvcGllcyBvZiBkYXRhIHN1YmplY3RzJyBjb25zZW50cyBvciBkxa9rYXpuw60gZG9rdW1lbnR5IGsgcHLDoXZuw61tdSB6YWtsYWR1Cm90aGVyIGV2aWRlbmNlIG9mIHRoZSBsZWdhbCBiYXNpcyBmb3IgcHJvY2Vzc2luZywgenByYWNvdmFuw60sIGxlZGHFvmUgYnkgamVqaWNoIHBvc2t5dG51dMOtIGJ5fG8KdW5sZXNzIHN1Y2ggcHJvdmlzaW9uIGlzIG5lY2Vzc2FyeSBmb3IgQnJhaW5vbWl4IHRvIG5lemJ5dG7DqSBrIHBsbsSbbsOtIHBvdmlubm9zdMOtIHNwb2xlxI1ub3N0aQpmdXxmaXx8IGl0cyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIGFncmVlbWVudCBvciBCcmFpbm9taXggcG9kbGUgdMOpdG8gc21sb3V2eSBuZWJvIHBsYXRuw71jaAphcHBsaWNhYmxlIGxhdzsgcHLDoXZuw61jaCBwxZllZHAKCjkuNC4gaWYgdGhlIGxlZ2FsIGJhc2lzIGZvciBQcm9jZXNzaW5nIGFueSBvZiB0aGUgOS40LiBidWRlcmxpIHByYXZuw61tIHrDoWtsYWRlbSBwcm8gWnByYWNvdsOhbsOtCkhvc3BpdGFsJ3MgUGVyc29uYWwgRGF0YSBpcyB0aGUgRGF0YSBTdWJqZWN0J3Mgb3NvYm7DrWNoIMO6ZGFqxa8gTmVtb2NuaWNlIHNvdWhsYXMgU3ViamVrdHUgw7pkYWrFrwpDb25zZW50IG9yLCBpbiB0aGUgY2FzZSBvZiBTcGVjaWFsIENhdGVnb3J5IG5lYm8gYnVkZXJsaSB2IHDFmcOtcGFkxJsgWnZsYcWhdG7DrWNoIGthdGVnb3Jpw60KUGVyc29uYWwgRGF0YSB0aGUgYWRkaXRpb25hbCBjb25kaXRpb24gaXMgdGhlIERhdGEgb3NvYm7DrWNoIMO6ZGFqxa8gZGF8xaHDrSBwb2Rtw61ua291IHbDvXNsb3Zuw70gc291aGxhcwpTdWJqZWN0J3MgZXhwbGljaXQgQ29uc2VudCwgYW5kIHRoYXQgQ29uc2VudCBpcyBTdWJqZWt0dSDDumRhasWvIGEgU3ViamVrdCDDumRhasWvIHN2xa9qIHNvdWhsYXMKd2l0aGRyYXduLCBvciBpZiBhbnkgRGF0YSBTdWJqZWN0cyBvYmplY3QgdG8gYW55IG9kdm9sYSwgYW5lYm8gU3ViamVrdCDDumRhasWvIHZ6bmVzZSBuYW1pdGt1IHByb3RpClByb2Nlc3Npbmcgb2YgdGhlaXIgUGVyc29uYWwgRGF0YSBjYXJyaWVkIG91dCBieSBacHJhY292w6Fuw60gc3bDvWNoIG9zb2Juw61jaCDDumRhasWvIHBybyBOZW1vY25pY2kKQnJhaW5vbWl4IG9yIGFueSBvZiBpdHMgU3VicHJvY2Vzc29ycyBmb3IgdGhlIHNwb2xlxI1ub3N0w60gQnJhaW5vbWl4IG5lYm8gamVqw61tIETDrWzEjcOtbQpIb3NwaXRhbCwgdGhlIEhvc3BpdGFsIHdpfHwgaW1tZWRpYXRlbHkgZ2l2ZSBub3RpY2UgenByYWNvdmF0ZWxlbSwgTmVtb2NuaWNlIGplIHBvdmlubmEgc3BvbGXEjW5vc3QKb2Z0aGF0IHdpdGhkcmF3YWxvcm9iamVjdGlvbiBhbmQgb2Z0aGUgSG9zcGl0YWwgQnJhaW5vbWl4IG8gb2R2b2xhbsOtIMSNaSBuYW1pdGNlIG5lcHJvZGxlbsSbClBlcnNvbmFsIERhdGEgYWZmZWN0ZWQgdG8gQnJhaW5vbWl4LiAoQnJhaW5vbWl4IGluZm9ybW92YXQgYSBzZMSbbGl0IGrDrSwga3RlcsO9Y2ggT3NvYm7DrWNoIMO6ZGFqxa8KYW5kIGl0cyBTdWJwcm9jZXNzb3JzIHNoYWxsIGNlYXNlLCB3aXRob3V0IGxpYWJpbGl0eSwgTmVtb2NuaWNlIHNlIHRhdG8gc2t1dGXEjW5vc3QgdMO9a2EuIChCcmFpbm9taXggYQp0aGUgUHJvY2Vzc2luZyBvZiB0aGUgcmV8ZXZhbnQgSG9zcGl0YWwgUGVyc29uYWwgaiBEw61sxI3DrSB6cHJhY292YXRlbMOpIG11c8OtLCBhbmnFviBieSBqaW0gdMOtbSB2em5pa2xhCkRhdGEgYW5kLCBpZiBhbnkgb2YgdGhhdCBIb3NwaXRhbCBQZXJzb25hbCBEYXRhIGlzIGpha2Frb2xpIG9kcG92xJtkbm9zdCwgdWtvbsSNaXQgWnByYWNvdsOhbsOtCmhlfGQgb24gQnJhaW5vbWl4J3Mgb3JpdHMgU3VicHJvY2Vzc29ycycgc3lzdGVtcywgZG90xI1lbsO9Y2ggb3NvYm7DrWNoIMO6ZGFqxa8gTmVtb2NuaWNlIGEgdHkgegpkZWxldGUgaXQgZnJvbSB0aG9zZSBzeXN0ZW1zIHVubGVzcyB0aGUgSG9zcGl0YWwgZG90xI1lbsO9Y2ggb3NvYm7DrWNoIMO6ZGFqxa8gTmVtb2NuaWNlLCBrdGVyw6kganNvdQpkZW1vbnN0cmF0ZXMgdGhhdCBCcmFpbm9taXgncyBhbmQgaXRzIHVjaG92w6F2w6FueSB2IHN5c3TDqW1lY2ggc3BvbGXEjW5vc3RpIEJyYWlub21peApTdWJwcm9jZXNzb3JzJyBjb250aW51ZWQgUHJvY2Vzc2luZyBvZiB0aGF0IG5lYm8gamVqw61jaCBEw61sxI3DrWNoIHpwcmFjb3ZhdGVsxa8sIGplIG9wcsOhdm7Em25hIHoKSG9zcGl0YWwgUGVyc29uYWwgRGF0YSB3aWxsIGJlIHxhd2Z1fC4pOyB0xJtjaHRvIHN5c3TDqW3FryB2eW1hemF0LCBwb2t1ZCBOZW1vY25pY2UKCm5lcG90dnJkw60sIMW+ZSBkYWzFocOtIFpwcmFjb3bDoW7DrSBkb3TEjWVuw71jaCBvc29ibsOtY2gKw7pkYWrFryBOZW1vY25pY2Ugc3BvbGXEjW5vc3TDrSBCcmFpbm9taXggYSBqZWrDrW1pCkTDrWzEjcOtbWkgenByYWNvdmF0ZWxpIGplIHYgc291bGFkdSBzIHByw6F2bsOtbWkKcMWZZWRwaXN5KToKCjkuNS4gcHJvdmlkZSBCcmFpbm9taXh3aXRoIHN1Y2hpbnN0cnVjdGlvbnNyZWdhcmRpbmcgOV81XyBidWRlIGTDoXZhdCBzcG9sZcSNbm9zdGkgQnJhaW5vbWl4IHBva3lueQp0aGUgUHJvY2Vzc2luZyBvZiB0aGUgSG9zcGl0YWwgUGVyc29uYWwgRGF0YSBhcyBvaGxlZG7EmyBacHJhY292w6Fuw60gT3NvYm7DrWNoIMO6ZGFqxa8gTmVtb2NuaWNlCm1heSBiZSBuZWNlc3NhcnkgdG8gYXx8b3cgQnJhaW5vbWl4IGFuZCBpdHMgdGFrLCBqYWsgdG8gYnVkZSBuZXpieXRuw6ksIGFieSBzcG9sZcSNbm9zdApTdWJwcm9jZXNzb3JzIHRvIFByb2Nlc3MgdGhlIEhvc3BpdGFsIFBlcnNvbmFsIEJyYWlub21peCBhIGplasOtIETDrWzEjcOtIHpwcmFjb3ZhdGVsw6kgbW9ofGkKRGF0YSBpbiBvcmRlciB0byBwcm92aWRlIHNlcnZpY2VzIHVuZGVyIGFuZCBpbiB6cHJhY292w6F2YXQgT3NvYm7DrSDDumRhamUgTmVtb2NuaWNlIHDFmWkKYWNjb3JkYW5jZSB3aXRoIHRoZSBBZ3JlZW1lbnQgYW5kIG5vdCBnaXZlIHBvc2t5dG92YW7DrXNsdcW+ZWIgbmEgesOha2xhZMSbIFNtbG91dnksYW5lZGF2YXQKQnJhaW5vbWl4IG9yIGFueSBvZiBpdHMgU3VicHJvY2Vzc29ycyBhbnkgdW58YXdmdXwgc3BvbGXEjW5vc3RpIEJyYWlub21peCBhbmkgamVqw61tIETDrWzEjcOtbQppbnN0cnVjdGlvbi4gKFRoZSBIb3NwaXRhbCdzIGluaXRpYXwgaW5zdHJ1Y3Rpb25zIGFyZSB6cHJhY292YXRlbMWvbSBwb2t5bnkgdiByb3pwb3J1IHMgcHLDoXZuw61taQp0byBQcm9jZXNzIHRoZSBIb3NwaXRhbCBQZXJzb25hbCBEYXRhIGluIG9yZGVyIHRvIHDFmWVkcGlzeS4gKMOadm9kbsOtIHBva3lueSBOZW1vY25pY2UganNvdToKcHJvdmlkZSB0aGUgU2VydmljZXMgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSB6cHJhY292w6F2YXQgT3NvYm7DrSDDumRhamUgTmVtb2NuaWNlIHDFmWkKQWdyZWVtZW50IGFuZCBpbiBvcmRlciB0byBjb21wbHkgd2l0aCB0aGUgRGF0YSBwb3NreXRvdsOhbsOtIHNsdcW+ZWIgbmEgesOha2xhZMSbIFNtbG91dnkKUHJvdGVjdGlvbiBMZWdpc2xhdGlvbiwgaW5jbHVkaW5nICh3aXRob3V0IGEgcG9zdHVwb3ZhdCBwxZlpdG9tIHYgc291bGFkdSBzIHByw6F2bsOtbWkKfGltaXRhdGlvbikgdHJhbnNmZXJyaW5nIHRoZSBIb3NwaXRhbCBQZXJzb25hbCBEYXRhIHDFmWVkcGlzeSBvIG9jaHJhbsSbIG9zb2Juw61jaCDDumRhasWvLCB0ai4gemVqbcOpbmEKCiAKCiAKCiAKCkJyYWlub21peCBFdXJvcGUgTGltaXRlZApTdWl0ZSAxMDM4MAoKMjYvMjcgVXBwZXIgUGVtYnJva2UgU3RyZWV0CkR1YmxpbiAyIEQwMiwgWDM2MSBJcmVsYW5kCgogCgp0byBCcmFpbm9taXgncyBTdWJwcm9jZXNzb3JzIGluIHRoZSBVbml0ZWQKS2luZ2RvbSBmb3IgdGhlIHB1cnBvc2VzIG9mIGhvc3RpbmcgdGhlIFNlcnZpY2UKYW5kIHByb3ZpZGluZ3RoZSBTdXBwb3J0IFNlcnZpY2VzKTsKCnDFmWVkw6F2YXQgb3NvYm7DrSDDumRhamUgTmVtb2NuaWNlIETDrWzEjcOtbQp6cHJhY292YXRlbMWvbSB2ZSBTcG9qZW7DqW0ga3LDoWxvdnN0dsOtIHBybyDDusSNZWx5Cmhvc3RvdsOhbsOtIFNsdcW+YnlhIHBvc2t5dG92YW7DrSBTbHXFvmViIHBvZHBvcnkpOwoKIAoKIAoKOS42LiBleGNlcHQgYXMgcHJvdmlkZWQgaW4gY2xhdXNlIDEwLjYgYmVsb3csIG5vdCA5LjYuIG5lbsOtcmxpIHYgxI1sLiAxMC42IHTEm2NodG8gUG9kbcOtbmVrIHVyxI1lbm8gamluYWssCmluc3RydWN0IEJyYWlub21peCBvciBhbnkgb2YgaXRzIFN1YnByb2Nlc3NvcnMgdG8gTmVtb2NuaWNlIG5lZGEgc3BvbGXEjW5vc3RpIEJyYWlub21peCBhbmkgamVqw61tCnRyYW5zZmVyIGFueSBvZiB0aGUgSG9zcGl0YWwgUGVyc29uYWwgRGF0YSBvdXRzaWRlIETDrWzEjcOtbSB6cHJhY292YXRlbMWvbSBwb2t5biBrIHDFmWVkw6Fuw60gb3NvYm7DrWNoCnRoZSBFdXJvcGVhbiBFY29ub21pYyBBcmVhIG9yIHRvIGFuIMO6ZGFqxa8gTmVtb2NuaWNlIG1pbW8gRXZyb3Bza8O9IGhvc3BvZMOhxZlza8O9CmludGVybmF0aW9uYWwgb3JnYW5pc2F0aW9uIHVubGVzcyB0aGUgdHJhbnNmZXIgaXMgaW4gcHJvc3RvciBuZWJvIGsgamVqaWNoIHDFmWVkw6Fuw60gbWV6aW7DoXJvZG7DrQphY2NvcmRhbmNlIHdpdGggdGhlIGFwcGxpY2FibGUgbGF3cyDigJQgaW4gb3JnYW5pemFjaSwgfGVkYcW+ZSBqZSB0YWtvdsOpIHDFmWVkw6Fuw60gdiBzb3VsYWR1IHMKcGFydHVjdWxhciBpZjogaSkgdGhlIHRyYW5zZmVyIGlzIHRvIHRoZSBVbml0ZWQgcMWZw61zbHXFoW7DvW1pIHByw6F2bsOtbWkgcMWZZWRwaXN5IOKAlCB0ZWR5IHplam3DqW5hCktpbmdkb20gYW5kLCB1bmRlciB0aGUgRVXDjVVLVHJhZGUgQWdyZWVtZW50LCBwb2t1ZDogaSkgw7pkYWplIG1hasOtIGLDvXQgcMWZZWTDoW55IGRvIFNwb2plbsOpaG8KdGhlIFVuaXRlZCBLaW5nZG9tIGlzIG5vdCB0cmVhdGVkIGFzIGEgdGhpcmQga3JhbG92c3R2w61hdnNvdWxhZHVzT2JjaG9kbsOtZG9ob2RvdSBFVcONVUsKY291bnRyeTsgaWkpIHRoZSBFdXJvcGVhbiBDb21taXNzaW9uIGhhcyBkZWNpZGVkIG5lbsOtIFNwb2plbsOpIGtyw6Fsb3ZzdHbDrSBwb3Zhxb5vdsOhbm8gemEgdMWZZXTDrSB6ZW1pOwp0aGF0IHRoZSBjb3VudHJ5IHRvIHdoaWNoIHRoZSBIb3NwaXRhbCBQZXJzb25hbCBpaSkgRXZyb3Bza8OhIGtvbWlzZSByb3pob2RsYSwgxb5lIHplbcSbLCBkbyBuw63FviBtYWrDrQpEYXRhIGlzIHRvIGJlIHRyYW5zZmVycmVkIG9yIG9uZSBvciBtb3JlIHNwZWNpZmllZCBiw710IG9zb2Juw60gw7pkYWplIE5lbW9jbmljZSBwxZllZGFuw70sIG5lYm8gamVkZW4Kc2VjdG9ycyB3aXRoaW4gdGhhdCBjb3VudHJ5LCBvciB0aGUgaW50ZXJuYXRpb25hbCDEjWkgbsSba29saWsga29ua3LDqXRuw61jaCBzZWt0b3LFryB1dm5pdMWZIGRvdHnEjW7DqQpvcmdhbmlzYXRpb24gaW4gcXVlc3Rpb24sIGVuc3VyZXMgYW4gYWRlcXVhdGUgemVtxJssIG5lYm8gZG90ecSNbsOhIG1lemluw6Fyb2Ruw60gb3JnYW5pemFjZSwKbGV2ZWwgb2YgcHJvdGVjdGlvbiBmb3IgUGVyc29uYWwgRGF0YSB1bmRlciBBcnRpY2xlIHphamnFocWldWplIG9kcG92w61kYWrDrWPDrSDDunJvdmXFiCBvY2hyYW55IG9zb2Juw61jaAo0NSBvZiB0aGUgR0RQUjsgb3IgaWlpKSBhcHByb3ByaWF0ZSBzYWZlZ3VhcmRzIMO6ZGFqxa8gdiBzb3VsYWR1IHMgxI1sw6Fua2VtIDQ1IEdEUFI7IG5lYm8gaWlpKSBieWx5CndpdGhpbiB0aGUgbWVhbmluZyBvZkFydGljSWUgNDYgb2YgdGhlIEdEUFIgaGF2ZSB2IHNvdXZpc2xvc3RpIHMgdGFrb3bDvW0gxZllZGFuw61tIHphdmVkZW55IHZob2Ruw6kKYmVlbiBpbXBsZW1lbnRlZCBpbiBjb25uZWN0aW9uIHdpdGggc3VjaCB6YXJ1a3kgdmUgc215c2x1IMSNbMOhbmt1IDQ2IEdEUFI7IGEKcHJvY2Vzc2luZzsgYW5kCgo5LjcuIGNhcnJ5IG91dCBhbnkgRGF0YSBQcm90ZWN0aW9uIEltcGFjdCBBc3Nlc3NtZW50cyA5LjcuIGJ1ZGUgcHJvdsOhZMSbdCBwb3NvdXplbsOtIHZsaXZ1IG5hIG9jaHJhbnUKCmluIHJlc3BlY3Qgb2YgdGhlIFByb2Nlc3Npbmcgb2YgdGhlIEhvc3BpdGFsClBlcnNvbmFsIERhdGEgbmVjZXNzYXJ5IHRvIGNvbXBseSB3aXRoIHRoZSBEYXRhClByb3RlY3Rpb24gTGVnaXNsYXRpb24uCgpvc29ibsOtY2ggw7pkYWrFryB2ZSB2enRhaHUga2UgWnByYWNvdsOhbsOtIG9zb2Juw61jaArDumRhasWvIE5lbW9jbmljZSwgYSB0byB2IHJvenNhaHUgbmV6Ynl0bsOpbQpremFqacWhdMSbbsOtIHNvdWxhZHUgcyBwcsOhdm7DrW1pIHDFmWVkcGlzeSBvIG9jaHJhbsSbCm9zb2Juw61jaCDDumRhasWvLgoKIAoKMTAuCgpCcmFpbm9taXggd2lsbCwgd2hlbiBQcm9jZXNzaW5nIGFueSBvZiB0aGUgSG9zcGl0YWwKUGVyc29uYWwgRGF0YSwgY29tcGx5IHdpdGggdGhlIERhdGEgUHJvdGVjdGlvbiBMZWdpc2xhdGlvbgppbnNvZmFyIGFzIGl0IHNwZWNpZmljYWxseSBpbXBvc2VzIGR1dGllcyBhbmQgb2JsaWdhdGlvbnMgb24KUHJvY2Vzc29ycyBhbmQsIGluIHJlbGF0aW9uIHRvIGFueSBvZiB0aGUgSG9zcGl0YWwgUGVyc29uYWwKRGF0YSwgZm9yIHNvIGxvbmcgYXMgQnJhaW5vbWl4IFByb2Nlc3NlcyB0aGF0IEhvc3BpdGFsClBlcnNvbmFsIERhdGEsIEJyYWlub21peCB3aWxsOgoKMTAuCgpCcmFpbm9taXggYnVkZSBwxZlpIFpwcmFjb3bDoW7DrSBvc29ibsOtY2ggw7pkYWrFryBOZW1vY25pY2UKamVkbmF0IHYgc291bGFkdSBzIHByw6F2bsOtbWkgcMWZZWRwaXN5IG8gb2NocmFuxJsgb3NvYm7DrWNoCsO6ZGFqxa8sIHBva3VkIHR5dG8gcMWZZWRwaXN5IHVrbGFkYWrDrSBrb25rcsOpdG7DrSBwb3Zpbm5vc3RpCnpwcmFjb3ZhdGVsxa9tLiBWZSB2enRhaHUgayBvc29ibsOtbSDDumRhasWvbSBOZW1vY25pY2UKYnVkZSBCcmFpbm9taXggcG8gY2Vsb3UgZG9idSwgcG8ga3Rlcm91IGplIGJ1ZGUKenByYWNvdsOhdmF0LCBwbG5pdCBuYXNsZWR1asOtY8OtIHBvdmlubm9zdGk6CgogCgoxMC4xLiBQcm9jZXNzIHRoZSBIb3NwaXRhbCBQZXJzb25hbCBEYXRhIGV4Y2x1c2l2ZWx5IG9uCgp0aGUgYmFzaXMgb2YgdGhlIEFncmVlbWVudCwgb3IgdGhlIEhvc3BpdGFsJ3MKd3JpdHRlbiBzcGVjaWZpYyBvciB0aGUgSG9zcGl0YWwncyB3cml0dGVuIHNwZWNpZmljCihyZWFzb25hYmxlIGFuZCBJYXdmdWwpIGluc3RydWN0aW9ucyBnaXZlbiBpbgp3cml0aW5nIHRvIEJyYWlub21peCBmcm9tIHRpbWUgdG8gdGltZSwgaW5jbHVkaW5nCndpdGggcmVnYXJkIHRvIHRyYW5zZmVycyBvZiB0aGUgSG9zcGl0YWwgUGVyc29uYWwKRGF0YSBvdXRzaWRlIHRoZSBFdXJvcGVhbiBFY29ub21pYyBBcmVhIG9yIHRoZQpVbml0ZWQgS2luZ2RvbSBvciB0byBhbiBpbnRlcm5hdGlvbmFsCm9yZ2FuaXNhdGlvbiwgdW5sZXNzIEJyYWlub21peCBpcyByZXF1aXJlZCB0bwp0cmFuc2ZlciBhbnkgb2YgdGhlIEhvc3BpdGFsIFBlcnNvbmFsIERhdGEgYnkgYW55CmxhdyB0byB3aGljaCBCcmFpbm9taXggaXMgc3ViamVjdC4gfG4gdGhhdCBjYXNlLApCcmFpbm9taXggd2l8fCBpbmZvcm0gdGhlIEhvc3BpdGFsIG9mIHRoYXQgbGVnYWwKcmVxdWlyZW1lbnQgYmVmb3JlIHRyYW5zZmVycmluZyB0aGUgcmVsZXZhbnQKSG9zcGl0YWwgUGVyc29uYWwgRGF0YSBvdXRzaWRlIHRoZSBFdXJvcGVhbgpFY29ub21pYyBBcmVhIG9yIHRoZSBVbml0ZWQgS2luZ2RvbSBvciB0byBhbgppbnRlcm5hdGlvbmFsIG9yZ2FuaXNhdGlvbiwgdW5sZXNzIGFueSBsYXcgdG8gd2hpY2gKQnJhaW5vbWl4IGlzIHN1YmplY3QgcHJvaGliaXRzIEJyYWlub21peCBmcm9tCnByb3ZpZGluZyB0aGF0IGluZm9ybWF0aW9uLiBCcmFpbm9taXggc2hhbGwKaW1tZWRpYXRlbHkgaW5mb3JtIHRoZSBIb3NwaXRhbCBpZiwgaW4gaXRzIG9waW5pb24sCkhvc3BpdGF84oCccyBpbnN0cnVjdGlvbiBpbmZyaW5nZXMgdGhlIERhdGEgUHJvdGVjdGlvbgpMZWdpc2xhdGlvbjsKCjEwLjEuIHpwcmFjb3bDoXZhdCBvc29ibsOtIMO6ZGFqZSBOZW1vY25pY2UgdsO9aHJhZG7EmyBuYQp6w6FrbGFkxJsgU21sb3V2eSwgcMWZw61wYWRuxJsgcMOtc2VtbsO9Y2gga29ua3LDqXRuw61jaAoocMWZaW3Em8WZZW7DvWNoIGEgesOha29ubsO9Y2gpIHBva3luxa8sIGt0ZXLDqSBvYmRyxb5lbGEKdiBww61zZW1uw6kgcG9kb2LEmywgemVqbcOpbmEgcG9rdWQgamRlCm8gcMWZZWTDoXbDoW7DrSBvc29ibsOtY2ggw7pkYWrFryBOZW1vY25pY2UgbWltbwpFdnJvcHNrw70gaG9zcG9kw6HFmXNrw70gcHJvc3RvciBuZWJvIFNwb2plbsOpCmtyw6Fsb3ZzdHbDrSBuZWJvIG1lemluw6Fyb2Ruw60gb3JnYW5pemFjaSwgbGVkYcW+ZSBieQpzcG9sZcSNbm9zdCBCcmFpbm9taXggYnlsYSBwb3Zpbm5hIG9zb2Juw60gw7pkYWplCk5lbW9jbmljZSBwxZllZGF0IG5hIHpha2xhZGUgcHLDoXZuw61jaCBwxZllZHBpc8WvLAprdGVyw6kgc2UgbmEgbmkgdnp0YWh1asOtLiBWIHRha292w6ltIHDFmcOtcGFkxJsgYnVkZQpCcmFpbm9taXggbyBwb8W+YWRhdmt1IHDFmWVkYXQgbmEgesOha2xhZMSbIHByw6F2bsOtY2gKcMWZZWRwaXPFryBvc29ibsOtIMO6ZGFqZSBOZW1vY25pY2UgbWltbyBFdnJvcHNrw70KaG9zcG9kw6HFmXNrw70gcHJvc3RvciBuZWJvIFNwb2plbsOpIGtyw6Fsb3ZzdHbDrSBuZWJvCm1lemluw6Fyb2Ruw60gb3JnYW5pemFjaSBpbmZvcm1vdmF0IE5lbW9jbmljaSwKbGVkYcW+ZSBieSBwcsOhdm7DrSBwxZllZHBpc3ksIGt0ZXLDqSBzZSBuYSBCcmFpbm9taXgKdnp0YWh1asOtLCB0YWtvdsOpIGluZm9ybW92w6Fuw60gemFrYXpvdmFseS4KQnJhaW5vbWl4IG5lcHJvZGxlbsSbIGluZm9ybXVqZSBOZW1vY25pY2kKdiBwxZnDrXBhZMSbLCDFvmUgcG9kbGUgamVqw60gbmF6b3J1IHVyxI1pdMO9IHBva3luCk5lbW9jbmljZSBwb3J1xaF1amUgUHLDoXZuw60gcMWZZWRwaXN5IG8gb2NocmFuxJsKb3NvYm7DrWNoIMO6ZGFqxa87CgogCgogCgogCgogCgogCgpCcmFpbm9taXggRXVyb3BlIExpbWl0ZWQKU3VpdGUgMTAzODAKCjI2LzI3IFVwcGVyIFBlbWJyb2tlIFN0cmVldApEdWJsaW4gMiBEMDIsIFgzNjEgSXJlbGFuZAoKIAoKMTAuMi4KCnRha2luZyBpbnRvIGFjY291bnQ6IHRoZSBzdGF0ZSBvZiB0aGUgYXJ0OyB0aGUgY29zdHMKb2YgaW1wbGVtZW50YXRpb247IHRoZSBuYXR1cmUsIHNjb3BlLCBjb250ZXh0IGFuZApwdXJwb3NlcyBvZiB0aGUgUHJvY2Vzc2luZzsgdGhlIHJpc2sgb2YgdmFyeWluZwp8aWtlfGlob29kIGFuZCBzZXZlcml0eSBmb3IgdGhlIHJpZ2h0cyBhbmQgZnJlZWRvbXMKb2YgRGF0YSBTdWJqZWN0czsgYW5kIHRoZSByaXNrcyBwcmVzZW50ZWQgYnkKUHJvY2Vzc2luZyAoaW4gcGFydGljdWxhciBmcm9tIGFjY2lkZW50YXwgb3IKdW58YXdmdXwgZGVzdHJ1Y3Rpb24sIGxvc3MsIGFsdGVyYXRpb24sIHVuYXV0aG9yaXNlZApkaXNjbG9zdXJlIG9mLCBvciBhY2Nlc3MgdG8gdGhlIEhvc3BpdGFsIFBlcnNvbmFsCkRhdGEpLCB0YWtlIGFwcHJvcHJpYXRlIHRlY2huaWNhfCBhbmQKb3JnYW5pc2F0aW9uYWwgbWVhc3VyZXMgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZQpEYXRhIFByb3RlY3Rpb24gTGVnaXNsYXRpb24gdG8gZW5zdXJlIGEgbGV2ZWwgb2YKc2VjdXJpdHkgZm9yIHRoZSBIb3NwaXRhbCBQZXJzb25hbCBEYXRhIGFwcHJvcHJpYXRlCnRvIHRoZSByaXNrLCBpbmNsdWRpbmcgKHdoZXJlIGFwcHJvcHJpYXRlKTogdGhlCnBzZXVkb255bWlzYXRpb24gYW5kIGVuY3J5cHRpb24gb2YgdGhlIEhvc3BpdGFsClBlcnNvbmFsIERhdGE7IHRoZSBhYml8aXR5IHRvIGVuc3VyZSB0aGUgb25nb2luZwpjb25maWRlbnRpYWxpdHksIGludGVncml0eSwgYXZhaWxhYmlsaXR5IGFuZCByZXNpbGllbmNlCm9mIHRoZSBzeXN0ZW1zIHVzZWQgdG8gUHJvY2VzcyB0aGUgSG9zcGl0YWwKUGVyc29uYWwgRGF0YTsgdGhlIGFiaWxpdHkgdG8gcmVzdG9yZSB0aGUgYXZhaXxhYml8aXR5CmFuZCBhY2Nlc3MgdG8gdGhlIEhvc3BpdGFsIFBlcnNvbmFsIERhdGEgaW4gYSB0aW1lcgptYW5uZXIgaW4gdGhlIGV2ZW50IG9mIGEgcGh5c2ljYWwgb3IgdGVjaG5pY2F8CmluY2lkZW50OyBhbmQgYSBwcm9jZXNzIGZvciByZWd1bGFybHkgdGVzdGluZywKYXNzZXNzaW5nIGFuZCBldmF8dWF0aW5nIHRoZSBlZmZlY3RpdmVuZXNzIG9mCnRlY2huaWNhfCBhbmQgb3JnYW5pc2F0aW9uYWwgbWVhc3VyZXMgZm9yIGVuc3VyaW5nCnRoZSBzZWN1cml0eSBvZiB0aGUgUHJvY2Vzc2luZyBvZiB0aGUgSG9zcGl0YWwKUGVyc29uYWwgRGF0YTsgOyB0aGUgbWluaW11bSBzY29wZSBvZiB0ZWNobmljYXwKYW5kIG9yZ2FuaXphdGlvbmFsIHNlY3VyaXR5IG1lYXN1cmVzIGlzIHNldCBmb3J0aCBpbgpBcHBlbmRpeCAyQSB0byB0aGlzQW5uZXgyCgoxMC4yLgoKcyBwxZlpaGzDqWRudXTDrW0ga2Ugc3RhdnUgdGVjaG5pa3ksIG7DoWtsYWTFr20gbmEKcHJvdmVkZW7DrSwgcG92YXplLCByb3pzYWh1LCBrb250ZXh0dSBhIMO6xI1lbMWvbQpacHJhY292w6Fuw60gaSBrIHLFr3puxJsgcHJhdmTEm3BvZG9ibsO9bSBhIHLFr3puxJsKemF2YcW+bsO9bSByaSBrxa9tIHBybyBwcsOhdmEgYSBzdm9ib2R5IHN1Ympla3TFrwrDumRhasWvIGEgayByaXppa8WvbSBwxZllZHN0YXZvdmFuw71tIFpwcmFjb3ZhbsOtbQooemVqbcOpbmEgdiBkxa9zbGVka3UgbsOhaG9kbsOpaG8gbmVibwpwcm90aXByw6F2bsOtaG8gem5pxI1lbsOtLCB6dHJhdHksIHBvem3Em27Em27DrSwKbmVvcHLDoXZuxJtuw6lobyB6cMWZw61zdHVwbsSbbsOtIG5lYm8gcMWZw61zdHVwdSBrCm9zb2Juw61tIMO6ZGFqxa9tIE5lbW9jbmljZSksIHDFmWlqbW91dCB2aG9kbmEKdGVjaG5pY2thIGFvcmdhbml6YcSNbsOtIG9wYXTFmWVuw60gdiBzb3VsYWR1IHMKcHLDoXZuw61taSBwxZllZHBpc3kgbyBvY2hyYW7EmyBvc29ibsOtY2ggw7pkYWrFrywgYWJ5CnphamlzdGlsYSDDunJvdmXFiCB6YWJlenBlxI1lbsOtIG9zb2Juw61jaCDDumRhasWvCk5lbW9jbmljZSBvZHBvdsOtZGFqw61jw60gZGFuw6ltdSByaXppa3UsIHDFmcOtcGFkbsSbCnbEjWV0bsSbOiBwc2V1ZG9ueW1pemFjZSBhIMWhaWZyb3ZhbsOtIG9zb2Juw61jaCDDumRhasWvCk5lbW9jbmljZTsgc2Nob3Bub3N0aSB6YWppc3RpdCBuZXVzdGFsb3UKZMWvdsSbcm5vc3QsIGludGVncml0dSwgZG9zdHVwbm9zdCBhIG9kb2xub3N0CnN5c3TDqW3FryBwb3XFvsOtdmFuw71jaCBrZSBacHJhY292w6Fuw60gb3NvYm7DrWNoCsO6ZGFqxa8gTmVtb2NuaWNlOyBzY2hvcG5vc3RpIG9ibm92aXQgZG9zdHVwbm9zdAphcMWZw61zdHVwIGsgb3NvYm7DrW0gw7pkYWrFr20gTmVtb2NuaWNlIHbEjWFzCnZwxZnDrXBhZMSbIGZ5emlja8O9Y2ggxI1pIHRlY2huaWNrw71jaCBpbmNpZGVudMWvOwphcHJvY2VzdSBwcmF2aWRlbG7DqWhvIHRlc3RvdmFuw60sIHBvc3V6b3bDoW7DrQphaG9kbm9jZW7DrSDDusSNaW5ub3N0aSB6YXZlZGVuw71jaCB0ZWNobmlja8O9Y2gKYSBvcmdhbml6YcSNbsOtY2ggb3BhdMWZZW7DrSBwcm8gemFqacWhdMSbbsOtIGJlenBlxI1ub3N0aQpacHJhY292w6Fuw60gb3NvYm7DrWNoIMO6ZGFqxa8gTmVtb2NuaWNlOyA7Cm1pbmltYWxuw60gcm96c2FoIHRlY2huaWNrw71jaCBhIG9yZ2FuaXphxI1uw61jaAp6YWJlenBlxI1lbsOtamUgcMWZw61sb2hvdSAyQSBrdMOpdG8gUMWZw61sb3plIDIKCiAKCiAKCjEwLjMuCgp0YWtlIHJlYXNvbmFibGUgc3RlcHMgdG8gZW5zdXJlIHRoYXQgQnJhaW5vbWl4J3MKUGVyc29ubmVsIGF1dGhvcmlzZWQgYnkgQnJhaW5vbWl4IHRvIFByb2Nlc3MgYW55Cm9mIHRoZSBIb3NwaXRhbCBQZXJzb25hbCBEYXRhIGhhdmUgY29tbWl0dGVkCnRoZW1zZWx2ZXMgdG8ga2VlcCB0aGF0IEhvc3BpdGFsIFBlcnNvbmFsIERhdGEKKGV4Y2VwdCBpbiByZWxhdGlvbiB0byBhbnkgSG9zcGl0YWwgUGVyc29uYWwgRGF0YQp0aGF0IGlzIGluIHRoZSBwdWJsaWMgZG9tYWluKSBjb25maWRlbnRpYXwgb3IgYXJlCnVuZGVyIGFuIGFwcHJvcHJpYXRlIHN0YXR1dG9yeSBvYmxpZ2F0aW9uIG9mCmNvbmZpZGVudGlhbGl0eTsKCjEwLjMuCgp1xI1pbml0IHZob2Ruw6kga3Jva3ksIGFieSB6YWppc3RpbGEsIMW+ZSBwZXJzb25hbApCcmFpbm9taXggb3Byw6F2bsSbbsO9IHNwb2xlxI1ub3N0w60gQnJhaW5vbWl4IGtlClpwcmFjb3bDoW7DrSBvc29ibsOtY2ggw7pkYWrFryBOZW1vY25pY2Ugc2UgemF2YcW+ZQprbWzEjWVubGl2b3N0aSBvIG9zb2Juw61jaCDDumRhasOtY2ggTmVtb2NuaWNlCihzIHbDvWppbWtvdSB0xJtjaCBvc29ibsOtY2ggw7pkYWrFryBOZW1vY25pY2UsIGt0ZXLDqQpqc291IHZlxZllam7EmyBwxZnDrXN0dXBuw6kpIG5lYm8gxb5lIHNlIG5hIG7Em2ogdnp0YWh1amUKemFrb25uYSBwb3Zpbm5vc3QgbWzEjWVubGl2b3N0aTsKCiAKCjEwLjQuCgp0YWtlIHJlYXNvbmFibGUgc3RlcHMgdG8gZW5zdXJlIHRoYXQgYW55CmluZGl2aWR1YWxzIGFjdGluZyB1bmRlciBCcmFpbm9taXgncyBhdXRob3JpdHkgYW5kCndobyBoYXZlIGFjY2VzcyB0byBhbnkgb2YgdGhlIEhvc3BpdGFsIFBlcnNvbmFsCkRhdGEgZG8gbm90IFByb2Nlc3MgdGhlbSBleGNlcHQgb24gaW5zdHJ1Y3Rpb25zCmZyb20gdGhlIEhvc3BpdGFsLCB1bmxlc3MgdGhleSBhcmUgcmVxdWlyZWQgdG8gZG8Kc28gYnkgYW55IGxhdyBhcHBsaWNhYmxlIHRvIEJyYWlub21peDsKCjEwLjQuCgp1xI1pbml0IHZob2Ruw6kga3Jva3ksIGFieSB6YWppc3RpbGEsIMW+ZSBmeXppY2vDqSBvc29ieQpqZWRuYWrDrWPDrSB6IGplasOtaG8gcG92xJvFmWVuw60sIGt0ZXLDqSBtYWrDrSBwxZnDrXN0dXAKa29zb2Juw61tIMO6ZGFqxa9tIE5lbW9jbmljZSwgYnVkb3UgdHl0byDDumRhamUKenByYWNvdsOhdmF0IHBvdXplIG5hIHrDoWtsYWTEmyBwb2t5bsWvIHZ5ZGFuw71jaApOZW1vY25pY8OtLCB8ZWRhxb5lIGppbSBacHJhY292w6Fuw60gdMSbY2h0byDDumRhasWvCnVrbGFkYWrDrSBwcsOhdm7DrSBwxZllZHBpc3ksIGt0ZXLDqSBzZSBuYSBzcG9sZcSNbm9zdApCcmFpbm9taXh2enRhaHVqw607CgogCgoxMC41LgoKbm90aWZ5IHRoZSBIb3NwaXRhbCBvZiBhbnkgUGVyc29uYWwgRGF0YSBCcmVhY2gKYWZmZWN0aW5nIHRoZSBIb3NwaXRhbCBQZXJzb25hbCBEYXRhIHdpdGhvdXQgdW5kdWUKZGV8YXksIGhvd2V2ZXIgMjQgaG91cnMgYXQgdGhlIGxhdGVzdCwgYWZ0ZXIKQnJhaW5vbWl4IGJlY29tZXMgYXdhcmUgb2YgaXQ7CgoxMC41LgoKaW5mb3Jtb3ZhdCBOZW1vY25pY2kgbyBwb3J1xaFlbsOtIHphYmV6cGXEjWVuw60Kw7pkYWrFrywgcG9rdWQgc2UgcG9ydcWhZW7DrSBkb3RrfG8gb3NvYm7DrWNoIMO6ZGFqxa8KTmVtb2NuaWNlLCBhIHRvIGJleiB6Ynl0ZcSNbsOpaG8gcHJvZGxlbsOtLApuZWpwb3pkxJtqaSB2xaFhayAyNCBob2RpbiBwb3TDqSwgY28gc2UgQnJhaW5vbWl4IG8KcG9ydcWhZW7DrWRvenbDrTsKCiAKCiAKCjEwLjYuCgpub3QgdHJhbnNmZXIgYW55IG9mIHRoZSBIb3NwaXRhbCBQZXJzb25hbCBEYXRhCm91dHNpZGUgdGhlIEV1cm9wZWFuIEVjb25vbWljIEFyZWEgKGluY2x1ZGluZyB0bwpCcmFpbm9taXgncyBTdWJwcm9jZXNzb3JzIGluIHRoZSBVbml0ZWQgS2luZ2RvbSkKb3IgdG8gYW4gaW50ZXJuYXRpb25hbCBvcmdhbmlzYXRpb24gdW5sZXNzOiBpKSB0aGUKdHJhbnNmZXIgaXMgdG8gdGhlIFVuaXRlZCBLaW5nZG9tIGFuZCwgdW5kZXIgdGhlCkVVw41VSyBUcmFkZSBBZ3JlZW1lbnQsIHRoZSBVbml0ZWQgS2luZ2RvbSBpcwpub3QgdHJlYXRlZCBhcyBhIHRoaXJkIGNvdW50cnk7IGlpKSB0aGUgRXVyb3BlYW4KQ29tbWlzc2lvbiBoYXMgZGVjaWRlZCB0aGF0IHRoZSBjb3VudHJ5IHRvIHdoaWNoCgogCgoxMC42LgoKbmVwxZllZGF2YXQgb3NvYm7DrSDDumRhamUgTmVtb2NuaWNlIG1pbW8KRXZyb3Bza8O9IGhvc3BvZMOhxZlza8O9IHByb3N0b3IgKHTDvWvDoSBzZSB0YWvDqSBEw61sxI3DrWNoCnpwcmFjb3ZhdGVsxa8gQnJhaW5vbWl4IHZlIFNwb2plbsOpbSBrcsOhbG92c3R2w60pCmFuaSBqZSBuZXDFmWVkYXZhdCBtZXppbsOhcm9kbsOtIG9yZ2FuaXphY2ksIHxlZGHFvmU6IGkpCsO6ZGFqZSBtYWrDrSBiw710IHDFmWVkw6FueSBkbyBTcG9qZW7DqWhvIGtyw6Fsb3ZzdHbDrSBhIHYKc291bGFkdSA1IE9iY2hvZG7DrSBkb2hvZG91IEVVw41VSyBuZW7DrSBTcG9qZW7DqQprcsOhbG92c3R2w60gcG92YcW+b3bDoW5vIHphIHTFmWV0w60gemVtaTsgaWkpIEV2cm9wc2vDoQprb21pc2Ugcm96aG9kbGEsIMW+ZSB6ZW3EmywgZG8gbsOtxb4gbWFqw60gYsO9dCBvc29ibsOtCgogCgogCgpCcmFpbm9taXggRXVyb3BlIExpbWl0ZWQKU3VpdGUgMTAzODAKCjI2LzI3IFVwcGVyIFBlbWJyb2tlIFN0cmVldApEdWJsaW4gMiBEMDIsIFgzNjEgSXJlbGFuZAoKIAoKdGhlIEhvc3BpdGFsIFBlcnNvbmFsIERhdGEgaXMgdG8gYmUgdHJhbnNmZXJyZWQgb3IKb25lIG9yIG1vcmUgc3BlY2lmaWVkIHNlY3RvcnMgd2l0aGluIHRoYXQgY291bnRyeSwKb3IgdGhlIGludGVybmF0aW9uYWwgb3JnYW5pc2F0aW9uIGluIHF1ZXN0aW9uLAplbnN1cmVzIGFuIGFkZXF1YXRlIGxldmVsIG9mIHByb3RlY3Rpb24gZm9yClBlcnNvbmFsIERhdGEgdW5kZXIgQXJ0aWNsZSA0NSBvZiB0aGUgR0RQUjsgb3IgaWlpKQp0aGUgY29uZGl0aW9ucyBmb3IgdGhlIHRyYW5zZmVyIG9mIHBlcnNvbmFsIGRhdGEKd2l0aGluIHRoZSBtZWFuaW5nIG9mIEFydGljbGUgNDYgb2YgdGhlIEdEUFIgYW5kCnJlbGV2YW50IGxlZ2lzbGF0aW9uIGFyZSBtZXQ7CgrDumRhamUgTmVtb2NuaWNlIHDFmWVkYW7DvSwgbmVibyBqZWRlbiDEjWkgbsSba29saWsKa29ua3LDqXRuw61jaCBzZWt0b3LFryB1dm5pdMWZIGRvdHnEjW7DqSB6ZW3EmywgbmVibwpkb3R5xI1uw6EgbWV6aW7DoXJvZG7DrSBvcmdhbml6YWNlLCB6YWppxaHFpXVqZQpvZHBvdsOtZCDDunJvdmXFiCBvY2hyYW55IG9zb2Juw61jaCDDumRhasWvIHYKc291bGFkdSBzIMSNbMOhbmtlbSA0NSBHRFBSOyBuZWJvIGlpaSkganNvdSBzcGxuxJtueQpwb2Rtw61ua3kgcHJvIHDFmWVkw6Fuw60gb3NvYm7DrWNoIMO6ZGFqxa8gdmUgc215c2x1CsSNbMOhbmt1IDQ2IEdEUFIgYSBwxZnDrXNsdcWhbsO9Y2ggcHLDoXZuw61jaCBwxZllZHBpc8WvOwoKICAKCiAKCjEwLjcuCgpzaG91bGQgdGhlIFVuaXRlZCBLaW5nZG9tIGJlIHRyZWF0ZWQgYXMgYSB0aGlyZApjb3VudHJ5IGFuZCB0aGUgRXVyb3BlYW4gVW5pb24gbm90IHJlY29nbmlzZQp0aGF0IHRoZSBVbml0ZWQgS2luZ2RvbSBlbnN1cmVzIGFuIGFkZXF1YXRlCmxldmVsIG9mIHByb3RlY3Rpb24gZm9yIFBlcnNvbmFsIERhdGEsIHRha2Ugc3RlcHMgdG8KY29tcGx5IHdpdGggYW55IGd1aWRhbmNlIGlzc3VlZCBieSB0aGUgRXVyb3BlYW4KVW5pb24gYW5kL29yIHRoZSBFdXJvcGVhbiBEYXRhIFByb3RlY3Rpb24gQm9hcmQKcmVsYXRpbmcgdG8gdHJhbnNmZXJzIG9mIFBlcnNvbmFsIERhdGEgZnJvbSB0aGUKRXVyb3BlYW4gRWNvbm9taWMgQXJlYSB0byB0aGUgVW5pdGVkIEtpbmdkb20sCmluY2x1ZGluZywgaWYgbmVjZXNzYXJ5LCBwdXR0aW5nIGluIHBsYWNlIFN0YW5kYXJkCkNvbnRyYWN0dWFsIGNsYXVzZXMgb3IgcHJvdmlzaW9ucyBiYXNlZCBvbgpTdGFuZGFyZCBDb250cmFjdHVhbCBjbGF1c2VzOwoKMTAuNy4KCnYgcMWZw61wYWTEmywgxb5lIFNwb2plbsOpIGtyw6Fsb3ZzdHbDrSBidWRlIHBvdmHFvm92w6Fubwp6YSB0xZlldMOtIHplbWkgYSBFdnJvcHNrw6EgdW5pZSBuZXV6bmEsIMW+ZSBTcG9qZW7DqQprcsOhbG92c3R2w60gemFqacWhxaV1amUgb2Rwb3bDrWRhasOtY8OtIMO6cm92ZcWIIG9jaHJhbnkKb3NvYm7DrWNoIMO6ZGFqxa8sIHXEjWluaXQga3Jva3kga2Ugc3BsbsSbbsOtIHBva3luxa8KdnlkYW7DvWNoIEV2cm9wc2tvdSB1bmnDrSBhL25lYm8gRXZyb3Bza8O9bQpzYm9yZW0gcHJvIG9jaHJhbnUgb3NvYm7DrWNoIMO6ZGFqxa8gb2hsZWRuxJsKcMWZZWTDoXbDoW7DrSBvc29ibsOtY2ggw7pkYWrFryB6IEV2cm9wc2vDqWhvCmhvc3BvZMOhxZlza8OpaG8gcHJvc3RvcnUgZG8gU3BvamVuw6lobyBrcsOhbG92c3R2w60sCmNvxb4gbcWvxb5lIHZwxZnDrXBhZMSbIG51dG5vc3RpIHphaHJub3ZhdCBtaW1vIGppbsOpCnVwbGF0bsSbbsOtIFN0YW5kYXJkbsOtY2ggc21sdXZuw61jaCBkb3xvxb5layBuZWJvCnVzdGFub3ZlbsOtIHZ5Y2jDoXplasOtY8OtY2ggemUgU3RhbmRhcmRuw61jaApzbWx1dm7DrWNoIGRvfG/FvmVrOwoKIAoKMTAuOC4KCmtlZXAgcmVjb3JkcyBvZiBpdHMgUHJvY2Vzc2luZyBvZiB0aGUgSG9zcGl0YWwKUGVyc29uYWwgRGF0YSBpbmNsdWRpbmc6IHRoZSBIb3NwaXRhbCdzIG5hbWUgYW5kCmNvbnRhY3QgZGV0YWlsczsgdGhlIG5hbWUgYW5kIGNvbnRhY3QgZGV0YWlscyBvZgp0aGUgSG9zcGl0YWwncyBhbmQgQnJhaW5vbWl4J3MgcmVzcGVjdGl2ZSBEYXRhClByb3RlY3Rpb24gT2ZmaWNlcnMgKGlmIGFueSk7IHRoZSBuYW1lIGFuZCBjb250YWN0CmRldGFpbHMgb2Z0aGUgSG9zcGl0YWwncyBSZXByZXNlbnRhdGl2ZSAoaWYgYW55KTsgdGhlCmNhdGVnb3JpZXMgb2YgUHJvY2Vzc2luZyBvZiB0aGUgSG9zcGl0YWwgUGVyc29uYWwKRGF0YTsgZGV0YWlscyBvZiB0cmFuc2ZlcnMgb2YgYW55IG9mIHRoZSBIb3NwaXRhbApQZXJzb25hbCBEYXRhIG91dHNpZGUgdGhlIEV1cm9wZWFuIEVjb25vbWljIEFyZWEKb3IgdG8gYW4gaW50ZXJuYXRpb25hbCBvcmdhbmlzYXRpb24gKGluY2x1ZGluZywKd2hlcmUgYXBwbGljYWJsZSwgdGhlIGRvY3VtZW50YXRpb24gb2YKQXBwcm9wcmlhdGUgU2FmZWd1YXJkcyB0YWtlbiBieSBCcmFpbm9taXggb3IgdGhlCkhvc3BpdGF8KTsgYW5kIGEgZ2VuZXJhbCBkZXNjcmlwdGlvbiBvZiB0aGUKdGVjaG5pY2FsIGFuZCBvcmdhbmlzYXRpb25hbCBzZWN1cml0eSBtZWFzdXJlcwp0YWtlbiBieSBCcmFpbm9taXguIElmIHJlcXVlc3RlZCBieSB0aGUgSG9zcGl0YWwsCkJyYWlub21peCB3aXx8IG1ha2UgdGhhdCBpbmZvcm1hdGlvbiBhdmFpbGFibGUgdG8KdGhlIEhvc3BpdGFsIHRvIGhlbHAgZGVtb25zdHJhdGUgQnJhaW5vbWl4J3MKY29tcGxpYW5jZSB3aXRoIGl0cyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIGNsYXVzZQoxMDsKCjEwLjguCgp2w6lzdCB6w6F6bmFteSBvIHN2w71jaCDEjWlubm9zdGVjaCB6cHJhY292w6Fuw60Kb3NvYm7DrWNoIMO6ZGFqxa8gTmVtb2NuaWNlLCB6ZWptw6luYTogbsOhemV2CmEga29udGFrdG7DrSDDumRhamUgTmVtb2NuaWNlOyBqbcOpbm8gYSBrb250YWt0bsOtCsO6ZGFqZSBwb3bEm8WZZW5jZSBwcm8gb2NocmFudSBvc29ibsOtY2ggw7pkYWrFrwpOZW1vY25pY2UgYSBzcG9sZcSNbm9zdGkgQnJhaW5vbWl4IChieWxybGkgdXLEjWVuKTsKam3DqW5vIGEga29udGFrdG7DrSDDumRhamUgemFzdHVwY2UgTmVtb2NuaWNlIChieWxpCnxpIHVyxI1lbik7IGthdGVnb3JpZSB6cHJhY292w6F2YW7DvWNoIG9zb2Juw61jaCDDumRhasWvCk5lbW9jbmljZTsgaW5mb3JtYWNlIG8gcMWZw61wYWRuw6ltIHDFmWVkw6Fuw60Kb3NvYm7DrWNoIMO6ZGFqxa8gTmVtb2NuaWNlIG1pbW8gRXZyb3Bza8O9Cmhvc3BvZMOhxZlza8O9IHByb3N0b3IgbmVibyBvIGplamljaCBwxZllZMOhbsOtCm1lemluw6Fyb2Ruw60gb3JnYW5pemFjaSAodsSNZXRuxJsgcMWZw61wYWRuw6lobwpkb2xvxb5lbsOtIHZob2Ruw71jaCB6YXJ1ayB6YXZlZGVuw71jaCBzcG9sZcSNbm9zdMOtCkJyYWlub21peCBuZWJvIE5lbW9jbmljw60pOyBhIG9iZWNuw70gcG9waXMKdGVjaG5pY2vDvWNoIGEgb3JnYW5pemHEjW7DrWNoIGJlenBlxI1ub3N0bsOtY2gKb3BhdMWZZW7DrSBwxZlpamF0w71jaCBzcG9sZcSNbm9zdMOtIEJyYWlub21peC4gTmEKcG/FvsOhZMOhbsOtIE5lbW9jbmljZSBCcmFpbm9taXggdHl0byBpbmZvcm1hY2UKTmVtb2NuaWNpIHpwxZnDrXN0dXBuw60gamFrbyBkxa9rYXogc3BsbsSbbsOtCnBvdmlubm9zdMOtLCBqaW1pxb4gamUgc3BvbGXEjW5vc3QgQnJhaW5vbWl4IHYgc291bGFkdQpzdMOtbXRvIMSNfC4xMHZhemFuYTsKCiAKCiAKCjEwLjkuCgp0YWtpbmcgaW50byBhY2NvdW50IHRoZSBuYXR1cmUgb2YgdGhlIFByb2Nlc3Npbmcgb2YKdGhlIEhvc3BpdGFsIFBlcnNvbmFsIERhdGEgY2FycmllZCBvdXQgYnkgQnJhaW5vbWl4CmFuZCB0aGUgaW5mb3JtYXRpb24gYXZhaWxhYmxlIHRvIEJyYWlub21peCwgaW5zb2ZhcgphcyBpcyByZWFzb25hYmx5IHBvc3NpYmxlLCBCcmFpbm9taXggd2lsbCwgaWYKcmVxdWVzdGVkIGJ5IHRoZSBIb3NwaXRhbCwgYXNzaXN0IHRoZSBIb3NwaXRhbCB3aXRoCmNvbXBsaWFuY2Ugd2l0aCB0aGUgSG9zcGl0YWwncyBvYmxpZ2F0aW9ucyBpbgpyZWxhdGlvbiB0byBkYXRhIHNlY3VyaXR5LCB0aGUgbm90aWZpY2F0aW9uIG9mClBlcnNvbmFsIERhdGEgQnJlYWNoZXMgdG8gdGhlIE9mZmljZSBmb3IgdGhlClBlcnNvbmFsIERhdGEgUHJvdGVjdGlvbiBhbmQgKHdoZXJlIHJlcXVpcmVkIGJ5CnRoZSBEYXRhIFByb3RlY3Rpb24gTGVnaXNsYXRpb24pIERhdGEgU3ViamVjdHMsCmNhcnJ5aW5nIG91dCBEYXRhIFByb3RlY3Rpb24gSW1wYWN0IEFzc2Vzc21lbnRzCmFuZCB0aGUgSG9zcGl0YWwncyBvYmxpZ2F0aW9ucyB0byByZXNwb25kIHRvCnJlcXVlc3RzIGZvciBleGVyY2lzaW5nIERhdGEgU3ViamVjdCdzIHJpZ2h0cyBzdWNoCmFzIHRoZSByaWdodCB0byBpbmZvcm1hdGlvbiBhbmQgYWNjZXNzIHRvLCBhbmQgdGhlCnJlY3RpZmljYXRpb24gYW5kIGVyYXN1cmUgb2YsIHRoZWlyIFBlcnNvbmFsIERhdGEKdGhhdCBpcyBpbmNsdWRlZCBpbiB0aGUgSG9zcGl0YWwgUGVyc29uYWwgRGF0YTsKQnJhaW5vbWl4IGFsc28gdW5kZXJ0YWtlcyB0byBwcm92aWRlIGVmZmVjdGl2ZQoKIAoKMTAuOS4KCnDFmWkgem9obGVkbsSbbsOtIHBvdmFoeSBacHJhY292w6Fuw60gb3NvYm7DrWNoIMO6ZGFqxa8KTmVtb2NuaWNlIHNwb2xlxI1ub3N0w60gQnJhaW5vbWl4IGEgaW5mb3JtYWPDrSwgamXFvgptw6EgQnJhaW5vbWl4IGsgZGlzcG96aWNpLCBiw710IE5lbW9jbmljaSBuYQpwb8W+w6Fkw6Fuw60gbmFwb21vY25hIHDFmWkgemFqacWhxaVvdsOhbsOtIHNvdWxhZHUKcyBwb3Zpbm5vc3RtaSBOZW1vY25pY2UsIHBva3VkIGpkZSBvIGJlenBlxI1ub3N0Cm9zb2Juw61jaCDDumRhasWvLCBvaGxhxaFvdsOhbsOtIHDFmcOtcGFkxa8gcG9ydcWhZW7DrQp6YWJlenBlxI1lbsOtIG9zb2Juw61jaCDDumRhasWvIMOaxZlhZHUgcHJvIG9jaHJhbnUKb3NvYm7DrWNoIMO6ZGFqxa8gYSAodWtsYWRhasOtcmxpIHRvIHByw6F2bsOtIHDFmWVkcGlzeQpvb2NocmFuxJsgb3NvYm7DrWNoIMO6ZGFqxa8pIHRha8OpIHN1Ympla3TFr20gw7pkYWrFrywKcMWZaSBwb3N1em92w6Fuw60gdmxpdnUgbmEgb2NocmFudSBvc29ibsOtY2ggw7pkYWrFryBhCnDFmWkgcGxuxJtuw60gcG92aW5ub3N0w60gTmVtb2NuaWNlIHJlYWdvdmF0IG5hCsW+w6Fkb3N0aSBvIHbDvWtvbiBwcmF2IHN1Ympla3R1IG9zb2Juw61jaCDDumRhasWvLApuYXDFmcOta2xhZCBwcsOhdmEgbmEgaW5mb3JtYWNlIGEgbmEgcMWZw61zdHVwIGtqZWhvCm9zb2Juw61tIMO6ZGFqxa9tIG9ic2HFvmVuw71tIHYgb3NvYm7DrWNoIMO6ZGFqw61jaApOZW1vY25pY2UgYSBwcsOhdmEgbmEgamVqaWNoIG9wcmF2dSBhIHbDvW1hejsgOyBrCnBvc2t5dG92w6Fuw60gZWZla3Rpdm7DrSBzb3XEjWlubm9zdGkgc2Ugc3BvbGXEjW5vc3QKQnJhaW5vbWl4IHphdmF6dWplIGkgdiBwxZnDrXBhZMSbLCDFvmUgYnVkZSB2CgogCgogCgpCcmFpbm9taXggRXVyb3BlIExpbWl0ZWQKU3VpdGUgMTAzODAKCjI2LzI3IFVwcGVyIFBlbWJyb2tlIFN0cmVldApEdWJsaW4gMiBEMDIsIFgzNjEgSXJlbGFuZAoKIAoKY29vcGVyYXRpb24gaW4gdGhlIGV2ZW50IHRoYXQgYW4gaXNucGVjdGlvbiBieSBhCnN1cGVydmlzb3J5IGF1dGhvcml0eSBpcyBpbml0aWF0ZWQgYXQgdGhlIEhvc3BpdGFsLCBvcgppZiBhZG1pbmlzdHJhdGl2ZSBvciBqdWRpY2lhfCBwcm9jZWVkaW5ncyByZWxhdGVkIHRvCnRoZSBwcm9jZXNzaW5nIG9mIHBlcnNvbmFsIGRhdGEgcHVyc3VuYXQgdW5kZXIKdGhpcyBBZ3JlZW1lbnQgYXJlIGNvbmR1Y3RlZCwgb3IgYW4gYXVkaXQgaXMKY29uZHVjdGVkOwoKTmVtb2NuaWNpIHphaGFqZW5hIGtvbnRyb2xhIHplIHN0cmFueSBkb3pvcm92w6lobwrDusWZYWR1LCBidWRlIHZlZGVubyBzcHLDoXZuw60gxI1pIHNvdWRuw60gxZnDrXplbsOtCnNvdXZpc2Vqw61jw60gc2UgenByYWNvdsOhbsOtbSBvc29ibsOtY2ggw7pkYWrFryBkbGUgdMOpdG8Kc21sb3V2eSwgbmVibyBidWRlIHByb3bDoWTEm24gYXVkaXQ7CgogCgoxMC4xMC5hfHxvdyB0aGUgSG9zcGl0YWwgKG9yIGEgcGVyc29uIGFwcG9pbnRlZCBieSB0aGUKSG9zcGl0YWwpIHRvIGF1ZGl0IGFuZCBpbnNwZWN0IEJyYWlub21peCdzClByb2Nlc3Npbmcgb2YgdGhlIEhvc3BpdGFsIFBlcnNvbmFsIERhdGEsIHByb3ZpZGVkCmFueSBzdWNoIGF1ZGl0IG9yIGluc3BlY3Rpb24gaXMgY2FycmllZCBvdXQgZHVyaW5nCkJyYWlub21peCdzIG5vcm1hfCB3b3JraW5nIGhvdXJzLCBvbiBub3QgbGVzcwp0aGFuIDcgZGF5cycgYWR2YW5jZSB3cml0dGVuIG5vdGljZSBhbmQgbm8gbW9yZQp0aGFuIG9uY2UgaW4gZXZlcnkgMTIgbW9udGhzOyBhbmQKCjEwLjEwLnVtb8W+bml0IE5lbW9jbmljaSAobmVibyBvc29ixJsgTmVtb2NuaWPDrQp1csSNZW7DqSkgYXVkaXQgYSBpbnNwZWtjaSB6cMWvc29ixa8gWnByYWNvdsOhbsOtCm9zb2Juw61jaCDDumRhasWvIE5lbW9jbmljZSBzcG9sZcSNbm9zdMOtIEJyYWlub21peCwKcMWZacSNZW3FviB0ZW50byBhdWRpdCDEjWkgaW5zcGVrY2UgbXVzw60gcHJvYsSbaG5vdXQKdmLEm8W+bsOpIHByYWNvdm7DrSBkb2LEmyBzcG9sZcSNbm9zdGkgQnJhaW5vbWl4LCBuYQp6w6FrbGFkxJsgcMOtc2VtbsOpaG8gb3puYW1lbsOtIGRhbsOpaG8gbmVqbcOpbsSbCjdkbsWvIHDFmWVkZW0sIGEgbmUgxI1hc3TEm2ppIG5lxb4gamVkbm91IHphCjEyIG3Em3PDrWPFrzthCgogCgoxMC4xMS4gZGVsZXRlIG9yIHByb3ZpZGUgdGhlIEhvc3BpdGFsIFBlcnNvbmFsIERhdGEgdG8KdGhlIEhvc3BpdGFsIG9uIHRoZSB0ZXJtaW5hdGlvbiBvciBleHBpcnkgb2YgdGhlCkFncmVlbWVudCAoaG93ZXZlciBpdCBoYXBwZW5zKSBhbmQgZGV8ZXRlIGF8fApjb3BpZXMgb2YgdGhlIEhvc3BpdGFsIFBlcnNvbmFsIERhdGEgZXhjZXB0IGFueQpjb3B5IHRoYXQgQnJhaW5vbWl4IG5lZWRzIHRvIHJldGFpbiBmb3IgbGVnYWwKcHVycG9zZXMgb3IgdG8gY29tcGx5IHdpdGggdGhlIHJlcXVpcmVtZW50cyBvZgphbnkgbGF3LCByZWd1bGF0aW9uLCBvciBnb3Zlcm5tZW50IG9yIHJlZ3VsYXRvcnkKYm9keSB0byB3aGljaCBCcmFpbm9taXggaXMgc3ViamVjdC4KCjEwLjExLnDFmWkgdWtvbsSNZW7DrSBuZWJvIHZ5cHLFoWVuw61TbUlvdXZ5KGJleiBvaGxlZHUgbmEKZMWvdm9kKSB2eW1hxb5lIG5lYm8gcMWZZWRhIE5lbW9jbmljaSB2xaFlY2hueQpvc29ibsOtIMO6ZGFqZSBOZW1vY25pY2UgYSB2eW1hxb5lIHRha8OpIHbFoWVjaG55CmtvcGllIG9zb2Juw61jaCDDumRhasWvIE5lbW9jbmljZSwga3JvbcSbIGtvcGnDrSwKa3RlcsOpIGplIHNwb2xlxI1ub3N0IEJyYWlub21peCBwb3Zpbm5hIHVjaG92YXQgegpkxa92b2TFryBkYW7DvWNoIHrDoWtvbmVtIG5lYm8gcHJvIHNwbG7Em27DrQp1c3Rhbm92ZW7DrSB6w6Frb25hLCBqaW7DqWhvIHDFmWVkcGlzdSBuZWJvIG5hxZnDrXplbsOtCnN0YXRuw61obyDEjWkgcmVndWxhdG9ybsOtaG8gb3JnYW51LCBwb2QgamVob8W+CnByYXZvbW9jIEJyYWlub21peCBzcGFkYS4KCiAKCiAKCiAKCjExLiBUaGUgSG9zcGl0YWxjb25zZW50c3RvQnJhaW5vbWl4IHVzaW5nIFN1YnByb2Nlc3NvcnNpbiAxMS4gTmVtb2NuaWNlIHNvdWhsYXPDrSwgYWJ5IHNwb2xlxI1ub3N0IEJyYWlub21peCBrCm9yZGVyIHRvIHByb3ZpZGUgYW55IFNlcnZpY2VzIHRvIHRoZSBIb3NwaXRhbCBwcm92aWRlZCBwb3NreXRvdmFuw61TSXXFvmViIE5lbW9jbmljaXZ5dcW+w612YWxhIETDrWzEjcOtenByYWNvdmF0ZWxlLAp0aG9zZSBTdWJwcm9jZXNzb3JzIGFyZSBsb2NhdGVkIGluIHRoZSBVbml0ZWQgS2luZ2RvbSBvciBwxZlpxI1lbcW+IHbFoWFrIHRpdG8gRMOtbMSNw60genByYWNvdmF0ZWzDqSBtdXNlasOtIGLDvXQgdXNhemVuaSB2ZQp0aGUgRXVyb3BlYW4gRWNvbm9taWMgQXJlYS4gQnJhaW5vbWl4IHdpfHwgaW1wb3NlIG9uIFNwb2plbsOpbSBrcsOhbG92c3R2w60gbmVibyB2IEV2cm9wc2vDqW0gaG9zcG9kw6HFmXNrw6ltCnRob3NlIFN1YnByb2Nlc3NvcnMgc3Vic3RhbnRpYWxseSB0aGUgc2FtZSBvYmxpZ2F0aW9ucyBhcyBwcm9zdG9ydS4gQnJhaW5vbWl4IHR5dG8gRMOtbMSNw60genByYWNvdmF0ZWxlIHphdmHFvmUKdGhlIG9ibGlnYXRpb25zIGltcG9zZWQgb24gQnJhaW5vbWl4IGluIFBhcnQgMSBvZiB0aGVzZSBzdGVqbsO9bWkgcG92aW5ub3N0bWksIGpha8O9bWkgamUgc2FtYSB2w6F6w6FuYSBuYSB6w6FrbGFkxJsKVGVybXMgb3IsIGluIHRoZSBjYXNlIG9mQW1hem9uIFdlYiBTZXJ2aWNlcyAoQVdTKSwgd2l8fCDEjcOhc3RpIDEgdMSbY2h0byBQb2Rtw61uZWssIG5lYm8sIHYgcMWZw61wYWTEmyBBbWF6b24gV2ViCmNvbnRyYWN0IHdpdGggQVdTIG9uIEFXUydzIHN0YW5kYXJkIHRlcm1zIGZyb20gdGltZSB0byBTZXJ2aWNlcyAoZMOhbGUgamVuIOKAnkFXUyIpLCB1emF2xZllIHMgQVdTIHBvZGxlIHBvdMWZZWJ5CnRpbWUgKGluY2x1ZGluZyBBV1MncyBEYXRhIFByb2Nlc3NpbmcgQWRkZW5kdW0pIGFuZCBzbWxvdXZ1IHphIHN0YW5kYXJkbsOtY2ggcG9kbcOtbmVrIEFXUyAodsSNZXRuxJsgZG9kYXRrdQpCcmFpbm9taXggd2l8fCBlbnN1cmUgdGhhdCB0aGUgSG9zcGl0YWwgUGVyc29uYWwgRGF0YSBoZXxkIEFXUyBvIHpwcmFjb3bDoW7DrSBvc29ibsOtY2ggw7pkYWrFrykgYSB6YWppc3TDrSwgYWJ5IG9zb2Juw60KYnkgQVdTaXMgcHNldWRvbnltaXNlZCBhbmQgZW5jcnlwdGVkLiBCcmFpbm9taXggbWF5IMO6ZGFqZSBOZW1vY25pY2UsIGt0ZXLDqSBtw6EgQVdTIHYgZHLFvmVuw60sIGJ5fHkKYXBwb2ludCBhbnkgYWRkaXRpb25hbCBvciByZXBsYWNlbWVudCBTdWJwcm9jZXNzb3Igb258eSBwc2V1ZG9ueW1pem92YW55IGEgxaFpZnJvdmFueS4gQnJhaW5vbWl4IGplIG9wcsOhdm7Em25hCndpdGggdGhlIEhvc3BpdGFsJ3MgcHJpb3Igd3JpdHRlbiBjb25zZW50LiBCcmFpbm9taXggc2hhbGwgemFwb2ppdCBkYWzFocOtaG8gbmVibyBuYWhyYWRuw61obyBEw61sxI3DrWhvIHpwcmFjb3ZhdGVsZQpub3RpZnkgdGhlIEhvc3BpdGFsIG9mIGl0cyBpbnRlbnRpb24gdG8gYXBwb2ludCBhbnkgcG91emUgbmEgesOha2xhZMSbIHDFmWVkY2hvesOtaG8gcMOtc2VtbsOpaG8gc291aGxhc3UKYWRkaXRpb25hbCBvciByZXBsYWNlbWVudCBTdWJwcm9jZXNzb3IgYXQgbGVhc3QgNyBkYXlzIGluIE5lbW9jbmljZS4gQnJhaW5vbWl4IG96bmFtw60gTmVtb2NuaWNpIHN2xa9qIMO6bXlzbAphZHZhbmNlIGFuZCBzaGFsbCBwcm92aWRlIHRoZSBIb3NwaXRhbCB3aXRoIHJlYXNvbmFibGUgemFwb2ppdCBkYWzFocOtaG8gbmVibyBuYWhyYWRuw61obyBEw61sxI3DrWhvIHpwcmFjb3ZhdGVsZQppbmZvcm1hdGlvbiBhYm91dCBzdWNoIFN1YnByb2Nlc3Nvci4gVGhlIEhvc3BpdGFsIHNoYWxsIGFsZXNwb8WIIDcgZG7FryBwxZllZGVtIGEgcG9za3l0bmUgTmVtb2NuaWNpIHDFmWltxJvFmWVuw6kKbm90IHdpdGhob2xkIG9yIGRlfGF5IGl0cyBjb25zZW50IHdpdGhvdXQgcmVhc29uYWJsZSBpbmZvcm1hY2UgbyB0b210byBEw61sxI3DrW0genByYWNvdmF0ZWxpLiBOZW1vY25pY2UKZ3JvdW5kcy4gQnJhaW5vbWl4IG90aGVyd2lzZSB1bmRlcnRha2VzIHRvIGNvbXBseSB3aXRoIHNvdWhsYXMgbmVvZG3DrXRuZSBiZXogcm96dW1uw6lobyBkxa92b2R1LiBCcmFpbm9taXggc2UKdGhlIGNvbmRpdGlvbnMgZm9yIHRoZSBpbnZvbHZlbWVudCBvZiBhbiBhZGRpdGlvbmFsIGRhdGEgamluYWsgemF2YXp1amUgZG9kcsW+b3ZhdCBwb2Rtw61ua3kgcHJvIHphcG9qZW7DrSBkYWzFocOtaG8KcHJvY2Vzc29yIHdpdGhpbiB0aGUgbWVhbmluZyBvZiBBcnRpY2xlIDI4KDIpIHRvICg0KSBvZiB0aGUgenByYWNvdmF0ZWxlIHZlIHNteXNsdSDEjWzDoW5rdSAyOCBvZHN0LiAyIGHFviA0IEdEUFIuCkdEUFIuIFRoZSBsaXN0IG9mIFN1YnByb2Nlc3NvcnMgY3VycmVudCBhcyBvZiB0aGUgZGF0ZSBvZiBTZXpuYW0gRMOtbMSNw61jaCB6cHJhY292YXRlbMWvIGFrdHVhbG7DrWNoIGtlIGRuaSB1emF2xZllbsOtCmV4ZWN1dGlvbiBvZiB0aGlzIEFncmVlbWVudCBpcyBzZXQgZm9ydGggaW4gQXBwZW5kaXggMkEgdG8gdMOpdG8gU21sb3V2eSBqZSB0dm/FmcOtIHDFmcOtbG9odSAyQiBrdMOpdG8gUMWZw61sb3plIDIuCnRoaXMgQW5uZXggMi4KCjEyLiBCcmFpbm9taXggd2l8fCBpbmRlbW5pZnkgdGhlIEhvc3BpdGFsIGFuZCB3aWxsIGtlZXAgdGhlIDEyLiBCcmFpbm9taXggbmFocmFkw60gTmVtb2NuaWNpIGpha291a298aSBwb2t1dHUgxI1pIHBlbmFsZSwKCkhvc3BpdGFsIGluZGVtbmlmaWVkIGFnYWluc3QgYXx8IGFuZCBhbnkgZmluZXMgYW5kCnBlbmFsdGllcyBpbmN1cnJlZCBieSB0aGUgSG9zcGl0YWwgYW5kIGFnYWluc3QgYW55IGFuZCBhbGwKY29zdHMsIGV4cGVuc2VzLCBkYW1hZ2VzLCBsb3NzZXMgYW5kIHxpYWJpfGl0aWVzIGF3YXJkZWQKYWdhaW5zdCBvciBpbmN1cnJlZCBieSB0aGUgSG9zcGl0YWwgYnV0IG9ufHkgYXMgdGhlIGRpcmVjdApyZXN1bHQgb2YgQnJhaW5vbWl4J3MgUHJvY2Vzc2luZyBhbnkgb2YgdGhlIEhvc3BpdGFsCgogCgpqYWtvxb4gaSB2ZcWha2Vyw6kgbsOha2xhZHksIHbDvWRhamUsIHBvdmlubm9zdGkgayBuYWhyYWTEmwrDumpteS/FoWtvZHksIHp0csOhdHkgYSB6w6F2YXpreSwga3RlcsOpIGrDrSBidWRvdSB1bG/FvmVueSBuZWJvCmrDrSB2em5pa25vdSwgYXbFoWFrIHBvdXplLCBwb2t1ZCBrIGplamljaCB1bG/FvmVuw60gbmVibwp2em5pa3UgZG/FoWxvIHYgcMWZw61tw6ltIGTFr3NsZWRrdSBacHJhY292w6Fuw60gb3NvYm7DrWNoCsO6ZGFqxa8gTmVtb2NuaWNlIHNwb2xlxI1ub3N0w60gQnJhaW5vbWl4LCBixJtoZW0gbsSbasW+CgogCgogCgpCcmFpbm9taXggRXVyb3BlIExpbWl0ZWQKU3VpdGUgMTAzODAKCjI2LzI3IFVwcGVyIFBlbWJyb2tlIFN0cmVldApEdWJsaW4gMiBEMDIsIFgzNjEgSXJlbGFuZAoKIAoKUGVyc29uYWwgRGF0YSB3aGVyZSBpdCBoYXMgbm90IGNvbXBsaWVkIHdpdGggdGhlIGR1dGllcwphbmQgb2JsaWdhdGlvbnMgc3BlY2lmaWNhbGx5IGltcG9zZWQgb24gUHJvY2Vzc29ycyBieSB0aGUKRGF0YSBQcm90ZWN0aW9uIExlZ2lzbGF0aW9uIG9yIHdoZXJlIEJyYWlub21peCBoYXMKUHJvY2Vzc2VkIGFueSBvZiB0aGUgSG9zcGl0YWwgRGF0YSBvdXRzaWRlIG9yIGNvbnRyYXJ5IHRvCnRoZSBIb3NwaXRhbCdzIElhd2Z1bCBhbmQgcmVhc29uYWJsZSBpbnN0cnVjdGlvbnMuIFRoZQpIb3NwaXRhbCB3aWxsIHVzZSBhfHwgcmVhc29uYWJsZSBlbmRlYXZvdXJzIHRvIG1pdGlnYXRlIGFueQphbmQgYWxsIGZpbmVzLCBwZW5hbHRpZXMsIGNvc3RzLCBleHBlbnNlcywgZGFtYWdlcywgbG9zc2VzCmFuZCB8aWFiaXxpdGllcyBleHBlbnNlcyBhbmQgfGlhYml8aXRpZXMgaW1wb3NlZCBvbiBvcgphd2FyZGVkIGFnYWluc3Qgb3IgaW5jdXJyZWQgYnkgdGhlIEhvc3BpdGFsLiBCcmFpbm9taXgncwpsaWFiaWxpdHkgdW5kZXIgdGhpcyBpbmRlbW5pdHkgaXMgc3ViamVjdCB0byB0aGUgZGlzY2xhaW1lcnMsCmxpbWl0YXRpb25zIG9uIGxpYWJpbGl0eSBhbmQgZXhjbHVzaW9ucyBvZiBsaWFiaWxpdHkgc2V0IG91dCBpbgp0aGUgQWdyZWVtZW50LCBleGNlcHQgd2hlcmUgdGhlIGJyZWFjaCBvZiBvYmxpZ2F0aW9ucwp3YXMgY2F1c2VkIHdpbGZ1bGx5IG9yIGJ5IGdyb3NzIG5lZ2xpZ2VuY2UuCgpzcG9sZcSNbm9zdCBCcmFpbm9taXggcG9ydcWhaWxhIG7Em2t0ZXJvdSBwb3Zpbm5vc3QsIGt0ZXJvdQprb25rcsOpdG7EmyB6cHJhY292YXRlbMWvbSB1a2xhZGFqw60gcHLDoXZuw60gcMWZZWRwaXN5IG8Kb2NocmFuxJsgb3NvYm7DrWNoIMO6ZGFqxa8sIG5lYm8gcG9rdWQgc3BvbGXEjW5vc3QgQnJhaW5vbWl4CnpwcmFjb3bDoXZhbGEgb3NvYm7DrSDDumRhamUgTmVtb2NuaWNlIG5hZCByw6FtZWMKesOha29ubsO9Y2ggYXDFmWltxJvFmWVuw71jaCBwb2t5bsWvIE5lbW9jbmljZSBuZWJvIHYKcm96cG9ydSBzIG5pbWkuIE5lbW9jbmljZSB1xI1pbsOtIHbFoWVjaG55IHDFmWltxJvFmWVuw6kga3Jva3kKbmEgb2JyYW51IHByb3RpIHBva3V0YW0sIHBlbsOhbGUsIG7DoWtsYWTFr20sIHbDvWRhasWvbSwKcG92aW5ub3N0ZW0gayBuw6FocmFkxJsgxaFrb2R5LCB6dHJhdGFtIGEgesOhdmF6a8WvbSwgamXFviBieQpqw60gbW9obHkgdnpuaWtub3V0IG5lYm8gYnkgasOtIG1vaGx5IGLDvXQgdWxvxb5lbnkuCk9kcG92xJtkbm9zdCBzcG9sZcSNbm9zdGkgQnJhaW5vbWl4IHBvZGxlIHRvaG90bwpvZHN0YXZjZSBqZSBvbWV6ZW5hIHByb2hsw6HFoWVuw61taSBvIHZ5bG91xI1lbsOtIGEgb21lemVuw60Kb2Rwb3bEm2Rub3N0aSBvYnNhxb5lbsO9bWkgdmUgU21sb3V2xJssIHMgdsO9amlta291IHDFmcOtcGFkxa8sCmtkeSBrIHBvcnXFoWVuw60gcG92aW5ub3N0w60gZG/FoWxvIMO6bXlzbG7EmyBuZWJvIHogaHJ1YsOpCm5lZGJhbG9zdGkuCgogCgogCgoxMy4KClRoZSBIb3NwaXRhbCB3aXx8IGluZGVtbmlmeSBCcmFpbm9taXggYW5kIEJyYWlub21peCBVSwphZ2FpbnN0IGFueSBhbmQgYWxsIGZpbmVzIGFuZCBwZW5hbHRpZXMgaW5jdXJyZWQgYnkgdGhlbQphbmQgYWdhaW5zdCBhbnkgYW5kIGFsbCBjb3N0cywgZXhwZW5zZXMsIGRhbWFnZXMgYW5kCnxpYWJpfGl0aWVzIGF3YXJkZWQgYWdhaW5zdCBvciBpbmN1cnJlZCBieSB0aGVtIGFzIGEgcmVzdWx0Cm9mIGFueSBQcm9jZXNzaW5nIG9mIGFueSBvZiB0aGUgSG9zcGl0YWwgUGVyc29uYWwgRGF0YSBpbgpicmVhY2ggb2YgdGhlIERhdGEgUHJvdGVjdGlvbiBMZWdpc2xhdGlvbiwgZXhjZXB0IHRvIHRoZQpleHRlbnQgdGhhdCBhbnkgc3VjaCBmaW5lLCBwZW5hbHR5LCBjb3N0cywgZXhwZW5zZXMsCmRhbWFnZXMgb3IgbGlhYmlsaXR5IGlzIHRoZSBkaXJlY3QgcmVzdWx0IG9mIEJyYWlub21peCBvcgpCcmFpbm9taXggVUsgbm90IGhhdmluZyBjb21wbGllZCB3aXRoIHRoZSBkdXRpZXMgYW5kCm9ibGlnYXRpb25zIHNwZWNpZmljYWxseSBpbXBvc2VkIG9uIFByb2Nlc3NvcnMgYnkgdGhlIERhdGEKUHJvdGVjdGlvbiBMZWdpc2xhdGlvbiBvciBCcmFpbm9taXggb3IgQnJhaW5vbWl4IFVLIGhhdmluZwpQcm9jZXNzZWQgYW55IG9mIHRoZSBIb3NwaXRhbCBEYXRhIG91dHNpZGUgb3IgY29udHJhcnkgdG8KdGhlIEhvc3BpdGFsJ3MgSWF3ZnVsIGluc3RydWN0aW9ucy4gQnJhaW5vbWl4IGFuZCBCcmFpbm9taXgKVUsgd2l8fCB1c2UgYXx8IHJlYXNvbmFibGUgZW5kZWF2b3VycyB0byBtaXRpZ2F0ZSBhbnkgYW5kCmFsbCBmaW5lcywgcGVuYWx0aWVzLCBjb3N0cywgZXhwZW5zZXMsIGRhbWFnZXMsIGxvc3NlcyBhbmQKfGlhYml8aXRpZXMgaW1wb3NlZCBvbiBvciBhd2FyZGVkIGFnYWluc3Qgb3IgaW5jdXJyZWQgYnkKdGhlbS4KCiAKCjEzLgoKTmVtb2NuaWNlIG5haHJhZMOtIHNwb2xlxI1ub3N0aSBCcmFpbm9taXggYSBCcmFpbm9taXggVUsKamFrb3Vrb2xpIMO6am11ICh2xI1ldG7EmyBuw6FrbGFkxa8sIHbDvWRhasWvIHwgJ2Frw71jaGtvbGkgcG9rdXQsCmt0ZXLDqSBidWRvdSBzcG9sZcSNbm9zdGkgQnJhaW5vbWl4IMSNaSBCcmFpbm9taXggVUsKdiBzb3V2aXNsb3N0aSBzZSBacHJhY292YW7DrW0gdWxvxb5lbnkgb3Jnw6FueSB2ZcWZZWpuw6kgbW9jaSksCmt0ZXLDoSBqw60gdnpuaWtuZSB2IGTFr3NsZWRrdSBacHJhY292w6Fuw60gb3NvYm7DrWNoIMO6ZGFqxa8KTmVtb2NuaWNlIHYgcm96cG9ydSBzIFByYXZuw61taSBwxZllZHBpc3kgbyBvY2hyYW7Emwpvc29ibsOtY2ggw7pkYWrFrywgfGVkYcW+ZSDDumptYSB2em5pa25lIHBvcnXFoWVuw61tIG7Em2t0ZXLDqQpwb3Zpbm5vc3RpIHplIHN0cmFueSBzcG9sZcSNbm9zdGkgQnJhaW5vbWl4IG5lYm8gQnJhaW5vbWl4ClVLLCBrdGVyb3Uga29ua3LDqXRuxJsgenByYWNvdmF0ZWzFr20gdWtsYWRhasOtIHByw6F2bsOtCnDFmWVkcGlzeSBvIG9jaHJhbsSbIG9zb2Juw61jaCDDumRhasWvLCBuZWJvIHBva3VkCnNwb2xlxI1ub3N0IEJyYWlub21peCBuZWJvIEJyYWlub21peCBVSyB6cHJhY292w6F2YWxhCm9zb2Juw60gw7pkYWplIE5lbW9jbmljZSBuYWQgcsOhbWVjIHrDoWtvbm7DvWNoIHBva3luxa8KTmVtb2NuaWNlIG5lYm8gdiByb3pwb3J1IHMgbmltaS4gQnJhaW5vbWl4IGEgQnJhaW5vbWl4ClVLIHXEjWluw60ga3Jva3ksIGt0ZXLDqSBsemUgcG8gbmljaCByb3p1bW7EmyBwb8W+YWRvdmF0LCBhYnkKdnpuaWt1IMO6am15LCBrdGVyYSBieWppbSBtb2hsYSB2em5pa25vdXQsIHDFmWVkZcWhbMO9LgoKIAoKIAoKIAoKIAoKQXBwZW5kaXggMiAvIFDFmcOtbG9oYSDEjS4gMgpBcHBlbmRpeCAyQS8gUMWZw61sb2hhIMSNLiBaQQoKQnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRDAyLCBYMzYxIElyZWxhbmQKClRlY2huaWNhbCwgb3JnYW5pemF0aW9uYWwsIGFuZCBwZXJzb25uZWwgc2FmZWd1YXJkcyBmb3IgdGhlIHBlcnNvbmFsIGRhdGEgYmVpbmcgcHJvY2Vzc2VkLyBUZWNobmlja8OpLApvcmdhbml6YcSNbsOtIGEgcGVyc29uw6FsbsOtIHphYmV6cGXEjWVuw60genByYWNvdsOhdmFuw71jaCBvc29ibsOtY2ggw7pkYWrFrwoKIAoKYSkgVGVjaG5pY2FsIFNlY3VyaXR5IG9mIFByb2Nlc3NlZCBQZXJzb25hbCBEYXRhIChkZXNjcmlwdGlvbgpvZiBzcGVjaWZpYyB0ZWNobmljYXwgc2VjdXJpdHkgbWVhc3VyZXMpCgphKSBUZWNobmlja8OpIHphYmV6cGXEjWVuw60genByYWNvdsOhdmFuw71jaCBvc29ibsOtY2ggw7pkYWrFrwoocG9waXMga29ua3LDqXRuw61jaCB0ZWNobmlja8O9Y2ggemFiZXpwZcSNb3ZhY8OtY2ggcHJ2a8WvKQoKIAoKQnJhaW5vbWl4IChoZXJlaW5hZnRlciBhbHNvIHJlZmVycmVkIHRvIGFzIHRoZSAiUHJvY2Vzc29yIiBmb3IgdGhlCnB1cnBvc2VzIG9mIHRoaXMgQW5uZXgpLCBhcyB0aGUgUHJvY2Vzc29yLCBzaGFsbCBlbnN1cmU6CgonIHRoYXQgcGVyc29uYWwgZGF0YSBpbiBlfGVjdHJvbmljIGZvcm0gYXJlIHN0b3JlZCBvbgpzZWN1cmVkIHRlY2huaWNhfCBlcXVpcG1lbnQgd2l0aCByZXN0cmljdGVkIGFjY2Vzcwp8aW1pdGVkIG9ufHkgdG8gYXV0aG9yaXplZCBwZXJzb25zLCBhbmQgdGhhdCBlbGVjdHJvbmljCmRhdGEgYXJlIHByb3RlY3RlZCBieSB1bmlxdWUgYWNjZXNzIHBhc3N3b3JkczsKCicgY2VudHJhbGlzZWQgbWFuYWdlbWVudCBvZiB1c2VyIGFjY291bnRzIGFjcm9zcwpzeXN0ZW1zIChvbnJwcmVtaXNlcyBhbmQgY3xvdWQpOwoKJyBzZWN1cml0eSBtb25pdG9yaW5nIChsb2dnaW5nIG9mIHVzZXJzIGFuZCBpbmRpdmlkdWFsCmFjY2VzcyBldmVudHMpOwoKJyBjb250aW51b3VzIG1vbml0b3Jpbmcgb2YgdnV8bmVyYWJpfGl0aWVzIGFuZCB0aGVpcgpyZW1lZGlhdGlvbjsKCicgYXV0b21hdGljIGxvY2tpbmcgKHBhc3N3b3JkIHJlcXVpcmVkIGZvciByZXJsb2dpbiksCmFudGl2aXJ1cyBwcm90ZWN0aW9uLCBhbmQgZmlyZXdhfHwgcHJvdGVjdGlvbjsKCicgZW5jcnlwdGlvbiBvZmRhdGEgaW4gdHJhbnNpdCAoVExTL0hUVFBTKTsKCicgZW5jcnlwdGlvbiBvZiBkYXRhIGF0IHJlc3Q7CgonIHRyYW5zZmVyIG9mIGRhdGEKcHNldWRvbnltaXNlZCBmb3JtOwoKdG8gdGhlIGN8b3VkIGV4Y2x1c2l2ZWx5IGluCgpCcmFub21peCAocHJvIMO6xI1lbHkgdMOpdG8gcMWZw61sb2h5IGTDoWxlIHTDqcW+IGplbiDigJ56cHJhY292YXRlbCIpLApqYWtvxb50byB6cHJhY292YXRlbCxqZSBwb3ZpbmVuIHphamlzdGl0OgoKLiBhYnkgb3NvYm7DrSDDumRhamUgdiBlbGVrdHJvbmlja8OpIHBvZG9ixJsgYnlseSB1bG/FvmVueSBuYQp6YWJlenBlxI1lbsOpbSB0ZWNobmlja8OpbSB2eWJhdmVuw60gc29tZXplbsO9bQpwxZnDrXN0dXBlbSBwb3V6ZSBvcHLDoXZuxJtuw71jaCBvc29iIGEgYWJ5IGJ5bGEKZWxla3Ryb25pY2thIGRhdGEgY2hyw6FuxJtuYSBqZWRpbmXEjW7DvW0gcMWZw61zdHVwb3bDvW0KCmhlc2xlbQoKLiBqZWRub3Rub3Ugc3Byw6F2dSB1xb5pdmF0ZWxza8O9Y2ggw7rEjXTFryBuYXDFmcOtxI0gc3lzdMOpbXkgKG9uZQpwcmVtaXNlcyBhIGN8b3VkKTsKCi4gYmV6cGXEjW5vc3Ruw60gbW9uaXRvcmluZyAobG9nb3bDoW7DrSB1xb5pdmF0ZWzFryBhCmplZG5vdGxpdsO9Y2ggcMWZw61zdHVwxa8pOwoKLiBwcsWvYsSbxb5uw6kgc2xlZG92w6Fuw60genJhbml0ZWxub3N0w60gYSBqZWppY2ggb2RzdHJhxYhvdsOhbsOtOwoKLiBhdXRvbWF0aWNrw6kgemFteWthbsOtICh2ecW+YWRvdmFuw60gaGVzbGEgcHJvIG9wxJt0b3Zuw6kKCnDFmWlobMOhxaFlbsOtKSwgYW50aXZpcm92YSBvY2hyYW5hLCBGaXJld2FsbDsKLiDFoWlmcm92YW7DrSBkYXQgcMWZaSBwxZllbm9zdSAoVExTL0hUSSdQUyk7CgouIMWhaWZyb3ZhbsOtIGRhdCB2IMO6bG/FvmnFoXRpOwouIHDFmWVub3MgZGF0IGRvIGN8b3VkdSB2w71ocmFkbsSbIHYgcHNldWRvbnltaXpvdmFuw6kKcG9kb2LEmwoKIAoKVGhlIFByb2Nlc3NvciBmdXJ0aGVyIHVuZGVuYWtlcyB0bzoKCicgYmluZCBhdXRob3JpemVkIHBlcnNvbnMgdG8gY29uZmlkZW50aWFsaXR5IG9ibGlnYXRpb25zCnJlZ2FyZGluZyBwZXJzb25hbCBkYXRhIGFuZCBpbXBsZW1lbnRlZCBzZWN1cml0eQptZWFzdXJlcywgdGhlIGRpc2Nsb3N1cmUgb2Ygd2hpY2ggY291fGQgamVvcGFyZGl6ZSB0aGUKc2VjdXJpdHkgb2YgdGhlIHByb2Nlc3NlZCBwZXJzb25hbCBkYXRhOwoKJyBpbXBsZW1lbnQgbWVhc3VyZXMgZW5zdXJpbmcgb25nb2luZyBjb25maWRlbnRpYWxpdHksCmludGVncml0eSwgYXZhaWxhYmlsaXR5LCBhbmQgcmVzaWxpZW5jZSBvZiBwcm9jZXNzaW5nCnN5c3RlbXMgYW5kIHNlcnZpY2VzOwoKJyByZWd1bGFybHkgdGVzdCwgYXNzZXNzLCBhbmQgZXZhfHVhdGUgdGhlIGVmZmVjdGl2ZW5lc3Mgb2YKaW1wbGVtZW50ZWQgdGVjaG5pY2F8IGFuZCBvcmdhbml6YXRpb25hbCBtZWFzdXJlcyB0bwplbnN1cmUgcHJvY2Vzc2luZyBzZWN1cml0eTsKCicgcmVndWxhcmx5IG1haW50YWluIGVxdWlwbWVudCBvbiB3aGljaCBwZXJzb25hbCBkYXRhCmFyZSBzdG9yZWQ7CgonIGluIHRoZSBldmVudCBvZiBwaHlzaWNhbCBvciB0ZWNobmljYXwgaW5jaWRlbnRzIGFmZmVjdGluZwp0aGUgUHJvY2Vzc29yLCB0YWtlIGF8fCBuZWNlc3NhcnkgbWVhc3VyZXMgdG8gcmVzdG9yZQp0aGUgYXZhaWxhYmlsaXR5IG9mIGFuZCBhY2Nlc3MgdG8gcGVyc29uYWwgZGF0YSBhcyBzb29uCmFzIHBvc3NpYmxlIGZvciBib3RoIHRoZSBDb250cm9sbGVyIGFuZCB0aGUgUHJvY2Vzc29yLgoKRMOhbGUgc2UgenByYWNvdmF0ZWwgemF2YXp1amU6CgouIHphd8WhemF0IG9wcsOhdm7Em27DqSBvc29ieSBwb3Zpbm5vc3TDrSBtbMSNZW5saXZvc3RpIG8Kb3NvYm7DrWNoIMO6ZGFqJ2ggYSBvIHDigJwiYXTDvWNoIGJlenBlxI1ub3N0bsOtY2gKb3BhdMWZZW7DrWNoLCBqZWppY2jFviB6dmXFmWVqbsSbbsOtIGJ5IG1vaGxvIG9ocm96aXQKYmV6cGXEjW5vc3QgenByYWNvdmF3bsO9Y2ggb3NvYm7DrWNoIMO6ZGFqxa87CgouIHDFmWlqbW91dCB0YWtvdsOhIG9wYXTFmWVuw60sIGFieSBieWxvIG1vxb5uw6kgemFqaXN0aXQKCm5ldXN0YWxvdSBkxa92xJtybm9zdCwgaW50ZWdyaXR1LCBkb3N0dXBub3N0IGEgb2RvbG5vc3QKc3lzdMOpbcWvIGEgc2x1xb5lYiB6cHJhY292YW7DrTsKCi4gcHJvdsOhZMSbdCBwcmF2aWRlbG7DqSB0ZXN0b3ZhbsOtLCBwb3N1em92w6Fuw60gYSBob2Rub2NlbsOtCsSNaW5ub3N0w60gemF2ZWRlbsO9Y2ggdGVjaG5pY2vDvWNoIGEgb3JnYW5pemHEjW7DrWNoCm9wYXTFmWVuw60gcHJvIHphamnFoXTEm27DrSBiZXpwZcSNbm9zdGkgenByYWNvdmFuw607CgouIHByYXZpZGVsbsSbIHByb3bDoWTEm3Qgw7pkcsW+YnUgemHFmcOtemVuw60sIG5hIGt0ZXLDvWNoIGpzb3UKb3NvYm7DrSDDumRhamUgdWxvxb5lbnk7CgouIHZwxZnDrXBhZMSbIGZ5emlja8O9Y2ggxI1pIHRlY2huaWNrw71jaCBpbmNpZGVudMWvIHUKenByYWNvdmF0ZWxlIHDFmWlqbW91dCB2ZcWha2VyYSBwb3TFmWVibsOhIG9wYXTFmWVuw60sIGFieQpieWxvIG1vxb5uw6kgY28gbmVqZMWZw612ZSBvYm5vdml0IGRvc3R1cG5vc3Qgb3NvYm7DrWNoCsO6ZGFqxa8gYSBwxZnDrXN0dXAga25pbSBqYWsgemUgc3RyYW55IHNwcmF2Y2UsIHRhawp6cHJhY292YXRlbGUuCgogCgpiKSBPcmdhbml6YXRpb25hbCBTZWN1cml0eSBvZiBQcm9jZXNzZWQgUGVyc29uYWwgRGF0YQoKKGRlc2NyaXB0aW9uIG9mIHNwZWNpZmljIG9yZ2FuaXphdGlvbmFsIG1lYXN1cmVzKQoKYikgT3JnYW5pemHEjW7DrSB6YWJlenBlxI1lbsOtIHpwcmFjb3bDoXZhbsO9Y2ggb3NvYm7DrWNoIMO6ZGFqxa8KKHBvcGlzIGtvbmtyw6l0bsOtY2ggb3JnYW5pemHEjW7DrWNoIHphYmV6cGXEjW92YWPDrWNoIHBydmvFrykKCiAKCiAKClRoZSBQcm9jZXNzb3IgdW5kZW5ha2VzIHRvOgoKJyBub3QgfGVhdmUgaW5zdGFsbGF0aW9uLCBiYWNrdXAsIG9yIGFyY2hpdmF8IG1lZGlhIG9yCmRvY3VtZW50YXRpb24gcmVsYXRlZCB0byB0aGUgc3ViamVjdCBtYXR0ZXIgb2YgdGhlCkFncmVlbWVudCBmcmVlfHkgYWNjZXNzaWJsZSBhdCB0aGUgd29ya3BsYWNlOwoKJyBjb21wbHkgd2l0aCBvcGVyYXRpb25hbCBhbmQgc2VjdXJpdHkgcnVsZXMgKGludGVybmFsCnJlZ3VsYXRpb25zKSBvZiBidWlsZGluZ3MgYW5kIHByZW1pc2VzLCBlc3BlY2lhbGx5CndoZXJlIHBlcnNvbmFsIGRhdGEgYXJlIHN0b3JlZDsKCicgZW5zdXJlIHRoYXQgcGVyc29uYWwgZGF0YSBhcmUgcHJvY2Vzc2VkIG9ubHkgYnkKYXV0aG9yaXplZCBwZXJzb25zIHdobyBoYXZlIGJlZW4gZ3JhbnRlZCBhY2Nlc3MgdG8Kc3VjaCBkYXRhOwoKIAoKWnByYWNvdmF0ZWwgc2UgemF2YXp1amU6CgouIG5hIHByYWNvdmnFoXRpIG5lcG9uZWNoYXQgdm9sbsSbIGRvc3R1cG7DoSBpbnN0YWxhxI1uw60sCnphbG/Fvm7DrSBuZWJvIGFyY2hpdm7DrSBtw6lkaWEgYW5pIGRva3VtZW50YWNpIGt0ZXJhIGplCnDFmWVkbcSbdGVtIHBsbsSbbsOtIGR8ZSBzbWxvdXZ5LAoKLiBkb2Ryxb5vdmF0IHJlxb5pbW92YSBvcGF0xZllbsOtIChwcm92b3puw60gxZlhZHkpIGJ1ZG92IGEKcHJvc3RvciB6ZWptw6luYSwga2RlIGpzb3UgdWxvxb5lbnkgb3NvYm7DrSDDumRhamUsCgouIHpwcmFjb3ZhbsOtIG9zb2Juw60gw7pkYWplIGJ1ZGUgcHJvdsOhZMSbbm8gcG91emUKb3Byw6F2bsSbbsO9bWkgb3NvYmFtaSwga3RlcsO9bSBidWRlIHVkxJtsZW4gcMWZw61zdHVwCmsgb3NvYm7DrW0gw7pkYWrFr20sCgouIHphamlzdGl0LCBhYnkgb3NvYnkgcMWZaXN0dXB1asOtY8OtIGsgb3NvYm7DrW0gw7pkYWrFr20gc3ByYXZjZQoKIAoKIAoKQnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRDAyLCBYMzYxIElyZWxhbmQKCiAKCicgZW5zdXJlIHRoYXQgcGVyc29ucyBhY2Nlc3NpbmcgdGhlIENvbnRyb2xsZXIncwpwZXJzb25hbCBkYXRhIHZpYSBpbnRlcm5hbCBuZXR3b3JrIG9yIHJlbW90ZSBhY2Nlc3MKYXJlIHByb3RlY3RlZCBieSBhdXRoZW50aWNhdGlvbiBtZWNoYW5pc21zOwoKJyBwcm92aWRlIHRoZSBDb250cm9sbGVyIHdpdGggYWxsIGluZm9ybWF0aW9uIHJlbGF0aW5nIHRvCnRoZSBzdWJqZWN0IG1hdHRlciBvZiB0aGUgQWdyZWVtZW50IGFuZCBhbGxvdyBhdWRpdHMKY2FycmllZCBvdXQgYnkgdGhlIENvbnRyb2xsZXIgb3IgYW4gYXV0aG9yaXplZCBhdWRpdG9yOwp0aGUgQ29udHJvbGxlciBzaGFsbCBub3RpZnkgdGhlIFByb2Nlc3NvciBpbiB3cml0aW5nIGF0CmxlYXN0IDcgZGF5cyBwcmlvciB0byBhbnkgcGxhbm5lZCBpbnNwZWN0aW9uIG9yIGF1ZGl0OyBpbgpjYXNlIG9mIHVuc2F0aXNmYWN0b3J5IHJlc3VsdHMsIHRoZSBQcm9jZXNzb3Igc2hhbGwgdGFrZQpuZWNlc3NhcnkgY29ycmVjdGl2ZSBtZWFzdXJlczsKCicgcHJvdmlkZSBmdXx8IGNvb3BlcmF0aW9uIHRvIHRoZSBDb250cm9sbGVyIGluIHJpc2sKYW5hbHlzaXMgcmVsYXRlZCB0byB0aGUgc3ViamVjdCBtYXR0ZXIgb2YgdGhlCkFncmVlbWVudCwgaW1wbGVtZW50YXRpb24gb2YgbWVhc3VyZXMgdG8gbWl0aWdhdGUKYWR2ZXJzZSBpbXBhY3RzIHJlbGF0ZWQgdG8gY2hhbmdlcywgdXBkYXRlcyB0bwpzZWN1cml0eSBkb2N1bWVudGF0aW9uLCByZWxhdGVkIHRlc3RpbmcsIGFuZCBlbnN1cmluZwp0aGUgcG9zc2liaWxpdHkgb2YgcmVzdG9yaW5ndGhlIG9yaWdpbmFsIHN0YXRlOwoKJyBwcm92aWRlIG5lY2Vzc2FyeSBjb29wZXJhdGlvbiBhbmQgbWFrZSBhdmFpbGFibGUgYXx8CmRvY3VtZW50YXRpb24gcmVsYXRpbmcgdG8gdGVjaG5pY2FsLCBvcmdhbml6YXRpb25hbCwKYW5kIHBlcnNvbm5lbCBtZWFzdXJlczsKCicgYWRvcHQgcmVsZXZhbnQgaW50ZXJuYWwgcG9saWNpZXMgYW5kIGVuc3VyZQphcHByb3ByaWF0ZSB0cmFpbmluZyBvZiBwZXJzb25zIGF1dGhvcml6ZWQgdG8gcHJvY2VzcwpwZXJzb25hbCBkYXRhIHVuZGVyIHRoaXMgQWdyZWVtZW50LgoKcHJvc3TFmWVkbmljdHbDrW0gaW50ZXJuw60gc8OtdMSbL3Z6ZGFsZW7DqWhvIHDFmWlwb2plbsOtIGRvIHPDrXTEmwpzcHJhdmNlLCBjaHJhbmlseSBhdXRlbnRpemHEjW7DrW1pIHByb3N0xZllZGt5LAoKLiBwb3NreXRub3V0IHNwcmF2Y2kgdmXFoWtlcsOpIGluZm9ybWFjZSB2enRhaHVqw61jw60gc2UKayBwxZllZG3Em3R1IHNtbG91dnkgYSB1bW/Fvm5pdCBzcHJhdmNpIHByb3ZlZGVuw60gYXVkaXTFrwpwcm92w6FkxJtuw71jaCBzcHJhdmNlbSDEjWkgcG92xJvFmWVuw71tIGF1ZGl0b3JlbTsgbwpwcm92ZWRlbsOtIGtvbnRyb2x5IMSNaSBhdWRpdHUsIG3DoSBwb3Zpbm5vc3Qgc3ByYXZjZQp6cHJhY292YXRlbGUgbmVqbcOpbsSbIDcgZG7FryBwxZllZCBwbMOhbm92YW5vdSBrb250cm9sb3UKxI1pIGF1ZGl0ZW0gcMOtc2VtbsSbIHZ5cm96dW3Em3Q7IHYgcMWZw61wYWTEmwpuZXVzcG9rb2ppdsO9Y2ggdsO9c2xlZGvFrywgbXVzw60genByYWNvdmF0ZWwgcG9kbmlrbm91dApuZXpieXRuw6Egb3BhdMWZZW7DrSwga3RlcsOhIHBvdmVkb3UgayBuw6FwcmF2xJssCgouIHBvc2t5dG5vdXQgc3ByYXZjaSB2ZcWha2Vyb3Ugc291xI1pbm5vc3QgcMWZaSBhbmFsw716ZQpzb3V2aXNlasOtY8OtY2ggcml6aWsgdnp0YWh1asOtY8OtIHNlIGtwxZllZG3Em3R1IHNtbG91dnksCnDFmWlqw61tYW7DrSBvcGF0xZllbsOtIHphIMO6xI1lbGVtIHNuw63FvmVuw60gdsWhZWNoIG5lcMWZw616bml2w71jaApkb3BhZMWvIHNwb2plbsO9Y2ggc2Ugem3Em25hbWksIGFrdHVhbGl6YWNlbWkKYmV6cGXEjW5vc3Ruw60gZG9rdW1lbnRhY2UsIHNvdXZpc2Vqw61jw61tIHRlc3RvdsOhbsOtbSBhCnphamnFoXTEm27DrSBtb8W+bm9zdGkgbmF2cmFjZW7DrSBkbyBwxa92b2Ruw61obyBzdGF2dSwKCi4gcG9za3l0bm91dCBzcHJhdmNpIG5lemJ5dG5vdSBzb3XEjWlubm9zdCBhIHpwxZnDrXN0dXBuaXQKdmXFoWtlcm91IGRva3VtZW50YWNpIHRlY2huaWNrw71jaCwgb3JnYW5pemHEjW7DrWNoCmEgcGVyc29uw6FsbsOtY2ggb3BhdMWZZW7DrSwKCi4gcMWZaWptb3V0IHDFmcOtc2x1xaFuw6kgc23Em3JuaWNlIGEgemFqaXN0aXQgYWJzb2x2b3bDoW7DrQpwxZnDrXNsdcWhbsO9Y2ggxaFrb2xlbsOtIG9zb2JhbWkgcG92xJvFmWVuw71taSB6cHJhY292w6Fuw61tCm9zb2Juw61jaCDDumRhasWvIGRsZSB0w6l0byBzbWxvdXZ5LgoKIAoKVGhlIFByb2Nlc3NvciBzaGFsbCBhbHNvIG1vbml0b3IgYW5kIGJlIHJlc3BvbnNpYmxlLCBpbnRlciBhfGlhLApmb3IgZW5zdXJpbmcgdGhhdDoKCicgYXx8IG5lY2Vzc2FyeSBtZWFzdXJlcyBhcmUgdGFrZW4gdG8gcHJldmVudCwgdG8gdGhlCmdyZWF0ZXN0IGV4dGVudCBwb3NzaWJsZSwgdW5hdXRob3JpemVkIGFjY2VzcyB0bywKcmVhZGluZywgY3JlYXRpb24sIGNvcHlpbmcsIHRyYW5zbWlzc2lvbiwgbW9kaWZpY2F0aW9uLApvciBkZXxldGlvbiBvZiByZWNvcmRzIGNvbnRhaW5pbmcgcGVyc29uYWwgZGF0YSw7CgonIGFkZGl0aW9uYWwgbWVhc3VyZXMgYXJlIGltcGxlbWVudGVkIHRvIGlkZW50aWZ5IGFuZAp2ZXJpZnkgd2hvIGFjY2Vzc2VkIHBlcnNvbmFsIGRhdGEsIHdoZW4sIGZvciB3aGF0CnB1cnBvc2UsIGFuZCBieSB3aG9tIHRoZSBkYXRhIHdlcmUgbW9kaWZpZWQgb3IKZGV8ZXRlZC4KCiAKClpwcmFjb3ZhdGVsIGtvbnRyb2x1amUgYSBvZHBvdsOtZMOhIG1qIHphIHRvLCDFvmU6CgouIGJ1ZG91IHDFmWlqYXRhIHZlxaFrZXLDoSBvcGF0cmVuw60sIGFieSBieWxvIHZjbyBuZWp2ecWhxaHDrQptb8W+bsOpIG3DrcWZZSB6YWJyw6FuxJtubyBuZW9wcsOhdm7Em27DqW11IHpwxZnDrXN0dXBuxJtuw60sCsSNdGVuw60sIHZ5dHbDocWZZW7DrSwga29ww61yb3bDoW7DrSwgcMWZZW5vc3UsIMO6cHJhdsSbIMSNaSB2eW1hesOhbsOtCnphem5hbXUgb2JzYWh1asOtY8OtIG9zb2Juw60gw7pkYWplLAoKLiBidWRvdSBwxZlpamF0YSBkYWzFocOtIG9wYXTFmWVuw60sIGt0ZXLDoSB1bW/Fvm7DrSB1csSNaXQgYSBvdsSbxZlpdCwKa2RvIGEga2R5IHNvc29ibsOtbWkgbmFrbGFkYWwsIHphIGpha8O9bSDDusSNZWxlbSBhIGvDvW0KYnlseSBwb3ptxJtuxJtueSBuZWJvIHNtYXrDoW55LgoKIAoKYykgUGVyc29ubmVsIFNlY3VyaXR5IGluIHRoZSBQcm9jZXNzaW5nIG9mIFBlcnNvbmFsIERhdGEKKGRlc2NyaXB0aW9uIG9mIHNwZWNpZmljIHBlcnNvbm5lbCBtZWFzdXJlcykKCmMpIFBlcnNvbsOhbG7DrSB6YWJlenBlxI1lbsOtIHDFmWkgenByYWNvdsOhdsOhbsOtIG9zb2Juw61jaCDDumRhasWvCihwb3BpcyBrb25rcsOpdG7DrWNoIHBlcnNvbsOhbG7DrWNoIHphYmV6cGXEjW92YWPDrWNoIHBydmvFrykKCiAKCiAKCicgVGhlIFByb2Nlc3NvciBzaGFsbCBlbnN1cmUgdGhhdCBlbXBsb3llZXMgYXJlCmluc3RydWN0ZWQgcmVnYXJkaW5nIHRoZWlyIG9ibGlnYXRpb25zIGluIHJlbGF0aW9uIHRvCnBlcnNvbmFsIGRhdGEgYW5kIHRoZSBzdWJqZWN0IG1hdHRlciBvZiB0aGUKQWdyZWVtZW50LCBpbmNsdWRpbmcgbW9uaXRvcmluZyBjb21wbGlhbmNlIHdpdGgKdGhlc2Ugb2JsaWdhdGlvbnMgYW5kIG1haW50YWluaW5nIGNvbmZpZGVudGlhbGl0eS4KCicgVGhlIFByb2Nlc3NvciBzaGFsbCBlbnN1cmUgdGhhdCBhfHwgYWNjZXNzIHJpZ2h0cwoocmVtb3RlIG9ufGluZSAvIHZpYSBWUE4pIG5lY2Vzc2FyeSBmb3IgdGhlCnBlcmZvcm1hbmNlIG9mIHRoZSBBZ3JlZW1lbnQgYXJlIHJlY29yZGVkIGFuZCB0aGF0CnRoZSBzY29wZSBvZiBwZXJtaXR0ZWQgcHJvY2Vzc2luZyBvcGVyYXRpb25zIGlzCmRlZmluZWQuCgogCgouIFpwcmFjb3ZhdGVsIGplIHBvdmluZW4gcmVhbGl6b3ZhdCBwb3XEjWVuw60gemFtxJtzdG5hbmPFrwpvIGplamljaCBwb3Zpbm5vc3RlY2ggdmUgdnp0YWh1IGtvc29ibsOtbSDDumRhasWvbSBhCnDFmWVkbcSbdHUgU21sb3V2eSwgdsSNZXRuxJsgemFqacWhxaVvdsOhbsOtIGtvbnRyb2x5CmRvZHLFvm92YW7DrXTEm2NodG8gcG92aW5ub3N0w60gYSB6YWNob3bDoW7DrSBtbMSNZW5saXZvc3RpLgoKLiBacHJhY292YXRlbCB6YWppc3TDrSwgYWJ5IHZlxaFrZXLDoSBwxZnDrXN0dXBvdsOhIG9wcsOhdm7Em27DrQoodnpkw6FsZW5hIG9ubGluZS9wxZllcyBWUE4pIG5lemJ5dG7DoSBrIHBsbsSbbsOtIHDFmWVkbcSbdHUKU21sb3V2eSBieWxhIGV2aWRvdmFuYSBhIGRlZmlub3ZhbiByb3pzYWggamVqaWNoCnBvdm9sZW7DvWNoIHpwcmFjb3ZhdGVsc2vDvWNoIG9wZXJhY8OtLgoKIAoKIAoKQnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRDAyLCBYMzYxIElyZWxhbmQKCkFwcGVuZGl4IDIgLyBQxZnDrWxvaGEgxI0uIDIKQXBwZW5kaXggWkIgLyBQxZnDrWxvaGEgxI0uIFpCCkxpc3Qgb2YgU3VicHJvY2Vzc29ycy8gU2V6bmFtIETDrWzEjcOtY2ggenByYWNvdmF0ZWzFrwoKTm8uL8WZLsOtc3xvIElkZW50aWZpY2F0aW9uIERldGFpbHMvIElkZW50aWZpa2HEjW7DrSDDumRhamUgRGVzY3JpcHRpb24vUG9waXMKCk5hbWUvTmF6ZXY6IEJyYXJub21yeCBMfG18dGVkIFpwcmFjb3bDoW7DrSBuZXpieXRuw6kgcHJvIHphamnFoXRlbsOtIHBvc2t5dG92YW7DrSBTbHXFvmViIGEgU29mdHdhcmUgLApDb21wYW55IE5vLi9JQ086IDA3NDI2NDA2IC4gLiAsIC4gLiAuIOKAnuKAniDigJ4gLgoKMS4g4oCeICwgZHxlIFNtbG91dnl6ZWptZW5hIHZ5aG9kbm9jb3ZhbnwgZGF0IHplIHNuaW1rdSBhIHphamlzdGVuaQpSZWdpc3RlcmVkIG9mZmljZS9TcmRsbzogMTV0IEZsb29yLCBTZWFjb3VydCBUb3dlciwgdGUgaG4nIGvDqSBvZCBvCldlc3QgV2F5LCBPeGZvcmQgMHgyIDAwLCBTcG9qZW7DqSBrcsOhbG92c3R2w60uIEMgJ0MgcCBwIOKAnCIKTmFtZS9OYXpldjogQW1hem9uIFdlYiBTZXJ2aWNlcyBFTUVBIFNBUkwKCjIgQ29tcGFueSBOby4vScSMTzogQiAxODYyODQgUG9za3l0b3bDoW7DrSBpbmZyYXN0cnVrdHVyeSBjbG91ZG92w71jaCBzbHXFvmViIHZ5dcW+w612YW7DvWNoIHDFmWkKClJlZ2lzdGVyZWQgb2ZmaWNlL1PDrWRsbzogMzggQXZlbnVlIEpvaG4gRi4gcG9za3l0b3ZhbsOtIFNsdcW+ZWIgYSBTb2Z0d2FyZSBkfGUgU21sb3V2eS4KS2VubmVkeSwgTHV4ZW1ib3VyZyAxODU1LCBMdXhlbWJvdXJnCgpCcmFpbm9taXggRXVyb3BlIExpbWl0ZWQKU3VpdGUgMTAzODAKCjI2LzI3IFVwcGVyIFBlbWJyb2tlIFN0cmVldApEdWJsaW4gMiBEMDIsIFgzNjEgSXJlbGFuZAoKQXBwZW5kaXggMyAvIFDFmcOtbG9oYSDEjS4gMwpTZW1pY2UgTGV2ZWwgQWdyZWVtZW50IC8gRG9ob2RhIDAgw7pyb3Zuw60gc2x1xb5lYgoKw5rEjWVsIGEgcMWZZWRtxJt0IGRvaG9keQoKVGF0byBkb2hvZGEgMCDDunJvdm7DrSBwb3NreXRvdmFuw71jaCBzbHXFvmViIChkw6FsZWplbiDigJxkb2hvZGEiKSBwb3Bpc3VqZSDDunJvdm7EmyBkb3N0dXBub3N0aSBzbHXFvmViLCBrdGVyw6kgc3BvbGXEjW5vc3QKQnJhaW5vbWl4IHBvc2t5dG5lIE5lbW9jbmljaSBrIHBvZHBvxZllIFNsdcW+YnkuIFRhdG8gZG9ob2RhIGJ5bGEgdnlwcmFjb3bDoW5hLCBhYnkgdXByYXZpbGEgcHJhY292bsOtIHByYXhpIGEgcHJhdmlkbGEsCmt0ZXLDqSBzZSBidWRvdSBhcGxpa292YXQgcMWZaSBobMOhxaFlbsOtLCBkaWFnbm9zdGljZSwgemppxaHFpW92w6Fuw60gYSBldmVudHXDoWxuw60gbsOhcHJhdsSbIG5lZG9zdGF0a8WvIFNsdcW+YnkuCgpUYXRvIGRvaG9kYSB6xa9zdGFuZSBwbGF0bsOhIGEgw7rEjWlubsOpIGLEm2hlbSBkb2J5IHRydsOhbsOtIFDFmcOtc3R1cHUga2UgU2x1xb5ixJssIHRha2pha2plIHNwZWNpZmxrb3bDoW5vIHZlIFNtbG91dsSbLiBTcG9sZcSNbm9zdApCcmFpbm9taXhqZSBvcHLDoXZuxJtuw6Ega2R5a29saSBuYXZyaG5vdXQgem3Em251IHTDqXRvIGRvaG9keSwgZG9qZGUtSWkga2Ugem3Em27EmyBTbHXFvmJ5LCBrdGVyw6Egc2kgdnnFvsOhZMOhIHptxJtudSBzdGFub3ZlbsOpCsO6cm92bsSbIHNsdcW+ZWIgKGtlIHptxJtuxJsgdsWhYWsgbcWvxb5lIGRvasOtdCBwb3V6ZSB2IHNvdWxhZHUgc2UgU21sb3V2b3UsIHRqLiBwcm9zdMWZZWRuaWN0dsOtbSBzbWx1dm7DrW1pIHN0cmFuYW1pCnBvZGVwc2Fuw6lobyBkb2RhdGt1IGtlIFNtbG91dsSbKS4KClBvam15IGRlZmlub3ZhbsOpIHZ0w6l0byBkb2hvZMSbIChwYWtsacW+ZSBuZW7DrXbDvXNsb3ZuxJsgdXZlZGVub2ppbmFrKSBtYWrDrXRlbnTDvcW+IHbDvXpuYW0sIGt0ZXLDvWppbSBieWwgcMWZacWZYXplbiB2ZQpTbWxvdXbEmyBhIHRhdG8gZG9ob2RhIGplIHBvZMWZw616ZW5hIHTEm210byBwb2Rtw61ua8OhbS4KCjEuIFNsdcW+YnkgcG9kcG9yeQoxMSBUYXRvIGRvaG9kYSBzZSB2enRhaHVqZSBuYSBuw6FzbGVkdWrDrWPDrSBzbHXFvmJ5OgooYSkgdGVsZWZvbmlja8OhIHBvZHBvcmE7CihiKSBwb2Rwb3JhIHByb3N0xZllZG5pY3R2w61tIHNsZWRvdmFuw71jaCBlLW1haWzFrzsKKGMpIHZ6ZMOhbGVuw6EgcG9kcG9yYSBwcm9zdMWZZWRuaWN0dsOtbSB6YWJlenBlxI1lbsOpaG8ga29tdW5pa2HEjW7DrWhvIHByb3Rva29sdSAoc2VjdXJlIHNoZWxsOyBzc2gpLCBBV1MKClNTTSBhIHZpcnR1w6FsbsOtIHByaXbDoXRuw61zw610xJsgKFZQTiksIHYgesOhdmlzbG9zdGkgbmEga29ua3LDqXRuw61tIHVzcG/FmcOhZMOhbsOtIGEgZG9zdHVwbm9zdGk7IGEKKGQpIHByYXZpZGVsbsOpIGtvbnRyb2x5IHN0YXZ1IHN5c3TDqW11IGEgb3puw6FtZW7DrW8gdsWhZWNoIHBsw6Fub3ZhbsO9Y2ggZG9iw6FjaCDDumRyxb5ieS4KCjIuIFBvdmlubm9zdGkgTmVtb2NuaWNlCgpQb3Zpbm5vc3RpIE5lbW9jbmljZSxqZWppY2jFviBzcGxuxJtuw61qZSBudXRuw6kga3RvbXUsIGFieSBzcG9sZcSNbm9zdCBCcmFpbm9taXggbW9obGEgcG9za3l0bm91dApwb2Rwb3J1IGRsZSB0w6l0byBkb2hvZHksIHphaHJudWrDrToKMi4xLiBQb3NreXRudXTDrSBwb8W+YWRvdmFuw6lobyBwb2Rwxa9ybsOpaG8gSVQgdnliYXZlbsOtOgoKKGEpIHDFmWlwb2plbsOta2ludGVybmV0dTsKCihiKSBwxZlpcG9qZW7DrWttw61zdG7DrXPDrXRpCgooYykgZWxla3RyaWNrw6kgbmFww6FqZW7DrWEgY2hsYXplbsOtIHBybyBmeXppY2vDqSB2eWJhdmVuw607CgooZCkga29tcGF0aWJpbG7DrSBoeXBlcnZpc29yIHBybyB2aXJ0dcOhbG7DrSBwcm9zdMWZZWTDrTsKCig5KSBzeXN0w6ltLCBrdGVyw70gc3BsxYh1amUgYW5lYm8gcMWZZXZ5xaF1amUgcG/FvmFkYXZreSBuYSBmdW5rxI1ub3N0IHN5c3TDqW11OyBhCihmKSBwxZlpcG9qaXRlbG5vc3QgRElDT00gbW9kYWxpdCBhIGFyY2hpdsWvLgoKMi4yIFByZXZlbmNlIHp0csOhdHkgZGF0LCBwbMOhbiBvYm5vdnkgc3lzdMOpbXUgKGRpc2FzdGVyIHJlY292ZXJ5KSBhIHBsw6FuIHphY2hvdsOhbsOtIHByb3ZvenUgKGJ1c2luZXNzIHJlY292ZXJ5KS4KU29mdHdhcmVqZSBwcm92b3pvdsOhbiBuYSB2aXJ0dcOhbG7DrW0gc2VydmVydSAoVk0pIHYgaW5mcmFzdHJ1a3R1xZllIG5lbW9jbmljZS4gWsOhbG9ob3bDoW7DrSwgb2Jub3ZhCnN5c3TDqW11IGEgemFqacWhdMSbbsOtIGtvbnRpbnVpdHkgcHJvdm96dSBzZSDFmcOtZMOtaW50ZXJuw61taSBwb2xpdGlrYW1pIG5lbW9jbmljZS4gQnJhaW5vbWl4IHphamnFoXQndWplCm9ibm92aXRlbG5vc3QgYSB0ZWNobmlja291IHBvZHBvcnUgc29mdHdhcnUsIE5lbW9jbmljZSBvZHBvdsOtZMOhIHphIHNwcsOhdnUgYSBvYm5vdnUgaG9zdGl0ZWxza8OpaG8KcHJvc3TFmWVkw60uCgozLiBQb3Zpbm5vc3RpIHBvc2t5dG92YXRlbGUgU2x1xb5ieQozMS4gUG92aW5ub3N0aSBwb3NreXRvdmF0ZWxlIFNsdcW+YnkgcMWZaSBwb2Rwb8WZZSBTbHXFvmJ5IHphaHJudWrDrToKKGEpIFZob2Ruw71tIHpwxa9zb2JlbSB1cG96b3LFiG92YXQgTmVtb2NuaWNpIG5hIHZlxaFrZXLDqSBwbMOhbm92YW7DqSDEjWFzeSDDumRyxb5ieSBzeXN0w6ltdTsKKGIpIFJlYWdvdmF0IG5hIMW+w6Fkb3N0aSBvIHBvZHBvcnUgdiBuw63FvmUgdXZlZGVuw71jaCDEjWFzb3bDvWNoIMO6c2Vjw61jaC4gUHJvZGxlbsOtIHpwxa9zb2JlbsOhIG5lZG9zdHVwbm9zdMOtCgp6w6FzdHVwY8WvIGtsaWVudGEgYS9uZWJvamVqaWNoIG5lc2Nob3Bub3N0IHphc2xhdCByZWxldmFudG7DrWluZm9ybWFjZSBhbmVibyB1bW/Fvm5pdCB2emTDoWxlbsO9IHDFmcOtc3R1cAoKQnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRDAyLCBYMzYxIElyZWxhbmQKCnNlIG5lYnVkb3UgemFwb8SNw610w6F2YXQgZG8gxI1hc8WvIG5hIG9kc3RyYW7Em27DrXrDoXZhZHkuCihjKSBWxb5keSB1ZHLFvm92YXQgZG9icm91IGtvbXVuaWthY2kgcyBOZW1vY25pY2kuCgo0LiBEb3N0dXBub3N0IHNsdcW+ZWIgcG9kcG9yeQo0MS4gU3BvbGXEjW5vc3QgQnJhaW5vbWl4IHBvc2t5dG5lIG7DoXNsZWR1asOtY8Otc2x1xb5ieSBwb2Rwb3J5IGtlIFNsdcW+YsSbOgooZykgVGVsZWZvbmlja8OhIGdvZGdvcmE6IC0gbmEgdGVsLiDEjS4gaWRvc3R1cG7DoSAyNC83LCBuYSB0ZWwuIMSNLiBuZWJvCmRvc3R1cG7DoSB2IFByYWNvdm7DrWNoIGRuZWNoIHYgZG9ixJsgb2QgOTowMCBkbyAxNzowMArCqSBFLW1haWxvdsOhIGdvZGdvcmE6IG5hIHNsZWRvdmFuw6EgdiBQcmFjb3Zuw61jaCBkbmVjaCB2IGRvYsSbIG9kIDk6MDAgZG8gMTc6MDAuCjUuIMW9w6Fkb3N0IG8gcG9kcG9ydQo1MS4gTmVtb2NuaWNlIG3Fr8W+ZSBwb8W+w6FkYXQgbyBwb2Rwb3J1LCBwb2t1ZCBidWRlIMW+w6Fkb3N0IG9ic2Fob3ZhdCBwb3BpcyBwcm9ibMOpbXUgYSDEjWFzLCB2IG7Em23FvgoKaW5jaWRlbnQgemFwb8SNYWwgKCLFvcOhZG9zdCBvIHBvZHBvcnUiKSwgxIxhcyBwxZlpamV0w63FvcOhZG9zdGkgbyBwb2Rwb3J1IHNlIHVyxI3DrW9rYW3FvmlrZW0gcMWZaWpldMOtCnBvxb5hZGF2a3UKCjUuMi4gTmVtb2NuaWNlIHBvc2t5dG5lIHNwb2xlxI1ub3N0aSBCcmFpbm9taXg6CihhKSByeWNobMOpIG96bsOhbWVuw61qYWvDqWtvbGkgesOhdmFkeSBTbHXFvmJ5OyBhCihiKSB0YWtvdsOpIHbDvXN0dXB5IGEgamluw6EgZGF0YSwgZG9rdW1lbnR5LCBpbmZvcm1hY2UsIHNvdcSNaW5ub3N0IGEgdnpkw6FsZW7DvSBwxZnDrXN0dXAsIGt0ZXLDqSBsemUgcm96dW1uxJsKcG/FvmFkb3ZhdCwgYWJ5IHBvbW9obCBzcG9sZcSNbm9zdGkgQnJhaW5vbWl4IHZ5dHZvxZlpdCBvcGVyYcSNbsOtIHBvZG3DrW5reSBwb2RvYm7DqSB0xJttLCBrdGVyw6kgbmFzdGFseQoKdiBkb2LEmywga2R5IE5lbW9jbmljZSB6amlzdGlsYSBwxZllZG3Em3Rub3UgesOhdmFkdSwgYSByZWFnb3ZhdCBuYSBwxZllZG3Em3Rub3Ugxb3DoWRvc3QgbyBwb2Rwb3J1LgoKNS4zLiBQxZlpIHBvZHBvxZllIHNsdcW+ZWIgdXByYXZlbsO9Y2ggdG91dG8gZG9ob2RvdSBidWRlIHNwb2xlxI1ub3N0IEJyYWlub21peCDFmWFkaXQgxb3DoWRvc3RpIG8gcG9kcG9ydSBkbGUKamVqw60gcm96dW1uw6kgw7p2YWh5IDAgc3R1cG5pIHrDoXZhxb5ub3N0aSBobMOhxaFlbsO9Y2ggcHJvYmzDqW3FryBhIHZ5dmluZSDDunNpbMOtLCBrdGVyw6kgcG8gbsOtIGx6ZSByb3p1bW7Emwpwb8W+YWRvdmF0LCBrIHRvbXUsIGFieSByZWFnb3ZhbGEgbmEgaW5jaWRlbnR5IHTDvWthasOtY8OtIHNlIHNsdcW+ZWIgYS9uZWJvIMW9w6Fkb3N0aSBvIHBvZHBvcnUgYsSbaGVtCmPDrWxvdsO9Y2ggZG9iIHJlYWtjZSBwcm9qZWRub3RsaXbDqSBzdHVwbsSbIHrDoXZhxb5ub3N0aSB0YWssamFranNvdSB0eXRvIHVwcmF2ZW55IHYgbsOhc2xlZHVqw61jw610YWJ1bGNlOgoKIAoKU3R1cGXFiCB6w6F2YcW+bm9zdGkKCkPDrWxvdsOhIGRvYmEgcmVha2NlCgpDw61sb3ZhIGRvYmEgdnnFmWXFoWVuw60KCiAKCktyaXRpY2vDvTogesOhdmFkYSBzIGtyaXRpY2vDvW0gZG9wYWRlbSBuYQprbGluaWNrw6kgd29ya2Zsb3c7IHrDoWtsYWRuw60gZnVua2NlIHN5c3TDqW11Cmpzb3UgbmVkb3N0dXBuw6kuCgpOYXDFmS46IHN5c3TDqW0gbmVwb3NreXR1amUgxb7DoWRuw6EgaG9kbm9jZW7DrTsKV2ViVUkgbmVibyBNb2JpbG7DrS9DbG91ZG92w6kgc2x1xb5ieWpzb3UKbmVkb3N0dXBuw6kKCmRvIDIgUHJhY292bsOtY2ggaG9kaW4KCjI0IFByYWNvdm7DrWNoIGhvZGluCgogCgpNecWhOiB6w6F2YWRhIHMgdsSbdMWhw61tIGRvcGFkZW0gbmEga2xpbmlja8OpCndvcmtmbG93OyBuxJtrdGVyw6kgesOha2xhZG7DrWZ1bmtjZSBzeXN0w6ltdQpqc291IG9tZXplbsOpIGEgamUgZG9zdHVwbsOpIG7DoWhyYWRuw60KKGRvxI1hc27DqSkgxZllxaFlbsOtLgoKTmFwxZkuOiBzeXN0w6ltamUgbmVkb3N0dXBuw70gcG91emUgcHJvCm7Em2t0ZXLDqSB1xb5pdmF0ZWxlOyBuZWZ1bmd1amUgYXV0b21hdGlja8OpCndvcmtmbG93LCBhbGVqZSBkb3N0dXBuw6kgbWFudcOhbG7DrQoKZG9zIFByYWNvdm7DrWNoIGhvZGluCgo0OCBQcmFjb3Zuw61jaCBob2RpbgoKIAoKIAoKJTogesOhdmFkYSBzIG1hbMO9bSBkb3BhZGVtIG5hIGtsaW5pY2vDqQp3b3JrZmxvdy4KCk5hcMWZLjogZHJvYm7DqSBjaHlieSB1xb5pdmF0ZWxza8OpaG8gcm96aHJhbsOtLAprdGVyw6kgbmVtYWrDrXZsaXYgbmEgdnlob2Rub2NlbsOtOyBwb21hbGVqxaHDrQphbmFsw716YSBwxZlpIHphY2hvdsOhbsOtIHBvc2t5dG92w6Fuw612w71zbGVka8WvOwpkb8SNYXNuw6ksIG5lcMWZZXRydsOhdmFqw61jw60gc2VsaMOhbsOtIHDFmWlobMOhxaFlbsOtCgogCgpkbyAyNCBQcmFjb3Zuw61jaCBob2RpbgoKIAoKNyBQcmFjb3Zuw61jaCBkbsWvCgogCgogCgo1LjQuIFNtbHV2bsOtc3RyYW55IHNlIG1vaG91IHYga29ua3LDqXRuw61tIHDFmcOtcGFkxJsgcMOtc2VtbsSbIGRvaG9kbm91dCBuYSByb3p1bW7DqW0gcHJvZGxvdcW+ZW7DrUPDrWxvdsOpCmRvYnkgcmVha2NlLiBWIHDFmcOtcGFkxJssIMW+ZSBrdGVyw6Frb2xpIHplIHNtbHV2bsOtY2ggc3RyYW4gemFzdMOhdsOhIG7DoXpvciwgxb5lIHrDoXZhZGEgdnnFvmFkdWplIHDFmWVkbm9zdG7DrQp2ecWZw616ZW7DrSwgbcWvxb5lIHBvxb7DoWRhdCBkcnVob3Ugc21sdXZuw60gc3RyYW51IG8gem3Em251IHDFmWVkbm9zdGkgxb3DoWRvc3RpIG8gcG9kcG9ydS4gU21sdXZuw61zdHJhbnkKbsOhc2xlZG7EmyB0YWtvdsO9IHBvxb5hZGF2ZWsgcHJvamVkbmFqw61hIGRvaG9kbm91IHNlIG5hIHBvxZlhZMOtxb3DoWRvc3RpIG8gcG9kcG9ydS4KCjUuNQoKUGxhdGJhIGEKNi4xIE5hCgpCcmFpbm9taXggRXVyb3BlIExpbWl0ZWQKU3VpdGUgMTAzODAKCjI2LzI3IFVwcGVyIFBlbWJyb2tlIFN0cmVldApEdWJsaW4gMiBEMDIsIFgzNjEgSXJlbGFuZAoKU2Fua2NlIHphIG5lZG9kcsW+ZW7DrSBjw61sb3bDqSBkb2J5IHJlYWtjZSBhIHZ5xZllxaFlbsOtCgpBYnkgYnlsYSB6YWppxaF0xJtuYSBvZHBvdsSbZG5vc3Qgc3BvbC4gQnJhaW5vbWl4LCBidWRvdSB2IHDFmcOtcGFkxJsgbmVkb2Ryxb5lbsOtIGPDrWxvdsOpIGRvYnkgb2RlenZ5IDMKdnnFmWXFoWVuw60gdXBsYXRuxJtueSBuw6FzbGVkdWrDrWPDrSBzYW5rY2U6CgpTdHVwZcWIIHrDoXZhxb5ub3N0aTogS3JpdGlja8O9ICgxLiB6w6F2YcW+bm9zdCl6ClBydm7DrSBwxZllc3R1cGVrOiA1JSBrcmVkaXQgeiBtxJtzw63EjW7DrWhvIHBvcGxhdGt1IHphIHNsdcW+YnUuCgpOw6FzbGVkbsOpIHDFmWVzdHVwa3k6IDEwJSBrcmVkaXQgeiBtxJtzw63EjW7DrWhvIHBvcGxhdGt1IHphIHNsdcW+YnUgemEga2HFvmTDvSBwxZnDrXBhZCBuZWRvZHLFvmVuw60uCgpTdHVwZcWIIHrDoXZhxb5ub3N0aTogVnnFocWhw60gKHrDoXZhxb5ub3N0IFopOgpQcnZuw60gcMWZZXN0dXBlazogMyUga3JlZGl0IHogbcSbc8OtxI1uw61obyBwb3BsYXRrdSB6YSBzbHXFvmJ1LgoKTsOhc2xlZG7DqSBwxZllc3R1cGt5OiA1JSBrcmVkaXQgeiBtxJtzw63EjW7DrWhvIHBvcGxhdGt1IHphIHNsdcW+YnUgemEga2HFvmTDvSBwxZnDrXBhZCBuZWRvZHLFvmVuw60uCgpTdHVwZcWIIHrDoXZhxb5ub3N0aTogTmnFvsWhw60gKHrDoXZhxb5ub3N0IDMpOgpQcnZuw60gcMWZZXN0dXBlazogMCAlIGtyZWRpdCB6IG3Em3PDrcSNbsOtaG8gcG9wbGF0a3UgemEgc2x1xb5idS4KCk7DoXNsZWRuw6kgcMWZZXN0dXBreTogMiUga3JlZGl0IHogbcSbc8OtxI1uw61obyBwb3BsYXRrdSB6YSBzbHXFvmJ1IHphIGthxb5kw70gcMWZw61wYWQgbmVkb2Ryxb5lbsOtLgoKdnlyb3Zuw6Fuw60gc2Fua2PDrQoKa29uY2kga2HFvmTDqWhvIHJvxI1uw61obyB2w71yb8SNw60gUm96aG9kbsOpaG8gb2Jkb2LDrSBwcm92ZWRlIE5lbW9jbmljZSByb8SNbsOtIGhvZG5vY2Vuw60gU2x1xb5lYiwga3RlcsOpCgpwb3NvdWTDrSDDunJvdmXFiCBwbG7Em27DrSBwb2Rwb3J5IHBvZGxlIHNtbG91dnkgMCDDunJvdm7DrSBzbHXFvmViIChTTEEpLgoKQ2Vsa292w70gcG/EjWV0IHDFmcOtcGFkxa8sIGt0ZXLDvSBuZW7DrSB2IHNvdWxhZHUgcyBvxI1la8OhdmFuw71tIHBsbsSbbsOtbSBwcm8ga2HFvmRvdSDDunJvdmXFiCB6w6F2YcW+bm9zdGkgKGtyaXRpY2vDoSwKCnrDoXZhxb5uw6EsIG1hbMOhKSwgYnVkZSB6YXpuYW1lbsOhbiBhIHpkb2t1bWVudG92w6FuLgoKNi4yIENlbGtvdsOhIHBlbsSbxb5uw60gaG9kbm90YSBzYW5rY8OtemEgZGFuw70gcm9rIGJ1ZGUgc291xI10ZW0gdsWhZWNoIGtyZWRpdMWvIHZ5cG/EjXRlbsO9Y2ggcHJvIGthxb5kw70gcMWZw61wYWQKbmVkb2Ryxb5lbsOtIG5hIHbFoWVjaCDDunJvdm7DrWNoIHrDoXZhxb5ub3N0aS4KClByb2NlcyB2eXJvdm7DoW7DrSBzYW5rY8OtCgo3LjEKCjcuMgoKQ2Vsa292w6EgcGVuxJvFvm7DrSBob2Rub3RhIHNhbmtjw60gdnpuaWtsw71jaCBixJtoZW0gc21sdXZuw61obyByb2t1IChrcm9txJsgcG9zbGVkbsOtaG8gcm9rdSkgcG9za3l0b3bDoW7DrQpTbHXFvmJ5IGJ1ZGUgb2RlxI10ZW5hIHogcGxhdGJ5IG5hIGRhbMWhw60gcm/EjW7DrSBvYmRvYsOtLgpDZWxrb3bDoSBwZW7Em8W+bsOtIGhvZG5vdGEgc2Fua2PDrSB2em5pa2zDvWNoIGLEm2hlbSBwb3NsZWRuw61obyBzbWx1dm7DrWhvIHJva3UgcG9za3l0b3bDoW7DrSBTbHXFvmJ5IGJ1ZGUKCnZ5cm92bsOhbmEgdnlzdGF2ZW7DrW0gZmFrdHVyeSBOZW1vY25pY2ksIHDFmWnEjWVtxb4gQnJhaW5vbWl4IHVocmFkw61mYWt0dXJ1IE5lbW9jbmljaSB2IG3DqW7EmyBDWksKCm5lanBvemTEm2ppIGRvIDMwICh0xZlpY2V0aSkgZG7FryBvZCBkYXRhIG9kZXNsw6Fuw60gcMWZw61zbHXFoW7DqSBmYWt0dXJ5IG5hIGFkcmVzdToKCkRva3VtZW50YWNlIGEgdHJhbnNwYXJlbnRub3N0Cgo4LjEKCjguMgoKOC4zCgo4LjQKClbDvWppbWt5Cgo5LjEuCgpIb2Rub3TDrWPDrSB6cHLDoXZhIGJ1ZGUgb2JzYWhvdmF0IHBvZHJvYm5vdSBkb2t1bWVudGFjaSB2xaFlY2ggcMWZw61wYWTFryBuZWRvZHLFvmVuw60gcGxuxJtuw60gU2x1xb5lYiwKa3RlcsOhIHphamlzdMOtdHJhbnNwYXJlbnRub3N0IHbDvXBvxI10dSBhIHVwbGF0xYhvdsOhbsOtc2Fua2PDrS4KCk9ixJsgc21sdXZuw60gc3RyYW55IHDFmWVkIHphcG/EjXRlbsOtbSBzYW5rY8OtIGEgdnlzdGF2ZW7DrW0gZmFrdHVyeSB6a29udHJvbHVqw60gamVqaWNoIHNwcsOhdm5vc3QgYQpkb2hvZG5vdSBzZSBuYSBjZWxrb3bDvWNoIHNhbmtjw61jaC4KCkpha8Opa29saSBzcG9yeSB0w71rYWrDrWPDrSBzZSB2w71wb8SNdHUgbmVibyB1cGxhdG7Em27DrSBzYW5rY8OtIG11c8OtIGLDvXQgdnpuZXNlbnkgZG8gMzAgZG7FryBvZCBvYmRyxb5lbsOtCnbDvXJvxI1uw60gaG9kbm90w61jw60genByw6F2eS4KCk9ixJsgc21sdXZuw60gc3RyYW55IGJ1ZG91IHNwb2x1cHJhY292YXQgbmEgc3ByYXZlZGxpdsOpbSBhIHbEjWFzbsOpbSB2ecWZZcWhZW7DrWpha8O9Y2hrb2xpIHNwb3LFryBvaGxlZG7Emwp2w71wb8SNdHUgbmVibyB1cGxhdG7Em27DrXNhbmtjw60uCgpCcmFpbm9taXggdcSNaW7DrXbFoWUsIGNvIG9kIG7Em2ogbHplIHJvenVtbsSbIHBvxb5hZG92YXQsIGFieSB2ecWZZcWhaWwga2HFvmRvdSB6w6F2YWR1IFNsdcW+YnkgdsSNYXMuCgpaIHV2ZWRlbsOpaG8gdsWhYWsgZXhpc3R1asOtIG7DoXNsZWR1asOtY8OtIHbDvWppbWt5LCBuYSBrdGVyZSBzZSB0YXRvIGRvaG9kYSBuZXZ6dGFodWplOgoKQnJhaW5vbWl4IEV1cm9wZSBMaW1pdGVkClN1aXRlIDEwMzgwCgoyNi8yNyBVcHBlciBQZW1icm9rZSBTdHJlZXQKRHVibGluIDIgRDAyLCBYMzYxIElyZWxhbmQKCihhKSBEb2hvZGEgc2UgbmV2enRhaHVqZSBuYSBqYWvDvWtvbGkgc29mdHdhcmUgxI1pIHNsdcW+YnUgb2RsacWhbm91IG9kIFNsdcW+Ynk7CihiKSBaw6F2YWRhIGJ5bGEgenDFr3NvYmVuYSBwb3XFvml0w61tIHZ5YmF2ZW7DrSwgc29mdHdhcmUgxI1pIHNsdcW+YnkgenDFr3NvYmVtLCBrdGVyw70gbmVuw60KCnBvdm9sZW47CihjKSBOZW1vY25pY2UgcHJvdmVkbGEgbmVhdXRvcml6b3ZhbsOpIHptxJtueSB2IGtvbmZsZ3VyYWNpIG5lYm8gbmFzdGF2ZW7DrVNvZnR3YXJ1IGEgdGF0byB6bcSbbmEKCnpwxa9zb2JpbGEgesOhdmFkdSBTbHXFvmJ5OwoKKGQpIFrDoXZhZGEgYnlsYSB6cMWvc29iZW5hIHptxJtub3UgdiBJVCBpbmZyYXN0cnVrdHXFmWUgTmVtb2NuaWNlLCBrdGVyw6EgbmFzdGFsYSBwbyBpbnN0YWxhY2kgU2x1xb5ieTsKCmFuZWJvCihlKSBaw6F2YWRhIGJ5bGEgenDFr3NvYmVuYSBuZXBvZHBvcm92YW7DvW0gemHFmcOtemVuw61tLCBzb2Z0d2FyZW0gxI1pamluw71taSBzbHXFvmJhbWkuCgo5LjIuIFRhdG8gZG9ob2RhIHNlIG5ldnp0YWh1amUgbmEgb2tvbG5vc3RpLCBrdGVyw6kgbmVqc291IHYgbW9jaSBwb3NreXRvdmF0ZWxlIFNsdcW+YnkgdsSNZXRuxJssIGF2xaFhayBuaWtvbGkKCnbDvWx1xI1uxJssamFrw6lob2tvbGlqZWRuw6Fuw63EjWkgb3BvbWVudXTDrSBOZW1vY25pY2UgYW5lYm8gdMWZZXTDrSBzdHJhbnksIHN0w6F2a3ksIHbDvWx1a3kgcHJvdm96dSDEjWkKamluw6lobyBrb2xla3Rpdm7DrWhvIHNwb3J1IHbDvXBhZGt1IHZlxZllam7DqSBpbmZyYXN0cnVrdHVyeSwgZG9wcmF2eSBhbmVibyB0ZWxla29tdW5pa2HEjW7DrWNoIHPDrXTDrSwgdnnFocWhw60KbW9jaSwgdsOhbGt5LCBwb3ZzdMOhbsOtLCBvYsSNYW5za8O9Y2ggbmVwb2tvasWvLCB6cMWvc29iZW7DrcWha29keSB6ZSDFoWtvZG9saWJvc3RpLCBuZWhvZHksIHBvcnVjaHkKdG92w6FybsOtaG8gbmVibyBzdHJvam7DrWhvIHphxZnDrXplbsOtLCBwb8W+w6FydSwgcG92b2Ruw60sIGJvdcWZZS4KCjkuMy4gVGF0byBkb2hvZGEgc2UgdMOpxb4gbmV2enRhaHVqZSBuYSBwxZnDrXBhZHksIGtkeSBOZW1vY25pY2UgcG9kc3RhdG7DvW0genDFr3NvYmVtIHBvcnXFoXVqZQoKcG9kbcOtbmt5IHN0YW5vdmVuw6kgdiB0w6l0byBTbWxvdXbEmywgdsSNZXRuxJsKcHJvZGxlbsOtIHBsYXRib3UgT2RtxJtueS4KCkJyYWlub21peCBFdXJvcGUgTGltaXRlZAoKU3VpdGUgMTAzODAKMjYvMjcgVXBwZXIgUGVtYnJva2UgU3RyZWV0CkR1YmxpbiAyIERPWiwgWDM2MSBJcmVsYW5kCgogCgo=576583fd5a33a66bc503f87b67753a5da5c83c14ec31145f2b4363f3c908fbe8[A] S20260030100 Kupní smlouva na SW pro záchyt CMP.txt2026-06-15T01:25:40+02:001005bf1911eaa73465f2b01af1647561e47daab0bda768beacdf09f1d9bb6b0cc