ZGlmZiAtLWdpdCBhLy5hcnRpZmFjdFZlcnNpb25zIGIvLmFydGlmYWN0VmVyc2lvbnMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOWExN2JkZQotLS0gL2Rldi9udWxsCisrKyBiLy5hcnRpZmFjdFZlcnNpb25zCkBAIC0wLDAgKzEsNCBAQAordmVyc2lvbj0wLjkuMS1TTkFQU0hPVAorcmVsZW5nVmVyc2lvbj0wLjEyLjUtU05BUFNIT1QKK3JlbGVuZ1AyVmVyc2lvbj0wLjEyLjUtU05BUFNIT1QKK3JlbGVuZ0dyb3VwSWQ9b3JnLmx1bmlmZXJhLnJlbGVuZy5tYXZlbgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhLy5kZXBWZXJzaW9ucyBiLy5kZXBWZXJzaW9ucwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41NDk0NzBmCi0tLSAvZGV2L251bGwKKysrIGIvLmRlcFZlcnNpb25zCkBAIC0wLDAgKzEsOSBAQAorb3JnLmVjbGlwc2UueHRlbmQ7bWluPTIuNy4zO21heD0yLjguMAorb3JnLmVjbGlwc2UueHRleHQ7bWluPTIuNy4zO21heD0yLjguMAorb3JnLnNlbWFudGljc29mdDttaW49Mi43LjM7bWF4PTMuMC4wCitvcmcubHVuaWZlcmEuZHNsO21pbj0wLjkuMDttYXg9MC4xMC4wCitvcmcubHVuaWZlcmE7bWluPTAuOS4wO21heD0wLjEwLjAKK2NvbS5nb29nbGUuZ3VhdmE7bWluPTEwLjAuMDttYXg9MTkuMC4wCitjb20udmFhZGluLmV4dGVybmFsLmF0bW9zcGhlcmUucnVudGltZTttaW49Mi4xLjI7bWF4PTIuMS4zCitjb20udmFhZGluLmV4dGVybmFsLm9yZy5zbGY0ajttaW49MS42LjE7bWF4PTEuNi4yCitjb20udmFhZGluO21pbj03LjMuODttYXg9Ny4zLjkKZGlmZiAtLWdpdCBhLy5vc2JwLnJlbGVuZy5yb290IGIvLm9zYnAucmVsZW5nLnJvb3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZTY5ZGUyOQotLS0gL2Rldi9udWxsCisrKyBiLy5vc2JwLnJlbGVuZy5yb290CmRpZmYgLS1naXQgYS8ucHJvamVjdCBiLy5wcm9qZWN0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjYxNzU0MTgKLS0tIC9kZXYvbnVsbAorKysgYi8ucHJvamVjdApAQCAtMCwwICsxLDIyIEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPHByb2plY3REZXNjcmlwdGlvbj4KKwk8bmFtZT5vcmcuZWNsaXBzZS5vc2JwLmlkZTwvbmFtZT4KKwk8Y29tbWVudD48L2NvbW1lbnQ+CisJPHByb2plY3RzPgorCTwvcHJvamVjdHM+CisJPGJ1aWxkU3BlYz4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLm0yZS5jb3JlLm1hdmVuMkJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLnNvbmFybGludC5lY2xpcHNlLmNvcmUuc29uYXJsaW50QnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJPC9idWlsZFNwZWM+CisJPG5hdHVyZXM+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UubTJlLmNvcmUubWF2ZW4yTmF0dXJlPC9uYXR1cmU+CisJPC9uYXR1cmVzPgorPC9wcm9qZWN0RGVzY3JpcHRpb24+CmRpZmYgLS1naXQgYS9MSUNFTlNFLnR4dCBiL0xJQ0VOU0UudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmZmNDJhZDQKLS0tIC9kZXYvbnVsbAorKysgYi9MSUNFTlNFLnR4dApAQCAtMCwwICsxLDE2MSBAQAorRWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtdiAxLjAKKworVEhFIEFDQ09NUEFOWUlORyBQUk9HUkFNIElTIFBST1ZJREVEIFVOREVSIFRIRSBURVJNUyBPRiBUSElTIEVDTElQU0UgUFVCTElDIExJQ0VOU0UgKCJBR1JFRU1FTlQiKS4gQU5ZIFVTRSwgUkVQUk9EVUNUSU9OCitPUiBESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gQ09OU1RJVFVURVMgUkVDSVBJRU5UJ1MgQUNDRVBUQU5DRSBPRiBUSElTIEFHUkVFTUVOVC4KKworMS4gREVGSU5JVElPTlMKKworIkNvbnRyaWJ1dGlvbiIgbWVhbnM6CisKK2EpIGluIHRoZSBjYXNlIG9mIHRoZSBpbml0aWFsIENvbnRyaWJ1dG9yLCB0aGUgaW5pdGlhbCBjb2RlIGFuZCBkb2N1bWVudGF0aW9uIGRpc3RyaWJ1dGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBhbmQKKworYikgaW4gdGhlIGNhc2Ugb2YgZWFjaCBzdWJzZXF1ZW50IENvbnRyaWJ1dG9yOgorCitpKSBjaGFuZ2VzIHRvIHRoZSBQcm9ncmFtLCBhbmQKKworaWkpIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbTsKKword2hlcmUgc3VjaCBjaGFuZ2VzIGFuZC9vciBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gb3JpZ2luYXRlIGZyb20gYW5kIGFyZSBkaXN0cmlidXRlZCBieSB0aGF0IHBhcnRpY3VsYXIgQ29udHJpYnV0b3IuCitBIENvbnRyaWJ1dGlvbiAnb3JpZ2luYXRlcycgZnJvbSBhIENvbnRyaWJ1dG9yIGlmIGl0IHdhcyBhZGRlZCB0byB0aGUgUHJvZ3JhbSBieSBzdWNoIENvbnRyaWJ1dG9yIGl0c2VsZiBvciBhbnlvbmUKK2FjdGluZyBvbiBzdWNoIENvbnRyaWJ1dG9yJ3MgYmVoYWxmLiBDb250cmlidXRpb25zIGRvIG5vdCBpbmNsdWRlIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbSB3aGljaDogKGkpIGFyZSBzZXBhcmF0ZQorbW9kdWxlcyBvZiBzb2Z0d2FyZSBkaXN0cmlidXRlZCBpbiBjb25qdW5jdGlvbiB3aXRoIHRoZSBQcm9ncmFtIHVuZGVyIHRoZWlyIG93biBsaWNlbnNlIGFncmVlbWVudCwgYW5kIChpaSkgYXJlIG5vdAorZGVyaXZhdGl2ZSB3b3JrcyBvZiB0aGUgUHJvZ3JhbS4KKworIkNvbnRyaWJ1dG9yIiBtZWFucyBhbnkgcGVyc29uIG9yIGVudGl0eSB0aGF0IGRpc3RyaWJ1dGVzIHRoZSBQcm9ncmFtLgorCisiTGljZW5zZWQgUGF0ZW50cyAiIG1lYW4gcGF0ZW50IGNsYWltcyBsaWNlbnNhYmxlIGJ5IGEgQ29udHJpYnV0b3Igd2hpY2ggYXJlIG5lY2Vzc2FyaWx5IGluZnJpbmdlZCBieSB0aGUgdXNlIG9yIHNhbGUgb2YKK2l0cyBDb250cmlidXRpb24gYWxvbmUgb3Igd2hlbiBjb21iaW5lZCB3aXRoIHRoZSBQcm9ncmFtLgorCisiUHJvZ3JhbSIgbWVhbnMgdGhlIENvbnRyaWJ1dGlvbnMgZGlzdHJpYnV0ZWQgaW4gYWNjb3JkYW5jZSB3aXRoIHRoaXMgQWdyZWVtZW50LgorCisiUmVjaXBpZW50IiBtZWFucyBhbnlvbmUgd2hvIHJlY2VpdmVzIHRoZSBQcm9ncmFtIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBpbmNsdWRpbmcgYWxsIENvbnRyaWJ1dG9ycy4KKworMi4gR1JBTlQgT0YgUklHSFRTCisKK2EpIFN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLAorcm95YWx0eS1mcmVlIGNvcHlyaWdodCBsaWNlbnNlIHRvIHJlcHJvZHVjZSwgcHJlcGFyZSBkZXJpdmF0aXZlIHdvcmtzIG9mLCBwdWJsaWNseSBkaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBkaXN0cmlidXRlCithbmQgc3VibGljZW5zZSB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgYW5kIHN1Y2ggZGVyaXZhdGl2ZSB3b3JrcywgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlCitmb3JtLgorCitiKSBTdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwKK3JveWFsdHktZnJlZSBwYXRlbnQgbGljZW5zZSB1bmRlciBMaWNlbnNlZCBQYXRlbnRzIHRvIG1ha2UsIHVzZSwgc2VsbCwgb2ZmZXIgdG8gc2VsbCwgaW1wb3J0IGFuZCBvdGhlcndpc2UgdHJhbnNmZXIgdGhlCitDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUgZm9ybS4gVGhpcyBwYXRlbnQgbGljZW5zZSBzaGFsbCBhcHBseSB0byB0aGUKK2NvbWJpbmF0aW9uIG9mIHRoZSBDb250cmlidXRpb24gYW5kIHRoZSBQcm9ncmFtIGlmLCBhdCB0aGUgdGltZSB0aGUgQ29udHJpYnV0aW9uIGlzIGFkZGVkIGJ5IHRoZSBDb250cmlidXRvciwgc3VjaAorYWRkaXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBjYXVzZXMgc3VjaCBjb21iaW5hdGlvbiB0byBiZSBjb3ZlcmVkIGJ5IHRoZSBMaWNlbnNlZCBQYXRlbnRzLiBUaGUgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgbm90CithcHBseSB0byBhbnkgb3RoZXIgY29tYmluYXRpb25zIHdoaWNoIGluY2x1ZGUgdGhlIENvbnRyaWJ1dGlvbi4gTm8gaGFyZHdhcmUgcGVyIHNlIGlzIGxpY2Vuc2VkIGhlcmV1bmRlci4KKworYykgUmVjaXBpZW50IHVuZGVyc3RhbmRzIHRoYXQgYWx0aG91Z2ggZWFjaCBDb250cmlidXRvciBncmFudHMgdGhlIGxpY2Vuc2VzIHRvIGl0cyBDb250cmlidXRpb25zIHNldCBmb3J0aCBoZXJlaW4sIG5vCithc3N1cmFuY2VzIGFyZSBwcm92aWRlZCBieSBhbnkgQ29udHJpYnV0b3IgdGhhdCB0aGUgUHJvZ3JhbSBkb2VzIG5vdCBpbmZyaW5nZSB0aGUgcGF0ZW50IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQorcmlnaHRzIG9mIGFueSBvdGhlciBlbnRpdHkuIEVhY2ggQ29udHJpYnV0b3IgZGlzY2xhaW1zIGFueSBsaWFiaWxpdHkgdG8gUmVjaXBpZW50IGZvciBjbGFpbXMgYnJvdWdodCBieSBhbnkgb3RoZXIgZW50aXR5CitiYXNlZCBvbiBpbmZyaW5nZW1lbnQgb2YgaW50ZWxsZWN0dWFsIHByb3BlcnR5IHJpZ2h0cyBvciBvdGhlcndpc2UuIEFzIGEgY29uZGl0aW9uIHRvIGV4ZXJjaXNpbmcgdGhlIHJpZ2h0cyBhbmQKK2xpY2Vuc2VzIGdyYW50ZWQgaGVyZXVuZGVyLCBlYWNoIFJlY2lwaWVudCBoZXJlYnkgYXNzdW1lcyBzb2xlIHJlc3BvbnNpYmlsaXR5IHRvIHNlY3VyZSBhbnkgb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5CityaWdodHMgbmVlZGVkLCBpZiBhbnkuIEZvciBleGFtcGxlLCBpZiBhIHRoaXJkIHBhcnR5IHBhdGVudCBsaWNlbnNlIGlzIHJlcXVpcmVkIHRvIGFsbG93IFJlY2lwaWVudCB0byBkaXN0cmlidXRlIHRoZQorUHJvZ3JhbSwgaXQgaXMgUmVjaXBpZW50J3MgcmVzcG9uc2liaWxpdHkgdG8gYWNxdWlyZSB0aGF0IGxpY2Vuc2UgYmVmb3JlIGRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbS4KKworZCkgRWFjaCBDb250cmlidXRvciByZXByZXNlbnRzIHRoYXQgdG8gaXRzIGtub3dsZWRnZSBpdCBoYXMgc3VmZmljaWVudCBjb3B5cmlnaHQgcmlnaHRzIGluIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgdG8KK2dyYW50IHRoZSBjb3B5cmlnaHQgbGljZW5zZSBzZXQgZm9ydGggaW4gdGhpcyBBZ3JlZW1lbnQuCisKKzMuIFJFUVVJUkVNRU5UUworCitBIENvbnRyaWJ1dG9yIG1heSBjaG9vc2UgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbSBpbiBvYmplY3QgY29kZSBmb3JtIHVuZGVyIGl0cyBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIHByb3ZpZGVkIHRoYXQ6CisKK2EpIGl0IGNvbXBsaWVzIHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50OyBhbmQKKworYikgaXRzIGxpY2Vuc2UgYWdyZWVtZW50OgorCitpKSBlZmZlY3RpdmVseSBkaXNjbGFpbXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIHdhcnJhbnRpZXMgYW5kIGNvbmRpdGlvbnMsIGV4cHJlc3MgYW5kIGltcGxpZWQsIGluY2x1ZGluZword2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIHRpdGxlIGFuZCBub24taW5mcmluZ2VtZW50LCBhbmQgaW1wbGllZCB3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgbWVyY2hhbnRhYmlsaXR5IGFuZAorZml0bmVzcyBmb3IgYSBwYXJ0aWN1bGFyIHB1cnBvc2U7CisKK2lpKSBlZmZlY3RpdmVseSBleGNsdWRlcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgbGlhYmlsaXR5IGZvciBkYW1hZ2VzLCBpbmNsdWRpbmcgZGlyZWN0LCBpbmRpcmVjdCwgc3BlY2lhbCwKK2luY2lkZW50YWwgYW5kIGNvbnNlcXVlbnRpYWwgZGFtYWdlcywgc3VjaCBhcyBsb3N0IHByb2ZpdHM7CisKK2lpaSkgc3RhdGVzIHRoYXQgYW55IHByb3Zpc2lvbnMgd2hpY2ggZGlmZmVyIGZyb20gdGhpcyBBZ3JlZW1lbnQgYXJlIG9mZmVyZWQgYnkgdGhhdCBDb250cmlidXRvciBhbG9uZSBhbmQgbm90IGJ5IGFueQorb3RoZXIgcGFydHk7IGFuZAorCitpdikgc3RhdGVzIHRoYXQgc291cmNlIGNvZGUgZm9yIHRoZSBQcm9ncmFtIGlzIGF2YWlsYWJsZSBmcm9tIHN1Y2ggQ29udHJpYnV0b3IsIGFuZCBpbmZvcm1zIGxpY2Vuc2VlcyBob3cgdG8gb2J0YWluIGl0CitpbiBhIHJlYXNvbmFibGUgbWFubmVyIG9uIG9yIHRocm91Z2ggYSBtZWRpdW0gY3VzdG9tYXJpbHkgdXNlZCBmb3Igc29mdHdhcmUgZXhjaGFuZ2UuCisKK1doZW4gdGhlIFByb2dyYW0gaXMgbWFkZSBhdmFpbGFibGUgaW4gc291cmNlIGNvZGUgZm9ybToKKworYSkgaXQgbXVzdCBiZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGlzIEFncmVlbWVudDsgYW5kCisKK2IpIGEgY29weSBvZiB0aGlzIEFncmVlbWVudCBtdXN0IGJlIGluY2x1ZGVkIHdpdGggZWFjaCBjb3B5IG9mIHRoZSBQcm9ncmFtLgorCitDb250cmlidXRvcnMgbWF5IG5vdCByZW1vdmUgb3IgYWx0ZXIgYW55IGNvcHlyaWdodCBub3RpY2VzIGNvbnRhaW5lZCB3aXRoaW4gdGhlIFByb2dyYW0uCisKK0VhY2ggQ29udHJpYnV0b3IgbXVzdCBpZGVudGlmeSBpdHNlbGYgYXMgdGhlIG9yaWdpbmF0b3Igb2YgaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCBpbiBhIG1hbm5lciB0aGF0IHJlYXNvbmFibHkgYWxsb3dzCitzdWJzZXF1ZW50IFJlY2lwaWVudHMgdG8gaWRlbnRpZnkgdGhlIG9yaWdpbmF0b3Igb2YgdGhlIENvbnRyaWJ1dGlvbi4KKworNC4gQ09NTUVSQ0lBTCBESVNUUklCVVRJT04KKworQ29tbWVyY2lhbCBkaXN0cmlidXRvcnMgb2Ygc29mdHdhcmUgbWF5IGFjY2VwdCBjZXJ0YWluIHJlc3BvbnNpYmlsaXRpZXMgd2l0aCByZXNwZWN0IHRvIGVuZCB1c2VycywgYnVzaW5lc3MgcGFydG5lcnMgYW5kCit0aGUgbGlrZS4gV2hpbGUgdGhpcyBsaWNlbnNlIGlzIGludGVuZGVkIHRvIGZhY2lsaXRhdGUgdGhlIGNvbW1lcmNpYWwgdXNlIG9mIHRoZSBQcm9ncmFtLCB0aGUgQ29udHJpYnV0b3Igd2hvIGluY2x1ZGVzCit0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZyBzaG91bGQgZG8gc28gaW4gYSBtYW5uZXIgd2hpY2ggZG9lcyBub3QgY3JlYXRlIHBvdGVudGlhbCBsaWFiaWxpdHkgZm9yCitvdGhlciBDb250cmlidXRvcnMuIFRoZXJlZm9yZSwgaWYgYSBDb250cmlidXRvciBpbmNsdWRlcyB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgc3VjaCBDb250cmlidXRvcgorKCJDb21tZXJjaWFsIENvbnRyaWJ1dG9yIikgaGVyZWJ5IGFncmVlcyB0byBkZWZlbmQgYW5kIGluZGVtbmlmeSBldmVyeSBvdGhlciBDb250cmlidXRvciAoIkluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIikKK2FnYWluc3QgYW55IGxvc3NlcywgZGFtYWdlcyBhbmQgY29zdHMgKGNvbGxlY3RpdmVseSAiTG9zc2VzIikgYXJpc2luZyBmcm9tIGNsYWltcywgbGF3c3VpdHMgYW5kIG90aGVyIGxlZ2FsIGFjdGlvbnMKK2Jyb3VnaHQgYnkgYSB0aGlyZCBwYXJ0eSBhZ2FpbnN0IHRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciB0byB0aGUgZXh0ZW50IGNhdXNlZCBieSB0aGUgYWN0cyBvciBvbWlzc2lvbnMgb2Ygc3VjaAorQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiBjb25uZWN0aW9uIHdpdGggaXRzIGRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZy4gVGhlCitvYmxpZ2F0aW9ucyBpbiB0aGlzIHNlY3Rpb24gZG8gbm90IGFwcGx5IHRvIGFueSBjbGFpbXMgb3IgTG9zc2VzIHJlbGF0aW5nIHRvIGFueSBhY3R1YWwgb3IgYWxsZWdlZCBpbnRlbGxlY3R1YWwKK3Byb3BlcnR5IGluZnJpbmdlbWVudC4gSW4gb3JkZXIgdG8gcXVhbGlmeSwgYW4gSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbXVzdDogYSkgcHJvbXB0bHkgbm90aWZ5IHRoZSBDb21tZXJjaWFsCitDb250cmlidXRvciBpbiB3cml0aW5nIG9mIHN1Y2ggY2xhaW0sIGFuZCBiKSBhbGxvdyB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB0byBjb250cm9sLCBhbmQgY29vcGVyYXRlIHdpdGggdGhlCitDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluLCB0aGUgZGVmZW5zZSBhbmQgYW55IHJlbGF0ZWQgc2V0dGxlbWVudCBuZWdvdGlhdGlvbnMuIFRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciBtYXkKKyBwYXJ0aWNpcGF0ZSBpbiBhbnkgc3VjaCBjbGFpbSBhdCBpdHMgb3duIGV4cGVuc2UuCisKK0ZvciBleGFtcGxlLCBhIENvbnRyaWJ1dG9yIG1pZ2h0IGluY2x1ZGUgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIFByb2R1Y3QgWC4gVGhhdCBDb250cmlidXRvciBpcwordGhlbiBhIENvbW1lcmNpYWwgQ29udHJpYnV0b3IuIElmIHRoYXQgQ29tbWVyY2lhbCBDb250cmlidXRvciB0aGVuIG1ha2VzIHBlcmZvcm1hbmNlIGNsYWltcywgb3Igb2ZmZXJzIHdhcnJhbnRpZXMKK3JlbGF0ZWQgdG8gUHJvZHVjdCBYLCB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMgYXJlIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvcidzIHJlc3BvbnNpYmlsaXR5IGFsb25lLgorVW5kZXIgdGhpcyBzZWN0aW9uLCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB3b3VsZCBoYXZlIHRvIGRlZmVuZCBjbGFpbXMgYWdhaW5zdCB0aGUgb3RoZXIgQ29udHJpYnV0b3JzIHJlbGF0ZWQgdG8KK3Rob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcywgYW5kIGlmIGEgY291cnQgcmVxdWlyZXMgYW55IG90aGVyIENvbnRyaWJ1dG9yIHRvIHBheSBhbnkgZGFtYWdlcyBhcyBhIHJlc3VsdCwKK3RoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIG11c3QgcGF5IHRob3NlIGRhbWFnZXMuCisKKzUuIE5PIFdBUlJBTlRZCisKK0VYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMgQUdSRUVNRU5ULCBUSEUgUFJPR1JBTSBJUyBQUk9WSURFRCBPTiBBTiAiQVMgSVMiIEJBU0lTLCBXSVRIT1VUIFdBUlJBTlRJRVMgT1IKK0NPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIEVJVEhFUiBFWFBSRVNTIE9SIElNUExJRUQgSU5DTFVESU5HLCBXSVRIT1VUIExJTUlUQVRJT04sIEFOWSBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgVElUTEUsCitOT04tSU5GUklOR0VNRU5ULCBNRVJDSEFOVEFCSUxJVFkgT1IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIEVhY2ggUmVjaXBpZW50IGlzIHNvbGVseSByZXNwb25zaWJsZSBmb3IKK2RldGVybWluaW5nIHRoZSBhcHByb3ByaWF0ZW5lc3Mgb2YgdXNpbmcgYW5kIGRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbSBhbmQgYXNzdW1lcyBhbGwgcmlza3MgYXNzb2NpYXRlZCB3aXRoIGl0cworZXhlcmNpc2Ugb2YgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50ICwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgcmlza3MgYW5kIGNvc3RzIG9mIHByb2dyYW0gZXJyb3JzLCBjb21wbGlhbmNlCit3aXRoIGFwcGxpY2FibGUgbGF3cywgZGFtYWdlIHRvIG9yIGxvc3Mgb2YgZGF0YSwgcHJvZ3JhbXMgb3IgZXF1aXBtZW50LCBhbmQgdW5hdmFpbGFiaWxpdHkgb3IgaW50ZXJydXB0aW9uIG9mIG9wZXJhdGlvbnMuCisKKzYuIERJU0NMQUlNRVIgT0YgTElBQklMSVRZCisKK0VYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMgQUdSRUVNRU5ULCBORUlUSEVSIFJFQ0lQSUVOVCBOT1IgQU5ZIENPTlRSSUJVVE9SUyBTSEFMTCBIQVZFIEFOWSBMSUFCSUxJVFkgRk9SIEFOWQorRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORyBXSVRIT1VUIExJTUlUQVRJT04gTE9TVCBQUk9GSVRTKSwKK0hPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IKK09USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBPUiBUSEUgRVhFUkNJU0UgT0YgQU5ZIFJJR0hUUyBHUkFOVEVECitIRVJFVU5ERVIsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0VTLgorCis3LiBHRU5FUkFMCisKK0lmIGFueSBwcm92aXNpb24gb2YgdGhpcyBBZ3JlZW1lbnQgaXMgaW52YWxpZCBvciB1bmVuZm9yY2VhYmxlIHVuZGVyIGFwcGxpY2FibGUgbGF3LCBpdCBzaGFsbCBub3QgYWZmZWN0IHRoZSB2YWxpZGl0eSBvcgorZW5mb3JjZWFiaWxpdHkgb2YgdGhlIHJlbWFpbmRlciBvZiB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGFuZCB3aXRob3V0IGZ1cnRoZXIgYWN0aW9uIGJ5IHRoZSBwYXJ0aWVzIGhlcmV0bywgc3VjaAorcHJvdmlzaW9uIHNoYWxsIGJlIHJlZm9ybWVkIHRvIHRoZSBtaW5pbXVtIGV4dGVudCBuZWNlc3NhcnkgdG8gbWFrZSBzdWNoIHByb3Zpc2lvbiB2YWxpZCBhbmQgZW5mb3JjZWFibGUuCisKK0lmIFJlY2lwaWVudCBpbnN0aXR1dGVzIHBhdGVudCBsaXRpZ2F0aW9uIGFnYWluc3QgYW55IGVudGl0eSAoaW5jbHVkaW5nIGEgY3Jvc3MtY2xhaW0gb3IgY291bnRlcmNsYWltIGluIGEgbGF3c3VpdCkKK2FsbGVnaW5nIHRoYXQgdGhlIFByb2dyYW0gaXRzZWxmIChleGNsdWRpbmcgY29tYmluYXRpb25zIG9mIHRoZSBQcm9ncmFtIHdpdGggb3RoZXIgc29mdHdhcmUgb3IgaGFyZHdhcmUpIGluZnJpbmdlcyBzdWNoCitSZWNpcGllbnQncyBwYXRlbnQocyksIHRoZW4gc3VjaCBSZWNpcGllbnQncyByaWdodHMgZ3JhbnRlZCB1bmRlciBTZWN0aW9uIDIoYikgc2hhbGwgdGVybWluYXRlIGFzIG9mIHRoZSBkYXRlIHN1Y2gKK2xpdGlnYXRpb24gaXMgZmlsZWQuCisKK0FsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgc2hhbGwgdGVybWluYXRlIGlmIGl0IGZhaWxzIHRvIGNvbXBseSB3aXRoIGFueSBvZiB0aGUgbWF0ZXJpYWwgdGVybXMgb3IKK2NvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQgYW5kIGRvZXMgbm90IGN1cmUgc3VjaCBmYWlsdXJlIGluIGEgcmVhc29uYWJsZSBwZXJpb2Qgb2YgdGltZSBhZnRlciBiZWNvbWluZyBhd2FyZSBvZiBzdWNoCitub25jb21wbGlhbmNlLiBJZiBhbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHRlcm1pbmF0ZSwgUmVjaXBpZW50IGFncmVlcyB0byBjZWFzZSB1c2UgYW5kIGRpc3RyaWJ1dGlvbgorb2YgdGhlIFByb2dyYW0gYXMgc29vbiBhcyByZWFzb25hYmx5IHByYWN0aWNhYmxlLiBIb3dldmVyLCBSZWNpcGllbnQncyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIEFncmVlbWVudCBhbmQgYW55IGxpY2Vuc2VzCisgZ3JhbnRlZCBieSBSZWNpcGllbnQgcmVsYXRpbmcgdG8gdGhlIFByb2dyYW0gc2hhbGwgY29udGludWUgYW5kIHN1cnZpdmUuCisKK0V2ZXJ5b25lIGlzIHBlcm1pdHRlZCB0byBjb3B5IGFuZCBkaXN0cmlidXRlIGNvcGllcyBvZiB0aGlzIEFncmVlbWVudCwgYnV0IGluIG9yZGVyIHRvIGF2b2lkIGluY29uc2lzdGVuY3kgdGhlIEFncmVlbWVudAoraXMgY29weXJpZ2h0ZWQgYW5kIG1heSBvbmx5IGJlIG1vZGlmaWVkIGluIHRoZSBmb2xsb3dpbmcgbWFubmVyLiBUaGUgQWdyZWVtZW50IFN0ZXdhcmQgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHB1Ymxpc2gKK25ldyB2ZXJzaW9ucyAoaW5jbHVkaW5nIHJldmlzaW9ucykgb2YgdGhpcyBBZ3JlZW1lbnQgZnJvbSB0aW1lIHRvIHRpbWUuIE5vIG9uZSBvdGhlciB0aGFuIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCBoYXMgdGhlCityaWdodCB0byBtb2RpZnkgdGhpcyBBZ3JlZW1lbnQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgdGhlIGluaXRpYWwgQWdyZWVtZW50IFN0ZXdhcmQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWF5Cithc3NpZ24gdGhlIHJlc3BvbnNpYmlsaXR5IHRvIHNlcnZlIGFzIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCB0byBhIHN1aXRhYmxlIHNlcGFyYXRlIGVudGl0eS4gRWFjaCBuZXcgdmVyc2lvbiBvZiB0aGUKK0FncmVlbWVudCB3aWxsIGJlIGdpdmVuIGEgZGlzdGluZ3Vpc2hpbmcgdmVyc2lvbiBudW1iZXIuIFRoZSBQcm9ncmFtIChpbmNsdWRpbmcgQ29udHJpYnV0aW9ucykgbWF5IGFsd2F5cyBiZQorZGlzdHJpYnV0ZWQgc3ViamVjdCB0byB0aGUgdmVyc2lvbiBvZiB0aGUgQWdyZWVtZW50IHVuZGVyIHdoaWNoIGl0IHdhcyByZWNlaXZlZC4gSW4gYWRkaXRpb24sIGFmdGVyIGEgbmV3IHZlcnNpb24gb2YKK3RoZSBBZ3JlZW1lbnQgaXMgcHVibGlzaGVkLCBDb250cmlidXRvciBtYXkgZWxlY3QgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbSAoaW5jbHVkaW5nIGl0cyBDb250cmlidXRpb25zKSB1bmRlciB0aGUKK25ldyB2ZXJzaW9uLiBFeGNlcHQgYXMgZXhwcmVzc2x5IHN0YXRlZCBpbiBTZWN0aW9ucyAyKGEpIGFuZCAyKGIpIGFib3ZlLCBSZWNpcGllbnQgcmVjZWl2ZXMgbm8gcmlnaHRzIG9yIGxpY2Vuc2VzIHRvCit0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IG9mIGFueSBDb250cmlidXRvciB1bmRlciB0aGlzIEFncmVlbWVudCwgd2hldGhlciBleHByZXNzbHksIGJ5IGltcGxpY2F0aW9uLCBlc3RvcHBlbCBvcgorb3RoZXJ3aXNlLiBBbGwgcmlnaHRzIGluIHRoZSBQcm9ncmFtIG5vdCBleHByZXNzbHkgZ3JhbnRlZCB1bmRlciB0aGlzIEFncmVlbWVudCBhcmUgcmVzZXJ2ZWQuCisKK1RoaXMgQWdyZWVtZW50IGlzIGdvdmVybmVkIGJ5IHRoZSBsYXdzIG9mIHRoZSBTdGF0ZSBvZiBOZXcgWW9yayBhbmQgdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBsYXdzIG9mIHRoZSBVbml0ZWQgU3RhdGVzCitvZiBBbWVyaWNhLiBObyBwYXJ0eSB0byB0aGlzIEFncmVlbWVudCB3aWxsIGJyaW5nIGEgbGVnYWwgYWN0aW9uIHVuZGVyIHRoaXMgQWdyZWVtZW50IG1vcmUgdGhhbiBvbmUgeWVhciBhZnRlciB0aGUgY2F1c2UKK29mIGFjdGlvbiBhcm9zZS4gRWFjaCBwYXJ0eSB3YWl2ZXMgaXRzIHJpZ2h0cyB0byBhIGp1cnkgdHJpYWwgaW4gYW55IHJlc3VsdGluZyBsaXRpZ2F0aW9uLgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL1JFQURNRS5tZCBiL1JFQURNRS5tZApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lNjlkZTI5Ci0tLSAvZGV2L251bGwKKysrIGIvUkVBRE1FLm1kCmRpZmYgLS1naXQgYS9hYm91dC5odG1sIGIvYWJvdXQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NGMwNTk4Ci0tLSAvZGV2L251bGwKKysrIGIvYWJvdXQuaHRtbApAQCAtMCwwICsxLDI4IEBACis8IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBTdHJpY3QvL0VOIgorICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS1zdHJpY3QuZHRkIj4KKzxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIj4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9SVNPLTg4NTktMSIvPgorPHRpdGxlPkFib3V0PC90aXRsZT4KKzwvaGVhZD4KKzxib2R5IGxhbmc9IkVOLVVTIj4KKzxoMj5BYm91dCBUaGlzIENvbnRlbnQ8L2gyPgorIAorPHA+SnVuZSAxLCAyMDE2PC9wPgkKKzxoMz5MaWNlbnNlPC9oMz4KKworPHA+VGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYWtlcyBhdmFpbGFibGUgYWxsIGNvbnRlbnQgaW4gdGhpcyBwbHVnLWluICgmcXVvdDtDb250ZW50JnF1b3Q7KS4gIFVubGVzcyBvdGhlcndpc2UgCitpbmRpY2F0ZWQgYmVsb3csIHRoZSBDb250ZW50IGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlCitFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wICgmcXVvdDtFUEwmcXVvdDspLiAgQSBjb3B5IG9mIHRoZSBFUEwgaXMgYXZhaWxhYmxlIAorYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sPC9hPi4KK0ZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAmcXVvdDtQcm9ncmFtJnF1b3Q7IHdpbGwgbWVhbiB0aGUgQ29udGVudC48L3A+CisKKzxwPklmIHlvdSBkaWQgbm90IHJlY2VpdmUgdGhpcyBDb250ZW50IGRpcmVjdGx5IGZyb20gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiwgdGhlIENvbnRlbnQgaXMgCitiZWluZyByZWRpc3RyaWJ1dGVkIGJ5IGFub3RoZXIgcGFydHkgKCZxdW90O1JlZGlzdHJpYnV0b3ImcXVvdDspIGFuZCBkaWZmZXJlbnQgdGVybXMgYW5kIGNvbmRpdGlvbnMgbWF5CithcHBseSB0byB5b3VyIHVzZSBvZiBhbnkgb2JqZWN0IGNvZGUgaW4gdGhlIENvbnRlbnQuICBDaGVjayB0aGUgUmVkaXN0cmlidXRvcidzIGxpY2Vuc2UgdGhhdCB3YXMgCitwcm92aWRlZCB3aXRoIHRoZSBDb250ZW50LiAgSWYgbm8gc3VjaCBsaWNlbnNlIGV4aXN0cywgY29udGFjdCB0aGUgUmVkaXN0cmlidXRvci4gIFVubGVzcyBvdGhlcndpc2UKK2luZGljYXRlZCBiZWxvdywgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFUEwgc3RpbGwgYXBwbHkgdG8gYW55IHNvdXJjZSBjb2RlIGluIHRoZSBDb250ZW50CithbmQgc3VjaCBzb3VyY2UgY29kZSBtYXkgYmUgb2J0YWluZWQgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy8iPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmc8L2E+LjwvcD4KKworPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2plbmtpbnMuYnVpbGQuY29uZmlnLnhtbCBiL2plbmtpbnMuYnVpbGQuY29uZmlnLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zMmQ1MzVkCi0tLSAvZGV2L251bGwKKysrIGIvamVua2lucy5idWlsZC5jb25maWcueG1sCkBAIC0wLDAgKzEsMjEgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorPCEtLSMgQ29weXJpZ2h0IChjKSAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0tPgorPCEtLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAJCSAtLT4KKzwhLS0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAgLS0+Cis8IS0tIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAgICAgICAgICAgICAgIC0tPgorPCEtLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAtLT4KKzwhLS0jICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLS0+Cis8IS0tIyBDb250cmlidXRvcnM6ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0tPgorPCEtLSMgQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24gICAgICAgICAgICAgICAgICAgICAgICAgICAtLT4KKzwhLS0jPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gLS0+Cis8IS0tIyBNb2R1bGUgc3BlY2lmaWMgcGFyYW1ldGVycyBmb3IgdGhlIEplbmtpbnMgSm9iIAkJCQkJCSAtLT4KKzwhLS0jPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gLS0+CisKKzxqZW5raW5zPgorCTwhLS0gRE8gTk9UIEVESVQgQkVMT1cgVEhJUyBMSU5FIC0tPgorICAgICAgICA8amVua2lucy5idWlsZC5kZXBlbmRlbmNpZXM+CisgICAgICAgICAgICAgICAgPGplbmtpbnMuYnVpbGQuZGVwZW5kZW5jeT5vcmcuZWNsaXBzZS5vc2JwLmRzbDwvamVua2lucy5idWlsZC5kZXBlbmRlbmN5PgorICAgICAgICAgICAgICAgIDxqZW5raW5zLmJ1aWxkLmRlcGVuZGVuY3k+b3JnLmVjbGlwc2Uub3NicC5lY3ZpZXcuY29yZTwvamVua2lucy5idWlsZC5kZXBlbmRlbmN5PgorICAgICAgICA8L2plbmtpbnMuYnVpbGQuZGVwZW5kZW5jaWVzPgorPC9qZW5raW5zPgpkaWZmIC0tZ2l0IGEvbm90aWNlLmh0bWwgYi9ub3RpY2UuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jM2QzNGMzCi0tLSAvZGV2L251bGwKKysrIGIvbm90aWNlLmh0bWwKQEAgLTAsMCArMSwxMDcgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IklTTy04ODU5LTEiID8+Cis8IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBTdHJpY3QvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtc3RyaWN0LmR0ZCI+Cis8aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+Cis8aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiIC8+Cis8dGl0bGU+RWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC90aXRsZT4KKzwvaGVhZD4KKworPGJvZHkgbGFuZz0iRU4tVVMiPgorPGgyPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvaDI+Cis8cD5BcHJpbCA5LCAyMDE0PC9wPgorCis8aDM+VXNhZ2UgT2YgQ29udGVudDwvaDM+CisKKzxwPlRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiBBTkQvT1IgT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUworICAgKENPTExFQ1RJVkVMWSAmcXVvdDtDT05URU5UJnF1b3Q7KS4gIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQKKyAgIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VIEFHUkVFIFRIQVQgWU9VUiBVU0UKKyAgIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SCisgICBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQKKyAgIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULjwvcD4KKworPGgzPkFwcGxpY2FibGUgTGljZW5zZXM8L2gzPgorCis8cD5Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wCisgICAoJnF1b3Q7RVBMJnF1b3Q7KS4gIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpcyBDb250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L2E+LgorICAgRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICZxdW90O1Byb2dyYW0mcXVvdDsgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvcD4KKworPHA+Q29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsIGRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBzb3VyY2UgY29kZQorICAgcmVwb3NpdG9yeSAoJnF1b3Q7UmVwb3NpdG9yeSZxdW90OykgaW4gc29mdHdhcmUgbW9kdWxlcyAoJnF1b3Q7TW9kdWxlcyZxdW90OykgYW5kIG1hZGUgYXZhaWxhYmxlIGFzIGRvd25sb2FkYWJsZSBhcmNoaXZlcyAoJnF1b3Q7RG93bmxvYWRzJnF1b3Q7KS48L3A+CisKKzx1bD4KKyAgICAgICA8bGk+Q29udGVudCBtYXkgYmUgc3RydWN0dXJlZCBhbmQgcGFja2FnZWQgaW50byBtb2R1bGVzIHRvIGZhY2lsaXRhdGUgZGVsaXZlcmluZywgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiAgVHlwaWNhbCBtb2R1bGVzIG1heSBpbmNsdWRlIHBsdWctaW5zICgmcXVvdDtQbHVnLWlucyZxdW90OyksIHBsdWctaW4gZnJhZ21lbnRzICgmcXVvdDtGcmFnbWVudHMmcXVvdDspLCBhbmQgZmVhdHVyZXMgKCZxdW90O0ZlYXR1cmVzJnF1b3Q7KS48L2xpPgorICAgICAgIDxsaT5FYWNoIFBsdWctaW4gb3IgRnJhZ21lbnQgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBvciBKQVIgKEphdmEmdHJhZGU7IEFSY2hpdmUpIGluIGEgZGlyZWN0b3J5IG5hbWVkICZxdW90O3BsdWdpbnMmcXVvdDsuPC9saT4KKyAgICAgICA8bGk+QSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuICBFYWNoIEZlYXR1cmUgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtmZWF0dXJlcyZxdW90Oy4gIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUueG1sJnF1b3Q7IG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMKKyAgICAgIGFuZC9vciBGcmFnbWVudHMgYXNzb2NpYXRlZCB3aXRoIHRoYXQgRmVhdHVyZS48L2xpPgorICAgICAgIDxsaT5GZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgmcXVvdDtJbmNsdWRlZCBGZWF0dXJlcyZxdW90OykuIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUueG1sJnF1b3Q7IG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy48L2xpPgorPC91bD4KKworPHA+VGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZSBjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgJnF1b3Q7YWJvdXQuaHRtbCZxdW90OyAoJnF1b3Q7QWJvdXRzJnF1b3Q7KS4gVGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBGZWF0dXJlcyBhbmQKK0luY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgJnF1b3Q7bGljZW5zZS5odG1sJnF1b3Q7ICgmcXVvdDtGZWF0dXJlIExpY2Vuc2VzJnF1b3Q7KS4gIEFib3V0cyBhbmQgRmVhdHVyZSBMaWNlbnNlcyBtYXkgYmUgbG9jYXRlZCBpbiBhbnkgZGlyZWN0b3J5IG9mIGEgRG93bmxvYWQgb3IgTW9kdWxlCitpbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIGxvY2F0aW9uczo8L3A+CisKKzx1bD4KKyAgICAgICA8bGk+VGhlIHRvcC1sZXZlbCAocm9vdCkgZGlyZWN0b3J5PC9saT4KKyAgICAgICA8bGk+UGx1Zy1pbiBhbmQgRnJhZ21lbnQgZGlyZWN0b3JpZXM8L2xpPgorICAgICAgIDxsaT5JbnNpZGUgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBwYWNrYWdlZCBhcyBKQVJzPC9saT4KKyAgICAgICA8bGk+U3ViLWRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgJnF1b3Q7c3JjJnF1b3Q7IG9mIGNlcnRhaW4gUGx1Zy1pbnM8L2xpPgorICAgICAgIDxsaT5GZWF0dXJlIGRpcmVjdG9yaWVzPC9saT4KKzwvdWw+CisKKzxwPk5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIGluc3RhbGxlZCB1c2luZyB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgKGFzIGRlZmluZWQgYmVsb3cpLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCZxdW90O0ZlYXR1cmUgVXBkYXRlIExpY2Vuc2UmcXVvdDspIGR1cmluZyB0aGUKK2luc3RhbGxhdGlvbiBwcm9jZXNzLiAgSWYgdGhlIEZlYXR1cmUgY29udGFpbnMgSW5jbHVkZWQgRmVhdHVyZXMsIHRoZSBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIHNob3VsZCBlaXRoZXIgcHJvdmlkZSB5b3Ugd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvcgoraW5mb3JtIHlvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiAgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgbWF5IGJlIGZvdW5kIGluIHRoZSAmcXVvdDtsaWNlbnNlJnF1b3Q7IHByb3BlcnR5IG9mIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUucHJvcGVydGllcyZxdW90OyBmb3VuZCB3aXRoaW4gYSBGZWF0dXJlLgorU3VjaCBBYm91dHMsIEZlYXR1cmUgTGljZW5zZXMsIGFuZCBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBjb250YWluIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyAob3IgcmVmZXJlbmNlcyB0byBzdWNoIHRlcm1zIGFuZCBjb25kaXRpb25zKSB0aGF0IGdvdmVybiB5b3VyIHVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluCit0aGF0IGRpcmVjdG9yeS48L3A+CisKKzxwPlRIRSBBQk9VVFMsIEZFQVRVUkUgTElDRU5TRVMsIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVIgVE8gVEhFIEVQTCBPUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuICBTT01FIE9GIFRIRVNFCitPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOjwvcD4KKworPHVsPgorICAgICAgIDxsaT5FY2xpcHNlIERpc3RyaWJ1dGlvbiBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9saWNlbnNlcy9lZGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGljZW5zZXMvZWRsLXYxLjAuaHRtbDwvYT4pPC9saT4KKyAgICAgICA8bGk+Q29tbW9uIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sPC9hPik8L2xpPgorICAgICAgIDxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAxLjEgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRSI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0U8L2E+KTwvbGk+CisgICAgICAgPGxpPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDIuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMCI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wPC9hPik8L2xpPgorICAgICAgIDxsaT5Nb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sIj5odHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWw8L2E+KTwvbGk+Cis8L3VsPgorCis8cD5JVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCBDT05ESVRJT05TIFBSSU9SIFRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2UsIG9yIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2UgaXMgcHJvdmlkZWQsIHBsZWFzZQorY29udGFjdCB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHRvIGRldGVybWluZSB3aGF0IHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC48L3A+CisKKworPGgzPlVzZSBvZiBQcm92aXNpb25pbmcgVGVjaG5vbG9neTwvaDM+CisKKzxwPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIHByb3Zpc2lvbmluZyBzb2Z0d2FyZSwgZXhhbXBsZXMgb2Ygd2hpY2ggaW5jbHVkZSwgYnV0IGFyZSBub3QgbGltaXRlZCB0bywgcDIgYW5kIHRoZSBFY2xpcHNlCisgICBVcGRhdGUgTWFuYWdlciAoJnF1b3Q7UHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kmcXVvdDspIGZvciB0aGUgcHVycG9zZSBvZiBhbGxvd2luZyB1c2VycyB0byBpbnN0YWxsIHNvZnR3YXJlLCBkb2N1bWVudGF0aW9uLCBpbmZvcm1hdGlvbiBhbmQvb3IKKyAgIG90aGVyIG1hdGVyaWFscyAoY29sbGVjdGl2ZWx5ICZxdW90O0luc3RhbGxhYmxlIFNvZnR3YXJlJnF1b3Q7KS4gVGhpcyBjYXBhYmlsaXR5IGlzIHByb3ZpZGVkIHdpdGggdGhlIGludGVudCBvZiBhbGxvd2luZyBzdWNoIHVzZXJzIHRvCisgICBpbnN0YWxsLCBleHRlbmQgYW5kIHVwZGF0ZSBFY2xpcHNlLWJhc2VkIHByb2R1Y3RzLiBJbmZvcm1hdGlvbiBhYm91dCBwYWNrYWdpbmcgSW5zdGFsbGFibGUgU29mdHdhcmUgaXMgYXZhaWxhYmxlIGF0IDxhCisgICAgICAgaHJlZj0iaHR0cDovL2VjbGlwc2Uub3JnL2VxdWlub3gvcDIvcmVwb3NpdG9yeV9wYWNrYWdpbmcuaHRtbCI+aHR0cDovL2VjbGlwc2Uub3JnL2VxdWlub3gvcDIvcmVwb3NpdG9yeV9wYWNrYWdpbmcuaHRtbDwvYT4KKyAgICgmcXVvdDtTcGVjaWZpY2F0aW9uJnF1b3Q7KS48L3A+CisKKzxwPllvdSBtYXkgdXNlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IHRvIGFsbG93IG90aGVyIHBhcnRpZXMgdG8gaW5zdGFsbCBJbnN0YWxsYWJsZSBTb2Z0d2FyZS4gWW91IHNoYWxsIGJlIHJlc3BvbnNpYmxlIGZvciBlbmFibGluZyB0aGUKKyAgIGFwcGxpY2FibGUgbGljZW5zZSBhZ3JlZW1lbnRzIHJlbGF0aW5nIHRvIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSB0byBiZSBwcmVzZW50ZWQgdG8sIGFuZCBhY2NlcHRlZCBieSwgdGhlIHVzZXJzIG9mIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neQorICAgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBTcGVjaWZpY2F0aW9uLiBCeSB1c2luZyBQcm92aXNpb25pbmcgVGVjaG5vbG9neSBpbiBzdWNoIGEgbWFubmVyIGFuZCBtYWtpbmcgaXQgYXZhaWxhYmxlIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUKKyAgIFNwZWNpZmljYXRpb24sIHlvdSBmdXJ0aGVyIGFja25vd2xlZGdlIHlvdXIgYWdyZWVtZW50IHRvLCBhbmQgdGhlIGFjcXVpc2l0aW9uIG9mIGFsbCBuZWNlc3NhcnkgcmlnaHRzIHRvIHBlcm1pdCB0aGUgZm9sbG93aW5nOjwvcD4KKworPG9sPgorICAgICAgIDxsaT5BIHNlcmllcyBvZiBhY3Rpb25zIG1heSBvY2N1ciAoJnF1b3Q7UHJvdmlzaW9uaW5nIFByb2Nlc3MmcXVvdDspIGluIHdoaWNoIGEgdXNlciBtYXkgZXhlY3V0ZSB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kKKyAgICAgICBvbiBhIG1hY2hpbmUgKCZxdW90O1RhcmdldCBNYWNoaW5lJnF1b3Q7KSB3aXRoIHRoZSBpbnRlbnQgb2YgaW5zdGFsbGluZywgZXh0ZW5kaW5nIG9yIHVwZGF0aW5nIHRoZSBmdW5jdGlvbmFsaXR5IG9mIGFuIEVjbGlwc2UtYmFzZWQKKyAgICAgICBwcm9kdWN0LjwvbGk+CisgICAgICAgPGxpPkR1cmluZyB0aGUgUHJvdmlzaW9uaW5nIFByb2Nlc3MsIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSBtYXkgY2F1c2UgdGhpcmQgcGFydHkgSW5zdGFsbGFibGUgU29mdHdhcmUgb3IgYSBwb3J0aW9uIHRoZXJlb2YgdG8gYmUKKyAgICAgICBhY2Nlc3NlZCBhbmQgY29waWVkIHRvIHRoZSBUYXJnZXQgTWFjaGluZS48L2xpPgorICAgICAgIDxsaT5QdXJzdWFudCB0byB0aGUgU3BlY2lmaWNhdGlvbiwgeW91IHdpbGwgcHJvdmlkZSB0byB0aGUgdXNlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgdGhhdCBnb3Zlcm4gdGhlIHVzZSBvZiB0aGUgSW5zdGFsbGFibGUKKyAgICAgICBTb2Z0d2FyZSAoJnF1b3Q7SW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50JnF1b3Q7KSBhbmQgc3VjaCBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQgc2hhbGwgYmUgYWNjZXNzZWQgZnJvbSB0aGUgVGFyZ2V0CisgICAgICAgTWFjaGluZSBpbiBhY2NvcmRhbmNlIHdpdGggdGhlIFNwZWNpZmljYXRpb24uIFN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50IG11c3QgaW5mb3JtIHRoZSB1c2VyIG9mIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyB0aGF0IGdvdmVybgorICAgICAgIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBhbmQgbXVzdCBzb2xpY2l0IGFjY2VwdGFuY2UgYnkgdGhlIGVuZCB1c2VyIGluIHRoZSBtYW5uZXIgcHJlc2NyaWJlZCBpbiBzdWNoIEluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudC4gVXBvbiBzdWNoCisgICAgICAgaW5kaWNhdGlvbiBvZiBhZ3JlZW1lbnQgYnkgdGhlIHVzZXIsIHRoZSBwcm92aXNpb25pbmcgVGVjaG5vbG9neSB3aWxsIGNvbXBsZXRlIGluc3RhbGxhdGlvbiBvZiB0aGUgSW5zdGFsbGFibGUgU29mdHdhcmUuPC9saT4KKzwvb2w+CisKKzxoMz5DcnlwdG9ncmFwaHk8L2gzPgorCis8cD5Db250ZW50IG1heSBjb250YWluIGVuY3J5cHRpb24gc29mdHdhcmUuIFRoZSBjb3VudHJ5IGluIHdoaWNoIHlvdSBhcmUgY3VycmVudGx5IG1heSBoYXZlIHJlc3RyaWN0aW9ucyBvbiB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBhbmQgdXNlLCBhbmQvb3IgcmUtZXhwb3J0IHRvCisgICBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRSB1c2luZyBhbnkgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cywgcmVndWxhdGlvbnMgYW5kIHBvbGljaWVzIGNvbmNlcm5pbmcgdGhlIGltcG9ydCwKKyAgIHBvc3Nlc3Npb24sIG9yIHVzZSwgYW5kIHJlLWV4cG9ydCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLCB0byBzZWUgaWYgdGhpcyBpcyBwZXJtaXR0ZWQuPC9wPgorCis8cD48c21hbGw+SmF2YSBhbmQgYWxsIEphdmEtYmFzZWQgdHJhZGVtYXJrcyBhcmUgdHJhZGVtYXJrcyBvZiBPcmFjbGUgQ29ycG9yYXRpb24gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC48L3NtYWxsPjwvcD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpLy5wcm9qZWN0IGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkvLnByb2plY3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDJiZDQzNgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpLy5wcm9qZWN0CkBAIC0wLDAgKzEsNTEgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8cHJvamVjdERlc2NyaXB0aW9uPgorCTxuYW1lPm9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpPC9uYW1lPgorCTxjb21tZW50PjwvY29tbWVudD4KKwk8cHJvamVjdHM+CisJPC9wcm9qZWN0cz4KKwk8YnVpbGRTcGVjPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UueHRleHQudWkuc2hhcmVkLnh0ZXh0QnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5qZHQuY29yZS5qYXZhYnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuTWFuaWZlc3RCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5TY2hlbWFCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLmJhYmVsLmVkaXRvci5yYmVCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5zb25hcmxpbnQuZWNsaXBzZS5jb3JlLnNvbmFybGludEJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UubTJlLmNvcmUubWF2ZW4yQnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJPC9idWlsZFNwZWM+CisJPG5hdHVyZXM+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UueHRleHQudWkuc2hhcmVkLnh0ZXh0TmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UubTJlLmNvcmUubWF2ZW4yTmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UucGRlLlBsdWdpbk5hdHVyZTwvbmF0dXJlPgorCQk8bmF0dXJlPm9yZy5lY2xpcHNlLmpkdC5jb3JlLmphdmFuYXR1cmU8L25hdHVyZT4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS5iYWJlbC5lZGl0b3IucmJlTmF0dXJlPC9uYXR1cmU+CisJPC9uYXR1cmVzPgorPC9wcm9qZWN0RGVzY3JpcHRpb24+CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS9MSUNFTlNFLnR4dCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpL0xJQ0VOU0UudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmZmNDJhZDQKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS9MSUNFTlNFLnR4dApAQCAtMCwwICsxLDE2MSBAQAorRWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtdiAxLjAKKworVEhFIEFDQ09NUEFOWUlORyBQUk9HUkFNIElTIFBST1ZJREVEIFVOREVSIFRIRSBURVJNUyBPRiBUSElTIEVDTElQU0UgUFVCTElDIExJQ0VOU0UgKCJBR1JFRU1FTlQiKS4gQU5ZIFVTRSwgUkVQUk9EVUNUSU9OCitPUiBESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gQ09OU1RJVFVURVMgUkVDSVBJRU5UJ1MgQUNDRVBUQU5DRSBPRiBUSElTIEFHUkVFTUVOVC4KKworMS4gREVGSU5JVElPTlMKKworIkNvbnRyaWJ1dGlvbiIgbWVhbnM6CisKK2EpIGluIHRoZSBjYXNlIG9mIHRoZSBpbml0aWFsIENvbnRyaWJ1dG9yLCB0aGUgaW5pdGlhbCBjb2RlIGFuZCBkb2N1bWVudGF0aW9uIGRpc3RyaWJ1dGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBhbmQKKworYikgaW4gdGhlIGNhc2Ugb2YgZWFjaCBzdWJzZXF1ZW50IENvbnRyaWJ1dG9yOgorCitpKSBjaGFuZ2VzIHRvIHRoZSBQcm9ncmFtLCBhbmQKKworaWkpIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbTsKKword2hlcmUgc3VjaCBjaGFuZ2VzIGFuZC9vciBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gb3JpZ2luYXRlIGZyb20gYW5kIGFyZSBkaXN0cmlidXRlZCBieSB0aGF0IHBhcnRpY3VsYXIgQ29udHJpYnV0b3IuCitBIENvbnRyaWJ1dGlvbiAnb3JpZ2luYXRlcycgZnJvbSBhIENvbnRyaWJ1dG9yIGlmIGl0IHdhcyBhZGRlZCB0byB0aGUgUHJvZ3JhbSBieSBzdWNoIENvbnRyaWJ1dG9yIGl0c2VsZiBvciBhbnlvbmUKK2FjdGluZyBvbiBzdWNoIENvbnRyaWJ1dG9yJ3MgYmVoYWxmLiBDb250cmlidXRpb25zIGRvIG5vdCBpbmNsdWRlIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbSB3aGljaDogKGkpIGFyZSBzZXBhcmF0ZQorbW9kdWxlcyBvZiBzb2Z0d2FyZSBkaXN0cmlidXRlZCBpbiBjb25qdW5jdGlvbiB3aXRoIHRoZSBQcm9ncmFtIHVuZGVyIHRoZWlyIG93biBsaWNlbnNlIGFncmVlbWVudCwgYW5kIChpaSkgYXJlIG5vdAorZGVyaXZhdGl2ZSB3b3JrcyBvZiB0aGUgUHJvZ3JhbS4KKworIkNvbnRyaWJ1dG9yIiBtZWFucyBhbnkgcGVyc29uIG9yIGVudGl0eSB0aGF0IGRpc3RyaWJ1dGVzIHRoZSBQcm9ncmFtLgorCisiTGljZW5zZWQgUGF0ZW50cyAiIG1lYW4gcGF0ZW50IGNsYWltcyBsaWNlbnNhYmxlIGJ5IGEgQ29udHJpYnV0b3Igd2hpY2ggYXJlIG5lY2Vzc2FyaWx5IGluZnJpbmdlZCBieSB0aGUgdXNlIG9yIHNhbGUgb2YKK2l0cyBDb250cmlidXRpb24gYWxvbmUgb3Igd2hlbiBjb21iaW5lZCB3aXRoIHRoZSBQcm9ncmFtLgorCisiUHJvZ3JhbSIgbWVhbnMgdGhlIENvbnRyaWJ1dGlvbnMgZGlzdHJpYnV0ZWQgaW4gYWNjb3JkYW5jZSB3aXRoIHRoaXMgQWdyZWVtZW50LgorCisiUmVjaXBpZW50IiBtZWFucyBhbnlvbmUgd2hvIHJlY2VpdmVzIHRoZSBQcm9ncmFtIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBpbmNsdWRpbmcgYWxsIENvbnRyaWJ1dG9ycy4KKworMi4gR1JBTlQgT0YgUklHSFRTCisKK2EpIFN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLAorcm95YWx0eS1mcmVlIGNvcHlyaWdodCBsaWNlbnNlIHRvIHJlcHJvZHVjZSwgcHJlcGFyZSBkZXJpdmF0aXZlIHdvcmtzIG9mLCBwdWJsaWNseSBkaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBkaXN0cmlidXRlCithbmQgc3VibGljZW5zZSB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgYW5kIHN1Y2ggZGVyaXZhdGl2ZSB3b3JrcywgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlCitmb3JtLgorCitiKSBTdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwKK3JveWFsdHktZnJlZSBwYXRlbnQgbGljZW5zZSB1bmRlciBMaWNlbnNlZCBQYXRlbnRzIHRvIG1ha2UsIHVzZSwgc2VsbCwgb2ZmZXIgdG8gc2VsbCwgaW1wb3J0IGFuZCBvdGhlcndpc2UgdHJhbnNmZXIgdGhlCitDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUgZm9ybS4gVGhpcyBwYXRlbnQgbGljZW5zZSBzaGFsbCBhcHBseSB0byB0aGUKK2NvbWJpbmF0aW9uIG9mIHRoZSBDb250cmlidXRpb24gYW5kIHRoZSBQcm9ncmFtIGlmLCBhdCB0aGUgdGltZSB0aGUgQ29udHJpYnV0aW9uIGlzIGFkZGVkIGJ5IHRoZSBDb250cmlidXRvciwgc3VjaAorYWRkaXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBjYXVzZXMgc3VjaCBjb21iaW5hdGlvbiB0byBiZSBjb3ZlcmVkIGJ5IHRoZSBMaWNlbnNlZCBQYXRlbnRzLiBUaGUgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgbm90CithcHBseSB0byBhbnkgb3RoZXIgY29tYmluYXRpb25zIHdoaWNoIGluY2x1ZGUgdGhlIENvbnRyaWJ1dGlvbi4gTm8gaGFyZHdhcmUgcGVyIHNlIGlzIGxpY2Vuc2VkIGhlcmV1bmRlci4KKworYykgUmVjaXBpZW50IHVuZGVyc3RhbmRzIHRoYXQgYWx0aG91Z2ggZWFjaCBDb250cmlidXRvciBncmFudHMgdGhlIGxpY2Vuc2VzIHRvIGl0cyBDb250cmlidXRpb25zIHNldCBmb3J0aCBoZXJlaW4sIG5vCithc3N1cmFuY2VzIGFyZSBwcm92aWRlZCBieSBhbnkgQ29udHJpYnV0b3IgdGhhdCB0aGUgUHJvZ3JhbSBkb2VzIG5vdCBpbmZyaW5nZSB0aGUgcGF0ZW50IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQorcmlnaHRzIG9mIGFueSBvdGhlciBlbnRpdHkuIEVhY2ggQ29udHJpYnV0b3IgZGlzY2xhaW1zIGFueSBsaWFiaWxpdHkgdG8gUmVjaXBpZW50IGZvciBjbGFpbXMgYnJvdWdodCBieSBhbnkgb3RoZXIgZW50aXR5CitiYXNlZCBvbiBpbmZyaW5nZW1lbnQgb2YgaW50ZWxsZWN0dWFsIHByb3BlcnR5IHJpZ2h0cyBvciBvdGhlcndpc2UuIEFzIGEgY29uZGl0aW9uIHRvIGV4ZXJjaXNpbmcgdGhlIHJpZ2h0cyBhbmQKK2xpY2Vuc2VzIGdyYW50ZWQgaGVyZXVuZGVyLCBlYWNoIFJlY2lwaWVudCBoZXJlYnkgYXNzdW1lcyBzb2xlIHJlc3BvbnNpYmlsaXR5IHRvIHNlY3VyZSBhbnkgb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5CityaWdodHMgbmVlZGVkLCBpZiBhbnkuIEZvciBleGFtcGxlLCBpZiBhIHRoaXJkIHBhcnR5IHBhdGVudCBsaWNlbnNlIGlzIHJlcXVpcmVkIHRvIGFsbG93IFJlY2lwaWVudCB0byBkaXN0cmlidXRlIHRoZQorUHJvZ3JhbSwgaXQgaXMgUmVjaXBpZW50J3MgcmVzcG9uc2liaWxpdHkgdG8gYWNxdWlyZSB0aGF0IGxpY2Vuc2UgYmVmb3JlIGRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbS4KKworZCkgRWFjaCBDb250cmlidXRvciByZXByZXNlbnRzIHRoYXQgdG8gaXRzIGtub3dsZWRnZSBpdCBoYXMgc3VmZmljaWVudCBjb3B5cmlnaHQgcmlnaHRzIGluIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgdG8KK2dyYW50IHRoZSBjb3B5cmlnaHQgbGljZW5zZSBzZXQgZm9ydGggaW4gdGhpcyBBZ3JlZW1lbnQuCisKKzMuIFJFUVVJUkVNRU5UUworCitBIENvbnRyaWJ1dG9yIG1heSBjaG9vc2UgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbSBpbiBvYmplY3QgY29kZSBmb3JtIHVuZGVyIGl0cyBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIHByb3ZpZGVkIHRoYXQ6CisKK2EpIGl0IGNvbXBsaWVzIHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50OyBhbmQKKworYikgaXRzIGxpY2Vuc2UgYWdyZWVtZW50OgorCitpKSBlZmZlY3RpdmVseSBkaXNjbGFpbXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIHdhcnJhbnRpZXMgYW5kIGNvbmRpdGlvbnMsIGV4cHJlc3MgYW5kIGltcGxpZWQsIGluY2x1ZGluZword2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIHRpdGxlIGFuZCBub24taW5mcmluZ2VtZW50LCBhbmQgaW1wbGllZCB3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgbWVyY2hhbnRhYmlsaXR5IGFuZAorZml0bmVzcyBmb3IgYSBwYXJ0aWN1bGFyIHB1cnBvc2U7CisKK2lpKSBlZmZlY3RpdmVseSBleGNsdWRlcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgbGlhYmlsaXR5IGZvciBkYW1hZ2VzLCBpbmNsdWRpbmcgZGlyZWN0LCBpbmRpcmVjdCwgc3BlY2lhbCwKK2luY2lkZW50YWwgYW5kIGNvbnNlcXVlbnRpYWwgZGFtYWdlcywgc3VjaCBhcyBsb3N0IHByb2ZpdHM7CisKK2lpaSkgc3RhdGVzIHRoYXQgYW55IHByb3Zpc2lvbnMgd2hpY2ggZGlmZmVyIGZyb20gdGhpcyBBZ3JlZW1lbnQgYXJlIG9mZmVyZWQgYnkgdGhhdCBDb250cmlidXRvciBhbG9uZSBhbmQgbm90IGJ5IGFueQorb3RoZXIgcGFydHk7IGFuZAorCitpdikgc3RhdGVzIHRoYXQgc291cmNlIGNvZGUgZm9yIHRoZSBQcm9ncmFtIGlzIGF2YWlsYWJsZSBmcm9tIHN1Y2ggQ29udHJpYnV0b3IsIGFuZCBpbmZvcm1zIGxpY2Vuc2VlcyBob3cgdG8gb2J0YWluIGl0CitpbiBhIHJlYXNvbmFibGUgbWFubmVyIG9uIG9yIHRocm91Z2ggYSBtZWRpdW0gY3VzdG9tYXJpbHkgdXNlZCBmb3Igc29mdHdhcmUgZXhjaGFuZ2UuCisKK1doZW4gdGhlIFByb2dyYW0gaXMgbWFkZSBhdmFpbGFibGUgaW4gc291cmNlIGNvZGUgZm9ybToKKworYSkgaXQgbXVzdCBiZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGlzIEFncmVlbWVudDsgYW5kCisKK2IpIGEgY29weSBvZiB0aGlzIEFncmVlbWVudCBtdXN0IGJlIGluY2x1ZGVkIHdpdGggZWFjaCBjb3B5IG9mIHRoZSBQcm9ncmFtLgorCitDb250cmlidXRvcnMgbWF5IG5vdCByZW1vdmUgb3IgYWx0ZXIgYW55IGNvcHlyaWdodCBub3RpY2VzIGNvbnRhaW5lZCB3aXRoaW4gdGhlIFByb2dyYW0uCisKK0VhY2ggQ29udHJpYnV0b3IgbXVzdCBpZGVudGlmeSBpdHNlbGYgYXMgdGhlIG9yaWdpbmF0b3Igb2YgaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCBpbiBhIG1hbm5lciB0aGF0IHJlYXNvbmFibHkgYWxsb3dzCitzdWJzZXF1ZW50IFJlY2lwaWVudHMgdG8gaWRlbnRpZnkgdGhlIG9yaWdpbmF0b3Igb2YgdGhlIENvbnRyaWJ1dGlvbi4KKworNC4gQ09NTUVSQ0lBTCBESVNUUklCVVRJT04KKworQ29tbWVyY2lhbCBkaXN0cmlidXRvcnMgb2Ygc29mdHdhcmUgbWF5IGFjY2VwdCBjZXJ0YWluIHJlc3BvbnNpYmlsaXRpZXMgd2l0aCByZXNwZWN0IHRvIGVuZCB1c2VycywgYnVzaW5lc3MgcGFydG5lcnMgYW5kCit0aGUgbGlrZS4gV2hpbGUgdGhpcyBsaWNlbnNlIGlzIGludGVuZGVkIHRvIGZhY2lsaXRhdGUgdGhlIGNvbW1lcmNpYWwgdXNlIG9mIHRoZSBQcm9ncmFtLCB0aGUgQ29udHJpYnV0b3Igd2hvIGluY2x1ZGVzCit0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZyBzaG91bGQgZG8gc28gaW4gYSBtYW5uZXIgd2hpY2ggZG9lcyBub3QgY3JlYXRlIHBvdGVudGlhbCBsaWFiaWxpdHkgZm9yCitvdGhlciBDb250cmlidXRvcnMuIFRoZXJlZm9yZSwgaWYgYSBDb250cmlidXRvciBpbmNsdWRlcyB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgc3VjaCBDb250cmlidXRvcgorKCJDb21tZXJjaWFsIENvbnRyaWJ1dG9yIikgaGVyZWJ5IGFncmVlcyB0byBkZWZlbmQgYW5kIGluZGVtbmlmeSBldmVyeSBvdGhlciBDb250cmlidXRvciAoIkluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIikKK2FnYWluc3QgYW55IGxvc3NlcywgZGFtYWdlcyBhbmQgY29zdHMgKGNvbGxlY3RpdmVseSAiTG9zc2VzIikgYXJpc2luZyBmcm9tIGNsYWltcywgbGF3c3VpdHMgYW5kIG90aGVyIGxlZ2FsIGFjdGlvbnMKK2Jyb3VnaHQgYnkgYSB0aGlyZCBwYXJ0eSBhZ2FpbnN0IHRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciB0byB0aGUgZXh0ZW50IGNhdXNlZCBieSB0aGUgYWN0cyBvciBvbWlzc2lvbnMgb2Ygc3VjaAorQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiBjb25uZWN0aW9uIHdpdGggaXRzIGRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZy4gVGhlCitvYmxpZ2F0aW9ucyBpbiB0aGlzIHNlY3Rpb24gZG8gbm90IGFwcGx5IHRvIGFueSBjbGFpbXMgb3IgTG9zc2VzIHJlbGF0aW5nIHRvIGFueSBhY3R1YWwgb3IgYWxsZWdlZCBpbnRlbGxlY3R1YWwKK3Byb3BlcnR5IGluZnJpbmdlbWVudC4gSW4gb3JkZXIgdG8gcXVhbGlmeSwgYW4gSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbXVzdDogYSkgcHJvbXB0bHkgbm90aWZ5IHRoZSBDb21tZXJjaWFsCitDb250cmlidXRvciBpbiB3cml0aW5nIG9mIHN1Y2ggY2xhaW0sIGFuZCBiKSBhbGxvdyB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB0byBjb250cm9sLCBhbmQgY29vcGVyYXRlIHdpdGggdGhlCitDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluLCB0aGUgZGVmZW5zZSBhbmQgYW55IHJlbGF0ZWQgc2V0dGxlbWVudCBuZWdvdGlhdGlvbnMuIFRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciBtYXkKKyBwYXJ0aWNpcGF0ZSBpbiBhbnkgc3VjaCBjbGFpbSBhdCBpdHMgb3duIGV4cGVuc2UuCisKK0ZvciBleGFtcGxlLCBhIENvbnRyaWJ1dG9yIG1pZ2h0IGluY2x1ZGUgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIFByb2R1Y3QgWC4gVGhhdCBDb250cmlidXRvciBpcwordGhlbiBhIENvbW1lcmNpYWwgQ29udHJpYnV0b3IuIElmIHRoYXQgQ29tbWVyY2lhbCBDb250cmlidXRvciB0aGVuIG1ha2VzIHBlcmZvcm1hbmNlIGNsYWltcywgb3Igb2ZmZXJzIHdhcnJhbnRpZXMKK3JlbGF0ZWQgdG8gUHJvZHVjdCBYLCB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMgYXJlIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvcidzIHJlc3BvbnNpYmlsaXR5IGFsb25lLgorVW5kZXIgdGhpcyBzZWN0aW9uLCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB3b3VsZCBoYXZlIHRvIGRlZmVuZCBjbGFpbXMgYWdhaW5zdCB0aGUgb3RoZXIgQ29udHJpYnV0b3JzIHJlbGF0ZWQgdG8KK3Rob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcywgYW5kIGlmIGEgY291cnQgcmVxdWlyZXMgYW55IG90aGVyIENvbnRyaWJ1dG9yIHRvIHBheSBhbnkgZGFtYWdlcyBhcyBhIHJlc3VsdCwKK3RoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIG11c3QgcGF5IHRob3NlIGRhbWFnZXMuCisKKzUuIE5PIFdBUlJBTlRZCisKK0VYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMgQUdSRUVNRU5ULCBUSEUgUFJPR1JBTSBJUyBQUk9WSURFRCBPTiBBTiAiQVMgSVMiIEJBU0lTLCBXSVRIT1VUIFdBUlJBTlRJRVMgT1IKK0NPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIEVJVEhFUiBFWFBSRVNTIE9SIElNUExJRUQgSU5DTFVESU5HLCBXSVRIT1VUIExJTUlUQVRJT04sIEFOWSBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgVElUTEUsCitOT04tSU5GUklOR0VNRU5ULCBNRVJDSEFOVEFCSUxJVFkgT1IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIEVhY2ggUmVjaXBpZW50IGlzIHNvbGVseSByZXNwb25zaWJsZSBmb3IKK2RldGVybWluaW5nIHRoZSBhcHByb3ByaWF0ZW5lc3Mgb2YgdXNpbmcgYW5kIGRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbSBhbmQgYXNzdW1lcyBhbGwgcmlza3MgYXNzb2NpYXRlZCB3aXRoIGl0cworZXhlcmNpc2Ugb2YgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50ICwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgcmlza3MgYW5kIGNvc3RzIG9mIHByb2dyYW0gZXJyb3JzLCBjb21wbGlhbmNlCit3aXRoIGFwcGxpY2FibGUgbGF3cywgZGFtYWdlIHRvIG9yIGxvc3Mgb2YgZGF0YSwgcHJvZ3JhbXMgb3IgZXF1aXBtZW50LCBhbmQgdW5hdmFpbGFiaWxpdHkgb3IgaW50ZXJydXB0aW9uIG9mIG9wZXJhdGlvbnMuCisKKzYuIERJU0NMQUlNRVIgT0YgTElBQklMSVRZCisKK0VYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMgQUdSRUVNRU5ULCBORUlUSEVSIFJFQ0lQSUVOVCBOT1IgQU5ZIENPTlRSSUJVVE9SUyBTSEFMTCBIQVZFIEFOWSBMSUFCSUxJVFkgRk9SIEFOWQorRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORyBXSVRIT1VUIExJTUlUQVRJT04gTE9TVCBQUk9GSVRTKSwKK0hPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IKK09USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBPUiBUSEUgRVhFUkNJU0UgT0YgQU5ZIFJJR0hUUyBHUkFOVEVECitIRVJFVU5ERVIsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0VTLgorCis3LiBHRU5FUkFMCisKK0lmIGFueSBwcm92aXNpb24gb2YgdGhpcyBBZ3JlZW1lbnQgaXMgaW52YWxpZCBvciB1bmVuZm9yY2VhYmxlIHVuZGVyIGFwcGxpY2FibGUgbGF3LCBpdCBzaGFsbCBub3QgYWZmZWN0IHRoZSB2YWxpZGl0eSBvcgorZW5mb3JjZWFiaWxpdHkgb2YgdGhlIHJlbWFpbmRlciBvZiB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGFuZCB3aXRob3V0IGZ1cnRoZXIgYWN0aW9uIGJ5IHRoZSBwYXJ0aWVzIGhlcmV0bywgc3VjaAorcHJvdmlzaW9uIHNoYWxsIGJlIHJlZm9ybWVkIHRvIHRoZSBtaW5pbXVtIGV4dGVudCBuZWNlc3NhcnkgdG8gbWFrZSBzdWNoIHByb3Zpc2lvbiB2YWxpZCBhbmQgZW5mb3JjZWFibGUuCisKK0lmIFJlY2lwaWVudCBpbnN0aXR1dGVzIHBhdGVudCBsaXRpZ2F0aW9uIGFnYWluc3QgYW55IGVudGl0eSAoaW5jbHVkaW5nIGEgY3Jvc3MtY2xhaW0gb3IgY291bnRlcmNsYWltIGluIGEgbGF3c3VpdCkKK2FsbGVnaW5nIHRoYXQgdGhlIFByb2dyYW0gaXRzZWxmIChleGNsdWRpbmcgY29tYmluYXRpb25zIG9mIHRoZSBQcm9ncmFtIHdpdGggb3RoZXIgc29mdHdhcmUgb3IgaGFyZHdhcmUpIGluZnJpbmdlcyBzdWNoCitSZWNpcGllbnQncyBwYXRlbnQocyksIHRoZW4gc3VjaCBSZWNpcGllbnQncyByaWdodHMgZ3JhbnRlZCB1bmRlciBTZWN0aW9uIDIoYikgc2hhbGwgdGVybWluYXRlIGFzIG9mIHRoZSBkYXRlIHN1Y2gKK2xpdGlnYXRpb24gaXMgZmlsZWQuCisKK0FsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgc2hhbGwgdGVybWluYXRlIGlmIGl0IGZhaWxzIHRvIGNvbXBseSB3aXRoIGFueSBvZiB0aGUgbWF0ZXJpYWwgdGVybXMgb3IKK2NvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQgYW5kIGRvZXMgbm90IGN1cmUgc3VjaCBmYWlsdXJlIGluIGEgcmVhc29uYWJsZSBwZXJpb2Qgb2YgdGltZSBhZnRlciBiZWNvbWluZyBhd2FyZSBvZiBzdWNoCitub25jb21wbGlhbmNlLiBJZiBhbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHRlcm1pbmF0ZSwgUmVjaXBpZW50IGFncmVlcyB0byBjZWFzZSB1c2UgYW5kIGRpc3RyaWJ1dGlvbgorb2YgdGhlIFByb2dyYW0gYXMgc29vbiBhcyByZWFzb25hYmx5IHByYWN0aWNhYmxlLiBIb3dldmVyLCBSZWNpcGllbnQncyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIEFncmVlbWVudCBhbmQgYW55IGxpY2Vuc2VzCisgZ3JhbnRlZCBieSBSZWNpcGllbnQgcmVsYXRpbmcgdG8gdGhlIFByb2dyYW0gc2hhbGwgY29udGludWUgYW5kIHN1cnZpdmUuCisKK0V2ZXJ5b25lIGlzIHBlcm1pdHRlZCB0byBjb3B5IGFuZCBkaXN0cmlidXRlIGNvcGllcyBvZiB0aGlzIEFncmVlbWVudCwgYnV0IGluIG9yZGVyIHRvIGF2b2lkIGluY29uc2lzdGVuY3kgdGhlIEFncmVlbWVudAoraXMgY29weXJpZ2h0ZWQgYW5kIG1heSBvbmx5IGJlIG1vZGlmaWVkIGluIHRoZSBmb2xsb3dpbmcgbWFubmVyLiBUaGUgQWdyZWVtZW50IFN0ZXdhcmQgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHB1Ymxpc2gKK25ldyB2ZXJzaW9ucyAoaW5jbHVkaW5nIHJldmlzaW9ucykgb2YgdGhpcyBBZ3JlZW1lbnQgZnJvbSB0aW1lIHRvIHRpbWUuIE5vIG9uZSBvdGhlciB0aGFuIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCBoYXMgdGhlCityaWdodCB0byBtb2RpZnkgdGhpcyBBZ3JlZW1lbnQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgdGhlIGluaXRpYWwgQWdyZWVtZW50IFN0ZXdhcmQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWF5Cithc3NpZ24gdGhlIHJlc3BvbnNpYmlsaXR5IHRvIHNlcnZlIGFzIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCB0byBhIHN1aXRhYmxlIHNlcGFyYXRlIGVudGl0eS4gRWFjaCBuZXcgdmVyc2lvbiBvZiB0aGUKK0FncmVlbWVudCB3aWxsIGJlIGdpdmVuIGEgZGlzdGluZ3Vpc2hpbmcgdmVyc2lvbiBudW1iZXIuIFRoZSBQcm9ncmFtIChpbmNsdWRpbmcgQ29udHJpYnV0aW9ucykgbWF5IGFsd2F5cyBiZQorZGlzdHJpYnV0ZWQgc3ViamVjdCB0byB0aGUgdmVyc2lvbiBvZiB0aGUgQWdyZWVtZW50IHVuZGVyIHdoaWNoIGl0IHdhcyByZWNlaXZlZC4gSW4gYWRkaXRpb24sIGFmdGVyIGEgbmV3IHZlcnNpb24gb2YKK3RoZSBBZ3JlZW1lbnQgaXMgcHVibGlzaGVkLCBDb250cmlidXRvciBtYXkgZWxlY3QgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbSAoaW5jbHVkaW5nIGl0cyBDb250cmlidXRpb25zKSB1bmRlciB0aGUKK25ldyB2ZXJzaW9uLiBFeGNlcHQgYXMgZXhwcmVzc2x5IHN0YXRlZCBpbiBTZWN0aW9ucyAyKGEpIGFuZCAyKGIpIGFib3ZlLCBSZWNpcGllbnQgcmVjZWl2ZXMgbm8gcmlnaHRzIG9yIGxpY2Vuc2VzIHRvCit0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IG9mIGFueSBDb250cmlidXRvciB1bmRlciB0aGlzIEFncmVlbWVudCwgd2hldGhlciBleHByZXNzbHksIGJ5IGltcGxpY2F0aW9uLCBlc3RvcHBlbCBvcgorb3RoZXJ3aXNlLiBBbGwgcmlnaHRzIGluIHRoZSBQcm9ncmFtIG5vdCBleHByZXNzbHkgZ3JhbnRlZCB1bmRlciB0aGlzIEFncmVlbWVudCBhcmUgcmVzZXJ2ZWQuCisKK1RoaXMgQWdyZWVtZW50IGlzIGdvdmVybmVkIGJ5IHRoZSBsYXdzIG9mIHRoZSBTdGF0ZSBvZiBOZXcgWW9yayBhbmQgdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBsYXdzIG9mIHRoZSBVbml0ZWQgU3RhdGVzCitvZiBBbWVyaWNhLiBObyBwYXJ0eSB0byB0aGlzIEFncmVlbWVudCB3aWxsIGJyaW5nIGEgbGVnYWwgYWN0aW9uIHVuZGVyIHRoaXMgQWdyZWVtZW50IG1vcmUgdGhhbiBvbmUgeWVhciBhZnRlciB0aGUgY2F1c2UKK29mIGFjdGlvbiBhcm9zZS4gRWFjaCBwYXJ0eSB3YWl2ZXMgaXRzIHJpZ2h0cyB0byBhIGp1cnkgdHJpYWwgaW4gYW55IHJlc3VsdGluZyBsaXRpZ2F0aW9uLgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpL01FVEEtSU5GL01BTklGRVNULk1GIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkvTUVUQS1JTkYvTUFOSUZFU1QuTUYKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMjg2YzQzYgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpL01FVEEtSU5GL01BTklGRVNULk1GCkBAIC0wLDAgKzEsMTYgQEAKK01hbmlmZXN0LVZlcnNpb246IDEuMAorQnVuZGxlLU1hbmlmZXN0VmVyc2lvbjogMgorQnVuZGxlLU5hbWU6IG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpCitCdW5kbGUtU3ltYm9saWNOYW1lOiBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaQorQnVuZGxlLVZlcnNpb246IDAuOS4wLnF1YWxpZmllcgorQnVuZGxlLVZlbmRvcjogRWNsaXBzZSBPU0JQCitCdW5kbGUtUmVxdWlyZWRFeGVjdXRpb25FbnZpcm9ubWVudDogSmF2YVNFLTEuNworSW1wb3J0LVBhY2thZ2U6IG9yZy5vc2dpLmZyYW1ld29yazt2ZXJzaW9uPSIxLjMuMCIsCisgb3JnLnNsZjRqO3ZlcnNpb249IjEuNy4yIgorQnVuZGxlLUFjdGl2YXRpb25Qb2xpY3k6IGxhenkKK1JlcXVpcmUtQnVuZGxlOiBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcztidW5kbGUtdmVyc2lvbj0iMy45LjAiLAorIG9yZy5lY2xpcHNlLmNvcmUucnVudGltZTtidW5kbGUtdmVyc2lvbj0iMy4xMC4wIiwKKyBjb20uZ29vZ2xlLmluamVjdDtidW5kbGUtdmVyc2lvbj0iMy4wLjAiCitFeHBvcnQtUGFja2FnZTogb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkuaTE4bjsKKyAgdXNlczo9Im9yZy5lY2xpcHNlLmNvcmUucnVudGltZSwKKyAgIG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzIjt2ZXJzaW9uPSIwLjkuMCIKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpL2Fib3V0Lmh0bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS9hYm91dC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjY0YzA1OTgKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS9hYm91dC5odG1sCkBAIC0wLDAgKzEsMjggQEAKKzwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFN0cmljdC8vRU4iCisgICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXN0cmljdC5kdGQiPgorPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiPgorPGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1JU08tODg1OS0xIi8+Cis8dGl0bGU+QWJvdXQ8L3RpdGxlPgorPC9oZWFkPgorPGJvZHkgbGFuZz0iRU4tVVMiPgorPGgyPkFib3V0IFRoaXMgQ29udGVudDwvaDI+CisgCis8cD5KdW5lIDEsIDIwMTY8L3A+CQorPGgzPkxpY2Vuc2U8L2gzPgorCis8cD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBhbGwgY29udGVudCBpbiB0aGlzIHBsdWctaW4gKCZxdW90O0NvbnRlbnQmcXVvdDspLiAgVW5sZXNzIG90aGVyd2lzZSAKK2luZGljYXRlZCBiZWxvdywgdGhlIENvbnRlbnQgaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUKK0VjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKCZxdW90O0VQTCZxdW90OykuICBBIGNvcHkgb2YgdGhlIEVQTCBpcyBhdmFpbGFibGUgCithdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L2E+LgorRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICZxdW90O1Byb2dyYW0mcXVvdDsgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvcD4KKworPHA+SWYgeW91IGRpZCBub3QgcmVjZWl2ZSB0aGlzIENvbnRlbnQgZGlyZWN0bHkgZnJvbSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uLCB0aGUgQ29udGVudCBpcyAKK2JlaW5nIHJlZGlzdHJpYnV0ZWQgYnkgYW5vdGhlciBwYXJ0eSAoJnF1b3Q7UmVkaXN0cmlidXRvciZxdW90OykgYW5kIGRpZmZlcmVudCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBtYXkKK2FwcGx5IHRvIHlvdXIgdXNlIG9mIGFueSBvYmplY3QgY29kZSBpbiB0aGUgQ29udGVudC4gIENoZWNrIHRoZSBSZWRpc3RyaWJ1dG9yJ3MgbGljZW5zZSB0aGF0IHdhcyAKK3Byb3ZpZGVkIHdpdGggdGhlIENvbnRlbnQuICBJZiBubyBzdWNoIGxpY2Vuc2UgZXhpc3RzLCBjb250YWN0IHRoZSBSZWRpc3RyaWJ1dG9yLiAgVW5sZXNzIG90aGVyd2lzZQoraW5kaWNhdGVkIGJlbG93LCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVQTCBzdGlsbCBhcHBseSB0byBhbnkgc291cmNlIGNvZGUgaW4gdGhlIENvbnRlbnQKK2FuZCBzdWNoIHNvdXJjZSBjb2RlIG1heSBiZSBvYnRhaW5lZCBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnLyI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZzwvYT4uPC9wPgorCis8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkvYWJvdXQuaW5pIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkvYWJvdXQuaW5pCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjdkZjY3MWYKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS9hYm91dC5pbmkKQEAgLTAsMCArMSwxNyBAQAorIyBhYm91dC5pbmkKKyMgY29udGFpbnMgaW5mb3JtYXRpb24gYWJvdXQgYSBmZWF0dXJlCisjIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCisjICIla2V5IiBhcmUgZXh0ZXJuYWxpemVkIHN0cmluZ3MgZGVmaW5lZCBpbiBhYm91dC5wcm9wZXJ0aWVzCisjIFRoaXMgZmlsZSBkb2VzIG5vdCBuZWVkIHRvIGJlIHRyYW5zbGF0ZWQuCisKKyMgUHJvcGVydHkgImFib3V0VGV4dCIgY29udGFpbnMgYmx1cmIgZm9yICJBYm91dCIgZGlhbG9nICh0cmFuc2xhdGVkKQorYWJvdXRUZXh0PSVmZWF0dXJlVGV4dAorCisjIFByb3BlcnR5ICJmZWF0dXJlSW1hZ2UiIGNvbnRhaW5zIHBhdGggdG8gZmVhdHVyZSBpbWFnZSAoMzJ4MzIpCitmZWF0dXJlSW1hZ2U9CisKKyMgUHJvcGVydHkgImFwcE5hbWUiIGNvbnRhaW5zIG5hbWUgb2YgdGhlIGFwcGxpY2F0aW9uICh0cmFuc2xhdGVkKQorYXBwTmFtZT0lZmVhdHVyZU5hbWUKKworIyBQcm9wZXJ0eSAid2VsY29tZVBhZ2UiIGNvbnRhaW5zIHBhdGggdG8gd2VsY29tZSBwYWdlIChzcGVjaWFsIFhNTC1iYXNlZCBmb3JtYXQpCit3ZWxjb21lUGFnZT0KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpL2Fib3V0Lm1hcHBpbmdzIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkvYWJvdXQubWFwcGluZ3MKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDUxMWEwYQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpL2Fib3V0Lm1hcHBpbmdzCkBAIC0wLDAgKzEsNiBAQAorIyBhYm91dC5tYXBwaW5ncworIyBjb250YWlucyBmaWxsLWlucyBmb3IgYWJvdXQucHJvcGVydGllcworIyBqYXZhLmlvLlByb3BlcnRpZXMgZmlsZSAoSVNPIDg4NTktMSB3aXRoICJcIiBlc2NhcGVzKQorIyBUaGlzIGZpbGUgZG9lcyBub3QgbmVlZCB0byBiZSB0cmFuc2xhdGVkLgorCiswPXF1YWxpZmllcgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkvYWJvdXQucHJvcGVydGllcyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpL2Fib3V0LnByb3BlcnRpZXMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTBiYTc5YwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpL2Fib3V0LnByb3BlcnRpZXMKQEAgLTAsMCArMSwyNiBAQAorIworIyBDb3B5cmlnaHQgKGMpIDIwMTIsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHIChIZWlkZWxiZXJnKQorIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisjIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAorIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorIworIyBDb250cmlidXRvcnM6CisjICAgIExvZXR6IEdtYkgmQ28uS0cgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KKyMKKworIyBOTFNfTUVTU0FHRUZPUk1BVF9WQVIKKworZmVhdHVyZU5hbWU9b3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkKKworIyMjIyMjIyMjIyMjIyMjIyBibHVyYiBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKK2ZlYXR1cmVUZXh0PVwKK0NvcHlyaWdodCAoYykgMjAxMi0yMDE2IC0gTG9ldHogR21iSCZDby5LRyBcblwKK0FsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHNcblwKK2FyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMFxuXAord2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXRcblwKK2h0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sXG5cCitcblwKK0NvbnRyaWJ1dG9yczpcblwKKyAgICBMb2V0eiBHbWJIJkNvLktHIC0gaW1wbGVtZW50YXRpb25cbgorIyMjIyMjIyMjIyMjIyMjIyBlbmQgb2YgYmx1cmIgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS9idWlsZC5wcm9wZXJ0aWVzIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkvYnVpbGQucHJvcGVydGllcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lMTg0ZDY2Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkvYnVpbGQucHJvcGVydGllcwpAQCAtMCwwICsxLDggQEAKK3NvdXJjZS4uID0gc3JjLworb3V0cHV0Li4gPSB0YXJnZXQvY2xhc3Nlcy8KK2Jpbi5pbmNsdWRlcyA9IGFib3V0LnByb3BlcnRpZXMsICBhYm91dC5tYXBwaW5ncywgIGFib3V0LmluaSwgIGFib3V0Lmh0bWwsICBNRVRBLUlORi8sXAorICAgICAgICAgICAgICAgLixcCisgICAgICAgICAgICAgICBMSUNFTlNFLnR4dCxcCisgICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwKK3NyYy5pbmNsdWRlcyA9IGFib3V0LnByb3BlcnRpZXMsICBhYm91dC5tYXBwaW5ncywgIGFib3V0LmluaSwgIGFib3V0Lmh0bWwsICBMSUNFTlNFLnR4dCxcCisgICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpL2xpY2Vuc2UuaHRtbCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpL2xpY2Vuc2UuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jMzNkNDVjCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkvbGljZW5zZS5odG1sCkBAIC0wLDAgKzEsMTA5IEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJJU08tODg1OS0xIiA/PgorPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgU3RyaWN0Ly9FTiIgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXN0cmljdC5kdGQiPgorPCEtLSBzYXZlZCBmcm9tIHVybD0oMDA0NClodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC9ub3RpY2UuaHRtbCAtLT4KKzxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIj4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9SVNPLTg4NTktMSIgLz4KKzx0aXRsZT5FY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L3RpdGxlPgorPC9oZWFkPgorCis8Ym9keSBsYW5nPSJFTi1VUyI+Cis8aDI+RWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9oMj4KKzxwPkZlYnJ1YXJ5IDEsIDIwMTE8L3A+CisKKzxoMz5Vc2FnZSBPZiBDb250ZW50PC9oMz4KKworPHA+VEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUiBPVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTCisgICAoQ09MTEVDVElWRUxZICZxdW90O0NPTlRFTlQmcXVvdDspLiAgVVNFIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORAorICAgQ09ORElUSU9OUyBPRiBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gIEJZIFVTSU5HIFRIRSBDT05URU5ULCBZT1UgQUdSRUUgVEhBVCBZT1VSIFVTRQorICAgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IKKyAgIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBJRiBZT1UgRE8gTk9UIEFHUkVFIFRPIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORAorICAgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVywgVEhFTiBZT1UgTUFZIE5PVCBVU0UgVEhFIENPTlRFTlQuPC9wPgorCis8aDM+QXBwbGljYWJsZSBMaWNlbnNlczwvaDM+CisKKzxwPlVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAKKyAgICgmcXVvdDtFUEwmcXVvdDspLiAgQSBjb3B5IG9mIHRoZSBFUEwgaXMgcHJvdmlkZWQgd2l0aCB0aGlzIENvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT4uCisgICBGb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgJnF1b3Q7UHJvZ3JhbSZxdW90OyB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9wPgorCis8cD5Db250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSwgZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHNvdXJjZSBjb2RlCisgICByZXBvc2l0b3J5ICgmcXVvdDtSZXBvc2l0b3J5JnF1b3Q7KSBpbiBzb2Z0d2FyZSBtb2R1bGVzICgmcXVvdDtNb2R1bGVzJnF1b3Q7KSBhbmQgbWFkZSBhdmFpbGFibGUgYXMgZG93bmxvYWRhYmxlIGFyY2hpdmVzICgmcXVvdDtEb3dubG9hZHMmcXVvdDspLjwvcD4KKworPHVsPgorICAgICAgIDxsaT5Db250ZW50IG1heSBiZSBzdHJ1Y3R1cmVkIGFuZCBwYWNrYWdlZCBpbnRvIG1vZHVsZXMgdG8gZmFjaWxpdGF0ZSBkZWxpdmVyaW5nLCBleHRlbmRpbmcsIGFuZCB1cGdyYWRpbmcgdGhlIENvbnRlbnQuICBUeXBpY2FsIG1vZHVsZXMgbWF5IGluY2x1ZGUgcGx1Zy1pbnMgKCZxdW90O1BsdWctaW5zJnF1b3Q7KSwgcGx1Zy1pbiBmcmFnbWVudHMgKCZxdW90O0ZyYWdtZW50cyZxdW90OyksIGFuZCBmZWF0dXJlcyAoJnF1b3Q7RmVhdHVyZXMmcXVvdDspLjwvbGk+CisgICAgICAgPGxpPkVhY2ggUGx1Zy1pbiBvciBGcmFnbWVudCBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IG9yIEpBUiAoSmF2YSZ0cmFkZTsgQVJjaGl2ZSkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgJnF1b3Q7cGx1Z2lucyZxdW90Oy48L2xpPgorICAgICAgIDxsaT5BIEZlYXR1cmUgaXMgYSBidW5kbGUgb2Ygb25lIG9yIG1vcmUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhbmQgYXNzb2NpYXRlZCBtYXRlcmlhbC4gIEVhY2ggRmVhdHVyZSBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IGluIGEgZGlyZWN0b3J5IG5hbWVkICZxdW90O2ZlYXR1cmVzJnF1b3Q7LiAgV2l0aGluIGEgRmVhdHVyZSwgZmlsZXMgbmFtZWQgJnF1b3Q7ZmVhdHVyZS54bWwmcXVvdDsgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIHRoZSBQbHVnLWlucworICAgICAgYW5kL29yIEZyYWdtZW50cyBhc3NvY2lhdGVkIHdpdGggdGhhdCBGZWF0dXJlLjwvbGk+CisgICAgICAgPGxpPkZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCZxdW90O0luY2x1ZGVkIEZlYXR1cmVzJnF1b3Q7KS4gV2l0aGluIGEgRmVhdHVyZSwgZmlsZXMgbmFtZWQgJnF1b3Q7ZmVhdHVyZS54bWwmcXVvdDsgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIEluY2x1ZGVkIEZlYXR1cmVzLjwvbGk+Cis8L3VsPgorCis8cD5UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAmcXVvdDthYm91dC5odG1sJnF1b3Q7ICgmcXVvdDtBYm91dHMmcXVvdDspLiBUaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIEZlYXR1cmVzIGFuZAorSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAmcXVvdDtsaWNlbnNlLmh0bWwmcXVvdDsgKCZxdW90O0ZlYXR1cmUgTGljZW5zZXMmcXVvdDspLiAgQWJvdXRzIGFuZCBGZWF0dXJlIExpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSBkaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGUKK2luY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOjwvcD4KKworPHVsPgorICAgICAgIDxsaT5UaGUgdG9wLWxldmVsIChyb290KSBkaXJlY3Rvcnk8L2xpPgorICAgICAgIDxsaT5QbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3RvcmllczwvbGk+CisgICAgICAgPGxpPkluc2lkZSBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHBhY2thZ2VkIGFzIEpBUnM8L2xpPgorICAgICAgIDxsaT5TdWItZGlyZWN0b3JpZXMgb2YgdGhlIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtzcmMmcXVvdDsgb2YgY2VydGFpbiBQbHVnLWluczwvbGk+CisgICAgICAgPGxpPkZlYXR1cmUgZGlyZWN0b3JpZXM8L2xpPgorPC91bD4KKworPHA+Tm90ZTogaWYgYSBGZWF0dXJlIG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgaW5zdGFsbGVkIHVzaW5nIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSAoYXMgZGVmaW5lZCBiZWxvdyksIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoJnF1b3Q7RmVhdHVyZSBVcGRhdGUgTGljZW5zZSZxdW90OykgZHVyaW5nIHRoZQoraW5zdGFsbGF0aW9uIHByb2Nlc3MuICBJZiB0aGUgRmVhdHVyZSBjb250YWlucyBJbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdSB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgdGhlIEluY2x1ZGVkIEZlYXR1cmVzIG9yCitpbmZvcm0geW91IHdoZXJlIHlvdSBjYW4gbG9jYXRlIHRoZW0uICBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW4gdGhlICZxdW90O2xpY2Vuc2UmcXVvdDsgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgJnF1b3Q7ZmVhdHVyZS5wcm9wZXJ0aWVzJnF1b3Q7IGZvdW5kIHdpdGhpbiBhIEZlYXR1cmUuCitTdWNoIEFib3V0cywgRmVhdHVyZSBMaWNlbnNlcywgYW5kIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXIgdXNlIG9mIHRoZSBhc3NvY2lhdGVkIENvbnRlbnQgaW4KK3RoYXQgZGlyZWN0b3J5LjwvcD4KKworPHA+VEhFIEFCT1VUUywgRkVBVFVSRSBMSUNFTlNFUywgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUiBUTyBUSEUgRVBMIE9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy4gIFNPTUUgT0YgVEhFU0UKK09USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6PC9wPgorCis8dWw+CisgICAgICAgPGxpPkVjbGlwc2UgRGlzdHJpYnV0aW9uIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xpY2Vuc2VzL2VkbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9saWNlbnNlcy9lZGwtdjEuMC5odG1sPC9hPik8L2xpPgorICAgICAgIDxsaT5Db21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWw8L2E+KTwvbGk+CisgICAgICAgPGxpPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRTwvYT4pPC9saT4KKyAgICAgICA8bGk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjA8L2E+KTwvbGk+CisgICAgICAgPGxpPk1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sIj5odHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbDwvYT4pPC9saT4KKyAgICAgICA8bGk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbCI+aHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sPC9hPik8L2xpPgorPC91bD4KKworPHA+SVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgQ09ORElUSU9OUyBQUklPUiBUTyBVU0UgT0YgVEhFIENPTlRFTlQuICBJZiBubyBBYm91dCwgRmVhdHVyZSBMaWNlbnNlLCBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIGlzIHByb3ZpZGVkLCBwbGVhc2UKK2NvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuPC9wPgorCisKKzxoMz5Vc2Ugb2YgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3k8L2gzPgorCis8cD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBwcm92aXNpb25pbmcgc29mdHdhcmUsIGV4YW1wbGVzIG9mIHdoaWNoIGluY2x1ZGUsIGJ1dCBhcmUgbm90IGxpbWl0ZWQgdG8sIHAyIGFuZCB0aGUgRWNsaXBzZQorICAgVXBkYXRlIE1hbmFnZXIgKCZxdW90O1Byb3Zpc2lvbmluZyBUZWNobm9sb2d5JnF1b3Q7KSBmb3IgdGhlIHB1cnBvc2Ugb2YgYWxsb3dpbmcgdXNlcnMgdG8gaW5zdGFsbCBzb2Z0d2FyZSwgZG9jdW1lbnRhdGlvbiwgaW5mb3JtYXRpb24gYW5kL29yCisgICBvdGhlciBtYXRlcmlhbHMgKGNvbGxlY3RpdmVseSAmcXVvdDtJbnN0YWxsYWJsZSBTb2Z0d2FyZSZxdW90OykuIFRoaXMgY2FwYWJpbGl0eSBpcyBwcm92aWRlZCB3aXRoIHRoZSBpbnRlbnQgb2YgYWxsb3dpbmcgc3VjaCB1c2VycyB0bworICAgaW5zdGFsbCwgZXh0ZW5kIGFuZCB1cGRhdGUgRWNsaXBzZS1iYXNlZCBwcm9kdWN0cy4gSW5mb3JtYXRpb24gYWJvdXQgcGFja2FnaW5nIEluc3RhbGxhYmxlIFNvZnR3YXJlIGlzIGF2YWlsYWJsZSBhdCA8YQorICAgICAgIGhyZWY9Imh0dHA6Ly9lY2xpcHNlLm9yZy9lcXVpbm94L3AyL3JlcG9zaXRvcnlfcGFja2FnaW5nLmh0bWwiPmh0dHA6Ly9lY2xpcHNlLm9yZy9lcXVpbm94L3AyL3JlcG9zaXRvcnlfcGFja2FnaW5nLmh0bWw8L2E+CisgICAoJnF1b3Q7U3BlY2lmaWNhdGlvbiZxdW90OykuPC9wPgorCis8cD5Zb3UgbWF5IHVzZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSB0byBhbGxvdyBvdGhlciBwYXJ0aWVzIHRvIGluc3RhbGwgSW5zdGFsbGFibGUgU29mdHdhcmUuIFlvdSBzaGFsbCBiZSByZXNwb25zaWJsZSBmb3IgZW5hYmxpbmcgdGhlCisgICBhcHBsaWNhYmxlIGxpY2Vuc2UgYWdyZWVtZW50cyByZWxhdGluZyB0byB0aGUgSW5zdGFsbGFibGUgU29mdHdhcmUgdG8gYmUgcHJlc2VudGVkIHRvLCBhbmQgYWNjZXB0ZWQgYnksIHRoZSB1c2VycyBvZiB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kKKyAgIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgU3BlY2lmaWNhdGlvbi4gQnkgdXNpbmcgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgaW4gc3VjaCBhIG1hbm5lciBhbmQgbWFraW5nIGl0IGF2YWlsYWJsZSBpbiBhY2NvcmRhbmNlIHdpdGggdGhlCisgICBTcGVjaWZpY2F0aW9uLCB5b3UgZnVydGhlciBhY2tub3dsZWRnZSB5b3VyIGFncmVlbWVudCB0bywgYW5kIHRoZSBhY3F1aXNpdGlvbiBvZiBhbGwgbmVjZXNzYXJ5IHJpZ2h0cyB0byBwZXJtaXQgdGhlIGZvbGxvd2luZzo8L3A+CisKKzxvbD4KKyAgICAgICA8bGk+QSBzZXJpZXMgb2YgYWN0aW9ucyBtYXkgb2NjdXIgKCZxdW90O1Byb3Zpc2lvbmluZyBQcm9jZXNzJnF1b3Q7KSBpbiB3aGljaCBhIHVzZXIgbWF5IGV4ZWN1dGUgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5CisgICAgICAgb24gYSBtYWNoaW5lICgmcXVvdDtUYXJnZXQgTWFjaGluZSZxdW90Oykgd2l0aCB0aGUgaW50ZW50IG9mIGluc3RhbGxpbmcsIGV4dGVuZGluZyBvciB1cGRhdGluZyB0aGUgZnVuY3Rpb25hbGl0eSBvZiBhbiBFY2xpcHNlLWJhc2VkCisgICAgICAgcHJvZHVjdC48L2xpPgorICAgICAgIDxsaT5EdXJpbmcgdGhlIFByb3Zpc2lvbmluZyBQcm9jZXNzLCB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgbWF5IGNhdXNlIHRoaXJkIHBhcnR5IEluc3RhbGxhYmxlIFNvZnR3YXJlIG9yIGEgcG9ydGlvbiB0aGVyZW9mIHRvIGJlCisgICAgICAgYWNjZXNzZWQgYW5kIGNvcGllZCB0byB0aGUgVGFyZ2V0IE1hY2hpbmUuPC9saT4KKyAgICAgICA8bGk+UHVyc3VhbnQgdG8gdGhlIFNwZWNpZmljYXRpb24sIHlvdSB3aWxsIHByb3ZpZGUgdG8gdGhlIHVzZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIHRoYXQgZ292ZXJuIHRoZSB1c2Ugb2YgdGhlIEluc3RhbGxhYmxlCisgICAgICAgU29mdHdhcmUgKCZxdW90O0luc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCZxdW90OykgYW5kIHN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50IHNoYWxsIGJlIGFjY2Vzc2VkIGZyb20gdGhlIFRhcmdldAorICAgICAgIE1hY2hpbmUgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBTcGVjaWZpY2F0aW9uLiBTdWNoIEluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCBtdXN0IGluZm9ybSB0aGUgdXNlciBvZiB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgdGhhdCBnb3Zlcm4KKyAgICAgICB0aGUgSW5zdGFsbGFibGUgU29mdHdhcmUgYW5kIG11c3Qgc29saWNpdCBhY2NlcHRhbmNlIGJ5IHRoZSBlbmQgdXNlciBpbiB0aGUgbWFubmVyIHByZXNjcmliZWQgaW4gc3VjaCBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQuIFVwb24gc3VjaAorICAgICAgIGluZGljYXRpb24gb2YgYWdyZWVtZW50IGJ5IHRoZSB1c2VyLCB0aGUgcHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgd2lsbCBjb21wbGV0ZSBpbnN0YWxsYXRpb24gb2YgdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlLjwvbGk+Cis8L29sPgorCis8aDM+Q3J5cHRvZ3JhcGh5PC9oMz4KKworPHA+Q29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlIGN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSwgYW5kL29yIHJlLWV4cG9ydCB0bworICAgYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkUgdXNpbmcgYW55IGVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsIHJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsCisgICBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLjwvcD4KKworPHA+PHNtYWxsPkphdmEgYW5kIGFsbCBKYXZhLWJhc2VkIHRyYWRlbWFya3MgYXJlIHRyYWRlbWFya3Mgb2YgT3JhY2xlIENvcnBvcmF0aW9uIGluIHRoZSBVbml0ZWQgU3RhdGVzLCBvdGhlciBjb3VudHJpZXMsIG9yIGJvdGguPC9zbWFsbD48L3A+Cis8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkvcG9tLnhtbCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpL3BvbS54bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYWFhMjIyNwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpL3BvbS54bWwKQEAgLTAsMCArMSw2NCBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KKzwhLS0jPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gLS0+Cis8IS0tIyBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMdW5pZmVyYSBHbWJIIChHcm9zcyBFbnplcnNkb3JmKSwgTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkgLS0+Cis8IS0tIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIC0tPgorPCEtLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIC0tPgorPCEtLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgLS0+Cis8IS0tIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAtLT4KKzwhLS0jIC0tPgorPCEtLSMgQ29udHJpYnV0b3JzOiAtLT4KKzwhLS0jICAgICBLbGVtZW5zIEVkbGVyIChMdW5pZmVyYSBHbWJIKSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiAtLT4KKzwhLS0jPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gLS0+CisKKzxwcm9qZWN0IHhtbG5zPSJodHRwOi8vbWF2ZW4uYXBhY2hlLm9yZy9QT00vNC4wLjAiIHhtbG5zOnhzaT0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEtaW5zdGFuY2UiIHhzaTpzY2hlbWFMb2NhdGlvbj0iaHR0cDovL21hdmVuLmFwYWNoZS5vcmcvUE9NLzQuMC4wIGh0dHA6Ly9tYXZlbi5hcGFjaGUub3JnL3hzZC9tYXZlbi00LjAuMC54c2QiPgorICAgIDxtb2RlbFZlcnNpb24+NC4wLjA8L21vZGVsVmVyc2lvbj4KKyAgICA8cGFyZW50PgorICAgICAgICA8Z3JvdXBJZD5vcmcuZWNsaXBzZS5vc2JwLmlkZTwvZ3JvdXBJZD4KKyAgICAgICAgPGFydGlmYWN0SWQ+b3JnLmVjbGlwc2Uub3NicC5pZGU8L2FydGlmYWN0SWQ+CisgICAgICAgIDx2ZXJzaW9uPjAuOS4wLVNOQVBTSE9UPC92ZXJzaW9uPgorICAgIDwvcGFyZW50PgorICAgIDxhcnRpZmFjdElkPm9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpPC9hcnRpZmFjdElkPgorICAgIDxwYWNrYWdpbmc+ZWNsaXBzZS1wbHVnaW48L3BhY2thZ2luZz4KKworICAgIDxidWlsZD4KKyAgICAgICAgPHNvdXJjZURpcmVjdG9yeT5zcmM8L3NvdXJjZURpcmVjdG9yeT4KKyAgICAgICAgPHBsdWdpbnM+CisgICAgICAgICAgICA8cGx1Z2luPgorICAgICAgICAgICAgICAgIDxncm91cElkPm9yZy5jb2RlaGF1cy5tb2pvPC9ncm91cElkPgorICAgICAgICAgICAgICAgIDxhcnRpZmFjdElkPmJ1aWxkLWhlbHBlci1tYXZlbi1wbHVnaW48L2FydGlmYWN0SWQ+CisgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbnM+CisgICAgICAgICAgICAgICAgICAgIDxleGVjdXRpb24+CisgICAgICAgICAgICAgICAgICAgICAgICA8aWQ+YWRkLXNvdXJjZTwvaWQ+CisgICAgICAgICAgICAgICAgICAgICAgICA8cGhhc2U+aW5pdGlhbGl6ZTwvcGhhc2U+CisgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbHM+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGdvYWw+YWRkLXNvdXJjZTwvZ29hbD4KKyAgICAgICAgICAgICAgICAgICAgICAgIDwvZ29hbHM+CisgICAgICAgICAgICAgICAgICAgICAgICA8Y29uZmlndXJhdGlvbj4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c291cmNlcz4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHNvdXJjZT54dGVuZC1nZW48L3NvdXJjZT4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3NvdXJjZXM+CisgICAgICAgICAgICAgICAgICAgICAgICA8L2NvbmZpZ3VyYXRpb24+CisgICAgICAgICAgICAgICAgICAgIDwvZXhlY3V0aW9uPgorICAgICAgICAgICAgICAgIDwvZXhlY3V0aW9ucz4KKyAgICAgICAgICAgIDwvcGx1Z2luPgorICAgICAgICAgICAgPHBsdWdpbj4KKyAgICAgICAgICAgICAgICA8YXJ0aWZhY3RJZD5tYXZlbi1jbGVhbi1wbHVnaW48L2FydGlmYWN0SWQ+CisgICAgICAgICAgICAgICAgPGNvbmZpZ3VyYXRpb24+CisgICAgICAgICAgICAgICAgICAgIDxmaWxlc2V0cz4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxmaWxlc2V0PgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxkaXJlY3Rvcnk+eHRlbmQtZ2VuPC9kaXJlY3Rvcnk+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGluY2x1ZGVzPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8aW5jbHVkZT4qKjwvaW5jbHVkZT4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2luY2x1ZGVzPgorICAgICAgICAgICAgICAgICAgICAgICAgPC9maWxlc2V0PgorICAgICAgICAgICAgICAgICAgICA8L2ZpbGVzZXRzPgorICAgICAgICAgICAgICAgIDwvY29uZmlndXJhdGlvbj4KKyAgICAgICAgICAgIDwvcGx1Z2luPgorICAgICAgICAgICAgPHBsdWdpbj4KKyAgICAgICAgICAgICAgICA8Z3JvdXBJZD5vcmcuZWNsaXBzZS54dGVuZDwvZ3JvdXBJZD4KKyAgICAgICAgICAgICAgICA8YXJ0aWZhY3RJZD54dGVuZC1tYXZlbi1wbHVnaW48L2FydGlmYWN0SWQ+CisgICAgICAgICAgICA8L3BsdWdpbj4KKyAgICAgICAgPC9wbHVnaW5zPgorICAgIDwvYnVpbGQ+CisKKzwvcHJvamVjdD4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS9jb3JlL2FwaS9pMThuL0NvcmVVdGlsLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS9hcGkvaTE4bi9Db3JlVXRpbC5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjc1NjZkNDEKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS9hcGkvaTE4bi9Db3JlVXRpbC5qYXZhCkBAIC0wLDAgKzEsNTggQEAKKy8qKgorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE1IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiwgQXVzdHJpYSksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorICoKKyAqIENvbnRyaWJ1dG9yczoKKyAqICAgICAgICAgRmxvcmlhbiBQaXJjaG5lciAtIEluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS5pMThuOworCitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVByb2plY3Q7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkNvcmVFeGNlcHRpb247CitpbXBvcnQgb3JnLnNsZjRqLkxvZ2dlcjsKK2ltcG9ydCBvcmcuc2xmNGouTG9nZ2VyRmFjdG9yeTsKKworLy8gVE9ETzogQXV0by1nZW5lcmF0ZWQgSmF2YWRvYworLyoqCisgKiBUaGUgQ2xhc3MgQ29yZVV0aWwuCisgKi8KK3B1YmxpYyBjbGFzcyBDb3JlVXRpbCB7CisKKwkvKiogVGhlIENvbnN0YW50IExPR0dFUi4gKi8KKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBMb2dnZXIgTE9HR0VSID0gTG9nZ2VyRmFjdG9yeQorCQkJLmdldExvZ2dlcihDb3JlVXRpbC5jbGFzcyk7CisKKwkvKiogVGhlIG5hdHVyZSBpZC4gKi8KKwlwdWJsaWMgc3RhdGljIFN0cmluZyBOQVRVUkVfSUQgPSAib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQuT1NCUE5hdHVyZSI7CisJCisJLyoqIFRoZSBDb25zdGFudCBCVUlMREVSX01PREVMX0VOSEFOQ0lOR19JRC4gKi8KKwlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBCVUlMREVSX01PREVMX0VOSEFOQ0lOR19JRCA9ICJvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC5PU0JQTW9kZWxFbmhhbmNpbmdCdWlsZGVyIjsKKwkKKwkvKiogVGhlIENvbnN0YW50IEJVSUxERVJfSTE4Tl9JRC4gKi8KKwlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBCVUlMREVSX0kxOE5fSUQgPSAib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQuT1NCUEkxOG5CdWlsZGVyIjsKKworCS8qKiBUaGUgQ29uc3RhbnQgRVZFTlRfVE9QSUNfX0JVSUxERVIuICovCisJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgRVZFTlRfVE9QSUNfX0JVSUxERVIgPSAib3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9idWlsZGVyIjsKKworCS8qKgorCSAqIFJldHVybnMgdHJ1ZSwgaWYgdGhlIGdpdmVuIHByb2plY3QgY29udGFpbnMgdGhlIE9TQlAgTmF0dXJlLgorCSAqCisJICogQHBhcmFtIHByb2plY3QKKwkgKiAgICAgICAgICAgIHRoZSBwcm9qZWN0CisJICogQHJldHVybiB0cnVlLCBpZiBzdWNjZXNzZnVsCisJICovCisJcHVibGljIHN0YXRpYyBib29sZWFuIGhhc05hdHVyZShJUHJvamVjdCBwcm9qZWN0KSB7CisJCXRyeSB7CisJCQlpZiAocHJvamVjdC5pc0FjY2Vzc2libGUoKSkgeworCQkJCXJldHVybiBwcm9qZWN0Lmhhc05hdHVyZShOQVRVUkVfSUQpOworCQkJfQorCQl9IGNhdGNoIChDb3JlRXhjZXB0aW9uIGUpIHsKKwkJCUxPR0dFUi5lcnJvcihlLmdldE1lc3NhZ2UoKSwgZSk7CisJCX0KKwkJcmV0dXJuIGZhbHNlOworCX0KKworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvYXBpL2kxOG4vSUkxOG5SZWdpc3RyeS5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvYXBpL2kxOG4vSUkxOG5SZWdpc3RyeS5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjAzYmFkYzUKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS9hcGkvaTE4bi9JSTE4blJlZ2lzdHJ5LmphdmEKQEAgLTAsMCArMSw0OTkgQEAKKy8qKgorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE1IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiwgQXVzdHJpYSksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorICoKKyAqIENvbnRyaWJ1dG9yczoKKyAqICAgICAgICAgRmxvcmlhbiBQaXJjaG5lciAtIEluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS5pMThuOworCitpbXBvcnQgamF2YS51dGlsLkFycmF5TGlzdDsKK2ltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbnM7CitpbXBvcnQgamF2YS51dGlsLkhhc2hNYXA7CitpbXBvcnQgamF2YS51dGlsLkhhc2hTZXQ7CitpbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOworaW1wb3J0IGphdmEudXRpbC5MaXN0OworaW1wb3J0IGphdmEudXRpbC5Mb2NhbGU7CitpbXBvcnQgamF2YS51dGlsLk1hcDsKK2ltcG9ydCBqYXZhLnV0aWwuUHJvcGVydGllczsKK2ltcG9ydCBqYXZhLnV0aWwuU2V0OworCitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVByb2plY3Q7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklQYXRoOworCisvLyBUT0RPOiBBdXRvLWdlbmVyYXRlZCBKYXZhZG9jCisvKioKKyAqIENhY2hlcyB0aGUgSTE4biBrZXlzIGFuZCB0aGVpciB2YWx1ZXMgYmFzZWQgaW4ge0BsaW5rIElQcm9qZWN0IHdvcmtzcGFjZQorICogcHJvZWpjdHN9LgorICovCitwdWJsaWMgaW50ZXJmYWNlIElJMThuUmVnaXN0cnkgeworCisJLyoqCisJICogUmV0dXJucyB0aGUgdHJhbnNsYXRlZCB2YWx1ZSBmb3IgdGhlIGdpdmVuIHByb2plY3QsIGxvY2FsZSBhbmQga2V5LgorCSAqCisJICogQHBhcmFtIHByb2plY3QKKwkgKiAgICAgICAgICAgIHRoZSBwcm9qZWN0CisJICogQHBhcmFtIGxvY2FsZQorCSAqICAgICAgICAgICAgdGhlIGxvY2FsZQorCSAqIEBwYXJhbSBrZXkKKwkgKiAgICAgICAgICAgIHRoZSBrZXkKKwkgKiBAcmV0dXJuIHRoZSB0ZXh0CisJICovCisJU3RyaW5nIGdldFRleHQoSVByb2plY3QgcHJvamVjdCwgTG9jYWxlIGxvY2FsZSwgU3RyaW5nIGtleSk7CisKKwkvKioKKwkgKiBSZXR1cm5zIGEgbGlzdCBvZiBwcm9wb3NhbHMuIElmIHRoZSBzZWFyY2hWYWx1ZSBtYXRjaGVzIHBhcnRzIG9mIHRoZQorCSAqIHZhbHVlIG9yIHRoZSBrZXkgZm9yIGFuIGkxOG4gcmVjb3JkLCBpdCBpcyBhZGRlZCB0byB0aGUgbGlzdCBvZgorCSAqIHByb3Bvc2Fscy4gTXVzdCBuZXZlciByZXR1cm4gPGNvZGU+bnVsbDwvY29kZT4uCisJICoKKwkgKiBAcGFyYW0gcHJvamVjdAorCSAqICAgICAgICAgICAgLSBUaGUgcHJvamVjdCB3aGljaCBzaG91bGQgYmUgc2VhcmNoZWQgZm9yIG1hdGNoaW5nIEkxOG4KKwkgKiAgICAgICAgICAgIHZhbHVlcy4KKwkgKiBAcGFyYW0gbG9jYWxlCisJICogICAgICAgICAgICAtIFRoZSBsb2NhbGUgd2hpY2ggc2hvdWxkIGJlIHVzZWQgdG8gc2VhcmNoIGZvciBtYXRjaGluZyBJMThuCisJICogICAgICAgICAgICB2YWx1ZXMuCisJICogQHBhcmFtIHBhY2thZ2VOYW1lCisJICogICAgICAgICAgICAtIFRoZSBwYWNrYWdlIG5hbWUuIEl0IGNhbiBiZSB1c2VkIHRvIHNlYXJjaCBmb3IgSTE4biB2YWx1ZXMsCisJICogICAgICAgICAgICBpZiB0aGUgc2VhcmNoVmFsdWUgc3RhcnRzIHdpdGggIi4iLiBGb3IgaW5zdGFuY2UKKwkgKiAgICAgICAgICAgICIuU2FsZXNPcmRlciIuIFRoZW4gdGhlIG1hdGNoZXIgb25seSBsb29rcyBmb3IgSTE4biBWYWx1ZXMKKwkgKiAgICAgICAgICAgIHdpdGggYSBrZXkgc3RhcnRpbmcgd2l0aCB0aGUgZ2l2ZW4gcGFja2FnZSBuYW1lLjxicj4KKwkgKiAgICAgICAgICAgIFdpbGRjYXJkcyBhcmUgYWxsb3dlZC4gRm9yIGluc3RhbmNlICIuKk9yZGVyIi4gVGhlIG1hdGNoZXIKKwkgKiAgICAgICAgICAgIHRyaWVzIHRvIGZpbmQgYW55IHBvc3NpYmxlIGNvbWJpbmF0aW9uLiBBICIqIiB3aWxkY2FyZCBhdCB0aGUKKwkgKiAgICAgICAgICAgIGVuZCBvZiB0aGUgc2VhcmNoVmFsdWUgd2lsbCBiZSBhZGRlZCBhdXRvbWF0aWNhbGx5IGJ5IHRoZQorCSAqICAgICAgICAgICAgbWF0Y2hlci4KKwkgKiBAcGFyYW0gc2VhcmNoVmFsdWUKKwkgKiAgICAgICAgICAgIHRoZSBzZWFyY2ggdmFsdWUKKwkgKiBAcmV0dXJuIHByb3Bvc2FsIC0gYSBMaXN0IG5ldmVyIDxjb2RlPm51bGw8L2NvZGU+CisJICovCisJTGlzdDxQcm9wb3NhbD4gZmluZENvbnRlbnRQcm9wb3NhbHMoSVByb2plY3QgcHJvamVjdCwgTG9jYWxlIGxvY2FsZSwKKwkJCVN0cmluZyBwYWNrYWdlTmFtZSwgU3RyaW5nIHNlYXJjaFZhbHVlKTsKKworCS8qKgorCSAqIFJldHVybnMgYSBsaXN0IG9mIHByb3Bvc2Fscy4gVGhlIHNlYXJjaFZhbHVlIG11c3QgbWF0Y2ggdGhlIGVudGlyZSBrZXkKKwkgKiBmb3IgYW4gaTE4biByZWNvcmQuCisJICogCisJICogQHBhcmFtIHByb2plY3QKKwkgKiAgICAgICAgICAgIC0gVGhlIHByb2plY3Qgd2hpY2ggc2hvdWxkIGJlIHNlYXJjaGVkIGZvciBtYXRjaGluZyBJMThuCisJICogICAgICAgICAgICB2YWx1ZXMuCisJICogQHBhcmFtIGxvY2FsZQorCSAqICAgICAgICAgICAgLSBUaGUgbG9jYWxlIHdoaWNoIHNob3VsZCBiZSB1c2VkIHRvIHNlYXJjaCBmb3IgbWF0Y2hpbmcgSTE4bgorCSAqICAgICAgICAgICAgdmFsdWVzLgorCSAqIEBwYXJhbSBwYWNrYWdlTmFtZQorCSAqICAgICAgICAgICAgLSBUaGUgcGFja2FnZSBuYW1lLiBJdCBjYW4gYmUgdXNlZCB0byBzZWFyY2ggZm9yIEkxOG4gdmFsdWVzLAorCSAqICAgICAgICAgICAgaWYgdGhlIHNlYXJjaFZhbHVlIHN0YXJ0cyB3aXRoICIuIi4gRm9yIGluc3RhbmNlCisJICogICAgICAgICAgICAiLlNhbGVzT3JkZXIiLiBUaGVuIHRoZSBtYXRjaGVyIG9ubHkgbG9va3MgZm9yIEkxOG4gVmFsdWVzCisJICogICAgICAgICAgICB3aXRoIGEga2V5IHN0YXJ0aW5nIHdpdGggdGhlIGdpdmVuIHBhY2thZ2UgbmFtZS48YnI+CisJICogICAgICAgICAgICBXaWxkY2FyZHMgYXJlIGFsbG93ZWQuIEZvciBpbnN0YW5jZSAiLipPcmRlciIuIFRoZSBtYXRjaGVyCisJICogICAgICAgICAgICB0cmllcyB0byBmaW5kIGFueSBwb3NzaWJsZSBjb21iaW5hdGlvbi4gQSAiKiIgd2lsZGNhcmQgYXQgdGhlCisJICogICAgICAgICAgICBlbmQgb2YgdGhlIHNlYXJjaFZhbHVlIHdpbGwgYmUgYWRkZWQgYXV0b21hdGljYWxseSBieSB0aGUKKwkgKiAgICAgICAgICAgIG1hdGNoZXIuCisJICogQHBhcmFtIGtleQorCSAqICAgICAgICAgICAgLSBUaGUga2V5IHRvIGxvb2sgZm9yLgorCSAqIEByZXR1cm4gcHJvcG9zYWwgLSBhIExpc3QgbmV2ZXIgPGNvZGU+bnVsbDwvY29kZT4KKwkgKi8KKwlMaXN0PFByb3Bvc2FsPiBmaW5kU3RyaWN0S2V5TWF0Y2hpbmdQcm9wb3NhbHMoSVByb2plY3QgcHJvamVjdCwKKwkJCUxvY2FsZSBsb2NhbGUsIFN0cmluZyBwYWNrYWdlTmFtZSwgU3RyaW5nIGtleSk7CisKKwkvKioKKwkgKiBSZXR1cm5zIHRoZSBiZXN0IG1hdGNoaW5nIHByb3Bvc2FsLgorCSAqIAorCSAqIEBwYXJhbSBwcm9qZWN0CisJICogICAgICAgICAgICAtIFRoZSBwcm9qZWN0IHdoaWNoIHNob3VsZCBiZSBzZWFyY2hlZCBmb3IgbWF0Y2hpbmcgSTE4bgorCSAqICAgICAgICAgICAgdmFsdWVzLgorCSAqIEBwYXJhbSBsb2NhbGUKKwkgKiAgICAgICAgICAgIC0gVGhlIGxvY2FsZSB3aGljaCBzaG91bGQgYmUgdXNlZCB0byBzZWFyY2ggZm9yIG1hdGNoaW5nIEkxOG4KKwkgKiAgICAgICAgICAgIHZhbHVlcy4KKwkgKiBAcGFyYW0gcGFja2FnZU5hbWUKKwkgKiAgICAgICAgICAgIC0gVGhlIHBhY2thZ2UgbmFtZS4gSXQgY2FuIGJlIHVzZWQgdG8gc2VhcmNoIGZvciBJMThuIHZhbHVlcywKKwkgKiAgICAgICAgICAgIGlmIHRoZSBzZWFyY2hWYWx1ZSBzdGFydHMgd2l0aCAiLiIuIEZvciBpbnN0YW5jZQorCSAqICAgICAgICAgICAgIi5TYWxlc09yZGVyIi4gVGhlbiB0aGUgbWF0Y2hlciBvbmx5IGxvb2tzIGZvciBJMThuIFZhbHVlcworCSAqICAgICAgICAgICAgd2l0aCBhIGtleSBzdGFydGluZyB3aXRoIHRoZSBnaXZlbiBwYWNrYWdlIG5hbWUuPGJyPgorCSAqICAgICAgICAgICAgV2lsZGNhcmRzIGFyZSBhbGxvd2VkLiBGb3IgaW5zdGFuY2UgIi4qT3JkZXIiLiBUaGUgbWF0Y2hlcgorCSAqICAgICAgICAgICAgdHJpZXMgdG8gZmluZCBhbnkgcG9zc2libGUgY29tYmluYXRpb24uIEEgIioiIHdpbGRjYXJkIGF0IHRoZQorCSAqICAgICAgICAgICAgZW5kIG9mIHRoZSBzZWFyY2hWYWx1ZSB3aWxsIGJlIGFkZGVkIGF1dG9tYXRpY2FsbHkgYnkgdGhlCisJICogICAgICAgICAgICBtYXRjaGVyLgorCSAqIEBwYXJhbSBrZXkKKwkgKiAgICAgICAgICAgIC0gVGhlIGtleSB0byBsb29rIGZvci4KKwkgKiBAcmV0dXJuIHByb3Bvc2FsIC0gYSBMaXN0IG5ldmVyIDxjb2RlPm51bGw8L2NvZGU+CisJICovCisJUHJvcG9zYWwgZmluZEJlc3RNYXRjaChJUHJvamVjdCBwcm9qZWN0LCBMb2NhbGUgbG9jYWxlLCBTdHJpbmcgcGFja2FnZU5hbWUsCisJCQlTdHJpbmcga2V5KTsKKworCS8qKgorCSAqIENhY2hlcyB0aGUgUHJvamVjdERlc2NyaXB0aW9uLgorCSAqCisJICogQHBhcmFtIGRlc2NyaXB0aW9uCisJICogICAgICAgICAgICB0aGUgZGVzY3JpcHRpb24KKwkgKi8KKwl2b2lkIGNhY2hlKFByb2plY3REZXNjcmlwdGlvbiBkZXNjcmlwdGlvbik7CisKKwkvKioKKwkgKiBDYWNoZXMgdGhlIFJlc291cmNlRGVzY3JpcHRpb24uCisJICoKKwkgKiBAcGFyYW0gZGVzY3JpcHRpb24KKwkgKiAgICAgICAgICAgIHRoZSBkZXNjcmlwdGlvbgorCSAqLworCXZvaWQgY2FjaGUoUmVzb3VyY2VEZXNjcmlwdGlvbiBkZXNjcmlwdGlvbik7CisKKwkvKioKKwkgKiBSZW1vdmVzIHRoZSBnaXZlbiByZXNvdXJjZSBmcm9tIHRoZSBwcm9qZWN0IGRlc2NyaXB0aW9uLgorCSAqCisJICogQHBhcmFtIHByb2plY3QKKwkgKiAgICAgICAgICAgIHRoZSBwcm9qZWN0CisJICogQHBhcmFtIGxvY2FsZQorCSAqICAgICAgICAgICAgdGhlIGxvY2FsZQorCSAqIEBwYXJhbSBsb2NhdGlvbgorCSAqICAgICAgICAgICAgdGhlIGxvY2F0aW9uCisJICovCisJdm9pZCByZW1vdmVSZXNvdXJjZShJUHJvamVjdCBwcm9qZWN0LCBMb2NhbGUgbG9jYWxlLCBJUGF0aCBsb2NhdGlvbik7CisKKwkvKioKKwkgKiBSZW1vdmVzIHRoZSBwcm9qZWN0IGZyb20gdGhlIGNhY2hlLgorCSAqCisJICogQHBhcmFtIHByb2plY3QKKwkgKiAgICAgICAgICAgIHRoZSBwcm9qZWN0CisJICovCisJdm9pZCByZW1vdmVQcm9qZWN0KElQcm9qZWN0IHByb2plY3QpOworCisJLyoqCisJICogUmV0dXJucyBhbGwgcHJvamVjdCBkZXNjcmlwdGlvbnMuCisJICoKKwkgKiBAcmV0dXJuIHRoZSBwcm9qZWN0IGRlc2NyaXB0aW9ucworCSAqLworCVNldDxQcm9qZWN0RGVzY3JpcHRpb24+IGdldFByb2plY3REZXNjcmlwdGlvbnMoKTsKKworCS8qKgorCSAqIENvbnRhaW5zIGFsbCByZXF1aXJlZCBpbmZvcm1hdGlvbiBhYm91dCBhIHByb2plY3QuIEl0IGNvbnRhaW5zIGFsbAorCSAqIHJlc291cmNlcy4KKwkgKi8KKwlwdWJsaWMgc3RhdGljIGNsYXNzIFByb2plY3REZXNjcmlwdGlvbiB7CisKKwkJLyoqIFRoZSByZXNvdXJjZXMuICovCisJCXByaXZhdGUgZmluYWwgTWFwPExvY2FsZSwgU2V0PFJlc291cmNlRGVzY3JpcHRpb24+PiByZXNvdXJjZXMgPSBDb2xsZWN0aW9ucworCQkJCS5zeW5jaHJvbml6ZWRNYXAobmV3IEhhc2hNYXA8TG9jYWxlLCBTZXQ8UmVzb3VyY2VEZXNjcmlwdGlvbj4+KCkpOworCisJCS8qKiBUaGUgcHJvamVjdC4gKi8KKwkJcHJpdmF0ZSBmaW5hbCBJUHJvamVjdCBwcm9qZWN0OworCisJCS8qKgorCQkgKiBJbnN0YW50aWF0ZXMgYSBuZXcgcHJvamVjdCBkZXNjcmlwdGlvbi4KKwkJICoKKwkJICogQHBhcmFtIHByb2plY3QKKwkJICogICAgICAgICAgICB0aGUgcHJvamVjdAorCQkgKi8KKwkJcHVibGljIFByb2plY3REZXNjcmlwdGlvbihJUHJvamVjdCBwcm9qZWN0KSB7CisJCQl0aGlzLnByb2plY3QgPSBwcm9qZWN0OworCQl9CisKKwkJLyoqCisJCSAqIEdldHMgdGhlIHByb2plY3QuCisJCSAqCisJCSAqIEByZXR1cm4gdGhlIHByb2plY3QKKwkJICovCisJCXB1YmxpYyBJUHJvamVjdCBnZXRQcm9qZWN0KCkgeworCQkJcmV0dXJuIHByb2plY3Q7CisJCX0KKworCQkvKioKKwkJICogUmV0dXJucyBhbGwgcmVzb3VyY2UgZGVzY3JpcHRpb25zIGNvbnRhaW5lZCBpbiB0aGUgcHJvamVjdCBmb3IgdGhlCisJCSAqIGdpdmVuIGxvY2FsZS4KKwkJICoKKwkJICogQHBhcmFtIGxvY2FsZQorCQkgKiAgICAgICAgICAgIHRoZSBsb2NhbGUKKwkJICogQHJldHVybiB0aGUgcmVzb3VyY2UgZGVzY3JpcHRpb25zCisJCSAqLworCQlwdWJsaWMgTGlzdDxSZXNvdXJjZURlc2NyaXB0aW9uPiBnZXRSZXNvdXJjZURlc2NyaXB0aW9ucyhMb2NhbGUgbG9jYWxlKSB7CisJCQlMaXN0PFJlc291cmNlRGVzY3JpcHRpb24+IHJlc3VsdCA9IG5ldyBBcnJheUxpc3Q8UmVzb3VyY2VEZXNjcmlwdGlvbj4oKTsKKwkJCWNvbGxlY3RCeUxvY2FsZShsb2NhbGUsIHJlc3VsdCk7CisJCQlyZXR1cm4gcmVzdWx0OworCQl9CisKKwkJLyoqCisJCSAqIENvbGxlY3QgYnkgbG9jYWxlLgorCQkgKgorCQkgKiBAcGFyYW0gbG9jYWxlCisJCSAqICAgICAgICAgICAgdGhlIGxvY2FsZQorCQkgKiBAcGFyYW0gcmVzdWx0CisJCSAqICAgICAgICAgICAgdGhlIHJlc3VsdAorCQkgKiBAcmV0dXJuIHRoZSByZXNvdXJjZSBkZXNjcmlwdGlvbgorCQkgKi8KKwkJcHJpdmF0ZSBSZXNvdXJjZURlc2NyaXB0aW9uIGNvbGxlY3RCeUxvY2FsZShMb2NhbGUgbG9jYWxlLAorCQkJCUxpc3Q8UmVzb3VyY2VEZXNjcmlwdGlvbj4gcmVzdWx0KSB7CisJCQlTZXQ8UmVzb3VyY2VEZXNjcmlwdGlvbj4gZGVzY3MgPSByZXNvdXJjZXMuZ2V0KGxvY2FsZSk7CisJCQlpZiAoZGVzY3MgIT0gbnVsbCkgeworCQkJCXJlc3VsdC5hZGRBbGwoZGVzY3MpOworCQkJfQorCQkJcmV0dXJuIG51bGw7CisJCX0KKworCQkvKioKKwkJICogUHV0cyB0aGUgbGlzdCBvZiByZXNvdXJjZXMgaW50byB0aGUgcmVzb3VyY2VzIG1hcC4KKwkJICoKKwkJICogQHBhcmFtIGtleQorCQkgKiAgICAgICAgICAgIHRoZSBrZXkKKwkJICogQHBhcmFtIHZhbHVlCisJCSAqICAgICAgICAgICAgdGhlIHZhbHVlCisJCSAqLworCQlwdWJsaWMgdm9pZCBwdXRSZXNvdXJjZXMoTG9jYWxlIGtleSwgU2V0PFJlc291cmNlRGVzY3JpcHRpb24+IHZhbHVlKSB7CisJCQlyZXNvdXJjZXMucHV0KGtleSwgdmFsdWUpOworCQl9CisKKwkJLyoqCisJCSAqIFB1dHMgYSBzaW5nbGUgcmVzb3VyY2UgaW50byB0aGUgcmVzb3VyY2VzIG1hcC4KKwkJICoKKwkJICogQHBhcmFtIHZhbHVlCisJCSAqICAgICAgICAgICAgdGhlIHZhbHVlCisJCSAqLworCQlwdWJsaWMgdm9pZCBwdXRSZXNvdXJjZShSZXNvdXJjZURlc2NyaXB0aW9uIHZhbHVlKSB7CisKKwkJCVNldDxSZXNvdXJjZURlc2NyaXB0aW9uPiBkZXNjcmlwdGlvbnMgPSByZXNvdXJjZXMuZ2V0KHZhbHVlCisJCQkJCS5nZXRMb2NhbGUoKSk7CisJCQlpZiAoZGVzY3JpcHRpb25zID09IG51bGwpIHsKKwkJCQlkZXNjcmlwdGlvbnMgPSBuZXcgSGFzaFNldDxJSTE4blJlZ2lzdHJ5LlJlc291cmNlRGVzY3JpcHRpb24+KCk7CisJCQkJZGVzY3JpcHRpb25zLmFkZCh2YWx1ZSk7CisJCQkJcmVzb3VyY2VzLnB1dCh2YWx1ZS5nZXRMb2NhbGUoKSwgZGVzY3JpcHRpb25zKTsKKwkJCX0gZWxzZSB7CisJCQkJLy8gaWYgdGhlIGhhc2gga2V5IG9mIGdpdmVuIHZhbHVlIGlzIGNvbnRhaW5lZCBpbiBzZXQsIHRoZW4KKwkJCQkvLyByZW1vdmUgaXQKKwkJCQlkZXNjcmlwdGlvbnMucmVtb3ZlKHZhbHVlKTsKKwkJCQkvLyBhbmQgYWRkIGl0IGFnYWluCisJCQkJZGVzY3JpcHRpb25zLmFkZCh2YWx1ZSk7CisJCQl9CisJCX0KKworCQkvKioKKwkJICogUmVtb3ZlcyB0aGUgZ2l2ZW4gcmVzb3VyY2UgZnJvbSB0aGUgaW50ZXJuYWwgbGlzdCBvZiByZXNvdXJjZXMuCisJCSAqCisJCSAqIEBwYXJhbSB2YWx1ZQorCQkgKiAgICAgICAgICAgIHRoZSB2YWx1ZQorCQkgKi8KKwkJcHVibGljIHZvaWQgcmVtb3ZlUmVzb3VyY2UoUmVzb3VyY2VEZXNjcmlwdGlvbiB2YWx1ZSkgeworCQkJc3luY2hyb25pemVkIChyZXNvdXJjZXMpIHsKKwkJCQlMb2NhbGUgbG9jYWxlID0gdmFsdWUuZ2V0TG9jYWxlKCk7CisJCQkJSVBhdGggcGF0aCA9IHZhbHVlLmdldFBhdGgoKTsKKworCQkJCXJlbW92ZVJlc291cmNlKGxvY2FsZSwgcGF0aCk7CisJCQl9CisJCX0KKworCQkvKioKKwkJICogUmVtb3ZlcyB0aGUgcmVzb3VyY2UgZm9yIHRoZSBnaXZlbiBwYXRoLgorCQkgKgorCQkgKiBAcGFyYW0gbG9jYWxlCisJCSAqICAgICAgICAgICAgdGhlIGxvY2FsZQorCQkgKiBAcGFyYW0gbG9jYXRpb24KKwkJICogICAgICAgICAgICB0aGUgbG9jYXRpb24KKwkJICovCisJCXB1YmxpYyB2b2lkIHJlbW92ZVJlc291cmNlKExvY2FsZSBsb2NhbGUsIElQYXRoIGxvY2F0aW9uKSB7CisJCQlTZXQ8UmVzb3VyY2VEZXNjcmlwdGlvbj4gZGVzY3JpcHRpb25zID0gcmVzb3VyY2VzLmdldChsb2NhbGUpOworCQkJZm9yIChJdGVyYXRvcjxSZXNvdXJjZURlc2NyaXB0aW9uPiBpdGVyYXRvciA9IGRlc2NyaXB0aW9ucworCQkJCQkuaXRlcmF0b3IoKTsgaXRlcmF0b3IuaGFzTmV4dCgpOykgeworCQkJCVJlc291cmNlRGVzY3JpcHRpb24gcmVzb3VyY2VEZXNjcmlwdGlvbiA9IGl0ZXJhdG9yLm5leHQoKTsKKwkJCQlpZiAocmVzb3VyY2VEZXNjcmlwdGlvbi5nZXRQYXRoKCkuZXF1YWxzKGxvY2F0aW9uKSkgeworCQkJCQlpdGVyYXRvci5yZW1vdmUoKTsKKwkJCQkJYnJlYWs7CisJCQkJfQorCQkJfQorCQl9CisKKwkJLyoqCisJCSAqIFJldHVybnMgYWxsIHJlc291cmNlIGRlc2NyaXB0aW9ucy4KKwkJICoKKwkJICogQHJldHVybiB0aGUgcmVzb3VyY2UgZGVzY3JpcHRpb25zCisJCSAqLworCQlwdWJsaWMgU2V0PFJlc291cmNlRGVzY3JpcHRpb24+IGdldFJlc291cmNlRGVzY3JpcHRpb25zKCkgeworCQkJU2V0PElJMThuUmVnaXN0cnkuUmVzb3VyY2VEZXNjcmlwdGlvbj4gcmVzdWx0ID0gbmV3IEhhc2hTZXQ8SUkxOG5SZWdpc3RyeS5SZXNvdXJjZURlc2NyaXB0aW9uPigpOworCQkJZm9yIChTZXQ8UmVzb3VyY2VEZXNjcmlwdGlvbj4gc2V0IDogcmVzb3VyY2VzLnZhbHVlcygpKSB7CisJCQkJZm9yIChSZXNvdXJjZURlc2NyaXB0aW9uIGRlc2MgOiBzZXQpIHsKKwkJCQkJcmVzdWx0LmFkZChkZXNjKTsKKwkJCQl9CisJCQl9CisJCQlyZXR1cm4gcmVzdWx0OworCQl9CisJfQorCisJLyoqCisJICogQSByZXNvdXJjZSBpcyBhIGZpbGUgY29udGFpbmluZyBhbGwgdHJhbnNsYXRpb25zIGZvciBhIGZpbGUuCisJICovCisJcHVibGljIHN0YXRpYyBjbGFzcyBSZXNvdXJjZURlc2NyaXB0aW9uIHsKKworCQkvKiogVGhlIHByb2plY3QuICovCisJCXByaXZhdGUgZmluYWwgSVByb2plY3QgcHJvamVjdDsKKwkJCisJCS8qKiBUaGUgbG9jYWxlLiAqLworCQlwcml2YXRlIGZpbmFsIExvY2FsZSBsb2NhbGU7CisJCQorCQkvKiogVGhlIHBhdGguICovCisJCXByaXZhdGUgZmluYWwgSVBhdGggcGF0aDsKKwkJCisJCS8qKiBUaGUgcHJvcGVydGllcy4gKi8KKwkJcHJpdmF0ZSBmaW5hbCBQcm9wZXJ0aWVzIHByb3BlcnRpZXM7CisKKwkJLyoqCisJCSAqIEluc3RhbnRpYXRlcyBhIG5ldyByZXNvdXJjZSBkZXNjcmlwdGlvbi4KKwkJICoKKwkJICogQHBhcmFtIHByb2plY3QKKwkJICogICAgICAgICAgICB0aGUgcHJvamVjdAorCQkgKiBAcGFyYW0gbG9jYWxlCisJCSAqICAgICAgICAgICAgdGhlIGxvY2FsZQorCQkgKiBAcGFyYW0gcGF0aAorCQkgKiAgICAgICAgICAgIHRoZSBwYXRoCisJCSAqIEBwYXJhbSBwcm9wZXJ0aWVzCisJCSAqICAgICAgICAgICAgdGhlIHByb3BlcnRpZXMKKwkJICovCisJCXB1YmxpYyBSZXNvdXJjZURlc2NyaXB0aW9uKElQcm9qZWN0IHByb2plY3QsIExvY2FsZSBsb2NhbGUsIElQYXRoIHBhdGgsCisJCQkJUHJvcGVydGllcyBwcm9wZXJ0aWVzKSB7CisJCQl0aGlzLnByb2plY3QgPSBwcm9qZWN0OworCQkJdGhpcy5sb2NhbGUgPSBsb2NhbGU7CisJCQl0aGlzLnBhdGggPSBwYXRoOworCQkJdGhpcy5wcm9wZXJ0aWVzID0gcHJvcGVydGllczsKKwkJfQorCisJCS8qKgorCQkgKiBHZXRzIHRoZSBwcm9qZWN0LgorCQkgKgorCQkgKiBAcmV0dXJuIHRoZSBwcm9qZWN0CisJCSAqLworCQlwdWJsaWMgSVByb2plY3QgZ2V0UHJvamVjdCgpIHsKKwkJCXJldHVybiBwcm9qZWN0OworCQl9CisKKwkJLyoqCisJCSAqIEdldHMgdGhlIGxvY2FsZS4KKwkJICoKKwkJICogQHJldHVybiB0aGUgbG9jYWxlCisJCSAqLworCQlwdWJsaWMgTG9jYWxlIGdldExvY2FsZSgpIHsKKwkJCXJldHVybiBsb2NhbGU7CisJCX0KKworCQkvKioKKwkJICogR2V0cyB0aGUgcGF0aC4KKwkJICoKKwkJICogQHJldHVybiB0aGUgcGF0aAorCQkgKi8KKwkJcHVibGljIElQYXRoIGdldFBhdGgoKSB7CisJCQlyZXR1cm4gcGF0aDsKKwkJfQorCisJCS8qKgorCQkgKiBHZXRzIHRoZSBwcm9wZXJ0aWVzLgorCQkgKgorCQkgKiBAcmV0dXJuIHRoZSBwcm9wZXJ0aWVzCisJCSAqLworCQlwdWJsaWMgUHJvcGVydGllcyBnZXRQcm9wZXJ0aWVzKCkgeworCQkJcmV0dXJuIHByb3BlcnRpZXM7CisJCX0KKworCQkvKiAobm9uLUphdmFkb2MpCisJCSAqIEBzZWUgamF2YS5sYW5nLk9iamVjdCNoYXNoQ29kZSgpCisJCSAqLworCQlAT3ZlcnJpZGUKKwkJcHVibGljIGludCBoYXNoQ29kZSgpIHsKKwkJCWZpbmFsIGludCBwcmltZSA9IDMxOworCQkJaW50IHJlc3VsdCA9IDE7CisJCQlyZXN1bHQgPSBwcmltZSAqIHJlc3VsdCArICgocGF0aCA9PSBudWxsKSA/IDAgOiBwYXRoLmhhc2hDb2RlKCkpOworCQkJcmV0dXJuIHJlc3VsdDsKKwkJfQorCisJCS8qIChub24tSmF2YWRvYykKKwkJICogQHNlZSBqYXZhLmxhbmcuT2JqZWN0I2VxdWFscyhqYXZhLmxhbmcuT2JqZWN0KQorCQkgKi8KKwkJQE92ZXJyaWRlCisJCXB1YmxpYyBib29sZWFuIGVxdWFscyhPYmplY3Qgb2JqKSB7CisJCQlpZiAodGhpcyA9PSBvYmopCisJCQkJcmV0dXJuIHRydWU7CisJCQlpZiAob2JqID09IG51bGwpCisJCQkJcmV0dXJuIGZhbHNlOworCQkJaWYgKGdldENsYXNzKCkgIT0gb2JqLmdldENsYXNzKCkpCisJCQkJcmV0dXJuIGZhbHNlOworCQkJUmVzb3VyY2VEZXNjcmlwdGlvbiBvdGhlciA9IChSZXNvdXJjZURlc2NyaXB0aW9uKSBvYmo7CisJCQlpZiAocGF0aCA9PSBudWxsKSB7CisJCQkJaWYgKG90aGVyLnBhdGggIT0gbnVsbCkKKwkJCQkJcmV0dXJuIGZhbHNlOworCQkJfSBlbHNlIGlmICghcGF0aC5lcXVhbHMob3RoZXIucGF0aCkpCisJCQkJcmV0dXJuIGZhbHNlOworCQkJcmV0dXJuIHRydWU7CisJCX0KKwl9CisKKwkvKioKKwkgKiBUaGUgQ2xhc3MgUHJvcG9zYWwuCisJICovCisJcHVibGljIHN0YXRpYyBjbGFzcyBQcm9wb3NhbCB7CisKKwkJLyoqIFRoZSBpMThuIGtleS4gKi8KKwkJcHJpdmF0ZSBmaW5hbCBTdHJpbmcgaTE4bktleTsKKwkJCisJCS8qKiBUaGUgaTE4biB2YWx1ZS4gKi8KKwkJcHJpdmF0ZSBmaW5hbCBTdHJpbmcgaTE4blZhbHVlOworCQkKKwkJLyoqIFRoZSByZXNvdXJjZSBkZXNjcmlwdGlvbi4gKi8KKwkJcHJpdmF0ZSBmaW5hbCBSZXNvdXJjZURlc2NyaXB0aW9uIHJlc291cmNlRGVzY3JpcHRpb247CisJCQorCQkvKiogVGhlIHByaW9yaXR5LiAqLworCQlAU3VwcHJlc3NXYXJuaW5ncygidW51c2VkIikKKwkJcHJpdmF0ZSBmaW5hbCBpbnQgcHJpb3JpdHk7CisKKwkJLyoqCisJCSAqIEluc3RhbnRpYXRlcyBhIG5ldyBwcm9wb3NhbC4KKwkJICoKKwkJICogQHBhcmFtIGkxOG5LZXkKKwkJICogICAgICAgICAgICB0aGUgaTE4biBrZXkKKwkJICogQHBhcmFtIGkxOG5WYWx1ZQorCQkgKiAgICAgICAgICAgIHRoZSBpMThuIHZhbHVlCisJCSAqIEBwYXJhbSByZXNvdXJjZURlc2NyaXB0aW9uCisJCSAqICAgICAgICAgICAgdGhlIHJlc291cmNlIGRlc2NyaXB0aW9uCisJCSAqIEBwYXJhbSBwcmlvcml0eQorCQkgKiAgICAgICAgICAgIHRoZSBwcmlvcml0eQorCQkgKi8KKwkJcHVibGljIFByb3Bvc2FsKFN0cmluZyBpMThuS2V5LCBTdHJpbmcgaTE4blZhbHVlLAorCQkJCVJlc291cmNlRGVzY3JpcHRpb24gcmVzb3VyY2VEZXNjcmlwdGlvbiwgaW50IHByaW9yaXR5KSB7CisJCQlzdXBlcigpOworCQkJdGhpcy5pMThuS2V5ID0gaTE4bktleTsKKwkJCXRoaXMuaTE4blZhbHVlID0gaTE4blZhbHVlOworCQkJdGhpcy5yZXNvdXJjZURlc2NyaXB0aW9uID0gcmVzb3VyY2VEZXNjcmlwdGlvbjsKKwkJCXRoaXMucHJpb3JpdHkgPSBwcmlvcml0eTsKKwkJfQorCisJCS8qKgorCQkgKiBSZXR1cm5zIHRoZSBpMThuS2V5LgorCQkgKgorCQkgKiBAcmV0dXJuIHRoZSBpMThuIGtleQorCQkgKi8KKwkJcHVibGljIFN0cmluZyBnZXRJMThuS2V5KCkgeworCQkJcmV0dXJuIGkxOG5LZXk7CisJCX0KKworCQkvKioKKwkJICogUmV0dXJucyB0aGUgaTE4blZhbHVlLgorCQkgKgorCQkgKiBAcmV0dXJuIHRoZSBpMThuIHZhbHVlCisJCSAqLworCQlwdWJsaWMgU3RyaW5nIGdldEkxOG5WYWx1ZSgpIHsKKwkJCXJldHVybiBpMThuVmFsdWU7CisJCX0KKworCQkvKioKKwkJICogUmV0dXJucyB0aGUgbG9jYWxlIHdoZXJlIGtleSBhbmQgdmFsdWUgaGFkIGJlZW4gZm91bmQuCisJCSAqCisJCSAqIEByZXR1cm4gdGhlIGxvY2FsZQorCQkgKi8KKwkJcHVibGljIExvY2FsZSBnZXRMb2NhbGUoKSB7CisJCQlyZXR1cm4gcmVzb3VyY2VEZXNjcmlwdGlvbi5nZXRMb2NhbGUoKTsKKwkJfQorCisJCS8qKgorCQkgKiBSZXR1cm5zIHRoZSByZXNvdXJjZSBkZXNjcmlwdGlvbiwgd2hlcmUgdGhlIGkxOG4gZW50cnkgd2FzIGNvbnRhaW5lZC4KKwkJICoKKwkJICogQHJldHVybiB0aGUgcmVzb3VyY2UgZGVzY3JpcHRpb24KKwkJICovCisJCXB1YmxpYyBSZXNvdXJjZURlc2NyaXB0aW9uIGdldFJlc291cmNlRGVzY3JpcHRpb24oKSB7CisJCQlyZXR1cm4gcmVzb3VyY2VEZXNjcmlwdGlvbjsKKwkJfQorCisJfQorfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvLnByb2plY3QgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC8ucHJvamVjdApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45OGJlNGMxCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvLnByb2plY3QKQEAgLTAsMCArMSw1MSBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KKzxwcm9qZWN0RGVzY3JpcHRpb24+CisJPG5hbWU+b3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQ8L25hbWU+CisJPGNvbW1lbnQ+PC9jb21tZW50PgorCTxwcm9qZWN0cz4KKwk8L3Byb2plY3RzPgorCTxidWlsZFNwZWM+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS54dGV4dC51aS5zaGFyZWQueHRleHRCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLmpkdC5jb3JlLmphdmFidWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5NYW5pZmVzdEJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLlNjaGVtYUJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UuYmFiZWwuZWRpdG9yLnJiZUJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLnNvbmFybGludC5lY2xpcHNlLmNvcmUuc29uYXJsaW50QnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5tMmUuY29yZS5tYXZlbjJCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwk8L2J1aWxkU3BlYz4KKwk8bmF0dXJlcz4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS54dGV4dC51aS5zaGFyZWQueHRleHROYXR1cmU8L25hdHVyZT4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS5tMmUuY29yZS5tYXZlbjJOYXR1cmU8L25hdHVyZT4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS5wZGUuUGx1Z2luTmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UuamR0LmNvcmUuamF2YW5hdHVyZTwvbmF0dXJlPgorCQk8bmF0dXJlPm9yZy5lY2xpcHNlLmJhYmVsLmVkaXRvci5yYmVOYXR1cmU8L25hdHVyZT4KKwk8L25hdHVyZXM+Cis8L3Byb2plY3REZXNjcmlwdGlvbj4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkL0xJQ0VOU0UudHh0IGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvTElDRU5TRS50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZmY0MmFkNAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkL0xJQ0VOU0UudHh0CkBAIC0wLDAgKzEsMTYxIEBACitFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC12IDEuMAorCitUSEUgQUNDT01QQU5ZSU5HIFBST0dSQU0gSVMgUFJPVklERUQgVU5ERVIgVEhFIFRFUk1TIE9GIFRISVMgRUNMSVBTRSBQVUJMSUMgTElDRU5TRSAoIkFHUkVFTUVOVCIpLiBBTlkgVVNFLCBSRVBST0RVQ1RJT04KK09SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBDT05TVElUVVRFUyBSRUNJUElFTlQnUyBBQ0NFUFRBTkNFIE9GIFRISVMgQUdSRUVNRU5ULgorCisxLiBERUZJTklUSU9OUworCisiQ29udHJpYnV0aW9uIiBtZWFuczoKKworYSkgaW4gdGhlIGNhc2Ugb2YgdGhlIGluaXRpYWwgQ29udHJpYnV0b3IsIHRoZSBpbml0aWFsIGNvZGUgYW5kIGRvY3VtZW50YXRpb24gZGlzdHJpYnV0ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGFuZAorCitiKSBpbiB0aGUgY2FzZSBvZiBlYWNoIHN1YnNlcXVlbnQgQ29udHJpYnV0b3I6CisKK2kpIGNoYW5nZXMgdG8gdGhlIFByb2dyYW0sIGFuZAorCitpaSkgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtOworCit3aGVyZSBzdWNoIGNoYW5nZXMgYW5kL29yIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbSBvcmlnaW5hdGUgZnJvbSBhbmQgYXJlIGRpc3RyaWJ1dGVkIGJ5IHRoYXQgcGFydGljdWxhciBDb250cmlidXRvci4KK0EgQ29udHJpYnV0aW9uICdvcmlnaW5hdGVzJyBmcm9tIGEgQ29udHJpYnV0b3IgaWYgaXQgd2FzIGFkZGVkIHRvIHRoZSBQcm9ncmFtIGJ5IHN1Y2ggQ29udHJpYnV0b3IgaXRzZWxmIG9yIGFueW9uZQorYWN0aW5nIG9uIHN1Y2ggQ29udHJpYnV0b3IncyBiZWhhbGYuIENvbnRyaWJ1dGlvbnMgZG8gbm90IGluY2x1ZGUgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIHdoaWNoOiAoaSkgYXJlIHNlcGFyYXRlCittb2R1bGVzIG9mIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIGluIGNvbmp1bmN0aW9uIHdpdGggdGhlIFByb2dyYW0gdW5kZXIgdGhlaXIgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBhbmQgKGlpKSBhcmUgbm90CitkZXJpdmF0aXZlIHdvcmtzIG9mIHRoZSBQcm9ncmFtLgorCisiQ29udHJpYnV0b3IiIG1lYW5zIGFueSBwZXJzb24gb3IgZW50aXR5IHRoYXQgZGlzdHJpYnV0ZXMgdGhlIFByb2dyYW0uCisKKyJMaWNlbnNlZCBQYXRlbnRzICIgbWVhbiBwYXRlbnQgY2xhaW1zIGxpY2Vuc2FibGUgYnkgYSBDb250cmlidXRvciB3aGljaCBhcmUgbmVjZXNzYXJpbHkgaW5mcmluZ2VkIGJ5IHRoZSB1c2Ugb3Igc2FsZSBvZgoraXRzIENvbnRyaWJ1dGlvbiBhbG9uZSBvciB3aGVuIGNvbWJpbmVkIHdpdGggdGhlIFByb2dyYW0uCisKKyJQcm9ncmFtIiBtZWFucyB0aGUgQ29udHJpYnV0aW9ucyBkaXN0cmlidXRlZCBpbiBhY2NvcmRhbmNlIHdpdGggdGhpcyBBZ3JlZW1lbnQuCisKKyJSZWNpcGllbnQiIG1lYW5zIGFueW9uZSB3aG8gcmVjZWl2ZXMgdGhlIFByb2dyYW0gdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGluY2x1ZGluZyBhbGwgQ29udHJpYnV0b3JzLgorCisyLiBHUkFOVCBPRiBSSUdIVFMKKworYSkgU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsCityb3lhbHR5LWZyZWUgY29weXJpZ2h0IGxpY2Vuc2UgdG8gcmVwcm9kdWNlLCBwcmVwYXJlIGRlcml2YXRpdmUgd29ya3Mgb2YsIHB1YmxpY2x5IGRpc3BsYXksIHB1YmxpY2x5IHBlcmZvcm0sIGRpc3RyaWJ1dGUKK2FuZCBzdWJsaWNlbnNlIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBhbmQgc3VjaCBkZXJpdmF0aXZlIHdvcmtzLCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUKK2Zvcm0uCisKK2IpIFN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLAorcm95YWx0eS1mcmVlIHBhdGVudCBsaWNlbnNlIHVuZGVyIExpY2Vuc2VkIFBhdGVudHMgdG8gbWFrZSwgdXNlLCBzZWxsLCBvZmZlciB0byBzZWxsLCBpbXBvcnQgYW5kIG90aGVyd2lzZSB0cmFuc2ZlciB0aGUKK0NvbnRyaWJ1dGlvbiBvZiBzdWNoIENvbnRyaWJ1dG9yLCBpZiBhbnksIGluIHNvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLiBUaGlzIHBhdGVudCBsaWNlbnNlIHNoYWxsIGFwcGx5IHRvIHRoZQorY29tYmluYXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBhbmQgdGhlIFByb2dyYW0gaWYsIGF0IHRoZSB0aW1lIHRoZSBDb250cmlidXRpb24gaXMgYWRkZWQgYnkgdGhlIENvbnRyaWJ1dG9yLCBzdWNoCithZGRpdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGNhdXNlcyBzdWNoIGNvbWJpbmF0aW9uIHRvIGJlIGNvdmVyZWQgYnkgdGhlIExpY2Vuc2VkIFBhdGVudHMuIFRoZSBwYXRlbnQgbGljZW5zZSBzaGFsbCBub3QKK2FwcGx5IHRvIGFueSBvdGhlciBjb21iaW5hdGlvbnMgd2hpY2ggaW5jbHVkZSB0aGUgQ29udHJpYnV0aW9uLiBObyBoYXJkd2FyZSBwZXIgc2UgaXMgbGljZW5zZWQgaGVyZXVuZGVyLgorCitjKSBSZWNpcGllbnQgdW5kZXJzdGFuZHMgdGhhdCBhbHRob3VnaCBlYWNoIENvbnRyaWJ1dG9yIGdyYW50cyB0aGUgbGljZW5zZXMgdG8gaXRzIENvbnRyaWJ1dGlvbnMgc2V0IGZvcnRoIGhlcmVpbiwgbm8KK2Fzc3VyYW5jZXMgYXJlIHByb3ZpZGVkIGJ5IGFueSBDb250cmlidXRvciB0aGF0IHRoZSBQcm9ncmFtIGRvZXMgbm90IGluZnJpbmdlIHRoZSBwYXRlbnQgb3Igb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5CityaWdodHMgb2YgYW55IG90aGVyIGVudGl0eS4gRWFjaCBDb250cmlidXRvciBkaXNjbGFpbXMgYW55IGxpYWJpbGl0eSB0byBSZWNpcGllbnQgZm9yIGNsYWltcyBicm91Z2h0IGJ5IGFueSBvdGhlciBlbnRpdHkKK2Jhc2VkIG9uIGluZnJpbmdlbWVudCBvZiBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG9yIG90aGVyd2lzZS4gQXMgYSBjb25kaXRpb24gdG8gZXhlcmNpc2luZyB0aGUgcmlnaHRzIGFuZAorbGljZW5zZXMgZ3JhbnRlZCBoZXJldW5kZXIsIGVhY2ggUmVjaXBpZW50IGhlcmVieSBhc3N1bWVzIHNvbGUgcmVzcG9uc2liaWxpdHkgdG8gc2VjdXJlIGFueSBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkKK3JpZ2h0cyBuZWVkZWQsIGlmIGFueS4gRm9yIGV4YW1wbGUsIGlmIGEgdGhpcmQgcGFydHkgcGF0ZW50IGxpY2Vuc2UgaXMgcmVxdWlyZWQgdG8gYWxsb3cgUmVjaXBpZW50IHRvIGRpc3RyaWJ1dGUgdGhlCitQcm9ncmFtLCBpdCBpcyBSZWNpcGllbnQncyByZXNwb25zaWJpbGl0eSB0byBhY3F1aXJlIHRoYXQgbGljZW5zZSBiZWZvcmUgZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtLgorCitkKSBFYWNoIENvbnRyaWJ1dG9yIHJlcHJlc2VudHMgdGhhdCB0byBpdHMga25vd2xlZGdlIGl0IGhhcyBzdWZmaWNpZW50IGNvcHlyaWdodCByaWdodHMgaW4gaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCB0bworZ3JhbnQgdGhlIGNvcHlyaWdodCBsaWNlbnNlIHNldCBmb3J0aCBpbiB0aGlzIEFncmVlbWVudC4KKworMy4gUkVRVUlSRU1FTlRTCisKK0EgQ29udHJpYnV0b3IgbWF5IGNob29zZSB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtIGluIG9iamVjdCBjb2RlIGZvcm0gdW5kZXIgaXRzIG93biBsaWNlbnNlIGFncmVlbWVudCwgcHJvdmlkZWQgdGhhdDoKKworYSkgaXQgY29tcGxpZXMgd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQ7IGFuZAorCitiKSBpdHMgbGljZW5zZSBhZ3JlZW1lbnQ6CisKK2kpIGVmZmVjdGl2ZWx5IGRpc2NsYWltcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgd2FycmFudGllcyBhbmQgY29uZGl0aW9ucywgZXhwcmVzcyBhbmQgaW1wbGllZCwgaW5jbHVkaW5nCit3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgdGl0bGUgYW5kIG5vbi1pbmZyaW5nZW1lbnQsIGFuZCBpbXBsaWVkIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiBtZXJjaGFudGFiaWxpdHkgYW5kCitmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZTsKKworaWkpIGVmZmVjdGl2ZWx5IGV4Y2x1ZGVzIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCBsaWFiaWxpdHkgZm9yIGRhbWFnZXMsIGluY2x1ZGluZyBkaXJlY3QsIGluZGlyZWN0LCBzcGVjaWFsLAoraW5jaWRlbnRhbCBhbmQgY29uc2VxdWVudGlhbCBkYW1hZ2VzLCBzdWNoIGFzIGxvc3QgcHJvZml0czsKKworaWlpKSBzdGF0ZXMgdGhhdCBhbnkgcHJvdmlzaW9ucyB3aGljaCBkaWZmZXIgZnJvbSB0aGlzIEFncmVlbWVudCBhcmUgb2ZmZXJlZCBieSB0aGF0IENvbnRyaWJ1dG9yIGFsb25lIGFuZCBub3QgYnkgYW55CitvdGhlciBwYXJ0eTsgYW5kCisKK2l2KSBzdGF0ZXMgdGhhdCBzb3VyY2UgY29kZSBmb3IgdGhlIFByb2dyYW0gaXMgYXZhaWxhYmxlIGZyb20gc3VjaCBDb250cmlidXRvciwgYW5kIGluZm9ybXMgbGljZW5zZWVzIGhvdyB0byBvYnRhaW4gaXQKK2luIGEgcmVhc29uYWJsZSBtYW5uZXIgb24gb3IgdGhyb3VnaCBhIG1lZGl1bSBjdXN0b21hcmlseSB1c2VkIGZvciBzb2Z0d2FyZSBleGNoYW5nZS4KKworV2hlbiB0aGUgUHJvZ3JhbSBpcyBtYWRlIGF2YWlsYWJsZSBpbiBzb3VyY2UgY29kZSBmb3JtOgorCithKSBpdCBtdXN0IGJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoaXMgQWdyZWVtZW50OyBhbmQKKworYikgYSBjb3B5IG9mIHRoaXMgQWdyZWVtZW50IG11c3QgYmUgaW5jbHVkZWQgd2l0aCBlYWNoIGNvcHkgb2YgdGhlIFByb2dyYW0uCisKK0NvbnRyaWJ1dG9ycyBtYXkgbm90IHJlbW92ZSBvciBhbHRlciBhbnkgY29weXJpZ2h0IG5vdGljZXMgY29udGFpbmVkIHdpdGhpbiB0aGUgUHJvZ3JhbS4KKworRWFjaCBDb250cmlidXRvciBtdXN0IGlkZW50aWZ5IGl0c2VsZiBhcyB0aGUgb3JpZ2luYXRvciBvZiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIGluIGEgbWFubmVyIHRoYXQgcmVhc29uYWJseSBhbGxvd3MKK3N1YnNlcXVlbnQgUmVjaXBpZW50cyB0byBpZGVudGlmeSB0aGUgb3JpZ2luYXRvciBvZiB0aGUgQ29udHJpYnV0aW9uLgorCis0LiBDT01NRVJDSUFMIERJU1RSSUJVVElPTgorCitDb21tZXJjaWFsIGRpc3RyaWJ1dG9ycyBvZiBzb2Z0d2FyZSBtYXkgYWNjZXB0IGNlcnRhaW4gcmVzcG9uc2liaWxpdGllcyB3aXRoIHJlc3BlY3QgdG8gZW5kIHVzZXJzLCBidXNpbmVzcyBwYXJ0bmVycyBhbmQKK3RoZSBsaWtlLiBXaGlsZSB0aGlzIGxpY2Vuc2UgaXMgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY29tbWVyY2lhbCB1c2Ugb2YgdGhlIFByb2dyYW0sIHRoZSBDb250cmlidXRvciB3aG8gaW5jbHVkZXMKK3RoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nIHNob3VsZCBkbyBzbyBpbiBhIG1hbm5lciB3aGljaCBkb2VzIG5vdCBjcmVhdGUgcG90ZW50aWFsIGxpYWJpbGl0eSBmb3IKK290aGVyIENvbnRyaWJ1dG9ycy4gVGhlcmVmb3JlLCBpZiBhIENvbnRyaWJ1dG9yIGluY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBzdWNoIENvbnRyaWJ1dG9yCisoIkNvbW1lcmNpYWwgQ29udHJpYnV0b3IiKSBoZXJlYnkgYWdyZWVzIHRvIGRlZmVuZCBhbmQgaW5kZW1uaWZ5IGV2ZXJ5IG90aGVyIENvbnRyaWJ1dG9yICgiSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IiKQorYWdhaW5zdCBhbnkgbG9zc2VzLCBkYW1hZ2VzIGFuZCBjb3N0cyAoY29sbGVjdGl2ZWx5ICJMb3NzZXMiKSBhcmlzaW5nIGZyb20gY2xhaW1zLCBsYXdzdWl0cyBhbmQgb3RoZXIgbGVnYWwgYWN0aW9ucworYnJvdWdodCBieSBhIHRoaXJkIHBhcnR5IGFnYWluc3QgdGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIHRvIHRoZSBleHRlbnQgY2F1c2VkIGJ5IHRoZSBhY3RzIG9yIG9taXNzaW9ucyBvZiBzdWNoCitDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluIGNvbm5lY3Rpb24gd2l0aCBpdHMgZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLiBUaGUKK29ibGlnYXRpb25zIGluIHRoaXMgc2VjdGlvbiBkbyBub3QgYXBwbHkgdG8gYW55IGNsYWltcyBvciBMb3NzZXMgcmVsYXRpbmcgdG8gYW55IGFjdHVhbCBvciBhbGxlZ2VkIGludGVsbGVjdHVhbAorcHJvcGVydHkgaW5mcmluZ2VtZW50LiBJbiBvcmRlciB0byBxdWFsaWZ5LCBhbiBJbmRlbW5pZmllZCBDb250cmlidXRvciBtdXN0OiBhKSBwcm9tcHRseSBub3RpZnkgdGhlIENvbW1lcmNpYWwKK0NvbnRyaWJ1dG9yIGluIHdyaXRpbmcgb2Ygc3VjaCBjbGFpbSwgYW5kIGIpIGFsbG93IHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRvIGNvbnRyb2wsIGFuZCBjb29wZXJhdGUgd2l0aCB0aGUKK0NvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4sIHRoZSBkZWZlbnNlIGFuZCBhbnkgcmVsYXRlZCBzZXR0bGVtZW50IG5lZ290aWF0aW9ucy4gVGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG1heQorIHBhcnRpY2lwYXRlIGluIGFueSBzdWNoIGNsYWltIGF0IGl0cyBvd24gZXhwZW5zZS4KKworRm9yIGV4YW1wbGUsIGEgQ29udHJpYnV0b3IgbWlnaHQgaW5jbHVkZSB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgUHJvZHVjdCBYLiBUaGF0IENvbnRyaWJ1dG9yIGlzCit0aGVuIGEgQ29tbWVyY2lhbCBDb250cmlidXRvci4gSWYgdGhhdCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRoZW4gbWFrZXMgcGVyZm9ybWFuY2UgY2xhaW1zLCBvciBvZmZlcnMgd2FycmFudGllcworcmVsYXRlZCB0byBQcm9kdWN0IFgsIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcyBhcmUgc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yJ3MgcmVzcG9uc2liaWxpdHkgYWxvbmUuCitVbmRlciB0aGlzIHNlY3Rpb24sIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHdvdWxkIGhhdmUgdG8gZGVmZW5kIGNsYWltcyBhZ2FpbnN0IHRoZSBvdGhlciBDb250cmlidXRvcnMgcmVsYXRlZCB0bwordGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZCB3YXJyYW50aWVzLCBhbmQgaWYgYSBjb3VydCByZXF1aXJlcyBhbnkgb3RoZXIgQ29udHJpYnV0b3IgdG8gcGF5IGFueSBkYW1hZ2VzIGFzIGEgcmVzdWx0LAordGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgbXVzdCBwYXkgdGhvc2UgZGFtYWdlcy4KKworNS4gTk8gV0FSUkFOVFkKKworRVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUyBBR1JFRU1FTlQsIFRIRSBQUk9HUkFNIElTIFBST1ZJREVEIE9OIEFOICJBUyBJUyIgQkFTSVMsIFdJVEhPVVQgV0FSUkFOVElFUyBPUgorQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgRUlUSEVSIEVYUFJFU1MgT1IgSU1QTElFRCBJTkNMVURJTkcsIFdJVEhPVVQgTElNSVRBVElPTiwgQU5ZIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBUSVRMRSwKK05PTi1JTkZSSU5HRU1FTlQsIE1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gRWFjaCBSZWNpcGllbnQgaXMgc29sZWx5IHJlc3BvbnNpYmxlIGZvcgorZGV0ZXJtaW5pbmcgdGhlIGFwcHJvcHJpYXRlbmVzcyBvZiB1c2luZyBhbmQgZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtIGFuZCBhc3N1bWVzIGFsbCByaXNrcyBhc3NvY2lhdGVkIHdpdGggaXRzCitleGVyY2lzZSBvZiByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgLCBpbmNsdWRpbmcgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSByaXNrcyBhbmQgY29zdHMgb2YgcHJvZ3JhbSBlcnJvcnMsIGNvbXBsaWFuY2UKK3dpdGggYXBwbGljYWJsZSBsYXdzLCBkYW1hZ2UgdG8gb3IgbG9zcyBvZiBkYXRhLCBwcm9ncmFtcyBvciBlcXVpcG1lbnQsIGFuZCB1bmF2YWlsYWJpbGl0eSBvciBpbnRlcnJ1cHRpb24gb2Ygb3BlcmF0aW9ucy4KKworNi4gRElTQ0xBSU1FUiBPRiBMSUFCSUxJVFkKKworRVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUyBBR1JFRU1FTlQsIE5FSVRIRVIgUkVDSVBJRU5UIE5PUiBBTlkgQ09OVFJJQlVUT1JTIFNIQUxMIEhBVkUgQU5ZIExJQUJJTElUWSBGT1IgQU5ZCitESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HIFdJVEhPVVQgTElNSVRBVElPTiBMT1NUIFBST0ZJVFMpLAorSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUgorT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIE9SIFRIRSBFWEVSQ0lTRSBPRiBBTlkgUklHSFRTIEdSQU5URUQKK0hFUkVVTkRFUiwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRVMuCisKKzcuIEdFTkVSQUwKKworSWYgYW55IHByb3Zpc2lvbiBvZiB0aGlzIEFncmVlbWVudCBpcyBpbnZhbGlkIG9yIHVuZW5mb3JjZWFibGUgdW5kZXIgYXBwbGljYWJsZSBsYXcsIGl0IHNoYWxsIG5vdCBhZmZlY3QgdGhlIHZhbGlkaXR5IG9yCitlbmZvcmNlYWJpbGl0eSBvZiB0aGUgcmVtYWluZGVyIG9mIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgYW5kIHdpdGhvdXQgZnVydGhlciBhY3Rpb24gYnkgdGhlIHBhcnRpZXMgaGVyZXRvLCBzdWNoCitwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlIG1pbmltdW0gZXh0ZW50IG5lY2Vzc2FyeSB0byBtYWtlIHN1Y2ggcHJvdmlzaW9uIHZhbGlkIGFuZCBlbmZvcmNlYWJsZS4KKworSWYgUmVjaXBpZW50IGluc3RpdHV0ZXMgcGF0ZW50IGxpdGlnYXRpb24gYWdhaW5zdCBhbnkgZW50aXR5IChpbmNsdWRpbmcgYSBjcm9zcy1jbGFpbSBvciBjb3VudGVyY2xhaW0gaW4gYSBsYXdzdWl0KQorYWxsZWdpbmcgdGhhdCB0aGUgUHJvZ3JhbSBpdHNlbGYgKGV4Y2x1ZGluZyBjb21iaW5hdGlvbnMgb2YgdGhlIFByb2dyYW0gd2l0aCBvdGhlciBzb2Z0d2FyZSBvciBoYXJkd2FyZSkgaW5mcmluZ2VzIHN1Y2gKK1JlY2lwaWVudCdzIHBhdGVudChzKSwgdGhlbiBzdWNoIFJlY2lwaWVudCdzIHJpZ2h0cyBncmFudGVkIHVuZGVyIFNlY3Rpb24gMihiKSBzaGFsbCB0ZXJtaW5hdGUgYXMgb2YgdGhlIGRhdGUgc3VjaAorbGl0aWdhdGlvbiBpcyBmaWxlZC4KKworQWxsIFJlY2lwaWVudCdzIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCBzaGFsbCB0ZXJtaW5hdGUgaWYgaXQgZmFpbHMgdG8gY29tcGx5IHdpdGggYW55IG9mIHRoZSBtYXRlcmlhbCB0ZXJtcyBvcgorY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudCBhbmQgZG9lcyBub3QgY3VyZSBzdWNoIGZhaWx1cmUgaW4gYSByZWFzb25hYmxlIHBlcmlvZCBvZiB0aW1lIGFmdGVyIGJlY29taW5nIGF3YXJlIG9mIHN1Y2gKK25vbmNvbXBsaWFuY2UuIElmIGFsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgdGVybWluYXRlLCBSZWNpcGllbnQgYWdyZWVzIHRvIGNlYXNlIHVzZSBhbmQgZGlzdHJpYnV0aW9uCitvZiB0aGUgUHJvZ3JhbSBhcyBzb29uIGFzIHJlYXNvbmFibHkgcHJhY3RpY2FibGUuIEhvd2V2ZXIsIFJlY2lwaWVudCdzIG9ibGlnYXRpb25zIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFuZCBhbnkgbGljZW5zZXMKKyBncmFudGVkIGJ5IFJlY2lwaWVudCByZWxhdGluZyB0byB0aGUgUHJvZ3JhbSBzaGFsbCBjb250aW51ZSBhbmQgc3Vydml2ZS4KKworRXZlcnlvbmUgaXMgcGVybWl0dGVkIHRvIGNvcHkgYW5kIGRpc3RyaWJ1dGUgY29waWVzIG9mIHRoaXMgQWdyZWVtZW50LCBidXQgaW4gb3JkZXIgdG8gYXZvaWQgaW5jb25zaXN0ZW5jeSB0aGUgQWdyZWVtZW50CitpcyBjb3B5cmlnaHRlZCBhbmQgbWF5IG9ubHkgYmUgbW9kaWZpZWQgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXIuIFRoZSBBZ3JlZW1lbnQgU3Rld2FyZCByZXNlcnZlcyB0aGUgcmlnaHQgdG8gcHVibGlzaAorbmV3IHZlcnNpb25zIChpbmNsdWRpbmcgcmV2aXNpb25zKSBvZiB0aGlzIEFncmVlbWVudCBmcm9tIHRpbWUgdG8gdGltZS4gTm8gb25lIG90aGVyIHRoYW4gdGhlIEFncmVlbWVudCBTdGV3YXJkIGhhcyB0aGUKK3JpZ2h0IHRvIG1vZGlmeSB0aGlzIEFncmVlbWVudC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyB0aGUgaW5pdGlhbCBBZ3JlZW1lbnQgU3Rld2FyZC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYXkKK2Fzc2lnbiB0aGUgcmVzcG9uc2liaWxpdHkgdG8gc2VydmUgYXMgdGhlIEFncmVlbWVudCBTdGV3YXJkIHRvIGEgc3VpdGFibGUgc2VwYXJhdGUgZW50aXR5LiBFYWNoIG5ldyB2ZXJzaW9uIG9mIHRoZQorQWdyZWVtZW50IHdpbGwgYmUgZ2l2ZW4gYSBkaXN0aW5ndWlzaGluZyB2ZXJzaW9uIG51bWJlci4gVGhlIFByb2dyYW0gKGluY2x1ZGluZyBDb250cmlidXRpb25zKSBtYXkgYWx3YXlzIGJlCitkaXN0cmlidXRlZCBzdWJqZWN0IHRvIHRoZSB2ZXJzaW9uIG9mIHRoZSBBZ3JlZW1lbnQgdW5kZXIgd2hpY2ggaXQgd2FzIHJlY2VpdmVkLiBJbiBhZGRpdGlvbiwgYWZ0ZXIgYSBuZXcgdmVyc2lvbiBvZgordGhlIEFncmVlbWVudCBpcyBwdWJsaXNoZWQsIENvbnRyaWJ1dG9yIG1heSBlbGVjdCB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtIChpbmNsdWRpbmcgaXRzIENvbnRyaWJ1dGlvbnMpIHVuZGVyIHRoZQorbmV3IHZlcnNpb24uIEV4Y2VwdCBhcyBleHByZXNzbHkgc3RhdGVkIGluIFNlY3Rpb25zIDIoYSkgYW5kIDIoYikgYWJvdmUsIFJlY2lwaWVudCByZWNlaXZlcyBubyByaWdodHMgb3IgbGljZW5zZXMgdG8KK3RoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgb2YgYW55IENvbnRyaWJ1dG9yIHVuZGVyIHRoaXMgQWdyZWVtZW50LCB3aGV0aGVyIGV4cHJlc3NseSwgYnkgaW1wbGljYXRpb24sIGVzdG9wcGVsIG9yCitvdGhlcndpc2UuIEFsbCByaWdodHMgaW4gdGhlIFByb2dyYW0gbm90IGV4cHJlc3NseSBncmFudGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFyZSByZXNlcnZlZC4KKworVGhpcyBBZ3JlZW1lbnQgaXMgZ292ZXJuZWQgYnkgdGhlIGxhd3Mgb2YgdGhlIFN0YXRlIG9mIE5ldyBZb3JrIGFuZCB0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGxhd3Mgb2YgdGhlIFVuaXRlZCBTdGF0ZXMKK29mIEFtZXJpY2EuIE5vIHBhcnR5IHRvIHRoaXMgQWdyZWVtZW50IHdpbGwgYnJpbmcgYSBsZWdhbCBhY3Rpb24gdW5kZXIgdGhpcyBBZ3JlZW1lbnQgbW9yZSB0aGFuIG9uZSB5ZWFyIGFmdGVyIHRoZSBjYXVzZQorb2YgYWN0aW9uIGFyb3NlLiBFYWNoIHBhcnR5IHdhaXZlcyBpdHMgcmlnaHRzIHRvIGEganVyeSB0cmlhbCBpbiBhbnkgcmVzdWx0aW5nIGxpdGlnYXRpb24uClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvTUVUQS1JTkYvTUFOSUZFU1QuTUYgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9NRVRBLUlORi9NQU5JRkVTVC5NRgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43MDM3NWI1Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvTUVUQS1JTkYvTUFOSUZFU1QuTUYKQEAgLTAsMCArMSwyNCBAQAorTWFuaWZlc3QtVmVyc2lvbjogMS4wCitCdW5kbGUtTWFuaWZlc3RWZXJzaW9uOiAyCitCdW5kbGUtTmFtZTogb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQKK0J1bmRsZS1TeW1ib2xpY05hbWU6IG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkO3NpbmdsZXRvbjo9dHJ1ZQorQnVuZGxlLVZlcnNpb246IDAuOS4wLnF1YWxpZmllcgorQnVuZGxlLUFjdGl2YXRvcjogb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQuaW50ZXJuYWwuQWN0aXZhdG9yCitCdW5kbGUtVmVuZG9yOiBFY2xpcHNlIE9TQlAKK0J1bmRsZS1SZXF1aXJlZEV4ZWN1dGlvbkVudmlyb25tZW50OiBKYXZhU0UtMS43CitJbXBvcnQtUGFja2FnZTogb3JnLm9zZ2kuZnJhbWV3b3JrO3ZlcnNpb249IjEuMy4wIiwKKyBvcmcub3NnaS5zZXJ2aWNlLmV2ZW50O3ZlcnNpb249IjEuMy4wIiwKKyBvcmcuc2xmNGo7dmVyc2lvbj0iMS43LjIiCitCdW5kbGUtQWN0aXZhdGlvblBvbGljeTogbGF6eQorUmVxdWlyZS1CdW5kbGU6IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzO2J1bmRsZS12ZXJzaW9uPSIzLjkuMCIsCisgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lO2J1bmRsZS12ZXJzaW9uPSIzLjEwLjAiLAorIG9yZy5lY2xpcHNlLnh0ZXh0LmJ1aWxkZXI7YnVuZGxlLXZlcnNpb249IlsyLjcuMywyLjguMCkiLAorIG9yZy5lY2xpcHNlLnVpLndvcmtiZW5jaCwKKyBvcmcuZWNsaXBzZS51aTtidW5kbGUtdmVyc2lvbj0iMy4xMDYuMCIsCisgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZTtidW5kbGUtdmVyc2lvbj0iWzAuOS4wLDAuMTAuMCkiLAorIG9yZy5lY2xpcHNlLnh0ZXh0LnVpO2J1bmRsZS12ZXJzaW9uPSJbMi43LjMsMi44LjApIiwKKyBvcmcuZWNsaXBzZS54dGV4dC51aS5zaGFyZWQ7YnVuZGxlLXZlcnNpb249IlsyLjcuMywyLjguMCkiLAorIG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpO2J1bmRsZS12ZXJzaW9uPSJbMC45LjAsMC4xMC4wKSIsCisgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aTtidW5kbGUtdmVyc2lvbj0iWzAuOS4wLDAuMTAuMCkiCitFeHBvcnQtUGFja2FnZTogb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQ7dmVyc2lvbj0iMC45LjAiLAorIG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkLmludGVybmFsO3gtaW50ZXJuYWw6PXRydWU7dmVyc2lvbj0iMC45LjAiCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9hYm91dC5odG1sIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvYWJvdXQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NGMwNTk4Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvYWJvdXQuaHRtbApAQCAtMCwwICsxLDI4IEBACis8IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBTdHJpY3QvL0VOIgorICAgICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS1zdHJpY3QuZHRkIj4KKzxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIj4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9SVNPLTg4NTktMSIvPgorPHRpdGxlPkFib3V0PC90aXRsZT4KKzwvaGVhZD4KKzxib2R5IGxhbmc9IkVOLVVTIj4KKzxoMj5BYm91dCBUaGlzIENvbnRlbnQ8L2gyPgorIAorPHA+SnVuZSAxLCAyMDE2PC9wPgkKKzxoMz5MaWNlbnNlPC9oMz4KKworPHA+VGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYWtlcyBhdmFpbGFibGUgYWxsIGNvbnRlbnQgaW4gdGhpcyBwbHVnLWluICgmcXVvdDtDb250ZW50JnF1b3Q7KS4gIFVubGVzcyBvdGhlcndpc2UgCitpbmRpY2F0ZWQgYmVsb3csIHRoZSBDb250ZW50IGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlCitFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wICgmcXVvdDtFUEwmcXVvdDspLiAgQSBjb3B5IG9mIHRoZSBFUEwgaXMgYXZhaWxhYmxlIAorYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sPC9hPi4KK0ZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAmcXVvdDtQcm9ncmFtJnF1b3Q7IHdpbGwgbWVhbiB0aGUgQ29udGVudC48L3A+CisKKzxwPklmIHlvdSBkaWQgbm90IHJlY2VpdmUgdGhpcyBDb250ZW50IGRpcmVjdGx5IGZyb20gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiwgdGhlIENvbnRlbnQgaXMgCitiZWluZyByZWRpc3RyaWJ1dGVkIGJ5IGFub3RoZXIgcGFydHkgKCZxdW90O1JlZGlzdHJpYnV0b3ImcXVvdDspIGFuZCBkaWZmZXJlbnQgdGVybXMgYW5kIGNvbmRpdGlvbnMgbWF5CithcHBseSB0byB5b3VyIHVzZSBvZiBhbnkgb2JqZWN0IGNvZGUgaW4gdGhlIENvbnRlbnQuICBDaGVjayB0aGUgUmVkaXN0cmlidXRvcidzIGxpY2Vuc2UgdGhhdCB3YXMgCitwcm92aWRlZCB3aXRoIHRoZSBDb250ZW50LiAgSWYgbm8gc3VjaCBsaWNlbnNlIGV4aXN0cywgY29udGFjdCB0aGUgUmVkaXN0cmlidXRvci4gIFVubGVzcyBvdGhlcndpc2UKK2luZGljYXRlZCBiZWxvdywgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFUEwgc3RpbGwgYXBwbHkgdG8gYW55IHNvdXJjZSBjb2RlIGluIHRoZSBDb250ZW50CithbmQgc3VjaCBzb3VyY2UgY29kZSBtYXkgYmUgb2J0YWluZWQgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy8iPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmc8L2E+LjwvcD4KKworPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkL2Fib3V0LmluaSBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkL2Fib3V0LmluaQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43ZGY2NzFmCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvYWJvdXQuaW5pCkBAIC0wLDAgKzEsMTcgQEAKKyMgYWJvdXQuaW5pCisjIGNvbnRhaW5zIGluZm9ybWF0aW9uIGFib3V0IGEgZmVhdHVyZQorIyBqYXZhLmlvLlByb3BlcnRpZXMgZmlsZSAoSVNPIDg4NTktMSB3aXRoICJcIiBlc2NhcGVzKQorIyAiJWtleSIgYXJlIGV4dGVybmFsaXplZCBzdHJpbmdzIGRlZmluZWQgaW4gYWJvdXQucHJvcGVydGllcworIyBUaGlzIGZpbGUgZG9lcyBub3QgbmVlZCB0byBiZSB0cmFuc2xhdGVkLgorCisjIFByb3BlcnR5ICJhYm91dFRleHQiIGNvbnRhaW5zIGJsdXJiIGZvciAiQWJvdXQiIGRpYWxvZyAodHJhbnNsYXRlZCkKK2Fib3V0VGV4dD0lZmVhdHVyZVRleHQKKworIyBQcm9wZXJ0eSAiZmVhdHVyZUltYWdlIiBjb250YWlucyBwYXRoIHRvIGZlYXR1cmUgaW1hZ2UgKDMyeDMyKQorZmVhdHVyZUltYWdlPQorCisjIFByb3BlcnR5ICJhcHBOYW1lIiBjb250YWlucyBuYW1lIG9mIHRoZSBhcHBsaWNhdGlvbiAodHJhbnNsYXRlZCkKK2FwcE5hbWU9JWZlYXR1cmVOYW1lCisKKyMgUHJvcGVydHkgIndlbGNvbWVQYWdlIiBjb250YWlucyBwYXRoIHRvIHdlbGNvbWUgcGFnZSAoc3BlY2lhbCBYTUwtYmFzZWQgZm9ybWF0KQord2VsY29tZVBhZ2U9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9hYm91dC5tYXBwaW5ncyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkL2Fib3V0Lm1hcHBpbmdzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQ1MTFhMGEKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9hYm91dC5tYXBwaW5ncwpAQCAtMCwwICsxLDYgQEAKKyMgYWJvdXQubWFwcGluZ3MKKyMgY29udGFpbnMgZmlsbC1pbnMgZm9yIGFib3V0LnByb3BlcnRpZXMKKyMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKKyMgVGhpcyBmaWxlIGRvZXMgbm90IG5lZWQgdG8gYmUgdHJhbnNsYXRlZC4KKworMD1xdWFsaWZpZXIKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkL2Fib3V0LnByb3BlcnRpZXMgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9hYm91dC5wcm9wZXJ0aWVzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjMwMzBhMTQKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9hYm91dC5wcm9wZXJ0aWVzCkBAIC0wLDAgKzEsMjYgQEAKKyMKKyMgQ29weXJpZ2h0IChjKSAyMDEyLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoSGVpZGVsYmVyZykKKyMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscworIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKKyMKKyMgQ29udHJpYnV0b3JzOgorIyAgICBMb2V0eiBHbWJIJkNvLktHIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCisjCisKKyMgTkxTX01FU1NBR0VGT1JNQVRfVkFSCisKK2ZlYXR1cmVOYW1lPW9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkCisKKyMjIyMjIyMjIyMjIyMjIyMgYmx1cmIgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCitmZWF0dXJlVGV4dD1cCitDb3B5cmlnaHQgKGMpIDIwMTItMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgXG5cCitBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzXG5cCithcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjBcblwKK3doaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0XG5cCitodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbFxuXAorXG5cCitDb250cmlidXRvcnM6XG5cCisgICAgTG9ldHogR21iSCZDby5LRyAtIGltcGxlbWVudGF0aW9uXG4KKyMjIyMjIyMjIyMjIyMjIyMgZW5kIG9mIGJsdXJiIHByb3BlcnR5ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIwpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvYnVpbGQucHJvcGVydGllcyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkL2J1aWxkLnByb3BlcnRpZXMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMGE1NzI5NQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkL2J1aWxkLnByb3BlcnRpZXMKQEAgLTAsMCArMSwxMSBAQAorc291cmNlLi4gPSBzcmMvCitvdXRwdXQuLiA9IHRhcmdldC9jbGFzc2VzLworYmluLmluY2x1ZGVzID0gYWJvdXQucHJvcGVydGllcywgIGFib3V0Lm1hcHBpbmdzLCAgYWJvdXQuaW5pLCAgYWJvdXQuaHRtbCwgIE1FVEEtSU5GLyxcCisgICAgICAgICAgICAgICAuLFwKKyAgICAgICAgICAgICAgIHBsdWdpbi54bWwsXAorICAgICAgICAgICAgICAgaWNvbnMvLFwKKyAgICAgICAgICAgICAgIC5wcm9qZWN0LFwKKyAgICAgICAgICAgICAgIExJQ0VOU0UudHh0LFwKKyAgICAgICAgICAgICAgIGxpY2Vuc2UuaHRtbAorc3JjLmluY2x1ZGVzID0gYWJvdXQucHJvcGVydGllcywgIGFib3V0Lm1hcHBpbmdzLCAgYWJvdXQuaW5pLCAgYWJvdXQuaHRtbCwgIGxpY2Vuc2UuaHRtbCxcCisgICAgICAgICAgICAgICBMSUNFTlNFLnR4dApkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvaWNvbnMvUHJvamVjdC5naWYgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9pY29ucy9Qcm9qZWN0LmdpZgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kY2M1MjRlCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvaWNvbnMvUHJvamVjdC5naWYKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvaWNvbnMvUHJvcGVydHkuZ2lmIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvaWNvbnMvUHJvcGVydHkuZ2lmCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQyZjI1N2MKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9pY29ucy9Qcm9wZXJ0eS5naWYKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvaWNvbnMvUmVzb3VyY2UuZ2lmIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvaWNvbnMvUmVzb3VyY2UuZ2lmCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmMyN2ZiYTQKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9pY29ucy9SZXNvdXJjZS5naWYKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvaWNvbnMvbmV3T1NCUFByb2plY3QucG5nIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvaWNvbnMvbmV3T1NCUFByb2plY3QucG5nCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjRiMjZkYmIKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9pY29ucy9uZXdPU0JQUHJvamVjdC5wbmcKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvbGljZW5zZS5odG1sIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvbGljZW5zZS5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmMzM2Q0NWMKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9saWNlbnNlLmh0bWwKQEAgLTAsMCArMSwxMDkgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IklTTy04ODU5LTEiID8+Cis8IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBTdHJpY3QvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtc3RyaWN0LmR0ZCI+Cis8IS0tIHNhdmVkIGZyb20gdXJsPSgwMDQ0KWh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsL25vdGljZS5odG1sIC0tPgorPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiPgorPGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1JU08tODg1OS0xIiAvPgorPHRpdGxlPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvdGl0bGU+Cis8L2hlYWQ+CisKKzxib2R5IGxhbmc9IkVOLVVTIj4KKzxoMj5FY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L2gyPgorPHA+RmVicnVhcnkgMSwgMjAxMTwvcD4KKworPGgzPlVzYWdlIE9mIENvbnRlbnQ8L2gzPgorCis8cD5USEUgRUNMSVBTRSBGT1VOREFUSU9OIE1BS0VTIEFWQUlMQUJMRSBTT0ZUV0FSRSwgRE9DVU1FTlRBVElPTiwgSU5GT1JNQVRJT04gQU5EL09SIE9USEVSIE1BVEVSSUFMUyBGT1IgT1BFTiBTT1VSQ0UgUFJPSkVDVFMKKyAgIChDT0xMRUNUSVZFTFkgJnF1b3Q7Q09OVEVOVCZxdW90OykuICBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5ECisgICBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVSBBR1JFRSBUSEFUIFlPVVIgVVNFCisgICBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUgorICAgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORCBUSEUgVEVSTVMgQU5ECisgICBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLCBUSEVOIFlPVSBNQVkgTk9UIFVTRSBUSEUgQ09OVEVOVC48L3A+CisKKzxoMz5BcHBsaWNhYmxlIExpY2Vuc2VzPC9oMz4KKworPHA+VW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMAorICAgKCZxdW90O0VQTCZxdW90OykuICBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXMgQ29udGVudCBhbmQgaXMgYWxzbyBhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sPC9hPi4KKyAgIEZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAmcXVvdDtQcm9ncmFtJnF1b3Q7IHdpbGwgbWVhbiB0aGUgQ29udGVudC48L3A+CisKKzxwPkNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLCBkb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gc291cmNlIGNvZGUKKyAgIHJlcG9zaXRvcnkgKCZxdW90O1JlcG9zaXRvcnkmcXVvdDspIGluIHNvZnR3YXJlIG1vZHVsZXMgKCZxdW90O01vZHVsZXMmcXVvdDspIGFuZCBtYWRlIGF2YWlsYWJsZSBhcyBkb3dubG9hZGFibGUgYXJjaGl2ZXMgKCZxdW90O0Rvd25sb2FkcyZxdW90OykuPC9wPgorCis8dWw+CisgICAgICAgPGxpPkNvbnRlbnQgbWF5IGJlIHN0cnVjdHVyZWQgYW5kIHBhY2thZ2VkIGludG8gbW9kdWxlcyB0byBmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsIGV4dGVuZGluZywgYW5kIHVwZ3JhZGluZyB0aGUgQ29udGVudC4gIFR5cGljYWwgbW9kdWxlcyBtYXkgaW5jbHVkZSBwbHVnLWlucyAoJnF1b3Q7UGx1Zy1pbnMmcXVvdDspLCBwbHVnLWluIGZyYWdtZW50cyAoJnF1b3Q7RnJhZ21lbnRzJnF1b3Q7KSwgYW5kIGZlYXR1cmVzICgmcXVvdDtGZWF0dXJlcyZxdW90OykuPC9saT4KKyAgICAgICA8bGk+RWFjaCBQbHVnLWluIG9yIEZyYWdtZW50IG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3Rvcnkgb3IgSkFSIChKYXZhJnRyYWRlOyBBUmNoaXZlKSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtwbHVnaW5zJnF1b3Q7LjwvbGk+CisgICAgICAgPGxpPkEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLiAgRWFjaCBGZWF0dXJlIG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3RvcnkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgJnF1b3Q7ZmVhdHVyZXMmcXVvdDsuICBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnhtbCZxdW90OyBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgdGhlIFBsdWctaW5zCisgICAgICBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuPC9saT4KKyAgICAgICA8bGk+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoJnF1b3Q7SW5jbHVkZWQgRmVhdHVyZXMmcXVvdDspLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnhtbCZxdW90OyBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgRmVhdHVyZXMuPC9saT4KKzwvdWw+CisKKzxwPlRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICZxdW90O2Fib3V0Lmh0bWwmcXVvdDsgKCZxdW90O0Fib3V0cyZxdW90OykuIFRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kCitJbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICZxdW90O2xpY2Vuc2UuaHRtbCZxdW90OyAoJnF1b3Q7RmVhdHVyZSBMaWNlbnNlcyZxdW90OykuICBBYm91dHMgYW5kIEZlYXR1cmUgTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55IGRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZQoraW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyBsb2NhdGlvbnM6PC9wPgorCis8dWw+CisgICAgICAgPGxpPlRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeTwvbGk+CisgICAgICAgPGxpPlBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzPC9saT4KKyAgICAgICA8bGk+SW5zaWRlIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgcGFja2FnZWQgYXMgSkFSczwvbGk+CisgICAgICAgPGxpPlN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICZxdW90O3NyYyZxdW90OyBvZiBjZXJ0YWluIFBsdWctaW5zPC9saT4KKyAgICAgICA8bGk+RmVhdHVyZSBkaXJlY3RvcmllczwvbGk+Cis8L3VsPgorCis8cD5Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IChhcyBkZWZpbmVkIGJlbG93KSwgeW91IG11c3QgYWdyZWUgdG8gYSBsaWNlbnNlICgmcXVvdDtGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlJnF1b3Q7KSBkdXJpbmcgdGhlCitpbnN0YWxsYXRpb24gcHJvY2Vzcy4gIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zIEluY2x1ZGVkIEZlYXR1cmVzLCB0aGUgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBzaG91bGQgZWl0aGVyIHByb3ZpZGUgeW91IHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IKK2luZm9ybSB5b3Ugd2hlcmUgeW91IGNhbiBsb2NhdGUgdGhlbS4gIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSBmb3VuZCBpbiB0aGUgJnF1b3Q7bGljZW5zZSZxdW90OyBwcm9wZXJ0eSBvZiBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnByb3BlcnRpZXMmcXVvdDsgZm91bmQgd2l0aGluIGEgRmVhdHVyZS4KK1N1Y2ggQWJvdXRzLCBGZWF0dXJlIExpY2Vuc2VzLCBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgKG9yIHJlZmVyZW5jZXMgdG8gc3VjaCB0ZXJtcyBhbmQgY29uZGl0aW9ucykgdGhhdCBnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbgordGhhdCBkaXJlY3RvcnkuPC9wPgorCis8cD5USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTLCBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSIFRPIFRIRSBFUEwgT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLiAgU09NRSBPRiBUSEVTRQorT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTo8L3A+CisKKzx1bD4KKyAgICAgICA8bGk+RWNsaXBzZSBEaXN0cmlidXRpb24gTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGljZW5zZXMvZWRsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xpY2Vuc2VzL2VkbC12MS4wLmh0bWw8L2E+KTwvbGk+CisgICAgICAgPGxpPkNvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbDwvYT4pPC9saT4KKyAgICAgICA8bGk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFPC9hPik8L2xpPgorICAgICAgIDxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMDwvYT4pPC9saT4KKyAgICAgICA8bGk+TWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwiPmh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sPC9hPik8L2xpPgorICAgICAgIDxsaT5Nb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sIj5odHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWw8L2E+KTwvbGk+Cis8L3VsPgorCis8cD5JVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCBDT05ESVRJT05TIFBSSU9SIFRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2UsIG9yIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2UgaXMgcHJvdmlkZWQsIHBsZWFzZQorY29udGFjdCB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHRvIGRldGVybWluZSB3aGF0IHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC48L3A+CisKKworPGgzPlVzZSBvZiBQcm92aXNpb25pbmcgVGVjaG5vbG9neTwvaDM+CisKKzxwPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIHByb3Zpc2lvbmluZyBzb2Z0d2FyZSwgZXhhbXBsZXMgb2Ygd2hpY2ggaW5jbHVkZSwgYnV0IGFyZSBub3QgbGltaXRlZCB0bywgcDIgYW5kIHRoZSBFY2xpcHNlCisgICBVcGRhdGUgTWFuYWdlciAoJnF1b3Q7UHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kmcXVvdDspIGZvciB0aGUgcHVycG9zZSBvZiBhbGxvd2luZyB1c2VycyB0byBpbnN0YWxsIHNvZnR3YXJlLCBkb2N1bWVudGF0aW9uLCBpbmZvcm1hdGlvbiBhbmQvb3IKKyAgIG90aGVyIG1hdGVyaWFscyAoY29sbGVjdGl2ZWx5ICZxdW90O0luc3RhbGxhYmxlIFNvZnR3YXJlJnF1b3Q7KS4gVGhpcyBjYXBhYmlsaXR5IGlzIHByb3ZpZGVkIHdpdGggdGhlIGludGVudCBvZiBhbGxvd2luZyBzdWNoIHVzZXJzIHRvCisgICBpbnN0YWxsLCBleHRlbmQgYW5kIHVwZGF0ZSBFY2xpcHNlLWJhc2VkIHByb2R1Y3RzLiBJbmZvcm1hdGlvbiBhYm91dCBwYWNrYWdpbmcgSW5zdGFsbGFibGUgU29mdHdhcmUgaXMgYXZhaWxhYmxlIGF0IDxhCisgICAgICAgaHJlZj0iaHR0cDovL2VjbGlwc2Uub3JnL2VxdWlub3gvcDIvcmVwb3NpdG9yeV9wYWNrYWdpbmcuaHRtbCI+aHR0cDovL2VjbGlwc2Uub3JnL2VxdWlub3gvcDIvcmVwb3NpdG9yeV9wYWNrYWdpbmcuaHRtbDwvYT4KKyAgICgmcXVvdDtTcGVjaWZpY2F0aW9uJnF1b3Q7KS48L3A+CisKKzxwPllvdSBtYXkgdXNlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IHRvIGFsbG93IG90aGVyIHBhcnRpZXMgdG8gaW5zdGFsbCBJbnN0YWxsYWJsZSBTb2Z0d2FyZS4gWW91IHNoYWxsIGJlIHJlc3BvbnNpYmxlIGZvciBlbmFibGluZyB0aGUKKyAgIGFwcGxpY2FibGUgbGljZW5zZSBhZ3JlZW1lbnRzIHJlbGF0aW5nIHRvIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSB0byBiZSBwcmVzZW50ZWQgdG8sIGFuZCBhY2NlcHRlZCBieSwgdGhlIHVzZXJzIG9mIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neQorICAgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBTcGVjaWZpY2F0aW9uLiBCeSB1c2luZyBQcm92aXNpb25pbmcgVGVjaG5vbG9neSBpbiBzdWNoIGEgbWFubmVyIGFuZCBtYWtpbmcgaXQgYXZhaWxhYmxlIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUKKyAgIFNwZWNpZmljYXRpb24sIHlvdSBmdXJ0aGVyIGFja25vd2xlZGdlIHlvdXIgYWdyZWVtZW50IHRvLCBhbmQgdGhlIGFjcXVpc2l0aW9uIG9mIGFsbCBuZWNlc3NhcnkgcmlnaHRzIHRvIHBlcm1pdCB0aGUgZm9sbG93aW5nOjwvcD4KKworPG9sPgorICAgICAgIDxsaT5BIHNlcmllcyBvZiBhY3Rpb25zIG1heSBvY2N1ciAoJnF1b3Q7UHJvdmlzaW9uaW5nIFByb2Nlc3MmcXVvdDspIGluIHdoaWNoIGEgdXNlciBtYXkgZXhlY3V0ZSB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kKKyAgICAgICBvbiBhIG1hY2hpbmUgKCZxdW90O1RhcmdldCBNYWNoaW5lJnF1b3Q7KSB3aXRoIHRoZSBpbnRlbnQgb2YgaW5zdGFsbGluZywgZXh0ZW5kaW5nIG9yIHVwZGF0aW5nIHRoZSBmdW5jdGlvbmFsaXR5IG9mIGFuIEVjbGlwc2UtYmFzZWQKKyAgICAgICBwcm9kdWN0LjwvbGk+CisgICAgICAgPGxpPkR1cmluZyB0aGUgUHJvdmlzaW9uaW5nIFByb2Nlc3MsIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSBtYXkgY2F1c2UgdGhpcmQgcGFydHkgSW5zdGFsbGFibGUgU29mdHdhcmUgb3IgYSBwb3J0aW9uIHRoZXJlb2YgdG8gYmUKKyAgICAgICBhY2Nlc3NlZCBhbmQgY29waWVkIHRvIHRoZSBUYXJnZXQgTWFjaGluZS48L2xpPgorICAgICAgIDxsaT5QdXJzdWFudCB0byB0aGUgU3BlY2lmaWNhdGlvbiwgeW91IHdpbGwgcHJvdmlkZSB0byB0aGUgdXNlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgdGhhdCBnb3Zlcm4gdGhlIHVzZSBvZiB0aGUgSW5zdGFsbGFibGUKKyAgICAgICBTb2Z0d2FyZSAoJnF1b3Q7SW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50JnF1b3Q7KSBhbmQgc3VjaCBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQgc2hhbGwgYmUgYWNjZXNzZWQgZnJvbSB0aGUgVGFyZ2V0CisgICAgICAgTWFjaGluZSBpbiBhY2NvcmRhbmNlIHdpdGggdGhlIFNwZWNpZmljYXRpb24uIFN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50IG11c3QgaW5mb3JtIHRoZSB1c2VyIG9mIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyB0aGF0IGdvdmVybgorICAgICAgIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBhbmQgbXVzdCBzb2xpY2l0IGFjY2VwdGFuY2UgYnkgdGhlIGVuZCB1c2VyIGluIHRoZSBtYW5uZXIgcHJlc2NyaWJlZCBpbiBzdWNoIEluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudC4gVXBvbiBzdWNoCisgICAgICAgaW5kaWNhdGlvbiBvZiBhZ3JlZW1lbnQgYnkgdGhlIHVzZXIsIHRoZSBwcm92aXNpb25pbmcgVGVjaG5vbG9neSB3aWxsIGNvbXBsZXRlIGluc3RhbGxhdGlvbiBvZiB0aGUgSW5zdGFsbGFibGUgU29mdHdhcmUuPC9saT4KKzwvb2w+CisKKzxoMz5DcnlwdG9ncmFwaHk8L2gzPgorCis8cD5Db250ZW50IG1heSBjb250YWluIGVuY3J5cHRpb24gc29mdHdhcmUuIFRoZSBjb3VudHJ5IGluIHdoaWNoIHlvdSBhcmUgY3VycmVudGx5IG1heSBoYXZlIHJlc3RyaWN0aW9ucyBvbiB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBhbmQgdXNlLCBhbmQvb3IgcmUtZXhwb3J0IHRvCisgICBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRSB1c2luZyBhbnkgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cywgcmVndWxhdGlvbnMgYW5kIHBvbGljaWVzIGNvbmNlcm5pbmcgdGhlIGltcG9ydCwKKyAgIHBvc3Nlc3Npb24sIG9yIHVzZSwgYW5kIHJlLWV4cG9ydCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLCB0byBzZWUgaWYgdGhpcyBpcyBwZXJtaXR0ZWQuPC9wPgorCis8cD48c21hbGw+SmF2YSBhbmQgYWxsIEphdmEtYmFzZWQgdHJhZGVtYXJrcyBhcmUgdHJhZGVtYXJrcyBvZiBPcmFjbGUgQ29ycG9yYXRpb24gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC48L3NtYWxsPjwvcD4KKzwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9wbHVnaW4ueG1sIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvcGx1Z2luLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42OTg5MTlkCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvcGx1Z2luLnhtbApAQCAtMCwwICsxLDg0IEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPHBsdWdpbj4KKyAgIDxleHRlbnNpb24KKyAgICAgICAgIGlkPSJPU0JQTmF0dXJlIgorICAgICAgICAgcG9pbnQ9Im9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLm5hdHVyZXMiPgorICAgCSA8cnVudGltZT4KKyAgICAgICAgIDxydW4KKyAgICAgICAgICAgICAgIGNsYXNzPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLm5hdHVyZS5PU0JQTmF0dXJlIj4KKyAgICAgICAgIDwvcnVuPgorICAgICAgPC9ydW50aW1lPgorICAgICAgICAgPGJ1aWxkZXIKKyAgICAgICAgICAgaWQ9Im9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkLk9TQlBNb2RlbEVuaGFuY2luZ0J1aWxkZXIiPgorICAgICAJPC9idWlsZGVyPgorICAgICAJPGJ1aWxkZXIKKyAgICAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC5PU0JQSTE4bkJ1aWxkZXIiPgorICAgICAJPC9idWlsZGVyPgorICAgPC9leHRlbnNpb24+CisgICA8ZXh0ZW5zaW9uCisgICAgICAgIGlkPSJPU0JQTW9kZWxFbmhhbmNpbmdCdWlsZGVyIgorICAgICAgICBuYW1lPSJPU0JQIE1vZGVsIEVuaGFuY2luZyBCdWlsZGVyIgorICAgICAgICBwb2ludD0ib3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuYnVpbGRlcnMiPgorICAgICAJPGJ1aWxkZXIKKyAgICAgICAgICAgaGFzTmF0dXJlPSJ0cnVlIj4KKyAgICAgICAgPHJ1bgorICAgICAgICAgICAgICBjbGFzcz0ib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQuaW50ZXJuYWwuRXhlY3V0YWJsZUV4dGVuc2lvbkZhY3RvcnkiPgorICAgICAgICAJPHBhcmFtZXRlciBuYW1lPSJndWljZWtleSIgdmFsdWU9Im9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuYnVpbGRlci5PU0JQTW9kZWxFbmhhbmNpbmdCdWlsZGVyIi8+CisgICAgICAgIDwvcnVuPgorICAgICA8L2J1aWxkZXI+CisgIDwvZXh0ZW5zaW9uPgorICA8ZXh0ZW5zaW9uCisgICAgICAgIGlkPSJPU0JQSTE4bkJ1aWxkZXIiCisgICAgICAgIG5hbWU9Ik9TQlAgSTE4biBCdWlsZGVyIgorICAgICAgICBwb2ludD0ib3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuYnVpbGRlcnMiPgorICAgICAJPGJ1aWxkZXIKKyAgICAgICAgICAgaGFzTmF0dXJlPSJ0cnVlIj4KKyAgICAgICAgPHJ1bgorICAgICAgICAgICAgICBjbGFzcz0ib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQuaW50ZXJuYWwuRXhlY3V0YWJsZUV4dGVuc2lvbkZhY3RvcnkiPgorICAgICAgICAJPHBhcmFtZXRlciBuYW1lPSJndWljZWtleSIgdmFsdWU9Im9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuYnVpbGRlci5PU0JQSTE4bkJ1aWxkZXIiLz4KKyAgICAgICAgPC9ydW4+CisgICAgIDwvYnVpbGRlcj4KKyAgPC9leHRlbnNpb24+CisgIDxleHRlbnNpb24KKyAgICAgICAgIGlkPSJYdGV4dEluZGV4VmlldyIKKyAgICAgICAgIHBvaW50PSJvcmcuZWNsaXBzZS51aS52aWV3cyI+CisgICAgICA8dmlldworICAgICAgICAgICAgY2F0ZWdvcnk9Im9yZy5lY2xpcHNlLm9zYnAuZWNsaXBzZS51aS52aWV3cy5jYXRlZ29yeS5SZXNvdXJjZXMiCisgICAgICAgICAgICBjbGFzcz0ib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQuaW50ZXJuYWwuRXhlY3V0YWJsZUV4dGVuc2lvbkZhY3Rvcnk6b3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS52aWV3Llh0ZXh0SW5kZXhWaWV3IgorICAgICAgICAgICAgaWNvbj0iaWNvbnMvb3NicF94dGV4dEluZGV4LnBuZyIKKyAgICAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnZpZXcueHRleHRpbmRleCIKKyAgICAgICAgICAgIG5hbWU9Ilh0ZXh0LUluZGV4IFZpZXciCisgICAgICAgICAgICByZXN0b3JhYmxlPSJ0cnVlIj4KKyAgICAgIDwvdmlldz4KKyAgIDwvZXh0ZW5zaW9uPgorICAgPGV4dGVuc2lvbgorICAgICAgICAgaWQ9IkkxOG5SZWdpc3RyeVZpZXciCisgICAgICAgICBwb2ludD0ib3JnLmVjbGlwc2UudWkudmlld3MiPgorICAgICAgPHZpZXcKKyAgICAgICAgICAgIGNhdGVnb3J5PSJvcmcuZWNsaXBzZS5vc2JwLmVjbGlwc2UudWkudmlld3MuY2F0ZWdvcnkuUmVzb3VyY2VzIgorICAgICAgICAgICAgY2xhc3M9Im9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkLmludGVybmFsLkV4ZWN1dGFibGVFeHRlbnNpb25GYWN0b3J5Om9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuaTE4bi5JMThuUmVnaXN0cnlWaWV3IgorICAgICAgICAgICAgaWNvbj0iaWNvbnMvb3NicC5wbmciCisgICAgICAgICAgICBpZD0ib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5pMThudmlldyIKKyAgICAgICAgICAgIG5hbWU9IkkxOG5SZWdpc3RyeSBWaWV3IgorICAgICAgICAgICAgcmVzdG9yYWJsZT0idHJ1ZSI+CisgICAgICA8L3ZpZXc+CisgICA8L2V4dGVuc2lvbj4KKyAgIDxleHRlbnNpb24KKyAgICAgICAgIGlkPSJFQ1ZpZXdCaW5kaW5nVmlldyIKKyAgICAgICAgIHBvaW50PSJvcmcuZWNsaXBzZS51aS52aWV3cyI+CisgICAgICA8dmlldworICAgICAgICAgICAgY2F0ZWdvcnk9Im9yZy5lY2xpcHNlLm9zYnAuZWNsaXBzZS51aS52aWV3cy5jYXRlZ29yeS5SZXNvdXJjZXMiCisgICAgICAgICAgICBjbGFzcz0ib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQuaW50ZXJuYWwuRXhlY3V0YWJsZUV4dGVuc2lvbkZhY3Rvcnk6b3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS52aWV3LkVDVmlld01vZGVsQmluZGluZ1ZpZXciCisgICAgICAgICAgICBpY29uPSJpY29ucy9vc2JwLnBuZyIKKyAgICAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLmVjdmlld2JpbmRpbmd2aWV3IgorICAgICAgICAgICAgbmFtZT0iRUNWaWV3IEJpbmRpbmcgVmlldyIKKyAgICAgICAgICAgIHJlc3RvcmFibGU9InRydWUiPgorICAgICAgPC92aWV3PgorICAgPC9leHRlbnNpb24+CisgICA8ZXh0ZW5zaW9uCisgICAgICAgICBwb2ludD0ib3JnLmVjbGlwc2UueHRleHQudWkuc2hhcmVkLnNoYXJlZFN0YXRlQ29udHJpYnV0aW5nTW9kdWxlIj4KKyAgICAgIDxtb2R1bGUKKyAgICAgICAgICAgIGNsYXNzPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC5pbnRlcm5hbC5TaGFyZWRTdGF0ZUNvbnRyaWJ1dGlvbiI+CisgICAgICA8L21vZHVsZT4KKyAgIDwvZXh0ZW5zaW9uPgorPC9wbHVnaW4+CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9wb20ueG1sIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvcG9tLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41MjhlOGRmCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvcG9tLnhtbApAQCAtMCwwICsxLDQwIEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPCEtLSM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4KKzwhLS0jIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIEx1bmlmZXJhIEdtYkggKEdyb3NzIEVuemVyc2RvcmYpLCBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KSAtLT4KKzwhLS0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgLS0+Cis8IS0tIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgLS0+Cis8IS0tIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAtLT4KKzwhLS0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIC0tPgorPCEtLSMgLS0+Cis8IS0tIyBDb250cmlidXRvcnM6IC0tPgorPCEtLSMgICAgIEtsZW1lbnMgRWRsZXIgKEx1bmlmZXJhIEdtYkgpIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIC0tPgorPCEtLSM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4KKworPHByb2plY3QgeG1sbnM9Imh0dHA6Ly9tYXZlbi5hcGFjaGUub3JnL1BPTS80LjAuMCIgeG1sbnM6eHNpPSJodHRwOi8vd3d3LnczLm9yZy8yMDAxL1hNTFNjaGVtYS1pbnN0YW5jZSIgeHNpOnNjaGVtYUxvY2F0aW9uPSJodHRwOi8vbWF2ZW4uYXBhY2hlLm9yZy9QT00vNC4wLjAgaHR0cDovL21hdmVuLmFwYWNoZS5vcmcveHNkL21hdmVuLTQuMC4wLnhzZCI+CisgICAgPG1vZGVsVmVyc2lvbj40LjAuMDwvbW9kZWxWZXJzaW9uPgorICAgIDxwYXJlbnQ+CisgICAgICAgIDxncm91cElkPm9yZy5lY2xpcHNlLm9zYnAuaWRlPC9ncm91cElkPgorICAgICAgICA8YXJ0aWZhY3RJZD5vcmcuZWNsaXBzZS5vc2JwLmlkZTwvYXJ0aWZhY3RJZD4KKyAgICAgICAgPHZlcnNpb24+MC45LjAtU05BUFNIT1Q8L3ZlcnNpb24+CisgICAgPC9wYXJlbnQ+CisgICAgPGFydGlmYWN0SWQ+b3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQ8L2FydGlmYWN0SWQ+CisgICAgPHBhY2thZ2luZz5lY2xpcHNlLXBsdWdpbjwvcGFja2FnaW5nPgorCisgICAgPGJ1aWxkPgorICAgICAgICA8cGx1Z2lucz4KKyAgICAgICAgICAgIDxwbHVnaW4+CisgICAgICAgICAgICAgICAgPGdyb3VwSWQ+b3JnLmFwYWNoZS5tYXZlbi5wbHVnaW5zPC9ncm91cElkPgorICAgICAgICAgICAgICAgIDxhcnRpZmFjdElkPm1hdmVuLWZhaWxzYWZlLXBsdWdpbjwvYXJ0aWZhY3RJZD4KKyAgICAgICAgICAgICAgICA8ZXhlY3V0aW9ucz4KKyAgICAgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbj4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxnb2Fscz4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbD5pbnRlZ3JhdGlvbi10ZXN0PC9nb2FsPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxnb2FsPnZlcmlmeTwvZ29hbD4KKyAgICAgICAgICAgICAgICAgICAgICAgIDwvZ29hbHM+CisgICAgICAgICAgICAgICAgICAgIDwvZXhlY3V0aW9uPgorICAgICAgICAgICAgICAgIDwvZXhlY3V0aW9ucz4KKyAgICAgICAgICAgIDwvcGx1Z2luPgorICAgICAgICA8L3BsdWdpbnM+CisgICAgPC9idWlsZD4KKworPC9wcm9qZWN0PgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvc2hhcmVkL0FjY2Vzcy5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvc2hhcmVkL0FjY2Vzcy5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU2MzM1OTcKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9zaGFyZWQvQWNjZXNzLmphdmEKQEAgLTAsMCArMSwyMiBAQAorLyoqCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTUgLSBMdW5pZmVyYSBHbWJIIChHcm9zcyBFbnplcnNkb3JmLCBBdXN0cmlhKSwgTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisgKgorICogQ29udHJpYnV0b3JzOgorICogICAgICAgICBGbG9yaWFuIFBpcmNobmVyIC0gSW5pdGlhbCBpbXBsZW1lbnRhdGlvbgorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkOworCitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkuaTE4bi5JSTE4blJlZ2lzdHJ5OworCitpbXBvcnQgY29tLmdvb2dsZS5pbmplY3QuUHJvdmlkZXI7CisKK3B1YmxpYyBjbGFzcyBBY2Nlc3MgZXh0ZW5kcyBvcmcuZWNsaXBzZS54dGV4dC51aS5zaGFyZWQuQWNjZXNzIHsKKworCXB1YmxpYyBzdGF0aWMgUHJvdmlkZXI8SUkxOG5SZWdpc3RyeT4gZ2V0SUkxOG5SZWdpc3RyeSgpIHsKKwkJcmV0dXJuIEFjY2Vzcy48SUkxOG5SZWdpc3RyeT4gY29udHJpYnV0ZWRQcm92aWRlcihJSTE4blJlZ2lzdHJ5LmNsYXNzKTsKKwl9Cit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9zaGFyZWQvT1NCUFNoYXJlZFN0YXRlTW9kdWxlLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9zaGFyZWQvT1NCUFNoYXJlZFN0YXRlTW9kdWxlLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjQ3ZTkxOQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS9jb3JlL3VpL3NoYXJlZC9PU0JQU2hhcmVkU3RhdGVNb2R1bGUuamF2YQpAQCAtMCwwICsxLDQyIEBACisvKioKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNSAtIEx1bmlmZXJhIEdtYkggKEdyb3NzIEVuemVyc2RvcmYsIEF1c3RyaWEpLCBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscworICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKKyAqCisgKiBDb250cmlidXRvcnM6CisgKiAgICAgICAgIEZsb3JpYW4gUGlyY2huZXIgLSBJbml0aWFsIGltcGxlbWVudGF0aW9uCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQ7CisKK2ltcG9ydCBvcmcuZWNsaXBzZS54dGV4dC5idWlsZGVyLmJ1aWxkZXJTdGF0ZS5JQnVpbGRlclN0YXRlOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnJlc291cmNlLlN5bmNocm9uaXplZFh0ZXh0UmVzb3VyY2VTZXQ7CitpbXBvcnQgb3JnLmVjbGlwc2UueHRleHQucmVzb3VyY2UuWHRleHRSZXNvdXJjZVNldDsKK2ltcG9ydCBvcmcuZWNsaXBzZS54dGV4dC5zZXJ2aWNlLkFic3RyYWN0R2VuZXJpY01vZHVsZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS5pMThuLklJMThuUmVnaXN0cnk7CisKK2ltcG9ydCBjb20uZ29vZ2xlLmluamVjdC5CaW5kZXI7CitpbXBvcnQgY29tLmdvb2dsZS5pbmplY3QuUHJvdmlkZXI7CisKKy8qKgorICogU2hhcmVkIHN0YXRlIG1vZHVsZSBkZWZpbmVzIHRoZSBiaW5kaW5ncyBmb3IgdGhlIGluamVjdG9yIG9mIHRoaXMgYnVuZGxlLgorICovCitwdWJsaWMgY2xhc3MgT1NCUFNoYXJlZFN0YXRlTW9kdWxlIGV4dGVuZHMgQWJzdHJhY3RHZW5lcmljTW9kdWxlIHsKKworCXB1YmxpYyBQcm92aWRlcjxJSTE4blJlZ2lzdHJ5PiBwcm92aWRlSUkxOG5SZWdpc3RyeSgpIHsKKwkJcmV0dXJuIEFjY2Vzcy5nZXRJSTE4blJlZ2lzdHJ5KCk7CisJfQorCisJQFN1cHByZXNzV2FybmluZ3MoInJlc3RyaWN0aW9uIikKKwlwdWJsaWMgUHJvdmlkZXI8SUJ1aWxkZXJTdGF0ZT4gcHJvdmlkZUlCdWlsZGVyU3RhdGUoKSB7CisJCXJldHVybiBBY2Nlc3MuZ2V0SUJ1aWxkZXJTdGF0ZSgpOworCX0KKworCXB1YmxpYyB2b2lkIGNvbmZpZ3VyZShCaW5kZXIgYmluZGVyKSB7CisJCXN1cGVyLmNvbmZpZ3VyZShiaW5kZXIpOworCisJCWJpbmRlci5iaW5kKFh0ZXh0UmVzb3VyY2VTZXQuY2xhc3MpLnRvKAorCQkJCVN5bmNocm9uaXplZFh0ZXh0UmVzb3VyY2VTZXQuY2xhc3MpOworCX0KK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS9jb3JlL3VpL3NoYXJlZC9pbnRlcm5hbC9BY3RpdmF0b3IuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS9jb3JlL3VpL3NoYXJlZC9pbnRlcm5hbC9BY3RpdmF0b3IuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44MjY4ZDBmCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvc2hhcmVkL2ludGVybmFsL0FjdGl2YXRvci5qYXZhCkBAIC0wLDAgKzEsNjUgQEAKKy8qKgorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE1IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiwgQXVzdHJpYSksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorICoKKyAqIENvbnRyaWJ1dG9yczoKKyAqICAgICAgICAgRmxvcmlhbiBQaXJjaG5lciAtIEluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC5pbnRlcm5hbDsKKworaW1wb3J0IG9yZy5lY2xpcHNlLnVpLnBsdWdpbi5BYnN0cmFjdFVJUGx1Z2luOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnVpLnNoYXJlZC5TaGFyZWRTdGF0ZU1vZHVsZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC5PU0JQU2hhcmVkU3RhdGVNb2R1bGU7CitpbXBvcnQgb3JnLm9zZ2kuZnJhbWV3b3JrLkJ1bmRsZUNvbnRleHQ7CitpbXBvcnQgb3JnLnNsZjRqLkxvZ2dlcjsKK2ltcG9ydCBvcmcuc2xmNGouTG9nZ2VyRmFjdG9yeTsKKworaW1wb3J0IGNvbS5nb29nbGUuaW5qZWN0Lkd1aWNlOworaW1wb3J0IGNvbS5nb29nbGUuaW5qZWN0LkluamVjdG9yOworaW1wb3J0IGNvbS5nb29nbGUuaW5qZWN0LnV0aWwuTW9kdWxlczsKKworcHVibGljIGNsYXNzIEFjdGl2YXRvciBleHRlbmRzIEFic3RyYWN0VUlQbHVnaW4geworCisJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgUExVR0lOX0lEID0gIm9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkIjsgLy8kTk9OLU5MUy0xJAorCXByaXZhdGUgc3RhdGljIGZpbmFsIExvZ2dlciBMT0dHRVIgPSBMb2dnZXJGYWN0b3J5CisJCQkuZ2V0TG9nZ2VyKEFjdGl2YXRvci5jbGFzcyk7CisJcHJpdmF0ZSBzdGF0aWMgQWN0aXZhdG9yIHBsdWdpbjsKKworCXB1YmxpYyBzdGF0aWMgQWN0aXZhdG9yIGdldERlZmF1bHQoKSB7CisJCXJldHVybiBwbHVnaW47CisJfQorCisJcHJpdmF0ZSBJbmplY3RvciBpbmplY3RvcjsKKworCXB1YmxpYyBJbmplY3RvciBnZXRJbmplY3RvcigpIHsKKwkJaWYgKGluamVjdG9yID09IG51bGwpIHsKKwkJCWluamVjdG9yID0gR3VpY2UuY3JlYXRlSW5qZWN0b3IoTW9kdWxlcy5vdmVycmlkZSgKKwkJCQkJbmV3IFNoYXJlZFN0YXRlTW9kdWxlKCkpLndpdGgoCisJCQkJCW5ldyBPU0JQU2hhcmVkU3RhdGVNb2R1bGUoKSkpOworCQl9CisJCXJldHVybiBpbmplY3RvcjsKKwl9CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgdm9pZCBzdGFydChCdW5kbGVDb250ZXh0IGNvbnRleHQpIHRocm93cyBFeGNlcHRpb24geworCQl0cnkgeworCQkJc3VwZXIuc3RhcnQoY29udGV4dCk7CisJCQlwbHVnaW4gPSB0aGlzOworCisJCX0gY2F0Y2ggKEV4Y2VwdGlvbiBlKSB7CisJCQlMT0dHRVIuZXJyb3IoCisJCQkJCSJFcnJvciBpbml0aWFsaXppbmcgIiArIFBMVUdJTl9JRCArICI6IiArIGUuZ2V0TWVzc2FnZSgpLCBlKTsKKwkJfQorCX0KKworCUBPdmVycmlkZQorCXB1YmxpYyB2b2lkIHN0b3AoQnVuZGxlQ29udGV4dCBjb250ZXh0KSB0aHJvd3MgRXhjZXB0aW9uIHsKKwkJcGx1Z2luID0gbnVsbDsKKwkJaW5qZWN0b3IgPSBudWxsOworCQlzdXBlci5zdG9wKGNvbnRleHQpOworCX0KKworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvc2hhcmVkL2ludGVybmFsL0V4ZWN1dGFibGVFeHRlbnNpb25GYWN0b3J5LmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9zaGFyZWQvaW50ZXJuYWwvRXhlY3V0YWJsZUV4dGVuc2lvbkZhY3RvcnkuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hZmM2Yzc3Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvc2hhcmVkL2ludGVybmFsL0V4ZWN1dGFibGVFeHRlbnNpb25GYWN0b3J5LmphdmEKQEAgLTAsMCArMSwzNiBAQAorLyoqCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTUgLSBMdW5pZmVyYSBHbWJIIChHcm9zcyBFbnplcnNkb3JmLCBBdXN0cmlhKSwgTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisgKgorICogQ29udHJpYnV0b3JzOgorICogICAgICAgICBGbG9yaWFuIFBpcmNobmVyIC0gSW5pdGlhbCBpbXBsZW1lbnRhdGlvbgorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkLmludGVybmFsOworCitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkNvcmVFeGNlcHRpb247CitpbXBvcnQgb3JnLmVjbGlwc2UueHRleHQudWkuZ3VpY2UuQWJzdHJhY3RHdWljZUF3YXJlRXhlY3V0YWJsZUV4dGVuc2lvbkZhY3Rvcnk7CitpbXBvcnQgb3JnLm9zZ2kuZnJhbWV3b3JrLkJ1bmRsZTsKKworaW1wb3J0IGNvbS5nb29nbGUuaW5qZWN0LkluamVjdG9yOworCitwdWJsaWMgY2xhc3MgRXhlY3V0YWJsZUV4dGVuc2lvbkZhY3RvcnkgZXh0ZW5kcworCQlBYnN0cmFjdEd1aWNlQXdhcmVFeGVjdXRhYmxlRXh0ZW5zaW9uRmFjdG9yeSB7CisKKwlAT3ZlcnJpZGUKKwlwcm90ZWN0ZWQgQnVuZGxlIGdldEJ1bmRsZSgpIHsKKwkJcmV0dXJuIEFjdGl2YXRvci5nZXREZWZhdWx0KCkuZ2V0QnVuZGxlKCk7CisJfQorCisJQE92ZXJyaWRlCisJcHJvdGVjdGVkIEluamVjdG9yIGdldEluamVjdG9yKCkgeworCQlyZXR1cm4gQWN0aXZhdG9yLmdldERlZmF1bHQoKS5nZXRJbmplY3RvcigpOworCX0KKwkKKwlwdWJsaWMgT2JqZWN0IGNyZWF0ZSgpIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKKwkJcmV0dXJuIHN1cGVyLmNyZWF0ZSgpOworCX0KKworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvc2hhcmVkL2ludGVybmFsL1NoYXJlZFN0YXRlQ29udHJpYnV0aW9uLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9zaGFyZWQvaW50ZXJuYWwvU2hhcmVkU3RhdGVDb250cmlidXRpb24uamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mOTgxYjRhCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvc2hhcmVkL2ludGVybmFsL1NoYXJlZFN0YXRlQ29udHJpYnV0aW9uLmphdmEKQEAgLTAsMCArMSwzOSBAQAorLyoqCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTUgLSBMdW5pZmVyYSBHbWJIIChHcm9zcyBFbnplcnNkb3JmLCBBdXN0cmlhKSwgTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisgKgorICogQ29udHJpYnV0b3JzOgorICogICAgICAgICBGbG9yaWFuIFBpcmNobmVyIC0gSW5pdGlhbCBpbXBsZW1lbnRhdGlvbgorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkLmludGVybmFsOworCitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkuaTE4bi5JSTE4blJlZ2lzdHJ5OworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuaTE4bi5JMThuUmVnaXN0cnk7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQuQWNjZXNzOworCitpbXBvcnQgY29tLmdvb2dsZS5pbmplY3QuQmluZGVyOworaW1wb3J0IGNvbS5nb29nbGUuaW5qZWN0Lk1vZHVsZTsKKworLyoqCisgKiBDb250cmlidXRlcyBiaW5kaW5ncyB0byB0aGUgWHRleHQgZnJhbWV3b3JrLiBUaGlzIG1vZHVsZSBpcyByZWdpc3RlcmVkIGJ5CisgKiBwbHVnaW4ueG1sLiBYdGV4dCB3aWxsIHVzZSB0aGUgYmluZGluZ3MgdG8gY3JlYXRlIGEgY2hpbGQgaW5qZWN0b3IuIDxicj4KKyAqIDxicj4KKyAqIE1vZHVsZXMgdGhhdCB3YW50IHRvIHVzZSB0aGUgc2luZ2xldG9uIHtAbGluayBJSTE4blJlZ2lzdHJ5fSBuZWVkcyB0byBhZGQKKyAqIHtAbGluayBBY2Nlc3MjZ2V0SUkxOG5SZWdpc3RyeSgpfSBpbiB0aGVpciBtb2R1bGUgZGVzY3JpcHRpb24uIEl0IHdpbGwgY3JlYXRlCisgKiBhIHByb3ZpZGVyLCB0aGF0IGRlbGVnYXRlcyB0byB0aGUgZXh0ZW5zaW9uIGNhY2hlLiBUaGVuIHRoZQorICoge0BsaW5rIElJMThuUmVnaXN0cnl9IHdpbGwgYXV0b21hdGljYWxseSBiZWNvbWUgaW5qZWN0ZWQuPGJyPgorICogPGJyPgorICogSWYgSUkxOG5SZWdpc3RyeSBpcyByZXF1ZXN0ZWQsIHRoZSBpbmplY3RvciB3aWxsIHRha2UgYSBsb29rIGludG8gdGhlCisgKiBleHRlbnNpb24gcmVnaXN0cnkuIFNlZQorICoge0BsaW5rIG9yZy5lY2xpcHNlLnh0ZXh0LnVpLnNoYXJlZC5BY2Nlc3MjY29udHJpYnV0ZWRQcm92aWRlcihDbGFzcyl9LiBTbworICogb25seSBvbmUgaW5zdGFuY2UgaXMgYXZhaWxhYmxlIGF0IGEgdGltZS4KKyAqLworcHVibGljIGNsYXNzIFNoYXJlZFN0YXRlQ29udHJpYnV0aW9uIGltcGxlbWVudHMgTW9kdWxlIHsKKworCXB1YmxpYyB2b2lkIGNvbmZpZ3VyZShCaW5kZXIgYmluZGVyKSB7CisJCWJpbmRlci5iaW5kKElJMThuUmVnaXN0cnkuY2xhc3MpLnRvKEkxOG5SZWdpc3RyeS5jbGFzcyk7CisJfQorfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS8ucHJvamVjdCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvLnByb2plY3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODE2NWI3YQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvLnByb2plY3QKQEAgLTAsMCArMSw1MSBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KKzxwcm9qZWN0RGVzY3JpcHRpb24+CisJPG5hbWU+b3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aTwvbmFtZT4KKwk8Y29tbWVudD48L2NvbW1lbnQ+CisJPHByb2plY3RzPgorCTwvcHJvamVjdHM+CisJPGJ1aWxkU3BlYz4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLnh0ZXh0LnVpLnNoYXJlZC54dGV4dEJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UuamR0LmNvcmUuamF2YWJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLk1hbmlmZXN0QnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuU2NoZW1hQnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5iYWJlbC5lZGl0b3IucmJlQnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuc29uYXJsaW50LmVjbGlwc2UuY29yZS5zb25hcmxpbnRCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLm0yZS5jb3JlLm1hdmVuMkJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCTwvYnVpbGRTcGVjPgorCTxuYXR1cmVzPgorCQk8bmF0dXJlPm9yZy5lY2xpcHNlLnh0ZXh0LnVpLnNoYXJlZC54dGV4dE5hdHVyZTwvbmF0dXJlPgorCQk8bmF0dXJlPm9yZy5lY2xpcHNlLm0yZS5jb3JlLm1hdmVuMk5hdHVyZTwvbmF0dXJlPgorCQk8bmF0dXJlPm9yZy5lY2xpcHNlLnBkZS5QbHVnaW5OYXR1cmU8L25hdHVyZT4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS5qZHQuY29yZS5qYXZhbmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UuYmFiZWwuZWRpdG9yLnJiZU5hdHVyZTwvbmF0dXJlPgorCTwvbmF0dXJlcz4KKzwvcHJvamVjdERlc2NyaXB0aW9uPgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9MSUNFTlNFLnR4dCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvTElDRU5TRS50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZmY0MmFkNAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvTElDRU5TRS50eHQKQEAgLTAsMCArMSwxNjEgQEAKK0VjbGlwc2UgUHVibGljIExpY2Vuc2UgLXYgMS4wCisKK1RIRSBBQ0NPTVBBTllJTkcgUFJPR1JBTSBJUyBQUk9WSURFRCBVTkRFUiBUSEUgVEVSTVMgT0YgVEhJUyBFQ0xJUFNFIFBVQkxJQyBMSUNFTlNFICgiQUdSRUVNRU5UIikuIEFOWSBVU0UsIFJFUFJPRFVDVElPTgorT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIENPTlNUSVRVVEVTIFJFQ0lQSUVOVCdTIEFDQ0VQVEFOQ0UgT0YgVEhJUyBBR1JFRU1FTlQuCisKKzEuIERFRklOSVRJT05TCisKKyJDb250cmlidXRpb24iIG1lYW5zOgorCithKSBpbiB0aGUgY2FzZSBvZiB0aGUgaW5pdGlhbCBDb250cmlidXRvciwgdGhlIGluaXRpYWwgY29kZSBhbmQgZG9jdW1lbnRhdGlvbiBkaXN0cmlidXRlZCB1bmRlciB0aGlzIEFncmVlbWVudCwgYW5kCisKK2IpIGluIHRoZSBjYXNlIG9mIGVhY2ggc3Vic2VxdWVudCBDb250cmlidXRvcjoKKworaSkgY2hhbmdlcyB0byB0aGUgUHJvZ3JhbSwgYW5kCisKK2lpKSBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW07CisKK3doZXJlIHN1Y2ggY2hhbmdlcyBhbmQvb3IgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIG9yaWdpbmF0ZSBmcm9tIGFuZCBhcmUgZGlzdHJpYnV0ZWQgYnkgdGhhdCBwYXJ0aWN1bGFyIENvbnRyaWJ1dG9yLgorQSBDb250cmlidXRpb24gJ29yaWdpbmF0ZXMnIGZyb20gYSBDb250cmlidXRvciBpZiBpdCB3YXMgYWRkZWQgdG8gdGhlIFByb2dyYW0gYnkgc3VjaCBDb250cmlidXRvciBpdHNlbGYgb3IgYW55b25lCithY3Rpbmcgb24gc3VjaCBDb250cmlidXRvcidzIGJlaGFsZi4gQ29udHJpYnV0aW9ucyBkbyBub3QgaW5jbHVkZSBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gd2hpY2g6IChpKSBhcmUgc2VwYXJhdGUKK21vZHVsZXMgb2Ygc29mdHdhcmUgZGlzdHJpYnV0ZWQgaW4gY29uanVuY3Rpb24gd2l0aCB0aGUgUHJvZ3JhbSB1bmRlciB0aGVpciBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIGFuZCAoaWkpIGFyZSBub3QKK2Rlcml2YXRpdmUgd29ya3Mgb2YgdGhlIFByb2dyYW0uCisKKyJDb250cmlidXRvciIgbWVhbnMgYW55IHBlcnNvbiBvciBlbnRpdHkgdGhhdCBkaXN0cmlidXRlcyB0aGUgUHJvZ3JhbS4KKworIkxpY2Vuc2VkIFBhdGVudHMgIiBtZWFuIHBhdGVudCBjbGFpbXMgbGljZW5zYWJsZSBieSBhIENvbnRyaWJ1dG9yIHdoaWNoIGFyZSBuZWNlc3NhcmlseSBpbmZyaW5nZWQgYnkgdGhlIHVzZSBvciBzYWxlIG9mCitpdHMgQ29udHJpYnV0aW9uIGFsb25lIG9yIHdoZW4gY29tYmluZWQgd2l0aCB0aGUgUHJvZ3JhbS4KKworIlByb2dyYW0iIG1lYW5zIHRoZSBDb250cmlidXRpb25zIGRpc3RyaWJ1dGVkIGluIGFjY29yZGFuY2Ugd2l0aCB0aGlzIEFncmVlbWVudC4KKworIlJlY2lwaWVudCIgbWVhbnMgYW55b25lIHdobyByZWNlaXZlcyB0aGUgUHJvZ3JhbSB1bmRlciB0aGlzIEFncmVlbWVudCwgaW5jbHVkaW5nIGFsbCBDb250cmlidXRvcnMuCisKKzIuIEdSQU5UIE9GIFJJR0hUUworCithKSBTdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwKK3JveWFsdHktZnJlZSBjb3B5cmlnaHQgbGljZW5zZSB0byByZXByb2R1Y2UsIHByZXBhcmUgZGVyaXZhdGl2ZSB3b3JrcyBvZiwgcHVibGljbHkgZGlzcGxheSwgcHVibGljbHkgcGVyZm9ybSwgZGlzdHJpYnV0ZQorYW5kIHN1YmxpY2Vuc2UgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoIENvbnRyaWJ1dG9yLCBpZiBhbnksIGFuZCBzdWNoIGRlcml2YXRpdmUgd29ya3MsIGluIHNvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZQorZm9ybS4KKworYikgU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsCityb3lhbHR5LWZyZWUgcGF0ZW50IGxpY2Vuc2UgdW5kZXIgTGljZW5zZWQgUGF0ZW50cyB0byBtYWtlLCB1c2UsIHNlbGwsIG9mZmVyIHRvIHNlbGwsIGltcG9ydCBhbmQgb3RoZXJ3aXNlIHRyYW5zZmVyIHRoZQorQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlIGZvcm0uIFRoaXMgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgYXBwbHkgdG8gdGhlCitjb21iaW5hdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGFuZCB0aGUgUHJvZ3JhbSBpZiwgYXQgdGhlIHRpbWUgdGhlIENvbnRyaWJ1dGlvbiBpcyBhZGRlZCBieSB0aGUgQ29udHJpYnV0b3IsIHN1Y2gKK2FkZGl0aW9uIG9mIHRoZSBDb250cmlidXRpb24gY2F1c2VzIHN1Y2ggY29tYmluYXRpb24gdG8gYmUgY292ZXJlZCBieSB0aGUgTGljZW5zZWQgUGF0ZW50cy4gVGhlIHBhdGVudCBsaWNlbnNlIHNoYWxsIG5vdAorYXBwbHkgdG8gYW55IG90aGVyIGNvbWJpbmF0aW9ucyB3aGljaCBpbmNsdWRlIHRoZSBDb250cmlidXRpb24uIE5vIGhhcmR3YXJlIHBlciBzZSBpcyBsaWNlbnNlZCBoZXJldW5kZXIuCisKK2MpIFJlY2lwaWVudCB1bmRlcnN0YW5kcyB0aGF0IGFsdGhvdWdoIGVhY2ggQ29udHJpYnV0b3IgZ3JhbnRzIHRoZSBsaWNlbnNlcyB0byBpdHMgQ29udHJpYnV0aW9ucyBzZXQgZm9ydGggaGVyZWluLCBubworYXNzdXJhbmNlcyBhcmUgcHJvdmlkZWQgYnkgYW55IENvbnRyaWJ1dG9yIHRoYXQgdGhlIFByb2dyYW0gZG9lcyBub3QgaW5mcmluZ2UgdGhlIHBhdGVudCBvciBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkKK3JpZ2h0cyBvZiBhbnkgb3RoZXIgZW50aXR5LiBFYWNoIENvbnRyaWJ1dG9yIGRpc2NsYWltcyBhbnkgbGlhYmlsaXR5IHRvIFJlY2lwaWVudCBmb3IgY2xhaW1zIGJyb3VnaHQgYnkgYW55IG90aGVyIGVudGl0eQorYmFzZWQgb24gaW5mcmluZ2VtZW50IG9mIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgb3Igb3RoZXJ3aXNlLiBBcyBhIGNvbmRpdGlvbiB0byBleGVyY2lzaW5nIHRoZSByaWdodHMgYW5kCitsaWNlbnNlcyBncmFudGVkIGhlcmV1bmRlciwgZWFjaCBSZWNpcGllbnQgaGVyZWJ5IGFzc3VtZXMgc29sZSByZXNwb25zaWJpbGl0eSB0byBzZWN1cmUgYW55IG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQorcmlnaHRzIG5lZWRlZCwgaWYgYW55LiBGb3IgZXhhbXBsZSwgaWYgYSB0aGlyZCBwYXJ0eSBwYXRlbnQgbGljZW5zZSBpcyByZXF1aXJlZCB0byBhbGxvdyBSZWNpcGllbnQgdG8gZGlzdHJpYnV0ZSB0aGUKK1Byb2dyYW0sIGl0IGlzIFJlY2lwaWVudCdzIHJlc3BvbnNpYmlsaXR5IHRvIGFjcXVpcmUgdGhhdCBsaWNlbnNlIGJlZm9yZSBkaXN0cmlidXRpbmcgdGhlIFByb2dyYW0uCisKK2QpIEVhY2ggQ29udHJpYnV0b3IgcmVwcmVzZW50cyB0aGF0IHRvIGl0cyBrbm93bGVkZ2UgaXQgaGFzIHN1ZmZpY2llbnQgY29weXJpZ2h0IHJpZ2h0cyBpbiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIHRvCitncmFudCB0aGUgY29weXJpZ2h0IGxpY2Vuc2Ugc2V0IGZvcnRoIGluIHRoaXMgQWdyZWVtZW50LgorCiszLiBSRVFVSVJFTUVOVFMKKworQSBDb250cmlidXRvciBtYXkgY2hvb3NlIHRvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0gaW4gb2JqZWN0IGNvZGUgZm9ybSB1bmRlciBpdHMgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBwcm92aWRlZCB0aGF0OgorCithKSBpdCBjb21wbGllcyB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudDsgYW5kCisKK2IpIGl0cyBsaWNlbnNlIGFncmVlbWVudDoKKworaSkgZWZmZWN0aXZlbHkgZGlzY2xhaW1zIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCB3YXJyYW50aWVzIGFuZCBjb25kaXRpb25zLCBleHByZXNzIGFuZCBpbXBsaWVkLCBpbmNsdWRpbmcKK3dhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiB0aXRsZSBhbmQgbm9uLWluZnJpbmdlbWVudCwgYW5kIGltcGxpZWQgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIG1lcmNoYW50YWJpbGl0eSBhbmQKK2ZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlOworCitpaSkgZWZmZWN0aXZlbHkgZXhjbHVkZXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIGxpYWJpbGl0eSBmb3IgZGFtYWdlcywgaW5jbHVkaW5nIGRpcmVjdCwgaW5kaXJlY3QsIHNwZWNpYWwsCitpbmNpZGVudGFsIGFuZCBjb25zZXF1ZW50aWFsIGRhbWFnZXMsIHN1Y2ggYXMgbG9zdCBwcm9maXRzOworCitpaWkpIHN0YXRlcyB0aGF0IGFueSBwcm92aXNpb25zIHdoaWNoIGRpZmZlciBmcm9tIHRoaXMgQWdyZWVtZW50IGFyZSBvZmZlcmVkIGJ5IHRoYXQgQ29udHJpYnV0b3IgYWxvbmUgYW5kIG5vdCBieSBhbnkKK290aGVyIHBhcnR5OyBhbmQKKworaXYpIHN0YXRlcyB0aGF0IHNvdXJjZSBjb2RlIGZvciB0aGUgUHJvZ3JhbSBpcyBhdmFpbGFibGUgZnJvbSBzdWNoIENvbnRyaWJ1dG9yLCBhbmQgaW5mb3JtcyBsaWNlbnNlZXMgaG93IHRvIG9idGFpbiBpdAoraW4gYSByZWFzb25hYmxlIG1hbm5lciBvbiBvciB0aHJvdWdoIGEgbWVkaXVtIGN1c3RvbWFyaWx5IHVzZWQgZm9yIHNvZnR3YXJlIGV4Y2hhbmdlLgorCitXaGVuIHRoZSBQcm9ncmFtIGlzIG1hZGUgYXZhaWxhYmxlIGluIHNvdXJjZSBjb2RlIGZvcm06CisKK2EpIGl0IG11c3QgYmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhpcyBBZ3JlZW1lbnQ7IGFuZAorCitiKSBhIGNvcHkgb2YgdGhpcyBBZ3JlZW1lbnQgbXVzdCBiZSBpbmNsdWRlZCB3aXRoIGVhY2ggY29weSBvZiB0aGUgUHJvZ3JhbS4KKworQ29udHJpYnV0b3JzIG1heSBub3QgcmVtb3ZlIG9yIGFsdGVyIGFueSBjb3B5cmlnaHQgbm90aWNlcyBjb250YWluZWQgd2l0aGluIHRoZSBQcm9ncmFtLgorCitFYWNoIENvbnRyaWJ1dG9yIG11c3QgaWRlbnRpZnkgaXRzZWxmIGFzIHRoZSBvcmlnaW5hdG9yIG9mIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgaW4gYSBtYW5uZXIgdGhhdCByZWFzb25hYmx5IGFsbG93cworc3Vic2VxdWVudCBSZWNpcGllbnRzIHRvIGlkZW50aWZ5IHRoZSBvcmlnaW5hdG9yIG9mIHRoZSBDb250cmlidXRpb24uCisKKzQuIENPTU1FUkNJQUwgRElTVFJJQlVUSU9OCisKK0NvbW1lcmNpYWwgZGlzdHJpYnV0b3JzIG9mIHNvZnR3YXJlIG1heSBhY2NlcHQgY2VydGFpbiByZXNwb25zaWJpbGl0aWVzIHdpdGggcmVzcGVjdCB0byBlbmQgdXNlcnMsIGJ1c2luZXNzIHBhcnRuZXJzIGFuZAordGhlIGxpa2UuIFdoaWxlIHRoaXMgbGljZW5zZSBpcyBpbnRlbmRlZCB0byBmYWNpbGl0YXRlIHRoZSBjb21tZXJjaWFsIHVzZSBvZiB0aGUgUHJvZ3JhbSwgdGhlIENvbnRyaWJ1dG9yIHdobyBpbmNsdWRlcwordGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcgc2hvdWxkIGRvIHNvIGluIGEgbWFubmVyIHdoaWNoIGRvZXMgbm90IGNyZWF0ZSBwb3RlbnRpYWwgbGlhYmlsaXR5IGZvcgorb3RoZXIgQ29udHJpYnV0b3JzLiBUaGVyZWZvcmUsIGlmIGEgQ29udHJpYnV0b3IgaW5jbHVkZXMgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIHN1Y2ggQ29udHJpYnV0b3IKKygiQ29tbWVyY2lhbCBDb250cmlidXRvciIpIGhlcmVieSBhZ3JlZXMgdG8gZGVmZW5kIGFuZCBpbmRlbW5pZnkgZXZlcnkgb3RoZXIgQ29udHJpYnV0b3IgKCJJbmRlbW5pZmllZCBDb250cmlidXRvciIpCithZ2FpbnN0IGFueSBsb3NzZXMsIGRhbWFnZXMgYW5kIGNvc3RzIChjb2xsZWN0aXZlbHkgIkxvc3NlcyIpIGFyaXNpbmcgZnJvbSBjbGFpbXMsIGxhd3N1aXRzIGFuZCBvdGhlciBsZWdhbCBhY3Rpb25zCiticm91Z2h0IGJ5IGEgdGhpcmQgcGFydHkgYWdhaW5zdCB0aGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgdG8gdGhlIGV4dGVudCBjYXVzZWQgYnkgdGhlIGFjdHMgb3Igb21pc3Npb25zIG9mIHN1Y2gKK0NvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4gY29ubmVjdGlvbiB3aXRoIGl0cyBkaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcuIFRoZQorb2JsaWdhdGlvbnMgaW4gdGhpcyBzZWN0aW9uIGRvIG5vdCBhcHBseSB0byBhbnkgY2xhaW1zIG9yIExvc3NlcyByZWxhdGluZyB0byBhbnkgYWN0dWFsIG9yIGFsbGVnZWQgaW50ZWxsZWN0dWFsCitwcm9wZXJ0eSBpbmZyaW5nZW1lbnQuIEluIG9yZGVyIHRvIHF1YWxpZnksIGFuIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG11c3Q6IGEpIHByb21wdGx5IG5vdGlmeSB0aGUgQ29tbWVyY2lhbAorQ29udHJpYnV0b3IgaW4gd3JpdGluZyBvZiBzdWNoIGNsYWltLCBhbmQgYikgYWxsb3cgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgdG8gY29udHJvbCwgYW5kIGNvb3BlcmF0ZSB3aXRoIHRoZQorQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiwgdGhlIGRlZmVuc2UgYW5kIGFueSByZWxhdGVkIHNldHRsZW1lbnQgbmVnb3RpYXRpb25zLiBUaGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbWF5CisgcGFydGljaXBhdGUgaW4gYW55IHN1Y2ggY2xhaW0gYXQgaXRzIG93biBleHBlbnNlLgorCitGb3IgZXhhbXBsZSwgYSBDb250cmlidXRvciBtaWdodCBpbmNsdWRlIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBQcm9kdWN0IFguIFRoYXQgQ29udHJpYnV0b3IgaXMKK3RoZW4gYSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yLiBJZiB0aGF0IENvbW1lcmNpYWwgQ29udHJpYnV0b3IgdGhlbiBtYWtlcyBwZXJmb3JtYW5jZSBjbGFpbXMsIG9yIG9mZmVycyB3YXJyYW50aWVzCityZWxhdGVkIHRvIFByb2R1Y3QgWCwgdGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZCB3YXJyYW50aWVzIGFyZSBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IncyByZXNwb25zaWJpbGl0eSBhbG9uZS4KK1VuZGVyIHRoaXMgc2VjdGlvbiwgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3Igd291bGQgaGF2ZSB0byBkZWZlbmQgY2xhaW1zIGFnYWluc3QgdGhlIG90aGVyIENvbnRyaWJ1dG9ycyByZWxhdGVkIHRvCit0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMsIGFuZCBpZiBhIGNvdXJ0IHJlcXVpcmVzIGFueSBvdGhlciBDb250cmlidXRvciB0byBwYXkgYW55IGRhbWFnZXMgYXMgYSByZXN1bHQsCit0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciBtdXN0IHBheSB0aG9zZSBkYW1hZ2VzLgorCis1LiBOTyBXQVJSQU5UWQorCitFWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTIEFHUkVFTUVOVCwgVEhFIFBST0dSQU0gSVMgUFJPVklERUQgT04gQU4gIkFTIElTIiBCQVNJUywgV0lUSE9VVCBXQVJSQU5USUVTIE9SCitDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBFSVRIRVIgRVhQUkVTUyBPUiBJTVBMSUVEIElOQ0xVRElORywgV0lUSE9VVCBMSU1JVEFUSU9OLCBBTlkgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIFRJVExFLAorTk9OLUlORlJJTkdFTUVOVCwgTUVSQ0hBTlRBQklMSVRZIE9SIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBFYWNoIFJlY2lwaWVudCBpcyBzb2xlbHkgcmVzcG9uc2libGUgZm9yCitkZXRlcm1pbmluZyB0aGUgYXBwcm9wcmlhdGVuZXNzIG9mIHVzaW5nIGFuZCBkaXN0cmlidXRpbmcgdGhlIFByb2dyYW0gYW5kIGFzc3VtZXMgYWxsIHJpc2tzIGFzc29jaWF0ZWQgd2l0aCBpdHMKK2V4ZXJjaXNlIG9mIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCAsIGluY2x1ZGluZyBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIHJpc2tzIGFuZCBjb3N0cyBvZiBwcm9ncmFtIGVycm9ycywgY29tcGxpYW5jZQord2l0aCBhcHBsaWNhYmxlIGxhd3MsIGRhbWFnZSB0byBvciBsb3NzIG9mIGRhdGEsIHByb2dyYW1zIG9yIGVxdWlwbWVudCwgYW5kIHVuYXZhaWxhYmlsaXR5IG9yIGludGVycnVwdGlvbiBvZiBvcGVyYXRpb25zLgorCis2LiBESVNDTEFJTUVSIE9GIExJQUJJTElUWQorCitFWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTIEFHUkVFTUVOVCwgTkVJVEhFUiBSRUNJUElFTlQgTk9SIEFOWSBDT05UUklCVVRPUlMgU0hBTEwgSEFWRSBBTlkgTElBQklMSVRZIEZPUiBBTlkKK0RJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcgV0lUSE9VVCBMSU1JVEFUSU9OIExPU1QgUFJPRklUUyksCitIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SCitPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPUiBESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gT1IgVEhFIEVYRVJDSVNFIE9GIEFOWSBSSUdIVFMgR1JBTlRFRAorSEVSRVVOREVSLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFUy4KKworNy4gR0VORVJBTAorCitJZiBhbnkgcHJvdmlzaW9uIG9mIHRoaXMgQWdyZWVtZW50IGlzIGludmFsaWQgb3IgdW5lbmZvcmNlYWJsZSB1bmRlciBhcHBsaWNhYmxlIGxhdywgaXQgc2hhbGwgbm90IGFmZmVjdCB0aGUgdmFsaWRpdHkgb3IKK2VuZm9yY2VhYmlsaXR5IG9mIHRoZSByZW1haW5kZXIgb2YgdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBhbmQgd2l0aG91dCBmdXJ0aGVyIGFjdGlvbiBieSB0aGUgcGFydGllcyBoZXJldG8sIHN1Y2gKK3Byb3Zpc2lvbiBzaGFsbCBiZSByZWZvcm1lZCB0byB0aGUgbWluaW11bSBleHRlbnQgbmVjZXNzYXJ5IHRvIG1ha2Ugc3VjaCBwcm92aXNpb24gdmFsaWQgYW5kIGVuZm9yY2VhYmxlLgorCitJZiBSZWNpcGllbnQgaW5zdGl0dXRlcyBwYXRlbnQgbGl0aWdhdGlvbiBhZ2FpbnN0IGFueSBlbnRpdHkgKGluY2x1ZGluZyBhIGNyb3NzLWNsYWltIG9yIGNvdW50ZXJjbGFpbSBpbiBhIGxhd3N1aXQpCithbGxlZ2luZyB0aGF0IHRoZSBQcm9ncmFtIGl0c2VsZiAoZXhjbHVkaW5nIGNvbWJpbmF0aW9ucyBvZiB0aGUgUHJvZ3JhbSB3aXRoIG90aGVyIHNvZnR3YXJlIG9yIGhhcmR3YXJlKSBpbmZyaW5nZXMgc3VjaAorUmVjaXBpZW50J3MgcGF0ZW50KHMpLCB0aGVuIHN1Y2ggUmVjaXBpZW50J3MgcmlnaHRzIGdyYW50ZWQgdW5kZXIgU2VjdGlvbiAyKGIpIHNoYWxsIHRlcm1pbmF0ZSBhcyBvZiB0aGUgZGF0ZSBzdWNoCitsaXRpZ2F0aW9uIGlzIGZpbGVkLgorCitBbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHNoYWxsIHRlcm1pbmF0ZSBpZiBpdCBmYWlscyB0byBjb21wbHkgd2l0aCBhbnkgb2YgdGhlIG1hdGVyaWFsIHRlcm1zIG9yCitjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50IGFuZCBkb2VzIG5vdCBjdXJlIHN1Y2ggZmFpbHVyZSBpbiBhIHJlYXNvbmFibGUgcGVyaW9kIG9mIHRpbWUgYWZ0ZXIgYmVjb21pbmcgYXdhcmUgb2Ygc3VjaAorbm9uY29tcGxpYW5jZS4gSWYgYWxsIFJlY2lwaWVudCdzIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCB0ZXJtaW5hdGUsIFJlY2lwaWVudCBhZ3JlZXMgdG8gY2Vhc2UgdXNlIGFuZCBkaXN0cmlidXRpb24KK29mIHRoZSBQcm9ncmFtIGFzIHNvb24gYXMgcmVhc29uYWJseSBwcmFjdGljYWJsZS4gSG93ZXZlciwgUmVjaXBpZW50J3Mgb2JsaWdhdGlvbnMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYW5kIGFueSBsaWNlbnNlcworIGdyYW50ZWQgYnkgUmVjaXBpZW50IHJlbGF0aW5nIHRvIHRoZSBQcm9ncmFtIHNoYWxsIGNvbnRpbnVlIGFuZCBzdXJ2aXZlLgorCitFdmVyeW9uZSBpcyBwZXJtaXR0ZWQgdG8gY29weSBhbmQgZGlzdHJpYnV0ZSBjb3BpZXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGJ1dCBpbiBvcmRlciB0byBhdm9pZCBpbmNvbnNpc3RlbmN5IHRoZSBBZ3JlZW1lbnQKK2lzIGNvcHlyaWdodGVkIGFuZCBtYXkgb25seSBiZSBtb2RpZmllZCBpbiB0aGUgZm9sbG93aW5nIG1hbm5lci4gVGhlIEFncmVlbWVudCBTdGV3YXJkIHJlc2VydmVzIHRoZSByaWdodCB0byBwdWJsaXNoCituZXcgdmVyc2lvbnMgKGluY2x1ZGluZyByZXZpc2lvbnMpIG9mIHRoaXMgQWdyZWVtZW50IGZyb20gdGltZSB0byB0aW1lLiBObyBvbmUgb3RoZXIgdGhhbiB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgaGFzIHRoZQorcmlnaHQgdG8gbW9kaWZ5IHRoaXMgQWdyZWVtZW50LiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIHRoZSBpbml0aWFsIEFncmVlbWVudCBTdGV3YXJkLiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1heQorYXNzaWduIHRoZSByZXNwb25zaWJpbGl0eSB0byBzZXJ2ZSBhcyB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgdG8gYSBzdWl0YWJsZSBzZXBhcmF0ZSBlbnRpdHkuIEVhY2ggbmV3IHZlcnNpb24gb2YgdGhlCitBZ3JlZW1lbnQgd2lsbCBiZSBnaXZlbiBhIGRpc3Rpbmd1aXNoaW5nIHZlcnNpb24gbnVtYmVyLiBUaGUgUHJvZ3JhbSAoaW5jbHVkaW5nIENvbnRyaWJ1dGlvbnMpIG1heSBhbHdheXMgYmUKK2Rpc3RyaWJ1dGVkIHN1YmplY3QgdG8gdGhlIHZlcnNpb24gb2YgdGhlIEFncmVlbWVudCB1bmRlciB3aGljaCBpdCB3YXMgcmVjZWl2ZWQuIEluIGFkZGl0aW9uLCBhZnRlciBhIG5ldyB2ZXJzaW9uIG9mCit0aGUgQWdyZWVtZW50IGlzIHB1Ymxpc2hlZCwgQ29udHJpYnV0b3IgbWF5IGVsZWN0IHRvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0gKGluY2x1ZGluZyBpdHMgQ29udHJpYnV0aW9ucykgdW5kZXIgdGhlCituZXcgdmVyc2lvbi4gRXhjZXB0IGFzIGV4cHJlc3NseSBzdGF0ZWQgaW4gU2VjdGlvbnMgMihhKSBhbmQgMihiKSBhYm92ZSwgUmVjaXBpZW50IHJlY2VpdmVzIG5vIHJpZ2h0cyBvciBsaWNlbnNlcyB0bwordGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBvZiBhbnkgQ29udHJpYnV0b3IgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIHdoZXRoZXIgZXhwcmVzc2x5LCBieSBpbXBsaWNhdGlvbiwgZXN0b3BwZWwgb3IKK290aGVyd2lzZS4gQWxsIHJpZ2h0cyBpbiB0aGUgUHJvZ3JhbSBub3QgZXhwcmVzc2x5IGdyYW50ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYXJlIHJlc2VydmVkLgorCitUaGlzIEFncmVlbWVudCBpcyBnb3Zlcm5lZCBieSB0aGUgbGF3cyBvZiB0aGUgU3RhdGUgb2YgTmV3IFlvcmsgYW5kIHRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgbGF3cyBvZiB0aGUgVW5pdGVkIFN0YXRlcworb2YgQW1lcmljYS4gTm8gcGFydHkgdG8gdGhpcyBBZ3JlZW1lbnQgd2lsbCBicmluZyBhIGxlZ2FsIGFjdGlvbiB1bmRlciB0aGlzIEFncmVlbWVudCBtb3JlIHRoYW4gb25lIHllYXIgYWZ0ZXIgdGhlIGNhdXNlCitvZiBhY3Rpb24gYXJvc2UuIEVhY2ggcGFydHkgd2FpdmVzIGl0cyByaWdodHMgdG8gYSBqdXJ5IHRyaWFsIGluIGFueSByZXN1bHRpbmcgbGl0aWdhdGlvbi4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL01FVEEtSU5GL01BTklGRVNULk1GIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9NRVRBLUlORi9NQU5JRkVTVC5NRgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hY2I5NDVjCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9NRVRBLUlORi9NQU5JRkVTVC5NRgpAQCAtMCwwICsxLDQ2IEBACitNYW5pZmVzdC1WZXJzaW9uOiAxLjAKK0J1bmRsZS1NYW5pZmVzdFZlcnNpb246IDIKK0J1bmRsZS1OYW1lOiBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpCitCdW5kbGUtU3ltYm9saWNOYW1lOiBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpO3NpbmdsZXRvbjo9dHJ1ZQorQnVuZGxlLVZlcnNpb246IDAuOS4wLnF1YWxpZmllcgorQnVuZGxlLUFjdGl2YXRvcjogb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5Db3JlVWlBY3RpdmF0b3IKK0J1bmRsZS1WZW5kb3I6IEVjbGlwc2UgT1NCUAorQnVuZGxlLVJlcXVpcmVkRXhlY3V0aW9uRW52aXJvbm1lbnQ6IEphdmFTRS0xLjgKK0ltcG9ydC1QYWNrYWdlOiBvcmcub3NnaS5mcmFtZXdvcms7dmVyc2lvbj0iMS4zLjAiLAorIG9yZy5vc2dpLnNlcnZpY2UuZXZlbnQ7dmVyc2lvbj0iMS4zLjAiLAorIG9yZy5zbGY0ajt2ZXJzaW9uPSIxLjcuMiIKK0J1bmRsZS1BY3RpdmF0aW9uUG9saWN5OiBsYXp5CitSZXF1aXJlLUJ1bmRsZTogb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXM7YnVuZGxlLXZlcnNpb249IjMuOS4wIiwKKyBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWU7YnVuZGxlLXZlcnNpb249IjMuMTAuMCIsCisgb3JnLmVjbGlwc2UueHRleHQuYnVpbGRlcjtidW5kbGUtdmVyc2lvbj0iWzIuNy4zLDIuOC4wKSIsCisgb3JnLmVjbGlwc2UudWkud29ya2JlbmNoLAorIG9yZy5lY2xpcHNlLnVpO2J1bmRsZS12ZXJzaW9uPSIzLjEwNi4wIiwKKyBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlO2J1bmRsZS12ZXJzaW9uPSJbMC45LjAsMC4xMC4wKSIsCisgb3JnLmVjbGlwc2UueHRleHQudWk7YnVuZGxlLXZlcnNpb249IlsyLjcuMywyLjguMCkiLAorIG9yZy5lY2xpcHNlLnh0ZXh0LnVpLnNoYXJlZDtidW5kbGUtdmVyc2lvbj0iWzIuNy4zLDIuOC4wKSIsCisgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGk7YnVuZGxlLXZlcnNpb249IlswLjkuMCwwLjEwLjApIiwKKyBvcmcuZWNsaXBzZS54dGV4dC5jb21tb24udHlwZXMudWk7YnVuZGxlLXZlcnNpb249IlsyLjcuMywyLjguMCkiLAorIG9yZy5lY2xpcHNlLmpkdC5jb3JlLAorIG9yZy5lY2xpcHNlLm9zYnAueHRleHQuYnVpbGRlci51aS5hY2Nlc3M7YnVuZGxlLXZlcnNpb249IlswLjkuMCwwLjEwLjApIiwKKyBvcmcuZWNsaXBzZS51aS5pZGU7YnVuZGxlLXZlcnNpb249IjMuMTAuMCIsCisgb3JnLmVjbGlwc2UuamR0LnVpLAorIG9yZy5lY2xpcHNlLnNlYXJjaCwKKyBvcmcuZWNsaXBzZS51aS5jb25zb2xlLAorIG9yZy5lY2xpcHNlLmpkdC5sYXVuY2hpbmcsCisgb3JnLmVjbGlwc2Uub3NicC5kc2wueHRleHQubGF6eXJlc29sdmVyLmFwaTtidW5kbGUtdmVyc2lvbj0iWzAuOS4wLDAuMTAuMCkiLAorIG9yZy5lY2xpcHNlLm9zYnAuZWN2aWV3LmNvcmUuY29tbW9uLm1vZGVsO2J1bmRsZS12ZXJzaW9uPSJbMC45LjAsMC4xMC4wKSIsCisgb3JnLmVjbGlwc2Uub3NicC5lY3ZpZXcuY29yZS5leHRlbnNpb24ubW9kZWw7YnVuZGxlLXZlcnNpb249IlswLjkuMCwwLjEwLjApIiwKKyBvcmcuZWNsaXBzZS5wZGUudWksCisgb3JnLmVjbGlwc2UuZXF1aW5veC5wMi5tZXRhZGF0YSwKKyBvcmcuZWNsaXBzZS5vc2JwLmRzbC5lbnRpdHkueHRleHQ7YnVuZGxlLXZlcnNpb249IlswLjkuMCwwLjEwLjApIiwKKyBvcmcuZWNsaXBzZS5vc2JwLmRzbC5kdG8ueHRleHQ7YnVuZGxlLXZlcnNpb249IlswLjkuMCwwLjEwLjApIiwKKyBvcmcuZWNsaXBzZS5vc2JwLmRzbC5zZXJ2aWNlcy54dGV4dDtidW5kbGUtdmVyc2lvbj0iWzAuOS4wLDAuMTAuMCkiCitFeHBvcnQtUGFja2FnZTogb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aTt4LWludGVybmFsOj10cnVlO3ZlcnNpb249IjAuOS4wIiwKKyBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLmJ1aWxkZXI7eC1pbnRlcm5hbDo9dHJ1ZTt2ZXJzaW9uPSIwLjkuMCIsCisgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5pMThuO3gtaW50ZXJuYWw6PXRydWU7dmVyc2lvbj0iMC45LjAiLAorIG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkubmF0dXJlO3gtaW50ZXJuYWw6PXRydWU7dmVyc2lvbj0iMC45LjAiLAorIG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkudXRpbDsKKyAgdXNlczo9Im9yZy5lY2xpcHNlLmVtZi5lY29yZSwKKyAgIG9yZy5lY2xpcHNlLmpkdC5jb3JlLAorICAgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMiO3ZlcnNpb249IjAuOS4wIiwKKyBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnZpZXc7eC1pbnRlcm5hbDo9dHJ1ZTt2ZXJzaW9uPSIwLjkuMCIKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvYWJvdXQuaHRtbCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvYWJvdXQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NGMwNTk4Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9hYm91dC5odG1sCkBAIC0wLDAgKzEsMjggQEAKKzwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFN0cmljdC8vRU4iCisgICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXN0cmljdC5kdGQiPgorPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiPgorPGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1JU08tODg1OS0xIi8+Cis8dGl0bGU+QWJvdXQ8L3RpdGxlPgorPC9oZWFkPgorPGJvZHkgbGFuZz0iRU4tVVMiPgorPGgyPkFib3V0IFRoaXMgQ29udGVudDwvaDI+CisgCis8cD5KdW5lIDEsIDIwMTY8L3A+CQorPGgzPkxpY2Vuc2U8L2gzPgorCis8cD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBhbGwgY29udGVudCBpbiB0aGlzIHBsdWctaW4gKCZxdW90O0NvbnRlbnQmcXVvdDspLiAgVW5sZXNzIG90aGVyd2lzZSAKK2luZGljYXRlZCBiZWxvdywgdGhlIENvbnRlbnQgaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUKK0VjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKCZxdW90O0VQTCZxdW90OykuICBBIGNvcHkgb2YgdGhlIEVQTCBpcyBhdmFpbGFibGUgCithdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L2E+LgorRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICZxdW90O1Byb2dyYW0mcXVvdDsgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvcD4KKworPHA+SWYgeW91IGRpZCBub3QgcmVjZWl2ZSB0aGlzIENvbnRlbnQgZGlyZWN0bHkgZnJvbSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uLCB0aGUgQ29udGVudCBpcyAKK2JlaW5nIHJlZGlzdHJpYnV0ZWQgYnkgYW5vdGhlciBwYXJ0eSAoJnF1b3Q7UmVkaXN0cmlidXRvciZxdW90OykgYW5kIGRpZmZlcmVudCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBtYXkKK2FwcGx5IHRvIHlvdXIgdXNlIG9mIGFueSBvYmplY3QgY29kZSBpbiB0aGUgQ29udGVudC4gIENoZWNrIHRoZSBSZWRpc3RyaWJ1dG9yJ3MgbGljZW5zZSB0aGF0IHdhcyAKK3Byb3ZpZGVkIHdpdGggdGhlIENvbnRlbnQuICBJZiBubyBzdWNoIGxpY2Vuc2UgZXhpc3RzLCBjb250YWN0IHRoZSBSZWRpc3RyaWJ1dG9yLiAgVW5sZXNzIG90aGVyd2lzZQoraW5kaWNhdGVkIGJlbG93LCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVQTCBzdGlsbCBhcHBseSB0byBhbnkgc291cmNlIGNvZGUgaW4gdGhlIENvbnRlbnQKK2FuZCBzdWNoIHNvdXJjZSBjb2RlIG1heSBiZSBvYnRhaW5lZCBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnLyI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZzwvYT4uPC9wPgorCis8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9hYm91dC5pbmkgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL2Fib3V0LmluaQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43ZGY2NzFmCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9hYm91dC5pbmkKQEAgLTAsMCArMSwxNyBAQAorIyBhYm91dC5pbmkKKyMgY29udGFpbnMgaW5mb3JtYXRpb24gYWJvdXQgYSBmZWF0dXJlCisjIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCisjICIla2V5IiBhcmUgZXh0ZXJuYWxpemVkIHN0cmluZ3MgZGVmaW5lZCBpbiBhYm91dC5wcm9wZXJ0aWVzCisjIFRoaXMgZmlsZSBkb2VzIG5vdCBuZWVkIHRvIGJlIHRyYW5zbGF0ZWQuCisKKyMgUHJvcGVydHkgImFib3V0VGV4dCIgY29udGFpbnMgYmx1cmIgZm9yICJBYm91dCIgZGlhbG9nICh0cmFuc2xhdGVkKQorYWJvdXRUZXh0PSVmZWF0dXJlVGV4dAorCisjIFByb3BlcnR5ICJmZWF0dXJlSW1hZ2UiIGNvbnRhaW5zIHBhdGggdG8gZmVhdHVyZSBpbWFnZSAoMzJ4MzIpCitmZWF0dXJlSW1hZ2U9CisKKyMgUHJvcGVydHkgImFwcE5hbWUiIGNvbnRhaW5zIG5hbWUgb2YgdGhlIGFwcGxpY2F0aW9uICh0cmFuc2xhdGVkKQorYXBwTmFtZT0lZmVhdHVyZU5hbWUKKworIyBQcm9wZXJ0eSAid2VsY29tZVBhZ2UiIGNvbnRhaW5zIHBhdGggdG8gd2VsY29tZSBwYWdlIChzcGVjaWFsIFhNTC1iYXNlZCBmb3JtYXQpCit3ZWxjb21lUGFnZT0KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvYWJvdXQubWFwcGluZ3MgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL2Fib3V0Lm1hcHBpbmdzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQ1MTFhMGEKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL2Fib3V0Lm1hcHBpbmdzCkBAIC0wLDAgKzEsNiBAQAorIyBhYm91dC5tYXBwaW5ncworIyBjb250YWlucyBmaWxsLWlucyBmb3IgYWJvdXQucHJvcGVydGllcworIyBqYXZhLmlvLlByb3BlcnRpZXMgZmlsZSAoSVNPIDg4NTktMSB3aXRoICJcIiBlc2NhcGVzKQorIyBUaGlzIGZpbGUgZG9lcyBub3QgbmVlZCB0byBiZSB0cmFuc2xhdGVkLgorCiswPXF1YWxpZmllcgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9hYm91dC5wcm9wZXJ0aWVzIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9hYm91dC5wcm9wZXJ0aWVzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmM2OTMxMDIKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL2Fib3V0LnByb3BlcnRpZXMKQEAgLTAsMCArMSwyNiBAQAorIworIyBDb3B5cmlnaHQgKGMpIDIwMTIsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHIChIZWlkZWxiZXJnKQorIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisjIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAorIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorIworIyBDb250cmlidXRvcnM6CisjICAgIExvZXR6IEdtYkgmQ28uS0cgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KKyMKKworIyBOTFNfTUVTU0FHRUZPUk1BVF9WQVIKKworZmVhdHVyZU5hbWU9b3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aQorCisjIyMjIyMjIyMjIyMjIyMjIGJsdXJiIHByb3BlcnR5ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIworZmVhdHVyZVRleHQ9XAorQ29weXJpZ2h0IChjKSAyMDEyLTIwMTYgLSBMb2V0eiBHbWJIJkNvLktHIFxuXAorQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFsc1xuXAorYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wXG5cCit3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdFxuXAoraHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWxcblwKK1xuXAorQ29udHJpYnV0b3JzOlxuXAorICAgIExvZXR6IEdtYkgmQ28uS0cgLSBpbXBsZW1lbnRhdGlvblxuCisjIyMjIyMjIyMjIyMjIyMjIGVuZCBvZiBibHVyYiBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvYnVpbGQucHJvcGVydGllcyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvYnVpbGQucHJvcGVydGllcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yYjU4YTc4Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9idWlsZC5wcm9wZXJ0aWVzCkBAIC0wLDAgKzEsMTAgQEAKK3NvdXJjZS4uID0gc3JjCitiaW4uaW5jbHVkZXMgPSBhYm91dC5wcm9wZXJ0aWVzLCAgYWJvdXQubWFwcGluZ3MsICBhYm91dC5pbmksICBhYm91dC5odG1sLCAgTUVUQS1JTkYvLFwKKyAgICAgICAgICAgICAgIC4sXAorICAgICAgICAgICAgICAgcGx1Z2luLnhtbCxcCisgICAgICAgICAgICAgICBpY29ucy8sXAorICAgICAgICAgICAgICAgLnByb2plY3QsXAorICAgICAgICAgICAgICAgTElDRU5TRS50eHQsXAorICAgICAgICAgICAgICAgbGljZW5zZS5odG1sCitvdXRwdXQuLiA9IHRhcmdldC9jbGFzc2VzLworc3JjLmluY2x1ZGVzID0gYWJvdXQucHJvcGVydGllcywgIGFib3V0Lm1hcHBpbmdzLCAgYWJvdXQuaW5pLCAgYWJvdXQuaHRtbCwgIGxpY2Vuc2UuaHRtbApkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9pY29ucy9Qcm9qZWN0LmdpZiBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvaWNvbnMvUHJvamVjdC5naWYKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZGNjNTI0ZQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvaWNvbnMvUHJvamVjdC5naWYKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9pY29ucy9Qcm9wZXJ0eS5naWYgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL2ljb25zL1Byb3BlcnR5LmdpZgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kMmYyNTdjCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9pY29ucy9Qcm9wZXJ0eS5naWYKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9pY29ucy9SZXNvdXJjZS5naWYgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL2ljb25zL1Jlc291cmNlLmdpZgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jMjdmYmE0Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9pY29ucy9SZXNvdXJjZS5naWYKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9pY29ucy9uYXR1cmVfb3ZlcmxheS5wbmcgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL2ljb25zL25hdHVyZV9vdmVybGF5LnBuZwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wMDk4ZWExCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9pY29ucy9uYXR1cmVfb3ZlcmxheS5wbmcKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9saWNlbnNlLmh0bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL2xpY2Vuc2UuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jMzNkNDVjCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9saWNlbnNlLmh0bWwKQEAgLTAsMCArMSwxMDkgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IklTTy04ODU5LTEiID8+Cis8IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBTdHJpY3QvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtc3RyaWN0LmR0ZCI+Cis8IS0tIHNhdmVkIGZyb20gdXJsPSgwMDQ0KWh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsL25vdGljZS5odG1sIC0tPgorPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiPgorPGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1JU08tODg1OS0xIiAvPgorPHRpdGxlPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvdGl0bGU+Cis8L2hlYWQ+CisKKzxib2R5IGxhbmc9IkVOLVVTIj4KKzxoMj5FY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L2gyPgorPHA+RmVicnVhcnkgMSwgMjAxMTwvcD4KKworPGgzPlVzYWdlIE9mIENvbnRlbnQ8L2gzPgorCis8cD5USEUgRUNMSVBTRSBGT1VOREFUSU9OIE1BS0VTIEFWQUlMQUJMRSBTT0ZUV0FSRSwgRE9DVU1FTlRBVElPTiwgSU5GT1JNQVRJT04gQU5EL09SIE9USEVSIE1BVEVSSUFMUyBGT1IgT1BFTiBTT1VSQ0UgUFJPSkVDVFMKKyAgIChDT0xMRUNUSVZFTFkgJnF1b3Q7Q09OVEVOVCZxdW90OykuICBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5ECisgICBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVSBBR1JFRSBUSEFUIFlPVVIgVVNFCisgICBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUgorICAgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORCBUSEUgVEVSTVMgQU5ECisgICBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLCBUSEVOIFlPVSBNQVkgTk9UIFVTRSBUSEUgQ09OVEVOVC48L3A+CisKKzxoMz5BcHBsaWNhYmxlIExpY2Vuc2VzPC9oMz4KKworPHA+VW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMAorICAgKCZxdW90O0VQTCZxdW90OykuICBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXMgQ29udGVudCBhbmQgaXMgYWxzbyBhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sPC9hPi4KKyAgIEZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAmcXVvdDtQcm9ncmFtJnF1b3Q7IHdpbGwgbWVhbiB0aGUgQ29udGVudC48L3A+CisKKzxwPkNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLCBkb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gc291cmNlIGNvZGUKKyAgIHJlcG9zaXRvcnkgKCZxdW90O1JlcG9zaXRvcnkmcXVvdDspIGluIHNvZnR3YXJlIG1vZHVsZXMgKCZxdW90O01vZHVsZXMmcXVvdDspIGFuZCBtYWRlIGF2YWlsYWJsZSBhcyBkb3dubG9hZGFibGUgYXJjaGl2ZXMgKCZxdW90O0Rvd25sb2FkcyZxdW90OykuPC9wPgorCis8dWw+CisgICAgICAgPGxpPkNvbnRlbnQgbWF5IGJlIHN0cnVjdHVyZWQgYW5kIHBhY2thZ2VkIGludG8gbW9kdWxlcyB0byBmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsIGV4dGVuZGluZywgYW5kIHVwZ3JhZGluZyB0aGUgQ29udGVudC4gIFR5cGljYWwgbW9kdWxlcyBtYXkgaW5jbHVkZSBwbHVnLWlucyAoJnF1b3Q7UGx1Zy1pbnMmcXVvdDspLCBwbHVnLWluIGZyYWdtZW50cyAoJnF1b3Q7RnJhZ21lbnRzJnF1b3Q7KSwgYW5kIGZlYXR1cmVzICgmcXVvdDtGZWF0dXJlcyZxdW90OykuPC9saT4KKyAgICAgICA8bGk+RWFjaCBQbHVnLWluIG9yIEZyYWdtZW50IG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3Rvcnkgb3IgSkFSIChKYXZhJnRyYWRlOyBBUmNoaXZlKSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtwbHVnaW5zJnF1b3Q7LjwvbGk+CisgICAgICAgPGxpPkEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLiAgRWFjaCBGZWF0dXJlIG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3RvcnkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgJnF1b3Q7ZmVhdHVyZXMmcXVvdDsuICBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnhtbCZxdW90OyBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgdGhlIFBsdWctaW5zCisgICAgICBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuPC9saT4KKyAgICAgICA8bGk+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoJnF1b3Q7SW5jbHVkZWQgRmVhdHVyZXMmcXVvdDspLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnhtbCZxdW90OyBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgb2YgSW5jbHVkZWQgRmVhdHVyZXMuPC9saT4KKzwvdWw+CisKKzxwPlRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICZxdW90O2Fib3V0Lmh0bWwmcXVvdDsgKCZxdW90O0Fib3V0cyZxdW90OykuIFRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kCitJbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICZxdW90O2xpY2Vuc2UuaHRtbCZxdW90OyAoJnF1b3Q7RmVhdHVyZSBMaWNlbnNlcyZxdW90OykuICBBYm91dHMgYW5kIEZlYXR1cmUgTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55IGRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZQoraW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyBsb2NhdGlvbnM6PC9wPgorCis8dWw+CisgICAgICAgPGxpPlRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeTwvbGk+CisgICAgICAgPGxpPlBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzPC9saT4KKyAgICAgICA8bGk+SW5zaWRlIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgcGFja2FnZWQgYXMgSkFSczwvbGk+CisgICAgICAgPGxpPlN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICZxdW90O3NyYyZxdW90OyBvZiBjZXJ0YWluIFBsdWctaW5zPC9saT4KKyAgICAgICA8bGk+RmVhdHVyZSBkaXJlY3RvcmllczwvbGk+Cis8L3VsPgorCis8cD5Ob3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IChhcyBkZWZpbmVkIGJlbG93KSwgeW91IG11c3QgYWdyZWUgdG8gYSBsaWNlbnNlICgmcXVvdDtGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlJnF1b3Q7KSBkdXJpbmcgdGhlCitpbnN0YWxsYXRpb24gcHJvY2Vzcy4gIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zIEluY2x1ZGVkIEZlYXR1cmVzLCB0aGUgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBzaG91bGQgZWl0aGVyIHByb3ZpZGUgeW91IHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IKK2luZm9ybSB5b3Ugd2hlcmUgeW91IGNhbiBsb2NhdGUgdGhlbS4gIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSBmb3VuZCBpbiB0aGUgJnF1b3Q7bGljZW5zZSZxdW90OyBwcm9wZXJ0eSBvZiBmaWxlcyBuYW1lZCAmcXVvdDtmZWF0dXJlLnByb3BlcnRpZXMmcXVvdDsgZm91bmQgd2l0aGluIGEgRmVhdHVyZS4KK1N1Y2ggQWJvdXRzLCBGZWF0dXJlIExpY2Vuc2VzLCBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgKG9yIHJlZmVyZW5jZXMgdG8gc3VjaCB0ZXJtcyBhbmQgY29uZGl0aW9ucykgdGhhdCBnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbgordGhhdCBkaXJlY3RvcnkuPC9wPgorCis8cD5USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTLCBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSIFRPIFRIRSBFUEwgT1IgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTLCBOT1RJQ0VTIE9SIFRFUk1TIEFORCBDT05ESVRJT05TLiAgU09NRSBPRiBUSEVTRQorT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTo8L3A+CisKKzx1bD4KKyAgICAgICA8bGk+RWNsaXBzZSBEaXN0cmlidXRpb24gTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGljZW5zZXMvZWRsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xpY2Vuc2VzL2VkbC12MS4wLmh0bWw8L2E+KTwvbGk+CisgICAgICAgPGxpPkNvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbDwvYT4pPC9saT4KKyAgICAgICA8bGk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFPC9hPik8L2xpPgorICAgICAgIDxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMDwvYT4pPC9saT4KKyAgICAgICA8bGk+TWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwiPmh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sPC9hPik8L2xpPgorICAgICAgIDxsaT5Nb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sIj5odHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWw8L2E+KTwvbGk+Cis8L3VsPgorCis8cD5JVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCBDT05ESVRJT05TIFBSSU9SIFRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2UsIG9yIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2UgaXMgcHJvdmlkZWQsIHBsZWFzZQorY29udGFjdCB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHRvIGRldGVybWluZSB3aGF0IHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC48L3A+CisKKworPGgzPlVzZSBvZiBQcm92aXNpb25pbmcgVGVjaG5vbG9neTwvaDM+CisKKzxwPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIHByb3Zpc2lvbmluZyBzb2Z0d2FyZSwgZXhhbXBsZXMgb2Ygd2hpY2ggaW5jbHVkZSwgYnV0IGFyZSBub3QgbGltaXRlZCB0bywgcDIgYW5kIHRoZSBFY2xpcHNlCisgICBVcGRhdGUgTWFuYWdlciAoJnF1b3Q7UHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kmcXVvdDspIGZvciB0aGUgcHVycG9zZSBvZiBhbGxvd2luZyB1c2VycyB0byBpbnN0YWxsIHNvZnR3YXJlLCBkb2N1bWVudGF0aW9uLCBpbmZvcm1hdGlvbiBhbmQvb3IKKyAgIG90aGVyIG1hdGVyaWFscyAoY29sbGVjdGl2ZWx5ICZxdW90O0luc3RhbGxhYmxlIFNvZnR3YXJlJnF1b3Q7KS4gVGhpcyBjYXBhYmlsaXR5IGlzIHByb3ZpZGVkIHdpdGggdGhlIGludGVudCBvZiBhbGxvd2luZyBzdWNoIHVzZXJzIHRvCisgICBpbnN0YWxsLCBleHRlbmQgYW5kIHVwZGF0ZSBFY2xpcHNlLWJhc2VkIHByb2R1Y3RzLiBJbmZvcm1hdGlvbiBhYm91dCBwYWNrYWdpbmcgSW5zdGFsbGFibGUgU29mdHdhcmUgaXMgYXZhaWxhYmxlIGF0IDxhCisgICAgICAgaHJlZj0iaHR0cDovL2VjbGlwc2Uub3JnL2VxdWlub3gvcDIvcmVwb3NpdG9yeV9wYWNrYWdpbmcuaHRtbCI+aHR0cDovL2VjbGlwc2Uub3JnL2VxdWlub3gvcDIvcmVwb3NpdG9yeV9wYWNrYWdpbmcuaHRtbDwvYT4KKyAgICgmcXVvdDtTcGVjaWZpY2F0aW9uJnF1b3Q7KS48L3A+CisKKzxwPllvdSBtYXkgdXNlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IHRvIGFsbG93IG90aGVyIHBhcnRpZXMgdG8gaW5zdGFsbCBJbnN0YWxsYWJsZSBTb2Z0d2FyZS4gWW91IHNoYWxsIGJlIHJlc3BvbnNpYmxlIGZvciBlbmFibGluZyB0aGUKKyAgIGFwcGxpY2FibGUgbGljZW5zZSBhZ3JlZW1lbnRzIHJlbGF0aW5nIHRvIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSB0byBiZSBwcmVzZW50ZWQgdG8sIGFuZCBhY2NlcHRlZCBieSwgdGhlIHVzZXJzIG9mIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neQorICAgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBTcGVjaWZpY2F0aW9uLiBCeSB1c2luZyBQcm92aXNpb25pbmcgVGVjaG5vbG9neSBpbiBzdWNoIGEgbWFubmVyIGFuZCBtYWtpbmcgaXQgYXZhaWxhYmxlIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUKKyAgIFNwZWNpZmljYXRpb24sIHlvdSBmdXJ0aGVyIGFja25vd2xlZGdlIHlvdXIgYWdyZWVtZW50IHRvLCBhbmQgdGhlIGFjcXVpc2l0aW9uIG9mIGFsbCBuZWNlc3NhcnkgcmlnaHRzIHRvIHBlcm1pdCB0aGUgZm9sbG93aW5nOjwvcD4KKworPG9sPgorICAgICAgIDxsaT5BIHNlcmllcyBvZiBhY3Rpb25zIG1heSBvY2N1ciAoJnF1b3Q7UHJvdmlzaW9uaW5nIFByb2Nlc3MmcXVvdDspIGluIHdoaWNoIGEgdXNlciBtYXkgZXhlY3V0ZSB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kKKyAgICAgICBvbiBhIG1hY2hpbmUgKCZxdW90O1RhcmdldCBNYWNoaW5lJnF1b3Q7KSB3aXRoIHRoZSBpbnRlbnQgb2YgaW5zdGFsbGluZywgZXh0ZW5kaW5nIG9yIHVwZGF0aW5nIHRoZSBmdW5jdGlvbmFsaXR5IG9mIGFuIEVjbGlwc2UtYmFzZWQKKyAgICAgICBwcm9kdWN0LjwvbGk+CisgICAgICAgPGxpPkR1cmluZyB0aGUgUHJvdmlzaW9uaW5nIFByb2Nlc3MsIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSBtYXkgY2F1c2UgdGhpcmQgcGFydHkgSW5zdGFsbGFibGUgU29mdHdhcmUgb3IgYSBwb3J0aW9uIHRoZXJlb2YgdG8gYmUKKyAgICAgICBhY2Nlc3NlZCBhbmQgY29waWVkIHRvIHRoZSBUYXJnZXQgTWFjaGluZS48L2xpPgorICAgICAgIDxsaT5QdXJzdWFudCB0byB0aGUgU3BlY2lmaWNhdGlvbiwgeW91IHdpbGwgcHJvdmlkZSB0byB0aGUgdXNlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgdGhhdCBnb3Zlcm4gdGhlIHVzZSBvZiB0aGUgSW5zdGFsbGFibGUKKyAgICAgICBTb2Z0d2FyZSAoJnF1b3Q7SW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50JnF1b3Q7KSBhbmQgc3VjaCBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQgc2hhbGwgYmUgYWNjZXNzZWQgZnJvbSB0aGUgVGFyZ2V0CisgICAgICAgTWFjaGluZSBpbiBhY2NvcmRhbmNlIHdpdGggdGhlIFNwZWNpZmljYXRpb24uIFN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50IG11c3QgaW5mb3JtIHRoZSB1c2VyIG9mIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyB0aGF0IGdvdmVybgorICAgICAgIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBhbmQgbXVzdCBzb2xpY2l0IGFjY2VwdGFuY2UgYnkgdGhlIGVuZCB1c2VyIGluIHRoZSBtYW5uZXIgcHJlc2NyaWJlZCBpbiBzdWNoIEluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudC4gVXBvbiBzdWNoCisgICAgICAgaW5kaWNhdGlvbiBvZiBhZ3JlZW1lbnQgYnkgdGhlIHVzZXIsIHRoZSBwcm92aXNpb25pbmcgVGVjaG5vbG9neSB3aWxsIGNvbXBsZXRlIGluc3RhbGxhdGlvbiBvZiB0aGUgSW5zdGFsbGFibGUgU29mdHdhcmUuPC9saT4KKzwvb2w+CisKKzxoMz5DcnlwdG9ncmFwaHk8L2gzPgorCis8cD5Db250ZW50IG1heSBjb250YWluIGVuY3J5cHRpb24gc29mdHdhcmUuIFRoZSBjb3VudHJ5IGluIHdoaWNoIHlvdSBhcmUgY3VycmVudGx5IG1heSBoYXZlIHJlc3RyaWN0aW9ucyBvbiB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBhbmQgdXNlLCBhbmQvb3IgcmUtZXhwb3J0IHRvCisgICBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRSB1c2luZyBhbnkgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cywgcmVndWxhdGlvbnMgYW5kIHBvbGljaWVzIGNvbmNlcm5pbmcgdGhlIGltcG9ydCwKKyAgIHBvc3Nlc3Npb24sIG9yIHVzZSwgYW5kIHJlLWV4cG9ydCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLCB0byBzZWUgaWYgdGhpcyBpcyBwZXJtaXR0ZWQuPC9wPgorCis8cD48c21hbGw+SmF2YSBhbmQgYWxsIEphdmEtYmFzZWQgdHJhZGVtYXJrcyBhcmUgdHJhZGVtYXJrcyBvZiBPcmFjbGUgQ29ycG9yYXRpb24gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC48L3NtYWxsPjwvcD4KKzwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL3BsdWdpbi54bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL3BsdWdpbi54bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYTU4NzFjZQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvcGx1Z2luLnhtbApAQCAtMCwwICsxLDg3IEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPHBsdWdpbj4KKwkgIDxleHRlbnNpb24KKyAgICAgICAgIHBvaW50PSJvcmcuZWNsaXBzZS51aS5wb3B1cE1lbnVzIj4KKyAgICAgIDxvYmplY3RDb250cmlidXRpb24KKyAgICAgICAgICAgIGFkYXB0YWJsZT0idHJ1ZSIKKyAgICAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLm5hdHVyZS5hZGROYXR1cmUiCisgICAgICAgICAgICBvYmplY3RDbGFzcz0ib3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVByb2plY3QiPgorICAgICAgICAgPGFjdGlvbgorICAgICAgICAgICAgICAgY2xhc3M9Im9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkubmF0dXJlLlRvZ2dsZU9TQlBOYXR1cmVBY3Rpb24iCisgICAgICAgICAgICAgICBpY29uPSJpY29ucy9uYXR1cmVfb3ZlcmxheS5wbmciCisgICAgICAgICAgICAgICBpZD0ib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5uYXR1cmUuQWRkT1NCUE5hdHVyZUFjdGlvbiIKKyAgICAgICAgICAgICAgIGxhYmVsPSJDb252ZXJ0IHRvIE9TQlAgcHJvamVjdCIKKyAgICAgICAgICAgICAgIG1lbnViYXJQYXRoPSJvcmcuZWNsaXBzZS51aS5wcm9qZWN0Q29uZmlndXJlL2FkZGl0aW9ucyI+CisgICAgICAgICA8L2FjdGlvbj4KKyAgICAgICAgIDx2aXNpYmlsaXR5PgorICAgICAgICAgCTxub3Q+CisJICAgICAgICAgICAgPG9iamVjdFN0YXRlCisgICAgCSAgICAgICAgICAgICAgbmFtZT0ibmF0dXJlIgorICAgICAgICAJICAgICAgICAgIHZhbHVlPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnNoYXJlZC5PU0JQTmF0dXJlIj4KKyAgICAgICAgICAgIAk8L29iamVjdFN0YXRlPgorICAgICAgICAgICAgPC9ub3Q+CisgICAgICAgICA8L3Zpc2liaWxpdHk+CisgICAgICA8L29iamVjdENvbnRyaWJ1dGlvbj4KKyAgICAgIDxvYmplY3RDb250cmlidXRpb24KKyAgICAgICAgICAgIGFkYXB0YWJsZT0idHJ1ZSIKKyAgICAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLm5hdHVyZS5yZW1vdmVOYXR1cmUiCisgICAgICAgICAgICBvYmplY3RDbGFzcz0ib3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVByb2plY3QiPgorICAgICAgICAgPGFjdGlvbgorICAgICAgICAgICAgICAgY2xhc3M9Im9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkubmF0dXJlLlRvZ2dsZU9TQlBOYXR1cmVBY3Rpb24iCisgICAgICAgICAgICAgICBpY29uPSJpY29ucy9uYXR1cmVfb3ZlcmxheS5wbmciCisgICAgICAgICAgICAgICBpZD0ib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5uYXR1cmUuUmVtb3ZlT1NCUE5hdHVyZUFjdGlvbiIKKyAgICAgICAgICAgICAgIGxhYmVsPSJSZW1vdmUgT1NCUCBOYXR1cmUiCisgICAgICAgICAgICAgICBtZW51YmFyUGF0aD0ib3JnLmVjbGlwc2UudWkucHJvamVjdENvbmZpZ3VyZS9hZGRpdGlvbnMiPgorICAgICAgICAgPC9hY3Rpb24+CisgICAgICAgICA8dmlzaWJpbGl0eT4KKyAgICAgICAgICAgICAgIDxvYmplY3RTdGF0ZQorICAgIAkgICAgICAgICAgICAgIG5hbWU9Im5hdHVyZSIKKyAgICAgICAgCSAgICAgICAgICB2YWx1ZT0ib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQuT1NCUE5hdHVyZSI+CisgICAgICAgICAgICAJPC9vYmplY3RTdGF0ZT4KKyAgICAgICAgIDwvdmlzaWJpbGl0eT4KKyAgICAgIDwvb2JqZWN0Q29udHJpYnV0aW9uPgorICAgPC9leHRlbnNpb24+CisgICA8ZXh0ZW5zaW9uCisgICAgICAgICBwb2ludD0ib3JnLmVjbGlwc2UudWkuZGVjb3JhdG9ycyI+CisgICAgICA8ZGVjb3JhdG9yCisgICAgICAgICAgICBhZGFwdGFibGU9InRydWUiCisgICAgICAgICAgICBpY29uPSJpY29ucy9uYXR1cmVfb3ZlcmxheS5wbmciCisgICAgICAgICAgICBpZD0ib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5uYXR1cmUub3ZlcmxheSIKKyAgICAgICAgICAgIGxhYmVsPSJPU0JQIE5hdHVyZSIKKyAgICAgICAgICAgIGxpZ2h0d2VpZ2h0PSJ0cnVlIgorICAgICAgICAgICAgbG9jYXRpb249IlRPUF9MRUZUIgorICAgICAgICAgICAgc3RhdGU9InRydWUiPgorICAgICAgICAgPGVuYWJsZW1lbnQ+CisgICAgICAgICAJPGFuZD4KKwkJICAgICAJPG9iamVjdENsYXNzCisJCSAgICAgICAgICAgICAgbmFtZT0ib3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVByb2plY3QiLz4KKwkJICAgICAgICA8b2JqZWN0U3RhdGUKKwkJICAgICAgICAgICAgICBuYW1lPSJuYXR1cmUiCisJCSAgICAgICAgICAgICAgdmFsdWU9Im9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkLk9TQlBOYXR1cmUiPgorCQkgICAgICAgIDwvb2JqZWN0U3RhdGU+CisgICAgICAgICAgICA8L2FuZD4KKyAgICAgICAgIDwvZW5hYmxlbWVudD4KKyAgICAgIDwvZGVjb3JhdG9yPgorICAgPC9leHRlbnNpb24+CisgICA8ZXh0ZW5zaW9uCisgICAgICAgICBwb2ludD0ib3JnLmVjbGlwc2UudWkucGVyc3BlY3RpdmVzIj4KKyAgICAgIDxwZXJzcGVjdGl2ZQorICAgICAgICAgICAgbmFtZT0iT1NCUCIKKyAgICAgICAgICAgIGljb249Ii9pY29ucy9vc2JwUGVyc3BlY3RpdmUucG5nIgorICAgICAgICAgICAgY2xhc3M9Im9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkucGVyc3BlY3RpdmUuT1NCUFBlcnNwZWN0aXZlRmFjdG9yeSIKKyAgICAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLk9TQlBQZXJzcGVjdGl2ZSI+CisgICAgICAgICA8ZGVzY3JpcHRpb24+CisgICAgICAgICAgICBQcm92aWRlcyB2aWV3cyBmb3IgT1NCUCBwcm9qZWN0CisgICAgICAgICA8L2Rlc2NyaXB0aW9uPgorICAgICAgPC9wZXJzcGVjdGl2ZT4gCisgICAgPC9leHRlbnNpb24+CisgICAgICAgPGV4dGVuc2lvbgorICAgICAgICAgcG9pbnQ9Im9yZy5lY2xpcHNlLnVpLnZpZXdzIj4KKyAgICAgIDxjYXRlZ29yeQorICAgICAgICAgICAgaWQ9Im9yZy5lY2xpcHNlLm9zYnAuZWNsaXBzZS51aS52aWV3cy5jYXRlZ29yeS5SZXNvdXJjZXMiCisgICAgICAgICAgICBuYW1lPSJPU0JQIFZpZXdzIj4KKyAgICAgIDwvY2F0ZWdvcnk+CisgICA8L2V4dGVuc2lvbj4KKyAgIAorCis8L3BsdWdpbj4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvcG9tLnhtbCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvcG9tLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44ODA5NWY1Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9wb20ueG1sCkBAIC0wLDAgKzEsNTkgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorPCEtLSMgQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpIC0tPgorPCEtLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAtLT4KKzwhLS0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAtLT4KKzwhLS0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IC0tPgorPCEtLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgLS0+Cis8IS0tIyAtLT4KKzwhLS0jIENvbnRyaWJ1dG9yczogLS0+Cis8IS0tIyAgICAgS2xlbWVucyBFZGxlciAoTHVuaWZlcmEgR21iSCkgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24gLS0+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorCis8cHJvamVjdCB4bWxucz0iaHR0cDovL21hdmVuLmFwYWNoZS5vcmcvUE9NLzQuMC4wIiB4bWxuczp4c2k9Imh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hLWluc3RhbmNlIiB4c2k6c2NoZW1hTG9jYXRpb249Imh0dHA6Ly9tYXZlbi5hcGFjaGUub3JnL1BPTS80LjAuMCBodHRwOi8vbWF2ZW4uYXBhY2hlLm9yZy94c2QvbWF2ZW4tNC4wLjAueHNkIj4KKyAgICA8bW9kZWxWZXJzaW9uPjQuMC4wPC9tb2RlbFZlcnNpb24+CisgICAgPHBhcmVudD4KKyAgICAgICAgPGdyb3VwSWQ+b3JnLmVjbGlwc2Uub3NicC5pZGU8L2dyb3VwSWQ+CisgICAgICAgIDxhcnRpZmFjdElkPm9yZy5lY2xpcHNlLm9zYnAuaWRlPC9hcnRpZmFjdElkPgorICAgICAgICA8dmVyc2lvbj4wLjkuMC1TTkFQU0hPVDwvdmVyc2lvbj4KKyAgICA8L3BhcmVudD4KKyAgICA8YXJ0aWZhY3RJZD5vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpPC9hcnRpZmFjdElkPgorICAgIDxwYWNrYWdpbmc+ZWNsaXBzZS1wbHVnaW48L3BhY2thZ2luZz4KKworICAgIDxidWlsZD4KKyAgICAgICAgPHBsdWdpbnM+CisgICAgICAgICAgICA8cGx1Z2luPgorICAgICAgICAgICAgICAgIDxhcnRpZmFjdElkPm1hdmVuLWNvbXBpbGVyLXBsdWdpbjwvYXJ0aWZhY3RJZD4KKyAgICAgICAgICAgICAgICA8dmVyc2lvbj4zLjE8L3ZlcnNpb24+CisgICAgICAgICAgICAgICAgPGNvbmZpZ3VyYXRpb24+CisgICAgICAgICAgICAgICAgICAgIDxzb3VyY2U+MS44PC9zb3VyY2U+CisgICAgICAgICAgICAgICAgICAgIDx0YXJnZXQ+MS44PC90YXJnZXQ+CisgICAgICAgICAgICAgICAgPC9jb25maWd1cmF0aW9uPgorICAgICAgICAgICAgPC9wbHVnaW4+CisgICAgICAgICAgICA8cGx1Z2luPgorICAgICAgICAgICAgICAgIDxncm91cElkPm9yZy5lY2xpcHNlLnR5Y2hvPC9ncm91cElkPgorICAgICAgICAgICAgICAgIDxhcnRpZmFjdElkPnR5Y2hvLWNvbXBpbGVyLXBsdWdpbjwvYXJ0aWZhY3RJZD4KKyAgICAgICAgICAgICAgICA8dmVyc2lvbj4wLjIxLjA8L3ZlcnNpb24+CisgICAgICAgICAgICAgICAgPGNvbmZpZ3VyYXRpb24+CisgICAgICAgICAgICAgICAgICAgIDxjb21waWxlclZlcnNpb24+MS44PC9jb21waWxlclZlcnNpb24+CisgICAgICAgICAgICAgICAgICAgIDxlbmNvZGluZz5VVEYtODwvZW5jb2Rpbmc+CisgICAgICAgICAgICAgICAgICAgIDxzb3VyY2U+MS44PC9zb3VyY2U+CisgICAgICAgICAgICAgICAgICAgIDx0YXJnZXQ+MS44PC90YXJnZXQ+CisgICAgICAgICAgICAgICAgPC9jb25maWd1cmF0aW9uPgorICAgICAgICAgICAgPC9wbHVnaW4+CisgICAgICAgICAgICA8cGx1Z2luPgorICAgICAgICAgICAgICAgIDxncm91cElkPm9yZy5hcGFjaGUubWF2ZW4ucGx1Z2luczwvZ3JvdXBJZD4KKyAgICAgICAgICAgICAgICA8YXJ0aWZhY3RJZD5tYXZlbi1mYWlsc2FmZS1wbHVnaW48L2FydGlmYWN0SWQ+CisgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbnM+CisgICAgICAgICAgICAgICAgICAgIDxleGVjdXRpb24+CisgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbHM+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGdvYWw+aW50ZWdyYXRpb24tdGVzdDwvZ29hbD4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbD52ZXJpZnk8L2dvYWw+CisgICAgICAgICAgICAgICAgICAgICAgICA8L2dvYWxzPgorICAgICAgICAgICAgICAgICAgICA8L2V4ZWN1dGlvbj4KKyAgICAgICAgICAgICAgICA8L2V4ZWN1dGlvbnM+CisgICAgICAgICAgICA8L3BsdWdpbj4KKyAgICAgICAgPC9wbHVnaW5zPgorICAgIDwvYnVpbGQ+CisKKzwvcHJvamVjdD4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc2F2ZW9sZC9SdW5WYWFjbGlwc2VBY3Rpb24uamF2YSBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc2F2ZW9sZC9SdW5WYWFjbGlwc2VBY3Rpb24uamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi41NzU5OGI0Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9zYXZlb2xkL1J1blZhYWNsaXBzZUFjdGlvbi5qYXZhCkBAIC0wLDAgKzEsNzYgQEAKKy8qKgorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE1IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiwgQXVzdHJpYSksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorICoKKyAqIENvbnRyaWJ1dG9yczoKKyAqICAgICAgICAgRmxvcmlhbiBQaXJjaG5lciAtIEluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLm5hdHVyZTsKKworaW1wb3J0IGphdmEuaW8uSU9FeGNlcHRpb247CitpbXBvcnQgamF2YS5uZXQuTWFsZm9ybWVkVVJMRXhjZXB0aW9uOworCitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkZpbGVMb2NhdG9yOworaW1wb3J0IG9yZy5lY2xpcHNlLmVxdWlub3gucmVnaW9uLlJlZ2lvbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5lcXVpbm94LnJlZ2lvbi5SZWdpb25EaWdyYXBoOworaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLmFjdGlvbi5JQWN0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuSVNlbGVjdGlvbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS51aS5JT2JqZWN0QWN0aW9uRGVsZWdhdGU7CitpbXBvcnQgb3JnLmVjbGlwc2UudWkuSVdvcmtiZW5jaFBhcnQ7CitpbXBvcnQgb3JnLm9zZ2kuZnJhbWV3b3JrLkJ1bmRsZTsKK2ltcG9ydCBvcmcub3NnaS5mcmFtZXdvcmsuQnVuZGxlQ29udGV4dDsKK2ltcG9ydCBvcmcub3NnaS5mcmFtZXdvcmsuQnVuZGxlRXhjZXB0aW9uOworaW1wb3J0IG9yZy5vc2dpLmZyYW1ld29yay5GcmFtZXdvcmtVdGlsOworaW1wb3J0IG9yZy5vc2dpLmZyYW1ld29yay5TZXJ2aWNlUmVmZXJlbmNlOworaW1wb3J0IG9yZy5zbGY0ai5Mb2dnZXJGYWN0b3J5OworCisvKioKKyAqIEBhdXRob3IgU3ZlbiBFZmZ0aW5nZSAtIEluaXRpYWwgY29udHJpYnV0aW9uIGFuZCBBUEkKKyAqLworcHVibGljIGNsYXNzIFJ1blZhYWNsaXBzZUFjdGlvbiBpbXBsZW1lbnRzIElPYmplY3RBY3Rpb25EZWxlZ2F0ZSB7CisKKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBvcmcuc2xmNGouTG9nZ2VyIGxvZyA9IExvZ2dlckZhY3RvcnkKKwkJCS5nZXRMb2dnZXIoUnVuVmFhY2xpcHNlQWN0aW9uLmNsYXNzKTsKKworCXByaXZhdGUgSVNlbGVjdGlvbiBzZWxlY3Rpb247CisKKwlwdWJsaWMgdm9pZCBydW4oSUFjdGlvbiBhY3Rpb24pIHsKKwkJdHJ5IHsKKwkJCUJ1bmRsZUNvbnRleHQgYmMgPSBGcmFtZXdvcmtVdGlsLmdldEJ1bmRsZShnZXRDbGFzcygpKQorCQkJCQkuZ2V0QnVuZGxlQ29udGV4dCgpOworCQkJU2VydmljZVJlZmVyZW5jZTxSZWdpb25EaWdyYXBoPiByZWYgPSBiYworCQkJCQkuZ2V0U2VydmljZVJlZmVyZW5jZShSZWdpb25EaWdyYXBoLmNsYXNzKTsKKwkJCVJlZ2lvbkRpZ3JhcGggZGlncmFwaCA9IGJjLmdldFNlcnZpY2UocmVmKTsKKworCQkJUmVnaW9uIHZhYWNsaXBzZSA9IGRpZ3JhcGguZ2V0UmVnaW9uKCJ2YWFjbGlwc2UiKTsKKwkJCWlmICh2YWFjbGlwc2UgIT0gbnVsbCkgeworCQkJCWRpZ3JhcGgucmVtb3ZlUmVnaW9uKHZhYWNsaXBzZSk7CisJCQl9CisJCQl2YWFjbGlwc2UgPSBkaWdyYXBoLmNyZWF0ZVJlZ2lvbigidmFhY2xpcHNlIik7CisKKwkJCWZvciAoQnVuZGxlIGIgOiBiYy5nZXRCdW5kbGVzKCkpIHsKKwkJCQlCdW5kbGUgbmV3QiA9IHZhYWNsaXBzZS5pbnN0YWxsQnVuZGxlKEZpbGVMb2NhdG9yCisJCQkJCQkuZ2V0QnVuZGxlRmlsZShiKS50b1VSSSgpLnRvVVJMKCkudG9FeHRlcm5hbEZvcm0oKSk7CisJCQkJdmFhY2xpcHNlLmFkZEJ1bmRsZShuZXdCKTsKKwkJCX0KKwkJfSBjYXRjaCAoQnVuZGxlRXhjZXB0aW9uIGUpIHsKKwkJCWUucHJpbnRTdGFja1RyYWNlKCk7CisJCX0gY2F0Y2ggKE1hbGZvcm1lZFVSTEV4Y2VwdGlvbiBlKSB7CisJCQllLnByaW50U3RhY2tUcmFjZSgpOworCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBlKSB7CisJCQllLnByaW50U3RhY2tUcmFjZSgpOworCQl9CisKKwl9CisKKwlwdWJsaWMgdm9pZCBzZWxlY3Rpb25DaGFuZ2VkKElBY3Rpb24gYWN0aW9uLCBJU2VsZWN0aW9uIHNlbGVjdGlvbikgeworCQl0aGlzLnNlbGVjdGlvbiA9IHNlbGVjdGlvbjsKKwl9CisKKwlwdWJsaWMgdm9pZCBzZXRBY3RpdmVQYXJ0KElBY3Rpb24gYWN0aW9uLCBJV29ya2JlbmNoUGFydCB0YXJnZXRQYXJ0KSB7CisJfQorCit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS9jb3JlL3VpL0NvcmVVaUFjdGl2YXRvci5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9Db3JlVWlBY3RpdmF0b3IuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mNWY2NTk5Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9Db3JlVWlBY3RpdmF0b3IuamF2YQpAQCAtMCwwICsxLDE0MiBAQAorLyoqCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTUgLSBMdW5pZmVyYSBHbWJIIChHcm9zcyBFbnplcnNkb3JmLCBBdXN0cmlhKSwgTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisgKgorICogQ29udHJpYnV0b3JzOgorICogICAgICAgICBGbG9yaWFuIFBpcmNobmVyIC0gSW5pdGlhbCBpbXBsZW1lbnRhdGlvbgorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWk7CisKK2ltcG9ydCBqYXZhLnV0aWwuSGFzaHRhYmxlOworaW1wb3J0IGphdmEudXRpbC5NYXA7CisKK2ltcG9ydCBvcmcuZWNsaXBzZS51aS5wbHVnaW4uQWJzdHJhY3RVSVBsdWdpbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLnh0ZXh0LmJ1aWxkZXIudWkuYWNjZXNzLklYdGV4dFV0aWxTZXJ2aWNlOworaW1wb3J0IG9yZy5vc2dpLmZyYW1ld29yay5CdW5kbGVDb250ZXh0OworaW1wb3J0IG9yZy5vc2dpLmZyYW1ld29yay5TZXJ2aWNlUmVmZXJlbmNlOworaW1wb3J0IG9yZy5vc2dpLmZyYW1ld29yay5TZXJ2aWNlUmVnaXN0cmF0aW9uOworaW1wb3J0IG9yZy5vc2dpLnNlcnZpY2UuZXZlbnQuRXZlbnRBZG1pbjsKK2ltcG9ydCBvcmcub3NnaS5zZXJ2aWNlLmV2ZW50LkV2ZW50SGFuZGxlcjsKK2ltcG9ydCBvcmcub3NnaS51dGlsLnRyYWNrZXIuU2VydmljZVRyYWNrZXI7CitpbXBvcnQgb3JnLnNsZjRqLkxvZ2dlcjsKK2ltcG9ydCBvcmcuc2xmNGouTG9nZ2VyRmFjdG9yeTsKKworLy8gVE9ETzogQXV0by1nZW5lcmF0ZWQgSmF2YWRvYworLyoqCisgKiBUaGUgQ2xhc3MgQ29yZVVpQWN0aXZhdG9yLgorICovCitwdWJsaWMgY2xhc3MgQ29yZVVpQWN0aXZhdG9yIGV4dGVuZHMgQWJzdHJhY3RVSVBsdWdpbiB7CisKKwkvKiogVGhlIENvbnN0YW50IFBMVUdJTl9JRC4gKi8KKwlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBQTFVHSU5fSUQgPSAib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aSI7IC8vJE5PTi1OTFMtMSQKKwkKKwkvKiogVGhlIENvbnN0YW50IExPR0dFUi4gKi8KKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBMb2dnZXIgTE9HR0VSID0gTG9nZ2VyRmFjdG9yeQorCQkJLmdldExvZ2dlcihDb3JlVWlBY3RpdmF0b3IuY2xhc3MpOworCQorCS8qKiBUaGUgcGx1Z2luLiAqLworCXByaXZhdGUgc3RhdGljIENvcmVVaUFjdGl2YXRvciBwbHVnaW47CisKKwkvKioKKwkgKiBHZXRzIHRoZSBkZWZhdWx0LgorCSAqCisJICogQHJldHVybiB0aGUgZGVmYXVsdAorCSAqLworCXB1YmxpYyBzdGF0aWMgQ29yZVVpQWN0aXZhdG9yIGdldERlZmF1bHQoKSB7CisJCXJldHVybiBwbHVnaW47CisJfQorCisJLyoqIFRoZSBldmVudCBhZG1pbi4gKi8KKwlwcml2YXRlIEV2ZW50QWRtaW4gZXZlbnRBZG1pbjsKKwkKKwkvKiogVGhlIHV0aWwgc2VydmljZSB0cmFja2VyLiAqLworCXByaXZhdGUgU2VydmljZVRyYWNrZXI8SVh0ZXh0VXRpbFNlcnZpY2UsIElYdGV4dFV0aWxTZXJ2aWNlPiB1dGlsU2VydmljZVRyYWNrZXI7CisJCisJLyoqIFRoZSB1dGlsIHNlcnZpY2UuICovCisJcHJpdmF0ZSBJWHRleHRVdGlsU2VydmljZSB1dGlsU2VydmljZTsKKworCS8qIChub24tSmF2YWRvYykKKwkgKiBAc2VlIG9yZy5lY2xpcHNlLnVpLnBsdWdpbi5BYnN0cmFjdFVJUGx1Z2luI3N0YXJ0KG9yZy5vc2dpLmZyYW1ld29yay5CdW5kbGVDb250ZXh0KQorCSAqLworCUBPdmVycmlkZQorCXB1YmxpYyB2b2lkIHN0YXJ0KEJ1bmRsZUNvbnRleHQgY29udGV4dCkgdGhyb3dzIEV4Y2VwdGlvbiB7CisJCXRyeSB7CisJCQlzdXBlci5zdGFydChjb250ZXh0KTsKKwkJCXBsdWdpbiA9IHRoaXM7CisKKwkJCVNlcnZpY2VSZWZlcmVuY2U8RXZlbnRBZG1pbj4gcmVmID0gY29udGV4dAorCQkJCQkuZ2V0U2VydmljZVJlZmVyZW5jZShFdmVudEFkbWluLmNsYXNzKTsKKwkJCWV2ZW50QWRtaW4gPSBjb250ZXh0LmdldFNlcnZpY2UocmVmKTsKKworCQl9IGNhdGNoIChFeGNlcHRpb24gZSkgeworCQkJTE9HR0VSLmVycm9yKAorCQkJCQkiRXJyb3IgaW5pdGlhbGl6aW5nICIgKyBQTFVHSU5fSUQgKyAiOiIgKyBlLmdldE1lc3NhZ2UoKSwgZSk7CisJCX0KKwl9CisKKwkvKiAobm9uLUphdmFkb2MpCisJICogQHNlZSBvcmcuZWNsaXBzZS51aS5wbHVnaW4uQWJzdHJhY3RVSVBsdWdpbiNzdG9wKG9yZy5vc2dpLmZyYW1ld29yay5CdW5kbGVDb250ZXh0KQorCSAqLworCUBPdmVycmlkZQorCXB1YmxpYyB2b2lkIHN0b3AoQnVuZGxlQ29udGV4dCBjb250ZXh0KSB0aHJvd3MgRXhjZXB0aW9uIHsKKwkJaWYgKHV0aWxTZXJ2aWNlVHJhY2tlciAhPSBudWxsKSB7CisJCQl1dGlsU2VydmljZVRyYWNrZXIuY2xvc2UoKTsKKwkJCXV0aWxTZXJ2aWNlID0gbnVsbDsKKwkJfQorCQlwbHVnaW4gPSBudWxsOworCQlzdXBlci5zdG9wKGNvbnRleHQpOworCX0KKworCS8qKgorCSAqIFJldHVybnMgdGhlIGV2ZW50IGFkbWluLgorCSAqCisJICogQHJldHVybiB0aGUgZXZlbnQgYWRtaW4KKwkgKi8KKwlwdWJsaWMgRXZlbnRBZG1pbiBnZXRFdmVudEFkbWluKCkgeworCQlyZXR1cm4gZXZlbnRBZG1pbjsKKwl9CisKKwkvKioKKwkgKiBSZWdpc3RlcnMgYSBldmVudGhhbmRsZXIgYXQgdGhlIGV2ZW50IGFkbWluLgorCSAqCisJICogQHBhcmFtIGhhbmRsZXIKKwkgKiAgICAgICAgICAgIHRoZSBoYW5kbGVyCisJICogQHBhcmFtIHByb3BzCisJICogICAgICAgICAgICB0aGUgcHJvcHMKKwkgKiBAcmV0dXJuIHRoZSBzZXJ2aWNlIHJlZ2lzdHJhdGlvbgorCSAqLworCXB1YmxpYyBTZXJ2aWNlUmVnaXN0cmF0aW9uPEV2ZW50SGFuZGxlcj4gcmVnaXN0ZXJFdmVudEhhbmRsZXIoCisJCQlFdmVudEhhbmRsZXIgaGFuZGxlciwgTWFwPFN0cmluZywgU3RyaW5nPiBwcm9wcykgeworCQlIYXNodGFibGU8U3RyaW5nLCBTdHJpbmc+IGNhc3RlZFByb3BzID0gbmV3IEhhc2h0YWJsZTxTdHJpbmcsIFN0cmluZz4oCisJCQkJcHJvcHMpOworCQlyZXR1cm4gZ2V0QnVuZGxlKCkuZ2V0QnVuZGxlQ29udGV4dCgpLnJlZ2lzdGVyU2VydmljZSgKKwkJCQlFdmVudEhhbmRsZXIuY2xhc3MsIGhhbmRsZXIsIGNhc3RlZFByb3BzKTsKKwl9CisKKwkvKioKKwkgKiBQcm92aWRlcyB0aGUgdXRpbFNlcnZpY2UuCisJICoKKwkgKiBAcmV0dXJuIHRoZSB1dGlsIHNlcnZpY2UKKwkgKi8KKwlwdWJsaWMgSVh0ZXh0VXRpbFNlcnZpY2UgZ2V0VXRpbFNlcnZpY2UoKSB7CisJCWlmICh1dGlsU2VydmljZSA9PSBudWxsKSB7CisJCQl1dGlsU2VydmljZVRyYWNrZXIgPSBuZXcgU2VydmljZVRyYWNrZXI8SVh0ZXh0VXRpbFNlcnZpY2UsIElYdGV4dFV0aWxTZXJ2aWNlPigKKwkJCQkJZ2V0QnVuZGxlKCkuZ2V0QnVuZGxlQ29udGV4dCgpLCBJWHRleHRVdGlsU2VydmljZS5jbGFzcywKKwkJCQkJbnVsbCk7CisJCQl1dGlsU2VydmljZVRyYWNrZXIub3BlbigpOworCQkJdHJ5IHsKKwkJCQl1dGlsU2VydmljZSA9IHV0aWxTZXJ2aWNlVHJhY2tlci53YWl0Rm9yU2VydmljZSgxMDAwKTsKKwkJCX0gY2F0Y2ggKEludGVycnVwdGVkRXhjZXB0aW9uIGUpIHsKKwkJCX0KKwkJCWlmICh1dGlsU2VydmljZSA9PSBudWxsKSB7CisJCQkJTE9HR0VSLmVycm9yKCJJWHRleHRVdGlsU2VydmljZSBjb3VsZCBub3QgYmUgZm91bmQuIEJ1aWxkaW5nIERUT3MgYW5kIFNlcnZpY2VzIG5vdCBwb3NzaWJsZS4iKTsKKwkJCX0KKwkJfQorCisJCXJldHVybiB1dGlsU2VydmljZTsKKwl9CisKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvYnVpbGRlci9PU0JQSTE4bkJ1aWxkZXIuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvYnVpbGRlci9PU0JQSTE4bkJ1aWxkZXIuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jODBkZWEyCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9idWlsZGVyL09TQlBJMThuQnVpbGRlci5qYXZhCkBAIC0wLDAgKzEsMzI5IEBACisvKioKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNSAtIEx1bmlmZXJhIEdtYkggKEdyb3NzIEVuemVyc2RvcmYsIEF1c3RyaWEpLCBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscworICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKKyAqCisgKiBDb250cmlidXRvcnM6CisgKiAgICAgICAgIEZsb3JpYW4gUGlyY2huZXIgLSBJbml0aWFsIGltcGxlbWVudGF0aW9uCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5idWlsZGVyOworCitpbXBvcnQgamF2YS5pby5JT0V4Y2VwdGlvbjsKK2ltcG9ydCBqYXZhLnV0aWwuQ29sbGVjdGlvbnM7CitpbXBvcnQgamF2YS51dGlsLkxvY2FsZTsKK2ltcG9ydCBqYXZhLnV0aWwuTWFwOworaW1wb3J0IGphdmEudXRpbC5Qcm9wZXJ0aWVzOworCitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSUZpbGU7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSUZvbGRlcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JUHJvamVjdDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JUmVzb3VyY2U7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVJlc291cmNlRGVsdGE7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVJlc291cmNlRGVsdGFWaXNpdG9yOworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklSZXNvdXJjZVZpc2l0b3I7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSW5jcmVtZW50YWxQcm9qZWN0QnVpbGRlcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuQ29yZUV4Y2VwdGlvbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuSVByb2dyZXNzTW9uaXRvcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuT3BlcmF0aW9uQ2FuY2VsZWRFeGNlcHRpb247CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLlByb2dyZXNzTW9uaXRvcldyYXBwZXI7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLlN1Yk1vbml0b3I7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkuaTE4bi5Db3JlVXRpbDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS5pMThuLklJMThuUmVnaXN0cnk7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5Db3JlVWlBY3RpdmF0b3I7CitpbXBvcnQgb3JnLm9zZ2kuc2VydmljZS5ldmVudC5FdmVudDsKK2ltcG9ydCBvcmcuc2xmNGouTG9nZ2VyOworaW1wb3J0IG9yZy5zbGY0ai5Mb2dnZXJGYWN0b3J5OworCitpbXBvcnQgY29tLmdvb2dsZS5pbmplY3QuSW5qZWN0OworCitwdWJsaWMgY2xhc3MgT1NCUEkxOG5CdWlsZGVyIGV4dGVuZHMgSW5jcmVtZW50YWxQcm9qZWN0QnVpbGRlciB7CisKKwlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBCVUlMREVSX0lEID0gQ29yZVV0aWwuQlVJTERFUl9JMThOX0lEOworCisJcHJpdmF0ZSBzdGF0aWMgZmluYWwgTG9nZ2VyIExPR0dFUiA9IExvZ2dlckZhY3RvcnkKKwkJCS5nZXRMb2dnZXIoT1NCUEkxOG5CdWlsZGVyLmNsYXNzKTsKKworCUBJbmplY3QKKwlwcml2YXRlIElJMThuUmVnaXN0cnkgaTE4blJlZ2lzdHJ5OworCisJcHJpdmF0ZSBib29sZWFuIGZpcnN0QnVpbGQ7CisKKwlwdWJsaWMgT1NCUEkxOG5CdWlsZGVyKCkgeworCisJfQorCisJQE92ZXJyaWRlCisJcHJvdGVjdGVkIElQcm9qZWN0W10gYnVpbGQoaW50IGtpbmQsIE1hcDxTdHJpbmcsIFN0cmluZz4gYXJncywKKwkJCUlQcm9ncmVzc01vbml0b3IgbW9uaXRvcikgdGhyb3dzIENvcmVFeGNlcHRpb24geworCisJCWxvbmcgc3RhcnRUaW1lID0gU3lzdGVtLmN1cnJlbnRUaW1lTWlsbGlzKCk7CisJCXRyeSB7CisJCQlpZiAobW9uaXRvciAhPSBudWxsKSB7CisJCQkJZmluYWwgU3RyaW5nIHRhc2tOYW1lID0gIkJ1aWxkaW5nIiArIGdldFByb2plY3QoKS5nZXROYW1lKCkKKwkJCQkJCSsgIjogIjsgLy8kTk9OLU5MUy0xJAorCQkJCW1vbml0b3IgPSBuZXcgUHJvZ3Jlc3NNb25pdG9yV3JhcHBlcihtb25pdG9yKSB7CisJCQkJCUBPdmVycmlkZQorCQkJCQlwdWJsaWMgdm9pZCBzdWJUYXNrKFN0cmluZyBuYW1lKSB7CisJCQkJCQlzdXBlci5zdWJUYXNrKHRhc2tOYW1lICsgbmFtZSk7CisJCQkJCX0KKwkJCQl9OworCQkJfQorCQkJU3ViTW9uaXRvciBwcm9ncmVzcyA9IFN1Yk1vbml0b3IuY29udmVydChtb25pdG9yLCA4KTsKKwkJCWlmIChraW5kID09IEZVTExfQlVJTEQgfHwgZmlyc3RCdWlsZCkgeworCQkJCWZpcnN0QnVpbGQgPSBmYWxzZTsKKwkJCQlmdWxsQnVpbGRJMThuKGdldFByb2plY3QoKSk7CisJCQl9IGVsc2UgeworCQkJCUlSZXNvdXJjZURlbHRhIGRlbHRhID0gZ2V0RGVsdGEoZ2V0UHJvamVjdCgpKTsKKwkJCQlpZiAoZGVsdGEgPT0gbnVsbCB8fCBpc09wZW5lZChkZWx0YSkpIHsKKwkJCQkJZnVsbEJ1aWxkSTE4bihnZXRQcm9qZWN0KCkpOworCQkJCX0gZWxzZSB7CisJCQkJCWluY3JlbWVudGFsQnVpbGQoZGVsdGEsIHByb2dyZXNzLm5ld0NoaWxkKDEpKTsKKwkJCQl9CisJCQl9CisJCQlpZiAobW9uaXRvciAhPSBudWxsKSB7CisJCQkJbW9uaXRvci53b3JrZWQoOCk7CisJCQl9CisJCX0gY2F0Y2ggKENvcmVFeGNlcHRpb24gZSkgeworCQkJTE9HR0VSLmVycm9yKGUuZ2V0TWVzc2FnZSgpLCBlKTsKKwkJCXRocm93IGU7CisJCX0gY2F0Y2ggKE9wZXJhdGlvbkNhbmNlbGVkRXhjZXB0aW9uIGUpIHsKKwkJCWZvcmdldExhc3RCdWlsdFN0YXRlKCk7CisJCQl0aHJvdyBlOworCQl9IGNhdGNoIChFeGNlcHRpb24gZSkgeworCQkJTE9HR0VSLmVycm9yKGUuZ2V0TWVzc2FnZSgpLCBlKTsKKwkJfSBmaW5hbGx5IHsKKwkJCWlmIChtb25pdG9yICE9IG51bGwpIHsKKwkJCQltb25pdG9yLmRvbmUoKTsKKwkJCX0KKwkJCUxPR0dFUi5pbmZvKCJCdWlsZCAiICsgZ2V0UHJvamVjdCgpLmdldE5hbWUoKSArICIgaW4gIgorCQkJCQkrIChTeXN0ZW0uY3VycmVudFRpbWVNaWxsaXMoKSAtIHN0YXJ0VGltZSkgKyAiIG1zIik7CisJCX0KKworCQlzZW5kQnVpbGRFdmVudCgpOworCisJCXJldHVybiBnZXRQcm9qZWN0KCkuZ2V0UmVmZXJlbmNlZFByb2plY3RzKCk7CisJfQorCisJLyoqCisJICogU2VuZHMgYW4gZXZlbnQgdGhhdCBhIGJ1aWxkIHdhcyBkb25lLgorCSAqLworCXByaXZhdGUgdm9pZCBzZW5kQnVpbGRFdmVudCgpIHsKKwkJRXZlbnQgZXZlbnQgPSBuZXcgRXZlbnQoQ29yZVV0aWwuRVZFTlRfVE9QSUNfX0JVSUxERVIsCisJCQkJQ29sbGVjdGlvbnMuPFN0cmluZywgU3RyaW5nPiBlbXB0eU1hcCgpKTsKKwkJQ29yZVVpQWN0aXZhdG9yLmdldERlZmF1bHQoKS5nZXRFdmVudEFkbWluKCkuc2VuZEV2ZW50KGV2ZW50KTsKKwl9CisKKwkvKioKKwkgKiBAcGFyYW0gbW9uaXRvcgorCSAqICAgICAgICAgICAgdGhlIHByb2dyZXNzIG1vbml0b3IgdG8gdXNlIGZvciByZXBvcnRpbmcgcHJvZ3Jlc3MgdG8gdGhlCisJICogICAgICAgICAgICB1c2VyLiBJdCBpcyB0aGUgY2FsbGVyJ3MgcmVzcG9uc2liaWxpdHkgdG8gY2FsbCBkb25lKCkgb24gdGhlCisJICogICAgICAgICAgICBnaXZlbiBtb25pdG9yLiBBY2NlcHRzIG51bGwsIGluZGljYXRpbmcgdGhhdCBubyBwcm9ncmVzcworCSAqICAgICAgICAgICAgc2hvdWxkIGJlIHJlcG9ydGVkIGFuZCB0aGF0IHRoZSBvcGVyYXRpb24gY2Fubm90IGJlIGNhbmNlbGxlZC4KKwkgKi8KKwlwcml2YXRlIHZvaWQgaW5jcmVtZW50YWxCdWlsZChJUmVzb3VyY2VEZWx0YSBkZWx0YSwKKwkJCWZpbmFsIElQcm9ncmVzc01vbml0b3IgbW9uaXRvcikgdGhyb3dzIENvcmVFeGNlcHRpb24geworCQlmaW5hbCBTdWJNb25pdG9yIHByb2dyZXNzID0gU3ViTW9uaXRvci5jb252ZXJ0KG1vbml0b3IsCisJCQkJIkNvbGxlY3Rpb24gaTE4biIsIDQpOworCQlwcm9ncmVzcy5zdWJUYXNrKCJDb2xsZWN0aW5nIGkxOG4iKTsKKwkJaWYgKHByb2dyZXNzLmlzQ2FuY2VsZWQoKSkKKwkJCXRocm93IG5ldyBPcGVyYXRpb25DYW5jZWxlZEV4Y2VwdGlvbigpOworCQlwcm9ncmVzcy53b3JrZWQoMik7CisKKwkJSVByb2plY3QgcHJvamVjdCA9IGdldFByb2plY3QoKTsKKwkJaWYgKCFwcm9qZWN0LmdldERlc2NyaXB0aW9uKCkuaGFzTmF0dXJlKENvcmVVdGlsLk5BVFVSRV9JRCkpIHsKKwkJCXJldHVybjsKKwkJfQorCisJCW1vbml0b3Iuc3ViVGFzaygiQnVpbGRpbmcgSTE4biIpOworCQlpbmNyZW1lbnRhbEJ1aWxkSTE4bihkZWx0YSwgcHJvZ3Jlc3MpOworCisJCWlmIChwcm9ncmVzcy5pc0NhbmNlbGVkKCkpCisJCQl0aHJvdyBuZXcgT3BlcmF0aW9uQ2FuY2VsZWRFeGNlcHRpb24oKTsKKwkJcHJvZ3Jlc3Mud29ya2VkKDQpOworCX0KKworCS8qKgorCSAqIEJ1aWxkcyBJMThuLgorCSAqIAorCSAqIEBwYXJhbSBkZWx0YQorCSAqIEBwYXJhbSBwcm9ncmVzcworCSAqIEB0aHJvd3MgQ29yZUV4Y2VwdGlvbgorCSAqLworCXByaXZhdGUgdm9pZCBpbmNyZW1lbnRhbEJ1aWxkSTE4bihJUmVzb3VyY2VEZWx0YSBkZWx0YSwKKwkJCWZpbmFsIFN1Yk1vbml0b3IgcHJvZ3Jlc3MpIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKKwkJZGVsdGEuYWNjZXB0KG5ldyBJUmVzb3VyY2VEZWx0YVZpc2l0b3IoKSB7CisJCQlAT3ZlcnJpZGUKKwkJCXB1YmxpYyBib29sZWFuIHZpc2l0KElSZXNvdXJjZURlbHRhIGRlbHRhKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7CisJCQkJaWYgKHByb2dyZXNzLmlzQ2FuY2VsZWQoKSkgeworCQkJCQl0aHJvdyBuZXcgT3BlcmF0aW9uQ2FuY2VsZWRFeGNlcHRpb24oKTsKKwkJCQl9CisJCQkJaWYgKGRlbHRhLmdldFJlc291cmNlKCkgaW5zdGFuY2VvZiBJUHJvamVjdCkgeworCQkJCQlyZXR1cm4gZGVsdGEuZ2V0UmVzb3VyY2UoKSA9PSBnZXRQcm9qZWN0KCk7CisJCQkJfSBlbHNlIGlmIChkZWx0YS5nZXRSZXNvdXJjZSgpIGluc3RhbmNlb2YgSUZpbGUpIHsKKwkJCQkJSUZpbGUgZmlsZSA9IChJRmlsZSkgZGVsdGEuZ2V0UmVzb3VyY2UoKTsKKwkJCQkJaWYgKGZpbGUuZ2V0RmlsZUV4dGVuc2lvbigpLmVxdWFscygicHJvcGVydGllcyIpKSB7CisJCQkJCQlTdHJpbmcgcGFyZW50Rm9sZGVyID0gZmlsZS5nZXRQYXJlbnQoKS5nZXROYW1lKCk7CisJCQkJCQlpZiAoIXBhcmVudEZvbGRlci5lcXVhbHMoImwxMG4iKQorCQkJCQkJCQkmJiAhcGFyZW50Rm9sZGVyLmVxdWFscygiaTE4biIpKSB7CisJCQkJCQkJcmV0dXJuIGZhbHNlOworCQkJCQkJfQorCQkJCQkJU3RyaW5nW10gdG9rZW5zID0gZmlsZS5nZXROYW1lKCkKKwkJCQkJCQkJLnJlcGxhY2UoIi5wcm9wZXJ0aWVzIiwgIiIpLnNwbGl0KCJfIik7CisJCQkJCQlTdHJpbmdCdWlsZGVyIGJ1aWxkZXIgPSBuZXcgU3RyaW5nQnVpbGRlcigpOworCQkJCQkJaWYgKHRva2Vucy5sZW5ndGggPj0gMikgeworCQkJCQkJCWZvciAoaW50IGkgPSAxOyBpIDwgdG9rZW5zLmxlbmd0aDsgaSsrKSB7CisJCQkJCQkJCWlmIChidWlsZGVyLmxlbmd0aCgpID4gMCkgeworCQkJCQkJCQkJYnVpbGRlci5hcHBlbmQoIi0iKTsKKwkJCQkJCQkJfQorCQkJCQkJCQlidWlsZGVyLmFwcGVuZCh0b2tlbnNbaV0pOworCQkJCQkJCX0KKwkJCQkJCX0KKwkJCQkJCUxvY2FsZSBsb2NhbGUgPSBMb2NhbGUuZm9yTGFuZ3VhZ2VUYWcoYnVpbGRlcgorCQkJCQkJCQkudG9TdHJpbmcoKSk7CisJCQkJCQlpZiAoZGVsdGEuZ2V0S2luZCgpID09IElSZXNvdXJjZURlbHRhLlJFTU9WRUQpIHsKKwkJCQkJCQkvLyByZW1vdmUgdGhlIHJlc291cmNlCisJCQkJCQkJaTE4blJlZ2lzdHJ5LnJlbW92ZVJlc291cmNlKGdldFByb2plY3QoKSwgbG9jYWxlLAorCQkJCQkJCQkJZmlsZS5nZXRQcm9qZWN0UmVsYXRpdmVQYXRoKCkpOworCQkJCQkJfSBlbHNlIGlmIChkZWx0YS5nZXRLaW5kKCkgPT0gSVJlc291cmNlRGVsdGEuQURERUQKKwkJCQkJCQkJfHwgZGVsdGEuZ2V0S2luZCgpID09IElSZXNvdXJjZURlbHRhLkNIQU5HRUQpIHsKKwkJCQkJCQlQcm9wZXJ0aWVzIHByb3BlcnRpZXMgPSBuZXcgUHJvcGVydGllcygpOworCQkJCQkJCXRyeSB7CisJCQkJCQkJCXByb3BlcnRpZXMubG9hZChmaWxlLmdldENvbnRlbnRzKCkpOworCQkJCQkJCQlJSTE4blJlZ2lzdHJ5LlJlc291cmNlRGVzY3JpcHRpb24gcmVzb3VyY2VEZXNjID0gbmV3IElJMThuUmVnaXN0cnkuUmVzb3VyY2VEZXNjcmlwdGlvbigKKwkJCQkJCQkJCQlnZXRQcm9qZWN0KCksIGxvY2FsZSwgZmlsZQorCQkJCQkJCQkJCQkJLmdldFByb2plY3RSZWxhdGl2ZVBhdGgoKSwKKwkJCQkJCQkJCQlwcm9wZXJ0aWVzKTsKKwkJCQkJCQkJLy8gY2FjaGUgdGhlIHJlc291cmNlIGRlc2NyaXB0aW9uCisJCQkJCQkJCWkxOG5SZWdpc3RyeS5jYWNoZShyZXNvdXJjZURlc2MpOworCQkJCQkJCX0gY2F0Y2ggKElPRXhjZXB0aW9uIGUpIHsKKwkJCQkJCQkJTE9HR0VSLmVycm9yKCJ7fSIsIGUpOworCQkJCQkJCX0KKwkJCQkJCQlyZXR1cm4gZmFsc2U7CisJCQkJCQl9CisJCQkJCX0KKwkJCQl9IGVsc2UgaWYgKGRlbHRhLmdldFJlc291cmNlKCkgaW5zdGFuY2VvZiBJRm9sZGVyKSB7CisJCQkJCVN0cmluZyBmb2xkZXJuYW1lID0gZGVsdGEuZ2V0UmVzb3VyY2UoKS5nZXROYW1lKCk7CisJCQkJCWlmIChmb2xkZXJuYW1lLmVxdWFscygiT1NHSS1JTkYiKSkgeworCQkJCQkJcmV0dXJuIHRydWU7CisJCQkJCX0gZWxzZSBpZiAoZm9sZGVybmFtZS5lcXVhbHMoImwxMG4iKSkgeworCQkJCQkJSUZvbGRlciBmb2xkZXIgPSAoSUZvbGRlcikgZGVsdGEuZ2V0UmVzb3VyY2UoKTsKKwkJCQkJCWlmIChmb2xkZXIuZ2V0UGFyZW50KCkuZ2V0TmFtZSgpLmVxdWFscygiT1NHSS1JTkYiKSkgeworCQkJCQkJCXJldHVybiB0cnVlOworCQkJCQkJfQorCQkJCQl9IGVsc2UgaWYgKGZvbGRlcm5hbWUuZXF1YWxzKCJpMThuIikpIHsKKwkJCQkJCXJldHVybiB0cnVlOworCQkJCQl9CisKKwkJCQl9CisJCQkJcmV0dXJuIGZhbHNlOworCQkJfQorCQl9KTsKKwl9CisKKwkvKioKKwkgKiBCdWlsZHMgSTE4biBzdHVmZi4KKwkgKiAKKwkgKiBAcGFyYW0gcHJvamVjdAorCSAqIEByZXR1cm4KKwkgKiBAdGhyb3dzIENvcmVFeGNlcHRpb24KKwkgKi8KKwlwcml2YXRlIHZvaWQgZnVsbEJ1aWxkSTE4bihJUHJvamVjdCBwcm9qZWN0KSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7CisJCWZpbmFsIElJMThuUmVnaXN0cnkuUHJvamVjdERlc2NyaXB0aW9uIHByb2plY3REZXNjcmlwdGlvbiA9IG5ldyBJSTE4blJlZ2lzdHJ5LlByb2plY3REZXNjcmlwdGlvbigKKwkJCQlnZXRQcm9qZWN0KCkpOworCQlwcm9qZWN0LmFjY2VwdChuZXcgSVJlc291cmNlVmlzaXRvcigpIHsKKwkJCUBPdmVycmlkZQorCQkJcHVibGljIGJvb2xlYW4gdmlzaXQoSVJlc291cmNlIHJlc291cmNlKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7CisJCQkJaWYgKHJlc291cmNlID09IGdldFByb2plY3QoKSkgeworCQkJCQlyZXR1cm4gdHJ1ZTsKKwkJCQl9IGVsc2UgaWYgKHJlc291cmNlIGluc3RhbmNlb2YgSUZpbGUpIHsKKwkJCQkJSUZpbGUgZmlsZSA9IChJRmlsZSkgcmVzb3VyY2U7CisJCQkJCWlmIChmaWxlLmdldEZpbGVFeHRlbnNpb24oKS5lcXVhbHMoInByb3BlcnRpZXMiKSkgeworCQkJCQkJU3RyaW5nIHBhcmVudEZvbGRlciA9IGZpbGUuZ2V0UGFyZW50KCkuZ2V0TmFtZSgpOworCQkJCQkJaWYgKCFwYXJlbnRGb2xkZXIuZXF1YWxzKCJsMTBuIikKKwkJCQkJCQkJJiYgIXBhcmVudEZvbGRlci5lcXVhbHMoImkxOG4iKSkgeworCQkJCQkJCXJldHVybiBmYWxzZTsKKwkJCQkJCX0KKwkJCQkJCVN0cmluZ1tdIHRva2VucyA9IGZpbGUuZ2V0TmFtZSgpCisJCQkJCQkJCS5yZXBsYWNlKCIucHJvcGVydGllcyIsICIiKS5zcGxpdCgiXyIpOworCQkJCQkJU3RyaW5nQnVpbGRlciBidWlsZGVyID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKKwkJCQkJCWlmICh0b2tlbnMubGVuZ3RoID49IDIpIHsKKwkJCQkJCQlmb3IgKGludCBpID0gMTsgaSA8IHRva2Vucy5sZW5ndGg7IGkrKykgeworCQkJCQkJCQlpZiAoYnVpbGRlci5sZW5ndGgoKSA+IDApIHsKKwkJCQkJCQkJCWJ1aWxkZXIuYXBwZW5kKCItIik7CisJCQkJCQkJCX0KKwkJCQkJCQkJYnVpbGRlci5hcHBlbmQodG9rZW5zW2ldKTsKKwkJCQkJCQl9CisJCQkJCQl9CisJCQkJCQlMb2NhbGUgbG9jYWxlID0gTG9jYWxlLmZvckxhbmd1YWdlVGFnKGJ1aWxkZXIKKwkJCQkJCQkJLnRvU3RyaW5nKCkpOworCQkJCQkJUHJvcGVydGllcyBwcm9wZXJ0aWVzID0gbmV3IFByb3BlcnRpZXMoKTsKKwkJCQkJCXRyeSB7CisJCQkJCQkJcHJvcGVydGllcy5sb2FkKGZpbGUuZ2V0Q29udGVudHMoKSk7CisJCQkJCQkJSUkxOG5SZWdpc3RyeS5SZXNvdXJjZURlc2NyaXB0aW9uIHJlc291cmNlRGVzYyA9IG5ldyBJSTE4blJlZ2lzdHJ5LlJlc291cmNlRGVzY3JpcHRpb24oCisJCQkJCQkJCQlnZXRQcm9qZWN0KCksIGxvY2FsZSwgZmlsZQorCQkJCQkJCQkJCQkuZ2V0UHJvamVjdFJlbGF0aXZlUGF0aCgpLAorCQkJCQkJCQkJcHJvcGVydGllcyk7CisJCQkJCQkJcHJvamVjdERlc2NyaXB0aW9uLnB1dFJlc291cmNlKHJlc291cmNlRGVzYyk7CisKKwkJCQkJCX0gY2F0Y2ggKElPRXhjZXB0aW9uIGUpIHsKKwkJCQkJCQlMT0dHRVIuZXJyb3IoInt9IiwgZSk7CisJCQkJCQl9CisJCQkJCQlyZXR1cm4gZmFsc2U7CisJCQkJCX0KKwkJCQl9IGVsc2UgaWYgKHJlc291cmNlIGluc3RhbmNlb2YgSUZvbGRlcikgeworCQkJCQlTdHJpbmcgZm9sZGVybmFtZSA9IHJlc291cmNlLmdldE5hbWUoKTsKKwkJCQkJaWYgKGZvbGRlcm5hbWUuZXF1YWxzKCJPU0dJLUlORiIpKSB7CisJCQkJCQlyZXR1cm4gdHJ1ZTsKKwkJCQkJfSBlbHNlIGlmIChmb2xkZXJuYW1lLmVxdWFscygibDEwbiIpKSB7CisJCQkJCQlJRm9sZGVyIGZvbGRlciA9IChJRm9sZGVyKSByZXNvdXJjZTsKKwkJCQkJCWlmIChmb2xkZXIuZ2V0UGFyZW50KCkuZ2V0TmFtZSgpLmVxdWFscygiT1NHSS1JTkYiKSkgeworCQkJCQkJCXJldHVybiB0cnVlOworCQkJCQkJfQorCQkJCQl9IGVsc2UgaWYgKGZvbGRlcm5hbWUuZXF1YWxzKCJpMThuIikpIHsKKwkJCQkJCXJldHVybiB0cnVlOworCQkJCQl9CisKKwkJCQl9CisJCQkJcmV0dXJuIGZhbHNlOworCQkJfQorCQl9KTsKKworCQlpMThuUmVnaXN0cnkuY2FjaGUocHJvamVjdERlc2NyaXB0aW9uKTsKKwl9CisKKwkvLyAvKioKKwkvLyAqIFRoaXMgbWV0aG9kIHRvdWNoZXMgVUkgbW9kZWxzIHRvIGVuc3VyZSB0aGF0IHRoZSBBdXRvd2lyZUhlbHBlciBpcworCS8vICogZXhlY3V0ZWQuCisJLy8gKgorCS8vICogQHBhcmFtIHRlbXBMRW50aXR5TW9kZWwKKwkvLyAqLworCS8vIHByaXZhdGUgdm9pZCBidWlsZFVpTW9kZWxzKExFbnRpdHlNb2RlbCB0ZW1wTEVudGl0eU1vZGVsKSB7CisJLy8gLy8gZmluZCByZWZlcmVuY2luZyBkdG8gbW9kZWwKKwkvLyBTZXQ8VVJJPiBlbnRpdHlVUklzID0gZmluZEVudGl0eVVSSXModGVtcExFbnRpdHlNb2RlbCk7CisJLy8gZmluYWwgTGlzdDxJUmVmZXJlbmNlRGVzY3JpcHRpb24+IHRhcmdldER0b1JlZmVyZW5jZXMgPQorCS8vIGZpbmRUYXJnZXRVaU1vZGVsUmVmZXJlbmNlcyhlbnRpdHlVUklzKTsKKwkvLyBpZiAodGFyZ2V0RHRvUmVmZXJlbmNlcy5pc0VtcHR5KCkpIHsKKwkvLyByZXR1cm47CisJLy8gfQorCS8vIH0KKworCXByaXZhdGUgYm9vbGVhbiBpc09wZW5lZChJUmVzb3VyY2VEZWx0YSBkZWx0YSkgeworCQlyZXR1cm4gZGVsdGEuZ2V0UmVzb3VyY2UoKSBpbnN0YW5jZW9mIElQcm9qZWN0CisJCQkJJiYgKGRlbHRhLmdldEZsYWdzKCkgJiBJUmVzb3VyY2VEZWx0YS5PUEVOKSAhPSAwCisJCQkJJiYgKChJUHJvamVjdCkgZGVsdGEuZ2V0UmVzb3VyY2UoKSkuaXNPcGVuKCk7CisJfQorCisJQE92ZXJyaWRlCisJcHJvdGVjdGVkIHZvaWQgY2xlYW4oSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7CisJCXRyeSB7CisJCQlpMThuUmVnaXN0cnkucmVtb3ZlUHJvamVjdChnZXRQcm9qZWN0KCkpOworCQl9IGZpbmFsbHkgeworCQkJaWYgKG1vbml0b3IgIT0gbnVsbCkgeworCQkJCW1vbml0b3IuZG9uZSgpOworCQkJfQorCQl9CisJfQorCit9ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9idWlsZGVyL09TQlBNb2RlbEVuaGFuY2luZ0J1aWxkZXIuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvYnVpbGRlci9PU0JQTW9kZWxFbmhhbmNpbmdCdWlsZGVyLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjViYTFhYwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvYnVpbGRlci9PU0JQTW9kZWxFbmhhbmNpbmdCdWlsZGVyLmphdmEKQEAgLTAsMCArMSwyMTIyIEBACisvKioKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNSAtIEx1bmlmZXJhIEdtYkggKEdyb3NzIEVuemVyc2RvcmYsIEF1c3RyaWEpLCBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscworICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKKyAqCisgKiBDb250cmlidXRvcnM6CisgKiAgICAgICAgIEZsb3JpYW4gUGlyY2huZXIgLSBJbml0aWFsIGltcGxlbWVudGF0aW9uCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5idWlsZGVyOworCitpbXBvcnQgamF2YS5pby5JT0V4Y2VwdGlvbjsKK2ltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OworaW1wb3J0IGphdmEudXRpbC5Db2xsZWN0aW9uczsKK2ltcG9ydCBqYXZhLnV0aWwuQ29tcGFyYXRvcjsKK2ltcG9ydCBqYXZhLnV0aWwuSGFzaE1hcDsKK2ltcG9ydCBqYXZhLnV0aWwuSGFzaFNldDsKK2ltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7CitpbXBvcnQgamF2YS51dGlsLkxpc3Q7CitpbXBvcnQgamF2YS51dGlsLk1hcDsKK2ltcG9ydCBqYXZhLnV0aWwuT3B0aW9uYWw7CitpbXBvcnQgamF2YS51dGlsLlNldDsKKworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklGaWxlOworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklGb2xkZXI7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVByb2plY3Q7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVJlc291cmNlOworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklSZXNvdXJjZVZpc2l0b3I7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVN0b3JhZ2U7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSW5jcmVtZW50YWxQcm9qZWN0QnVpbGRlcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5SZXNvdXJjZXNQbHVnaW47CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkNvcmVFeGNlcHRpb247CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklQcm9ncmVzc01vbml0b3I7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklTdGF0dXM7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLk9wZXJhdGlvbkNhbmNlbGVkRXhjZXB0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5QYXRoOworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5TdGF0dXM7CitpbXBvcnQgb3JnLmVjbGlwc2UuZW1mLmNvbW1vbi5ub3RpZnkuQWRhcHRlcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5lbWYuY29tbW9uLm5vdGlmeS5pbXBsLkFkYXB0ZXJJbXBsOworaW1wb3J0IG9yZy5lY2xpcHNlLmVtZi5jb21tb24udXRpbC5EaWFnbm9zdGljOworaW1wb3J0IG9yZy5lY2xpcHNlLmVtZi5jb21tb24udXRpbC5VUkk7CitpbXBvcnQgb3JnLmVjbGlwc2UuZW1mLmNvbW1vbi51dGlsLldyYXBwZWRFeGNlcHRpb247CitpbXBvcnQgb3JnLmVjbGlwc2UuZW1mLmVjb3JlLkVPYmplY3Q7CitpbXBvcnQgb3JnLmVjbGlwc2UuZW1mLmVjb3JlLnJlc291cmNlLlJlc291cmNlOworaW1wb3J0IG9yZy5lY2xpcHNlLmVtZi5lY29yZS5yZXNvdXJjZS5SZXNvdXJjZVNldDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5lbWYuZWNvcmUudXRpbC5EaWFnbm9zdGljaWFuOworaW1wb3J0IG9yZy5lY2xpcHNlLmVtZi5lY29yZS51dGlsLkVjb3JlVXRpbDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS5kaWFsb2dzLkVycm9yRGlhbG9nOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZHNsLnNlbWFudGljLmNvbW1vbi50eXBlcy5MQXR0cmlidXRlOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZHNsLnNlbWFudGljLmNvbW1vbi50eXBlcy5MRW51bTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5zZW1hbnRpYy5jb21tb24udHlwZXMuTEVudW1MaXRlcmFsOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZHNsLnNlbWFudGljLmNvbW1vbi50eXBlcy5MSW1wb3J0OworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZHNsLnNlbWFudGljLmNvbW1vbi50eXBlcy5MUmVmZXJlbmNlOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZHNsLnNlbWFudGljLmNvbW1vbi50eXBlcy5MVHlwZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5zZW1hbnRpYy5jb21tb24udHlwZXMuTFR5cGVkUGFja2FnZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5zZW1hbnRpYy5jb21tb24udHlwZXMuT1NCUFR5cGVzRmFjdG9yeTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5zZW1hbnRpYy5kdG8uTEF1dG9Jbmhlcml0RHRvOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZHNsLnNlbWFudGljLmR0by5MRHRvOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZHNsLnNlbWFudGljLmR0by5MRHRvRmVhdHVyZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5zZW1hbnRpYy5kdG8uTER0b0luaGVyaXRlZEF0dHJpYnV0ZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5zZW1hbnRpYy5kdG8uTER0b0luaGVyaXRlZFJlZmVyZW5jZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5zZW1hbnRpYy5kdG8uTER0b01vZGVsOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZHNsLnNlbWFudGljLmR0by5PU0JQRHRvRmFjdG9yeTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5zZW1hbnRpYy5kdG8uT1NCUER0b1BhY2thZ2U7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5kc2wuc2VtYW50aWMuZHRvLnV0aWwuTmFtaW5nQ29udmVudGlvbnNVdGlsOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZHNsLnNlbWFudGljLmVudGl0eS5MQmVhbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5zZW1hbnRpYy5lbnRpdHkuTEJlYW5BdHRyaWJ1dGU7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5kc2wuc2VtYW50aWMuZW50aXR5LkxCZWFuRmVhdHVyZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5zZW1hbnRpYy5lbnRpdHkuTEJlYW5SZWZlcmVuY2U7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5kc2wuc2VtYW50aWMuZW50aXR5LkxFbnRpdHk7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5kc2wuc2VtYW50aWMuZW50aXR5LkxFbnRpdHlBdHRyaWJ1dGU7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5kc2wuc2VtYW50aWMuZW50aXR5LkxFbnRpdHlGZWF0dXJlOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZHNsLnNlbWFudGljLmVudGl0eS5MRW50aXR5TW9kZWw7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5kc2wuc2VtYW50aWMuZW50aXR5LkxFbnRpdHlSZWZlcmVuY2U7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5kc2wuc2VtYW50aWMuc2VydmljZS5MRFRPU2VydmljZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5zZW1hbnRpYy5zZXJ2aWNlLkxTZXJ2aWNlOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZHNsLnNlbWFudGljLnNlcnZpY2UuTFNlcnZpY2VNb2RlbDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5zZW1hbnRpYy5zZXJ2aWNlLk9TQlBTZXJ2aWNlRmFjdG9yeTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC5zZW1hbnRpYy5zZXJ2aWNlLk9TQlBTZXJ2aWNlUGFja2FnZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC54dGV4dC5sYXp5cmVzb2x2ZXIuYXBpLklTZW1hbnRpY0xvYWRpbmdSZXNvdXJjZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmRzbC54dGV4dC5sYXp5cmVzb2x2ZXIuYXBpLmxvZ2dlci5UaW1lTG9nZ2VyOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpLmkxOG4uQ29yZVV0aWw7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5Db3JlVWlBY3RpdmF0b3I7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5uYXR1cmUuT1NCUE5hdHVyZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLnh0ZXh0LmJ1aWxkZXIudWkuYWNjZXNzLklYdGV4dFV0aWxTZXJ2aWNlOworaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkRpc3BsYXk7CitpbXBvcnQgb3JnLmVjbGlwc2UueHRleHQuYnVpbGRlci5idWlsZGVyU3RhdGUuSUJ1aWxkZXJTdGF0ZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS54dGV4dC5jb21tb24udHlwZXMuVHlwZXNQYWNrYWdlOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnJlc291cmNlLklFT2JqZWN0RGVzY3JpcHRpb247CitpbXBvcnQgb3JnLmVjbGlwc2UueHRleHQucmVzb3VyY2UuSVJlZmVyZW5jZURlc2NyaXB0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnJlc291cmNlLklSZXNvdXJjZURlc2NyaXB0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnJlc291cmNlLklSZXNvdXJjZURlc2NyaXB0aW9uLkRlbHRhOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnJlc291cmNlLlNhdmVPcHRpb25zOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnJlc291cmNlLlh0ZXh0UmVzb3VyY2VTZXQ7CitpbXBvcnQgb3JnLmVjbGlwc2UueHRleHQudWkuZWRpdG9yLmZpbmRyZWZzLklSZWZlcmVuY2VGaW5kZXI7CitpbXBvcnQgb3JnLmVjbGlwc2UueHRleHQudWkucmVzb3VyY2UuSVN0b3JhZ2UyVXJpTWFwcGVyOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnVpLnJlc291cmNlLlh0ZXh0UmVzb3VyY2VTZXRQcm92aWRlcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS54dGV4dC51dGlsLklBY2NlcHRvcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS54dGV4dC51dGlsLlBhaXI7CitpbXBvcnQgb3JnLmVjbGlwc2UueHRleHQudXRpbC5jb25jdXJyZW50LklVbml0T2ZXb3JrOworaW1wb3J0IG9yZy5zbGY0ai5Mb2dnZXI7CitpbXBvcnQgb3JnLnNsZjRqLkxvZ2dlckZhY3Rvcnk7CisKK2ltcG9ydCBjb20uZ29vZ2xlLmluamVjdC5JbmplY3Q7CitpbXBvcnQgY29tLmdvb2dsZS5pbmplY3QuSW5qZWN0b3I7CisKKy8vIFRPRE86IEF1dG8tZ2VuZXJhdGVkIEphdmFkb2MKKy8qKgorICogVGhpcyBidWlsZGVyIGlzIGF3YXJlIGFib3V0IHRoZSBYdGV4dCBpbmRleC4gSWYgY2hhbmdlcyBvY2N1cnJlZCB0aGVyZSwgd2UKKyAqIHBlbmQgdGhlIHtAbGluayBJUmVzb3VyY2VEZXNjcmlwdGlvbn0gYW5kIGRvIGEgbW9kZWwtZW5oYW5jaW5nLWJ1aWxkIGxhdGVyLgorICogU2VlIHtAbGluayAjbmVlZFJlYnVpbGQoKX0uIEl0IHJlaW52b2tlZCB0aGUgYnVpbGQgY2hhaW4gbGF0ZXIuIFNvIHdlIGNhbgorICogZW5zdXJlLCB0aGF0IHRoZSBpbmRleCBmb3Igb3VyIGVuaGFuY2VkIG1vZGVscyBpcyBjcmVhdGVkIHRvby4KKyAqLworQFN1cHByZXNzV2FybmluZ3MoInJlc3RyaWN0aW9uIikKK3B1YmxpYyBjbGFzcyBPU0JQTW9kZWxFbmhhbmNpbmdCdWlsZGVyIGV4dGVuZHMgSW5jcmVtZW50YWxQcm9qZWN0QnVpbGRlcgorCQlpbXBsZW1lbnRzIElSZXNvdXJjZURlc2NyaXB0aW9uLkV2ZW50Lkxpc3RlbmVyIHsKKworCS8qKiBUaGUgQ29uc3RhbnQgQlVJTERFUl9JRC4gKi8KKwlwdWJsaWMgc3RhdGljIGZpbmFsIFN0cmluZyBCVUlMREVSX0lEID0gQ29yZVV0aWwuQlVJTERFUl9NT0RFTF9FTkhBTkNJTkdfSUQ7CisKKwlwdWJsaWMgZmluYWwgc3RhdGljIFN0cmluZyBNT0RFTFNfQkFTRV9TUkNfRElSRUNUT1JZID0gIm1vZGVscyI7CisJcHVibGljIGZpbmFsIHN0YXRpYyBTdHJpbmcgU09VUkNFX0JBU0VfU1JDX0RJUkVDVE9SWSA9ICJzcmMiOworCisJLyoqIFRoZSBDb25zdGFudCBMT0dHRVIuICovCisJcHJpdmF0ZSBzdGF0aWMgZmluYWwgTG9nZ2VyIExPR0dFUiA9IExvZ2dlckZhY3RvcnkKKwkJCS5nZXRMb2dnZXIoT1NCUE1vZGVsRW5oYW5jaW5nQnVpbGRlci5jbGFzcyk7CisKKwkvKiogVGhlIHN0YXRlLiAqLworCUBJbmplY3QKKwlwcml2YXRlIElCdWlsZGVyU3RhdGUgc3RhdGU7CisKKwkvKiogVGhlIGluamVjdG9yLiAqLworCUBJbmplY3QKKwlwcml2YXRlIEluamVjdG9yIGluamVjdG9yOworCisJLyoqIFRoZSB1cmkgc3RvcmFnZSBtYXBwZXIuICovCisJQEluamVjdAorCXByaXZhdGUgSVN0b3JhZ2UyVXJpTWFwcGVyIHVyaVN0b3JhZ2VNYXBwZXI7CisKKwkvKiogVGhlIGR0byBidWlsZGVyLiAqLworCXByaXZhdGUgRHRvRW5oYW5jZXIgZHRvQnVpbGRlcjsKKworCS8qKiBUaGUgc2VydmljZSBidWlsZGVyLiAqLworCXByaXZhdGUgU2VydmljZUVuaGFuY2VyIHNlcnZpY2VCdWlsZGVyOworCisJcHJpdmF0ZSBMaXN0PFBlbmRpbmc+IHBlbmRpbmcgPSBuZXcgQXJyYXlMaXN0PFBlbmRpbmc+KCk7CisJcHJpdmF0ZSBib29sZWFuIGZpcnN0QnVpbGQgPSB0cnVlOworCisJLyoqCisJICogSW5zdGFudGlhdGVzIGEgbmV3IE9TQlAgbW9kZWwgZW5oYW5jaW5nIGJ1aWxkZXIuCisJICovCisJcHVibGljIE9TQlBNb2RlbEVuaGFuY2luZ0J1aWxkZXIoKSB7CisKKwl9CisKKwkvKioKKwkgKiBMaXN0ZW5zIGZvciBjaGFuZ2VzIG9mIFh0ZXh0IGJ1aWxkZXIuIElmIGVudGl0eSBvciBkdG8gYXJlIGJlaW5nIGNoYW5nZWQsCisJICogdGhlbiB3ZSBzdG9yZSB0aGUgbW9kZWxzIGZvciBsYXRlci4KKwkgKgorCSAqIEBwYXJhbSBldmVudAorCSAqICAgICAgICAgICAgdGhlIGV2ZW50CisJICovCisJQE92ZXJyaWRlCisJcHVibGljIHZvaWQgZGVzY3JpcHRpb25zQ2hhbmdlZCgKKwkJCW9yZy5lY2xpcHNlLnh0ZXh0LnJlc291cmNlLklSZXNvdXJjZURlc2NyaXB0aW9uLkV2ZW50IGV2ZW50KSB7CisJCWZvciAoRGVsdGEgZGVsdGEgOiBldmVudC5nZXREZWx0YXMoKSkgeworCQkJLy8gZG8gbm90IGNoZWNrIGZvciBjaGFuZ2VzIGluIHRoZSBlb2JqZWN0IGRlc2NyaXB0aW9uLiBDYXVzZXMKKwkJCS8vIGNvbmZ1c2lvbiBmb3IgdGhlIHVzZXIKKwkJCWlmIChkZWx0YS5nZXROZXcoKSA9PSBudWxsKSB7CisJCQkJY29udGludWU7CisJCQl9CisKKwkJCWlmIChzaG91bGRVc2UoZGVsdGEuZ2V0VXJpKCkpKSB7CisKKwkJCQlTdHJpbmcgZmlsZUV4dGVuc2lvbiA9IGRlbHRhLmdldFVyaSgpLmZpbGVFeHRlbnNpb24oKTsKKwkJCQlzd2l0Y2ggKGZpbGVFeHRlbnNpb24pIHsKKwkJCQljYXNlICJlbnRpdHkiOgorCQkJCQlpZiAoIWNvbnRhaW5zKGRlbHRhLmdldFVyaSgpKSkgeworCQkJCQkJcGVuZGluZy5hZGQobmV3IFBlbmRpbmcoZGVsdGEuZ2V0TmV3KCkpKTsKKwkJCQkJfQorCQkJCQlicmVhazsKKwkJCQljYXNlICJkdG8iOgorCQkJCQlpZiAoIWNvbnRhaW5zKGRlbHRhLmdldFVyaSgpKSkgeworCQkJCQkJcGVuZGluZy5hZGQobmV3IFBlbmRpbmcoZGVsdGEuZ2V0TmV3KCkpKTsKKwkJCQkJfQorCQkJCQlicmVhazsKKwkJCQl9CisJCQl9CisJCX0KKwl9CisKKwkvKioKKwkgKiBDb250YWlucy4KKwkgKgorCSAqIEBwYXJhbSB1cmkKKwkgKiAgICAgICAgICAgIHRoZSB1cmkKKwkgKiBAcmV0dXJuIHRydWUsIGlmIHN1Y2Nlc3NmdWwKKwkgKi8KKwlwcml2YXRlIGJvb2xlYW4gY29udGFpbnMoVVJJIHVyaSkgeworCQlyZXR1cm4gcGVuZGluZy5zdHJlYW0oKS5maWx0ZXIoZSAtPiBlLnVyaS5lcXVhbHModXJpKSkuY291bnQoKSA+IDA7CisJfQorCisJLyoqCisJICogU2hvdWxkIHVzZS4KKwkgKgorCSAqIEBwYXJhbSB1cmkKKwkgKiAgICAgICAgICAgIHRoZSB1cmkKKwkgKiBAcmV0dXJuIHRydWUsIGlmIHN1Y2Nlc3NmdWwKKwkgKi8KKwlwcml2YXRlIGJvb2xlYW4gc2hvdWxkVXNlKFVSSSB1cmkpIHsKKwkJaWYgKHVyaSA9PSBudWxsKSB7CisJCQlyZXR1cm4gZmFsc2U7CisJCX0KKworCQlTdHJpbmcgcGxhdGZvcm1SZXNvdXJjZVBhdGggPSB1cmkudG9QbGF0Zm9ybVN0cmluZyh0cnVlKTsKKwkJaWYgKHBsYXRmb3JtUmVzb3VyY2VQYXRoID09IG51bGwpIHsKKwkJCXJldHVybiBmYWxzZTsKKwkJfQorCQlJRmlsZSBmaWxlID0gUmVzb3VyY2VzUGx1Z2luLmdldFdvcmtzcGFjZSgpLmdldFJvb3QoKQorCQkJCS5nZXRGaWxlKG5ldyBQYXRoKHBsYXRmb3JtUmVzb3VyY2VQYXRoKSk7CisJCWlmIChmaWxlID09IG51bGwgfHwgIWZpbGUuZXhpc3RzKCkpIHsKKwkJCS8vIGlmIHJlc291cmNlIGlzIG5vdCBpbiB3b3Jrc3BhY2UgY29udGludWUKKwkJCXJldHVybiBmYWxzZTsKKwkJfQorCisJCUl0ZXJhYmxlPFBhaXI8SVN0b3JhZ2UsIElQcm9qZWN0Pj4gcGFpcnMgPSB1cmlTdG9yYWdlTWFwcGVyCisJCQkJLmdldFN0b3JhZ2VzKHVyaSk7CisJCWlmIChwYWlycy5pdGVyYXRvcigpLmhhc05leHQoKSkgeworCQkJUGFpcjxJU3RvcmFnZSwgSVByb2plY3Q+IHBhaXIgPSBwYWlycy5pdGVyYXRvcigpLm5leHQoKTsKKwkJCUlQcm9qZWN0IGR0b1Byb2plY3QgPSBwYWlyLmdldFNlY29uZCgpOworCQkJaWYgKGR0b1Byb2plY3QgIT0gbnVsbCAmJiBwYWlyLmdldEZpcnN0KCkgaW5zdGFuY2VvZiBJRmlsZSkgeworCQkJCXJldHVybiB0cnVlOworCQkJfQorCQl9CisJCXJldHVybiBmYWxzZTsKKwl9CisKKwkvKgorCSAqIChub24tSmF2YWRvYykKKwkgKiAKKwkgKiBAc2VlIG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLkluY3JlbWVudGFsUHJvamVjdEJ1aWxkZXIjYnVpbGQoaW50LAorCSAqIGphdmEudXRpbC5NYXAsIG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5JUHJvZ3Jlc3NNb25pdG9yKQorCSAqLworCUBPdmVycmlkZQorCXByb3RlY3RlZCBJUHJvamVjdFtdIGJ1aWxkKGludCBraW5kLCBNYXA8U3RyaW5nLCBTdHJpbmc+IGFyZ3MsCisJCQlJUHJvZ3Jlc3NNb25pdG9yIG1vbml0b3IpIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKKwkJZW5zdXJlUGFydGljaXBhbnRzKCk7CisKKwkJaWYgKGtpbmQgPT0gRlVMTF9CVUlMRCB8fCBmaXJzdEJ1aWxkKSB7CisJCQlmaXJzdEJ1aWxkID0gZmFsc2U7CisJCQljb2xsZWN0SW5pdGlhbFBlbmRpbmcoKTsKKwkJfQorCisJCWlmICghcGVuZGluZy5pc0VtcHR5KCkpIHsKKwkJCUNvbGxlY3Rpb25zLnNvcnQocGVuZGluZywgbmV3IENvbXBhcmF0b3I8UGVuZGluZz4oKSB7CisJCQkJQE92ZXJyaWRlCisJCQkJcHVibGljIGludCBjb21wYXJlKFBlbmRpbmcgbzEsIFBlbmRpbmcgbzIpIHsKKwkJCQkJaWYgKG8xLnVyaS5maWxlRXh0ZW5zaW9uKCkuZXF1YWxzKCJlbnRpdHkiKSkgeworCQkJCQkJcmV0dXJuIC0xOworCQkJCQl9CisJCQkJCWlmIChvMS51cmkuZmlsZUV4dGVuc2lvbigpLmVxdWFscygiZHRvIikpIHsKKwkJCQkJCXJldHVybiAxOworCQkJCQl9CisJCQkJCXJldHVybiAwOworCQkJCX0KKwkJCX0pOworCisJCQlib29sZWFuIHByb2Nlc3NlZCA9IGZhbHNlOworCQkJZm9yIChJdGVyYXRvcjxQZW5kaW5nPiBpdGVyYXRvciA9IHBlbmRpbmcuaXRlcmF0b3IoKTsgaXRlcmF0b3IKKwkJCQkJLmhhc05leHQoKSAmJiAhcHJvY2Vzc2VkOykgeworCQkJCVBlbmRpbmcgcGVuZGluZyA9IGl0ZXJhdG9yLm5leHQoKTsKKwkJCQl0cnkgeworCisJCQkJCS8vIFVSSSB1cmkgPSBwZW5kaW5nLnVyaTsKKwkJCQkJLy8gaWYodXJpLmlzUGxhdGZvcm0oKSkgeworCQkJCQkvLyAvLyBTdHJpbmcgcHJvamVjdE5hbWUgPSBnZXRQcm9qZWN0KCkuZ2V0TmFtZSgpOworCQkJCQkvLyAvLyBpZih1cmkuZGV2aWNlKCkuZXF1YWxzKHByb2plY3ROYW1lKSkKKwkJCQkJLy8gUmVzb3VyY2VzUGx1Z2luLmdldFdvcmtzcGFjZSgpLmdldFJvb3QoKS5nZXQKKwkJCQkJLy8gfQorCisJCQkJCVN0cmluZyBmaWxlRXh0ZW5zaW9uID0gcGVuZGluZy51cmkuZmlsZUV4dGVuc2lvbigpOworCQkJCQlzd2l0Y2ggKGZpbGVFeHRlbnNpb24pIHsKKwkJCQkJY2FzZSAiZW50aXR5IjoKKwkJCQkJCUxFbnRpdHlNb2RlbCBsZW50aXR5ID0gZHRvQnVpbGRlcgorCQkJCQkJCQkubG9hZFNlbWFudGljTW9kZWwocGVuZGluZy51cmkpOworCQkJCQkJaWYgKGxlbnRpdHkgIT0gbnVsbCkgeworCQkJCQkJCWR0b0J1aWxkZXIuYnVpbGREdG9zKGxlbnRpdHkpOworCQkJCQkJCXByb2Nlc3NlZCA9IHRydWU7CisJCQkJCQkJbmVlZFJlYnVpbGQoKTsKKwkJCQkJCX0KKwkJCQkJCWJyZWFrOworCQkJCQljYXNlICJkdG8iOgorCQkJCQkJTER0b01vZGVsIGxEdG9Nb2RlbCA9IHNlcnZpY2VCdWlsZGVyCisJCQkJCQkJCS5sb2FkU2VtYW50aWNNb2RlbChwZW5kaW5nLnVyaSk7CisJCQkJCQlpZiAobER0b01vZGVsICE9IG51bGwpIHsKKwkJCQkJCQkvLyB0b3VjaCB0aGUgdWkgYW5kIGRpYWxvZyBtb2RlbHMKKwkJCQkJCQl0cnkgeworCQkJCQkJCQlzZXJ2aWNlQnVpbGRlcgorCQkJCQkJCQkJCS5idWlsZFVpQW5kRGlhbG9nTW9kZWxzKGxEdG9Nb2RlbCk7CisJCQkJCQkJfSBjYXRjaCAoRXhjZXB0aW9uIGUpIHsKKwkJCQkJCQkJTE9HR0VSLmVycm9yKCJ7fSIsIGUpOworCQkJCQkJCX0KKwkJCQkJCQl0cnkgeworCQkJCQkJCQlzZXJ2aWNlQnVpbGRlci5idWlsZFNlcnZpY2VzKGxEdG9Nb2RlbCk7CisJCQkJCQkJfSBjYXRjaCAoRXhjZXB0aW9uIGUpIHsKKwkJCQkJCQkJTE9HR0VSLmVycm9yKCJ7fSIsIGUpOworCQkJCQkJCX0KKwkJCQkJCQlwcm9jZXNzZWQgPSB0cnVlOworCQkJCQkJCW5lZWRSZWJ1aWxkKCk7CisJCQkJCQl9CisJCQkJCQlicmVhazsKKwkJCQkJfQorCQkJCX0gZmluYWxseSB7CisJCQkJCWl0ZXJhdG9yLnJlbW92ZSgpOworCQkJCX0KKwkJCX0KKwkJfQorCisJCXJldHVybiBnZXRQcm9qZWN0KCkuZ2V0UmVmZXJlbmNlZFByb2plY3RzKCk7CisJfQorCisJLyoqCisJICogQ29sbGVjdHMgYWxsIHJlc291cmNlcyB0aGF0IHNob3VsZCBiZSB1c2VkIGZvciBhbiBpbml0aWFsIGJ1aWxkLgorCSAqIAorCSAqIEB0aHJvd3MgQ29yZUV4Y2VwdGlvbgorCSAqLworCXByaXZhdGUgdm9pZCBjb2xsZWN0SW5pdGlhbFBlbmRpbmcoKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7CisJCUlQcm9qZWN0IHByb2plY3QgPSBnZXRQcm9qZWN0KCk7CisJCWlmICghcHJvamVjdC5nZXREZXNjcmlwdGlvbigpLmhhc05hdHVyZShPU0JQTmF0dXJlLk5BVFVSRV9JRCkpIHsKKwkJCXJldHVybjsKKwkJfQorCQlwcm9qZWN0LmFjY2VwdChuZXcgSVJlc291cmNlVmlzaXRvcigpIHsKKwkJCUBPdmVycmlkZQorCQkJLy8gTk9TT05BUiAtIGFub255bW91cyB0byBsYW1iZGEKKwkJCXB1YmxpYyBib29sZWFuIHZpc2l0KElSZXNvdXJjZSByZXNvdXJjZSkgdGhyb3dzIENvcmVFeGNlcHRpb24geworCQkJCWlmIChyZXNvdXJjZSA9PSBnZXRQcm9qZWN0KCkpIHsKKwkJCQkJcmV0dXJuIHRydWU7CisJCQkJfSBlbHNlIGlmIChyZXNvdXJjZSBpbnN0YW5jZW9mIElGb2xkZXIpIHsKKwkJCQkJcmV0dXJuIGNoZWNrRm9sZGVyKChJRm9sZGVyKSByZXNvdXJjZSk7CisJCQkJfSBlbHNlIGlmIChyZXNvdXJjZSBpbnN0YW5jZW9mIElGaWxlKSB7CisJCQkJCUlGaWxlIGZpbGUgPSAoSUZpbGUpIHJlc291cmNlOworCisJCQkJCW9yZy5lY2xpcHNlLmVtZi5jb21tb24udXRpbC5VUkkgdXJpID0gb3JnLmVjbGlwc2UuZW1mLmNvbW1vbi51dGlsLlVSSQorCQkJCQkJCS5jcmVhdGVQbGF0Zm9ybVJlc291cmNlVVJJKGZpbGUuZ2V0RnVsbFBhdGgoKQorCQkJCQkJCQkJLnRvU3RyaW5nKCksIGZhbHNlKTsKKwkJCQkJaWYgKHNob3VsZFVzZSh1cmkpKSB7CisJCQkJCQlTdHJpbmcgZmlsZUV4dGVuc2lvbiA9IHVyaS5maWxlRXh0ZW5zaW9uKCk7CisJCQkJCQlzd2l0Y2ggKGZpbGVFeHRlbnNpb24pIHsKKwkJCQkJCWNhc2UgImVudGl0eSI6CisJCQkJCQkJaWYgKCFjb250YWlucyh1cmkpKSB7CisJCQkJCQkJCXBlbmRpbmcuYWRkKG5ldyBQZW5kaW5nKHVyaSkpOworCQkJCQkJCX0KKwkJCQkJCQlicmVhazsKKwkJCQkJCWNhc2UgImR0byI6CisJCQkJCQkJaWYgKCFjb250YWlucyh1cmkpKSB7CisJCQkJCQkJCXBlbmRpbmcuYWRkKG5ldyBQZW5kaW5nKHVyaSkpOworCQkJCQkJCX0KKwkJCQkJCQlicmVhazsKKwkJCQkJCX0KKwkJCQkJfQorCisJCQkJfQorCQkJCXJldHVybiBmYWxzZTsKKwkJCX0KKwkJfSk7CisJfQorCisJcHJpdmF0ZSBib29sZWFuIGNoZWNrRm9sZGVyKElGb2xkZXIgZm9sZGVyKSB7IC8vIE5PU09OQVIgLSBjb21wbGV4aXR5CisJCWlmIChNT0RFTFNfQkFTRV9TUkNfRElSRUNUT1JZLmVxdWFscyhmb2xkZXIuZ2V0TmFtZSgpKSkgeworCQkJcmV0dXJuIHRydWU7CisJCX0KKwkJaWYgKFNPVVJDRV9CQVNFX1NSQ19ESVJFQ1RPUlkuZXF1YWxzKGZvbGRlci5nZXROYW1lKCkpKSB7CisJCQlyZXR1cm4gdHJ1ZTsKKwkJfQorCQlyZXR1cm4gZmFsc2U7CisJfQorCisJLyoqCisJICogRW5zdXJlIHBhcnRpY2lwYW50cy4KKwkgKi8KKwlwcml2YXRlIHZvaWQgZW5zdXJlUGFydGljaXBhbnRzKCkgeworCQlpZiAoZHRvQnVpbGRlciA9PSBudWxsKSB7CisJCQkvLyBvbiBzdGFydHVwIGFkZCB0aGUgc3RhdGUgbGlzdGVuZXIKKwkJCXN0YXRlLmFkZExpc3RlbmVyKHRoaXMpOworCisJCQlkdG9CdWlsZGVyID0gbmV3IER0b0VuaGFuY2VyKCk7CisJCQlpbmplY3Rvci5pbmplY3RNZW1iZXJzKGR0b0J1aWxkZXIpOworCQl9CisKKwkJaWYgKHNlcnZpY2VCdWlsZGVyID09IG51bGwpIHsKKwkJCXNlcnZpY2VCdWlsZGVyID0gbmV3IFNlcnZpY2VFbmhhbmNlcigpOworCQkJaW5qZWN0b3IuaW5qZWN0TWVtYmVycyhzZXJ2aWNlQnVpbGRlcik7CisJCX0KKwl9CisKKwkvKioKKwkgKiBUaGUgQ2xhc3MgRHRvRW5oYW5jZXIuCisJICovCisJcHVibGljIGNsYXNzIER0b0VuaGFuY2VyIHsKKworCQkvKioKKwkJICogVGhlIENsYXNzIER0b0VuaGFuY2VyQ29udGV4dC4KKwkJICovCisJCXByaXZhdGUgY2xhc3MgRHRvRW5oYW5jZXJDb250ZXh0IHsKKworCQkJLyoqIFRoZSBkdG8gcmVzb3VyY2UuICovCisJCQlwcml2YXRlIElTZW1hbnRpY0xvYWRpbmdSZXNvdXJjZSBkdG9SZXNvdXJjZTsKKworCQkJLyoqIFRoZSB3cml0ZWFibGUgcmVzb3VyY2Ugc2V0LiAqLworCQkJcHJpdmF0ZSBSZXNvdXJjZVNldCB3cml0ZWFibGVSZXNvdXJjZVNldDsKKwkJfQorCisJCS8qKiBUaGUgcnMgcHJvdmlkZXIuICovCisJCUBJbmplY3QKKwkJcHJpdmF0ZSBYdGV4dFJlc291cmNlU2V0UHJvdmlkZXIgcnNQcm92aWRlcjsKKworCQkvKiogVGhlIHJlZmVyZW5jZSBmaW5kZXIuICovCisJCUBJbmplY3QKKwkJcHJpdmF0ZSBJUmVmZXJlbmNlRmluZGVyIHJlZmVyZW5jZUZpbmRlcjsKKworCQkvKiogVGhlIHVyaSBzdG9yYWdlIG1hcHBlci4gKi8KKwkJQEluamVjdAorCQlwcml2YXRlIElTdG9yYWdlMlVyaU1hcHBlciB1cmlTdG9yYWdlTWFwcGVyOworCisJCS8qKgorCQkgKiBCdWlsZHMgdGhlIGR0by4KKwkJICoKKwkJICogQHBhcmFtIHRlbXBMRW50aXR5TW9kZWwKKwkJICogICAgICAgICAgICB0aGUgdGVtcCBsIGVudGl0eSBtb2RlbAorCQkgKi8KKwkJcHVibGljIHZvaWQgYnVpbGREdG9zKExFbnRpdHlNb2RlbCB0ZW1wTEVudGl0eU1vZGVsKSB7CisJCQlJWHRleHRVdGlsU2VydmljZSBzZXJ2aWNlID0gQ29yZVVpQWN0aXZhdG9yLmdldERlZmF1bHQoKQorCQkJCQkuZ2V0VXRpbFNlcnZpY2UoKTsKKwkJCWlmIChzZXJ2aWNlID09IG51bGwpIHsKKwkJCQlMT0dHRVIuZXJyb3IoIlNraXBwaW5nIGR0byBidWlsZCBzaW5jZSBJWHRleHRVdGlsU2VydmljZSBpcyBub3QgYXZhaWxhYmxlISIpOworCQkJCXJldHVybjsKKwkJCX0KKworCQkJVGltZUxvZ2dlciB0aW1lTG9nZ2VyID0gVGltZUxvZ2dlci5zdGFydChnZXRDbGFzcygpKTsKKworCQkJLy8KKwkJCS8vIHdlIG5lZWQgdG8gcHJlcGFyZSBhIGR0b1Jlc291cmNlIGFuZCBhIHdyaXRlYWJsZVJlc291cmNlU2V0CisJCQkvLworCQkJLy8gZmluZCByZWZlcmVuY2luZyBkdG8gbW9kZWwKKwkJCVNldDxVUkk+IGVudGl0eVVSSXMgPSBmaW5kRW50aXR5VVJJcyh0ZW1wTEVudGl0eU1vZGVsKTsKKwkJCWZpbmFsIExpc3Q8SVJlZmVyZW5jZURlc2NyaXB0aW9uPiB0YXJnZXREdG9SZWZlcmVuY2VzID0gZmluZFRhcmdldER0b1JlZmVyZW5jZXMoCisJCQkJCWVudGl0eVVSSXMsIHRlbXBMRW50aXR5TW9kZWwuZVJlc291cmNlKCkuZ2V0UmVzb3VyY2VTZXQoKSk7CisKKwkJCS8vIC0tLS0tLS0gY3JlYXRlIHRoZSBidWlsZCBjb250ZXh0IC0tLS0tLS0KKwkJCUR0b0VuaGFuY2VyQ29udGV4dCBjb250ZXh0ID0gY3JlYXRlRHRvQnVpbGRDb250ZXh0KAorCQkJCQl0ZW1wTEVudGl0eU1vZGVsLCB0YXJnZXREdG9SZWZlcmVuY2VzKTsKKworCQkJSVNlbWFudGljTG9hZGluZ1Jlc291cmNlIGVudGl0eVJlc291cmNlID0gKElTZW1hbnRpY0xvYWRpbmdSZXNvdXJjZSkgY29udGV4dC53cml0ZWFibGVSZXNvdXJjZVNldAorCQkJCQkuZ2V0UmVzb3VyY2UodGVtcExFbnRpdHlNb2RlbC5lUmVzb3VyY2UoKS5nZXRVUkkoKSwgdHJ1ZSk7CisKKwkJCUxpc3Q8TFR5cGU+IHNvdXJjZUFydGlmYWN0cyA9IGNvbGxlY3RFbnRpdGllcygoTEVudGl0eU1vZGVsKSBlbnRpdHlSZXNvdXJjZQorCQkJCQkuZ2V0U2VtYW50aWNFbGVtZW50KCkpOworCisJCQlMaXN0PExUeXBlPiB0ZW1wRHRvcyA9IGNvbGxlY3REdG9zKChMRHRvTW9kZWwpIGNvbnRleHQuZHRvUmVzb3VyY2UKKwkJCQkJLmdldFNlbWFudGljRWxlbWVudCgpKTsKKworCQkJTGlzdDxTb3VyY2VUeXBlU3RvcmU+IHNvdXJjZVR5cGVTdG9yZXMgPSBuZXcgQXJyYXlMaXN0PFNvdXJjZVR5cGVTdG9yZT4oKTsKKwkJCUxpc3Q8TFR5cGU+IGR0b3NUb1BlcnNpc3QgPSBuZXcgQXJyYXlMaXN0PExUeXBlPigpOworCisJCQkvLyBjcmVhdGUgYWxsIGR0b3MgLT4gbm8gbGlua2luZworCQkJLy8KKwkJCVNldDxMVHlwZWRQYWNrYWdlPiB0b3VjaGVkUGFja2FnZXMgPSBuZXcgSGFzaFNldDxMVHlwZWRQYWNrYWdlPigpOworCQkJZm9yIChMVHlwZSBsVHlwZSA6IHNvdXJjZUFydGlmYWN0cykgeworCQkJCWlmIChsVHlwZSBpbnN0YW5jZW9mIExFbnRpdHkpIHsKKwkJCQkJTEVudGl0eSBsRW50aXR5ID0gKExFbnRpdHkpIGxUeXBlOworCQkJCQlMRHRvIGxEdG8gPSAoTER0bykgZmluZER0b1R5cGUobEVudGl0eSwgdGVtcER0b3MpOworCQkJCQlpZiAobER0byA9PSBudWxsKSB7CisJCQkJCQlsRHRvID0gT1NCUER0b0ZhY3RvcnkuZUlOU1RBTkNFLmNyZWF0ZUxBdXRvSW5oZXJpdER0bygpOworCQkJCQkJbER0by5zZXRBbm5vdGF0aW9uSW5mbyhPU0JQRHRvRmFjdG9yeS5lSU5TVEFOQ0UKKwkJCQkJCQkJLmNyZWF0ZUxEdG8oKSk7CisJCQkJCQl0ZW1wRHRvcy5hZGQobER0byk7CisJCQkJCX0gZWxzZSB7CisJCQkJCQkvLyByZW1vdmUgZnJvbSBwYWNrYWdlIGZvciBhIHdoaWxlCisJCQkJCQlMVHlwZWRQYWNrYWdlIGxQa2cgPSAoTFR5cGVkUGFja2FnZSkgbER0by5lQ29udGFpbmVyKCk7CisJCQkJCQlsUGtnLmdldFR5cGVzKCkucmVtb3ZlKGxEdG8pOworCQkJCQkJLy8gY29sbGVjdCBhbGwgdG91Y2hlZCBwYWNrYWdlcyAtPiBUaGV5IG5lZWQgY2xlYW51cAorCQkJCQkJLy8gbGF0ZXIKKwkJCQkJCXRvdWNoZWRQYWNrYWdlcy5hZGQobFBrZyk7CisJCQkJCX0KKwkJCQkJbER0by5zZXROYW1lKE5hbWluZ0NvbnZlbnRpb25zVXRpbC50b0R0b05hbWUobEVudGl0eSkpOworCQkJCQlsRHRvLnNldFdyYXBwZWRUeXBlKGxFbnRpdHkpOworCisJCQkJCWR0b3NUb1BlcnNpc3QuYWRkKGxEdG8pOworCisJCQkJCS8vIHN0b3JlIHRoZSBzb3VyY2UgdHlwZSBvZiB0aGUgbmV3IGVudW0KKwkJCQkJc291cmNlVHlwZVN0b3Jlcy5hZGQobmV3IFNvdXJjZVR5cGVTdG9yZShsRW50aXR5LCBsRHRvKSk7CisKKwkJCQl9IGVsc2UgaWYgKGxUeXBlIGluc3RhbmNlb2YgTEJlYW4pIHsKKwkJCQkJTEJlYW4gbEJlYW4gPSAoTEJlYW4pIGxUeXBlOworCQkJCQlMRHRvIGxEdG8gPSAoTER0bykgZmluZER0b1R5cGUobEJlYW4sIHRlbXBEdG9zKTsKKwkJCQkJaWYgKGxEdG8gPT0gbnVsbCkgeworCQkJCQkJbER0byA9IE9TQlBEdG9GYWN0b3J5LmVJTlNUQU5DRS5jcmVhdGVMQXV0b0luaGVyaXREdG8oKTsKKwkJCQkJCWxEdG8uc2V0QW5ub3RhdGlvbkluZm8oT1NCUER0b0ZhY3RvcnkuZUlOU1RBTkNFCisJCQkJCQkJCS5jcmVhdGVMRHRvKCkpOworCQkJCQkJdGVtcER0b3MuYWRkKGxEdG8pOworCQkJCQl9IGVsc2UgeworCQkJCQkJLy8gcmVtb3ZlIGZyb20gcGFja2FnZSBmb3IgYSB3aGlsZQorCQkJCQkJTFR5cGVkUGFja2FnZSBsUGtnID0gKExUeXBlZFBhY2thZ2UpIGxEdG8uZUNvbnRhaW5lcigpOworCQkJCQkJbFBrZy5nZXRUeXBlcygpLnJlbW92ZShsRHRvKTsKKworCQkJCQkJLy8gY29sbGVjdCBhbGwgdG91Y2hlZCBwYWNrYWdlcyAtPiBUaGV5IG5lZWQgY2xlYW51cAorCQkJCQkJLy8gbGF0ZXIKKwkJCQkJCXRvdWNoZWRQYWNrYWdlcy5hZGQobFBrZyk7CisJCQkJCX0KKwkJCQkJbER0by5zZXROYW1lKE5hbWluZ0NvbnZlbnRpb25zVXRpbC50b0R0b05hbWUobEJlYW4pKTsKKwkJCQkJbER0by5zZXRXcmFwcGVkVHlwZShsQmVhbik7CisKKwkJCQkJZHRvc1RvUGVyc2lzdC5hZGQobER0byk7CisKKwkJCQkJLy8gc3RvcmUgdGhlIHNvdXJjZSB0eXBlIG9mIHRoZSBuZXcgZW51bQorCQkJCQlzb3VyY2VUeXBlU3RvcmVzLmFkZChuZXcgU291cmNlVHlwZVN0b3JlKGxCZWFuLCBsRHRvKSk7CisJCQkJfSBlbHNlIGlmIChsVHlwZSBpbnN0YW5jZW9mIExFbnVtKSB7CisJCQkJCUxFbnVtIGxTb3VyY2VUeXBlID0gKExFbnVtKSBsVHlwZTsKKwkJCQkJTEVudW0gbER0b1R5cGUgPSAoTEVudW0pIGZpbmREdG9UeXBlKGxTb3VyY2VUeXBlLCB0ZW1wRHRvcyk7CisJCQkJCWlmIChsRHRvVHlwZSA9PSBudWxsKSB7CisJCQkJCQlsRHRvVHlwZSA9IE9TQlBUeXBlc0ZhY3RvcnkuZUlOU1RBTkNFLmNyZWF0ZUxFbnVtKCk7CisJCQkJCQkvLyBsRHRvVHlwZS5zZXRBbm5vdGF0aW9uSW5mbyhPU0JQVHlwZXNGYWN0b3J5LmVJTlNUQU5DRQorCQkJCQkJLy8gLmNyZWF0ZUxFbnVtKCkpOworCQkJCQkJdGVtcER0b3MuYWRkKGxEdG9UeXBlKTsKKwkJCQkJfSBlbHNlIHsKKwkJCQkJCS8vIHJlbW92ZSBmcm9tIHBhY2thZ2UgZm9yIGEgd2hpbGUKKwkJCQkJCUxUeXBlZFBhY2thZ2UgbFBrZyA9IChMVHlwZWRQYWNrYWdlKSBsRHRvVHlwZQorCQkJCQkJCQkuZUNvbnRhaW5lcigpOworCQkJCQkJbFBrZy5nZXRUeXBlcygpLnJlbW92ZShsRHRvVHlwZSk7CisKKwkJCQkJCS8vIGNvbGxlY3QgYWxsIHRvdWNoZWQgcGFja2FnZXMgLT4gVGhleSBuZWVkIGNsZWFudXAKKwkJCQkJCS8vIGxhdGVyCisJCQkJCQl0b3VjaGVkUGFja2FnZXMuYWRkKGxQa2cpOworCQkJCQl9CisJCQkJCWxEdG9UeXBlLnNldE5hbWUoTmFtaW5nQ29udmVudGlvbnNVdGlsCisJCQkJCQkJLnRvRHRvTmFtZShsU291cmNlVHlwZSkpOworCisJCQkJCWR0b3NUb1BlcnNpc3QuYWRkKGxEdG9UeXBlKTsKKworCQkJCQkvLyBzdG9yZSB0aGUgc291cmNlIHR5cGUgb2YgdGhlIG5ldyBlbnVtCisJCQkJCXNvdXJjZVR5cGVTdG9yZXMuYWRkKG5ldyBTb3VyY2VUeXBlU3RvcmUobFNvdXJjZVR5cGUsCisJCQkJCQkJbER0b1R5cGUpKTsKKworCQkJCX0KKwkJCX0KKworCQkJLy8gY2xlYW4gdG91Y2hlZCBwYWNrYWdlcyAtPiBBbHNvIHJlbW92ZSBkdG9zIHRoYXQgYXJlIG5vdCBiYXNlZCBvbgorCQkJLy8gYW4KKwkJCS8vIGVudGl0eSBhbnltb3JlCisJCQlmb3IgKExUeXBlZFBhY2thZ2UgbFBrZyA6IHRvdWNoZWRQYWNrYWdlcykgeworCQkJCWZvciAoSXRlcmF0b3I8TFR5cGU+IGl0ZXJhdG9yID0gbFBrZy5nZXRUeXBlcygpLml0ZXJhdG9yKCk7IGl0ZXJhdG9yCisJCQkJCQkuaGFzTmV4dCgpOykgeworCQkJCQlMVHlwZSBsVHlwZSA9IChMVHlwZSkgaXRlcmF0b3IubmV4dCgpOworCQkJCQlpZiAobFR5cGUgaW5zdGFuY2VvZiBMQXV0b0luaGVyaXREdG8pIHsKKwkJCQkJCUxEdG8gbER0byA9IChMRHRvKSBsVHlwZTsKKwkJCQkJCWlmIChsRHRvLmdldFdyYXBwZWRUeXBlKCkgPT0gbnVsbAorCQkJCQkJCQl8fCBsRHRvLmdldFdyYXBwZWRUeXBlKCkuZUlzUHJveHkoKSkgeworCQkJCQkJCWl0ZXJhdG9yLnJlbW92ZSgpOworCQkJCQkJfQorCQkJCQl9CisJCQkJfQorCQkJfQorCisJCQkvLyByZW1vdmUgYWxsIGR0b3MgaGF2aW5nIG5vIHdyYXBwZWQgdHlwZSBhbnltb3JlCisJCQkvLworCQkJZm9yIChMVHlwZSBsVHlwZSA6IG5ldyBBcnJheUxpc3Q8Pih0ZW1wRHRvcykpIHsKKwkJCQlpZiAobFR5cGUgaW5zdGFuY2VvZiBMQXV0b0luaGVyaXREdG8pIHsKKwkJCQkJTER0byBsRHRvID0gKExEdG8pIGxUeXBlOworCQkJCQlpZiAobER0by5nZXRXcmFwcGVkVHlwZSgpID09IG51bGwKKwkJCQkJCQl8fCBsRHRvLmdldFdyYXBwZWRUeXBlKCkuZUlzUHJveHkoKSkgeworCQkJCQkJdGVtcER0b3MucmVtb3ZlKGxEdG8pOworCQkJCQl9CisJCQkJfQorCQkJfQorCisJCQkvLyBjbGVhbiBzdXBlciB0eXBlcworCQkJLy8KKwkJCWZvciAoTFR5cGUgbFR5cGUgOiBkdG9zVG9QZXJzaXN0KSB7CisJCQkJaWYgKGxUeXBlIGluc3RhbmNlb2YgTEF1dG9Jbmhlcml0RHRvKSB7CisJCQkJCUxEdG8gbER0byA9IChMRHRvKSBsVHlwZTsKKwkJCQkJbER0by5zZXRTdXBlclR5cGUobnVsbCk7CisJCQkJfQorCQkJfQorCisJCQkvLyBsaW5rIHN1cGVyIHR5cGVzCisJCQkvLworCQkJZm9yIChMVHlwZSBsVHlwZSA6IHNvdXJjZUFydGlmYWN0cykgeworCQkJCWlmIChsVHlwZSBpbnN0YW5jZW9mIExFbnRpdHkpIHsKKwkJCQkJTEVudGl0eSBsRW50aXR5ID0gKExFbnRpdHkpIGxUeXBlOworCQkJCQlpZiAobEVudGl0eS5nZXRTdXBlclR5cGUoKSAhPSBudWxsCisJCQkJCQkJJiYgIWxFbnRpdHkuZ2V0U3VwZXJUeXBlKCkuZUlzUHJveHkoKSkgeworCQkJCQkJTEVudGl0eSBsRW50aXR5U3VwZXJUeXBlID0gbEVudGl0eS5nZXRTdXBlclR5cGUoKTsKKwkJCQkJCUxEdG8gbER0byA9IChMRHRvKSBmaW5kRHRvVHlwZShsRW50aXR5LCB0ZW1wRHRvcyk7CisJCQkJCQlMRHRvIGxEdG9TdXBlclR5cGUgPSAoTER0bykgZmluZER0b1R5cGUoCisJCQkJCQkJCWxFbnRpdHlTdXBlclR5cGUsIHRlbXBEdG9zKTsKKwkJCQkJCWxEdG8uc2V0U3VwZXJUeXBlKGxEdG9TdXBlclR5cGUpOworCQkJCQl9CisJCQkJfSBlbHNlIGlmIChsVHlwZSBpbnN0YW5jZW9mIExCZWFuKSB7CisJCQkJCUxCZWFuIGxCZWFuID0gKExCZWFuKSBsVHlwZTsKKwkJCQkJaWYgKGxCZWFuLmdldFN1cGVyVHlwZSgpICE9IG51bGwKKwkJCQkJCQkmJiAhbEJlYW4uZ2V0U3VwZXJUeXBlKCkuZUlzUHJveHkoKSkgeworCQkJCQkJTEJlYW4gbEJlYW5TdXBlclR5cGUgPSBsQmVhbi5nZXRTdXBlclR5cGUoKTsKKwkJCQkJCUxEdG8gbER0byA9IChMRHRvKSBmaW5kRHRvVHlwZShsQmVhbiwgdGVtcER0b3MpOworCQkJCQkJTER0byBsRHRvU3VwZXJUeXBlID0gKExEdG8pIGZpbmREdG9UeXBlKGxCZWFuU3VwZXJUeXBlLAorCQkJCQkJCQl0ZW1wRHRvcyk7CisJCQkJCQlsRHRvLnNldFN1cGVyVHlwZShsRHRvU3VwZXJUeXBlKTsKKwkJCQkJfQorCQkJCX0KKwkJCX0KKworCQkJLy8gZml4IGZlYXR1cmVzCisJCQkvLworCQkJZm9yIChMVHlwZSBsVHlwZSA6IGR0b3NUb1BlcnNpc3QpIHsKKwkJCQlpZiAobFR5cGUgaW5zdGFuY2VvZiBMQXV0b0luaGVyaXREdG8pIHsKKwkJCQkJTER0byBsRHRvID0gKExEdG8pIGxUeXBlOworCQkJCQlmaXhGZWF0dXJlcyhsRHRvLCBkdG9zVG9QZXJzaXN0KTsKKwkJCQl9IGVsc2UgaWYgKGxUeXBlIGluc3RhbmNlb2YgTEVudW0pIHsKKwkJCQkJTEVudW0gbER0b0VudW0gPSAoTEVudW0pIGxUeXBlOworCQkJCQlmaXhMaXRlcmFscyhsRHRvRW51bSk7CisJCQkJfQorCQkJfQorCisJCQlpZiAoIWR0b3NUb1BlcnNpc3QuaXNFbXB0eSgpKSB7CisJCQkJLy8gYWRkIHRoZSBkdG9zIHRvIHRoZSBwYWNrYWdlIGluIHRoZSBwcm9wZXIgb3JkZXIKKwkJCQkvLworCQkJCVNldDxTdHJpbmc+IGR0b05hbWVzID0gbmV3IEhhc2hTZXQ8U3RyaW5nPigpOworCQkJCWZvciAoTFR5cGUgbFR5cGUgOiBkdG9zVG9QZXJzaXN0KSB7CisKKwkJCQkJaWYgKGxUeXBlIGluc3RhbmNlb2YgTER0bykgeworCQkJCQkJTER0byBsRHRvID0gKExEdG8pIGxUeXBlOworCQkJCQkJLy8gZmlsdGVyIGR0b3MKKwkJCQkJCWlmIChkdG9OYW1lcy5jb250YWlucyhsRHRvLmdldE5hbWUoKSkpIHsKKwkJCQkJCQkvLyByZW1vdmUgZHVwbGljYXRlIGR0b3MKKwkJCQkJCQljb250aW51ZTsKKwkJCQkJCX0gZWxzZSBpZiAobER0by5nZXRXcmFwcGVkVHlwZSgpLmVJc1Byb3h5KCkpIHsKKwkJCQkJCQkvLyByZW1vdmUgZHRvIHdpdGhvdXQgYSBwcm9wZXIgZW50aXR5IHJlZmVyZW5jZQorCQkJCQkJCWNvbnRpbnVlOworCQkJCQkJfQorCQkJCQkJZHRvTmFtZXMuYWRkKGxEdG8uZ2V0TmFtZSgpKTsKKworCQkJCQkJTFR5cGVkUGFja2FnZSBsU291cmNlVHlwZVBrZyA9IChMVHlwZWRQYWNrYWdlKSBsRHRvCisJCQkJCQkJCS5nZXRXcmFwcGVkVHlwZSgpLmVDb250YWluZXIoKTsKKwkJCQkJCWFkZER0b1RvUGFja2FnZSgKKwkJCQkJCQkJTmFtaW5nQ29udmVudGlvbnNVdGlsCisJCQkJCQkJCQkJLnRvRHRvUGFja2FnZShsU291cmNlVHlwZVBrZyksCisJCQkJCQkJCWxEdG8sIChMRHRvTW9kZWwpIGNvbnRleHQuZHRvUmVzb3VyY2UKKwkJCQkJCQkJCQkuZ2V0U2VtYW50aWNFbGVtZW50KCksIGxTb3VyY2VUeXBlUGtnCisJCQkJCQkJCQkJLmdldE5hbWUoKSk7CisJCQkJCX0gZWxzZSBpZiAobFR5cGUgaW5zdGFuY2VvZiBMRW51bSkgeworCQkJCQkJTEVudW0gbEVudW0gPSAoTEVudW0pIGxUeXBlOworCQkJCQkJLy8gZmlsdGVyIGR0b3MKKwkJCQkJCWlmIChkdG9OYW1lcy5jb250YWlucyhsRW51bS5nZXROYW1lKCkpKSB7CisJCQkJCQkJLy8gcmVtb3ZlIGR1cGxpY2F0ZSBlbnVtcworCQkJCQkJCWNvbnRpbnVlOworCQkJCQkJfQorCQkJCQkJZHRvTmFtZXMuYWRkKGxFbnVtLmdldE5hbWUoKSk7CisKKwkJCQkJCUxFbnVtIHNvdXJjZVR5cGUgPSAoTEVudW0pIFNvdXJjZVR5cGVTdG9yZQorCQkJCQkJCQkuZmluZFNvdXJjZVR5cGUobEVudW0pOworCQkJCQkJTFR5cGVkUGFja2FnZSBsU291cmNlVHlwZVBrZyA9IChMVHlwZWRQYWNrYWdlKSBzb3VyY2VUeXBlCisJCQkJCQkJCS5lQ29udGFpbmVyKCk7CisJCQkJCQlhZGREdG9Ub1BhY2thZ2UoCisJCQkJCQkJCU5hbWluZ0NvbnZlbnRpb25zVXRpbAorCQkJCQkJCQkJCS50b0R0b1BhY2thZ2UobFNvdXJjZVR5cGVQa2cpLAorCQkJCQkJCQlsRW51bSwgKExEdG9Nb2RlbCkgY29udGV4dC5kdG9SZXNvdXJjZQorCQkJCQkJCQkJCS5nZXRTZW1hbnRpY0VsZW1lbnQoKSwgbFNvdXJjZVR5cGVQa2cKKwkJCQkJCQkJCQkuZ2V0TmFtZSgpKTsKKwkJCQkJfQorCQkJCX0KKworCQkJCS8vIHJlbW92ZSBhbGwgYWRkZWQgYWRhcHRlcnMKKwkJCQkvLworCQkJCWZvciAoU291cmNlVHlwZVN0b3JlIHN0b3JlIDogc291cmNlVHlwZVN0b3JlcykgeworCQkJCQlzdG9yZS5kaXNwb3NlKCk7CisJCQkJfQorCisJCQkJLy8gc2F2ZSB0aGUgZHRvcworCQkJCS8vCisJCQkJdHJ5IHsKKwkJCQkJRGlhZ25vc3RpYyBkaWFnbm9zdGljID0gRGlhZ25vc3RpY2lhbi5JTlNUQU5DRQorCQkJCQkJCS52YWxpZGF0ZShjb250ZXh0LmR0b1Jlc291cmNlLmdldFNlbWFudGljRWxlbWVudCgpKTsKKwkJCQkJaW50IHNldiA9IGRpYWdub3N0aWMuZ2V0U2V2ZXJpdHkoKTsKKwkJCQkJaWYgKHNldiA8PSBEaWFnbm9zdGljLldBUk5JTkcpIHsKKwkJCQkJCWNvbnRleHQuZHRvUmVzb3VyY2Uuc2F2ZShTYXZlT3B0aW9ucy5uZXdCdWlsZGVyKCkKKwkJCQkJCQkJLmZvcm1hdCgpLmdldE9wdGlvbnMoKS50b09wdGlvbnNNYXAoKSk7CisJCQkJCX0gZWxzZSB7CisJCQkJCQlpZiAoIWNvbnRleHQuZHRvUmVzb3VyY2UuZ2V0RXJyb3JzKCkuaXNFbXB0eSgpKSB7CisJCQkJCQkJU3RyaW5nIG1lc3NhZ2UgPSBjb250ZXh0LmR0b1Jlc291cmNlLmdldEVycm9ycygpCisJCQkJCQkJCQkuZ2V0KDApLnRvU3RyaW5nKCk7CisJCQkJCQkJTE9HR0VSLmVycm9yKG1lc3NhZ2UpOworCisJCQkJCQkJSVN0YXR1cyBzdGF0dXMgPSBuZXcgU3RhdHVzKElTdGF0dXMuRVJST1IsCisJCQkJCQkJCQkib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aSIsIG1lc3NhZ2UpOworCQkJCQkJCURpc3BsYXkuZ2V0RGVmYXVsdCgpLmFzeW5jRXhlYygKKwkJCQkJCQkJCSgpIC0+IHsKKwkJCQkJCQkJCQlFcnJvckRpYWxvZy5vcGVuRXJyb3IoRGlzcGxheQorCQkJCQkJCQkJCQkJLmdldERlZmF1bHQoKS5nZXRBY3RpdmVTaGVsbCgpLAorCQkJCQkJCQkJCQkJIkVycm9yIiwgbWVzc2FnZSwgc3RhdHVzKTsKKwkJCQkJCQkJCX0pOworCQkJCQkJfSBlbHNlIHsKKwkJCQkJCQlTdHJpbmcgbWVzc2FnZSA9IGRpYWdub3N0aWMudG9TdHJpbmcoKTsKKwkJCQkJCQlMT0dHRVIuZXJyb3IoZGlhZ25vc3RpYy50b1N0cmluZygpKTsKKworCQkJCQkJCUlTdGF0dXMgc3RhdHVzID0gbmV3IFN0YXR1cyhJU3RhdHVzLkVSUk9SLAorCQkJCQkJCQkJIm9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkiLCBtZXNzYWdlKTsKKwkJCQkJCQlEaXNwbGF5LmdldERlZmF1bHQoKS5hc3luY0V4ZWMoCisJCQkJCQkJCQkoKSAtPiB7CisJCQkJCQkJCQkJRXJyb3JEaWFsb2cub3BlbkVycm9yKERpc3BsYXkKKwkJCQkJCQkJCQkJCS5nZXREZWZhdWx0KCkuZ2V0QWN0aXZlU2hlbGwoKSwKKwkJCQkJCQkJCQkJCSJFcnJvciIsIG1lc3NhZ2UsIHN0YXR1cyk7CisJCQkJCQkJCQl9KTsKKwkJCQkJCX0KKwkJCQkJfQorCQkJCQljb250ZXh0LmR0b1Jlc291cmNlLnVubG9hZCgpOworCisJCQkJCS8vIGludm9rZSB0aGUgaW5jcmVtZW50YWwgYnVpbGQKKwkJCQkJLy8KKwkJCQkJbmVlZFJlYnVpbGQoKTsKKwkJCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBlKSB7CisJCQkJCUxPR0dFUi5lcnJvcigie30iLCBlKTsKKwkJCQl9CisKKwkJCQl0aW1lTG9nZ2VyLnN0b3AoTE9HR0VSLCAiRmluaXNoZWQgT1NCUEJ1aWxkZXIjYnVpbGREdG9zIGluICIpOworCisJCQl9CisJCX0KKworCQkvKioKKwkJICogQ3JlYXRlcyB0aGUgZHRvIGJ1aWxkIGNvbnRleHQuCisJCSAqCisJCSAqIEBwYXJhbSB0ZW1wTEVudGl0eU1vZGVsCisJCSAqICAgICAgICAgICAgdGhlIHRlbXAgbCBlbnRpdHkgbW9kZWwKKwkJICogQHBhcmFtIHRhcmdldER0b1JlZmVyZW5jZXMKKwkJICogICAgICAgICAgICB0aGUgdGFyZ2V0IGR0byByZWZlcmVuY2VzCisJCSAqIEByZXR1cm4gdGhlIGR0byBlbmhhbmNlciBjb250ZXh0CisJCSAqLworCQlwcml2YXRlIER0b0VuaGFuY2VyQ29udGV4dCBjcmVhdGVEdG9CdWlsZENvbnRleHQoCisJCQkJTEVudGl0eU1vZGVsIHRlbXBMRW50aXR5TW9kZWwsCisJCQkJZmluYWwgTGlzdDxJUmVmZXJlbmNlRGVzY3JpcHRpb24+IHRhcmdldER0b1JlZmVyZW5jZXMpIHsKKwkJCUR0b0VuaGFuY2VyQ29udGV4dCBjb250ZXh0ID0gbmV3IER0b0VuaGFuY2VyQ29udGV4dCgpOworCQkJaWYgKCF0YXJnZXREdG9SZWZlcmVuY2VzLmlzRW1wdHkoKSkgeworCQkJCS8vCisJCQkJLy8gaWYgd2UgY291bGQgZmluZCByZWZlcmVuY2VkIGR0b3MsIHRoZW4gd2UgdXNlIHRoaXMKKwkJCQkvLyBpbmZvcm1hdGlvbiB0bworCQkJCS8vIGNyZWF0ZSBkdG9SZXNvdXJjZSBhbmQgd3JpdGVhYmxlUmVzb3VyY2VTZXQKKwkJCQkvLworCisJCQkJLy8gYWNjZXNzIGVudGl0eSByZXNvdXJjZQorCQkJCUlTZW1hbnRpY0xvYWRpbmdSZXNvdXJjZSB0ZW1wRW50aXR5UmVzb3VyY2UgPSAoSVNlbWFudGljTG9hZGluZ1Jlc291cmNlKSB0ZW1wTEVudGl0eU1vZGVsCisJCQkJCQkuZVJlc291cmNlKCk7CisJCQkJUmVzb3VyY2VTZXQgcmVhZG9ubHlSZXNvdXJjZVNldCA9IHRlbXBFbnRpdHlSZXNvdXJjZQorCQkJCQkJLmdldFJlc291cmNlU2V0KCk7CisKKwkJCQkvLyBhY2Nlc3MgZHRvIHJlc291cmNlIGJhc2VkIG9uIGVudGl0eVJlc291cmNlU2V0CisJCQkJSVJlZmVyZW5jZURlc2NyaXB0aW9uIGZpcnN0RGVzYyA9IHRhcmdldER0b1JlZmVyZW5jZXMuZ2V0KDApOworCQkJCUxEdG8gdGVtcER0byA9IChMRHRvKSByZWFkb25seVJlc291cmNlU2V0LmdldEVPYmplY3QoCisJCQkJCQlmaXJzdERlc2MuZ2V0U291cmNlRU9iamVjdFVyaSgpLCB0cnVlKTsKKworCQkJCS8vIGNyZWF0ZSB0aGUgcHJvcGVyIGR0byByZXNvdXJjZVNldCB0byBzYXZlIHRoZSBkdG8KKwkJCQljb250ZXh0LndyaXRlYWJsZVJlc291cmNlU2V0ID0gZ2V0UHJvamVjdFJlc291cmNlU2V0KEVjb3JlVXRpbAorCQkJCQkJLmdldFVSSSh0ZW1wRHRvKSk7CisKKwkJCQkvLyBsb2FkIHRoZSBkdG9SZXNvdXJjZSBiYXNlZCBvbiB0aGUgZHRvIHJlc291cmNlU2V0CisJCQkJY29udGV4dC5kdG9SZXNvdXJjZSA9IChJU2VtYW50aWNMb2FkaW5nUmVzb3VyY2UpIGNvbnRleHQud3JpdGVhYmxlUmVzb3VyY2VTZXQKKwkJCQkJCS5nZXRSZXNvdXJjZShFY29yZVV0aWwuZ2V0VVJJKHRlbXBEdG8pLnRyaW1GcmFnbWVudCgpLAorCQkJCQkJCQl0cnVlKTsKKwkJCX0gZWxzZSB7CisKKwkJCQlVUkkgZW50aXR5VVJJID0gRWNvcmVVdGlsLmdldFVSSSh0ZW1wTEVudGl0eU1vZGVsKTsKKwkJCQkvLyBjcmVhdGUgdGhlIHByb3BlciBkdG8gcmVzb3VyY2VTZXQgdG8gc2F2ZSB0aGUgZHRvCisJCQkJY29udGV4dC53cml0ZWFibGVSZXNvdXJjZVNldCA9IGdldFByb2plY3RSZXNvdXJjZVNldChlbnRpdHlVUkkpOworCisJCQkJLy8gdHJ5IHRvIGZpbmQgYSBmaWxlIHdpdGggZXh0ZW5zaW9uIC5kdG9zIGluIHNhbWUgcHJvamVjdAorCQkJCUlSZXNvdXJjZSBtZW1iZXIgPSBmaW5kRHRvRmlsZShlbnRpdHlVUkkpOworCQkJCVN0cmluZyBkdG9SZXNvdXJjZVBhdGggPSBudWxsOworCQkJCWlmIChtZW1iZXIgIT0gbnVsbCkgeworCQkJCQlkdG9SZXNvdXJjZVBhdGggPSBtZW1iZXIuZ2V0RnVsbFBhdGgoKS50b1N0cmluZygpOworCQkJCX0gZWxzZSB7CisJCQkJCS8vCisJCQkJCS8vIGlmIHdlIGNvdWxkIG5vdCBmaW5kIHJlZmVyZW5jZWQgZHRvcywgdGhlbiB3ZSB1c2UgdGhlCisJCQkJCS8vIGZvbGRlcgorCQkJCQkvLyBvZgorCQkJCQkvLyB0aGUgZW50aXR5IGFuZCBwdXQgdGhlIGR0b3MgaW4gdGhlcmUKKwkJCQkJLy8KKworCQkJCQkvLyBjb252ZXJ0IGEgcGF0aCBmcm9tCisJCQkJCS8vICJvcmcvbXkvZm9vL2VudGl0eS9NeUVudGl0eS5lbnRpdHkiCisJCQkJCS8vIHRvCisJCQkJCS8vICJvcmcvbXkvZm9vL2VudGl0eS9NeUVudGl0eS5kdG9zIgorCQkJCQlkdG9SZXNvdXJjZVBhdGggPSBOYW1pbmdDb252ZW50aW9uc1V0aWwKKwkJCQkJCQkudG9EdG9QYWNrYWdlKGVudGl0eVVSSS5wYXRoKCkucmVwbGFjZSgiL3Jlc291cmNlIiwKKwkJCQkJCQkJCSIiKSk7CisJCQkJfQorCisJCQkJLy8gbm93IGNyZWF0ZSBhIGR0b1Jlc291cmNlCisKKwkJCQlVUkkgZHRvTW9kZWxVUkkgPSBVUkkuY3JlYXRlUGxhdGZvcm1SZXNvdXJjZVVSSSgKKwkJCQkJCWR0b1Jlc291cmNlUGF0aCwgdHJ1ZSk7CisJCQkJY29udGV4dC5kdG9SZXNvdXJjZSA9IChJU2VtYW50aWNMb2FkaW5nUmVzb3VyY2UpIGNvbnRleHQud3JpdGVhYmxlUmVzb3VyY2VTZXQKKwkJCQkJCS5jcmVhdGVSZXNvdXJjZShkdG9Nb2RlbFVSSSk7CisJCQkJY29udGV4dC5kdG9SZXNvdXJjZS5nZXRDb250ZW50cygpLmFkZCgKKwkJCQkJCU9TQlBEdG9GYWN0b3J5LmVJTlNUQU5DRS5jcmVhdGVMRHRvTW9kZWwoKSk7CisJCQl9CisJCQlyZXR1cm4gY29udGV4dDsKKwkJfQorCisJCXByaXZhdGUgSVJlc291cmNlIGZpbmREdG9GaWxlKFVSSSBlbnRpdHlVUkkpIHsKKwkJCVN0cmluZyBkdG9GaWxlTmFtZSA9IGVudGl0eVVSSS5wYXRoKCkKKwkJCQkJLnN1YnN0cmluZyhlbnRpdHlVUkkucGF0aCgpLmxhc3RJbmRleE9mKCIvIikgKyAxKQorCQkJCQkucmVwbGFjZSgiLmVudGl0eSIsICIuZHRvIik7CisKKwkJCUlSZXNvdXJjZVtdIHRlbXAgPSBuZXcgSVJlc291cmNlWzFdOworCQkJdHJ5IHsKKwkJCQlnZXRQcm9qZWN0KCkuYWNjZXB0KG5ldyBJUmVzb3VyY2VWaXNpdG9yKCkgeworCQkJCQlwdWJsaWMgYm9vbGVhbiB2aXNpdChJUmVzb3VyY2UgcmVzKSB7CisJCQkJCQlpZiAocmVzIGluc3RhbmNlb2YgSUZpbGUpIHsKKwkJCQkJCQlpZiAocmVzLmdldE5hbWUoKS5lcXVhbHMoZHRvRmlsZU5hbWUpKSB7CisJCQkJCQkJCXRlbXBbMF0gPSByZXM7CisJCQkJCQkJfQorCQkJCQkJCXJldHVybiB0cnVlOworCQkJCQkJfSBlbHNlIGlmIChyZXMgaW5zdGFuY2VvZiBJRm9sZGVyKSB7CisJCQkJCQkJaWYgKHJlcy5nZXROYW1lKCkuZXF1YWxzKCJiaW4iKQorCQkJCQkJCQkJfHwgcmVzLmdldE5hbWUoKS5lcXVhbHMoInRhcmdldCIpKSB7CisJCQkJCQkJCXJldHVybiBmYWxzZTsKKwkJCQkJCQl9CisJCQkJCQkJcmV0dXJuIHRydWU7CisJCQkJCQl9IGVsc2UgaWYgKHJlcyBpbnN0YW5jZW9mIElQcm9qZWN0KSB7CisJCQkJCQkJcmV0dXJuIHRydWU7CisJCQkJCQl9CisJCQkJCQlyZXR1cm4gZmFsc2U7CisJCQkJCX0KKwkJCQl9KTsKKwkJCX0gY2F0Y2ggKENvcmVFeGNlcHRpb24gZSkgeworCQkJCUxPR0dFUi53YXJuKCJ7fSIsIGUpOworCQkJfQorCisJCQlJUmVzb3VyY2UgbWVtYmVyID0gdGVtcFswXTsKKwkJCXJldHVybiBtZW1iZXI7CisJCX0KKworCQkvKioKKwkJICogRmluZCBkdG8gdHlwZS4KKwkJICoKKwkJICogQHBhcmFtIGxTb3VyY2VBcnRlZmFjdAorCQkgKiAgICAgICAgICAgIHRoZSBsIHNvdXJjZSBhcnRlZmFjdAorCQkgKiBAcGFyYW0gZHRvcworCQkgKiAgICAgICAgICAgIHRoZSBkdG9zCisJCSAqIEByZXR1cm4gdGhlIGwgdHlwZQorCQkgKi8KKwkJcHJpdmF0ZSBMVHlwZSBmaW5kRHRvVHlwZShMVHlwZSBsU291cmNlQXJ0ZWZhY3QsIExpc3Q8TFR5cGU+IGR0b3MpIHsKKwkJCWZvciAoTFR5cGUgbFR5cGUgOiBkdG9zKSB7CisJCQkJaWYgKGxUeXBlIGluc3RhbmNlb2YgTER0bykgeworCQkJCQlMRHRvIGxEdG8gPSAoTER0bykgbFR5cGU7CisJCQkJCWlmIChsRHRvLmdldFdyYXBwZWRUeXBlKCkgPT0gbFNvdXJjZUFydGVmYWN0KSB7CisJCQkJCQlyZXR1cm4gbER0bzsKKwkJCQkJfQorCQkJCX0gZWxzZSBpZiAobFR5cGUgaW5zdGFuY2VvZiBMRW51bSkgeworCQkJCQlMRW51bSBsRW51bSA9IChMRW51bSkgbFR5cGU7CisJCQkJCWlmIChsRW51bS5nZXROYW1lKCkuZXF1YWxzKGxTb3VyY2VBcnRlZmFjdC5nZXROYW1lKCkpKSB7CisJCQkJCQlyZXR1cm4gbEVudW07CisJCQkJCX0KKwkJCQl9CisJCQl9CisJCQlyZXR1cm4gbnVsbDsKKwkJfQorCisJCS8qKgorCQkgKiBBZGRzIHRoZSBkdG8gdG8gdGhlIHBhY2thZ2UgbWFjaGluZyB0aGUgcGFja2FnZU5hbWUuCisJCSAqCisJCSAqIEBwYXJhbSBwYWNrYWdlTmFtZQorCQkgKiAgICAgICAgICAgIHRoZSBwYWNrYWdlIG5hbWUKKwkJICogQHBhcmFtIG5ld0R0bworCQkgKiAgICAgICAgICAgIHRoZSBuZXcgZHRvCisJCSAqIEBwYXJhbSBsRHRvTW9kZWwKKwkJICogICAgICAgICAgICB0aGUgbCBkdG8gbW9kZWwKKwkJICogQHBhcmFtIGVudGl0eVBhY2thZ2UKKwkJICogICAgICAgICAgICB0aGUgZW50aXR5IHBhY2thZ2UKKwkJICovCisJCXByaXZhdGUgdm9pZCBhZGREdG9Ub1BhY2thZ2UoU3RyaW5nIHBhY2thZ2VOYW1lLCBMVHlwZSBuZXdEdG8sCisJCQkJTER0b01vZGVsIGxEdG9Nb2RlbCwgU3RyaW5nIGVudGl0eVBhY2thZ2UpIHsKKworCQkJT3B0aW9uYWw8TFR5cGVkUGFja2FnZT4gb3B0UGtnID0gbER0b01vZGVsLmdldFBhY2thZ2VzKCkuc3RyZWFtKCkKKwkJCQkJLmZpbHRlcihwIC0+IHAuZ2V0TmFtZSgpLmVxdWFscyhwYWNrYWdlTmFtZSkpLmZpbmRGaXJzdCgpOworCQkJTFR5cGVkUGFja2FnZSBwa2cgPSBudWxsOworCQkJaWYgKG9wdFBrZy5pc1ByZXNlbnQoKSkgeworCQkJCXBrZyA9IG9wdFBrZy5nZXQoKTsKKwkJCX0KKwkJCWlmIChwa2cgPT0gbnVsbCkgeworCQkJCXBrZyA9IE9TQlBUeXBlc0ZhY3RvcnkuZUlOU1RBTkNFLmNyZWF0ZUxUeXBlZFBhY2thZ2UoKTsKKwkJCQlwa2cuc2V0TmFtZShwYWNrYWdlTmFtZSk7CisJCQkJbER0b01vZGVsLmdldFBhY2thZ2VzKCkuYWRkKHBrZyk7CisJCQl9CisKKwkJCS8vIGNoZWNrIGlmIGVudGl0eVBhY2thZ2UgaXMgaW1wb3J0ZWQKKwkJCWlmICghY29udGFpbnNJbXBvcnQocGtnLCBlbnRpdHlQYWNrYWdlICsgIi4qIikpIHsKKwkJCQlMSW1wb3J0IGxJbXBvcnQgPSBPU0JQVHlwZXNGYWN0b3J5LmVJTlNUQU5DRS5jcmVhdGVMSW1wb3J0KCk7CisJCQkJbEltcG9ydC5zZXRJbXBvcnRlZE5hbWVzcGFjZShlbnRpdHlQYWNrYWdlICsgIi4qIik7CisJCQkJcGtnLmdldEltcG9ydHMoKS5hZGQobEltcG9ydCk7CisJCQl9CisKKwkJCXBrZy5nZXRUeXBlcygpLmFkZChuZXdEdG8pOworCQl9CisKKwkJLyoqCisJCSAqIENvbnRhaW5zIGltcG9ydC4KKwkJICoKKwkJICogQHBhcmFtIHBrZworCQkgKiAgICAgICAgICAgIHRoZSBwa2cKKwkJICogQHBhcmFtIGVudGl0eVBhY2thZ2VJbXBvcnQKKwkJICogICAgICAgICAgICB0aGUgZW50aXR5IHBhY2thZ2UgaW1wb3J0CisJCSAqIEByZXR1cm4gdHJ1ZSwgaWYgc3VjY2Vzc2Z1bAorCQkgKi8KKwkJcHJpdmF0ZSBib29sZWFuIGNvbnRhaW5zSW1wb3J0KExUeXBlZFBhY2thZ2UgcGtnLAorCQkJCVN0cmluZyBlbnRpdHlQYWNrYWdlSW1wb3J0KSB7CisJCQlmb3IgKExJbXBvcnQgbEltcG9ydCA6IHBrZy5nZXRJbXBvcnRzKCkpIHsKKwkJCQlpZiAobEltcG9ydC5nZXRJbXBvcnRlZE5hbWVzcGFjZSgpLmVxdWFscyhlbnRpdHlQYWNrYWdlSW1wb3J0KSkgeworCQkJCQlyZXR1cm4gdHJ1ZTsKKwkJCQl9CisJCQl9CisJCQlyZXR1cm4gZmFsc2U7CisJCX0KKworCQkvKioKKwkJICogUmVtb3ZlcyBhbGwgaW5oZXJpdGVkIGZlYXR1cmVzIGFuZCBhZGRzIHRoZW0gYWdhaW4uCisJCSAqCisJCSAqIEBwYXJhbSBsRHRvCisJCSAqICAgICAgICAgICAgdGhlIGwgZHRvCisJCSAqIEBwYXJhbSBkdG9zCisJCSAqICAgICAgICAgICAgdGhlIGR0b3MKKwkJICovCisJCXByaXZhdGUgdm9pZCBmaXhGZWF0dXJlcyhMRHRvIGxEdG8sIExpc3Q8TFR5cGU+IGR0b3MpIHsKKwkJCXJlbW92ZUFsbEluaGVyaXRlZEZlYXR1cmVzKGxEdG8pOworCQkJYWRkSW5oZXJpdGVkRmVhdHVyZXNGcm9tRW50aXR5KGxEdG8sIGR0b3MpOworCQl9CisKKwkJLyoqCisJCSAqIFJlbW92ZXMgYWxsIGxpdGVyYWxzIGFuZCBhZGQgdGhlbSBhZ2Fpbi4KKwkJICoKKwkJICogQHBhcmFtIGxEdG9FbnVtCisJCSAqICAgICAgICAgICAgdGhlIGwgZHRvIGVudW0KKwkJICovCisJCXByaXZhdGUgdm9pZCBmaXhMaXRlcmFscyhMRW51bSBsRHRvRW51bSkgeworCQkJbER0b0VudW0uZ2V0TGl0ZXJhbHMoKS5jbGVhcigpOworCisJCQlMRW51bSBlbnRpdHlFbnVtID0gKExFbnVtKSBTb3VyY2VUeXBlU3RvcmUuZmluZFNvdXJjZVR5cGUobER0b0VudW0pOworCQkJZm9yIChMRW51bUxpdGVyYWwgbGl0ZXJhbCA6IGVudGl0eUVudW0uZ2V0TGl0ZXJhbHMoKSkgeworCQkJCWxEdG9FbnVtLmdldExpdGVyYWxzKCkuYWRkKEVjb3JlVXRpbC5jb3B5KGxpdGVyYWwpKTsKKwkJCX0KKwkJfQorCisJCS8qKgorCQkgKiBBZGRzIGFsbCBpbmhlcml0ZWQgZmVhdHVyZXMgZnJvbSB0aGUgZW50aXR5IG9yIGJlYW4uCisJCSAqCisJCSAqIEBwYXJhbSBsRHRvCisJCSAqICAgICAgICAgICAgdGhlIGwgZHRvCisJCSAqIEBwYXJhbSBkdG9zCisJCSAqICAgICAgICAgICAgdGhlIGR0b3MKKwkJICovCisJCXByaXZhdGUgdm9pZCBhZGRJbmhlcml0ZWRGZWF0dXJlc0Zyb21FbnRpdHkoTER0byBsRHRvLCBMaXN0PExUeXBlPiBkdG9zKSB7CisJCQlpZiAobER0by5nZXRXcmFwcGVkVHlwZSgpIGluc3RhbmNlb2YgTEVudGl0eSkgeworCQkJCUxFbnRpdHkgY3VycmVudEVudGl0eSA9IChMRW50aXR5KSBsRHRvLmdldFdyYXBwZWRUeXBlKCk7CisJCQkJLy8gbm93IGFkZCBhbGwgZmVhdHVyZXMgZnJvbSB0aGUgZW50aXR5IGFzIGluaGVyaXRlZAorCQkJCS8vIGZlYXR1cmUKKworCQkJCS8vIGFsc28gYWRkIGZlYXR1cmVzIGZyb20gc3VwZXJ0eXBlLCBpZiBkdG8gZG9lcyBub3QKKwkJCQkvLyBleHRlbmQgYW55IGR0by4KKwkJCQlMaXN0PExFbnRpdHlGZWF0dXJlPiBmZWF0dXJlcyA9IGxEdG8uZ2V0U3VwZXJUeXBlKCkgPT0gbnVsbCA/IGN1cnJlbnRFbnRpdHkKKwkJCQkJCS5nZXRBbGxGZWF0dXJlcygpIDogY3VycmVudEVudGl0eS5nZXRGZWF0dXJlcygpOworCQkJCWZvciAoTEVudGl0eUZlYXR1cmUgbEVudGl0eUZlYXR1cmUgOiBmZWF0dXJlcykgeworCQkJCQlpZiAobEVudGl0eUZlYXR1cmUgaW5zdGFuY2VvZiBMRW50aXR5QXR0cmlidXRlKSB7CisJCQkJCQlMRHRvSW5oZXJpdGVkQXR0cmlidXRlIGxOZXdBdHQgPSBPU0JQRHRvRmFjdG9yeS5lSU5TVEFOQ0UKKwkJCQkJCQkJLmNyZWF0ZUxEdG9Jbmhlcml0ZWRBdHRyaWJ1dGUoKTsKKwkJCQkJCWxOZXdBdHQuc2V0SW5oZXJpdGVkRmVhdHVyZSgoTEF0dHJpYnV0ZSkgbEVudGl0eUZlYXR1cmUpOworCQkJCQkJTER0b0ZlYXR1cmUgbEFublRhcmdldCA9IE9TQlBEdG9GYWN0b3J5LmVJTlNUQU5DRQorCQkJCQkJCQkuY3JlYXRlTER0b0ZlYXR1cmUoKTsKKwkJCQkJCWxOZXdBdHQuc2V0QW5ub3RhdGlvbkluZm8obEFublRhcmdldCk7CisJCQkJCQlsRHRvLmdldEZlYXR1cmVzKCkuYWRkKGxOZXdBdHQpOworCQkJCQl9IGVsc2UgaWYgKGxFbnRpdHlGZWF0dXJlIGluc3RhbmNlb2YgTEVudGl0eVJlZmVyZW5jZSkgeworCQkJCQkJLy8gTWFwcGVkIGR0bworCQkJCQkJTER0byBtYXBUb0R0byA9IGdldE1hcFRvRHRvKAorCQkJCQkJCQkoTEVudGl0eVJlZmVyZW5jZSkgbEVudGl0eUZlYXR1cmUsIGR0b3MpOworCQkJCQkJaWYgKG1hcFRvRHRvID09IG51bGwpIHsKKwkJCQkJCQlMT0dHRVIuZXJyb3IoIk5vIE1hcHBpbmctRFRPIGNvdWxkIGJlIGZvdW5kIGZvciAiCisJCQkJCQkJCQkrIGxFbnRpdHlGZWF0dXJlLmdldEVudGl0eSgpKTsKKwkJCQkJCQljb250aW51ZTsKKwkJCQkJCX0KKworCQkJCQkJTER0b0luaGVyaXRlZFJlZmVyZW5jZSBsTmV3UmVmID0gT1NCUER0b0ZhY3RvcnkuZUlOU1RBTkNFCisJCQkJCQkJCS5jcmVhdGVMRHRvSW5oZXJpdGVkUmVmZXJlbmNlKCk7CisJCQkJCQlsTmV3UmVmLnNldEluaGVyaXRlZEZlYXR1cmUoKExSZWZlcmVuY2UpIGxFbnRpdHlGZWF0dXJlKTsKKwkJCQkJCUxEdG9GZWF0dXJlIGxBbm5UYXJnZXQgPSBPU0JQRHRvRmFjdG9yeS5lSU5TVEFOQ0UKKwkJCQkJCQkJLmNyZWF0ZUxEdG9GZWF0dXJlKCk7CisJCQkJCQlsTmV3UmVmLnNldEFubm90YXRpb25JbmZvKGxBbm5UYXJnZXQpOworCQkJCQkJbER0by5nZXRGZWF0dXJlcygpLmFkZChsTmV3UmVmKTsKKwkJCQkJCWxOZXdSZWYuc2V0VHlwZShtYXBUb0R0byk7CisJCQkJCX0KKwkJCQl9CisJCQl9IGVsc2UgaWYgKGxEdG8uZ2V0V3JhcHBlZFR5cGUoKSBpbnN0YW5jZW9mIExCZWFuKSB7CisJCQkJTEJlYW4gY3VycmVudEJlYW4gPSAoTEJlYW4pIGxEdG8uZ2V0V3JhcHBlZFR5cGUoKTsKKwkJCQkvLyBub3cgYWRkIGFsbCBmZWF0dXJlcyBmcm9tIHRoZSBlbnRpdHkgYXMgaW5oZXJpdGVkCisJCQkJLy8gZmVhdHVyZQorCisJCQkJLy8gYWxzbyBhZGQgZmVhdHVyZXMgZnJvbSBzdXBlcnR5cGUsIGlmIGR0byBkb2VzIG5vdAorCQkJCS8vIGV4dGVuZCBhbnkgZHRvLgorCQkJCUxpc3Q8TEJlYW5GZWF0dXJlPiBmZWF0dXJlcyA9IGxEdG8uZ2V0U3VwZXJUeXBlKCkgPT0gbnVsbCA/IGN1cnJlbnRCZWFuCisJCQkJCQkuZ2V0QWxsRmVhdHVyZXMoKSA6IGN1cnJlbnRCZWFuLmdldEZlYXR1cmVzKCk7CisJCQkJZm9yIChMQmVhbkZlYXR1cmUgbEJlYW5GZWF0dXJlIDogZmVhdHVyZXMpIHsKKwkJCQkJaWYgKGxCZWFuRmVhdHVyZSBpbnN0YW5jZW9mIExCZWFuQXR0cmlidXRlKSB7CisJCQkJCQlMRHRvSW5oZXJpdGVkQXR0cmlidXRlIGxOZXdBdHQgPSBPU0JQRHRvRmFjdG9yeS5lSU5TVEFOQ0UKKwkJCQkJCQkJLmNyZWF0ZUxEdG9Jbmhlcml0ZWRBdHRyaWJ1dGUoKTsKKwkJCQkJCWxOZXdBdHQuc2V0SW5oZXJpdGVkRmVhdHVyZSgoTEF0dHJpYnV0ZSkgbEJlYW5GZWF0dXJlKTsKKwkJCQkJCUxEdG9GZWF0dXJlIGxBbm5UYXJnZXQgPSBPU0JQRHRvRmFjdG9yeS5lSU5TVEFOQ0UKKwkJCQkJCQkJLmNyZWF0ZUxEdG9GZWF0dXJlKCk7CisJCQkJCQlsTmV3QXR0LnNldEFubm90YXRpb25JbmZvKGxBbm5UYXJnZXQpOworCQkJCQkJbER0by5nZXRGZWF0dXJlcygpLmFkZChsTmV3QXR0KTsKKwkJCQkJfSBlbHNlIGlmIChsQmVhbkZlYXR1cmUgaW5zdGFuY2VvZiBMRW50aXR5UmVmZXJlbmNlKSB7CisJCQkJCQlMRHRvIG1hcFRvRHRvID0gZ2V0TWFwVG9EdG8oCisJCQkJCQkJCShMRW50aXR5UmVmZXJlbmNlKSBsQmVhbkZlYXR1cmUsIGR0b3MpOworCQkJCQkJaWYgKG1hcFRvRHRvID09IG51bGwpIHsKKwkJCQkJCQlMT0dHRVIuZXJyb3IoIk5vIE1hcHBpbmctRFRPIGNvdWxkIGJlIGZvdW5kIGZvciAiCisJCQkJCQkJCQkrIGxCZWFuRmVhdHVyZS5nZXRCZWFuKCkpOworCQkJCQkJCWNvbnRpbnVlOworCQkJCQkJfQorCisJCQkJCQlMRHRvSW5oZXJpdGVkUmVmZXJlbmNlIGxOZXdSZWYgPSBPU0JQRHRvRmFjdG9yeS5lSU5TVEFOQ0UKKwkJCQkJCQkJLmNyZWF0ZUxEdG9Jbmhlcml0ZWRSZWZlcmVuY2UoKTsKKwkJCQkJCWxOZXdSZWYuc2V0SW5oZXJpdGVkRmVhdHVyZSgoTFJlZmVyZW5jZSkgbEJlYW5GZWF0dXJlKTsKKwkJCQkJCUxEdG9GZWF0dXJlIGxBbm5UYXJnZXQgPSBPU0JQRHRvRmFjdG9yeS5lSU5TVEFOQ0UKKwkJCQkJCQkJLmNyZWF0ZUxEdG9GZWF0dXJlKCk7CisJCQkJCQlsTmV3UmVmLnNldEFubm90YXRpb25JbmZvKGxBbm5UYXJnZXQpOworCQkJCQkJbER0by5nZXRGZWF0dXJlcygpLmFkZChsTmV3UmVmKTsKKwkJCQkJCWxOZXdSZWYuc2V0VHlwZShtYXBUb0R0byk7CisJCQkJCX0gZWxzZSBpZiAobEJlYW5GZWF0dXJlIGluc3RhbmNlb2YgTEJlYW5SZWZlcmVuY2UpIHsKKwkJCQkJCUxEdG8gbWFwVG9EdG8gPSBnZXRNYXBUb0R0bygKKwkJCQkJCQkJKExCZWFuUmVmZXJlbmNlKSBsQmVhbkZlYXR1cmUsIGR0b3MpOworCQkJCQkJaWYgKG1hcFRvRHRvID09IG51bGwpIHsKKwkJCQkJCQlMT0dHRVIuZXJyb3IoIk5vIE1hcHBpbmctRFRPIGNvdWxkIGJlIGZvdW5kIGZvciAiCisJCQkJCQkJCQkrIGxCZWFuRmVhdHVyZS5nZXRCZWFuKCkpOworCQkJCQkJCWNvbnRpbnVlOworCQkJCQkJfQorCisJCQkJCQlMRHRvSW5oZXJpdGVkUmVmZXJlbmNlIGxOZXdSZWYgPSBPU0JQRHRvRmFjdG9yeS5lSU5TVEFOQ0UKKwkJCQkJCQkJLmNyZWF0ZUxEdG9Jbmhlcml0ZWRSZWZlcmVuY2UoKTsKKwkJCQkJCWxOZXdSZWYuc2V0SW5oZXJpdGVkRmVhdHVyZSgoTFJlZmVyZW5jZSkgbEJlYW5GZWF0dXJlKTsKKwkJCQkJCUxEdG9GZWF0dXJlIGxBbm5UYXJnZXQgPSBPU0JQRHRvRmFjdG9yeS5lSU5TVEFOQ0UKKwkJCQkJCQkJLmNyZWF0ZUxEdG9GZWF0dXJlKCk7CisJCQkJCQlsTmV3UmVmLnNldEFubm90YXRpb25JbmZvKGxBbm5UYXJnZXQpOworCQkJCQkJbER0by5nZXRGZWF0dXJlcygpLmFkZChsTmV3UmVmKTsKKwkJCQkJCWxOZXdSZWYuc2V0VHlwZShtYXBUb0R0byk7CisJCQkJCX0KKwkJCQl9CisJCQl9CisJCX0KKworCQkvKioKKwkJICogUmVtb3ZlcyBhbGwgaW5oZXJpdGVkIGZlYXR1cmVzLgorCQkgKgorCQkgKiBAcGFyYW0gbER0bworCQkgKiAgICAgICAgICAgIHRoZSBsIGR0bworCQkgKi8KKwkJcHJpdmF0ZSB2b2lkIHJlbW92ZUFsbEluaGVyaXRlZEZlYXR1cmVzKExEdG8gbER0bykgeworCQkJZm9yIChJdGVyYXRvcjxMRHRvRmVhdHVyZT4gaXRlcmF0b3IgPSBsRHRvLmdldEZlYXR1cmVzKCkuaXRlcmF0b3IoKTsgaXRlcmF0b3IKKwkJCQkJLmhhc05leHQoKTspIHsKKwkJCQlMRHRvRmVhdHVyZSBsRmVhdHVyZSA9IGl0ZXJhdG9yLm5leHQoKTsKKwkJCQlpZiAoKGxGZWF0dXJlIGluc3RhbmNlb2YgTER0b0luaGVyaXRlZEF0dHJpYnV0ZSkKKwkJCQkJCXx8IChsRmVhdHVyZSBpbnN0YW5jZW9mIExEdG9Jbmhlcml0ZWRSZWZlcmVuY2UpKSB7CisJCQkJCWl0ZXJhdG9yLnJlbW92ZSgpOworCQkJCX0KKwkJCX0KKwkJfQorCisJCS8qKgorCQkgKiBHZXRzIHRoZSBwcm9qZWN0IHJlc291cmNlIHNldC4KKwkJICoKKwkJICogQHBhcmFtIHVyaQorCQkgKiAgICAgICAgICAgIHRoZSB1cmkKKwkJICogQHJldHVybiB0aGUgcHJvamVjdCByZXNvdXJjZSBzZXQKKwkJICovCisJCXByaXZhdGUgWHRleHRSZXNvdXJjZVNldCBnZXRQcm9qZWN0UmVzb3VyY2VTZXQoVVJJIHVyaSkgeworCQkJSVByb2plY3QgZHRvUHJvamVjdCA9IG51bGw7CisJCQlJdGVyYWJsZTxQYWlyPElTdG9yYWdlLCBJUHJvamVjdD4+IHBhaXJzID0gdXJpU3RvcmFnZU1hcHBlcgorCQkJCQkuZ2V0U3RvcmFnZXModXJpKTsKKwkJCWlmIChwYWlycy5pdGVyYXRvcigpLmhhc05leHQoKSkgeworCQkJCWR0b1Byb2plY3QgPSBwYWlycy5pdGVyYXRvcigpLm5leHQoKS5nZXRTZWNvbmQoKTsKKwkJCX0KKworCQkJaWYgKGR0b1Byb2plY3QgPT0gbnVsbCkgeworCQkJCUxPR0dFUi5lcnJvcigiTm8gcHJvamVjdCBjb3VsZCBiZSBmb3VuZCBmb3IgIiArIHVyaSk7CisJCQkJcmV0dXJuIG51bGw7CisJCQl9CisKKwkJCVh0ZXh0UmVzb3VyY2VTZXQgcmVzb3VyY2VTZXQgPSAoWHRleHRSZXNvdXJjZVNldCkgcnNQcm92aWRlcgorCQkJCQkuZ2V0KGR0b1Byb2plY3QpOworCQkJcmV0dXJuIHJlc291cmNlU2V0OworCQl9CisKKwkJLyoqCisJCSAqIEZpbmQgZW50aXR5IHVyIGlzLgorCQkgKgorCQkgKiBAcGFyYW0gbEVudGl0eU1vZGVsCisJCSAqICAgICAgICAgICAgdGhlIGwgZW50aXR5IG1vZGVsCisJCSAqIEByZXR1cm4gdGhlIHNldHMgdGhlCisJCSAqLworCQlwcml2YXRlIFNldDxVUkk+IGZpbmRFbnRpdHlVUklzKExFbnRpdHlNb2RlbCBsRW50aXR5TW9kZWwpIHsKKwkJCVNldDxVUkk+IGVudGl0eVVSSXMgPSBuZXcgSGFzaFNldDxVUkk+KCk7CisJCQlmb3IgKExUeXBlZFBhY2thZ2UgbFBrZyA6IGxFbnRpdHlNb2RlbC5nZXRQYWNrYWdlcygpKSB7CisJCQkJZm9yIChMVHlwZSBsVHlwZSA6IGxQa2cuZ2V0VHlwZXMoKSkgeworCQkJCQlpZiAobFR5cGUgaW5zdGFuY2VvZiBMRW50aXR5IHx8IGxUeXBlIGluc3RhbmNlb2YgTEJlYW4pIHsKKwkJCQkJCWVudGl0eVVSSXMuYWRkKEVjb3JlVXRpbC5nZXRVUkkobFR5cGUpKTsKKwkJCQkJfQorCQkJCX0KKwkJCX0KKwkJCXJldHVybiBlbnRpdHlVUklzOworCQl9CisKKwkJLyoqCisJCSAqIENvbGxlY3QgZW50aXRpZXMuCisJCSAqCisJCSAqIEBwYXJhbSBsRW50aXR5TW9kZWwKKwkJICogICAgICAgICAgICB0aGUgbCBlbnRpdHkgbW9kZWwKKwkJICogQHJldHVybiB0aGUgbGlzdAorCQkgKi8KKwkJcHJpdmF0ZSBMaXN0PExUeXBlPiBjb2xsZWN0RW50aXRpZXMoTEVudGl0eU1vZGVsIGxFbnRpdHlNb2RlbCkgeworCQkJTGlzdDxMVHlwZT4gZW50aXRpZXMgPSBuZXcgQXJyYXlMaXN0PExUeXBlPigpOworCQkJZm9yIChMVHlwZWRQYWNrYWdlIGxQa2cgOiBsRW50aXR5TW9kZWwuZ2V0UGFja2FnZXMoKSkgeworCQkJCWZvciAoTFR5cGUgbFR5cGUgOiBsUGtnLmdldFR5cGVzKCkpIHsKKwkJCQkJaWYgKGxUeXBlIGluc3RhbmNlb2YgTEVudGl0eSB8fCBsVHlwZSBpbnN0YW5jZW9mIExCZWFuCisJCQkJCQkJfHwgbFR5cGUgaW5zdGFuY2VvZiBMRW51bSkgeworCQkJCQkJZW50aXRpZXMuYWRkKGxUeXBlKTsKKwkJCQkJfQorCQkJCX0KKwkJCX0KKwkJCXJldHVybiBlbnRpdGllczsKKwkJfQorCisJCS8qKgorCQkgKiBDb2xsZWN0IGR0b3MuCisJCSAqCisJCSAqIEBwYXJhbSBsRHRvTW9kZWwKKwkJICogICAgICAgICAgICB0aGUgbCBkdG8gbW9kZWwKKwkJICogQHJldHVybiB0aGUgbGlzdAorCQkgKi8KKwkJcHJpdmF0ZSBMaXN0PExUeXBlPiBjb2xsZWN0RHRvcyhMRHRvTW9kZWwgbER0b01vZGVsKSB7CisJCQlMaXN0PExUeXBlPiBkdG9zID0gbmV3IEFycmF5TGlzdDxMVHlwZT4oKTsKKwkJCWZvciAoTFR5cGVkUGFja2FnZSBsUGtnIDogbER0b01vZGVsLmdldFBhY2thZ2VzKCkpIHsKKwkJCQlmb3IgKExUeXBlIGxUeXBlIDogbFBrZy5nZXRUeXBlcygpKSB7CisJCQkJCWlmIChsVHlwZSBpbnN0YW5jZW9mIExEdG8pIHsKKwkJCQkJCUxEdG8gbER0byA9IChMRHRvKSBsVHlwZTsKKwkJCQkJCWlmIChsRHRvLmdldFdyYXBwZWRUeXBlKCkgIT0gbnVsbCkgeworCQkJCQkJCWR0b3MuYWRkKGxUeXBlKTsKKwkJCQkJCX0KKwkJCQkJfSBlbHNlIGlmIChsVHlwZSBpbnN0YW5jZW9mIExFbnVtKSB7CisJCQkJCQlkdG9zLmFkZChsVHlwZSk7CisJCQkJCX0KKwkJCQl9CisJCQl9CisJCQlyZXR1cm4gZHRvczsKKwkJfQorCisJCS8qKgorCQkgKiBGaW5kIHRhcmdldCBkdG8gcmVmZXJlbmNlcy4KKwkJICoKKwkJICogQHBhcmFtIGVudGl0eVVSSXMKKwkJICogICAgICAgICAgICB0aGUgZW50aXR5IHVyIGlzCisJCSAqIEBwYXJhbSByZXNvdXJjZVNldAorCQkgKiAgICAgICAgICAgIHRoZSByZXNvdXJjZSBzZXQKKwkJICogQHJldHVybiB0aGUgbGlzdAorCQkgKi8KKwkJcHJpdmF0ZSBMaXN0PElSZWZlcmVuY2VEZXNjcmlwdGlvbj4gZmluZFRhcmdldER0b1JlZmVyZW5jZXMoCisJCQkJU2V0PFVSST4gZW50aXR5VVJJcywgUmVzb3VyY2VTZXQgcmVzb3VyY2VTZXQpIHsKKwkJCWZpbmFsIExpc3Q8SVJlZmVyZW5jZURlc2NyaXB0aW9uPiB0YXJnZXREdG9SZWZlcmVuY2VzID0gbmV3IEFycmF5TGlzdDxJUmVmZXJlbmNlRGVzY3JpcHRpb24+KCk7CisJCQlyZWZlcmVuY2VGaW5kZXIuZmluZEFsbFJlZmVyZW5jZXMoZW50aXR5VVJJcywKKwkJCQkJbmV3IExvY2FsUmVzb3VyY2VBY2Nlc3MocmVzb3VyY2VTZXQpLAorCQkJCQluZXcgSUFjY2VwdG9yPElSZWZlcmVuY2VEZXNjcmlwdGlvbj4oKSB7CisJCQkJCQlAT3ZlcnJpZGUKKwkJCQkJCXB1YmxpYyB2b2lkIGFjY2VwdChJUmVmZXJlbmNlRGVzY3JpcHRpb24gdCkgeworCQkJCQkJCWlmICh0LmdldEVSZWZlcmVuY2UoKSA9PSBPU0JQRHRvUGFja2FnZS5MaXRlcmFscy5MRFRPX19XUkFQUEVEX1RZUEUpIHsKKwkJCQkJCQkJdGFyZ2V0RHRvUmVmZXJlbmNlcy5hZGQodCk7CisJCQkJCQkJfQorCQkJCQkJfQorCQkJCQl9LCBudWxsKTsKKwkJCXJldHVybiB0YXJnZXREdG9SZWZlcmVuY2VzOworCQl9CisKKwkJLy8gQFN1cHByZXNzV2FybmluZ3MoInJlc3RyaWN0aW9uIikKKwkJLy8gcHJpdmF0ZSBMaXN0PElSZWZlcmVuY2VEZXNjcmlwdGlvbj4gZmluZFRhcmdldFVpTW9kZWxSZWZlcmVuY2VzKAorCQkvLyBTZXQ8VVJJPiBlbnRpdHlVUklzKSB7CisJCS8vIGZpbmFsIExpc3Q8SVJlZmVyZW5jZURlc2NyaXB0aW9uPiB0YXJnZXRVaU1vZGVsUmVmZXJlbmNlcyA9IG5ldworCQkvLyBBcnJheUxpc3Q8SVJlZmVyZW5jZURlc2NyaXB0aW9uPigpOworCQkvLyByZWZlcmVuY2VGaW5kZXIuZmluZEFsbFJlZmVyZW5jZXMoZW50aXR5VVJJcywgbnVsbCwKKwkJLy8gbmV3IElBY2NlcHRvcjxJUmVmZXJlbmNlRGVzY3JpcHRpb24+KCkgeworCQkvLyBAT3ZlcnJpZGUKKwkJLy8gcHVibGljIHZvaWQgYWNjZXB0KElSZWZlcmVuY2VEZXNjcmlwdGlvbiB0KSB7CisJCS8vIGlmICh0LmdldEVSZWZlcmVuY2UoKSA9PQorCQkvLyBVaU1vZGVsUGFja2FnZS5MaXRlcmFscy5VSV9CRUFOX1NMT1RfX0pWTV9UWVBFKQorCQkvLyB7CisJCS8vIHRhcmdldFVpTW9kZWxSZWZlcmVuY2VzLmFkZCh0KTsKKwkJLy8gfQorCQkvLyB9CisJCS8vIH0sIG51bGwpOworCQkvLyByZXR1cm4gdGFyZ2V0VWlNb2RlbFJlZmVyZW5jZXM7CisJCS8vIH0KKworCQkvKioKKwkJICogUmV0dXJucyB0aGUgbWFwcGVkIERUTyBvciA8Y29kZT5udWxsPC9jb2RlPi4KKwkJICoKKwkJICogQHBhcmFtIGxFbnRpdHlGZWF0dXJlCisJCSAqICAgICAgICAgICAgdGhlIGwgZW50aXR5IGZlYXR1cmUKKwkJICogQHBhcmFtIGR0b3MKKwkJICogICAgICAgICAgICB0aGUgZHRvcworCQkgKiBAcmV0dXJuIHRoZSBtYXAgdG8gZHRvCisJCSAqLworCQlwcml2YXRlIExEdG8gZ2V0TWFwVG9EdG8oTEVudGl0eVJlZmVyZW5jZSBsRW50aXR5RmVhdHVyZSwKKwkJCQlMaXN0PExUeXBlPiBkdG9zKSB7CisJCQlMRW50aXR5IGVudGl0eSA9IGxFbnRpdHlGZWF0dXJlLmdldFR5cGUoKTsKKwkJCXJldHVybiAoTER0bykgZmluZER0b1R5cGUoZW50aXR5LCBkdG9zKTsKKwkJfQorCisJCS8qKgorCQkgKiBSZXR1cm5zIHRoZSBtYXBwZWQgRFRPIG9yIDxjb2RlPm51bGw8L2NvZGU+LgorCQkgKgorCQkgKiBAcGFyYW0gbEVudGl0eUZlYXR1cmUKKwkJICogICAgICAgICAgICB0aGUgbCBlbnRpdHkgZmVhdHVyZQorCQkgKiBAcGFyYW0gZHRvcworCQkgKiAgICAgICAgICAgIHRoZSBkdG9zCisJCSAqIEByZXR1cm4gdGhlIG1hcCB0byBkdG8KKwkJICovCisJCS8vIHByaXZhdGUgTER0byBnZXRNYXBUb0R0byhMQmVhblJlZmVyZW5jZSBsRW50aXR5RmVhdHVyZSwgTGlzdDxMVHlwZT4KKwkJLy8gZHRvcykgeworCQkvLyBMRW50aXR5IGVudGl0eSA9IChMRW50aXR5KSBsRW50aXR5RmVhdHVyZS5nZXRUeXBlKCk7CisJCS8vIHJldHVybiAoTER0bykgZmluZER0b1R5cGUoZW50aXR5LCBkdG9zKTsKKwkJLy8gfQorCQlwcml2YXRlIExEdG8gZ2V0TWFwVG9EdG8oTEJlYW5SZWZlcmVuY2UgbEVudGl0eUZlYXR1cmUsIExpc3Q8TFR5cGU+IGR0b3MpIHsKKwkJCUxUeXBlIGVudGl0eSA9IChMVHlwZSkgbEVudGl0eUZlYXR1cmUuZ2V0VHlwZSgpOworCQkJcmV0dXJuIChMRHRvKSBmaW5kRHRvVHlwZShlbnRpdHksIGR0b3MpOworCQl9CisKKwkJLyoqCisJCSAqIExvYWQgc2VtYW50aWMgbW9kZWwuCisJCSAqCisJCSAqIEBwYXJhbSA8QT4KKwkJICogICAgICAgICAgICB0aGUgZ2VuZXJpYyB0eXBlCisJCSAqIEBwYXJhbSBtb2RlbFVSSQorCQkgKiAgICAgICAgICAgIHRoZSBtb2RlbCB1cmkKKwkJICogQHJldHVybiB0aGUgYQorCQkgKi8KKwkJQFN1cHByZXNzV2FybmluZ3MoInVuY2hlY2tlZCIpCisJCXByaXZhdGUgPEEgZXh0ZW5kcyBFT2JqZWN0PiBBIGxvYWRTZW1hbnRpY01vZGVsKFVSSSBtb2RlbFVSSSkgeworCQkJLy8gTE9HR0VSLmluZm8oImxvYWRpbmc6IiArIGZpbGUuZ2V0TmFtZSgpKTsKKwkJCS8vIG9yZy5lY2xpcHNlLmVtZi5jb21tb24udXRpbC5VUkkgbW9kZWxVUkkgPQorCQkJLy8gb3JnLmVjbGlwc2UuZW1mLmNvbW1vbi51dGlsLlVSSQorCQkJLy8gLmNyZWF0ZVBsYXRmb3JtUmVzb3VyY2VVUkkoZmlsZS5nZXRGdWxsUGF0aCgpLnRvU3RyaW5nKCksCisJCQkvLyBmYWxzZSk7CisJCQlYdGV4dFJlc291cmNlU2V0IHJzID0gKFh0ZXh0UmVzb3VyY2VTZXQpIHJzUHJvdmlkZXIKKwkJCQkJLmdldChnZXRQcm9qZWN0KCkpOworCQkJUmVzb3VyY2UgcmVzb3VyY2UgPSBycy5nZXRSZXNvdXJjZShtb2RlbFVSSSwgdHJ1ZSk7CisJCQl0cnkgeworCQkJCXJlc291cmNlLmxvYWQobnVsbCk7CisJCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBlKSB7CisJCQkJZS5wcmludFN0YWNrVHJhY2UoKTsKKwkJCQlyZXR1cm4gbnVsbDsKKwkJCX0KKwkJCUEgc2VtYW50aWNNb2RlbCA9IG51bGw7CisJCQlpZiAocmVzb3VyY2UgaW5zdGFuY2VvZiBJU2VtYW50aWNMb2FkaW5nUmVzb3VyY2UpIHsKKwkJCQlzZW1hbnRpY01vZGVsID0gKEEpICgoSVNlbWFudGljTG9hZGluZ1Jlc291cmNlKSByZXNvdXJjZSkKKwkJCQkJCS5nZXRTZW1hbnRpY0VsZW1lbnQoKTsKKwkJCX0gZWxzZSB7CisJCQkJc2VtYW50aWNNb2RlbCA9IChBKSByZXNvdXJjZS5nZXRDb250ZW50cygpLmdldCgwKTsKKwkJCX0KKworCQkJLy8gTE9HR0VSLmluZm8oImZpbmlzaGVkIGxvYWRpbmc6IiArIG1vZGVsVVJJLmdldE5hbWUoKSk7CisJCQlyZXR1cm4gc2VtYW50aWNNb2RlbDsKKwkJfQorCX0KKworCS8qKgorCSAqIFRoZSBDbGFzcyBTZXJ2aWNlRW5oYW5jZXIuCisJICovCisJcHVibGljIGNsYXNzIFNlcnZpY2VFbmhhbmNlciB7CisKKwkJLyoqCisJCSAqIFRoZSBDbGFzcyBTZXJ2aWNlRW5oYW5jZXJDb250ZXh0LgorCQkgKi8KKwkJcHJpdmF0ZSBjbGFzcyBTZXJ2aWNlRW5oYW5jZXJDb250ZXh0IHsKKworCQkJLyoqIFRoZSBzZXJ2aWNlIHJlc291cmNlLiAqLworCQkJcHJpdmF0ZSBJU2VtYW50aWNMb2FkaW5nUmVzb3VyY2Ugc2VydmljZVJlc291cmNlOworCisJCQkvKiogVGhlIHdyaXRlYWJsZSByZXNvdXJjZSBzZXQuICovCisJCQlwcml2YXRlIFJlc291cmNlU2V0IHdyaXRlYWJsZVJlc291cmNlU2V0OworCQl9CisKKwkJLyoqIFRoZSBycyBwcm92aWRlci4gKi8KKwkJQEluamVjdAorCQlwcml2YXRlIFh0ZXh0UmVzb3VyY2VTZXRQcm92aWRlciByc1Byb3ZpZGVyOworCisJCS8qKiBUaGUgcmVmZXJlbmNlIGZpbmRlci4gKi8KKwkJQEluamVjdAorCQlwcml2YXRlIElSZWZlcmVuY2VGaW5kZXIgcmVmZXJlbmNlRmluZGVyOworCisJCS8qKiBUaGUgdXJpIHN0b3JhZ2UgbWFwcGVyLiAqLworCQlASW5qZWN0CisJCXByaXZhdGUgSVN0b3JhZ2UyVXJpTWFwcGVyIHVyaVN0b3JhZ2VNYXBwZXI7CisKKwkJLyoqCisJCSAqIEluc3RhbnRpYXRlcyBhIG5ldyBzZXJ2aWNlIGVuaGFuY2VyLgorCQkgKi8KKwkJcHVibGljIFNlcnZpY2VFbmhhbmNlcigpIHsKKworCQl9CisKKwkJLyoqCisJCSAqIFRoaXMgbWV0aG9kIHRvdWNoZXMgVUkgYW5kIGRpYWxvZyBtb2RlbHMgdG8gZW5zdXJlIHRoYXQgdGhlCisJCSAqIEF1dG93aXJlSGVscGVyIGlzIGV4ZWN1dGVkLgorCQkgKgorCQkgKiBAcGFyYW0gdGVtcExEdG9Nb2RlbAorCQkgKiAgICAgICAgICAgIHRoZSB0ZW1wIGwgZHRvIG1vZGVsCisJCSAqLworCQlwdWJsaWMgdm9pZCBidWlsZFVpQW5kRGlhbG9nTW9kZWxzKExEdG9Nb2RlbCB0ZW1wTER0b01vZGVsKSB7CisKKwkJCVRpbWVMb2dnZXIgdGltZUxvZ2dlciA9IFRpbWVMb2dnZXIuc3RhcnQoZ2V0Q2xhc3MoKSk7CisKKwkJCS8vIGZpbmQgcmVmZXJlbmNpbmcgZHRvIG1vZGVsCisJCQlTZXQ8VVJJPiBkdG9VUklzID0gZmluZER0b0p2bVR5cGVVUklzKHRlbXBMRHRvTW9kZWwpOworCQkJZmluYWwgU2V0PFVSST4gdWlNb2RlbFVSSXMgPSBmaW5kVGFyZ2V0VWlBbmREaWFsb2dNb2RlbFJlZmVyZW5jZXMoCisJCQkJCWR0b1VSSXMsIHRlbXBMRHRvTW9kZWwuZVJlc291cmNlKCkuZ2V0UmVzb3VyY2VTZXQoKSk7CisJCQlpZiAodWlNb2RlbFVSSXMuaXNFbXB0eSgpKSB7CisJCQkJcmV0dXJuOworCQkJfQorCisJCQlNYXA8VVJJLCBYdGV4dFJlc291cmNlU2V0PiByZXNvdXJjZVNldHMgPSBnZXRQcm9qZWN0UmVzb3VyY2VTZXRNYXAodWlNb2RlbFVSSXMpOworCQkJZm9yIChVUkkgdWlNb2RlbFVSSSA6IHVpTW9kZWxVUklzKSB7CisJCQkJLy8gY3JlYXRlIHRoZSBwcm9wZXIgZHRvIHJlc291cmNlU2V0IHRvIHNhdmUgdGhlIGR0bworCQkJCVJlc291cmNlU2V0IHdyaXRlYWJsZVJlc291cmNlU2V0ID0gcmVzb3VyY2VTZXRzLmdldCh1aU1vZGVsVVJJKTsKKwkJCQlpZiAod3JpdGVhYmxlUmVzb3VyY2VTZXQgPT0gbnVsbCkgeworCQkJCQlMT0dHRVIuZXJyb3IoCisJCQkJCQkJIkNhbiBub3Qgc2F2ZSB7fSBzaW5jZSByZXNvdXJjZSBzZXQgbm90IGF2YWlsYWJsZSIsCisJCQkJCQkJdWlNb2RlbFVSSSk7CisJCQkJCWNvbnRpbnVlOworCQkJCX0KKworCQkJCVJlc291cmNlIHVpTW9kZWxSZXNvdXJjZSA9IChSZXNvdXJjZSkgd3JpdGVhYmxlUmVzb3VyY2VTZXQKKwkJCQkJCS5nZXRSZXNvdXJjZSh1aU1vZGVsVVJJLCB0cnVlKTsKKwkJCQkvLyBlbnN1cmVzIHRoYXQgdGhlIGluZmVycmVyIGlzIGludm9rZWQKKwkJCQl1aU1vZGVsUmVzb3VyY2UuZ2V0Q29udGVudHMoKTsKKwkJCQl0cnkgeworCQkJCQlEaWFnbm9zdGljIGRpYWdub3N0aWMgPSBEaWFnbm9zdGljaWFuLklOU1RBTkNFCisJCQkJCQkJLnZhbGlkYXRlKHVpTW9kZWxSZXNvdXJjZS5nZXRDb250ZW50cygpLmdldCgwKSk7CisJCQkJCWludCBzZXYgPSBkaWFnbm9zdGljLmdldFNldmVyaXR5KCk7CisJCQkJCWlmIChzZXYgPD0gRGlhZ25vc3RpYy5XQVJOSU5HKSB7CisJCQkJCQl1aU1vZGVsUmVzb3VyY2Uuc2F2ZShTYXZlT3B0aW9ucy5uZXdCdWlsZGVyKCkuZm9ybWF0KCkKKwkJCQkJCQkJLmdldE9wdGlvbnMoKS50b09wdGlvbnNNYXAoKSk7CisJCQkJCX0gZWxzZSB7CisJCQkJCQlMT0dHRVIuZXJyb3IodWlNb2RlbFJlc291cmNlLmdldEVycm9ycygpLmdldCgwKQorCQkJCQkJCQkudG9TdHJpbmcoKSk7CisJCQkJCX0KKwkJCQkJdWlNb2RlbFJlc291cmNlLnVubG9hZCgpOworCQkJCX0gY2F0Y2ggKElPRXhjZXB0aW9uIGUpIHsKKwkJCQkJTE9HR0VSLmVycm9yKCJ7fSIsIGUpOworCQkJCX0KKwkJCX0KKworCQkJdGltZUxvZ2dlci5zdG9wKExPR0dFUiwKKwkJCQkJIkZpbmlzaGVkIE9TQlBTZXJ2aWNlQnVpbGRlciNidWlsZFVpTW9kZWxzIGluICIpOworCQl9CisKKwkJLyoqCisJCSAqIEZpbmRzIGFsbCB0YXJnZXQgdWkgbW9kZWxzIHRoYXQgaGF2ZSBhIHJlZmVyZW5jZSB0byBvbmUgb2YgdGhlIGdpdmVuCisJCSAqIGR0byBKdm1UeXBlcy4KKwkJICoKKwkJICogQHBhcmFtIGR0b0p2bVR5cGVVUklzCisJCSAqICAgICAgICAgICAgdGhlIGR0byBqdm0gdHlwZSB1ciBpcworCQkgKiBAcGFyYW0gcmVzb3VyY2VTZXQKKwkJICogICAgICAgICAgICB0aGUgcmVzb3VyY2Ugc2V0CisJCSAqIEByZXR1cm4gdGhlIHNldHMgdGhlCisJCSAqLworCQlwcml2YXRlIFNldDxVUkk+IGZpbmRUYXJnZXRVaUFuZERpYWxvZ01vZGVsUmVmZXJlbmNlcygKKwkJCQlTZXQ8VVJJPiBkdG9Kdm1UeXBlVVJJcywgUmVzb3VyY2VTZXQgcmVzb3VyY2VTZXQpIHsKKwkJCWZpbmFsIFNldDxVUkk+IHRhcmdldFVpTW9kZWxSZWZlcmVuY2VzID0gbmV3IEhhc2hTZXQ8PigpOworCQkJcmVmZXJlbmNlRmluZGVyLmZpbmRBbGxSZWZlcmVuY2VzKGR0b0p2bVR5cGVVUklzLAorCQkJCQluZXcgTG9jYWxSZXNvdXJjZUFjY2VzcyhyZXNvdXJjZVNldCksCisJCQkJCW5ldyBJQWNjZXB0b3I8SVJlZmVyZW5jZURlc2NyaXB0aW9uPigpIHsKKwkJCQkJCUBPdmVycmlkZQorCQkJCQkJcHVibGljIHZvaWQgYWNjZXB0KElSZWZlcmVuY2VEZXNjcmlwdGlvbiB0KSB7CisJCQkJCQkJaWYgKHQuZ2V0U291cmNlRU9iamVjdFVyaSgpLmZpbGVFeHRlbnNpb24oKQorCQkJCQkJCQkJLmVxdWFscygidWkiKQorCQkJCQkJCQkJfHwgdC5nZXRTb3VyY2VFT2JqZWN0VXJpKCkuZmlsZUV4dGVuc2lvbigpCisJCQkJCQkJCQkJCS5lcXVhbHMoImRpYWxvZyIpKSB7CisJCQkJCQkJCXRhcmdldFVpTW9kZWxSZWZlcmVuY2VzLmFkZCh0CisJCQkJCQkJCQkJLmdldENvbnRhaW5lckVPYmplY3RVUkkoKQorCQkJCQkJCQkJCS50cmltRnJhZ21lbnQoKSk7CisJCQkJCQkJfQorCQkJCQkJfQorCQkJCQl9LCBudWxsKTsKKwkJCXJldHVybiB0YXJnZXRVaU1vZGVsUmVmZXJlbmNlczsKKwkJfQorCisJCS8qKgorCQkgKiBCdWlsZHMgdGhlIHNlcnZpY2VzLgorCQkgKgorCQkgKiBAcGFyYW0gdGVtcExEdG9Nb2RlbAorCQkgKiAgICAgICAgICAgIHRoZSB0ZW1wIGwgZHRvIG1vZGVsCisJCSAqLworCQlwdWJsaWMgdm9pZCBidWlsZFNlcnZpY2VzKExEdG9Nb2RlbCB0ZW1wTER0b01vZGVsKSB7CisJCQlJWHRleHRVdGlsU2VydmljZSBzZXJ2aWNlID0gQ29yZVVpQWN0aXZhdG9yLmdldERlZmF1bHQoKQorCQkJCQkuZ2V0VXRpbFNlcnZpY2UoKTsKKwkJCWlmIChzZXJ2aWNlID09IG51bGwpIHsKKwkJCQlMT0dHRVIuZXJyb3IoIlNraXBwaW5nIGR0byBidWlsZCBzaW5jZSBJWHRleHRVdGlsU2VydmljZSBpcyBub3QgYXZhaWxhYmxlISIpOworCQkJCXJldHVybjsKKwkJCX0KKworCQkJVGltZUxvZ2dlciB0aW1lTG9nZ2VyID0gVGltZUxvZ2dlci5zdGFydChnZXRDbGFzcygpKTsKKworCQkJLy8KKwkJCS8vIHdlIG5lZWQgdG8gcHJlcGFyZSBhIHNlcnZpY2VSZXNvdXJjZSBhbmQgYSB3cml0ZWFibGVSZXNvdXJjZVNldAorCQkJLy8KKwkJCS8vIGZpbmQgcmVmZXJlbmNpbmcgc2VydmljZSBtb2RlbAorCQkJU2V0PFVSST4gZHRvVVJJcyA9IGZpbmREdG9VUklzKHRlbXBMRHRvTW9kZWwpOworCQkJZmluYWwgTGlzdDxJUmVmZXJlbmNlRGVzY3JpcHRpb24+IHRhcmdldFNlcnZpY2VSZWZlcmVuY2VzID0gZmluZFRhcmdldFNlcnZpY2VSZWZlcmVuY2VzKAorCQkJCQlkdG9VUklzLCB0ZW1wTER0b01vZGVsLmVSZXNvdXJjZSgpLmdldFJlc291cmNlU2V0KCkpOworCisJCQkvLyAtLS0tLS0tIGNyZWF0ZSB0aGUgYnVpbGQgY29udGV4dCAtLS0tLS0tCisJCQlTZXJ2aWNlRW5oYW5jZXJDb250ZXh0IGNvbnRleHQgPSBjcmVhdGVTZXJ2aWNlQnVpbGRDb250ZXh0KAorCQkJCQl0ZW1wTER0b01vZGVsLCB0YXJnZXRTZXJ2aWNlUmVmZXJlbmNlcyk7CisKKwkJCUlTZW1hbnRpY0xvYWRpbmdSZXNvdXJjZSBkdG9SZXNvdXJjZSA9IChJU2VtYW50aWNMb2FkaW5nUmVzb3VyY2UpIGNvbnRleHQud3JpdGVhYmxlUmVzb3VyY2VTZXQKKwkJCQkJLmdldFJlc291cmNlKHRlbXBMRHRvTW9kZWwuZVJlc291cmNlKCkuZ2V0VVJJKCksIHRydWUpOworCisJCQlMaXN0PExUeXBlPiBzb3VyY2VBcnRpZmFjdHMgPSBjb2xsZWN0RHRvcygoTER0b01vZGVsKSBkdG9SZXNvdXJjZQorCQkJCQkuZ2V0U2VtYW50aWNFbGVtZW50KCkpOworCisJCQlMaXN0PExUeXBlPiB0ZW1wU2VydmljZXMgPSBjb2xsZWN0U2VydmljZXMoKExTZXJ2aWNlTW9kZWwpIGNvbnRleHQuc2VydmljZVJlc291cmNlCisJCQkJCS5nZXRTZW1hbnRpY0VsZW1lbnQoKSk7CisKKwkJCUxpc3Q8TFR5cGU+IHNlcnZpY2VzVG9QZXJzaXN0ID0gbmV3IEFycmF5TGlzdDxMVHlwZT4oKTsKKworCQkJLy8gY3JlYXRlIGFsbCBzZXJ2aWNlcyAtPiBubyBsaW5raW5nCisJCQkvLworCQkJU2V0PExUeXBlZFBhY2thZ2U+IHRvdWNoZWRQYWNrYWdlcyA9IG5ldyBIYXNoU2V0PExUeXBlZFBhY2thZ2U+KCk7CisJCQlmb3IgKExUeXBlIGxUeXBlIDogc291cmNlQXJ0aWZhY3RzKSB7CisJCQkJaWYgKGxUeXBlIGluc3RhbmNlb2YgTER0bykgeworCQkJCQlMRHRvIGxEdG8gPSAoTER0bykgbFR5cGU7CisJCQkJCWlmICghKGxEdG8uZ2V0V3JhcHBlZFR5cGUoKSBpbnN0YW5jZW9mIExFbnRpdHkpKSB7CisJCQkJCQljb250aW51ZTsKKwkJCQkJfQorCisJCQkJCUxFbnRpdHkgbEVudGl0eSA9IChMRW50aXR5KSBsRHRvLmdldFdyYXBwZWRUeXBlKCk7CisJCQkJCWlmIChsRW50aXR5LmlzQWJzdHJhY3QoKSB8fCBsRW50aXR5LmlzTWFwcGVkU3VwZXJjbGFzcygpKSB7CisJCQkJCQljb250aW51ZTsKKwkJCQkJfQorCisJCQkJCUxEVE9TZXJ2aWNlIGxTZXJ2aWNlID0gZmluZFNlcnZpY2UobER0bywgdGVtcFNlcnZpY2VzKTsKKwkJCQkJaWYgKGxTZXJ2aWNlID09IG51bGwpIHsKKwkJCQkJCWxTZXJ2aWNlID0gT1NCUFNlcnZpY2VGYWN0b3J5LmVJTlNUQU5DRQorCQkJCQkJCQkuY3JlYXRlTERUT1NlcnZpY2UoKTsKKwkJCQkJCWxTZXJ2aWNlLnNldEFubm90YXRpb25JbmZvKE9TQlBTZXJ2aWNlRmFjdG9yeS5lSU5TVEFOQ0UKKwkJCQkJCQkJLmNyZWF0ZUxEVE9TZXJ2aWNlKCkpOworCQkJCQkJbFNlcnZpY2Uuc2V0SW5qZWN0ZWRTZXJ2aWNlcyhPU0JQU2VydmljZUZhY3RvcnkuZUlOU1RBTkNFCisJCQkJCQkJCS5jcmVhdGVMSW5qZWN0ZWRTZXJ2aWNlcygpKTsKKwkJCQkJCXRlbXBTZXJ2aWNlcy5hZGQobFNlcnZpY2UpOworCQkJCQl9IGVsc2UgeworCQkJCQkJLy8gcmVtb3ZlIGZyb20gcGFja2FnZSBmb3IgYSB3aGlsZQorCQkJCQkJTFR5cGVkUGFja2FnZSBsUGtnID0gKExUeXBlZFBhY2thZ2UpIGxTZXJ2aWNlCisJCQkJCQkJCS5lQ29udGFpbmVyKCk7CisJCQkJCQlsUGtnLmdldFR5cGVzKCkucmVtb3ZlKGxTZXJ2aWNlKTsKKwkJCQkJCS8vIGNvbGxlY3QgYWxsIHRvdWNoZWQgcGFja2FnZXMgLT4gVGhleSBuZWVkIGNsZWFudXAKKwkJCQkJCS8vIGxhdGVyCisJCQkJCQl0b3VjaGVkUGFja2FnZXMuYWRkKGxQa2cpOworCQkJCQl9CisJCQkJCWxTZXJ2aWNlLnNldE5hbWUoZ2V0U2VydmljZU5hbWUobER0bykpOworCQkJCQlsU2VydmljZS5zZXREdG8obER0byk7CisKKwkJCQkJc2VydmljZXNUb1BlcnNpc3QuYWRkKGxTZXJ2aWNlKTsKKwkJCQl9CisJCQl9CisKKwkJCS8vIGNsZWFuIHRvdWNoZWQgcGFja2FnZXMgLT4gQWxzbyByZW1vdmUgc2VydmljZXMgdGhhdCBhcmUgbm90IGJhc2VkCisJCQkvLyBvbgorCQkJLy8gYW4gZHRvIGFueW1vcmUKKwkJCWZvciAoTFR5cGVkUGFja2FnZSBsUGtnIDogdG91Y2hlZFBhY2thZ2VzKSB7CisJCQkJZm9yIChJdGVyYXRvcjxMVHlwZT4gaXRlcmF0b3IgPSBsUGtnLmdldFR5cGVzKCkuaXRlcmF0b3IoKTsgaXRlcmF0b3IKKwkJCQkJCS5oYXNOZXh0KCk7KSB7CisJCQkJCUxUeXBlIGxUeXBlID0gKExUeXBlKSBpdGVyYXRvci5uZXh0KCk7CisJCQkJCWlmIChsVHlwZSBpbnN0YW5jZW9mIExEVE9TZXJ2aWNlKSB7CisJCQkJCQlMRFRPU2VydmljZSBsU2VydmljZSA9IChMRFRPU2VydmljZSkgbFR5cGU7CisJCQkJCQlpZiAobFNlcnZpY2UuZ2V0RHRvKCkgPT0gbnVsbAorCQkJCQkJCQl8fCBsU2VydmljZS5nZXREdG8oKS5lSXNQcm94eSgpCisJCQkJCQkJCXx8ICEobFNlcnZpY2UuZ2V0RHRvKCkuZ2V0V3JhcHBlZFR5cGUoKSBpbnN0YW5jZW9mIExFbnRpdHkpKSB7CisJCQkJCQkJaXRlcmF0b3IucmVtb3ZlKCk7CisJCQkJCQl9CisJCQkJCX0KKwkJCQl9CisJCQl9CisKKwkJCS8vIHJlbW92ZSBhbGwgc2VydmljZXMgaGF2aW5nIG5vIHdyYXBwZWQgdHlwZSBhbnltb3JlCisJCQkvLworCQkJZm9yIChMVHlwZSBsVHlwZSA6IG5ldyBBcnJheUxpc3Q8PihzZXJ2aWNlc1RvUGVyc2lzdCkpIHsKKwkJCQlMRFRPU2VydmljZSBsU2VydmljZSA9IChMRFRPU2VydmljZSkgbFR5cGU7CisJCQkJaWYgKGxTZXJ2aWNlLmdldER0bygpID09IG51bGwgfHwgbFNlcnZpY2UuZ2V0RHRvKCkuZUlzUHJveHkoKSkgeworCQkJCQlzZXJ2aWNlc1RvUGVyc2lzdC5yZW1vdmUobFNlcnZpY2UpOworCQkJCX0KKwkJCX0KKworCQkJLy8gZml4IGZlYXR1cmVzCisJCQkvLworCQkJZm9yIChMVHlwZSBsVHlwZSA6IHNlcnZpY2VzVG9QZXJzaXN0KSB7CisJCQkJTERUT1NlcnZpY2UgbFNlcnZpY2UgPSAoTERUT1NlcnZpY2UpIGxUeXBlOworCQkJCUxEdG8gbER0byA9IGxTZXJ2aWNlLmdldER0bygpOworCQkJCS8vIGNhbiBuZXZlciBiZSBhIGJlYW4hCisJCQkJaWYgKGxEdG8uZ2V0V3JhcHBlZFR5cGUoKSBpbnN0YW5jZW9mIExFbnRpdHkpIHsKKwkJCQkJTEVudGl0eSBsRW50aXR5ID0gKExFbnRpdHkpIGxEdG8uZ2V0V3JhcHBlZFR5cGUoKTsKKwkJCQkJU3RyaW5nIHB1ID0gbEVudGl0eS5nZXRQZXJzaXN0ZW5jZVVuaXQoKTsKKwkJCQkJaWYgKHB1ICE9IG51bGwgJiYgIXB1LmVxdWFscygiIikpIHsKKwkJCQkJCWxTZXJ2aWNlLnNldE11dGFibGVQZXJzaXN0ZW5jZUlkKHRydWUpOworCQkJCQkJbFNlcnZpY2Uuc2V0UGVyc2lzdGVuY2VJZChwdSk7CisJCQkJCX0KKwkJCQl9CisJCQl9CisKKwkJCWlmICghc2VydmljZXNUb1BlcnNpc3QuaXNFbXB0eSgpKSB7CisJCQkJLy8gYWRkIHRoZSBzZXJ2aWNlcyB0byB0aGUgcGFja2FnZSBpbiB0aGUgcHJvcGVyIG9yZGVyCisJCQkJLy8KKwkJCQlTZXQ8U3RyaW5nPiBzZXJ2aWNlTmFtZXMgPSBuZXcgSGFzaFNldDxTdHJpbmc+KCk7CisJCQkJZm9yIChMVHlwZSBsVHlwZSA6IHNlcnZpY2VzVG9QZXJzaXN0KSB7CisJCQkJCUxEVE9TZXJ2aWNlIGxTZXJ2aWNlID0gKExEVE9TZXJ2aWNlKSBsVHlwZTsKKworCQkJCQkvLyBmaWx0ZXIgZHRvcworCQkJCQlpZiAoc2VydmljZU5hbWVzLmNvbnRhaW5zKGxTZXJ2aWNlLmdldE5hbWUoKSkpIHsKKwkJCQkJCS8vIHJlbW92ZSBkdXBsaWNhdGUgZHRvcworCQkJCQkJY29udGludWU7CisJCQkJCX0gZWxzZSBpZiAobFNlcnZpY2UuZ2V0RHRvKCkuZUlzUHJveHkoKSkgeworCQkJCQkJLy8gcmVtb3ZlIGR0byB3aXRob3V0IGEgcHJvcGVyIGVudGl0eSByZWZlcmVuY2UKKwkJCQkJCWNvbnRpbnVlOworCQkJCQl9CisJCQkJCXNlcnZpY2VOYW1lcy5hZGQobFNlcnZpY2UuZ2V0TmFtZSgpKTsKKworCQkJCQlMVHlwZWRQYWNrYWdlIGxTb3VyY2VUeXBlUGtnID0gKExUeXBlZFBhY2thZ2UpIGxTZXJ2aWNlCisJCQkJCQkJLmdldER0bygpLmVDb250YWluZXIoKTsKKwkJCQkJYWRkU2VydmljZXNUb1BhY2thZ2UoZ2V0U2VydmljZVBhY2thZ2VOYW1lKGxTb3VyY2VUeXBlUGtnKSwKKwkJCQkJCQlsU2VydmljZSwKKwkJCQkJCQkoTFNlcnZpY2VNb2RlbCkgY29udGV4dC5zZXJ2aWNlUmVzb3VyY2UKKwkJCQkJCQkJCS5nZXRTZW1hbnRpY0VsZW1lbnQoKSwKKwkJCQkJCQlsU291cmNlVHlwZVBrZy5nZXROYW1lKCkpOworCQkJCX0KKworCQkJCXRyeSB7CisJCQkJCURpYWdub3N0aWMgZGlhZ25vc3RpYyA9IERpYWdub3N0aWNpYW4uSU5TVEFOQ0UKKwkJCQkJCQkudmFsaWRhdGUoY29udGV4dC5zZXJ2aWNlUmVzb3VyY2UKKwkJCQkJCQkJCS5nZXRTZW1hbnRpY0VsZW1lbnQoKSk7CisJCQkJCWludCBzZXYgPSBkaWFnbm9zdGljLmdldFNldmVyaXR5KCk7CisJCQkJCWlmIChzZXYgPD0gRGlhZ25vc3RpYy5XQVJOSU5HKSB7CisJCQkJCQljb250ZXh0LnNlcnZpY2VSZXNvdXJjZS5zYXZlKFNhdmVPcHRpb25zLm5ld0J1aWxkZXIoKQorCQkJCQkJCQkuZm9ybWF0KCkuZ2V0T3B0aW9ucygpLnRvT3B0aW9uc01hcCgpKTsKKwkJCQkJfSBlbHNlIHsKKwkJCQkJCUxPR0dFUi5lcnJvcihjb250ZXh0LnNlcnZpY2VSZXNvdXJjZS5nZXRFcnJvcnMoKS5nZXQoMCkKKwkJCQkJCQkJLnRvU3RyaW5nKCkpOworCQkJCQl9CisJCQkJCWNvbnRleHQuc2VydmljZVJlc291cmNlLnVubG9hZCgpOworCisJCQkJCS8vIGludm9rZSB0aGUgaW5jcmVtZW50YWwgYnVpbGQKKwkJCQkJLy8KKwkJCQkJbmVlZFJlYnVpbGQoKTsKKwkJCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBlKSB7CisJCQkJCUxPR0dFUi5lcnJvcigie30iLCBlKTsKKwkJCQl9CisKKwkJCQl0aW1lTG9nZ2VyLnN0b3AoTE9HR0VSLAorCQkJCQkJIkZpbmlzaGVkIE9TQlBTZXJ2aWNlQnVpbGRlciNidWlsZFNlcnZpY2VzIGluICIpOworCQkJfQorCQl9CisKKwkJLyoqCisJCSAqIENyZWF0ZXMgdGhlIHNlcnZpY2UgYnVpbGQgY29udGV4dC4KKwkJICoKKwkJICogQHBhcmFtIHRlbXBMRHRvTW9kZWwKKwkJICogICAgICAgICAgICB0aGUgdGVtcCBsIGR0byBtb2RlbAorCQkgKiBAcGFyYW0gdGFyZ2V0U2VydmljZVJlZmVyZW5jZXMKKwkJICogICAgICAgICAgICB0aGUgdGFyZ2V0IHNlcnZpY2UgcmVmZXJlbmNlcworCQkgKiBAcmV0dXJuIHRoZSBzZXJ2aWNlIGVuaGFuY2VyIGNvbnRleHQKKwkJICovCisJCXByaXZhdGUgU2VydmljZUVuaGFuY2VyQ29udGV4dCBjcmVhdGVTZXJ2aWNlQnVpbGRDb250ZXh0KAorCQkJCUxEdG9Nb2RlbCB0ZW1wTER0b01vZGVsLAorCQkJCWZpbmFsIExpc3Q8SVJlZmVyZW5jZURlc2NyaXB0aW9uPiB0YXJnZXRTZXJ2aWNlUmVmZXJlbmNlcykgeworCQkJU2VydmljZUVuaGFuY2VyQ29udGV4dCBjb250ZXh0ID0gbmV3IFNlcnZpY2VFbmhhbmNlckNvbnRleHQoKTsKKwkJCWlmICghdGFyZ2V0U2VydmljZVJlZmVyZW5jZXMuaXNFbXB0eSgpKSB7CisJCQkJLy8KKwkJCQkvLyBpZiB3ZSBjb3VsZCBmaW5kIHJlZmVyZW5jZWQgZHRvcywgdGhlbiB3ZSB1c2UgdGhpcworCQkJCS8vIGluZm9ybWF0aW9uIHRvCisJCQkJLy8gY3JlYXRlIGR0b1Jlc291cmNlIGFuZCB3cml0ZWFibGVSZXNvdXJjZVNldAorCQkJCS8vCisKKwkJCQkvLyBhY2Nlc3MgZW50aXR5IHJlc291cmNlCisJCQkJSVNlbWFudGljTG9hZGluZ1Jlc291cmNlIHRlbXBEdG9SZXNvdXJjZSA9IChJU2VtYW50aWNMb2FkaW5nUmVzb3VyY2UpIHRlbXBMRHRvTW9kZWwKKwkJCQkJCS5lUmVzb3VyY2UoKTsKKwkJCQlSZXNvdXJjZVNldCByZWFkb25seVJlc291cmNlU2V0ID0gdGVtcER0b1Jlc291cmNlCisJCQkJCQkuZ2V0UmVzb3VyY2VTZXQoKTsKKworCQkJCS8vIGFjY2VzcyBkdG8gcmVzb3VyY2UgYmFzZWQgb24gZW50aXR5UmVzb3VyY2VTZXQKKwkJCQlJUmVmZXJlbmNlRGVzY3JpcHRpb24gZmlyc3REZXNjID0gdGFyZ2V0U2VydmljZVJlZmVyZW5jZXMKKwkJCQkJCS5nZXQoMCk7CisJCQkJTFNlcnZpY2UgdGVtcFNlcnZpY2UgPSAoTFNlcnZpY2UpIHJlYWRvbmx5UmVzb3VyY2VTZXQKKwkJCQkJCS5nZXRFT2JqZWN0KGZpcnN0RGVzYy5nZXRTb3VyY2VFT2JqZWN0VXJpKCksIHRydWUpOworCisJCQkJLy8gY3JlYXRlIHRoZSBwcm9wZXIgZHRvIHJlc291cmNlU2V0IHRvIHNhdmUgdGhlIGR0bworCQkJCWNvbnRleHQud3JpdGVhYmxlUmVzb3VyY2VTZXQgPSBnZXRQcm9qZWN0UmVzb3VyY2VTZXQoRWNvcmVVdGlsCisJCQkJCQkuZ2V0VVJJKHRlbXBTZXJ2aWNlKSk7CisKKwkJCQkvLyBsb2FkIHRoZSBkdG9SZXNvdXJjZSBiYXNlZCBvbiB0aGUgZHRvIHJlc291cmNlU2V0CisJCQkJY29udGV4dC5zZXJ2aWNlUmVzb3VyY2UgPSAoSVNlbWFudGljTG9hZGluZ1Jlc291cmNlKSBjb250ZXh0LndyaXRlYWJsZVJlc291cmNlU2V0CisJCQkJCQkuZ2V0UmVzb3VyY2UoRWNvcmVVdGlsLmdldFVSSSh0ZW1wU2VydmljZSkKKwkJCQkJCQkJLnRyaW1GcmFnbWVudCgpLCB0cnVlKTsKKwkJCX0gZWxzZSB7CisJCQkJVVJJIGR0b1VSSSA9IEVjb3JlVXRpbC5nZXRVUkkodGVtcExEdG9Nb2RlbCk7CisJCQkJLy8gY3JlYXRlIHRoZSBwcm9wZXIgZHRvIHJlc291cmNlU2V0IHRvIHNhdmUgdGhlIGR0bworCQkJCWNvbnRleHQud3JpdGVhYmxlUmVzb3VyY2VTZXQgPSBnZXRQcm9qZWN0UmVzb3VyY2VTZXQoZHRvVVJJKTsKKworCQkJCS8vIHRyeSB0byBmaW5kIGEgZmlsZSB3aXRoIGV4dGVuc2lvbiAuc2VydmljZXMgaW4gc2FtZSBwcm9qZWN0CisJCQkJSVJlc291cmNlIG1lbWJlciA9IGZpbmRTZXJ2aWNlRmlsZShkdG9VUkkpOworCQkJCVN0cmluZyBzZXJ2aWNlUmVzb3VyY2VQYXRoID0gbnVsbDsKKwkJCQlpZiAobWVtYmVyICE9IG51bGwpIHsKKwkJCQkJc2VydmljZVJlc291cmNlUGF0aCA9IG1lbWJlci5nZXRGdWxsUGF0aCgpLnRvU3RyaW5nKCk7CisJCQkJfSBlbHNlIHsKKwkJCQkJLy8KKwkJCQkJLy8gaWYgd2UgY291bGQgbm90IGZpbmQgcmVmZXJlbmNlZCBkdG9zLCB0aGVuIHdlIHVzZSB0aGUKKwkJCQkJLy8gZm9sZGVyCisJCQkJCS8vIG9mCisJCQkJCS8vIHRoZSBlbnRpdHkgYW5kIHB1dCB0aGUgZHRvcyBpbiB0aGVyZQorCQkJCQkvLworCQkJCQkvLyBub3cgY3JlYXRlIGEgZHRvUmVzb3VyY2UKKworCQkJCQlzZXJ2aWNlUmVzb3VyY2VQYXRoID0gb3JnLmVjbGlwc2Uub3NicC5kc2wuc2VtYW50aWMuc2VydmljZS51dGlsLk5hbWluZ0NvbnZlbnRpb25zVXRpbAorCQkJCQkJCS50b1NlcnZpY2VQYWNrYWdlKGR0b1VSSS5wYXRoKCkucmVwbGFjZSgKKwkJCQkJCQkJCSIvcmVzb3VyY2UiLCAiIikpOworCQkJCX0KKworCQkJCVVSSSBzZXJ2aWNlTW9kZWxVUkkgPSBVUkkuY3JlYXRlUGxhdGZvcm1SZXNvdXJjZVVSSSgKKwkJCQkJCXNlcnZpY2VSZXNvdXJjZVBhdGgsIHRydWUpOworCQkJCWNvbnRleHQuc2VydmljZVJlc291cmNlID0gKElTZW1hbnRpY0xvYWRpbmdSZXNvdXJjZSkgY29udGV4dC53cml0ZWFibGVSZXNvdXJjZVNldAorCQkJCQkJLmNyZWF0ZVJlc291cmNlKHNlcnZpY2VNb2RlbFVSSSk7CisJCQkJY29udGV4dC5zZXJ2aWNlUmVzb3VyY2UuZ2V0Q29udGVudHMoKS5hZGQoCisJCQkJCQlPU0JQU2VydmljZUZhY3RvcnkuZUlOU1RBTkNFLmNyZWF0ZUxTZXJ2aWNlTW9kZWwoKSk7CisJCQl9CisJCQlyZXR1cm4gY29udGV4dDsKKwkJfQorCisJCXByaXZhdGUgSVJlc291cmNlIGZpbmRTZXJ2aWNlRmlsZShVUkkgZW50aXR5VVJJKSB7CisJCQlTdHJpbmcgZHRvRmlsZU5hbWUgPSBlbnRpdHlVUkkucGF0aCgpCisJCQkJCS5zdWJzdHJpbmcoZW50aXR5VVJJLnBhdGgoKS5sYXN0SW5kZXhPZigiLyIpICsgMSkKKwkJCQkJLnJlcGxhY2UoIi5kdG8iLCAiLnNlcnZpY2UiKTsKKworCQkJSVJlc291cmNlW10gdGVtcCA9IG5ldyBJUmVzb3VyY2VbMV07CisJCQl0cnkgeworCQkJCWdldFByb2plY3QoKS5hY2NlcHQobmV3IElSZXNvdXJjZVZpc2l0b3IoKSB7CisJCQkJCXB1YmxpYyBib29sZWFuIHZpc2l0KElSZXNvdXJjZSByZXMpIHsKKwkJCQkJCWlmIChyZXMgaW5zdGFuY2VvZiBJRmlsZSkgeworCQkJCQkJCWlmIChyZXMuZ2V0TmFtZSgpLmVxdWFscyhkdG9GaWxlTmFtZSkpIHsKKwkJCQkJCQkJdGVtcFswXSA9IHJlczsKKwkJCQkJCQl9CisJCQkJCQkJcmV0dXJuIHRydWU7CisJCQkJCQl9IGVsc2UgaWYgKHJlcyBpbnN0YW5jZW9mIElGb2xkZXIpIHsKKwkJCQkJCQlpZiAocmVzLmdldE5hbWUoKS5lcXVhbHMoImJpbiIpCisJCQkJCQkJCQl8fCByZXMuZ2V0TmFtZSgpLmVxdWFscygidGFyZ2V0IikpIHsKKwkJCQkJCQkJcmV0dXJuIGZhbHNlOworCQkJCQkJCX0KKwkJCQkJCQlyZXR1cm4gdHJ1ZTsKKwkJCQkJCX0gZWxzZSBpZiAocmVzIGluc3RhbmNlb2YgSVByb2plY3QpIHsKKwkJCQkJCQlyZXR1cm4gdHJ1ZTsKKwkJCQkJCX0KKwkJCQkJCXJldHVybiBmYWxzZTsKKwkJCQkJfQorCQkJCX0pOworCQkJfSBjYXRjaCAoQ29yZUV4Y2VwdGlvbiBlKSB7CisJCQkJTE9HR0VSLndhcm4oInt9IiwgZSk7CisJCQl9CisKKwkJCUlSZXNvdXJjZSBtZW1iZXIgPSB0ZW1wWzBdOworCQkJcmV0dXJuIG1lbWJlcjsKKwkJfQorCisJCS8qKgorCQkgKiBGaW5kIHNlcnZpY2UuCisJCSAqCisJCSAqIEBwYXJhbSBsRHRvCisJCSAqICAgICAgICAgICAgdGhlIGwgZHRvCisJCSAqIEBwYXJhbSBzZXJ2aWNlcworCQkgKiAgICAgICAgICAgIHRoZSBzZXJ2aWNlcworCQkgKiBAcmV0dXJuIHRoZSBMRFRPIHNlcnZpY2UKKwkJICovCisJCXByaXZhdGUgTERUT1NlcnZpY2UgZmluZFNlcnZpY2UoTFR5cGUgbER0bywgTGlzdDxMVHlwZT4gc2VydmljZXMpIHsKKwkJCWZvciAoTFR5cGUgbFR5cGUgOiBzZXJ2aWNlcykgeworCQkJCWlmIChsVHlwZSBpbnN0YW5jZW9mIExEVE9TZXJ2aWNlKSB7CisJCQkJCUxEVE9TZXJ2aWNlIGxTZXJ2aWNlID0gKExEVE9TZXJ2aWNlKSBsVHlwZTsKKwkJCQkJaWYgKGxTZXJ2aWNlLmdldER0bygpID09IGxEdG8pIHsKKwkJCQkJCXJldHVybiBsU2VydmljZTsKKwkJCQkJfQorCQkJCX0KKwkJCX0KKwkJCXJldHVybiBudWxsOworCQl9CisKKwkJLyoqCisJCSAqIEdldHMgdGhlIHNlcnZpY2UgcGFja2FnZSBuYW1lLgorCQkgKgorCQkgKiBAcGFyYW0gbFR5cGVQa2cKKwkJICogICAgICAgICAgICB0aGUgbCB0eXBlIHBrZworCQkgKiBAcmV0dXJuIHRoZSBzZXJ2aWNlIHBhY2thZ2UgbmFtZQorCQkgKi8KKwkJcHJpdmF0ZSBTdHJpbmcgZ2V0U2VydmljZVBhY2thZ2VOYW1lKExUeXBlZFBhY2thZ2UgbFR5cGVQa2cpIHsKKwkJCXJldHVybiBsVHlwZVBrZy5nZXROYW1lKCkgKyAiLnNlcnZpY2UiOworCQl9CisKKwkJLyoqCisJCSAqIEFkZHMgdGhlIHNlcnZpY2UgdG8gdGhlIHBhY2thZ2UgbWFjaGluZyB0aGUgcGFja2FnZU5hbWUuCisJCSAqCisJCSAqIEBwYXJhbSBwYWNrYWdlTmFtZQorCQkgKiAgICAgICAgICAgIHRoZSBwYWNrYWdlIG5hbWUKKwkJICogQHBhcmFtIG5ld1NlcnZpY2UKKwkJICogICAgICAgICAgICB0aGUgbmV3IHNlcnZpY2UKKwkJICogQHBhcmFtIGxNb2RlbAorCQkgKiAgICAgICAgICAgIHRoZSBsIG1vZGVsCisJCSAqIEBwYXJhbSBkdG9QYWNrYWdlCisJCSAqICAgICAgICAgICAgdGhlIGR0byBwYWNrYWdlCisJCSAqLworCQlwcml2YXRlIHZvaWQgYWRkU2VydmljZXNUb1BhY2thZ2UoU3RyaW5nIHBhY2thZ2VOYW1lLAorCQkJCUxTZXJ2aWNlIG5ld1NlcnZpY2UsIExTZXJ2aWNlTW9kZWwgbE1vZGVsLCBTdHJpbmcgZHRvUGFja2FnZSkgeworCisJCQlPcHRpb25hbDxMVHlwZWRQYWNrYWdlPiBvcHRQa2cgPSBsTW9kZWwuZ2V0UGFja2FnZXMoKS5zdHJlYW0oKQorCQkJCQkuZmlsdGVyKHAgLT4gcC5nZXROYW1lKCkuZXF1YWxzKHBhY2thZ2VOYW1lKSkuZmluZEZpcnN0KCk7CisJCQlMVHlwZWRQYWNrYWdlIHBrZyA9IG51bGw7CisJCQlpZiAob3B0UGtnLmlzUHJlc2VudCgpKSB7CisJCQkJcGtnID0gb3B0UGtnLmdldCgpOworCQkJfQorCQkJaWYgKHBrZyA9PSBudWxsKSB7CisJCQkJcGtnID0gT1NCUFR5cGVzRmFjdG9yeS5lSU5TVEFOQ0UuY3JlYXRlTFR5cGVkUGFja2FnZSgpOworCQkJCXBrZy5zZXROYW1lKHBhY2thZ2VOYW1lKTsKKwkJCQlsTW9kZWwuZ2V0UGFja2FnZXMoKS5hZGQocGtnKTsKKwkJCX0KKworCQkJLy8gY2hlY2sgaWYgZW50aXR5UGFja2FnZSBpcyBpbXBvcnRlZAorCQkJaWYgKCFjb250YWluc0ltcG9ydChwa2csIGR0b1BhY2thZ2UgKyAiLioiKSkgeworCQkJCUxJbXBvcnQgbEltcG9ydCA9IE9TQlBUeXBlc0ZhY3RvcnkuZUlOU1RBTkNFLmNyZWF0ZUxJbXBvcnQoKTsKKwkJCQlsSW1wb3J0LnNldEltcG9ydGVkTmFtZXNwYWNlKGR0b1BhY2thZ2UgKyAiLioiKTsKKwkJCQlwa2cuZ2V0SW1wb3J0cygpLmFkZChsSW1wb3J0KTsKKwkJCX0KKworCQkJcGtnLmdldFR5cGVzKCkuYWRkKG5ld1NlcnZpY2UpOworCQl9CisKKwkJLyoqCisJCSAqIENvbnRhaW5zIGltcG9ydC4KKwkJICoKKwkJICogQHBhcmFtIHBrZworCQkgKiAgICAgICAgICAgIHRoZSBwa2cKKwkJICogQHBhcmFtIGVudGl0eVBhY2thZ2VJbXBvcnQKKwkJICogICAgICAgICAgICB0aGUgZW50aXR5IHBhY2thZ2UgaW1wb3J0CisJCSAqIEByZXR1cm4gdHJ1ZSwgaWYgc3VjY2Vzc2Z1bAorCQkgKi8KKwkJcHJpdmF0ZSBib29sZWFuIGNvbnRhaW5zSW1wb3J0KExUeXBlZFBhY2thZ2UgcGtnLAorCQkJCVN0cmluZyBlbnRpdHlQYWNrYWdlSW1wb3J0KSB7CisJCQlmb3IgKExJbXBvcnQgbEltcG9ydCA6IHBrZy5nZXRJbXBvcnRzKCkpIHsKKwkJCQlpZiAobEltcG9ydC5nZXRJbXBvcnRlZE5hbWVzcGFjZSgpLmVxdWFscyhlbnRpdHlQYWNrYWdlSW1wb3J0KSkgeworCQkJCQlyZXR1cm4gdHJ1ZTsKKwkJCQl9CisJCQl9CisJCQlyZXR1cm4gZmFsc2U7CisJCX0KKworCQkvKioKKwkJICogR2V0cyB0aGUgc2VydmljZSBuYW1lLgorCQkgKgorCQkgKiBAcGFyYW0gbFR5cGUKKwkJICogICAgICAgICAgICB0aGUgbCB0eXBlCisJCSAqIEByZXR1cm4gdGhlIHNlcnZpY2UgbmFtZQorCQkgKi8KKwkJcHJpdmF0ZSBTdHJpbmcgZ2V0U2VydmljZU5hbWUoTER0byBsVHlwZSkgeworCQkJcmV0dXJuIG9yZy5lY2xpcHNlLm9zYnAuZHNsLnNlbWFudGljLnNlcnZpY2UudXRpbC5OYW1pbmdDb252ZW50aW9uc1V0aWwKKwkJCQkJLnRvU2VydmljZU5hbWUobFR5cGUpOworCQl9CisKKwkJLyoqCisJCSAqIEdldHMgdGhlIHByb2plY3QgcmVzb3VyY2Ugc2V0LgorCQkgKgorCQkgKiBAcGFyYW0gdXJpCisJCSAqICAgICAgICAgICAgdGhlIHVyaQorCQkgKiBAcmV0dXJuIHRoZSBwcm9qZWN0IHJlc291cmNlIHNldAorCQkgKi8KKwkJcHJpdmF0ZSBYdGV4dFJlc291cmNlU2V0IGdldFByb2plY3RSZXNvdXJjZVNldChVUkkgdXJpKSB7CisJCQlJUHJvamVjdCBkdG9Qcm9qZWN0ID0gbnVsbDsKKwkJCUl0ZXJhYmxlPFBhaXI8SVN0b3JhZ2UsIElQcm9qZWN0Pj4gcGFpcnMgPSB1cmlTdG9yYWdlTWFwcGVyCisJCQkJCS5nZXRTdG9yYWdlcyh1cmkpOworCQkJaWYgKHBhaXJzLml0ZXJhdG9yKCkuaGFzTmV4dCgpKSB7CisJCQkJZHRvUHJvamVjdCA9IHBhaXJzLml0ZXJhdG9yKCkubmV4dCgpLmdldFNlY29uZCgpOworCQkJfQorCisJCQlpZiAoZHRvUHJvamVjdCA9PSBudWxsKSB7CisJCQkJTE9HR0VSLmVycm9yKCJObyBwcm9qZWN0IGNvdWxkIGJlIGZvdW5kIGZvciAiICsgdXJpKTsKKwkJCQlyZXR1cm4gbnVsbDsKKwkJCX0KKworCQkJWHRleHRSZXNvdXJjZVNldCByZXNvdXJjZVNldCA9IChYdGV4dFJlc291cmNlU2V0KSByc1Byb3ZpZGVyCisJCQkJCS5nZXQoZHRvUHJvamVjdCk7CisJCQlyZXR1cm4gcmVzb3VyY2VTZXQ7CisJCX0KKworCQkvKioKKwkJICogQ3JlYXRlcyBhIG1hcCB3aXRoIGEgcmVzb3VyY2Ugc2V0IGZvciBlYWNoIHVyaS4gRW5zdXJlcywgdGhhdAorCQkgKiByZXNvdXJjZSBzZXRzIGFyZSByZXVzZWQgYnkgcHJvamVjdCB0byBlbmhhbmNlIHBlcmZvcm1hbmNlLgorCQkgKgorCQkgKiBAcGFyYW0gdXJpcworCQkgKiAgICAgICAgICAgIHRoZSB1cmlzCisJCSAqIEByZXR1cm4gdGhlIHByb2plY3QgcmVzb3VyY2Ugc2V0IG1hcAorCQkgKi8KKwkJcHJpdmF0ZSBNYXA8VVJJLCBYdGV4dFJlc291cmNlU2V0PiBnZXRQcm9qZWN0UmVzb3VyY2VTZXRNYXAoCisJCQkJU2V0PFVSST4gdXJpcykgeworCQkJSVByb2plY3QgcHJvamVjdCA9IG51bGw7CisJCQlNYXA8SVByb2plY3QsIFh0ZXh0UmVzb3VyY2VTZXQ+IGJ5UHJvamVjdCA9IG5ldyBIYXNoTWFwPD4oKTsKKwkJCU1hcDxVUkksIFh0ZXh0UmVzb3VyY2VTZXQ+IHJlc3VsdCA9IG5ldyBIYXNoTWFwPD4oKTsKKwkJCWZvciAoVVJJIHVyaSA6IHVyaXMpIHsKKwkJCQlJdGVyYWJsZTxQYWlyPElTdG9yYWdlLCBJUHJvamVjdD4+IHBhaXJzID0gdXJpU3RvcmFnZU1hcHBlcgorCQkJCQkJLmdldFN0b3JhZ2VzKHVyaSk7CisJCQkJaWYgKHBhaXJzLml0ZXJhdG9yKCkuaGFzTmV4dCgpKSB7CisJCQkJCXByb2plY3QgPSBwYWlycy5pdGVyYXRvcigpLm5leHQoKS5nZXRTZWNvbmQoKTsKKwkJCQl9CisKKwkJCQlpZiAocHJvamVjdCA9PSBudWxsKSB7CisJCQkJCUxPR0dFUi5lcnJvcigiTm8gcHJvamVjdCBjb3VsZCBiZSBmb3VuZCBmb3IgIiArIHVyaSk7CisJCQkJCWNvbnRpbnVlOworCQkJCX0KKworCQkJCWlmIChieVByb2plY3QuY29udGFpbnNLZXkocHJvamVjdCkpIHsKKwkJCQkJLy8gc2FtZSBwcm9qZWN0cyB1c2Ugc2hhcmVkIHJlc291cmNlIHNldAorCQkJCQlyZXN1bHQucHV0KHVyaSwgYnlQcm9qZWN0LmdldChwcm9qZWN0KSk7CisJCQkJfSBlbHNlIHsKKwkJCQkJWHRleHRSZXNvdXJjZVNldCByZXNvdXJjZVNldCA9IChYdGV4dFJlc291cmNlU2V0KSByc1Byb3ZpZGVyCisJCQkJCQkJLmdldChwcm9qZWN0KTsKKwkJCQkJYnlQcm9qZWN0LnB1dChwcm9qZWN0LCByZXNvdXJjZVNldCk7CisJCQkJCXJlc3VsdC5wdXQodXJpLCByZXNvdXJjZVNldCk7CisJCQkJfQorCQkJfQorCQkJcmV0dXJuIHJlc3VsdDsKKwkJfQorCisJCS8qKgorCQkgKiBGaW5kIGR0byB1ciBpcy4KKwkJICoKKwkJICogQHBhcmFtIGxEdG9Nb2RlbAorCQkgKiAgICAgICAgICAgIHRoZSBsIGR0byBtb2RlbAorCQkgKiBAcmV0dXJuIHRoZSBzZXRzIHRoZQorCQkgKi8KKwkJcHJpdmF0ZSBTZXQ8VVJJPiBmaW5kRHRvVVJJcyhMRHRvTW9kZWwgbER0b01vZGVsKSB7CisJCQlTZXQ8VVJJPiBkdG9VUklzID0gbmV3IEhhc2hTZXQ8VVJJPigpOworCQkJZm9yIChMVHlwZWRQYWNrYWdlIGxQa2cgOiBsRHRvTW9kZWwuZ2V0UGFja2FnZXMoKSkgeworCQkJCWZvciAoTFR5cGUgbFR5cGUgOiBsUGtnLmdldFR5cGVzKCkpIHsKKwkJCQkJaWYgKGxUeXBlIGluc3RhbmNlb2YgTER0bykgeworCQkJCQkJZHRvVVJJcy5hZGQoRWNvcmVVdGlsLmdldFVSSShsVHlwZSkpOworCQkJCQl9CisJCQkJfQorCQkJfQorCQkJcmV0dXJuIGR0b1VSSXM7CisJCX0KKworCQkvKioKKwkJICogSXRlcmF0ZXMgYWxsIGR0b3MgaW4gdGhlIG1vZGVsIGFuZCBjcmVhdGVzIHRoZSBVUklzIGZvciB0aGVpcgorCQkgKiBKdm1UeXBlcy4KKwkJICoKKwkJICogQHBhcmFtIGxEdG9Nb2RlbAorCQkgKiAgICAgICAgICAgIHRoZSBsIGR0byBtb2RlbAorCQkgKiBAcmV0dXJuIHRoZSBzZXRzIHRoZQorCQkgKi8KKwkJcHJpdmF0ZSBTZXQ8VVJJPiBmaW5kRHRvSnZtVHlwZVVSSXMoTER0b01vZGVsIGxEdG9Nb2RlbCkgeworCQkJU2V0PFVSST4gZHRvVVJJcyA9IG5ldyBIYXNoU2V0PFVSST4oKTsKKworCQkJSVh0ZXh0VXRpbFNlcnZpY2Ugc2VydmljZSA9IENvcmVVaUFjdGl2YXRvci5nZXREZWZhdWx0KCkKKwkJCQkJLmdldFV0aWxTZXJ2aWNlKCk7CisJCQlmb3IgKExUeXBlZFBhY2thZ2UgbFBrZyA6IGxEdG9Nb2RlbC5nZXRQYWNrYWdlcygpKSB7CisJCQkJZm9yIChMVHlwZSBsVHlwZSA6IGxQa2cuZ2V0VHlwZXMoKSkgeworCQkJCQlpZiAobFR5cGUgaW5zdGFuY2VvZiBMRHRvKSB7CisJCQkJCQlmb3IgKElFT2JqZWN0RGVzY3JpcHRpb24gZGVzYyA6IHNlcnZpY2UKKwkJCQkJCQkJLmdldEVPYmplY3REZXNjcmlwdGlvbnMoCisJCQkJCQkJCQkJVHlwZXNQYWNrYWdlLkxpdGVyYWxzLkpWTV9UWVBFLAorCQkJCQkJCQkJCXRvRnFuKGxUeXBlKSkpIHsKKwkJCQkJCQlkdG9VUklzLmFkZChkZXNjLmdldEVPYmplY3RVUkkoKSk7CisJCQkJCQl9CisJCQkJCX0KKwkJCQl9CisJCQl9CisJCQlyZXR1cm4gZHRvVVJJczsKKwkJfQorCisJCS8qKgorCQkgKiBSZXR1cm5zIHRoZSBmdWxseSBxdWFsaWZpZWQgbmFtZSBmb3IgdGhlIGdpdmVuIHR5cGUuCisJCSAqCisJCSAqIEBwYXJhbSBsVHlwZQorCQkgKiAgICAgICAgICAgIHRoZSBsIHR5cGUKKwkJICogQHJldHVybiB0aGUgc3RyaW5nCisJCSAqLworCQlwcml2YXRlIFN0cmluZyB0b0ZxbihMVHlwZSBsVHlwZSkgeworCQkJTFR5cGVkUGFja2FnZSBwa2cgPSAoTFR5cGVkUGFja2FnZSkgbFR5cGUuZUNvbnRhaW5lcigpOworCQkJcmV0dXJuIHBrZy5nZXROYW1lKCkgKyAiLiIgKyBsVHlwZS5nZXROYW1lKCk7CisJCX0KKworCQkvKioKKwkJICogQ29sbGVjdCBkdG9zLgorCQkgKgorCQkgKiBAcGFyYW0gbER0b01vZGVsCisJCSAqICAgICAgICAgICAgdGhlIGwgZHRvIG1vZGVsCisJCSAqIEByZXR1cm4gdGhlIGxpc3QKKwkJICovCisJCXByaXZhdGUgTGlzdDxMVHlwZT4gY29sbGVjdER0b3MoTER0b01vZGVsIGxEdG9Nb2RlbCkgeworCQkJTGlzdDxMVHlwZT4gZHRvcyA9IG5ldyBBcnJheUxpc3Q8TFR5cGU+KCk7CisJCQlmb3IgKExUeXBlZFBhY2thZ2UgbFBrZyA6IGxEdG9Nb2RlbC5nZXRQYWNrYWdlcygpKSB7CisJCQkJZm9yIChMVHlwZSBsVHlwZSA6IGxQa2cuZ2V0VHlwZXMoKSkgeworCQkJCQlpZiAobFR5cGUgaW5zdGFuY2VvZiBMRHRvKSB7CisJCQkJCQlMRHRvIGxEdG8gPSAoTER0bykgbFR5cGU7CisJCQkJCQlpZiAobER0by5nZXRXcmFwcGVkVHlwZSgpICE9IG51bGwpIHsKKwkJCQkJCQlkdG9zLmFkZChsVHlwZSk7CisJCQkJCQl9CisJCQkJCX0KKwkJCQl9CisJCQl9CisJCQlyZXR1cm4gZHRvczsKKwkJfQorCisJCS8qKgorCQkgKiBDb2xsZWN0IHNlcnZpY2VzLgorCQkgKgorCQkgKiBAcGFyYW0gbFNlcnZpY2VNb2RlbAorCQkgKiAgICAgICAgICAgIHRoZSBsIHNlcnZpY2UgbW9kZWwKKwkJICogQHJldHVybiB0aGUgbGlzdAorCQkgKi8KKwkJcHJpdmF0ZSBMaXN0PExUeXBlPiBjb2xsZWN0U2VydmljZXMoTFNlcnZpY2VNb2RlbCBsU2VydmljZU1vZGVsKSB7CisJCQlMaXN0PExUeXBlPiBzZXJ2aWNlcyA9IG5ldyBBcnJheUxpc3Q8TFR5cGU+KCk7CisJCQlmb3IgKExUeXBlZFBhY2thZ2UgbFBrZyA6IGxTZXJ2aWNlTW9kZWwuZ2V0UGFja2FnZXMoKSkgeworCQkJCWZvciAoTFR5cGUgbFR5cGUgOiBsUGtnLmdldFR5cGVzKCkpIHsKKwkJCQkJaWYgKGxUeXBlIGluc3RhbmNlb2YgTFNlcnZpY2UpIHsKKwkJCQkJCXNlcnZpY2VzLmFkZChsVHlwZSk7CisJCQkJCX0KKwkJCQl9CisJCQl9CisJCQlyZXR1cm4gc2VydmljZXM7CisJCX0KKworCQkvKioKKwkJICogRmluZCB0YXJnZXQgc2VydmljZSByZWZlcmVuY2VzLgorCQkgKgorCQkgKiBAcGFyYW0gZHRvVVJJcworCQkgKiAgICAgICAgICAgIHRoZSBkdG8gdXIgaXMKKwkJICogQHBhcmFtIHJlc291cmNlU2V0CisJCSAqICAgICAgICAgICAgdGhlIHJlc291cmNlIHNldAorCQkgKiBAcmV0dXJuIHRoZSBsaXN0CisJCSAqLworCQlwcml2YXRlIExpc3Q8SVJlZmVyZW5jZURlc2NyaXB0aW9uPiBmaW5kVGFyZ2V0U2VydmljZVJlZmVyZW5jZXMoCisJCQkJU2V0PFVSST4gZHRvVVJJcywgUmVzb3VyY2VTZXQgcmVzb3VyY2VTZXQpIHsKKwkJCWZpbmFsIExpc3Q8SVJlZmVyZW5jZURlc2NyaXB0aW9uPiB0YXJnZXRTZXJ2aWNlUmVmZXJlbmNlcyA9IG5ldyBBcnJheUxpc3Q8SVJlZmVyZW5jZURlc2NyaXB0aW9uPigpOworCQkJcmVmZXJlbmNlRmluZGVyLmZpbmRBbGxSZWZlcmVuY2VzKGR0b1VSSXMsIG5ldyBMb2NhbFJlc291cmNlQWNjZXNzKAorCQkJCQlyZXNvdXJjZVNldCksIG5ldyBJQWNjZXB0b3I8SVJlZmVyZW5jZURlc2NyaXB0aW9uPigpIHsKKwkJCQlAT3ZlcnJpZGUKKwkJCQlwdWJsaWMgdm9pZCBhY2NlcHQoSVJlZmVyZW5jZURlc2NyaXB0aW9uIHQpIHsKKwkJCQkJaWYgKHQuZ2V0RVJlZmVyZW5jZSgpID09IE9TQlBTZXJ2aWNlUGFja2FnZS5MaXRlcmFscy5MRFRPX1NFUlZJQ0VfX0RUTykgeworCQkJCQkJdGFyZ2V0U2VydmljZVJlZmVyZW5jZXMuYWRkKHQpOworCQkJCQl9CisJCQkJfQorCQkJfSwgbnVsbCk7CisJCQlyZXR1cm4gdGFyZ2V0U2VydmljZVJlZmVyZW5jZXM7CisJCX0KKworCQkvKioKKwkJICogTG9hZCBzZW1hbnRpYyBtb2RlbC4KKwkJICoKKwkJICogQHBhcmFtIDxBPgorCQkgKiAgICAgICAgICAgIHRoZSBnZW5lcmljIHR5cGUKKwkJICogQHBhcmFtIG1vZGVsVVJJCisJCSAqICAgICAgICAgICAgdGhlIG1vZGVsIHVyaQorCQkgKiBAcmV0dXJuIHRoZSBhCisJCSAqLworCQlAU3VwcHJlc3NXYXJuaW5ncygidW5jaGVja2VkIikKKwkJcHJpdmF0ZSA8QSBleHRlbmRzIEVPYmplY3Q+IEEgbG9hZFNlbWFudGljTW9kZWwoVVJJIG1vZGVsVVJJKSB7CisJCQlYdGV4dFJlc291cmNlU2V0IHJzID0gKFh0ZXh0UmVzb3VyY2VTZXQpIHJzUHJvdmlkZXIKKwkJCQkJLmdldChnZXRQcm9qZWN0KCkpOworCQkJUmVzb3VyY2UgcmVzb3VyY2UgPSBycy5nZXRSZXNvdXJjZShtb2RlbFVSSSwgdHJ1ZSk7CisJCQl0cnkgeworCQkJCXJlc291cmNlLmxvYWQobnVsbCk7CisJCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBlKSB7CisJCQkJZS5wcmludFN0YWNrVHJhY2UoKTsKKwkJCQlyZXR1cm4gbnVsbDsKKwkJCX0KKwkJCUEgc2VtYW50aWNNb2RlbCA9IG51bGw7CisJCQlpZiAocmVzb3VyY2UgaW5zdGFuY2VvZiBJU2VtYW50aWNMb2FkaW5nUmVzb3VyY2UpIHsKKwkJCQlzZW1hbnRpY01vZGVsID0gKEEpICgoSVNlbWFudGljTG9hZGluZ1Jlc291cmNlKSByZXNvdXJjZSkKKwkJCQkJCS5nZXRTZW1hbnRpY0VsZW1lbnQoKTsKKwkJCX0gZWxzZSB7CisJCQkJc2VtYW50aWNNb2RlbCA9IChBKSByZXNvdXJjZS5nZXRDb250ZW50cygpLmdldCgwKTsKKwkJCX0KKworCQkJTE9HR0VSLmluZm8oImZpbmlzaGVkIGxvYWRpbmc6IiArIG1vZGVsVVJJKTsKKwkJCXJldHVybiBzZW1hbnRpY01vZGVsOworCQl9CisKKwkJLyoqCisJCSAqIENsZWFuLgorCQkgKgorCQkgKiBAcGFyYW0gbW9uaXRvcgorCQkgKiAgICAgICAgICAgIHRoZSBtb25pdG9yCisJCSAqIEB0aHJvd3MgQ29yZUV4Y2VwdGlvbgorCQkgKiAgICAgICAgICAgICB0aGUgY29yZSBleGNlcHRpb24KKwkJICovCisJCXByb3RlY3RlZCB2b2lkIGNsZWFuKElQcm9ncmVzc01vbml0b3IgbW9uaXRvcikgdGhyb3dzIENvcmVFeGNlcHRpb24geworCQl9CisJfQorCisJLyoqCisJICogVGhlIENsYXNzIFNvdXJjZVR5cGVTdG9yZS4KKwkgKi8KKwlwcml2YXRlIHN0YXRpYyBjbGFzcyBTb3VyY2VUeXBlU3RvcmUgZXh0ZW5kcyBBZGFwdGVySW1wbCB7CisKKwkJLyoqIFRoZSBzb3VyY2UgdHlwZS4gKi8KKwkJcHJpdmF0ZSBmaW5hbCBMVHlwZSBzb3VyY2VUeXBlOworCisJCS8qKiBUaGUgYWRhcHRlZC4gKi8KKwkJcHJpdmF0ZSBmaW5hbCBMVHlwZSBhZGFwdGVkOworCisJCS8qKgorCQkgKiBJbnN0YW50aWF0ZXMgYSBuZXcgc291cmNlIHR5cGUgc3RvcmUuCisJCSAqCisJCSAqIEBwYXJhbSBzb3VyY2VUeXBlCisJCSAqICAgICAgICAgICAgdGhlIHNvdXJjZSB0eXBlCisJCSAqIEBwYXJhbSBhZGFwdGVkCisJCSAqICAgICAgICAgICAgdGhlIGFkYXB0ZWQKKwkJICovCisJCXB1YmxpYyBTb3VyY2VUeXBlU3RvcmUoTFR5cGUgc291cmNlVHlwZSwgTFR5cGUgYWRhcHRlZCkgeworCQkJc3VwZXIoKTsKKwkJCXRoaXMuc291cmNlVHlwZSA9IHNvdXJjZVR5cGU7CisJCQl0aGlzLmFkYXB0ZWQgPSBhZGFwdGVkOworCisJCQlhZGFwdGVkLmVBZGFwdGVycygpLmFkZCh0aGlzKTsKKwkJfQorCisJCS8qKgorCQkgKiBEaXNwb3NlLgorCQkgKi8KKwkJcHVibGljIHZvaWQgZGlzcG9zZSgpIHsKKwkJCWFkYXB0ZWQuZUFkYXB0ZXJzKCkucmVtb3ZlKHRoaXMpOworCQl9CisKKwkJLyoqCisJCSAqIEZpbmQgc291cmNlIHR5cGUuCisJCSAqCisJCSAqIEBwYXJhbSBhZGFwdGVkCisJCSAqICAgICAgICAgICAgdGhlIGFkYXB0ZWQKKwkJICogQHJldHVybiB0aGUgbCB0eXBlCisJCSAqLworCQlwdWJsaWMgc3RhdGljIExUeXBlIGZpbmRTb3VyY2VUeXBlKExUeXBlIGFkYXB0ZWQpIHsKKwkJCWZvciAoQWRhcHRlciBhZGFwdGVyIDogYWRhcHRlZC5lQWRhcHRlcnMoKSkgeworCQkJCWlmIChhZGFwdGVyIGluc3RhbmNlb2YgU291cmNlVHlwZVN0b3JlKSB7CisJCQkJCVNvdXJjZVR5cGVTdG9yZSBzdG9yZSA9IChTb3VyY2VUeXBlU3RvcmUpIGFkYXB0ZXI7CisJCQkJCXJldHVybiBzdG9yZS5zb3VyY2VUeXBlOworCQkJCX0KKwkJCX0KKwkJCXJldHVybiBudWxsOworCQl9CisKKwl9CisKKwkvKioKKwkgKiBUaGUgQ2xhc3MgTG9jYWxSZXNvdXJjZUFjY2Vzcy4KKwkgKi8KKwlwdWJsaWMgc3RhdGljIGNsYXNzIExvY2FsUmVzb3VyY2VBY2Nlc3MgaW1wbGVtZW50cworCQkJSVJlZmVyZW5jZUZpbmRlci5JTG9jYWxSZXNvdXJjZUFjY2VzcyB7CisKKwkJLyoqIFRoZSByZXNvdXJjZSBzZXQuICovCisJCXByaXZhdGUgUmVzb3VyY2VTZXQgcmVzb3VyY2VTZXQ7CisKKwkJLyoqCisJCSAqIEluc3RhbnRpYXRlcyBhIG5ldyBsb2NhbCByZXNvdXJjZSBhY2Nlc3MuCisJCSAqCisJCSAqIEBwYXJhbSByZXNvdXJjZVNldAorCQkgKiAgICAgICAgICAgIHRoZSByZXNvdXJjZSBzZXQKKwkJICovCisJCXB1YmxpYyBMb2NhbFJlc291cmNlQWNjZXNzKFJlc291cmNlU2V0IHJlc291cmNlU2V0KSB7CisJCQl0aGlzLnJlc291cmNlU2V0ID0gcmVzb3VyY2VTZXQ7CisJCX0KKworCQkvKgorCQkgKiAobm9uLUphdmFkb2MpCisJCSAqIAorCQkgKiBAc2VlCisJCSAqIG9yZy5lY2xpcHNlLnh0ZXh0LmZpbmRSZWZlcmVuY2VzLklSZWZlcmVuY2VGaW5kZXIuSVJlc291cmNlQWNjZXNzCisJCSAqICNyZWFkT25seShvcmcuZWNsaXBzZS5lbWYuY29tbW9uLnV0aWwuVVJJLAorCQkgKiBvcmcuZWNsaXBzZS54dGV4dC51dGlsLmNvbmN1cnJlbnQuSVVuaXRPZldvcmspCisJCSAqLworCQlwdWJsaWMgPFI+IFIgcmVhZE9ubHkoVVJJIHRhcmdldFVSSSwgSVVuaXRPZldvcms8UiwgUmVzb3VyY2VTZXQ+IHdvcmspIHsKKwkJCXRyeSB7CisJCQkJcmV0dXJuIHdvcmsuZXhlYyhyZXNvdXJjZVNldCk7CisJCQl9IGNhdGNoIChPcGVyYXRpb25DYW5jZWxlZEV4Y2VwdGlvbiBlKSB7CisJCQkJdGhyb3cgZTsKKwkJCX0gY2F0Y2ggKEV4Y2VwdGlvbiBleGMpIHsKKwkJCQl0aHJvdyBuZXcgV3JhcHBlZEV4Y2VwdGlvbihleGMpOworCQkJfQorCQl9CisKKwl9CisKKwlwcml2YXRlIHN0YXRpYyBjbGFzcyBQZW5kaW5nIHsKKworCQkvLyBpZiBlbXB0eSwgdGhlbiBwZW5kaW5nIHdhcyB0cmlnZ2VyZWQgZm9yIGluaXRpYWwgYnVpbGQKKwkJcHVibGljIGZpbmFsIElSZXNvdXJjZURlc2NyaXB0aW9uIGRlc2M7CisKKwkJcHVibGljIGZpbmFsIFVSSSB1cmk7CisKKwkJcHVibGljIFBlbmRpbmcoSVJlc291cmNlRGVzY3JpcHRpb24gZGVzYykgeworCQkJdGhpcy5kZXNjID0gZGVzYzsKKwkJCXRoaXMudXJpID0gZGVzYy5nZXRVUkkoKTsKKwkJfQorCisJCXB1YmxpYyBQZW5kaW5nKFVSSSB1cmkpIHsKKwkJCXRoaXMuZGVzYyA9IG51bGw7CisJCQl0aGlzLnVyaSA9IHVyaTsKKwkJfQorCisJfQorfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9pMThuL0kxOG5SZWdpc3RyeVZpZXcuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvaTE4bi9JMThuUmVnaXN0cnlWaWV3LmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNWY4M2MwNQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvaTE4bi9JMThuUmVnaXN0cnlWaWV3LmphdmEKQEAgLTAsMCArMSwxOTMgQEAKKy8qKgorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE1IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiwgQXVzdHJpYSksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorICoKKyAqIENvbnRyaWJ1dG9yczoKKyAqICAgICAgICAgRmxvcmlhbiBQaXJjaG5lciAtIEluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLmkxOG47CisKK2ltcG9ydCBqYXZhLnV0aWwuSGFzaE1hcDsKK2ltcG9ydCBqYXZhLnV0aWwuTWFwOworaW1wb3J0IGphdmEudXRpbC5NYXAuRW50cnk7CitpbXBvcnQgamF2YS51dGlsLlByb3BlcnRpZXM7CitpbXBvcnQgamF2YS51dGlsLlNldDsKKworaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuSVRyZWVDb250ZW50UHJvdmlkZXI7CitpbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5MYWJlbFByb3ZpZGVyOworaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuVHJlZVZpZXdlcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLlZpZXdlcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5zd3QuZ3JhcGhpY3MuSW1hZ2U7CitpbXBvcnQgb3JnLmVjbGlwc2Uuc3d0LndpZGdldHMuQ29tcG9zaXRlOworaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkRpc3BsYXk7CitpbXBvcnQgb3JnLmVjbGlwc2UudWkucGFydC5WaWV3UGFydDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS5pMThuLkNvcmVVdGlsOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpLmkxOG4uSUkxOG5SZWdpc3RyeTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS5pMThuLklJMThuUmVnaXN0cnkuUHJvamVjdERlc2NyaXB0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpLmkxOG4uSUkxOG5SZWdpc3RyeS5SZXNvdXJjZURlc2NyaXB0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuQ29yZVVpQWN0aXZhdG9yOworaW1wb3J0IG9yZy5vc2dpLmZyYW1ld29yay5TZXJ2aWNlUmVnaXN0cmF0aW9uOworaW1wb3J0IG9yZy5vc2dpLnNlcnZpY2UuZXZlbnQuRXZlbnQ7CitpbXBvcnQgb3JnLm9zZ2kuc2VydmljZS5ldmVudC5FdmVudENvbnN0YW50czsKK2ltcG9ydCBvcmcub3NnaS5zZXJ2aWNlLmV2ZW50LkV2ZW50SGFuZGxlcjsKKworaW1wb3J0IGNvbS5nb29nbGUuaW5qZWN0LkluamVjdDsKKworcHVibGljIGNsYXNzIEkxOG5SZWdpc3RyeVZpZXcgZXh0ZW5kcyBWaWV3UGFydCB7CisJCisJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgSUQgPSAib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5pMThudmlldyI7CisKKwlASW5qZWN0CisJcHJpdmF0ZSBJSTE4blJlZ2lzdHJ5IHJlZ2lzdHJ5OworCisJcHJpdmF0ZSBJbWFnZSBwcm9qZWN0SW1hZ2UgPSBDb3JlVWlBY3RpdmF0b3IuaW1hZ2VEZXNjcmlwdG9yRnJvbVBsdWdpbigKKwkJCUNvcmVVaUFjdGl2YXRvci5QTFVHSU5fSUQsICJpY29ucy9Qcm9qZWN0LmdpZiIpLmNyZWF0ZUltYWdlKCk7CisJcHJpdmF0ZSBJbWFnZSByZXNvdXJjZUltYWdlID0gQ29yZVVpQWN0aXZhdG9yLmltYWdlRGVzY3JpcHRvckZyb21QbHVnaW4oCisJCQlDb3JlVWlBY3RpdmF0b3IuUExVR0lOX0lELCAiaWNvbnMvUmVzb3VyY2UuZ2lmIikuY3JlYXRlSW1hZ2UoKTsKKwlwcml2YXRlIEltYWdlIHByb3BlcnR5SW1hZ2UgPSBDb3JlVWlBY3RpdmF0b3IuaW1hZ2VEZXNjcmlwdG9yRnJvbVBsdWdpbigKKwkJCUNvcmVVaUFjdGl2YXRvci5QTFVHSU5fSUQsICJpY29ucy9Qcm9wZXJ0eS5naWYiKS5jcmVhdGVJbWFnZSgpOworCisJcHJpdmF0ZSBUcmVlVmlld2VyIHRyZWVWaWV3ZXI7CisKKwlwcml2YXRlIFNlcnZpY2VSZWdpc3RyYXRpb248RXZlbnRIYW5kbGVyPiByZWdpc3RyYXRpb247CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgdm9pZCBjcmVhdGVQYXJ0Q29udHJvbChDb21wb3NpdGUgcGFyZW50KSB7CisKKwkJdHJlZVZpZXdlciA9IG5ldyBUcmVlVmlld2VyKHBhcmVudCk7CisJCXRyZWVWaWV3ZXIuc2V0Q29udGVudFByb3ZpZGVyKG5ldyBDb250ZW50UHJvdmlkZXIoKSk7CisJCXRyZWVWaWV3ZXIuc2V0TGFiZWxQcm92aWRlcihuZXcgTGFiZWxQcm92aWRlcigpIHsKKwkJCUBPdmVycmlkZQorCQkJcHVibGljIEltYWdlIGdldEltYWdlKE9iamVjdCBlbGVtZW50KSB7CisJCQkJaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBJSTE4blJlZ2lzdHJ5LlByb2plY3REZXNjcmlwdGlvbikgeworCQkJCQlyZXR1cm4gcHJvamVjdEltYWdlOworCQkJCX0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIElJMThuUmVnaXN0cnkuUmVzb3VyY2VEZXNjcmlwdGlvbikgeworCQkJCQlyZXR1cm4gcmVzb3VyY2VJbWFnZTsKKwkJCQl9IGVsc2UgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBFbnRyeSkgeworCQkJCQlyZXR1cm4gcHJvcGVydHlJbWFnZTsKKwkJCQl9CisJCQkJcmV0dXJuIHN1cGVyLmdldEltYWdlKGVsZW1lbnQpOworCQkJfQorCisJCQlAT3ZlcnJpZGUKKwkJCXB1YmxpYyBTdHJpbmcgZ2V0VGV4dChPYmplY3QgZWxlbWVudCkgeworCQkJCWlmIChlbGVtZW50IGluc3RhbmNlb2YgSUkxOG5SZWdpc3RyeS5Qcm9qZWN0RGVzY3JpcHRpb24pIHsKKwkJCQkJSUkxOG5SZWdpc3RyeS5Qcm9qZWN0RGVzY3JpcHRpb24gZGVzYyA9IChQcm9qZWN0RGVzY3JpcHRpb24pIGVsZW1lbnQ7CisJCQkJCXJldHVybiBkZXNjLmdldFByb2plY3QoKS5nZXROYW1lKCk7CisJCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgSUkxOG5SZWdpc3RyeS5SZXNvdXJjZURlc2NyaXB0aW9uKSB7CisKKwkJCQkJSUkxOG5SZWdpc3RyeS5SZXNvdXJjZURlc2NyaXB0aW9uIGRlc2MgPSAoSUkxOG5SZWdpc3RyeS5SZXNvdXJjZURlc2NyaXB0aW9uKSBlbGVtZW50OworCisJCQkJCVN0cmluZyBsYW5ndWFnZVRhZyA9IGRlc2MuZ2V0TG9jYWxlKCkudG9MYW5ndWFnZVRhZygpOworCQkJCQlpZiAoZGVzYy5nZXRMb2NhbGUoKS50b1N0cmluZygpLmVxdWFscygiIikpIHsKKwkJCQkJCWxhbmd1YWdlVGFnID0gImVtcHR5IjsKKwkJCQkJfQorCQkJCQlyZXR1cm4gU3RyaW5nLmZvcm1hdCgiJXM6ICVzIiwgbGFuZ3VhZ2VUYWcsIGRlc2MuZ2V0UGF0aCgpCisJCQkJCQkJLm1ha2VSZWxhdGl2ZSgpLnRvU3RyaW5nKCkpOworCQkJCX0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIEVudHJ5KSB7CisJCQkJCUBTdXBwcmVzc1dhcm5pbmdzKCJ1bmNoZWNrZWQiKQorCQkJCQlFbnRyeTxTdHJpbmcsIFN0cmluZz4gZW50cnkgPSAoRW50cnk8U3RyaW5nLCBTdHJpbmc+KSBlbGVtZW50OworCQkJCQlyZXR1cm4gU3RyaW5nLmZvcm1hdCgiJXMgPSAlcyIsIGVudHJ5LmdldEtleSgpLAorCQkJCQkJCWVudHJ5LmdldFZhbHVlKCkpOworCQkJCX0KKwkJCQlyZXR1cm4gIiI7CisJCQl9CisJCX0pOworCisJCXRyZWVWaWV3ZXIuc2V0SW5wdXQocmVnaXN0cnkpOworCisJCXJlZ2lzdGVyRXZlbnRBZG1pbigpOworCisJfQorCisJLyoqCisJICogUmVnaXN0ZXJzIGZvciBub3RpZmljYXRpb24gYWJvdXQgdGhlIGJ1aWxkLgorCSAqLworCXByaXZhdGUgdm9pZCByZWdpc3RlckV2ZW50QWRtaW4oKSB7CisJCUV2ZW50SGFuZGxlciBoYW5kbGVyID0gbmV3IEV2ZW50SGFuZGxlcigpIHsKKwkJCUBPdmVycmlkZQorCQkJcHVibGljIHZvaWQgaGFuZGxlRXZlbnQoRXZlbnQgZXZlbnQpIHsKKwkJCQlEaXNwbGF5LmdldERlZmF1bHQoKS5hc3luY0V4ZWMobmV3IFJ1bm5hYmxlKCkgeworCQkJCQlAT3ZlcnJpZGUKKwkJCQkJcHVibGljIHZvaWQgcnVuKCkgeworCQkJCQkJdHJlZVZpZXdlci5yZWZyZXNoKCk7CisJCQkJCX0KKwkJCQl9KTsKKwkJCX0KKwkJfTsKKwkJTWFwPFN0cmluZywgU3RyaW5nPiBwcm9wcyA9IG5ldyBIYXNoTWFwPFN0cmluZywgU3RyaW5nPigpOworCQlwcm9wcy5wdXQoRXZlbnRDb25zdGFudHMuRVZFTlRfVE9QSUMsIENvcmVVdGlsLkVWRU5UX1RPUElDX19CVUlMREVSKTsKKwkJcmVnaXN0cmF0aW9uID0gQ29yZVVpQWN0aXZhdG9yLmdldERlZmF1bHQoKS5yZWdpc3RlckV2ZW50SGFuZGxlcigKKwkJCQloYW5kbGVyLCBwcm9wcyk7CisJfQorCisJQE92ZXJyaWRlCisJcHVibGljIHZvaWQgc2V0Rm9jdXMoKSB7CisKKwl9CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgdm9pZCBkaXNwb3NlKCkgeworCQlwcm9qZWN0SW1hZ2UuZGlzcG9zZSgpOworCQlyZXNvdXJjZUltYWdlLmRpc3Bvc2UoKTsKKwkJcHJvcGVydHlJbWFnZS5kaXNwb3NlKCk7CisKKwkJcmVnaXN0cmF0aW9uLnVucmVnaXN0ZXIoKTsKKworCQlzdXBlci5kaXNwb3NlKCk7CisJfQorCisJcHJpdmF0ZSBjbGFzcyBDb250ZW50UHJvdmlkZXIgaW1wbGVtZW50cyBJVHJlZUNvbnRlbnRQcm92aWRlciB7CisKKwkJQE92ZXJyaWRlCisJCXB1YmxpYyB2b2lkIGRpc3Bvc2UoKSB7CisKKwkJfQorCisJCUBPdmVycmlkZQorCQlwdWJsaWMgdm9pZCBpbnB1dENoYW5nZWQoVmlld2VyIHZpZXdlciwgT2JqZWN0IG9sZElucHV0LCBPYmplY3QgbmV3SW5wdXQpIHsKKwkJfQorCisJCUBPdmVycmlkZQorCQlwdWJsaWMgT2JqZWN0W10gZ2V0RWxlbWVudHMoT2JqZWN0IGlucHV0RWxlbWVudCkgeworCQkJU2V0PFByb2plY3REZXNjcmlwdGlvbj4gdGVtcCA9IHJlZ2lzdHJ5LmdldFByb2plY3REZXNjcmlwdGlvbnMoKTsKKwkJCXJldHVybiB0ZW1wLnRvQXJyYXkoKTsKKwkJfQorCisJCUBPdmVycmlkZQorCQlwdWJsaWMgT2JqZWN0W10gZ2V0Q2hpbGRyZW4oT2JqZWN0IHBhcmVudEVsZW1lbnQpIHsKKwkJCWlmIChwYXJlbnRFbGVtZW50IGluc3RhbmNlb2YgUHJvamVjdERlc2NyaXB0aW9uKSB7CisJCQkJU2V0PFJlc291cmNlRGVzY3JpcHRpb24+IGRlc2NzID0gKChQcm9qZWN0RGVzY3JpcHRpb24pIHBhcmVudEVsZW1lbnQpCisJCQkJCQkuZ2V0UmVzb3VyY2VEZXNjcmlwdGlvbnMoKTsKKwkJCQlyZXR1cm4gZGVzY3MudG9BcnJheSgpOworCQkJfSBlbHNlIGlmIChwYXJlbnRFbGVtZW50IGluc3RhbmNlb2YgUmVzb3VyY2VEZXNjcmlwdGlvbikgeworCQkJCVByb3BlcnRpZXMgcHJvcHMgPSAoKFJlc291cmNlRGVzY3JpcHRpb24pIHBhcmVudEVsZW1lbnQpCisJCQkJCQkuZ2V0UHJvcGVydGllcygpOworCQkJCXJldHVybiBwcm9wcy5lbnRyeVNldCgpLnRvQXJyYXkoKTsKKwkJCX0KKwkJCXJldHVybiBudWxsOworCQl9CisKKwkJQE92ZXJyaWRlCisJCXB1YmxpYyBPYmplY3QgZ2V0UGFyZW50KE9iamVjdCBlbGVtZW50KSB7CisJCQlyZXR1cm4gbnVsbDsKKwkJfQorCisJCUBPdmVycmlkZQorCQlwdWJsaWMgYm9vbGVhbiBoYXNDaGlsZHJlbihPYmplY3QgZWxlbWVudCkgeworCQkJaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBQcm9qZWN0RGVzY3JpcHRpb24pIHsKKwkJCQlTZXQ8UmVzb3VyY2VEZXNjcmlwdGlvbj4gZGVzY3MgPSAoKFByb2plY3REZXNjcmlwdGlvbikgZWxlbWVudCkKKwkJCQkJCS5nZXRSZXNvdXJjZURlc2NyaXB0aW9ucygpOworCQkJCXJldHVybiAhZGVzY3MuaXNFbXB0eSgpOworCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgUmVzb3VyY2VEZXNjcmlwdGlvbikgeworCQkJCVByb3BlcnRpZXMgcHJvcHMgPSAoKFJlc291cmNlRGVzY3JpcHRpb24pIGVsZW1lbnQpCisJCQkJCQkuZ2V0UHJvcGVydGllcygpOworCQkJCXJldHVybiAhcHJvcHMuaXNFbXB0eSgpOworCQkJfQorCQkJcmV0dXJuIGZhbHNlOworCQl9CisJfQorfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9uYXR1cmUvT1NCUE5hdHVyZS5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9uYXR1cmUvT1NCUE5hdHVyZS5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjk0NGYwMWYKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS9jb3JlL3VpL25hdHVyZS9PU0JQTmF0dXJlLmphdmEKQEAgLTAsMCArMSwxMTQgQEAKKy8qKgorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE1IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiwgQXVzdHJpYSksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorICoKKyAqIENvbnRyaWJ1dG9yczoKKyAqICAgICAgICAgRmxvcmlhbiBQaXJjaG5lciAtIEluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLm5hdHVyZTsKKworaW1wb3J0IGphdmEudXRpbC5BcnJheUxpc3Q7CitpbXBvcnQgamF2YS51dGlsLkFycmF5czsKK2ltcG9ydCBqYXZhLnV0aWwuQ29tcGFyYXRvcjsKK2ltcG9ydCBqYXZhLnV0aWwuSXRlcmF0b3I7CitpbXBvcnQgamF2YS51dGlsLkxpc3Q7CisKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JQ29tbWFuZDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JUHJvamVjdDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JUHJvamVjdERlc2NyaXB0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklQcm9qZWN0TmF0dXJlOworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5Db3JlRXhjZXB0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpLmkxOG4uQ29yZVV0aWw7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5idWlsZGVyLk9TQlBJMThuQnVpbGRlcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLmJ1aWxkZXIuT1NCUE1vZGVsRW5oYW5jaW5nQnVpbGRlcjsKKworcHVibGljIGNsYXNzIE9TQlBOYXR1cmUgaW1wbGVtZW50cyBJUHJvamVjdE5hdHVyZSB7CisKKwlwdWJsaWMgc3RhdGljIFN0cmluZyBOQVRVUkVfSUQgPSBDb3JlVXRpbC5OQVRVUkVfSUQ7CisKKwlwcml2YXRlIElQcm9qZWN0IHByb2plY3Q7CisKKwlwdWJsaWMgdm9pZCBjb25maWd1cmUoKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiB7CisJCUlQcm9qZWN0RGVzY3JpcHRpb24gZGVzYyA9IHByb2plY3QuZ2V0RGVzY3JpcHRpb24oKTsKKwkJSUNvbW1hbmRbXSBjb21tYW5kcyA9IGRlc2MuZ2V0QnVpbGRTcGVjKCk7CisKKwkJTGlzdDxJQ29tbWFuZD4gdGVtcCA9IG5ldyBBcnJheUxpc3Q8SUNvbW1hbmQ+KEFycmF5cy5hc0xpc3QoY29tbWFuZHMpKTsKKwkJaWYgKCFjb250YWlucyh0ZW1wLCBPU0JQTW9kZWxFbmhhbmNpbmdCdWlsZGVyLkJVSUxERVJfSUQpKSB7CisJCQlJQ29tbWFuZCBjb21tYW5kID0gZGVzYy5uZXdDb21tYW5kKCk7CisJCQljb21tYW5kLnNldEJ1aWxkZXJOYW1lKE9TQlBNb2RlbEVuaGFuY2luZ0J1aWxkZXIuQlVJTERFUl9JRCk7CisJCQl0ZW1wLmFkZChjb21tYW5kKTsKKwkJfQorCisJCWlmICghY29udGFpbnModGVtcCwgT1NCUEkxOG5CdWlsZGVyLkJVSUxERVJfSUQpKSB7CisJCQlJQ29tbWFuZCBjb21tYW5kID0gZGVzYy5uZXdDb21tYW5kKCk7CisJCQljb21tYW5kLnNldEJ1aWxkZXJOYW1lKE9TQlBJMThuQnVpbGRlci5CVUlMREVSX0lEKTsKKwkJCXRlbXAuYWRkKGNvbW1hbmQpOworCQl9CisKKwkJdGVtcC5zb3J0KG5ldyBDb21wYXJhdG9yPElDb21tYW5kPigpIHsKKwkJCUBPdmVycmlkZQorCQkJcHVibGljIGludCBjb21wYXJlKElDb21tYW5kIG8xLCBJQ29tbWFuZCBvMikgeworCQkJCXJldHVybiBnZXRJbmRleChvMS5nZXRCdWlsZGVyTmFtZSgpKQorCQkJCQkJLSBnZXRJbmRleChvMi5nZXRCdWlsZGVyTmFtZSgpKTsKKwkJCX0KKworCQkJcHJpdmF0ZSBpbnQgZ2V0SW5kZXgoU3RyaW5nIGJzbikgeworCQkJCWlmIChic24uZXF1YWxzKCJvcmcuZWNsaXBzZS54dGV4dC51aS5zaGFyZWQueHRleHRCdWlsZGVyIikpIHsKKwkJCQkJcmV0dXJuIDA7CisJCQkJfSBlbHNlIGlmIChic24uc3RhcnRzV2l0aCgib3JnLmVjbGlwc2Uub3NicCIpKSB7CisJCQkJCXJldHVybiAxOworCQkJCX0gZWxzZSBpZiAoYnNuLmVxdWFscygib3JnLmVjbGlwc2UuamR0LmNvcmUuamF2YWJ1aWxkZXIiKSkgeworCQkJCQlyZXR1cm4gMjsKKwkJCQl9CisJCQkJcmV0dXJuIDM7CisJCQl9CisKKwkJfSk7CisKKwkJZGVzYy5zZXRCdWlsZFNwZWModGVtcC50b0FycmF5KG5ldyBJQ29tbWFuZFt0ZW1wLnNpemUoKV0pKTsKKwkJcHJvamVjdC5zZXREZXNjcmlwdGlvbihkZXNjLCBudWxsKTsKKwl9CisKKwlwcml2YXRlIGJvb2xlYW4gY29udGFpbnMoTGlzdDxJQ29tbWFuZD4gdGVtcCwgU3RyaW5nIGJ1aWxkZXJJZCkgeworCQlmb3IgKElDb21tYW5kIGNtZCA6IHRlbXApIHsKKwkJCWlmIChjbWQuZ2V0QnVpbGRlck5hbWUoKS5lcXVhbHMoYnVpbGRlcklkKSkgeworCQkJCXJldHVybiB0cnVlOworCQkJfQorCQl9CisJCXJldHVybiBmYWxzZTsKKwl9CisKKwlwcml2YXRlIHZvaWQgcmVtb3ZlKExpc3Q8SUNvbW1hbmQ+IHRlbXAsIFN0cmluZyBidWlsZGVySWQpIHsKKwkJZm9yIChJdGVyYXRvcjxJQ29tbWFuZD4gaXRlcmF0b3IgPSB0ZW1wLml0ZXJhdG9yKCk7IGl0ZXJhdG9yLmhhc05leHQoKTspIHsKKwkJCUlDb21tYW5kIGlDb21tYW5kID0gaXRlcmF0b3IubmV4dCgpOworCQkJaWYgKGlDb21tYW5kLmdldEJ1aWxkZXJOYW1lKCkuZXF1YWxzKGJ1aWxkZXJJZCkpIHsKKwkJCQlpdGVyYXRvci5yZW1vdmUoKTsKKwkJCQlyZXR1cm47CisJCQl9CisJCX0KKwl9CisKKwlwdWJsaWMgdm9pZCBkZWNvbmZpZ3VyZSgpIHRocm93cyBDb3JlRXhjZXB0aW9uIHsKKwkJSVByb2plY3REZXNjcmlwdGlvbiBkZXNjcmlwdGlvbiA9IGdldFByb2plY3QoKS5nZXREZXNjcmlwdGlvbigpOworCQlJQ29tbWFuZFtdIGNvbW1hbmRzID0gZGVzY3JpcHRpb24uZ2V0QnVpbGRTcGVjKCk7CisJCUxpc3Q8SUNvbW1hbmQ+IHRlbXAgPSBuZXcgQXJyYXlMaXN0PElDb21tYW5kPihBcnJheXMuYXNMaXN0KGNvbW1hbmRzKSk7CisKKwkJcmVtb3ZlKHRlbXAsIE9TQlBNb2RlbEVuaGFuY2luZ0J1aWxkZXIuQlVJTERFUl9JRCk7CisJCXJlbW92ZSh0ZW1wLCBPU0JQSTE4bkJ1aWxkZXIuQlVJTERFUl9JRCk7CisKKwkJZGVzY3JpcHRpb24uc2V0QnVpbGRTcGVjKHRlbXAudG9BcnJheShuZXcgSUNvbW1hbmRbdGVtcC5zaXplKCldKSk7CisJCXByb2plY3Quc2V0RGVzY3JpcHRpb24oZGVzY3JpcHRpb24sIG51bGwpOworCX0KKworCXB1YmxpYyBJUHJvamVjdCBnZXRQcm9qZWN0KCkgeworCQlyZXR1cm4gcHJvamVjdDsKKwl9CisKKwlwdWJsaWMgdm9pZCBzZXRQcm9qZWN0KElQcm9qZWN0IHByb2plY3QpIHsKKwkJdGhpcy5wcm9qZWN0ID0gcHJvamVjdDsKKwl9CisKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvbmF0dXJlL1RvZ2dsZU9TQlBOYXR1cmVBY3Rpb24uamF2YSBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvbmF0dXJlL1RvZ2dsZU9TQlBOYXR1cmVBY3Rpb24uamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yYjA2MDM1Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9uYXR1cmUvVG9nZ2xlT1NCUE5hdHVyZUFjdGlvbi5qYXZhCkBAIC0wLDAgKzEsOTYgQEAKKy8qKgorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE1IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiwgQXVzdHJpYSksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorICoKKyAqIENvbnRyaWJ1dG9yczoKKyAqICAgICAgICAgRmxvcmlhbiBQaXJjaG5lciAtIEluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLm5hdHVyZTsKKworaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKKworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklQcm9qZWN0OworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklQcm9qZWN0RGVzY3JpcHRpb247CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkNvcmVFeGNlcHRpb247CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklBZGFwdGFibGU7CitpbXBvcnQgb3JnLmVjbGlwc2UuamZhY2UuYWN0aW9uLklBY3Rpb247CitpbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5JU2VsZWN0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuSVN0cnVjdHVyZWRTZWxlY3Rpb247CitpbXBvcnQgb3JnLmVjbGlwc2UudWkuSU9iamVjdEFjdGlvbkRlbGVnYXRlOworaW1wb3J0IG9yZy5lY2xpcHNlLnVpLklXb3JrYmVuY2hQYXJ0OworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpLmkxOG4uQ29yZVV0aWw7CitpbXBvcnQgb3JnLnNsZjRqLkxvZ2dlckZhY3Rvcnk7CisKKy8qKgorICogQGF1dGhvciBTdmVuIEVmZnRpbmdlIC0gSW5pdGlhbCBjb250cmlidXRpb24gYW5kIEFQSQorICovCitwdWJsaWMgY2xhc3MgVG9nZ2xlT1NCUE5hdHVyZUFjdGlvbiBpbXBsZW1lbnRzIElPYmplY3RBY3Rpb25EZWxlZ2F0ZSB7CisKKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBvcmcuc2xmNGouTG9nZ2VyIGxvZyA9IExvZ2dlckZhY3RvcnkKKwkJCS5nZXRMb2dnZXIoVG9nZ2xlT1NCUE5hdHVyZUFjdGlvbi5jbGFzcyk7CisKKwlwcml2YXRlIElTZWxlY3Rpb24gc2VsZWN0aW9uOworCisJcHVibGljIHZvaWQgcnVuKElBY3Rpb24gYWN0aW9uKSB7CisJCWlmIChzZWxlY3Rpb24gaW5zdGFuY2VvZiBJU3RydWN0dXJlZFNlbGVjdGlvbikgeworCQkJZm9yIChJdGVyYXRvcjw/PiBpdCA9ICgoSVN0cnVjdHVyZWRTZWxlY3Rpb24pIHNlbGVjdGlvbikuaXRlcmF0b3IoKTsgaXQKKwkJCQkJLmhhc05leHQoKTspIHsKKwkJCQlPYmplY3QgZWxlbWVudCA9IGl0Lm5leHQoKTsKKwkJCQlJUHJvamVjdCBwcm9qZWN0ID0gbnVsbDsKKwkJCQlpZiAoZWxlbWVudCBpbnN0YW5jZW9mIElQcm9qZWN0KSB7CisJCQkJCXByb2plY3QgPSAoSVByb2plY3QpIGVsZW1lbnQ7CisJCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgSUFkYXB0YWJsZSkgeworCQkJCQlwcm9qZWN0ID0gKElQcm9qZWN0KSAoKElBZGFwdGFibGUpIGVsZW1lbnQpCisJCQkJCQkJLmdldEFkYXB0ZXIoSVByb2plY3QuY2xhc3MpOworCQkJCX0KKwkJCQlpZiAocHJvamVjdCAhPSBudWxsKSB7CisJCQkJCXRvZ2dsZU5hdHVyZShwcm9qZWN0KTsKKwkJCQl9CisJCQl9CisJCX0KKwl9CisKKwlwdWJsaWMgdm9pZCBzZWxlY3Rpb25DaGFuZ2VkKElBY3Rpb24gYWN0aW9uLCBJU2VsZWN0aW9uIHNlbGVjdGlvbikgeworCQl0aGlzLnNlbGVjdGlvbiA9IHNlbGVjdGlvbjsKKwl9CisKKwlwdWJsaWMgdm9pZCBzZXRBY3RpdmVQYXJ0KElBY3Rpb24gYWN0aW9uLCBJV29ya2JlbmNoUGFydCB0YXJnZXRQYXJ0KSB7CisJfQorCisJcHVibGljIHZvaWQgdG9nZ2xlTmF0dXJlKElQcm9qZWN0IHByb2plY3QpIHsKKwkJdHJ5IHsKKwkJCUlQcm9qZWN0RGVzY3JpcHRpb24gZGVzY3JpcHRpb24gPSBwcm9qZWN0LmdldERlc2NyaXB0aW9uKCk7CisJCQlTdHJpbmdbXSBuYXR1cmVzID0gZGVzY3JpcHRpb24uZ2V0TmF0dXJlSWRzKCk7CisKKwkJCWZvciAoaW50IGkgPSAwOyBpIDwgbmF0dXJlcy5sZW5ndGg7ICsraSkgeworCQkJCWlmIChPU0JQTmF0dXJlLk5BVFVSRV9JRC5lcXVhbHMobmF0dXJlc1tpXSkpIHsKKwkJCQkJLy8gUmVtb3ZlIHRoZSBuYXR1cmUKKwkJCQkJU3RyaW5nW10gbmV3TmF0dXJlcyA9IG5ldyBTdHJpbmdbbmF0dXJlcy5sZW5ndGggLSAxXTsKKwkJCQkJU3lzdGVtLmFycmF5Y29weShuYXR1cmVzLCAwLCBuZXdOYXR1cmVzLCAwLCBpKTsKKwkJCQkJU3lzdGVtLmFycmF5Y29weShuYXR1cmVzLCBpICsgMSwgbmV3TmF0dXJlcywgaSwKKwkJCQkJCQluYXR1cmVzLmxlbmd0aCAtIGkgLSAxKTsKKwkJCQkJZGVzY3JpcHRpb24uc2V0TmF0dXJlSWRzKG5ld05hdHVyZXMpOworCQkJCQlwcm9qZWN0LnNldERlc2NyaXB0aW9uKGRlc2NyaXB0aW9uLCBudWxsKTsKKwkJCQkJcmV0dXJuOworCQkJCX0KKwkJCX0KKworCQkJLy8gQWRkIHRoZSBuYXR1cmUKKwkJCVN0cmluZ1tdIG5ld05hdHVyZXMgPSBuZXcgU3RyaW5nW25hdHVyZXMubGVuZ3RoICsgMV07CisJCQlTeXN0ZW0uYXJyYXljb3B5KG5hdHVyZXMsIDAsIG5ld05hdHVyZXMsIDAsIG5hdHVyZXMubGVuZ3RoKTsKKwkJCW5ld05hdHVyZXNbbmF0dXJlcy5sZW5ndGhdID0gT1NCUE5hdHVyZS5OQVRVUkVfSUQ7CisJCQlkZXNjcmlwdGlvbi5zZXROYXR1cmVJZHMobmV3TmF0dXJlcyk7CisJCQlwcm9qZWN0LnNldERlc2NyaXB0aW9uKGRlc2NyaXB0aW9uLCBudWxsKTsKKwkJfSBjYXRjaCAoQ29yZUV4Y2VwdGlvbiBlKSB7CisJCQlsb2cuZXJyb3IoInt9IiwgZSk7CisJCX0KKwl9CisKKwlwdWJsaWMgYm9vbGVhbiBoYXNOYXR1cmUoSVByb2plY3QgcHJvamVjdCkgeworCQlyZXR1cm4gQ29yZVV0aWwuaGFzTmF0dXJlKHByb2plY3QpOworCX0KKworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9wZXJzcGVjdGl2ZS9PU0JQUGVyc3BlY3RpdmVGYWN0b3J5LmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS9jb3JlL3VpL3BlcnNwZWN0aXZlL09TQlBQZXJzcGVjdGl2ZUZhY3RvcnkuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NWEwODY2Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS9wZXJzcGVjdGl2ZS9PU0JQUGVyc3BlY3RpdmVGYWN0b3J5LmphdmEKQEAgLTAsMCArMSwxMDAgQEAKKy8qKgorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE1IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiwgQXVzdHJpYSksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorICoKKyAqIENvbnRyaWJ1dG9yczoKKyAqICAgICAgICAgRmxvcmlhbiBQaXJjaG5lciAtIEluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqLworCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkucGVyc3BlY3RpdmU7CisKK2ltcG9ydCBvcmcuZWNsaXBzZS5kZWJ1Zy51aS5JRGVidWdVSUNvbnN0YW50czsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuaW50ZXJuYWwudWkuSmF2YVBsdWdpbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQudWkuSmF2YVVJOworaW1wb3J0IG9yZy5lY2xpcHNlLnNlYXJjaC51aS5OZXdTZWFyY2hVSTsKK2ltcG9ydCBvcmcuZWNsaXBzZS51aS5JRm9sZGVyTGF5b3V0OworaW1wb3J0IG9yZy5lY2xpcHNlLnVpLklQYWdlTGF5b3V0OworaW1wb3J0IG9yZy5lY2xpcHNlLnVpLklQZXJzcGVjdGl2ZUZhY3Rvcnk7CitpbXBvcnQgb3JnLmVjbGlwc2UudWkuY29uc29sZS5JQ29uc29sZUNvbnN0YW50czsKK2ltcG9ydCBvcmcuZWNsaXBzZS51aS5wcm9ncmVzcy5JUHJvZ3Jlc3NDb25zdGFudHM7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5pMThuLkkxOG5SZWdpc3RyeVZpZXc7CisKK3B1YmxpYyBjbGFzcyBPU0JQUGVyc3BlY3RpdmVGYWN0b3J5IGltcGxlbWVudHMgSVBlcnNwZWN0aXZlRmFjdG9yeSB7CisKKwlwdWJsaWMgdm9pZCBjcmVhdGVJbml0aWFsTGF5b3V0KElQYWdlTGF5b3V0IGxheW91dCkgeworCQlTdHJpbmcgZWRpdG9yQXJlYSA9IGxheW91dC5nZXRFZGl0b3JBcmVhKCk7CisKKwkJSUZvbGRlckxheW91dCBmb2xkZXIgPSBsYXlvdXQuY3JlYXRlRm9sZGVyKAorCQkJCSJsZWZ0IiwgSVBhZ2VMYXlvdXQuTEVGVCwgKGZsb2F0KSAwLjI1LCBlZGl0b3JBcmVhKTsgLy8kTk9OLU5MUy0xJAorCQlmb2xkZXIuYWRkVmlldyhKYXZhVUkuSURfUEFDS0FHRVMpOworCQlmb2xkZXIuYWRkVmlldygib3JnLmVjbGlwc2Uuc2lyaXVzLnVpLnRvb2xzLnZpZXdzLm1vZGVsLmV4cGxvcmVyIik7CisJCWZvbGRlci5hZGRQbGFjZWhvbGRlcihKYXZhVUkuSURfVFlQRV9ISUVSQVJDSFkpOworCQlmb2xkZXIuYWRkUGxhY2Vob2xkZXIoSmF2YVBsdWdpbi5JRF9SRVNfTkFWKTsKKwkJZm9sZGVyLmFkZFBsYWNlaG9sZGVyKElQYWdlTGF5b3V0LklEX1BST0pFQ1RfRVhQTE9SRVIpOworCisJCUlGb2xkZXJMYXlvdXQgb3V0cHV0Zm9sZGVyID0gbGF5b3V0LmNyZWF0ZUZvbGRlcigKKwkJCQkiYm90dG9tIiwgSVBhZ2VMYXlvdXQuQk9UVE9NLCAoZmxvYXQpIDAuNzUsIGVkaXRvckFyZWEpOyAvLyROT04tTkxTLTEkCisJCW91dHB1dGZvbGRlci5hZGRWaWV3KElQYWdlTGF5b3V0LklEX1BST0JMRU1fVklFVyk7CisJCW91dHB1dGZvbGRlci5hZGRWaWV3KEphdmFVSS5JRF9KQVZBRE9DX1ZJRVcpOworCQlvdXRwdXRmb2xkZXIuYWRkVmlldyhKYXZhVUkuSURfU09VUkNFX1ZJRVcpOworCQlvdXRwdXRmb2xkZXIuYWRkVmlldygib3JnLmVjbGlwc2Uub3NicC5lY3ZpZXcuaWRlLnByZXZpZXcudmFhZGluLmlkZSIpOworCQlvdXRwdXRmb2xkZXIuYWRkVmlldygib3JnLmVjbGlwc2Uub3NicC5lY3ZpZXcuaWRlLnByZXZpZXcudmFhZGluLm1vYmlsZSIpOworCQlvdXRwdXRmb2xkZXIuYWRkUGxhY2Vob2xkZXIoTmV3U2VhcmNoVUkuU0VBUkNIX1ZJRVdfSUQpOworCQlvdXRwdXRmb2xkZXIuYWRkUGxhY2Vob2xkZXIoSUNvbnNvbGVDb25zdGFudHMuSURfQ09OU09MRV9WSUVXKTsKKwkJb3V0cHV0Zm9sZGVyLmFkZFBsYWNlaG9sZGVyKEkxOG5SZWdpc3RyeVZpZXcuSUQpOworCQlvdXRwdXRmb2xkZXIuYWRkUGxhY2Vob2xkZXIoSVBhZ2VMYXlvdXQuSURfQk9PS01BUktTKTsKKwkJb3V0cHV0Zm9sZGVyLmFkZFBsYWNlaG9sZGVyKElQcm9ncmVzc0NvbnN0YW50cy5QUk9HUkVTU19WSUVXX0lEKTsKKworCQlJRm9sZGVyTGF5b3V0IG91dGxpbmVGb2xkZXIgPSBsYXlvdXQuY3JlYXRlRm9sZGVyKAorCQkJCSJyaWdodCIsIElQYWdlTGF5b3V0LlJJR0hULCAoZmxvYXQpIDAuNzUsIGVkaXRvckFyZWEpOyAvLyROT04tTkxTLTEkCisJCW91dGxpbmVGb2xkZXIuYWRkVmlldyhJUGFnZUxheW91dC5JRF9PVVRMSU5FKTsKKworCQlsYXlvdXQuYWRkQWN0aW9uU2V0KElEZWJ1Z1VJQ29uc3RhbnRzLkxBVU5DSF9BQ1RJT05fU0VUKTsKKwkJbGF5b3V0LmFkZEFjdGlvblNldChKYXZhVUkuSURfQUNUSU9OX1NFVCk7CisJCWxheW91dC5hZGRBY3Rpb25TZXQoSmF2YVVJLklEX0VMRU1FTlRfQ1JFQVRJT05fQUNUSU9OX1NFVCk7CisJCWxheW91dC5hZGRBY3Rpb25TZXQoSVBhZ2VMYXlvdXQuSURfTkFWSUdBVEVfQUNUSU9OX1NFVCk7CisKKwkJLy8gdmlld3MgLSBqYXZhCisJCWxheW91dC5hZGRTaG93Vmlld1Nob3J0Y3V0KEphdmFVSS5JRF9QQUNLQUdFUyk7CisJCWxheW91dC5hZGRTaG93Vmlld1Nob3J0Y3V0KEphdmFVSS5JRF9UWVBFX0hJRVJBUkNIWSk7CisJCWxheW91dC5hZGRTaG93Vmlld1Nob3J0Y3V0KEphdmFVSS5JRF9TT1VSQ0VfVklFVyk7CisJCWxheW91dC5hZGRTaG93Vmlld1Nob3J0Y3V0KEphdmFVSS5JRF9KQVZBRE9DX1ZJRVcpOworCisJCS8vIHZpZXdzIC0gc2VhcmNoCisJCWxheW91dC5hZGRTaG93Vmlld1Nob3J0Y3V0KE5ld1NlYXJjaFVJLlNFQVJDSF9WSUVXX0lEKTsKKworCQkvLyB2aWV3cyAtIGRlYnVnZ2luZworCQlsYXlvdXQuYWRkU2hvd1ZpZXdTaG9ydGN1dChJQ29uc29sZUNvbnN0YW50cy5JRF9DT05TT0xFX1ZJRVcpOworCisJCS8vIHZpZXdzIC0gc3RhbmRhcmQgd29ya2JlbmNoCisJCWxheW91dC5hZGRTaG93Vmlld1Nob3J0Y3V0KElQYWdlTGF5b3V0LklEX09VVExJTkUpOworCQlsYXlvdXQuYWRkU2hvd1ZpZXdTaG9ydGN1dChJUGFnZUxheW91dC5JRF9QUk9CTEVNX1ZJRVcpOworCQlsYXlvdXQuYWRkU2hvd1ZpZXdTaG9ydGN1dChKYXZhUGx1Z2luLklEX1JFU19OQVYpOworCQlsYXlvdXQuYWRkU2hvd1ZpZXdTaG9ydGN1dChJUGFnZUxheW91dC5JRF9UQVNLX0xJU1QpOworCQlsYXlvdXQuYWRkU2hvd1ZpZXdTaG9ydGN1dChJUHJvZ3Jlc3NDb25zdGFudHMuUFJPR1JFU1NfVklFV19JRCk7CisJCWxheW91dC5hZGRTaG93Vmlld1Nob3J0Y3V0KElQYWdlTGF5b3V0LklEX1BST0pFQ1RfRVhQTE9SRVIpOworCQlsYXlvdXQuYWRkU2hvd1ZpZXdTaG9ydGN1dCgib3JnLmVjbGlwc2UucGRlLnJ1bnRpbWUuTG9nVmlldyIpOyAvLyROT04tTkxTLTEkCisKKwkJLy8gbmV3IGFjdGlvbnMgLSBKYXZhIHByb2plY3QgY3JlYXRpb24gd2l6YXJkCisJCWxheW91dC5hZGROZXdXaXphcmRTaG9ydGN1dCgib3JnLmVjbGlwc2UuamR0LnVpLndpemFyZHMuSmF2YVByb2plY3RXaXphcmQiKTsgLy8kTk9OLU5MUy0xJAorCQlsYXlvdXQuYWRkTmV3V2l6YXJkU2hvcnRjdXQoIm9yZy5lY2xpcHNlLmpkdC51aS53aXphcmRzLk5ld1BhY2thZ2VDcmVhdGlvbldpemFyZCIpOyAvLyROT04tTkxTLTEkCisJCWxheW91dC5hZGROZXdXaXphcmRTaG9ydGN1dCgib3JnLmVjbGlwc2UuamR0LnVpLndpemFyZHMuTmV3Q2xhc3NDcmVhdGlvbldpemFyZCIpOyAvLyROT04tTkxTLTEkCisJCWxheW91dC5hZGROZXdXaXphcmRTaG9ydGN1dCgib3JnLmVjbGlwc2UuamR0LnVpLndpemFyZHMuTmV3SW50ZXJmYWNlQ3JlYXRpb25XaXphcmQiKTsgLy8kTk9OLU5MUy0xJAorCQlsYXlvdXQuYWRkTmV3V2l6YXJkU2hvcnRjdXQoIm9yZy5lY2xpcHNlLmpkdC51aS53aXphcmRzLk5ld0VudW1DcmVhdGlvbldpemFyZCIpOyAvLyROT04tTkxTLTEkCisJCWxheW91dC5hZGROZXdXaXphcmRTaG9ydGN1dCgib3JnLmVjbGlwc2UuamR0LnVpLndpemFyZHMuTmV3QW5ub3RhdGlvbkNyZWF0aW9uV2l6YXJkIik7IC8vJE5PTi1OTFMtMSQKKwkJbGF5b3V0LmFkZE5ld1dpemFyZFNob3J0Y3V0KCJvcmcuZWNsaXBzZS5qZHQudWkud2l6YXJkcy5OZXdTb3VyY2VGb2xkZXJDcmVhdGlvbldpemFyZCIpOyAvLyROT04tTkxTLTEkCisJCWxheW91dC5hZGROZXdXaXphcmRTaG9ydGN1dCgib3JnLmVjbGlwc2UuamR0LnVpLndpemFyZHMuTmV3U25pcHBldEZpbGVDcmVhdGlvbldpemFyZCIpOyAvLyROT04tTkxTLTEkCisJCWxheW91dC5hZGROZXdXaXphcmRTaG9ydGN1dCgib3JnLmVjbGlwc2UuamR0LnVpLndpemFyZHMuTmV3SmF2YVdvcmtpbmdTZXRXaXphcmQiKTsgLy8kTk9OLU5MUy0xJAorCQlsYXlvdXQuYWRkTmV3V2l6YXJkU2hvcnRjdXQoIm9yZy5lY2xpcHNlLnVpLndpemFyZHMubmV3LmZvbGRlciIpOy8vJE5PTi1OTFMtMSQKKwkJbGF5b3V0LmFkZE5ld1dpemFyZFNob3J0Y3V0KCJvcmcuZWNsaXBzZS51aS53aXphcmRzLm5ldy5maWxlIik7Ly8kTk9OLU5MUy0xJAorCQlsYXlvdXQuYWRkTmV3V2l6YXJkU2hvcnRjdXQoIm9yZy5lY2xpcHNlLnVpLmVkaXRvcnMud2l6YXJkcy5VbnRpdGxlZFRleHRGaWxlV2l6YXJkIik7Ly8kTk9OLU5MUy0xJAorCisJCS8vICdXaW5kb3cnID4gJ09wZW4gUGVyc3BlY3RpdmUnIGNvbnRyaWJ1dGlvbnMKKwkJbGF5b3V0LmFkZFBlcnNwZWN0aXZlU2hvcnRjdXQoSmF2YVVJLklEX0JST1dTSU5HX1BFUlNQRUNUSVZFKTsKKwkJbGF5b3V0LmFkZFBlcnNwZWN0aXZlU2hvcnRjdXQoSURlYnVnVUlDb25zdGFudHMuSURfREVCVUdfUEVSU1BFQ1RJVkUpOworCisJfQorfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS91dGlsL0NvcmVVaVV0aWwuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvdXRpbC9Db3JlVWlVdGlsLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOTQzMWU0YQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvdXRpbC9Db3JlVWlVdGlsLmphdmEKQEAgLTAsMCArMSw2OSBAQAorLyoqCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTUgLSBMdW5pZmVyYSBHbWJIIChHcm9zcyBFbnplcnNkb3JmLCBBdXN0cmlhKSwgTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisgKgorICogQ29udHJpYnV0b3JzOgorICogICAgICAgICBGbG9yaWFuIFBpcmNobmVyIC0gSW5pdGlhbCBpbXBsZW1lbnRhdGlvbgorICovCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkudXRpbDsKKworaW1wb3J0IGphdmEudXRpbC5Mb2NhbGU7CisKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JUHJvamVjdDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5lbWYuZWNvcmUuRU9iamVjdDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZHQuY29yZS5JSmF2YVByb2plY3Q7CitpbXBvcnQgb3JnLmVjbGlwc2UueHRleHQuY29tbW9uLnR5cGVzLmFjY2Vzcy5qZHQuSUphdmFQcm9qZWN0UHJvdmlkZXI7CisKK2ltcG9ydCBjb20uZ29vZ2xlLmluamVjdC5JbmplY3Q7CisKKy8vIFRPRE86IEF1dG8tZ2VuZXJhdGVkIEphdmFkb2MKKy8qKgorICogVXRpbCBjbGFzcyB0aGF0IG9mZmVycyBjb252ZW5pZW50IG1ldGhvZHMuCisgKi8KK3B1YmxpYyBjbGFzcyBDb3JlVWlVdGlsIHsKKworCS8qKiBUaGUgcHJvamVjdCBwcm92aWRlci4gKi8KKwlASW5qZWN0CisJcHJpdmF0ZSBJSmF2YVByb2plY3RQcm92aWRlciBwcm9qZWN0UHJvdmlkZXI7CisKKwkvKioKKwkgKiBSZXR1cm5zIHRoZSBwcm9qZWN0IHdoZXJlIHRoZSB4dGV4dE1vZGVsIGlzIGxvY2F0ZWQgaW4uCisJICoKKwkgKiBAcGFyYW0geHRleHRFbGVtZW50CisJICogICAgICAgICAgICB0aGUgeHRleHQgZWxlbWVudAorCSAqIEByZXR1cm4gdGhlIHByb2plY3QKKwkgKi8KKwlwdWJsaWMgSVByb2plY3QgZ2V0UHJvamVjdChFT2JqZWN0IHh0ZXh0RWxlbWVudCkgeworCQlJSmF2YVByb2plY3QgamF2YVByb2plY3QgPSBnZXRKYXZhUHJvamVjdCh4dGV4dEVsZW1lbnQpOworCQlpZiAoamF2YVByb2plY3QgPT0gbnVsbCkgeworCQkJcmV0dXJuIG51bGw7CisJCX0KKwkJcmV0dXJuIGphdmFQcm9qZWN0LmdldFByb2plY3QoKTsKKwl9CisKKwkvKioKKwkgKiBSZXR1cm5zIHRoZSBqYXZhUHJvamVjdCB3aGVyZSB0aGUgeHRleHRNb2RlbCBpcyBsb2NhdGVkIGluLgorCSAqCisJICogQHBhcmFtIHh0ZXh0RWxlbWVudAorCSAqICAgICAgICAgICAgdGhlIHh0ZXh0IGVsZW1lbnQKKwkgKiBAcmV0dXJuIHRoZSBqYXZhIHByb2plY3QKKwkgKi8KKwlwdWJsaWMgSUphdmFQcm9qZWN0IGdldEphdmFQcm9qZWN0KEVPYmplY3QgeHRleHRFbGVtZW50KSB7CisJCXJldHVybiBwcm9qZWN0UHJvdmlkZXIuZ2V0SmF2YVByb2plY3QoeHRleHRFbGVtZW50LmVSZXNvdXJjZSgpCisJCQkJLmdldFJlc291cmNlU2V0KCkpOworCX0KKworCS8qKgorCSAqIFJldHVybnMgdGhlIGN1cnJlbnQgbG9jYWxlLiBGb3Igbm93IHtAbGluayBMb2NhbGUjZ2V0RGVmYXVsdCgpfSBpcyB1c2VkLgorCSAqIExhdGVyIG1heWJlIGEgdmFsdWUgZnJvbSBwcmVmZXJlbmNlcyBpcyByZXR1cm5lZC4KKwkgKgorCSAqIEByZXR1cm4gdGhlIGxvY2FsZQorCSAqLworCXB1YmxpYyBMb2NhbGUgZ2V0TG9jYWxlKCkgeworCQlyZXR1cm4gTG9jYWxlLmdldERlZmF1bHQoKTsKKwl9CisKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvdmlldy9FQ1ZpZXdNb2RlbEJpbmRpbmdWaWV3LmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS9jb3JlL3VpL3ZpZXcvRUNWaWV3TW9kZWxCaW5kaW5nVmlldy5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjliNTA3YTMKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS9jb3JlL3VpL3ZpZXcvRUNWaWV3TW9kZWxCaW5kaW5nVmlldy5qYXZhCkBAIC0wLDAgKzEsMzQwIEBACisvKioKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNSAtIEx1bmlmZXJhIEdtYkggKEdyb3NzIEVuemVyc2RvcmYsIEF1c3RyaWEpLCBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscworICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKKyAqCisgKiBDb250cmlidXRvcnM6CisgKiAgICAgICAgIEZsb3JpYW4gUGlyY2huZXIgLSBJbml0aWFsIGltcGxlbWVudGF0aW9uCisgKi8KKworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnZpZXc7CisKK2ltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OworaW1wb3J0IGphdmEudXRpbC5MaXN0OworCitpbXBvcnQgb3JnLmVjbGlwc2UuZW1mLmVjb3JlLkVPYmplY3Q7CitpbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5JVHJlZUNvbnRlbnRQcm92aWRlcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLkxhYmVsUHJvdmlkZXI7CitpbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5UcmVlVmlld2VyOworaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuVmlld2VyOworaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5ncmFwaGljcy5JbWFnZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7CitpbXBvcnQgb3JnLmVjbGlwc2UudWkuSVBhcnRMaXN0ZW5lcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS51aS5JV29ya2JlbmNoUGFydDsKK2ltcG9ydCBvcmcuZWNsaXBzZS51aS5JV29ya2JlbmNoUGFydFNpdGU7CitpbXBvcnQgb3JnLmVjbGlwc2UudWkucGFydC5WaWV3UGFydDsKK2ltcG9ydCBvcmcuZWNsaXBzZS54dGV4dC5idWlsZGVyLmJ1aWxkZXJTdGF0ZS5JQnVpbGRlclN0YXRlOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnJlc291cmNlLlh0ZXh0UmVzb3VyY2U7CitpbXBvcnQgb3JnLmVjbGlwc2UueHRleHQudWkuZWRpdG9yLlh0ZXh0RWRpdG9yOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnVpLmVkaXRvci5tb2RlbC5JWHRleHREb2N1bWVudDsKK2ltcG9ydCBvcmcuZWNsaXBzZS54dGV4dC51aS5lZGl0b3IubW9kZWwuSVh0ZXh0TW9kZWxMaXN0ZW5lcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS54dGV4dC51dGlsLmNvbmN1cnJlbnQuSVVuaXRPZldvcms7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5lY3ZpZXcuY29yZS5jb21tb24ubW9kZWwuYmluZGluZy5ZQmVhblZhbHVlQmluZGluZ0VuZHBvaW50OworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZWN2aWV3LmNvcmUuY29tbW9uLm1vZGVsLmJpbmRpbmcuWUJpbmRpbmc7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5lY3ZpZXcuY29yZS5jb21tb24ubW9kZWwuYmluZGluZy5ZQmluZGluZ1NldDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmVjdmlldy5jb3JlLmNvbW1vbi5tb2RlbC5iaW5kaW5nLllEZXRhaWxWYWx1ZUJpbmRpbmdFbmRwb2ludDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmVjdmlldy5jb3JlLmNvbW1vbi5tb2RlbC5iaW5kaW5nLllFQ1ZpZXdNb2RlbExpc3RCaW5kaW5nRW5kcG9pbnQ7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5lY3ZpZXcuY29yZS5jb21tb24ubW9kZWwuYmluZGluZy5ZRUNWaWV3TW9kZWxWYWx1ZUJpbmRpbmdFbmRwb2ludDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmVjdmlldy5jb3JlLmNvbW1vbi5tb2RlbC5iaW5kaW5nLllFbnVtTGlzdEJpbmRpbmdFbmRwb2ludDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmVjdmlldy5jb3JlLmNvbW1vbi5tb2RlbC5iaW5kaW5nLllWaXNpYmlsaXR5UHJvY2Vzc29yVmFsdWVCaW5kaW5nRW5kcG9pbnQ7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5lY3ZpZXcuY29yZS5jb21tb24ubW9kZWwuY29yZS5ZQWN0aXZhdGVkRW5kcG9pbnQ7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5lY3ZpZXcuY29yZS5jb21tb24ubW9kZWwuY29yZS5ZQmVhblNsb3RMaXN0QmluZGluZ0VuZHBvaW50OworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZWN2aWV3LmNvcmUuY29tbW9uLm1vZGVsLmNvcmUuWUJlYW5TbG90VmFsdWVCaW5kaW5nRW5kcG9pbnQ7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5lY3ZpZXcuY29yZS5jb21tb24ubW9kZWwuY29yZS5ZQ29udGV4dFZhbHVlQmluZGluZ0VuZHBvaW50OworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuZWN2aWV3LmNvcmUuY29tbW9uLm1vZGVsLmNvcmUuWUVsZW1lbnQ7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5lY3ZpZXcuY29yZS5jb21tb24ubW9kZWwuY29yZS5ZRW1iZWRkYWJsZUNvbGxlY3Rpb25FbmRwb2ludDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmVjdmlldy5jb3JlLmNvbW1vbi5tb2RlbC5jb3JlLllFbWJlZGRhYmxlTXVsdGlTZWxlY3Rpb25FbmRwb2ludDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2JwLmVjdmlldy5jb3JlLmNvbW1vbi5tb2RlbC5jb3JlLllFbWJlZGRhYmxlU2VsZWN0aW9uRW5kcG9pbnQ7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5lY3ZpZXcuY29yZS5jb21tb24ubW9kZWwuY29yZS5ZRW1iZWRkYWJsZVZhbHVlRW5kcG9pbnQ7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5lY3ZpZXcuY29yZS5jb21tb24ubW9kZWwuY29yZS5ZVmlldzsKKworaW1wb3J0IGNvbS5nb29nbGUuaW5qZWN0LkluamVjdDsKKworQFN1cHByZXNzV2FybmluZ3MoInJlc3RyaWN0aW9uIikKK3B1YmxpYyBjbGFzcyBFQ1ZpZXdNb2RlbEJpbmRpbmdWaWV3IGV4dGVuZHMgVmlld1BhcnQgaW1wbGVtZW50cyBJUGFydExpc3RlbmVyLAorCQlJWHRleHRNb2RlbExpc3RlbmVyIHsKKworCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIElEID0gIm9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkudmlldy54dGV4dGluZGV4IjsKKworCUBJbmplY3QKKwlwcml2YXRlIElCdWlsZGVyU3RhdGUgYnVpbGRlclN0YXRlOworCisJLy8gcHJpdmF0ZSBJbWFnZSBpbmRleEltYWdlID0gQ29yZVVpQWN0aXZhdG9yLmltYWdlRGVzY3JpcHRvckZyb21QbHVnaW4oCisJLy8gQ29yZVVpQWN0aXZhdG9yLlBMVUdJTl9JRCwgImljb25zL0luZGV4LVJlc291cmNlLmdpZiIpCisJLy8gLmNyZWF0ZUltYWdlKCk7CisJLy8gcHJpdmF0ZSBJbWFnZSBleHBvcnRlZENvbnRhaW5lckltYWdlID0gQ29yZVVpQWN0aXZhdG9yCisJLy8gLmltYWdlRGVzY3JpcHRvckZyb21QbHVnaW4oQ29yZVVpQWN0aXZhdG9yLlBMVUdJTl9JRCwKKwkvLyAiaWNvbnMvSW5kZXgtRXhwb3J0ZWRDb250YWluZXIuZ2lmIikuY3JlYXRlSW1hZ2UoKTsKKwkvLyBwcml2YXRlIEltYWdlIGltcG9ydGVkTmFtZUNvbnRhaW5lckltYWdlID0gQ29yZVVpQWN0aXZhdG9yCisJLy8gLmltYWdlRGVzY3JpcHRvckZyb21QbHVnaW4oQ29yZVVpQWN0aXZhdG9yLlBMVUdJTl9JRCwKKwkvLyAiaWNvbnMvSW5kZXgtSW1wb3J0ZWROYW1lQ29udGFpbmVyLmdpZiIpLmNyZWF0ZUltYWdlKCk7CisJLy8gcHJpdmF0ZSBJbWFnZSByZWZlcmVuY2VDb250YWluZXJJbWFnZSA9IENvcmVVaUFjdGl2YXRvcgorCS8vIC5pbWFnZURlc2NyaXB0b3JGcm9tUGx1Z2luKENvcmVVaUFjdGl2YXRvci5QTFVHSU5fSUQsCisJLy8gImljb25zL0luZGV4LVJlZmVyZW5jZUNvbnRhaW5lci5naWYiKS5jcmVhdGVJbWFnZSgpOworCS8vIHByaXZhdGUgSW1hZ2UgcmVmZXJlbmNlSW1hZ2UgPSBDb3JlVWlBY3RpdmF0b3IuaW1hZ2VEZXNjcmlwdG9yRnJvbVBsdWdpbigKKwkvLyBDb3JlVWlBY3RpdmF0b3IuUExVR0lOX0lELCAiaWNvbnMvSW5kZXgtUmVmZXJlbmNlRGVzY3JpcHRpb24uZ2lmIikKKwkvLyAuY3JlYXRlSW1hZ2UoKTsKKworCXByaXZhdGUgVHJlZVZpZXdlciB0cmVlVmlld2VyOworCisJcHJpdmF0ZSBJWHRleHREb2N1bWVudCBsYXN0QWN0aXZlRG9jdW1lbnQ7CisKKwlwcml2YXRlIFlCaW5kaW5nU2V0IHlCaW5kaW5nU2V0OworCisJcHVibGljIEVDVmlld01vZGVsQmluZGluZ1ZpZXcoKSB7CisKKwl9CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgdm9pZCBjcmVhdGVQYXJ0Q29udHJvbChDb21wb3NpdGUgcGFyZW50KSB7CisKKwkJdHJlZVZpZXdlciA9IG5ldyBUcmVlVmlld2VyKHBhcmVudCk7CisJCXRyZWVWaWV3ZXIuc2V0Q29udGVudFByb3ZpZGVyKG5ldyBDb250ZW50UHJvdmlkZXIoKSk7CisJCXRyZWVWaWV3ZXIuc2V0TGFiZWxQcm92aWRlcihuZXcgTGFiZWxQcm92aWRlcigpIHsKKwkJCUBPdmVycmlkZQorCQkJcHVibGljIEltYWdlIGdldEltYWdlKE9iamVjdCBlbGVtZW50KSB7CisJCQkJLy8gaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBJUmVzb3VyY2VEZXNjcmlwdGlvbikgeworCQkJCS8vIHJldHVybiBpbmRleEltYWdlOworCQkJCS8vIH0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIEV4cG9ydGVkT2JqZWN0cykgeworCQkJCS8vIHJldHVybiBleHBvcnRlZENvbnRhaW5lckltYWdlOworCQkJCS8vIH0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIEltcG9ydGVkTmFtZXMpIHsKKwkJCQkvLyByZXR1cm4gaW1wb3J0ZWROYW1lQ29udGFpbmVySW1hZ2U7CisJCQkJLy8gfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgUmVmZXJlbmNlRGVzY3JpcHRpb25zKSB7CisJCQkJLy8gcmV0dXJuIHJlZmVyZW5jZUNvbnRhaW5lckltYWdlOworCQkJCS8vIH0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIElSZWZlcmVuY2VEZXNjcmlwdGlvbikgeworCQkJCS8vIHJldHVybiByZWZlcmVuY2VJbWFnZTsKKwkJCQkvLyB9CisJCQkJcmV0dXJuIHN1cGVyLmdldEltYWdlKGVsZW1lbnQpOworCQkJfQorCisJCQlAT3ZlcnJpZGUKKwkJCXB1YmxpYyBTdHJpbmcgZ2V0VGV4dChPYmplY3QgZWxlbWVudCkgeworCQkJCXRyeSB7CisJCQkJCWlmIChlbGVtZW50IGluc3RhbmNlb2YgU3RyaW5nKSB7CisJCQkJCQlyZXR1cm4gKFN0cmluZykgZWxlbWVudDsKKwkJCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgWUJpbmRpbmcpIHsKKwkJCQkJCXJldHVybiBlbGVtZW50LmdldENsYXNzKCkuZ2V0U2ltcGxlTmFtZSgpOworCQkJCQl9IGVsc2UgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBZQWN0aXZhdGVkRW5kcG9pbnQpIHsKKwkJCQkJCVlBY3RpdmF0ZWRFbmRwb2ludCBlcCA9IChZQWN0aXZhdGVkRW5kcG9pbnQpIGVsZW1lbnQ7CisJCQkJCQlyZXR1cm4gIkFjdGl2YXRlZEVuZHBvaW50OiAiCisJCQkJCQkJCSsgZXAuZ2V0RWxlbWVudCgpLmdldENsYXNzKCkuZ2V0U2ltcGxlTmFtZSgpOworCQkJCQl9IGVsc2UgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBZQmVhblNsb3RWYWx1ZUJpbmRpbmdFbmRwb2ludCkgeworCQkJCQkJWUJlYW5TbG90VmFsdWVCaW5kaW5nRW5kcG9pbnQgZXAgPSAoWUJlYW5TbG90VmFsdWVCaW5kaW5nRW5kcG9pbnQpIGVsZW1lbnQ7CisJCQkJCQlyZXR1cm4gIllCZWFuU2xvdFZhbHVlQmluZGluZ0VuZHBvaW50OiAiCisJCQkJCQkJCSsgZXAuZ2V0QmVhblNsb3QoKS5nZXROYW1lKCkgKyAiOiIKKwkJCQkJCQkJKyBlcC5nZXRBdHRyaWJ1dGVQYXRoKCk7CisJCQkJCX0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIFlCZWFuVmFsdWVCaW5kaW5nRW5kcG9pbnQpIHsKKwkJCQkJCVlCZWFuVmFsdWVCaW5kaW5nRW5kcG9pbnQgZXAgPSAoWUJlYW5WYWx1ZUJpbmRpbmdFbmRwb2ludCkgZWxlbWVudDsKKwkJCQkJCXJldHVybiAiWUJlYW5WYWx1ZUJpbmRpbmdFbmRwb2ludDogIgorCQkJCQkJCQkrIGVwLmdldFByb3BlcnR5UGF0aCgpOworCQkJCQl9IGVsc2UgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBZQ29udGV4dFZhbHVlQmluZGluZ0VuZHBvaW50KSB7CisJCQkJCQlZQ29udGV4dFZhbHVlQmluZGluZ0VuZHBvaW50IGVwID0gKFlDb250ZXh0VmFsdWVCaW5kaW5nRW5kcG9pbnQpIGVsZW1lbnQ7CisJCQkJCQlyZXR1cm4gIllDb250ZXh0VmFsdWVCaW5kaW5nRW5kcG9pbnQ6ICIKKwkJCQkJCQkJKyBlcC5nZXRVcmxTdHJpbmcoKTsKKwkJCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgWUNvbnRleHRWYWx1ZUJpbmRpbmdFbmRwb2ludCkgeworCQkJCQkJWURldGFpbFZhbHVlQmluZGluZ0VuZHBvaW50IGVwID0gKFlEZXRhaWxWYWx1ZUJpbmRpbmdFbmRwb2ludCkgZWxlbWVudDsKKwkJCQkJCXJldHVybiAiWURldGFpbFZhbHVlQmluZGluZ0VuZHBvaW50OiAoIgorCQkJCQkJCQkrIGdldFRleHQoZXAuZ2V0TWFzdGVyT2JzZXJ2YWJsZSgpKSArICIpLiIKKwkJCQkJCQkJKyBlcC5nZXRQcm9wZXJ0eVBhdGgoKTsKKwkJCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgWUVDVmlld01vZGVsVmFsdWVCaW5kaW5nRW5kcG9pbnQpIHsKKwkJCQkJCVlFQ1ZpZXdNb2RlbFZhbHVlQmluZGluZ0VuZHBvaW50IGVwID0gKFlFQ1ZpZXdNb2RlbFZhbHVlQmluZGluZ0VuZHBvaW50KSBlbGVtZW50OworCQkJCQkJcmV0dXJuICJZRUNWaWV3TW9kZWxWYWx1ZUJpbmRpbmdFbmRwb2ludDogIgorCQkJCQkJCQkrIGVwLmdldEVsZW1lbnQoKS5nZXRDbGFzcygpLmdldFNpbXBsZU5hbWUoKQorCQkJCQkJCQkrICI6IiArIGdldElkKGVwLmdldEVsZW1lbnQoKSkgKyAiLiIKKwkJCQkJCQkJKyBlcC5nZXRQcm9wZXJ0eVBhdGgoKTsKKwkJCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgWUVtYmVkZGFibGVTZWxlY3Rpb25FbmRwb2ludCkgeworCQkJCQkJWUVtYmVkZGFibGVTZWxlY3Rpb25FbmRwb2ludCBlcCA9IChZRW1iZWRkYWJsZVNlbGVjdGlvbkVuZHBvaW50KSBlbGVtZW50OworCQkJCQkJcmV0dXJuICJZRW1iZWRkYWJsZVNlbGVjdGlvbkVuZHBvaW50OiAiCisJCQkJCQkJCSsgZXAuZ2V0RWxlbWVudCgpLmdldENsYXNzKCkuZ2V0U2ltcGxlTmFtZSgpCisJCQkJCQkJCSsgIjoiICsgZ2V0SWQoZXAuZ2V0RWxlbWVudCgpKSArICIuIgorCQkJCQkJCQkrIGVwLmdldEF0dHJpYnV0ZVBhdGgoKTsKKwkJCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgWUVtYmVkZGFibGVWYWx1ZUVuZHBvaW50KSB7CisJCQkJCQlZRW1iZWRkYWJsZVZhbHVlRW5kcG9pbnQgZXAgPSAoWUVtYmVkZGFibGVWYWx1ZUVuZHBvaW50KSBlbGVtZW50OworCQkJCQkJcmV0dXJuICJZRW1iZWRkYWJsZVZhbHVlRW5kcG9pbnQ6ICIKKwkJCQkJCQkJKyBlcC5nZXRFbGVtZW50KCkuZ2V0Q2xhc3MoKS5nZXRTaW1wbGVOYW1lKCkKKwkJCQkJCQkJKyAiOiIgKyBnZXRJZChlcC5nZXRFbGVtZW50KCkpICsgIi52YWx1ZSI7CisJCQkJCX0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIFlWaXNpYmlsaXR5UHJvY2Vzc29yVmFsdWVCaW5kaW5nRW5kcG9pbnQpIHsKKwkJCQkJCVlWaXNpYmlsaXR5UHJvY2Vzc29yVmFsdWVCaW5kaW5nRW5kcG9pbnQgZXAgPSAoWVZpc2liaWxpdHlQcm9jZXNzb3JWYWx1ZUJpbmRpbmdFbmRwb2ludCkgZWxlbWVudDsKKwkJCQkJCXJldHVybiAiWVZpc2liaWxpdHlQcm9jZXNzb3JWYWx1ZUJpbmRpbmdFbmRwb2ludDogIgorCQkJCQkJCQkrIGVwLmdldFByb2Nlc3Nvckluc3RhbmNlKCkuZ2V0Q2xhc3MoKQorCQkJCQkJCQkJCS5nZXRTaW1wbGVOYW1lKCkgKyAiOiIKKwkJCQkJCQkJKyBlcC5nZXRQcm9wZXJ0eSgpOworCQkJCQl9IGVsc2UgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBZQmVhblNsb3RMaXN0QmluZGluZ0VuZHBvaW50KSB7CisJCQkJCQlZQmVhblNsb3RMaXN0QmluZGluZ0VuZHBvaW50IGVwID0gKFlCZWFuU2xvdExpc3RCaW5kaW5nRW5kcG9pbnQpIGVsZW1lbnQ7CisJCQkJCQlyZXR1cm4gIllCZWFuU2xvdExpc3RCaW5kaW5nRW5kcG9pbnQ6ICIKKwkJCQkJCQkJKyBlcC5nZXRCZWFuU2xvdCgpLmdldE5hbWUoKSArICI6IgorCQkJCQkJCQkrIGVwLmdldEF0dHJpYnV0ZVBhdGgoKTsKKwkJCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgWUVDVmlld01vZGVsTGlzdEJpbmRpbmdFbmRwb2ludCkgeworCQkJCQkJWUVDVmlld01vZGVsTGlzdEJpbmRpbmdFbmRwb2ludCBlcCA9IChZRUNWaWV3TW9kZWxMaXN0QmluZGluZ0VuZHBvaW50KSBlbGVtZW50OworCQkJCQkJcmV0dXJuICJZRUNWaWV3TW9kZWxMaXN0QmluZGluZ0VuZHBvaW50OiAiCisJCQkJCQkJCSsgZXAuZ2V0RWxlbWVudCgpLmdldENsYXNzKCkuZ2V0U2ltcGxlTmFtZSgpCisJCQkJCQkJCSsgIjoiICsgZ2V0SWQoZXAuZ2V0RWxlbWVudCgpKSArICIuIgorCQkJCQkJCQkrIGVwLmdldFByb3BlcnR5UGF0aCgpOworCQkJCQl9IGVsc2UgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBZRW1iZWRkYWJsZUNvbGxlY3Rpb25FbmRwb2ludCkgeworCQkJCQkJWUVtYmVkZGFibGVDb2xsZWN0aW9uRW5kcG9pbnQgZXAgPSAoWUVtYmVkZGFibGVDb2xsZWN0aW9uRW5kcG9pbnQpIGVsZW1lbnQ7CisJCQkJCQlyZXR1cm4gIllFbWJlZGRhYmxlQ29sbGVjdGlvbkVuZHBvaW50OiAiCisJCQkJCQkJCSsgZXAuZ2V0RWxlbWVudCgpLmdldENsYXNzKCkuZ2V0U2ltcGxlTmFtZSgpCisJCQkJCQkJCSsgIjoiICsgZ2V0SWQoZXAuZ2V0RWxlbWVudCgpKTsKKwkJCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgWUVtYmVkZGFibGVNdWx0aVNlbGVjdGlvbkVuZHBvaW50KSB7CisJCQkJCQlZRW1iZWRkYWJsZU11bHRpU2VsZWN0aW9uRW5kcG9pbnQgZXAgPSAoWUVtYmVkZGFibGVNdWx0aVNlbGVjdGlvbkVuZHBvaW50KSBlbGVtZW50OworCQkJCQkJcmV0dXJuICJZRW1iZWRkYWJsZU11bHRpU2VsZWN0aW9uRW5kcG9pbnQ6ICIKKwkJCQkJCQkJKyBlcC5nZXRFbGVtZW50KCkuZ2V0Q2xhc3MoKS5nZXRTaW1wbGVOYW1lKCkKKwkJCQkJCQkJKyAiOiIgKyBnZXRJZChlcC5nZXRFbGVtZW50KCkpOworCQkJCQl9IGVsc2UgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBZRW51bUxpc3RCaW5kaW5nRW5kcG9pbnQpIHsKKwkJCQkJCVlFbnVtTGlzdEJpbmRpbmdFbmRwb2ludCBlcCA9IChZRW51bUxpc3RCaW5kaW5nRW5kcG9pbnQpIGVsZW1lbnQ7CisJCQkJCQlyZXR1cm4gIllFbnVtTGlzdEJpbmRpbmdFbmRwb2ludDogIgorCQkJCQkJCQkrIGVwLmdldEVudW0oKS5nZXRDbGFzcygpLmdldFNpbXBsZU5hbWUoKTsKKwkJCQkJfQorCQkJCX0gY2F0Y2ggKEV4Y2VwdGlvbiBlKSB7CisJCQkJCXJldHVybiAiZXhjZXB0aW9uIGluIHRoaXMgbGluZS4iOworCQkJCX0KKwkJCQlyZXR1cm4gIiI7CisJCQl9CisKKwkJCXByaXZhdGUgU3RyaW5nIGdldElkKEVPYmplY3QgZWxlbWVudCkgeworCQkJCWlmIChlbGVtZW50IGluc3RhbmNlb2YgWUVsZW1lbnQpIHsKKwkJCQkJcmV0dXJuICgoWUVsZW1lbnQpIGVsZW1lbnQpLmdldElkKCk7CisJCQkJfQorCQkJCXJldHVybiAibm9JZCI7CisJCQl9CisJCX0pOworCisJCXN0YXJ0KGdldFZpZXdTaXRlKCkpOworCX0KKworCUBPdmVycmlkZQorCXB1YmxpYyB2b2lkIHNldEZvY3VzKCkgeworCisJfQorCisJQE92ZXJyaWRlCisJcHVibGljIHZvaWQgZGlzcG9zZSgpIHsKKworCQlzdG9wKGdldFZpZXdTaXRlKCkpOworCisJCS8vIGV4cG9ydGVkQ29udGFpbmVySW1hZ2UuZGlzcG9zZSgpOworCQkvLyBpbXBvcnRlZE5hbWVDb250YWluZXJJbWFnZS5kaXNwb3NlKCk7CisJCS8vIHJlZmVyZW5jZUNvbnRhaW5lckltYWdlLmRpc3Bvc2UoKTsKKwkJLy8gcmVmZXJlbmNlSW1hZ2UuZGlzcG9zZSgpOworCQkvLyBpbmRleEltYWdlLmRpc3Bvc2UoKTsKKworCQlzdXBlci5kaXNwb3NlKCk7CisJfQorCisJcHVibGljIHZvaWQgc3RhcnQoSVdvcmtiZW5jaFBhcnRTaXRlIHNpdGUpIHsKKwkJdXBkYXRlVmlldyhzaXRlLmdldFBhZ2UoKS5nZXRBY3RpdmVFZGl0b3IoKSk7CisJCXNpdGUuZ2V0V29ya2JlbmNoV2luZG93KCkuZ2V0UGFydFNlcnZpY2UoKS5hZGRQYXJ0TGlzdGVuZXIodGhpcyk7CisJfQorCisJcHVibGljIHZvaWQgc3RvcChJV29ya2JlbmNoUGFydFNpdGUgc2l0ZSkgeworCQlzaXRlLmdldFdvcmtiZW5jaFdpbmRvdygpLmdldFBhcnRTZXJ2aWNlKCkucmVtb3ZlUGFydExpc3RlbmVyKHRoaXMpOworCQlsYXN0QWN0aXZlRG9jdW1lbnQgPSBudWxsOworCX0KKworCXB1YmxpYyB2b2lkIHBhcnRBY3RpdmF0ZWQoSVdvcmtiZW5jaFBhcnQgcGFydCkgeworCQl1cGRhdGVWaWV3KHBhcnQpOworCX0KKworCXByaXZhdGUgdm9pZCB1cGRhdGVWaWV3KElXb3JrYmVuY2hQYXJ0IHBhcnQpIHsKKwkJaWYgKHBhcnQgaW5zdGFuY2VvZiBYdGV4dEVkaXRvcikgeworCQkJWHRleHRFZGl0b3IgeHRleHRFZGl0b3IgPSAoWHRleHRFZGl0b3IpIHBhcnQ7CisJCQlJWHRleHREb2N1bWVudCB4dGV4dERvY3VtZW50ID0geHRleHRFZGl0b3IuZ2V0RG9jdW1lbnQoKTsKKwkJCWlmICh4dGV4dERvY3VtZW50ICE9IGxhc3RBY3RpdmVEb2N1bWVudCkgeworCQkJCWlmIChsYXN0QWN0aXZlRG9jdW1lbnQgIT0gbnVsbCkgeworCQkJCQlsYXN0QWN0aXZlRG9jdW1lbnQucmVtb3ZlTW9kZWxMaXN0ZW5lcih0aGlzKTsKKwkJCQl9CisKKwkJCQlsYXN0QWN0aXZlRG9jdW1lbnQgPSB4dGV4dERvY3VtZW50OworCQkJCWxhc3RBY3RpdmVEb2N1bWVudC5hZGRNb2RlbExpc3RlbmVyKHRoaXMpOworCQkJCWxhc3RBY3RpdmVEb2N1bWVudAorCQkJCQkJLnJlYWRPbmx5KG5ldyBJVW5pdE9mV29yazxCb29sZWFuLCBYdGV4dFJlc291cmNlPigpIHsKKwkJCQkJCQlAT3ZlcnJpZGUKKwkJCQkJCQlwdWJsaWMgQm9vbGVhbiBleGVjKFh0ZXh0UmVzb3VyY2Ugc3RhdGUpCisJCQkJCQkJCQl0aHJvd3MgRXhjZXB0aW9uIHsKKwkJCQkJCQkJbW9kZWxDaGFuZ2VkKHN0YXRlKTsKKwkJCQkJCQkJcmV0dXJuIHRydWU7CisJCQkJCQkJfQorCQkJCQkJfSk7CisJCQl9CisJCX0KKwl9CisKKwlwdWJsaWMgdm9pZCBwYXJ0QnJvdWdodFRvVG9wKElXb3JrYmVuY2hQYXJ0IHBhcnQpIHsKKwl9CisKKwlwdWJsaWMgdm9pZCBwYXJ0Q2xvc2VkKElXb3JrYmVuY2hQYXJ0IHBhcnQpIHsKKwl9CisKKwlwdWJsaWMgdm9pZCBwYXJ0RGVhY3RpdmF0ZWQoSVdvcmtiZW5jaFBhcnQgcGFydCkgeworCX0KKworCXB1YmxpYyB2b2lkIHBhcnRPcGVuZWQoSVdvcmtiZW5jaFBhcnQgcGFydCkgeworCX0KKworCXB1YmxpYyB2b2lkIG1vZGVsQ2hhbmdlZChmaW5hbCBYdGV4dFJlc291cmNlIHJlc291cmNlKSB7CisJCWlmIChyZXNvdXJjZSA9PSBudWxsKSB7CisJCQlyZXR1cm47CisJCX0KKwkJZ2V0U2l0ZSgpLmdldFdvcmtiZW5jaFdpbmRvdygpLmdldFNoZWxsKCkuZ2V0RGlzcGxheSgpCisJCQkJLmFzeW5jRXhlYyhuZXcgUnVubmFibGUoKSB7CisJCQkJCUBPdmVycmlkZQorCQkJCQlwdWJsaWMgdm9pZCBydW4oKSB7CisJCQkJCQlpZiAodHJlZVZpZXdlciAhPSBudWxsICYmIHJlc291cmNlICE9IG51bGwpIHsKKwkJCQkJCQlpZiAocmVzb3VyY2UuZ2V0VVJJKCkuZmlsZUV4dGVuc2lvbigpCisJCQkJCQkJCQkuZXF1YWxzKCJ1aW1vZGVsIikpIHsKKwkJCQkJCQkJWVZpZXcgeVZpZXcgPSAoWVZpZXcpIHJlc291cmNlLmdldENvbnRlbnRzKCkKKwkJCQkJCQkJCQkuZ2V0KDEpOworCQkJCQkJCQl0cmVlVmlld2VyLnNldElucHV0KHlWaWV3LmdldEJpbmRpbmdTZXQoKSk7CisJCQkJCQkJfQorCQkJCQkJfQorCQkJCQl9CisJCQkJfSk7CisKKwl9CisKKwlwcml2YXRlIGNsYXNzIENvbnRlbnRQcm92aWRlciBpbXBsZW1lbnRzIElUcmVlQ29udGVudFByb3ZpZGVyIHsKKworCQlAT3ZlcnJpZGUKKwkJcHVibGljIHZvaWQgZGlzcG9zZSgpIHsKKworCQl9CisKKwkJQE92ZXJyaWRlCisJCXB1YmxpYyB2b2lkIGlucHV0Q2hhbmdlZChWaWV3ZXIgdmlld2VyLCBPYmplY3Qgb2xkSW5wdXQsIE9iamVjdCBuZXdJbnB1dCkgeworCQl9CisKKwkJQE92ZXJyaWRlCisJCXB1YmxpYyBPYmplY3RbXSBnZXRFbGVtZW50cyhPYmplY3QgaW5wdXRFbGVtZW50KSB7CisJCQlZQmluZGluZ1NldCB5QmluZGluZ1NldCA9IChZQmluZGluZ1NldCkgaW5wdXRFbGVtZW50OworCQkJcmV0dXJuIHlCaW5kaW5nU2V0ICE9IG51bGwgPyB5QmluZGluZ1NldC5nZXRCaW5kaW5ncygpLnRvQXJyYXkoKQorCQkJCQk6IG5ldyBPYmplY3RbMF07CisJCX0KKworCQlAT3ZlcnJpZGUKKwkJcHVibGljIE9iamVjdFtdIGdldENoaWxkcmVuKE9iamVjdCBwYXJlbnRFbGVtZW50KSB7CisJCQlpZiAocGFyZW50RWxlbWVudCBpbnN0YW5jZW9mIFlCaW5kaW5nKSB7CisJCQkJWUJpbmRpbmcgeUJpbmRpbmcgPSAoWUJpbmRpbmcpIHBhcmVudEVsZW1lbnQ7CisJCQkJTGlzdDxPYmplY3Q+IG9iamVjdHMgPSBuZXcgQXJyYXlMaXN0PE9iamVjdD4oKTsKKwkJCQlvYmplY3RzLmFkZCh5QmluZGluZy5nZXRNb2RlbEVuZHBvaW50KCkpOworCQkJCW9iamVjdHMuYWRkKHlCaW5kaW5nLmdldFRhcmdldEVuZHBvaW50KCkpOworCQkJCXJldHVybiBvYmplY3RzLnRvQXJyYXkoKTsKKwkJCX0KKwkJCXJldHVybiBudWxsOworCQl9CisKKwkJQE92ZXJyaWRlCisJCXB1YmxpYyBPYmplY3QgZ2V0UGFyZW50KE9iamVjdCBlbGVtZW50KSB7CisJCQlyZXR1cm4gbnVsbDsKKwkJfQorCisJCUBPdmVycmlkZQorCQlwdWJsaWMgYm9vbGVhbiBoYXNDaGlsZHJlbihPYmplY3QgZWxlbWVudCkgeworCQkJaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBZQmluZGluZykgeworCQkJCXJldHVybiB0cnVlOworCQkJfQorCQkJcmV0dXJuIGZhbHNlOworCQl9CisJfQorfQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvdmlldy9YdGV4dEluZGV4Vmlldy5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS91aS92aWV3L1h0ZXh0SW5kZXhWaWV3LmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMmVhYWQ3ZQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvdWkvdmlldy9YdGV4dEluZGV4Vmlldy5qYXZhCkBAIC0wLDAgKzEsNDA1IEBACisvKioKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNSAtIEx1bmlmZXJhIEdtYkggKEdyb3NzIEVuemVyc2RvcmYsIEF1c3RyaWEpLCBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscworICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKKyAqCisgKiBDb250cmlidXRvcnM6CisgKiAgICAgICAgIEZsb3JpYW4gUGlyY2huZXIgLSBJbml0aWFsIGltcGxlbWVudGF0aW9uCisgKi8KKworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpLnZpZXc7CisKK2ltcG9ydCBqYXZhLmlvLklPRXhjZXB0aW9uOworaW1wb3J0IGphdmEuc2VjdXJpdHkuSW52YWxpZEtleUV4Y2VwdGlvbjsKK2ltcG9ydCBqYXZhLnNlY3VyaXR5Lk5vU3VjaEFsZ29yaXRobUV4Y2VwdGlvbjsKK2ltcG9ydCBqYXZhLnNlY3VyaXR5Lk5vU3VjaFByb3ZpZGVyRXhjZXB0aW9uOworaW1wb3J0IGphdmEuc2VjdXJpdHkuU2lnbmF0dXJlRXhjZXB0aW9uOworaW1wb3J0IGphdmEuc2VjdXJpdHkuY2VydC5DZXJ0aWZpY2F0ZUV4Y2VwdGlvbjsKK2ltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OworaW1wb3J0IGphdmEudXRpbC5MaXN0OworCitpbXBvcnQgb3JnLmVjbGlwc2UuZW1mLmNvbW1vbi51dGlsLlVSSTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5lbWYuZWNvcmUucmVzb3VyY2UuUmVzb3VyY2U7CitpbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5JVHJlZUNvbnRlbnRQcm92aWRlcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLkxhYmVsUHJvdmlkZXI7CitpbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5UcmVlVmlld2VyOworaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuVmlld2VyOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kuc2lnbmVkY29udGVudC5TaWduZWRDb250ZW50OworaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kuc2lnbmVkY29udGVudC5TaWduZWRDb250ZW50RW50cnk7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS5zaWduZWRjb250ZW50LlNpZ25lZENvbnRlbnRGYWN0b3J5OworaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC5ncmFwaGljcy5JbWFnZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5Db21wb3NpdGU7CitpbXBvcnQgb3JnLmVjbGlwc2UudWkuSVBhcnRMaXN0ZW5lcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS51aS5JV29ya2JlbmNoUGFydDsKK2ltcG9ydCBvcmcuZWNsaXBzZS51aS5JV29ya2JlbmNoUGFydFNpdGU7CitpbXBvcnQgb3JnLmVjbGlwc2UudWkucGFydC5WaWV3UGFydDsKK2ltcG9ydCBvcmcuZWNsaXBzZS54dGV4dC5idWlsZGVyLmJ1aWxkZXJTdGF0ZS5JQnVpbGRlclN0YXRlOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0Lm5hbWluZy5RdWFsaWZpZWROYW1lOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnJlc291cmNlLklFT2JqZWN0RGVzY3JpcHRpb247CitpbXBvcnQgb3JnLmVjbGlwc2UueHRleHQucmVzb3VyY2UuSVJlZmVyZW5jZURlc2NyaXB0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnJlc291cmNlLklSZXNvdXJjZURlc2NyaXB0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnJlc291cmNlLlh0ZXh0UmVzb3VyY2U7CitpbXBvcnQgb3JnLmVjbGlwc2UueHRleHQudWkuZWRpdG9yLlh0ZXh0RWRpdG9yOworaW1wb3J0IG9yZy5lY2xpcHNlLnh0ZXh0LnVpLmVkaXRvci5tb2RlbC5JWHRleHREb2N1bWVudDsKK2ltcG9ydCBvcmcuZWNsaXBzZS54dGV4dC51aS5lZGl0b3IubW9kZWwuSVh0ZXh0TW9kZWxMaXN0ZW5lcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS54dGV4dC51dGlsLmNvbmN1cnJlbnQuSVVuaXRPZldvcms7CitpbXBvcnQgb3JnLmVjbGlwc2UueHRleHQueGJhc2UubGliLkZ1bmN0aW9uczsKK2ltcG9ydCBvcmcuZWNsaXBzZS54dGV4dC54YmFzZS5saWIuSXRlcmFibGVFeHRlbnNpb25zOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuQ29yZVVpQWN0aXZhdG9yOworaW1wb3J0IG9yZy5vc2dpLmZyYW1ld29yay5CdW5kbGU7CitpbXBvcnQgb3JnLm9zZ2kuZnJhbWV3b3JrLkZyYW1ld29ya1V0aWw7CitpbXBvcnQgb3JnLm9zZ2kuZnJhbWV3b3JrLlNlcnZpY2VSZWZlcmVuY2U7CisKK2ltcG9ydCBjb20uZ29vZ2xlLmluamVjdC5JbmplY3Q7CisKK0BTdXBwcmVzc1dhcm5pbmdzKCJyZXN0cmljdGlvbiIpCitwdWJsaWMgY2xhc3MgWHRleHRJbmRleFZpZXcgZXh0ZW5kcyBWaWV3UGFydCBpbXBsZW1lbnRzIElQYXJ0TGlzdGVuZXIsCisJCUlYdGV4dE1vZGVsTGlzdGVuZXIgeworCisJcHVibGljIHN0YXRpYyBmaW5hbCBTdHJpbmcgSUQgPSAib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS52aWV3Lnh0ZXh0aW5kZXgiOworCisJQEluamVjdAorCXByaXZhdGUgSUJ1aWxkZXJTdGF0ZSBidWlsZGVyU3RhdGU7CisKKy8vCXByaXZhdGUgSW1hZ2UgaW5kZXhJbWFnZSA9IENvcmVVaUFjdGl2YXRvci5pbWFnZURlc2NyaXB0b3JGcm9tUGx1Z2luKAorLy8JCQlDb3JlVWlBY3RpdmF0b3IuUExVR0lOX0lELCAiaWNvbnMvSW5kZXgtUmVzb3VyY2UuZ2lmIikKKy8vCQkJLmNyZWF0ZUltYWdlKCk7CisvLwlwcml2YXRlIEltYWdlIGV4cG9ydGVkQ29udGFpbmVySW1hZ2UgPSBDb3JlVWlBY3RpdmF0b3IKKy8vCQkJLmltYWdlRGVzY3JpcHRvckZyb21QbHVnaW4oQ29yZVVpQWN0aXZhdG9yLlBMVUdJTl9JRCwKKy8vCQkJCQkiaWNvbnMvSW5kZXgtRXhwb3J0ZWRDb250YWluZXIuZ2lmIikuY3JlYXRlSW1hZ2UoKTsKKy8vCXByaXZhdGUgSW1hZ2UgaW1wb3J0ZWROYW1lQ29udGFpbmVySW1hZ2UgPSBDb3JlVWlBY3RpdmF0b3IKKy8vCQkJLmltYWdlRGVzY3JpcHRvckZyb21QbHVnaW4oQ29yZVVpQWN0aXZhdG9yLlBMVUdJTl9JRCwKKy8vCQkJCQkiaWNvbnMvSW5kZXgtSW1wb3J0ZWROYW1lQ29udGFpbmVyLmdpZiIpLmNyZWF0ZUltYWdlKCk7CisvLwlwcml2YXRlIEltYWdlIHJlZmVyZW5jZUNvbnRhaW5lckltYWdlID0gQ29yZVVpQWN0aXZhdG9yCisvLwkJCS5pbWFnZURlc2NyaXB0b3JGcm9tUGx1Z2luKENvcmVVaUFjdGl2YXRvci5QTFVHSU5fSUQsCisvLwkJCQkJImljb25zL0luZGV4LVJlZmVyZW5jZUNvbnRhaW5lci5naWYiKS5jcmVhdGVJbWFnZSgpOworLy8JcHJpdmF0ZSBJbWFnZSByZWZlcmVuY2VJbWFnZSA9IENvcmVVaUFjdGl2YXRvci5pbWFnZURlc2NyaXB0b3JGcm9tUGx1Z2luKAorLy8JCQlDb3JlVWlBY3RpdmF0b3IuUExVR0lOX0lELCAiaWNvbnMvSW5kZXgtUmVmZXJlbmNlRGVzY3JpcHRpb24uZ2lmIikKKy8vCQkJLmNyZWF0ZUltYWdlKCk7CisKKwlwcml2YXRlIFRyZWVWaWV3ZXIgdHJlZVZpZXdlcjsKKworCXByaXZhdGUgSVh0ZXh0RG9jdW1lbnQgbGFzdEFjdGl2ZURvY3VtZW50OworCisJcHVibGljIFh0ZXh0SW5kZXhWaWV3KCkgeworCisJfQorCisJQE92ZXJyaWRlCisJcHVibGljIHZvaWQgY3JlYXRlUGFydENvbnRyb2woQ29tcG9zaXRlIHBhcmVudCkgeworCisJCUJ1bmRsZSBiID0gRnJhbWV3b3JrVXRpbC5nZXRCdW5kbGUoZ2V0Q2xhc3MoKSk7CisJCVNlcnZpY2VSZWZlcmVuY2U8U2lnbmVkQ29udGVudEZhY3Rvcnk+IHJlZiA9IChTZXJ2aWNlUmVmZXJlbmNlPFNpZ25lZENvbnRlbnRGYWN0b3J5PikgYi5nZXRCdW5kbGVDb250ZXh0KCkuZ2V0U2VydmljZVJlZmVyZW5jZShTaWduZWRDb250ZW50RmFjdG9yeS5jbGFzcy5nZXROYW1lKCkpOworCQlTaWduZWRDb250ZW50RmFjdG9yeSBzZXJ2aWNlID0gYi5nZXRCdW5kbGVDb250ZXh0KCkuZ2V0U2VydmljZShyZWYpOworCQkKKwkJZm9yKEJ1bmRsZSB0IDogYi5nZXRCdW5kbGVDb250ZXh0KCkuZ2V0QnVuZGxlcygpKXsKKwkJCWlmKHQuZ2V0U3ltYm9saWNOYW1lKCkuZXF1YWxzKCJvcmcuZWNsaXBzZS5lcXVpbm94LnByZWZlcmVuY2VzIikpeworCQkJCVNpZ25lZENvbnRlbnQgc2M7CisJCQkJdHJ5IHsKKwkJCQkJc2MgPSBzZXJ2aWNlLmdldFNpZ25lZENvbnRlbnQodCk7CisJCQkJCVNpZ25lZENvbnRlbnRFbnRyeVtdIHNjZSA9IHNjLmdldFNpZ25lZEVudHJpZXMoKTsKKwkJCQkJCisJCQkJCWZvciAoU2lnbmVkQ29udGVudEVudHJ5IHNpZ25lZENvbnRlbnRFbnRyeSA6IHNjZSkgeworCQkJCQkJU3lzdGVtLm91dC5wcmludGxuKHNpZ25lZENvbnRlbnRFbnRyeSk7CisJCQkJCX0KKworCQkJCQlzYy5jaGVja1ZhbGlkaXR5KHNjLmdldFNpZ25lckluZm9zKClbc2MuZ2V0U2lnbmVySW5mb3MoKS5sZW5ndGggLSAxXSk7CisJCQkJCQorCQkJCQlpZihzY2UubGVuZ3RoID4gMTcpIHsKKwkJCQkJCVN5c3RlbS5vdXQucHJpbnRsbigiVGVzdCIpOworCQkJCQl9CisJCQkJCQorCQkJCX0gY2F0Y2ggKEludmFsaWRLZXlFeGNlcHRpb24gfCBTaWduYXR1cmVFeGNlcHRpb24KKwkJCQkJCXwgQ2VydGlmaWNhdGVFeGNlcHRpb24gfCBOb1N1Y2hBbGdvcml0aG1FeGNlcHRpb24KKwkJCQkJCXwgTm9TdWNoUHJvdmlkZXJFeGNlcHRpb24gfCBJT0V4Y2VwdGlvbiBlKSB7CisJCQkJCWUucHJpbnRTdGFja1RyYWNlKCk7CisJCQkJfQorCQkJfQorCQl9CisJCQorCQkKKwkJCisJCQorCQl0cmVlVmlld2VyID0gbmV3IFRyZWVWaWV3ZXIocGFyZW50KTsKKwkJdHJlZVZpZXdlci5zZXRDb250ZW50UHJvdmlkZXIobmV3IENvbnRlbnRQcm92aWRlcigpKTsKKwkJdHJlZVZpZXdlci5zZXRMYWJlbFByb3ZpZGVyKG5ldyBMYWJlbFByb3ZpZGVyKCkgeworCQkJQE92ZXJyaWRlCisJCQlwdWJsaWMgSW1hZ2UgZ2V0SW1hZ2UoT2JqZWN0IGVsZW1lbnQpIHsKKy8vCQkJCWlmIChlbGVtZW50IGluc3RhbmNlb2YgSVJlc291cmNlRGVzY3JpcHRpb24pIHsKKy8vCQkJCQlyZXR1cm4gaW5kZXhJbWFnZTsKKy8vCQkJCX0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIEV4cG9ydGVkT2JqZWN0cykgeworLy8JCQkJCXJldHVybiBleHBvcnRlZENvbnRhaW5lckltYWdlOworLy8JCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgSW1wb3J0ZWROYW1lcykgeworLy8JCQkJCXJldHVybiBpbXBvcnRlZE5hbWVDb250YWluZXJJbWFnZTsKKy8vCQkJCX0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIFJlZmVyZW5jZURlc2NyaXB0aW9ucykgeworLy8JCQkJCXJldHVybiByZWZlcmVuY2VDb250YWluZXJJbWFnZTsKKy8vCQkJCX0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIElSZWZlcmVuY2VEZXNjcmlwdGlvbikgeworLy8JCQkJCXJldHVybiByZWZlcmVuY2VJbWFnZTsKKy8vCQkJCX0KKwkJCQlyZXR1cm4gc3VwZXIuZ2V0SW1hZ2UoZWxlbWVudCk7CisJCQl9CisKKwkJCUBPdmVycmlkZQorCQkJcHVibGljIFN0cmluZyBnZXRUZXh0KE9iamVjdCBlbGVtZW50KSB7CisJCQkJaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBTdHJpbmcpIHsKKwkJCQkJcmV0dXJuIChTdHJpbmcpIGVsZW1lbnQ7CisJCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgSVJlc291cmNlRGVzY3JpcHRpb24pIHsKKwkJCQkJcmV0dXJuICgoSVJlc291cmNlRGVzY3JpcHRpb24pIGVsZW1lbnQpLmdldFVSSSgpLnRvU3RyaW5nKCk7CisJCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgRXhwb3J0ZWRPYmplY3RzKSB7CisJCQkJCXJldHVybiAiZXhwb3J0ZWQgT2JqZWN0cyI7CisJCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgSW1wb3J0ZWROYW1lcykgeworCQkJCQlyZXR1cm4gImltcG9ydGVkIE5hbWVzIjsKKwkJCQl9IGVsc2UgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBSZWZlcmVuY2VEZXNjcmlwdGlvbnMpIHsKKwkJCQkJcmV0dXJuICJyZWZlcmVuY2UgRGVzY3JpcHRpb25zIjsKKwkJCQl9IGVsc2UgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBJUmVmZXJlbmNlRGVzY3JpcHRpb24pIHsKKwkJCQkJSVJlZmVyZW5jZURlc2NyaXB0aW9uIGRlc2MgPSAoSVJlZmVyZW5jZURlc2NyaXB0aW9uKSBlbGVtZW50OworCQkJCQlyZXR1cm4gZGVzYy5nZXRFUmVmZXJlbmNlKCkuZ2V0TmFtZSgpICsgIi0tIgorCQkJCQkJCSsgKGRlc2MuZ2V0Q29udGFpbmVyRU9iamVjdFVSSSgpICE9IG51bGwgPyBkZXNjLmdldENvbnRhaW5lckVPYmplY3RVUkkoKS50b1N0cmluZygpIDogIm51bGwiKTsKKwkJCQl9IGVsc2UgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBFbnRyeSkgeworCQkJCQlFbnRyeSBlbnRyeSA9IChFbnRyeSkgZWxlbWVudDsKKwkJCQkJcmV0dXJuIGVudHJ5LmtleSArICI6ICAiICsgZW50cnkudmFsdWU7CisJCQkJfSBlbHNlIGlmIChlbGVtZW50IGluc3RhbmNlb2YgSUVPYmplY3REZXNjcmlwdGlvbikgeworCQkJCQlJRU9iamVjdERlc2NyaXB0aW9uIGRlc2MgPSAoSUVPYmplY3REZXNjcmlwdGlvbikgZWxlbWVudDsKKwkJCQkJU3RyaW5nQnVpbGRlciBiID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKKwkJCQkJYi5hcHBlbmQoIiAtICIpOworCQkJCQliLmFwcGVuZChkZXNjLmdldEVDbGFzcygpLmdldE5hbWUoKSk7CisJCQkJCWIuYXBwZW5kKCIoIik7CisJCQkJCWIuYXBwZW5kKGRlc2MuZ2V0TmFtZSgpKTsKKwkJCQkJYi5hcHBlbmQoIikgIC0tPiAgIik7CisJCQkJCWIuYXBwZW5kKGRlc2MuZ2V0RU9iamVjdFVSSSgpKTsKKwkJCQkJcmV0dXJuIGIudG9TdHJpbmcoKTsKKwkJCQl9IGVsc2UgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBVUkkpIHsKKwkJCQkJcmV0dXJuIGVsZW1lbnQudG9TdHJpbmcoKTsKKwkJCQl9CisJCQkJcmV0dXJuICIiOworCQkJfQorCQl9KTsKKworCQlzdGFydChnZXRWaWV3U2l0ZSgpKTsKKwl9CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgdm9pZCBzZXRGb2N1cygpIHsKKworCX0KKworCUBPdmVycmlkZQorCXB1YmxpYyB2b2lkIGRpc3Bvc2UoKSB7CisKKwkJc3RvcChnZXRWaWV3U2l0ZSgpKTsKKworLy8JCWV4cG9ydGVkQ29udGFpbmVySW1hZ2UuZGlzcG9zZSgpOworLy8JCWltcG9ydGVkTmFtZUNvbnRhaW5lckltYWdlLmRpc3Bvc2UoKTsKKy8vCQlyZWZlcmVuY2VDb250YWluZXJJbWFnZS5kaXNwb3NlKCk7CisvLwkJcmVmZXJlbmNlSW1hZ2UuZGlzcG9zZSgpOworLy8JCWluZGV4SW1hZ2UuZGlzcG9zZSgpOworCisJCXN1cGVyLmRpc3Bvc2UoKTsKKwl9CisKKwlwdWJsaWMgdm9pZCBzdGFydChJV29ya2JlbmNoUGFydFNpdGUgc2l0ZSkgeworCQl1cGRhdGVWaWV3KHNpdGUuZ2V0UGFnZSgpLmdldEFjdGl2ZUVkaXRvcigpKTsKKwkJc2l0ZS5nZXRXb3JrYmVuY2hXaW5kb3coKS5nZXRQYXJ0U2VydmljZSgpLmFkZFBhcnRMaXN0ZW5lcih0aGlzKTsKKwl9CisKKwlwdWJsaWMgdm9pZCBzdG9wKElXb3JrYmVuY2hQYXJ0U2l0ZSBzaXRlKSB7CisJCXNpdGUuZ2V0V29ya2JlbmNoV2luZG93KCkuZ2V0UGFydFNlcnZpY2UoKS5yZW1vdmVQYXJ0TGlzdGVuZXIodGhpcyk7CisJCWxhc3RBY3RpdmVEb2N1bWVudCA9IG51bGw7CisJfQorCisJcHVibGljIHZvaWQgcGFydEFjdGl2YXRlZChJV29ya2JlbmNoUGFydCBwYXJ0KSB7CisJCXVwZGF0ZVZpZXcocGFydCk7CisJfQorCisJcHJpdmF0ZSB2b2lkIHVwZGF0ZVZpZXcoSVdvcmtiZW5jaFBhcnQgcGFydCkgeworCQlpZiAocGFydCBpbnN0YW5jZW9mIFh0ZXh0RWRpdG9yKSB7CisJCQlYdGV4dEVkaXRvciB4dGV4dEVkaXRvciA9IChYdGV4dEVkaXRvcikgcGFydDsKKwkJCUlYdGV4dERvY3VtZW50IHh0ZXh0RG9jdW1lbnQgPSB4dGV4dEVkaXRvci5nZXREb2N1bWVudCgpOworCQkJaWYgKHh0ZXh0RG9jdW1lbnQgIT0gbGFzdEFjdGl2ZURvY3VtZW50KSB7CisJCQkJaWYgKGxhc3RBY3RpdmVEb2N1bWVudCAhPSBudWxsKSB7CisJCQkJCWxhc3RBY3RpdmVEb2N1bWVudC5yZW1vdmVNb2RlbExpc3RlbmVyKHRoaXMpOworCQkJCX0KKworCQkJCWxhc3RBY3RpdmVEb2N1bWVudCA9IHh0ZXh0RG9jdW1lbnQ7CisJCQkJbGFzdEFjdGl2ZURvY3VtZW50LmFkZE1vZGVsTGlzdGVuZXIodGhpcyk7CisJCQkJbGFzdEFjdGl2ZURvY3VtZW50CisJCQkJCQkucmVhZE9ubHkobmV3IElVbml0T2ZXb3JrPEJvb2xlYW4sIFh0ZXh0UmVzb3VyY2U+KCkgeworCQkJCQkJCUBPdmVycmlkZQorCQkJCQkJCXB1YmxpYyBCb29sZWFuIGV4ZWMoWHRleHRSZXNvdXJjZSBzdGF0ZSkKKwkJCQkJCQkJCXRocm93cyBFeGNlcHRpb24geworCQkJCQkJCQltb2RlbENoYW5nZWQoc3RhdGUpOworCQkJCQkJCQlyZXR1cm4gdHJ1ZTsKKwkJCQkJCQl9CisJCQkJCQl9KTsKKwkJCX0KKwkJfQorCX0KKworCXB1YmxpYyB2b2lkIHBhcnRCcm91Z2h0VG9Ub3AoSVdvcmtiZW5jaFBhcnQgcGFydCkgeworCX0KKworCXB1YmxpYyB2b2lkIHBhcnRDbG9zZWQoSVdvcmtiZW5jaFBhcnQgcGFydCkgeworCX0KKworCXB1YmxpYyB2b2lkIHBhcnREZWFjdGl2YXRlZChJV29ya2JlbmNoUGFydCBwYXJ0KSB7CisJfQorCisJcHVibGljIHZvaWQgcGFydE9wZW5lZChJV29ya2JlbmNoUGFydCBwYXJ0KSB7CisJfQorCisJcHVibGljIHZvaWQgbW9kZWxDaGFuZ2VkKGZpbmFsIFh0ZXh0UmVzb3VyY2UgcmVzb3VyY2UpIHsKKwkJaWYgKHJlc291cmNlID09IG51bGwpIHsKKwkJCXJldHVybjsKKwkJfQorCQlnZXRTaXRlKCkuZ2V0V29ya2JlbmNoV2luZG93KCkuZ2V0U2hlbGwoKS5nZXREaXNwbGF5KCkKKwkJCQkuYXN5bmNFeGVjKG5ldyBSdW5uYWJsZSgpIHsKKwkJCQkJQE92ZXJyaWRlCisJCQkJCXB1YmxpYyB2b2lkIHJ1bigpIHsKKwkJCQkJCWlmICh0cmVlVmlld2VyICE9IG51bGwgJiYgcmVzb3VyY2UgIT0gbnVsbCkgeworCQkJCQkJCXRyZWVWaWV3ZXIuc2V0SW5wdXQocmVzb3VyY2UpOworCQkJCQkJfQorCQkJCQl9CisJCQkJfSk7CisKKwl9CisKKwlwcml2YXRlIGNsYXNzIENvbnRlbnRQcm92aWRlciBpbXBsZW1lbnRzIElUcmVlQ29udGVudFByb3ZpZGVyIHsKKworCQlAT3ZlcnJpZGUKKwkJcHVibGljIHZvaWQgZGlzcG9zZSgpIHsKKworCQl9CisKKwkJQE92ZXJyaWRlCisJCXB1YmxpYyB2b2lkIGlucHV0Q2hhbmdlZChWaWV3ZXIgdmlld2VyLCBPYmplY3Qgb2xkSW5wdXQsIE9iamVjdCBuZXdJbnB1dCkgeworCQl9CisKKwkJQE92ZXJyaWRlCisJCXB1YmxpYyBPYmplY3RbXSBnZXRFbGVtZW50cyhPYmplY3QgaW5wdXRFbGVtZW50KSB7CisJCQlSZXNvdXJjZSByZXNvdXJjZSA9IChSZXNvdXJjZSkgaW5wdXRFbGVtZW50OworCQkJSVJlc291cmNlRGVzY3JpcHRpb24gZGVzYyA9IGJ1aWxkZXJTdGF0ZQorCQkJCQkuZ2V0UmVzb3VyY2VEZXNjcmlwdGlvbihyZXNvdXJjZS5nZXRVUkkoKSk7CisJCQlyZXR1cm4gZGVzYyAhPSBudWxsID8gbmV3IE9iamVjdFtdIHsgZGVzYyB9IDogbmV3IE9iamVjdFswXTsKKwkJfQorCisJCUBPdmVycmlkZQorCQlwdWJsaWMgT2JqZWN0W10gZ2V0Q2hpbGRyZW4oT2JqZWN0IHBhcmVudEVsZW1lbnQpIHsKKwkJCWlmIChwYXJlbnRFbGVtZW50IGluc3RhbmNlb2YgSVJlc291cmNlRGVzY3JpcHRpb24pIHsKKwkJCQlJUmVzb3VyY2VEZXNjcmlwdGlvbiBkZXNjID0gKElSZXNvdXJjZURlc2NyaXB0aW9uKSBwYXJlbnRFbGVtZW50OworCQkJCUxpc3Q8T2JqZWN0PiBvYmplY3RzID0gbmV3IEFycmF5TGlzdDxPYmplY3Q+KCk7CisJCQkJb2JqZWN0cy5hZGQobmV3IEV4cG9ydGVkT2JqZWN0cyhkZXNjLmdldEV4cG9ydGVkT2JqZWN0cygpKSk7CisJCQkJb2JqZWN0cy5hZGQobmV3IEltcG9ydGVkTmFtZXMoZGVzYy5nZXRJbXBvcnRlZE5hbWVzKCkpKTsKKwkJCQlvYmplY3RzLmFkZChuZXcgUmVmZXJlbmNlRGVzY3JpcHRpb25zKGRlc2MKKwkJCQkJCS5nZXRSZWZlcmVuY2VEZXNjcmlwdGlvbnMoKSkpOworCQkJCXJldHVybiBvYmplY3RzLnRvQXJyYXkoKTsKKwkJCX0gZWxzZSBpZiAocGFyZW50RWxlbWVudCBpbnN0YW5jZW9mIEV4cG9ydGVkT2JqZWN0cykgeworCQkJCUV4cG9ydGVkT2JqZWN0cyBleHBvcnRlZE9iamVjdHMgPSAoRXhwb3J0ZWRPYmplY3RzKSBwYXJlbnRFbGVtZW50OworCQkJCXJldHVybiBleHBvcnRlZE9iamVjdHMuZXhwb3J0ZWQudG9BcnJheSgpOworCQkJfSBlbHNlIGlmIChwYXJlbnRFbGVtZW50IGluc3RhbmNlb2YgSW1wb3J0ZWROYW1lcykgeworCQkJCUltcG9ydGVkTmFtZXMgbmFtZXMgPSAoSW1wb3J0ZWROYW1lcykgcGFyZW50RWxlbWVudDsKKwkJCQlyZXR1cm4gbmFtZXMuaW1wb3J0ZWROYW1lcy50b0FycmF5KCk7CisJCQl9IGVsc2UgaWYgKHBhcmVudEVsZW1lbnQgaW5zdGFuY2VvZiBSZWZlcmVuY2VEZXNjcmlwdGlvbnMpIHsKKwkJCQlSZWZlcmVuY2VEZXNjcmlwdGlvbnMgcmVzRGVzY3MgPSAoUmVmZXJlbmNlRGVzY3JpcHRpb25zKSBwYXJlbnRFbGVtZW50OworCQkJCXJldHVybiByZXNEZXNjcy5yZWZEZXNjcy50b0FycmF5KCk7CisJCQl9IGVsc2UgaWYgKHBhcmVudEVsZW1lbnQgaW5zdGFuY2VvZiBJUmVmZXJlbmNlRGVzY3JpcHRpb24pIHsKKwkJCQlJUmVmZXJlbmNlRGVzY3JpcHRpb24gZGVzYyA9IChJUmVmZXJlbmNlRGVzY3JpcHRpb24pIHBhcmVudEVsZW1lbnQ7CisJCQkJTGlzdDxPYmplY3Q+IGVsZW1lbnRzID0gbmV3IEFycmF5TGlzdDxPYmplY3Q+KCk7CisJCQkJZWxlbWVudHMuYWRkKG5ldyBFbnRyeSgiIC0gZVJlZmVyZW5jZSIsIGRlc2MuZ2V0RVJlZmVyZW5jZSgpCisJCQkJCQkuZ2V0TmFtZSgpKSk7CisJCQkJZWxlbWVudHMuYWRkKG5ldyBFbnRyeSgiIC0gaW5kZXgiLCBJbnRlZ2VyLnRvU3RyaW5nKGRlc2MKKwkJCQkJCS5nZXRJbmRleEluTGlzdCgpKSkpOworCQkJCWVsZW1lbnRzLmFkZChuZXcgRW50cnkoIiAtIGNvbnRhaW5lciIsIGRlc2MKKwkJCQkJCS5nZXRDb250YWluZXJFT2JqZWN0VVJJKCkgIT0gbnVsbCA/IGRlc2MKKwkJCQkJCS5nZXRDb250YWluZXJFT2JqZWN0VVJJKCkudG9TdHJpbmcoKSA6ICJudWxsIikpOworCQkJCWVsZW1lbnRzLmFkZChuZXcgRW50cnkoIiAtIHNvdXJjZSIsIGRlc2MuZ2V0U291cmNlRU9iamVjdFVyaSgpCisJCQkJCQkudG9TdHJpbmcoKSkpOworCQkJCWVsZW1lbnRzLmFkZChuZXcgRW50cnkoIiAtIHRhcmdldCIsIGRlc2MuZ2V0VGFyZ2V0RU9iamVjdFVyaSgpCisJCQkJCQkudG9TdHJpbmcoKSkpOworCQkJCXJldHVybiBlbGVtZW50cy50b0FycmF5KCk7CisJCQl9IGVsc2UgaWYgKHBhcmVudEVsZW1lbnQgaW5zdGFuY2VvZiBJRU9iamVjdERlc2NyaXB0aW9uKSB7CisJCQkJSUVPYmplY3REZXNjcmlwdGlvbiBkZXNjID0gKElFT2JqZWN0RGVzY3JpcHRpb24pIHBhcmVudEVsZW1lbnQ7CisJCQkJTGlzdDxTdHJpbmc+IHVzZXJEYXRhID0gbmV3IEFycmF5TGlzdDxTdHJpbmc+KCk7CisJCQkJZm9yIChTdHJpbmcga2V5IDogZGVzYy5nZXRVc2VyRGF0YUtleXMoKSkgeworCQkJCQlTdHJpbmcgZGF0YSA9IGtleSArICIgOiAiICsgZGVzYy5nZXRVc2VyRGF0YShrZXkpOworCQkJCQl1c2VyRGF0YS5hZGQoZGF0YSk7CisJCQkJfQorCQkJCXJldHVybiB1c2VyRGF0YS50b0FycmF5KCk7CisJCQl9CisJCQlyZXR1cm4gbnVsbDsKKwkJfQorCisJCUBPdmVycmlkZQorCQlwdWJsaWMgT2JqZWN0IGdldFBhcmVudChPYmplY3QgZWxlbWVudCkgeworCQkJcmV0dXJuIG51bGw7CisJCX0KKworCQlAT3ZlcnJpZGUKKwkJcHVibGljIGJvb2xlYW4gaGFzQ2hpbGRyZW4oT2JqZWN0IGVsZW1lbnQpIHsKKwkJCWlmIChlbGVtZW50IGluc3RhbmNlb2YgSVJlc291cmNlRGVzY3JpcHRpb24pIHsKKwkJCQlyZXR1cm4gdHJ1ZTsKKwkJCX0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIEV4cG9ydGVkT2JqZWN0cykgeworCQkJCUV4cG9ydGVkT2JqZWN0cyBleHBvcnRlZE9iamVjdHMgPSAoRXhwb3J0ZWRPYmplY3RzKSBlbGVtZW50OworCQkJCXJldHVybiAhZXhwb3J0ZWRPYmplY3RzLmV4cG9ydGVkLmlzRW1wdHkoKTsKKwkJCX0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIEltcG9ydGVkTmFtZXMpIHsKKwkJCQlJbXBvcnRlZE5hbWVzIG5hbWVzID0gKEltcG9ydGVkTmFtZXMpIGVsZW1lbnQ7CisJCQkJcmV0dXJuICFuYW1lcy5pbXBvcnRlZE5hbWVzLmlzRW1wdHkoKTsKKwkJCX0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIFJlZmVyZW5jZURlc2NyaXB0aW9ucykgeworCQkJCVJlZmVyZW5jZURlc2NyaXB0aW9ucyByZXNEZXNjcyA9IChSZWZlcmVuY2VEZXNjcmlwdGlvbnMpIGVsZW1lbnQ7CisJCQkJcmV0dXJuICFyZXNEZXNjcy5yZWZEZXNjcy5pc0VtcHR5KCk7CisJCQl9IGVsc2UgaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBJUmVmZXJlbmNlRGVzY3JpcHRpb24pIHsKKwkJCQlyZXR1cm4gdHJ1ZTsKKwkJCX0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIElFT2JqZWN0RGVzY3JpcHRpb24pIHsKKwkJCQlyZXR1cm4gKChJRU9iamVjdERlc2NyaXB0aW9uKSBlbGVtZW50KS5nZXRVc2VyRGF0YUtleXMoKS5sZW5ndGggPiAwOworCQkJfQorCQkJcmV0dXJuIGZhbHNlOworCQl9CisJfQorCisJcHJpdmF0ZSBzdGF0aWMgY2xhc3MgRXhwb3J0ZWRPYmplY3RzIHsKKworCQlwcml2YXRlIExpc3Q8SUVPYmplY3REZXNjcmlwdGlvbj4gZXhwb3J0ZWQ7CisKKwkJcHVibGljIEV4cG9ydGVkT2JqZWN0cyhJdGVyYWJsZTxJRU9iamVjdERlc2NyaXB0aW9uPiBleHBvcnRlZE9iamVjdHMpIHsKKwkJCWV4cG9ydGVkID0gSXRlcmFibGVFeHRlbnNpb25zLnRvTGlzdChleHBvcnRlZE9iamVjdHMpOworCQl9CisKKwl9CisKKwlwcml2YXRlIHN0YXRpYyBjbGFzcyBJbXBvcnRlZE5hbWVzIHsKKwkJcHJpdmF0ZSBMaXN0PFN0cmluZz4gaW1wb3J0ZWROYW1lczsKKworCQlwdWJsaWMgSW1wb3J0ZWROYW1lcyhJdGVyYWJsZTxRdWFsaWZpZWROYW1lPiBpbXBvcnRlZE5hbWVzKSB7CisJCQlJdGVyYWJsZTxTdHJpbmc+IG1hcHBlZCA9IEl0ZXJhYmxlRXh0ZW5zaW9ucworCQkJCQkuPFF1YWxpZmllZE5hbWUsIFN0cmluZz4gbWFwKGltcG9ydGVkTmFtZXMsCisJCQkJCQkJbmV3IEZ1bmN0aW9ucy5GdW5jdGlvbjE8UXVhbGlmaWVkTmFtZSwgU3RyaW5nPigpIHsKKwkJCQkJCQkJQE92ZXJyaWRlCisJCQkJCQkJCXB1YmxpYyBTdHJpbmcgYXBwbHkoUXVhbGlmaWVkTmFtZSBpbnB1dCkgeworCQkJCQkJCQkJcmV0dXJuICIgLSAiICsgaW5wdXQudG9TdHJpbmcoKTsKKwkJCQkJCQkJfQorCQkJCQkJCX0pOworCQkJdGhpcy5pbXBvcnRlZE5hbWVzID0gSXRlcmFibGVFeHRlbnNpb25zLnRvTGlzdChtYXBwZWQpOworCQl9CisJfQorCisJcHJpdmF0ZSBzdGF0aWMgY2xhc3MgUmVmZXJlbmNlRGVzY3JpcHRpb25zIHsKKworCQlwcml2YXRlIExpc3Q8SVJlZmVyZW5jZURlc2NyaXB0aW9uPiByZWZEZXNjczsKKworCQlwdWJsaWMgUmVmZXJlbmNlRGVzY3JpcHRpb25zKAorCQkJCUl0ZXJhYmxlPElSZWZlcmVuY2VEZXNjcmlwdGlvbj4gcmVmZXJlbmNlRGVzY3JpcHRpb25zKSB7CisJCQlyZWZEZXNjcyA9IEl0ZXJhYmxlRXh0ZW5zaW9ucy50b0xpc3QocmVmZXJlbmNlRGVzY3JpcHRpb25zKTsKKwkJfQorCX0KKworCXByaXZhdGUgc3RhdGljIGNsYXNzIEVudHJ5IHsKKwkJcHJpdmF0ZSBTdHJpbmcga2V5OworCQlwcml2YXRlIFN0cmluZyB2YWx1ZTsKKworCQlwdWJsaWMgRW50cnkoU3RyaW5nIGtleSwgU3RyaW5nIHZhbHVlKSB7CisJCQl0aGlzLmtleSA9IGtleTsKKwkJCXRoaXMudmFsdWUgPSB2YWx1ZTsKKwkJfQorCX0KK30KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLy5wcm9qZWN0IGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS8ucHJvamVjdApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44ZTRkMjY3Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS8ucHJvamVjdApAQCAtMCwwICsxLDUxIEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPHByb2plY3REZXNjcmlwdGlvbj4KKwk8bmFtZT5vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlPC9uYW1lPgorCTxjb21tZW50PjwvY29tbWVudD4KKwk8cHJvamVjdHM+CisJPC9wcm9qZWN0cz4KKwk8YnVpbGRTcGVjPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UueHRleHQudWkuc2hhcmVkLnh0ZXh0QnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5qZHQuY29yZS5qYXZhYnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuTWFuaWZlc3RCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5TY2hlbWFCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLmJhYmVsLmVkaXRvci5yYmVCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5zb25hcmxpbnQuZWNsaXBzZS5jb3JlLnNvbmFybGludEJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UubTJlLmNvcmUubWF2ZW4yQnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJPC9idWlsZFNwZWM+CisJPG5hdHVyZXM+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UueHRleHQudWkuc2hhcmVkLnh0ZXh0TmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UubTJlLmNvcmUubWF2ZW4yTmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UucGRlLlBsdWdpbk5hdHVyZTwvbmF0dXJlPgorCQk8bmF0dXJlPm9yZy5lY2xpcHNlLmpkdC5jb3JlLmphdmFuYXR1cmU8L25hdHVyZT4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS5iYWJlbC5lZGl0b3IucmJlTmF0dXJlPC9uYXR1cmU+CisJPC9uYXR1cmVzPgorPC9wcm9qZWN0RGVzY3JpcHRpb24+CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL0xJQ0VOU0UudHh0IGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS9MSUNFTlNFLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mZjQyYWQ0Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS9MSUNFTlNFLnR4dApAQCAtMCwwICsxLDE2MSBAQAorRWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtdiAxLjAKKworVEhFIEFDQ09NUEFOWUlORyBQUk9HUkFNIElTIFBST1ZJREVEIFVOREVSIFRIRSBURVJNUyBPRiBUSElTIEVDTElQU0UgUFVCTElDIExJQ0VOU0UgKCJBR1JFRU1FTlQiKS4gQU5ZIFVTRSwgUkVQUk9EVUNUSU9OCitPUiBESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gQ09OU1RJVFVURVMgUkVDSVBJRU5UJ1MgQUNDRVBUQU5DRSBPRiBUSElTIEFHUkVFTUVOVC4KKworMS4gREVGSU5JVElPTlMKKworIkNvbnRyaWJ1dGlvbiIgbWVhbnM6CisKK2EpIGluIHRoZSBjYXNlIG9mIHRoZSBpbml0aWFsIENvbnRyaWJ1dG9yLCB0aGUgaW5pdGlhbCBjb2RlIGFuZCBkb2N1bWVudGF0aW9uIGRpc3RyaWJ1dGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBhbmQKKworYikgaW4gdGhlIGNhc2Ugb2YgZWFjaCBzdWJzZXF1ZW50IENvbnRyaWJ1dG9yOgorCitpKSBjaGFuZ2VzIHRvIHRoZSBQcm9ncmFtLCBhbmQKKworaWkpIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbTsKKword2hlcmUgc3VjaCBjaGFuZ2VzIGFuZC9vciBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gb3JpZ2luYXRlIGZyb20gYW5kIGFyZSBkaXN0cmlidXRlZCBieSB0aGF0IHBhcnRpY3VsYXIgQ29udHJpYnV0b3IuCitBIENvbnRyaWJ1dGlvbiAnb3JpZ2luYXRlcycgZnJvbSBhIENvbnRyaWJ1dG9yIGlmIGl0IHdhcyBhZGRlZCB0byB0aGUgUHJvZ3JhbSBieSBzdWNoIENvbnRyaWJ1dG9yIGl0c2VsZiBvciBhbnlvbmUKK2FjdGluZyBvbiBzdWNoIENvbnRyaWJ1dG9yJ3MgYmVoYWxmLiBDb250cmlidXRpb25zIGRvIG5vdCBpbmNsdWRlIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbSB3aGljaDogKGkpIGFyZSBzZXBhcmF0ZQorbW9kdWxlcyBvZiBzb2Z0d2FyZSBkaXN0cmlidXRlZCBpbiBjb25qdW5jdGlvbiB3aXRoIHRoZSBQcm9ncmFtIHVuZGVyIHRoZWlyIG93biBsaWNlbnNlIGFncmVlbWVudCwgYW5kIChpaSkgYXJlIG5vdAorZGVyaXZhdGl2ZSB3b3JrcyBvZiB0aGUgUHJvZ3JhbS4KKworIkNvbnRyaWJ1dG9yIiBtZWFucyBhbnkgcGVyc29uIG9yIGVudGl0eSB0aGF0IGRpc3RyaWJ1dGVzIHRoZSBQcm9ncmFtLgorCisiTGljZW5zZWQgUGF0ZW50cyAiIG1lYW4gcGF0ZW50IGNsYWltcyBsaWNlbnNhYmxlIGJ5IGEgQ29udHJpYnV0b3Igd2hpY2ggYXJlIG5lY2Vzc2FyaWx5IGluZnJpbmdlZCBieSB0aGUgdXNlIG9yIHNhbGUgb2YKK2l0cyBDb250cmlidXRpb24gYWxvbmUgb3Igd2hlbiBjb21iaW5lZCB3aXRoIHRoZSBQcm9ncmFtLgorCisiUHJvZ3JhbSIgbWVhbnMgdGhlIENvbnRyaWJ1dGlvbnMgZGlzdHJpYnV0ZWQgaW4gYWNjb3JkYW5jZSB3aXRoIHRoaXMgQWdyZWVtZW50LgorCisiUmVjaXBpZW50IiBtZWFucyBhbnlvbmUgd2hvIHJlY2VpdmVzIHRoZSBQcm9ncmFtIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBpbmNsdWRpbmcgYWxsIENvbnRyaWJ1dG9ycy4KKworMi4gR1JBTlQgT0YgUklHSFRTCisKK2EpIFN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLAorcm95YWx0eS1mcmVlIGNvcHlyaWdodCBsaWNlbnNlIHRvIHJlcHJvZHVjZSwgcHJlcGFyZSBkZXJpdmF0aXZlIHdvcmtzIG9mLCBwdWJsaWNseSBkaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBkaXN0cmlidXRlCithbmQgc3VibGljZW5zZSB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgYW5kIHN1Y2ggZGVyaXZhdGl2ZSB3b3JrcywgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlCitmb3JtLgorCitiKSBTdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwKK3JveWFsdHktZnJlZSBwYXRlbnQgbGljZW5zZSB1bmRlciBMaWNlbnNlZCBQYXRlbnRzIHRvIG1ha2UsIHVzZSwgc2VsbCwgb2ZmZXIgdG8gc2VsbCwgaW1wb3J0IGFuZCBvdGhlcndpc2UgdHJhbnNmZXIgdGhlCitDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUgZm9ybS4gVGhpcyBwYXRlbnQgbGljZW5zZSBzaGFsbCBhcHBseSB0byB0aGUKK2NvbWJpbmF0aW9uIG9mIHRoZSBDb250cmlidXRpb24gYW5kIHRoZSBQcm9ncmFtIGlmLCBhdCB0aGUgdGltZSB0aGUgQ29udHJpYnV0aW9uIGlzIGFkZGVkIGJ5IHRoZSBDb250cmlidXRvciwgc3VjaAorYWRkaXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBjYXVzZXMgc3VjaCBjb21iaW5hdGlvbiB0byBiZSBjb3ZlcmVkIGJ5IHRoZSBMaWNlbnNlZCBQYXRlbnRzLiBUaGUgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgbm90CithcHBseSB0byBhbnkgb3RoZXIgY29tYmluYXRpb25zIHdoaWNoIGluY2x1ZGUgdGhlIENvbnRyaWJ1dGlvbi4gTm8gaGFyZHdhcmUgcGVyIHNlIGlzIGxpY2Vuc2VkIGhlcmV1bmRlci4KKworYykgUmVjaXBpZW50IHVuZGVyc3RhbmRzIHRoYXQgYWx0aG91Z2ggZWFjaCBDb250cmlidXRvciBncmFudHMgdGhlIGxpY2Vuc2VzIHRvIGl0cyBDb250cmlidXRpb25zIHNldCBmb3J0aCBoZXJlaW4sIG5vCithc3N1cmFuY2VzIGFyZSBwcm92aWRlZCBieSBhbnkgQ29udHJpYnV0b3IgdGhhdCB0aGUgUHJvZ3JhbSBkb2VzIG5vdCBpbmZyaW5nZSB0aGUgcGF0ZW50IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQorcmlnaHRzIG9mIGFueSBvdGhlciBlbnRpdHkuIEVhY2ggQ29udHJpYnV0b3IgZGlzY2xhaW1zIGFueSBsaWFiaWxpdHkgdG8gUmVjaXBpZW50IGZvciBjbGFpbXMgYnJvdWdodCBieSBhbnkgb3RoZXIgZW50aXR5CitiYXNlZCBvbiBpbmZyaW5nZW1lbnQgb2YgaW50ZWxsZWN0dWFsIHByb3BlcnR5IHJpZ2h0cyBvciBvdGhlcndpc2UuIEFzIGEgY29uZGl0aW9uIHRvIGV4ZXJjaXNpbmcgdGhlIHJpZ2h0cyBhbmQKK2xpY2Vuc2VzIGdyYW50ZWQgaGVyZXVuZGVyLCBlYWNoIFJlY2lwaWVudCBoZXJlYnkgYXNzdW1lcyBzb2xlIHJlc3BvbnNpYmlsaXR5IHRvIHNlY3VyZSBhbnkgb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5CityaWdodHMgbmVlZGVkLCBpZiBhbnkuIEZvciBleGFtcGxlLCBpZiBhIHRoaXJkIHBhcnR5IHBhdGVudCBsaWNlbnNlIGlzIHJlcXVpcmVkIHRvIGFsbG93IFJlY2lwaWVudCB0byBkaXN0cmlidXRlIHRoZQorUHJvZ3JhbSwgaXQgaXMgUmVjaXBpZW50J3MgcmVzcG9uc2liaWxpdHkgdG8gYWNxdWlyZSB0aGF0IGxpY2Vuc2UgYmVmb3JlIGRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbS4KKworZCkgRWFjaCBDb250cmlidXRvciByZXByZXNlbnRzIHRoYXQgdG8gaXRzIGtub3dsZWRnZSBpdCBoYXMgc3VmZmljaWVudCBjb3B5cmlnaHQgcmlnaHRzIGluIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgdG8KK2dyYW50IHRoZSBjb3B5cmlnaHQgbGljZW5zZSBzZXQgZm9ydGggaW4gdGhpcyBBZ3JlZW1lbnQuCisKKzMuIFJFUVVJUkVNRU5UUworCitBIENvbnRyaWJ1dG9yIG1heSBjaG9vc2UgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbSBpbiBvYmplY3QgY29kZSBmb3JtIHVuZGVyIGl0cyBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIHByb3ZpZGVkIHRoYXQ6CisKK2EpIGl0IGNvbXBsaWVzIHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50OyBhbmQKKworYikgaXRzIGxpY2Vuc2UgYWdyZWVtZW50OgorCitpKSBlZmZlY3RpdmVseSBkaXNjbGFpbXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIHdhcnJhbnRpZXMgYW5kIGNvbmRpdGlvbnMsIGV4cHJlc3MgYW5kIGltcGxpZWQsIGluY2x1ZGluZword2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIHRpdGxlIGFuZCBub24taW5mcmluZ2VtZW50LCBhbmQgaW1wbGllZCB3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgbWVyY2hhbnRhYmlsaXR5IGFuZAorZml0bmVzcyBmb3IgYSBwYXJ0aWN1bGFyIHB1cnBvc2U7CisKK2lpKSBlZmZlY3RpdmVseSBleGNsdWRlcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgbGlhYmlsaXR5IGZvciBkYW1hZ2VzLCBpbmNsdWRpbmcgZGlyZWN0LCBpbmRpcmVjdCwgc3BlY2lhbCwKK2luY2lkZW50YWwgYW5kIGNvbnNlcXVlbnRpYWwgZGFtYWdlcywgc3VjaCBhcyBsb3N0IHByb2ZpdHM7CisKK2lpaSkgc3RhdGVzIHRoYXQgYW55IHByb3Zpc2lvbnMgd2hpY2ggZGlmZmVyIGZyb20gdGhpcyBBZ3JlZW1lbnQgYXJlIG9mZmVyZWQgYnkgdGhhdCBDb250cmlidXRvciBhbG9uZSBhbmQgbm90IGJ5IGFueQorb3RoZXIgcGFydHk7IGFuZAorCitpdikgc3RhdGVzIHRoYXQgc291cmNlIGNvZGUgZm9yIHRoZSBQcm9ncmFtIGlzIGF2YWlsYWJsZSBmcm9tIHN1Y2ggQ29udHJpYnV0b3IsIGFuZCBpbmZvcm1zIGxpY2Vuc2VlcyBob3cgdG8gb2J0YWluIGl0CitpbiBhIHJlYXNvbmFibGUgbWFubmVyIG9uIG9yIHRocm91Z2ggYSBtZWRpdW0gY3VzdG9tYXJpbHkgdXNlZCBmb3Igc29mdHdhcmUgZXhjaGFuZ2UuCisKK1doZW4gdGhlIFByb2dyYW0gaXMgbWFkZSBhdmFpbGFibGUgaW4gc291cmNlIGNvZGUgZm9ybToKKworYSkgaXQgbXVzdCBiZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGlzIEFncmVlbWVudDsgYW5kCisKK2IpIGEgY29weSBvZiB0aGlzIEFncmVlbWVudCBtdXN0IGJlIGluY2x1ZGVkIHdpdGggZWFjaCBjb3B5IG9mIHRoZSBQcm9ncmFtLgorCitDb250cmlidXRvcnMgbWF5IG5vdCByZW1vdmUgb3IgYWx0ZXIgYW55IGNvcHlyaWdodCBub3RpY2VzIGNvbnRhaW5lZCB3aXRoaW4gdGhlIFByb2dyYW0uCisKK0VhY2ggQ29udHJpYnV0b3IgbXVzdCBpZGVudGlmeSBpdHNlbGYgYXMgdGhlIG9yaWdpbmF0b3Igb2YgaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCBpbiBhIG1hbm5lciB0aGF0IHJlYXNvbmFibHkgYWxsb3dzCitzdWJzZXF1ZW50IFJlY2lwaWVudHMgdG8gaWRlbnRpZnkgdGhlIG9yaWdpbmF0b3Igb2YgdGhlIENvbnRyaWJ1dGlvbi4KKworNC4gQ09NTUVSQ0lBTCBESVNUUklCVVRJT04KKworQ29tbWVyY2lhbCBkaXN0cmlidXRvcnMgb2Ygc29mdHdhcmUgbWF5IGFjY2VwdCBjZXJ0YWluIHJlc3BvbnNpYmlsaXRpZXMgd2l0aCByZXNwZWN0IHRvIGVuZCB1c2VycywgYnVzaW5lc3MgcGFydG5lcnMgYW5kCit0aGUgbGlrZS4gV2hpbGUgdGhpcyBsaWNlbnNlIGlzIGludGVuZGVkIHRvIGZhY2lsaXRhdGUgdGhlIGNvbW1lcmNpYWwgdXNlIG9mIHRoZSBQcm9ncmFtLCB0aGUgQ29udHJpYnV0b3Igd2hvIGluY2x1ZGVzCit0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZyBzaG91bGQgZG8gc28gaW4gYSBtYW5uZXIgd2hpY2ggZG9lcyBub3QgY3JlYXRlIHBvdGVudGlhbCBsaWFiaWxpdHkgZm9yCitvdGhlciBDb250cmlidXRvcnMuIFRoZXJlZm9yZSwgaWYgYSBDb250cmlidXRvciBpbmNsdWRlcyB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgc3VjaCBDb250cmlidXRvcgorKCJDb21tZXJjaWFsIENvbnRyaWJ1dG9yIikgaGVyZWJ5IGFncmVlcyB0byBkZWZlbmQgYW5kIGluZGVtbmlmeSBldmVyeSBvdGhlciBDb250cmlidXRvciAoIkluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIikKK2FnYWluc3QgYW55IGxvc3NlcywgZGFtYWdlcyBhbmQgY29zdHMgKGNvbGxlY3RpdmVseSAiTG9zc2VzIikgYXJpc2luZyBmcm9tIGNsYWltcywgbGF3c3VpdHMgYW5kIG90aGVyIGxlZ2FsIGFjdGlvbnMKK2Jyb3VnaHQgYnkgYSB0aGlyZCBwYXJ0eSBhZ2FpbnN0IHRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciB0byB0aGUgZXh0ZW50IGNhdXNlZCBieSB0aGUgYWN0cyBvciBvbWlzc2lvbnMgb2Ygc3VjaAorQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiBjb25uZWN0aW9uIHdpdGggaXRzIGRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZy4gVGhlCitvYmxpZ2F0aW9ucyBpbiB0aGlzIHNlY3Rpb24gZG8gbm90IGFwcGx5IHRvIGFueSBjbGFpbXMgb3IgTG9zc2VzIHJlbGF0aW5nIHRvIGFueSBhY3R1YWwgb3IgYWxsZWdlZCBpbnRlbGxlY3R1YWwKK3Byb3BlcnR5IGluZnJpbmdlbWVudC4gSW4gb3JkZXIgdG8gcXVhbGlmeSwgYW4gSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbXVzdDogYSkgcHJvbXB0bHkgbm90aWZ5IHRoZSBDb21tZXJjaWFsCitDb250cmlidXRvciBpbiB3cml0aW5nIG9mIHN1Y2ggY2xhaW0sIGFuZCBiKSBhbGxvdyB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB0byBjb250cm9sLCBhbmQgY29vcGVyYXRlIHdpdGggdGhlCitDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluLCB0aGUgZGVmZW5zZSBhbmQgYW55IHJlbGF0ZWQgc2V0dGxlbWVudCBuZWdvdGlhdGlvbnMuIFRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciBtYXkKKyBwYXJ0aWNpcGF0ZSBpbiBhbnkgc3VjaCBjbGFpbSBhdCBpdHMgb3duIGV4cGVuc2UuCisKK0ZvciBleGFtcGxlLCBhIENvbnRyaWJ1dG9yIG1pZ2h0IGluY2x1ZGUgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIFByb2R1Y3QgWC4gVGhhdCBDb250cmlidXRvciBpcwordGhlbiBhIENvbW1lcmNpYWwgQ29udHJpYnV0b3IuIElmIHRoYXQgQ29tbWVyY2lhbCBDb250cmlidXRvciB0aGVuIG1ha2VzIHBlcmZvcm1hbmNlIGNsYWltcywgb3Igb2ZmZXJzIHdhcnJhbnRpZXMKK3JlbGF0ZWQgdG8gUHJvZHVjdCBYLCB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMgYXJlIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvcidzIHJlc3BvbnNpYmlsaXR5IGFsb25lLgorVW5kZXIgdGhpcyBzZWN0aW9uLCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB3b3VsZCBoYXZlIHRvIGRlZmVuZCBjbGFpbXMgYWdhaW5zdCB0aGUgb3RoZXIgQ29udHJpYnV0b3JzIHJlbGF0ZWQgdG8KK3Rob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcywgYW5kIGlmIGEgY291cnQgcmVxdWlyZXMgYW55IG90aGVyIENvbnRyaWJ1dG9yIHRvIHBheSBhbnkgZGFtYWdlcyBhcyBhIHJlc3VsdCwKK3RoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIG11c3QgcGF5IHRob3NlIGRhbWFnZXMuCisKKzUuIE5PIFdBUlJBTlRZCisKK0VYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMgQUdSRUVNRU5ULCBUSEUgUFJPR1JBTSBJUyBQUk9WSURFRCBPTiBBTiAiQVMgSVMiIEJBU0lTLCBXSVRIT1VUIFdBUlJBTlRJRVMgT1IKK0NPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIEVJVEhFUiBFWFBSRVNTIE9SIElNUExJRUQgSU5DTFVESU5HLCBXSVRIT1VUIExJTUlUQVRJT04sIEFOWSBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgVElUTEUsCitOT04tSU5GUklOR0VNRU5ULCBNRVJDSEFOVEFCSUxJVFkgT1IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIEVhY2ggUmVjaXBpZW50IGlzIHNvbGVseSByZXNwb25zaWJsZSBmb3IKK2RldGVybWluaW5nIHRoZSBhcHByb3ByaWF0ZW5lc3Mgb2YgdXNpbmcgYW5kIGRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbSBhbmQgYXNzdW1lcyBhbGwgcmlza3MgYXNzb2NpYXRlZCB3aXRoIGl0cworZXhlcmNpc2Ugb2YgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50ICwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgcmlza3MgYW5kIGNvc3RzIG9mIHByb2dyYW0gZXJyb3JzLCBjb21wbGlhbmNlCit3aXRoIGFwcGxpY2FibGUgbGF3cywgZGFtYWdlIHRvIG9yIGxvc3Mgb2YgZGF0YSwgcHJvZ3JhbXMgb3IgZXF1aXBtZW50LCBhbmQgdW5hdmFpbGFiaWxpdHkgb3IgaW50ZXJydXB0aW9uIG9mIG9wZXJhdGlvbnMuCisKKzYuIERJU0NMQUlNRVIgT0YgTElBQklMSVRZCisKK0VYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMgQUdSRUVNRU5ULCBORUlUSEVSIFJFQ0lQSUVOVCBOT1IgQU5ZIENPTlRSSUJVVE9SUyBTSEFMTCBIQVZFIEFOWSBMSUFCSUxJVFkgRk9SIEFOWQorRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORyBXSVRIT1VUIExJTUlUQVRJT04gTE9TVCBQUk9GSVRTKSwKK0hPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IKK09USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBPUiBUSEUgRVhFUkNJU0UgT0YgQU5ZIFJJR0hUUyBHUkFOVEVECitIRVJFVU5ERVIsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0VTLgorCis3LiBHRU5FUkFMCisKK0lmIGFueSBwcm92aXNpb24gb2YgdGhpcyBBZ3JlZW1lbnQgaXMgaW52YWxpZCBvciB1bmVuZm9yY2VhYmxlIHVuZGVyIGFwcGxpY2FibGUgbGF3LCBpdCBzaGFsbCBub3QgYWZmZWN0IHRoZSB2YWxpZGl0eSBvcgorZW5mb3JjZWFiaWxpdHkgb2YgdGhlIHJlbWFpbmRlciBvZiB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGFuZCB3aXRob3V0IGZ1cnRoZXIgYWN0aW9uIGJ5IHRoZSBwYXJ0aWVzIGhlcmV0bywgc3VjaAorcHJvdmlzaW9uIHNoYWxsIGJlIHJlZm9ybWVkIHRvIHRoZSBtaW5pbXVtIGV4dGVudCBuZWNlc3NhcnkgdG8gbWFrZSBzdWNoIHByb3Zpc2lvbiB2YWxpZCBhbmQgZW5mb3JjZWFibGUuCisKK0lmIFJlY2lwaWVudCBpbnN0aXR1dGVzIHBhdGVudCBsaXRpZ2F0aW9uIGFnYWluc3QgYW55IGVudGl0eSAoaW5jbHVkaW5nIGEgY3Jvc3MtY2xhaW0gb3IgY291bnRlcmNsYWltIGluIGEgbGF3c3VpdCkKK2FsbGVnaW5nIHRoYXQgdGhlIFByb2dyYW0gaXRzZWxmIChleGNsdWRpbmcgY29tYmluYXRpb25zIG9mIHRoZSBQcm9ncmFtIHdpdGggb3RoZXIgc29mdHdhcmUgb3IgaGFyZHdhcmUpIGluZnJpbmdlcyBzdWNoCitSZWNpcGllbnQncyBwYXRlbnQocyksIHRoZW4gc3VjaCBSZWNpcGllbnQncyByaWdodHMgZ3JhbnRlZCB1bmRlciBTZWN0aW9uIDIoYikgc2hhbGwgdGVybWluYXRlIGFzIG9mIHRoZSBkYXRlIHN1Y2gKK2xpdGlnYXRpb24gaXMgZmlsZWQuCisKK0FsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgc2hhbGwgdGVybWluYXRlIGlmIGl0IGZhaWxzIHRvIGNvbXBseSB3aXRoIGFueSBvZiB0aGUgbWF0ZXJpYWwgdGVybXMgb3IKK2NvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQgYW5kIGRvZXMgbm90IGN1cmUgc3VjaCBmYWlsdXJlIGluIGEgcmVhc29uYWJsZSBwZXJpb2Qgb2YgdGltZSBhZnRlciBiZWNvbWluZyBhd2FyZSBvZiBzdWNoCitub25jb21wbGlhbmNlLiBJZiBhbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHRlcm1pbmF0ZSwgUmVjaXBpZW50IGFncmVlcyB0byBjZWFzZSB1c2UgYW5kIGRpc3RyaWJ1dGlvbgorb2YgdGhlIFByb2dyYW0gYXMgc29vbiBhcyByZWFzb25hYmx5IHByYWN0aWNhYmxlLiBIb3dldmVyLCBSZWNpcGllbnQncyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIEFncmVlbWVudCBhbmQgYW55IGxpY2Vuc2VzCisgZ3JhbnRlZCBieSBSZWNpcGllbnQgcmVsYXRpbmcgdG8gdGhlIFByb2dyYW0gc2hhbGwgY29udGludWUgYW5kIHN1cnZpdmUuCisKK0V2ZXJ5b25lIGlzIHBlcm1pdHRlZCB0byBjb3B5IGFuZCBkaXN0cmlidXRlIGNvcGllcyBvZiB0aGlzIEFncmVlbWVudCwgYnV0IGluIG9yZGVyIHRvIGF2b2lkIGluY29uc2lzdGVuY3kgdGhlIEFncmVlbWVudAoraXMgY29weXJpZ2h0ZWQgYW5kIG1heSBvbmx5IGJlIG1vZGlmaWVkIGluIHRoZSBmb2xsb3dpbmcgbWFubmVyLiBUaGUgQWdyZWVtZW50IFN0ZXdhcmQgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHB1Ymxpc2gKK25ldyB2ZXJzaW9ucyAoaW5jbHVkaW5nIHJldmlzaW9ucykgb2YgdGhpcyBBZ3JlZW1lbnQgZnJvbSB0aW1lIHRvIHRpbWUuIE5vIG9uZSBvdGhlciB0aGFuIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCBoYXMgdGhlCityaWdodCB0byBtb2RpZnkgdGhpcyBBZ3JlZW1lbnQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgdGhlIGluaXRpYWwgQWdyZWVtZW50IFN0ZXdhcmQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWF5Cithc3NpZ24gdGhlIHJlc3BvbnNpYmlsaXR5IHRvIHNlcnZlIGFzIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCB0byBhIHN1aXRhYmxlIHNlcGFyYXRlIGVudGl0eS4gRWFjaCBuZXcgdmVyc2lvbiBvZiB0aGUKK0FncmVlbWVudCB3aWxsIGJlIGdpdmVuIGEgZGlzdGluZ3Vpc2hpbmcgdmVyc2lvbiBudW1iZXIuIFRoZSBQcm9ncmFtIChpbmNsdWRpbmcgQ29udHJpYnV0aW9ucykgbWF5IGFsd2F5cyBiZQorZGlzdHJpYnV0ZWQgc3ViamVjdCB0byB0aGUgdmVyc2lvbiBvZiB0aGUgQWdyZWVtZW50IHVuZGVyIHdoaWNoIGl0IHdhcyByZWNlaXZlZC4gSW4gYWRkaXRpb24sIGFmdGVyIGEgbmV3IHZlcnNpb24gb2YKK3RoZSBBZ3JlZW1lbnQgaXMgcHVibGlzaGVkLCBDb250cmlidXRvciBtYXkgZWxlY3QgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbSAoaW5jbHVkaW5nIGl0cyBDb250cmlidXRpb25zKSB1bmRlciB0aGUKK25ldyB2ZXJzaW9uLiBFeGNlcHQgYXMgZXhwcmVzc2x5IHN0YXRlZCBpbiBTZWN0aW9ucyAyKGEpIGFuZCAyKGIpIGFib3ZlLCBSZWNpcGllbnQgcmVjZWl2ZXMgbm8gcmlnaHRzIG9yIGxpY2Vuc2VzIHRvCit0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IG9mIGFueSBDb250cmlidXRvciB1bmRlciB0aGlzIEFncmVlbWVudCwgd2hldGhlciBleHByZXNzbHksIGJ5IGltcGxpY2F0aW9uLCBlc3RvcHBlbCBvcgorb3RoZXJ3aXNlLiBBbGwgcmlnaHRzIGluIHRoZSBQcm9ncmFtIG5vdCBleHByZXNzbHkgZ3JhbnRlZCB1bmRlciB0aGlzIEFncmVlbWVudCBhcmUgcmVzZXJ2ZWQuCisKK1RoaXMgQWdyZWVtZW50IGlzIGdvdmVybmVkIGJ5IHRoZSBsYXdzIG9mIHRoZSBTdGF0ZSBvZiBOZXcgWW9yayBhbmQgdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBsYXdzIG9mIHRoZSBVbml0ZWQgU3RhdGVzCitvZiBBbWVyaWNhLiBObyBwYXJ0eSB0byB0aGlzIEFncmVlbWVudCB3aWxsIGJyaW5nIGEgbGVnYWwgYWN0aW9uIHVuZGVyIHRoaXMgQWdyZWVtZW50IG1vcmUgdGhhbiBvbmUgeWVhciBhZnRlciB0aGUgY2F1c2UKK29mIGFjdGlvbiBhcm9zZS4gRWFjaCBwYXJ0eSB3YWl2ZXMgaXRzIHJpZ2h0cyB0byBhIGp1cnkgdHJpYWwgaW4gYW55IHJlc3VsdGluZyBsaXRpZ2F0aW9uLgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUvTUVUQS1JTkYvTUFOSUZFU1QuTUYgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL01FVEEtSU5GL01BTklGRVNULk1GCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjJiM2EyYzgKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL01FVEEtSU5GL01BTklGRVNULk1GCkBAIC0wLDAgKzEsMjEgQEAKK01hbmlmZXN0LVZlcnNpb246IDEuMAorQnVuZGxlLU1hbmlmZXN0VmVyc2lvbjogMgorQnVuZGxlLU5hbWU6IG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUKK0J1bmRsZS1TeW1ib2xpY05hbWU6IG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmU7c2luZ2xldG9uOj10cnVlCitCdW5kbGUtVmVyc2lvbjogMC45LjAucXVhbGlmaWVyCitCdW5kbGUtQWN0aXZhdG9yOiBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLkFjdGl2YXRvcgorQnVuZGxlLVZlbmRvcjogRWNsaXBzZSBPU0JQCitCdW5kbGUtUmVxdWlyZWRFeGVjdXRpb25FbnZpcm9ubWVudDogSmF2YVNFLTEuNworSW1wb3J0LVBhY2thZ2U6IG9yZy5vc2dpLmZyYW1ld29yazt2ZXJzaW9uPSIxLjMuMCIsCisgb3JnLnNsZjRqO3ZlcnNpb249IjEuNy4yIgorQnVuZGxlLUFjdGl2YXRpb25Qb2xpY3k6IGxhenkKK1JlcXVpcmUtQnVuZGxlOiBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcztidW5kbGUtdmVyc2lvbj0iMy45LjAiLAorIG9yZy5lY2xpcHNlLmNvcmUucnVudGltZTtidW5kbGUtdmVyc2lvbj0iMy4xMC4wIiwKKyBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaTtidW5kbGUtdmVyc2lvbj0iWzAuOS4wLDAuMTAuMCkiLAorIGNvbS5nb29nbGUuaW5qZWN0O2J1bmRsZS12ZXJzaW9uPSIzLjAuMCIKK0V4cG9ydC1QYWNrYWdlOiBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlOworICB1c2VzOj0ib3JnLm9zZ2kuZnJhbWV3b3JrIjt2ZXJzaW9uPSIwLjkuMCIsCisgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5pMThuOworICB1c2VzOj0ib3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLAorICAgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMsCisgICBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaS5pMThuIjt2ZXJzaW9uPSIwLjkuMCIKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUvYWJvdXQuaHRtbCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUvYWJvdXQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NGMwNTk4Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS9hYm91dC5odG1sCkBAIC0wLDAgKzEsMjggQEAKKzwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFN0cmljdC8vRU4iCisgICAgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXN0cmljdC5kdGQiPgorPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiPgorPGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1JU08tODg1OS0xIi8+Cis8dGl0bGU+QWJvdXQ8L3RpdGxlPgorPC9oZWFkPgorPGJvZHkgbGFuZz0iRU4tVVMiPgorPGgyPkFib3V0IFRoaXMgQ29udGVudDwvaDI+CisgCis8cD5KdW5lIDEsIDIwMTY8L3A+CQorPGgzPkxpY2Vuc2U8L2gzPgorCis8cD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBhbGwgY29udGVudCBpbiB0aGlzIHBsdWctaW4gKCZxdW90O0NvbnRlbnQmcXVvdDspLiAgVW5sZXNzIG90aGVyd2lzZSAKK2luZGljYXRlZCBiZWxvdywgdGhlIENvbnRlbnQgaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUKK0VjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKCZxdW90O0VQTCZxdW90OykuICBBIGNvcHkgb2YgdGhlIEVQTCBpcyBhdmFpbGFibGUgCithdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L2E+LgorRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICZxdW90O1Byb2dyYW0mcXVvdDsgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvcD4KKworPHA+SWYgeW91IGRpZCBub3QgcmVjZWl2ZSB0aGlzIENvbnRlbnQgZGlyZWN0bHkgZnJvbSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uLCB0aGUgQ29udGVudCBpcyAKK2JlaW5nIHJlZGlzdHJpYnV0ZWQgYnkgYW5vdGhlciBwYXJ0eSAoJnF1b3Q7UmVkaXN0cmlidXRvciZxdW90OykgYW5kIGRpZmZlcmVudCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBtYXkKK2FwcGx5IHRvIHlvdXIgdXNlIG9mIGFueSBvYmplY3QgY29kZSBpbiB0aGUgQ29udGVudC4gIENoZWNrIHRoZSBSZWRpc3RyaWJ1dG9yJ3MgbGljZW5zZSB0aGF0IHdhcyAKK3Byb3ZpZGVkIHdpdGggdGhlIENvbnRlbnQuICBJZiBubyBzdWNoIGxpY2Vuc2UgZXhpc3RzLCBjb250YWN0IHRoZSBSZWRpc3RyaWJ1dG9yLiAgVW5sZXNzIG90aGVyd2lzZQoraW5kaWNhdGVkIGJlbG93LCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVQTCBzdGlsbCBhcHBseSB0byBhbnkgc291cmNlIGNvZGUgaW4gdGhlIENvbnRlbnQKK2FuZCBzdWNoIHNvdXJjZSBjb2RlIG1heSBiZSBvYnRhaW5lZCBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnLyI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZzwvYT4uPC9wPgorCis8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS9hYm91dC5pbmkgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL2Fib3V0LmluaQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43ZGY2NzFmCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS9hYm91dC5pbmkKQEAgLTAsMCArMSwxNyBAQAorIyBhYm91dC5pbmkKKyMgY29udGFpbnMgaW5mb3JtYXRpb24gYWJvdXQgYSBmZWF0dXJlCisjIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCisjICIla2V5IiBhcmUgZXh0ZXJuYWxpemVkIHN0cmluZ3MgZGVmaW5lZCBpbiBhYm91dC5wcm9wZXJ0aWVzCisjIFRoaXMgZmlsZSBkb2VzIG5vdCBuZWVkIHRvIGJlIHRyYW5zbGF0ZWQuCisKKyMgUHJvcGVydHkgImFib3V0VGV4dCIgY29udGFpbnMgYmx1cmIgZm9yICJBYm91dCIgZGlhbG9nICh0cmFuc2xhdGVkKQorYWJvdXRUZXh0PSVmZWF0dXJlVGV4dAorCisjIFByb3BlcnR5ICJmZWF0dXJlSW1hZ2UiIGNvbnRhaW5zIHBhdGggdG8gZmVhdHVyZSBpbWFnZSAoMzJ4MzIpCitmZWF0dXJlSW1hZ2U9CisKKyMgUHJvcGVydHkgImFwcE5hbWUiIGNvbnRhaW5zIG5hbWUgb2YgdGhlIGFwcGxpY2F0aW9uICh0cmFuc2xhdGVkKQorYXBwTmFtZT0lZmVhdHVyZU5hbWUKKworIyBQcm9wZXJ0eSAid2VsY29tZVBhZ2UiIGNvbnRhaW5zIHBhdGggdG8gd2VsY29tZSBwYWdlIChzcGVjaWFsIFhNTC1iYXNlZCBmb3JtYXQpCit3ZWxjb21lUGFnZT0KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUvYWJvdXQubWFwcGluZ3MgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL2Fib3V0Lm1hcHBpbmdzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQ1MTFhMGEKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL2Fib3V0Lm1hcHBpbmdzCkBAIC0wLDAgKzEsNiBAQAorIyBhYm91dC5tYXBwaW5ncworIyBjb250YWlucyBmaWxsLWlucyBmb3IgYWJvdXQucHJvcGVydGllcworIyBqYXZhLmlvLlByb3BlcnRpZXMgZmlsZSAoSVNPIDg4NTktMSB3aXRoICJcIiBlc2NhcGVzKQorIyBUaGlzIGZpbGUgZG9lcyBub3QgbmVlZCB0byBiZSB0cmFuc2xhdGVkLgorCiswPXF1YWxpZmllcgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS9hYm91dC5wcm9wZXJ0aWVzIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS9hYm91dC5wcm9wZXJ0aWVzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjk0NGMzMWYKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL2Fib3V0LnByb3BlcnRpZXMKQEAgLTAsMCArMSwyNiBAQAorIworIyBDb3B5cmlnaHQgKGMpIDIwMTIsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHIChIZWlkZWxiZXJnKQorIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisjIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAorIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorIworIyBDb250cmlidXRvcnM6CisjICAgIExvZXR6IEdtYkgmQ28uS0cgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KKyMKKworIyBOTFNfTUVTU0FHRUZPUk1BVF9WQVIKKworZmVhdHVyZU5hbWU9b3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZQorCisjIyMjIyMjIyMjIyMjIyMjIGJsdXJiIHByb3BlcnR5ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIworZmVhdHVyZVRleHQ9XAorQ29weXJpZ2h0IChjKSAyMDEyLTIwMTYgLSBMb2V0eiBHbWJIJkNvLktHIFxuXAorQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFsc1xuXAorYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wXG5cCit3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdFxuXAoraHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWxcblwKK1xuXAorQ29udHJpYnV0b3JzOlxuXAorICAgIExvZXR6IEdtYkgmQ28uS0cgLSBpbXBsZW1lbnRhdGlvblxuCisjIyMjIyMjIyMjIyMjIyMjIGVuZCBvZiBibHVyYiBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUvYnVpbGQucHJvcGVydGllcyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUvYnVpbGQucHJvcGVydGllcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5hY2EzOWU5Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS9idWlsZC5wcm9wZXJ0aWVzCkBAIC0wLDAgKzEsOSBAQAorc291cmNlLi4gPSBzcmMvCitiaW4uaW5jbHVkZXMgPSBhYm91dC5wcm9wZXJ0aWVzLCAgYWJvdXQubWFwcGluZ3MsICBhYm91dC5pbmksICBhYm91dC5odG1sLCAgTUVUQS1JTkYvLFwKKyAgICAgICAgICAgICAgIC4sXAorICAgICAgICAgICAgICAgcGx1Z2luLnhtbCxcCisgICAgICAgICAgICAgICBMSUNFTlNFLnR4dCxcCisgICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwKK291dHB1dC4uID0gdGFyZ2V0L2NsYXNzZXMvCitzcmMuaW5jbHVkZXMgPSBhYm91dC5wcm9wZXJ0aWVzLCAgYWJvdXQubWFwcGluZ3MsICBhYm91dC5pbmksICBhYm91dC5odG1sLCAgTElDRU5TRS50eHQsXAorICAgICAgICAgICAgICAgbGljZW5zZS5odG1sCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL2xpY2Vuc2UuaHRtbCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUvbGljZW5zZS5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmMzM2Q0NWMKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL2xpY2Vuc2UuaHRtbApAQCAtMCwwICsxLDEwOSBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iSVNPLTg4NTktMSIgPz4KKzwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFN0cmljdC8vRU4iICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS1zdHJpY3QuZHRkIj4KKzwhLS0gc2F2ZWQgZnJvbSB1cmw9KDAwNDQpaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwvbm90aWNlLmh0bWwgLS0+Cis8aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+Cis8aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiIC8+Cis8dGl0bGU+RWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC90aXRsZT4KKzwvaGVhZD4KKworPGJvZHkgbGFuZz0iRU4tVVMiPgorPGgyPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvaDI+Cis8cD5GZWJydWFyeSAxLCAyMDExPC9wPgorCis8aDM+VXNhZ2UgT2YgQ29udGVudDwvaDM+CisKKzxwPlRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiBBTkQvT1IgT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUworICAgKENPTExFQ1RJVkVMWSAmcXVvdDtDT05URU5UJnF1b3Q7KS4gIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQKKyAgIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VIEFHUkVFIFRIQVQgWU9VUiBVU0UKKyAgIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SCisgICBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQKKyAgIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULjwvcD4KKworPGgzPkFwcGxpY2FibGUgTGljZW5zZXM8L2gzPgorCis8cD5Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wCisgICAoJnF1b3Q7RVBMJnF1b3Q7KS4gIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpcyBDb250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L2E+LgorICAgRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICZxdW90O1Byb2dyYW0mcXVvdDsgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvcD4KKworPHA+Q29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsIGRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBzb3VyY2UgY29kZQorICAgcmVwb3NpdG9yeSAoJnF1b3Q7UmVwb3NpdG9yeSZxdW90OykgaW4gc29mdHdhcmUgbW9kdWxlcyAoJnF1b3Q7TW9kdWxlcyZxdW90OykgYW5kIG1hZGUgYXZhaWxhYmxlIGFzIGRvd25sb2FkYWJsZSBhcmNoaXZlcyAoJnF1b3Q7RG93bmxvYWRzJnF1b3Q7KS48L3A+CisKKzx1bD4KKyAgICAgICA8bGk+Q29udGVudCBtYXkgYmUgc3RydWN0dXJlZCBhbmQgcGFja2FnZWQgaW50byBtb2R1bGVzIHRvIGZhY2lsaXRhdGUgZGVsaXZlcmluZywgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiAgVHlwaWNhbCBtb2R1bGVzIG1heSBpbmNsdWRlIHBsdWctaW5zICgmcXVvdDtQbHVnLWlucyZxdW90OyksIHBsdWctaW4gZnJhZ21lbnRzICgmcXVvdDtGcmFnbWVudHMmcXVvdDspLCBhbmQgZmVhdHVyZXMgKCZxdW90O0ZlYXR1cmVzJnF1b3Q7KS48L2xpPgorICAgICAgIDxsaT5FYWNoIFBsdWctaW4gb3IgRnJhZ21lbnQgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBvciBKQVIgKEphdmEmdHJhZGU7IEFSY2hpdmUpIGluIGEgZGlyZWN0b3J5IG5hbWVkICZxdW90O3BsdWdpbnMmcXVvdDsuPC9saT4KKyAgICAgICA8bGk+QSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuICBFYWNoIEZlYXR1cmUgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtmZWF0dXJlcyZxdW90Oy4gIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUueG1sJnF1b3Q7IG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMKKyAgICAgIGFuZC9vciBGcmFnbWVudHMgYXNzb2NpYXRlZCB3aXRoIHRoYXQgRmVhdHVyZS48L2xpPgorICAgICAgIDxsaT5GZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgmcXVvdDtJbmNsdWRlZCBGZWF0dXJlcyZxdW90OykuIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUueG1sJnF1b3Q7IG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy48L2xpPgorPC91bD4KKworPHA+VGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZSBjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgJnF1b3Q7YWJvdXQuaHRtbCZxdW90OyAoJnF1b3Q7QWJvdXRzJnF1b3Q7KS4gVGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBGZWF0dXJlcyBhbmQKK0luY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgJnF1b3Q7bGljZW5zZS5odG1sJnF1b3Q7ICgmcXVvdDtGZWF0dXJlIExpY2Vuc2VzJnF1b3Q7KS4gIEFib3V0cyBhbmQgRmVhdHVyZSBMaWNlbnNlcyBtYXkgYmUgbG9jYXRlZCBpbiBhbnkgZGlyZWN0b3J5IG9mIGEgRG93bmxvYWQgb3IgTW9kdWxlCitpbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIGxvY2F0aW9uczo8L3A+CisKKzx1bD4KKyAgICAgICA8bGk+VGhlIHRvcC1sZXZlbCAocm9vdCkgZGlyZWN0b3J5PC9saT4KKyAgICAgICA8bGk+UGx1Zy1pbiBhbmQgRnJhZ21lbnQgZGlyZWN0b3JpZXM8L2xpPgorICAgICAgIDxsaT5JbnNpZGUgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBwYWNrYWdlZCBhcyBKQVJzPC9saT4KKyAgICAgICA8bGk+U3ViLWRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgJnF1b3Q7c3JjJnF1b3Q7IG9mIGNlcnRhaW4gUGx1Zy1pbnM8L2xpPgorICAgICAgIDxsaT5GZWF0dXJlIGRpcmVjdG9yaWVzPC9saT4KKzwvdWw+CisKKzxwPk5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIGluc3RhbGxlZCB1c2luZyB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgKGFzIGRlZmluZWQgYmVsb3cpLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCZxdW90O0ZlYXR1cmUgVXBkYXRlIExpY2Vuc2UmcXVvdDspIGR1cmluZyB0aGUKK2luc3RhbGxhdGlvbiBwcm9jZXNzLiAgSWYgdGhlIEZlYXR1cmUgY29udGFpbnMgSW5jbHVkZWQgRmVhdHVyZXMsIHRoZSBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIHNob3VsZCBlaXRoZXIgcHJvdmlkZSB5b3Ugd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvcgoraW5mb3JtIHlvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiAgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgbWF5IGJlIGZvdW5kIGluIHRoZSAmcXVvdDtsaWNlbnNlJnF1b3Q7IHByb3BlcnR5IG9mIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUucHJvcGVydGllcyZxdW90OyBmb3VuZCB3aXRoaW4gYSBGZWF0dXJlLgorU3VjaCBBYm91dHMsIEZlYXR1cmUgTGljZW5zZXMsIGFuZCBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBjb250YWluIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyAob3IgcmVmZXJlbmNlcyB0byBzdWNoIHRlcm1zIGFuZCBjb25kaXRpb25zKSB0aGF0IGdvdmVybiB5b3VyIHVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluCit0aGF0IGRpcmVjdG9yeS48L3A+CisKKzxwPlRIRSBBQk9VVFMsIEZFQVRVUkUgTElDRU5TRVMsIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVIgVE8gVEhFIEVQTCBPUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuICBTT01FIE9GIFRIRVNFCitPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOjwvcD4KKworPHVsPgorICAgICAgIDxsaT5FY2xpcHNlIERpc3RyaWJ1dGlvbiBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9saWNlbnNlcy9lZGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGljZW5zZXMvZWRsLXYxLjAuaHRtbDwvYT4pPC9saT4KKyAgICAgICA8bGk+Q29tbW9uIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sPC9hPik8L2xpPgorICAgICAgIDxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAxLjEgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRSI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0U8L2E+KTwvbGk+CisgICAgICAgPGxpPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDIuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMCI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wPC9hPik8L2xpPgorICAgICAgIDxsaT5NZXRybyBMaW5rIFB1YmxpYyBMaWNlbnNlIDEuMDAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbCI+aHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWw8L2E+KTwvbGk+CisgICAgICAgPGxpPk1vemlsbGEgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjEgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWwiPmh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbDwvYT4pPC9saT4KKzwvdWw+CisKKzxwPklUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1IgVE8gVVNFIE9GIFRIRSBDT05URU5ULiAgSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSwgb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBpcyBwcm92aWRlZCwgcGxlYXNlCitjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LjwvcD4KKworCis8aDM+VXNlIG9mIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5PC9oMz4KKworPHA+VGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYWtlcyBhdmFpbGFibGUgcHJvdmlzaW9uaW5nIHNvZnR3YXJlLCBleGFtcGxlcyBvZiB3aGljaCBpbmNsdWRlLCBidXQgYXJlIG5vdCBsaW1pdGVkIHRvLCBwMiBhbmQgdGhlIEVjbGlwc2UKKyAgIFVwZGF0ZSBNYW5hZ2VyICgmcXVvdDtQcm92aXNpb25pbmcgVGVjaG5vbG9neSZxdW90OykgZm9yIHRoZSBwdXJwb3NlIG9mIGFsbG93aW5nIHVzZXJzIHRvIGluc3RhbGwgc29mdHdhcmUsIGRvY3VtZW50YXRpb24sIGluZm9ybWF0aW9uIGFuZC9vcgorICAgb3RoZXIgbWF0ZXJpYWxzIChjb2xsZWN0aXZlbHkgJnF1b3Q7SW5zdGFsbGFibGUgU29mdHdhcmUmcXVvdDspLiBUaGlzIGNhcGFiaWxpdHkgaXMgcHJvdmlkZWQgd2l0aCB0aGUgaW50ZW50IG9mIGFsbG93aW5nIHN1Y2ggdXNlcnMgdG8KKyAgIGluc3RhbGwsIGV4dGVuZCBhbmQgdXBkYXRlIEVjbGlwc2UtYmFzZWQgcHJvZHVjdHMuIEluZm9ybWF0aW9uIGFib3V0IHBhY2thZ2luZyBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBpcyBhdmFpbGFibGUgYXQgPGEKKyAgICAgICBocmVmPSJodHRwOi8vZWNsaXBzZS5vcmcvZXF1aW5veC9wMi9yZXBvc2l0b3J5X3BhY2thZ2luZy5odG1sIj5odHRwOi8vZWNsaXBzZS5vcmcvZXF1aW5veC9wMi9yZXBvc2l0b3J5X3BhY2thZ2luZy5odG1sPC9hPgorICAgKCZxdW90O1NwZWNpZmljYXRpb24mcXVvdDspLjwvcD4KKworPHA+WW91IG1heSB1c2UgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgdG8gYWxsb3cgb3RoZXIgcGFydGllcyB0byBpbnN0YWxsIEluc3RhbGxhYmxlIFNvZnR3YXJlLiBZb3Ugc2hhbGwgYmUgcmVzcG9uc2libGUgZm9yIGVuYWJsaW5nIHRoZQorICAgYXBwbGljYWJsZSBsaWNlbnNlIGFncmVlbWVudHMgcmVsYXRpbmcgdG8gdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlIHRvIGJlIHByZXNlbnRlZCB0bywgYW5kIGFjY2VwdGVkIGJ5LCB0aGUgdXNlcnMgb2YgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5CisgICBpbiBhY2NvcmRhbmNlIHdpdGggdGhlIFNwZWNpZmljYXRpb24uIEJ5IHVzaW5nIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IGluIHN1Y2ggYSBtYW5uZXIgYW5kIG1ha2luZyBpdCBhdmFpbGFibGUgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZQorICAgU3BlY2lmaWNhdGlvbiwgeW91IGZ1cnRoZXIgYWNrbm93bGVkZ2UgeW91ciBhZ3JlZW1lbnQgdG8sIGFuZCB0aGUgYWNxdWlzaXRpb24gb2YgYWxsIG5lY2Vzc2FyeSByaWdodHMgdG8gcGVybWl0IHRoZSBmb2xsb3dpbmc6PC9wPgorCis8b2w+CisgICAgICAgPGxpPkEgc2VyaWVzIG9mIGFjdGlvbnMgbWF5IG9jY3VyICgmcXVvdDtQcm92aXNpb25pbmcgUHJvY2VzcyZxdW90OykgaW4gd2hpY2ggYSB1c2VyIG1heSBleGVjdXRlIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neQorICAgICAgIG9uIGEgbWFjaGluZSAoJnF1b3Q7VGFyZ2V0IE1hY2hpbmUmcXVvdDspIHdpdGggdGhlIGludGVudCBvZiBpbnN0YWxsaW5nLCBleHRlbmRpbmcgb3IgdXBkYXRpbmcgdGhlIGZ1bmN0aW9uYWxpdHkgb2YgYW4gRWNsaXBzZS1iYXNlZAorICAgICAgIHByb2R1Y3QuPC9saT4KKyAgICAgICA8bGk+RHVyaW5nIHRoZSBQcm92aXNpb25pbmcgUHJvY2VzcywgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IG1heSBjYXVzZSB0aGlyZCBwYXJ0eSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBvciBhIHBvcnRpb24gdGhlcmVvZiB0byBiZQorICAgICAgIGFjY2Vzc2VkIGFuZCBjb3BpZWQgdG8gdGhlIFRhcmdldCBNYWNoaW5lLjwvbGk+CisgICAgICAgPGxpPlB1cnN1YW50IHRvIHRoZSBTcGVjaWZpY2F0aW9uLCB5b3Ugd2lsbCBwcm92aWRlIHRvIHRoZSB1c2VyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyB0aGF0IGdvdmVybiB0aGUgdXNlIG9mIHRoZSBJbnN0YWxsYWJsZQorICAgICAgIFNvZnR3YXJlICgmcXVvdDtJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQmcXVvdDspIGFuZCBzdWNoIEluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCBzaGFsbCBiZSBhY2Nlc3NlZCBmcm9tIHRoZSBUYXJnZXQKKyAgICAgICBNYWNoaW5lIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgU3BlY2lmaWNhdGlvbi4gU3VjaCBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQgbXVzdCBpbmZvcm0gdGhlIHVzZXIgb2YgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIHRoYXQgZ292ZXJuCisgICAgICAgdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlIGFuZCBtdXN0IHNvbGljaXQgYWNjZXB0YW5jZSBieSB0aGUgZW5kIHVzZXIgaW4gdGhlIG1hbm5lciBwcmVzY3JpYmVkIGluIHN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50LiBVcG9uIHN1Y2gKKyAgICAgICBpbmRpY2F0aW9uIG9mIGFncmVlbWVudCBieSB0aGUgdXNlciwgdGhlIHByb3Zpc2lvbmluZyBUZWNobm9sb2d5IHdpbGwgY29tcGxldGUgaW5zdGFsbGF0aW9uIG9mIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZS48L2xpPgorPC9vbD4KKworPGgzPkNyeXB0b2dyYXBoeTwvaDM+CisKKzxwPkNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZSBjdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsIGFuZC9vciByZS1leHBvcnQgdG8KKyAgIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFIHVzaW5nIGFueSBlbmNyeXB0aW9uIHNvZnR3YXJlLCBwbGVhc2UgY2hlY2sgdGhlIGNvdW50cnkncyBsYXdzLCByZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgY29uY2VybmluZyB0aGUgaW1wb3J0LAorICAgcG9zc2Vzc2lvbiwgb3IgdXNlLCBhbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIHRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC48L3A+CisKKzxwPjxzbWFsbD5KYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIE9yYWNsZSBDb3Jwb3JhdGlvbiBpbiB0aGUgVW5pdGVkIFN0YXRlcywgb3RoZXIgY291bnRyaWVzLCBvciBib3RoLjwvc21hbGw+PC9wPgorPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUvcDJ0YXJnZXRzLnByb3BlcnRpZXMgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL3AydGFyZ2V0cy5wcm9wZXJ0aWVzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQwMjk3N2YKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL3AydGFyZ2V0cy5wcm9wZXJ0aWVzCkBAIC0wLDAgKzEsMiBAQAorb3NicC5wMi5ydW50aW1lU2VydmVyVVJMPWh0dHA6Ly9sdW4ub3NicC5vcmcvZG93bmxvYWRzL3AyL29zYnAvbHVuYS9sYXRlc3QvCitvc2JwLnAyLnJ1bnRpbWVTZXJ2ZXJVUkwuZmVhdHVyZT1vcmcuZWNsaXBzZS5vc2JwLnJ1bnRpbWUuZmVhdHVyZS5hbGxpbm9uZS50ZXN0ZnJhbWV3b3JrCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL3BsdWdpbi54bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL3BsdWdpbi54bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGU5NWU0ZAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUvcGx1Z2luLnhtbApAQCAtMCwwICsxLDMgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8cGx1Z2luPgorPC9wbHVnaW4+CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL3BvbS54bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL3BvbS54bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNjEyMTFkZQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUvcG9tLnhtbApAQCAtMCwwICsxLDIzIEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPCEtLSM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4KKzwhLS0jIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIEx1bmlmZXJhIEdtYkggKEdyb3NzIEVuemVyc2RvcmYpLCBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KSAtLT4KKzwhLS0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgLS0+Cis8IS0tIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgLS0+Cis8IS0tIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAtLT4KKzwhLS0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIC0tPgorPCEtLSMgLS0+Cis8IS0tIyBDb250cmlidXRvcnM6IC0tPgorPCEtLSMgICAgIEtsZW1lbnMgRWRsZXIgKEx1bmlmZXJhIEdtYkgpIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIC0tPgorPCEtLSM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4KKworPHByb2plY3QgeG1sbnM9Imh0dHA6Ly9tYXZlbi5hcGFjaGUub3JnL1BPTS80LjAuMCIgeG1sbnM6eHNpPSJodHRwOi8vd3d3LnczLm9yZy8yMDAxL1hNTFNjaGVtYS1pbnN0YW5jZSIgeHNpOnNjaGVtYUxvY2F0aW9uPSJodHRwOi8vbWF2ZW4uYXBhY2hlLm9yZy9QT00vNC4wLjAgaHR0cDovL21hdmVuLmFwYWNoZS5vcmcveHNkL21hdmVuLTQuMC4wLnhzZCI+CisgICAgPG1vZGVsVmVyc2lvbj40LjAuMDwvbW9kZWxWZXJzaW9uPgorICAgIDxwYXJlbnQ+CisgICAgICAgIDxncm91cElkPm9yZy5lY2xpcHNlLm9zYnAuaWRlPC9ncm91cElkPgorICAgICAgICA8YXJ0aWZhY3RJZD5vcmcuZWNsaXBzZS5vc2JwLmlkZTwvYXJ0aWZhY3RJZD4KKyAgICAgICAgPHZlcnNpb24+MC45LjAtU05BUFNIT1Q8L3ZlcnNpb24+CisgICAgPC9wYXJlbnQ+CisgICAgPGFydGlmYWN0SWQ+b3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZTwvYXJ0aWZhY3RJZD4KKyAgICA8cGFja2FnaW5nPmVjbGlwc2UtcGx1Z2luPC9wYWNrYWdpbmc+CisKKzwvcHJvamVjdD4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvQWN0aXZhdG9yLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS9jb3JlL0FjdGl2YXRvci5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmNiOWI5ZmEKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS9jb3JlL0FjdGl2YXRvci5qYXZhCkBAIC0wLDAgKzEsNDAgQEAKKy8qKgorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE1IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiwgQXVzdHJpYSksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorICoKKyAqIENvbnRyaWJ1dG9yczoKKyAqICAgICAgICAgRmxvcmlhbiBQaXJjaG5lciAtIEluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqLworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlOworCitpbXBvcnQgb3JnLm9zZ2kuZnJhbWV3b3JrLkJ1bmRsZUFjdGl2YXRvcjsKK2ltcG9ydCBvcmcub3NnaS5mcmFtZXdvcmsuQnVuZGxlQ29udGV4dDsKKworcHVibGljIGNsYXNzIEFjdGl2YXRvciBpbXBsZW1lbnRzIEJ1bmRsZUFjdGl2YXRvciB7CisKKwlwcml2YXRlIHN0YXRpYyBCdW5kbGVDb250ZXh0IGNvbnRleHQ7CisKKwlwdWJsaWMgc3RhdGljIEJ1bmRsZUNvbnRleHQgZ2V0Q29udGV4dCgpIHsKKwkJcmV0dXJuIGNvbnRleHQ7CisJfQorCisJLyoKKwkgKiAobm9uLUphdmFkb2MpCisJICogQHNlZSBvcmcub3NnaS5mcmFtZXdvcmsuQnVuZGxlQWN0aXZhdG9yI3N0YXJ0KG9yZy5vc2dpLmZyYW1ld29yay5CdW5kbGVDb250ZXh0KQorCSAqLworCXB1YmxpYyB2b2lkIHN0YXJ0KEJ1bmRsZUNvbnRleHQgYnVuZGxlQ29udGV4dCkgdGhyb3dzIEV4Y2VwdGlvbiB7CisJCUFjdGl2YXRvci5jb250ZXh0ID0gYnVuZGxlQ29udGV4dDsKKwl9CisKKwkvKgorCSAqIChub24tSmF2YWRvYykKKwkgKiBAc2VlIG9yZy5vc2dpLmZyYW1ld29yay5CdW5kbGVBY3RpdmF0b3Ijc3RvcChvcmcub3NnaS5mcmFtZXdvcmsuQnVuZGxlQ29udGV4dCkKKwkgKi8KKwlwdWJsaWMgdm9pZCBzdG9wKEJ1bmRsZUNvbnRleHQgYnVuZGxlQ29udGV4dCkgdGhyb3dzIEV4Y2VwdGlvbiB7CisJCUFjdGl2YXRvci5jb250ZXh0ID0gbnVsbDsKKwl9CisKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvaTE4bi9JMThuUmVnaXN0cnkuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL2NvcmUvaTE4bi9JMThuUmVnaXN0cnkuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jNWVmNmVjCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvY29yZS9pMThuL0kxOG5SZWdpc3RyeS5qYXZhCkBAIC0wLDAgKzEsNDk4IEBACisvKioKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNSAtIEx1bmlmZXJhIEdtYkggKEdyb3NzIEVuemVyc2RvcmYsIEF1c3RyaWEpLCBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscworICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKKyAqCisgKiBDb250cmlidXRvcnM6CisgKiAgICAgICAgIEZsb3JpYW4gUGlyY2huZXIgLSBJbml0aWFsIGltcGxlbWVudGF0aW9uCisgKi8KK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5pMThuOworCitpbXBvcnQgamF2YS51dGlsLkNvbGxlY3Rpb25zOworaW1wb3J0IGphdmEudXRpbC5IYXNoTWFwOworaW1wb3J0IGphdmEudXRpbC5IYXNoU2V0OworaW1wb3J0IGphdmEudXRpbC5MaW5rZWRMaXN0OworaW1wb3J0IGphdmEudXRpbC5MaXN0OworaW1wb3J0IGphdmEudXRpbC5Mb2NhbGU7CitpbXBvcnQgamF2YS51dGlsLk1hcDsKK2ltcG9ydCBqYXZhLnV0aWwuU2V0OworaW1wb3J0IGphdmEudXRpbC5yZWdleC5NYXRjaGVyOworaW1wb3J0IGphdmEudXRpbC5yZWdleC5QYXR0ZXJuOworCitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVByb2plY3Q7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkNvcmVFeGNlcHRpb247CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklQYXRoOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUuYXBpLmkxOG4uQ29yZVV0aWw7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGkuaTE4bi5JSTE4blJlZ2lzdHJ5OworaW1wb3J0IG9yZy5zbGY0ai5Mb2dnZXI7CitpbXBvcnQgb3JnLnNsZjRqLkxvZ2dlckZhY3Rvcnk7CisKK2ltcG9ydCBjb20uZ29vZ2xlLmluamVjdC5TaW5nbGV0b247CisKK0BTaW5nbGV0b24KK3B1YmxpYyBjbGFzcyBJMThuUmVnaXN0cnkgaW1wbGVtZW50cyBJSTE4blJlZ2lzdHJ5IHsKKworCXByaXZhdGUgc3RhdGljIGZpbmFsIFByb2plY3REZXNjcmlwdGlvbiBFTVBZX1BST0pFQ1RfREVTQ1JJUFRJT04gPSBuZXcgUHJvamVjdERlc2NyaXB0aW9uKAorCQkJbnVsbCk7CisKKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBMb2dnZXIgTE9HR0VSID0gTG9nZ2VyRmFjdG9yeQorCQkJLmdldExvZ2dlcihJMThuUmVnaXN0cnkuY2xhc3MpOworCisJcHJpdmF0ZSBNYXA8SVByb2plY3QsIFByb2plY3REZXNjcmlwdGlvbj4gY2FjaGUgPSBDb2xsZWN0aW9ucworCQkJLnN5bmNocm9uaXplZE1hcChuZXcgSGFzaE1hcDxJUHJvamVjdCwgUHJvamVjdERlc2NyaXB0aW9uPigpKTsKKworCXB1YmxpYyBJMThuUmVnaXN0cnkoKSB7CisKKwl9CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgU3RyaW5nIGdldFRleHQoSVByb2plY3QgcHJvamVjdCwgTG9jYWxlIGxvY2FsZSwgU3RyaW5nIGtleSkgeworCQlTdHJpbmcgcmVzdWx0ID0gZmluZFRyYW5zbGF0aW9uKHByb2plY3QsIGxvY2FsZSwga2V5LCBsb2NhbGUpOworCQlyZXR1cm4gcmVzdWx0OworCX0KKworCUBPdmVycmlkZQorCXB1YmxpYyBMaXN0PFByb3Bvc2FsPiBmaW5kQ29udGVudFByb3Bvc2FscyhJUHJvamVjdCBwcm9qZWN0LCBMb2NhbGUgbG9jYWxlLAorCQkJU3RyaW5nIHBhY2thZ2VOYW1lLCBTdHJpbmcgc2VhcmNoVmFsdWUpIHsKKwkJQWNjZXNzUGF0aCBhY2Nlc3NQYXRoID0gY29tcHV0ZUFjY2Vzc1BhdGgocHJvamVjdCwgbG9jYWxlLCBwYWNrYWdlTmFtZSwKKwkJCQlzZWFyY2hWYWx1ZSk7CisJCXJldHVybiBhY2Nlc3NQYXRoLmdldENvbnRlbnRQcm9wb3NhbHMoKTsKKwl9CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgTGlzdDxQcm9wb3NhbD4gZmluZFN0cmljdEtleU1hdGNoaW5nUHJvcG9zYWxzKElQcm9qZWN0IHByb2plY3QsCisJCQlMb2NhbGUgbG9jYWxlLCBTdHJpbmcgcGFja2FnZU5hbWUsIFN0cmluZyBrZXkpIHsKKwkJQWNjZXNzUGF0aCBhY2Nlc3NQYXRoID0gY29tcHV0ZUJlc3RNYXRjaEFjY2Vzc1BhdGgocHJvamVjdCwgbG9jYWxlLAorCQkJCXBhY2thZ2VOYW1lLCBrZXkpOworCQlyZXR1cm4gYWNjZXNzUGF0aC5nZXRTdHJpY3RLZXlNYXRjaGluZ1Byb3Bvc2FscygpOworCX0KKworCUBPdmVycmlkZQorCXB1YmxpYyBQcm9wb3NhbCBmaW5kQmVzdE1hdGNoKElQcm9qZWN0IHByb2plY3QsIExvY2FsZSBsb2NhbGUsCisJCQlTdHJpbmcgcGFja2FnZU5hbWUsIFN0cmluZyBrZXkpIHsKKwkJQWNjZXNzUGF0aCBhY2Nlc3NQYXRoID0gY29tcHV0ZUJlc3RNYXRjaEFjY2Vzc1BhdGgocHJvamVjdCwgbG9jYWxlLAorCQkJCXBhY2thZ2VOYW1lLCBrZXkpOworCQlyZXR1cm4gYWNjZXNzUGF0aC5nZXRCZXN0TWF0Y2goKTsKKwl9CisKKwkvKioKKwkgKiBDb21wdXRlcyB0aGUgYWNjZXNzIHBhdGguCisJICogPHA+CisJICogRm9sbG93aW5nIG9yZGVyIHdpbGwgYmUgdXNlZDoKKwkgKiA8b2w+CisJICogPGxpPkZpbmQgYWxsIGVudHJpZXMgaW4gY3VycmVudCBwcm9qZWN0CisJICogPHVsPgorCSAqIDxsaT5Vc2UgZ2l2ZW4gcHJvamVjdCBhbmQgbG9jYWxlPC9saT4KKwkgKiA8bGk+Q3JlYXRlIG1vcmUgc3BlY2lmaWMgbG9jYWxlIGFuZCByZXBlYXQgdW50aWwgZGVmYXVsdCBsb2NhbGUgaXMKKwkgKiByZWFjaGVkLjwvbGk+CisJICogPC91bD4KKwkgKiA8L2xpPgorCSAqIDxsaT5JdGVyYXRlIHRoZSByZWZlcmVuY2VkIHByb2plY3RzIGFuZCBzdGFydCBhdCAxKSBmb3IgZWFjaCBwcm9qZWN0IHdpdGgKKwkgKiB0aGUgcmVxdWVzdGVkIGxvY2FsZS48L2xpPgorCSAqIDwvb2w+CisJICogCisJICogQHBhcmFtIHByb2plY3QKKwkgKiBAcGFyYW0gbG9jYWxlCisJICogQHBhcmFtIHBhY2thZ2VOYW1lCisJICogQHBhcmFtIHNlYXJjaFZhbHVlCisJICogQHJldHVybgorCSAqLworCXByaXZhdGUgQWNjZXNzUGF0aCBjb21wdXRlQWNjZXNzUGF0aChJUHJvamVjdCBwcm9qZWN0LCBMb2NhbGUgbG9jYWxlLAorCQkJU3RyaW5nIHBhY2thZ2VOYW1lLCBTdHJpbmcgc2VhcmNoVmFsdWUpIHsKKworCQlTdHJpbmcgbWF0Y2hpbmdQYWNrYWdlID0gbnVsbDsKKwkJU3RyaW5nIHZhbHVlUGF0dGVyblN0cmluZyA9IG51bGw7CisJCS8vIHNlYXJjaCBpbiBnaXZlbiBwYWNrYWdlCisJCWlmIChzZWFyY2hWYWx1ZS5zdGFydHNXaXRoKCIuIikpIHsKKwkJCXZhbHVlUGF0dGVyblN0cmluZyA9IHNlYXJjaFZhbHVlLnJlcGxhY2VGaXJzdCgiLiIsICIiKTsKKwkJCW1hdGNoaW5nUGFja2FnZSA9IHBhY2thZ2VOYW1lOworCQl9IGVsc2UgeworCQkJdmFsdWVQYXR0ZXJuU3RyaW5nID0gc2VhcmNoVmFsdWU7CisJCX0KKworCQlNYXRjaGVyIHZhbHVlTWF0Y2hlciA9IG51bGw7CisJCWlmICh2YWx1ZVBhdHRlcm5TdHJpbmcgIT0gbnVsbCAmJiAhdmFsdWVQYXR0ZXJuU3RyaW5nLmVxdWFscygiIikpIHsKKwkJCXZhbHVlUGF0dGVyblN0cmluZyA9IFBhdHRlcm4ucXVvdGUodmFsdWVQYXR0ZXJuU3RyaW5nKTsKKwkJCVBhdHRlcm4gdmFsdWVQYXR0ZXJuID0gUGF0dGVybi5jb21waWxlKHZhbHVlUGF0dGVyblN0cmluZworCQkJCQkudG9TdHJpbmcoKSk7CisJCQl2YWx1ZU1hdGNoZXIgPSB2YWx1ZVBhdHRlcm4ubWF0Y2hlcigiIik7CisJCQl2YWx1ZU1hdGNoZXIucmVzZXQoKTsKKwkJfQorCisJCUFjY2Vzc1BhdGggcGF0aCA9IG5ldyBBY2Nlc3NQYXRoKCk7CisJCWludCBwcmlvID0gMDsKKworCQkvLyBhbGwgbG9jYWxlcyBmb3IgdGhlIGdpdmVuIHByb2plY3QKKwkJTGlzdDxJUHJvamVjdD4gY29tcHV0ZWRQcm9qZWN0cyA9IGNvbXB1dGVQcm9qZWN0cyhwcm9qZWN0KTsKKwkJTGlzdDxMb2NhbGU+IGNvbXB1dGVkTG9jYWxlcyA9IGNvbXB1dGVMb2NhbGVzKGxvY2FsZSk7CisKKwkJZm9yIChJUHJvamVjdCBjb21wdXRlZFByb2plY3QgOiBjb21wdXRlZFByb2plY3RzKSB7CisJCQlmb3IgKExvY2FsZSBjb21wdXRlZExvY2FsZSA6IGNvbXB1dGVkTG9jYWxlcykgeworCQkJCUFjY2Vzc29yIGFjY2Vzc29yID0gbmV3IEFjY2Vzc29yKGNvbXB1dGVkUHJvamVjdCwKKwkJCQkJCWNvbXB1dGVkTG9jYWxlLCArK3ByaW8sIHNlYXJjaFZhbHVlLCBtYXRjaGluZ1BhY2thZ2UsCisJCQkJCQl2YWx1ZU1hdGNoZXIpOworCQkJCXBhdGguYWRkQWNjZXNzb3IoYWNjZXNzb3IpOworCQkJfQorCQl9CisKKwkJcmV0dXJuIHBhdGg7CisJfQorCisJLyoqCisJICogQ29tcHV0ZXMgdGhlIGFjY2VzcyBwYXRoIHRvIGZpbmQgdGhlIGJlc3QgbWF0Y2hpbmcgZWxlbWVudC4gU2VlCisJICoge0BsaW5rICNjb21wdXRlQWNjZXNzUGF0aChJUHJvamVjdCwgTG9jYWxlLCBTdHJpbmcsIFN0cmluZyl9LgorCSAqCisJICogQHBhcmFtIHByb2plY3QKKwkgKiBAcGFyYW0gbG9jYWxlCisJICogQHBhcmFtIHBhY2thZ2VOYW1lCisJICogQHBhcmFtIHNlYXJjaFZhbHVlCisJICogQHJldHVybgorCSAqLworCXByaXZhdGUgQWNjZXNzUGF0aCBjb21wdXRlQmVzdE1hdGNoQWNjZXNzUGF0aChJUHJvamVjdCBwcm9qZWN0LAorCQkJTG9jYWxlIGxvY2FsZSwgU3RyaW5nIHBhY2thZ2VOYW1lLCBTdHJpbmcgc2VhcmNoVmFsdWUpIHsKKwkJcmV0dXJuIGNvbXB1dGVBY2Nlc3NQYXRoKHByb2plY3QsIGxvY2FsZSwgcGFja2FnZU5hbWUsIHNlYXJjaFZhbHVlKTsKKwl9CisKKwkvKioKKwkgKiBDb21wdXRlcyBhbGwgcHJvamVjdHMgdGhhdCBzaG91bGQgYmUgYWRkZWQgdG8gQWNjZXNzUGF0aAorCSAqIAorCSAqIEBwYXJhbSBwcm9qZWN0CisJICogQHJldHVybgorCSAqLworCXByaXZhdGUgTGlzdDxJUHJvamVjdD4gY29tcHV0ZVByb2plY3RzKElQcm9qZWN0IHByb2plY3QpIHsKKwkJTGlzdDxJUHJvamVjdD4gcHJvamVjdHMgPSBuZXcgTGlua2VkTGlzdDxJUHJvamVjdD4oKTsKKwkJLy8gQWRkIGZpcnN0IHJvb3QgcHJvamVjdAorCQlwcm9qZWN0cy5hZGQocHJvamVjdCk7CisKKwkJdHJ5IHsKKwkJCWZvciAoSVByb2plY3QgcmVmZXJlbmNlZCA6IHByb2plY3QuZ2V0UmVmZXJlbmNlZFByb2plY3RzKCkpIHsKKwkJCQlpZiAoQ29yZVV0aWwuaGFzTmF0dXJlKHJlZmVyZW5jZWQpKSB7CisJCQkJCXByb2plY3RzLmFkZChyZWZlcmVuY2VkKTsKKwkJCQl9CisJCQl9CisJCX0gY2F0Y2ggKENvcmVFeGNlcHRpb24gZSkgeworCQkJTE9HR0VSLmVycm9yKCJ7fSIsIGUpOworCQl9CisKKwkJcmV0dXJuIHByb2plY3RzOworCX0KKworCS8qKgorCSAqIENvbXB1dGVzIGFsbCBsb2NhbGVzIHRoYXQgc2hvdWxkIGJlIGFkZGVkIHRvIEFjY2Vzc1BhdGgKKwkgKiAKKwkgKiBAcGFyYW0gbG9jYWxlCisJICogQHJldHVybgorCSAqLworCXByaXZhdGUgTGlzdDxMb2NhbGU+IGNvbXB1dGVMb2NhbGVzKExvY2FsZSBsb2NhbGUpIHsKKwkJTGlzdDxMb2NhbGU+IGxvY2FsZXMgPSBuZXcgTGlua2VkTGlzdDxMb2NhbGU+KCk7CisKKwkJLy8gQWRkIGZpcnN0IGxvY2FsZQorCQlsb2NhbGVzLmFkZChsb2NhbGUpOworCisJCUxvY2FsZSB0ZW1wID0gbG9jYWxlOworCQl3aGlsZSAodHJ1ZSkgeworCQkJU3RyaW5nIHRhZyA9IHRlbXAudG9MYW5ndWFnZVRhZygpOworCQkJU3RyaW5nW10gc2VnbWVudHMgPSB0YWcuc3BsaXQoIi0iKTsKKwkJCWlmIChzZWdtZW50cy5sZW5ndGggPiAxKSB7CisJCQkJU3RyaW5nQnVpbGRlciBidWlsZGVyID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKKwkJCQlmb3IgKGludCBpID0gMDsgaSA8IHNlZ21lbnRzLmxlbmd0aCAtIDE7IGkrKykgeworCQkJCQlpZiAoYnVpbGRlci5sZW5ndGgoKSAhPSAwKSB7CisJCQkJCQlidWlsZGVyLmFwcGVuZCgiLSIpOworCQkJCQl9CisJCQkJCWJ1aWxkZXIuYXBwZW5kKHNlZ21lbnRzW2ldKTsKKwkJCQl9CisJCQkJTG9jYWxlIG1vcmVHZW5lcmFsID0gTG9jYWxlLmZvckxhbmd1YWdlVGFnKGJ1aWxkZXIudG9TdHJpbmcoKSk7CisJCQkJbG9jYWxlcy5hZGQobW9yZUdlbmVyYWwpOworCQkJCXRlbXAgPSBtb3JlR2VuZXJhbDsKKwkJCX0gZWxzZSB7CisJCQkJYnJlYWs7CisJCQl9CisJCX0KKworCQlsb2NhbGVzLmFkZChuZXcgTG9jYWxlKCIiKSk7CisKKwkJcmV0dXJuIGxvY2FsZXM7CisJfQorCisJLyoqCisJICogVHJpZXMgdG8gZmluZCB0aGUgdHJhbnNsYXRpb24ga2V5LgorCSAqIDxwPgorCSAqIDxvbD4KKwkgKiA8bGk+VHJpZXMgdG8gZmluZCB0aGUgdHJhbnNsYXRpb24gaW4gYWxsIHJlc291cmNlcyBpbiB0aGUgZ2l2ZW4gcHJvamVjdC48L2xpPgorCSAqIDxsaT5DcmVhdGVzIGEgbW9yZSBnZW5lcmFsIGxvY2FsZSBhbmQgY29udGludWVzIDE8L2xpPgorCSAqIDxsaT5JZiBsb2NhbGUgaXMgbW9zdCBnZW5lcmFsLCB0aGVuIGFsbCByZWZlcmVuY2VzIHByb2plY3RzIGFyZSB1c2VkIHRvCisJICogbG9vayBmb3IgYSB0cmFuc2xhdGlvbi4gQ29udGludWVzIDE8L2xpPgorCSAqIDxvbD4KKwkgKiAKKwkgKiBAcGFyYW0gcHJvamVjdAorCSAqIEBwYXJhbSBsb2NhbGUKKwkgKiBAcGFyYW0ga2V5CisJICogQHBhcmFtIG9yaWdpbmFsTG9jYWxlCisJICogQHJldHVybgorCSAqLworCXByaXZhdGUgU3RyaW5nIGZpbmRUcmFuc2xhdGlvbihJUHJvamVjdCBwcm9qZWN0LCBMb2NhbGUgbG9jYWxlLCBTdHJpbmcga2V5LAorCQkJTG9jYWxlIG9yaWdpbmFsTG9jYWxlKSB7CisJCVN0cmluZyByZXN1bHQgPSBudWxsOworCQkvLyBmaXJzdCB0cnkgdG8gZmluZCBhIHRyYW5zbGF0aW9uIHdpdGggdGhlIGdpdmVuIGxvY2FsZSBpbiB0aGUgcHJvamVjdAorCQkvLworCQlQcm9qZWN0RGVzY3JpcHRpb24gcHJvamVjdERlc2NyaXB0aW9uID0gZ2V0UHJvamVjdERlc2NyaXB0aW9uKHByb2plY3QpOworCQlMaXN0PFJlc291cmNlRGVzY3JpcHRpb24+IGRlc2NzID0gcHJvamVjdERlc2NyaXB0aW9uCisJCQkJLmdldFJlc291cmNlRGVzY3JpcHRpb25zKGxvY2FsZSk7CisKKwkJZm9yIChSZXNvdXJjZURlc2NyaXB0aW9uIGRlc2MgOiBkZXNjcykgeworCQkJcmVzdWx0ID0gZGVzYy5nZXRQcm9wZXJ0aWVzKCkuZ2V0UHJvcGVydHkoa2V5KTsKKwkJCWlmIChpc1ZhbGlkKHJlc3VsdCkpIHsKKwkJCQlyZXR1cm4gcmVzdWx0OworCQkJfQorCQl9CisKKwkJLy8gaWYgbm8gdHJhbnNsYXRpb24gYXZhaWxhYmxlLCB0aGVuIHRyeSB0byB1c2UgYSBtb3JlIGdlbmVyYWwgb25lCisJCS8vCisJCVN0cmluZyB0YWcgPSBsb2NhbGUudG9MYW5ndWFnZVRhZygpOworCQlTdHJpbmdbXSBzZWdtZW50cyA9IHRhZy5zcGxpdCgiLSIpOworCQlpZiAoc2VnbWVudHMubGVuZ3RoID4gMSkgeworCQkJU3RyaW5nQnVpbGRlciBidWlsZGVyID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKKwkJCWZvciAoaW50IGkgPSAwOyBpIDwgc2VnbWVudHMubGVuZ3RoIC0gMTsgaSsrKSB7CisJCQkJaWYgKGJ1aWxkZXIubGVuZ3RoKCkgIT0gMCkgeworCQkJCQlidWlsZGVyLmFwcGVuZCgiLSIpOworCQkJCX0KKwkJCQlidWlsZGVyLmFwcGVuZChzZWdtZW50c1tpXSk7CisJCQl9CisKKwkJCUxvY2FsZSBtb3JlR2VuZXJhbCA9IExvY2FsZS5mb3JMYW5ndWFnZVRhZyhidWlsZGVyLnRvU3RyaW5nKCkpOworCQkJcmVzdWx0ID0gZmluZFRyYW5zbGF0aW9uKHByb2plY3QsIG1vcmVHZW5lcmFsLCBrZXksIG9yaWdpbmFsTG9jYWxlKTsKKwkJCWlmIChpc1ZhbGlkKHJlc3VsdCkpIHsKKwkJCQlyZXR1cm4gcmVzdWx0OworCQkJfQorCQl9IGVsc2UgeworCQkJdHJ5IHsKKwkJCQlmb3IgKElQcm9qZWN0IHJlZmVyZW5jZWQgOiBwcm9qZWN0LmdldFJlZmVyZW5jZWRQcm9qZWN0cygpKSB7CisJCQkJCWlmIChyZWZlcmVuY2VkLmdldERlc2NyaXB0aW9uKCkuaGFzTmF0dXJlKAorCQkJCQkJCUNvcmVVdGlsLk5BVFVSRV9JRCkpIHsKKwkJCQkJCXJlc3VsdCA9IGdldFRleHQocmVmZXJlbmNlZCwgb3JpZ2luYWxMb2NhbGUsIGtleSk7CisJCQkJCQlpZiAoaXNWYWxpZChyZXN1bHQpKSB7CisJCQkJCQkJcmV0dXJuIHJlc3VsdDsKKwkJCQkJCX0KKwkJCQkJfQorCQkJCX0KKwkJCX0gY2F0Y2ggKENvcmVFeGNlcHRpb24gZSkgeworCQkJCUxPR0dFUi5lcnJvcigie30iLCBlKTsKKwkJCX0KKwkJfQorCQlyZXR1cm4gcmVzdWx0OworCX0KKworCXByaXZhdGUgYm9vbGVhbiBpc1ZhbGlkKFN0cmluZyByZXN1bHQpIHsKKwkJcmV0dXJuIHJlc3VsdCAhPSBudWxsICYmICFyZXN1bHQuZXF1YWxzKCIiKTsKKwl9CisKKwlwcml2YXRlIFByb2plY3REZXNjcmlwdGlvbiBnZXRQcm9qZWN0RGVzY3JpcHRpb24oSVByb2plY3QgcHJvamVjdCkgeworCQlQcm9qZWN0RGVzY3JpcHRpb24gZGVzY3JpcHRpb24gPSBjYWNoZS5nZXQocHJvamVjdCk7CisJCXJldHVybiBkZXNjcmlwdGlvbiAhPSBudWxsID8gZGVzY3JpcHRpb24gOiBFTVBZX1BST0pFQ1RfREVTQ1JJUFRJT047CisJfQorCisJQE92ZXJyaWRlCisJcHVibGljIHZvaWQgY2FjaGUoUHJvamVjdERlc2NyaXB0aW9uIGRlc2NyaXB0aW9uKSB7CisJCWNhY2hlLnB1dChkZXNjcmlwdGlvbi5nZXRQcm9qZWN0KCksIGRlc2NyaXB0aW9uKTsKKwl9CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgdm9pZCBjYWNoZShSZXNvdXJjZURlc2NyaXB0aW9uIGRlc2NyaXB0aW9uKSB7CisJCWlmIChjYWNoZS5jb250YWluc0tleShkZXNjcmlwdGlvbi5nZXRQcm9qZWN0KCkpKSB7CisJCQlQcm9qZWN0RGVzY3JpcHRpb24gcHJvamVjdERlc2MgPSBjYWNoZQorCQkJCQkuZ2V0KGRlc2NyaXB0aW9uLmdldFByb2plY3QoKSk7CisJCQlpZiAocHJvamVjdERlc2MgIT0gbnVsbCkgeworCQkJCXByb2plY3REZXNjLnB1dFJlc291cmNlKGRlc2NyaXB0aW9uKTsKKwkJCX0KKwkJfSBlbHNlIHsKKwkJCVByb2plY3REZXNjcmlwdGlvbiBwcm9qZWN0RGVzYyA9IG5ldyBQcm9qZWN0RGVzY3JpcHRpb24oCisJCQkJCWRlc2NyaXB0aW9uLmdldFByb2plY3QoKSk7CisJCQlwcm9qZWN0RGVzYy5wdXRSZXNvdXJjZShkZXNjcmlwdGlvbik7CisJCQljYWNoZShwcm9qZWN0RGVzYyk7CisJCX0KKwl9CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgdm9pZCByZW1vdmVSZXNvdXJjZShJUHJvamVjdCBwcm9qZWN0LCBMb2NhbGUgbG9jYWxlLCBJUGF0aCBsb2NhdGlvbikgeworCQlQcm9qZWN0RGVzY3JpcHRpb24gZGVmID0gZ2V0UHJvamVjdERlc2NyaXB0aW9uKHByb2plY3QpOworCQlkZWYucmVtb3ZlUmVzb3VyY2UobG9jYWxlLCBsb2NhdGlvbik7CisJfQorCisJQE92ZXJyaWRlCisJcHVibGljIFNldDxQcm9qZWN0RGVzY3JpcHRpb24+IGdldFByb2plY3REZXNjcmlwdGlvbnMoKSB7CisJCVNldDxQcm9qZWN0RGVzY3JpcHRpb24+IHJlc3VsdCA9IG5ldyBIYXNoU2V0PElJMThuUmVnaXN0cnkuUHJvamVjdERlc2NyaXB0aW9uPigKKwkJCQljYWNoZS52YWx1ZXMoKSk7CisJCXJldHVybiBDb2xsZWN0aW9ucy51bm1vZGlmaWFibGVTZXQocmVzdWx0KTsKKwl9CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgdm9pZCByZW1vdmVQcm9qZWN0KElQcm9qZWN0IHByb2plY3QpIHsKKwkJY2FjaGUucmVtb3ZlKHByb2plY3QpOworCX0KKworCS8qKgorCSAqIERlZmluZXMgaG93IHRoZSByZWdpc3RyeSBzaG91bGQgYmUgc2VhcmNoZWQuIEZvciBpbnN0YW5jZSB0aGUgb3JkZXJpbmcgb2YKKwkgKiBsb2NhbGVzLCB0aGUgb3JkZXJpbmcgb2YgcHJvamVjdHMsLi4uCisJICogCisJICogQGF1dGhvciBhZG1pbgorCSAqCisJICovCisJcHJpdmF0ZSBzdGF0aWMgY2xhc3MgQWNjZXNzUGF0aCB7CisJCXByaXZhdGUgTGlzdDxBY2Nlc3Nvcj4gYWNjZXNzb3JzID0gbmV3IExpbmtlZExpc3Q8STE4blJlZ2lzdHJ5LkFjY2Vzc29yPigpOworCisJCXB1YmxpYyBBY2Nlc3NQYXRoKCkgeworCQl9CisKKwkJcHVibGljIHZvaWQgYWRkQWNjZXNzb3IoQWNjZXNzb3IgYWNjZXNzb3IpIHsKKwkJCWFjY2Vzc29ycy5hZGQoYWNjZXNzb3IpOworCQl9CisKKwkJLyoqCisJCSAqIFJldHVybnMgYSBsaXN0IG9mIHByb3Bvc2Fscy4gSWYgdGhlIHNlYXJjaFZhbHVlIG1hdGNoZXMgcGFydHMgb2YgdGhlCisJCSAqIHZhbHVlIG9yIHRoZSBrZXkgZm9yIGFuIGkxOG4gcmVjb3JkLCBpdCBpcyBhZGRlZCB0byB0aGUgbGlzdCBvZgorCQkgKiBwcm9wb3NhbHMuCisJCSAqIAorCQkgKiBAcmV0dXJuCisJCSAqLworCQlwdWJsaWMgTGlzdDxQcm9wb3NhbD4gZ2V0Q29udGVudFByb3Bvc2FscygpIHsKKwkJCUxpc3Q8UHJvcG9zYWw+IHByb3Bvc2FscyA9IG5ldyBMaW5rZWRMaXN0PElJMThuUmVnaXN0cnkuUHJvcG9zYWw+KCk7CisJCQlmb3IgKEFjY2Vzc29yIGFjY2Vzc29yIDogYWNjZXNzb3JzKSB7CisJCQkJcHJvcG9zYWxzLmFkZEFsbChhY2Nlc3Nvci5nZXRQcm9wb3NhbHMoKSk7CisJCQl9CisKKwkJCXJldHVybiBwcm9wb3NhbHM7CisJCX0KKworCQkvKioKKwkJICogUmV0dXJucyBhIGxpc3Qgb2YgcHJvcG9zYWxzLiBUaGUgc2VhcmNoVmFsdWUgbWF0Y2hlcyB0aGUgZW50aXJlIGtleQorCQkgKiBmb3IgYW4gaTE4biByZWNvcmQuCisJCSAqIAorCQkgKiBAcmV0dXJuCisJCSAqLworCQlwdWJsaWMgTGlzdDxQcm9wb3NhbD4gZ2V0U3RyaWN0S2V5TWF0Y2hpbmdQcm9wb3NhbHMoKSB7CisJCQlMaXN0PFByb3Bvc2FsPiBwcm9wb3NhbHMgPSBuZXcgTGlua2VkTGlzdDxJSTE4blJlZ2lzdHJ5LlByb3Bvc2FsPigpOworCQkJZm9yIChBY2Nlc3NvciBhY2Nlc3NvciA6IGFjY2Vzc29ycykgeworCQkJCXByb3Bvc2Fscy5hZGRBbGwoYWNjZXNzb3IuZ2V0U3RyaWN0S2V5UHJvcG9zYWxzKCkpOworCQkJfQorCisJCQlyZXR1cm4gcHJvcG9zYWxzOworCQl9CisKKwkJLyoqCisJCSAqIEJlc3QgbWF0Y2ggcmV0dXJucyB0aGUgZmlyc3QgZm91bmQgdHJhbnNsYXRpb24uICJCZXN0IiBpcyBlbnN1cmVkIGJ5CisJCSAqIHRoZSBhY2Nlc3NvciBvcmRlci4gSWYgbm8gcHJvcG9zYWwgd2FzIGZvdW5kIHRoZW4gPGNvZGU+bnVsbDwvY29kZT4KKwkJICogaXMgcmV0dXJuZWQuCisJCSAqIAorCQkgKiBAcmV0dXJuCisJCSAqLworCQlwdWJsaWMgUHJvcG9zYWwgZ2V0QmVzdE1hdGNoKCkgeworCQkJZm9yIChBY2Nlc3NvciBhY2Nlc3NvciA6IGFjY2Vzc29ycykgeworCQkJCUxpc3Q8UHJvcG9zYWw+IHJlc3VsdCA9IGFjY2Vzc29yLmdldFN0cmljdEtleVByb3Bvc2FscygpOworCQkJCWlmICghcmVzdWx0LmlzRW1wdHkoKSkgeworCQkJCQlyZXR1cm4gcmVzdWx0LmdldCgwKTsKKwkJCQl9CisJCQl9CisKKwkJCXJldHVybiBudWxsOworCQl9CisJfQorCisJLyoqCisJICogVGhpcyBjbGFzcyB3aWxsIGFjY2VzcyB0aGUgcmVnaXN0cnkuCisJICovCisJcHJpdmF0ZSBjbGFzcyBBY2Nlc3NvciB7CisKKwkJcHJpdmF0ZSBmaW5hbCBJUHJvamVjdCBwcm9qZWN0OworCQlwcml2YXRlIGZpbmFsIExvY2FsZSBsb2NhbGU7CisJCXByaXZhdGUgZmluYWwgTWF0Y2hlciBtYXRjaGVyOworCQlAU3VwcHJlc3NXYXJuaW5ncygidW51c2VkIikKKwkJcHJpdmF0ZSBmaW5hbCBTdHJpbmcgc2VhcmNoVmFsdWU7CisJCXByaXZhdGUgZmluYWwgU3RyaW5nIGtleVBhY2thZ2U7CisJCXByaXZhdGUgZmluYWwgaW50IHByaW87CisKKwkJcHVibGljIEFjY2Vzc29yKElQcm9qZWN0IHByb2plY3QsIExvY2FsZSBsb2NhbGUsIGludCBwcmlvLAorCQkJCVN0cmluZyBzZWFyY2hWYWx1ZSwgU3RyaW5nIGtleVBhY2thZ2UsIE1hdGNoZXIgbWF0Y2hlcikgeworCQkJc3VwZXIoKTsKKwkJCXRoaXMucHJvamVjdCA9IHByb2plY3Q7CisJCQl0aGlzLmxvY2FsZSA9IGxvY2FsZTsKKwkJCXRoaXMuc2VhcmNoVmFsdWUgPSBzZWFyY2hWYWx1ZTsKKwkJCXRoaXMua2V5UGFja2FnZSA9IGtleVBhY2thZ2U7CisJCQl0aGlzLm1hdGNoZXIgPSBtYXRjaGVyOworCQkJdGhpcy5wcmlvID0gcHJpbzsKKwkJfQorCisJCS8qKgorCQkgKiBSZXR1cm5zIGFsbCBwcm9wb3NhbHMgZm9yIHRoZSBkZWZpbmVkIHZhbHVlcy4gQSByZXN1bHQgaXMgYWRkZWQgdG8KKwkJICogdGhlIGxpc3Qgb2YgcHJvcG9zYWxzLCBpZiBwYXJ0cyBvZiB0aGUga2V5IG1hdGNoIHRoZSBwYXR0ZXJuLiBNdXN0CisJCSAqIG5ldmVyIHJldHVybiA8Y29kZT5udWxsPC9jb2RlPi4KKwkJICogCisJCSAqIEByZXR1cm4KKwkJICovCisJCXB1YmxpYyBMaXN0PFByb3Bvc2FsPiBnZXRQcm9wb3NhbHMoKSB7CisJCQlQcm9qZWN0RGVzY3JpcHRpb24gcHJvamVjdERlc2MgPSBnZXRQcm9qZWN0RGVzY3JpcHRpb24ocHJvamVjdCk7CisJCQlpZiAocHJvamVjdERlc2MgPT0gSTE4blJlZ2lzdHJ5LkVNUFlfUFJPSkVDVF9ERVNDUklQVElPTikgeworCQkJCXJldHVybiBDb2xsZWN0aW9ucy5lbXB0eUxpc3QoKTsKKwkJCX0KKworCQkJTGlzdDxQcm9wb3NhbD4gcHJvcG9zYWxzID0gbmV3IExpbmtlZExpc3Q8SUkxOG5SZWdpc3RyeS5Qcm9wb3NhbD4oKTsKKwkJCUxpc3Q8UmVzb3VyY2VEZXNjcmlwdGlvbj4gZGVzY3MgPSBwcm9qZWN0RGVzYworCQkJCQkuZ2V0UmVzb3VyY2VEZXNjcmlwdGlvbnMobG9jYWxlKTsKKwkJCWZvciAoUmVzb3VyY2VEZXNjcmlwdGlvbiBkZXNjIDogZGVzY3MpIHsKKwkJCQlmb3IgKE1hcC5FbnRyeTxPYmplY3QsIE9iamVjdD4gZW50cnkgOiBkZXNjLmdldFByb3BlcnRpZXMoKQorCQkJCQkJLmVudHJ5U2V0KCkpIHsKKwkJCQkJaWYgKGtleVBhY2thZ2UgIT0gbnVsbAorCQkJCQkJCSYmICEoKFN0cmluZykgZW50cnkuZ2V0S2V5KCkpCisJCQkJCQkJCQkuc3RhcnRzV2l0aChrZXlQYWNrYWdlKSkgeworCQkJCQkJY29udGludWU7CisJCQkJCX0KKworCQkJCQlpZiAobWF0Y2hlciA9PSBudWxsCisJCQkJCQkJfHwgbWF0Y2hlci5yZXNldCgoKFN0cmluZykgZW50cnkuZ2V0VmFsdWUoKSkpCisJCQkJCQkJCQkuZmluZCgpCisJCQkJCQkJfHwgbWF0Y2hlci5yZXNldCgoKFN0cmluZykgZW50cnkuZ2V0S2V5KCkpKS5maW5kKCkpIHsKKwkJCQkJCXByb3Bvc2Fscy5hZGQobmV3IFByb3Bvc2FsKChTdHJpbmcpIGVudHJ5LmdldEtleSgpLAorCQkJCQkJCQkoU3RyaW5nKSBlbnRyeS5nZXRWYWx1ZSgpLCBkZXNjLCBwcmlvKSk7CisJCQkJCX0KKwkJCQl9CisJCQl9CisJCQlyZXR1cm4gcHJvcG9zYWxzOworCQl9CisKKwkJLyoqCisJCSAqIFJldHVybnMgYWxsIHByb3Bvc2FscyBmb3IgdGhlIGRlZmluZWQgdmFsdWVzLiBUaGUgbWF0Y2hlciBtdXN0IG1hdGNoCisJCSAqIHRoZSBnaXZlbiBrZXkuIE11c3QgbmV2ZXIgcmV0dXJuIDxjb2RlPm51bGw8L2NvZGU+LgorCQkgKiAKKwkJICogQHJldHVybgorCQkgKi8KKwkJcHVibGljIExpc3Q8UHJvcG9zYWw+IGdldFN0cmljdEtleVByb3Bvc2FscygpIHsKKwkJCVByb2plY3REZXNjcmlwdGlvbiBwcm9qZWN0RGVzYyA9IGdldFByb2plY3REZXNjcmlwdGlvbihwcm9qZWN0KTsKKwkJCWlmIChwcm9qZWN0RGVzYyA9PSBJMThuUmVnaXN0cnkuRU1QWV9QUk9KRUNUX0RFU0NSSVBUSU9OKSB7CisJCQkJcmV0dXJuIENvbGxlY3Rpb25zLmVtcHR5TGlzdCgpOworCQkJfQorCisJCQlMaXN0PFByb3Bvc2FsPiBwcm9wb3NhbHMgPSBuZXcgTGlua2VkTGlzdDxJSTE4blJlZ2lzdHJ5LlByb3Bvc2FsPigpOworCQkJTGlzdDxSZXNvdXJjZURlc2NyaXB0aW9uPiBkZXNjcyA9IHByb2plY3REZXNjCisJCQkJCS5nZXRSZXNvdXJjZURlc2NyaXB0aW9ucyhsb2NhbGUpOworCQkJZm9yIChSZXNvdXJjZURlc2NyaXB0aW9uIGRlc2MgOiBkZXNjcykgeworCQkJCWZvciAoTWFwLkVudHJ5PE9iamVjdCwgT2JqZWN0PiBlbnRyeSA6IGRlc2MuZ2V0UHJvcGVydGllcygpCisJCQkJCQkuZW50cnlTZXQoKSkgeworCQkJCQlpZiAoa2V5UGFja2FnZSAhPSBudWxsCisJCQkJCQkJJiYgISgoU3RyaW5nKSBlbnRyeS5nZXRLZXkoKSkKKwkJCQkJCQkJCS5zdGFydHNXaXRoKGtleVBhY2thZ2UpKSB7CisJCQkJCQljb250aW51ZTsKKwkJCQkJfQorCisJCQkJCWlmIChtYXRjaGVyID09IG51bGwKKwkJCQkJCQl8fCBtYXRjaGVyLnJlc2V0KCgoU3RyaW5nKSBlbnRyeS5nZXRLZXkoKSkpCisJCQkJCQkJCQkubWF0Y2hlcygpKSB7CisJCQkJCQlwcm9wb3NhbHMuYWRkKG5ldyBQcm9wb3NhbCgoU3RyaW5nKSBlbnRyeS5nZXRLZXkoKSwKKwkJCQkJCQkJKFN0cmluZykgZW50cnkuZ2V0VmFsdWUoKSwgZGVzYywgcHJpbykpOworCQkJCQl9CisJCQkJfQorCQkJfQorCQkJcmV0dXJuIHByb3Bvc2FsczsKKwkJfQorCX0KK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3MvLnByb2plY3QgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLmhlYWRsZXNzLy5wcm9qZWN0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmQxNGUxNzgKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLmhlYWRsZXNzLy5wcm9qZWN0CkBAIC0wLDAgKzEsMzQgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8cHJvamVjdERlc2NyaXB0aW9uPgorCTxuYW1lPm9yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3M8L25hbWU+CisJPGNvbW1lbnQ+PC9jb21tZW50PgorCTxwcm9qZWN0cz4KKwk8L3Byb2plY3RzPgorCTxidWlsZFNwZWM+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS54dGV4dC51aS5zaGFyZWQueHRleHRCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5GZWF0dXJlQnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuc29uYXJsaW50LmVjbGlwc2UuY29yZS5zb25hcmxpbnRCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLm0yZS5jb3JlLm1hdmVuMkJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCTwvYnVpbGRTcGVjPgorCTxuYXR1cmVzPgorCQk8bmF0dXJlPm9yZy5lY2xpcHNlLnh0ZXh0LnVpLnNoYXJlZC54dGV4dE5hdHVyZTwvbmF0dXJlPgorCQk8bmF0dXJlPm9yZy5lY2xpcHNlLm0yZS5jb3JlLm1hdmVuMk5hdHVyZTwvbmF0dXJlPgorCQk8bmF0dXJlPm9yZy5lY2xpcHNlLnBkZS5GZWF0dXJlTmF0dXJlPC9uYXR1cmU+CisJPC9uYXR1cmVzPgorPC9wcm9qZWN0RGVzY3JpcHRpb24+CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLmhlYWRsZXNzL0xJQ0VOU0UudHh0IGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS5oZWFkbGVzcy9MSUNFTlNFLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mZjQyYWQ0Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS5oZWFkbGVzcy9MSUNFTlNFLnR4dApAQCAtMCwwICsxLDE2MSBAQAorRWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtdiAxLjAKKworVEhFIEFDQ09NUEFOWUlORyBQUk9HUkFNIElTIFBST1ZJREVEIFVOREVSIFRIRSBURVJNUyBPRiBUSElTIEVDTElQU0UgUFVCTElDIExJQ0VOU0UgKCJBR1JFRU1FTlQiKS4gQU5ZIFVTRSwgUkVQUk9EVUNUSU9OCitPUiBESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gQ09OU1RJVFVURVMgUkVDSVBJRU5UJ1MgQUNDRVBUQU5DRSBPRiBUSElTIEFHUkVFTUVOVC4KKworMS4gREVGSU5JVElPTlMKKworIkNvbnRyaWJ1dGlvbiIgbWVhbnM6CisKK2EpIGluIHRoZSBjYXNlIG9mIHRoZSBpbml0aWFsIENvbnRyaWJ1dG9yLCB0aGUgaW5pdGlhbCBjb2RlIGFuZCBkb2N1bWVudGF0aW9uIGRpc3RyaWJ1dGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBhbmQKKworYikgaW4gdGhlIGNhc2Ugb2YgZWFjaCBzdWJzZXF1ZW50IENvbnRyaWJ1dG9yOgorCitpKSBjaGFuZ2VzIHRvIHRoZSBQcm9ncmFtLCBhbmQKKworaWkpIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbTsKKword2hlcmUgc3VjaCBjaGFuZ2VzIGFuZC9vciBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gb3JpZ2luYXRlIGZyb20gYW5kIGFyZSBkaXN0cmlidXRlZCBieSB0aGF0IHBhcnRpY3VsYXIgQ29udHJpYnV0b3IuCitBIENvbnRyaWJ1dGlvbiAnb3JpZ2luYXRlcycgZnJvbSBhIENvbnRyaWJ1dG9yIGlmIGl0IHdhcyBhZGRlZCB0byB0aGUgUHJvZ3JhbSBieSBzdWNoIENvbnRyaWJ1dG9yIGl0c2VsZiBvciBhbnlvbmUKK2FjdGluZyBvbiBzdWNoIENvbnRyaWJ1dG9yJ3MgYmVoYWxmLiBDb250cmlidXRpb25zIGRvIG5vdCBpbmNsdWRlIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbSB3aGljaDogKGkpIGFyZSBzZXBhcmF0ZQorbW9kdWxlcyBvZiBzb2Z0d2FyZSBkaXN0cmlidXRlZCBpbiBjb25qdW5jdGlvbiB3aXRoIHRoZSBQcm9ncmFtIHVuZGVyIHRoZWlyIG93biBsaWNlbnNlIGFncmVlbWVudCwgYW5kIChpaSkgYXJlIG5vdAorZGVyaXZhdGl2ZSB3b3JrcyBvZiB0aGUgUHJvZ3JhbS4KKworIkNvbnRyaWJ1dG9yIiBtZWFucyBhbnkgcGVyc29uIG9yIGVudGl0eSB0aGF0IGRpc3RyaWJ1dGVzIHRoZSBQcm9ncmFtLgorCisiTGljZW5zZWQgUGF0ZW50cyAiIG1lYW4gcGF0ZW50IGNsYWltcyBsaWNlbnNhYmxlIGJ5IGEgQ29udHJpYnV0b3Igd2hpY2ggYXJlIG5lY2Vzc2FyaWx5IGluZnJpbmdlZCBieSB0aGUgdXNlIG9yIHNhbGUgb2YKK2l0cyBDb250cmlidXRpb24gYWxvbmUgb3Igd2hlbiBjb21iaW5lZCB3aXRoIHRoZSBQcm9ncmFtLgorCisiUHJvZ3JhbSIgbWVhbnMgdGhlIENvbnRyaWJ1dGlvbnMgZGlzdHJpYnV0ZWQgaW4gYWNjb3JkYW5jZSB3aXRoIHRoaXMgQWdyZWVtZW50LgorCisiUmVjaXBpZW50IiBtZWFucyBhbnlvbmUgd2hvIHJlY2VpdmVzIHRoZSBQcm9ncmFtIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBpbmNsdWRpbmcgYWxsIENvbnRyaWJ1dG9ycy4KKworMi4gR1JBTlQgT0YgUklHSFRTCisKK2EpIFN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLAorcm95YWx0eS1mcmVlIGNvcHlyaWdodCBsaWNlbnNlIHRvIHJlcHJvZHVjZSwgcHJlcGFyZSBkZXJpdmF0aXZlIHdvcmtzIG9mLCBwdWJsaWNseSBkaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBkaXN0cmlidXRlCithbmQgc3VibGljZW5zZSB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgYW5kIHN1Y2ggZGVyaXZhdGl2ZSB3b3JrcywgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlCitmb3JtLgorCitiKSBTdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwKK3JveWFsdHktZnJlZSBwYXRlbnQgbGljZW5zZSB1bmRlciBMaWNlbnNlZCBQYXRlbnRzIHRvIG1ha2UsIHVzZSwgc2VsbCwgb2ZmZXIgdG8gc2VsbCwgaW1wb3J0IGFuZCBvdGhlcndpc2UgdHJhbnNmZXIgdGhlCitDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUgZm9ybS4gVGhpcyBwYXRlbnQgbGljZW5zZSBzaGFsbCBhcHBseSB0byB0aGUKK2NvbWJpbmF0aW9uIG9mIHRoZSBDb250cmlidXRpb24gYW5kIHRoZSBQcm9ncmFtIGlmLCBhdCB0aGUgdGltZSB0aGUgQ29udHJpYnV0aW9uIGlzIGFkZGVkIGJ5IHRoZSBDb250cmlidXRvciwgc3VjaAorYWRkaXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBjYXVzZXMgc3VjaCBjb21iaW5hdGlvbiB0byBiZSBjb3ZlcmVkIGJ5IHRoZSBMaWNlbnNlZCBQYXRlbnRzLiBUaGUgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgbm90CithcHBseSB0byBhbnkgb3RoZXIgY29tYmluYXRpb25zIHdoaWNoIGluY2x1ZGUgdGhlIENvbnRyaWJ1dGlvbi4gTm8gaGFyZHdhcmUgcGVyIHNlIGlzIGxpY2Vuc2VkIGhlcmV1bmRlci4KKworYykgUmVjaXBpZW50IHVuZGVyc3RhbmRzIHRoYXQgYWx0aG91Z2ggZWFjaCBDb250cmlidXRvciBncmFudHMgdGhlIGxpY2Vuc2VzIHRvIGl0cyBDb250cmlidXRpb25zIHNldCBmb3J0aCBoZXJlaW4sIG5vCithc3N1cmFuY2VzIGFyZSBwcm92aWRlZCBieSBhbnkgQ29udHJpYnV0b3IgdGhhdCB0aGUgUHJvZ3JhbSBkb2VzIG5vdCBpbmZyaW5nZSB0aGUgcGF0ZW50IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQorcmlnaHRzIG9mIGFueSBvdGhlciBlbnRpdHkuIEVhY2ggQ29udHJpYnV0b3IgZGlzY2xhaW1zIGFueSBsaWFiaWxpdHkgdG8gUmVjaXBpZW50IGZvciBjbGFpbXMgYnJvdWdodCBieSBhbnkgb3RoZXIgZW50aXR5CitiYXNlZCBvbiBpbmZyaW5nZW1lbnQgb2YgaW50ZWxsZWN0dWFsIHByb3BlcnR5IHJpZ2h0cyBvciBvdGhlcndpc2UuIEFzIGEgY29uZGl0aW9uIHRvIGV4ZXJjaXNpbmcgdGhlIHJpZ2h0cyBhbmQKK2xpY2Vuc2VzIGdyYW50ZWQgaGVyZXVuZGVyLCBlYWNoIFJlY2lwaWVudCBoZXJlYnkgYXNzdW1lcyBzb2xlIHJlc3BvbnNpYmlsaXR5IHRvIHNlY3VyZSBhbnkgb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5CityaWdodHMgbmVlZGVkLCBpZiBhbnkuIEZvciBleGFtcGxlLCBpZiBhIHRoaXJkIHBhcnR5IHBhdGVudCBsaWNlbnNlIGlzIHJlcXVpcmVkIHRvIGFsbG93IFJlY2lwaWVudCB0byBkaXN0cmlidXRlIHRoZQorUHJvZ3JhbSwgaXQgaXMgUmVjaXBpZW50J3MgcmVzcG9uc2liaWxpdHkgdG8gYWNxdWlyZSB0aGF0IGxpY2Vuc2UgYmVmb3JlIGRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbS4KKworZCkgRWFjaCBDb250cmlidXRvciByZXByZXNlbnRzIHRoYXQgdG8gaXRzIGtub3dsZWRnZSBpdCBoYXMgc3VmZmljaWVudCBjb3B5cmlnaHQgcmlnaHRzIGluIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgdG8KK2dyYW50IHRoZSBjb3B5cmlnaHQgbGljZW5zZSBzZXQgZm9ydGggaW4gdGhpcyBBZ3JlZW1lbnQuCisKKzMuIFJFUVVJUkVNRU5UUworCitBIENvbnRyaWJ1dG9yIG1heSBjaG9vc2UgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbSBpbiBvYmplY3QgY29kZSBmb3JtIHVuZGVyIGl0cyBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIHByb3ZpZGVkIHRoYXQ6CisKK2EpIGl0IGNvbXBsaWVzIHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50OyBhbmQKKworYikgaXRzIGxpY2Vuc2UgYWdyZWVtZW50OgorCitpKSBlZmZlY3RpdmVseSBkaXNjbGFpbXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIHdhcnJhbnRpZXMgYW5kIGNvbmRpdGlvbnMsIGV4cHJlc3MgYW5kIGltcGxpZWQsIGluY2x1ZGluZword2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIHRpdGxlIGFuZCBub24taW5mcmluZ2VtZW50LCBhbmQgaW1wbGllZCB3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgbWVyY2hhbnRhYmlsaXR5IGFuZAorZml0bmVzcyBmb3IgYSBwYXJ0aWN1bGFyIHB1cnBvc2U7CisKK2lpKSBlZmZlY3RpdmVseSBleGNsdWRlcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgbGlhYmlsaXR5IGZvciBkYW1hZ2VzLCBpbmNsdWRpbmcgZGlyZWN0LCBpbmRpcmVjdCwgc3BlY2lhbCwKK2luY2lkZW50YWwgYW5kIGNvbnNlcXVlbnRpYWwgZGFtYWdlcywgc3VjaCBhcyBsb3N0IHByb2ZpdHM7CisKK2lpaSkgc3RhdGVzIHRoYXQgYW55IHByb3Zpc2lvbnMgd2hpY2ggZGlmZmVyIGZyb20gdGhpcyBBZ3JlZW1lbnQgYXJlIG9mZmVyZWQgYnkgdGhhdCBDb250cmlidXRvciBhbG9uZSBhbmQgbm90IGJ5IGFueQorb3RoZXIgcGFydHk7IGFuZAorCitpdikgc3RhdGVzIHRoYXQgc291cmNlIGNvZGUgZm9yIHRoZSBQcm9ncmFtIGlzIGF2YWlsYWJsZSBmcm9tIHN1Y2ggQ29udHJpYnV0b3IsIGFuZCBpbmZvcm1zIGxpY2Vuc2VlcyBob3cgdG8gb2J0YWluIGl0CitpbiBhIHJlYXNvbmFibGUgbWFubmVyIG9uIG9yIHRocm91Z2ggYSBtZWRpdW0gY3VzdG9tYXJpbHkgdXNlZCBmb3Igc29mdHdhcmUgZXhjaGFuZ2UuCisKK1doZW4gdGhlIFByb2dyYW0gaXMgbWFkZSBhdmFpbGFibGUgaW4gc291cmNlIGNvZGUgZm9ybToKKworYSkgaXQgbXVzdCBiZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGlzIEFncmVlbWVudDsgYW5kCisKK2IpIGEgY29weSBvZiB0aGlzIEFncmVlbWVudCBtdXN0IGJlIGluY2x1ZGVkIHdpdGggZWFjaCBjb3B5IG9mIHRoZSBQcm9ncmFtLgorCitDb250cmlidXRvcnMgbWF5IG5vdCByZW1vdmUgb3IgYWx0ZXIgYW55IGNvcHlyaWdodCBub3RpY2VzIGNvbnRhaW5lZCB3aXRoaW4gdGhlIFByb2dyYW0uCisKK0VhY2ggQ29udHJpYnV0b3IgbXVzdCBpZGVudGlmeSBpdHNlbGYgYXMgdGhlIG9yaWdpbmF0b3Igb2YgaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCBpbiBhIG1hbm5lciB0aGF0IHJlYXNvbmFibHkgYWxsb3dzCitzdWJzZXF1ZW50IFJlY2lwaWVudHMgdG8gaWRlbnRpZnkgdGhlIG9yaWdpbmF0b3Igb2YgdGhlIENvbnRyaWJ1dGlvbi4KKworNC4gQ09NTUVSQ0lBTCBESVNUUklCVVRJT04KKworQ29tbWVyY2lhbCBkaXN0cmlidXRvcnMgb2Ygc29mdHdhcmUgbWF5IGFjY2VwdCBjZXJ0YWluIHJlc3BvbnNpYmlsaXRpZXMgd2l0aCByZXNwZWN0IHRvIGVuZCB1c2VycywgYnVzaW5lc3MgcGFydG5lcnMgYW5kCit0aGUgbGlrZS4gV2hpbGUgdGhpcyBsaWNlbnNlIGlzIGludGVuZGVkIHRvIGZhY2lsaXRhdGUgdGhlIGNvbW1lcmNpYWwgdXNlIG9mIHRoZSBQcm9ncmFtLCB0aGUgQ29udHJpYnV0b3Igd2hvIGluY2x1ZGVzCit0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZyBzaG91bGQgZG8gc28gaW4gYSBtYW5uZXIgd2hpY2ggZG9lcyBub3QgY3JlYXRlIHBvdGVudGlhbCBsaWFiaWxpdHkgZm9yCitvdGhlciBDb250cmlidXRvcnMuIFRoZXJlZm9yZSwgaWYgYSBDb250cmlidXRvciBpbmNsdWRlcyB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgc3VjaCBDb250cmlidXRvcgorKCJDb21tZXJjaWFsIENvbnRyaWJ1dG9yIikgaGVyZWJ5IGFncmVlcyB0byBkZWZlbmQgYW5kIGluZGVtbmlmeSBldmVyeSBvdGhlciBDb250cmlidXRvciAoIkluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIikKK2FnYWluc3QgYW55IGxvc3NlcywgZGFtYWdlcyBhbmQgY29zdHMgKGNvbGxlY3RpdmVseSAiTG9zc2VzIikgYXJpc2luZyBmcm9tIGNsYWltcywgbGF3c3VpdHMgYW5kIG90aGVyIGxlZ2FsIGFjdGlvbnMKK2Jyb3VnaHQgYnkgYSB0aGlyZCBwYXJ0eSBhZ2FpbnN0IHRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciB0byB0aGUgZXh0ZW50IGNhdXNlZCBieSB0aGUgYWN0cyBvciBvbWlzc2lvbnMgb2Ygc3VjaAorQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiBjb25uZWN0aW9uIHdpdGggaXRzIGRpc3RyaWJ1dGlvbiBvZiB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZy4gVGhlCitvYmxpZ2F0aW9ucyBpbiB0aGlzIHNlY3Rpb24gZG8gbm90IGFwcGx5IHRvIGFueSBjbGFpbXMgb3IgTG9zc2VzIHJlbGF0aW5nIHRvIGFueSBhY3R1YWwgb3IgYWxsZWdlZCBpbnRlbGxlY3R1YWwKK3Byb3BlcnR5IGluZnJpbmdlbWVudC4gSW4gb3JkZXIgdG8gcXVhbGlmeSwgYW4gSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbXVzdDogYSkgcHJvbXB0bHkgbm90aWZ5IHRoZSBDb21tZXJjaWFsCitDb250cmlidXRvciBpbiB3cml0aW5nIG9mIHN1Y2ggY2xhaW0sIGFuZCBiKSBhbGxvdyB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB0byBjb250cm9sLCBhbmQgY29vcGVyYXRlIHdpdGggdGhlCitDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluLCB0aGUgZGVmZW5zZSBhbmQgYW55IHJlbGF0ZWQgc2V0dGxlbWVudCBuZWdvdGlhdGlvbnMuIFRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciBtYXkKKyBwYXJ0aWNpcGF0ZSBpbiBhbnkgc3VjaCBjbGFpbSBhdCBpdHMgb3duIGV4cGVuc2UuCisKK0ZvciBleGFtcGxlLCBhIENvbnRyaWJ1dG9yIG1pZ2h0IGluY2x1ZGUgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIFByb2R1Y3QgWC4gVGhhdCBDb250cmlidXRvciBpcwordGhlbiBhIENvbW1lcmNpYWwgQ29udHJpYnV0b3IuIElmIHRoYXQgQ29tbWVyY2lhbCBDb250cmlidXRvciB0aGVuIG1ha2VzIHBlcmZvcm1hbmNlIGNsYWltcywgb3Igb2ZmZXJzIHdhcnJhbnRpZXMKK3JlbGF0ZWQgdG8gUHJvZHVjdCBYLCB0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMgYXJlIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvcidzIHJlc3BvbnNpYmlsaXR5IGFsb25lLgorVW5kZXIgdGhpcyBzZWN0aW9uLCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB3b3VsZCBoYXZlIHRvIGRlZmVuZCBjbGFpbXMgYWdhaW5zdCB0aGUgb3RoZXIgQ29udHJpYnV0b3JzIHJlbGF0ZWQgdG8KK3Rob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcywgYW5kIGlmIGEgY291cnQgcmVxdWlyZXMgYW55IG90aGVyIENvbnRyaWJ1dG9yIHRvIHBheSBhbnkgZGFtYWdlcyBhcyBhIHJlc3VsdCwKK3RoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIG11c3QgcGF5IHRob3NlIGRhbWFnZXMuCisKKzUuIE5PIFdBUlJBTlRZCisKK0VYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMgQUdSRUVNRU5ULCBUSEUgUFJPR1JBTSBJUyBQUk9WSURFRCBPTiBBTiAiQVMgSVMiIEJBU0lTLCBXSVRIT1VUIFdBUlJBTlRJRVMgT1IKK0NPTkRJVElPTlMgT0YgQU5ZIEtJTkQsIEVJVEhFUiBFWFBSRVNTIE9SIElNUExJRUQgSU5DTFVESU5HLCBXSVRIT1VUIExJTUlUQVRJT04sIEFOWSBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMgT0YgVElUTEUsCitOT04tSU5GUklOR0VNRU5ULCBNRVJDSEFOVEFCSUxJVFkgT1IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuIEVhY2ggUmVjaXBpZW50IGlzIHNvbGVseSByZXNwb25zaWJsZSBmb3IKK2RldGVybWluaW5nIHRoZSBhcHByb3ByaWF0ZW5lc3Mgb2YgdXNpbmcgYW5kIGRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbSBhbmQgYXNzdW1lcyBhbGwgcmlza3MgYXNzb2NpYXRlZCB3aXRoIGl0cworZXhlcmNpc2Ugb2YgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50ICwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgcmlza3MgYW5kIGNvc3RzIG9mIHByb2dyYW0gZXJyb3JzLCBjb21wbGlhbmNlCit3aXRoIGFwcGxpY2FibGUgbGF3cywgZGFtYWdlIHRvIG9yIGxvc3Mgb2YgZGF0YSwgcHJvZ3JhbXMgb3IgZXF1aXBtZW50LCBhbmQgdW5hdmFpbGFiaWxpdHkgb3IgaW50ZXJydXB0aW9uIG9mIG9wZXJhdGlvbnMuCisKKzYuIERJU0NMQUlNRVIgT0YgTElBQklMSVRZCisKK0VYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMgQUdSRUVNRU5ULCBORUlUSEVSIFJFQ0lQSUVOVCBOT1IgQU5ZIENPTlRSSUJVVE9SUyBTSEFMTCBIQVZFIEFOWSBMSUFCSUxJVFkgRk9SIEFOWQorRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORyBXSVRIT1VUIExJTUlUQVRJT04gTE9TVCBQUk9GSVRTKSwKK0hPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IKK09USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBPUiBUSEUgRVhFUkNJU0UgT0YgQU5ZIFJJR0hUUyBHUkFOVEVECitIRVJFVU5ERVIsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0VTLgorCis3LiBHRU5FUkFMCisKK0lmIGFueSBwcm92aXNpb24gb2YgdGhpcyBBZ3JlZW1lbnQgaXMgaW52YWxpZCBvciB1bmVuZm9yY2VhYmxlIHVuZGVyIGFwcGxpY2FibGUgbGF3LCBpdCBzaGFsbCBub3QgYWZmZWN0IHRoZSB2YWxpZGl0eSBvcgorZW5mb3JjZWFiaWxpdHkgb2YgdGhlIHJlbWFpbmRlciBvZiB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGFuZCB3aXRob3V0IGZ1cnRoZXIgYWN0aW9uIGJ5IHRoZSBwYXJ0aWVzIGhlcmV0bywgc3VjaAorcHJvdmlzaW9uIHNoYWxsIGJlIHJlZm9ybWVkIHRvIHRoZSBtaW5pbXVtIGV4dGVudCBuZWNlc3NhcnkgdG8gbWFrZSBzdWNoIHByb3Zpc2lvbiB2YWxpZCBhbmQgZW5mb3JjZWFibGUuCisKK0lmIFJlY2lwaWVudCBpbnN0aXR1dGVzIHBhdGVudCBsaXRpZ2F0aW9uIGFnYWluc3QgYW55IGVudGl0eSAoaW5jbHVkaW5nIGEgY3Jvc3MtY2xhaW0gb3IgY291bnRlcmNsYWltIGluIGEgbGF3c3VpdCkKK2FsbGVnaW5nIHRoYXQgdGhlIFByb2dyYW0gaXRzZWxmIChleGNsdWRpbmcgY29tYmluYXRpb25zIG9mIHRoZSBQcm9ncmFtIHdpdGggb3RoZXIgc29mdHdhcmUgb3IgaGFyZHdhcmUpIGluZnJpbmdlcyBzdWNoCitSZWNpcGllbnQncyBwYXRlbnQocyksIHRoZW4gc3VjaCBSZWNpcGllbnQncyByaWdodHMgZ3JhbnRlZCB1bmRlciBTZWN0aW9uIDIoYikgc2hhbGwgdGVybWluYXRlIGFzIG9mIHRoZSBkYXRlIHN1Y2gKK2xpdGlnYXRpb24gaXMgZmlsZWQuCisKK0FsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgc2hhbGwgdGVybWluYXRlIGlmIGl0IGZhaWxzIHRvIGNvbXBseSB3aXRoIGFueSBvZiB0aGUgbWF0ZXJpYWwgdGVybXMgb3IKK2NvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQgYW5kIGRvZXMgbm90IGN1cmUgc3VjaCBmYWlsdXJlIGluIGEgcmVhc29uYWJsZSBwZXJpb2Qgb2YgdGltZSBhZnRlciBiZWNvbWluZyBhd2FyZSBvZiBzdWNoCitub25jb21wbGlhbmNlLiBJZiBhbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHRlcm1pbmF0ZSwgUmVjaXBpZW50IGFncmVlcyB0byBjZWFzZSB1c2UgYW5kIGRpc3RyaWJ1dGlvbgorb2YgdGhlIFByb2dyYW0gYXMgc29vbiBhcyByZWFzb25hYmx5IHByYWN0aWNhYmxlLiBIb3dldmVyLCBSZWNpcGllbnQncyBvYmxpZ2F0aW9ucyB1bmRlciB0aGlzIEFncmVlbWVudCBhbmQgYW55IGxpY2Vuc2VzCisgZ3JhbnRlZCBieSBSZWNpcGllbnQgcmVsYXRpbmcgdG8gdGhlIFByb2dyYW0gc2hhbGwgY29udGludWUgYW5kIHN1cnZpdmUuCisKK0V2ZXJ5b25lIGlzIHBlcm1pdHRlZCB0byBjb3B5IGFuZCBkaXN0cmlidXRlIGNvcGllcyBvZiB0aGlzIEFncmVlbWVudCwgYnV0IGluIG9yZGVyIHRvIGF2b2lkIGluY29uc2lzdGVuY3kgdGhlIEFncmVlbWVudAoraXMgY29weXJpZ2h0ZWQgYW5kIG1heSBvbmx5IGJlIG1vZGlmaWVkIGluIHRoZSBmb2xsb3dpbmcgbWFubmVyLiBUaGUgQWdyZWVtZW50IFN0ZXdhcmQgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHB1Ymxpc2gKK25ldyB2ZXJzaW9ucyAoaW5jbHVkaW5nIHJldmlzaW9ucykgb2YgdGhpcyBBZ3JlZW1lbnQgZnJvbSB0aW1lIHRvIHRpbWUuIE5vIG9uZSBvdGhlciB0aGFuIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCBoYXMgdGhlCityaWdodCB0byBtb2RpZnkgdGhpcyBBZ3JlZW1lbnQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgdGhlIGluaXRpYWwgQWdyZWVtZW50IFN0ZXdhcmQuIFRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWF5Cithc3NpZ24gdGhlIHJlc3BvbnNpYmlsaXR5IHRvIHNlcnZlIGFzIHRoZSBBZ3JlZW1lbnQgU3Rld2FyZCB0byBhIHN1aXRhYmxlIHNlcGFyYXRlIGVudGl0eS4gRWFjaCBuZXcgdmVyc2lvbiBvZiB0aGUKK0FncmVlbWVudCB3aWxsIGJlIGdpdmVuIGEgZGlzdGluZ3Vpc2hpbmcgdmVyc2lvbiBudW1iZXIuIFRoZSBQcm9ncmFtIChpbmNsdWRpbmcgQ29udHJpYnV0aW9ucykgbWF5IGFsd2F5cyBiZQorZGlzdHJpYnV0ZWQgc3ViamVjdCB0byB0aGUgdmVyc2lvbiBvZiB0aGUgQWdyZWVtZW50IHVuZGVyIHdoaWNoIGl0IHdhcyByZWNlaXZlZC4gSW4gYWRkaXRpb24sIGFmdGVyIGEgbmV3IHZlcnNpb24gb2YKK3RoZSBBZ3JlZW1lbnQgaXMgcHVibGlzaGVkLCBDb250cmlidXRvciBtYXkgZWxlY3QgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbSAoaW5jbHVkaW5nIGl0cyBDb250cmlidXRpb25zKSB1bmRlciB0aGUKK25ldyB2ZXJzaW9uLiBFeGNlcHQgYXMgZXhwcmVzc2x5IHN0YXRlZCBpbiBTZWN0aW9ucyAyKGEpIGFuZCAyKGIpIGFib3ZlLCBSZWNpcGllbnQgcmVjZWl2ZXMgbm8gcmlnaHRzIG9yIGxpY2Vuc2VzIHRvCit0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IG9mIGFueSBDb250cmlidXRvciB1bmRlciB0aGlzIEFncmVlbWVudCwgd2hldGhlciBleHByZXNzbHksIGJ5IGltcGxpY2F0aW9uLCBlc3RvcHBlbCBvcgorb3RoZXJ3aXNlLiBBbGwgcmlnaHRzIGluIHRoZSBQcm9ncmFtIG5vdCBleHByZXNzbHkgZ3JhbnRlZCB1bmRlciB0aGlzIEFncmVlbWVudCBhcmUgcmVzZXJ2ZWQuCisKK1RoaXMgQWdyZWVtZW50IGlzIGdvdmVybmVkIGJ5IHRoZSBsYXdzIG9mIHRoZSBTdGF0ZSBvZiBOZXcgWW9yayBhbmQgdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBsYXdzIG9mIHRoZSBVbml0ZWQgU3RhdGVzCitvZiBBbWVyaWNhLiBObyBwYXJ0eSB0byB0aGlzIEFncmVlbWVudCB3aWxsIGJyaW5nIGEgbGVnYWwgYWN0aW9uIHVuZGVyIHRoaXMgQWdyZWVtZW50IG1vcmUgdGhhbiBvbmUgeWVhciBhZnRlciB0aGUgY2F1c2UKK29mIGFjdGlvbiBhcm9zZS4gRWFjaCBwYXJ0eSB3YWl2ZXMgaXRzIHJpZ2h0cyB0byBhIGp1cnkgdHJpYWwgaW4gYW55IHJlc3VsdGluZyBsaXRpZ2F0aW9uLgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3MvYnVpbGQucHJvcGVydGllcyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3MvYnVpbGQucHJvcGVydGllcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5iZmI3ZjZiCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS5oZWFkbGVzcy9idWlsZC5wcm9wZXJ0aWVzCkBAIC0wLDAgKzEsNiBAQAorYmluLmluY2x1ZGVzID0gZmVhdHVyZS54bWwsXAorICAgICAgICAgICAgICAgZmVhdHVyZS5wcm9wZXJ0aWVzLFwKKyAgICAgICAgICAgICAgIExJQ0VOU0UudHh0LFwKKyAgICAgICAgICAgICAgIGxpY2Vuc2UuaHRtbAorc3JjLmluY2x1ZGVzID0gTElDRU5TRS50eHQsXAorICAgICAgICAgICAgICAgbGljZW5zZS5odG1sCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLmhlYWRsZXNzL2VwbC12MTAuaHRtbCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3MvZXBsLXYxMC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmIzOThhY2MKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLmhlYWRsZXNzL2VwbC12MTAuaHRtbApAQCAtMCwwICsxLDI1OSBAQAorPCEtLT94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iSVNPLTg4NTktMSIgPy0tPgorPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgVHJhbnNpdGlvbmFsLy9FTiIgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXRyYW5zaXRpb25hbC5kdGQiPgorPGh0bWwgeG1sbnM9Imh0dHA6Ly93d3cudzMub3JnLzE5OTkveGh0bWwiPjxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9SVNPLTg4NTktMSI+Cis8dGl0bGU+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIFZlcnNpb24gMS4wPC90aXRsZT4KKzxzdHlsZSB0eXBlPSJ0ZXh0L2NzcyI+CisgIGJvZHkgeworICAgIHNpemU6IDguNWluIDExLjBpbjsKKyAgICBtYXJnaW46IDAuMjVpbiAwLjVpbiAwLjI1aW4gMC41aW47CisgICAgdGFiLWludGVydmFsOiAwLjVpbjsKKyAgICB9CisgIHAgeyAgCQorICAgIG1hcmdpbi1sZWZ0OiBhdXRvOworICAgIG1hcmdpbi10b3A6ICAwLjVlbTsKKyAgICBtYXJnaW4tYm90dG9tOiAwLjVlbTsKKyAgICB9CisgIHAubGlzdCB7CisgIAltYXJnaW4tbGVmdDogMC41aW47CisgICAgbWFyZ2luLXRvcDogIDAuMDVlbTsKKyAgICBtYXJnaW4tYm90dG9tOiAwLjA1ZW07CisgICAgfQorICA8L3N0eWxlPgorCis8L2hlYWQ+CisKKzxib2R5IGxhbmc9IkVOLVVTIj4KKworPGgyPkVjbGlwc2UgUHVibGljIExpY2Vuc2UgLSB2IDEuMDwvaDI+CisKKzxwPlRIRSBBQ0NPTVBBTllJTkcgUFJPR1JBTSBJUyBQUk9WSURFRCBVTkRFUiBUSEUgVEVSTVMgT0YgVEhJUyBFQ0xJUFNFCitQVUJMSUMgTElDRU5TRSAoIkFHUkVFTUVOVCIpLiBBTlkgVVNFLCBSRVBST0RVQ1RJT04gT1IKK0RJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBDT05TVElUVVRFUyBSRUNJUElFTlQnUyBBQ0NFUFRBTkNFIE9GIFRISVMKK0FHUkVFTUVOVC48L3A+CisKKzxwPjxiPjEuIERFRklOSVRJT05TPC9iPjwvcD4KKworPHA+IkNvbnRyaWJ1dGlvbiIgbWVhbnM6PC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YSkgaW4gdGhlIGNhc2Ugb2YgdGhlIGluaXRpYWwgQ29udHJpYnV0b3IsIHRoZSBpbml0aWFsCitjb2RlIGFuZCBkb2N1bWVudGF0aW9uIGRpc3RyaWJ1dGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50LCBhbmQ8L3A+Cis8cCBjbGFzcz0ibGlzdCI+YikgaW4gdGhlIGNhc2Ugb2YgZWFjaCBzdWJzZXF1ZW50IENvbnRyaWJ1dG9yOjwvcD4KKzxwIGNsYXNzPSJsaXN0Ij5pKSBjaGFuZ2VzIHRvIHRoZSBQcm9ncmFtLCBhbmQ8L3A+Cis8cCBjbGFzcz0ibGlzdCI+aWkpIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbTs8L3A+Cis8cCBjbGFzcz0ibGlzdCI+d2hlcmUgc3VjaCBjaGFuZ2VzIGFuZC9vciBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0KK29yaWdpbmF0ZSBmcm9tIGFuZCBhcmUgZGlzdHJpYnV0ZWQgYnkgdGhhdCBwYXJ0aWN1bGFyIENvbnRyaWJ1dG9yLiBBCitDb250cmlidXRpb24gJ29yaWdpbmF0ZXMnIGZyb20gYSBDb250cmlidXRvciBpZiBpdCB3YXMgYWRkZWQgdG8gdGhlCitQcm9ncmFtIGJ5IHN1Y2ggQ29udHJpYnV0b3IgaXRzZWxmIG9yIGFueW9uZSBhY3Rpbmcgb24gc3VjaAorQ29udHJpYnV0b3IncyBiZWhhbGYuIENvbnRyaWJ1dGlvbnMgZG8gbm90IGluY2x1ZGUgYWRkaXRpb25zIHRvIHRoZQorUHJvZ3JhbSB3aGljaDogKGkpIGFyZSBzZXBhcmF0ZSBtb2R1bGVzIG9mIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIGluCitjb25qdW5jdGlvbiB3aXRoIHRoZSBQcm9ncmFtIHVuZGVyIHRoZWlyIG93biBsaWNlbnNlIGFncmVlbWVudCwgYW5kIChpaSkKK2FyZSBub3QgZGVyaXZhdGl2ZSB3b3JrcyBvZiB0aGUgUHJvZ3JhbS48L3A+CisKKzxwPiJDb250cmlidXRvciIgbWVhbnMgYW55IHBlcnNvbiBvciBlbnRpdHkgdGhhdCBkaXN0cmlidXRlcwordGhlIFByb2dyYW0uPC9wPgorCis8cD4iTGljZW5zZWQgUGF0ZW50cyIgbWVhbiBwYXRlbnQgY2xhaW1zIGxpY2Vuc2FibGUgYnkgYQorQ29udHJpYnV0b3Igd2hpY2ggYXJlIG5lY2Vzc2FyaWx5IGluZnJpbmdlZCBieSB0aGUgdXNlIG9yIHNhbGUgb2YgaXRzCitDb250cmlidXRpb24gYWxvbmUgb3Igd2hlbiBjb21iaW5lZCB3aXRoIHRoZSBQcm9ncmFtLjwvcD4KKworPHA+IlByb2dyYW0iIG1lYW5zIHRoZSBDb250cmlidXRpb25zIGRpc3RyaWJ1dGVkIGluIGFjY29yZGFuY2UKK3dpdGggdGhpcyBBZ3JlZW1lbnQuPC9wPgorCis8cD4iUmVjaXBpZW50IiBtZWFucyBhbnlvbmUgd2hvIHJlY2VpdmVzIHRoZSBQcm9ncmFtIHVuZGVyCit0aGlzIEFncmVlbWVudCwgaW5jbHVkaW5nIGFsbCBDb250cmlidXRvcnMuPC9wPgorCis8cD48Yj4yLiBHUkFOVCBPRiBSSUdIVFM8L2I+PC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YSkgU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2gKK0NvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLAorcm95YWx0eS1mcmVlIGNvcHlyaWdodCBsaWNlbnNlIHRvIHJlcHJvZHVjZSwgcHJlcGFyZSBkZXJpdmF0aXZlIHdvcmtzCitvZiwgcHVibGljbHkgZGlzcGxheSwgcHVibGljbHkgcGVyZm9ybSwgZGlzdHJpYnV0ZSBhbmQgc3VibGljZW5zZSB0aGUKK0NvbnRyaWJ1dGlvbiBvZiBzdWNoIENvbnRyaWJ1dG9yLCBpZiBhbnksIGFuZCBzdWNoIGRlcml2YXRpdmUgd29ya3MsIGluCitzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUgZm9ybS48L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5iKSBTdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaAorQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsCityb3lhbHR5LWZyZWUgcGF0ZW50IGxpY2Vuc2UgdW5kZXIgTGljZW5zZWQgUGF0ZW50cyB0byBtYWtlLCB1c2UsIHNlbGwsCitvZmZlciB0byBzZWxsLCBpbXBvcnQgYW5kIG90aGVyd2lzZSB0cmFuc2ZlciB0aGUgQ29udHJpYnV0aW9uIG9mIHN1Y2gKK0NvbnRyaWJ1dG9yLCBpZiBhbnksIGluIHNvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLiBUaGlzIHBhdGVudAorbGljZW5zZSBzaGFsbCBhcHBseSB0byB0aGUgY29tYmluYXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBhbmQgdGhlCitQcm9ncmFtIGlmLCBhdCB0aGUgdGltZSB0aGUgQ29udHJpYnV0aW9uIGlzIGFkZGVkIGJ5IHRoZSBDb250cmlidXRvciwKK3N1Y2ggYWRkaXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBjYXVzZXMgc3VjaCBjb21iaW5hdGlvbiB0byBiZSBjb3ZlcmVkCitieSB0aGUgTGljZW5zZWQgUGF0ZW50cy4gVGhlIHBhdGVudCBsaWNlbnNlIHNoYWxsIG5vdCBhcHBseSB0byBhbnkgb3RoZXIKK2NvbWJpbmF0aW9ucyB3aGljaCBpbmNsdWRlIHRoZSBDb250cmlidXRpb24uIE5vIGhhcmR3YXJlIHBlciBzZSBpcworbGljZW5zZWQgaGVyZXVuZGVyLjwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmMpIFJlY2lwaWVudCB1bmRlcnN0YW5kcyB0aGF0IGFsdGhvdWdoIGVhY2ggQ29udHJpYnV0b3IKK2dyYW50cyB0aGUgbGljZW5zZXMgdG8gaXRzIENvbnRyaWJ1dGlvbnMgc2V0IGZvcnRoIGhlcmVpbiwgbm8gYXNzdXJhbmNlcworYXJlIHByb3ZpZGVkIGJ5IGFueSBDb250cmlidXRvciB0aGF0IHRoZSBQcm9ncmFtIGRvZXMgbm90IGluZnJpbmdlIHRoZQorcGF0ZW50IG9yIG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgb2YgYW55IG90aGVyIGVudGl0eS4gRWFjaAorQ29udHJpYnV0b3IgZGlzY2xhaW1zIGFueSBsaWFiaWxpdHkgdG8gUmVjaXBpZW50IGZvciBjbGFpbXMgYnJvdWdodCBieQorYW55IG90aGVyIGVudGl0eSBiYXNlZCBvbiBpbmZyaW5nZW1lbnQgb2YgaW50ZWxsZWN0dWFsIHByb3BlcnR5IHJpZ2h0cworb3Igb3RoZXJ3aXNlLiBBcyBhIGNvbmRpdGlvbiB0byBleGVyY2lzaW5nIHRoZSByaWdodHMgYW5kIGxpY2Vuc2VzCitncmFudGVkIGhlcmV1bmRlciwgZWFjaCBSZWNpcGllbnQgaGVyZWJ5IGFzc3VtZXMgc29sZSByZXNwb25zaWJpbGl0eSB0bworc2VjdXJlIGFueSBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG5lZWRlZCwgaWYgYW55LiBGb3IKK2V4YW1wbGUsIGlmIGEgdGhpcmQgcGFydHkgcGF0ZW50IGxpY2Vuc2UgaXMgcmVxdWlyZWQgdG8gYWxsb3cgUmVjaXBpZW50Cit0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtLCBpdCBpcyBSZWNpcGllbnQncyByZXNwb25zaWJpbGl0eSB0byBhY3F1aXJlCit0aGF0IGxpY2Vuc2UgYmVmb3JlIGRpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbS48L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5kKSBFYWNoIENvbnRyaWJ1dG9yIHJlcHJlc2VudHMgdGhhdCB0byBpdHMga25vd2xlZGdlIGl0CitoYXMgc3VmZmljaWVudCBjb3B5cmlnaHQgcmlnaHRzIGluIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgdG8gZ3JhbnQKK3RoZSBjb3B5cmlnaHQgbGljZW5zZSBzZXQgZm9ydGggaW4gdGhpcyBBZ3JlZW1lbnQuPC9wPgorCis8cD48Yj4zLiBSRVFVSVJFTUVOVFM8L2I+PC9wPgorCis8cD5BIENvbnRyaWJ1dG9yIG1heSBjaG9vc2UgdG8gZGlzdHJpYnV0ZSB0aGUgUHJvZ3JhbSBpbiBvYmplY3QgY29kZQorZm9ybSB1bmRlciBpdHMgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBwcm92aWRlZCB0aGF0OjwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmEpIGl0IGNvbXBsaWVzIHdpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoaXMKK0FncmVlbWVudDsgYW5kPC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YikgaXRzIGxpY2Vuc2UgYWdyZWVtZW50OjwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmkpIGVmZmVjdGl2ZWx5IGRpc2NsYWltcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycworYWxsIHdhcnJhbnRpZXMgYW5kIGNvbmRpdGlvbnMsIGV4cHJlc3MgYW5kIGltcGxpZWQsIGluY2x1ZGluZyB3YXJyYW50aWVzCitvciBjb25kaXRpb25zIG9mIHRpdGxlIGFuZCBub24taW5mcmluZ2VtZW50LCBhbmQgaW1wbGllZCB3YXJyYW50aWVzIG9yCitjb25kaXRpb25zIG9mIG1lcmNoYW50YWJpbGl0eSBhbmQgZml0bmVzcyBmb3IgYSBwYXJ0aWN1bGFyIHB1cnBvc2U7PC9wPgorCis8cCBjbGFzcz0ibGlzdCI+aWkpIGVmZmVjdGl2ZWx5IGV4Y2x1ZGVzIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzCithbGwgbGlhYmlsaXR5IGZvciBkYW1hZ2VzLCBpbmNsdWRpbmcgZGlyZWN0LCBpbmRpcmVjdCwgc3BlY2lhbCwKK2luY2lkZW50YWwgYW5kIGNvbnNlcXVlbnRpYWwgZGFtYWdlcywgc3VjaCBhcyBsb3N0IHByb2ZpdHM7PC9wPgorCis8cCBjbGFzcz0ibGlzdCI+aWlpKSBzdGF0ZXMgdGhhdCBhbnkgcHJvdmlzaW9ucyB3aGljaCBkaWZmZXIgZnJvbSB0aGlzCitBZ3JlZW1lbnQgYXJlIG9mZmVyZWQgYnkgdGhhdCBDb250cmlidXRvciBhbG9uZSBhbmQgbm90IGJ5IGFueSBvdGhlcgorcGFydHk7IGFuZDwvcD4KKworPHAgY2xhc3M9Imxpc3QiPml2KSBzdGF0ZXMgdGhhdCBzb3VyY2UgY29kZSBmb3IgdGhlIFByb2dyYW0gaXMgYXZhaWxhYmxlCitmcm9tIHN1Y2ggQ29udHJpYnV0b3IsIGFuZCBpbmZvcm1zIGxpY2Vuc2VlcyBob3cgdG8gb2J0YWluIGl0IGluIGEKK3JlYXNvbmFibGUgbWFubmVyIG9uIG9yIHRocm91Z2ggYSBtZWRpdW0gY3VzdG9tYXJpbHkgdXNlZCBmb3Igc29mdHdhcmUKK2V4Y2hhbmdlLjwvcD4KKworPHA+V2hlbiB0aGUgUHJvZ3JhbSBpcyBtYWRlIGF2YWlsYWJsZSBpbiBzb3VyY2UgY29kZSBmb3JtOjwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmEpIGl0IG11c3QgYmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhpcyBBZ3JlZW1lbnQ7IGFuZDwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmIpIGEgY29weSBvZiB0aGlzIEFncmVlbWVudCBtdXN0IGJlIGluY2x1ZGVkIHdpdGggZWFjaAorY29weSBvZiB0aGUgUHJvZ3JhbS48L3A+CisKKzxwPkNvbnRyaWJ1dG9ycyBtYXkgbm90IHJlbW92ZSBvciBhbHRlciBhbnkgY29weXJpZ2h0IG5vdGljZXMgY29udGFpbmVkCit3aXRoaW4gdGhlIFByb2dyYW0uPC9wPgorCis8cD5FYWNoIENvbnRyaWJ1dG9yIG11c3QgaWRlbnRpZnkgaXRzZWxmIGFzIHRoZSBvcmlnaW5hdG9yIG9mIGl0cworQ29udHJpYnV0aW9uLCBpZiBhbnksIGluIGEgbWFubmVyIHRoYXQgcmVhc29uYWJseSBhbGxvd3Mgc3Vic2VxdWVudAorUmVjaXBpZW50cyB0byBpZGVudGlmeSB0aGUgb3JpZ2luYXRvciBvZiB0aGUgQ29udHJpYnV0aW9uLjwvcD4KKworPHA+PGI+NC4gQ09NTUVSQ0lBTCBESVNUUklCVVRJT048L2I+PC9wPgorCis8cD5Db21tZXJjaWFsIGRpc3RyaWJ1dG9ycyBvZiBzb2Z0d2FyZSBtYXkgYWNjZXB0IGNlcnRhaW4KK3Jlc3BvbnNpYmlsaXRpZXMgd2l0aCByZXNwZWN0IHRvIGVuZCB1c2VycywgYnVzaW5lc3MgcGFydG5lcnMgYW5kIHRoZQorbGlrZS4gV2hpbGUgdGhpcyBsaWNlbnNlIGlzIGludGVuZGVkIHRvIGZhY2lsaXRhdGUgdGhlIGNvbW1lcmNpYWwgdXNlIG9mCit0aGUgUHJvZ3JhbSwgdGhlIENvbnRyaWJ1dG9yIHdobyBpbmNsdWRlcyB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwKK3Byb2R1Y3Qgb2ZmZXJpbmcgc2hvdWxkIGRvIHNvIGluIGEgbWFubmVyIHdoaWNoIGRvZXMgbm90IGNyZWF0ZQorcG90ZW50aWFsIGxpYWJpbGl0eSBmb3Igb3RoZXIgQ29udHJpYnV0b3JzLiBUaGVyZWZvcmUsIGlmIGEgQ29udHJpYnV0b3IKK2luY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBzdWNoIENvbnRyaWJ1dG9yCisoIkNvbW1lcmNpYWwgQ29udHJpYnV0b3IiKSBoZXJlYnkgYWdyZWVzIHRvIGRlZmVuZCBhbmQKK2luZGVtbmlmeSBldmVyeSBvdGhlciBDb250cmlidXRvciAoIkluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIikKK2FnYWluc3QgYW55IGxvc3NlcywgZGFtYWdlcyBhbmQgY29zdHMgKGNvbGxlY3RpdmVseSAiTG9zc2VzIikKK2FyaXNpbmcgZnJvbSBjbGFpbXMsIGxhd3N1aXRzIGFuZCBvdGhlciBsZWdhbCBhY3Rpb25zIGJyb3VnaHQgYnkgYSB0aGlyZAorcGFydHkgYWdhaW5zdCB0aGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgdG8gdGhlIGV4dGVudCBjYXVzZWQgYnkgdGhlCithY3RzIG9yIG9taXNzaW9ucyBvZiBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4gY29ubmVjdGlvbiB3aXRoIGl0cworZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLiBUaGUKK29ibGlnYXRpb25zIGluIHRoaXMgc2VjdGlvbiBkbyBub3QgYXBwbHkgdG8gYW55IGNsYWltcyBvciBMb3NzZXMKK3JlbGF0aW5nIHRvIGFueSBhY3R1YWwgb3IgYWxsZWdlZCBpbnRlbGxlY3R1YWwgcHJvcGVydHkgaW5mcmluZ2VtZW50LiBJbgorb3JkZXIgdG8gcXVhbGlmeSwgYW4gSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbXVzdDogYSkgcHJvbXB0bHkgbm90aWZ5Cit0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiB3cml0aW5nIG9mIHN1Y2ggY2xhaW0sIGFuZCBiKSBhbGxvdyB0aGUKK0NvbW1lcmNpYWwgQ29udHJpYnV0b3IgdG8gY29udHJvbCwgYW5kIGNvb3BlcmF0ZSB3aXRoIHRoZSBDb21tZXJjaWFsCitDb250cmlidXRvciBpbiwgdGhlIGRlZmVuc2UgYW5kIGFueSByZWxhdGVkIHNldHRsZW1lbnQgbmVnb3RpYXRpb25zLiBUaGUKK0luZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG1heSBwYXJ0aWNpcGF0ZSBpbiBhbnkgc3VjaCBjbGFpbSBhdCBpdHMgb3duCitleHBlbnNlLjwvcD4KKworPHA+Rm9yIGV4YW1wbGUsIGEgQ29udHJpYnV0b3IgbWlnaHQgaW5jbHVkZSB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwKK3Byb2R1Y3Qgb2ZmZXJpbmcsIFByb2R1Y3QgWC4gVGhhdCBDb250cmlidXRvciBpcyB0aGVuIGEgQ29tbWVyY2lhbAorQ29udHJpYnV0b3IuIElmIHRoYXQgQ29tbWVyY2lhbCBDb250cmlidXRvciB0aGVuIG1ha2VzIHBlcmZvcm1hbmNlCitjbGFpbXMsIG9yIG9mZmVycyB3YXJyYW50aWVzIHJlbGF0ZWQgdG8gUHJvZHVjdCBYLCB0aG9zZSBwZXJmb3JtYW5jZQorY2xhaW1zIGFuZCB3YXJyYW50aWVzIGFyZSBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IncyByZXNwb25zaWJpbGl0eQorYWxvbmUuIFVuZGVyIHRoaXMgc2VjdGlvbiwgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3Igd291bGQgaGF2ZSB0bworZGVmZW5kIGNsYWltcyBhZ2FpbnN0IHRoZSBvdGhlciBDb250cmlidXRvcnMgcmVsYXRlZCB0byB0aG9zZQorcGVyZm9ybWFuY2UgY2xhaW1zIGFuZCB3YXJyYW50aWVzLCBhbmQgaWYgYSBjb3VydCByZXF1aXJlcyBhbnkgb3RoZXIKK0NvbnRyaWJ1dG9yIHRvIHBheSBhbnkgZGFtYWdlcyBhcyBhIHJlc3VsdCwgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IKK211c3QgcGF5IHRob3NlIGRhbWFnZXMuPC9wPgorCis8cD48Yj41LiBOTyBXQVJSQU5UWTwvYj48L3A+CisKKzxwPkVYQ0VQVCBBUyBFWFBSRVNTTFkgU0VUIEZPUlRIIElOIFRISVMgQUdSRUVNRU5ULCBUSEUgUFJPR1JBTSBJUworUFJPVklERUQgT04gQU4gIkFTIElTIiBCQVNJUywgV0lUSE9VVCBXQVJSQU5USUVTIE9SIENPTkRJVElPTlMKK09GIEFOWSBLSU5ELCBFSVRIRVIgRVhQUkVTUyBPUiBJTVBMSUVEIElOQ0xVRElORywgV0lUSE9VVCBMSU1JVEFUSU9OLAorQU5ZIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBUSVRMRSwgTk9OLUlORlJJTkdFTUVOVCwgTUVSQ0hBTlRBQklMSVRZCitPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gRWFjaCBSZWNpcGllbnQgaXMgc29sZWx5CityZXNwb25zaWJsZSBmb3IgZGV0ZXJtaW5pbmcgdGhlIGFwcHJvcHJpYXRlbmVzcyBvZiB1c2luZyBhbmQKK2Rpc3RyaWJ1dGluZyB0aGUgUHJvZ3JhbSBhbmQgYXNzdW1lcyBhbGwgcmlza3MgYXNzb2NpYXRlZCB3aXRoIGl0cworZXhlcmNpc2Ugb2YgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50ICwgaW5jbHVkaW5nIGJ1dCBub3QgbGltaXRlZCB0bwordGhlIHJpc2tzIGFuZCBjb3N0cyBvZiBwcm9ncmFtIGVycm9ycywgY29tcGxpYW5jZSB3aXRoIGFwcGxpY2FibGUgbGF3cywKK2RhbWFnZSB0byBvciBsb3NzIG9mIGRhdGEsIHByb2dyYW1zIG9yIGVxdWlwbWVudCwgYW5kIHVuYXZhaWxhYmlsaXR5IG9yCitpbnRlcnJ1cHRpb24gb2Ygb3BlcmF0aW9ucy48L3A+CisKKzxwPjxiPjYuIERJU0NMQUlNRVIgT0YgTElBQklMSVRZPC9iPjwvcD4KKworPHA+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUyBBR1JFRU1FTlQsIE5FSVRIRVIgUkVDSVBJRU5UCitOT1IgQU5ZIENPTlRSSUJVVE9SUyBTSEFMTCBIQVZFIEFOWSBMSUFCSUxJVFkgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULAorSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORworV0lUSE9VVCBMSU1JVEFUSU9OIExPU1QgUFJPRklUUyksIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZIE9GCitMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORworTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPUgorRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIE9SIFRIRSBFWEVSQ0lTRSBPRiBBTlkgUklHSFRTIEdSQU5URUQKK0hFUkVVTkRFUiwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRVMuPC9wPgorCis8cD48Yj43LiBHRU5FUkFMPC9iPjwvcD4KKworPHA+SWYgYW55IHByb3Zpc2lvbiBvZiB0aGlzIEFncmVlbWVudCBpcyBpbnZhbGlkIG9yIHVuZW5mb3JjZWFibGUgdW5kZXIKK2FwcGxpY2FibGUgbGF3LCBpdCBzaGFsbCBub3QgYWZmZWN0IHRoZSB2YWxpZGl0eSBvciBlbmZvcmNlYWJpbGl0eSBvZgordGhlIHJlbWFpbmRlciBvZiB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGFuZCB3aXRob3V0IGZ1cnRoZXIgYWN0aW9uCitieSB0aGUgcGFydGllcyBoZXJldG8sIHN1Y2ggcHJvdmlzaW9uIHNoYWxsIGJlIHJlZm9ybWVkIHRvIHRoZSBtaW5pbXVtCitleHRlbnQgbmVjZXNzYXJ5IHRvIG1ha2Ugc3VjaCBwcm92aXNpb24gdmFsaWQgYW5kIGVuZm9yY2VhYmxlLjwvcD4KKworPHA+SWYgUmVjaXBpZW50IGluc3RpdHV0ZXMgcGF0ZW50IGxpdGlnYXRpb24gYWdhaW5zdCBhbnkgZW50aXR5CisoaW5jbHVkaW5nIGEgY3Jvc3MtY2xhaW0gb3IgY291bnRlcmNsYWltIGluIGEgbGF3c3VpdCkgYWxsZWdpbmcgdGhhdCB0aGUKK1Byb2dyYW0gaXRzZWxmIChleGNsdWRpbmcgY29tYmluYXRpb25zIG9mIHRoZSBQcm9ncmFtIHdpdGggb3RoZXIKK3NvZnR3YXJlIG9yIGhhcmR3YXJlKSBpbmZyaW5nZXMgc3VjaCBSZWNpcGllbnQncyBwYXRlbnQocyksIHRoZW4gc3VjaAorUmVjaXBpZW50J3MgcmlnaHRzIGdyYW50ZWQgdW5kZXIgU2VjdGlvbiAyKGIpIHNoYWxsIHRlcm1pbmF0ZSBhcyBvZiB0aGUKK2RhdGUgc3VjaCBsaXRpZ2F0aW9uIGlzIGZpbGVkLjwvcD4KKworPHA+QWxsIFJlY2lwaWVudCdzIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCBzaGFsbCB0ZXJtaW5hdGUgaWYgaXQKK2ZhaWxzIHRvIGNvbXBseSB3aXRoIGFueSBvZiB0aGUgbWF0ZXJpYWwgdGVybXMgb3IgY29uZGl0aW9ucyBvZiB0aGlzCitBZ3JlZW1lbnQgYW5kIGRvZXMgbm90IGN1cmUgc3VjaCBmYWlsdXJlIGluIGEgcmVhc29uYWJsZSBwZXJpb2Qgb2YgdGltZQorYWZ0ZXIgYmVjb21pbmcgYXdhcmUgb2Ygc3VjaCBub25jb21wbGlhbmNlLiBJZiBhbGwgUmVjaXBpZW50J3MgcmlnaHRzCit1bmRlciB0aGlzIEFncmVlbWVudCB0ZXJtaW5hdGUsIFJlY2lwaWVudCBhZ3JlZXMgdG8gY2Vhc2UgdXNlIGFuZAorZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGFzIHNvb24gYXMgcmVhc29uYWJseSBwcmFjdGljYWJsZS4gSG93ZXZlciwKK1JlY2lwaWVudCdzIG9ibGlnYXRpb25zIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFuZCBhbnkgbGljZW5zZXMgZ3JhbnRlZCBieQorUmVjaXBpZW50IHJlbGF0aW5nIHRvIHRoZSBQcm9ncmFtIHNoYWxsIGNvbnRpbnVlIGFuZCBzdXJ2aXZlLjwvcD4KKworPHA+RXZlcnlvbmUgaXMgcGVybWl0dGVkIHRvIGNvcHkgYW5kIGRpc3RyaWJ1dGUgY29waWVzIG9mIHRoaXMKK0FncmVlbWVudCwgYnV0IGluIG9yZGVyIHRvIGF2b2lkIGluY29uc2lzdGVuY3kgdGhlIEFncmVlbWVudCBpcworY29weXJpZ2h0ZWQgYW5kIG1heSBvbmx5IGJlIG1vZGlmaWVkIGluIHRoZSBmb2xsb3dpbmcgbWFubmVyLiBUaGUKK0FncmVlbWVudCBTdGV3YXJkIHJlc2VydmVzIHRoZSByaWdodCB0byBwdWJsaXNoIG5ldyB2ZXJzaW9ucyAoaW5jbHVkaW5nCityZXZpc2lvbnMpIG9mIHRoaXMgQWdyZWVtZW50IGZyb20gdGltZSB0byB0aW1lLiBObyBvbmUgb3RoZXIgdGhhbiB0aGUKK0FncmVlbWVudCBTdGV3YXJkIGhhcyB0aGUgcmlnaHQgdG8gbW9kaWZ5IHRoaXMgQWdyZWVtZW50LiBUaGUgRWNsaXBzZQorRm91bmRhdGlvbiBpcyB0aGUgaW5pdGlhbCBBZ3JlZW1lbnQgU3Rld2FyZC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYXkKK2Fzc2lnbiB0aGUgcmVzcG9uc2liaWxpdHkgdG8gc2VydmUgYXMgdGhlIEFncmVlbWVudCBTdGV3YXJkIHRvIGEKK3N1aXRhYmxlIHNlcGFyYXRlIGVudGl0eS4gRWFjaCBuZXcgdmVyc2lvbiBvZiB0aGUgQWdyZWVtZW50IHdpbGwgYmUKK2dpdmVuIGEgZGlzdGluZ3Vpc2hpbmcgdmVyc2lvbiBudW1iZXIuIFRoZSBQcm9ncmFtIChpbmNsdWRpbmcKK0NvbnRyaWJ1dGlvbnMpIG1heSBhbHdheXMgYmUgZGlzdHJpYnV0ZWQgc3ViamVjdCB0byB0aGUgdmVyc2lvbiBvZiB0aGUKK0FncmVlbWVudCB1bmRlciB3aGljaCBpdCB3YXMgcmVjZWl2ZWQuIEluIGFkZGl0aW9uLCBhZnRlciBhIG5ldyB2ZXJzaW9uCitvZiB0aGUgQWdyZWVtZW50IGlzIHB1Ymxpc2hlZCwgQ29udHJpYnV0b3IgbWF5IGVsZWN0IHRvIGRpc3RyaWJ1dGUgdGhlCitQcm9ncmFtIChpbmNsdWRpbmcgaXRzIENvbnRyaWJ1dGlvbnMpIHVuZGVyIHRoZSBuZXcgdmVyc2lvbi4gRXhjZXB0IGFzCitleHByZXNzbHkgc3RhdGVkIGluIFNlY3Rpb25zIDIoYSkgYW5kIDIoYikgYWJvdmUsIFJlY2lwaWVudCByZWNlaXZlcyBubworcmlnaHRzIG9yIGxpY2Vuc2VzIHRvIHRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgb2YgYW55IENvbnRyaWJ1dG9yIHVuZGVyCit0aGlzIEFncmVlbWVudCwgd2hldGhlciBleHByZXNzbHksIGJ5IGltcGxpY2F0aW9uLCBlc3RvcHBlbCBvcgorb3RoZXJ3aXNlLiBBbGwgcmlnaHRzIGluIHRoZSBQcm9ncmFtIG5vdCBleHByZXNzbHkgZ3JhbnRlZCB1bmRlciB0aGlzCitBZ3JlZW1lbnQgYXJlIHJlc2VydmVkLjwvcD4KKworPHA+VGhpcyBBZ3JlZW1lbnQgaXMgZ292ZXJuZWQgYnkgdGhlIGxhd3Mgb2YgdGhlIFN0YXRlIG9mIE5ldyBZb3JrIGFuZAordGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBsYXdzIG9mIHRoZSBVbml0ZWQgU3RhdGVzIG9mIEFtZXJpY2EuIE5vIHBhcnR5Cit0byB0aGlzIEFncmVlbWVudCB3aWxsIGJyaW5nIGEgbGVnYWwgYWN0aW9uIHVuZGVyIHRoaXMgQWdyZWVtZW50IG1vcmUKK3RoYW4gb25lIHllYXIgYWZ0ZXIgdGhlIGNhdXNlIG9mIGFjdGlvbiBhcm9zZS4gRWFjaCBwYXJ0eSB3YWl2ZXMgaXRzCityaWdodHMgdG8gYSBqdXJ5IHRyaWFsIGluIGFueSByZXN1bHRpbmcgbGl0aWdhdGlvbi48L3A+CisKKworCis8L2JvZHk+PC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3MvZmVhdHVyZS5wcm9wZXJ0aWVzIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS5oZWFkbGVzcy9mZWF0dXJlLnByb3BlcnRpZXMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNmExMzBhMgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3MvZmVhdHVyZS5wcm9wZXJ0aWVzCkBAIC0wLDAgKzEsMTY5IEBACisjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCisjIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpLgorIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisjIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAorIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorIworIyBDb250cmlidXRvcnM6CisjICAgICBDcmlzdGlhbm8gR2F2aeNvIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uCisjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCisjIGZlYXR1cmUucHJvcGVydGllcworIyBjb250YWlucyBleHRlcm5hbGl6ZWQgc3RyaW5ncyBmb3IgZmVhdHVyZS54bWwKKyMgIiVmb28iIGluIGZlYXR1cmUueG1sIGNvcnJlc3BvbmRzIHRvIHRoZSBrZXkgImZvbyIgaW4gdGhpcyBmaWxlCisjIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCisjIFRoaXMgZmlsZSBzaG91bGQgYmUgdHJhbnNsYXRlZC4KKworIyAiZmVhdHVyZU5hbWUiIHByb3BlcnR5IC0gbmFtZSBvZiB0aGUgZmVhdHVyZQorZmVhdHVyZU5hbWUgPUhlYWRsZXNzIEZlYXR1cmUgZm9yIE9TQlAgSURFIAorCisjICJwcm92aWRlck5hbWUiIHByb3BlcnR5IC0gbmFtZSBvZiB0aGUgY29tcGFueSB0aGF0IHByb3ZpZGVzIHRoZSBmZWF0dXJlCitwcm92aWRlck5hbWU9RWNsaXBzZSBPU0JQCisKKyMgImRlc2NyaXB0aW9uIiBwcm9wZXJ0eSAtIGRlc2NyaXB0aW9uIG9mIHRoZSBmZWF0dXJlCitkZXNjcmlwdGlvbj1JbnN0YWxscyBhbGwgZmVhdHVyZXMgcmVxdWlyZWQgZm9yIE9TQlAgaW50byB0aGUgSURFCisKKyMgInVwZGF0ZVNpdGVOYW1lIiBwcm9wZXJ0eSAtIGxhYmVsIGZvciB0aGUgdXBkYXRlIHNpdGUKK3VwZGF0ZVNpdGVOYW1lPQorCisjICJjb3B5cmlnaHQiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIENvcHlyaWdodCIKK2NvcHlyaWdodD1cCitDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KSBcblwKK0FsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHNcblwKK2FyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMFxuXAord2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXRcblwKK2h0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sXG5cCitcblwKKyMjIyMjIyMjIyMjIyMjIyMgZW5kIG9mIGNvcHlyaWdodCBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKKworIyAibGljZW5zZVVSTCIgcHJvcGVydHkgLSBVUkwgb2YgdGhlICJGZWF0dXJlIExpY2Vuc2UiCisjIGRvIG5vdCB0cmFuc2xhdGUgdmFsdWUgLSBqdXN0IGNoYW5nZSB0byBwb2ludCB0byBhIGxvY2FsZS1zcGVjaWZpYyBIVE1MIHBhZ2UKK2xpY2Vuc2VVUkw9bGljZW5zZS5odG1sCisKKyMgImxpY2Vuc2UiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIExpY2Vuc2UiCisjIHNob3VsZCBiZSBwbGFpbiB0ZXh0IHZlcnNpb24gb2YgbGljZW5zZSBhZ3JlZW1lbnQgcG9pbnRlZCB0byBiZSAibGljZW5zZVVSTCIKK2xpY2Vuc2U9XAorRWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50XG5cCitGZWJydWFyeSAxLCAyMDExXG5cCitcblwKK1VzYWdlIE9mIENvbnRlbnRcblwKK1xuXAorVEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUlxuXAorT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUyAoQ09MTEVDVElWRUxZICJDT05URU5UIikuXG5cCitVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVNcblwKK0FHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUlxuXAorTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gIEJZIFVTSU5HIFRIRSBDT05URU5ULCBZT1VcblwKK0FHUkVFIFRIQVQgWU9VUiBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhJUyBBR1JFRU1FTlRcblwKK0FORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTXG5cCitPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEVcblwKK1RFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORCBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlNcblwKK09GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEXG5cCitCRUxPVywgVEhFTiBZT1UgTUFZIE5PVCBVU0UgVEhFIENPTlRFTlQuXG5cCitcblwKK0FwcGxpY2FibGUgTGljZW5zZXNcblwKK1xuXAorVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZVxuXAorRWNsaXBzZSBGb3VuZGF0aW9uIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2ZcblwKK3RoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wICgiRVBMIikuIEEgY29weSBvZiB0aGUgRVBMIGlzXG5cCitwcm92aWRlZCB3aXRoIHRoaXMgQ29udGVudCBhbmQgaXMgYWxzbyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuXG5cCitGb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC5cblwKK1xuXAorQ29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsXG5cCitkb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gc291cmNlIGNvZGVcblwKK3JlcG9zaXRvcnkgKCJSZXBvc2l0b3J5IikgaW4gc29mdHdhcmUgbW9kdWxlcyAoIk1vZHVsZXMiKSBhbmQgbWFkZSBhdmFpbGFibGVcblwKK2FzIGRvd25sb2FkYWJsZSBhcmNoaXZlcyAoIkRvd25sb2FkcyIpLlxuXAorXG5cCisgICAgICAgLSBDb250ZW50IG1heSBiZSBzdHJ1Y3R1cmVkIGFuZCBwYWNrYWdlZCBpbnRvIG1vZHVsZXMgdG8gZmFjaWxpdGF0ZSBkZWxpdmVyaW5nLFxuXAorICAgICAgICAgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiBUeXBpY2FsIG1vZHVsZXMgbWF5IGluY2x1ZGUgcGx1Zy1pbnMgKCJQbHVnLWlucyIpLFxuXAorICAgICAgICAgcGx1Zy1pbiBmcmFnbWVudHMgKCJGcmFnbWVudHMiKSwgYW5kIGZlYXR1cmVzICgiRmVhdHVyZXMiKS5cblwKKyAgICAgICAtIEVhY2ggUGx1Zy1pbiBvciBGcmFnbWVudCBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IG9yIEpBUiAoSmF2YShUTSkgQVJjaGl2ZSlcblwKKyAgICAgICAgIGluIGEgZGlyZWN0b3J5IG5hbWVkICJwbHVnaW5zIi5cblwKKyAgICAgICAtIEEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLlxuXAorICAgICAgICAgRWFjaCBGZWF0dXJlIG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3RvcnkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgImZlYXR1cmVzIi5cblwKKyAgICAgICAgIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvblxuXAorICAgICAgICAgbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhc3NvY2lhdGVkIHdpdGggdGhhdCBGZWF0dXJlLlxuXAorICAgICAgIC0gRmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzXG5cCisgICAgICAgICBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy5cblwKK1xuXAorVGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZVxuXAorY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICJhYm91dC5odG1sIiAoIkFib3V0cyIpLiBUaGUgdGVybXMgYW5kXG5cCitjb25kaXRpb25zIGdvdmVybmluZyBGZWF0dXJlcyBhbmQgSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZFxuXAoraW4gZmlsZXMgbmFtZWQgImxpY2Vuc2UuaHRtbCIgKCJGZWF0dXJlIExpY2Vuc2VzIikuIEFib3V0cyBhbmQgRmVhdHVyZVxuXAorTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55IGRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZVxuXAoraW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyBsb2NhdGlvbnM6XG5cCitcblwKKyAgICAgICAtIFRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeVxuXAorICAgICAgIC0gUGx1Zy1pbiBhbmQgRnJhZ21lbnQgZGlyZWN0b3JpZXNcblwKKyAgICAgICAtIEluc2lkZSBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHBhY2thZ2VkIGFzIEpBUnNcblwKKyAgICAgICAtIFN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnNcblwKKyAgICAgICAtIEZlYXR1cmUgZGlyZWN0b3JpZXNcblwKK1xuXAorTm90ZTogaWYgYSBGZWF0dXJlIG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgaW5zdGFsbGVkIHVzaW5nIHRoZVxuXAorUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgKGFzIGRlZmluZWQgYmVsb3cpLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFxuXAorVXBkYXRlIExpY2Vuc2UiKSBkdXJpbmcgdGhlIGluc3RhbGxhdGlvbiBwcm9jZXNzLiBJZiB0aGUgRmVhdHVyZSBjb250YWluc1xuXAorSW5jbHVkZWQgRmVhdHVyZXMsIHRoZSBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIHNob3VsZCBlaXRoZXIgcHJvdmlkZSB5b3VcblwKK3dpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IgaW5mb3JtXG5cCit5b3Ugd2hlcmUgeW91IGNhbiBsb2NhdGUgdGhlbS4gRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgbWF5IGJlIGZvdW5kIGluXG5cCit0aGUgImxpY2Vuc2UiIHByb3BlcnR5IG9mIGZpbGVzIG5hbWVkICJmZWF0dXJlLnByb3BlcnRpZXMiIGZvdW5kIHdpdGhpbiBhIEZlYXR1cmUuXG5cCitTdWNoIEFib3V0cywgRmVhdHVyZSBMaWNlbnNlcywgYW5kIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlXG5cCit0ZXJtcyBhbmQgY29uZGl0aW9ucyAob3IgcmVmZXJlbmNlcyB0byBzdWNoIHRlcm1zIGFuZCBjb25kaXRpb25zKSB0aGF0XG5cCitnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbiB0aGF0IGRpcmVjdG9yeS5cblwKK1xuXAorVEhFIEFCT1VUUywgRkVBVFVSRSBMSUNFTlNFUywgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUlxuXAorVE8gVEhFIEVQTCBPUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuXG5cCitTT01FIE9GIFRIRVNFIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6XG5cCitcblwKKyAgICAgICAtIEVjbGlwc2UgRGlzdHJpYnV0aW9uIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xpY2Vuc2VzL2VkbC12MS4wLmh0bWwpXG5cCisgICAgICAgLSBDb21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbClcblwKKyAgICAgICAtIEFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFKVxuXAorICAgICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wKVxuXAorICAgICAgIC0gTWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwpXG5cCisgICAgICAgLSBNb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sKVxuXAorXG5cCitJVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCBDT05ESVRJT05TIFBSSU9SXG5cCitUTyBVU0UgT0YgVEhFIENPTlRFTlQuIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2UsIG9yIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VcblwKK2lzIHByb3ZpZGVkLCBwbGVhc2UgY29udGFjdCB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHRvIGRldGVybWluZSB3aGF0IHRlcm1zIGFuZCBjb25kaXRpb25zXG5cCitnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuXG5cCitcblwKK1xuXFVzZSBvZiBQcm92aXNpb25pbmcgVGVjaG5vbG9neVxuXAorXG5cCitUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBwcm92aXNpb25pbmcgc29mdHdhcmUsIGV4YW1wbGVzIG9mIHdoaWNoIGluY2x1ZGUsXG5cCitidXQgYXJlIG5vdCBsaW1pdGVkIHRvLCBwMiBhbmQgdGhlIEVjbGlwc2UgVXBkYXRlIE1hbmFnZXIgKCJQcm92aXNpb25pbmcgVGVjaG5vbG9neSIpIGZvclxuXAordGhlIHB1cnBvc2Ugb2YgYWxsb3dpbmcgdXNlcnMgdG8gaW5zdGFsbCBzb2Z0d2FyZSwgZG9jdW1lbnRhdGlvbiwgaW5mb3JtYXRpb24gYW5kL29yXG5cCitvdGhlciBtYXRlcmlhbHMgKGNvbGxlY3RpdmVseSAiSW5zdGFsbGFibGUgU29mdHdhcmUiKS4gVGhpcyBjYXBhYmlsaXR5IGlzIHByb3ZpZGVkIHdpdGhcblwKK3RoZSBpbnRlbnQgb2YgYWxsb3dpbmcgc3VjaCB1c2VycyB0byBpbnN0YWxsLCBleHRlbmQgYW5kIHVwZGF0ZSBFY2xpcHNlLWJhc2VkIHByb2R1Y3RzLlxuXAorSW5mb3JtYXRpb24gYWJvdXQgcGFja2FnaW5nIEluc3RhbGxhYmxlIFNvZnR3YXJlIGlzIGF2YWlsYWJsZSBhdFxuXAoraHR0cDovL2VjbGlwc2Uub3JnL2VxdWlub3gvcDIvcmVwb3NpdG9yeV9wYWNrYWdpbmcuaHRtbCAoIlNwZWNpZmljYXRpb24iKS5cblwKK1xuXAorWW91IG1heSB1c2UgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgdG8gYWxsb3cgb3RoZXIgcGFydGllcyB0byBpbnN0YWxsIEluc3RhbGxhYmxlIFNvZnR3YXJlLlxuXAorWW91IHNoYWxsIGJlIHJlc3BvbnNpYmxlIGZvciBlbmFibGluZyB0aGUgYXBwbGljYWJsZSBsaWNlbnNlIGFncmVlbWVudHMgcmVsYXRpbmcgdG8gdGhlXG5cCitJbnN0YWxsYWJsZSBTb2Z0d2FyZSB0byBiZSBwcmVzZW50ZWQgdG8sIGFuZCBhY2NlcHRlZCBieSwgdGhlIHVzZXJzIG9mIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neVxuXAoraW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBTcGVjaWZpY2F0aW9uLiBCeSB1c2luZyBQcm92aXNpb25pbmcgVGVjaG5vbG9neSBpbiBzdWNoIGEgbWFubmVyIGFuZFxuXAorbWFraW5nIGl0IGF2YWlsYWJsZSBpbiBhY2NvcmRhbmNlIHdpdGggdGhlIFNwZWNpZmljYXRpb24sIHlvdSBmdXJ0aGVyIGFja25vd2xlZGdlIHlvdXJcblwKK2FncmVlbWVudCB0bywgYW5kIHRoZSBhY3F1aXNpdGlvbiBvZiBhbGwgbmVjZXNzYXJ5IHJpZ2h0cyB0byBwZXJtaXQgdGhlIGZvbGxvd2luZzpcblwKK1xuXAorICAgICAgIDEuIEEgc2VyaWVzIG9mIGFjdGlvbnMgbWF5IG9jY3VyICgiUHJvdmlzaW9uaW5nIFByb2Nlc3MiKSBpbiB3aGljaCBhIHVzZXIgbWF5IGV4ZWN1dGVcblwKKyAgICAgICAgICB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgb24gYSBtYWNoaW5lICgiVGFyZ2V0IE1hY2hpbmUiKSB3aXRoIHRoZSBpbnRlbnQgb2YgaW5zdGFsbGluZyxcblwKKyAgICAgICAgICBleHRlbmRpbmcgb3IgdXBkYXRpbmcgdGhlIGZ1bmN0aW9uYWxpdHkgb2YgYW4gRWNsaXBzZS1iYXNlZCBwcm9kdWN0LlxuXAorICAgICAgIDIuIER1cmluZyB0aGUgUHJvdmlzaW9uaW5nIFByb2Nlc3MsIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSBtYXkgY2F1c2UgdGhpcmQgcGFydHlcblwKKyAgICAgICAgICBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBvciBhIHBvcnRpb24gdGhlcmVvZiB0byBiZSBhY2Nlc3NlZCBhbmQgY29waWVkIHRvIHRoZSBUYXJnZXQgTWFjaGluZS5cblwKKyAgICAgICAzLiBQdXJzdWFudCB0byB0aGUgU3BlY2lmaWNhdGlvbiwgeW91IHdpbGwgcHJvdmlkZSB0byB0aGUgdXNlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgdGhhdFxuXAorICAgICAgICAgIGdvdmVybiB0aGUgdXNlIG9mIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSAoIkluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCIpIGFuZCBzdWNoXG5cCisgICAgICAgICAgSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50IHNoYWxsIGJlIGFjY2Vzc2VkIGZyb20gdGhlIFRhcmdldCBNYWNoaW5lIGluIGFjY29yZGFuY2VcblwKKyAgICAgICAgICB3aXRoIHRoZSBTcGVjaWZpY2F0aW9uLiBTdWNoIEluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCBtdXN0IGluZm9ybSB0aGUgdXNlciBvZiB0aGVcblwKKyAgICAgICAgICB0ZXJtcyBhbmQgY29uZGl0aW9ucyB0aGF0IGdvdmVybiB0aGUgSW5zdGFsbGFibGUgU29mdHdhcmUgYW5kIG11c3Qgc29saWNpdCBhY2NlcHRhbmNlIGJ5XG5cCisgICAgICAgICAgdGhlIGVuZCB1c2VyIGluIHRoZSBtYW5uZXIgcHJlc2NyaWJlZCBpbiBzdWNoIEluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudC4gVXBvbiBzdWNoXG5cCisgICAgICAgICAgaW5kaWNhdGlvbiBvZiBhZ3JlZW1lbnQgYnkgdGhlIHVzZXIsIHRoZSBwcm92aXNpb25pbmcgVGVjaG5vbG9neSB3aWxsIGNvbXBsZXRlIGluc3RhbGxhdGlvblxuXAorICAgICAgICAgIG9mIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZS5cblwKK1xuXAorQ3J5cHRvZ3JhcGh5XG5cCitcblwKK0NvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZVxuXAorY3VycmVudGx5IG1heSBoYXZlIHJlc3RyaWN0aW9ucyBvbiB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBhbmQgdXNlLFxuXAorYW5kL29yIHJlLWV4cG9ydCB0byBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRVxuXAordXNpbmcgYW55IGVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsXG5cCityZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgY29uY2VybmluZyB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZFxuXAorcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIHRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC5cblwKK1xuXAorSmF2YSBhbmQgYWxsIEphdmEtYmFzZWQgdHJhZGVtYXJrcyBhcmUgdHJhZGVtYXJrcyBvZiBPcmFjbGUgQ29ycG9yYXRpb24gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC5cbgorIyMjIyMjIyMjIyMgZW5kIG9mIGxpY2Vuc2UgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLmhlYWRsZXNzL2ZlYXR1cmUueG1sIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS5oZWFkbGVzcy9mZWF0dXJlLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zOTcyOTAxCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS5oZWFkbGVzcy9mZWF0dXJlLnhtbApAQCAtMCwwICsxLDQ1IEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPCEtLSM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4KKzwhLS0jIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpIC0tPgorPCEtLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAtLT4KKzwhLS0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAtLT4KKzwhLS0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IC0tPgorPCEtLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgLS0+Cis8IS0tIyAtLT4KKzwhLS0jIENvbnRyaWJ1dG9yczogLS0+Cis8IS0tIyAgICAgQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24gLS0+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorCis8ZmVhdHVyZQorICAgICAgICBpZD0ib3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS5oZWFkbGVzcyIKKyAgICAgICAgbGFiZWw9IiVmZWF0dXJlTmFtZSIKKyAgICAgICAgdmVyc2lvbj0iMC45LjAucXVhbGlmaWVyIgorICAgICAgICBwcm92aWRlci1uYW1lPSIlcHJvdmlkZXJOYW1lIj4KKyAgICAgICAgCisgICAgPGRlc2NyaXB0aW9uPgorICAgICAgICAlZGVzY3JpcHRpb24KKyAgICA8L2Rlc2NyaXB0aW9uPgorICAgICAgICAKKyAgICA8Y29weXJpZ2h0PgorICAgICAgICAlY29weXJpZ2h0CisgICAgPC9jb3B5cmlnaHQ+CisgICAgICAgIAorICAgIDxsaWNlbnNlIHVybD0iJWxpY2Vuc2VVUkwiPgorICAgICAgICAlbGljZW5zZQorICAgIDwvbGljZW5zZT4KKyAgICAgICAgCisgICAgPHBsdWdpbgorICAgICAgICBpZD0ib3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZSIKKyAgICAgICAgZG93bmxvYWQtc2l6ZT0iMCIKKyAgICAgICAgaW5zdGFsbC1zaXplPSIwIgorICAgICAgICB2ZXJzaW9uPSIwLjAuMCIKKyAgICAgICAgdW5wYWNrPSJmYWxzZSIvPgorICAgICAgICAKKyAgICA8cGx1Z2luCisgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLmFwaSIKKyAgICAgICAgZG93bmxvYWQtc2l6ZT0iMCIKKyAgICAgICAgaW5zdGFsbC1zaXplPSIwIgorICAgICAgICB2ZXJzaW9uPSIwLjAuMCIKKyAgICAgICAgdW5wYWNrPSJmYWxzZSIvPgorICAgICAgICAKKzwvZmVhdHVyZT4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3MvbGljZW5zZS5odG1sIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS5oZWFkbGVzcy9saWNlbnNlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNmU1NzlhNQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3MvbGljZW5zZS5odG1sCkBAIC0wLDAgKzEsMTY0IEBACis8IS0tP3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJJU08tODg1OS0xIiA/LS0+Cis8IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBTdHJpY3QvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtc3RyaWN0LmR0ZCI+Cis8aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+PGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1JU08tODg1OS0xIj4KKzx0aXRsZT5FY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L3RpdGxlPgorPC9oZWFkPgorCis8Ym9keSBsYW5nPSJFTi1VUyI+Cis8aDI+RWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9oMj4KKzxwPkZlYnJ1YXJ5IDEsIDIwMTE8L3A+CisKKzxoMz5Vc2FnZSBPZiBDb250ZW50PC9oMz4KKworPHA+VEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUiBPVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTCisgICAoQ09MTEVDVElWRUxZICJDT05URU5UIikuICBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5ECisgICBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVSBBR1JFRSBUSEFUIFlPVVIgVVNFCisgICBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUgorICAgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gIElGIFlPVSBETyBOT1QgQUdSRUUgVE8gVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORCBUSEUgVEVSTVMgQU5ECisgICBDT05ESVRJT05TIE9GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLCBUSEVOIFlPVSBNQVkgTk9UIFVTRSBUSEUgQ09OVEVOVC48L3A+CisKKzxoMz5BcHBsaWNhYmxlIExpY2Vuc2VzPC9oMz4KKworPHA+VW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlCisgRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSAKK0VjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAKKyAgICgiRVBMIikuICBBIGNvcHkgb2YgdGhlIEVQTCBpcyBwcm92aWRlZCB3aXRoIHRoaXMgQ29udGVudCBhbmQgaXMgYWxzbworIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L2E+LgorICAgRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICJQcm9ncmFtIiB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9wPgorCis8cD5Db250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSwgCitkb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gCitzb3VyY2UgY29kZQorICAgcmVwb3NpdG9yeSAoIlJlcG9zaXRvcnkiKSBpbiBzb2Z0d2FyZSBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIAorYXZhaWxhYmxlIGFzIGRvd25sb2FkYWJsZSBhcmNoaXZlcyAoIkRvd25sb2FkcyIpLjwvcD4KKworPHVsPgorICAgICAgIDxsaT5Db250ZW50IG1heSBiZSBzdHJ1Y3R1cmVkIGFuZCBwYWNrYWdlZCBpbnRvIG1vZHVsZXMgdG8gCitmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsIGV4dGVuZGluZywgYW5kIHVwZ3JhZGluZyB0aGUgQ29udGVudC4gIFR5cGljYWwgCittb2R1bGVzIG1heSBpbmNsdWRlIHBsdWctaW5zICgiUGx1Zy1pbnMiKSwgcGx1Zy1pbiBmcmFnbWVudHMgCisoIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLjwvbGk+CisgICAgICAgPGxpPkVhY2ggUGx1Zy1pbiBvciBGcmFnbWVudCBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IG9yIEpBUiAoSmF2YSYjODQ4MjsgQVJjaGl2ZSkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgInBsdWdpbnMiLjwvbGk+CisgICAgICAgPGxpPkEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgCitGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuICBFYWNoIEZlYXR1cmUgbWF5IGJlIHBhY2thZ2VkIGFzIGEgCitzdWItZGlyZWN0b3J5IGluIGEgZGlyZWN0b3J5IG5hbWVkICJmZWF0dXJlcyIuICBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyAKK25hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIAorb2YgdGhlIFBsdWctaW5zCisgICAgICBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuPC9saT4KKyAgICAgICA8bGk+RmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIAorRmVhdHVyZXMiKS4gV2l0aGluIGEgRmVhdHVyZSwgZmlsZXMgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIAorbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy48L2xpPgorPC91bD4KKworPHA+VGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZSAKK2NvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAiYWJvdXQuaHRtbCIgKCJBYm91dHMiKS4gVGhlIHRlcm1zIGFuZCAKK2NvbmRpdGlvbnMgZ292ZXJuaW5nIEZlYXR1cmVzIGFuZAorSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAibGljZW5zZS5odG1sIiAKKygiRmVhdHVyZSBMaWNlbnNlcyIpLiAgQWJvdXRzIGFuZCBGZWF0dXJlIExpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueQorIGRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZQoraW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyBsb2NhdGlvbnM6PC9wPgorCis8dWw+CisgICAgICAgPGxpPlRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeTwvbGk+CisgICAgICAgPGxpPlBsdWctaW4gYW5kIEZyYWdtZW50IGRpcmVjdG9yaWVzPC9saT4KKyAgICAgICA8bGk+SW5zaWRlIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgcGFja2FnZWQgYXMgSkFSczwvbGk+CisgICAgICAgPGxpPlN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnM8L2xpPgorICAgICAgIDxsaT5GZWF0dXJlIGRpcmVjdG9yaWVzPC9saT4KKzwvdWw+CisKKzxwPk5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIAoraW5zdGFsbGVkIHVzaW5nIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSAoYXMgZGVmaW5lZCBiZWxvdyksIHlvdSBtdXN0CisgYWdyZWUgdG8gYSBsaWNlbnNlICgiRmVhdHVyZSBVcGRhdGUgTGljZW5zZSIpIGR1cmluZyB0aGUKK2luc3RhbGxhdGlvbiBwcm9jZXNzLiAgSWYgdGhlIEZlYXR1cmUgY29udGFpbnMgSW5jbHVkZWQgRmVhdHVyZXMsIHRoZSAKK0ZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdSB3aXRoIHRoZSB0ZXJtcyBhbmQgCitjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IKK2luZm9ybSB5b3Ugd2hlcmUgeW91IGNhbiBsb2NhdGUgdGhlbS4gIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIG1heSBiZSAKK2ZvdW5kIGluIHRoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIgCitmb3VuZCB3aXRoaW4gYSBGZWF0dXJlLgorU3VjaCBBYm91dHMsIEZlYXR1cmUgTGljZW5zZXMsIGFuZCBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBjb250YWluIHRoZSAKK3Rlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgCitnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbgordGhhdCBkaXJlY3RvcnkuPC9wPgorCis8cD5USEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTLCBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSIAorVE8gVEhFIEVQTCBPUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuCisgIFNPTUUgT0YgVEhFU0UKK09USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6PC9wPgorCis8dWw+CisgICAgICAgPGxpPkVjbGlwc2UgRGlzdHJpYnV0aW9uIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xpY2Vuc2VzL2VkbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9saWNlbnNlcy9lZGwtdjEuMC5odG1sPC9hPik8L2xpPgorICAgICAgIDxsaT5Db21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWw8L2E+KTwvbGk+CisgICAgICAgPGxpPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRTwvYT4pPC9saT4KKyAgICAgICA8bGk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjA8L2E+KTwvbGk+CisgICAgICAgPGxpPk1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sIj5odHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbDwvYT4pPC9saT4KKyAgICAgICA8bGk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbCI+aHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sPC9hPik8L2xpPgorPC91bD4KKworPHA+SVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgCitDT05ESVRJT05TIFBSSU9SIFRPIFVTRSBPRiBUSEUgQ09OVEVOVC4gIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2UsIAorb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBpcyBwcm92aWRlZCwgcGxlYXNlCitjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIGNvbmRpdGlvbnMgCitnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuPC9wPgorCisKKzxoMz5Vc2Ugb2YgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3k8L2gzPgorCis8cD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBwcm92aXNpb25pbmcgc29mdHdhcmUsIAorZXhhbXBsZXMgb2Ygd2hpY2ggaW5jbHVkZSwgYnV0IGFyZSBub3QgbGltaXRlZCB0bywgcDIgYW5kIHRoZSBFY2xpcHNlCisgICBVcGRhdGUgTWFuYWdlciAoIlByb3Zpc2lvbmluZyBUZWNobm9sb2d5IikgZm9yIHRoZSBwdXJwb3NlIG9mIAorYWxsb3dpbmcgdXNlcnMgdG8gaW5zdGFsbCBzb2Z0d2FyZSwgZG9jdW1lbnRhdGlvbiwgaW5mb3JtYXRpb24gYW5kL29yCisgICBvdGhlciBtYXRlcmlhbHMgKGNvbGxlY3RpdmVseSAiSW5zdGFsbGFibGUgU29mdHdhcmUiKS4gVGhpcyAKK2NhcGFiaWxpdHkgaXMgcHJvdmlkZWQgd2l0aCB0aGUgaW50ZW50IG9mIGFsbG93aW5nIHN1Y2ggdXNlcnMgdG8KKyAgIGluc3RhbGwsIGV4dGVuZCBhbmQgdXBkYXRlIEVjbGlwc2UtYmFzZWQgcHJvZHVjdHMuIEluZm9ybWF0aW9uIGFib3V0IAorcGFja2FnaW5nIEluc3RhbGxhYmxlIFNvZnR3YXJlIGlzIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vZWNsaXBzZS5vcmcvZXF1aW5veC9wMi9yZXBvc2l0b3J5X3BhY2thZ2luZy5odG1sIj5odHRwOi8vZWNsaXBzZS5vcmcvZXF1aW5veC9wMi9yZXBvc2l0b3J5X3BhY2thZ2luZy5odG1sPC9hPgorICAgKCJTcGVjaWZpY2F0aW9uIikuPC9wPgorCis8cD5Zb3UgbWF5IHVzZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSB0byBhbGxvdyBvdGhlciBwYXJ0aWVzIHRvIGluc3RhbGwKKyBJbnN0YWxsYWJsZSBTb2Z0d2FyZS4gWW91IHNoYWxsIGJlIHJlc3BvbnNpYmxlIGZvciBlbmFibGluZyB0aGUKKyAgIGFwcGxpY2FibGUgbGljZW5zZSBhZ3JlZW1lbnRzIHJlbGF0aW5nIHRvIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSB0bworIGJlIHByZXNlbnRlZCB0bywgYW5kIGFjY2VwdGVkIGJ5LCB0aGUgdXNlcnMgb2YgdGhlIFByb3Zpc2lvbmluZyAKK1RlY2hub2xvZ3kKKyAgIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgU3BlY2lmaWNhdGlvbi4gQnkgdXNpbmcgUHJvdmlzaW9uaW5nIAorVGVjaG5vbG9neSBpbiBzdWNoIGEgbWFubmVyIGFuZCBtYWtpbmcgaXQgYXZhaWxhYmxlIGluIGFjY29yZGFuY2Ugd2l0aCAKK3RoZQorICAgU3BlY2lmaWNhdGlvbiwgeW91IGZ1cnRoZXIgYWNrbm93bGVkZ2UgeW91ciBhZ3JlZW1lbnQgdG8sIGFuZCB0aGUgCithY3F1aXNpdGlvbiBvZiBhbGwgbmVjZXNzYXJ5IHJpZ2h0cyB0byBwZXJtaXQgdGhlIGZvbGxvd2luZzo8L3A+CisKKzxvbD4KKyAgICAgICA8bGk+QSBzZXJpZXMgb2YgYWN0aW9ucyBtYXkgb2NjdXIgKCJQcm92aXNpb25pbmcgUHJvY2VzcyIpIGluIAord2hpY2ggYSB1c2VyIG1heSBleGVjdXRlIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neQorICAgICAgIG9uIGEgbWFjaGluZSAoIlRhcmdldCBNYWNoaW5lIikgd2l0aCB0aGUgaW50ZW50IG9mIGluc3RhbGxpbmcsIAorZXh0ZW5kaW5nIG9yIHVwZGF0aW5nIHRoZSBmdW5jdGlvbmFsaXR5IG9mIGFuIEVjbGlwc2UtYmFzZWQKKyAgICAgICBwcm9kdWN0LjwvbGk+CisgICAgICAgPGxpPkR1cmluZyB0aGUgUHJvdmlzaW9uaW5nIFByb2Nlc3MsIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSAKK21heSBjYXVzZSB0aGlyZCBwYXJ0eSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBvciBhIHBvcnRpb24gdGhlcmVvZiB0byBiZQorICAgICAgIGFjY2Vzc2VkIGFuZCBjb3BpZWQgdG8gdGhlIFRhcmdldCBNYWNoaW5lLjwvbGk+CisgICAgICAgPGxpPlB1cnN1YW50IHRvIHRoZSBTcGVjaWZpY2F0aW9uLCB5b3Ugd2lsbCBwcm92aWRlIHRvIHRoZSB1c2VyIAordGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIHRoYXQgZ292ZXJuIHRoZSB1c2Ugb2YgdGhlIEluc3RhbGxhYmxlCisgICAgICAgU29mdHdhcmUgKCJJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQiKSBhbmQgc3VjaCBJbnN0YWxsYWJsZSAKK1NvZnR3YXJlIEFncmVlbWVudCBzaGFsbCBiZSBhY2Nlc3NlZCBmcm9tIHRoZSBUYXJnZXQKKyAgICAgICBNYWNoaW5lIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgU3BlY2lmaWNhdGlvbi4gU3VjaCBJbnN0YWxsYWJsZSAKK1NvZnR3YXJlIEFncmVlbWVudCBtdXN0IGluZm9ybSB0aGUgdXNlciBvZiB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgdGhhdAorIGdvdmVybgorICAgICAgIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBhbmQgbXVzdCBzb2xpY2l0IGFjY2VwdGFuY2UgYnkgdGhlIGVuZCAKK3VzZXIgaW4gdGhlIG1hbm5lciBwcmVzY3JpYmVkIGluIHN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50LiAKK1Vwb24gc3VjaAorICAgICAgIGluZGljYXRpb24gb2YgYWdyZWVtZW50IGJ5IHRoZSB1c2VyLCB0aGUgcHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgCit3aWxsIGNvbXBsZXRlIGluc3RhbGxhdGlvbiBvZiB0aGUgSW5zdGFsbGFibGUgU29mdHdhcmUuPC9saT4KKzwvb2w+CisKKzxoMz5DcnlwdG9ncmFwaHk8L2gzPgorCis8cD5Db250ZW50IG1heSBjb250YWluIGVuY3J5cHRpb24gc29mdHdhcmUuIFRoZSBjb3VudHJ5IGluIHdoaWNoIHlvdSBhcmUKKyBjdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsIAorYW5kL29yIHJlLWV4cG9ydCB0bworICAgYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkUgdXNpbmcgYW55IGVuY3J5cHRpb24gCitzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cywgcmVndWxhdGlvbnMgYW5kIHBvbGljaWVzIAorY29uY2VybmluZyB0aGUgaW1wb3J0LAorICAgcG9zc2Vzc2lvbiwgb3IgdXNlLCBhbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIHRvIHNlZSBpZiAKK3RoaXMgaXMgcGVybWl0dGVkLjwvcD4KKworPHA+PHNtYWxsPkphdmEgYW5kIGFsbCBKYXZhLWJhc2VkIHRyYWRlbWFya3MgYXJlIHRyYWRlbWFya3Mgb2YgT3JhY2xlIENvcnBvcmF0aW9uIGluIHRoZSBVbml0ZWQgU3RhdGVzLCBvdGhlciBjb3VudHJpZXMsIG9yIGJvdGguPC9zbWFsbD48L3A+CisKKworPC9ib2R5PjwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLmhlYWRsZXNzL3BvbS54bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLmhlYWRsZXNzL3BvbS54bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMzU2MmEzMwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3MvcG9tLnhtbApAQCAtMCwwICsxLDg0IEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPCEtLSM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4KKzwhLS0jIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIEx1bmlmZXJhIEdtYkggKEdyb3NzIEVuemVyc2RvcmYpLCBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KSAtLT4KKzwhLS0jIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMgLS0+Cis8IS0tIyBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAgLS0+Cis8IS0tIyB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdCAtLT4KKzwhLS0jIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIC0tPgorPCEtLSMgLS0+Cis8IS0tIyBDb250cmlidXRvcnM6IC0tPgorPCEtLSMgICAgIEtsZW1lbnMgRWRsZXIgKEx1bmlmZXJhIEdtYkgpIC0gaW5pdGlhbCBBUEkgYW5kIGltcGxlbWVudGF0aW9uIC0tPgorPCEtLSM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4KKworPHByb2plY3QgeG1sbnM9Imh0dHA6Ly9tYXZlbi5hcGFjaGUub3JnL1BPTS80LjAuMCIgeG1sbnM6eHNpPSJodHRwOi8vd3d3LnczLm9yZy8yMDAxL1hNTFNjaGVtYS1pbnN0YW5jZSIgeHNpOnNjaGVtYUxvY2F0aW9uPSJodHRwOi8vbWF2ZW4uYXBhY2hlLm9yZy9QT00vNC4wLjAgaHR0cDovL21hdmVuLmFwYWNoZS5vcmcvbWF2ZW4tdjRfMF8wLnhzZCI+CisgICAgPG1vZGVsVmVyc2lvbj40LjAuMDwvbW9kZWxWZXJzaW9uPgorCisgICAgPHBhcmVudD4KKyAgICAgICAgPGdyb3VwSWQ+b3JnLmVjbGlwc2Uub3NicC5pZGU8L2dyb3VwSWQ+CisgICAgICAgIDxhcnRpZmFjdElkPm9yZy5lY2xpcHNlLm9zYnAuaWRlPC9hcnRpZmFjdElkPgorICAgICAgICA8dmVyc2lvbj4wLjkuMC1TTkFQU0hPVDwvdmVyc2lvbj4KKyAgICA8L3BhcmVudD4KKworICAgIDxhcnRpZmFjdElkPm9yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3M8L2FydGlmYWN0SWQ+CisgICAgPHBhY2thZ2luZz5lY2xpcHNlLWZlYXR1cmU8L3BhY2thZ2luZz4KKworICAgIDxkZXBlbmRlbmNpZXM+CisgICAgCisgICAgPC9kZXBlbmRlbmNpZXM+CisKKyAgICA8YnVpbGQ+CisgICAgICAgIDxwbHVnaW5zPgorICAgICAgICAgICAgPHBsdWdpbj4KKyAgICAgICAgICAgICAgICA8Z3JvdXBJZD5vcmcuZWNsaXBzZS50eWNoby5leHRyYXM8L2dyb3VwSWQ+CisgICAgICAgICAgICAgICAgPGFydGlmYWN0SWQ+dHljaG8tc291cmNlLWZlYXR1cmUtcGx1Z2luPC9hcnRpZmFjdElkPgorICAgICAgICAgICAgICAgIDx2ZXJzaW9uPiR7dHljaG8tdmVyc2lvbn08L3ZlcnNpb24+CisgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbnM+CisgICAgICAgICAgICAgICAgICAgIDxleGVjdXRpb24+CisgICAgICAgICAgICAgICAgICAgICAgICA8aWQ+c291cmNlLWZlYXR1cmU8L2lkPgorICAgICAgICAgICAgICAgICAgICAgICAgPHBoYXNlPnBhY2thZ2U8L3BoYXNlPgorICAgICAgICAgICAgICAgICAgICAgICAgPGdvYWxzPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxnb2FsPnNvdXJjZS1mZWF0dXJlPC9nb2FsPgorICAgICAgICAgICAgICAgICAgICAgICAgPC9nb2Fscz4KKyAgICAgICAgICAgICAgICAgICAgPC9leGVjdXRpb24+CisgICAgICAgICAgICAgICAgPC9leGVjdXRpb25zPgorICAgICAgICAgICAgICAgIDxjb25maWd1cmF0aW9uPgorICAgICAgICAgICAgICAgICAgICA8bGFiZWxTdWZmaXg+IChzb3VyY2UpPC9sYWJlbFN1ZmZpeD4KKyAgICAgICAgICAgICAgICAgICAgPGV4Y2x1ZGVzPgorICAgICAgICAgICAgICAgICAgICAgICAgPHBsdWdpbiBpZD0iY29tLmlibS5pY3UiLz4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxwbHVnaW4gaWQ9Im9yZy5hcGFjaGUuY29tbW9ucy5jbGkiLz4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxwbHVnaW4gaWQ9ImNvbS5nb29nbGUuZ3VhdmEiLz4KKyAgICAgICAgICAgICAgICAgICAgPC9leGNsdWRlcz4KKyAgICAgICAgICAgICAgICA8L2NvbmZpZ3VyYXRpb24+CisgICAgICAgICAgICA8L3BsdWdpbj4KKyAgICAgICAgICAgIDxwbHVnaW4+CisgICAgICAgICAgICAgICAgPCEtLSB3b3JrYXJvdW5kIHdoaWxlIGJ1ZyBodHRwczovL2J1Z3MuZWNsaXBzZS5vcmcvYnVncy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4MjUwIAorCQkJCQlpcyBub3QgZml4ZWQgLS0+CisgICAgICAgICAgICAgICAgPGdyb3VwSWQ+b3JnLmVjbGlwc2UudHljaG88L2dyb3VwSWQ+CisgICAgICAgICAgICAgICAgPGFydGlmYWN0SWQ+dHljaG8tcDItcGx1Z2luPC9hcnRpZmFjdElkPgorICAgICAgICAgICAgICAgIDx2ZXJzaW9uPiR7dHljaG8tdmVyc2lvbn08L3ZlcnNpb24+CisgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbnM+CisgICAgICAgICAgICAgICAgICAgIDxleGVjdXRpb24+CisgICAgICAgICAgICAgICAgICAgICAgICA8aWQ+YXR0YWNoZWQtcDItbWV0YWRhdGE8L2lkPgorICAgICAgICAgICAgICAgICAgICAgICAgPHBoYXNlPnBhY2thZ2U8L3BoYXNlPgorICAgICAgICAgICAgICAgICAgICAgICAgPGdvYWxzPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxnb2FsPnAyLW1ldGFkYXRhPC9nb2FsPgorICAgICAgICAgICAgICAgICAgICAgICAgPC9nb2Fscz4KKyAgICAgICAgICAgICAgICAgICAgPC9leGVjdXRpb24+CisgICAgICAgICAgICAgICAgPC9leGVjdXRpb25zPgorICAgICAgICAgICAgPC9wbHVnaW4+CisJCQk8cGx1Z2luPgorCQkJCTxhcnRpZmFjdElkPm1hdmVuLWphdmFkb2MtcGx1Z2luPC9hcnRpZmFjdElkPgorCQkJCTxleGVjdXRpb25zPgorCQkJCQk8ZXhlY3V0aW9uPgorCQkJCQkJPGlkPmphdmFkb2MtamFyPC9pZD4KKwkJCQkJCTxwaGFzZT5wYWNrYWdlPC9waGFzZT4KKwkJCQkJCTxnb2Fscz4KKwkJCQkJCQk8Z29hbD5qYXI8L2dvYWw+CisJCQkJCQk8L2dvYWxzPgorCQkJCQk8L2V4ZWN1dGlvbj4KKwkJCQk8L2V4ZWN1dGlvbnM+CisJCQk8L3BsdWdpbj4KKyAgICAgICAgPC9wbHVnaW5zPgorICAgIDwvYnVpbGQ+CisKKzwvcHJvamVjdD4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3Mvc3JjL21haW4vamF2YWRvYy9SRUFETUUudHh0IGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS5oZWFkbGVzcy9zcmMvbWFpbi9qYXZhZG9jL1JFQURNRS50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODMxZGE3ZQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3Mvc3JjL21haW4vamF2YWRvYy9SRUFETUUudHh0CkBAIC0wLDAgKzEgQEAKK1Jlc291cmNlIGZvbGRlciBmb3IgamF2YWRvYyByZXNvdXJjZXMuClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS5oZWFkbGVzcy9zcmMvb3ZlcnZpZXcuaHRtbCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3Mvc3JjL292ZXJ2aWV3Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNzhhMWM2ZAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUuaGVhZGxlc3Mvc3JjL292ZXJ2aWV3Lmh0bWwKQEAgLTAsMCArMSwxMSBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMCBUcmFuc2l0aW9uYWwvL0VOIj4KKzxodG1sPgorPGhlYWQ+CisJPHRpdGxlPk9TQlAgcnVudGltZSB3ZWIgdmFhZGluIGNvbXBvbmVudHMgZmVhdHVyZSBPdmVydmlldzwvdGl0bGU+Cis8L2hlYWQ+Cis8Ym9keT4KKzxwPlRoZSA8Yj5PU0JQJm5ic3A7ZmVhdHVyZTwvYj4gY29udGFpbnMgYWxsIGZlYXR1cmVzIHJlcXVpcmVkIGZvciBPU0JQIGludG8gdGhlIElERTwvcD4KKworPHA+Jm5ic3A7PC9wPgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy8ucHJvamVjdCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudG9vbHMvLnByb2plY3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZjNiYTQ1ZQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudG9vbHMvLnByb2plY3QKQEAgLTAsMCArMSwzNCBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KKzxwcm9qZWN0RGVzY3JpcHRpb24+CisJPG5hbWU+b3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29sczwvbmFtZT4KKwk8Y29tbWVudD48L2NvbW1lbnQ+CisJPHByb2plY3RzPgorCTwvcHJvamVjdHM+CisJPGJ1aWxkU3BlYz4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLnh0ZXh0LnVpLnNoYXJlZC54dGV4dEJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLkZlYXR1cmVCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5zb25hcmxpbnQuZWNsaXBzZS5jb3JlLnNvbmFybGludEJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UubTJlLmNvcmUubWF2ZW4yQnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJPC9idWlsZFNwZWM+CisJPG5hdHVyZXM+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UueHRleHQudWkuc2hhcmVkLnh0ZXh0TmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UubTJlLmNvcmUubWF2ZW4yTmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UucGRlLkZlYXR1cmVOYXR1cmU8L25hdHVyZT4KKwk8L25hdHVyZXM+Cis8L3Byb2plY3REZXNjcmlwdGlvbj4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudG9vbHMvTElDRU5TRS50eHQgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnRvb2xzL0xJQ0VOU0UudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmZmNDJhZDQKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnRvb2xzL0xJQ0VOU0UudHh0CkBAIC0wLDAgKzEsMTYxIEBACitFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC12IDEuMAorCitUSEUgQUNDT01QQU5ZSU5HIFBST0dSQU0gSVMgUFJPVklERUQgVU5ERVIgVEhFIFRFUk1TIE9GIFRISVMgRUNMSVBTRSBQVUJMSUMgTElDRU5TRSAoIkFHUkVFTUVOVCIpLiBBTlkgVVNFLCBSRVBST0RVQ1RJT04KK09SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBDT05TVElUVVRFUyBSRUNJUElFTlQnUyBBQ0NFUFRBTkNFIE9GIFRISVMgQUdSRUVNRU5ULgorCisxLiBERUZJTklUSU9OUworCisiQ29udHJpYnV0aW9uIiBtZWFuczoKKworYSkgaW4gdGhlIGNhc2Ugb2YgdGhlIGluaXRpYWwgQ29udHJpYnV0b3IsIHRoZSBpbml0aWFsIGNvZGUgYW5kIGRvY3VtZW50YXRpb24gZGlzdHJpYnV0ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGFuZAorCitiKSBpbiB0aGUgY2FzZSBvZiBlYWNoIHN1YnNlcXVlbnQgQ29udHJpYnV0b3I6CisKK2kpIGNoYW5nZXMgdG8gdGhlIFByb2dyYW0sIGFuZAorCitpaSkgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtOworCit3aGVyZSBzdWNoIGNoYW5nZXMgYW5kL29yIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbSBvcmlnaW5hdGUgZnJvbSBhbmQgYXJlIGRpc3RyaWJ1dGVkIGJ5IHRoYXQgcGFydGljdWxhciBDb250cmlidXRvci4KK0EgQ29udHJpYnV0aW9uICdvcmlnaW5hdGVzJyBmcm9tIGEgQ29udHJpYnV0b3IgaWYgaXQgd2FzIGFkZGVkIHRvIHRoZSBQcm9ncmFtIGJ5IHN1Y2ggQ29udHJpYnV0b3IgaXRzZWxmIG9yIGFueW9uZQorYWN0aW5nIG9uIHN1Y2ggQ29udHJpYnV0b3IncyBiZWhhbGYuIENvbnRyaWJ1dGlvbnMgZG8gbm90IGluY2x1ZGUgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIHdoaWNoOiAoaSkgYXJlIHNlcGFyYXRlCittb2R1bGVzIG9mIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIGluIGNvbmp1bmN0aW9uIHdpdGggdGhlIFByb2dyYW0gdW5kZXIgdGhlaXIgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBhbmQgKGlpKSBhcmUgbm90CitkZXJpdmF0aXZlIHdvcmtzIG9mIHRoZSBQcm9ncmFtLgorCisiQ29udHJpYnV0b3IiIG1lYW5zIGFueSBwZXJzb24gb3IgZW50aXR5IHRoYXQgZGlzdHJpYnV0ZXMgdGhlIFByb2dyYW0uCisKKyJMaWNlbnNlZCBQYXRlbnRzICIgbWVhbiBwYXRlbnQgY2xhaW1zIGxpY2Vuc2FibGUgYnkgYSBDb250cmlidXRvciB3aGljaCBhcmUgbmVjZXNzYXJpbHkgaW5mcmluZ2VkIGJ5IHRoZSB1c2Ugb3Igc2FsZSBvZgoraXRzIENvbnRyaWJ1dGlvbiBhbG9uZSBvciB3aGVuIGNvbWJpbmVkIHdpdGggdGhlIFByb2dyYW0uCisKKyJQcm9ncmFtIiBtZWFucyB0aGUgQ29udHJpYnV0aW9ucyBkaXN0cmlidXRlZCBpbiBhY2NvcmRhbmNlIHdpdGggdGhpcyBBZ3JlZW1lbnQuCisKKyJSZWNpcGllbnQiIG1lYW5zIGFueW9uZSB3aG8gcmVjZWl2ZXMgdGhlIFByb2dyYW0gdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGluY2x1ZGluZyBhbGwgQ29udHJpYnV0b3JzLgorCisyLiBHUkFOVCBPRiBSSUdIVFMKKworYSkgU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsCityb3lhbHR5LWZyZWUgY29weXJpZ2h0IGxpY2Vuc2UgdG8gcmVwcm9kdWNlLCBwcmVwYXJlIGRlcml2YXRpdmUgd29ya3Mgb2YsIHB1YmxpY2x5IGRpc3BsYXksIHB1YmxpY2x5IHBlcmZvcm0sIGRpc3RyaWJ1dGUKK2FuZCBzdWJsaWNlbnNlIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBhbmQgc3VjaCBkZXJpdmF0aXZlIHdvcmtzLCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUKK2Zvcm0uCisKK2IpIFN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLAorcm95YWx0eS1mcmVlIHBhdGVudCBsaWNlbnNlIHVuZGVyIExpY2Vuc2VkIFBhdGVudHMgdG8gbWFrZSwgdXNlLCBzZWxsLCBvZmZlciB0byBzZWxsLCBpbXBvcnQgYW5kIG90aGVyd2lzZSB0cmFuc2ZlciB0aGUKK0NvbnRyaWJ1dGlvbiBvZiBzdWNoIENvbnRyaWJ1dG9yLCBpZiBhbnksIGluIHNvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLiBUaGlzIHBhdGVudCBsaWNlbnNlIHNoYWxsIGFwcGx5IHRvIHRoZQorY29tYmluYXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBhbmQgdGhlIFByb2dyYW0gaWYsIGF0IHRoZSB0aW1lIHRoZSBDb250cmlidXRpb24gaXMgYWRkZWQgYnkgdGhlIENvbnRyaWJ1dG9yLCBzdWNoCithZGRpdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGNhdXNlcyBzdWNoIGNvbWJpbmF0aW9uIHRvIGJlIGNvdmVyZWQgYnkgdGhlIExpY2Vuc2VkIFBhdGVudHMuIFRoZSBwYXRlbnQgbGljZW5zZSBzaGFsbCBub3QKK2FwcGx5IHRvIGFueSBvdGhlciBjb21iaW5hdGlvbnMgd2hpY2ggaW5jbHVkZSB0aGUgQ29udHJpYnV0aW9uLiBObyBoYXJkd2FyZSBwZXIgc2UgaXMgbGljZW5zZWQgaGVyZXVuZGVyLgorCitjKSBSZWNpcGllbnQgdW5kZXJzdGFuZHMgdGhhdCBhbHRob3VnaCBlYWNoIENvbnRyaWJ1dG9yIGdyYW50cyB0aGUgbGljZW5zZXMgdG8gaXRzIENvbnRyaWJ1dGlvbnMgc2V0IGZvcnRoIGhlcmVpbiwgbm8KK2Fzc3VyYW5jZXMgYXJlIHByb3ZpZGVkIGJ5IGFueSBDb250cmlidXRvciB0aGF0IHRoZSBQcm9ncmFtIGRvZXMgbm90IGluZnJpbmdlIHRoZSBwYXRlbnQgb3Igb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5CityaWdodHMgb2YgYW55IG90aGVyIGVudGl0eS4gRWFjaCBDb250cmlidXRvciBkaXNjbGFpbXMgYW55IGxpYWJpbGl0eSB0byBSZWNpcGllbnQgZm9yIGNsYWltcyBicm91Z2h0IGJ5IGFueSBvdGhlciBlbnRpdHkKK2Jhc2VkIG9uIGluZnJpbmdlbWVudCBvZiBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG9yIG90aGVyd2lzZS4gQXMgYSBjb25kaXRpb24gdG8gZXhlcmNpc2luZyB0aGUgcmlnaHRzIGFuZAorbGljZW5zZXMgZ3JhbnRlZCBoZXJldW5kZXIsIGVhY2ggUmVjaXBpZW50IGhlcmVieSBhc3N1bWVzIHNvbGUgcmVzcG9uc2liaWxpdHkgdG8gc2VjdXJlIGFueSBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkKK3JpZ2h0cyBuZWVkZWQsIGlmIGFueS4gRm9yIGV4YW1wbGUsIGlmIGEgdGhpcmQgcGFydHkgcGF0ZW50IGxpY2Vuc2UgaXMgcmVxdWlyZWQgdG8gYWxsb3cgUmVjaXBpZW50IHRvIGRpc3RyaWJ1dGUgdGhlCitQcm9ncmFtLCBpdCBpcyBSZWNpcGllbnQncyByZXNwb25zaWJpbGl0eSB0byBhY3F1aXJlIHRoYXQgbGljZW5zZSBiZWZvcmUgZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtLgorCitkKSBFYWNoIENvbnRyaWJ1dG9yIHJlcHJlc2VudHMgdGhhdCB0byBpdHMga25vd2xlZGdlIGl0IGhhcyBzdWZmaWNpZW50IGNvcHlyaWdodCByaWdodHMgaW4gaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCB0bworZ3JhbnQgdGhlIGNvcHlyaWdodCBsaWNlbnNlIHNldCBmb3J0aCBpbiB0aGlzIEFncmVlbWVudC4KKworMy4gUkVRVUlSRU1FTlRTCisKK0EgQ29udHJpYnV0b3IgbWF5IGNob29zZSB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtIGluIG9iamVjdCBjb2RlIGZvcm0gdW5kZXIgaXRzIG93biBsaWNlbnNlIGFncmVlbWVudCwgcHJvdmlkZWQgdGhhdDoKKworYSkgaXQgY29tcGxpZXMgd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQ7IGFuZAorCitiKSBpdHMgbGljZW5zZSBhZ3JlZW1lbnQ6CisKK2kpIGVmZmVjdGl2ZWx5IGRpc2NsYWltcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgd2FycmFudGllcyBhbmQgY29uZGl0aW9ucywgZXhwcmVzcyBhbmQgaW1wbGllZCwgaW5jbHVkaW5nCit3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgdGl0bGUgYW5kIG5vbi1pbmZyaW5nZW1lbnQsIGFuZCBpbXBsaWVkIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiBtZXJjaGFudGFiaWxpdHkgYW5kCitmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZTsKKworaWkpIGVmZmVjdGl2ZWx5IGV4Y2x1ZGVzIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCBsaWFiaWxpdHkgZm9yIGRhbWFnZXMsIGluY2x1ZGluZyBkaXJlY3QsIGluZGlyZWN0LCBzcGVjaWFsLAoraW5jaWRlbnRhbCBhbmQgY29uc2VxdWVudGlhbCBkYW1hZ2VzLCBzdWNoIGFzIGxvc3QgcHJvZml0czsKKworaWlpKSBzdGF0ZXMgdGhhdCBhbnkgcHJvdmlzaW9ucyB3aGljaCBkaWZmZXIgZnJvbSB0aGlzIEFncmVlbWVudCBhcmUgb2ZmZXJlZCBieSB0aGF0IENvbnRyaWJ1dG9yIGFsb25lIGFuZCBub3QgYnkgYW55CitvdGhlciBwYXJ0eTsgYW5kCisKK2l2KSBzdGF0ZXMgdGhhdCBzb3VyY2UgY29kZSBmb3IgdGhlIFByb2dyYW0gaXMgYXZhaWxhYmxlIGZyb20gc3VjaCBDb250cmlidXRvciwgYW5kIGluZm9ybXMgbGljZW5zZWVzIGhvdyB0byBvYnRhaW4gaXQKK2luIGEgcmVhc29uYWJsZSBtYW5uZXIgb24gb3IgdGhyb3VnaCBhIG1lZGl1bSBjdXN0b21hcmlseSB1c2VkIGZvciBzb2Z0d2FyZSBleGNoYW5nZS4KKworV2hlbiB0aGUgUHJvZ3JhbSBpcyBtYWRlIGF2YWlsYWJsZSBpbiBzb3VyY2UgY29kZSBmb3JtOgorCithKSBpdCBtdXN0IGJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoaXMgQWdyZWVtZW50OyBhbmQKKworYikgYSBjb3B5IG9mIHRoaXMgQWdyZWVtZW50IG11c3QgYmUgaW5jbHVkZWQgd2l0aCBlYWNoIGNvcHkgb2YgdGhlIFByb2dyYW0uCisKK0NvbnRyaWJ1dG9ycyBtYXkgbm90IHJlbW92ZSBvciBhbHRlciBhbnkgY29weXJpZ2h0IG5vdGljZXMgY29udGFpbmVkIHdpdGhpbiB0aGUgUHJvZ3JhbS4KKworRWFjaCBDb250cmlidXRvciBtdXN0IGlkZW50aWZ5IGl0c2VsZiBhcyB0aGUgb3JpZ2luYXRvciBvZiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIGluIGEgbWFubmVyIHRoYXQgcmVhc29uYWJseSBhbGxvd3MKK3N1YnNlcXVlbnQgUmVjaXBpZW50cyB0byBpZGVudGlmeSB0aGUgb3JpZ2luYXRvciBvZiB0aGUgQ29udHJpYnV0aW9uLgorCis0LiBDT01NRVJDSUFMIERJU1RSSUJVVElPTgorCitDb21tZXJjaWFsIGRpc3RyaWJ1dG9ycyBvZiBzb2Z0d2FyZSBtYXkgYWNjZXB0IGNlcnRhaW4gcmVzcG9uc2liaWxpdGllcyB3aXRoIHJlc3BlY3QgdG8gZW5kIHVzZXJzLCBidXNpbmVzcyBwYXJ0bmVycyBhbmQKK3RoZSBsaWtlLiBXaGlsZSB0aGlzIGxpY2Vuc2UgaXMgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY29tbWVyY2lhbCB1c2Ugb2YgdGhlIFByb2dyYW0sIHRoZSBDb250cmlidXRvciB3aG8gaW5jbHVkZXMKK3RoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nIHNob3VsZCBkbyBzbyBpbiBhIG1hbm5lciB3aGljaCBkb2VzIG5vdCBjcmVhdGUgcG90ZW50aWFsIGxpYWJpbGl0eSBmb3IKK290aGVyIENvbnRyaWJ1dG9ycy4gVGhlcmVmb3JlLCBpZiBhIENvbnRyaWJ1dG9yIGluY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBzdWNoIENvbnRyaWJ1dG9yCisoIkNvbW1lcmNpYWwgQ29udHJpYnV0b3IiKSBoZXJlYnkgYWdyZWVzIHRvIGRlZmVuZCBhbmQgaW5kZW1uaWZ5IGV2ZXJ5IG90aGVyIENvbnRyaWJ1dG9yICgiSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IiKQorYWdhaW5zdCBhbnkgbG9zc2VzLCBkYW1hZ2VzIGFuZCBjb3N0cyAoY29sbGVjdGl2ZWx5ICJMb3NzZXMiKSBhcmlzaW5nIGZyb20gY2xhaW1zLCBsYXdzdWl0cyBhbmQgb3RoZXIgbGVnYWwgYWN0aW9ucworYnJvdWdodCBieSBhIHRoaXJkIHBhcnR5IGFnYWluc3QgdGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIHRvIHRoZSBleHRlbnQgY2F1c2VkIGJ5IHRoZSBhY3RzIG9yIG9taXNzaW9ucyBvZiBzdWNoCitDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluIGNvbm5lY3Rpb24gd2l0aCBpdHMgZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLiBUaGUKK29ibGlnYXRpb25zIGluIHRoaXMgc2VjdGlvbiBkbyBub3QgYXBwbHkgdG8gYW55IGNsYWltcyBvciBMb3NzZXMgcmVsYXRpbmcgdG8gYW55IGFjdHVhbCBvciBhbGxlZ2VkIGludGVsbGVjdHVhbAorcHJvcGVydHkgaW5mcmluZ2VtZW50LiBJbiBvcmRlciB0byBxdWFsaWZ5LCBhbiBJbmRlbW5pZmllZCBDb250cmlidXRvciBtdXN0OiBhKSBwcm9tcHRseSBub3RpZnkgdGhlIENvbW1lcmNpYWwKK0NvbnRyaWJ1dG9yIGluIHdyaXRpbmcgb2Ygc3VjaCBjbGFpbSwgYW5kIGIpIGFsbG93IHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRvIGNvbnRyb2wsIGFuZCBjb29wZXJhdGUgd2l0aCB0aGUKK0NvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4sIHRoZSBkZWZlbnNlIGFuZCBhbnkgcmVsYXRlZCBzZXR0bGVtZW50IG5lZ290aWF0aW9ucy4gVGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG1heQorIHBhcnRpY2lwYXRlIGluIGFueSBzdWNoIGNsYWltIGF0IGl0cyBvd24gZXhwZW5zZS4KKworRm9yIGV4YW1wbGUsIGEgQ29udHJpYnV0b3IgbWlnaHQgaW5jbHVkZSB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgUHJvZHVjdCBYLiBUaGF0IENvbnRyaWJ1dG9yIGlzCit0aGVuIGEgQ29tbWVyY2lhbCBDb250cmlidXRvci4gSWYgdGhhdCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRoZW4gbWFrZXMgcGVyZm9ybWFuY2UgY2xhaW1zLCBvciBvZmZlcnMgd2FycmFudGllcworcmVsYXRlZCB0byBQcm9kdWN0IFgsIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcyBhcmUgc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yJ3MgcmVzcG9uc2liaWxpdHkgYWxvbmUuCitVbmRlciB0aGlzIHNlY3Rpb24sIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHdvdWxkIGhhdmUgdG8gZGVmZW5kIGNsYWltcyBhZ2FpbnN0IHRoZSBvdGhlciBDb250cmlidXRvcnMgcmVsYXRlZCB0bwordGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZCB3YXJyYW50aWVzLCBhbmQgaWYgYSBjb3VydCByZXF1aXJlcyBhbnkgb3RoZXIgQ29udHJpYnV0b3IgdG8gcGF5IGFueSBkYW1hZ2VzIGFzIGEgcmVzdWx0LAordGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgbXVzdCBwYXkgdGhvc2UgZGFtYWdlcy4KKworNS4gTk8gV0FSUkFOVFkKKworRVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUyBBR1JFRU1FTlQsIFRIRSBQUk9HUkFNIElTIFBST1ZJREVEIE9OIEFOICJBUyBJUyIgQkFTSVMsIFdJVEhPVVQgV0FSUkFOVElFUyBPUgorQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgRUlUSEVSIEVYUFJFU1MgT1IgSU1QTElFRCBJTkNMVURJTkcsIFdJVEhPVVQgTElNSVRBVElPTiwgQU5ZIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBUSVRMRSwKK05PTi1JTkZSSU5HRU1FTlQsIE1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gRWFjaCBSZWNpcGllbnQgaXMgc29sZWx5IHJlc3BvbnNpYmxlIGZvcgorZGV0ZXJtaW5pbmcgdGhlIGFwcHJvcHJpYXRlbmVzcyBvZiB1c2luZyBhbmQgZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtIGFuZCBhc3N1bWVzIGFsbCByaXNrcyBhc3NvY2lhdGVkIHdpdGggaXRzCitleGVyY2lzZSBvZiByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgLCBpbmNsdWRpbmcgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSByaXNrcyBhbmQgY29zdHMgb2YgcHJvZ3JhbSBlcnJvcnMsIGNvbXBsaWFuY2UKK3dpdGggYXBwbGljYWJsZSBsYXdzLCBkYW1hZ2UgdG8gb3IgbG9zcyBvZiBkYXRhLCBwcm9ncmFtcyBvciBlcXVpcG1lbnQsIGFuZCB1bmF2YWlsYWJpbGl0eSBvciBpbnRlcnJ1cHRpb24gb2Ygb3BlcmF0aW9ucy4KKworNi4gRElTQ0xBSU1FUiBPRiBMSUFCSUxJVFkKKworRVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUyBBR1JFRU1FTlQsIE5FSVRIRVIgUkVDSVBJRU5UIE5PUiBBTlkgQ09OVFJJQlVUT1JTIFNIQUxMIEhBVkUgQU5ZIExJQUJJTElUWSBGT1IgQU5ZCitESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HIFdJVEhPVVQgTElNSVRBVElPTiBMT1NUIFBST0ZJVFMpLAorSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUgorT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIE9SIFRIRSBFWEVSQ0lTRSBPRiBBTlkgUklHSFRTIEdSQU5URUQKK0hFUkVVTkRFUiwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRVMuCisKKzcuIEdFTkVSQUwKKworSWYgYW55IHByb3Zpc2lvbiBvZiB0aGlzIEFncmVlbWVudCBpcyBpbnZhbGlkIG9yIHVuZW5mb3JjZWFibGUgdW5kZXIgYXBwbGljYWJsZSBsYXcsIGl0IHNoYWxsIG5vdCBhZmZlY3QgdGhlIHZhbGlkaXR5IG9yCitlbmZvcmNlYWJpbGl0eSBvZiB0aGUgcmVtYWluZGVyIG9mIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgYW5kIHdpdGhvdXQgZnVydGhlciBhY3Rpb24gYnkgdGhlIHBhcnRpZXMgaGVyZXRvLCBzdWNoCitwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlIG1pbmltdW0gZXh0ZW50IG5lY2Vzc2FyeSB0byBtYWtlIHN1Y2ggcHJvdmlzaW9uIHZhbGlkIGFuZCBlbmZvcmNlYWJsZS4KKworSWYgUmVjaXBpZW50IGluc3RpdHV0ZXMgcGF0ZW50IGxpdGlnYXRpb24gYWdhaW5zdCBhbnkgZW50aXR5IChpbmNsdWRpbmcgYSBjcm9zcy1jbGFpbSBvciBjb3VudGVyY2xhaW0gaW4gYSBsYXdzdWl0KQorYWxsZWdpbmcgdGhhdCB0aGUgUHJvZ3JhbSBpdHNlbGYgKGV4Y2x1ZGluZyBjb21iaW5hdGlvbnMgb2YgdGhlIFByb2dyYW0gd2l0aCBvdGhlciBzb2Z0d2FyZSBvciBoYXJkd2FyZSkgaW5mcmluZ2VzIHN1Y2gKK1JlY2lwaWVudCdzIHBhdGVudChzKSwgdGhlbiBzdWNoIFJlY2lwaWVudCdzIHJpZ2h0cyBncmFudGVkIHVuZGVyIFNlY3Rpb24gMihiKSBzaGFsbCB0ZXJtaW5hdGUgYXMgb2YgdGhlIGRhdGUgc3VjaAorbGl0aWdhdGlvbiBpcyBmaWxlZC4KKworQWxsIFJlY2lwaWVudCdzIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCBzaGFsbCB0ZXJtaW5hdGUgaWYgaXQgZmFpbHMgdG8gY29tcGx5IHdpdGggYW55IG9mIHRoZSBtYXRlcmlhbCB0ZXJtcyBvcgorY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudCBhbmQgZG9lcyBub3QgY3VyZSBzdWNoIGZhaWx1cmUgaW4gYSByZWFzb25hYmxlIHBlcmlvZCBvZiB0aW1lIGFmdGVyIGJlY29taW5nIGF3YXJlIG9mIHN1Y2gKK25vbmNvbXBsaWFuY2UuIElmIGFsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgdGVybWluYXRlLCBSZWNpcGllbnQgYWdyZWVzIHRvIGNlYXNlIHVzZSBhbmQgZGlzdHJpYnV0aW9uCitvZiB0aGUgUHJvZ3JhbSBhcyBzb29uIGFzIHJlYXNvbmFibHkgcHJhY3RpY2FibGUuIEhvd2V2ZXIsIFJlY2lwaWVudCdzIG9ibGlnYXRpb25zIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFuZCBhbnkgbGljZW5zZXMKKyBncmFudGVkIGJ5IFJlY2lwaWVudCByZWxhdGluZyB0byB0aGUgUHJvZ3JhbSBzaGFsbCBjb250aW51ZSBhbmQgc3Vydml2ZS4KKworRXZlcnlvbmUgaXMgcGVybWl0dGVkIHRvIGNvcHkgYW5kIGRpc3RyaWJ1dGUgY29waWVzIG9mIHRoaXMgQWdyZWVtZW50LCBidXQgaW4gb3JkZXIgdG8gYXZvaWQgaW5jb25zaXN0ZW5jeSB0aGUgQWdyZWVtZW50CitpcyBjb3B5cmlnaHRlZCBhbmQgbWF5IG9ubHkgYmUgbW9kaWZpZWQgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXIuIFRoZSBBZ3JlZW1lbnQgU3Rld2FyZCByZXNlcnZlcyB0aGUgcmlnaHQgdG8gcHVibGlzaAorbmV3IHZlcnNpb25zIChpbmNsdWRpbmcgcmV2aXNpb25zKSBvZiB0aGlzIEFncmVlbWVudCBmcm9tIHRpbWUgdG8gdGltZS4gTm8gb25lIG90aGVyIHRoYW4gdGhlIEFncmVlbWVudCBTdGV3YXJkIGhhcyB0aGUKK3JpZ2h0IHRvIG1vZGlmeSB0aGlzIEFncmVlbWVudC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyB0aGUgaW5pdGlhbCBBZ3JlZW1lbnQgU3Rld2FyZC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYXkKK2Fzc2lnbiB0aGUgcmVzcG9uc2liaWxpdHkgdG8gc2VydmUgYXMgdGhlIEFncmVlbWVudCBTdGV3YXJkIHRvIGEgc3VpdGFibGUgc2VwYXJhdGUgZW50aXR5LiBFYWNoIG5ldyB2ZXJzaW9uIG9mIHRoZQorQWdyZWVtZW50IHdpbGwgYmUgZ2l2ZW4gYSBkaXN0aW5ndWlzaGluZyB2ZXJzaW9uIG51bWJlci4gVGhlIFByb2dyYW0gKGluY2x1ZGluZyBDb250cmlidXRpb25zKSBtYXkgYWx3YXlzIGJlCitkaXN0cmlidXRlZCBzdWJqZWN0IHRvIHRoZSB2ZXJzaW9uIG9mIHRoZSBBZ3JlZW1lbnQgdW5kZXIgd2hpY2ggaXQgd2FzIHJlY2VpdmVkLiBJbiBhZGRpdGlvbiwgYWZ0ZXIgYSBuZXcgdmVyc2lvbiBvZgordGhlIEFncmVlbWVudCBpcyBwdWJsaXNoZWQsIENvbnRyaWJ1dG9yIG1heSBlbGVjdCB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtIChpbmNsdWRpbmcgaXRzIENvbnRyaWJ1dGlvbnMpIHVuZGVyIHRoZQorbmV3IHZlcnNpb24uIEV4Y2VwdCBhcyBleHByZXNzbHkgc3RhdGVkIGluIFNlY3Rpb25zIDIoYSkgYW5kIDIoYikgYWJvdmUsIFJlY2lwaWVudCByZWNlaXZlcyBubyByaWdodHMgb3IgbGljZW5zZXMgdG8KK3RoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgb2YgYW55IENvbnRyaWJ1dG9yIHVuZGVyIHRoaXMgQWdyZWVtZW50LCB3aGV0aGVyIGV4cHJlc3NseSwgYnkgaW1wbGljYXRpb24sIGVzdG9wcGVsIG9yCitvdGhlcndpc2UuIEFsbCByaWdodHMgaW4gdGhlIFByb2dyYW0gbm90IGV4cHJlc3NseSBncmFudGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFyZSByZXNlcnZlZC4KKworVGhpcyBBZ3JlZW1lbnQgaXMgZ292ZXJuZWQgYnkgdGhlIGxhd3Mgb2YgdGhlIFN0YXRlIG9mIE5ldyBZb3JrIGFuZCB0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGxhd3Mgb2YgdGhlIFVuaXRlZCBTdGF0ZXMKK29mIEFtZXJpY2EuIE5vIHBhcnR5IHRvIHRoaXMgQWdyZWVtZW50IHdpbGwgYnJpbmcgYSBsZWdhbCBhY3Rpb24gdW5kZXIgdGhpcyBBZ3JlZW1lbnQgbW9yZSB0aGFuIG9uZSB5ZWFyIGFmdGVyIHRoZSBjYXVzZQorb2YgYWN0aW9uIGFyb3NlLiBFYWNoIHBhcnR5IHdhaXZlcyBpdHMgcmlnaHRzIHRvIGEganVyeSB0cmlhbCBpbiBhbnkgcmVzdWx0aW5nIGxpdGlnYXRpb24uClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy9idWlsZC5wcm9wZXJ0aWVzIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy9idWlsZC5wcm9wZXJ0aWVzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmJmYjdmNmIKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnRvb2xzL2J1aWxkLnByb3BlcnRpZXMKQEAgLTAsMCArMSw2IEBACitiaW4uaW5jbHVkZXMgPSBmZWF0dXJlLnhtbCxcCisgICAgICAgICAgICAgICBmZWF0dXJlLnByb3BlcnRpZXMsXAorICAgICAgICAgICAgICAgTElDRU5TRS50eHQsXAorICAgICAgICAgICAgICAgbGljZW5zZS5odG1sCitzcmMuaW5jbHVkZXMgPSBMSUNFTlNFLnR4dCxcCisgICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudG9vbHMvZXBsLXYxMC5odG1sIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy9lcGwtdjEwLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjM5OGFjYwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudG9vbHMvZXBsLXYxMC5odG1sCkBAIC0wLDAgKzEsMjU5IEBACis8IS0tP3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJJU08tODg1OS0xIiA/LS0+Cis8IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Cis8aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+PGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1JU08tODg1OS0xIj4KKzx0aXRsZT5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gVmVyc2lvbiAxLjA8L3RpdGxlPgorPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKyAgYm9keSB7CisgICAgc2l6ZTogOC41aW4gMTEuMGluOworICAgIG1hcmdpbjogMC4yNWluIDAuNWluIDAuMjVpbiAwLjVpbjsKKyAgICB0YWItaW50ZXJ2YWw6IDAuNWluOworICAgIH0KKyAgcCB7ICAJCisgICAgbWFyZ2luLWxlZnQ6IGF1dG87CisgICAgbWFyZ2luLXRvcDogIDAuNWVtOworICAgIG1hcmdpbi1ib3R0b206IDAuNWVtOworICAgIH0KKyAgcC5saXN0IHsKKyAgCW1hcmdpbi1sZWZ0OiAwLjVpbjsKKyAgICBtYXJnaW4tdG9wOiAgMC4wNWVtOworICAgIG1hcmdpbi1ib3R0b206IDAuMDVlbTsKKyAgICB9CisgIDwvc3R5bGU+CisKKzwvaGVhZD4KKworPGJvZHkgbGFuZz0iRU4tVVMiPgorCis8aDI+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIHYgMS4wPC9oMj4KKworPHA+VEhFIEFDQ09NUEFOWUlORyBQUk9HUkFNIElTIFBST1ZJREVEIFVOREVSIFRIRSBURVJNUyBPRiBUSElTIEVDTElQU0UKK1BVQkxJQyBMSUNFTlNFICgiQUdSRUVNRU5UIikuIEFOWSBVU0UsIFJFUFJPRFVDVElPTiBPUgorRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIENPTlNUSVRVVEVTIFJFQ0lQSUVOVCdTIEFDQ0VQVEFOQ0UgT0YgVEhJUworQUdSRUVNRU5ULjwvcD4KKworPHA+PGI+MS4gREVGSU5JVElPTlM8L2I+PC9wPgorCis8cD4iQ29udHJpYnV0aW9uIiBtZWFuczo8L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5hKSBpbiB0aGUgY2FzZSBvZiB0aGUgaW5pdGlhbCBDb250cmlidXRvciwgdGhlIGluaXRpYWwKK2NvZGUgYW5kIGRvY3VtZW50YXRpb24gZGlzdHJpYnV0ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGFuZDwvcD4KKzxwIGNsYXNzPSJsaXN0Ij5iKSBpbiB0aGUgY2FzZSBvZiBlYWNoIHN1YnNlcXVlbnQgQ29udHJpYnV0b3I6PC9wPgorPHAgY2xhc3M9Imxpc3QiPmkpIGNoYW5nZXMgdG8gdGhlIFByb2dyYW0sIGFuZDwvcD4KKzxwIGNsYXNzPSJsaXN0Ij5paSkgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtOzwvcD4KKzxwIGNsYXNzPSJsaXN0Ij53aGVyZSBzdWNoIGNoYW5nZXMgYW5kL29yIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbQorb3JpZ2luYXRlIGZyb20gYW5kIGFyZSBkaXN0cmlidXRlZCBieSB0aGF0IHBhcnRpY3VsYXIgQ29udHJpYnV0b3IuIEEKK0NvbnRyaWJ1dGlvbiAnb3JpZ2luYXRlcycgZnJvbSBhIENvbnRyaWJ1dG9yIGlmIGl0IHdhcyBhZGRlZCB0byB0aGUKK1Byb2dyYW0gYnkgc3VjaCBDb250cmlidXRvciBpdHNlbGYgb3IgYW55b25lIGFjdGluZyBvbiBzdWNoCitDb250cmlidXRvcidzIGJlaGFsZi4gQ29udHJpYnV0aW9ucyBkbyBub3QgaW5jbHVkZSBhZGRpdGlvbnMgdG8gdGhlCitQcm9ncmFtIHdoaWNoOiAoaSkgYXJlIHNlcGFyYXRlIG1vZHVsZXMgb2Ygc29mdHdhcmUgZGlzdHJpYnV0ZWQgaW4KK2Nvbmp1bmN0aW9uIHdpdGggdGhlIFByb2dyYW0gdW5kZXIgdGhlaXIgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBhbmQgKGlpKQorYXJlIG5vdCBkZXJpdmF0aXZlIHdvcmtzIG9mIHRoZSBQcm9ncmFtLjwvcD4KKworPHA+IkNvbnRyaWJ1dG9yIiBtZWFucyBhbnkgcGVyc29uIG9yIGVudGl0eSB0aGF0IGRpc3RyaWJ1dGVzCit0aGUgUHJvZ3JhbS48L3A+CisKKzxwPiJMaWNlbnNlZCBQYXRlbnRzIiBtZWFuIHBhdGVudCBjbGFpbXMgbGljZW5zYWJsZSBieSBhCitDb250cmlidXRvciB3aGljaCBhcmUgbmVjZXNzYXJpbHkgaW5mcmluZ2VkIGJ5IHRoZSB1c2Ugb3Igc2FsZSBvZiBpdHMKK0NvbnRyaWJ1dGlvbiBhbG9uZSBvciB3aGVuIGNvbWJpbmVkIHdpdGggdGhlIFByb2dyYW0uPC9wPgorCis8cD4iUHJvZ3JhbSIgbWVhbnMgdGhlIENvbnRyaWJ1dGlvbnMgZGlzdHJpYnV0ZWQgaW4gYWNjb3JkYW5jZQord2l0aCB0aGlzIEFncmVlbWVudC48L3A+CisKKzxwPiJSZWNpcGllbnQiIG1lYW5zIGFueW9uZSB3aG8gcmVjZWl2ZXMgdGhlIFByb2dyYW0gdW5kZXIKK3RoaXMgQWdyZWVtZW50LCBpbmNsdWRpbmcgYWxsIENvbnRyaWJ1dG9ycy48L3A+CisKKzxwPjxiPjIuIEdSQU5UIE9GIFJJR0hUUzwvYj48L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5hKSBTdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaAorQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsCityb3lhbHR5LWZyZWUgY29weXJpZ2h0IGxpY2Vuc2UgdG8gcmVwcm9kdWNlLCBwcmVwYXJlIGRlcml2YXRpdmUgd29ya3MKK29mLCBwdWJsaWNseSBkaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBkaXN0cmlidXRlIGFuZCBzdWJsaWNlbnNlIHRoZQorQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgYW5kIHN1Y2ggZGVyaXZhdGl2ZSB3b3JrcywgaW4KK3NvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLjwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmIpIFN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoCitDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwKK3JveWFsdHktZnJlZSBwYXRlbnQgbGljZW5zZSB1bmRlciBMaWNlbnNlZCBQYXRlbnRzIHRvIG1ha2UsIHVzZSwgc2VsbCwKK29mZmVyIHRvIHNlbGwsIGltcG9ydCBhbmQgb3RoZXJ3aXNlIHRyYW5zZmVyIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaAorQ29udHJpYnV0b3IsIGlmIGFueSwgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlIGZvcm0uIFRoaXMgcGF0ZW50CitsaWNlbnNlIHNoYWxsIGFwcGx5IHRvIHRoZSBjb21iaW5hdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGFuZCB0aGUKK1Byb2dyYW0gaWYsIGF0IHRoZSB0aW1lIHRoZSBDb250cmlidXRpb24gaXMgYWRkZWQgYnkgdGhlIENvbnRyaWJ1dG9yLAorc3VjaCBhZGRpdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGNhdXNlcyBzdWNoIGNvbWJpbmF0aW9uIHRvIGJlIGNvdmVyZWQKK2J5IHRoZSBMaWNlbnNlZCBQYXRlbnRzLiBUaGUgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgbm90IGFwcGx5IHRvIGFueSBvdGhlcgorY29tYmluYXRpb25zIHdoaWNoIGluY2x1ZGUgdGhlIENvbnRyaWJ1dGlvbi4gTm8gaGFyZHdhcmUgcGVyIHNlIGlzCitsaWNlbnNlZCBoZXJldW5kZXIuPC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YykgUmVjaXBpZW50IHVuZGVyc3RhbmRzIHRoYXQgYWx0aG91Z2ggZWFjaCBDb250cmlidXRvcgorZ3JhbnRzIHRoZSBsaWNlbnNlcyB0byBpdHMgQ29udHJpYnV0aW9ucyBzZXQgZm9ydGggaGVyZWluLCBubyBhc3N1cmFuY2VzCithcmUgcHJvdmlkZWQgYnkgYW55IENvbnRyaWJ1dG9yIHRoYXQgdGhlIFByb2dyYW0gZG9lcyBub3QgaW5mcmluZ2UgdGhlCitwYXRlbnQgb3Igb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5IHJpZ2h0cyBvZiBhbnkgb3RoZXIgZW50aXR5LiBFYWNoCitDb250cmlidXRvciBkaXNjbGFpbXMgYW55IGxpYWJpbGl0eSB0byBSZWNpcGllbnQgZm9yIGNsYWltcyBicm91Z2h0IGJ5Cithbnkgb3RoZXIgZW50aXR5IGJhc2VkIG9uIGluZnJpbmdlbWVudCBvZiBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzCitvciBvdGhlcndpc2UuIEFzIGEgY29uZGl0aW9uIHRvIGV4ZXJjaXNpbmcgdGhlIHJpZ2h0cyBhbmQgbGljZW5zZXMKK2dyYW50ZWQgaGVyZXVuZGVyLCBlYWNoIFJlY2lwaWVudCBoZXJlYnkgYXNzdW1lcyBzb2xlIHJlc3BvbnNpYmlsaXR5IHRvCitzZWN1cmUgYW55IG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgbmVlZGVkLCBpZiBhbnkuIEZvcgorZXhhbXBsZSwgaWYgYSB0aGlyZCBwYXJ0eSBwYXRlbnQgbGljZW5zZSBpcyByZXF1aXJlZCB0byBhbGxvdyBSZWNpcGllbnQKK3RvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0sIGl0IGlzIFJlY2lwaWVudCdzIHJlc3BvbnNpYmlsaXR5IHRvIGFjcXVpcmUKK3RoYXQgbGljZW5zZSBiZWZvcmUgZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtLjwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmQpIEVhY2ggQ29udHJpYnV0b3IgcmVwcmVzZW50cyB0aGF0IHRvIGl0cyBrbm93bGVkZ2UgaXQKK2hhcyBzdWZmaWNpZW50IGNvcHlyaWdodCByaWdodHMgaW4gaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCB0byBncmFudAordGhlIGNvcHlyaWdodCBsaWNlbnNlIHNldCBmb3J0aCBpbiB0aGlzIEFncmVlbWVudC48L3A+CisKKzxwPjxiPjMuIFJFUVVJUkVNRU5UUzwvYj48L3A+CisKKzxwPkEgQ29udHJpYnV0b3IgbWF5IGNob29zZSB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtIGluIG9iamVjdCBjb2RlCitmb3JtIHVuZGVyIGl0cyBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIHByb3ZpZGVkIHRoYXQ6PC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YSkgaXQgY29tcGxpZXMgd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhpcworQWdyZWVtZW50OyBhbmQ8L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5iKSBpdHMgbGljZW5zZSBhZ3JlZW1lbnQ6PC9wPgorCis8cCBjbGFzcz0ibGlzdCI+aSkgZWZmZWN0aXZlbHkgZGlzY2xhaW1zIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzCithbGwgd2FycmFudGllcyBhbmQgY29uZGl0aW9ucywgZXhwcmVzcyBhbmQgaW1wbGllZCwgaW5jbHVkaW5nIHdhcnJhbnRpZXMKK29yIGNvbmRpdGlvbnMgb2YgdGl0bGUgYW5kIG5vbi1pbmZyaW5nZW1lbnQsIGFuZCBpbXBsaWVkIHdhcnJhbnRpZXMgb3IKK2NvbmRpdGlvbnMgb2YgbWVyY2hhbnRhYmlsaXR5IGFuZCBmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZTs8L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5paSkgZWZmZWN0aXZlbHkgZXhjbHVkZXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMKK2FsbCBsaWFiaWxpdHkgZm9yIGRhbWFnZXMsIGluY2x1ZGluZyBkaXJlY3QsIGluZGlyZWN0LCBzcGVjaWFsLAoraW5jaWRlbnRhbCBhbmQgY29uc2VxdWVudGlhbCBkYW1hZ2VzLCBzdWNoIGFzIGxvc3QgcHJvZml0czs8L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5paWkpIHN0YXRlcyB0aGF0IGFueSBwcm92aXNpb25zIHdoaWNoIGRpZmZlciBmcm9tIHRoaXMKK0FncmVlbWVudCBhcmUgb2ZmZXJlZCBieSB0aGF0IENvbnRyaWJ1dG9yIGFsb25lIGFuZCBub3QgYnkgYW55IG90aGVyCitwYXJ0eTsgYW5kPC9wPgorCis8cCBjbGFzcz0ibGlzdCI+aXYpIHN0YXRlcyB0aGF0IHNvdXJjZSBjb2RlIGZvciB0aGUgUHJvZ3JhbSBpcyBhdmFpbGFibGUKK2Zyb20gc3VjaCBDb250cmlidXRvciwgYW5kIGluZm9ybXMgbGljZW5zZWVzIGhvdyB0byBvYnRhaW4gaXQgaW4gYQorcmVhc29uYWJsZSBtYW5uZXIgb24gb3IgdGhyb3VnaCBhIG1lZGl1bSBjdXN0b21hcmlseSB1c2VkIGZvciBzb2Z0d2FyZQorZXhjaGFuZ2UuPC9wPgorCis8cD5XaGVuIHRoZSBQcm9ncmFtIGlzIG1hZGUgYXZhaWxhYmxlIGluIHNvdXJjZSBjb2RlIGZvcm06PC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YSkgaXQgbXVzdCBiZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGlzIEFncmVlbWVudDsgYW5kPC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YikgYSBjb3B5IG9mIHRoaXMgQWdyZWVtZW50IG11c3QgYmUgaW5jbHVkZWQgd2l0aCBlYWNoCitjb3B5IG9mIHRoZSBQcm9ncmFtLjwvcD4KKworPHA+Q29udHJpYnV0b3JzIG1heSBub3QgcmVtb3ZlIG9yIGFsdGVyIGFueSBjb3B5cmlnaHQgbm90aWNlcyBjb250YWluZWQKK3dpdGhpbiB0aGUgUHJvZ3JhbS48L3A+CisKKzxwPkVhY2ggQ29udHJpYnV0b3IgbXVzdCBpZGVudGlmeSBpdHNlbGYgYXMgdGhlIG9yaWdpbmF0b3Igb2YgaXRzCitDb250cmlidXRpb24sIGlmIGFueSwgaW4gYSBtYW5uZXIgdGhhdCByZWFzb25hYmx5IGFsbG93cyBzdWJzZXF1ZW50CitSZWNpcGllbnRzIHRvIGlkZW50aWZ5IHRoZSBvcmlnaW5hdG9yIG9mIHRoZSBDb250cmlidXRpb24uPC9wPgorCis8cD48Yj40LiBDT01NRVJDSUFMIERJU1RSSUJVVElPTjwvYj48L3A+CisKKzxwPkNvbW1lcmNpYWwgZGlzdHJpYnV0b3JzIG9mIHNvZnR3YXJlIG1heSBhY2NlcHQgY2VydGFpbgorcmVzcG9uc2liaWxpdGllcyB3aXRoIHJlc3BlY3QgdG8gZW5kIHVzZXJzLCBidXNpbmVzcyBwYXJ0bmVycyBhbmQgdGhlCitsaWtlLiBXaGlsZSB0aGlzIGxpY2Vuc2UgaXMgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY29tbWVyY2lhbCB1c2Ugb2YKK3RoZSBQcm9ncmFtLCB0aGUgQ29udHJpYnV0b3Igd2hvIGluY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbAorcHJvZHVjdCBvZmZlcmluZyBzaG91bGQgZG8gc28gaW4gYSBtYW5uZXIgd2hpY2ggZG9lcyBub3QgY3JlYXRlCitwb3RlbnRpYWwgbGlhYmlsaXR5IGZvciBvdGhlciBDb250cmlidXRvcnMuIFRoZXJlZm9yZSwgaWYgYSBDb250cmlidXRvcgoraW5jbHVkZXMgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIHN1Y2ggQ29udHJpYnV0b3IKKygiQ29tbWVyY2lhbCBDb250cmlidXRvciIpIGhlcmVieSBhZ3JlZXMgdG8gZGVmZW5kIGFuZAoraW5kZW1uaWZ5IGV2ZXJ5IG90aGVyIENvbnRyaWJ1dG9yICgiSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IiKQorYWdhaW5zdCBhbnkgbG9zc2VzLCBkYW1hZ2VzIGFuZCBjb3N0cyAoY29sbGVjdGl2ZWx5ICJMb3NzZXMiKQorYXJpc2luZyBmcm9tIGNsYWltcywgbGF3c3VpdHMgYW5kIG90aGVyIGxlZ2FsIGFjdGlvbnMgYnJvdWdodCBieSBhIHRoaXJkCitwYXJ0eSBhZ2FpbnN0IHRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciB0byB0aGUgZXh0ZW50IGNhdXNlZCBieSB0aGUKK2FjdHMgb3Igb21pc3Npb25zIG9mIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiBjb25uZWN0aW9uIHdpdGggaXRzCitkaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcuIFRoZQorb2JsaWdhdGlvbnMgaW4gdGhpcyBzZWN0aW9uIGRvIG5vdCBhcHBseSB0byBhbnkgY2xhaW1zIG9yIExvc3NlcworcmVsYXRpbmcgdG8gYW55IGFjdHVhbCBvciBhbGxlZ2VkIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBpbmZyaW5nZW1lbnQuIEluCitvcmRlciB0byBxdWFsaWZ5LCBhbiBJbmRlbW5pZmllZCBDb250cmlidXRvciBtdXN0OiBhKSBwcm9tcHRseSBub3RpZnkKK3RoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluIHdyaXRpbmcgb2Ygc3VjaCBjbGFpbSwgYW5kIGIpIGFsbG93IHRoZQorQ29tbWVyY2lhbCBDb250cmlidXRvciB0byBjb250cm9sLCBhbmQgY29vcGVyYXRlIHdpdGggdGhlIENvbW1lcmNpYWwKK0NvbnRyaWJ1dG9yIGluLCB0aGUgZGVmZW5zZSBhbmQgYW55IHJlbGF0ZWQgc2V0dGxlbWVudCBuZWdvdGlhdGlvbnMuIFRoZQorSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbWF5IHBhcnRpY2lwYXRlIGluIGFueSBzdWNoIGNsYWltIGF0IGl0cyBvd24KK2V4cGVuc2UuPC9wPgorCis8cD5Gb3IgZXhhbXBsZSwgYSBDb250cmlidXRvciBtaWdodCBpbmNsdWRlIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbAorcHJvZHVjdCBvZmZlcmluZywgUHJvZHVjdCBYLiBUaGF0IENvbnRyaWJ1dG9yIGlzIHRoZW4gYSBDb21tZXJjaWFsCitDb250cmlidXRvci4gSWYgdGhhdCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRoZW4gbWFrZXMgcGVyZm9ybWFuY2UKK2NsYWltcywgb3Igb2ZmZXJzIHdhcnJhbnRpZXMgcmVsYXRlZCB0byBQcm9kdWN0IFgsIHRob3NlIHBlcmZvcm1hbmNlCitjbGFpbXMgYW5kIHdhcnJhbnRpZXMgYXJlIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvcidzIHJlc3BvbnNpYmlsaXR5CithbG9uZS4gVW5kZXIgdGhpcyBzZWN0aW9uLCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB3b3VsZCBoYXZlIHRvCitkZWZlbmQgY2xhaW1zIGFnYWluc3QgdGhlIG90aGVyIENvbnRyaWJ1dG9ycyByZWxhdGVkIHRvIHRob3NlCitwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMsIGFuZCBpZiBhIGNvdXJ0IHJlcXVpcmVzIGFueSBvdGhlcgorQ29udHJpYnV0b3IgdG8gcGF5IGFueSBkYW1hZ2VzIGFzIGEgcmVzdWx0LCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvcgorbXVzdCBwYXkgdGhvc2UgZGFtYWdlcy48L3A+CisKKzxwPjxiPjUuIE5PIFdBUlJBTlRZPC9iPjwvcD4KKworPHA+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUyBBR1JFRU1FTlQsIFRIRSBQUk9HUkFNIElTCitQUk9WSURFRCBPTiBBTiAiQVMgSVMiIEJBU0lTLCBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUworT0YgQU5ZIEtJTkQsIEVJVEhFUiBFWFBSRVNTIE9SIElNUExJRUQgSU5DTFVESU5HLCBXSVRIT1VUIExJTUlUQVRJT04sCitBTlkgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIFRJVExFLCBOT04tSU5GUklOR0VNRU5ULCBNRVJDSEFOVEFCSUxJVFkKK09SIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBFYWNoIFJlY2lwaWVudCBpcyBzb2xlbHkKK3Jlc3BvbnNpYmxlIGZvciBkZXRlcm1pbmluZyB0aGUgYXBwcm9wcmlhdGVuZXNzIG9mIHVzaW5nIGFuZAorZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtIGFuZCBhc3N1bWVzIGFsbCByaXNrcyBhc3NvY2lhdGVkIHdpdGggaXRzCitleGVyY2lzZSBvZiByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgLCBpbmNsdWRpbmcgYnV0IG5vdCBsaW1pdGVkIHRvCit0aGUgcmlza3MgYW5kIGNvc3RzIG9mIHByb2dyYW0gZXJyb3JzLCBjb21wbGlhbmNlIHdpdGggYXBwbGljYWJsZSBsYXdzLAorZGFtYWdlIHRvIG9yIGxvc3Mgb2YgZGF0YSwgcHJvZ3JhbXMgb3IgZXF1aXBtZW50LCBhbmQgdW5hdmFpbGFiaWxpdHkgb3IKK2ludGVycnVwdGlvbiBvZiBvcGVyYXRpb25zLjwvcD4KKworPHA+PGI+Ni4gRElTQ0xBSU1FUiBPRiBMSUFCSUxJVFk8L2I+PC9wPgorCis8cD5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTIEFHUkVFTUVOVCwgTkVJVEhFUiBSRUNJUElFTlQKK05PUiBBTlkgQ09OVFJJQlVUT1JTIFNIQUxMIEhBVkUgQU5ZIExJQUJJTElUWSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsCitJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HCitXSVRIT1VUIExJTUlUQVRJT04gTE9TVCBQUk9GSVRTKSwgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YKK0xJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HCitORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9SCitESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gT1IgVEhFIEVYRVJDSVNFIE9GIEFOWSBSSUdIVFMgR1JBTlRFRAorSEVSRVVOREVSLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFUy48L3A+CisKKzxwPjxiPjcuIEdFTkVSQUw8L2I+PC9wPgorCis8cD5JZiBhbnkgcHJvdmlzaW9uIG9mIHRoaXMgQWdyZWVtZW50IGlzIGludmFsaWQgb3IgdW5lbmZvcmNlYWJsZSB1bmRlcgorYXBwbGljYWJsZSBsYXcsIGl0IHNoYWxsIG5vdCBhZmZlY3QgdGhlIHZhbGlkaXR5IG9yIGVuZm9yY2VhYmlsaXR5IG9mCit0aGUgcmVtYWluZGVyIG9mIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgYW5kIHdpdGhvdXQgZnVydGhlciBhY3Rpb24KK2J5IHRoZSBwYXJ0aWVzIGhlcmV0bywgc3VjaCBwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlIG1pbmltdW0KK2V4dGVudCBuZWNlc3NhcnkgdG8gbWFrZSBzdWNoIHByb3Zpc2lvbiB2YWxpZCBhbmQgZW5mb3JjZWFibGUuPC9wPgorCis8cD5JZiBSZWNpcGllbnQgaW5zdGl0dXRlcyBwYXRlbnQgbGl0aWdhdGlvbiBhZ2FpbnN0IGFueSBlbnRpdHkKKyhpbmNsdWRpbmcgYSBjcm9zcy1jbGFpbSBvciBjb3VudGVyY2xhaW0gaW4gYSBsYXdzdWl0KSBhbGxlZ2luZyB0aGF0IHRoZQorUHJvZ3JhbSBpdHNlbGYgKGV4Y2x1ZGluZyBjb21iaW5hdGlvbnMgb2YgdGhlIFByb2dyYW0gd2l0aCBvdGhlcgorc29mdHdhcmUgb3IgaGFyZHdhcmUpIGluZnJpbmdlcyBzdWNoIFJlY2lwaWVudCdzIHBhdGVudChzKSwgdGhlbiBzdWNoCitSZWNpcGllbnQncyByaWdodHMgZ3JhbnRlZCB1bmRlciBTZWN0aW9uIDIoYikgc2hhbGwgdGVybWluYXRlIGFzIG9mIHRoZQorZGF0ZSBzdWNoIGxpdGlnYXRpb24gaXMgZmlsZWQuPC9wPgorCis8cD5BbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHNoYWxsIHRlcm1pbmF0ZSBpZiBpdAorZmFpbHMgdG8gY29tcGx5IHdpdGggYW55IG9mIHRoZSBtYXRlcmlhbCB0ZXJtcyBvciBjb25kaXRpb25zIG9mIHRoaXMKK0FncmVlbWVudCBhbmQgZG9lcyBub3QgY3VyZSBzdWNoIGZhaWx1cmUgaW4gYSByZWFzb25hYmxlIHBlcmlvZCBvZiB0aW1lCithZnRlciBiZWNvbWluZyBhd2FyZSBvZiBzdWNoIG5vbmNvbXBsaWFuY2UuIElmIGFsbCBSZWNpcGllbnQncyByaWdodHMKK3VuZGVyIHRoaXMgQWdyZWVtZW50IHRlcm1pbmF0ZSwgUmVjaXBpZW50IGFncmVlcyB0byBjZWFzZSB1c2UgYW5kCitkaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gYXMgc29vbiBhcyByZWFzb25hYmx5IHByYWN0aWNhYmxlLiBIb3dldmVyLAorUmVjaXBpZW50J3Mgb2JsaWdhdGlvbnMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYW5kIGFueSBsaWNlbnNlcyBncmFudGVkIGJ5CitSZWNpcGllbnQgcmVsYXRpbmcgdG8gdGhlIFByb2dyYW0gc2hhbGwgY29udGludWUgYW5kIHN1cnZpdmUuPC9wPgorCis8cD5FdmVyeW9uZSBpcyBwZXJtaXR0ZWQgdG8gY29weSBhbmQgZGlzdHJpYnV0ZSBjb3BpZXMgb2YgdGhpcworQWdyZWVtZW50LCBidXQgaW4gb3JkZXIgdG8gYXZvaWQgaW5jb25zaXN0ZW5jeSB0aGUgQWdyZWVtZW50IGlzCitjb3B5cmlnaHRlZCBhbmQgbWF5IG9ubHkgYmUgbW9kaWZpZWQgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXIuIFRoZQorQWdyZWVtZW50IFN0ZXdhcmQgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHB1Ymxpc2ggbmV3IHZlcnNpb25zIChpbmNsdWRpbmcKK3JldmlzaW9ucykgb2YgdGhpcyBBZ3JlZW1lbnQgZnJvbSB0aW1lIHRvIHRpbWUuIE5vIG9uZSBvdGhlciB0aGFuIHRoZQorQWdyZWVtZW50IFN0ZXdhcmQgaGFzIHRoZSByaWdodCB0byBtb2RpZnkgdGhpcyBBZ3JlZW1lbnQuIFRoZSBFY2xpcHNlCitGb3VuZGF0aW9uIGlzIHRoZSBpbml0aWFsIEFncmVlbWVudCBTdGV3YXJkLiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1heQorYXNzaWduIHRoZSByZXNwb25zaWJpbGl0eSB0byBzZXJ2ZSBhcyB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgdG8gYQorc3VpdGFibGUgc2VwYXJhdGUgZW50aXR5LiBFYWNoIG5ldyB2ZXJzaW9uIG9mIHRoZSBBZ3JlZW1lbnQgd2lsbCBiZQorZ2l2ZW4gYSBkaXN0aW5ndWlzaGluZyB2ZXJzaW9uIG51bWJlci4gVGhlIFByb2dyYW0gKGluY2x1ZGluZworQ29udHJpYnV0aW9ucykgbWF5IGFsd2F5cyBiZSBkaXN0cmlidXRlZCBzdWJqZWN0IHRvIHRoZSB2ZXJzaW9uIG9mIHRoZQorQWdyZWVtZW50IHVuZGVyIHdoaWNoIGl0IHdhcyByZWNlaXZlZC4gSW4gYWRkaXRpb24sIGFmdGVyIGEgbmV3IHZlcnNpb24KK29mIHRoZSBBZ3JlZW1lbnQgaXMgcHVibGlzaGVkLCBDb250cmlidXRvciBtYXkgZWxlY3QgdG8gZGlzdHJpYnV0ZSB0aGUKK1Byb2dyYW0gKGluY2x1ZGluZyBpdHMgQ29udHJpYnV0aW9ucykgdW5kZXIgdGhlIG5ldyB2ZXJzaW9uLiBFeGNlcHQgYXMKK2V4cHJlc3NseSBzdGF0ZWQgaW4gU2VjdGlvbnMgMihhKSBhbmQgMihiKSBhYm92ZSwgUmVjaXBpZW50IHJlY2VpdmVzIG5vCityaWdodHMgb3IgbGljZW5zZXMgdG8gdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBvZiBhbnkgQ29udHJpYnV0b3IgdW5kZXIKK3RoaXMgQWdyZWVtZW50LCB3aGV0aGVyIGV4cHJlc3NseSwgYnkgaW1wbGljYXRpb24sIGVzdG9wcGVsIG9yCitvdGhlcndpc2UuIEFsbCByaWdodHMgaW4gdGhlIFByb2dyYW0gbm90IGV4cHJlc3NseSBncmFudGVkIHVuZGVyIHRoaXMKK0FncmVlbWVudCBhcmUgcmVzZXJ2ZWQuPC9wPgorCis8cD5UaGlzIEFncmVlbWVudCBpcyBnb3Zlcm5lZCBieSB0aGUgbGF3cyBvZiB0aGUgU3RhdGUgb2YgTmV3IFlvcmsgYW5kCit0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGxhd3Mgb2YgdGhlIFVuaXRlZCBTdGF0ZXMgb2YgQW1lcmljYS4gTm8gcGFydHkKK3RvIHRoaXMgQWdyZWVtZW50IHdpbGwgYnJpbmcgYSBsZWdhbCBhY3Rpb24gdW5kZXIgdGhpcyBBZ3JlZW1lbnQgbW9yZQordGhhbiBvbmUgeWVhciBhZnRlciB0aGUgY2F1c2Ugb2YgYWN0aW9uIGFyb3NlLiBFYWNoIHBhcnR5IHdhaXZlcyBpdHMKK3JpZ2h0cyB0byBhIGp1cnkgdHJpYWwgaW4gYW55IHJlc3VsdGluZyBsaXRpZ2F0aW9uLjwvcD4KKworCisKKzwvYm9keT48L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy9mZWF0dXJlLnByb3BlcnRpZXMgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnRvb2xzL2ZlYXR1cmUucHJvcGVydGllcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xNDY3YzI0Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy9mZWF0dXJlLnByb3BlcnRpZXMKQEAgLTAsMCArMSwxNjkgQEAKKyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKKyMgQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkuCisjIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCisjIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisjIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisjCisjIENvbnRyaWJ1dG9yczoKKyMgICAgIENyaXN0aWFubyBHYXZp428gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KKyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKKyMgZmVhdHVyZS5wcm9wZXJ0aWVzCisjIGNvbnRhaW5zIGV4dGVybmFsaXplZCBzdHJpbmdzIGZvciBmZWF0dXJlLnhtbAorIyAiJWZvbyIgaW4gZmVhdHVyZS54bWwgY29ycmVzcG9uZHMgdG8gdGhlIGtleSAiZm9vIiBpbiB0aGlzIGZpbGUKKyMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKKyMgVGhpcyBmaWxlIHNob3VsZCBiZSB0cmFuc2xhdGVkLgorCisjICJmZWF0dXJlTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBmZWF0dXJlCitmZWF0dXJlTmFtZSA9RGV2ZWxvcGVyIFRvb2xzIEZlYXR1cmUgZm9yIE9TQlAgSURFIAorCisjICJwcm92aWRlck5hbWUiIHByb3BlcnR5IC0gbmFtZSBvZiB0aGUgY29tcGFueSB0aGF0IHByb3ZpZGVzIHRoZSBmZWF0dXJlCitwcm92aWRlck5hbWU9RWNsaXBzZSBPU0JQCisKKyMgImRlc2NyaXB0aW9uIiBwcm9wZXJ0eSAtIGRlc2NyaXB0aW9uIG9mIHRoZSBmZWF0dXJlCitkZXNjcmlwdGlvbj1JbnN0YWxscyBkZXZlbG9wZXIgdG9vbHMgZm9yIE9TQlAgaW50byB0aGUgSURFCisKKyMgInVwZGF0ZVNpdGVOYW1lIiBwcm9wZXJ0eSAtIGxhYmVsIGZvciB0aGUgdXBkYXRlIHNpdGUKK3VwZGF0ZVNpdGVOYW1lPQorCisjICJjb3B5cmlnaHQiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIENvcHlyaWdodCIKK2NvcHlyaWdodD1cCitDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KSBcblwKK0FsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHNcblwKK2FyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMFxuXAord2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXRcblwKK2h0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sXG5cCitcblwKKyMjIyMjIyMjIyMjIyMjIyMgZW5kIG9mIGNvcHlyaWdodCBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKKworIyAibGljZW5zZVVSTCIgcHJvcGVydHkgLSBVUkwgb2YgdGhlICJGZWF0dXJlIExpY2Vuc2UiCisjIGRvIG5vdCB0cmFuc2xhdGUgdmFsdWUgLSBqdXN0IGNoYW5nZSB0byBwb2ludCB0byBhIGxvY2FsZS1zcGVjaWZpYyBIVE1MIHBhZ2UKK2xpY2Vuc2VVUkw9bGljZW5zZS5odG1sCisKKyMgImxpY2Vuc2UiIHByb3BlcnR5IC0gdGV4dCBvZiB0aGUgIkZlYXR1cmUgVXBkYXRlIExpY2Vuc2UiCisjIHNob3VsZCBiZSBwbGFpbiB0ZXh0IHZlcnNpb24gb2YgbGljZW5zZSBhZ3JlZW1lbnQgcG9pbnRlZCB0byBiZSAibGljZW5zZVVSTCIKK2xpY2Vuc2U9XAorRWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50XG5cCitGZWJydWFyeSAxLCAyMDExXG5cCitcblwKK1VzYWdlIE9mIENvbnRlbnRcblwKK1xuXAorVEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUlxuXAorT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUyAoQ09MTEVDVElWRUxZICJDT05URU5UIikuXG5cCitVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVNcblwKK0FHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORCBDT05ESVRJT05TIE9GIExJQ0VOU0UgQUdSRUVNRU5UUyBPUlxuXAorTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gIEJZIFVTSU5HIFRIRSBDT05URU5ULCBZT1VcblwKK0FHUkVFIFRIQVQgWU9VUiBVU0UgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhJUyBBR1JFRU1FTlRcblwKK0FORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTXG5cCitPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEVcblwKK1RFUk1TIEFORCBDT05ESVRJT05TIE9GIFRISVMgQUdSRUVNRU5UIEFORCBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlNcblwKK09GIEFOWSBBUFBMSUNBQkxFIExJQ0VOU0UgQUdSRUVNRU5UUyBPUiBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEXG5cCitCRUxPVywgVEhFTiBZT1UgTUFZIE5PVCBVU0UgVEhFIENPTlRFTlQuXG5cCitcblwKK0FwcGxpY2FibGUgTGljZW5zZXNcblwKK1xuXAorVW5sZXNzIG90aGVyd2lzZSBpbmRpY2F0ZWQsIGFsbCBDb250ZW50IG1hZGUgYXZhaWxhYmxlIGJ5IHRoZVxuXAorRWNsaXBzZSBGb3VuZGF0aW9uIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2ZcblwKK3RoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wICgiRVBMIikuIEEgY29weSBvZiB0aGUgRVBMIGlzXG5cCitwcm92aWRlZCB3aXRoIHRoaXMgQ29udGVudCBhbmQgaXMgYWxzbyBhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwuXG5cCitGb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC5cblwKK1xuXAorQ29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsXG5cCitkb2N1bWVudGF0aW9uIGFuZCBvdGhlciBmaWxlcyBtYWludGFpbmVkIGluIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gc291cmNlIGNvZGVcblwKK3JlcG9zaXRvcnkgKCJSZXBvc2l0b3J5IikgaW4gc29mdHdhcmUgbW9kdWxlcyAoIk1vZHVsZXMiKSBhbmQgbWFkZSBhdmFpbGFibGVcblwKK2FzIGRvd25sb2FkYWJsZSBhcmNoaXZlcyAoIkRvd25sb2FkcyIpLlxuXAorXG5cCisgICAgICAgLSBDb250ZW50IG1heSBiZSBzdHJ1Y3R1cmVkIGFuZCBwYWNrYWdlZCBpbnRvIG1vZHVsZXMgdG8gZmFjaWxpdGF0ZSBkZWxpdmVyaW5nLFxuXAorICAgICAgICAgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiBUeXBpY2FsIG1vZHVsZXMgbWF5IGluY2x1ZGUgcGx1Zy1pbnMgKCJQbHVnLWlucyIpLFxuXAorICAgICAgICAgcGx1Zy1pbiBmcmFnbWVudHMgKCJGcmFnbWVudHMiKSwgYW5kIGZlYXR1cmVzICgiRmVhdHVyZXMiKS5cblwKKyAgICAgICAtIEVhY2ggUGx1Zy1pbiBvciBGcmFnbWVudCBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IG9yIEpBUiAoSmF2YShUTSkgQVJjaGl2ZSlcblwKKyAgICAgICAgIGluIGEgZGlyZWN0b3J5IG5hbWVkICJwbHVnaW5zIi5cblwKKyAgICAgICAtIEEgRmVhdHVyZSBpcyBhIGJ1bmRsZSBvZiBvbmUgb3IgbW9yZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFuZCBhc3NvY2lhdGVkIG1hdGVyaWFsLlxuXAorICAgICAgICAgRWFjaCBGZWF0dXJlIG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3RvcnkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgImZlYXR1cmVzIi5cblwKKyAgICAgICAgIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvblxuXAorICAgICAgICAgbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhc3NvY2lhdGVkIHdpdGggdGhhdCBGZWF0dXJlLlxuXAorICAgICAgIC0gRmVhdHVyZXMgbWF5IGFsc28gaW5jbHVkZSBvdGhlciBGZWF0dXJlcyAoIkluY2x1ZGVkIEZlYXR1cmVzIikuIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzXG5cCisgICAgICAgICBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy5cblwKK1xuXAorVGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZVxuXAorY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICJhYm91dC5odG1sIiAoIkFib3V0cyIpLiBUaGUgdGVybXMgYW5kXG5cCitjb25kaXRpb25zIGdvdmVybmluZyBGZWF0dXJlcyBhbmQgSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZFxuXAoraW4gZmlsZXMgbmFtZWQgImxpY2Vuc2UuaHRtbCIgKCJGZWF0dXJlIExpY2Vuc2VzIikuIEFib3V0cyBhbmQgRmVhdHVyZVxuXAorTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55IGRpcmVjdG9yeSBvZiBhIERvd25sb2FkIG9yIE1vZHVsZVxuXAoraW5jbHVkaW5nLCBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGZvbGxvd2luZyBsb2NhdGlvbnM6XG5cCitcblwKKyAgICAgICAtIFRoZSB0b3AtbGV2ZWwgKHJvb3QpIGRpcmVjdG9yeVxuXAorICAgICAgIC0gUGx1Zy1pbiBhbmQgRnJhZ21lbnQgZGlyZWN0b3JpZXNcblwKKyAgICAgICAtIEluc2lkZSBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHBhY2thZ2VkIGFzIEpBUnNcblwKKyAgICAgICAtIFN1Yi1kaXJlY3RvcmllcyBvZiB0aGUgZGlyZWN0b3J5IG5hbWVkICJzcmMiIG9mIGNlcnRhaW4gUGx1Zy1pbnNcblwKKyAgICAgICAtIEZlYXR1cmUgZGlyZWN0b3JpZXNcblwKK1xuXAorTm90ZTogaWYgYSBGZWF0dXJlIG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgaW5zdGFsbGVkIHVzaW5nIHRoZVxuXAorUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgKGFzIGRlZmluZWQgYmVsb3cpLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFxuXAorVXBkYXRlIExpY2Vuc2UiKSBkdXJpbmcgdGhlIGluc3RhbGxhdGlvbiBwcm9jZXNzLiBJZiB0aGUgRmVhdHVyZSBjb250YWluc1xuXAorSW5jbHVkZWQgRmVhdHVyZXMsIHRoZSBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIHNob3VsZCBlaXRoZXIgcHJvdmlkZSB5b3VcblwKK3dpdGggdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyB0aGUgSW5jbHVkZWQgRmVhdHVyZXMgb3IgaW5mb3JtXG5cCit5b3Ugd2hlcmUgeW91IGNhbiBsb2NhdGUgdGhlbS4gRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgbWF5IGJlIGZvdW5kIGluXG5cCit0aGUgImxpY2Vuc2UiIHByb3BlcnR5IG9mIGZpbGVzIG5hbWVkICJmZWF0dXJlLnByb3BlcnRpZXMiIGZvdW5kIHdpdGhpbiBhIEZlYXR1cmUuXG5cCitTdWNoIEFib3V0cywgRmVhdHVyZSBMaWNlbnNlcywgYW5kIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlXG5cCit0ZXJtcyBhbmQgY29uZGl0aW9ucyAob3IgcmVmZXJlbmNlcyB0byBzdWNoIHRlcm1zIGFuZCBjb25kaXRpb25zKSB0aGF0XG5cCitnb3Zlcm4geW91ciB1c2Ugb2YgdGhlIGFzc29jaWF0ZWQgQ29udGVudCBpbiB0aGF0IGRpcmVjdG9yeS5cblwKK1xuXAorVEhFIEFCT1VUUywgRkVBVFVSRSBMSUNFTlNFUywgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUlxuXAorVE8gVEhFIEVQTCBPUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuXG5cCitTT01FIE9GIFRIRVNFIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6XG5cCitcblwKKyAgICAgICAtIEVjbGlwc2UgRGlzdHJpYnV0aW9uIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xpY2Vuc2VzL2VkbC12MS4wLmh0bWwpXG5cCisgICAgICAgLSBDb21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbClcblwKKyAgICAgICAtIEFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFKVxuXAorICAgICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wKVxuXAorICAgICAgIC0gTWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwpXG5cCisgICAgICAgLSBNb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sKVxuXAorXG5cCitJVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCBDT05ESVRJT05TIFBSSU9SXG5cCitUTyBVU0UgT0YgVEhFIENPTlRFTlQuIElmIG5vIEFib3V0LCBGZWF0dXJlIExpY2Vuc2UsIG9yIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VcblwKK2lzIHByb3ZpZGVkLCBwbGVhc2UgY29udGFjdCB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHRvIGRldGVybWluZSB3aGF0IHRlcm1zIGFuZCBjb25kaXRpb25zXG5cCitnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuXG5cCitcblwKK1xuXFVzZSBvZiBQcm92aXNpb25pbmcgVGVjaG5vbG9neVxuXAorXG5cCitUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBwcm92aXNpb25pbmcgc29mdHdhcmUsIGV4YW1wbGVzIG9mIHdoaWNoIGluY2x1ZGUsXG5cCitidXQgYXJlIG5vdCBsaW1pdGVkIHRvLCBwMiBhbmQgdGhlIEVjbGlwc2UgVXBkYXRlIE1hbmFnZXIgKCJQcm92aXNpb25pbmcgVGVjaG5vbG9neSIpIGZvclxuXAordGhlIHB1cnBvc2Ugb2YgYWxsb3dpbmcgdXNlcnMgdG8gaW5zdGFsbCBzb2Z0d2FyZSwgZG9jdW1lbnRhdGlvbiwgaW5mb3JtYXRpb24gYW5kL29yXG5cCitvdGhlciBtYXRlcmlhbHMgKGNvbGxlY3RpdmVseSAiSW5zdGFsbGFibGUgU29mdHdhcmUiKS4gVGhpcyBjYXBhYmlsaXR5IGlzIHByb3ZpZGVkIHdpdGhcblwKK3RoZSBpbnRlbnQgb2YgYWxsb3dpbmcgc3VjaCB1c2VycyB0byBpbnN0YWxsLCBleHRlbmQgYW5kIHVwZGF0ZSBFY2xpcHNlLWJhc2VkIHByb2R1Y3RzLlxuXAorSW5mb3JtYXRpb24gYWJvdXQgcGFja2FnaW5nIEluc3RhbGxhYmxlIFNvZnR3YXJlIGlzIGF2YWlsYWJsZSBhdFxuXAoraHR0cDovL2VjbGlwc2Uub3JnL2VxdWlub3gvcDIvcmVwb3NpdG9yeV9wYWNrYWdpbmcuaHRtbCAoIlNwZWNpZmljYXRpb24iKS5cblwKK1xuXAorWW91IG1heSB1c2UgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgdG8gYWxsb3cgb3RoZXIgcGFydGllcyB0byBpbnN0YWxsIEluc3RhbGxhYmxlIFNvZnR3YXJlLlxuXAorWW91IHNoYWxsIGJlIHJlc3BvbnNpYmxlIGZvciBlbmFibGluZyB0aGUgYXBwbGljYWJsZSBsaWNlbnNlIGFncmVlbWVudHMgcmVsYXRpbmcgdG8gdGhlXG5cCitJbnN0YWxsYWJsZSBTb2Z0d2FyZSB0byBiZSBwcmVzZW50ZWQgdG8sIGFuZCBhY2NlcHRlZCBieSwgdGhlIHVzZXJzIG9mIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neVxuXAoraW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBTcGVjaWZpY2F0aW9uLiBCeSB1c2luZyBQcm92aXNpb25pbmcgVGVjaG5vbG9neSBpbiBzdWNoIGEgbWFubmVyIGFuZFxuXAorbWFraW5nIGl0IGF2YWlsYWJsZSBpbiBhY2NvcmRhbmNlIHdpdGggdGhlIFNwZWNpZmljYXRpb24sIHlvdSBmdXJ0aGVyIGFja25vd2xlZGdlIHlvdXJcblwKK2FncmVlbWVudCB0bywgYW5kIHRoZSBhY3F1aXNpdGlvbiBvZiBhbGwgbmVjZXNzYXJ5IHJpZ2h0cyB0byBwZXJtaXQgdGhlIGZvbGxvd2luZzpcblwKK1xuXAorICAgICAgIDEuIEEgc2VyaWVzIG9mIGFjdGlvbnMgbWF5IG9jY3VyICgiUHJvdmlzaW9uaW5nIFByb2Nlc3MiKSBpbiB3aGljaCBhIHVzZXIgbWF5IGV4ZWN1dGVcblwKKyAgICAgICAgICB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgb24gYSBtYWNoaW5lICgiVGFyZ2V0IE1hY2hpbmUiKSB3aXRoIHRoZSBpbnRlbnQgb2YgaW5zdGFsbGluZyxcblwKKyAgICAgICAgICBleHRlbmRpbmcgb3IgdXBkYXRpbmcgdGhlIGZ1bmN0aW9uYWxpdHkgb2YgYW4gRWNsaXBzZS1iYXNlZCBwcm9kdWN0LlxuXAorICAgICAgIDIuIER1cmluZyB0aGUgUHJvdmlzaW9uaW5nIFByb2Nlc3MsIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSBtYXkgY2F1c2UgdGhpcmQgcGFydHlcblwKKyAgICAgICAgICBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBvciBhIHBvcnRpb24gdGhlcmVvZiB0byBiZSBhY2Nlc3NlZCBhbmQgY29waWVkIHRvIHRoZSBUYXJnZXQgTWFjaGluZS5cblwKKyAgICAgICAzLiBQdXJzdWFudCB0byB0aGUgU3BlY2lmaWNhdGlvbiwgeW91IHdpbGwgcHJvdmlkZSB0byB0aGUgdXNlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgdGhhdFxuXAorICAgICAgICAgIGdvdmVybiB0aGUgdXNlIG9mIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSAoIkluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCIpIGFuZCBzdWNoXG5cCisgICAgICAgICAgSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50IHNoYWxsIGJlIGFjY2Vzc2VkIGZyb20gdGhlIFRhcmdldCBNYWNoaW5lIGluIGFjY29yZGFuY2VcblwKKyAgICAgICAgICB3aXRoIHRoZSBTcGVjaWZpY2F0aW9uLiBTdWNoIEluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCBtdXN0IGluZm9ybSB0aGUgdXNlciBvZiB0aGVcblwKKyAgICAgICAgICB0ZXJtcyBhbmQgY29uZGl0aW9ucyB0aGF0IGdvdmVybiB0aGUgSW5zdGFsbGFibGUgU29mdHdhcmUgYW5kIG11c3Qgc29saWNpdCBhY2NlcHRhbmNlIGJ5XG5cCisgICAgICAgICAgdGhlIGVuZCB1c2VyIGluIHRoZSBtYW5uZXIgcHJlc2NyaWJlZCBpbiBzdWNoIEluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudC4gVXBvbiBzdWNoXG5cCisgICAgICAgICAgaW5kaWNhdGlvbiBvZiBhZ3JlZW1lbnQgYnkgdGhlIHVzZXIsIHRoZSBwcm92aXNpb25pbmcgVGVjaG5vbG9neSB3aWxsIGNvbXBsZXRlIGluc3RhbGxhdGlvblxuXAorICAgICAgICAgIG9mIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZS5cblwKK1xuXAorQ3J5cHRvZ3JhcGh5XG5cCitcblwKK0NvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZVxuXAorY3VycmVudGx5IG1heSBoYXZlIHJlc3RyaWN0aW9ucyBvbiB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBhbmQgdXNlLFxuXAorYW5kL29yIHJlLWV4cG9ydCB0byBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRVxuXAordXNpbmcgYW55IGVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsXG5cCityZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgY29uY2VybmluZyB0aGUgaW1wb3J0LCBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZFxuXAorcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIHRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC5cblwKK1xuXAorSmF2YSBhbmQgYWxsIEphdmEtYmFzZWQgdHJhZGVtYXJrcyBhcmUgdHJhZGVtYXJrcyBvZiBPcmFjbGUgQ29ycG9yYXRpb24gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC5cbgorIyMjIyMjIyMjIyMgZW5kIG9mIGxpY2Vuc2UgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnRvb2xzL2ZlYXR1cmUueG1sIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy9mZWF0dXJlLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44YmM0M2EzCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy9mZWF0dXJlLnhtbApAQCAtMCwwICsxLDM4IEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPCEtLSM9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PSAtLT4KKzwhLS0jIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpIC0tPgorPCEtLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAtLT4KKzwhLS0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAtLT4KKzwhLS0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IC0tPgorPCEtLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgLS0+Cis8IS0tIyAtLT4KKzwhLS0jIENvbnRyaWJ1dG9yczogLS0+Cis8IS0tIyAgICAgQ2hyaXN0b3BoZSBMb2V0eiAoTG9ldHogR21iSCZDby5LRykgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24gLS0+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorCis8ZmVhdHVyZQorICAgICAgICBpZD0ib3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scyIKKyAgICAgICAgbGFiZWw9IiVmZWF0dXJlTmFtZSIKKyAgICAgICAgdmVyc2lvbj0iMC45LjAucXVhbGlmaWVyIgorICAgICAgICBwcm92aWRlci1uYW1lPSIlcHJvdmlkZXJOYW1lIj4KKyAgICAgICAgCisgICAgPGRlc2NyaXB0aW9uPgorICAgICAgICAlZGVzY3JpcHRpb24KKyAgICA8L2Rlc2NyaXB0aW9uPgorICAgICAgICAKKyAgICA8Y29weXJpZ2h0PgorICAgICAgICAlY29weXJpZ2h0CisgICAgPC9jb3B5cmlnaHQ+CisgICAgICAgIAorICAgIDxsaWNlbnNlIHVybD0iJWxpY2Vuc2VVUkwiPgorICAgICAgICAlbGljZW5zZQorICAgIDwvbGljZW5zZT4KKyAgICAgICAgCisgICAgPHBsdWdpbgorICAgICAgICBpZD0ib3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyIgorICAgICAgICBkb3dubG9hZC1zaXplPSIwIgorICAgICAgICBpbnN0YWxsLXNpemU9IjAiCisgICAgICAgIHZlcnNpb249IjAuMC4wIgorICAgICAgICB1bnBhY2s9ImZhbHNlIi8+CisgICAgICAgIAorPC9mZWF0dXJlPgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy9saWNlbnNlLmh0bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnRvb2xzL2xpY2Vuc2UuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ZTU3OWE1Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy9saWNlbnNlLmh0bWwKQEAgLTAsMCArMSwxNjQgQEAKKzwhLS0/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IklTTy04ODU5LTEiID8tLT4KKzwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFN0cmljdC8vRU4iICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS1zdHJpY3QuZHRkIj4KKzxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIj48aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiPgorPHRpdGxlPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvdGl0bGU+Cis8L2hlYWQ+CisKKzxib2R5IGxhbmc9IkVOLVVTIj4KKzxoMj5FY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L2gyPgorPHA+RmVicnVhcnkgMSwgMjAxMTwvcD4KKworPGgzPlVzYWdlIE9mIENvbnRlbnQ8L2gzPgorCis8cD5USEUgRUNMSVBTRSBGT1VOREFUSU9OIE1BS0VTIEFWQUlMQUJMRSBTT0ZUV0FSRSwgRE9DVU1FTlRBVElPTiwgSU5GT1JNQVRJT04gQU5EL09SIE9USEVSIE1BVEVSSUFMUyBGT1IgT1BFTiBTT1VSQ0UgUFJPSkVDVFMKKyAgIChDT0xMRUNUSVZFTFkgIkNPTlRFTlQiKS4gIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQKKyAgIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VIEFHUkVFIFRIQVQgWU9VUiBVU0UKKyAgIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SCisgICBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQKKyAgIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULjwvcD4KKworPGgzPkFwcGxpY2FibGUgTGljZW5zZXM8L2gzPgorCis8cD5Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UKKyBGb3VuZGF0aW9uIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIAorRWNsaXBzZSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMAorICAgKCJFUEwiKS4gIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpcyBDb250ZW50IGFuZCBpcyBhbHNvCisgYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT4uCisgICBGb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC48L3A+CisKKzxwPkNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLCAKK2RvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiAKK3NvdXJjZSBjb2RlCisgICByZXBvc2l0b3J5ICgiUmVwb3NpdG9yeSIpIGluIHNvZnR3YXJlIG1vZHVsZXMgKCJNb2R1bGVzIikgYW5kIG1hZGUgCithdmFpbGFibGUgYXMgZG93bmxvYWRhYmxlIGFyY2hpdmVzICgiRG93bmxvYWRzIikuPC9wPgorCis8dWw+CisgICAgICAgPGxpPkNvbnRlbnQgbWF5IGJlIHN0cnVjdHVyZWQgYW5kIHBhY2thZ2VkIGludG8gbW9kdWxlcyB0byAKK2ZhY2lsaXRhdGUgZGVsaXZlcmluZywgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiAgVHlwaWNhbCAKK21vZHVsZXMgbWF5IGluY2x1ZGUgcGx1Zy1pbnMgKCJQbHVnLWlucyIpLCBwbHVnLWluIGZyYWdtZW50cyAKKygiRnJhZ21lbnRzIiksIGFuZCBmZWF0dXJlcyAoIkZlYXR1cmVzIikuPC9saT4KKyAgICAgICA8bGk+RWFjaCBQbHVnLWluIG9yIEZyYWdtZW50IG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3Rvcnkgb3IgSkFSIChKYXZhJiM4NDgyOyBBUmNoaXZlKSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAicGx1Z2lucyIuPC9saT4KKyAgICAgICA8bGk+QSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciAKK0ZyYWdtZW50cyBhbmQgYXNzb2NpYXRlZCBtYXRlcmlhbC4gIEVhY2ggRmVhdHVyZSBtYXkgYmUgcGFja2FnZWQgYXMgYSAKK3N1Yi1kaXJlY3RvcnkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgImZlYXR1cmVzIi4gIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIAorbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgCitvZiB0aGUgUGx1Zy1pbnMKKyAgICAgIGFuZC9vciBGcmFnbWVudHMgYXNzb2NpYXRlZCB3aXRoIHRoYXQgRmVhdHVyZS48L2xpPgorICAgICAgIDxsaT5GZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgiSW5jbHVkZWQgCitGZWF0dXJlcyIpLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgCitsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIEluY2x1ZGVkIEZlYXR1cmVzLjwvbGk+Cis8L3VsPgorCis8cD5UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlIAorY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICJhYm91dC5odG1sIiAoIkFib3V0cyIpLiBUaGUgdGVybXMgYW5kIAorY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kCitJbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICJsaWNlbnNlLmh0bWwiIAorKCJGZWF0dXJlIExpY2Vuc2VzIikuICBBYm91dHMgYW5kIEZlYXR1cmUgTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55CisgZGlyZWN0b3J5IG9mIGEgRG93bmxvYWQgb3IgTW9kdWxlCitpbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIGxvY2F0aW9uczo8L3A+CisKKzx1bD4KKyAgICAgICA8bGk+VGhlIHRvcC1sZXZlbCAocm9vdCkgZGlyZWN0b3J5PC9saT4KKyAgICAgICA8bGk+UGx1Zy1pbiBhbmQgRnJhZ21lbnQgZGlyZWN0b3JpZXM8L2xpPgorICAgICAgIDxsaT5JbnNpZGUgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBwYWNrYWdlZCBhcyBKQVJzPC9saT4KKyAgICAgICA8bGk+U3ViLWRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgInNyYyIgb2YgY2VydGFpbiBQbHVnLWluczwvbGk+CisgICAgICAgPGxpPkZlYXR1cmUgZGlyZWN0b3JpZXM8L2xpPgorPC91bD4KKworPHA+Tm90ZTogaWYgYSBGZWF0dXJlIG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgCitpbnN0YWxsZWQgdXNpbmcgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IChhcyBkZWZpbmVkIGJlbG93KSwgeW91IG11c3QKKyBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIikgZHVyaW5nIHRoZQoraW5zdGFsbGF0aW9uIHByb2Nlc3MuICBJZiB0aGUgRmVhdHVyZSBjb250YWlucyBJbmNsdWRlZCBGZWF0dXJlcywgdGhlIAorRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBzaG91bGQgZWl0aGVyIHByb3ZpZGUgeW91IHdpdGggdGhlIHRlcm1zIGFuZCAKK2NvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvcgoraW5mb3JtIHlvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiAgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgbWF5IGJlIAorZm91bmQgaW4gdGhlICJsaWNlbnNlIiBwcm9wZXJ0eSBvZiBmaWxlcyBuYW1lZCAiZmVhdHVyZS5wcm9wZXJ0aWVzIiAKK2ZvdW5kIHdpdGhpbiBhIEZlYXR1cmUuCitTdWNoIEFib3V0cywgRmVhdHVyZSBMaWNlbnNlcywgYW5kIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIAordGVybXMgYW5kIGNvbmRpdGlvbnMgKG9yIHJlZmVyZW5jZXMgdG8gc3VjaCB0ZXJtcyBhbmQgY29uZGl0aW9ucykgdGhhdCAKK2dvdmVybiB5b3VyIHVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluCit0aGF0IGRpcmVjdG9yeS48L3A+CisKKzxwPlRIRSBBQk9VVFMsIEZFQVRVUkUgTElDRU5TRVMsIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVIgCitUTyBUSEUgRVBMIE9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy4KKyAgU09NRSBPRiBUSEVTRQorT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTo8L3A+CisKKzx1bD4KKyAgICAgICA8bGk+RWNsaXBzZSBEaXN0cmlidXRpb24gTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGljZW5zZXMvZWRsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xpY2Vuc2VzL2VkbC12MS4wLmh0bWw8L2E+KTwvbGk+CisgICAgICAgPGxpPkNvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbDwvYT4pPC9saT4KKyAgICAgICA8bGk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFPC9hPik8L2xpPgorICAgICAgIDxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMDwvYT4pPC9saT4KKyAgICAgICA8bGk+TWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwiPmh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sPC9hPik8L2xpPgorICAgICAgIDxsaT5Nb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sIj5odHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWw8L2E+KTwvbGk+Cis8L3VsPgorCis8cD5JVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCAKK0NPTkRJVElPTlMgUFJJT1IgVE8gVVNFIE9GIFRIRSBDT05URU5ULiAgSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSwgCitvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIGlzIHByb3ZpZGVkLCBwbGVhc2UKK2NvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9ucyAKK2dvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC48L3A+CisKKworPGgzPlVzZSBvZiBQcm92aXNpb25pbmcgVGVjaG5vbG9neTwvaDM+CisKKzxwPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIHByb3Zpc2lvbmluZyBzb2Z0d2FyZSwgCitleGFtcGxlcyBvZiB3aGljaCBpbmNsdWRlLCBidXQgYXJlIG5vdCBsaW1pdGVkIHRvLCBwMiBhbmQgdGhlIEVjbGlwc2UKKyAgIFVwZGF0ZSBNYW5hZ2VyICgiUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kiKSBmb3IgdGhlIHB1cnBvc2Ugb2YgCithbGxvd2luZyB1c2VycyB0byBpbnN0YWxsIHNvZnR3YXJlLCBkb2N1bWVudGF0aW9uLCBpbmZvcm1hdGlvbiBhbmQvb3IKKyAgIG90aGVyIG1hdGVyaWFscyAoY29sbGVjdGl2ZWx5ICJJbnN0YWxsYWJsZSBTb2Z0d2FyZSIpLiBUaGlzIAorY2FwYWJpbGl0eSBpcyBwcm92aWRlZCB3aXRoIHRoZSBpbnRlbnQgb2YgYWxsb3dpbmcgc3VjaCB1c2VycyB0bworICAgaW5zdGFsbCwgZXh0ZW5kIGFuZCB1cGRhdGUgRWNsaXBzZS1iYXNlZCBwcm9kdWN0cy4gSW5mb3JtYXRpb24gYWJvdXQgCitwYWNrYWdpbmcgSW5zdGFsbGFibGUgU29mdHdhcmUgaXMgYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly9lY2xpcHNlLm9yZy9lcXVpbm94L3AyL3JlcG9zaXRvcnlfcGFja2FnaW5nLmh0bWwiPmh0dHA6Ly9lY2xpcHNlLm9yZy9lcXVpbm94L3AyL3JlcG9zaXRvcnlfcGFja2FnaW5nLmh0bWw8L2E+CisgICAoIlNwZWNpZmljYXRpb24iKS48L3A+CisKKzxwPllvdSBtYXkgdXNlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IHRvIGFsbG93IG90aGVyIHBhcnRpZXMgdG8gaW5zdGFsbAorIEluc3RhbGxhYmxlIFNvZnR3YXJlLiBZb3Ugc2hhbGwgYmUgcmVzcG9uc2libGUgZm9yIGVuYWJsaW5nIHRoZQorICAgYXBwbGljYWJsZSBsaWNlbnNlIGFncmVlbWVudHMgcmVsYXRpbmcgdG8gdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlIHRvCisgYmUgcHJlc2VudGVkIHRvLCBhbmQgYWNjZXB0ZWQgYnksIHRoZSB1c2VycyBvZiB0aGUgUHJvdmlzaW9uaW5nIAorVGVjaG5vbG9neQorICAgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBTcGVjaWZpY2F0aW9uLiBCeSB1c2luZyBQcm92aXNpb25pbmcgCitUZWNobm9sb2d5IGluIHN1Y2ggYSBtYW5uZXIgYW5kIG1ha2luZyBpdCBhdmFpbGFibGUgaW4gYWNjb3JkYW5jZSB3aXRoIAordGhlCisgICBTcGVjaWZpY2F0aW9uLCB5b3UgZnVydGhlciBhY2tub3dsZWRnZSB5b3VyIGFncmVlbWVudCB0bywgYW5kIHRoZSAKK2FjcXVpc2l0aW9uIG9mIGFsbCBuZWNlc3NhcnkgcmlnaHRzIHRvIHBlcm1pdCB0aGUgZm9sbG93aW5nOjwvcD4KKworPG9sPgorICAgICAgIDxsaT5BIHNlcmllcyBvZiBhY3Rpb25zIG1heSBvY2N1ciAoIlByb3Zpc2lvbmluZyBQcm9jZXNzIikgaW4gCit3aGljaCBhIHVzZXIgbWF5IGV4ZWN1dGUgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5CisgICAgICAgb24gYSBtYWNoaW5lICgiVGFyZ2V0IE1hY2hpbmUiKSB3aXRoIHRoZSBpbnRlbnQgb2YgaW5zdGFsbGluZywgCitleHRlbmRpbmcgb3IgdXBkYXRpbmcgdGhlIGZ1bmN0aW9uYWxpdHkgb2YgYW4gRWNsaXBzZS1iYXNlZAorICAgICAgIHByb2R1Y3QuPC9saT4KKyAgICAgICA8bGk+RHVyaW5nIHRoZSBQcm92aXNpb25pbmcgUHJvY2VzcywgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IAorbWF5IGNhdXNlIHRoaXJkIHBhcnR5IEluc3RhbGxhYmxlIFNvZnR3YXJlIG9yIGEgcG9ydGlvbiB0aGVyZW9mIHRvIGJlCisgICAgICAgYWNjZXNzZWQgYW5kIGNvcGllZCB0byB0aGUgVGFyZ2V0IE1hY2hpbmUuPC9saT4KKyAgICAgICA8bGk+UHVyc3VhbnQgdG8gdGhlIFNwZWNpZmljYXRpb24sIHlvdSB3aWxsIHByb3ZpZGUgdG8gdGhlIHVzZXIgCit0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgdGhhdCBnb3Zlcm4gdGhlIHVzZSBvZiB0aGUgSW5zdGFsbGFibGUKKyAgICAgICBTb2Z0d2FyZSAoIkluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCIpIGFuZCBzdWNoIEluc3RhbGxhYmxlIAorU29mdHdhcmUgQWdyZWVtZW50IHNoYWxsIGJlIGFjY2Vzc2VkIGZyb20gdGhlIFRhcmdldAorICAgICAgIE1hY2hpbmUgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBTcGVjaWZpY2F0aW9uLiBTdWNoIEluc3RhbGxhYmxlIAorU29mdHdhcmUgQWdyZWVtZW50IG11c3QgaW5mb3JtIHRoZSB1c2VyIG9mIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyB0aGF0CisgZ292ZXJuCisgICAgICAgdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlIGFuZCBtdXN0IHNvbGljaXQgYWNjZXB0YW5jZSBieSB0aGUgZW5kIAordXNlciBpbiB0aGUgbWFubmVyIHByZXNjcmliZWQgaW4gc3VjaCBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQuIAorVXBvbiBzdWNoCisgICAgICAgaW5kaWNhdGlvbiBvZiBhZ3JlZW1lbnQgYnkgdGhlIHVzZXIsIHRoZSBwcm92aXNpb25pbmcgVGVjaG5vbG9neSAKK3dpbGwgY29tcGxldGUgaW5zdGFsbGF0aW9uIG9mIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZS48L2xpPgorPC9vbD4KKworPGgzPkNyeXB0b2dyYXBoeTwvaDM+CisKKzxwPkNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZQorIGN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSwgCithbmQvb3IgcmUtZXhwb3J0IHRvCisgICBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRSB1c2luZyBhbnkgZW5jcnlwdGlvbiAKK3NvZnR3YXJlLCBwbGVhc2UgY2hlY2sgdGhlIGNvdW50cnkncyBsYXdzLCByZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgCitjb25jZXJuaW5nIHRoZSBpbXBvcnQsCisgICBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIAordGhpcyBpcyBwZXJtaXR0ZWQuPC9wPgorCis8cD48c21hbGw+SmF2YSBhbmQgYWxsIEphdmEtYmFzZWQgdHJhZGVtYXJrcyBhcmUgdHJhZGVtYXJrcyBvZiBPcmFjbGUgQ29ycG9yYXRpb24gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC48L3NtYWxsPjwvcD4KKworCis8L2JvZHk+PC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudG9vbHMvcG9tLnhtbCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudG9vbHMvcG9tLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45ZDE3NDE1Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy9wb20ueG1sCkBAIC0wLDAgKzEsODQgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorPCEtLSMgQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpIC0tPgorPCEtLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAtLT4KKzwhLS0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAtLT4KKzwhLS0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IC0tPgorPCEtLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgLS0+Cis8IS0tIyAtLT4KKzwhLS0jIENvbnRyaWJ1dG9yczogLS0+Cis8IS0tIyAgICAgS2xlbWVucyBFZGxlciAoTHVuaWZlcmEgR21iSCkgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24gLS0+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorCis8cHJvamVjdCB4bWxucz0iaHR0cDovL21hdmVuLmFwYWNoZS5vcmcvUE9NLzQuMC4wIiB4bWxuczp4c2k9Imh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hLWluc3RhbmNlIiB4c2k6c2NoZW1hTG9jYXRpb249Imh0dHA6Ly9tYXZlbi5hcGFjaGUub3JnL1BPTS80LjAuMCBodHRwOi8vbWF2ZW4uYXBhY2hlLm9yZy9tYXZlbi12NF8wXzAueHNkIj4KKyAgICA8bW9kZWxWZXJzaW9uPjQuMC4wPC9tb2RlbFZlcnNpb24+CisKKyAgICA8cGFyZW50PgorICAgICAgICA8Z3JvdXBJZD5vcmcuZWNsaXBzZS5vc2JwLmlkZTwvZ3JvdXBJZD4KKyAgICAgICAgPGFydGlmYWN0SWQ+b3JnLmVjbGlwc2Uub3NicC5pZGU8L2FydGlmYWN0SWQ+CisgICAgICAgIDx2ZXJzaW9uPjAuOS4wLVNOQVBTSE9UPC92ZXJzaW9uPgorICAgIDwvcGFyZW50PgorCisgICAgPGFydGlmYWN0SWQ+b3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29sczwvYXJ0aWZhY3RJZD4KKyAgICA8cGFja2FnaW5nPmVjbGlwc2UtZmVhdHVyZTwvcGFja2FnaW5nPgorCisgICAgPGRlcGVuZGVuY2llcz4KKyAgICAKKyAgICA8L2RlcGVuZGVuY2llcz4KKworICAgIDxidWlsZD4KKyAgICAgICAgPHBsdWdpbnM+CisgICAgICAgICAgICA8cGx1Z2luPgorICAgICAgICAgICAgICAgIDxncm91cElkPm9yZy5lY2xpcHNlLnR5Y2hvLmV4dHJhczwvZ3JvdXBJZD4KKyAgICAgICAgICAgICAgICA8YXJ0aWZhY3RJZD50eWNoby1zb3VyY2UtZmVhdHVyZS1wbHVnaW48L2FydGlmYWN0SWQ+CisgICAgICAgICAgICAgICAgPHZlcnNpb24+JHt0eWNoby12ZXJzaW9ufTwvdmVyc2lvbj4KKyAgICAgICAgICAgICAgICA8ZXhlY3V0aW9ucz4KKyAgICAgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbj4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxpZD5zb3VyY2UtZmVhdHVyZTwvaWQ+CisgICAgICAgICAgICAgICAgICAgICAgICA8cGhhc2U+cGFja2FnZTwvcGhhc2U+CisgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbHM+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGdvYWw+c291cmNlLWZlYXR1cmU8L2dvYWw+CisgICAgICAgICAgICAgICAgICAgICAgICA8L2dvYWxzPgorICAgICAgICAgICAgICAgICAgICA8L2V4ZWN1dGlvbj4KKyAgICAgICAgICAgICAgICA8L2V4ZWN1dGlvbnM+CisgICAgICAgICAgICAgICAgPGNvbmZpZ3VyYXRpb24+CisgICAgICAgICAgICAgICAgICAgIDxsYWJlbFN1ZmZpeD4gKHNvdXJjZSk8L2xhYmVsU3VmZml4PgorICAgICAgICAgICAgICAgICAgICA8ZXhjbHVkZXM+CisgICAgICAgICAgICAgICAgICAgICAgICA8cGx1Z2luIGlkPSJjb20uaWJtLmljdSIvPgorICAgICAgICAgICAgICAgICAgICAgICAgPHBsdWdpbiBpZD0ib3JnLmFwYWNoZS5jb21tb25zLmNsaSIvPgorICAgICAgICAgICAgICAgICAgICAgICAgPHBsdWdpbiBpZD0iY29tLmdvb2dsZS5ndWF2YSIvPgorICAgICAgICAgICAgICAgICAgICA8L2V4Y2x1ZGVzPgorICAgICAgICAgICAgICAgIDwvY29uZmlndXJhdGlvbj4KKyAgICAgICAgICAgIDwvcGx1Z2luPgorICAgICAgICAgICAgPHBsdWdpbj4KKyAgICAgICAgICAgICAgICA8IS0tIHdvcmthcm91bmQgd2hpbGUgYnVnIGh0dHBzOi8vYnVncy5lY2xpcHNlLm9yZy9idWdzL3Nob3dfYnVnLmNnaT9pZD0zOTgyNTAgCisJCQkJCWlzIG5vdCBmaXhlZCAtLT4KKyAgICAgICAgICAgICAgICA8Z3JvdXBJZD5vcmcuZWNsaXBzZS50eWNobzwvZ3JvdXBJZD4KKyAgICAgICAgICAgICAgICA8YXJ0aWZhY3RJZD50eWNoby1wMi1wbHVnaW48L2FydGlmYWN0SWQ+CisgICAgICAgICAgICAgICAgPHZlcnNpb24+JHt0eWNoby12ZXJzaW9ufTwvdmVyc2lvbj4KKyAgICAgICAgICAgICAgICA8ZXhlY3V0aW9ucz4KKyAgICAgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbj4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxpZD5hdHRhY2hlZC1wMi1tZXRhZGF0YTwvaWQ+CisgICAgICAgICAgICAgICAgICAgICAgICA8cGhhc2U+cGFja2FnZTwvcGhhc2U+CisgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbHM+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGdvYWw+cDItbWV0YWRhdGE8L2dvYWw+CisgICAgICAgICAgICAgICAgICAgICAgICA8L2dvYWxzPgorICAgICAgICAgICAgICAgICAgICA8L2V4ZWN1dGlvbj4KKyAgICAgICAgICAgICAgICA8L2V4ZWN1dGlvbnM+CisgICAgICAgICAgICA8L3BsdWdpbj4KKwkJCTxwbHVnaW4+CisJCQkJPGFydGlmYWN0SWQ+bWF2ZW4tamF2YWRvYy1wbHVnaW48L2FydGlmYWN0SWQ+CisJCQkJPGV4ZWN1dGlvbnM+CisJCQkJCTxleGVjdXRpb24+CisJCQkJCQk8aWQ+amF2YWRvYy1qYXI8L2lkPgorCQkJCQkJPHBoYXNlPnBhY2thZ2U8L3BoYXNlPgorCQkJCQkJPGdvYWxzPgorCQkJCQkJCTxnb2FsPmphcjwvZ29hbD4KKwkJCQkJCTwvZ29hbHM+CisJCQkJCTwvZXhlY3V0aW9uPgorCQkJCTwvZXhlY3V0aW9ucz4KKwkJCTwvcGx1Z2luPgorICAgICAgICA8L3BsdWdpbnM+CisgICAgPC9idWlsZD4KKworPC9wcm9qZWN0PgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy9zcmMvbWFpbi9qYXZhZG9jL1JFQURNRS50eHQgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnRvb2xzL3NyYy9tYWluL2phdmFkb2MvUkVBRE1FLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44MzFkYTdlCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy9zcmMvbWFpbi9qYXZhZG9jL1JFQURNRS50eHQKQEAgLTAsMCArMSBAQAorUmVzb3VyY2UgZm9sZGVyIGZvciBqYXZhZG9jIHJlc291cmNlcy4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnRvb2xzL3NyYy9vdmVydmlldy5odG1sIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy9zcmMvb3ZlcnZpZXcuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jZjUxN2RhCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29scy9zcmMvb3ZlcnZpZXcuaHRtbApAQCAtMCwwICsxLDkgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAgVHJhbnNpdGlvbmFsLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorCTx0aXRsZT5PU0JQIHJ1bnRpbWUgd2ViIHZhYWRpbiBjb21wb25lbnRzIGZlYXR1cmUgT3ZlcnZpZXc8L3RpdGxlPgorPC9oZWFkPgorPGJvZHk+Cis8cD5UaGUgPGI+T1NCUCZuYnNwO2ZlYXR1cmU8L2I+IGNvbnRhaW5zIGRldmVsb3BlciB0b29scyBmb3IgT1NCUCBpbnRvIHRoZSBJREUuPC9wPgorPC9ib2R5PgorPC9odG1sPgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS51aS8ucHJvamVjdCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudWkvLnByb2plY3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNDQ2YTlmOAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudWkvLnByb2plY3QKQEAgLTAsMCArMSwzNCBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KKzxwcm9qZWN0RGVzY3JpcHRpb24+CisJPG5hbWU+b3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS51aTwvbmFtZT4KKwk8Y29tbWVudD48L2NvbW1lbnQ+CisJPHByb2plY3RzPgorCTwvcHJvamVjdHM+CisJPGJ1aWxkU3BlYz4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLnh0ZXh0LnVpLnNoYXJlZC54dGV4dEJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLkZlYXR1cmVCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5zb25hcmxpbnQuZWNsaXBzZS5jb3JlLnNvbmFybGludEJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UubTJlLmNvcmUubWF2ZW4yQnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJPC9idWlsZFNwZWM+CisJPG5hdHVyZXM+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UueHRleHQudWkuc2hhcmVkLnh0ZXh0TmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UubTJlLmNvcmUubWF2ZW4yTmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UucGRlLkZlYXR1cmVOYXR1cmU8L25hdHVyZT4KKwk8L25hdHVyZXM+Cis8L3Byb2plY3REZXNjcmlwdGlvbj4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudWkvTElDRU5TRS50eHQgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnVpL0xJQ0VOU0UudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmZmNDJhZDQKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnVpL0xJQ0VOU0UudHh0CkBAIC0wLDAgKzEsMTYxIEBACitFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC12IDEuMAorCitUSEUgQUNDT01QQU5ZSU5HIFBST0dSQU0gSVMgUFJPVklERUQgVU5ERVIgVEhFIFRFUk1TIE9GIFRISVMgRUNMSVBTRSBQVUJMSUMgTElDRU5TRSAoIkFHUkVFTUVOVCIpLiBBTlkgVVNFLCBSRVBST0RVQ1RJT04KK09SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBDT05TVElUVVRFUyBSRUNJUElFTlQnUyBBQ0NFUFRBTkNFIE9GIFRISVMgQUdSRUVNRU5ULgorCisxLiBERUZJTklUSU9OUworCisiQ29udHJpYnV0aW9uIiBtZWFuczoKKworYSkgaW4gdGhlIGNhc2Ugb2YgdGhlIGluaXRpYWwgQ29udHJpYnV0b3IsIHRoZSBpbml0aWFsIGNvZGUgYW5kIGRvY3VtZW50YXRpb24gZGlzdHJpYnV0ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGFuZAorCitiKSBpbiB0aGUgY2FzZSBvZiBlYWNoIHN1YnNlcXVlbnQgQ29udHJpYnV0b3I6CisKK2kpIGNoYW5nZXMgdG8gdGhlIFByb2dyYW0sIGFuZAorCitpaSkgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtOworCit3aGVyZSBzdWNoIGNoYW5nZXMgYW5kL29yIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbSBvcmlnaW5hdGUgZnJvbSBhbmQgYXJlIGRpc3RyaWJ1dGVkIGJ5IHRoYXQgcGFydGljdWxhciBDb250cmlidXRvci4KK0EgQ29udHJpYnV0aW9uICdvcmlnaW5hdGVzJyBmcm9tIGEgQ29udHJpYnV0b3IgaWYgaXQgd2FzIGFkZGVkIHRvIHRoZSBQcm9ncmFtIGJ5IHN1Y2ggQ29udHJpYnV0b3IgaXRzZWxmIG9yIGFueW9uZQorYWN0aW5nIG9uIHN1Y2ggQ29udHJpYnV0b3IncyBiZWhhbGYuIENvbnRyaWJ1dGlvbnMgZG8gbm90IGluY2x1ZGUgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIHdoaWNoOiAoaSkgYXJlIHNlcGFyYXRlCittb2R1bGVzIG9mIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIGluIGNvbmp1bmN0aW9uIHdpdGggdGhlIFByb2dyYW0gdW5kZXIgdGhlaXIgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBhbmQgKGlpKSBhcmUgbm90CitkZXJpdmF0aXZlIHdvcmtzIG9mIHRoZSBQcm9ncmFtLgorCisiQ29udHJpYnV0b3IiIG1lYW5zIGFueSBwZXJzb24gb3IgZW50aXR5IHRoYXQgZGlzdHJpYnV0ZXMgdGhlIFByb2dyYW0uCisKKyJMaWNlbnNlZCBQYXRlbnRzICIgbWVhbiBwYXRlbnQgY2xhaW1zIGxpY2Vuc2FibGUgYnkgYSBDb250cmlidXRvciB3aGljaCBhcmUgbmVjZXNzYXJpbHkgaW5mcmluZ2VkIGJ5IHRoZSB1c2Ugb3Igc2FsZSBvZgoraXRzIENvbnRyaWJ1dGlvbiBhbG9uZSBvciB3aGVuIGNvbWJpbmVkIHdpdGggdGhlIFByb2dyYW0uCisKKyJQcm9ncmFtIiBtZWFucyB0aGUgQ29udHJpYnV0aW9ucyBkaXN0cmlidXRlZCBpbiBhY2NvcmRhbmNlIHdpdGggdGhpcyBBZ3JlZW1lbnQuCisKKyJSZWNpcGllbnQiIG1lYW5zIGFueW9uZSB3aG8gcmVjZWl2ZXMgdGhlIFByb2dyYW0gdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGluY2x1ZGluZyBhbGwgQ29udHJpYnV0b3JzLgorCisyLiBHUkFOVCBPRiBSSUdIVFMKKworYSkgU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsCityb3lhbHR5LWZyZWUgY29weXJpZ2h0IGxpY2Vuc2UgdG8gcmVwcm9kdWNlLCBwcmVwYXJlIGRlcml2YXRpdmUgd29ya3Mgb2YsIHB1YmxpY2x5IGRpc3BsYXksIHB1YmxpY2x5IHBlcmZvcm0sIGRpc3RyaWJ1dGUKK2FuZCBzdWJsaWNlbnNlIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBhbmQgc3VjaCBkZXJpdmF0aXZlIHdvcmtzLCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUKK2Zvcm0uCisKK2IpIFN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLAorcm95YWx0eS1mcmVlIHBhdGVudCBsaWNlbnNlIHVuZGVyIExpY2Vuc2VkIFBhdGVudHMgdG8gbWFrZSwgdXNlLCBzZWxsLCBvZmZlciB0byBzZWxsLCBpbXBvcnQgYW5kIG90aGVyd2lzZSB0cmFuc2ZlciB0aGUKK0NvbnRyaWJ1dGlvbiBvZiBzdWNoIENvbnRyaWJ1dG9yLCBpZiBhbnksIGluIHNvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLiBUaGlzIHBhdGVudCBsaWNlbnNlIHNoYWxsIGFwcGx5IHRvIHRoZQorY29tYmluYXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBhbmQgdGhlIFByb2dyYW0gaWYsIGF0IHRoZSB0aW1lIHRoZSBDb250cmlidXRpb24gaXMgYWRkZWQgYnkgdGhlIENvbnRyaWJ1dG9yLCBzdWNoCithZGRpdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGNhdXNlcyBzdWNoIGNvbWJpbmF0aW9uIHRvIGJlIGNvdmVyZWQgYnkgdGhlIExpY2Vuc2VkIFBhdGVudHMuIFRoZSBwYXRlbnQgbGljZW5zZSBzaGFsbCBub3QKK2FwcGx5IHRvIGFueSBvdGhlciBjb21iaW5hdGlvbnMgd2hpY2ggaW5jbHVkZSB0aGUgQ29udHJpYnV0aW9uLiBObyBoYXJkd2FyZSBwZXIgc2UgaXMgbGljZW5zZWQgaGVyZXVuZGVyLgorCitjKSBSZWNpcGllbnQgdW5kZXJzdGFuZHMgdGhhdCBhbHRob3VnaCBlYWNoIENvbnRyaWJ1dG9yIGdyYW50cyB0aGUgbGljZW5zZXMgdG8gaXRzIENvbnRyaWJ1dGlvbnMgc2V0IGZvcnRoIGhlcmVpbiwgbm8KK2Fzc3VyYW5jZXMgYXJlIHByb3ZpZGVkIGJ5IGFueSBDb250cmlidXRvciB0aGF0IHRoZSBQcm9ncmFtIGRvZXMgbm90IGluZnJpbmdlIHRoZSBwYXRlbnQgb3Igb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5CityaWdodHMgb2YgYW55IG90aGVyIGVudGl0eS4gRWFjaCBDb250cmlidXRvciBkaXNjbGFpbXMgYW55IGxpYWJpbGl0eSB0byBSZWNpcGllbnQgZm9yIGNsYWltcyBicm91Z2h0IGJ5IGFueSBvdGhlciBlbnRpdHkKK2Jhc2VkIG9uIGluZnJpbmdlbWVudCBvZiBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG9yIG90aGVyd2lzZS4gQXMgYSBjb25kaXRpb24gdG8gZXhlcmNpc2luZyB0aGUgcmlnaHRzIGFuZAorbGljZW5zZXMgZ3JhbnRlZCBoZXJldW5kZXIsIGVhY2ggUmVjaXBpZW50IGhlcmVieSBhc3N1bWVzIHNvbGUgcmVzcG9uc2liaWxpdHkgdG8gc2VjdXJlIGFueSBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkKK3JpZ2h0cyBuZWVkZWQsIGlmIGFueS4gRm9yIGV4YW1wbGUsIGlmIGEgdGhpcmQgcGFydHkgcGF0ZW50IGxpY2Vuc2UgaXMgcmVxdWlyZWQgdG8gYWxsb3cgUmVjaXBpZW50IHRvIGRpc3RyaWJ1dGUgdGhlCitQcm9ncmFtLCBpdCBpcyBSZWNpcGllbnQncyByZXNwb25zaWJpbGl0eSB0byBhY3F1aXJlIHRoYXQgbGljZW5zZSBiZWZvcmUgZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtLgorCitkKSBFYWNoIENvbnRyaWJ1dG9yIHJlcHJlc2VudHMgdGhhdCB0byBpdHMga25vd2xlZGdlIGl0IGhhcyBzdWZmaWNpZW50IGNvcHlyaWdodCByaWdodHMgaW4gaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCB0bworZ3JhbnQgdGhlIGNvcHlyaWdodCBsaWNlbnNlIHNldCBmb3J0aCBpbiB0aGlzIEFncmVlbWVudC4KKworMy4gUkVRVUlSRU1FTlRTCisKK0EgQ29udHJpYnV0b3IgbWF5IGNob29zZSB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtIGluIG9iamVjdCBjb2RlIGZvcm0gdW5kZXIgaXRzIG93biBsaWNlbnNlIGFncmVlbWVudCwgcHJvdmlkZWQgdGhhdDoKKworYSkgaXQgY29tcGxpZXMgd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQ7IGFuZAorCitiKSBpdHMgbGljZW5zZSBhZ3JlZW1lbnQ6CisKK2kpIGVmZmVjdGl2ZWx5IGRpc2NsYWltcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgd2FycmFudGllcyBhbmQgY29uZGl0aW9ucywgZXhwcmVzcyBhbmQgaW1wbGllZCwgaW5jbHVkaW5nCit3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgdGl0bGUgYW5kIG5vbi1pbmZyaW5nZW1lbnQsIGFuZCBpbXBsaWVkIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiBtZXJjaGFudGFiaWxpdHkgYW5kCitmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZTsKKworaWkpIGVmZmVjdGl2ZWx5IGV4Y2x1ZGVzIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCBsaWFiaWxpdHkgZm9yIGRhbWFnZXMsIGluY2x1ZGluZyBkaXJlY3QsIGluZGlyZWN0LCBzcGVjaWFsLAoraW5jaWRlbnRhbCBhbmQgY29uc2VxdWVudGlhbCBkYW1hZ2VzLCBzdWNoIGFzIGxvc3QgcHJvZml0czsKKworaWlpKSBzdGF0ZXMgdGhhdCBhbnkgcHJvdmlzaW9ucyB3aGljaCBkaWZmZXIgZnJvbSB0aGlzIEFncmVlbWVudCBhcmUgb2ZmZXJlZCBieSB0aGF0IENvbnRyaWJ1dG9yIGFsb25lIGFuZCBub3QgYnkgYW55CitvdGhlciBwYXJ0eTsgYW5kCisKK2l2KSBzdGF0ZXMgdGhhdCBzb3VyY2UgY29kZSBmb3IgdGhlIFByb2dyYW0gaXMgYXZhaWxhYmxlIGZyb20gc3VjaCBDb250cmlidXRvciwgYW5kIGluZm9ybXMgbGljZW5zZWVzIGhvdyB0byBvYnRhaW4gaXQKK2luIGEgcmVhc29uYWJsZSBtYW5uZXIgb24gb3IgdGhyb3VnaCBhIG1lZGl1bSBjdXN0b21hcmlseSB1c2VkIGZvciBzb2Z0d2FyZSBleGNoYW5nZS4KKworV2hlbiB0aGUgUHJvZ3JhbSBpcyBtYWRlIGF2YWlsYWJsZSBpbiBzb3VyY2UgY29kZSBmb3JtOgorCithKSBpdCBtdXN0IGJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoaXMgQWdyZWVtZW50OyBhbmQKKworYikgYSBjb3B5IG9mIHRoaXMgQWdyZWVtZW50IG11c3QgYmUgaW5jbHVkZWQgd2l0aCBlYWNoIGNvcHkgb2YgdGhlIFByb2dyYW0uCisKK0NvbnRyaWJ1dG9ycyBtYXkgbm90IHJlbW92ZSBvciBhbHRlciBhbnkgY29weXJpZ2h0IG5vdGljZXMgY29udGFpbmVkIHdpdGhpbiB0aGUgUHJvZ3JhbS4KKworRWFjaCBDb250cmlidXRvciBtdXN0IGlkZW50aWZ5IGl0c2VsZiBhcyB0aGUgb3JpZ2luYXRvciBvZiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIGluIGEgbWFubmVyIHRoYXQgcmVhc29uYWJseSBhbGxvd3MKK3N1YnNlcXVlbnQgUmVjaXBpZW50cyB0byBpZGVudGlmeSB0aGUgb3JpZ2luYXRvciBvZiB0aGUgQ29udHJpYnV0aW9uLgorCis0LiBDT01NRVJDSUFMIERJU1RSSUJVVElPTgorCitDb21tZXJjaWFsIGRpc3RyaWJ1dG9ycyBvZiBzb2Z0d2FyZSBtYXkgYWNjZXB0IGNlcnRhaW4gcmVzcG9uc2liaWxpdGllcyB3aXRoIHJlc3BlY3QgdG8gZW5kIHVzZXJzLCBidXNpbmVzcyBwYXJ0bmVycyBhbmQKK3RoZSBsaWtlLiBXaGlsZSB0aGlzIGxpY2Vuc2UgaXMgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY29tbWVyY2lhbCB1c2Ugb2YgdGhlIFByb2dyYW0sIHRoZSBDb250cmlidXRvciB3aG8gaW5jbHVkZXMKK3RoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nIHNob3VsZCBkbyBzbyBpbiBhIG1hbm5lciB3aGljaCBkb2VzIG5vdCBjcmVhdGUgcG90ZW50aWFsIGxpYWJpbGl0eSBmb3IKK290aGVyIENvbnRyaWJ1dG9ycy4gVGhlcmVmb3JlLCBpZiBhIENvbnRyaWJ1dG9yIGluY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBzdWNoIENvbnRyaWJ1dG9yCisoIkNvbW1lcmNpYWwgQ29udHJpYnV0b3IiKSBoZXJlYnkgYWdyZWVzIHRvIGRlZmVuZCBhbmQgaW5kZW1uaWZ5IGV2ZXJ5IG90aGVyIENvbnRyaWJ1dG9yICgiSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IiKQorYWdhaW5zdCBhbnkgbG9zc2VzLCBkYW1hZ2VzIGFuZCBjb3N0cyAoY29sbGVjdGl2ZWx5ICJMb3NzZXMiKSBhcmlzaW5nIGZyb20gY2xhaW1zLCBsYXdzdWl0cyBhbmQgb3RoZXIgbGVnYWwgYWN0aW9ucworYnJvdWdodCBieSBhIHRoaXJkIHBhcnR5IGFnYWluc3QgdGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIHRvIHRoZSBleHRlbnQgY2F1c2VkIGJ5IHRoZSBhY3RzIG9yIG9taXNzaW9ucyBvZiBzdWNoCitDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluIGNvbm5lY3Rpb24gd2l0aCBpdHMgZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLiBUaGUKK29ibGlnYXRpb25zIGluIHRoaXMgc2VjdGlvbiBkbyBub3QgYXBwbHkgdG8gYW55IGNsYWltcyBvciBMb3NzZXMgcmVsYXRpbmcgdG8gYW55IGFjdHVhbCBvciBhbGxlZ2VkIGludGVsbGVjdHVhbAorcHJvcGVydHkgaW5mcmluZ2VtZW50LiBJbiBvcmRlciB0byBxdWFsaWZ5LCBhbiBJbmRlbW5pZmllZCBDb250cmlidXRvciBtdXN0OiBhKSBwcm9tcHRseSBub3RpZnkgdGhlIENvbW1lcmNpYWwKK0NvbnRyaWJ1dG9yIGluIHdyaXRpbmcgb2Ygc3VjaCBjbGFpbSwgYW5kIGIpIGFsbG93IHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRvIGNvbnRyb2wsIGFuZCBjb29wZXJhdGUgd2l0aCB0aGUKK0NvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4sIHRoZSBkZWZlbnNlIGFuZCBhbnkgcmVsYXRlZCBzZXR0bGVtZW50IG5lZ290aWF0aW9ucy4gVGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG1heQorIHBhcnRpY2lwYXRlIGluIGFueSBzdWNoIGNsYWltIGF0IGl0cyBvd24gZXhwZW5zZS4KKworRm9yIGV4YW1wbGUsIGEgQ29udHJpYnV0b3IgbWlnaHQgaW5jbHVkZSB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgUHJvZHVjdCBYLiBUaGF0IENvbnRyaWJ1dG9yIGlzCit0aGVuIGEgQ29tbWVyY2lhbCBDb250cmlidXRvci4gSWYgdGhhdCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRoZW4gbWFrZXMgcGVyZm9ybWFuY2UgY2xhaW1zLCBvciBvZmZlcnMgd2FycmFudGllcworcmVsYXRlZCB0byBQcm9kdWN0IFgsIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcyBhcmUgc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yJ3MgcmVzcG9uc2liaWxpdHkgYWxvbmUuCitVbmRlciB0aGlzIHNlY3Rpb24sIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHdvdWxkIGhhdmUgdG8gZGVmZW5kIGNsYWltcyBhZ2FpbnN0IHRoZSBvdGhlciBDb250cmlidXRvcnMgcmVsYXRlZCB0bwordGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZCB3YXJyYW50aWVzLCBhbmQgaWYgYSBjb3VydCByZXF1aXJlcyBhbnkgb3RoZXIgQ29udHJpYnV0b3IgdG8gcGF5IGFueSBkYW1hZ2VzIGFzIGEgcmVzdWx0LAordGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgbXVzdCBwYXkgdGhvc2UgZGFtYWdlcy4KKworNS4gTk8gV0FSUkFOVFkKKworRVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUyBBR1JFRU1FTlQsIFRIRSBQUk9HUkFNIElTIFBST1ZJREVEIE9OIEFOICJBUyBJUyIgQkFTSVMsIFdJVEhPVVQgV0FSUkFOVElFUyBPUgorQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgRUlUSEVSIEVYUFJFU1MgT1IgSU1QTElFRCBJTkNMVURJTkcsIFdJVEhPVVQgTElNSVRBVElPTiwgQU5ZIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBUSVRMRSwKK05PTi1JTkZSSU5HRU1FTlQsIE1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gRWFjaCBSZWNpcGllbnQgaXMgc29sZWx5IHJlc3BvbnNpYmxlIGZvcgorZGV0ZXJtaW5pbmcgdGhlIGFwcHJvcHJpYXRlbmVzcyBvZiB1c2luZyBhbmQgZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtIGFuZCBhc3N1bWVzIGFsbCByaXNrcyBhc3NvY2lhdGVkIHdpdGggaXRzCitleGVyY2lzZSBvZiByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgLCBpbmNsdWRpbmcgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSByaXNrcyBhbmQgY29zdHMgb2YgcHJvZ3JhbSBlcnJvcnMsIGNvbXBsaWFuY2UKK3dpdGggYXBwbGljYWJsZSBsYXdzLCBkYW1hZ2UgdG8gb3IgbG9zcyBvZiBkYXRhLCBwcm9ncmFtcyBvciBlcXVpcG1lbnQsIGFuZCB1bmF2YWlsYWJpbGl0eSBvciBpbnRlcnJ1cHRpb24gb2Ygb3BlcmF0aW9ucy4KKworNi4gRElTQ0xBSU1FUiBPRiBMSUFCSUxJVFkKKworRVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUyBBR1JFRU1FTlQsIE5FSVRIRVIgUkVDSVBJRU5UIE5PUiBBTlkgQ09OVFJJQlVUT1JTIFNIQUxMIEhBVkUgQU5ZIExJQUJJTElUWSBGT1IgQU5ZCitESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HIFdJVEhPVVQgTElNSVRBVElPTiBMT1NUIFBST0ZJVFMpLAorSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUgorT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIE9SIFRIRSBFWEVSQ0lTRSBPRiBBTlkgUklHSFRTIEdSQU5URUQKK0hFUkVVTkRFUiwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRVMuCisKKzcuIEdFTkVSQUwKKworSWYgYW55IHByb3Zpc2lvbiBvZiB0aGlzIEFncmVlbWVudCBpcyBpbnZhbGlkIG9yIHVuZW5mb3JjZWFibGUgdW5kZXIgYXBwbGljYWJsZSBsYXcsIGl0IHNoYWxsIG5vdCBhZmZlY3QgdGhlIHZhbGlkaXR5IG9yCitlbmZvcmNlYWJpbGl0eSBvZiB0aGUgcmVtYWluZGVyIG9mIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgYW5kIHdpdGhvdXQgZnVydGhlciBhY3Rpb24gYnkgdGhlIHBhcnRpZXMgaGVyZXRvLCBzdWNoCitwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlIG1pbmltdW0gZXh0ZW50IG5lY2Vzc2FyeSB0byBtYWtlIHN1Y2ggcHJvdmlzaW9uIHZhbGlkIGFuZCBlbmZvcmNlYWJsZS4KKworSWYgUmVjaXBpZW50IGluc3RpdHV0ZXMgcGF0ZW50IGxpdGlnYXRpb24gYWdhaW5zdCBhbnkgZW50aXR5IChpbmNsdWRpbmcgYSBjcm9zcy1jbGFpbSBvciBjb3VudGVyY2xhaW0gaW4gYSBsYXdzdWl0KQorYWxsZWdpbmcgdGhhdCB0aGUgUHJvZ3JhbSBpdHNlbGYgKGV4Y2x1ZGluZyBjb21iaW5hdGlvbnMgb2YgdGhlIFByb2dyYW0gd2l0aCBvdGhlciBzb2Z0d2FyZSBvciBoYXJkd2FyZSkgaW5mcmluZ2VzIHN1Y2gKK1JlY2lwaWVudCdzIHBhdGVudChzKSwgdGhlbiBzdWNoIFJlY2lwaWVudCdzIHJpZ2h0cyBncmFudGVkIHVuZGVyIFNlY3Rpb24gMihiKSBzaGFsbCB0ZXJtaW5hdGUgYXMgb2YgdGhlIGRhdGUgc3VjaAorbGl0aWdhdGlvbiBpcyBmaWxlZC4KKworQWxsIFJlY2lwaWVudCdzIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCBzaGFsbCB0ZXJtaW5hdGUgaWYgaXQgZmFpbHMgdG8gY29tcGx5IHdpdGggYW55IG9mIHRoZSBtYXRlcmlhbCB0ZXJtcyBvcgorY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudCBhbmQgZG9lcyBub3QgY3VyZSBzdWNoIGZhaWx1cmUgaW4gYSByZWFzb25hYmxlIHBlcmlvZCBvZiB0aW1lIGFmdGVyIGJlY29taW5nIGF3YXJlIG9mIHN1Y2gKK25vbmNvbXBsaWFuY2UuIElmIGFsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgdGVybWluYXRlLCBSZWNpcGllbnQgYWdyZWVzIHRvIGNlYXNlIHVzZSBhbmQgZGlzdHJpYnV0aW9uCitvZiB0aGUgUHJvZ3JhbSBhcyBzb29uIGFzIHJlYXNvbmFibHkgcHJhY3RpY2FibGUuIEhvd2V2ZXIsIFJlY2lwaWVudCdzIG9ibGlnYXRpb25zIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFuZCBhbnkgbGljZW5zZXMKKyBncmFudGVkIGJ5IFJlY2lwaWVudCByZWxhdGluZyB0byB0aGUgUHJvZ3JhbSBzaGFsbCBjb250aW51ZSBhbmQgc3Vydml2ZS4KKworRXZlcnlvbmUgaXMgcGVybWl0dGVkIHRvIGNvcHkgYW5kIGRpc3RyaWJ1dGUgY29waWVzIG9mIHRoaXMgQWdyZWVtZW50LCBidXQgaW4gb3JkZXIgdG8gYXZvaWQgaW5jb25zaXN0ZW5jeSB0aGUgQWdyZWVtZW50CitpcyBjb3B5cmlnaHRlZCBhbmQgbWF5IG9ubHkgYmUgbW9kaWZpZWQgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXIuIFRoZSBBZ3JlZW1lbnQgU3Rld2FyZCByZXNlcnZlcyB0aGUgcmlnaHQgdG8gcHVibGlzaAorbmV3IHZlcnNpb25zIChpbmNsdWRpbmcgcmV2aXNpb25zKSBvZiB0aGlzIEFncmVlbWVudCBmcm9tIHRpbWUgdG8gdGltZS4gTm8gb25lIG90aGVyIHRoYW4gdGhlIEFncmVlbWVudCBTdGV3YXJkIGhhcyB0aGUKK3JpZ2h0IHRvIG1vZGlmeSB0aGlzIEFncmVlbWVudC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyB0aGUgaW5pdGlhbCBBZ3JlZW1lbnQgU3Rld2FyZC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYXkKK2Fzc2lnbiB0aGUgcmVzcG9uc2liaWxpdHkgdG8gc2VydmUgYXMgdGhlIEFncmVlbWVudCBTdGV3YXJkIHRvIGEgc3VpdGFibGUgc2VwYXJhdGUgZW50aXR5LiBFYWNoIG5ldyB2ZXJzaW9uIG9mIHRoZQorQWdyZWVtZW50IHdpbGwgYmUgZ2l2ZW4gYSBkaXN0aW5ndWlzaGluZyB2ZXJzaW9uIG51bWJlci4gVGhlIFByb2dyYW0gKGluY2x1ZGluZyBDb250cmlidXRpb25zKSBtYXkgYWx3YXlzIGJlCitkaXN0cmlidXRlZCBzdWJqZWN0IHRvIHRoZSB2ZXJzaW9uIG9mIHRoZSBBZ3JlZW1lbnQgdW5kZXIgd2hpY2ggaXQgd2FzIHJlY2VpdmVkLiBJbiBhZGRpdGlvbiwgYWZ0ZXIgYSBuZXcgdmVyc2lvbiBvZgordGhlIEFncmVlbWVudCBpcyBwdWJsaXNoZWQsIENvbnRyaWJ1dG9yIG1heSBlbGVjdCB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtIChpbmNsdWRpbmcgaXRzIENvbnRyaWJ1dGlvbnMpIHVuZGVyIHRoZQorbmV3IHZlcnNpb24uIEV4Y2VwdCBhcyBleHByZXNzbHkgc3RhdGVkIGluIFNlY3Rpb25zIDIoYSkgYW5kIDIoYikgYWJvdmUsIFJlY2lwaWVudCByZWNlaXZlcyBubyByaWdodHMgb3IgbGljZW5zZXMgdG8KK3RoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgb2YgYW55IENvbnRyaWJ1dG9yIHVuZGVyIHRoaXMgQWdyZWVtZW50LCB3aGV0aGVyIGV4cHJlc3NseSwgYnkgaW1wbGljYXRpb24sIGVzdG9wcGVsIG9yCitvdGhlcndpc2UuIEFsbCByaWdodHMgaW4gdGhlIFByb2dyYW0gbm90IGV4cHJlc3NseSBncmFudGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFyZSByZXNlcnZlZC4KKworVGhpcyBBZ3JlZW1lbnQgaXMgZ292ZXJuZWQgYnkgdGhlIGxhd3Mgb2YgdGhlIFN0YXRlIG9mIE5ldyBZb3JrIGFuZCB0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGxhd3Mgb2YgdGhlIFVuaXRlZCBTdGF0ZXMKK29mIEFtZXJpY2EuIE5vIHBhcnR5IHRvIHRoaXMgQWdyZWVtZW50IHdpbGwgYnJpbmcgYSBsZWdhbCBhY3Rpb24gdW5kZXIgdGhpcyBBZ3JlZW1lbnQgbW9yZSB0aGFuIG9uZSB5ZWFyIGFmdGVyIHRoZSBjYXVzZQorb2YgYWN0aW9uIGFyb3NlLiBFYWNoIHBhcnR5IHdhaXZlcyBpdHMgcmlnaHRzIHRvIGEganVyeSB0cmlhbCBpbiBhbnkgcmVzdWx0aW5nIGxpdGlnYXRpb24uClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS51aS9idWlsZC5wcm9wZXJ0aWVzIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS51aS9idWlsZC5wcm9wZXJ0aWVzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmRiZDljNDQKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnVpL2J1aWxkLnByb3BlcnRpZXMKQEAgLTAsMCArMSw2IEBACitiaW4uaW5jbHVkZXMgPSBmZWF0dXJlLnhtbCxcCisgICAgICAgICAgICAgICBmZWF0dXJlLnByb3BlcnRpZXMsXAorICAgICAgICAgICAgICAgTElDRU5TRS50eHQsXAorICAgICAgICAgICAgICAgbGljZW5zZS5odG1sCitzcmMuaW5jbHVkZXMgPSBsaWNlbnNlLmh0bWwsXAorICAgICAgICAgICAgICAgTElDRU5TRS50eHQKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudWkvZXBsLXYxMC5odG1sIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS51aS9lcGwtdjEwLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYjM5OGFjYwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudWkvZXBsLXYxMC5odG1sCkBAIC0wLDAgKzEsMjU5IEBACis8IS0tP3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJJU08tODg1OS0xIiA/LS0+Cis8IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL1czQy8vRFREIFhIVE1MIDEuMCBUcmFuc2l0aW9uYWwvL0VOIiAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtdHJhbnNpdGlvbmFsLmR0ZCI+Cis8aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+PGhlYWQ+Cis8bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1JU08tODg1OS0xIj4KKzx0aXRsZT5FY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC0gVmVyc2lvbiAxLjA8L3RpdGxlPgorPHN0eWxlIHR5cGU9InRleHQvY3NzIj4KKyAgYm9keSB7CisgICAgc2l6ZTogOC41aW4gMTEuMGluOworICAgIG1hcmdpbjogMC4yNWluIDAuNWluIDAuMjVpbiAwLjVpbjsKKyAgICB0YWItaW50ZXJ2YWw6IDAuNWluOworICAgIH0KKyAgcCB7ICAJCisgICAgbWFyZ2luLWxlZnQ6IGF1dG87CisgICAgbWFyZ2luLXRvcDogIDAuNWVtOworICAgIG1hcmdpbi1ib3R0b206IDAuNWVtOworICAgIH0KKyAgcC5saXN0IHsKKyAgCW1hcmdpbi1sZWZ0OiAwLjVpbjsKKyAgICBtYXJnaW4tdG9wOiAgMC4wNWVtOworICAgIG1hcmdpbi1ib3R0b206IDAuMDVlbTsKKyAgICB9CisgIDwvc3R5bGU+CisKKzwvaGVhZD4KKworPGJvZHkgbGFuZz0iRU4tVVMiPgorCis8aDI+RWNsaXBzZSBQdWJsaWMgTGljZW5zZSAtIHYgMS4wPC9oMj4KKworPHA+VEhFIEFDQ09NUEFOWUlORyBQUk9HUkFNIElTIFBST1ZJREVEIFVOREVSIFRIRSBURVJNUyBPRiBUSElTIEVDTElQU0UKK1BVQkxJQyBMSUNFTlNFICgiQUdSRUVNRU5UIikuIEFOWSBVU0UsIFJFUFJPRFVDVElPTiBPUgorRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIENPTlNUSVRVVEVTIFJFQ0lQSUVOVCdTIEFDQ0VQVEFOQ0UgT0YgVEhJUworQUdSRUVNRU5ULjwvcD4KKworPHA+PGI+MS4gREVGSU5JVElPTlM8L2I+PC9wPgorCis8cD4iQ29udHJpYnV0aW9uIiBtZWFuczo8L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5hKSBpbiB0aGUgY2FzZSBvZiB0aGUgaW5pdGlhbCBDb250cmlidXRvciwgdGhlIGluaXRpYWwKK2NvZGUgYW5kIGRvY3VtZW50YXRpb24gZGlzdHJpYnV0ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGFuZDwvcD4KKzxwIGNsYXNzPSJsaXN0Ij5iKSBpbiB0aGUgY2FzZSBvZiBlYWNoIHN1YnNlcXVlbnQgQ29udHJpYnV0b3I6PC9wPgorPHAgY2xhc3M9Imxpc3QiPmkpIGNoYW5nZXMgdG8gdGhlIFByb2dyYW0sIGFuZDwvcD4KKzxwIGNsYXNzPSJsaXN0Ij5paSkgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtOzwvcD4KKzxwIGNsYXNzPSJsaXN0Ij53aGVyZSBzdWNoIGNoYW5nZXMgYW5kL29yIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbQorb3JpZ2luYXRlIGZyb20gYW5kIGFyZSBkaXN0cmlidXRlZCBieSB0aGF0IHBhcnRpY3VsYXIgQ29udHJpYnV0b3IuIEEKK0NvbnRyaWJ1dGlvbiAnb3JpZ2luYXRlcycgZnJvbSBhIENvbnRyaWJ1dG9yIGlmIGl0IHdhcyBhZGRlZCB0byB0aGUKK1Byb2dyYW0gYnkgc3VjaCBDb250cmlidXRvciBpdHNlbGYgb3IgYW55b25lIGFjdGluZyBvbiBzdWNoCitDb250cmlidXRvcidzIGJlaGFsZi4gQ29udHJpYnV0aW9ucyBkbyBub3QgaW5jbHVkZSBhZGRpdGlvbnMgdG8gdGhlCitQcm9ncmFtIHdoaWNoOiAoaSkgYXJlIHNlcGFyYXRlIG1vZHVsZXMgb2Ygc29mdHdhcmUgZGlzdHJpYnV0ZWQgaW4KK2Nvbmp1bmN0aW9uIHdpdGggdGhlIFByb2dyYW0gdW5kZXIgdGhlaXIgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBhbmQgKGlpKQorYXJlIG5vdCBkZXJpdmF0aXZlIHdvcmtzIG9mIHRoZSBQcm9ncmFtLjwvcD4KKworPHA+IkNvbnRyaWJ1dG9yIiBtZWFucyBhbnkgcGVyc29uIG9yIGVudGl0eSB0aGF0IGRpc3RyaWJ1dGVzCit0aGUgUHJvZ3JhbS48L3A+CisKKzxwPiJMaWNlbnNlZCBQYXRlbnRzIiBtZWFuIHBhdGVudCBjbGFpbXMgbGljZW5zYWJsZSBieSBhCitDb250cmlidXRvciB3aGljaCBhcmUgbmVjZXNzYXJpbHkgaW5mcmluZ2VkIGJ5IHRoZSB1c2Ugb3Igc2FsZSBvZiBpdHMKK0NvbnRyaWJ1dGlvbiBhbG9uZSBvciB3aGVuIGNvbWJpbmVkIHdpdGggdGhlIFByb2dyYW0uPC9wPgorCis8cD4iUHJvZ3JhbSIgbWVhbnMgdGhlIENvbnRyaWJ1dGlvbnMgZGlzdHJpYnV0ZWQgaW4gYWNjb3JkYW5jZQord2l0aCB0aGlzIEFncmVlbWVudC48L3A+CisKKzxwPiJSZWNpcGllbnQiIG1lYW5zIGFueW9uZSB3aG8gcmVjZWl2ZXMgdGhlIFByb2dyYW0gdW5kZXIKK3RoaXMgQWdyZWVtZW50LCBpbmNsdWRpbmcgYWxsIENvbnRyaWJ1dG9ycy48L3A+CisKKzxwPjxiPjIuIEdSQU5UIE9GIFJJR0hUUzwvYj48L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5hKSBTdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaAorQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsCityb3lhbHR5LWZyZWUgY29weXJpZ2h0IGxpY2Vuc2UgdG8gcmVwcm9kdWNlLCBwcmVwYXJlIGRlcml2YXRpdmUgd29ya3MKK29mLCBwdWJsaWNseSBkaXNwbGF5LCBwdWJsaWNseSBwZXJmb3JtLCBkaXN0cmlidXRlIGFuZCBzdWJsaWNlbnNlIHRoZQorQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgYW5kIHN1Y2ggZGVyaXZhdGl2ZSB3b3JrcywgaW4KK3NvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLjwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmIpIFN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoCitDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwKK3JveWFsdHktZnJlZSBwYXRlbnQgbGljZW5zZSB1bmRlciBMaWNlbnNlZCBQYXRlbnRzIHRvIG1ha2UsIHVzZSwgc2VsbCwKK29mZmVyIHRvIHNlbGwsIGltcG9ydCBhbmQgb3RoZXJ3aXNlIHRyYW5zZmVyIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaAorQ29udHJpYnV0b3IsIGlmIGFueSwgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlIGZvcm0uIFRoaXMgcGF0ZW50CitsaWNlbnNlIHNoYWxsIGFwcGx5IHRvIHRoZSBjb21iaW5hdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGFuZCB0aGUKK1Byb2dyYW0gaWYsIGF0IHRoZSB0aW1lIHRoZSBDb250cmlidXRpb24gaXMgYWRkZWQgYnkgdGhlIENvbnRyaWJ1dG9yLAorc3VjaCBhZGRpdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGNhdXNlcyBzdWNoIGNvbWJpbmF0aW9uIHRvIGJlIGNvdmVyZWQKK2J5IHRoZSBMaWNlbnNlZCBQYXRlbnRzLiBUaGUgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgbm90IGFwcGx5IHRvIGFueSBvdGhlcgorY29tYmluYXRpb25zIHdoaWNoIGluY2x1ZGUgdGhlIENvbnRyaWJ1dGlvbi4gTm8gaGFyZHdhcmUgcGVyIHNlIGlzCitsaWNlbnNlZCBoZXJldW5kZXIuPC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YykgUmVjaXBpZW50IHVuZGVyc3RhbmRzIHRoYXQgYWx0aG91Z2ggZWFjaCBDb250cmlidXRvcgorZ3JhbnRzIHRoZSBsaWNlbnNlcyB0byBpdHMgQ29udHJpYnV0aW9ucyBzZXQgZm9ydGggaGVyZWluLCBubyBhc3N1cmFuY2VzCithcmUgcHJvdmlkZWQgYnkgYW55IENvbnRyaWJ1dG9yIHRoYXQgdGhlIFByb2dyYW0gZG9lcyBub3QgaW5mcmluZ2UgdGhlCitwYXRlbnQgb3Igb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5IHJpZ2h0cyBvZiBhbnkgb3RoZXIgZW50aXR5LiBFYWNoCitDb250cmlidXRvciBkaXNjbGFpbXMgYW55IGxpYWJpbGl0eSB0byBSZWNpcGllbnQgZm9yIGNsYWltcyBicm91Z2h0IGJ5Cithbnkgb3RoZXIgZW50aXR5IGJhc2VkIG9uIGluZnJpbmdlbWVudCBvZiBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzCitvciBvdGhlcndpc2UuIEFzIGEgY29uZGl0aW9uIHRvIGV4ZXJjaXNpbmcgdGhlIHJpZ2h0cyBhbmQgbGljZW5zZXMKK2dyYW50ZWQgaGVyZXVuZGVyLCBlYWNoIFJlY2lwaWVudCBoZXJlYnkgYXNzdW1lcyBzb2xlIHJlc3BvbnNpYmlsaXR5IHRvCitzZWN1cmUgYW55IG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgbmVlZGVkLCBpZiBhbnkuIEZvcgorZXhhbXBsZSwgaWYgYSB0aGlyZCBwYXJ0eSBwYXRlbnQgbGljZW5zZSBpcyByZXF1aXJlZCB0byBhbGxvdyBSZWNpcGllbnQKK3RvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0sIGl0IGlzIFJlY2lwaWVudCdzIHJlc3BvbnNpYmlsaXR5IHRvIGFjcXVpcmUKK3RoYXQgbGljZW5zZSBiZWZvcmUgZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtLjwvcD4KKworPHAgY2xhc3M9Imxpc3QiPmQpIEVhY2ggQ29udHJpYnV0b3IgcmVwcmVzZW50cyB0aGF0IHRvIGl0cyBrbm93bGVkZ2UgaXQKK2hhcyBzdWZmaWNpZW50IGNvcHlyaWdodCByaWdodHMgaW4gaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCB0byBncmFudAordGhlIGNvcHlyaWdodCBsaWNlbnNlIHNldCBmb3J0aCBpbiB0aGlzIEFncmVlbWVudC48L3A+CisKKzxwPjxiPjMuIFJFUVVJUkVNRU5UUzwvYj48L3A+CisKKzxwPkEgQ29udHJpYnV0b3IgbWF5IGNob29zZSB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtIGluIG9iamVjdCBjb2RlCitmb3JtIHVuZGVyIGl0cyBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIHByb3ZpZGVkIHRoYXQ6PC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YSkgaXQgY29tcGxpZXMgd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhpcworQWdyZWVtZW50OyBhbmQ8L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5iKSBpdHMgbGljZW5zZSBhZ3JlZW1lbnQ6PC9wPgorCis8cCBjbGFzcz0ibGlzdCI+aSkgZWZmZWN0aXZlbHkgZGlzY2xhaW1zIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzCithbGwgd2FycmFudGllcyBhbmQgY29uZGl0aW9ucywgZXhwcmVzcyBhbmQgaW1wbGllZCwgaW5jbHVkaW5nIHdhcnJhbnRpZXMKK29yIGNvbmRpdGlvbnMgb2YgdGl0bGUgYW5kIG5vbi1pbmZyaW5nZW1lbnQsIGFuZCBpbXBsaWVkIHdhcnJhbnRpZXMgb3IKK2NvbmRpdGlvbnMgb2YgbWVyY2hhbnRhYmlsaXR5IGFuZCBmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZTs8L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5paSkgZWZmZWN0aXZlbHkgZXhjbHVkZXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMKK2FsbCBsaWFiaWxpdHkgZm9yIGRhbWFnZXMsIGluY2x1ZGluZyBkaXJlY3QsIGluZGlyZWN0LCBzcGVjaWFsLAoraW5jaWRlbnRhbCBhbmQgY29uc2VxdWVudGlhbCBkYW1hZ2VzLCBzdWNoIGFzIGxvc3QgcHJvZml0czs8L3A+CisKKzxwIGNsYXNzPSJsaXN0Ij5paWkpIHN0YXRlcyB0aGF0IGFueSBwcm92aXNpb25zIHdoaWNoIGRpZmZlciBmcm9tIHRoaXMKK0FncmVlbWVudCBhcmUgb2ZmZXJlZCBieSB0aGF0IENvbnRyaWJ1dG9yIGFsb25lIGFuZCBub3QgYnkgYW55IG90aGVyCitwYXJ0eTsgYW5kPC9wPgorCis8cCBjbGFzcz0ibGlzdCI+aXYpIHN0YXRlcyB0aGF0IHNvdXJjZSBjb2RlIGZvciB0aGUgUHJvZ3JhbSBpcyBhdmFpbGFibGUKK2Zyb20gc3VjaCBDb250cmlidXRvciwgYW5kIGluZm9ybXMgbGljZW5zZWVzIGhvdyB0byBvYnRhaW4gaXQgaW4gYQorcmVhc29uYWJsZSBtYW5uZXIgb24gb3IgdGhyb3VnaCBhIG1lZGl1bSBjdXN0b21hcmlseSB1c2VkIGZvciBzb2Z0d2FyZQorZXhjaGFuZ2UuPC9wPgorCis8cD5XaGVuIHRoZSBQcm9ncmFtIGlzIG1hZGUgYXZhaWxhYmxlIGluIHNvdXJjZSBjb2RlIGZvcm06PC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YSkgaXQgbXVzdCBiZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGlzIEFncmVlbWVudDsgYW5kPC9wPgorCis8cCBjbGFzcz0ibGlzdCI+YikgYSBjb3B5IG9mIHRoaXMgQWdyZWVtZW50IG11c3QgYmUgaW5jbHVkZWQgd2l0aCBlYWNoCitjb3B5IG9mIHRoZSBQcm9ncmFtLjwvcD4KKworPHA+Q29udHJpYnV0b3JzIG1heSBub3QgcmVtb3ZlIG9yIGFsdGVyIGFueSBjb3B5cmlnaHQgbm90aWNlcyBjb250YWluZWQKK3dpdGhpbiB0aGUgUHJvZ3JhbS48L3A+CisKKzxwPkVhY2ggQ29udHJpYnV0b3IgbXVzdCBpZGVudGlmeSBpdHNlbGYgYXMgdGhlIG9yaWdpbmF0b3Igb2YgaXRzCitDb250cmlidXRpb24sIGlmIGFueSwgaW4gYSBtYW5uZXIgdGhhdCByZWFzb25hYmx5IGFsbG93cyBzdWJzZXF1ZW50CitSZWNpcGllbnRzIHRvIGlkZW50aWZ5IHRoZSBvcmlnaW5hdG9yIG9mIHRoZSBDb250cmlidXRpb24uPC9wPgorCis8cD48Yj40LiBDT01NRVJDSUFMIERJU1RSSUJVVElPTjwvYj48L3A+CisKKzxwPkNvbW1lcmNpYWwgZGlzdHJpYnV0b3JzIG9mIHNvZnR3YXJlIG1heSBhY2NlcHQgY2VydGFpbgorcmVzcG9uc2liaWxpdGllcyB3aXRoIHJlc3BlY3QgdG8gZW5kIHVzZXJzLCBidXNpbmVzcyBwYXJ0bmVycyBhbmQgdGhlCitsaWtlLiBXaGlsZSB0aGlzIGxpY2Vuc2UgaXMgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY29tbWVyY2lhbCB1c2Ugb2YKK3RoZSBQcm9ncmFtLCB0aGUgQ29udHJpYnV0b3Igd2hvIGluY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbAorcHJvZHVjdCBvZmZlcmluZyBzaG91bGQgZG8gc28gaW4gYSBtYW5uZXIgd2hpY2ggZG9lcyBub3QgY3JlYXRlCitwb3RlbnRpYWwgbGlhYmlsaXR5IGZvciBvdGhlciBDb250cmlidXRvcnMuIFRoZXJlZm9yZSwgaWYgYSBDb250cmlidXRvcgoraW5jbHVkZXMgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIHN1Y2ggQ29udHJpYnV0b3IKKygiQ29tbWVyY2lhbCBDb250cmlidXRvciIpIGhlcmVieSBhZ3JlZXMgdG8gZGVmZW5kIGFuZAoraW5kZW1uaWZ5IGV2ZXJ5IG90aGVyIENvbnRyaWJ1dG9yICgiSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IiKQorYWdhaW5zdCBhbnkgbG9zc2VzLCBkYW1hZ2VzIGFuZCBjb3N0cyAoY29sbGVjdGl2ZWx5ICJMb3NzZXMiKQorYXJpc2luZyBmcm9tIGNsYWltcywgbGF3c3VpdHMgYW5kIG90aGVyIGxlZ2FsIGFjdGlvbnMgYnJvdWdodCBieSBhIHRoaXJkCitwYXJ0eSBhZ2FpbnN0IHRoZSBJbmRlbW5pZmllZCBDb250cmlidXRvciB0byB0aGUgZXh0ZW50IGNhdXNlZCBieSB0aGUKK2FjdHMgb3Igb21pc3Npb25zIG9mIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiBjb25uZWN0aW9uIHdpdGggaXRzCitkaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcuIFRoZQorb2JsaWdhdGlvbnMgaW4gdGhpcyBzZWN0aW9uIGRvIG5vdCBhcHBseSB0byBhbnkgY2xhaW1zIG9yIExvc3NlcworcmVsYXRpbmcgdG8gYW55IGFjdHVhbCBvciBhbGxlZ2VkIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBpbmZyaW5nZW1lbnQuIEluCitvcmRlciB0byBxdWFsaWZ5LCBhbiBJbmRlbW5pZmllZCBDb250cmlidXRvciBtdXN0OiBhKSBwcm9tcHRseSBub3RpZnkKK3RoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluIHdyaXRpbmcgb2Ygc3VjaCBjbGFpbSwgYW5kIGIpIGFsbG93IHRoZQorQ29tbWVyY2lhbCBDb250cmlidXRvciB0byBjb250cm9sLCBhbmQgY29vcGVyYXRlIHdpdGggdGhlIENvbW1lcmNpYWwKK0NvbnRyaWJ1dG9yIGluLCB0aGUgZGVmZW5zZSBhbmQgYW55IHJlbGF0ZWQgc2V0dGxlbWVudCBuZWdvdGlhdGlvbnMuIFRoZQorSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbWF5IHBhcnRpY2lwYXRlIGluIGFueSBzdWNoIGNsYWltIGF0IGl0cyBvd24KK2V4cGVuc2UuPC9wPgorCis8cD5Gb3IgZXhhbXBsZSwgYSBDb250cmlidXRvciBtaWdodCBpbmNsdWRlIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbAorcHJvZHVjdCBvZmZlcmluZywgUHJvZHVjdCBYLiBUaGF0IENvbnRyaWJ1dG9yIGlzIHRoZW4gYSBDb21tZXJjaWFsCitDb250cmlidXRvci4gSWYgdGhhdCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRoZW4gbWFrZXMgcGVyZm9ybWFuY2UKK2NsYWltcywgb3Igb2ZmZXJzIHdhcnJhbnRpZXMgcmVsYXRlZCB0byBQcm9kdWN0IFgsIHRob3NlIHBlcmZvcm1hbmNlCitjbGFpbXMgYW5kIHdhcnJhbnRpZXMgYXJlIHN1Y2ggQ29tbWVyY2lhbCBDb250cmlidXRvcidzIHJlc3BvbnNpYmlsaXR5CithbG9uZS4gVW5kZXIgdGhpcyBzZWN0aW9uLCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciB3b3VsZCBoYXZlIHRvCitkZWZlbmQgY2xhaW1zIGFnYWluc3QgdGhlIG90aGVyIENvbnRyaWJ1dG9ycyByZWxhdGVkIHRvIHRob3NlCitwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMsIGFuZCBpZiBhIGNvdXJ0IHJlcXVpcmVzIGFueSBvdGhlcgorQ29udHJpYnV0b3IgdG8gcGF5IGFueSBkYW1hZ2VzIGFzIGEgcmVzdWx0LCB0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvcgorbXVzdCBwYXkgdGhvc2UgZGFtYWdlcy48L3A+CisKKzxwPjxiPjUuIE5PIFdBUlJBTlRZPC9iPjwvcD4KKworPHA+RVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUyBBR1JFRU1FTlQsIFRIRSBQUk9HUkFNIElTCitQUk9WSURFRCBPTiBBTiAiQVMgSVMiIEJBU0lTLCBXSVRIT1VUIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUworT0YgQU5ZIEtJTkQsIEVJVEhFUiBFWFBSRVNTIE9SIElNUExJRUQgSU5DTFVESU5HLCBXSVRIT1VUIExJTUlUQVRJT04sCitBTlkgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIFRJVExFLCBOT04tSU5GUklOR0VNRU5ULCBNRVJDSEFOVEFCSUxJVFkKK09SIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBFYWNoIFJlY2lwaWVudCBpcyBzb2xlbHkKK3Jlc3BvbnNpYmxlIGZvciBkZXRlcm1pbmluZyB0aGUgYXBwcm9wcmlhdGVuZXNzIG9mIHVzaW5nIGFuZAorZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtIGFuZCBhc3N1bWVzIGFsbCByaXNrcyBhc3NvY2lhdGVkIHdpdGggaXRzCitleGVyY2lzZSBvZiByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgLCBpbmNsdWRpbmcgYnV0IG5vdCBsaW1pdGVkIHRvCit0aGUgcmlza3MgYW5kIGNvc3RzIG9mIHByb2dyYW0gZXJyb3JzLCBjb21wbGlhbmNlIHdpdGggYXBwbGljYWJsZSBsYXdzLAorZGFtYWdlIHRvIG9yIGxvc3Mgb2YgZGF0YSwgcHJvZ3JhbXMgb3IgZXF1aXBtZW50LCBhbmQgdW5hdmFpbGFiaWxpdHkgb3IKK2ludGVycnVwdGlvbiBvZiBvcGVyYXRpb25zLjwvcD4KKworPHA+PGI+Ni4gRElTQ0xBSU1FUiBPRiBMSUFCSUxJVFk8L2I+PC9wPgorCis8cD5FWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTIEFHUkVFTUVOVCwgTkVJVEhFUiBSRUNJUElFTlQKK05PUiBBTlkgQ09OVFJJQlVUT1JTIFNIQUxMIEhBVkUgQU5ZIExJQUJJTElUWSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsCitJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HCitXSVRIT1VUIExJTUlUQVRJT04gTE9TVCBQUk9GSVRTKSwgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YKK0xJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVCAoSU5DTFVESU5HCitORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9SCitESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gT1IgVEhFIEVYRVJDSVNFIE9GIEFOWSBSSUdIVFMgR1JBTlRFRAorSEVSRVVOREVSLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFUy48L3A+CisKKzxwPjxiPjcuIEdFTkVSQUw8L2I+PC9wPgorCis8cD5JZiBhbnkgcHJvdmlzaW9uIG9mIHRoaXMgQWdyZWVtZW50IGlzIGludmFsaWQgb3IgdW5lbmZvcmNlYWJsZSB1bmRlcgorYXBwbGljYWJsZSBsYXcsIGl0IHNoYWxsIG5vdCBhZmZlY3QgdGhlIHZhbGlkaXR5IG9yIGVuZm9yY2VhYmlsaXR5IG9mCit0aGUgcmVtYWluZGVyIG9mIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgYW5kIHdpdGhvdXQgZnVydGhlciBhY3Rpb24KK2J5IHRoZSBwYXJ0aWVzIGhlcmV0bywgc3VjaCBwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlIG1pbmltdW0KK2V4dGVudCBuZWNlc3NhcnkgdG8gbWFrZSBzdWNoIHByb3Zpc2lvbiB2YWxpZCBhbmQgZW5mb3JjZWFibGUuPC9wPgorCis8cD5JZiBSZWNpcGllbnQgaW5zdGl0dXRlcyBwYXRlbnQgbGl0aWdhdGlvbiBhZ2FpbnN0IGFueSBlbnRpdHkKKyhpbmNsdWRpbmcgYSBjcm9zcy1jbGFpbSBvciBjb3VudGVyY2xhaW0gaW4gYSBsYXdzdWl0KSBhbGxlZ2luZyB0aGF0IHRoZQorUHJvZ3JhbSBpdHNlbGYgKGV4Y2x1ZGluZyBjb21iaW5hdGlvbnMgb2YgdGhlIFByb2dyYW0gd2l0aCBvdGhlcgorc29mdHdhcmUgb3IgaGFyZHdhcmUpIGluZnJpbmdlcyBzdWNoIFJlY2lwaWVudCdzIHBhdGVudChzKSwgdGhlbiBzdWNoCitSZWNpcGllbnQncyByaWdodHMgZ3JhbnRlZCB1bmRlciBTZWN0aW9uIDIoYikgc2hhbGwgdGVybWluYXRlIGFzIG9mIHRoZQorZGF0ZSBzdWNoIGxpdGlnYXRpb24gaXMgZmlsZWQuPC9wPgorCis8cD5BbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHNoYWxsIHRlcm1pbmF0ZSBpZiBpdAorZmFpbHMgdG8gY29tcGx5IHdpdGggYW55IG9mIHRoZSBtYXRlcmlhbCB0ZXJtcyBvciBjb25kaXRpb25zIG9mIHRoaXMKK0FncmVlbWVudCBhbmQgZG9lcyBub3QgY3VyZSBzdWNoIGZhaWx1cmUgaW4gYSByZWFzb25hYmxlIHBlcmlvZCBvZiB0aW1lCithZnRlciBiZWNvbWluZyBhd2FyZSBvZiBzdWNoIG5vbmNvbXBsaWFuY2UuIElmIGFsbCBSZWNpcGllbnQncyByaWdodHMKK3VuZGVyIHRoaXMgQWdyZWVtZW50IHRlcm1pbmF0ZSwgUmVjaXBpZW50IGFncmVlcyB0byBjZWFzZSB1c2UgYW5kCitkaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gYXMgc29vbiBhcyByZWFzb25hYmx5IHByYWN0aWNhYmxlLiBIb3dldmVyLAorUmVjaXBpZW50J3Mgb2JsaWdhdGlvbnMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYW5kIGFueSBsaWNlbnNlcyBncmFudGVkIGJ5CitSZWNpcGllbnQgcmVsYXRpbmcgdG8gdGhlIFByb2dyYW0gc2hhbGwgY29udGludWUgYW5kIHN1cnZpdmUuPC9wPgorCis8cD5FdmVyeW9uZSBpcyBwZXJtaXR0ZWQgdG8gY29weSBhbmQgZGlzdHJpYnV0ZSBjb3BpZXMgb2YgdGhpcworQWdyZWVtZW50LCBidXQgaW4gb3JkZXIgdG8gYXZvaWQgaW5jb25zaXN0ZW5jeSB0aGUgQWdyZWVtZW50IGlzCitjb3B5cmlnaHRlZCBhbmQgbWF5IG9ubHkgYmUgbW9kaWZpZWQgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXIuIFRoZQorQWdyZWVtZW50IFN0ZXdhcmQgcmVzZXJ2ZXMgdGhlIHJpZ2h0IHRvIHB1Ymxpc2ggbmV3IHZlcnNpb25zIChpbmNsdWRpbmcKK3JldmlzaW9ucykgb2YgdGhpcyBBZ3JlZW1lbnQgZnJvbSB0aW1lIHRvIHRpbWUuIE5vIG9uZSBvdGhlciB0aGFuIHRoZQorQWdyZWVtZW50IFN0ZXdhcmQgaGFzIHRoZSByaWdodCB0byBtb2RpZnkgdGhpcyBBZ3JlZW1lbnQuIFRoZSBFY2xpcHNlCitGb3VuZGF0aW9uIGlzIHRoZSBpbml0aWFsIEFncmVlbWVudCBTdGV3YXJkLiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1heQorYXNzaWduIHRoZSByZXNwb25zaWJpbGl0eSB0byBzZXJ2ZSBhcyB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgdG8gYQorc3VpdGFibGUgc2VwYXJhdGUgZW50aXR5LiBFYWNoIG5ldyB2ZXJzaW9uIG9mIHRoZSBBZ3JlZW1lbnQgd2lsbCBiZQorZ2l2ZW4gYSBkaXN0aW5ndWlzaGluZyB2ZXJzaW9uIG51bWJlci4gVGhlIFByb2dyYW0gKGluY2x1ZGluZworQ29udHJpYnV0aW9ucykgbWF5IGFsd2F5cyBiZSBkaXN0cmlidXRlZCBzdWJqZWN0IHRvIHRoZSB2ZXJzaW9uIG9mIHRoZQorQWdyZWVtZW50IHVuZGVyIHdoaWNoIGl0IHdhcyByZWNlaXZlZC4gSW4gYWRkaXRpb24sIGFmdGVyIGEgbmV3IHZlcnNpb24KK29mIHRoZSBBZ3JlZW1lbnQgaXMgcHVibGlzaGVkLCBDb250cmlidXRvciBtYXkgZWxlY3QgdG8gZGlzdHJpYnV0ZSB0aGUKK1Byb2dyYW0gKGluY2x1ZGluZyBpdHMgQ29udHJpYnV0aW9ucykgdW5kZXIgdGhlIG5ldyB2ZXJzaW9uLiBFeGNlcHQgYXMKK2V4cHJlc3NseSBzdGF0ZWQgaW4gU2VjdGlvbnMgMihhKSBhbmQgMihiKSBhYm92ZSwgUmVjaXBpZW50IHJlY2VpdmVzIG5vCityaWdodHMgb3IgbGljZW5zZXMgdG8gdGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBvZiBhbnkgQ29udHJpYnV0b3IgdW5kZXIKK3RoaXMgQWdyZWVtZW50LCB3aGV0aGVyIGV4cHJlc3NseSwgYnkgaW1wbGljYXRpb24sIGVzdG9wcGVsIG9yCitvdGhlcndpc2UuIEFsbCByaWdodHMgaW4gdGhlIFByb2dyYW0gbm90IGV4cHJlc3NseSBncmFudGVkIHVuZGVyIHRoaXMKK0FncmVlbWVudCBhcmUgcmVzZXJ2ZWQuPC9wPgorCis8cD5UaGlzIEFncmVlbWVudCBpcyBnb3Zlcm5lZCBieSB0aGUgbGF3cyBvZiB0aGUgU3RhdGUgb2YgTmV3IFlvcmsgYW5kCit0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGxhd3Mgb2YgdGhlIFVuaXRlZCBTdGF0ZXMgb2YgQW1lcmljYS4gTm8gcGFydHkKK3RvIHRoaXMgQWdyZWVtZW50IHdpbGwgYnJpbmcgYSBsZWdhbCBhY3Rpb24gdW5kZXIgdGhpcyBBZ3JlZW1lbnQgbW9yZQordGhhbiBvbmUgeWVhciBhZnRlciB0aGUgY2F1c2Ugb2YgYWN0aW9uIGFyb3NlLiBFYWNoIHBhcnR5IHdhaXZlcyBpdHMKK3JpZ2h0cyB0byBhIGp1cnkgdHJpYWwgaW4gYW55IHJlc3VsdGluZyBsaXRpZ2F0aW9uLjwvcD4KKworCisKKzwvYm9keT48L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS51aS9mZWF0dXJlLnByb3BlcnRpZXMgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnVpL2ZlYXR1cmUucHJvcGVydGllcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43ZTg0YmJjCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS51aS9mZWF0dXJlLnByb3BlcnRpZXMKQEAgLTAsMCArMSwxNjkgQEAKKyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKKyMgQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkuCisjIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCisjIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisjIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisjCisjIENvbnRyaWJ1dG9yczoKKyMgICAgIENyaXN0aWFubyBHYXZp428gLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24KKyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKKyMgZmVhdHVyZS5wcm9wZXJ0aWVzCisjIGNvbnRhaW5zIGV4dGVybmFsaXplZCBzdHJpbmdzIGZvciBmZWF0dXJlLnhtbAorIyAiJWZvbyIgaW4gZmVhdHVyZS54bWwgY29ycmVzcG9uZHMgdG8gdGhlIGtleSAiZm9vIiBpbiB0aGlzIGZpbGUKKyMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKKyMgVGhpcyBmaWxlIHNob3VsZCBiZSB0cmFuc2xhdGVkLgorCisjICJmZWF0dXJlTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBmZWF0dXJlCitmZWF0dXJlTmFtZSA9VUkgZmVhdHVyZSBmb3IgT1NCUCBJREUgCisKKyMgInByb3ZpZGVyTmFtZSIgcHJvcGVydHkgLSBuYW1lIG9mIHRoZSBjb21wYW55IHRoYXQgcHJvdmlkZXMgdGhlIGZlYXR1cmUKK3Byb3ZpZGVyTmFtZT1FY2xpcHNlIE9TQlAKKworIyAiZGVzY3JpcHRpb24iIHByb3BlcnR5IC0gZGVzY3JpcHRpb24gb2YgdGhlIGZlYXR1cmUKK2Rlc2NyaXB0aW9uPUluc3RhbGxzIGFsbCBmZWF0dXJlcyByZXF1aXJlZCBmb3IgT1NCUCBpbnRvIHRoZSBJREUKKworIyAidXBkYXRlU2l0ZU5hbWUiIHByb3BlcnR5IC0gbGFiZWwgZm9yIHRoZSB1cGRhdGUgc2l0ZQordXBkYXRlU2l0ZU5hbWU9CisKKyMgImNvcHlyaWdodCIgcHJvcGVydHkgLSB0ZXh0IG9mIHRoZSAiRmVhdHVyZSBVcGRhdGUgQ29weXJpZ2h0IgorY29weXJpZ2h0PVwKK0NvcHlyaWdodCAoYykgMjAxMSwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpIFxuXAorQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFsc1xuXAorYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wXG5cCit3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdFxuXAoraHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWxcblwKK1xuXAorIyMjIyMjIyMjIyMjIyMjIyBlbmQgb2YgY29weXJpZ2h0IHByb3BlcnR5ICMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIworCisjICJsaWNlbnNlVVJMIiBwcm9wZXJ0eSAtIFVSTCBvZiB0aGUgIkZlYXR1cmUgTGljZW5zZSIKKyMgZG8gbm90IHRyYW5zbGF0ZSB2YWx1ZSAtIGp1c3QgY2hhbmdlIHRvIHBvaW50IHRvIGEgbG9jYWxlLXNwZWNpZmljIEhUTUwgcGFnZQorbGljZW5zZVVSTD1saWNlbnNlLmh0bWwKKworIyAibGljZW5zZSIgcHJvcGVydHkgLSB0ZXh0IG9mIHRoZSAiRmVhdHVyZSBVcGRhdGUgTGljZW5zZSIKKyMgc2hvdWxkIGJlIHBsYWluIHRleHQgdmVyc2lvbiBvZiBsaWNlbnNlIGFncmVlbWVudCBwb2ludGVkIHRvIGJlICJsaWNlbnNlVVJMIgorbGljZW5zZT1cCitFY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnRcblwKK0ZlYnJ1YXJ5IDEsIDIwMTFcblwKK1xuXAorVXNhZ2UgT2YgQ29udGVudFxuXAorXG5cCitUSEUgRUNMSVBTRSBGT1VOREFUSU9OIE1BS0VTIEFWQUlMQUJMRSBTT0ZUV0FSRSwgRE9DVU1FTlRBVElPTiwgSU5GT1JNQVRJT04gQU5EL09SXG5cCitPVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTIChDT0xMRUNUSVZFTFkgIkNPTlRFTlQiKS5cblwKK1VTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJU1xuXAorQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SXG5cCitOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgQlkgVVNJTkcgVEhFIENPTlRFTlQsIFlPVVxuXAorQUdSRUUgVEhBVCBZT1VSIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSElTIEFHUkVFTUVOVFxuXAorQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFNcblwKK09SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBJRiBZT1UgRE8gTk9UIEFHUkVFIFRPIFRIRVxuXAorVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OU1xuXAorT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRURcblwKK0JFTE9XLCBUSEVOIFlPVSBNQVkgTk9UIFVTRSBUSEUgQ09OVEVOVC5cblwKK1xuXAorQXBwbGljYWJsZSBMaWNlbnNlc1xuXAorXG5cCitVbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlXG5cCitFY2xpcHNlIEZvdW5kYXRpb24gaXMgcHJvdmlkZWQgdG8geW91IHVuZGVyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZlxuXAordGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKCJFUEwiKS4gQSBjb3B5IG9mIHRoZSBFUEwgaXNcblwKK3Byb3ZpZGVkIHdpdGggdGhpcyBDb250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbC5cblwKK0ZvciBwdXJwb3NlcyBvZiB0aGUgRVBMLCAiUHJvZ3JhbSIgd2lsbCBtZWFuIHRoZSBDb250ZW50LlxuXAorXG5cCitDb250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSxcblwKK2RvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBzb3VyY2UgY29kZVxuXAorcmVwb3NpdG9yeSAoIlJlcG9zaXRvcnkiKSBpbiBzb2Z0d2FyZSBtb2R1bGVzICgiTW9kdWxlcyIpIGFuZCBtYWRlIGF2YWlsYWJsZVxuXAorYXMgZG93bmxvYWRhYmxlIGFyY2hpdmVzICgiRG93bmxvYWRzIikuXG5cCitcblwKKyAgICAgICAtIENvbnRlbnQgbWF5IGJlIHN0cnVjdHVyZWQgYW5kIHBhY2thZ2VkIGludG8gbW9kdWxlcyB0byBmYWNpbGl0YXRlIGRlbGl2ZXJpbmcsXG5cCisgICAgICAgICBleHRlbmRpbmcsIGFuZCB1cGdyYWRpbmcgdGhlIENvbnRlbnQuIFR5cGljYWwgbW9kdWxlcyBtYXkgaW5jbHVkZSBwbHVnLWlucyAoIlBsdWctaW5zIiksXG5cCisgICAgICAgICBwbHVnLWluIGZyYWdtZW50cyAoIkZyYWdtZW50cyIpLCBhbmQgZmVhdHVyZXMgKCJGZWF0dXJlcyIpLlxuXAorICAgICAgIC0gRWFjaCBQbHVnLWluIG9yIEZyYWdtZW50IG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3Rvcnkgb3IgSkFSIChKYXZhKFRNKSBBUmNoaXZlKVxuXAorICAgICAgICAgaW4gYSBkaXJlY3RvcnkgbmFtZWQgInBsdWdpbnMiLlxuXAorICAgICAgIC0gQSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuXG5cCisgICAgICAgICBFYWNoIEZlYXR1cmUgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAiZmVhdHVyZXMiLlxuXAorICAgICAgICAgV2l0aGluIGEgRmVhdHVyZSwgZmlsZXMgbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uXG5cCisgICAgICAgICBudW1iZXJzIG9mIHRoZSBQbHVnLWlucyBhbmQvb3IgRnJhZ21lbnRzIGFzc29jaWF0ZWQgd2l0aCB0aGF0IEZlYXR1cmUuXG5cCisgICAgICAgLSBGZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgiSW5jbHVkZWQgRmVhdHVyZXMiKS4gV2l0aGluIGEgRmVhdHVyZSwgZmlsZXNcblwKKyAgICAgICAgIG5hbWVkICJmZWF0dXJlLnhtbCIgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIEluY2x1ZGVkIEZlYXR1cmVzLlxuXAorXG5cCitUaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlXG5cCitjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgImFib3V0Lmh0bWwiICgiQWJvdXRzIikuIFRoZSB0ZXJtcyBhbmRcblwKK2NvbmRpdGlvbnMgZ292ZXJuaW5nIEZlYXR1cmVzIGFuZCBJbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkXG5cCitpbiBmaWxlcyBuYW1lZCAibGljZW5zZS5odG1sIiAoIkZlYXR1cmUgTGljZW5zZXMiKS4gQWJvdXRzIGFuZCBGZWF0dXJlXG5cCitMaWNlbnNlcyBtYXkgYmUgbG9jYXRlZCBpbiBhbnkgZGlyZWN0b3J5IG9mIGEgRG93bmxvYWQgb3IgTW9kdWxlXG5cCitpbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIGxvY2F0aW9uczpcblwKK1xuXAorICAgICAgIC0gVGhlIHRvcC1sZXZlbCAocm9vdCkgZGlyZWN0b3J5XG5cCisgICAgICAgLSBQbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3Rvcmllc1xuXAorICAgICAgIC0gSW5zaWRlIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgcGFja2FnZWQgYXMgSkFSc1xuXAorICAgICAgIC0gU3ViLWRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgInNyYyIgb2YgY2VydGFpbiBQbHVnLWluc1xuXAorICAgICAgIC0gRmVhdHVyZSBkaXJlY3Rvcmllc1xuXAorXG5cCitOb3RlOiBpZiBhIEZlYXR1cmUgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBpbnN0YWxsZWQgdXNpbmcgdGhlXG5cCitQcm92aXNpb25pbmcgVGVjaG5vbG9neSAoYXMgZGVmaW5lZCBiZWxvdyksIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoIkZlYXR1cmUgXG5cCitVcGRhdGUgTGljZW5zZSIpIGR1cmluZyB0aGUgaW5zdGFsbGF0aW9uIHByb2Nlc3MuIElmIHRoZSBGZWF0dXJlIGNvbnRhaW5zXG5cCitJbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdVxuXAord2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvciBpbmZvcm1cblwKK3lvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW5cblwKK3RoZSAibGljZW5zZSIgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgImZlYXR1cmUucHJvcGVydGllcyIgZm91bmQgd2l0aGluIGEgRmVhdHVyZS5cblwKK1N1Y2ggQWJvdXRzLCBGZWF0dXJlIExpY2Vuc2VzLCBhbmQgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgY29udGFpbiB0aGVcblwKK3Rlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXRcblwKK2dvdmVybiB5b3VyIHVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluIHRoYXQgZGlyZWN0b3J5LlxuXAorXG5cCitUSEUgQUJPVVRTLCBGRUFUVVJFIExJQ0VOU0VTLCBBTkQgRkVBVFVSRSBVUERBVEUgTElDRU5TRVMgTUFZIFJFRkVSXG5cCitUTyBUSEUgRVBMIE9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy5cblwKK1NPTUUgT0YgVEhFU0UgT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTpcblwKK1xuXAorICAgICAgIC0gRWNsaXBzZSBEaXN0cmlidXRpb24gTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGljZW5zZXMvZWRsLXYxLjAuaHRtbClcblwKKyAgICAgICAtIENvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sKVxuXAorICAgICAgIC0gQXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UpXG5cCisgICAgICAgLSBBcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjApXG5cCisgICAgICAgLSBNZXRybyBMaW5rIFB1YmxpYyBMaWNlbnNlIDEuMDAgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbClcblwKKyAgICAgICAtIE1vemlsbGEgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjEgKGF2YWlsYWJsZSBhdCBodHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWwpXG5cCitcblwKK0lUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1JcblwKK1RPIFVTRSBPRiBUSEUgQ09OVEVOVC4gSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSwgb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZVxuXAoraXMgcHJvdmlkZWQsIHBsZWFzZSBjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIGNvbmRpdGlvbnNcblwKK2dvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC5cblwKK1xuXAorXG5cVXNlIG9mIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5XG5cCitcblwKK1RoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIHByb3Zpc2lvbmluZyBzb2Z0d2FyZSwgZXhhbXBsZXMgb2Ygd2hpY2ggaW5jbHVkZSxcblwKK2J1dCBhcmUgbm90IGxpbWl0ZWQgdG8sIHAyIGFuZCB0aGUgRWNsaXBzZSBVcGRhdGUgTWFuYWdlciAoIlByb3Zpc2lvbmluZyBUZWNobm9sb2d5IikgZm9yXG5cCit0aGUgcHVycG9zZSBvZiBhbGxvd2luZyB1c2VycyB0byBpbnN0YWxsIHNvZnR3YXJlLCBkb2N1bWVudGF0aW9uLCBpbmZvcm1hdGlvbiBhbmQvb3JcblwKK290aGVyIG1hdGVyaWFscyAoY29sbGVjdGl2ZWx5ICJJbnN0YWxsYWJsZSBTb2Z0d2FyZSIpLiBUaGlzIGNhcGFiaWxpdHkgaXMgcHJvdmlkZWQgd2l0aFxuXAordGhlIGludGVudCBvZiBhbGxvd2luZyBzdWNoIHVzZXJzIHRvIGluc3RhbGwsIGV4dGVuZCBhbmQgdXBkYXRlIEVjbGlwc2UtYmFzZWQgcHJvZHVjdHMuXG5cCitJbmZvcm1hdGlvbiBhYm91dCBwYWNrYWdpbmcgSW5zdGFsbGFibGUgU29mdHdhcmUgaXMgYXZhaWxhYmxlIGF0XG5cCitodHRwOi8vZWNsaXBzZS5vcmcvZXF1aW5veC9wMi9yZXBvc2l0b3J5X3BhY2thZ2luZy5odG1sICgiU3BlY2lmaWNhdGlvbiIpLlxuXAorXG5cCitZb3UgbWF5IHVzZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSB0byBhbGxvdyBvdGhlciBwYXJ0aWVzIHRvIGluc3RhbGwgSW5zdGFsbGFibGUgU29mdHdhcmUuXG5cCitZb3Ugc2hhbGwgYmUgcmVzcG9uc2libGUgZm9yIGVuYWJsaW5nIHRoZSBhcHBsaWNhYmxlIGxpY2Vuc2UgYWdyZWVtZW50cyByZWxhdGluZyB0byB0aGVcblwKK0luc3RhbGxhYmxlIFNvZnR3YXJlIHRvIGJlIHByZXNlbnRlZCB0bywgYW5kIGFjY2VwdGVkIGJ5LCB0aGUgdXNlcnMgb2YgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5XG5cCitpbiBhY2NvcmRhbmNlIHdpdGggdGhlIFNwZWNpZmljYXRpb24uIEJ5IHVzaW5nIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IGluIHN1Y2ggYSBtYW5uZXIgYW5kXG5cCittYWtpbmcgaXQgYXZhaWxhYmxlIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgU3BlY2lmaWNhdGlvbiwgeW91IGZ1cnRoZXIgYWNrbm93bGVkZ2UgeW91clxuXAorYWdyZWVtZW50IHRvLCBhbmQgdGhlIGFjcXVpc2l0aW9uIG9mIGFsbCBuZWNlc3NhcnkgcmlnaHRzIHRvIHBlcm1pdCB0aGUgZm9sbG93aW5nOlxuXAorXG5cCisgICAgICAgMS4gQSBzZXJpZXMgb2YgYWN0aW9ucyBtYXkgb2NjdXIgKCJQcm92aXNpb25pbmcgUHJvY2VzcyIpIGluIHdoaWNoIGEgdXNlciBtYXkgZXhlY3V0ZVxuXAorICAgICAgICAgIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSBvbiBhIG1hY2hpbmUgKCJUYXJnZXQgTWFjaGluZSIpIHdpdGggdGhlIGludGVudCBvZiBpbnN0YWxsaW5nLFxuXAorICAgICAgICAgIGV4dGVuZGluZyBvciB1cGRhdGluZyB0aGUgZnVuY3Rpb25hbGl0eSBvZiBhbiBFY2xpcHNlLWJhc2VkIHByb2R1Y3QuXG5cCisgICAgICAgMi4gRHVyaW5nIHRoZSBQcm92aXNpb25pbmcgUHJvY2VzcywgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IG1heSBjYXVzZSB0aGlyZCBwYXJ0eVxuXAorICAgICAgICAgIEluc3RhbGxhYmxlIFNvZnR3YXJlIG9yIGEgcG9ydGlvbiB0aGVyZW9mIHRvIGJlIGFjY2Vzc2VkIGFuZCBjb3BpZWQgdG8gdGhlIFRhcmdldCBNYWNoaW5lLlxuXAorICAgICAgIDMuIFB1cnN1YW50IHRvIHRoZSBTcGVjaWZpY2F0aW9uLCB5b3Ugd2lsbCBwcm92aWRlIHRvIHRoZSB1c2VyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyB0aGF0XG5cCisgICAgICAgICAgZ292ZXJuIHRoZSB1c2Ugb2YgdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlICgiSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50IikgYW5kIHN1Y2hcblwKKyAgICAgICAgICBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQgc2hhbGwgYmUgYWNjZXNzZWQgZnJvbSB0aGUgVGFyZ2V0IE1hY2hpbmUgaW4gYWNjb3JkYW5jZVxuXAorICAgICAgICAgIHdpdGggdGhlIFNwZWNpZmljYXRpb24uIFN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50IG11c3QgaW5mb3JtIHRoZSB1c2VyIG9mIHRoZVxuXAorICAgICAgICAgIHRlcm1zIGFuZCBjb25kaXRpb25zIHRoYXQgZ292ZXJuIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBhbmQgbXVzdCBzb2xpY2l0IGFjY2VwdGFuY2UgYnlcblwKKyAgICAgICAgICB0aGUgZW5kIHVzZXIgaW4gdGhlIG1hbm5lciBwcmVzY3JpYmVkIGluIHN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50LiBVcG9uIHN1Y2hcblwKKyAgICAgICAgICBpbmRpY2F0aW9uIG9mIGFncmVlbWVudCBieSB0aGUgdXNlciwgdGhlIHByb3Zpc2lvbmluZyBUZWNobm9sb2d5IHdpbGwgY29tcGxldGUgaW5zdGFsbGF0aW9uXG5cCisgICAgICAgICAgb2YgdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlLlxuXAorXG5cCitDcnlwdG9ncmFwaHlcblwKK1xuXAorQ29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlXG5cCitjdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsXG5cCithbmQvb3IgcmUtZXhwb3J0IHRvIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFXG5cCit1c2luZyBhbnkgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgcGxlYXNlIGNoZWNrIHRoZSBjb3VudHJ5J3MgbGF3cyxcblwKK3JlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIG9yIHVzZSwgYW5kXG5cCityZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLlxuXAorXG5cCitKYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIE9yYWNsZSBDb3Jwb3JhdGlvbiBpbiB0aGUgVW5pdGVkIFN0YXRlcywgb3RoZXIgY291bnRyaWVzLCBvciBib3RoLlxuCisjIyMjIyMjIyMjIyBlbmQgb2YgbGljZW5zZSBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudWkvZmVhdHVyZS54bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnVpL2ZlYXR1cmUueG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmI3NDMyMDAKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnVpL2ZlYXR1cmUueG1sCkBAIC0wLDAgKzEsNDkgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorPCEtLSMgQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkgLS0+Cis8IS0tIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIC0tPgorPCEtLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIC0tPgorPCEtLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgLS0+Cis8IS0tIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAtLT4KKzwhLS0jIC0tPgorPCEtLSMgQ29udHJpYnV0b3JzOiAtLT4KKzwhLS0jICAgICBDaHJpc3RvcGhlIExvZXR6IChMb2V0eiBHbWJIJkNvLktHKSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiAtLT4KKzwhLS0jPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gLS0+CisKKzxmZWF0dXJlCisgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnVpIgorICAgICAgICBsYWJlbD0iJWZlYXR1cmVOYW1lIgorICAgICAgICB2ZXJzaW9uPSIwLjkuMC5xdWFsaWZpZXIiCisgICAgICAgIHByb3ZpZGVyLW5hbWU9IiVwcm92aWRlck5hbWUiPgorICAgICAgICAKKyAgICA8ZGVzY3JpcHRpb24+CisgICAgICAgICVkZXNjcmlwdGlvbgorICAgIDwvZGVzY3JpcHRpb24+CisgICAgICAgIAorICAgIDxjb3B5cmlnaHQ+CisgICAgICAgICVjb3B5cmlnaHQKKyAgICA8L2NvcHlyaWdodD4KKyAgICAgICAgCisgICAgPGxpY2Vuc2UgdXJsPSIlbGljZW5zZVVSTCI+CisgICAgICAgICVsaWNlbnNlCisgICAgPC9saWNlbnNlPgorICAgICAgICAKKyAgICA8cmVxdWlyZXM+CisgICAgICAgIDxpbXBvcnQgZmVhdHVyZT0ib3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS5oZWFkbGVzcyIgdmVyc2lvbj0iMC45LjAiLz4KKyAgICA8L3JlcXVpcmVzPgorICAgICAgICAKKyAgICA8cGx1Z2luCisgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpIgorICAgICAgICBkb3dubG9hZC1zaXplPSIwIgorICAgICAgICBpbnN0YWxsLXNpemU9IjAiCisgICAgICAgIHZlcnNpb249IjAuMC4wIgorICAgICAgICB1bnBhY2s9ImZhbHNlIi8+CisgICAgICAgIAorICAgIDxwbHVnaW4KKyAgICAgICAgaWQ9Im9yZy5lY2xpcHNlLm9zYnAuaWRlLmNvcmUudWkuc2hhcmVkIgorICAgICAgICBkb3dubG9hZC1zaXplPSIwIgorICAgICAgICBpbnN0YWxsLXNpemU9IjAiCisgICAgICAgIHZlcnNpb249IjAuMC4wIgorICAgICAgICB1bnBhY2s9ImZhbHNlIi8+CisgICAgICAgIAorPC9mZWF0dXJlPgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS51aS9saWNlbnNlLmh0bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLnVpL2xpY2Vuc2UuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ZTU3OWE1Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS51aS9saWNlbnNlLmh0bWwKQEAgLTAsMCArMSwxNjQgQEAKKzwhLS0/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IklTTy04ODU5LTEiID8tLT4KKzwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFN0cmljdC8vRU4iICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS1zdHJpY3QuZHRkIj4KKzxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIj48aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiPgorPHRpdGxlPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvdGl0bGU+Cis8L2hlYWQ+CisKKzxib2R5IGxhbmc9IkVOLVVTIj4KKzxoMj5FY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L2gyPgorPHA+RmVicnVhcnkgMSwgMjAxMTwvcD4KKworPGgzPlVzYWdlIE9mIENvbnRlbnQ8L2gzPgorCis8cD5USEUgRUNMSVBTRSBGT1VOREFUSU9OIE1BS0VTIEFWQUlMQUJMRSBTT0ZUV0FSRSwgRE9DVU1FTlRBVElPTiwgSU5GT1JNQVRJT04gQU5EL09SIE9USEVSIE1BVEVSSUFMUyBGT1IgT1BFTiBTT1VSQ0UgUFJPSkVDVFMKKyAgIChDT0xMRUNUSVZFTFkgIkNPTlRFTlQiKS4gIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQKKyAgIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VIEFHUkVFIFRIQVQgWU9VUiBVU0UKKyAgIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SCisgICBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQKKyAgIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULjwvcD4KKworPGgzPkFwcGxpY2FibGUgTGljZW5zZXM8L2gzPgorCis8cD5Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UKKyBGb3VuZGF0aW9uIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIAorRWNsaXBzZSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMAorICAgKCJFUEwiKS4gIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpcyBDb250ZW50IGFuZCBpcyBhbHNvCisgYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT4uCisgICBGb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgIlByb2dyYW0iIHdpbGwgbWVhbiB0aGUgQ29udGVudC48L3A+CisKKzxwPkNvbnRlbnQgaW5jbHVkZXMsIGJ1dCBpcyBub3QgbGltaXRlZCB0bywgc291cmNlIGNvZGUsIG9iamVjdCBjb2RlLCAKK2RvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiAKK3NvdXJjZSBjb2RlCisgICByZXBvc2l0b3J5ICgiUmVwb3NpdG9yeSIpIGluIHNvZnR3YXJlIG1vZHVsZXMgKCJNb2R1bGVzIikgYW5kIG1hZGUgCithdmFpbGFibGUgYXMgZG93bmxvYWRhYmxlIGFyY2hpdmVzICgiRG93bmxvYWRzIikuPC9wPgorCis8dWw+CisgICAgICAgPGxpPkNvbnRlbnQgbWF5IGJlIHN0cnVjdHVyZWQgYW5kIHBhY2thZ2VkIGludG8gbW9kdWxlcyB0byAKK2ZhY2lsaXRhdGUgZGVsaXZlcmluZywgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiAgVHlwaWNhbCAKK21vZHVsZXMgbWF5IGluY2x1ZGUgcGx1Zy1pbnMgKCJQbHVnLWlucyIpLCBwbHVnLWluIGZyYWdtZW50cyAKKygiRnJhZ21lbnRzIiksIGFuZCBmZWF0dXJlcyAoIkZlYXR1cmVzIikuPC9saT4KKyAgICAgICA8bGk+RWFjaCBQbHVnLWluIG9yIEZyYWdtZW50IG1heSBiZSBwYWNrYWdlZCBhcyBhIHN1Yi1kaXJlY3Rvcnkgb3IgSkFSIChKYXZhJiM4NDgyOyBBUmNoaXZlKSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAicGx1Z2lucyIuPC9saT4KKyAgICAgICA8bGk+QSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciAKK0ZyYWdtZW50cyBhbmQgYXNzb2NpYXRlZCBtYXRlcmlhbC4gIEVhY2ggRmVhdHVyZSBtYXkgYmUgcGFja2FnZWQgYXMgYSAKK3N1Yi1kaXJlY3RvcnkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgImZlYXR1cmVzIi4gIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIAorbmFtZWQgImZlYXR1cmUueG1sIiBtYXkgY29udGFpbiBhIGxpc3Qgb2YgdGhlIG5hbWVzIGFuZCB2ZXJzaW9uIG51bWJlcnMgCitvZiB0aGUgUGx1Zy1pbnMKKyAgICAgIGFuZC9vciBGcmFnbWVudHMgYXNzb2NpYXRlZCB3aXRoIHRoYXQgRmVhdHVyZS48L2xpPgorICAgICAgIDxsaT5GZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgiSW5jbHVkZWQgCitGZWF0dXJlcyIpLiBXaXRoaW4gYSBGZWF0dXJlLCBmaWxlcyBuYW1lZCAiZmVhdHVyZS54bWwiIG1heSBjb250YWluIGEgCitsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIEluY2x1ZGVkIEZlYXR1cmVzLjwvbGk+Cis8L3VsPgorCis8cD5UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlIAorY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICJhYm91dC5odG1sIiAoIkFib3V0cyIpLiBUaGUgdGVybXMgYW5kIAorY29uZGl0aW9ucyBnb3Zlcm5pbmcgRmVhdHVyZXMgYW5kCitJbmNsdWRlZCBGZWF0dXJlcyBzaG91bGQgYmUgY29udGFpbmVkIGluIGZpbGVzIG5hbWVkICJsaWNlbnNlLmh0bWwiIAorKCJGZWF0dXJlIExpY2Vuc2VzIikuICBBYm91dHMgYW5kIEZlYXR1cmUgTGljZW5zZXMgbWF5IGJlIGxvY2F0ZWQgaW4gYW55CisgZGlyZWN0b3J5IG9mIGEgRG93bmxvYWQgb3IgTW9kdWxlCitpbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIGxvY2F0aW9uczo8L3A+CisKKzx1bD4KKyAgICAgICA8bGk+VGhlIHRvcC1sZXZlbCAocm9vdCkgZGlyZWN0b3J5PC9saT4KKyAgICAgICA8bGk+UGx1Zy1pbiBhbmQgRnJhZ21lbnQgZGlyZWN0b3JpZXM8L2xpPgorICAgICAgIDxsaT5JbnNpZGUgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBwYWNrYWdlZCBhcyBKQVJzPC9saT4KKyAgICAgICA8bGk+U3ViLWRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgInNyYyIgb2YgY2VydGFpbiBQbHVnLWluczwvbGk+CisgICAgICAgPGxpPkZlYXR1cmUgZGlyZWN0b3JpZXM8L2xpPgorPC91bD4KKworPHA+Tm90ZTogaWYgYSBGZWF0dXJlIG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgCitpbnN0YWxsZWQgdXNpbmcgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IChhcyBkZWZpbmVkIGJlbG93KSwgeW91IG11c3QKKyBhZ3JlZSB0byBhIGxpY2Vuc2UgKCJGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIikgZHVyaW5nIHRoZQoraW5zdGFsbGF0aW9uIHByb2Nlc3MuICBJZiB0aGUgRmVhdHVyZSBjb250YWlucyBJbmNsdWRlZCBGZWF0dXJlcywgdGhlIAorRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBzaG91bGQgZWl0aGVyIHByb3ZpZGUgeW91IHdpdGggdGhlIHRlcm1zIGFuZCAKK2NvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvcgoraW5mb3JtIHlvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiAgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgbWF5IGJlIAorZm91bmQgaW4gdGhlICJsaWNlbnNlIiBwcm9wZXJ0eSBvZiBmaWxlcyBuYW1lZCAiZmVhdHVyZS5wcm9wZXJ0aWVzIiAKK2ZvdW5kIHdpdGhpbiBhIEZlYXR1cmUuCitTdWNoIEFib3V0cywgRmVhdHVyZSBMaWNlbnNlcywgYW5kIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIAordGVybXMgYW5kIGNvbmRpdGlvbnMgKG9yIHJlZmVyZW5jZXMgdG8gc3VjaCB0ZXJtcyBhbmQgY29uZGl0aW9ucykgdGhhdCAKK2dvdmVybiB5b3VyIHVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluCit0aGF0IGRpcmVjdG9yeS48L3A+CisKKzxwPlRIRSBBQk9VVFMsIEZFQVRVUkUgTElDRU5TRVMsIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVIgCitUTyBUSEUgRVBMIE9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy4KKyAgU09NRSBPRiBUSEVTRQorT1RIRVIgTElDRU5TRSBBR1JFRU1FTlRTIE1BWSBJTkNMVURFIChCVVQgQVJFIE5PVCBMSU1JVEVEIFRPKTo8L3A+CisKKzx1bD4KKyAgICAgICA8bGk+RWNsaXBzZSBEaXN0cmlidXRpb24gTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGljZW5zZXMvZWRsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xpY2Vuc2VzL2VkbC12MS4wLmh0bWw8L2E+KTwvbGk+CisgICAgICAgPGxpPkNvbW1vbiBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbDwvYT4pPC9saT4KKyAgICAgICA8bGk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFPC9hPik8L2xpPgorICAgICAgIDxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAyLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjAiPmh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMDwvYT4pPC9saT4KKyAgICAgICA8bGk+TWV0cm8gTGluayBQdWJsaWMgTGljZW5zZSAxLjAwIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWwiPmh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sPC9hPik8L2xpPgorICAgICAgIDxsaT5Nb3ppbGxhIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4xIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sIj5odHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWw8L2E+KTwvbGk+Cis8L3VsPgorCis8cD5JVCBJUyBZT1VSIE9CTElHQVRJT04gVE8gUkVBRCBBTkQgQUNDRVBUIEFMTCBTVUNIIFRFUk1TIEFORCAKK0NPTkRJVElPTlMgUFJJT1IgVE8gVVNFIE9GIFRIRSBDT05URU5ULiAgSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSwgCitvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIGlzIHByb3ZpZGVkLCBwbGVhc2UKK2NvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9ucyAKK2dvdmVybiB0aGF0IHBhcnRpY3VsYXIgQ29udGVudC48L3A+CisKKworPGgzPlVzZSBvZiBQcm92aXNpb25pbmcgVGVjaG5vbG9neTwvaDM+CisKKzxwPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIHByb3Zpc2lvbmluZyBzb2Z0d2FyZSwgCitleGFtcGxlcyBvZiB3aGljaCBpbmNsdWRlLCBidXQgYXJlIG5vdCBsaW1pdGVkIHRvLCBwMiBhbmQgdGhlIEVjbGlwc2UKKyAgIFVwZGF0ZSBNYW5hZ2VyICgiUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kiKSBmb3IgdGhlIHB1cnBvc2Ugb2YgCithbGxvd2luZyB1c2VycyB0byBpbnN0YWxsIHNvZnR3YXJlLCBkb2N1bWVudGF0aW9uLCBpbmZvcm1hdGlvbiBhbmQvb3IKKyAgIG90aGVyIG1hdGVyaWFscyAoY29sbGVjdGl2ZWx5ICJJbnN0YWxsYWJsZSBTb2Z0d2FyZSIpLiBUaGlzIAorY2FwYWJpbGl0eSBpcyBwcm92aWRlZCB3aXRoIHRoZSBpbnRlbnQgb2YgYWxsb3dpbmcgc3VjaCB1c2VycyB0bworICAgaW5zdGFsbCwgZXh0ZW5kIGFuZCB1cGRhdGUgRWNsaXBzZS1iYXNlZCBwcm9kdWN0cy4gSW5mb3JtYXRpb24gYWJvdXQgCitwYWNrYWdpbmcgSW5zdGFsbGFibGUgU29mdHdhcmUgaXMgYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly9lY2xpcHNlLm9yZy9lcXVpbm94L3AyL3JlcG9zaXRvcnlfcGFja2FnaW5nLmh0bWwiPmh0dHA6Ly9lY2xpcHNlLm9yZy9lcXVpbm94L3AyL3JlcG9zaXRvcnlfcGFja2FnaW5nLmh0bWw8L2E+CisgICAoIlNwZWNpZmljYXRpb24iKS48L3A+CisKKzxwPllvdSBtYXkgdXNlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IHRvIGFsbG93IG90aGVyIHBhcnRpZXMgdG8gaW5zdGFsbAorIEluc3RhbGxhYmxlIFNvZnR3YXJlLiBZb3Ugc2hhbGwgYmUgcmVzcG9uc2libGUgZm9yIGVuYWJsaW5nIHRoZQorICAgYXBwbGljYWJsZSBsaWNlbnNlIGFncmVlbWVudHMgcmVsYXRpbmcgdG8gdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlIHRvCisgYmUgcHJlc2VudGVkIHRvLCBhbmQgYWNjZXB0ZWQgYnksIHRoZSB1c2VycyBvZiB0aGUgUHJvdmlzaW9uaW5nIAorVGVjaG5vbG9neQorICAgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBTcGVjaWZpY2F0aW9uLiBCeSB1c2luZyBQcm92aXNpb25pbmcgCitUZWNobm9sb2d5IGluIHN1Y2ggYSBtYW5uZXIgYW5kIG1ha2luZyBpdCBhdmFpbGFibGUgaW4gYWNjb3JkYW5jZSB3aXRoIAordGhlCisgICBTcGVjaWZpY2F0aW9uLCB5b3UgZnVydGhlciBhY2tub3dsZWRnZSB5b3VyIGFncmVlbWVudCB0bywgYW5kIHRoZSAKK2FjcXVpc2l0aW9uIG9mIGFsbCBuZWNlc3NhcnkgcmlnaHRzIHRvIHBlcm1pdCB0aGUgZm9sbG93aW5nOjwvcD4KKworPG9sPgorICAgICAgIDxsaT5BIHNlcmllcyBvZiBhY3Rpb25zIG1heSBvY2N1ciAoIlByb3Zpc2lvbmluZyBQcm9jZXNzIikgaW4gCit3aGljaCBhIHVzZXIgbWF5IGV4ZWN1dGUgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5CisgICAgICAgb24gYSBtYWNoaW5lICgiVGFyZ2V0IE1hY2hpbmUiKSB3aXRoIHRoZSBpbnRlbnQgb2YgaW5zdGFsbGluZywgCitleHRlbmRpbmcgb3IgdXBkYXRpbmcgdGhlIGZ1bmN0aW9uYWxpdHkgb2YgYW4gRWNsaXBzZS1iYXNlZAorICAgICAgIHByb2R1Y3QuPC9saT4KKyAgICAgICA8bGk+RHVyaW5nIHRoZSBQcm92aXNpb25pbmcgUHJvY2VzcywgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IAorbWF5IGNhdXNlIHRoaXJkIHBhcnR5IEluc3RhbGxhYmxlIFNvZnR3YXJlIG9yIGEgcG9ydGlvbiB0aGVyZW9mIHRvIGJlCisgICAgICAgYWNjZXNzZWQgYW5kIGNvcGllZCB0byB0aGUgVGFyZ2V0IE1hY2hpbmUuPC9saT4KKyAgICAgICA8bGk+UHVyc3VhbnQgdG8gdGhlIFNwZWNpZmljYXRpb24sIHlvdSB3aWxsIHByb3ZpZGUgdG8gdGhlIHVzZXIgCit0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgdGhhdCBnb3Zlcm4gdGhlIHVzZSBvZiB0aGUgSW5zdGFsbGFibGUKKyAgICAgICBTb2Z0d2FyZSAoIkluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCIpIGFuZCBzdWNoIEluc3RhbGxhYmxlIAorU29mdHdhcmUgQWdyZWVtZW50IHNoYWxsIGJlIGFjY2Vzc2VkIGZyb20gdGhlIFRhcmdldAorICAgICAgIE1hY2hpbmUgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBTcGVjaWZpY2F0aW9uLiBTdWNoIEluc3RhbGxhYmxlIAorU29mdHdhcmUgQWdyZWVtZW50IG11c3QgaW5mb3JtIHRoZSB1c2VyIG9mIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyB0aGF0CisgZ292ZXJuCisgICAgICAgdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlIGFuZCBtdXN0IHNvbGljaXQgYWNjZXB0YW5jZSBieSB0aGUgZW5kIAordXNlciBpbiB0aGUgbWFubmVyIHByZXNjcmliZWQgaW4gc3VjaCBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQuIAorVXBvbiBzdWNoCisgICAgICAgaW5kaWNhdGlvbiBvZiBhZ3JlZW1lbnQgYnkgdGhlIHVzZXIsIHRoZSBwcm92aXNpb25pbmcgVGVjaG5vbG9neSAKK3dpbGwgY29tcGxldGUgaW5zdGFsbGF0aW9uIG9mIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZS48L2xpPgorPC9vbD4KKworPGgzPkNyeXB0b2dyYXBoeTwvaDM+CisKKzxwPkNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZQorIGN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSwgCithbmQvb3IgcmUtZXhwb3J0IHRvCisgICBhbm90aGVyIGNvdW50cnksIG9mIGVuY3J5cHRpb24gc29mdHdhcmUuIEJFRk9SRSB1c2luZyBhbnkgZW5jcnlwdGlvbiAKK3NvZnR3YXJlLCBwbGVhc2UgY2hlY2sgdGhlIGNvdW50cnkncyBsYXdzLCByZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgCitjb25jZXJuaW5nIHRoZSBpbXBvcnQsCisgICBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIAordGhpcyBpcyBwZXJtaXR0ZWQuPC9wPgorCis8cD48c21hbGw+SmF2YSBhbmQgYWxsIEphdmEtYmFzZWQgdHJhZGVtYXJrcyBhcmUgdHJhZGVtYXJrcyBvZiBPcmFjbGUgQ29ycG9yYXRpb24gaW4gdGhlIFVuaXRlZCBTdGF0ZXMsIG90aGVyIGNvdW50cmllcywgb3IgYm90aC48L3NtYWxsPjwvcD4KKworCis8L2JvZHk+PC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudWkvcG9tLnhtbCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudWkvcG9tLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lYmFkZWUxCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS51aS9wb20ueG1sCkBAIC0wLDAgKzEsODMgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorPCEtLSMgQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpIC0tPgorPCEtLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAtLT4KKzwhLS0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAtLT4KKzwhLS0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IC0tPgorPCEtLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgLS0+Cis8IS0tIyAtLT4KKzwhLS0jIENvbnRyaWJ1dG9yczogLS0+Cis8IS0tIyAgICAgS2xlbWVucyBFZGxlciAoTHVuaWZlcmEgR21iSCkgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24gLS0+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorPHByb2plY3QgeG1sbnM9Imh0dHA6Ly9tYXZlbi5hcGFjaGUub3JnL1BPTS80LjAuMCIgeG1sbnM6eHNpPSJodHRwOi8vd3d3LnczLm9yZy8yMDAxL1hNTFNjaGVtYS1pbnN0YW5jZSIgeHNpOnNjaGVtYUxvY2F0aW9uPSJodHRwOi8vbWF2ZW4uYXBhY2hlLm9yZy9QT00vNC4wLjAgaHR0cDovL21hdmVuLmFwYWNoZS5vcmcvbWF2ZW4tdjRfMF8wLnhzZCI+CisgICAgPG1vZGVsVmVyc2lvbj40LjAuMDwvbW9kZWxWZXJzaW9uPgorCisgICAgPHBhcmVudD4KKyAgICAgICAgPGdyb3VwSWQ+b3JnLmVjbGlwc2Uub3NicC5pZGU8L2dyb3VwSWQ+CisgICAgICAgIDxhcnRpZmFjdElkPm9yZy5lY2xpcHNlLm9zYnAuaWRlPC9hcnRpZmFjdElkPgorICAgICAgICA8dmVyc2lvbj4wLjkuMC1TTkFQU0hPVDwvdmVyc2lvbj4KKyAgICA8L3BhcmVudD4KKworICAgIDxhcnRpZmFjdElkPm9yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudWk8L2FydGlmYWN0SWQ+CisgICAgPHBhY2thZ2luZz5lY2xpcHNlLWZlYXR1cmU8L3BhY2thZ2luZz4KKworICAgIDxkZXBlbmRlbmNpZXM+CisgICAgCisgICAgPC9kZXBlbmRlbmNpZXM+CisKKyAgICA8YnVpbGQ+CisgICAgICAgIDxwbHVnaW5zPgorICAgICAgICAgICAgPHBsdWdpbj4KKyAgICAgICAgICAgICAgICA8Z3JvdXBJZD5vcmcuZWNsaXBzZS50eWNoby5leHRyYXM8L2dyb3VwSWQ+CisgICAgICAgICAgICAgICAgPGFydGlmYWN0SWQ+dHljaG8tc291cmNlLWZlYXR1cmUtcGx1Z2luPC9hcnRpZmFjdElkPgorICAgICAgICAgICAgICAgIDx2ZXJzaW9uPiR7dHljaG8tdmVyc2lvbn08L3ZlcnNpb24+CisgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbnM+CisgICAgICAgICAgICAgICAgICAgIDxleGVjdXRpb24+CisgICAgICAgICAgICAgICAgICAgICAgICA8aWQ+c291cmNlLWZlYXR1cmU8L2lkPgorICAgICAgICAgICAgICAgICAgICAgICAgPHBoYXNlPnBhY2thZ2U8L3BoYXNlPgorICAgICAgICAgICAgICAgICAgICAgICAgPGdvYWxzPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxnb2FsPnNvdXJjZS1mZWF0dXJlPC9nb2FsPgorICAgICAgICAgICAgICAgICAgICAgICAgPC9nb2Fscz4KKyAgICAgICAgICAgICAgICAgICAgPC9leGVjdXRpb24+CisgICAgICAgICAgICAgICAgPC9leGVjdXRpb25zPgorICAgICAgICAgICAgICAgIDxjb25maWd1cmF0aW9uPgorICAgICAgICAgICAgICAgICAgICA8bGFiZWxTdWZmaXg+IChzb3VyY2UpPC9sYWJlbFN1ZmZpeD4KKyAgICAgICAgICAgICAgICAgICAgPGV4Y2x1ZGVzPgorICAgICAgICAgICAgICAgICAgICAgICAgPHBsdWdpbiBpZD0iY29tLmlibS5pY3UiLz4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxwbHVnaW4gaWQ9Im9yZy5hcGFjaGUuY29tbW9ucy5jbGkiLz4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxwbHVnaW4gaWQ9ImNvbS5nb29nbGUuZ3VhdmEiLz4KKyAgICAgICAgICAgICAgICAgICAgPC9leGNsdWRlcz4KKyAgICAgICAgICAgICAgICA8L2NvbmZpZ3VyYXRpb24+CisgICAgICAgICAgICA8L3BsdWdpbj4KKyAgICAgICAgICAgIDxwbHVnaW4+CisgICAgICAgICAgICAgICAgPCEtLSB3b3JrYXJvdW5kIHdoaWxlIGJ1ZyBodHRwczovL2J1Z3MuZWNsaXBzZS5vcmcvYnVncy9zaG93X2J1Zy5jZ2k/aWQ9Mzk4MjUwIAorCQkJCQlpcyBub3QgZml4ZWQgLS0+CisgICAgICAgICAgICAgICAgPGdyb3VwSWQ+b3JnLmVjbGlwc2UudHljaG88L2dyb3VwSWQ+CisgICAgICAgICAgICAgICAgPGFydGlmYWN0SWQ+dHljaG8tcDItcGx1Z2luPC9hcnRpZmFjdElkPgorICAgICAgICAgICAgICAgIDx2ZXJzaW9uPiR7dHljaG8tdmVyc2lvbn08L3ZlcnNpb24+CisgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbnM+CisgICAgICAgICAgICAgICAgICAgIDxleGVjdXRpb24+CisgICAgICAgICAgICAgICAgICAgICAgICA8aWQ+YXR0YWNoZWQtcDItbWV0YWRhdGE8L2lkPgorICAgICAgICAgICAgICAgICAgICAgICAgPHBoYXNlPnBhY2thZ2U8L3BoYXNlPgorICAgICAgICAgICAgICAgICAgICAgICAgPGdvYWxzPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxnb2FsPnAyLW1ldGFkYXRhPC9nb2FsPgorICAgICAgICAgICAgICAgICAgICAgICAgPC9nb2Fscz4KKyAgICAgICAgICAgICAgICAgICAgPC9leGVjdXRpb24+CisgICAgICAgICAgICAgICAgPC9leGVjdXRpb25zPgorICAgICAgICAgICAgPC9wbHVnaW4+CisJCQk8cGx1Z2luPgorCQkJCTxhcnRpZmFjdElkPm1hdmVuLWphdmFkb2MtcGx1Z2luPC9hcnRpZmFjdElkPgorCQkJCTxleGVjdXRpb25zPgorCQkJCQk8ZXhlY3V0aW9uPgorCQkJCQkJPGlkPmphdmFkb2MtamFyPC9pZD4KKwkJCQkJCTxwaGFzZT5wYWNrYWdlPC9waGFzZT4KKwkJCQkJCTxnb2Fscz4KKwkJCQkJCQk8Z29hbD5qYXI8L2dvYWw+CisJCQkJCQk8L2dvYWxzPgorCQkJCQk8L2V4ZWN1dGlvbj4KKwkJCQk8L2V4ZWN1dGlvbnM+CisJCQk8L3BsdWdpbj4KKyAgICAgICAgPC9wbHVnaW5zPgorICAgIDwvYnVpbGQ+CisKKzwvcHJvamVjdD4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudWkvc3JjL21haW4vamF2YWRvYy9SRUFETUUudHh0IGIvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS51aS9zcmMvbWFpbi9qYXZhZG9jL1JFQURNRS50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODMxZGE3ZQotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudWkvc3JjL21haW4vamF2YWRvYy9SRUFETUUudHh0CkBAIC0wLDAgKzEgQEAKK1Jlc291cmNlIGZvbGRlciBmb3IgamF2YWRvYyByZXNvdXJjZXMuClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS51aS9zcmMvb3ZlcnZpZXcuaHRtbCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudWkvc3JjL292ZXJ2aWV3Lmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2NiNzQzNwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudWkvc3JjL292ZXJ2aWV3Lmh0bWwKQEAgLTAsMCArMSwxMSBAQAorPCFET0NUWVBFIEhUTUwgUFVCTElDICItLy9XM0MvL0RURCBIVE1MIDQuMCBUcmFuc2l0aW9uYWwvL0VOIj4KKzxodG1sPgorPGhlYWQ+CisJPHRpdGxlPk9TQlAgcnVudGltZSB3ZWIgdmFhZGluIGNvbXBvbmVudHMgZmVhdHVyZSBPdmVydmlldzwvdGl0bGU+Cis8L2hlYWQ+Cis8Ym9keT4KKzxwPlRoZSA8Yj5PU0JQJm5ic3A7ZmVhdHVyZTwvYj4mbmJzcDtpbnN0YWxscyBhbGwgZmVhdHVyZXMgcmVxdWlyZWQgZm9yIE9TQlAgaW50byB0aGUgSURFLjwvcD4KKworPHA+PHN0cm9uZz5BdHRlbnRpb246IFJlYWQgdGhlIGNvcHlyaWdodCBub3RpY2Ugb2YgQ1ZBTDMgbGljZW5zZS48L3N0cm9uZz48L3A+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvLnByb2plY3QgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvLnByb2plY3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOWY3M2U5NAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3Blci8ucHJvamVjdApAQCAtMCwwICsxLDUxIEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPHByb2plY3REZXNjcmlwdGlvbj4KKwk8bmFtZT5vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXI8L25hbWU+CisJPGNvbW1lbnQ+PC9jb21tZW50PgorCTxwcm9qZWN0cz4KKwk8L3Byb2plY3RzPgorCTxidWlsZFNwZWM+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS54dGV4dC51aS5zaGFyZWQueHRleHRCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLmpkdC5jb3JlLmphdmFidWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5NYW5pZmVzdEJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLlNjaGVtYUJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UuYmFiZWwuZWRpdG9yLnJiZUJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLnNvbmFybGludC5lY2xpcHNlLmNvcmUuc29uYXJsaW50QnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5tMmUuY29yZS5tYXZlbjJCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwk8L2J1aWxkU3BlYz4KKwk8bmF0dXJlcz4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS54dGV4dC51aS5zaGFyZWQueHRleHROYXR1cmU8L25hdHVyZT4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS5tMmUuY29yZS5tYXZlbjJOYXR1cmU8L25hdHVyZT4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS5wZGUuUGx1Z2luTmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UuamR0LmNvcmUuamF2YW5hdHVyZTwvbmF0dXJlPgorCQk8bmF0dXJlPm9yZy5lY2xpcHNlLmJhYmVsLmVkaXRvci5yYmVOYXR1cmU8L25hdHVyZT4KKwk8L25hdHVyZXM+Cis8L3Byb2plY3REZXNjcmlwdGlvbj4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3Blci9MSUNFTlNFLnR4dCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3Blci9MSUNFTlNFLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5mZjQyYWQ0Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL0xJQ0VOU0UudHh0CkBAIC0wLDAgKzEsMTYxIEBACitFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC12IDEuMAorCitUSEUgQUNDT01QQU5ZSU5HIFBST0dSQU0gSVMgUFJPVklERUQgVU5ERVIgVEhFIFRFUk1TIE9GIFRISVMgRUNMSVBTRSBQVUJMSUMgTElDRU5TRSAoIkFHUkVFTUVOVCIpLiBBTlkgVVNFLCBSRVBST0RVQ1RJT04KK09SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBDT05TVElUVVRFUyBSRUNJUElFTlQnUyBBQ0NFUFRBTkNFIE9GIFRISVMgQUdSRUVNRU5ULgorCisxLiBERUZJTklUSU9OUworCisiQ29udHJpYnV0aW9uIiBtZWFuczoKKworYSkgaW4gdGhlIGNhc2Ugb2YgdGhlIGluaXRpYWwgQ29udHJpYnV0b3IsIHRoZSBpbml0aWFsIGNvZGUgYW5kIGRvY3VtZW50YXRpb24gZGlzdHJpYnV0ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGFuZAorCitiKSBpbiB0aGUgY2FzZSBvZiBlYWNoIHN1YnNlcXVlbnQgQ29udHJpYnV0b3I6CisKK2kpIGNoYW5nZXMgdG8gdGhlIFByb2dyYW0sIGFuZAorCitpaSkgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtOworCit3aGVyZSBzdWNoIGNoYW5nZXMgYW5kL29yIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbSBvcmlnaW5hdGUgZnJvbSBhbmQgYXJlIGRpc3RyaWJ1dGVkIGJ5IHRoYXQgcGFydGljdWxhciBDb250cmlidXRvci4KK0EgQ29udHJpYnV0aW9uICdvcmlnaW5hdGVzJyBmcm9tIGEgQ29udHJpYnV0b3IgaWYgaXQgd2FzIGFkZGVkIHRvIHRoZSBQcm9ncmFtIGJ5IHN1Y2ggQ29udHJpYnV0b3IgaXRzZWxmIG9yIGFueW9uZQorYWN0aW5nIG9uIHN1Y2ggQ29udHJpYnV0b3IncyBiZWhhbGYuIENvbnRyaWJ1dGlvbnMgZG8gbm90IGluY2x1ZGUgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIHdoaWNoOiAoaSkgYXJlIHNlcGFyYXRlCittb2R1bGVzIG9mIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIGluIGNvbmp1bmN0aW9uIHdpdGggdGhlIFByb2dyYW0gdW5kZXIgdGhlaXIgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBhbmQgKGlpKSBhcmUgbm90CitkZXJpdmF0aXZlIHdvcmtzIG9mIHRoZSBQcm9ncmFtLgorCisiQ29udHJpYnV0b3IiIG1lYW5zIGFueSBwZXJzb24gb3IgZW50aXR5IHRoYXQgZGlzdHJpYnV0ZXMgdGhlIFByb2dyYW0uCisKKyJMaWNlbnNlZCBQYXRlbnRzICIgbWVhbiBwYXRlbnQgY2xhaW1zIGxpY2Vuc2FibGUgYnkgYSBDb250cmlidXRvciB3aGljaCBhcmUgbmVjZXNzYXJpbHkgaW5mcmluZ2VkIGJ5IHRoZSB1c2Ugb3Igc2FsZSBvZgoraXRzIENvbnRyaWJ1dGlvbiBhbG9uZSBvciB3aGVuIGNvbWJpbmVkIHdpdGggdGhlIFByb2dyYW0uCisKKyJQcm9ncmFtIiBtZWFucyB0aGUgQ29udHJpYnV0aW9ucyBkaXN0cmlidXRlZCBpbiBhY2NvcmRhbmNlIHdpdGggdGhpcyBBZ3JlZW1lbnQuCisKKyJSZWNpcGllbnQiIG1lYW5zIGFueW9uZSB3aG8gcmVjZWl2ZXMgdGhlIFByb2dyYW0gdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGluY2x1ZGluZyBhbGwgQ29udHJpYnV0b3JzLgorCisyLiBHUkFOVCBPRiBSSUdIVFMKKworYSkgU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsCityb3lhbHR5LWZyZWUgY29weXJpZ2h0IGxpY2Vuc2UgdG8gcmVwcm9kdWNlLCBwcmVwYXJlIGRlcml2YXRpdmUgd29ya3Mgb2YsIHB1YmxpY2x5IGRpc3BsYXksIHB1YmxpY2x5IHBlcmZvcm0sIGRpc3RyaWJ1dGUKK2FuZCBzdWJsaWNlbnNlIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBhbmQgc3VjaCBkZXJpdmF0aXZlIHdvcmtzLCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUKK2Zvcm0uCisKK2IpIFN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLAorcm95YWx0eS1mcmVlIHBhdGVudCBsaWNlbnNlIHVuZGVyIExpY2Vuc2VkIFBhdGVudHMgdG8gbWFrZSwgdXNlLCBzZWxsLCBvZmZlciB0byBzZWxsLCBpbXBvcnQgYW5kIG90aGVyd2lzZSB0cmFuc2ZlciB0aGUKK0NvbnRyaWJ1dGlvbiBvZiBzdWNoIENvbnRyaWJ1dG9yLCBpZiBhbnksIGluIHNvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLiBUaGlzIHBhdGVudCBsaWNlbnNlIHNoYWxsIGFwcGx5IHRvIHRoZQorY29tYmluYXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBhbmQgdGhlIFByb2dyYW0gaWYsIGF0IHRoZSB0aW1lIHRoZSBDb250cmlidXRpb24gaXMgYWRkZWQgYnkgdGhlIENvbnRyaWJ1dG9yLCBzdWNoCithZGRpdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGNhdXNlcyBzdWNoIGNvbWJpbmF0aW9uIHRvIGJlIGNvdmVyZWQgYnkgdGhlIExpY2Vuc2VkIFBhdGVudHMuIFRoZSBwYXRlbnQgbGljZW5zZSBzaGFsbCBub3QKK2FwcGx5IHRvIGFueSBvdGhlciBjb21iaW5hdGlvbnMgd2hpY2ggaW5jbHVkZSB0aGUgQ29udHJpYnV0aW9uLiBObyBoYXJkd2FyZSBwZXIgc2UgaXMgbGljZW5zZWQgaGVyZXVuZGVyLgorCitjKSBSZWNpcGllbnQgdW5kZXJzdGFuZHMgdGhhdCBhbHRob3VnaCBlYWNoIENvbnRyaWJ1dG9yIGdyYW50cyB0aGUgbGljZW5zZXMgdG8gaXRzIENvbnRyaWJ1dGlvbnMgc2V0IGZvcnRoIGhlcmVpbiwgbm8KK2Fzc3VyYW5jZXMgYXJlIHByb3ZpZGVkIGJ5IGFueSBDb250cmlidXRvciB0aGF0IHRoZSBQcm9ncmFtIGRvZXMgbm90IGluZnJpbmdlIHRoZSBwYXRlbnQgb3Igb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5CityaWdodHMgb2YgYW55IG90aGVyIGVudGl0eS4gRWFjaCBDb250cmlidXRvciBkaXNjbGFpbXMgYW55IGxpYWJpbGl0eSB0byBSZWNpcGllbnQgZm9yIGNsYWltcyBicm91Z2h0IGJ5IGFueSBvdGhlciBlbnRpdHkKK2Jhc2VkIG9uIGluZnJpbmdlbWVudCBvZiBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG9yIG90aGVyd2lzZS4gQXMgYSBjb25kaXRpb24gdG8gZXhlcmNpc2luZyB0aGUgcmlnaHRzIGFuZAorbGljZW5zZXMgZ3JhbnRlZCBoZXJldW5kZXIsIGVhY2ggUmVjaXBpZW50IGhlcmVieSBhc3N1bWVzIHNvbGUgcmVzcG9uc2liaWxpdHkgdG8gc2VjdXJlIGFueSBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkKK3JpZ2h0cyBuZWVkZWQsIGlmIGFueS4gRm9yIGV4YW1wbGUsIGlmIGEgdGhpcmQgcGFydHkgcGF0ZW50IGxpY2Vuc2UgaXMgcmVxdWlyZWQgdG8gYWxsb3cgUmVjaXBpZW50IHRvIGRpc3RyaWJ1dGUgdGhlCitQcm9ncmFtLCBpdCBpcyBSZWNpcGllbnQncyByZXNwb25zaWJpbGl0eSB0byBhY3F1aXJlIHRoYXQgbGljZW5zZSBiZWZvcmUgZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtLgorCitkKSBFYWNoIENvbnRyaWJ1dG9yIHJlcHJlc2VudHMgdGhhdCB0byBpdHMga25vd2xlZGdlIGl0IGhhcyBzdWZmaWNpZW50IGNvcHlyaWdodCByaWdodHMgaW4gaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCB0bworZ3JhbnQgdGhlIGNvcHlyaWdodCBsaWNlbnNlIHNldCBmb3J0aCBpbiB0aGlzIEFncmVlbWVudC4KKworMy4gUkVRVUlSRU1FTlRTCisKK0EgQ29udHJpYnV0b3IgbWF5IGNob29zZSB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtIGluIG9iamVjdCBjb2RlIGZvcm0gdW5kZXIgaXRzIG93biBsaWNlbnNlIGFncmVlbWVudCwgcHJvdmlkZWQgdGhhdDoKKworYSkgaXQgY29tcGxpZXMgd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQ7IGFuZAorCitiKSBpdHMgbGljZW5zZSBhZ3JlZW1lbnQ6CisKK2kpIGVmZmVjdGl2ZWx5IGRpc2NsYWltcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgd2FycmFudGllcyBhbmQgY29uZGl0aW9ucywgZXhwcmVzcyBhbmQgaW1wbGllZCwgaW5jbHVkaW5nCit3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgdGl0bGUgYW5kIG5vbi1pbmZyaW5nZW1lbnQsIGFuZCBpbXBsaWVkIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiBtZXJjaGFudGFiaWxpdHkgYW5kCitmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZTsKKworaWkpIGVmZmVjdGl2ZWx5IGV4Y2x1ZGVzIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCBsaWFiaWxpdHkgZm9yIGRhbWFnZXMsIGluY2x1ZGluZyBkaXJlY3QsIGluZGlyZWN0LCBzcGVjaWFsLAoraW5jaWRlbnRhbCBhbmQgY29uc2VxdWVudGlhbCBkYW1hZ2VzLCBzdWNoIGFzIGxvc3QgcHJvZml0czsKKworaWlpKSBzdGF0ZXMgdGhhdCBhbnkgcHJvdmlzaW9ucyB3aGljaCBkaWZmZXIgZnJvbSB0aGlzIEFncmVlbWVudCBhcmUgb2ZmZXJlZCBieSB0aGF0IENvbnRyaWJ1dG9yIGFsb25lIGFuZCBub3QgYnkgYW55CitvdGhlciBwYXJ0eTsgYW5kCisKK2l2KSBzdGF0ZXMgdGhhdCBzb3VyY2UgY29kZSBmb3IgdGhlIFByb2dyYW0gaXMgYXZhaWxhYmxlIGZyb20gc3VjaCBDb250cmlidXRvciwgYW5kIGluZm9ybXMgbGljZW5zZWVzIGhvdyB0byBvYnRhaW4gaXQKK2luIGEgcmVhc29uYWJsZSBtYW5uZXIgb24gb3IgdGhyb3VnaCBhIG1lZGl1bSBjdXN0b21hcmlseSB1c2VkIGZvciBzb2Z0d2FyZSBleGNoYW5nZS4KKworV2hlbiB0aGUgUHJvZ3JhbSBpcyBtYWRlIGF2YWlsYWJsZSBpbiBzb3VyY2UgY29kZSBmb3JtOgorCithKSBpdCBtdXN0IGJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoaXMgQWdyZWVtZW50OyBhbmQKKworYikgYSBjb3B5IG9mIHRoaXMgQWdyZWVtZW50IG11c3QgYmUgaW5jbHVkZWQgd2l0aCBlYWNoIGNvcHkgb2YgdGhlIFByb2dyYW0uCisKK0NvbnRyaWJ1dG9ycyBtYXkgbm90IHJlbW92ZSBvciBhbHRlciBhbnkgY29weXJpZ2h0IG5vdGljZXMgY29udGFpbmVkIHdpdGhpbiB0aGUgUHJvZ3JhbS4KKworRWFjaCBDb250cmlidXRvciBtdXN0IGlkZW50aWZ5IGl0c2VsZiBhcyB0aGUgb3JpZ2luYXRvciBvZiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIGluIGEgbWFubmVyIHRoYXQgcmVhc29uYWJseSBhbGxvd3MKK3N1YnNlcXVlbnQgUmVjaXBpZW50cyB0byBpZGVudGlmeSB0aGUgb3JpZ2luYXRvciBvZiB0aGUgQ29udHJpYnV0aW9uLgorCis0LiBDT01NRVJDSUFMIERJU1RSSUJVVElPTgorCitDb21tZXJjaWFsIGRpc3RyaWJ1dG9ycyBvZiBzb2Z0d2FyZSBtYXkgYWNjZXB0IGNlcnRhaW4gcmVzcG9uc2liaWxpdGllcyB3aXRoIHJlc3BlY3QgdG8gZW5kIHVzZXJzLCBidXNpbmVzcyBwYXJ0bmVycyBhbmQKK3RoZSBsaWtlLiBXaGlsZSB0aGlzIGxpY2Vuc2UgaXMgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY29tbWVyY2lhbCB1c2Ugb2YgdGhlIFByb2dyYW0sIHRoZSBDb250cmlidXRvciB3aG8gaW5jbHVkZXMKK3RoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nIHNob3VsZCBkbyBzbyBpbiBhIG1hbm5lciB3aGljaCBkb2VzIG5vdCBjcmVhdGUgcG90ZW50aWFsIGxpYWJpbGl0eSBmb3IKK290aGVyIENvbnRyaWJ1dG9ycy4gVGhlcmVmb3JlLCBpZiBhIENvbnRyaWJ1dG9yIGluY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBzdWNoIENvbnRyaWJ1dG9yCisoIkNvbW1lcmNpYWwgQ29udHJpYnV0b3IiKSBoZXJlYnkgYWdyZWVzIHRvIGRlZmVuZCBhbmQgaW5kZW1uaWZ5IGV2ZXJ5IG90aGVyIENvbnRyaWJ1dG9yICgiSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IiKQorYWdhaW5zdCBhbnkgbG9zc2VzLCBkYW1hZ2VzIGFuZCBjb3N0cyAoY29sbGVjdGl2ZWx5ICJMb3NzZXMiKSBhcmlzaW5nIGZyb20gY2xhaW1zLCBsYXdzdWl0cyBhbmQgb3RoZXIgbGVnYWwgYWN0aW9ucworYnJvdWdodCBieSBhIHRoaXJkIHBhcnR5IGFnYWluc3QgdGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIHRvIHRoZSBleHRlbnQgY2F1c2VkIGJ5IHRoZSBhY3RzIG9yIG9taXNzaW9ucyBvZiBzdWNoCitDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluIGNvbm5lY3Rpb24gd2l0aCBpdHMgZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLiBUaGUKK29ibGlnYXRpb25zIGluIHRoaXMgc2VjdGlvbiBkbyBub3QgYXBwbHkgdG8gYW55IGNsYWltcyBvciBMb3NzZXMgcmVsYXRpbmcgdG8gYW55IGFjdHVhbCBvciBhbGxlZ2VkIGludGVsbGVjdHVhbAorcHJvcGVydHkgaW5mcmluZ2VtZW50LiBJbiBvcmRlciB0byBxdWFsaWZ5LCBhbiBJbmRlbW5pZmllZCBDb250cmlidXRvciBtdXN0OiBhKSBwcm9tcHRseSBub3RpZnkgdGhlIENvbW1lcmNpYWwKK0NvbnRyaWJ1dG9yIGluIHdyaXRpbmcgb2Ygc3VjaCBjbGFpbSwgYW5kIGIpIGFsbG93IHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRvIGNvbnRyb2wsIGFuZCBjb29wZXJhdGUgd2l0aCB0aGUKK0NvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4sIHRoZSBkZWZlbnNlIGFuZCBhbnkgcmVsYXRlZCBzZXR0bGVtZW50IG5lZ290aWF0aW9ucy4gVGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG1heQorIHBhcnRpY2lwYXRlIGluIGFueSBzdWNoIGNsYWltIGF0IGl0cyBvd24gZXhwZW5zZS4KKworRm9yIGV4YW1wbGUsIGEgQ29udHJpYnV0b3IgbWlnaHQgaW5jbHVkZSB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgUHJvZHVjdCBYLiBUaGF0IENvbnRyaWJ1dG9yIGlzCit0aGVuIGEgQ29tbWVyY2lhbCBDb250cmlidXRvci4gSWYgdGhhdCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRoZW4gbWFrZXMgcGVyZm9ybWFuY2UgY2xhaW1zLCBvciBvZmZlcnMgd2FycmFudGllcworcmVsYXRlZCB0byBQcm9kdWN0IFgsIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcyBhcmUgc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yJ3MgcmVzcG9uc2liaWxpdHkgYWxvbmUuCitVbmRlciB0aGlzIHNlY3Rpb24sIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHdvdWxkIGhhdmUgdG8gZGVmZW5kIGNsYWltcyBhZ2FpbnN0IHRoZSBvdGhlciBDb250cmlidXRvcnMgcmVsYXRlZCB0bwordGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZCB3YXJyYW50aWVzLCBhbmQgaWYgYSBjb3VydCByZXF1aXJlcyBhbnkgb3RoZXIgQ29udHJpYnV0b3IgdG8gcGF5IGFueSBkYW1hZ2VzIGFzIGEgcmVzdWx0LAordGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgbXVzdCBwYXkgdGhvc2UgZGFtYWdlcy4KKworNS4gTk8gV0FSUkFOVFkKKworRVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUyBBR1JFRU1FTlQsIFRIRSBQUk9HUkFNIElTIFBST1ZJREVEIE9OIEFOICJBUyBJUyIgQkFTSVMsIFdJVEhPVVQgV0FSUkFOVElFUyBPUgorQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgRUlUSEVSIEVYUFJFU1MgT1IgSU1QTElFRCBJTkNMVURJTkcsIFdJVEhPVVQgTElNSVRBVElPTiwgQU5ZIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBUSVRMRSwKK05PTi1JTkZSSU5HRU1FTlQsIE1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gRWFjaCBSZWNpcGllbnQgaXMgc29sZWx5IHJlc3BvbnNpYmxlIGZvcgorZGV0ZXJtaW5pbmcgdGhlIGFwcHJvcHJpYXRlbmVzcyBvZiB1c2luZyBhbmQgZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtIGFuZCBhc3N1bWVzIGFsbCByaXNrcyBhc3NvY2lhdGVkIHdpdGggaXRzCitleGVyY2lzZSBvZiByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgLCBpbmNsdWRpbmcgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSByaXNrcyBhbmQgY29zdHMgb2YgcHJvZ3JhbSBlcnJvcnMsIGNvbXBsaWFuY2UKK3dpdGggYXBwbGljYWJsZSBsYXdzLCBkYW1hZ2UgdG8gb3IgbG9zcyBvZiBkYXRhLCBwcm9ncmFtcyBvciBlcXVpcG1lbnQsIGFuZCB1bmF2YWlsYWJpbGl0eSBvciBpbnRlcnJ1cHRpb24gb2Ygb3BlcmF0aW9ucy4KKworNi4gRElTQ0xBSU1FUiBPRiBMSUFCSUxJVFkKKworRVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUyBBR1JFRU1FTlQsIE5FSVRIRVIgUkVDSVBJRU5UIE5PUiBBTlkgQ09OVFJJQlVUT1JTIFNIQUxMIEhBVkUgQU5ZIExJQUJJTElUWSBGT1IgQU5ZCitESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HIFdJVEhPVVQgTElNSVRBVElPTiBMT1NUIFBST0ZJVFMpLAorSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUgorT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIE9SIFRIRSBFWEVSQ0lTRSBPRiBBTlkgUklHSFRTIEdSQU5URUQKK0hFUkVVTkRFUiwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRVMuCisKKzcuIEdFTkVSQUwKKworSWYgYW55IHByb3Zpc2lvbiBvZiB0aGlzIEFncmVlbWVudCBpcyBpbnZhbGlkIG9yIHVuZW5mb3JjZWFibGUgdW5kZXIgYXBwbGljYWJsZSBsYXcsIGl0IHNoYWxsIG5vdCBhZmZlY3QgdGhlIHZhbGlkaXR5IG9yCitlbmZvcmNlYWJpbGl0eSBvZiB0aGUgcmVtYWluZGVyIG9mIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgYW5kIHdpdGhvdXQgZnVydGhlciBhY3Rpb24gYnkgdGhlIHBhcnRpZXMgaGVyZXRvLCBzdWNoCitwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlIG1pbmltdW0gZXh0ZW50IG5lY2Vzc2FyeSB0byBtYWtlIHN1Y2ggcHJvdmlzaW9uIHZhbGlkIGFuZCBlbmZvcmNlYWJsZS4KKworSWYgUmVjaXBpZW50IGluc3RpdHV0ZXMgcGF0ZW50IGxpdGlnYXRpb24gYWdhaW5zdCBhbnkgZW50aXR5IChpbmNsdWRpbmcgYSBjcm9zcy1jbGFpbSBvciBjb3VudGVyY2xhaW0gaW4gYSBsYXdzdWl0KQorYWxsZWdpbmcgdGhhdCB0aGUgUHJvZ3JhbSBpdHNlbGYgKGV4Y2x1ZGluZyBjb21iaW5hdGlvbnMgb2YgdGhlIFByb2dyYW0gd2l0aCBvdGhlciBzb2Z0d2FyZSBvciBoYXJkd2FyZSkgaW5mcmluZ2VzIHN1Y2gKK1JlY2lwaWVudCdzIHBhdGVudChzKSwgdGhlbiBzdWNoIFJlY2lwaWVudCdzIHJpZ2h0cyBncmFudGVkIHVuZGVyIFNlY3Rpb24gMihiKSBzaGFsbCB0ZXJtaW5hdGUgYXMgb2YgdGhlIGRhdGUgc3VjaAorbGl0aWdhdGlvbiBpcyBmaWxlZC4KKworQWxsIFJlY2lwaWVudCdzIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCBzaGFsbCB0ZXJtaW5hdGUgaWYgaXQgZmFpbHMgdG8gY29tcGx5IHdpdGggYW55IG9mIHRoZSBtYXRlcmlhbCB0ZXJtcyBvcgorY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudCBhbmQgZG9lcyBub3QgY3VyZSBzdWNoIGZhaWx1cmUgaW4gYSByZWFzb25hYmxlIHBlcmlvZCBvZiB0aW1lIGFmdGVyIGJlY29taW5nIGF3YXJlIG9mIHN1Y2gKK25vbmNvbXBsaWFuY2UuIElmIGFsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgdGVybWluYXRlLCBSZWNpcGllbnQgYWdyZWVzIHRvIGNlYXNlIHVzZSBhbmQgZGlzdHJpYnV0aW9uCitvZiB0aGUgUHJvZ3JhbSBhcyBzb29uIGFzIHJlYXNvbmFibHkgcHJhY3RpY2FibGUuIEhvd2V2ZXIsIFJlY2lwaWVudCdzIG9ibGlnYXRpb25zIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFuZCBhbnkgbGljZW5zZXMKKyBncmFudGVkIGJ5IFJlY2lwaWVudCByZWxhdGluZyB0byB0aGUgUHJvZ3JhbSBzaGFsbCBjb250aW51ZSBhbmQgc3Vydml2ZS4KKworRXZlcnlvbmUgaXMgcGVybWl0dGVkIHRvIGNvcHkgYW5kIGRpc3RyaWJ1dGUgY29waWVzIG9mIHRoaXMgQWdyZWVtZW50LCBidXQgaW4gb3JkZXIgdG8gYXZvaWQgaW5jb25zaXN0ZW5jeSB0aGUgQWdyZWVtZW50CitpcyBjb3B5cmlnaHRlZCBhbmQgbWF5IG9ubHkgYmUgbW9kaWZpZWQgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXIuIFRoZSBBZ3JlZW1lbnQgU3Rld2FyZCByZXNlcnZlcyB0aGUgcmlnaHQgdG8gcHVibGlzaAorbmV3IHZlcnNpb25zIChpbmNsdWRpbmcgcmV2aXNpb25zKSBvZiB0aGlzIEFncmVlbWVudCBmcm9tIHRpbWUgdG8gdGltZS4gTm8gb25lIG90aGVyIHRoYW4gdGhlIEFncmVlbWVudCBTdGV3YXJkIGhhcyB0aGUKK3JpZ2h0IHRvIG1vZGlmeSB0aGlzIEFncmVlbWVudC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyB0aGUgaW5pdGlhbCBBZ3JlZW1lbnQgU3Rld2FyZC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYXkKK2Fzc2lnbiB0aGUgcmVzcG9uc2liaWxpdHkgdG8gc2VydmUgYXMgdGhlIEFncmVlbWVudCBTdGV3YXJkIHRvIGEgc3VpdGFibGUgc2VwYXJhdGUgZW50aXR5LiBFYWNoIG5ldyB2ZXJzaW9uIG9mIHRoZQorQWdyZWVtZW50IHdpbGwgYmUgZ2l2ZW4gYSBkaXN0aW5ndWlzaGluZyB2ZXJzaW9uIG51bWJlci4gVGhlIFByb2dyYW0gKGluY2x1ZGluZyBDb250cmlidXRpb25zKSBtYXkgYWx3YXlzIGJlCitkaXN0cmlidXRlZCBzdWJqZWN0IHRvIHRoZSB2ZXJzaW9uIG9mIHRoZSBBZ3JlZW1lbnQgdW5kZXIgd2hpY2ggaXQgd2FzIHJlY2VpdmVkLiBJbiBhZGRpdGlvbiwgYWZ0ZXIgYSBuZXcgdmVyc2lvbiBvZgordGhlIEFncmVlbWVudCBpcyBwdWJsaXNoZWQsIENvbnRyaWJ1dG9yIG1heSBlbGVjdCB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtIChpbmNsdWRpbmcgaXRzIENvbnRyaWJ1dGlvbnMpIHVuZGVyIHRoZQorbmV3IHZlcnNpb24uIEV4Y2VwdCBhcyBleHByZXNzbHkgc3RhdGVkIGluIFNlY3Rpb25zIDIoYSkgYW5kIDIoYikgYWJvdmUsIFJlY2lwaWVudCByZWNlaXZlcyBubyByaWdodHMgb3IgbGljZW5zZXMgdG8KK3RoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgb2YgYW55IENvbnRyaWJ1dG9yIHVuZGVyIHRoaXMgQWdyZWVtZW50LCB3aGV0aGVyIGV4cHJlc3NseSwgYnkgaW1wbGljYXRpb24sIGVzdG9wcGVsIG9yCitvdGhlcndpc2UuIEFsbCByaWdodHMgaW4gdGhlIFByb2dyYW0gbm90IGV4cHJlc3NseSBncmFudGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFyZSByZXNlcnZlZC4KKworVGhpcyBBZ3JlZW1lbnQgaXMgZ292ZXJuZWQgYnkgdGhlIGxhd3Mgb2YgdGhlIFN0YXRlIG9mIE5ldyBZb3JrIGFuZCB0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGxhd3Mgb2YgdGhlIFVuaXRlZCBTdGF0ZXMKK29mIEFtZXJpY2EuIE5vIHBhcnR5IHRvIHRoaXMgQWdyZWVtZW50IHdpbGwgYnJpbmcgYSBsZWdhbCBhY3Rpb24gdW5kZXIgdGhpcyBBZ3JlZW1lbnQgbW9yZSB0aGFuIG9uZSB5ZWFyIGFmdGVyIHRoZSBjYXVzZQorb2YgYWN0aW9uIGFyb3NlLiBFYWNoIHBhcnR5IHdhaXZlcyBpdHMgcmlnaHRzIHRvIGEganVyeSB0cmlhbCBpbiBhbnkgcmVzdWx0aW5nIGxpdGlnYXRpb24uClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL01FVEEtSU5GL01BTklGRVNULk1GIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL01FVEEtSU5GL01BTklGRVNULk1GCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjAxODg1YmMKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvTUVUQS1JTkYvTUFOSUZFU1QuTUYKQEAgLTAsMCArMSwxMyBAQAorTWFuaWZlc3QtVmVyc2lvbjogMS4wCitCdW5kbGUtTWFuaWZlc3RWZXJzaW9uOiAyCitCdW5kbGUtTmFtZTogb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyCitCdW5kbGUtU3ltYm9saWNOYW1lOiBvcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXI7c2luZ2xldG9uOj10cnVlCitCdW5kbGUtVmVyc2lvbjogMC45LjAucXVhbGlmaWVyCitCdW5kbGUtQWN0aXZhdG9yOiBvcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIuQWN0aXZhdG9yCitCdW5kbGUtVmVuZG9yOiBFY2xpcHNlIE9TQlAKK1JlcXVpcmUtQnVuZGxlOiBvcmcuZWNsaXBzZS51aSwKKyBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUsCisgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXM7YnVuZGxlLXZlcnNpb249IjMuOS4wIgorQnVuZGxlLVJlcXVpcmVkRXhlY3V0aW9uRW52aXJvbm1lbnQ6IEphdmFTRS0xLjcKK0J1bmRsZS1BY3RpdmF0aW9uUG9saWN5OiBsYXp5CitJbXBvcnQtUGFja2FnZTogb3JnLnNsZjRqO3ZlcnNpb249IjEuNy4yIgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL2Fib3V0Lmh0bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvYWJvdXQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NGMwNTk4Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL2Fib3V0Lmh0bWwKQEAgLTAsMCArMSwyOCBAQAorPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgU3RyaWN0Ly9FTiIKKyAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtc3RyaWN0LmR0ZCI+Cis8aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+Cis8aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiLz4KKzx0aXRsZT5BYm91dDwvdGl0bGU+Cis8L2hlYWQ+Cis8Ym9keSBsYW5nPSJFTi1VUyI+Cis8aDI+QWJvdXQgVGhpcyBDb250ZW50PC9oMj4KKyAKKzxwPkp1bmUgMSwgMjAxNjwvcD4JCis8aDM+TGljZW5zZTwvaDM+CisKKzxwPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIGFsbCBjb250ZW50IGluIHRoaXMgcGx1Zy1pbiAoJnF1b3Q7Q29udGVudCZxdW90OykuICBVbmxlc3Mgb3RoZXJ3aXNlIAoraW5kaWNhdGVkIGJlbG93LCB0aGUgQ29udGVudCBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZQorRWNsaXBzZSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoJnF1b3Q7RVBMJnF1b3Q7KS4gIEEgY29weSBvZiB0aGUgRVBMIGlzIGF2YWlsYWJsZSAKK2F0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT4uCitGb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgJnF1b3Q7UHJvZ3JhbSZxdW90OyB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9wPgorCis8cD5JZiB5b3UgZGlkIG5vdCByZWNlaXZlIHRoaXMgQ29udGVudCBkaXJlY3RseSBmcm9tIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24sIHRoZSBDb250ZW50IGlzIAorYmVpbmcgcmVkaXN0cmlidXRlZCBieSBhbm90aGVyIHBhcnR5ICgmcXVvdDtSZWRpc3RyaWJ1dG9yJnF1b3Q7KSBhbmQgZGlmZmVyZW50IHRlcm1zIGFuZCBjb25kaXRpb25zIG1heQorYXBwbHkgdG8geW91ciB1c2Ugb2YgYW55IG9iamVjdCBjb2RlIGluIHRoZSBDb250ZW50LiAgQ2hlY2sgdGhlIFJlZGlzdHJpYnV0b3IncyBsaWNlbnNlIHRoYXQgd2FzIAorcHJvdmlkZWQgd2l0aCB0aGUgQ29udGVudC4gIElmIG5vIHN1Y2ggbGljZW5zZSBleGlzdHMsIGNvbnRhY3QgdGhlIFJlZGlzdHJpYnV0b3IuICBVbmxlc3Mgb3RoZXJ3aXNlCitpbmRpY2F0ZWQgYmVsb3csIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRVBMIHN0aWxsIGFwcGx5IHRvIGFueSBzb3VyY2UgY29kZSBpbiB0aGUgQ29udGVudAorYW5kIHN1Y2ggc291cmNlIGNvZGUgbWF5IGJlIG9idGFpbmVkIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnPC9hPi48L3A+CisKKzwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvYWJvdXQuaW5pIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL2Fib3V0LmluaQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43ZGY2NzFmCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL2Fib3V0LmluaQpAQCAtMCwwICsxLDE3IEBACisjIGFib3V0LmluaQorIyBjb250YWlucyBpbmZvcm1hdGlvbiBhYm91dCBhIGZlYXR1cmUKKyMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKKyMgIiVrZXkiIGFyZSBleHRlcm5hbGl6ZWQgc3RyaW5ncyBkZWZpbmVkIGluIGFib3V0LnByb3BlcnRpZXMKKyMgVGhpcyBmaWxlIGRvZXMgbm90IG5lZWQgdG8gYmUgdHJhbnNsYXRlZC4KKworIyBQcm9wZXJ0eSAiYWJvdXRUZXh0IiBjb250YWlucyBibHVyYiBmb3IgIkFib3V0IiBkaWFsb2cgKHRyYW5zbGF0ZWQpCithYm91dFRleHQ9JWZlYXR1cmVUZXh0CisKKyMgUHJvcGVydHkgImZlYXR1cmVJbWFnZSIgY29udGFpbnMgcGF0aCB0byBmZWF0dXJlIGltYWdlICgzMngzMikKK2ZlYXR1cmVJbWFnZT0KKworIyBQcm9wZXJ0eSAiYXBwTmFtZSIgY29udGFpbnMgbmFtZSBvZiB0aGUgYXBwbGljYXRpb24gKHRyYW5zbGF0ZWQpCithcHBOYW1lPSVmZWF0dXJlTmFtZQorCisjIFByb3BlcnR5ICJ3ZWxjb21lUGFnZSIgY29udGFpbnMgcGF0aCB0byB3ZWxjb21lIHBhZ2UgKHNwZWNpYWwgWE1MLWJhc2VkIGZvcm1hdCkKK3dlbGNvbWVQYWdlPQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL2Fib3V0Lm1hcHBpbmdzIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL2Fib3V0Lm1hcHBpbmdzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQ1MTFhMGEKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvYWJvdXQubWFwcGluZ3MKQEAgLTAsMCArMSw2IEBACisjIGFib3V0Lm1hcHBpbmdzCisjIGNvbnRhaW5zIGZpbGwtaW5zIGZvciBhYm91dC5wcm9wZXJ0aWVzCisjIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCisjIFRoaXMgZmlsZSBkb2VzIG5vdCBuZWVkIHRvIGJlIHRyYW5zbGF0ZWQuCisKKzA9cXVhbGlmaWVyCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvYWJvdXQucHJvcGVydGllcyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3Blci9hYm91dC5wcm9wZXJ0aWVzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmUwNjBhOTQKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvYWJvdXQucHJvcGVydGllcwpAQCAtMCwwICsxLDI2IEBACisjCisjIENvcHlyaWdodCAoYykgMjAxMiwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKEhlaWRlbGJlcmcpCisjIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCisjIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisjIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisjCisjIENvbnRyaWJ1dG9yczoKKyMgICAgTG9ldHogR21iSCZDby5LRyAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgorIworCisjIE5MU19NRVNTQUdFRk9STUFUX1ZBUgorCitmZWF0dXJlTmFtZT1vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIKKworIyMjIyMjIyMjIyMjIyMjIyBibHVyYiBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKK2ZlYXR1cmVUZXh0PVwKK0NvcHlyaWdodCAoYykgMjAxMi0yMDE2IC0gTG9ldHogR21iSCZDby5LRyBcblwKK0FsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHNcblwKK2FyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMFxuXAord2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXRcblwKK2h0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sXG5cCitcblwKK0NvbnRyaWJ1dG9yczpcblwKKyAgICBMb2V0eiBHbWJIJkNvLktHIC0gaW1wbGVtZW50YXRpb25cbgorIyMjIyMjIyMjIyMjIyMjIyBlbmQgb2YgYmx1cmIgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvYnVpbGQucHJvcGVydGllcyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3Blci9idWlsZC5wcm9wZXJ0aWVzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmI4ZjViMDcKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvYnVpbGQucHJvcGVydGllcwpAQCAtMCwwICsxLDkgQEAKK3NvdXJjZS4uID0gc3JjLworb3V0cHV0Li4gPSBiaW4vCitiaW4uaW5jbHVkZXMgPSBhYm91dC5wcm9wZXJ0aWVzLCAgYWJvdXQubWFwcGluZ3MsICBhYm91dC5pbmksICBhYm91dC5odG1sLCAgTUVUQS1JTkYvLFwKKyAgICAgICAgICAgICAgIC4sXAorICAgICAgICAgICAgICAgcGx1Z2luLnhtbCxcCisgICAgICAgICAgICAgICBMSUNFTlNFLnR4dCxcCisgICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwKK3NyYy5pbmNsdWRlcyA9IGFib3V0LnByb3BlcnRpZXMsICBhYm91dC5tYXBwaW5ncywgIGFib3V0LmluaSwgIGFib3V0Lmh0bWwsICBMSUNFTlNFLnR4dCxcCisgICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3Blci9saWNlbnNlLmh0bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvbGljZW5zZS5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmMzM2Q0NWMKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvbGljZW5zZS5odG1sCkBAIC0wLDAgKzEsMTA5IEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJJU08tODg1OS0xIiA/PgorPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgU3RyaWN0Ly9FTiIgImh0dHA6Ly93d3cudzMub3JnL1RSL3hodG1sMS9EVEQveGh0bWwxLXN0cmljdC5kdGQiPgorPCEtLSBzYXZlZCBmcm9tIHVybD0oMDA0NClodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC9ub3RpY2UuaHRtbCAtLT4KKzxodG1sIHhtbG5zPSJodHRwOi8vd3d3LnczLm9yZy8xOTk5L3hodG1sIj4KKzxoZWFkPgorPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9SVNPLTg4NTktMSIgLz4KKzx0aXRsZT5FY2xpcHNlIEZvdW5kYXRpb24gU29mdHdhcmUgVXNlciBBZ3JlZW1lbnQ8L3RpdGxlPgorPC9oZWFkPgorCis8Ym9keSBsYW5nPSJFTi1VUyI+Cis8aDI+RWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC9oMj4KKzxwPkZlYnJ1YXJ5IDEsIDIwMTE8L3A+CisKKzxoMz5Vc2FnZSBPZiBDb250ZW50PC9oMz4KKworPHA+VEhFIEVDTElQU0UgRk9VTkRBVElPTiBNQUtFUyBBVkFJTEFCTEUgU09GVFdBUkUsIERPQ1VNRU5UQVRJT04sIElORk9STUFUSU9OIEFORC9PUiBPVEhFUiBNQVRFUklBTFMgRk9SIE9QRU4gU09VUkNFIFBST0pFQ1RTCisgICAoQ09MTEVDVElWRUxZICZxdW90O0NPTlRFTlQmcXVvdDspLiAgVVNFIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQvT1IgVEhFIFRFUk1TIEFORAorICAgQ09ORElUSU9OUyBPRiBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVy4gIEJZIFVTSU5HIFRIRSBDT05URU5ULCBZT1UgQUdSRUUgVEhBVCBZT1VSIFVTRQorICAgT0YgVEhFIENPTlRFTlQgSVMgR09WRVJORUQgQlkgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IKKyAgIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBJRiBZT1UgRE8gTk9UIEFHUkVFIFRPIFRIRSBURVJNUyBBTkQgQ09ORElUSU9OUyBPRiBUSElTIEFHUkVFTUVOVCBBTkQgVEhFIFRFUk1TIEFORAorICAgQ09ORElUSU9OUyBPRiBBTlkgQVBQTElDQUJMRSBMSUNFTlNFIEFHUkVFTUVOVFMgT1IgTk9USUNFUyBJTkRJQ0FURUQgT1IgUkVGRVJFTkNFRCBCRUxPVywgVEhFTiBZT1UgTUFZIE5PVCBVU0UgVEhFIENPTlRFTlQuPC9wPgorCis8aDM+QXBwbGljYWJsZSBMaWNlbnNlczwvaDM+CisKKzxwPlVubGVzcyBvdGhlcndpc2UgaW5kaWNhdGVkLCBhbGwgQ29udGVudCBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIHByb3ZpZGVkIHRvIHlvdSB1bmRlciB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAKKyAgICgmcXVvdDtFUEwmcXVvdDspLiAgQSBjb3B5IG9mIHRoZSBFUEwgaXMgcHJvdmlkZWQgd2l0aCB0aGlzIENvbnRlbnQgYW5kIGlzIGFsc28gYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT4uCisgICBGb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgJnF1b3Q7UHJvZ3JhbSZxdW90OyB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9wPgorCis8cD5Db250ZW50IGluY2x1ZGVzLCBidXQgaXMgbm90IGxpbWl0ZWQgdG8sIHNvdXJjZSBjb2RlLCBvYmplY3QgY29kZSwgZG9jdW1lbnRhdGlvbiBhbmQgb3RoZXIgZmlsZXMgbWFpbnRhaW5lZCBpbiB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIHNvdXJjZSBjb2RlCisgICByZXBvc2l0b3J5ICgmcXVvdDtSZXBvc2l0b3J5JnF1b3Q7KSBpbiBzb2Z0d2FyZSBtb2R1bGVzICgmcXVvdDtNb2R1bGVzJnF1b3Q7KSBhbmQgbWFkZSBhdmFpbGFibGUgYXMgZG93bmxvYWRhYmxlIGFyY2hpdmVzICgmcXVvdDtEb3dubG9hZHMmcXVvdDspLjwvcD4KKworPHVsPgorICAgICAgIDxsaT5Db250ZW50IG1heSBiZSBzdHJ1Y3R1cmVkIGFuZCBwYWNrYWdlZCBpbnRvIG1vZHVsZXMgdG8gZmFjaWxpdGF0ZSBkZWxpdmVyaW5nLCBleHRlbmRpbmcsIGFuZCB1cGdyYWRpbmcgdGhlIENvbnRlbnQuICBUeXBpY2FsIG1vZHVsZXMgbWF5IGluY2x1ZGUgcGx1Zy1pbnMgKCZxdW90O1BsdWctaW5zJnF1b3Q7KSwgcGx1Zy1pbiBmcmFnbWVudHMgKCZxdW90O0ZyYWdtZW50cyZxdW90OyksIGFuZCBmZWF0dXJlcyAoJnF1b3Q7RmVhdHVyZXMmcXVvdDspLjwvbGk+CisgICAgICAgPGxpPkVhY2ggUGx1Zy1pbiBvciBGcmFnbWVudCBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IG9yIEpBUiAoSmF2YSZ0cmFkZTsgQVJjaGl2ZSkgaW4gYSBkaXJlY3RvcnkgbmFtZWQgJnF1b3Q7cGx1Z2lucyZxdW90Oy48L2xpPgorICAgICAgIDxsaT5BIEZlYXR1cmUgaXMgYSBidW5kbGUgb2Ygb25lIG9yIG1vcmUgUGx1Zy1pbnMgYW5kL29yIEZyYWdtZW50cyBhbmQgYXNzb2NpYXRlZCBtYXRlcmlhbC4gIEVhY2ggRmVhdHVyZSBtYXkgYmUgcGFja2FnZWQgYXMgYSBzdWItZGlyZWN0b3J5IGluIGEgZGlyZWN0b3J5IG5hbWVkICZxdW90O2ZlYXR1cmVzJnF1b3Q7LiAgV2l0aGluIGEgRmVhdHVyZSwgZmlsZXMgbmFtZWQgJnF1b3Q7ZmVhdHVyZS54bWwmcXVvdDsgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIHRoZSBQbHVnLWlucworICAgICAgYW5kL29yIEZyYWdtZW50cyBhc3NvY2lhdGVkIHdpdGggdGhhdCBGZWF0dXJlLjwvbGk+CisgICAgICAgPGxpPkZlYXR1cmVzIG1heSBhbHNvIGluY2x1ZGUgb3RoZXIgRmVhdHVyZXMgKCZxdW90O0luY2x1ZGVkIEZlYXR1cmVzJnF1b3Q7KS4gV2l0aGluIGEgRmVhdHVyZSwgZmlsZXMgbmFtZWQgJnF1b3Q7ZmVhdHVyZS54bWwmcXVvdDsgbWF5IGNvbnRhaW4gYSBsaXN0IG9mIHRoZSBuYW1lcyBhbmQgdmVyc2lvbiBudW1iZXJzIG9mIEluY2x1ZGVkIEZlYXR1cmVzLjwvbGk+Cis8L3VsPgorCis8cD5UaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIFBsdWctaW5zIGFuZCBGcmFnbWVudHMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAmcXVvdDthYm91dC5odG1sJnF1b3Q7ICgmcXVvdDtBYm91dHMmcXVvdDspLiBUaGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIEZlYXR1cmVzIGFuZAorSW5jbHVkZWQgRmVhdHVyZXMgc2hvdWxkIGJlIGNvbnRhaW5lZCBpbiBmaWxlcyBuYW1lZCAmcXVvdDtsaWNlbnNlLmh0bWwmcXVvdDsgKCZxdW90O0ZlYXR1cmUgTGljZW5zZXMmcXVvdDspLiAgQWJvdXRzIGFuZCBGZWF0dXJlIExpY2Vuc2VzIG1heSBiZSBsb2NhdGVkIGluIGFueSBkaXJlY3Rvcnkgb2YgYSBEb3dubG9hZCBvciBNb2R1bGUKK2luY2x1ZGluZywgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSBmb2xsb3dpbmcgbG9jYXRpb25zOjwvcD4KKworPHVsPgorICAgICAgIDxsaT5UaGUgdG9wLWxldmVsIChyb290KSBkaXJlY3Rvcnk8L2xpPgorICAgICAgIDxsaT5QbHVnLWluIGFuZCBGcmFnbWVudCBkaXJlY3RvcmllczwvbGk+CisgICAgICAgPGxpPkluc2lkZSBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHBhY2thZ2VkIGFzIEpBUnM8L2xpPgorICAgICAgIDxsaT5TdWItZGlyZWN0b3JpZXMgb2YgdGhlIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtzcmMmcXVvdDsgb2YgY2VydGFpbiBQbHVnLWluczwvbGk+CisgICAgICAgPGxpPkZlYXR1cmUgZGlyZWN0b3JpZXM8L2xpPgorPC91bD4KKworPHA+Tm90ZTogaWYgYSBGZWF0dXJlIG1hZGUgYXZhaWxhYmxlIGJ5IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gaXMgaW5zdGFsbGVkIHVzaW5nIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSAoYXMgZGVmaW5lZCBiZWxvdyksIHlvdSBtdXN0IGFncmVlIHRvIGEgbGljZW5zZSAoJnF1b3Q7RmVhdHVyZSBVcGRhdGUgTGljZW5zZSZxdW90OykgZHVyaW5nIHRoZQoraW5zdGFsbGF0aW9uIHByb2Nlc3MuICBJZiB0aGUgRmVhdHVyZSBjb250YWlucyBJbmNsdWRlZCBGZWF0dXJlcywgdGhlIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2Ugc2hvdWxkIGVpdGhlciBwcm92aWRlIHlvdSB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm5pbmcgdGhlIEluY2x1ZGVkIEZlYXR1cmVzIG9yCitpbmZvcm0geW91IHdoZXJlIHlvdSBjYW4gbG9jYXRlIHRoZW0uICBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBtYXkgYmUgZm91bmQgaW4gdGhlICZxdW90O2xpY2Vuc2UmcXVvdDsgcHJvcGVydHkgb2YgZmlsZXMgbmFtZWQgJnF1b3Q7ZmVhdHVyZS5wcm9wZXJ0aWVzJnF1b3Q7IGZvdW5kIHdpdGhpbiBhIEZlYXR1cmUuCitTdWNoIEFib3V0cywgRmVhdHVyZSBMaWNlbnNlcywgYW5kIEZlYXR1cmUgVXBkYXRlIExpY2Vuc2VzIGNvbnRhaW4gdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIChvciByZWZlcmVuY2VzIHRvIHN1Y2ggdGVybXMgYW5kIGNvbmRpdGlvbnMpIHRoYXQgZ292ZXJuIHlvdXIgdXNlIG9mIHRoZSBhc3NvY2lhdGVkIENvbnRlbnQgaW4KK3RoYXQgZGlyZWN0b3J5LjwvcD4KKworPHA+VEhFIEFCT1VUUywgRkVBVFVSRSBMSUNFTlNFUywgQU5EIEZFQVRVUkUgVVBEQVRFIExJQ0VOU0VTIE1BWSBSRUZFUiBUTyBUSEUgRVBMIE9SIE9USEVSIExJQ0VOU0UgQUdSRUVNRU5UUywgTk9USUNFUyBPUiBURVJNUyBBTkQgQ09ORElUSU9OUy4gIFNPTUUgT0YgVEhFU0UKK09USEVSIExJQ0VOU0UgQUdSRUVNRU5UUyBNQVkgSU5DTFVERSAoQlVUIEFSRSBOT1QgTElNSVRFRCBUTyk6PC9wPgorCis8dWw+CisgICAgICAgPGxpPkVjbGlwc2UgRGlzdHJpYnV0aW9uIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xpY2Vuc2VzL2VkbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9saWNlbnNlcy9lZGwtdjEuMC5odG1sPC9hPik8L2xpPgorICAgICAgIDxsaT5Db21tb24gUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2NwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWw8L2E+KTwvbGk+CisgICAgICAgPGxpPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRTwvYT4pPC9saT4KKyAgICAgICA8bGk+QXBhY2hlIFNvZnR3YXJlIExpY2Vuc2UgMi4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wIj5odHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRS0yLjA8L2E+KTwvbGk+CisgICAgICAgPGxpPk1ldHJvIExpbmsgUHVibGljIExpY2Vuc2UgMS4wMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cub3Blbmdyb3VwLm9yZy9vcGVubW90aWYvc3VwcG9ydGVycy9tZXRyb2xpbmsvbGljZW5zZS5odG1sIj5odHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbDwvYT4pPC9saT4KKyAgICAgICA8bGk+TW96aWxsYSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMSAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbCI+aHR0cDovL3d3dy5tb3ppbGxhLm9yZy9NUEwvTVBMLTEuMS5odG1sPC9hPik8L2xpPgorPC91bD4KKworPHA+SVQgSVMgWU9VUiBPQkxJR0FUSU9OIFRPIFJFQUQgQU5EIEFDQ0VQVCBBTEwgU1VDSCBURVJNUyBBTkQgQ09ORElUSU9OUyBQUklPUiBUTyBVU0UgT0YgVEhFIENPTlRFTlQuICBJZiBubyBBYm91dCwgRmVhdHVyZSBMaWNlbnNlLCBvciBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIGlzIHByb3ZpZGVkLCBwbGVhc2UKK2NvbnRhY3QgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiB0byBkZXRlcm1pbmUgd2hhdCB0ZXJtcyBhbmQgY29uZGl0aW9ucyBnb3Zlcm4gdGhhdCBwYXJ0aWN1bGFyIENvbnRlbnQuPC9wPgorCisKKzxoMz5Vc2Ugb2YgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3k8L2gzPgorCis8cD5UaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1ha2VzIGF2YWlsYWJsZSBwcm92aXNpb25pbmcgc29mdHdhcmUsIGV4YW1wbGVzIG9mIHdoaWNoIGluY2x1ZGUsIGJ1dCBhcmUgbm90IGxpbWl0ZWQgdG8sIHAyIGFuZCB0aGUgRWNsaXBzZQorICAgVXBkYXRlIE1hbmFnZXIgKCZxdW90O1Byb3Zpc2lvbmluZyBUZWNobm9sb2d5JnF1b3Q7KSBmb3IgdGhlIHB1cnBvc2Ugb2YgYWxsb3dpbmcgdXNlcnMgdG8gaW5zdGFsbCBzb2Z0d2FyZSwgZG9jdW1lbnRhdGlvbiwgaW5mb3JtYXRpb24gYW5kL29yCisgICBvdGhlciBtYXRlcmlhbHMgKGNvbGxlY3RpdmVseSAmcXVvdDtJbnN0YWxsYWJsZSBTb2Z0d2FyZSZxdW90OykuIFRoaXMgY2FwYWJpbGl0eSBpcyBwcm92aWRlZCB3aXRoIHRoZSBpbnRlbnQgb2YgYWxsb3dpbmcgc3VjaCB1c2VycyB0bworICAgaW5zdGFsbCwgZXh0ZW5kIGFuZCB1cGRhdGUgRWNsaXBzZS1iYXNlZCBwcm9kdWN0cy4gSW5mb3JtYXRpb24gYWJvdXQgcGFja2FnaW5nIEluc3RhbGxhYmxlIFNvZnR3YXJlIGlzIGF2YWlsYWJsZSBhdCA8YQorICAgICAgIGhyZWY9Imh0dHA6Ly9lY2xpcHNlLm9yZy9lcXVpbm94L3AyL3JlcG9zaXRvcnlfcGFja2FnaW5nLmh0bWwiPmh0dHA6Ly9lY2xpcHNlLm9yZy9lcXVpbm94L3AyL3JlcG9zaXRvcnlfcGFja2FnaW5nLmh0bWw8L2E+CisgICAoJnF1b3Q7U3BlY2lmaWNhdGlvbiZxdW90OykuPC9wPgorCis8cD5Zb3UgbWF5IHVzZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neSB0byBhbGxvdyBvdGhlciBwYXJ0aWVzIHRvIGluc3RhbGwgSW5zdGFsbGFibGUgU29mdHdhcmUuIFlvdSBzaGFsbCBiZSByZXNwb25zaWJsZSBmb3IgZW5hYmxpbmcgdGhlCisgICBhcHBsaWNhYmxlIGxpY2Vuc2UgYWdyZWVtZW50cyByZWxhdGluZyB0byB0aGUgSW5zdGFsbGFibGUgU29mdHdhcmUgdG8gYmUgcHJlc2VudGVkIHRvLCBhbmQgYWNjZXB0ZWQgYnksIHRoZSB1c2VycyBvZiB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kKKyAgIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgU3BlY2lmaWNhdGlvbi4gQnkgdXNpbmcgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgaW4gc3VjaCBhIG1hbm5lciBhbmQgbWFraW5nIGl0IGF2YWlsYWJsZSBpbiBhY2NvcmRhbmNlIHdpdGggdGhlCisgICBTcGVjaWZpY2F0aW9uLCB5b3UgZnVydGhlciBhY2tub3dsZWRnZSB5b3VyIGFncmVlbWVudCB0bywgYW5kIHRoZSBhY3F1aXNpdGlvbiBvZiBhbGwgbmVjZXNzYXJ5IHJpZ2h0cyB0byBwZXJtaXQgdGhlIGZvbGxvd2luZzo8L3A+CisKKzxvbD4KKyAgICAgICA8bGk+QSBzZXJpZXMgb2YgYWN0aW9ucyBtYXkgb2NjdXIgKCZxdW90O1Byb3Zpc2lvbmluZyBQcm9jZXNzJnF1b3Q7KSBpbiB3aGljaCBhIHVzZXIgbWF5IGV4ZWN1dGUgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5CisgICAgICAgb24gYSBtYWNoaW5lICgmcXVvdDtUYXJnZXQgTWFjaGluZSZxdW90Oykgd2l0aCB0aGUgaW50ZW50IG9mIGluc3RhbGxpbmcsIGV4dGVuZGluZyBvciB1cGRhdGluZyB0aGUgZnVuY3Rpb25hbGl0eSBvZiBhbiBFY2xpcHNlLWJhc2VkCisgICAgICAgcHJvZHVjdC48L2xpPgorICAgICAgIDxsaT5EdXJpbmcgdGhlIFByb3Zpc2lvbmluZyBQcm9jZXNzLCB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgbWF5IGNhdXNlIHRoaXJkIHBhcnR5IEluc3RhbGxhYmxlIFNvZnR3YXJlIG9yIGEgcG9ydGlvbiB0aGVyZW9mIHRvIGJlCisgICAgICAgYWNjZXNzZWQgYW5kIGNvcGllZCB0byB0aGUgVGFyZ2V0IE1hY2hpbmUuPC9saT4KKyAgICAgICA8bGk+UHVyc3VhbnQgdG8gdGhlIFNwZWNpZmljYXRpb24sIHlvdSB3aWxsIHByb3ZpZGUgdG8gdGhlIHVzZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIHRoYXQgZ292ZXJuIHRoZSB1c2Ugb2YgdGhlIEluc3RhbGxhYmxlCisgICAgICAgU29mdHdhcmUgKCZxdW90O0luc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCZxdW90OykgYW5kIHN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50IHNoYWxsIGJlIGFjY2Vzc2VkIGZyb20gdGhlIFRhcmdldAorICAgICAgIE1hY2hpbmUgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZSBTcGVjaWZpY2F0aW9uLiBTdWNoIEluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCBtdXN0IGluZm9ybSB0aGUgdXNlciBvZiB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgdGhhdCBnb3Zlcm4KKyAgICAgICB0aGUgSW5zdGFsbGFibGUgU29mdHdhcmUgYW5kIG11c3Qgc29saWNpdCBhY2NlcHRhbmNlIGJ5IHRoZSBlbmQgdXNlciBpbiB0aGUgbWFubmVyIHByZXNjcmliZWQgaW4gc3VjaCBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQuIFVwb24gc3VjaAorICAgICAgIGluZGljYXRpb24gb2YgYWdyZWVtZW50IGJ5IHRoZSB1c2VyLCB0aGUgcHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgd2lsbCBjb21wbGV0ZSBpbnN0YWxsYXRpb24gb2YgdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlLjwvbGk+Cis8L29sPgorCis8aDM+Q3J5cHRvZ3JhcGh5PC9oMz4KKworPHA+Q29udGVudCBtYXkgY29udGFpbiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBUaGUgY291bnRyeSBpbiB3aGljaCB5b3UgYXJlIGN1cnJlbnRseSBtYXkgaGF2ZSByZXN0cmljdGlvbnMgb24gdGhlIGltcG9ydCwgcG9zc2Vzc2lvbiwgYW5kIHVzZSwgYW5kL29yIHJlLWV4cG9ydCB0bworICAgYW5vdGhlciBjb3VudHJ5LCBvZiBlbmNyeXB0aW9uIHNvZnR3YXJlLiBCRUZPUkUgdXNpbmcgYW55IGVuY3J5cHRpb24gc29mdHdhcmUsIHBsZWFzZSBjaGVjayB0aGUgY291bnRyeSdzIGxhd3MsIHJlZ3VsYXRpb25zIGFuZCBwb2xpY2llcyBjb25jZXJuaW5nIHRoZSBpbXBvcnQsCisgICBwb3NzZXNzaW9uLCBvciB1c2UsIGFuZCByZS1leHBvcnQgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZSwgdG8gc2VlIGlmIHRoaXMgaXMgcGVybWl0dGVkLjwvcD4KKworPHA+PHNtYWxsPkphdmEgYW5kIGFsbCBKYXZhLWJhc2VkIHRyYWRlbWFya3MgYXJlIHRyYWRlbWFya3Mgb2YgT3JhY2xlIENvcnBvcmF0aW9uIGluIHRoZSBVbml0ZWQgU3RhdGVzLCBvdGhlciBjb3VudHJpZXMsIG9yIGJvdGguPC9zbWFsbD48L3A+Cis8L2JvZHk+Cis8L2h0bWw+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL3BsdWdpbi54bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvcGx1Z2luLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kMzg2MDU3Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL3BsdWdpbi54bWwKQEAgLTAsMCArMSwzMCBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KKzw/ZWNsaXBzZSB2ZXJzaW9uPSIzLjQiPz4KKzxwbHVnaW4+CisgICA8ZXh0ZW5zaW9uCisgICAgICAgICBwb2ludD0ib3JnLmVjbGlwc2UudWkucG9wdXBNZW51cyI+CisgICAgICA8b2JqZWN0Q29udHJpYnV0aW9uCisgICAgICAgICAgICBhZGFwdGFibGU9InRydWUiCisgICAgICAgICAgICBpZD0ib3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyLnVwZGF0ZURlcFZlcnNpb24iCisgICAgICAgICAgICBvYmplY3RDbGFzcz0ib3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVByb2plY3QiPgorICAgICAgICAgPGFjdGlvbgorICAgICAgICAgICAgICAgY2xhc3M9Im9yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3Blci5VcGRhdGVEZXBlbmRlbmN5VmVyc2lvbnMiCisgICAgICAgICAgICAgICBpZD0ib3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyLlVwZGF0ZURlcFZlcnNpb24iCisgICAgICAgICAgICAgICBsYWJlbD0iVXBkYXRlIGRlcGVuZGVuY3kgdmVyc2lvbnMiCisgICAgICAgICAgICAgICBtZW51YmFyUGF0aD0ib3JnLmVjbGlwc2UudWkucHJvamVjdENvbmZpZ3VyZS9hZGRpdGlvbnMiPgorICAgICAgICAgPC9hY3Rpb24+CisgICAgICA8L29iamVjdENvbnRyaWJ1dGlvbj4KKyAgICAgIDxvYmplY3RDb250cmlidXRpb24KKyAgICAgICAgICAgIGFkYXB0YWJsZT0idHJ1ZSIKKyAgICAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIudXBkYXRlQXJ0aWZhY3RWZXJzaW9uIgorICAgICAgICAgICAgb2JqZWN0Q2xhc3M9Im9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklQcm9qZWN0Ij4KKyAgICAgICAgIDxhY3Rpb24KKyAgICAgICAgICAgICAgIGNsYXNzPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIuVXBkYXRlQXJ0aWZhY3RWZXJzaW9ucyIKKyAgICAgICAgICAgICAgIGlkPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIuVXBkYXRlQXJ0aWZhY3RWZXJzaW9uIgorICAgICAgICAgICAgICAgbGFiZWw9IlVwZGF0ZSBhcnRpZmFjdCB2ZXJzaW9ucyIKKyAgICAgICAgICAgICAgIG1lbnViYXJQYXRoPSJvcmcuZWNsaXBzZS51aS5wcm9qZWN0Q29uZmlndXJlL2FkZGl0aW9ucyI+CisgICAgICAgICA8L2FjdGlvbj4KKyAgICAgIDwvb2JqZWN0Q29udHJpYnV0aW9uPgorICAgPC9leHRlbnNpb24+CisKKzwvcGx1Z2luPgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL3BvbS54bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvcG9tLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42ZDhjYzk5Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL3BvbS54bWwKQEAgLTAsMCArMSwyMyBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KKzwhLS0jPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gLS0+Cis8IS0tIyBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMdW5pZmVyYSBHbWJIIChHcm9zcyBFbnplcnNkb3JmKSwgTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkgLS0+Cis8IS0tIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIC0tPgorPCEtLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIC0tPgorPCEtLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgLS0+Cis8IS0tIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAtLT4KKzwhLS0jIC0tPgorPCEtLSMgQ29udHJpYnV0b3JzOiAtLT4KKzwhLS0jICAgICBLbGVtZW5zIEVkbGVyIChMdW5pZmVyYSBHbWJIKSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiAtLT4KKzwhLS0jPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gLS0+CisKKzxwcm9qZWN0IHhtbG5zPSJodHRwOi8vbWF2ZW4uYXBhY2hlLm9yZy9QT00vNC4wLjAiIHhtbG5zOnhzaT0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEtaW5zdGFuY2UiIHhzaTpzY2hlbWFMb2NhdGlvbj0iaHR0cDovL21hdmVuLmFwYWNoZS5vcmcvUE9NLzQuMC4wIGh0dHA6Ly9tYXZlbi5hcGFjaGUub3JnL3hzZC9tYXZlbi00LjAuMC54c2QiPgorICAgIDxtb2RlbFZlcnNpb24+NC4wLjA8L21vZGVsVmVyc2lvbj4KKyAgICA8cGFyZW50PgorICAgICAgICA8Z3JvdXBJZD5vcmcuZWNsaXBzZS5vc2JwLmlkZTwvZ3JvdXBJZD4KKyAgICAgICAgPGFydGlmYWN0SWQ+b3JnLmVjbGlwc2Uub3NicC5pZGU8L2FydGlmYWN0SWQ+CisgICAgICAgIDx2ZXJzaW9uPjAuOS4wLVNOQVBTSE9UPC92ZXJzaW9uPgorICAgIDwvcGFyZW50PgorICAgIDxhcnRpZmFjdElkPm9yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3BlcjwvYXJ0aWZhY3RJZD4KKyAgICA8cGFja2FnaW5nPmVjbGlwc2UtcGx1Z2luPC9wYWNrYWdpbmc+CisKKzwvcHJvamVjdD4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3Blci9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvdG9vbHMvZGV2ZWxvcGVyL0FjdGl2YXRvci5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS90b29scy9kZXZlbG9wZXIvQWN0aXZhdG9yLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZTlmYjkxNgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3Blci9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvdG9vbHMvZGV2ZWxvcGVyL0FjdGl2YXRvci5qYXZhCkBAIC0wLDAgKzEsNjEgQEAKKy8qKgorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE1IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiwgQXVzdHJpYSksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorICoKKyAqIENvbnRyaWJ1dG9yczoKKyAqICAgICAgICAgRmxvcmlhbiBQaXJjaG5lciAtIEluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqLworCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3BlcjsKKworaW1wb3J0IG9yZy5lY2xpcHNlLnVpLnBsdWdpbi5BYnN0cmFjdFVJUGx1Z2luOworaW1wb3J0IG9yZy5vc2dpLmZyYW1ld29yay5CdW5kbGVDb250ZXh0OworCisvKioKKyAqIFRoZSBhY3RpdmF0b3IgY2xhc3MgY29udHJvbHMgdGhlIHBsdWctaW4gbGlmZSBjeWNsZQorICovCitwdWJsaWMgY2xhc3MgQWN0aXZhdG9yIGV4dGVuZHMgQWJzdHJhY3RVSVBsdWdpbiB7CisKKwkvLyBUaGUgcGx1Zy1pbiBJRAorCXB1YmxpYyBzdGF0aWMgZmluYWwgU3RyaW5nIFBMVUdJTl9JRCA9ICJvcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIiOyAvLyROT04tTkxTLTEkCisKKwkvLyBUaGUgc2hhcmVkIGluc3RhbmNlCisJcHJpdmF0ZSBzdGF0aWMgQWN0aXZhdG9yIHBsdWdpbjsKKwkKKwkvKioKKwkgKiBUaGUgY29uc3RydWN0b3IKKwkgKi8KKwlwdWJsaWMgQWN0aXZhdG9yKCkgeworCX0KKworCS8qCisJICogKG5vbi1KYXZhZG9jKQorCSAqIEBzZWUgb3JnLmVjbGlwc2UudWkucGx1Z2luLkFic3RyYWN0VUlQbHVnaW4jc3RhcnQob3JnLm9zZ2kuZnJhbWV3b3JrLkJ1bmRsZUNvbnRleHQpCisJICovCisJcHVibGljIHZvaWQgc3RhcnQoQnVuZGxlQ29udGV4dCBjb250ZXh0KSB0aHJvd3MgRXhjZXB0aW9uIHsKKwkJc3VwZXIuc3RhcnQoY29udGV4dCk7CisJCXBsdWdpbiA9IHRoaXM7CisJfQorCisJLyoKKwkgKiAobm9uLUphdmFkb2MpCisJICogQHNlZSBvcmcuZWNsaXBzZS51aS5wbHVnaW4uQWJzdHJhY3RVSVBsdWdpbiNzdG9wKG9yZy5vc2dpLmZyYW1ld29yay5CdW5kbGVDb250ZXh0KQorCSAqLworCXB1YmxpYyB2b2lkIHN0b3AoQnVuZGxlQ29udGV4dCBjb250ZXh0KSB0aHJvd3MgRXhjZXB0aW9uIHsKKwkJcGx1Z2luID0gbnVsbDsKKwkJc3VwZXIuc3RvcChjb250ZXh0KTsKKwl9CisKKwkvKioKKwkgKiBSZXR1cm5zIHRoZSBzaGFyZWQgaW5zdGFuY2UKKwkgKgorCSAqIEByZXR1cm4gdGhlIHNoYXJlZCBpbnN0YW5jZQorCSAqLworCXB1YmxpYyBzdGF0aWMgQWN0aXZhdG9yIGdldERlZmF1bHQoKSB7CisJCXJldHVybiBwbHVnaW47CisJfQorCit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL3Rvb2xzL2RldmVsb3Blci9BcnRpZmFjdFZlcnNpb25VcGRhdGUuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3Blci9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvdG9vbHMvZGV2ZWxvcGVyL0FydGlmYWN0VmVyc2lvblVwZGF0ZS5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjgzMTdmNjcKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL3Rvb2xzL2RldmVsb3Blci9BcnRpZmFjdFZlcnNpb25VcGRhdGUuamF2YQpAQCAtMCwwICsxLDMyMyBAQAorLyoqCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTUgLSBMdW5pZmVyYSBHbWJIIChHcm9zcyBFbnplcnNkb3JmLCBBdXN0cmlhKSwgTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisgKgorICogQ29udHJpYnV0b3JzOgorICogICAgICAgICBGbG9yaWFuIFBpcmNobmVyIC0gSW5pdGlhbCBpbXBsZW1lbnRhdGlvbgorICovCisKK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyOworCitpbXBvcnQgamF2YS5pby5CdWZmZXJlZFJlYWRlcjsKK2ltcG9ydCBqYXZhLmlvLkJ5dGVBcnJheUlucHV0U3RyZWFtOworaW1wb3J0IGphdmEuaW8uSU9FeGNlcHRpb247CitpbXBvcnQgamF2YS5pby5JbnB1dFN0cmVhbTsKK2ltcG9ydCBqYXZhLmlvLklucHV0U3RyZWFtUmVhZGVyOworaW1wb3J0IGphdmEudXRpbC5Qcm9wZXJ0aWVzOworCitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSUNvbnRhaW5lcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JRmlsZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JUHJvamVjdDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JUmVzb3VyY2U7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkNvcmVFeGNlcHRpb247CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLk51bGxQcm9ncmVzc01vbml0b3I7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLlBhdGg7CisKK3B1YmxpYyBjbGFzcyBBcnRpZmFjdFZlcnNpb25VcGRhdGUgeworCisJcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEZJTEVOQU1FID0gIi8uYXJ0aWZhY3RWZXJzaW9ucyI7CisJcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIFZFUlNJT05fT0xEX1ZFUlNJT05fUkVHRVggPSAiQnVuZGxlLVZlcnNpb246IFtcXHdcXC5dKiI7CisJcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIFZFUlNJT05fTkVXX1ZFUlNJT04gPSAiQnVuZGxlLVZlcnNpb246ICVzIjsKKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgRVhQT1JUUEFDS0FHRV9PTERfVkVSU0lPTl9SRUdFWCA9ICJ2ZXJzaW9uPVwiW1xcd1xcLl0qXCIiOworCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBFWFBPUlRQQUNLQUdFX05FV19WRVJTSU9OID0gInZlcnNpb249XCIlc1wiIjsKKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgUE9NX0FSVElGQUNUX09MRF9WRVJTSU9OX1JFR0VYID0gIjx2ZXJzaW9uPltcXHdcXC4tXSo8L3ZlcnNpb24+IjsKKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgUE9NX0FSVElGQUNUX05FV19WRVJTSU9OID0gIjx2ZXJzaW9uPiVzPC92ZXJzaW9uPiI7CisJcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIEZFQVRVUkVfT0xEX1ZFUlNJT05fUkVHRVggPSAidmVyc2lvbj1cIltcXHdcXC5dKlwiIjsKKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgRkVBVFVSRV9ORVdfVkVSU0lPTiA9ICJ2ZXJzaW9uPVwiJXNcIiI7CisKKwlwcml2YXRlIFN0cmluZyBwb21BcnRpZmFjdFZlcnNpb247CisJcHJpdmF0ZSBTdHJpbmcgcG9tUmVsZW5nVmVyc2lvbjsKKwlwcml2YXRlIFN0cmluZyBwb21SZWxlbmdQMlZlcnNpb247CisJcHJpdmF0ZSBTdHJpbmcgcG9tUmVsZW5nR3JvdXBJZDsKKworCXB1YmxpYyB2b2lkIGV4ZWN1dGUoSVByb2plY3QgYWdncmVnYXRvcikgdGhyb3dzIEV4Y2VwdGlvbiB7CisJCUlGaWxlIGZpbGUgPSBhZ2dyZWdhdG9yLmdldEZpbGUoRklMRU5BTUUpOworCQlpZiAoIWZpbGUuZXhpc3RzKCkpIHsKKwkJCXJldHVybjsKKwkJfQorCisJCVByb3BlcnRpZXMgcHJvcGVydGllcyA9IG5ldyBQcm9wZXJ0aWVzKCk7CisJCXByb3BlcnRpZXMubG9hZChmaWxlLmdldENvbnRlbnRzKCkpOworCisJCXBvbUFydGlmYWN0VmVyc2lvbiA9IHByb3BlcnRpZXMuZ2V0UHJvcGVydHkoInZlcnNpb24iKTsKKwkJcG9tUmVsZW5nVmVyc2lvbiA9IHByb3BlcnRpZXMuZ2V0UHJvcGVydHkoInJlbGVuZ1ZlcnNpb24iKTsKKwkJcG9tUmVsZW5nUDJWZXJzaW9uID0gcHJvcGVydGllcy5nZXRQcm9wZXJ0eSgicmVsZW5nUDJWZXJzaW9uIik7CisJCXBvbVJlbGVuZ0dyb3VwSWQgPSBwcm9wZXJ0aWVzLmdldFByb3BlcnR5KCJyZWxlbmdHcm91cElkIik7CisKKwkJcHJvY2Vzc1Byb2plY3QoYWdncmVnYXRvcik7CisKKwl9CisKKwlwcml2YXRlIGJvb2xlYW4gaXNTbmFwc2hvdChTdHJpbmcgdmVyc2lvbikgeworCQlyZXR1cm4gdmVyc2lvbi5lbmRzV2l0aCgiU05BUFNIT1QiKTsKKwl9CisKKwlwcml2YXRlIHZvaWQgcHJvY2Vzc1Byb2plY3QoSUNvbnRhaW5lciBwcm9qZWN0KSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiwKKwkJCUlPRXhjZXB0aW9uIHsKKworCQlJUmVzb3VyY2UgbWFuaWZlc3QgPSBwcm9qZWN0LmdldEZpbGUobmV3IFBhdGgoIi9NRVRBLUlORi9NQU5JRkVTVC5NRiIpKTsKKwkJaWYgKG1hbmlmZXN0ICE9IG51bGwgJiYgbWFuaWZlc3QuZXhpc3RzKCkpIHsKKwkJCXByb2Nlc3NNYW5pZmVzdCgoSUZpbGUpIG1hbmlmZXN0KTsKKwkJfQorCisJCUlSZXNvdXJjZSBwb20gPSBwcm9qZWN0LmdldEZpbGUobmV3IFBhdGgoIi9wb20ueG1sIikpOworCQlpZiAocG9tICE9IG51bGwgJiYgcG9tLmV4aXN0cygpKSB7CisJCQlwcm9jZXNzUG9tKChJRmlsZSkgcG9tKTsKKwkJfQorCisJCUlSZXNvdXJjZSBmZWF0dXJlWG1sID0gcHJvamVjdC5nZXRGaWxlKG5ldyBQYXRoKCIvZmVhdHVyZS54bWwiKSk7CisJCWlmIChmZWF0dXJlWG1sICE9IG51bGwgJiYgZmVhdHVyZVhtbC5leGlzdHMoKSkgeworCQkJcHJvY2Vzc0ZlYXR1cmVYbWwoKElGaWxlKSBmZWF0dXJlWG1sKTsKKwkJfQorCisJCWZvciAoSVJlc291cmNlIG1lbWJlciA6IHByb2plY3QubWVtYmVycygpKSB7CisJCQlpZiAobWVtYmVyIGluc3RhbmNlb2YgSUNvbnRhaW5lcikgeworCQkJCWlmIChpc0NoaWxkUHJvamVjdCgoSUNvbnRhaW5lcikgbWVtYmVyKSkgeworCQkJCQkvLyBwcm9jZXNzIGNoaWxkcmVuIHJlY3Vyc2l2ZWx5CisJCQkJCXByb2Nlc3NQcm9qZWN0KChJQ29udGFpbmVyKSBtZW1iZXIpOworCQkJCX0KKwkJCX0KKwkJfQorCisJfQorCisJcHJpdmF0ZSBib29sZWFuIGlzQ2hpbGRQcm9qZWN0KElDb250YWluZXIgbWVtYmVyKSB7CisJCUlSZXNvdXJjZSBwcm9qZWN0RmlsZSA9IG1lbWJlci5nZXRGaWxlKG5ldyBQYXRoKCIvLnByb2plY3QiKSk7CisJCXJldHVybiBwcm9qZWN0RmlsZSAhPSBudWxsICYmIHByb2plY3RGaWxlLmV4aXN0cygpOworCX0KKworCXByaXZhdGUgdm9pZCBwcm9jZXNzTWFuaWZlc3QoSUZpbGUgbWFuaWZlc3QpIHRocm93cyBDb3JlRXhjZXB0aW9uLAorCQkJSU9FeGNlcHRpb24geworCisJCVN0cmluZ0J1aWxkZXIgZmlsZUNvbnRlbnQgPSBnZW5lcmF0ZU1hbmlmZXN0KG1hbmlmZXN0KTsKKworCQltYW5pZmVzdC5zZXRDb250ZW50cyhuZXcgQnl0ZUFycmF5SW5wdXRTdHJlYW0oZmlsZUNvbnRlbnQudG9TdHJpbmcoKQorCQkJCS5nZXRCeXRlcygpKSwgdHJ1ZSwgdHJ1ZSwgbmV3IE51bGxQcm9ncmVzc01vbml0b3IoKSk7CisJfQorCisJcHJpdmF0ZSB2b2lkIHByb2Nlc3NQb20oSUZpbGUgcG9tKSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiwgSU9FeGNlcHRpb24geworCisJCVN0cmluZ0J1aWxkZXIgZmlsZUNvbnRlbnQgPSBnZW5lcmF0ZVBvbShwb20pOworCisJCXBvbS5zZXRDb250ZW50cyhuZXcgQnl0ZUFycmF5SW5wdXRTdHJlYW0oZmlsZUNvbnRlbnQudG9TdHJpbmcoKQorCQkJCS5nZXRCeXRlcygpKSwgdHJ1ZSwgdHJ1ZSwgbmV3IE51bGxQcm9ncmVzc01vbml0b3IoKSk7CisJfQorCisJcHJpdmF0ZSB2b2lkIHByb2Nlc3NGZWF0dXJlWG1sKElGaWxlIGZlYXR1cmVYbWwpIHRocm93cyBDb3JlRXhjZXB0aW9uLAorCQkJSU9FeGNlcHRpb24geworCisJCVN0cmluZ0J1aWxkZXIgZmlsZUNvbnRlbnQgPSBnZW5lcmF0ZUZlYXR1cmVYbWwoZmVhdHVyZVhtbCk7CisKKwkJZmVhdHVyZVhtbC5zZXRDb250ZW50cyhuZXcgQnl0ZUFycmF5SW5wdXRTdHJlYW0oZmlsZUNvbnRlbnQudG9TdHJpbmcoKQorCQkJCS5nZXRCeXRlcygpKSwgdHJ1ZSwgdHJ1ZSwgbmV3IE51bGxQcm9ncmVzc01vbml0b3IoKSk7CisJfQorCisJcHJpdmF0ZSBTdHJpbmdCdWlsZGVyIGdlbmVyYXRlTWFuaWZlc3QoSUZpbGUgbWFuaWZlc3QpCisJCQl0aHJvd3MgQ29yZUV4Y2VwdGlvbiwgSU9FeGNlcHRpb24geworCQkvLyBPcGVuIHRoZSBmaWxlCisJCUlucHV0U3RyZWFtIGlucHV0U3RyZWFtID0gbWFuaWZlc3QuZ2V0Q29udGVudHMoKTsKKwkJQnVmZmVyZWRSZWFkZXIgcmVhZGVyID0gbmV3IEJ1ZmZlcmVkUmVhZGVyKG5ldyBJbnB1dFN0cmVhbVJlYWRlcigKKwkJCQlpbnB1dFN0cmVhbSkpOworCQlTdHJpbmcgbGluZSA9IG51bGw7CisJCVN0cmluZyBuZXdMaW5lID0gbnVsbDsKKwkJU3RyaW5nQnVpbGRlciBmaWxlQ29udGVudCA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7CisJCWJvb2xlYW4gaW5FUCA9IGZhbHNlOworCisJCVN0cmluZyBzeW1ib2xpY05hbWUgPSBudWxsOworCQkvLyBSZWFkIGZpbGUgbGluZSBieSBsaW5lCisJCXdoaWxlICgobGluZSA9IHJlYWRlci5yZWFkTGluZSgpKSAhPSBudWxsKSB7CisJCQluZXdMaW5lID0gbGluZTsKKworCQkJaWYgKGxpbmUuc3RhcnRzV2l0aCgiQnVuZGxlLVN5bWJvbGljTmFtZSIpKSB7CisJCQkJc3ltYm9saWNOYW1lID0gKFN0cmluZykgbGluZS5zdWJTZXF1ZW5jZShsaW5lLmluZGV4T2YoIiAiKSArIDEsCisJCQkJCQlsaW5lLmNvbnRhaW5zKCI7IikgPyBsaW5lLmluZGV4T2YoIjsiKSA6IGxpbmUubGVuZ3RoKCkpOworCQkJCWluRVAgPSBmYWxzZTsKKwkJCX0gZWxzZSBpZiAobGluZS5zdGFydHNXaXRoKCJCdW5kbGUtVmVyc2lvbiIpKSB7CisJCQkJbmV3TGluZSA9IGxpbmUucmVwbGFjZUZpcnN0KFZFUlNJT05fT0xEX1ZFUlNJT05fUkVHRVgsCisJCQkJCQlTdHJpbmcuZm9ybWF0KFZFUlNJT05fTkVXX1ZFUlNJT04sIGdldE9TR2lWZXJzaW9uKCkpKTsKKwkJCQlpbkVQID0gZmFsc2U7CisJCQl9IGVsc2UgaWYgKGxpbmUuc3RhcnRzV2l0aCgiRXhwb3J0LVBhY2thZ2UiKSkgeworCQkJCWluRVAgPSB0cnVlOworCQkJfSBlbHNlIGlmICghbGluZS5zdGFydHNXaXRoKCIgIikpIHsKKwkJCQluZXdMaW5lID0gbGluZTsKKwkJCQlpbkVQID0gZmFsc2U7CisJCQl9CisKKwkJCWlmIChpbkVQKSB7CisJCQkJaWYgKHN5bWJvbGljTmFtZSA9PSBudWxsKSB7CisJCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oCisJCQkJCQkJIlN5bWJvbGljIG5hbWUgbXVzdCBiZSBsb2NhdGVkIGJlZm9yZSBleHBvcnQgcGFja2FnZXMuIik7CisJCQkJfQorCQkJCVN0cmluZyB0b2tlbnNbXSA9IGxpbmUuc3BsaXQoIiAiKTsKKwkJCQlpZiAodG9rZW5zLmxlbmd0aCA+IDApIHsKKwkJCQkJaWYgKHRva2Vuc1sxXS5zdGFydHNXaXRoKHN5bWJvbGljTmFtZSkpIHsKKwkJCQkJCW5ld0xpbmUgPSBsaW5lLnJlcGxhY2VGaXJzdCgKKwkJCQkJCQkJRVhQT1JUUEFDS0FHRV9PTERfVkVSU0lPTl9SRUdFWCwgU3RyaW5nLmZvcm1hdCgKKwkJCQkJCQkJCQlFWFBPUlRQQUNLQUdFX05FV19WRVJTSU9OLAorCQkJCQkJCQkJCWdldE9TR2lFUFZlcnNpb24oKSkpOworCQkJCQl9IGVsc2UgeworCQkJCQkJbmV3TGluZSA9IGxpbmU7CisJCQkJCX0KKwkJCQl9CisJCQl9CisKKwkJCS8vIHVwZGF0ZSBjb250ZW50IGFzIGl0IGlzCisJCQlmaWxlQ29udGVudC5hcHBlbmQobmV3TGluZSk7CisJCQlmaWxlQ29udGVudC5hcHBlbmQoIlxuIik7CisJCX0KKwkJcmV0dXJuIGZpbGVDb250ZW50OworCX0KKworCXByaXZhdGUgU3RyaW5nQnVpbGRlciBnZW5lcmF0ZVBvbShJRmlsZSBwb20pIHRocm93cyBDb3JlRXhjZXB0aW9uLAorCQkJSU9FeGNlcHRpb24geworCQkvLyBPcGVuIHRoZSBmaWxlCisJCUlucHV0U3RyZWFtIGlucHV0U3RyZWFtID0gcG9tLmdldENvbnRlbnRzKCk7CisJCUJ1ZmZlcmVkUmVhZGVyIHJlYWRlciA9IG5ldyBCdWZmZXJlZFJlYWRlcihuZXcgSW5wdXRTdHJlYW1SZWFkZXIoCisJCQkJaW5wdXRTdHJlYW0pKTsKKwkJU3RyaW5nIGxpbmUgPSBudWxsOworCQlTdHJpbmcgbmV3TGluZSA9IG51bGw7CisJCVN0cmluZ0J1aWxkZXIgZmlsZUNvbnRlbnQgPSBuZXcgU3RyaW5nQnVpbGRlcigpOworCQlib29sZWFuIGlzUGFyZW50Q29vcmRpbmF0ZSA9IGZhbHNlOworCQlib29sZWFuIGlzUGx1Z2luRGVmID0gZmFsc2U7CisJCWJvb2xlYW4gaXNQcm9maWxlRGVmID0gZmFsc2U7CisJCWJvb2xlYW4gaXNEZXBlbmRlbmN5RGVmID0gZmFsc2U7CisJCWJvb2xlYW4gcGFyZW50SXNSZWxlbmcgPSBmYWxzZTsKKworCQkvLyBSZWFkIGZpbGUgbGluZSBieSBsaW5lCisJCXdoaWxlICgobGluZSA9IHJlYWRlci5yZWFkTGluZSgpKSAhPSBudWxsKSB7CisJCQluZXdMaW5lID0gbGluZTsKKworCQkJLy8gUmVtZW1iZXIgaWYgd2UgYXJlIGluc2lkZSBjZXJ0YWluIHRhZ3MKKwkJCWlmIChsaW5lLmNvbnRhaW5zKCI8cGFyZW50PiIpKSB7CisJCQkJaXNQYXJlbnRDb29yZGluYXRlID0gdHJ1ZTsKKwkJCX0gZWxzZSBpZiAobGluZS5jb250YWlucygiPC9wYXJlbnQ+IikpIHsKKwkJCQlpc1BhcmVudENvb3JkaW5hdGUgPSBmYWxzZTsKKwkJCQlwYXJlbnRJc1JlbGVuZyA9IGZhbHNlOworCQkJfSBlbHNlIGlmIChsaW5lLmNvbnRhaW5zKCI8cHJvZmlsZT4iKSkgeworCQkJCWlzUHJvZmlsZURlZiA9IHRydWU7CisJCQl9IGVsc2UgaWYgKGxpbmUuY29udGFpbnMoIjwvcHJvZmlsZT4iKSkgeworCQkJCWlzUHJvZmlsZURlZiA9IGZhbHNlOworCQkJfSBlbHNlIGlmIChsaW5lLmNvbnRhaW5zKCI8cGx1Z2luPiIpKSB7CisJCQkJaXNQbHVnaW5EZWYgPSB0cnVlOworCQkJfSBlbHNlIGlmIChsaW5lLmNvbnRhaW5zKCI8L3BsdWdpbj4iKSkgeworCQkJCWlzUGx1Z2luRGVmID0gZmFsc2U7CisJCQl9IGVsc2UgaWYgKGxpbmUuY29udGFpbnMoIjxkZXBlbmRlbmN5PiIpKSB7CisJCQkJaXNEZXBlbmRlbmN5RGVmID0gdHJ1ZTsKKwkJCX0gZWxzZSBpZiAobGluZS5jb250YWlucygiPC9kZXBlbmRlbmN5PiIpKSB7CisJCQkJaXNEZXBlbmRlbmN5RGVmID0gZmFsc2U7CisJCQl9CisKKwkJCS8vIFJlbWVtYmVyIGlmIHBhcmVudCBpcyBhbiBleHRlcm5hbCByZWxlbmcgcHJvamVjdAorCQkJaWYgKGlzUGFyZW50Q29vcmRpbmF0ZSAmJiBsaW5lLmNvbnRhaW5zKCJncm91cElkIikKKwkJCQkJJiYgbGluZS5jb250YWlucyhwb21SZWxlbmdHcm91cElkKSkgeworCQkJCXBhcmVudElzUmVsZW5nID0gdHJ1ZTsKKwkJCX0KKworCQkJLy8gQ2hhbmdlcyBhcmUgbmVjZXNzYXJ5IG9ubHkgZm9yIDx2ZXJzaW9uPiB0YWdzIG91dHNpZGUgb2YgcGx1Z2luLAorCQkJLy8gZGVwZW5kZW5jeSBvciBwcm9maWxlIGRlZmluaXRpb25zCisJCQlpZiAoIWlzUHJvZmlsZURlZiAmJiAhaXNQbHVnaW5EZWYgJiYgIWlzRGVwZW5kZW5jeURlZgorCQkJCQkmJiBsaW5lLmNvbnRhaW5zKCI8dmVyc2lvbj4iKSkgeworCisJCQkJLy8gRGVmaW5pdGlvbnMgb2YgYSBwYXJlbnQgUE9NIHZlcnNpb24KKwkJCQlpZiAoaXNQYXJlbnRDb29yZGluYXRlKSB7CisKKwkJCQkJLy8gUGFyZW50IGlzIFAyCisJCQkJCWlmIChwb20uZ2V0RnVsbFBhdGgoKS50b1N0cmluZygpLmVuZHNXaXRoKCJwMiIpKSB7CisJCQkJCQluZXdMaW5lID0gbGluZS5yZXBsYWNlRmlyc3QoCisJCQkJCQkJCVBPTV9BUlRJRkFDVF9PTERfVkVSU0lPTl9SRUdFWCwgU3RyaW5nLmZvcm1hdCgKKwkJCQkJCQkJCQlQT01fQVJUSUZBQ1RfTkVXX1ZFUlNJT04sCisJCQkJCQkJCQkJcG9tUmVsZW5nUDJWZXJzaW9uKSk7CisJCQkJCX0gZWxzZSB7CisJCQkJCQkvLyBQYXJlbnQgaXMgZXh0ZXJuYWwgcmVsZW5nIHByb2plY3QKKwkJCQkJCWlmIChwYXJlbnRJc1JlbGVuZykgeworCQkJCQkJCW5ld0xpbmUgPSBsaW5lLnJlcGxhY2VGaXJzdCgKKwkJCQkJCQkJCVBPTV9BUlRJRkFDVF9PTERfVkVSU0lPTl9SRUdFWCwgU3RyaW5nCisJCQkJCQkJCQkJCS5mb3JtYXQoUE9NX0FSVElGQUNUX05FV19WRVJTSU9OLAorCQkJCQkJCQkJCQkJCXBvbVJlbGVuZ1ZlcnNpb24pKTsKKwkJCQkJCQkvLyBQYXJlbnQgaXMgd2l0aGluIHNhbWUgcmVwbworCQkJCQkJfSBlbHNlIHsKKwkJCQkJCQluZXdMaW5lID0gbGluZS5yZXBsYWNlRmlyc3QoCisJCQkJCQkJCQlQT01fQVJUSUZBQ1RfT0xEX1ZFUlNJT05fUkVHRVgsIFN0cmluZworCQkJCQkJCQkJCQkuZm9ybWF0KFBPTV9BUlRJRkFDVF9ORVdfVkVSU0lPTiwKKwkJCQkJCQkJCQkJCQlwb21BcnRpZmFjdFZlcnNpb24pKTsKKwkJCQkJCX0KKwkJCQkJfQorCisJCQkJCS8vIFZlcnNpb24gb2YgdGhpcyBQT00gKG91dHNpZGUgPHBhcmVudD4gdGFncykKKwkJCQl9IGVsc2UgeworCQkJCQluZXdMaW5lID0gbGluZS5yZXBsYWNlRmlyc3QoUE9NX0FSVElGQUNUX09MRF9WRVJTSU9OX1JFR0VYLAorCQkJCQkJCVN0cmluZy5mb3JtYXQoUE9NX0FSVElGQUNUX05FV19WRVJTSU9OLAorCQkJCQkJCQkJcG9tQXJ0aWZhY3RWZXJzaW9uKSk7CisJCQkJfQorCQkJfQorCisJCQkvLyB3cml0ZSBjaGFuZ2VzIHRvIGZpbGUKKwkJCWZpbGVDb250ZW50LmFwcGVuZChuZXdMaW5lKTsKKwkJCWZpbGVDb250ZW50LmFwcGVuZCgiXG4iKTsKKwkJfQorCQlyZXR1cm4gZmlsZUNvbnRlbnQ7CisJfQorCisJcHJpdmF0ZSBTdHJpbmdCdWlsZGVyIGdlbmVyYXRlRmVhdHVyZVhtbChJRmlsZSBmZWF0dXJlWG1sKQorCQkJdGhyb3dzIENvcmVFeGNlcHRpb24sIElPRXhjZXB0aW9uIHsKKwkJLy8gT3BlbiB0aGUgZmlsZQorCQlJbnB1dFN0cmVhbSBpbnB1dFN0cmVhbSA9IGZlYXR1cmVYbWwuZ2V0Q29udGVudHMoKTsKKwkJQnVmZmVyZWRSZWFkZXIgcmVhZGVyID0gbmV3IEJ1ZmZlcmVkUmVhZGVyKG5ldyBJbnB1dFN0cmVhbVJlYWRlcigKKwkJCQlpbnB1dFN0cmVhbSkpOworCQlTdHJpbmcgbGluZSA9IG51bGw7CisJCVN0cmluZyBuZXdMaW5lID0gbnVsbDsKKwkJU3RyaW5nQnVpbGRlciBmaWxlQ29udGVudCA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7CisJCWJvb2xlYW4gaW5SZXF1aXJlID0gZmFsc2U7CisJCWJvb2xlYW4gaW5QbHVnaW4gPSBmYWxzZTsKKworCQlTdHJpbmcgc3ltYm9saWNOYW1lID0gbnVsbDsKKwkJLy8gUmVhZCBmaWxlIGxpbmUgYnkgbGluZQorCQl3aGlsZSAoKGxpbmUgPSByZWFkZXIucmVhZExpbmUoKSkgIT0gbnVsbCkgeworCQkJbmV3TGluZSA9IGxpbmU7CisKKwkJCS8vIHJlbWVtYmVyIHdoaWNoIHNlY3Rpb24gd2UgYXJlIGluCisJCQlpZiAobGluZS5jb250YWlucygiPHJlcXVpcmVzPiIpKSB7CisJCQkJaW5SZXF1aXJlID0gdHJ1ZTsKKwkJCX0gZWxzZSBpZiAobGluZS5jb250YWlucygiPC9yZXF1aXJlcz4iKSkgeworCQkJCWluUmVxdWlyZSA9IGZhbHNlOworCQkJfSBlbHNlIGlmIChsaW5lLmNvbnRhaW5zKCI8cGx1Z2luIikpIHsKKwkJCQlpblBsdWdpbiA9IHRydWU7CisJCQl9IGVsc2UgaWYgKGluUGx1Z2luICYmIGxpbmUuY29udGFpbnMoIi8+IikpIHsKKwkJCQlpblBsdWdpbiA9IGZhbHNlOworCQkJfQorCisJCQkvLyBvbmx5IGNoYW5nZSB2ZXJzaW9uIG9mIGZlYXR1cmUgaXRzZWxmCisJCQlpZiAoIWluUmVxdWlyZSAmJiAhaW5QbHVnaW4gJiYgIWxpbmUuY29udGFpbnMoIjw/eG1sIikpIHsKKwkJCQluZXdMaW5lID0gbGluZS5yZXBsYWNlRmlyc3QoRkVBVFVSRV9PTERfVkVSU0lPTl9SRUdFWCwKKwkJCQkJCVN0cmluZy5mb3JtYXQoRkVBVFVSRV9ORVdfVkVSU0lPTiwgZ2V0T1NHaVZlcnNpb24oKSkpOworCQkJfQorCisJCQkvLyB1cGRhdGUgY29udGVudCBhcyBpdCBpcworCQkJZmlsZUNvbnRlbnQuYXBwZW5kKG5ld0xpbmUpOworCQkJZmlsZUNvbnRlbnQuYXBwZW5kKCJcbiIpOworCQl9CisJCXJldHVybiBmaWxlQ29udGVudDsKKwl9CisKKwlwcml2YXRlIE9iamVjdCBnZXRPU0dpVmVyc2lvbigpIHsKKwkJcmV0dXJuIHBvbUFydGlmYWN0VmVyc2lvbi5yZXBsYWNlKCItU05BUFNIT1QiLCAiLnF1YWxpZmllciIpOworCX0KKworCXByaXZhdGUgT2JqZWN0IGdldE9TR2lFUFZlcnNpb24oKSB7CisJCXJldHVybiBwb21BcnRpZmFjdFZlcnNpb24ucmVwbGFjZSgiLVNOQVBTSE9UIiwgIiIpOworCX0KKworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS90b29scy9kZXZlbG9wZXIvRGVwZW5kZW5jeVZlcnNpb25VcGRhdGUuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3Blci9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvdG9vbHMvZGV2ZWxvcGVyL0RlcGVuZGVuY3lWZXJzaW9uVXBkYXRlLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOGZjMGFlNwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3Blci9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvdG9vbHMvZGV2ZWxvcGVyL0RlcGVuZGVuY3lWZXJzaW9uVXBkYXRlLmphdmEKQEAgLTAsMCArMSwzMTcgQEAKKy8qKgorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE1IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiwgQXVzdHJpYSksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorICoKKyAqIENvbnRyaWJ1dG9yczoKKyAqICAgICAgICAgRmxvcmlhbiBQaXJjaG5lciAtIEluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqLworCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3BlcjsKKworaW1wb3J0IGphdmEuaW8uQnVmZmVyZWRSZWFkZXI7CitpbXBvcnQgamF2YS5pby5CeXRlQXJyYXlJbnB1dFN0cmVhbTsKK2ltcG9ydCBqYXZhLmlvLklPRXhjZXB0aW9uOworaW1wb3J0IGphdmEuaW8uSW5wdXRTdHJlYW07CitpbXBvcnQgamF2YS5pby5JbnB1dFN0cmVhbVJlYWRlcjsKK2ltcG9ydCBqYXZhLnV0aWwuQXJyYXlMaXN0OworaW1wb3J0IGphdmEudXRpbC5MaXN0OworCitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSUNvbnRhaW5lcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JRmlsZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JUHJvamVjdDsKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJlc291cmNlcy5JUmVzb3VyY2U7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLkNvcmVFeGNlcHRpb247CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLk51bGxQcm9ncmVzc01vbml0b3I7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLlBhdGg7CisKK3B1YmxpYyBjbGFzcyBEZXBlbmRlbmN5VmVyc2lvblVwZGF0ZSB7CisKKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgRklMRU5BTUUgPSAiLy5kZXBWZXJzaW9ucyI7CisJcHJpdmF0ZSBzdGF0aWMgZmluYWwgU3RyaW5nIFJFUVVJUkVCVU5ETEVfT0xEX1ZFUlNJT05fUkVHRVggPSAiYnVuZGxlLXZlcnNpb249XCJbXFx3XFwuXFxbXFwpLF0qXCIiOworCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBSRVFVSVJFQlVORExFX05FV19WRVJTSU9OID0gImJ1bmRsZS12ZXJzaW9uPVwiJXNcIiI7CisKKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgSU1QT1JUUEFDS0FHRV9PTERfVkVSU0lPTl9SRUdFWCA9ICJ2ZXJzaW9uPVwiW1xcd1xcLlxcW1xcKSxdKlwiIjsKKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgSU1QT1JUUEFDS0FHRV9ORVdfVkVSU0lPTiA9ICJ2ZXJzaW9uPVwiJXNcIiI7CisKKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgRkVBVFVSRV9PTERfVkVSU0lPTl9SRUdFWCA9ICJ2ZXJzaW9uPVwiW1xcd1xcLl0qXCIiOworCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBGRUFUVVJFX05FV19WRVJTSU9OID0gInZlcnNpb249XCIlc1wiIjsKKworCXByaXZhdGUgTGlzdDxWZXJzaW9uRGVmPiBkZWZzOworCisJcHVibGljIHZvaWQgZXhlY3V0ZShJUHJvamVjdCBhZ2dyZWdhdG9yKSB0aHJvd3MgRXhjZXB0aW9uIHsKKwkJSUZpbGUgZmlsZSA9IGFnZ3JlZ2F0b3IuZ2V0RmlsZShGSUxFTkFNRSk7CisJCWlmICghZmlsZS5leGlzdHMoKSkgeworCQkJcmV0dXJuOworCQl9CisKKwkJZGVmcyA9IHBhcnNlRGVmcyhmaWxlKTsKKworCQlwcm9jZXNzUHJvamVjdChhZ2dyZWdhdG9yKTsKKwl9CisKKwlwcml2YXRlIHZvaWQgcHJvY2Vzc1Byb2plY3QoSUNvbnRhaW5lciBwcm9qZWN0KSB0aHJvd3MgQ29yZUV4Y2VwdGlvbiwKKwkJCUlPRXhjZXB0aW9uIHsKKworCQlJUmVzb3VyY2UgbWFuaWZlc3QgPSBwcm9qZWN0LmdldEZpbGUobmV3IFBhdGgoIi9NRVRBLUlORi9NQU5JRkVTVC5NRiIpKTsKKwkJaWYgKG1hbmlmZXN0ICE9IG51bGwgJiYgbWFuaWZlc3QuZXhpc3RzKCkpIHsKKwkJCXByb2Nlc3NNYW5pZmVzdCgoSUZpbGUpIG1hbmlmZXN0KTsKKwkJfQorCisJCUlSZXNvdXJjZSBmZWF0dXJlWG1sID0gcHJvamVjdC5nZXRGaWxlKG5ldyBQYXRoKCIvZmVhdHVyZS54bWwiKSk7CisJCWlmIChmZWF0dXJlWG1sICE9IG51bGwgJiYgZmVhdHVyZVhtbC5leGlzdHMoKSkgeworCQkJcHJvY2Vzc0ZlYXR1cmVYbWwoKElGaWxlKSBmZWF0dXJlWG1sKTsKKwkJfQorCisJCWZvciAoSVJlc291cmNlIG1lbWJlciA6IHByb2plY3QubWVtYmVycygpKSB7CisJCQlpZiAobWVtYmVyIGluc3RhbmNlb2YgSUNvbnRhaW5lcikgeworCQkJCWlmIChpc0NoaWxkUHJvamVjdCgoSUNvbnRhaW5lcikgbWVtYmVyKSkgeworCQkJCQkvLyBhbHNvIHByb2Nlc3MgY2hpbGRzCisJCQkJCXByb2Nlc3NQcm9qZWN0KChJQ29udGFpbmVyKSBtZW1iZXIpOworCQkJCX0KKwkJCX0KKwkJfQorCisJfQorCisJcHJpdmF0ZSBib29sZWFuIGlzQ2hpbGRQcm9qZWN0KElDb250YWluZXIgbWVtYmVyKSB7CisJCUlSZXNvdXJjZSBwcm9qZWN0RmlsZSA9IG1lbWJlci5nZXRGaWxlKG5ldyBQYXRoKCIvLnByb2plY3QiKSk7CisJCXJldHVybiBwcm9qZWN0RmlsZSAhPSBudWxsICYmIHByb2plY3RGaWxlLmV4aXN0cygpOworCX0KKworCXByaXZhdGUgdm9pZCBwcm9jZXNzTWFuaWZlc3QoSUZpbGUgbWFuaWZlc3QpIHRocm93cyBDb3JlRXhjZXB0aW9uLAorCQkJSU9FeGNlcHRpb24geworCisJCVN0cmluZ0J1aWxkZXIgZmlsZUNvbnRlbnQgPSBnZW5lcmF0ZU1hbmlmZXN0KG1hbmlmZXN0KTsKKworCQltYW5pZmVzdC5zZXRDb250ZW50cyhuZXcgQnl0ZUFycmF5SW5wdXRTdHJlYW0oZmlsZUNvbnRlbnQudG9TdHJpbmcoKQorCQkJCS5nZXRCeXRlcygpKSwgdHJ1ZSwgdHJ1ZSwgbmV3IE51bGxQcm9ncmVzc01vbml0b3IoKSk7CisKKwl9CisKKwlwcml2YXRlIFN0cmluZ0J1aWxkZXIgZ2VuZXJhdGVNYW5pZmVzdChJRmlsZSBtYW5pZmVzdCkKKwkJCXRocm93cyBDb3JlRXhjZXB0aW9uLCBJT0V4Y2VwdGlvbiB7CisJCS8vIE9wZW4gdGhlIGZpbGUKKwkJSW5wdXRTdHJlYW0gaW5wdXRTdHJlYW0gPSBtYW5pZmVzdC5nZXRDb250ZW50cygpOworCQlCdWZmZXJlZFJlYWRlciByZWFkZXIgPSBuZXcgQnVmZmVyZWRSZWFkZXIobmV3IElucHV0U3RyZWFtUmVhZGVyKAorCQkJCWlucHV0U3RyZWFtKSk7CisJCVN0cmluZyBsaW5lID0gbnVsbDsKKwkJU3RyaW5nIG5ld0xpbmUgPSBudWxsOworCQlTdHJpbmdCdWlsZGVyIGZpbGVDb250ZW50ID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKKwkJU3RyaW5nIGhlYWRlciA9ICIiOworCisJCS8vIFJlYWQgZmlsZSBsaW5lIGJ5IGxpbmUKKwkJd2hpbGUgKChsaW5lID0gcmVhZGVyLnJlYWRMaW5lKCkpICE9IG51bGwpIHsKKwkJCW5ld0xpbmUgPSBsaW5lOworCisJCQkvLyBGaW5kIG91dCBpbiB3aGljaCBzZWN0aW9uIHdlIGFyZSwgc3RvcmUgdGhpcyBpbmZvCisJCQlpZiAobGluZS5zdGFydHNXaXRoKCJJbXBvcnQtUGFja2FnZSIpKSB7CisJCQkJaGVhZGVyID0gImlwIjsKKwkJCX0gZWxzZSBpZiAobGluZS5zdGFydHNXaXRoKCJSZXF1aXJlLUJ1bmRsZSIpKSB7CisJCQkJaGVhZGVyID0gInJiIjsKKwkJCX0gZWxzZSBpZiAoIWxpbmUuc3RhcnRzV2l0aCgiICIpKSB7IC8vIGFueSBvdGhlciBzZWN0aW9uID4+PiBubworCQkJCQkJCQkJCQkJLy8gY2hhbmdlcworCQkJCWhlYWRlciA9ICIiOworCQkJCWZpbGVDb250ZW50LmFwcGVuZChsaW5lKTsKKwkJCQlmaWxlQ29udGVudC5hcHBlbmQoIlxuIik7CisJCQkJY29udGludWU7CisJCQl9CisKKwkJCS8vIENoYW5nZXMgbmVjZXNzYXJ5IG9ubHkgaW4gSW1wb3J0IG9yIFJlcXVpcmUgc2VjdGlvbnMKKwkJCWlmICghaGVhZGVyLmVxdWFscygiIikpIHsKKworCQkJCS8vIEdldCBidW5kbGUgbmFtZSAoYWZ0ZXIgZmlyc3Qgc3BhY2UpCisJCQkJU3RyaW5nIHRva2Vuc1tdID0gbGluZS5zcGxpdCgiICIpOworCQkJCWlmICh0b2tlbnMubGVuZ3RoID4gMSkgeworCQkJCQlTdHJpbmcgbmFtZSA9IHRva2Vuc1sxXTsKKworCQkJCQkvLyBSZXBsYWNlIHZlcnNpb24gd2l0aCB2ZXJzaW9uIGluIC5kZXBWZXJzaW9ucyBmaWxlCisJCQkJCVZlcnNpb25EZWYgZGVmID0gZmluZFZlcnNpb25EZWYobmFtZSk7CisJCQkJCWlmIChkZWYgIT0gbnVsbCkgeworCQkJCQkJaWYgKGhlYWRlci5lcXVhbHMoImlwIikpIHsKKwkJCQkJCQluZXdMaW5lID0gZGVmLmNyZWF0ZUltcG9ydFBhY2thZ2UobGluZSk7CisJCQkJCQl9IGVsc2UgaWYgKGhlYWRlci5lcXVhbHMoInJiIikpIHsKKwkJCQkJCQluZXdMaW5lID0gZGVmLmNyZWF0ZVJlcXVpcmVCdW5kbGUobGluZSk7CisJCQkJCQl9IGVsc2UgeworCQkJCQkJCXRocm93IG5ldyBJbGxlZ2FsU3RhdGVFeGNlcHRpb24oKTsKKwkJCQkJCX0KKwkJCQkJfQorCQkJCX0KKwkJCX0KKworCQkJLy8gd3JpdGUgcmVzdWx0IHRvIGZpbGUKKwkJCWZpbGVDb250ZW50LmFwcGVuZChuZXdMaW5lKTsKKwkJCWZpbGVDb250ZW50LmFwcGVuZCgiXG4iKTsKKwkJfQorCQlyZXR1cm4gZmlsZUNvbnRlbnQ7CisJfQorCisJcHJpdmF0ZSB2b2lkIHByb2Nlc3NGZWF0dXJlWG1sKElGaWxlIGZlYXR1cmVYbWwpIHRocm93cyBDb3JlRXhjZXB0aW9uLAorCQkJSU9FeGNlcHRpb24geworCisJCVN0cmluZ0J1aWxkZXIgZmlsZUNvbnRlbnQgPSBnZW5lcmF0ZUZlYXR1cmVYbWwoZmVhdHVyZVhtbCk7CisKKwkJZmVhdHVyZVhtbC5zZXRDb250ZW50cyhuZXcgQnl0ZUFycmF5SW5wdXRTdHJlYW0oZmlsZUNvbnRlbnQudG9TdHJpbmcoKQorCQkJCS5nZXRCeXRlcygpKSwgdHJ1ZSwgdHJ1ZSwgbmV3IE51bGxQcm9ncmVzc01vbml0b3IoKSk7CisKKwl9CisKKwlwcml2YXRlIFN0cmluZ0J1aWxkZXIgZ2VuZXJhdGVGZWF0dXJlWG1sKElGaWxlIGZlYXR1cmVYbWwpCisJCQl0aHJvd3MgQ29yZUV4Y2VwdGlvbiwgSU9FeGNlcHRpb24geworCQkvLyBPcGVuIHRoZSBmaWxlCisJCUlucHV0U3RyZWFtIGlucHV0U3RyZWFtID0gZmVhdHVyZVhtbC5nZXRDb250ZW50cygpOworCQlCdWZmZXJlZFJlYWRlciByZWFkZXIgPSBuZXcgQnVmZmVyZWRSZWFkZXIobmV3IElucHV0U3RyZWFtUmVhZGVyKAorCQkJCWlucHV0U3RyZWFtKSk7CisJCVN0cmluZyBsaW5lID0gbnVsbDsKKwkJU3RyaW5nIG5ld0xpbmUgPSBudWxsOworCQlTdHJpbmdCdWlsZGVyIGZpbGVDb250ZW50ID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKKwkJYm9vbGVhbiBpblJlcXVpcmUgPSBmYWxzZTsKKwkJYm9vbGVhbiBpblBsdWdpbiA9IGZhbHNlOworCisJCVN0cmluZyBzeW1ib2xpY05hbWUgPSBudWxsOworCQkvLyBSZWFkIGZpbGUgbGluZSBieSBsaW5lCisJCXdoaWxlICgobGluZSA9IHJlYWRlci5yZWFkTGluZSgpKSAhPSBudWxsKSB7CisJCQluZXdMaW5lID0gbGluZTsKKworCQkJLy8gcmVtZW1iZXIgd2hpY2ggc2VjdGlvbiB3ZSBhcmUgaW4KKwkJCWlmIChsaW5lLmNvbnRhaW5zKCI8cmVxdWlyZXM+IikpIHsKKwkJCQlpblJlcXVpcmUgPSB0cnVlOworCQkJfSBlbHNlIGlmIChsaW5lLmNvbnRhaW5zKCI8L3JlcXVpcmVzPiIpKSB7CisJCQkJaW5SZXF1aXJlID0gZmFsc2U7CisJCQl9IGVsc2UgaWYgKGxpbmUuY29udGFpbnMoIjxwbHVnaW4iKSkgeworCQkJCWluUGx1Z2luID0gdHJ1ZTsKKwkJCX0gZWxzZSBpZiAobGluZS5jb250YWlucygiPC9wbHVnaW4+IikpIHsKKwkJCQlpblBsdWdpbiA9IGZhbHNlOworCQkJfQorCisJCQkvLyBjaGFuZ2UgdmVyc2lvbnMgb2YgZGVwZW5kZW5jaWVzIGluICJyZXF1aXJlcyIKKwkJCWlmIChpblJlcXVpcmUgJiYgIWluUGx1Z2luKSB7CisKKwkJCQkvLyBHZXQgYnVuZGxlIG5hbWUgKGFmdGVyIGZpcnN0IHNwYWNlKQorCQkJCVN0cmluZ1tdIHRva2VucyA9IGxpbmUuc3BsaXQoIlwiIik7CisJCQkJaWYgKHRva2Vucy5sZW5ndGggPiAxKSB7CisJCQkJCVN0cmluZyBuYW1lID0gdG9rZW5zWzFdOworCisJCQkJCS8vIFJlcGxhY2UgdmVyc2lvbiB3aXRoIHZlcnNpb24gaW4gLmRlcFZlcnNpb25zIGZpbGUKKwkJCQkJVmVyc2lvbkRlZiBkZWYgPSBmaW5kVmVyc2lvbkRlZihuYW1lKTsKKwkJCQkJaWYoZGVmICE9IG51bGwpIHsKKwkJCQkJCW5ld0xpbmUgPSBkZWYuY3JlYXRlRmVhdHVyZVJlcXVpcmVzKGxpbmUpOworCQkJCQl9CisJCQkJfQorCQkJfQorCisJCQkvLyB3cml0ZSByZXN1bHQgdG8gZmlsZQorCQkJZmlsZUNvbnRlbnQuYXBwZW5kKG5ld0xpbmUpOworCQkJZmlsZUNvbnRlbnQuYXBwZW5kKCJcbiIpOworCQl9CisJCXJldHVybiBmaWxlQ29udGVudDsKKwl9CisKKwlwcml2YXRlIFZlcnNpb25EZWYgZmluZFZlcnNpb25EZWYoU3RyaW5nIG5hbWUpIHsKKworCQlmb3IgKFZlcnNpb25EZWYgZGVmIDogZGVmcykgeworCQkJaWYgKG5hbWUuc3RhcnRzV2l0aChkZWYuZ2V0TmFtZSgpKSkgeworCQkJCXJldHVybiBkZWY7CisJCQl9CisJCX0KKworCQlyZXR1cm4gbnVsbDsKKwl9CisKKwlwcml2YXRlIExpc3Q8VmVyc2lvbkRlZj4gcGFyc2VEZWZzKElGaWxlIGZpbGUpIHRocm93cyBDb3JlRXhjZXB0aW9uLAorCQkJSU9FeGNlcHRpb24geworCisJCUxpc3Q8VmVyc2lvbkRlZj4gZGVmcyA9IG5ldyBBcnJheUxpc3Q8VmVyc2lvbkRlZj4oKTsKKworCQkvLyBPcGVuIHRoZSBmaWxlCisJCUJ1ZmZlcmVkUmVhZGVyIHJlYWRlciA9IG5ldyBCdWZmZXJlZFJlYWRlcihuZXcgSW5wdXRTdHJlYW1SZWFkZXIoCisJCQkJZmlsZS5nZXRDb250ZW50cygpKSk7CisJCVN0cmluZyBsaW5lID0gbnVsbDsKKwkJLy8gUmVhZCBmaWxlIGxpbmUgYnkgbGluZQorCQl3aGlsZSAoKGxpbmUgPSByZWFkZXIucmVhZExpbmUoKSkgIT0gbnVsbCkgeworCQkJVmVyc2lvbkRlZiBkZWYgPSBuZXcgVmVyc2lvbkRlZihsaW5lKTsKKwkJCWRlZnMuYWRkKGRlZik7CisJCX0KKworCQlyZXR1cm4gZGVmczsKKwl9CisKKwlwcml2YXRlIHN0YXRpYyBjbGFzcyBWZXJzaW9uRGVmIHsKKwkJcHJpdmF0ZSBTdHJpbmcgbmFtZTsKKwkJcHJpdmF0ZSBTdHJpbmcgbWluVmVyc2lvbjsKKwkJcHJpdmF0ZSBTdHJpbmcgbWF4VmVyc2lvbjsKKworCQlwdWJsaWMgVmVyc2lvbkRlZihTdHJpbmcgbGluZSkgeworCQkJU3RyaW5nW10gdG9rZW5zID0gbGluZS5zcGxpdCgiOyIpOworCQkJZm9yIChpbnQgaSA9IDA7IGkgPCB0b2tlbnMubGVuZ3RoOyBpKyspIHsKKwkJCQlTdHJpbmcgdG9rZW4gPSB0b2tlbnNbaV07CisJCQkJaWYgKGkgPT0gMCkgeworCQkJCQluYW1lID0gdG9rZW47CisJCQkJfSBlbHNlIGlmICh0b2tlbi5zdGFydHNXaXRoKCJtaW4iKSkgeworCQkJCQltaW5WZXJzaW9uID0gdG9rZW4ucmVwbGFjZSgibWluPSIsICIiKTsKKwkJCQl9IGVsc2UgaWYgKHRva2VuLnN0YXJ0c1dpdGgoIm1heCIpKSB7CisJCQkJCW1heFZlcnNpb24gPSB0b2tlbi5yZXBsYWNlKCJtYXg9IiwgIiIpOworCQkJCX0KKwkJCX0KKwkJfQorCisJCXB1YmxpYyBTdHJpbmcgZ2V0TmFtZSgpIHsKKwkJCXJldHVybiBuYW1lOworCQl9CisKKwkJcHVibGljIFN0cmluZyBnZXRNaW5WZXJzaW9uKCkgeworCQkJcmV0dXJuIG1pblZlcnNpb247CisJCX0KKworCQlwdWJsaWMgU3RyaW5nIGdldE1heFZlcnNpb24oKSB7CisJCQlyZXR1cm4gbWF4VmVyc2lvbjsKKwkJfQorCisJCXB1YmxpYyBTdHJpbmcgY3JlYXRlSW1wb3J0UGFja2FnZShTdHJpbmcgaW5wdXQpIHsKKwkJCVN0cmluZyBuZXdMaW5lID0gaW5wdXQucmVwbGFjZUZpcnN0KAorCQkJCQlJTVBPUlRQQUNLQUdFX09MRF9WRVJTSU9OX1JFR0VYLCBTdHJpbmcuZm9ybWF0KAorCQkJCQkJCUlNUE9SVFBBQ0tBR0VfTkVXX1ZFUlNJT04sIGNyZWF0ZVZlcnNpb25SYW5nZSgpKSk7CisJCQlyZXR1cm4gbmV3TGluZTsKKwkJfQorCisJCXB1YmxpYyBTdHJpbmcgY3JlYXRlUmVxdWlyZUJ1bmRsZShTdHJpbmcgaW5wdXQpIHsKKwkJCVN0cmluZyBuZXdMaW5lID0gaW5wdXQucmVwbGFjZUZpcnN0KAorCQkJCQlSRVFVSVJFQlVORExFX09MRF9WRVJTSU9OX1JFR0VYLCBTdHJpbmcuZm9ybWF0KAorCQkJCQkJCVJFUVVJUkVCVU5ETEVfTkVXX1ZFUlNJT04sIGNyZWF0ZVZlcnNpb25SYW5nZSgpKSk7CisJCQlyZXR1cm4gbmV3TGluZTsKKwkJfQorCisJCXB1YmxpYyBTdHJpbmcgY3JlYXRlRmVhdHVyZVJlcXVpcmVzKFN0cmluZyBpbnB1dCkgeworCQkJU3RyaW5nIG5ld0xpbmUgPSBpbnB1dC5yZXBsYWNlRmlyc3QoRkVBVFVSRV9PTERfVkVSU0lPTl9SRUdFWCwKKwkJCQkJU3RyaW5nLmZvcm1hdChGRUFUVVJFX05FV19WRVJTSU9OLCBtaW5WZXJzaW9uKSk7CisJCQlyZXR1cm4gbmV3TGluZTsKKwkJfQorCisJCXByaXZhdGUgU3RyaW5nIGNyZWF0ZVZlcnNpb25SYW5nZSgpIHsKKwkJCVN0cmluZ0J1aWxkZXIgc2IgPSBuZXcgU3RyaW5nQnVpbGRlcigpOworCQkJaWYgKHVzZU1heFZlcnNpb24oKSkgeworCQkJCXNiLmFwcGVuZCgiWyIpOworCQkJfQorCisJCQlzYi5hcHBlbmQobWluVmVyc2lvbik7CisKKwkJCWlmICh1c2VNYXhWZXJzaW9uKCkpIHsKKwkJCQlzYi5hcHBlbmQoIiwiKTsKKwkJCQlzYi5hcHBlbmQobWF4VmVyc2lvbik7CisJCQl9CisKKwkJCWlmICh1c2VNYXhWZXJzaW9uKCkpIHsKKwkJCQlzYi5hcHBlbmQoIikiKTsKKwkJCX0KKworCQkJcmV0dXJuIHNiLnRvU3RyaW5nKCk7CisJCX0KKworCQlwcml2YXRlIGJvb2xlYW4gdXNlTWF4VmVyc2lvbigpIHsKKwkJCXJldHVybiBtYXhWZXJzaW9uICE9IG51bGw7CisJCX0KKwl9CisKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3Blci9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvdG9vbHMvZGV2ZWxvcGVyL1VwZGF0ZUFydGlmYWN0VmVyc2lvbnMuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3Blci9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvdG9vbHMvZGV2ZWxvcGVyL1VwZGF0ZUFydGlmYWN0VmVyc2lvbnMuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kYjdlMTYyCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS90b29scy9kZXZlbG9wZXIvVXBkYXRlQXJ0aWZhY3RWZXJzaW9ucy5qYXZhCkBAIC0wLDAgKzEsNzkgQEAKKy8qKgorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE1IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiwgQXVzdHJpYSksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorICoKKyAqIENvbnRyaWJ1dG9yczoKKyAqICAgICAgICAgRmxvcmlhbiBQaXJjaG5lciAtIEluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqLworCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3BlcjsKKworaW1wb3J0IGphdmEudXRpbC5JdGVyYXRvcjsKKworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucmVzb3VyY2VzLklQcm9qZWN0OworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5JQWRhcHRhYmxlOworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5JU3RhdHVzOworaW1wb3J0IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5TdGF0dXM7CitpbXBvcnQgb3JnLmVjbGlwc2UuamZhY2UuYWN0aW9uLklBY3Rpb247CitpbXBvcnQgb3JnLmVjbGlwc2UuamZhY2UuZGlhbG9ncy5FcnJvckRpYWxvZzsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLklTZWxlY3Rpb247CitpbXBvcnQgb3JnLmVjbGlwc2UuamZhY2Uudmlld2Vycy5JU3RydWN0dXJlZFNlbGVjdGlvbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5zd3Qud2lkZ2V0cy5EaXNwbGF5OworaW1wb3J0IG9yZy5lY2xpcHNlLnVpLklPYmplY3RBY3Rpb25EZWxlZ2F0ZTsKK2ltcG9ydCBvcmcuZWNsaXBzZS51aS5JV29ya2JlbmNoUGFydDsKK2ltcG9ydCBvcmcuc2xmNGouTG9nZ2VyRmFjdG9yeTsKKworcHVibGljIGNsYXNzIFVwZGF0ZUFydGlmYWN0VmVyc2lvbnMgaW1wbGVtZW50cyBJT2JqZWN0QWN0aW9uRGVsZWdhdGUgeworCisJcHJpdmF0ZSBzdGF0aWMgZmluYWwgb3JnLnNsZjRqLkxvZ2dlciBsb2cgPSBMb2dnZXJGYWN0b3J5CisJCQkuZ2V0TG9nZ2VyKFVwZGF0ZUFydGlmYWN0VmVyc2lvbnMuY2xhc3MpOworCisJcHJpdmF0ZSBJU2VsZWN0aW9uIHNlbGVjdGlvbjsKKworCXB1YmxpYyB2b2lkIHJ1bihJQWN0aW9uIGFjdGlvbikgeworCQlpZiAoc2VsZWN0aW9uIGluc3RhbmNlb2YgSVN0cnVjdHVyZWRTZWxlY3Rpb24pIHsKKwkJCWZvciAoSXRlcmF0b3I8Pz4gaXQgPSAoKElTdHJ1Y3R1cmVkU2VsZWN0aW9uKSBzZWxlY3Rpb24pLml0ZXJhdG9yKCk7IGl0CisJCQkJCS5oYXNOZXh0KCk7KSB7CisJCQkJT2JqZWN0IGVsZW1lbnQgPSBpdC5uZXh0KCk7CisJCQkJSVByb2plY3QgcHJvamVjdCA9IG51bGw7CisJCQkJaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBJUHJvamVjdCkgeworCQkJCQlwcm9qZWN0ID0gKElQcm9qZWN0KSBlbGVtZW50OworCQkJCX0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIElBZGFwdGFibGUpIHsKKwkJCQkJcHJvamVjdCA9IChJUHJvamVjdCkgKChJQWRhcHRhYmxlKSBlbGVtZW50KQorCQkJCQkJCS5nZXRBZGFwdGVyKElQcm9qZWN0LmNsYXNzKTsKKwkJCQl9CisJCQkJaWYgKHByb2plY3QgIT0gbnVsbCkgeworCQkJCQlleGVjdXRlVXBkYXRlKHByb2plY3QpOworCQkJCX0KKwkJCX0KKwkJfQorCX0KKworCXB1YmxpYyB2b2lkIHNlbGVjdGlvbkNoYW5nZWQoSUFjdGlvbiBhY3Rpb24sIElTZWxlY3Rpb24gc2VsZWN0aW9uKSB7CisJCXRoaXMuc2VsZWN0aW9uID0gc2VsZWN0aW9uOworCX0KKworCXB1YmxpYyB2b2lkIHNldEFjdGl2ZVBhcnQoSUFjdGlvbiBhY3Rpb24sIElXb3JrYmVuY2hQYXJ0IHRhcmdldFBhcnQpIHsKKwl9CisKKwlwdWJsaWMgdm9pZCBleGVjdXRlVXBkYXRlKElQcm9qZWN0IHByb2plY3QpIHsKKwkJdHJ5IHsKKwkJCW5ldyBBcnRpZmFjdFZlcnNpb25VcGRhdGUoKS5leGVjdXRlKHByb2plY3QpOworCQl9IGNhdGNoIChFeGNlcHRpb24gZSkgeworCQkJbG9nLmVycm9yKCJ7fSIsIGUpOworCisJCQlFcnJvckRpYWxvZworCQkJCQkub3BlbkVycm9yKAorCQkJCQkJCURpc3BsYXkuZ2V0Q3VycmVudCgpLmdldEFjdGl2ZVNoZWxsKCksCisJCQkJCQkJIkVycm9yIiwKKwkJCQkJCQllLnRvU3RyaW5nKCksCisJCQkJCQkJbmV3IFN0YXR1cyhJU3RhdHVzLkVSUk9SLAorCQkJCQkJCQkJIm9yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLmRldmVsb3BlciIsIGUKKwkJCQkJCQkJCQkJLnRvU3RyaW5nKCksIGUpKTsKKwkJfQorCX0KKworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS90b29scy9kZXZlbG9wZXIvVXBkYXRlRGVwZW5kZW5jeVZlcnNpb25zLmphdmEgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXIvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL3Rvb2xzL2RldmVsb3Blci9VcGRhdGVEZXBlbmRlbmN5VmVyc2lvbnMuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44YmI4ODhiCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS90b29scy9kZXZlbG9wZXIvVXBkYXRlRGVwZW5kZW5jeVZlcnNpb25zLmphdmEKQEAgLTAsMCArMSw3OSBAQAorLyoqCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTUgLSBMdW5pZmVyYSBHbWJIIChHcm9zcyBFbnplcnNkb3JmLCBBdXN0cmlhKSwgTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisgKgorICogQ29udHJpYnV0b3JzOgorICogICAgICAgICBGbG9yaWFuIFBpcmNobmVyIC0gSW5pdGlhbCBpbXBsZW1lbnRhdGlvbgorICovCisKK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyOworCitpbXBvcnQgamF2YS51dGlsLkl0ZXJhdG9yOworCitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5yZXNvdXJjZXMuSVByb2plY3Q7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklBZGFwdGFibGU7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklTdGF0dXM7CitpbXBvcnQgb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLlN0YXR1czsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS5hY3Rpb24uSUFjdGlvbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS5kaWFsb2dzLkVycm9yRGlhbG9nOworaW1wb3J0IG9yZy5lY2xpcHNlLmpmYWNlLnZpZXdlcnMuSVNlbGVjdGlvbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5qZmFjZS52aWV3ZXJzLklTdHJ1Y3R1cmVkU2VsZWN0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLnN3dC53aWRnZXRzLkRpc3BsYXk7CitpbXBvcnQgb3JnLmVjbGlwc2UudWkuSU9iamVjdEFjdGlvbkRlbGVnYXRlOworaW1wb3J0IG9yZy5lY2xpcHNlLnVpLklXb3JrYmVuY2hQYXJ0OworaW1wb3J0IG9yZy5zbGY0ai5Mb2dnZXJGYWN0b3J5OworCitwdWJsaWMgY2xhc3MgVXBkYXRlRGVwZW5kZW5jeVZlcnNpb25zIGltcGxlbWVudHMgSU9iamVjdEFjdGlvbkRlbGVnYXRlIHsKKworCXByaXZhdGUgc3RhdGljIGZpbmFsIG9yZy5zbGY0ai5Mb2dnZXIgbG9nID0gTG9nZ2VyRmFjdG9yeQorCQkJLmdldExvZ2dlcihVcGRhdGVEZXBlbmRlbmN5VmVyc2lvbnMuY2xhc3MpOworCisJcHJpdmF0ZSBJU2VsZWN0aW9uIHNlbGVjdGlvbjsKKworCXB1YmxpYyB2b2lkIHJ1bihJQWN0aW9uIGFjdGlvbikgeworCQlpZiAoc2VsZWN0aW9uIGluc3RhbmNlb2YgSVN0cnVjdHVyZWRTZWxlY3Rpb24pIHsKKwkJCWZvciAoSXRlcmF0b3I8Pz4gaXQgPSAoKElTdHJ1Y3R1cmVkU2VsZWN0aW9uKSBzZWxlY3Rpb24pLml0ZXJhdG9yKCk7IGl0CisJCQkJCS5oYXNOZXh0KCk7KSB7CisJCQkJT2JqZWN0IGVsZW1lbnQgPSBpdC5uZXh0KCk7CisJCQkJSVByb2plY3QgcHJvamVjdCA9IG51bGw7CisJCQkJaWYgKGVsZW1lbnQgaW5zdGFuY2VvZiBJUHJvamVjdCkgeworCQkJCQlwcm9qZWN0ID0gKElQcm9qZWN0KSBlbGVtZW50OworCQkJCX0gZWxzZSBpZiAoZWxlbWVudCBpbnN0YW5jZW9mIElBZGFwdGFibGUpIHsKKwkJCQkJcHJvamVjdCA9IChJUHJvamVjdCkgKChJQWRhcHRhYmxlKSBlbGVtZW50KQorCQkJCQkJCS5nZXRBZGFwdGVyKElQcm9qZWN0LmNsYXNzKTsKKwkJCQl9CisJCQkJaWYgKHByb2plY3QgIT0gbnVsbCkgeworCQkJCQlleGVjdXRlVXBkYXRlKHByb2plY3QpOworCQkJCX0KKwkJCX0KKwkJfQorCX0KKworCXB1YmxpYyB2b2lkIHNlbGVjdGlvbkNoYW5nZWQoSUFjdGlvbiBhY3Rpb24sIElTZWxlY3Rpb24gc2VsZWN0aW9uKSB7CisJCXRoaXMuc2VsZWN0aW9uID0gc2VsZWN0aW9uOworCX0KKworCXB1YmxpYyB2b2lkIHNldEFjdGl2ZVBhcnQoSUFjdGlvbiBhY3Rpb24sIElXb3JrYmVuY2hQYXJ0IHRhcmdldFBhcnQpIHsKKwl9CisKKwlwdWJsaWMgdm9pZCBleGVjdXRlVXBkYXRlKElQcm9qZWN0IHByb2plY3QpIHsKKwkJdHJ5IHsKKwkJCW5ldyBEZXBlbmRlbmN5VmVyc2lvblVwZGF0ZSgpLmV4ZWN1dGUocHJvamVjdCk7CisJCX0gY2F0Y2ggKEV4Y2VwdGlvbiBlKSB7CisJCQlsb2cuZXJyb3IoInt9IiwgZSk7CisKKwkJCUVycm9yRGlhbG9nCisJCQkJCS5vcGVuRXJyb3IoCisJCQkJCQkJRGlzcGxheS5nZXRDdXJyZW50KCkuZ2V0QWN0aXZlU2hlbGwoKSwKKwkJCQkJCQkiRXJyb3IiLAorCQkJCQkJCWUudG9TdHJpbmcoKSwKKwkJCQkJCQluZXcgU3RhdHVzKElTdGF0dXMuRVJST1IsCisJCQkJCQkJCQkib3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMuZGV2ZWxvcGVyIiwgZQorCQkJCQkJCQkJCQkudG9TdHJpbmcoKSwgZSkpOworCQl9CisJfQorCit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdC8ucHJvamVjdCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5wcm9kdWN0Ly5wcm9qZWN0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjViZjNkOWEKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdC8ucHJvamVjdApAQCAtMCwwICsxLDUwIEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPHByb2plY3REZXNjcmlwdGlvbj4KKwk8bmFtZT5vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdDwvbmFtZT4KKwk8Y29tbWVudD48L2NvbW1lbnQ+CisJPHByb2plY3RzPgorCTwvcHJvamVjdHM+CisJPGJ1aWxkU3BlYz4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLnh0ZXh0LnVpLnNoYXJlZC54dGV4dEJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UuamR0LmNvcmUuamF2YWJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UucGRlLk1hbmlmZXN0QnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuU2NoZW1hQnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuZHMuY29yZS5idWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5zb25hcmxpbnQuZWNsaXBzZS5jb3JlLnNvbmFybGludEJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UubTJlLmNvcmUubWF2ZW4yQnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJPC9idWlsZFNwZWM+CisJPG5hdHVyZXM+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UueHRleHQudWkuc2hhcmVkLnh0ZXh0TmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UubTJlLmNvcmUubWF2ZW4yTmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UucGRlLlBsdWdpbk5hdHVyZTwvbmF0dXJlPgorCQk8bmF0dXJlPm9yZy5lY2xpcHNlLmpkdC5jb3JlLmphdmFuYXR1cmU8L25hdHVyZT4KKwk8L25hdHVyZXM+Cis8L3Byb2plY3REZXNjcmlwdGlvbj4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5wcm9kdWN0L0xJQ0VOU0UudHh0IGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yLnByb2R1Y3QvTElDRU5TRS50eHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZmY0MmFkNAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5wcm9kdWN0L0xJQ0VOU0UudHh0CkBAIC0wLDAgKzEsMTYxIEBACitFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIC12IDEuMAorCitUSEUgQUNDT01QQU5ZSU5HIFBST0dSQU0gSVMgUFJPVklERUQgVU5ERVIgVEhFIFRFUk1TIE9GIFRISVMgRUNMSVBTRSBQVUJMSUMgTElDRU5TRSAoIkFHUkVFTUVOVCIpLiBBTlkgVVNFLCBSRVBST0RVQ1RJT04KK09SIERJU1RSSUJVVElPTiBPRiBUSEUgUFJPR1JBTSBDT05TVElUVVRFUyBSRUNJUElFTlQnUyBBQ0NFUFRBTkNFIE9GIFRISVMgQUdSRUVNRU5ULgorCisxLiBERUZJTklUSU9OUworCisiQ29udHJpYnV0aW9uIiBtZWFuczoKKworYSkgaW4gdGhlIGNhc2Ugb2YgdGhlIGluaXRpYWwgQ29udHJpYnV0b3IsIHRoZSBpbml0aWFsIGNvZGUgYW5kIGRvY3VtZW50YXRpb24gZGlzdHJpYnV0ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGFuZAorCitiKSBpbiB0aGUgY2FzZSBvZiBlYWNoIHN1YnNlcXVlbnQgQ29udHJpYnV0b3I6CisKK2kpIGNoYW5nZXMgdG8gdGhlIFByb2dyYW0sIGFuZAorCitpaSkgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtOworCit3aGVyZSBzdWNoIGNoYW5nZXMgYW5kL29yIGFkZGl0aW9ucyB0byB0aGUgUHJvZ3JhbSBvcmlnaW5hdGUgZnJvbSBhbmQgYXJlIGRpc3RyaWJ1dGVkIGJ5IHRoYXQgcGFydGljdWxhciBDb250cmlidXRvci4KK0EgQ29udHJpYnV0aW9uICdvcmlnaW5hdGVzJyBmcm9tIGEgQ29udHJpYnV0b3IgaWYgaXQgd2FzIGFkZGVkIHRvIHRoZSBQcm9ncmFtIGJ5IHN1Y2ggQ29udHJpYnV0b3IgaXRzZWxmIG9yIGFueW9uZQorYWN0aW5nIG9uIHN1Y2ggQ29udHJpYnV0b3IncyBiZWhhbGYuIENvbnRyaWJ1dGlvbnMgZG8gbm90IGluY2x1ZGUgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIHdoaWNoOiAoaSkgYXJlIHNlcGFyYXRlCittb2R1bGVzIG9mIHNvZnR3YXJlIGRpc3RyaWJ1dGVkIGluIGNvbmp1bmN0aW9uIHdpdGggdGhlIFByb2dyYW0gdW5kZXIgdGhlaXIgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBhbmQgKGlpKSBhcmUgbm90CitkZXJpdmF0aXZlIHdvcmtzIG9mIHRoZSBQcm9ncmFtLgorCisiQ29udHJpYnV0b3IiIG1lYW5zIGFueSBwZXJzb24gb3IgZW50aXR5IHRoYXQgZGlzdHJpYnV0ZXMgdGhlIFByb2dyYW0uCisKKyJMaWNlbnNlZCBQYXRlbnRzICIgbWVhbiBwYXRlbnQgY2xhaW1zIGxpY2Vuc2FibGUgYnkgYSBDb250cmlidXRvciB3aGljaCBhcmUgbmVjZXNzYXJpbHkgaW5mcmluZ2VkIGJ5IHRoZSB1c2Ugb3Igc2FsZSBvZgoraXRzIENvbnRyaWJ1dGlvbiBhbG9uZSBvciB3aGVuIGNvbWJpbmVkIHdpdGggdGhlIFByb2dyYW0uCisKKyJQcm9ncmFtIiBtZWFucyB0aGUgQ29udHJpYnV0aW9ucyBkaXN0cmlidXRlZCBpbiBhY2NvcmRhbmNlIHdpdGggdGhpcyBBZ3JlZW1lbnQuCisKKyJSZWNpcGllbnQiIG1lYW5zIGFueW9uZSB3aG8gcmVjZWl2ZXMgdGhlIFByb2dyYW0gdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIGluY2x1ZGluZyBhbGwgQ29udHJpYnV0b3JzLgorCisyLiBHUkFOVCBPRiBSSUdIVFMKKworYSkgU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsCityb3lhbHR5LWZyZWUgY29weXJpZ2h0IGxpY2Vuc2UgdG8gcmVwcm9kdWNlLCBwcmVwYXJlIGRlcml2YXRpdmUgd29ya3Mgb2YsIHB1YmxpY2x5IGRpc3BsYXksIHB1YmxpY2x5IHBlcmZvcm0sIGRpc3RyaWJ1dGUKK2FuZCBzdWJsaWNlbnNlIHRoZSBDb250cmlidXRpb24gb2Ygc3VjaCBDb250cmlidXRvciwgaWYgYW55LCBhbmQgc3VjaCBkZXJpdmF0aXZlIHdvcmtzLCBpbiBzb3VyY2UgY29kZSBhbmQgb2JqZWN0IGNvZGUKK2Zvcm0uCisKK2IpIFN1YmplY3QgdG8gdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBlYWNoIENvbnRyaWJ1dG9yIGhlcmVieSBncmFudHMgUmVjaXBpZW50IGEgbm9uLWV4Y2x1c2l2ZSwgd29ybGR3aWRlLAorcm95YWx0eS1mcmVlIHBhdGVudCBsaWNlbnNlIHVuZGVyIExpY2Vuc2VkIFBhdGVudHMgdG8gbWFrZSwgdXNlLCBzZWxsLCBvZmZlciB0byBzZWxsLCBpbXBvcnQgYW5kIG90aGVyd2lzZSB0cmFuc2ZlciB0aGUKK0NvbnRyaWJ1dGlvbiBvZiBzdWNoIENvbnRyaWJ1dG9yLCBpZiBhbnksIGluIHNvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZSBmb3JtLiBUaGlzIHBhdGVudCBsaWNlbnNlIHNoYWxsIGFwcGx5IHRvIHRoZQorY29tYmluYXRpb24gb2YgdGhlIENvbnRyaWJ1dGlvbiBhbmQgdGhlIFByb2dyYW0gaWYsIGF0IHRoZSB0aW1lIHRoZSBDb250cmlidXRpb24gaXMgYWRkZWQgYnkgdGhlIENvbnRyaWJ1dG9yLCBzdWNoCithZGRpdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGNhdXNlcyBzdWNoIGNvbWJpbmF0aW9uIHRvIGJlIGNvdmVyZWQgYnkgdGhlIExpY2Vuc2VkIFBhdGVudHMuIFRoZSBwYXRlbnQgbGljZW5zZSBzaGFsbCBub3QKK2FwcGx5IHRvIGFueSBvdGhlciBjb21iaW5hdGlvbnMgd2hpY2ggaW5jbHVkZSB0aGUgQ29udHJpYnV0aW9uLiBObyBoYXJkd2FyZSBwZXIgc2UgaXMgbGljZW5zZWQgaGVyZXVuZGVyLgorCitjKSBSZWNpcGllbnQgdW5kZXJzdGFuZHMgdGhhdCBhbHRob3VnaCBlYWNoIENvbnRyaWJ1dG9yIGdyYW50cyB0aGUgbGljZW5zZXMgdG8gaXRzIENvbnRyaWJ1dGlvbnMgc2V0IGZvcnRoIGhlcmVpbiwgbm8KK2Fzc3VyYW5jZXMgYXJlIHByb3ZpZGVkIGJ5IGFueSBDb250cmlidXRvciB0aGF0IHRoZSBQcm9ncmFtIGRvZXMgbm90IGluZnJpbmdlIHRoZSBwYXRlbnQgb3Igb3RoZXIgaW50ZWxsZWN0dWFsIHByb3BlcnR5CityaWdodHMgb2YgYW55IG90aGVyIGVudGl0eS4gRWFjaCBDb250cmlidXRvciBkaXNjbGFpbXMgYW55IGxpYWJpbGl0eSB0byBSZWNpcGllbnQgZm9yIGNsYWltcyBicm91Z2h0IGJ5IGFueSBvdGhlciBlbnRpdHkKK2Jhc2VkIG9uIGluZnJpbmdlbWVudCBvZiBpbnRlbGxlY3R1YWwgcHJvcGVydHkgcmlnaHRzIG9yIG90aGVyd2lzZS4gQXMgYSBjb25kaXRpb24gdG8gZXhlcmNpc2luZyB0aGUgcmlnaHRzIGFuZAorbGljZW5zZXMgZ3JhbnRlZCBoZXJldW5kZXIsIGVhY2ggUmVjaXBpZW50IGhlcmVieSBhc3N1bWVzIHNvbGUgcmVzcG9uc2liaWxpdHkgdG8gc2VjdXJlIGFueSBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkKK3JpZ2h0cyBuZWVkZWQsIGlmIGFueS4gRm9yIGV4YW1wbGUsIGlmIGEgdGhpcmQgcGFydHkgcGF0ZW50IGxpY2Vuc2UgaXMgcmVxdWlyZWQgdG8gYWxsb3cgUmVjaXBpZW50IHRvIGRpc3RyaWJ1dGUgdGhlCitQcm9ncmFtLCBpdCBpcyBSZWNpcGllbnQncyByZXNwb25zaWJpbGl0eSB0byBhY3F1aXJlIHRoYXQgbGljZW5zZSBiZWZvcmUgZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtLgorCitkKSBFYWNoIENvbnRyaWJ1dG9yIHJlcHJlc2VudHMgdGhhdCB0byBpdHMga25vd2xlZGdlIGl0IGhhcyBzdWZmaWNpZW50IGNvcHlyaWdodCByaWdodHMgaW4gaXRzIENvbnRyaWJ1dGlvbiwgaWYgYW55LCB0bworZ3JhbnQgdGhlIGNvcHlyaWdodCBsaWNlbnNlIHNldCBmb3J0aCBpbiB0aGlzIEFncmVlbWVudC4KKworMy4gUkVRVUlSRU1FTlRTCisKK0EgQ29udHJpYnV0b3IgbWF5IGNob29zZSB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtIGluIG9iamVjdCBjb2RlIGZvcm0gdW5kZXIgaXRzIG93biBsaWNlbnNlIGFncmVlbWVudCwgcHJvdmlkZWQgdGhhdDoKKworYSkgaXQgY29tcGxpZXMgd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgb2YgdGhpcyBBZ3JlZW1lbnQ7IGFuZAorCitiKSBpdHMgbGljZW5zZSBhZ3JlZW1lbnQ6CisKK2kpIGVmZmVjdGl2ZWx5IGRpc2NsYWltcyBvbiBiZWhhbGYgb2YgYWxsIENvbnRyaWJ1dG9ycyBhbGwgd2FycmFudGllcyBhbmQgY29uZGl0aW9ucywgZXhwcmVzcyBhbmQgaW1wbGllZCwgaW5jbHVkaW5nCit3YXJyYW50aWVzIG9yIGNvbmRpdGlvbnMgb2YgdGl0bGUgYW5kIG5vbi1pbmZyaW5nZW1lbnQsIGFuZCBpbXBsaWVkIHdhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiBtZXJjaGFudGFiaWxpdHkgYW5kCitmaXRuZXNzIGZvciBhIHBhcnRpY3VsYXIgcHVycG9zZTsKKworaWkpIGVmZmVjdGl2ZWx5IGV4Y2x1ZGVzIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCBsaWFiaWxpdHkgZm9yIGRhbWFnZXMsIGluY2x1ZGluZyBkaXJlY3QsIGluZGlyZWN0LCBzcGVjaWFsLAoraW5jaWRlbnRhbCBhbmQgY29uc2VxdWVudGlhbCBkYW1hZ2VzLCBzdWNoIGFzIGxvc3QgcHJvZml0czsKKworaWlpKSBzdGF0ZXMgdGhhdCBhbnkgcHJvdmlzaW9ucyB3aGljaCBkaWZmZXIgZnJvbSB0aGlzIEFncmVlbWVudCBhcmUgb2ZmZXJlZCBieSB0aGF0IENvbnRyaWJ1dG9yIGFsb25lIGFuZCBub3QgYnkgYW55CitvdGhlciBwYXJ0eTsgYW5kCisKK2l2KSBzdGF0ZXMgdGhhdCBzb3VyY2UgY29kZSBmb3IgdGhlIFByb2dyYW0gaXMgYXZhaWxhYmxlIGZyb20gc3VjaCBDb250cmlidXRvciwgYW5kIGluZm9ybXMgbGljZW5zZWVzIGhvdyB0byBvYnRhaW4gaXQKK2luIGEgcmVhc29uYWJsZSBtYW5uZXIgb24gb3IgdGhyb3VnaCBhIG1lZGl1bSBjdXN0b21hcmlseSB1c2VkIGZvciBzb2Z0d2FyZSBleGNoYW5nZS4KKworV2hlbiB0aGUgUHJvZ3JhbSBpcyBtYWRlIGF2YWlsYWJsZSBpbiBzb3VyY2UgY29kZSBmb3JtOgorCithKSBpdCBtdXN0IGJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoaXMgQWdyZWVtZW50OyBhbmQKKworYikgYSBjb3B5IG9mIHRoaXMgQWdyZWVtZW50IG11c3QgYmUgaW5jbHVkZWQgd2l0aCBlYWNoIGNvcHkgb2YgdGhlIFByb2dyYW0uCisKK0NvbnRyaWJ1dG9ycyBtYXkgbm90IHJlbW92ZSBvciBhbHRlciBhbnkgY29weXJpZ2h0IG5vdGljZXMgY29udGFpbmVkIHdpdGhpbiB0aGUgUHJvZ3JhbS4KKworRWFjaCBDb250cmlidXRvciBtdXN0IGlkZW50aWZ5IGl0c2VsZiBhcyB0aGUgb3JpZ2luYXRvciBvZiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIGluIGEgbWFubmVyIHRoYXQgcmVhc29uYWJseSBhbGxvd3MKK3N1YnNlcXVlbnQgUmVjaXBpZW50cyB0byBpZGVudGlmeSB0aGUgb3JpZ2luYXRvciBvZiB0aGUgQ29udHJpYnV0aW9uLgorCis0LiBDT01NRVJDSUFMIERJU1RSSUJVVElPTgorCitDb21tZXJjaWFsIGRpc3RyaWJ1dG9ycyBvZiBzb2Z0d2FyZSBtYXkgYWNjZXB0IGNlcnRhaW4gcmVzcG9uc2liaWxpdGllcyB3aXRoIHJlc3BlY3QgdG8gZW5kIHVzZXJzLCBidXNpbmVzcyBwYXJ0bmVycyBhbmQKK3RoZSBsaWtlLiBXaGlsZSB0aGlzIGxpY2Vuc2UgaXMgaW50ZW5kZWQgdG8gZmFjaWxpdGF0ZSB0aGUgY29tbWVyY2lhbCB1c2Ugb2YgdGhlIFByb2dyYW0sIHRoZSBDb250cmlidXRvciB3aG8gaW5jbHVkZXMKK3RoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nIHNob3VsZCBkbyBzbyBpbiBhIG1hbm5lciB3aGljaCBkb2VzIG5vdCBjcmVhdGUgcG90ZW50aWFsIGxpYWJpbGl0eSBmb3IKK290aGVyIENvbnRyaWJ1dG9ycy4gVGhlcmVmb3JlLCBpZiBhIENvbnRyaWJ1dG9yIGluY2x1ZGVzIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBzdWNoIENvbnRyaWJ1dG9yCisoIkNvbW1lcmNpYWwgQ29udHJpYnV0b3IiKSBoZXJlYnkgYWdyZWVzIHRvIGRlZmVuZCBhbmQgaW5kZW1uaWZ5IGV2ZXJ5IG90aGVyIENvbnRyaWJ1dG9yICgiSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IiKQorYWdhaW5zdCBhbnkgbG9zc2VzLCBkYW1hZ2VzIGFuZCBjb3N0cyAoY29sbGVjdGl2ZWx5ICJMb3NzZXMiKSBhcmlzaW5nIGZyb20gY2xhaW1zLCBsYXdzdWl0cyBhbmQgb3RoZXIgbGVnYWwgYWN0aW9ucworYnJvdWdodCBieSBhIHRoaXJkIHBhcnR5IGFnYWluc3QgdGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIHRvIHRoZSBleHRlbnQgY2F1c2VkIGJ5IHRoZSBhY3RzIG9yIG9taXNzaW9ucyBvZiBzdWNoCitDb21tZXJjaWFsIENvbnRyaWJ1dG9yIGluIGNvbm5lY3Rpb24gd2l0aCBpdHMgZGlzdHJpYnV0aW9uIG9mIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLiBUaGUKK29ibGlnYXRpb25zIGluIHRoaXMgc2VjdGlvbiBkbyBub3QgYXBwbHkgdG8gYW55IGNsYWltcyBvciBMb3NzZXMgcmVsYXRpbmcgdG8gYW55IGFjdHVhbCBvciBhbGxlZ2VkIGludGVsbGVjdHVhbAorcHJvcGVydHkgaW5mcmluZ2VtZW50LiBJbiBvcmRlciB0byBxdWFsaWZ5LCBhbiBJbmRlbW5pZmllZCBDb250cmlidXRvciBtdXN0OiBhKSBwcm9tcHRseSBub3RpZnkgdGhlIENvbW1lcmNpYWwKK0NvbnRyaWJ1dG9yIGluIHdyaXRpbmcgb2Ygc3VjaCBjbGFpbSwgYW5kIGIpIGFsbG93IHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRvIGNvbnRyb2wsIGFuZCBjb29wZXJhdGUgd2l0aCB0aGUKK0NvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4sIHRoZSBkZWZlbnNlIGFuZCBhbnkgcmVsYXRlZCBzZXR0bGVtZW50IG5lZ290aWF0aW9ucy4gVGhlIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG1heQorIHBhcnRpY2lwYXRlIGluIGFueSBzdWNoIGNsYWltIGF0IGl0cyBvd24gZXhwZW5zZS4KKworRm9yIGV4YW1wbGUsIGEgQ29udHJpYnV0b3IgbWlnaHQgaW5jbHVkZSB0aGUgUHJvZ3JhbSBpbiBhIGNvbW1lcmNpYWwgcHJvZHVjdCBvZmZlcmluZywgUHJvZHVjdCBYLiBUaGF0IENvbnRyaWJ1dG9yIGlzCit0aGVuIGEgQ29tbWVyY2lhbCBDb250cmlidXRvci4gSWYgdGhhdCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHRoZW4gbWFrZXMgcGVyZm9ybWFuY2UgY2xhaW1zLCBvciBvZmZlcnMgd2FycmFudGllcworcmVsYXRlZCB0byBQcm9kdWN0IFgsIHRob3NlIHBlcmZvcm1hbmNlIGNsYWltcyBhbmQgd2FycmFudGllcyBhcmUgc3VjaCBDb21tZXJjaWFsIENvbnRyaWJ1dG9yJ3MgcmVzcG9uc2liaWxpdHkgYWxvbmUuCitVbmRlciB0aGlzIHNlY3Rpb24sIHRoZSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yIHdvdWxkIGhhdmUgdG8gZGVmZW5kIGNsYWltcyBhZ2FpbnN0IHRoZSBvdGhlciBDb250cmlidXRvcnMgcmVsYXRlZCB0bwordGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZCB3YXJyYW50aWVzLCBhbmQgaWYgYSBjb3VydCByZXF1aXJlcyBhbnkgb3RoZXIgQ29udHJpYnV0b3IgdG8gcGF5IGFueSBkYW1hZ2VzIGFzIGEgcmVzdWx0LAordGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgbXVzdCBwYXkgdGhvc2UgZGFtYWdlcy4KKworNS4gTk8gV0FSUkFOVFkKKworRVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUyBBR1JFRU1FTlQsIFRIRSBQUk9HUkFNIElTIFBST1ZJREVEIE9OIEFOICJBUyBJUyIgQkFTSVMsIFdJVEhPVVQgV0FSUkFOVElFUyBPUgorQ09ORElUSU9OUyBPRiBBTlkgS0lORCwgRUlUSEVSIEVYUFJFU1MgT1IgSU1QTElFRCBJTkNMVURJTkcsIFdJVEhPVVQgTElNSVRBVElPTiwgQU5ZIFdBUlJBTlRJRVMgT1IgQ09ORElUSU9OUyBPRiBUSVRMRSwKK05PTi1JTkZSSU5HRU1FTlQsIE1FUkNIQU5UQUJJTElUWSBPUiBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gRWFjaCBSZWNpcGllbnQgaXMgc29sZWx5IHJlc3BvbnNpYmxlIGZvcgorZGV0ZXJtaW5pbmcgdGhlIGFwcHJvcHJpYXRlbmVzcyBvZiB1c2luZyBhbmQgZGlzdHJpYnV0aW5nIHRoZSBQcm9ncmFtIGFuZCBhc3N1bWVzIGFsbCByaXNrcyBhc3NvY2lhdGVkIHdpdGggaXRzCitleGVyY2lzZSBvZiByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgLCBpbmNsdWRpbmcgYnV0IG5vdCBsaW1pdGVkIHRvIHRoZSByaXNrcyBhbmQgY29zdHMgb2YgcHJvZ3JhbSBlcnJvcnMsIGNvbXBsaWFuY2UKK3dpdGggYXBwbGljYWJsZSBsYXdzLCBkYW1hZ2UgdG8gb3IgbG9zcyBvZiBkYXRhLCBwcm9ncmFtcyBvciBlcXVpcG1lbnQsIGFuZCB1bmF2YWlsYWJpbGl0eSBvciBpbnRlcnJ1cHRpb24gb2Ygb3BlcmF0aW9ucy4KKworNi4gRElTQ0xBSU1FUiBPRiBMSUFCSUxJVFkKKworRVhDRVBUIEFTIEVYUFJFU1NMWSBTRVQgRk9SVEggSU4gVEhJUyBBR1JFRU1FTlQsIE5FSVRIRVIgUkVDSVBJRU5UIE5PUiBBTlkgQ09OVFJJQlVUT1JTIFNIQUxMIEhBVkUgQU5ZIExJQUJJTElUWSBGT1IgQU5ZCitESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HIFdJVEhPVVQgTElNSVRBVElPTiBMT1NUIFBST0ZJVFMpLAorSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUgorT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIE9SIFRIRSBFWEVSQ0lTRSBPRiBBTlkgUklHSFRTIEdSQU5URUQKK0hFUkVVTkRFUiwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRVMuCisKKzcuIEdFTkVSQUwKKworSWYgYW55IHByb3Zpc2lvbiBvZiB0aGlzIEFncmVlbWVudCBpcyBpbnZhbGlkIG9yIHVuZW5mb3JjZWFibGUgdW5kZXIgYXBwbGljYWJsZSBsYXcsIGl0IHNoYWxsIG5vdCBhZmZlY3QgdGhlIHZhbGlkaXR5IG9yCitlbmZvcmNlYWJpbGl0eSBvZiB0aGUgcmVtYWluZGVyIG9mIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgYW5kIHdpdGhvdXQgZnVydGhlciBhY3Rpb24gYnkgdGhlIHBhcnRpZXMgaGVyZXRvLCBzdWNoCitwcm92aXNpb24gc2hhbGwgYmUgcmVmb3JtZWQgdG8gdGhlIG1pbmltdW0gZXh0ZW50IG5lY2Vzc2FyeSB0byBtYWtlIHN1Y2ggcHJvdmlzaW9uIHZhbGlkIGFuZCBlbmZvcmNlYWJsZS4KKworSWYgUmVjaXBpZW50IGluc3RpdHV0ZXMgcGF0ZW50IGxpdGlnYXRpb24gYWdhaW5zdCBhbnkgZW50aXR5IChpbmNsdWRpbmcgYSBjcm9zcy1jbGFpbSBvciBjb3VudGVyY2xhaW0gaW4gYSBsYXdzdWl0KQorYWxsZWdpbmcgdGhhdCB0aGUgUHJvZ3JhbSBpdHNlbGYgKGV4Y2x1ZGluZyBjb21iaW5hdGlvbnMgb2YgdGhlIFByb2dyYW0gd2l0aCBvdGhlciBzb2Z0d2FyZSBvciBoYXJkd2FyZSkgaW5mcmluZ2VzIHN1Y2gKK1JlY2lwaWVudCdzIHBhdGVudChzKSwgdGhlbiBzdWNoIFJlY2lwaWVudCdzIHJpZ2h0cyBncmFudGVkIHVuZGVyIFNlY3Rpb24gMihiKSBzaGFsbCB0ZXJtaW5hdGUgYXMgb2YgdGhlIGRhdGUgc3VjaAorbGl0aWdhdGlvbiBpcyBmaWxlZC4KKworQWxsIFJlY2lwaWVudCdzIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCBzaGFsbCB0ZXJtaW5hdGUgaWYgaXQgZmFpbHMgdG8gY29tcGx5IHdpdGggYW55IG9mIHRoZSBtYXRlcmlhbCB0ZXJtcyBvcgorY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudCBhbmQgZG9lcyBub3QgY3VyZSBzdWNoIGZhaWx1cmUgaW4gYSByZWFzb25hYmxlIHBlcmlvZCBvZiB0aW1lIGFmdGVyIGJlY29taW5nIGF3YXJlIG9mIHN1Y2gKK25vbmNvbXBsaWFuY2UuIElmIGFsbCBSZWNpcGllbnQncyByaWdodHMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgdGVybWluYXRlLCBSZWNpcGllbnQgYWdyZWVzIHRvIGNlYXNlIHVzZSBhbmQgZGlzdHJpYnV0aW9uCitvZiB0aGUgUHJvZ3JhbSBhcyBzb29uIGFzIHJlYXNvbmFibHkgcHJhY3RpY2FibGUuIEhvd2V2ZXIsIFJlY2lwaWVudCdzIG9ibGlnYXRpb25zIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFuZCBhbnkgbGljZW5zZXMKKyBncmFudGVkIGJ5IFJlY2lwaWVudCByZWxhdGluZyB0byB0aGUgUHJvZ3JhbSBzaGFsbCBjb250aW51ZSBhbmQgc3Vydml2ZS4KKworRXZlcnlvbmUgaXMgcGVybWl0dGVkIHRvIGNvcHkgYW5kIGRpc3RyaWJ1dGUgY29waWVzIG9mIHRoaXMgQWdyZWVtZW50LCBidXQgaW4gb3JkZXIgdG8gYXZvaWQgaW5jb25zaXN0ZW5jeSB0aGUgQWdyZWVtZW50CitpcyBjb3B5cmlnaHRlZCBhbmQgbWF5IG9ubHkgYmUgbW9kaWZpZWQgaW4gdGhlIGZvbGxvd2luZyBtYW5uZXIuIFRoZSBBZ3JlZW1lbnQgU3Rld2FyZCByZXNlcnZlcyB0aGUgcmlnaHQgdG8gcHVibGlzaAorbmV3IHZlcnNpb25zIChpbmNsdWRpbmcgcmV2aXNpb25zKSBvZiB0aGlzIEFncmVlbWVudCBmcm9tIHRpbWUgdG8gdGltZS4gTm8gb25lIG90aGVyIHRoYW4gdGhlIEFncmVlbWVudCBTdGV3YXJkIGhhcyB0aGUKK3JpZ2h0IHRvIG1vZGlmeSB0aGlzIEFncmVlbWVudC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyB0aGUgaW5pdGlhbCBBZ3JlZW1lbnQgU3Rld2FyZC4gVGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYXkKK2Fzc2lnbiB0aGUgcmVzcG9uc2liaWxpdHkgdG8gc2VydmUgYXMgdGhlIEFncmVlbWVudCBTdGV3YXJkIHRvIGEgc3VpdGFibGUgc2VwYXJhdGUgZW50aXR5LiBFYWNoIG5ldyB2ZXJzaW9uIG9mIHRoZQorQWdyZWVtZW50IHdpbGwgYmUgZ2l2ZW4gYSBkaXN0aW5ndWlzaGluZyB2ZXJzaW9uIG51bWJlci4gVGhlIFByb2dyYW0gKGluY2x1ZGluZyBDb250cmlidXRpb25zKSBtYXkgYWx3YXlzIGJlCitkaXN0cmlidXRlZCBzdWJqZWN0IHRvIHRoZSB2ZXJzaW9uIG9mIHRoZSBBZ3JlZW1lbnQgdW5kZXIgd2hpY2ggaXQgd2FzIHJlY2VpdmVkLiBJbiBhZGRpdGlvbiwgYWZ0ZXIgYSBuZXcgdmVyc2lvbiBvZgordGhlIEFncmVlbWVudCBpcyBwdWJsaXNoZWQsIENvbnRyaWJ1dG9yIG1heSBlbGVjdCB0byBkaXN0cmlidXRlIHRoZSBQcm9ncmFtIChpbmNsdWRpbmcgaXRzIENvbnRyaWJ1dGlvbnMpIHVuZGVyIHRoZQorbmV3IHZlcnNpb24uIEV4Y2VwdCBhcyBleHByZXNzbHkgc3RhdGVkIGluIFNlY3Rpb25zIDIoYSkgYW5kIDIoYikgYWJvdmUsIFJlY2lwaWVudCByZWNlaXZlcyBubyByaWdodHMgb3IgbGljZW5zZXMgdG8KK3RoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgb2YgYW55IENvbnRyaWJ1dG9yIHVuZGVyIHRoaXMgQWdyZWVtZW50LCB3aGV0aGVyIGV4cHJlc3NseSwgYnkgaW1wbGljYXRpb24sIGVzdG9wcGVsIG9yCitvdGhlcndpc2UuIEFsbCByaWdodHMgaW4gdGhlIFByb2dyYW0gbm90IGV4cHJlc3NseSBncmFudGVkIHVuZGVyIHRoaXMgQWdyZWVtZW50IGFyZSByZXNlcnZlZC4KKworVGhpcyBBZ3JlZW1lbnQgaXMgZ292ZXJuZWQgYnkgdGhlIGxhd3Mgb2YgdGhlIFN0YXRlIG9mIE5ldyBZb3JrIGFuZCB0aGUgaW50ZWxsZWN0dWFsIHByb3BlcnR5IGxhd3Mgb2YgdGhlIFVuaXRlZCBTdGF0ZXMKK29mIEFtZXJpY2EuIE5vIHBhcnR5IHRvIHRoaXMgQWdyZWVtZW50IHdpbGwgYnJpbmcgYSBsZWdhbCBhY3Rpb24gdW5kZXIgdGhpcyBBZ3JlZW1lbnQgbW9yZSB0aGFuIG9uZSB5ZWFyIGFmdGVyIHRoZSBjYXVzZQorb2YgYWN0aW9uIGFyb3NlLiBFYWNoIHBhcnR5IHdhaXZlcyBpdHMgcmlnaHRzIHRvIGEganVyeSB0cmlhbCBpbiBhbnkgcmVzdWx0aW5nIGxpdGlnYXRpb24uClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yLnByb2R1Y3QvTUVUQS1JTkYvTUFOSUZFU1QuTUYgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdC9NRVRBLUlORi9NQU5JRkVTVC5NRgpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4wNTk3NjM2Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yLnByb2R1Y3QvTUVUQS1JTkYvTUFOSUZFU1QuTUYKQEAgLTAsMCArMSwxNSBAQAorTWFuaWZlc3QtVmVyc2lvbjogMS4wCitCdW5kbGUtTWFuaWZlc3RWZXJzaW9uOiAyCitCdW5kbGUtTmFtZTogb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yLnByb2R1Y3QKK0J1bmRsZS1TeW1ib2xpY05hbWU6IG9yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5wcm9kdWN0O3NpbmdsZXRvbjo9dHJ1ZQorQnVuZGxlLVZlcnNpb246IDAuOS4wLnF1YWxpZmllcgorQnVuZGxlLVZlbmRvcjogRWNsaXBzZSBPU0JQCitSZXF1aXJlLUJ1bmRsZTogb3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLAorIG9yZy5lY2xpcHNlLmVxdWlub3gucDIuYXJ0aWZhY3QucmVwb3NpdG9yeTtidW5kbGUtdmVyc2lvbj0iMS4xLjMwMCIsCisgb3JnLmVjbGlwc2UuZXF1aW5veC5wMi5yZXBvc2l0b3J5LnRvb2xzO2J1bmRsZS12ZXJzaW9uPSIyLjEuMCIKK0J1bmRsZS1SZXF1aXJlZEV4ZWN1dGlvbkVudmlyb25tZW50OiBKYXZhU0UtMS43CitCdW5kbGUtQWN0aXZhdGlvblBvbGljeTogbGF6eQorSW1wb3J0LVBhY2thZ2U6IG9yZy5vc2dpLnNlcnZpY2UuY29tcG9uZW50O3ZlcnNpb249IjEuMi4yIiwKKyBvcmcub3NnaS5zZXJ2aWNlLmNvbXBvbmVudC5hbm5vdGF0aW9uczt2ZXJzaW9uPSIxLjIuMCIsCisgb3JnLnNsZjRqO3ZlcnNpb249IjEuNy4yIgorU2VydmljZS1Db21wb25lbnQ6IE9TR0ktSU5GL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5Db25zb2xlQ29tbWFuZHMueG1sCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdC9PU0dJLUlORi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IuQ29uc29sZUNvbW1hbmRzLnhtbCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5wcm9kdWN0L09TR0ktSU5GL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5Db25zb2xlQ29tbWFuZHMueG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjEwNmY3ZTUKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdC9PU0dJLUlORi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IuQ29uc29sZUNvbW1hbmRzLnhtbApAQCAtMCwwICsxLDkgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8c2NyOmNvbXBvbmVudCB4bWxuczpzY3I9Imh0dHA6Ly93d3cub3NnaS5vcmcveG1sbnMvc2NyL3YxLjEuMCIgYWN0aXZhdGU9ImFjdGl2YXRlIiBkZWFjdGl2YXRlPSJkZWFjdGl2YXRlIiBuYW1lPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IuQ29uc29sZUNvbW1hbmRzIj4KKyAgIDxpbXBsZW1lbnRhdGlvbiBjbGFzcz0ib3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yLkNvbnNvbGVDb21tYW5kcyIvPgorICAgPHNlcnZpY2U+CisgICAgICA8cHJvdmlkZSBpbnRlcmZhY2U9Im9yZy5lY2xpcHNlLm9zZ2kuZnJhbWV3b3JrLmNvbnNvbGUuQ29tbWFuZFByb3ZpZGVyIi8+CisgICA8L3NlcnZpY2U+CisgICA8cmVmZXJlbmNlIGJpbmQ9ImJpbmRBcnRpZmFjdHMiIGNhcmRpbmFsaXR5PSIxLi4xIiBpbnRlcmZhY2U9Im9yZy5vc2dpLnNlcnZpY2UuYXBwbGljYXRpb24uQXBwbGljYXRpb25EZXNjcmlwdG9yIiBuYW1lPSJBcnRpZmFjdHMiIHBvbGljeT0ic3RhdGljIiB0YXJnZXQ9IihzZXJ2aWNlLnBpZD1vcmcuZWNsaXBzZS5lcXVpbm94LnAyLmFydGlmYWN0LnJlcG9zaXRvcnkubWlycm9yQXBwbGljYXRpb24pIi8+CisgICA8cmVmZXJlbmNlIGJpbmQ9ImJpbmRNZXRhZGF0YSIgY2FyZGluYWxpdHk9IjEuLjEiIGludGVyZmFjZT0ib3JnLm9zZ2kuc2VydmljZS5hcHBsaWNhdGlvbi5BcHBsaWNhdGlvbkRlc2NyaXB0b3IiIG5hbWU9Ik1ldGFkYXRhIiBwb2xpY3k9InN0YXRpYyIgdGFyZ2V0PSIoc2VydmljZS5waWQ9b3JnLmVjbGlwc2UuZXF1aW5veC5wMi5tZXRhZGF0YS5yZXBvc2l0b3J5Lm1pcnJvckFwcGxpY2F0aW9uKSIvPgorPC9zY3I6Y29tcG9uZW50PgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5wcm9kdWN0L2J1aWxkLnByb3BlcnRpZXMgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdC9idWlsZC5wcm9wZXJ0aWVzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmMzMTRiMTIKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdC9idWlsZC5wcm9wZXJ0aWVzCkBAIC0wLDAgKzEsMTAgQEAKK291dHB1dC4uID0gYmluLworYmluLmluY2x1ZGVzID0gTUVUQS1JTkYvLFwKKyAgICAgICAgICAgICAgIC4sXAorICAgICAgICAgICAgICAgcGx1Z2luLnhtbCxcCisgICAgICAgICAgICAgICBPU0dJLUlORi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IuQ29uc29sZUNvbW1hbmRzLnhtbCxcCisgICAgICAgICAgICAgICBMSUNFTlNFLnR4dCxcCisgICAgICAgICAgICAgICBsaWNlbnNlLmh0bWwKK3NvdXJjZS4uID0gc3JjLworc3JjLmluY2x1ZGVzID0gTElDRU5TRS50eHQsXAorICAgICAgICAgICAgICAgbGljZW5zZS5odG1sCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdC9saWNlbnNlLmh0bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdC9saWNlbnNlLmh0bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uYzMzZDQ1YwotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5wcm9kdWN0L2xpY2Vuc2UuaHRtbApAQCAtMCwwICsxLDEwOSBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iSVNPLTg4NTktMSIgPz4KKzwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFN0cmljdC8vRU4iICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS1zdHJpY3QuZHRkIj4KKzwhLS0gc2F2ZWQgZnJvbSB1cmw9KDAwNDQpaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwvbm90aWNlLmh0bWwgLS0+Cis8aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+Cis8aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiIC8+Cis8dGl0bGU+RWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC90aXRsZT4KKzwvaGVhZD4KKworPGJvZHkgbGFuZz0iRU4tVVMiPgorPGgyPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvaDI+Cis8cD5GZWJydWFyeSAxLCAyMDExPC9wPgorCis8aDM+VXNhZ2UgT2YgQ29udGVudDwvaDM+CisKKzxwPlRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiBBTkQvT1IgT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUworICAgKENPTExFQ1RJVkVMWSAmcXVvdDtDT05URU5UJnF1b3Q7KS4gIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQKKyAgIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VIEFHUkVFIFRIQVQgWU9VUiBVU0UKKyAgIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SCisgICBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQKKyAgIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULjwvcD4KKworPGgzPkFwcGxpY2FibGUgTGljZW5zZXM8L2gzPgorCis8cD5Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wCisgICAoJnF1b3Q7RVBMJnF1b3Q7KS4gIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpcyBDb250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L2E+LgorICAgRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICZxdW90O1Byb2dyYW0mcXVvdDsgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvcD4KKworPHA+Q29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsIGRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBzb3VyY2UgY29kZQorICAgcmVwb3NpdG9yeSAoJnF1b3Q7UmVwb3NpdG9yeSZxdW90OykgaW4gc29mdHdhcmUgbW9kdWxlcyAoJnF1b3Q7TW9kdWxlcyZxdW90OykgYW5kIG1hZGUgYXZhaWxhYmxlIGFzIGRvd25sb2FkYWJsZSBhcmNoaXZlcyAoJnF1b3Q7RG93bmxvYWRzJnF1b3Q7KS48L3A+CisKKzx1bD4KKyAgICAgICA8bGk+Q29udGVudCBtYXkgYmUgc3RydWN0dXJlZCBhbmQgcGFja2FnZWQgaW50byBtb2R1bGVzIHRvIGZhY2lsaXRhdGUgZGVsaXZlcmluZywgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiAgVHlwaWNhbCBtb2R1bGVzIG1heSBpbmNsdWRlIHBsdWctaW5zICgmcXVvdDtQbHVnLWlucyZxdW90OyksIHBsdWctaW4gZnJhZ21lbnRzICgmcXVvdDtGcmFnbWVudHMmcXVvdDspLCBhbmQgZmVhdHVyZXMgKCZxdW90O0ZlYXR1cmVzJnF1b3Q7KS48L2xpPgorICAgICAgIDxsaT5FYWNoIFBsdWctaW4gb3IgRnJhZ21lbnQgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBvciBKQVIgKEphdmEmdHJhZGU7IEFSY2hpdmUpIGluIGEgZGlyZWN0b3J5IG5hbWVkICZxdW90O3BsdWdpbnMmcXVvdDsuPC9saT4KKyAgICAgICA8bGk+QSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuICBFYWNoIEZlYXR1cmUgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtmZWF0dXJlcyZxdW90Oy4gIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUueG1sJnF1b3Q7IG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMKKyAgICAgIGFuZC9vciBGcmFnbWVudHMgYXNzb2NpYXRlZCB3aXRoIHRoYXQgRmVhdHVyZS48L2xpPgorICAgICAgIDxsaT5GZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgmcXVvdDtJbmNsdWRlZCBGZWF0dXJlcyZxdW90OykuIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUueG1sJnF1b3Q7IG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy48L2xpPgorPC91bD4KKworPHA+VGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZSBjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgJnF1b3Q7YWJvdXQuaHRtbCZxdW90OyAoJnF1b3Q7QWJvdXRzJnF1b3Q7KS4gVGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBGZWF0dXJlcyBhbmQKK0luY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgJnF1b3Q7bGljZW5zZS5odG1sJnF1b3Q7ICgmcXVvdDtGZWF0dXJlIExpY2Vuc2VzJnF1b3Q7KS4gIEFib3V0cyBhbmQgRmVhdHVyZSBMaWNlbnNlcyBtYXkgYmUgbG9jYXRlZCBpbiBhbnkgZGlyZWN0b3J5IG9mIGEgRG93bmxvYWQgb3IgTW9kdWxlCitpbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIGxvY2F0aW9uczo8L3A+CisKKzx1bD4KKyAgICAgICA8bGk+VGhlIHRvcC1sZXZlbCAocm9vdCkgZGlyZWN0b3J5PC9saT4KKyAgICAgICA8bGk+UGx1Zy1pbiBhbmQgRnJhZ21lbnQgZGlyZWN0b3JpZXM8L2xpPgorICAgICAgIDxsaT5JbnNpZGUgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBwYWNrYWdlZCBhcyBKQVJzPC9saT4KKyAgICAgICA8bGk+U3ViLWRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgJnF1b3Q7c3JjJnF1b3Q7IG9mIGNlcnRhaW4gUGx1Zy1pbnM8L2xpPgorICAgICAgIDxsaT5GZWF0dXJlIGRpcmVjdG9yaWVzPC9saT4KKzwvdWw+CisKKzxwPk5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIGluc3RhbGxlZCB1c2luZyB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgKGFzIGRlZmluZWQgYmVsb3cpLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCZxdW90O0ZlYXR1cmUgVXBkYXRlIExpY2Vuc2UmcXVvdDspIGR1cmluZyB0aGUKK2luc3RhbGxhdGlvbiBwcm9jZXNzLiAgSWYgdGhlIEZlYXR1cmUgY29udGFpbnMgSW5jbHVkZWQgRmVhdHVyZXMsIHRoZSBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIHNob3VsZCBlaXRoZXIgcHJvdmlkZSB5b3Ugd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvcgoraW5mb3JtIHlvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiAgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgbWF5IGJlIGZvdW5kIGluIHRoZSAmcXVvdDtsaWNlbnNlJnF1b3Q7IHByb3BlcnR5IG9mIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUucHJvcGVydGllcyZxdW90OyBmb3VuZCB3aXRoaW4gYSBGZWF0dXJlLgorU3VjaCBBYm91dHMsIEZlYXR1cmUgTGljZW5zZXMsIGFuZCBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBjb250YWluIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyAob3IgcmVmZXJlbmNlcyB0byBzdWNoIHRlcm1zIGFuZCBjb25kaXRpb25zKSB0aGF0IGdvdmVybiB5b3VyIHVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluCit0aGF0IGRpcmVjdG9yeS48L3A+CisKKzxwPlRIRSBBQk9VVFMsIEZFQVRVUkUgTElDRU5TRVMsIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVIgVE8gVEhFIEVQTCBPUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuICBTT01FIE9GIFRIRVNFCitPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOjwvcD4KKworPHVsPgorICAgICAgIDxsaT5FY2xpcHNlIERpc3RyaWJ1dGlvbiBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9saWNlbnNlcy9lZGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGljZW5zZXMvZWRsLXYxLjAuaHRtbDwvYT4pPC9saT4KKyAgICAgICA8bGk+Q29tbW9uIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sPC9hPik8L2xpPgorICAgICAgIDxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAxLjEgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRSI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0U8L2E+KTwvbGk+CisgICAgICAgPGxpPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDIuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMCI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wPC9hPik8L2xpPgorICAgICAgIDxsaT5NZXRybyBMaW5rIFB1YmxpYyBMaWNlbnNlIDEuMDAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbCI+aHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWw8L2E+KTwvbGk+CisgICAgICAgPGxpPk1vemlsbGEgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjEgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWwiPmh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbDwvYT4pPC9saT4KKzwvdWw+CisKKzxwPklUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1IgVE8gVVNFIE9GIFRIRSBDT05URU5ULiAgSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSwgb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBpcyBwcm92aWRlZCwgcGxlYXNlCitjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LjwvcD4KKworCis8aDM+VXNlIG9mIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5PC9oMz4KKworPHA+VGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYWtlcyBhdmFpbGFibGUgcHJvdmlzaW9uaW5nIHNvZnR3YXJlLCBleGFtcGxlcyBvZiB3aGljaCBpbmNsdWRlLCBidXQgYXJlIG5vdCBsaW1pdGVkIHRvLCBwMiBhbmQgdGhlIEVjbGlwc2UKKyAgIFVwZGF0ZSBNYW5hZ2VyICgmcXVvdDtQcm92aXNpb25pbmcgVGVjaG5vbG9neSZxdW90OykgZm9yIHRoZSBwdXJwb3NlIG9mIGFsbG93aW5nIHVzZXJzIHRvIGluc3RhbGwgc29mdHdhcmUsIGRvY3VtZW50YXRpb24sIGluZm9ybWF0aW9uIGFuZC9vcgorICAgb3RoZXIgbWF0ZXJpYWxzIChjb2xsZWN0aXZlbHkgJnF1b3Q7SW5zdGFsbGFibGUgU29mdHdhcmUmcXVvdDspLiBUaGlzIGNhcGFiaWxpdHkgaXMgcHJvdmlkZWQgd2l0aCB0aGUgaW50ZW50IG9mIGFsbG93aW5nIHN1Y2ggdXNlcnMgdG8KKyAgIGluc3RhbGwsIGV4dGVuZCBhbmQgdXBkYXRlIEVjbGlwc2UtYmFzZWQgcHJvZHVjdHMuIEluZm9ybWF0aW9uIGFib3V0IHBhY2thZ2luZyBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBpcyBhdmFpbGFibGUgYXQgPGEKKyAgICAgICBocmVmPSJodHRwOi8vZWNsaXBzZS5vcmcvZXF1aW5veC9wMi9yZXBvc2l0b3J5X3BhY2thZ2luZy5odG1sIj5odHRwOi8vZWNsaXBzZS5vcmcvZXF1aW5veC9wMi9yZXBvc2l0b3J5X3BhY2thZ2luZy5odG1sPC9hPgorICAgKCZxdW90O1NwZWNpZmljYXRpb24mcXVvdDspLjwvcD4KKworPHA+WW91IG1heSB1c2UgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgdG8gYWxsb3cgb3RoZXIgcGFydGllcyB0byBpbnN0YWxsIEluc3RhbGxhYmxlIFNvZnR3YXJlLiBZb3Ugc2hhbGwgYmUgcmVzcG9uc2libGUgZm9yIGVuYWJsaW5nIHRoZQorICAgYXBwbGljYWJsZSBsaWNlbnNlIGFncmVlbWVudHMgcmVsYXRpbmcgdG8gdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlIHRvIGJlIHByZXNlbnRlZCB0bywgYW5kIGFjY2VwdGVkIGJ5LCB0aGUgdXNlcnMgb2YgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5CisgICBpbiBhY2NvcmRhbmNlIHdpdGggdGhlIFNwZWNpZmljYXRpb24uIEJ5IHVzaW5nIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IGluIHN1Y2ggYSBtYW5uZXIgYW5kIG1ha2luZyBpdCBhdmFpbGFibGUgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZQorICAgU3BlY2lmaWNhdGlvbiwgeW91IGZ1cnRoZXIgYWNrbm93bGVkZ2UgeW91ciBhZ3JlZW1lbnQgdG8sIGFuZCB0aGUgYWNxdWlzaXRpb24gb2YgYWxsIG5lY2Vzc2FyeSByaWdodHMgdG8gcGVybWl0IHRoZSBmb2xsb3dpbmc6PC9wPgorCis8b2w+CisgICAgICAgPGxpPkEgc2VyaWVzIG9mIGFjdGlvbnMgbWF5IG9jY3VyICgmcXVvdDtQcm92aXNpb25pbmcgUHJvY2VzcyZxdW90OykgaW4gd2hpY2ggYSB1c2VyIG1heSBleGVjdXRlIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neQorICAgICAgIG9uIGEgbWFjaGluZSAoJnF1b3Q7VGFyZ2V0IE1hY2hpbmUmcXVvdDspIHdpdGggdGhlIGludGVudCBvZiBpbnN0YWxsaW5nLCBleHRlbmRpbmcgb3IgdXBkYXRpbmcgdGhlIGZ1bmN0aW9uYWxpdHkgb2YgYW4gRWNsaXBzZS1iYXNlZAorICAgICAgIHByb2R1Y3QuPC9saT4KKyAgICAgICA8bGk+RHVyaW5nIHRoZSBQcm92aXNpb25pbmcgUHJvY2VzcywgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IG1heSBjYXVzZSB0aGlyZCBwYXJ0eSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBvciBhIHBvcnRpb24gdGhlcmVvZiB0byBiZQorICAgICAgIGFjY2Vzc2VkIGFuZCBjb3BpZWQgdG8gdGhlIFRhcmdldCBNYWNoaW5lLjwvbGk+CisgICAgICAgPGxpPlB1cnN1YW50IHRvIHRoZSBTcGVjaWZpY2F0aW9uLCB5b3Ugd2lsbCBwcm92aWRlIHRvIHRoZSB1c2VyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyB0aGF0IGdvdmVybiB0aGUgdXNlIG9mIHRoZSBJbnN0YWxsYWJsZQorICAgICAgIFNvZnR3YXJlICgmcXVvdDtJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQmcXVvdDspIGFuZCBzdWNoIEluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCBzaGFsbCBiZSBhY2Nlc3NlZCBmcm9tIHRoZSBUYXJnZXQKKyAgICAgICBNYWNoaW5lIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgU3BlY2lmaWNhdGlvbi4gU3VjaCBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQgbXVzdCBpbmZvcm0gdGhlIHVzZXIgb2YgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIHRoYXQgZ292ZXJuCisgICAgICAgdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlIGFuZCBtdXN0IHNvbGljaXQgYWNjZXB0YW5jZSBieSB0aGUgZW5kIHVzZXIgaW4gdGhlIG1hbm5lciBwcmVzY3JpYmVkIGluIHN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50LiBVcG9uIHN1Y2gKKyAgICAgICBpbmRpY2F0aW9uIG9mIGFncmVlbWVudCBieSB0aGUgdXNlciwgdGhlIHByb3Zpc2lvbmluZyBUZWNobm9sb2d5IHdpbGwgY29tcGxldGUgaW5zdGFsbGF0aW9uIG9mIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZS48L2xpPgorPC9vbD4KKworPGgzPkNyeXB0b2dyYXBoeTwvaDM+CisKKzxwPkNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZSBjdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsIGFuZC9vciByZS1leHBvcnQgdG8KKyAgIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFIHVzaW5nIGFueSBlbmNyeXB0aW9uIHNvZnR3YXJlLCBwbGVhc2UgY2hlY2sgdGhlIGNvdW50cnkncyBsYXdzLCByZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgY29uY2VybmluZyB0aGUgaW1wb3J0LAorICAgcG9zc2Vzc2lvbiwgb3IgdXNlLCBhbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIHRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC48L3A+CisKKzxwPjxzbWFsbD5KYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIE9yYWNsZSBDb3Jwb3JhdGlvbiBpbiB0aGUgVW5pdGVkIFN0YXRlcywgb3RoZXIgY291bnRyaWVzLCBvciBib3RoLjwvc21hbGw+PC9wPgorPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5wcm9kdWN0L3BsdWdpbi54bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdC9wbHVnaW4ueG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjU1MzU2OTAKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdC9wbHVnaW4ueG1sCkBAIC0wLDAgKzEsNSBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KKzw/ZWNsaXBzZSB2ZXJzaW9uPSIzLjQiPz4KKzxwbHVnaW4+CisKKzwvcGx1Z2luPgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yLnByb2R1Y3QvcG9tLnhtbCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5wcm9kdWN0L3BvbS54bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2ZjNjUwYgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5wcm9kdWN0L3BvbS54bWwKQEAgLTAsMCArMSw0NyBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KKzwhLS0jPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gLS0+Cis8IS0tIyBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMdW5pZmVyYSBHbWJIIChHcm9zcyBFbnplcnNkb3JmKSwgTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkgLS0+Cis8IS0tIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIC0tPgorPCEtLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIC0tPgorPCEtLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgLS0+Cis8IS0tIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAtLT4KKzwhLS0jIC0tPgorPCEtLSMgQ29udHJpYnV0b3JzOiAtLT4KKzwhLS0jICAgICBLbGVtZW5zIEVkbGVyIChMdW5pZmVyYSBHbWJIKSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiAtLT4KKzwhLS0jPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gLS0+CisKKzxwcm9qZWN0IHhtbG5zPSJodHRwOi8vbWF2ZW4uYXBhY2hlLm9yZy9QT00vNC4wLjAiIHhtbG5zOnhzaT0iaHR0cDovL3d3dy53My5vcmcvMjAwMS9YTUxTY2hlbWEtaW5zdGFuY2UiIHhzaTpzY2hlbWFMb2NhdGlvbj0iaHR0cDovL21hdmVuLmFwYWNoZS5vcmcvUE9NLzQuMC4wIGh0dHA6Ly9tYXZlbi5hcGFjaGUub3JnL3hzZC9tYXZlbi00LjAuMC54c2QiPgorICAgIDxtb2RlbFZlcnNpb24+NC4wLjA8L21vZGVsVmVyc2lvbj4KKyAgICA8cGFyZW50PgorICAgICAgICA8Z3JvdXBJZD5vcmcuZWNsaXBzZS5vc2JwLmlkZTwvZ3JvdXBJZD4KKyAgICAgICAgPGFydGlmYWN0SWQ+b3JnLmVjbGlwc2Uub3NicC5pZGU8L2FydGlmYWN0SWQ+CisgICAgICAgIDx2ZXJzaW9uPjAuOS4wLVNOQVBTSE9UPC92ZXJzaW9uPgorICAgIDwvcGFyZW50PgorICAgIDxhcnRpZmFjdElkPm9yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5wcm9kdWN0PC9hcnRpZmFjdElkPgorICAgIDxwYWNrYWdpbmc+ZWNsaXBzZS1yZXBvc2l0b3J5PC9wYWNrYWdpbmc+CisKKyAgICA8YnVpbGQ+CisgICAgICAgIDxwbHVnaW5zPgorICAgICAgICAgICAgPHBsdWdpbj4KKyAgICAgICAgICAgICAgICA8Z3JvdXBJZD5vcmcuZWNsaXBzZS50eWNobzwvZ3JvdXBJZD4KKyAgICAgICAgICAgICAgICA8YXJ0aWZhY3RJZD50eWNoby1wMi1kaXJlY3Rvci1wbHVnaW48L2FydGlmYWN0SWQ+CisgICAgICAgICAgICAgICAgPHZlcnNpb24+JHt0eWNoby12ZXJzaW9ufTwvdmVyc2lvbj4KKyAgICAgICAgICAgICAgICA8ZXhlY3V0aW9ucz4KKyAgICAgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbj4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxpZD5tYXRlcmlhbGl6ZS1wcm9kdWN0czwvaWQ+CisgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbHM+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGdvYWw+bWF0ZXJpYWxpemUtcHJvZHVjdHM8L2dvYWw+CisgICAgICAgICAgICAgICAgICAgICAgICA8L2dvYWxzPgorICAgICAgICAgICAgICAgICAgICA8L2V4ZWN1dGlvbj4KKyAgICAgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbj4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxpZD5hcmNoaXZlLXByb2R1Y3RzPC9pZD4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxnb2Fscz4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbD5hcmNoaXZlLXByb2R1Y3RzPC9nb2FsPgorICAgICAgICAgICAgICAgICAgICAgICAgPC9nb2Fscz4KKyAgICAgICAgICAgICAgICAgICAgPC9leGVjdXRpb24+CisgICAgICAgICAgICAgICAgPC9leGVjdXRpb25zPgorICAgICAgICAgICAgPC9wbHVnaW4+CisgICAgICAgIDwvcGx1Z2lucz4KKyAgICA8L2J1aWxkPgorCis8L3Byb2plY3Q+CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdC9wcm9kdWN0LnByb2R1Y3QgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdC9wcm9kdWN0LnByb2R1Y3QKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uM2E4YjdlZAotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5wcm9kdWN0L3Byb2R1Y3QucHJvZHVjdApAQCAtMCwwICsxLDc4IEBACis8P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgorPD9wZGUgdmVyc2lvbj0iMy41Ij8+CisKKzxwcm9kdWN0IHVpZD0ib3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yLnByb2R1Y3QiIGFwcGxpY2F0aW9uPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IuYXBwIiB2ZXJzaW9uPSIwLjcuNS5xdWFsaWZpZXIiIHVzZUZlYXR1cmVzPSJmYWxzZSIgaW5jbHVkZUxhdW5jaGVycz0idHJ1ZSI+CisKKyAgIDxjb25maWdJbmkgdXNlPSJkZWZhdWx0Ij4KKyAgIDwvY29uZmlnSW5pPgorCisgICA8bGF1bmNoZXJBcmdzPgorICAgICAgPHByb2dyYW1BcmdzPi1jb25zb2xlTG9nIC1jb25zb2xlCisgICAgICA8L3Byb2dyYW1BcmdzPgorICAgICAgPHZtQXJncz4tRG9zZ2kucmVxdWlyZWRKYXZhVmVyc2lvbj0xLjYgLVhYOk1heFBlcm1TaXplPTI1Nm0gLVhtczQwbSAtWG14NTEybQorICAgICAgPC92bUFyZ3M+CisgICAgICA8dm1BcmdzTWFjPi1Yc3RhcnRPbkZpcnN0VGhyZWFkIC1Eb3JnLmVjbGlwc2Uuc3d0LmludGVybmFsLmNhcmJvbi5zbWFsbEZvbnRzCisgICAgICA8L3ZtQXJnc01hYz4KKyAgIDwvbGF1bmNoZXJBcmdzPgorCisgICA8dm0+CisgICAgICA8bGludXggaW5jbHVkZT0iZmFsc2UiPm9yZy5lY2xpcHNlLmpkdC5sYXVuY2hpbmcuSlJFX0NPTlRBSU5FUi9vcmcuZWNsaXBzZS5qZHQuaW50ZXJuYWwuZGVidWcudWkubGF1bmNoZXIuU3RhbmRhcmRWTVR5cGUvSmF2YVNFLTEuNzwvbGludXg+CisgICA8L3ZtPgorCisgICA8cGx1Z2lucz4KKyAgICAgIDxwbHVnaW4gaWQ9ImphdmF4LnhtbCIvPgorICAgICAgPHBsdWdpbiBpZD0ib3JnLmFwYWNoZS5mZWxpeC5nb2dvLmNvbW1hbmQiIHZlcnNpb249IjAuMTAuMC52MjAxMjA5MzAxMjE1Ii8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuYXBhY2hlLmZlbGl4LmdvZ28ucnVudGltZSIgdmVyc2lvbj0iMC4xMC4wLnYyMDEyMDkzMDEwMzYiLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5hcGFjaGUuZmVsaXguZ29nby5zaGVsbCIgdmVyc2lvbj0iMC4xMC4wLnYyMDEyMTIxMDE2MDUiLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLmNvcmUuY29udGVudHR5cGUiLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLmNvcmUuam9icyIvPgorICAgICAgPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2UuY29yZS5uZXQiLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLmNvcmUubmV0LmxpbnV4Lng4Nl82NCIgZnJhZ21lbnQ9InRydWUiLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLmNvcmUucnVudGltZSIvPgorICAgICAgPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2UuZWNmIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lY2YuZmlsZXRyYW5zZmVyIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lY2YuaWRlbnRpdHkiLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLmVjZi5wcm92aWRlci5maWxldHJhbnNmZXIiLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLmVxdWlub3guYXBwIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LmNvbW1vbiIvPgorICAgICAgPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2UuZXF1aW5veC5jb25zb2xlIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LmRzIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LmZyYW1ld29ya2FkbWluIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LmZyYW1ld29ya2FkbWluLmVxdWlub3giLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLmVxdWlub3gucDIuYXJ0aWZhY3QucmVwb3NpdG9yeSIvPgorICAgICAgPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2UuZXF1aW5veC5wMi5jb3JlIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LnAyLmRpcmVjdG9yIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LnAyLmRpcmVjdG9yLmFwcCIvPgorICAgICAgPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2UuZXF1aW5veC5wMi5lbmdpbmUiLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLmVxdWlub3gucDIuamFycHJvY2Vzc29yIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LnAyLm1ldGFkYXRhIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LnAyLm1ldGFkYXRhLnJlcG9zaXRvcnkiLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLmVxdWlub3gucDIucHVibGlzaGVyIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LnAyLnB1Ymxpc2hlci5lY2xpcHNlIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LnAyLnJlcG9zaXRvcnkiLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLmVxdWlub3gucDIucmVwb3NpdG9yeS50b29scyIvPgorICAgICAgPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2UuZXF1aW5veC5wMi50cmFuc3BvcnQuZWNmIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LnByZWZlcmVuY2VzIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LnJlZ2lzdHJ5Ii8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LnNlY3VyaXR5Ii8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LnNpbXBsZWNvbmZpZ3VyYXRvciIvPgorICAgICAgPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2UuZXF1aW5veC5zaW1wbGVjb25maWd1cmF0b3IubWFuaXB1bGF0b3IiLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLmVxdWlub3gudXRpbCIvPgorICAgICAgPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2Uub3NnaSIvPgorICAgICAgPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2Uub3NnaS5zZXJ2aWNlcyIvPgorICAgICAgPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2Uub3NnaS51dGlsIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IiLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5zYXQ0ai5jb3JlIi8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuc2F0NGoucGIiLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5zbGY0ai5hcGkiLz4KKyAgIDwvcGx1Z2lucz4KKworICAgPGNvbmZpZ3VyYXRpb25zPgorICAgICAgPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2UuY29yZS5ydW50aW1lIiBhdXRvU3RhcnQ9InRydWUiIHN0YXJ0TGV2ZWw9IjAiIC8+CisgICAgICA8cGx1Z2luIGlkPSJvcmcuZWNsaXBzZS5lcXVpbm94LmNvbW1vbiIgYXV0b1N0YXJ0PSJ0cnVlIiBzdGFydExldmVsPSIyIiAvPgorICAgICAgPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2UuZXF1aW5veC5kcyIgYXV0b1N0YXJ0PSJ0cnVlIiBzdGFydExldmVsPSIxIiAvPgorICAgICAgPHBsdWdpbiBpZD0ib3JnLmVjbGlwc2UuZXF1aW5veC5zaW1wbGVjb25maWd1cmF0b3IiIGF1dG9TdGFydD0idHJ1ZSIgc3RhcnRMZXZlbD0iMSIgLz4KKyAgICAgIDxwbHVnaW4gaWQ9Im9yZy5lY2xpcHNlLm9zZ2kiIGF1dG9TdGFydD0idHJ1ZSIgc3RhcnRMZXZlbD0iLTEiIC8+CisgICA8L2NvbmZpZ3VyYXRpb25zPgorCis8L3Byb2R1Y3Q+CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdC9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvdG9vbHMvcDIvbWlycm9yL0NvbnNvbGVDb21tYW5kcy5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yLnByb2R1Y3Qvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL3Rvb2xzL3AyL21pcnJvci9Db25zb2xlQ29tbWFuZHMuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xYzAyMmJjCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yLnByb2R1Y3Qvc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL3Rvb2xzL3AyL21pcnJvci9Db25zb2xlQ29tbWFuZHMuamF2YQpAQCAtMCwwICsxLDI0OCBAQAorLyoqCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTUgLSBMdW5pZmVyYSBHbWJIIChHcm9zcyBFbnplcnNkb3JmLCBBdXN0cmlhKSwgTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisgKgorICogQ29udHJpYnV0b3JzOgorICogICAgICAgICBGbG9yaWFuIFBpcmNobmVyIC0gSW5pdGlhbCBpbXBsZW1lbnRhdGlvbgorICovCisKK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yOworCitpbXBvcnQgamF2YS5pby5CdWZmZXJlZFJlYWRlcjsKK2ltcG9ydCBqYXZhLmlvLkZpbGU7CitpbXBvcnQgamF2YS5pby5GaWxlSW5wdXRTdHJlYW07CitpbXBvcnQgamF2YS5pby5GaWxlTm90Rm91bmRFeGNlcHRpb247CitpbXBvcnQgamF2YS5pby5GaWxlV3JpdGVyOworaW1wb3J0IGphdmEuaW8uSU9FeGNlcHRpb247CitpbXBvcnQgamF2YS5pby5JbnB1dFN0cmVhbTsKK2ltcG9ydCBqYXZhLmlvLklucHV0U3RyZWFtUmVhZGVyOworaW1wb3J0IGphdmEudXRpbC5IYXNoTWFwOworaW1wb3J0IGphdmEudXRpbC5IYXNoU2V0OworaW1wb3J0IGphdmEudXRpbC5NYXA7CitpbXBvcnQgamF2YS51dGlsLlNldDsKKworaW1wb3J0IG9yZy5lY2xpcHNlLmVxdWlub3guYXBwLklBcHBsaWNhdGlvbkNvbnRleHQ7CitpbXBvcnQgb3JnLmVjbGlwc2Uub3NnaS5mcmFtZXdvcmsuY29uc29sZS5Db21tYW5kSW50ZXJwcmV0ZXI7CitpbXBvcnQgb3JnLm9zZ2kuc2VydmljZS5hcHBsaWNhdGlvbi5BcHBsaWNhdGlvbkRlc2NyaXB0b3I7CitpbXBvcnQgb3JnLm9zZ2kuc2VydmljZS5hcHBsaWNhdGlvbi5BcHBsaWNhdGlvbkhhbmRsZTsKK2ltcG9ydCBvcmcub3NnaS5zZXJ2aWNlLmNvbXBvbmVudC5Db21wb25lbnRDb250ZXh0OworaW1wb3J0IG9yZy5vc2dpLnNlcnZpY2UuY29tcG9uZW50LmFubm90YXRpb25zLkFjdGl2YXRlOworaW1wb3J0IG9yZy5vc2dpLnNlcnZpY2UuY29tcG9uZW50LmFubm90YXRpb25zLkNvbXBvbmVudDsKK2ltcG9ydCBvcmcub3NnaS5zZXJ2aWNlLmNvbXBvbmVudC5hbm5vdGF0aW9ucy5EZWFjdGl2YXRlOworaW1wb3J0IG9yZy5vc2dpLnNlcnZpY2UuY29tcG9uZW50LmFubm90YXRpb25zLlJlZmVyZW5jZTsKK2ltcG9ydCBvcmcub3NnaS5zZXJ2aWNlLmNvbXBvbmVudC5hbm5vdGF0aW9ucy5SZWZlcmVuY2VDYXJkaW5hbGl0eTsKKworQENvbXBvbmVudAorcHVibGljIGNsYXNzIENvbnNvbGVDb21tYW5kcyBpbXBsZW1lbnRzCisJCW9yZy5lY2xpcHNlLm9zZ2kuZnJhbWV3b3JrLmNvbnNvbGUuQ29tbWFuZFByb3ZpZGVyIHsKKworCXByaXZhdGUgQ29tcG9uZW50Q29udGV4dCBjb250ZXh0OworCXByaXZhdGUgU2V0PE1pcnJvcj4gbWlycm9ycyA9IG5ldyBIYXNoU2V0PENvbnNvbGVDb21tYW5kcy5NaXJyb3I+KCk7CisJcHJpdmF0ZSBBcHBsaWNhdGlvbkRlc2NyaXB0b3IgYXJ0aWZhY3RzRGVzYzsKKwlwcml2YXRlIEFwcGxpY2F0aW9uRGVzY3JpcHRvciBtZXRhZGF0YURlc2M7CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgU3RyaW5nIGdldEhlbHAoKSB7CisJCXJldHVybiAiT1NCUCBQMiBtaXJyb3IgY29tbWFuZHMiOworCX0KKworCUBBY3RpdmF0ZQorCXByb3RlY3RlZCB2b2lkIGFjdGl2YXRlKENvbXBvbmVudENvbnRleHQgY29udGV4dCkgeworCQl0aGlzLmNvbnRleHQgPSBjb250ZXh0OworCisJCWxvYWRNaXJyb3JzKGNvbnRleHQpOworCX0KKworCUBSZWZlcmVuY2UoY2FyZGluYWxpdHkgPSBSZWZlcmVuY2VDYXJkaW5hbGl0eS5NQU5EQVRPUlksIHRhcmdldCA9ICIoc2VydmljZS5waWQ9b3JnLmVjbGlwc2UuZXF1aW5veC5wMi5tZXRhZGF0YS5yZXBvc2l0b3J5Lm1pcnJvckFwcGxpY2F0aW9uKSIpCisJcHJvdGVjdGVkIHZvaWQgYmluZE1ldGFkYXRhKEFwcGxpY2F0aW9uRGVzY3JpcHRvciBtZXRhZGF0YURlc2MpIHsKKwkJdGhpcy5tZXRhZGF0YURlc2MgPSBtZXRhZGF0YURlc2M7CisJfQorCisJQFJlZmVyZW5jZShjYXJkaW5hbGl0eSA9IFJlZmVyZW5jZUNhcmRpbmFsaXR5Lk1BTkRBVE9SWSwgdGFyZ2V0ID0gIihzZXJ2aWNlLnBpZD1vcmcuZWNsaXBzZS5lcXVpbm94LnAyLmFydGlmYWN0LnJlcG9zaXRvcnkubWlycm9yQXBwbGljYXRpb24pIikKKwlwcm90ZWN0ZWQgdm9pZCBiaW5kQXJ0aWZhY3RzKEFwcGxpY2F0aW9uRGVzY3JpcHRvciBhcnRpZmFjdHNEZXNjKSB7CisJCXRoaXMuYXJ0aWZhY3RzRGVzYyA9IGFydGlmYWN0c0Rlc2M7CisJfQorCisJLyoqCisJICogTG9hZHMgYWxsIG1pcnJvcnMuCisJICogCisJICogQHBhcmFtIGNvbnRleHQKKwkgKi8KKwlwcml2YXRlIHZvaWQgbG9hZE1pcnJvcnMoQ29tcG9uZW50Q29udGV4dCBjb250ZXh0KSB7CisJCXRyeSB7CisJCQlGaWxlIHNldHRpbmdzID0gY29udGV4dC5nZXRCdW5kbGVDb250ZXh0KCkuZ2V0RGF0YUZpbGUoCisJCQkJCSJsdW5wMm1pcnJvcnMiKTsKKwkJCWlmICghc2V0dGluZ3MuZXhpc3RzKCkpIHsKKwkJCQlzZXR0aW5ncy5jcmVhdGVOZXdGaWxlKCk7CisJCQl9CisKKwkJCUlucHV0U3RyZWFtIGlucHV0U3RyZWFtID0gbmV3IEZpbGVJbnB1dFN0cmVhbShzZXR0aW5ncyk7CisJCQlCdWZmZXJlZFJlYWRlciByZWFkZXIgPSBuZXcgQnVmZmVyZWRSZWFkZXIobmV3IElucHV0U3RyZWFtUmVhZGVyKAorCQkJCQlpbnB1dFN0cmVhbSkpOworCQkJU3RyaW5nIGxpbmUgPSBudWxsOworCQkJLy8gUmVhZCBmaWxlIGxpbmUgYnkgbGluZQorCQkJd2hpbGUgKChsaW5lID0gcmVhZGVyLnJlYWRMaW5lKCkpICE9IG51bGwpIHsKKwkJCQltaXJyb3JzLmFkZChNaXJyb3IucGFyc2UobGluZSkpOworCQkJfQorCQkJcmVhZGVyLmNsb3NlKCk7CisJCX0gY2F0Y2ggKEZpbGVOb3RGb3VuZEV4Y2VwdGlvbiBlKSB7CisJCQllLnByaW50U3RhY2tUcmFjZSgpOworCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBlKSB7CisJCQllLnByaW50U3RhY2tUcmFjZSgpOworCQl9CisJfQorCisJQERlYWN0aXZhdGUKKwlwcm90ZWN0ZWQgdm9pZCBkZWFjdGl2YXRlKENvbXBvbmVudENvbnRleHQgY29udGV4dCkgeworCQl0aGlzLmNvbnRleHQgPSBudWxsOworCX0KKworCXB1YmxpYyB2b2lkIF9sdW5wMm1pcnJvcihmaW5hbCBDb21tYW5kSW50ZXJwcmV0ZXIgY2kpIHRocm93cyBFeGNlcHRpb24geworCQlTdHJpbmcgYXJndW1lbnQgPSBjaS5uZXh0QXJndW1lbnQoKTsKKwkJaWYgKGFyZ3VtZW50ID09IG51bGwpIHsKKwkJCWNpLnByaW50bG4oZ2V0SGVscCgpKTsKKwkJfSBlbHNlIGlmIChhcmd1bWVudC5lcXVhbHMoImxzIikpIHsKKwkJCXByaW50TWlycm9ycyhjaSk7CisJCX0gZWxzZSBpZiAoYXJndW1lbnQuZXF1YWxzKCJhZGQiKSkgeworCQkJYWRkTWlycm9yKGNpKTsKKwkJfSBlbHNlIGlmIChhcmd1bWVudC5lcXVhbHMoInVwZGF0ZSIpKSB7CisJCQl1cGRhdGUoY2kpOworCQl9IGVsc2UgeworCQkJY2kucHJpbnRsbigiRVJST1IgLSBub3QgYSB2YWxpZCBjb21tYW5kISIpOworCQkJY2kucHJpbnRsbihnZXRIZWxwKCkpOworCQl9CisJfQorCisJLy8gbHVucDJtaXJyb3IgYWRkIG9zYnBQMiBodHRwOi8vLi4uLmNvbQorCXByaXZhdGUgdm9pZCBhZGRNaXJyb3IoQ29tbWFuZEludGVycHJldGVyIGNpKSB7CisKKwkJU3RyaW5nIGlkID0gY2kubmV4dEFyZ3VtZW50KCk7CisJCWlmIChpZCA9PSBudWxsKSB7CisJCQljaS5wcmludGxuKCJcdEVSUk9SOiBObyBpZCBzcGVjaWZpZWQhIik7CisJCQlyZXR1cm47CisJCX0KKworCQlTdHJpbmcgdXJsID0gY2kubmV4dEFyZ3VtZW50KCk7CisJCWlmICh1cmwgPT0gbnVsbCkgeworCQkJY2kucHJpbnRsbigiXHRFUlJPUjogTm8gVVJMIHNwZWNpZmllZCEiKTsKKwkJCXJldHVybjsKKwkJfQorCisJCVN0cmluZyBkZXN0aW5hdGlvbiA9IGNpLm5leHRBcmd1bWVudCgpOworCQlpZiAoZGVzdGluYXRpb24gPT0gbnVsbCkgeworCQkJY2kucHJpbnRsbigiXHRFUlJPUjogTm8gZGVzdGluYXRpb24gc3BlY2lmaWVkISIpOworCQkJcmV0dXJuOworCQl9CisKKwkJTWlycm9yIG5ld01pcnJvciA9IG5ldyBNaXJyb3IoaWQsIHVybCwgZGVzdGluYXRpb24pOworCQltaXJyb3JzLmFkZChuZXdNaXJyb3IpOworCisJCXNhdmVGaWxlKCk7CisKKwl9CisKKwlwcml2YXRlIHZvaWQgc2F2ZUZpbGUoKSB7CisJCVN0cmluZ0J1aWxkZXIgYiA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7CisJCWZvciAoTWlycm9yIG1pcnJvciA6IG1pcnJvcnMpIHsKKwkJCWIuYXBwZW5kKG1pcnJvci50b1N0cmluZygpKTsKKwkJCWIuYXBwZW5kKCJcbiIpOworCQl9CisKKwkJdHJ5IHsKKwkJCUZpbGUgc2V0dGluZ3MgPSBjb250ZXh0LmdldEJ1bmRsZUNvbnRleHQoKS5nZXREYXRhRmlsZSgKKwkJCQkJImx1bnAybWlycm9ycyIpOworCQkJRmlsZVdyaXRlciB3cml0ZXIgPSBuZXcgRmlsZVdyaXRlcihzZXR0aW5ncyk7CisJCQl3cml0ZXIuYXBwZW5kKGIudG9TdHJpbmcoKSk7CisJCQl3cml0ZXIuZmx1c2goKTsKKwkJCXdyaXRlci5jbG9zZSgpOworCQl9IGNhdGNoIChGaWxlTm90Rm91bmRFeGNlcHRpb24gZSkgeworCQkJZS5wcmludFN0YWNrVHJhY2UoKTsKKwkJfSBjYXRjaCAoSU9FeGNlcHRpb24gZSkgeworCQkJZS5wcmludFN0YWNrVHJhY2UoKTsKKwkJfQorCX0KKworCXByaXZhdGUgdm9pZCB1cGRhdGUoQ29tbWFuZEludGVycHJldGVyIGNpKSB7CisJCVN0cmluZyBpZCA9IGNpLm5leHRBcmd1bWVudCgpOworCQlpZiAoaWQgPT0gbnVsbCkgeworCQkJY2kucHJpbnRsbigiXHRFUlJPUjogTm8gaWQgc3BlY2lmaWVkISIpOworCQkJcmV0dXJuOworCQl9CisKKwkJZm9yIChNaXJyb3IgbWlycm9yIDogbWlycm9ycykgeworCQkJaWYgKG1pcnJvci5pZC5lcXVhbHMoaWQpKSB7CisJCQkJdHJ5IHsKKwkJCQkJcnVuKGNpLCBtaXJyb3IpOworCQkJCX0gY2F0Y2ggKEV4Y2VwdGlvbiBlKSB7CisJCQkJCWUucHJpbnRTdGFja1RyYWNlKCk7CisJCQkJfQorCQkJCWJyZWFrOworCQkJfQorCQl9CisKKwl9CisKKwlwcml2YXRlIHZvaWQgcHJpbnRNaXJyb3JzKENvbW1hbmRJbnRlcnByZXRlciBjaSkgeworCisJCVN0cmluZ0J1aWxkZXIgYiA9IG5ldyBTdHJpbmdCdWlsZGVyKCk7CisJCWZvciAoTWlycm9yIG1pcnJvciA6IG1pcnJvcnMpIHsKKwkJCWIuYXBwZW5kKCJcdElkOiAiKTsKKwkJCWIuYXBwZW5kKG1pcnJvci5pZCk7CisJCQliLmFwcGVuZCgiXHRVUkw6ICIpOworCQkJYi5hcHBlbmQobWlycm9yLnVybCk7CisJCQliLmFwcGVuZCgiXHREZXN0aW5hdGlvbjogIik7CisJCQliLmFwcGVuZChtaXJyb3IuZGVzdGluYXRpb24pOworCQkJYi5hcHBlbmQoIlxuIik7CisJCX0KKworCQljaS5wcmludGxuKCJcdC0tLS0gQXZhaWxhYmxlIG1pcnJvcnMgLS0tLVxuIik7CisJCWNpLnByaW50bG4oYi50b1N0cmluZygpKTsKKwl9CisKKwlwdWJsaWMgdm9pZCBydW4oQ29tbWFuZEludGVycHJldGVyIGNpLCBNaXJyb3IgbWlycm9yKSB0aHJvd3MgRXhjZXB0aW9uIHsKKwkJdHJ5IHsKKwkJCU1hcDxTdHJpbmcsIE9iamVjdD4gbGF1bmNoQXJncyA9IG5ldyBIYXNoTWFwPD4oMSk7CisJCQlNYXA8U3RyaW5nLCBPYmplY3Q+IGFwcEFyZ3MgPSBuZXcgSGFzaE1hcDw+KCk7CisJCQlsYXVuY2hBcmdzLnB1dChJQXBwbGljYXRpb25Db250ZXh0LkFQUExJQ0FUSU9OX0FSR1MsIGFwcEFyZ3MpOworCisJCQlhcHBBcmdzLnB1dCgiLXNvdXJjZSIsIG1pcnJvci51cmwpOworCQkJYXBwQXJncy5wdXQoIi1kZXN0aW5hdGlvbiIsIG1pcnJvci5kZXN0aW5hdGlvbik7CisKKwkJCUFwcGxpY2F0aW9uSGFuZGxlIG1ldGFkYXRhSGFuZGxlID0gbWV0YWRhdGFEZXNjLmxhdW5jaChsYXVuY2hBcmdzKTsKKwkJCWNpLnByaW50bG4oIkxhdW5jaGVkIGFwcGxpY2F0aW9uIGluc3RhbmNlOiAiICsgbWV0YWRhdGFIYW5kbGUuZ2V0SW5zdGFuY2VJZCgpKTsgLy8kTk9OLU5MUy0xJAorCQkJQXBwbGljYXRpb25IYW5kbGUgYXJ0aWZhY3RzSGFuZGxlID0gYXJ0aWZhY3RzRGVzYworCQkJCQkubGF1bmNoKGxhdW5jaEFyZ3MpOworCQkJY2kucHJpbnRsbigiTGF1bmNoZWQgYXBwbGljYXRpb24gaW5zdGFuY2U6ICIgKyBhcnRpZmFjdHNIYW5kbGUuZ2V0SW5zdGFuY2VJZCgpKTsgLy8kTk9OLU5MUy0xJAorCisJCX0gZmluYWxseSB7CisJCX0KKwkJcmV0dXJuOworCX0KKworCXByaXZhdGUgc3RhdGljIGNsYXNzIE1pcnJvciB7CisJCXB1YmxpYyBmaW5hbCBTdHJpbmcgaWQ7CisJCXB1YmxpYyBmaW5hbCBTdHJpbmcgdXJsOworCQlwdWJsaWMgZmluYWwgU3RyaW5nIGRlc3RpbmF0aW9uOworCisJCXB1YmxpYyBNaXJyb3IoU3RyaW5nIGlkLCBTdHJpbmcgdXJsLCBTdHJpbmcgZGVzdGluYXRpb24pIHsKKwkJCXN1cGVyKCk7CisJCQl0aGlzLmlkID0gaWQ7CisJCQl0aGlzLnVybCA9IHVybDsKKwkJCXRoaXMuZGVzdGluYXRpb24gPSBkZXN0aW5hdGlvbjsKKwkJfQorCisJCXB1YmxpYyBzdGF0aWMgTWlycm9yIHBhcnNlKFN0cmluZyBsaW5lKSB7CisJCQlTdHJpbmdbXSB0b2tlbnMgPSBsaW5lLnNwbGl0KCI7Iik7CisJCQlyZXR1cm4gbmV3IE1pcnJvcih0b2tlbnNbMF0sIHRva2Vuc1sxXSwgdG9rZW5zWzJdKTsKKwkJfQorCisJCXB1YmxpYyBTdHJpbmcgdG9TdHJpbmcoKSB7CisJCQlyZXR1cm4gU3RyaW5nLmZvcm1hdCgiJXM7JXM7JXMiLCBpZCwgdXJsLCBkZXN0aW5hdGlvbik7CisJCX0KKworCX0KKworfQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yLy5wcm9qZWN0IGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yLy5wcm9qZWN0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmNkNmEyNGMKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IvLnByb2plY3QKQEAgLTAsMCArMSw1MCBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KKzxwcm9qZWN0RGVzY3JpcHRpb24+CisJPG5hbWU+b3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yPC9uYW1lPgorCTxjb21tZW50PjwvY29tbWVudD4KKwk8cHJvamVjdHM+CisJPC9wcm9qZWN0cz4KKwk8YnVpbGRTcGVjPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLmVjbGlwc2UueHRleHQudWkuc2hhcmVkLnh0ZXh0QnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5qZHQuY29yZS5qYXZhYnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5wZGUuTWFuaWZlc3RCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5TY2hlbWFCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwkJPGJ1aWxkQ29tbWFuZD4KKwkJCTxuYW1lPm9yZy5lY2xpcHNlLnBkZS5kcy5jb3JlLmJ1aWxkZXI8L25hbWU+CisJCQk8YXJndW1lbnRzPgorCQkJPC9hcmd1bWVudHM+CisJCTwvYnVpbGRDb21tYW5kPgorCQk8YnVpbGRDb21tYW5kPgorCQkJPG5hbWU+b3JnLnNvbmFybGludC5lY2xpcHNlLmNvcmUuc29uYXJsaW50QnVpbGRlcjwvbmFtZT4KKwkJCTxhcmd1bWVudHM+CisJCQk8L2FyZ3VtZW50cz4KKwkJPC9idWlsZENvbW1hbmQ+CisJCTxidWlsZENvbW1hbmQ+CisJCQk8bmFtZT5vcmcuZWNsaXBzZS5tMmUuY29yZS5tYXZlbjJCdWlsZGVyPC9uYW1lPgorCQkJPGFyZ3VtZW50cz4KKwkJCTwvYXJndW1lbnRzPgorCQk8L2J1aWxkQ29tbWFuZD4KKwk8L2J1aWxkU3BlYz4KKwk8bmF0dXJlcz4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS54dGV4dC51aS5zaGFyZWQueHRleHROYXR1cmU8L25hdHVyZT4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS5tMmUuY29yZS5tYXZlbjJOYXR1cmU8L25hdHVyZT4KKwkJPG5hdHVyZT5vcmcuZWNsaXBzZS5wZGUuUGx1Z2luTmF0dXJlPC9uYXR1cmU+CisJCTxuYXR1cmU+b3JnLmVjbGlwc2UuamR0LmNvcmUuamF2YW5hdHVyZTwvbmF0dXJlPgorCTwvbmF0dXJlcz4KKzwvcHJvamVjdERlc2NyaXB0aW9uPgpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL0xJQ0VOU0UudHh0IGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL0xJQ0VOU0UudHh0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmZmNDJhZDQKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IvTElDRU5TRS50eHQKQEAgLTAsMCArMSwxNjEgQEAKK0VjbGlwc2UgUHVibGljIExpY2Vuc2UgLXYgMS4wCisKK1RIRSBBQ0NPTVBBTllJTkcgUFJPR1JBTSBJUyBQUk9WSURFRCBVTkRFUiBUSEUgVEVSTVMgT0YgVEhJUyBFQ0xJUFNFIFBVQkxJQyBMSUNFTlNFICgiQUdSRUVNRU5UIikuIEFOWSBVU0UsIFJFUFJPRFVDVElPTgorT1IgRElTVFJJQlVUSU9OIE9GIFRIRSBQUk9HUkFNIENPTlNUSVRVVEVTIFJFQ0lQSUVOVCdTIEFDQ0VQVEFOQ0UgT0YgVEhJUyBBR1JFRU1FTlQuCisKKzEuIERFRklOSVRJT05TCisKKyJDb250cmlidXRpb24iIG1lYW5zOgorCithKSBpbiB0aGUgY2FzZSBvZiB0aGUgaW5pdGlhbCBDb250cmlidXRvciwgdGhlIGluaXRpYWwgY29kZSBhbmQgZG9jdW1lbnRhdGlvbiBkaXN0cmlidXRlZCB1bmRlciB0aGlzIEFncmVlbWVudCwgYW5kCisKK2IpIGluIHRoZSBjYXNlIG9mIGVhY2ggc3Vic2VxdWVudCBDb250cmlidXRvcjoKKworaSkgY2hhbmdlcyB0byB0aGUgUHJvZ3JhbSwgYW5kCisKK2lpKSBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW07CisKK3doZXJlIHN1Y2ggY2hhbmdlcyBhbmQvb3IgYWRkaXRpb25zIHRvIHRoZSBQcm9ncmFtIG9yaWdpbmF0ZSBmcm9tIGFuZCBhcmUgZGlzdHJpYnV0ZWQgYnkgdGhhdCBwYXJ0aWN1bGFyIENvbnRyaWJ1dG9yLgorQSBDb250cmlidXRpb24gJ29yaWdpbmF0ZXMnIGZyb20gYSBDb250cmlidXRvciBpZiBpdCB3YXMgYWRkZWQgdG8gdGhlIFByb2dyYW0gYnkgc3VjaCBDb250cmlidXRvciBpdHNlbGYgb3IgYW55b25lCithY3Rpbmcgb24gc3VjaCBDb250cmlidXRvcidzIGJlaGFsZi4gQ29udHJpYnV0aW9ucyBkbyBub3QgaW5jbHVkZSBhZGRpdGlvbnMgdG8gdGhlIFByb2dyYW0gd2hpY2g6IChpKSBhcmUgc2VwYXJhdGUKK21vZHVsZXMgb2Ygc29mdHdhcmUgZGlzdHJpYnV0ZWQgaW4gY29uanVuY3Rpb24gd2l0aCB0aGUgUHJvZ3JhbSB1bmRlciB0aGVpciBvd24gbGljZW5zZSBhZ3JlZW1lbnQsIGFuZCAoaWkpIGFyZSBub3QKK2Rlcml2YXRpdmUgd29ya3Mgb2YgdGhlIFByb2dyYW0uCisKKyJDb250cmlidXRvciIgbWVhbnMgYW55IHBlcnNvbiBvciBlbnRpdHkgdGhhdCBkaXN0cmlidXRlcyB0aGUgUHJvZ3JhbS4KKworIkxpY2Vuc2VkIFBhdGVudHMgIiBtZWFuIHBhdGVudCBjbGFpbXMgbGljZW5zYWJsZSBieSBhIENvbnRyaWJ1dG9yIHdoaWNoIGFyZSBuZWNlc3NhcmlseSBpbmZyaW5nZWQgYnkgdGhlIHVzZSBvciBzYWxlIG9mCitpdHMgQ29udHJpYnV0aW9uIGFsb25lIG9yIHdoZW4gY29tYmluZWQgd2l0aCB0aGUgUHJvZ3JhbS4KKworIlByb2dyYW0iIG1lYW5zIHRoZSBDb250cmlidXRpb25zIGRpc3RyaWJ1dGVkIGluIGFjY29yZGFuY2Ugd2l0aCB0aGlzIEFncmVlbWVudC4KKworIlJlY2lwaWVudCIgbWVhbnMgYW55b25lIHdobyByZWNlaXZlcyB0aGUgUHJvZ3JhbSB1bmRlciB0aGlzIEFncmVlbWVudCwgaW5jbHVkaW5nIGFsbCBDb250cmlidXRvcnMuCisKKzIuIEdSQU5UIE9GIFJJR0hUUworCithKSBTdWJqZWN0IHRvIHRoZSB0ZXJtcyBvZiB0aGlzIEFncmVlbWVudCwgZWFjaCBDb250cmlidXRvciBoZXJlYnkgZ3JhbnRzIFJlY2lwaWVudCBhIG5vbi1leGNsdXNpdmUsIHdvcmxkd2lkZSwKK3JveWFsdHktZnJlZSBjb3B5cmlnaHQgbGljZW5zZSB0byByZXByb2R1Y2UsIHByZXBhcmUgZGVyaXZhdGl2ZSB3b3JrcyBvZiwgcHVibGljbHkgZGlzcGxheSwgcHVibGljbHkgcGVyZm9ybSwgZGlzdHJpYnV0ZQorYW5kIHN1YmxpY2Vuc2UgdGhlIENvbnRyaWJ1dGlvbiBvZiBzdWNoIENvbnRyaWJ1dG9yLCBpZiBhbnksIGFuZCBzdWNoIGRlcml2YXRpdmUgd29ya3MsIGluIHNvdXJjZSBjb2RlIGFuZCBvYmplY3QgY29kZQorZm9ybS4KKworYikgU3ViamVjdCB0byB0aGUgdGVybXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGVhY2ggQ29udHJpYnV0b3IgaGVyZWJ5IGdyYW50cyBSZWNpcGllbnQgYSBub24tZXhjbHVzaXZlLCB3b3JsZHdpZGUsCityb3lhbHR5LWZyZWUgcGF0ZW50IGxpY2Vuc2UgdW5kZXIgTGljZW5zZWQgUGF0ZW50cyB0byBtYWtlLCB1c2UsIHNlbGwsIG9mZmVyIHRvIHNlbGwsIGltcG9ydCBhbmQgb3RoZXJ3aXNlIHRyYW5zZmVyIHRoZQorQ29udHJpYnV0aW9uIG9mIHN1Y2ggQ29udHJpYnV0b3IsIGlmIGFueSwgaW4gc291cmNlIGNvZGUgYW5kIG9iamVjdCBjb2RlIGZvcm0uIFRoaXMgcGF0ZW50IGxpY2Vuc2Ugc2hhbGwgYXBwbHkgdG8gdGhlCitjb21iaW5hdGlvbiBvZiB0aGUgQ29udHJpYnV0aW9uIGFuZCB0aGUgUHJvZ3JhbSBpZiwgYXQgdGhlIHRpbWUgdGhlIENvbnRyaWJ1dGlvbiBpcyBhZGRlZCBieSB0aGUgQ29udHJpYnV0b3IsIHN1Y2gKK2FkZGl0aW9uIG9mIHRoZSBDb250cmlidXRpb24gY2F1c2VzIHN1Y2ggY29tYmluYXRpb24gdG8gYmUgY292ZXJlZCBieSB0aGUgTGljZW5zZWQgUGF0ZW50cy4gVGhlIHBhdGVudCBsaWNlbnNlIHNoYWxsIG5vdAorYXBwbHkgdG8gYW55IG90aGVyIGNvbWJpbmF0aW9ucyB3aGljaCBpbmNsdWRlIHRoZSBDb250cmlidXRpb24uIE5vIGhhcmR3YXJlIHBlciBzZSBpcyBsaWNlbnNlZCBoZXJldW5kZXIuCisKK2MpIFJlY2lwaWVudCB1bmRlcnN0YW5kcyB0aGF0IGFsdGhvdWdoIGVhY2ggQ29udHJpYnV0b3IgZ3JhbnRzIHRoZSBsaWNlbnNlcyB0byBpdHMgQ29udHJpYnV0aW9ucyBzZXQgZm9ydGggaGVyZWluLCBubworYXNzdXJhbmNlcyBhcmUgcHJvdmlkZWQgYnkgYW55IENvbnRyaWJ1dG9yIHRoYXQgdGhlIFByb2dyYW0gZG9lcyBub3QgaW5mcmluZ2UgdGhlIHBhdGVudCBvciBvdGhlciBpbnRlbGxlY3R1YWwgcHJvcGVydHkKK3JpZ2h0cyBvZiBhbnkgb3RoZXIgZW50aXR5LiBFYWNoIENvbnRyaWJ1dG9yIGRpc2NsYWltcyBhbnkgbGlhYmlsaXR5IHRvIFJlY2lwaWVudCBmb3IgY2xhaW1zIGJyb3VnaHQgYnkgYW55IG90aGVyIGVudGl0eQorYmFzZWQgb24gaW5mcmluZ2VtZW50IG9mIGludGVsbGVjdHVhbCBwcm9wZXJ0eSByaWdodHMgb3Igb3RoZXJ3aXNlLiBBcyBhIGNvbmRpdGlvbiB0byBleGVyY2lzaW5nIHRoZSByaWdodHMgYW5kCitsaWNlbnNlcyBncmFudGVkIGhlcmV1bmRlciwgZWFjaCBSZWNpcGllbnQgaGVyZWJ5IGFzc3VtZXMgc29sZSByZXNwb25zaWJpbGl0eSB0byBzZWN1cmUgYW55IG90aGVyIGludGVsbGVjdHVhbCBwcm9wZXJ0eQorcmlnaHRzIG5lZWRlZCwgaWYgYW55LiBGb3IgZXhhbXBsZSwgaWYgYSB0aGlyZCBwYXJ0eSBwYXRlbnQgbGljZW5zZSBpcyByZXF1aXJlZCB0byBhbGxvdyBSZWNpcGllbnQgdG8gZGlzdHJpYnV0ZSB0aGUKK1Byb2dyYW0sIGl0IGlzIFJlY2lwaWVudCdzIHJlc3BvbnNpYmlsaXR5IHRvIGFjcXVpcmUgdGhhdCBsaWNlbnNlIGJlZm9yZSBkaXN0cmlidXRpbmcgdGhlIFByb2dyYW0uCisKK2QpIEVhY2ggQ29udHJpYnV0b3IgcmVwcmVzZW50cyB0aGF0IHRvIGl0cyBrbm93bGVkZ2UgaXQgaGFzIHN1ZmZpY2llbnQgY29weXJpZ2h0IHJpZ2h0cyBpbiBpdHMgQ29udHJpYnV0aW9uLCBpZiBhbnksIHRvCitncmFudCB0aGUgY29weXJpZ2h0IGxpY2Vuc2Ugc2V0IGZvcnRoIGluIHRoaXMgQWdyZWVtZW50LgorCiszLiBSRVFVSVJFTUVOVFMKKworQSBDb250cmlidXRvciBtYXkgY2hvb3NlIHRvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0gaW4gb2JqZWN0IGNvZGUgZm9ybSB1bmRlciBpdHMgb3duIGxpY2Vuc2UgYWdyZWVtZW50LCBwcm92aWRlZCB0aGF0OgorCithKSBpdCBjb21wbGllcyB3aXRoIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGlzIEFncmVlbWVudDsgYW5kCisKK2IpIGl0cyBsaWNlbnNlIGFncmVlbWVudDoKKworaSkgZWZmZWN0aXZlbHkgZGlzY2xhaW1zIG9uIGJlaGFsZiBvZiBhbGwgQ29udHJpYnV0b3JzIGFsbCB3YXJyYW50aWVzIGFuZCBjb25kaXRpb25zLCBleHByZXNzIGFuZCBpbXBsaWVkLCBpbmNsdWRpbmcKK3dhcnJhbnRpZXMgb3IgY29uZGl0aW9ucyBvZiB0aXRsZSBhbmQgbm9uLWluZnJpbmdlbWVudCwgYW5kIGltcGxpZWQgd2FycmFudGllcyBvciBjb25kaXRpb25zIG9mIG1lcmNoYW50YWJpbGl0eSBhbmQKK2ZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlOworCitpaSkgZWZmZWN0aXZlbHkgZXhjbHVkZXMgb24gYmVoYWxmIG9mIGFsbCBDb250cmlidXRvcnMgYWxsIGxpYWJpbGl0eSBmb3IgZGFtYWdlcywgaW5jbHVkaW5nIGRpcmVjdCwgaW5kaXJlY3QsIHNwZWNpYWwsCitpbmNpZGVudGFsIGFuZCBjb25zZXF1ZW50aWFsIGRhbWFnZXMsIHN1Y2ggYXMgbG9zdCBwcm9maXRzOworCitpaWkpIHN0YXRlcyB0aGF0IGFueSBwcm92aXNpb25zIHdoaWNoIGRpZmZlciBmcm9tIHRoaXMgQWdyZWVtZW50IGFyZSBvZmZlcmVkIGJ5IHRoYXQgQ29udHJpYnV0b3IgYWxvbmUgYW5kIG5vdCBieSBhbnkKK290aGVyIHBhcnR5OyBhbmQKKworaXYpIHN0YXRlcyB0aGF0IHNvdXJjZSBjb2RlIGZvciB0aGUgUHJvZ3JhbSBpcyBhdmFpbGFibGUgZnJvbSBzdWNoIENvbnRyaWJ1dG9yLCBhbmQgaW5mb3JtcyBsaWNlbnNlZXMgaG93IHRvIG9idGFpbiBpdAoraW4gYSByZWFzb25hYmxlIG1hbm5lciBvbiBvciB0aHJvdWdoIGEgbWVkaXVtIGN1c3RvbWFyaWx5IHVzZWQgZm9yIHNvZnR3YXJlIGV4Y2hhbmdlLgorCitXaGVuIHRoZSBQcm9ncmFtIGlzIG1hZGUgYXZhaWxhYmxlIGluIHNvdXJjZSBjb2RlIGZvcm06CisKK2EpIGl0IG11c3QgYmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhpcyBBZ3JlZW1lbnQ7IGFuZAorCitiKSBhIGNvcHkgb2YgdGhpcyBBZ3JlZW1lbnQgbXVzdCBiZSBpbmNsdWRlZCB3aXRoIGVhY2ggY29weSBvZiB0aGUgUHJvZ3JhbS4KKworQ29udHJpYnV0b3JzIG1heSBub3QgcmVtb3ZlIG9yIGFsdGVyIGFueSBjb3B5cmlnaHQgbm90aWNlcyBjb250YWluZWQgd2l0aGluIHRoZSBQcm9ncmFtLgorCitFYWNoIENvbnRyaWJ1dG9yIG11c3QgaWRlbnRpZnkgaXRzZWxmIGFzIHRoZSBvcmlnaW5hdG9yIG9mIGl0cyBDb250cmlidXRpb24sIGlmIGFueSwgaW4gYSBtYW5uZXIgdGhhdCByZWFzb25hYmx5IGFsbG93cworc3Vic2VxdWVudCBSZWNpcGllbnRzIHRvIGlkZW50aWZ5IHRoZSBvcmlnaW5hdG9yIG9mIHRoZSBDb250cmlidXRpb24uCisKKzQuIENPTU1FUkNJQUwgRElTVFJJQlVUSU9OCisKK0NvbW1lcmNpYWwgZGlzdHJpYnV0b3JzIG9mIHNvZnR3YXJlIG1heSBhY2NlcHQgY2VydGFpbiByZXNwb25zaWJpbGl0aWVzIHdpdGggcmVzcGVjdCB0byBlbmQgdXNlcnMsIGJ1c2luZXNzIHBhcnRuZXJzIGFuZAordGhlIGxpa2UuIFdoaWxlIHRoaXMgbGljZW5zZSBpcyBpbnRlbmRlZCB0byBmYWNpbGl0YXRlIHRoZSBjb21tZXJjaWFsIHVzZSBvZiB0aGUgUHJvZ3JhbSwgdGhlIENvbnRyaWJ1dG9yIHdobyBpbmNsdWRlcwordGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcgc2hvdWxkIGRvIHNvIGluIGEgbWFubmVyIHdoaWNoIGRvZXMgbm90IGNyZWF0ZSBwb3RlbnRpYWwgbGlhYmlsaXR5IGZvcgorb3RoZXIgQ29udHJpYnV0b3JzLiBUaGVyZWZvcmUsIGlmIGEgQ29udHJpYnV0b3IgaW5jbHVkZXMgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcsIHN1Y2ggQ29udHJpYnV0b3IKKygiQ29tbWVyY2lhbCBDb250cmlidXRvciIpIGhlcmVieSBhZ3JlZXMgdG8gZGVmZW5kIGFuZCBpbmRlbW5pZnkgZXZlcnkgb3RoZXIgQ29udHJpYnV0b3IgKCJJbmRlbW5pZmllZCBDb250cmlidXRvciIpCithZ2FpbnN0IGFueSBsb3NzZXMsIGRhbWFnZXMgYW5kIGNvc3RzIChjb2xsZWN0aXZlbHkgIkxvc3NlcyIpIGFyaXNpbmcgZnJvbSBjbGFpbXMsIGxhd3N1aXRzIGFuZCBvdGhlciBsZWdhbCBhY3Rpb25zCiticm91Z2h0IGJ5IGEgdGhpcmQgcGFydHkgYWdhaW5zdCB0aGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgdG8gdGhlIGV4dGVudCBjYXVzZWQgYnkgdGhlIGFjdHMgb3Igb21pc3Npb25zIG9mIHN1Y2gKK0NvbW1lcmNpYWwgQ29udHJpYnV0b3IgaW4gY29ubmVjdGlvbiB3aXRoIGl0cyBkaXN0cmlidXRpb24gb2YgdGhlIFByb2dyYW0gaW4gYSBjb21tZXJjaWFsIHByb2R1Y3Qgb2ZmZXJpbmcuIFRoZQorb2JsaWdhdGlvbnMgaW4gdGhpcyBzZWN0aW9uIGRvIG5vdCBhcHBseSB0byBhbnkgY2xhaW1zIG9yIExvc3NlcyByZWxhdGluZyB0byBhbnkgYWN0dWFsIG9yIGFsbGVnZWQgaW50ZWxsZWN0dWFsCitwcm9wZXJ0eSBpbmZyaW5nZW1lbnQuIEluIG9yZGVyIHRvIHF1YWxpZnksIGFuIEluZGVtbmlmaWVkIENvbnRyaWJ1dG9yIG11c3Q6IGEpIHByb21wdGx5IG5vdGlmeSB0aGUgQ29tbWVyY2lhbAorQ29udHJpYnV0b3IgaW4gd3JpdGluZyBvZiBzdWNoIGNsYWltLCBhbmQgYikgYWxsb3cgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3IgdG8gY29udHJvbCwgYW5kIGNvb3BlcmF0ZSB3aXRoIHRoZQorQ29tbWVyY2lhbCBDb250cmlidXRvciBpbiwgdGhlIGRlZmVuc2UgYW5kIGFueSByZWxhdGVkIHNldHRsZW1lbnQgbmVnb3RpYXRpb25zLiBUaGUgSW5kZW1uaWZpZWQgQ29udHJpYnV0b3IgbWF5CisgcGFydGljaXBhdGUgaW4gYW55IHN1Y2ggY2xhaW0gYXQgaXRzIG93biBleHBlbnNlLgorCitGb3IgZXhhbXBsZSwgYSBDb250cmlidXRvciBtaWdodCBpbmNsdWRlIHRoZSBQcm9ncmFtIGluIGEgY29tbWVyY2lhbCBwcm9kdWN0IG9mZmVyaW5nLCBQcm9kdWN0IFguIFRoYXQgQ29udHJpYnV0b3IgaXMKK3RoZW4gYSBDb21tZXJjaWFsIENvbnRyaWJ1dG9yLiBJZiB0aGF0IENvbW1lcmNpYWwgQ29udHJpYnV0b3IgdGhlbiBtYWtlcyBwZXJmb3JtYW5jZSBjbGFpbXMsIG9yIG9mZmVycyB3YXJyYW50aWVzCityZWxhdGVkIHRvIFByb2R1Y3QgWCwgdGhvc2UgcGVyZm9ybWFuY2UgY2xhaW1zIGFuZCB3YXJyYW50aWVzIGFyZSBzdWNoIENvbW1lcmNpYWwgQ29udHJpYnV0b3IncyByZXNwb25zaWJpbGl0eSBhbG9uZS4KK1VuZGVyIHRoaXMgc2VjdGlvbiwgdGhlIENvbW1lcmNpYWwgQ29udHJpYnV0b3Igd291bGQgaGF2ZSB0byBkZWZlbmQgY2xhaW1zIGFnYWluc3QgdGhlIG90aGVyIENvbnRyaWJ1dG9ycyByZWxhdGVkIHRvCit0aG9zZSBwZXJmb3JtYW5jZSBjbGFpbXMgYW5kIHdhcnJhbnRpZXMsIGFuZCBpZiBhIGNvdXJ0IHJlcXVpcmVzIGFueSBvdGhlciBDb250cmlidXRvciB0byBwYXkgYW55IGRhbWFnZXMgYXMgYSByZXN1bHQsCit0aGUgQ29tbWVyY2lhbCBDb250cmlidXRvciBtdXN0IHBheSB0aG9zZSBkYW1hZ2VzLgorCis1LiBOTyBXQVJSQU5UWQorCitFWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTIEFHUkVFTUVOVCwgVEhFIFBST0dSQU0gSVMgUFJPVklERUQgT04gQU4gIkFTIElTIiBCQVNJUywgV0lUSE9VVCBXQVJSQU5USUVTIE9SCitDT05ESVRJT05TIE9GIEFOWSBLSU5ELCBFSVRIRVIgRVhQUkVTUyBPUiBJTVBMSUVEIElOQ0xVRElORywgV0lUSE9VVCBMSU1JVEFUSU9OLCBBTlkgV0FSUkFOVElFUyBPUiBDT05ESVRJT05TIE9GIFRJVExFLAorTk9OLUlORlJJTkdFTUVOVCwgTUVSQ0hBTlRBQklMSVRZIE9SIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiBFYWNoIFJlY2lwaWVudCBpcyBzb2xlbHkgcmVzcG9uc2libGUgZm9yCitkZXRlcm1pbmluZyB0aGUgYXBwcm9wcmlhdGVuZXNzIG9mIHVzaW5nIGFuZCBkaXN0cmlidXRpbmcgdGhlIFByb2dyYW0gYW5kIGFzc3VtZXMgYWxsIHJpc2tzIGFzc29jaWF0ZWQgd2l0aCBpdHMKK2V4ZXJjaXNlIG9mIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCAsIGluY2x1ZGluZyBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIHJpc2tzIGFuZCBjb3N0cyBvZiBwcm9ncmFtIGVycm9ycywgY29tcGxpYW5jZQord2l0aCBhcHBsaWNhYmxlIGxhd3MsIGRhbWFnZSB0byBvciBsb3NzIG9mIGRhdGEsIHByb2dyYW1zIG9yIGVxdWlwbWVudCwgYW5kIHVuYXZhaWxhYmlsaXR5IG9yIGludGVycnVwdGlvbiBvZiBvcGVyYXRpb25zLgorCis2LiBESVNDTEFJTUVSIE9GIExJQUJJTElUWQorCitFWENFUFQgQVMgRVhQUkVTU0xZIFNFVCBGT1JUSCBJTiBUSElTIEFHUkVFTUVOVCwgTkVJVEhFUiBSRUNJUElFTlQgTk9SIEFOWSBDT05UUklCVVRPUlMgU0hBTEwgSEFWRSBBTlkgTElBQklMSVRZIEZPUiBBTlkKK0RJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcgV0lUSE9VVCBMSU1JVEFUSU9OIExPU1QgUFJPRklUUyksCitIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQgKElOQ0xVRElORyBORUdMSUdFTkNFIE9SCitPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPUiBESVNUUklCVVRJT04gT0YgVEhFIFBST0dSQU0gT1IgVEhFIEVYRVJDSVNFIE9GIEFOWSBSSUdIVFMgR1JBTlRFRAorSEVSRVVOREVSLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFUy4KKworNy4gR0VORVJBTAorCitJZiBhbnkgcHJvdmlzaW9uIG9mIHRoaXMgQWdyZWVtZW50IGlzIGludmFsaWQgb3IgdW5lbmZvcmNlYWJsZSB1bmRlciBhcHBsaWNhYmxlIGxhdywgaXQgc2hhbGwgbm90IGFmZmVjdCB0aGUgdmFsaWRpdHkgb3IKK2VuZm9yY2VhYmlsaXR5IG9mIHRoZSByZW1haW5kZXIgb2YgdGhlIHRlcm1zIG9mIHRoaXMgQWdyZWVtZW50LCBhbmQgd2l0aG91dCBmdXJ0aGVyIGFjdGlvbiBieSB0aGUgcGFydGllcyBoZXJldG8sIHN1Y2gKK3Byb3Zpc2lvbiBzaGFsbCBiZSByZWZvcm1lZCB0byB0aGUgbWluaW11bSBleHRlbnQgbmVjZXNzYXJ5IHRvIG1ha2Ugc3VjaCBwcm92aXNpb24gdmFsaWQgYW5kIGVuZm9yY2VhYmxlLgorCitJZiBSZWNpcGllbnQgaW5zdGl0dXRlcyBwYXRlbnQgbGl0aWdhdGlvbiBhZ2FpbnN0IGFueSBlbnRpdHkgKGluY2x1ZGluZyBhIGNyb3NzLWNsYWltIG9yIGNvdW50ZXJjbGFpbSBpbiBhIGxhd3N1aXQpCithbGxlZ2luZyB0aGF0IHRoZSBQcm9ncmFtIGl0c2VsZiAoZXhjbHVkaW5nIGNvbWJpbmF0aW9ucyBvZiB0aGUgUHJvZ3JhbSB3aXRoIG90aGVyIHNvZnR3YXJlIG9yIGhhcmR3YXJlKSBpbmZyaW5nZXMgc3VjaAorUmVjaXBpZW50J3MgcGF0ZW50KHMpLCB0aGVuIHN1Y2ggUmVjaXBpZW50J3MgcmlnaHRzIGdyYW50ZWQgdW5kZXIgU2VjdGlvbiAyKGIpIHNoYWxsIHRlcm1pbmF0ZSBhcyBvZiB0aGUgZGF0ZSBzdWNoCitsaXRpZ2F0aW9uIGlzIGZpbGVkLgorCitBbGwgUmVjaXBpZW50J3MgcmlnaHRzIHVuZGVyIHRoaXMgQWdyZWVtZW50IHNoYWxsIHRlcm1pbmF0ZSBpZiBpdCBmYWlscyB0byBjb21wbHkgd2l0aCBhbnkgb2YgdGhlIG1hdGVyaWFsIHRlcm1zIG9yCitjb25kaXRpb25zIG9mIHRoaXMgQWdyZWVtZW50IGFuZCBkb2VzIG5vdCBjdXJlIHN1Y2ggZmFpbHVyZSBpbiBhIHJlYXNvbmFibGUgcGVyaW9kIG9mIHRpbWUgYWZ0ZXIgYmVjb21pbmcgYXdhcmUgb2Ygc3VjaAorbm9uY29tcGxpYW5jZS4gSWYgYWxsIFJlY2lwaWVudCdzIHJpZ2h0cyB1bmRlciB0aGlzIEFncmVlbWVudCB0ZXJtaW5hdGUsIFJlY2lwaWVudCBhZ3JlZXMgdG8gY2Vhc2UgdXNlIGFuZCBkaXN0cmlidXRpb24KK29mIHRoZSBQcm9ncmFtIGFzIHNvb24gYXMgcmVhc29uYWJseSBwcmFjdGljYWJsZS4gSG93ZXZlciwgUmVjaXBpZW50J3Mgb2JsaWdhdGlvbnMgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYW5kIGFueSBsaWNlbnNlcworIGdyYW50ZWQgYnkgUmVjaXBpZW50IHJlbGF0aW5nIHRvIHRoZSBQcm9ncmFtIHNoYWxsIGNvbnRpbnVlIGFuZCBzdXJ2aXZlLgorCitFdmVyeW9uZSBpcyBwZXJtaXR0ZWQgdG8gY29weSBhbmQgZGlzdHJpYnV0ZSBjb3BpZXMgb2YgdGhpcyBBZ3JlZW1lbnQsIGJ1dCBpbiBvcmRlciB0byBhdm9pZCBpbmNvbnNpc3RlbmN5IHRoZSBBZ3JlZW1lbnQKK2lzIGNvcHlyaWdodGVkIGFuZCBtYXkgb25seSBiZSBtb2RpZmllZCBpbiB0aGUgZm9sbG93aW5nIG1hbm5lci4gVGhlIEFncmVlbWVudCBTdGV3YXJkIHJlc2VydmVzIHRoZSByaWdodCB0byBwdWJsaXNoCituZXcgdmVyc2lvbnMgKGluY2x1ZGluZyByZXZpc2lvbnMpIG9mIHRoaXMgQWdyZWVtZW50IGZyb20gdGltZSB0byB0aW1lLiBObyBvbmUgb3RoZXIgdGhhbiB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgaGFzIHRoZQorcmlnaHQgdG8gbW9kaWZ5IHRoaXMgQWdyZWVtZW50LiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIHRoZSBpbml0aWFsIEFncmVlbWVudCBTdGV3YXJkLiBUaGUgRWNsaXBzZSBGb3VuZGF0aW9uIG1heQorYXNzaWduIHRoZSByZXNwb25zaWJpbGl0eSB0byBzZXJ2ZSBhcyB0aGUgQWdyZWVtZW50IFN0ZXdhcmQgdG8gYSBzdWl0YWJsZSBzZXBhcmF0ZSBlbnRpdHkuIEVhY2ggbmV3IHZlcnNpb24gb2YgdGhlCitBZ3JlZW1lbnQgd2lsbCBiZSBnaXZlbiBhIGRpc3Rpbmd1aXNoaW5nIHZlcnNpb24gbnVtYmVyLiBUaGUgUHJvZ3JhbSAoaW5jbHVkaW5nIENvbnRyaWJ1dGlvbnMpIG1heSBhbHdheXMgYmUKK2Rpc3RyaWJ1dGVkIHN1YmplY3QgdG8gdGhlIHZlcnNpb24gb2YgdGhlIEFncmVlbWVudCB1bmRlciB3aGljaCBpdCB3YXMgcmVjZWl2ZWQuIEluIGFkZGl0aW9uLCBhZnRlciBhIG5ldyB2ZXJzaW9uIG9mCit0aGUgQWdyZWVtZW50IGlzIHB1Ymxpc2hlZCwgQ29udHJpYnV0b3IgbWF5IGVsZWN0IHRvIGRpc3RyaWJ1dGUgdGhlIFByb2dyYW0gKGluY2x1ZGluZyBpdHMgQ29udHJpYnV0aW9ucykgdW5kZXIgdGhlCituZXcgdmVyc2lvbi4gRXhjZXB0IGFzIGV4cHJlc3NseSBzdGF0ZWQgaW4gU2VjdGlvbnMgMihhKSBhbmQgMihiKSBhYm92ZSwgUmVjaXBpZW50IHJlY2VpdmVzIG5vIHJpZ2h0cyBvciBsaWNlbnNlcyB0bwordGhlIGludGVsbGVjdHVhbCBwcm9wZXJ0eSBvZiBhbnkgQ29udHJpYnV0b3IgdW5kZXIgdGhpcyBBZ3JlZW1lbnQsIHdoZXRoZXIgZXhwcmVzc2x5LCBieSBpbXBsaWNhdGlvbiwgZXN0b3BwZWwgb3IKK290aGVyd2lzZS4gQWxsIHJpZ2h0cyBpbiB0aGUgUHJvZ3JhbSBub3QgZXhwcmVzc2x5IGdyYW50ZWQgdW5kZXIgdGhpcyBBZ3JlZW1lbnQgYXJlIHJlc2VydmVkLgorCitUaGlzIEFncmVlbWVudCBpcyBnb3Zlcm5lZCBieSB0aGUgbGF3cyBvZiB0aGUgU3RhdGUgb2YgTmV3IFlvcmsgYW5kIHRoZSBpbnRlbGxlY3R1YWwgcHJvcGVydHkgbGF3cyBvZiB0aGUgVW5pdGVkIFN0YXRlcworb2YgQW1lcmljYS4gTm8gcGFydHkgdG8gdGhpcyBBZ3JlZW1lbnQgd2lsbCBicmluZyBhIGxlZ2FsIGFjdGlvbiB1bmRlciB0aGlzIEFncmVlbWVudCBtb3JlIHRoYW4gb25lIHllYXIgYWZ0ZXIgdGhlIGNhdXNlCitvZiBhY3Rpb24gYXJvc2UuIEVhY2ggcGFydHkgd2FpdmVzIGl0cyByaWdodHMgdG8gYSBqdXJ5IHRyaWFsIGluIGFueSByZXN1bHRpbmcgbGl0aWdhdGlvbi4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IvTUVUQS1JTkYvTUFOSUZFU1QuTUYgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IvTUVUQS1JTkYvTUFOSUZFU1QuTUYKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uOTViZGQxZgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci9NRVRBLUlORi9NQU5JRkVTVC5NRgpAQCAtMCwwICsxLDE2IEBACitNYW5pZmVzdC1WZXJzaW9uOiAxLjAKK0J1bmRsZS1NYW5pZmVzdFZlcnNpb246IDIKK0J1bmRsZS1OYW1lOiBvcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IKK0J1bmRsZS1TeW1ib2xpY05hbWU6IG9yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvcjtzaW5nbGV0b246PXRydWUKK0J1bmRsZS1WZXJzaW9uOiAwLjkuMC5xdWFsaWZpZXIKK0J1bmRsZS1WZW5kb3I6IEVjbGlwc2UgT1NCUAorUmVxdWlyZS1CdW5kbGU6IG9yZy5lY2xpcHNlLmNvcmUucnVudGltZSwKKyBvcmcuZWNsaXBzZS5lcXVpbm94LnAyLmFydGlmYWN0LnJlcG9zaXRvcnk7YnVuZGxlLXZlcnNpb249IjEuMS4zMDAiLAorIG9yZy5lY2xpcHNlLmVxdWlub3gucDIucmVwb3NpdG9yeS50b29scztidW5kbGUtdmVyc2lvbj0iMi4xLjAiLAorIG9yZy5lY2xpcHNlLmVxdWlub3gucDIucmVwb3NpdG9yeQorQnVuZGxlLVJlcXVpcmVkRXhlY3V0aW9uRW52aXJvbm1lbnQ6IEphdmFTRS0xLjcKK0J1bmRsZS1BY3RpdmF0aW9uUG9saWN5OiBsYXp5CitJbXBvcnQtUGFja2FnZTogb3JnLm9zZ2kuc2VydmljZS5jb21wb25lbnQ7dmVyc2lvbj0iMS4yLjIiLAorIG9yZy5vc2dpLnNlcnZpY2UuY29tcG9uZW50LmFubm90YXRpb25zO3ZlcnNpb249IjEuMi4wIiwKKyBvcmcuc2xmNGo7dmVyc2lvbj0iMS43LjIiCitTZXJ2aWNlLUNvbXBvbmVudDogT1NHSS1JTkYvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yLkNvbnNvbGVDb21tYW5kcy54bWwKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci9PU0dJLUlORi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IuQ29uc29sZUNvbW1hbmRzLnhtbCBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci9PU0dJLUlORi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IuQ29uc29sZUNvbW1hbmRzLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4xMDZmN2U1Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL09TR0ktSU5GL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5Db25zb2xlQ29tbWFuZHMueG1sCkBAIC0wLDAgKzEsOSBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KKzxzY3I6Y29tcG9uZW50IHhtbG5zOnNjcj0iaHR0cDovL3d3dy5vc2dpLm9yZy94bWxucy9zY3IvdjEuMS4wIiBhY3RpdmF0ZT0iYWN0aXZhdGUiIGRlYWN0aXZhdGU9ImRlYWN0aXZhdGUiIG5hbWU9Im9yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5Db25zb2xlQ29tbWFuZHMiPgorICAgPGltcGxlbWVudGF0aW9uIGNsYXNzPSJvcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IuQ29uc29sZUNvbW1hbmRzIi8+CisgICA8c2VydmljZT4KKyAgICAgIDxwcm92aWRlIGludGVyZmFjZT0ib3JnLmVjbGlwc2Uub3NnaS5mcmFtZXdvcmsuY29uc29sZS5Db21tYW5kUHJvdmlkZXIiLz4KKyAgIDwvc2VydmljZT4KKyAgIDxyZWZlcmVuY2UgYmluZD0iYmluZEFydGlmYWN0cyIgY2FyZGluYWxpdHk9IjEuLjEiIGludGVyZmFjZT0ib3JnLm9zZ2kuc2VydmljZS5hcHBsaWNhdGlvbi5BcHBsaWNhdGlvbkRlc2NyaXB0b3IiIG5hbWU9IkFydGlmYWN0cyIgcG9saWN5PSJzdGF0aWMiIHRhcmdldD0iKHNlcnZpY2UucGlkPW9yZy5lY2xpcHNlLmVxdWlub3gucDIuYXJ0aWZhY3QucmVwb3NpdG9yeS5taXJyb3JBcHBsaWNhdGlvbikiLz4KKyAgIDxyZWZlcmVuY2UgYmluZD0iYmluZE1ldGFkYXRhIiBjYXJkaW5hbGl0eT0iMS4uMSIgaW50ZXJmYWNlPSJvcmcub3NnaS5zZXJ2aWNlLmFwcGxpY2F0aW9uLkFwcGxpY2F0aW9uRGVzY3JpcHRvciIgbmFtZT0iTWV0YWRhdGEiIHBvbGljeT0ic3RhdGljIiB0YXJnZXQ9IihzZXJ2aWNlLnBpZD1vcmcuZWNsaXBzZS5lcXVpbm94LnAyLm1ldGFkYXRhLnJlcG9zaXRvcnkubWlycm9yQXBwbGljYXRpb24pIi8+Cis8L3Njcjpjb21wb25lbnQ+ClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL2Fib3V0Lmh0bWwgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IvYWJvdXQuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi42NGMwNTk4Ci0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL2Fib3V0Lmh0bWwKQEAgLTAsMCArMSwyOCBAQAorPCFET0NUWVBFIGh0bWwgUFVCTElDICItLy9XM0MvL0RURCBYSFRNTCAxLjAgU3RyaWN0Ly9FTiIKKyAgICAiaHR0cDovL3d3dy53My5vcmcvVFIveGh0bWwxL0RURC94aHRtbDEtc3RyaWN0LmR0ZCI+Cis8aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+Cis8aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiLz4KKzx0aXRsZT5BYm91dDwvdGl0bGU+Cis8L2hlYWQ+Cis8Ym9keSBsYW5nPSJFTi1VUyI+Cis8aDI+QWJvdXQgVGhpcyBDb250ZW50PC9oMj4KKyAKKzxwPkp1bmUgMSwgMjAxNjwvcD4JCis8aDM+TGljZW5zZTwvaDM+CisKKzxwPlRoZSBFY2xpcHNlIEZvdW5kYXRpb24gbWFrZXMgYXZhaWxhYmxlIGFsbCBjb250ZW50IGluIHRoaXMgcGx1Zy1pbiAoJnF1b3Q7Q29udGVudCZxdW90OykuICBVbmxlc3Mgb3RoZXJ3aXNlIAoraW5kaWNhdGVkIGJlbG93LCB0aGUgQ29udGVudCBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZQorRWNsaXBzZSBQdWJsaWMgTGljZW5zZSBWZXJzaW9uIDEuMCAoJnF1b3Q7RVBMJnF1b3Q7KS4gIEEgY29weSBvZiB0aGUgRVBMIGlzIGF2YWlsYWJsZSAKK2F0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbDwvYT4uCitGb3IgcHVycG9zZXMgb2YgdGhlIEVQTCwgJnF1b3Q7UHJvZ3JhbSZxdW90OyB3aWxsIG1lYW4gdGhlIENvbnRlbnQuPC9wPgorCis8cD5JZiB5b3UgZGlkIG5vdCByZWNlaXZlIHRoaXMgQ29udGVudCBkaXJlY3RseSBmcm9tIHRoZSBFY2xpcHNlIEZvdW5kYXRpb24sIHRoZSBDb250ZW50IGlzIAorYmVpbmcgcmVkaXN0cmlidXRlZCBieSBhbm90aGVyIHBhcnR5ICgmcXVvdDtSZWRpc3RyaWJ1dG9yJnF1b3Q7KSBhbmQgZGlmZmVyZW50IHRlcm1zIGFuZCBjb25kaXRpb25zIG1heQorYXBwbHkgdG8geW91ciB1c2Ugb2YgYW55IG9iamVjdCBjb2RlIGluIHRoZSBDb250ZW50LiAgQ2hlY2sgdGhlIFJlZGlzdHJpYnV0b3IncyBsaWNlbnNlIHRoYXQgd2FzIAorcHJvdmlkZWQgd2l0aCB0aGUgQ29udGVudC4gIElmIG5vIHN1Y2ggbGljZW5zZSBleGlzdHMsIGNvbnRhY3QgdGhlIFJlZGlzdHJpYnV0b3IuICBVbmxlc3Mgb3RoZXJ3aXNlCitpbmRpY2F0ZWQgYmVsb3csIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyBvZiB0aGUgRVBMIHN0aWxsIGFwcGx5IHRvIGFueSBzb3VyY2UgY29kZSBpbiB0aGUgQ29udGVudAorYW5kIHN1Y2ggc291cmNlIGNvZGUgbWF5IGJlIG9idGFpbmVkIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvIj5odHRwOi8vd3d3LmVjbGlwc2Uub3JnPC9hPi48L3A+CisKKzwvYm9keT4KKzwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IvYWJvdXQuaW5pIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL2Fib3V0LmluaQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi43ZGY2NzFmCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL2Fib3V0LmluaQpAQCAtMCwwICsxLDE3IEBACisjIGFib3V0LmluaQorIyBjb250YWlucyBpbmZvcm1hdGlvbiBhYm91dCBhIGZlYXR1cmUKKyMgamF2YS5pby5Qcm9wZXJ0aWVzIGZpbGUgKElTTyA4ODU5LTEgd2l0aCAiXCIgZXNjYXBlcykKKyMgIiVrZXkiIGFyZSBleHRlcm5hbGl6ZWQgc3RyaW5ncyBkZWZpbmVkIGluIGFib3V0LnByb3BlcnRpZXMKKyMgVGhpcyBmaWxlIGRvZXMgbm90IG5lZWQgdG8gYmUgdHJhbnNsYXRlZC4KKworIyBQcm9wZXJ0eSAiYWJvdXRUZXh0IiBjb250YWlucyBibHVyYiBmb3IgIkFib3V0IiBkaWFsb2cgKHRyYW5zbGF0ZWQpCithYm91dFRleHQ9JWZlYXR1cmVUZXh0CisKKyMgUHJvcGVydHkgImZlYXR1cmVJbWFnZSIgY29udGFpbnMgcGF0aCB0byBmZWF0dXJlIGltYWdlICgzMngzMikKK2ZlYXR1cmVJbWFnZT0KKworIyBQcm9wZXJ0eSAiYXBwTmFtZSIgY29udGFpbnMgbmFtZSBvZiB0aGUgYXBwbGljYXRpb24gKHRyYW5zbGF0ZWQpCithcHBOYW1lPSVmZWF0dXJlTmFtZQorCisjIFByb3BlcnR5ICJ3ZWxjb21lUGFnZSIgY29udGFpbnMgcGF0aCB0byB3ZWxjb21lIHBhZ2UgKHNwZWNpYWwgWE1MLWJhc2VkIGZvcm1hdCkKK3dlbGNvbWVQYWdlPQpkaWZmIC0tZ2l0IGEvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL2Fib3V0Lm1hcHBpbmdzIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL2Fib3V0Lm1hcHBpbmdzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjQ1MTFhMGEKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IvYWJvdXQubWFwcGluZ3MKQEAgLTAsMCArMSw2IEBACisjIGFib3V0Lm1hcHBpbmdzCisjIGNvbnRhaW5zIGZpbGwtaW5zIGZvciBhYm91dC5wcm9wZXJ0aWVzCisjIGphdmEuaW8uUHJvcGVydGllcyBmaWxlIChJU08gODg1OS0xIHdpdGggIlwiIGVzY2FwZXMpCisjIFRoaXMgZmlsZSBkb2VzIG5vdCBuZWVkIHRvIGJlIHRyYW5zbGF0ZWQuCisKKzA9cXVhbGlmaWVyCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IvYWJvdXQucHJvcGVydGllcyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci9hYm91dC5wcm9wZXJ0aWVzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjhlODRjYzcKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IvYWJvdXQucHJvcGVydGllcwpAQCAtMCwwICsxLDI2IEBACisjCisjIENvcHlyaWdodCAoYykgMjAxMiwgMjAxNiAtIExvZXR6IEdtYkgmQ28uS0cgKEhlaWRlbGJlcmcpCisjIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCisjIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisjIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisjCisjIENvbnRyaWJ1dG9yczoKKyMgICAgTG9ldHogR21iSCZDby5LRyAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbgorIworCisjIE5MU19NRVNTQUdFRk9STUFUX1ZBUgorCitmZWF0dXJlTmFtZT1vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IKKworIyMjIyMjIyMjIyMjIyMjIyBibHVyYiBwcm9wZXJ0eSAjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMKK2ZlYXR1cmVUZXh0PVwKK0NvcHlyaWdodCAoYykgMjAxMi0yMDE2IC0gTG9ldHogR21iSCZDby5LRyBcblwKK0FsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHNcblwKK2FyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMFxuXAord2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXRcblwKK2h0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sXG5cCitcblwKK0NvbnRyaWJ1dG9yczpcblwKKyAgICBMb2V0eiBHbWJIJkNvLktHIC0gaW1wbGVtZW50YXRpb25cbgorIyMjIyMjIyMjIyMjIyMjIyBlbmQgb2YgYmx1cmIgcHJvcGVydHkgIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjIyMjCmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IvYnVpbGQucHJvcGVydGllcyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci9idWlsZC5wcm9wZXJ0aWVzCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmY1MmRhMTgKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IvYnVpbGQucHJvcGVydGllcwpAQCAtMCwwICsxLDEwIEBACitvdXRwdXQuLiA9IGJpbi8KK2Jpbi5pbmNsdWRlcyA9IGFib3V0LnByb3BlcnRpZXMsICBhYm91dC5tYXBwaW5ncywgIGFib3V0LmluaSwgIGFib3V0Lmh0bWwsICBNRVRBLUlORi8sXAorICAgICAgICAgICAgICAgLixcCisgICAgICAgICAgICAgICBwbHVnaW4ueG1sLFwKKyAgICAgICAgICAgICAgIE9TR0ktSU5GL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5Db25zb2xlQ29tbWFuZHMueG1sLFwKKyAgICAgICAgICAgICAgIExJQ0VOU0UudHh0LFwKKyAgICAgICAgICAgICAgIGxpY2Vuc2UuaHRtbAorc291cmNlLi4gPSBzcmMvCitzcmMuaW5jbHVkZXMgPSBhYm91dC5wcm9wZXJ0aWVzLCAgYWJvdXQubWFwcGluZ3MsICBhYm91dC5pbmksICBhYm91dC5odG1sLCAgbGljZW5zZS5odG1sLFwKKyAgICAgICAgICAgICAgIExJQ0VOU0UudHh0CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IvbGljZW5zZS5odG1sIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL2xpY2Vuc2UuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jMzNkNDVjCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL2xpY2Vuc2UuaHRtbApAQCAtMCwwICsxLDEwOSBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iSVNPLTg4NTktMSIgPz4KKzwhRE9DVFlQRSBodG1sIFBVQkxJQyAiLS8vVzNDLy9EVEQgWEhUTUwgMS4wIFN0cmljdC8vRU4iICJodHRwOi8vd3d3LnczLm9yZy9UUi94aHRtbDEvRFREL3hodG1sMS1zdHJpY3QuZHRkIj4KKzwhLS0gc2F2ZWQgZnJvbSB1cmw9KDAwNDQpaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwvbm90aWNlLmh0bWwgLS0+Cis8aHRtbCB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMTk5OS94aHRtbCI+Cis8aGVhZD4KKzxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PUlTTy04ODU5LTEiIC8+Cis8dGl0bGU+RWNsaXBzZSBGb3VuZGF0aW9uIFNvZnR3YXJlIFVzZXIgQWdyZWVtZW50PC90aXRsZT4KKzwvaGVhZD4KKworPGJvZHkgbGFuZz0iRU4tVVMiPgorPGgyPkVjbGlwc2UgRm91bmRhdGlvbiBTb2Z0d2FyZSBVc2VyIEFncmVlbWVudDwvaDI+Cis8cD5GZWJydWFyeSAxLCAyMDExPC9wPgorCis8aDM+VXNhZ2UgT2YgQ29udGVudDwvaDM+CisKKzxwPlRIRSBFQ0xJUFNFIEZPVU5EQVRJT04gTUFLRVMgQVZBSUxBQkxFIFNPRlRXQVJFLCBET0NVTUVOVEFUSU9OLCBJTkZPUk1BVElPTiBBTkQvT1IgT1RIRVIgTUFURVJJQUxTIEZPUiBPUEVOIFNPVVJDRSBQUk9KRUNUUworICAgKENPTExFQ1RJVkVMWSAmcXVvdDtDT05URU5UJnF1b3Q7KS4gIFVTRSBPRiBUSEUgQ09OVEVOVCBJUyBHT1ZFUk5FRCBCWSBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EL09SIFRIRSBURVJNUyBBTkQKKyAgIENPTkRJVElPTlMgT0YgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1cuICBCWSBVU0lORyBUSEUgQ09OVEVOVCwgWU9VIEFHUkVFIFRIQVQgWU9VUiBVU0UKKyAgIE9GIFRIRSBDT05URU5UIElTIEdPVkVSTkVEIEJZIFRISVMgQUdSRUVNRU5UIEFORC9PUiBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SCisgICBOT1RJQ0VTIElORElDQVRFRCBPUiBSRUZFUkVOQ0VEIEJFTE9XLiAgSUYgWU9VIERPIE5PVCBBR1JFRSBUTyBUSEUgVEVSTVMgQU5EIENPTkRJVElPTlMgT0YgVEhJUyBBR1JFRU1FTlQgQU5EIFRIRSBURVJNUyBBTkQKKyAgIENPTkRJVElPTlMgT0YgQU5ZIEFQUExJQ0FCTEUgTElDRU5TRSBBR1JFRU1FTlRTIE9SIE5PVElDRVMgSU5ESUNBVEVEIE9SIFJFRkVSRU5DRUQgQkVMT1csIFRIRU4gWU9VIE1BWSBOT1QgVVNFIFRIRSBDT05URU5ULjwvcD4KKworPGgzPkFwcGxpY2FibGUgTGljZW5zZXM8L2gzPgorCis8cD5Vbmxlc3Mgb3RoZXJ3aXNlIGluZGljYXRlZCwgYWxsIENvbnRlbnQgbWFkZSBhdmFpbGFibGUgYnkgdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBpcyBwcm92aWRlZCB0byB5b3UgdW5kZXIgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wCisgICAoJnF1b3Q7RVBMJnF1b3Q7KS4gIEEgY29weSBvZiB0aGUgRVBMIGlzIHByb3ZpZGVkIHdpdGggdGhpcyBDb250ZW50IGFuZCBpcyBhbHNvIGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCI+aHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWw8L2E+LgorICAgRm9yIHB1cnBvc2VzIG9mIHRoZSBFUEwsICZxdW90O1Byb2dyYW0mcXVvdDsgd2lsbCBtZWFuIHRoZSBDb250ZW50LjwvcD4KKworPHA+Q29udGVudCBpbmNsdWRlcywgYnV0IGlzIG5vdCBsaW1pdGVkIHRvLCBzb3VyY2UgY29kZSwgb2JqZWN0IGNvZGUsIGRvY3VtZW50YXRpb24gYW5kIG90aGVyIGZpbGVzIG1haW50YWluZWQgaW4gdGhlIEVjbGlwc2UgRm91bmRhdGlvbiBzb3VyY2UgY29kZQorICAgcmVwb3NpdG9yeSAoJnF1b3Q7UmVwb3NpdG9yeSZxdW90OykgaW4gc29mdHdhcmUgbW9kdWxlcyAoJnF1b3Q7TW9kdWxlcyZxdW90OykgYW5kIG1hZGUgYXZhaWxhYmxlIGFzIGRvd25sb2FkYWJsZSBhcmNoaXZlcyAoJnF1b3Q7RG93bmxvYWRzJnF1b3Q7KS48L3A+CisKKzx1bD4KKyAgICAgICA8bGk+Q29udGVudCBtYXkgYmUgc3RydWN0dXJlZCBhbmQgcGFja2FnZWQgaW50byBtb2R1bGVzIHRvIGZhY2lsaXRhdGUgZGVsaXZlcmluZywgZXh0ZW5kaW5nLCBhbmQgdXBncmFkaW5nIHRoZSBDb250ZW50LiAgVHlwaWNhbCBtb2R1bGVzIG1heSBpbmNsdWRlIHBsdWctaW5zICgmcXVvdDtQbHVnLWlucyZxdW90OyksIHBsdWctaW4gZnJhZ21lbnRzICgmcXVvdDtGcmFnbWVudHMmcXVvdDspLCBhbmQgZmVhdHVyZXMgKCZxdW90O0ZlYXR1cmVzJnF1b3Q7KS48L2xpPgorICAgICAgIDxsaT5FYWNoIFBsdWctaW4gb3IgRnJhZ21lbnQgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBvciBKQVIgKEphdmEmdHJhZGU7IEFSY2hpdmUpIGluIGEgZGlyZWN0b3J5IG5hbWVkICZxdW90O3BsdWdpbnMmcXVvdDsuPC9saT4KKyAgICAgICA8bGk+QSBGZWF0dXJlIGlzIGEgYnVuZGxlIG9mIG9uZSBvciBtb3JlIFBsdWctaW5zIGFuZC9vciBGcmFnbWVudHMgYW5kIGFzc29jaWF0ZWQgbWF0ZXJpYWwuICBFYWNoIEZlYXR1cmUgbWF5IGJlIHBhY2thZ2VkIGFzIGEgc3ViLWRpcmVjdG9yeSBpbiBhIGRpcmVjdG9yeSBuYW1lZCAmcXVvdDtmZWF0dXJlcyZxdW90Oy4gIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUueG1sJnF1b3Q7IG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiB0aGUgUGx1Zy1pbnMKKyAgICAgIGFuZC9vciBGcmFnbWVudHMgYXNzb2NpYXRlZCB3aXRoIHRoYXQgRmVhdHVyZS48L2xpPgorICAgICAgIDxsaT5GZWF0dXJlcyBtYXkgYWxzbyBpbmNsdWRlIG90aGVyIEZlYXR1cmVzICgmcXVvdDtJbmNsdWRlZCBGZWF0dXJlcyZxdW90OykuIFdpdGhpbiBhIEZlYXR1cmUsIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUueG1sJnF1b3Q7IG1heSBjb250YWluIGEgbGlzdCBvZiB0aGUgbmFtZXMgYW5kIHZlcnNpb24gbnVtYmVycyBvZiBJbmNsdWRlZCBGZWF0dXJlcy48L2xpPgorPC91bD4KKworPHA+VGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBQbHVnLWlucyBhbmQgRnJhZ21lbnRzIHNob3VsZCBiZSBjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgJnF1b3Q7YWJvdXQuaHRtbCZxdW90OyAoJnF1b3Q7QWJvdXRzJnF1b3Q7KS4gVGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIGdvdmVybmluZyBGZWF0dXJlcyBhbmQKK0luY2x1ZGVkIEZlYXR1cmVzIHNob3VsZCBiZSBjb250YWluZWQgaW4gZmlsZXMgbmFtZWQgJnF1b3Q7bGljZW5zZS5odG1sJnF1b3Q7ICgmcXVvdDtGZWF0dXJlIExpY2Vuc2VzJnF1b3Q7KS4gIEFib3V0cyBhbmQgRmVhdHVyZSBMaWNlbnNlcyBtYXkgYmUgbG9jYXRlZCBpbiBhbnkgZGlyZWN0b3J5IG9mIGEgRG93bmxvYWQgb3IgTW9kdWxlCitpbmNsdWRpbmcsIGJ1dCBub3QgbGltaXRlZCB0byB0aGUgZm9sbG93aW5nIGxvY2F0aW9uczo8L3A+CisKKzx1bD4KKyAgICAgICA8bGk+VGhlIHRvcC1sZXZlbCAocm9vdCkgZGlyZWN0b3J5PC9saT4KKyAgICAgICA8bGk+UGx1Zy1pbiBhbmQgRnJhZ21lbnQgZGlyZWN0b3JpZXM8L2xpPgorICAgICAgIDxsaT5JbnNpZGUgUGx1Zy1pbnMgYW5kIEZyYWdtZW50cyBwYWNrYWdlZCBhcyBKQVJzPC9saT4KKyAgICAgICA8bGk+U3ViLWRpcmVjdG9yaWVzIG9mIHRoZSBkaXJlY3RvcnkgbmFtZWQgJnF1b3Q7c3JjJnF1b3Q7IG9mIGNlcnRhaW4gUGx1Zy1pbnM8L2xpPgorICAgICAgIDxsaT5GZWF0dXJlIGRpcmVjdG9yaWVzPC9saT4KKzwvdWw+CisKKzxwPk5vdGU6IGlmIGEgRmVhdHVyZSBtYWRlIGF2YWlsYWJsZSBieSB0aGUgRWNsaXBzZSBGb3VuZGF0aW9uIGlzIGluc3RhbGxlZCB1c2luZyB0aGUgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgKGFzIGRlZmluZWQgYmVsb3cpLCB5b3UgbXVzdCBhZ3JlZSB0byBhIGxpY2Vuc2UgKCZxdW90O0ZlYXR1cmUgVXBkYXRlIExpY2Vuc2UmcXVvdDspIGR1cmluZyB0aGUKK2luc3RhbGxhdGlvbiBwcm9jZXNzLiAgSWYgdGhlIEZlYXR1cmUgY29udGFpbnMgSW5jbHVkZWQgRmVhdHVyZXMsIHRoZSBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlIHNob3VsZCBlaXRoZXIgcHJvdmlkZSB5b3Ugd2l0aCB0aGUgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuaW5nIHRoZSBJbmNsdWRlZCBGZWF0dXJlcyBvcgoraW5mb3JtIHlvdSB3aGVyZSB5b3UgY2FuIGxvY2F0ZSB0aGVtLiAgRmVhdHVyZSBVcGRhdGUgTGljZW5zZXMgbWF5IGJlIGZvdW5kIGluIHRoZSAmcXVvdDtsaWNlbnNlJnF1b3Q7IHByb3BlcnR5IG9mIGZpbGVzIG5hbWVkICZxdW90O2ZlYXR1cmUucHJvcGVydGllcyZxdW90OyBmb3VuZCB3aXRoaW4gYSBGZWF0dXJlLgorU3VjaCBBYm91dHMsIEZlYXR1cmUgTGljZW5zZXMsIGFuZCBGZWF0dXJlIFVwZGF0ZSBMaWNlbnNlcyBjb250YWluIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyAob3IgcmVmZXJlbmNlcyB0byBzdWNoIHRlcm1zIGFuZCBjb25kaXRpb25zKSB0aGF0IGdvdmVybiB5b3VyIHVzZSBvZiB0aGUgYXNzb2NpYXRlZCBDb250ZW50IGluCit0aGF0IGRpcmVjdG9yeS48L3A+CisKKzxwPlRIRSBBQk9VVFMsIEZFQVRVUkUgTElDRU5TRVMsIEFORCBGRUFUVVJFIFVQREFURSBMSUNFTlNFUyBNQVkgUkVGRVIgVE8gVEhFIEVQTCBPUiBPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMsIE5PVElDRVMgT1IgVEVSTVMgQU5EIENPTkRJVElPTlMuICBTT01FIE9GIFRIRVNFCitPVEhFUiBMSUNFTlNFIEFHUkVFTUVOVFMgTUFZIElOQ0xVREUgKEJVVCBBUkUgTk9UIExJTUlURUQgVE8pOjwvcD4KKworPHVsPgorICAgICAgIDxsaT5FY2xpcHNlIERpc3RyaWJ1dGlvbiBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9saWNlbnNlcy9lZGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGljZW5zZXMvZWRsLXYxLjAuaHRtbDwvYT4pPC9saT4KKyAgICAgICA8bGk+Q29tbW9uIFB1YmxpYyBMaWNlbnNlIFZlcnNpb24gMS4wIChhdmFpbGFibGUgYXQgPGEgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9jcGwtdjEwLmh0bWwiPmh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvY3BsLXYxMC5odG1sPC9hPik8L2xpPgorICAgICAgIDxsaT5BcGFjaGUgU29mdHdhcmUgTGljZW5zZSAxLjEgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3LmFwYWNoZS5vcmcvbGljZW5zZXMvTElDRU5TRSI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0U8L2E+KTwvbGk+CisgICAgICAgPGxpPkFwYWNoZSBTb2Z0d2FyZSBMaWNlbnNlIDIuMCAoYXZhaWxhYmxlIGF0IDxhIGhyZWY9Imh0dHA6Ly93d3cuYXBhY2hlLm9yZy9saWNlbnNlcy9MSUNFTlNFLTIuMCI+aHR0cDovL3d3dy5hcGFjaGUub3JnL2xpY2Vuc2VzL0xJQ0VOU0UtMi4wPC9hPik8L2xpPgorICAgICAgIDxsaT5NZXRybyBMaW5rIFB1YmxpYyBMaWNlbnNlIDEuMDAgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3Lm9wZW5ncm91cC5vcmcvb3Blbm1vdGlmL3N1cHBvcnRlcnMvbWV0cm9saW5rL2xpY2Vuc2UuaHRtbCI+aHR0cDovL3d3dy5vcGVuZ3JvdXAub3JnL29wZW5tb3RpZi9zdXBwb3J0ZXJzL21ldHJvbGluay9saWNlbnNlLmh0bWw8L2E+KTwvbGk+CisgICAgICAgPGxpPk1vemlsbGEgUHVibGljIExpY2Vuc2UgVmVyc2lvbiAxLjEgKGF2YWlsYWJsZSBhdCA8YSBocmVmPSJodHRwOi8vd3d3Lm1vemlsbGEub3JnL01QTC9NUEwtMS4xLmh0bWwiPmh0dHA6Ly93d3cubW96aWxsYS5vcmcvTVBML01QTC0xLjEuaHRtbDwvYT4pPC9saT4KKzwvdWw+CisKKzxwPklUIElTIFlPVVIgT0JMSUdBVElPTiBUTyBSRUFEIEFORCBBQ0NFUFQgQUxMIFNVQ0ggVEVSTVMgQU5EIENPTkRJVElPTlMgUFJJT1IgVE8gVVNFIE9GIFRIRSBDT05URU5ULiAgSWYgbm8gQWJvdXQsIEZlYXR1cmUgTGljZW5zZSwgb3IgRmVhdHVyZSBVcGRhdGUgTGljZW5zZSBpcyBwcm92aWRlZCwgcGxlYXNlCitjb250YWN0IHRoZSBFY2xpcHNlIEZvdW5kYXRpb24gdG8gZGV0ZXJtaW5lIHdoYXQgdGVybXMgYW5kIGNvbmRpdGlvbnMgZ292ZXJuIHRoYXQgcGFydGljdWxhciBDb250ZW50LjwvcD4KKworCis8aDM+VXNlIG9mIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5PC9oMz4KKworPHA+VGhlIEVjbGlwc2UgRm91bmRhdGlvbiBtYWtlcyBhdmFpbGFibGUgcHJvdmlzaW9uaW5nIHNvZnR3YXJlLCBleGFtcGxlcyBvZiB3aGljaCBpbmNsdWRlLCBidXQgYXJlIG5vdCBsaW1pdGVkIHRvLCBwMiBhbmQgdGhlIEVjbGlwc2UKKyAgIFVwZGF0ZSBNYW5hZ2VyICgmcXVvdDtQcm92aXNpb25pbmcgVGVjaG5vbG9neSZxdW90OykgZm9yIHRoZSBwdXJwb3NlIG9mIGFsbG93aW5nIHVzZXJzIHRvIGluc3RhbGwgc29mdHdhcmUsIGRvY3VtZW50YXRpb24sIGluZm9ybWF0aW9uIGFuZC9vcgorICAgb3RoZXIgbWF0ZXJpYWxzIChjb2xsZWN0aXZlbHkgJnF1b3Q7SW5zdGFsbGFibGUgU29mdHdhcmUmcXVvdDspLiBUaGlzIGNhcGFiaWxpdHkgaXMgcHJvdmlkZWQgd2l0aCB0aGUgaW50ZW50IG9mIGFsbG93aW5nIHN1Y2ggdXNlcnMgdG8KKyAgIGluc3RhbGwsIGV4dGVuZCBhbmQgdXBkYXRlIEVjbGlwc2UtYmFzZWQgcHJvZHVjdHMuIEluZm9ybWF0aW9uIGFib3V0IHBhY2thZ2luZyBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBpcyBhdmFpbGFibGUgYXQgPGEKKyAgICAgICBocmVmPSJodHRwOi8vZWNsaXBzZS5vcmcvZXF1aW5veC9wMi9yZXBvc2l0b3J5X3BhY2thZ2luZy5odG1sIj5odHRwOi8vZWNsaXBzZS5vcmcvZXF1aW5veC9wMi9yZXBvc2l0b3J5X3BhY2thZ2luZy5odG1sPC9hPgorICAgKCZxdW90O1NwZWNpZmljYXRpb24mcXVvdDspLjwvcD4KKworPHA+WW91IG1heSB1c2UgUHJvdmlzaW9uaW5nIFRlY2hub2xvZ3kgdG8gYWxsb3cgb3RoZXIgcGFydGllcyB0byBpbnN0YWxsIEluc3RhbGxhYmxlIFNvZnR3YXJlLiBZb3Ugc2hhbGwgYmUgcmVzcG9uc2libGUgZm9yIGVuYWJsaW5nIHRoZQorICAgYXBwbGljYWJsZSBsaWNlbnNlIGFncmVlbWVudHMgcmVsYXRpbmcgdG8gdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlIHRvIGJlIHByZXNlbnRlZCB0bywgYW5kIGFjY2VwdGVkIGJ5LCB0aGUgdXNlcnMgb2YgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5CisgICBpbiBhY2NvcmRhbmNlIHdpdGggdGhlIFNwZWNpZmljYXRpb24uIEJ5IHVzaW5nIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IGluIHN1Y2ggYSBtYW5uZXIgYW5kIG1ha2luZyBpdCBhdmFpbGFibGUgaW4gYWNjb3JkYW5jZSB3aXRoIHRoZQorICAgU3BlY2lmaWNhdGlvbiwgeW91IGZ1cnRoZXIgYWNrbm93bGVkZ2UgeW91ciBhZ3JlZW1lbnQgdG8sIGFuZCB0aGUgYWNxdWlzaXRpb24gb2YgYWxsIG5lY2Vzc2FyeSByaWdodHMgdG8gcGVybWl0IHRoZSBmb2xsb3dpbmc6PC9wPgorCis8b2w+CisgICAgICAgPGxpPkEgc2VyaWVzIG9mIGFjdGlvbnMgbWF5IG9jY3VyICgmcXVvdDtQcm92aXNpb25pbmcgUHJvY2VzcyZxdW90OykgaW4gd2hpY2ggYSB1c2VyIG1heSBleGVjdXRlIHRoZSBQcm92aXNpb25pbmcgVGVjaG5vbG9neQorICAgICAgIG9uIGEgbWFjaGluZSAoJnF1b3Q7VGFyZ2V0IE1hY2hpbmUmcXVvdDspIHdpdGggdGhlIGludGVudCBvZiBpbnN0YWxsaW5nLCBleHRlbmRpbmcgb3IgdXBkYXRpbmcgdGhlIGZ1bmN0aW9uYWxpdHkgb2YgYW4gRWNsaXBzZS1iYXNlZAorICAgICAgIHByb2R1Y3QuPC9saT4KKyAgICAgICA8bGk+RHVyaW5nIHRoZSBQcm92aXNpb25pbmcgUHJvY2VzcywgdGhlIFByb3Zpc2lvbmluZyBUZWNobm9sb2d5IG1heSBjYXVzZSB0aGlyZCBwYXJ0eSBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBvciBhIHBvcnRpb24gdGhlcmVvZiB0byBiZQorICAgICAgIGFjY2Vzc2VkIGFuZCBjb3BpZWQgdG8gdGhlIFRhcmdldCBNYWNoaW5lLjwvbGk+CisgICAgICAgPGxpPlB1cnN1YW50IHRvIHRoZSBTcGVjaWZpY2F0aW9uLCB5b3Ugd2lsbCBwcm92aWRlIHRvIHRoZSB1c2VyIHRoZSB0ZXJtcyBhbmQgY29uZGl0aW9ucyB0aGF0IGdvdmVybiB0aGUgdXNlIG9mIHRoZSBJbnN0YWxsYWJsZQorICAgICAgIFNvZnR3YXJlICgmcXVvdDtJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQmcXVvdDspIGFuZCBzdWNoIEluc3RhbGxhYmxlIFNvZnR3YXJlIEFncmVlbWVudCBzaGFsbCBiZSBhY2Nlc3NlZCBmcm9tIHRoZSBUYXJnZXQKKyAgICAgICBNYWNoaW5lIGluIGFjY29yZGFuY2Ugd2l0aCB0aGUgU3BlY2lmaWNhdGlvbi4gU3VjaCBJbnN0YWxsYWJsZSBTb2Z0d2FyZSBBZ3JlZW1lbnQgbXVzdCBpbmZvcm0gdGhlIHVzZXIgb2YgdGhlIHRlcm1zIGFuZCBjb25kaXRpb25zIHRoYXQgZ292ZXJuCisgICAgICAgdGhlIEluc3RhbGxhYmxlIFNvZnR3YXJlIGFuZCBtdXN0IHNvbGljaXQgYWNjZXB0YW5jZSBieSB0aGUgZW5kIHVzZXIgaW4gdGhlIG1hbm5lciBwcmVzY3JpYmVkIGluIHN1Y2ggSW5zdGFsbGFibGUgU29mdHdhcmUgQWdyZWVtZW50LiBVcG9uIHN1Y2gKKyAgICAgICBpbmRpY2F0aW9uIG9mIGFncmVlbWVudCBieSB0aGUgdXNlciwgdGhlIHByb3Zpc2lvbmluZyBUZWNobm9sb2d5IHdpbGwgY29tcGxldGUgaW5zdGFsbGF0aW9uIG9mIHRoZSBJbnN0YWxsYWJsZSBTb2Z0d2FyZS48L2xpPgorPC9vbD4KKworPGgzPkNyeXB0b2dyYXBoeTwvaDM+CisKKzxwPkNvbnRlbnQgbWF5IGNvbnRhaW4gZW5jcnlwdGlvbiBzb2Z0d2FyZS4gVGhlIGNvdW50cnkgaW4gd2hpY2ggeW91IGFyZSBjdXJyZW50bHkgbWF5IGhhdmUgcmVzdHJpY3Rpb25zIG9uIHRoZSBpbXBvcnQsIHBvc3Nlc3Npb24sIGFuZCB1c2UsIGFuZC9vciByZS1leHBvcnQgdG8KKyAgIGFub3RoZXIgY291bnRyeSwgb2YgZW5jcnlwdGlvbiBzb2Z0d2FyZS4gQkVGT1JFIHVzaW5nIGFueSBlbmNyeXB0aW9uIHNvZnR3YXJlLCBwbGVhc2UgY2hlY2sgdGhlIGNvdW50cnkncyBsYXdzLCByZWd1bGF0aW9ucyBhbmQgcG9saWNpZXMgY29uY2VybmluZyB0aGUgaW1wb3J0LAorICAgcG9zc2Vzc2lvbiwgb3IgdXNlLCBhbmQgcmUtZXhwb3J0IG9mIGVuY3J5cHRpb24gc29mdHdhcmUsIHRvIHNlZSBpZiB0aGlzIGlzIHBlcm1pdHRlZC48L3A+CisKKzxwPjxzbWFsbD5KYXZhIGFuZCBhbGwgSmF2YS1iYXNlZCB0cmFkZW1hcmtzIGFyZSB0cmFkZW1hcmtzIG9mIE9yYWNsZSBDb3Jwb3JhdGlvbiBpbiB0aGUgVW5pdGVkIFN0YXRlcywgb3RoZXIgY291bnRyaWVzLCBvciBib3RoLjwvc21hbGw+PC9wPgorPC9ib2R5PgorPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci9wbHVnaW4ueG1sIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL3BsdWdpbi54bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uODBlODUwMgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci9wbHVnaW4ueG1sCkBAIC0wLDAgKzEsMjUgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8P2VjbGlwc2UgdmVyc2lvbj0iMy40Ij8+Cis8cGx1Z2luPgorICAgPGV4dGVuc2lvbgorICAgICAgICAgaWQ9ImFwcCIKKyAgICAgICAgIHBvaW50PSJvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuYXBwbGljYXRpb25zIj4KKyAgICAgIDxhcHBsaWNhdGlvbgorICAgICAgICAgICAgY2FyZGluYWxpdHk9IioiCisgICAgICAgICAgICB0aHJlYWQ9ImFueSIKKyAgICAgICAgICAgIHZpc2libGU9InRydWUiPgorICAgICAgICAgPHJ1bgorICAgICAgICAgICAgICAgY2xhc3M9Im9yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5QMk1pcnJvckFwcGxpY2F0aW9uIj4KKyAgICAgICAgIDwvcnVuPgorICAgICAgPC9hcHBsaWNhdGlvbj4KKyAgIDwvZXh0ZW5zaW9uPgorICAgPGV4dGVuc2lvbgorICAgICAgICAgaWQ9Im9yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5wcm9kdWN0IgorICAgICAgICAgcG9pbnQ9Im9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5wcm9kdWN0cyI+CisgICAgICA8cHJvZHVjdAorICAgICAgICAgICAgYXBwbGljYXRpb249Im9yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci5hcHAiCisgICAgICAgICAgICBuYW1lPSJtaXJyb3JQcm9kdWN0Ij4KKyAgICAgIDwvcHJvZHVjdD4KKyAgIDwvZXh0ZW5zaW9uPgorCis8L3BsdWdpbj4KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci9wb20ueG1sIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL3BvbS54bWwKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNTcxM2E4ZgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci9wb20ueG1sCkBAIC0wLDAgKzEsMjMgQEAKKzw/eG1sIHZlcnNpb249IjEuMCIgZW5jb2Rpbmc9IlVURi04Ij8+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorPCEtLSMgQ29weXJpZ2h0IChjKSAyMDExLCAyMDE2IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpIC0tPgorPCEtLSMgQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscyAtLT4KKzwhLS0jIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMCAtLT4KKzwhLS0jIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0IC0tPgorPCEtLSMgaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwgLS0+Cis8IS0tIyAtLT4KKzwhLS0jIENvbnRyaWJ1dG9yczogLS0+Cis8IS0tIyAgICAgS2xlbWVucyBFZGxlciAoTHVuaWZlcmEgR21iSCkgLSBpbml0aWFsIEFQSSBhbmQgaW1wbGVtZW50YXRpb24gLS0+Cis8IS0tIz09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09IC0tPgorCis8cHJvamVjdCB4bWxucz0iaHR0cDovL21hdmVuLmFwYWNoZS5vcmcvUE9NLzQuMC4wIiB4bWxuczp4c2k9Imh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hLWluc3RhbmNlIiB4c2k6c2NoZW1hTG9jYXRpb249Imh0dHA6Ly9tYXZlbi5hcGFjaGUub3JnL1BPTS80LjAuMCBodHRwOi8vbWF2ZW4uYXBhY2hlLm9yZy94c2QvbWF2ZW4tNC4wLjAueHNkIj4KKyAgICA8bW9kZWxWZXJzaW9uPjQuMC4wPC9tb2RlbFZlcnNpb24+CisgICAgPHBhcmVudD4KKyAgICAgICAgPGdyb3VwSWQ+b3JnLmVjbGlwc2Uub3NicC5pZGU8L2dyb3VwSWQ+CisgICAgICAgIDxhcnRpZmFjdElkPm9yZy5lY2xpcHNlLm9zYnAuaWRlPC9hcnRpZmFjdElkPgorICAgICAgICA8dmVyc2lvbj4wLjkuMC1TTkFQU0hPVDwvdmVyc2lvbj4KKyAgICA8L3BhcmVudD4KKyAgICA8YXJ0aWZhY3RJZD5vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3I8L2FydGlmYWN0SWQ+CisgICAgPHBhY2thZ2luZz5lY2xpcHNlLXBsdWdpbjwvcGFja2FnaW5nPgorCis8L3Byb2plY3Q+CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3Ivc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL3Rvb2xzL3AyL21pcnJvci9Db25zb2xlQ29tbWFuZHMuamF2YSBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvdG9vbHMvcDIvbWlycm9yL0NvbnNvbGVDb21tYW5kcy5qYXZhCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmNjZTFjOTAKLS0tIC9kZXYvbnVsbAorKysgYi9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3Ivc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL3Rvb2xzL3AyL21pcnJvci9Db25zb2xlQ29tbWFuZHMuamF2YQpAQCAtMCwwICsxLDI2MCBAQAorLyoqCisgKiBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTUgLSBMdW5pZmVyYSBHbWJIIChHcm9zcyBFbnplcnNkb3JmLCBBdXN0cmlhKSwgTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkKKyAqIEFsbCByaWdodHMgcmVzZXJ2ZWQuIFRoaXMgcHJvZ3JhbSBhbmQgdGhlIGFjY29tcGFueWluZyBtYXRlcmlhbHMKKyAqIGFyZSBtYWRlIGF2YWlsYWJsZSB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEVjbGlwc2UgUHVibGljIExpY2Vuc2UgdjEuMAorICogd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQKKyAqIGh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvbGVnYWwvZXBsLXYxMC5odG1sCisgKgorICogQ29udHJpYnV0b3JzOgorICogICAgICAgICBGbG9yaWFuIFBpcmNobmVyIC0gSW5pdGlhbCBpbXBsZW1lbnRhdGlvbgorICovCisKK3BhY2thZ2Ugb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yOworCitpbXBvcnQgamF2YS5pby5CdWZmZXJlZFJlYWRlcjsKK2ltcG9ydCBqYXZhLmlvLkZpbGU7CitpbXBvcnQgamF2YS5pby5GaWxlSW5wdXRTdHJlYW07CitpbXBvcnQgamF2YS5pby5GaWxlTm90Rm91bmRFeGNlcHRpb247CitpbXBvcnQgamF2YS5pby5GaWxlV3JpdGVyOworaW1wb3J0IGphdmEuaW8uSU9FeGNlcHRpb247CitpbXBvcnQgamF2YS5pby5JbnB1dFN0cmVhbTsKK2ltcG9ydCBqYXZhLmlvLklucHV0U3RyZWFtUmVhZGVyOworaW1wb3J0IGphdmEudXRpbC5IYXNoTWFwOworaW1wb3J0IGphdmEudXRpbC5IYXNoU2V0OworaW1wb3J0IGphdmEudXRpbC5NYXA7CitpbXBvcnQgamF2YS51dGlsLlNldDsKKworaW1wb3J0IG9yZy5lY2xpcHNlLmVxdWlub3guYXBwLklBcHBsaWNhdGlvbkNvbnRleHQ7CitpbXBvcnQgb3JnLmVjbGlwc2UuZXF1aW5veC5wMi5pbnRlcm5hbC5yZXBvc2l0b3J5LnRvb2xzLk1pcnJvckFwcGxpY2F0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLm9zZ2kuZnJhbWV3b3JrLmNvbnNvbGUuQ29tbWFuZEludGVycHJldGVyOworaW1wb3J0IG9yZy5vc2dpLnNlcnZpY2UuYXBwbGljYXRpb24uQXBwbGljYXRpb25EZXNjcmlwdG9yOworaW1wb3J0IG9yZy5vc2dpLnNlcnZpY2UuY29tcG9uZW50LkNvbXBvbmVudENvbnRleHQ7CitpbXBvcnQgb3JnLm9zZ2kuc2VydmljZS5jb21wb25lbnQuYW5ub3RhdGlvbnMuQWN0aXZhdGU7CitpbXBvcnQgb3JnLm9zZ2kuc2VydmljZS5jb21wb25lbnQuYW5ub3RhdGlvbnMuQ29tcG9uZW50OworaW1wb3J0IG9yZy5vc2dpLnNlcnZpY2UuY29tcG9uZW50LmFubm90YXRpb25zLkRlYWN0aXZhdGU7CitpbXBvcnQgb3JnLm9zZ2kuc2VydmljZS5jb21wb25lbnQuYW5ub3RhdGlvbnMuUmVmZXJlbmNlOworaW1wb3J0IG9yZy5vc2dpLnNlcnZpY2UuY29tcG9uZW50LmFubm90YXRpb25zLlJlZmVyZW5jZUNhcmRpbmFsaXR5OworCitAQ29tcG9uZW50CitwdWJsaWMgY2xhc3MgQ29uc29sZUNvbW1hbmRzIGltcGxlbWVudHMKKwkJb3JnLmVjbGlwc2Uub3NnaS5mcmFtZXdvcmsuY29uc29sZS5Db21tYW5kUHJvdmlkZXIgeworCisJcHJpdmF0ZSBDb21wb25lbnRDb250ZXh0IGNvbnRleHQ7CisJcHJpdmF0ZSBTZXQ8TWlycm9yPiBtaXJyb3JzID0gbmV3IEhhc2hTZXQ8Q29uc29sZUNvbW1hbmRzLk1pcnJvcj4oKTsKKwlwcml2YXRlIEFwcGxpY2F0aW9uRGVzY3JpcHRvciBhcnRpZmFjdHNEZXNjOworCXByaXZhdGUgQXBwbGljYXRpb25EZXNjcmlwdG9yIG1ldGFkYXRhRGVzYzsKKworCUBPdmVycmlkZQorCXB1YmxpYyBTdHJpbmcgZ2V0SGVscCgpIHsKKwkJcmV0dXJuICJPU0JQIFAyIG1pcnJvciBjb21tYW5kcyI7CisJfQorCisJQEFjdGl2YXRlCisJcHJvdGVjdGVkIHZvaWQgYWN0aXZhdGUoQ29tcG9uZW50Q29udGV4dCBjb250ZXh0KSB7CisJCXRoaXMuY29udGV4dCA9IGNvbnRleHQ7CisKKwkJbG9hZE1pcnJvcnMoY29udGV4dCk7CisJfQorCisJQFJlZmVyZW5jZShjYXJkaW5hbGl0eSA9IFJlZmVyZW5jZUNhcmRpbmFsaXR5Lk1BTkRBVE9SWSwgdGFyZ2V0ID0gIihzZXJ2aWNlLnBpZD1vcmcuZWNsaXBzZS5lcXVpbm94LnAyLm1ldGFkYXRhLnJlcG9zaXRvcnkubWlycm9yQXBwbGljYXRpb24pIikKKwlwcm90ZWN0ZWQgdm9pZCBiaW5kTWV0YWRhdGEoQXBwbGljYXRpb25EZXNjcmlwdG9yIG1ldGFkYXRhRGVzYykgeworCQl0aGlzLm1ldGFkYXRhRGVzYyA9IG1ldGFkYXRhRGVzYzsKKwl9CisKKwlAUmVmZXJlbmNlKGNhcmRpbmFsaXR5ID0gUmVmZXJlbmNlQ2FyZGluYWxpdHkuTUFOREFUT1JZLCB0YXJnZXQgPSAiKHNlcnZpY2UucGlkPW9yZy5lY2xpcHNlLmVxdWlub3gucDIuYXJ0aWZhY3QucmVwb3NpdG9yeS5taXJyb3JBcHBsaWNhdGlvbikiKQorCXByb3RlY3RlZCB2b2lkIGJpbmRBcnRpZmFjdHMoQXBwbGljYXRpb25EZXNjcmlwdG9yIGFydGlmYWN0c0Rlc2MpIHsKKwkJdGhpcy5hcnRpZmFjdHNEZXNjID0gYXJ0aWZhY3RzRGVzYzsKKwl9CisKKwkvKioKKwkgKiBMb2FkcyBhbGwgbWlycm9ycy4KKwkgKiAKKwkgKiBAcGFyYW0gY29udGV4dAorCSAqLworCXByaXZhdGUgdm9pZCBsb2FkTWlycm9ycyhDb21wb25lbnRDb250ZXh0IGNvbnRleHQpIHsKKwkJdHJ5IHsKKwkJCUZpbGUgc2V0dGluZ3MgPSBjb250ZXh0LmdldEJ1bmRsZUNvbnRleHQoKS5nZXREYXRhRmlsZSgKKwkJCQkJImx1bnAybWlycm9ycyIpOworCQkJaWYgKCFzZXR0aW5ncy5leGlzdHMoKSkgeworCQkJCXNldHRpbmdzLmNyZWF0ZU5ld0ZpbGUoKTsKKwkJCX0KKworCQkJSW5wdXRTdHJlYW0gaW5wdXRTdHJlYW0gPSBuZXcgRmlsZUlucHV0U3RyZWFtKHNldHRpbmdzKTsKKwkJCUJ1ZmZlcmVkUmVhZGVyIHJlYWRlciA9IG5ldyBCdWZmZXJlZFJlYWRlcihuZXcgSW5wdXRTdHJlYW1SZWFkZXIoCisJCQkJCWlucHV0U3RyZWFtKSk7CisJCQlTdHJpbmcgbGluZSA9IG51bGw7CisJCQkvLyBSZWFkIGZpbGUgbGluZSBieSBsaW5lCisJCQl3aGlsZSAoKGxpbmUgPSByZWFkZXIucmVhZExpbmUoKSkgIT0gbnVsbCkgeworCQkJCW1pcnJvcnMuYWRkKE1pcnJvci5wYXJzZShsaW5lKSk7CisJCQl9CisJCQlyZWFkZXIuY2xvc2UoKTsKKwkJfSBjYXRjaCAoRmlsZU5vdEZvdW5kRXhjZXB0aW9uIGUpIHsKKwkJCWUucHJpbnRTdGFja1RyYWNlKCk7CisJCX0gY2F0Y2ggKElPRXhjZXB0aW9uIGUpIHsKKwkJCWUucHJpbnRTdGFja1RyYWNlKCk7CisJCX0KKwl9CisKKwlARGVhY3RpdmF0ZQorCXByb3RlY3RlZCB2b2lkIGRlYWN0aXZhdGUoQ29tcG9uZW50Q29udGV4dCBjb250ZXh0KSB7CisJCXRoaXMuY29udGV4dCA9IG51bGw7CisJfQorCisJcHVibGljIHZvaWQgX2x1bnAybWlycm9yKGZpbmFsIENvbW1hbmRJbnRlcnByZXRlciBjaSkgdGhyb3dzIEV4Y2VwdGlvbiB7CisJCVN0cmluZyBhcmd1bWVudCA9IGNpLm5leHRBcmd1bWVudCgpOworCQlpZiAoYXJndW1lbnQgPT0gbnVsbCkgeworCQkJY2kucHJpbnRsbihnZXRIZWxwKCkpOworCQl9IGVsc2UgaWYgKGFyZ3VtZW50LmVxdWFscygibHMiKSkgeworCQkJcHJpbnRNaXJyb3JzKGNpKTsKKwkJfSBlbHNlIGlmIChhcmd1bWVudC5lcXVhbHMoImFkZCIpKSB7CisJCQlhZGRNaXJyb3IoY2kpOworCQl9IGVsc2UgaWYgKGFyZ3VtZW50LmVxdWFscygidXBkYXRlIikpIHsKKwkJCXVwZGF0ZShjaSk7CisJCX0gZWxzZSB7CisJCQljaS5wcmludGxuKCJFUlJPUiAtIG5vdCBhIHZhbGlkIGNvbW1hbmQhIik7CisJCQljaS5wcmludGxuKGdldEhlbHAoKSk7CisJCX0KKwl9CisKKwkvLyBsdW5wMm1pcnJvciBhZGQgb3NicFAyIGh0dHA6Ly8uLi4uY29tCisJcHJpdmF0ZSB2b2lkIGFkZE1pcnJvcihDb21tYW5kSW50ZXJwcmV0ZXIgY2kpIHsKKworCQlTdHJpbmcgaWQgPSBjaS5uZXh0QXJndW1lbnQoKTsKKwkJaWYgKGlkID09IG51bGwpIHsKKwkJCWNpLnByaW50bG4oIlx0RVJST1I6IE5vIGlkIHNwZWNpZmllZCEiKTsKKwkJCXJldHVybjsKKwkJfQorCisJCVN0cmluZyB1cmwgPSBjaS5uZXh0QXJndW1lbnQoKTsKKwkJaWYgKHVybCA9PSBudWxsKSB7CisJCQljaS5wcmludGxuKCJcdEVSUk9SOiBObyBVUkwgc3BlY2lmaWVkISIpOworCQkJcmV0dXJuOworCQl9CisKKwkJU3RyaW5nIGRlc3RpbmF0aW9uID0gY2kubmV4dEFyZ3VtZW50KCk7CisJCWlmIChkZXN0aW5hdGlvbiA9PSBudWxsKSB7CisJCQljaS5wcmludGxuKCJcdEVSUk9SOiBObyBkZXN0aW5hdGlvbiBzcGVjaWZpZWQhIik7CisJCQlyZXR1cm47CisJCX0KKworCQlNaXJyb3IgbmV3TWlycm9yID0gbmV3IE1pcnJvcihpZCwgdXJsLCBkZXN0aW5hdGlvbik7CisJCW1pcnJvcnMuYWRkKG5ld01pcnJvcik7CisKKwkJc2F2ZUZpbGUoKTsKKworCX0KKworCXByaXZhdGUgdm9pZCBzYXZlRmlsZSgpIHsKKwkJU3RyaW5nQnVpbGRlciBiID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKKwkJZm9yIChNaXJyb3IgbWlycm9yIDogbWlycm9ycykgeworCQkJYi5hcHBlbmQobWlycm9yLnRvU3RyaW5nKCkpOworCQkJYi5hcHBlbmQoIlxuIik7CisJCX0KKworCQl0cnkgeworCQkJRmlsZSBzZXR0aW5ncyA9IGNvbnRleHQuZ2V0QnVuZGxlQ29udGV4dCgpLmdldERhdGFGaWxlKAorCQkJCQkibHVucDJtaXJyb3JzIik7CisJCQlGaWxlV3JpdGVyIHdyaXRlciA9IG5ldyBGaWxlV3JpdGVyKHNldHRpbmdzKTsKKwkJCXdyaXRlci5hcHBlbmQoYi50b1N0cmluZygpKTsKKwkJCXdyaXRlci5mbHVzaCgpOworCQkJd3JpdGVyLmNsb3NlKCk7CisJCX0gY2F0Y2ggKEZpbGVOb3RGb3VuZEV4Y2VwdGlvbiBlKSB7CisJCQllLnByaW50U3RhY2tUcmFjZSgpOworCQl9IGNhdGNoIChJT0V4Y2VwdGlvbiBlKSB7CisJCQllLnByaW50U3RhY2tUcmFjZSgpOworCQl9CisJfQorCisJcHJpdmF0ZSB2b2lkIHVwZGF0ZShDb21tYW5kSW50ZXJwcmV0ZXIgY2kpIHsKKwkJU3RyaW5nIGlkID0gY2kubmV4dEFyZ3VtZW50KCk7CisJCWlmIChpZCA9PSBudWxsKSB7CisJCQljaS5wcmludGxuKCJcdEVSUk9SOiBObyBpZCBzcGVjaWZpZWQhIik7CisJCQlyZXR1cm47CisJCX0KKworCQlmb3IgKE1pcnJvciBtaXJyb3IgOiBtaXJyb3JzKSB7CisJCQlpZiAobWlycm9yLmlkLmVxdWFscyhpZCkpIHsKKwkJCQl0cnkgeworCQkJCQlydW4oY2ksIG1pcnJvcik7CisJCQkJfSBjYXRjaCAoRXhjZXB0aW9uIGUpIHsKKwkJCQkJZS5wcmludFN0YWNrVHJhY2UoKTsKKwkJCQl9CisJCQkJYnJlYWs7CisJCQl9CisJCX0KKworCX0KKworCXByaXZhdGUgdm9pZCBwcmludE1pcnJvcnMoQ29tbWFuZEludGVycHJldGVyIGNpKSB7CisKKwkJU3RyaW5nQnVpbGRlciBiID0gbmV3IFN0cmluZ0J1aWxkZXIoKTsKKwkJZm9yIChNaXJyb3IgbWlycm9yIDogbWlycm9ycykgeworCQkJYi5hcHBlbmQoIlx0SWQ6ICIpOworCQkJYi5hcHBlbmQobWlycm9yLmlkKTsKKwkJCWIuYXBwZW5kKCJcdFVSTDogIik7CisJCQliLmFwcGVuZChtaXJyb3IudXJsKTsKKwkJCWIuYXBwZW5kKCJcdERlc3RpbmF0aW9uOiAiKTsKKwkJCWIuYXBwZW5kKG1pcnJvci5kZXN0aW5hdGlvbik7CisJCQliLmFwcGVuZCgiXG4iKTsKKwkJfQorCisJCWNpLnByaW50bG4oIlx0LS0tLSBBdmFpbGFibGUgbWlycm9ycyAtLS0tXG4iKTsKKwkJY2kucHJpbnRsbihiLnRvU3RyaW5nKCkpOworCX0KKworCUBTdXBwcmVzc1dhcm5pbmdzKCJyZXN0cmljdGlvbiIpCisJcHVibGljIHZvaWQgcnVuKENvbW1hbmRJbnRlcnByZXRlciBjaSwgTWlycm9yIG1pcnJvcikgdGhyb3dzIEV4Y2VwdGlvbiB7CisJCXRyeSB7CisJCQkvLyBNYXA8U3RyaW5nLCBPYmplY3Q+IGxhdW5jaEFyZ3MgPSBuZXcgSGFzaE1hcDw+KDEpOworCisJCQlTdHJpbmdbXSBhcmdzID0gbmV3IFN0cmluZ1tdIHsgIi1zb3VyY2UiLCBtaXJyb3IudXJsLAorCQkJCQkiLWRlc3RpbmF0aW9uIiwgbWlycm9yLmRlc3RpbmF0aW9uLCAiLXdyaXRlTW9kZSIsICJjbGVhbiIsICItcmVmZXJlbmNlcyIsICJmYWxzZSIgfTsKKwkJCS8vIGxhdW5jaEFyZ3MucHV0KElBcHBsaWNhdGlvbkNvbnRleHQuQVBQTElDQVRJT05fQVJHUywgYXJncyk7CisKKwkJCUR1bW15QXBwbGljYXRpb25Db250ZXh0IGNvbnRleHQgPSBuZXcgRHVtbXlBcHBsaWNhdGlvbkNvbnRleHQoKTsKKwkJCWNvbnRleHQuZ2V0QXJndW1lbnRzKCkucHV0KElBcHBsaWNhdGlvbkNvbnRleHQuQVBQTElDQVRJT05fQVJHUywKKwkJCQkJYXJncyk7CisJCQlNaXJyb3JBcHBsaWNhdGlvbiBtZXRhZGF0YUFwcGxpY2F0aW9uID0gbmV3IE1pcnJvckFwcGxpY2F0aW9uKCk7CisJCQlNYXA8U3RyaW5nLCBTdHJpbmc+IGluaXRBcmdzID0gbmV3IEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+KDEpOworCQkJaW5pdEFyZ3MucHV0KCJtZXRhZGF0YU9yQXJ0aWZhY3RzIiwgIm1ldGFkYXRhIik7CisJCQltZXRhZGF0YUFwcGxpY2F0aW9uLnNldEluaXRpYWxpemF0aW9uRGF0YShudWxsLCBudWxsLCBpbml0QXJncyk7CisJCQlNaXJyb3JMb2cgbG9nID0gbmV3IE1pcnJvckxvZyhjaSk7CisJCQltZXRhZGF0YUFwcGxpY2F0aW9uLnNldExvZyhsb2cpOworCQkJbWV0YWRhdGFBcHBsaWNhdGlvbi5zdGFydChjb250ZXh0KTsKKworCQkJTWlycm9yQXBwbGljYXRpb24gYXJ0aWZhY3RzQXBwbGljYXRpb24gPSBuZXcgTWlycm9yQXBwbGljYXRpb24oKTsKKwkJCWluaXRBcmdzID0gbmV3IEhhc2hNYXA8U3RyaW5nLCBTdHJpbmc+KDEpOworCQkJaW5pdEFyZ3MucHV0KCJtZXRhZGF0YU9yQXJ0aWZhY3RzIiwgImFydGlmYWN0cyIpOworCQkJYXJ0aWZhY3RzQXBwbGljYXRpb24uc2V0SW5pdGlhbGl6YXRpb25EYXRhKG51bGwsIG51bGwsIGluaXRBcmdzKTsKKwkJCWFydGlmYWN0c0FwcGxpY2F0aW9uLnNldExvZyhsb2cpOworCQkJYXJ0aWZhY3RzQXBwbGljYXRpb24uc3RhcnQoY29udGV4dCk7CisKKwkJfSBmaW5hbGx5IHsKKwkJfQorCQlyZXR1cm47CisJfQorCisJcHJpdmF0ZSBzdGF0aWMgY2xhc3MgTWlycm9yIHsKKwkJcHVibGljIGZpbmFsIFN0cmluZyBpZDsKKwkJcHVibGljIGZpbmFsIFN0cmluZyB1cmw7CisJCXB1YmxpYyBmaW5hbCBTdHJpbmcgZGVzdGluYXRpb247CisKKwkJcHVibGljIE1pcnJvcihTdHJpbmcgaWQsIFN0cmluZyB1cmwsIFN0cmluZyBkZXN0aW5hdGlvbikgeworCQkJc3VwZXIoKTsKKwkJCXRoaXMuaWQgPSBpZDsKKwkJCXRoaXMudXJsID0gdXJsOworCQkJdGhpcy5kZXN0aW5hdGlvbiA9IGRlc3RpbmF0aW9uOworCQl9CisKKwkJcHVibGljIHN0YXRpYyBNaXJyb3IgcGFyc2UoU3RyaW5nIGxpbmUpIHsKKwkJCVN0cmluZ1tdIHRva2VucyA9IGxpbmUuc3BsaXQoIjsiKTsKKwkJCXJldHVybiBuZXcgTWlycm9yKHRva2Vuc1swXSwgdG9rZW5zWzFdLCB0b2tlbnNbMl0pOworCQl9CisKKwkJcHVibGljIFN0cmluZyB0b1N0cmluZygpIHsKKwkJCXJldHVybiBTdHJpbmcuZm9ybWF0KCIlczslczslcyIsIGlkLCB1cmwsIGRlc3RpbmF0aW9uKTsKKwkJfQorCisJfQorCit9CmRpZmYgLS1naXQgYS9vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3Ivc3JjL29yZy9lY2xpcHNlL29zYnAvaWRlL3Rvb2xzL3AyL21pcnJvci9EdW1teUFwcGxpY2F0aW9uQ29udGV4dC5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS90b29scy9wMi9taXJyb3IvRHVtbXlBcHBsaWNhdGlvbkNvbnRleHQuamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4yYzc2NTJjCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS90b29scy9wMi9taXJyb3IvRHVtbXlBcHBsaWNhdGlvbkNvbnRleHQuamF2YQpAQCAtMCwwICsxLDcxIEBACisvKioKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNSAtIEx1bmlmZXJhIEdtYkggKEdyb3NzIEVuemVyc2RvcmYsIEF1c3RyaWEpLCBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscworICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKKyAqCisgKiBDb250cmlidXRvcnM6CisgKiAgICAgICAgIEZsb3JpYW4gUGlyY2huZXIgLSBJbml0aWFsIGltcGxlbWVudGF0aW9uCisgKi8KKworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3I7CisKK2ltcG9ydCBqYXZhLnV0aWwuSGFzaE1hcDsKK2ltcG9ydCBqYXZhLnV0aWwuTWFwOworCitpbXBvcnQgb3JnLmVjbGlwc2UuZXF1aW5veC5hcHAuSUFwcGxpY2F0aW9uOworaW1wb3J0IG9yZy5lY2xpcHNlLmVxdWlub3guYXBwLklBcHBsaWNhdGlvbkNvbnRleHQ7CitpbXBvcnQgb3JnLm9zZ2kuZnJhbWV3b3JrLkJ1bmRsZTsKKworcHVibGljIGNsYXNzIER1bW15QXBwbGljYXRpb25Db250ZXh0IGltcGxlbWVudHMgSUFwcGxpY2F0aW9uQ29udGV4dCB7CisKKwlwcml2YXRlIE1hcDxTdHJpbmcsIE9iamVjdD4gYXJncyA9IG5ldyBIYXNoTWFwPFN0cmluZywgT2JqZWN0PigpOworCisJQE92ZXJyaWRlCisJcHVibGljIE1hcDxTdHJpbmcsIE9iamVjdD4gZ2V0QXJndW1lbnRzKCkgeworCQlyZXR1cm4gYXJnczsKKwl9CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgdm9pZCBhcHBsaWNhdGlvblJ1bm5pbmcoKSB7CisKKwl9CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgU3RyaW5nIGdldEJyYW5kaW5nQXBwbGljYXRpb24oKSB7CisJCXJldHVybiBudWxsOworCX0KKworCUBPdmVycmlkZQorCXB1YmxpYyBTdHJpbmcgZ2V0QnJhbmRpbmdOYW1lKCkgeworCQlyZXR1cm4gbnVsbDsKKwl9CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgU3RyaW5nIGdldEJyYW5kaW5nRGVzY3JpcHRpb24oKSB7CisJCXJldHVybiBudWxsOworCX0KKworCUBPdmVycmlkZQorCXB1YmxpYyBTdHJpbmcgZ2V0QnJhbmRpbmdJZCgpIHsKKwkJcmV0dXJuIG51bGw7CisJfQorCisJQE92ZXJyaWRlCisJcHVibGljIFN0cmluZyBnZXRCcmFuZGluZ1Byb3BlcnR5KFN0cmluZyBrZXkpIHsKKwkJcmV0dXJuIG51bGw7CisJfQorCisJQE92ZXJyaWRlCisJcHVibGljIEJ1bmRsZSBnZXRCcmFuZGluZ0J1bmRsZSgpIHsKKwkJcmV0dXJuIG51bGw7CisJfQorCisJQE92ZXJyaWRlCisJcHVibGljIHZvaWQgc2V0UmVzdWx0KE9iamVjdCByZXN1bHQsIElBcHBsaWNhdGlvbiBhcHBsaWNhdGlvbikgeworCQkvLyBUT0RPIEF1dG8tZ2VuZXJhdGVkIG1ldGhvZCBzdHViCisKKwl9CisKK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvdG9vbHMvcDIvbWlycm9yL01pcnJvckxvZy5qYXZhIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS90b29scy9wMi9taXJyb3IvTWlycm9yTG9nLmphdmEKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMGVlZmM1ZgotLS0gL2Rldi9udWxsCisrKyBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvdG9vbHMvcDIvbWlycm9yL01pcnJvckxvZy5qYXZhCkBAIC0wLDAgKzEsMTA0IEBACisvKioKKyAqIENvcHlyaWdodCAoYykgMjAxMSwgMjAxNSAtIEx1bmlmZXJhIEdtYkggKEdyb3NzIEVuemVyc2RvcmYsIEF1c3RyaWEpLCBMb2V0eiBHbWJIJkNvLktHICg2OTExNSBIZWlkZWxiZXJnLCBHZXJtYW55KQorICogQWxsIHJpZ2h0cyByZXNlcnZlZC4gVGhpcyBwcm9ncmFtIGFuZCB0aGUgYWNjb21wYW55aW5nIG1hdGVyaWFscworICogYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wCisgKiB3aGljaCBhY2NvbXBhbmllcyB0aGlzIGRpc3RyaWJ1dGlvbiwgYW5kIGlzIGF2YWlsYWJsZSBhdAorICogaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9sZWdhbC9lcGwtdjEwLmh0bWwKKyAqCisgKiBDb250cmlidXRvcnM6CisgKiAgICAgICAgIEZsb3JpYW4gUGlyY2huZXIgLSBJbml0aWFsIGltcGxlbWVudGF0aW9uCisgKi8KKworcGFja2FnZSBvcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3I7CisKK2ltcG9ydCBvcmcuZWNsaXBzZS5jb3JlLnJ1bnRpbWUuSVN0YXR1czsKK2ltcG9ydCBvcmcuZWNsaXBzZS5lcXVpbm94LnAyLmludGVybmFsLnJlcG9zaXRvcnkubWlycm9yaW5nLklBcnRpZmFjdE1pcnJvckxvZzsKK2ltcG9ydCBvcmcuZWNsaXBzZS5lcXVpbm94LnAyLnJlcG9zaXRvcnkuYXJ0aWZhY3QuSUFydGlmYWN0RGVzY3JpcHRvcjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5vc2dpLmZyYW1ld29yay5jb25zb2xlLkNvbW1hbmRJbnRlcnByZXRlcjsKKworcHVibGljIGNsYXNzIE1pcnJvckxvZyBpbXBsZW1lbnRzIElBcnRpZmFjdE1pcnJvckxvZyB7CisKKwlwcml2YXRlIHN0YXRpYyBmaW5hbCBTdHJpbmcgSU5ERU5UID0gIlx0IjsgLy8kTk9OLU5MUy0xJAorCXByaXZhdGUgc3RhdGljIGZpbmFsIFN0cmluZyBTRVBBUkFUT1IgPSBTeXN0ZW0KKwkJCS5nZXRQcm9wZXJ0eSgibGluZS5zZXBhcmF0b3IiKTsgLy8kTk9OLU5MUy0xJAorCXByaXZhdGUgYm9vbGVhbiBjb25zb2xlTWVzc2FnZSA9IGZhbHNlOworCXByaXZhdGUgaW50IG1pblNldmVyaXR5ID0gSVN0YXR1cy5PSzsKKwlwcml2YXRlIGJvb2xlYW4gaGFzUm9vdCA9IGZhbHNlOworCXByaXZhdGUgQ29tbWFuZEludGVycHJldGVyIGNpOworCisJcHVibGljIE1pcnJvckxvZyhDb21tYW5kSW50ZXJwcmV0ZXIgY2kpIHsKKwkJdGhpcy5taW5TZXZlcml0eSA9IG1pblNldmVyaXR5OworCQl0aGlzLmNpID0gY2k7CisJfQorCisJLyoKKwkgKiAobm9uLUphdmFkb2MpCisJICogCisJICogQHNlZQorCSAqIG9yZy5lY2xpcHNlLmVxdWlub3guaW50ZXJuYWwucDIuYXJ0aWZhY3QubWlycm9yLklBcnRpZmFjdE1pcnJvckxvZyNsb2cKKwkgKiAob3JnLmVjbGlwc2UuZXF1aW5veC5pbnRlcm5hbC5wcm92aXNpb25hbC5wMi5hcnRpZmFjdC5yZXBvc2l0b3J5LgorCSAqIElBcnRpZmFjdERlc2NyaXB0b3IsIG9yZy5lY2xpcHNlLmNvcmUucnVudGltZS5JU3RhdHVzKQorCSAqLworCXB1YmxpYyB2b2lkIGxvZyhJQXJ0aWZhY3REZXNjcmlwdG9yIGRlc2NyaXB0b3IsIElTdGF0dXMgc3RhdHVzKSB7CisJCWlmIChzdGF0dXMuZ2V0U2V2ZXJpdHkoKSA+PSBtaW5TZXZlcml0eSkgeworCQkJbG9nKGRlc2NyaXB0b3IudG9TdHJpbmcoKSk7CisJCQlsb2coc3RhdHVzLCBJTkRFTlQpOworCQl9CisJfQorCisJLyoKKwkgKiAobm9uLUphdmFkb2MpCisJICogCisJICogQHNlZQorCSAqIG9yZy5lY2xpcHNlLmVxdWlub3guaW50ZXJuYWwucDIuYXJ0aWZhY3QubWlycm9yLklBcnRpZmFjdE1pcnJvckxvZyNsb2cKKwkgKiAob3JnLmVjbGlwc2UuY29yZS5ydW50aW1lLklTdGF0dXMpCisJICovCisJcHVibGljIHZvaWQgbG9nKElTdGF0dXMgc3RhdHVzKSB7CisJCWxvZyhzdGF0dXMsICIiKTsgLy8kTk9OLU5MUy0xJAorCX0KKworCS8qCisJICogV3JpdGUgYSBzdGF0dXMgdG8gdGhlIGxvZywgaW5kZW50aW5nIGl0IGJhc2VkIG9uIHN0YXR1cyBkZXB0aC4KKwkgKiAKKwkgKiBAcGFyYW0gc3RhdHVzIHRoZSBzdGF0dXMgdG8gbG9nCisJICogCisJICogQHBhcmFtIGRlcHRoIHRoZSBkZXB0aCBvZiB0aGUgc3RhdHVzCisJICovCisJcHJpdmF0ZSB2b2lkIGxvZyhJU3RhdHVzIHN0YXR1cywgU3RyaW5nIHByZWZpeCkgeworCQlpZiAoc3RhdHVzLmdldFNldmVyaXR5KCkgPj0gbWluU2V2ZXJpdHkpIHsKKwkJCS8vIFdyaXRlIHN0YXR1cyB0byBsb2cKKwkJCWxvZyhwcmVmaXggKyBzdGF0dXMuZ2V0TWVzc2FnZSgpKTsKKworCQkJLy8gV3JpdGUgZXhjZXB0aW9uIHRvIGxvZyBpZiBhcHBsaWNhYmxlCisJCQlTdHJpbmcgZXhjZXB0aW9uTWVzc2FnZSA9IHN0YXR1cy5nZXRFeGNlcHRpb24oKSAhPSBudWxsID8gc3RhdHVzCisJCQkJCS5nZXRFeGNlcHRpb24oKS5nZXRNZXNzYWdlKCkgOiBudWxsOworCQkJaWYgKGV4Y2VwdGlvbk1lc3NhZ2UgIT0gbnVsbCkKKwkJCQlsb2cocHJlZml4ICsgZXhjZXB0aW9uTWVzc2FnZSk7CisKKwkJCS8vIFdyaXRlIHRoZSBjaGlsZHJlbiBvZiB0aGUgc3RhdHVzIHRvIHRoZSBsb2cKKwkJCUlTdGF0dXNbXSBuZXN0ZWRTdGF0dXMgPSBzdGF0dXMuZ2V0Q2hpbGRyZW4oKTsKKwkJCWlmIChuZXN0ZWRTdGF0dXMgIT0gbnVsbCkKKwkJCQlmb3IgKGludCBpID0gMDsgaSA8IG5lc3RlZFN0YXR1cy5sZW5ndGg7IGkrKykKKwkJCQkJbG9nKG5lc3RlZFN0YXR1c1tpXSwgcHJlZml4ICsgSU5ERU5UKTsKKwkJfQorCX0KKworCS8qCisJICogV3JpdGUgYSBtZXNzYWdlIHRvIHRoZSBsb2cKKwkgKiAKKwkgKiBAcGFyYW0gbWVzc2FnZSB0aGUgbWVzc2FnZSB0byB3cml0ZQorCSAqLworCXByaXZhdGUgdm9pZCBsb2coU3RyaW5nIG1lc3NhZ2UpIHsKKwkJY2kucHJpbnQoKGhhc1Jvb3QgPyBJTkRFTlQgOiAiIikgKyBtZXNzYWdlICsgU0VQQVJBVE9SKTsgLy8kTk9OLU5MUy0xJAorCX0KKworCS8qCisJICogKG5vbi1KYXZhZG9jKQorCSAqIAorCSAqIEBzZWUKKwkgKiBvcmcuZWNsaXBzZS5lcXVpbm94LmludGVybmFsLnAyLmFydGlmYWN0Lm1pcnJvci5JQXJ0aWZhY3RNaXJyb3JMb2cjY2xvc2UKKwkgKiAoKQorCSAqLworCXB1YmxpYyB2b2lkIGNsb3NlKCkgeworCX0KK30KZGlmZiAtLWdpdCBhL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvdG9vbHMvcDIvbWlycm9yL1AyTWlycm9yQXBwbGljYXRpb24uamF2YSBiL29yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvci9zcmMvb3JnL2VjbGlwc2Uvb3NicC9pZGUvdG9vbHMvcDIvbWlycm9yL1AyTWlycm9yQXBwbGljYXRpb24uamF2YQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi40MGFiZjAwCi0tLSAvZGV2L251bGwKKysrIGIvb3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yL3NyYy9vcmcvZWNsaXBzZS9vc2JwL2lkZS90b29scy9wMi9taXJyb3IvUDJNaXJyb3JBcHBsaWNhdGlvbi5qYXZhCkBAIC0wLDAgKzEsNDAgQEAKKy8qKgorICogQ29weXJpZ2h0IChjKSAyMDExLCAyMDE1IC0gTHVuaWZlcmEgR21iSCAoR3Jvc3MgRW56ZXJzZG9yZiwgQXVzdHJpYSksIExvZXR6IEdtYkgmQ28uS0cgKDY5MTE1IEhlaWRlbGJlcmcsIEdlcm1hbnkpCisgKiBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzCisgKiBhcmUgbWFkZSBhdmFpbGFibGUgdW5kZXIgdGhlIHRlcm1zIG9mIHRoZSBFY2xpcHNlIFB1YmxpYyBMaWNlbnNlIHYxLjAKKyAqIHdoaWNoIGFjY29tcGFuaWVzIHRoaXMgZGlzdHJpYnV0aW9uLCBhbmQgaXMgYXZhaWxhYmxlIGF0CisgKiBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbAorICoKKyAqIENvbnRyaWJ1dG9yczoKKyAqICAgICAgICAgRmxvcmlhbiBQaXJjaG5lciAtIEluaXRpYWwgaW1wbGVtZW50YXRpb24KKyAqLworCitwYWNrYWdlIG9yZy5lY2xpcHNlLm9zYnAuaWRlLnRvb2xzLnAyLm1pcnJvcjsKKworaW1wb3J0IGphdmEudXRpbC5jb25jdXJyZW50LkFycmF5QmxvY2tpbmdRdWV1ZTsKKworaW1wb3J0IG9yZy5lY2xpcHNlLmVxdWlub3guYXBwLklBcHBsaWNhdGlvbjsKK2ltcG9ydCBvcmcuZWNsaXBzZS5lcXVpbm94LmFwcC5JQXBwbGljYXRpb25Db250ZXh0OworCitwdWJsaWMgY2xhc3MgUDJNaXJyb3JBcHBsaWNhdGlvbiBpbXBsZW1lbnRzIElBcHBsaWNhdGlvbiB7CisKKwlwcml2YXRlIEFycmF5QmxvY2tpbmdRdWV1ZTxTdHJpbmc+IHF1ZXVlOworCisJQE92ZXJyaWRlCisJcHVibGljIE9iamVjdCBzdGFydChJQXBwbGljYXRpb25Db250ZXh0IGNvbnRleHQpIHRocm93cyBFeGNlcHRpb24geworCQlxdWV1ZSA9IG5ldyBBcnJheUJsb2NraW5nUXVldWU8U3RyaW5nPigxMCk7CisKKwkJU3RyaW5nIG1zZzsKKwkJd2hpbGUgKCEobXNnID0gcXVldWUudGFrZSgpKS5lcXVhbHMoImV4aXQiKSkgeworCQkJU3lzdGVtLm91dC5wcmludGxuKCJBcHBsaWNhdGlvbiBzaHV0ZG93bmVkIik7CisJCX0KKworCQlyZXR1cm4gRVhJVF9PSzsKKwl9CisKKwlAT3ZlcnJpZGUKKwlwdWJsaWMgdm9pZCBzdG9wKCkgeworCisJfQorCit9CmRpZmYgLS1naXQgYS9wb20ueG1sIGIvcG9tLnhtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lMmUzYzVkCi0tLSAvZGV2L251bGwKKysrIGIvcG9tLnhtbApAQCAtMCwwICsxLDE3MiBAQAorPD94bWwgdmVyc2lvbj0iMS4wIiBlbmNvZGluZz0iVVRGLTgiPz4KKzwhLS0jPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gLS0+Cis8IS0tIyBDb3B5cmlnaHQgKGMpIDIwMTEsIDIwMTYgLSBMdW5pZmVyYSBHbWJIIChHcm9zcyBFbnplcnNkb3JmKSwgTG9ldHogR21iSCZDby5LRyAoNjkxMTUgSGVpZGVsYmVyZywgR2VybWFueSkgLS0+Cis8IS0tIyBBbGwgcmlnaHRzIHJlc2VydmVkLiBUaGlzIHByb2dyYW0gYW5kIHRoZSBhY2NvbXBhbnlpbmcgbWF0ZXJpYWxzIC0tPgorPCEtLSMgYXJlIG1hZGUgYXZhaWxhYmxlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgRWNsaXBzZSBQdWJsaWMgTGljZW5zZSB2MS4wIC0tPgorPCEtLSMgd2hpY2ggYWNjb21wYW5pZXMgdGhpcyBkaXN0cmlidXRpb24sIGFuZCBpcyBhdmFpbGFibGUgYXQgLS0+Cis8IS0tIyBodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2xlZ2FsL2VwbC12MTAuaHRtbCAtLT4KKzwhLS0jIC0tPgorPCEtLSMgQ29udHJpYnV0b3JzOiAtLT4KKzwhLS0jICAgICBLbGVtZW5zIEVkbGVyIChMdW5pZmVyYSBHbWJIKSAtIGluaXRpYWwgQVBJIGFuZCBpbXBsZW1lbnRhdGlvbiAtLT4KKzwhLS0jPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0gLS0+Cis8cHJvamVjdCB4bWxucz0iaHR0cDovL21hdmVuLmFwYWNoZS5vcmcvUE9NLzQuMC4wIiB4bWxuczp4c2k9Imh0dHA6Ly93d3cudzMub3JnLzIwMDEvWE1MU2NoZW1hLWluc3RhbmNlIiB4c2k6c2NoZW1hTG9jYXRpb249Imh0dHA6Ly9tYXZlbi5hcGFjaGUub3JnL1BPTS80LjAuMCBodHRwOi8vbWF2ZW4uYXBhY2hlLm9yZy94c2QvbWF2ZW4tNC4wLjAueHNkIj4KKyAgICA8bW9kZWxWZXJzaW9uPjQuMC4wPC9tb2RlbFZlcnNpb24+CisKKyAgICA8Z3JvdXBJZD5vcmcuZWNsaXBzZS5vc2JwLmlkZTwvZ3JvdXBJZD4KKyAgICA8YXJ0aWZhY3RJZD5vcmcuZWNsaXBzZS5vc2JwLmlkZTwvYXJ0aWZhY3RJZD4KKyAgICA8dmVyc2lvbj4wLjkuMC1TTkFQU0hPVDwvdmVyc2lvbj4KKyAgICA8cGFja2FnaW5nPnBvbTwvcGFja2FnaW5nPgorCisgICAgPHBhcmVudD4KKyAgICAgICAgPGdyb3VwSWQ+b3JnLmVjbGlwc2Uub3NicC5yZWxlbmcubWF2ZW48L2dyb3VwSWQ+CisgICAgICAgIDxhcnRpZmFjdElkPm9yZy5lY2xpcHNlLm9zYnAucmVsZW5nLm1hdmVuLnBhcmVudC50eWNobzwvYXJ0aWZhY3RJZD4KKyAgICAgICAgPHZlcnNpb24+MC45LjAtU05BUFNIT1Q8L3ZlcnNpb24+CisgICAgPC9wYXJlbnQ+CisKKyAgICA8dXJsPiR7b3NicC5zaXRlLnJlcG9zaXRvcnkudXJsfTwvdXJsPgorICAgIDxzY20+CisgICAgICAgIDx1cmw+JHtvc2JwLnNjbS51cmx9PC91cmw+CisgICAgICAgIDxjb25uZWN0aW9uPiR7b3NicC5zY20uY29ubmVjdGlvbn08L2Nvbm5lY3Rpb24+CisgICAgICAgIDxkZXZlbG9wZXJDb25uZWN0aW9uPiR7b3NicC5zY20uY29ubmVjdGlvbi5kZXZ9PC9kZXZlbG9wZXJDb25uZWN0aW9uPgorICAgICAgICA8dGFnPkhFQUQ8L3RhZz4KKyAgICA8L3NjbT4KKyAgICA8ZGlzdHJpYnV0aW9uTWFuYWdlbWVudD4KKyAgICAgICAgPHNpdGU+CisgICAgICAgICAgICA8aWQ+Z2gtcGFnZXM8L2lkPgorICAgICAgICAgICAgPG5hbWU+T1NCUCBHaXRIdWIgUGFnZXM8L25hbWU+CisgICAgICAgICAgICA8dXJsPiR7ZGlzdHJpYnV0aW9uLnNpdGUudXJsfTwvdXJsPgorICAgICAgICA8L3NpdGU+CisgICAgPC9kaXN0cmlidXRpb25NYW5hZ2VtZW50PgorCisgICAgPHByb3BlcnRpZXM+CisgICAgICAgIDxvc2JwLmdpdHJlcG8ubmFtZT4ke3Byb2plY3QuZ3JvdXBJZH08L29zYnAuZ2l0cmVwby5uYW1lPgorICAgICAgICA8eHRleHQudmVyc2lvbj4yLjcuMzwveHRleHQudmVyc2lvbj4KKyAgICA8L3Byb3BlcnRpZXM+CisKKyAgICA8bW9kdWxlcz4KKyAgICAgICAgPG1vZHVsZT5vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlPC9tb2R1bGU+CisgICAgICAgIDxtb2R1bGU+b3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS5hcGk8L21vZHVsZT4KKyAgICAgICAgPG1vZHVsZT5vcmcuZWNsaXBzZS5vc2JwLmlkZS5jb3JlLnVpPC9tb2R1bGU+CisgICAgICAgIDxtb2R1bGU+b3JnLmVjbGlwc2Uub3NicC5pZGUuY29yZS51aS5zaGFyZWQ8L21vZHVsZT4KKyAgICAgICAgPG1vZHVsZT5vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5kZXZlbG9wZXI8L21vZHVsZT4KKyAgICAgICAgPG1vZHVsZT5vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3I8L21vZHVsZT4KKyAgICAgICAgPG1vZHVsZT5vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdDwvbW9kdWxlPgorICAgICAgICA8IS0tPG1vZHVsZT5vcmcuZWNsaXBzZS5vc2JwLmlkZS5wMjwvbW9kdWxlPi0tPgorICAgICAgICA8bW9kdWxlPm9yZy5lY2xpcHNlLm9zYnAuaWRlLmZlYXR1cmUudWk8L21vZHVsZT4KKyAgICAgICAgPG1vZHVsZT5vcmcuZWNsaXBzZS5vc2JwLmlkZS5mZWF0dXJlLmhlYWRsZXNzPC9tb2R1bGU+CisgICAgICAgIDxtb2R1bGU+b3JnLmVjbGlwc2Uub3NicC5pZGUuZmVhdHVyZS50b29sczwvbW9kdWxlPgorICAgIDwvbW9kdWxlcz4KKworICAgIDxwcm9maWxlcz4KKyAgICAgICAgPCEtLTxwcm9maWxlPgorCQkJPGlkPmJ1aWxkLnAyPC9pZD4KKwkJCTxhY3RpdmF0aW9uPgorCQkJCTxwcm9wZXJ0eT4KKwkJCQkJPG5hbWU+b3NicC5idWlsZC5wMjwvbmFtZT4KKwkJCQk8L3Byb3BlcnR5PgorCQkJPC9hY3RpdmF0aW9uPgorCQkJPG1vZHVsZXM+CisJCQkJPG1vZHVsZT5vcmcuZWNsaXBzZS5vc2JwLmlkZS5wMjwvbW9kdWxlPgorCQkJPC9tb2R1bGVzPgorCQk8L3Byb2ZpbGU+CisJCTxwcm9maWxlPgorCQkJPGlkPmJ1aWxkLnByb2R1Y3Q8L2lkPgorCQkJPGFjdGl2YXRpb24+CisJCQkJPHByb3BlcnR5PgorCQkJCQk8bmFtZT5vc2JwLmJ1aWxkLnByb2R1Y3Q8L25hbWU+CisJCQkJPC9wcm9wZXJ0eT4KKwkJCTwvYWN0aXZhdGlvbj4KKwkJCTxtb2R1bGVzPgorCQkJCTxtb2R1bGU+b3JnLmVjbGlwc2Uub3NicC5pZGUudG9vbHMucDIubWlycm9yPC9tb2R1bGU+CisJCQkJPG1vZHVsZT5vcmcuZWNsaXBzZS5vc2JwLmlkZS50b29scy5wMi5taXJyb3IucHJvZHVjdDwvbW9kdWxlPgorCQkJPC9tb2R1bGVzPgorCQk8L3Byb2ZpbGU+LS0+CisgICAgPC9wcm9maWxlcz4KKworICAgIDxidWlsZD4KKyAgICAgICAgPHBsdWdpbk1hbmFnZW1lbnQ+CisgICAgICAgICAgICA8cGx1Z2lucz4KKyAgICAgICAgICAgICAgICA8cGx1Z2luPgorICAgICAgICAgICAgICAgICAgICA8Z3JvdXBJZD5vcmcuY29kZWhhdXMubW9qbzwvZ3JvdXBJZD4KKyAgICAgICAgICAgICAgICAgICAgPGFydGlmYWN0SWQ+YnVpbGQtaGVscGVyLW1hdmVuLXBsdWdpbjwvYXJ0aWZhY3RJZD4KKyAgICAgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbnM+CisgICAgICAgICAgICAgICAgICAgICAgICA8ZXhlY3V0aW9uPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxpZD5hZGQtc291cmNlPC9pZD4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8cGhhc2U+aW5pdGlhbGl6ZTwvcGhhc2U+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGdvYWxzPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbD5hZGQtc291cmNlPC9nb2FsPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIDwvZ29hbHM+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGNvbmZpZ3VyYXRpb24+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxzb3VyY2VzPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPHNvdXJjZT5zcmMtZ2VuPC9zb3VyY2U+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8c291cmNlPnh0ZW5kLWdlbjwvc291cmNlPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L3NvdXJjZXM+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9jb25maWd1cmF0aW9uPgorICAgICAgICAgICAgICAgICAgICAgICAgPC9leGVjdXRpb24+CisgICAgICAgICAgICAgICAgICAgIDwvZXhlY3V0aW9ucz4KKyAgICAgICAgICAgICAgICA8L3BsdWdpbj4KKyAgICAgICAgICAgICAgICA8cGx1Z2luPgorICAgICAgICAgICAgICAgICAgICA8Z3JvdXBJZD5vcmcuZWNsaXBzZS50eWNobzwvZ3JvdXBJZD4KKyAgICAgICAgICAgICAgICAgICAgPGFydGlmYWN0SWQ+dHljaG8tc291cmNlLXBsdWdpbjwvYXJ0aWZhY3RJZD4KKyAgICAgICAgICAgICAgICAgICAgPHZlcnNpb24+JHt0eWNoby12ZXJzaW9ufTwvdmVyc2lvbj4KKyAgICAgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbnM+CisgICAgICAgICAgICAgICAgICAgICAgICA8ZXhlY3V0aW9uPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxpZD5wbHVnaW4tc291cmNlPC9pZD4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbHM+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxnb2FsPnBsdWdpbi1zb3VyY2U8L2dvYWw+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9nb2Fscz4KKyAgICAgICAgICAgICAgICAgICAgICAgIDwvZXhlY3V0aW9uPgorICAgICAgICAgICAgICAgICAgICA8L2V4ZWN1dGlvbnM+CisgICAgICAgICAgICAgICAgPC9wbHVnaW4+CisgICAgICAgICAgICAgICAgPHBsdWdpbj4KKyAgICAgICAgICAgICAgICAgICAgPGdyb3VwSWQ+b3JnLmVjbGlwc2UueHRlbmQ8L2dyb3VwSWQ+CisgICAgICAgICAgICAgICAgICAgIDxhcnRpZmFjdElkPnh0ZW5kLW1hdmVuLXBsdWdpbjwvYXJ0aWZhY3RJZD4KKyAgICAgICAgICAgICAgICAgICAgPHZlcnNpb24+JHt4dGV4dC52ZXJzaW9ufTwvdmVyc2lvbj4KKyAgICAgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbnM+CisgICAgICAgICAgICAgICAgICAgICAgICA8ZXhlY3V0aW9uPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxnb2Fscz4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGdvYWw+Y29tcGlsZTwvZ29hbD4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGdvYWw+eHRlbmQtaW5zdGFsbC1kZWJ1Zy1pbmZvPC9nb2FsPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbD50ZXN0Q29tcGlsZTwvZ29hbD4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGdvYWw+eHRlbmQtdGVzdC1pbnN0YWxsLWRlYnVnLWluZm88L2dvYWw+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgPC9nb2Fscz4KKyAgICAgICAgICAgICAgICAgICAgICAgIDwvZXhlY3V0aW9uPgorICAgICAgICAgICAgICAgICAgICA8L2V4ZWN1dGlvbnM+CisgICAgICAgICAgICAgICAgICAgIDxjb25maWd1cmF0aW9uPgorICAgICAgICAgICAgICAgICAgICAgICAgPG91dHB1dERpcmVjdG9yeT54dGVuZC1nZW48L291dHB1dERpcmVjdG9yeT4KKyAgICAgICAgICAgICAgICAgICAgPC9jb25maWd1cmF0aW9uPgorICAgICAgICAgICAgICAgIDwvcGx1Z2luPgorICAgICAgICAgICAgPC9wbHVnaW5zPgorICAgICAgICA8L3BsdWdpbk1hbmFnZW1lbnQ+CisgICAgICAgIDxwbHVnaW5zPgorICAgICAgICAgICAgPHBsdWdpbj4KKyAgICAgICAgICAgICAgICA8YXJ0aWZhY3RJZD5tYXZlbi1jbGVhbi1wbHVnaW48L2FydGlmYWN0SWQ+CisgICAgICAgICAgICAgICAgPGNvbmZpZ3VyYXRpb24+CisgICAgICAgICAgICAgICAgICAgIDxmaWxlc2V0cz4KKyAgICAgICAgICAgICAgICAgICAgICAgIDxmaWxlc2V0PgorICAgICAgICAgICAgICAgICAgICAgICAgICAgIDxkaXJlY3Rvcnk+eHRlbmQtZ2VuPC9kaXJlY3Rvcnk+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGluY2x1ZGVzPgorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICA8aW5jbHVkZT4qKjwvaW5jbHVkZT4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8L2luY2x1ZGVzPgorICAgICAgICAgICAgICAgICAgICAgICAgPC9maWxlc2V0PgorICAgICAgICAgICAgICAgICAgICA8L2ZpbGVzZXRzPgorICAgICAgICAgICAgICAgIDwvY29uZmlndXJhdGlvbj4KKyAgICAgICAgICAgIDwvcGx1Z2luPgorICAgICAgICAgICAgPHBsdWdpbj4KKyAgICAgICAgICAgICAgICA8Z3JvdXBJZD5vcmcuZWNsaXBzZS54dGVuZDwvZ3JvdXBJZD4KKyAgICAgICAgICAgICAgICA8YXJ0aWZhY3RJZD54dGVuZC1tYXZlbi1wbHVnaW48L2FydGlmYWN0SWQ+CisgICAgICAgICAgICAgICAgPGV4ZWN1dGlvbnM+CisgICAgICAgICAgICAgICAgICAgIDxleGVjdXRpb24+CisgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbHM+CisgICAgICAgICAgICAgICAgICAgICAgICAgICAgPGdvYWw+Y29tcGlsZTwvZ29hbD4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8Z29hbD50ZXN0Q29tcGlsZTwvZ29hbD4KKyAgICAgICAgICAgICAgICAgICAgICAgIDwvZ29hbHM+CisgICAgICAgICAgICAgICAgICAgICAgICA8Y29uZmlndXJhdGlvbj4KKyAgICAgICAgICAgICAgICAgICAgICAgICAgICA8b3V0cHV0RGlyZWN0b3J5Pnh0ZW5kLWdlbjwvb3V0cHV0RGlyZWN0b3J5PgorICAgICAgICAgICAgICAgICAgICAgICAgPC9jb25maWd1cmF0aW9uPgorICAgICAgICAgICAgICAgICAgICA8L2V4ZWN1dGlvbj4KKyAgICAgICAgICAgICAgICA8L2V4ZWN1dGlvbnM+CisgICAgICAgICAgICA8L3BsdWdpbj4KKyAgICAgICAgPC9wbHVnaW5zPgorICAgIDwvYnVpbGQ+Cis8L3Byb2plY3Q+Cg==