PCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMDEgVHJhbnNpdGlvbmFsLy9FTiI+CjxodG1sPgo8aGVhZD4KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9Y2hhcnNldD1JU08tODg1OS0xIj4KICA8dGl0bGU+V2hhdCB0aGUgaGVjayBpcyBhIHBsdWctaW4gYW55d2F5PzwvdGl0bGU+CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKICA8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii9kZWZhdWx0X3N0eWxlLmNzcyI+CjwvaGVhZD4KICA8Ym9keSBsaW5rPSIjMDAwMGZmIiB2bGluaz0iIzgwMDA4MCI+CiAgICAgICAKPHAgYWxpZ249InJpZ2h0Ij48aW1nIHNyYz0iLi4vLi4vLi4vaW1hZ2VzL25naWJtY3B5LmdpZiIgYWx0PSJDb3B5cmlnaHQgSUJNIENvcnBvcmF0aW9uIGFuZCBvdGhlcnMgMjAwMCwgMjAwMy4iIGJvcmRlcj0iMCIgd2lkdGg9IjMyNCIgaGVpZ2h0PSIxNCI+PC9wPgo8dGFibGUgYm9yZGVyPSIwIiBjZWxsc3BhY2luZz0iMCIgY2VsbHBhZGRpbmc9IjIiIHdpZHRoPSIxMDAlIj4KICAgICAgPHRib2R5PgogICAgICAgIDx0cj4KICAgICAgICAgIDx0ZCBhbGlnbj0iTGVmdCIgdmFsaWduPSJUb3AiIGNvbHNwYW49IjIiIGJnY29sb3I9IiMwMDgwYzAiPjxiPjxmb250IGZhY2U9IkFyaWFsLEhlbHZldGljYSI+PGZvbnQgY29sb3I9IiNmZmZmZmYiPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgRWNsaXBzZSAgICAgICAgICBDb3JuZXIgQXJ0aWNsZTwvZm9udD48L2ZvbnQ+PC9iPjwvdGQ+CiAgICAgICAgPC90cj4KICAgICAgICAgICAgICAgCiAgPC90Ym9keT4gICAgCjwvdGFibGU+CiAgICAKICAgICAgIAo8ZGl2IGFsaWduPSJMZWZ0Ij4gICAgCjxoMT48aW1nIHNyYz0iaW1hZ2VzL0lkZWEuanBnIiBoZWlnaHQ9Ijg2IiB3aWR0aD0iMTIwIiBhbGlnbj0iQ2VudGVyIj4KICA8L2gxPgogIDwvZGl2PgogICAgICAgCjxoMSBhbGlnbj0iQ2VudGVyIj5XaGF0IHRoZSBoZWNrIGlzIGEgcGx1Zy1pbiBhbnl3YXk/IDwvaDE+CiAgICAgICAKPGJsb2NrcXVvdGU+ICAgICAgICAgICAgCiAgPHA+PGI+U3VtbWFyeTwvYj48YnI+CiAgICA8YnI+CiAgICBUaGUgRWNsaXBzZSBQbGF0Zm9ybSBpcyBiYXNlZCBvbiB0aGUgbm90aW9uIG9mIHBsdWctaW5zLiBQbHVnLWlucyBhcmUgYSBzaW1wbGUgCiAgICBidXQgcG93ZXJmdWwgbWVjaGFuaXNtIHRoYXQgYWxsb3cgZGV2ZWxvcGVycyBhbmQgdXNlcnMgdG8gY29uc3RydWN0IGNvbXBsZXggCiAgICB0b29sIHNldHMgYnkgY29tcG9zaW5nIGZ1bmN0aW9uYWxpdHkgKGkuZS4sIHBsdWctaW5zKS4gVGhlcmUgYXJlIG9mIGNvdXJzZSAKICAgIGEgbnVtYmVyIG9mIHN1YnRsZXRpZXMgaW4gaG93IHBsdWctaW5zIGFyZSBkZWZpbmVkIGFuZCBob3cgdGhleSBpbnRlcmFjdC4gCiAgICBUaGlzIGFydGljbGUgYXR0ZW1wdHMgdG8gZGVteXN0aWZ5IHBsdWctaW5zIGFuZCBtYWtlIGl0IGVhc2llciB0byBjcmVhdGUgYW5kIAogIG1hbmFnZSBFY2xpcHNlIFBsYXRmb3JtIGNvbmZpZ3VyYXRpb25zLjwvcD4KICA8cD48Yj4gQnkgRGViYmllIFdpbHNvbiBhbmQgSmVmZiBNY0FmZmVyLCBJQk0gT1RJIExhYnM8L2I+PGJyPgogICAgPGZvbnQgc2l6ZT0iLTEiPk1hcmNoIDksIDIwMDQ8L2ZvbnQ+PC9wPgogICAgICA8L2Jsb2NrcXVvdGU+CiAgICAgICAgICAgICAgIAogIDxociB3aWR0aD0iMTAwJSI+ICAgICAgICAgICAgCiAgPGgyPldoeSBQbHVnLWlucz88L2gyPgogICAgICAgICAgICAgICAKICAKPHA+T25lIG9mIHRoZSBtYWluIGRlc2lnbiBwb2ludHMgb2YgdGhlIEVjbGlwc2UgUGxhdGZvcm0gaXMgdGhhdCBpdCBpcyBleHRyZW1lbHkgCiAgZXh0ZW5zaWJsZS4gQW5vdGhlciBpcyB0aGF0IGl0IGlzIHVuaWZvcm0uIFRoZSBFY2xpcHNlIHBsdWctaW4gbW9kZWwgaXMga2V5IAogIGluIHNhdGlzZnlpbmcgYm90aCBvZiB0aGVzZSBnb2Fscy4gQSBwbHVnLWluIGlzIGEgcGllY2Ugb2YgZnVuY3Rpb25hbGl0eSB3aGljaCAKICBjYW4gYmUgYWRkZWQgdG8gdGhlIFBsYXRmb3JtLiBUb29scyBvciBhcHBsaWNhdGlvbnMgYXJlIGNvbnN0cnVjdGVkIGJ5IGNyZWF0aW5nIAogIG9uZSBvciBtb3JlIHBsdWctaW5zLiBIb3cgdG9vbHMgb3IgYXBwbGljYXRpb25zIGFyZSBmYWN0b3JlZCBpbnRvIHBsdWctaW5zIGRlcGVuZHMgCiAgb24gdGhlIG5hdHVyZSBvZiB0aGUgdG9vbCBvciBhcHBsaWNhdGlvbi4gPC9wPgo8cD5UaGUgRWNsaXBzZSBQbGF0Zm9ybSBpdHNlbGYsIGZvciBleGFtcGxlLCBpcyBtYWRlIHVwIGVudGlyZWx5IG9mIHBsdWctaW5zOiAKICBzb21lIDUwIG9yIHNvIGluIGFsbC4gRXZlbiB0aGUgcnVudGltZSB3aGljaCBtYW5hZ2VzIHBsdWctaW5zLCBpcyBpdHNlbGYgYSBwbHVnLWluISAKICBQbHVnLWlucyBpbnRlcmFjdCB2aWEgd2VsbCBkZWZpbmVkIEFQSSdzLiBTaW5jZSBldmVyeXRoaW5nIGlzIGEgcGx1Zy1pbiBhbmQgCiAgcGx1Zy1pbnMgaW50ZXJhY3QgdmlhIHB1YmxpYyBpbnRlcmZhY2VzLCBhbGwgcGx1Zy1pbnMgYXJlIGVxdWFsIGluIHRoZSBzeXN0ZW0uIAogIFRoZXJlIGFyZSBubyBwbHVnLWlucyB3aGljaCBnZXQgc3BlY2lhbCB0cmVhdG1lbnQgb3IgcHJpdmlsZWdlcy4gRm9yIGV4YW1wbGUsIAogIHRoZSBXb3JrYmVuY2ggVUkgaXMgYSBwbHVnLWluIHdoaWNoIHByZXNlbnRzIHRoZSByZXNvdXJjZSBtb2RlbCBkZWZpbmVkIGJ5IHRoZSAKICBSZXNvdXJjZXMgcGx1Zy1pbi4gU2luY2UgdGhlIFdvcmtiZW5jaCBhY2Nlc3NlcyB0aGUgUmVzb3VyY2VzIHBsdWctaW4gb25seSB2aWEgCiAgQVBJLCBhbGwgb3RoZXIgcGx1Zy1pbnMgaGF2ZSBleGFjdGx5IHRoZSBzYW1lIG9wcG9ydHVuaXRpZXMgZm9yIG1hbmlwdWxhdGluZyAKICByZXNvdXJjZXMuPC9wPgo8cD5JdCBmb2xsb3dzIGZyb20gdGhpcywgdGhhdCBjYXBhYmlsaXRpZXMgYXJlIGFkZGVkIHRvIHRoZSBQbGF0Zm9ybSBpbmNyZW1lbnRhbGx5LCAKICBieSBhZGRpbmcgcGx1Zy1pbnMuIEVhY2ggbmV3IHBsdWctaW4gdGllcyBpbnRvIHRoZSBBUEkgb2YgZXhpc3RpbmcgcGx1Zy1pbnMgCiAgYW5kIHByb3ZpZGVzIG5ldyBmdW5jdGlvbmFsaXR5LiBTdGlsbCBvdGhlciBwbHVnLWlucyB0aGVuIGJ1aWxkIG9uIHRoZSBBUEkgb2YgCiAgdGhlc2UgbmV3IHBsdWctaW5zIHRvIGFkZCBzdGlsbCBtb3JlIGZ1bmN0aW9uYWxpdHkgdG8gdGhlIFBsYXRmb3JtLiBBbmQgc28gb24uLi48L3A+CiAgICAgICAgICAgICAgIAogIAo8cD5Bbm90aGVyIGRlc2lnbiBwb2ludCB0aGF0IG1ha2VzIEVjbGlwc2UgZXh0cmVtZWx5IGV4dGVuc2libGUgaXMgaXRzIHBvbGljeSAKICBvZiBsYXp5IHBsdWctaW4gYWN0aXZhdGlvbi4gT25seSB0aG9zZSBwbHVnLWlucyB3aXRoIGNvZGUgdGhhdCBpcyBhY3R1YWxseSBiZWluZyAKICB1c2VkIGFyZSBhY3RpdmF0ZWQuIExhenkgYWN0aXZhdGlvbiBpcyBrZXkgdG8gc3VwcG9ydGluZyBhIGxhcmdlIGJhc2Ugb2YgaW5zdGFsbGVkIAogIHBsdWctaW5zLCBvbmx5IHNvbWUgb2Ygd2hpY2ggYXJlIG5lZWRlZCBpbiBhbnkgZ2l2ZW4gdXNlciBzZXNzaW9uLiBVbnRpbCBhIHBsdWctaW4ncyAKICBjb2RlIGlzIGxvYWRlZCwgaXQgaGFzIGEgbmVnbGlnaWJsZSBtZW1vcnkgZm9vdHByaW50IGFuZCBpbXBhY3Qgb24gc3RhcnQgdXAgCiAgdGltZS48L3A+CjxoMj5XaGF0IGlzIGEgUGx1Zy1pbj88L2gyPgo8cD5Ob3RlOiBUaGlzIGFydGljbGUgY292ZXJzIHBsdWctaW5zIGFzIHRoZXkgYXJlIGluIEVjbGlwc2UgMi4xLiBXaGlsZSB0aGVyZQogIGFyZSBzb21lIGNoYW5nZXMgY29taW5nIGluIEVjbGlwc2UgMy4wLCB0aGUgYmFzaWMgbW9kZWwgZGVzY3JpYmVkIGhlcmUgd2lsbAogIGNvbnRpbnVlIHRvIGJlIGFjY3VyYXRlLjwvcD4KPHA+RnVuZGFtZW50YWxseSwgcGx1Zy1pbnMKICAgIGFyZSBkZWZpbmVkIGJ5IGFuIFhNTCA8ZW0+bWFuaWZlc3QKICAgICAgZmlsZTwvZW0+IGNhbGxlZCA8Y29kZT48c3Ryb25nPnBsdWdpbi54bWw8L3N0cm9uZz48L2NvZGU+LiBBbiBleGFtcGxlIHBsdWctaW4KICAgICAgbWFuaWZlc3QgaXMgc2hvd24gYmVsb3cuIDwvcD4KPGJsb2NrcXVvdGU+IAogIDxwcmU+Jmx0Oz94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPyZndDsKJmx0O3BsdWdpbgogICAgaWQ9ImNvbS5leGFtcGxlLm15cGx1Z2luIgogICAgbmFtZT0iTXkgUGx1Z2luIgogICAgdmVyc2lvbj0iMi4wLjAiCiAgICBwcm92aWRlci1uYW1lPSJFeGFtcGxlIFBsdWctaW5zIEluYy4iJmd0Ozxicj4mbHQ7L3BsdWdpbiZndDsKPC9wcmU+CjwvYmxvY2txdW90ZT4KPHA+RWFjaCBwbHVnLWluIGlzIGNvbnRhaW5lZCBpbiBhIGZpbGUgc3lzdGVtIGRpcmVjdG9yeSBvciBhdCBhIGJhc2UgVVJMIG9uIGEgCiAgc2VydmVyLCB3aXRoIGEgcGx1Zy1pbiBtYW5pZmVzdCBmaWxlIChhcyBzZWVuIGFib3ZlKSBhbmQgYW55dGhpbmcgZWxzZSBpdCBuZWVkcy4gCjwvcD4KPHA+QSB0eXBpY2FsIHBsdWctaW4gY29uc2lzdHMgb2YgSmF2YSBjb2RlIGluIGEgSkFSIGxpYnJhcnksIHNvbWUgcmVhZC1vbmx5IGZpbGVzLCAKICBhbmQgb3RoZXIgcmVzb3VyY2VzIHN1Y2ggYXMgaW1hZ2VzLCB3ZWIgdGVtcGxhdGVzLCBtZXNzYWdlIGNhdGFsb2dzLCBuYXRpdmUgCiAgY29kZSBsaWJyYXJpZXMsIHRyYW5zbGF0aW9uIGZpbGVzLCBldGMuIE1vc3QgcGx1Zy1pbnMgY29udHJpYnV0ZSBleGVjdXRhYmxlIAogIGNvZGUgdGhvdWdoIG5vdCBhbGwuIERvY3VtZW50YXRpb24gcGx1Zy1pbnMsIGZvciBleGFtcGxlLCBjb250cmlidXRlIG9ubGluZSAKICBoZWxwIGluIHRoZSBmb3JtIG9mIEhUTUwgcGFnZXMuIElmIGEgcGx1Zy1pbiBkb2VzIGNvbnRhaW4gY29kZSBpdCBtdXN0IGVpdGhlciAKICBiZSB3cml0dGVuIGluIEphdmEgb3IgYmUgY2FsbGFibGUgZnJvbSBKYXZhLiA8L3A+CjxwPlRoZSBhYm92ZSBwbHVnLWluIGV4YW1wbGUgaXMgdmVyeSBzaW1wbGUuIFRoZSBmb2xsb3dpbmcgc2VjdGlvbnMgc2hvdyBob3cgdGhlIAogIGZvbGxvd2luZyBlbGVtZW50cyBvZiB0aGUgcGx1Zy1pbiBhcmNoaXRlY3R1cmUgYXJlIHVzZWQgdG8gcm91bmQgb3V0IHRoZSBzcGVjaWZpY2F0aW9uIAogIG9mIGEgcGx1Zy1pbi48L3A+Cjx1bD4KICA8bGk+PGI+TGlicmFyaWVzPC9iPiBkZWZpbmUgdGhlIGxvY2F0aW9uIG9mIGV4ZWN1dGFibGUgY29kZS4gPC9saT4KICA8bGk+PGI+UHJlcmVxdWlzaXRlczwvYj4gZGVmaW5lIGRlcGVuZGVuY2llcyBiZXR3ZWVuIHBsdWctaW5zLiA8L2xpPgogIDxsaT48Yj5FeHRlbnNpb24gcG9pbnRzPC9iPiBhbGxvdyBvdGhlciBwbHVnLWlucyB0byBjb250cmlidXRlIGluZm9ybWF0aW9uIGluIAogICAgYSB3ZWxsLWRlZmluZWQgbWFubmVyLiA8L2xpPgogIDxsaT48Yj5FeHRlbnNpb25zPC9iPiBjb250cmlidXRlIGluZm9ybWF0aW9uIHRvIHRoZSBleHRlbnNpb24gcG9pbnRzIG9mIG90aGVyIAogICAgcGx1Zy1pbnMuIDwvbGk+CiAgPGxpPjxiPkZyYWdtZW50czwvYj4gYWxsb3cgYSBwbHVnLWluIHRvIGJlIGV4dGVuZGVkIHdpdGhvdXQgdGhlIG5lZWQgdG8gbW9kaWZ5IAogICAgYW55dGhpbmcgcmVsYXRlZCB0byB0aGUgZXhpc3RpbmcgcGx1Zy1pbi4gPC9saT4KPC91bD4KPGgyPldoYXQgaXMgYSBMaWJyYXJ5PzwvaDI+CjxwPlRoZSBmaXJzdCB0aGluZyB5b3UgYXJlIGxpa2VseSB0byB3YW50IHRvIGRvIHdpdGggYSBwbHVnLWluIGlzIGRlZmluZSB0aGUgbG9jYXRpb24gCiAgb2YgdGhlIHBsdWctaW4ncyBleGVjdXRhYmxlIGNvZGUgYW5kL29yIHJlc291cmNlcy4gPGNvZGU+PHN0cm9uZz5saWJyYXJ5PC9zdHJvbmc+PC9jb2RlPiAKICBlbnRyaWVzIGluIHBsdWdpbi54bWwgKHNlZSBleGFtcGxlIGJlbG93KSBkZXNjcmliZSB0aGUgc2hhcGUgb2YgdGhlc2UgY29udHJpYnV0aW9ucy4gCjwvcD4KPGJsb2NrcXVvdGU+CjxwcmU+Jmx0Oz94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPyZndDsKJmx0O3BsdWdpbgogICAgaWQ9ImNvbS5leGFtcGxlLm15cGx1Z2luIgogICAgbmFtZT0iTXkgUGx1Z2luIgogICAgdmVyc2lvbj0iMi4wLjAiCiAgICBwcm92aWRlci1uYW1lPSJFeGFtcGxlIFBsdWctaW5zIEluYy4iJmd0OwoKICA8c3Ryb25nPiZsdDtydW50aW1lJmd0OwogICAgJmx0O2xpYnJhcnkgbmFtZT0ibXlsaWJyYXJ5LmphciIgdHlwZT0mcXVvdDtjb2RlJnF1b3Q7Jmd0OwogICAgICAmbHQ7ZXhwb3J0IG5hbWU9IioiLyZndDsKICAgICZsdDsvbGlicmFyeSZndDsKICAmbHQ7L3J1bnRpbWUmZ3Q7Cjwvc3Ryb25nPgombHQ7L3BsdWdpbiZndDsKPC9wcmU+CjwvYmxvY2txdW90ZT4KPHA+PGNvZGU+PHN0cm9uZz5saWJyYXJ5PC9zdHJvbmc+PC9jb2RlPiBlbGVtZW50cyBzcGVjaWZ5IGEgcG9ydGlvbiBvZiB0aGUgcGx1Zy1pbidzIAogIGxvY2FsIGNsYXNzcGF0aC4gRWFjaCBwbHVnLWluIGhhcyB0d28gY2xhc3NwYXRoczogb25lIGZvciBjb2RlIGxpYnJhcmllcyBhbmQgCiAgb25lIGZvciByZXNvdXJjZSBsaWJyYXJpZXMuIENvcnJlc3BvbmRpbmdseSwgPGNvZGU+PHN0cm9uZz5saWJyYXJ5PC9zdHJvbmc+PC9jb2RlPiAKICBlbGVtZW50cyBoYXZlIGEgdHlwZSBhdHRyaWJ1dGUgd2hvc2UgdmFsdWUgaXMgZWl0aGVyIDxjb2RlPjxzdHJvbmc+Y29kZTwvc3Ryb25nPjwvY29kZT4gCiAgb3IgPGNvZGU+PHN0cm9uZz5yZXNvdXJjZTwvc3Ryb25nPjwvY29kZT4gKDxjb2RlPjxzdHJvbmc+Y29kZTwvc3Ryb25nPjwvY29kZT4gCiAgaXMgdGhlIGRlZmF1bHQpLiBDb2RlIGxpYnJhcmllcyBjb250YWluIEphdmEgY2xhc3MgZmlsZXMgYXMgd2VsbCBhcyBhbnkgYXNzb2NpYXRlZCAKICByZXNvdXJjZXMuIFRoZXJlIGlzIG5vIG5lZWQgdG8gYXJ0aWZpY2lhbGx5IHNlcGFyYXRlIHJlc291cmNlcyBmcm9tIHRoZSBjb2RlIAogIGFzIGNvZGUgbGlicmFyaWVzIGNhbiBjb250YWluIGJvdGguIExpYnJhcmllcyBkZWZpbmVkIGFzIHR5cGUgPGNvZGU+PHN0cm9uZz5yZXNvdXJjZTwvc3Ryb25nPjwvY29kZT4gCiAgb24gdGhlIG90aGVyIGhhbmQsIGNhbiBjb250YWluIG9ubHkgcmVzb3VyY2VzIChwcm9wZXJ0aWVzIGZpbGVzLCBpbWFnZXMpLjwvcD4KPHA+VGhlIGRpc3RpbmN0aW9uIGFsbG93cyB0aGUgY2xhc3Nsb2FkZXJzIHRvIGlnbm9yZSByZXNvdXJjZSBsaWJyYXJpZXMgd2hpbGUgCiAgbG9hZGluZyBjbGFzc2VzLCBhcyB0aGV5IGFyZSBndWFyYW50ZWVkIHRvIGNvbnRhaW4gb25seSByZXNvdXJjZXMgKGUuZy4sIHRyYW5zbGF0ZWQgCiAgcHJvcGVydGllcyBmaWxlcykuIFRoaXMgdHJhbnNsYXRlcyBpbnRvIHBlcmZvcm1hbmNlIGltcHJvdmVtZW50cyBhcyB0aGVyZSBhcmUgCiAgZmV3ZXIgcGxhY2VzIHRvIGxvb2sgZm9yIGNsYXNzZXMuIE5vdGUgdGhhdCBib3RoIHRoZSBjb2RlIGFuZCByZXNvdXJjZSBsaWJyYXJpZXMgCiAgYXJlIGNvbnN1bHRlZCB3aGVuIGxvYWRpbmcgcmVzb3VyY2VzLjwvcD4KPHA+RWFjaCA8c3Ryb25nPjxjb2RlPmxpYnJhcnk8L2NvZGU+PC9zdHJvbmc+IGVsZW1lbnQgaWRlbnRpZmllcyBhIGZpbGVzIHN5c3RlbSAKICBsb2NhdGlvbiAoZGlyZWN0b3J5IG9yIGphciBmaWxlKSB3aGljaCBjb250YWlucyB0aGUgY29kZSBhbmQvb3IgcmVzb3VyY2VzLiBUaGUgCiAgcGF0aCBzcGVjaWZpZWQgaXMgcmVsYXRpdmUgdG8gdGhlIHBsdWctaW4ncyBmaWxlIHN5c3RlbSBkaXJlY3RvcnkgYW5kIGNhbm5vdCAKICByZXNvbHZlIHRvIGEgbG9jYXRpb24gb3V0c2lkZSB0aGUgc2NvcGUgb2YgdGhlIHBsdWctaW4gKGZvciBleGFtcGxlLCAmcXVvdDsuLi8uLi9mb28uamFyJnF1b3Q7IAogIGlzIG5vdCBhbGxvd2VkKS4gPC9wPgo8cD5CeSBkZWZhdWx0LCBldmVyeXRoaW5nIGluIGEgY29kZSBsaWJyYXJ5IGlzIGNvbnNpZGVyZWQgcHJpdmF0ZSAoaS5lLiwga25vd24gCiAgb25seSB3aXRoaW4gdGhlIHNjb3BlIG9mIHRoZSBwbHVnLWluKS4gUG9ydGlvbnMgb2YgYSBsaWJyYXJ5IGFyZSBtYWRlIHZpc2libGUgCiAgb3V0c2lkZSBpdHMgY29udGFpbmluZyBwbHVnLWluIHVzaW5nIHRoZSA8c3Ryb25nPjxjb2RlPmV4cG9ydDwvY29kZT48L3N0cm9uZz4gCiAgc3ViLWVsZW1lbnQuIFBsdWctaW5zIGNhbiBleHBvcnQgc29tZSwgYWxsIG9yIG5vbmUgb2YgdGhlaXIgbGlicmFyaWVzIGJ5IHNwZWNpZnlpbmcgCiAgcGF0dGVybnMgaW4gdGhlIG5hbWUgYXR0cmlidXRlIG9mIHRoZSA8c3Ryb25nPjxjb2RlPmV4cG9ydDwvY29kZT48L3N0cm9uZz4gdGFnLiAKPC9wPgo8cD5BIDxzdHJvbmc+PGNvZGU+bGlicmFyeTwvY29kZT48L3N0cm9uZz4gZW50cnkgY29udGFpbmVkIGluIG91ciBleGFtcGxlIHBsdWctaW4sIAogIDxjb2RlPmNvbS5leGFtcGxlLm15cGx1Z2luPC9jb2RlPiBpcyBzaG93biBpbiB0aGUgc25pcHBldCBhYm92ZS4gSXQgc2hvd3MgYSAKICBjb2RlIGxpYnJhcnkgY2FsbGVkICZxdW90O215bGlicmFyeS5qYXImcXVvdDsgd2hpY2ggaXMgZXhwb3J0ZWQgaW4gdG90YWwuPC9wPgo8aDI+V2hhdCBpcyBhIFBsdWctaW4gUHJlcmVxdWlzaXRlPzwvaDI+CjxwPlBsdWctaW5zIG11c3QgZGVjbGFyZSB0aGVpciBkZXBlbmRlbmNpZXMgb24gb3RoZXIgcGx1Zy1pbnMgdXNpbmcgYSA8c3Ryb25nPjxjb2RlPnJlcXVpcmVzPC9jb2RlPjwvc3Ryb25nPiAKICBlbGVtZW50IGluIHRoZWlyIHBsdWctaW4gbWFuaWZlc3QgZmlsZS4gVHlwaWNhbGx5IGRlcGVuZGVuY2llcyBhcmlzZSBmcm9tIGludGVyLXBsdWctaW4gCiAgY2xhc3MgcmVmZXJlbmNlcy4gSWYgYSBwbHVnLWluIEEgcmVxdWlyZXMgcGx1Zy1pbiBCLCBwbHVnLWluIEIgaXMgc2FpZCB0byBiZSAKICBhIHByZXJlcXVpc2l0ZSBvZiBwbHVnLWluIEEuIENvbnRpbnVpbmcgb3VyIGV4YW1wbGUsIHRoZSBtYW5pZmVzdCBiZWxvdyBzaG93cyAKICB0aGUgcGx1Z2luLnhtbCBleHByZXNzaW5nIGEgZGVwZW5kZW5jeSBvbiA8Y29kZT5jb20uZXhhbXBsZS5hbm90aGVycGx1Z2luPC9jb2RlPi48L3A+CjxibG9ja3F1b3RlPiAKICA8cHJlPiZsdDs/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8mZ3Q7CiZsdDtwbHVnaW4KICAgIGlkPSJjb20uZXhhbXBsZS5teXBsdWdpbiIKICAgIG5hbWU9Ik15IFBsdWctaW4iCgkgdmVyc2lvbj0iMi4wLjAiCiAgICBwcm92aWRlci1uYW1lPSJFeGFtcGxlIFBsdWctaW5zIEluYy4iJmd0Ozxicj4KICA8c3Ryb25nPiZsdDtyZXF1aXJlcyZndDsKICAgICZsdDtpbXBvcnQgcGx1Z2luPSJjb20uZXhhbXBsZS5hbm90aGVycGx1Z2luIgogICAgICAgIHZlcnNpb249JnF1b3Q7Mi4xLjMmcXVvdDsKICAgICAgICBtYXRjaD0mcXVvdDtlcXVpdmFsZW50JnF1b3Q7LyZndDsKICAmbHQ7L3JlcXVpcmVzJmd0Owo8L3N0cm9uZz4KICAmbHQ7cnVudGltZSZndDsKICAgICZsdDtsaWJyYXJ5IG5hbWU9Im15bGlicmFyeS5qYXIiIHR5cGU9JnF1b3Q7Y29kZSZxdW90OyZndDsKICAgICAgJmx0O2V4cG9ydCBuYW1lPSIqIi8mZ3Q7CiAgICAmbHQ7L2xpYnJhcnkmZ3Q7CiAgJmx0Oy9ydW50aW1lJmd0OwoKJmx0Oy9wbHVnaW4mZ3Q7PC9wcmU+CjwvYmxvY2txdW90ZT4KPHA+SW4gdGhpcyBleGFtcGxlLCA8Y29kZT5jb20uZXhhbXBsZS5teXBsdWdpbjwvY29kZT4gKE15IFBsdWdpbikgY2FuIGFjY2VzcyBhbnkgCiAgb2YgdGhlIGNsYXNzZXMgaW4gPGNvZGU+Y29tLmV4YW1wbGUuYW5vdGhlcnBsdWdpbjwvY29kZT4gKEFub3RoZXIgUGx1Z2luKSB3aGljaCAKICBhcmUgZXhwbGljaXRseSBleHBvcnRlZCBpbiBpdHMgbGlicmFyeSBzdGF0ZW1lbnRzLiA8L3A+CjxwPk5vdGljZSB0aGF0IHRoZSA8c3Ryb25nPjxjb2RlPmltcG9ydDwvY29kZT48L3N0cm9uZz4gc3RhdGVtZW50IGlzIHF1YWxpZmllZCAKICBieSBhIHZlcnNpb24gbnVtYmVyIGFuZCBtYXRjaGluZyBydWxlLiBWZXJzaW9ucyByZWZpbmUgdGhlIGRlcGVuZGVuY2llcyBiZXR3ZWVuIAogIHBsdWdpbnMgYW5kIGhlbHAgdGhlIHJ1bnRpbWUgY2hvb3NlIGJldHdlZW4gZGlmZmVyZW50IGluc3RhbGxhdGlvbnMgb2YgdGhlIHNhbWUgCiAgcGx1Zy1pbi4gSW4gZ2VuZXJhbCB0aGUgcnVudGltZSBwaWNrcyB0aGUgbW9zdCByZWNlbnQgdmVyc2lvbiB3aGljaCBtYXRjaGVzIAogIGdpdmVuIHRoZSBtYXRjaGluZyBydWxlLiBFY2xpcHNlIHZlcnNpb24gbnVtYmVycyBhcmUgYSBmb3VyIHBhcnQgc3RyaW5nIG9mIHRoZSAKICBmb3JtIDxzdHJvbmc+PGNvZGU+bWFqb3IubWlub3Iuc2VydmljZS50YWc8L2NvZGU+PC9zdHJvbmc+LiBWZXJzaW9ucyBhcmUgY29tcGFyZWQgCiAgdXNpbmcgb25lIG9mIGZvdXIgbWF0Y2hpbmcgcnVsZXMuPC9wPgo8ZGw+CiAgPGRsPgogICAgPGR0PjxiPnBlcmZlY3Q8L2I+PC9kdD4KICAgIDxkZD5BbGwgZm91ciBjb21wb25lbnRzIG9mIHRoZSB2ZXJzaW9uIG11c3QgbWF0Y2guPC9kZD4KICAgIDxkdD48Yj5lcXVpdmFsZW50PC9iPjwvZHQ+CiAgICA8ZGQ+bWFqb3IgYW5kIG1pbm9yIG11c3QgbWF0Y2ggYW5kIG90aGVycyBtdXN0IHNvcnQgYWZ0ZXI8L2RkPgogICAgPGR0PjxiPmNvbXBhdGlibGU8L2I+IChkZWZhdWx0KTwvZHQ+CiAgICA8ZGQ+bWFqb3IgbXVzdCBtYXRjaCBhbmQgb3RoZXJzIG11c3Qgc29ydCBhZnRlcjwvZGQ+CiAgICA8ZHQ+PGI+Z3JlYXRlck9yRXF1YWw8L2I+PC9kdD4KICAgIDxkZD5BbnkgdmVyc2lvbiB3aGljaCBpcyBhIHBlcmZlY3QgbWF0Y2ggb3Igc29ydHMgbGV4b2dyYXBoaWNhbGx5IGFmdGVyPC9kZD4KICA8L2RsPgo8L2RsPgo8cD5QbHVnLWluIGRlcGVuZGVuY2llcyBhcmUgdHJhbnNpdGl2ZS4gVGhhdCBpcywgaWYgQW5vdGhlciBQbHVnaW4gcmVxdWlyZXMgc29tZQogICBwbHVnLWluLCBzYXkgRmluYWwgUGx1Z2luLCB0aGVuIE15IFBsdWdpbiB3aWxsIG5vdCBiZSBlbmFibGVkIHVubGVzcyBib3RoCiAgQW5vdGhlciAKICBQbHVnaW4gYW5kIEZpbmFsIFBsdWdpbiBhcmUgcHJlc2VudC4gVGhpcyBpcyBlYXN5IHRvIHNlZSBzaW5jZSBBbm90aGVyIFBsdWdpbgogICB3b3VsZCBiZSBkaXNhYmxlZCBpZiBpdHMgcHJlcmVxdWlzaXRlcyBhcmUgbm90IHByZXNlbnQgKGUuZy4sIEZpbmFsIFBsdWdpbgogIGlzIG1pc3NpbmcpLiBTaW1pbGFybHksIE15IFBsdWdpbiB3b3VsZCBhbHNvIGJlIGRpc2FibGVkIGlmIGl0cyBwcmVyZXF1aXNpdGUsCiAgQW5vdGhlciAgUGx1Z2luLCBpcyBub3QgcHJlc2VudC4gVW5kZXIgbm8gY2lyY3Vtc3RhbmNlcyBhcmUgY2lyY3VsYXIgZGVwZW5kZW5jaWVzCiAgcGVybWl0dGVkLiAKICBBbnkgcGx1Zy1pbiBpbnZvbHZlZCBpbiBhIGN5Y2xlIHdpbGwgYmUgZGlzYWJsZWQgYXQgcnVudGltZS48L3A+CjxwPkNsYXNzIHZpc2liaWxpdHkgdGhyb3VnaCB0aGUgZGVwZW5kZW5jeSBjaGFpbiBpcyBub3QgdHJhbnNpdGl2ZSB1bmxlc3MgZXhwbGljaXRseQogIHN0YXRlZC4gVGhhdCBpcywgTXkgUGx1Z2luIGNhbm5vdCBzZWUgdGhlIGNsYXNzZXMgaW4gRmluYWwgUGx1Z2luLiBUaGlzIGVmZmVjdGl2ZWx5CiAgZW5jYXBzdWxhdGVzCiAgdGhlIGltcGxlbWVudGF0aW9uIG9mIEFub3RoZXIgUGx1Z2luLiBXaGVyZSB0cmFuc2l0aXZpdHkgaXMgcmVxdWlyZWQsIHRoZSA8Y29kZT48c3Ryb25nPmV4cG9ydDwvc3Ryb25nPjwvY29kZT4gCiAgYXR0cmlidXRlIG9mIHRoZSA8c3Ryb25nPjxjb2RlPmltcG9ydDwvY29kZT48L3N0cm9uZz4gdGFnIGlzIHVzZWQgdG8gcmUtZXhwb3J0CiAgIHRoZSBjbGFzc2VzIGV4cG9ydGVkIGJ5IGltcG9ydGVkIHBsdWctaW5zLiAodHJ5IHNheWluZyB0aGF0IGEgZmV3IHRpbWVzIHF1aWNrbHkhKS4KICAKICBGb3IgZXhhbXBsZSwgQW5vdGhlciAKICBQbHVnaW4gY2FuIGV4cGxpY2l0bHkgcmUtZXhwb3J0IGl0cyBpbXBvcnQgb2YgRmluYWwgUGx1Z2luOjwvcD4KIDxibG9ja3F1b3RlPgogIDxwcmU+ICAgICZsdDtpbXBvcnQgcGx1Z2luPSJjb20uZXhhbXBsZS5maW5hbHBsdWdpbiIgZXhwb3J0PSZxdW90O3RydWUmcXVvdDsvJmd0Owo8L3ByZT4KPC9ibG9ja3F1b3RlPgo8cD5GaW5hbGx5LCBwbHVnLWluIHByZXJlcXVpc2l0ZSBzdGF0ZW1lbnRzIGNhbiBiZSBtYWRlIG9wdGlvbmFsIGJ5IGFkZGluZyB0aGUgCiAgPHN0cm9uZz48Y29kZT5vcHRpb25hbD0mcXVvdDt0cnVlJnF1b3Q7PC9jb2RlPjwvc3Ryb25nPiBhdHRyaWJ1dGUgdG8gdGhlIDxzdHJvbmc+PGNvZGU+aW1wb3J0PC9jb2RlPjwvc3Ryb25nPiAKICB0YWcgKHNlZSBiZWxvdyBmb3IgYW4gZXhhbXBsZSkuIE1hcmtpbmcgYW4gaW1wb3J0IGFzIDxjb2RlPm9wdGlvbmFsPC9jb2RlPiBzaW1wbHkgCiAgc3RhdGVzIHRoYXQgaWYgdGhlIHNwZWNpZmllZCBwbHVnLWluIGlzIG5vdCBmb3VuZCBhdCBydW50aW1lLCB0aGUgZGVwZW5kZW50IAogIHBsdWctaW4gc2hvdWxkIGJlIGxlZnQgZW5hYmxlZC4gVGhpcyBpcyB1c2VkIHdoZW4gYSBwbHVnLWluIGNhbiBiZSB1c2VkIGluIG1hbnkgCiAgc2NlbmFyaW9zIG9yIGl0IGlzIHJlYXNvbmFibGUgdG8gb3BlcmF0ZSB3aXRoIHJlZHVjZWQgZnVuY3Rpb24uIEl0IGFsbG93cyB0aGUgCiAgY3JlYXRpb24gb2YgbWluaW1hbCBpbnN0YWxscyB0aGF0IGNvdmVyIGZ1bmN0aW9uYWwgc3Vic2V0cy4gQXV0aG9ycyBvZiBwbHVnLWlucyAKICB1c2luZyBvcHRpb25hbCBwcmVyZXF1aXNpdGVzIHNob3VsZCB0YWtlIHNwZWNpYWwgY2FyZSB0byBhdm9pZCBvciBoYW5kbGUgdGhlIAogIENsYXNzTm90Rm91bmRFeGNlcHRpb25zIHdoaWNoIHdpbGwgb2NjdXIgd2hlbiB0aGUgb3B0aW9uYWwgcGx1Zy1pbiBpcyBub3QgcHJlc2VudC48L3A+CjxwcmU+ICAgICZsdDtpbXBvcnQgcGx1Z2luPSJjb20uZXhhbXBsZS5maW5hbHBsdWdpbiIgb3B0aW9uYWw9JnF1b3Q7dHJ1ZSZxdW90Oy8mZ3Q7CjwvcHJlPgo8aDI+V2hhdCBhcmUgRXh0ZW5zaW9ucyBhbmQgRXh0ZW5zaW9uIFBvaW50cz88L2gyPgo8cD48ZW0+RXh0ZW5zaW9uIHBvaW50czwvZW0+IGFyZSBhIG1lY2hhbmlzbSB1c2VkIGJ5IHBsdWctaW5zIHRvIGluZGljYXRlIHRoZXkgCiAgYXJlIHdpbGxpbmcgdG8gYWNjZXB0IGNvbnRyaWJ1dGlvbnMgZnJvbSBvdGhlciBwbHVnLWlucy4gQW4gPGVtPmV4dGVuc2lvbjwvZW0+IAogIGlzIGEgcGx1Zy1pbidzIHdheSBvZiBjb250cmlidXRpbmcgaW5mb3JtYXRpb24gdG8gdGhlc2UgZXh0ZW5zaW9uIHBvaW50cy4gRm9yIAogIGV4YW1wbGUsIGEgVUkgcGx1Zy1pbiBtaWdodCBleHBvc2UgYW4gZXh0ZW5zaW9uIHBvaW50IGZvciBtZW51IGFjdGlvbnMuIEEgcGx1Zy1pbiAKICB3aXNoaW5nIHRvIGNvbnRyaWJ1dGUgYW4gYWN0aW9uIHRvIHRoZSBVSSB3b3VsZCBkZWZpbmUgYW4gZXh0ZW5zaW9uIGZvciB0aGUgCiAgVUkncyBtZW51IGFjdGlvbiBleHRlbnNpb24gcG9pbnQuPC9wPgo8cD5FeHRlbnNpb24gcG9pbnRzIGhhdmUgYSBnbG9iYWxseSB1bmlxdWUgaWQgY29uc3RydWN0ZWQgZnJvbSB0aGUgZGVmaW5pbmcgcGx1Zy1pbiAKICBpZCBhbmQgYSBzaW1wbGUgaWQgc3BlY2lmaWVkIGluIHRoZSBleHRlbnNpb24gcG9pbnQgaXRzZWxmLiBUaGUgZXhhbXBsZSBiZWxvdyAKICBpcyBmcm9tIHRoZSA8Y29kZT5vcmcuZWNsaXBzZS51aTwvY29kZT4gcGx1Zy1pbi4gVGhlIGZ1bGwgaWRlbnRpZmllciBvZiB0aGUgCiAgZXh0ZW5zaW9uIHBvaW50IGlzIHRoZXJlZm9yZSA8Y29kZT5vcmcuZWNsaXBzZS51aS5hY3Rpb25TZXRzPC9jb2RlPi4gQWxsIGV4dGVuc2lvbiAKICBwb2ludHMgaGF2ZSB0aGlzIHJlbGF0aXZlbHkgc2ltcGxlIGZvcm0uPC9wPgo8YmxvY2txdW90ZT4KICA8cHJlPiAgJmx0O2V4dGVuc2lvbi1wb2ludCBuYW1lPSJBY3Rpb24gU2V0cyIgaWQ9ImFjdGlvblNldHMiLyZndDs8L3ByZT4KPC9ibG9ja3F1b3RlPgo8cD5UaGUgZXhhY3QgZm9ybSBvZiBleHRlbnNpb25zIGlzIGRlZmluZWQgYnkgdGhlIHBsdWctaW4gd2hpY2ggZGVmaW5lcyB0aGUgZXh0ZW5zaW9uCiAgIHBvaW50IGJlaW5nIGV4dGVuZGVkLiBJbiB0aGUgYWJvdmUgZXhhbXBsZSwgdGhlIFVJIHBsdWctaW4gc3BlY2lmaWVzIHdoYXQKICBpbmZvcm1hdGlvbiAKICBpcyBuZWVkZWQgdG8gZGVmaW5lIHRoZSBtZW51IGFjdGlvbiBhcyB3ZWxsIGFzIHRoZSBmb3JtIG9mIHRoYXQgaW5mb3JtYXRpb24uCiAgIEZvciBleGFtcGxlLCB0aGUgVUkgbmVlZHMgYW4gaWNvbiBhbmQgbGFiZWwgdG8gZHJhdyBhbmQgYSBjbGFzcyB0byBpbnN0YW50aWF0ZQogIGFuZCBydW4gd2hlbiB0aGUgbWVudSBlbnRyeSAKICBpcyBzZWxlY3RlZC4gRXh0ZW5zaW9ucyB3aGljaCBpZGVudGlmeSBjbGFzc2VzIHRvIHJ1biBhcmUgY2FsbGVkICA8ZW0+ZXhlY3V0YWJsZQogIGV4dGVuc2lvbnM8L2VtPi4gVGhlIHR5cGUgY2hhcmFjdGVyaXN0aWNzIChlLmcuLCBzdXBlcmNsYXNzLAogIGludGVyZmFjZXMpIG9mIHRoZSBjbGFzcyBhcmUgYWxzbyBkZWZpbmVkIGJ5IHRoZSBleHRlbnNpb24gcG9pbnQgaXRzZWxmLiBUaGUKICBzbmlwcGV0IGJlbG93IHNob3dzCiAgYW4gZXhhbXBsZSBVSSBleHRlbnNpb24uPC9wPgo8YmxvY2txdW90ZT4gCiAgPHByZT4gICZsdDtleHRlbnNpb24KICAgICAgcG9pbnQ9JnF1b3Q7b3JnLmVjbGlwc2UudWkuYWN0aW9uU2V0cyZxdW90OyZndDsKICAgICZsdDthY3Rpb25TZXQKICAgICAgICBsYWJlbD0mcXVvdDtFeGFtcGxlJnF1b3Q7CiAgICAgICAgdmlzaWJsZT0mcXVvdDtmYWxzZSZxdW90OwogICAgICAgIGlkPSZxdW90O2NvbS5leGFtcGxlLmFjdGlvbnMmcXVvdDsmZ3Q7CiAgICAgICZsdDthY3Rpb24KICAgICAgICAgIGlkPSZxdW90O2NvbS5leGFtcGxlLmFjdGlvbjEmcXVvdDsKICAgICAgICAgIGNsYXNzPSZxdW90O2NvbS5leGFtcGxlLkNvb2xBY3Rpb24mcXVvdDsKICAgICAgICAgIGljb249JnF1b3Q7aWNvbnMvYWN0aW9uMS5naWYmcXVvdDsKICAgICAgICAgIGxhYmVsPSZxdW90O0Nvb2wgQWN0aW9uJnF1b3Q7CiAgICAgICZsdDsvYWN0aW9uJmd0OwogICAgJmx0Oy9hY3Rpb25TZXQmZ3Q7CiAgJmx0Oy9leHRlbnNpb24mZ3Q7CjwvcHJlPgogIDwvYmxvY2txdW90ZT4KPHA+QSBwbHVnLWluIGNhbiBkZWZpbmUgYW55IG51bWJlciBvZiBleHRlbnNpb24gcG9pbnRzIGFuZCBleHRlbnNpb25zLiBGdXJ0aGVyLAogIGFueSBnaXZlbiBleHRlbnNpb24gcG9pbnQgbWF5IGJlIGV4dGVuZGVkIGJ5IGFueSBudW1iZXIgb2YgZXh0ZW5zaW9ucy4gRXh0ZW5zaW9ucwogIGNhbiBleHRlbmQgZXh0ZW5zaW9uIHBvaW50cyBkZWZpbmVkIGluIHRoZWlyIG93biBwbHVnLWluIG9yIGluCiAgb3RoZXJzLiBJdCBmb2xsb3dzLCB0aGVyZWZvcmUsIHRoYXQgZXh0ZW5zaW9uIHBvaW50cyBjYW4gYWNjZXB0IGV4dGVuc2lvbnMKICBmcm9tIHRoZWlyIG93biBwbHVnLWluIG9yIG90aGVyIHBsdWctaW5zLiA8L3A+CjxwPkV4dGVuZGluZyBhbiBleHRlbnNpb24gcG9pbnQgZG9lcyBub3QgaW1wbHkgYSBkZXBlbmRlbmN5IHJlbGF0aW9uc2hpcC4gUmF0aGVyLAogICBpdCBpcyBhIHN0YXRlbWVudCB0aGF0IGlmIHRoZXJlIGlzIGFuIGV4dGVuc2lvbiBwb2ludCB3aXRoIHRoZSBnaXZlbiBpZCAocG9pbnQKICAKICBhdHRyaWJ1dGUgaW4gdGhlIDxzdHJvbmc+PGNvZGU+ZXh0ZW5zaW9uPC9jb2RlPjwvc3Ryb25nPiB0YWcpLCBhZGQgdGhlIGdpdmVuCiAgIGV4dGVuc2lvbi4gT3RoZXJ3aXNlLCBkbyBub3RoaW5nLiBEb2MgcGx1Zy1pbnMgZm9yIGV4YW1wbGUgaGF2ZSBubyBuZWVkIHRvCiAgZ2V0IGNsYXNzZXMgZnJvbSB0aGUgSGVscCBwbHVnLWlucyAtLSB0aGV5IHNpbXBseSBhZGQgZXh0ZW5zaW9ucyB0byBIZWxwIHN5c3RlbQogIGV4dGVuc2lvbiBwb2ludHMuPC9wPgo8aDQ+PC9oND4KPGgyPldoYXQgaXMgYSBQbHVnLWluIEZyYWdtZW50PzwvaDI+CjxwPkZyYWdtZW50cyBhbGxvdyBvcHRpb25hbCBmdW5jdGlvbmFsaXR5L2NvbnRlbnQgdG8gYmUgPHN0cm9uZz5hZGRlZDwvc3Ryb25nPiAKICB0byBleGlzdGluZyBwbHVnLWlucy4gRm9yIGV4YW1wbGUsIHRoZSBiYXNlIEVjbGlwc2UgY29udGFpbnMgb25seSBFbmdsaXNoIG1lc3NhZ2VzLiAKICBGcmFnbWVudHMgYXJlIHVzZWQgdG8gYWRkIG1lc3NhZ2UgY2F0YWxvZ3MgY29udGFpbmluZyBvdGhlciBsYW5ndWFnZXMgKGUuZy4sIAogIEZyZW5jaCwgSXRhbGlhbikgd2l0aG91dCBtb2RpZnlpbmcgdGhlIGV4aXN0aW5nIHBsdWctaW5zLiBOb3RlIHRoYXQgZnJhZ21lbnRzIAogIGNhbiBvbmx5IGFkZCBmdW5jdGlvbi9jb250ZW50IHRvIHBsdWctaW5zLiBUaGV5IGNhbm5vdCBvdmVycmlkZSB0aGF0IHdoaWNoIHRoZSAKICBwbHVnLWluIGFscmVhZHkgY29udGFpbnMuIEZyYWdtZW50cyBhcmUgYWRkZWQgdG8gdGhlIGJhc2UgcGx1Zy1pbiBpbiBubyBwYXJ0aWN1bGFyIAogIG9yZGVyIGFuZCBmcmFnbWVudHMgZm9yIG1pc3NpbmcgcGx1Zy1pbnMgYXJlIGlnbm9yZWQuPC9wPgo8cD5JdCBpcyBub3Qgc3VycHJpc2luZyB0byBmaW5kIHRoYXQgZnJhZ21lbnRzIGFyZSB2ZXJ5IHNpbWlsYXIgdG8gcGx1Zy1pbnM7IHRoZXkgCiAgYXJlIGRlZmluZWQgd2l0aCBhIHNpbmdsZSBtYW5pZmVzdCBmaWxlLCBjYWxsZWQgPHN0cm9uZz48Y29kZT5mcmFnbWVudC54bWw8L2NvZGU+PC9zdHJvbmc+LCAKICBpbiBhIGZpbGUgc3lzdGVtIGRpcmVjdG9yeSB3aGljaCBjb250YWlucyBldmVyeXRoaW5nIHRoZSBmcmFnbWVudCBuZWVkcy4gRWFjaCAKICBmcmFnbWVudCBtdXN0IGJlIGFzc29jaWF0ZWQgd2l0aCBhIHBhcnRpY3VsYXIgcGx1Zy1pbi4gQW5kIGFueSBnaXZlbiBwbHVnLWluIAogIGNhbiBoYXZlIGFueSBudW1iZXIgb2YgZnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCBpdC4gPC9wPgo8cD5GdXJ0aGVyLCBmcmFnbWVudHMgY2FuIGNvbnRyaWJ1dGUgbGlicmFyaWVzLCBwcmVyZXF1aXNpdGVzLCBleHRlbnNpb24gcG9pbnRzIAogIG9yIGV4dGVuc2lvbnMgdXNpbmcgc3RhbmRhcmQgc3ludGF4LiBUaGVzZSBjb250cmlidXRpb25zIGFyZSBzZWFtbGVzc2x5IG1lcmdlZCAKICBpbnRvIHRoZSBmcmFnbWVudCdzIGJhc2UgcGx1Zy1pbi4gVGhhdCBpcywgZXh0ZW5zaW9ucyBhbmQgZXh0ZW5zaW9uIHBvaW50cyBmcm9tIAogIGEgZnJhZ21lbnQgYXBwZWFyIHRvIGNvbWUgZnJvbS9iZSBwYXJ0IG9mIChyZXNwZWN0aXZlbHkpIHRoZSBiYXNlIHBsdWctaW4sIGxpYnJhcmllcyAKICBhcmUgcHV0IG9uIHRoZSBiYXNlIHBsdWctaW4ncyBjbGFzc3BhdGggYW5kIHByZXJlcXVpc2l0ZXMgY29udHJpYnV0ZSB0byB0aGUgCiAgcGx1Zy1pbidzIHByZXJlcXVpc2l0ZSBjaGFpbi48L3A+CjxwPkJlbG93LCBpcyBhbiBleGFtcGxlIG9mIGEgc2ltcGxlIE5MIGZyYWdtZW50IGZvciA8Y29kZT5jb20uZXhhbXBsZS5teXBsdWdpbjwvY29kZT4uPC9wPgo8YmxvY2txdW90ZT4gCiAgPHByZT4mbHQ7P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/Jmd0OwombHQ7ZnJhZ21lbnQKICAgIGlkPSJjb20uZXhhbXBsZS5teXBsdWdpbi5hZGRvbjEiICAJICAKICAgIG5hbWU9IkV4YW1wbGUgQWRkLW9uIDEgRnJhZ21lbnQiCiAgICB2ZXJzaW9uPSIyLjEuMiIKICAgIHByb3ZpZGVyLW5hbWU9IkVjbGlwc2Uub3JnIgogICAgcGx1Z2luLWlkPSJjb20uZXhhbXBsZS5teXBsdWdpbiIKICAgIHBsdWdpbi12ZXJzaW9uPSIyLjEuMCIKICAgIG1hdGNoPSJjb21wYXRpYmxlIiZndDsKCiAgJmx0O3J1bnRpbWUmZ3Q7PGJyPiAgICAmbHQ7bGlicmFyeSBuYW1lPSJubDEuamFyIi8mZ3Q7PGJyPiAgJmx0Oy9ydW50aW1lJmd0Ozxicj4mbHQ7L2ZyYWdtZW50Jmd0Owo8L3ByZT4KPC9ibG9ja3F1b3RlPgo8cD5UaGlzIGZyYWdtZW50IGNvbnRyaWJ1dGVzIGFkZGl0aW9uYWwgamFycyB3aGljaCBjb250YWluIHRyYW5zbGF0aW9ucyBvZiB0aGUKICAgbWVzc2FnZXMgdXNlZCBieSB0aGUgaG9zdGluZyBwbHVnLWluIGl0c2VsZi4gSW4gdGhpcyBjYXNlIHRoZSBqYXIgY29udGFpbnMKICBmaWxlcyBuYW1lZCAKICBhY2NvcmRpbmcgdG8gdGhlIHN0YW5kYXJkIEphdmEgbG9jYWxlLWJhc2VkIGxvb2t1cCBzdHJhdGVneSAoZS5nLiwgbWVzc2FnZV9lbl9VUy5wcm9wZXJ0aWVzLAogICBtZXNzYWdlX2pwX0pQLnByb3BlcnRpZXMpLiBTaW5jZSB0aGUgamFycyBhcmUgYWRkZWQgdG8gdGhlIHBsdWctaW4ncyBjbGFzc3BhdGgsCiAgCiAgdGhlIHBsdWctaW4gY2xhc3Nsb2FkZXIgd2lsbCBmaW5kIHRoZXNlIHJlc291cmNlcyBhdXRvbWF0aWNhbGx5LiA8L3A+CjxoMj5UaGUgUGx1Zy1pbiBNb2RlbCBhdCBSdW50aW1lPC9oMj4KPHA+QWxsIG9mIHRoZSBpbmZvcm1hdGlvbiB3ZSBoYXZlIGRpc2N1c3NlZCBzbyBmYXIgaGFzIGRlYWx0IHdpdGggcGh5c2ljYWwgcGx1Zy1pbgogICBpbmZvcm1hdGlvbiBzdG9yZWQgaW4gdGhlIEVjbGlwc2UgZW52aXJvbm1lbnQuIFdlIHdpbGwgbm93IHRhbGsgYWJvdXQgdGhlIDxlbT5ydW50aW1lPC9lbT4gCiAgdmVyc2lvbiBvZiBhbGwgdGhpcyBwbHVnLWluIGluZm9ybWF0aW9uLjwvcD4KPGg0PlRoZSBQbHVnLWluIFJlZ2lzdHJ5PC9oND4KPHA+V2hlbiB0aGUgRWNsaXBzZSBQbGF0Zm9ybSBzdGFydHMsIGl0IGZpcnN0IGRpc2NvdmVycyBhbGwgYXZhaWxhYmxlIHBsdWctaW5zIAogIGFuZCBmcmFnbWVudHMuIFRoZSBpbnN0YWxsL3VwZGF0ZSBjb21wb25lbnQgb2YgRWNsaXBzZSBhbmQgYSB1c2VyLWRlZmluZWFibGUgCiAgcGx1Zy1pbiBwYXRoIGFyZSB1c2VkIHRvIGRldGVybWluZSBkaXJlY3RvcmllcyB3aGVyZSBwbHVnLWlucyBhbmQgZnJhZ21lbnRzIAogIGNhbiBiZSBmb3VuZC4gRWFjaCBwbHVnLWluL2ZyYWdtZW50IGRpcmVjdG9yeSBtYXkgY29udGFpbiBleGFjdGx5IG9uZSBtYW5pZmVzdCAKICBmaWxlIG5hbWVkIDxjb2RlPnBsdWdpbi54bWwgPC9jb2RlPm9yIDxjb2RlPmZyYWdtZW50LnhtbDwvY29kZT4uIDwvcD4KPHA+IE9uY2UgdGhlIGRpc2NvdmVyeSBpcyBjb21wbGV0ZWQsIHRoZSBwbGF0Zm9ybSBwYXJzZXMgdGhlIGRpc2NvdmVyZWQgbWFuaWZlc3QKICAgZmlsZXMgYW5kIGJ1aWxkcyBhIDxlbT5wbHVnLWluIHJlZ2lzdHJ5PC9lbT4uIE1hbmlmZXN0cyB3aGljaCBjYW5ub3QgYmUgbG9hZGVkCiAgICBhcmUgc2tpcHBlZCBhbmQgdGhlIGZhaWx1cmUgaXMgbm90ZWQgaW4gdGhlIHBsYXRmb3JtJ3MgbG9nICh0eXBpY2FsbHkgdW5kZXIKICAgCiAgaW4gPGNvZGU+Jmx0O3dvcmtzcGFjZSZndDsvLm1ldGFkYXRhLy5sb2c8L2NvZGU+KS4gVGhlIHJlZ2lzdHJ5IGlzCiAgdGhlbiAKICA8ZW0+cmVzb2x2ZWQuPC9lbT4gVGhhdCBpcywgaXQgaXMgZXhhbWluZWQgdG8gZW5zdXJlIHRoZSBzdHJ1Y3R1cmUgaXMgdXNlZnVsCiAgIGFuZCBzYW5lLCBhbmQgaXRzIHN0cnVjdHVyZXMgYXJlIGNyb3NzIGxpbmtlZC4gUmVzb2x1dGlvbiBpbmNsdWRlcyB0aGUgZm9sbG93aW5nCiAgCiAgc3RlcHM6PC9wPgo8dWw+CiAgPGxpPmVhY2ggZWxlbWVudCBpbiB0aGUgbGlzdCAocGx1Zy1pbiwgZnJhZ21lbnQsIGV4dGVuc2lvbiBwb2ludCwgZXRjLikgbXVzdCAKICAgIGhhdmUgYWxsIG9mIHRoZSByZXF1aXJlZCBmaWVsZHMuIFJlcXVpcmVkIGZpZWxkcyBhcmUgdGhvc2UgZmllbGRzIHdpdGggdGhlIAogICAgdGFnICZxdW90OyNSRVFVSVJFRCZxdW90OyBpbiB0aGUgYXBwZW5kaXggJnF1b3Q7RFREJ3MgZm9yIHBsdWdpbi54bWwgYW5kIGZyYWdtZW50LnhtbCIuPC9saT4KICA8bGk+ZWFjaCBmcmFnbWVudCBtdXN0IGJlIGFzc29jaWF0ZWQgd2l0aCBhIHBsdWctaW48L2xpPgogIDxsaT5lYWNoIHBsdWctaW4gbXVzdCBoYXZlIGFjY2VzcyB0byBhbnkgcHJlcmVxdWlzaXRlIHBsdWctaW5zIChhZnRlciB2ZXJzaW9uIAogICAgY29tcGF0aWJpbGl0eSBtYXRjaGluZykgdW5sZXNzIGEgcHJlcmVxdWlzaXRlIGhhcyBiZWVuIGRlbm90ZWQgYXMgPGNvZGU+b3B0aW9uYWw8L2NvZGU+PC9saT4KICA8bGk+ZWFjaCBleHRlbnNpb24gbXVzdCBiZSBtYXRjaGVkIHdpdGggYW4gZXh0ZW5zaW9uIHBvaW50PC9saT4KPC91bD4KPHA+QW4gZXJyb3IgbWVzc2FnZSBpcyBsb2dnZWQgaWYgYW55IHByb2JsZW1zIGFyZSBlbmNvdW50ZXJlZCBhbmQgdGhlIG9mZmVuZGluZyAKICBlbGVtZW50IGlzIHJlbW92ZWQgZnJvbSB0aGUgcGx1Zy1pbiByZWdpc3RyeS4gVGhpcyBhbGxvd3MgRWNsaXBzZSB0byBjb250aW51ZSAKICBydW5uaW5nIGV2ZW4gaWYgdGhlcmUgYXJlIG1pbm9yIHByb2JsZW1zLiBUaGUgcmVzdWx0aW5nIHBsdWctaW4gcmVnaXN0cnkgaXMgCiAgYXZhaWxhYmxlIHZpYSB0aGUgPGNvZGU+b3JnLmVjbGlwc2UuY29yZS5ydW50aW1lPC9jb2RlPiBwbHVnLWluJ3MgQVBJLiBUaGUgd2hvbGUgCiAgcGx1Zy1pbiByZWdpc3RyeSBpcyBhdmFpbGFibGUgdGhyb3VnaCA8Y29kZT5JUGx1Z2luUmVnaXN0cnk8L2NvZGU+IGFuZCBpbmRpdmlkdWFsIAogIHBsdWctaW5zIGNhbiBiZSBleGFtaW5lZCB3aXRoIDxjb2RlPklQbHVnaW5EZXNjcmlwdG9yPC9jb2RlPi48L3A+CjxwPkNoYW5nZXMgdG8gdGhlIHNldCBvZiBpbnN0YWxsZWQgcGx1Zy1pbnMgYXJlIG9ubHkgZGV0ZWN0ZWQgd2hlbiBFY2xpc2UgaXMKICByZXN0YXJ0ZWQuPC9wPgo8aDQ+UGx1Zy1pbiBBY3RpdmF0aW9uPC9oND4KPHA+V2hlbiBFY2xpcHNlIHN0YXJ0cyB1cCwgb25seSB0aG9zZSBwbHVnLWlucyBuZWVkZWQgdG8gYnVpbGQgdGhlIHBsdWctaW4gcmVnaXN0cnkgCiAgYW5kIGdldCB0aGluZ3Mgc3RhcnRlZCBhcmUgYWN0aXZhdGVkLiBBbGwgb3RoZXIgcGx1Zy1pbnMgKHRoZSB2YXN0IG1ham9yaXR5IAogIG9mIHBsdWctaW5zKSByZW1haW4gZG9ybWFudC4gV2hlbiBzb21ldGhpbmcgaGFwcGVucyBjYXVzaW5nIHRoZSBjb2RlIHdpdGhpbiAKICBhIHBsdWctaW4gdG8gYmUgbG9hZGVkLCB0aGF0IHBhcnRpY3VsYXIgcGx1Zy1pbiBpcyBhY3RpdmF0ZWQuIFRoYXQgaXMsIGNsYXNzbG9hZGluZyAKICBpcyB0aGUgb25seSB0cmlnZ2VyIGZvciBwbHVnLWluIGFjdGl2YXRpb24uIFBsdWctaW5zIGFyZSBvbmx5IGFjdGl2YXRlZCBpZiB0aGUgCiAgY2xhc3MgbG9hZGVkIGNvbWVzIGZyb20gdGhlIHBsdWctaW4ncyBsb2NhbCBjbGFzc3BhdGggKGkuZS4sIG9uZSBvZiBpdHMgbGlicmFyaWVzKS4gCiAgTG9hZGluZyBjbGFzc2VzIGZyb20gYSBwcmVyZXF1aXNpdGUgZG9lcyBub3QgY291bnQuIFRoaXMgaXMgdGhlIGJhc2lzIGZvciBFY2xpcHNlJ3MgCiAgbGF6eSBwbHVnLWluIGFjdGl2YXRpb24gcG9saWN5LjwvcD4KPHA+TWFueSB0aGluZ3MgY2FuIGhhcHBlbiB3aXRob3V0IGFjdGl2YXRpbmcgYSBwbHVnLWluLiBJbiBwYXJ0aWN1bGFyLCA8L3A+Cjx1bD4KICA8bGk+cmVzb3VyY2VzIGNhbiBiZSBsb2FkZWQgKGVpdGhlciBmcm9tIGEgcmVzb3VyY2Ugb3IgY29kZSBsaWJyYXJ5KSA8L2xpPgogIDxsaT5wbHVnLWluIGNsYXNzbG9hZGVycyBjYW4gYXNrIG90aGVyIGNsYXNzbG9hZGVycyB0byBsb2FkIGNsYXNzZXMuIDwvbGk+CiAgPGxpPmV4dGVuc2lvbnMgYW5kIGV4dGVuc2lvbiBwb2ludHMgY2FuIGJlIGV4YW1pbmVkIHdpdGhvdXQgaGF2aW5nIHRvIGFjdGl2YXRlIAogICAgdGhlIHBsdWctaW4gdGhhdCBjb250YWlucyB0aGUgZXh0ZW5zaW9uLiA8L2xpPgo8L3VsPgo8cD5PbmNlIGEgcGx1Zy1pbiBpcyBhY3RpdmF0ZWQgaXQgcmVtYWlucyBhY3RpdmUgdW50aWwgRWNsaXBzZSBzaHV0cyBkb3duLiBXaGVuIAogIEVjbGlwc2UgZG9lcyBzaHV0IGRvd24sIGFsbCBwbHVnLWlucyBhcmUgc2h1dCBkb3duIGluIGEgZGVwZW5kZW50cy1maXJzdCBvcmRlci4gCiAgRm9yIGV4YW1wbGUsIGlmIHBsdWctaW4gQSByZXF1aXJlcyBwbHVnLWluIEIsIHRoZW4gcGx1Zy1pbiBBIHdpbGwgYmUgc2h1dCBkb3duIAogIGJlZm9yZSBwbHVnLWluIEIuPC9wPgo8aDQ+UGx1Zy1pbiBDbGFzc2xvYWRpbmc8L2g0Pgo8cD5MaWJyYXJpZXMgZGVmaW5lIHRoZSBsb2NhbCBjbGFzc3BhdGggb2YgYSBwbHVnLWluLiBFYWNoIGxpYnJhcnkgZW50cnkgdHJhbnNsYXRlcyAKICBpbnRvIGFuIGVudHJ5IG9uIHRoZSBjbGFzc3BhdGggb2YgdGhlIHBsdWctaW4ncyBjbGFzc2xvYWRlci4gRWFybGllciB3ZSBkaXNjdXNzZWQgCiAgdGhlIGNvbmNlcHQgb2YgYSA8c3Ryb25nPjxjb2RlPmNvZGU8L2NvZGU+PC9zdHJvbmc+IHZzLiBhIDxzdHJvbmc+PGNvZGU+cmVzb3VyY2U8L2NvZGU+PC9zdHJvbmc+IAogIGxpYnJhcnkuIFJlc291cmNlIGxpYnJhcmllcyBhcmUgbG9hZGVkIGJ5IGEgcmVzb3VyY2UgbG9hZGVyIGFuZCBkbyBub3QgZmlndXJlIAogIGludG8gdGhlIHN0cmljdCBjbGFzc2xvYWRpbmcgbW9kZWwuPC9wPgo8cD5DbGFzc2xvYWRpbmcgaW4gRWNsaXBzZSBmb2xsb3dzIHRoZSBQLVMtUCBtb2RlbC4gVGhhdCBpcywgUGFyZW50LVNlbGYtUHJlcmVxdWlzaXRlcy4gCjwvcD4KPGRsPiAKICA8ZGw+CiAgICA8ZHQ+PGI+UGFyZW50PC9iPiA8L2R0PgogICAgPGRkPkVhY2ggcGx1Zy1pbiBjbGFzc2xvYWRlciBoYXMgdGhlIEVjbGlwc2UgYm9vdCBwbHVnLWluJ3MgY2xhc3Nsb2FkZXIgYXMgCiAgICAgIGl0cyBwYXJlbnQuIFRoZSBib290IHBsdWctaW4gbG9hZGVyJ3MgcGFyZW50IGlzIHRoZSBzeXN0ZW0gY2xhc3Nsb2FkZXIuIAogICAgICBOb3RlIHRoYXQgdGhlIHN0YW5kYXJkIEphdmEgQXBwQ2xhc3Nsb2FkZXIgKHRoZSBvbmUgdXNlZCB0byBsb2FkIHRoZSBjbGFzcyAKICAgICAgY29udGFpbmluZyBtYWluKCkpIGlzIG5vdCBhZGRlZCB0byB0aGUgY2xhc3Nsb2FkaW5nIGNoYWluLiBBcyBhIHJlc3VsdCwgCiAgICAgIHRoZSBqYXJzIGFkZGVkIHRvIHRoZSBKVk0ncyBjbGFzc3BhdGggYXJlIGlnbm9yZWQuIEphcnMgYWRkZWQgdG8gdGhlIEpWTSdzIAogICAgICBib290Y2xhc3NwYXRoIGFyZSBwYXJ0IG9mIHRoZSBzeXN0ZW0gY2xhc3Nsb2FkZXIgYW5kIGFyZSBjb25zaWRlcmVkIGR1cmluZyAKICAgICAgcGx1Zy1pbiBjbGFzc2xvYWRpbmcuPC9kZD4KICAgIDxkdD48Yj5TZWxmPC9iPjwvZHQ+CiAgICA8ZGQ+U2VsZiBjb25zaWRlcnMgdGhlIGxpYnJhcmllcyBkZWZpbmVkIGFzIHBhcnQgb2YgdGhpcyBwbHVnLWluLiBBbGwgY29kZSAKICAgICAgbGlicmFyaWVzIGNvbnRyaWJ1dGVkIGJ5IGZyYWdtZW50cyB0byB0aGlzIHBsdWctaW4gYXJlIGFsc28gY29uc2lkZXJlZC4gCiAgICAgIExpYnJhcmllcyBjb250cmlidXRlZCBieSBmcmFnbWVudHMgYXBwZWFyIGFmdGVyIHRob3NlIGNvbnRyaWJ1dGVkIGluIHRoZSAKICAgICAgcGx1Zy1pbiBtYW5pZmVzdCAoaW4gaW5kZXRlcm1pbmFudCBvcmRlcikuIExpYnJhcmllcyBmcm9tIHRoZSBzYW1lIG1hbmlmZXN0IAogICAgICBhcHBlYXIgb24gdGhlIGNsYXNzIHBhdGggaW4gdGhlIHNhbWUgb3JkZXIgaW4gd2hpY2ggdGhleSB3ZXJlIGRlY2xhcmVkLjwvZGQ+CiAgICA8ZHQ+PGI+UHJlcmVxdWlzaXRlczwvYj48L2R0PgogICAgPGRkPkZpbmFsbHkgdGhlIGV4cG9ydGVkIGxpYnJhcmllcyBvZiB0aGUgcGx1Zy1pbidzIHByZXJlcXVpc2l0ZXMgYXJlIGNvbnNpZGVyZWQuIAogICAgICBQcmVyZXF1aXNpdGVzIGFyZSBxdWVyaWVkIGluIHRoZSBvcmRlciBpbiB3aGljaCB0aGV5IHdlcmUgZGVjbGFyZWQgd2l0aCAKICAgICAgdGhlIGV4Y2VwdGlvbiBvZiB0aGUgcnVudGltZSBwbHVnaW4gKDxjb2RlPm9yZy5lY2xpcHNlLmNvcmUucnVudGltZTwvY29kZT4pLiAKICAgICAgQWxsIHBsdWctaW5zIGF1dG9tYXRpY2FsbHkgaGF2ZSB0aGUgRWNsaXBzZSBydW50aW1lIHBsdWctaW4gKDxjb2RlPm9yZy5lY2xpcHNlLmNvcmUucnVudGltZTwvY29kZT4pIAogICAgICBhZGRlZCB0byB0aGVpciBwcmVyZXF1aXNpdGUgbGlzdCBhcyB0aGUgZmlyc3QgcHJlcmVxdWlzaXRlLiBBbGwgaW1wb3J0cyAKICAgICAgb2YgdGhlIHJ1bnRpbWUgcGx1Zy1pbiBhcmUgaWdub3JlZC4gCiAgICAgIDxwPiBOb3RlIHRoYXQgcHJlcmVxdWlzaXRlIGNvbnN1bHRhdGlvbiBpcyB0cmFuc2l0aXZlLiBXaGVuIGxvY2F0aW5nIGEgY2xhc3MsIAogICAgICAgIGEgcHJlcmVxdWlzaXRlIHBsdWctaW4gd2lsbCBmb2xsb3cgdGhlIHNhbWUgKHRob3VnaCBvcHRpbWl6ZWQpIFAtUy1QIG1vZGVsLiAKICAgICAgICBTaW5jZSBhbGwgcGx1Zy1pbiBjbGFzc2xvYWRlcnMgaGF2ZSB0aGUgc2FtZSBwYXJlbnQsIHByZXJlcXVpc2l0ZSBsb2FkZXJzIAogICAgICAgIG5lZWQgbm90IGxvb2sgdGhlcmUuIFNpbWlsYXJseSwgcGx1Zy1pbnMgd2hpY2ggb2NjdXIgcmVwZWF0ZWRseSBpbiB0aGUgCiAgICAgICAgdHJhbnNpdGl2ZSBjbG9zdXJlIG9mIHRoZSBwcmVyZXF1aXNpdGUgZ3JhcGggYXJlIGNvbnN1bHRlZCBhdCBtb3N0IG9uY2UuIAogICAgICAgIEZpbmFsbHksIHByZXJlcXVpc2l0ZSByZS1leHBvcnRpbmcgcnVsZXMgYXJlIGZvbGxvd2VkIGFzIGRlc2NyaWJlZCBhYm92ZS48L3A+CiAgICA8L2RkPgogIDwvZGw+CjwvZGw+CjxoND5QbHVnLWluIERhdGE8L2g0PgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgCiAgICAgIAo8cD5UaGUgRWNsaXBzZSBQbGF0Zm9ybSBtYWtlcyBjZXJ0YWluIGFzc3VtcHRpb25zIGFib3V0IHRoZSBwaHlzaWNhbCBzdHJ1Y3R1cmUgCiAgb2YgYSBwbHVnLWluLiBFYWNoIHBsdWctaW4gb3IgZnJhZ21lbnQgaXMgdHlwaWNhbGx5IHN0b3JlZCBpbiBhIHNlcGFyYXRlIGRpcmVjdG9yeSAKICB1bmRlciBhIGRpcmVjdG9yeSBuYW1lZCA8c3Ryb25nPjxjb2RlPnBsdWdpbnM8L2NvZGU+PC9zdHJvbmc+IHVuZGVyIHlvdXIgRWNsaXBzZSAKICBpbnN0YWxsIGRpcmVjdG9yeS4gVGhlIG5hbWUgb2YgdGhpcyBkaXJlY3RvcnkgaXMgdXN1YWxseSB0aGUgc2FtZSBhcyB0aGUgcGx1Zy1pbidzIAogIGlkICh0aG91Z2ggaXQgbWF5IGhhdmUgdGhlIHZlcnNpb24gbnVtYmVyIGFwcGVuZGVkIHRvIGl0KS4gSW4gYWRkaXRpb24gdG8gdGhlIAogIDxjb2RlPnBsdWdpbi54bWw8L2NvZGU+IG9yIDxzdHJvbmc+PGNvZGU+ZnJhZ21lbnQueG1sPC9jb2RlPjwvc3Ryb25nPiBmaWxlLCAKICB0aGVyZSBtYXkgYmUgYW55IG51bWJlciBvZiBmb2xkZXJzIHVuZGVyIHRoZSBwbHVnLWluJ3Mgcm9vdCBmb2xkZXIuPC9wPgo8cD5TaW5jZSBFY2xpcHNlIGNhbiBiZSBydW4gb24gYSB3aWRlIHJhbmdlIG9mIG1hY2hpbmUgY29uZmlndXJhdGlvbnMgKGkuZS4sIG9wZXJhdGluZyAKICBzeXN0ZW0sIHdpbmRvdyBzeXN0ZW0pIGl0IG5lZWRzIGEgd2F5IG9mIG1hbmFnaW5nIGRpZmZlcmVudCBmb3JtcyBvZiB0aGUgc2FtZSAKICBkYXRhIChlLmcuLCBzaGFyZWQgbGlicmFyaWVzKS4gRWNsaXBzZSBwcm92aWRlcyBmb3VyIHZhcmlhYmxlcyBmb3IgdXNlIGluIGxpYnJhcnkgCiAgc3RhdGVtZW50cyB3aGljaCByZXNvbHZlIHRvIHBhcnRzIG9mIHRoZSBjdXJyZW50IG1hY2hpbmUgY29uZmlndXJhdGlvbi48L3A+CjxkbD4gCiAgPGRsPgogICAgPGR0PjxiPm9zPC9iPjwvZHQ+CiAgICA8ZGQ+VGhlIG9wZXJhdGluZyBzeXN0ZW0gb24gd2hpY2ggRWNsaXBzZSBpcyBjdXJyZW50bHkgcnVubmluZyAoZS5nLiwgd2luMzIsIAogICAgICBsaW51eCwgc29sYXJpcyk8L2RkPgogICAgPGR0PjxiPndzPC9iPjwvZHQ+CiAgICA8ZGQ+VGhlIHdpbmRvdyBzeXN0ZW0gYmVpbmcgdXNlZCBmb3IgdGhlIEVjbGlwc2UgVUkgKGUuZy4sIHdpbjMyLCBtb3RpZiwgZ3RrKTwvZGQ+CiAgICA8ZHQ+PGI+YXJjaDwvYj48L2R0PgogICAgPGRkPlRoZSB0eXBlIG9mIHByb2Nlc3NvciBpbiB0aGUgbWFjaGluZSAoZS5nLiwgeDg2LCBwcGMsIHNwYXJjKTwvZGQ+CiAgICA8ZHQ+PGI+bmw8L2I+PC9kdD4KICAgIDxkZD5UaGUgY3VycmVudCBsb2NhbGUgKGUuZy4sIGVuX0NBLCBqcF9KUCk8L2RkPgogIDwvZGw+CjwvZGw+CjxwPlNvLCBmb3IgZXhhbXBsZSwgaWYgeW91ciBwbHVnLWluIHVzZXMgd2luZG93aW5nIHN5c3RlbS1zcGVjaWZpYyBmZWF0dXJlcywgaXQgCiAgbWF5IGJlIG5lY2Vzc2FyeSB0byBwcm92aWRlIGEgZGlmZmVyZW50IGxpYnJhcnkgZm9yIGVhY2ggY29uZmlndXJhdGlvbi4gVXNpbmc8ZW0+IAogIDwvZW0+PHN0cm9uZz48Y29kZT4kd3MkLyZsdDtsaWJyYXJ5IG5hbWUmZ3Q7PC9jb2RlPjwvc3Ryb25nPiBpbiB5b3VyIHBsdWctaW4gCiAgbWFuaWZlc3QgZmlsZSBkaXJlY3RzIEVjbGlwc2UgdG8gbG9vayBmb3IgdGhlIGxpYnJhcnkgaW4gYSB3aW5kb3cgc3lzdGVtIGRpcmVjdG9yeSAKICB3aXRoIHRoZSBzYW1lIG5hbWUgYXMgdGhlIGN1cnJlbnQgd2luZG93IHN5c3RlbS6gVGhlIDxjb2RlPm9yZy5lY2xpcHNlLnN3dDwvY29kZT4gCiAgcGx1Zy1pbiB1c2VzIHRoaXMgbWVjaGFuaXNtIGFzIGZvbGxvd3M6PC9wPgo8YmxvY2txdW90ZT4KICA8cHJlPiAgJmx0O3J1bnRpbWUmZ3Q7CiAgICAmbHQ7bGlicmFyeSBuYW1lPSZxdW90OyR3cyQvc3d0LmphciZxdW90OyZndDsKICAgICAgJmx0O2V4cG9ydCBuYW1lPSZxdW90OyomcXVvdDsvJmd0OwogICAgJmx0Oy9saWJyYXJ5Jmd0OwogICZsdDsvcnVudGltZSZndDsKPC9wcmU+CjwvYmxvY2txdW90ZT4KPHA+VGhlIFNXVCBwbHVnLWluIGhhcyBhIHNlcmllcyBvZiBkaXJlY3RvcmllcyBvZiB0aGUgZm9ybSA8Y29kZT53cy8mbHQ7d2luZG93aW5nCiAgICAgc3lzdGVtJmd0Oy88L2NvZGU+KGUuZy4sIDxjb2RlPndzL3dpbjMyPC9jb2RlPiwgPGNvZGU+d3MvZ3RrPC9jb2RlPiwgPGNvZGU+d3MvbW90aWY8L2NvZGU+KS4KICAgICAgRWFjaCBvZiB0aGVzZSBkaXJlY3RvcmllcyBjb250YWlucyBhIGRpZmZlcmVudCB2ZXJzaW9uIG9mIDxjb2RlPnN3dC5qYXI8L2NvZGU+LgogICAgICAgSWYgeW91IGFyZSB3b3JraW5nIGluIGFuIEVjbGlwc2UgZW52aXJvbm1lbnQgaW4gYSB3aW4zMiB3aW5kb3dpbmcgc3lzdGVtLAogICAgICB0aGUgCiAgbGlicmFyeSBuYW1lIDxjb2RlPiR3cyQvc3d0LmphcjwvY29kZT4gd2lsbCBtYXRjaCA8Y29kZT53cy93aW4zMi9zd3QuamFyPC9jb2RlPi4KICAgTm90ZSB0aGF0IGluIHByYWN0aWNlIGFueSBnaXZlbiBFY2xpcHNlIGluc3RhbGwgd2lsbCBoYXZlIG9ubHkgb25lIDxjb2RlPnN3dC5qYXI8L2NvZGU+IAogICh0aGUgb25lIHRoYXQgbWF0Y2hlcyB0aGUgaW5zdGFsbCkuIFRoZSBqYXJzIGFyZSBhY3R1YWxseSBjb250cmlidXRlZCBieSB3aW5kb3cKICAgc3lzdGVtLXNwZWNpZmljIGZyYWdtZW50cy4gU2ltaWxhciBzdHJ1Y3R1cmVzIGFyZSBzZWVuIGluIHRoZSBSZXNvdXJjZXMsIGFuZAogIFVwZGF0ZSBwbHVnLWlucy4gVGhpcyBtZWNoYW5pc20gYWxsb3dzIHRoZSBjb21tb24gZWxlbWVudHMgdG8gYmUgcHV0CiAgIGluIHRoZSBwbHVnLWluIGFuZCBoYXZlIG9ubHkgdGhlIHdpbmRvdyBzeXN0ZW0sIG9wZXJhdGluZyBzeXN0ZW0sIC4uLiBzcGVjaWZpYwogIHBhcnRzIGluIGEgZnJhZ21lbnQuPC9wPgo8aDI+U3VtbWFyeTwvaDI+CjxwPlRoaXMgYXJ0aWNsZSBoYXMgc2V0IHRoZSBzdGFnZSBmb3IgcGx1Zy1pbnM6IGRlZmluaW5nIHdoYXQgdGhleSBhcmUsIHdoeSB0aGV5CiAgYXJlIGltcG9ydGFudCBhbmQgY29uY2VwdHMgcmVsYXRlZCB0byB0aGVtLiBNb3JlIGRldGFpbCBvbiB0aGUgZXhhY3QgZm9ybSBvZgogIDxhIGhyZWY9Imh0dHA6Ly9oZWxwLmVjbGlwc2Uub3JnL2hlbHAyMS90b3BpYy9vcmcuZWNsaXBzZS5wbGF0Zm9ybS5kb2MuaXN2L3JlZmVyZW5jZS9taXNjL3BsdWdpbl9tYW5pZmVzdC5odG1sIj5wbHVnLWluL2ZyYWdtZW50CiAgbWFya3VwPC9hPiBjYW4gYmUgZm91bmQgaW4gdGhlIEVjbGlwc2UgaGVscCBzeXN0ZW0uIEVjbGlwc2UgcGx1Zy1pbiBkZXZlbG9wZXJzCiAgYXJlIGVuY291cmFnZWQgdG8gbG9vayBhdCBleGlzdGluZyBwbHVnLWlucyBmb3IgZnVydGhlciBleGFtcGxlcy48L3A+CjxkaXYgY2xhc3M9U2VjdGlvbjE+CiAgPHA+PGEgaHJlZj0iaGdsZWdhbC5odG0iPjxpbWcgc3JjPSIuLi8uLi8uLi9pbWFnZXMvbmdpYm1jcHkuZ2lmIiBhbHQ9IkNvcHlyaWdodCBJQk0gQ29ycG9yYXRpb24gYW5kIG90aGVycyAyMDAwLCAyMDAzLiIgYm9yZGVyPSIwIiB3aWR0aD0iMjUwIiBoZWlnaHQ9IjEyIj48L2E+PC9wPgo8L2Rpdj4KPHA+Jm5ic3A7PC9wPgogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAKPC9ib2R5Pgo8L2h0bWw+Cg==