PCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMCBUcmFuc2l0aW9uYWwvL0VOIj4KPCEtLQogKiBMaWNlbnNlZCB0byB0aGUgQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb24gKEFTRikgdW5kZXIgb25lCiAqIG9yIG1vcmUgY29udHJpYnV0b3IgbGljZW5zZSBhZ3JlZW1lbnRzLiAgU2VlIHRoZSBOT1RJQ0UgZmlsZQogKiBkaXN0cmlidXRlZCB3aXRoIHRoaXMgd29yayBmb3IgYWRkaXRpb25hbCBpbmZvcm1hdGlvbgogKiByZWdhcmRpbmcgY29weXJpZ2h0IG93bmVyc2hpcC4gIFRoZSBBU0YgbGljZW5zZXMgdGhpcyBmaWxlCiAqIHRvIHlvdSB1bmRlciB0aGUgQXBhY2hlIExpY2Vuc2UsIFZlcnNpb24gMi4wICh0aGUKICogIkxpY2Vuc2UiKTsgeW91IG1heSBub3QgdXNlIHRoaXMgZmlsZSBleGNlcHQgaW4gY29tcGxpYW5jZQogKiB3aXRoIHRoZSBMaWNlbnNlLiAgWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0CiAqIAogKiAgIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMAogKiAKICogVW5sZXNzIHJlcXVpcmVkIGJ5IGFwcGxpY2FibGUgbGF3IG9yIGFncmVlZCB0byBpbiB3cml0aW5nLAogKiBzb2Z0d2FyZSBkaXN0cmlidXRlZCB1bmRlciB0aGUgTGljZW5zZSBpcyBkaXN0cmlidXRlZCBvbiBhbgogKiAiQVMgSVMiIEJBU0lTLCBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBBTlkKICogS0lORCwgZWl0aGVyIGV4cHJlc3Mgb3IgaW1wbGllZC4gIFNlZSB0aGUgTGljZW5zZSBmb3IgdGhlCiAqIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmQgbGltaXRhdGlvbnMKICogdW5kZXIgdGhlIExpY2Vuc2UuCiAtLT4KCjxodG1sPgogPGhlYWQ+CiAgIDxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiPgogICA8dGl0bGU+QXBhY2hlIEMrKyBPdmVydmlldyBhbmQgU2V0dXA8L3RpdGxlPgogICA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9ImNzcy9zdHlsZXNoZWV0LmNzcyIgdHlwZT0idGV4dC9jc3MiPgogPC9oZWFkPgo8Ym9keSBiZ2NvbG9yPSJ3aGl0ZSIgdGV4dD0iYmxhY2siIGxpbms9IiMwMDAwRkYiIHZsaW5rPSIjODQwMDg0IiBhbGluaz0iIzAwMDBGRiI+PGRpdiBjbGFzcz0iYm9vayIgbGFuZz0iZW4iIGlkPSJkMGUyIj48ZGl2IGNsYXNzPSJ0aXRsZXBhZ2UiPjxkaXY+PGRpdj48aDEgY2xhc3M9InRpdGxlIj48YSBuYW1lPSJkMGUyIj48L2E+QXBhY2hlIFVJTUEgQysrIE92ZXJ2aWV3IGFuZCBTZXR1cDwvaDE+PC9kaXY+PGRpdj48ZGl2IGNsYXNzPSJhdXRob3Jncm91cCI+PGgzIGNsYXNzPSJjb3JwYXV0aG9yIj5BdXRob3JzOiBUaGUgQXBhY2hlIFVJTUEgRGV2ZWxvcG1lbnQgQ29tbXVuaXR5PC9oMz48L2Rpdj48L2Rpdj48ZGl2PjxwIGNsYXNzPSJyZWxlYXNlaW5mbyI+VmVyc2lvbiAyLjIuMjwvcD48L2Rpdj48ZGl2PjxwIGNsYXNzPSJjb3B5cmlnaHQiPkNvcHlyaWdodCAmY29weTsgMjAwNiwgMjAwNyBUaGUgQXBhY2hlIFNvZnR3YXJlIEZvdW5kYXRpb248L3A+PC9kaXY+PGRpdj48cCBjbGFzcz0iY29weXJpZ2h0Ij5Db3B5cmlnaHQgJmNvcHk7IDIwMDQsIDIwMDYgSW50ZXJuYXRpb25hbCBCdXNpbmVzcyBNYWNoaW5lcyBDb3Jwb3JhdGlvbjwvcD48L2Rpdj48ZGl2PjxkaXYgY2xhc3M9ImxlZ2Fsbm90aWNlIj48YSBuYW1lPSJkMGUxNSI+PC9hPjxwPiA8L3A+PHA+PGI+SW5jdWJhdGlvbiBOb3RpY2UgYW5kIERpc2NsYWltZXIuJm5ic3A7PC9iPkFwYWNoZSBVSU1BIGlzIGFuIGVmZm9ydCB1bmRlcmdvaW5nIGluY3ViYXRpb24gYXQgdGhlIEFwYWNoZSBTb2Z0d2FyZSBGb3VuZGF0aW9uIChBU0YpLiAKICAgICAgICAgIEluY3ViYXRpb24gaXMgcmVxdWlyZWQgb2YgYWxsIG5ld2x5IGFjY2VwdGVkIHByb2plY3RzIHVudGlsIGEgZnVydGhlciByZXZpZXcgaW5kaWNhdGVzIHRoYXQgCiAgICAgICAgICB0aGUgaW5mcmFzdHJ1Y3R1cmUsIGNvbW11bmljYXRpb25zLCBhbmQgZGVjaXNpb24gbWFraW5nIHByb2Nlc3MgaGF2ZSBzdGFiaWxpemVkIGluIGEgbWFubmVyIAogICAgICAgICAgY29uc2lzdGVudCB3aXRoIG90aGVyIHN1Y2Nlc3NmdWwgQVNGIHByb2plY3RzLiBXaGlsZSBpbmN1YmF0aW9uIHN0YXR1cyBpcyBub3QgbmVjZXNzYXJpbHkgCiAgICAgICAgICBhIHJlZmxlY3Rpb24gb2YgdGhlIGNvbXBsZXRlbmVzcyBvciBzdGFiaWxpdHkgb2YgdGhlIGNvZGUsIAogICAgICAgICAgaXQgZG9lcyBpbmRpY2F0ZSB0aGF0IHRoZSBwcm9qZWN0IGhhcyB5ZXQgdG8gYmUgZnVsbHkgZW5kb3JzZWQgYnkgdGhlIEFTRi48L3A+PHA+IDwvcD48cD4gPC9wPjxwPjxiPkxpY2Vuc2UgYW5kIERpc2NsYWltZXIuJm5ic3A7PC9iPlRoZSBBU0YgbGljZW5zZXMgdGhpcyBkb2N1bWVudGF0aW9uCiAgICAgICAgICAgdG8geW91IHVuZGVyIHRoZSBBcGFjaGUgTGljZW5zZSwgVmVyc2lvbiAyLjAgKHRoZQogICAgICAgICAgICJMaWNlbnNlIik7IHlvdSBtYXkgbm90IHVzZSB0aGlzIGRvY3VtZW50YXRpb24gZXhjZXB0IGluIGNvbXBsaWFuY2UKICAgICAgICAgICB3aXRoIHRoZSBMaWNlbnNlLiAgWW91IG1heSBvYnRhaW4gYSBjb3B5IG9mIHRoZSBMaWNlbnNlIGF0CiAgICAgICAgIAogICAgICAgICA8L3A+PGRpdiBjbGFzcz0iYmxvY2txdW90ZSI+PGJsb2NrcXVvdGUgY2xhc3M9ImJsb2NrcXVvdGUiPjxhIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMCIgdGFyZ2V0PSJfdG9wIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjA8L2E+PC9ibG9ja3F1b3RlPjwvZGl2PjxwPgogICAgICAgICAKICAgICAgICAgICBVbmxlc3MgcmVxdWlyZWQgYnkgYXBwbGljYWJsZSBsYXcgb3IgYWdyZWVkIHRvIGluIHdyaXRpbmcsCiAgICAgICAgICAgdGhpcyBkb2N1bWVudGF0aW9uIGFuZCBpdHMgY29udGVudHMgYXJlIGRpc3RyaWJ1dGVkIHVuZGVyIHRoZSBMaWNlbnNlIAogICAgICAgICAgIG9uIGFuIAogICAgICAgICAgICJBUyBJUyIgQkFTSVMsIFdJVEhPVVQgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIEFOWQogICAgICAgICAgIEtJTkQsIGVpdGhlciBleHByZXNzIG9yIGltcGxpZWQuICBTZWUgdGhlIExpY2Vuc2UgZm9yIHRoZQogICAgICAgICAgIHNwZWNpZmljIGxhbmd1YWdlIGdvdmVybmluZyBwZXJtaXNzaW9ucyBhbmQgbGltaXRhdGlvbnMKICAgICAgICAgICB1bmRlciB0aGUgTGljZW5zZS4KICAgICAgICAgPC9wPjxwPiA8L3A+PHA+IDwvcD48cD48Yj5UcmFkZW1hcmtzLiZuYnNwOzwvYj5BbGwgdGVybXMgbWVudGlvbmVkIGluIHRoZSB0ZXh0IHRoYXQgYXJlIGtub3duIHRvIGJlIHRyYWRlbWFya3Mgb3IgCiAgICAgICAgc2VydmljZSBtYXJrcyBoYXZlIGJlZW4gYXBwcm9wcmlhdGVseSBjYXBpdGFsaXplZC4gIFVzZSBvZiBzdWNoIHRlcm1zCiAgICAgICAgaW4gdGhpcyBib29rIHNob3VsZCBub3QgYmUgcmVnYXJkZWQgYXMgYWZmZWN0aW5nIHRoZSB2YWxpZGl0eSBvZiB0aGUKICAgICAgICB0aGUgdHJhZGVtYXJrIG9yIHNlcnZpY2UgbWFyay4KICAgICAgICA8L3A+PC9kaXY+PC9kaXY+PGRpdj48cCBjbGFzcz0icHViZGF0ZSI+QXVndXN0LCAyMDA4PC9wPjwvZGl2PjwvZGl2Pjxocj48L2Rpdj4KCgoKPGgyPjEuMCBBcGFjaGUgVUlNQSBDKysgT3ZlcnZpZXc8L2gyPgo8cD5UaGUgQXBhY2hlIFVJTUEgQysrIGZyYW1ld29yayBpcyBwcmltYXJpbHkgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY3JlYXRpb24gb2YgVUlNQSBjb21wbGlhbnQgCmFuYWx5c2lzIGVuZ2luZXMgZnJvbSBhbmFseXRpY3Mgd3JpdHRlbiBpbiBDL0MrKy4gVGhlIHJpY2ggc2V0IG9mIENBUyBpbnRlcmZhY2UgbWV0aG9kcyBtaW5pbWl6ZXMKdGhlIGVmZm9ydCB0byBleHRyYWN0IGlucHV0IGRhdGEgZnJvbSBhIENBUyBhbmQgdGhlbiB1cGRhdGUgdGhlIENBUyB3aXRoIHRoZSBhbmFseXRpYyByZXN1bHRzLgpUaGUgVUlNQSBDKysgZnJhbWV3b3JrIHRyYW5zcGFyZW50bHkgbW92ZXMgdGhlIENBUyBmcm9tIEphdmEgdG8gQysrIGVudmlyb25tZW50cywgYW5kIGZyb20gYSBVSU1BCmNsaWVudCB0byBhIFVJTUEgc2VydmljZS4gCjwvcD4KPHA+CkEgVUlNQSBDKysgY29tcG9uZW50IGlzIGlkZW50aWZpZWQgYXMgc3VjaCB0byB0aGUgZnJhbWV3b3JrIGJ5IHNwZWNpZnlpbmcgaW4gaXRzCmNvbXBvbmVudCBkZXNjcmlwdG9yOgogIDx1bD4KICAgIDxjb2RlPiZsdDtmcmFtZXdvcmtJbXBsZW1lbnRhdGlvbj5vcmcuYXBhY2hlLnVpbWEuY3BwJmx0Oy9mcmFtZXdvcmtJbXBsZW1lbnRhdGlvbj48L2NvZGU+CiAgPC91bD4gIAo8L3A+CjxwPlRoZSBVSU1BIEMrKyBmcmFtZXdvcmsgc3VwcG9ydHMgZW1iZWRkaW5nIFVJTUEgY29tcG9uZW50cyBpbiBhIG5hdGl2ZSBwcm9jZXNzLiBUaGVyZSBhcmUgQVBJcyB0byAKcGFyc2UgY29tcG9uZW50IGRlc2NyaXB0b3JzLCBpbnN0YW50aWF0ZSBhbmQgY2FsbCBhbmFseXNpcyBlbmdpbmVzLgpBIFVJTUEgQysrIHRlc3QgZHJpdmVyIGlzIGF2YWlsYWJsZSBzbyB0aGF0IGEgVUlNQSBDKysgYW5hbHl0aWMgY2FuIGJlIGRldmVsb3BlZCBhbmQgdGVzdGVkIHdpdGggCnN0YW5kYXJkIG5hdGl2ZSBwcm9ncmFtbWluZyB0b29sczsgbm8gcHJvZ3JhbWluZyBpbiBKYXZhIGlzIHJlcXVpcmVkLgpPbiB0aGUgb3RoZXIgaGFuZCwgZm9yIGEgbW9yZSBjb25zaXN0ZW50IGRldmVsb3BtZW50IGVudmlyb25tZW50CkVjbGlwc2UgY2FuIHByb3ZpZGUgYSBzaW5nbGUgSURFIGZvciBib3RoIEphdmEgYW5kIEMrKyBjb21wb25lbnRzCnVzaW5nIHRoZSA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2NkdC8iPkNEVDwvYT4uCjwvcD4KPHA+VGhlcmUgYXJlIHR3byBhcHByb2FjaGVzIHRvIGludGVncmF0aW5nIFVJTUEgQysrIGFuYWx5dGljcyB3aXRoIHRoZQpVSU1BIEphdmEgZnJhbWV3b3JrOiB1c2luZyB0aGUgSmF2YSBOYXRpdmUgSW50ZXJmYWNlIChKTkkpLCBhbmQgdXNpbmcKYSBuYXRpdmUgQysrIHNlcnZpY2Ugd3JhcHBlciB3aGljaCBpcyBjb21wYXRpYmxlIHdpdGggVUlNQSBBUy4gVXNpbmcKdGhlIEpOSSwgYSBDKysgYW5hbHlzaXMgZW5naW5lIGNhbiBiZSB1c2VkIGFueXdoZXJlIGEgSmF2YSBhbmFseXNpcwplbmdpbmUgaXMgdXNlZDsgaW4gdGhpcyBjYXNlIGEgSmF2YSBwcm94eSB3aWxsIGluc3RhbnRpYXRlIHRoZSB1aW1hY3BwCmZyYW1ld29yayB0aG91Z2ggdGhlIEpOSS4gTm90ZSB0aGF0IGlmIG1vcmUgdGhhbiBvbmUgQysrIGNvbXBvbmVudCBpcwp1c2VkIGluIHRoZSBzYW1lIEpWTSwgdGhleSBtdXN0IHNoYXJlIHRoZSBzYW1lIG5hdGl2ZQplbnZpcm9ubWVudC4gVXNpbmcgVUlNQSBBUywgYSBDKysgY29tcG9uZW50IGlzIHN0YXJ0ZWQgYXMgYSBzZXBhcmF0ZQpwcm9jZXNzLCBhbmQgZWFjaCBjb21wb25lbnQgY2FuIGhhdmUgZGlmZmVyZW50IG5hdGl2ZSBlbnZpcm9ubWVudHMgaWYKZGVzaXJlZC4gV2hlbiBDKysgaXMgbGF1bmNoZWQgYXV0b21hdGljYWxseSBmcm9tIEphdmEsIGxvZ2dpbmcgaXMgYnkKZGVmYXVsdCBpbnRlZ3JhdGVkIHdpdGggb3RoZXIgVUlNQSBjb21wb25lbnRzIHJ1bm5pbmcgaW4gdGhlIHNhbWUgSlZNLgo8L3A+Cgo8aDM+MS4xIFVJTUEgQysrIEZ1bmN0aW9uYWxpdHk8L2gzPgo8cD5UaGUgVUlNQSBDKysgZnJhbWV3b3JrIGltcGxlbWVudHMgYSBzdWJzZXQgb2YgdGhhdCBpbiBKYXZhLiBNYWpvciBmdW5jdGlvbmFsaXR5IGNvbnNpc3RzIG9mOgo8b2w+CjxsaT5UaGUgYWJpbGl0eSB0byBpbnN0YW50aWF0ZSBwcmltaXRpdmUgb3IgYWdncmVnYXRlIGFuYWx5c2lzIGVuZ2luZXMuPC9saT4KPGxpPlRoZSBVSU1BIGNvbnRleHQgb2JqZWN0IGZvciBlYWNoIGFuYWx5c2lzIGVuZ2luZS48L2xpPgo8bGk+Q29tcGxldGUgc2V0IG9mIENBUyBBUElzLjwvbGk+CjxsaT5DQVMgZGF0YSBzZXJpYWxpemF0aW9uIGNvbXBhdGlibGUgd2l0aCBVSU1BIEphdmEuIFhNSSwgWENBUyBhbmQgYmluYXJ5IGZvcm1hdHMgYWxsIHN1cHBvcnRlZC48L2xpPgo8bGk+QSBKTkkgY29udHJvbGxlciBzdXBwb3J0aW5nIGRpcmVjdCBpbnRlZ3JhdGlvbiB3aXRoIFVJTUEgcnVubmluZyBvbiBKYXZhLjwvbGk+CjxsaT5TdXBwb3J0IGZvciBhbmFseXRpY3Mgd3JpdHRlbiBpbiBQZXJsLCBQeXRob24gYW5kIFRjbC48L2xpPgo8bGk+QSBkcml2ZXIgdXRpbGl0eSBmb3IgbmF0aXZlIGRldmVsb3BtZW50IGFuZCB0ZXN0aW5nLjwvbGk+Cjwvb2w+CjwvcD4KPHA+TWFqb3IgVUlNQSBmdW5jdGlvbmFsaXR5IG1pc3NpbmcgaW4gdGhlIEMrKyBmcmFtZXdvcms6CjxvbD4KPGxpPk5vIGN1c3RvbSBmbG93IGNvbnRyb2xsZXIgZm9yIGFnZ3JlZ2F0ZXMuPC9saT4KPGxpPk5vIG11bHRpdGhyZWFkZWQgYXBwbGljYXRpb24gZHJpdmVyIChlLmcuIHRoZSBDUE0pLgo8L29sPgo8L3A+Cgo8cD5VSU1BIGNvbXBsaWFudCBhbm5vdGF0b3JzIGNhbiBiZSB3cml0dGVuIGluIFBlcmwsIFB5dGhvbiBhbmQgVGNsIHVzaW5nIEMrKyBhbm5vdGF0b3JzIGluY2x1ZGVkIGluIHRoaXMgcGFja2FnZS4gRm9yIGZ1cnRoZXIgZGV0YWlscyBzZWUgPGEgaHJlZj0iLi4vc2NyaXB0YXRvcnMvcGVybC9QZXJsLmh0bWwiPlBlcmw8L2E+LCA8YSBocmVmPSIuLi9zY3JpcHRhdG9ycy9weXRob24vUHl0aG9uLmh0bWwiPlB5dGhvbjwvYT4gYW5kIDxhIGhyZWY9Ii4uL3NjcmlwdGF0b3JzL3RjbC9UY2wuaHRtbCI+VGNsPC9hPi4KPC9wPgo8cD5UaGUgVUlNQSBDKysgZnJhbWV3b3JrIGRlcGVuZHMgb24gVW5pY29kZSBzdXBwb3J0IGZyb20gdGhlIElDVSAoc2VlIGh0dHA6Ly93d3cuaWJtLmNvbS9zb2Z0d2FyZS9nbG9iYWxpemF0aW9uL2ljdSksIFhNTCBwYXJzaW5nIHN1cHBvcnQgZnJvbSB4ZXJjZXMgKHNlZSBodHRwOi8veG1sLmFwYWNoZS5vcmcveGVyY2VzLWMvKSBhbmQgcGxhdGZvcm0gcG9ydGFiaWxpdHkgZnJvbSBBUFIgKHNlZSBodHRwOi8vYXByLmFwYWNoZS5vcmcvKS4KPC9wPgoKPHA+QVBJIGRvY3VtZW50YXRpb24gZm9yIHRoZSBDKysgZnJhbWV3b3JrIGlzIGF2YWlsYWJsZSA8YSBocmVmPSJodG1sL2luZGV4Lmh0bWwiPmhlcmU8L2E+Lgo8L3A+Cgo8aDM+MS4yIFN1cHBvcnRlZCBQbGF0Zm9ybXM8L2gzPgo8cD5MaW51eK4gSW50ZWyuIDMyIGFuZCA2NC1iaXQgcGxhdGZvcm1zLCBNYWNPU1ggYW5kIFdpbmRvd3OuIDIwMDAvWFAuPC9wPgoKPGgzPjEuMyBCaW5hcnkgRGlzdHJpYnV0aW9uPC9oMz4KPHA+QmluYXJ5IGRpc3RyaWJ1dGlvbnMgYXJlIGluIGNvbXByZXNzZWQgdGFyZmlsZXMgZm9yIExpbnV4IGFuZCB6aXBmaWxlcyBmb3IgV2luZG93cy4KPC9wPiAgCgo8aDM+MS40IFNvdXJjZSBEaXN0cmlidXRpb248L2gzPgpUaGUgc291cmNlIGNvZGUgZGlzdHJpYnV0aW9ucyBhcmUgaW4gYSBjb21wcmVzc2VkIHRhcmZpbGUgZm9yIFVuaXggYnVpbGRzIGFuZCBhIHppcGZpbGUgZm9yIFdpbmRvd3MgYnVpbGRzLgoKPGgyPjIuMCBJbnN0YWxsaW5nIGFuZCBUZXN0aW5nIFVJTUEgQysrPC9oMj4KVGhlIGJpbmFyeSBkaXN0cmlidXRpb24gY2FuIGJlIGluc3RhbGxlZCBhbnl3aGVyZS4gSG93ZXZlciwgd2hlbgppbnN0YWxsZWQgb24gYSBzeXN0ZW0gd2l0aCB0aGUgQXBhY2hlIFVJTUEgSmF2YSBkaXN0cmlidXRpb24sIHVucGFja2luZyBkaXJlY3RseSB1bmRlcm5lYXRoICRVSU1BX0hPTUUKcHJvdmlkZXMgYmV0dGVyIGludGVyb3BlcmFiaWxpdHkuCgo8aDM+Mi4xIFNldHRpbmcgRW52aXJvbm1lbnQgVmFyaWFibGVzPC9oMz4KPHA+U2V0IFVJTUFDUFBfSE9NRSB0byB0aGUgaW5zdGFsbGVkIGxvY2F0aW9uIG9mIHRoZSBVSU1BIEMrKyBTREsuPC9wPgo8cD4KQm90aCB0aGUgVUlNQSBDKysgZnJhbWV3b3JrIGFuZCB0aGUgdXNlcnMnIEMrKyBjb21wb25lbnRzIGFyZSBpbXBsZW1lbnRlZCBhcwpzaGFyZWQgbGlicmFyaWVzIGFuZCBtdXN0IGJlIGF2YWlsYWJsZSB0byB0aGUgbmF0aXZlIGxpYnJhcnkgbG9hZGVyLgpPbiBMaW51eCB0aGVzZSBkaXJlY3RvcmllcyBtdXN0IGJlIGluIHRoZSBMRF9MSUJSQVJZX1BBVEgsIGluIERZTERfTElCUkFSWV9QQVRIIG9uIE1hY09TWAphbmQgb24gV2luZG93cyBpbiB0aGUgc3lzdGVtIFBBVEguIFRoZSBVSU1BIEMrKyB0ZXN0IGRyaXZlciBzaG91bGQgYmUgYWRkZWQgdG8gdGhlIHN5c3RlbSBQQVRILgo8L3A+CjxoND5PbiBMaW51eDwvaDQ+CiAgPHVsPgogICAgPGNvZGU+ZXhwb3J0IExEX0xJQlJBUllfUEFUSD0kVUlNQUNQUF9IT01FL2xpYjokTERfTElCUkFSWV9QQVRIPC9jb2RlPjxicj4KICAgIDxjb2RlPmV4cG9ydCBQQVRIPSRVSU1BQ1BQX0hPTUUvYmluOiRQQVRIPC9jb2RlPgogIDwvdWw+ICAKPGg0Pk9uIFdpbmRvd3M8L2g0PgogIDx1bD4KICAgIDxjb2RlPnNldCBQQVRIPSVVSU1BQ1BQX0hPTUUlXGJpbjslUEFUSCU8L2NvZGU+CiAgPC91bD4KCjxoMz4yLjIgVmVyaWZ5aW5nIFlvdXIgSW5zdGFsbGF0aW9uPC9oMz4KCjxwPlRvIHRlc3QgdGhlIGluc3RhbGxhdGlvbiwgc2V0IHRoZSBlbnZpcm9ubWVudCB2YXJpYWJsZXMgYXMgZGVzY3JpYmVkIGFib3ZlCmFuZCBmb2xsb3cgdGhlc2UgZGlyZWN0aW9uczoKCjxoND4yLjIuMSBPbiBMaW51eDwvaDQ+CiAgPHVsPgogICAgPGNvZGU+CiAgICAgIGNkICRVSU1BQ1BQX0hPTUUvZXhhbXBsZXM8YnI+CiAgICAgIG1ha2UgLUMgc3JjIC1mIERhdmVEZXRlY3Rvci5tYWsKICAgIDwvY29kZT4KICA8L3VsPiAgCjxwPlRoZSBidWlsZCBzaG91bGQgY3JlYXRlIGEgc2hhcmVkIGxpYnJhcnksIERhdmVEZXRlY3Rvci5zbywgd2hpY2ggbXVzdCBiZSBwbGFjZWQKIGluIHRoZSBMRF9MSUJSQVJZX1BBVEguPGJyPgo8L3A+Cjx1bD4KICAgIDxjb2RlPgogICAgICBMRF9MSUJSQVJZX1BBVEg9YHB3ZGAvc3JjOiRMRF9MSUJSQVJZX1BBVEg8YnI+CiAgICA8L2NvZGU+CjwvdWw+ClJ1biB0aGlzIEMrKyBhbm5vdGF0b3IgYXMgZm9sbG93czoKICA8dWw+CiAgICA8Y29kZT5ydW5BRUNwcCBkZXNjcmlwdG9ycy9EYXZlRGV0ZWN0b3IueG1sIGRhdGEvZXhhbXBsZS50eHQ8L2NvZGU+CiAgPC91bD4gIAo8cD4KVGhlIHJ1bkFFQ3BwIGRyaXZlciB3aWxsIHByb2Nlc3MgdGhlIGlucHV0IHRleHQgZmlsZSBhbmQgRGF2ZURldGVjdG9yIHNob3VsZCBmaW5kIGEgRGF2ZSBpbiBpdC4gCjwvcD4KCjxoND4yLjIuMiBPbiBXaW5kb3dzPC9oND4KICA8dWw+CiAgICA8Y29kZT4KICAgIGNkICVVSU1BQ1BQX0hPTUUlXGV4YW1wbGVzPGJyPgogICAgZGV2ZW52IHNyY1xEYXZlRGV0ZWN0b3IudmNwcm9qIC9idWlsZCByZWxlYXNlPGJyPgogICAgPC9jb2RlPgogIDwvdWw+ICAKPHA+VGhlIGJ1aWxkIHNob3VsZCBjcmVhdGUgYSBzaGFyZWQgbGlicmFyeSwgRGF2ZURldGVjdG9yLmRsbCwgd2hpY2ggbXVzdCBiZQpwbGFjZWQgaW4gdGhlIFBBVEguPGJyPgo8L3A+Cjx1bD4KICAgIDxjb2RlPgogICAgICBQQVRIPSVDRCVcc3JjOyRQQVRICiAgICA8L2NvZGU+CjwvdWw+ClJ1biB0aGlzIEMrKyBhbm5vdGF0b3IgYXMgZm9sbG93czoKICA8dWw+CiAgICA8Y29kZT5ydW5BRUNwcCBkZXNjcmlwdG9yc1xEYXZlRGV0ZWN0b3IueG1sIGRhdGFcZXhhbXBsZXMudHh0IDwvY29kZT4KICA8L3VsPgo8cD4KVGhlIHJ1bkFFQ3BwIGRyaXZlciB3aWxsIHByb2Nlc3MgdGhlIGlucHV0IHRleHQgZmlsZSBhbmQgRGF2ZURldGVjdG9yIHNob3VsZCBmaW5kIGEgRGF2ZSBpbiBpdC4gCjwvcD4KPGg0PjIuMi4zIE1vcmUgSW5mbyBvbiBVSU1BIEMrKyBFeGFtcGxlczwvaDQ+CjxwPkZvciBmdXJ0aGVyIGRldGFpbHMgYWJvdXQgaG93IHRvIGJ1aWxkIGFuZCBydW4gb3RoZXIgZXhhbXBsZXMgc2VlCjxhIGhyZWY9Ii4uL2V4YW1wbGVzL3JlYWRtZS5odG1sIj5DKysgRXhhbXBsZXM8L2E+CjwvcD4KCjxoMz4yLjMgVGVzdGluZyBJbnRlcm9wZXJhYmlsaXR5IHdpdGggSmF2YTwvaDM+ClRvIHRlc3QgdGhlIGludGVyb3BlcmFiaWxpdHkgd2l0aCBVSU1BIEphdmEgU0RLLCBtYWtlIHN1cmUgVUlNQV9IT01FIGlzIHNldCB0byB0aGUgbG9jYXRpb24gb2YgdGhlIFVJTUEgU0RLLCBhbmQgdGhhdCBpdHMgYmluIGRpcmVjdG9yeSBpcyBpbiB0aGUgUEFUSC4gUnVuIERhdmVEZXRlY3RvciBhcyBmb2xsb3dzOgo8aDQ+Mi4zLjEgT24gTGludXg8L2g0Pgo8dWw+CiAgICA8Y29kZT5ydW5BRS5zaCBkZXNjcmlwdG9ycy9EYXZlRGV0ZWN0b3IueG1sIGRhdGE8L2NvZGU+CjwvdWw+ICAKPGg0PjIuMy4yIE9uIFdpbmRvd3M8L2g0Pgo8dWw+CiAgICA8Y29kZT5ydW5BRSBkZXNjcmlwdG9yc1xEYXZlRGV0ZWN0b3IueG1sIGRhdGE8L2NvZGU+CjwvdWw+ICAKVGhlIHJ1bkFFIGRyaXZlciB3aWxsIHByb2Nlc3MgYWxsIGZpbGVzIGluIHRoZSBkYXRhIGRpcmVjdG9yeSBhbmQgRGF2ZURldGVjdG9yIHNob3VsZCBmaW5kIERhdmVzIGluIHNvbWUgb2YgdGhlbS4KCjxoMj4zLjAgRGV2ZWxvcGluZyBhIEMrKyBDb21wb25lbnQ8L2gyPgoKPGgzPjMuMSBEZXZlbG9waW5nIFVJTUEgQysrIENvbXBvbmVudHMgd2l0aG91dCBKYXZhPC9oMz4KPHA+Ckl0IGlzIGFkdmFudGFnZW91cyB0byBkZXZlbG9wIEMrKyBjb21wb25lbnRzIGFzIHN0YW5kLWFsb25lIEMrKyBhcHBsaWNhdGlvbnMuClRoZSBwcm9ncmFtIDxDT0RFPnJ1bkFFQ3BwPC9DT0RFPiBmb3VuZCB1bmRlciB0aGUgJFVJTUFDUFBfSE9NRS9iaW4gZGlyZWN0b3J5IGlzIGEKQysrIHV0aWxpdHkgdGhhdCBpbXBvcnRzIG9uZSBvciBtb3JlIFhNTCBmb3JtYXQgQ0FTIGZpbGVzIGludG8gQ0FTIG9iamVjdHMgYW5kIGZvciBlYWNoIGNhbGxzIHRoZSAKPENPREU+cHJvY2VzczwvQ09ERT4gbWV0aG9kIG9mIHRoZSBzcGVjaWZpZWQgVUlNQSBDKysgY29tcG9uZW50LCBvcHRpb25hbGx5CnNhdmluZyB0aGUgcmVzdWx0cyBhcyBYTUwgZm9ybWF0IENBUyBmaWxlcy4KPC9wPgo8cD4KQm90aCBYTUkgYW5kIFhDQVMgZm9ybWF0IENBUyBmaWxlcyBhcmUgc3VwcG9ydGVkIGJ5IHJ1bkFFQ3BwLgpUaGUgPENPREU+WG1pV3JpdGVyQ2FzQ29uc3VtZXI8L0NPREU+IGFuZCA8Q09ERT5YQ2FzV3JpdGVyQ2FzQ29uc3VtZXI8L0NPREU+IGFyZSBKYXZhIFVJTUEgY29tcG9uZW50cyAKdGhhdCBjYW4gYmUgcnVuIGF0IGFueSBwb2ludAppbiB0aGUgQ1BFIGZsb3cgdG8gZXhwb3J0IHRoZSBjb250ZW50cyBvZiB0aGUgQ0FTIG9iamVjdCB0byBhIGZpbGUgaW4gYW4gWE1MIGZvcm1hdC4gCjwvcD4KPHA+ClRvIGRldmVsb3AgdXNpbmcgWE1MIENBUyBzZXJpYWxpemF0aW9uLCB1c2Ugb25lIG9mIHRoZSBhYm92ZSBzZXJpYWxpemVycyB0byBkdW1wCnRoZSBDQVMgYXQgdGhlIHBvaW50IHRoZSBDKysgY29tcG9uZW50IHdvdWxkIGJlIGNhbGxlZCwgCm9yIGV2ZW4gY3JlYXRlIHRoZSBYTUwgY29udGVudCB3aXRoIGFuIGVkaXRvci4gIFVzZSBydW5BRUNwcCB0byBwcm9jZXNzIFhNTCBmb3JtYXQgQ0FTIGlucHV0IGFzIGZvbGxvd3M6CjwvcD4KPHVsPgo8Y29kZT5ydW5BRUNwcCAmbHQ7VWltYUNwcERlc2NyaXB0b3ImZ3Q7ICZsdDtJbnB1dEZpbGVPckRpcmVjdG9yeSZndDsgWyZsdDtPdXRwdXREaXJlY3RvcnkmZ3Q7XSBbLXggfCAteG1pXSBbLXMgVmlld05hbWVdIFstbCBsb2dsZXZlbF08L2NvZGU+CjwvdWw+Cjx1bD4KPGxpPlVpbWFDcHBEZXNjcmlwdG9yIGlzIHRoZSBDKysgY29tcG9uZW50IGRlc2NyaXB0b3I8L2xpPgo8bGk+SW5wdXRGaWxlT3JEaXJlY3RvcnkgaXMgdGhlIG5hbWUgb2YgYW4gaW5wdXQgZmlsZSBvciBhIGRpcmVjdG9yeSBjb250YWluaW5nIGlucHV0IGZpbGVzPC9saT4KPGxpPklmIGFuIG9wdGlvbmFsIE91dHB1dERpcmVjdG9yeSBpcyBzcGVjaWZpZWQsIHRoZSBjb250ZW50cyBvZiB0aGUgQ0FTIGFmdGVyIHByb2Nlc3Npbmcgd2lsbCBiZSB3cml0dGVuIG91dCB3aXRoIHRoZSBzYW1lIG5hbWVzIGFzIHRoZSBpbnB1dCBmaWxlcy4gQmUgY2FyZWZ1bCBub3QgdG8gc3BlY2lmeSB0aGUgZGlyZWN0b3J5IGNvbnRhaW5pbmcgdGhlIGlucHV0IGZpbGVzITwvbGk+CjxsaT5Vc2UgdGhlIC14IG9wdGlvbiBpZiB0aGUgaW5wdXQgZmlsZShzKSBhcmUgaW4gWENBUyBmb3JtYXQuIFVzZSB0aGUgLXhtaSBvcHRpb24gdG8gcHJvY2VzcyBYTUkgZm9ybWF0IENBUyBpbnB1dC4gT3RoZXJ3aXNlLCBpbnB1dCBmaWxlcyBhcmUgYXNzdW1lZCB0byBiZSB0ZXh0IGZpbGVzIGFuZCBhcmUgdXNlZCB0byBjcmVhdGUgdGhlIGRvY3VtZW50IHRleHQgZm9yIGFuYWx5c2lzLjwvbGk+CjxsaT5UbyBzdXBwb3J0IG11bHRpLVZpZXcgc2NlbmFyaW9zIHdoZXJlIHRoZSBDKysgY29tcG9uZW50IGlzIGV4cGVjdGluZyBhIHZpZXcgb2YgYSBzcGVjaWZpYyBTb2ZhLCB0aGUgbmFtZSBvZiB0aGUgdmlldyB0byB1c2UgY2FuIGJlIHByb3ZpZGVkPC9saT4KPGxpPlRoZSBsb2dsZXZlbCBmb3IgbWVzc2FnZXMgY2FuIGJlIHNwZWNpZmllZDwvbGk+CjwvdWw+CjxwPlNhbXBsZSBYTUkgYW5kIFhDQVMgZm9ybWF0IENBUyBmaWxlcyBhcmUgaW5jbHVkZWQgd2l0aCB0aGUgVUlNQSBDKysgZXhhbXBsZXMuIEFmdGVyIGJ1aWxkaW5nIHRoZSAKPENPREU+U29mYUV4YW1wbGVBbm5vdGF0b3I8L0NPREU+IGV4YW1wbGUgYXMgZGVzY3JpYmVkIGFib3ZlIGZvciBEYXZlRGV0ZWN0b3IsIHRyeTo8L3A+Cjx1bD4KPGNvZGU+CnJ1bkFFQ3BwIC14bWkgZGVzY3JpcHRvcnMvRGF2ZURldGVjdG9yLnhtbCBkYXRhL3RjYXMueG1pICZsdDt5b3VyT3V0cHV0RGlyJmd0Ozxicj4KcnVuQUVDcHAgLXhtaSBkZXNjcmlwdG9ycy9EYXZlRGV0ZWN0b3IueG1sIGRhdGEvc29mYS54bWkgJmx0O3lvdXJPdXRwdXREaXImZ3Q7IC1zIEVuZ2xpc2hEb2N1bWVudDxicj4KcnVuQUVDcHAgLXggZGVzY3JpcHRvcnMvU29mYUV4YW1wbGVBbm5vdGF0b3IueG1sIGRhdGEvc29mYS54Y2FzICZsdDt5b3VyT3V0cHV0RGlyJmd0Ozxicj4KPC9jb2RlPgo8L3VsPgo8cD5Gb3IgZnVydGhlciBkZXRhaWxzIGFib3V0IHRoZXNlIGFuZCBvdGhlciBleGFtcGxlcyBzZWUKPGEgaHJlZj0iLi4vZXhhbXBsZXMvcmVhZG1lLmh0bWwiPkMrKyBFeGFtcGxlczwvYT4KPC9wPgoKPGgzPjMuMiBEZWJ1Z2dpbmcgVUlNQSBDKysgQ29tcG9uZW50czwvaDM+CjxwPkFub3RoZXIgYWR2YW50YWdlIGluIGRldmVsb3BpbmcgVUlNQSBDKysgY29tcG9uZW50cyBhcyBzdGFuZC1hbG9uZSBhcHBsaWNhdGlvbnMgaXMgdGhlIHVzZSBvZiBuYXRpdmUgZGVidWdnZXJzLgpUaGUgY29tcG9uZW50IGRyaXZlciwgcnVuQUVDcHAsIHNpbXBsaWZpZXMgcnVubmluZyB0aGUgQysrIGNvbXBvbmVudCB1bmRlciBhIG5hdGl2ZSBkZWJ1Z2dlci4KPC9wPgo8aDQ+My4yLjEgRGVidWdnaW5nIG9uIFdpbmRvd3M8L2g0Pgo8cD5UaGUgVUlNQSBDKysgZnJhbWV3b3JrIGhhcyBzcGVjaWFsIHByb3Zpc2lvbnMgZm9yIGRlYnVnZ2luZyBvbiBXaW5kb3dzLgpVSU1BIEMrKyBjb21wb25lbnRzIGJ1aWx0IGRlYnVnIHNob3VsZCBsaW5rIHRvIGEgZGVidWcgdmVyc2lvbiBvZiB0aGUgZnJhbWV3b3JrLCB1aW1hRC5kbGwuClRoZSBkZWJ1ZyBmcmFtZXdvcmsgYXV0b21hdGljYWxseSBhcHBlbmRzICJEIiB0byB0aGUgbmFtZSBvZiBDKysgY29tcG9uZW50cyBiZWZvcmUgdHJ5aW5nIHRvIGxvYWQgdGhlbS4KVGhpcyBhcHBsaWVzIHRvIGFubm90YXRvcnMgYW5kIFVSSSBzY2hlbWUgaGFuZGxlcnMuIEFsbCBVSU1BIEMrKyBleGFtcGxlIGNvZGUgZm9sbG93IHRoaXMgY29udmVudGlvbi4KPC9wPgo8cD5Ob3RlIGFsc28gdGhhdCB0aGUgcnVuQUVDcHBEIHZlcnNpb24gb2YgdGhlIGNvbXBvbmVudCBkcml2ZXIgc2hvdWxkIGJlIHVzZWQgd2l0aCBkZWJ1ZyBjb21wb25lbnRzLgo8L3A+Cgo8aDM+My4zIFJ1bm5pbmcgQysrIENvbXBvbmVudHMgdW5kZXIgSmF2YTwvaDM+CjxwPk5hdGl2ZSBjb21wb25lbnRzIHJ1bm5pbmcgdW5kZXIgSmF2YSBtYXkgb3BlcmF0ZSBkaWZmZXJlbnRseSB0aGFuIHdoZW4gcnVuIGZyb20gYSBuYXRpdmUgYXBwbGljYXRpb24uClRoaXMgaXMgYmVjYXVzZSB0aGUgSlZNIHVzZXMgZGlmZmVyZW50IGRlZmF1bHQgcHJvY2VzcyBsaW1pdHMgdGhhbiB0aG9zZSB1c2VkIGZvciBhIG5hdGl2ZSBhcHBsaWNhdGlvbi4KRm9yIGV4YW1wbGUsIHRoZSBtYXhpbXVtIHN0YWNrIHNpemUgZm9yIGEgdGhyZWFkIHJ1bm5pbmcgdW5kZXIgYSBKVk0gbWF5IGJlIDEwMEtCIHZlcnN1cwoxTUIgZm9yIGEgbmF0aXZlIGNvbW1hbmQgbGluZSBhcHBsaWNhdGlvbi4gVXNlICJqYXZhIC1YIiB0byBnZXQgbW9yZSBpbmZvcm1hdGlvbiBvbiBub24tc3RhbmRhcmQgSlZNIG9wdGlvbnMuCjwvcD4KPGg0PjMuMy4xIFJ1bm5pbmcgRGVidWcgTW9kdWxlcyBvbiBXaW5kb3dzPC9oND4KPHA+SW4gb3JkZXIgdG8gcnVuIFVJTUEgQysrIGNvbXBvbmVudHMgYnVpbHQgZGVidWcsIEphdmEgbXVzdCBsb2FkIHRoZSBkZWJ1ZyB2ZXJzaW9uIG9mIHRoZSBmcmFtZXdvcmsuCkRlZmluZSB0aGUgSmF2YSBzeXN0ZW0gcHJvcGVydHkgREVCVUdfVUlNQUNQUCB0byBzcGVjaWZ5IHVzZSBvZiB0aGUgZGVidWcgZnJhbWV3b3JrLiAKQSBjb252ZW5pZW50IHdheSB0byBwYXNzIEpWTSBwcm9wZXJ0aWVzIHRvIFVJTUEncyBKYXZhIGNvbW1hbmRsaW5lIHV0aWxpdGllcywgc3VjaCBhcyBydW5BRS5zaCwgaXMgdG8gZGVmaW5lIAp0aGVtIGluIHRoZSBlbnZpcm9ubWVudGFsIHZhcmlhYmxlIFVJTUFfSlZNX09QVFMuIEZvciBleGFtcGxlIHRvIHJ1biBhIGRlYnVnIHZlcnNpb24gb2YgRGF2ZURldGVjdG9yIGZyb20gSmF2YToKPHVsPgogICAgPGNvZGU+ZXhwb3J0IFVJTUFfSlZNX09QVFM9LURERUJVR19VSU1BQ1BQPC9jb2RlPjxicj4KICAgIDxjb2RlPnJ1bkFFLnNoIGRlc2NyaXB0b3JzL0RhdmVEZXRlY3Rvci54bWwgZGF0YTwvY29kZT4KPC91bD4KPC9wPgoKCjxoMz4zLjQgTWVzc2FnZSBMb2dnaW5nIGZyb20gYSBDKysgQ29tcG9uZW50PC9oMz4KPHA+Rm9yIGZvcm1hbCBpbnRlZ3JhdGlvbiB3aXRoIFVJTUEgYXBwbGljYXRpb25zLCBhIGxvZ2ZpbGUgaW50ZXJmYWNlIGlzIGF2YWlsYWJsZS4KV2hlbiBhIEMrKyBhbm5vdGF0b3IgaXMgY2FsbGVkIGZyb20gSmF2YSwgbG9nZ2luZyBtZXNzYWdlcyBhcmUgaW50ZWdyYXRlZCBpbnRvIHRoZSBKYXZhIGxvZy4KSWYgdGhlIEMrKyBhbm5vdGF0b3IgaXMgY2FsbGVkIGZyb20gYSBuYXRpdmUgQysrIGFwcGxpY2F0aW9uLCBzdWNoIGFzIHJ1bkFFQ3BwLAphIGxvY2FsIGxvZ2ZpbGUgbWF5IGJlIGNyZWF0ZWQuIFRoZSBuYW1lIG9mIHRoZSBsb2dmaWxlIGlzIHRha2VuIGZyb20gdGhlIAp0aGUgZW52aXJvbm1lbnRhbCBwYXJhbWV0ZXIsIFVJTUFDUFBfTE9HRklMRSwgYW5kIGl0IGlzIG9wZW5lZCAiYXBwZW5kIi4KVGhlIGRlZmF1bHQgaXMgdG8gZGlzYWJsZSBsb2dnaW5nLgo8L3A+CjxwPlRocmVlIGxldmVscyBvZiBtZXNzYWdlIGxvZ2dpbmcgY2FuIGJlIHVzZWQ6IE1lc3NhZ2UsIFdhcm5pbmcgYW5kIEVycm9yLgpXaGVuIGNhbGxlZCBmcm9tIEphdmEgdGhlIFVJTUEgbG9nIGxldmVsIGlzIHVzZWQgdG8gY29udHJvbCBvdXRwdXQuCldoZW4gY2FsbGVkIGZyb20gYSBDKysgYXBwbGljYXRpb24gYW4gQVBJIGlzIGF2YWlsYWJsZSB0byBzZXQgdGhlIGxvZyBsZXZlbDsgdGhlIGRlZmF1bHQgbGV2ZWwgaXMgRXJyb3IuCldoZW4gY2FsbGVkIGZyb20gcnVuQUVDcHAgdGhlIHZhbHVlIG9mIHRoZXNlIGxldmVscyBhcmUgMCwgMSwgYW5kIDIsIHJlc3BlY3RpdmVseS4KPC9wPgoKPC9ib2R5Pgo8L2h0bWw+Cg==