ZGlmZiAtLWdpdCBhL2RldmVsb3BtZW50Ly5wcm9qZWN0IGIvZGV2ZWxvcG1lbnQvLnByb2plY3QKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDYzZTMxYTQuLjAwMDAwMDAKLS0tIGEvZGV2ZWxvcG1lbnQvLnByb2plY3QKKysrIC9kZXYvbnVsbApAQCAtMSwxMSArMCwwIEBACi08P3htbCB2ZXJzaW9uPSIxLjAiIGVuY29kaW5nPSJVVEYtOCI/PgotPHByb2plY3REZXNjcmlwdGlvbj4KLQk8bmFtZT5qc3Qgc2VydmVyIGRldmVsb3BtZW50PC9uYW1lPgotCTxjb21tZW50PjwvY29tbWVudD4KLQk8cHJvamVjdHM+Ci0JPC9wcm9qZWN0cz4KLQk8YnVpbGRTcGVjPgotCTwvYnVpbGRTcGVjPgotCTxuYXR1cmVzPgotCTwvbmF0dXJlcz4KLTwvcHJvamVjdERlc2NyaXB0aW9uPgpkaWZmIC0tZ2l0IGEvZGV2ZWxvcG1lbnQvUGx1Z2luT3ZlcnZpZXcuaHRtbCBiL2RldmVsb3BtZW50L1BsdWdpbk92ZXJ2aWV3Lmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDg0MDRlOTQuLjAwMDAwMDAKLS0tIGEvZGV2ZWxvcG1lbnQvUGx1Z2luT3ZlcnZpZXcuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDQ3ICswLDAgQEAKLTwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vVzNDLy9EVEQgSFRNTCA0LjAgVHJhbnNpdGlvbmFsLy9FTiI+Ci08SFRNTD4KLTxIRUFEPgotCQotCTxUSVRMRT5FY2xpcHNlIEpTVCBzZXJ2ZXIgY29tcG9uZW50IHBsdWdpbnM8L1RJVExFPgotCTxNRVRBIE5BTUU9IkdFTkVSQVRPUiIgQ09OVEVOVD0iT3Blbk9mZmljZS5vcmcgMS4xLjMgIChXaW4zMikiPgotCTxNRVRBIE5BTUU9IkNSRUFURUQiIENPTlRFTlQ9IjIwMDQxMTExOzIxNDcwNzA5Ij4KLQk8TUVUQSBOQU1FPSJDSEFOR0VEIiBDT05URU5UPSIxNjAxMDEwMTswIj4KLTwvSEVBRD4KLTxCT0RZPgotPFAgPjxCUj48QlI+Ci08L1A+Ci08SDEgQUxJR049Q0VOVEVSPkVjbGlwc2UgSlNUIHNlcnZlciBjb21wb25lbnQgcGx1Z2luczwvSDE+Ci08SDI+SlNUIFNlcnZlciBQbHVnaW5zPC9IMj4KLTxQPjxCUj5KU1IgU2VydmVyIGNvbnNpc3RzIG9mIHRoZSBmb2xsb3dpbmcgcGx1Z2luczwvUD4KLTxVTD4KLQk8TEk+PFAgU1RZTEU9Im1hcmdpbi1ib3R0b206IDBjbSI+UGx1Z2luIGZvciBqMmVlCi0JcnVudGltZSBzdXBwb3J0PC9QPgotCTxMST48UCBTVFlMRT0ibWFyZ2luLWJvdHRvbTogMGNtIj5nZW5lcmljIHNlcnZlciB0aGF0Ci0JYWRkcyB0aGUgYWJpbGl0eSB0byBkZWZpbmUgbmV3IHNlcnZlcnMgd2l0aCBhIGRlZmluaXRpb24gZmlsZTwvUD4KLQk8TEk+PFAgU1RZTEU9Im1hcmdpbi1ib3R0b206IDBjbSI+QXBhY2hlIFRvbWNhdCBzZXJ2ZXIKLQl0b29sczwvUD4KLTwvVUw+Ci08SFI+Ci08SDIgPlBsdWdpbiBEZXNjcmlwdGlvbnM8L0gyPgotPEg0Pm9yZy5lY2xpcHNlLmpzdC5zZXJ2ZXIuY29yZTwvSDQ+Ci08UD5UaGlzIHBsdWdpbiBwcm92aWRlcyB0aGUgY29yZSBvZiB0aGUgajJlZSBzdXBwb3J0LjwvUD4KLTxIND5vcmcuZWNsaXBzZS5qc3Quc2VydmVyLnVpPC9IND4KLTxQPlByb3ZpZGVzIHRoZSBVSSBjb21wb25lbnRzIGZvciB0aGUgajJlZSBzdXBwb3J0LjwvUD4KLTxIND5vcmcuZWNsaXBzZS5qc3Quc2VydmVyLmdlbmVyaWMuY29yZTwvSDQ+Ci08UD5UaGUgY29yZSBvZiB0aGUgZ2VuZXJpYyBzZXJ2ZXIgdG9vbC4gJllhY3V0ZTtuY2x1ZGVzCi10aGUgaW1wbGVtZXRhdGlvbiBvZiBzZXJ2ZXIgdG9vbGluZyBhbmQgdGhlIG1lY2hhbmlzbXMgZm9yIHNlcnZlcgotdHlwZSBkZWZpbml0b24gZmlsZXMuPC9QPgotPEg0Pm9yZy5lY2xpcHNlLmpzdC5zZXJ2ZXIuZ2VuZXJpYy51aTwvSDQ+Ci08UD5UaGUgVUkgY29tcG9uZW50cyBmb3IgdGhlIGdlbmVyaWMgc2VydmVyIHRvb2xpbmcuIAotPC9QPgotPEg0Pm9yZy5lY2xpcHNlLmpzdC5zZXJ2ZXIuZ2VuZXJpYy5tb2R1bGVzPC9IND4KLTxQPlByb3ZpZGVzIHRoZSBqMmVlIHN0YW5kYXJkIG1vZHVsZSBkZWZpbml0aW9ucyB1c2VkIGJ5Ci10aGUgZ2VuZXJpYyBzZXJ2ZXIgcGx1Z2luLiBUaGlzIGlzIHN1YmplY3QgdG8gY2hhbmdlIHdoZW4gdGhlCi1mbGV4aWJsZSBwcm9qZWN0IHdvcmsgaXMgY29tcGxldGVkLjwvUD4KLTxIND5vcmcuZWNsaXBzZS5qc3Quc2VydmVyLnRvbWNhdC5jb3JlPC9IND4KLTxQPkFwYWNoZSBUb21jYXQgc2VydmVyIHRvb2xpbmcgLjwvUD4KLTxIND5vcmcuZWNsaXBzZS5qc3Quc2VydmVyLnRvbWNhdC51aTwvSDQ+Ci08UD5VSSBjb21wb25lbnRzIGZvciB0aGUgQXBhY2hlIFRvbWNhdCBTZXJ2ZXIgdG9vbHMuPC9QPgotPEhSPgotPC9CT0RZPgotPC9IVE1MPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2RldmVsb3BtZW50L1NlcnZlckRldmVsb3BtZW50UGxhbi5odG1sIGIvZGV2ZWxvcG1lbnQvU2VydmVyRGV2ZWxvcG1lbnRQbGFuLmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDgyYTk4OTAuLjAwMDAwMDAKLS0tIGEvZGV2ZWxvcG1lbnQvU2VydmVyRGV2ZWxvcG1lbnRQbGFuLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSw5MyArMCwwIEBACi08IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL1czQy8vRFREIEhUTUwgNC4wIFRyYW5zaXRpb25hbC8vRU4iPgotPEhUTUw+Ci08SEVBRD4KLQk8VElUTEU+SlNUIFNlcnZlciBEZXZlbG9wbWVudCBwbGFuPC9USVRMRT4KLTwvSEVBRD4KLTxCT0RZID4KLTxIMSBhbGlnbj0iY2VudGVyIj5KU1QgU2VydmVyIENvbXBvbmVudCBEZXZlbG9wbWVudCBQbGFuPC9IMT4KLTxIMiA+Q29tcG9uZW50IGxlYWQ6IE5hY2kgRGFpPC9IMj4KLTxIMiA+PEJSPjxCUj4KLTwvSDI+Ci08UD5UaGUgbWFpbiBnb2FsIGZvciBNMiBpcyBmbGV4aWJsZSBwcm9qZWN0L21vZHVsZQotc3RydWN0dXJlLiAKLTwvUD4KLQotPFA+R2VuZXJpYyBzZXJ2ZXIgcGx1Z2luIHdpbGwgYmVjb21lIG1vcmUgZ2VuZXJpYy4gUHJvdmlkZSBleHRlbnNpb24gcG9pbnRzIHRvIGVhc2lsbHkgYWRkIG5ldyBzZXJ2ZXIgdHlwZSAKLWRlZmluaXRpb25zLiAKLTwvUD4KLQotPFRBQkxFIFdJRFRIPTgxNyBCT1JERVI9MSBDRUxMUEFERElORz0yIENFTExTUEFDSU5HPTM+Ci0JPENPTCBXSURUSD0zNzQ+Ci0JPENPTCBXSURUSD01Nj4KLQk8Q09MIFdJRFRIPTE2MD4KLQk8Q09MIFdJRFRIPTEzNz4KLQk8Q09MIFdJRFRIPTUwPgotCTxUUj4KLQkJPFREIFdJRFRIPTM3ND4KLQkJCTxQPjxCPlRhc2s8L0I+PC9QPgotCQk8L1REPgotCQk8VEQgV0lEVEg9NTY+Ci0JCQk8UD48Qj5Qcmlvcml0eTwvQj48L1A+Ci0JCTwvVEQ+Ci0JCTxURCBXSURUSD0xNjA+Ci0JCQk8UD48Qj5SZXNwb25zaWJsZSA8QlI+UGVyc29uIG9yIFRlYW08L0I+PC9QPgotCQk8L1REPgotCQk8VEQgV0lEVEg9MTM3PgotCQkJPFA+PEI+UGxhbm5lZCB0aW1lZnJhbWU8L0I+PC9QPgotCQk8L1REPgotCQk8VEQgV0lEVEg9NTA+Ci0JCQk8UD48Qj5TdGF0dXM8L0I+PC9QPgotCQk8L1REPgotCTwvVFI+Ci0JPFRSPgotCQk8VEQgV0lEVEg9Mzc0PgotCQkJPFA+U2VwZXJhdGUgc2VydmVyIGFuZCBydW50aW1lIGluIGdlbmVyaWMgcGx1Z2luPC9QPgotCQk8L1REPgotCQk8VEQgV0lEVEg9NTY+Ci0JCQk8UD4xPC9QPgotCQk8L1REPgotCQk8VEQgV0lEVEg9MTYwPgotCQkJPFA+R29ya2VtIEVyY2FuPC9QPgotCQk8L1REPgotCQk8VEQgV0lEVEg9MTM3PgotCQkJPFA+MTEvNSB0byAxMS8zMCA8L1A+Ci0JCTwvVEQ+Ci0JCTxURCBXSURUSD01MD4mbmJzcDs8L1REPgotCTwvVFI+Ci0JPFRSPgotCQkKLQk8L1RSPgotCTxUUj4KLQkJPFREIFdJRFRIPTM3ND4KLQkJCTxQPkNyZWF0ZSBleHRlbnNpb24gcG9pbiBmb3IgYWRkaW5nIG5ldyBnZW5lcmljIHNlcnZlciBkZWZpbml0aW9ucwotCQkJPC9QPgotCQk8L1REPgotCQk8VEQgV0lEVEg9NTY+Ci0JCQk8UD4yCi0JCQk8L1A+Ci0JCTwvVEQ+Ci0JCTxURCBXSURUSD0xNjA+Ci0JCQk8UD5Hb3JrZW0gRXJjYW4KLQkJCTwvUD4KLQkJPC9URD4KLQkJPFREIFdJRFRIPTEzNz4KLQkJCTxQPjExLzE2IHRvIDEyLzEwIDwvUD4KLQkJPC9URD4KLQotCQk8VEQgV0lEVEg9NTA+Jm5ic3A7PC9URD4KLQk8L1RSPgotCTxURCBXSURUSD0zNzQ+Ci0JCQk8UD5DcmVhdGUgYW5kIHVzZSBhIFhTRCBmb3Igc2VydmVyIGRlZmluaXRpb25zPC9QPgotCQk8L1REPgotCQk8VEQgV0lEVEg9NTYgPgotCQkJPFA+MjwvUD4KLQkJPC9URD4KLQkJPFREIFdJRFRIPTE2MD4KLQkJCTxQPkdvcmtlbSBFcmNhbiwgTmFjaSBEYWk8L1A+Ci0JCTwvVEQ+Ci0JCTxURCBXSURUSD0xMzc+TTM8L1REPgotCQk8VEQgV0lEVEg9NTA+Jm5ic3A7PC9URD4KLTwvVEFCTEU+Ci08L1A+Ci08L0JPRFk+Ci08L0hUTUw+CmRpZmYgLS1naXQgYS9kZXZlbG9wbWVudC9kZXNjcmlwdGlvbi50eHQgYi9kZXZlbG9wbWVudC9kZXNjcmlwdGlvbi50eHQKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGJlODA3ZGUuLjAwMDAwMDAKLS0tIGEvZGV2ZWxvcG1lbnQvZGVzY3JpcHRpb24udHh0CisrKyAvZGV2L251bGwKQEAgLTEsMTcgKzAsMCBAQAotVGhpcyBkaXJlY3RvcnkgaXMgdXNlZCB0byBob2xkIHZhcmlvdXMgZmlsZXMgdXNlZnVsIHRvIAotY29yZSBkZXZlbG9wZXJzIChjb21taXR0ZXJzIGFuZCBjb250cmlidXRvcnMpIHRvIHNlcnZlciB0b29scwotY29tcG9uZW50LiAKLQotTm90ZSwgd2hlbiBjaGVja2luZyAnZGV2ZWxvcG1lbnQnIG91dCBvZiByZXBvc2l0b3J5IHRvIAotd29ya3NwYWNlLCB5b3UgbWF5IHdhbnQgdG8gdXNlICJjaGVjayBvdXQgYXMiIGFuZCAKLW5hbWUgeW91ciB3b3Jrc3BhY2UgcHJvamVjdCAnanN0IHNlcnZlciBkZXZlbG9wbWVudCcsIAotaW4gY2FzZSB5b3UgaGF2ZSBzZXZlcmFsICdkZXZlbG9wbWVudCcgZm9sZGVycyBjaGVja2VkIG91dC4KLQotRmlsZXMgaW4gdGhpcyBkaXJlY3Rvcnkgc2hvdWxkIG5vdCBiZSBsaW5rZWQvcHVibGlzaGVkCi1kaXJlY3RseSBmb3Igd2ViIGFjY2VzcyAodGhlcmUncyBzb21lIGlzc3VlcyB3aXRoIG1pcnJvciAKLXVwZGF0ZXMgSSd2ZSBoZWFyZCkgb3IgaW5jbHVkZWQgZGlyZWN0bHkgaW4gYnVpbGRzLiAKLQotSG93ZXZlciwgdGhpcyBkaXJlY3RvcnkgY2FuIGJlIHVzZWQgZm9yIGluaXRpYWwgb3IgCi13b3JraW5nIGNvcGllcyBvZiBzdWNoIGRvY3VtZW50cyB3aGljaCBhcmUgdGhlbiBjb3BpZWQgCi1vciBwdWJsaXNoZWQgdG8gYXBwcm9wcmlhdGUgbG9jYXRpb25zIG9uY2UgcmVhZHkgZm9yIAotc3VjaCBkaXN0cmlidXRpb24uClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvZGV2ZWxvcG1lbnQvbWVldGluZ25vdGVzLzIwMDQxMDE0LnR4dCBiL2RldmVsb3BtZW50L21lZXRpbmdub3Rlcy8yMDA0MTAxNC50eHQKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IGY0Y2JlNGYuLjAwMDAwMDAKLS0tIGEvZGV2ZWxvcG1lbnQvbWVldGluZ25vdGVzLzIwMDQxMDE0LnR4dAorKysgL2Rldi9udWxsCkBAIC0xLDE2MiArMCwwIEBACi1qc3Qgc2VydmVyIGRldmVsb3BtZW50IG1lZXRpbmcgbm90ZXMKLQotVGhpcyBmaWxlLCB3aGlsZSBkYXRlZCAyMDA0MTAxNCBhY3R1YWxseSBjb3ZlcnMgYSBudW1iZXIgb2YgbWVldGluZwotb3ZlciB0aGUgbGFzdCBzZXZlcmFsIHdlZWtzLgotCi0KLTIwMDQwODE5IE1lZXRpbmcgbm90ZXMKLQotCVRhc2s6ICg/KSBzb21lb25lIHNob3VsZCB0cnkgZG9pbmcgImxvY2FsIGJ1aWxkIiBmb2xsb3dpbmcKLQlOYWNpJ3MgaW5zdHJ1Y3Rpb25zLCBtYWtlIHN1cmUgaXQgd29ya3Mgb2ssIGFuZCBnaXZlIGZlZWRiYWNrCi0Jb24gZGlyZWN0aW9ucwotCi0JVGFzazogKEdvcmtlbSkgYWRkIHVuaXQgdGVzdHMgKGV2ZW4gaWYganVzdCBhIGZldyBzaW1wbGUgb25jZXMKLQl0aGF0IHNob3cgY2xhc3MgY2FuIGJlIGluc3RhbnRpYXRlZCAoYW5kIHRoZXJlZm9yZSBwbHVnaW4KLQlsb2FkZWQpLgotCi0JVGFzazogKD8pIG5lZWQgdG8gaW5jb3Jwb3JhdGUgRWxpcHNlIGJhc2UgInBlcmZvcm1hbmNlIHVuaXQKLQl0ZXN0cyBmcmFtZXdvcmsiIHRvIGhhdmUgcmVndWxhciBwZXJmb3JtYW5jZSBkYXRhCi0KLTIwMDQwOTE2IE1lZXRpbmcgbm90ZXMKLQotCUppbSBkZXMgUml2aWVyZXMgcHJlc2VudGVkICJob3cgdG8gbWFrZSBwbGF0Zm9ybSBxdWFsaXR5IGNvZGUKLQkxMDEiLiAodGhhdCBjYW4gaGF2ZSBhIGxvbmcgbGlmZSwgZXRjKS4KLQloaXMgcHJlc2VudGF0aW9uIHVuZGVyIG1pc2Nkb2N1bWVudHMgZGlyZWN0b3J5LCBXVFAgU2VydmVyIENvcmUgQVBJcy5wcHQuCi0KLQlIZSBlbXBoYXNpemVkIGRpZmZlcmVuY2UgYmV0d2VlbiBBUEkgYW5kIFNQSSAuLi4gd2hpY2ggaXMgbm90Ci0Jd2VsbCBkZWxpbmlhdGVkIGluIGN1cnJlbnQgY29kZS4KLQotCi0JTGF0ZXIsIHJlZmVycmVkIHRvIHRoZXNlIHdlYiByZWZlcmVuY2VzLgotCVNvbWUgb3RoZXIgQVBJLXJlbGF0ZWQgcmVzb3VyY2VzOgotCi0KLQlodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2FydGljbGVzL0FydGljbGUtQVBJJTIwdXNlL2VjbGlwc2UtYXBpLXVzYWdlLXJ1bGVzLmh0bWwKLQotCWh0dHA6Ly9lY2xpcHNlLm9yZy9lY2xpcHNlL2RldmVsb3BtZW50L2phdmEtYXBpLWV2b2x1dGlvbi5odG1sCi0KLQlodHRwOi8vZGV2LmVjbGlwc2Uub3JnL25hbWluZy5odG1sCi0KLQotMjAwNDA5MjMKLQotCUppbSBjb250aW51ZWQgaGlzIHByZXNlbnRhdGlvbi4KLQlGb3Igc2VydmVyIGNvcmUgYXBpcywgaXQgd291bGQgc2VlbSBtb3JlICJTUEkiIHdvdWxkIGJlCi0JZXh0ZW5zaW9uIHBvaW50cyAoYW5kIHRoZWlyIHJlcXVpcmVkIGludGVyZmFjZXMpLgotCi0JV2hlbiBhc2tlZCBhYm91dCB3aGF0IHR5cGUgb2YgZG9jdW1lbnRhdGlvbiBpcyBnb29kIGV4YW1wbGVzCi0Jb2Ygd2hhdCB3ZSBzaG91bGQgcHJvZHVjZSwgSmltIG1lbnRpb25lZCB0d28gbGV2ZWxzLgotCi0JRmlyc3QsIHRoZXkgdHlwZSBvZiBvdmVydmlldywgc3VjaCBhcyB0aGF0IHdoaWNoIGV4aXN0cyBpbiB0aGUKLQlFY2xpcHNlIHBsYXRmb3JtcyBEZXZlbG9wZXJzIEd1aWRlCi0KLQlTZWNvbmQsIGphdmEgZG9jOiBlc3BlY2lhbGx5IHJlY29tbWVuZGVkIGNvcmUucmVzb3VyY2VzIGFuZAotCXJlbGF0aW9uc2hpcCB0byB0ZWFtLgotCQlhbHNvIG1lbnRpb25lZCBqZHQuY29yZSBhcyBnb29kIGV4YW1wbGUgb2YgamF2YSBkb2MuCi0KLQlUYXNrOiAoPykgImRldmVsb3BlcnMgZ3VpZGUiIHdyaXRldXAgZm9yIHNlcnZlciBwcm92aWRlciBhbmQKLQlzZXJ2ZXIgY2xpZW50cwotCi0KLQotCi0JSmltIGFza2VkIGFib3V0IEpTUidzIDg4IGFuZCA3Ny4gSXRzJyBiZWxpZXZlZCA3NyBpcyBhbHJlYWR5Ci0JaW4gSlNLIDEuND8KLQlObyBvbmUga25ldyBlbm91Z2ggdG8ga25vdyBpbXBsaWNhdGlvbnMgKGlmIHRoZXkgd2VyZSB0aGluZ3MKLQl3ZSBzaG91bGQgcmUtdXNlLCBvciB0aGluZ3Mgd2UgaGFkIHRvIGJlIGNvbXBsaWFudCB3aXRoKS4KLQlOYWNpIGFnZ3JlZWQgdG8gc3R1ZHkgSlNSIDc3IG1vcmUKLQotCVRhc2s6IChOYWNpKSBKU1IgNzcgLS0gd2hhdCBpdHMgaXQsIHdoYXQncyBpbXBsaWNhdGlvbnMgZm9yCi0JdXM/Ci0KLQlUYXNrOiAoPykgSlNSIDg4IC0tIHdoYXQgaXMgaXQgYW5kIHdoYXQncyBpbXBsaWNhdGlvbnMgZm9yIHVzPwotCi0JVGFzaz86ICg/KSBKTVggd2FzIG1lbnRpb25lZCB0b28gKGJ1dCBJIGRpZG4ndCBnZXQgd2hhdCB3YXMKLQlzYWlkKS4KLQotCU5hY2kgbWVudGlvbmVkIHNvbWV0aGluZyBhYm91dCBkaWZmZXJlbmNlIGJldHdlZW4gJ2RlcGxveScgYW5kCi0JJ3B1Ymxpc2gnIHRob3VnaCBJIGRpZG4ndCBnZXQgd2hhdCBpdCB3YXMgKGhlcmUgaW4gbXkgbm90ZXMpLAotCVByb2JhYmx5IGJlY2F1c2UgSSB3YXMgcmVtZW1lcmluZyBob3cgdGhpcyBoYXMgYmVlbiBjb25mdXNpbmcKLQlpbiB0aGUgcGFzdCB3aXRoIGN1c3RvbWVycyB3aG8gdGhpbmsgd2UgcHJvdmlkZSBhIGZvcm1hbAotCWRlcGxveW1lbnQKLQlzeXN0ZW0gKG1hbmFnaW5nIHZlcnNpb24gZGVwZW5kYW5jaWVzLCBncm91cHMgb2YgdWVzcnMsIGV0Yy4pCi0JZm9yIGxhcmdlIElUIHNob3BzLgotCi0yMDA0MDkyNAotCi0JU2hvcnQgbWVldGluZywgV2UgaGFkIGNvbm5lY3Rpb24gdHJvdWJsZSwgc28gTmFjaSBhbmQgR29ya2VtCi0JY291bGQgbm90IHByZXNlbnQgYXMgcGxhbm5lZC4KLQotCU1hcnNoYWxsIEN1bHBlcHBlciBmcm9tIGpib3NzLm9yZyBqb2luZWQgY2FsbCAob24gRGFsbGFzCi0JVGltZSkuCi0JVGFzayAoTWFyc2hhbGwgQ3VscGVwcGVyKSBwcm92aWRlIGEgSkJvc3MgYWRhcHRlciBzaW1pbGFyIHRvCi0JaG93IHdlIGhhdmUgcHJvdmlkZWQgdG9tY2F0IGFkYXB0ZXJzLgotCi0JVGltIG1lbnRpb25lZCBsb3RzIG9mIGNvbnZlcnNhdGlvbnMgd2l0aCBEYXJpbiBXcmlnaHQgb24KLQlpbXByb3ZpbmcgbGF1bmNoIHN1cHBvcnQsIHNvLCBmb3IgZXhhbXBsZSwgY2FuIGhhdmUgb3RoZXIKLQlsYXVuY2ggcHJlZmVyZW5jZXMsCi0JYSBsYXVuY2hlZCBwYWdlIGhpc3RvcnksCi0JSSBvcGVuZWQgZmVhdHVyZSByZXF1ZXN0Ci0JaHR0cHM6Ly9idWdzLmVjbGlwc2Uub3JnL2J1Z3Mvc2hvd19idWcuY2dpP2lkPTc1NzYyIHRvICJob2xkIgotCXRoaXMgYXJlYSBvZiB3b3JrLCB0aG91Z2gKLQl3ZSB3aWxsIG5lZWQgdG8gYmUgbW9yZSBzcGVjaWZpYyB3aXRoIHdoYXQgd2Ugd2FudC9uZWVkLgotCi0KLTIwMDQxMDA3Ci0KLQotCXNob3J0IG1lZXRpbmcsIE5hY2kgYW5kIEdvcmtlbSBjb3VsZG4ndCBqb2luLgotCi0JSXQgd2FzIGFubm91bmNlZCwgdGhvdWdoLCB0aGF0IEFydGh1ciBpcyBoYXZpbmcgYSBmYWNlLWZhY2UKLQltZWV0aW5nIGluIFRvcm9udG8gd2l0aCBUaW0gRGUgQm9lciwgSmltIGRlcyBSaXZpZXJlcywgYW5kCi0Jb3RoZXJzIGZyb20gVG9yb250bywgaW4gb3JkZXIgdG8gbWFrZSBmYXN0ZXIgcHJvZ3Jlc3MgaW4KLQlkZXNpZ25zIGFuZCBtYWtpbmcgInBsYXRmb3JtIHF1YWxpdHkgYXBpcyIuCi0KLQotMjAwNDEwMTQKLQotCUdvcmtlbSBhbmQgTmFjaSBnYXZlIHNvbWUgZGVtbydzIG9mICJMb21ib3otbGlrZSIgZ2VuZXJpYwotCXNlcnZlciBzdXBwb3J0LgotCXRoZXkgaGFkIDMgLnNlcnZlciBmaWxlcyBmb3IgamJvc3MsIGpvbmFzLCBhbmQgc29tZXRoaW5nIGVsc2UKLQlJIGRvbid0IHJlY2FsbC4KLQotCVRoZSBpbW1lZGlhdGUgZmVlZGJhY2sgaW4gdGhlIG1lZXRpbmcgd2FzCi0KLQkJMSkgd2h5IGNvdWxkbid0IHRoZSBYTUwgZmlsZXMgYmUgIm1vdmVkIiB0byB0aGUKLQkJZXh0ZW5zaW9uIHBvaW50IG1vZGVsIGFuZCBiZSBwYXJ0IG9mIGEgcGx1Z2luPwotCQkyKSBldmVuIGlmIHRoYXQgd2FzIHVuZGVzaXJhYmxlIGZvciBzb21lIGNhc2VzL25lZWRzLAotCQl0aGVyZSBuZWVkcyB0byBiZSBhbiAiaW1wb3J0IiBmdW5jdGlvbiB0aGF0IHJlYWRzCi0JCXRoZSBmaWxlIGZyb20gb25lIHBsYWNlIG9uIGRpc2sgKG9yIGludGVybmV0IT8pIGFuZAotCQlwbGFjZXMgdGhlbSBpbiBtZXRhZGlyZWN0b3J5PywgaW5zdGVhZCBvZiB1c2VyIGhhdmluZwotCQl0bwotCQltYW51YWxseSBjb3B5aW5nIGEgZmlsZSB0byB0aGUgcmlnaHQgcGxhY2UuCi0KLQotCUFydGh1ciB3b25kZXJlZCBpZiB0aGlzIGZyYW1ld29yayB3YXMgZ2VuZXJpYyBlbm91Z2ggdG8gYmUKLQl1c2VkIGZvciBhIGRhdGEgYmFzZSBzZXJ2ZXIgKGFwYWNoZSBkZXJieSkgdG8gInB1Ymxpc2giIHN0b3JlZAotCXByb2NlZHVyZSBjYWxscy4KLQlOYWNpIHJlc3BvbmRlZCB0aGF0IGN1cnJlbnRseSB0aGVyZSB3YXMgYWN0dWFsbHkgc29tZSBKMkVFCi0Jc3BlY2lmaWMgIHN0dWZmIGluIHRoZXJlIG5vdywgYnV0IGluIGdlbmVyYWwgY291bGQgYmUgbWFkZQotCW1vcmUgZ2VuZXJpYy4KLQotCU5hY2kgaGFkIHNvbWUgVU1MIGRpYWdyYW1zIGhlIHN0YXJ0ZWQgdG8gcHJlc2VudCBiZWZvcmUgd2UgcmFuCi0Jb3V0IG9mIHRpbWUuCi0JW05hY2kgcGVyaGFwcyB5b3UgY291bGQgcGxlYXNlIHB1dCB0aG9zZSBpbiBtaXNjZG9jdW1lbnRzLCAKLQlzbyB3ZSBjYW4gcmVhZC9zdHVkeSBiZWZvcmUgbmV4dCBtZWV0aW5nXS4KLQotCUl0IHF1aWNrbHkgYmVjYW1lIGFwcGFyZW50IHRoYXQgd2UgY291bGQgbm90IHRhbGsgYWJvdXQKLQknc2VydmVyIHRvb2xzJyBkZXNpZ24gdG9vIG11Y2ggZnVydGhlciwgd2l0aG91dCBhZGRyZXNzaW5nCi0JdGhlICdmbGV4aWJsZSBwcm9qZWN0JyBkZXNpZ24sIHNvIGV2ZXJ5b25lIHdhbnRlZCB0byBzdGFydAotCWZvY3VzaW5nIG9uIHRoYXQgaW4gd2Vla3MgdG8gY29tZS4KLQotCUFmdGVyIHRoZSBjYWxsLCBpbiBjaGF0IHdpdGggSmltIHdlIGRlY2lkZWQgYmVmb3JlIHdlIGp1bXAKLQlyaWdodCBpbnRvIHByb2plY3Qgc3VwcG9ydCwgdGhhdCB3ZSBjb21lIHVwIHdpdGggYW5kIGFncmVlIG9uCi0Jc29tZSB1c2UtY2FzZXMgdGhhdCBoYXZlIGJlZW4gaW1wbGljaXQgaW4gdGhpcyBkaXNjdXNzaW9ucy4gVGhhdAotCXdheSB3ZSBjYW4gYXNzaWduIHByaW9yaXRpZXMgdG8gaW1wbGVtZW50aW5nL3Rlc3RpbmcgdGhlIHVzZQotCWNhc2VzLiBUaGlzIGlzIGNyaXRpY2FsIHNvIHRoYXQgd2UgbWFpbnRhaW4gZm9jdXMgYW5kIG1haW50YWluIHRoZQotCXJpZ2h0IHNjb3BlIG9mIHRoZSBkZXNpZ24gYW5kIHRoZSBBUEkuIFdlIGRpc2N1c3NlZCBob3cgaXQKLQl3b3VsZCBiZSBkZXNpcmVhYmxlIHRvIGhhdmUgdGhlIHVzZS1jYXNlcyBpcm9uZWQgb3V0IGJlZm9yZSB0aGUgMTAvMjUKLQkiZm9jdXNlZCBkZXNpZ24gbWVldGluZyIuCi0KLQlUYXNrOiAoZGF2aWQpIGNyZWF0ZSBpbml0aWFsIHJvdWdoIGRyYWZ0IG9mIHVzZSBjYXNlcwotCmRpZmYgLS1naXQgYS9kZXZlbG9wbWVudC9tZWV0aW5nbm90ZXMvMjAwNDEwMjEudHh0IGIvZGV2ZWxvcG1lbnQvbWVldGluZ25vdGVzLzIwMDQxMDIxLnR4dApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMWI2OWMzOC4uMDAwMDAwMAotLS0gYS9kZXZlbG9wbWVudC9tZWV0aW5nbm90ZXMvMjAwNDEwMjEudHh0CisrKyAvZGV2L251bGwKQEAgLTEsNTIgKzAsMCBAQAotMjAwNDEwMjEgQWdlbmRhCi0KLQlBc3Nlc3Mgd2hlcmUgd2UgYXJlIGluIGRlc2lnbiBwcm9jZXNzIGFuZCBwcm9ncmVzcy4KLQkKLQkJCVRlYW0gYWdyZWVkIHRvIGZsdXNoIG91dCBzb21lIHVzZSBjYXNlcyB0byBoZWxwIGZvY3VzIGRlc2lnbiwgCi0JCQlhbmQgaGVscCAibGltaXQiIFJlbGVhc2UgMSBBUEkgdG8gb25seSB0aGUgbW9zdCBpbXBvcnRhbnQsIGtub3duIHBhdGhzLiAKLQkJCQotCQkJSmltIGV4cHJlc3NlZCBjb25jZXJuIGFib3V0IGhhdmluZyB0d28gQVBJJ3MsIG9uZSBmb3IgImtub3duIEoyRUUgc2VydmVycyIgYW5kCi0JCQlvbmUgZm9yICJ1bmtub3duIHNlcnZlcnMiIChpZiBJJ20gY2FwdHVyaW5nIGl0IGNvcnJlY3RseSkgLi4uIGFuZCBob3cgCi0JCQl3ZSBkbyBub3Qgd2FudCB0d28gQVBJJ3MuICh0aGVuIGl0cyBub3QgcmVhbGx5IGFuIEFQSSwgdG9vIGRpZmZpY3VsdCB0byBtYWludGFpbiwgCi0JCQlhbmQgZXZvbHZlKS4KLQotCURpc2N1c3MgdGFzayB0byBjcmVhdGUgZXhwbGljaXQgdXNlIGNhc2VzCi0JCSAgICBKaW0gYW5kIFRpbSB3aWxsIGNyZWF0ZS9hZGQgc29tZSB3aGlsZSBtZWV0aW5nIGluIFRvcm9udG8sIGFuZAotCQkgICAgSmltIHdpbGwgZGlzY3VzcyBuZXh0IG1lZXRpbmcgKFRpbSB3aWxsIGJlIG5vdCBiZSBhYmxlIHRvIG1ha2UgbmV4dCBtZWV0aW5nKS4KLQkJICAgIAotCQkgICAgTmFjaSBhbmQgQ2h1Y2sgd2lsbCBjcmVhdGUgc29tZSBmb3IgcHJvamVjdCBsYXlvdXQgYW5kIGRpc2N1c3MKLQkJICAgIG5leHQgd2Vlay4gCi0JCSAgICAKLQkJICAgIEhvdyB0byBjYXB0dXJlIHRoZSAiaW50ZXJzZWN0aW9uIiBvZiBzZXJ2ZXJzIHRvb2xzIGFuZCBwcm9qZWN0cyBpcyBzdGlsbCAKLQkJICAgIHVuY2xlYXIgKHRvIG1lKS4gCi0JCQotCVRoZSByb2xlIG9mIGFudCB0YXNrcz8gCi0JCQlBcmUgdGhleSBhIHBvc2l0aXZlIHRoaW5nPwotCQkJT3IgYW4gYWRtaXNzaW9uIHdlIHNpbXBsZSBkb24ndCBrbm93IHdoYXQgdG8gZG8/Ci0JCQkoc28gaW5zdGVhZCBvZiB3cml0aW5nIGphdmEgY29kZSwgdXNlcnMgY2FuIHdyaXRlIGFudCBzY3JpcHRzPykKLQkJCQotCQkJdGVhbSBjbGFyaWZpZWQ6IAotCQkJCXBhcnRpYWxseSBpcyB0byBoYW5kbGUgZmFjdCB0aGF0IHdoaWxlIHdhcidzIGFuZCBlYXIncyBhcmUgInNwZWMnZCIgd2hlcmUgCi0JCQkJCXRoZXkgZ28gb24gYSBzZXJ2ZXIgaXMgbm90LiAKLQkJCQlBbHNvLCBtYW55IHVzZXJzIGhhdmUgcHJlLWV4aXN0aW5nIGJ1aWxkIHNjcmlwdHMgdGhleSB3YW50IHRvIGNvbnRpbnVlIHRvIHVzZS4KLQkJCQotCVNvbWUgb2YgZ2VuZXJpYyBzZXJ2ZXIgc3VwcG9ydCBpcyBwcm92aWRpbmcgbGF1bmNoIHBhcmFtZXRlcnMKLQkJTmFjaSBhY2tub3dsZWRnZSBzb21lIG9mIHdoYXQncyB0aGVyZSBub3csIAotCQljb3VsZCBiZSBtb3ZlZCB0byAicHJvcGVydGllcyBmaWxlcyIvcHJlZmVyZW5jZSBwYWdlcwotCQkJCi0JUHJvamVjdCBsYXlvdXQgLS0gb25seSBicmllZmx5IGRpc2N1c3NlZCAtLSBOYWNpIGFuZCBDaHVjayB0byBjbGFyaWZ5IG5leHQgd2Vlay4KLQkJCUVjbGlwc2UgbmF0aXZlIGxheW91dAotCQkJCW1hcHMgdG8gSjJFRSBydW50aW1lIHNwZWMKLQkJCQlydW5zIGluIHBsYWNlIHZpYSBmaWxlIHN5c3RlbQotCQkJCi0JCQlNYXZlbiBwcm9qZWN0IGxheW91dC4KLQkJCQotCQkJTmF0aXZlIGxheW91dCB3aXRoIGxpbmtlZCBjb250ZW50cwotCQkJCW1hcHMgdG8gSjJFRSBydW50aW1lIHNwZWMgKHZpYSBsaW5rcykKLQkJCQlydW5zIGluIHBsYWNlIChhZnRlciBmb2xsb3dpbmcgbGlua3M/KQotCQkJCUNhbiB3ZSBpbmZlci9kZXJpdmUgbGlua3MsIGdpdmVuIHNvbWUgY29uc3RhaW50cwotCQkJCQlvciB1c2VyIGhpbnRzPwotCQkJCi0JCQlVc2VyIGxheW91dCB3aXRoIHVzZXIgc3BlY2lmaWVkIGNvbnRlbnRzL3JlbGF0aW9uc2hpcHMKLQkJCSAgICBXaGF0IGRvICp3ZSogZG8sIHRoZW4/ICh3aGF0J3MgdmFsdWUgYWRkPykKLQkJCQpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2RldmVsb3BtZW50L21lZXRpbmdub3Rlcy8yMDA0MTAyOC50eHQgYi9kZXZlbG9wbWVudC9tZWV0aW5nbm90ZXMvMjAwNDEwMjgudHh0CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4MTViODRjLi4wMDAwMDAwCi0tLSBhL2RldmVsb3BtZW50L21lZXRpbmdub3Rlcy8yMDA0MTAyOC50eHQKKysrIC9kZXYvbnVsbApAQCAtMSw1MiArMCwwIEBACi0yMDA0MTAyOCBBZ2VuZGEKLQotCUppbS9BcnRodXIgdG8gcmVwb3J0IG9uIFNlcnZlciBBUEkgbWVldGluZyBpbiBUb3JvbnRvCi0JCShzaW5jZSBUaW0gb3V0KQotCU5hY2kvQ2h1Y2sgdG8gcmVwb3J0L3ByZXNlbnQgZmxleGlibGUgcHJvamVjdCBsYXlvdXQKLQkKLQkKLQlKaW06Ci0JCi0JZ29vZCBtZWV0aW5nLCBhcHByZWNpYXRlcyBjb21wbGV4aXR5IG9mIHRoZSBkb21haW4KLQkobXVjaCBvZiB0aGUgY29tcGxleGl0eSBoYXJkIHRvIGNhcHR1cmUgaW4gdXNlIGNhc2VzKS4gCi0JCi0Jb3ZlcmFsbCwgbm90IGEgbG90IG9mIHNpbXBsaWZpY2F0aW9uIHBvc3NpYmxlLiAKLQkKLQkqIHdpdGggdGhlIG9uZSBleGNlcHRpb24gb2YgZmFjdG9yaW5nIG91dCAicHJvamVjdCIgCi0JcmVsYXRlZCB0aGluZ3MsIGFuZCBwcm9iYWJseSByZXBsYWNpbmcgd2l0aCBhIAotCSJtb2R1bGUgZmFjdG9yeSIsIHdoZXJlIHRoZSBwcm9qZWN0IGxheW91dCBzcGVjaWZpYyAKLQljb2RlIGNvdWxkIGdvLiAodGhlIHByb2plY3Qgc3BlY2lmaWMgc3R1ZmYgaXMgbW9zdGx5IAotCXJlbGV2YW50IGR1cmluZyAicHVibGlzaCIgYXNwZWN0cyBhbmQgInByb2plY3QgaGFzIGNoYW5nZWQiIAotCWFzcGVjdHMpLiAKLQkKLQlPbmNlIHByb2plY3RzICJyZW1vdmVkIiAuLi4gdGhlICJzZXJ2ZXIgY29yZSIgYW5kICJtb2R1bGUgY29yZSIgCi0Jc2hvdWxkIGJlIGZhaXJseSBzZXBhcmF0ZSBwaWVjZXMuIAotCQotCVRoaXMgTmVlZHMgYSAiY29uY2VwdCBkb2N1bWVudCIgZGVzY3JpYmluZyBkb21haW4uIAotCSogW3Rhc2tdIEppbSB3aWxsIHByb2R1Y2UgYSBkcmFmdCBvZiB0aGUgZG9jdW1lbnQsIHdoaWxlCi0JaWRlYXMgYXJlIGZyZXNoIGluIGhpcyBtaW5kLiAKLQkKLQkqIFJlbWFpbmluZyAoY29udGludWluZykgaXNzdWU6IFRoZXkgZGlkIG5vdCB3b3JrIG9uIHNlcGFyYXRpb24gCi0Jb2YgV1NUIHBhcnQgYW5kIEpTVCBwYXJ0LiAKLQkKLQlOYWNpIChhbmQgQ2h1Y2spOiAKLQkKLQlOYWNpIHByZXNlbnRlZCB0aGUgdXNlLWNhc2UvZGVzaWduIGRvY3VtZW50IGhlIGhhcyBpbiBkZXZlbG9wbWVudCBkaXJlY3RvcnksIAotCXByb2plY3RsYXlvdXQtbm1kLnBwdC4gCi0JCi0JQ2h1Y2sgd2lsbCBwdXQgaGlzIHJlc3BvbnNlIHRvIHRoaXMgZG9jdW1lbnQgaW4gZGV2ZWxvcG1lbnQgZGlyZWN0b3J5Ci0JYXMgd2VsbC4gKFRoZSBnaXN0IG9mIHdoaWNoIGlzIGEgY2VydGFpbiByb2xlIG91dCBvZiB3aGF0J3MgZmVhc2libGUgCi0Jd2hlbiwgYW5kIHNvbWUgbWVudGlvbiBvZiBzdWNjZXNzZXMgaW4gcHJvdG90eXBpbmcgY29tcGxleCBsYXlvdXRzIHVzaW5nIAotCWxpbmtlZCBmb2xkZXJzL3Jlc291cmNlcy4gKEkgZ290IHRoZSBpbXByZXNzaW9uIHRoYXQgZm9yIG1haW4gZmxleGlibGUgCi0JcHJvamVjdHMsIHRoZXJlIG1heSBiZSBubyBuZWVkIGZvciBpbXByb3ZlZCBFY2xpcHNlIGJhc2Ugc3VwcG9ydCwgYnV0IAotCW5lZWQgdG8gY29uZmlybSB0aGF0IHdpdGggQ2h1Y2gvTmFjaSBhcyB0aGlzIHdvcmsgcHJvZ3Jlc3Nlcy4gCi0JCi0JSXQgd2FzIGFncmVlZCBhICJjb25jZXB0cyIgZG9jdW1lbnQgaXMgbmVlZGVkIGhlcmUgdG9vLCBidXQgCi0Jd2FzIGRlY2lkZWQgdG8gd2FpdCB1bnRpbCB3ZSBzZWUgSmltJ3MgZHJhZnQgb2Ygc2VydmVyIHBhcnQsIAotCXRvIGRlY2lkZSBob3cgYmVzdCB0byBwcm9jZWVkLiAKLQkKLQkKLQlBZ2VuZGEgZm9yIG5leHQgd2VlazoKLQkKLQlKaW0gd2lsbCBkaXNjdXNzL3ByZXNlbnQgc2VydmVycy9tb2R1bGVzIGNvbmNlcHRzIGRvY3VtZW50LiAKLQkKXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9kZXZlbG9wbWVudC9tZWV0aW5nbm90ZXMvMjAwNDExMDQudHh0IGIvZGV2ZWxvcG1lbnQvbWVldGluZ25vdGVzLzIwMDQxMTA0LnR4dApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYTkwNmFmZC4uMDAwMDAwMAotLS0gYS9kZXZlbG9wbWVudC9tZWV0aW5nbm90ZXMvMjAwNDExMDQudHh0CisrKyAvZGV2L251bGwKQEAgLTEsMTUgKzAsMCBAQAotMjAwNDExMDQgQWdlbmRhCi0KLQlBdHRlbmRlZXM6IAotCi0JRGlzY3VzcyBKaW0gYW5kIFRpbSdzIGNvbmNlcHQgZG9jdW1lbnRzICh3b3JrIGluIHByb2dyZXNzKQotCXNlZQotCW1vZHVsZXNfYW5kX3NlcnZlcnMuaHRtbCwgYW5kIAotCXdlYl90b29sc19zZXJ2ZXJfYXBpX2NvbmNlcHRzLmh0bWwKLQkoYm90aCBpbiAvanN0L2NvbXBvbmVudHMvc2VydmVyL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvICkKLQkKLQlQcm9jZXNzIGZvciByb2xsaW5nIG91dCBBUEkgY2hhbmdlcy4gCi0JCi0JTmV4dCBTdGVwcz8KLQkKLQkKXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9kZXZlbG9wbWVudC9tZWV0aW5nbm90ZXMvMjAwNDExMTgudHh0IGIvZGV2ZWxvcG1lbnQvbWVldGluZ25vdGVzLzIwMDQxMTE4LnR4dApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNjJkZjFhYS4uMDAwMDAwMAotLS0gYS9kZXZlbG9wbWVudC9tZWV0aW5nbm90ZXMvMjAwNDExMTgudHh0CisrKyAvZGV2L251bGwKQEAgLTEsMjMgKzAsMCBAQAotMjAwNDExMTggU2VydmVyL01vZHVsZSByZXZpZXcgbWVldGluZyBub3RlcwotCi1BdHRlbmRlZXM6IERhdmlkLCBUaW0sIENodWNrLCBKZWVtLCBhbmQgP0ppbT8sIGZyb20gU0FQCi0KLUNodWNrOiBmbGV4aWJsZSBwcm9qZWN0OiB3aWxsIHJldmlzZSBkb2N1bWVudCBieSBuZXh0IHdlZWsuCi0KLVRpbTogd29ya2luZyBpbiBzZXAuIHN0cmVhbSBmb3IgQVBJIGltcHJvdmVtZW50cy4gCi0Jd2lsbCBiZSBhdCBhdCBsZWFzdCBzb21lIG1lcmdlIHBvaW50IGZvciAxMi8yLCBzbyAKLQlzaG9ydGx5IGFmdGVyIHRoZSBpbnRlZ3JhdGlvbiBidWlsZCwgaGUgd2lsbCBtZXJnZSAKLQliYWNrIHRvIGhlYWQsIHNvIGNsaWVudHMgY2FuIHVwZGF0ZS9jaGFuZ2UgaW4gdGltZSBmb3IgCi0JMTIvMTAgbWlsZXN0b25lIGN1dC1vZmYgZGF0ZS4gCi0JCi1KZWVtOiBtZW50aW9uZWQgdGhhdCBpcy93aGVuIHdlIHVzZSBpbnRlbmFsIEFQSXMsIGFuZCBoYXZlIAotb3BlbmVkIGZlYXR1cmUgcmVxdWVzdCBvbiBiYXNlLCB3ZSBzaG91bGQgYWRkIGhpbSBvbiBDQy4KLQotTmV4dCBNZWV0aW5nOgotIDEyLzIKLSAJQWdlbmRhOiAKLSAJCQlUaW0gd2lsbCBkaXNjdXNzL2Rlc2NyaWJlIG5ldyBBUEkncyBhbmQgZGVzaWduCi0gCSAgICAgICAgQ2h1Y2sgd2lsbCBkaXNjdXNzIGFuZCBkZXNjcmliZSBsYXRlc3QgCi0gCSAgICAgICAgCWZsZXhpYmxlIHByb2plY3QgZGVzaWduIGRvY3VtZW50LgotCi0KZGlmZiAtLWdpdCBhL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvRmxleGlibGVQcm9qZWN0Q29uY2VwdHMuaHRtIGIvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy9GbGV4aWJsZVByb2plY3RDb25jZXB0cy5odG0KZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDMxZmI3MTUuLjAwMDAwMDAKLS0tIGEvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy9GbGV4aWJsZVByb2plY3RDb25jZXB0cy5odG0KKysrIC9kZXYvbnVsbApAQCAtMSw5NTggKzAsMCBAQAotPGh0bWwgeG1sbnM6dj0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTp2bWwiCi14bWxuczpvPSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTpvZmZpY2UiCi14bWxuczp3PSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTp3b3JkIgoteG1sbnM6c3QxPSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTpzbWFydHRhZ3MiCi14bWxucz0iaHR0cDovL3d3dy53My5vcmcvVFIvUkVDLWh0bWw0MCI+Ci0KLTxoZWFkPgotPG1ldGEgaHR0cC1lcXVpdj1Db250ZW50LVR5cGUgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXdpbmRvd3MtMTI1MiI+Ci08bWV0YSBuYW1lPVByb2dJZCBjb250ZW50PVdvcmQuRG9jdW1lbnQ+Ci08bWV0YSBuYW1lPUdlbmVyYXRvciBjb250ZW50PSJNaWNyb3NvZnQgV29yZCAxMCI+Ci08bWV0YSBuYW1lPU9yaWdpbmF0b3IgY29udGVudD0iTWljcm9zb2Z0IFdvcmQgMTAiPgotPGxpbmsgcmVsPUZpbGUtTGlzdCBocmVmPSJGbGV4aWJsZVByb2plY3RDb25jZXB0c19maWxlcy9maWxlbGlzdC54bWwiPgotPGxpbmsgcmVsPUVkaXQtVGltZS1EYXRhIGhyZWY9IkZsZXhpYmxlUHJvamVjdENvbmNlcHRzX2ZpbGVzL2VkaXRkYXRhLm1zbyI+Ci08IS0tW2lmICFtc29dPgotPHN0eWxlPgotdlw6KiB7YmVoYXZpb3I6dXJsKCNkZWZhdWx0I1ZNTCk7fQotb1w6KiB7YmVoYXZpb3I6dXJsKCNkZWZhdWx0I1ZNTCk7fQotd1w6KiB7YmVoYXZpb3I6dXJsKCNkZWZhdWx0I1ZNTCk7fQotLnNoYXBlIHtiZWhhdmlvcjp1cmwoI2RlZmF1bHQjVk1MKTt9Ci08L3N0eWxlPgotPCFbZW5kaWZdLS0+Ci08dGl0bGU+UHJvYmxlbXMgdGhhdCBhcmUgb2J2aW91c2x5IHVzOjwvdGl0bGU+Ci08bzpTbWFydFRhZ1R5cGUgbmFtZXNwYWNldXJpPSJ1cm46c2NoZW1hcy1taWNyb3NvZnQtY29tOm9mZmljZTpzbWFydHRhZ3MiCi0gbmFtZT0icGxhY2UiLz4KLTxvOlNtYXJ0VGFnVHlwZSBuYW1lc3BhY2V1cmk9InVybjpzY2hlbWFzLW1pY3Jvc29mdC1jb206b2ZmaWNlOnNtYXJ0dGFncyIKLSBuYW1lPSJDaXR5Ii8+Ci08IS0tW2lmIGd0ZSBtc28gOV0+PHhtbD4KLSA8bzpEb2N1bWVudFByb3BlcnRpZXM+Ci0gIDxvOkF1dGhvcj5NaWNoYWVsIEQuIEVsZGVyPC9vOkF1dGhvcj4KLSAgPG86TGFzdEF1dGhvcj5jYnJpZGdoYTwvbzpMYXN0QXV0aG9yPgotICA8bzpSZXZpc2lvbj4yPC9vOlJldmlzaW9uPgotICA8bzpUb3RhbFRpbWU+NjwvbzpUb3RhbFRpbWU+Ci0gIDxvOkxhc3RQcmludGVkPjIwMDQtMTEtMTFUMTY6Mjc6MDBaPC9vOkxhc3RQcmludGVkPgotICA8bzpDcmVhdGVkPjIwMDQtMTEtMTFUMTg6MDU6MDBaPC9vOkNyZWF0ZWQ+Ci0gIDxvOkxhc3RTYXZlZD4yMDA0LTExLTExVDE4OjA1OjAwWjwvbzpMYXN0U2F2ZWQ+Ci0gIDxvOlBhZ2VzPjE8L286UGFnZXM+Ci0gIDxvOldvcmRzPjE1MDI8L286V29yZHM+Ci0gIDxvOkNoYXJhY3RlcnM+ODU2MjwvbzpDaGFyYWN0ZXJzPgotICA8bzpDb21wYW55PklCTTwvbzpDb21wYW55PgotICA8bzpMaW5lcz43MTwvbzpMaW5lcz4KLSAgPG86UGFyYWdyYXBocz4yMDwvbzpQYXJhZ3JhcGhzPgotICA8bzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4xMDA0NDwvbzpDaGFyYWN0ZXJzV2l0aFNwYWNlcz4KLSAgPG86VmVyc2lvbj4xMC40MjE5PC9vOlZlcnNpb24+Ci0gPC9vOkRvY3VtZW50UHJvcGVydGllcz4KLTwveG1sPjwhW2VuZGlmXS0tPjwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDx3OldvcmREb2N1bWVudD4KLSAgPHc6Q29tcGF0aWJpbGl0eT4KLSAgIDx3OkJyZWFrV3JhcHBlZFRhYmxlcy8+Ci0gICA8dzpTbmFwVG9HcmlkSW5DZWxsLz4KLSAgIDx3OldyYXBUZXh0V2l0aFB1bmN0Lz4KLSAgIDx3OlVzZUFzaWFuQnJlYWtSdWxlcy8+Ci0gIDwvdzpDb21wYXRpYmlsaXR5PgotICA8dzpCcm93c2VyTGV2ZWw+TWljcm9zb2Z0SW50ZXJuZXRFeHBsb3JlcjQ8L3c6QnJvd3NlckxldmVsPgotIDwvdzpXb3JkRG9jdW1lbnQ+Ci08L3htbD48IVtlbmRpZl0tLT48IS0tW2lmICFtc29dPjxvYmplY3QKLSBjbGFzc2lkPSJjbHNpZDozODQ4MTgwNy1DQTBFLTQyRDItQkYzOS1CMzNBRjEzNUNDNEQiIGlkPWllb291aT48L29iamVjdD4KLTxzdHlsZT4KLXN0MVw6KntiZWhhdmlvcjp1cmwoI2llb291aSkgfQotPC9zdHlsZT4KLTwhW2VuZGlmXS0tPgotPHN0eWxlPgotPCEtLQotIC8qIEZvbnQgRGVmaW5pdGlvbnMgKi8KLSBAZm9udC1mYWNlCi0Je2ZvbnQtZmFtaWx5OldpbmdkaW5nczsKLQlwYW5vc2UtMTo1IDAgMCAwIDAgMCAwIDAgMCAwOwotCW1zby1mb250LWNoYXJzZXQ6MjsKLQltc28tZ2VuZXJpYy1mb250LWZhbWlseTphdXRvOwotCW1zby1mb250LXBpdGNoOnZhcmlhYmxlOwotCW1zby1mb250LXNpZ25hdHVyZTowIDI2ODQzNTQ1NiAwIDAgLTIxNDc0ODM2NDggMDt9Ci1AZm9udC1mYWNlCi0Je2ZvbnQtZmFtaWx5OlRhaG9tYTsKLQlwYW5vc2UtMToyIDExIDYgNCAzIDUgNCA0IDIgNDsKLQltc28tZm9udC1jaGFyc2V0OjA7Ci0JbXNvLWdlbmVyaWMtZm9udC1mYW1pbHk6c3dpc3M7Ci0JbXNvLWZvbnQtcGl0Y2g6dmFyaWFibGU7Ci0JbXNvLWZvbnQtc2lnbmF0dXJlOjE2Mjc0MjEzMTkgLTIxNDc0ODM2NDggOCAwIDY2MDQ3IDA7fQotIC8qIFN0eWxlIERlZmluaXRpb25zICovCi0gcC5Nc29Ob3JtYWwsIGxpLk1zb05vcm1hbCwgZGl2Lk1zb05vcm1hbAotCXttc28tc3R5bGUtcGFyZW50OiIiOwotCW1hcmdpbjowaW47Ci0JbWFyZ2luLWJvdHRvbTouMDAwMXB0OwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTIuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iOwotCW1zby1mYXJlYXN0LWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLWgzCi0Je21zby1tYXJnaW4tdG9wLWFsdDphdXRvOwotCW1hcmdpbi1yaWdodDowaW47Ci0JbXNvLW1hcmdpbi1ib3R0b20tYWx0OmF1dG87Ci0JbWFyZ2luLWxlZnQ6MGluOwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQltc28tb3V0bGluZS1sZXZlbDozOwotCWZvbnQtc2l6ZToxMy41cHQ7Ci0JZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotYTpsaW5rLCBzcGFuLk1zb0h5cGVybGluawotCXtjb2xvcjpibHVlOwotCXRleHQtZGVjb3JhdGlvbjp1bmRlcmxpbmU7Ci0JdGV4dC11bmRlcmxpbmU6c2luZ2xlO30KLWE6dmlzaXRlZCwgc3Bhbi5Nc29IeXBlcmxpbmtGb2xsb3dlZAotCXtjb2xvcjpwdXJwbGU7Ci0JdGV4dC1kZWNvcmF0aW9uOnVuZGVybGluZTsKLQl0ZXh0LXVuZGVybGluZTpzaW5nbGU7fQotQHBhZ2UgU2VjdGlvbjEKLQl7c2l6ZTo4LjVpbiAxMS4waW47Ci0JbWFyZ2luOjEuMGluIDEuMjVpbiAxLjBpbiAxLjI1aW47Ci0JbXNvLWhlYWRlci1tYXJnaW46LjVpbjsKLQltc28tZm9vdGVyLW1hcmdpbjouNWluOwotCW1zby1wYXBlci1zb3VyY2U6MDt9Ci1kaXYuU2VjdGlvbjEKLQl7cGFnZTpTZWN0aW9uMTt9Ci0gLyogTGlzdCBEZWZpbml0aW9ucyAqLwotIEBsaXN0IGwwCi0Je21zby1saXN0LWlkOjEzMjUyOTE1MTsKLQltc28tbGlzdC10eXBlOmh5YnJpZDsKLQltc28tbGlzdC10ZW1wbGF0ZS1pZHM6MTA5MzQ0MjkxMCA2NzY5ODcwOSA2NzY5ODcxMyA2NzY5ODcxNSA2NzY5ODcwMyA2NzY5ODcxMyA2NzY5ODcxNSA2NzY5ODcwMyA2NzY5ODcxMyA2NzY5ODcxNTt9Ci1AbGlzdCBsMDpsZXZlbDEKLQl7bXNvLWxldmVsLW51bWJlci1mb3JtYXQ6YWxwaGEtdXBwZXI7Ci0JbXNvLWxldmVsLXRhYi1zdG9wOi41aW47Ci0JbXNvLWxldmVsLW51bWJlci1wb3NpdGlvbjpsZWZ0OwotCXRleHQtaW5kZW50Oi0uMjVpbjt9Ci1AbGlzdCBsMDpsZXZlbDIKLQl7bXNvLWxldmVsLW51bWJlci1mb3JtYXQ6YWxwaGEtbG93ZXI7Ci0JbXNvLWxldmVsLXRhYi1zdG9wOjEuMGluOwotCW1zby1sZXZlbC1udW1iZXItcG9zaXRpb246bGVmdDsKLQl0ZXh0LWluZGVudDotLjI1aW47fQotQGxpc3QgbDA6bGV2ZWwzCi0Je21zby1sZXZlbC1udW1iZXItZm9ybWF0OnJvbWFuLWxvd2VyOwotCW1zby1sZXZlbC10YWItc3RvcDoxLjVpbjsKLQltc28tbGV2ZWwtbnVtYmVyLXBvc2l0aW9uOnJpZ2h0OwotCXRleHQtaW5kZW50Oi05LjBwdDt9Ci1AbGlzdCBsMQotCXttc28tbGlzdC1pZDoyODg5NzQxNTk7Ci0JbXNvLWxpc3QtdHlwZTpoeWJyaWQ7Ci0JbXNvLWxpc3QtdGVtcGxhdGUtaWRzOjEwNDYxMDg4NjQgMTExMTc4NTQ0MCA2NzY5ODY5MSA2NzY5ODY5MyA2NzY5ODY4OSA2NzY5ODY5MSA2NzY5ODY5MyA2NzY5ODY4OSA2NzY5ODY5MSA2NzY5ODY5Mzt9Ci1AbGlzdCBsMTpsZXZlbDEKLQl7bXNvLWxldmVsLXN0YXJ0LWF0OjA7Ci0JbXNvLWxldmVsLW51bWJlci1mb3JtYXQ6YnVsbGV0OwotCW1zby1sZXZlbC10ZXh0Oi07Ci0JbXNvLWxldmVsLXRhYi1zdG9wOi43NWluOwotCW1zby1sZXZlbC1udW1iZXItcG9zaXRpb246bGVmdDsKLQltYXJnaW4tbGVmdDouNzVpbjsKLQl0ZXh0LWluZGVudDotLjI1aW47Ci0JZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7Ci0JbXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotQGxpc3QgbDIKLQl7bXNvLWxpc3QtaWQ6MzkxNjU5MjU1OwotCW1zby1saXN0LXR5cGU6aHlicmlkOwotCW1zby1saXN0LXRlbXBsYXRlLWlkczotMTg4MTYyMTE2NiA2NzY5ODY4OSA2NzY5ODY5MSA2NzY5ODY5MyA2NzY5ODY4OSA2NzY5ODY5MSA2NzY5ODY5MyA2NzY5ODY4OSA2NzY5ODY5MSA2NzY5ODY5Mzt9Ci1AbGlzdCBsMjpsZXZlbDEKLQl7bXNvLWxldmVsLW51bWJlci1mb3JtYXQ6YnVsbGV0OwotCW1zby1sZXZlbC10ZXh0OlxGMEI3OwotCW1zby1sZXZlbC10YWItc3RvcDouNWluOwotCW1zby1sZXZlbC1udW1iZXItcG9zaXRpb246bGVmdDsKLQl0ZXh0LWluZGVudDotLjI1aW47Ci0JZm9udC1mYW1pbHk6U3ltYm9sO30KLUBsaXN0IGwzCi0Je21zby1saXN0LWlkOjg1OTUwODUxNzsKLQltc28tbGlzdC10eXBlOmh5YnJpZDsKLQltc28tbGlzdC10ZW1wbGF0ZS1pZHM6MjA5NDA0NTMwNCA2NzY5ODY4OSA2NzY5ODY5MSA2NzY5ODY5MyA2NzY5ODY4OSA2NzY5ODY5MSA2NzY5ODY5MyA2NzY5ODY4OSA2NzY5ODY5MSA2NzY5ODY5Mzt9Ci1AbGlzdCBsMzpsZXZlbDEKLQl7bXNvLWxldmVsLW51bWJlci1mb3JtYXQ6YnVsbGV0OwotCW1zby1sZXZlbC10ZXh0OlxGMEI3OwotCW1zby1sZXZlbC10YWItc3RvcDoxLjVpbjsKLQltc28tbGV2ZWwtbnVtYmVyLXBvc2l0aW9uOmxlZnQ7Ci0JbWFyZ2luLWxlZnQ6MS41aW47Ci0JdGV4dC1pbmRlbnQ6LS4yNWluOwotCWZvbnQtZmFtaWx5OlN5bWJvbDt9Ci1AbGlzdCBsNAotCXttc28tbGlzdC1pZDoxMDA2NTk0ODY0OwotCW1zby1saXN0LXR5cGU6aHlicmlkOwotCW1zby1saXN0LXRlbXBsYXRlLWlkczotNzk0ODkwMzg0IDY2ODA4MTM4MCA2NzY5ODY5MSA2NzY5ODY5MyA2NzY5ODY4OSA2NzY5ODY5MSA2NzY5ODY5MyA2NzY5ODY4OSA2NzY5ODY5MSA2NzY5ODY5Mzt9Ci1AbGlzdCBsNDpsZXZlbDEKLQl7bXNvLWxldmVsLXN0YXJ0LWF0OjA7Ci0JbXNvLWxldmVsLW51bWJlci1mb3JtYXQ6YnVsbGV0OwotCW1zby1sZXZlbC10ZXh0OlxGMDZFOwotCW1zby1sZXZlbC10YWItc3RvcDouNzVpbjsKLQltc28tbGV2ZWwtbnVtYmVyLXBvc2l0aW9uOmxlZnQ7Ci0JbWFyZ2luLWxlZnQ6Ljc1aW47Ci0JdGV4dC1pbmRlbnQ6LS4yNWluOwotCWZvbnQtZmFtaWx5OldpbmdkaW5nczsKLQltc28tZmFyZWFzdC1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjsKLQltc28tYmlkaS1mb250LWZhbWlseToiVGltZXMgTmV3IFJvbWFuIjt9Ci1AbGlzdCBsNDpsZXZlbDIKLQl7bXNvLWxldmVsLW51bWJlci1mb3JtYXQ6YnVsbGV0OwotCW1zby1sZXZlbC10ZXh0Om87Ci0JbXNvLWxldmVsLXRhYi1zdG9wOjEuMjVpbjsKLQltc28tbGV2ZWwtbnVtYmVyLXBvc2l0aW9uOmxlZnQ7Ci0JbWFyZ2luLWxlZnQ6MS4yNWluOwotCXRleHQtaW5kZW50Oi0uMjVpbjsKLQlmb250LWZhbWlseToiQ291cmllciBOZXciO30KLUBsaXN0IGw1Ci0Je21zby1saXN0LWlkOjE0MDI4MjkxOTA7Ci0JbXNvLWxpc3QtdHlwZTpoeWJyaWQ7Ci0JbXNvLWxpc3QtdGVtcGxhdGUtaWRzOi0xNTMxMjUxNzM0IDY3Njk4Njg5IDY3Njk4NjkxIDY3Njk4NjkzIDY3Njk4Njg5IDY3Njk4NjkxIDY3Njk4NjkzIDY3Njk4Njg5IDY3Njk4NjkxIDY3Njk4NjkzO30KLUBsaXN0IGw1OmxldmVsMQotCXttc28tbGV2ZWwtbnVtYmVyLWZvcm1hdDpidWxsZXQ7Ci0JbXNvLWxldmVsLXRleHQ6XEYwQjc7Ci0JbXNvLWxldmVsLXRhYi1zdG9wOjEuMGluOwotCW1zby1sZXZlbC1udW1iZXItcG9zaXRpb246bGVmdDsKLQltYXJnaW4tbGVmdDoxLjBpbjsKLQl0ZXh0LWluZGVudDotLjI1aW47Ci0JZm9udC1mYW1pbHk6U3ltYm9sO30KLUBsaXN0IGw2Ci0Je21zby1saXN0LWlkOjE0NTcyOTEyMDI7Ci0JbXNvLWxpc3QtdHlwZTpoeWJyaWQ7Ci0JbXNvLWxpc3QtdGVtcGxhdGUtaWRzOi0yNjU2Njk0NDggNjc2OTg2ODkgNjc2OTg2OTEgNjc2OTg2OTMgNjc2OTg2ODkgNjc2OTg2OTEgNjc2OTg2OTMgNjc2OTg2ODkgNjc2OTg2OTEgNjc2OTg2OTM7fQotQGxpc3QgbDY6bGV2ZWwxCi0Je21zby1sZXZlbC1udW1iZXItZm9ybWF0OmJ1bGxldDsKLQltc28tbGV2ZWwtdGV4dDpcRjBCNzsKLQltc28tbGV2ZWwtdGFiLXN0b3A6MS41aW47Ci0JbXNvLWxldmVsLW51bWJlci1wb3NpdGlvbjpsZWZ0OwotCW1hcmdpbi1sZWZ0OjEuNWluOwotCXRleHQtaW5kZW50Oi0uMjVpbjsKLQlmb250LWZhbWlseTpTeW1ib2w7fQotQGxpc3QgbDcKLQl7bXNvLWxpc3QtaWQ6MTgzODM3Njk3NTsKLQltc28tbGlzdC10eXBlOmh5YnJpZDsKLQltc28tbGlzdC10ZW1wbGF0ZS1pZHM6LTE0NjA3NzY5MzAgNjc2OTg2ODkgNjc2OTg2OTEgNjc2OTg2OTMgNjc2OTg2ODkgNjc2OTg2OTEgNjc2OTg2OTMgNjc2OTg2ODkgNjc2OTg2OTEgNjc2OTg2OTM7fQotQGxpc3QgbDc6bGV2ZWwxCi0Je21zby1sZXZlbC1udW1iZXItZm9ybWF0OmJ1bGxldDsKLQltc28tbGV2ZWwtdGV4dDpcRjBCNzsKLQltc28tbGV2ZWwtdGFiLXN0b3A6MS4waW47Ci0JbXNvLWxldmVsLW51bWJlci1wb3NpdGlvbjpsZWZ0OwotCW1hcmdpbi1sZWZ0OjEuMGluOwotCXRleHQtaW5kZW50Oi0uMjVpbjsKLQlmb250LWZhbWlseTpTeW1ib2w7fQotb2wKLQl7bWFyZ2luLWJvdHRvbTowaW47fQotdWwKLQl7bWFyZ2luLWJvdHRvbTowaW47fQotLS0+Ci08L3N0eWxlPgotPCEtLVtpZiBndGUgbXNvIDEwXT4KLTxzdHlsZT4KLSAvKiBTdHlsZSBEZWZpbml0aW9ucyAqLwotIHRhYmxlLk1zb05vcm1hbFRhYmxlCi0Je21zby1zdHlsZS1uYW1lOiJUYWJsZSBOb3JtYWwiOwotCW1zby10c3R5bGUtcm93YmFuZC1zaXplOjA7Ci0JbXNvLXRzdHlsZS1jb2xiYW5kLXNpemU6MDsKLQltc28tc3R5bGUtbm9zaG93OnllczsKLQltc28tc3R5bGUtcGFyZW50OiIiOwotCW1zby1wYWRkaW5nLWFsdDowaW4gNS40cHQgMGluIDUuNHB0OwotCW1zby1wYXJhLW1hcmdpbjowaW47Ci0JbXNvLXBhcmEtbWFyZ2luLWJvdHRvbTouMDAwMXB0OwotCW1zby1wYWdpbmF0aW9uOndpZG93LW9ycGhhbjsKLQlmb250LXNpemU6MTAuMHB0OwotCWZvbnQtZmFtaWx5OiJUaW1lcyBOZXcgUm9tYW4iO30KLXRhYmxlLk1zb1RhYmxlR3JpZAotCXttc28tc3R5bGUtbmFtZToiVGFibGUgR3JpZCI7Ci0JbXNvLXRzdHlsZS1yb3diYW5kLXNpemU6MDsKLQltc28tdHN0eWxlLWNvbGJhbmQtc2l6ZTowOwotCWJvcmRlcjpzb2xpZCB3aW5kb3d0ZXh0IDEuMHB0OwotCW1zby1ib3JkZXItYWx0OnNvbGlkIHdpbmRvd3RleHQgLjVwdDsKLQltc28tcGFkZGluZy1hbHQ6MGluIDUuNHB0IDBpbiA1LjRwdDsKLQltc28tYm9yZGVyLWluc2lkZWg6LjVwdCBzb2xpZCB3aW5kb3d0ZXh0OwotCW1zby1ib3JkZXItaW5zaWRldjouNXB0IHNvbGlkIHdpbmRvd3RleHQ7Ci0JbXNvLXBhcmEtbWFyZ2luOjBpbjsKLQltc28tcGFyYS1tYXJnaW4tYm90dG9tOi4wMDAxcHQ7Ci0JbXNvLXBhZ2luYXRpb246d2lkb3ctb3JwaGFuOwotCWZvbnQtc2l6ZToxMC4wcHQ7Ci0JZm9udC1mYW1pbHk6IlRpbWVzIE5ldyBSb21hbiI7fQotPC9zdHlsZT4KLTwhW2VuZGlmXS0tPjwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDxvOnNoYXBlZGVmYXVsdHMgdjpleHQ9ImVkaXQiIHNwaWRtYXg9IjIwNTAiLz4KLTwveG1sPjwhW2VuZGlmXS0tPjwhLS1baWYgZ3RlIG1zbyA5XT48eG1sPgotIDxvOnNoYXBlbGF5b3V0IHY6ZXh0PSJlZGl0Ij4KLSAgPG86aWRtYXAgdjpleHQ9ImVkaXQiIGRhdGE9IjEiLz4KLSA8L286c2hhcGVsYXlvdXQ+PC94bWw+PCFbZW5kaWZdLS0+Ci08L2hlYWQ+Ci0KLTxib2R5IGxhbmc9RU4tVVMgbGluaz1ibHVlIHZsaW5rPXB1cnBsZSBzdHlsZT0ndGFiLWludGVydmFsOi41aW4nPgotCi08ZGl2IGNsYXNzPVNlY3Rpb24xPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+VGhlIEoyRUUgRmxleGlibGUgUHJvamVjdCBDb25jZXB0cyBEb2N1bWVudGF0aW9uPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PG86cD4mbmJzcDs8L286cD48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD5UaGUgZ29hbCBvZiB0aGlzIGRvY3VtZW50IGlzIHRvIHNoYXJlIHNvbWUgaW5pdGlhbCBpZGVhcwotdGhhdCB3aWxsIGhlbHAgc2hhcGUgdGhlIEVjbGlwc2UgV2ViIFRvb2xzIChXVFApIEoyRUUgcHJvamVjdCBhcHBsaWNhdGlvbiBtb2RlbAotYW5kIGl0cyBpbXBsZW1lbnRhdGlvbi4gV2UgaW5pdGlhbGx5IHBsYW5uZWQgdG8gcHVyc3VlIHRoaXMgZWZmb3J0IGFzIGEgZm9ybWFsCi1yZXF1aXJlbWVudHMgZ2F0aGVyaW5nIGFuZCBkb2N1bWVudGF0aW9uIHByb2Nlc3MuIEJ1dCBvbmNlIHdlIGJlZ2FuIGFuYWx5emluZwotdGhlIHByb2JsZW0gc3BhY2UgaXQgd2FzIGNsZWFyIHRoYXQgdGhlcmUgaXMgbm8gY29tbW9uIEoyRUUgcHJvamVjdCBtb2RlbCB1c2VkCi13aXRoaW4gdGhlIEoyRUUgZGV2ZWxvcG1lbnQgY29tbXVuaXR5LiBTdGF0ZWQgYW5vdGhlciB3YXksIGFsbCBjdXJyZW50IEoyRUUKLXByb2plY3QgbW9kZWxzIGFyZSBhZCBob2MuIEF0IG1vc3QsIHRoZSBKMkVFIGFwcGxpY2F0aW9uIGRlcGxveW1lbnQgbW9kZWwsCi1kZWZpbmVkIGluIHRoZSBKMkVFIHNwZWNpZmljYXRpb24sIGlzIHRoZSBvbmx5IGNvbW1vbiByZWZlcmVuY2Ugc3RydWN0dXJlIGFuZAotaXQgb25seSBzcGVjaWZpZXMgdG8gdGhlIHJ1bnRpbWUgYXJjaGl2ZSBmb3JtIG9mIHZhbGlkIEoyRUUgYXBwbGljYXRpb25zLiBXaXRoCi10aGF0IGFzIG91ciBzdGFydGluZyBwb2ludCwgd2UgY29uY2x1ZGVkIHRoYXQgcmF0aGVyIHRoYW4gYXR0ZW1wdCB0byBkcmFmdCBhCi1jb252ZW50aW9uYWwgcmVxdWlyZW1lbnRzIGRvY3VtZW50LCBpdCB3b3VsZCBiZSBtb3JlIGJlbmVmaWNpYWwgdG8gaW5pdGlhdGUgYQotZGlzY3Vzc2lvbiBvZiBpZGVhcyBhbW9uZyB0aGUga2V5IFdUUCBwYXJ0aWNpcGFudHMgdGhhdCBjYW4gc2VydmUgYXMgdGhlCi1jYXRhbHlzdCBmb3IgYSBKMkVFIGFwcGxpY2F0aW9uIHByb2plY3QgcmVxdWlyZW1lbnRzIGFuZCBzdWJzZXF1ZW50Ci1hcmNoaXRlY3R1cmUgYW5kIGltcGxlbWVudGF0aW9uLjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjxvOnA+Jm5ic3A7PC9vOnA+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+VGhlIGNvbnRlbnRzIG9mIHRoaXMgZG9jdW1lbnQgYXJlIHJlcHJlc2VudGF0aXZlIG9mIHRoZQotZnV0dXJlIGRpcmVjdGlvbi4gSG93ZXZlciwgc29tZSBvZiB0aGlzIGZ1bmN0aW9uYWxpdHkgZGVzY3JpYmVkIGlzCi1yZXByZXNlbnRhdGl2ZSBvZiBvdXIgY3VycmVudCBzdGF0ZS48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48bzpwPiZuYnNwOzwvbzpwPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjxzcGFuIGxhbmc9VFIgc3R5bGU9J21zby1hbnNpLWxhbmd1YWdlOlRSJz5UaGVyZSBhcmUgc2V2ZXJhbAotdXNlIGNhc2VzIGRlc2NyaWJlZCBpbiB0aGUgVXNlIENhc2UgU2NlbmFyaW8gUG93ZXJwb2ludCBTbGlkZXMuIFdoZXJlIHJlbGV2YW50LAotdGhlIHJlbGF0aW9uc2hpcCBvZiB0aGUgY29uY2VwdHMgZGVzY3JpYmVkIGluIHRoaXMgZG9jdW1lbnQgYW5kIHRoZSBzY2VuYXJpbwotc2xpZGVzIGFyZSBoaWdobGlnaHRlZC48L3NwYW4+PG86cD48L286cD48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6LjI1aW4nPjxvOnA+Jm5ic3A7PC9vOnA+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PHNwYW4gbGFuZz1UUiBzdHlsZT0nbXNvLWFuc2ktbGFuZ3VhZ2U6VFInPkEgPGIKLXN0eWxlPSdtc28tYmlkaS1mb250LXdlaWdodDpub3JtYWwnPnByb2plY3Q8L2I+IGlzIGEgdHlwZSBvZiByZXNvdXJjZSB3aGljaAotZ3JvdXBzIHJlc291cmNlcyBpbnRvIGJ1aWxkYWJsZSwgcmV1c2FibGUgdW5pdHM8L3NwYW4+IC0gSmF2YSA8c3BhbiBsYW5nPVRSCi1zdHlsZT0nbXNvLWFuc2ktbGFuZ3VhZ2U6VFInPnByb2plY3QgcmVzb3VyY2U8L3NwYW4+cyBhcmUgZGVmaW5lZDxzcGFuIGxhbmc9VFIKLXN0eWxlPSdtc28tYW5zaS1sYW5ndWFnZTpUUic+IGluIHRlcm1zIG9mIEphdmE8c3BhbiBzdHlsZT0nbXNvLXNwYWNlcnVuOnllcyc+oAotPC9zcGFuPmVsZW1lbnRzIHN1Y2ggYXMgcGFja2FnZSBmcmFnbWVudHMsIHR5cGVzLCBtZXRob2RzIGFuZCBmaWVsZHMuPG86cD48L286cD48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PHNwYW4gbGFuZz1UUiBzdHlsZT0nbXNvLWFuc2ktbGFuZ3VhZ2U6VFInPjxvOnA+Jm5ic3A7PC9vOnA+PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjxzcGFuIGxhbmc9VFIgc3R5bGU9J21zby1hbnNpLWxhbmd1YWdlOlRSJz5UaGUgc2NlbmFyaW8KLXNsaWRlcyBoaWdobGlnaHQgdGhlIGZvbGxvd2luZyB0eXBlcyBvZiB1c2UgY2FzZXM6PG86cD48L286cD48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PHNwYW4gbGFuZz1UUiBzdHlsZT0nbXNvLWFuc2ktbGFuZ3VhZ2U6VFInPjxvOnA+Jm5ic3A7PC9vOnA+PC9zcGFuPjwvcD4KLQotPHVsIHN0eWxlPSdtYXJnaW4tdG9wOjBpbicgdHlwZT1kaXNjPgotIDxsaSBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21zby1saXN0OmwyIGxldmVsMSBsZm84O3RhYi1zdG9wczpsaXN0IC41aW4nPjxzcGFuCi0gICAgIGxhbmc9VFIgc3R5bGU9J21zby1hbnNpLWxhbmd1YWdlOlRSJz5TaW1wbGUgUHJvamVjdCAoY29udGFpbnMgb25lIG1vZHVsZQotICAgICBhbmQgb25lIERlcGxveSBTY2hlbWUpPG86cD48L286cD48L3NwYW4+PC9saT4KLSA8bGkgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtc28tbGlzdDpsMiBsZXZlbDEgbGZvODt0YWItc3RvcHM6bGlzdCAuNWluJz48c3BhbgotICAgICBsYW5nPVRSIHN0eWxlPSdtc28tYW5zaS1sYW5ndWFnZTpUUic+U2ltcGxlIENvbnRhaW5lciBQcm9qZWN0IChjb250YWlucyBvbmUKLSAgICAgb3IgbW9yZSBtb2R1bGVzLCBwb3NzaWJseSBtdWx0aXBsZSBEZXBsb3kgU2NoZW1lcyk8bzpwPjwvbzpwPjwvc3Bhbj48L2xpPgotIDxsaSBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21zby1saXN0OmwyIGxldmVsMSBsZm84O3RhYi1zdG9wczpsaXN0IC41aW4nPjxzcGFuCi0gICAgIGxhbmc9VFIgc3R5bGU9J21zby1hbnNpLWxhbmd1YWdlOlRSJz5BcHBsaWNhdGlvbiBQcm9qZWN0IChhcHBsaWNhdGlvbiBhbmQKLSAgICAgbW9kdWxlcyBjb250YWluZWQgaW4gdGhlIHNhbWU8c3BhbiBzdHlsZT0nbXNvLXNwYWNlcnVuOnllcyc+oAotICAgICA8L3NwYW4+U2ltcGxlIENvbnRhaW5lciBwcm9qZWN0KTxvOnA+PC9vOnA+PC9zcGFuPjwvbGk+Ci0gPGxpIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbXNvLWxpc3Q6bDIgbGV2ZWwxIGxmbzg7dGFiLXN0b3BzOmxpc3QgLjVpbic+PHNwYW4KLSAgICAgbGFuZz1UUiBzdHlsZT0nbXNvLWFuc2ktbGFuZ3VhZ2U6VFInPkFwcGxpY2F0aW9uIFByb2plY3QgVmFyaWF0aW9uIChhcHBsaWNhdGlvbgotICAgICBpbiBvbmUgU2ltcGxlIENvbnRhaW5lciBQcm9qZWN0IG1vZHVsZXMgbWF5IGJlIGluIG90aGVyIFNpbXBsZSBDb250YWluZXIKLSAgICAgcHJvamVjdHMpPG86cD48L286cD48L3NwYW4+PC9saT4KLSA8bGkgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtc28tbGlzdDpsMiBsZXZlbDEgbGZvODt0YWItc3RvcHM6bGlzdCAuNWluJz48c3BhbgotICAgICBsYW5nPVRSIHN0eWxlPSdtc28tYW5zaS1sYW5ndWFnZTpUUic+Q29tcG9zZWQgTW9kdWxlcyAoc3RheSB0dW5lZCAoYnVtIGJ1bQotICAgICBidW0pKTxvOnA+PC9vOnA+PC9zcGFuPjwvbGk+Ci08L3VsPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PHNwYW4gbGFuZz1UUiBzdHlsZT0nbXNvLWFuc2ktbGFuZ3VhZ2U6VFInPjxvOnA+Jm5ic3A7PC9vOnA+PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjxzcGFuIGxhbmc9VFIgc3R5bGU9J21zby1hbnNpLWxhbmd1YWdlOlRSJz5UaGUgSjJFRSBtb2R1bGUKLWRlZmluaXRpb25zIGJ1aWxkIG9uIHRoZSB1c2UgY2FzZSBjb25jZXB0cy4gQXMgZGlzY3Vzc2VkIGluIHRoZSB1c2UgY2FzZXMsIGEKLW1vZHVsZSBpcyBhIGNvbGxlY3Rpb24gb2YgZmlsZXMgaW4gYSBwcm9qZWN0LiBIb3dldmVyLCBmb3IgdGhlIHJlbWFpbmRlciBvZgotdGhpcyBkb2N1bWVudCwgdGhlIHRlcm0gYWJzdHJhY3QgbW9kdWxlIHdpbGwgcmVmZXIgdG8gYW4gaW50YW5naWJsZSBjb25jZXB0ICh0bwotYmUgZGVmaW5lZCBtb3JlIGV4cGxpY2l0bHkgbGF0ZXIgb24pLiBUaGUgYWJzdHJhY3QgbW9kdWxlIGNvbmNlcHQgcmVwcmVzZW50cwotdGhlIGFic3RyYWN0aW9uIG9mIGEgcGh5c2ljYWwgbW9kdWxlIGluIHRlcm1zIHRoYXQgY2FuIGJlIHVuZGVyc3Rvb2QKLXByb2dyYW1tYXRpY2FsbHkuIFRoZSBzcGVjaWZpY3Mgb2YgaG93IHRoZXNlIHByb2plY3RzPHNwYW4KLXN0eWxlPSdtc28tc3BhY2VydW46eWVzJz6gIDwvc3Bhbj5hcmUgY29uc3RydWN0ZWQgaXMgbm90IGltcG9ydGFudCB0byB0aGUKLWRpc2N1c3Npb24gb2YgbW9kdWxlcy48bzpwPjwvbzpwPjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48bzpwPiZuYnNwOzwvbzpwPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPkEgPGIgc3R5bGU9J21zby1iaWRpLWZvbnQtd2VpZ2h0Om5vcm1hbCc+cmVzb3VyY2U8L2I+IGlzIGEKLWFic3RyYWN0aW9uIHdoaWNoIGNvbnRhaW5zIG1vZGVsIGVsZW1lbnRzLiBBIDxiIHN0eWxlPSdtc28tYmlkaS1mb250LXdlaWdodDoKLW5vcm1hbCc+cmVzb3VyY2Ugc2V0IDwvYj5pcyBhIGNvbGxlY3Rpb24gb2YgcmVsYXRlZCBwZXJzaXN0ZW50IHJlc291cmNlcy4gVGhlCi1yZXNvdXJjZSBzZXQgbWFuYWdlcyB0aGUgY29sbGVjdGlvbiBvZiByZXNvdXJjZXMgYW5kIHByb2R1Y2VzIG5vdGlmaWNhdGlvbnMgZm9yCi1jaGFuZ2VzIHRvIHRoYXQgY29sbGVjdGlvbi4gQSA8YiBzdHlsZT0nbXNvLWJpZGktZm9udC13ZWlnaHQ6bm9ybWFsJz5wcm9qZWN0IHJlc291cmNlCi1zZXQgPC9iPmlzIGEgcmVzb3VyY2Ugc2V0IGRlZmluZWQgYXQgdGhlIHByb2plY3QgbGV2ZWwsIG1lYW5pbmcgdGhlIHByb2plY3QKLXJlc291cmNlIHNldCBtYW5hZ2VzIHRoZSBjb2xsZWN0aW9uIG9mIHJlc291cmNlcyBmb3IgdGhhdCBwcm9qZWN0LiBUaGVyZSBpcwotb25seSBvbmUgcHJvamVjdCByZXNvdXJjZSBzZXQgcGVyIHByb2plY3QsIGVuc3VyaW5nIGVhY2ggcmVzb3VyY2UgaXMgb25seQotbG9hZGVkIG9uY2Ugd2l0aGluIHRoZSB3b3Jrc3BhY2UuIEVhY2ggcmVzb3VyY2UgY29udGFpbmVkIGluIHRoZSBwcm9qZWN0Ci1yZXNvdXJjZSBzZXQgaGFzIGEgPGIgc3R5bGU9J21zby1iaWRpLWZvbnQtd2VpZ2h0Om5vcm1hbCc+cmVsYXRpdmUgVVJJLCA8L2I+d2hpY2g8Ygotc3R5bGU9J21zby1iaWRpLWZvbnQtd2VpZ2h0Om5vcm1hbCc+IDwvYj5pcyBhIHBhcnRpYWwgVVJJIHdpdGggcmVzcGVjdCB0byBvcgotcmVsYXRpdmUgdG8gdGhlIHByb2plY3QuIEEgPGIgc3R5bGU9J21zby1iaWRpLWZvbnQtd2VpZ2h0Om5vcm1hbCc+V1RQIHByb2plY3QKLXJlc291cmNlIHNldCA8L2I+aXMgZGVmaW5lZCBpbiB0ZXJtcyBvZiBtb2R1bGUgcmVzb3VyY2VzLCB3aGljaCBjb250YWluCi1hYnN0cmFjdCBtb2R1bGUgbW9kZWxzIChkZWZpbmVkIGxhdGVyKS48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48bzpwPiZuYnNwOzwvbzpwPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPkEgPGIgc3R5bGU9J21zby1iaWRpLWZvbnQtd2VpZ2h0Om5vcm1hbCc+VVJJIGNvbnZlcnRlcjwvYj4KLW1heSBiZSBjb25maWd1cmVkIG9uIGEgcmVzb3VyY2Ugc2V0IHRvIG5vcm1hbGl6ZSByZWxhdGl2ZSBVUklzIGZvciBjb21wYXJpc29uCi1hbmQgdG8gbW9uaXRvciBhY2Nlc3MgdG8gdGhlIGJhY2tpbmcgc3RvcmUuPHNwYW4gc3R5bGU9J21zby1zcGFjZXJ1bjp5ZXMnPqAKLTwvc3Bhbj5UaGUgcmVzb3VyY2Ugc2V0IHdpbGwgdXNlIHRoaXMgY29udmVydGVyIHRvIHByb2R1Y2UgYW4gaW5wdXQgb3Igb3V0cHV0Ci1zdHJlYW0gZm9yIGEgVVJJLCBkdXJpbmcgc2VyaWFsaXphdGlvbiBvciBkZXNlcmlhbGl6YXRpb24gb2YgYSByZXNvdXJjZSwgYW5kCi1kdXJpbmcgYSBsb2FkIHRvIGNoZWNrIGZvciBhIHJlc291cmNlIFVSSSBtYXRjaCB0byBvbmUgb2YgaXRzIGtub3duIHJlc291cmNlcy48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48bzpwPiZuYnNwOzwvbzpwPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPkFuIDxiIHN0eWxlPSdtc28tYmlkaS1mb250LXdlaWdodDpub3JtYWwnPmFic3RyYWN0IG1vZHVsZTwvYj4KLWlzIGEgbG9naWNhbCwgYWJzdHJhY3RlZCwgZmlyc3QtY2xhc3MgbW9kZWwgb2YgYSBkZXBsb3lhYmxlIGFydGlmYWN0LiBUaGUKLWluaXRpYWwgYXNzdW1wdGlvbiB3aWxsIGJlIHRoYXQgYWJzdHJhY3QgbW9kdWxlcyBtdXN0IGJlIGNvbnRhaW5lZCB3aXRoaW4gb25lCi1wcm9qZWN0IGFuZCB0aHVzIHVzZSBvbmUgcHJvamVjdCByZXNvdXJjZSBzZXQuPHNwYW4gc3R5bGU9J21zby1zcGFjZXJ1bjp5ZXMnPqAKLTwvc3Bhbj5Ib3dldmVyLCBhIHByb2plY3QgYW5kIHRoZSBhc3NvY2lhdGVkIHByb2plY3QgcmVzb3VyY2Ugc2V0IG1heSBjb250YWluCi1tb3JlIHRoYW4gb25lIGFic3RyYWN0IG1vZHVsZS48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48bzpwPiZuYnNwOzwvbzpwPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdsaW5lLWhlaWdodDoxMi4wcHQ7dGFiLXN0b3BzOi41aW4gMS4waW4gMS41aW4gMi4waW4gMi41aW4gMy4waW47Ci1tc28tbGF5b3V0LWdyaWQtYWxpZ246bm9uZTt0ZXh0LWF1dG9zcGFjZTpub25lJz48c3BhbiBsYW5nPVRSIHN0eWxlPSdjb2xvcjoKLWJsYWNrO21zby1hbnNpLWxhbmd1YWdlOlRSJz5BIDxiIHN0eWxlPSdtc28tYmlkaS1mb250LXdlaWdodDpub3JtYWwnPkoyRUUgYTwvYj48L3NwYW4+PGIKLXN0eWxlPSdtc28tYmlkaS1mb250LXdlaWdodDpub3JtYWwnPjxzcGFuIGxhbmc9VFIgc3R5bGU9J21zby1hbnNpLWxhbmd1YWdlOgotVFInPmJzdHJhY3QgbTxzcGFuIHN0eWxlPSdjb2xvcjpibGFjayc+b2R1bGUgPC9zcGFuPjwvc3Bhbj48L2I+PHNwYW4gbGFuZz1UUgotc3R5bGU9J2NvbG9yOmJsYWNrO21zby1hbnNpLWxhbmd1YWdlOlRSJz5pcyBhIGNvbGxlY3Rpb24gb2Ygb25lIG9yIG1vcmUKLWNvbXBvbmVudHMsIG9yZ2FuaXplZCBieSBhIHN0YW5kYXJkIGxheW91dCwgdGFyZ2V0ZWQgZm9yIHRoZSBzYW1lIGNvbnRhaW5lcgotdXBvbiBkZXBsb3ltZW50PC9zcGFuPjxzcGFuIHN0eWxlPSdjb2xvcjpibGFjayc+LCBhbmQgd2hpY2ggY2FuIGJlIGFyY2hpdmVkCi1jb25mb3JtaW5nIHRvIHRoZSBKMkVFIHNwZWNpZmljYXRpb24uIE1vZHVsZXMgYWx3YXlzIGNvbnRhaW4gYSBzZXQgb2YgZmlsZXMsCi1idXQgYWxsIEoyRUUgbW9kdWxlcyBhbHNvIGNvbnRhaW4gc3BlY2lhbGl6ZWQgZmlsZXMgY2FsbGVkIDxiIHN0eWxlPSdtc28tYmlkaS1mb250LXdlaWdodDoKLW5vcm1hbCc+ZGVwbG95bWVudCBkZXNjcmlwdG9yczwvYj4uIERlcGxveW1lbnQgZGVzY3JpcHRvcnMgZGVzY3JpYmUgdGhlCi1jb250ZW50cyBvZiBkZXBsb3ltZW50IHVuaXRzIGFuZCBjb25maWd1cmUgY29tcG9uZW50cyBhbmQgYXBwbGljYXRpb25zIHRvIHRoZWlyCi1lbnZpcm9ubWVudC4gVGhleSBhbHNvIGV4dGVybmFsaXplIHRoZSByZWxhdGlvbnNoaXBzIGJldHdlZW4gY29tcG9uZW50cywgc28gdGhvc2UKLXJlbGF0aW9uc2hpcHMgY2FuIGJlIG1hbmFnZWQgd2l0aG91dCB3cml0aW5nIG9yIGNoYW5naW5nIHByb2dyYW0gY29kZS4gVGhlcmUKLWFyZSBmaXZlIGNvcmUgdHlwZXMgb2YgSjJFRSBkZXBsb3ltZW50IGRlc2NyaXB0b3JzLCBlYWNoIG9mIHdoaWNoIGNvcnJlc3BvbmRzCi10byBhIHR5cGUgb2YgSjJFRSBkZXBsb3ltZW50IHVuaXQ6IDxvOnA+PC9vOnA+PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdsaW5lLWhlaWdodDoxMi4wcHQ7dGFiLXN0b3BzOi41aW4gMS4waW4gMS41aW4gMi4waW4gMi41aW4gMy4waW47Ci1tc28tbGF5b3V0LWdyaWQtYWxpZ246bm9uZTt0ZXh0LWF1dG9zcGFjZTpub25lJz48c3BhbiBzdHlsZT0nY29sb3I6YmxhY2snPjxvOnA+Jm5ic3A7PC9vOnA+PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDoxLjBpbjt0ZXh0LWluZGVudDotLjI1aW47bGluZS1oZWlnaHQ6Ci0xMi4wcHQ7bXNvLWxpc3Q6bDMgbGV2ZWwxIGxmbzc7dGFiLXN0b3BzOmxpc3QgMS4waW4gbGVmdCAyLjBpbiAyLjVpbiAzLjBpbjsKLW1zby1sYXlvdXQtZ3JpZC1hbGlnbjpub25lO3RleHQtYXV0b3NwYWNlOm5vbmUnPjwhW2lmICFzdXBwb3J0TGlzdHNdPjxzcGFuCi1zdHlsZT0nZm9udC1mYW1pbHk6U3ltYm9sO21zby1mYXJlYXN0LWZvbnQtZmFtaWx5OlN5bWJvbDttc28tYmlkaS1mb250LWZhbWlseToKLVN5bWJvbDtjb2xvcjpibGFjayc+PHNwYW4gc3R5bGU9J21zby1saXN0Oklnbm9yZSc+tzxzcGFuIHN0eWxlPSdmb250OjcuMHB0ICJUaW1lcyBOZXcgUm9tYW4iJz4mbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDsKLTwvc3Bhbj48L3NwYW4+PC9zcGFuPjwhW2VuZGlmXT48c3BhbiBzdHlsZT0nY29sb3I6YmxhY2snPkFwcGxpY2F0aW9uPG86cD48L286cD48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0OjEuMGluO3RleHQtaW5kZW50Oi0uMjVpbjtsaW5lLWhlaWdodDoKLTEyLjBwdDttc28tbGlzdDpsMyBsZXZlbDEgbGZvNzt0YWItc3RvcHM6bGlzdCAxLjBpbiBsZWZ0IDIuMGluIDIuNWluIDMuMGluOwotbXNvLWxheW91dC1ncmlkLWFsaWduOm5vbmU7dGV4dC1hdXRvc3BhY2U6bm9uZSc+PCFbaWYgIXN1cHBvcnRMaXN0c10+PHNwYW4KLXN0eWxlPSdmb250LWZhbWlseTpTeW1ib2w7bXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6U3ltYm9sO21zby1iaWRpLWZvbnQtZmFtaWx5OgotU3ltYm9sO2NvbG9yOmJsYWNrJz48c3BhbiBzdHlsZT0nbXNvLWxpc3Q6SWdub3JlJz63PHNwYW4gc3R5bGU9J2ZvbnQ6Ny4wcHQgIlRpbWVzIE5ldyBSb21hbiInPiZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOwotPC9zcGFuPjwvc3Bhbj48L3NwYW4+PCFbZW5kaWZdPjxzcGFuIHN0eWxlPSdjb2xvcjpibGFjayc+QXBwbGljYXRpb24gQ2xpZW50IDxvOnA+PC9vOnA+PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDoxLjBpbjt0ZXh0LWluZGVudDotLjI1aW47bGluZS1oZWlnaHQ6Ci0xMi4wcHQ7bXNvLWxpc3Q6bDMgbGV2ZWwxIGxmbzc7dGFiLXN0b3BzOmxpc3QgMS4waW4gbGVmdCAyLjBpbiAyLjVpbiAzLjBpbjsKLW1zby1sYXlvdXQtZ3JpZC1hbGlnbjpub25lO3RleHQtYXV0b3NwYWNlOm5vbmUnPjwhW2lmICFzdXBwb3J0TGlzdHNdPjxzcGFuCi1zdHlsZT0nZm9udC1mYW1pbHk6U3ltYm9sO21zby1mYXJlYXN0LWZvbnQtZmFtaWx5OlN5bWJvbDttc28tYmlkaS1mb250LWZhbWlseToKLVN5bWJvbDtjb2xvcjpibGFjayc+PHNwYW4gc3R5bGU9J21zby1saXN0Oklnbm9yZSc+tzxzcGFuIHN0eWxlPSdmb250OjcuMHB0ICJUaW1lcyBOZXcgUm9tYW4iJz4mbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDsKLTwvc3Bhbj48L3NwYW4+PC9zcGFuPjwhW2VuZGlmXT48c3BhbiBzdHlsZT0nY29sb3I6YmxhY2snPkVKQiA8bzpwPjwvbzpwPjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6MS4waW47dGV4dC1pbmRlbnQ6LS4yNWluO2xpbmUtaGVpZ2h0OgotMTIuMHB0O21zby1saXN0OmwzIGxldmVsMSBsZm83O3RhYi1zdG9wczpsaXN0IDEuMGluIGxlZnQgMi4waW4gMi41aW4gMy4waW47Ci1tc28tbGF5b3V0LWdyaWQtYWxpZ246bm9uZTt0ZXh0LWF1dG9zcGFjZTpub25lJz48IVtpZiAhc3VwcG9ydExpc3RzXT48c3Bhbgotc3R5bGU9J2ZvbnQtZmFtaWx5OlN5bWJvbDttc28tZmFyZWFzdC1mb250LWZhbWlseTpTeW1ib2w7bXNvLWJpZGktZm9udC1mYW1pbHk6Ci1TeW1ib2w7Y29sb3I6YmxhY2snPjxzcGFuIHN0eWxlPSdtc28tbGlzdDpJZ25vcmUnPrc8c3BhbiBzdHlsZT0nZm9udDo3LjBwdCAiVGltZXMgTmV3IFJvbWFuIic+Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Ci08L3NwYW4+PC9zcGFuPjwvc3Bhbj48IVtlbmRpZl0+PHNwYW4gc3R5bGU9J2NvbG9yOmJsYWNrJz5XZWIgPG86cD48L286cD48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0OjEuMGluO3RleHQtaW5kZW50Oi0uMjVpbjtsaW5lLWhlaWdodDoKLTEyLjBwdDttc28tbGlzdDpsMyBsZXZlbDEgbGZvNzt0YWItc3RvcHM6bGlzdCAxLjBpbiBsZWZ0IDIuMGluIDIuNWluIDMuMGluOwotbXNvLWxheW91dC1ncmlkLWFsaWduOm5vbmU7dGV4dC1hdXRvc3BhY2U6bm9uZSc+PCFbaWYgIXN1cHBvcnRMaXN0c10+PHNwYW4KLXN0eWxlPSdmb250LWZhbWlseTpTeW1ib2w7bXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6U3ltYm9sO21zby1iaWRpLWZvbnQtZmFtaWx5OgotU3ltYm9sO2NvbG9yOmJsYWNrJz48c3BhbiBzdHlsZT0nbXNvLWxpc3Q6SWdub3JlJz63PHNwYW4gc3R5bGU9J2ZvbnQ6Ny4wcHQgIlRpbWVzIE5ldyBSb21hbiInPiZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOwotPC9zcGFuPjwvc3Bhbj48L3NwYW4+PCFbZW5kaWZdPjxzcGFuIHN0eWxlPSdjb2xvcjpibGFjayc+UmVzb3VyY2UgQWRhcHRlciBmb3IKLUphdmEgQ29ubmVjdG9yPG86cD48L286cD48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J2xpbmUtaGVpZ2h0OjEyLjBwdDt0YWItc3RvcHM6LjVpbiAxLjBpbiAyLjBpbiAyLjVpbiAzLjBpbjsKLW1zby1sYXlvdXQtZ3JpZC1hbGlnbjpub25lO3RleHQtYXV0b3NwYWNlOm5vbmUnPjxzcGFuIHN0eWxlPSdjb2xvcjpibGFjayc+PG86cD4mbmJzcDs8L286cD48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J2xpbmUtaGVpZ2h0OjEyLjBwdDt0YWItc3RvcHM6LjVpbiAxLjBpbiAxLjVpbiAyLjBpbiAyLjVpbiAzLjBpbjsKLW1zby1sYXlvdXQtZ3JpZC1hbGlnbjpub25lO3RleHQtYXV0b3NwYWNlOm5vbmUnPjxzcGFuIHN0eWxlPSdjb2xvcjpibGFjayc+VmVuZG9yLXNwZWNpZmljCi1kZXBsb3ltZW50IGRlc2NyaXB0b3JzIG1heSBiZSBkZWZpbmVkIGZvciBkaWZmZXJlbnQgPC9zcGFuPjxzdDE6Q2l0eT48c3QxOnBsYWNlPjxzcGFuCi0gIHN0eWxlPSdjb2xvcjpibGFjayc+RW50ZXJwcmlzZTwvc3Bhbj48L3N0MTpwbGFjZT48L3N0MTpDaXR5PjxzcGFuCi1zdHlsZT0nY29sb3I6YmxhY2snPiBhcHBsaWNhdGlvbiBjb250YWluZXJzIHRvIHByb3ZpZGUgYWRkaXRpb25hbCBpbmZvcm1hdGlvbi4gPG86cD48L286cD48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J2xpbmUtaGVpZ2h0OjEyLjBwdDt0YWItc3RvcHM6LjVpbiAxLjBpbiAxLjVpbiAyLjBpbiAyLjVpbiAzLjBpbjsKLW1zby1sYXlvdXQtZ3JpZC1hbGlnbjpub25lO3RleHQtYXV0b3NwYWNlOm5vbmUnPjxzcGFuIHN0eWxlPSdjb2xvcjpibGFjayc+PG86cD4mbmJzcDs8L286cD48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J2xpbmUtaGVpZ2h0OjEyLjBwdDt0YWItc3RvcHM6LjVpbiAxLjBpbiAxLjVpbiAyLjBpbiAyLjVpbiAzLjBpbjsKLW1zby1sYXlvdXQtZ3JpZC1hbGlnbjpub25lO3RleHQtYXV0b3NwYWNlOm5vbmUnPjxzcGFuIHN0eWxlPSdjb2xvcjpibGFjayc+RWFjaAotZGVwbG95bWVudCBkZXNjcmlwdG9yIGRlc2NyaWJlcyBhIHNldCBvZiBjb250YWluZWQgb2JqZWN0cyB3aGljaCBhcmUKLXJlcHJlc2VudGVkIHRocm91Z2ggPGIgc3R5bGU9J21zby1iaWRpLWZvbnQtd2VpZ2h0Om5vcm1hbCc+bW9kdWxlIG1vZGVsczwvYj48L3NwYW4+LjxzcGFuCi1zdHlsZT0nbXNvLXNwYWNlcnVuOnllcyc+oCA8L3NwYW4+VGhlIHJvb3QgYWJzdHJhY3QgbW9kdWxlIG1vZGVsIG9iamVjdCBmb3IgdGhlCi1kZXBsb3ltZW50IGRlc2NyaXB0b3IgaXMgdGhlIGFzc29jaWF0ZWQgSjJFRSBhYnN0cmFjdCBtb2R1bGUgdHlwZSBvYmplY3QuPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J2xpbmUtaGVpZ2h0OjEyLjBwdDt0YWItc3RvcHM6LjVpbiAxLjBpbiAxLjVpbiAyLjBpbiAyLjVpbiAzLjBpbjsKLW1zby1sYXlvdXQtZ3JpZC1hbGlnbjpub25lO3RleHQtYXV0b3NwYWNlOm5vbmUnPjxvOnA+Jm5ic3A7PC9vOnA+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0OjEuMGluO3RleHQtaW5kZW50Oi0uMjVpbjtsaW5lLWhlaWdodDoKLTEyLjBwdDttc28tbGlzdDpsNiBsZXZlbDEgbGZvNjt0YWItc3RvcHM6LjVpbiAxLjBpbiBsaXN0IDEuNWluIGxlZnQgMi4waW4gMi41aW4gMy4waW47Ci1tc28tbGF5b3V0LWdyaWQtYWxpZ246bm9uZTt0ZXh0LWF1dG9zcGFjZTpub25lJz48IVtpZiAhc3VwcG9ydExpc3RzXT48c3Bhbgotc3R5bGU9J2ZvbnQtZmFtaWx5OlN5bWJvbDttc28tZmFyZWFzdC1mb250LWZhbWlseTpTeW1ib2w7bXNvLWJpZGktZm9udC1mYW1pbHk6Ci1TeW1ib2w7Y29sb3I6YmxhY2snPjxzcGFuIHN0eWxlPSdtc28tbGlzdDpJZ25vcmUnPrc8c3BhbiBzdHlsZT0nZm9udDo3LjBwdCAiVGltZXMgTmV3IFJvbWFuIic+Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Ci08L3NwYW4+PC9zcGFuPjwvc3Bhbj48IVtlbmRpZl0+PHNwYW4gc3R5bGU9J2NvbG9yOmJsYWNrJz5UaGUgPGIKLXN0eWxlPSdtc28tYmlkaS1mb250LXdlaWdodDpub3JtYWwnPkFwcGxpY2F0aW9uPC9iPiBpcyB0aGUgcm9vdCBvYmplY3QgZm9yIGFuIEVBUgotbW9kdWxlLjxvOnA+PC9vOnA+PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDoxLjBpbjt0ZXh0LWluZGVudDotLjI1aW47bGluZS1oZWlnaHQ6Ci0xMi4wcHQ7bXNvLWxpc3Q6bDYgbGV2ZWwxIGxmbzY7dGFiLXN0b3BzOi41aW4gMS4waW4gbGlzdCAxLjVpbiBsZWZ0IDIuMGluIDIuNWluIDMuMGluOwotbXNvLWxheW91dC1ncmlkLWFsaWduOm5vbmU7dGV4dC1hdXRvc3BhY2U6bm9uZSc+PCFbaWYgIXN1cHBvcnRMaXN0c10+PHNwYW4KLXN0eWxlPSdmb250LWZhbWlseTpTeW1ib2w7bXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6U3ltYm9sO21zby1iaWRpLWZvbnQtZmFtaWx5OgotU3ltYm9sO2NvbG9yOmJsYWNrJz48c3BhbiBzdHlsZT0nbXNvLWxpc3Q6SWdub3JlJz63PHNwYW4gc3R5bGU9J2ZvbnQ6Ny4wcHQgIlRpbWVzIE5ldyBSb21hbiInPiZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOwotPC9zcGFuPjwvc3Bhbj48L3NwYW4+PCFbZW5kaWZdPjxzcGFuIHN0eWxlPSdjb2xvcjpibGFjayc+VGhlIDxiCi1zdHlsZT0nbXNvLWJpZGktZm9udC13ZWlnaHQ6bm9ybWFsJz5FSkJKYXI8L2I+IGlzIHRoZSByb290IG9iamVjdCBmb3IgYW4gRUpCCi1tb2R1bGUuPG86cD48L286cD48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWwgc3R5bGU9J21hcmdpbi1sZWZ0OjEuMGluO3RleHQtaW5kZW50Oi0uMjVpbjtsaW5lLWhlaWdodDoKLTEyLjBwdDttc28tbGlzdDpsNiBsZXZlbDEgbGZvNjt0YWItc3RvcHM6LjVpbiAxLjBpbiBsaXN0IDEuNWluIGxlZnQgMi4waW4gMi41aW4gMy4waW47Ci1tc28tbGF5b3V0LWdyaWQtYWxpZ246bm9uZTt0ZXh0LWF1dG9zcGFjZTpub25lJz48IVtpZiAhc3VwcG9ydExpc3RzXT48c3Bhbgotc3R5bGU9J2ZvbnQtZmFtaWx5OlN5bWJvbDttc28tZmFyZWFzdC1mb250LWZhbWlseTpTeW1ib2w7bXNvLWJpZGktZm9udC1mYW1pbHk6Ci1TeW1ib2w7Y29sb3I6YmxhY2snPjxzcGFuIHN0eWxlPSdtc28tbGlzdDpJZ25vcmUnPrc8c3BhbiBzdHlsZT0nZm9udDo3LjBwdCAiVGltZXMgTmV3IFJvbWFuIic+Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Jm5ic3A7Ci08L3NwYW4+PC9zcGFuPjwvc3Bhbj48IVtlbmRpZl0+PHNwYW4gc3R5bGU9J2NvbG9yOmJsYWNrJz5UaGUgPGIKLXN0eWxlPSdtc28tYmlkaS1mb250LXdlaWdodDpub3JtYWwnPldlYkFwcDwvYj4gaXMgdGhlIHJvb3Qgb2JqZWN0IGZvciBhIFdlYgotbW9kdWxlLjxvOnA+PC9vOnA+PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdtYXJnaW4tbGVmdDoxLjBpbjt0ZXh0LWluZGVudDotLjI1aW47bGluZS1oZWlnaHQ6Ci0xMi4wcHQ7bXNvLWxpc3Q6bDYgbGV2ZWwxIGxmbzY7dGFiLXN0b3BzOi41aW4gMS4waW4gbGlzdCAxLjVpbiBsZWZ0IDIuMGluIDIuNWluIDMuMGluOwotbXNvLWxheW91dC1ncmlkLWFsaWduOm5vbmU7dGV4dC1hdXRvc3BhY2U6bm9uZSc+PCFbaWYgIXN1cHBvcnRMaXN0c10+PHNwYW4KLXN0eWxlPSdmb250LWZhbWlseTpTeW1ib2w7bXNvLWZhcmVhc3QtZm9udC1mYW1pbHk6U3ltYm9sO21zby1iaWRpLWZvbnQtZmFtaWx5OgotU3ltYm9sO2NvbG9yOmJsYWNrJz48c3BhbiBzdHlsZT0nbXNvLWxpc3Q6SWdub3JlJz63PHNwYW4gc3R5bGU9J2ZvbnQ6Ny4wcHQgIlRpbWVzIE5ldyBSb21hbiInPiZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOyZuYnNwOwotPC9zcGFuPjwvc3Bhbj48L3NwYW4+PCFbZW5kaWZdPjxzcGFuIHN0eWxlPSdjb2xvcjpibGFjayc+VGhlIDxiCi1zdHlsZT0nbXNvLWJpZGktZm9udC13ZWlnaHQ6bm9ybWFsJz5BcHBsaWNhdGlvbkNsaWVudDwvYj4gaXMgdGhlIHJvb3Qgb2JqZWN0Ci1mb3IgYW4gQXBwbGljYXRpb24gQ2xpZW50IG1vZHVsZS48bzpwPjwvbzpwPjwvc3Bhbj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbCBzdHlsZT0nbWFyZ2luLWxlZnQ6MS4waW47dGV4dC1pbmRlbnQ6LS4yNWluO2xpbmUtaGVpZ2h0OgotMTIuMHB0O21zby1saXN0Omw2IGxldmVsMSBsZm82O3RhYi1zdG9wczouNWluIDEuMGluIGxpc3QgMS41aW4gbGVmdCAyLjBpbiAyLjVpbiAzLjBpbjsKLW1zby1sYXlvdXQtZ3JpZC1hbGlnbjpub25lO3RleHQtYXV0b3NwYWNlOm5vbmUnPjwhW2lmICFzdXBwb3J0TGlzdHNdPjxzcGFuCi1zdHlsZT0nZm9udC1mYW1pbHk6U3ltYm9sO21zby1mYXJlYXN0LWZvbnQtZmFtaWx5OlN5bWJvbDttc28tYmlkaS1mb250LWZhbWlseToKLVN5bWJvbDtjb2xvcjpibGFjayc+PHNwYW4gc3R5bGU9J21zby1saXN0Oklnbm9yZSc+tzxzcGFuIHN0eWxlPSdmb250OjcuMHB0ICJUaW1lcyBOZXcgUm9tYW4iJz4mbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDsmbmJzcDsKLTwvc3Bhbj48L3NwYW4+PC9zcGFuPjwhW2VuZGlmXT48c3BhbiBzdHlsZT0nY29sb3I6YmxhY2snPlRoZSA8Ygotc3R5bGU9J21zby1iaWRpLWZvbnQtd2VpZ2h0Om5vcm1hbCc+Q29ubmVjdG9yPC9iPiBpcyB0aGUgcm9vdCBvYmplY3QgZm9yIGEgSkNBCi1Db25uZWN0b3IgbW9kdWxlLjxvOnA+PC9vOnA+PC9zcGFuPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsIHN0eWxlPSdsaW5lLWhlaWdodDoxMi4wcHQ7dGFiLXN0b3BzOi41aW4gMS4waW4gMi4waW4gMi41aW4gMy4waW47Ci1tc28tbGF5b3V0LWdyaWQtYWxpZ246bm9uZTt0ZXh0LWF1dG9zcGFjZTpub25lJz48c3BhbiBzdHlsZT0nY29sb3I6YmxhY2snPjxzcGFuCi1zdHlsZT0nbXNvLXNwYWNlcnVuOnllcyc+oDwvc3Bhbj48L3NwYW4+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+QmVmb3JlIHByb2NlZWRpbmcsIGl0IHNob3VsZCBiZSBub3RlZCB0aGF0IHRoZXJlIGFyZSB0d28KLWRpc3RpbmN0IG1ldGFtb2RlbHMgaW4gdGhlIHRvb2xpbmcgZW52aXJvbm1lbnQuIEZpcnN0LCBKMkVFIGFic3RyYWN0IG1vZGVscwotYWxsb3cgZnJhbWV3b3JrIGNsaWVudHMgdG8gdW5kZXJzdGFuZCB0aGUgSjJFRS1zcGVjaWZpYyBkZXBsb3ltZW50IGRlc2NyaXB0b3JzCi1hbmQgdGhlaXIgdGhpcmQtcGFydHkgZXh0ZW5zaW9ucy4gVGhlIHRvb2xpbmcgZnJhbWV3b3JrcyBhcmUgYnVpbHQgcHJpbWFyaWx5IHRvCi1tb2RpZnkgYW5kIHVwZGF0ZSB0aGVzZSBtb2RlbHMuIFRoZXJlIGlzIGFsc28gYSBzZXBhcmF0ZSBtb2RlbCBmb3IKLXVuZGVyc3RhbmRpbmcgaG93IG1vZHVsZXMgYW5kIHRoZWlyIGNvbnRhaW5lZCByZXNvdXJjZXMgY2FuIGJlIGNvbnN0cnVjdGVkIGZvcgotZGVwbG95aW5nIHRvIHNlcnZlciBlbnZpcm9ubWVudHMsIHdoaWNoIGlzIHJlZmVycmVkIHRvIGFzIDxiIHN0eWxlPSdtc28tYmlkaS1mb250LXdlaWdodDoKLW5vcm1hbCc+TW9kdWxlQ29yZTwvYj4uIDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjxvOnA+Jm5ic3A7PC9vOnA+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PGIgc3R5bGU9J21zby1iaWRpLWZvbnQtd2VpZ2h0Om5vcm1hbCc+TW9kdWxlQ29yZTwvYj4gY2FuIGJlCi11c2VkIHRvIGFjcXVpcmUsIGNyZWF0ZSwgYW5kIGRlc3Ryb3kgPGIgc3R5bGU9J21zby1iaWRpLWZvbnQtd2VpZ2h0Om5vcm1hbCc+YWJzdHJhY3QKLW1vZHVsZSBjb250ZXh0czwvYj4uIEFuIDxiIHN0eWxlPSdtc28tYmlkaS1mb250LXdlaWdodDpub3JtYWwnPmFic3RyYWN0IG1vZHVsZQotY29udGV4dDwvYj4gaXM8YiBzdHlsZT0nbXNvLWJpZGktZm9udC13ZWlnaHQ6bm9ybWFsJz4gPC9iPnVzZWQgdG8gbWFuYWdlCi1tdWx0aXBsZSBhYnN0cmFjdCBtb2R1bGVzIHBlciBwcm9qZWN0LiBJbiB0aGUgZmlyc3QgaW1wbGVtZW50YXRpb24sIGFuIGFic3RyYWN0Ci1tb2R1bGUgY29udGV4dCB3aWxsIG5vdCBzcGFuIG11bHRpcGxlIHByb2plY3RzLiBFYWNoIGFic3RyYWN0IG1vZHVsZSBjb250ZXh0IGlkZW50aWZpZXMKLWEgdW5pcXVlIGN1c3RvbSBkZWZpbmVkIGFic3RyYWN0IG1vZHVsZSB1c2luZyBhIG1vZHVsZSBoYW5kbGUgKHNlZSBTZXJ2ZXIKLVRvb2xpbmcpLCBzZXJ2ZXIgdGFyZ2V0IHR5cGUgKHNlZSBTZXJ2ZXIgVG9vbGluZyksIGFuIGVkaXQgbW9kZWwgKHRvIGJlCi1kaXNjdXNzZWQgbGF0ZXIpLiA8L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48bzpwPiZuYnNwOzwvbzpwPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjxvOnA+Jm5ic3A7PC9vOnA+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PG86cD4mbmJzcDs8L286cD48L3A+Ci0KLTx0YWJsZSBjbGFzcz1Nc29UYWJsZUdyaWQgYm9yZGVyPTEgY2VsbHNwYWNpbmc9MCBjZWxscGFkZGluZz0wCi0gc3R5bGU9J2JvcmRlci1jb2xsYXBzZTpjb2xsYXBzZTtib3JkZXI6bm9uZTttc28tYm9yZGVyLWFsdDpzb2xpZCB3aW5kb3d0ZXh0IC41cHQ7Ci0gbXNvLXlmdGktdGJsbG9vazo0ODA7bXNvLXBhZGRpbmctYWx0OjBpbiA1LjRwdCAwaW4gNS40cHQ7bXNvLWJvcmRlci1pbnNpZGVoOgotIC41cHQgc29saWQgd2luZG93dGV4dDttc28tYm9yZGVyLWluc2lkZXY6LjVwdCBzb2xpZCB3aW5kb3d0ZXh0Jz4KLSA8dHIgc3R5bGU9J21zby15ZnRpLWlyb3c6MCc+Ci0gIDx0ZCB3aWR0aD01OTAgdmFsaWduPXRvcCBzdHlsZT0nd2lkdGg6Ni4xNWluO2JvcmRlcjpzb2xpZCB3aW5kb3d0ZXh0IDEuMHB0OwotICBtc28tYm9yZGVyLWFsdDpzb2xpZCB3aW5kb3d0ZXh0IC41cHQ7cGFkZGluZzowaW4gNS40cHQgMGluIDUuNHB0Jz4KLSAgPHAgY2xhc3M9TXNvTm9ybWFsPjwhLS1baWYgbXNvICYgIXN1cHBvcnRJbmxpbmVTaGFwZXMgJiBzdXBwb3J0RmllbGRzXT48c3BhbgotICBzdHlsZT0nbXNvLWVsZW1lbnQ6ZmllbGQtYmVnaW47bXNvLWZpZWxkLWxvY2s6eWVzJz48L3NwYW4+PHNwYW4KLSAgc3R5bGU9J21zby1zcGFjZXJ1bjp5ZXMnPqA8L3NwYW4+U0hBUEU8c3BhbiBzdHlsZT0nbXNvLXNwYWNlcnVuOnllcyc+oAotICA8L3NwYW4+XCogTUVSR0VGT1JNQVQgPHNwYW4gc3R5bGU9J21zby1lbGVtZW50OmZpZWxkLXNlcGFyYXRvcic+PC9zcGFuPjwhW2VuZGlmXS0tPjwhLS1baWYgZ3RlIHZtbCAxXT48djpncm91cAotICAgaWQ9Il94MDAwMF9zMTA2NyIgZWRpdGFzPSJjYW52YXMiIHN0eWxlPSd3aWR0aDo2aW47aGVpZ2h0OjE5OHB0OwotICAgbXNvLXBvc2l0aW9uLWhvcml6b250YWwtcmVsYXRpdmU6Y2hhcjttc28tcG9zaXRpb24tdmVydGljYWwtcmVsYXRpdmU6bGluZScKLSAgIGNvb3Jkb3JpZ2luPSIzOTYwLDEwMTA0IiBjb29yZHNpemU9IjcyMDAsMzM5NCI+Ci0gICA8bzpsb2NrIHY6ZXh0PSJlZGl0IiBhc3BlY3RyYXRpbz0idCIvPgotICAgPHY6c2hhcGV0eXBlIGlkPSJfeDAwMDBfdDc1IiBjb29yZHNpemU9IjIxNjAwLDIxNjAwIiBvOnNwdD0iNzUiCi0gICAgbzpwcmVmZXJyZWxhdGl2ZT0idCIgcGF0aD0ibUA0QDVsQDRAMTFAOUAxMUA5QDV4ZSIgZmlsbGVkPSJmIiBzdHJva2VkPSJmIj4KLSAgICA8djpzdHJva2Ugam9pbnN0eWxlPSJtaXRlciIvPgotICAgIDx2OmZvcm11bGFzPgotICAgICA8djpmIGVxbj0iaWYgbGluZURyYXduIHBpeGVsTGluZVdpZHRoIDAiLz4KLSAgICAgPHY6ZiBlcW49InN1bSBAMCAxIDAiLz4KLSAgICAgPHY6ZiBlcW49InN1bSAwIDAgQDEiLz4KLSAgICAgPHY6ZiBlcW49InByb2QgQDIgMSAyIi8+Ci0gICAgIDx2OmYgZXFuPSJwcm9kIEAzIDIxNjAwIHBpeGVsV2lkdGgiLz4KLSAgICAgPHY6ZiBlcW49InByb2QgQDMgMjE2MDAgcGl4ZWxIZWlnaHQiLz4KLSAgICAgPHY6ZiBlcW49InN1bSBAMCAwIDEiLz4KLSAgICAgPHY6ZiBlcW49InByb2QgQDYgMSAyIi8+Ci0gICAgIDx2OmYgZXFuPSJwcm9kIEA3IDIxNjAwIHBpeGVsV2lkdGgiLz4KLSAgICAgPHY6ZiBlcW49InN1bSBAOCAyMTYwMCAwIi8+Ci0gICAgIDx2OmYgZXFuPSJwcm9kIEA3IDIxNjAwIHBpeGVsSGVpZ2h0Ii8+Ci0gICAgIDx2OmYgZXFuPSJzdW0gQDEwIDIxNjAwIDAiLz4KLSAgICA8L3Y6Zm9ybXVsYXM+Ci0gICAgPHY6cGF0aCBvOmV4dHJ1c2lvbm9rPSJmIiBncmFkaWVudHNoYXBlb2s9InQiIG86Y29ubmVjdHR5cGU9InJlY3QiLz4KLSAgICA8bzpsb2NrIHY6ZXh0PSJlZGl0IiBhc3BlY3RyYXRpbz0idCIvPgotICAgPC92OnNoYXBldHlwZT48djpzaGFwZSBpZD0iX3gwMDAwX3MxMDY4IiB0eXBlPSIjX3gwMDAwX3Q3NSIgc3R5bGU9J3Bvc2l0aW9uOmFic29sdXRlOwotICAgIGxlZnQ6Mzk2MDt0b3A6MTAxMDQ7d2lkdGg6NzIwMDtoZWlnaHQ6MzM5NCcgbzpwcmVmZXJyZWxhdGl2ZT0iZiI+Ci0gICAgPHY6ZmlsbCBvOmRldGVjdG1vdXNlY2xpY2s9InQiLz4KLSAgICA8djpwYXRoIG86ZXh0cnVzaW9ub2s9InQiIG86Y29ubmVjdHR5cGU9Im5vbmUiLz4KLSAgICA8bzpsb2NrIHY6ZXh0PSJlZGl0IiB0ZXh0PSJ0Ii8+Ci0gICA8L3Y6c2hhcGU+PHY6cmVjdCBpZD0iX3gwMDAwX3MxMDY5IiBzdHlsZT0ncG9zaXRpb246YWJzb2x1dGU7bGVmdDo0NDEwOwotICAgIHRvcDoxMDI1ODt3aWR0aDo2MzAwO2hlaWdodDozMDg2Jz4KLSAgICA8djp0ZXh0Ym94IHN0eWxlPSdtc28tbmV4dC10ZXh0Ym94OiNfeDAwMDBfczEwNjknPgotICAgICA8IVtpZiAhbXNvXT4KLSAgICAgPHRhYmxlIGNlbGxwYWRkaW5nPTAgY2VsbHNwYWNpbmc9MCB3aWR0aD0iMTAwJSI+Ci0gICAgICA8dHI+Ci0gICAgICAgPHRkPjwhW2VuZGlmXT4KLSAgICAgICA8ZGl2PgotICAgICAgIDxwIGNsYXNzPU1zb05vcm1hbD5Nb2R1bGVDb3JlPC9wPgotICAgICAgIDwvZGl2PgotICAgICAgIDwhW2lmICFtc29dPjwvdGQ+Ci0gICAgICA8L3RyPgotICAgICA8L3RhYmxlPgotICAgICA8IVtlbmRpZl0+PC92OnRleHRib3g+Ci0gICA8L3Y6cmVjdD48djpyZWN0IGlkPSJfeDAwMDBfczEwNzAiIHN0eWxlPSdwb3NpdGlvbjphYnNvbHV0ZTtsZWZ0OjQ1NjA7dG9wOjEwNzIxOwotICAgIHdpZHRoOjI4NTA7aGVpZ2h0OjEwODAnPgotICAgIDx2OnRleHRib3ggc3R5bGU9J21zby1uZXh0LXRleHRib3g6I194MDAwMF9zMTA3MCc+Ci0gICAgIDwhW2lmICFtc29dPgotICAgICA8dGFibGUgY2VsbHBhZGRpbmc9MCBjZWxsc3BhY2luZz0wIHdpZHRoPSIxMDAlIj4KLSAgICAgIDx0cj4KLSAgICAgICA8dGQ+PCFbZW5kaWZdPgotICAgICAgIDxkaXY+Ci0gICAgICAgPHAgY2xhc3M9TXNvTm9ybWFsPk1vZHVsZUNvbnRleHQ8L3A+Ci0gICAgICAgPC9kaXY+Ci0gICAgICAgPCFbaWYgIW1zb10+PC90ZD4KLSAgICAgIDwvdHI+Ci0gICAgIDwvdGFibGU+Ci0gICAgIDwhW2VuZGlmXT48L3Y6dGV4dGJveD4KLSAgIDwvdjpyZWN0Pjx2OnJlY3QgaWQ9Il94MDAwMF9zMTA3MSIgc3R5bGU9J3Bvc2l0aW9uOmFic29sdXRlO2xlZnQ6NzU2MDt0b3A6MTA3MjE7Ci0gICAgd2lkdGg6Mjg1MDtoZWlnaHQ6MTA4MCc+Ci0gICAgPHY6dGV4dGJveCBzdHlsZT0nbXNvLW5leHQtdGV4dGJveDojX3gwMDAwX3MxMDcxJz4KLSAgICAgPCFbaWYgIW1zb10+Ci0gICAgIDx0YWJsZSBjZWxscGFkZGluZz0wIGNlbGxzcGFjaW5nPTAgd2lkdGg9IjEwMCUiPgotICAgICAgPHRyPgotICAgICAgIDx0ZD48IVtlbmRpZl0+Ci0gICAgICAgPGRpdj4KLSAgICAgICA8cCBjbGFzcz1Nc29Ob3JtYWw+TW9kdWxlQ29udGV4dDwvcD4KLSAgICAgICA8L2Rpdj4KLSAgICAgICA8IVtpZiAhbXNvXT48L3RkPgotICAgICAgPC90cj4KLSAgICAgPC90YWJsZT4KLSAgICAgPCFbZW5kaWZdPjwvdjp0ZXh0Ym94PgotICAgPC92OnJlY3Q+PHY6cmVjdCBpZD0iX3gwMDAwX3MxMDcyIiBzdHlsZT0ncG9zaXRpb246YWJzb2x1dGU7bGVmdDo0NTYwO3RvcDoxMTk1NTsKLSAgICB3aWR0aDoyODUwO2hlaWdodDoxMDgwJz4KLSAgICA8djp0ZXh0Ym94IHN0eWxlPSdtc28tbmV4dC10ZXh0Ym94OiNfeDAwMDBfczEwNzInPgotICAgICA8IVtpZiAhbXNvXT4KLSAgICAgPHRhYmxlIGNlbGxwYWRkaW5nPTAgY2VsbHNwYWNpbmc9MCB3aWR0aD0iMTAwJSI+Ci0gICAgICA8dHI+Ci0gICAgICAgPHRkPjwhW2VuZGlmXT4KLSAgICAgICA8ZGl2PgotICAgICAgIDxwIGNsYXNzPU1zb05vcm1hbD5Nb2R1bGVDb250ZXh0PC9wPgotICAgICAgIDwvZGl2PgotICAgICAgIDwhW2lmICFtc29dPjwvdGQ+Ci0gICAgICA8L3RyPgotICAgICA8L3RhYmxlPgotICAgICA8IVtlbmRpZl0+PC92OnRleHRib3g+Ci0gICA8L3Y6cmVjdD48djpyZWN0IGlkPSJfeDAwMDBfczEwNzMiIHN0eWxlPSdwb3NpdGlvbjphYnNvbHV0ZTtsZWZ0Ojc1NjA7dG9wOjExOTU1OwotICAgIHdpZHRoOjI4NTA7aGVpZ2h0OjEwODAnPgotICAgIDx2OnRleHRib3ggc3R5bGU9J21zby1uZXh0LXRleHRib3g6I194MDAwMF9zMTA3Myc+Ci0gICAgIDwhW2lmICFtc29dPgotICAgICA8dGFibGUgY2VsbHBhZGRpbmc9MCBjZWxsc3BhY2luZz0wIHdpZHRoPSIxMDAlIj4KLSAgICAgIDx0cj4KLSAgICAgICA8dGQ+PCFbZW5kaWZdPgotICAgICAgIDxkaXY+Ci0gICAgICAgPHAgY2xhc3M9TXNvTm9ybWFsPk1vZHVsZUNvbnRleHQ8L3A+Ci0gICAgICAgPC9kaXY+Ci0gICAgICAgPCFbaWYgIW1zb10+PC90ZD4KLSAgICAgIDwvdHI+Ci0gICAgIDwvdGFibGU+Ci0gICAgIDwhW2VuZGlmXT48L3Y6dGV4dGJveD4KLSAgIDwvdjpyZWN0Pjx2OnJlY3QgaWQ9Il94MDAwMF9zMTA3NCIgc3R5bGU9J3Bvc2l0aW9uOmFic29sdXRlO2xlZnQ6NDcxMDt0b3A6MTEwMjk7Ci0gICAgd2lkdGg6MTA1MDtoZWlnaHQ6NjE4Jz4KLSAgICA8djp0ZXh0Ym94IHN0eWxlPSdtc28tbmV4dC10ZXh0Ym94OiNfeDAwMDBfczEwNzQnPgotICAgICA8IVtpZiAhbXNvXT4KLSAgICAgPHRhYmxlIGNlbGxwYWRkaW5nPTAgY2VsbHNwYWNpbmc9MCB3aWR0aD0iMTAwJSI+Ci0gICAgICA8dHI+Ci0gICAgICAgPHRkPjwhW2VuZGlmXT4KLSAgICAgICA8ZGl2PgotICAgICAgIDxwIGNsYXNzPU1zb05vcm1hbD5BYnN0cmFjdE1vZHVsZTwvcD4KLSAgICAgICA8L2Rpdj4KLSAgICAgICA8IVtpZiAhbXNvXT48L3RkPgotICAgICAgPC90cj4KLSAgICAgPC90YWJsZT4KLSAgICAgPCFbZW5kaWZdPjwvdjp0ZXh0Ym94PgotICAgPC92OnJlY3Q+PHY6cmVjdCBpZD0iX3gwMDAwX3MxMDc2IiBzdHlsZT0ncG9zaXRpb246YWJzb2x1dGU7bGVmdDo3NzEwO3RvcDoxMTAzMDsKLSAgICB3aWR0aDoxMDUwO2hlaWdodDo2MTcnPgotICAgIDx2OnRleHRib3ggc3R5bGU9J21zby1uZXh0LXRleHRib3g6I194MDAwMF9zMTA3Nic+Ci0gICAgIDwhW2lmICFtc29dPgotICAgICA8dGFibGUgY2VsbHBhZGRpbmc9MCBjZWxsc3BhY2luZz0wIHdpZHRoPSIxMDAlIj4KLSAgICAgIDx0cj4KLSAgICAgICA8dGQ+PCFbZW5kaWZdPgotICAgICAgIDxkaXY+Ci0gICAgICAgPHAgY2xhc3M9TXNvTm9ybWFsPkFic3RyYWN0PHNwYW4gc3R5bGU9J21zby1zcGFjZXJ1bjp5ZXMnPqAgPC9zcGFuPk1vZHVsZTwvcD4KLSAgICAgICA8L2Rpdj4KLSAgICAgICA8IVtpZiAhbXNvXT48L3RkPgotICAgICAgPC90cj4KLSAgICAgPC90YWJsZT4KLSAgICAgPCFbZW5kaWZdPjwvdjp0ZXh0Ym94PgotICAgPC92OnJlY3Q+PHY6cmVjdCBpZD0iX3gwMDAwX3MxMDc3IiBzdHlsZT0ncG9zaXRpb246YWJzb2x1dGU7bGVmdDo4OTEwO3RvcDoxMTAyOTsKLSAgICB3aWR0aDoxMDUwO2hlaWdodDo2MTgnPgotICAgIDx2OnRleHRib3ggc3R5bGU9J21zby1uZXh0LXRleHRib3g6I194MDAwMF9zMTA3Nyc+Ci0gICAgIDwhW2lmICFtc29dPgotICAgICA8dGFibGUgY2VsbHBhZGRpbmc9MCBjZWxsc3BhY2luZz0wIHdpZHRoPSIxMDAlIj4KLSAgICAgIDx0cj4KLSAgICAgICA8dGQ+PCFbZW5kaWZdPgotICAgICAgIDxkaXY+Ci0gICAgICAgPHAgY2xhc3M9TXNvTm9ybWFsPkFic3RyYWN0PHNwYW4gc3R5bGU9J21zby1zcGFjZXJ1bjp5ZXMnPqAgPC9zcGFuPk1vZHVsZTwvcD4KLSAgICAgICA8L2Rpdj4KLSAgICAgICA8IVtpZiAhbXNvXT48L3RkPgotICAgICAgPC90cj4KLSAgICAgPC90YWJsZT4KLSAgICAgPCFbZW5kaWZdPjwvdjp0ZXh0Ym94PgotICAgPC92OnJlY3Q+PHY6cmVjdCBpZD0iX3gwMDAwX3MxMDc4IiBzdHlsZT0ncG9zaXRpb246YWJzb2x1dGU7bGVmdDo3NzEwO3RvcDoxMjI2NDsKLSAgICB3aWR0aDoxMDUwO2hlaWdodDo2MTcnPgotICAgIDx2OnRleHRib3ggc3R5bGU9J21zby1uZXh0LXRleHRib3g6I194MDAwMF9zMTA3OCc+Ci0gICAgIDwhW2lmICFtc29dPgotICAgICA8dGFibGUgY2VsbHBhZGRpbmc9MCBjZWxsc3BhY2luZz0wIHdpZHRoPSIxMDAlIj4KLSAgICAgIDx0cj4KLSAgICAgICA8dGQ+PCFbZW5kaWZdPgotICAgICAgIDxkaXY+Ci0gICAgICAgPHAgY2xhc3M9TXNvTm9ybWFsPkFic3RyYWN0IE1vZHVsZTwvcD4KLSAgICAgICA8L2Rpdj4KLSAgICAgICA8IVtpZiAhbXNvXT48L3RkPgotICAgICAgPC90cj4KLSAgICAgPC90YWJsZT4KLSAgICAgPCFbZW5kaWZdPjwvdjp0ZXh0Ym94PgotICAgPC92OnJlY3Q+PHY6cmVjdCBpZD0iX3gwMDAwX3MxMDc5IiBzdHlsZT0ncG9zaXRpb246YWJzb2x1dGU7bGVmdDo4OTEwO3RvcDoxMjI2NDsKLSAgICB3aWR0aDoxMDUwO2hlaWdodDo2MTcnPgotICAgIDx2OnRleHRib3ggc3R5bGU9J21zby1uZXh0LXRleHRib3g6I194MDAwMF9zMTA3OSc+Ci0gICAgIDwhW2lmICFtc29dPgotICAgICA8dGFibGUgY2VsbHBhZGRpbmc9MCBjZWxsc3BhY2luZz0wIHdpZHRoPSIxMDAlIj4KLSAgICAgIDx0cj4KLSAgICAgICA8dGQ+PCFbZW5kaWZdPgotICAgICAgIDxkaXY+Ci0gICAgICAgPHAgY2xhc3M9TXNvTm9ybWFsPkFic3RyYWN0PHNwYW4gc3R5bGU9J21zby1zcGFjZXJ1bjp5ZXMnPqAgPC9zcGFuPk1vZHVsZTwvcD4KLSAgICAgICA8L2Rpdj4KLSAgICAgICA8IVtpZiAhbXNvXT48L3RkPgotICAgICAgPC90cj4KLSAgICAgPC90YWJsZT4KLSAgICAgPCFbZW5kaWZdPjwvdjp0ZXh0Ym94PgotICAgPC92OnJlY3Q+PHY6cmVjdCBpZD0iX3gwMDAwX3MxMDgwIiBzdHlsZT0ncG9zaXRpb246YWJzb2x1dGU7bGVmdDo0NzEwO3RvcDoxMjI2NDsKLSAgICB3aWR0aDoxMDUwO2hlaWdodDo2MTcnPgotICAgIDx2OnRleHRib3ggc3R5bGU9J21zby1uZXh0LXRleHRib3g6I194MDAwMF9zMTA4MCc+Ci0gICAgIDwhW2lmICFtc29dPgotICAgICA8dGFibGUgY2VsbHBhZGRpbmc9MCBjZWxsc3BhY2luZz0wIHdpZHRoPSIxMDAlIj4KLSAgICAgIDx0cj4KLSAgICAgICA8dGQ+PCFbZW5kaWZdPgotICAgICAgIDxkaXY+Ci0gICAgICAgPHAgY2xhc3M9TXNvTm9ybWFsPkFic3RyYWN0IE1vZHVsZTwvcD4KLSAgICAgICA8L2Rpdj4KLSAgICAgICA8IVtpZiAhbXNvXT48L3RkPgotICAgICAgPC90cj4KLSAgICAgPC90YWJsZT4KLSAgICAgPCFbZW5kaWZdPjwvdjp0ZXh0Ym94PgotICAgPC92OnJlY3Q+PHY6cmVjdCBpZD0iX3gwMDAwX3MxMDgxIiBzdHlsZT0ncG9zaXRpb246YWJzb2x1dGU7bGVmdDo1OTEwO3RvcDoxMjI2NDsKLSAgICB3aWR0aDoxMDUwO2hlaWdodDo2MTcnPgotICAgIDx2OnRleHRib3ggc3R5bGU9J21zby1uZXh0LXRleHRib3g6I194MDAwMF9zMTA4MSc+Ci0gICAgIDwhW2lmICFtc29dPgotICAgICA8dGFibGUgY2VsbHBhZGRpbmc9MCBjZWxsc3BhY2luZz0wIHdpZHRoPSIxMDAlIj4KLSAgICAgIDx0cj4KLSAgICAgICA8dGQ+PCFbZW5kaWZdPgotICAgICAgIDxkaXY+Ci0gICAgICAgPHAgY2xhc3M9TXNvTm9ybWFsPkFic3RyYWN0IE1vZHVsZTwvcD4KLSAgICAgICA8L2Rpdj4KLSAgICAgICA8IVtpZiAhbXNvXT48L3RkPgotICAgICAgPC90cj4KLSAgICAgPC90YWJsZT4KLSAgICAgPCFbZW5kaWZdPjwvdjp0ZXh0Ym94PgotICAgPC92OnJlY3Q+PHY6cmVjdCBpZD0iX3gwMDAwX3MxMTU2IiBzdHlsZT0ncG9zaXRpb246YWJzb2x1dGU7bGVmdDo1OTEwO3RvcDoxMTAzMDsKLSAgICB3aWR0aDoxMDUwO2hlaWdodDo2MTgnPgotICAgIDx2OnRleHRib3ggc3R5bGU9J21zby1uZXh0LXRleHRib3g6I194MDAwMF9zMTE1Nic+Ci0gICAgIDwhW2lmICFtc29dPgotICAgICA8dGFibGUgY2VsbHBhZGRpbmc9MCBjZWxsc3BhY2luZz0wIHdpZHRoPSIxMDAlIj4KLSAgICAgIDx0cj4KLSAgICAgICA8dGQ+PCFbZW5kaWZdPgotICAgICAgIDxkaXY+Ci0gICAgICAgPHAgY2xhc3M9TXNvTm9ybWFsPkFic3RyYWN0TW9kdWxlPC9wPgotICAgICAgIDwvZGl2PgotICAgICAgIDwhW2lmICFtc29dPjwvdGQ+Ci0gICAgICA8L3RyPgotICAgICA8L3RhYmxlPgotICAgICA8IVtlbmRpZl0+PC92OnRleHRib3g+Ci0gICA8L3Y6cmVjdD48dzp3cmFwIHR5cGU9Im5vbmUiLz4KLSAgIDx3OmFuY2hvcmxvY2svPgotICA8L3Y6Z3JvdXA+PCFbZW5kaWZdLS0+PCFbaWYgIXZtbF0+PGltZyB3aWR0aD01NzYgaGVpZ2h0PTI2NAotICBzcmM9IkZsZXhpYmxlUHJvamVjdENvbmNlcHRzX2ZpbGVzL2ltYWdlMDAxLmdpZiIgdjpzaGFwZXM9Il94MDAwMF9zMTA2NyBfeDAwMDBfczEwNjggX3gwMDAwX3MxMDY5IF94MDAwMF9zMTA3MCBfeDAwMDBfczEwNzEgX3gwMDAwX3MxMDcyIF94MDAwMF9zMTA3MyBfeDAwMDBfczEwNzQgX3gwMDAwX3MxMDc2IF94MDAwMF9zMTA3NyBfeDAwMDBfczEwNzggX3gwMDAwX3MxMDc5IF94MDAwMF9zMTA4MCBfeDAwMDBfczEwODEgX3gwMDAwX3MxMTU2Ij48IVtlbmRpZl0+PCEtLVtpZiBtc28gJiAhc3VwcG9ydElubGluZVNoYXBlcyAmIHN1cHBvcnRGaWVsZHNdPjx2OnNoYXBlCi0gICBpZD0iX3gwMDAwX2kxMDI1IiB0eXBlPSIjX3gwMDAwX3Q3NSIgc3R5bGU9J3dpZHRoOjZpbjtoZWlnaHQ6MTk4cHQnPgotICAgPHY6aW1hZ2VkYXRhIGNyb3B0b3A9Ii02NTUyMGYiIGNyb3Bib3R0b209IjY1NTIwZiIvPgotICA8L3Y6c2hhcGU+PHNwYW4gc3R5bGU9J21zby1lbGVtZW50OmZpZWxkLWVuZCc+PC9zcGFuPjwhW2VuZGlmXS0tPjwvcD4KLSAgPC90ZD4KLSA8L3RyPgotIDx0ciBzdHlsZT0nbXNvLXlmdGktaXJvdzoxO21zby15ZnRpLWxhc3Ryb3c6eWVzJz4KLSAgPHRkIHdpZHRoPTU5MCB2YWxpZ249dG9wIHN0eWxlPSd3aWR0aDo2LjE1aW47Ym9yZGVyOnNvbGlkIHdpbmRvd3RleHQgMS4wcHQ7Ci0gIGJvcmRlci10b3A6bm9uZTttc28tYm9yZGVyLXRvcC1hbHQ6c29saWQgd2luZG93dGV4dCAuNXB0O21zby1ib3JkZXItYWx0OnNvbGlkIHdpbmRvd3RleHQgLjVwdDsKLSAgcGFkZGluZzowaW4gNS40cHQgMGluIDUuNHB0Jz4KLSAgPHAgY2xhc3M9TXNvTm9ybWFsPkZpZ3VyZSAxOiBPdmVydmlldyBvZiBNb2R1bGVDb3JlLCBNb2R1bGVDb250ZXh0LCBhbmQgQWJzdHJhY3QKLSAgTW9kdWxlIHJlbGF0aW9uc2hpcHMuPC9wPgotICA8L3RkPgotIDwvdHI+Ci08L3RhYmxlPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PG86cD4mbmJzcDs8L286cD48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48bzpwPiZuYnNwOzwvbzpwPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjxvOnA+Jm5ic3A7PC9vOnA+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+TWVhbndoaWxlLCA8YiBzdHlsZT0nbXNvLWJpZGktZm9udC13ZWlnaHQ6bm9ybWFsJz5lZGl0Ci1tb2RlbHM8L2I+IHByb3ZpZGUgYSBzaGFyZWQsIHJlZmVyZW5jZSBjb3VudGVkLCByZWFkL3dyaXRlIGNvbnRyb2xsZWQgYW1hbGdhbWF0aW9uCi1vZiBhIHJlbGF0ZWQgc2V0IG9mIHJlc291cmNlcy4gUHJpbWFyaWx5LCByZXNvdXJjZXMgYW5kIEphdmEgd29ya2luZyBjb3BpZXMgYXJlCi13cmFwcGVkIGJ5IGFuIEVkaXQgTW9kZWwgaW4gb3JkZXIgdG8gcmVwcmVzZW50IGEgY29oZXJlbnQgYW5kIGNvbnNpc3RlbnQgdmlldwotZm9yIGNsaWVudHMuIE1hbmFnaW5nIHRoZXNlIHJlc291cmNlcyBhcyBhIGdyb3VwLCBhbGxvd3MgY2hhbmdlcyB0byBiZQotY29tbWl0dGVkIG9yIHJvbGxlZCBiYWNrIGFzIGEgY29uc2lzdGVudCB1bml0IG9mIHdvcmsuIDwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjxvOnA+Jm5ic3A7PC9vOnA+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+VHlwaWNhbGx5LCBzcGVjaWFsaXplZCB0eXBlcyBvZiBlZGl0IG1vZGVscyBoYXZlCi1hZm9yZW1lbnRpb25lZCBrbm93bGVkZ2Ugb2YgdGhlaXIgZXhwZWN0ZWQgb3IgcmVxdWlyZWQgcmVzb3VyY2VzIGZvciBhIGdpdmVuCi10eXBlIG9mIGFic3RyYWN0ZWQgbW9kdWxlLiBOb3Qgc3VycHJpc2luZ2x5LCBjbGllbnRzIG1heSB3aXNoIHRvIGFkZAotY2FwYWJpbGl0aWVzIGFuZCBhZGRpdGlvbmFsIGtub3duIHJlc291cmNlcyB0byBleGlzdGluZyBlZGl0IG1vZGVsLiBUaGUgZWRpdAotbW9kZWwgd2lsbCBhdHRlbXB0IHRvIGxvYWQgdGhlc2UgcmVzb3VyY2VzIHNvIHRoYXQgdGhleSBtYXkgYmUgbWFuYWdlZCB3aXRoIHRoZQotZXhpc3RpbmcsIGtub3duIHJlc291cmNlcy4gPG86cD48L286cD48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48bzpwPiZuYnNwOzwvbzpwPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPkVkaXQgbW9kZWxzIGFyZSBjcmVhdGVkIHZpYSBhbiBleHRlbnNpb24gd2hpY2ggZGVmaW5lcyB0aGUgPGIKLXN0eWxlPSdtc28tYmlkaS1mb250LXdlaWdodDpub3JtYWwnPmVkaXQgbW9kZWwgZmFjdG9yeTwvYj4uIFRoZSBsaWZlY3ljbGUgb2YKLWhvdyBlZGl0IG1vZGVscyBhcmUgY3JlYXRlZCBhbmQgZGVzdHJveWVkIHdpbGwgYmUgY292ZXJlZCBpbiB0aGUgQVBJIENvbmNlcHRzCi1kb2N1bWVudC48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48bzpwPiZuYnNwOzwvbzpwPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPlR5cGljYWxseSwgSjJFRSBjb21wb25lbnRzIGFyZSBidWlsdCBvbiBhIHJlZ3VsYXIgc2NoZWR1bGUKLShlLmcuIGRhaWx5KSBhbmQgcGFja2FnZWQgYXMgRW50ZXJwcmlzZSBBcmNoaXZlcyAoRUFScykuIENvbGxhYm9yYXRpb24gYmV0d2VlbgotdGVhbXMgYW5kIGluZGl2aWR1YWwgbWVtYmVycyBpcyBmYWNpbGl0YXRlZCBieSB0aGVzZSBidWlsZCBhcnRpZmFjdHMgd2hpY2ggYXJlCi11c2VkIHRvIGJhY2sgY3VycmVudCBkZXZlbG9wbWVudC4gVGhlc2UgYXJlIHJlZmVycmVkIHRvIGFzIDxiIHN0eWxlPSdtc28tYmlkaS1mb250LXdlaWdodDoKLW5vcm1hbCc+dGFyZ2V0IEVBUnM8L2I+LiBEZXZlbG9wZXJzIHNldCB1cCB0aGVpciBkZXZlbG9wbWVudCBlbnZpcm9ubWVudHMgc28KLXRoZSBjb21wb25lbnRzIHRoZXkgYXJlIGFjdGl2ZWx5IHdvcmtpbmcgb24gYXJlIGxvYWRlZCBkaXJlY3RseSBmcm9tIGEgc291cmNlCi1yZXBvc2l0b3J5IGFuZCB0aGUgb3RoZXIgY29tcG9uZW50cyBhcmUgbG9hZGVkIGZyb20gdGhlIFRhcmdldCBFQVJzLjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjxvOnA+Jm5ic3A7PC9vOnA+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+VGhlIHVzZSBvZiB0YXJnZXQgRUFScyBpcyBhbmFsb2dvdXMgdG8gc2VsZi1ob3N0aW5nIGluCi1FY2xpcHNlLiBUaGUgaWRlYSBpcyB0byBvbmx5IGhhdmUgYWJzdHJhY3QgbW9kdWxlcyB0aGF0IGFyZSBjdXJyZW50bHkgYmVpbmcKLWRldmVsb3BlZCBpbiB0aGUgd29ya3NwYWNlLiBBbGwgb3RoZXIgZGVwZW5kZW5jaWVzIHdpbGwgYmUgbG9hZGVkIGZyb20gYSB0YXJnZXQKLUVBUi4gQ2hhbmdpbmcgdGFyZ2V0IEVBUnMgd291bGQgc2ltcGx5IGJlIGEgbWF0dGVyIG9mIGFkanVzdGluZyBzb21lIGFic3RyYWN0IG1vZHVsZQotcHJvcGVydHkgKGp1c3QgbGlrZSBQREUpLjxzcGFuIHN0eWxlPSdtc28tc3BhY2VydW46eWVzJz6gIDwvc3Bhbj5Mb2FkaW5nCi1wcm9qZWN0cyBmcm9tIHRoZSByZXBvc2l0b3J5LCBvciBkZWxldGluZyB0aGVtIGZyb20gdGhlIHdvcmtzcGFjZSB3b3VsZCBjaGFuZ2UKLXdoZXJlIHRoZXkgd2VyZSBsb2FkZWQgZnJvbSBhcyB3ZWxsIChhbHNvIGxpa2UgUERFKS48bzpwPjwvbzpwPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPjxvOnA+Jm5ic3A7PC9vOnA+PC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+UmF0aGVyIHRoYW4gdXNpbmcgdGFyZ2V0IEVBUnMsIEVBUiBmaWxlcyBtYXkgYmUgZXh0cmFjdGVkIHRvCi1hIHN0cnVjdHVyZSB3aGljaCByZXByZXNlbnRzIGl0cyBjb250YWluZWQgYWJzdHJhY3QgbW9kdWxlcy48c3Bhbgotc3R5bGU9J21zby1zcGFjZXJ1bjp5ZXMnPqAgPC9zcGFuPlRoZSByZW1haW5pbmcgbm9uLW1vZHVsZSBqYXIgYXJjaGl2ZXMgYXJlCi1jYWxsZWQgPGIgc3R5bGU9J21zby1iaWRpLWZvbnQtd2VpZ2h0Om5vcm1hbCc+dXRpbGl0eSBqYXJzPC9iPi4gVXRpbGl0eSBqYXJzCi1hcmUgcmVndWxhciBqYXJzIHdoaWNoIHRoZSB2YXJpb3VzIGFic3RyYWN0IG1vZHVsZXMgY2FuIGRlcGVuZCBvbi48c3Bhbgotc3R5bGU9J21zby1zcGFjZXJ1bjp5ZXMnPqAgPC9zcGFuPlV0aWxpdHkgamFycyBtYXkgZXhpc3QgYXMgamFyIGZpbGVzIHdpdGhpbgotdGhlIEVBUiBhYnN0cmFjdCBtb2R1bGUgd2hpY2ggaXMgdXNlZnVsIHdoZW4gYSBkZXZlbG9wZXIgaXMgbm90IGN1cnJlbnRseQotd29ya2luZyBvbiB0aGUgY29udGVudHMgb2YgdGhlIHV0aWxpdHkgamFyLiA8c3Bhbgotc3R5bGU9J21zby1zcGFjZXJ1bjp5ZXMnPqA8L3NwYW4+QWxsIGFic3RyYWN0IG1vZHVsZSBhcmNoaXZlcyBtdXN0ICh1dGlsaXR5Ci1qYXJzIGhhdmUgdGhlIG9wdGlvbikgYmUgaGFuZGxlZCBpbiBzZXBhcmF0ZSBhYnN0cmFjdCBtb2R1bGVzLjxiCi1zdHlsZT0nbXNvLWJpZGktZm9udC13ZWlnaHQ6bm9ybWFsJz48bzpwPjwvbzpwPjwvYj48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48bzpwPiZuYnNwOzwvbzpwPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPkFuIDxiIHN0eWxlPSdtc28tYmlkaS1mb250LXdlaWdodDpub3JtYWwnPmV4dHJhY3RlZDwvYj4gPGIKLXN0eWxlPSdtc28tYmlkaS1mb250LXdlaWdodDpub3JtYWwnPm1vZHVsZTwvYj4gb3IgPGIgc3R5bGU9J21zby1iaWRpLWZvbnQtd2VpZ2h0Ogotbm9ybWFsJz51dGlsaXR5IGphciBtb2R1bGU8L2I+IGlzIHNpbXBseSBhIG1vZHVsZSBjb250YWluaW5nIHRoZSBleHRyYWN0ZWQKLWNvbnRlbnRzIG9mIHRoZSBhcmNoaXZlLjxzcGFuIHN0eWxlPSdtc28tc3BhY2VydW46eWVzJz6gIDwvc3Bhbj5UaGUgYmVuZWZpdCBvZgotdXNpbmcgZXh0cmFjdGVkIG1vZHVsZXMgaXMgYWxsIHRoZSBhcnRpZmFjdHMgY2FuIGJlIG1vZGlmaWVkLjxzcGFuCi1zdHlsZT0nbXNvLXNwYWNlcnVuOnllcyc+oCA8L3NwYW4+VGhpcyB3b3VsZCBiZSB1c2VmdWwgaWYgYSBkZXZlbG9wZXIgZGlkIG5vdAotaGF2ZSBhY2Nlc3MgdG8gdGhlIHNvdXJjZSByZXBvc2l0b3J5LjxzcGFuIHN0eWxlPSdtc28tc3BhY2VydW46eWVzJz6gCi08L3NwYW4+VHlwaWNhbGx5LCBob3dldmVyLCBpbnN0ZWFkIG9mIHVzaW5nIGV4dHJhY3RlZCBtb2R1bGVzLCBhIGRldmVsb3Blcgotd291bGQgY29ubmVjdCB0byBhIHNvdXJjZSByZXBvc2l0b3J5LiBKYXJzIHdpdGhpbiBXQVJzIGNhbiBiZSBleHRyYWN0ZWQgYXMgbW9kdWxlcwotd2l0aGluIEVjbGlwc2UgcHJvamVjdHMgKGxpa2UgdXRpbGl0eSBqYXIgbW9kdWxlcykgb3IgY2FuIHJlbWFpbiBpbiB0aGUgV0FSIGluCi1iaW5hcnkgZm9ybS4gPC9wPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PG86cD4mbmJzcDs8L286cD48L3A+Ci0KLTxwIGNsYXNzPU1zb05vcm1hbD48bzpwPiZuYnNwOzwvbzpwPjwvcD4KLQotPHAgY2xhc3M9TXNvTm9ybWFsPkRvY3VtZW50IENvbmNlcHRzPC9wPgotCi08dGFibGUgY2xhc3M9TXNvVGFibGVHcmlkIGJvcmRlcj0xIGNlbGxzcGFjaW5nPTAgY2VsbHBhZGRpbmc9MAotIHN0eWxlPSdib3JkZXItY29sbGFwc2U6Y29sbGFwc2U7Ym9yZGVyOm5vbmU7bXNvLWJvcmRlci1hbHQ6c29saWQgd2luZG93dGV4dCAuNXB0OwotIG1zby15ZnRpLXRibGxvb2s6NDgwO21zby1wYWRkaW5nLWFsdDowaW4gNS40cHQgMGluIDUuNHB0O21zby1ib3JkZXItaW5zaWRlaDoKLSAuNXB0IHNvbGlkIHdpbmRvd3RleHQ7bXNvLWJvcmRlci1pbnNpZGV2Oi41cHQgc29saWQgd2luZG93dGV4dCc+Ci0gPHRyIHN0eWxlPSdtc28teWZ0aS1pcm93OjAnPgotICA8dGQgd2lkdGg9Mjk1IHZhbGlnbj10b3Agc3R5bGU9J3dpZHRoOjIyMS40cHQ7Ym9yZGVyOnNvbGlkIHdpbmRvd3RleHQgMS4wcHQ7Ci0gIG1zby1ib3JkZXItYWx0OnNvbGlkIHdpbmRvd3RleHQgLjVwdDtwYWRkaW5nOjBpbiA1LjRwdCAwaW4gNS40cHQnPgotICA8cCBjbGFzcz1Nc29Ob3JtYWw+Q2h1Y2s8c3BhbiBzdHlsZT0nbXNvLXNwYWNlcnVuOnllcyc+oCA8L3NwYW4+QnJpZGdoYW08L3A+Ci0gIDwvdGQ+Ci0gIDx0ZCB3aWR0aD0yOTUgdmFsaWduPXRvcCBzdHlsZT0nd2lkdGg6MjIxLjRwdDtib3JkZXI6c29saWQgd2luZG93dGV4dCAxLjBwdDsKLSAgYm9yZGVyLWxlZnQ6bm9uZTttc28tYm9yZGVyLWxlZnQtYWx0OnNvbGlkIHdpbmRvd3RleHQgLjVwdDttc28tYm9yZGVyLWFsdDoKLSAgc29saWQgd2luZG93dGV4dCAuNXB0O3BhZGRpbmc6MGluIDUuNHB0IDBpbiA1LjRwdCc+Ci0gIDxwIGNsYXNzPU1zb05vcm1hbD48YSBocmVmPSJtYWlsdG86Y2JyaWRnaGFAdXMuaWJtLmNvbSI+Y2JyaWRnaGFAdXMuaWJtLmNvbTwvYT48bzpwPjwvbzpwPjwvcD4KLSAgPC90ZD4KLSA8L3RyPgotIDx0ciBzdHlsZT0nbXNvLXlmdGktaXJvdzoxJz4KLSAgPHRkIHdpZHRoPTI5NSB2YWxpZ249dG9wIHN0eWxlPSd3aWR0aDoyMjEuNHB0O2JvcmRlcjpzb2xpZCB3aW5kb3d0ZXh0IDEuMHB0OwotICBib3JkZXItdG9wOm5vbmU7bXNvLWJvcmRlci10b3AtYWx0OnNvbGlkIHdpbmRvd3RleHQgLjVwdDttc28tYm9yZGVyLWFsdDpzb2xpZCB3aW5kb3d0ZXh0IC41cHQ7Ci0gIHBhZGRpbmc6MGluIDUuNHB0IDBpbiA1LjRwdCc+Ci0gIDxwIGNsYXNzPU1zb05vcm1hbD5KaWFsaW4gQy4gQ2hlbiA8L3A+Ci0gIDwvdGQ+Ci0gIDx0ZCB3aWR0aD0yOTUgdmFsaWduPXRvcCBzdHlsZT0nd2lkdGg6MjIxLjRwdDtib3JkZXItdG9wOm5vbmU7Ym9yZGVyLWxlZnQ6Ci0gIG5vbmU7Ym9yZGVyLWJvdHRvbTpzb2xpZCB3aW5kb3d0ZXh0IDEuMHB0O2JvcmRlci1yaWdodDpzb2xpZCB3aW5kb3d0ZXh0IDEuMHB0OwotICBtc28tYm9yZGVyLXRvcC1hbHQ6c29saWQgd2luZG93dGV4dCAuNXB0O21zby1ib3JkZXItbGVmdC1hbHQ6c29saWQgd2luZG93dGV4dCAuNXB0OwotICBtc28tYm9yZGVyLWFsdDpzb2xpZCB3aW5kb3d0ZXh0IC41cHQ7cGFkZGluZzowaW4gNS40cHQgMGluIDUuNHB0Jz4KLSAgPHAgY2xhc3M9TXNvTm9ybWFsPjxhIGhyZWY9Im1haWx0bzpqaWFsaW5AdXMuaWJtLmNvbSI+amlhbGluQHVzLmlibS5jb208L2E+PC9wPgotICA8L3RkPgotIDwvdHI+Ci0gPHRyIHN0eWxlPSdtc28teWZ0aS1pcm93OjInPgotICA8dGQgd2lkdGg9Mjk1IHZhbGlnbj10b3Agc3R5bGU9J3dpZHRoOjIyMS40cHQ7Ym9yZGVyOnNvbGlkIHdpbmRvd3RleHQgMS4wcHQ7Ci0gIGJvcmRlci10b3A6bm9uZTttc28tYm9yZGVyLXRvcC1hbHQ6c29saWQgd2luZG93dGV4dCAuNXB0O21zby1ib3JkZXItYWx0OnNvbGlkIHdpbmRvd3RleHQgLjVwdDsKLSAgcGFkZGluZzowaW4gNS40cHQgMGluIDUuNHB0Jz4KLSAgPHAgY2xhc3M9TXNvTm9ybWFsPk1pY2hhZWwgRC4gRWxkZXI8L3A+Ci0gIDwvdGQ+Ci0gIDx0ZCB3aWR0aD0yOTUgdmFsaWduPXRvcCBzdHlsZT0nd2lkdGg6MjIxLjRwdDtib3JkZXItdG9wOm5vbmU7Ym9yZGVyLWxlZnQ6Ci0gIG5vbmU7Ym9yZGVyLWJvdHRvbTpzb2xpZCB3aW5kb3d0ZXh0IDEuMHB0O2JvcmRlci1yaWdodDpzb2xpZCB3aW5kb3d0ZXh0IDEuMHB0OwotICBtc28tYm9yZGVyLXRvcC1hbHQ6c29saWQgd2luZG93dGV4dCAuNXB0O21zby1ib3JkZXItbGVmdC1hbHQ6c29saWQgd2luZG93dGV4dCAuNXB0OwotICBtc28tYm9yZGVyLWFsdDpzb2xpZCB3aW5kb3d0ZXh0IC41cHQ7cGFkZGluZzowaW4gNS40cHQgMGluIDUuNHB0Jz4KLSAgPHAgY2xhc3M9TXNvTm9ybWFsPjxhIGhyZWY9Im1haWx0bzptZGVsZGVyQHVzLmlibS5jb20iPm1kZWxkZXJAdXMuaWJtLmNvbTwvYT48L3A+Ci0gIDwvdGQ+Ci0gPC90cj4KLSA8dHIgc3R5bGU9J21zby15ZnRpLWlyb3c6Myc+Ci0gIDx0ZCB3aWR0aD0yOTUgdmFsaWduPXRvcCBzdHlsZT0nd2lkdGg6MjIxLjRwdDtib3JkZXI6c29saWQgd2luZG93dGV4dCAxLjBwdDsKLSAgYm9yZGVyLXRvcDpub25lO21zby1ib3JkZXItdG9wLWFsdDpzb2xpZCB3aW5kb3d0ZXh0IC41cHQ7bXNvLWJvcmRlci1hbHQ6c29saWQgd2luZG93dGV4dCAuNXB0OwotICBwYWRkaW5nOjBpbiA1LjRwdCAwaW4gNS40cHQnPgotICA8cCBjbGFzcz1Nc29Ob3JtYWw+RGVyZWsgSG9sdDwvcD4KLSAgPC90ZD4KLSAgPHRkIHdpZHRoPTI5NSB2YWxpZ249dG9wIHN0eWxlPSd3aWR0aDoyMjEuNHB0O2JvcmRlci10b3A6bm9uZTtib3JkZXItbGVmdDoKLSAgbm9uZTtib3JkZXItYm90dG9tOnNvbGlkIHdpbmRvd3RleHQgMS4wcHQ7Ym9yZGVyLXJpZ2h0OnNvbGlkIHdpbmRvd3RleHQgMS4wcHQ7Ci0gIG1zby1ib3JkZXItdG9wLWFsdDpzb2xpZCB3aW5kb3d0ZXh0IC41cHQ7bXNvLWJvcmRlci1sZWZ0LWFsdDpzb2xpZCB3aW5kb3d0ZXh0IC41cHQ7Ci0gIG1zby1ib3JkZXItYWx0OnNvbGlkIHdpbmRvd3RleHQgLjVwdDtwYWRkaW5nOjBpbiA1LjRwdCAwaW4gNS40cHQnPgotICA8cCBjbGFzcz1Nc29Ob3JtYWw+PGEgaHJlZj0ibWFpbHRvOmRmaG9sdEB1cy5pYm0uY29tIj5kZmhvbHRAdXMuaWJtLmNvbTwvYT48L3A+Ci0gIDwvdGQ+Ci0gPC90cj4KLSA8dHIgc3R5bGU9J21zby15ZnRpLWlyb3c6NCc+Ci0gIDx0ZCB3aWR0aD0yOTUgdmFsaWduPXRvcCBzdHlsZT0nd2lkdGg6MjIxLjRwdDtib3JkZXI6c29saWQgd2luZG93dGV4dCAxLjBwdDsKLSAgYm9yZGVyLXRvcDpub25lO21zby1ib3JkZXItdG9wLWFsdDpzb2xpZCB3aW5kb3d0ZXh0IC41cHQ7bXNvLWJvcmRlci1hbHQ6c29saWQgd2luZG93dGV4dCAuNXB0OwotICBwYWRkaW5nOjBpbiA1LjRwdCAwaW4gNS40cHQnPgotICA8cCBjbGFzcz1Nc29Ob3JtYWw+Sm9obiBMYW51dGk8L3A+Ci0gIDwvdGQ+Ci0gIDx0ZCB3aWR0aD0yOTUgdmFsaWduPXRvcCBzdHlsZT0nd2lkdGg6MjIxLjRwdDtib3JkZXItdG9wOm5vbmU7Ym9yZGVyLWxlZnQ6Ci0gIG5vbmU7Ym9yZGVyLWJvdHRvbTpzb2xpZCB3aW5kb3d0ZXh0IDEuMHB0O2JvcmRlci1yaWdodDpzb2xpZCB3aW5kb3d0ZXh0IDEuMHB0OwotICBtc28tYm9yZGVyLXRvcC1hbHQ6c29saWQgd2luZG93dGV4dCAuNXB0O21zby1ib3JkZXItbGVmdC1hbHQ6c29saWQgd2luZG93dGV4dCAuNXB0OwotICBtc28tYm9yZGVyLWFsdDpzb2xpZCB3aW5kb3d0ZXh0IC41cHQ7cGFkZGluZzowaW4gNS40cHQgMGluIDUuNHB0Jz4KLSAgPHAgY2xhc3M9TXNvTm9ybWFsPjxhIGhyZWY9Im1haWx0bzpqbGFudXRpQHVzLmlibS5jb20iPmpsYW51dGlAdXMuaWJtLmNvbTwvYT48L3A+Ci0gIDwvdGQ+Ci0gPC90cj4KLSA8dHIgc3R5bGU9J21zby15ZnRpLWlyb3c6NTttc28teWZ0aS1sYXN0cm93Onllcyc+Ci0gIDx0ZCB3aWR0aD0yOTUgdmFsaWduPXRvcCBzdHlsZT0nd2lkdGg6MjIxLjRwdDtib3JkZXI6c29saWQgd2luZG93dGV4dCAxLjBwdDsKLSAgYm9yZGVyLXRvcDpub25lO21zby1ib3JkZXItdG9wLWFsdDpzb2xpZCB3aW5kb3d0ZXh0IC41cHQ7bXNvLWJvcmRlci1hbHQ6c29saWQgd2luZG93dGV4dCAuNXB0OwotICBwYWRkaW5nOjBpbiA1LjRwdCAwaW4gNS40cHQnPgotICA8cCBjbGFzcz1Nc29Ob3JtYWw+SmFzb24gU2hvbGw8L3A+Ci0gIDwvdGQ+Ci0gIDx0ZCB3aWR0aD0yOTUgdmFsaWduPXRvcCBzdHlsZT0nd2lkdGg6MjIxLjRwdDtib3JkZXItdG9wOm5vbmU7Ym9yZGVyLWxlZnQ6Ci0gIG5vbmU7Ym9yZGVyLWJvdHRvbTpzb2xpZCB3aW5kb3d0ZXh0IDEuMHB0O2JvcmRlci1yaWdodDpzb2xpZCB3aW5kb3d0ZXh0IDEuMHB0OwotICBtc28tYm9yZGVyLXRvcC1hbHQ6c29saWQgd2luZG93dGV4dCAuNXB0O21zby1ib3JkZXItbGVmdC1hbHQ6c29saWQgd2luZG93dGV4dCAuNXB0OwotICBtc28tYm9yZGVyLWFsdDpzb2xpZCB3aW5kb3d0ZXh0IC41cHQ7cGFkZGluZzowaW4gNS40cHQgMGluIDUuNHB0Jz4KLSAgPHAgY2xhc3M9TXNvTm9ybWFsPjxhIGhyZWY9Im1haWx0bzpqc2hvbGxAdXMuaWJtLmNvbSI+anNob2xsQHVzLmlibS5jb208L2E+PC9wPgotICA8L3RkPgotIDwvdHI+Ci08L3RhYmxlPgotCi08cCBjbGFzcz1Nc29Ob3JtYWw+PG86cD4mbmJzcDs8L286cD48L3A+Ci0KLTwvZGl2PgotCi08L2JvZHk+Ci0KLTwvaHRtbD4KZGlmZiAtLWdpdCBhL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvRmxleGlibGVQcm9qZWN0Q29uY2VwdHNfZmlsZXMvZmlsZWxpc3QueG1sIGIvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy9GbGV4aWJsZVByb2plY3RDb25jZXB0c19maWxlcy9maWxlbGlzdC54bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhjYzYxMjguLjAwMDAwMDAKLS0tIGEvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy9GbGV4aWJsZVByb2plY3RDb25jZXB0c19maWxlcy9maWxlbGlzdC54bWwKKysrIC9kZXYvbnVsbApAQCAtMSw1ICswLDAgQEAKLTx4bWwgeG1sbnM6bz0idXJuOnNjaGVtYXMtbWljcm9zb2Z0LWNvbTpvZmZpY2U6b2ZmaWNlIj4KLSA8bzpNYWluRmlsZSBIUmVmPSIuLi9GbGV4aWJsZVByb2plY3RDb25jZXB0cy5odG0iLz4KLSA8bzpGaWxlIEhSZWY9ImltYWdlMDAxLmdpZiIvPgotIDxvOkZpbGUgSFJlZj0iZmlsZWxpc3QueG1sIi8+Ci08L3htbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL0ZsZXhpYmxlUHJvamVjdENvbmNlcHRzX2ZpbGVzL2ltYWdlMDAxLmdpZiBiL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvRmxleGlibGVQcm9qZWN0Q29uY2VwdHNfZmlsZXMvaW1hZ2UwMDEuZ2lmCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBmMjk2MmRiLi4wMDAwMDAwCi0tLSBhL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvRmxleGlibGVQcm9qZWN0Q29uY2VwdHNfZmlsZXMvaW1hZ2UwMDEuZ2lmCisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy9TZXJ2ZXIgVG9vbHMgQVBJIEJyYW5jaC5odG1sIGIvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy9TZXJ2ZXIgVG9vbHMgQVBJIEJyYW5jaC5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0ZDhhM2JjLi4wMDAwMDAwCi0tLSBhL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvU2VydmVyIFRvb2xzIEFQSSBCcmFuY2guaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDE2NiArMCwwIEBACi08aHRtbD4KLQotPGhlYWQ+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LUxhbmd1YWdlIiBjb250ZW50PSJlbi11cyI+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD13aW5kb3dzLTEyNTIiPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2RlZmF1bHRfc3R5bGUuY3NzIiB0eXBlPSJ0ZXh0L2NzcyI+Ci08dGl0bGU+U2VydmVyIFRvb2xzIEFQSSBCcmFuY2g8L3RpdGxlPgotPC9oZWFkPgotCi08Ym9keT4KLQotPGJvZHkgYWxpbms9IiNmZjAwMDAiIGJnY29sb3I9IiNmZmZmZmYiIGxpbms9IiMwMDAwZWUiIHRleHQ9IiMwMDAwMDAiIHZsaW5rPSIjNTUxYThiIj4KLQotPHRhYmxlIGJvcmRlcj0iMCIgY2VsbHBhZGRpbmc9IjIiIGNlbGxzcGFjaW5nPSI1IiB3aWR0aD0iMTAwJSI+Ci0gIDx0Ym9keT48dHI+Ci0gCQk8VEQgV0lEVEg9NjAlPgotCQkJPFAgQUxJR049TEVGVD48Qj48Rk9OVCBTSVpFPTY+PEZPTlQgRkFDRT0iVmVyZGFuYSwgQXJpYWwsIEhlbHZldGljYSwgc2Fucy1zZXJpZiI+U2VydmVyIFRvb2xzIEFQSSBCcmFuY2g8L0ZPTlQ+PC9GT05UPjwvQj48QlI+Ci0JCQk8Rk9OVCBTSVpFPTE+PEZPTlQgRkFDRT0iQXJpYWwsIEhlbHZldGljYSwgc2Fucy1zZXJpZiI+PEZPTlQgQ09MT1I9IiM4MDgwZmYiPkluZm9ybWF0aW9uIG9uIHRoZSBTZXJ2ZXIgVG9vbHMgQVBJIEJyYW5jaDwvRk9OVD48L0ZPTlQ+PC9GT05UPgotCQkJPC9QPgotCQk8L1REPgotICAgIDx0ZCByb3dzcGFuPSIyIiB3aWR0aD0iMTklIj48aW1nIHNyYz0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9pbWFnZXMvSWRlYS5qcGciIGJvcmRlcj0iMCIgaGVpZ2h0PSI4NiIgd2lkdGg9IjEyMCI+PC90ZD4KLSAgPC90cj4KLTwvdGJvZHk+PC90YWJsZT4KLQotPHRhYmxlIGJvcmRlcj0iMCIgY2VsbHBhZGRpbmc9IjIiIGNlbGxzcGFjaW5nPSI1IiB3aWR0aD0iMTAwJSI+Ci0gIDx0Ym9keT48dHI+IAotICAgIDx0ZCBjb2xzcGFuPSIyIiBhbGlnbj0ibGVmdCIgYmdjb2xvcj0iIzAwODBjMCIgdmFsaWduPSJ0b3AiPjxiPjxmb250IGNvbG9yPSIjZmZmZmZmIiBmYWNlPSJBcmlhbCxIZWx2ZXRpY2EiPkNoYW5nZXM8L2ZvbnQ+PC9iPjwvdGQ+Ci0gIDwvdHI+PC90Ym9keT4KLTwvdGFibGU+Ci0KLVRoaXMgZG9jdW1lbnQgY29udGFpbnMgaW5mb3JtYXRpb24gb24gdGhlIFNlcnZlciBUb29scyBBUEkgY2hhbmdlcyB0aGF0IGhhdmUgZ29uZQotaW50byB0aGUgU2VydmVyIFRvb2xzIEFQSSBCcmFuY2ggZm9yIE0yLgotCi08cC8+Ci0KLTx0YWJsZSBib3JkZXI9MT4KLTx0cj4KLSAgPHRoPkNoYW5nZTwvdGg+Ci0gIDx0aD5SZWFzb248L3RoPgotICA8dGg+T2xkIENvZGU8L3RoPgotICA8dGg+TmV3IENvZGU8L3RoPgotPC90cj4KLTx0cj4KLSAgPHRkPkFsbCBqYXZhLnV0aWwuTGlzdHMgcmV0dXJuZWQgZnJvbSBtZXRob2RzIGhhdmUgYmVlbiBjaGFuZ2VkIHRvIGFycmF5cyBvZiB0aGUgY29ycmVzcG9uZGluZwotICAgICAgY29udGVudCB0eXBlLjwvdGQ+Ci0gIDx0ZD5TdHJvbmdlciB0eXBlZCByZXR1cm4gdmFsdWVzIGFyZSBzYWZlciwgYW5kIHJldHVybmluZyBhIGNvcHkgb2YgdGhlIGxpc3QgKGluc3RlYWQgb2YgdGhlIGxpc3QKLSAgICAgIGl0c2VsZikgYmxvY2tzIGFnYWluc3QgY2xpZW50cyBtb2RpZnlpbmcgaW50ZXJuYWwgZGF0YSBzdHJ1Y3R1cmVzLjwvdGQ+Ci0gIDx0ZD5MaXN0IGxpc3QgPSBTZXJ2ZXJDb3JlLmdldFJ1bnRpbWVUeXBlcygpOzwvdGQ+Ci0gIDx0ZD5JUnVudGltZVR5cGVbXSBydCA9IFNlcnZlckNvcmUuZ2V0UnVudGltZVR5cGVzKCk7PC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5JUmVzb3VyY2VNYW5hZ2VyIGhhcyBiZWVuIHJlbW92ZWQuIE1vc3Qgb2YgaXQncyBtZXRob2RzIGhhdmUgYmVlbiBtb3ZlZCB0byB0aGUgU2VydmVyQ29yZQotICAgICAgY2xhc3MsIHdpdGggdGhlIHJlbWFpbmluZyBvbmVzIGluIFNlcnZlclV0aWwuPC90ZD4KLSAgPHRkPlRoZXJlIHdhcyBubyBjbGllbnQgYmVuZWZpdCBvZiB0aGUgcmVzb3VyY2UgbWFuYWdlciwgYW5kIGl0IHdhcyBtaXNuYW1lZC48L3RkPgotICA8dGQ+U2VydmVyQ29yZS5nZXRSZXNvdXJjZU1hbmFnZXIoKS5nZXRTZXJ2ZXJzKCk7PC90ZD4KLSAgPHRkPlNlcnZlckNvcmUuZ2V0U2VydmVycygpOzwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+QWxsIGV4dGVuc2lvbiBwb2ludCBpbnRlcmZhY2VzIGhhdmUgYmVlbiBjaGFuZ2VkIHRvIGFic3RyYWN0IGNsYXNzZXMsIGFuZCB0aGUgIkkiIHJlbW92ZWQKLSAgICBmcm9tIHRoZSBuYW1lLjwvdGQ+Ci0gIDx0ZD5BbGxvd3MgZm9yIGZ1dHVyZSBzdXBwb3J0IGFuZCBtYWludGVuYW5jZSB3aXRob3V0IGJyZWFraW5nIGV4aXN0aW5nIGludGVyZmFjZXMuPC90ZD4KLSAgPHRkPjwvdGQ+Ci0gIDx0ZD48L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPlNldmVyYWwgaW50ZXJmYWNlcyB3ZXJlIG1vdmVkIGZyb20gdGhlIC5jb3JlLm1vZGVsIHBhY2thZ2UgdG8gLmNvcmUuPC90ZD4KLSAgPHRkPlRoZSAuY29yZS5tb2RlbCBwYWNrYWdlIHdhcyBtZWFudCBmb3IgU1BJcywgbm90IEFQSS4gQWxsIEFQSSBjbGFzc2VzICYgaW50ZXJmYWNlcyB3aWxsCi0gICAgICBiZSBtb3ZlZCBvciByZW1haW4gaW4gLmNvcmUgc28gdGhhdCBBUEkgdXNlcnMgZG8gbm90IG5lZWQgdG8gdXNlIHRoZSAuY29yZS5tb2RlbCBwYWNrYWdlLjwvdGQ+Ci0gIDx0ZD5pbXBvcnQgb3JnLmVjbGlwc2Uud3N0LnNlcnZlci5jb2RlLm1vZGVsLklNb2R1bGU7PC90ZD4KLSAgPHRkPmltcG9ydCBvcmcuZWNsaXBzZS53c3Quc2VydmVyLmNvZGUuSU1vZHVsZTs8L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPklTZXJ2ZXJSZXNvdXJjZUxpc3RlbmVyIHJlbmFtZWQgdG8gSVNlcnZlckxpZmVjeWNsZUxpc3RlbmVyLiBTZXZlcmFsIG1ldGhvZHMgbW92ZWQgb3V0IHRvCi0gICAgICBuZXcgSVJ1bnRpbWVMaXN0ZW5lciBhbmQgSVNlcnZlckNvbmZpZ3VyYXRpb25MaXN0ZW5lciBpbnRlcmZhY2VzLjwvdGQ+Ci0gIDx0ZD4iUmVzb3VyY2UiIGhhZCB0byBiZSByZW1vdmVkIGZyb20gdGhlIG5hbWUsIGFuZCB0aGUgaW50ZXJmYWNlIGNvbnRhaW5lZCBtZXRob2RzIGZvcgotICAgICAgcnVudGltZXMgYW5kIHNlcnZlciBjb25maWd1cmF0aW9ucyBhcyB3ZWxsLiBUaGV5IGFyZSBzcGxpdCB1cCBzbyB0aGF0IEFQSSB1c2VycyBkbyBub3QKLSAgICAgIG5lZWQgdG8gbGlzdGVuIGZvciBhbGwgdHlwZXMgb2YgY2hhbmdlcyBmcm9tIGEgc2luZ2xlIGludGVyZmFjZS48L3RkPgotICA8dGQ+U2VydmVyQ29yZS5nZXRSZXNvdXJjZU1hbmFnZXIoKS5hZGRTZXJ2ZXJSZXNvdXJjZUxpc3RlbmVyKG15TGlzdGVuZXIpOzwvdGQ+Ci0gIDx0ZD5TZXJ2ZXJDb3JlLmFkZFJ1bnRpbWVMaWZlY3ljbGVMaXN0ZW5lcihteUxpc3RlbmVyKTs8L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPlB1Ymxpc2hpbmcgaW50ZXJmYWNlcyBjb21wbGV0ZWx5IHJld3JpdHRlbiAmIC5jb3JlLnJlc291cmNlcyBwYWNrYWdlIHJlbW92ZWQuPC90ZD4KLSAgPHRkPlRoZSBwdWJsaXNoaW5nIGludGVyZmFjZSB3YXMgb3V0ZGF0ZWQgYW5kIHdyaXR0ZW4gYmVmb3JlIHRoZSBFY2xpcHNlIHRlYW0gc3VwcG9ydCwKLSAgICAgIEFOVCwgb3Igb3RoZXIgcmVjZW50IHB1Ymxpc2hpbmcgbWV0aG9kcyBoYWQgYmVlbiBkZXZlbG9wZWQuIFRoZSBuZXcgQVBJIGFsbG93cyBmb3IKLSAgICAgIGJldHRlciBzdXBwb3J0IGFuZCBmb3IgZWFjaCBzZXJ2ZXIgdHlwZSB0byB1c2UgaXQncyBvd24gcHVibGlzaGluZyBtZWNoYW5pc20uPC90ZD4KLSAgPHRkPjwvdGQ+Ci0gIDx0ZD48L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPklSdW50aW1lRGVsZWdhdGUgYW5kIElSdW50aW1lV29ya2luZ0NvcHlEZWxlZ2F0ZSBtZXJnZWQgaW50byBhIHNpbmdsZSBSdW50aW1lRGVsZWdhdGUuCi0gICAgICBJU2VydmVyRGVsZWdhdGUgYW5kIElTZXJ2ZXJXb3JraW5nQ29weURlbGVnYXRlIHJld29ya2VkIGludG8gCi0gICAgICBTZXJ2ZXJEZWxlZ2F0ZSBhbmQgU2VydmVyQmVoYXZpb3VyRGVsZWdhdGUuPC90ZD4KLSAgPHRkPk1ha2luZyBjbGllbnRzIHByb3ZpZGUgdHdvIHNlcGFyYXRlIGNsYXNzZXMgZm9yIHRoZSBkZWxlZ2F0ZXMgd2FzIGV4Y2Vzc2l2ZSwKLSAgICAgIHVubmVjZXNzYXJ5LCBhbmQgZW5kZWQgdXAgd2l0aCB0b28gbWFueSBTUEkgY2xhc3Nlcy4gT25seSBhIHNpbmdsZSBkZWxlZ2F0ZSBjbGFzcyBpcwotICAgICAgbm93IHJlcXVpcmVkIGZvciB0aGVzZSBleHRlbnNpb24gcG9pbnRzLjwvdGQ+Ci0gIDx0ZD48L3RkPgotICA8dGQ+PC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5JUnVudGltZS5nZXREZWxlZ2F0ZSgpLCBJUnVudGltZS5nZXRXb3JraW5nQ29weURlbGVnYXRlKCkgY2hhbmdlZCBpbnRvIElSdW50aW1lIGV4dGVuZGluZwotICAgICAgSUFkYXB0YWJsZS4gU2ltaWxhciBmb3IgSVNlcnZlciBhbmQgb3RoZXIgZGVsZWdhdGVzPC90ZD4KLSAgPHRkPklBZGFwdGFibGUgaXMgYSBjb21tb24gRWNsaXBzZSBtZWNoYW5pc20sIGFuZCBhbGxvd3MgZm9yIG90aGVyIGV4dGVuc2lvbiBhcyB3ZWxsLiBDbGllbnRzCi0gICAgICBzaG91bGQgc3RpbGwgcmVtZW1iZXIgdGhhdCBjYWxsaW5nIHRoaXMgbWV0aG9kIG1heSBpbnZvbHZlIHBsdWdpbiBsb2FkaW5nLCBzbyBpdCBzaG91bGQKLSAgICAgIG5vdCBiZSB1c2VkIGluIHBvcHVwIG1lbnVzLCBldGMuPC90ZD4KLSAgPHRkPklUb21jYXRSdW50aW1lIHRyID0gKElUb21jYXRSdW50aW1lKSBydW50aW1lLmdldERlbGVnYXRlKCk7PC90ZD4KLSAgPHRkPklUb21jYXRSdW50aW1lIHRyID0gKElUb21jYXRSdW50aW1lKSBydW50aW1lLmdldEFkYXB0ZXIoSVRvbWNhdFJ1bnRpbWUuY2xhc3MpOzwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+SU1vZHVsZVR5cGUgYW5kIElNb2R1bGVLaW5kIGludGVyZmFjZXMgbWVyZ2VkLjwvdGQ+Ci0gIDx0ZD5JTW9kdWxlS2luZCB3YXMgY3JlYXRlZCBsYXRlIGluIHRoZSBwcmV2aW91cyByZWxlYXNlIGN5Y2xlIGFuZCBjb3VsZG4ndCBiZSBtZXJnZWQgYXQgdGhlCi0gICAgICB0aW1lIGl0IHdhcyBjcmVhdGVkLjwvdGQ+Ci0gIDx0ZD48L3RkPgotICA8dGQ+PC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5JU2VydmVyVGFzayBjaGFuZ2VkIGFuZCBJTW9kdWxlVGFzayByZW1vdmVkLjwvdGQ+Ci0gIDx0ZD5UaGUgZXhpc3RpbmcgaW50ZXJmYWNlcyBoYWQgYW4gSVRhc2sgZGlyZWN0bHkgcmV0dXJuZWQgYXMgYSBkZWxlZ2F0ZSwgYW5kIG9ubHkgYWxsb3dlZCBhCi0gICAgICBzaW5nbGUgdGFzayBwZXIgZXh0ZW5zaW9uIHBvaW50LiBUaGUgbmV3IElTZXJ2ZXJUYXNrIGFsbG93cyB0aGUgZGVsZWdhdGUgdG8gcmV0dXJuIG11bHRpcGxlCi0gICAgICB0YXNrcyBmcm9tIGEgc2luZ2xlIGV4dGVuc2lvbiBwb2ludCwgYW5kIGl0IGlzIG5vdCBpdHNlbGYgYSB0YXNrLjwvdGQ+Ci0gIDx0ZD48L3RkPgotICA8dGQ+PC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5JU2VydmVyQ29uZmlndXJhdGlvbiwgSVNlcnZlckNvbmZpZ3VyYXRpb24sIGV0Yy4gcmVtb3ZlZDwvdGQ+Ci0gIDx0ZD5UaGUgc2VydmVyIGNvbmZpZyB3YXMgYSByZWxpYyBhbmQgZGlkIG5vdCBuZWVkIHRvIGJlIGEgZmlyc3QgY2xhc3MgcmVzb3VyY2UuIFNlcnZlckRlbGVnYXRlcwotICAgICAgYXJlIG5vdyBkaXJlY3RseSByZXNwb25zaWJsZSBmb3IgbWFpbnRhaW5pbmcgdGhlIGNvbmZpZ3VyYXRpb24uPC90ZD4KLSAgPHRkPjwvdGQ+Ci0gIDx0ZD5zZWUgVG9tY2F0IGltcGxlbWVudGF0aW9uPC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5WYXJpb3VzIG1pbm9yIGNsZWFudXAgLSBtZXRob2RzIHJlbmFtZWQsIHBhcmFtZXRlcnMgY2hhbmdlZCwgZXRjLjwvdGQ+Ci0gIDx0ZD5DbGVhbnVwIGFuZCBmdXR1cmUgbWFpbnRlbmFuY2UuPC90ZD4KLSAgPHRkPjwvdGQ+Ci0gIDx0ZD48L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPklNb2R1bGVPYmplY3RBZGFwdGVyIC0+IElNb2R1bGVBcnRpZmFjdEFkYXB0ZXIsIElNb2R1bGVPYmplY3QgLT4gSU1vZHVsZUFydGlmYWN0PC90ZD4KLSAgPHRkPk9iamVjdCB3YXMgdG9vIGdlbmVyaWMgYW5kIGRpZG4ndCBoYXZlIGFueSByZWFsIG1lYW5pbmcuIEFydGlmYWN0IHJlcHJlc2VudHMgd2hhdCB0aGUKLSAgICAgIElNb2R1bGVPYmplY3QgcmVhbGx5IHJlcHJlc2VudHMgLSByZXNvdXJjZXMgd2l0aGluIGEgbW9kdWxlPC90ZD4KLSAgPHRkPjwvdGQ+Ci0gIDx0ZD48L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPmdldFNlcnZlclR5cGUoU3RyaW5nIGlkKSAtPiBmaW5kU2VydmVyVHlwZShTdHJpbmcgaWQpPC90ZD4KLSAgPHRkPkxvb2t1cCBtZXRob2RzIG9uIFNlcnZlckNvcmUgYW5kIFNlcnZlclV0aWwgcmVuYW1lZCB0byBiZSBtb3JlIGFjY3VyYXRlLjwvdGQ+Ci0gIDx0ZD5JU2VydmVyVHlwZSBzdCA9IGdldFNlcnZlclR5cGUoImNvbS54Iik8L3RkPgotICA8dGQ+SVNlcnZlclR5cGUgc3QgPSBmaW5kU2VydmVyVHlwZSgiY29tLngiKTwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+TG90cyBvZiBtZXRob2RzICYgaW50ZXJmYWNlcyBtb3ZlZCB0byBpbnRlcm5hbCBwYWNrYWdlczwvdGQ+Ci0gIDx0ZD5OZWVkIHRvIHRyaW0gZG93biB0aGUgZXhwb3NlZCBBUEkgdG8gb25seSB3aGF0IGlzIHJlcXVpcmVkIGZvciBvbmdvaW5nIG1haW50ZW5hbmNlLiBJZgotICAgICAgdGhlcmUgaXMgYW55dGhpbmcgaW4gYW4gaW50ZXJuYWwgcGFja2FnZSB0aGF0IHlvdSB3ZXJlIHByZXZpb3VzbHkgdXNpbmcsIG9yIHBsYW4gdG8gdXNlCi0gICAgICBpbiB0aGUgZnV0dXJlLCBwbGVhc2UgY29udGFjdCBtZSBhbmQgd2UnbGwgd29yayBvdXQgYW4gQVBJIHNvbHV0aW9uPC90ZD4KLSAgPHRkPjwvdGQ+Ci0gIDx0ZD48L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPjwvdGQ+Ci0gIDx0ZD48L3RkPgotICA8dGQ+PC90ZD4KLSAgPHRkPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLQotPC9ib2R5PgotPC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvU2VydmVyIFRvb2xzIEFQSSBDaGFuZ2VzLmh0bWwgYi9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL1NlcnZlciBUb29scyBBUEkgQ2hhbmdlcy5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCBkYjFjOGUzLi4wMDAwMDAwCi0tLSBhL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvU2VydmVyIFRvb2xzIEFQSSBDaGFuZ2VzLmh0bWwKKysrIC9kZXYvbnVsbApAQCAtMSwyNjMgKzAsMCBAQAotPGh0bWw+Ci0KLTxoZWFkPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1MYW5ndWFnZSIgY29udGVudD0iZW4tdXMiPgotPG1ldGEgaHR0cC1lcXVpdj0iQ29udGVudC1UeXBlIiBjb250ZW50PSJ0ZXh0L2h0bWw7IGNoYXJzZXQ9d2luZG93cy0xMjUyIj4KLTxsaW5rIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9kZWZhdWx0X3N0eWxlLmNzcyIgdHlwZT0idGV4dC9jc3MiPgotPHRpdGxlPlNlcnZlciBUb29scyBBUEkgQ2hhbmdlczwvdGl0bGU+Ci08c3R5bGU+Ci10ZCB7IGZvbnQtZmFtaWx5OiBhcmlhbCwgaGVsdmV0aWNhLCBnZW5ldmE7IGZvbnQtc2l6ZTogOXB0OyB2ZXJ0aWNhbC1hbGlnbjogdG9wOyB9Ci10ZC5jb2RlIHsgZm9udC1mYW1pbHk6ICJDb3VyaWVyIE5ldyIsIENvdXJpZXIsIG1vbm87IGZvbnQtc2l6ZTogNy43NXB0fQotPC9zdHlsZT4KLTwvaGVhZD4KLQotPGJvZHkgYWxpbms9IiNmZjAwMDAiIGJnY29sb3I9IiNmZmZmZmYiIGxpbms9IiMwMDAwZWUiIHRleHQ9IiMwMDAwMDAiIHZsaW5rPSIjNTUxYThiIj4KLQotPHRhYmxlIGJvcmRlcj0iMCIgY2VsbHBhZGRpbmc9IjIiIGNlbGxzcGFjaW5nPSI1IiB3aWR0aD0iMTAwJSI+Ci0gIDx0Ym9keT48dHI+Ci0gCQk8VEQgV0lEVEg9NjAlPgotCQkJPFAgQUxJR049TEVGVD48Qj48Rk9OVCBTSVpFPTY+PEZPTlQgRkFDRT0iVmVyZGFuYSwgQXJpYWwsIEhlbHZldGljYSwgc2Fucy1zZXJpZiI+U2VydmVyIFRvb2xzIEFQSSBDaGFuZ2VzPC9GT05UPjwvRk9OVD48L0I+PEJSPgotCQkJPEZPTlQgU0laRT0xPjxGT05UIEZBQ0U9IkFyaWFsLCBIZWx2ZXRpY2EsIHNhbnMtc2VyaWYiPjxGT05UIENPTE9SPSIjODA4MGZmIj5JbmZvcm1hdGlvbiBvbiBTZXJ2ZXIgVG9vbHMgQVBJIENoYW5nZXM8L0ZPTlQ+PC9GT05UPjwvRk9OVD4KLQkJCTwvUD4KLQkJPC9URD4KLSAgICA8dGQgcm93c3Bhbj0iMiIgd2lkdGg9IjE5JSI+PGltZyBzcmM9Imh0dHA6Ly93d3cuZWNsaXBzZS5vcmcvaW1hZ2VzL0lkZWEuanBnIiBib3JkZXI9IjAiIGhlaWdodD0iODYiIHdpZHRoPSIxMjAiPjwvdGQ+Ci0gIDwvdHI+Ci08L3Rib2R5PjwvdGFibGU+Ci0KLQotPHRhYmxlIGJvcmRlcj0iMCIgY2VsbHBhZGRpbmc9IjIiIGNlbGxzcGFjaW5nPSI1IiB3aWR0aD0iMTAwJSI+Ci0gIDx0Ym9keT48dHI+IAotICAgIDx0ZCBjb2xzcGFuPSIyIiBhbGlnbj0ibGVmdCIgYmdjb2xvcj0iIzAwODBjMCIgdmFsaWduPSJ0b3AiPjxiPjxmb250IGNvbG9yPSIjZmZmZmZmIiBmYWNlPSJBcmlhbCxIZWx2ZXRpY2EiPk0xIENoYW5nZXM8L2ZvbnQ+PC9iPjwvdGQ+Ci0gIDwvdHI+PC90Ym9keT4KLTwvdGFibGU+Ci0KLVRoaXMgZG9jdW1lbnQgY29udGFpbnMgaW5mb3JtYXRpb24gb24gdGhlIFNlcnZlciBUb29scyBBUEkgY2hhbmdlcyB0aGF0IGhhdmUgZ29uZQotaW50byBNMS4KLQotPHAvPgotCi08dGFibGUgYm9yZGVyPTEgY2VsbHNwYWNpbmc9IjAiPgotPHRyPgotICA8dGg+Q2hhbmdlPC90aD4KLSAgPHRoPlJlYXNvbjwvdGg+Ci0gIDx0aD5PbGQgQ29kZTwvdGg+Ci0gIDx0aD5OZXcgQ29kZTwvdGg+Ci08L3RyPgotPHRyPgotICA8dGQ+UGFja2FnZSByZW5hbWVzOjxici8+Ci0gIGNvbS5pYm0ud3RwLnNlcnZlci5jb3JlIC0+IG9yZy5lY2xpcHNlLndzdC5zZXJ2ZXIuY29yZTxici8+Ci0gIGNvbS5pYm0ud3RwLnNlcnZlci51aSAtPiBvcmcuZWNsaXBzZS53c3Quc2VydmVyLnVpPGJyLz4KLSAgY29tLmlibS53dHAuc2VydmVyLnV0aWwgLT4gb3JnLmVjbGlwc2Uud3N0LnNlcnZlci51dGlsPGJyLz4KLSAgY29tLmlibS53dHAuc2VydmVyLmphdmEuY29yZSAtPiBvcmcuZWNsaXBzZS5qc3Quc2VydmVyLmNvcmU8YnIvPgotICBjb20uaWJtLnd0cC5zZXJ2ZXIuamF2YS51aSAtPiBvcmcuZWNsaXBzZS5qc3Quc2VydmVyLnVpPGJyLz4KLSAgY29tLmlibS53dHAuc2VydmVyLnRvbWNhdC5jb3JlIC0+IG9yZy5lY2xpcHNlLmpzdC5zZXJ2ZXIudG9tY2F0LmNvcmU8YnIvPgotICBjb20uaWJtLnd0cC5zZXJ2ZXIudG9tY2F0LnVpIC0+IG9yZy5lY2xpcHNlLmpzdC5zZXJ2ZXIudG9tY2F0LnVpPGJyLz4KLSAgY29tLmlibS53dHAubW9uaXRvci5jb3JlIC0+IG9yZy5lY2xpcHNlLndzdC5tb25pdG9yLmNvcmU8YnIvPgotICBjb20uaWJtLnd0cC5tb25pdG9yLnVpIC0+IG9yZy5lY2xpcHNlLndzdC5tb25pdG9yLnVpPGJyLz4KLSAgY29tLmlibS53dHAud2ViYnJvd3NlciAtPiBvcmcuZWNsaXBzZS53c3Qud2ViYnJvd3NlcjwvdGQ+Ci0gIDx0ZD5SZW5hbWluZyBmb3Igb3BlbiBzb3VyY2U8L3RkPgotICA8dGQ+PC90ZD4KLSAgPHRkPjwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+PC90ZD4KLSAgPHRkPjwvdGQ+Ci0gIDx0ZD48L3RkPgotICA8dGQ+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotCi0KLTx0YWJsZSBib3JkZXI9IjAiIGNlbGxwYWRkaW5nPSIyIiBjZWxsc3BhY2luZz0iNSIgd2lkdGg9IjEwMCUiPgotICA8dGJvZHk+PHRyPiAKLSAgICA8dGQgY29sc3Bhbj0iMiIgYWxpZ249ImxlZnQiIGJnY29sb3I9IiMwMDgwYzAiIHZhbGlnbj0idG9wIj48Yj48Zm9udCBjb2xvcj0iI2ZmZmZmZiIgZmFjZT0iQXJpYWwsSGVsdmV0aWNhIj5NMiBDaGFuZ2VzPC9mb250PjwvYj48L3RkPgotICA8L3RyPjwvdGJvZHk+Ci08L3RhYmxlPgotCi1UaGlzIGRvY3VtZW50IGNvbnRhaW5zIGluZm9ybWF0aW9uIG9uIHRoZSBTZXJ2ZXIgVG9vbHMgQVBJIGNoYW5nZXMgdGhhdCBoYXZlIGdvbmUgaW50byBNMi4KLQotPHAvPgotCi08dGFibGUgYm9yZGVyPTEgY2VsbHNwYWNpbmc9IjAiPgotPHRyPgotICA8dGg+Q2hhbmdlPC90aD4KLSAgPHRoPlJlYXNvbjwvdGg+Ci0gIDx0aD5PbGQgQ29kZTwvdGg+Ci0gIDx0aD5OZXcgQ29kZTwvdGg+Ci08L3RyPgotPHRyPgotICA8dGQ+QWxsIGphdmEudXRpbC5MaXN0cyByZXR1cm5lZCBmcm9tIG1ldGhvZHMgaGF2ZSBiZWVuIGNoYW5nZWQgdG8gYXJyYXlzIG9mIHRoZSBjb3JyZXNwb25kaW5nCi0gICAgICBjb250ZW50IHR5cGUuPC90ZD4KLSAgPHRkPlN0cm9uZ2VyIHR5cGVkIHJldHVybiB2YWx1ZXMgYXJlIHNhZmVyLCBhbmQgcmV0dXJuaW5nIGEgY29weSBvZiB0aGUgbGlzdCAoaW5zdGVhZCBvZiB0aGUgbGlzdAotICAgICAgaXRzZWxmKSBibG9ja3MgYWdhaW5zdCBjbGllbnRzIG1vZGlmeWluZyBpbnRlcm5hbCBkYXRhIHN0cnVjdHVyZXMuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5MaXN0IGxpc3QgPSBTZXJ2ZXJDb3JlLmdldFJ1bnRpbWVUeXBlcygpOzwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+SVJ1bnRpbWVUeXBlW10gcnQgPSBTZXJ2ZXJDb3JlLmdldFJ1bnRpbWVUeXBlcygpOzwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+SVJlc291cmNlTWFuYWdlciBoYXMgYmVlbiByZW1vdmVkLiBNb3N0IG9mIGl0J3MgbWV0aG9kcyBoYXZlIGJlZW4gbW92ZWQgdG8gdGhlIFNlcnZlckNvcmUKLSAgICAgIGNsYXNzLCB3aXRoIHRoZSByZW1haW5pbmcgb25lcyBpbiBTZXJ2ZXJVdGlsLjwvdGQ+Ci0gIDx0ZD5UaGVyZSB3YXMgbm8gY2xpZW50IGJlbmVmaXQgb2YgdGhlIHJlc291cmNlIG1hbmFnZXIsIGFuZCBpdCB3YXMgbWlzbmFtZWQuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5TZXJ2ZXJDb3JlLmdldFJlc291cmNlTWFuYWdlcigpLmdldFNlcnZlcnMoKTs8L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPlNlcnZlckNvcmUuZ2V0U2VydmVycygpOzwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+QWxsIGV4dGVuc2lvbiBwb2ludCBpbnRlcmZhY2VzIGhhdmUgYmVlbiBjaGFuZ2VkIHRvIGFic3RyYWN0IGNsYXNzZXMsIGFuZCB0aGUgIkkiIHJlbW92ZWQKLSAgICBmcm9tIHRoZSBuYW1lLjwvdGQ+Ci0gIDx0ZD5BbGxvd3MgZm9yIGZ1dHVyZSBzdXBwb3J0IGFuZCBtYWludGVuYW5jZSB3aXRob3V0IGJyZWFraW5nIGV4aXN0aW5nIGludGVyZmFjZXMuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+U2V2ZXJhbCBpbnRlcmZhY2VzIHdlcmUgbW92ZWQgZnJvbSB0aGUgLmNvcmUubW9kZWwgcGFja2FnZSB0byAuY29yZS48L3RkPgotICA8dGQ+VGhlIC5jb3JlLm1vZGVsIHBhY2thZ2Ugd2FzIG1lYW50IGZvciBTUElzLCBub3QgQVBJLiBBbGwgQVBJIGNsYXNzZXMgJiBpbnRlcmZhY2VzIHdpbGwKLSAgICAgIGJlIG1vdmVkIG9yIHJlbWFpbiBpbiAuY29yZSBzbyB0aGF0IEFQSSB1c2VycyBkbyBub3QgbmVlZCB0byB1c2UgdGhlIC5jb3JlLm1vZGVsIHBhY2thZ2UuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5pbXBvcnQgb3JnLmVjbGlwc2Uud3N0LnNlcnZlci5jb2RlLm1vZGVsLklNb2R1bGU7PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5pbXBvcnQgb3JnLmVjbGlwc2Uud3N0LnNlcnZlci5jb2RlLklNb2R1bGU7PC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5JU2VydmVyUmVzb3VyY2VMaXN0ZW5lciByZW5hbWVkIHRvIElTZXJ2ZXJMaWZlY3ljbGVMaXN0ZW5lci4gU2V2ZXJhbCBtZXRob2RzIG1vdmVkIG91dCB0bwotICAgICAgbmV3IElSdW50aW1lTGlzdGVuZXIgYW5kIElTZXJ2ZXJDb25maWd1cmF0aW9uTGlzdGVuZXIgaW50ZXJmYWNlcy48L3RkPgotICA8dGQ+IlJlc291cmNlIiBoYWQgdG8gYmUgcmVtb3ZlZCBmcm9tIHRoZSBuYW1lLCBhbmQgdGhlIGludGVyZmFjZSBjb250YWluZWQgbWV0aG9kcyBmb3IKLSAgICAgIHJ1bnRpbWVzIGFuZCBzZXJ2ZXIgY29uZmlndXJhdGlvbnMgYXMgd2VsbC4gVGhleSBhcmUgc3BsaXQgdXAgc28gdGhhdCBBUEkgdXNlcnMgZG8gbm90Ci0gICAgICBuZWVkIHRvIGxpc3RlbiBmb3IgYWxsIHR5cGVzIG9mIGNoYW5nZXMgZnJvbSBhIHNpbmdsZSBpbnRlcmZhY2UuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5TZXJ2ZXJDb3JlLmdldFJlc291cmNlTWFuYWdlcigpLmFkZFNlcnZlclJlc291cmNlTGlzdGVuZXIobXlMaXN0ZW5lcik7PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5TZXJ2ZXJDb3JlLmFkZFJ1bnRpbWVMaWZlY3ljbGVMaXN0ZW5lcihteUxpc3RlbmVyKTs8L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPlB1Ymxpc2hpbmcgaW50ZXJmYWNlcyBjb21wbGV0ZWx5IHJld3JpdHRlbiAmIC5jb3JlLnJlc291cmNlcyBwYWNrYWdlIHJlbW92ZWQuPC90ZD4KLSAgPHRkPlRoZSBwdWJsaXNoaW5nIGludGVyZmFjZSB3YXMgb3V0ZGF0ZWQgYW5kIHdyaXR0ZW4gYmVmb3JlIHRoZSBFY2xpcHNlIHRlYW0gc3VwcG9ydCwKLSAgICAgIEFOVCwgb3Igb3RoZXIgcmVjZW50IHB1Ymxpc2hpbmcgbWV0aG9kcyBoYWQgYmVlbiBkZXZlbG9wZWQuIFRoZSBuZXcgQVBJIGFsbG93cyBmb3IKLSAgICAgIGJldHRlciBzdXBwb3J0IGFuZCBmb3IgZWFjaCBzZXJ2ZXIgdHlwZSB0byB1c2UgaXQncyBvd24gcHVibGlzaGluZyBtZWNoYW5pc20uPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+SVJ1bnRpbWVEZWxlZ2F0ZSBhbmQgSVJ1bnRpbWVXb3JraW5nQ29weURlbGVnYXRlIG1lcmdlZCBpbnRvIGEgc2luZ2xlIFJ1bnRpbWVEZWxlZ2F0ZS4KLSAgICAgIElTZXJ2ZXJEZWxlZ2F0ZSBhbmQgSVNlcnZlcldvcmtpbmdDb3B5RGVsZWdhdGUgcmV3b3JrZWQgaW50byAKLSAgICAgIFNlcnZlckRlbGVnYXRlIGFuZCBTZXJ2ZXJCZWhhdmlvdXJEZWxlZ2F0ZS48L3RkPgotICA8dGQ+TWFraW5nIGNsaWVudHMgcHJvdmlkZSB0d28gc2VwYXJhdGUgY2xhc3NlcyBmb3IgdGhlIGRlbGVnYXRlcyB3YXMgZXhjZXNzaXZlLAotICAgICAgdW5uZWNlc3NhcnksIGFuZCBlbmRlZCB1cCB3aXRoIHRvbyBtYW55IFNQSSBjbGFzc2VzLiBPbmx5IGEgc2luZ2xlIGRlbGVnYXRlIGNsYXNzIGlzCi0gICAgICBub3cgcmVxdWlyZWQgZm9yIHRoZXNlIGV4dGVuc2lvbiBwb2ludHMuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+SVJ1bnRpbWUuZ2V0RGVsZWdhdGUoKSwgSVJ1bnRpbWUuZ2V0V29ya2luZ0NvcHlEZWxlZ2F0ZSgpIGNoYW5nZWQgaW50byBJUnVudGltZSBleHRlbmRpbmcKLSAgICAgIElBZGFwdGFibGUuIFNpbWlsYXIgZm9yIElTZXJ2ZXIgYW5kIG90aGVyIGRlbGVnYXRlczwvdGQ+Ci0gIDx0ZD5JQWRhcHRhYmxlIGlzIGEgY29tbW9uIEVjbGlwc2UgbWVjaGFuaXNtLCBhbmQgYWxsb3dzIGZvciBvdGhlciBleHRlbnNpb24gYXMgd2VsbC4gQ2xpZW50cwotICAgICAgc2hvdWxkIHN0aWxsIHJlbWVtYmVyIHRoYXQgY2FsbGluZyB0aGlzIG1ldGhvZCBtYXkgaW52b2x2ZSBwbHVnaW4gbG9hZGluZywgc28gaXQgc2hvdWxkCi0gICAgICBub3QgYmUgdXNlZCBpbiBwb3B1cCBtZW51cywgZXRjLjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+SVRvbWNhdFJ1bnRpbWUgdHIgPSAoSVRvbWNhdFJ1bnRpbWUpIHJ1bnRpbWUuZ2V0RGVsZWdhdGUoKTs8L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPklUb21jYXRSdW50aW1lIHRyID0gKElUb21jYXRSdW50aW1lKSBydW50aW1lLmdldEFkYXB0ZXIoSVRvbWNhdFJ1bnRpbWUuY2xhc3MpOzwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+SU1vZHVsZVR5cGUgYW5kIElNb2R1bGVLaW5kIGludGVyZmFjZXMgbWVyZ2VkLjwvdGQ+Ci0gIDx0ZD5JTW9kdWxlS2luZCB3YXMgY3JlYXRlZCBsYXRlIGluIHRoZSBwcmV2aW91cyByZWxlYXNlIGN5Y2xlIGFuZCBjb3VsZG4ndCBiZSBtZXJnZWQgYXQgdGhlCi0gICAgICB0aW1lIGl0IHdhcyBjcmVhdGVkLjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPklTZXJ2ZXJUYXNrIGNoYW5nZWQgYW5kIElNb2R1bGVUYXNrIHJlbW92ZWQuPC90ZD4KLSAgPHRkPlRoZSBleGlzdGluZyBpbnRlcmZhY2VzIGhhZCBhbiBJVGFzayBkaXJlY3RseSByZXR1cm5lZCBhcyBhIGRlbGVnYXRlLCBhbmQgb25seSBhbGxvd2VkIGEKLSAgICAgIHNpbmdsZSB0YXNrIHBlciBleHRlbnNpb24gcG9pbnQuIFRoZSBuZXcgSVNlcnZlclRhc2sgYWxsb3dzIHRoZSBkZWxlZ2F0ZSB0byByZXR1cm4gbXVsdGlwbGUKLSAgICAgIHRhc2tzIGZyb20gYSBzaW5nbGUgZXh0ZW5zaW9uIHBvaW50LCBhbmQgaXQgaXMgbm90IGl0c2VsZiBhIHRhc2suPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+SVNlcnZlckNvbmZpZ3VyYXRpb24sIElTZXJ2ZXJDb25maWd1cmF0aW9uLCBldGMuIHJlbW92ZWQ8L3RkPgotICA8dGQ+VGhlIHNlcnZlciBjb25maWcgd2FzIGEgcmVsaWMgYW5kIGRpZCBub3QgbmVlZCB0byBiZSBhIGZpcnN0IGNsYXNzIHJlc291cmNlLiBTZXJ2ZXJEZWxlZ2F0ZXMKLSAgICAgIGFyZSBub3cgZGlyZWN0bHkgcmVzcG9uc2libGUgZm9yIG1haW50YWluaW5nIHRoZSBjb25maWd1cmF0aW9uLjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5zZWUgVG9tY2F0IGltcGxlbWVudGF0aW9uPC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5WYXJpb3VzIG1pbm9yIGNsZWFudXAgLSBtZXRob2RzIHJlbmFtZWQsIHBhcmFtZXRlcnMgY2hhbmdlZCwgZXRjLjwvdGQ+Ci0gIDx0ZD5DbGVhbnVwIGFuZCBmdXR1cmUgbWFpbnRlbmFuY2UuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+SU1vZHVsZU9iamVjdEFkYXB0ZXIgLT4gSU1vZHVsZUFydGlmYWN0QWRhcHRlciwgSU1vZHVsZU9iamVjdCAtPiBJTW9kdWxlQXJ0aWZhY3Q8L3RkPgotICA8dGQ+T2JqZWN0IHdhcyB0b28gZ2VuZXJpYyBhbmQgZGlkbid0IGhhdmUgYW55IHJlYWwgbWVhbmluZy4gQXJ0aWZhY3QgcmVwcmVzZW50cyB3aGF0IHRoZQotICAgICAgSU1vZHVsZU9iamVjdCByZWFsbHkgcmVwcmVzZW50cyAtIHJlc291cmNlcyB3aXRoaW4gYSBtb2R1bGU8L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+PC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5nZXRTZXJ2ZXJUeXBlKFN0cmluZyBpZCkgLT4gZmluZFNlcnZlclR5cGUoU3RyaW5nIGlkKTwvdGQ+Ci0gIDx0ZD5Mb29rdXAgbWV0aG9kcyBvbiBTZXJ2ZXJDb3JlIGFuZCBTZXJ2ZXJVdGlsIHJlbmFtZWQgdG8gYmUgbW9yZSBhY2N1cmF0ZSB0byB3aGF0Ci0gICAgICB0aGV5IGRvLjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+SVNlcnZlclR5cGUgc3QgPSBnZXRTZXJ2ZXJUeXBlKCJjb20ueCIpPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5JU2VydmVyVHlwZSBzdCA9IGZpbmRTZXJ2ZXJUeXBlKCJjb20ueCIpPC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5Mb3RzIG9mIG1ldGhvZHMgJiBpbnRlcmZhY2VzIG1vdmVkIHRvIGludGVybmFsIHBhY2thZ2VzPC90ZD4KLSAgPHRkPk5lZWQgdG8gdHJpbSBkb3duIHRoZSBleHBvc2VkIEFQSSB0byBvbmx5IHdoYXQgaXMgcmVxdWlyZWQgZm9yIG9uZ29pbmcgbWFpbnRlbmFuY2UuIElmCi0gICAgICB0aGVyZSBpcyBhbnl0aGluZyBpbiBhbiBpbnRlcm5hbCBwYWNrYWdlIHRoYXQgeW91IHdlcmUgcHJldmlvdXNseSB1c2luZywgb3IgcGxhbiB0byB1c2UKLSAgICAgIGluIHRoZSBmdXR1cmUsIHBsZWFzZSBjb250YWN0IG1lIGFuZCB3ZSdsbCB3b3JrIG91dCBhbiBBUEkgc29sdXRpb248L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+PC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5QdWJsaXNoaW5nIGNoYW5nZXMgLSBzZXZlcmFsIGludGVyZmFjZXMgYW5kIHRoZSBvcmcuZWNsaXBzZS53c3Quc2VydmVyLmNvcmUucmVzb3VyY2UKLSAgICAgIHBhY2thZ2UgcmVtb3ZlZDwvdGQ+Ci0gIDx0ZD5UaGUgb2xkIHB1Ymxpc2hpbmcgbWVjaGFuaXNtIGRpZCBub3QgYWxsb3cgZmxleGliaWxpdHkgaW4gcHVibGlzaGluZyBvcHRpb25zIChlLmcuCi0gICAgICBBTlQsIEVjbGlwc2UgdGVhbSBzdXBwb3J0LCBvciBzb21lIG90aGVyIG1lY2hhbmlzbSkgYW5kIHVzZWQgYW4gb3V0ZGF0ZWQgcHVibGlzaGluZwotICAgICAgbWFuYWdlciBmcmFtZXdvcmsuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPlNlcnZlckRlbGVnYXRlLnB1Ymxpc2hTdGFydCgpOyAvLyBDYWxsZWQgdG8gdGVsbCB0aGUgc2VydmVyIHRoYXQgcHVibGlzaGluZyBpcyBzdGFydGluZy4KLSAgICAgIENhbiBiZSB1c2VkIHRvIGNvbm5lY3QgdG8gYSByZW1vdGUgc2VydmVyLCBldGMuPGJyLz4KLSAgICAgIFNlcnZlckRlbGVnYXRlLnB1Ymxpc2hTdGFydCgpOyAvLyBDYWxsZWQgb25jZSB0byBhbGxvdyB0aGUgc2VydmVyIHRvIHB1Ymxpc2ggYW55ICJnbG9iYWwiCi0gICAgICByZXNvdXJjZXMgb3IgYSBzZXJ2ZXIgY29uZmlnPGJyLz4KLSAgICAgIFNlcnZlckRlbGVnYXRlLnB1Ymxpc2hTdGFydCgpOyAvLyBDYWxsZWQgZm9yIGVhY2ggbW9kdWxlIHRvIGdpdmUgdGhlIHNlcnZlciBhIGNoYW5jZQotICAgICAgdG8gcHVibGlzaCB1c2luZyBhbnkgbWV0aG9kIGl0IHdhbnRzPGJyLz4KLSAgICAgIFNlcnZlckRlbGVnYXRlLnB1Ymxpc2hGaW5pc2goKTsgLy8gQ2FsbGVkIHRvIGRpc2Nvbm5lY3QgZnJvbSB0aGUgc2VydmVyIG9yIGNsZWFudXA8L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPklNb25pdG9yYWJsZVNlcnZlciBtZXJnZWQgd2l0aCBJU2VydmVyPC90ZD4KLSAgPHRkPk5vIG5lZWQgZm9yIDwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+SVNlcnZlckRlbGVnYXRlIGRlbGVnYXRlID0gc2VydmVyLmdldERlbGVnYXRlKCk8YnIvPgotICAgICAgaWYgKGRlbGVnYXRlIGluc3RhbmNlb2YgSU1vbml0b3JhYmxlU2VydmVyKSB7PGJyLz4KLSAgICAgICAgIElNb25pdG9yYWJsZVNlcnZlciBtcyA9IChJTW9uaXRvcmFibGVTZXJ2ZXIpIGRlbGVnYXRlOzxici8+Ci0gICAgICAgICBMaXN0IHBvcnRzID0gbXMuZ2V0U2VydmVyUG9ydHMoKTs8YnIvPgotICAgICAgfTwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+SVNlcnZlclBvcnRbXSBwb3J0cyA9IHNlcnZlci5nZXRTZXJ2ZXJQb3J0cygpOzwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+V29ya2luZyBjb3B5IGNoYW5nZXM8L3RkPgotICA8dGQ+UHJldmlvdXNseSwgcmVmZXJlbmNlcyB3ZXJlIGtlcHQgdG8gZXZlcnkgd29ya2luZyBjb3B5LCBhbmQgY2xpZW50cyBoYWQgdG8gc2F2ZSgpIG9yCi0gICAgICByZWxlYXNlKCkgdGhlbSBpbiBmaW5hbGx5IGJsb2NrcyBvciBlbHNlIHRoZSByZWZlcmVuY2Ugd291bGQgYmUgZGFuZ2xpbmcgKGFuZCBwb3NzaWJseQotICAgICAgYmxvY2tpbmcgb3RoZXIgY2hhbmdlcykgZm9yZXZlci4gVGhpcyBjb2RlIHdhcyB1bnNhZmUgYW5kIGNhdXNlZCBwcm9ibGVtcyBpZiBhIGNsaWVudAotICAgICAgdHJpZWQgdG8gdXNlIGEgd29ya2luZyBjb3B5IGFmdGVyIGl0IGhhZCBiZWVuIHNhdmVkIG9yIHJlbGVhc2VkLgotICAgICAgTm93LCBjbGllbnRzIGNhbiBjcmVhdGUgYSB3b3JraW5nIGNvcHkgYXQgYW55IHRpbWUsIGFuZCByZWZlcmVuY2VzIGFyZSBub3Qga2VwdC4gT24KLSAgICAgIHNhdmUsIGEgY2xpZW50IGNhbiBzcGVjaWZ5IHdoZXRoZXIgdGhlIHdvcmtpbmcgY29weSBjaGFuZ2VzIHNob3VsZCBiZSBmb3JjZWQsIG9yIG5vdAotICAgICAgKGluIHdoaWNoIGNhc2UgdGhlIHNhdmUgd2lsbCBmYWlsIGlmIHNvbWVvbmUgZWxzZSBoYXMgbWFkZSBjaGFuZ2VzIHRvIHRoZSBvYmplY3QgaW4KLSAgICAgIHRoZSBtZWFudGltZSkuIElmIHRoZSBjaGFuZ2VzIGRvIG5vdCBuZWVkIHRvIGJlIHNhdmVkLCBjbGllbnRzIGNhbiBqdXN0IGRyb3AgdGhlCi0gICAgICByZWZlcmVuY2UgdG8gdGhlIHdvcmtpbmcgY29weSBhdCBhbnkgdGltZS4gQXMgYmVmb3JlLCB3b3JraW5nIGNvcGllcyBzaG91bGQgbm90IGJlCi0gICAgICB1c2VkIGZvciBsb25nIHBlcmlvZHMgb2YgdGltZSBzaW5jZSBpdCBpbmNyZWFzZXMgdGhlIGNoYW5jZXMgdGhhdCBhbm90aGVyIGNsaWVudCBoYXMKLSAgICAgIG1hZGUgY2hhbmdlczwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+SVNlcnZlcldvcmtpbmdDb3B5IHdjID0gSVNlcnZlci5nZXRXb3JraW5nQ29weSgpOzxici8+Ci0gICAgICAvLyBkbyBzb21ldGhpbmcgd2l0aCB3Yzxici8+Ci0gICAgICB3Yy5zYXZlKCk7IG9yIHdjLnJlbGVhc2UoKTs8L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPklTZXJ2ZXJXb3JraW5nQ29weSB3YyA9IElTZXJ2ZXIuY3JlYXRlV29ya2luZ0NvcHkoKTs8YnIvPgotICAgICAgLy8gZG8gc29tZXRoaW5nIHdpdGggd2M8YnIvPgotICAgICAgd2Muc2F2ZSgpOyBvciBsb3NlIHJlZmVyZW5jZTwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+Q2hhbmdlIElTZXJ2ZXIuaXNSZXN0YXJ0TmVlZGVkKCkgdG8gbWF0Y2ggb3RoZXIgbWV0aG9kczwvdGQ+Ci0gIDx0ZD48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPklTZXJ2ZXIuaXNSZXN0YXJ0TmVlZGVkKCk7PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5JU2VydmVyLmdldFNlcnZlclJlc3RhcnRTdGF0ZSgpOzwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+PC90ZD4KLSAgPHRkPjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotPC90cj4KLTwvdGFibGU+Ci0KLTwvYm9keT4KLTwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL1NlcnZlciBUb29scyBQYWNrYWdlIFJlbmFtZXMucHJvcGVydGllcyBiL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvU2VydmVyIFRvb2xzIFBhY2thZ2UgUmVuYW1lcy5wcm9wZXJ0aWVzCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA4ZmI1NjY4Li4wMDAwMDAwCi0tLSBhL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvU2VydmVyIFRvb2xzIFBhY2thZ2UgUmVuYW1lcy5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTAgKzAsMCBAQAotY29tLmlibS53dHAuc2VydmVyLmNvcmU9b3JnLmVjbGlwc2Uud3N0LnNlcnZlci5jb3JlCi1jb20uaWJtLnd0cC5zZXJ2ZXIudWk9b3JnLmVjbGlwc2Uud3N0LnNlcnZlci51aQotY29tLmlibS53dHAuc2VydmVyLnV0aWw9b3JnLmVjbGlwc2Uud3N0LnNlcnZlci51dGlsCi1jb20uaWJtLnd0cC5zZXJ2ZXIuamF2YS5jb3JlPW9yZy5lY2xpcHNlLmpzdC5zZXJ2ZXIuY29yZQotY29tLmlibS53dHAuc2VydmVyLmphdmEudWk9b3JnLmVjbGlwc2UuanN0LnNlcnZlci51aQotY29tLmlibS53dHAuc2VydmVyLnRvbWNhdC5jb3JlPW9yZy5lY2xpcHNlLmpzdC5zZXJ2ZXIudG9tY2F0LmNvcmUKLWNvbS5pYm0ud3RwLnNlcnZlci50b21jYXQudWk9b3JnLmVjbGlwc2UuanN0LnNlcnZlci50b21jYXQudWkKLWNvbS5pYm0ud3RwLm1vbml0b3IuY29yZT1vcmcuZWNsaXBzZS53c3QubW9uaXRvci5jb3JlCi1jb20uaWJtLnd0cC5tb25pdG9yLnVpPW9yZy5lY2xpcHNlLndzdC5tb25pdG9yLnVpCi1jb20uaWJtLnd0cC53ZWJicm93c2VyPW9yZy5lY2xpcHNlLndzdC53ZWJicm93c2VyClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy9TZXJ2ZXJUb29sc1VzZUNhc2VzLmh0bWwgYi9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL1NlcnZlclRvb2xzVXNlQ2FzZXMuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNGI4MTI4Ny4uMDAwMDAwMAotLS0gYS9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL1NlcnZlclRvb2xzVXNlQ2FzZXMuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDMyNSArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL3czYy8vZHRkIGh0bWwgNC4wIHRyYW5zaXRpb25hbC8vZW4iPgotPGh0bWw+PGhlYWQ+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4KLQotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2RlZmF1bHRfc3R5bGUuY3NzIiB0eXBlPSJ0ZXh0L2NzcyI+Ci08L2hlYWQ+Ci0KLQotCi08Ym9keSBhbGluaz0iI2ZmMDAwMCIgYmdjb2xvcj0iI2ZmZmZmZiIgbGluaz0iIzAwMDBlZSIgdGV4dD0iIzAwMDAwMCIgdmxpbms9IiM1NTFhOGIiPgotCi08dGFibGUgYm9yZGVyPSIwIiBjZWxscGFkZGluZz0iMiIgY2VsbHNwYWNpbmc9IjUiIHdpZHRoPSIxMDAlIj4KLQotICA8dGJvZHk+PHRyPiAKLQotIAkJPFREIFdJRFRIPTYwJT4KLQkJCTxQIEFMSUdOPUxFRlQ+PEI+PEZPTlQgU0laRT02PjxGT05UIEZBQ0U9IlZlcmRhbmEsIEFyaWFsLCBIZWx2ZXRpY2EsIHNhbnMtc2VyaWYiPlNlcnZlciBUb29scyBVc2UgQ2FzZXM8L0ZPTlQ+PC9GT05UPjwvQj48QlI+PEZPTlQgU0laRT0xPjxGT05UIEZBQ0U9IkFyaWFsLCBIZWx2ZXRpY2EsIHNhbnMtc2VyaWYiPjxGT05UIENPTE9SPSIjODA4MGZmIj50aGUKLQkJCVNlcnZlciBUb29scyBVc2UgQ2FzZXM8L0ZPTlQ+PC9GT05UPjwvRk9OVD4KLQkJCQkJCTwvUD4KLQkJPC9URD4KLQotCi08L3RkPgotCi08IS0tICAgIDx0ZCB3aWR0aD0iMTklIiByb3dzcGFuPSIyIj48aW1nIHNyYz0iaW1hZ2VzL0lkZWEuanBnIiBoZWlnaHQ9ODYgd2lkdGg9MTIwPjwvdGQ+IC0tPgotCi0gICAgPHRkIHJvd3NwYW49IjIiIHdpZHRoPSIxOSUiPjxpbWcgc3JjPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2ltYWdlcy9JZGVhLmpwZyIgYm9yZGVyPSIwIiBoZWlnaHQ9Ijg2IiB3aWR0aD0iMTIwIj48L3RkPgotCi0gIDwvdHI+Ci0KLQotPC90Ym9keT48L3RhYmxlPgotCi08dGFibGUgYm9yZGVyPSIwIiBjZWxscGFkZGluZz0iMiIgY2VsbHNwYWNpbmc9IjUiIHdpZHRoPSIxMDAlIj4KLQotICA8dGJvZHk+PHRyPiAKLQotICAgIDx0ZCBjb2xzcGFuPSIyIiBhbGlnbj0ibGVmdCIgYmdjb2xvcj0iIzAwODBjMCIgdmFsaWduPSJ0b3AiPjxiPjxmb250IGNvbG9yPSIjZmZmZmZmIiBmYWNlPSJBcmlhbCxIZWx2ZXRpY2EiPlByaW5jaXBsZXM8L2ZvbnQ+PC9iPjwvdGQ+Ci0KLSAgPC90cj4KLTx0cj4KLTx0ZD4KLTxwPlRoZSBwdXJwb3NlIG9mIHRoaXMgZG9jdW1lbnQgaXMgdG8gbGlzdCBleHBsaWNpdCB1c2UgY2FzZXMgZm9yIHRoZSBzZXJ2ZXIgdG9vbHMgY29tcG9uZW50LiBUaGVzZSB1c2VzIGNhc2VzIGNhbiBiZSB1c2VkIHRvIGJvdGggaGVscCBndWlkZSBkZXNpZ24gKHRvIG1ha2Ugc3VyZSBtaW5pbWFsIEFQSSBpcyBzdWZmaWNpZW50IHRvIHN1cHBvcnQgdGhlc2UgbGlzdGVkLCBhbmQgb25seSB0aGVzZSBsaXN0ZWQsIHVzZSBjYXNlcykgYW5kIHRvIGhlbHAgZ3VpZGUgdGVzdGluZyAoYm90aCB1bml0IHRlc3RzLCBhbmQgbWlsZXN0b25lL3JlbGVhc2UgdGVzdGluZykuPC9wPgotCQkJPFA+PEI+UHJpbmNpcGxlOjwvQj4gV2UnbGwgY29uc2lkZXIgc3RhcnRpbmcgcG9pbnQgbmFpdmUgZW5kIHVzZXJzIHdobwotCQkJa25vdyBub3RoaW5nIG9mIHNlcnZlcnMsIGFuZCB0aGV5IGRvbid0IGNhcmUsIGp1c3Qgd2FudCBvbmUgaW5zdGFsbGVkCi0JCQlpbnN0YWxsZWQgc28gdGhleSBjYW4gZm9jdXMgb24gdGhlaXIgd2ViIGRldmVsb3BtZW50LiBXZSdsbCBjb25zaWRlcgotCQkJdGhyZWUgbGV2ZWxzOiAxKSBVc2VyIGRvZXMgbmVhciBub3RoaW5nLCAyKSB1c2VyIGRvZXNuJ3QgZG8gbXVjaCwgYnV0Ci0JCQltYXkgaGF2ZSB0byBwcm92aWRlIHNvbWUgY29uZmlndXJhdGlvbiB2YWx1ZXMgYW5kL29yIGltcG9ydAotCQkJY29uZmlndXJhdGlvbiB2YWx1ZXMuIDMpIFVzZXIgaGFzIHRvIHByb3ZpZGUgbWFueSBjb25maWd1cmF0aW9uCi0JCQl2YWx1ZXMsIGFuZCBpbiB0aGUgd29yc3QgY2FzZXMsIGFjdHVhbGx5IHdyaXRlIGFudCBzY3JpcHRzLjwvUD4KLQkJCTxwPjxiPlByaW5jaXBsZTo8L2I+IEluIGFkZGl0aW9uIHRvICJlbmQgdXNlciIgdXNlIGNhc2VzLCAKLXdlJ2xsIHNwZWNpZnkgJnF1b3Q7Y2xpZW50IGNvZGUmcXVvdDsgdXNlcy1jYXNlIHRoYXQgbWF5Ci1zaW1wbHkgYmUgc3BlY2lmeWluZyBkZXRhaWxzIG9mIGZ1bmN0aW9uIG5lZWRlZCBmb3IgZW5kLXVzZXIgdXNlIGNhc2VzLCBidXQKLXdpbGwgYWx3YXlzIGhhdmUgYSB1bml0IHRlc3QgYXNzb2NpYXRlZCB3aXRoIGl0LiBBbHNvLCB3ZSdsbCBzcGVjaWZ5ICJzZXJ2aWNlIHByb3ZpZGVyIiAKLXVzZSBjYXNlcyB3aGljaCBjYW4gYmUgdXNlZCB0byBkZWZpbmUgU1BJJ3MuIDwvcD4KLTwvdGQ+Ci08L3RyPgotPHRyPgotICAgIDx0ZCBjb2xzcGFuPSIyIiBhbGlnbj0ibGVmdCIgYmdjb2xvcj0iIzAwODBjMCIgdmFsaWduPSJ0b3AiPjxiPjxmb250IGNvbG9yPSIjZmZmZmZmIiBmYWNlPSJBcmlhbCxIZWx2ZXRpY2EiPkVuZCBVc2VyIFVzZSBDYXNlczwvZm9udD48L2I+PC90ZD4KLSAgPC90cj4KLSAgPHRyPgotICA8dGQ+Ci0gPHRhYmxlIHdpZHRoPSI5NSUiIGJvcmRlcj0iMSIgY2VsbHBhZGRpbmc9IjEiIGNlbGxzcGFjaW5nPSIxIj4KLQk8dGJvZHk+Ci0JCTx0cj4KLQkJCTx0aCBzdHlsZT0id2lkdGg6IDEwOHB4Ij5OYW1lPC90aD4KLQkJCTx0aCBzdHlsZT0id2lkdGg6IDYwcHgiPlByaW9yaXR5PC90aD4KLQkJCTx0aCBzdHlsZT0id2lkdGg6IDM2MHB4Ij5EZXNjcmlwdGlvbjwvdGg+Ci0JCTwvdHI+Ci0JCTx0cj4KLQkJCTx0ZD5JbnN0YWxsIGEgU2VydmVyPC90ZD4KLQkJCTx0ZD4yPC90ZD4KLQkJCTx0ZD5Gcm9tIGFuIHVwZGF0ZSBzaXRlLCB1c2VyIGNhbiBpbnN0YWxsIGEKLQkJCXNlcnZlciAodXNpbmcgRWNsaXBzZSBzdGFuZGFyZCB1cGRhdGUgbWFuYWdlciBmdW5jdGlvbnMpLjwvdGQ+Ci0JCTwvdHI+Ci0JCTx0cj4KLQkJCTx0ZD5Db25maWd1cmUgYSBKYWthcnRhLXRvbWNhdDwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+R2l2ZW4gYSBKYWthcnRhLXRvbWNhdCBzZXJ2ZXIgKFY1KSBpbnN0YWxsZWQKLQkJCW9uIGxvY2FsIGZpbGUgc3lzdGVtLCB1c2VyIGNhbiAmcXVvdDtpbnN0YWxsJnF1b3Q7IGEgc2VydmVyIHRvIFdUUCBieQotCQkJc2VsZWN0aW5nIGZyb20gYSBsaXN0IG9mIGF2YWlsYWJsZSBzZXJ2ZXIgYWRhcHRlcnMsIHNlbGVjdGluZyB0aGUgb25lCi0JCQlmb3IgSmFrYXJ0YS10b21jYXQgc2VydmVyLCBhbmQgc3BlY2lmeWluZyBsb2NhdGlvbiBvZiBzZXJ2ZXIncwotCQkJaW5zdGFsbCBkaXJlY3RvcnkuCi0JCQk8dGFibGUgYm9yZGVyPSIxIj4KLQkJCQk8dGJvZHk+Ci0JCQkJCTx0cj4KLQkJCQkJCTx0ZD5WYXJpYW50IDE8L3RkPgotCQkJCQkJPHRkIHN0eWxlPSJ3aWR0aDogMjc3cHgiPkpCb3NzIFNlcnZlciBpbnN0ZWFkPC90ZD4KLQkJCQkJPC90cj4KLQkJCQk8L3Rib2R5PgotCQkJPC90YWJsZT4KLQkJCTwvdGQ+Ci0JCTwvdHI+Ci0KLQkJPHRyPgotCQkJPHRkPkV4cG9ydCBBTlQgYnVpbGQgc2NyaXB0cyBmb3IgbW9kdWxlczwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+VXNlciBleHBvcnRzIEFOVCBidWlsZCBzY3JpcHQgdGhhdCBjb21waWxlcyBhbmQgcGFja2FnZXMgYSBtb2R1bGUgaW4gZm9yIHVzZSBvdXRzaWRlIHRoZSBFY2xpcHNlLCBwb3NzaWJseSBmb3IgYXV0b21hdGVkIGJ1aWxkcy4gPC90ZD4KLQkJPC90cj4KLQkJPHRyPgotCQkJPHRkPkRyYWcgYSBtb2R1bGUvYXJ0aWZhY3QgdG8gYSBzZXJ2ZXIgdG8gcHVibGlzaCBpdDwvdGQ+Ci0JCQk8dGQ+MzwvdGQ+Ci0JCQk8dGQ+VXNlcnMgZHJhZ3MgYSBtb2R1bGUgb3IgYSBhcnRpZmFjdCBpbiBpdCBpbnRvIGEgc2VydmVyLCB3aGljaCB3b3VsZCBtZWFuIHRoZSBzYW1lIGFjdGlvbiBhcyAmcXVvdDtSdW4gb24gU2VydmVyJnF1b3Q7IC48L3RkPgotCQk8L3RyPgotCi0JCTx0cj4KLQkJCTx0ZD5ydW4gb24gSjJFRSBzZXJ2ZXI8L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPnVzZXIgY2FuIHNlbGVjdCBhIEpTUCBhbmQgJnF1b3Q7cnVuIG9uCi0JCQlzZXJ2ZXImcXVvdDssIG1lYW5pbmcgaXQgd2lsbCBiZSBkaXNwbGF5ZWQgaW4gRWNsaXBzZSB3ZWIgYnJvd3Nlci4KLQkJCTx0YWJsZSBib3JkZXI9IjEiPgotCQkJCTx0Ym9keT4KLQkJCQkJPHRyPgotCQkJCQkJPHRkIHN0eWxlPSJ3aWR0aDogNjZweCI+VmFyaWFudCAxPC90ZD4KLQkJCQkJCTx0ZCBzdHlsZT0id2lkdGg6IDM0OHB4Ij5JZiBubyBtb3JlIHRoYW4gb25lIGluc3RhbGxlZCwgdGhlIHVzZXIKLQkJCQkJCXdpbGwgbm90IGdldCBsaXN0IHRvIHNlbGVjdCBmcm9tPC90ZD4KLQkJCQkJPC90cj4KLQkJCQk8L3Rib2R5PgotCQkJPC90YWJsZT4KLQkJCTx0YWJsZSBib3JkZXI9IjEiPgotCQkJCTx0Ym9keT4KLQkJCQkJPHRyPgotCQkJCQkJPHRkIHN0eWxlPSJ3aWR0aDogNjlweCI+VmFyaWFudCAyPC90ZD4KLQkJCQkJCTx0ZCBzdHlsZT0id2lkdGg6IDM0NXB4Ij5JZiBub25lIGluc3RhbGxlZCwgdGhlIHVzZXIgd2lsbCBiZSBnaXZlbgotCQkJCQkJYSBjaGFuY2UgdG8gc2VsZWN0IGFuZCBpbnN0YWxsIG9uZSAoc2VlIEluc3RhbGwgYSBTZXJ2ZXIpPC90ZD4KLQkJCQkJPC90cj4KLQkJCQk8L3Rib2R5PgotCQkJPC90YWJsZT4KLQkJCTx0YWJsZSBib3JkZXI9IjEiPgotCQkJCTx0Ym9keT4KLQkJCQkJPHRyPgotCQkJCQkJPHRkIHN0eWxlPSJ3aWR0aDogNjVweCI+VmFyaWFudCAzPC90ZD4KLQkJCQkJCTx0ZCBzdHlsZT0id2lkdGg6IDM0OXB4Ij5JZiBtb3JlIHRoYW4gb25lIGluc3RhbGxlZCwgdXNlciBnaXZlbgotCQkJCQkJdGhlIGxpc3Q8L3RkPgotCQkJCQk8L3RyPgotCQkJCTwvdGJvZHk+Ci0JCQk8L3RhYmxlPgotCQkJPC90ZD4KLQkJPC90cj4KLQkJPFRSPgotCQkJPFREPnJ1biBvbiBIVFRQIHNlcnZlcjwvVEQ+Ci0JCQk8VEQ+PC9URD4KLQkJCTxURD5Vc2VyIGNhbiBzZWxlY3QgYW4gSFRNTCBmaWxlLCBhbmQgJnF1b3Q7cnVuIG9uIHNlcnZlciZxdW90Oy4gVGhpcyB1c2UgY2FzZSBjYW4gYmUgcGVyZm9ybWVkIHdpdGggV1NUIG9ubHkuIChUaGlzIHVzZSBjYXNlIGhhcyBub3QgZ290dGVuIGEgbG90IG9mIGRpc2N1c3Npb24sIGJ1dCBzdXBwb3J0IGZvciAmcXVvdDtzdGF0aWMgcHJvamVjdHMmcXVvdDsgaXMgbWVudGlvbmVkIGluIFdUUC9XU1QgdmlzaW9uIHN0YXRlbWVudCwgYW5kIGlzIGEgZ29vZCBjYXNlIHRvIG1ha2Ugc3VyZSB0aGUgYXJjaGl0ZWN0dXJlIGFuZCBkZXNpZ24gaXMgY29ycmVjdCkuIDwvVEQ+Ci0JCTwvVFI+Ci0KLQkJPHRyPgotCQkJPHRkPkFkYXB0IHRvIGV4aXN0aW5nIHByb2plY3QvbW9kdWxlIGxheW91dDxpPihJIGFtIG5vdCBzdXJlLCB0aGlzIGlzIG1heSBiZSBhIHVzZSBjYXNlIGZvciBwcm9qZWN0IGxheW91dCk8L2k+PC90ZD4KLQkJCTx0ZD4xPC90ZD4KLQkJCTx0ZD5Vc2VyIGRlc2NyaWJlcyB0aGUgY3VycmVudCBwcm9qZWN0IGxheW91dCBldmVuIGlmIGl0IGlzIG5vdCBhIGtub3duIGxheW91dCBvZiBhbnkga2luZC4gPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+QWRkIHJ1bnRpbWU8L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPkFkZCBhIG5ldyBzZXJ2ZXIgcnVudGltZSBlbnZpcm9ubWVudCB0aGF0IGV4aXN0cyBvbiB0aGUgdXNlcidzIG1hY2hpbmUuIChQaWNrIHJ1bnRpbWUgZnJvbSBsaXN0LiBFbnRlciBuYW1lLCBsb2NhdGlvbi4gRW50ZXIgcnVudGltZSBzcGVjaWZpYyBpbmZvcm1hdGlvbi4pPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+RWRpdCBvciByZW1vdmUgcnVudGltZTwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+TW9kaWZ5IHJ1bnRpbWUgYXR0cmlidXRlcyBvciByZW1vdmUuPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+VGFyZ2V0IHByb2plY3Q8L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPlRhcmdldCBhIHByb2plY3QgdG8gYSBzcGVjaWZpYyBydW50aW1lLiBUaGlzIGlzIG9wdGlvbmFsIGFuZCBhIHByb2plY3QgbWF5IG9ubHkgYmUgdGFyZ2V0dGVkIHRvIG9uZSBydW50aW1lIGF0IGEgdGltZS4gKFNvbWUgcHJvamVjdCB0eXBlcyBkbwotICAgICAgICAgICAgICAgIG5vdCBuZWVkIGEgdGFyZ2V0LCBzb21lIHByb2plY3RzIGRvIG5lZWQgYSB0YXJnZXQpPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+QWRkIHNlcnZlcjwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+QWRkIChpbnN0YWxsKSBhIG5ldyBzZXJ2ZXIuIEVudGVyIG5hbWUgJiBob3N0bmFtZSwgcGljayBhIHNlcnZlciB0eXBlIGZyb20gYSBsaXN0LCBhbmQgZW50ZXIgc2VydmVyIHNwZWNpZmljIGluZm9ybWF0aW9uLiAoU29tZSBzZXJ2ZXIgdHlwZXMgbWF5IG9ubHkgc3VwcG9ydCBsb2NhbCwgbm90IHJlbW90ZS4gU29tZSBsb2NhbCBzZXJ2ZXJzIG1heSByZXF1aXJlIGEgcnVudGltZS4pPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+RWRpdCBvciByZW1vdmUgc2VydmVyPC90ZD4KLQkJCTx0ZD4xPC90ZD4KLQkJCTx0ZD5Nb2RpZnkgc2VydmVyIGF0dHJpYnV0ZXMgb3IgcmVtb3ZlLjwvdGQ+Ci0JCTwvdHI+Ci0KLQkJPHRyPgotCQkJPHRkPlN0YXJ0L1N0b3AvUmVzdGFydDwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+RWFjaCBzZXJ2ZXIgdHlwZSBtYXkgc3VwcG9ydCBzb21lL2FsbC9ub25lIG9mIHRoZXNlIHN0YXRlIGNoYW5nZXMuIEVhY2ggc2VydmVyIHR5cGUgaGFzIGFuIGluaXRpYWwgc3RhdGUgKG1heSBiZSB1bmtub3duKSwgYW5kIG11c3Qga2VlcCB0aGUgc3RhdGUgaW4gc3luYyBvbmNlIGl0IGlzIGxvYWRlZC4gCi0gICAgICAgICAgICAgICAgU29tZSBvZiB0aGUgc3RhdGUgY2hhbmdlcyAoc3RhcnQvc3RvcCkgYXJlIG5vdCBhdmFpbGFibGUgdW5sZXNzIHRoZSBzZXJ2ZXIgaXMgaW4gdGhlIGNvcnJlY3Qgc3RhdGUuIENvbnNvbGUvRGVidWcgdmlldywgZXRjLiBzaG91bGQgYmUgc3luYydlZCB1cCBvciB1c2VkIGFzIGl0IG1ha2VzIHNlbnNlCi0gICAgICAgICAgICAgICAgZm9yIHRoZSBzZXJ2ZXIgdHlwZS4gU3RhcnRpbmcgbWF5IGJlIGRvbmUgaW4gdGhlIHJlZ3VsYXIgRWNsaXBzZSBsYXVuY2ggbW9kZXMsIGUuZy4gUnVuLCBEZWJ1ZywgUHJvZmlsZSwgLi4uIGRlcGVuZGluZyBvbiB3aGF0IHRoZSBzZXJ2ZXIgc3VwcG9ydHMuIExhdW5jaCBDb25maWd1cmF0aW9ucyBhcmUKLSAgICAgICAgICAgICAgICBjcmVhdGVkIGFuZCB1c2VkIGFzIGFwcGxpY2FibGUuPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+QWRkIHByb2plY3Q8L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPkFkZCBhIG1vZHVsZSB0byBhIHNlcnZlci4gVXNlciBpcyBwcmVzZW50ZWQgd2l0aCBhIGxpc3Qgb2YgbW9kdWxlcyB0aGF0IGFyZSBhdmFpbGFibGUgdG8gYmUgYWRkZWQgdG8gdGhlIHNlcnZlciwgYXMgd2VsbCBhcyBhIGxpc3Qgb2YgbW9kdWxlcyBmcm9tIHRoZSB3b3Jrc3BhY2UgdGhhdCBhcmUKLSAgICAgICAgICAgICAgICBhbHJlYWR5IG9uIHRoZSBzZXJ2ZXIuIEluIHNvbWUgY2FzZXMsIHRoZSBzZXJ2ZXIgbWF5IHByZXNlbnQgYWRkaXRpb25hbCBtb2R1bGVzIGluIHRoZSBzZWNvbmQgbGlzdCB0aGF0IGFyZSBub3QgZnJvbSB0aGUgd29ya3NwYWNlL3VzZXIuIFVzZXIgY2FuIG1vdmUgbW9kdWxlcyBhcm91bmQgYW5kCi0gICAgICAgICAgICAgICAgd2hlbiB0aGV5IGFyZSBkb25lLCB0aGUgbW9kdWxlIGlzIGNvbmZpZ3VyZWQgb24gKGFuZCBwb3NzaWJseSBwdWJsaXNoZWQgdG8pIHRoZSBzZXJ2ZXIuPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+UmVtb3ZlIHByb2plY3Q8L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPlNhbWUgYXMgYWJvdmU8L3RkPgotCQk8L3RyPgotCQkKLQkJPHRyPgotCQkJPHRkPlB1Ymxpc2gvU3luYzwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+T25lIHdheSBwdWJsaXNoIG9mIGFsbCBtb2R1bGVzIHRvIGEgcGFydGljdWxhciBzZXJ2ZXIuIFN5bmNzIHRoZSBtb2R1bGUgY29udGVudCAtIGNvdWxkIGJlIGEgZGVsdGEgb3IgYSBmdWxsIHJlZnJlc2ggZGVwZW5kaW5nIG9uIHRoZSBpbXBsZW1lbnRhdGlvbi48L3RkPgotCQk8L3RyPgotCi0JCTx0cj4KLQkJCTx0ZD5SZXN0YXJ0IG1vZHVsZTwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+T3B0aW9uYWwgYmFzZWQgb24gc2VydmVyIHR5cGUgc3VwcG9ydC4gUmVzdGFydC9yZWZyZXNoL3JlbW92ZSBjYWNoZSBmb3IgYSBwYXJ0aWN1bGFyIG1vZHVsZSBvbiB0aGUgc2VydmVyIHRvIGFsbG93IHRoZSBuZXdseSBwdWJsaXNoZWQgY29udGVudCB0byBiZSBzZXJ2ZWQuPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+Q2hhbmdlIG5vdGlmaWNhdGlvbjwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+VXNlciBtYWtlcyBhIGNoYW5nZSB0byBhIG1vZHVsZSAoZS5nLiBlZGl0IGEgZmlsZSkuIFVzZXIgc2hvdWxkIGJlIG5vdGlmaWVkIG9mIHRoZSBpbXBhY3QgdG8gYW55IHJ1bm5pbmcgc2VydmVycyBhbmQgd2hhdCB0aGV5IG5lZWQgdG8gZG8gdG8gZ2V0IHRoZSBjaGFuZ2UKLQkJCSAgICBwcm9wb2dhdGVkIHRvIHRoZSBzZXJ2ZXIuIChlLmcuIG5vdGhpbmcsIHJlcHVibGlzaCwgcmVzdGFydCBtb2R1bGUsIHJlc3RhcnQgc2VydmVyKSA8L3RkPgotCQk8L3RyPgotCQkKLQkJPHRyPgotCQkJPHRkPkF1dG8gdXBkYXRlPC90ZD4KLQkJCTx0ZD4yPC90ZD4KLQkJCTx0ZD5BdXRvbWF0aWNhbGx5IG9yIHZpYSBhIHNpbmdsZSBjbGljaywgZG8gdGhlIGFib3ZlIHVzZSBjYXNlIHRvIGtlZXAgc2VydmVyIGluIHN5bmMgYXQgYWxsIHRpbWVzLjwvdGQ+Ci0JCTwvdHI+Ci0JCQotCQk8dHI+Ci0JCQk8dGQ+UnVuL0RlYnVnL1Byb2ZpbGUgb24gU2VydmVyPC90ZD4KLQkJCTx0ZD4xPC90ZD4KLQkJCTx0ZD5Gcm9tIGFueSBhcnRpZmFjdCAoVUkgc2VsZWN0aW9uLCBlZGl0b3IgaW5wdXQsIGV0Yy4pLCBkZXRlcm1pbmUgd2hpY2ggbW9kdWxlIGl0IGJlbG9uZ3MgdG8sIHByb21wdCB0byBjaG9vc2Ugb3IgY3JlYXRlIGEgc2VydmVyIGlmIG5lY2Vzc2FyeSwgcHVibGlzaC9zeW5jIHRoZSBtb2R1bGUgb24gdGhlIHNlcnZlciwgYW5kIGRpc3BsYXkgYW4KLQkJCSAgICBhcHByb3ByaWF0ZSBjbGllbnQgdG8gYWNjZXNzIChydW4pIHRoYXQgYXJ0aWZhY3Qgb24gdGhlIHNlcnZlci48L3RkPgotCQk8L3RyPgotCQkKLTwhLS0JCTx0cj4KLQkJCTx0ZD48L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPjwvdGQ+Ci0JCTwvdHI+LS0+Ci0KLQk8L3Rib2R5PgotPC90YWJsZT4KLTwvdGQ+PC90cj4KLQotPHRyPgotICAgIDx0ZCBjb2xzcGFuPSIyIiBhbGlnbj0ibGVmdCIgYmdjb2xvcj0iIzAwODBjMCIgdmFsaWduPSJ0b3AiPjxiPjxmb250IGNvbG9yPSIjZmZmZmZmIiBmYWNlPSJBcmlhbCxIZWx2ZXRpY2EiPkFQSSBVc2UgQ2FzZXM8L2ZvbnQ+PC9iPjwvdGQ+Ci0gIDwvdHI+Ci0KLQotPHRyPjx0ZD4KLSA8dGFibGUgd2lkdGg9Ijk1JSIgYm9yZGVyPSIxIiBjZWxscGFkZGluZz0iMSIgY2VsbHNwYWNpbmc9IjEiPgotCTx0Ym9keT4KLQkJPHRyPgotCQkJPHRoIHN0eWxlPSJ3aWR0aDogMTA4cHgiPk5hbWU8L3RoPgotCQkJPHRoIHN0eWxlPSJ3aWR0aDogNjBweCI+UHJpb3JpdHk8L3RoPgotCQkJPHRoIHN0eWxlPSJ3aWR0aDogMzYwcHgiPkRlc2NyaXB0aW9uPC90aD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+Q3JlYXRlIG1vZHVsZSB0eXBlKHMpPC90ZD4KLQkJCTx0ZD4xPC90ZD4KLQkJCTx0ZD5EZWZpbmUgYSBuZXcgdHlwZSBvZiBtb2R1bGUgKGludGVyZmFjZSBhbmQgaWQpIHNvIHRoYXQgb3RoZXIgU1BJIHByb3ZpZGVycyBjYW4gcHJvdmlkZSBpbnN0YW5jZXMgb2YgdGhlc2UgbW9kdWxlIG9yIHNlcnZlcnMgdGhhdCBzdXBwb3J0IHRoZW0uPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+UHJvdmlkZSBtb2R1bGUgZmFjdG9yeTwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+RGVmaW5lIGEgbmV3IG1vZHVsZSBmYWN0b3J5IGZvciBjcmVhdGluZy9kaXNjb3ZlcmluZyB0aGUgbW9kdWxlcyBvZiBhbiBleGlzdGluZyB0eXBlLiAoLm1vZHVsZXMgZmlsZT8pPC90ZD4KLQkJPC90cj4KLQkJCi0JCTx0cj4KLQkJCTx0ZD5EZWZpbmUgcnVudGltZSB0eXBlPC90ZD4KLQkJCTx0ZD4xPC90ZD4KLQkJCTx0ZD5EZWZpbmUgYSBuZXcgcnVudGltZSB0eXBlLCBhbG9uZyB3aXRoIHRoZSBtb2R1bGUgdHlwZXMgdGhhdCBpdCBzdXBwb3J0cy4gRGVmaW5lIHdoYXQgaXQgbWVhbnMgdG8gdGFyZ2V0IGEgcHJvamVjdCB0byB0aGlzIHJ1bnRpbWUuPC90ZD4KLQkJPC90cj4KLQkJCi0JCTx0cj4KLQkJCTx0ZD5EZWZpbmUgc2VydmVyIHR5cGU8L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPkRlZmluZSBhIG5ldyBzZXJ2ZXIgdHlwZSwgYWxvbmcgd2l0aCB0aGUgbW9kdWxlIHR5cGVzIHRoaXMgaXQgc3VwcG9ydHMuIFByb3ZpZGUgaW1wbGVtZW50YXRpb25zIGZvciBhZGQvcmVtb3ZlIG1vZHVsZXMsIHB1Ymxpc2hpbmcsIHN0YXJ0L3N0b3AsIGV0Yy48L3RkPgotCQk8L3RyPgotCQkKLQkJPHRyPgotCQkJPHRkPmdldCBsaXN0IG9mIHNlcnZlciBhZGFwdGVyczwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+cHJvZ3JhbW1hdGljYWxseSBnZXQgbGlzdCBvZiBrbm93bgotCQkJSmFrYXJ0YS10b21jYXQgc2VydmVycyBhZGFwdGVycyBhbmQgdGhlaXIgYXNzb2NpYXRlZCBpbmZvcm1hdGlvbgotCQkJKG5hbWUsIHZlcnNpb24sIHdoZXRoZXIgaW5zdGFsbGVkIG9yIG5vdCwgZXRjKTwvdGQ+Ci0JCTwvdHI+Ci0JCTx0cj4KLQkJCTx0ZD5nZXQgbGlzdCBvZiBpbnN0YWxsZWQgc2VydmVyczwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+cHJvZ3JhbW1hdGljYWxseSBnZXQgbGlzdCBvZiBpbnN0YWxsZWQKLQkJCXNlcnZlcnMgYW5kIHRoZWlyIGFzc29jaWF0ZWQgaW5mb3JtYXRpb24gKG5hbWUsIGV0Yyk8L3RkPgotCQk8L3RyPgotCQk8dHI+Ci0JCQk8dGQ+aW1wb3J0L2V4cG9ydCBzZXJ2ZXIgY29uZmlndXJhdGlvbjwvdGQ+Ci0JCQk8dGQ+MjwvdGQ+Ci0JCQk8dGQ+Q2FuIGltcG9ydCBvciBleHBvcnQgc2VydmVyIGNvbmZpZ3VyYXRpb24KLQkJCWZpbGVzLCBzdWNoIGFzIHRvIGdpdmUgdG8gYW5vdGhlciBtZW1iZXIgb2YgdGVhbS4gVGhpcyBmaWxlIG1heSBiZXN0Ci0JCQliZSBpbiBYTUwgZm9ybWF0LjwvdGQ+Ci0JCTwvdHI+Ci0JCTx0cj4KLQkJCTx0ZD5TZXJ2ZXIgUHJvdmlkZXJzIGNhbiBwcm92aWRlIGRpc2NvdmVyYWJsZSBhZGFwdGVyPC90ZD4KLQkJCTx0ZD4xIC0gU1BJPC90ZD4KLQkJCTx0ZD5UaGUgaW5mb3JtYXRpb24gbmVlZGVkIHRvIGJlIGxpc3RlZCBhcyBwb3RlbnRpYWwgc2VydmVyIGFkYXB0ZXIgY2FuIGJlIGZvdW5kIGNvbXBsZXRlbHkgaW4gcGx1Z2luLnhtbCAobm90IEphdmEgY29kZSwgd2hpY2ggd291bGQgcmVxdWlyZSBhY3RpdmF0aW9uIG9mIHBsdWdpbikuIDwvdGQ+Ci0JCTwvdHI+Ci0KLQkJPHRyPgotCQkJPHRkPlByb3ZpZGUgY2xhc3Nsb2FkZXIgYmVoYXZpb3I8L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPkEgY2xpZW50LCBhIGpzcC9lamIgY29tcGlsZXIgZm9yIGV4YW1wbGUsIGxlYXJucyB0aGUgY2xhc3Nsb2FkZXIgYmVoYXZpb3IgdG8gbWltaWMgdGhlIHNlcnZlciBydW50aW1lIGVudmlyb25tZW50PC90ZD4KLQkJPC90cj4KLQotCTwvdGJvZHk+Ci08L3RhYmxlPgotICA8L3RkPgotPC90cj4KLTwvdGJvZHk+PC90YWJsZT4KLQotCi08L2JvZHk+PC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCAiYS9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL1dUUCBGbGV4IHByb2plY3QgZGlzY3Vzc2lvblwwNTBDaHVja1wwNTEuZG9jIiAiYi9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL1dUUCBGbGV4IHByb2plY3QgZGlzY3Vzc2lvblwwNTBDaHVja1wwNTEuZG9jIgpkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMjllODYxMC4uMDAwMDAwMAotLS0gImEvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy9XVFAgRmxleCBwcm9qZWN0IGRpc2N1c3Npb25cMDUwQ2h1Y2tcMDUxLmRvYyIKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL1dUUCBTZXJ2ZXIgQ29yZSBBUElzLnBwdCBiL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvV1RQIFNlcnZlciBDb3JlIEFQSXMucHB0CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA2YjEyNzlhLi4wMDAwMDAwCi0tLSBhL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvV1RQIFNlcnZlciBDb3JlIEFQSXMucHB0CisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy9tb2R1bGVzX2FuZF9zZXJ2ZXJzLmh0bWwgYi9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL21vZHVsZXNfYW5kX3NlcnZlcnMuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggZDQyYjU2My4uMDAwMDAwMAotLS0gYS9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL21vZHVsZXNfYW5kX3NlcnZlcnMuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDMyNSArMCwwIEBACi08IS0tIHNhdmVkIGZyb20gdXJsPSgwMDIyKWh0dHA6Ly9pbnRlcm5ldC5lLW1haWwgLS0+Ci08aHRtbD4KLQotPGhlYWQ+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LUxhbmd1YWdlIiBjb250ZW50PSJlbi11cyI+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD13aW5kb3dzLTEyNTIiPgotPG1ldGEgbmFtZT0iR0VORVJBVE9SIiBjb250ZW50PSJNaWNyb3NvZnQgRnJvbnRQYWdlIDQuMCI+Ci08bWV0YSBuYW1lPSJQcm9nSWQiIGNvbnRlbnQ9IkZyb250UGFnZS5FZGl0b3IuRG9jdW1lbnQiPgotPHRpdGxlPk1vZHVsZXMgYW5kIFNlcnZlcnM8L3RpdGxlPgotPC9oZWFkPgotCi08Ym9keT4KLQotPGgxPldUUCBTZXJ2ZXIgVG9vbHMgQVBJPGJyPgotTW9kdWxlcyBhbmQgU2VydmVyczwvaDE+Ci08cD5MYXN0IG1vZGlmaWVkIE5vdi4gMywgMjAwNDwvcD4KLTxwPlRoZXNlIGRlc2lnbiBub3RlcyBncmV3IG91dCBvZiBkaXNjdXNzaW9ucyBiZXR3ZWVuIEppbSBkZXMgUml2aWVyZXMgYW5kIFRpbQotRGVib2VyIHRoZSB3ZWVrIG9mIE9jdC4gMjUtMjcuIFRoZSBxdWVzdGlvbiBpcyBob3cgdG8gdGhpbmsgb2YgdGhlCi0mcXVvdDttb2R1bGVzJnF1b3Q7IGFzIHRoZXkgYXBwZWFyIGluIHRoZSBTZXJ2ZXIgQ29yZSBBUEksIGFuZCBob3cgYmVzdCB0byBhbGxvdwotZm9yIGZsZXhpYmxlIG1vZHVsZXMgbGF5b3V0cyBpbiB0aGUgd29ya3NwYWNlLjwvcD4KLTxoMj5XaG8gb3ducyB0aGUgbm90aW9uIG9mIG1vZHVsZT88L2gyPgotPHA+QSBtb2R1bGUgY29uc2lzdHMgb2Ygc29tZSBjb250ZW50IC0gdHlwaWNhbGx5IHNvbWUgZmlsZXMgaW4gdGhlIHdvcmtzcGFjZS4KLUVhY2ggZGlmZmVyZW50IG1vZHVsZSB0eXBlIHdpbGwgaGF2ZSBpdHMgb3duIHJ1bGVzIGZvciB0aGUgc3RydWN0dXJlIGFuZCBtZWFuaW5nCi1vZiBpdHMgY29udGVudC4gRm9yIGV4YW1wbGUsIGEgc2ltcGxlIHdlYiBtb2R1bGUgbWlnaHQgY29uc2lzdCBvZiBhIHNpbXBsZSB0cmVlCi1vZiBIVE1MIGZpbGVzLiBXaGVuIHRoZSBtb2R1bGUgaXMgcHVibGlzaGVkIHRvIGEgc2VydmVyLCB0aGVzZSBmaWxlcyB3aWxsIGJlCi1jb3BpZWQgdG8gdGhlIHJlYWwgc2VydmVyLjwvcD4KLTxwPkhvd2V2ZXIsIGl0J3MgZnVubnkgdG8gdGhpbmsgb2YgdGhlIG1vZHVsZSBhcyBzb21ldGhpbmcgdGhhdCBleGlzdHMgc29sZWx5Ci1mb3IgdGhlIHB1cnBvc2Ugb2YgYmVpbmcgcHVibGlzaGVkLiBBIG1vZHVsZSBpbiB0aGUgd29ya3NwYWNlIHNob3VsZCBiZSB2aWV3ZWQKLWFzIHNvbWV0aGluZyByaWNoIGFuZCBtdWx0aS1mYWNldGVkLiBNb3N0IG9mIHRoZSBpbnRlcmVzdGluZyBhc3BlY3RzIG9mIGEgbW9kdWxlCi13aWxsIGJlIGxlZnQgdXAgdG8gdGhlIHBhcnRpZXMgdGhhdCBhY3R1YWxseSBkZWZpbmVzIHJlYWwgbW9kdWxlcy4gSXQncyBsaWtlIHRoZQotZGlmZmVyZW5jZSBiZXR3ZWVuIHRoZSBub3Rpb25zIG9mIGVtcGxveWVlIGFuZCBwZXJzb24uIEFuIGVtcGxveWVlIGlzIGEgbGltaXRlZAotbm90aW9uIHN1aXRhYmxlIGZvciB0aGUgbGltaXRlZCBwdXJwb3NlcyBvZiBkZXNjcmliaW5nIGFuIG9yZ2FuaXphdGlvbiBvciBhCi1wYXlyb2xsOyBhIHBlcnNvbiBpcyBhIG1vcmUgZ2VuZXJhbCBub3Rpb24uPC9wPgotPHA+QXMgZGlzY3Vzc2VkIGluIHRoZSBKU1QgY29udGVudCwgdGhlcmUgbmVlZHMgdG8gZmxleGliaWxpdHkgb24gaG93IEoyRUUKLW1vZHVsZXMgZ2V0IGxhaWQgb3V0IGluIHRoZSB3b3Jrc3BhY2UuIFRoZSBjb21wbGV4aXRpZXMgaW5jbHVkZTo8L3A+Ci08b2w+Ci0gIDxsaT5TaW5nbGUgb3IgbXVsdGlwbGUgbW9kdWxlcyBwZXIgd29ya3NwYWNlIHByb2plY3QuPC9saT4KLSAgPGxpPkZpbGVzLCBsaWtlIEphdmEgc291cmNlIGNvZGUsIHRoYXQgYXJlIG9yZGluYXJpbHkgY29uc2lkZXJlZCBwYXJ0IG9mIHRoYXQKLSAgICBtb2R1bGUncyBjb250ZW50LCBidXQgbm90IGZvciB0aGUgcHVycG9zZXMgb2YgcHVibGlzaGluZyB0byB0aGUgc2VydmVyLjwvbGk+Ci0gIDxsaT5Nb2R1bGVzIHdpdGggZmlsZXMgcmVzaWRpbmcgaW4gSkFSIGFyY2hpdmVzIHJhdGhlciB0aGFuIGRpcmVjdGx5IGluIHRoZQotICAgIGZpbGUgc3lzdGVtLjwvbGk+Ci0gIDxsaT5KMkVFIHBhcmVudC1jaGlsZCByZWxhdGlvbnNoaXBzIGJldHdlZW4gbW9kdWxlcyB0aGF0IG1heSBvciBtYXkgbm90IGJlCi0gICAgcmVwcmVzZW50ZWQgd2l0aCBkaXJlY3RvcnkgY29udGFpbm1lbnQuPC9saT4KLTwvb2w+Ci08cD5HaXZlbiB0aGUgaGlnaCBkZWdyZWUgb2YgdmFyaWFiaWxpdHkgKGFuZCBjdXJyZW50IHVuY2VydGFpbnR5KSBvbiB0aGUgbW9kdWxlCi1zaWRlLCBvbmUgZWZmZWN0aXZlIHN0cmF0ZWd5IGlzIHRvIHNlcGFyYXRlIG1vZHVsZS1yZWxhdGVkIGNvbmNlcm5zIGFzIG11Y2ggYXMKLXBvc3NpYmxlIGZyb20gdGhlIHNlcnZlci1yZWxhdGVkIGNvbmNlcm5zLCBhbmQgdG8gcGxhY2Ugb25seSBtaW5pbWFsCi1yZXF1aXJlbWVudHMgd2hhdCB0aGUgbW9kdWxlIHNpZGUgbmVlZHMgdG8gYmUgbGlrZS48L3A+Ci08cD5JbiBvdGhlciB3b3JkcywgdGhlIFNlcnZlciBDb3JlIEFQSSBzaG91bGQgb25seSBhdHRlbXB0IHRvIGNhcHR1cmUgYSBsaW1pdGVkCi1ub3Rpb24gb2YgbW9kdWxlLWFzLXNvbWV0aGluZy10by1wdWJsaXNoLiAoSVB1Ymxpc2hhYmxlTW9kdWxlIHdvdWxkIGJlIGEgbW9yZQotc3VnZ2VzdGl2ZSBuYW1lIHRoYW4gdGhlIGN1cnJlbnQgSU1vZHVsZS4pPC9wPgotPGgyPldoYXQgZG9lcyBhIHNlcnZlciBuZWVkIHRvIGtub3cgYWJvdXQgYSBtb2R1bGU/PC9oMj4KLTxwPkhlcmUgYXJlIHRoZSBoaWdoLWxldmVsIEFQSSBvcGVyYXRpb25zIHRoYXQgaW52b2x2ZSBib3RoIG1vZHVsZXMgYW5kIHNlcnZlcnM6PC9wPgotPHVsPgotICA8bGk+QXNzb2NpYXRpbmcgYSBtb2R1bGUgd2l0aCBhIHNlcnZlcgotICAgIDx1bD4KLSAgICAgIDxsaT5BZGQgYSBtb2R1bGUgdG8gYSBzZXJ2ZXIuPC9saT4KLSAgICAgIDxsaT5SZW1vdmUgYSBtb2R1bGUgZnJvbSBhIHNlcnZlci48L2xpPgotICAgICAgPGxpPk9idGFpbiBhIGxpc3Qgb2YgbW9kdWxlcyBhc3NvY2lhdGVkIHdpdGggYSBzZXJ2ZXIuPC9saT4KLSAgICA8L3VsPgotICA8L2xpPgotICA8bGk+UHVibGlzaGluZyBhIG1vZHVsZSB0byBhIHNlcnZlcgotICAgIDx1bD4KLSAgICAgIDxsaT5BIHNlcnZlciBwdWJsaXNoZXMgdGhlIGNvbnRlbnQgb2Ygb25lIG9mIGl0cyBtb2R1bGVzIHRvIHRoZSByZWFsCi0gICAgICAgIHNlcnZlci48L2xpPgotICAgIDwvdWw+Ci0gIDwvbGk+Ci0gIDxsaT5Nb25pdG9yaW5nIHN5bmMgb2YgbW9kdWxlIGNvbnRlbnRzCi0gICAgPHVsPgotICAgICAgPGxpPkEgc2VydmVyIGRldGVybWluZXMgd2hldGhlciB0aGUgY29udGVudCBvZiBvbmUgb2YgaXRzIG1vZHVsZXMgaXMgaW4KLSAgICAgICAgc3luYy48L2xpPgotICAgICAgPGxpPkEgc2VydmVyIHJlZ2lzdGVycyBpbnRlcmVzdCBpbiBiZWluZyBub3RpZmllZCBvZiBmdXR1cmUgY2hhbmdlcyB0byB0aGUKLSAgICAgICAgY29udGVudHMgb2Ygb25lIG9mIGl0cyBtb2R1bGVzLjwvbGk+Ci0gICAgPC91bD4KLSAgPC9saT4KLTwvdWw+Ci08cD5UaGUgZmlyc3QgZ3JvdXAgb2Ygb3BlcmF0aW9ucyBmb3IgbWFuYWdpbmcgYXNzb2NpYXRpb25zIGJldHdlZW4gbW9kdWxlcyBhbmQKLXNlcnZlcnMgY291bGQsIGluIHByaW5jaXBsZSwgYmUgZG9uZSB1c2luZyBtb2R1bGUgaWRzIGFsb25lOyB0aGUgYWN0dWFsIG1vZHVsZXMKLWNvbnRlbnQgKG9yIGV2ZW4gdGhlIG1vZHVsZSdzIGV4aXN0ZW5jZSkgbmVlZCBub3QgZW50ZXIgaW50byBpdDsgdGhlCi1pbXBsZW1lbnRhdGlvbiBvZiB0aGVzZSBvcGVyYXRpb25zIGNhbiBiZSBlbnRpcmVseSBnZW5lcmljLiBJbiBwcmFjdGljZSwgdGhlcmUKLWFyZSBhZGRpdGlvbmFsIHZhbGlkYXRpb24gY2hlY2tzIHRoYXQgd291bGQgYmUgc2VydmVyLXR5cGUtc3BlY2lmaWMuIFRoZSBhZGQKLW9wZXJhdGlvbnMgaXMgbmVjZXNzYXJpbHkgaW5pdGlhdGVkIGJ5IGEgY2xpZW50IGluIHBvc3Nlc3Npb24gb2YgYm90aCBhIG1vZHVsZQotYW5kIGEgc2VydmVyLjwvcD4KLTxwPlRoZSBzZWNvbmQgZ3JvdXAgb2Ygb3BlcmF0aW9ucyBmb3IgYWN0dWFsIHB1Ymxpc2hpbmcgYSBtb2R1bGUncyBjb250ZW50Ci1yZXF1aXJlcyBkaXNjb3ZlcmluZyBhbmQgYWNjZXNzaW5nIHRoYXQgY29udGVudC4gU2V2ZXJhbCB0aGluZ3MgdG8gb2JzZXJ2ZTo8L3A+Ci08dWw+Ci0gIDxsaT5UaGUgY29kZSB0aGF0IHB1Ymxpc2hlcyBhIG1vZHVsZSBpcyBzZXJ2ZXItdHlwZS1zcGVjaWZpYyBhbmQgY2FuIGJlCi0gICAgc3BlY2lhbGl6ZWQgZm9yIGVhY2ggcGFydGljdWxhciBtb2R1bGUgdHlwZSB0aGF0IHRoZSBzZXJ2ZXIgc3VwcG9ydHMuIEUuZy4sCi0gICAgVG9tY2F0LXNwZWNpZmljIGNvZGUgZm9yIHB1Ymxpc2hpbmcgYW4gRUpCIG1vZHVsZTsgSkJvc3Mtc3BlY2lmaWMgY29kZSBmb3IKLSAgICBwdWJsaXNoaW5nIGFuIEVKQiBtb2R1bGUuPC9saT4KLSAgPGxpPlRoZSBtb2R1bGUncyBjb250ZW50IGNhbiBiZSBwcmVzZW50ZWQgdG8gc2VydmVycyBpbiBhIG1vZHVsZS10eXBlLXNwZWNpZmljCi0gICAgd2F5LiBFLmcuLCBhIGEgc2ltcGxlIHN0YXRpYyB3ZWIgbW9kdWxlIGNhbiBsb29rIGxpa2UgYSAmcXVvdDt2aXJ0dWFsJnF1b3Q7Ci0gICAgdHJlZSBvZiBIVE1MIGZpbGVzOyBhIGRhdGFiYXNlIG1vZHVsZSBjb3VsZCBwcmVzZW50IGl0cyBjb250ZW50IGFzIHNvbWV0aGluZwotICAgIHN1aXRhYmxlIGZvciBkYXRhYmFzZXMuIChUaGUgY3VycmVudCBhcHByb2FjaCB1c2VzIGEgdHJlZSBvZiBmaWxlcyBmb3IKLSAgICBldmVyeXRoaW5nLik8L2xpPgotICA8bGk+VGhlIG1vZHVsZS10eXBlLXNwZWNpZmljIHNjaGVtZSBjb3VsZCBhbHNvIGluY2x1ZGUgaW50ZXItbW9kdWxlCi0gICAgcmVsYXRpb25zaGlwcyB3aGVyZSBhcHByb3ByaWF0ZS4gRS5nLiwgcGFyZW50LWNoaWxkIHJlbGF0aW9uc2hpcHMgZm9yIEoyRUUKLSAgICBtb2R1bGUgdHlwZXMuPC9saT4KLSAgPGxpPlRoZSBtb2R1bGUtdHlwZS1zcGVjaWZpYyBzY2hlbWUgZm9yIHByZXNlbnRpbmcgbW9kdWxlIGNvbnRlbnQgdG8gc2VydmVycwotICAgIGNhbiBidWlsZCBpbiBzdXBwb3J0IGZvciB2YXJpb3VzIGFsdGVybmF0aXZlcy4gRm9yIGV4YW1wbGUsIEVKQiBtb2R1bGUKLSAgICBjb250ZW50IGNvdWxkIGJlIHByZXNlbnRlZCB2YXJpb3VzbHkgYXMgYSBkZXBsb3ltZW50IGRlc2NyaXB0b3IgcGx1cwotICAgICZxdW90O3ZpcnR1YWwmcXVvdDsgZmlsZXMgd2l0aCBzdGFuZGFyZCBuYW1lczsgb3IgYXMgYSAmcXVvdDt2aXJ0dWFsJnF1b3Q7Ci0gICAgRUFSIGZpbGU7IG9yIGFzIGEgamF2YS5pby5GaWxlIHBhdGggdG8gYW4gRUFSIGZpbGU7IG9yIGFzIGEgamF2YS5pby5GaWxlCi0gICAgZGlyZWN0b3J5IGNvbnRhaW5pbmcgYW4gdW56aXBwZWQgRUFSLjwvbGk+Ci0gIDxsaT5UaGUgbW9kdWxlcyBjb250ZW50cyBhcmUgcmV2ZWFsZWQgdG8gdGhlIHNlcnZlciBvbmx5IGZvciBhIGxpbWl0ZWQtdGltZQotICAgIGludGVyYWN0aW9uLiBUaGlzIG1lYW5zIHRoYXQgdGhlIG9iamVjdHMgYXJlIHNob3J0LWxpdmVkLiBUaGVyZSBpcyBubwotICAgIHJlcXVpcmVtZW50IGZvciBldmVudHMgdG8gcmVwb3J0IGNoYW5nZXMgdG8gY29udGVudCA8aT5kdXJpbmc8L2k+IGEgcHVibGlzaAotICAgIG9wZXJhdGlvbi48L2xpPgotICA8bGk+Rm9yIG1vZHVsZXMgdGhhdCByZWFsbHkgYXJlIGJhc2VkIG9uIGZpbGVzIGluIHRoZSB3b3Jrc3BhY2UsIHRoZSBtb2R1bGUKLSAgICBjb250ZW50cyB0aGF0IGdldCBwcmVzZW50ZWQgZm9yIHB1YmxpY2F0aW9uIG5lZWQgbm90IGJldHJheSB0aGF0IGZhY3QuPC9saT4KLTwvdWw+Ci08cD5UaGUgdGhpcmQgZ3JvdXAgb2Ygb3BlcmF0aW9ucywgZm9yIG1vbml0b3Jpbmcgc3luYyBvZiBtb2R1bGUgY29udGVudHMsIGFyZQotdmVyeSBtdWNoIGxpa2UgdGhlIHNlY29uZC48L3A+Ci08dWw+Ci0gIDxsaT5UaGUgbW9kdWxlLXR5cGUtc3BlY2lmaWMgc2NoZW1lIGZvciBwcmVzZW50aW5nIG1vZHVsZSBjb250ZW50IHRvIHNlcnZlcnMKLSAgICBjb3VsZCBpbmNsdWRlIGEgdGltZXN0YW1wLiBJZiB0aGUgc2VydmVyIG1haW50YWlucyBhbiBpbnRlcm5hbCByZWNvcmQgb2YKLSAgICB3aGF0IGlzIG9uIHRoZSByZWFsIHNlcnZlciBhbG9uZyB3aXRoIHRoZSB0aW1lc3RhbXAsIHRoZSBzZXJ2ZXIgY2FuCi0gICAgZGV0ZXJtaW5lIHdoZXRoZXIgdGhlIG1vZHVsZSBjb250ZW50cyBuZWVkIHRvIGJlIHJlcHVibGlzaGVkLjwvbGk+Ci0gIDxsaT5Gb3IgbW9kdWxlLXR5cGUtc3BlY2lmaWMgc2NoZW1lcyBpbnZvbHZpbmcgZmlsZXMsIGVhY2ggZmlsZSBjb3VsZCBjYXJyeQotICAgIHRpbWVzdGFtcCBpbmZvcm1hdGlvbi4gRm9yIHNvbWUgc2VydmVyIHR5cGVzLCB0aGlzIHdvdWxkIGFsbG93IGp1c3QgdGhlCi0gICAgc3Vic2V0IG9mIGNoYW5nZWQgZmlsZXMgdG8gYmUgcmVjb3BpZWQgdG8gdGhlIHNlcnZlciBpbiBzb21lIGNhc2VzLjwvbGk+Ci0gIDxsaT5XaGVuIHRoZSBmaWxlcyBvZiBhIG1vZHVsZSBhcmUgc3RvcmVkIGluIHRoZSB3b3Jrc3BhY2UgKG9yIHNvbWV3aGVyZSBlbHNlCi0gICAgdGhhdCBjYW4gYmUgdGlnaHRseSBtb25pdG9yZWQpLCBpdCBpcyBhbHNvIHByYWN0aWNhbCB0byByZXBvcnQgY2hhbmdlIGV2ZW50cwotICAgIGFmZmVjdGluZyBhIG1vZHVsZSB0byBpbnRlcmVzdGVkIHNlcnZlcnMsIGluc3RlYWQgb2YgaGF2aW5nIHRoZSBzZXJ2ZXJzIHBvbGwKLSAgICBmb3Igc3VjaCBjaGFuZ2VzLjwvbGk+Ci08L3VsPgotPHA+SGVyZSdzIGFuIEFQSSBza2V0Y2ggKGl0IGRpZmZlcnMgaW4gYSBudW1iZXIgb2Ygd2F5IGZyb20gd2hhdCBpcyBjdXJyZW50bHkKLXJlbGVhc2VkKTo8L3A+Ci08dWw+Ci0gIDxsaT5FeHRlbnNpb24gcG9pbnQgZm9yIGRlZmluaW5nIGEgbmV3IG1vZHVsZSB0eXBlLgotICAgIDx1bD4KLSAgICAgIDxsaT5EZWZpbmUgbW9kdWxlIHR5cGUgaWQsIG1vZHVsZSB0eXBlIG5hbWUuPC9saT4KLSAgICAgIDxsaT5Qcm92aWRlIGludGVyZmFjZSBmb3IgYWNjZXNzaW5nIHB1Ymxpc2hhYmxlIGNvbnRlbnQuPC9saT4KLSAgICA8L3VsPgotICA8L2xpPgotICA8bGk+RXh0ZW5zaW9uIHBvaW50IGZvciBkZWZpbmluZyBhIG5ldyBzZXJ2ZXIgdHlwZS4KLSAgICA8dWw+Ci0gICAgICA8bGk+RGVmaW5lIHNlcnZlciB0eXBlIGlkLCBzZXJ2ZXIgdHlwZSBuYW1lLjwvbGk+Ci0gICAgICA8bGk+R2l2ZSBsaXN0IG9mIHN1cHBvcnRlZCBtb2R1bGUgdHlwZXMuPC9saT4KLSAgICAgIDxsaT5Qcm92aWRlIG1lY2hhbmlzbSBmb3IgcHVibGlzaGluZyBzdXBwb3J0ZWQgbW9kdWxlIHR5cGVzIHRvIHJlYWwKLSAgICAgICAgc2VydmVyLiAoU2VydmVyLXR5cGUtc3BlY2lmaWMgYW5kIG1vZHVsZS10eXBlLXNwZWNpZmljLCBidXQgaWdub3JhbnQgb2YKLSAgICAgICAgaG93IGFuZCB3aGVyZSBtb2R1bGUncyBjb250ZW50IGlzIGFjdHVhbGx5IHN0b3JlZC4pJm5ic3A7PC9saT4KLSAgICAgIDxsaT5Qcm92aWRlIG1lY2hhbmlzbSBmb3IgbGF1bmNoaW5nIGFuZCB0YWxraW5nIHRvIHJlYWwgc2VydmVyLjwvbGk+Ci0gICAgPC91bD4KLSAgPC9saT4KLSAgPGxpPkV4dGVuc2lvbiBwb2ludCBmb3IgZGVmaW5pbmcgYSBuZXcgbW9kdWxlIGZhY3RvcnkuCi0gICAgPHVsPgotICAgICAgPGxpPlN1cHBseSBtb2R1bGUgZmFjdG9yeSBpZCwgbW9kdWxlIGZhY3RvcnkgbmFtZS48L2xpPgotICAgICAgPGxpPkdpdmUgbGlzdCBvZiBtb2R1bGUgdHlwZXMgdGhhdCB0aGlzIGZhY3RvcnkgaXMgY2FwYWJsZSBvZiBjcmVhdGluZy48L2xpPgotICAgICAgPGxpPlByb3ZpZGUgbWVjaGFuaXNtIGZvciBjcmVhdGluZy9kaXNjb3ZlcmluZyBtb2R1bGUgaW5zdGFuY2VzLCBhbmQgZm9yCi0gICAgICAgIHRyYWNraW5nIGl0cyBtb2R1bGUgaW5zdGFuY2VzLjwvbGk+Ci0gICAgICA8bGk+UHJvdmlkZSBtZWNoYW5pc20gZm9yIHByb3ZpZGluZyBwdWJsaXNoYWJsZSBtb2R1bGUgY29udGVudCBmb3IgaXRzCi0gICAgICAgIG1vZHVsZSBpbnN0YW5jZXMuIChTZXJ2ZXItdHlwZS1pbmRlcGVuZGVudCwgbW9kdWxlLXR5cGUtc3BlY2lmaWMsIGFuZAotICAgICAgICBjb2duaXphbnQgb2YgaG93IGFuZCB3aGVyZSBhIG1vZHVsZSdzIHB1Ymxpc2hhYmxlIGNvbnRlbnQgaXMgYWN0dWFsbHkKLSAgICAgICAgc3RvcmVkLik8L2xpPgotICAgICAgPGxpPlByb3ZpZGUgbWVjaGFuaXNtLCB3aGVyZSBmZWFzaWJsZSwgZm9yIG5vdGlmeWluZyBhIHNlcnZlciBvZiBjaGFuZ2VzCi0gICAgICAgIGFmZmVjdGluZyBwdWJsaXNoYWJsZSBtb2R1bGUgY29udGVudCBmb3IgaXRzIG1vZHVsZSBpbnN0YW5jZXMuPC9saT4KLSAgICA8L3VsPgotICA8L2xpPgotICA8bGk+TW9kdWxlIGhhbmRsZSByZXByZXNlbnQgYSB1bmlxdWUgbW9kdWxlIGluc3RhbmNlLgotICAgIDx1bD4KLSAgICAgIDxsaT5Nb2R1bGUgaGFzIGEgdW5pcXVlIG1vZHVsZSBpZC48L2xpPgotICAgICAgPGxpPk1vZHVsZSBoYXMgYSBtb2R1bGUgdHlwZSAocmVwcmVzZW50ZWQgYnkgYSBtb2R1bGUgdHlwZSBpZCAtIG1vZHVsZQotICAgICAgICB0eXBlcyBtaWdodCBub3QgZXhpc3QpPC9saT4KLSAgICAgIDxsaT5Nb2R1bGUgaGFzIGEgbW9kdWxlIGZhY3RvcnkgKHJlcHJlc2VudGVkIGJ5IGEgbW9kdWxlIGZhY3RvcnkgaWQmbmJzcDsKLSAgICAgICAgLSBtb2R1bGUgZmFjdG9yeSBtaWdodCBub3QgZXhpc3QpLiBUaGlzIGlzIHRoZSBtb2R1bGUgZmFjdG9yeQotICAgICAgICByZXNwb25zaWJsZSBmb3IgbW9kdWxlIGluc3RhbmNlLjwvbGk+Ci0gICAgICA8bGk+TW9kdWxlIGlzIGp1c3QgYSBoYW5kbGUgKHBhc3NpdmUga2V5KS4gTW9kdWxlIG1pZ2h0IG5vdCBleGlzdC48L2xpPgotICAgICAgPGxpPlVzZWQgaW4gc2VydmVyIEFQSSBmb3IgYWRkaW5nL3JlbW92aW5nIGEgbW9kdWxlIHRvL2Zyb20gYSBzZXJ2ZXI7IGZvcgotICAgICAgICBvYnRhaW5pbmcgYSBsaXN0IG9mIG1vZHVsZXMgYXNzb2NpYXRlZCB3aXRoIGEgc2VydmVyOyBmb3Igb2J0YWluaW5nIGEKLSAgICAgICAgbGlzdCBvZiBtb2R1bGVzIGFzc29jaWF0ZWQgd2l0aCBhIG1vZHVsZSBmYWN0b3J5LjwvbGk+Ci0gICAgICA8bGk+SW50ZXJmYWNlIGlzIGNsaWVudCBBUEk7IGNsaWVudHMgZG8gbm90IGltcGxlbWVudC48L2xpPgotICAgICAgPGxpPkltcGxlbWVudGF0aW9uIGlzIGludGVybmFsLjwvbGk+Ci0gICAgICA8bGk+Ci0gICAgICAgIDxwcmU+cHVibGljIGludGVyZmFjZSBJTW9kdWxlSGFuZGxlIHsKLSAgcHVibGljIFN0cmluZyBnZXRJZCgpOwotICBwdWJsaWMgU3RyaW5nIGdldE1vZHVsZVR5cGVJZCgpOwotICBwdWJsaWMgU3RyaW5nIGdldE1vZHVsZUZhY3RvcnlJZCgpOwotICB9Ci1bc29tZXdoZXJlIG9uIFNQSSB3aGVyZSBpdCBpcyBhdmFpbGFibGUgdG8gc2VydmVycyBhbmQgbW9kdWxlIGZhY3Rvcmllc10KLSAgcHVibGljIElNb2R1bGVIYW5kbGUgY3JlYXRlTW9kdWxlSGFuZGxlKFN0cmluZyBtb2R1bGVJZCwgU3RyaW5nIG1vZHVsZVR5cGVJZCwgU3RyaW5nIG1vZHVsZUZhY3RvcnlJZCk7PC9wcmU+Ci0gICAgICA8L2xpPgotICAgIDwvdWw+Ci0gIDwvbGk+Ci0gIDxsaT5QdWJsaXNoYWJsZSBtb2R1bGUgdXNlZCBieSBzZXJ2ZXIgZm9yIGxpbWl0ZWQtcHVycG9zZSBvZiBwdWJsaXNoaW5nIGEKLSAgICBtb2R1bGUncyBjb250ZW50cy4KLSAgICA8dWw+Ci0gICAgICA8bGk+JnF1b3Q7TWFya2VyJnF1b3Q7IGludGVyZmFjZSAtIG5vIG1ldGhvZHMuPC9saT4KLSAgICAgIDxsaT5FYWNoIG1vZHVsZSB0eXBlIGRlZmluZXMgaXRzIG93biBzcGVjaWFsaXplZCBwdWJsaWMgc3ViaW50ZXJmYWNlIGZvcgotICAgICAgICBvYnRhaW5pbmcgdGhlIG1vZHVsZSdzIGNvbnRlbnQuPC9saT4KLSAgICAgIDxsaT5TdWJpbnRlcmZhY2UgaXMgQVBJIGZvciBwYXJ0aWVzIHN1cHBseWluZyBtb2R1bGUgZmFjdG9yaWVzIGFuZCBzZXJ2ZXIKLSAgICAgICAgZGVsZWdhdGVzIChib3RoIFNQSSBzaWRlKTwvbGk+Ci0gICAgICA8bGk+U3ViaW50ZXJmYWNlIGNhbiBzcGVjIHdoYXRldmVyIGNvbnRyYWN0IHdvcmtzIGZvciBtYWtpbmcgdGhlIG1vZHVsZSdzCi0gICAgICAgIHB1Ymxpc2hhYmxlIGNvbnRlbnQgYXZhaWxhYmxlIHRvIGFueSB0eXBlIG9mIHNlcnZlciB0aGF0IHdpc2hlcyB0bwotICAgICAgICBzdXBwb3J0IHRoYXQgbW9kdWxlIHR5cGUuPC9saT4KLSAgICAgIDxsaT5Nb2R1bGUtdHlwZS1zcGVjaWZpYyBzdWJpbnRlcmZhY2UgaXMgdXNlZCBieSBzZXJ2ZXIgZGVsZWdhdGUgZm9yCi0gICAgICAgIHB1Ymxpc2hpbmcgcHVycG9zZXMuPC9saT4KLSAgICAgIDxsaT5Nb2R1bGUtdHlwZS1zcGVjaWZpYyBzdWJpbnRlcmZhY2UgaXMgaW1wbGVtZW50ZWQgZGlmZmVyZW50bHkgYnkgZWFjaAotICAgICAgICBtb2R1bGUgZmFjdG9yeSB0aGF0IGNhbiBjcmVhdGUgaW5zdGFuY2VzIG9mIHRoZSBtb2R1bGUgdHlwZS48L2xpPgotICAgICAgPGxpPlRoZXNlIG9iamVjdCBvbmx5IG5lZWRzIHRvIGJlIHVzZWZ1bCBmb3IgdGhlIGxpbWl0ZWQgZHVyYXRpb24gb2YKLSAgICAgICAgcHVibGlzaGluZyAob3IgcmVzeW5jaW5nKS48L2xpPgotICAgICAgPGxpPlRoZSBtZXRob2Qgc2hvdWxkIG5vdCBiZSBhdmFpbGFibGUgdG8gb3RoZXIgcGFydGllcy48L2xpPgotICAgIDwvdWw+Ci0gIDwvbGk+Ci0gIDx1bD4KLSAgICA8bGk+Ci0gICAgICA8cHJlPltzb21ld2hlcmUgYXZhaWxhYmxlIHRvIHNlcnZlciBkZWxlZ2F0ZSAob25seSldCi0gIHB1YmxpYyBJUHVibGlzaGFibGVNb2R1bGUgcmVzb2x2ZUZvclB1Ymxpc2goSU1vZHVsZUhhbmRsZSBtb2R1bGVIYW5kbGUpOwotcHVibGljIGludGVyZmFjZSBJUHVibGlzaGFibGVNb2R1bGUge308L3ByZT4KLSAgICA8L2xpPgotICA8L3VsPgotICA8bGk+TW9kdWxlIGZhY3RvcmllcyBhcmUgdGhpbmdzIHRoYXQgY3JlYXRlIGFuZCBtb2R1bGVzLgotICAgIDx1bD4KLSAgICAgIDxsaT5DbGllbnQgQVBJIHByb3ZpZGVzIGdsb2JhbCBsaXN0IG9mIG1vZHVsZSBmYWN0b3JpZXMuPC9saT4KLSAgICAgIDxsaT5FYWNoIG1vZHVsZSBmYWN0b3J5IGNhbiBzdXBwb3J0IGFueSBudW1iZXIgb2YgZGlmZmVyZW50IG1vZHVsZSB0eXBlcy48L2xpPgotICAgICAgPGxpPkVhY2ggbW9kdWxlIGZhY3RvcnkgaXMgcmVzcG9uc2libGUgZm9yIGNyZWF0aW5nIGFuZCBtYW5hZ2luZyBhIGdsb2JhbCwKLSAgICAgICAgcGVyc2lzdGVudCwgbGlzdCBvZiBpdHMgbW9kdWxlIGluc3RhbmNlcy4gKEl0IHdvdWxkIGJlIGV2ZW4gYmV0dGVyIGlmIGEKLSAgICAgICAgZmFjdG9yeSBjb3VsZCBrZWVwIC4pPC9saT4KLSAgICAgIDxsaT5Nb2R1bGUgZmFjdG9yeSBjbGllbnQgQVBJLjwvbGk+Ci0gICAgPC91bD4KLSAgICA8dWw+Ci0gICAgICA8bGk+Ci0gICAgICAgIDxwcmU+U2VydmVyQ29yZQotICBwdWJsaWMgSU1vZHVsZUZhY3RvcnlbXSBnZXRNb2R1bGVGYWN0b3JpZXMoKTsKLXB1YmxpYyBpbnRlcmZhY2UgSU1vZHVsZUZhY3RvcnkgewotICBwdWJsaWMgU3RyaW5nIGdldElkKCk7Ci0gIHB1YmxpYyBzdXBwb3J0c01vZHVsZVR5cGUoSU1vZHVsZVR5cGUgbW9kdWxlVHlwZSk7Ci0gIHB1YmxpYyBJTW9kdWxlSGFuZGxlW10gZ2V0TW9kdWxlcygpOwotICBwdWJsaWMgSU1vZHVsZUhhbmRsZSBjcmVhdGVNb2R1bGUoU3RyaW5nIG1vZHVsZUlkLCBTdHJpbmcgbW9kdWxlVHlwZUlkLCBPYmplY3QgZGF0YSk7Ci0gIHB1YmxpYyB2b2lkIGRlbGV0ZU1vZHVsZShJTW9kdWxlSGFuZGxlKTsKLSAgcHVibGljIHZvaWQgYWRkTW9kdWxlRmFjdG9yeUxpc3RlbmVyKElNb2R1bGVGYWN0b3J5TGlzdGVuZXIpOwotICBwdWJsaWMgdm9pZCByZW1vdmVNb2R1bGVGYWN0b3J5TGlzdGVuZXIoSU1vZHVsZUZhY3RvcnlMaXN0ZW5lcik7Ci19PC9wcmU+Ci0gICAgICA8L2xpPgotICAgIDwvdWw+Ci0gICAgPHVsPgotICAgICAgPGxpPk1vZHVsZSBmYWN0b3J5IFNQSS48L2xpPgotICAgIDwvdWw+Ci0gIDwvbGk+Ci0gIDx1bD4KLSAgICA8bGk+Ci0gICAgICA8cHJlPnB1YmxpYyBhYnN0cmFjdCBjbGFzcyBBYnN0cmFjdE1vZHVsZUZhY3RvcnlEZWxlZ2F0ZSB7Ci0gIHB1YmxpYyBBYnN0cmFjdE1vZHVsZUZhY3RvcnlEZWxlZ2F0ZShJTW9kdWxlRmFjdG9yeSBmYWN0b3J5KSB7Li4ufQotICBwdWJsaWMgZmluYWwgSU1vZHVsZUZhY3RvcnkgZ2V0RmFjdG9yeSgpIHsuLi59Ci0gIHB1YmxpYyBhYnN0cmFjdCBJTW9kdWxlSGFuZGxlW10gZ2V0TW9kdWxlcygpOwotICBwdWJsaWMgYWJzdHJhY3QgSU1vZHVsZUhhbmRsZSBjcmVhdGVNb2R1bGUoU3RyaW5nIG1vZHVsZUlkLCBTdHJpbmcgbW9kdWxlVHlwZUlkLCBPYmplY3QgZGF0YSk7Ci0gIHB1YmxpYyBhYnN0cmFjdCBkZWxldGVNb2R1bGUoSU1vZHVsZUhhbmRsZSk7Ci0gIHB1YmxpYyBhYnN0cmFjdCBJUHVibGlzaGFibGVNb2R1bGUgcmVzb2x2ZUZvclB1Ymxpc2goSU1vZHVsZUhhbmRsZSBtb2R1bGVIYW5kbGUpOwotfTwvcHJlPgotICAgIDwvbGk+Ci0gIDwvdWw+Ci0gIDxsaT5FeGFtcGxlCi0gICAgPHVsPgotICAgICAgPGxpPkRlY2xhcmF0aW9uIG9mIG1vZHVsZSB0eXBlOiBzaW1wbGUgc3RhdGljIHdlYjwvbGk+Ci0gICAgICA8bGk+SW5jbHVkZSBtb2R1bGUtdHlwZS1zcGVjaWZpYyBzdWJpbnRlcmZhY2UgZm9yIHB1Ymxpc2hpbmcgbW9kdWxlCi0gICAgICAgIGV4cHJlc3NlZCBhcyBhIHRyZWUgb2YgZmlsZXMgd2l0aCB0aW1lc3RhbXBzLjwvbGk+Ci0gICAgICA8bGk+Ci0gICAgICAgIDxwcmU+cHVibGljIGludGVyZmFjZSBJV2ViTW9kdWxlIGV4dGVuZHMgSVB1Ymxpc2hhYmxlTW9kdWxlIHsKLSAgcHVibGljIGludGVyZmFjZSBJTW9kdWxlUmVzb3VyY2UgewotICAgIHB1YmxpYyBTdHJpbmcgZ2V0TmFtZSgpOwotICAgIHB1YmxpYyBJUGF0aCBnZXRNb2R1bGVSZWxhdGl2ZVBhdGgoKTsKLSAgfQotICBwdWJsaWMgaW50ZXJmYWNlIElNb2R1bGVGaWxlIGV4dGVuZHMgSU1vZHVsZVJlc291cmNlIHsKLSAgICBwdWJsaWMgbG9uZyBnZXRUaW1lU3RhbXAoKTsKLSAgICBwdWJsaWMgSW5wdXRTdHJlYW0gZ2V0Q29udGVudHMoKTsKLSAgfQotICBwdWJsaWMgaW50ZXJmYWNlIElNb2R1bGVGb2xkZXIgZXh0ZW5kcyBJTW9kdWxlUmVzb3VyY2UgewotICAgIHB1YmxpYyBJTW9kdWxlUmVzb3VyY2VbXSBtZW1iZXJzKCk7Ci0gIH0KLSAgcHVibGljIElNb2R1bGVSZXNvdXJjZVtdIG1lbWJlcnMoKTsKLX08L3ByZT4KLSAgICAgIDwvbGk+Ci0gICAgICA8bGk+SVdlYk1vZHVsZSBpcyB1c2VkIGluIHNlcnZlcnMgdGhhdCBzdXBwb3J0IHNpbXBsZSBzdGF0aWMgd2ViIG1vZHVsZXMKLSAgICAgICAgPHVsPgotICAgICAgICAgIDxsaT5FeGFtcGxlIHNlcnZlciB0eXBlOiBzaW1wbGUgd2ViIHNlcnZlcjwvbGk+Ci0gICAgICAgICAgPGxpPlNlcnZlciBkZWxlZ2F0ZSB1c2VzIHJlc29sdmVGb3JQdWJsaXNoKG1vZHVsZUhhbmRsZSkgdG8gZ2V0IGFuCi0gICAgICAgICAgICBJUHVibGlzaGFibGVNb2R1bGU8L2xpPgotICAgICAgICAgIDxsaT5Eb3duY2FzdHMgSVB1Ymxpc2hhYmxlTW9kdWxlIHRvIElXZWJNb2R1bGU8L2xpPgotICAgICAgICAgIDxsaT5DYWxscyBtZXRob2RzIG9uIElXZWJNb2R1bGUgdG8gZGlzY292ZXIgZmlsZXMgY29tcHJpc2luZyBjb250ZW50LjwvbGk+Ci0gICAgICAgIDwvdWw+Ci0gICAgICA8L2xpPgotICAgICAgPGxpPklXZWJNb2R1bGUgaXMgaW1wbGVtZW50ZWQgYnkgbW9kdWxlIGZhY3RvcmllcyB0aGF0IHN1cHBvcnQgc2ltcGxlCi0gICAgICAgIHN0YXRpYyB3ZWIgbW9kdWxlcwotICAgICAgICA8dWw+Ci0gICAgICAgICAgPGxpPkV4YW1wbGUgbW9kdWxlIGZhY3RvcnkgMTogc3RhdGljIHdlYiBtb2R1bGVzIGtlcHQgaW4gd29ya3NwYWNlCi0gICAgICAgICAgICBmb2xkZXJzCi0gICAgICAgICAgICA8dWw+Ci0gICAgICAgICAgICAgIDxsaT5QdWJsaXNoYWJsZSBjb250ZW50IGxpdmVzIGluIHdvcmtzcGFjZTwvbGk+Ci0gICAgICAgICAgICAgIDxsaT5FYWNoIG1vZHVsZSBoYXMgYSByb290IGZvbGRlci48L2xpPgotICAgICAgICAgICAgICA8bGk+RmlsZXMgYW5kIGZvbGRlcnMgdW5kZXIgcm9vdCBmb2xkZXIgYXJlIGlzb21vcnBoaWMgdG8KLSAgICAgICAgICAgICAgICBJV2ViTW9kdWxlIGxheW91dC4KLSAgICAgICAgICAgICAgICA8dWw+Ci0gICAgICAgICAgICAgICAgICA8bGk+QWxsIGZpbGVzIGFuZCBmb2xkZXJzIHVuZGVyIHJvb3QgZm9sZGVyIGFyZSBwdWJsaXNoYWJsZS48L2xpPgotICAgICAgICAgICAgICAgICAgPGxpPkZpbGUgYW5kIGZvbGRlciBuYW1lcyBhcmUgYXMgcHVibGlzaGVkLjwvbGk+Ci0gICAgICAgICAgICAgICAgICA8bGk+RmlsZSBjb250ZW50cyBhbmQgdGltZXN0YW1wcyBhcmUgYXMgcHVibGlzaGVkLjwvbGk+Ci0gICAgICAgICAgICAgICAgPC91bD4KLSAgICAgICAgICAgICAgPC9saT4KLSAgICAgICAgICAgICAgPGxpPiZxdW90O2RhdGEmcXVvdDsgb2JqZWN0IHBhc3NlZCB0byBJTW9kdWxlRmFjdG9yeS5jcmVhdGVNb2R1bGUKLSAgICAgICAgICAgICAgICBpcyBJQ29udGFpbmVyIGZvciBtb2R1bGUncyByb290IGZvbGRlci48L2xpPgotICAgICAgICAgICAgICA8bGk+RmFjdG9yeSBtYWludGFpbnMgZ2xvYmFsIGxpc3Qgb2YgbW9kdWxlcyBpbiBwcml2YXRlIHBsdWctaW4KLSAgICAgICAgICAgICAgICBzdGF0ZS48L2xpPgotICAgICAgICAgICAgPC91bD4KLSAgICAgICAgICA8L2xpPgotICAgICAgICAgIDxsaT5FeGFtcGxlIG1vZHVsZSBmYWN0b3J5IDI6IHN0YXRpYyB3ZWIgbW9kdWxlcyBrZXB0IGluIHppcCBmaWxlCi0gICAgICAgICAgICA8dWw+Ci0gICAgICAgICAgICAgIDxsaT5QdWJsaXNoYWJsZSBjb250ZW50IGxpdmVzIGluIHppcCBmaWxlcyBvdXRzaWRlIHdvcmtzcGFjZTwvbGk+Ci0gICAgICAgICAgICAgIDxsaT5FYWNoIG1vZHVsZSBoYXMgYSBzaW5nbGUgemlwIGZpbGUuPC9saT4KLSAgICAgICAgICAgICAgPGxpPiZxdW90O2RhdGEmcXVvdDsgb2JqZWN0IHBhc3NlZCB0byBJTW9kdWxlRmFjdG9yeS5jcmVhdGVNb2R1bGUKLSAgICAgICAgICAgICAgICBpcyBqYXZhLmlvLkZpbGUgKG9yIElQYXRoKSBmb3IgbW9kdWxlJ3MgemlwIGZpbGUuPC9saT4KLSAgICAgICAgICAgICAgPGxpPkZpbGVzIGFuZCBmb2xkZXJzIHdpdGhpbiB6aXAgZmlsZSBhcmUgaXNvbW9ycGhpYyB0byBJV2ViTW9kdWxlCi0gICAgICAgICAgICAgICAgbGF5b3V0LjwvbGk+Ci0gICAgICAgICAgICAgIDxsaT5GYWN0b3J5IG1haW50YWlucyBnbG9iYWwgbGlzdCBvZiBpdHMgbW9kdWxlcyBpbiBwcml2YXRlCi0gICAgICAgICAgICAgICAgcGx1Zy1pbiBzdGF0ZS48L2xpPgotICAgICAgICAgICAgPC91bD4KLSAgICAgICAgICA8L2xpPgotICAgICAgICA8L3VsPgotICAgICAgPC9saT4KLSAgICA8L3VsPgotICA8L2xpPgotPC91bD4KLTxwPiZuYnNwOzwvcD4KLQotPC9ib2R5PgotCi08L2h0bWw+CmRpZmYgLS1naXQgYS9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL3Byb2plY3RsYXlvdXQtbm1kLnBwdCBiL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvcHJvamVjdGxheW91dC1ubWQucHB0CmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0N2EyOGYyLi4wMDAwMDAwCi0tLSBhL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvcHJvamVjdGxheW91dC1ubWQucHB0CisrKyAvZGV2L251bGwKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy9zZXJ2ZXIvU2VydmVyIFRvb2xzIEFQSSBDaGFuZ2VzLmh0bWwgYi9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL3NlcnZlci9TZXJ2ZXIgVG9vbHMgQVBJIENoYW5nZXMuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggNmY0NGQ4ZS4uMDAwMDAwMAotLS0gYS9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL3NlcnZlci9TZXJ2ZXIgVG9vbHMgQVBJIENoYW5nZXMuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDM1MiArMCwwIEBACi08aHRtbD4KLQotPGhlYWQ+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LUxhbmd1YWdlIiBjb250ZW50PSJlbi11cyI+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD13aW5kb3dzLTEyNTIiPgotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2RlZmF1bHRfc3R5bGUuY3NzIiB0eXBlPSJ0ZXh0L2NzcyI+Ci08dGl0bGU+U2VydmVyIFRvb2xzIEFQSSBDaGFuZ2VzPC90aXRsZT4KLTxzdHlsZT4KLXRkIHsgZm9udC1mYW1pbHk6IGFyaWFsLCBoZWx2ZXRpY2EsIGdlbmV2YTsgZm9udC1zaXplOiA5cHQ7IHZlcnRpY2FsLWFsaWduOiB0b3A7IH0KLXRkLmNvZGUgeyBmb250LWZhbWlseTogIkNvdXJpZXIgTmV3IiwgQ291cmllciwgbW9ubzsgZm9udC1zaXplOiA3Ljc1cHR9Ci08L3N0eWxlPgotPC9oZWFkPgotCi08Ym9keSBhbGluaz0iI2ZmMDAwMCIgYmdjb2xvcj0iI2ZmZmZmZiIgbGluaz0iIzAwMDBlZSIgdGV4dD0iIzAwMDAwMCIgdmxpbms9IiM1NTFhOGIiPgotCi08dGFibGUgYm9yZGVyPSIwIiBjZWxscGFkZGluZz0iMiIgY2VsbHNwYWNpbmc9IjUiIHdpZHRoPSIxMDAlIj4KLSAgPHRib2R5Pjx0cj4KLSAJCTxURCBXSURUSD02MCU+Ci0JCQk8UCBBTElHTj1MRUZUPjxCPjxGT05UIFNJWkU9Nj48Rk9OVCBGQUNFPSJWZXJkYW5hLCBBcmlhbCwgSGVsdmV0aWNhLCBzYW5zLXNlcmlmIj5TZXJ2ZXIgVG9vbHMgQVBJIENoYW5nZXM8L0ZPTlQ+PC9GT05UPjwvQj48QlI+Ci0JCQk8Rk9OVCBTSVpFPTE+PEZPTlQgRkFDRT0iQXJpYWwsIEhlbHZldGljYSwgc2Fucy1zZXJpZiI+PEZPTlQgQ09MT1I9IiM4MDgwZmYiPkluZm9ybWF0aW9uIG9uIFNlcnZlciBUb29scyBBUEkgQ2hhbmdlczwvRk9OVD48L0ZPTlQ+PC9GT05UPgotCQkJPC9QPgotCQk8L1REPgotICAgIDx0ZCByb3dzcGFuPSIyIiB3aWR0aD0iMTklIj48aW1nIHNyYz0iaHR0cDovL3d3dy5lY2xpcHNlLm9yZy9pbWFnZXMvSWRlYS5qcGciIGJvcmRlcj0iMCIgaGVpZ2h0PSI4NiIgd2lkdGg9IjEyMCI+PC90ZD4KLSAgPC90cj4KLTwvdGJvZHk+PC90YWJsZT4KLQotCi08dGFibGUgYm9yZGVyPSIwIiBjZWxscGFkZGluZz0iMiIgY2VsbHNwYWNpbmc9IjUiIHdpZHRoPSIxMDAlIj4KLSAgPHRib2R5Pjx0cj4gCi0gICAgPHRkIGNvbHNwYW49IjIiIGFsaWduPSJsZWZ0IiBiZ2NvbG9yPSIjMDA4MGMwIiB2YWxpZ249InRvcCI+PGI+PGZvbnQgY29sb3I9IiNmZmZmZmYiIGZhY2U9IkFyaWFsLEhlbHZldGljYSI+TTEgQ2hhbmdlczwvZm9udD48L2I+PC90ZD4KLSAgPC90cj48L3Rib2R5PgotPC90YWJsZT4KLQotSGVyZSBhcmUgdGhlIFNlcnZlciBUb29scyBBUEkgY2hhbmdlcyB0aGF0IHdlbnQgaW50byBNMS4KLQotPHAvPgotCi08dGFibGUgYm9yZGVyPTEgY2VsbHNwYWNpbmc9IjAiPgotPHRyPgotICA8dGg+Q2hhbmdlPC90aD4KLSAgPHRoPlJlYXNvbjwvdGg+Ci0gIDx0aD5PbGQgQ29kZTwvdGg+Ci0gIDx0aD5OZXcgQ29kZTwvdGg+Ci08L3RyPgotPHRyPgotICA8dGQ+UGFja2FnZSByZW5hbWVzOjxici8+Ci0gIGNvbS5pYm0ud3RwLnNlcnZlci5jb3JlIC0+IG9yZy5lY2xpcHNlLndzdC5zZXJ2ZXIuY29yZTxici8+Ci0gIGNvbS5pYm0ud3RwLnNlcnZlci51aSAtPiBvcmcuZWNsaXBzZS53c3Quc2VydmVyLnVpPGJyLz4KLSAgY29tLmlibS53dHAuc2VydmVyLnV0aWwgLT4gb3JnLmVjbGlwc2Uud3N0LnNlcnZlci51dGlsPGJyLz4KLSAgY29tLmlibS53dHAuc2VydmVyLmphdmEuY29yZSAtPiBvcmcuZWNsaXBzZS5qc3Quc2VydmVyLmNvcmU8YnIvPgotICBjb20uaWJtLnd0cC5zZXJ2ZXIuamF2YS51aSAtPiBvcmcuZWNsaXBzZS5qc3Quc2VydmVyLnVpPGJyLz4KLSAgY29tLmlibS53dHAuc2VydmVyLnRvbWNhdC5jb3JlIC0+IG9yZy5lY2xpcHNlLmpzdC5zZXJ2ZXIudG9tY2F0LmNvcmU8YnIvPgotICBjb20uaWJtLnd0cC5zZXJ2ZXIudG9tY2F0LnVpIC0+IG9yZy5lY2xpcHNlLmpzdC5zZXJ2ZXIudG9tY2F0LnVpPGJyLz4KLSAgY29tLmlibS53dHAubW9uaXRvci5jb3JlIC0+IG9yZy5lY2xpcHNlLndzdC5tb25pdG9yLmNvcmU8YnIvPgotICBjb20uaWJtLnd0cC5tb25pdG9yLnVpIC0+IG9yZy5lY2xpcHNlLndzdC5tb25pdG9yLnVpPGJyLz4KLSAgY29tLmlibS53dHAud2ViYnJvd3NlciAtPiBvcmcuZWNsaXBzZS53c3Qud2ViYnJvd3NlcjwvdGQ+Ci0gIDx0ZD5SZW5hbWluZyBmb3Igb3BlbiBzb3VyY2U8L3RkPgotICA8dGQ+PC90ZD4KLSAgPHRkPjwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+PC90ZD4KLSAgPHRkPjwvdGQ+Ci0gIDx0ZD48L3RkPgotICA8dGQ+PC90ZD4KLTwvdHI+Ci08L3RhYmxlPgotCi0KLQotCi08dGFibGUgYm9yZGVyPSIwIiBjZWxscGFkZGluZz0iMiIgY2VsbHNwYWNpbmc9IjUiIHdpZHRoPSIxMDAlIj4KLSAgPHRib2R5Pjx0cj4gCi0gICAgPHRkIGNvbHNwYW49IjIiIGFsaWduPSJsZWZ0IiBiZ2NvbG9yPSIjMDA4MGMwIiB2YWxpZ249InRvcCI+PGI+PGZvbnQgY29sb3I9IiNmZmZmZmYiIGZhY2U9IkFyaWFsLEhlbHZldGljYSI+TTIgQ2hhbmdlczwvZm9udD48L2I+PC90ZD4KLSAgPC90cj48L3Rib2R5PgotPC90YWJsZT4KLQotSGVyZSBhcmUgdGhlIFNlcnZlciBUb29scyBBUEkgY2hhbmdlcyB0aGF0IHdlbnQgaW50byBNMi4KLQotPHAvPgotCi08dGFibGUgYm9yZGVyPTEgY2VsbHNwYWNpbmc9IjAiPgotPHRyPgotICA8dGg+Q2hhbmdlPC90aD4KLSAgPHRoPlJlYXNvbjwvdGg+Ci0gIDx0aD5PbGQgQ29kZTwvdGg+Ci0gIDx0aD5OZXcgQ29kZTwvdGg+Ci08L3RyPgotPHRyPgotICA8dGQ+QWxsIGphdmEudXRpbC5MaXN0cyByZXR1cm5lZCBmcm9tIG1ldGhvZHMgaGF2ZSBiZWVuIGNoYW5nZWQgdG8gYXJyYXlzIG9mIHRoZSBjb3JyZXNwb25kaW5nCi0gICAgICBjb250ZW50IHR5cGUuPC90ZD4KLSAgPHRkPlN0cm9uZ2VyIHR5cGVkIHJldHVybiB2YWx1ZXMgYXJlIHNhZmVyLCBhbmQgcmV0dXJuaW5nIGEgY29weSBvZiB0aGUgbGlzdCAoaW5zdGVhZCBvZiB0aGUgbGlzdAotICAgICAgaXRzZWxmKSBibG9ja3MgYWdhaW5zdCBjbGllbnRzIG1vZGlmeWluZyBpbnRlcm5hbCBkYXRhIHN0cnVjdHVyZXMuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5MaXN0IGxpc3QgPSBTZXJ2ZXJDb3JlLmdldFJ1bnRpbWVUeXBlcygpOzwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+SVJ1bnRpbWVUeXBlW10gcnQgPSBTZXJ2ZXJDb3JlLmdldFJ1bnRpbWVUeXBlcygpOzwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+SVJlc291cmNlTWFuYWdlciBoYXMgYmVlbiByZW1vdmVkLiBNb3N0IG9mIGl0J3MgbWV0aG9kcyBoYXZlIGJlZW4gbW92ZWQgdG8gdGhlIFNlcnZlckNvcmUKLSAgICAgIGNsYXNzLCB3aXRoIHRoZSByZW1haW5pbmcgb25lcyBpbiBTZXJ2ZXJVdGlsLjwvdGQ+Ci0gIDx0ZD5UaGVyZSB3YXMgbm8gY2xpZW50IGJlbmVmaXQgb2YgdGhlIHJlc291cmNlIG1hbmFnZXIsIGFuZCBpdCB3YXMgbWlzbmFtZWQuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5TZXJ2ZXJDb3JlLmdldFJlc291cmNlTWFuYWdlcigpLmdldFNlcnZlcnMoKTs8L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPlNlcnZlckNvcmUuZ2V0U2VydmVycygpOzwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+QWxsIGV4dGVuc2lvbiBwb2ludCBpbnRlcmZhY2VzIGhhdmUgYmVlbiBjaGFuZ2VkIHRvIGFic3RyYWN0IGNsYXNzZXMsIGFuZCB0aGUgIkkiIHJlbW92ZWQKLSAgICBmcm9tIHRoZSBuYW1lLjwvdGQ+Ci0gIDx0ZD5BbGxvd3MgZm9yIGZ1dHVyZSBzdXBwb3J0IGFuZCBtYWludGVuYW5jZSB3aXRob3V0IGJyZWFraW5nIGV4aXN0aW5nIGludGVyZmFjZXMuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+U2V2ZXJhbCBpbnRlcmZhY2VzIHdlcmUgbW92ZWQgZnJvbSB0aGUgLmNvcmUubW9kZWwgcGFja2FnZSB0byAuY29yZS48L3RkPgotICA8dGQ+VGhlIC5jb3JlLm1vZGVsIHBhY2thZ2Ugd2FzIG1lYW50IGZvciBTUElzLCBub3QgQVBJLiBBbGwgQVBJIGNsYXNzZXMgJiBpbnRlcmZhY2VzIHdpbGwKLSAgICAgIGJlIG1vdmVkIG9yIHJlbWFpbiBpbiAuY29yZSBzbyB0aGF0IEFQSSB1c2VycyBkbyBub3QgbmVlZCB0byB1c2UgdGhlIC5jb3JlLm1vZGVsIHBhY2thZ2UuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5pbXBvcnQgb3JnLmVjbGlwc2Uud3N0LnNlcnZlci5jb2RlLm1vZGVsLklNb2R1bGU7PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5pbXBvcnQgb3JnLmVjbGlwc2Uud3N0LnNlcnZlci5jb2RlLklNb2R1bGU7PC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5JU2VydmVyUmVzb3VyY2VMaXN0ZW5lciByZW5hbWVkIHRvIElTZXJ2ZXJMaWZlY3ljbGVMaXN0ZW5lci4gU2V2ZXJhbCBtZXRob2RzIG1vdmVkIG91dCB0bwotICAgICAgbmV3IElSdW50aW1lTGlzdGVuZXIgYW5kIElTZXJ2ZXJDb25maWd1cmF0aW9uTGlzdGVuZXIgaW50ZXJmYWNlcy48L3RkPgotICA8dGQ+IlJlc291cmNlIiBoYWQgdG8gYmUgcmVtb3ZlZCBmcm9tIHRoZSBuYW1lLCBhbmQgdGhlIGludGVyZmFjZSBjb250YWluZWQgbWV0aG9kcyBmb3IKLSAgICAgIHJ1bnRpbWVzIGFuZCBzZXJ2ZXIgY29uZmlndXJhdGlvbnMgYXMgd2VsbC4gVGhleSBhcmUgc3BsaXQgdXAgc28gdGhhdCBBUEkgdXNlcnMgZG8gbm90Ci0gICAgICBuZWVkIHRvIGxpc3RlbiBmb3IgYWxsIHR5cGVzIG9mIGNoYW5nZXMgZnJvbSBhIHNpbmdsZSBpbnRlcmZhY2UuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5TZXJ2ZXJDb3JlLmdldFJlc291cmNlTWFuYWdlcigpLmFkZFNlcnZlclJlc291cmNlTGlzdGVuZXIobXlMaXN0ZW5lcik7PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5TZXJ2ZXJDb3JlLmFkZFJ1bnRpbWVMaWZlY3ljbGVMaXN0ZW5lcihteUxpc3RlbmVyKTs8L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPlB1Ymxpc2hpbmcgaW50ZXJmYWNlcyBjb21wbGV0ZWx5IHJld3JpdHRlbiAmIC5jb3JlLnJlc291cmNlcyBwYWNrYWdlIHJlbW92ZWQuPC90ZD4KLSAgPHRkPlRoZSBwdWJsaXNoaW5nIGludGVyZmFjZSB3YXMgb3V0ZGF0ZWQgYW5kIHdyaXR0ZW4gYmVmb3JlIHRoZSBFY2xpcHNlIHRlYW0gc3VwcG9ydCwKLSAgICAgIEFOVCwgb3Igb3RoZXIgcmVjZW50IHB1Ymxpc2hpbmcgbWV0aG9kcyBoYWQgYmVlbiBkZXZlbG9wZWQuIFRoZSBuZXcgQVBJIGFsbG93cyBmb3IKLSAgICAgIGJldHRlciBzdXBwb3J0IGFuZCBmb3IgZWFjaCBzZXJ2ZXIgdHlwZSB0byB1c2UgaXQncyBvd24gcHVibGlzaGluZyBtZWNoYW5pc20uPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+SVJ1bnRpbWVEZWxlZ2F0ZSBhbmQgSVJ1bnRpbWVXb3JraW5nQ29weURlbGVnYXRlIG1lcmdlZCBpbnRvIGEgc2luZ2xlIFJ1bnRpbWVEZWxlZ2F0ZS4KLSAgICAgIElTZXJ2ZXJEZWxlZ2F0ZSBhbmQgSVNlcnZlcldvcmtpbmdDb3B5RGVsZWdhdGUgcmV3b3JrZWQgaW50byAKLSAgICAgIFNlcnZlckRlbGVnYXRlIGFuZCBTZXJ2ZXJCZWhhdmlvdXJEZWxlZ2F0ZS48L3RkPgotICA8dGQ+TWFraW5nIGNsaWVudHMgcHJvdmlkZSB0d28gc2VwYXJhdGUgY2xhc3NlcyBmb3IgdGhlIGRlbGVnYXRlcyB3YXMgZXhjZXNzaXZlLAotICAgICAgdW5uZWNlc3NhcnksIGFuZCBlbmRlZCB1cCB3aXRoIHRvbyBtYW55IFNQSSBjbGFzc2VzLiBPbmx5IGEgc2luZ2xlIGRlbGVnYXRlIGNsYXNzIGlzCi0gICAgICBub3cgcmVxdWlyZWQgZm9yIHRoZXNlIGV4dGVuc2lvbiBwb2ludHMuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+SVJ1bnRpbWUuZ2V0RGVsZWdhdGUoKSwgSVJ1bnRpbWUuZ2V0V29ya2luZ0NvcHlEZWxlZ2F0ZSgpIGNoYW5nZWQgaW50byBJUnVudGltZSBleHRlbmRpbmcKLSAgICAgIElBZGFwdGFibGUuIFNpbWlsYXIgZm9yIElTZXJ2ZXIgYW5kIG90aGVyIGRlbGVnYXRlczwvdGQ+Ci0gIDx0ZD5JQWRhcHRhYmxlIGlzIGEgY29tbW9uIEVjbGlwc2UgbWVjaGFuaXNtLCBhbmQgYWxsb3dzIGZvciBvdGhlciBleHRlbnNpb24gYXMgd2VsbC4gQ2xpZW50cwotICAgICAgc2hvdWxkIHN0aWxsIHJlbWVtYmVyIHRoYXQgY2FsbGluZyB0aGlzIG1ldGhvZCBtYXkgaW52b2x2ZSBwbHVnaW4gbG9hZGluZywgc28gaXQgc2hvdWxkCi0gICAgICBub3QgYmUgdXNlZCBpbiBwb3B1cCBtZW51cywgZXRjLjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+SVRvbWNhdFJ1bnRpbWUgdHIgPSAoSVRvbWNhdFJ1bnRpbWUpIHJ1bnRpbWUuZ2V0RGVsZWdhdGUoKTs8L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPklUb21jYXRSdW50aW1lIHRyID0gKElUb21jYXRSdW50aW1lKSBydW50aW1lLmdldEFkYXB0ZXIoSVRvbWNhdFJ1bnRpbWUuY2xhc3MpOzwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+SU1vZHVsZVR5cGUgYW5kIElNb2R1bGVLaW5kIGludGVyZmFjZXMgbWVyZ2VkLjwvdGQ+Ci0gIDx0ZD5JTW9kdWxlS2luZCB3YXMgY3JlYXRlZCBsYXRlIGluIHRoZSBwcmV2aW91cyByZWxlYXNlIGN5Y2xlIGFuZCBjb3VsZG4ndCBiZSBtZXJnZWQgYXQgdGhlCi0gICAgICB0aW1lIGl0IHdhcyBjcmVhdGVkLjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPklTZXJ2ZXJUYXNrIGNoYW5nZWQgYW5kIElNb2R1bGVUYXNrIHJlbW92ZWQuPC90ZD4KLSAgPHRkPlRoZSBleGlzdGluZyBpbnRlcmZhY2VzIGhhZCBhbiBJVGFzayBkaXJlY3RseSByZXR1cm5lZCBhcyBhIGRlbGVnYXRlLCBhbmQgb25seSBhbGxvd2VkIGEKLSAgICAgIHNpbmdsZSB0YXNrIHBlciBleHRlbnNpb24gcG9pbnQuIFRoZSBuZXcgSVNlcnZlclRhc2sgYWxsb3dzIHRoZSBkZWxlZ2F0ZSB0byByZXR1cm4gbXVsdGlwbGUKLSAgICAgIHRhc2tzIGZyb20gYSBzaW5nbGUgZXh0ZW5zaW9uIHBvaW50LCBhbmQgaXQgaXMgbm90IGl0c2VsZiBhIHRhc2suPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+SVNlcnZlckNvbmZpZ3VyYXRpb24sIElTZXJ2ZXJDb25maWd1cmF0aW9uLCBldGMuIHJlbW92ZWQ8L3RkPgotICA8dGQ+VGhlIHNlcnZlciBjb25maWcgd2FzIGEgcmVsaWMgYW5kIGRpZCBub3QgbmVlZCB0byBiZSBhIGZpcnN0IGNsYXNzIHJlc291cmNlLiBTZXJ2ZXJEZWxlZ2F0ZXMKLSAgICAgIGFyZSBub3cgZGlyZWN0bHkgcmVzcG9uc2libGUgZm9yIG1haW50YWluaW5nIHRoZSBjb25maWd1cmF0aW9uLjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5zZWUgVG9tY2F0IGltcGxlbWVudGF0aW9uPC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5WYXJpb3VzIG1pbm9yIGNsZWFudXAgLSBtZXRob2RzIHJlbmFtZWQsIHBhcmFtZXRlcnMgY2hhbmdlZCwgZXRjLjwvdGQ+Ci0gIDx0ZD5DbGVhbnVwIGFuZCBmdXR1cmUgbWFpbnRlbmFuY2UuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+SU1vZHVsZU9iamVjdEFkYXB0ZXIgLT4gSU1vZHVsZUFydGlmYWN0QWRhcHRlciwgSU1vZHVsZU9iamVjdCAtPiBJTW9kdWxlQXJ0aWZhY3Q8L3RkPgotICA8dGQ+T2JqZWN0IHdhcyB0b28gZ2VuZXJpYyBhbmQgZGlkbid0IGhhdmUgYW55IHJlYWwgbWVhbmluZy4gQXJ0aWZhY3QgcmVwcmVzZW50cyB3aGF0IHRoZQotICAgICAgSU1vZHVsZU9iamVjdCByZWFsbHkgcmVwcmVzZW50cyAtIHJlc291cmNlcyB3aXRoaW4gYSBtb2R1bGU8L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+PC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5nZXRTZXJ2ZXJUeXBlKFN0cmluZyBpZCkgLT4gZmluZFNlcnZlclR5cGUoU3RyaW5nIGlkKTwvdGQ+Ci0gIDx0ZD5Mb29rdXAgbWV0aG9kcyBvbiBTZXJ2ZXJDb3JlIGFuZCBTZXJ2ZXJVdGlsIHJlbmFtZWQgdG8gYmUgbW9yZSBhY2N1cmF0ZSB0byB3aGF0Ci0gICAgICB0aGV5IGRvLjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+SVNlcnZlclR5cGUgc3QgPSBnZXRTZXJ2ZXJUeXBlKCJjb20ueCIpPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5JU2VydmVyVHlwZSBzdCA9IGZpbmRTZXJ2ZXJUeXBlKCJjb20ueCIpPC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5Mb3RzIG9mIG1ldGhvZHMgJiBpbnRlcmZhY2VzIG1vdmVkIHRvIGludGVybmFsIHBhY2thZ2VzPC90ZD4KLSAgPHRkPk5lZWQgdG8gdHJpbSBkb3duIHRoZSBleHBvc2VkIEFQSSB0byBvbmx5IHdoYXQgaXMgcmVxdWlyZWQgZm9yIG9uZ29pbmcgbWFpbnRlbmFuY2UuIElmCi0gICAgICB0aGVyZSBpcyBhbnl0aGluZyBpbiBhbiBpbnRlcm5hbCBwYWNrYWdlIHRoYXQgeW91IHdlcmUgcHJldmlvdXNseSB1c2luZywgb3IgcGxhbiB0byB1c2UKLSAgICAgIGluIHRoZSBmdXR1cmUsIHBsZWFzZSBjb250YWN0IG1lIGFuZCB3ZSdsbCB3b3JrIG91dCBhbiBBUEkgc29sdXRpb248L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+PC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5QdWJsaXNoaW5nIGNoYW5nZXMgLSBzZXZlcmFsIGludGVyZmFjZXMgYW5kIHRoZSBvcmcuZWNsaXBzZS53c3Quc2VydmVyLmNvcmUucmVzb3VyY2UKLSAgICAgIHBhY2thZ2UgcmVtb3ZlZDwvdGQ+Ci0gIDx0ZD5UaGUgb2xkIHB1Ymxpc2hpbmcgbWVjaGFuaXNtIGRpZCBub3QgYWxsb3cgZmxleGliaWxpdHkgaW4gcHVibGlzaGluZyBvcHRpb25zIChlLmcuCi0gICAgICBBTlQsIEVjbGlwc2UgdGVhbSBzdXBwb3J0LCBvciBzb21lIG90aGVyIG1lY2hhbmlzbSkgYW5kIHVzZWQgYW4gb3V0ZGF0ZWQgcHVibGlzaGluZwotICAgICAgbWFuYWdlciBmcmFtZXdvcmsuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPlNlcnZlckRlbGVnYXRlLnB1Ymxpc2hTdGFydCgpOyAvLyBDYWxsZWQgdG8gdGVsbCB0aGUgc2VydmVyIHRoYXQgcHVibGlzaGluZyBpcyBzdGFydGluZy4KLSAgICAgIENhbiBiZSB1c2VkIHRvIGNvbm5lY3QgdG8gYSByZW1vdGUgc2VydmVyLCBldGMuPGJyLz4KLSAgICAgIFNlcnZlckRlbGVnYXRlLnB1Ymxpc2hTdGFydCgpOyAvLyBDYWxsZWQgb25jZSB0byBhbGxvdyB0aGUgc2VydmVyIHRvIHB1Ymxpc2ggYW55ICJnbG9iYWwiCi0gICAgICByZXNvdXJjZXMgb3IgYSBzZXJ2ZXIgY29uZmlnPGJyLz4KLSAgICAgIFNlcnZlckRlbGVnYXRlLnB1Ymxpc2hTdGFydCgpOyAvLyBDYWxsZWQgZm9yIGVhY2ggbW9kdWxlIHRvIGdpdmUgdGhlIHNlcnZlciBhIGNoYW5jZQotICAgICAgdG8gcHVibGlzaCB1c2luZyBhbnkgbWV0aG9kIGl0IHdhbnRzPGJyLz4KLSAgICAgIFNlcnZlckRlbGVnYXRlLnB1Ymxpc2hGaW5pc2goKTsgLy8gQ2FsbGVkIHRvIGRpc2Nvbm5lY3QgZnJvbSB0aGUgc2VydmVyIG9yIGNsZWFudXA8L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPklNb25pdG9yYWJsZVNlcnZlciBtZXJnZWQgd2l0aCBJU2VydmVyPC90ZD4KLSAgPHRkPk5vIG5lZWQgZm9yIGFkZGl0aW9uYWwgaW50ZXJmYWNlPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5JU2VydmVyRGVsZWdhdGUgZGVsZWdhdGUgPSBzZXJ2ZXIuZ2V0RGVsZWdhdGUoKTxici8+Ci0gICAgICBpZiAoZGVsZWdhdGUgaW5zdGFuY2VvZiBJTW9uaXRvcmFibGVTZXJ2ZXIpIHs8YnIvPgotICAgICAgICAgSU1vbml0b3JhYmxlU2VydmVyIG1zID0gKElNb25pdG9yYWJsZVNlcnZlcikgZGVsZWdhdGU7PGJyLz4KLSAgICAgICAgIExpc3QgcG9ydHMgPSBtcy5nZXRTZXJ2ZXJQb3J0cygpOzxici8+Ci0gICAgICB9PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5JU2VydmVyUG9ydFtdIHBvcnRzID0gc2VydmVyLmdldFNlcnZlclBvcnRzKCk7PC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5Xb3JraW5nIGNvcHkgY2hhbmdlczwvdGQ+Ci0gIDx0ZD5QcmV2aW91c2x5LCByZWZlcmVuY2VzIHdlcmUga2VwdCB0byBldmVyeSB3b3JraW5nIGNvcHksIGFuZCBjbGllbnRzIGhhZCB0byBzYXZlKCkgb3IKLSAgICAgIHJlbGVhc2UoKSB0aGVtIGluIGZpbmFsbHkgYmxvY2tzIG9yIGVsc2UgdGhlIHJlZmVyZW5jZSB3b3VsZCBiZSBkYW5nbGluZyAoYW5kIHBvc3NpYmx5Ci0gICAgICBibG9ja2luZyBvdGhlciBjaGFuZ2VzKSBmb3JldmVyLiBUaGlzIGNvZGUgd2FzIHVuc2FmZSBhbmQgY2F1c2VkIHByb2JsZW1zIGlmIGEgY2xpZW50Ci0gICAgICB0cmllZCB0byB1c2UgYSB3b3JraW5nIGNvcHkgYWZ0ZXIgaXQgaGFkIGJlZW4gc2F2ZWQgb3IgcmVsZWFzZWQuCi0gICAgICBOb3csIGNsaWVudHMgY2FuIGNyZWF0ZSBhIHdvcmtpbmcgY29weSBhdCBhbnkgdGltZSwgYW5kIHJlZmVyZW5jZXMgYXJlIG5vdCBrZXB0LiBPbgotICAgICAgc2F2ZSwgYSBjbGllbnQgY2FuIHNwZWNpZnkgd2hldGhlciB0aGUgd29ya2luZyBjb3B5IGNoYW5nZXMgc2hvdWxkIGJlIGZvcmNlZCwgb3Igbm90Ci0gICAgICAoaW4gd2hpY2ggY2FzZSB0aGUgc2F2ZSB3aWxsIGZhaWwgaWYgc29tZW9uZSBlbHNlIGhhcyBtYWRlIGNoYW5nZXMgdG8gdGhlIG9iamVjdCBpbgotICAgICAgdGhlIG1lYW50aW1lKS4gSWYgdGhlIGNoYW5nZXMgZG8gbm90IG5lZWQgdG8gYmUgc2F2ZWQsIGNsaWVudHMgY2FuIGp1c3QgZHJvcCB0aGUKLSAgICAgIHJlZmVyZW5jZSB0byB0aGUgd29ya2luZyBjb3B5IGF0IGFueSB0aW1lLiBBcyBiZWZvcmUsIHdvcmtpbmcgY29waWVzIHNob3VsZCBub3QgYmUKLSAgICAgIHVzZWQgZm9yIGxvbmcgcGVyaW9kcyBvZiB0aW1lIHNpbmNlIGl0IGluY3JlYXNlcyB0aGUgY2hhbmNlcyB0aGF0IGFub3RoZXIgY2xpZW50IGhhcwotICAgICAgbWFkZSBjaGFuZ2VzPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj5JU2VydmVyV29ya2luZ0NvcHkgd2MgPSBJU2VydmVyLmdldFdvcmtpbmdDb3B5KCk7PGJyLz4KLSAgICAgIC8vIGRvIHNvbWV0aGluZyB3aXRoIHdjPGJyLz4KLSAgICAgIHdjLnNhdmUoKTsgb3Igd2MucmVsZWFzZSgpOzwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+SVNlcnZlcldvcmtpbmdDb3B5IHdjID0gSVNlcnZlci5jcmVhdGVXb3JraW5nQ29weSgpOzxici8+Ci0gICAgICAvLyBkbyBzb21ldGhpbmcgd2l0aCB3Yzxici8+Ci0gICAgICB3Yy5zYXZlKCk7IG9yIGxvc2UgcmVmZXJlbmNlPC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5DaGFuZ2UgSVNlcnZlci5pc1Jlc3RhcnROZWVkZWQoKSB0byBtYXRjaCBvdGhlciBtZXRob2RzPC90ZD4KLSAgPHRkPjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+SVNlcnZlci5pc1Jlc3RhcnROZWVkZWQoKTs8L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPklTZXJ2ZXIuZ2V0U2VydmVyUmVzdGFydFN0YXRlKCk7PC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD48L3RkPgotICA8dGQ+PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci08L3RyPgotPC90YWJsZT4KLQotCi0KLTx0YWJsZSBib3JkZXI9IjAiIGNlbGxwYWRkaW5nPSIyIiBjZWxsc3BhY2luZz0iNSIgd2lkdGg9IjEwMCUiPgotICA8dGJvZHk+PHRyPiAKLSAgICA8dGQgY29sc3Bhbj0iMiIgYWxpZ249ImxlZnQiIGJnY29sb3I9IiMwMDgwYzAiIHZhbGlnbj0idG9wIj48Yj48Zm9udCBjb2xvcj0iI2ZmZmZmZiIgZmFjZT0iQXJpYWwsSGVsdmV0aWNhIj5NMyBDaGFuZ2VzPC9mb250PjwvYj48L3RkPgotICA8L3RyPjwvdGJvZHk+Ci08L3RhYmxlPgotCi1IZXJlIGFyZSB0aGUgU2VydmVyIFRvb2xzIEFQSSBjaGFuZ2VzIHRoYXQgd2VudCBpbnRvIE0zLgotCi08cC8+Ci0KLTx0YWJsZSBib3JkZXI9MSBjZWxsc3BhY2luZz0iMCI+Ci08dHI+Ci0gIDx0aD5DaGFuZ2U8L3RoPgotICA8dGg+UmVhc29uPC90aD4KLSAgPHRoPk9sZCBDb2RlPC90aD4KLSAgPHRoPk5ldyBDb2RlPC90aD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5SZW1vdmUgc2VydmVyQWN0aW9uIGV4dGVuc2lvbiBwb2ludDwvdGQ+Ci0gIDx0ZD5EdXBsaWNhdGUgZnVuY3Rpb24gZXhpc3RzIGluIEVjbGlwc2UgdjMuMDwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+Jmx0O2V4dGVuc2lvbiBwb2ludD0ib3JnLmVjbGlwc2Uud3N0LnNlcnZlci51aS5zZXJ2ZXJBY3Rpb25zIiZndDs8YnIvPgotICAmbHQ7c2VydmVyQWN0aW9uIGlkPSJvcmcuZWNsaXBzZS53c3Quc2VydmVyLnVpLnByb2plY3RzIjxici8+Ci0gICAgdHlwZUlkcz0ib3JnLmVjbGlwc2UuanN0LioiPGJyLz4KLSAgICBsYWJlbD0iJWFjdGlvbk1vZGlmeU1vZHVsZXMiPGJyLz4KLSAgICBjYXRlZ29yeT0iY29udHJvbCI8YnIvPgotICAgIGljb249Imljb25zL2N0b29sMTYvd2l6X21vZGlmeV9tb2R1bGVzLmdpZiI8YnIvPgotICAgIG9yZGVyPSI1MCI8YnIvPgotICAgIGNsYXNzPSJvcmcuZWNsaXBzZS53c3Quc2VydmVyLnVpLmludGVybmFsLmFjdGlvbnMuQWRkUmVtb3ZlTW9kdWxlc0FjdGlvbiIvJmd0Ozxici8+Ci0mbHQ7L2V4dGVuc2lvbiZndDs8L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPiZsdDtleHRlbnNpb24gcG9pbnQ9Im9yZy5lY2xpcHNlLnVpLnBvcHVwTWVudXMiJmd0Ozxici8+Ci0gICZsdDtvYmplY3RDb250cmlidXRpb248YnIvPgotICAgIGlkPSJvcmcuZWNsaXBzZS53c3Quc2VydmVyLnVpLnBvcHVwTWVudSI8YnIvPgotICAgIG9iamVjdENsYXNzPSJvcmcuZWNsaXBzZS53c3Quc2VydmVyLmNvcmUuSVNlcnZlciI8YnIvPgotICAgIGFkYXB0YWJsZT0idHJ1ZSImZ3Q7PGJyLz4KLSAgICAmbHQ7ZmlsdGVyIG5hbWU9InR5cGVJZHMiIHZhbHVlPSJvcmcuZWNsaXBzZS5qc3QuKiIvJmd0Ozxici8+Ci0gICAgJmx0O2FjdGlvbjxici8+Ci0gICAgICBpZD0ib3JnLmVjbGlwc2Uud3N0LnNlcnZlci51aS5hY3Rpb24ubW9kaWZ5TW9kdWxlcyI8YnIvPgotICAgICAgbGFiZWw9IiVhY3Rpb25Nb2RpZnlNb2R1bGVzIjxici8+Ci0gICAgICBpY29uPSJpY29ucy9jdG9vbDE2L3dpel9tb2RpZnlfbW9kdWxlcy5naWYiPGJyLz4KLSAgICAgIGNsYXNzPSJvcmcuZWNsaXBzZS53c3Quc2VydmVyLnVpLmludGVybmFsLmFjdGlvbnMuTW9kaWZ5TW9kdWxlc0FjdGlvbiImZ3Q7PGJyLz4KLSAgICAmbHQ7L2FjdGlvbiZndDs8YnIvPgotICAmbHQ7L29iamVjdENvbnRyaWJ1dGlvbiZndDs8YnIvPgotJmx0Oy9leHRlbnNpb24mZ3Q7PC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5SZW1vdmUgb2JqZWN0Q2xhc3MgYXR0cmlidXRlIGZyb20gbW9kdWxlQXJ0aWZhY3RBZGFwdGVyIGV4dGVuc2lvbiBwb2ludCBhbmQgc3dpdGNoIHRvIGV4cHJlc3Npb25zPC90ZD4KLSAgPHRkPlJlbW92YWwgb2YgSU1vZHVsZUFydGlmYWN0QWRhcHRlciBjbGFzczwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPklFbGVtZW50IGFuZCBJRWxlbWVudFdvcmtpbmdDb3B5IHJlbW92ZWQ8L3RkPgotICA8dGQ+VGhlcmUgd2FzIG5vIHBvaW50IGhhdmluZyBjb21tb24gY29kZSBiZXR3ZWVuIElSdW50aW1lIGFuZCBJU2VydmVyLCBzaW5jZSB0aGV5IGRpZG4ndCByZWFsbHkgaGF2ZQotICAgICAgYW55IGNvbW1vbiBzdHJ1Y3R1cmUuIEV4aXN0aW5nIG1ldGhvZHMgbW92ZWQgdG8gY29ycmVjdCBsb2NhdGlvbiBpbiBJUnVudGltZSwgSVNlcnZlciwgYW5kIHRoZWlyIHdvcmtpbmcgY29waWVzLjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotPC90cj4KLTx0cj4KLSAgPHRkPklNb2R1bGVFdmVudCBhbmQgSU1vZHVsZUZhY3RvcnlFdmVudCBjaGFuZ2VkIHRvIE1vZHVsZUV2ZW50IGFuZCBNb2R1bGVGYWN0b3J5RXZlbnQ8L3RkPgotICA8dGQ+RXZlbnQgY2xhc3NlcyBhcmUgbm90IHR5cGljYWxseSBpbnRlcmZhY2VzLCBhbmQgdGhlcmUgd2FzIG5vIHJlYXNvbiB0byBhYnN0cmFjdCB0aGVzZSB0d28gY2xhc3Nlcy48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPklNb2R1bGVFdmVudDxici8+SU1vZHVsZUZhY3RvcnlFdmVudDwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+TW9kdWxlRXZlbnQ8YnIvPk1vZHVsZUZhY3RvcnlFdmVudDwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+SVNlcnZlclByZWZlcmVuY2VzIHJlbW92ZWQ8L3RkPgotICA8dGQ+SVNlcnZlclByZWZlcmVuY2VzIHdhcyBub3QgcmVxdWlyZWQgYXMgQVBJIGFuZCB3YXMgbm90IGJlaW5nIHVzZWQgYnkgZXh0ZXJuYWwgcGx1Z2lucy4gVG8gY2xlYW4gdXAgQVBJLAotICAgICAgaXQgaXMgYmVpbmcgcmVtb3ZlZCBmcm9tIHRoZSBmaXJzdCBBUEkgdmVyc2lvbi48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+PC90ZD4KLTwvdHI+Ci08dHI+Ci0gIDx0ZD5TZXJ2ZXJCZWhhdmlvdXJEZWxlZ2F0ZS5zZXRMYXVuY2hEZWZhdWx0cygpIHJlbmFtZWQ8L3RkPgotICA8dGQ+U2VydmVyQmVoYXZpb3VyRGVsZWdhdGUuc2V0TGF1bmNoRGVmYXVsdHMoKSB3YXMgcmVuYW1lZCB0byBTZXJ2ZXJCZWhhdmlvdXJEZWxlZ2F0ZS5zZXR1cExhdW5jaENvbmZpZ3VyYXRpb24oKS4KLSAgICAgIEl0IGlzIG5vdyBjYWxsZWQgb24gZXZlcnkgbGF1bmNoIGluc3RlYWQgb2YganVzdCB0aGUgZmlyc3QgdGltZS4gVGhpcyBhbGxvd3Mgc2VydmVycyB0byB1cGRhdGUgdGhlIGxhdW5jaAotICAgICAgY29uZmlndXJhdGlvbiBiZWZvcmUgaXQgaXMgZXhlY3V0ZWQuPC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotICA8dGQgY2xhc3M9ImNvZGUiPjwvdGQ+Ci08L3RyPgotPHRyPgotICA8dGQ+PC90ZD4KLSAgPHRkPjwvdGQ+Ci0gIDx0ZCBjbGFzcz0iY29kZSI+PC90ZD4KLSAgPHRkIGNsYXNzPSJjb2RlIj48L3RkPgotPC90cj4KLTwvdGFibGU+Ci0KLTwvYm9keT4KLTwvaHRtbD4KXCBObyBuZXdsaW5lIGF0IGVuZCBvZiBmaWxlCmRpZmYgLS1naXQgYS9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL3NlcnZlci9TZXJ2ZXIgVG9vbHMgUGFja2FnZSBSZW5hbWVzLnByb3BlcnRpZXMgYi9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL3NlcnZlci9TZXJ2ZXIgVG9vbHMgUGFja2FnZSBSZW5hbWVzLnByb3BlcnRpZXMKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhmYjU2NjguLjAwMDAwMDAKLS0tIGEvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy9zZXJ2ZXIvU2VydmVyIFRvb2xzIFBhY2thZ2UgUmVuYW1lcy5wcm9wZXJ0aWVzCisrKyAvZGV2L251bGwKQEAgLTEsMTAgKzAsMCBAQAotY29tLmlibS53dHAuc2VydmVyLmNvcmU9b3JnLmVjbGlwc2Uud3N0LnNlcnZlci5jb3JlCi1jb20uaWJtLnd0cC5zZXJ2ZXIudWk9b3JnLmVjbGlwc2Uud3N0LnNlcnZlci51aQotY29tLmlibS53dHAuc2VydmVyLnV0aWw9b3JnLmVjbGlwc2Uud3N0LnNlcnZlci51dGlsCi1jb20uaWJtLnd0cC5zZXJ2ZXIuamF2YS5jb3JlPW9yZy5lY2xpcHNlLmpzdC5zZXJ2ZXIuY29yZQotY29tLmlibS53dHAuc2VydmVyLmphdmEudWk9b3JnLmVjbGlwc2UuanN0LnNlcnZlci51aQotY29tLmlibS53dHAuc2VydmVyLnRvbWNhdC5jb3JlPW9yZy5lY2xpcHNlLmpzdC5zZXJ2ZXIudG9tY2F0LmNvcmUKLWNvbS5pYm0ud3RwLnNlcnZlci50b21jYXQudWk9b3JnLmVjbGlwc2UuanN0LnNlcnZlci50b21jYXQudWkKLWNvbS5pYm0ud3RwLm1vbml0b3IuY29yZT1vcmcuZWNsaXBzZS53c3QubW9uaXRvci5jb3JlCi1jb20uaWJtLnd0cC5tb25pdG9yLnVpPW9yZy5lY2xpcHNlLndzdC5tb25pdG9yLnVpCi1jb20uaWJtLnd0cC53ZWJicm93c2VyPW9yZy5lY2xpcHNlLndzdC53ZWJicm93c2VyClwgTm8gbmV3bGluZSBhdCBlbmQgb2YgZmlsZQpkaWZmIC0tZ2l0IGEvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy9zZXJ2ZXIvU2VydmVyVG9vbHNVc2VDYXNlcy5odG1sIGIvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy9zZXJ2ZXIvU2VydmVyVG9vbHNVc2VDYXNlcy5odG1sCmRlbGV0ZWQgZmlsZSBtb2RlIDEwMDY0NAppbmRleCA0YjgxMjg3Li4wMDAwMDAwCi0tLSBhL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvc2VydmVyL1NlcnZlclRvb2xzVXNlQ2FzZXMuaHRtbAorKysgL2Rldi9udWxsCkBAIC0xLDMyNSArMCwwIEBACi08IURPQ1RZUEUgaHRtbCBQVUJMSUMgIi0vL3czYy8vZHRkIGh0bWwgNC4wIHRyYW5zaXRpb25hbC8vZW4iPgotPGh0bWw+PGhlYWQ+Ci08bWV0YSBodHRwLWVxdWl2PSJDb250ZW50LVR5cGUiIGNvbnRlbnQ9InRleHQvaHRtbDsgY2hhcnNldD1pc28tODg1OS0xIj4KLQotPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2RlZmF1bHRfc3R5bGUuY3NzIiB0eXBlPSJ0ZXh0L2NzcyI+Ci08L2hlYWQ+Ci0KLQotCi08Ym9keSBhbGluaz0iI2ZmMDAwMCIgYmdjb2xvcj0iI2ZmZmZmZiIgbGluaz0iIzAwMDBlZSIgdGV4dD0iIzAwMDAwMCIgdmxpbms9IiM1NTFhOGIiPgotCi08dGFibGUgYm9yZGVyPSIwIiBjZWxscGFkZGluZz0iMiIgY2VsbHNwYWNpbmc9IjUiIHdpZHRoPSIxMDAlIj4KLQotICA8dGJvZHk+PHRyPiAKLQotIAkJPFREIFdJRFRIPTYwJT4KLQkJCTxQIEFMSUdOPUxFRlQ+PEI+PEZPTlQgU0laRT02PjxGT05UIEZBQ0U9IlZlcmRhbmEsIEFyaWFsLCBIZWx2ZXRpY2EsIHNhbnMtc2VyaWYiPlNlcnZlciBUb29scyBVc2UgQ2FzZXM8L0ZPTlQ+PC9GT05UPjwvQj48QlI+PEZPTlQgU0laRT0xPjxGT05UIEZBQ0U9IkFyaWFsLCBIZWx2ZXRpY2EsIHNhbnMtc2VyaWYiPjxGT05UIENPTE9SPSIjODA4MGZmIj50aGUKLQkJCVNlcnZlciBUb29scyBVc2UgQ2FzZXM8L0ZPTlQ+PC9GT05UPjwvRk9OVD4KLQkJCQkJCTwvUD4KLQkJPC9URD4KLQotCi08L3RkPgotCi08IS0tICAgIDx0ZCB3aWR0aD0iMTklIiByb3dzcGFuPSIyIj48aW1nIHNyYz0iaW1hZ2VzL0lkZWEuanBnIiBoZWlnaHQ9ODYgd2lkdGg9MTIwPjwvdGQ+IC0tPgotCi0gICAgPHRkIHJvd3NwYW49IjIiIHdpZHRoPSIxOSUiPjxpbWcgc3JjPSJodHRwOi8vd3d3LmVjbGlwc2Uub3JnL2ltYWdlcy9JZGVhLmpwZyIgYm9yZGVyPSIwIiBoZWlnaHQ9Ijg2IiB3aWR0aD0iMTIwIj48L3RkPgotCi0gIDwvdHI+Ci0KLQotPC90Ym9keT48L3RhYmxlPgotCi08dGFibGUgYm9yZGVyPSIwIiBjZWxscGFkZGluZz0iMiIgY2VsbHNwYWNpbmc9IjUiIHdpZHRoPSIxMDAlIj4KLQotICA8dGJvZHk+PHRyPiAKLQotICAgIDx0ZCBjb2xzcGFuPSIyIiBhbGlnbj0ibGVmdCIgYmdjb2xvcj0iIzAwODBjMCIgdmFsaWduPSJ0b3AiPjxiPjxmb250IGNvbG9yPSIjZmZmZmZmIiBmYWNlPSJBcmlhbCxIZWx2ZXRpY2EiPlByaW5jaXBsZXM8L2ZvbnQ+PC9iPjwvdGQ+Ci0KLSAgPC90cj4KLTx0cj4KLTx0ZD4KLTxwPlRoZSBwdXJwb3NlIG9mIHRoaXMgZG9jdW1lbnQgaXMgdG8gbGlzdCBleHBsaWNpdCB1c2UgY2FzZXMgZm9yIHRoZSBzZXJ2ZXIgdG9vbHMgY29tcG9uZW50LiBUaGVzZSB1c2VzIGNhc2VzIGNhbiBiZSB1c2VkIHRvIGJvdGggaGVscCBndWlkZSBkZXNpZ24gKHRvIG1ha2Ugc3VyZSBtaW5pbWFsIEFQSSBpcyBzdWZmaWNpZW50IHRvIHN1cHBvcnQgdGhlc2UgbGlzdGVkLCBhbmQgb25seSB0aGVzZSBsaXN0ZWQsIHVzZSBjYXNlcykgYW5kIHRvIGhlbHAgZ3VpZGUgdGVzdGluZyAoYm90aCB1bml0IHRlc3RzLCBhbmQgbWlsZXN0b25lL3JlbGVhc2UgdGVzdGluZykuPC9wPgotCQkJPFA+PEI+UHJpbmNpcGxlOjwvQj4gV2UnbGwgY29uc2lkZXIgc3RhcnRpbmcgcG9pbnQgbmFpdmUgZW5kIHVzZXJzIHdobwotCQkJa25vdyBub3RoaW5nIG9mIHNlcnZlcnMsIGFuZCB0aGV5IGRvbid0IGNhcmUsIGp1c3Qgd2FudCBvbmUgaW5zdGFsbGVkCi0JCQlpbnN0YWxsZWQgc28gdGhleSBjYW4gZm9jdXMgb24gdGhlaXIgd2ViIGRldmVsb3BtZW50LiBXZSdsbCBjb25zaWRlcgotCQkJdGhyZWUgbGV2ZWxzOiAxKSBVc2VyIGRvZXMgbmVhciBub3RoaW5nLCAyKSB1c2VyIGRvZXNuJ3QgZG8gbXVjaCwgYnV0Ci0JCQltYXkgaGF2ZSB0byBwcm92aWRlIHNvbWUgY29uZmlndXJhdGlvbiB2YWx1ZXMgYW5kL29yIGltcG9ydAotCQkJY29uZmlndXJhdGlvbiB2YWx1ZXMuIDMpIFVzZXIgaGFzIHRvIHByb3ZpZGUgbWFueSBjb25maWd1cmF0aW9uCi0JCQl2YWx1ZXMsIGFuZCBpbiB0aGUgd29yc3QgY2FzZXMsIGFjdHVhbGx5IHdyaXRlIGFudCBzY3JpcHRzLjwvUD4KLQkJCTxwPjxiPlByaW5jaXBsZTo8L2I+IEluIGFkZGl0aW9uIHRvICJlbmQgdXNlciIgdXNlIGNhc2VzLCAKLXdlJ2xsIHNwZWNpZnkgJnF1b3Q7Y2xpZW50IGNvZGUmcXVvdDsgdXNlcy1jYXNlIHRoYXQgbWF5Ci1zaW1wbHkgYmUgc3BlY2lmeWluZyBkZXRhaWxzIG9mIGZ1bmN0aW9uIG5lZWRlZCBmb3IgZW5kLXVzZXIgdXNlIGNhc2VzLCBidXQKLXdpbGwgYWx3YXlzIGhhdmUgYSB1bml0IHRlc3QgYXNzb2NpYXRlZCB3aXRoIGl0LiBBbHNvLCB3ZSdsbCBzcGVjaWZ5ICJzZXJ2aWNlIHByb3ZpZGVyIiAKLXVzZSBjYXNlcyB3aGljaCBjYW4gYmUgdXNlZCB0byBkZWZpbmUgU1BJJ3MuIDwvcD4KLTwvdGQ+Ci08L3RyPgotPHRyPgotICAgIDx0ZCBjb2xzcGFuPSIyIiBhbGlnbj0ibGVmdCIgYmdjb2xvcj0iIzAwODBjMCIgdmFsaWduPSJ0b3AiPjxiPjxmb250IGNvbG9yPSIjZmZmZmZmIiBmYWNlPSJBcmlhbCxIZWx2ZXRpY2EiPkVuZCBVc2VyIFVzZSBDYXNlczwvZm9udD48L2I+PC90ZD4KLSAgPC90cj4KLSAgPHRyPgotICA8dGQ+Ci0gPHRhYmxlIHdpZHRoPSI5NSUiIGJvcmRlcj0iMSIgY2VsbHBhZGRpbmc9IjEiIGNlbGxzcGFjaW5nPSIxIj4KLQk8dGJvZHk+Ci0JCTx0cj4KLQkJCTx0aCBzdHlsZT0id2lkdGg6IDEwOHB4Ij5OYW1lPC90aD4KLQkJCTx0aCBzdHlsZT0id2lkdGg6IDYwcHgiPlByaW9yaXR5PC90aD4KLQkJCTx0aCBzdHlsZT0id2lkdGg6IDM2MHB4Ij5EZXNjcmlwdGlvbjwvdGg+Ci0JCTwvdHI+Ci0JCTx0cj4KLQkJCTx0ZD5JbnN0YWxsIGEgU2VydmVyPC90ZD4KLQkJCTx0ZD4yPC90ZD4KLQkJCTx0ZD5Gcm9tIGFuIHVwZGF0ZSBzaXRlLCB1c2VyIGNhbiBpbnN0YWxsIGEKLQkJCXNlcnZlciAodXNpbmcgRWNsaXBzZSBzdGFuZGFyZCB1cGRhdGUgbWFuYWdlciBmdW5jdGlvbnMpLjwvdGQ+Ci0JCTwvdHI+Ci0JCTx0cj4KLQkJCTx0ZD5Db25maWd1cmUgYSBKYWthcnRhLXRvbWNhdDwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+R2l2ZW4gYSBKYWthcnRhLXRvbWNhdCBzZXJ2ZXIgKFY1KSBpbnN0YWxsZWQKLQkJCW9uIGxvY2FsIGZpbGUgc3lzdGVtLCB1c2VyIGNhbiAmcXVvdDtpbnN0YWxsJnF1b3Q7IGEgc2VydmVyIHRvIFdUUCBieQotCQkJc2VsZWN0aW5nIGZyb20gYSBsaXN0IG9mIGF2YWlsYWJsZSBzZXJ2ZXIgYWRhcHRlcnMsIHNlbGVjdGluZyB0aGUgb25lCi0JCQlmb3IgSmFrYXJ0YS10b21jYXQgc2VydmVyLCBhbmQgc3BlY2lmeWluZyBsb2NhdGlvbiBvZiBzZXJ2ZXIncwotCQkJaW5zdGFsbCBkaXJlY3RvcnkuCi0JCQk8dGFibGUgYm9yZGVyPSIxIj4KLQkJCQk8dGJvZHk+Ci0JCQkJCTx0cj4KLQkJCQkJCTx0ZD5WYXJpYW50IDE8L3RkPgotCQkJCQkJPHRkIHN0eWxlPSJ3aWR0aDogMjc3cHgiPkpCb3NzIFNlcnZlciBpbnN0ZWFkPC90ZD4KLQkJCQkJPC90cj4KLQkJCQk8L3Rib2R5PgotCQkJPC90YWJsZT4KLQkJCTwvdGQ+Ci0JCTwvdHI+Ci0KLQkJPHRyPgotCQkJPHRkPkV4cG9ydCBBTlQgYnVpbGQgc2NyaXB0cyBmb3IgbW9kdWxlczwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+VXNlciBleHBvcnRzIEFOVCBidWlsZCBzY3JpcHQgdGhhdCBjb21waWxlcyBhbmQgcGFja2FnZXMgYSBtb2R1bGUgaW4gZm9yIHVzZSBvdXRzaWRlIHRoZSBFY2xpcHNlLCBwb3NzaWJseSBmb3IgYXV0b21hdGVkIGJ1aWxkcy4gPC90ZD4KLQkJPC90cj4KLQkJPHRyPgotCQkJPHRkPkRyYWcgYSBtb2R1bGUvYXJ0aWZhY3QgdG8gYSBzZXJ2ZXIgdG8gcHVibGlzaCBpdDwvdGQ+Ci0JCQk8dGQ+MzwvdGQ+Ci0JCQk8dGQ+VXNlcnMgZHJhZ3MgYSBtb2R1bGUgb3IgYSBhcnRpZmFjdCBpbiBpdCBpbnRvIGEgc2VydmVyLCB3aGljaCB3b3VsZCBtZWFuIHRoZSBzYW1lIGFjdGlvbiBhcyAmcXVvdDtSdW4gb24gU2VydmVyJnF1b3Q7IC48L3RkPgotCQk8L3RyPgotCi0JCTx0cj4KLQkJCTx0ZD5ydW4gb24gSjJFRSBzZXJ2ZXI8L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPnVzZXIgY2FuIHNlbGVjdCBhIEpTUCBhbmQgJnF1b3Q7cnVuIG9uCi0JCQlzZXJ2ZXImcXVvdDssIG1lYW5pbmcgaXQgd2lsbCBiZSBkaXNwbGF5ZWQgaW4gRWNsaXBzZSB3ZWIgYnJvd3Nlci4KLQkJCTx0YWJsZSBib3JkZXI9IjEiPgotCQkJCTx0Ym9keT4KLQkJCQkJPHRyPgotCQkJCQkJPHRkIHN0eWxlPSJ3aWR0aDogNjZweCI+VmFyaWFudCAxPC90ZD4KLQkJCQkJCTx0ZCBzdHlsZT0id2lkdGg6IDM0OHB4Ij5JZiBubyBtb3JlIHRoYW4gb25lIGluc3RhbGxlZCwgdGhlIHVzZXIKLQkJCQkJCXdpbGwgbm90IGdldCBsaXN0IHRvIHNlbGVjdCBmcm9tPC90ZD4KLQkJCQkJPC90cj4KLQkJCQk8L3Rib2R5PgotCQkJPC90YWJsZT4KLQkJCTx0YWJsZSBib3JkZXI9IjEiPgotCQkJCTx0Ym9keT4KLQkJCQkJPHRyPgotCQkJCQkJPHRkIHN0eWxlPSJ3aWR0aDogNjlweCI+VmFyaWFudCAyPC90ZD4KLQkJCQkJCTx0ZCBzdHlsZT0id2lkdGg6IDM0NXB4Ij5JZiBub25lIGluc3RhbGxlZCwgdGhlIHVzZXIgd2lsbCBiZSBnaXZlbgotCQkJCQkJYSBjaGFuY2UgdG8gc2VsZWN0IGFuZCBpbnN0YWxsIG9uZSAoc2VlIEluc3RhbGwgYSBTZXJ2ZXIpPC90ZD4KLQkJCQkJPC90cj4KLQkJCQk8L3Rib2R5PgotCQkJPC90YWJsZT4KLQkJCTx0YWJsZSBib3JkZXI9IjEiPgotCQkJCTx0Ym9keT4KLQkJCQkJPHRyPgotCQkJCQkJPHRkIHN0eWxlPSJ3aWR0aDogNjVweCI+VmFyaWFudCAzPC90ZD4KLQkJCQkJCTx0ZCBzdHlsZT0id2lkdGg6IDM0OXB4Ij5JZiBtb3JlIHRoYW4gb25lIGluc3RhbGxlZCwgdXNlciBnaXZlbgotCQkJCQkJdGhlIGxpc3Q8L3RkPgotCQkJCQk8L3RyPgotCQkJCTwvdGJvZHk+Ci0JCQk8L3RhYmxlPgotCQkJPC90ZD4KLQkJPC90cj4KLQkJPFRSPgotCQkJPFREPnJ1biBvbiBIVFRQIHNlcnZlcjwvVEQ+Ci0JCQk8VEQ+PC9URD4KLQkJCTxURD5Vc2VyIGNhbiBzZWxlY3QgYW4gSFRNTCBmaWxlLCBhbmQgJnF1b3Q7cnVuIG9uIHNlcnZlciZxdW90Oy4gVGhpcyB1c2UgY2FzZSBjYW4gYmUgcGVyZm9ybWVkIHdpdGggV1NUIG9ubHkuIChUaGlzIHVzZSBjYXNlIGhhcyBub3QgZ290dGVuIGEgbG90IG9mIGRpc2N1c3Npb24sIGJ1dCBzdXBwb3J0IGZvciAmcXVvdDtzdGF0aWMgcHJvamVjdHMmcXVvdDsgaXMgbWVudGlvbmVkIGluIFdUUC9XU1QgdmlzaW9uIHN0YXRlbWVudCwgYW5kIGlzIGEgZ29vZCBjYXNlIHRvIG1ha2Ugc3VyZSB0aGUgYXJjaGl0ZWN0dXJlIGFuZCBkZXNpZ24gaXMgY29ycmVjdCkuIDwvVEQ+Ci0JCTwvVFI+Ci0KLQkJPHRyPgotCQkJPHRkPkFkYXB0IHRvIGV4aXN0aW5nIHByb2plY3QvbW9kdWxlIGxheW91dDxpPihJIGFtIG5vdCBzdXJlLCB0aGlzIGlzIG1heSBiZSBhIHVzZSBjYXNlIGZvciBwcm9qZWN0IGxheW91dCk8L2k+PC90ZD4KLQkJCTx0ZD4xPC90ZD4KLQkJCTx0ZD5Vc2VyIGRlc2NyaWJlcyB0aGUgY3VycmVudCBwcm9qZWN0IGxheW91dCBldmVuIGlmIGl0IGlzIG5vdCBhIGtub3duIGxheW91dCBvZiBhbnkga2luZC4gPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+QWRkIHJ1bnRpbWU8L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPkFkZCBhIG5ldyBzZXJ2ZXIgcnVudGltZSBlbnZpcm9ubWVudCB0aGF0IGV4aXN0cyBvbiB0aGUgdXNlcidzIG1hY2hpbmUuIChQaWNrIHJ1bnRpbWUgZnJvbSBsaXN0LiBFbnRlciBuYW1lLCBsb2NhdGlvbi4gRW50ZXIgcnVudGltZSBzcGVjaWZpYyBpbmZvcm1hdGlvbi4pPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+RWRpdCBvciByZW1vdmUgcnVudGltZTwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+TW9kaWZ5IHJ1bnRpbWUgYXR0cmlidXRlcyBvciByZW1vdmUuPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+VGFyZ2V0IHByb2plY3Q8L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPlRhcmdldCBhIHByb2plY3QgdG8gYSBzcGVjaWZpYyBydW50aW1lLiBUaGlzIGlzIG9wdGlvbmFsIGFuZCBhIHByb2plY3QgbWF5IG9ubHkgYmUgdGFyZ2V0dGVkIHRvIG9uZSBydW50aW1lIGF0IGEgdGltZS4gKFNvbWUgcHJvamVjdCB0eXBlcyBkbwotICAgICAgICAgICAgICAgIG5vdCBuZWVkIGEgdGFyZ2V0LCBzb21lIHByb2plY3RzIGRvIG5lZWQgYSB0YXJnZXQpPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+QWRkIHNlcnZlcjwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+QWRkIChpbnN0YWxsKSBhIG5ldyBzZXJ2ZXIuIEVudGVyIG5hbWUgJiBob3N0bmFtZSwgcGljayBhIHNlcnZlciB0eXBlIGZyb20gYSBsaXN0LCBhbmQgZW50ZXIgc2VydmVyIHNwZWNpZmljIGluZm9ybWF0aW9uLiAoU29tZSBzZXJ2ZXIgdHlwZXMgbWF5IG9ubHkgc3VwcG9ydCBsb2NhbCwgbm90IHJlbW90ZS4gU29tZSBsb2NhbCBzZXJ2ZXJzIG1heSByZXF1aXJlIGEgcnVudGltZS4pPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+RWRpdCBvciByZW1vdmUgc2VydmVyPC90ZD4KLQkJCTx0ZD4xPC90ZD4KLQkJCTx0ZD5Nb2RpZnkgc2VydmVyIGF0dHJpYnV0ZXMgb3IgcmVtb3ZlLjwvdGQ+Ci0JCTwvdHI+Ci0KLQkJPHRyPgotCQkJPHRkPlN0YXJ0L1N0b3AvUmVzdGFydDwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+RWFjaCBzZXJ2ZXIgdHlwZSBtYXkgc3VwcG9ydCBzb21lL2FsbC9ub25lIG9mIHRoZXNlIHN0YXRlIGNoYW5nZXMuIEVhY2ggc2VydmVyIHR5cGUgaGFzIGFuIGluaXRpYWwgc3RhdGUgKG1heSBiZSB1bmtub3duKSwgYW5kIG11c3Qga2VlcCB0aGUgc3RhdGUgaW4gc3luYyBvbmNlIGl0IGlzIGxvYWRlZC4gCi0gICAgICAgICAgICAgICAgU29tZSBvZiB0aGUgc3RhdGUgY2hhbmdlcyAoc3RhcnQvc3RvcCkgYXJlIG5vdCBhdmFpbGFibGUgdW5sZXNzIHRoZSBzZXJ2ZXIgaXMgaW4gdGhlIGNvcnJlY3Qgc3RhdGUuIENvbnNvbGUvRGVidWcgdmlldywgZXRjLiBzaG91bGQgYmUgc3luYydlZCB1cCBvciB1c2VkIGFzIGl0IG1ha2VzIHNlbnNlCi0gICAgICAgICAgICAgICAgZm9yIHRoZSBzZXJ2ZXIgdHlwZS4gU3RhcnRpbmcgbWF5IGJlIGRvbmUgaW4gdGhlIHJlZ3VsYXIgRWNsaXBzZSBsYXVuY2ggbW9kZXMsIGUuZy4gUnVuLCBEZWJ1ZywgUHJvZmlsZSwgLi4uIGRlcGVuZGluZyBvbiB3aGF0IHRoZSBzZXJ2ZXIgc3VwcG9ydHMuIExhdW5jaCBDb25maWd1cmF0aW9ucyBhcmUKLSAgICAgICAgICAgICAgICBjcmVhdGVkIGFuZCB1c2VkIGFzIGFwcGxpY2FibGUuPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+QWRkIHByb2plY3Q8L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPkFkZCBhIG1vZHVsZSB0byBhIHNlcnZlci4gVXNlciBpcyBwcmVzZW50ZWQgd2l0aCBhIGxpc3Qgb2YgbW9kdWxlcyB0aGF0IGFyZSBhdmFpbGFibGUgdG8gYmUgYWRkZWQgdG8gdGhlIHNlcnZlciwgYXMgd2VsbCBhcyBhIGxpc3Qgb2YgbW9kdWxlcyBmcm9tIHRoZSB3b3Jrc3BhY2UgdGhhdCBhcmUKLSAgICAgICAgICAgICAgICBhbHJlYWR5IG9uIHRoZSBzZXJ2ZXIuIEluIHNvbWUgY2FzZXMsIHRoZSBzZXJ2ZXIgbWF5IHByZXNlbnQgYWRkaXRpb25hbCBtb2R1bGVzIGluIHRoZSBzZWNvbmQgbGlzdCB0aGF0IGFyZSBub3QgZnJvbSB0aGUgd29ya3NwYWNlL3VzZXIuIFVzZXIgY2FuIG1vdmUgbW9kdWxlcyBhcm91bmQgYW5kCi0gICAgICAgICAgICAgICAgd2hlbiB0aGV5IGFyZSBkb25lLCB0aGUgbW9kdWxlIGlzIGNvbmZpZ3VyZWQgb24gKGFuZCBwb3NzaWJseSBwdWJsaXNoZWQgdG8pIHRoZSBzZXJ2ZXIuPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+UmVtb3ZlIHByb2plY3Q8L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPlNhbWUgYXMgYWJvdmU8L3RkPgotCQk8L3RyPgotCQkKLQkJPHRyPgotCQkJPHRkPlB1Ymxpc2gvU3luYzwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+T25lIHdheSBwdWJsaXNoIG9mIGFsbCBtb2R1bGVzIHRvIGEgcGFydGljdWxhciBzZXJ2ZXIuIFN5bmNzIHRoZSBtb2R1bGUgY29udGVudCAtIGNvdWxkIGJlIGEgZGVsdGEgb3IgYSBmdWxsIHJlZnJlc2ggZGVwZW5kaW5nIG9uIHRoZSBpbXBsZW1lbnRhdGlvbi48L3RkPgotCQk8L3RyPgotCi0JCTx0cj4KLQkJCTx0ZD5SZXN0YXJ0IG1vZHVsZTwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+T3B0aW9uYWwgYmFzZWQgb24gc2VydmVyIHR5cGUgc3VwcG9ydC4gUmVzdGFydC9yZWZyZXNoL3JlbW92ZSBjYWNoZSBmb3IgYSBwYXJ0aWN1bGFyIG1vZHVsZSBvbiB0aGUgc2VydmVyIHRvIGFsbG93IHRoZSBuZXdseSBwdWJsaXNoZWQgY29udGVudCB0byBiZSBzZXJ2ZWQuPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+Q2hhbmdlIG5vdGlmaWNhdGlvbjwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+VXNlciBtYWtlcyBhIGNoYW5nZSB0byBhIG1vZHVsZSAoZS5nLiBlZGl0IGEgZmlsZSkuIFVzZXIgc2hvdWxkIGJlIG5vdGlmaWVkIG9mIHRoZSBpbXBhY3QgdG8gYW55IHJ1bm5pbmcgc2VydmVycyBhbmQgd2hhdCB0aGV5IG5lZWQgdG8gZG8gdG8gZ2V0IHRoZSBjaGFuZ2UKLQkJCSAgICBwcm9wb2dhdGVkIHRvIHRoZSBzZXJ2ZXIuIChlLmcuIG5vdGhpbmcsIHJlcHVibGlzaCwgcmVzdGFydCBtb2R1bGUsIHJlc3RhcnQgc2VydmVyKSA8L3RkPgotCQk8L3RyPgotCQkKLQkJPHRyPgotCQkJPHRkPkF1dG8gdXBkYXRlPC90ZD4KLQkJCTx0ZD4yPC90ZD4KLQkJCTx0ZD5BdXRvbWF0aWNhbGx5IG9yIHZpYSBhIHNpbmdsZSBjbGljaywgZG8gdGhlIGFib3ZlIHVzZSBjYXNlIHRvIGtlZXAgc2VydmVyIGluIHN5bmMgYXQgYWxsIHRpbWVzLjwvdGQ+Ci0JCTwvdHI+Ci0JCQotCQk8dHI+Ci0JCQk8dGQ+UnVuL0RlYnVnL1Byb2ZpbGUgb24gU2VydmVyPC90ZD4KLQkJCTx0ZD4xPC90ZD4KLQkJCTx0ZD5Gcm9tIGFueSBhcnRpZmFjdCAoVUkgc2VsZWN0aW9uLCBlZGl0b3IgaW5wdXQsIGV0Yy4pLCBkZXRlcm1pbmUgd2hpY2ggbW9kdWxlIGl0IGJlbG9uZ3MgdG8sIHByb21wdCB0byBjaG9vc2Ugb3IgY3JlYXRlIGEgc2VydmVyIGlmIG5lY2Vzc2FyeSwgcHVibGlzaC9zeW5jIHRoZSBtb2R1bGUgb24gdGhlIHNlcnZlciwgYW5kIGRpc3BsYXkgYW4KLQkJCSAgICBhcHByb3ByaWF0ZSBjbGllbnQgdG8gYWNjZXNzIChydW4pIHRoYXQgYXJ0aWZhY3Qgb24gdGhlIHNlcnZlci48L3RkPgotCQk8L3RyPgotCQkKLTwhLS0JCTx0cj4KLQkJCTx0ZD48L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPjwvdGQ+Ci0JCTwvdHI+LS0+Ci0KLQk8L3Rib2R5PgotPC90YWJsZT4KLTwvdGQ+PC90cj4KLQotPHRyPgotICAgIDx0ZCBjb2xzcGFuPSIyIiBhbGlnbj0ibGVmdCIgYmdjb2xvcj0iIzAwODBjMCIgdmFsaWduPSJ0b3AiPjxiPjxmb250IGNvbG9yPSIjZmZmZmZmIiBmYWNlPSJBcmlhbCxIZWx2ZXRpY2EiPkFQSSBVc2UgQ2FzZXM8L2ZvbnQ+PC9iPjwvdGQ+Ci0gIDwvdHI+Ci0KLQotPHRyPjx0ZD4KLSA8dGFibGUgd2lkdGg9Ijk1JSIgYm9yZGVyPSIxIiBjZWxscGFkZGluZz0iMSIgY2VsbHNwYWNpbmc9IjEiPgotCTx0Ym9keT4KLQkJPHRyPgotCQkJPHRoIHN0eWxlPSJ3aWR0aDogMTA4cHgiPk5hbWU8L3RoPgotCQkJPHRoIHN0eWxlPSJ3aWR0aDogNjBweCI+UHJpb3JpdHk8L3RoPgotCQkJPHRoIHN0eWxlPSJ3aWR0aDogMzYwcHgiPkRlc2NyaXB0aW9uPC90aD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+Q3JlYXRlIG1vZHVsZSB0eXBlKHMpPC90ZD4KLQkJCTx0ZD4xPC90ZD4KLQkJCTx0ZD5EZWZpbmUgYSBuZXcgdHlwZSBvZiBtb2R1bGUgKGludGVyZmFjZSBhbmQgaWQpIHNvIHRoYXQgb3RoZXIgU1BJIHByb3ZpZGVycyBjYW4gcHJvdmlkZSBpbnN0YW5jZXMgb2YgdGhlc2UgbW9kdWxlIG9yIHNlcnZlcnMgdGhhdCBzdXBwb3J0IHRoZW0uPC90ZD4KLQkJPC90cj4KLQotCQk8dHI+Ci0JCQk8dGQ+UHJvdmlkZSBtb2R1bGUgZmFjdG9yeTwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+RGVmaW5lIGEgbmV3IG1vZHVsZSBmYWN0b3J5IGZvciBjcmVhdGluZy9kaXNjb3ZlcmluZyB0aGUgbW9kdWxlcyBvZiBhbiBleGlzdGluZyB0eXBlLiAoLm1vZHVsZXMgZmlsZT8pPC90ZD4KLQkJPC90cj4KLQkJCi0JCTx0cj4KLQkJCTx0ZD5EZWZpbmUgcnVudGltZSB0eXBlPC90ZD4KLQkJCTx0ZD4xPC90ZD4KLQkJCTx0ZD5EZWZpbmUgYSBuZXcgcnVudGltZSB0eXBlLCBhbG9uZyB3aXRoIHRoZSBtb2R1bGUgdHlwZXMgdGhhdCBpdCBzdXBwb3J0cy4gRGVmaW5lIHdoYXQgaXQgbWVhbnMgdG8gdGFyZ2V0IGEgcHJvamVjdCB0byB0aGlzIHJ1bnRpbWUuPC90ZD4KLQkJPC90cj4KLQkJCi0JCTx0cj4KLQkJCTx0ZD5EZWZpbmUgc2VydmVyIHR5cGU8L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPkRlZmluZSBhIG5ldyBzZXJ2ZXIgdHlwZSwgYWxvbmcgd2l0aCB0aGUgbW9kdWxlIHR5cGVzIHRoaXMgaXQgc3VwcG9ydHMuIFByb3ZpZGUgaW1wbGVtZW50YXRpb25zIGZvciBhZGQvcmVtb3ZlIG1vZHVsZXMsIHB1Ymxpc2hpbmcsIHN0YXJ0L3N0b3AsIGV0Yy48L3RkPgotCQk8L3RyPgotCQkKLQkJPHRyPgotCQkJPHRkPmdldCBsaXN0IG9mIHNlcnZlciBhZGFwdGVyczwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+cHJvZ3JhbW1hdGljYWxseSBnZXQgbGlzdCBvZiBrbm93bgotCQkJSmFrYXJ0YS10b21jYXQgc2VydmVycyBhZGFwdGVycyBhbmQgdGhlaXIgYXNzb2NpYXRlZCBpbmZvcm1hdGlvbgotCQkJKG5hbWUsIHZlcnNpb24sIHdoZXRoZXIgaW5zdGFsbGVkIG9yIG5vdCwgZXRjKTwvdGQ+Ci0JCTwvdHI+Ci0JCTx0cj4KLQkJCTx0ZD5nZXQgbGlzdCBvZiBpbnN0YWxsZWQgc2VydmVyczwvdGQ+Ci0JCQk8dGQ+MTwvdGQ+Ci0JCQk8dGQ+cHJvZ3JhbW1hdGljYWxseSBnZXQgbGlzdCBvZiBpbnN0YWxsZWQKLQkJCXNlcnZlcnMgYW5kIHRoZWlyIGFzc29jaWF0ZWQgaW5mb3JtYXRpb24gKG5hbWUsIGV0Yyk8L3RkPgotCQk8L3RyPgotCQk8dHI+Ci0JCQk8dGQ+aW1wb3J0L2V4cG9ydCBzZXJ2ZXIgY29uZmlndXJhdGlvbjwvdGQ+Ci0JCQk8dGQ+MjwvdGQ+Ci0JCQk8dGQ+Q2FuIGltcG9ydCBvciBleHBvcnQgc2VydmVyIGNvbmZpZ3VyYXRpb24KLQkJCWZpbGVzLCBzdWNoIGFzIHRvIGdpdmUgdG8gYW5vdGhlciBtZW1iZXIgb2YgdGVhbS4gVGhpcyBmaWxlIG1heSBiZXN0Ci0JCQliZSBpbiBYTUwgZm9ybWF0LjwvdGQ+Ci0JCTwvdHI+Ci0JCTx0cj4KLQkJCTx0ZD5TZXJ2ZXIgUHJvdmlkZXJzIGNhbiBwcm92aWRlIGRpc2NvdmVyYWJsZSBhZGFwdGVyPC90ZD4KLQkJCTx0ZD4xIC0gU1BJPC90ZD4KLQkJCTx0ZD5UaGUgaW5mb3JtYXRpb24gbmVlZGVkIHRvIGJlIGxpc3RlZCBhcyBwb3RlbnRpYWwgc2VydmVyIGFkYXB0ZXIgY2FuIGJlIGZvdW5kIGNvbXBsZXRlbHkgaW4gcGx1Z2luLnhtbCAobm90IEphdmEgY29kZSwgd2hpY2ggd291bGQgcmVxdWlyZSBhY3RpdmF0aW9uIG9mIHBsdWdpbikuIDwvdGQ+Ci0JCTwvdHI+Ci0KLQkJPHRyPgotCQkJPHRkPlByb3ZpZGUgY2xhc3Nsb2FkZXIgYmVoYXZpb3I8L3RkPgotCQkJPHRkPjE8L3RkPgotCQkJPHRkPkEgY2xpZW50LCBhIGpzcC9lamIgY29tcGlsZXIgZm9yIGV4YW1wbGUsIGxlYXJucyB0aGUgY2xhc3Nsb2FkZXIgYmVoYXZpb3IgdG8gbWltaWMgdGhlIHNlcnZlciBydW50aW1lIGVudmlyb25tZW50PC90ZD4KLQkJPC90cj4KLQotCTwvdGJvZHk+Ci08L3RhYmxlPgotICA8L3RkPgotPC90cj4KLTwvdGJvZHk+PC90YWJsZT4KLQotCi08L2JvZHk+PC9odG1sPgpcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUKZGlmZiAtLWdpdCBhL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvc2VydmVyL1dUUCBTZXJ2ZXIgQ29yZSBBUElzLnBwdCBiL2RldmVsb3BtZW50L21pc2Nkb2N1bWVudHMvc2VydmVyL1dUUCBTZXJ2ZXIgQ29yZSBBUElzLnBwdApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggYmQ0NmYzYy4uMDAwMDAwMAotLS0gYS9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL3NlcnZlci9XVFAgU2VydmVyIENvcmUgQVBJcy5wcHQKKysrIC9kZXYvbnVsbApCaW5hcnkgZmlsZXMgZGlmZmVyCmRpZmYgLS1naXQgYS9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL3NlcnZlci93ZWJfdG9vbHNfc2VydmVyX2FwaV9jb25jZXB0cy5odG1sIGIvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy9zZXJ2ZXIvd2ViX3Rvb2xzX3NlcnZlcl9hcGlfY29uY2VwdHMuaHRtbApkZWxldGVkIGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggOGI0YjIzZi4uMDAwMDAwMAotLS0gYS9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL3NlcnZlci93ZWJfdG9vbHNfc2VydmVyX2FwaV9jb25jZXB0cy5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsMjYwICswLDAgQEAKLTxodG1sPgotCi08aGVhZD4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXdpbmRvd3MtMTI1MiI+Ci08bWV0YSBuYW1lPSJHRU5FUkFUT1IiIGNvbnRlbnQ9Ik1pY3Jvc29mdCBGcm9udFBhZ2UgNC4wIj4KLTxtZXRhIG5hbWU9IlByb2dJZCIgY29udGVudD0iRnJvbnRQYWdlLkVkaXRvci5Eb2N1bWVudCI+Ci08dGl0bGU+QVBJIENvbmNlcHRzIGFuZCBSb2xlczwvdGl0bGU+Ci08L2hlYWQ+Ci0KLTxib2R5PgotCi08aDE+V1RQIFNlcnZlciBUb29sczxicj4KLUFQSSBDb25jZXB0cyBhbmQgUm9sZXM8L2gxPgotPHA+TGFzdCBtb2RpZmllZCBOb3YuIDIsIDIwMDQ8L3A+Ci08cD5bPGk+VGhpcyBkb2N1bWVudCBpcyBhIHdvcmsgaW4gcHJvZ3Jlc3MuIFRoZSBkb2N1bWVudCBpcyBhbiBhdHRlbXB0IHRvCi1jYXB0dXJlIHRoZSBrZXkgY29uY2VwdHMgcmVxdWlyZWQgZm9yIHVuZGVyc3RhbmRpbmcgYW5kIHdvcmtpbmcgd2l0aCB0aGUgV1RQCi1TZXJ2ZXIgQ29yZSBBUEkuIE5vdGUgdGhhdCB0aGUgY29uY2VwdHMgbWF5IGRpZmZlciBzdWJ0bHkgZnJvbSB3aGF0IGlzIGN1cnJlbnRseQotZm91bmQgaW4gdGhlIGN1cnJlbnRseSByZWxlYXNlZCA8YSBocmVmPSJodHRwOi8vZGV2LmVjbGlwc2Uub3JnL3ZpZXdjdnMvaW5kZXguY2dpL3dzdC9jb21wb25lbnRzL3NlcnZlci9wbHVnaW5zL29yZy5lY2xpcHNlLndzdC5zZXJ2ZXIuY29yZS8/Y3Zzcm9vdD1XZWJUb29sc19Qcm9qZWN0Ij5vcmcuZWNsaXBzZS53c3Quc2VydmVyLmNvcmUKLXBsdWctaW48L2E+LiBPbmNlIHRoaXMgZG9jdW1lbnQgaXMgZmluYWxpemVkLCBvdXIgaW50ZW50IGlzIHRvIGJyaW5nIHRoZSBjb2RlCi1hbmQgc3BlY3MgaW50byBsaW5lIHdpdGggdGhpcyBkb2N1bWVudC5dPC9pPjwvcD4KLTxwPlRoZSBrZXkgY29uY2VwdHMgZm9yIHVuZGVyc3RhbmRpbmcgdGhlIEFQSSAoYW5kIFNQSSkgYXJlIHNlcnZlcnMgYW5kIG1vZHVsZXMuCi1UaGUgbm90aW9ucyBvZiBzZXJ2ZXIgcnVudGltZXMgYW5kIHNlcnZlciBjb25maWd1cmF0aW9ucyBwbGF5IGFuIGltcG9ydGFudCwgYnV0Ci1zZWNvbmRhcnkgcm9sZS48L3A+Ci08cD5Ob3Qgc3VycHJpc2luZ2x5LCB0aGUgbm90aW9uIG9mIDxiPnNlcnZlcjwvYj4gaXMgY2VudHJhbCBpbiB0aGUgd2ViIHRvb2xzCi1zZXJ2ZXIgaW5mcmFzdHJ1Y3R1cmUuIEluIHRoaXMgY29udGV4dCB3ZSBhcmUgdG8gdW5kZXJzdGFuZCB0aGF0IHRoZSBzZXJ2ZXIgaXMgYQotd2ViIHNlcnZlciBvZiBzb21lIGlsayAoYSBtb3JlIGV4YWN0IGRlZmluaXRpb24gaXMgbm90IHJlcXVpcmVkIGZvciBvdXIKLXB1cnBvc2VzKS4gRnJvbSBhIHRvb2wtY2VudHJpYyBwb2ludCBvZiB2aWV3LCBhIHNlcnZlciBpcyBzb21ldGhpbmcgdGhhdCB0aGUKLWRldmVsb3BlciBpcyB3cml0aW5nICZxdW90O2NvbnRlbnQmcXVvdDsgZm9yLiAoSW4gYSBzZW5zZSwgdGhlIHNlcnZlciBleGlzdHMsCi1idXQgbGFja3MgdXNlZnVsIGNvbnRlbnQuIFRoZSBkZXZlbG9wbWVudCB0YXNrIGlzIHRvIHByb3ZpZGUgdGhhdCBjb250ZW50LikgVGhlCi1jb250ZW50IGNhbiBpbmNsdWRlIGFueXRoaW5nIGZyb20gc2ltcGxlLCBzdGF0aWMgSFRNTCB3ZWIgcGFnZXMgdG8gY29tcGxleCwKLWhpZ2hseSBkeW5hbWljIHdlYiBhcHBsaWNhdGlvbnMuIEluIHRoZSBjb3Vyc2Ugb2Ygd3JpdGluZyBhbmQgZGVidWdnaW5nIHRoaXMKLWNvbnRlbnQsIHRoZXkgd2lsbCB3YW50IHRvIHRlc3QgdGhlaXIgY29udGVudCBvbiBhIHdlYiBzZXJ2ZXIsIHRvIHNlZSBob3cgaXQKLWdldHMgc2VydmVkIHVwLiBGb3IgdGhpcyB0aGV5IHdpbGwgbmVlZCB0byBsYXVuY2ggYSBzZXJ2ZXIgcHJvY2VzcyBydW5uaW5nIG9uCi1zb21lIGhvc3QgbWFjaGluZSAob2Z0ZW4gdGhlIGxvY2FsIGhvc3Qgb24gd2hpY2ggdGhlIEVjbGlwc2UgSURFIGlzIHJ1bm5pbmcpLCBvcgotYXR0YWNoIHRvIGEgc2VydmVyIHRoYXQncyBhbHJlYWR5IHJ1bm5pbmcuIEFuZCB3ZSBtdXN0IGFycmFuZ2UgdGhhdCB0aGUgbmV3bHkKLWRldmVsb3BlZCBjb250ZW50IHNpdHRpbmcgaW4gdGhlIGRldmVsb3BlcidzIHdvcmtzcGFjZSBlbmRzIHVwIGluIGEgbG9jYXRpb24gYW5kCi1mb3JtYXQgdGhhdCBhIHJ1bm5pbmcgc2VydmVyIGNhbiB1c2UgZm9yIGl0cyBzZXJ2aW5nIHB1cnBvc2VzLjwvcD4KLTxwPihUaGUgc2VydmVyIG9iamVjdHMgaW4gdGhlIEFQSSBhcmUgaW4gZmFjdCBpbnRlcm1lZGlhcnkgJnF1b3Q7cHJveHkmcXVvdDsKLW9iamVjdHMgdGhhdCBtZWRpYXRlIGJldHdlZW4gdGhlIHRvb2xzIHJ1bm5pbmcgaW4gRWNsaXBzZSBhbmQgdGhlIHJlYWwgc2VydmVyLiBBCi1zZXJ2ZXIgcHJveHkgb2JqZWN0IGhhcyBhIHNvbWV3aGF0IGluZGVwZW5kZW50IGxpZmUgZnJvbSB0aGF0IG9mIGEgcmVhbCBzZXJ2ZXIuCi1JbiBjYXNlcyB3aGVyZSB0aGUgc2VydmVyIHByb2Nlc3MgbXVzdCBiZSBsYXVuY2hlZCwgdGhlIHByb3h5IG9iamVjdCBleGlzdHMgaW4KLWFkdmFuY2Ugb2YgdGhlIHNlcnZlciBwcm9jZXNzLCBhbmQgbGl2ZXMgcGFzdCB0aGUgdGVybWluYXRpb24gb2YgdGhlIHNlcnZlcgotcHJvY2Vzcy4gVGhlIHNhbWUgc2VydmVyIHByb3h5IG1heSBiZSBzZXJpYWxseSByZXVzZWQgdG8gcmVsYXVuY2ggc2VydmVyCi1wcm9jZXNzZXMuIEluIGNhc2VzIHdoZXJlIHdlIGFyZSBjb25uZWN0aW5nIHRvIGEgc2VydmVyIHByb2Nlc3MgcnVubmluZyBvbiBhCi1yZW1vdGUgaG9zdCwgdGhlIHNlcnZlciBwcm9jZXNzIG1heSB3ZWxsIG91dGxpdmUgdGhlIHByb3h5Lik8L3A+Ci08cD5TZXJ2ZXJzIGhhdmUgYSA8Yj5zZXJ2ZXIgcnVudGltZTwvYj4uIFRoZSBzZXJ2ZXIgcnVudGltZSBjb3JyZXNwb25kcyB0byB0aGUKLWluc3RhbGxlZCBjb2RlIGJhc2UgZm9yIHRoZSBzZXJ2ZXIuIFRoZSBtYWluIHJvbGUgcGxheWVkIGJ5IHRoZSBzZXJ2ZXIgcnVudGltZQotaXMgaW4gaWRlbnRpZnlpbmcgY29kZSBsaWJyYXJpZXMgdG8gY29tcGlsZSBvciBidWlsZCBhZ2FpbnN0LiBJbiB0aGUgY2FzZSBvZgotbG9jYWwgc2VydmVycywgdGhlIHNlcnZlciBydW50aW1lIG1heSBwbGF5IGEgc2Vjb25kYXJ5IHJvbGUgb2YgYmVpbmcgdXNlZCB0bwotbGF1bmNoIHRoZSBzZXJ2ZXIgZm9yIHRlc3RpbmcuIEhhdmluZyB0aGUgc2VydmVyIHJ1bnRpbWVzIGlkZW50aWZpZWQgYXMgYW4KLWVudGl0eSBzZXBhcmF0ZSBmcm9tIHRoZSBzZXJ2ZXIgaXRzZWxmIGZhY2lsaXRhdGVzIHNoYXJpbmcgc2VydmVyIHJ1bnRpbWVzCi1iZXR3ZWVuIHNldmVyYWwgc2VydmVycy48L3A+Ci08cD5TZXJ2ZXJzIGhhdmUgYW4gb3B0aW9uYWwgPGI+c2VydmVyIGNvbmZpZ3VyYXRpb248L2I+LiBUaGUgc2VydmVyCi1jb25maWd1cmF0aW9uIGlzIGluZm9ybWF0aW9uIHVzZWQgdG8gY29uZmlndXJlIGEgcnVubmluZyBzZXJ2ZXIuIFNpbXBsZSB0eXBlcyBvZgotc2VydmVycyBtaWdodCBub3QgcmVxdWlyZSBhbnkgY29uZmlndXJhdGlvbiwgd2hlcmVhcyBmdWxsLWZlYXR1cmVkIHdlYiBzZXJ2ZXIKLWhhdmUgYW4gZXh0ZW5zaXZlIHNldCBvZiBwYXJhbWV0ZXJzIGZvciBhZGp1c3RpbmcgdGhlIHNlcnZlcidzIGJlaGF2aW9yLiBFdmVuCi10aG91Z2ggc2VydmVyIGNvbmZpZ3VyYXRpb24gaW5mb3JtYXRpb24gdXN1YWxseSB0YWtlcyB0aGUgZm9ybSBvZiBvbmUgb3IgbW9yZQotZmlsZXMsIGNvbmZpZ3VyYXRpb24gaW5mb3JtYXRpb24gaXMgdHJlYXRlZCBzZXBhcmF0ZWx5IGZyb20gYWN0dWFsIGNvbnRlbnQuCi1BY3R1YWwgd2ViIGNvbnRlbnQgY2FuIGJlIGRlcGxveWVkIG9uIGRpZmZlcmVudCBzZXJ2ZXJzIHdpdGhvdXQgY2hhbmdlLCB3aGVyZWFzCi1zZXJ2ZXIgY29uZmlndXJhdGlvbiBpbmZvcm1hdGlvbiBpcyB1c3VhbGx5IGhpZ2hseSBkZXBlbmRlbnQgb24gdGhlIHBhcnRpY3VsYXJzCi1vZiB0aGUgc2VydmVyLiBIYXZpbmcgdGhlIHNlcnZlciBjb25maWd1cmF0aW9uIGlkZW50aWZpZWQgYXMgYW4gZW50aXR5IHNlcGFyYXRlCi1mcm9tIHRoZSBzZXJ2ZXIgaXRzZWxmIGZhY2lsaXRhdGVzIHN3aXRjaGluZyBhbiBleGlzdGluZyBzZXJ2ZXIgYmV0d2VlbgotY29uZmlndXJhdGlvbnMsIGFuZCBzaGFyaW5nIHNlcnZlciBjb25maWd1cmF0aW9ucyBiZXR3ZWVuIHNldmVyYWwgc2VydmVycyAoZS5nLiwKLWEgbG9jYWwgdGVzdCBzZXJ2ZXIgYW5kIGEgcmVtb3RlIHNlcnZlciBydW5uaW5nIG9uIGFub3RoZXIgaG9zdCkuPC9wPgotPHA+VGhlIHdlYiBjb250ZW50IHRoYXQgaXMgZGV2ZWxvcGVkIGZvciBhIHdlYiBzZXJ2ZXIgY29tZXMgaW4gPGI+bW9kdWxlczwvYj4uIEEKLW1vZHVsZSB1c3VhbGx5IGNvbnNpc3RzIG9mIGEgdHJlZSBvZiBmaWxlczsgYSBzdGF0aWMgSFRNTCB3ZWIgaXMgb25lIHNpbXBsZQotZXhhbXBsZS4gRGlmZmVyZW50IHR5cGVzIG9mIG1vZHVsZXMgY29uc2lzdCBvZiBwb3NzaWJseSBjb25zdHJhaW5lZCBhcnJhbmdlbWVudHMKLWZpbGVzIG9mIGNlcnRhaW4gZmlsZSB0eXBlcy4gVGhlIGZpbGVzIG1ha2luZyB1cCBhIG1vZHVsZSB1bmRlciBkZXZlbG9wbWVudAotcmVzaWRlIGluIHRoZSBFY2xpcHNlIHdvcmtzcGFjZS4gSW4gb3JkZXIgZm9yIGEgc2VydmVyIHRvIHVzZSBhY2Nlc3MgdGhlIGNvbnRlbnQKLXdpdGhpbiBhIG1vZHVsZSwgdGhlIG1vZHVsZSBpbiB0aGUgd29ya3NwYWNlIG11c3QgYmUgPGI+cHVibGlzaGVkIDwvYj50byB0aGUKLXNlcnZlciAod2UgdXNlIHRoZSB0ZXJtJm5ic3A7IDxpPnB1Ymxpc2g8L2k+IHJhdGhlciB0aGFuIDxpPmRlcGxveTwvaT4gd2hpY2ggaXMKLW92ZXJ1c2VkIGluIEoyRUUpLiBUaGUgbW9kdWxlIGlzIHRoZSB1bml0IG9mIGNvbnRlbnQgdGhhdCBpcyBwdWJsaXNoZWQgdG8gYQotc2VydmVyLiBJbiB0aGUgY2FzZSBvZiBKMkVFIHNlcnZlcnMsIHRoZSBub3Rpb24gb2YgbW9kdWxlIGFsaWducyB3aXRoIHRoZSBKMkVFCi1ub3Rpb24gb2YgYSBtb2R1bGUgKGEgc2VydmVyIGNvbmNlcHQpLiZuYnNwOyBCdXQgdGhhdCBuZWVkbid0IGJlIHRoZSBjYXNlOyBzb21lCi10eXBlcyBvZiBzZXJ2ZXJzLCBzdWNoIGFzIGEgc2ltcGxlIEhUVFAgc2VydmVyLCBkb24ndCBoYXZlIGEgbm90aW9uIG9mIG1vZHVsZS4KLUVpdGhlciB3YXksIHB1Ymxpc2hpbmcgYSBtb2R1bGUgdG8gdGhlIHNlcnZlciBlbnRhaWxzIHdoYXRldmVyIGl0IHRha2VzIHRvIGdldAotdGhlIHB1Ymxpc2hhYmxlIGNvbnRlbnQgZnJvbSB0aGUgd29ya3NwYWNlIHRvIHRoZSBzZXJ2ZXIgaW4gYSBmb3JtIHRoYXQgdGhlCi1zZXJ2ZXIgY2FuIGFjY2VzcyBpdC4gRGlmZmVyZW50IHR5cGVzIG9mIHNlcnZlciBydW50aW1lcyBhcmUgY2FwYWJsZSBvZiBzdXBwb3J0Ci12YXJpb3VzIG1vZHVsZSB0eXBlcy48L3A+Ci08cD5BdCBhbnkgZ2l2ZW4gdGltZSwgdGhlIGRldmVsb3BlciBtYXkgYmUgd29ya2luZyB3aXRoIGFueSBudW1iZXIgb2Ygc2VydmVycy4KLUVhY2ggc2VydmVyIGhhcyBhIHNlcnZlciBjb25maWd1cmF0aW9uIGFuZCBhIHNldCBvZiBtb2R1bGVzLiBGcm9tIHRoZSBjb21wbGV0ZQotc2V0IG9mIG1vZHVsZXMgaW4gdGhlIHdvcmtzcGFjZSwgYW55IHBhcnRpY3VsYXIgc2VydmVyIG1heSBzZWUgb25seSBhIHN1YnNldCwKLWFsdGhvdWdoIGl0IGlzIGFsc28gY29tbW9uIGZvciBhbGwgc2VydmVycyB0byBzZWUgYWxsIGF2YWlsYWJsZSBtb2R1bGVzLiBBZnRlcgotdGhlIGRldmVsb3BlciBtYWtlcyBjaGFuZ2VzIHRvIHRoZSBtb2R1bGVzIGluIHRoZSB3b3Jrc3BhY2UgYW5kIG5vdyB3YW50cyB0bwotdGVzdCB0aGVpciBtb2RpZmljYXRpb24sIHRoZXkgcmVwdWJsaXNoIHRoZSBtb2R1bGVzIHRvIHRoZSBzZXJ2ZXIuIERlcGVuZGluZyBvbgotdGhlIHR5cGUgb2Ygc2VydmVyLCByZXB1Ymxpc2hpbmcgYSBtb2R1bGUgbWF5IGVudGFpbCBzdG9wcGluZyBhbmQgcmVzdGFydGluZyB0aGUKLXNlcnZlci48L3A+Ci08cD5Tb21lIHR5cGVzIG9mIG1vZHVsZXMgY2FuIGhhdmUgb3RoZXIgbW9kdWxlcyBhcyBjaGlsZHJlbi4gVGhlIHN0YW5kYXJkCi1leGFtcGxlIG9mIHRoaXMgaXMgYSBKMkVFIEVudGVycHJpc2UgQXBwbGljYXRpb24gKEVBKSBtb2R1bGUsIHdob3NlIGNoaWxkcmVuIGFyZQotc2ltcGxlIEoyRUUgbW9kdWxlcyBsaWtlIEVudGVycHJpc2UgSmF2YSBCZWFucyBhbmQgV2ViIEFwcGxpY2F0aW9ucy4gVGhlCi1wYXJlbnQtY2hpbGQgcmVsYXRpb25zaGlwIGlzIHdlYWs6IHR3byBwYXJlbnQgbW9kdWxlcyBjYW4gc2hhcmUgdGhlIHNhbWUgY2hpbGQKLW1vZHVsZSwgYW5kIHRoZSBzYW1lIGNoaWxkIGNhbiBiZSBwYXJlbnRlZCBieSBzZXZlcmFsIG1vZHVsZXMgKG9uIHRoZSBzYW1lIG9yIG9uCi1kaWZmZXJlbnQgc2VydmVycykuIFRoZSBmaWxlIHRyZWVzIGZvciBtb2R1bGVzIGFyZSBub3JtYWxseSBtdXR1YWxseSBkaXNqb2ludC4KLU1vZHVsZSBjb250YWlubWVudCBpcyBub3QgcmVmbGVjdGVkIGJ5IGFueSBzb3J0IG9mIGRpcmVjdG9yeSBuZXN0aW5nLiBQYXJlbnQgYW5kCi1jaGlsZCBtb2R1bGVzIG1hcCB0byBub24tb3ZlcmxhcHBpbmcgZmlsZSB0cmVlcy48L3A+Ci08cD5Nb2R1bGVzIHJlc2lkZSBpbiB0aGUgd29ya3NwYWNlLiBUaGUgdHlwaWNhbCBhcnJhbmdlbWVudCBpcyB0aGF0IGVhY2ggbW9kdWxlCi1oYXMgaXRzIG93biBwcm9qZWN0LCB0ZXJtZWQgYSA8Yj5tb2R1bGUgcHJvamVjdDwvYj4uIFRoZSBtb2R1bGUgY29udGVudCB1c3VhbGx5Ci1jb3JyZXNwb25kcyB0byBhIHBhcnRpY3VsYXIgZm9sZGVyIHdpdGhpbiBhIHByb2plY3QgcmF0aGVyIHRoYW4gdGhlIHJvb3Qgb2YgdGhlCi1wcm9qZWN0OyB0aGlzIGFsbG93cyB0aGUgcHJvamVjdCB0byBjb250YWluIG90aGVyIGZpbGVzIChlLmcuLCAucHJvamVjdCwgLmNsYXNzcGF0aCwKLXNvdXJjZSBjb2RlKSB0aGF0IGFyZSBub3QgY29uc2lkZXJlZCBwYXJ0IG9mIHRoZSBtb2R1bGUgY29udGVudCBwcm9wZXIuIEVhY2gKLWRpZmZlcmVudCB0eXBlIG9mIG1vZHVsZSBoYXMgaXRzIG93biBydWxlcyBmb3IgaG93IHRoZSBjb250ZW50IGZpbGVzIHdpdGhpbiBpdAotYXJlIGxhaWQgb3V0LiBGb3IgaW5zdGFuY2UsIGEgSjJFRSB3ZWIgbW9kdWxlIGhhcyB0aGUgc2FtZSBzdHJ1Y3R1cmUgYXMgYW4KLXVuemlwcGVkIFdBUiBmaWxlLiAoTm90ZSB0aGF0IHRoZSBtb2R1bGUgc3RydWN0dXJlIHJ1bGVzIGFyZSBsYXJnZWx5IGltcGxpY2l0Ci1hbmQgbm90IHJlZmxlY3RlZCBkaXJlY3RseSBpbiB0aGUgQVBJcy4pIEl0IGlzIHBvc3NpYmxlIGZvciBhIHByb2plY3QgdG8KLWNvbnRhaW5zIG1vcmUgdGhhbiBvbmUgbW9kdWxlIChhbHRob3VnaCB0aGlzIGFycmFuZ2VtZW50IGlzIGxlc3MgY29tbW9uLCBhbmQgbm90Ci1hcyB3ZWxsIHN1cHBvcnRlZCkuPC9wPgotPHA+RHVyaW5nIGRldmVsb3BtZW50LCBwcm9qZWN0cyBjb250YWluaW5nIG1vZHVsZXMgY2FuIGJlIDxiPnRhcmdldGVkPC9iPiB0byBhCi1wYXJ0aWN1bGFyIHNlcnZlciBydW50aW1lLiBUYXJnZXRpbmcgYWxsb3dzIHRoZSBJREUgdG8gc2V0IHVwIHZhcmlvdXMKLWRldmVsb3BtZW50IHRpbWUgcHJvcGVydGllcyBvZiB0aGUgcHJvamVjdCAoc3VjaCBhcyB0aGUgYmFja2JvbmUgb2YgdGhlIEphdmEKLWJ1aWxkIHBhdGgpIGFwcHJvcHJpYXRlbHkuIFRoZSBtb3N0IGNvbW1vbiBzY2VuYXJpbyBpcyB3aGVyZSB0aGUgcHJvamVjdCBpcwotdGFyZ2V0ZWQgdG8gdGhlIHNlcnZlciBydW50aW1lIGZvciB0aGUgc2VydmVyIHRvIHdoaWNoIHRoZSBtb2R1bGUgaXMgYmVpbmcKLXB1Ymxpc2hlZC4gSG93ZXZlciwgaXQgaXMgYWxzbyBwb3NzaWJsZSB0byB0YXJnZXQgb25lIHNlcnZlciBydW50aW1lIChlLmcuLCBhCi1nZW5lcmljIEoyRUUgMS4zIHNlcnZlciBydW50aW1lKSB3aGlsZSBwdWJsaXNoaW5nIHRvIGEgc2VydmVyIHdpdGggYSBkaWZmZXJlbnQKLXNlcnZlciBydW50aW1lIChlLmcuLCBhIFRvbWNhdCB2NS4wIHNlcnZlcikuIFRhcmdldGluZyBhIHByb2plY3QgdG8gYSBwYXJ0aWN1bGFyCi1zZXJ2ZXIgcnVudGltZSB0eXBpY2FsbHkgZXN0YWJsaXNoZXMgdGhlIEphdmEgYnVpbGQgY2xhc3NwYXRoIG9mIHRoZSBwcm9qZWN0IHRvCi1pbmNsdWRlIHRoZSBsaWJyYXJpZXMgY29udGFpbmluZyB0aGUgSmF2YSBBUElzIGZvciB0aGF0IHNlcnZlciBydW50aW1lIChlLmcuLAotdGhlIGFwcHJvcHJpYXRlIEoyRUUgY2xhc3MgbGlicmFyaWVzKS4gVGhlIEphdmEgYnVpbGQgY2xhc3NwYXRoIGFsc28gbmVlZHMgdG8KLXJlZmxlY3QgaW50ZXItbW9kdWxlIGRlcGVuZGVuY2llczsgZm9yIEoyRUUgbW9kdWxlIHR5cGVzLCB0aGUgYXBwcm9wcmlhdGUKLWVudHJpZXMgYXJlIHR5cGljYWxseSBkZXJpdmVkIGZyb20gdGhlIG1vZHVsZSdzIG1hbmlmZXN0LjwvcD4KLTxwPkEgPGI+c2VydmVyIHByb2plY3Q8L2I+IGlzIGEgcHJvamVjdCB1c2VkIHRvIGhvbGQgc2VyaWFsaXplZCBzZXJ2ZXIgKHNlcnZlcgotcnVudGltZSwgc2VydmVyIGNvbmZpZ3VyYXRpb24pIGluc3RhbmNlcy4gVGhlIHByb2plY3QgaXMgdGFnZ2VkIHdpdGggYSBzcGVjaWFsCi1FY2xpcHNlIHNlcnZlciBuYXR1cmUuIFRoZSBtYWluIHJlYXNvbiBiZWhpbmQgc2VydmVyIHByb2plY3RzIHdhcyBhcyBhbgotZWZmaWNpZW50IG1lYW5zIG9mIG1ha2luZyB0aGVzZSBzZXJpYWxpemVkIGZpbGVzIHZpc2libGUgaW4gdGhlIHJlc291cmNlCi1uYXZpZ2F0b3IgYW5kIG1vbml0b3JpbmcgY2hhbmdlcyB0byB0aGVtLjwvcD4KLTxwPlRoZSBtYWluIGdvYWxzIG9mIHRoZSBTZXJ2ZXIgQ29yZSBjbGllbnQgQVBJcyBhcmUgdG8gYWxsb3cgY2xpZW50cyB0byBjcmVhdGUsCi1jb25maWd1cmUsIGFuZCBsYXVuY2ggaW5zdGFuY2VzIG9mIHBhcnRpY3VsYXIgc2VydmVyIHR5cGVzLiBEdWUgdG8gZGlmZmVyZW5jZXMKLWluIHRoZSBiZWhhdmlvciAoYW5kIEFQSXMpIG9mIGRpZmZlcmVudCBzZXJ2ZXIgdHlwZXMsIGEgY2xpZW50IG11c3QgZ2VuZXJhbGx5IGJlCi1rbm93bGVkZ2VhYmxlIG9mIHJ1bGVzIGZvciBhIHBhcnRpY3VsYXIgc2VydmVyIHR5cGUuIENsaWVudHMgdGhhdCBoYXZlIG5vCi1rbm93bGVkZ2Ugb2YgYW55IHNwZWNpZmljIHNlcnZlciB0eXBlIGFyZSBsaW1pdGVkIHRvIGRvaW5nIHRoaW5ncyBsaWtlIHN0YXJ0aW5nLAotc3RvcHBpbmcsIGFuZCByZWxhdW5jaGluZyBleGlzdGluZyBzZXJ2ZXJzLiBJbiBvdGhlciB3b3JkcywgdGhlIGNsaWVudHMgQVBJcyBhcmUKLWdlbmVyYWxseSBzZXJ2ZXItdHlwZS1zcGVjaWZpYywgcmF0aGVyIHRoYW4gc2V2ZXItdHlwZS1nZW5lcmljLjwvcD4KLTxwPlRoZSB3ZWIgdG9vbHMgc2VydmVyIGFyY2hpdGVjdHVyZSBhbGxvd3MgZm9yIGFuIG9wZW4tZW5kZWQgc2V0IG9mIHNlcnZlcgotdHlwZXMsIHNlcnZlciBydW50aW1lIHR5cGVzLCBzZXJ2ZXIgY29uZmlndXJhdGlvbiB0eXBlcywgYW5kIG1vZHVsZSB0eXBlcy4gTmV3Ci10eXBlcyBhcmUgZGVjbGFyZWQgdmlhIGV4dGVuc2lvbiBwb2ludHMgaW4gdGhlIFNlcnZlciBDb3JlIHBsdWctaW4gKG9yZy5lY2xpcHNlLnd0cC5zZXJ2ZXIuY29yZSkuCi1TZXJ2ZXIgdHlwZXMgYXJlIGRlY2xhcmVkIGJ5IHRoZSBzZXJ2ZXJUeXBlcyBleHRlbnNpb24gcG9pbnQ7IHNlcnZlciBydW50aW1lCi10eXBlcywgYnkgcnVudGltZVR5cGVzOyBzZXJ2ZXIgY29uZmlndXJhdGlvbiB0eXBlcywgYnkgc2VydmVyQ29uZmlndXJhdGlvblR5cGVzOwotYW5kIG1vZHVsZSB0eXBlcywgYnkgbW9kdWxlS2luZHMuIChBZGRpdGlvbmFsIGV4dGVuc2lvbiBwb2ludHMgYXJlIGRpc2N1c3NlZAotYmVsb3cuKSBBc3NvY2lhdGVkIHdpdGggdGhlc2UgZXh0ZW5zaW9uIHBvaW50cyBhcmUgY29kZSBBUElzIGRlc2lnbmVkIGZvciB1c2UgYnkKLWNsaWVudHMgY29udHJpYnV0aW5nIHRvIHRoZSBTZXJ2ZXIgQ29yZSBleHRlbnNpb24gcG9pbnRzOyB0aGVzZSBhcmUgbW9yZQotY29ycmVjdGx5IGNhbGxlZCBTUElzIChzZXJ2aWNlIHByb3ZpZGVyIGludGVyZmFjZXMpIHRvIGRpc3Rpbmd1aXNoIHRoZW0gZnJvbSB0aGUKLWNvZGUgZGVzaWduZWQgdG8gYmUgdXNlZCBieSBvdGhlciBjbGllbnRzICh3aGljaCB3ZSByZWZlciB0byBoZXJlIGFzIGNsaWVudAotQVBJcykuPC9wPgotPHA+TWFueSBvZiB0aGUgZXh0ZW5zaW9uIHBvaW50cyBwcm92aWRlIGZvciBhIGR5bmFtaWMgY29kZSBjb21wb25lbnQgaW4gYWRkaXRpb24KLXRvIHRoZSBzdGF0aWMgaW5mb3JtYXRpb24gc3VwcGxpZWQgaW4gdGhlIGV4dGVuc2lvbiBkZWNsYXJhdGlvbi4gVGhlc2UgYXJlCi10ZXJtZWQgPGk+ZGVsZWdhdGVzPC9pPi4gRm9yIGluc3RhbmNlLCBhbGwgY29tbXVuaWNhdGlvbiB3aXRoIHRoZSBydW5uaW5nIHNlcnZlcgotaXMgaGFuZGxlZCBieSBhIDxiPnNlcnZlciBkZWxlZ2F0ZTwvYj4gY29udHJpYnV0ZWQgdmlhIHRoZSBzZXJ2ZXIgdHlwZSBleHRlbnNpb24KLXBvaW50LiBDbGllbnRzIGdlbmVyYWxseSBkZWFsIGRpcmVjdGx5IHdpdGggYSBsYXllciBvZiBvYmplY3RzIGV4cG9zZWQgYnkgdGhlCi1BUEkgZXhwcmVzc2x5IGZvciBjbGllbnQgdXNlLiBJbiB0aGUgY2FzZSBvZiBzZXJ2ZXIsIGNsaWVudHMgZGVhbCB3aXRoIGFuCi1JU2VydmVyLiBJU2VydmVyIGhhcyBhIGZpeGVkLCBoaWRkZW4gaW1wbGVtZW50YXRpb24gKHRoZSBpbnRlcm5hbCBjbGFzcyBTZXJ2ZXIpLAotd2hpY2ggaGFuZ3Mgb24gdG8gYSBsYXppbHktY3JlYXRlZCBzZXJ2ZXIgZGVsZWdhdGUgb2YgdHlwZSBJU2VydmVyRGVsZWdhdGUuIFRoZQotSVNlcnZlckRlbGVnYXRlIGltcGxlbWVudGF0aW9uIGlzIGEgc2VydmVyLXR5cGUtc3BlY2lmaWMgb2JqZWN0LiBUaGUgbW9yZQotaW50ZXJlc3RpbmcgSVNlcnZlciBtZXRob2RzIChlLmcuLCBnZXRTZXJ2ZXJTdGF0ZSgpKSBhcmUgaGFuZGxlZCBieSB0aGUKLWRlbGVnYXRlLiBUaGVyZSBhcmUgYWxzbyBnZXREZWxlZ2F0ZSgpIG1ldGhvZHMgdGhhdCBicmlkZ2UgQVBJIHRvIFNQSSwgYWxsb3dpbmcKLWNsaWVudHMgdG8gY2FsbCBtZXRob2RzIG9uIHRoZSBkZWxlZ2F0ZSBkaXJlY3RseS4gU2VydmljZSBwcm92aWRlcnMgbWF5IGFsc28KLWNob29zZSB0byBleHBvc2UgdGhlaXIgZGVsZWdhdGUgaW1wbGVtZW50YXRpb24gYXMgQVBJLiBUaGlzIGFsbG93cywgZm9yIGV4YW1wbGUsCi10aGUgcHJvdmlkZXIgb2YgYSBzZXJ2ZXIgdHlwZSB0byBvZmZlciBhZGRpdGlvbmFsIEFQSSB0aGF0IGlzCi1zZXJ2ZXItdHlwZS1zcGVjaWZpYy48L3A+Ci08cD5BIDxiPm1vZHVsZSBmYWN0b3J5PC9iPiBpcyByZXNwb25zaWJsZSBmb3IgY3JlYXRpbmcgbW9kdWxlcy4gVGhlcmUgY2FuIGJlIGFueQotbnVtYmVyIG9mIHJlZ2lzdGVyZWQgbW9kdWxlIGZhY3RvcmllcywgZGVjbGFyZWQgdmlhIHRoZQotb3JnLmVjbGlwc2Uud3RwLnNlcnZlci5jb3JlLm1vZHVsZUZhY3RvcnkgZXh0ZW5zaW9uIHBvaW50LiBBIG1vZHVsZSBmYWN0b3J5IG1heQotY3JlYXRlIG9uZSBvciBtb3JlIHR5cGVzIG9mIG1vZHVsZXMgKGFsc28gZGVjbGFyZWQgaW4gdGhlIGV4dGVuc2lvbiBwb2ludCkuIFRoZQotbW9kdWxlIGZhY3RvcnkgQVBJIGRvZXMgbm90IHByZXNjcmliZSBhIHdheSB0byBjcmVhdGUgbW9kdWxlczsgaXQgZG9lcywgaG93ZXZlciwKLXByb3ZpZGUgbWV0aG9kcyBmb3IgcmV0cmlldmluZyBleHRhbnQgbW9kdWxlcyB0aGF0IGl0IHdhcyByZXNwb25zaWJsZSBmb3IKLWNyZWF0aW5nIChJTW9kdWxlRmFjdG9yeURlbGVnYXRlLmdldE1vZHVsZXMoKSBhbmQKLUlNb2R1bGVGYWN0b3J5RGVsZWdhdGUuZ2V0TW9kdWxlKFN0cmluZyBtZW1lbnRvKSkuPC9wPgotPHA+QSA8Yj5wdWJsaXNoIG1hbmFnZXI8L2I+IGlzIHJlc3BvbnNpYmxlIGZvciBkZWNpZGluZyB3aGV0aGVyIGEgZmlsZSByZXNvdXJjZQotd2lsbCBiZSBwdWJsaXNoZWQgb3Igbm90IChub3RlOiBwdWJsaXNoaW5nIGluY2x1ZGVzIGZpbGUgZGVsZXRpb25zIGFzIHdlbGwgYXMKLWZpbGUgY3JlYXRpb25zIGFuZCBtb2RpZmljYXRpb25zKS4gUHVibGlzaCBtYW5hZ2VycyBhcmUgZGVjbGFyZWQgdmlhIHRoZQotb3JnLmVjbGlwc2Uud3RwLnNlcnZlci5jb3JlLnB1Ymxpc2ggZXh0ZW5zaW9uIHBvaW50LgotU2VydmVyQ29yZS5nZXRQdWJsaXNoTWFuYWdlcnMoKSByZXR1cm5zIGxpc3Qgb2Yga25vdyBwdWJsaXNoIG1hbmFnZXJzLiBUaGVyZSBhcmUKLXR3byBidWlsZC1pbiBoZWFkbGVzcyBwdWJsaXNoIG1hbmFnZXJzLiBUaGUgRnVsbCBQdWJsaXNoIE1hbmFnZXIgaXMgZHVtYiwgYW5kCi1wdWJsaXNoZXMgYWxsIG9mIHRoZSBtb2R1bGUncyByZXNvdXJjZSBmcm9tIHdvcmtzcGFjZSB0byBzZXJ2ZXIuIFRoZSBTbWFydAotUHVibGlzaCBNYW5hZ2VyIG9ubHkgcHVibGlzaGVzIG1vZHVsZSByZXNvdXJjZXMgdGhhdCBoYXZlIGJlZW4gY3JlYXRlZCwgY2hhbmdlZCwKLW9yIGRlbGV0ZWQgaW4gdGhlIHdvcmtzcGFjZSwgb3Igb25lcyB0aGF0IGhhdmUgYmVlbiBjaGFuZ2VkIChzb21laG93KSBvbiB0aGUKLXNlcnZlci4gQSBwdWJsaXNoIG9wZXJhdGlvbiBpbml0aWF0ZWQgYnkgSVNlcnZlci5wdWJsaXNoKElQcm9ncmVzc01vbml0b3IKLW1vbml0b3IpIHVzZXMgdGhlIHN5c3RlbS13aWRlIGRlZmF1bHQgcHVibGlzaCBtYW5hZ2VyLCB3aGljaCBkZWZhdWx0cyB0byB0aGUKLVNtYXJ0IFB1Ymxpc2ggTWFuYWdlci4gKFRoZXJlJ3MgYWxzbyBhIFZpc3VhbCBQdWJsaXNoIE1hbmFnZXIgdGhhdCBsZXRzIHRoZSB1c2VyCi1waWNrIGFuZCBjaG9vc2Ugd2hpY2ggZmlsZXMgdG8gcHVibGlzaC4pPC9wPgotPHA+QSA8Yj5wdWJsaXNoZXI8L2I+IChJUHVibGlzaGVyKSBpcyBhbiBvYmplY3QgdGhhdCBhY3R1YWxseSBwdWJsaXNoZXMgdGhlIGZpbGUKLW9mIGEgcGFydGljdWxhciBtb2R1bGUgdG8gYSBwYXJ0aWN1bGFyIHNlcnZlci4gRWFjaCBzZXJ2ZXIgdHlwZSBpbXBsZW1lbnRzIGl0cwotb3duIHB1Ymxpc2hlcnMuIE9uIGEgcGFydGljdWxhciBvY2Nhc2lvbiwgdGhlIElTZXJ2ZXJEZWxlZ2F0ZS5nZXRQdWJsaXNoZXIoTGlzdAotcGFyZW50cywgSU1vZHVsZSBtb2R1bGUpIHJldHVybnMgdGhlIHB1Ymxpc2hlciB0byB1c2UgdG8gcHVibGlzaCB0aGUgZmlsZXMgb2YKLXRoZSBnaXZlbiBtb2R1bGUuIElQdWJsaXNoZXIucHVibGlzaChJTW9kdWxlUmVzb3VyY2VbXSByZXNvdXJjZSwKLUlQcm9ncmVzc01vbml0b3IgbW9uaXRvcikgYW5kIElQdWJsaXNoZXIuZGVsZXRlKElSZW1vdGVSZXNvdXJjZVtdIHJlc291cmNlLAotSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSBkbyB0aGUgaGVhdnkgbGlmdGluZy48L3A+Ci08cD5UaGUgY2xpZW50IEFQSSBleHBvc2VzOjwvcD4KLTx1bD4KLSAgPGxpPlNlcnZlciBydW50aW1lIHR5cGVzIGFzIElSdW50aW1lVHlwZS4gU2VydmVyQ29yZS5nZXRSdW50aW1lVHlwZXMoKSByZXR1cm5zCi0gICAgYWxsIGtub3duIHNlcnZlciBydW50aW1lIHR5cGVzLjwvbGk+Ci0gIDxsaT5TZXJ2ZXIgdHlwZXMgYXMgSVNlcnZlclR5cGUuIFNlcnZlckNvcmUuZ2V0U2VydmVyVHlwZXMoKSByZXR1cm5zIGFsbCBrbm93bgotICAgIHNlcnZlciB0eXBlcy4mbmJzcDs8L2xpPgotICA8bGk+U2VydmVyIGNvbmZpZ3VyYXRpb24gdHlwZXMgYXMgSVNlcnZlckNvbmZpZ3VyYXRpb25UeXBlLgotICAgIFNlcnZlckNvcmUuZ2V0U2VydmVyQ29uZmlndXJhdGlvblR5cGVzKCkgcmV0dXJucyBhbGwga25vd24gc2VydmVyCi0gICAgY29uZmlndXJhdGlvbiB0eXBlcy48L2xpPgotICA8bGk+TW9kdWxlIHR5cGVzIGFzIElNb2R1bGVLaW5kLiBTZXJ2ZXJDb3JlLmdldE1vZHVsZUtpbmRzKCkgcmV0dXJucyBhbGwga25vd24KLSAgICBtb2R1bGUga2luZHMuPC9saT4KLTwvdWw+Ci08cD5UaGUgdHlwZS1sZXZlbCByZWxhdGlvbnNoaXBzIGFyZTo8L3A+Ci08dWw+Ci0gIDxsaT5hIHNlcnZlciB0eXBlIGhhcyBhIHNlcnZlciBydW50aW1lIHR5cGU7IHRoaXMgaXMgdGhlIHR5cGUgb2Ygc2VydmVyCi0gICAgcnVudGltZSByZXF1aXJlZCB0byBydW4gdGhlIHNlcnZlcjsgZXhwb3NlZCBhcyBJU2VydmVyVHlwZS5nZXRSdW50aW1lVHlwZSgpPC9saT4KLSAgPGxpPmEgc2VydmVyIHR5cGUgaGFzIGFuIG9wdGlvbmFsIHNlcnZlciBjb25maWd1cmF0aW9uIHR5cGU7IHRoaXMgaXMgdGhlIHR5cGUKLSAgICBvZiBzZXJ2ZXIgY29uZmlndXJhdGlvbiByZXF1aXJlZCB0byBjb25maWd1cmUgdGhlIHNlcnZlcjsgZXhwb3NlZCBhcwotICAgIElTZXJ2ZXJUeXBlLmdldFNlcnZlckNvbmZpZ3VyYXRpb25UeXBlKCk8L2xpPgotICA8bGk+YSBzZXJ2ZXIgcnVudGltZSB0eXBlIHN1cHBvcnRzIDAgb3IgbW9yZSBtb2R1bGUgdHlwZXM7IGV4cG9zZWQgYXMKLSAgICBJUnVudGltZVR5cGUuZ2V0TW9kdWxlVHlwZXMoKTwvbGk+Ci08L3VsPgotPHA+VGhlIEFQSSBleHBvc2VzIHNlcnZlciBydW50aW1lIGluc3RhbmNlcyBhcyBJUnVudGltZS4mbmJzcDsKLVNlcnZlckNvcmUuZ2V0UmVzb3VyY2VNYW5hZ2VyKCkuZ2V0UnVudGltZXMoKSByZXR1cm5zIGFsbCBrbm93biBzZXJ2ZXIgcnVudGltZQotaW5zdGFuY2VzLiBTZXJ2ZXIgcnVudGltZSBpbnN0YW5jZXMgYXJlIGNyZWF0ZWQgKG9ubHkpIGZyb20gc2VydmVyIHJ1bnRpbWUgdHlwZXMKLWJ5IElSdW50aW1lVHlwZS5jcmVhdGVSdW50aW1lKFN0cmluZyBpZCksIHdoaWNoIHJldHVybnMgYW4gSVJ1bnRpbWVXb3JraW5nQ29weS4KLUFueSBudW1iZXIgb2YgYXNwZWN0cyBvZiB0aGUgc2VydmVyIHJ1bnRpbWUgaW5zdGFuY2UgKGluY2x1ZGluZyBsb2NhdGlvbiBpbiB0aGUKLWZpbGUgc3lzdGVtKSBjYW4gYmUgZXN0YWJsaXNoZWQgb3IgYWRqdXN0ZWQgZnJvbSB0aGVpciBkZWZhdWx0cy4gV2hlbiBlZGl0aW5nIGlzCi1jb21wbGV0ZSwgSVJ1bnRpbWVXb3JraW5nQ29weS5zYXZlKElQcm9ncmVzc01vbml0b3IgbW9uaXRvcikgY3JlYXRlcywgcmVnaXN0ZXJzLAotcmV0dXJucyBhIHNlcnZlciBydW50aW1lIGluc3RhbmNlIChJUnVudGltZSkgY2FwdHVyaW5nIHRoZSBkZXNpcmVkIHNldHRpbmdzICh0aGUKLXdvcmtpbmcgY29weSBpcyBkaXNwb3NlZCBvZikuPC9wPgotPHA+VGhlIEFQSSBleHBvc2VzIHNlcnZlciBjb25maWd1cmF0aW9uIGluc3RhbmNlcyBhcyBJU2VydmVyQ29uZmlndXJhdGlvbi4KLVNlcnZlckNvcmUuZ2V0UmVzb3VyY2VNYW5hZ2VyKCkuZ2V0U2VydmVyQ29uZmlndXJhdGlvbnMoKSByZXR1cm5zIGFsbCBrbm93bgotc2VydmVyIGNvbmZpZ3VyYXRpb24gaW5zdGFuY2VzLiBTZXJ2ZXIgY29uZmlndXJhdGlvbiBpbnN0YW5jZXMgYXJlIGNyZWF0ZWQKLShvbmx5KSBmcm9tIHNlcnZlciB0eXBlcyBieQotSVNlcnZlckNvbmZpZ3VyYXRpb25UeXBlLmNyZWF0ZVNlcnZlckNvbmZpZ3VyYXRpb24oU3RyaW5nIGlkLCBJRmlsZSBmaWxlLAotSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSBvciBJU2VydmVyQ29uZmlndXJhdGlvblR5cGUuaW1wb3J0RnJvbVBhdGgoU3RyaW5nIGlkLAotSUZpbGUgZmlsZSwgSVBhdGggcGF0aCwgSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSBvcgotSVNlcnZlckNvbmZpZ3VyYXRpb25UeXBlLmltcG9ydEZyb21SdW50aW1lKFN0cmluZyBpZCwgSUZpbGUgZmlsZSwgSVJ1bnRpbWUKLXJ1bnRpbWUsIElQcm9ncmVzc01vbml0b3IgbW9uaXRvcikuIFRoZSBmaWxlIHBhcmFtZXRlciBpcyB1c2VkIHRvIGNvbnRyb2wgd2hlcmUKLXRoZSBzZXJ2ZXIgY29uZmlndXJhdGlvbiBpbnN0YW5jZSBpcyBzZXJpYWxpemVkLiBBbGwgMyByZXR1cm4gYW4KLUlTZXJ2ZXJDb25maWd1cmF0aW9uV29ya2luZ0NvcHkuIChUaGVyZSBhcmUgbm8gYXNwZWN0cyBvZiB0aGUgc2VydmVyCi1jb25maWd1cmF0aW9uIGluc3RhbmNlIHRvIGFkanVzdC4pCi1JU2VydmVyQ29uZmlndXJhdGlvbldvcmtpbmdDb3B5LnNhdmUoSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSBjcmVhdGVzLAotcmVnaXN0ZXJzLCByZXR1cm5zIGEgc2VydmVyIGNvbmZpZ3VyYXRpb24gaW5zdGFuY2UgKElTZXJ2ZXJDb25maWd1cmF0aW9uKQotY2FwdHVyaW5nIHRoZSBkZXNpcmVkIHNldHRpbmdzICh0aGUgd29ya2luZyBjb3B5IGlzIGRpc3Bvc2VkIG9mKS4mbmJzcDs8L3A+Ci08cD5UaGUgQVBJIGV4cG9zZXMgc2VydmVyIGluc3RhbmNlcyBhcyBJU2VydmVyLgotU2VydmVyQ29yZS5nZXRSZXNvdXJjZU1hbmFnZXIoKS5nZXRTZXJ2ZXJzKCkgcmV0dXJucyBhbGwga25vd24gc2VydmVyIGluc3RhbmNlcy4KLVNlcnZlciBpbnN0YW5jZXMgYXJlIGNyZWF0ZWQgKG9ubHkpIGZyb20gc2VydmVyIHR5cGVzIGJ5Ci1JU2VydmVyVHlwZS5jcmVhdGVTZXJ2ZXIoU3RyaW5nIGlkLCBJRmlsZSBmaWxlLCBJUnVudGltZSBydW50aW1lLAotSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSBvciBJU2VydmVyVHlwZS5jcmVhdGVTZXJ2ZXIoU3RyaW5nIGlkLCBJRmlsZSBmaWxlLAotSVJ1bnRpbWUgcnVudGltZSwgSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKS4gVGhlIGZpbGUgcGFyYW1ldGVyIGlzIHVzZWQgdG8KLWNvbnRyb2wgd2hlcmUgdGhlIHNlcnZlciBpbnN0YW5jZSBpcyBzZXJpYWxpemVkLiBCb3RoIHJldHVybiBhbgotSVNlcnZlcldvcmtpbmdDb3B5LiBBbnkgbnVtYmVyIG9mIGFzcGVjdHMgb2YgdGhlIHNlcnZlciBpbnN0YW5jZSAoaG9zdCBuYW1lLAotc2VydmVyIHJ1bnRpbWUsIHNlcnZlciBjb25maWd1cmF0aW9uLCBtb2R1bGVzLCAuLi4pIGNhbiBiZSBlc3RhYmxpc2hlZCBvcgotYWRqdXN0ZWQgZnJvbSB0aGVpciBkZWZhdWx0cy4gV2hlbiBlZGl0aW5nIGlzIGNvbXBsZXRlLAotSVNlcnZlcldvcmtpbmdDb3B5LnNhdmUoSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSBjcmVhdGVzLCByZWdpc3RlcnMsIHJldHVybnMgYQotc2VydmVyIGluc3RhbmNlIChJU2VydmVyKSBjYXB0dXJpbmcgdGhlIGRlc2lyZWQgc2V0dGluZ3MgKHRoZSB3b3JraW5nIGNvcHkgaXMKLWRpc3Bvc2VkIG9mKS4mbmJzcDs8L3A+Ci08cD5UaGUgaW5zdGFuY2UtbGV2ZWwgcmVsYXRpb25zaGlwIGJldHdlZW4gc2VydmVycyBhbmQgc2VydmVyIHJ1bnRpbWVzIGFuZAotc2VydmVyIGNvbmZpZ3VyYXRpb25zIGlzIGV4cG9zZWQgYXQgdGhlIEFQSTogZm9yIGEgZ2l2ZW4gc2VydmVyLAotSVNlcnZlci5nZXRSdW50aW1lKCkgcmV0dXJucyB0aGUgc2VydmVyIHJ1bnRpbWUgKElSdW50aW1lKSwKLUlTZXJ2ZXIuZ2V0U2VydmVyQ29uZmlndXJhdGlvbigpIHJldHVybnMgdGhlIHNlcnZlciBjb25maWd1cmF0aW9uIChJU2VydmVyQ29uZmlndXJhdGlvbikuPC9wPgotPHA+SVNlcnZlci5zdGFydChTdHJpbmcgbW9kZSwgSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSwgc3RvcCgpLCBhbmQKLXJlc3RhcnQoU3RyaW5nIG1vZGUpIGFyZSB1c2VkIHRvIHN0YXJ0LCBzdG9wLCBhbmQgcmVzdGFydCBhIHNlcnZlciwgcmVzcGVjdGl2ZWx5Ci0odGhlcmUgYXJlIGFsc28gc3luY2hyb25vdXMgbWV0aG9kcyBmb3Igc3RhcnRpbmcgYW5kIHN0b3BwaW5nKS4gVGhlIHByZWRpY2F0ZXMKLUlTZXJ2ZXIuY2FuU3RhcnQoU3RyaW5nIG1vZGUpLCBjYW5SZXN0YXJ0KFN0cmluZyBtb2RlKSwgYW5kIGNhblN0b3AoKSBpbmRpY2F0ZQotd2hldGhlciB0aGUgc2VydmVyIGlzIHJlY2VwdGl2ZSB0byBiZWluZyBjb250cm9sbGVkLiBJU2VydmVyLmdldFNlcnZlclN0YXRlKCkKLWNhbiBiZSB1c2VkIHRvIHF1ZXJ5IHRoZSBvdmVyYWxsIHN0YXRlIG9mIHRoZSBzZXJ2ZXIgKG9uZSBvZiBzdGFydGluZywgc3RhcnRlZCwKLXN0b3BwaW5nLCBzdG9wcGVkLCBvciB1bmtub3duKSwgYW5kIElTZXJ2ZXIuZ2V0TW9kdWxlU3RhdGUoSU1vZHVsZSBtb2R1bGUpIGNhbgotYmUgdXNlZCB0byBxdWVyeSB0aGUgc3RhdGUgb2YgYW55IG9mIGl0cyBtb2R1bGVzLjwvcD4KLQotPC9ib2R5PgotCi08L2h0bWw+CmRpZmYgLS1naXQgYS9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL3dlYl90b29sc19zZXJ2ZXJfYXBpX2NvbmNlcHRzLmh0bWwgYi9kZXZlbG9wbWVudC9taXNjZG9jdW1lbnRzL3dlYl90b29sc19zZXJ2ZXJfYXBpX2NvbmNlcHRzLmh0bWwKZGVsZXRlZCBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDhiNGIyM2YuLjAwMDAwMDAKLS0tIGEvZGV2ZWxvcG1lbnQvbWlzY2RvY3VtZW50cy93ZWJfdG9vbHNfc2VydmVyX2FwaV9jb25jZXB0cy5odG1sCisrKyAvZGV2L251bGwKQEAgLTEsMjYwICswLDAgQEAKLTxodG1sPgotCi08aGVhZD4KLTxtZXRhIGh0dHAtZXF1aXY9IkNvbnRlbnQtVHlwZSIgY29udGVudD0idGV4dC9odG1sOyBjaGFyc2V0PXdpbmRvd3MtMTI1MiI+Ci08bWV0YSBuYW1lPSJHRU5FUkFUT1IiIGNvbnRlbnQ9Ik1pY3Jvc29mdCBGcm9udFBhZ2UgNC4wIj4KLTxtZXRhIG5hbWU9IlByb2dJZCIgY29udGVudD0iRnJvbnRQYWdlLkVkaXRvci5Eb2N1bWVudCI+Ci08dGl0bGU+QVBJIENvbmNlcHRzIGFuZCBSb2xlczwvdGl0bGU+Ci08L2hlYWQ+Ci0KLTxib2R5PgotCi08aDE+V1RQIFNlcnZlciBUb29sczxicj4KLUFQSSBDb25jZXB0cyBhbmQgUm9sZXM8L2gxPgotPHA+TGFzdCBtb2RpZmllZCBOb3YuIDIsIDIwMDQ8L3A+Ci08cD5bPGk+VGhpcyBkb2N1bWVudCBpcyBhIHdvcmsgaW4gcHJvZ3Jlc3MuIFRoZSBkb2N1bWVudCBpcyBhbiBhdHRlbXB0IHRvCi1jYXB0dXJlIHRoZSBrZXkgY29uY2VwdHMgcmVxdWlyZWQgZm9yIHVuZGVyc3RhbmRpbmcgYW5kIHdvcmtpbmcgd2l0aCB0aGUgV1RQCi1TZXJ2ZXIgQ29yZSBBUEkuIE5vdGUgdGhhdCB0aGUgY29uY2VwdHMgbWF5IGRpZmZlciBzdWJ0bHkgZnJvbSB3aGF0IGlzIGN1cnJlbnRseQotZm91bmQgaW4gdGhlIGN1cnJlbnRseSByZWxlYXNlZCA8YSBocmVmPSJodHRwOi8vZGV2LmVjbGlwc2Uub3JnL3ZpZXdjdnMvaW5kZXguY2dpL3dzdC9jb21wb25lbnRzL3NlcnZlci9wbHVnaW5zL29yZy5lY2xpcHNlLndzdC5zZXJ2ZXIuY29yZS8/Y3Zzcm9vdD1XZWJUb29sc19Qcm9qZWN0Ij5vcmcuZWNsaXBzZS53c3Quc2VydmVyLmNvcmUKLXBsdWctaW48L2E+LiBPbmNlIHRoaXMgZG9jdW1lbnQgaXMgZmluYWxpemVkLCBvdXIgaW50ZW50IGlzIHRvIGJyaW5nIHRoZSBjb2RlCi1hbmQgc3BlY3MgaW50byBsaW5lIHdpdGggdGhpcyBkb2N1bWVudC5dPC9pPjwvcD4KLTxwPlRoZSBrZXkgY29uY2VwdHMgZm9yIHVuZGVyc3RhbmRpbmcgdGhlIEFQSSAoYW5kIFNQSSkgYXJlIHNlcnZlcnMgYW5kIG1vZHVsZXMuCi1UaGUgbm90aW9ucyBvZiBzZXJ2ZXIgcnVudGltZXMgYW5kIHNlcnZlciBjb25maWd1cmF0aW9ucyBwbGF5IGFuIGltcG9ydGFudCwgYnV0Ci1zZWNvbmRhcnkgcm9sZS48L3A+Ci08cD5Ob3Qgc3VycHJpc2luZ2x5LCB0aGUgbm90aW9uIG9mIDxiPnNlcnZlcjwvYj4gaXMgY2VudHJhbCBpbiB0aGUgd2ViIHRvb2xzCi1zZXJ2ZXIgaW5mcmFzdHJ1Y3R1cmUuIEluIHRoaXMgY29udGV4dCB3ZSBhcmUgdG8gdW5kZXJzdGFuZCB0aGF0IHRoZSBzZXJ2ZXIgaXMgYQotd2ViIHNlcnZlciBvZiBzb21lIGlsayAoYSBtb3JlIGV4YWN0IGRlZmluaXRpb24gaXMgbm90IHJlcXVpcmVkIGZvciBvdXIKLXB1cnBvc2VzKS4gRnJvbSBhIHRvb2wtY2VudHJpYyBwb2ludCBvZiB2aWV3LCBhIHNlcnZlciBpcyBzb21ldGhpbmcgdGhhdCB0aGUKLWRldmVsb3BlciBpcyB3cml0aW5nICZxdW90O2NvbnRlbnQmcXVvdDsgZm9yLiAoSW4gYSBzZW5zZSwgdGhlIHNlcnZlciBleGlzdHMsCi1idXQgbGFja3MgdXNlZnVsIGNvbnRlbnQuIFRoZSBkZXZlbG9wbWVudCB0YXNrIGlzIHRvIHByb3ZpZGUgdGhhdCBjb250ZW50LikgVGhlCi1jb250ZW50IGNhbiBpbmNsdWRlIGFueXRoaW5nIGZyb20gc2ltcGxlLCBzdGF0aWMgSFRNTCB3ZWIgcGFnZXMgdG8gY29tcGxleCwKLWhpZ2hseSBkeW5hbWljIHdlYiBhcHBsaWNhdGlvbnMuIEluIHRoZSBjb3Vyc2Ugb2Ygd3JpdGluZyBhbmQgZGVidWdnaW5nIHRoaXMKLWNvbnRlbnQsIHRoZXkgd2lsbCB3YW50IHRvIHRlc3QgdGhlaXIgY29udGVudCBvbiBhIHdlYiBzZXJ2ZXIsIHRvIHNlZSBob3cgaXQKLWdldHMgc2VydmVkIHVwLiBGb3IgdGhpcyB0aGV5IHdpbGwgbmVlZCB0byBsYXVuY2ggYSBzZXJ2ZXIgcHJvY2VzcyBydW5uaW5nIG9uCi1zb21lIGhvc3QgbWFjaGluZSAob2Z0ZW4gdGhlIGxvY2FsIGhvc3Qgb24gd2hpY2ggdGhlIEVjbGlwc2UgSURFIGlzIHJ1bm5pbmcpLCBvcgotYXR0YWNoIHRvIGEgc2VydmVyIHRoYXQncyBhbHJlYWR5IHJ1bm5pbmcuIEFuZCB3ZSBtdXN0IGFycmFuZ2UgdGhhdCB0aGUgbmV3bHkKLWRldmVsb3BlZCBjb250ZW50IHNpdHRpbmcgaW4gdGhlIGRldmVsb3BlcidzIHdvcmtzcGFjZSBlbmRzIHVwIGluIGEgbG9jYXRpb24gYW5kCi1mb3JtYXQgdGhhdCBhIHJ1bm5pbmcgc2VydmVyIGNhbiB1c2UgZm9yIGl0cyBzZXJ2aW5nIHB1cnBvc2VzLjwvcD4KLTxwPihUaGUgc2VydmVyIG9iamVjdHMgaW4gdGhlIEFQSSBhcmUgaW4gZmFjdCBpbnRlcm1lZGlhcnkgJnF1b3Q7cHJveHkmcXVvdDsKLW9iamVjdHMgdGhhdCBtZWRpYXRlIGJldHdlZW4gdGhlIHRvb2xzIHJ1bm5pbmcgaW4gRWNsaXBzZSBhbmQgdGhlIHJlYWwgc2VydmVyLiBBCi1zZXJ2ZXIgcHJveHkgb2JqZWN0IGhhcyBhIHNvbWV3aGF0IGluZGVwZW5kZW50IGxpZmUgZnJvbSB0aGF0IG9mIGEgcmVhbCBzZXJ2ZXIuCi1JbiBjYXNlcyB3aGVyZSB0aGUgc2VydmVyIHByb2Nlc3MgbXVzdCBiZSBsYXVuY2hlZCwgdGhlIHByb3h5IG9iamVjdCBleGlzdHMgaW4KLWFkdmFuY2Ugb2YgdGhlIHNlcnZlciBwcm9jZXNzLCBhbmQgbGl2ZXMgcGFzdCB0aGUgdGVybWluYXRpb24gb2YgdGhlIHNlcnZlcgotcHJvY2Vzcy4gVGhlIHNhbWUgc2VydmVyIHByb3h5IG1heSBiZSBzZXJpYWxseSByZXVzZWQgdG8gcmVsYXVuY2ggc2VydmVyCi1wcm9jZXNzZXMuIEluIGNhc2VzIHdoZXJlIHdlIGFyZSBjb25uZWN0aW5nIHRvIGEgc2VydmVyIHByb2Nlc3MgcnVubmluZyBvbiBhCi1yZW1vdGUgaG9zdCwgdGhlIHNlcnZlciBwcm9jZXNzIG1heSB3ZWxsIG91dGxpdmUgdGhlIHByb3h5Lik8L3A+Ci08cD5TZXJ2ZXJzIGhhdmUgYSA8Yj5zZXJ2ZXIgcnVudGltZTwvYj4uIFRoZSBzZXJ2ZXIgcnVudGltZSBjb3JyZXNwb25kcyB0byB0aGUKLWluc3RhbGxlZCBjb2RlIGJhc2UgZm9yIHRoZSBzZXJ2ZXIuIFRoZSBtYWluIHJvbGUgcGxheWVkIGJ5IHRoZSBzZXJ2ZXIgcnVudGltZQotaXMgaW4gaWRlbnRpZnlpbmcgY29kZSBsaWJyYXJpZXMgdG8gY29tcGlsZSBvciBidWlsZCBhZ2FpbnN0LiBJbiB0aGUgY2FzZSBvZgotbG9jYWwgc2VydmVycywgdGhlIHNlcnZlciBydW50aW1lIG1heSBwbGF5IGEgc2Vjb25kYXJ5IHJvbGUgb2YgYmVpbmcgdXNlZCB0bwotbGF1bmNoIHRoZSBzZXJ2ZXIgZm9yIHRlc3RpbmcuIEhhdmluZyB0aGUgc2VydmVyIHJ1bnRpbWVzIGlkZW50aWZpZWQgYXMgYW4KLWVudGl0eSBzZXBhcmF0ZSBmcm9tIHRoZSBzZXJ2ZXIgaXRzZWxmIGZhY2lsaXRhdGVzIHNoYXJpbmcgc2VydmVyIHJ1bnRpbWVzCi1iZXR3ZWVuIHNldmVyYWwgc2VydmVycy48L3A+Ci08cD5TZXJ2ZXJzIGhhdmUgYW4gb3B0aW9uYWwgPGI+c2VydmVyIGNvbmZpZ3VyYXRpb248L2I+LiBUaGUgc2VydmVyCi1jb25maWd1cmF0aW9uIGlzIGluZm9ybWF0aW9uIHVzZWQgdG8gY29uZmlndXJlIGEgcnVubmluZyBzZXJ2ZXIuIFNpbXBsZSB0eXBlcyBvZgotc2VydmVycyBtaWdodCBub3QgcmVxdWlyZSBhbnkgY29uZmlndXJhdGlvbiwgd2hlcmVhcyBmdWxsLWZlYXR1cmVkIHdlYiBzZXJ2ZXIKLWhhdmUgYW4gZXh0ZW5zaXZlIHNldCBvZiBwYXJhbWV0ZXJzIGZvciBhZGp1c3RpbmcgdGhlIHNlcnZlcidzIGJlaGF2aW9yLiBFdmVuCi10aG91Z2ggc2VydmVyIGNvbmZpZ3VyYXRpb24gaW5mb3JtYXRpb24gdXN1YWxseSB0YWtlcyB0aGUgZm9ybSBvZiBvbmUgb3IgbW9yZQotZmlsZXMsIGNvbmZpZ3VyYXRpb24gaW5mb3JtYXRpb24gaXMgdHJlYXRlZCBzZXBhcmF0ZWx5IGZyb20gYWN0dWFsIGNvbnRlbnQuCi1BY3R1YWwgd2ViIGNvbnRlbnQgY2FuIGJlIGRlcGxveWVkIG9uIGRpZmZlcmVudCBzZXJ2ZXJzIHdpdGhvdXQgY2hhbmdlLCB3aGVyZWFzCi1zZXJ2ZXIgY29uZmlndXJhdGlvbiBpbmZvcm1hdGlvbiBpcyB1c3VhbGx5IGhpZ2hseSBkZXBlbmRlbnQgb24gdGhlIHBhcnRpY3VsYXJzCi1vZiB0aGUgc2VydmVyLiBIYXZpbmcgdGhlIHNlcnZlciBjb25maWd1cmF0aW9uIGlkZW50aWZpZWQgYXMgYW4gZW50aXR5IHNlcGFyYXRlCi1mcm9tIHRoZSBzZXJ2ZXIgaXRzZWxmIGZhY2lsaXRhdGVzIHN3aXRjaGluZyBhbiBleGlzdGluZyBzZXJ2ZXIgYmV0d2VlbgotY29uZmlndXJhdGlvbnMsIGFuZCBzaGFyaW5nIHNlcnZlciBjb25maWd1cmF0aW9ucyBiZXR3ZWVuIHNldmVyYWwgc2VydmVycyAoZS5nLiwKLWEgbG9jYWwgdGVzdCBzZXJ2ZXIgYW5kIGEgcmVtb3RlIHNlcnZlciBydW5uaW5nIG9uIGFub3RoZXIgaG9zdCkuPC9wPgotPHA+VGhlIHdlYiBjb250ZW50IHRoYXQgaXMgZGV2ZWxvcGVkIGZvciBhIHdlYiBzZXJ2ZXIgY29tZXMgaW4gPGI+bW9kdWxlczwvYj4uIEEKLW1vZHVsZSB1c3VhbGx5IGNvbnNpc3RzIG9mIGEgdHJlZSBvZiBmaWxlczsgYSBzdGF0aWMgSFRNTCB3ZWIgaXMgb25lIHNpbXBsZQotZXhhbXBsZS4gRGlmZmVyZW50IHR5cGVzIG9mIG1vZHVsZXMgY29uc2lzdCBvZiBwb3NzaWJseSBjb25zdHJhaW5lZCBhcnJhbmdlbWVudHMKLWZpbGVzIG9mIGNlcnRhaW4gZmlsZSB0eXBlcy4gVGhlIGZpbGVzIG1ha2luZyB1cCBhIG1vZHVsZSB1bmRlciBkZXZlbG9wbWVudAotcmVzaWRlIGluIHRoZSBFY2xpcHNlIHdvcmtzcGFjZS4gSW4gb3JkZXIgZm9yIGEgc2VydmVyIHRvIHVzZSBhY2Nlc3MgdGhlIGNvbnRlbnQKLXdpdGhpbiBhIG1vZHVsZSwgdGhlIG1vZHVsZSBpbiB0aGUgd29ya3NwYWNlIG11c3QgYmUgPGI+cHVibGlzaGVkIDwvYj50byB0aGUKLXNlcnZlciAod2UgdXNlIHRoZSB0ZXJtJm5ic3A7IDxpPnB1Ymxpc2g8L2k+IHJhdGhlciB0aGFuIDxpPmRlcGxveTwvaT4gd2hpY2ggaXMKLW92ZXJ1c2VkIGluIEoyRUUpLiBUaGUgbW9kdWxlIGlzIHRoZSB1bml0IG9mIGNvbnRlbnQgdGhhdCBpcyBwdWJsaXNoZWQgdG8gYQotc2VydmVyLiBJbiB0aGUgY2FzZSBvZiBKMkVFIHNlcnZlcnMsIHRoZSBub3Rpb24gb2YgbW9kdWxlIGFsaWducyB3aXRoIHRoZSBKMkVFCi1ub3Rpb24gb2YgYSBtb2R1bGUgKGEgc2VydmVyIGNvbmNlcHQpLiZuYnNwOyBCdXQgdGhhdCBuZWVkbid0IGJlIHRoZSBjYXNlOyBzb21lCi10eXBlcyBvZiBzZXJ2ZXJzLCBzdWNoIGFzIGEgc2ltcGxlIEhUVFAgc2VydmVyLCBkb24ndCBoYXZlIGEgbm90aW9uIG9mIG1vZHVsZS4KLUVpdGhlciB3YXksIHB1Ymxpc2hpbmcgYSBtb2R1bGUgdG8gdGhlIHNlcnZlciBlbnRhaWxzIHdoYXRldmVyIGl0IHRha2VzIHRvIGdldAotdGhlIHB1Ymxpc2hhYmxlIGNvbnRlbnQgZnJvbSB0aGUgd29ya3NwYWNlIHRvIHRoZSBzZXJ2ZXIgaW4gYSBmb3JtIHRoYXQgdGhlCi1zZXJ2ZXIgY2FuIGFjY2VzcyBpdC4gRGlmZmVyZW50IHR5cGVzIG9mIHNlcnZlciBydW50aW1lcyBhcmUgY2FwYWJsZSBvZiBzdXBwb3J0Ci12YXJpb3VzIG1vZHVsZSB0eXBlcy48L3A+Ci08cD5BdCBhbnkgZ2l2ZW4gdGltZSwgdGhlIGRldmVsb3BlciBtYXkgYmUgd29ya2luZyB3aXRoIGFueSBudW1iZXIgb2Ygc2VydmVycy4KLUVhY2ggc2VydmVyIGhhcyBhIHNlcnZlciBjb25maWd1cmF0aW9uIGFuZCBhIHNldCBvZiBtb2R1bGVzLiBGcm9tIHRoZSBjb21wbGV0ZQotc2V0IG9mIG1vZHVsZXMgaW4gdGhlIHdvcmtzcGFjZSwgYW55IHBhcnRpY3VsYXIgc2VydmVyIG1heSBzZWUgb25seSBhIHN1YnNldCwKLWFsdGhvdWdoIGl0IGlzIGFsc28gY29tbW9uIGZvciBhbGwgc2VydmVycyB0byBzZWUgYWxsIGF2YWlsYWJsZSBtb2R1bGVzLiBBZnRlcgotdGhlIGRldmVsb3BlciBtYWtlcyBjaGFuZ2VzIHRvIHRoZSBtb2R1bGVzIGluIHRoZSB3b3Jrc3BhY2UgYW5kIG5vdyB3YW50cyB0bwotdGVzdCB0aGVpciBtb2RpZmljYXRpb24sIHRoZXkgcmVwdWJsaXNoIHRoZSBtb2R1bGVzIHRvIHRoZSBzZXJ2ZXIuIERlcGVuZGluZyBvbgotdGhlIHR5cGUgb2Ygc2VydmVyLCByZXB1Ymxpc2hpbmcgYSBtb2R1bGUgbWF5IGVudGFpbCBzdG9wcGluZyBhbmQgcmVzdGFydGluZyB0aGUKLXNlcnZlci48L3A+Ci08cD5Tb21lIHR5cGVzIG9mIG1vZHVsZXMgY2FuIGhhdmUgb3RoZXIgbW9kdWxlcyBhcyBjaGlsZHJlbi4gVGhlIHN0YW5kYXJkCi1leGFtcGxlIG9mIHRoaXMgaXMgYSBKMkVFIEVudGVycHJpc2UgQXBwbGljYXRpb24gKEVBKSBtb2R1bGUsIHdob3NlIGNoaWxkcmVuIGFyZQotc2ltcGxlIEoyRUUgbW9kdWxlcyBsaWtlIEVudGVycHJpc2UgSmF2YSBCZWFucyBhbmQgV2ViIEFwcGxpY2F0aW9ucy4gVGhlCi1wYXJlbnQtY2hpbGQgcmVsYXRpb25zaGlwIGlzIHdlYWs6IHR3byBwYXJlbnQgbW9kdWxlcyBjYW4gc2hhcmUgdGhlIHNhbWUgY2hpbGQKLW1vZHVsZSwgYW5kIHRoZSBzYW1lIGNoaWxkIGNhbiBiZSBwYXJlbnRlZCBieSBzZXZlcmFsIG1vZHVsZXMgKG9uIHRoZSBzYW1lIG9yIG9uCi1kaWZmZXJlbnQgc2VydmVycykuIFRoZSBmaWxlIHRyZWVzIGZvciBtb2R1bGVzIGFyZSBub3JtYWxseSBtdXR1YWxseSBkaXNqb2ludC4KLU1vZHVsZSBjb250YWlubWVudCBpcyBub3QgcmVmbGVjdGVkIGJ5IGFueSBzb3J0IG9mIGRpcmVjdG9yeSBuZXN0aW5nLiBQYXJlbnQgYW5kCi1jaGlsZCBtb2R1bGVzIG1hcCB0byBub24tb3ZlcmxhcHBpbmcgZmlsZSB0cmVlcy48L3A+Ci08cD5Nb2R1bGVzIHJlc2lkZSBpbiB0aGUgd29ya3NwYWNlLiBUaGUgdHlwaWNhbCBhcnJhbmdlbWVudCBpcyB0aGF0IGVhY2ggbW9kdWxlCi1oYXMgaXRzIG93biBwcm9qZWN0LCB0ZXJtZWQgYSA8Yj5tb2R1bGUgcHJvamVjdDwvYj4uIFRoZSBtb2R1bGUgY29udGVudCB1c3VhbGx5Ci1jb3JyZXNwb25kcyB0byBhIHBhcnRpY3VsYXIgZm9sZGVyIHdpdGhpbiBhIHByb2plY3QgcmF0aGVyIHRoYW4gdGhlIHJvb3Qgb2YgdGhlCi1wcm9qZWN0OyB0aGlzIGFsbG93cyB0aGUgcHJvamVjdCB0byBjb250YWluIG90aGVyIGZpbGVzIChlLmcuLCAucHJvamVjdCwgLmNsYXNzcGF0aCwKLXNvdXJjZSBjb2RlKSB0aGF0IGFyZSBub3QgY29uc2lkZXJlZCBwYXJ0IG9mIHRoZSBtb2R1bGUgY29udGVudCBwcm9wZXIuIEVhY2gKLWRpZmZlcmVudCB0eXBlIG9mIG1vZHVsZSBoYXMgaXRzIG93biBydWxlcyBmb3IgaG93IHRoZSBjb250ZW50IGZpbGVzIHdpdGhpbiBpdAotYXJlIGxhaWQgb3V0LiBGb3IgaW5zdGFuY2UsIGEgSjJFRSB3ZWIgbW9kdWxlIGhhcyB0aGUgc2FtZSBzdHJ1Y3R1cmUgYXMgYW4KLXVuemlwcGVkIFdBUiBmaWxlLiAoTm90ZSB0aGF0IHRoZSBtb2R1bGUgc3RydWN0dXJlIHJ1bGVzIGFyZSBsYXJnZWx5IGltcGxpY2l0Ci1hbmQgbm90IHJlZmxlY3RlZCBkaXJlY3RseSBpbiB0aGUgQVBJcy4pIEl0IGlzIHBvc3NpYmxlIGZvciBhIHByb2plY3QgdG8KLWNvbnRhaW5zIG1vcmUgdGhhbiBvbmUgbW9kdWxlIChhbHRob3VnaCB0aGlzIGFycmFuZ2VtZW50IGlzIGxlc3MgY29tbW9uLCBhbmQgbm90Ci1hcyB3ZWxsIHN1cHBvcnRlZCkuPC9wPgotPHA+RHVyaW5nIGRldmVsb3BtZW50LCBwcm9qZWN0cyBjb250YWluaW5nIG1vZHVsZXMgY2FuIGJlIDxiPnRhcmdldGVkPC9iPiB0byBhCi1wYXJ0aWN1bGFyIHNlcnZlciBydW50aW1lLiBUYXJnZXRpbmcgYWxsb3dzIHRoZSBJREUgdG8gc2V0IHVwIHZhcmlvdXMKLWRldmVsb3BtZW50IHRpbWUgcHJvcGVydGllcyBvZiB0aGUgcHJvamVjdCAoc3VjaCBhcyB0aGUgYmFja2JvbmUgb2YgdGhlIEphdmEKLWJ1aWxkIHBhdGgpIGFwcHJvcHJpYXRlbHkuIFRoZSBtb3N0IGNvbW1vbiBzY2VuYXJpbyBpcyB3aGVyZSB0aGUgcHJvamVjdCBpcwotdGFyZ2V0ZWQgdG8gdGhlIHNlcnZlciBydW50aW1lIGZvciB0aGUgc2VydmVyIHRvIHdoaWNoIHRoZSBtb2R1bGUgaXMgYmVpbmcKLXB1Ymxpc2hlZC4gSG93ZXZlciwgaXQgaXMgYWxzbyBwb3NzaWJsZSB0byB0YXJnZXQgb25lIHNlcnZlciBydW50aW1lIChlLmcuLCBhCi1nZW5lcmljIEoyRUUgMS4zIHNlcnZlciBydW50aW1lKSB3aGlsZSBwdWJsaXNoaW5nIHRvIGEgc2VydmVyIHdpdGggYSBkaWZmZXJlbnQKLXNlcnZlciBydW50aW1lIChlLmcuLCBhIFRvbWNhdCB2NS4wIHNlcnZlcikuIFRhcmdldGluZyBhIHByb2plY3QgdG8gYSBwYXJ0aWN1bGFyCi1zZXJ2ZXIgcnVudGltZSB0eXBpY2FsbHkgZXN0YWJsaXNoZXMgdGhlIEphdmEgYnVpbGQgY2xhc3NwYXRoIG9mIHRoZSBwcm9qZWN0IHRvCi1pbmNsdWRlIHRoZSBsaWJyYXJpZXMgY29udGFpbmluZyB0aGUgSmF2YSBBUElzIGZvciB0aGF0IHNlcnZlciBydW50aW1lIChlLmcuLAotdGhlIGFwcHJvcHJpYXRlIEoyRUUgY2xhc3MgbGlicmFyaWVzKS4gVGhlIEphdmEgYnVpbGQgY2xhc3NwYXRoIGFsc28gbmVlZHMgdG8KLXJlZmxlY3QgaW50ZXItbW9kdWxlIGRlcGVuZGVuY2llczsgZm9yIEoyRUUgbW9kdWxlIHR5cGVzLCB0aGUgYXBwcm9wcmlhdGUKLWVudHJpZXMgYXJlIHR5cGljYWxseSBkZXJpdmVkIGZyb20gdGhlIG1vZHVsZSdzIG1hbmlmZXN0LjwvcD4KLTxwPkEgPGI+c2VydmVyIHByb2plY3Q8L2I+IGlzIGEgcHJvamVjdCB1c2VkIHRvIGhvbGQgc2VyaWFsaXplZCBzZXJ2ZXIgKHNlcnZlcgotcnVudGltZSwgc2VydmVyIGNvbmZpZ3VyYXRpb24pIGluc3RhbmNlcy4gVGhlIHByb2plY3QgaXMgdGFnZ2VkIHdpdGggYSBzcGVjaWFsCi1FY2xpcHNlIHNlcnZlciBuYXR1cmUuIFRoZSBtYWluIHJlYXNvbiBiZWhpbmQgc2VydmVyIHByb2plY3RzIHdhcyBhcyBhbgotZWZmaWNpZW50IG1lYW5zIG9mIG1ha2luZyB0aGVzZSBzZXJpYWxpemVkIGZpbGVzIHZpc2libGUgaW4gdGhlIHJlc291cmNlCi1uYXZpZ2F0b3IgYW5kIG1vbml0b3JpbmcgY2hhbmdlcyB0byB0aGVtLjwvcD4KLTxwPlRoZSBtYWluIGdvYWxzIG9mIHRoZSBTZXJ2ZXIgQ29yZSBjbGllbnQgQVBJcyBhcmUgdG8gYWxsb3cgY2xpZW50cyB0byBjcmVhdGUsCi1jb25maWd1cmUsIGFuZCBsYXVuY2ggaW5zdGFuY2VzIG9mIHBhcnRpY3VsYXIgc2VydmVyIHR5cGVzLiBEdWUgdG8gZGlmZmVyZW5jZXMKLWluIHRoZSBiZWhhdmlvciAoYW5kIEFQSXMpIG9mIGRpZmZlcmVudCBzZXJ2ZXIgdHlwZXMsIGEgY2xpZW50IG11c3QgZ2VuZXJhbGx5IGJlCi1rbm93bGVkZ2VhYmxlIG9mIHJ1bGVzIGZvciBhIHBhcnRpY3VsYXIgc2VydmVyIHR5cGUuIENsaWVudHMgdGhhdCBoYXZlIG5vCi1rbm93bGVkZ2Ugb2YgYW55IHNwZWNpZmljIHNlcnZlciB0eXBlIGFyZSBsaW1pdGVkIHRvIGRvaW5nIHRoaW5ncyBsaWtlIHN0YXJ0aW5nLAotc3RvcHBpbmcsIGFuZCByZWxhdW5jaGluZyBleGlzdGluZyBzZXJ2ZXJzLiBJbiBvdGhlciB3b3JkcywgdGhlIGNsaWVudHMgQVBJcyBhcmUKLWdlbmVyYWxseSBzZXJ2ZXItdHlwZS1zcGVjaWZpYywgcmF0aGVyIHRoYW4gc2V2ZXItdHlwZS1nZW5lcmljLjwvcD4KLTxwPlRoZSB3ZWIgdG9vbHMgc2VydmVyIGFyY2hpdGVjdHVyZSBhbGxvd3MgZm9yIGFuIG9wZW4tZW5kZWQgc2V0IG9mIHNlcnZlcgotdHlwZXMsIHNlcnZlciBydW50aW1lIHR5cGVzLCBzZXJ2ZXIgY29uZmlndXJhdGlvbiB0eXBlcywgYW5kIG1vZHVsZSB0eXBlcy4gTmV3Ci10eXBlcyBhcmUgZGVjbGFyZWQgdmlhIGV4dGVuc2lvbiBwb2ludHMgaW4gdGhlIFNlcnZlciBDb3JlIHBsdWctaW4gKG9yZy5lY2xpcHNlLnd0cC5zZXJ2ZXIuY29yZSkuCi1TZXJ2ZXIgdHlwZXMgYXJlIGRlY2xhcmVkIGJ5IHRoZSBzZXJ2ZXJUeXBlcyBleHRlbnNpb24gcG9pbnQ7IHNlcnZlciBydW50aW1lCi10eXBlcywgYnkgcnVudGltZVR5cGVzOyBzZXJ2ZXIgY29uZmlndXJhdGlvbiB0eXBlcywgYnkgc2VydmVyQ29uZmlndXJhdGlvblR5cGVzOwotYW5kIG1vZHVsZSB0eXBlcywgYnkgbW9kdWxlS2luZHMuIChBZGRpdGlvbmFsIGV4dGVuc2lvbiBwb2ludHMgYXJlIGRpc2N1c3NlZAotYmVsb3cuKSBBc3NvY2lhdGVkIHdpdGggdGhlc2UgZXh0ZW5zaW9uIHBvaW50cyBhcmUgY29kZSBBUElzIGRlc2lnbmVkIGZvciB1c2UgYnkKLWNsaWVudHMgY29udHJpYnV0aW5nIHRvIHRoZSBTZXJ2ZXIgQ29yZSBleHRlbnNpb24gcG9pbnRzOyB0aGVzZSBhcmUgbW9yZQotY29ycmVjdGx5IGNhbGxlZCBTUElzIChzZXJ2aWNlIHByb3ZpZGVyIGludGVyZmFjZXMpIHRvIGRpc3Rpbmd1aXNoIHRoZW0gZnJvbSB0aGUKLWNvZGUgZGVzaWduZWQgdG8gYmUgdXNlZCBieSBvdGhlciBjbGllbnRzICh3aGljaCB3ZSByZWZlciB0byBoZXJlIGFzIGNsaWVudAotQVBJcykuPC9wPgotPHA+TWFueSBvZiB0aGUgZXh0ZW5zaW9uIHBvaW50cyBwcm92aWRlIGZvciBhIGR5bmFtaWMgY29kZSBjb21wb25lbnQgaW4gYWRkaXRpb24KLXRvIHRoZSBzdGF0aWMgaW5mb3JtYXRpb24gc3VwcGxpZWQgaW4gdGhlIGV4dGVuc2lvbiBkZWNsYXJhdGlvbi4gVGhlc2UgYXJlCi10ZXJtZWQgPGk+ZGVsZWdhdGVzPC9pPi4gRm9yIGluc3RhbmNlLCBhbGwgY29tbXVuaWNhdGlvbiB3aXRoIHRoZSBydW5uaW5nIHNlcnZlcgotaXMgaGFuZGxlZCBieSBhIDxiPnNlcnZlciBkZWxlZ2F0ZTwvYj4gY29udHJpYnV0ZWQgdmlhIHRoZSBzZXJ2ZXIgdHlwZSBleHRlbnNpb24KLXBvaW50LiBDbGllbnRzIGdlbmVyYWxseSBkZWFsIGRpcmVjdGx5IHdpdGggYSBsYXllciBvZiBvYmplY3RzIGV4cG9zZWQgYnkgdGhlCi1BUEkgZXhwcmVzc2x5IGZvciBjbGllbnQgdXNlLiBJbiB0aGUgY2FzZSBvZiBzZXJ2ZXIsIGNsaWVudHMgZGVhbCB3aXRoIGFuCi1JU2VydmVyLiBJU2VydmVyIGhhcyBhIGZpeGVkLCBoaWRkZW4gaW1wbGVtZW50YXRpb24gKHRoZSBpbnRlcm5hbCBjbGFzcyBTZXJ2ZXIpLAotd2hpY2ggaGFuZ3Mgb24gdG8gYSBsYXppbHktY3JlYXRlZCBzZXJ2ZXIgZGVsZWdhdGUgb2YgdHlwZSBJU2VydmVyRGVsZWdhdGUuIFRoZQotSVNlcnZlckRlbGVnYXRlIGltcGxlbWVudGF0aW9uIGlzIGEgc2VydmVyLXR5cGUtc3BlY2lmaWMgb2JqZWN0LiBUaGUgbW9yZQotaW50ZXJlc3RpbmcgSVNlcnZlciBtZXRob2RzIChlLmcuLCBnZXRTZXJ2ZXJTdGF0ZSgpKSBhcmUgaGFuZGxlZCBieSB0aGUKLWRlbGVnYXRlLiBUaGVyZSBhcmUgYWxzbyBnZXREZWxlZ2F0ZSgpIG1ldGhvZHMgdGhhdCBicmlkZ2UgQVBJIHRvIFNQSSwgYWxsb3dpbmcKLWNsaWVudHMgdG8gY2FsbCBtZXRob2RzIG9uIHRoZSBkZWxlZ2F0ZSBkaXJlY3RseS4gU2VydmljZSBwcm92aWRlcnMgbWF5IGFsc28KLWNob29zZSB0byBleHBvc2UgdGhlaXIgZGVsZWdhdGUgaW1wbGVtZW50YXRpb24gYXMgQVBJLiBUaGlzIGFsbG93cywgZm9yIGV4YW1wbGUsCi10aGUgcHJvdmlkZXIgb2YgYSBzZXJ2ZXIgdHlwZSB0byBvZmZlciBhZGRpdGlvbmFsIEFQSSB0aGF0IGlzCi1zZXJ2ZXItdHlwZS1zcGVjaWZpYy48L3A+Ci08cD5BIDxiPm1vZHVsZSBmYWN0b3J5PC9iPiBpcyByZXNwb25zaWJsZSBmb3IgY3JlYXRpbmcgbW9kdWxlcy4gVGhlcmUgY2FuIGJlIGFueQotbnVtYmVyIG9mIHJlZ2lzdGVyZWQgbW9kdWxlIGZhY3RvcmllcywgZGVjbGFyZWQgdmlhIHRoZQotb3JnLmVjbGlwc2Uud3RwLnNlcnZlci5jb3JlLm1vZHVsZUZhY3RvcnkgZXh0ZW5zaW9uIHBvaW50LiBBIG1vZHVsZSBmYWN0b3J5IG1heQotY3JlYXRlIG9uZSBvciBtb3JlIHR5cGVzIG9mIG1vZHVsZXMgKGFsc28gZGVjbGFyZWQgaW4gdGhlIGV4dGVuc2lvbiBwb2ludCkuIFRoZQotbW9kdWxlIGZhY3RvcnkgQVBJIGRvZXMgbm90IHByZXNjcmliZSBhIHdheSB0byBjcmVhdGUgbW9kdWxlczsgaXQgZG9lcywgaG93ZXZlciwKLXByb3ZpZGUgbWV0aG9kcyBmb3IgcmV0cmlldmluZyBleHRhbnQgbW9kdWxlcyB0aGF0IGl0IHdhcyByZXNwb25zaWJsZSBmb3IKLWNyZWF0aW5nIChJTW9kdWxlRmFjdG9yeURlbGVnYXRlLmdldE1vZHVsZXMoKSBhbmQKLUlNb2R1bGVGYWN0b3J5RGVsZWdhdGUuZ2V0TW9kdWxlKFN0cmluZyBtZW1lbnRvKSkuPC9wPgotPHA+QSA8Yj5wdWJsaXNoIG1hbmFnZXI8L2I+IGlzIHJlc3BvbnNpYmxlIGZvciBkZWNpZGluZyB3aGV0aGVyIGEgZmlsZSByZXNvdXJjZQotd2lsbCBiZSBwdWJsaXNoZWQgb3Igbm90IChub3RlOiBwdWJsaXNoaW5nIGluY2x1ZGVzIGZpbGUgZGVsZXRpb25zIGFzIHdlbGwgYXMKLWZpbGUgY3JlYXRpb25zIGFuZCBtb2RpZmljYXRpb25zKS4gUHVibGlzaCBtYW5hZ2VycyBhcmUgZGVjbGFyZWQgdmlhIHRoZQotb3JnLmVjbGlwc2Uud3RwLnNlcnZlci5jb3JlLnB1Ymxpc2ggZXh0ZW5zaW9uIHBvaW50LgotU2VydmVyQ29yZS5nZXRQdWJsaXNoTWFuYWdlcnMoKSByZXR1cm5zIGxpc3Qgb2Yga25vdyBwdWJsaXNoIG1hbmFnZXJzLiBUaGVyZSBhcmUKLXR3byBidWlsZC1pbiBoZWFkbGVzcyBwdWJsaXNoIG1hbmFnZXJzLiBUaGUgRnVsbCBQdWJsaXNoIE1hbmFnZXIgaXMgZHVtYiwgYW5kCi1wdWJsaXNoZXMgYWxsIG9mIHRoZSBtb2R1bGUncyByZXNvdXJjZSBmcm9tIHdvcmtzcGFjZSB0byBzZXJ2ZXIuIFRoZSBTbWFydAotUHVibGlzaCBNYW5hZ2VyIG9ubHkgcHVibGlzaGVzIG1vZHVsZSByZXNvdXJjZXMgdGhhdCBoYXZlIGJlZW4gY3JlYXRlZCwgY2hhbmdlZCwKLW9yIGRlbGV0ZWQgaW4gdGhlIHdvcmtzcGFjZSwgb3Igb25lcyB0aGF0IGhhdmUgYmVlbiBjaGFuZ2VkIChzb21laG93KSBvbiB0aGUKLXNlcnZlci4gQSBwdWJsaXNoIG9wZXJhdGlvbiBpbml0aWF0ZWQgYnkgSVNlcnZlci5wdWJsaXNoKElQcm9ncmVzc01vbml0b3IKLW1vbml0b3IpIHVzZXMgdGhlIHN5c3RlbS13aWRlIGRlZmF1bHQgcHVibGlzaCBtYW5hZ2VyLCB3aGljaCBkZWZhdWx0cyB0byB0aGUKLVNtYXJ0IFB1Ymxpc2ggTWFuYWdlci4gKFRoZXJlJ3MgYWxzbyBhIFZpc3VhbCBQdWJsaXNoIE1hbmFnZXIgdGhhdCBsZXRzIHRoZSB1c2VyCi1waWNrIGFuZCBjaG9vc2Ugd2hpY2ggZmlsZXMgdG8gcHVibGlzaC4pPC9wPgotPHA+QSA8Yj5wdWJsaXNoZXI8L2I+IChJUHVibGlzaGVyKSBpcyBhbiBvYmplY3QgdGhhdCBhY3R1YWxseSBwdWJsaXNoZXMgdGhlIGZpbGUKLW9mIGEgcGFydGljdWxhciBtb2R1bGUgdG8gYSBwYXJ0aWN1bGFyIHNlcnZlci4gRWFjaCBzZXJ2ZXIgdHlwZSBpbXBsZW1lbnRzIGl0cwotb3duIHB1Ymxpc2hlcnMuIE9uIGEgcGFydGljdWxhciBvY2Nhc2lvbiwgdGhlIElTZXJ2ZXJEZWxlZ2F0ZS5nZXRQdWJsaXNoZXIoTGlzdAotcGFyZW50cywgSU1vZHVsZSBtb2R1bGUpIHJldHVybnMgdGhlIHB1Ymxpc2hlciB0byB1c2UgdG8gcHVibGlzaCB0aGUgZmlsZXMgb2YKLXRoZSBnaXZlbiBtb2R1bGUuIElQdWJsaXNoZXIucHVibGlzaChJTW9kdWxlUmVzb3VyY2VbXSByZXNvdXJjZSwKLUlQcm9ncmVzc01vbml0b3IgbW9uaXRvcikgYW5kIElQdWJsaXNoZXIuZGVsZXRlKElSZW1vdGVSZXNvdXJjZVtdIHJlc291cmNlLAotSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSBkbyB0aGUgaGVhdnkgbGlmdGluZy48L3A+Ci08cD5UaGUgY2xpZW50IEFQSSBleHBvc2VzOjwvcD4KLTx1bD4KLSAgPGxpPlNlcnZlciBydW50aW1lIHR5cGVzIGFzIElSdW50aW1lVHlwZS4gU2VydmVyQ29yZS5nZXRSdW50aW1lVHlwZXMoKSByZXR1cm5zCi0gICAgYWxsIGtub3duIHNlcnZlciBydW50aW1lIHR5cGVzLjwvbGk+Ci0gIDxsaT5TZXJ2ZXIgdHlwZXMgYXMgSVNlcnZlclR5cGUuIFNlcnZlckNvcmUuZ2V0U2VydmVyVHlwZXMoKSByZXR1cm5zIGFsbCBrbm93bgotICAgIHNlcnZlciB0eXBlcy4mbmJzcDs8L2xpPgotICA8bGk+U2VydmVyIGNvbmZpZ3VyYXRpb24gdHlwZXMgYXMgSVNlcnZlckNvbmZpZ3VyYXRpb25UeXBlLgotICAgIFNlcnZlckNvcmUuZ2V0U2VydmVyQ29uZmlndXJhdGlvblR5cGVzKCkgcmV0dXJucyBhbGwga25vd24gc2VydmVyCi0gICAgY29uZmlndXJhdGlvbiB0eXBlcy48L2xpPgotICA8bGk+TW9kdWxlIHR5cGVzIGFzIElNb2R1bGVLaW5kLiBTZXJ2ZXJDb3JlLmdldE1vZHVsZUtpbmRzKCkgcmV0dXJucyBhbGwga25vd24KLSAgICBtb2R1bGUga2luZHMuPC9saT4KLTwvdWw+Ci08cD5UaGUgdHlwZS1sZXZlbCByZWxhdGlvbnNoaXBzIGFyZTo8L3A+Ci08dWw+Ci0gIDxsaT5hIHNlcnZlciB0eXBlIGhhcyBhIHNlcnZlciBydW50aW1lIHR5cGU7IHRoaXMgaXMgdGhlIHR5cGUgb2Ygc2VydmVyCi0gICAgcnVudGltZSByZXF1aXJlZCB0byBydW4gdGhlIHNlcnZlcjsgZXhwb3NlZCBhcyBJU2VydmVyVHlwZS5nZXRSdW50aW1lVHlwZSgpPC9saT4KLSAgPGxpPmEgc2VydmVyIHR5cGUgaGFzIGFuIG9wdGlvbmFsIHNlcnZlciBjb25maWd1cmF0aW9uIHR5cGU7IHRoaXMgaXMgdGhlIHR5cGUKLSAgICBvZiBzZXJ2ZXIgY29uZmlndXJhdGlvbiByZXF1aXJlZCB0byBjb25maWd1cmUgdGhlIHNlcnZlcjsgZXhwb3NlZCBhcwotICAgIElTZXJ2ZXJUeXBlLmdldFNlcnZlckNvbmZpZ3VyYXRpb25UeXBlKCk8L2xpPgotICA8bGk+YSBzZXJ2ZXIgcnVudGltZSB0eXBlIHN1cHBvcnRzIDAgb3IgbW9yZSBtb2R1bGUgdHlwZXM7IGV4cG9zZWQgYXMKLSAgICBJUnVudGltZVR5cGUuZ2V0TW9kdWxlVHlwZXMoKTwvbGk+Ci08L3VsPgotPHA+VGhlIEFQSSBleHBvc2VzIHNlcnZlciBydW50aW1lIGluc3RhbmNlcyBhcyBJUnVudGltZS4mbmJzcDsKLVNlcnZlckNvcmUuZ2V0UmVzb3VyY2VNYW5hZ2VyKCkuZ2V0UnVudGltZXMoKSByZXR1cm5zIGFsbCBrbm93biBzZXJ2ZXIgcnVudGltZQotaW5zdGFuY2VzLiBTZXJ2ZXIgcnVudGltZSBpbnN0YW5jZXMgYXJlIGNyZWF0ZWQgKG9ubHkpIGZyb20gc2VydmVyIHJ1bnRpbWUgdHlwZXMKLWJ5IElSdW50aW1lVHlwZS5jcmVhdGVSdW50aW1lKFN0cmluZyBpZCksIHdoaWNoIHJldHVybnMgYW4gSVJ1bnRpbWVXb3JraW5nQ29weS4KLUFueSBudW1iZXIgb2YgYXNwZWN0cyBvZiB0aGUgc2VydmVyIHJ1bnRpbWUgaW5zdGFuY2UgKGluY2x1ZGluZyBsb2NhdGlvbiBpbiB0aGUKLWZpbGUgc3lzdGVtKSBjYW4gYmUgZXN0YWJsaXNoZWQgb3IgYWRqdXN0ZWQgZnJvbSB0aGVpciBkZWZhdWx0cy4gV2hlbiBlZGl0aW5nIGlzCi1jb21wbGV0ZSwgSVJ1bnRpbWVXb3JraW5nQ29weS5zYXZlKElQcm9ncmVzc01vbml0b3IgbW9uaXRvcikgY3JlYXRlcywgcmVnaXN0ZXJzLAotcmV0dXJucyBhIHNlcnZlciBydW50aW1lIGluc3RhbmNlIChJUnVudGltZSkgY2FwdHVyaW5nIHRoZSBkZXNpcmVkIHNldHRpbmdzICh0aGUKLXdvcmtpbmcgY29weSBpcyBkaXNwb3NlZCBvZikuPC9wPgotPHA+VGhlIEFQSSBleHBvc2VzIHNlcnZlciBjb25maWd1cmF0aW9uIGluc3RhbmNlcyBhcyBJU2VydmVyQ29uZmlndXJhdGlvbi4KLVNlcnZlckNvcmUuZ2V0UmVzb3VyY2VNYW5hZ2VyKCkuZ2V0U2VydmVyQ29uZmlndXJhdGlvbnMoKSByZXR1cm5zIGFsbCBrbm93bgotc2VydmVyIGNvbmZpZ3VyYXRpb24gaW5zdGFuY2VzLiBTZXJ2ZXIgY29uZmlndXJhdGlvbiBpbnN0YW5jZXMgYXJlIGNyZWF0ZWQKLShvbmx5KSBmcm9tIHNlcnZlciB0eXBlcyBieQotSVNlcnZlckNvbmZpZ3VyYXRpb25UeXBlLmNyZWF0ZVNlcnZlckNvbmZpZ3VyYXRpb24oU3RyaW5nIGlkLCBJRmlsZSBmaWxlLAotSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSBvciBJU2VydmVyQ29uZmlndXJhdGlvblR5cGUuaW1wb3J0RnJvbVBhdGgoU3RyaW5nIGlkLAotSUZpbGUgZmlsZSwgSVBhdGggcGF0aCwgSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSBvcgotSVNlcnZlckNvbmZpZ3VyYXRpb25UeXBlLmltcG9ydEZyb21SdW50aW1lKFN0cmluZyBpZCwgSUZpbGUgZmlsZSwgSVJ1bnRpbWUKLXJ1bnRpbWUsIElQcm9ncmVzc01vbml0b3IgbW9uaXRvcikuIFRoZSBmaWxlIHBhcmFtZXRlciBpcyB1c2VkIHRvIGNvbnRyb2wgd2hlcmUKLXRoZSBzZXJ2ZXIgY29uZmlndXJhdGlvbiBpbnN0YW5jZSBpcyBzZXJpYWxpemVkLiBBbGwgMyByZXR1cm4gYW4KLUlTZXJ2ZXJDb25maWd1cmF0aW9uV29ya2luZ0NvcHkuIChUaGVyZSBhcmUgbm8gYXNwZWN0cyBvZiB0aGUgc2VydmVyCi1jb25maWd1cmF0aW9uIGluc3RhbmNlIHRvIGFkanVzdC4pCi1JU2VydmVyQ29uZmlndXJhdGlvbldvcmtpbmdDb3B5LnNhdmUoSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSBjcmVhdGVzLAotcmVnaXN0ZXJzLCByZXR1cm5zIGEgc2VydmVyIGNvbmZpZ3VyYXRpb24gaW5zdGFuY2UgKElTZXJ2ZXJDb25maWd1cmF0aW9uKQotY2FwdHVyaW5nIHRoZSBkZXNpcmVkIHNldHRpbmdzICh0aGUgd29ya2luZyBjb3B5IGlzIGRpc3Bvc2VkIG9mKS4mbmJzcDs8L3A+Ci08cD5UaGUgQVBJIGV4cG9zZXMgc2VydmVyIGluc3RhbmNlcyBhcyBJU2VydmVyLgotU2VydmVyQ29yZS5nZXRSZXNvdXJjZU1hbmFnZXIoKS5nZXRTZXJ2ZXJzKCkgcmV0dXJucyBhbGwga25vd24gc2VydmVyIGluc3RhbmNlcy4KLVNlcnZlciBpbnN0YW5jZXMgYXJlIGNyZWF0ZWQgKG9ubHkpIGZyb20gc2VydmVyIHR5cGVzIGJ5Ci1JU2VydmVyVHlwZS5jcmVhdGVTZXJ2ZXIoU3RyaW5nIGlkLCBJRmlsZSBmaWxlLCBJUnVudGltZSBydW50aW1lLAotSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSBvciBJU2VydmVyVHlwZS5jcmVhdGVTZXJ2ZXIoU3RyaW5nIGlkLCBJRmlsZSBmaWxlLAotSVJ1bnRpbWUgcnVudGltZSwgSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKS4gVGhlIGZpbGUgcGFyYW1ldGVyIGlzIHVzZWQgdG8KLWNvbnRyb2wgd2hlcmUgdGhlIHNlcnZlciBpbnN0YW5jZSBpcyBzZXJpYWxpemVkLiBCb3RoIHJldHVybiBhbgotSVNlcnZlcldvcmtpbmdDb3B5LiBBbnkgbnVtYmVyIG9mIGFzcGVjdHMgb2YgdGhlIHNlcnZlciBpbnN0YW5jZSAoaG9zdCBuYW1lLAotc2VydmVyIHJ1bnRpbWUsIHNlcnZlciBjb25maWd1cmF0aW9uLCBtb2R1bGVzLCAuLi4pIGNhbiBiZSBlc3RhYmxpc2hlZCBvcgotYWRqdXN0ZWQgZnJvbSB0aGVpciBkZWZhdWx0cy4gV2hlbiBlZGl0aW5nIGlzIGNvbXBsZXRlLAotSVNlcnZlcldvcmtpbmdDb3B5LnNhdmUoSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSBjcmVhdGVzLCByZWdpc3RlcnMsIHJldHVybnMgYQotc2VydmVyIGluc3RhbmNlIChJU2VydmVyKSBjYXB0dXJpbmcgdGhlIGRlc2lyZWQgc2V0dGluZ3MgKHRoZSB3b3JraW5nIGNvcHkgaXMKLWRpc3Bvc2VkIG9mKS4mbmJzcDs8L3A+Ci08cD5UaGUgaW5zdGFuY2UtbGV2ZWwgcmVsYXRpb25zaGlwIGJldHdlZW4gc2VydmVycyBhbmQgc2VydmVyIHJ1bnRpbWVzIGFuZAotc2VydmVyIGNvbmZpZ3VyYXRpb25zIGlzIGV4cG9zZWQgYXQgdGhlIEFQSTogZm9yIGEgZ2l2ZW4gc2VydmVyLAotSVNlcnZlci5nZXRSdW50aW1lKCkgcmV0dXJucyB0aGUgc2VydmVyIHJ1bnRpbWUgKElSdW50aW1lKSwKLUlTZXJ2ZXIuZ2V0U2VydmVyQ29uZmlndXJhdGlvbigpIHJldHVybnMgdGhlIHNlcnZlciBjb25maWd1cmF0aW9uIChJU2VydmVyQ29uZmlndXJhdGlvbikuPC9wPgotPHA+SVNlcnZlci5zdGFydChTdHJpbmcgbW9kZSwgSVByb2dyZXNzTW9uaXRvciBtb25pdG9yKSwgc3RvcCgpLCBhbmQKLXJlc3RhcnQoU3RyaW5nIG1vZGUpIGFyZSB1c2VkIHRvIHN0YXJ0LCBzdG9wLCBhbmQgcmVzdGFydCBhIHNlcnZlciwgcmVzcGVjdGl2ZWx5Ci0odGhlcmUgYXJlIGFsc28gc3luY2hyb25vdXMgbWV0aG9kcyBmb3Igc3RhcnRpbmcgYW5kIHN0b3BwaW5nKS4gVGhlIHByZWRpY2F0ZXMKLUlTZXJ2ZXIuY2FuU3RhcnQoU3RyaW5nIG1vZGUpLCBjYW5SZXN0YXJ0KFN0cmluZyBtb2RlKSwgYW5kIGNhblN0b3AoKSBpbmRpY2F0ZQotd2hldGhlciB0aGUgc2VydmVyIGlzIHJlY2VwdGl2ZSB0byBiZWluZyBjb250cm9sbGVkLiBJU2VydmVyLmdldFNlcnZlclN0YXRlKCkKLWNhbiBiZSB1c2VkIHRvIHF1ZXJ5IHRoZSBvdmVyYWxsIHN0YXRlIG9mIHRoZSBzZXJ2ZXIgKG9uZSBvZiBzdGFydGluZywgc3RhcnRlZCwKLXN0b3BwaW5nLCBzdG9wcGVkLCBvciB1bmtub3duKSwgYW5kIElTZXJ2ZXIuZ2V0TW9kdWxlU3RhdGUoSU1vZHVsZSBtb2R1bGUpIGNhbgotYmUgdXNlZCB0byBxdWVyeSB0aGUgc3RhdGUgb2YgYW55IG9mIGl0cyBtb2R1bGVzLjwvcD4KLQotPC9ib2R5PgotCi08L2h0bWw+Cg==