PD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iSVNPLTg4NTktMSI/Pgo8IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBTdHJpY3QvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtc3RyaWN0LmR0ZCI+CjxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIiBsYW5nPSJlbiIgeG1sOmxhbmc9ImVuIj48aGVhZD48IS0tCiAgICAgICAgWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFgKICAgICAgICAgICAgICBUaGlzIGZpbGUgaXMgZ2VuZXJhdGVkIGZyb20geG1sIHNvdXJjZTogRE8gTk9UIEVESVQKICAgICAgICBYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWAogICAgICAtLT4KPHRpdGxlPkFwYWNoZSBUdXRvcmlhbDogRHluYW1pYyBDb250ZW50IHdpdGggQ0dJIC0gQXBhY2hlIEhUVFAgU2VydmVyPC90aXRsZT4KPGxpbmsgaHJlZj0iLi4vc3R5bGUvY3NzL21hbnVhbC5jc3MiIHJlbD0ic3R5bGVzaGVldCIgbWVkaWE9ImFsbCIgdHlwZT0idGV4dC9jc3MiIHRpdGxlPSJNYWluIHN0eWxlc2hlZXQiIC8+CjxsaW5rIGhyZWY9Ii4uL3N0eWxlL2Nzcy9tYW51YWwtbG9vc2UtMTAwcGMuY3NzIiByZWw9ImFsdGVybmF0ZSBzdHlsZXNoZWV0IiBtZWRpYT0iYWxsIiB0eXBlPSJ0ZXh0L2NzcyIgdGl0bGU9Ik5vIFNpZGViYXIgLSBEZWZhdWx0IGZvbnQgc2l6ZSIgLz4KPGxpbmsgaHJlZj0iLi4vc3R5bGUvY3NzL21hbnVhbC1wcmludC5jc3MiIHJlbD0ic3R5bGVzaGVldCIgbWVkaWE9InByaW50IiB0eXBlPSJ0ZXh0L2NzcyIgLz4KPGxpbmsgaHJlZj0iLi4vaW1hZ2VzL2Zhdmljb24uaWNvIiByZWw9InNob3J0Y3V0IGljb24iIC8+PC9oZWFkPgo8Ym9keSBpZD0ibWFudWFsLXBhZ2UiPjxkaXYgaWQ9InBhZ2UtaGVhZGVyIj4KPHAgY2xhc3M9Im1lbnUiPjxhIGhyZWY9Ii4uL21vZC8iPk1vZHVsZXM8L2E+IHwgPGEgaHJlZj0iLi4vbW9kL2RpcmVjdGl2ZXMuaHRtbCI+RGlyZWN0aXZlczwvYT4gfCA8YSBocmVmPSIuLi9mYXEvIj5GQVE8L2E+IHwgPGEgaHJlZj0iLi4vZ2xvc3NhcnkuaHRtbCI+R2xvc3Nhcnk8L2E+IHwgPGEgaHJlZj0iLi4vc2l0ZW1hcC5odG1sIj5TaXRlbWFwPC9hPjwvcD4KPHAgY2xhc3M9ImFwYWNoZSI+QXBhY2hlIEhUVFAgU2VydmVyIFZlcnNpb24gMi4zPC9wPgo8aW1nIGFsdD0iIiBzcmM9Ii4uL2ltYWdlcy9mZWF0aGVyLmdpZiIgLz48L2Rpdj4KPGRpdiBjbGFzcz0idXAiPjxhIGhyZWY9Ii4vIj48aW1nIHRpdGxlPSImbHQ7LSIgYWx0PSImbHQ7LSIgc3JjPSIuLi9pbWFnZXMvbGVmdC5naWYiIC8+PC9hPjwvZGl2Pgo8ZGl2IGlkPSJwYXRoIj4KPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnLyI+QXBhY2hlPC9hPiAmZ3Q7IDxhIGhyZWY9Imh0dHA6Ly9odHRwZC5hcGFjaGUub3JnLyI+SFRUUCBTZXJ2ZXI8L2E+ICZndDsgPGEgaHJlZj0iaHR0cDovL2h0dHBkLmFwYWNoZS5vcmcvZG9jcy8iPkRvY3VtZW50YXRpb248L2E+ICZndDsgPGEgaHJlZj0iLi4vIj5WZXJzaW9uIDIuMzwvYT4gJmd0OyA8YSBocmVmPSIuLyI+SG93LVRvIC8gVHV0b3JpYWxzPC9hPjwvZGl2PjxkaXYgaWQ9InBhZ2UtY29udGVudCI+PGRpdiBpZD0icHJlYW1ibGUiPjxoMT5BcGFjaGUgVHV0b3JpYWw6IER5bmFtaWMgQ29udGVudCB3aXRoIENHSTwvaDE+CjxkaXYgY2xhc3M9InRvcGxhbmciPgo8cD48c3Bhbj5BdmFpbGFibGUgTGFuZ3VhZ2VzOiA8L3NwYW4+PGEgaHJlZj0iLi4vZW4vaG93dG8vY2dpLmh0bWwiIHRpdGxlPSJFbmdsaXNoIj4mbmJzcDtlbiZuYnNwOzwvYT4gfAo8YSBocmVmPSIuLi9mci9ob3d0by9jZ2kuaHRtbCIgaHJlZmxhbmc9ImZyIiByZWw9ImFsdGVybmF0ZSIgdGl0bGU9IkZyYW7nYWlzIj4mbmJzcDtmciZuYnNwOzwvYT4gfAo8YSBocmVmPSIuLi9qYS9ob3d0by9jZ2kuaHRtbCIgaHJlZmxhbmc9ImphIiByZWw9ImFsdGVybmF0ZSIgdGl0bGU9IkphcGFuZXNlIj4mbmJzcDtqYSZuYnNwOzwvYT4gfAo8YSBocmVmPSIuLi9rby9ob3d0by9jZ2kuaHRtbCIgaHJlZmxhbmc9ImtvIiByZWw9ImFsdGVybmF0ZSIgdGl0bGU9IktvcmVhbiI+Jm5ic3A7a28mbmJzcDs8L2E+PC9wPgo8L2Rpdj4KPC9kaXY+CjxkaXYgaWQ9InF1aWNrdmlldyI+PHVsIGlkPSJ0b2MiPjxsaT48aW1nIGFsdD0iIiBzcmM9Ii4uL2ltYWdlcy9kb3duLmdpZiIgLz4gPGEgaHJlZj0iI2ludHJvIj5JbnRyb2R1Y3Rpb248L2E+PC9saT4KPGxpPjxpbWcgYWx0PSIiIHNyYz0iLi4vaW1hZ2VzL2Rvd24uZ2lmIiAvPiA8YSBocmVmPSIjY29uZmlndXJpbmciPkNvbmZpZ3VyaW5nIEFwYWNoZSB0byBwZXJtaXQgQ0dJPC9hPjwvbGk+CjxsaT48aW1nIGFsdD0iIiBzcmM9Ii4uL2ltYWdlcy9kb3duLmdpZiIgLz4gPGEgaHJlZj0iI3dyaXRpbmciPldyaXRpbmcgYSBDR0kgcHJvZ3JhbTwvYT48L2xpPgo8bGk+PGltZyBhbHQ9IiIgc3JjPSIuLi9pbWFnZXMvZG93bi5naWYiIC8+IDxhIGhyZWY9IiN0cm91Ymxlc2hvb3QiPkJ1dCBpdCdzIHN0aWxsIG5vdCB3b3JraW5nITwvYT48L2xpPgo8bGk+PGltZyBhbHQ9IiIgc3JjPSIuLi9pbWFnZXMvZG93bi5naWYiIC8+IDxhIGhyZWY9IiNiZWhpbmRzY2VuZXMiPldoYXQncyBnb2luZyBvbiBiZWhpbmQgdGhlIHNjZW5lcz88L2E+PC9saT4KPGxpPjxpbWcgYWx0PSIiIHNyYz0iLi4vaW1hZ2VzL2Rvd24uZ2lmIiAvPiA8YSBocmVmPSIjbGlicmFyaWVzIj5DR0kgbW9kdWxlcy9saWJyYXJpZXM8L2E+PC9saT4KPGxpPjxpbWcgYWx0PSIiIHNyYz0iLi4vaW1hZ2VzL2Rvd24uZ2lmIiAvPiA8YSBocmVmPSIjbW9yZWluZm8iPkZvciBtb3JlIGluZm9ybWF0aW9uPC9hPjwvbGk+CjwvdWw+PC9kaXY+CjxkaXYgY2xhc3M9InRvcCI+PGEgaHJlZj0iI3BhZ2UtaGVhZGVyIj48aW1nIGFsdD0idG9wIiBzcmM9Ii4uL2ltYWdlcy91cC5naWYiIC8+PC9hPjwvZGl2Pgo8ZGl2IGNsYXNzPSJzZWN0aW9uIj4KPGgyPjxhIG5hbWU9ImludHJvIiBpZD0iaW50cm8iPkludHJvZHVjdGlvbjwvYT48L2gyPgogICAgCgogICAgPHRhYmxlIGNsYXNzPSJyZWxhdGVkIj48dHI+PHRoPlJlbGF0ZWQgTW9kdWxlczwvdGg+PHRoPlJlbGF0ZWQgRGlyZWN0aXZlczwvdGg+PC90cj48dHI+PHRkPjx1bD48bGk+PGNvZGUgY2xhc3M9Im1vZHVsZSI+PGEgaHJlZj0iLi4vbW9kL21vZF9hbGlhcy5odG1sIj5tb2RfYWxpYXM8L2E+PC9jb2RlPjwvbGk+PGxpPjxjb2RlIGNsYXNzPSJtb2R1bGUiPjxhIGhyZWY9Ii4uL21vZC9tb2RfY2dpLmh0bWwiPm1vZF9jZ2k8L2E+PC9jb2RlPjwvbGk+PC91bD48L3RkPjx0ZD48dWw+PGxpPjxjb2RlIGNsYXNzPSJkaXJlY3RpdmUiPjxhIGhyZWY9Ii4uL21vZC9tb2RfbWltZS5odG1sI2FkZGhhbmRsZXIiPkFkZEhhbmRsZXI8L2E+PC9jb2RlPjwvbGk+PGxpPjxjb2RlIGNsYXNzPSJkaXJlY3RpdmUiPjxhIGhyZWY9Ii4uL21vZC9jb3JlLmh0bWwjb3B0aW9ucyI+T3B0aW9uczwvYT48L2NvZGU+PC9saT48bGk+PGNvZGUgY2xhc3M9ImRpcmVjdGl2ZSI+PGEgaHJlZj0iLi4vbW9kL21vZF9hbGlhcy5odG1sI3NjcmlwdGFsaWFzIj5TY3JpcHRBbGlhczwvYT48L2NvZGU+PC9saT48L3VsPjwvdGQ+PC90cj48L3RhYmxlPgoKICAgIDxwPlRoZSBDR0kgKENvbW1vbiBHYXRld2F5IEludGVyZmFjZSkgZGVmaW5lcyBhIHdheSBmb3IgYSB3ZWIKICAgIHNlcnZlciB0byBpbnRlcmFjdCB3aXRoIGV4dGVybmFsIGNvbnRlbnQtZ2VuZXJhdGluZyBwcm9ncmFtcywKICAgIHdoaWNoIGFyZSBvZnRlbiByZWZlcnJlZCB0byBhcyBDR0kgcHJvZ3JhbXMgb3IgQ0dJIHNjcmlwdHMuIEl0CiAgICBpcyB0aGUgc2ltcGxlc3QsIGFuZCBtb3N0IGNvbW1vbiwgd2F5IHRvIHB1dCBkeW5hbWljIGNvbnRlbnQgb24KICAgIHlvdXIgd2ViIHNpdGUuIFRoaXMgZG9jdW1lbnQgd2lsbCBiZSBhbiBpbnRyb2R1Y3Rpb24gdG8gc2V0dGluZwogICAgdXAgQ0dJIG9uIHlvdXIgQXBhY2hlIHdlYiBzZXJ2ZXIsIGFuZCBnZXR0aW5nIHN0YXJ0ZWQgd3JpdGluZwogICAgQ0dJIHByb2dyYW1zLjwvcD4KICA8L2Rpdj48ZGl2IGNsYXNzPSJ0b3AiPjxhIGhyZWY9IiNwYWdlLWhlYWRlciI+PGltZyBhbHQ9InRvcCIgc3JjPSIuLi9pbWFnZXMvdXAuZ2lmIiAvPjwvYT48L2Rpdj4KPGRpdiBjbGFzcz0ic2VjdGlvbiI+CjxoMj48YSBuYW1lPSJjb25maWd1cmluZyIgaWQ9ImNvbmZpZ3VyaW5nIj5Db25maWd1cmluZyBBcGFjaGUgdG8gcGVybWl0IENHSTwvYT48L2gyPgogICAgCgogICAgPHA+SW4gb3JkZXIgdG8gZ2V0IHlvdXIgQ0dJIHByb2dyYW1zIHRvIHdvcmsgcHJvcGVybHksIHlvdSdsbAogICAgbmVlZCB0byBoYXZlIEFwYWNoZSBjb25maWd1cmVkIHRvIHBlcm1pdCBDR0kgZXhlY3V0aW9uLiBUaGVyZQogICAgYXJlIHNldmVyYWwgd2F5cyB0byBkbyB0aGlzLjwvcD4KCiAgICA8ZGl2IGNsYXNzPSJ3YXJuaW5nIj5Ob3RlOiBJZiBBcGFjaGUgaGFzIGJlZW4gYnVpbHQgd2l0aCBzaGFyZWQgbW9kdWxlCiAgICBzdXBwb3J0IHlvdSBuZWVkIHRvIGVuc3VyZSB0aGF0IHRoZSBtb2R1bGUgaXMgbG9hZGVkOyBpbiB5b3VyCiAgICA8Y29kZT5odHRwZC5jb25mPC9jb2RlPiB5b3UgbmVlZCB0byBtYWtlIHN1cmUgdGhlCiAgICA8Y29kZSBjbGFzcz0iZGlyZWN0aXZlIj48YSBocmVmPSIuLi9tb2QvbW9kX3NvLmh0bWwjbG9hZG1vZHVsZSI+TG9hZE1vZHVsZTwvYT48L2NvZGU+CiAgICBkaXJlY3RpdmUgaGFzIG5vdCBiZWVuIGNvbW1lbnRlZCBvdXQuICBBIGNvcnJlY3RseSBjb25maWd1cmVkIGRpcmVjdGl2ZQogICAgbWF5IGxvb2sgbGlrZSB0aGlzOgoKICAgIDxkaXYgY2xhc3M9ImV4YW1wbGUiPjxwPjxjb2RlPgogICAgICBMb2FkTW9kdWxlIGNnaV9tb2R1bGUgbW9kdWxlcy9tb2RfY2dpLnNvCiAgICA8L2NvZGU+PC9wPjwvZGl2PjwvZGl2PgoKICAgIDxoMz48YSBuYW1lPSJzY3JpcHRhbGlhcyIgaWQ9InNjcmlwdGFsaWFzIj5TY3JpcHRBbGlhczwvYT48L2gzPgogICAgICAKCiAgICAgIDxwPlRoZSAKICAgICAgPGNvZGUgY2xhc3M9ImRpcmVjdGl2ZSI+PGEgaHJlZj0iLi4vbW9kL21vZF9hbGlhcy5odG1sI3NjcmlwdGFsaWFzIj5TY3JpcHRBbGlhczwvYT48L2NvZGU+CgogICAgICBkaXJlY3RpdmUgdGVsbHMgQXBhY2hlIHRoYXQgYSBwYXJ0aWN1bGFyIGRpcmVjdG9yeSBpcyBzZXQKICAgICAgYXNpZGUgZm9yIENHSSBwcm9ncmFtcy4gQXBhY2hlIHdpbGwgYXNzdW1lIHRoYXQgZXZlcnkgZmlsZSBpbgogICAgICB0aGlzIGRpcmVjdG9yeSBpcyBhIENHSSBwcm9ncmFtLCBhbmQgd2lsbCBhdHRlbXB0IHRvIGV4ZWN1dGUKICAgICAgaXQsIHdoZW4gdGhhdCBwYXJ0aWN1bGFyIHJlc291cmNlIGlzIHJlcXVlc3RlZCBieSBhCiAgICAgIGNsaWVudC48L3A+CgogICAgICA8cD5UaGUgPGNvZGUgY2xhc3M9ImRpcmVjdGl2ZSI+PGEgaHJlZj0iLi4vbW9kL21vZF9hbGlhcy5odG1sI3NjcmlwdGFsaWFzIj5TY3JpcHRBbGlhczwvYT48L2NvZGU+CiAgICAgIGRpcmVjdGl2ZSBsb29rcyBsaWtlOjwvcD4KCiAgICAgIDxkaXYgY2xhc3M9ImV4YW1wbGUiPjxwPjxjb2RlPgogICAgICAgIFNjcmlwdEFsaWFzIC9jZ2ktYmluLyAvdXNyL2xvY2FsL2FwYWNoZTIvY2dpLWJpbi8KICAgICAgPC9jb2RlPjwvcD48L2Rpdj4KCiAgICAgIDxwPlRoZSBleGFtcGxlIHNob3duIGlzIGZyb20geW91ciBkZWZhdWx0IDxjb2RlPmh0dHBkLmNvbmY8L2NvZGU+CiAgICAgIGNvbmZpZ3VyYXRpb24gZmlsZSwgaWYgeW91IGluc3RhbGxlZCBBcGFjaGUgaW4gdGhlIGRlZmF1bHQKICAgICAgbG9jYXRpb24uIFRoZSA8Y29kZSBjbGFzcz0iZGlyZWN0aXZlIj48YSBocmVmPSIuLi9tb2QvbW9kX2FsaWFzLmh0bWwjc2NyaXB0YWxpYXMiPlNjcmlwdEFsaWFzPC9hPjwvY29kZT4KICAgICAgZGlyZWN0aXZlIGlzIG11Y2ggbGlrZSB0aGUgPGNvZGUgY2xhc3M9ImRpcmVjdGl2ZSI+PGEgaHJlZj0iLi4vbW9kL21vZF9hbGlhcy5odG1sI2FsaWFzIj5BbGlhczwvYT48L2NvZGU+IGRpcmVjdGl2ZSwgd2hpY2ggZGVmaW5lcyBhIFVSTCBwcmVmaXggdGhhdAogICAgICBpcyB0byBtYXBwZWQgdG8gYSBwYXJ0aWN1bGFyIGRpcmVjdG9yeS4gPGNvZGUgY2xhc3M9ImRpcmVjdGl2ZSI+QWxpYXM8L2NvZGU+CiAgICAgIGFuZCA8Y29kZSBjbGFzcz0iZGlyZWN0aXZlIj5TY3JpcHRBbGlhczwvY29kZT4gYXJlIHVzdWFsbHkgdXNlZCBmb3IKICAgICAgZGlyZWN0b3JpZXMgdGhhdCBhcmUgb3V0c2lkZSBvZiB0aGUgPGNvZGUgY2xhc3M9ImRpcmVjdGl2ZSI+PGEgaHJlZj0iLi4vbW9kL2NvcmUuaHRtbCNkb2N1bWVudHJvb3QiPkRvY3VtZW50Um9vdDwvYT48L2NvZGU+IGRpcmVjdG9yeS4gVGhlIGRpZmZlcmVuY2UgYmV0d2VlbgogICAgICA8Y29kZSBjbGFzcz0iZGlyZWN0aXZlIj5BbGlhczwvY29kZT4gYW5kIDxjb2RlIGNsYXNzPSJkaXJlY3RpdmUiPlNjcmlwdEFsaWFzPC9jb2RlPgogICAgICBpcyB0aGF0IDxjb2RlIGNsYXNzPSJkaXJlY3RpdmUiPlNjcmlwdEFsaWFzPC9jb2RlPiBoYXMgdGhlIGFkZGVkIG1lYW5pbmcKICAgICAgdGhhdCBldmVyeXRoaW5nIHVuZGVyIHRoYXQgVVJMIHByZWZpeCB3aWxsIGJlIGNvbnNpZGVyZWQgYSBDR0kKICAgICAgcHJvZ3JhbS4gU28sIHRoZSBleGFtcGxlIGFib3ZlIHRlbGxzIEFwYWNoZSB0aGF0IGFueSByZXF1ZXN0IGZvciBhCiAgICAgIHJlc291cmNlIGJlZ2lubmluZyB3aXRoIDxjb2RlPi9jZ2ktYmluLzwvY29kZT4gc2hvdWxkIGJlIHNlcnZlZCBmcm9tCiAgICAgIHRoZSBkaXJlY3RvcnkgIDxjb2RlPi91c3IvbG9jYWwvYXBhY2hlMi9jZ2ktYmluLzwvY29kZT4sIGFuZCBzaG91bGQgYmUKICAgICAgdHJlYXRlZCBhcyBhIENHSSBwcm9ncmFtLjwvcD4KCiAgICAgIDxwPkZvciBleGFtcGxlLCBpZiB0aGUgVVJMCiAgICAgIDxjb2RlPmh0dHA6Ly93d3cuZXhhbXBsZS5jb20vY2dpLWJpbi90ZXN0LnBsPC9jb2RlPgogICAgICBpcyByZXF1ZXN0ZWQsIEFwYWNoZSB3aWxsIGF0dGVtcHQgdG8gZXhlY3V0ZSB0aGUgZmlsZSAKICAgICAgPGNvZGU+L3Vzci9sb2NhbC9hcGFjaGUyL2NnaS1iaW4vdGVzdC5wbDwvY29kZT4KICAgICAgYW5kIHJldHVybiB0aGUgb3V0cHV0LiBPZiBjb3Vyc2UsIHRoZSBmaWxlIHdpbGwgaGF2ZSB0bwogICAgICBleGlzdCwgYW5kIGJlIGV4ZWN1dGFibGUsIGFuZCByZXR1cm4gb3V0cHV0IGluIGEgcGFydGljdWxhcgogICAgICB3YXksIG9yIEFwYWNoZSB3aWxsIHJldHVybiBhbiBlcnJvciBtZXNzYWdlLjwvcD4KICAgIAoKICAgIDxoMz48YSBuYW1lPSJub25zY3JpcHRhbGlhcyIgaWQ9Im5vbnNjcmlwdGFsaWFzIj5DR0kgb3V0c2lkZSBvZiBTY3JpcHRBbGlhcyBkaXJlY3RvcmllczwvYT48L2gzPgogICAgICAKCiAgICAgIDxwPkNHSSBwcm9ncmFtcyBhcmUgb2Z0ZW4gcmVzdHJpY3RlZCB0byA8Y29kZSBjbGFzcz0iZGlyZWN0aXZlIj48YSBocmVmPSIuLi9tb2QvbW9kX2FsaWFzLmh0bWwjc2NyaXB0YWxpYXMiPlNjcmlwdEFsaWFzPC9hPjwvY29kZT4nZWQgZGlyZWN0b3JpZXMgZm9yIHNlY3VyaXR5IHJlYXNvbnMuCiAgICAgIEluIHRoaXMgd2F5LCBhZG1pbmlzdHJhdG9ycyBjYW4gdGlnaHRseSBjb250cm9sIHdobyBpcyBhbGxvd2VkIHRvCiAgICAgIHVzZSBDR0kgcHJvZ3JhbXMuIEhvd2V2ZXIsIGlmIHRoZSBwcm9wZXIgc2VjdXJpdHkgcHJlY2F1dGlvbnMgYXJlCiAgICAgIHRha2VuLCB0aGVyZSBpcyBubyByZWFzb24gd2h5IENHSSBwcm9ncmFtcyBjYW5ub3QgYmUgcnVuIGZyb20KICAgICAgYXJiaXRyYXJ5IGRpcmVjdG9yaWVzLiBGb3IgZXhhbXBsZSwgeW91IG1heSB3aXNoIHRvIGxldCB1c2VycwogICAgICBoYXZlIHdlYiBjb250ZW50IGluIHRoZWlyIGhvbWUgZGlyZWN0b3JpZXMgd2l0aCB0aGUgCiAgICAgIDxjb2RlIGNsYXNzPSJkaXJlY3RpdmUiPjxhIGhyZWY9Ii4uL21vZC9tb2RfdXNlcmRpci5odG1sI3VzZXJkaXIiPlVzZXJEaXI8L2E+PC9jb2RlPiBkaXJlY3RpdmUuCiAgICAgIElmIHRoZXkgd2FudCB0byBoYXZlIHRoZWlyIG93biBDR0kgcHJvZ3JhbXMsIGJ1dCBkb24ndCBoYXZlIGFjY2VzcyB0bwogICAgICB0aGUgbWFpbiA8Y29kZT5jZ2ktYmluPC9jb2RlPiBkaXJlY3RvcnksIHRoZXkgd2lsbCBuZWVkIHRvIGJlIGFibGUgdG8KICAgICAgcnVuIENHSSBwcm9ncmFtcyBlbHNld2hlcmUuPC9wPgoKICAgICAgPHA+VGhlcmUgYXJlIHR3byBzdGVwcyB0byBhbGxvd2luZyBDR0kgZXhlY3V0aW9uIGluIGFuIGFyYml0cmFyeQogICAgICBkaXJlY3RvcnkuICBGaXJzdCwgdGhlIDxjb2RlPmNnaS1zY3JpcHQ8L2NvZGU+IGhhbmRsZXIgbXVzdCBiZQogICAgICBhY3RpdmF0ZWQgdXNpbmcgdGhlIDxjb2RlIGNsYXNzPSJkaXJlY3RpdmUiPjxhIGhyZWY9Ii4uL21vZC9tb2RfbWltZS5odG1sI2FkZGhhbmRsZXIiPkFkZEhhbmRsZXI8L2E+PC9jb2RlPiBvciA8Y29kZSBjbGFzcz0iZGlyZWN0aXZlIj48YSBocmVmPSIuLi9tb2QvY29yZS5odG1sI3NldGhhbmRsZXIiPlNldEhhbmRsZXI8L2E+PC9jb2RlPiBkaXJlY3RpdmUuICBTZWNvbmQsCiAgICAgIDxjb2RlPkV4ZWNDR0k8L2NvZGU+IG11c3QgYmUgc3BlY2lmaWVkIGluIHRoZSA8Y29kZSBjbGFzcz0iZGlyZWN0aXZlIj48YSBocmVmPSIuLi9tb2QvY29yZS5odG1sI29wdGlvbnMiPk9wdGlvbnM8L2E+PC9jb2RlPiBkaXJlY3RpdmUuPC9wPiAKICAgIAoKICAgIDxoMz48YSBuYW1lPSJvcHRpb25zIiBpZD0ib3B0aW9ucyI+RXhwbGljaXRseSB1c2luZyBPcHRpb25zIHRvIHBlcm1pdCBDR0kgZXhlY3V0aW9uPC9hPjwvaDM+CiAgICAgIAoKICAgICAgPHA+WW91IGNvdWxkIGV4cGxpY2l0bHkgdXNlIHRoZSA8Y29kZSBjbGFzcz0iZGlyZWN0aXZlIj48YSBocmVmPSIuLi9tb2QvY29yZS5odG1sI29wdGlvbnMiPk9wdGlvbnM8L2E+PC9jb2RlPiBkaXJlY3RpdmUsIGluc2lkZSB5b3VyIG1haW4gc2VydmVyIGNvbmZpZ3VyYXRpb24KICAgICAgZmlsZSwgdG8gc3BlY2lmeSB0aGF0IENHSSBleGVjdXRpb24gd2FzIHBlcm1pdHRlZCBpbiBhIHBhcnRpY3VsYXIKICAgICAgZGlyZWN0b3J5OjwvcD4KCiAgICAgIDxkaXYgY2xhc3M9ImV4YW1wbGUiPjxwPjxjb2RlPgogICAgICAgICZsdDtEaXJlY3RvcnkgL3Vzci9sb2NhbC9hcGFjaGUyL2h0ZG9jcy9zb21lZGlyJmd0OzxiciAvPgogICAgICAgIDxzcGFuIGNsYXNzPSJpbmRlbnQiPgogICAgICAgICAgT3B0aW9ucyArRXhlY0NHSTxiciAvPgogICAgICAgIDwvc3Bhbj4KICAgICAgICAmbHQ7L0RpcmVjdG9yeSZndDsKICAgICAgPC9jb2RlPjwvcD48L2Rpdj4KCiAgICAgIDxwPlRoZSBhYm92ZSBkaXJlY3RpdmUgdGVsbHMgQXBhY2hlIHRvIHBlcm1pdCB0aGUgZXhlY3V0aW9uCiAgICAgIG9mIENHSSBmaWxlcy4gWW91IHdpbGwgYWxzbyBuZWVkIHRvIHRlbGwgdGhlIHNlcnZlciB3aGF0CiAgICAgIGZpbGVzIGFyZSBDR0kgZmlsZXMuIFRoZSBmb2xsb3dpbmcgPGNvZGUgY2xhc3M9ImRpcmVjdGl2ZSI+PGEgaHJlZj0iLi4vbW9kL21vZF9taW1lLmh0bWwjYWRkaGFuZGxlciI+QWRkSGFuZGxlcjwvYT48L2NvZGU+IGRpcmVjdGl2ZSB0ZWxscyB0aGUgc2VydmVyIHRvIHRyZWF0IGFsbAogICAgICBmaWxlcyB3aXRoIHRoZSA8Y29kZT5jZ2k8L2NvZGU+IG9yIDxjb2RlPnBsPC9jb2RlPiBleHRlbnNpb24gYXMgQ0dJCiAgICAgIHByb2dyYW1zOjwvcD4KCiAgICAgIDxkaXYgY2xhc3M9ImV4YW1wbGUiPjxwPjxjb2RlPgogICAgICAgIEFkZEhhbmRsZXIgY2dpLXNjcmlwdCAuY2dpIC5wbAogICAgICA8L2NvZGU+PC9wPjwvZGl2PgogICAgCgogICAgPGgzPjxhIG5hbWU9Imh0YWNjZXNzIiBpZD0iaHRhY2Nlc3MiPi5odGFjY2VzcyBmaWxlczwvYT48L2gzPgogICAgICAKCiAgICAgIDxwPlRoZSA8YSBocmVmPSJodGFjY2Vzcy5odG1sIj48Y29kZT4uaHRhY2Nlc3M8L2NvZGU+IHR1dG9yaWFsPC9hPgogICAgICBzaG93cyBob3cgdG8gYWN0aXZhdGUgQ0dJIHByb2dyYW1zIGlmIHlvdSBkbyBub3QgaGF2ZQogICAgICBhY2Nlc3MgdG8gPGNvZGU+aHR0cGQuY29uZjwvY29kZT4uPC9wPgogICAgCgogICAgPGgzPjxhIG5hbWU9InVzZXJkaXIiIGlkPSJ1c2VyZGlyIj5Vc2VyIERpcmVjdG9yaWVzPC9hPjwvaDM+CiAgICAgIAoKICAgICAgPHA+VG8gYWxsb3cgQ0dJIHByb2dyYW0gZXhlY3V0aW9uIGZvciBhbnkgZmlsZSBlbmRpbmcgaW4KICAgICAgPGNvZGU+LmNnaTwvY29kZT4gaW4gdXNlcnMnIGRpcmVjdG9yaWVzLCB5b3UgY2FuIHVzZSB0aGUKICAgICAgZm9sbG93aW5nIGNvbmZpZ3VyYXRpb24uPC9wPgoKICAgICAgPGRpdiBjbGFzcz0iZXhhbXBsZSI+PHA+PGNvZGU+CiAgICAgICZsdDtEaXJlY3RvcnkgL2hvbWUvKi9wdWJsaWNfaHRtbCZndDs8YnIgLz4KICAgICAgPHNwYW4gY2xhc3M9ImluZGVudCI+CiAgICAgICAgT3B0aW9ucyArRXhlY0NHSTxiciAvPgogICAgICAgIEFkZEhhbmRsZXIgY2dpLXNjcmlwdCAuY2dpPGJyIC8+CiAgICAgIDwvc3Bhbj4KICAgICAgJmx0Oy9EaXJlY3RvcnkmZ3Q7CiAgICAgIDwvY29kZT48L3A+PC9kaXY+CgogICAgICA8cD5JZiB5b3Ugd2lzaCBkZXNpZ25hdGUgYSA8Y29kZT5jZ2ktYmluPC9jb2RlPiBzdWJkaXJlY3Rvcnkgb2YKICAgICAgYSB1c2VyJ3MgZGlyZWN0b3J5IHdoZXJlIGV2ZXJ5dGhpbmcgd2lsbCBiZSB0cmVhdGVkIGFzIGEgQ0dJCiAgICAgIHByb2dyYW0sIHlvdSBjYW4gdXNlIHRoZSBmb2xsb3dpbmcuPC9wPgoKICAgICAgPGRpdiBjbGFzcz0iZXhhbXBsZSI+PHA+PGNvZGU+CiAgICAgICZsdDtEaXJlY3RvcnkgL2hvbWUvKi9wdWJsaWNfaHRtbC9jZ2ktYmluJmd0OzxiciAvPgogICAgICA8c3BhbiBjbGFzcz0iaW5kZW50Ij4KICAgICAgICBPcHRpb25zIEV4ZWNDR0k8YnIgLz4KICAgICAgICBTZXRIYW5kbGVyIGNnaS1zY3JpcHQ8YnIgLz4KICAgICAgPC9zcGFuPgogICAgICAmbHQ7L0RpcmVjdG9yeSZndDsKICAgICAgPC9jb2RlPjwvcD48L2Rpdj4KCiAgICAKCiAgPC9kaXY+PGRpdiBjbGFzcz0idG9wIj48YSBocmVmPSIjcGFnZS1oZWFkZXIiPjxpbWcgYWx0PSJ0b3AiIHNyYz0iLi4vaW1hZ2VzL3VwLmdpZiIgLz48L2E+PC9kaXY+CjxkaXYgY2xhc3M9InNlY3Rpb24iPgo8aDI+PGEgbmFtZT0id3JpdGluZyIgaWQ9IndyaXRpbmciPldyaXRpbmcgYSBDR0kgcHJvZ3JhbTwvYT48L2gyPgogICAgCgogICAgPHA+VGhlcmUgYXJlIHR3byBtYWluIGRpZmZlcmVuY2VzIGJldHdlZW4gYGByZWd1bGFyJycKICAgIHByb2dyYW1taW5nLCBhbmQgQ0dJIHByb2dyYW1taW5nLjwvcD4KCiAgICA8cD5GaXJzdCwgYWxsIG91dHB1dCBmcm9tIHlvdXIgQ0dJIHByb2dyYW0gbXVzdCBiZSBwcmVjZWRlZCBieQogICAgYSA8YSBjbGFzcz0iZ2xvc3NhcnlsaW5rIiBocmVmPSIuLi9nbG9zc2FyeS5odG1sI21pbWUtdHlwZSIgdGl0bGU9InNlZSBnbG9zc2FyeSI+TUlNRS10eXBlPC9hPiBoZWFkZXIuIFRoaXMgaXMgSFRUUCBoZWFkZXIgdGhhdCB0ZWxscyB0aGUgY2xpZW50CiAgICB3aGF0IHNvcnQgb2YgY29udGVudCBpdCBpcyByZWNlaXZpbmcuIE1vc3Qgb2YgdGhlIHRpbWUsIHRoaXMKICAgIHdpbGwgbG9vayBsaWtlOjwvcD4KCiAgICA8ZGl2IGNsYXNzPSJleGFtcGxlIj48cD48Y29kZT4KICAgICAgQ29udGVudC10eXBlOiB0ZXh0L2h0bWwKICAgIDwvY29kZT48L3A+PC9kaXY+CgogICAgPHA+U2Vjb25kbHksIHlvdXIgb3V0cHV0IG5lZWRzIHRvIGJlIGluIEhUTUwsIG9yIHNvbWUgb3RoZXIKICAgIGZvcm1hdCB0aGF0IGEgYnJvd3NlciB3aWxsIGJlIGFibGUgdG8gZGlzcGxheS4gTW9zdCBvZiB0aGUKICAgIHRpbWUsIHRoaXMgd2lsbCBiZSBIVE1MLCBidXQgb2NjYXNpb25hbGx5IHlvdSBtaWdodCB3cml0ZSBhIENHSQogICAgcHJvZ3JhbSB0aGF0IG91dHB1dHMgYSBnaWYgaW1hZ2UsIG9yIG90aGVyIG5vbi1IVE1MCiAgICBjb250ZW50LjwvcD4KCiAgICA8cD5BcGFydCBmcm9tIHRob3NlIHR3byB0aGluZ3MsIHdyaXRpbmcgYSBDR0kgcHJvZ3JhbSB3aWxsIGxvb2sKICAgIGEgbG90IGxpa2UgYW55IG90aGVyIHByb2dyYW0gdGhhdCB5b3UgbWlnaHQgd3JpdGUuPC9wPgoKICAgIDxoMz48YSBuYW1lPSJmaXJzdGNnaSIgaWQ9ImZpcnN0Y2dpIj5Zb3VyIGZpcnN0IENHSSBwcm9ncmFtPC9hPjwvaDM+CiAgICAgIAoKICAgICAgPHA+VGhlIGZvbGxvd2luZyBpcyBhbiBleGFtcGxlIENHSSBwcm9ncmFtIHRoYXQgcHJpbnRzIG9uZQogICAgICBsaW5lIHRvIHlvdXIgYnJvd3Nlci4gVHlwZSBpbiB0aGUgZm9sbG93aW5nLCBzYXZlIGl0IHRvIGEKICAgICAgZmlsZSBjYWxsZWQgPGNvZGU+Zmlyc3QucGw8L2NvZGU+LCBhbmQgcHV0IGl0IGluIHlvdXIgCiAgICAgIDxjb2RlPmNnaS1iaW48L2NvZGU+IGRpcmVjdG9yeS48L3A+CgogICAgICA8ZGl2IGNsYXNzPSJleGFtcGxlIj48cD48Y29kZT4KICAgICAgICAjIS91c3IvYmluL3Blcmw8YnIgLz4KICAgICAgICBwcmludCAiQ29udGVudC10eXBlOiB0ZXh0L2h0bWxcblxuIjs8YnIgLz4KICAgICAgICBwcmludCAiSGVsbG8sIFdvcmxkLiI7CiAgICAgIDwvY29kZT48L3A+PC9kaXY+CgogICAgICA8cD5FdmVuIGlmIHlvdSBhcmUgbm90IGZhbWlsaWFyIHdpdGggUGVybCwgeW91IHNob3VsZCBiZSBhYmxlCiAgICAgIHRvIHNlZSB3aGF0IGlzIGhhcHBlbmluZyBoZXJlLiBUaGUgZmlyc3QgbGluZSB0ZWxscyBBcGFjaGUKICAgICAgKG9yIHdoYXRldmVyIHNoZWxsIHlvdSBoYXBwZW4gdG8gYmUgcnVubmluZyB1bmRlcikgdGhhdCB0aGlzCiAgICAgIHByb2dyYW0gY2FuIGJlIGV4ZWN1dGVkIGJ5IGZlZWRpbmcgdGhlIGZpbGUgdG8gdGhlCiAgICAgIGludGVycHJldGVyIGZvdW5kIGF0IHRoZSBsb2NhdGlvbiA8Y29kZT4vdXNyL2Jpbi9wZXJsPC9jb2RlPi4KICAgICAgVGhlIHNlY29uZCBsaW5lIHByaW50cyB0aGUgY29udGVudC10eXBlIGRlY2xhcmF0aW9uIHdlCiAgICAgIHRhbGtlZCBhYm91dCwgZm9sbG93ZWQgYnkgdHdvIGNhcnJpYWdlLXJldHVybiBuZXdsaW5lIHBhaXJzLgogICAgICBUaGlzIHB1dHMgYSBibGFuayBsaW5lIGFmdGVyIHRoZSBoZWFkZXIsIHRvIGluZGljYXRlIHRoZSBlbmQKICAgICAgb2YgdGhlIEhUVFAgaGVhZGVycywgYW5kIHRoZSBiZWdpbm5pbmcgb2YgdGhlIGJvZHkuIFRoZSB0aGlyZAogICAgICBsaW5lIHByaW50cyB0aGUgc3RyaW5nICJIZWxsbywgV29ybGQuIi4gQW5kIHRoYXQncyB0aGUgZW5kCiAgICAgIG9mIGl0LjwvcD4KCiAgICAgIDxwPklmIHlvdSBvcGVuIHlvdXIgZmF2b3JpdGUgYnJvd3NlciBhbmQgdGVsbCBpdCB0byBnZXQgdGhlCiAgICAgIGFkZHJlc3M8L3A+CgogICAgICA8ZGl2IGNsYXNzPSJleGFtcGxlIj48cD48Y29kZT4KICAgICAgICBodHRwOi8vd3d3LmV4YW1wbGUuY29tL2NnaS1iaW4vZmlyc3QucGwKICAgICAgPC9jb2RlPjwvcD48L2Rpdj4KCiAgICAgIDxwPm9yIHdoZXJldmVyIHlvdSBwdXQgeW91ciBmaWxlLCB5b3Ugd2lsbCBzZWUgdGhlIG9uZSBsaW5lIAogICAgICA8Y29kZT5IZWxsbywgV29ybGQuPC9jb2RlPiBhcHBlYXIgaW4geW91ciBicm93c2VyIHdpbmRvdy4KICAgICAgSXQncyBub3QgdmVyeSBleGNpdGluZywgYnV0IG9uY2UgeW91IGdldCB0aGF0IHdvcmtpbmcsIHlvdSdsbAogICAgICBoYXZlIGEgZ29vZCBjaGFuY2Ugb2YgZ2V0dGluZyBqdXN0IGFib3V0IGFueXRoaW5nIHdvcmtpbmcuPC9wPgogICAgCiAgPC9kaXY+PGRpdiBjbGFzcz0idG9wIj48YSBocmVmPSIjcGFnZS1oZWFkZXIiPjxpbWcgYWx0PSJ0b3AiIHNyYz0iLi4vaW1hZ2VzL3VwLmdpZiIgLz48L2E+PC9kaXY+CjxkaXYgY2xhc3M9InNlY3Rpb24iPgo8aDI+PGEgbmFtZT0idHJvdWJsZXNob290IiBpZD0idHJvdWJsZXNob290Ij5CdXQgaXQncyBzdGlsbCBub3Qgd29ya2luZyE8L2E+PC9oMj4KICAgIAoKICAgIDxwPlRoZXJlIGFyZSBmb3VyIGJhc2ljIHRoaW5ncyB0aGF0IHlvdSBtYXkgc2VlIGluIHlvdXIgYnJvd3NlcgogICAgd2hlbiB5b3UgdHJ5IHRvIGFjY2VzcyB5b3VyIENHSSBwcm9ncmFtIGZyb20gdGhlIHdlYjo8L3A+CgogICAgPGRsPgogICAgICA8ZHQ+VGhlIG91dHB1dCBvZiB5b3VyIENHSSBwcm9ncmFtPC9kdD4KICAgICAgPGRkPkdyZWF0ISBUaGF0IG1lYW5zIGV2ZXJ5dGhpbmcgd29ya2VkIGZpbmUuICBJZiB0aGUgb3V0cHV0IGlzIGNvcnJlY3QsCiAgICAgIGJ1dCB0aGUgYnJvd3NlciBpcyBub3QgcHJvY2Vzc2luZyBpdCBjb3JyZWN0bHksIG1ha2Ugc3VyZSB5b3UgaGF2ZSB0aGUKICAgICAgY29ycmVjdCA8Y29kZT5Db250ZW50LVR5cGU8L2NvZGU+IHNldCBpbiB5b3VyIENHSSBwcm9ncmFtLjwvZGQ+CgogICAgICA8ZHQ+VGhlIHNvdXJjZSBjb2RlIG9mIHlvdXIgQ0dJIHByb2dyYW0gb3IgYSAiUE9TVCBNZXRob2QgTm90CiAgICAgIEFsbG93ZWQiIG1lc3NhZ2U8L2R0PgogICAgICA8ZGQ+VGhhdCBtZWFucyB0aGF0IHlvdSBoYXZlIG5vdCBwcm9wZXJseSBjb25maWd1cmVkIEFwYWNoZQogICAgICB0byBwcm9jZXNzIHlvdXIgQ0dJIHByb2dyYW0uIFJlcmVhZCB0aGUgc2VjdGlvbiBvbiAKICAgICAgPGEgaHJlZj0iI2NvbmZpZ3VyaW5nIj5jb25maWd1cmluZwogICAgICBBcGFjaGU8L2E+IGFuZCB0cnkgdG8gZmluZCB3aGF0IHlvdSBtaXNzZWQuPC9kZD4KCiAgICAgIDxkdD5BIG1lc3NhZ2Ugc3RhcnRpbmcgd2l0aCAiRm9yYmlkZGVuIjwvZHQ+CiAgICAgIDxkZD5UaGF0IG1lYW5zIHRoYXQgdGhlcmUgaXMgYSBwZXJtaXNzaW9ucyBwcm9ibGVtLiBDaGVjayB0aGUKICAgICAgPGEgaHJlZj0iI2Vycm9ybG9ncyI+QXBhY2hlIGVycm9yIGxvZzwvYT4gYW5kIHRoZSBzZWN0aW9uIGJlbG93IG9uCiAgICAgIDxhIGhyZWY9IiNwZXJtaXNzaW9ucyI+ZmlsZSBwZXJtaXNzaW9uczwvYT4uPC9kZD4KCiAgICAgIDxkdD5BIG1lc3NhZ2Ugc2F5aW5nICJJbnRlcm5hbCBTZXJ2ZXIgRXJyb3IiPC9kdD4KICAgICAgPGRkPklmIHlvdSBjaGVjayB0aGUgCiAgICAgIDxhIGhyZWY9IiNlcnJvcmxvZ3MiPkFwYWNoZSBlcnJvciBsb2c8L2E+LCB5b3Ugd2lsbCBwcm9iYWJseQogICAgICBmaW5kIHRoYXQgaXQgc2F5cyAiUHJlbWF0dXJlIGVuZCBvZgogICAgICBzY3JpcHQgaGVhZGVycyIsIHBvc3NpYmx5IGFsb25nIHdpdGggYW4gZXJyb3IgbWVzc2FnZQogICAgICBnZW5lcmF0ZWQgYnkgeW91ciBDR0kgcHJvZ3JhbS4gSW4gdGhpcyBjYXNlLCB5b3Ugd2lsbCB3YW50IHRvCiAgICAgIGNoZWNrIGVhY2ggb2YgdGhlIGJlbG93IHNlY3Rpb25zIHRvIHNlZSB3aGF0IG1pZ2h0IGJlCiAgICAgIHByZXZlbnRpbmcgeW91ciBDR0kgcHJvZ3JhbSBmcm9tIGVtaXR0aW5nIHRoZSBwcm9wZXIgSFRUUAogICAgICBoZWFkZXJzLjwvZGQ+CiAgICA8L2RsPgoKICAgIDxoMz48YSBuYW1lPSJwZXJtaXNzaW9ucyIgaWQ9InBlcm1pc3Npb25zIj5GaWxlIHBlcm1pc3Npb25zPC9hPjwvaDM+CiAgICAgIAoKICAgICAgPHA+UmVtZW1iZXIgdGhhdCB0aGUgc2VydmVyIGRvZXMgbm90IHJ1biBhcyB5b3UuIFRoYXQgaXMsCiAgICAgIHdoZW4gdGhlIHNlcnZlciBzdGFydHMgdXAsIGl0IGlzIHJ1bm5pbmcgd2l0aCB0aGUgcGVybWlzc2lvbnMKICAgICAgb2YgYW4gdW5wcml2aWxlZ2VkIHVzZXIgLSB1c3VhbGx5IDxjb2RlPm5vYm9keTwvY29kZT4sIG9yCiAgICAgIDxjb2RlPnd3dzwvY29kZT4gLSBhbmQgc28gaXQgd2lsbCBuZWVkIGV4dHJhIHBlcm1pc3Npb25zIHRvCiAgICAgIGV4ZWN1dGUgZmlsZXMgdGhhdCBhcmUgb3duZWQgYnkgeW91LiBVc3VhbGx5LCB0aGUgd2F5IHRvIGdpdmUKICAgICAgYSBmaWxlIHN1ZmZpY2llbnQgcGVybWlzc2lvbnMgdG8gYmUgZXhlY3V0ZWQgYnkgPGNvZGU+bm9ib2R5PC9jb2RlPgogICAgICBpcyB0byBnaXZlIGV2ZXJ5b25lIGV4ZWN1dGUgcGVybWlzc2lvbiBvbiB0aGUgZmlsZTo8L3A+CgogICAgICA8ZGl2IGNsYXNzPSJleGFtcGxlIj48cD48Y29kZT4KICAgICAgICBjaG1vZCBhK3ggZmlyc3QucGwKICAgICAgPC9jb2RlPjwvcD48L2Rpdj4KCiAgICAgIDxwPkFsc28sIGlmIHlvdXIgcHJvZ3JhbSByZWFkcyBmcm9tLCBvciB3cml0ZXMgdG8sIGFueSBvdGhlcgogICAgICBmaWxlcywgdGhvc2UgZmlsZXMgd2lsbCBuZWVkIHRvIGhhdmUgdGhlIGNvcnJlY3QgcGVybWlzc2lvbnMKICAgICAgdG8gcGVybWl0IHRoaXMuPC9wPgoKICAgIAoKICAgIDxoMz48YSBuYW1lPSJwYXRoaW5mb3JtYXRpb24iIGlkPSJwYXRoaW5mb3JtYXRpb24iPlBhdGggaW5mb3JtYXRpb24gYW5kIGVudmlyb25tZW50PC9hPjwvaDM+CiAgICAgIAoKICAgICAgPHA+V2hlbiB5b3UgcnVuIGEgcHJvZ3JhbSBmcm9tIHlvdXIgY29tbWFuZCBsaW5lLCB5b3UgaGF2ZQogICAgICBjZXJ0YWluIGluZm9ybWF0aW9uIHRoYXQgaXMgcGFzc2VkIHRvIHRoZSBzaGVsbCB3aXRob3V0IHlvdQogICAgICB0aGlua2luZyBhYm91dCBpdC4gRm9yIGV4YW1wbGUsIHlvdSBoYXZlIGEgPGNvZGU+UEFUSDwvY29kZT4sCiAgICAgIHdoaWNoIHRlbGxzIHRoZSBzaGVsbCB3aGVyZSBpdCBjYW4gbG9vayBmb3IgZmlsZXMgdGhhdCB5b3UKICAgICAgcmVmZXJlbmNlLjwvcD4KCiAgICAgIDxwPldoZW4gYSBwcm9ncmFtIHJ1bnMgdGhyb3VnaCB0aGUgd2ViIHNlcnZlciBhcyBhIENHSSBwcm9ncmFtLAogICAgICBpdCBtYXkgbm90IGhhdmUgdGhlIHNhbWUgPGNvZGU+UEFUSDwvY29kZT4uIEFueSBwcm9ncmFtcyB0aGF0IHlvdQogICAgICBpbnZva2UgaW4geW91ciBDR0kgcHJvZ3JhbSAobGlrZSA8Y29kZT5zZW5kbWFpbDwvY29kZT4sIGZvcgogICAgICBleGFtcGxlKSB3aWxsIG5lZWQgdG8gYmUgc3BlY2lmaWVkIGJ5IGEgZnVsbCBwYXRoLCBzbyB0aGF0IHRoZQogICAgICBzaGVsbCBjYW4gZmluZCB0aGVtIHdoZW4gaXQgYXR0ZW1wdHMgdG8gZXhlY3V0ZSB5b3VyIENHSQogICAgICBwcm9ncmFtLjwvcD4KCiAgICAgIDxwPkEgY29tbW9uIG1hbmlmZXN0YXRpb24gb2YgdGhpcyBpcyB0aGUgcGF0aCB0byB0aGUgc2NyaXB0CiAgICAgIGludGVycHJldGVyIChvZnRlbiA8Y29kZT5wZXJsPC9jb2RlPikgaW5kaWNhdGVkIGluIHRoZSBmaXJzdAogICAgICBsaW5lIG9mIHlvdXIgQ0dJIHByb2dyYW0sIHdoaWNoIHdpbGwgbG9vayBzb21ldGhpbmcgbGlrZTo8L3A+CgogICAgICA8ZGl2IGNsYXNzPSJleGFtcGxlIj48cD48Y29kZT4KICAgICAgICAjIS91c3IvYmluL3BlcmwKICAgICAgPC9jb2RlPjwvcD48L2Rpdj4KCiAgICAgIDxwPk1ha2Ugc3VyZSB0aGF0IHRoaXMgaXMgaW4gZmFjdCB0aGUgcGF0aCB0byB0aGUKICAgICAgaW50ZXJwcmV0ZXIuPC9wPgogICAgICA8ZGl2IGNsYXNzPSJ3YXJuaW5nIj4KICAgICAgV2hlbiBlZGl0aW5nIENHSSBzY3JpcHRzIG9uIFdpbmRvd3MsIGVuZC1vZi1saW5lIGNoYXJhY3RlcnMgbWF5IGJlCiAgICAgIGFwcGVuZGVkIHRvIHRoZSBpbnRlcnByZXRlciBwYXRoLiBFbnN1cmUgdGhhdCBmaWxlcyBhcmUgdGhlbgogICAgICB0cmFuc2ZlcnJlZCB0byB0aGUgc2VydmVyIGluIEFTQ0lJIG1vZGUuIEZhaWx1cmUgdG8gZG8gc28gbWF5CiAgICAgIHJlc3VsdCBpbiAiQ29tbWFuZCBub3QgZm91bmQiIHdhcm5pbmdzIGZyb20gdGhlIE9TLCBkdWUgdG8gdGhlCiAgICAgIHVucmVjb2duaXplZCBlbmQtb2YtbGluZSBjaGFyYWN0ZXIgYmVpbmcgaW50ZXJwcmV0ZWQgYXMgYSBwYXJ0IG9mCiAgICAgIHRoZSBpbnRlcnByZXRlciBmaWxlbmFtZS4KICAgICAgPC9kaXY+CiAgICAKCiAgICA8aDM+PGEgbmFtZT0ibWlzc2luZ2VudiIgaWQ9Im1pc3NpbmdlbnYiPk1pc3NpbmcgZW52aXJvbm1lbnQgdmFyaWFibGVzPC9hPjwvaDM+CiAgICAgIAoKICAgICAgPHA+SWYgeW91ciBDR0kgcHJvZ3JhbSBkZXBlbmRzIG9uIG5vbi1zdGFuZGFyZCA8YSBocmVmPSIjZW52Ij5lbnZpcm9ubWVudCB2YXJpYWJsZXM8L2E+LCB5b3Ugd2lsbCBuZWVkIHRvCiAgICAgIGFzc3VyZSB0aGF0IHRob3NlIHZhcmlhYmxlcyBhcmUgcGFzc2VkIGJ5IEFwYWNoZS48L3A+CgogICAgICA8cD5XaGVuIHlvdSBtaXNzIEhUVFAgaGVhZGVycyBmcm9tIHRoZSBlbnZpcm9ubWVudCwgbWFrZQogICAgICBzdXJlIHRoZXkgYXJlIGZvcm1hdHRlZCBhY2NvcmRpbmcgdG8gCiAgICAgIDxhIGhyZWY9Imh0dHA6Ly90b29scy5pZXRmLm9yZy9odG1sL3JmYzI2MTYiPlJGQyAyNjE2PC9hPiwKICAgICAgc2VjdGlvbiA0LjI6IEhlYWRlciBuYW1lcyBtdXN0IHN0YXJ0IHdpdGggYSBsZXR0ZXIsIAogICAgICBmb2xsb3dlZCBvbmx5IGJ5IGxldHRlcnMsIG51bWJlcnMgb3IgaHlwaGVuLiBBbnkgaGVhZGVyCiAgICAgIHZpb2xhdGluZyB0aGlzIHJ1bGUgd2lsbCBiZSBkcm9wcGVkIHNpbGVudGx5LjwvcD4KCiAgICAKCiAgICA8aDM+PGEgbmFtZT0ic3ludGF4ZXJyb3JzIiBpZD0ic3ludGF4ZXJyb3JzIj5Qcm9ncmFtIGVycm9yczwvYT48L2gzPgogICAgICAKCiAgICAgIDxwPk1vc3Qgb2YgdGhlIHRpbWUgd2hlbiBhIENHSSBwcm9ncmFtIGZhaWxzLCBpdCdzIGJlY2F1c2Ugb2YKICAgICAgYSBwcm9ibGVtIHdpdGggdGhlIHByb2dyYW0gaXRzZWxmLiBUaGlzIGlzIHBhcnRpY3VsYXJseSB0cnVlCiAgICAgIG9uY2UgeW91IGdldCB0aGUgaGFuZyBvZiB0aGlzIENHSSBzdHVmZiwgYW5kIG5vIGxvbmdlciBtYWtlCiAgICAgIHRoZSBhYm92ZSB0d28gbWlzdGFrZXMuICBUaGUgZmlyc3QgdGhpbmcgdG8gZG8gaXMgdG8gbWFrZQogICAgICBzdXJlIHRoYXQgeW91ciBwcm9ncmFtIHJ1bnMgZnJvbSB0aGUgY29tbWFuZCBsaW5lIGJlZm9yZQogICAgICB0ZXN0aW5nIGl0IHZpYSB0aGUgd2ViIHNlcnZlci4gIEZvciBleGFtcGxlLCB0cnk6PC9wPgoKICAgICAgPGRpdiBjbGFzcz0iZXhhbXBsZSI+PHA+PGNvZGU+CiAgICAgIGNkIC91c3IvbG9jYWwvYXBhY2hlMi9jZ2ktYmluPGJyIC8+CiAgICAgIC4vZmlyc3QucGwKICAgICAgPC9jb2RlPjwvcD48L2Rpdj4KCiAgICAgIDxwPihEbyBub3QgY2FsbCB0aGUgPGNvZGU+cGVybDwvY29kZT4gaW50ZXJwcmV0ZXIuICBUaGUgc2hlbGwKICAgICAgYW5kIEFwYWNoZSBzaG91bGQgZmluZCB0aGUgaW50ZXJwcmV0ZXIgdXNpbmcgdGhlIDxhIGhyZWY9IiNwYXRoaW5mb3JtYXRpb24iPnBhdGggaW5mb3JtYXRpb248L2E+IG9uIHRoZSBmaXJzdCBsaW5lIG9mCiAgICAgIHRoZSBzY3JpcHQuKTwvcD4KCiAgICAgIDxwPlRoZSBmaXJzdCB0aGluZyB5b3Ugc2VlIHdyaXR0ZW4gYnkgeW91ciBwcm9ncmFtIHNob3VsZCBiZQogICAgICBhIHNldCBvZiBIVFRQIGhlYWRlcnMsIGluY2x1ZGluZyB0aGUgPGNvZGU+Q29udGVudC1UeXBlPC9jb2RlPiwKICAgICAgZm9sbG93ZWQgYnkgYSBibGFuayBsaW5lLiAgSWYgeW91IHNlZSBhbnl0aGluZyBlbHNlLCBBcGFjaGUgd2lsbAogICAgICByZXR1cm4gdGhlIDxjb2RlPlByZW1hdHVyZSBlbmQgb2Ygc2NyaXB0IGhlYWRlcnM8L2NvZGU+IGVycm9yIGlmCiAgICAgIHlvdSB0cnkgdG8gcnVuIGl0IHRocm91Z2ggdGhlIHNlcnZlci4gU2VlIDxhIGhyZWY9IiN3cml0aW5nIj5Xcml0aW5nIGEgQ0dJIHByb2dyYW08L2E+IGFib3ZlIGZvciBtb3JlCiAgICAgIGRldGFpbHMuPC9wPgogICAgCgogICAgPGgzPjxhIG5hbWU9ImVycm9ybG9ncyIgaWQ9ImVycm9ybG9ncyI+RXJyb3IgbG9nczwvYT48L2gzPgogICAgICAKCiAgICAgIDxwPlRoZSBlcnJvciBsb2dzIGFyZSB5b3VyIGZyaWVuZC4gQW55dGhpbmcgdGhhdCBnb2VzIHdyb25nCiAgICAgIGdlbmVyYXRlcyBtZXNzYWdlIGluIHRoZSBlcnJvciBsb2cuIFlvdSBzaG91bGQgYWx3YXlzIGxvb2sKICAgICAgdGhlcmUgZmlyc3QuIElmIHRoZSBwbGFjZSB3aGVyZSB5b3UgYXJlIGhvc3RpbmcgeW91ciB3ZWIgc2l0ZQogICAgICBkb2VzIG5vdCBwZXJtaXQgeW91IGFjY2VzcyB0byB0aGUgZXJyb3IgbG9nLCB5b3Ugc2hvdWxkCiAgICAgIHByb2JhYmx5IGhvc3QgeW91ciBzaXRlIHNvbWV3aGVyZSBlbHNlLiBMZWFybiB0byByZWFkIHRoZQogICAgICBlcnJvciBsb2dzLCBhbmQgeW91J2xsIGZpbmQgdGhhdCBhbG1vc3QgYWxsIG9mIHlvdXIgcHJvYmxlbXMKICAgICAgYXJlIHF1aWNrbHkgaWRlbnRpZmllZCwgYW5kIHF1aWNrbHkgc29sdmVkLjwvcD4KICAgIAoKICAgIDxoMz48YSBuYW1lPSJzdWV4ZWMiIGlkPSJzdWV4ZWMiPlN1ZXhlYzwvYT48L2gzPgogICAgICAKCiAgICAgIDxwPlRoZSA8YSBocmVmPSIuLi9zdWV4ZWMuaHRtbCI+c3VleGVjPC9hPiBzdXBwb3J0IHByb2dyYW0KICAgICAgYWxsb3dzIENHSSBwcm9ncmFtcyB0byBiZSBydW4gdW5kZXIgZGlmZmVyZW50IHVzZXIgcGVybWlzc2lvbnMsCiAgICAgIGRlcGVuZGluZyBvbiB3aGljaCB2aXJ0dWFsIGhvc3Qgb3IgdXNlciBob21lIGRpcmVjdG9yeSB0aGV5IGFyZQogICAgICBsb2NhdGVkIGluLiBTdWV4ZWMgaGFzIHZlcnkgc3RyaWN0IHBlcm1pc3Npb24gY2hlY2tpbmcsIGFuZCBhbnkKICAgICAgZmFpbHVyZSBpbiB0aGF0IGNoZWNraW5nIHdpbGwgcmVzdWx0IGluIHlvdXIgQ0dJIHByb2dyYW1zCiAgICAgIGZhaWxpbmcgd2l0aCA8Y29kZT5QcmVtYXR1cmUgZW5kIG9mIHNjcmlwdCBoZWFkZXJzPC9jb2RlPi48L3A+CgogICAgICA8cD5UbyBjaGVjayBpZiB5b3UgYXJlIHVzaW5nIHN1ZXhlYywgcnVuIDxjb2RlPmFwYWNoZWN0bAogICAgICAtVjwvY29kZT4gYW5kIGNoZWNrIGZvciB0aGUgbG9jYXRpb24gb2YgPGNvZGU+U1VFWEVDX0JJTjwvY29kZT4uCiAgICAgIElmIEFwYWNoZSBmaW5kcyBhbiA8Y29kZSBjbGFzcz0icHJvZ3JhbSI+PGEgaHJlZj0iLi4vcHJvZ3JhbXMvc3VleGVjLmh0bWwiPnN1ZXhlYzwvYT48L2NvZGU+IGJpbmFyeSB0aGVyZSBvbiBzdGFydHVwLAogICAgICBzdWV4ZWMgd2lsbCBiZSBhY3RpdmF0ZWQuPC9wPgoKICAgICAgPHA+VW5sZXNzIHlvdSBmdWxseSB1bmRlcnN0YW5kIHN1ZXhlYywgeW91IHNob3VsZCBub3QgYmUgdXNpbmcgaXQuCiAgICAgIFRvIGRpc2FibGUgc3VleGVjLCBzaW1wbHkgcmVtb3ZlIChvciByZW5hbWUpIHRoZSA8Y29kZSBjbGFzcz0icHJvZ3JhbSI+PGEgaHJlZj0iLi4vcHJvZ3JhbXMvc3VleGVjLmh0bWwiPnN1ZXhlYzwvYT48L2NvZGU+CiAgICAgIGJpbmFyeSBwb2ludGVkIHRvIGJ5IDxjb2RlPlNVRVhFQ19CSU48L2NvZGU+IGFuZCB0aGVuIHJlc3RhcnQgdGhlCiAgICAgIHNlcnZlci4gIElmLCBhZnRlciByZWFkaW5nIGFib3V0IDxhIGhyZWY9Ii4uL3N1ZXhlYy5odG1sIj5zdWV4ZWM8L2E+LAogICAgICB5b3Ugc3RpbGwgd2lzaCB0byB1c2UgaXQsIHRoZW4gcnVuIDxjb2RlPnN1ZXhlYyAtVjwvY29kZT4gdG8gZmluZAogICAgICB0aGUgbG9jYXRpb24gb2YgdGhlIHN1ZXhlYyBsb2cgZmlsZSwgYW5kIHVzZSB0aGF0IGxvZyBmaWxlIHRvCiAgICAgIGZpbmQgd2hhdCBwb2xpY3kgeW91IGFyZSB2aW9sYXRpbmcuPC9wPgogICAgCiAgPC9kaXY+PGRpdiBjbGFzcz0idG9wIj48YSBocmVmPSIjcGFnZS1oZWFkZXIiPjxpbWcgYWx0PSJ0b3AiIHNyYz0iLi4vaW1hZ2VzL3VwLmdpZiIgLz48L2E+PC9kaXY+CjxkaXYgY2xhc3M9InNlY3Rpb24iPgo8aDI+PGEgbmFtZT0iYmVoaW5kc2NlbmVzIiBpZD0iYmVoaW5kc2NlbmVzIj5XaGF0J3MgZ29pbmcgb24gYmVoaW5kIHRoZSBzY2VuZXM/PC9hPjwvaDI+CiAgICAKCiAgICA8cD5BcyB5b3UgYmVjb21lIG1vcmUgYWR2YW5jZWQgaW4gQ0dJIHByb2dyYW1taW5nLCBpdCB3aWxsCiAgICBiZWNvbWUgdXNlZnVsIHRvIHVuZGVyc3RhbmQgbW9yZSBhYm91dCB3aGF0J3MgaGFwcGVuaW5nIGJlaGluZAogICAgdGhlIHNjZW5lcy4gU3BlY2lmaWNhbGx5LCBob3cgdGhlIGJyb3dzZXIgYW5kIHNlcnZlcgogICAgY29tbXVuaWNhdGUgd2l0aCBvbmUgYW5vdGhlci4gQmVjYXVzZSBhbHRob3VnaCBpdCdzIGFsbCB2ZXJ5CiAgICB3ZWxsIHRvIHdyaXRlIGEgcHJvZ3JhbSB0aGF0IHByaW50cyAiSGVsbG8sIFdvcmxkLiIsIGl0J3Mgbm90CiAgICBwYXJ0aWN1bGFybHkgdXNlZnVsLjwvcD4KCiAgICA8aDM+PGEgbmFtZT0iZW52IiBpZD0iZW52Ij5FbnZpcm9ubWVudCB2YXJpYWJsZXM8L2E+PC9oMz4KICAgICAgCgogICAgICA8cD5FbnZpcm9ubWVudCB2YXJpYWJsZXMgYXJlIHZhbHVlcyB0aGF0IGZsb2F0IGFyb3VuZCB5b3UgYXMKICAgICAgeW91IHVzZSB5b3VyIGNvbXB1dGVyLiBUaGV5IGFyZSB1c2VmdWwgdGhpbmdzIGxpa2UgeW91ciBwYXRoCiAgICAgICh3aGVyZSB0aGUgY29tcHV0ZXIgc2VhcmNoZXMgZm9yIHRoZSBhY3R1YWwgZmlsZQogICAgICBpbXBsZW1lbnRpbmcgYSBjb21tYW5kIHdoZW4geW91IHR5cGUgaXQpLCB5b3VyIHVzZXJuYW1lLCB5b3VyCiAgICAgIHRlcm1pbmFsIHR5cGUsIGFuZCBzbyBvbi4gRm9yIGEgZnVsbCBsaXN0IG9mIHlvdXIgbm9ybWFsLAogICAgICBldmVyeSBkYXkgZW52aXJvbm1lbnQgdmFyaWFibGVzLCB0eXBlIAogICAgICA8Y29kZT5lbnY8L2NvZGU+IGF0IGEgY29tbWFuZCBwcm9tcHQuPC9wPgoKICAgICAgPHA+RHVyaW5nIHRoZSBDR0kgdHJhbnNhY3Rpb24sIHRoZSBzZXJ2ZXIgYW5kIHRoZSBicm93c2VyCiAgICAgIGFsc28gc2V0IGVudmlyb25tZW50IHZhcmlhYmxlcywgc28gdGhhdCB0aGV5IGNhbiBjb21tdW5pY2F0ZQogICAgICB3aXRoIG9uZSBhbm90aGVyLiBUaGVzZSBhcmUgdGhpbmdzIGxpa2UgdGhlIGJyb3dzZXIgdHlwZQogICAgICAoTmV0c2NhcGUsIElFLCBMeW54KSwgdGhlIHNlcnZlciB0eXBlIChBcGFjaGUsIElJUywgV2ViU2l0ZSksCiAgICAgIHRoZSBuYW1lIG9mIHRoZSBDR0kgcHJvZ3JhbSB0aGF0IGlzIGJlaW5nIHJ1biwgYW5kIHNvIG9uLjwvcD4KCiAgICAgIDxwPlRoZXNlIHZhcmlhYmxlcyBhcmUgYXZhaWxhYmxlIHRvIHRoZSBDR0kgcHJvZ3JhbW1lciwgYW5kCiAgICAgIGFyZSBoYWxmIG9mIHRoZSBzdG9yeSBvZiB0aGUgY2xpZW50LXNlcnZlciBjb21tdW5pY2F0aW9uLiBUaGUKICAgICAgY29tcGxldGUgbGlzdCBvZiByZXF1aXJlZCB2YXJpYWJsZXMgaXMgYXQgCiAgICAgIDxhIGhyZWY9Imh0dHA6Ly93d3cuaWV0Zi5vcmcvcmZjL3JmYzM4NzUiPkNvbW1vbiBHYXRld2F5CiAgICAgIEludGVyZmFjZSBSRkM8L2E+LjwvcD4KCiAgICAgIDxwPlRoaXMgc2ltcGxlIFBlcmwgQ0dJIHByb2dyYW0gd2lsbCBkaXNwbGF5IGFsbCBvZiB0aGUKICAgICAgZW52aXJvbm1lbnQgdmFyaWFibGVzIHRoYXQgYXJlIGJlaW5nIHBhc3NlZCBhcm91bmQuIFR3bwogICAgICBzaW1pbGFyIHByb2dyYW1zIGFyZSBpbmNsdWRlZCBpbiB0aGUgCiAgICAgIDxjb2RlPmNnaS1iaW48L2NvZGU+CgogICAgICBkaXJlY3Rvcnkgb2YgdGhlIEFwYWNoZSBkaXN0cmlidXRpb24uIE5vdGUgdGhhdCBzb21lCiAgICAgIHZhcmlhYmxlcyBhcmUgcmVxdWlyZWQsIHdoaWxlIG90aGVycyBhcmUgb3B0aW9uYWwsIHNvIHlvdSBtYXkKICAgICAgc2VlIHNvbWUgdmFyaWFibGVzIGxpc3RlZCB0aGF0IHdlcmUgbm90IGluIHRoZSBvZmZpY2lhbCBsaXN0LgogICAgICBJbiBhZGRpdGlvbiwgQXBhY2hlIHByb3ZpZGVzIG1hbnkgZGlmZmVyZW50IHdheXMgZm9yIHlvdSB0byAKICAgICAgPGEgaHJlZj0iLi4vZW52Lmh0bWwiPmFkZCB5b3VyIG93biBlbnZpcm9ubWVudCB2YXJpYWJsZXM8L2E+CiAgICAgIHRvIHRoZSBiYXNpYyBvbmVzIHByb3ZpZGVkIGJ5IGRlZmF1bHQuPC9wPgoKICAgICAgPGRpdiBjbGFzcz0iZXhhbXBsZSI+PHA+PGNvZGU+CiAgICAgICAgIyEvdXNyL2Jpbi9wZXJsPGJyIC8+CiAgICAgICAgcHJpbnQgIkNvbnRlbnQtdHlwZTogdGV4dC9odG1sXG5cbiI7PGJyIC8+CiAgICAgICAgZm9yZWFjaCAka2V5IChrZXlzICVFTlYpIHs8YnIgLz4KICAgICAgICA8c3BhbiBjbGFzcz0iaW5kZW50Ij4KICAgICAgICAgIHByaW50ICIka2V5IC0tJmd0OyAkRU5WeyRrZXl9Jmx0O2JyJmd0OyI7PGJyIC8+CiAgICAgICAgPC9zcGFuPgogICAgICAgIH0KICAgICAgPC9jb2RlPjwvcD48L2Rpdj4KICAgIAoKICAgIDxoMz48YSBuYW1lPSJzdGRpbiIgaWQ9InN0ZGluIj5TVERJTiBhbmQgU1RET1VUPC9hPjwvaDM+CiAgICAgIAoKICAgICAgPHA+T3RoZXIgY29tbXVuaWNhdGlvbiBiZXR3ZWVuIHRoZSBzZXJ2ZXIgYW5kIHRoZSBjbGllbnQKICAgICAgaGFwcGVucyBvdmVyIHN0YW5kYXJkIGlucHV0ICg8Y29kZT5TVERJTjwvY29kZT4pIGFuZCBzdGFuZGFyZAogICAgICBvdXRwdXQgKDxjb2RlPlNURE9VVDwvY29kZT4pLiBJbiBub3JtYWwgZXZlcnlkYXkgY29udGV4dCwgCiAgICAgIDxjb2RlPlNURElOPC9jb2RlPiBtZWFucyB0aGUga2V5Ym9hcmQsIG9yIGEgZmlsZSB0aGF0IGEgCiAgICAgIHByb2dyYW0gaXMgZ2l2ZW4gdG8gYWN0IG9uLCBhbmQgPGNvZGU+U1RET1VUPC9jb2RlPgogICAgICB1c3VhbGx5IG1lYW5zIHRoZSBjb25zb2xlIG9yIHNjcmVlbi48L3A+IAoKICAgICAgPHA+V2hlbiB5b3UgPGNvZGU+UE9TVDwvY29kZT4gYSB3ZWIgZm9ybSB0byBhIENHSSBwcm9ncmFtLAogICAgICB0aGUgZGF0YSBpbiB0aGF0IGZvcm0gaXMgYnVuZGxlZCB1cCBpbnRvIGEgc3BlY2lhbCBmb3JtYXQKICAgICAgYW5kIGdldHMgZGVsaXZlcmVkIHRvIHlvdXIgQ0dJIHByb2dyYW0gb3ZlciA8Y29kZT5TVERJTjwvY29kZT4uCiAgICAgIFRoZSBwcm9ncmFtIHRoZW4gY2FuIHByb2Nlc3MgdGhhdCBkYXRhIGFzIHRob3VnaCBpdCB3YXMKICAgICAgY29taW5nIGluIGZyb20gdGhlIGtleWJvYXJkLCBvciBmcm9tIGEgZmlsZTwvcD4KCiAgICAgIDxwPlRoZSAic3BlY2lhbCBmb3JtYXQiIGlzIHZlcnkgc2ltcGxlLiBBIGZpZWxkIG5hbWUgYW5kCiAgICAgIGl0cyB2YWx1ZSBhcmUgam9pbmVkIHRvZ2V0aGVyIHdpdGggYW4gZXF1YWxzICg9KSBzaWduLCBhbmQKICAgICAgcGFpcnMgb2YgdmFsdWVzIGFyZSBqb2luZWQgdG9nZXRoZXIgd2l0aCBhbiBhbXBlcnNhbmQKICAgICAgKCZhbXA7KS4gSW5jb252ZW5pZW50IGNoYXJhY3RlcnMgbGlrZSBzcGFjZXMsIGFtcGVyc2FuZHMsIGFuZAogICAgICBlcXVhbHMgc2lnbnMsIGFyZSBjb252ZXJ0ZWQgaW50byB0aGVpciBoZXggZXF1aXZhbGVudCBzbyB0aGF0CiAgICAgIHRoZXkgZG9uJ3QgZ3VtIHVwIHRoZSB3b3Jrcy4gVGhlIHdob2xlIGRhdGEgc3RyaW5nIG1pZ2h0IGxvb2sKICAgICAgc29tZXRoaW5nIGxpa2U6PC9wPgoKICAgICAgPGRpdiBjbGFzcz0iZXhhbXBsZSI+PHA+PGNvZGU+CiAgICAgICAgbmFtZT1SaWNoJTIwQm93ZW4mYW1wO2NpdHk9TGV4aW5ndG9uJmFtcDtzdGF0ZT1LWSZhbXA7c2lkZWtpY2s9U3F1aXJyZWwlMjBNb25rZXkKICAgICAgPC9jb2RlPjwvcD48L2Rpdj4KCiAgICAgIDxwPllvdSdsbCBzb21ldGltZXMgYWxzbyBzZWUgdGhpcyB0eXBlIG9mIHN0cmluZyBhcHBlbmRlZCB0bwogICAgICBhIFVSTC4gV2hlbiB0aGF0IGlzIGRvbmUsIHRoZSBzZXJ2ZXIgcHV0cyB0aGF0IHN0cmluZwogICAgICBpbnRvIHRoZSBlbnZpcm9ubWVudCB2YXJpYWJsZSBjYWxsZWQgCiAgICAgIDxjb2RlPlFVRVJZX1NUUklORzwvY29kZT4uIFRoYXQncyBjYWxsZWQgYSA8Y29kZT5HRVQ8L2NvZGU+CiAgICAgIHJlcXVlc3QuIFlvdXIgSFRNTCBmb3JtIHNwZWNpZmllcyB3aGV0aGVyIGEgPGNvZGU+R0VUPC9jb2RlPgogICAgICBvciBhIDxjb2RlPlBPU1Q8L2NvZGU+IGlzIHVzZWQgdG8gZGVsaXZlciB0aGUgZGF0YSwgYnkgc2V0dGluZyB0aGUgCiAgICAgIDxjb2RlPk1FVEhPRDwvY29kZT4gYXR0cmlidXRlIGluIHRoZSA8Y29kZT5GT1JNPC9jb2RlPiB0YWcuPC9wPgoKICAgICAgPHA+WW91ciBwcm9ncmFtIGlzIHRoZW4gcmVzcG9uc2libGUgZm9yIHNwbGl0dGluZyB0aGF0IHN0cmluZwogICAgICB1cCBpbnRvIHVzZWZ1bCBpbmZvcm1hdGlvbi4gRm9ydHVuYXRlbHksIHRoZXJlIGFyZSBsaWJyYXJpZXMKICAgICAgYW5kIG1vZHVsZXMgYXZhaWxhYmxlIHRvIGhlbHAgeW91IHByb2Nlc3MgdGhpcyBkYXRhLCBhcyB3ZWxsCiAgICAgIGFzIGhhbmRsZSBvdGhlciBvZiB0aGUgYXNwZWN0cyBvZiB5b3VyIENHSSBwcm9ncmFtLjwvcD4KICAgIAogIDwvZGl2PjxkaXYgY2xhc3M9InRvcCI+PGEgaHJlZj0iI3BhZ2UtaGVhZGVyIj48aW1nIGFsdD0idG9wIiBzcmM9Ii4uL2ltYWdlcy91cC5naWYiIC8+PC9hPjwvZGl2Pgo8ZGl2IGNsYXNzPSJzZWN0aW9uIj4KPGgyPjxhIG5hbWU9ImxpYnJhcmllcyIgaWQ9ImxpYnJhcmllcyI+Q0dJIG1vZHVsZXMvbGlicmFyaWVzPC9hPjwvaDI+CiAgICAKCiAgICA8cD5XaGVuIHlvdSB3cml0ZSBDR0kgcHJvZ3JhbXMsIHlvdSBzaG91bGQgY29uc2lkZXIgdXNpbmcgYQogICAgY29kZSBsaWJyYXJ5LCBvciBtb2R1bGUsIHRvIGRvIG1vc3Qgb2YgdGhlIGdydW50IHdvcmsgZm9yIHlvdS4KICAgIFRoaXMgbGVhZHMgdG8gZmV3ZXIgZXJyb3JzLCBhbmQgZmFzdGVyIGRldmVsb3BtZW50LjwvcD4KCiAgICA8cD5JZiB5b3UncmUgd3JpdGluZyBDR0kgcHJvZ3JhbXMgaW4gUGVybCwgbW9kdWxlcyBhcmUKICAgIGF2YWlsYWJsZSBvbiA8YSBocmVmPSJodHRwOi8vd3d3LmNwYW4ub3JnLyI+Q1BBTjwvYT4uIFRoZSBtb3N0CiAgICBwb3B1bGFyIG1vZHVsZSBmb3IgdGhpcyBwdXJwb3NlIGlzIDxjb2RlPkNHSS5wbTwvY29kZT4uIFlvdSBtaWdodAogICAgYWxzbyBjb25zaWRlciA8Y29kZT5DR0k6OkxpdGU8L2NvZGU+LCB3aGljaCBpbXBsZW1lbnRzIGEgbWluaW1hbAogICAgc2V0IG9mIGZ1bmN0aW9uYWxpdHksIHdoaWNoIGlzIGFsbCB5b3UgbmVlZCBpbiBtb3N0IHByb2dyYW1zLjwvcD4KCiAgICA8cD5JZiB5b3UncmUgd3JpdGluZyBDR0kgcHJvZ3JhbXMgaW4gQywgdGhlcmUgYXJlIGEgdmFyaWV0eSBvZgogICAgb3B0aW9ucy4gT25lIG9mIHRoZXNlIGlzIHRoZSA8Y29kZT5DR0lDPC9jb2RlPiBsaWJyYXJ5LCBmcm9tIAogICAgPGEgaHJlZj0iaHR0cDovL3d3dy5ib3V0ZWxsLmNvbS9jZ2ljLyI+aHR0cDovL3d3dy5ib3V0ZWxsLmNvbS9jZ2ljLzwvYT4uPC9wPgogIDwvZGl2PjxkaXYgY2xhc3M9InRvcCI+PGEgaHJlZj0iI3BhZ2UtaGVhZGVyIj48aW1nIGFsdD0idG9wIiBzcmM9Ii4uL2ltYWdlcy91cC5naWYiIC8+PC9hPjwvZGl2Pgo8ZGl2IGNsYXNzPSJzZWN0aW9uIj4KPGgyPjxhIG5hbWU9Im1vcmVpbmZvIiBpZD0ibW9yZWluZm8iPkZvciBtb3JlIGluZm9ybWF0aW9uPC9hPjwvaDI+CiAgICAKCiAgICA8cD5UaGUgY3VycmVudCBDR0kgc3BlY2lmaWNhdGlvbiBpcyBhdmFpbGFibGUgaW4gdGhlIAogICAgPGEgaHJlZj0iaHR0cDovL3d3dy5pZXRmLm9yZy9yZmMvcmZjMzg3NSI+Q29tbW9uIEdhdGV3YXkKICAgIEludGVyZmFjZSBSRkM8L2E+LjwvcD4KCiAgICA8cD5XaGVuIHlvdSBwb3N0IGEgcXVlc3Rpb24gYWJvdXQgYSBDR0kgcHJvYmxlbSB0aGF0IHlvdSdyZQogICAgaGF2aW5nLCB3aGV0aGVyIHRvIGEgbWFpbGluZyBsaXN0LCBvciB0byBhIG5ld3Nncm91cCwgbWFrZSBzdXJlCiAgICB5b3UgcHJvdmlkZSBlbm91Z2ggaW5mb3JtYXRpb24gYWJvdXQgd2hhdCBoYXBwZW5lZCwgd2hhdCB5b3UKICAgIGV4cGVjdGVkIHRvIGhhcHBlbiwgYW5kIGhvdyB3aGF0IGFjdHVhbGx5IGhhcHBlbmVkIHdhcwogICAgZGlmZmVyZW50LCB3aGF0IHNlcnZlciB5b3UncmUgcnVubmluZywgd2hhdCBsYW5ndWFnZSB5b3VyIENHSQogICAgcHJvZ3JhbSB3YXMgaW4sIGFuZCwgaWYgcG9zc2libGUsIHRoZSBvZmZlbmRpbmcgY29kZS4gVGhpcyB3aWxsCiAgICBtYWtlIGZpbmRpbmcgeW91ciBwcm9ibGVtIG11Y2ggc2ltcGxlci48L3A+CgogICAgPHA+Tm90ZSB0aGF0IHF1ZXN0aW9ucyBhYm91dCBDR0kgcHJvYmxlbXMgc2hvdWxkIDxzdHJvbmc+bmV2ZXI8L3N0cm9uZz4KICAgIGJlIHBvc3RlZCB0byB0aGUgQXBhY2hlIGJ1ZyBkYXRhYmFzZSB1bmxlc3MgeW91IGFyZSBzdXJlIHlvdQogICAgaGF2ZSBmb3VuZCBhIHByb2JsZW0gaW4gdGhlIEFwYWNoZSBzb3VyY2UgY29kZS48L3A+CiAgPC9kaXY+PC9kaXY+CjxkaXYgY2xhc3M9ImJvdHRvbWxhbmciPgo8cD48c3Bhbj5BdmFpbGFibGUgTGFuZ3VhZ2VzOiA8L3NwYW4+PGEgaHJlZj0iLi4vZW4vaG93dG8vY2dpLmh0bWwiIHRpdGxlPSJFbmdsaXNoIj4mbmJzcDtlbiZuYnNwOzwvYT4gfAo8YSBocmVmPSIuLi9mci9ob3d0by9jZ2kuaHRtbCIgaHJlZmxhbmc9ImZyIiByZWw9ImFsdGVybmF0ZSIgdGl0bGU9IkZyYW7nYWlzIj4mbmJzcDtmciZuYnNwOzwvYT4gfAo8YSBocmVmPSIuLi9qYS9ob3d0by9jZ2kuaHRtbCIgaHJlZmxhbmc9ImphIiByZWw9ImFsdGVybmF0ZSIgdGl0bGU9IkphcGFuZXNlIj4mbmJzcDtqYSZuYnNwOzwvYT4gfAo8YSBocmVmPSIuLi9rby9ob3d0by9jZ2kuaHRtbCIgaHJlZmxhbmc9ImtvIiByZWw9ImFsdGVybmF0ZSIgdGl0bGU9IktvcmVhbiI+Jm5ic3A7a28mbmJzcDs8L2E+PC9wPgo8L2Rpdj48ZGl2IGlkPSJmb290ZXIiPgo8cCBjbGFzcz0iYXBhY2hlIj5Db3B5cmlnaHQgMjAxMSBUaGUgQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb24uPGJyIC8+TGljZW5zZWQgdW5kZXIgdGhlIDxhIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMCI+QXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wPC9hPi48L3A+CjxwIGNsYXNzPSJtZW51Ij48YSBocmVmPSIuLi9tb2QvIj5Nb2R1bGVzPC9hPiB8IDxhIGhyZWY9Ii4uL21vZC9kaXJlY3RpdmVzLmh0bWwiPkRpcmVjdGl2ZXM8L2E+IHwgPGEgaHJlZj0iLi4vZmFxLyI+RkFRPC9hPiB8IDxhIGhyZWY9Ii4uL2dsb3NzYXJ5Lmh0bWwiPkdsb3NzYXJ5PC9hPiB8IDxhIGhyZWY9Ii4uL3NpdGVtYXAuaHRtbCI+U2l0ZW1hcDwvYT48L3A+PC9kaXY+CjwvYm9keT48L2h0bWw+