PGh0bWw+Cgo8aGVhZD4KPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9d2luZG93cy0xMjUyIj4KCgo8dGl0bGU+UHJlZmVyZW5jZXMgYW5kIFByb3BlcnRpZXMgaW4gdGhlIEVjbGlwc2UgV29ya2JlbmNoIFVJPC90aXRsZT4KPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiB0eXBlPSJ0ZXh0L2NzcyIgaHJlZj0iZGVmYXVsdF9zdHlsZS5jc3MiPgo8L2hlYWQ+Cgo8Ym9keT4KPERJViBhbGlnbj1yaWdodD4mbmJzcDsgPEZPTlQgZmFjZT0iVGltZXMgTmV3IFJvbWFuLCBUaW1lcywgc2VyaWYiIApzaXplPTI+Q29weXJpZ2h0IKkgMjAwMSBPYmplY3QgVGVjaG5vbG9neSBJbnRlcm5hdGlvbmFsLCBJbmMuPC9GT05UPiA8L0RJVj4KPFRBQkxFIGJvcmRlcj0wIGNlbGxQYWRkaW5nPTIgY2VsbFNwYWNpbmc9MCB3aWR0aD0iMTAwJSI+CiAgPFRCT0RZPgogIDxUUj4KICAgIDxURCBhbGlnbj1sZWZ0IGJnQ29sb3I9IzAwODBjMCBjb2xTcGFuPTIgdkFsaWduPXRvcD48Qj48Rk9OVCAKICAgICAgZmFjZT1BcmlhbCxIZWx2ZXRpY2E+PEZPTlQgY29sb3I9I2ZmZmZmZj4mbmJzcDtFY2xpcHNlIENvcm5lciAKICAgICAgQXJ0aWNsZTwvRk9OVD48L0ZPTlQ+PC9CPjwvVEQ+PC9UUj48L1RCT0RZPjwvVEFCTEU+CjxIMT48aW1nIGFsaWduPWNlbnRlciAKc3JjPSJJZGVhLmpwZyIgd2lkdGg9IjEyMCIgaGVpZ2h0PSI4NiI+CjxjZW50ZXI+UHJlZmVyZW5jZXMgaW4gdGhlIEVjbGlwc2UgV29ya2JlbmNoIFVJPC9jZW50ZXI+PC9IMT4KPGJsb2NrcXVvdGU+CjxiPlN1bW1hcnk8L2I+PGJyPgpJbiB0aGUgRWNsaXBzZSBQbGF0Zm9ybSBwbHVnLWluIGRldmVsb3BlcnMgZGVmaW5lIHByZWZlcmVuY2UgcGFnZXMgZm9yIHRoZWlyIHBsdWctaW5zCmZvciB1c2UgaW4gdGhlIFdvcmtiZW5jaCBQcmVmZXJlbmNlcyBEaWFsb2cuIFRoaXMgYXJ0aWNsZSBleHBsYWlucyB3aGVuIHRvIHVzZSBhCnByZWZlcmVuY2UgYW5kIHNvbWUgb2YgdGhlIGZlYXR1cmVzIHRoZSBFY2xpcHNlIFBsYXRmb3JtIHByb3ZpZGVzIHRvIHN1cHBvcnQKcHJlZmVyZW5jZXMuCjxwPjxiPkJ5IFRvZCBDcmVhc2V5LCBPVEk8YnI+CiAgICA8L2I+IERlY2VtYmVyIDE1LCAyMDAxPC9wPgo8L2Jsb2NrcXVvdGU+CjxIUiB3aWR0aD0iMTAwJSI+Cgo8aDI+SW50cm9kdWN0aW9uPC9oMj4KPHA+VGhlIEVjbGlwc2UgUGxhdGZvcm0gaGFzIHN1cHBvcnQgZm9yIHVzZXIgZGVmaW5lZCBwcmVmZXJlbmNlcyB0aGF0IGFyZQpwZXJzaXN0ZWQgYWxvbmcgd2l0aCB0aGUgd29ya2JlbmNoLiBUaGlzIGFydGljbGUgd2lsbCBkaXNjdXNzIHdoYXQgdHlwZSBvZiBkYXRhCnNob3VsZCBiZSBzdG9yZWQgYXMgYSBwcmVmZXJlbmNlIGFuZCB3aWxsIHNob3cgaG93IHRvIGRldmVsb3AgYW5kIHJlZ2lzdGVyIGEKdXNlciBpbnRlcmZhY2UgdG8gYWxsb3cgdGhlIHVzZXIgdG8gc2V0IHRoZXNlIHByZWZlcmVuY2VzLiBJdCB3aWxsIGFsc28gY292ZXIKaG93IHRvIGluaXRpYWxpemUgYW5kIHJldHJpZXZlIHByZWZlcmVuY2VzIGZvciB1c2UgYnkgb3RoZXIgb3RoZXIgcGx1Zy1pbnMgdGhhdAp1c2UgeW91ciBwbHVnLWluLiBUaGlzIGZ1bmN0aW9uYWxpdHkgd2lsbCBiZSBzaG93biB1c2luZyBhbiBleGFtcGxlIHRoYXQKc2VhcmNoZXMgZG9jdW1lbnRzIGZvciBiYWQgd29yZHMuIFdlIHdpbGwgc2V0IG91ciBwcmVmZXJlbmNlcyBmb3IgdGhpcyB0b29sCnVzaW5nIHR3byBwcmVmZXJlbmNlIHBhZ2VzLCBvbmUgc2ltcGxlIG9uZSB0byBzZXQgYSBoaWdobGlnaHQgY29sb3IgYW5kIG9uZSBtb3JlCmNvbXBsZXggb25lIHRvIHNldCB0aGUgbGlzdCBvZiB3b3Jkcy4KPC9wPgo8aDI+V2hlbiB0byBVc2UgYSBQcmVmZXJlbmNlCjwvaDI+CjxwPkEgcHJlZmVyZW5jZSBpcyBkYXRhIHRoYXQgaXMgcGVyc2lzdGVkIGJldHdlZW4gd29ya2JlbmNoIHNlc3Npb25zIHRvIGFsbG93CnRoZSB1c2VyIHRvIGtlZXAgdGhlIHN0YXRlIG9mIGEgcGx1Zy1pbiBjb25zaXN0ZW50IGJldHdlZW4gRWNsaXBzZSBzZXNzaW9ucy4gVHlwaWNhbCBwcmVmZXJlbmNlcyBhcmUKZGVmYXVsdCB2YWx1ZXMgZm9yIG5ldyBpbnN0YW5jZXMsIGNvbG9ycyBmb3IgZWRpdG9ycyBhbmQgcGF0aHMsIG9yIHByb2Nlc3NpbmcKaW5mb3JtYXRpb24gZm9yIG9wZXJhdGlvbnMgcGVyZm9ybWVkIG9uIGRhdGEgKHN1Y2ggYXMgYSBidWlsZCBwYXRoIGZvciBhIEphdmEmdHJhZGU7CmZpbGUpLgo8L3A+CjxwPlByZWZlcmVuY2VzIGFyZSBub3QgaW50ZW5kZWQgdG8gcmVmZXJlbmNlIGFueSByZXNvdXJjZSBjdXJyZW50bHkgZGVmaW5lZCBpbgp0aGUgd29ya3NwYWNlIGFuZCBpbnN0ZWFkIHNob3VsZCBiZSB1c2VkIGZvciBlZGl0b3JzLCB2aWV3cyBvciBvdGhlciBvYmplY3RzIHRoYXQKcGVyZm9ybSBvcGVyYXRpb25zIG9uIGEgcmVzb3VyY2UuIERhdGEgcGVyc2lzdGVkIG9uIGEgcmVzb3VyY2UgaW5zdGFuY2UgaXMgYmV0dGVyIHN1aXRlZCB0byBiZQphIHByb3BlcnR5IHdoaWNoIHdpbGwgYmUgZGlzY3Vzc2VkIGluIGEgbGF0ZXIgYXJ0aWNsZS4KPC9wPgo8cD5BIHByZWZlcmVuY2UgY2FuIGJlIG1hZGUgYXZhaWxhYmxlIHRvIGFueSBwbHVnLWluIHRoYXQgaGFzIHlvdXIgcGx1Zy1pbiBhcyBhCnByZXJlcXVpc2l0ZS4gVGhlIHVzdWFsIHdheSB0byBkbyB0aGF0IGlzIHRvIHByb3ZpZGUgQVBJIG9uIHlvdXIgcGx1Zy1pbiB0aGF0CmFsbG93cyBmb3IgYWNjZXNzIHRvIHRoZSBwcmVmZXJlbmNlcyB5b3Ugd2FudCB0byBtYWtlIGF2YWlsYWJsZS4gVGhlIHZhbHVlcyBvZgp0aGVzZSBwcmVmZXJlbmNlcyBhcmUgc3RvcmVkIGluIHRoZSAubWV0YWRhdGEvLnBsdWdpbnMgZGlyZWN0b3J5IG9mIHRoZQp3b3JrYmVuY2ggb24gYSBwZXIgcGx1Zy1pbiBiYXNpcy4gV2UgZGVtb25zdHJhdGUKaG93IHRvIGRvIHRoaXMgYmVsb3cuCjwvcD4KPGgyPlRoZSBQcmVmZXJlbmNlIFN0b3JlIGFuZCB0aGUgUGx1Zy1pbjwvaDI+CjxwPkV2ZXJ5IFVJIHBsdWctaW4gaGFzIGl0J3Mgb3duIHByZWZlcmVuY2Ugc3RvcmUgcHJvdmlkZWQgYnkgdGhlIHdvcmtiZW5jaC4gRm9yIAogIHRoaXMgZXhhbXBsZSB3ZSB3aWxsIGRlZmluZSBhIHBsdWctaW4gYW5kIHVzZSBpdHMgcHJlZmVyZW5jZSBzdG9yZSBmb3Igb3VyIHByZWZlcmVuY2VzLiAKICBBcyB3ZSBhcmUgZ29pbmcgdG8gdXNlIHRoaXMgcGx1Zy1pbiB3aXRoaW4gdGhlIFVJIHdlIGRlZmluZSBpdCBhcyBhIHN1YmNsYXNzIAogIG9mIEFic3RyYWN0VUlQbHVnaW4uIE91ciBjb25zdHJ1Y3RvciAoc2VlIDxpbWcgYm9yZGVyPSIwIiBzcmM9InRhZ18yLmdpZiIgd2lkdGg9IjI0IiBoZWlnaHQ9IjEzIj4pIAogIHdpbGwgY3JlYXRlIGEgc2luZ2xldG9uIHRvIGFsbG93IGVhc3kgYWNjZXNzIHRvIHRoZSBwbHVnLWluIGluc3RhbmNlIGluIHRoZSAKICB3b3JrYmVuY2guIFdlIGFsc28gaW1wbGVtZW50IHRoZSBtZXRob2QgaW5pdGlhbGl6ZURlZmF1bHRQcmVmZXJlbmNlcygpIHRvIHNldCAKICB1cCBvdXIgZGVmYXVsdCB2YWx1ZXMgZm9yIG91ciB0d28gcHJlZmVyZW5jZXMuIFdlIGFyZSBkZWZpbmluZyBhIHByZWZlcmVuY2UgCiAgZm9yIHRoZSBiYWQgd29yZHMgYW5kIGEgcHJlZmVyZW5jZSBmb3IgdGhlIGNvbG9yIG9mIHRoZSBoaWdobGlnaHQuIEVhY2ggcHJlZmVyZW5jZSAKICB2YWx1ZSBpcyBsb29rZWQgdXAgdXNpbmcgYSBnaXZlbiBrZXkuIEluIHRoZSBjb2RlIGJlbG93IHRoZSBrZXlzIHdlIGFyZSB1c2luZyAKICBhcmUgZGVmaW5lZCBieSB0aGUgY29uc3RhbnRzIGluIDxpbWcgc3JjPSJ0YWdfMS5naWYiIHdpZHRoPSIyNCIgaGVpZ2h0PSIxMyI+LiAKPC9wPgo8cD5UaGUgZGVmYXVsdCB2YWx1ZSBzaG91bGQgYmUgc2V0IGZvciBhbGwgcHJlZmVyZW5jZXMgdG8gYmUgc3VyZSB0aGF0IHRoZXJlIGlzIAogIGEgdmFsdWUgdG8gdXNlIGF0IGFsbCB0aW1lcy4gQSBkZWZhdWx0IHZhbHVlIGFsc28gZW5zdXJlcyB0aGF0IHRoZSBVSSBjYW4gcHJvdmlkZSAKICBhIHdheSB0byByZXNldCBhIHByZWZlcmVuY2UgdmFsdWUgYmFjayB0byBhIHJlYXNvbmFibGUgaW5pdGlhbCBzZXR0aW5nIHZpYSB0aGUgCiAgUmVzdG9yZSBEZWZhdWx0cyBidXR0b24uVGhlIGRlZmF1bHQgdmFsdWUgb2YgdGhlIHByZWZlcmVuY2Ugc2hvdWxkIGJlIGluaXRpYWxpemVkIAogIGluIHRoZSBwbHVnLWluIHNvIHRoYXQgaXQgaXMgc2V0IGJlZm9yZSBhbnkgb2YgdGhlIFVJIGlzIGNyZWF0ZWQuJm5ic3A7IDwvcD4KPHA+IElBYnN0cmFjdFdvcmtiZW5jaFBsdWdpbiBkZWZpbmVzIGEgbWV0aG9kIGNhbGxlZCBpbml0aWFsaXplRGVmYXVsdFByZWZlcmVuY2VzKElQcmVmZXJlbmNlU3RvcmUpIAogIHdoaWNoIGlzIGNhbGxlZCB3aGVuIHRoZSBwcmVmZXJlbmNlIHN0b3JlIGlzIGNyZWF0ZWQgdGhlIGZpcnN0IHRpbWUuIEluIHRoaXMgCiAgbWV0aG9kIChzZWUgPGltZyBib3JkZXI9IjAiIHNyYz0idGFnXzMuZ2lmIiB3aWR0aD0iMjQiIGhlaWdodD0iMTMiPikgeW91IHNob3VsZCAKICBzZXQgdGhlIGRlZmF1bHQgdmFsdWUgZm9yIGFsbCB2YWx1ZXMgdGhhdCB5b3Ugd2lsbCBiZSB1c2luZyB0aGUgcHJlZmVyZW5jZSBzdG9yZSAKICBmb3IuIFdlIHNldCBhIGRlZmF1bHQgY29sb3IgdXNpbmcgdGhlIGhlbHBlciBtZXRob2RzIGluIHRoZSBQcmVmZXJlbmNlQ29udmVydGVyIAogIHdoaWNoIGFsbG93cyB0aGUgcGx1Zy1pbiBkZXZlbG9wZXIgdG8gc2V0IGFuZCBnZXQgdmFsdWVzIGZvciBhIHByZWZlcmVuY2Ugb2YgCiAgY29tbW9ubHkgc3RvcmVkIHR5cGVzIGxpa2UgRm9udERhdGEsIFBvaW50IGV0Yy4gVGhpcyBBUEkgaXMgcHJvdmlkZWQgYmVjYXVzZSAKICBwcmVmZXJlbmNlcyBhcmUgc3RvcmVkIGFuZCByZXRyaWV2ZWQgYXMgU3RyaW5ncyBpbiBhIGh1bWFuIHJlYWRhYmxlIGZvcm1hdCBpbiAKICBvcmRlciB0byBsZXZlcmFnZSB0aGUgamF2YSBwcm9wZXJ0aWVzIG1lY2hhbmlzbS4mbmJzcDsgT3VyIG1vcmUgY29tcGxleCBiYWQgCiAgd29yZHMgcHJlZmVyZW5jZSBpcyBpbml0aWFsaXplZCB1c2luZyBhIHNldCBvZiBwcmVzZWxlY3RlZCBiYWQgd29yZHMgZGVmaW5lZCAKICBpbiB0aGUgZm9ybWF0IHdlIGFyZSBnb2luZyB0byBzdG9yZSB0aGVtIGluIGFzIHdlIGRvIG5vdCBoYXZlIEFQSSBvbiB0aGUgUHJlZmVyZW5jZUNvbnZlcnRvciAKICB0byBzdG9yZSBvciByZXRyZWl2ZSBhcnJheXMgb2YgU3RyaW5ncy48L3A+CjxwcmU+Q29sb3IgY29sb3I9IERpc3BsYXkuZ2V0RGVmYXVsdCgpLmdldFN5c3RlbUNvbG9yKFNXVC5DT0xPUl9CTFVFKTsKUHJlZmVyZW5jZUNvbnZlcnRlci5zZXREZWZhdWx0KHN0b3JlLCBISUdITElHSFRfUFJFRkVSRU5DRSwgY29sb3IuZ2V0UkdCKCkpOzwvcHJlPgo8cHJlPnB1YmxpYyBjbGFzcyBCYWRXb3JkQ2hlY2tlclBsdWdpbiBleHRlbmRzIEFic3RyYWN0VUlQbHVnaW4gewoJLy9UaGUgc2hhcmVkIGluc3RhbmNlLgoJcHJpdmF0ZSBzdGF0aWMgQmFkV29yZENoZWNrZXJQbHVnaW4gcGx1Z2luOwoKCS8vVGhlIGlkZW50aWZpZXJzIGZvciB0aGUgcHJlZmVyZW5jZXMJCjxpbWcgYm9yZGVyPSIwIiBzcmM9InRhZ18xLmdpZiIgd2lkdGg9IjI0IiBoZWlnaHQ9IjEzIj4JcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgQkFEX1dPUkRTX1BSRUZFUkVOQ0UgPQoJCSZxdW90O29yZy5lY2xpcHNlLnVpLmFydGljbGVzLmJhZHdvcmRjaGVja2VyLmJhZHdvcmRzJnF1b3Q7OwoJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgSElHSExJR0hUX1BSRUZFUkVOQ0UgPQoJCSZxdW90O29yZy5lY2xpcHNlLnVpLmFydGljbGVzLmJhZHdvcmRjaGVja2VyLmhpZ2hsaWdodCZxdW90OzsKCgkvL1RoZSBkZWZhdWx0IHZhbHVlcyBmb3IgdGhlIHByZWZlcmVuY2VzCglwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBERUZBVUxUX0JBRF9XT1JEUyA9ICZxdW90O2J1Zztib2d1cztoYWNrOyZxdW90OzsKCXB1YmxpYyBzdGF0aWMgZmluYWwgaW50IERFRkFVTFRfSElHSExJR0hUID0gU1dULkNPTE9SX0JMVUU7CgoJLyoqCgkgKiBUaGUgY29uc3RydWN0b3IuCgkgKi8KCXB1YmxpYyBCYWRXb3JkQ2hlY2tlclBsdWdpbihJUGx1Z2luRGVzY3JpcHRvciBkZXNjcmlwdG9yKSB7CgkJc3VwZXIoZGVzY3JpcHRvcik7CjxpbWcgYm9yZGVyPSIwIiBzcmM9InRhZ18yLmdpZiIgd2lkdGg9IjI0IiBoZWlnaHQ9IjEzIj4JCXBsdWdpbiA9IHRoaXM7Cgl9CgoJLyoqCgkgKiBSZXR1cm5zIHRoZSBzaGFyZWQgaW5zdGFuY2UuCgkgKi8KCXB1YmxpYyBzdGF0aWMgQmFkV29yZENoZWNrZXJQbHVnaW4gZ2V0RGVmYXVsdCgpIHsKCQlyZXR1cm4gcGx1Z2luOwoJfQoKCS8qKiAKCSAqIEluaXRpYWxpemVzIGEgcHJlZmVyZW5jZSBzdG9yZSB3aXRoIGRlZmF1bHQgcHJlZmVyZW5jZSB2YWx1ZXMgCgkgKiBmb3IgdGhpcyBwbHVnLWluLgoJICogQHBhcmFtIHN0b3JlIHRoZSBwcmVmZXJlbmNlIHN0b3JlIHRvIGZpbGwKCSAqLwoJcHJvdGVjdGVkIHZvaWQgaW5pdGlhbGl6ZURlZmF1bHRQcmVmZXJlbmNlcyhJUHJlZmVyZW5jZVN0b3JlIHN0b3JlKSB7CjxpbWcgYm9yZGVyPSIwIiBzcmM9InRhZ18zLmdpZiIgd2lkdGg9IjI0IiBoZWlnaHQ9IjEzIj4JCXN0b3JlLnNldERlZmF1bHQoQkFEX1dPUkRTX1BSRUZFUkVOQ0UsIERFRkFVTFRfQkFEX1dPUkRTKTsKCQlDb2xvciBjb2xvcj0gRGlzcGxheS5nZXREZWZhdWx0KCkuZ2V0U3lzdGVtQ29sb3IoREVGQVVMVF9ISUdITElHSFQpOwoJCVByZWZlcmVuY2VDb252ZXJ0ZXIuc2V0RGVmYXVsdChzdG9yZSwgIEhJR0hMSUdIVF9QUkVGRVJFTkNFLCBjb2xvci5nZXRSR0IoKSk7CgoJfQp9PC9wcmU+CjxoMj5EZWZpbmluZyBQcmVmZXJlbmNlIFBhZ2VzIGluIHBsdWdpbi54bWw8L2gyPgo8cD5Ob3cgdGhhdCB3ZSBoYXZlIGRlZmluZWQgdGhlIHByZWZlcmVuY2Ugd2Ugd2FudCB0byBwcm92aWRlIGEgd2F5IGZvciB0aGUgdXNlcgp0byBzZXQgdGhlIHByZWZlcmVuY2UgdmFsdWUuIFByZWZlcmVuY2UgcGFnZXMgZm9yIHRoZSB3b3JrYmVuY2ggY2FuIGJlIGZvdW5kIGluCnRoZSBwcmVmZXJlbmNlcyBkaWFsb2cuIFRoZSBwcmVmZXJlbmNlcyBkaWFsb2cgaXMgYWNjZXNzaWJsZSB2aWEgdGhlIFdpbmRvdy0mZ3Q7UHJlZmVyZW5jZXMKbWVudSBncm91cC4gUGx1Zy1pbiBkZXZlbG9wZXJzIHNob3VsZCBhZGQgdGhlaXIgcHJlZmVyZW5jZSBwYWdlcyB0byB0aGlzIGRpYWxvZyB1c2luZyB0aGUgcGx1Z2luLnhtbCBvZiB0aGVpcgpwbHVnLWluIGluIG9yZGVyIHRvIG1haW50YWluIGEgY29uc2lzdGVudCBsb29rIGFuZCBmZWVsIHdpdGggb3RoZXIgRWNsaXBzZQpwbHVnLWlucy4gVGhlIGRlZmluaXRpb24gb2YgdGhlIHByZWZlcmVuY2UgcGFnZXMgd2l0aGluIHBsdWdpbi54bWwgbG9va3MgbGlrZQp0aGlzOgo8L3A+CjxwcmU+Jmx0O2V4dGVuc2lvbiBwb2ludD0mcXVvdDtvcmcuZWNsaXBzZS51aS5wcmVmZXJlbmNlUGFnZXMmcXVvdDsmZ3Q7CiAJJmx0O3BhZ2UgaWQ9JnF1b3Q7b3JnLmVjbGlwc2UudWkuYXJ0aWNsZXMuQmFkV29yZHNQcmVmZXJlbmNlJnF1b3Q7CjxpbWcgYm9yZGVyPSIwIiBzcmM9InRhZ18xLmdpZiIgd2lkdGg9IjI0IiBoZWlnaHQ9IjEzIj4gCQluYW1lPSZxdW90O0JhZCBXb3JkcyZxdW90Owo8aW1nIGJvcmRlcj0iMCIgc3JjPSJ0YWdfMi5naWYiIHdpZHRoPSIyNCIgaGVpZ2h0PSIxMyI+ICAgIAkJY2xhc3M9JnF1b3Q7b3JnLmVjbGlwc2UudWkuYXJ0aWNsZXMuYmFkd29yZGNoZWNrZXIuQmFkV29yZHNQcmVmZXJlbmNlUGFnZSZxdW90OyZndDsKICAgCSZsdDsvcGFnZSZndDsKICAgCQogCSZsdDtwYWdlIGlkPSZxdW90O29yZy5lY2xpcHNlLnVpLmFydGljbGVzLkJhZFdvcmRzQ29sb3JQcmVmZXJlbmNlJnF1b3Q7CiAgCSAgICAgIAluYW1lPSZxdW90O0NvbG9ycyZxdW90OwoJICAgICAgCWNsYXNzPSZxdW90O29yZy5lY2xpcHNlLnVpLmFydGljbGVzLmJhZHdvcmRjaGVja2VyLkJhZFdvcmRzQ29sb3JQcmVmZXJlbmNlUGFnZSZxdW90Owo8aW1nIGJvcmRlcj0iMCIgc3JjPSJ0YWdfMy5naWYiIHdpZHRoPSIyNCIgaGVpZ2h0PSIxMyI+CQljYXRlZ29yeT0mcXVvdDtvcmcuZWNsaXBzZS51aS5hcnRpY2xlcy5CYWRXb3Jkc1ByZWZlcmVuY2UmcXVvdDsmZ3Q7CiAgIAkmbHQ7L3BhZ2UmZ3Q7CiZsdDsvZXh0ZW5zaW9uJmd0OzwvcHJlPgo8cD5UaGUgZGVmaW5pdGlvbiBhYm92ZSBzZXRzIHRoZSBuYW1lICg8aW1nIGJvcmRlcj0iMCIgc3JjPSJ0YWdfMS5naWYiIHdpZHRoPSIyNCIgaGVpZ2h0PSIxMyI+KQpvZiB0aGUgcHJlZmVyZW5jZSBwYWdlIGZvciB1c2UgaW4gdGhlIGxpc3QKb2YgcGFnZXMgaW4gdGhlIHByZWZlcmVuY2UgZGlhbG9nIGFuZCBhbHNvIHNwZWNpZmllcyB0aGUgY2xhc3MoPGltZyBib3JkZXI9IjAiIHNyYz0idGFnXzIuZ2lmIiB3aWR0aD0iMjQiIGhlaWdodD0iMTMiPikgdG8gYmUKaW5zdGFudGlhdGVkIGZvciBjcmVhdGluZyB0aGUgcHJlZmVyZW5jZSBwYWdlLiBUaGlzIGNsYXNzIG11c3QgY29uZm9ybSB0bwpJV29ya2JlbmNoUHJlZmVyZW5jZVBhZ2UuPC9wPgo8cD5JbiB0aGUgc2Vjb25kIGRlZmluaXRpb24gdGhlcmUgaXMgYSBjYXRlZ29yeSAoPGltZyBib3JkZXI9IjAiIHNyYz0idGFnXzMuZ2lmIiB3aWR0aD0iMjQiIGhlaWdodD0iMTMiPikKdGFnIHdoaWNoIGlzIHVzZWQgdG8gbWFrZSBvbmUKcGFnZSB0aGUgY2hpbGQgb2YgYW5vdGhlciBpbiB0aGUgbGlzdCBpbiB0aGUgcHJlZmVyZW5jZXMgZGlhbG9nLiBQcmVmZXJlbmNlCnBhZ2VzIGNhbiBiZSBzdG9yZWQgYXMgdGhlIGNoaWxkcmVuIG9mIG90aGVyIHBhZ2VzLiBUaGlzIGlzIHVzZWZ1bApmb3Iga2VlcGluZyBhIHNlcmllcyBvZiBwYWdlcyB0b2dldGhlciB0aGF0IGFyZSByZWxhdGVkIHRvIGVhY2ggb3RoZXIgYW5kIGFsc28KcmVkdWNlcyB0aGUgY2x1dHRlciBpbiB0aGUgd29ya2JlbmNoIHByZWZlcmVuY2VzIHBhZ2UuIEEgcGFnZSBjYW4gYmUgbWFkZSB0aGUKY2hpbGQgb2YgYW5vdGhlciBwYWdlIGJ5IHNldHRpbmcgdGhlIGlkIG9mIHRoZSBwYXJlbnQgcGFnZSBhcyB0aGUgdmFsdWUgb2YgdGhlCmNhdGVnb3J5IGZpZWxkIGluIHRoZSBwbHVnaW4ueG1sLiBBIHBhZ2Ugd2l0aCBubyBwYXJlbnQgaXMgZGlzcGxheWVkIGFzIGEgY2hpbGQKd2l0aCBubyByb290LjwvcD4KPHA+V2l0aCB0aGUgYWJvdmUgZGVjbGFyYXRpb25zIGluIG91ciBwbHVnaW4ueG1sIHRoZSBsaXN0IG9mIHByZWZlcmVuY2UgcGFnZXMKc2hvd24gaW4gdGhlIHByZWZlcmVuY2UgZGlhbG9nIHdpbGwgbG9vayBsaWtlOjwvcD4KPHAgYWxpZ249ImNlbnRlciI+PGltZyBib3JkZXI9IjAiIHNyYz0idHJlZS5qcGciIHdpZHRoPSIxNzkiIGhlaWdodD0iMjg0Ij48L3A+CjxwIGFsaWduPSJjZW50ZXIiPlRoZSBQcmVmZXJlbmNlIERpYWxvZyBUcmVlIHdpdGggdGhlIEJhZCBXb3JkcyBhbmQgQ29sb3IgUGFnZQpBZGRlZDwvcD4KPGgyPlRoZSBDb2xvciBQcmVmZXJlbmNlIFBhZ2UKPC9oMj4KPHA+VGhlIGNvbG9yIHByZWZlcmVuY2UgcGFnZSBpcyBhbiBleGFtcGxlIG9mIGEgc2ltcGxlIHBhZ2UgdGhhdCB1c2VzIGEgc2luZ2xlCkpGYWNlIGZpZWxkIGVkaXRvciB0byBtYW5hZ2UgaXRzIHZhbHVlcy4gSW5pdGlhbGx5IGEgcHJlZmVyZW5jZSBwYWdlIGNsYXNzIGlzCmRlZmluZWQuJm5ic3A7IEFsbApjbGFzc2VzIHVzZWQgaW4gdGhlIHByZWZlcmVuY2UgZGlhbG9nIG11c3QgY29uZm9ybSB0byBJV29ya2JlbmNoUHJlZmVyZW5jZVBhZ2UuCkVjbGlwc2UgaW5jbHVkZXMgdGhlIGNsYXNzIFByZWZlcmVuY2VQYWdlIHdoaWNoIGltcGxlbWVudHMgbW9zdCBvZiB0aGUgbmVjZXNzYXJ5IEFQSQpmb3IgYSBwcmVmZXJlbmNlIHBhZ2UuIFRoZSBjbGFzcyBkZWZpbml0aW9uIGZvciBvdXIgcHJlZmVyZW5jZSBwYWdlIGlzOjwvcD4KPHByZT5CYWRXb3Jkc0NvbG9yUHJlZmVyZW5jZVBhZ2UKCWV4dGVuZHMgUHJlZmVyZW5jZVBhZ2UKCWltcGxlbWVudHMgSVdvcmtiZW5jaFByZWZlcmVuY2VQYWdlPC9wcmU+CjxwPk9uY2Ugd2UgaGF2ZSBkZWZpbmVkIHRoZSBwYWdlIHdlIHdhbnQgdG8gaW5pdGlhbGl6ZSBpdC4mbmJzcDsgSVdvcmtiZW5jaFByZWZlcmVuY2VQYWdlCnNwZWNpZmllcyBhIG1lc3NhZ2UgaW5pdChJV29ya2JlbmNoKSBmb3IgdGhpcyBwdXJwb3NlLiBXZSB3aWxsIG5vdCB1c2UgdGhlIFdvcmtiZW5jaAphcmd1bWVudCBmb3IgdGhpcyBwYWdlLiBPdXIgaW1wbGVtZW50YXRpb24gb25seSBzZXRzCnRoZSBwcmVmZXJlbmNlIHN0b3JlIGZvciB0aGUgcGFnZS48L3A+CjxwcmU+cHVibGljIHZvaWQgaW5pdChJV29ya2JlbmNoIHdvcmtiZW5jaCkgewoJLy9Jbml0aWFsaXplIHRoZSBwcmVmZXJlbmNlIHN0b3JlIHdlIHdpc2ggdG8gdXNlCglzZXRQcmVmZXJlbmNlU3RvcmUoQmFkV29yZENoZWNrZXJQbHVnaW4uZ2V0RGVmYXVsdCgpLmdldFByZWZlcmVuY2VTdG9yZSgpKTsKfTwvcHJlPgo8cD5UaGUgb3RoZXIgcmVxdWlyZWQgbWV0aG9kIHdlIG11c3QgaW1wbGVtZW50IGlzIGNyZWF0ZUNvbnRlbnRzKCkuCkFsbCB3ZSBhcmUgZ29pbmcgdG8gZG8gaXMgdXNlIGEgQ29sb3JGaWVsZEVkaXRvcgp0byBzZXQgb3VyIHByZWZlcmVuY2UuIEl0IGlzIGFsc28gc3VnZ2VzdGVkIHRoYXQgcGVyZm9ybURlZmF1bHRzIGlzCmltcGxlbWVudGVkIHNvIHRoYXQgdGhlIGN1cnJlbnQgc3RhdGUgY2FuIGJlIHJlc2V0IHRvIHRoZSBkZWZhdWx0cyBkZWZpbmVkIGluCnRoZSBwbHVnLWluLiBXZSBhbHNvIG5lZWQgdG8gaW1wbGVtZW50IHBlcmZvcm1PSyBzbyB0aGF0IHRoZSBzZXR0aW5ncyBkZWZpbmVkIGJ5IHRoZSB1c2VyIGFyZQpzdG9yZWQgaW4gdGhlIHByZWZlcmVuY2Ugc3RvcmUgZm9yIG91ciBwbHVnLWluLiBPdXIKaW1wbGVtZW50YXRpb24gaXMgc2ltcGxlIGFzIHRoZSBDb2xvckZpZWxkRWRpdG9yIGhhcyB0aGUgY29kZSB0byBsb2FkIGRlZmF1bHRzCmFuZCBzdG9yZSB0aGUgcmVzdWx0cyBvZiBhbiBhcHBseSBmb3IgYSBwcmVmZXJlbmNlIGFscmVhZHkgZGVmaW5lZCBhbmQgcGVyZm9ybU9LCmFuZCBwZXJmb3JtRGVmYXVsdHMgY2FuIGNhbGwgdGhlIGNvcnJlc3BvbmRpbmcgbWV0aG9kcyBvbiBDb2xvckZpZWxkRWRpdG9yLjwvcD4KPHByZT4vKioKICogUGVyZm9ybXMgc3BlY2lhbCBwcm9jZXNzaW5nIHdoZW4gdGhpcyBwYWdlJ3MgUmVzdG9yZSBEZWZhdWx0cyBidXR0b24gaGFzIAogKiBiZWVuIHByZXNzZWQuCiAqIFNldHMgdGhlIGNvbnRlbnRzIG9mIHRoZSBjb2xvciBmaWVsZCB0byB0aGUgZGVmYXVsdCB2YWx1ZSBpbiB0aGUgcHJlZmVyZW5jZQogKiBzdG9yZS4KICovCnByb3RlY3RlZCB2b2lkIHBlcmZvcm1EZWZhdWx0cygpIHsKCWNvbG9yRWRpdG9yLmxvYWREZWZhdWx0KCk7Cn0KLyoqIAogKiBNZXRob2QgZGVjbGFyZWQgb24gSVByZWZlcmVuY2VQYWdlLiBTYXZlIHRoZQogKiBjb2xvciBwcmVmZXJlbmNlIHRvIHRoZSBwcmVmZXJlbmNlIHN0b3JlLgogKi8KcHVibGljIGJvb2xlYW4gcGVyZm9ybU9rKCkgewoJY29sb3JFZGl0b3Iuc3RvcmUoKTsKCXJldHVybiBzdXBlci5wZXJmb3JtT2soKTsKfTwvcHJlPgo8cD4mbmJzcDs8L3A+CjxwIGFsaWduPSJjZW50ZXIiPjxpbWcgYm9yZGVyPSIwIiBzcmM9ImNvbG9ycHJlZmVyZW5jZS5qcGciIHdpZHRoPSI1OTgiIGhlaWdodD0iNTQxIj48L3A+CjxwIGFsaWduPSJjZW50ZXIiPlRoZSBDb2xvciBQcmVmZXJlbmNlIFBhZ2U8L3A+CjxoMj5UaGUgQmFkIFdvcmRzIFByZWZlcmVuY2UgUGFnZQo8L2gyPgo8cD5XZSBoYXZlIHNlZW4gaG93IHRvIGRvIGEgc2ltcGxlIHByZWZlcmVuY2UgcGFnZSB3aXRoIGp1c3QgYSBjb2xvciBhbmQgY2F0ZWdvcml6ZSBpdC4KTm93IHdlIHdpbGwgc2hvdyBob3cgdG8gdXNlIGEgY29tcGxleCBvYmplY3QgYXMgYQpwcmVmZXJlbmNlIGFuZCBzdGlsbCBoYXZlIGl0IHBlcnNpc3RlZCBieSB0aGUgcHJlZmVyZW5jZSBzdG9yZSBhbmQgZWRpdGFibGUgaW4gYQpwcmVmZXJlbmNlIHBhZ2UuIEZvciB0aGlzIGV4YW1wbGUKd2UgYXJlIGdvaW5nIHRvIGFkZCBhIGJhZCB3b3JkcyBwcmVmZXJlbmNlIHdoaWNoIGlzIGFuIGFycmF5IG9mIFN0cmluZ3MuCjwvcD4KPHA+QXMgdGhlIFByZWZlcmVuY2VDb252ZXJ0ZXIgZG9lcyBub3QgaGF2ZSBBUEkgZm9yIGNvbnZlcnNpb24gb2YgYXJyYXlzIG9mClN0cmluZ3Mgd2Ugd2lsbCBpbXBsZW1lbnQgaXQgb3Vyc2VsdmVzIGluIHRoZSBCYWRXb3JkQ2hlY2tlclBsdWdpbi4KQnkgaW1wbGVtZW50aW5nIGl0IGluIHRoZSBwbHVnLWluIHdlIHB1dCB0aGUgQVBJIGZvciB0aGUgdXNlIG9mIHRoZSBwcmVmZXJlbmNlIGluCmEgcGxhY2UgdmlzaWJsZSB0byBhbGwgb2JqZWN0cyB0aGF0IGhhdmUgYWNjZXNzIHRvIHRoaXMgcGx1Zy1pbi4gTm9ybWFsbHkgd2UKd291bGQgdXNlIHRoZSBQcmVmZXJlbmNlQ29udmVydGVyIGZvciBjb252ZXJzaW9uIHRvIGFuZCBmcm9tIHRoZSBzdG9yYWdlIGZvcm1hdC48L3A+CjxwPk1ldGhvZHMgZm9yIGdldHRpbmcgdGhlIGRlZmF1bHQgdmFsdWUgb2YgdGhlCnByZWZlcmVuY2UgYW5kIGEgZ2V0dGVyIGFuZCBhIHNldHRlciBhcmUKZGVmaW5lZCBmaXJzdCAtIGdldEJhZFdvcmRzRGVmYXVsdFByZWZlcmVuY2UgKHdoaWNoIHJldHVybnMgYW4gYXJyYXkgb2YgU3RyaW5ncykmbmJzcDsgZ2V0QmFkV29yZHNQcmVmZXJlbmNlICh3aGljaCBhbHNvIHJldHVybnMgYW4gYXJyYXkgb2YgU3RyaW5ncykgYW5kCnNldEJhZFdvcmRzUHJlZmVyZW5jZSB3aGljaCB0YWtlcyBhbiBhcnJheSBvZiBTdHJpbmdzIGFzIGl0cyBhcmd1bWVudC4gVGhlClN0cmluZyBhcnJheSBpcyBzdG9yZWQgaW4gdGhlIHByZWZlcmVuY2Ugc3RvcmUgYXMgYSBzaW5nbGUgc3RyaW5nIHNlcGFyYXRlZCBieSBzZW1pY29sb25zLiBXZSBjaG9vc2UKc2VtaWNvbG9ucyBhcyB0aGlzIGFyZSBvbmx5IGV2ZXIgdXNlZCBhcyBwdW5jdHVhdGlvbiBhbmQgd2lsbCB0aGVyZWZvcmUgbmV2ZXIKYmUgcGFydCBvZiBhIHdvcmQgd2UgYXJlIHNlYXJjaGluZyBmb3IuPC9wPgo8cHJlPi8qKgogKiBSZXR1cm4gdGhlIGJhZCB3b3JkcyBwcmVmZXJlbmNlIGRlZmF1bHQKICogYXMgYW4gYXJyYXkgb2YgU3RyaW5ncy4KICogQHJldHVybiBTdHJpbmdbXQogKi8KcHVibGljIFN0cmluZ1tdIGdldERlZmF1bHRCYWRXb3Jkc1ByZWZlcmVuY2UoKXsKCXJldHVybiBjb252ZXJ0KGdldFByZWZlcmVuY2VTdG9yZSgpLmdldERlZmF1bHRTdHJpbmcoQkFEX1dPUkRTX1BSRUZFUkVOQ0UpKTsKfQoKLyoqCiAqIFJldHVybiB0aGUgYmFkIHdvcmRzIHByZWZlcmVuY2UgYXMgYW4gYXJyYXkgb2YKICogU3RyaW5ncy4KICogQHJldHVybiBTdHJpbmdbXQogKi8KcHVibGljIFN0cmluZ1tdIGdldEJhZFdvcmRzUHJlZmVyZW5jZSgpIHsKCXJldHVybiBjb252ZXJ0KGdldFByZWZlcmVuY2VTdG9yZSgpLmdldFN0cmluZyhCQURfV09SRFNfUFJFRkVSRU5DRSkpOwp9CgkKLyoqCiAqIENvbnZlcnQgdGhlIHN1cHBsaWVkIFBSRUZFUkVOQ0VfREVMSU1JVEVSIGRlbGltaXRlZAogKiBTdHJpbmcgdG8gYSBTdHJpbmcgYXJyYXkuCiAqIEByZXR1cm4gU3RyaW5nW10KICovCnByaXZhdGUgU3RyaW5nW10gY29udmVydChTdHJpbmcgcHJlZmVyZW5jZVZhbHVlKSB7CglTdHJpbmdUb2tlbml6ZXIgdG9rZW5pemVyID0KCQluZXcgU3RyaW5nVG9rZW5pemVyKHByZWZlcmVuY2VWYWx1ZSwgUFJFRkVSRU5DRV9ERUxJTUlURVIpOwoJaW50IHRva2VuQ291bnQgPSB0b2tlbml6ZXIuY291bnRUb2tlbnMoKTsKCVN0cmluZ1tdIGVsZW1lbnRzID0gbmV3IFN0cmluZ1t0b2tlbkNvdW50XTsKCQlmb3IgKGludCBpID0gMDsgaSAmbHQ7IHRva2VuQ291bnQ7IGkrKykgewoJCQllbGVtZW50c1tpXSA9IHRva2VuaXplci5uZXh0VG9rZW4oKTsKCX0KCglyZXR1cm4gZWxlbWVudHM7Cn0KCi8qKgogKiBTZXQgdGhlIGJhZCB3b3JkcyBwcmVmZXJlbmNlCiAqIEBwYXJhbSBTdHJpbmcgW10gZWxlbWVudHMgLSB0aGUgU3RyaW5ncyB0byBiZSAKICogCWNvbnZlcnRlZCB0byB0aGUgcHJlZmVyZW5jZSB2YWx1ZQogKi8KcHVibGljIHZvaWQgc2V0QmFkV29yZHNQcmVmZXJlbmNlKFN0cmluZ1tdIGVsZW1lbnRzKSB7CglTdHJpbmdCdWZmZXIgYnVmZmVyID0gbmV3IFN0cmluZ0J1ZmZlcigpOwoJZm9yIChpbnQgaSA9IDA7IGkgJmx0OyBlbGVtZW50cy5sZW5ndGg7IGkrKykgewoJCWJ1ZmZlci5hcHBlbmQoZWxlbWVudHNbaV0pOwoJCWJ1ZmZlci5hcHBlbmQoUFJFRkVSRU5DRV9ERUxJTUlURVIpOwoJfQoJZ2V0UHJlZmVyZW5jZVN0b3JlKCkuc2V0VmFsdWUoQkFEX1dPUkRTX1BSRUZFUkVOQ0UsIGJ1ZmZlci50b1N0cmluZygpKTsKfQo8L3ByZT4KPHA+VGhlcmUgaXMgbm8gZmllbGQgZWRpdG9yIGRlZmluZWQgaW4gSkZhY2UKZm9yJm5ic3A7IGVkaXRpbmcgU3RyaW5nIGFycmF5cyBzbyB3ZSB3aWxsIGRlZmluZSBhIGxpc3QgdGhhdCBzaG93cyB0aGUKaXRlbXMgd2l0aCB3aWRnZXRzIHRvIGFkZCBhbmQgcmVtb3ZlIHRoZW0uIE91ciBwZXJmb3JtT0sgbWV0aG9kIHdpbGwgc2VuZCB0aGUKY3VycmVudCBjb250ZW50cyBvZiB0aGUgbGlzdCB0byB0aGUgc2V0QmFkV29yZHNQcmVmZXJlbmNlIG1ldGhvZCBhbmQgdGhlCnBlcmZvcm1EZWZhdWx0cyBtZXRob2Qgd2lsbCByZXNldCB0aGUgbGlzdCBvZiBzdHJpbmdzIHRvIGJlIHRoZSByZXN1bHQgb2YKZ2V0RGVmYXVsdEJhZFdvcmRzUHJlZmVyZW5jZSBmcm9tIEJhZFdvcmRDaGVja2VyUGx1Z2luLiBBcyBhIExpc3Qgd2lkZ2V0IHRha2VzIGFuIGFycmF5IG9mIFN0cmluZ3MgYXMgaXRzCmNvbnRlbnQgd2UgY2FuIHVzZSB0aGUgcmVzdWx0cyBvZiB0aGVzZSBoZWxwZXIgbWV0aG9kcyBkaXJlY3RseQppbiBjb25qdW5jdGlvbiB3aXRoIHRoZSBtZXRob2RzIHdlIGRlZmluZWQgZm9yIHRoZSBiYWQgd29yZHMgcHJlZmVyZW5jZSBpbiB0aGUKcGx1Zy1pbi4gVGhlIHBlcmZvcm1PSyBhbmQgcGVyZm9ybURlZmF1bHRzIGZvciB0aGlzIHByZWZlcmVuY2UgcGFnZSB1c2UgdGhlc2UKbWV0aG9kcyB0byB1cGRhdGUgdGhlIHByZWZlcmVuY2UgYW5kIHJlc2V0IHRoZSB2YWx1ZXMgaW4gdGhlIGxpc3Qgd2lkZ2V0Lgo8L3A+CjxwcmU+LyoqCiAqIFBlcmZvcm1zIHNwZWNpYWwgcHJvY2Vzc2luZyB3aGVuIHRoaXMgcGFnZSdzIFJlc3RvcmUgRGVmYXVsdHMgYnV0dG9uIGhhcyBiZWVuIHByZXNzZWQuCiAqIFNldHMgdGhlIGNvbnRlbnRzIG9mIHRoZSBuYW1lRW50cnkgZmllbGQgdG8KICogYmUgdGhlIGRlZmF1bHQgCiAqLwpwcm90ZWN0ZWQgdm9pZCBwZXJmb3JtRGVmYXVsdHMoKSB7CgliYWRXb3JkTGlzdC5zZXRJdGVtcyhCYWRXb3JkQ2hlY2tlclBsdWdpbi5nZXREZWZhdWx0KCkuZ2V0RGVmYXVsdEJhZFdvcmRzUHJlZmVyZW5jZSgpKTsKfQovKiogCiAqIE1ldGhvZCBkZWNsYXJlZCBvbiBJUHJlZmVyZW5jZVBhZ2UuIFNhdmUgdGhlCiAqIGF1dGhvciBuYW1lIHRvIHRoZSBwcmVmZXJlbmNlIHN0b3JlLgogKi8KcHVibGljIGJvb2xlYW4gcGVyZm9ybU9rKCkgewoJQmFkV29yZENoZWNrZXJQbHVnaW4uZ2V0RGVmYXVsdCgpLnNldEJhZFdvcmRzUHJlZmVyZW5jZShiYWRXb3JkTGlzdC5nZXRJdGVtcygpKTsKCXJldHVybiBzdXBlci5wZXJmb3JtT2soKTsKfTwvcHJlPgo8cCBhbGlnbj0iY2VudGVyIj48aW1nIGJvcmRlcj0iMCIgc3JjPSJiYWR3b3JkcHJlZmVyZW5jZS5qcGciIHdpZHRoPSI1OTYiIGhlaWdodD0iNTM5Ij4gCjwvcD4KPHAgYWxpZ249ImNlbnRlciI+VGhlIEJhZCBXb3JkIFByZWZlcmVuY2UgRGlhbG9nCjwvcD4KPGgyPkNvbmNsdXNpb25zCjwvaDI+CjxwPkluIHRoaXMgYXJ0aWNsZSB3ZSBoYXZlIGRlbW9uc3RyYXRlZCBob3cgdG8gdXNlIHRoZSBwcmVmZXJlbmNlcyBzdG9yZSBhbmQKcHJlZmVyZW5jZXMgcGFnZXMgcHJvdmlkZWQgYnkgRWNsaXBzZSB0byBhbGxvdyBhIHBsdWctaW4gdG8gbWFpbnRhaW4gYW5kIHVwZGF0ZQpwcmVmZXJlbmNlcyBiZXR3ZWVuIEVjbGlwc2Ugc2Vzc2lvbnMuIEJ5IHVzZSBvZiB0aGUgcHJlZmVyZW5jZSBzdG9yZSBpbgpjb25qdW5jdGlvbiB3aXRoIHRoZSBwcmVmZXJlbmNlcyBkaWFsb2cgYW5kIHByb3ZpZGVkIGZpZWxkIGVkaXRvcnMgYSBwbHVnLWluCmRldmVsb3BlciBjYW4gcXVpY2tseSBwdXQgdG9nZXRoZXIgYSB1c2VyIGludGVyZmFjZSBmb3IgbWFuYWdpbmcgcHJlZmVyZW5jZXMuIFRvCmZpbmQgb3V0IG1vcmUgYWJvdXQgdGhlIHByZWZlcmVuY2VzIHRoYXQgRWNsaXBzZSBwcm92aWRlcyBzZWUgdGhlIFBsYXRmb3JtClBsdWctaW4gRGV2ZWxvcGVycyBHdWlkZSBpbiB0aGUgSGVscCBQZXJzcGVjdGl2ZS4gVGhlIGhlbHAgaW5mb3JtYXRpb24gaXMgaW4gdGhlClByb2dyYW1tZXJzIEd1aWRlIFByZWZlcmVuY2VzIGFuZCBQcm9wZXJ0aWVzIHNlY3Rpb24uCjwvcD4KPHA+VGhlIGZ1bGwgaW1wbGVtZW50YXRpb24gb2YgdGhlIGV4YW1wbGUgaW4gdGhpcyBhcnRpY2xlIGNhbiBiZSBmb3VuZCBpbiA8YSBocmVmPSJwcmVmZXJlbmNlcy56aXAiPnByZWZlcmVuY2VzLnppcDwvYT4uCjwvcD4KCjxwPjxzbWFsbD5KYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFuZCBsb2dvcyBhcmUgdHJhZGVtYXJrcyBvciByZWdpc3RlcmVkCnRyYWRlbWFya3Mgb2YgU3VuIE1pY3Jvc3lzdGVtcywgSW5jLiBpbiB0aGUgVW5pdGVkIFN0YXRlcywgb3RoZXIgY291bnRyaWVzLCBvcgpib3RoLjwvc21hbGw+PC9wPgoKPC9ib2R5PgoKPC9odG1sPgo=