PCFkb2N0eXBlIGh0bWwgcHVibGljICItLy93M2MvL2R0ZCBodG1sIDQuMCB0cmFuc2l0aW9uYWwvL2VuIj4KPGh0bWw+Cgo8aGVhZD4KPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9aXNvLTg4NTktMSI+Cjx0aXRsZT5SZWFkTWUgZm9yIElDVTRKPC90aXRsZT4KPCEtLQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiogQ29weXJpZ2h0IChDKSAyMDAwLTIwMDMsIEludGVybmF0aW9uYWwgQnVzaW5lc3MgTWFjaGluZXMgQ29ycG9yYXRpb24gYW5kICAgICoKKiBvdGhlcnMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKgoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCioKKiAkU291cmNlOiAveHNybC9Oc3ZuL2ljdS9pY3U0ai9yZWFkbWUuaHRtbCx2ICQKKiAkRGF0ZTogMjAwMy8xMS8yNSAwMToyMzo1OSAkCiogJFJldmlzaW9uOiAxLjUxICQKKgoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0tPgo8L2hlYWQ+Cgo8Ym9keSBiZ2NvbG9yPSIjRkZGRkZGIiBsaW5rPSIjMDAwMEZGIiB2bGluaz0iIzgwMDA4MCIgbGFuZz0iRU4tVVMiPgoKICAgIDxoMj5JbnRlcm5hdGlvbmFsIENvbXBvbmVudHMgZm9yIFVuaWNvZGUgZm9yIEphdmE8L2gyPgogICAgPGgzPlJlYWQgTWUgZm9yIElDVTRKIDIuODwvaDM+Cgo8aHIgc2l6ZT0iMiIgd2lkdGg9IjEwMCUiIGFsaWduPSJjZW50ZXIiPgogICAgPHA+PGI+UmVsZWFzZSBEYXRlPC9iPjxicj4KICAgIE5vdmVtYmVyIDNyZCwgMjAwMzwvcD4KCjxwPkZvciB0aGUgbW9zdCByZWNlbnQKICAgICAgcmVsZWFzZSwgc2VlIHRoZSA8YSBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovZG93bmxvYWQvaW5kZXguaHRtbCI+CiAgICAgIElDVTRKIGRvd25sb2FkIHNpdGU8L2E+LgogICAgPC9QPgoKPGgzPjx1PkNvbnRlbnRzPC91PjwvaDM+Cgo8dWwgdHlwZT0iZGlzYyI+CiAgPGxpPjxhIGhyZWY9IiNpbnRyb2R1Y3Rpb24iPkludHJvZHVjdGlvbiB0byBJQ1U0SiAoSW50ZXJuYXRpb25hbCBDb21wb25lbnRzIGZvciBVbmljb2RlIGZvciBKYXZhKTwvYT48L2xpPgogIDxsaT48YSBocmVmPSIjbGljZW5zZSI+TGljZW5zZSBJbmZvcm1hdGlvbjwvYT48L2xpPgogIDxsaT48YSBocmVmPSIjUGxhdGZvcm1EZXBlbmRlbmNpZXMiPlBsYXRmb3JtIERlcGVuZGVuY2llczwvYT48L2xpPgogIDxsaT48YSBocmVmPSIjZG93bmxvYWQiPkhvdyB0byBEb3dubG9hZCBJQ1U0SjwvYT48L2xpPgogIDxsaT48YSBocmVmPSIjV2hhdENvbnRhaW4iPlRoZSBTdHJ1Y3R1cmUgYW5kIENvbnRlbnRzIG9mIElDVTRKPC9hPjwvbGk+CiAgPGxpPjxhIGhyZWY9IiNBUEkiPldoZXJlIHRvIEdldCBEb2N1bWVudGF0aW9uPC9hPjwvbGk+CiAgPGxpPjxhIGhyZWY9IiNIb3dUb0luc3RhbGxKYXZhYyI+SG93IHRvIEluc3RhbGwgYW5kIEJ1aWxkPC9hPjwvbGk+CiAgPGxpPjxhIGhyZWY9IiNIb3dUb01vZHVsYXJpemUiPkhvdyB0byBtb2R1bGFyaXplIElDVTRKPC9hPjwvbGk+CiAgPGxpPjxhIGhyZWY9IiN0cnlpbmdvdXQiPlRyeWluZyBPdXQgSUNVNEo8L2E+PC9saT4KICA8bGk+PGEgaHJlZj0iI3Jlc291cmNlcyI+SUNVNEogUmVzb3VyY2UgSW5mb3JtYXRpb248L2E+PC9saT4KICA8bGk+PGEgaHJlZj0iI1doZXJlVG9GaW5kTW9yZSI+V2hlcmUgdG8gRmluZCBNb3JlIEluZm9ybWF0aW9uPC9hPjwvbGk+CiAgPGxpPjxhIGhyZWY9IiNTdWJtaXR0aW5nQ29tbWVudHMiPlN1Ym1pdHRpbmcgQ29tbWVudHMsIFJlcXVlc3RpbmcgRmVhdHVyZXMgYW5kIFJlcG9ydGluZwogICAgQnVnczwvYT48L2xpPgo8L3VsPgoKPGgzPjxhIE5BTUU9ImludHJvZHVjdGlvbiI+PC9hPjx1PkludHJvZHVjdGlvbiB0byBJQ1U0SiAoSW50ZXJuYXRpb25hbCBDb21wb25lbnRzIGZvciBVbmljb2RlIGZvciBKYXZhKTwvdT48L2gzPgoKPHA+VG9kYXkncyBnbG9iYWwgbWFya2V0IGRlbWFuZHMgcHJvZ3JhbXMgdGhhdCBzdXBwb3J0IGEgd2lkZSB2YXJpZXR5CiAgICBvZiBsYW5ndWFnZXMgYW5kIG5hdGlvbmFsIGNvbnZlbnRpb25zLiZuYnNwOyBDdXN0b21lcnMgcHJlZmVyIHNvZnR3YXJlCiAgICBhbmQgd2ViIHBhZ2VzIHRhaWxvcmVkIHRvIHRoZWlyIG5lZWRzLCBzdHVkaWVzIGNvbmZpcm0gdGhhdAogICAgdGhpcyBsZWFkcyB0byBpbmNyZWFzZWQgc2FsZXMuJm5ic3A7ICBKYXZhIHByb3ZpZGVzIGEgc3Ryb25nCiAgICBmb3VuZGF0aW9uIGZvciBnbG9iYWwgcHJvZ3JhbXMsIGFuZCBJQk0gYW5kIHRoZSBJQ1U0SiB0ZWFtIHBsYXllZAogICAgYSBrZXkgcm9sZSBpbiBwcm92aWRpbmcgZ2xvYmFsaXphdGlvbiB0ZWNobm9sb2d5IHRvIFN1biBmb3IgdXNlIGluCiAgICBKYXZhLiA8L3A+CiAgICA8cD4KICAgIEJ1dCBKYXZhIGRvZXMgbm90IHlldCBwcm92aWRlIGFsbCB0aGUgZmVhdHVyZXMgdGhhdCBzb21lIHByb2R1Y3RzIHJlcXVpcmUuJm5ic3A7IElDVTRKIGlzIGFuIGFkZC1vbiBsaWJyYXJ5IHRoYXQgZXh0ZW5kcyBKYXZhJ3MgZ2xvYmFsaXphdGlvbiB0ZWNobm9sb2d5IGJ5IHByb3ZpZGluZyB0aGUgZm9sbG93aW5nIHRvb2xzOgogICAgPHVsPgogICAgPGxpPgogICAgVW5pY29kZSBOb3JtYWxpemF0aW9uIJYgTkZDLCBORkQsIE5GS0QsIE5GS0MKICAgICAgICA8YmxvY2txdW90ZT5Qcm9kdWNlcyBjYW5vbmljYWwgdGV4dCByZXByZXNlbnRhdGlvbnMsIG5lZWRlZCBmb3IgWE1MIGFuZCB0aGUgbmV0LjwvYmxvY2txdW90ZT4KICAgIDxsaT4KICAgIEludGVybmF0aW9uYWwgQ2FsZW5kYXJzIJYgQXJhYmljLCBCdWRkaGlzdCwgSGVicmV3LCBhbmQgSmFwYW5lc2U8YnI+CiAgICAgICAgPGJsb2NrcXVvdGU+UmVxdWlyZWQgZm9yIGNvcnJlY3QgcHJlc2VudGF0aW9uIG9mIGRhdGVzIGluIHNvbWUgY291bnRyaWVzLjwvYmxvY2txdW90ZT4KICAgIDxsaT4KICAgIE51bWJlciBGb3JtYXQgRW5oYW5jZW1lbnRzIJYgU2NpZW50aWZpYyBOb3RhdGlvbiwgU3BlbGxlZC1vdXQgTnVtYmVycwogICAgICAgICAgICAgIDxibG9ja3F1b3RlPkVuaGFuY2VzIHN0YW5kYXJkIEphdmEgbnVtYmVyIGZvcm1hdHRpbmcuIFRoZSBzcGVsbGVkLW91dCBmb3JtYXQgaXMgdXNlZApmb3IgY2hlY2tzIGFuZCBzaW1pbGFyIGRvY3VtZW50cy48L2Jsb2NrcXVvdGU+CgogICAgPGxpPkVuaGFuY2VkIHdvcmQtYnJlYWsgZGV0ZWN0aW9uIJYgUnVsZS1iYXNlZCwgc3VwcG9ydHMgVGhhaQogICAgICAgICAgICAgIDxibG9ja3F1b3RlPlJlcXVpcmVkIGZvciBjb3JyZWN0IHN1cHBvcnQgb2YgVGhhaS48L2Jsb2NrcXVvdGU+CgogICAgPGxpPlVuaWNvZGUgVGV4dCBDb21wcmVzc2lvbiCWIFN0YW5kYXJkIGNvbXByZXNzaW9uIG9mIFVuaWNvZGUgdGV4dAogICAgICAgICAgICAgIDxibG9ja3F1b3RlPlN1aXRhYmxlIGZvciBsYXJnZSBudW1iZXJzIG9mIHNtYWxsIGZpZWxkcywgd2hlcmUgTFpXIGFuZCBzaW1pbGFyIHNjaGVtZXMKZG8gbm90IGFwcGx5LjwvYmxvY2txdW90ZT4KICAgIDxsaT5Db2xsYXRpb24gLSBSdWxlLWJhc2VkLCB1cC10by1kYXRlIFVuaWNvZGUgQ29sbGF0aW9uIEFsZ29yaXRobSAoVUNBKSBzb3J0aW5nIG9yZGVyCiAgICAgICAgPGJsb2NrcXVvdGU+Rm9yIGZhc3QgbXVsdGlsaW5ndWFsIHN0cmluZyBjb21wYXJpc29uPC9ibG9ja3F1b3RlPgogICAgPC91bD4KSW4gc29tZSBjYXNlcywgdGhlIGFib3ZlIHN1cHBvcnQgaGFzIGJlZW4gcm9sbGVkIGludG8gYSBsYXRlciByZWxlYXNlIG9mCkphdmEuIEZvciBleGFtcGxlLCB0aGUgVGhhaSB3b3JkLWJyZWFrIGlzIG5vdyBpbiBKYXZhIDEuNC4gSG93ZXZlciwgaWYgeW91CmFyZSB1c2luZyBKYXZhIDEuMywgeW91IGNhbiB1c2UgdGhlIElDVTRKIHBhY2thZ2UgdW50aWwgeW91IHVwZ3JhZGUgdG8gMS40Lgo8L3A+Cgo8aDM+PGEgbmFtZT1saWNlbnNlPjwvYT48dT5MaWNlbnNlIEluZm9ybWF0aW9uPC91PjwvaDM+CjxwPgpUaGUgSUNVIHByb2plY3RzIChJQ1U0QyBhbmQgSUNVNEopIHVzZSB0aGUgWCBsaWNlbnNlLiZuYnNwOyBUaGUgWCBsaWNlbnNlIGlzIGEgPGI+bm9uLXZpcmFsPC9iPiBhbmQgcmVjb21tZW5kZWQgZnJlZSBzb2Z0d2FyZSBsaWNlbnNlIHRoYXQgaXMgY29tcGF0aWJsZSB3aXRoIHRoZSBHTlUgR1BMIGxpY2Vuc2UuJm5ic3A7IFRoaXMgYmVjYW1lIGVmZmVjdGl2ZSB3aXRoIHJlbGVhc2UgMS44LjEgb2YgSUNVNEMgYW5kIHJlbGVhc2UgMS4zLjEgb2YgSUNVNEogaW4gbWlkLTIwMDEuIEFsbCBuZXcgSUNVIHJlbGVhc2VzIHdpbGwgYWRvcHQgdGhlIFggbGljZW5zZTsgcHJldmlvdXMgSUNVIHJlbGVhc2VzIGNvbnRpbnVlIHRvIHV0aWxpemUgdGhlIElQTCAoSUJNIFB1YmxpYyBMaWNlbnNlKS4mbmJzcDsgVXNlcnMgb2YgcHJldmlvdXMgcmVsZWFzZXMgb2YgSUNVIHdobyB3YW50IHRvIGFkb3B0IG5ldyBJQ1UgcmVsZWFzZXMgd2lsbCBuZWVkIHRvIGFjY2VwdCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIFggbGljZW5zZS4KPC9wPgo8cD4KVGhlIG1haW4gZWZmZWN0IG9mIHRoZSBjaGFuZ2UgaXMgdG8gcHJvdmlkZSBHUEwgY29tcGF0aWJpbGl0eS4mbmJzcDsgVGhlIFggbGljZW5zZSBpcyBsaXN0ZWQgYXMgR1BMIGNvbXBhdGlibGUsIHNlZSB0aGUgZ251IHBhZ2UgYXQgPGEgaHJlZj1odHRwOi8vd3d3LmdudS5vcmcvcGhpbG9zb3BoeS9saWNlbnNlLWxpc3QuaHRtbCNHUExDb21wYXRpYmxlTGljZW5zZXM+Cmh0dHA6Ly93d3cuZ251Lm9yZy9waGlsb3NvcGh5L2xpY2Vuc2UtbGlzdC5odG1sI0dQTENvbXBhdGlibGVMaWNlbnNlczwvYT4uICBUaGlzIG1lYW5zIHRoYXQgR1BMIHByb2plY3RzIGNhbiBub3cgdXNlIElDVSBjb2RlLCBpdCBkb2VzIDxiPm5vdDwvYj4gbWVhbiB0aGF0IHByb2plY3RzIHVzaW5nIElDVSBiZWNvbWUgc3ViamVjdCB0byBHUEwuCjwvcD4KPHA+ClRoZSB0ZXh0IG9mIHRoZSBYIGxpY2Vuc2UgaXMgYXZhaWxhYmxlIGF0IDxhIGhyZWY9aHR0cDovL3d3dy54Lm9yZy90ZXJtcy5odG0+aHR0cDovL3d3dy54Lm9yZy90ZXJtcy5odG08L2E+LiBUaGUgSUJNIHZlcnNpb24gY29udGFpbnMgdGhlIGVzc2VudGlhbCB0ZXh0IG9mIHRoZSBsaWNlbnNlLCBvbWl0dGluZyB0aGUgWC1zcGVjaWZpYyB0cmFkZW1hcmtzIGFuZCBjb3B5cmlnaHQgbm90aWNlcy4gIFRoZSBmdWxsIGNvcHkgb2YgPGEgaHJlZj1saWNlbnNlLmh0bWw+SUNVJ3MgbGljZW5zZTwvYT4gaXMgaW5jbHVkZWQgaW4gdGhlIGRvd25sb2FkIHBhY2thZ2UuCjwvcD4KPHA+CkZvciBtb3JlIGRldGFpbHMgcGxlYXNlIHNlZSB0aGUgPGEgaHJlZj1odHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1L3ByZXNzLmh0bWw+cHJlc3MgYW5ub3VuY2VtZW50PC9hPiBhbmQgdGhlIDxhIGhyZWY9aHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2ljdS9wcm9qZWN0X2ZhcS5odG1sI2xpY2Vuc2U+UHJvamVjdCBGQVE8L2E+Lgo8L3A+Cgo8aDM+PGEgTkFNRT0iUGxhdGZvcm1EZXBlbmRlbmNpZXMiPjwvYT48dT5QbGF0Zm9ybSBEZXBlbmRlbmNpZXM8L3U+PC9oMz4KICAgICAgPFA+CiAgICAgIFBhcnRzIG9mIElDVTRKIGRlcGVuZCBvbiBmdW5jdGlvbmFsaXR5IHRoYXQgaXMgb25seSBhdmFpbGFibGUgaW4gSkRLIDEuMwogICAgICBvciBsYXRlciwgYWx0aG91Z2ggc29tZSBjb21wb25lbnRzIHdvcmsgdW5kZXIgZWFybGllciBKVk1zLiBBbGwKICAgICAgY29tcG9uZW50cyBzaG91bGQgYmUgY29tcGlsZWQgdXNpbmcgYSBKYXZhMiBjb21waWxlciwgYXMgZXZlbiBjb21wb25lbnRzCiAgICAgIHRoYXQgcnVuIHVuZGVyIGVhcmxpZXIgSlZNcyBjYW4gcmVxdWlyZSBsYW5ndWFnZSBmZWF0dXJlcyB0aGF0IGFyZSBvbmx5CiAgICAgIHByZXNlbnQgaW4gSmF2YTIuIEN1cnJlbnRseSAxLjEueCBhbmQgMS4yLnggSlZNcyBhcmUgdW5zdXBwb3J0ZWQgYW5kIHVudGVzdGVkLCBhbmQgeW91IHVzZQogICAgICB0aGUgY29tcG9uZW50cyBvbiB0aGVzZSBKVk1zIGF0IHlvdXIgb3duIHJpc2suPC9QPgogICAgICA8cD4KICAgICAgVGhlIHJlZmVyZW5jZSBwbGF0Zm9ybXMgd2hpY2ggd2Ugc3VwcG9ydCBhbmQgdGVzdCBJQ1U0SiBvbiBhcmU6PHVsPgo8bGk+IFdpbjIwMDAsIElCTSBKREsgMS4zLjE8L2xpPgo8bGk+IFNvbGFyaXMgMi43LCBTdW4gSkRLIDEuMzwvbGk+CjxsaT4gQUlYIDUuMSwgSUJNIEpESyAxLjMuMTwvbGk+CjwvdWw+CjwvcD4KPHA+UGxlYXNlIHVzZSB0aGUgbW9zdCByZWNlbnQgdXBkYXRlcyBvZiB0aGUgc3VwcG9ydGVkIEpESyB2ZXJzaW9ucy48L3A+Cgo8cD5BZGRpdGlvbmFsbHksIHdlIGhhdmUgYnVpbHQgYW5kIHRlc3RlZCBJQ1U0SiBvbiB0aGUgZm9sbG93aW5nIDxiPnVuc3VwcG9ydGVkPC9iPiBwbGF0Zm9ybXM6Cjx1bD4KPGxpPiBXaW45OCwgV2luTlQsIFdpblhQIC8gSUJNIEpESyAxLjMuMSwgMS40LjEsIFN1biBKREsgMS4zLjEsIDEuNCwgMS40LjE8L2xpPgo8bGk+IFdpbjIwMDAgLyBJQk0gSkRLIDEuMy4xLCAxLjQuMSwgU3VuIEpESyAxLjMuMSwgMS40LCAxLjQuMTwvbGk+CjxsaT4gU29sYXJpcyAyLjYgLCBTb2xhcmlzIDIuOCAvIFN1biBKREsgMS4zLjEsIDEuNCwgMS40LjE8L2xpPgo8bGk+IFNvbGFyaXMgMi43IC8gU3VuIEpESyAxLjMuMSwgMS40LCAxLjQuMTwvbGk+CjxsaT4gQUlYIDUuMSwgSUJNIEpESyAxLjMuMSwgMS40LjE8L2xpPgo8L3VsPgoKPGgzPjxhIE5BTUU9Im9idGFpbmluZyI+PC9hPjx1PkhvdyB0byBEb3dubG9hZCBJQ1U0SjwvdT48L2gzPgoKPHA+VGhlcmUgYXJlIHR3byB3YXlzIHRvIGRvd25sb2FkIHRoZSBJQ1U0SiByZWxlYXNlcy4KCjx1bCB0eXBlPSJkaXNjIj4KICA8bGk+PGI+T2ZmaWNpYWwgUmVsZWFzZSBTbmFwc2hvdDo8L2I+PGJyPgoKICAgIElmIHlvdSB3YW50IHRvIHVzZSBJQ1U0SiAoYXMgb3Bwb3NlZCB0byBkZXZlbG9waW5nIGl0KSwgeW91ciBiZXN0CiAgICBiZXQgaXMgdG8gZG93bmxvYWQgYW4gb2ZmaWNpYWwsIHBhY2thZ2VkIHZlcnNpb24gb2YgdGhlIElDVTRKCiAgICBzb3VyY2UgY29kZS4mbmJzcDsgVGhlc2UgdmVyc2lvbnMgYXJlIHRlc3RlZCBtb3JlIHRob3JvdWdobHkgdGhhbgogICAgZGF5LXRvLWRheSBkZXZlbG9wbWVudCBidWlsZHMsIGFuZCB0aGV5IGFyZSBwYWNrYWdlZCBpbiB6aXAgZmlsZXMKICAgIGZvciBjb252ZW5pZW50IGRvd25sb2FkLiZuYnNwOyBUaGVzZSBwYWNrYWdlZCBmaWxlcyBjYW4gYmUgZm91bmQKICAgIGF0IDxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb3dubG9hZC9pbmRleC5odG1sIj5odHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovZG93bmxvYWQvaW5kZXguaHRtbDwvYT4uJm5ic3A7IElmIGEgcGFja2FnZWQgc25hcHNob3QgaXMgbmFtZWQgPGI+SUNVNEpYWFhYWFguemlwPC9iPiwgd2hlcmUgWFhYWFhYIGlzCiAgICB0aGUgcmVsZWFzZSB2ZXJzaW9uIG51bWJlci4mbmJzcDsgUGxlYXNlIHVuemlwIHRoaXMgZmlsZS4mbmJzcDsgSXQKICAgIHdpbGwgcmVjb25zdHJ1Y3QgdGhlIHNvdXJjZSBkaXJlY3RvcnkuIDwvbGk+CjwvdWw+Cgo8dWwgdHlwZT0iZGlzYyI+CiAgPGxpPjxiPkNWUyBTb3VyY2UgUmVwb3NpdG9yeTo8L2I+PGJyPgogICAgSWYgeW91IGFyZSBpbnRlcmVzdGVkIGluIGRldmVsb3BpbmcgZmVhdHVyZXMsIHBhdGNoZXMsIG9yIGJ1ZyBmaXhlcyBmb3IgSUNVNEosIHlvdSBzaG91bGQKICAgIHByb2JhYmx5IGJlIHdvcmtpbmcgd2l0aCB0aGUgbGF0ZXN0IHZlcnNpb24gb2YgdGhlIElDVTRKIHNvdXJjZSBjb2RlLiBZb3Ugd2lsbCBuZWVkIHRvCiAgICBjaGVjayB0aGUgY29kZSBvdXQgb2Ygb3VyIENWUyByZXBvc2l0b3J5IHRvIGVuc3VyZSB0aGF0IHlvdSBoYXZlIHRoZSBtb3N0IHJlY2VudCB2ZXJzaW9uCiAgICBvZiBhbGwgb2YgdGhlIGZpbGVzLiBUaGVyZSBhcmUgc2V2ZXJhbCB3YXlzIHRvIGRvIHRoaXM6IDxicj4KICAgIDx1bCB0eXBlPSJjaXJjbGUiPgogICAgICA8bGk+V2ViQ1ZTOjxicj4KICAgICAgICBJZiB5b3Ugd2FudCB0byBicm93c2UgdGhlIGNvZGUgYW5kIG9ubHkgbWFrZSBvY2Nhc2lvbmFsIGRvd25sb2FkcywgeW91IG1heSB3YW50IHRvIHVzZQogICAgICAgIFdlYkNWUy4gSXQgcHJvdmlkZXMgYSBjb252ZW5pZW50LCB3ZWItYmFzZWQgaW50ZXJmYWNlIGZvciBicm93c2luZyBhbmQgZG93bmxvYWRpbmcgdGhlCiAgICAgICAgbGF0ZXN0IHZlcnNpb24gb2YgdGhlIElDVTRKIHNvdXJjZSBjb2RlIGFuZCBkb2N1bWVudGF0aW9uLiBZb3UgY2FuIGFsc28gdmlldyBlYWNoIGZpbGUncwogICAgICAgIHJldmlzaW9uIGhpc3RvcnksIGRpc3BsYXkgdGhlIGRpZmZlcmVuY2VzIGJldHdlZW4gaW5kaXZpZHVhbCByZXZpc2lvbnMsIGRldGVybWluZSB3aGljaAogICAgICAgIHJldmlzaW9ucyB3ZXJlIHBhcnQgb2Ygd2hpY2ggb2ZmaWNpYWwgcmVsZWFzZSwgYW5kIHNvIG9uLiA8YnI+CiAgICAgIDwvbGk+CiAgICAgIDxsaT5XaW5DVlM6PGJyPgogICAgICAgIElmIHlvdSB3aWxsIGJlIGRvaW5nIHNlcmlvdXMgd29yayBvbiBJQ1U0SiwgeW91IHNob3VsZCBwcm9iYWJseSBpbnN0YWxsIGEgQ1ZTIGNsaWVudCBvbgogICAgICAgIHlvdXIgb3duIG1hY2hpbmUgc28gdGhhdCB5b3UgY2FuIGRvIGJhdGNoIG9wZXJhdGlvbnMgd2l0aG91dCBnb2luZyB0aHJvdWdoIHRoZSBXZWJDVlMKICAgICAgICBpbnRlcmZhY2UuIE9uIFdpbmRvd3MsIHdlIHN1Z2dlc3QgdGhlIFdpbkNWUyBjbGllbnQuIFRvIGRvd25sb2FkIElDVTRKIHZpYSBXaW5DVlM6IDxvbD4KICAgICAgICAgIDxsaT5JbnN0YWxsIHRoZSBXaW5DVlMgY2xpZW50LCB3aGljaCB5b3UgY2FuIGRvd25sb2FkIGZyb20gdGhlIDxhCiAgICAgICAgICAgIGhyZWY9Imh0dHA6Ly93d3cud2luY3ZzLm9yZyI+aHR0cDovL3d3dy53aW5jdnMub3JnPC9hPi48L2xpPgogICAgICAgICAgPGxpPlNlbGVjdCA8c3Ryb25nPlByZWZlcmVuY2VzPC9zdHJvbmc+IGZyb20gdGhlIDxzdHJvbmc+QWRtaW48L3N0cm9uZz4gbWVudS48b2wgdHlwZT0iYSI+CiAgICAgICAgICAgICAgPGxpPk9uIHRoZSA8c3Ryb25nPkdlbmVyYWw8L3N0cm9uZz4gdGFiIHBhbmVsOiBTZXQgeW91ciA8c3Ryb25nPkNWU1JPT1Q8L3N0cm9uZz4gdG8gJnF1b3Q7PHN0cm9uZz46cHNlcnZlcjphbm9uY3ZzQG9zcy5zb2Z0d2FyZS5pYm0uY29tOi91c3IvY3ZzL2ljdTRqPC9zdHJvbmc+JnF1b3Q7Ljxicj4KICAgICAgICAgICAgICAgIExlYXZlIG90aGVyIG9wdGlvbnMgb24gdGhpcyBwYWdlIGF0IHRoZWlyIGRlZmF1bHQuPC9saT4KICAgICAgICAgICAgICA8bGk+T24gdGhlIDxzdHJvbmc+UG9ydHM8L3N0cm9uZz4gdGFiIHBhbmVsOiBDaGVjayB0aGUgPHN0cm9uZz5wc2VydmVyPC9zdHJvbmc+IGNoZWNrYm94IGFuZAogICAgICAgICAgICAgICAgZW50ZXIgcG9ydCA8c3Ryb25nPjI0MDE8L3N0cm9uZz4uPC9saT4KICAgICAgICAgICAgPC9vbD4KICAgICAgICAgIDwvbGk+CiAgICAgICAgICA8bGk+Q2xpY2sgb24gdGhlIExvZ2luIG1lbnUgYnV0dG9uICg8c3Ryb25nPkFkbWluPC9zdHJvbmc+IG1lbnUpLiBFbnRlciBpbiAgJnF1b3Q7PHN0cm9uZz5hbm9uY3ZzPC9zdHJvbmc+JnF1b3Q7IHdoZW4gcmVxdWVzdGVkLjwvbGk+CiAgICAgICAgICA8bGk+VG8gZXh0cmFjdCB0aGUgbW9zdCByZWNlbnQgdmVyc2lvbiBvZiBJQ1U0Siwgc2VsZWN0IDxzdHJvbmc+Q2hlY2tvdXQgbW9kdWxlPC9zdHJvbmc+CiAgICAgICAgICAgIGZyb20gdGhlIDxzdHJvbmc+Q3JlYXRlPC9zdHJvbmc+IG1lbnUuIFNwZWNpZnkgJnF1b3Q7PHN0cm9uZz5pY3U0ajwvc3Ryb25nPiZxdW90OyBmb3IgdGhlCiAgICAgICAgICAgIG1vZHVsZSBuYW1lLiBUaGlzIHdpbGwgY3JlYXRlIGEgbmV3IGNvcHkgb2YgdGhlIHdvcmtzcGFjZSBvbiB5b3VyIGxvY2FsIGhhcmQgZHJpdmUuPC9saT4KICAgICAgICAgIDxsaT5JbiB0aGUgZnV0dXJlLCB5b3UgY2FuIGRvd25sb2FkIHVwZGF0ZWQgZmlsZXMgZnJvbSB0aGUgcmVwb3NpdG9yeSB0byB5b3VyIGhhcmQgZHJpdmUKICAgICAgICAgICAgdXNpbmcgdGhlIDxzdHJvbmc+VXBkYXRlIHNlbGVjdGlvbjwvc3Ryb25nPiBpdGVtIGluIHRoZSA8c3Ryb25nPk1vZGlmeTwvc3Ryb25nPiBtZW51Ljxicj4KICAgICAgICAgIDwvbGk+CiAgICAgICAgPC9vbD4KICAgICAgPC9saT4KICAgICAgPGxpPkNWUyBjb21tYW5kIGxpbmU6PGJyPgogICAgICAgIFlvdSBjYW4gYWxzbyBjaGVjayBvdXQgdGhlIHJlcG9zaXRvcnkgYW5vbnltb3VzbHkgb24gVU5JWCB1c2luZyB0aGUgZm9sbG93aW5nIGNvbW1hbmRzLAogICAgICAgIGFmdGVyIGZpcnN0IHNldHRpbmcgeW91ciBDVlNST09UIHRvIHBvaW50IHRvIHRoZSBJQ1U0SiByZXBvc2l0b3J5OiA8cHJlPjxjb2RlPmV4cG9ydCBDVlNST09UPTpwc2VydmVyOmFub25jdnNAb3NzLnNvZnR3YXJlLmlibS5jb206L3Vzci9jdnMvaWN1NGoKY3ZzIGxvZ2luIENWUyBwYXNzd29yZDogYW5vbmN2cwpjdnMgY2hlY2tvdXQgaWN1NGoKY3ZzIGxvZ291dDwvY29kZT48L3ByZT4KICAgICAgPC9saT4KICAgIDwvdWw+CiAgPC9saT4KPC91bD4KCjxwPkZvciBtb3JlIGRldGFpbHMgb24gaG93IHRvIGRvd25sb2FkIElDVTRKIGRpcmVjdGx5IGZyb20gdGhlIHdlYiBzaXRlLCBwbGVhc2UgYWxzbyBzZWUgPGEKaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2ljdTRqL2Rvd25sb2FkL2luZGV4Lmh0bWwiPmh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb3dubG9hZC9pbmRleC5odG1sPC9hPgo8L3A+Cgo8aDM+PGEgTkFNRT0iV2hhdENvbnRhaW4iPjwvYT48dT5UaGUgU3RydWN0dXJlIGFuZCBDb250ZW50cyBvZiBJQ1U0SjwvdT48L2gzPgoKPHA+QmVsb3csIDxiPiRSb290PC9iPiBpcyB0aGUgcGxhY2VtZW50IG9mIHRoZSBpY3UgZGlyZWN0b3J5IGluIHlvdXIgZmlsZSBzeXN0ZW0sIGxpa2UKJnF1b3Q7ZHJpdmU6XC4uLlxpY3U0aiZxdW90OyBpbiB5b3VyIGVudmlyb25tZW50LiAmcXVvdDtkcml2ZTpcLi4uJnF1b3Q7IHN0YW5kcyBmb3IgYW55CmRyaXZlIGFuZCBhbnkgZGlyZWN0b3J5IG9uIHRoYXQgZHJpdmUgdGhhdCB5b3UgY2hvc2UgdG8gaW5zdGFsbCBpY3U0aiBpbnRvLiA8L3A+Cgo8cD48Yj5JbmZvcm1hdGlvbiBhbmQgYnVpbGQgZmlsZXM6PC9iPjwvcD4KCjx0YWJsZSBCT1JERVI9IjEiIENFTExQQURESU5HPSIzIj4KICA8dHI+CiAgICA8dGQ+cmVhZG1lLmh0bWw8YnI+CiAgICAgICAgKHRoaXMgZmlsZSk8L3RkPgogICAgPHRkPkEgZGVzY3JpcHRpb24gb2YgSUNVNEogKEludGVybmF0aW9uYWwgQ29tcG9uZW50cyBmb3IgVW5pY29kZSBmb3IgSmF2YSk8L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPnJlbGVhc2Vub3Rlcy5odG1sCiAgICA8dGQ+QSBkZXNjcmlwdGlvbiBvZiBmZWF0dXJlcyBhbmQgY2hhbmdlcyBpbiB0aGlzIGFuZCBwcmlvciByZWxlYXNlcyBvZiBJQ1U0SjwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+bGljZW5zZS5odG1sPC90ZD4KICAgIDx0ZD5UaGUgWCBsaWNlbnNlLCB1c2VkIGJ5IElDVTRKPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0ZD5idWlsZC5iYXQ8L3RkPgogICAgPHRkPkEgY29udmVuaWVuY2UgYmF0IGZpbGUgZm9yIGJ1aWxkaW5nIElDVTRKIHdpdGggQW50IG9uIFdpbmRvd3M8L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPmJ1aWxkLnNoPC90ZD4KICAgIDx0ZD5BIGNvbnZlbmllbmNlIHNoIGZpbGUgZm9yIGJ1aWxkaW5nIElDVTRKIHdpdGggQW50IG9uIFVuaXg8L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPmJ1aWxkLnhtbDwvdGQ+CiAgICA8dGQ+QW50IGJ1aWxkIGZpbGUuIFNlZSA8YSBocmVmPSIjSG93VG9JbnN0YWxsSmF2YWMiPkhvdyB0byBJbnN0YWxsIGFuZCBCdWlsZDwvYT4gZm9yIG1vcmUgaW5mb3JtYXRpb248L3RkPgogIDwvdHI+CjwvdGFibGU+Cgo8cD48Yj5UaGUgc291cmNlIGRpcmVjdG9yaWVzIG1pcnJvciB0aGUgcGFja2FnZSBzdHJ1Y3R1cmUgb2YgdGhlIGNvZGUuPC9iPjxicj48Zm9udCBjb2xvcj0icmVkIj5Db3JlPC9mb250PiBwYWNrYWdlcyBiZWNvbWUgcGFydCBvZiB0aGUgSUNVNEogamFyIGZpbGUuPGJyPjxmb250IGNvbG9yPSJyZWQiPkFQSTwvZm9udD4gcGFja2FnZXMgY29udGFpbiBjbGFzc2VzIHdpdGggc3VwcG9ydGVkIEFQSS4gPGJyPjxmb250IGNvbG9yPSJyZWQiPlJpY2hUZXh0PC9mb250PiBjbGFzc2VzIGFyZSBDb3JlIGFuZCBBUEksIGJ1dCBjYW4gYmUgcmVtb3ZlZCBmcm9tIGljdTRqLmphciwgYW5kIGNhbiBiZSBidWlsdCBpbnRvIHRoZWlyIG93biBqYXIuPC9wPgoKPHRhYmxlIEJPUkRFUj0iMSIgQ0VMTFBBRERJTkc9IjMiIFdJRFRIPSI2MjMiPgogIDx0cj4KICAgIDx0ZD4kUm9vdC9zcmMvY29tL2libS9pY3UvZGV2PGJyPjxmb250IGNvbG9yPSJyZWQiPk5vbi1Db3JlLCBOb24tQVBJPC9mb250PjwvdGQ+CiAgICA8dGQ+UGFja2FnZXMgdXNlZCBmb3IgaW50ZXJuYWwgZGV2ZWxvcG1lbnQ6CiAgICA8dWw+CiAgICA8bGk+RGF0YTogZGF0YSB1c2VkIGJ5IHRlc3RzIGFuZCBpbiBidWlsZGluZyBJQ1U8L2xpPgogICAgPGxpPkRlbW9zOiBDYWxlbmRhciwgSG9saWRheSwgQnJlYWsgSXRlcmF0b3IsIFJ1bGUtYmFzZWQgTnVtYmVyIEZvcm1hdCwgVHJhbnNmb3JtYXRpb25zPGJyPihTZWUgPGEgaHJlZj0iI3RyeWluZ291dCI+YmVsb3c8L2E+IGZvciBtb3JlIGluZm9ybWF0aW9uIGFib3V0IHRoZSBkZW1vcy4pPC9saT4KICAgIDxsaT5UZXN0czogQVBJIGFuZCBjb3ZlcmFnZSB0ZXN0cyBvZiBhbGwgZnVuY3Rpb25hbGl0eS48YnI+Rm9yIGluZm9ybWF0aW9uIGFib3V0IHJ1bm5pbmcgdGhlIHRlc3RzLCBzZWUgJFJvb3Qvc3JjL2NvbS9pYm0vaWN1L2Rldi90ZXN0L1Rlc3RBbGwuamF2YS48L2xpPgogICAgPGxpPlRvb2xzOiB0b29scyB1c2VkIHRvIGJ1aWxkIGRhdGEgdGFibGVzLCBldGMuPC9saT48L3VsPjwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+JFJvb3Qvc3JjL2NvbS9pYm0vaWN1L2ltcGw8YnI+PGZvbnQgY29sb3I9InJlZCI+Q29yZSwgTm9uLUFQSTwvZm9udD48L3RkPgogICAgPHRkPlRoZXNlIGFyZSB1dGlsaXR5IGNsYXNzZXMgdXNlZCBmcm9tIGRpZmZlcmVudCBJQ1U0SiBjb3JlIHBhY2thZ2VzLjwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+JFJvb3Qvc3JjL2NvbS9pYm0vaWN1L2xhbmc8YnI+PGZvbnQgY29sb3I9InJlZCI+Q29yZSwgQVBJPC9mb250PjwvdGQ+CiAgICA8dGQ+Q2hhcmFjdGVyIHByb3BlcnRpZXMgcGFja2FnZS48L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPiRSb290L3NyYy9jb20vaWJtL2ljdS9tYXRoPGJyPjxmb250IGNvbG9yPSJyZWQiPkNvcmUsIEFQSTwvZm9udD48L3RkPgogICAgPHRkPkFkZGl0aW9uYWwgbWF0aCBjbGFzc2VzLjwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+JFJvb3Qvc3JjL2NvbS9pYm0vaWN1L3RleHQ8YnI+PGZvbnQgY29sb3I9InJlZCI+Q29yZSwgQVBJPC9mb250PjwvdGQ+CiAgICA8dGQ+QWRkaXRpb25hbCB0ZXh0IGNsYXNzZXMuICBUaGVzZSBhZGQgdG8sIGFuZCBpbiBzb21lIGNhc2VzIHJlcGxhY2UsIHJlbGF0ZWQgY29yZSBKYXZhIGNsYXNzZXM6CiAgICAgIDx1bD4KICAgICAgPGxpPkFyYWJpYyBzaGFwaW5nCiAgICAgIDxsaT5CcmVhayBpdGVyYXRpb24KICAgICAgPGxpPkRhdGUgZm9ybWF0dGluZwogICAgICA8bGk+TnVtYmVyIGZvcm1hdHRpbmcKICAgICAgPGxpPlRyYW5zbGl0ZXJhdGlvbgogICAgICA8bGk+Tm9ybWFsaXphdGlvbgogICAgICA8bGk+U3RyaW5nIG1hbmlwdWxhdGlvbgogICAgICA8bGk+Q29sbGF0aW9uCiAgICAgIDxsaT5TdHJpbmcgc2VhcmNoCiAgICAgIDxsaT5Vbmljb2RlIGNvbXByZXNzaW9uCiAgICAgIDxsaT5Vbmljb2RlIHNldHMKICAgIDwvdWw+CiAgICA8L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPiRSb290L3NyYy9jb20vaWJtL2ljdS91dGlsPGJyPjxmb250IGNvbG9yPSJyZWQiPkNvcmUsIEFQSTwvZm9udD48L3RkPgogICAgPHRkPkFkZGl0aW9uYWwgdXRpbGl0eSBjbGFzc2VzOgogICAgPHVsPgogICAgPGxpPkNhbGVuZGFycyAtIEdyZWdvcmlhbiwgQnVkZGhpc3QsIEhlYnJldywgSXNsYW1pYywgSmFwYW5lc2UKICAgIDxsaT5Ib2xpZGF5PC9saT4KICAgIDxsaT5UaW1lWm9uZTwvbGk+CiAgICA8bGk+VmVyc2lvbkluZm88L2xpPgogICAgPGxpPkl0ZXJhdGlvbjwvbGk+CiAgICA8L3VsPgogICAgPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0ZD4kUm9vdC9zcmMvY29tL2libS9yaWNodGV4dDxicj48Zm9udCBjb2xvcj0icmVkIj5SaWNoVGV4dDwvZm9udD48L3RkPgogICAgPHRkPlN0eWxlZCB0ZXh0IGVkaXRpbmcKICAgIHBhY2thZ2UuIFRoaXMgaW5jbHVkZXMgZGVtb3MsIHRlc3RzLCBhbmQgR1VJcyBmb3IgZWRpdGluZyBhbmQKICAgIGRpc3BsYXlpbmcgc3R5bGVkIHRleHQuICBUaGUgcmljaHRleHQgcGFja2FnZSBwcm92aWRlcyBhCiAgICBzY3JvbGxhYmxlIGRpc3BsYXksIHR5cGluZywgYXJyb3cta2V5IHN1cHBvcnQsIHRhYnMsIGFsaWdubWVudCBhbmQKICAgIGp1c3RpZmljYXRpb24sIHdvcmQtIGFuZCBzZW50ZW5jZS1zZWxlY3Rpb24gKGJ5IGRvdWJsZS1jbGlja2luZwogICAgYW5kIHRyaXBsZS1jbGlja2luZywgcmVzcGVjdGl2ZWx5KSwgdGV4dCBzdHlsZXMsIGNsaXBib2FyZAogICAgb3BlcmF0aW9ucyAoY3V0LCBjb3B5IGFuZCBwYXN0ZSkgYW5kIGEgbG9nIG9mIGNoYW5nZXMgZm9yCiAgICB1bmRvLXJlZG8uICBSaWNodGV4dCB1c2VzIEphdmEncyBUZXh0TGF5b3V0IGFuZCBjb21wbGV4CiAgICB0ZXh0IHN1cHBvcnQgKHByb3ZpZGVkIHRvIFN1biBieSB0aGUgSUNVNEogdGVhbSkuPC90ZD4KICA8L3RyPgo8L3RhYmxlPgoKPHA+PGI+QnVpbGRpbmcgSUNVNEogY3JlYXRlcyBhbmQgcG9wdWxhdGVzIHRoZSBmb2xsb3dpbmcgZGlyZWN0b3JpZXM6PC9iPiA8L3A+Cgo8dGFibGUgQk9SREVSPSIxIiBDRUxMUEFERElORz0iMyI+CiAgPHRyPgogICAgPHRkPiRSb290L2NsYXNzZXM8L3RkPgogICAgPHRkPmNvbnRhaW5zIGFsbCBjbGFzcyBmaWxlczwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+JFJvb3QvZG9jPC90ZD4KICAgIDx0ZD5jb250YWlucyBKYXZhRG9jIGZvciBhbGwgcGFja2FnZXM8L3RkPgogIDwvdHI+CjwvdGFibGU+Cgo8cD48Yj5EYXRhIG9yZ2FuaXphdGlvbjo8L2I+IDwvcD4KCjxwPklDVTRKIGRhdGEgaXMgc3RvcmVkIGluIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOgoKPHRhYmxlIEJPUkRFUj0iMSIgQ0VMTFBBRERJTkc9IjMiIFdJRFRIPSI2MjMiPgogIDx0cj4KICAgIDx0ZD48Y29kZT5jb20uaWJtLmljdS5pbXBsLmRhdGE8L2NvZGU+PC90ZD4KICAgIDx0ZD5Ib2xkcyBkYXRhIHVzZWQgYnkgdGhlIElDVTRKIGNvcmUgcGFja2FnZXMgKDxjb2RlPmNvbS5pYm0uaWN1Lmxhbmc8L2NvZGU+LCA8Y29kZT5jb20uaWJtLmljdS50ZXh0PC9jb2RlPiwgPGNvZGU+Y29tLmlibS5pY3UudXRpbDwvY29kZT4sIDxjb2RlPmNvbS5pYm0uaWN1Lm1hdGg8L2NvZGU+IGFuZCA8Y29kZT5jb20uaWJtLmljdS50ZXh0PC9jb2RlPikuIEluIHBhcnRpY3VsYXIsIGFsbCByZXNvdXJjZSBpbmZvcm1hdGlvbiBpcyBzdG9yZWQgaGVyZS48L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPjxjb2RlPmNvbS5pYm0uaWN1LmRldi5kYXRhPC9jb2RlPjwvdGQ+CiAgICA8dGQ+SG9sZHMgZGF0YSB0aGF0IGlzIG5vdCBwYXJ0IG9mIElDVTRKIGNvcmUsIGJ1dCByYXRoZXIgcGFydCBvZiBhIHRlc3QsIHNhbXBsZSwgb3IgZGVtby48L3RkPgogIDwvdHI+CjwvdGFibGU+Cgo8aDM+PHU+PGEgbmFtZT0iQVBJIj48L2E+V2hlcmUgdG8gZ2V0IERvY3VtZW50YXRpb248L3U+PC9oMz4KCjxwPlRoZSA8YSBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1L3VzZXJndWlkZS8iPklDVSB1c2VyJ3MgZ3VpZGU8L2E+IGNvbnRhaW5zIGxvdHMgb2YgZ2VuZXJhbCBpbmZvcm1hdGlvbiBhYm91dCBJQ1UsIGluIGl0cyBDLCBDKyssIGFuZCBKYXZhIGluY2FybmF0aW9ucy48L3A+Cgo8cD5UaGUgY29tcGxldGUgQVBJIGRvY3VtZW50YXRpb24gZm9yIElDVTRKIChqYXZhZG9jKSBpcyBhdmFpbGFibGUgb24gdGhlIElDVTRKIHdlYiBzaXRlLCBhbmQgY2FuIGJlIGJ1aWx0IGZyb20gdGhlIHNvdXJjZXM6Cgo8dWw+CiAgPGxpPjxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb2MvaW5kZXguaHRtbCI+SW5kZXggdG8gYWxsIElDVTRKIEFQSTwvYT48L2xpPgogIDxsaT5JbnRlcm5hdGlvbmFsIENhbGVuZGFycyAmIzE1MDsgPGEgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2ljdTRqL2RvYy9jb20vaWJtL2ljdS91dGlsL0lzbGFtaWNDYWxlbmRhci5odG1sIj5Jc2xhbWljPC9hPiwKICAgIDxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb2MvY29tL2libS9pY3UvdXRpbC9CdWRkaGlzdENhbGVuZGFyLmh0bWwiPkJ1ZGRoaXN0PC9hPiwgPGEKICAgIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb2MvY29tL2libS9pY3UvdXRpbC9IZWJyZXdDYWxlbmRhci5odG1sIj5IZWJyZXc8L2E+LCA8YQogICAgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2ljdTRqL2RvYy9jb20vaWJtL2ljdS91dGlsL0phcGFuZXNlQ2FsZW5kYXIuaHRtbCI+SmFwYW5lc2U8L2E+LjwvbGk+CiAgPGxpPjxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb2MvY29tL2libS9pY3UvdGV4dC9Ob3JtYWxpemVyLmh0bWwiPlVuaWNvZGUgTm9ybWFsaXphdGlvbjwvYT4gJiMxNTA7CiAgICBDYW5vbmljYWwgdGV4dCByZXByZXNlbnRhdGlvbiBmb3IgVzNDLjwvbGk+CiAgPGxpPjxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb2MvY29tL2libS9pY3UvdGV4dC9OdW1iZXJGb3JtYXQuaHRtbCI+TnVtYmVyIEZvcm1hdCBFbmhhbmNlbWVudHM8L2E+ICYjMTUwOwogICAgU2NpZW50aWZpYyBOb3RhdGlvbiwgU3BlbGxlZCBvdXQuPC9saT4KICA8bGk+PGEgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2ljdTRqL2RvYy9jb20vaWJtL2ljdS90ZXh0L0JyZWFrSXRlcmF0b3IuaHRtbCI+RW5oYW5jZWQgd29yZC1icmVhayBkZXRlY3Rpb248L2E+CiAgICAmIzE1MDsgUnVsZS1iYXNlZCwgc3VwcG9ydHMgVGhhaTwvbGk+CjxsaT48YSBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovZG9jL2NvbS9pYm0vaWN1L3RleHQvVHJhbnNsaXRlcmF0b3IuaHRtbCI+VHJhbnNsaXRlcmF0aW9uPC9hPiAmIzE1MDsgQSBnZW5lcmFsIGZyYW1ld29yayBmb3Igb252ZXJ0aW5nIHRleHQgZnJvbSBvbmUgZm9ybWF0IHRvIGFub3RoZXIsIGUuZy4gQ3lyaWxsaWMgdG8gTGF0aW4sIG9yIEhleCB0byBVbmljb2RlLgogIDxsaT5Vbmljb2RlIFRleHQgPGEgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2ljdTRqL2RvYy9jb20vaWJtL2ljdS90ZXh0L1VuaWNvZGVDb21wcmVzc29yLmh0bWwiPkNvbXByZXNzaW9uPC9hPiAmYW1wOwogICAgPGEgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2ljdTRqL2RvYy9jb20vaWJtL2ljdS90ZXh0L1VuaWNvZGVEZWNvbXByZXNzb3IuaHRtbCI+RGVjb21wcmVzc2lvbjwvYT4gJiMxNTA7IDI6MQogICAgY29tcHJlc3Npb24gb24gRW5nbGlzaCBVbmljb2RlIHRleHQuPC9saT4KICA8bGk+Q29sbGF0aW9uIC0gPGEgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2ljdTRqL2RvYy9jb20vaWJtL2ljdS90ZXh0L1J1bGVCYXNlZENvbGxhdG9yLmh0bWwiPlJ1bGUtYmFzZWQgc29ydGluZzwvYT4sIDxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb2MvY29tL2libS9pY3UvdGV4dC9TdHJpbmdTZWFyY2guaHRtbCI+RWZmaWNpZW50IG11bHRpLWxpbmd1YWwgc2VhcmNoaW5nPC9hPiA8L2xpPgo8L3VsPgoKPGgzPjxhIE5BTUU9Ikhvd1RvSW5zdGFsbEphdmFjIj48L2E+PHU+SG93IHRvIEluc3RhbGwgYW5kIEJ1aWxkPC91PjwvaDM+Cgo8cD5UbyBpbnN0YWxsIElDVTRKLCBzaW1wbHkgcGxhY2UgdGhlIHByZWJ1aWx0IGphciBmaWxlIDxzdHJvbmc+aWN1NGouamFyPC9zdHJvbmc+IG9uIHlvdXIKSmF2YSBDTEFTU1BBVEguJm5ic3A7IE5vIG90aGVyIGZpbGVzIGFyZSBuZWVkZWQuPC9wPgoKPHA+VG8gYnVpbGQgSUNVNEosIHlvdSB3aWxsIG5lZWQgYSBKYXZhMiBKREsgYW5kIHRoZSBBbnQgYnVpbGQgc3lzdGVtLgpXZSBzdHJvbmdseSByZWNvbW1lbmQgdXNpbmcgdGhlIEFudCBidWlsZCBzeXN0ZW0gdG8gYnVpbGQgSUNVNEo6PC9wPgoKPHVsPgogIDxsaT5JdCdzIHJlY29tbWVuZGVkIHRvIGluc3RhbGwgYm90aCB0aGUgSkRLIGFuZCBBbnQgc29tZXdoZXJlIDxlbT5vdXRzaWRlPC9lbT4gdGhlIElDVTRKCiAgICBkaXJlY3RvcnkuIEZvciBleGFtcGxlLCBvbiBMaW51eCB5b3UgbWlnaHQgaW5zdGFsbCB0aGVzZQogICAgaW4gL3Vzci9sb2NhbC48L2xpPgogIDxsaT5JbnN0YWxsIGEgcmVjZW50IEpESywgdmVyc2lvbiAxLjMueCBvciAxLjQueCB3aWxsIHdvcmsuPC9saT4KICA8bGk+PHA+TmV4dCBpbnN0YWxsIHRoZSA8YSBocmVmPSJodHRwOi8vYW50LmFwYWNoZS5vcmcvIj48c3Ryb25nPkFudDwvc3Ryb25nPjwvYT4gYnVpbGQKICAgIHN5c3RlbS4gQW50IGlzIGEgcG9ydGFibGUsIEphdmEtYmFzZWQgYnVpbGQgc3lzdGVtIHNpbWlsYXIgdG8gbWFrZS4gSUNVNEogdXNlcyBBbnQKICAgIGJlY2F1c2UgaXQgaW50cm9kdWNlcyBubyBvdGhlciBkZXBlbmRlbmNpZXMsIGl0J3MgcG9ydGFibGUsIGFuZCBpdCdzIGVhc2llciB0byBtYW5hZ2UgdGhhbgogICAgYSBjb2xsZWN0aW9uIG9mIG1ha2VmaWxlcy4gV2UgY3VycmVudGx5IGJ1aWxkIElDVTRKIHVzaW5nIGEgc2luZ2xlIG1ha2VmaWxlIG9uIGJvdGgKICAgIFdpbmRvd3MgOXggYW5kIExpbnV4IHVzaW5nIEFudC4gIFRoZSBidWlsZCBzeXN0ZW0gcmVxdWlyZXMgQW50IDEuNSBvciBsYXRlci48L3A+CiAgICA8cD5JbnN0YWxsaW5nIEFudCBpcyBzdHJhaWdodGZvcndhcmQuIERvd25sb2FkIGl0IChzZWUgPGEKICAgIGhyZWY9Imh0dHA6Ly9hbnQuYXBhY2hlLm9yZy9iaW5kb3dubG9hZC5jZ2kiPmh0dHA6Ly9hbnQuYXBhY2hlLm9yZy9iaW5kb3dubG9hZC5jZ2k8L2E+KSwKICAgIGV4dHJhY3QgaXQgb250byB5b3VyIHN5c3RlbSwgc2V0IHNvbWUgZW52aXJvbm1lbnQgdmFyaWFibGVzLCBhbmQgYWRkIGl0cyBiaW4gZGlyZWN0b3J5IHRvCiAgICB5b3VyIHBhdGguIEZvciBleGFtcGxlOgo8cHJlPiAgICBzZXQgSkFWQV9IT01FPUM6XGpkazEuMy4xCiAgICBzZXQgQU5UX0hPTUU9QzpcYW50CiAgICBzZXQgUEFUSD0lUEFUSCU7JUFOVF9IT01FJVxiaW48L3ByZT48L3A+CiAgICA8cD5TZWUgdGhlIGN1cnJlbnQgQW50IGRvY3VtZW50YXRpb24gZm9yIGRldGFpbHMuPC9wPgogIDwvbGk+CjwvdWw+Cgo8cD5PbmNlIHRoZSBKREsgYW5kIEFudCBhcmUgaW5zdGFsbGVkLCBidWlsZGluZyBpcyBqdXN0IGEgbWF0dGVyIG9mCnR5cGluZyA8c3Ryb25nPmFudDwvc3Ryb25nPiBpbiB0aGUgSUNVNEogcm9vdCBkaXJlY3RvcnkuIFRoaXMgY2F1c2VzCnRoZSBBbnQgYnVpbGQgc3lzdGVtIHRvIHBlcmZvcm0gYSBidWlsZCBhcyBzcGVjaWZpZWQgYnkgdGhlIGZpbGUKPHN0cm9uZz5idWlsZC54bWw8L3N0cm9uZz4sIGxvY2F0ZWQgaW4gdGhlIElDVTRKIHJvb3QgZGlyZWN0b3J5LiBZb3UKY2FuIGdpdmUgQW50IG9wdGlvbnMgbGlrZSAtdmVyYm9zZSwgYW5kIHlvdSBjYW4gc3BlY2lmeSB0YXJnZXRzLiBBbnQKd2lsbCBvbmx5IGJ1aWxkIHdoYXQncyBiZWVuIGNoYW5nZWQgYW5kIHdpbGwgcmVzb2x2ZSBkZXBlbmRlbmNpZXMKcHJvcGVybHkuICBGb3IgZXhhbXBsZTo8L3A+CjxibG9ja3F1b3RlPgogIDxwcmU+RjpcaWN1NGomZ3Q7YW50IHRlc3RzCkJ1aWxkZmlsZTogYnVpbGQueG1sClByb2plY3QgYmFzZSBkaXIgc2V0IHRvOiBGOlxpY3U0agpFeGVjdXRpbmcgVGFyZ2V0OiBjb3JlCkNvbXBpbGluZyA3MSBzb3VyY2UgZmlsZXMgdG8gRjpcaWN1NGpcY2xhc3NlcwpFeGVjdXRpbmcgVGFyZ2V0OiB0ZXN0cwpDb21waWxpbmcgMjQgc291cmNlIGZpbGVzIHRvIEY6XGljdTRqXGNsYXNzZXMKQ29tcGxldGVkIGluIDE5IHNlY29uZHM8L3ByZT4KPC9ibG9ja3F1b3RlPgoKPHA+VGhlIGZvbGxvd2luZyBhcmUgc29tZSB0YXJnZXRzIHRoYXQgeW91IGNhbiBnaXZlIGFmdGVyIDxzdHJvbmc+YW50PC9zdHJvbmc+LiAgRm9yIG1vcmUKdGFyZ2V0cywgc2VlIHRoZSBidWlsZC54bWwgZmlsZTo8L3A+CjxkaXYgYWxpZ249ImxlZnQiPgoKPHRhYmxlIGJvcmRlcj0iMSIgY2VsbHBhZGRpbmc9IjAiPgogIDx0cj4KICAgIDx0ZD5hbGw8L3RkPgogICAgPHRkPkJ1aWxkIGFsbCB0YXJnZXRzLjwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+Y29yZTwvdGQ+CiAgICA8dGQ+QnVpbGQgdGhlIG1haW4gY2xhc3MgZmlsZXMgaW4gdGhlIHN1YmRpcmVjdG9yeSA8c3Ryb25nPmNsYXNzZXM8L3N0cm9uZz4uIElmIG5vIHRhcmdldAogICAgaXMgc3BlY2lmaWVkLCBjb3JlIGlzIGFzc3VtZWQuPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0ZD50ZXN0czwvdGQ+CiAgICA8dGQ+QnVpbGQgdGhlIHRlc3QgY2xhc3MgZmlsZXMuPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0ZD5kZW1vczwvdGQ+CiAgICA8dGQ+QnVpbGQgdGhlIGRlbW9zLjwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+dG9vbHM8L3RkPgogICAgPHRkPkJ1aWxkIHRoZSB0b29scy48L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPmRvY3M8L3RkPgogICAgPHRkPlJ1biBqYXZhZG9jIG92ZXIgdGhlIG1haW4gY2xhc3MgZmlsZXMsIGdlbmVyYXRpbmcgYW4gSFRNTCBkb2N1bWVudGF0aW9uIHRyZWUgaW4gdGhlCiAgICBzdWJkaXJlY3RvcnkgPHN0cm9uZz5kb2M8L3N0cm9uZz4uPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0ZD5qYXI8L3RkPgogICAgPHRkPkNyZWF0ZSBhIGphciBhcmNoaXZlIDxzdHJvbmc+aWN1NGouamFyPC9zdHJvbmc+IGluIHRoZSByb290IElDVTRKIGRpcmVjdG9yeSBjb250YWluaW5nCiAgICB0aGUgbWFpbiBjbGFzcyBmaWxlcy48L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPnppcDwvdGQ+CiAgICA8dGQ+Q3JlYXRlIGEgemlwIGFyY2hpdmUgb2YgdGhlIHNvdXJjZSwgZG9jcywgYW5kIGphciBmaWxlIGZvciBkaXN0cmlidXRpb24uIFRoZSB6aXAgZmlsZSA8c3Ryb25nPmljdTRqWVlZWU1NREQuemlwPC9zdHJvbmc+CiAgICB3aWxsIGJlIGNyZWF0ZWQgaW4gdGhlIGRpcmVjdG9yeSA8ZW0+YWJvdmU8L2VtPiB0aGUgcm9vdCBJQ1U0SiBkaXJlY3RvcnksIHdoZXJlIFlZWVlNTURECiAgICBpcyB0b2RheSdzIGRhdGUuIEFueSBleGlzdGluZyBmaWxlIG9mIHRoYXQgbmFtZSB3aWxsIGJlIG92ZXJ3cml0dGVuLjwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+emlwc3JjPC90ZD4KICAgIDx0ZD5MaWtlIHRoZSA8c3Ryb25nPnppcDwvc3Ryb25nPiB0YXJnZXQsIHdpdGhvdXQgdGhlIGRvY3MgYW5kIHRoZSBqYXIgZmlsZS4gVGhlIHppcCBmaWxlIDxzdHJvbmc+aWN1NGpzcmNZWVlZTU1ERC56aXA8L3N0cm9uZz4KICAgIHdpbGwgYmUgY3JlYXRlZCBpbiB0aGUgZGlyZWN0b3J5IDxlbT5hYm92ZTwvZW0+IHRoZSByb290IElDVTRKIGRpcmVjdG9yeS48L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPnJpY2hlZGl0PC90ZD4KICAgIDx0ZD5CdWlsZCB0aGUgcmljaGVkaXQgY29yZSBjbGFzcyBmaWxlcyBhbmQgdGVzdHMuCiAgPC90cj4KICA8dHI+CiAgICA8dGQ+cmljaGVkaXRKYXI8L3RkPgogICAgPHRkPkNyZWF0ZSB0aGUgcmljaGVkaXQgamFyIGZpbGUgKHdoaWNoIGNvbnRhaW5zIG9ubHkgdGhlIHJpY2hlZGl0IGNvcmUgY2xhc3MgZmlsZXMpLgogICAgVGhlIGZpbGUgPHN0cm9uZz5yaWNoZWRpdC5qYXI8L3N0cm9uZz4KICAgIHdpbGwgYmUgY3JlYXRlZCBpbiB0aGUgPHN0cm9uZz4uL3JpY2hlZGl0PC9zdHJvbmc+IHN1YmRpcmVjdG9yeS4gQW55IGV4aXN0aW5nIGZpbGUgb2YKICAgIHRoYXQgbmFtZSB3aWxsIGJlIG92ZXJ3cml0dGVuLjwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+cmljaGVkaXRaaXA8L3RkPgogICAgPHRkPkNyZWF0ZSBhIHppcCBhcmNoaXZlIG9mIHRoZSByaWNoZWRpdCBkb2NzIGFuZCBqYXIgZmlsZSBmb3IgZGlzdHJpYnV0aW9uLiBUaGUgemlwIGZpbGUgPHN0cm9uZz5yaWNoZWRpdC56aXA8L3N0cm9uZz4KICAgIHdpbGwgYmUgY3JlYXRlZCBpbiB0aGUgPHN0cm9uZz4uL3JpY2hlZGl0PC9zdHJvbmc+IHN1YmRpcmVjdG9yeS4gQW55IGV4aXN0aW5nIGZpbGUgb2YKICAgIHRoYXQgbmFtZSB3aWxsIGJlIG92ZXJ3cml0dGVuLjwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+Y2xlYW48L3RkPgogICAgPHRkPlJlbW92ZSBhbGwgYnVpbHQgdGFyZ2V0cywgbGVhdmluZyB0aGUgc291cmNlLjwvdGQ+CiAgPC90cj4KPC90YWJsZT4KPC9kaXY+Cgo8cD5Gb3IgbW9yZSBpbmZvcm1hdGlvbiwgcmVhZCB0aGUgQW50IGRvY3VtZW50YXRpb24gYW5kIHRoZSA8c3Ryb25nPmJ1aWxkLnhtbDwvc3Ryb25nPgpmaWxlLjwvcD4KCjxwPkFmdGVyIGRvaW5nIGEgYnVpbGQgaXQgaXMgYSBnb29kIGlkZWEgdG8gcnVuIGFsbCB0aGUgaWN1NGogdGVzdHMgYnkgdHlwaW5nIDxicj4mcXVvdDtqYXZhCi1jbGFzc3BhdGggJFJvb3QvY2xhc3NlcyAtRFVuaWNvZGVEYXRhPSRSb290L3NyYy9jb20vaWJtL2ljdS9kZXYvZGF0YS91bmljb2RlIGNvbS5pYm0uZGV2LnRlc3QuVGVzdEFsbCZxdW90Oy48L3A+Cgo8cD4oSWYgeW91IGFyZSBhbGxlcmdpYyB0byBidWlsZCBzeXN0ZW1zLCBhcyBhbiBhbHRlcm5hdGl2ZSB0byB1c2luZwpBbnQgeW91IGNhbiBidWlsZCBieSBydW5uaW5nIGphdmFjIGFuZCBqYXZhZG9jIGRpcmVjdGx5LiBUaGlzCmlzIG5vdCByZWNvbW1lbmRlZC4gWW91IG1heSBoYXZlIHRvIG1hbnVhbGx5IGNyZWF0ZSBkZXN0aW5hdGlvbgpkaXJlY3Rvcmllcy4pPC9wPgoKPGgzPjxhIG5hbWU9Ikhvd1RvTW9kdWxhcml6ZSI+PC9hPjx1PkhvdyB0byBtb2R1bGFyaXplIElDVTRKPC91PjwvaDM+ClNvbWUgYXBwbGljYXRpb25zIGFuZCBlbnZpcm9ubWVudHMgbWF5IG5vdCB3aXNoIHRvIHNoaXAgYWxsIG9mIElDVTRKIGJ1bmRsZWQgYXMgYSBqYXIgZmlsZSBzaW5jZSB0aGUgamFyIGZpbGUgaXMgbGFyZ2UgYW5kIG1heSBjb250YWluIHBhcnRzIG9mIElDVTRKIHdoaWNoIGFyZSBub3QgdXNlZC4KU29tZSBhcHBsaWNhdGlvbnMgdXNlIG9ubHkgYSBwYXJ0aWN1bGFyIHNlcnZpY2UgZnJvbSB0aGUgcmFuZ2Ugb2Ygc2VydmljZXMgdGhhdCBJQ1U0SiBvZmZlcnMsIHNvIHdvdWxkIHdhbnQgdG8gc2hpcCBvbmx5IHRoYXQgc2VydmljZSBhcyBhIGphciBmaWxlLgpTaW5jZSBJQ1U0SiByZWxlYXNlIDIuNiwgbmV3IGJ1aWxkIG9wdGlvbnMgYXJlIHByb3ZpZGVkIHRvIHNlbGVjdCBpbmRpdmlkdWFsIElDVTRKIG1vZHVsZXMgZm9yIGEgbW9yZSBjb21wYWN0IGphciBkaXN0cmlidXRpb24uClRoZSBtb2R1bGVzIGFyZSBkaXZpZGVkIG9uIGJhc2lzIG9mIHNlcnZpY2UgYW5kIHNldCBvZiBBUElzIHJlcXVpcmVkIGZvciBzdXBwb3J0aW5nIHRoYXQgc2VydmljZSxlLmcuLAp0aGUgbm9ybWFsaXplciBtb2R1bGUgc3VwcG9ydHMgYWxsIHRoZSBOb3JtYWxpemVyIEFQSXMuVGhlIHNlbGYgdGVzdHMgZm9yIHRoZXNlIEFQSXMgY2FuIGJlIHJ1biB0byB2ZXJpZnkgdGhhdCB0aGUgQVBJcyB3b3JrLgpFdmVuIHRob3VnaCBhIG51bWJlciBvZiBzdXBwb3J0aW5nIGNsYXNzZXMgYXJlIGNvbXBpbGVkIGNvbnRhaW5pbmcgb3RoZXIgQVBJcywgPGVtPm5vIGd1YXJhbnRlZXM8L2VtPiBhcmUgbWFkZSB0aGF0IHRoZXNlIEFQSXMgd2lsbCB3b3JrLgpUaGUgbW9kdWxlcyBhcmUgaW50ZXJkZXBlbmRlbnQgbm90IGluZGVwZW5kZW50LGkuZS4sIHNlcGFyYXRlIG1vZHVsZXMgYXJlIG5vdCBidWlsdCBpbnRvIHNlcGFyYXRlIGphcnMsIGluc3RlYWQgb25lIG9yIG1vcmUgbW9kdWxlIHRhcmdldHMgYXJlIHNwZWNpZmllZCBpbm9yZGVyIHRvIGJ1aWxkIGEgc21hbGxlciBqYXIuCgpDdXJyZW50bHkgSUNVNEogY2FuIGJlIGRpdmlkZWQgaW50byB0aGUgZm9sbG93aW5nIG1vZHVsZXM6Cjxicj48YnI+Cjx0YWJsZSBib3JkZXI9IjEiPgoJPHRyPgoKCQk8dGg+PGI+TW9kdWxlIE5hbWU8L2I+PC90aD4KCgkJPHRoPjxiPkFudCBUYXJnZXRzPC9iPjwvdGg+CgoJCTx0aD48Yj5UZXN0IFBhY2thZ2UgU3VwcG9ydGVkPC9iPjwvdGg+CgoJCTx0aD48Yj5NYWluIENsYXNzZXMqJiN4MjAyMDs8L2I+PC90aD4KCgkJPHRoPjxiPlNpemU8L2I+PC90aD4KCgk8L3RyPgoKCTx0cj4KCgkJPHRkPk5vcm1hbGl6ZXI8L3RkPgoKCQk8dGQ+bm9ybWFsaXplciwgbm9ybWFsaXplclRlc3RzPC90ZD4KCgkJPHRkPmNvbS5pYm0uaWN1LmRldi50ZXN0Lm5vcm1hbGl6ZXI8L3RkPgoKCQk8dGQ+CgkJCQlsYW5nLlVDaGFyYWN0ZXIKCQkJPGJyPmxhbmcuVUNoYXJhY3RlckNhdGVnb3J5CgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJEaXJlY3Rpb24KCQkJPGJyPmxhbmcuVUNoYXJhY3Rlck5hbWVJdGVyYXRvcgoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyVHlwZUl0ZXJhdG9yCgkJCTxicj5sYW5nLlVQcm9wZXJ0eQoJCQk8YnI+bGFuZy5VU2NyaXB0CgkJCTxiPjxicj50ZXh0Lk5vcm1hbGl6ZXI8L2I+CgkJCTxicj50ZXh0LlJlcGxhY2VhYmxlCgkJCTxicj50ZXh0LlJlcGxhY2VhYmxlU3RyaW5nCgkJCTxiPjxicj50ZXh0LlVDaGFyYWN0ZXJJdGVyYXRvcgoJCQk8YnI+dGV4dC5VRm9yd2FyZENoYXJhY3Rlckl0ZXJhdG9yPC9iPgoJCQk8YnI+dGV4dC5Vbmljb2RlRmlsdGVyCgkJCTxicj50ZXh0LlVuaWNvZGVNYXRjaGVyCgkJCTxicj50ZXh0LlVuaWNvZGVTZXQKCQkJPGJyPnRleHQuVW5pY29kZVNldEl0ZXJhdG9yCgkJCTxicj50ZXh0LlVURjE2CgkJCTxicj51dGlsLlZhbHVlSXRlcmF0b3IKCQkJPGJyPnV0aWwuVmVyc2lvbkluZm8KCQk8L3RkPgoKCQk8dGQ+Jm5ic3A7MzU1IEtCPC90ZD4KCgk8L3RyPgoKCTx0cj4KCgkJPHRkPkNvbGxhdG9yPC90ZD4KCgkJPHRkPmNvbGxhdG9yLCBjb2xsYXRvclRlc3RzPC90ZD4KCgkJPHRkPmNvbS5pYm0uaWN1LmRldi50ZXN0LmNvbGxhdG9yPC90ZD4KCgkJPHRkPgoJCSAgICAgICAgbGFuZy5VQ2hhcmFjdGVyCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJDYXRlZ29yeQoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyRGlyZWN0aW9uCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJOYW1lSXRlcmF0b3IKCQkJPGJyPmxhbmcuVUNoYXJhY3RlclR5cGVJdGVyYXRvcgoJCQk8YnI+bGFuZy5VUHJvcGVydHkKCQkJPGJyPmxhbmcuVVNjcmlwdAoJCQk8YnI+dGV4dC5CcmVha0RpY3Rpb25hcnkKCQkJPGJyPnRleHQuQnJlYWtJdGVyYXRvcgoJCQk8YnI+dGV4dC5CcmVha0l0ZXJhdG9yRmFjdG9yeQoJCQk8YnI+dGV4dC5DYW5vbmljYWxJdGVyYXRvcgoJCQk8Yj48YnI+dGV4dC5Db2xsYXRpb25FbGVtZW50SXRlcmF0b3IKCQkJPGJyPnRleHQuQ29sbGF0aW9uS2V5CgkJCTxicj50ZXh0LkNvbGxhdGlvblBhcnNlZFJ1bGVCdWlsZGVyCgkJCTxicj50ZXh0LkNvbGxhdGlvblJ1bGVQYXJzZXIKCQkJPGJyPnRleHQuQ29sbGF0b3IKCQkJPGJyPnRleHQuQ29sbGF0b3JSZWFkZXI8L2I+CgkJCTxicj50ZXh0LkRpY3Rpb25hcnlCYXNlZEJyZWFrSXRlcmF0b3IKCQkJPGI+PGJyPnRleHQuTm9ybWFsaXplcjwvYj4KCQkJPGJyPnRleHQuUmVwbGFjZWFibGUKCQkJPGJyPnRleHQuUmVwbGFjZWFibGVTdHJpbmcKCQkJPGJyPnRleHQuUnVsZUJhc2VkQnJlYWtJdGVyYXRvcgoJCQk8Yj48YnI+dGV4dC5SdWxlQmFzZWRDb2xsYXRvcgoJCQk8YnI+dGV4dC5TZWFyY2hJdGVyYXRvcgoJCQk8YnI+dGV4dC5TdHJpbmdTZWFyY2g8L2I+CgkJCTxiPjxicj50ZXh0LlVDaGFyYWN0ZXJJdGVyYXRvcgoJCQk8YnI+dGV4dC5VRm9yd2FyZENoYXJhY3Rlckl0ZXJhdG9yPC9iPgoJCQk8YnI+dGV4dC5Vbmljb2RlRmlsdGVyCgkJCTxicj50ZXh0LlVuaWNvZGVNYXRjaGVyCgkJCTxicj50ZXh0LlVuaWNvZGVTZXQKCQkJPGJyPnRleHQuVW5pY29kZVNldEl0ZXJhdG9yCgkJCTxicj50ZXh0LlVURjE2CgkJCTxicj51dGlsLlZhbHVlSXRlcmF0b3IKCQkJPGJyPnV0aWwuVmVyc2lvbkluZm8KCQk8L3RkPgoKCQk8dGQ+MSw3MTYgS0I8L3RkPgoKCTwvdHI+CgoJPHRyPgoKCQk8dGQ+Q2FsZW5kYXI8L3RkPgoKCQk8dGQ+Y2FsZW5kYXIsIGNhbGVuZGFyVGVzdHM8L3RkPgoKCQk8dGQ+Y29tLmlibS5pY3UuZGV2LnRlc3QuY2FsZW5kYXI8L3RkPgoKCQk8dGQ+CgkJICAgICAgICBsYW5nLlVDaGFyYWN0ZXIKCQkJPGJyPmxhbmcuVUNoYXJhY3RlckNhdGVnb3J5CgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJEaXJlY3Rpb24KCQkJPGJyPmxhbmcuVUNoYXJhY3Rlck5hbWVJdGVyYXRvcgoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyVHlwZUl0ZXJhdG9yCgkJCTxicj5sYW5nLlVQcm9wZXJ0eQoJCQk8YnI+bGFuZy5VU2NyaXB0CgkJCTxiPjxicj5tYXRoLkJpZ0RlY2ltYWw8L2I+CgkJCTxicj50ZXh0LkJyZWFrSXRlcmF0b3IKCQkJPGI+PGJyPnRleHQuQ2hpbmVzZURhdGVGb3JtYXQKCQkJPGJyPnRleHQuQ2hpbmVzZURhdGVGb3JtYXRTeW1ib2xzCgkJCTxicj50ZXh0LkRhdGVGb3JtYXQKCQkJPGJyPnRleHQuRGF0ZUZvcm1hdFN5bWJvbHMKCQkJPGJyPnRleHQuRGVjaW1hbEZvcm1hdAoJCQk8YnI+dGV4dC5EZWNpbWFsRm9ybWF0U3ltYm9sczwvYj4KCQkJPGJyPnRleHQuTm9ybWFsaXplcgoJCQk8YnI+dGV4dC5OdW1iZXJGb3JtYXQKCQkJPGJyPnRleHQuUmVwbGFjZWFibGUKCQkJPGJyPnRleHQuUmVwbGFjZWFibGVTdHJpbmcKCQkJPGI+PGJyPnRleHQuU2ltcGxlRGF0ZUZvcm1hdAoJCQk8YnI+dGV4dC5VQ2hhcmFjdGVySXRlcmF0b3IKCQkJPGJyPnRleHQuVUZvcndhcmRDaGFyYWN0ZXJJdGVyYXRvcjwvYj4KCQkJPGJyPnRleHQuVW5pY29kZUZpbHRlcgoJCQk8YnI+dGV4dC5Vbmljb2RlTWF0Y2hlcgoJCQk8YnI+dGV4dC5Vbmljb2RlU2V0CgkJCTxicj50ZXh0LlVuaWNvZGVTZXRJdGVyYXRvcgoJCQk8YnI+dGV4dC5VVEYxNgoJCQk8Yj48YnI+dXRpbC5CdWRkaGlzdENhbGVuZGFyCgkJCTxicj51dGlsLkNhbGVuZGFyCgkJCTxicj51dGlsLkNhbGVuZGFyQXN0cm9ub21lcgoJCQk8YnI+dXRpbC5DYWxlbmRhckNhY2hlCgkJCTxicj51dGlsLkNhbGVuZGFyRmFjdG9yeQoJCQk8YnI+dXRpbC5DaGluZXNlQ2FsZW5kYXIKCQkJPGJyPnV0aWwuQ3VycmVuY3kKCQkJPGJyPnV0aWwuRGF0ZVJ1bGUKCQkJPGJyPnV0aWwuRWFzdGVySG9saWRheQoJCQk8YnI+dXRpbC5FYXN0ZXJSdWxlCgkJCTxicj51dGlsLkdyZWdvcmlhbkNhbGVuZGFyCgkJCTxicj51dGlsLkhlYnJld0NhbGVuZGFyCgkJCTxicj51dGlsLkhlYnJld0hvbGlkYXkKCQkJPGJyPnV0aWwuSG9saWRheQoJCQk8YnI+dXRpbC5Jc2xhbWljQ2FsZW5kYXIKCQkJPGJyPnV0aWwuSmFwYW5lc2VDYWxlbmRhcgoJCQk8YnI+dXRpbC5SYW5nZURhdGVSdWxlCgkJCTxicj51dGlsLlNpbXBsZURhdGVSdWxlCgkJCTxicj51dGlsLlNpbXBsZUhvbGlkYXkKCQkJPGJyPnV0aWwuU2ltcGxlVGltZVpvbmUKCQkJPGJyPnV0aWwuU2ltcGxlVGltZVpvbmVBZGFwdGVyCgkJCTxicj51dGlsLlRpbWVab25lCgkJCTxicj51dGlsLlRpbWVab25lRGF0YTwvYj4KCQkJPGJyPnV0aWwuVmFsdWVJdGVyYXRvcgoJCQk8YnI+dXRpbC5WZXJzaW9uSW5mbwoJCTwvdGQ+CgoJCTx0ZD4xLDE2MCBLQjwvdGQ+CgoKCTwvdHI+CgoJPHRyPgoKCQk8dGQ+Jm5ic3A7QnJlYWtJdGVyYXRvcjwvdGQ+CgoJCTx0ZD5icmVha0l0ZXJhdG9yLCBicmVha0l0ZXJhdG9yVGVzdHM8L3RkPgoKCQk8dGQ+Y29tLmlibS5pY3UuZGV2LnRlc3QuYnJlYWtpdGVyYXRvcjwvdGQ+CgoJCTx0ZD4KCQkJCWxhbmcuVUNoYXJhY3RlcgoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyQ2F0ZWdvcnkKCQkJPGJyPmxhbmcuVUNoYXJhY3RlckRpcmVjdGlvbgoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyTmFtZUl0ZXJhdG9yCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJUeXBlSXRlcmF0b3IKCQkJPGJyPmxhbmcuVVByb3BlcnR5CgkJCTxicj5sYW5nLlVTY3JpcHQKCQkJPGI+PGJyPnRleHQuQnJlYWtEaWN0aW9uYXJ5CgkJCTxicj50ZXh0LkJyZWFrSXRlcmF0b3IKCQkJPGJyPnRleHQuQnJlYWtJdGVyYXRvckZhY3RvcnkKCQkJPGJyPnRleHQuRGljdGlvbmFyeUJhc2VkQnJlYWtJdGVyYXRvcjwvYj4KCQkJPGJyPnRleHQuTm9ybWFsaXplcgoJCQk8YnI+dGV4dC5SZXBsYWNlYWJsZQoJCQk8YnI+dGV4dC5SZXBsYWNlYWJsZVN0cmluZwoJCQk8Yj48YnI+dGV4dC5SdWxlQmFzZWRCcmVha0l0ZXJhdG9yPC9iPgoJCQk8YnI+dGV4dC5VQ2hhcmFjdGVySXRlcmF0b3IKCQkJPGJyPnRleHQuVUZvcndhcmRDaGFyYWN0ZXJJdGVyYXRvcgoJCQk8YnI+dGV4dC5Vbmljb2RlRmlsdGVyCgkJCTxicj50ZXh0LlVuaWNvZGVNYXRjaGVyCgkJCTxicj50ZXh0LlVuaWNvZGVTZXQKCQkJPGJyPnRleHQuVW5pY29kZVNldEl0ZXJhdG9yCgkJCTxicj50ZXh0LlVURjE2CgkJCTxicj51dGlsLlJhbmdlVmFsdWVJdGVyYXRvcgoJCQk8YnI+dXRpbC5WYWx1ZUl0ZXJhdG9yCgkJCTxicj51dGlsLlZlcnNpb25JbmZvCgkJPC90ZD4KCgkJPHRkPjEsMTA1IEtCPC90ZD4KCgk8L3RyPgoKCTx0cj4KCgkJPHRkPkJhc2ljIFByb3BlcnRpZXM8L3RkPgoKCQk8dGQ+cHJvcGVydGllc0Jhc2ljLCBwcm9wZXJ0aWVzVGVzdHM8L3RkPgoKCQk8dGQ+Y29tLmlibS5pY3UuZGV2LnRlc3QubGFuZzwvdGQ+CgoJCTx0ZD4KCQkgIDxiPiAgICAgbGFuZy5VQ2hhcmFjdGVyCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJDYXRlZ29yeQoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyRGlyZWN0aW9uCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJOYW1lSXRlcmF0b3IKCQkJPGJyPmxhbmcuVUNoYXJhY3RlclR5cGVJdGVyYXRvcgoJCQk8YnI+bGFuZy5VUHJvcGVydHkKCQkJPGJyPmxhbmcuVVNjcmlwdAoJCQk8YnI+bGFuZy5VU2NyaXB0UnVuIDwvYj4KCQkJPGJyPnRleHQuQnJlYWtEaWN0aW9uYXJ5CgkJCTxicj50ZXh0LkJyZWFrSXRlcmF0b3IKCQkJPGJyPnRleHQuQnJlYWtJdGVyYXRvckZhY3RvcnkKCQkJPGJyPnRleHQuRGljdGlvbmFyeUJhc2VkQnJlYWtJdGVyYXRvcgoJCQk8YnI+dGV4dC5Ob3JtYWxpemVyCgkJCTxicj50ZXh0LlJlcGxhY2VhYmxlCgkJCTxicj50ZXh0LlJlcGxhY2VhYmxlU3RyaW5nCgkJCTxicj50ZXh0LlJ1bGVCYXNlZEJyZWFrSXRlcmF0b3IKCQkJPGJyPnRleHQuU3ltYm9sVGFibGUKCQkJPGJyPnRleHQuVUNoYXJhY3Rlckl0ZXJhdG9yCgkJCTxicj50ZXh0LlVGb3J3YXJkQ2hhcmFjdGVySXRlcmF0b3IKCQkJPGJyPnRleHQuVW5pY29kZUZpbHRlcgoJCQk8YnI+dGV4dC5Vbmljb2RlTWF0Y2hlcgoJCQk8YnI+dGV4dC5Vbmljb2RlU2V0CgkJCTxicj50ZXh0LlVuaWNvZGVTZXRJdGVyYXRvcgoJCQk8Yj48YnI+dGV4dC5VVEYxNiA8L2I+CgkJCTxicj51dGlsLkNvbXBhY3RCeXRlQXJyYXkKCQkJPGJyPnV0aWwuUmFuZ2VWYWx1ZUl0ZXJhdG9yCgkJCTxicj51dGlsLlZhbHVlSXRlcmF0b3IKCQkJPGJyPnV0aWwuVmVyc2lvbkluZm8KCQk8L3RkPgoKCQk8dGQ+MzUwIEtCPC90ZD4KCgk8L3RyPgoKCTx0cj4KCgkJPHRkPkZ1bGwgUHJvcGVydGllczwvdGQ+CgoJCTx0ZD5wcm9wZXJ0aWVzRnVsbCwKCQk8YnI+cHJvcGVydGllc1Rlc3RzPC90ZD4KCgkJPHRkPmNvbS5pYm0uaWN1LmRldi50ZXN0Lmxhbmc8L3RkPgoKCQk8dGQ+CgkJICAgIDxiPiAgICBsYW5nLlVDaGFyYWN0ZXIKCQkJPGJyPmxhbmcuVUNoYXJhY3RlckNhdGVnb3J5CgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJEaXJlY3Rpb24KCQkJPGJyPmxhbmcuVUNoYXJhY3Rlck5hbWVJdGVyYXRvcgoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyVHlwZUl0ZXJhdG9yCgkJCTxicj5sYW5nLlVQcm9wZXJ0eQoJCQk8YnI+bGFuZy5VU2NyaXB0CgkJCTxicj5sYW5nLlVTY3JpcHRSdW48L2I+CgkJCTxicj50ZXh0LkJyZWFrRGljdGlvbmFyeQoJCQk8YnI+dGV4dC5CcmVha0l0ZXJhdG9yCgkJCTxicj50ZXh0LkJyZWFrSXRlcmF0b3JGYWN0b3J5CgkJCTxicj50ZXh0LkRpY3Rpb25hcnlCYXNlZEJyZWFrSXRlcmF0b3IKCQkJPGI+PGJyPnRleHQuTm9ybWFsaXplcgoJCQk8YnI+dGV4dC5SZXBsYWNlYWJsZQoJCQk8YnI+dGV4dC5SZXBsYWNlYWJsZVN0cmluZyA8L2I+CgkJCTxicj50ZXh0LlJ1bGVCYXNlZEJyZWFrSXRlcmF0b3IKCQkgICAgPGI+PGJyPnRleHQuVUNoYXJhY3Rlckl0ZXJhdG9yCgkJCTxicj50ZXh0LlVGb3J3YXJkQ2hhcmFjdGVySXRlcmF0b3IKCQkJPGJyPnRleHQuVW5pY29kZUZpbHRlcgoJCQk8YnI+dGV4dC5Vbmljb2RlTWF0Y2hlcgoJCQk8YnI+dGV4dC5Vbmljb2RlU2V0CgkJCTxicj50ZXh0LlVuaWNvZGVTZXRJdGVyYXRvcgoJCQk8YnI+dGV4dC5VVEYxNgoJCQk8YnI+dXRpbC5SYW5nZVZhbHVlSXRlcmF0b3IKCQkJPGJyPnV0aWwuVmFsdWVJdGVyYXRvcgoJCQk8YnI+dXRpbC5WZXJzaW9uSW5mbyA8L2I+CgkJPC90ZD4KCgkJPHRkPiZuYnNwOzk4NiBLQjwvdGQ+CgoJPC90cj4KCgk8dHI+CgoJCTx0ZD5Gb3JtYXR0aW5nPC90ZD4KCgkJPHRkPmZvcm1hdCwgZm9ybWF0VGVzdHM8L3RkPgoKCQk8dGQ+Y29tLmlibS5pY3UuZGV2LnRlc3QuZm9ybWF0PC90ZD4KCgkJPHRkPgoJCSAgICAgICAgbGFuZy5VQ2hhcmFjdGVyCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJDYXRlZ29yeQoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyRGlyZWN0aW9uCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJOYW1lSXRlcmF0b3IKCQkJPGJyPmxhbmcuVUNoYXJhY3RlclR5cGVJdGVyYXRvcgoJCQk8YnI+bGFuZy5VUHJvcGVydHkKCQkJPGJyPmxhbmcuVVNjcmlwdAoJCQk8Yj48YnI+bWF0aC5CaWdEZWNpbWFsPC9iPgoJCQk8YnI+dGV4dC5CcmVha0l0ZXJhdG9yCgkJCTxicj50ZXh0LkNhbm9uaWNhbEl0ZXJhdG9yCgkJCTxicj50ZXh0LkNoaW5lc2VEYXRlRm9ybWF0CgkJCTxicj50ZXh0LkNoaW5lc2VEYXRlRm9ybWF0U3ltYm9scwoJCQk8YnI+dGV4dC5Db2xsYXRpb25FbGVtZW50SXRlcmF0b3IKCQkJPGJyPnRleHQuQ29sbGF0aW9uS2V5CgkJCTxicj50ZXh0LkNvbGxhdGlvblBhcnNlZFJ1bGVCdWlsZGVyCgkJCTxicj50ZXh0LkNvbGxhdGlvblJ1bGVQYXJzZXIKCQkJPGJyPnRleHQuQ29sbGF0b3IKCQkJPGJyPnRleHQuQ29sbGF0b3JSZWFkZXIKCQkJPGI+PGJyPnRleHQuRGF0ZUZvcm1hdAoJCQk8YnI+dGV4dC5EYXRlRm9ybWF0U3ltYm9scwoJCQk8YnI+dGV4dC5EZWNpbWFsRm9ybWF0CgkJCTxicj50ZXh0LkRlY2ltYWxGb3JtYXRTeW1ib2xzPC9iPgoJCQk8YnI+dGV4dC5Ob3JtYWxpemVyCgkJCTxiPjxicj50ZXh0Lk51bWJlckZvcm1hdDwvYj4KCQkJPGJyPnRleHQuUmVwbGFjZWFibGUKCQkJPGJyPnRleHQuUmVwbGFjZWFibGVTdHJpbmcKCQkJPGJyPnRleHQuUnVsZUJhc2VkQ29sbGF0b3IKCQkJPGI+PGJyPnRleHQuUnVsZUJhc2VkTnVtYmVyRm9ybWF0CgkJCTxicj50ZXh0LlNpbXBsZURhdGVGb3JtYXQKCQkJPGJyPnRleHQuVUNoYXJhY3Rlckl0ZXJhdG9yCgkJCTxicj50ZXh0LlVGb3J3YXJkQ2hhcmFjdGVySXRlcmF0b3I8L2I+CgkJCTxicj50ZXh0LlVuaWNvZGVGaWx0ZXIKCQkJPGJyPnRleHQuVW5pY29kZU1hdGNoZXIKCQkJPGJyPnRleHQuVW5pY29kZVNldAoJCQk8YnI+dGV4dC5Vbmljb2RlU2V0SXRlcmF0b3IKCQkJPGJyPnRleHQuVVRGMTYKCQkJPGI+PGJyPnV0aWwuQ2FsZW5kYXIKCQkJPGJyPnV0aWwuQ2FsZW5kYXJBc3Ryb25vbWVyCgkJCTxicj51dGlsLkNhbGVuZGFyQ2FjaGUKCQkJPGJyPnV0aWwuQ2FsZW5kYXJGYWN0b3J5CgkJCTxicj51dGlsLkNoaW5lc2VDYWxlbmRhcgoJCQk8YnI+dXRpbC5DdXJyZW5jeQoJCQk8YnI+dXRpbC5HcmVnb3JpYW5DYWxlbmRhcgoJCQk8YnI+dXRpbC5SYW5nZVZhbHVlSXRlcmF0b3IKCQkJPGJyPnV0aWwuU2ltcGxlVGltZVpvbmUKCQkJPGJyPnV0aWwuU2ltcGxlVGltZVpvbmVBZGFwdGVyCgkJCTxicj51dGlsLlRpbWVab25lCgkJCTxicj51dGlsLlRpbWVab25lRGF0YTwvYj4KCQkJPGJyPnV0aWwuVmFsdWVJdGVyYXRvcgoJCQk8YnI+dXRpbC5WZXJzaW9uSW5mbwoJCTwvdGQ+CgkJPHRkPjEsNzg4IEtCIDwvdGQ+Cgk8L3RyPgoKICAgIDx0cj4KCgkJPHRkPlRyYW5zZm9ybXM8L3RkPgoKCQk8dGQ+dHJhbnNsaXRlcmF0b3IsIHRyYW5zbGl0ZXJhdG9yVGVzdHM8L3RkPgoKCQk8dGQ+Y29tLmlibS5pY3UuZGV2LnRlc3QudHJhbnNsaXQ8L3RkPgoKCQk8dGQ+CgkJIDxiPgkJbGFuZy5VQ2hhcmFjdGVyCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJDYXRlZ29yeQoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyRGlyZWN0aW9uCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJOYW1lSXRlcmF0b3IKCQkJPGJyPmxhbmcuVUNoYXJhY3RlclR5cGVJdGVyYXRvcgoJCQk8YnI+bGFuZy5VUHJvcGVydHkKCQkJPGJyPmxhbmcuVVNjcmlwdAoJCQk8YnI+bGFuZy5VU2NyaXB0UnVuCgkJCTxicj50ZXh0LkFueVRyYW5zbGl0ZXJhdG9yCgkJCTxicj50ZXh0LkJyZWFrRGljdGlvbmFyeQoJCQk8YnI+dGV4dC5CcmVha0l0ZXJhdG9yCgkJCTxicj50ZXh0LkJyZWFrSXRlcmF0b3JGYWN0b3J5CgkJCTxicj50ZXh0LkJyZWFrVHJhbnNsaXRlcmF0b3IKCQkJPGJyPnRleHQuRGljdGlvbmFyeUJhc2VkQnJlYWtJdGVyYXRvcgoJCQk8YnI+dGV4dC5Ob3JtYWxpemVyCgkJCTxicj50ZXh0LlJlcGxhY2VhYmxlCgkJCTxicj50ZXh0LlJlcGxhY2VhYmxlU3RyaW5nCgkJCTxicj50ZXh0LlJ1bGVCYXNlZEJyZWFrSXRlcmF0b3IKCQkJPGJyPnRleHQuU3RyaW5nUmVwbGFjZXIKCQkJPGJyPnRleHQuVHJhbnNsaXRlcmF0b3IKCQkJPGJyPnRleHQuVUNoYXJhY3Rlckl0ZXJhdG9yCgkJCTxicj50ZXh0LlVGb3J3YXJkQ2hhcmFjdGVySXRlcmF0b3IKCQkJPGJyPnRleHQuVW5pY29kZVNldAoJCQk8YnI+dGV4dC5Vbmljb2RlU2V0SXRlcmF0b3IKCQkJPGJyPnRleHQuVVRGMTYKCQkJPGJyPnV0aWwuUmFuZ2VWYWx1ZUl0ZXJhdG9yCgkJCTxicj51dGlsLlZhbHVlSXRlcmF0b3IKCQkJPGJyPnV0aWwuVmVyc2lvbkluZm88L2I+CgkJPC90ZD4KCgkJPHRkPjEsMzY0IEtCPC90ZD4KCgk8L3RyPgo8L3RhYmxlPgo8Yj4KPGZvbnQgc2l6ZT0yPgoqIGNvbS5pYm0uaWN1LiBzaG91bGQgYmUgcHJlcGVuZGVkIHRvIHRoZSBuYW1lcyBsaXN0ZWQuCjxicj4mI3gyMDIwOyBBUElzIGNvbnRhaW5lZCBieSBjbGFzcyBuYW1lcyBpbiBib2xkIGFyZSBndWFyYW50ZWVkIHRvIHdvcmsuCjwvZm9udD4KPC9iPgo8YnI+Cjxicj4KCkJ1aWxkaW5nIGFueSBvZiB0aGVzZSBtb2R1bGVzIGlzIGFzIGVhc3kgYXMgc3BlY2lmeWluZyBhIGJ1aWxkIHRhcmdldCB0byB0aGUgQW50IGJ1aWxkIHN5c3RlbSxlLmc6Cjxicj5UbyBidWlsZCBhIG1vZHVsZSB0aGF0IGNvbnRhaW5zIG9ubHkgdGhlIE5vcm1hbGl6ZXIgQVBJOgogICAgPG9sPgogICAgICAgIDxsaT4gQnVpbGQgdGhlIG1vZHVsZS4gPGJyPiA8Y29kZT4gYW50IG5vcm1hbGl6ZXIgPC9jb2RlPiA8L2xpPgogICAgICAgIDxsaT4gQnVpbGQgdGhlIHRlc3RzIGZvciB0aGUgbW9kdWxlLiA8YnI+IDxjb2RlPiBhbnQgbm9ybWFsaXplclRlc3RzIDwvY29kZT4gPC9saT4KICAgICAgICA8YnI+PGI+PGZvbnQgc2l6ZT0yPk5vdGU6PC9mb250PjwvYj4gWW91IGNvdWxkIG9taXQgdGhlIHN0ZXAgMSBhbmQgcHJvY2VlZCB0byBzdGVwIDIsIGZvciBhbGwgbW9kdWxlcyBleGNlcHQgZnVsbCBjaGFyYWN0ZXIgcHJvcGVydGllcywgYW5kIGxldCB0aGUgZGVwZW5kZWN5IGFuYWx5c2lzIGNvbXBpbGUgdGhlIHJlcXVpc2l0ZSBtb2R1bGUuCiAgICAgICAgPGxpPiBSdW4gdGhlIHRlc3RzIGFuZCB2ZXJpZnkgdGhhdCB0aGUgc2VsZiB0ZXN0cyBwYXNzLiA8YnI+IDxjb2RlPiBqYXZhIC1jbGFzc3BhdGggJGljdTRqX3Jvb3QvY2xhc3NlcyBjb20uaWJtLmljdS5kZXYudGVzdC5UZXN0QWxsIC1ub3Rocm93IC13IDwvY29kZT4KIAkJPGxpPiBCdWlsZCB0aGUgamFyIGNvbnRhaW5pbmcgdGhlIG1vZHVsZS4gPGJyPiA8Y29kZT5hbnQgbW9kdWxlSmFyIDwvY29kZT4KICAgICA8L29sPgoKSWYgbW9yZSB0aGFuIG9uZSBtb2R1bGUgaXMgcmVxdWlyZWQsIHRoZSBtb2R1bGUgYnVpbGQgdGFyZ2V0cyBjYW4gYmUgY29uY2F0ZW5hdGVkLCBlLmc6CiAgICA8b2w+CiAgICAgICAgPGxpPiBCdWlsZCB0aGUgbW9kdWxlcy4gPGJyPiA8Y29kZT4gYW50IG5vcm1hbGl6ZXIgY29sbGF0b3IgPC9jb2RlPiA8L2xpPgogICAgICAgIDxsaT4gQnVpbGQgdGhlIHRlc3RzIGZvciB0aGUgbW9kdWxlLiA8YnI+IDxjb2RlPiBhbnQgbm9ybWFsaXplclRlc3RzIGNvbGxhdG9yVGVzdHMgPC9jb2RlPiA8L2xpPgogICAgICAgIDxsaT4gUnVuIHRoZSB0ZXN0cyBhbmQgdmVyaWZ5IHRoYXQgdGhlIHNlbGYgdGVzdHMgcGFzcy4gPGJyPiA8Y29kZT4gamF2YSAtY2xhc3NwYXRoICRpY3U0al9yb290L2NsYXNzZXMgY29tLmlibS5pY3UuZGV2LnRlc3QuVGVzdEFsbCAtbm90aHJvdyAtdyA8L2NvZGU+CiAgICAgICAgPGxpPiBCdWlsZCB0aGUgamFyIGNvbnRhaW5pbmcgdGhlIG1vZHVsZS4gPGJyPiA8Y29kZT5hbnQgbW9kdWxlSmFyIDwvY29kZT4KICAgICA8L29sPgoKPGg1PiBOb3RlczogPC9oNT4KPHVsPgoJPGxpPlJlZ2FyZGxlc3Mgb2Ygd2hldGhlciBJQ1U0SiBpcyBidWlsdCBhcyBhIHdob2xlIG9yIGFzIG1vZHVsZXMsIHRoZSBqYXIgZmlsZSBwcm9kdWNlZCBpcyBuYW1lZCA8ZW0+aWN1NGouamFyPC9lbT4uPC9saT4KCTxsaT5UbyBhc2NlcnRhaW4gaWYgYW4gaWN1NGouamFyIGNvbnRhaW5zIGFsbCBpZiBJQ1Ugb3Igbm90LCBwbGVhc2Ugc2VlIHRoZSBtYW5pZmVzdCBmaWxlIG9mIGphcjwvbGk+Cgk8bGk+VGhlIHRhcmdldCBtb2R1bGVKYXIgZG9lcyBub3QgZGVwZW5kIG9uIGFueSBvdGhlciB0YXJnZXQuIEl0IGp1c3QgY3JlYXRlcyBhIGphciBvZiBhbGwgY2xhc3MgZmlsZXMgdW5kZXIKCSAgICAkaWN1NGpfcm9vdC9jbGFzc2VzL2NvbS9pYm0vaWN1LywgZXhjbHVkaW5nIHRoZSBjbGFzc3MgZmlsZXMgaW4gJGljdTRqX3Jvb3QvY2xhc3Nlcy9jb20vaWJtL2ljdS9kZXYgZm9sZGVyPC9saT4KICAgIDxsaT5UaGUgbGlzdCBvZiBtb2R1bGUgYnVpbGQgdGFyZ2V0cyBjYW4gYmUgb2J0YWluZWQgYnkgcnVubmluZyB0aGUgY29tbWFuZCA6IDxjb2RlPiBhbnQgLXByb2plY3RoZWxwIDwvY29kZT4gPC9saT4KCTxsaT5UbyB2ZXJpZnkgdGhhdCB0aGUgamFyIGZpbGUgYnVpbHQgdXNpbmcgdGhlIG1vZHVsZSB0YXJnZXQgd29ya3MsIHBsZWFzZSBkZWxldGUgYWxsIGRpcmVjdG9yaWVzIHVuZGVyICRpY3U0al9yb290L2NsYXNzZXMvY29tL2libS9pY3UvLCAKCSAgICBleGNlcHQgJGljdTRqX3Jvb3QvY2xhc3Nlcy9jb20vaWJtL2ljdS9kZXYsIGFuZCBydW4gdGhlIHRlc3RzIGFnYWluc3QgdGhlIGphciBmaWxlLgoJCTxicj48Y29kZT4gamF2YSAtY2xhc3NwYXRoICRpY3U0al9yb290L2ljdTRqLmphciBjb20uaWJtLmljdS5kZXYudGVzdC5UZXN0QWxsIC1ub3Rocm93IC13IDwvY29kZT4KCSA8L2xpPgo8L3VsPgoKPGgzPjxhIG5hbWU9InRyeWluZ291dCI+PC9hPjx1PlRyeWluZyBPdXQgSUNVNEo8L3U+PC9oMz4KCjxwPjxzdHJvbmc+Tm90ZTo8L3N0cm9uZz4gdGhlIGRlbW9zIHByb3ZpZGVkIHdpdGggSUNVNEogYXJlIGZvciB0aGUKbW9zdCBwYXJ0IHVuZG9jdW1lbnRlZC4gIFRoaXMgbGlzdCBjYW4gc2hvdyB5b3Ugd2hlcmUgdG8gbG9vaywgYnV0IHlvdSdsbApoYXZlIHRvIGV4cGVyaW1lbnQgYSBiaXQuICBUaGUgZGVtb3MgKHdpdGggdGhlCmV4Y2VwdGlvbiBvZiByaWNoZWRpdCkgYXJlIDxzdHJvbmc+dW5zdXBwb3J0ZWQ8L3N0cm9uZz4gYW5kIG1heSBjaGFuZ2UKb3IgZGlzYXBwZWFyIHdpdGhvdXQgbm90aWNlLjwvcD4KPHA+VGhlIGljdTRqLmphciBmaWxlIGNvbnRhaW5zIG9ubHkgdGhlIGNvcmUgSUNVNEogY2xhc3Nlcywgbm90IHRoZQpkZW1vIGNsYXNzZXMsIHNvIHVubGVzcyB5b3UgYnVpbGQgSUNVNEogdGhlcmUgaXMgbGl0dGxlIHRvIHRyeSBvdXQuCgo8aDQ+UmljaCBFZGl0PC9oND4KVG8gdHJ5IG91dCB0aGUgPHN0cm9uZz5yaWNoZWRpdDwvc3Ryb25nPiBwYWNrYWdlLCBmaXJzdCBidWlsZCB0aGUgcmljaGVkaXRKYXIgdGFyZ2V0LgpUaGlzIGlzIGEgJ3J1bm5hYmxlJyBqYXIgZmlsZS4gIFRvIHJ1biB0aGUgcmljaGVkaXQgZGVtbywgdHlwZToKPHR0PjxibG9ja3F1b3RlPiAgamF2YSAtamFyICRSb290L3JpY2hlZGl0L3JpY2hlZGl0LmphcjwvYmxvY2txdW90ZT48L3R0PgoKVGhpcyB3aWxsIHByZXNlbnQgYW4gZW1wdHkgZWRpdCBwYW5lIHdpdGggYW4gYXd0IGludGVyZmFjZS48L3A+Cgo8cD5XaXRoIGEgZnVsbGVyIGNvbW1hbmQgbGluZSB5b3UgY2FuIHRyeSBvdXQgb3RoZXIgb3B0aW9ucywgZm9yIGV4YW1wbGU6Cjx0dD48YmxvY2txdW90ZT4gICBqYXZhIC1jbGFzc3BhdGggJFJvb3QvcmljaGVkaXQvcmljaGVkaXQuamFyIGNvbS5pYm0ucmljaHRleHQuZGVtby5FZGl0RGVtbyBbLXN3aW5nXVtmaWxlXTwvYmxvY2txdW90ZT48L3R0PgpUaGlzIHdpbGwgdXNlIGFuIGF3dCBHVUksIG9yIGEgc3dpbmcgR1VJIGlmCjx0dD4tc3dpbmc8L3R0PiBpcyBwYXNzZWQgb24gdGhlIGNvbW1hbmQgbGluZS4gIEl0IHdpbGwgb3BlbiBhIHRleHQKZmlsZSBpZiBvbmUgaXMgcHJvdmlkZWQsIG90aGVyd2lzZSBpdCB3aWxsIG9wZW4gYSBibGFuayBwYWdlLiAgQ2xpY2sKdG8gdHlwZS48L3A+CjxwPgpZb3UgY2FuIGFkZCB0YWJzIHRvIHRoZSB0YWIgcnVsZXIgYnkgY2xpY2tpbmcgaW4gdGhlIHJ1bGVyIHdoaWxlIGhvbGRpbmcgZG93biB0aGUgY29udHJvbCBrZXkuCkNsaWNraW5nIG9uIGFuIGV4aXN0aW5nIHRhYiBjaGFuZ2VzIGJldHdlZW4gbGVmdCwgcmlnaHQsIGNlbnRlciwgYW5kIGRlY2ltYWwgdGFicy4gIERyYWdnaW5nCmEgdGFiIG1vdmVzIGl0LCBkcmFnZ2luZyBpdCBvZmYgdGhlIHJ1bGVyIHJlbW92ZXMgaXQuPC9wPgo8cD4KWW91IGNhbiBleHBlcmltZW50IHdpdGggY29tcGxleCB0ZXh0IGJ5IHVzaW5nIHRoZSBrZXltYXAgZnVuY3Rpb25zLgpQbGVhc2Ugbm90ZSB0aGF0IHRoZXNlIGFyZSBtYWlubHkgZm9yIGRlbW8gcHVycG9zZXMsIGZvciByZWFsIHdvcmsKd2l0aCBBcmFiaWMgb3IgSGVicmV3IHlvdSB3aWxsIHdhbnQgdG8gdXNlIGFuIGlucHV0IG1ldGhvZC4gIFlvdSB3aWxsCm5lZWQgdG8gdXNlIGEgZm9udCB0aGF0IHN1cHBvcnRzIEFyYWJpYyBvciBIZWJyZXcsICdMdWNpZGEgU2FucycgKHByb3ZpZGVkCndpdGggSmF2YSkgc3VwcG9ydHMgdGhlc2UgbGFuZ3VhZ2VzLjwvcD4KCjxoND5PdGhlciBkZW1vczwvaDQ+CjxwPlRoZSBvdGhlciBkZW1vIHByb2dyYW1zIGFyZSA8c3Ryb25nPm5vdCBzdXBwb3J0ZWQ8L3N0cm9uZz4gYW5kIGV4aXN0IG9ubHkgdG8gbGV0IHlvdQpleHBlcmltZW50IHdpdGggdGhlIElDVTRKIGNsYXNzZXMuICBGaXJzdCwgYnVpbGQgSUNVNEogdXNpbmcgPHR0PmFudCZuYnNwO2FsbDwvdHQ+LiAgVGhlbiB0cnkKb25lIG9mIHRoZSBmb2xsb3dpbmc6Cjx1bD4KPGxpPjx0dD5qYXZhIC1jbGFzc3BhdGggY2xhc3NlcyBjb20uaWJtLmljdS5kZXYuZGVtby5jYWxlbmRhci5DYWxlbmRhckFwcDwvdHQ+CjxsaT48dHQ+amF2YSAtY2xhc3NwYXRoIGNsYXNzZXMgY29tLmlibS5pY3UuZGV2LmRlbW8uaG9saWRheS5Ib2xpZGF5Q2FsZW5kYXJEZW1vPC90dD4KPGxpPjx0dD5qYXZhIC1jbGFzc3BhdGggY2xhc3NlcyBjb20uaWJtLmljdS5kZXYuZGVtby5yYmJpLlRleHRCb3VuZERlbW88L3R0Pjxicj4oQ2xpY2sgaW4gdGhlIHRleHQsIHRoZW4gdXNlIDx0dD5jdHJsLU48L3R0PiBhbmQgPHR0PmN0cmwtUDwvdHQ+IHRvIHNlbGVjdCB0aGUgbmV4dCBvciBwcmV2aW91cyBibG9jayBvZiB0ZXh0LikKPGxpPjx0dD5qYXZhIC1jbGFzc3BhdGggY2xhc3NlcyBjb20uaWJtLmljdS5kZXYuZGVtby5yYm5mLlJibmZEZW1vPC90dD4KPGxpPjx0dD5qYXZhIC1jbGFzc3BhdGggY2xhc3NlcyBjb20uaWJtLmljdS5kZXYuZGVtby50cmFuc2xpdC5EZW1vPC90dD4KPC91bD4KPC9wPgoKPGEgbmFtZT0icmVzb3VyY2VzIj4KPGgzPjx1PklDVTRKIFJlc291cmNlIEluZm9ybWF0aW9uPC91PjwvaDM+CjwvYT4KU3RhcnRpbmcgd2l0aCByZWxlYXNlIDIuMSwgSUNVNEogaW5jbHVkZXMgaXRzIG93bgpyZXNvdXJjZSBpbmZvcm1hdGlvbgp3aGljaCBpcyBjb21wbGV0ZWx5IGluZGVwZW5kZW50IG9mIHRoZSBKREsgcmVzb3VyY2UgaW5mb3JtYXRpb24uICBUaGUKbmV3IElDVTRKIGluZm9ybWF0aW9uIGlzIGVxdWl2YWxlbnQgdG8gdGhlIGluZm9ybWF0aW9uIGluIElDVTRDIGFuZAp1bHRpbWF0ZWx5IGRlcml2ZXMgZnJvbSB0aGUgc2FtZSBzb3VyY2UuICBUaGlzIGFsbG93cyBJQ1U0SiAyLjEgYW5kIGFib3ZlCnRvIGJlCmJ1aWx0IG9uLCBhbmQgcnVuIG9uLCBKREsgMS40Lgo8L3A+CjxwPgpCeSBkZWZhdWx0IHRoZSBJQ1U0SiBkaXN0cmlidXRpb24gaW5jbHVkZXMgYWxsIG9mIHRoZSBuZXcgcmVzb3VyY2UKaW5mb3JtYXRpb24uICBJdCBpcyBsb2NhdGVkIGluIHRoZSBwYWNrYWdlIGNvbS5pYm0uaWN1LmltcGwuZGF0YSwgYXMgYQpzZXQgb2YgY2xhc3MgZmlsZXMgbmFtZWQgIkxvY2FsZUVsZW1lbnRzIiBmb2xsb3dlZCBieSB0aGUgbmFtZXMgb2YKbG9jYWxlcyBpbiB0aGUgZm9ybSBfeHhfWVlfWlpaWiwgd2hlcmUgJ3h4JyBpcyB0aGUgdHdvLWxldHRlciBsYW5ndWFnZQpjb2RlLCAnWVknIGlzIHRoZSBjb3VudHJ5IGNvZGUsIGFuZCAnWlonICh3aGljaCBjYW4gYmUgYW55IGxlbmd0aCkgaXMKYSB2YXJpYW50LiAgTWFueSBvZiB0aGVzZSBmaWVsZHMgY2FuIGJlIG9taXR0ZWQuICBMb2NhbGUgbmFtaW5nIGlzCmRvY3VtZW50ZWQgdGhlIExvY2FsZSBjbGFzcywgamF2YS51dGlsLkxvY2FsZSwgYW5kIHRoZSB1c2Ugb2YgdGhlc2UKbmFtZXMgaW4gc2VhcmNoaW5nIGZvciByZXNvdXJjZXMgaXMgZG9jdW1lbnRlZCBpbgpqYXZhLnV0aWwuUmVzb3VyY2VCdW5kbGUuCjwvcD4KPHA+ClNvbWUgb2YgdGhlc2UgZmlsZXMgcmVxdWlyZSBzZXBhcmF0ZSBiaW5hcnkgZGF0YS4gIFRoZSBuYW1lcyBvZiB0aGUKYmluYXJ5IGRhdGEgZmlsZXMgc3RhcnQgd2l0aCAiQ29sbGF0aW9uRWxlbWVudHMiLCB0aGVuIHRoZQpjb3JyZXNwb25kaW5nIExvY2FsZSBzdHJpbmcsIGFuZCBlbmQgd2l0aCAnLnJlcycuICBBbm90aGVyIGRhdGEgZmlsZQoob25seSBvbmUgYXQgdGhlIG1vbWVudCkgc3RhcnRzIHdpdGggdGhlIG5hbWUgIkJyZWFrRGljdGlvbmFyeURhdGEiLAp0aGUgY29ycmVzcG9uZGluZyBMb2NhbGUgc3RyaW5nLCBhbmQgZW5kcyB3aXRoICcudWNzJy4KPC9wPgo8cD4KU29tZSBvZiB0aGUgTG9jYWxlRWxlbWVudHMgZmlsZXMgc2hhcmUgZGF0YSB3aXRoIG90aGVyIExvY2FsZUVsZW1lbnRzCmZpbGVzLCBiZWNhdXNlIHNvbWUgTG9jYWxlIG5hbWVzIGhhdmUgY2hhbmdlZC4gRm9yIGV4YW1wbGUsIGhlX0lMIHVzZWQKdG8gYmUgaXdfSUwuICBJbiBvcmRlciB0byBzdXBwb3J0IGJvdGggbmFtZXMgYnV0IG5vdCBkdXBsaWNhdGUgdGhlCmRhdGEsIG9uZSBvZiB0aGUgY2xhc3MgZmlsZXMgcmVmZXJzIHRvIHRoZSBvdGhlciBjbGFzcyBmaWxlJ3MgZGF0YS4KPC9wPgo8cD4KVGhlIGxpc3Qgb2Ygc3VwcG9ydGVkIHJlc291cmNlcyBpcyBmb3VuZCBpbiBhIGZpbGUgY2FsbGVkCkxvY2FsZUVsZW1lbnRzX2luZGV4LmNsYXNzLiAgVGhpcyBjb250YWlucyB0aGUgbmFtZXMgb2YgYWxsIHRoZQpMb2NhbGVFbGVtZW50cyByZXNvdXJjZXMgYW5kIGlzIHRoZSBzb3VyY2Ugb2YgdGhlIGluZm9ybWF0aW9uIHJldHVybmVkCmJ5IEFQSSBzdWNoIGFzIENhbGVuZGFyLmdldEF2YWlsYWJsZUxvY2FsZXMuIChOb3RlOiBmb3IgZWFzZSBvZgpjdXN0b21pemF0aW9uIHRoaXMgcHJvYmFibHkgc2hvdWxkIGJlIGEgdGV4dCBmaWxlKS4KPC9wPgo8cD4KTG9jYWxlRWxlbWVudHMgZmlsZXMgZm9ybSBhIGhpZXJhcmNoeSwgd2l0aCB1cCB0byBmb3VyIGxldmVsczogYSByb290LApsYW5ndWFnZSwgcmVnaW9uIChjb3VudHJ5KSwgYW5kIHZhcmlhbnQuICBTZWFyY2hlcyBmb3IgbG9jYWxlIGRhdGEKYXR0ZW1wdCB0byBtYXRjaCBhcyBmYXIgZG93biB0aGUgaGllcmFyY2h5IGFzIHBvc3NpYmxlLCBmb3IgZXhhbXBsZSwKJ2hlX0lMJyB3aWxsIG1hdGNoIExvY2FsZUVsZW1lbnRzX2hlX0lMLCBidXQgJ2hlX1VTJyB3aWxsIG1hdGNoCkxvY2FsZUVsZW1lbnRzX2hlIChzaW5jZSB0aGVyZSBpcyBubyAnVVMnIHZhcmlhbnQgZm9yICdoZScsIGFuZAoneHhfWVknIHdpbGwgbWF0Y2ggTG9jYWxlRWxlbWVudHMgKHNpbmNlIHRoZXJlIGlzIG5vICd4eCcgbGFuZ3VhZ2UKY29kZSBpbiB0aGUgTG9jYWxlRWxlbWVudHMgaGllcmFyY2h5KS4gIEFnYWluLCBzZWUKamF2YS51dGlsLlJlc291cmNlQnVuZGxlIGZvciBtb3JlIGluZm9ybWF0aW9uLgo8L3A+CjxwPgpXaXRoIHRoaXMgaW4gbWluZCwgdGhlIHdheSB0byByZW1vdmUgTG9jYWxlRGF0YSBpcyB0byBtYWtlIHN1cmUgdG8KcmVtb3ZlIGFsbCBkZXBlbmRlbmNpZXMgb24gdGhhdCBkYXRhIGFzIHdlbGwuICBGb3IgZXhhbXBsZSwgaWYgeW91CnJlbW92ZSBMb2NhbGVFbGVtZW50c19oZS5jbGFzcywgeW91IG5lZWQgdG8gcmVtb3ZlCkxvY2FsZUVsZW1lbnRzX2hlX0lMLmNsYXNzLCBzaW5jZSBpdCBpcyBsb3dlciBpbiB0aGUgaGllcmFyY2h5LCBhbmQKeW91IG11c3QgcmVtb3ZlIExvY2FsZUVsZW1lbnRzX2l3LmNsYXNzLCBzaW5jZSBpdCByZWZlcmVuY2VzCkxvY2FsZUVsZW1lbnRzX2hlLCBhbmQgTG9jYWxlRUxlbWVudHNfaXdfSUwuY2xhc3MsIHNpbmNlIGl0IGRlcGVuZHMgb24KaXQgKGFuZCBhbHNvIHJlZmVyZW5jZXMgTG9jYWxlRWxlbWVudHNfaGVfSUwpLiAgRm9yIGFub3RoZXIgZXhhbXBsZSwKaWYgeW91IHJlbW92ZSBDb2xsYXRpb25FbGVtZW50c196aF9fUElOWUlOLnJlcywgeW91IG11c3QgYWxzbyByZW1vdmUKTG9jYWxlRWxlbWVudHNfemhfX1BJTllJTi5jbGFzcywgc2luY2UgaXQgZGVwZW5kcyBvbiB0aGUKQ29sbGF0aW9uRWxlbWVudHNfemhfX1BJTllJTi5yZXMuCjwvcD4KCjxwPgpVbmZvcnR1bmF0ZWx5LCB0aGUgamFyIHRvb2wgaW4gdGhlIEpESyBwcm92aWRlcyBubyB3YXkgdG8gcmVtb3ZlIGl0ZW1zCmZyb20gYSBqYXIgZmlsZS4gIFRodXMgeW91IGhhdmUgdG8gZXh0cmFjdCB0aGUgcmVzb3VyY2VzLCByZW1vdmUgdGhlCm9uZXMgeW91IGRvbid0IHdhbnQsIGFuZCB0aGVuIGNyZWF0ZSBhIG5ldyBqYXIgZmlsZSB3aXRoIHRoZSByZW1pbmluZwpyZXNvdXJjZXMuICBTZWUgdGhlIGphciB0b29sIGluZm9ybWF0aW9uIGZvciBob3cgdG8gZG8gdGhpcy4gIEJlZm9yZQoncmVqYXJpbmcnIHRoZSBmaWxlcywgYmUgc3VyZSB0byB0aG9yb3VnaGx5IHRlc3QgeW91ciBhcHBsaWNhdGlvbiB3aXRoCnRoZSByZW1haW5pbmcgcmVzb3VyY2VzLCBtYWtpbmcgc3VyZSBlYWNoIHJlcXVpcmVkIHJlc291cmNlIGlzCnByZXNlbnQuCjwvcD4KCjxoMz5EZXZlbG9waW5nIFJlc291cmNlcyB0byBiZSB1c2VkIHdpdGggSUNVNEo8L2gzPgo8cD4KSUNVNEogMi4xIGFuZCBhYm92ZSB1c2VzIHRoZSBzdGFuZGFyZCBjbGFzcyBsb29rdXAgbWVjaGFuaXNtLiAgVGhpcyBtZWFucwphbnkgcHByb3ByaWF0ZWx5IG5hbWVkIHJlc291cmNlIG9uIHRoZSBDTEFTU1BBVEggd2lsbCBiZSBsb2NhdGVkLCBpbiB0aGUKb3JkZXIgbGlzdGVkIGluIHRoZSBjbGFzc3BhdGguCjwvcD4KPHA+CklmIHlvdSBjcmVhdGUgYSByZXNvdXJjZSBmaWxlCmNvbS5pYm0uaWN1LmltcGwuZGF0YS5Mb2NhbGVFbGVtZW50c194eF9ZWS5jbGFzcywgYW5kIGxpc3QgaXQgb24gdGhlCkNMQVNTUEFUSCBiZWZvcmUgaWN1NGouamFyLCB5b3VyIHJlc291cmNlIHdpbGwgYmUgdXNlZCBpbiBwbGFjZSBvZiBhbnkKZXhpc3RpbmcgTG9jYWxlRWxlbWVudHNfeHhfWVkgcmVzb3VyY2UgaW4gaWN1NGouICBUaGlzIGlzIGEgZ29vZCB3YXkKdG8gdHJ5IG91dCBjaGFuZ2VzIHRvIHJlc291cmNlcy4gIFlvdSBjYW4sIGZvciBleGFtcGxlLCBpbmNsdWRlIHRoZQpyZXNvdXJjZSBpbiB5b3VyIGFwcGxpY2F0aW9uJ3MgamFyIGZpbGUgYW5kIGxpc3QgaXQgYWhlYWQgb2YKaWN1NGouamFyLgo8L3A+CjxwPgpJbiBvcmRlciB0byBjcmVhdGUgbmV3IHJlc291cmNlcywgeW91IGZpcnN0IG11c3QgdGhvcm91Z2hseSB1bmRlcnN0YW5kCnRoZSB2YXJpb3VzIGVsZW1lbnRzIGNvbnRhaW5lZCBpbiB0aGUgcmVzb3VyY2UgZmlsZXMsIHRoZWlyIHN5bnRheCBhbmQKZGVwZW5kZW5jaWVzLiAgWW91IGNhbm5vdCBzaW1wbHkgJ3BhdGNoJyBleGlzdGluZyByZXNvdXJjZSBmaWxlcyB3aXRoCmEgc2luZ2xlIGNoYW5nZSBiZWNhdXNlIHRoZSBuZXcgZmlsZSBjb21wbGV0ZWx5IHJlcGxhY2VzIHRoZSBvbGQgZmlsZQppbiB0aGUgcmVzb3VyY2UgaGllcmFyY2h5LiAgSW4gZ2VuZXJhbCwgdGhlIG5ldyByZXNvdXJjZSBmaWxlIHNob3VsZApjb250YWluIGFsbCB0aGUgZGlmZmVyZW50IGRhdGEgdGhhdCB0aGUgb2xkIG9uZSBkaWQsIHBsdXMgeW91cgpjaGFuZ2VzLgo8L3A+CjxwPgpBZGRpbmcgYSBuZXcgJ2xlYWYnIHJlc291cmNlIGlzIGVhc2llc3QuICBFbGVtZW50cyBkZWZpbmVkIGluIHRoYXQKcmVzb3VyY2Ugd2lsbCBvdmVycmlkZSBjb3JyZXNwb25kaW5nIG9uZXMgaW4gdGhlIHJlc291cmNlcyBmdXJ0aGVyIHVwCnRoZSBoaWVyYXJjaHkuICBUaHVzIHlvdSBjYW4sIGZvciBleGFtcGxlLCB0cnkgb3V0IG5ldyBsb2NhbGl6ZWQgbmFtZXMKb2YgZGF5cyBvZiB0aGUgd2VlaywgYXMgdGhleSBhcmUgYWxsIGNvbnRhaW5lZCBpbiBvbmUgZWxlbWVudC4gIFRoZQp2YXJpYW50IG1lY2hhbmlzbSBjYW4gYmUgdXNlZCB0byB0ZW1wb3JhcmlseSB0cnkgb3V0IG5ldyB2ZXJzaW9ucyBvZgpleGlzdGluZyByZXNvdXJjZSBlbGVtZW50cyAodGhvdWdoIHdlIGRvbid0IHJlY29tbWVuZCBzaGlwcGluZyB0aGlzCndheSkuICBOb3RlIHRob3VnaCB0aGF0IHNvbWUgcmVzb3VyY2VzIGhhdmUgZGV0YWlsZWQgZGVwZW5kZW5jaWVzIG9uCmVhY2ggb3RoZXIsIHNvIHRoYXQgeW91IGNhbm5vdCBzaW1wbHkgYXNzdW1lIHRoYXQgYSBuZXcgZWxlbWVudCB3aXRoCnRoZSBzYW1lIHN0cnVjdHVyZSBhbmQgbnVtYmVyIG9mIGNvbnRlbnRzIHdpbGwgJ2p1c3Qgd29yay4nCjwvcD4KPHA+ClBhdGNoaW5nIGFuICdpbnRlcm5hbCcgcmVzb3VyY2UgKHNheSwgb25lIGNvcnJlc3BvbmRpbmcgdG8gYW4gZXhpc3RpbmcKbGFuZ3VhZ2UgcmVzb3VyY2UgdGhhdCBoYXMgY2hpbGRyZW4pIHJlcXVpcmVzIGNhcmVmdWwgYW5hbHlzaXMgb2YgdGhlCmNvbnRlbnRzIG9mIHRoZSByZXNvdXJjZXMuCjwvcD4KCjxwPgpMb2NhbGVFbGVtZW50cyByZXNvdXJjZSBkYXRhIGluIElDVTRKIGlzIGNoZWNrZWQgaW4gdG8gdGhlCnJlcG9zaXRvcnkgYXMgcHJlY29tcGlsZWQgY2xhc3MgZmlsZXMuICBUaGlzIG1lYW5zIHRoYXQgaW5zcGVjdGluZyB0aGUKY29udGVudHMgb2YgdGhlc2UgcmVzb3VyY2VzIGlzIGRpZmZpY3VsdC4gIFRoZXkgYXJlIGNvbXBpbGVkIGZyb20gamF2YQpmaWxlcyB0aGF0IGluIHR1cm4gYXJlIG1hY2hpbmUtZ2VuZXJhdGVkIGZyb20gSUNVNEMgYmluYXJ5IGRhdGEsIHVzaW5nCnRoZSBnZW5yYiB0b29sIGluIElDVTRDLiAgWW91IGNhbiB2aWV3IHRoZSBjb250ZW50cyBvZiB0aGUgSUNVNEMgdGV4dApyZXNvdXJjZSBmaWxlcyB0byB1bmRlcnN0YW5kIHRoZSBjb250ZW50cyBvZiB0aGUgSUNVNEogcmVzb3VyY2VzLCBhcwp0aGV5IGFyZSB0aGUgc2FtZS4KPC9wPgoKPGgzPkRldmVsb3BpbmcgSUNVNEogUmVzb3VyY2VzPC9oMz4KPHA+CkN1cnJlbnRseSBvbmx5IHRoZSBMb2NhbGVFbGVtZW50cyByZXNvdXJjZSBkYXRhIGlzIHNoYXJlZCwgb3RoZXIgSUNVCnJlc291cmNlcyAoY2FsZW5kYXIsIHRyYW5zbGl0ZXJhdG9yLCBldGMuKSBhcmUgc3RpbGwgY2hlY2tlZCBpbgpkaXJlY3RseSB0byBJQ1U0SiBhcyBzb3VyY2UgZmlsZXMuICBUaGlzIG1lYW5zIHRoYXQgZGV2ZWxvcG1lbnQgYW5kCm1haW50ZW5hbmNlIG9mIHRoZXNlIHJlc291cmNlcyBjb250aW51ZXMgYXMgYmVmb3JlLCBvbmx5CkxvY2FsZUVsZW1lbnRzIHJlc291cmNlIGRhdGEgaGFzIGJlZW4gY2hhbmdlZCBpbiBJQ1U0SiAyLjEuICBUaGlzCnByb2JhYmx5IHdpbGwgY2hhbmdlIGluIHRoZSBmdXR1cmUgb25jZSB3ZSB3b3JrIG91dCBhIHJlYXNvbmFibGUKbWVjaGFuaXNtIGZvciBzdG9yaW5nIGFuZCBnZW5lcmF0aW5nIHRoZSByZXNvdXJjZSBkYXRhLgo8L3A+CjxwPgpPbmUgZ29hbCBvZiB1c2luZyB0aGUgc2FtZSByZXNvdXJjZSBkYXRhIGFzIElDVTRDIGlzIHRvIGF2b2lkIGtlZXBpbmcKcmVkdW5kYW50IGNvcGllcyBvZiB0aGUgcmVzb3VyY2UgZGF0YS4gIEN1cnJlbnRseSB0aGVyZSBpcyBubyBzZXBhcmF0ZQpyZXBvc2l0b3J5IG9mIHRoZSAnbWFzdGVyJyByZXNvdXJjZSBkYXRhLCBpdCBpcyBjaGVja2VkIGluIHRvIElDVTRDLAphbmQgdGhlIHRvb2xzIGZvciBjb252ZXJ0aW5nIGl0IHRvIC5qYXZhIGZpbGVzIGFyZSBJQ1U0QyB0b29scy4gIFRoaXMKaXMgaW5jb252ZW5pZW50IGZvciB3b3JraW5nIGluIEphdmEsIGJ1dCBzaW5jZSBtYWludGVuYW5jZSBvZiBJQ1U0SgphbmQgSUNVNEMgaXMgc3VwcG9zZWQgdG8gZ28gb24gJ2luIHBhcmFsbGVsLCcgYXMgYSBwcmFjdGljYWwgbWF0dGVyCnBlb3BsZSB3aWxsIGhhdmUgdG8gYmUgZmFtaWxpYXIgd2l0aCBkZXZlbG9wbWVudCBpbiBib3RoIEMgYW5kIEphdmEsCmFuZCB3aXRoIHRoZSBjb252ZW50aW9ucyBhbmQgc3RydWN0dXJlIG9mIGVhY2ggcHJvamVjdC4gIEFkZGl0aW9uYWxseSwKc2hhcmluZyBvZiBkYXRhIG1lYW5zIHRoYXQgbW9kaWZpY2F0aW9ucyB0byBkYXRhIGltbWVkaWF0ZWx5IGltcGFjdApib3RoIHByb2plY3RzIChhcyBpdCBzaG91bGQpIGFuZCB0aHVzIGJvdGggcHJvamVjdHMgbmVlZCB0byBiZSB0ZXN0ZWQKd2hlbiBzdWNoIGNoYW5nZXMgYXJlIG1hZGUuICBUaGUgYnVsayBvZiB0aGUgdG9vbHMgYXJlIGN1cnJlbnRseSBvbgp0aGUgSUNVNEMgc2lkZSwgYW5kIHdpbGwgbGlrZWx5IHN0YXkgdGhhdCB3YXksIHNvIHRoaXMgc2VlbXMgbGlrZSBhCnJlYXNvbmFibGUgaW5pdGlhbCBhcHByb2FjaCB0byBzaGFyaW5nIHRoZSBkYXRhLgo8L3A+Cgo8cD4KV2hpbGUgcHJvdG90eXBpbmcgb2YgTG9jYWxlRWxlbWVudHMgZGF0YSBjYW4gb2NjdXIgaW4gZWl0aGVyIEphdmEgb3IKQywgdGhlIGZpbmFsIHZlcnNpb24gc2hvdWxkIGJlIGNoZWNrZWQgaW4gdG8gSUNVNEMgaW4gdGV4dCBmb3JtYXQuCkdlbnJiIGlzIHRoZW4gcnVuIHRvIGdlbmVyYXRlIHRoZSAuamF2YSBhbmQgLnJlcyBmaWxlcy4gIFRoZXkgYXJlIHRoZW4KY29tcGlsZWQgYW5kIGphcidkIGludG8gdGhlIGZpbGUgSUNVTG9jYWxlRGF0YS5qYXIuICBUaGUgcmVzdWx0aW5nIGphcgpmaWxlIGlzIHRoZW4gY2hlY2tlZCBpbiB0byBJQ1U0SiBhcwpzcmMvY29tL2libS9pY3UvZGV2L2RhdGEvSUNVTG9jYWxlRGF0YS5qYXIuICAoVGhpcyBpcyBub3QgZ3JlYXQgYnV0IGl0CmFsbG93cyBJQ1U0SiB0byBiZSBkb3dubG9hZGVkIGFuZCBidWlsdCBhcyBvbmUgcHJvamVjdCwgaW5zdGVhZCBvZgp0d28sIG9uZSBmb3IgbG9jYWxlIGRhdGEgYW5kIG9uZSBmb3IgSUNVNEogcHJvcGVyLiAgR2l2ZW4gdGhlIDIuNApzY2hlZHVsZSBpdCB3YXNuJ3QgcG9zc2libGUgdG8gd29yayBvdXQgdGhlIGxhcmdlciBkYXRhIHNoYXJpbmcKcHJvYmxlbSBpbiB0aW1lLCBzbyB3ZSB0cmllZCB0byBsaW1pdCB0aGUgaW1wYWN0IHRvIGp1c3Qgd2hhdCB3YXMKbmVlZGVkIHRvIGdldCBKREsgMS40IHN1cHBvcnQgdXAgYW5kIHJ1bm5pbmcuKQo8L3A+Cgo8cD4KVGhlIGZpbGVzIGluIElDVUxvY2FsZURhdGEuamFyIGdldCBleHRyYWN0ZWQgdG8gY29tL2libS9pY3UvaW1wbC9kYXRhIGluCnRoZSBidWlsZCBkaXJlY3Rvcnkgd2hlbiB0aGUgJ2NvcmUnIHRhcmdldCBpcyBidWlsdC4gIFRoZXJlYWZ0ZXIsIGFzCmxvbmcgYXMgdGhlIGZpbGUgTG9jYWxlRWxlbWVudHNfaW5kZXguY2xhc3MgZmlsZSBpcyB1bnRvdWNoZWQsIHRoZXkgd2lsbApub3QgYmUgZXh0cmFjdGVkIGFnYWluLiAgQnVpbGRpbmcgdGhlICdyZXNvdXJjZScgdGFyZ2V0IHdpbGwgZm9yY2UgdGhlCnJlc291cmNlcyB0byBvbmNlIGFnYWluIGJlIGV4dHJhY3RlZC4gIEV4dHJhY3Rpb24gd2lsbApvdmVyd3JpdGUgYW55IGNvcnJlc3BvbmRpbmcgLmNsYXNzIGZpbGVzIGFscmVhZHkgaW4gdGhhdCBkaXJlY3RvcnkuCjwvcD4KPGg0PkJ1aWxkaW5nIElDVTRKIFJlc291cmNlcyBmcm9tIElDVTRDPC9oND4KICA8b2w+CiAgICA8bGk+IERvd25sb2FkIGFuZCBidWlsZCBJQ1Ugb24gYSA8Yj5CaWcgRW5kaWFuPC9iPiBtYWNoaW5lIDwvbGk+CiAgICA8bGk+IERvd25sb2FkIGFuZCBidWlsZCBJQ1U0SiBvbiB0aGUgc2FtZSBtYWNoaW5lPC9saT4KICAgIDxsaT4gQ2hhbmdlIGRpcmVjdG9yeSB0byAkaWN1X3Jvb3Rcc291cmNlXHRvb2xzXGdlbnJiICA8L2xpPgogICAgPGxpPiBMYXVuY2ggZ2VucmJqYXIucGwgZnJvbSB0aGF0IGRpcmVjdG9yeSBpdHNlbGYgd2l0aCB0aGUgY29tbWFuZAogICAgICAgIDxicj4KICAgICAgICAgZ2VucmJqYXIucGwgJGljdV9yb290X2RpcjsgJGljdTRqX3Jvb3Q7ICZsdDtsZF9wYXRoX3ZhcmlhYmxlX25hbWUmZ3Q7IFsmbHQ7bG9jYWxlJmd0OytdCiAgICAgICAgPGJyPgogICAgICAgIFRvIGNyZWF0ZSBhbGwgdGhlIGxvY2FsZSBkYXRhIGZpbGVzIG9taXQgdGhlIGxvY2FsZSBhcmd1bWVudAogICAgPC9saT4KICA8L29sPgogIEV4ZWN1dGlvbiBvZiBnZW5yYmphci5wbCBzY3JpcHQgd2lsbCBjcmVhdGUgdGhlIHJlcXVpcmVkIHNvdXJjZSAoKi5qYXZhKSBmaWxlcywKICBjbGFzcyBmaWxlIGFuZCBJQ1VMb2NhbGVEYXRhLmphciBpbiAmbHQ7aWN1X3Jvb3RfZGlyJmd0O1xzb3VyY2VcZGF0YVxsb2NhbGVzXGphdmEgZGlyZWN0b3J5LgoKPGgzPjxhIG5hbWU9IldoZXJlVG9GaW5kTW9yZSI+PC9hPjx1PldoZXJlIHRvIEZpbmQgTW9yZSBJbmZvcm1hdGlvbjwvdT48L2gzPgoKPHA+Rm9yIGluZm9ybWF0aW9uIHNwZWNpZmljIHRvIHRoaXMgY3VycmVudCByZWxlYXNlLCBwbGVhc2UgcmVmZXIgdG8gdGhlIDxhIGhyZWY9InJlbGVhc2Vub3Rlcy5odG1sIj5yZWxlYXNlbm90ZXMuaHRtbDwvYT48L3A+Cgo8cD48YSBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovIj5odHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovPC9hPiBpcyBhCnBvaW50ZXIgdG8gZ2VuZXJhbCBpbmZvcm1hdGlvbiBhYm91dCB0aGUgSW50ZXJuYXRpb25hbCBDb21wb25lbnRzIGZvciBVbmljb2RlIGluIEphdmEgPC9wPgoKPHA+PGEgaHJlZj0iaHR0cDovL3d3dy5pYm0uY29tL2RldmVsb3Blci91bmljb2RlIj5odHRwOi8vd3d3LmlibS5jb20vZGV2ZWxvcGVyL3VuaWNvZGU8L2E+IGlzIGEgcG9pbnRlciB0bwppbmZvcm1hdGlvbiBvbiBob3cgdG8gbWFrZSBhcHBsaWNhdGlvbnMgZ2xvYmFsLiA8L3A+Cgo8aDM+PGEgTkFNRT0iU3VibWl0dGluZ0NvbW1lbnRzIj48L2E+PHU+U3VibWl0dGluZyBDb21tZW50cywgUmVxdWVzdGluZyBGZWF0dXJlcyBhbmQKUmVwb3J0aW5nIEJ1Z3M8L3U+PC9oMz4KCjxwPllvdXIgY29tbWVudHMgYXJlIGltcG9ydGFudCB0byBtYWtpbmcgSUNVNEogc3VjY2Vzc2Z1bC4mbmJzcDsgV2UgYXJlIGNvbW1pdHRlZAp0byBmaXhpbmcgYW55IGJ1Z3MsIGFuZCB3aWxsIHVzZSB5b3VyIGZlZWRiYWNrIHRvIGhlbHAgcGxhbiBmdXR1cmUgcmVsZWFzZXMuPC9wPgoKPHA+VG8gc3VibWl0IGNvbW1lbnRzLCByZXF1ZXN0IGZlYXR1cmVzIGFuZCByZXBvcnQgYnVncywgY29udGFjdCB1cyB0aHJvdWdoIHRoZSA8YSBocmVmPWh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9hcmNoaXZlcy9pbmRleC5odG1sPklDVTRKIG1haWxpbmcgbGlzdDwvYT4uPGJyPgpXaGlsZSB3ZSBhcmUgbm90IGFibGUgdG8gcmVzcG9uZCBpbmRpdmlkdWFsbHkgdG8gZWFjaCBjb21tZW50LCB3ZSBkbyByZXZpZXcgYWxsIGNvbW1lbnRzLjwvcD4KPHA+VGhhbmtzIGZvciB5b3VyIGludGVyZXN0IGluIElDVTRKITwvcD4KCjxociBzaXplPSIyIiB3aWR0aD0iMTAwJSIgYWxpZ249ImNlbnRlciI+Cgo8cD48aT48Zm9udCBzaXplPSItMSI+Q29weXJpZ2h0IKkgMjAwMi0yMDAzIEludGVybmF0aW9uYWwgQnVzaW5lc3MgTWFjaGluZXMgQ29ycG9yYXRpb24gYW5kIG90aGVycy4gQWxsIFJpZ2h0cwpSZXNlcnZlZC48YnI+CjU2MDAgQ290dGxlIFJvYWQsIFNhbiBKb3PpLCBDQSA5NTE5Mwo8L2ZvbnQ+PC9pPjwvcD4KCjwvYm9keT4KPC9odG1sPgo=