PCFkb2N0eXBlIGh0bWwgcHVibGljICItLy93M2MvL2R0ZCBodG1sIDQuMCB0cmFuc2l0aW9uYWwvL2VuIj4KPGh0bWw+Cgo8aGVhZD4KPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9aXNvLTg4NTktMSI+Cjx0aXRsZT5SZWFkTWUgZm9yIElDVTRKPC90aXRsZT4KPCEtLQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiogQ29weXJpZ2h0IChDKSAyMDAwLTIwMDMsIEludGVybmF0aW9uYWwgQnVzaW5lc3MgTWFjaGluZXMgQ29ycG9yYXRpb24gYW5kICAgICoKKiBvdGhlcnMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKgoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCioKKiAkU291cmNlOiAveHNybC9Oc3ZuL2ljdS9pY3U0ai9yZWFkbWUuaHRtbCx2ICQKKiAkRGF0ZTogMjAwMy8wNi8xMyAyMzowMzoxNyAkCiogJFJldmlzaW9uOiAxLjQ3ICQKKgoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCi0tPgo8L2hlYWQ+Cgo8Ym9keSBiZ2NvbG9yPSIjRkZGRkZGIiBsaW5rPSIjMDAwMEZGIiB2bGluaz0iIzgwMDA4MCIgbGFuZz0iRU4tVVMiPgoKICAgIDxoMj5JbnRlcm5hdGlvbmFsIENvbXBvbmVudHMgZm9yIFVuaWNvZGUgZm9yIEphdmE8L2gyPgogICAgPGgzPlJlYWQgTWUgZm9yIElDVTRKIDIuNjwvaDM+Cgo8aHIgc2l6ZT0iMiIgd2lkdGg9IjEwMCUiIGFsaWduPSJjZW50ZXIiPgogICAgPHA+PGI+UmVsZWFzZSBEYXRlPC9iPjxicj4KICAgIEp1bmUgMTN0aCwgMjAwMzwvcD4KCjxwPkZvciB0aGUgbW9zdCByZWNlbnQKICAgICAgcmVsZWFzZSwgc2VlIHRoZSA8YSBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovZG93bmxvYWQvaW5kZXguaHRtbCI+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+Cgo8cD5BZGRpdGlvbmFsbHksIHdlIGhhdmUgYnVpbHQgYW5kIHRlc3RlZCBJQ1U0SiBvbiB0aGUgZm9sbG93aW5nIDxiPnVuc3VwcG9ydGVkPC9iPiBwbGF0Zm9ybXM6Cjx1bD4KPGxpPiBXaW45OCwgV2luTlQsIFdpblhQIC8gSUJNIEpESyAxLjMsIDEuMy4xLCAxLjQuMSwgU3VuIEpESyAxLjMuMSwgMS40LCAxLjQuMTwvbGk+CjxsaT4gV2luMjAwMCAvIElCTSBKREsgMS4zLjEsIDEuNC4xLCBTdW4gSkRLIDEuMy4xLCAxLjQsIDEuNC4xPC9saT4KPGxpPiBTb2xhcmlzIDIuNiAsIFNvbGFyaXMgMi44IC8gU3VuIEpESyAxLjMsIDEuMy4xLCAxLjQsIDEuNC4xPC9saT4KPGxpPiBTb2xhcmlzIDIuNyAvIFN1biBKREsgMS4zLjEsIDEuNCwgMS40LjE8L2xpPgo8bGk+IEFJWCA1LjEsIElCTSBKREsgMS4zLjEsIDEuNC4xPC9saT4KPC91bD4KCjxoMz48YSBOQU1FPSJvYnRhaW5pbmciPjwvYT48dT5Ib3cgdG8gRG93bmxvYWQgSUNVNEo8L3U+PC9oMz4KCjxwPlRoZXJlIGFyZSB0d28gd2F5cyB0byBkb3dubG9hZCB0aGUgSUNVNEogcmVsZWFzZXMuCgo8dWwgdHlwZT0iZGlzYyI+CiAgPGxpPjxiPk9mZmljaWFsIFJlbGVhc2UgU25hcHNob3Q6PC9iPjxicj4KCiAgICBJZiB5b3Ugd2FudCB0byB1c2UgSUNVNEogKGFzIG9wcG9zZWQgdG8gZGV2ZWxvcGluZyBpdCksIHlvdXIgYmVzdAogICAgYmV0IGlzIHRvIGRvd25sb2FkIGFuIG9mZmljaWFsLCBwYWNrYWdlZCB2ZXJzaW9uIG9mIHRoZSBJQ1U0SgogICAgc291cmNlIGNvZGUuJm5ic3A7IFRoZXNlIHZlcnNpb25zIGFyZSB0ZXN0ZWQgbW9yZSB0aG9yb3VnaGx5IHRoYW4KICAgIGRheS10by1kYXkgZGV2ZWxvcG1lbnQgYnVpbGRzLCBhbmQgdGhleSBhcmUgcGFja2FnZWQgaW4gemlwIGZpbGVzCiAgICBmb3IgY29udmVuaWVudCBkb3dubG9hZC4mbmJzcDsgVGhlc2UgcGFja2FnZWQgZmlsZXMgY2FuIGJlIGZvdW5kCiAgICBhdCA8YSBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovZG93bmxvYWQvaW5kZXguaHRtbCI+aHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2ljdTRqL2Rvd25sb2FkL2luZGV4Lmh0bWw8L2E+LiZuYnNwOyBJZiBhIHBhY2thZ2VkIHNuYXBzaG90IGlzIG5hbWVkIDxiPklDVTRKWFhYWFhYLnppcDwvYj4sIHdoZXJlIFhYWFhYWCBpcwogICAgdGhlIHJlbGVhc2UgdmVyc2lvbiBudW1iZXIuJm5ic3A7IFBsZWFzZSB1bnppcCB0aGlzIGZpbGUuJm5ic3A7IEl0CiAgICB3aWxsIHJlY29uc3RydWN0IHRoZSBzb3VyY2UgZGlyZWN0b3J5LiA8L2xpPgo8L3VsPgoKPHVsIHR5cGU9ImRpc2MiPgogIDxsaT48Yj5DVlMgU291cmNlIFJlcG9zaXRvcnk6PC9iPjxicj4KICAgIElmIHlvdSBhcmUgaW50ZXJlc3RlZCBpbiBkZXZlbG9waW5nIGZlYXR1cmVzLCBwYXRjaGVzLCBvciBidWcgZml4ZXMgZm9yIElDVTRKLCB5b3Ugc2hvdWxkCiAgICBwcm9iYWJseSBiZSB3b3JraW5nIHdpdGggdGhlIGxhdGVzdCB2ZXJzaW9uIG9mIHRoZSBJQ1U0SiBzb3VyY2UgY29kZS4gWW91IHdpbGwgbmVlZCB0bwogICAgY2hlY2sgdGhlIGNvZGUgb3V0IG9mIG91ciBDVlMgcmVwb3NpdG9yeSB0byBlbnN1cmUgdGhhdCB5b3UgaGF2ZSB0aGUgbW9zdCByZWNlbnQgdmVyc2lvbgogICAgb2YgYWxsIG9mIHRoZSBmaWxlcy4gVGhlcmUgYXJlIHNldmVyYWwgd2F5cyB0byBkbyB0aGlzOiA8YnI+CiAgICA8dWwgdHlwZT0iY2lyY2xlIj4KICAgICAgPGxpPldlYkNWUzo8YnI+CiAgICAgICAgSWYgeW91IHdhbnQgdG8gYnJvd3NlIHRoZSBjb2RlIGFuZCBvbmx5IG1ha2Ugb2NjYXNpb25hbCBkb3dubG9hZHMsIHlvdSBtYXkgd2FudCB0byB1c2UKICAgICAgICBXZWJDVlMuIEl0IHByb3ZpZGVzIGEgY29udmVuaWVudCwgd2ViLWJhc2VkIGludGVyZmFjZSBmb3IgYnJvd3NpbmcgYW5kIGRvd25sb2FkaW5nIHRoZQogICAgICAgIGxhdGVzdCB2ZXJzaW9uIG9mIHRoZSBJQ1U0SiBzb3VyY2UgY29kZSBhbmQgZG9jdW1lbnRhdGlvbi4gWW91IGNhbiBhbHNvIHZpZXcgZWFjaCBmaWxlJ3MKICAgICAgICByZXZpc2lvbiBoaXN0b3J5LCBkaXNwbGF5IHRoZSBkaWZmZXJlbmNlcyBiZXR3ZWVuIGluZGl2aWR1YWwgcmV2aXNpb25zLCBkZXRlcm1pbmUgd2hpY2gKICAgICAgICByZXZpc2lvbnMgd2VyZSBwYXJ0IG9mIHdoaWNoIG9mZmljaWFsIHJlbGVhc2UsIGFuZCBzbyBvbi4gPGJyPgogICAgICA8L2xpPgogICAgICA8bGk+V2luQ1ZTOjxicj4KICAgICAgICBJZiB5b3Ugd2lsbCBiZSBkb2luZyBzZXJpb3VzIHdvcmsgb24gSUNVNEosIHlvdSBzaG91bGQgcHJvYmFibHkgaW5zdGFsbCBhIENWUyBjbGllbnQgb24KICAgICAgICB5b3VyIG93biBtYWNoaW5lIHNvIHRoYXQgeW91IGNhbiBkbyBiYXRjaCBvcGVyYXRpb25zIHdpdGhvdXQgZ29pbmcgdGhyb3VnaCB0aGUgV2ViQ1ZTCiAgICAgICAgaW50ZXJmYWNlLiBPbiBXaW5kb3dzLCB3ZSBzdWdnZXN0IHRoZSBXaW5DVlMgY2xpZW50LiBUbyBkb3dubG9hZCBJQ1U0SiB2aWEgV2luQ1ZTOiA8b2w+CiAgICAgICAgICA8bGk+SW5zdGFsbCB0aGUgV2luQ1ZTIGNsaWVudCwgd2hpY2ggeW91IGNhbiBkb3dubG9hZCBmcm9tIHRoZSA8YQogICAgICAgICAgICBocmVmPSJodHRwOi8vd3d3LndpbmN2cy5vcmciPmh0dHA6Ly93d3cud2luY3ZzLm9yZzwvYT4uPC9saT4KICAgICAgICAgIDxsaT5TZWxlY3QgPHN0cm9uZz5QcmVmZXJlbmNlczwvc3Ryb25nPiBmcm9tIHRoZSA8c3Ryb25nPkFkbWluPC9zdHJvbmc+IG1lbnUuPG9sIHR5cGU9ImEiPgogICAgICAgICAgICAgIDxsaT5PbiB0aGUgPHN0cm9uZz5HZW5lcmFsPC9zdHJvbmc+IHRhYiBwYW5lbDogU2V0IHlvdXIgPHN0cm9uZz5DVlNST09UPC9zdHJvbmc+IHRvICZxdW90OzxzdHJvbmc+OnBzZXJ2ZXI6YW5vbmN2c0Bvc3Muc29mdHdhcmUuaWJtLmNvbTovdXNyL2N2cy9pY3U0ajwvc3Ryb25nPiZxdW90Oy48YnI+CiAgICAgICAgICAgICAgICBMZWF2ZSBvdGhlciBvcHRpb25zIG9uIHRoaXMgcGFnZSBhdCB0aGVpciBkZWZhdWx0LjwvbGk+CiAgICAgICAgICAgICAgPGxpPk9uIHRoZSA8c3Ryb25nPlBvcnRzPC9zdHJvbmc+IHRhYiBwYW5lbDogQ2hlY2sgdGhlIDxzdHJvbmc+cHNlcnZlcjwvc3Ryb25nPiBjaGVja2JveCBhbmQKICAgICAgICAgICAgICAgIGVudGVyIHBvcnQgPHN0cm9uZz4yNDAxPC9zdHJvbmc+LjwvbGk+CiAgICAgICAgICAgIDwvb2w+CiAgICAgICAgICA8L2xpPgogICAgICAgICAgPGxpPkNsaWNrIG9uIHRoZSBMb2dpbiBtZW51IGJ1dHRvbiAoPHN0cm9uZz5BZG1pbjwvc3Ryb25nPiBtZW51KS4gRW50ZXIgaW4gICZxdW90OzxzdHJvbmc+YW5vbmN2czwvc3Ryb25nPiZxdW90OyB3aGVuIHJlcXVlc3RlZC48L2xpPgogICAgICAgICAgPGxpPlRvIGV4dHJhY3QgdGhlIG1vc3QgcmVjZW50IHZlcnNpb24gb2YgSUNVNEosIHNlbGVjdCA8c3Ryb25nPkNoZWNrb3V0IG1vZHVsZTwvc3Ryb25nPgogICAgICAgICAgICBmcm9tIHRoZSA8c3Ryb25nPkNyZWF0ZTwvc3Ryb25nPiBtZW51LiBTcGVjaWZ5ICZxdW90OzxzdHJvbmc+aWN1NGo8L3N0cm9uZz4mcXVvdDsgZm9yIHRoZQogICAgICAgICAgICBtb2R1bGUgbmFtZS4gVGhpcyB3aWxsIGNyZWF0ZSBhIG5ldyBjb3B5IG9mIHRoZSB3b3Jrc3BhY2Ugb24geW91ciBsb2NhbCBoYXJkIGRyaXZlLjwvbGk+CiAgICAgICAgICA8bGk+SW4gdGhlIGZ1dHVyZSwgeW91IGNhbiBkb3dubG9hZCB1cGRhdGVkIGZpbGVzIGZyb20gdGhlIHJlcG9zaXRvcnkgdG8geW91ciBoYXJkIGRyaXZlCiAgICAgICAgICAgIHVzaW5nIHRoZSA8c3Ryb25nPlVwZGF0ZSBzZWxlY3Rpb248L3N0cm9uZz4gaXRlbSBpbiB0aGUgPHN0cm9uZz5Nb2RpZnk8L3N0cm9uZz4gbWVudS48YnI+CiAgICAgICAgICA8L2xpPgogICAgICAgIDwvb2w+CiAgICAgIDwvbGk+CiAgICAgIDxsaT5DVlMgY29tbWFuZCBsaW5lOjxicj4KICAgICAgICBZb3UgY2FuIGFsc28gY2hlY2sgb3V0IHRoZSByZXBvc2l0b3J5IGFub255bW91c2x5IG9uIFVOSVggdXNpbmcgdGhlIGZvbGxvd2luZyBjb21tYW5kcywKICAgICAgICBhZnRlciBmaXJzdCBzZXR0aW5nIHlvdXIgQ1ZTUk9PVCB0byBwb2ludCB0byB0aGUgSUNVNEogcmVwb3NpdG9yeTogPHByZT48Y29kZT5leHBvcnQgQ1ZTUk9PVD06cHNlcnZlcjphbm9uY3ZzQG9zcy5zb2Z0d2FyZS5pYm0uY29tOi91c3IvY3ZzL2ljdTRqCmN2cyBsb2dpbiBDVlMgcGFzc3dvcmQ6IGFub25jdnMKY3ZzIGNoZWNrb3V0IGljdTRqCmN2cyBsb2dvdXQ8L2NvZGU+PC9wcmU+CiAgICAgIDwvbGk+CiAgICA8L3VsPgogIDwvbGk+CjwvdWw+Cgo8cD5Gb3IgbW9yZSBkZXRhaWxzIG9uIGhvdyB0byBkb3dubG9hZCBJQ1U0SiBkaXJlY3RseSBmcm9tIHRoZSB3ZWIgc2l0ZSwgcGxlYXNlIGFsc28gc2VlIDxhCmhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb3dubG9hZC9pbmRleC5odG1sIj5odHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovZG93bmxvYWQvaW5kZXguaHRtbDwvYT4KPC9wPgoKPGgzPjxhIE5BTUU9IldoYXRDb250YWluIj48L2E+PHU+VGhlIFN0cnVjdHVyZSBhbmQgQ29udGVudHMgb2YgSUNVNEo8L3U+PC9oMz4KCjxwPkJlbG93LCA8Yj4kUm9vdDwvYj4gaXMgdGhlIHBsYWNlbWVudCBvZiB0aGUgaWN1IGRpcmVjdG9yeSBpbiB5b3VyIGZpbGUgc3lzdGVtLCBsaWtlCiZxdW90O2RyaXZlOlwuLi5caWN1NGomcXVvdDsgaW4geW91ciBlbnZpcm9ubWVudC4gJnF1b3Q7ZHJpdmU6XC4uLiZxdW90OyBzdGFuZHMgZm9yIGFueQpkcml2ZSBhbmQgYW55IGRpcmVjdG9yeSBvbiB0aGF0IGRyaXZlIHRoYXQgeW91IGNob3NlIHRvIGluc3RhbGwgaWN1NGogaW50by4gPC9wPgoKPHA+PGI+SW5mb3JtYXRpb24gYW5kIGJ1aWxkIGZpbGVzOjwvYj48L3A+Cgo8dGFibGUgQk9SREVSPSIxIiBDRUxMUEFERElORz0iMyI+CiAgPHRyPgogICAgPHRkPnJlYWRtZS5odG1sPGJyPgogICAgICAgICh0aGlzIGZpbGUpPC90ZD4KICAgIDx0ZD5BIGRlc2NyaXB0aW9uIG9mIElDVTRKIChJbnRlcm5hdGlvbmFsIENvbXBvbmVudHMgZm9yIFVuaWNvZGUgZm9yIEphdmEpPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0ZD5yZWxlYXNlbm90ZXMuaHRtbAogICAgPHRkPkEgZGVzY3JpcHRpb24gb2YgZmVhdHVyZXMgYW5kIGNoYW5nZXMgaW4gdGhpcyBhbmQgcHJpb3IgcmVsZWFzZXMgb2YgSUNVNEo8L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPmxpY2Vuc2UuaHRtbDwvdGQ+CiAgICA8dGQ+VGhlIFggbGljZW5zZSwgdXNlZCBieSBJQ1U0SjwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+YnVpbGQuYmF0PC90ZD4KICAgIDx0ZD5BIGNvbnZlbmllbmNlIGJhdCBmaWxlIGZvciBidWlsZGluZyBJQ1U0SiB3aXRoIEFudCBvbiBXaW5kb3dzPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0ZD5idWlsZC5zaDwvdGQ+CiAgICA8dGQ+QSBjb252ZW5pZW5jZSBzaCBmaWxlIGZvciBidWlsZGluZyBJQ1U0SiB3aXRoIEFudCBvbiBVbml4PC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0ZD5idWlsZC54bWw8L3RkPgogICAgPHRkPkFudCBidWlsZCBmaWxlLiBTZWUgPGEgaHJlZj0iI0hvd1RvSW5zdGFsbEphdmFjIj5Ib3cgdG8gSW5zdGFsbCBhbmQgQnVpbGQ8L2E+IGZvciBtb3JlIGluZm9ybWF0aW9uPC90ZD4KICA8L3RyPgo8L3RhYmxlPgoKPHA+PGI+VGhlIHNvdXJjZSBkaXJlY3RvcmllcyBtaXJyb3IgdGhlIHBhY2thZ2Ugc3RydWN0dXJlIG9mIHRoZSBjb2RlLjwvYj48YnI+PGZvbnQgY29sb3I9InJlZCI+Q29yZTwvZm9udD4gcGFja2FnZXMgYmVjb21lIHBhcnQgb2YgdGhlIElDVTRKIGphciBmaWxlLjxicj48Zm9udCBjb2xvcj0icmVkIj5BUEk8L2ZvbnQ+IHBhY2thZ2VzIGNvbnRhaW4gY2xhc3NlcyB3aXRoIHN1cHBvcnRlZCBBUEkuIDxicj48Zm9udCBjb2xvcj0icmVkIj5SaWNoVGV4dDwvZm9udD4gY2xhc3NlcyBhcmUgQ29yZSBhbmQgQVBJLCBidXQgY2FuIGJlIHJlbW92ZWQgZnJvbSBpY3U0ai5qYXIsIGFuZCBjYW4gYmUgYnVpbHQgaW50byB0aGVpciBvd24gamFyLjwvcD4KCjx0YWJsZSBCT1JERVI9IjEiIENFTExQQURESU5HPSIzIiBXSURUSD0iNjIzIj4KICA8dHI+CiAgICA8dGQ+JFJvb3Qvc3JjL2NvbS9pYm0vaWN1L2Rldjxicj48Zm9udCBjb2xvcj0icmVkIj5Ob24tQ29yZSwgTm9uLUFQSTwvZm9udD48L3RkPgogICAgPHRkPlBhY2thZ2VzIHVzZWQgZm9yIGludGVybmFsIGRldmVsb3BtZW50OgogICAgPHVsPgogICAgPGxpPkRhdGE6IGRhdGEgdXNlZCBieSB0ZXN0cyBhbmQgaW4gYnVpbGRpbmcgSUNVPC9saT4KICAgIDxsaT5EZW1vczogQ2FsZW5kYXIsIEhvbGlkYXksIEJyZWFrIEl0ZXJhdG9yLCBSdWxlLWJhc2VkIE51bWJlciBGb3JtYXQsIFRyYW5zZm9ybWF0aW9uczxicj4oU2VlIDxhIGhyZWY9IiN0cnlpbmdvdXQiPmJlbG93PC9hPiBmb3IgbW9yZSBpbmZvcm1hdGlvbiBhYm91dCB0aGUgZGVtb3MuKTwvbGk+CiAgICA8bGk+VGVzdHM6IEFQSSBhbmQgY292ZXJhZ2UgdGVzdHMgb2YgYWxsIGZ1bmN0aW9uYWxpdHkuPGJyPkZvciBpbmZvcm1hdGlvbiBhYm91dCBydW5uaW5nIHRoZSB0ZXN0cywgc2VlICRSb290L3NyYy9jb20vaWJtL2ljdS9kZXYvdGVzdC9UZXN0QWxsLmphdmEuPC9saT4KICAgIDxsaT5Ub29sczogdG9vbHMgdXNlZCB0byBidWlsZCBkYXRhIHRhYmxlcywgZXRjLjwvbGk+PC91bD48L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPiRSb290L3NyYy9jb20vaWJtL2ljdS9pbXBsPGJyPjxmb250IGNvbG9yPSJyZWQiPkNvcmUsIE5vbi1BUEk8L2ZvbnQ+PC90ZD4KICAgIDx0ZD5UaGVzZSBhcmUgdXRpbGl0eSBjbGFzc2VzIHVzZWQgZnJvbSBkaWZmZXJlbnQgSUNVNEogY29yZSBwYWNrYWdlcy48L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPiRSb290L3NyYy9jb20vaWJtL2ljdS9sYW5nPGJyPjxmb250IGNvbG9yPSJyZWQiPkNvcmUsIEFQSTwvZm9udD48L3RkPgogICAgPHRkPkNoYXJhY3RlciBwcm9wZXJ0aWVzIHBhY2thZ2UuPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0ZD4kUm9vdC9zcmMvY29tL2libS9pY3UvbWF0aDxicj48Zm9udCBjb2xvcj0icmVkIj5Db3JlLCBBUEk8L2ZvbnQ+PC90ZD4KICAgIDx0ZD5BZGRpdGlvbmFsIG1hdGggY2xhc3Nlcy48L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPiRSb290L3NyYy9jb20vaWJtL2ljdS90ZXh0PGJyPjxmb250IGNvbG9yPSJyZWQiPkNvcmUsIEFQSTwvZm9udD48L3RkPgogICAgPHRkPkFkZGl0aW9uYWwgdGV4dCBjbGFzc2VzLiAgVGhlc2UgYWRkIHRvLCBhbmQgaW4gc29tZSBjYXNlcyByZXBsYWNlLCByZWxhdGVkIGNvcmUgSmF2YSBjbGFzc2VzOgogICAgICA8dWw+CiAgICAgIDxsaT5BcmFiaWMgc2hhcGluZwogICAgICA8bGk+QnJlYWsgaXRlcmF0aW9uCiAgICAgIDxsaT5EYXRlIGZvcm1hdHRpbmcKICAgICAgPGxpPk51bWJlciBmb3JtYXR0aW5nCiAgICAgIDxsaT5UcmFuc2xpdGVyYXRpb24KICAgICAgPGxpPk5vcm1hbGl6YXRpb24KICAgICAgPGxpPlN0cmluZyBtYW5pcHVsYXRpb24KICAgICAgPGxpPkNvbGxhdGlvbgogICAgICA8bGk+U3RyaW5nIHNlYXJjaAogICAgICA8bGk+VW5pY29kZSBjb21wcmVzc2lvbgogICAgICA8bGk+VW5pY29kZSBzZXRzCiAgICA8L3VsPgogICAgPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0ZD4kUm9vdC9zcmMvY29tL2libS9pY3UvdXRpbDxicj48Zm9udCBjb2xvcj0icmVkIj5Db3JlLCBBUEk8L2ZvbnQ+PC90ZD4KICAgIDx0ZD5BZGRpdGlvbmFsIHV0aWxpdHkgY2xhc3NlczoKICAgIDx1bD4KICAgIDxsaT5DYWxlbmRhcnMgLSBHcmVnb3JpYW4sIEJ1ZGRoaXN0LCBIZWJyZXcsIElzbGFtaWMsIEphcGFuZXNlCiAgICA8bGk+SG9saWRheTwvbGk+CiAgICA8bGk+VGltZVpvbmU8L2xpPgogICAgPGxpPlZlcnNpb25JbmZvPC9saT4KICAgIDxsaT5JdGVyYXRpb248L2xpPgogICAgPC91bD4KICAgIDwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+JFJvb3Qvc3JjL2NvbS9pYm0vcmljaHRleHQ8YnI+PGZvbnQgY29sb3I9InJlZCI+UmljaFRleHQ8L2ZvbnQ+PC90ZD4KICAgIDx0ZD5TdHlsZWQgdGV4dCBlZGl0aW5nCiAgICBwYWNrYWdlLiBUaGlzIGluY2x1ZGVzIGRlbW9zLCB0ZXN0cywgYW5kIEdVSXMgZm9yIGVkaXRpbmcgYW5kCiAgICBkaXNwbGF5aW5nIHN0eWxlZCB0ZXh0LiAgVGhlIHJpY2h0ZXh0IHBhY2thZ2UgcHJvdmlkZXMgYQogICAgc2Nyb2xsYWJsZSBkaXNwbGF5LCB0eXBpbmcsIGFycm93LWtleSBzdXBwb3J0LCB0YWJzLCBhbGlnbm1lbnQgYW5kCiAgICBqdXN0aWZpY2F0aW9uLCB3b3JkLSBhbmQgc2VudGVuY2Utc2VsZWN0aW9uIChieSBkb3VibGUtY2xpY2tpbmcKICAgIGFuZCB0cmlwbGUtY2xpY2tpbmcsIHJlc3BlY3RpdmVseSksIHRleHQgc3R5bGVzLCBjbGlwYm9hcmQKICAgIG9wZXJhdGlvbnMgKGN1dCwgY29weSBhbmQgcGFzdGUpIGFuZCBhIGxvZyBvZiBjaGFuZ2VzIGZvcgogICAgdW5kby1yZWRvLiAgUmljaHRleHQgdXNlcyBKYXZhJ3MgVGV4dExheW91dCBhbmQgY29tcGxleAogICAgdGV4dCBzdXBwb3J0IChwcm92aWRlZCB0byBTdW4gYnkgdGhlIElDVTRKIHRlYW0pLjwvdGQ+CiAgPC90cj4KPC90YWJsZT4KCjxwPjxiPkJ1aWxkaW5nIElDVTRKIGNyZWF0ZXMgYW5kIHBvcHVsYXRlcyB0aGUgZm9sbG93aW5nIGRpcmVjdG9yaWVzOjwvYj4gPC9wPgoKPHRhYmxlIEJPUkRFUj0iMSIgQ0VMTFBBRERJTkc9IjMiPgogIDx0cj4KICAgIDx0ZD4kUm9vdC9jbGFzc2VzPC90ZD4KICAgIDx0ZD5jb250YWlucyBhbGwgY2xhc3MgZmlsZXM8L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPiRSb290L2RvYzwvdGQ+CiAgICA8dGQ+Y29udGFpbnMgSmF2YURvYyBmb3IgYWxsIHBhY2thZ2VzPC90ZD4KICA8L3RyPgo8L3RhYmxlPgoKPHA+PGI+RGF0YSBvcmdhbml6YXRpb246PC9iPiA8L3A+Cgo8cD5JQ1U0SiBkYXRhIGlzIHN0b3JlZCBpbiB0aGUgZm9sbG93aW5nIGxvY2F0aW9uczoKCjx0YWJsZSBCT1JERVI9IjEiIENFTExQQURESU5HPSIzIiBXSURUSD0iNjIzIj4KICA8dHI+CiAgICA8dGQ+PGNvZGU+Y29tLmlibS5pY3UuaW1wbC5kYXRhPC9jb2RlPjwvdGQ+CiAgICA8dGQ+SG9sZHMgZGF0YSB1c2VkIGJ5IHRoZSBJQ1U0SiBjb3JlIHBhY2thZ2VzICg8Y29kZT5jb20uaWJtLmljdS5sYW5nPC9jb2RlPiwgPGNvZGU+Y29tLmlibS5pY3UudGV4dDwvY29kZT4sIDxjb2RlPmNvbS5pYm0uaWN1LnV0aWw8L2NvZGU+LCA8Y29kZT5jb20uaWJtLmljdS5tYXRoPC9jb2RlPiBhbmQgPGNvZGU+Y29tLmlibS5pY3UudGV4dDwvY29kZT4pLiBJbiBwYXJ0aWN1bGFyLCBhbGwgcmVzb3VyY2UgaW5mb3JtYXRpb24gaXMgc3RvcmVkIGhlcmUuPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0ZD48Y29kZT5jb20uaWJtLmljdS5kZXYuZGF0YTwvY29kZT48L3RkPgogICAgPHRkPkhvbGRzIGRhdGEgdGhhdCBpcyBub3QgcGFydCBvZiBJQ1U0SiBjb3JlLCBidXQgcmF0aGVyIHBhcnQgb2YgYSB0ZXN0LCBzYW1wbGUsIG9yIGRlbW8uPC90ZD4KICA8L3RyPgo8L3RhYmxlPgoKPGgzPjx1PjxhIG5hbWU9IkFQSSI+PC9hPldoZXJlIHRvIGdldCBEb2N1bWVudGF0aW9uPC91PjwvaDM+Cgo8cD5UaGUgPGEgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2ljdS91c2VyZ3VpZGUvIj5JQ1UgdXNlcidzIGd1aWRlPC9hPiBjb250YWlucyBsb3RzIG9mIGdlbmVyYWwgaW5mb3JtYXRpb24gYWJvdXQgSUNVLCBpbiBpdHMgQywgQysrLCBhbmQgSmF2YSBpbmNhcm5hdGlvbnMuPC9wPgoKPHA+VGhlIGNvbXBsZXRlIEFQSSBkb2N1bWVudGF0aW9uIGZvciBJQ1U0SiAoamF2YWRvYykgaXMgYXZhaWxhYmxlIG9uIHRoZSBJQ1U0SiB3ZWIgc2l0ZSwgYW5kIGNhbiBiZSBidWlsdCBmcm9tIHRoZSBzb3VyY2VzOgoKPHVsPgogIDxsaT48YSBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovZG9jL2luZGV4Lmh0bWwiPkluZGV4IHRvIGFsbCBJQ1U0SiBBUEk8L2E+PC9saT4KICA8bGk+SW50ZXJuYXRpb25hbCBDYWxlbmRhcnMgJiMxNTA7IDxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb2MvY29tL2libS9pY3UvdXRpbC9Jc2xhbWljQ2FsZW5kYXIuaHRtbCI+SXNsYW1pYzwvYT4sCiAgICA8YSBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovZG9jL2NvbS9pYm0vaWN1L3V0aWwvQnVkZGhpc3RDYWxlbmRhci5odG1sIj5CdWRkaGlzdDwvYT4sIDxhCiAgICBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovZG9jL2NvbS9pYm0vaWN1L3V0aWwvSGVicmV3Q2FsZW5kYXIuaHRtbCI+SGVicmV3PC9hPiwgPGEKICAgIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb2MvY29tL2libS9pY3UvdXRpbC9KYXBhbmVzZUNhbGVuZGFyLmh0bWwiPkphcGFuZXNlPC9hPi48L2xpPgogIDxsaT48YSBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovZG9jL2NvbS9pYm0vaWN1L3RleHQvTm9ybWFsaXplci5odG1sIj5Vbmljb2RlIE5vcm1hbGl6YXRpb248L2E+ICYjMTUwOwogICAgQ2Fub25pY2FsIHRleHQgcmVwcmVzZW50YXRpb24gZm9yIFczQy48L2xpPgogIDxsaT48YSBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovZG9jL2NvbS9pYm0vaWN1L3RleHQvTnVtYmVyRm9ybWF0Lmh0bWwiPk51bWJlciBGb3JtYXQgRW5oYW5jZW1lbnRzPC9hPiAmIzE1MDsKICAgIFNjaWVudGlmaWMgTm90YXRpb24sIFNwZWxsZWQgb3V0LjwvbGk+CiAgPGxpPjxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb2MvY29tL2libS9pY3UvdGV4dC9CcmVha0l0ZXJhdG9yLmh0bWwiPkVuaGFuY2VkIHdvcmQtYnJlYWsgZGV0ZWN0aW9uPC9hPgogICAgJiMxNTA7IFJ1bGUtYmFzZWQsIHN1cHBvcnRzIFRoYWk8L2xpPgo8bGk+PGEgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2ljdTRqL2RvYy9jb20vaWJtL2ljdS90ZXh0L1RyYW5zbGl0ZXJhdG9yLmh0bWwiPlRyYW5zbGl0ZXJhdGlvbjwvYT4gJiMxNTA7IEEgZ2VuZXJhbCBmcmFtZXdvcmsgZm9yIG9udmVydGluZyB0ZXh0IGZyb20gb25lIGZvcm1hdCB0byBhbm90aGVyLCBlLmcuIEN5cmlsbGljIHRvIExhdGluLCBvciBIZXggdG8gVW5pY29kZS4KICA8bGk+VW5pY29kZSBUZXh0IDxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb2MvY29tL2libS9pY3UvdGV4dC9Vbmljb2RlQ29tcHJlc3Nvci5odG1sIj5Db21wcmVzc2lvbjwvYT4gJmFtcDsKICAgIDxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb2MvY29tL2libS9pY3UvdGV4dC9Vbmljb2RlRGVjb21wcmVzc29yLmh0bWwiPkRlY29tcHJlc3Npb248L2E+ICYjMTUwOyAyOjEKICAgIGNvbXByZXNzaW9uIG9uIEVuZ2xpc2ggVW5pY29kZSB0ZXh0LjwvbGk+CiAgPGxpPkNvbGxhdGlvbiAtIDxhIGhyZWY9Imh0dHA6Ly9vc3Muc29mdHdhcmUuaWJtLmNvbS9pY3U0ai9kb2MvY29tL2libS9pY3UvdGV4dC9SdWxlQmFzZWRDb2xsYXRvci5odG1sIj5SdWxlLWJhc2VkIHNvcnRpbmc8L2E+LCA8YSBocmVmPSJodHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovZG9jL2NvbS9pYm0vaWN1L3RleHQvU3RyaW5nU2VhcmNoLmh0bWwiPkVmZmljaWVudCBtdWx0aS1saW5ndWFsIHNlYXJjaGluZzwvYT4gPC9saT4KPC91bD4KCjxoMz48YSBOQU1FPSJIb3dUb0luc3RhbGxKYXZhYyI+PC9hPjx1PkhvdyB0byBJbnN0YWxsIGFuZCBCdWlsZDwvdT48L2gzPgoKPHA+VG8gaW5zdGFsbCBJQ1U0Siwgc2ltcGx5IHBsYWNlIHRoZSBwcmVidWlsdCBqYXIgZmlsZSA8c3Ryb25nPmljdTRqLmphcjwvc3Ryb25nPiBvbiB5b3VyCkphdmEgQ0xBU1NQQVRILiZuYnNwOyBObyBvdGhlciBmaWxlcyBhcmUgbmVlZGVkLjwvcD4KCjxwPlRvIGJ1aWxkIElDVTRKLCB5b3Ugd2lsbCBuZWVkIGEgSmF2YTIgSkRLIGFuZCB0aGUgQW50IGJ1aWxkIHN5c3RlbS4KV2Ugc3Ryb25nbHkgcmVjb21tZW5kIHVzaW5nIHRoZSBBbnQgYnVpbGQgc3lzdGVtIHRvIGJ1aWxkIElDVTRKOjwvcD4KCjx1bD4KICA8bGk+SXQncyByZWNvbW1lbmRlZCB0byBpbnN0YWxsIGJvdGggdGhlIEpESyBhbmQgQW50IHNvbWV3aGVyZSA8ZW0+b3V0c2lkZTwvZW0+IHRoZSBJQ1U0SgogICAgZGlyZWN0b3J5LiBGb3IgZXhhbXBsZSwgb24gTGludXggeW91IG1pZ2h0IGluc3RhbGwgdGhlc2UKICAgIGluIC91c3IvbG9jYWwuPC9saT4KICA8bGk+SW5zdGFsbCBhIHJlY2VudCBKREssIHZlcnNpb24gMS4zLnggb3IgMS40Lnggd2lsbCB3b3JrLjwvbGk+CiAgPGxpPjxwPk5leHQgaW5zdGFsbCB0aGUgPGEgaHJlZj0iaHR0cDovL2FudC5hcGFjaGUub3JnLyI+PHN0cm9uZz5BbnQ8L3N0cm9uZz48L2E+IGJ1aWxkCiAgICBzeXN0ZW0uIEFudCBpcyBhIHBvcnRhYmxlLCBKYXZhLWJhc2VkIGJ1aWxkIHN5c3RlbSBzaW1pbGFyIHRvIG1ha2UuIElDVTRKIHVzZXMgQW50CiAgICBiZWNhdXNlIGl0IGludHJvZHVjZXMgbm8gb3RoZXIgZGVwZW5kZW5jaWVzLCBpdCdzIHBvcnRhYmxlLCBhbmQgaXQncyBlYXNpZXIgdG8gbWFuYWdlIHRoYW4KICAgIGEgY29sbGVjdGlvbiBvZiBtYWtlZmlsZXMuIFdlIGN1cnJlbnRseSBidWlsZCBJQ1U0SiB1c2luZyBhIHNpbmdsZSBtYWtlZmlsZSBvbiBib3RoCiAgICBXaW5kb3dzIDl4IGFuZCBMaW51eCB1c2luZyBBbnQuICBUaGUgYnVpbGQgc3lzdGVtIHJlcXVpcmVzIEFudCAxLjQgb3IgbGF0ZXIuPC9wPgogICAgPHA+SW5zdGFsbGluZyBBbnQgaXMgc3RyYWlnaHRmb3J3YXJkLiBEb3dubG9hZCBpdCAoc2VlIDxhCiAgICBocmVmPSJodHRwOi8vYW50LmFwYWNoZS5vcmcvYmluZG93bmxvYWQuY2dpIj5odHRwOi8vYW50LmFwYWNoZS5vcmcvYmluZG93bmxvYWQuY2dpPC9hPiksCiAgICBleHRyYWN0IGl0IG9udG8geW91ciBzeXN0ZW0sIHNldCBzb21lIGVudmlyb25tZW50IHZhcmlhYmxlcywgYW5kIGFkZCBpdHMgYmluIGRpcmVjdG9yeSB0bwogICAgeW91ciBwYXRoLiBGb3IgZXhhbXBsZToKPHByZT4gICAgc2V0IEpBVkFfSE9NRT1DOlxqZGsxLjMuMQogICAgc2V0IEFOVF9IT01FPUM6XGFudAogICAgc2V0IFBBVEg9JVBBVEglOyVBTlRfSE9NRSVcYmluPC9wcmU+PC9wPgogICAgPHA+U2VlIHRoZSBjdXJyZW50IEFudCBkb2N1bWVudGF0aW9uIGZvciBkZXRhaWxzLjwvcD4KICA8L2xpPgo8L3VsPgoKPHA+T25jZSB0aGUgSkRLIGFuZCBBbnQgYXJlIGluc3RhbGxlZCwgYnVpbGRpbmcgaXMganVzdCBhIG1hdHRlciBvZgp0eXBpbmcgPHN0cm9uZz5hbnQ8L3N0cm9uZz4gaW4gdGhlIElDVTRKIHJvb3QgZGlyZWN0b3J5LiBUaGlzIGNhdXNlcwp0aGUgQW50IGJ1aWxkIHN5c3RlbSB0byBwZXJmb3JtIGEgYnVpbGQgYXMgc3BlY2lmaWVkIGJ5IHRoZSBmaWxlCjxzdHJvbmc+YnVpbGQueG1sPC9zdHJvbmc+LCBsb2NhdGVkIGluIHRoZSBJQ1U0SiByb290IGRpcmVjdG9yeS4gWW91CmNhbiBnaXZlIEFudCBvcHRpb25zIGxpa2UgLXZlcmJvc2UsIGFuZCB5b3UgY2FuIHNwZWNpZnkgdGFyZ2V0cy4gQW50CndpbGwgb25seSBidWlsZCB3aGF0J3MgYmVlbiBjaGFuZ2VkIGFuZCB3aWxsIHJlc29sdmUgZGVwZW5kZW5jaWVzCnByb3Blcmx5LiAgRm9yIGV4YW1wbGU6PC9wPgo8YmxvY2txdW90ZT4KICA8cHJlPkY6XGljdTRqJmd0O2FudCB0ZXN0cwpCdWlsZGZpbGU6IGJ1aWxkLnhtbApQcm9qZWN0IGJhc2UgZGlyIHNldCB0bzogRjpcaWN1NGoKRXhlY3V0aW5nIFRhcmdldDogY29yZQpDb21waWxpbmcgNzEgc291cmNlIGZpbGVzIHRvIEY6XGljdTRqXGNsYXNzZXMKRXhlY3V0aW5nIFRhcmdldDogdGVzdHMKQ29tcGlsaW5nIDI0IHNvdXJjZSBmaWxlcyB0byBGOlxpY3U0alxjbGFzc2VzCkNvbXBsZXRlZCBpbiAxOSBzZWNvbmRzPC9wcmU+CjwvYmxvY2txdW90ZT4KCjxwPlRoZSBmb2xsb3dpbmcgYXJlIHNvbWUgdGFyZ2V0cyB0aGF0IHlvdSBjYW4gZ2l2ZSBhZnRlciA8c3Ryb25nPmFudDwvc3Ryb25nPi4gIEZvciBtb3JlCnRhcmdldHMsIHNlZSB0aGUgYnVpbGQueG1sIGZpbGU6PC9wPgo8ZGl2IGFsaWduPSJsZWZ0Ij4KCjx0YWJsZSBib3JkZXI9IjEiIGNlbGxwYWRkaW5nPSIwIj4KICA8dHI+CiAgICA8dGQ+YWxsPC90ZD4KICAgIDx0ZD5CdWlsZCBhbGwgdGFyZ2V0cy48L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPmNvcmU8L3RkPgogICAgPHRkPkJ1aWxkIHRoZSBtYWluIGNsYXNzIGZpbGVzIGluIHRoZSBzdWJkaXJlY3RvcnkgPHN0cm9uZz5jbGFzc2VzPC9zdHJvbmc+LiBJZiBubyB0YXJnZXQKICAgIGlzIHNwZWNpZmllZCwgY29yZSBpcyBhc3N1bWVkLjwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+dGVzdHM8L3RkPgogICAgPHRkPkJ1aWxkIHRoZSB0ZXN0IGNsYXNzIGZpbGVzLjwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+ZGVtb3M8L3RkPgogICAgPHRkPkJ1aWxkIHRoZSBkZW1vcy48L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPnRvb2xzPC90ZD4KICAgIDx0ZD5CdWlsZCB0aGUgdG9vbHMuPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0ZD5kb2NzPC90ZD4KICAgIDx0ZD5SdW4gamF2YWRvYyBvdmVyIHRoZSBtYWluIGNsYXNzIGZpbGVzLCBnZW5lcmF0aW5nIGFuIEhUTUwgZG9jdW1lbnRhdGlvbiB0cmVlIGluIHRoZQogICAgc3ViZGlyZWN0b3J5IDxzdHJvbmc+ZG9jPC9zdHJvbmc+LjwvdGQ+CiAgPC90cj4KICA8dHI+CiAgICA8dGQ+amFyPC90ZD4KICAgIDx0ZD5DcmVhdGUgYSBqYXIgYXJjaGl2ZSA8c3Ryb25nPmljdTRqLmphcjwvc3Ryb25nPiBpbiB0aGUgcm9vdCBJQ1U0SiBkaXJlY3RvcnkgY29udGFpbmluZwogICAgdGhlIG1haW4gY2xhc3MgZmlsZXMuPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0ZD56aXA8L3RkPgogICAgPHRkPkNyZWF0ZSBhIHppcCBhcmNoaXZlIG9mIHRoZSBzb3VyY2UsIGRvY3MsIGFuZCBqYXIgZmlsZSBmb3IgZGlzdHJpYnV0aW9uLiBUaGUgemlwIGZpbGUgPHN0cm9uZz5pY3U0allZWVlNTURELnppcDwvc3Ryb25nPgogICAgd2lsbCBiZSBjcmVhdGVkIGluIHRoZSBkaXJlY3RvcnkgPGVtPmFib3ZlPC9lbT4gdGhlIHJvb3QgSUNVNEogZGlyZWN0b3J5LCB3aGVyZSBZWVlZTU1ERAogICAgaXMgdG9kYXkncyBkYXRlLiBBbnkgZXhpc3RpbmcgZmlsZSBvZiB0aGF0IG5hbWUgd2lsbCBiZSBvdmVyd3JpdHRlbi48L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPnppcHNyYzwvdGQ+CiAgICA8dGQ+TGlrZSB0aGUgPHN0cm9uZz56aXA8L3N0cm9uZz4gdGFyZ2V0LCB3aXRob3V0IHRoZSBkb2NzIGFuZCB0aGUgamFyIGZpbGUuIFRoZSB6aXAgZmlsZSA8c3Ryb25nPmljdTRqc3JjWVlZWU1NREQuemlwPC9zdHJvbmc+CiAgICB3aWxsIGJlIGNyZWF0ZWQgaW4gdGhlIGRpcmVjdG9yeSA8ZW0+YWJvdmU8L2VtPiB0aGUgcm9vdCBJQ1U0SiBkaXJlY3RvcnkuPC90ZD4KICA8L3RyPgogIDx0cj4KICAgIDx0ZD5yaWNoZWRpdDwvdGQ+CiAgICA8dGQ+QnVpbGQgdGhlIHJpY2hlZGl0IGNvcmUgY2xhc3MgZmlsZXMgYW5kIHRlc3RzLgogIDwvdHI+CiAgPHRyPgogICAgPHRkPnJpY2hlZGl0SmFyPC90ZD4KICAgIDx0ZD5DcmVhdGUgdGhlIHJpY2hlZGl0IGphciBmaWxlICh3aGljaCBjb250YWlucyBvbmx5IHRoZSByaWNoZWRpdCBjb3JlIGNsYXNzIGZpbGVzKS4KICAgIFRoZSBmaWxlIDxzdHJvbmc+cmljaGVkaXQuamFyPC9zdHJvbmc+CiAgICB3aWxsIGJlIGNyZWF0ZWQgaW4gdGhlIDxzdHJvbmc+Li9yaWNoZWRpdDwvc3Ryb25nPiBzdWJkaXJlY3RvcnkuIEFueSBleGlzdGluZyBmaWxlIG9mCiAgICB0aGF0IG5hbWUgd2lsbCBiZSBvdmVyd3JpdHRlbi48L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPnJpY2hlZGl0WmlwPC90ZD4KICAgIDx0ZD5DcmVhdGUgYSB6aXAgYXJjaGl2ZSBvZiB0aGUgcmljaGVkaXQgZG9jcyBhbmQgamFyIGZpbGUgZm9yIGRpc3RyaWJ1dGlvbi4gVGhlIHppcCBmaWxlIDxzdHJvbmc+cmljaGVkaXQuemlwPC9zdHJvbmc+CiAgICB3aWxsIGJlIGNyZWF0ZWQgaW4gdGhlIDxzdHJvbmc+Li9yaWNoZWRpdDwvc3Ryb25nPiBzdWJkaXJlY3RvcnkuIEFueSBleGlzdGluZyBmaWxlIG9mCiAgICB0aGF0IG5hbWUgd2lsbCBiZSBvdmVyd3JpdHRlbi48L3RkPgogIDwvdHI+CiAgPHRyPgogICAgPHRkPmNsZWFuPC90ZD4KICAgIDx0ZD5SZW1vdmUgYWxsIGJ1aWx0IHRhcmdldHMsIGxlYXZpbmcgdGhlIHNvdXJjZS48L3RkPgogIDwvdHI+CjwvdGFibGU+CjwvZGl2PgoKPHA+Rm9yIG1vcmUgaW5mb3JtYXRpb24sIHJlYWQgdGhlIEFudCBkb2N1bWVudGF0aW9uIGFuZCB0aGUgPHN0cm9uZz5idWlsZC54bWw8L3N0cm9uZz4KZmlsZS48L3A+Cgo8cD5BZnRlciBkb2luZyBhIGJ1aWxkIGl0IGlzIGEgZ29vZCBpZGVhIHRvIHJ1biBhbGwgdGhlIGljdTRqIHRlc3RzIGJ5IHR5cGluZyA8YnI+JnF1b3Q7amF2YQotY2xhc3NwYXRoICRSb290L2NsYXNzZXMgLURVbmljb2RlRGF0YT0kUm9vdC9zcmMvY29tL2libS9pY3UvZGV2L2RhdGEvdW5pY29kZSBjb20uaWJtLmRldi50ZXN0LlRlc3RBbGwmcXVvdDsuPC9wPgoKPHA+KElmIHlvdSBhcmUgYWxsZXJnaWMgdG8gYnVpbGQgc3lzdGVtcywgYXMgYW4gYWx0ZXJuYXRpdmUgdG8gdXNpbmcKQW50IHlvdSBjYW4gYnVpbGQgYnkgcnVubmluZyBqYXZhYyBhbmQgamF2YWRvYyBkaXJlY3RseS4gVGhpcwppcyBub3QgcmVjb21tZW5kZWQuIFlvdSBtYXkgaGF2ZSB0byBtYW51YWxseSBjcmVhdGUgZGVzdGluYXRpb24KZGlyZWN0b3JpZXMuKTwvcD4KCjxoMz48YSBuYW1lPSJIb3dUb01vZHVsYXJpemUiPjwvYT48dT5Ib3cgdG8gbW9kdWxhcml6ZSBJQ1U0SjwvdT48L2gzPgpTb21lIGFwcGxpY2F0aW9ucyBhbmQgZW52aXJvbm1lbnRzIG1heSBub3Qgd2lzaCB0byBzaGlwIGFsbCBvZiBJQ1U0SiBidW5kbGVkIGFzIGEgamFyIGZpbGUgc2luY2UgdGhlIGphciBmaWxlIGlzIGxhcmdlIGFuZCBtYXkgY29udGFpbiBwYXJ0cyBvZiBJQ1U0SiB3aGljaCBhcmUgbm90IHVzZWQuClNvbWUgYXBwbGljYXRpb25zIHVzZSBvbmx5IGEgcGFydGljdWxhciBzZXJ2aWNlIGZyb20gdGhlIHJhbmdlIG9mIHNlcnZpY2VzIHRoYXQgSUNVNEogb2ZmZXJzLCBzbyB3b3VsZCB3YW50IHRvIHNoaXAgb25seSB0aGF0IHNlcnZpY2UgYXMgYSBqYXIgZmlsZS4KU2luY2UgSUNVNEogcmVsZWFzZSAyLjYsIG5ldyBidWlsZCBvcHRpb25zIGFyZSBwcm92aWRlZCB0byBzZWxlY3QgaW5kaXZpZHVhbCBJQ1U0SiBtb2R1bGVzIGZvciBhIG1vcmUgY29tcGFjdCBqYXIgZGlzdHJpYnV0aW9uLgpUaGUgbW9kdWxlcyBhcmUgZGl2aWRlZCBvbiBiYXNpcyBvZiBzZXJ2aWNlIGFuZCBzZXQgb2YgQVBJcyByZXF1aXJlZCBmb3Igc3VwcG9ydGluZyB0aGF0IHNlcnZpY2UsZS5nLiwKdGhlIG5vcm1hbGl6ZXIgbW9kdWxlIHN1cHBvcnRzIGFsbCB0aGUgTm9ybWFsaXplciBBUElzLlRoZSBzZWxmIHRlc3RzIGZvciB0aGVzZSBBUElzIGNhbiBiZSBydW4gdG8gdmVyaWZ5IHRoYXQgdGhlIEFQSXMgd29yay4KRXZlbiB0aG91Z2ggYSBudW1iZXIgb2Ygc3VwcG9ydGluZyBjbGFzc2VzIGFyZSBjb21waWxlZCBjb250YWluaW5nIG90aGVyIEFQSXMsIDxlbT5ubyBndWFyYW50ZWVzPC9lbT4gYXJlIG1hZGUgdGhhdCB0aGVzZSBBUElzIHdpbGwgd29yay4KVGhlIG1vZHVsZXMgYXJlIGludGVyZGVwZW5kZW50IG5vdCBpbmRlcGVuZGVudCxpLmUuLCBzZXBhcmF0ZSBtb2R1bGVzIGFyZSBub3QgYnVpbHQgaW50byBzZXBhcmF0ZSBqYXJzLCBpbnN0ZWFkIG9uZSBvciBtb3JlIG1vZHVsZSB0YXJnZXRzIGFyZSBzcGVjaWZpZWQgaW5vcmRlciB0byBidWlsZCBhIHNtYWxsZXIgamFyLgoKQ3VycmVudGx5IElDVTRKIGNhbiBiZSBkaXZpZGVkIGludG8gdGhlIGZvbGxvd2luZyBtb2R1bGVzOgo8YnI+PGJyPgo8dGFibGUgYm9yZGVyPSIxIj4KCTx0cj4KCgkJPHRoPjxiPk1vZHVsZSBOYW1lPC9iPjwvdGg+CgoJCTx0aD48Yj5BbnQgVGFyZ2V0czwvYj48L3RoPgoKCQk8dGg+PGI+VGVzdCBQYWNrYWdlIFN1cHBvcnRlZDwvYj48L3RoPgoKCQk8dGg+PGI+TWFpbiBDbGFzc2VzKiYjeDIwMjA7PC9iPjwvdGg+CgoJCTx0aD48Yj5TaXplPC9iPjwvdGg+CgoJPC90cj4KCgk8dHI+CgoJCTx0ZD5Ob3JtYWxpemVyPC90ZD4KCgkJPHRkPm5vcm1hbGl6ZXIsIG5vcm1hbGl6ZXJUZXN0czwvdGQ+CgoJCTx0ZD5jb20uaWJtLmljdS5kZXYudGVzdC5ub3JtYWxpemVyPC90ZD4KCgkJPHRkPgoJCQkJbGFuZy5VQ2hhcmFjdGVyCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJDYXRlZ29yeQoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyRGlyZWN0aW9uCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJOYW1lSXRlcmF0b3IKCQkJPGJyPmxhbmcuVUNoYXJhY3RlclR5cGVJdGVyYXRvcgoJCQk8YnI+bGFuZy5VUHJvcGVydHkKCQkJPGJyPmxhbmcuVVNjcmlwdAoJCQk8Yj48YnI+dGV4dC5Ob3JtYWxpemVyPC9iPgoJCQk8YnI+dGV4dC5SZXBsYWNlYWJsZQoJCQk8YnI+dGV4dC5SZXBsYWNlYWJsZVN0cmluZwoJCQk8Yj48YnI+dGV4dC5VQ2hhcmFjdGVySXRlcmF0b3IKCQkJPGJyPnRleHQuVUZvcndhcmRDaGFyYWN0ZXJJdGVyYXRvcjwvYj4KCQkJPGJyPnRleHQuVW5pY29kZUZpbHRlcgoJCQk8YnI+dGV4dC5Vbmljb2RlTWF0Y2hlcgoJCQk8YnI+dGV4dC5Vbmljb2RlU2V0CgkJCTxicj50ZXh0LlVuaWNvZGVTZXRJdGVyYXRvcgoJCQk8YnI+dGV4dC5VVEYxNgoJCQk8YnI+dXRpbC5WYWx1ZUl0ZXJhdG9yCgkJCTxicj51dGlsLlZlcnNpb25JbmZvCgkJPC90ZD4KCgkJPHRkPiZuYnNwOzM1NSBLQjwvdGQ+CgoJPC90cj4KCgk8dHI+CgoJCTx0ZD5Db2xsYXRvcjwvdGQ+CgoJCTx0ZD5jb2xsYXRvciwgY29sbGF0b3JUZXN0czwvdGQ+CgoJCTx0ZD5jb20uaWJtLmljdS5kZXYudGVzdC5jb2xsYXRvcjwvdGQ+CgoJCTx0ZD4KCQkgICAgICAgIGxhbmcuVUNoYXJhY3RlcgoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyQ2F0ZWdvcnkKCQkJPGJyPmxhbmcuVUNoYXJhY3RlckRpcmVjdGlvbgoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyTmFtZUl0ZXJhdG9yCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJUeXBlSXRlcmF0b3IKCQkJPGJyPmxhbmcuVVByb3BlcnR5CgkJCTxicj5sYW5nLlVTY3JpcHQKCQkJPGJyPnRleHQuQnJlYWtEaWN0aW9uYXJ5CgkJCTxicj50ZXh0LkJyZWFrSXRlcmF0b3IKCQkJPGJyPnRleHQuQnJlYWtJdGVyYXRvckZhY3RvcnkKCQkJPGJyPnRleHQuQ2Fub25pY2FsSXRlcmF0b3IKCQkJPGI+PGJyPnRleHQuQ29sbGF0aW9uRWxlbWVudEl0ZXJhdG9yCgkJCTxicj50ZXh0LkNvbGxhdGlvbktleQoJCQk8YnI+dGV4dC5Db2xsYXRpb25QYXJzZWRSdWxlQnVpbGRlcgoJCQk8YnI+dGV4dC5Db2xsYXRpb25SdWxlUGFyc2VyCgkJCTxicj50ZXh0LkNvbGxhdG9yCgkJCTxicj50ZXh0LkNvbGxhdG9yUmVhZGVyPC9iPgoJCQk8YnI+dGV4dC5EaWN0aW9uYXJ5QmFzZWRCcmVha0l0ZXJhdG9yCgkJCTxiPjxicj50ZXh0Lk5vcm1hbGl6ZXI8L2I+CgkJCTxicj50ZXh0LlJlcGxhY2VhYmxlCgkJCTxicj50ZXh0LlJlcGxhY2VhYmxlU3RyaW5nCgkJCTxicj50ZXh0LlJ1bGVCYXNlZEJyZWFrSXRlcmF0b3IKCQkJPGI+PGJyPnRleHQuUnVsZUJhc2VkQ29sbGF0b3IKCQkJPGJyPnRleHQuU2VhcmNoSXRlcmF0b3IKCQkJPGJyPnRleHQuU3RyaW5nU2VhcmNoPC9iPgoJCQk8Yj48YnI+dGV4dC5VQ2hhcmFjdGVySXRlcmF0b3IKCQkJPGJyPnRleHQuVUZvcndhcmRDaGFyYWN0ZXJJdGVyYXRvcjwvYj4KCQkJPGJyPnRleHQuVW5pY29kZUZpbHRlcgoJCQk8YnI+dGV4dC5Vbmljb2RlTWF0Y2hlcgoJCQk8YnI+dGV4dC5Vbmljb2RlU2V0CgkJCTxicj50ZXh0LlVuaWNvZGVTZXRJdGVyYXRvcgoJCQk8YnI+dGV4dC5VVEYxNgoJCQk8YnI+dXRpbC5WYWx1ZUl0ZXJhdG9yCgkJCTxicj51dGlsLlZlcnNpb25JbmZvCgkJPC90ZD4KCgkJPHRkPjEsNzE2IEtCPC90ZD4KCgk8L3RyPgoKCTx0cj4KCgkJPHRkPkNhbGVuZGFyPC90ZD4KCgkJPHRkPmNhbGVuZGFyLCBjYWxlbmRhclRlc3RzPC90ZD4KCgkJPHRkPmNvbS5pYm0uaWN1LmRldi50ZXN0LmNhbGVuZGFyPC90ZD4KCgkJPHRkPgoJCSAgICAgICAgbGFuZy5VQ2hhcmFjdGVyCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJDYXRlZ29yeQoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyRGlyZWN0aW9uCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJOYW1lSXRlcmF0b3IKCQkJPGJyPmxhbmcuVUNoYXJhY3RlclR5cGVJdGVyYXRvcgoJCQk8YnI+bGFuZy5VUHJvcGVydHkKCQkJPGJyPmxhbmcuVVNjcmlwdAoJCQk8Yj48YnI+bWF0aC5CaWdEZWNpbWFsPC9iPgoJCQk8YnI+dGV4dC5CcmVha0l0ZXJhdG9yCgkJCTxiPjxicj50ZXh0LkNoaW5lc2VEYXRlRm9ybWF0CgkJCTxicj50ZXh0LkNoaW5lc2VEYXRlRm9ybWF0U3ltYm9scwoJCQk8YnI+dGV4dC5EYXRlRm9ybWF0CgkJCTxicj50ZXh0LkRhdGVGb3JtYXRTeW1ib2xzCgkJCTxicj50ZXh0LkRlY2ltYWxGb3JtYXQKCQkJPGJyPnRleHQuRGVjaW1hbEZvcm1hdFN5bWJvbHM8L2I+CgkJCTxicj50ZXh0Lk5vcm1hbGl6ZXIKCQkJPGJyPnRleHQuTnVtYmVyRm9ybWF0CgkJCTxicj50ZXh0LlJlcGxhY2VhYmxlCgkJCTxicj50ZXh0LlJlcGxhY2VhYmxlU3RyaW5nCgkJCTxiPjxicj50ZXh0LlNpbXBsZURhdGVGb3JtYXQKCQkJPGJyPnRleHQuVUNoYXJhY3Rlckl0ZXJhdG9yCgkJCTxicj50ZXh0LlVGb3J3YXJkQ2hhcmFjdGVySXRlcmF0b3I8L2I+CgkJCTxicj50ZXh0LlVuaWNvZGVGaWx0ZXIKCQkJPGJyPnRleHQuVW5pY29kZU1hdGNoZXIKCQkJPGJyPnRleHQuVW5pY29kZVNldAoJCQk8YnI+dGV4dC5Vbmljb2RlU2V0SXRlcmF0b3IKCQkJPGJyPnRleHQuVVRGMTYKCQkJPGI+PGJyPnV0aWwuQnVkZGhpc3RDYWxlbmRhcgoJCQk8YnI+dXRpbC5DYWxlbmRhcgoJCQk8YnI+dXRpbC5DYWxlbmRhckFzdHJvbm9tZXIKCQkJPGJyPnV0aWwuQ2FsZW5kYXJDYWNoZQoJCQk8YnI+dXRpbC5DYWxlbmRhckZhY3RvcnkKCQkJPGJyPnV0aWwuQ2hpbmVzZUNhbGVuZGFyCgkJCTxicj51dGlsLkN1cnJlbmN5CgkJCTxicj51dGlsLkRhdGVSdWxlCgkJCTxicj51dGlsLkVhc3RlckhvbGlkYXkKCQkJPGJyPnV0aWwuRWFzdGVyUnVsZQoJCQk8YnI+dXRpbC5HcmVnb3JpYW5DYWxlbmRhcgoJCQk8YnI+dXRpbC5IZWJyZXdDYWxlbmRhcgoJCQk8YnI+dXRpbC5IZWJyZXdIb2xpZGF5CgkJCTxicj51dGlsLkhvbGlkYXkKCQkJPGJyPnV0aWwuSXNsYW1pY0NhbGVuZGFyCgkJCTxicj51dGlsLkphcGFuZXNlQ2FsZW5kYXIKCQkJPGJyPnV0aWwuUmFuZ2VEYXRlUnVsZQoJCQk8YnI+dXRpbC5TaW1wbGVEYXRlUnVsZQoJCQk8YnI+dXRpbC5TaW1wbGVIb2xpZGF5CgkJCTxicj51dGlsLlNpbXBsZVRpbWVab25lCgkJCTxicj51dGlsLlNpbXBsZVRpbWVab25lQWRhcHRlcgoJCQk8YnI+dXRpbC5UaW1lWm9uZQoJCQk8YnI+dXRpbC5UaW1lWm9uZURhdGE8L2I+CgkJCTxicj51dGlsLlZhbHVlSXRlcmF0b3IKCQkJPGJyPnV0aWwuVmVyc2lvbkluZm8KCQk8L3RkPgoKCQk8dGQ+MSwxNjAgS0I8L3RkPgoKCgk8L3RyPgoKCTx0cj4KCgkJPHRkPiZuYnNwO0JyZWFrSXRlcmF0b3I8L3RkPgoKCQk8dGQ+YnJlYWtJdGVyYXRvciwgYnJlYWtJdGVyYXRvclRlc3RzPC90ZD4KCgkJPHRkPmNvbS5pYm0uaWN1LmRldi50ZXN0LmJyZWFraXRlcmF0b3I8L3RkPgoKCQk8dGQ+CgkJCQlsYW5nLlVDaGFyYWN0ZXIKCQkJPGJyPmxhbmcuVUNoYXJhY3RlckNhdGVnb3J5CgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJEaXJlY3Rpb24KCQkJPGJyPmxhbmcuVUNoYXJhY3Rlck5hbWVJdGVyYXRvcgoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyVHlwZUl0ZXJhdG9yCgkJCTxicj5sYW5nLlVQcm9wZXJ0eQoJCQk8YnI+bGFuZy5VU2NyaXB0CgkJCTxiPjxicj50ZXh0LkJyZWFrRGljdGlvbmFyeQoJCQk8YnI+dGV4dC5CcmVha0l0ZXJhdG9yCgkJCTxicj50ZXh0LkJyZWFrSXRlcmF0b3JGYWN0b3J5CgkJCTxicj50ZXh0LkRpY3Rpb25hcnlCYXNlZEJyZWFrSXRlcmF0b3I8L2I+CgkJCTxicj50ZXh0Lk5vcm1hbGl6ZXIKCQkJPGJyPnRleHQuUmVwbGFjZWFibGUKCQkJPGJyPnRleHQuUmVwbGFjZWFibGVTdHJpbmcKCQkJPGI+PGJyPnRleHQuUnVsZUJhc2VkQnJlYWtJdGVyYXRvcjwvYj4KCQkJPGJyPnRleHQuVUNoYXJhY3Rlckl0ZXJhdG9yCgkJCTxicj50ZXh0LlVGb3J3YXJkQ2hhcmFjdGVySXRlcmF0b3IKCQkJPGJyPnRleHQuVW5pY29kZUZpbHRlcgoJCQk8YnI+dGV4dC5Vbmljb2RlTWF0Y2hlcgoJCQk8YnI+dGV4dC5Vbmljb2RlU2V0CgkJCTxicj50ZXh0LlVuaWNvZGVTZXRJdGVyYXRvcgoJCQk8YnI+dGV4dC5VVEYxNgoJCQk8YnI+dXRpbC5SYW5nZVZhbHVlSXRlcmF0b3IKCQkJPGJyPnV0aWwuVmFsdWVJdGVyYXRvcgoJCQk8YnI+dXRpbC5WZXJzaW9uSW5mbwoJCTwvdGQ+CgoJCTx0ZD4xLDEwNSBLQjwvdGQ+CgoJPC90cj4KCgk8dHI+CgoJCTx0ZD5CYXNpYyBQcm9wZXJ0aWVzPC90ZD4KCgkJPHRkPnByb3BlcnRpZXNCYXNpYywgcHJvcGVydGllc1Rlc3RzPC90ZD4KCgkJPHRkPmNvbS5pYm0uaWN1LmRldi50ZXN0Lmxhbmc8L3RkPgoKCQk8dGQ+CgkJICA8Yj4gICAgIGxhbmcuVUNoYXJhY3RlcgoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyQ2F0ZWdvcnkKCQkJPGJyPmxhbmcuVUNoYXJhY3RlckRpcmVjdGlvbgoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyTmFtZUl0ZXJhdG9yCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJUeXBlSXRlcmF0b3IKCQkJPGJyPmxhbmcuVVByb3BlcnR5CgkJCTxicj5sYW5nLlVTY3JpcHQKCQkJPGJyPmxhbmcuVVNjcmlwdFJ1biA8L2I+CgkJCTxicj50ZXh0LkJyZWFrRGljdGlvbmFyeQoJCQk8YnI+dGV4dC5CcmVha0l0ZXJhdG9yCgkJCTxicj50ZXh0LkJyZWFrSXRlcmF0b3JGYWN0b3J5CgkJCTxicj50ZXh0LkRpY3Rpb25hcnlCYXNlZEJyZWFrSXRlcmF0b3IKCQkJPGJyPnRleHQuTm9ybWFsaXplcgoJCQk8YnI+dGV4dC5SZXBsYWNlYWJsZQoJCQk8YnI+dGV4dC5SZXBsYWNlYWJsZVN0cmluZwoJCQk8YnI+dGV4dC5SdWxlQmFzZWRCcmVha0l0ZXJhdG9yCgkJCTxicj50ZXh0LlN5bWJvbFRhYmxlCgkJCTxicj50ZXh0LlVDaGFyYWN0ZXJJdGVyYXRvcgoJCQk8YnI+dGV4dC5VRm9yd2FyZENoYXJhY3Rlckl0ZXJhdG9yCgkJCTxicj50ZXh0LlVuaWNvZGVGaWx0ZXIKCQkJPGJyPnRleHQuVW5pY29kZU1hdGNoZXIKCQkJPGJyPnRleHQuVW5pY29kZVNldAoJCQk8YnI+dGV4dC5Vbmljb2RlU2V0SXRlcmF0b3IKCQkJPGI+PGJyPnRleHQuVVRGMTYgPC9iPgoJCQk8YnI+dXRpbC5Db21wYWN0Qnl0ZUFycmF5CgkJCTxicj51dGlsLlJhbmdlVmFsdWVJdGVyYXRvcgoJCQk8YnI+dXRpbC5WYWx1ZUl0ZXJhdG9yCgkJCTxicj51dGlsLlZlcnNpb25JbmZvCgkJPC90ZD4KCgkJPHRkPjM1MCBLQjwvdGQ+CgoJPC90cj4KCgk8dHI+CgoJCTx0ZD5GdWxsIFByb3BlcnRpZXM8L3RkPgoKCQk8dGQ+cHJvcGVydGllc0Z1bGwsCgkJPGJyPnByb3BlcnRpZXNUZXN0czwvdGQ+CgoJCTx0ZD5jb20uaWJtLmljdS5kZXYudGVzdC5sYW5nPC90ZD4KCgkJPHRkPgoJCSAgICA8Yj4gICAgbGFuZy5VQ2hhcmFjdGVyCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJDYXRlZ29yeQoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyRGlyZWN0aW9uCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJOYW1lSXRlcmF0b3IKCQkJPGJyPmxhbmcuVUNoYXJhY3RlclR5cGVJdGVyYXRvcgoJCQk8YnI+bGFuZy5VUHJvcGVydHkKCQkJPGJyPmxhbmcuVVNjcmlwdAoJCQk8YnI+bGFuZy5VU2NyaXB0UnVuPC9iPgoJCQk8YnI+dGV4dC5CcmVha0RpY3Rpb25hcnkKCQkJPGJyPnRleHQuQnJlYWtJdGVyYXRvcgoJCQk8YnI+dGV4dC5CcmVha0l0ZXJhdG9yRmFjdG9yeQoJCQk8YnI+dGV4dC5EaWN0aW9uYXJ5QmFzZWRCcmVha0l0ZXJhdG9yCgkJCTxiPjxicj50ZXh0Lk5vcm1hbGl6ZXIKCQkJPGJyPnRleHQuUmVwbGFjZWFibGUKCQkJPGJyPnRleHQuUmVwbGFjZWFibGVTdHJpbmcgPC9iPgoJCQk8YnI+dGV4dC5SdWxlQmFzZWRCcmVha0l0ZXJhdG9yCgkJICAgIDxiPjxicj50ZXh0LlVDaGFyYWN0ZXJJdGVyYXRvcgoJCQk8YnI+dGV4dC5VRm9yd2FyZENoYXJhY3Rlckl0ZXJhdG9yCgkJCTxicj50ZXh0LlVuaWNvZGVGaWx0ZXIKCQkJPGJyPnRleHQuVW5pY29kZU1hdGNoZXIKCQkJPGJyPnRleHQuVW5pY29kZVNldAoJCQk8YnI+dGV4dC5Vbmljb2RlU2V0SXRlcmF0b3IKCQkJPGJyPnRleHQuVVRGMTYKCQkJPGJyPnV0aWwuUmFuZ2VWYWx1ZUl0ZXJhdG9yCgkJCTxicj51dGlsLlZhbHVlSXRlcmF0b3IKCQkJPGJyPnV0aWwuVmVyc2lvbkluZm8gPC9iPgoJCTwvdGQ+CgoJCTx0ZD4mbmJzcDs5ODYgS0I8L3RkPgoKCTwvdHI+CgoJPHRyPgoKCQk8dGQ+Rm9ybWF0dGluZzwvdGQ+CgoJCTx0ZD5mb3JtYXQsIGZvcm1hdFRlc3RzPC90ZD4KCgkJPHRkPmNvbS5pYm0uaWN1LmRldi50ZXN0LmZvcm1hdDwvdGQ+CgoJCTx0ZD4KCQkgICAgICAgIGxhbmcuVUNoYXJhY3RlcgoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyQ2F0ZWdvcnkKCQkJPGJyPmxhbmcuVUNoYXJhY3RlckRpcmVjdGlvbgoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyTmFtZUl0ZXJhdG9yCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJUeXBlSXRlcmF0b3IKCQkJPGJyPmxhbmcuVVByb3BlcnR5CgkJCTxicj5sYW5nLlVTY3JpcHQKCQkJPGI+PGJyPm1hdGguQmlnRGVjaW1hbDwvYj4KCQkJPGJyPnRleHQuQnJlYWtJdGVyYXRvcgoJCQk8YnI+dGV4dC5DYW5vbmljYWxJdGVyYXRvcgoJCQk8YnI+dGV4dC5DaGluZXNlRGF0ZUZvcm1hdAoJCQk8YnI+dGV4dC5DaGluZXNlRGF0ZUZvcm1hdFN5bWJvbHMKCQkJPGJyPnRleHQuQ29sbGF0aW9uRWxlbWVudEl0ZXJhdG9yCgkJCTxicj50ZXh0LkNvbGxhdGlvbktleQoJCQk8YnI+dGV4dC5Db2xsYXRpb25QYXJzZWRSdWxlQnVpbGRlcgoJCQk8YnI+dGV4dC5Db2xsYXRpb25SdWxlUGFyc2VyCgkJCTxicj50ZXh0LkNvbGxhdG9yCgkJCTxicj50ZXh0LkNvbGxhdG9yUmVhZGVyCgkJCTxiPjxicj50ZXh0LkRhdGVGb3JtYXQKCQkJPGJyPnRleHQuRGF0ZUZvcm1hdFN5bWJvbHMKCQkJPGJyPnRleHQuRGVjaW1hbEZvcm1hdAoJCQk8YnI+dGV4dC5EZWNpbWFsRm9ybWF0U3ltYm9sczwvYj4KCQkJPGJyPnRleHQuTm9ybWFsaXplcgoJCQk8Yj48YnI+dGV4dC5OdW1iZXJGb3JtYXQ8L2I+CgkJCTxicj50ZXh0LlJlcGxhY2VhYmxlCgkJCTxicj50ZXh0LlJlcGxhY2VhYmxlU3RyaW5nCgkJCTxicj50ZXh0LlJ1bGVCYXNlZENvbGxhdG9yCgkJCTxiPjxicj50ZXh0LlJ1bGVCYXNlZE51bWJlckZvcm1hdAoJCQk8YnI+dGV4dC5TaW1wbGVEYXRlRm9ybWF0CgkJCTxicj50ZXh0LlVDaGFyYWN0ZXJJdGVyYXRvcgoJCQk8YnI+dGV4dC5VRm9yd2FyZENoYXJhY3Rlckl0ZXJhdG9yPC9iPgoJCQk8YnI+dGV4dC5Vbmljb2RlRmlsdGVyCgkJCTxicj50ZXh0LlVuaWNvZGVNYXRjaGVyCgkJCTxicj50ZXh0LlVuaWNvZGVTZXQKCQkJPGJyPnRleHQuVW5pY29kZVNldEl0ZXJhdG9yCgkJCTxicj50ZXh0LlVURjE2CgkJCTxiPjxicj51dGlsLkNhbGVuZGFyCgkJCTxicj51dGlsLkNhbGVuZGFyQXN0cm9ub21lcgoJCQk8YnI+dXRpbC5DYWxlbmRhckNhY2hlCgkJCTxicj51dGlsLkNhbGVuZGFyRmFjdG9yeQoJCQk8YnI+dXRpbC5DaGluZXNlQ2FsZW5kYXIKCQkJPGJyPnV0aWwuQ3VycmVuY3kKCQkJPGJyPnV0aWwuR3JlZ29yaWFuQ2FsZW5kYXIKCQkJPGJyPnV0aWwuUmFuZ2VWYWx1ZUl0ZXJhdG9yCgkJCTxicj51dGlsLlNpbXBsZVRpbWVab25lCgkJCTxicj51dGlsLlNpbXBsZVRpbWVab25lQWRhcHRlcgoJCQk8YnI+dXRpbC5UaW1lWm9uZQoJCQk8YnI+dXRpbC5UaW1lWm9uZURhdGE8L2I+CgkJCTxicj51dGlsLlZhbHVlSXRlcmF0b3IKCQkJPGJyPnV0aWwuVmVyc2lvbkluZm8KCQk8L3RkPgoJCTx0ZD4xLDc4OCBLQiA8L3RkPgoJPC90cj4KCiAgICA8dHI+CgoJCTx0ZD5UcmFuc2Zvcm1zPC90ZD4KCgkJPHRkPnRyYW5zbGl0ZXJhdG9yLCB0cmFuc2xpdGVyYXRvclRlc3RzPC90ZD4KCgkJPHRkPmNvbS5pYm0uaWN1LmRldi50ZXN0LnRyYW5zbGl0PC90ZD4KCgkJPHRkPgoJCSA8Yj4JCWxhbmcuVUNoYXJhY3RlcgoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyQ2F0ZWdvcnkKCQkJPGJyPmxhbmcuVUNoYXJhY3RlckRpcmVjdGlvbgoJCQk8YnI+bGFuZy5VQ2hhcmFjdGVyTmFtZUl0ZXJhdG9yCgkJCTxicj5sYW5nLlVDaGFyYWN0ZXJUeXBlSXRlcmF0b3IKCQkJPGJyPmxhbmcuVVByb3BlcnR5CgkJCTxicj5sYW5nLlVTY3JpcHQKCQkJPGJyPmxhbmcuVVNjcmlwdFJ1bgoJCQk8YnI+dGV4dC5BbnlUcmFuc2xpdGVyYXRvcgoJCQk8YnI+dGV4dC5CcmVha0RpY3Rpb25hcnkKCQkJPGJyPnRleHQuQnJlYWtJdGVyYXRvcgoJCQk8YnI+dGV4dC5CcmVha0l0ZXJhdG9yRmFjdG9yeQoJCQk8YnI+dGV4dC5CcmVha1RyYW5zbGl0ZXJhdG9yCgkJCTxicj50ZXh0LkRpY3Rpb25hcnlCYXNlZEJyZWFrSXRlcmF0b3IKCQkJPGJyPnRleHQuTm9ybWFsaXplcgoJCQk8YnI+dGV4dC5SZXBsYWNlYWJsZQoJCQk8YnI+dGV4dC5SZXBsYWNlYWJsZVN0cmluZwoJCQk8YnI+dGV4dC5SdWxlQmFzZWRCcmVha0l0ZXJhdG9yCgkJCTxicj50ZXh0LlN0cmluZ1JlcGxhY2VyCgkJCTxicj50ZXh0LlRyYW5zbGl0ZXJhdG9yCgkJCTxicj50ZXh0LlVDaGFyYWN0ZXJJdGVyYXRvcgoJCQk8YnI+dGV4dC5VRm9yd2FyZENoYXJhY3Rlckl0ZXJhdG9yCgkJCTxicj50ZXh0LlVuaWNvZGVTZXQKCQkJPGJyPnRleHQuVW5pY29kZVNldEl0ZXJhdG9yCgkJCTxicj50ZXh0LlVURjE2CgkJCTxicj51dGlsLlJhbmdlVmFsdWVJdGVyYXRvcgoJCQk8YnI+dXRpbC5WYWx1ZUl0ZXJhdG9yCgkJCTxicj51dGlsLlZlcnNpb25JbmZvPC9iPgoJCTwvdGQ+CgoJCTx0ZD4xLDM2NCBLQjwvdGQ+CgoJPC90cj4KPC90YWJsZT4KPGI+Cjxmb250IHNpemU9Mj4KKiBjb20uaWJtLmljdS4gc2hvdWxkIGJlIHByZXBlbmRlZCB0byB0aGUgbmFtZXMgbGlzdGVkLgo8YnI+JiN4MjAyMDsgQVBJcyBjb250YWluZWQgYnkgY2xhc3MgbmFtZXMgaW4gYm9sZCBhcmUgZ3VhcmFudGVlZCB0byB3b3JrLgo8L2ZvbnQ+CjwvYj4KPGJyPgo8YnI+CgpCdWlsZGluZyBhbnkgb2YgdGhlc2UgbW9kdWxlcyBpcyBhcyBlYXN5IGFzIHNwZWNpZnlpbmcgYSBidWlsZCB0YXJnZXQgdG8gdGhlIEFudCBidWlsZCBzeXN0ZW0sZS5nOgo8YnI+VG8gYnVpbGQgYSBtb2R1bGUgdGhhdCBjb250YWlucyBvbmx5IHRoZSBOb3JtYWxpemVyIEFQSToKICAgIDxvbD4KICAgICAgICA8bGk+IEJ1aWxkIHRoZSBtb2R1bGUuIDxicj4gPGNvZGU+IGFudCBub3JtYWxpemVyIDwvY29kZT4gPC9saT4KICAgICAgICA8bGk+IEJ1aWxkIHRoZSB0ZXN0cyBmb3IgdGhlIG1vZHVsZS4gPGJyPiA8Y29kZT4gYW50IG5vcm1hbGl6ZXJUZXN0cyA8L2NvZGU+IDwvbGk+CiAgICAgICAgPGJyPjxiPjxmb250IHNpemU9Mj5Ob3RlOjwvZm9udD48L2I+IFlvdSBjb3VsZCBvbWl0IHRoZSBzdGVwIDEgYW5kIHByb2NlZWQgdG8gc3RlcCAyLCBmb3IgYWxsIG1vZHVsZXMgZXhjZXB0IGZ1bGwgY2hhcmFjdGVyIHByb3BlcnRpZXMsIGFuZCBsZXQgdGhlIGRlcGVuZGVjeSBhbmFseXNpcyBjb21waWxlIHRoZSByZXF1aXNpdGUgbW9kdWxlLgogICAgICAgIDxsaT4gUnVuIHRoZSB0ZXN0cyBhbmQgdmVyaWZ5IHRoYXQgdGhlIHNlbGYgdGVzdHMgcGFzcy4gPGJyPiA8Y29kZT4gamF2YSAtY2xhc3NwYXRoICRpY3U0al9yb290L2NsYXNzZXMgY29tLmlibS5pY3UuZGV2LnRlc3QuVGVzdEFsbCAtbm90aHJvdyAtdyA8L2NvZGU+CiAJCTxsaT4gQnVpbGQgdGhlIGphciBjb250YWluaW5nIHRoZSBtb2R1bGUuIDxicj4gPGNvZGU+YW50IG1vZHVsZUphciA8L2NvZGU+CiAgICAgPC9vbD4KCklmIG1vcmUgdGhhbiBvbmUgbW9kdWxlIGlzIHJlcXVpcmVkLCB0aGUgbW9kdWxlIGJ1aWxkIHRhcmdldHMgY2FuIGJlIGNvbmNhdGVuYXRlZCwgZS5nOgogICAgPG9sPgogICAgICAgIDxsaT4gQnVpbGQgdGhlIG1vZHVsZXMuIDxicj4gPGNvZGU+IGFudCBub3JtYWxpemVyIGNvbGxhdG9yIDwvY29kZT4gPC9saT4KICAgICAgICA8bGk+IEJ1aWxkIHRoZSB0ZXN0cyBmb3IgdGhlIG1vZHVsZS4gPGJyPiA8Y29kZT4gYW50IG5vcm1hbGl6ZXJUZXN0cyBjb2xsYXRvclRlc3RzIDwvY29kZT4gPC9saT4KICAgICAgICA8bGk+IFJ1biB0aGUgdGVzdHMgYW5kIHZlcmlmeSB0aGF0IHRoZSBzZWxmIHRlc3RzIHBhc3MuIDxicj4gPGNvZGU+IGphdmEgLWNsYXNzcGF0aCAkaWN1NGpfcm9vdC9jbGFzc2VzIGNvbS5pYm0uaWN1LmRldi50ZXN0LlRlc3RBbGwgLW5vdGhyb3cgLXcgPC9jb2RlPgogICAgICAgIDxsaT4gQnVpbGQgdGhlIGphciBjb250YWluaW5nIHRoZSBtb2R1bGUuIDxicj4gPGNvZGU+YW50IG1vZHVsZUphciA8L2NvZGU+CiAgICAgPC9vbD4KCjxoNT4gTm90ZXM6IDwvaDU+Cjx1bD4KCTxsaT5SZWdhcmRsZXNzIG9mIHdoZXRoZXIgSUNVNEogaXMgYnVpbHQgYXMgYSB3aG9sZSBvciBhcyBtb2R1bGVzLCB0aGUgamFyIGZpbGUgcHJvZHVjZWQgaXMgbmFtZWQgPGVtPmljdTRqLmphcjwvZW0+LjwvbGk+Cgk8bGk+VG8gYXNjZXJ0YWluIGlmIGFuIGljdTRqLmphciBjb250YWlucyBhbGwgaWYgSUNVIG9yIG5vdCwgcGxlYXNlIHNlZSB0aGUgbWFuaWZlc3QgZmlsZSBvZiBqYXI8L2xpPgoJPGxpPlRoZSB0YXJnZXQgbW9kdWxlSmFyIGRvZXMgbm90IGRlcGVuZCBvbiBhbnkgb3RoZXIgdGFyZ2V0LiBJdCBqdXN0IGNyZWF0ZXMgYSBqYXIgb2YgYWxsIGNsYXNzIGZpbGVzIHVuZGVyCgkgICAgJGljdTRqX3Jvb3QvY2xhc3Nlcy9jb20vaWJtL2ljdS8sIGV4Y2x1ZGluZyB0aGUgY2xhc3NzIGZpbGVzIGluICRpY3U0al9yb290L2NsYXNzZXMvY29tL2libS9pY3UvZGV2IGZvbGRlcjwvbGk+CiAgICA8bGk+VGhlIGxpc3Qgb2YgbW9kdWxlIGJ1aWxkIHRhcmdldHMgY2FuIGJlIG9idGFpbmVkIGJ5IHJ1bm5pbmcgdGhlIGNvbW1hbmQgOiA8Y29kZT4gYW50IC1wcm9qZWN0aGVscCA8L2NvZGU+IDwvbGk+Cgk8bGk+VG8gdmVyaWZ5IHRoYXQgdGhlIGphciBmaWxlIGJ1aWx0IHVzaW5nIHRoZSBtb2R1bGUgdGFyZ2V0IHdvcmtzLCBwbGVhc2UgZGVsZXRlIGFsbCBkaXJlY3RvcmllcyB1bmRlciAkaWN1NGpfcm9vdC9jbGFzc2VzL2NvbS9pYm0vaWN1LywgCgkgICAgZXhjZXB0ICRpY3U0al9yb290L2NsYXNzZXMvY29tL2libS9pY3UvZGV2LCBhbmQgcnVuIHRoZSB0ZXN0cyBhZ2FpbnN0IHRoZSBqYXIgZmlsZS4KCQk8YnI+PGNvZGU+IGphdmEgLWNsYXNzcGF0aCAkaWN1NGpfcm9vdC9pY3U0ai5qYXIgY29tLmlibS5pY3UuZGV2LnRlc3QuVGVzdEFsbCAtbm90aHJvdyAtdyA8L2NvZGU+CgkgPC9saT4KPC91bD4KCjxoMz48YSBuYW1lPSJ0cnlpbmdvdXQiPjwvYT48dT5UcnlpbmcgT3V0IElDVTRKPC91PjwvaDM+Cgo8cD48c3Ryb25nPk5vdGU6PC9zdHJvbmc+IHRoZSBkZW1vcyBwcm92aWRlZCB3aXRoIElDVTRKIGFyZSBmb3IgdGhlCm1vc3QgcGFydCB1bmRvY3VtZW50ZWQuICBUaGlzIGxpc3QgY2FuIHNob3cgeW91IHdoZXJlIHRvIGxvb2ssIGJ1dCB5b3UnbGwKaGF2ZSB0byBleHBlcmltZW50IGEgYml0LiAgVGhlIGRlbW9zICh3aXRoIHRoZQpleGNlcHRpb24gb2YgcmljaGVkaXQpIGFyZSA8c3Ryb25nPnVuc3VwcG9ydGVkPC9zdHJvbmc+IGFuZCBtYXkgY2hhbmdlCm9yIGRpc2FwcGVhciB3aXRob3V0IG5vdGljZS48L3A+CjxwPlRoZSBpY3U0ai5qYXIgZmlsZSBjb250YWlucyBvbmx5IHRoZSBjb3JlIElDVTRKIGNsYXNzZXMsIG5vdCB0aGUKZGVtbyBjbGFzc2VzLCBzbyB1bmxlc3MgeW91IGJ1aWxkIElDVTRKIHRoZXJlIGlzIGxpdHRsZSB0byB0cnkgb3V0LgoKPGg0PlJpY2ggRWRpdDwvaDQ+ClRvIHRyeSBvdXQgdGhlIDxzdHJvbmc+cmljaGVkaXQ8L3N0cm9uZz4gcGFja2FnZSwgZmlyc3QgYnVpbGQgdGhlIHJpY2hlZGl0SmFyIHRhcmdldC4KVGhpcyBpcyBhICdydW5uYWJsZScgamFyIGZpbGUuICBUbyBydW4gdGhlIHJpY2hlZGl0IGRlbW8sIHR5cGU6Cjx0dD48YmxvY2txdW90ZT4gIGphdmEgLWphciAkUm9vdC9yaWNoZWRpdC9yaWNoZWRpdC5qYXI8L2Jsb2NrcXVvdGU+PC90dD4KClRoaXMgd2lsbCBwcmVzZW50IGFuIGVtcHR5IGVkaXQgcGFuZSB3aXRoIGFuIGF3dCBpbnRlcmZhY2UuPC9wPgoKPHA+V2l0aCBhIGZ1bGxlciBjb21tYW5kIGxpbmUgeW91IGNhbiB0cnkgb3V0IG90aGVyIG9wdGlvbnMsIGZvciBleGFtcGxlOgo8dHQ+PGJsb2NrcXVvdGU+ICAgamF2YSAtY2xhc3NwYXRoICRSb290L3JpY2hlZGl0L3JpY2hlZGl0LmphciBjb20uaWJtLnJpY2h0ZXh0LmRlbW8uRWRpdERlbW8gWy1zd2luZ11bZmlsZV08L2Jsb2NrcXVvdGU+PC90dD4KVGhpcyB3aWxsIHVzZSBhbiBhd3QgR1VJLCBvciBhIHN3aW5nIEdVSSBpZgo8dHQ+LXN3aW5nPC90dD4gaXMgcGFzc2VkIG9uIHRoZSBjb21tYW5kIGxpbmUuICBJdCB3aWxsIG9wZW4gYSB0ZXh0CmZpbGUgaWYgb25lIGlzIHByb3ZpZGVkLCBvdGhlcndpc2UgaXQgd2lsbCBvcGVuIGEgYmxhbmsgcGFnZS4gIENsaWNrCnRvIHR5cGUuPC9wPgo8cD4KWW91IGNhbiBhZGQgdGFicyB0byB0aGUgdGFiIHJ1bGVyIGJ5IGNsaWNraW5nIGluIHRoZSBydWxlciB3aGlsZSBob2xkaW5nIGRvd24gdGhlIGNvbnRyb2wga2V5LgpDbGlja2luZyBvbiBhbiBleGlzdGluZyB0YWIgY2hhbmdlcyBiZXR3ZWVuIGxlZnQsIHJpZ2h0LCBjZW50ZXIsIGFuZCBkZWNpbWFsIHRhYnMuICBEcmFnZ2luZwphIHRhYiBtb3ZlcyBpdCwgZHJhZ2dpbmcgaXQgb2ZmIHRoZSBydWxlciByZW1vdmVzIGl0LjwvcD4KPHA+CllvdSBjYW4gZXhwZXJpbWVudCB3aXRoIGNvbXBsZXggdGV4dCBieSB1c2luZyB0aGUga2V5bWFwIGZ1bmN0aW9ucy4KUGxlYXNlIG5vdGUgdGhhdCB0aGVzZSBhcmUgbWFpbmx5IGZvciBkZW1vIHB1cnBvc2VzLCBmb3IgcmVhbCB3b3JrCndpdGggQXJhYmljIG9yIEhlYnJldyB5b3Ugd2lsbCB3YW50IHRvIHVzZSBhbiBpbnB1dCBtZXRob2QuICBZb3Ugd2lsbApuZWVkIHRvIHVzZSBhIGZvbnQgdGhhdCBzdXBwb3J0cyBBcmFiaWMgb3IgSGVicmV3LCAnTHVjaWRhIFNhbnMnIChwcm92aWRlZAp3aXRoIEphdmEpIHN1cHBvcnRzIHRoZXNlIGxhbmd1YWdlcy48L3A+Cgo8aDQ+T3RoZXIgZGVtb3M8L2g0Pgo8cD5UaGUgb3RoZXIgZGVtbyBwcm9ncmFtcyBhcmUgPHN0cm9uZz5ub3Qgc3VwcG9ydGVkPC9zdHJvbmc+IGFuZCBleGlzdCBvbmx5IHRvIGxldCB5b3UKZXhwZXJpbWVudCB3aXRoIHRoZSBJQ1U0SiBjbGFzc2VzLiAgRmlyc3QsIGJ1aWxkIElDVTRKIHVzaW5nIDx0dD5hbnQmbmJzcDthbGw8L3R0Pi4gIFRoZW4gdHJ5Cm9uZSBvZiB0aGUgZm9sbG93aW5nOgo8dWw+CjxsaT48dHQ+amF2YSAtY2xhc3NwYXRoIGNsYXNzZXMgY29tLmlibS5pY3UuZGV2LmRlbW8uY2FsZW5kYXIuQ2FsZW5kYXJBcHA8L3R0Pgo8bGk+PHR0PmphdmEgLWNsYXNzcGF0aCBjbGFzc2VzIGNvbS5pYm0uaWN1LmRldi5kZW1vLmhvbGlkYXkuSG9saWRheUNhbGVuZGFyRGVtbzwvdHQ+CjxsaT48dHQ+amF2YSAtY2xhc3NwYXRoIGNsYXNzZXMgY29tLmlibS5pY3UuZGV2LmRlbW8ucmJiaS5UZXh0Qm91bmREZW1vPC90dD48YnI+KENsaWNrIGluIHRoZSB0ZXh0LCB0aGVuIHVzZSA8dHQ+Y3RybC1OPC90dD4gYW5kIDx0dD5jdHJsLVA8L3R0PiB0byBzZWxlY3QgdGhlIG5leHQgb3IgcHJldmlvdXMgYmxvY2sgb2YgdGV4dC4pCjxsaT48dHQ+amF2YSAtY2xhc3NwYXRoIGNsYXNzZXMgY29tLmlibS5pY3UuZGV2LmRlbW8ucmJuZi5SYm5mRGVtbzwvdHQ+CjxsaT48dHQ+amF2YSAtY2xhc3NwYXRoIGNsYXNzZXMgY29tLmlibS5pY3UuZGV2LmRlbW8udHJhbnNsaXQuRGVtbzwvdHQ+CjwvdWw+CjwvcD4KCjxhIG5hbWU9InJlc291cmNlcyI+CjxoMz48dT5JQ1U0SiBSZXNvdXJjZSBJbmZvcm1hdGlvbjwvdT48L2gzPgo8L2E+ClN0YXJ0aW5nIHdpdGggcmVsZWFzZSAyLjEsIElDVTRKIGluY2x1ZGVzIGl0cyBvd24KcmVzb3VyY2UgaW5mb3JtYXRpb24Kd2hpY2ggaXMgY29tcGxldGVseSBpbmRlcGVuZGVudCBvZiB0aGUgSkRLIHJlc291cmNlIGluZm9ybWF0aW9uLiAgVGhlCm5ldyBJQ1U0SiBpbmZvcm1hdGlvbiBpcyBlcXVpdmFsZW50IHRvIHRoZSBpbmZvcm1hdGlvbiBpbiBJQ1U0QyBhbmQKdWx0aW1hdGVseSBkZXJpdmVzIGZyb20gdGhlIHNhbWUgc291cmNlLiAgVGhpcyBhbGxvd3MgSUNVNEogMi4xIGFuZCBhYm92ZQp0byBiZQpidWlsdCBvbiwgYW5kIHJ1biBvbiwgSkRLIDEuNC4KPC9wPgo8cD4KQnkgZGVmYXVsdCB0aGUgSUNVNEogZGlzdHJpYnV0aW9uIGluY2x1ZGVzIGFsbCBvZiB0aGUgbmV3IHJlc291cmNlCmluZm9ybWF0aW9uLiAgSXQgaXMgbG9jYXRlZCBpbiB0aGUgcGFja2FnZSBjb20uaWJtLmljdS5pbXBsLmRhdGEsIGFzIGEKc2V0IG9mIGNsYXNzIGZpbGVzIG5hbWVkICJMb2NhbGVFbGVtZW50cyIgZm9sbG93ZWQgYnkgdGhlIG5hbWVzIG9mCmxvY2FsZXMgaW4gdGhlIGZvcm0gX3h4X1lZX1paWlosIHdoZXJlICd4eCcgaXMgdGhlIHR3by1sZXR0ZXIgbGFuZ3VhZ2UKY29kZSwgJ1lZJyBpcyB0aGUgY291bnRyeSBjb2RlLCBhbmQgJ1paJyAod2hpY2ggY2FuIGJlIGFueSBsZW5ndGgpIGlzCmEgdmFyaWFudC4gIE1hbnkgb2YgdGhlc2UgZmllbGRzIGNhbiBiZSBvbWl0dGVkLiAgTG9jYWxlIG5hbWluZyBpcwpkb2N1bWVudGVkIHRoZSBMb2NhbGUgY2xhc3MsIGphdmEudXRpbC5Mb2NhbGUsIGFuZCB0aGUgdXNlIG9mIHRoZXNlCm5hbWVzIGluIHNlYXJjaGluZyBmb3IgcmVzb3VyY2VzIGlzIGRvY3VtZW50ZWQgaW4KamF2YS51dGlsLlJlc291cmNlQnVuZGxlLgo8L3A+CjxwPgpTb21lIG9mIHRoZXNlIGZpbGVzIHJlcXVpcmUgc2VwYXJhdGUgYmluYXJ5IGRhdGEuICBUaGUgbmFtZXMgb2YgdGhlCmJpbmFyeSBkYXRhIGZpbGVzIHN0YXJ0IHdpdGggIkNvbGxhdGlvbkVsZW1lbnRzIiwgdGhlbiB0aGUKY29ycmVzcG9uZGluZyBMb2NhbGUgc3RyaW5nLCBhbmQgZW5kIHdpdGggJy5yZXMnLiAgQW5vdGhlciBkYXRhIGZpbGUKKG9ubHkgb25lIGF0IHRoZSBtb21lbnQpIHN0YXJ0cyB3aXRoIHRoZSBuYW1lICJCcmVha0RpY3Rpb25hcnlEYXRhIiwKdGhlIGNvcnJlc3BvbmRpbmcgTG9jYWxlIHN0cmluZywgYW5kIGVuZHMgd2l0aCAnLnVjcycuCjwvcD4KPHA+ClNvbWUgb2YgdGhlIExvY2FsZUVsZW1lbnRzIGZpbGVzIHNoYXJlIGRhdGEgd2l0aCBvdGhlciBMb2NhbGVFbGVtZW50cwpmaWxlcywgYmVjYXVzZSBzb21lIExvY2FsZSBuYW1lcyBoYXZlIGNoYW5nZWQuIEZvciBleGFtcGxlLCBoZV9JTCB1c2VkCnRvIGJlIGl3X0lMLiAgSW4gb3JkZXIgdG8gc3VwcG9ydCBib3RoIG5hbWVzIGJ1dCBub3QgZHVwbGljYXRlIHRoZQpkYXRhLCBvbmUgb2YgdGhlIGNsYXNzIGZpbGVzIHJlZmVycyB0byB0aGUgb3RoZXIgY2xhc3MgZmlsZSdzIGRhdGEuCjwvcD4KPHA+ClRoZSBsaXN0IG9mIHN1cHBvcnRlZCByZXNvdXJjZXMgaXMgZm91bmQgaW4gYSBmaWxlIGNhbGxlZApMb2NhbGVFbGVtZW50c19pbmRleC5jbGFzcy4gIFRoaXMgY29udGFpbnMgdGhlIG5hbWVzIG9mIGFsbCB0aGUKTG9jYWxlRWxlbWVudHMgcmVzb3VyY2VzIGFuZCBpcyB0aGUgc291cmNlIG9mIHRoZSBpbmZvcm1hdGlvbiByZXR1cm5lZApieSBBUEkgc3VjaCBhcyBDYWxlbmRhci5nZXRBdmFpbGFibGVMb2NhbGVzLiAoTm90ZTogZm9yIGVhc2Ugb2YKY3VzdG9taXphdGlvbiB0aGlzIHByb2JhYmx5IHNob3VsZCBiZSBhIHRleHQgZmlsZSkuCjwvcD4KPHA+CkxvY2FsZUVsZW1lbnRzIGZpbGVzIGZvcm0gYSBoaWVyYXJjaHksIHdpdGggdXAgdG8gZm91ciBsZXZlbHM6IGEgcm9vdCwKbGFuZ3VhZ2UsIHJlZ2lvbiAoY291bnRyeSksIGFuZCB2YXJpYW50LiAgU2VhcmNoZXMgZm9yIGxvY2FsZSBkYXRhCmF0dGVtcHQgdG8gbWF0Y2ggYXMgZmFyIGRvd24gdGhlIGhpZXJhcmNoeSBhcyBwb3NzaWJsZSwgZm9yIGV4YW1wbGUsCidoZV9JTCcgd2lsbCBtYXRjaCBMb2NhbGVFbGVtZW50c19oZV9JTCwgYnV0ICdoZV9VUycgd2lsbCBtYXRjaApMb2NhbGVFbGVtZW50c19oZSAoc2luY2UgdGhlcmUgaXMgbm8gJ1VTJyB2YXJpYW50IGZvciAnaGUnLCBhbmQKJ3h4X1lZJyB3aWxsIG1hdGNoIExvY2FsZUVsZW1lbnRzIChzaW5jZSB0aGVyZSBpcyBubyAneHgnIGxhbmd1YWdlCmNvZGUgaW4gdGhlIExvY2FsZUVsZW1lbnRzIGhpZXJhcmNoeSkuICBBZ2Fpbiwgc2VlCmphdmEudXRpbC5SZXNvdXJjZUJ1bmRsZSBmb3IgbW9yZSBpbmZvcm1hdGlvbi4KPC9wPgo8cD4KV2l0aCB0aGlzIGluIG1pbmQsIHRoZSB3YXkgdG8gcmVtb3ZlIExvY2FsZURhdGEgaXMgdG8gbWFrZSBzdXJlIHRvCnJlbW92ZSBhbGwgZGVwZW5kZW5jaWVzIG9uIHRoYXQgZGF0YSBhcyB3ZWxsLiAgRm9yIGV4YW1wbGUsIGlmIHlvdQpyZW1vdmUgTG9jYWxlRWxlbWVudHNfaGUuY2xhc3MsIHlvdSBuZWVkIHRvIHJlbW92ZQpMb2NhbGVFbGVtZW50c19oZV9JTC5jbGFzcywgc2luY2UgaXQgaXMgbG93ZXIgaW4gdGhlIGhpZXJhcmNoeSwgYW5kCnlvdSBtdXN0IHJlbW92ZSBMb2NhbGVFbGVtZW50c19pdy5jbGFzcywgc2luY2UgaXQgcmVmZXJlbmNlcwpMb2NhbGVFbGVtZW50c19oZSwgYW5kIExvY2FsZUVMZW1lbnRzX2l3X0lMLmNsYXNzLCBzaW5jZSBpdCBkZXBlbmRzIG9uCml0IChhbmQgYWxzbyByZWZlcmVuY2VzIExvY2FsZUVsZW1lbnRzX2hlX0lMKS4gIEZvciBhbm90aGVyIGV4YW1wbGUsCmlmIHlvdSByZW1vdmUgQ29sbGF0aW9uRWxlbWVudHNfemhfX1BJTllJTi5yZXMsIHlvdSBtdXN0IGFsc28gcmVtb3ZlCkxvY2FsZUVsZW1lbnRzX3poX19QSU5ZSU4uY2xhc3MsIHNpbmNlIGl0IGRlcGVuZHMgb24gdGhlCkNvbGxhdGlvbkVsZW1lbnRzX3poX19QSU5ZSU4ucmVzLgo8L3A+Cgo8cD4KVW5mb3J0dW5hdGVseSwgdGhlIGphciB0b29sIGluIHRoZSBKREsgcHJvdmlkZXMgbm8gd2F5IHRvIHJlbW92ZSBpdGVtcwpmcm9tIGEgamFyIGZpbGUuICBUaHVzIHlvdSBoYXZlIHRvIGV4dHJhY3QgdGhlIHJlc291cmNlcywgcmVtb3ZlIHRoZQpvbmVzIHlvdSBkb24ndCB3YW50LCBhbmQgdGhlbiBjcmVhdGUgYSBuZXcgamFyIGZpbGUgd2l0aCB0aGUgcmVtaW5pbmcKcmVzb3VyY2VzLiAgU2VlIHRoZSBqYXIgdG9vbCBpbmZvcm1hdGlvbiBmb3IgaG93IHRvIGRvIHRoaXMuICBCZWZvcmUKJ3JlamFyaW5nJyB0aGUgZmlsZXMsIGJlIHN1cmUgdG8gdGhvcm91Z2hseSB0ZXN0IHlvdXIgYXBwbGljYXRpb24gd2l0aAp0aGUgcmVtYWluaW5nIHJlc291cmNlcywgbWFraW5nIHN1cmUgZWFjaCByZXF1aXJlZCByZXNvdXJjZSBpcwpwcmVzZW50Lgo8L3A+Cgo8aDM+RGV2ZWxvcGluZyBSZXNvdXJjZXMgdG8gYmUgdXNlZCB3aXRoIElDVTRKPC9oMz4KPHA+CklDVTRKIDIuMSBhbmQgYWJvdmUgdXNlcyB0aGUgc3RhbmRhcmQgY2xhc3MgbG9va3VwIG1lY2hhbmlzbS4gIFRoaXMgbWVhbnMKYW55IHBwcm9wcmlhdGVseSBuYW1lZCByZXNvdXJjZSBvbiB0aGUgQ0xBU1NQQVRIIHdpbGwgYmUgbG9jYXRlZCwgaW4gdGhlCm9yZGVyIGxpc3RlZCBpbiB0aGUgY2xhc3NwYXRoLgo8L3A+CjxwPgpJZiB5b3UgY3JlYXRlIGEgcmVzb3VyY2UgZmlsZQpjb20uaWJtLmljdS5pbXBsLmRhdGEuTG9jYWxlRWxlbWVudHNfeHhfWVkuY2xhc3MsIGFuZCBsaXN0IGl0IG9uIHRoZQpDTEFTU1BBVEggYmVmb3JlIGljdTRqLmphciwgeW91ciByZXNvdXJjZSB3aWxsIGJlIHVzZWQgaW4gcGxhY2Ugb2YgYW55CmV4aXN0aW5nIExvY2FsZUVsZW1lbnRzX3h4X1lZIHJlc291cmNlIGluIGljdTRqLiAgVGhpcyBpcyBhIGdvb2Qgd2F5CnRvIHRyeSBvdXQgY2hhbmdlcyB0byByZXNvdXJjZXMuICBZb3UgY2FuLCBmb3IgZXhhbXBsZSwgaW5jbHVkZSB0aGUKcmVzb3VyY2UgaW4geW91ciBhcHBsaWNhdGlvbidzIGphciBmaWxlIGFuZCBsaXN0IGl0IGFoZWFkIG9mCmljdTRqLmphci4KPC9wPgo8cD4KSW4gb3JkZXIgdG8gY3JlYXRlIG5ldyByZXNvdXJjZXMsIHlvdSBmaXJzdCBtdXN0IHRob3JvdWdobHkgdW5kZXJzdGFuZAp0aGUgdmFyaW91cyBlbGVtZW50cyBjb250YWluZWQgaW4gdGhlIHJlc291cmNlIGZpbGVzLCB0aGVpciBzeW50YXggYW5kCmRlcGVuZGVuY2llcy4gIFlvdSBjYW5ub3Qgc2ltcGx5ICdwYXRjaCcgZXhpc3RpbmcgcmVzb3VyY2UgZmlsZXMgd2l0aAphIHNpbmdsZSBjaGFuZ2UgYmVjYXVzZSB0aGUgbmV3IGZpbGUgY29tcGxldGVseSByZXBsYWNlcyB0aGUgb2xkIGZpbGUKaW4gdGhlIHJlc291cmNlIGhpZXJhcmNoeS4gIEluIGdlbmVyYWwsIHRoZSBuZXcgcmVzb3VyY2UgZmlsZSBzaG91bGQKY29udGFpbiBhbGwgdGhlIGRpZmZlcmVudCBkYXRhIHRoYXQgdGhlIG9sZCBvbmUgZGlkLCBwbHVzIHlvdXIKY2hhbmdlcy4KPC9wPgo8cD4KQWRkaW5nIGEgbmV3ICdsZWFmJyByZXNvdXJjZSBpcyBlYXNpZXN0LiAgRWxlbWVudHMgZGVmaW5lZCBpbiB0aGF0CnJlc291cmNlIHdpbGwgb3ZlcnJpZGUgY29ycmVzcG9uZGluZyBvbmVzIGluIHRoZSByZXNvdXJjZXMgZnVydGhlciB1cAp0aGUgaGllcmFyY2h5LiAgVGh1cyB5b3UgY2FuLCBmb3IgZXhhbXBsZSwgdHJ5IG91dCBuZXcgbG9jYWxpemVkIG5hbWVzCm9mIGRheXMgb2YgdGhlIHdlZWssIGFzIHRoZXkgYXJlIGFsbCBjb250YWluZWQgaW4gb25lIGVsZW1lbnQuICBUaGUKdmFyaWFudCBtZWNoYW5pc20gY2FuIGJlIHVzZWQgdG8gdGVtcG9yYXJpbHkgdHJ5IG91dCBuZXcgdmVyc2lvbnMgb2YKZXhpc3RpbmcgcmVzb3VyY2UgZWxlbWVudHMgKHRob3VnaCB3ZSBkb24ndCByZWNvbW1lbmQgc2hpcHBpbmcgdGhpcwp3YXkpLiAgTm90ZSB0aG91Z2ggdGhhdCBzb21lIHJlc291cmNlcyBoYXZlIGRldGFpbGVkIGRlcGVuZGVuY2llcyBvbgplYWNoIG90aGVyLCBzbyB0aGF0IHlvdSBjYW5ub3Qgc2ltcGx5IGFzc3VtZSB0aGF0IGEgbmV3IGVsZW1lbnQgd2l0aAp0aGUgc2FtZSBzdHJ1Y3R1cmUgYW5kIG51bWJlciBvZiBjb250ZW50cyB3aWxsICdqdXN0IHdvcmsuJwo8L3A+CjxwPgpQYXRjaGluZyBhbiAnaW50ZXJuYWwnIHJlc291cmNlIChzYXksIG9uZSBjb3JyZXNwb25kaW5nIHRvIGFuIGV4aXN0aW5nCmxhbmd1YWdlIHJlc291cmNlIHRoYXQgaGFzIGNoaWxkcmVuKSByZXF1aXJlcyBjYXJlZnVsIGFuYWx5c2lzIG9mIHRoZQpjb250ZW50cyBvZiB0aGUgcmVzb3VyY2VzLgo8L3A+Cgo8cD4KTG9jYWxlRWxlbWVudHMgcmVzb3VyY2UgZGF0YSBpbiBJQ1U0SiBpcyBjaGVja2VkIGluIHRvIHRoZQpyZXBvc2l0b3J5IGFzIHByZWNvbXBpbGVkIGNsYXNzIGZpbGVzLiAgVGhpcyBtZWFucyB0aGF0IGluc3BlY3RpbmcgdGhlCmNvbnRlbnRzIG9mIHRoZXNlIHJlc291cmNlcyBpcyBkaWZmaWN1bHQuICBUaGV5IGFyZSBjb21waWxlZCBmcm9tIGphdmEKZmlsZXMgdGhhdCBpbiB0dXJuIGFyZSBtYWNoaW5lLWdlbmVyYXRlZCBmcm9tIElDVTRDIGJpbmFyeSBkYXRhLCB1c2luZwp0aGUgZ2VucmIgdG9vbCBpbiBJQ1U0Qy4gIFlvdSBjYW4gdmlldyB0aGUgY29udGVudHMgb2YgdGhlIElDVTRDIHRleHQKcmVzb3VyY2UgZmlsZXMgdG8gdW5kZXJzdGFuZCB0aGUgY29udGVudHMgb2YgdGhlIElDVTRKIHJlc291cmNlcywgYXMKdGhleSBhcmUgdGhlIHNhbWUuCjwvcD4KCjxoMz5EZXZlbG9waW5nIElDVTRKIFJlc291cmNlczwvaDM+CjxwPgpDdXJyZW50bHkgb25seSB0aGUgTG9jYWxlRWxlbWVudHMgcmVzb3VyY2UgZGF0YSBpcyBzaGFyZWQsIG90aGVyIElDVQpyZXNvdXJjZXMgKGNhbGVuZGFyLCB0cmFuc2xpdGVyYXRvciwgZXRjLikgYXJlIHN0aWxsIGNoZWNrZWQgaW4KZGlyZWN0bHkgdG8gSUNVNEogYXMgc291cmNlIGZpbGVzLiAgVGhpcyBtZWFucyB0aGF0IGRldmVsb3BtZW50IGFuZAptYWludGVuYW5jZSBvZiB0aGVzZSByZXNvdXJjZXMgY29udGludWVzIGFzIGJlZm9yZSwgb25seQpMb2NhbGVFbGVtZW50cyByZXNvdXJjZSBkYXRhIGhhcyBiZWVuIGNoYW5nZWQgaW4gSUNVNEogMi4xLiAgVGhpcwpwcm9iYWJseSB3aWxsIGNoYW5nZSBpbiB0aGUgZnV0dXJlIG9uY2Ugd2Ugd29yayBvdXQgYSByZWFzb25hYmxlCm1lY2hhbmlzbSBmb3Igc3RvcmluZyBhbmQgZ2VuZXJhdGluZyB0aGUgcmVzb3VyY2UgZGF0YS4KPC9wPgo8cD4KT25lIGdvYWwgb2YgdXNpbmcgdGhlIHNhbWUgcmVzb3VyY2UgZGF0YSBhcyBJQ1U0QyBpcyB0byBhdm9pZCBrZWVwaW5nCnJlZHVuZGFudCBjb3BpZXMgb2YgdGhlIHJlc291cmNlIGRhdGEuICBDdXJyZW50bHkgdGhlcmUgaXMgbm8gc2VwYXJhdGUKcmVwb3NpdG9yeSBvZiB0aGUgJ21hc3RlcicgcmVzb3VyY2UgZGF0YSwgaXQgaXMgY2hlY2tlZCBpbiB0byBJQ1U0QywKYW5kIHRoZSB0b29scyBmb3IgY29udmVydGluZyBpdCB0byAuamF2YSBmaWxlcyBhcmUgSUNVNEMgdG9vbHMuICBUaGlzCmlzIGluY29udmVuaWVudCBmb3Igd29ya2luZyBpbiBKYXZhLCBidXQgc2luY2UgbWFpbnRlbmFuY2Ugb2YgSUNVNEoKYW5kIElDVTRDIGlzIHN1cHBvc2VkIHRvIGdvIG9uICdpbiBwYXJhbGxlbCwnIGFzIGEgcHJhY3RpY2FsIG1hdHRlcgpwZW9wbGUgd2lsbCBoYXZlIHRvIGJlIGZhbWlsaWFyIHdpdGggZGV2ZWxvcG1lbnQgaW4gYm90aCBDIGFuZCBKYXZhLAphbmQgd2l0aCB0aGUgY29udmVudGlvbnMgYW5kIHN0cnVjdHVyZSBvZiBlYWNoIHByb2plY3QuICBBZGRpdGlvbmFsbHksCnNoYXJpbmcgb2YgZGF0YSBtZWFucyB0aGF0IG1vZGlmaWNhdGlvbnMgdG8gZGF0YSBpbW1lZGlhdGVseSBpbXBhY3QKYm90aCBwcm9qZWN0cyAoYXMgaXQgc2hvdWxkKSBhbmQgdGh1cyBib3RoIHByb2plY3RzIG5lZWQgdG8gYmUgdGVzdGVkCndoZW4gc3VjaCBjaGFuZ2VzIGFyZSBtYWRlLiAgVGhlIGJ1bGsgb2YgdGhlIHRvb2xzIGFyZSBjdXJyZW50bHkgb24KdGhlIElDVTRDIHNpZGUsIGFuZCB3aWxsIGxpa2VseSBzdGF5IHRoYXQgd2F5LCBzbyB0aGlzIHNlZW1zIGxpa2UgYQpyZWFzb25hYmxlIGluaXRpYWwgYXBwcm9hY2ggdG8gc2hhcmluZyB0aGUgZGF0YS4KPC9wPgoKPHA+CldoaWxlIHByb3RvdHlwaW5nIG9mIExvY2FsZUVsZW1lbnRzIGRhdGEgY2FuIG9jY3VyIGluIGVpdGhlciBKYXZhIG9yCkMsIHRoZSBmaW5hbCB2ZXJzaW9uIHNob3VsZCBiZSBjaGVja2VkIGluIHRvIElDVTRDIGluIHRleHQgZm9ybWF0LgpHZW5yYiBpcyB0aGVuIHJ1biB0byBnZW5lcmF0ZSB0aGUgLmphdmEgYW5kIC5yZXMgZmlsZXMuICBUaGV5IGFyZSB0aGVuCmNvbXBpbGVkIGFuZCBqYXInZCBpbnRvIHRoZSBmaWxlIElDVUxvY2FsZURhdGEuamFyLiAgVGhlIHJlc3VsdGluZyBqYXIKZmlsZSBpcyB0aGVuIGNoZWNrZWQgaW4gdG8gSUNVNEogYXMKc3JjL2NvbS9pYm0vaWN1L2Rldi9kYXRhL0lDVUxvY2FsZURhdGEuamFyLiAgKFRoaXMgaXMgbm90IGdyZWF0IGJ1dCBpdAphbGxvd3MgSUNVNEogdG8gYmUgZG93bmxvYWRlZCBhbmQgYnVpbHQgYXMgb25lIHByb2plY3QsIGluc3RlYWQgb2YKdHdvLCBvbmUgZm9yIGxvY2FsZSBkYXRhIGFuZCBvbmUgZm9yIElDVTRKIHByb3Blci4gIEdpdmVuIHRoZSAyLjQKc2NoZWR1bGUgaXQgd2Fzbid0IHBvc3NpYmxlIHRvIHdvcmsgb3V0IHRoZSBsYXJnZXIgZGF0YSBzaGFyaW5nCnByb2JsZW0gaW4gdGltZSwgc28gd2UgdHJpZWQgdG8gbGltaXQgdGhlIGltcGFjdCB0byBqdXN0IHdoYXQgd2FzCm5lZWRlZCB0byBnZXQgSkRLIDEuNCBzdXBwb3J0IHVwIGFuZCBydW5uaW5nLikKPC9wPgoKPHA+ClRoZSBmaWxlcyBpbiBJQ1VMb2NhbGVEYXRhLmphciBnZXQgZXh0cmFjdGVkIHRvIGNvbS9pYm0vaWN1L2ltcGwvZGF0YSBpbgp0aGUgYnVpbGQgZGlyZWN0b3J5IHdoZW4gdGhlICdjb3JlJyB0YXJnZXQgaXMgYnVpbHQuICBUaGVyZWFmdGVyLCBhcwpsb25nIGFzIHRoZSBmaWxlIExvY2FsZUVsZW1lbnRzX2luZGV4LmNsYXNzIGZpbGUgaXMgdW50b3VjaGVkLCB0aGV5IHdpbGwKbm90IGJlIGV4dHJhY3RlZCBhZ2Fpbi4gIEJ1aWxkaW5nIHRoZSAncmVzb3VyY2UnIHRhcmdldCB3aWxsIGZvcmNlIHRoZQpyZXNvdXJjZXMgdG8gb25jZSBhZ2FpbiBiZSBleHRyYWN0ZWQuICBFeHRyYWN0aW9uIHdpbGwKb3ZlcndyaXRlIGFueSBjb3JyZXNwb25kaW5nIC5jbGFzcyBmaWxlcyBhbHJlYWR5IGluIHRoYXQgZGlyZWN0b3J5Lgo8L3A+CjxoND5CdWlsZGluZyBJQ1U0SiBSZXNvdXJjZXMgZnJvbSBJQ1U0QzwvaDQ+CiAgPG9sPgogICAgPGxpPiBEb3dubG9hZCBhbmQgYnVpbGQgSUNVIG9uIGEgPGI+QmlnIEVuZGlhbjwvYj4gbWFjaGluZSA8L2xpPgogICAgPGxpPiBEb3dubG9hZCBhbmQgYnVpbGQgSUNVNEogb24gdGhlIHNhbWUgbWFjaGluZTwvbGk+CiAgICA8bGk+IENoYW5nZSBkaXJlY3RvcnkgdG8gJGljdV9yb290XHNvdXJjZVx0b29sc1xnZW5yYiAgPC9saT4KICAgIDxsaT4gTGF1bmNoIGdlbnJiamFyLnBsIGZyb20gdGhhdCBkaXJlY3RvcnkgaXRzZWxmIHdpdGggdGhlIGNvbW1hbmQKICAgICAgICA8YnI+CiAgICAgICAgIGdlbnJiamFyLnBsICRpY3Vfcm9vdF9kaXI7ICRpY3U0al9yb290OyAmbHQ7bGRfcGF0aF92YXJpYWJsZV9uYW1lJmd0OyBbJmx0O2xvY2FsZSZndDsrXQogICAgICAgIDxicj4KICAgICAgICBUbyBjcmVhdGUgYWxsIHRoZSBsb2NhbGUgZGF0YSBmaWxlcyBvbWl0IHRoZSBsb2NhbGUgYXJndW1lbnQKICAgIDwvbGk+CiAgPC9vbD4KICBFeGVjdXRpb24gb2YgZ2VucmJqYXIucGwgc2NyaXB0IHdpbGwgY3JlYXRlIHRoZSByZXF1aXJlZCBzb3VyY2UgKCouamF2YSkgZmlsZXMsCiAgY2xhc3MgZmlsZSBhbmQgSUNVTG9jYWxlRGF0YS5qYXIgaW4gJmx0O2ljdV9yb290X2RpciZndDtcc291cmNlXGRhdGFcbG9jYWxlc1xqYXZhIGRpcmVjdG9yeS4KCjxoMz48YSBuYW1lPSJXaGVyZVRvRmluZE1vcmUiPjwvYT48dT5XaGVyZSB0byBGaW5kIE1vcmUgSW5mb3JtYXRpb248L3U+PC9oMz4KCjxwPkZvciBpbmZvcm1hdGlvbiBzcGVjaWZpYyB0byB0aGlzIGN1cnJlbnQgcmVsZWFzZSwgcGxlYXNlIHJlZmVyIHRvIHRoZSA8YSBocmVmPSJyZWxlYXNlbm90ZXMuaHRtbCI+cmVsZWFzZW5vdGVzLmh0bWw8L2E+PC9wPgoKPHA+PGEgaHJlZj0iaHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2ljdTRqLyI+aHR0cDovL29zcy5zb2Z0d2FyZS5pYm0uY29tL2ljdTRqLzwvYT4gaXMgYQpwb2ludGVyIHRvIGdlbmVyYWwgaW5mb3JtYXRpb24gYWJvdXQgdGhlIEludGVybmF0aW9uYWwgQ29tcG9uZW50cyBmb3IgVW5pY29kZSBpbiBKYXZhIDwvcD4KCjxwPjxhIGhyZWY9Imh0dHA6Ly93d3cuaWJtLmNvbS9kZXZlbG9wZXIvdW5pY29kZSI+aHR0cDovL3d3dy5pYm0uY29tL2RldmVsb3Blci91bmljb2RlPC9hPiBpcyBhIHBvaW50ZXIgdG8KaW5mb3JtYXRpb24gb24gaG93IHRvIG1ha2UgYXBwbGljYXRpb25zIGdsb2JhbC4gPC9wPgoKPGgzPjxhIE5BTUU9IlN1Ym1pdHRpbmdDb21tZW50cyI+PC9hPjx1PlN1Ym1pdHRpbmcgQ29tbWVudHMsIFJlcXVlc3RpbmcgRmVhdHVyZXMgYW5kClJlcG9ydGluZyBCdWdzPC91PjwvaDM+Cgo8cD5Zb3VyIGNvbW1lbnRzIGFyZSBpbXBvcnRhbnQgdG8gbWFraW5nIElDVTRKIHN1Y2Nlc3NmdWwuJm5ic3A7IFdlIGFyZSBjb21taXR0ZWQKdG8gZml4aW5nIGFueSBidWdzLCBhbmQgd2lsbCB1c2UgeW91ciBmZWVkYmFjayB0byBoZWxwIHBsYW4gZnV0dXJlIHJlbGVhc2VzLjwvcD4KCjxwPlRvIHN1Ym1pdCBjb21tZW50cywgcmVxdWVzdCBmZWF0dXJlcyBhbmQgcmVwb3J0IGJ1Z3MsIGNvbnRhY3QgdXMgdGhyb3VnaCB0aGUgPGEgaHJlZj1odHRwOi8vb3NzLnNvZnR3YXJlLmlibS5jb20vaWN1NGovYXJjaGl2ZXMvaW5kZXguaHRtbD5JQ1U0SiBtYWlsaW5nIGxpc3Q8L2E+Ljxicj4KV2hpbGUgd2UgYXJlIG5vdCBhYmxlIHRvIHJlc3BvbmQgaW5kaXZpZHVhbGx5IHRvIGVhY2ggY29tbWVudCwgd2UgZG8gcmV2aWV3IGFsbCBjb21tZW50cy48L3A+CjxwPlRoYW5rcyBmb3IgeW91ciBpbnRlcmVzdCBpbiBJQ1U0SiE8L3A+Cgo8aHIgc2l6ZT0iMiIgd2lkdGg9IjEwMCUiIGFsaWduPSJjZW50ZXIiPgoKPHA+PGk+PGZvbnQgc2l6ZT0iLTEiPkNvcHlyaWdodCCpIDIwMDItMjAwMyBJbnRlcm5hdGlvbmFsIEJ1c2luZXNzIE1hY2hpbmVzIENvcnBvcmF0aW9uIGFuZCBvdGhlcnMuIEFsbCBSaWdodHMKUmVzZXJ2ZWQuPGJyPgo1NjAwIENvdHRsZSBSb2FkLCBTYW4gSm9z6SwgQ0EgOTUxOTMKPC9mb250PjwvaT48L3A+Cgo8L2JvZHk+CjwvaHRtbD4K