LyoKICogTm9uLWNsaWVudCBhcmVhIHdpbmRvdyBmdW5jdGlvbnMKICoKICogQ29weXJpZ2h0IDE5OTQgQWxleGFuZHJlIEp1bGxpYXJkCiAqCiAqLwoKI2luY2x1ZGUgIndpbmRlZi5oIgojaW5jbHVkZSAid2luZ2RpLmgiCiNpbmNsdWRlICJ3aW5lL3dpbnVzZXIxNi5oIgojaW5jbHVkZSAidmVyc2lvbi5oIgojaW5jbHVkZSAid2luLmgiCiNpbmNsdWRlICJtZXNzYWdlLmgiCiNpbmNsdWRlICJ1c2VyLmgiCiNpbmNsdWRlICJoZWFwLmgiCiNpbmNsdWRlICJkY2UuaCIKI2luY2x1ZGUgImN1cnNvcmljb24uaCIKI2luY2x1ZGUgImRpYWxvZy5oIgojaW5jbHVkZSAibWVudS5oIgojaW5jbHVkZSAid2lucG9zLmgiCiNpbmNsdWRlICJob29rLmgiCiNpbmNsdWRlICJzY3JvbGwuaCIKI2luY2x1ZGUgIm5vbmNsaWVudC5oIgojaW5jbHVkZSAicXVldWUuaCIKI2luY2x1ZGUgInNlbGVjdG9ycy5oIgojaW5jbHVkZSAidHdlYWsuaCIKI2luY2x1ZGUgImRlYnVndG9vbHMuaCIKI2luY2x1ZGUgIm9wdGlvbnMuaCIKI2luY2x1ZGUgInNoZWxsYXBpLmgiCiNpbmNsdWRlICJjYWNoZS5oIgojaW5jbHVkZSAiYml0bWFwLmgiCgpERUZBVUxUX0RFQlVHX0NIQU5ORUwobm9uY2xpZW50KQpERUNMQVJFX0RFQlVHX0NIQU5ORUwoc2hlbGwpCgpCT09MIE5DX0RyYXdHcmF5QnV0dG9uKEhEQyBoZGMsIGludCB4LCBpbnQgeSk7CgpzdGF0aWMgSEJJVE1BUDE2IGhiaXRtYXBDbG9zZSA9IDA7CnN0YXRpYyBIQklUTUFQMTYgaGJpdG1hcENsb3NlRCA9IDA7CnN0YXRpYyBIQklUTUFQMTYgaGJpdG1hcE1pbmltaXplID0gMDsKc3RhdGljIEhCSVRNQVAxNiBoYml0bWFwTWluaW1pemVEID0gMDsKc3RhdGljIEhCSVRNQVAxNiBoYml0bWFwTWF4aW1pemUgPSAwOwpzdGF0aWMgSEJJVE1BUDE2IGhiaXRtYXBNYXhpbWl6ZUQgPSAwOwpzdGF0aWMgSEJJVE1BUDE2IGhiaXRtYXBSZXN0b3JlID0gMDsKc3RhdGljIEhCSVRNQVAxNiBoYml0bWFwUmVzdG9yZUQgPSAwOwoKQllURSBscEdyYXlNYXNrW10gPSB7IDB4QUEsIDB4QTAsCgkJICAgICAgMHg1NSwgMHg1MCwgIAoJCSAgICAgIDB4QUEsIDB4QTAsCgkJICAgICAgMHg1NSwgMHg1MCwgIAoJCSAgICAgIDB4QUEsIDB4QTAsCgkJICAgICAgMHg1NSwgMHg1MCwgIAoJCSAgICAgIDB4QUEsIDB4QTAsCgkJICAgICAgMHg1NSwgMHg1MCwgIAoJCSAgICAgIDB4QUEsIDB4QTAsCgkJICAgICAgMHg1NSwgMHg1MH07CgojZGVmaW5lIFNDX0FCT1VUV0lORSAgICAJKFNDX1NDUkVFTlNBVkUrMSkKI2RlZmluZSBTQ19QVVRNQVJLICAgICAJCShTQ19TQ1JFRU5TQVZFKzIpCgogIC8qIFNvbWUgdXNlZnVsIG1hY3JvcyAqLwojZGVmaW5lIEhBU19ETEdGUkFNRShzdHlsZSxleFN0eWxlKSBcCiAgICAoKChleFN0eWxlKSAmIFdTX0VYX0RMR01PREFMRlJBTUUpIHx8IFwKICAgICAoKChzdHlsZSkgJiBXU19ETEdGUkFNRSkgJiYgISgoc3R5bGUpICYgV1NfVEhJQ0tGUkFNRSkpKQoKI2RlZmluZSBIQVNfVEhJQ0tGUkFNRShzdHlsZSxleFN0eWxlKSBcCiAgICAoKChzdHlsZSkgJiBXU19USElDS0ZSQU1FKSAmJiBcCiAgICAgISgoKHN0eWxlKSAmIChXU19ETEdGUkFNRXxXU19CT1JERVIpKSA9PSBXU19ETEdGUkFNRSkpCgojZGVmaW5lIEhBU19USElORlJBTUUoc3R5bGUpIFwKICAgICgoKHN0eWxlKSAmIFdTX0JPUkRFUikgfHwgISgoc3R5bGUpICYgKFdTX0NISUxEIHwgV1NfUE9QVVApKSkKCiNkZWZpbmUgSEFTX0JJR0ZSQU1FKHN0eWxlLGV4U3R5bGUpIFwKICAgICgoKHN0eWxlKSAmIChXU19USElDS0ZSQU1FIHwgV1NfRExHRlJBTUUpKSB8fCBcCiAgICAgKChleFN0eWxlKSAmIFdTX0VYX0RMR01PREFMRlJBTUUpKQoKI2RlZmluZSBIQVNfQU5ZRlJBTUUoc3R5bGUsZXhTdHlsZSkgXAogICAgKCgoc3R5bGUpICYgKFdTX1RISUNLRlJBTUUgfCBXU19ETEdGUkFNRSB8IFdTX0JPUkRFUikpIHx8IFwKICAgICAoKGV4U3R5bGUpICYgV1NfRVhfRExHTU9EQUxGUkFNRSkgfHwgXAogICAgICEoKHN0eWxlKSAmIChXU19DSElMRCB8IFdTX1BPUFVQKSkpCgojZGVmaW5lIEhBU19NRU5VKHcpICAoISgodyktPmR3U3R5bGUgJiBXU19DSElMRCkgJiYgKCh3KS0+d0lEbWVudSAhPSAwKSkKCiNkZWZpbmUgT05fTEVGVF9CT1JERVIoaGl0KSBcCiAoKChoaXQpID09IEhUTEVGVCkgfHwgKChoaXQpID09IEhUVE9QTEVGVCkgfHwgKChoaXQpID09IEhUQk9UVE9NTEVGVCkpCiNkZWZpbmUgT05fUklHSFRfQk9SREVSKGhpdCkgXAogKCgoaGl0KSA9PSBIVFJJR0hUKSB8fCAoKGhpdCkgPT0gSFRUT1BSSUdIVCkgfHwgKChoaXQpID09IEhUQk9UVE9NUklHSFQpKQojZGVmaW5lIE9OX1RPUF9CT1JERVIoaGl0KSBcCiAoKChoaXQpID09IEhUVE9QKSB8fCAoKGhpdCkgPT0gSFRUT1BMRUZUKSB8fCAoKGhpdCkgPT0gSFRUT1BSSUdIVCkpCiNkZWZpbmUgT05fQk9UVE9NX0JPUkRFUihoaXQpIFwKICgoKGhpdCkgPT0gSFRCT1RUT00pIHx8ICgoaGl0KSA9PSBIVEJPVFRPTUxFRlQpIHx8ICgoaGl0KSA9PSBIVEJPVFRPTVJJR0hUKSkKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgV0lOX1dpbmRvd05lZWRzV01Cb3JkZXIKICoKICogVGhpcyBtZXRob2QgZGVmaW5lcyB0aGUgcnVsZXMgZm9yIGEgd2luZG93IHRvIGhhdmUgYSBXTSBib3JkZXIsCiAqIGNhcHRpb24uLi4gIEl0IGlzIHVzZWQgZm9yIGNvbnNpdGVuY3kgcHVycG9zZXMuCiAqLwpCT09MIFdJTl9XaW5kb3dOZWVkc1dNQm9yZGVyKCBEV09SRCBzdHlsZSwgRFdPUkQgZXhTdHlsZSApCnsKICAgIGlmICghKHN0eWxlICYgV1NfQ0hJTEQpICYmIAoJT3B0aW9ucy5tYW5hZ2VkICAmJgoJIShleFN0eWxlICYgV1NfRVhfVE9PTFdJTkRPVykgJiYKICAgICAgICAoICgoc3R5bGUgJiBXU19DQVBUSU9OKSA9PSBXU19DQVBUSU9OKSB8fAoJICAoc3R5bGUgJiBXU19USElDS0ZSQU1FKSkpCiAgICAgICAgcmV0dXJuIFRSVUU7CiAgICBpZiAoZXhTdHlsZSAmIFdTX0VYX1RSQVlXSU5ET1cpCglyZXR1cm4gVFJVRTsKICAgIHJldHVybiBGQUxTRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBOQ19BZGp1c3RSZWN0CiAqCiAqIENvbXB1dGUgdGhlIHNpemUgb2YgdGhlIHdpbmRvdyByZWN0YW5nbGUgZnJvbSB0aGUgc2l6ZSBvZiB0aGUKICogY2xpZW50IHJlY3RhbmdsZS4KICovCnN0YXRpYyB2b2lkIE5DX0FkanVzdFJlY3QoIExQUkVDVDE2IHJlY3QsIERXT1JEIHN0eWxlLCBCT09MIG1lbnUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgIERXT1JEIGV4U3R5bGUgKQp7CiAgICBpZiAoVFdFQUtfV2luZUxvb2sgPiBXSU4zMV9MT09LKQoJRVJSKCJDYWxsZWQgaW4gV2luOTUgbW9kZS4gQWllZSEgUGxlYXNlIHJlcG9ydCB0aGlzLlxuIiApOwoKICAgIGlmKHN0eWxlICYgV1NfSUNPTklDKSByZXR1cm47CiAgICAvKiBEZWNpZGUgaWYgdGhlIHdpbmRvdyB3aWxsIGJlIG1hbmFnZWQgKHNlZSBDcmVhdGVXaW5kb3dFeCkgKi8KICAgIGlmICghV0lOX1dpbmRvd05lZWRzV01Cb3JkZXIoc3R5bGUsIGV4U3R5bGUpKQogICAgewogICAgICAgIGlmIChIQVNfVEhJQ0tGUkFNRSggc3R5bGUsIGV4U3R5bGUgKSkKICAgICAgICAgICAgSW5mbGF0ZVJlY3QxNiggcmVjdCwgR2V0U3lzdGVtTWV0cmljcyhTTV9DWEZSQU1FKSwgR2V0U3lzdGVtTWV0cmljcyhTTV9DWUZSQU1FKSApOwogICAgICAgIGVsc2UKICAgICAgICBpZiAoSEFTX0RMR0ZSQU1FKCBzdHlsZSwgZXhTdHlsZSApKQogICAgICAgICAgICBJbmZsYXRlUmVjdDE2KCByZWN0LCBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYRExHRlJBTUUpLCBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZRExHRlJBTUUpICk7CiAgICAgICAgZWxzZQogICAgICAgIGlmIChIQVNfVEhJTkZSQU1FKCBzdHlsZSApKQogICAgICAgICAgICBJbmZsYXRlUmVjdDE2KCByZWN0LCBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYQk9SREVSKSwgR2V0U3lzdGVtTWV0cmljcyhTTV9DWUJPUkRFUikpOwoKICAgICAgICBpZiAoKHN0eWxlICYgV1NfQ0FQVElPTikgPT0gV1NfQ0FQVElPTikKICAgICAgICAgICAgcmVjdC0+dG9wIC09IEdldFN5c3RlbU1ldHJpY3MoU01fQ1lDQVBUSU9OKSAtIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lCT1JERVIpOwogICAgfQogICAgaWYgKG1lbnUpIHJlY3QtPnRvcCAtPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZTUVOVSkgKyBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZQk9SREVSKTsKCiAgICBpZiAoc3R5bGUgJiBXU19WU0NST0xMKSB7CiAgICAgIHJlY3QtPnJpZ2h0ICArPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYVlNDUk9MTCkgLSAxOwogICAgICBpZighSEFTX0FOWUZSQU1FKCBzdHlsZSwgZXhTdHlsZSApKQoJIHJlY3QtPnJpZ2h0Kys7CiAgICB9CgogICAgaWYgKHN0eWxlICYgV1NfSFNDUk9MTCkgewogICAgICByZWN0LT5ib3R0b20gKz0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWUhTQ1JPTEwpIC0gMTsKICAgICAgaWYoIUhBU19BTllGUkFNRSggc3R5bGUsIGV4U3R5bGUgKSkKCSByZWN0LT5ib3R0b20rKzsKICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogTkNfQWRqdXN0UmVjdE91dGVyOTUKICoKICogQ29tcHV0ZXMgdGhlIHNpemUgb2YgdGhlICJvdXRzaWRlIiBwYXJ0cyBvZiB0aGUgd2luZG93IGJhc2VkIG9uIHRoZQogKiBwYXJhbWV0ZXJzIG9mIHRoZSBjbGllbnQgYXJlYS4KICoKICsgUEFSQU1TCiAqICAgICBMUFJFQ1QxNiAgcmVjdAogKiAgICAgRFdPUkQgIHN0eWxlCiAqICAgICBCT09MICBtZW51CiAqICAgICBEV09SRCAgZXhTdHlsZQogKgogKiBOT1RFUwogKiAgICAgIk91dGVyIiBwYXJ0cyBvZiBhIHdpbmRvdyBtZWFucyB0aGUgd2hvbGUgd2luZG93IGZyYW1lLCBjYXB0aW9uIGFuZAogKiAgICAgbWVudSBiYXIuIEl0IGRvZXMgbm90IGluY2x1ZGUgImlubmVyIiBwYXJ0cyBvZiB0aGUgZnJhbWUgbGlrZSBjbGllbnQKICogICAgIGVkZ2UsIHN0YXRpYyBlZGdlIG9yIHNjcm9sbCBiYXJzLgogKgogKiBSZXZpc2lvbiBoaXN0b3J5CiAqICAgICAwNS1KdWwtMTk5NyBEYXZlIEN1dGhiZXJ0IChkYWN1dEBlY2UuY211LmVkdSkKICogICAgICAgIE9yaWdpbmFsIChOQ19BZGp1c3RSZWN0OTUpIGN1dCAmIHBhc3RlIGZyb20gTkNfQWRqdXN0UmVjdAogKgogKiAgICAgMjAtSnVuLTE5OTggRXJpYyBLb2hsIChla29obEBhYm8ucmhlaW4temVpdHVuZy5kZSkKICogICAgICAgIFNwbGl0IE5DX0FkanVzdFJlY3Q5NSBpbnRvIE5DX0FkanVzdFJlY3RPdXRlcjk1IGFuZAogKiAgICAgICAgTkNfQWRqdXN0UmVjdElubmVyOTUgYW5kIGFkZGVkIGhhbmRsaW5nIG9mIFdpbjk1IHN0eWxlcy4KICoKICogICAgIDI4LUp1bC0xOTk5IE92ZSBL5XZlbiAob3Zla0BhcmN0aWNuZXQubm8pCiAqICAgICAgICBTdHJlYW1saW5lZCB3aW5kb3cgc3R5bGUgY2hlY2tzLgogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgpzdGF0aWMgdm9pZApOQ19BZGp1c3RSZWN0T3V0ZXI5NSAoTFBSRUNUMTYgcmVjdCwgRFdPUkQgc3R5bGUsIEJPT0wgbWVudSwgRFdPUkQgZXhTdHlsZSkKewogICAgaWYoc3R5bGUgJiBXU19JQ09OSUMpIHJldHVybjsKCiAgICAvKiBEZWNpZGUgaWYgdGhlIHdpbmRvdyB3aWxsIGJlIG1hbmFnZWQgKHNlZSBDcmVhdGVXaW5kb3dFeCkgKi8KICAgIGlmICghV0lOX1dpbmRvd05lZWRzV01Cb3JkZXIoc3R5bGUsIGV4U3R5bGUpKQogICAgewogICAgICAgIGlmIChIQVNfVEhJQ0tGUkFNRSggc3R5bGUsIGV4U3R5bGUgKSkKICAgICAgICAgICAgSW5mbGF0ZVJlY3QxNiggcmVjdCwgR2V0U3lzdGVtTWV0cmljcyhTTV9DWEZSQU1FKSwgR2V0U3lzdGVtTWV0cmljcyhTTV9DWUZSQU1FKSApOwogICAgICAgIGVsc2UKICAgICAgICBpZiAoSEFTX0RMR0ZSQU1FKCBzdHlsZSwgZXhTdHlsZSApKQogICAgICAgICAgICBJbmZsYXRlUmVjdDE2KHJlY3QsIEdldFN5c3RlbU1ldHJpY3MoU01fQ1hETEdGUkFNRSksIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lETEdGUkFNRSkgKTsKICAgICAgICBlbHNlCiAgICAgICAgaWYgKEhBU19USElORlJBTUUoIHN0eWxlICkpCiAgICAgICAgICAgIEluZmxhdGVSZWN0MTYoIHJlY3QsIEdldFN5c3RlbU1ldHJpY3MoU01fQ1hCT1JERVIpLCBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZQk9SREVSKSk7CgogICAgICAgIGlmICgoc3R5bGUgJiBXU19DQVBUSU9OKSA9PSBXU19DQVBUSU9OKQogICAgICAgIHsKCSAgICBpZiAoZXhTdHlsZSAmIFdTX0VYX1RPT0xXSU5ET1cpCgkJcmVjdC0+dG9wIC09IEdldFN5c3RlbU1ldHJpY3MoU01fQ1lTTUNBUFRJT04pOwoJICAgIGVsc2UKCQlyZWN0LT50b3AgLT0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWUNBUFRJT04pOwogICAgICAgIH0KICAgIH0KCiAgICBpZiAobWVudSkKCXJlY3QtPnRvcCAtPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZTUVOVSk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIE5DX0FkanVzdFJlY3RJbm5lcjk1CiAqCiAqIENvbXB1dGVzIHRoZSBzaXplIG9mIHRoZSAiaW5zaWRlIiBwYXJ0IG9mIHRoZSB3aW5kb3cgYmFzZWQgb24gdGhlCiAqIHBhcmFtZXRlcnMgb2YgdGhlIGNsaWVudCBhcmVhLgogKgogKyBQQVJBTVMKICogICAgIExQUkVDVDE2IHJlY3QKICogICAgIERXT1JEICAgIHN0eWxlCiAqICAgICBEV09SRCAgICBleFN0eWxlCiAqCiAqIE5PVEVTCiAqICAgICAiSW5uZXIiIHBhcnQgb2YgYSB3aW5kb3cgbWVhbnMgdGhlIHdpbmRvdyBmcmFtZSBpbnNpZGUgb2YgdGhlIGZsYXQKICogICAgIHdpbmRvdyBmcmFtZS4gSXQgaW5jbHVkZXMgdGhlIGNsaWVudCBlZGdlLCB0aGUgc3RhdGljIGVkZ2UgYW5kIHRoZQogKiAgICAgc2Nyb2xsIGJhcnMuCiAqCiAqIFJldmlzaW9uIGhpc3RvcnkKICogICAgIDA1LUp1bC0xOTk3IERhdmUgQ3V0aGJlcnQgKGRhY3V0QGVjZS5jbXUuZWR1KQogKiAgICAgICAgT3JpZ2luYWwgKE5DX0FkanVzdFJlY3Q5NSkgY3V0ICYgcGFzdGUgZnJvbSBOQ19BZGp1c3RSZWN0CiAqCiAqICAgICAyMC1KdW4tMTk5OCBFcmljIEtvaGwgKGVrb2hsQGFiby5yaGVpbi16ZWl0dW5nLmRlKQogKiAgICAgICAgU3BsaXQgTkNfQWRqdXN0UmVjdDk1IGludG8gTkNfQWRqdXN0UmVjdE91dGVyOTUgYW5kCiAqICAgICAgICBOQ19BZGp1c3RSZWN0SW5uZXI5NSBhbmQgYWRkZWQgaGFuZGxpbmcgb2YgV2luOTUgc3R5bGVzLgogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgpzdGF0aWMgdm9pZApOQ19BZGp1c3RSZWN0SW5uZXI5NSAoTFBSRUNUMTYgcmVjdCwgRFdPUkQgc3R5bGUsIERXT1JEIGV4U3R5bGUpCnsKICAgIGlmKHN0eWxlICYgV1NfSUNPTklDKSByZXR1cm47CgogICAgaWYgKGV4U3R5bGUgJiBXU19FWF9DTElFTlRFREdFKQoJSW5mbGF0ZVJlY3QxNiAocmVjdCwgR2V0U3lzdGVtTWV0cmljcyhTTV9DWEVER0UpLCBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZRURHRSkpOwoKICAgIGlmIChleFN0eWxlICYgV1NfRVhfU1RBVElDRURHRSkKCUluZmxhdGVSZWN0MTYgKHJlY3QsIEdldFN5c3RlbU1ldHJpY3MoU01fQ1hCT1JERVIpLCBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZQk9SREVSKSk7CgogICAgaWYgKHN0eWxlICYgV1NfVlNDUk9MTCkgcmVjdC0+cmlnaHQgICs9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1hWU0NST0xMKTsKICAgIGlmIChzdHlsZSAmIFdTX0hTQ1JPTEwpIHJlY3QtPmJvdHRvbSArPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZSFNDUk9MTCk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogRHJhd0NhcHRpb24xNiBbVVNFUi42NjBdIERyYXdzIGEgY2FwdGlvbiBiYXIKICoKICogUEFSQU1TCiAqICAgICBod25kICAgW0ldCiAqICAgICBoZGMgICAgW0ldCiAqICAgICBscFJlY3QgW0ldCiAqICAgICB1RmxhZ3MgW0ldCiAqCiAqIFJFVFVSTlMKICogICAgIFN1Y2Nlc3M6CiAqICAgICBGYWlsdXJlOgogKi8KCkJPT0wxNiBXSU5BUEkKRHJhd0NhcHRpb24xNiAoSFdORDE2IGh3bmQsIEhEQzE2IGhkYywgY29uc3QgUkVDVDE2ICpyZWN0LCBVSU5UMTYgdUZsYWdzKQp7CiAgICBSRUNUIHJlY3QzMjsKCiAgICBpZiAocmVjdCkKCUNPTlZfUkVDVDE2VE8zMiAocmVjdCwgJnJlY3QzMik7CgogICAgcmV0dXJuIChCT09MMTYpRHJhd0NhcHRpb25UZW1wQSAoaHduZCwgaGRjLCByZWN0ID8gJnJlY3QzMiA6IE5VTEwsCgkJCQkgICAgICAgMCwgMCwgTlVMTCwgdUZsYWdzICYgMHgxRik7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogRHJhd0NhcHRpb24gW1VTRVIzMi4xNTRdIERyYXdzIGEgY2FwdGlvbiBiYXIKICoKICogUEFSQU1TCiAqICAgICBod25kICAgW0ldCiAqICAgICBoZGMgICAgW0ldCiAqICAgICBscFJlY3QgW0ldCiAqICAgICB1RmxhZ3MgW0ldCiAqCiAqIFJFVFVSTlMKICogICAgIFN1Y2Nlc3M6CiAqICAgICBGYWlsdXJlOgogKi8KCkJPT0wgV0lOQVBJCkRyYXdDYXB0aW9uIChIV05EIGh3bmQsIEhEQyBoZGMsIGNvbnN0IFJFQ1QgKmxwUmVjdCwgVUlOVCB1RmxhZ3MpCnsKICAgIHJldHVybiBEcmF3Q2FwdGlvblRlbXBBIChod25kLCBoZGMsIGxwUmVjdCwgMCwgMCwgTlVMTCwgdUZsYWdzICYgMHgxRik7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogRHJhd0NhcHRpb25UZW1wMTYgW1VTRVIuNjU3XQogKgogKiBQQVJBTVMKICoKICogUkVUVVJOUwogKiAgICAgU3VjY2VzczoKICogICAgIEZhaWx1cmU6CiAqLwoKQk9PTDE2IFdJTkFQSQpEcmF3Q2FwdGlvblRlbXAxNiAoSFdORDE2IGh3bmQsIEhEQzE2IGhkYywgY29uc3QgUkVDVDE2ICpyZWN0LCBIRk9OVDE2IGhGb250LAoJCSAgIEhJQ09OMTYgaEljb24sIExQQ1NUUiBzdHIsIFVJTlQxNiB1RmxhZ3MpCnsKICAgIFJFQ1QgcmVjdDMyOwoKICAgIGlmIChyZWN0KQoJQ09OVl9SRUNUMTZUTzMyKHJlY3QsJnJlY3QzMik7CgogICAgcmV0dXJuIChCT09MMTYpRHJhd0NhcHRpb25UZW1wQSAoaHduZCwgaGRjLCByZWN0PyZyZWN0MzI6TlVMTCwgaEZvbnQsCgkJCQkgICAgICAgaEljb24sIHN0ciwgdUZsYWdzICYgMHgxRik7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogRHJhd0NhcHRpb25UZW1wQSBbVVNFUjMyLjU5OV0KICoKICogUEFSQU1TCiAqCiAqIFJFVFVSTlMKICogICAgIFN1Y2Nlc3M6CiAqICAgICBGYWlsdXJlOgogKi8KCkJPT0wgV0lOQVBJCkRyYXdDYXB0aW9uVGVtcEEgKEhXTkQgaHduZCwgSERDIGhkYywgY29uc3QgUkVDVCAqcmVjdCwgSEZPTlQgaEZvbnQsCgkJICAgIEhJQ09OIGhJY29uLCBMUENTVFIgc3RyLCBVSU5UIHVGbGFncykKewogICAgUkVDVCAgIHJjID0gKnJlY3Q7CgogICAgVFJBQ0UoIiglMDh4LCUwOHgsJXAsJTA4eCwlMDh4LFwiJXNcIiwlMDh4KVxuIiwKICAgICAgICAgIGh3bmQsIGhkYywgcmVjdCwgaEZvbnQsIGhJY29uLCBzdHIsIHVGbGFncyk7CgogICAgLyogZHJhd2luZyBiYWNrZ3JvdW5kICovCiAgICBpZiAodUZsYWdzICYgRENfSU5CVVRUT04pIHsKCUZpbGxSZWN0IChoZGMsICZyYywgR2V0U3lzQ29sb3JCcnVzaCAoQ09MT1JfM0RGQUNFKSk7CgoJaWYgKHVGbGFncyAmIERDX0FDVElWRSkgewoJICAgIEhCUlVTSCBoYnIgPSBTZWxlY3RPYmplY3QgKGhkYywgQ0FDSEVfR2V0UGF0dGVybjU1QUFCcnVzaCAoKSk7CgkgICAgUGF0Qmx0IChoZGMsIHJjLmxlZnQsIHJjLnRvcCwKCQkgICAgICByYy5yaWdodC1yYy5sZWZ0LCByYy5ib3R0b20tcmMudG9wLCAweEZBMDA4OSk7CgkgICAgU2VsZWN0T2JqZWN0IChoZGMsIGhicik7Cgl9CiAgICB9CiAgICBlbHNlIHsKCUZpbGxSZWN0IChoZGMsICZyYywgR2V0U3lzQ29sb3JCcnVzaCAoKHVGbGFncyAmIERDX0FDVElWRSkgPwoJCSAgICBDT0xPUl9BQ1RJVkVDQVBUSU9OIDogQ09MT1JfSU5BQ1RJVkVDQVBUSU9OKSk7CiAgICB9CgoKICAgIC8qIGRyYXdpbmcgaWNvbiAqLwogICAgaWYgKCh1RmxhZ3MgJiBEQ19JQ09OKSAmJiAhKHVGbGFncyAmIERDX1NNQUxMQ0FQKSkgewoJUE9JTlQgcHQ7CgoJcHQueCA9IHJjLmxlZnQgKyAyOwoJcHQueSA9IChyYy5ib3R0b20gKyByYy50b3AgLSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU01JQ09OKSkgLyAyOwoKCWlmIChoSWNvbikgewoJICAgIERyYXdJY29uRXggKGhkYywgcHQueCwgcHQueSwgaEljb24sIEdldFN5c3RlbU1ldHJpY3MoU01fQ1hTTUlDT04pLAoJCQkgIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lTTUlDT04pLCAwLCAwLCBESV9OT1JNQUwpOwoJfQoJZWxzZSB7CgkgICAgV05EKiB3bmRQdHIgPSBXSU5fRmluZFduZFB0cihod25kKTsKCSAgICBISUNPTiBoQXBwSWNvbiA9IChISUNPTikgTkNfSWNvbkZvcldpbmRvdyh3bmRQdHIpOwoJICAgIERyYXdJY29uRXggKGhkYywgcHQueCwgcHQueSwgaEFwcEljb24sIEdldFN5c3RlbU1ldHJpY3MoU01fQ1hTTUlDT04pLAoJCQkgIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lTTUlDT04pLCAwLCAwLCBESV9OT1JNQUwpOwogICAgICAgICAgICBXSU5fUmVsZWFzZVduZFB0cih3bmRQdHIpOwoJfQoKCXJjLmxlZnQgKz0gKHJjLmJvdHRvbSAtIHJjLnRvcCk7CiAgICB9CgogICAgLyogZHJhd2luZyB0ZXh0ICovCiAgICBpZiAodUZsYWdzICYgRENfVEVYVCkgewoJSEZPTlQgaE9sZEZvbnQ7CgoJaWYgKHVGbGFncyAmIERDX0lOQlVUVE9OKQoJICAgIFNldFRleHRDb2xvciAoaGRjLCBHZXRTeXNDb2xvciAoQ09MT1JfQlROVEVYVCkpOwoJZWxzZSBpZiAodUZsYWdzICYgRENfQUNUSVZFKQoJICAgIFNldFRleHRDb2xvciAoaGRjLCBHZXRTeXNDb2xvciAoQ09MT1JfQ0FQVElPTlRFWFQpKTsKCWVsc2UKCSAgICBTZXRUZXh0Q29sb3IgKGhkYywgR2V0U3lzQ29sb3IgKENPTE9SX0lOQUNUSVZFQ0FQVElPTlRFWFQpKTsKCglTZXRCa01vZGUgKGhkYywgVFJBTlNQQVJFTlQpOwoKCWlmIChoRm9udCkKCSAgICBoT2xkRm9udCA9IFNlbGVjdE9iamVjdCAoaGRjLCBoRm9udCk7CgllbHNlIHsKCSAgICBOT05DTElFTlRNRVRSSUNTQSBuY2xtOwoJICAgIEhGT05UIGhOZXdGb250OwoJICAgIG5jbG0uY2JTaXplID0gc2l6ZW9mKE5PTkNMSUVOVE1FVFJJQ1NBKTsKCSAgICBTeXN0ZW1QYXJhbWV0ZXJzSW5mb0EgKFNQSV9HRVROT05DTElFTlRNRVRSSUNTLCAwLCAmbmNsbSwgMCk7CgkgICAgaE5ld0ZvbnQgPSBDcmVhdGVGb250SW5kaXJlY3RBICgodUZsYWdzICYgRENfU01BTExDQVApID8KCQkmbmNsbS5sZlNtQ2FwdGlvbkZvbnQgOiAmbmNsbS5sZkNhcHRpb25Gb250KTsKCSAgICBoT2xkRm9udCA9IFNlbGVjdE9iamVjdCAoaGRjLCBoTmV3Rm9udCk7Cgl9CgoJaWYgKHN0cikKCSAgICBEcmF3VGV4dEEgKGhkYywgc3RyLCAtMSwgJnJjLAoJCQkgRFRfU0lOR0xFTElORSB8IERUX1ZDRU5URVIgfCBEVF9OT1BSRUZJWCB8IERUX0xFRlQpOwoJZWxzZSB7CgkgICAgQ0hBUiBzelRleHRbMTI4XTsKCSAgICBJTlQgbkxlbjsKCSAgICBuTGVuID0gR2V0V2luZG93VGV4dEEgKGh3bmQsIHN6VGV4dCwgMTI4KTsKCSAgICBEcmF3VGV4dEEgKGhkYywgc3pUZXh0LCBuTGVuLCAmcmMsCgkJCSBEVF9TSU5HTEVMSU5FIHwgRFRfVkNFTlRFUiB8IERUX05PUFJFRklYIHwgRFRfTEVGVCk7Cgl9CgoJaWYgKGhGb250KQoJICAgIFNlbGVjdE9iamVjdCAoaGRjLCBoT2xkRm9udCk7CgllbHNlCgkgICAgRGVsZXRlT2JqZWN0IChTZWxlY3RPYmplY3QgKGhkYywgaE9sZEZvbnQpKTsKICAgIH0KCiAgICAvKiBkcmF3aW5nIGZvY3VzID8/PyAqLwogICAgaWYgKHVGbGFncyAmIDB4MjAwMCkKCUZJWE1FKCJ1bmRvY3VtZW50ZWQgZmxhZyAoMHgyMDAwKSFcbiIpOwoKICAgIHJldHVybiAwOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIERyYXdDYXB0aW9uVGVtcFcgW1VTRVIzMi42MDJdCiAqCiAqIFBBUkFNUwogKgogKiBSRVRVUk5TCiAqICAgICBTdWNjZXNzOgogKiAgICAgRmFpbHVyZToKICovCgpCT09MIFdJTkFQSQpEcmF3Q2FwdGlvblRlbXBXIChIV05EIGh3bmQsIEhEQyBoZGMsIGNvbnN0IFJFQ1QgKnJlY3QsIEhGT05UIGhGb250LAoJCSAgICBISUNPTiBoSWNvbiwgTFBDV1NUUiBzdHIsIFVJTlQgdUZsYWdzKQp7CiAgICBMUFNUUiBwID0gSEVBUF9zdHJkdXBXdG9BIChHZXRQcm9jZXNzSGVhcCAoKSwgMCwgc3RyKTsKICAgIEJPT0wgcmVzID0gRHJhd0NhcHRpb25UZW1wQSAoaHduZCwgaGRjLCByZWN0LCBoRm9udCwgaEljb24sIHAsIHVGbGFncyk7CiAgICBIZWFwRnJlZSAoR2V0UHJvY2Vzc0hlYXAgKCksIDAsIHApOwogICAgcmV0dXJuIHJlczsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgQWRqdXN0V2luZG93UmVjdDE2ICAgIChVU0VSLjEwMikKICovCkJPT0wxNiBXSU5BUEkgQWRqdXN0V2luZG93UmVjdDE2KCBMUFJFQ1QxNiByZWN0LCBEV09SRCBzdHlsZSwgQk9PTDE2IG1lbnUgKQp7CiAgICByZXR1cm4gQWRqdXN0V2luZG93UmVjdEV4MTYoIHJlY3QsIHN0eWxlLCBtZW51LCAwICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIEFkanVzdFdpbmRvd1JlY3QgICAgKFVTRVIzMi4yKQogKi8KQk9PTCBXSU5BUEkgQWRqdXN0V2luZG93UmVjdCggTFBSRUNUIHJlY3QsIERXT1JEIHN0eWxlLCBCT09MIG1lbnUgKQp7CiAgICByZXR1cm4gQWRqdXN0V2luZG93UmVjdEV4KCByZWN0LCBzdHlsZSwgbWVudSwgMCApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBBZGp1c3RXaW5kb3dSZWN0RXgxNiAgICAoVVNFUi40NTQpCiAqLwpCT09MMTYgV0lOQVBJIEFkanVzdFdpbmRvd1JlY3RFeDE2KCBMUFJFQ1QxNiByZWN0LCBEV09SRCBzdHlsZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQk9PTDE2IG1lbnUsIERXT1JEIGV4U3R5bGUgKQp7CiAgICAgIC8qIENvcnJlY3QgdGhlIHdpbmRvdyBzdHlsZSAqLwoKICAgIGlmICghKHN0eWxlICYgKFdTX1BPUFVQIHwgV1NfQ0hJTEQpKSkgIC8qIE92ZXJsYXBwZWQgd2luZG93ICovCglzdHlsZSB8PSBXU19DQVBUSU9OOwogICAgc3R5bGUgJj0gKFdTX0RMR0ZSQU1FIHwgV1NfQk9SREVSIHwgV1NfVEhJQ0tGUkFNRSB8IFdTX0NISUxEKTsKICAgIGV4U3R5bGUgJj0gKFdTX0VYX0RMR01PREFMRlJBTUUgfCBXU19FWF9DTElFTlRFREdFIHwKCQlXU19FWF9TVEFUSUNFREdFIHwgV1NfRVhfVE9PTFdJTkRPVyk7CiAgICBpZiAoZXhTdHlsZSAmIFdTX0VYX0RMR01PREFMRlJBTUUpIHN0eWxlICY9IH5XU19USElDS0ZSQU1FOwoKICAgIFRSQUNFKCIoJWQsJWQpLSglZCwlZCkgJTA4bHggJWQgJTA4bHhcbiIsCiAgICAgICAgICByZWN0LT5sZWZ0LCByZWN0LT50b3AsIHJlY3QtPnJpZ2h0LCByZWN0LT5ib3R0b20sCiAgICAgICAgICBzdHlsZSwgbWVudSwgZXhTdHlsZSApOwoKICAgIGlmIChUV0VBS19XaW5lTG9vayA9PSBXSU4zMV9MT09LKQoJTkNfQWRqdXN0UmVjdCggcmVjdCwgc3R5bGUsIG1lbnUsIGV4U3R5bGUgKTsKICAgIGVsc2UgewoJTkNfQWRqdXN0UmVjdE91dGVyOTUoIHJlY3QsIHN0eWxlLCBtZW51LCBleFN0eWxlICk7CglOQ19BZGp1c3RSZWN0SW5uZXI5NSggcmVjdCwgc3R5bGUsIGV4U3R5bGUgKTsKICAgIH0KCiAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgQWRqdXN0V2luZG93UmVjdEV4ICAgIChVU0VSMzIuMykKICovCkJPT0wgV0lOQVBJIEFkanVzdFdpbmRvd1JlY3RFeCggTFBSRUNUIHJlY3QsIERXT1JEIHN0eWxlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBCT09MIG1lbnUsIERXT1JEIGV4U3R5bGUgKQp7CiAgICBSRUNUMTYgcmVjdDE2OwogICAgQk9PTCByZXQ7CgogICAgQ09OVl9SRUNUMzJUTzE2KCByZWN0LCAmcmVjdDE2ICk7CiAgICByZXQgPSBBZGp1c3RXaW5kb3dSZWN0RXgxNiggJnJlY3QxNiwgc3R5bGUsIChCT09MMTYpbWVudSwgZXhTdHlsZSApOwogICAgQ09OVl9SRUNUMTZUTzMyKCAmcmVjdDE2LCByZWN0ICk7CiAgICByZXR1cm4gcmV0Owp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBOQ19IYW5kbGVOQ0NhbGNTaXplCiAqCiAqIEhhbmRsZSBhIFdNX05DQ0FMQ1NJWkUgbWVzc2FnZS4gQ2FsbGVkIGZyb20gRGVmV2luZG93UHJvYygpLgogKi8KTE9ORyBOQ19IYW5kbGVOQ0NhbGNTaXplKCBXTkQgKnBXbmQsIFJFQ1QgKndpblJlY3QgKQp7CiAgICBSRUNUMTYgdG1wUmVjdCA9IHsgMCwgMCwgMCwgMCB9OwogICAgTE9ORyByZXN1bHQgPSAwOwogICAgVUlOVCBzdHlsZSA9IChVSU5UKSBHZXRDbGFzc0xvbmdBKHBXbmQtPmh3bmRTZWxmLCBHQ0xfU1RZTEUpOwoKICAgIGlmIChzdHlsZSAmIENTX1ZSRURSQVcpIHJlc3VsdCB8PSBXVlJfVlJFRFJBVzsKICAgIGlmIChzdHlsZSAmIENTX0hSRURSQVcpIHJlc3VsdCB8PSBXVlJfSFJFRFJBVzsKCiAgICBpZiggISggcFduZC0+ZHdTdHlsZSAmIFdTX01JTklNSVpFICkgKSB7CglpZiAoVFdFQUtfV2luZUxvb2sgPT0gV0lOMzFfTE9PSykKCSAgICBOQ19BZGp1c3RSZWN0KCAmdG1wUmVjdCwgcFduZC0+ZHdTdHlsZSwgRkFMU0UsIHBXbmQtPmR3RXhTdHlsZSApOwoJZWxzZQoJICAgIE5DX0FkanVzdFJlY3RPdXRlcjk1KCAmdG1wUmVjdCwgcFduZC0+ZHdTdHlsZSwgRkFMU0UsIHBXbmQtPmR3RXhTdHlsZSApOwoKCXdpblJlY3QtPmxlZnQgICAtPSB0bXBSZWN0LmxlZnQ7Cgl3aW5SZWN0LT50b3AgICAgLT0gdG1wUmVjdC50b3A7Cgl3aW5SZWN0LT5yaWdodCAgLT0gdG1wUmVjdC5yaWdodDsKCXdpblJlY3QtPmJvdHRvbSAtPSB0bXBSZWN0LmJvdHRvbTsKCglpZiAoSEFTX01FTlUocFduZCkpIHsKCSAgICBUUkFDRSgiQ2FsbGluZyBHZXRNZW51QmFySGVpZ2h0IHdpdGggSFdORCAweCV4LCB3aWR0aCAlZCwgIgogICAgICAgICAgICAgICAgICAiYXQgKCVkLCAlZCkuXG4iLCBwV25kLT5od25kU2VsZiwKICAgICAgICAgICAgICAgICAgd2luUmVjdC0+cmlnaHQgLSB3aW5SZWN0LT5sZWZ0LAogICAgICAgICAgICAgICAgICAtdG1wUmVjdC5sZWZ0LCAtdG1wUmVjdC50b3AgKTsKCgkgICAgd2luUmVjdC0+dG9wICs9CgkJTUVOVV9HZXRNZW51QmFySGVpZ2h0KCBwV25kLT5od25kU2VsZiwKCQkJCSAgICAgICB3aW5SZWN0LT5yaWdodCAtIHdpblJlY3QtPmxlZnQsCgkJCQkgICAgICAgLXRtcFJlY3QubGVmdCwgLXRtcFJlY3QudG9wICkgKyAxOwoJfQoKCWlmIChUV0VBS19XaW5lTG9vayA+IFdJTjMxX0xPT0spIHsKCSAgICBTZXRSZWN0MTYgKCZ0bXBSZWN0LCAwLCAwLCAwLCAwKTsKCSAgICBOQ19BZGp1c3RSZWN0SW5uZXI5NSAoJnRtcFJlY3QsIHBXbmQtPmR3U3R5bGUsIHBXbmQtPmR3RXhTdHlsZSk7CgkgICAgd2luUmVjdC0+bGVmdCAgIC09IHRtcFJlY3QubGVmdDsKCSAgICB3aW5SZWN0LT50b3AgICAgLT0gdG1wUmVjdC50b3A7CgkgICAgd2luUmVjdC0+cmlnaHQgIC09IHRtcFJlY3QucmlnaHQ7CgkgICAgd2luUmVjdC0+Ym90dG9tIC09IHRtcFJlY3QuYm90dG9tOwoJfQoKICAgICAgICBpZiAod2luUmVjdC0+dG9wID4gd2luUmVjdC0+Ym90dG9tKQogICAgICAgICAgICB3aW5SZWN0LT5ib3R0b20gPSB3aW5SZWN0LT50b3A7CgogICAgICAgIGlmICh3aW5SZWN0LT5sZWZ0ID4gd2luUmVjdC0+cmlnaHQpCiAgICAgICAgICAgIHdpblJlY3QtPnJpZ2h0ID0gd2luUmVjdC0+bGVmdDsKICAgIH0KICAgIHJldHVybiByZXN1bHQ7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE5DX0dldEluc2lkZVJlY3QKICoKICogR2V0IHRoZSAnaW5zaWRlJyByZWN0YW5nbGUgb2YgYSB3aW5kb3csIGkuZS4gdGhlIHdob2xlIHdpbmRvdyByZWN0YW5nbGUKICogYnV0IHdpdGhvdXQgdGhlIGJvcmRlcnMgKGlmIGFueSkuCiAqIFRoZSByZWN0YW5nbGUgaXMgaW4gd2luZG93IGNvb3JkaW5hdGVzIChmb3IgZHJhd2luZyB3aXRoIEdldFdpbmRvd0RDKCkpLgogKi8Kc3RhdGljIHZvaWQgTkNfR2V0SW5zaWRlUmVjdCggSFdORCBod25kLCBSRUNUICpyZWN0ICkKewogICAgV05EICogd25kUHRyID0gV0lOX0ZpbmRXbmRQdHIoIGh3bmQgKTsKCiAgICByZWN0LT50b3AgICAgPSByZWN0LT5sZWZ0ID0gMDsKICAgIHJlY3QtPnJpZ2h0ICA9IHduZFB0ci0+cmVjdFdpbmRvdy5yaWdodCAtIHduZFB0ci0+cmVjdFdpbmRvdy5sZWZ0OwogICAgcmVjdC0+Ym90dG9tID0gd25kUHRyLT5yZWN0V2luZG93LmJvdHRvbSAtIHduZFB0ci0+cmVjdFdpbmRvdy50b3A7CgogICAgaWYgKCh3bmRQdHItPmR3U3R5bGUgJiBXU19JQ09OSUMpIHx8ICh3bmRQdHItPmZsYWdzICYgV0lOX01BTkFHRUQpKSBnb3RvIEVORDsKCiAgICAvKiBSZW1vdmUgZnJhbWUgZnJvbSByZWN0YW5nbGUgKi8KICAgIGlmIChIQVNfVEhJQ0tGUkFNRSggd25kUHRyLT5kd1N0eWxlLCB3bmRQdHItPmR3RXhTdHlsZSApKQoJSW5mbGF0ZVJlY3QoIHJlY3QsIC1HZXRTeXN0ZW1NZXRyaWNzKFNNX0NYRlJBTUUpLCAtR2V0U3lzdGVtTWV0cmljcyhTTV9DWUZSQU1FKSApOwogICAgZWxzZQogICAgaWYgKEhBU19ETEdGUkFNRSggd25kUHRyLT5kd1N0eWxlLCB3bmRQdHItPmR3RXhTdHlsZSApKQogICAgewoJSW5mbGF0ZVJlY3QoIHJlY3QsIC1HZXRTeXN0ZW1NZXRyaWNzKFNNX0NYRExHRlJBTUUpLCAtR2V0U3lzdGVtTWV0cmljcyhTTV9DWURMR0ZSQU1FKSk7CgkvKiBGSVhNRTogdGhpcyBpc24ndCBpbiBOQ19BZGp1c3RSZWN0PyB3aHkgbm90PyAqLwoJaWYgKHduZFB0ci0+ZHdFeFN0eWxlICYgV1NfRVhfRExHTU9EQUxGUkFNRSkKICAgICAgICAgICAgSW5mbGF0ZVJlY3QoIHJlY3QsIC0xLCAwICk7CiAgICB9CiAgICBlbHNlCiAgICBpZiAoSEFTX1RISU5GUkFNRSggd25kUHRyLT5kd1N0eWxlICkpCglJbmZsYXRlUmVjdCggcmVjdCwgLUdldFN5c3RlbU1ldHJpY3MoU01fQ1hCT1JERVIpLCAtR2V0U3lzdGVtTWV0cmljcyhTTV9DWUJPUkRFUikgKTsKRU5EOgogICAgV0lOX1JlbGVhc2VXbmRQdHIod25kUHRyKTsKICAgIHJldHVybjsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTkNfR2V0SW5zaWRlUmVjdDk1CiAqCiAqIEdldCB0aGUgJ2luc2lkZScgcmVjdGFuZ2xlIG9mIGEgd2luZG93LCBpLmUuIHRoZSB3aG9sZSB3aW5kb3cgcmVjdGFuZ2xlCiAqIGJ1dCB3aXRob3V0IHRoZSBib3JkZXJzIChpZiBhbnkpLgogKiBUaGUgcmVjdGFuZ2xlIGlzIGluIHdpbmRvdyBjb29yZGluYXRlcyAoZm9yIGRyYXdpbmcgd2l0aCBHZXRXaW5kb3dEQygpKS4KICovCgpzdGF0aWMgdm9pZApOQ19HZXRJbnNpZGVSZWN0OTUgKEhXTkQgaHduZCwgUkVDVCAqcmVjdCkKewogICAgV05EICogd25kUHRyID0gV0lOX0ZpbmRXbmRQdHIoIGh3bmQgKTsKCiAgICByZWN0LT50b3AgICAgPSByZWN0LT5sZWZ0ID0gMDsKICAgIHJlY3QtPnJpZ2h0ICA9IHduZFB0ci0+cmVjdFdpbmRvdy5yaWdodCAtIHduZFB0ci0+cmVjdFdpbmRvdy5sZWZ0OwogICAgcmVjdC0+Ym90dG9tID0gd25kUHRyLT5yZWN0V2luZG93LmJvdHRvbSAtIHduZFB0ci0+cmVjdFdpbmRvdy50b3A7CgogICAgaWYgKCh3bmRQdHItPmR3U3R5bGUgJiBXU19JQ09OSUMpIHx8ICh3bmRQdHItPmZsYWdzICYgV0lOX01BTkFHRUQpKSBnb3RvIEVORDsKCiAgICAvKiBSZW1vdmUgZnJhbWUgZnJvbSByZWN0YW5nbGUgKi8KICAgIGlmIChIQVNfVEhJQ0tGUkFNRSAod25kUHRyLT5kd1N0eWxlLCB3bmRQdHItPmR3RXhTdHlsZSkpCiAgICB7CglJbmZsYXRlUmVjdCggcmVjdCwgLUdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFRlJBTUUpLCAtR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNJWkVGUkFNRSkgKTsKICAgIH0KICAgIGVsc2UgaWYgKEhBU19ETEdGUkFNRSAod25kUHRyLT5kd1N0eWxlLCB3bmRQdHItPmR3RXhTdHlsZSApKQogICAgewoJSW5mbGF0ZVJlY3QoIHJlY3QsIC1HZXRTeXN0ZW1NZXRyaWNzKFNNX0NYRklYRURGUkFNRSksIC1HZXRTeXN0ZW1NZXRyaWNzKFNNX0NZRklYRURGUkFNRSkpOwogICAgfQogICAgZWxzZSBpZiAoSEFTX1RISU5GUkFNRSAod25kUHRyLT5kd1N0eWxlKSkKICAgIHsKICAgICAgICBJbmZsYXRlUmVjdCggcmVjdCwgLUdldFN5c3RlbU1ldHJpY3MoU01fQ1hCT1JERVIpLCAtR2V0U3lzdGVtTWV0cmljcyhTTV9DWUJPUkRFUikgKTsKICAgIH0KCiAgICAvKiBXZSBoYXZlIGFkZGl0aW9uYWwgYm9yZGVyIGluZm9ybWF0aW9uIGlmIHRoZSB3aW5kb3cKICAgICAqIGlzIGEgY2hpbGQgKGJ1dCBub3QgYW4gTURJIGNoaWxkKSAqLwogICAgaWYgKCAod25kUHRyLT5kd1N0eWxlICYgV1NfQ0hJTEQpICAmJgoJICggKHduZFB0ci0+ZHdFeFN0eWxlICYgV1NfRVhfTURJQ0hJTEQpID09IDAgKSApCiAgICB7IAoJaWYgKHduZFB0ci0+ZHdFeFN0eWxlICYgV1NfRVhfQ0xJRU5URURHRSkKCSAgICBJbmZsYXRlUmVjdCAocmVjdCwgLUdldFN5c3RlbU1ldHJpY3MoU01fQ1hFREdFKSwgLUdldFN5c3RlbU1ldHJpY3MoU01fQ1lFREdFKSk7CgoJaWYgKHduZFB0ci0+ZHdFeFN0eWxlICYgV1NfRVhfU1RBVElDRURHRSkKCSAgICBJbmZsYXRlUmVjdCAocmVjdCwgLUdldFN5c3RlbU1ldHJpY3MoU01fQ1hCT1JERVIpLCAtR2V0U3lzdGVtTWV0cmljcyhTTV9DWUJPUkRFUikpOwogICAgfQpFTkQ6CiAgICBXSU5fUmVsZWFzZVduZFB0cih3bmRQdHIpOwogICAgcmV0dXJuOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIE5DX0RvTkNIaXRUZXN0CiAqCiAqIEhhbmRsZSBhIFdNX05DSElUVEVTVCBtZXNzYWdlLiBDYWxsZWQgZnJvbSBOQ19IYW5kbGVOY0hpdFRlc3QoKS4KICovCgpzdGF0aWMgTE9ORyBOQ19Eb05DSGl0VGVzdCAoV05EICp3bmRQdHIsIFBPSU5UMTYgcHQgKQp7CiAgICBSRUNUMTYgcmVjdDsKCiAgICBUUkFDRSgiaHduZD0lMDR4IHB0PSVkLCVkXG4iLCB3bmRQdHItPmh3bmRTZWxmLCBwdC54LCBwdC55ICk7CgogICAgR2V0V2luZG93UmVjdDE2ICh3bmRQdHItPmh3bmRTZWxmLCAmcmVjdCApOwogICAgaWYgKCFQdEluUmVjdDE2KCAmcmVjdCwgcHQgKSkgcmV0dXJuIEhUTk9XSEVSRTsKCiAgICBpZiAod25kUHRyLT5kd1N0eWxlICYgV1NfTUlOSU1JWkUpIHJldHVybiBIVENBUFRJT047CgogICAgaWYgKCEod25kUHRyLT5mbGFncyAmIFdJTl9NQU5BR0VEKSkKICAgIHsKICAgICAgICAvKiBDaGVjayBib3JkZXJzICovCiAgICAgICAgaWYgKEhBU19USElDS0ZSQU1FKCB3bmRQdHItPmR3U3R5bGUsIHduZFB0ci0+ZHdFeFN0eWxlICkpCiAgICAgICAgewogICAgICAgICAgICBJbmZsYXRlUmVjdDE2KCAmcmVjdCwgLUdldFN5c3RlbU1ldHJpY3MoU01fQ1hGUkFNRSksIC1HZXRTeXN0ZW1NZXRyaWNzKFNNX0NZRlJBTUUpICk7CiAgICAgICAgICAgIGlmICghUHRJblJlY3QxNiggJnJlY3QsIHB0ICkpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIC8qIENoZWNrIHRvcCBzaXppbmcgYm9yZGVyICovCiAgICAgICAgICAgICAgICBpZiAocHQueSA8IHJlY3QudG9wKQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIGlmIChwdC54IDwgcmVjdC5sZWZ0K0dldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKSkgcmV0dXJuIEhUVE9QTEVGVDsKICAgICAgICAgICAgICAgICAgICBpZiAocHQueCA+PSByZWN0LnJpZ2h0LUdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKSkgcmV0dXJuIEhUVE9QUklHSFQ7CiAgICAgICAgICAgICAgICAgICAgcmV0dXJuIEhUVE9QOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgLyogQ2hlY2sgYm90dG9tIHNpemluZyBib3JkZXIgKi8KICAgICAgICAgICAgICAgIGlmIChwdC55ID49IHJlY3QuYm90dG9tKQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIGlmIChwdC54IDwgcmVjdC5sZWZ0K0dldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKSkgcmV0dXJuIEhUQk9UVE9NTEVGVDsKICAgICAgICAgICAgICAgICAgICBpZiAocHQueCA+PSByZWN0LnJpZ2h0LUdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKSkgcmV0dXJuIEhUQk9UVE9NUklHSFQ7CiAgICAgICAgICAgICAgICAgICAgcmV0dXJuIEhUQk9UVE9NOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgLyogQ2hlY2sgbGVmdCBzaXppbmcgYm9yZGVyICovCiAgICAgICAgICAgICAgICBpZiAocHQueCA8IHJlY3QubGVmdCkKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICBpZiAocHQueSA8IHJlY3QudG9wK0dldFN5c3RlbU1ldHJpY3MoU01fQ1lTSVpFKSkgcmV0dXJuIEhUVE9QTEVGVDsKICAgICAgICAgICAgICAgICAgICBpZiAocHQueSA+PSByZWN0LmJvdHRvbS1HZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU0laRSkpIHJldHVybiBIVEJPVFRPTUxFRlQ7CiAgICAgICAgICAgICAgICAgICAgcmV0dXJuIEhUTEVGVDsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIC8qIENoZWNrIHJpZ2h0IHNpemluZyBib3JkZXIgKi8KICAgICAgICAgICAgICAgIGlmIChwdC54ID49IHJlY3QucmlnaHQpCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgaWYgKHB0LnkgPCByZWN0LnRvcCtHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU0laRSkpIHJldHVybiBIVFRPUFJJR0hUOwogICAgICAgICAgICAgICAgICAgIGlmIChwdC55ID49IHJlY3QuYm90dG9tLUdldFN5c3RlbU1ldHJpY3MoU01fQ1lTSVpFKSkgcmV0dXJuIEhUQk9UVE9NUklHSFQ7CiAgICAgICAgICAgICAgICAgICAgcmV0dXJuIEhUUklHSFQ7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICAgICAgZWxzZSAgLyogTm8gdGhpY2sgZnJhbWUgKi8KICAgICAgICB7CiAgICAgICAgICAgIGlmIChIQVNfRExHRlJBTUUoIHduZFB0ci0+ZHdTdHlsZSwgd25kUHRyLT5kd0V4U3R5bGUgKSkKICAgICAgICAgICAgICAgIEluZmxhdGVSZWN0MTYoJnJlY3QsIC1HZXRTeXN0ZW1NZXRyaWNzKFNNX0NYRExHRlJBTUUpLCAtR2V0U3lzdGVtTWV0cmljcyhTTV9DWURMR0ZSQU1FKSk7CiAgICAgICAgICAgIGVsc2UgaWYgKEhBU19USElORlJBTUUoIHduZFB0ci0+ZHdTdHlsZSApKQogICAgICAgICAgICAgICAgSW5mbGF0ZVJlY3QxNigmcmVjdCwgLUdldFN5c3RlbU1ldHJpY3MoU01fQ1hCT1JERVIpLCAtR2V0U3lzdGVtTWV0cmljcyhTTV9DWUJPUkRFUikpOwogICAgICAgICAgICBpZiAoIVB0SW5SZWN0MTYoICZyZWN0LCBwdCApKSByZXR1cm4gSFRCT1JERVI7CiAgICAgICAgfQoKICAgICAgICAvKiBDaGVjayBjYXB0aW9uICovCgogICAgICAgIGlmICgod25kUHRyLT5kd1N0eWxlICYgV1NfQ0FQVElPTikgPT0gV1NfQ0FQVElPTikKICAgICAgICB7CiAgICAgICAgICAgIHJlY3QudG9wICs9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1lDQVBUSU9OKSAtIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lCT1JERVIpOwogICAgICAgICAgICBpZiAoIVB0SW5SZWN0MTYoICZyZWN0LCBwdCApKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAvKiBDaGVjayBzeXN0ZW0gbWVudSAqLwogICAgICAgICAgICAgICAgaWYgKCh3bmRQdHItPmR3U3R5bGUgJiBXU19TWVNNRU5VKSAmJiAhKHduZFB0ci0+ZHdFeFN0eWxlICYgV1NfRVhfVE9PTFdJTkRPVykpCiAgICAgICAgICAgICAgICAgICAgcmVjdC5sZWZ0ICs9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKTsKICAgICAgICAgICAgICAgIGlmIChwdC54IDw9IHJlY3QubGVmdCkgcmV0dXJuIEhUU1lTTUVOVTsKCiAgICAgICAgICAgICAgICAvKiBDaGVjayBtYXhpbWl6ZSBib3ggKi8KICAgICAgICAgICAgICAgIGlmICh3bmRQdHItPmR3U3R5bGUgJiBXU19NQVhJTUlaRUJPWCkKICAgICAgICAgICAgICAgICAgICByZWN0LnJpZ2h0IC09IEdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKSArIDE7CgogICAgICAgICAgICAgICAgaWYgKHB0LnggPj0gcmVjdC5yaWdodCkgcmV0dXJuIEhUTUFYQlVUVE9OOwogICAgICAgICAgICAgICAgLyogQ2hlY2sgbWluaW1pemUgYm94ICovCiAgICAgICAgICAgICAgICBpZiAod25kUHRyLT5kd1N0eWxlICYgV1NfTUlOSU1JWkVCT1gpCiAgICAgICAgICAgICAgICAgICAgcmVjdC5yaWdodCAtPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0laRSkgKyAxOwogICAgICAgICAgICAgICAgaWYgKHB0LnggPj0gcmVjdC5yaWdodCkgcmV0dXJuIEhUTUlOQlVUVE9OOwogICAgICAgICAgICAgICAgcmV0dXJuIEhUQ0FQVElPTjsKICAgICAgICAgICAgfQogICAgICAgIH0KICAgIH0KCiAgICAgIC8qIENoZWNrIGNsaWVudCBhcmVhICovCgogICAgU2NyZWVuVG9DbGllbnQxNiggd25kUHRyLT5od25kU2VsZiwgJnB0ICk7CiAgICBHZXRDbGllbnRSZWN0MTYoIHduZFB0ci0+aHduZFNlbGYsICZyZWN0ICk7CiAgICBpZiAoUHRJblJlY3QxNiggJnJlY3QsIHB0ICkpIHJldHVybiBIVENMSUVOVDsKCiAgICAgIC8qIENoZWNrIHZlcnRpY2FsIHNjcm9sbCBiYXIgKi8KCiAgICBpZiAod25kUHRyLT5kd1N0eWxlICYgV1NfVlNDUk9MTCkKICAgIHsKCXJlY3QucmlnaHQgKz0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWFZTQ1JPTEwpOwoJaWYgKFB0SW5SZWN0MTYoICZyZWN0LCBwdCApKSByZXR1cm4gSFRWU0NST0xMOwogICAgfQoKICAgICAgLyogQ2hlY2sgaG9yaXpvbnRhbCBzY3JvbGwgYmFyICovCgogICAgaWYgKHduZFB0ci0+ZHdTdHlsZSAmIFdTX0hTQ1JPTEwpCiAgICB7CglyZWN0LmJvdHRvbSArPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZSFNDUk9MTCk7CglpZiAoUHRJblJlY3QxNiggJnJlY3QsIHB0ICkpCgl7CgkgICAgICAvKiBDaGVjayBzaXplIGJveCAqLwoJICAgIGlmICgod25kUHRyLT5kd1N0eWxlICYgV1NfVlNDUk9MTCkgJiYKCQkocHQueCA+PSByZWN0LnJpZ2h0IC0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWFZTQ1JPTEwpKSkKCQlyZXR1cm4gSFRTSVpFOwoJICAgIHJldHVybiBIVEhTQ1JPTEw7Cgl9CiAgICB9CgogICAgICAvKiBDaGVjayBtZW51IGJhciAqLwoKICAgIGlmIChIQVNfTUVOVSh3bmRQdHIpKQogICAgewoJaWYgKChwdC55IDwgMCkgJiYgKHB0LnggPj0gMCkgJiYgKHB0LnggPCByZWN0LnJpZ2h0KSkKCSAgICByZXR1cm4gSFRNRU5VOwogICAgfQoKICAgIC8qIEhhcyB0byByZXR1cm4gSFROT1dIRVJFIGlmIG5vdGhpbmcgd2FzIGZvdW5kICAKICAgICAgIENvdWxkIGhhcHBlbiB3aGVuIGEgd2luZG93IGhhcyBhIGN1c3RvbWl6ZWQgbm9uIGNsaWVudCBhcmVhICovCiAgICByZXR1cm4gSFROT1dIRVJFOyAgCn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogTkNfRG9OQ0hpdFRlc3Q5NQogKgogKiBIYW5kbGUgYSBXTV9OQ0hJVFRFU1QgbWVzc2FnZS4gQ2FsbGVkIGZyb20gTkNfSGFuZGxlTkNIaXRUZXN0KCkuCiAqCiAqIEZJWE1FOiAgSnVzdCBhIG1vZGlmaWVkIGNvcHkgb2YgdGhlIFdpbiAzLjEgdmVyc2lvbi4KICovCgpzdGF0aWMgTE9ORwpOQ19Eb05DSGl0VGVzdDk1IChXTkQgKnduZFB0ciwgUE9JTlQxNiBwdCApCnsKICAgIFJFQ1QxNiByZWN0OwoKICAgIFRSQUNFKCJod25kPSUwNHggcHQ9JWQsJWRcbiIsIHduZFB0ci0+aHduZFNlbGYsIHB0LngsIHB0LnkgKTsKCiAgICBHZXRXaW5kb3dSZWN0MTYgKHduZFB0ci0+aHduZFNlbGYsICZyZWN0ICk7CiAgICBpZiAoIVB0SW5SZWN0MTYoICZyZWN0LCBwdCApKSByZXR1cm4gSFROT1dIRVJFOwoKICAgIGlmICh3bmRQdHItPmR3U3R5bGUgJiBXU19NSU5JTUlaRSkgcmV0dXJuIEhUQ0FQVElPTjsKCiAgICBpZiAoISh3bmRQdHItPmZsYWdzICYgV0lOX01BTkFHRUQpKQogICAgewogICAgICAgIC8qIENoZWNrIGJvcmRlcnMgKi8KICAgICAgICBpZiAoSEFTX1RISUNLRlJBTUUoIHduZFB0ci0+ZHdTdHlsZSwgd25kUHRyLT5kd0V4U3R5bGUgKSkKICAgICAgICB7CiAgICAgICAgICAgIEluZmxhdGVSZWN0MTYoICZyZWN0LCAtR2V0U3lzdGVtTWV0cmljcyhTTV9DWEZSQU1FKSwgLUdldFN5c3RlbU1ldHJpY3MoU01fQ1lGUkFNRSkgKTsKICAgICAgICAgICAgaWYgKCFQdEluUmVjdDE2KCAmcmVjdCwgcHQgKSkKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgLyogQ2hlY2sgdG9wIHNpemluZyBib3JkZXIgKi8KICAgICAgICAgICAgICAgIGlmIChwdC55IDwgcmVjdC50b3ApCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgaWYgKHB0LnggPCByZWN0LmxlZnQrR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNJWkUpKSByZXR1cm4gSFRUT1BMRUZUOwogICAgICAgICAgICAgICAgICAgIGlmIChwdC54ID49IHJlY3QucmlnaHQtR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNJWkUpKSByZXR1cm4gSFRUT1BSSUdIVDsKICAgICAgICAgICAgICAgICAgICByZXR1cm4gSFRUT1A7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAvKiBDaGVjayBib3R0b20gc2l6aW5nIGJvcmRlciAqLwogICAgICAgICAgICAgICAgaWYgKHB0LnkgPj0gcmVjdC5ib3R0b20pCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgaWYgKHB0LnggPCByZWN0LmxlZnQrR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNJWkUpKSByZXR1cm4gSFRCT1RUT01MRUZUOwogICAgICAgICAgICAgICAgICAgIGlmIChwdC54ID49IHJlY3QucmlnaHQtR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNJWkUpKSByZXR1cm4gSFRCT1RUT01SSUdIVDsKICAgICAgICAgICAgICAgICAgICByZXR1cm4gSFRCT1RUT007CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAvKiBDaGVjayBsZWZ0IHNpemluZyBib3JkZXIgKi8KICAgICAgICAgICAgICAgIGlmIChwdC54IDwgcmVjdC5sZWZ0KQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIGlmIChwdC55IDwgcmVjdC50b3ArR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNJWkUpKSByZXR1cm4gSFRUT1BMRUZUOwogICAgICAgICAgICAgICAgICAgIGlmIChwdC55ID49IHJlY3QuYm90dG9tLUdldFN5c3RlbU1ldHJpY3MoU01fQ1lTSVpFKSkgcmV0dXJuIEhUQk9UVE9NTEVGVDsKICAgICAgICAgICAgICAgICAgICByZXR1cm4gSFRMRUZUOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgLyogQ2hlY2sgcmlnaHQgc2l6aW5nIGJvcmRlciAqLwogICAgICAgICAgICAgICAgaWYgKHB0LnggPj0gcmVjdC5yaWdodCkKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICBpZiAocHQueSA8IHJlY3QudG9wK0dldFN5c3RlbU1ldHJpY3MoU01fQ1lTSVpFKSkgcmV0dXJuIEhUVE9QUklHSFQ7CiAgICAgICAgICAgICAgICAgICAgaWYgKHB0LnkgPj0gcmVjdC5ib3R0b20tR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNJWkUpKSByZXR1cm4gSFRCT1RUT01SSUdIVDsKICAgICAgICAgICAgICAgICAgICByZXR1cm4gSFRSSUdIVDsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfQogICAgICAgIH0KICAgICAgICBlbHNlICAvKiBObyB0aGljayBmcmFtZSAqLwogICAgICAgIHsKICAgICAgICAgICAgaWYgKEhBU19ETEdGUkFNRSggd25kUHRyLT5kd1N0eWxlLCB3bmRQdHItPmR3RXhTdHlsZSApKQogICAgICAgICAgICAgICAgSW5mbGF0ZVJlY3QxNigmcmVjdCwgLUdldFN5c3RlbU1ldHJpY3MoU01fQ1hETEdGUkFNRSksIC1HZXRTeXN0ZW1NZXRyaWNzKFNNX0NZRExHRlJBTUUpKTsKICAgICAgICAgICAgZWxzZSBpZiAoSEFTX1RISU5GUkFNRSggd25kUHRyLT5kd1N0eWxlICkpCiAgICAgICAgICAgICAgICBJbmZsYXRlUmVjdDE2KCZyZWN0LCAtR2V0U3lzdGVtTWV0cmljcyhTTV9DWEJPUkRFUiksIC1HZXRTeXN0ZW1NZXRyaWNzKFNNX0NZQk9SREVSKSk7CiAgICAgICAgICAgIGlmICghUHRJblJlY3QxNiggJnJlY3QsIHB0ICkpIHJldHVybiBIVEJPUkRFUjsKICAgICAgICB9CgogICAgICAgIC8qIENoZWNrIGNhcHRpb24gKi8KCiAgICAgICAgaWYgKCh3bmRQdHItPmR3U3R5bGUgJiBXU19DQVBUSU9OKSA9PSBXU19DQVBUSU9OKQogICAgICAgIHsKCSAgICBpZiAod25kUHRyLT5kd0V4U3R5bGUgJiBXU19FWF9UT09MV0lORE9XKQoJICAgICAgICByZWN0LnRvcCArPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU01DQVBUSU9OKSAtIDE7CgkgICAgZWxzZQoJICAgICAgICByZWN0LnRvcCArPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZQ0FQVElPTikgLSAxOwogICAgICAgICAgICBpZiAoIVB0SW5SZWN0MTYoICZyZWN0LCBwdCApKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAvKiBDaGVjayBzeXN0ZW0gbWVudSAqLwogICAgICAgICAgICAgICAgaWYgKCh3bmRQdHItPmR3U3R5bGUgJiBXU19TWVNNRU5VKSAmJiAhKHduZFB0ci0+ZHdFeFN0eWxlICYgV1NfRVhfVE9PTFdJTkRPVykpCgkJewoJCSAgICBpZiAoTkNfSWNvbkZvcldpbmRvdyh3bmRQdHIpKQoJCQlyZWN0LmxlZnQgKz0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWUNBUFRJT04pIC0gMTsKCQl9CiAgICAgICAgICAgICAgICBpZiAocHQueCA8IHJlY3QubGVmdCkgcmV0dXJuIEhUU1lTTUVOVTsKCiAgICAgICAgICAgICAgICAvKiBDaGVjayBjbG9zZSBidXR0b24gKi8KICAgICAgICAgICAgICAgIGlmICh3bmRQdHItPmR3U3R5bGUgJiBXU19TWVNNRU5VKQogICAgICAgICAgICAgICAgICAgIHJlY3QucmlnaHQgLT0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWUNBUFRJT04pIC0gMTsKICAgICAgICAgICAgICAgIGlmIChwdC54ID4gcmVjdC5yaWdodCkgcmV0dXJuIEhUQ0xPU0U7CgogICAgICAgICAgICAgICAgLyogQ2hlY2sgbWF4aW1pemUgYm94ICovCgkJLyogSW4gd2luOTUgdGhlcmUgaXMgYXV0b21hdGljYWxseSBhIE1heGltaXplIGJ1dHRvbiB3aGVuIHRoZXJlIGlzIGEgbWluaW1pemUgb25lKi8KICAgICAgICAgICAgICAgIGlmICgod25kUHRyLT5kd1N0eWxlICYgV1NfTUFYSU1JWkVCT1gpfHwgKHduZFB0ci0+ZHdTdHlsZSAmIFdTX01JTklNSVpFQk9YKSkKICAgICAgICAgICAgICAgICAgICByZWN0LnJpZ2h0IC09IEdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKSArIDE7CiAgICAgICAgICAgICAgICBpZiAocHQueCA+IHJlY3QucmlnaHQpIHJldHVybiBIVE1BWEJVVFRPTjsKCiAgICAgICAgICAgICAgICAvKiBDaGVjayBtaW5pbWl6ZSBib3ggKi8KCQkvKiBJbiB3aW45NSB0aGVyZSBpcyBhdXRvbWF0aWNhbGx5IGEgTWF4aW1pemUgYnV0dG9uIHdoZW4gdGhlcmUgaXMgYSBNYXhpbWl6ZSBvbmUqLwogICAgICAgICAgICAgICAgaWYgKCh3bmRQdHItPmR3U3R5bGUgJiBXU19NSU5JTUlaRUJPWCl8fCh3bmRQdHItPmR3U3R5bGUgJiBXU19NQVhJTUlaRUJPWCkpCiAgICAgICAgICAgICAgICAgICAgcmVjdC5yaWdodCAtPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0laRSkgKyAxOwoKICAgICAgICAgICAgICAgIGlmIChwdC54ID4gcmVjdC5yaWdodCkgcmV0dXJuIEhUTUlOQlVUVE9OOwogICAgICAgICAgICAgICAgcmV0dXJuIEhUQ0FQVElPTjsKICAgICAgICAgICAgfQogICAgICAgIH0KICAgIH0KCiAgICAgIC8qIENoZWNrIGNsaWVudCBhcmVhICovCgogICAgU2NyZWVuVG9DbGllbnQxNiggd25kUHRyLT5od25kU2VsZiwgJnB0ICk7CiAgICBHZXRDbGllbnRSZWN0MTYoIHduZFB0ci0+aHduZFNlbGYsICZyZWN0ICk7CiAgICBpZiAoUHRJblJlY3QxNiggJnJlY3QsIHB0ICkpIHJldHVybiBIVENMSUVOVDsKCiAgICAgIC8qIENoZWNrIHZlcnRpY2FsIHNjcm9sbCBiYXIgKi8KCiAgICBpZiAod25kUHRyLT5kd1N0eWxlICYgV1NfVlNDUk9MTCkKICAgIHsKCXJlY3QucmlnaHQgKz0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWFZTQ1JPTEwpOwoJaWYgKFB0SW5SZWN0MTYoICZyZWN0LCBwdCApKSByZXR1cm4gSFRWU0NST0xMOwogICAgfQoKICAgICAgLyogQ2hlY2sgaG9yaXpvbnRhbCBzY3JvbGwgYmFyICovCgogICAgaWYgKHduZFB0ci0+ZHdTdHlsZSAmIFdTX0hTQ1JPTEwpCiAgICB7CglyZWN0LmJvdHRvbSArPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZSFNDUk9MTCk7CglpZiAoUHRJblJlY3QxNiggJnJlY3QsIHB0ICkpCgl7CgkgICAgICAvKiBDaGVjayBzaXplIGJveCAqLwoJICAgIGlmICgod25kUHRyLT5kd1N0eWxlICYgV1NfVlNDUk9MTCkgJiYKCQkocHQueCA+PSByZWN0LnJpZ2h0IC0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWFZTQ1JPTEwpKSkKCQlyZXR1cm4gSFRTSVpFOwoJICAgIHJldHVybiBIVEhTQ1JPTEw7Cgl9CiAgICB9CgogICAgICAvKiBDaGVjayBtZW51IGJhciAqLwoKICAgIGlmIChIQVNfTUVOVSh3bmRQdHIpKQogICAgewoJaWYgKChwdC55IDwgMCkgJiYgKHB0LnggPj0gMCkgJiYgKHB0LnggPCByZWN0LnJpZ2h0KSkKCSAgICByZXR1cm4gSFRNRU5VOwogICAgfQoKICAgIC8qIEhhcyB0byByZXR1cm4gSFROT1dIRVJFIGlmIG5vdGhpbmcgd2FzIGZvdW5kICAKICAgICAgIENvdWxkIGhhcHBlbiB3aGVuIGEgd2luZG93IGhhcyBhIGN1c3RvbWl6ZWQgbm9uIGNsaWVudCBhcmVhICovCiAgICByZXR1cm4gSFROT1dIRVJFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIE5DX0hhbmRsZU5DSGl0VGVzdAogKgogKiBIYW5kbGUgYSBXTV9OQ0hJVFRFU1QgbWVzc2FnZS4gQ2FsbGVkIGZyb20gRGVmV2luZG93UHJvYygpLgogKi8KTE9ORwpOQ19IYW5kbGVOQ0hpdFRlc3QgKEhXTkQgaHduZCAsIFBPSU5UMTYgcHQpCnsKICAgIExPTkcgcmV0dmFsdWU7CiAgICBXTkQgKnduZFB0ciA9IFdJTl9GaW5kV25kUHRyIChod25kKTsKCiAgICBpZiAoIXduZFB0cikKCXJldHVybiBIVEVSUk9SOwoKICAgIGlmIChUV0VBS19XaW5lTG9vayA9PSBXSU4zMV9MT09LKQogICAgICAgIHJldHZhbHVlID0gTkNfRG9OQ0hpdFRlc3QgKHduZFB0ciwgcHQpOwogICAgZWxzZQogICAgICAgIHJldHZhbHVlID0gTkNfRG9OQ0hpdFRlc3Q5NSAod25kUHRyLCBwdCk7CiAgICBXSU5fUmVsZWFzZVduZFB0cih3bmRQdHIpOwogICAgcmV0dXJuIHJldHZhbHVlOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBOQ19EcmF3U3lzQnV0dG9uCiAqLwp2b2lkIE5DX0RyYXdTeXNCdXR0b24oIEhXTkQgaHduZCwgSERDIGhkYywgQk9PTCBkb3duICkKewogICAgUkVDVCByZWN0OwogICAgSERDIGhkY01lbTsKICAgIEhCSVRNQVAgaGJpdG1hcDsKICAgIFdORCAqd25kUHRyID0gV0lOX0ZpbmRXbmRQdHIoIGh3bmQgKTsKCiAgICBpZiggISh3bmRQdHItPmZsYWdzICYgV0lOX01BTkFHRUQpICkKICAgIHsKICAgICAgTkNfR2V0SW5zaWRlUmVjdCggaHduZCwgJnJlY3QgKTsKICAgICAgaGRjTWVtID0gQ3JlYXRlQ29tcGF0aWJsZURDKCBoZGMgKTsKICAgICAgaGJpdG1hcCA9IFNlbGVjdE9iamVjdCggaGRjTWVtLCBoYml0bWFwQ2xvc2UgKTsKICAgICAgQml0Qmx0KGhkYywgcmVjdC5sZWZ0LCByZWN0LnRvcCwgR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNJWkUpLCBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU0laRSksCiAgICAgICAgICAgICAgIGhkY01lbSwgKHduZFB0ci0+ZHdTdHlsZSAmIFdTX0NISUxEKSA/IEdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKSA6IDAsIDAsCiAgICAgICAgICAgICAgIGRvd24gPyBOT1RTUkNDT1BZIDogU1JDQ09QWSApOwogICAgICBTZWxlY3RPYmplY3QoIGhkY01lbSwgaGJpdG1hcCApOwogICAgICBEZWxldGVEQyggaGRjTWVtICk7CiAgICB9CiAgICBXSU5fUmVsZWFzZVduZFB0cih3bmRQdHIpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBOQ19EcmF3TWF4QnV0dG9uCiAqLwpzdGF0aWMgdm9pZCBOQ19EcmF3TWF4QnV0dG9uKCBIV05EIGh3bmQsIEhEQzE2IGhkYywgQk9PTCBkb3duICkKewogICAgUkVDVCByZWN0OwogICAgV05EICp3bmRQdHIgPSBXSU5fRmluZFduZFB0ciggaHduZCApOwogICAgSERDIGhkY01lbTsKCiAgICBpZiggISh3bmRQdHItPmZsYWdzICYgV0lOX01BTkFHRUQpICkKICAgIHsKICAgICAgTkNfR2V0SW5zaWRlUmVjdCggaHduZCwgJnJlY3QgKTsKICAgICAgaGRjTWVtID0gQ3JlYXRlQ29tcGF0aWJsZURDKCBoZGMgKTsKICAgICAgU2VsZWN0T2JqZWN0KCBoZGNNZW0sICAoSXNab29tZWQoaHduZCkgCgkJCSAgICAgPyAoZG93biA/IGhiaXRtYXBSZXN0b3JlRCA6IGhiaXRtYXBSZXN0b3JlKQoJCQkgICAgIDogKGRvd24gPyBoYml0bWFwTWF4aW1pemVEIDogaGJpdG1hcE1heGltaXplKSkgKTsKICAgICAgQml0Qmx0KCBoZGMsIHJlY3QucmlnaHQgLSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0laRSkgLSAxLCByZWN0LnRvcCwKCQlHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0laRSkgKyAxLCBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU0laRSksIGhkY01lbSwgMCwgMCwKCQlTUkNDT1BZICk7CiAgICAgIERlbGV0ZURDKCBoZGNNZW0gKTsKICAgIH0KICAgIFdJTl9SZWxlYXNlV25kUHRyKHduZFB0cik7Cgp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBOQ19EcmF3TWluQnV0dG9uCiAqLwpzdGF0aWMgdm9pZCBOQ19EcmF3TWluQnV0dG9uKCBIV05EIGh3bmQsIEhEQzE2IGhkYywgQk9PTCBkb3duICkKewogICAgUkVDVCByZWN0OwogICAgV05EICp3bmRQdHIgPSBXSU5fRmluZFduZFB0ciggaHduZCApOwogICAgSERDIGhkY01lbTsKCiAgICBpZiggISh3bmRQdHItPmZsYWdzICYgV0lOX01BTkFHRUQpICkKICAgIHsKICAgICAgTkNfR2V0SW5zaWRlUmVjdCggaHduZCwgJnJlY3QgKTsKICAgICAgaGRjTWVtID0gQ3JlYXRlQ29tcGF0aWJsZURDKCBoZGMgKTsKICAgICAgU2VsZWN0T2JqZWN0KCBoZGNNZW0sIChkb3duID8gaGJpdG1hcE1pbmltaXplRCA6IGhiaXRtYXBNaW5pbWl6ZSkgKTsKICAgICAgaWYgKHduZFB0ci0+ZHdTdHlsZSAmIFdTX01BWElNSVpFQk9YKSByZWN0LnJpZ2h0IC09IEdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKSsxOwogICAgICBCaXRCbHQoIGhkYywgcmVjdC5yaWdodCAtIEdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKSAtIDEsIHJlY3QudG9wLAoJCUdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKSArIDEsIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lTSVpFKSwgaGRjTWVtLCAwLCAwLAoJCVNSQ0NPUFkgKTsKICAgICAgRGVsZXRlREMoIGhkY01lbSApOwogICAgfQogICAgV0lOX1JlbGVhc2VXbmRQdHIod25kUHRyKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoKICogICB2b2lkICBOQ19EcmF3U3lzQnV0dG9uOTUoCiAqICAgICAgSFdORCAgaHduZCwKICogICAgICBIREMgIGhkYywKICogICAgICBCT09MICBkb3duICkKICoKICogICBEcmF3cyB0aGUgV2luOTUgc3lzdGVtIGljb24uCiAqCiAqICAgUmV2aXNpb24gaGlzdG9yeQogKiAgICAgICAgMDUtSnVsLTE5OTcgRGF2ZSBDdXRoYmVydCAoZGFjdXRAZWNlLmNtdS5lZHUpCiAqICAgICAgICAgICAgIE9yaWdpbmFsIGltcGxlbWVudGF0aW9uIGZyb20gTkNfRHJhd1N5c0J1dHRvbiBzb3VyY2UuCiAqICAgICAgICAxMS1KdW4tMTk5OCBFcmljIEtvaGwgKGVrb2hsQGFiby5yaGVpbi16ZWl0dW5nLmRlKQogKiAgICAgICAgICAgICBGaXhlZCBtb3N0IGJ1Z3MuCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCkJPT0wKTkNfRHJhd1N5c0J1dHRvbjk1IChIV05EIGh3bmQsIEhEQyBoZGMsIEJPT0wgZG93bikKewogICAgV05EICp3bmRQdHIgPSBXSU5fRmluZFduZFB0ciggaHduZCApOwoKICAgIGlmKCAhKHduZFB0ci0+ZmxhZ3MgJiBXSU5fTUFOQUdFRCkgKQogICAgewoJSElDT04gIGhJY29uOwoJUkVDVCByZWN0OwoKCU5DX0dldEluc2lkZVJlY3Q5NSggaHduZCwgJnJlY3QgKTsKCgloSWNvbiA9IE5DX0ljb25Gb3JXaW5kb3coIHduZFB0ciApOwoKCWlmIChoSWNvbikKCSAgICBEcmF3SWNvbkV4IChoZGMsIHJlY3QubGVmdCArIDIsIHJlY3QudG9wICsgMiwgaEljb24sCgkJCSAgR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNNSUNPTiksCgkJCSAgR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNNSUNPTiksCgkJCSAgMCwgMCwgRElfTk9STUFMKTsKCiAgICAgICAgV0lOX1JlbGVhc2VXbmRQdHIod25kUHRyKTsKCXJldHVybiAoaEljb24gIT0gMCk7CiAgICB9CiAgICBXSU5fUmVsZWFzZVduZFB0cih3bmRQdHIpOwogICAgcmV0dXJuIEZBTFNFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgogKiAgIHZvaWQgIE5DX0RyYXdDbG9zZUJ1dHRvbjk1KAogKiAgICAgIEhXTkQgIGh3bmQsCiAqICAgICAgSERDICBoZGMsCiAqICAgICAgQk9PTCAgZG93biwKICogICAgICBCT09MICAgIGJHcmF5ZWQgKQogKgogKiAgIERyYXdzIHRoZSBXaW45NSBjbG9zZSBidXR0b24uCiAqCiAqICAgSWYgYkdyYXllZCBpcyB0cnVlLCB0aGVuIGRyYXcgYSBkaXNhYmxlZCBDbG9zZSBidXR0b24KICoKICogICBSZXZpc2lvbiBoaXN0b3J5CiAqICAgICAgICAxMS1KdW4tMTk5OCBFcmljIEtvaGwgKGVrb2hsQGFiby5yaGVpbi16ZWl0dW5nLmRlKQogKiAgICAgICAgICAgICBPcmlnaW5hbCBpbXBsZW1lbnRhdGlvbiBmcm9tIE5DX0RyYXdTeXNCdXR0b245NSBzb3VyY2UuCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCnN0YXRpYyB2b2lkIE5DX0RyYXdDbG9zZUJ1dHRvbjk1IChIV05EIGh3bmQsIEhEQyBoZGMsIEJPT0wgZG93biwgQk9PTCBiR3JheWVkKQp7CiAgICBSRUNUIHJlY3Q7CiAgICBIREMgaGRjTWVtOwogICAgV05EICp3bmRQdHIgPSBXSU5fRmluZFduZFB0ciggaHduZCApOwoKICAgIGlmKCAhKHduZFB0ci0+ZmxhZ3MgJiBXSU5fTUFOQUdFRCkgKQogICAgewoJQklUTUFQIGJtcDsKCUhCSVRNQVAgaEJtcCwgaE9sZEJtcDsKCglOQ19HZXRJbnNpZGVSZWN0OTUoIGh3bmQsICZyZWN0ICk7CgoJLyogQSB0b29sIHdpbmRvdyBoYXMgYSBzbWFsbGVyIENsb3NlIGJ1dHRvbiAqLwoJaWYod25kUHRyLT5kd0V4U3R5bGUgJiBXU19FWF9UT09MV0lORE9XKQoJewogICAgICAgICAgICBSRUNUIHRvb2xSZWN0OwkgICAgIAogICAgICAgICAgICBJTlQgaUJtcEhlaWdodCA9IDExOyAvKiBXaW5kb3dzIGRvZXMgbm90IHVzZSBTTV9DWFNNU0laRSBhbmQgU01fQ1lTTVNJWkUgICAqLwogICAgICAgICAgICBJTlQgaUJtcFdpZHRoID0gMTE7ICAvKiBpdCB1c2VzIDExeDExIGZvciAgdGhlIGNsb3NlIGJ1dHRvbiBpbiB0b29sIHdpbmRvdyAqLyAJICAJIAogICAgICAgICAgICBJTlQgaUNhcHRpb25IZWlnaHQgPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU01DQVBUSU9OKTsKCiAgICAgICAgICAgIHRvb2xSZWN0LnRvcCA9IHJlY3QudG9wICsgKGlDYXB0aW9uSGVpZ2h0IC0gMSAtIGlCbXBIZWlnaHQpIC8gMjsKICAgICAgICAgICAgdG9vbFJlY3QubGVmdCA9IHJlY3QucmlnaHQgLSAoaUNhcHRpb25IZWlnaHQgKyAxICsgaUJtcFdpZHRoKSAvIDI7CiAgICAgICAgICAgIHRvb2xSZWN0LmJvdHRvbSA9IHRvb2xSZWN0LnRvcCArIGlCbXBIZWlnaHQ7CiAgICAgICAgICAgIHRvb2xSZWN0LnJpZ2h0ID0gdG9vbFJlY3QubGVmdCArIGlCbXBXaWR0aDsKICAgICAgICAgICAgRHJhd0ZyYW1lQ29udHJvbChoZGMsJnRvb2xSZWN0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIERGQ19DQVBUSU9OLERGQ1NfQ0FQVElPTkNMT1NFIHwgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZG93biA/IERGQ1NfUFVTSEVEIDogMCB8IAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJHcmF5ZWQgPyBERkNTX0lOQUNUSVZFIDogMCk7Cgl9CgllbHNlCgl7CiAgICAgICAgICAgIGhkY01lbSA9IENyZWF0ZUNvbXBhdGlibGVEQyggaGRjICk7CiAgICAgICAgICAgIGhCbXAgPSBkb3duID8gaGJpdG1hcENsb3NlRCA6IGhiaXRtYXBDbG9zZTsKICAgICAgICAgICAgaE9sZEJtcCA9IFNlbGVjdE9iamVjdCAoaGRjTWVtLCBoQm1wKTsKICAgICAgICAgICAgR2V0T2JqZWN0QSAoaEJtcCwgc2l6ZW9mKEJJVE1BUCksICZibXApOwoKICAgICAgICAgICAgQml0Qmx0IChoZGMsIHJlY3QucmlnaHQgLSAoR2V0U3lzdGVtTWV0cmljcyhTTV9DWUNBUFRJT04pICsgMSArIGJtcC5ibVdpZHRoKSAvIDIsCiAgICAgICAgICAgICAgICAgICAgcmVjdC50b3AgKyAoR2V0U3lzdGVtTWV0cmljcyhTTV9DWUNBUFRJT04pIC0gMSAtIGJtcC5ibUhlaWdodCkgLyAyLAogICAgICAgICAgICAgICAgICAgIGJtcC5ibVdpZHRoLCBibXAuYm1IZWlnaHQsIGhkY01lbSwgMCwgMCwgU1JDQ09QWSk7CgogICAgICAgICAgICBpZihiR3JheWVkKQogICAgICAgICAgICAgICAgTkNfRHJhd0dyYXlCdXR0b24oaGRjLHJlY3QucmlnaHQgLSAoR2V0U3lzdGVtTWV0cmljcyhTTV9DWUNBUFRJT04pICsgMSArIGJtcC5ibVdpZHRoKSAvIDIgKyAyLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVjdC50b3AgKyAoR2V0U3lzdGVtTWV0cmljcyhTTV9DWUNBUFRJT04pIC0gMSAtIGJtcC5ibUhlaWdodCkgLyAyICsgMik7CgogICAgICAgICAgICBTZWxlY3RPYmplY3QgKGhkY01lbSwgaE9sZEJtcCk7CiAgICAgICAgICAgIERlbGV0ZURDIChoZGNNZW0pOwoJfQogICAgfQogICAgV0lOX1JlbGVhc2VXbmRQdHIod25kUHRyKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgogKiAgIE5DX0RyYXdNYXhCdXR0b245NSgKICogICAgICBIV05EICBod25kLAogKiAgICAgIEhEQzE2ICBoZGMsCiAqICAgICAgQk9PTCAgZG93biAKICogICAgICBCT09MICAgIGJHcmF5ZWQgKQogKgogKiAgIERyYXdzIHRoZSBtYXhpbWl6ZSBidXR0b24gZm9yIFdpbjk1IHN0eWxlIHdpbmRvd3MuCiAqCiAqICAgSWYgYkdyYXllZCBpcyB0cnVlLCB0aGVuIGRyYXcgYSBkaXNhYmxlZCBNYXhpbWl6ZSBidXR0b24KICoKICogICBCdWdzCiAqICAgICAgICBNYW55LiAgU3BhY2luZyBtaWdodCBzdGlsbCBiZSBpbmNvcnJlY3QuICBOZWVkIHRvIGZpdCBhIGNsb3NlCiAqICAgICAgICBidXR0b24gYmV0d2VlbiB0aGUgbWF4IGJ1dHRvbiBhbmQgdGhlIGVkZ2UuCiAqICAgICAgICBTaG91bGQgc2NhbGUgdGhlIGltYWdlIHdpdGggdGhlIHRpdGxlIGJhci4gIEFuZCBtb3JlLi4uCiAqCiAqICAgUmV2aXNpb24gaGlzdG9yeQogKiAgICAgICAgMDUtSnVsLTE5OTcgRGF2ZSBDdXRoYmVydCAoZGFjdXRAZWNlLmNtdS5lZHUpCiAqICAgICAgICAgICAgIE9yaWdpbmFsIGltcGxlbWVudGF0aW9uLgogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgpzdGF0aWMgdm9pZCBOQ19EcmF3TWF4QnV0dG9uOTUoSFdORCBod25kLEhEQzE2IGhkYyxCT09MIGRvd24sIEJPT0wgYkdyYXllZCkKewogICAgUkVDVCByZWN0OwogICAgSERDIGhkY01lbTsKICAgIFdORCAqd25kUHRyID0gV0lOX0ZpbmRXbmRQdHIoIGh3bmQgKTsKCiAgICBpZiggISh3bmRQdHItPmZsYWdzICYgV0lOX01BTkFHRUQpKQogICAgewogICAgICAgIEJJVE1BUCAgYm1wOwogICAgICAgIEhCSVRNQVAgIGhCbXAsaE9sZEJtcDsKCglOQ19HZXRJbnNpZGVSZWN0OTUoIGh3bmQsICZyZWN0ICk7CgloZGNNZW0gPSBDcmVhdGVDb21wYXRpYmxlREMoIGhkYyApOwoJaEJtcCA9IElzWm9vbWVkKGh3bmQpID8KCSAgICAoZG93biA/IGhiaXRtYXBSZXN0b3JlRCA6IGhiaXRtYXBSZXN0b3JlICkgOgoJICAgIChkb3duID8gaGJpdG1hcE1heGltaXplRDogaGJpdG1hcE1heGltaXplKTsKCWhPbGRCbXA9U2VsZWN0T2JqZWN0KCBoZGNNZW0sIGhCbXAgKTsKCUdldE9iamVjdEEgKGhCbXAsIHNpemVvZihCSVRNQVApLCAmYm1wKTsKCQoJaWYgKHduZFB0ci0+ZHdTdHlsZSAmIFdTX1NZU01FTlUpCgkgICAgcmVjdC5yaWdodCAtPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZQ0FQVElPTikgKyAxOwoJCglCaXRCbHQoIGhkYywgcmVjdC5yaWdodCAtIChHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0laRSkgKyBibXAuYm1XaWR0aCkgLyAyLAoJCSAgcmVjdC50b3AgKyAoR2V0U3lzdGVtTWV0cmljcyhTTV9DWUNBUFRJT04pIC0gMSAtIGJtcC5ibUhlaWdodCkgLyAyLAoJCSAgYm1wLmJtV2lkdGgsIGJtcC5ibUhlaWdodCwgaGRjTWVtLCAwLCAwLCBTUkNDT1BZICk7CgkKCWlmKGJHcmF5ZWQpCgkgICAgTkNfRHJhd0dyYXlCdXR0b24oaGRjLCByZWN0LnJpZ2h0IC0gKEdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKSArIGJtcC5ibVdpZHRoKSAvIDIgKyAyLAoJCQkgICAgICByZWN0LnRvcCArIChHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZQ0FQVElPTikgLSAxIC0gYm1wLmJtSGVpZ2h0KSAvIDIgKyAyKTsKCSAgICAKCQoJU2VsZWN0T2JqZWN0IChoZGNNZW0sIGhPbGRCbXApOwoJRGVsZXRlREMoIGhkY01lbSApOwogICAgfQogICAgV0lOX1JlbGVhc2VXbmRQdHIod25kUHRyKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgogKiAgIE5DX0RyYXdNaW5CdXR0b245NSgKICogICAgICBIV05EICBod25kLAogKiAgICAgIEhEQzE2ICBoZGMsCiAqICAgICAgQk9PTCAgZG93biwKICogICAgICBCT09MICAgIGJHcmF5ZWQgKQogKgogKiAgIERyYXdzIHRoZSBtaW5pbWl6ZSBidXR0b24gZm9yIFdpbjk1IHN0eWxlIHdpbmRvd3MuCiAqCiAqICAgSWYgYkdyYXllZCBpcyB0cnVlLCB0aGVuIGRyYXcgYSBkaXNhYmxlZCBNaW5pbWl6ZSBidXR0b24KICoKICogICBCdWdzCiAqICAgICAgICBNYW55LiAgU3BhY2luZyBpcyBzdGlsbCBpbmNvcnJlY3QuICBTaG91bGQgc2NhbGUgdGhlIGltYWdlIHdpdGggdGhlCiAqICAgICAgICB0aXRsZSBiYXIuICBBbmQgbW9yZS4uLgogKgogKiAgIFJldmlzaW9uIGhpc3RvcnkKICogICAgICAgIDA1LUp1bC0xOTk3IERhdmUgQ3V0aGJlcnQgKGRhY3V0QGVjZS5jbXUuZWR1KQogKiAgICAgICAgICAgICBPcmlnaW5hbCBpbXBsZW1lbnRhdGlvbi4KICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKc3RhdGljIHZvaWQgIE5DX0RyYXdNaW5CdXR0b245NShIV05EIGh3bmQsSERDMTYgaGRjLEJPT0wgZG93biwgQk9PTCBiR3JheWVkKQp7CiAgICBSRUNUIHJlY3Q7CiAgICBIREMgaGRjTWVtOwogICAgV05EICp3bmRQdHIgPSBXSU5fRmluZFduZFB0ciggaHduZCApOwoKICAgIGlmKCAhKHduZFB0ci0+ZmxhZ3MgJiBXSU5fTUFOQUdFRCkpCiAgICAgICAgCiAgICB7CiAgICAgICBCSVRNQVAgIGJtcDsKICAgICAgIEhCSVRNQVAgIGhCbXAsaE9sZEJtcDsKCQoJTkNfR2V0SW5zaWRlUmVjdDk1KCBod25kLCAmcmVjdCApOwoKICAgICAgIGhkY01lbSA9IENyZWF0ZUNvbXBhdGlibGVEQyggaGRjICk7CiAgICAgICBoQm1wID0gZG93biA/IGhiaXRtYXBNaW5pbWl6ZUQgOiBoYml0bWFwTWluaW1pemU7CiAgICAgICBoT2xkQm1wPSBTZWxlY3RPYmplY3QoIGhkY01lbSwgaEJtcCApOwoJR2V0T2JqZWN0QSAoaEJtcCwgc2l6ZW9mKEJJVE1BUCksICZibXApOwoKCWlmICh3bmRQdHItPmR3U3R5bGUgJiBXU19TWVNNRU5VKQoJICAgIHJlY3QucmlnaHQgLT0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWUNBUFRJT04pICsgMTsKCgkvKiBJbiB3aW4gOTUgdGhlcmUgaXMgYWx3YXlzIGEgTWF4aW1pemUgYm94IHdoZW4gdGhlcmUgaXMgYSBNaW5pbWl6ZSBvbmUgKi8KCWlmICgod25kUHRyLT5kd1N0eWxlICYgV1NfTUFYSU1JWkVCT1gpIHx8ICh3bmRQdHItPmR3U3R5bGUgJiBXU19NSU5JTUlaRUJPWCkpIAoJICAgIHJlY3QucmlnaHQgKz0gLTEgLSAoR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNJWkUpICsgYm1wLmJtV2lkdGgpIC8gMjsKCglCaXRCbHQoIGhkYywgcmVjdC5yaWdodCAtIChHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0laRSkgKyBibXAuYm1XaWR0aCkgLyAyLAoJCSAgcmVjdC50b3AgKyAoR2V0U3lzdGVtTWV0cmljcyhTTV9DWUNBUFRJT04pIC0gMSAtIGJtcC5ibUhlaWdodCkgLyAyLAoJCSAgYm1wLmJtV2lkdGgsIGJtcC5ibUhlaWdodCwgaGRjTWVtLCAwLCAwLCBTUkNDT1BZICk7CgoJaWYoYkdyYXllZCkKCSAgICBOQ19EcmF3R3JheUJ1dHRvbihoZGMsIHJlY3QucmlnaHQgLSAoR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNJWkUpICsgYm1wLmJtV2lkdGgpIC8gMiArIDIsCgkJCSAgICAgIHJlY3QudG9wICsgKEdldFN5c3RlbU1ldHJpY3MoU01fQ1lDQVBUSU9OKSAtIDEgLSBibXAuYm1IZWlnaHQpIC8gMiArIDIpOwoJCQkgIAoJCiAgICAgICBTZWxlY3RPYmplY3QgKGhkY01lbSwgaE9sZEJtcCk7CiAgICAgICBEZWxldGVEQyggaGRjTWVtICk7CiAgICB9CiAgICBXSU5fUmVsZWFzZVduZFB0cih3bmRQdHIpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE5DX0RyYXdGcmFtZQogKgogKiBEcmF3IGEgd2luZG93IGZyYW1lIGluc2lkZSB0aGUgZ2l2ZW4gcmVjdGFuZ2xlLCBhbmQgdXBkYXRlIHRoZSByZWN0YW5nbGUuCiAqIFRoZSBjb3JyZWN0IHBlbiBmb3IgdGhlIGZyYW1lIG11c3QgYmUgc2VsZWN0ZWQgaW4gdGhlIERDLgogKi8Kc3RhdGljIHZvaWQgTkNfRHJhd0ZyYW1lKCBIREMgaGRjLCBSRUNUICpyZWN0LCBCT09MIGRsZ0ZyYW1lLAogICAgICAgICAgICAgICAgICAgICAgICAgIEJPT0wgYWN0aXZlICkKewogICAgSU5UIHdpZHRoLCBoZWlnaHQ7CgogICAgaWYgKFRXRUFLX1dpbmVMb29rICE9IFdJTjMxX0xPT0spCglFUlIoIkNhbGxlZCBpbiBXaW45NSBtb2RlLiBBaWVlISBQbGVhc2UgcmVwb3J0IHRoaXMuXG4iICk7CgogICAgaWYgKGRsZ0ZyYW1lKQogICAgewoJd2lkdGggPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYRExHRlJBTUUpIC0gMTsKCWhlaWdodCA9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1lETEdGUkFNRSkgLSAxOwogICAgICAgIFNlbGVjdE9iamVjdCggaGRjLCBHZXRTeXNDb2xvckJydXNoKGFjdGl2ZSA/IENPTE9SX0FDVElWRUNBUFRJT04gOgoJCQkJCQlDT0xPUl9JTkFDVElWRUNBUFRJT04pICk7CiAgICB9CiAgICBlbHNlCiAgICB7Cgl3aWR0aCA9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1hGUkFNRSkgLSAyOwoJaGVpZ2h0ID0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWUZSQU1FKSAtIDI7CiAgICAgICAgU2VsZWN0T2JqZWN0KCBoZGMsIEdldFN5c0NvbG9yQnJ1c2goYWN0aXZlID8gQ09MT1JfQUNUSVZFQk9SREVSIDoKCQkJCQkJQ09MT1JfSU5BQ1RJVkVCT1JERVIpICk7CiAgICB9CgogICAgICAvKiBEcmF3IGZyYW1lICovCiAgICBQYXRCbHQoIGhkYywgcmVjdC0+bGVmdCwgcmVjdC0+dG9wLAogICAgICAgICAgICAgIHJlY3QtPnJpZ2h0IC0gcmVjdC0+bGVmdCwgaGVpZ2h0LCBQQVRDT1BZICk7CiAgICBQYXRCbHQoIGhkYywgcmVjdC0+bGVmdCwgcmVjdC0+dG9wLAogICAgICAgICAgICAgIHdpZHRoLCByZWN0LT5ib3R0b20gLSByZWN0LT50b3AsIFBBVENPUFkgKTsKICAgIFBhdEJsdCggaGRjLCByZWN0LT5sZWZ0LCByZWN0LT5ib3R0b20gLSAxLAogICAgICAgICAgICAgIHJlY3QtPnJpZ2h0IC0gcmVjdC0+bGVmdCwgLWhlaWdodCwgUEFUQ09QWSApOwogICAgUGF0Qmx0KCBoZGMsIHJlY3QtPnJpZ2h0IC0gMSwgcmVjdC0+dG9wLAogICAgICAgICAgICAgIC13aWR0aCwgcmVjdC0+Ym90dG9tIC0gcmVjdC0+dG9wLCBQQVRDT1BZICk7CgogICAgaWYgKGRsZ0ZyYW1lKQogICAgewoJSW5mbGF0ZVJlY3QoIHJlY3QsIC13aWR0aCwgLWhlaWdodCApOwogICAgfSAKICAgIGVsc2UKICAgIHsKICAgICAgICBJTlQgZGVjWU9mZiA9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1hGUkFNRSkgKyBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0laRSkgLSAxOwoJSU5UIGRlY1hPZmYgPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZRlJBTUUpICsgR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNJWkUpIC0gMTsKCiAgICAgIC8qIERyYXcgaW5uZXIgcmVjdGFuZ2xlICovCgoJU2VsZWN0T2JqZWN0KCBoZGMsIEdldFN0b2NrT2JqZWN0KE5VTExfQlJVU0gpICk7CglSZWN0YW5nbGUoIGhkYywgcmVjdC0+bGVmdCArIHdpZHRoLCByZWN0LT50b3AgKyBoZWlnaHQsCgkJICAgICByZWN0LT5yaWdodCAtIHdpZHRoICwgcmVjdC0+Ym90dG9tIC0gaGVpZ2h0ICk7CgogICAgICAvKiBEcmF3IHRoZSBkZWNvcmF0aW9ucyAqLwoKCU1vdmVUb0V4KCBoZGMsIHJlY3QtPmxlZnQsIHJlY3QtPnRvcCArIGRlY1lPZmYsIE5VTEwgKTsKCUxpbmVUbyggaGRjLCByZWN0LT5sZWZ0ICsgd2lkdGgsIHJlY3QtPnRvcCArIGRlY1lPZmYgKTsKCU1vdmVUb0V4KCBoZGMsIHJlY3QtPnJpZ2h0IC0gMSwgcmVjdC0+dG9wICsgZGVjWU9mZiwgTlVMTCApOwoJTGluZVRvKCBoZGMsIHJlY3QtPnJpZ2h0IC0gd2lkdGggLSAxLCByZWN0LT50b3AgKyBkZWNZT2ZmICk7CglNb3ZlVG9FeCggaGRjLCByZWN0LT5sZWZ0LCByZWN0LT5ib3R0b20gLSBkZWNZT2ZmLCBOVUxMICk7CglMaW5lVG8oIGhkYywgcmVjdC0+bGVmdCArIHdpZHRoLCByZWN0LT5ib3R0b20gLSBkZWNZT2ZmICk7CglNb3ZlVG9FeCggaGRjLCByZWN0LT5yaWdodCAtIDEsIHJlY3QtPmJvdHRvbSAtIGRlY1lPZmYsIE5VTEwgKTsKCUxpbmVUbyggaGRjLCByZWN0LT5yaWdodCAtIHdpZHRoIC0gMSwgcmVjdC0+Ym90dG9tIC0gZGVjWU9mZiApOwoKCU1vdmVUb0V4KCBoZGMsIHJlY3QtPmxlZnQgKyBkZWNYT2ZmLCByZWN0LT50b3AsIE5VTEwgKTsKCUxpbmVUbyggaGRjLCByZWN0LT5sZWZ0ICsgZGVjWE9mZiwgcmVjdC0+dG9wICsgaGVpZ2h0KTsKCU1vdmVUb0V4KCBoZGMsIHJlY3QtPmxlZnQgKyBkZWNYT2ZmLCByZWN0LT5ib3R0b20gLSAxLCBOVUxMICk7CglMaW5lVG8oIGhkYywgcmVjdC0+bGVmdCArIGRlY1hPZmYsIHJlY3QtPmJvdHRvbSAtIGhlaWdodCAtIDEgKTsKCU1vdmVUb0V4KCBoZGMsIHJlY3QtPnJpZ2h0IC0gZGVjWE9mZiwgcmVjdC0+dG9wLCBOVUxMICk7CglMaW5lVG8oIGhkYywgcmVjdC0+cmlnaHQgLSBkZWNYT2ZmLCByZWN0LT50b3AgKyBoZWlnaHQgKTsKCU1vdmVUb0V4KCBoZGMsIHJlY3QtPnJpZ2h0IC0gZGVjWE9mZiwgcmVjdC0+Ym90dG9tIC0gMSwgTlVMTCApOwoJTGluZVRvKCBoZGMsIHJlY3QtPnJpZ2h0IC0gZGVjWE9mZiwgcmVjdC0+Ym90dG9tIC0gaGVpZ2h0IC0gMSApOwoKCUluZmxhdGVSZWN0KCByZWN0LCAtd2lkdGggLSAxLCAtaGVpZ2h0IC0gMSApOwogICAgfQp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgogKiAgIHZvaWQgIE5DX0RyYXdGcmFtZTk1KAogKiAgICAgIEhEQyAgaGRjLAogKiAgICAgIFJFQ1QgICpyZWN0LAogKiAgICAgIEJPT0wgIGRsZ0ZyYW1lLAogKiAgICAgIEJPT0wgIGFjdGl2ZSApCiAqCiAqICAgRHJhdyBhIHdpbmRvdyBmcmFtZSBpbnNpZGUgdGhlIGdpdmVuIHJlY3RhbmdsZSwgYW5kIHVwZGF0ZSB0aGUgcmVjdGFuZ2xlLgogKiAgIFRoZSBjb3JyZWN0IHBlbiBmb3IgdGhlIGZyYW1lIG11c3QgYmUgc2VsZWN0ZWQgaW4gdGhlIERDLgogKgogKiAgIEJ1Z3MKICogICAgICAgIE1hbnkuICBGaXJzdCwganVzdCB3aGF0IElTIGEgZnJhbWUgaW4gV2luOTU/ICBOb3RlIHRoYXQgdGhlIDNEIGxvb2sKICogICAgICAgIG9uIHRoZSBvdXRlciBlZGdlIGlzIGhhbmRsZWQgYnkgTkNfRG9OQ1BhaW50OTUuICBBcyBpcyB0aGUgaW5uZXIKICogICAgICAgIGVkZ2UuICBUaGUgaW5uZXIgcmVjdGFuZ2xlIGp1c3QgaW5zaWRlIHRoZSBmcmFtZSBpcyBoYW5kbGVkIGJ5IHRoZQogKiAgICAgICAgQ2FwdGlvbiBjb2RlLgogKgogKiAgICAgICAgSW4gc2hvcnQsIGZvciBtb3N0IHBlb3BsZSwgdGhpcyBmdW5jdGlvbiBzaG91bGQgYmUgYSBub3AgKHVubGVzcwogKiAgICAgICAgeW91IExJS0UgdGhpY2sgYm9yZGVycyBpbiBXaW45NS9OVDQuMCAtLSBJJ3ZlIGJlZW4gd29ya2luZyB3aXRoCiAqICAgICAgICB0aGVtIGxhdGVseSwgYnV0IGp1c3QgdG8gZ2V0IHRoaXMgY29kZSByaWdodCkuICBFdmVuIHNvLCBpdCBkb2Vzbid0CiAqICAgICAgICBhcHBlYXIgdG8gYmUgc28uICBJdCdzIGJlaW5nIHdvcmtlZCBvbi4uLgogKiAKICogICBSZXZpc2lvbiBoaXN0b3J5CiAqICAgICAgICAwNi1KdWwtMTk5NyBEYXZlIEN1dGhiZXJ0IChkYWN1dEBlY2UuY211LmVkdSkKICogICAgICAgICAgICAgT3JpZ2luYWwgaW1wbGVtZW50YXRpb24gKGJhc2VkIG9uIE5DX0RyYXdGcmFtZSkKICogICAgICAgIDAyLUp1bi0xOTk4IEVyaWMgS29obCAoZWtvaGxAYWJvLnJoZWluLXplaXR1bmcuZGUpCiAqICAgICAgICAgICAgIFNvbWUgbWlub3IgZml4ZXMuCiAqICAgICAgICAyOS1KdW4tMTk5OSBPdmUgS+V2ZW4gKG92ZWtAYXJjdGljbmV0Lm5vKQogKiAgICAgICAgICAgICBGaXhlZCBhIGZpeCBvciBzb21ldGhpbmcuCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCnN0YXRpYyB2b2lkICBOQ19EcmF3RnJhbWU5NSgKICAgIEhEQyAgaGRjLAogICAgUkVDVCAgKnJlY3QsCiAgICBCT09MICBkbGdGcmFtZSwKICAgIEJPT0wgIGFjdGl2ZSApCnsKICAgIElOVCB3aWR0aCwgaGVpZ2h0OwoKICAgIGlmIChkbGdGcmFtZSkKICAgIHsKCXdpZHRoID0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWERMR0ZSQU1FKSAtIEdldFN5c3RlbU1ldHJpY3MoU01fQ1hFREdFKTsKCWhlaWdodCA9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1lETEdGUkFNRSkgLSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZRURHRSk7CiAgICB9CiAgICBlbHNlCiAgICB7Cgl3aWR0aCA9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1hGUkFNRSkgLSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYRURHRSk7CgloZWlnaHQgPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZRlJBTUUpIC0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWUVER0UpOwogICAgfQoKICAgIFNlbGVjdE9iamVjdCggaGRjLCBHZXRTeXNDb2xvckJydXNoKGFjdGl2ZSA/IENPTE9SX0FDVElWRUJPUkRFUiA6CgkJQ09MT1JfSU5BQ1RJVkVCT1JERVIpICk7CgogICAgLyogRHJhdyBmcmFtZSAqLwogICAgUGF0Qmx0KCBoZGMsIHJlY3QtPmxlZnQsIHJlY3QtPnRvcCwKICAgICAgICAgICAgICByZWN0LT5yaWdodCAtIHJlY3QtPmxlZnQsIGhlaWdodCwgUEFUQ09QWSApOwogICAgUGF0Qmx0KCBoZGMsIHJlY3QtPmxlZnQsIHJlY3QtPnRvcCwKICAgICAgICAgICAgICB3aWR0aCwgcmVjdC0+Ym90dG9tIC0gcmVjdC0+dG9wLCBQQVRDT1BZICk7CiAgICBQYXRCbHQoIGhkYywgcmVjdC0+bGVmdCwgcmVjdC0+Ym90dG9tIC0gMSwKICAgICAgICAgICAgICByZWN0LT5yaWdodCAtIHJlY3QtPmxlZnQsIC1oZWlnaHQsIFBBVENPUFkgKTsKICAgIFBhdEJsdCggaGRjLCByZWN0LT5yaWdodCAtIDEsIHJlY3QtPnRvcCwKICAgICAgICAgICAgICAtd2lkdGgsIHJlY3QtPmJvdHRvbSAtIHJlY3QtPnRvcCwgUEFUQ09QWSApOwoKICAgIEluZmxhdGVSZWN0KCByZWN0LCAtd2lkdGgsIC1oZWlnaHQgKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBOQ19EcmF3TW92aW5nRnJhbWUKICoKICogRHJhdyB0aGUgZnJhbWUgdXNlZCB3aGVuIG1vdmluZyBvciByZXNpemluZyB3aW5kb3cuCiAqCiAqIEZJWE1FOiAgVGhpcyBjYXVzZXMgcHJvYmxlbXMgaW4gV2luOTUgbW9kZS4gICh3aHk/KQogKi8Kc3RhdGljIHZvaWQgTkNfRHJhd01vdmluZ0ZyYW1lKCBIREMgaGRjLCBSRUNUICpyZWN0LCBCT09MIHRoaWNrZnJhbWUgKQp7CiAgICBpZiAodGhpY2tmcmFtZSkKICAgIHsKICAgICAgICBSRUNUMTYgcjE2OwogICAgICAgIENPTlZfUkVDVDMyVE8xNiggcmVjdCwgJnIxNiApOwogICAgICAgIEZhc3RXaW5kb3dGcmFtZTE2KCBoZGMsICZyMTYsIEdldFN5c3RlbU1ldHJpY3MoU01fQ1hGUkFNRSksCiAgICAgICAgICAgICAgICAgICAgICAgICBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZRlJBTUUpLCBQQVRJTlZFUlQgKTsKICAgIH0KICAgIGVsc2UgRHJhd0ZvY3VzUmVjdCggaGRjLCByZWN0ICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE5DX0RyYXdDYXB0aW9uCiAqCiAqIERyYXcgdGhlIHdpbmRvdyBjYXB0aW9uLgogKiBUaGUgY29ycmVjdCBwZW4gZm9yIHRoZSB3aW5kb3cgZnJhbWUgbXVzdCBiZSBzZWxlY3RlZCBpbiB0aGUgREMuCiAqLwpzdGF0aWMgdm9pZCBOQ19EcmF3Q2FwdGlvbiggSERDIGhkYywgUkVDVCAqcmVjdCwgSFdORCBod25kLAoJCQkgICAgRFdPUkQgc3R5bGUsIEJPT0wgYWN0aXZlICkKewogICAgUkVDVCByID0gKnJlY3Q7CiAgICBXTkQgKiB3bmRQdHIgPSBXSU5fRmluZFduZFB0ciggaHduZCApOwogICAgY2hhciBidWZmZXJbMjU2XTsKCiAgICBpZiAod25kUHRyLT5mbGFncyAmIFdJTl9NQU5BR0VEKQogICAgewogICAgICAgIFdJTl9SZWxlYXNlV25kUHRyKHduZFB0cik7CiAgICAgICAgcmV0dXJuOwogICAgfQoKICAgIGlmICghaGJpdG1hcENsb3NlKQogICAgewoJaWYgKCEoaGJpdG1hcENsb3NlID0gTG9hZEJpdG1hcDE2KCAwLCBNQUtFSU5UUkVTT1VSQ0UxNihPQk1fQ0xPU0UpICkpKQogICAgICAgIHsKICAgICAgICAgICAgV0lOX1JlbGVhc2VXbmRQdHIod25kUHRyKTsKCSAgICByZXR1cm47CiAgICAgICAgfQoJaGJpdG1hcENsb3NlRCAgICA9IExvYWRCaXRtYXAxNiggMCwgTUFLRUlOVFJFU09VUkNFMTYoT0JNX0NMT1NFRCkgKTsKCWhiaXRtYXBNaW5pbWl6ZSAgPSBMb2FkQml0bWFwMTYoIDAsIE1BS0VJTlRSRVNPVVJDRTE2KE9CTV9SRURVQ0UpICk7CgloYml0bWFwTWluaW1pemVEID0gTG9hZEJpdG1hcDE2KCAwLCBNQUtFSU5UUkVTT1VSQ0UxNihPQk1fUkVEVUNFRCkgKTsKCWhiaXRtYXBNYXhpbWl6ZSAgPSBMb2FkQml0bWFwMTYoIDAsIE1BS0VJTlRSRVNPVVJDRTE2KE9CTV9aT09NKSApOwoJaGJpdG1hcE1heGltaXplRCA9IExvYWRCaXRtYXAxNiggMCwgTUFLRUlOVFJFU09VUkNFMTYoT0JNX1pPT01EKSApOwoJaGJpdG1hcFJlc3RvcmUgICA9IExvYWRCaXRtYXAxNiggMCwgTUFLRUlOVFJFU09VUkNFMTYoT0JNX1JFU1RPUkUpICk7CgloYml0bWFwUmVzdG9yZUQgID0gTG9hZEJpdG1hcDE2KCAwLCBNQUtFSU5UUkVTT1VSQ0UxNihPQk1fUkVTVE9SRUQpICk7CiAgICB9CiAgICAKICAgIGlmICh3bmRQdHItPmR3RXhTdHlsZSAmIFdTX0VYX0RMR01PREFMRlJBTUUpCiAgICB7CiAgICAgICAgSEJSVVNIIGhicnVzaE9sZCA9IFNlbGVjdE9iamVjdChoZGMsIEdldFN5c0NvbG9yQnJ1c2goQ09MT1JfV0lORE9XKSApOwoJUGF0Qmx0KCBoZGMsIHIubGVmdCwgci50b3AsIDEsIHIuYm90dG9tLXIudG9wKzEsUEFUQ09QWSApOwoJUGF0Qmx0KCBoZGMsIHIucmlnaHQtMSwgci50b3AsIDEsIHIuYm90dG9tLXIudG9wKzEsIFBBVENPUFkgKTsKCVBhdEJsdCggaGRjLCByLmxlZnQsIHIudG9wLTEsIHIucmlnaHQtci5sZWZ0LCAxLCBQQVRDT1BZICk7CglyLmxlZnQrKzsKCXIucmlnaHQtLTsKCVNlbGVjdE9iamVjdCggaGRjLCBoYnJ1c2hPbGQgKTsKICAgIH0KICAgIFdJTl9SZWxlYXNlV25kUHRyKHduZFB0cik7CiAgICBNb3ZlVG9FeCggaGRjLCByLmxlZnQsIHIuYm90dG9tLCBOVUxMICk7CiAgICBMaW5lVG8oIGhkYywgci5yaWdodCwgci5ib3R0b20gKTsKCiAgICBpZiAoc3R5bGUgJiBXU19TWVNNRU5VKQogICAgewoJTkNfRHJhd1N5c0J1dHRvbiggaHduZCwgaGRjLCBGQUxTRSApOwoJci5sZWZ0ICs9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKSArIDE7CglNb3ZlVG9FeCggaGRjLCByLmxlZnQgLSAxLCByLnRvcCwgTlVMTCApOwoJTGluZVRvKCBoZGMsIHIubGVmdCAtIDEsIHIuYm90dG9tICk7CiAgICB9CiAgICBpZiAoc3R5bGUgJiBXU19NQVhJTUlaRUJPWCkKICAgIHsKCU5DX0RyYXdNYXhCdXR0b24oIGh3bmQsIGhkYywgRkFMU0UgKTsKCXIucmlnaHQgLT0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNJWkUpICsgMTsKICAgIH0KICAgIGlmIChzdHlsZSAmIFdTX01JTklNSVpFQk9YKQogICAgewoJTkNfRHJhd01pbkJ1dHRvbiggaHduZCwgaGRjLCBGQUxTRSApOwoJci5yaWdodCAtPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0laRSkgKyAxOwogICAgfQoKICAgIEZpbGxSZWN0KCBoZGMsICZyLCBHZXRTeXNDb2xvckJydXNoKGFjdGl2ZSA/IENPTE9SX0FDVElWRUNBUFRJT04gOgoJCQkJCSAgICBDT0xPUl9JTkFDVElWRUNBUFRJT04pICk7CgogICAgaWYgKEdldFdpbmRvd1RleHRBKCBod25kLCBidWZmZXIsIHNpemVvZihidWZmZXIpICkpCiAgICB7CglpZiAoYWN0aXZlKSBTZXRUZXh0Q29sb3IoIGhkYywgR2V0U3lzQ29sb3IoIENPTE9SX0NBUFRJT05URVhUICkgKTsKCWVsc2UgU2V0VGV4dENvbG9yKCBoZGMsIEdldFN5c0NvbG9yKCBDT0xPUl9JTkFDVElWRUNBUFRJT05URVhUICkgKTsKCVNldEJrTW9kZSggaGRjLCBUUkFOU1BBUkVOVCApOwoJRHJhd1RleHRBKCBoZGMsIGJ1ZmZlciwgLTEsICZyLAogICAgICAgICAgICAgICAgICAgICBEVF9TSU5HTEVMSU5FIHwgRFRfQ0VOVEVSIHwgRFRfVkNFTlRFUiB8IERUX05PUFJFRklYICk7CiAgICB9Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCiAqICAgTkNfRHJhd0NhcHRpb245NSgKICogICAgICBIREMgIGhkYywKICogICAgICBSRUNUICpyZWN0LAogKiAgICAgIEhXTkQgaHduZCwKICogICAgICBEV09SRCAgc3R5bGUsCiAqICAgICAgQk9PTCBhY3RpdmUgKQogKgogKiAgIERyYXcgdGhlIHdpbmRvdyBjYXB0aW9uIGZvciBXaW45NSBzdHlsZSB3aW5kb3dzLgogKiAgIFRoZSBjb3JyZWN0IHBlbiBmb3IgdGhlIHdpbmRvdyBmcmFtZSBtdXN0IGJlIHNlbGVjdGVkIGluIHRoZSBEQy4KICoKICogICBCdWdzCiAqICAgICAgICBIZXksIGEgZnVuY3Rpb24gdGhhdCBmaW5hbGx5IHdvcmtzISAgV2VsbCwgYWxtb3N0LgogKiAgICAgICAgSXQncyBiZWluZyB3b3JrZWQgb24uCiAqCiAqICAgUmV2aXNpb24gaGlzdG9yeQogKiAgICAgICAgMDUtSnVsLTE5OTcgRGF2ZSBDdXRoYmVydCAoZGFjdXRAZWNlLmNtdS5lZHUpCiAqICAgICAgICAgICAgIE9yaWdpbmFsIGltcGxlbWVudGF0aW9uLgogKiAgICAgICAgMDItSnVuLTE5OTggRXJpYyBLb2hsIChla29obEBhYm8ucmhlaW4temVpdHVuZy5kZSkKICogICAgICAgICAgICAgU29tZSBtaW5vciBmaXhlcy4KICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKc3RhdGljIHZvaWQgIE5DX0RyYXdDYXB0aW9uOTUoCiAgICBIREMgIGhkYywKICAgIFJFQ1QgKnJlY3QsCiAgICBIV05EIGh3bmQsCiAgICBEV09SRCAgc3R5bGUsCiAgICBEV09SRCAgZXhTdHlsZSwKICAgIEJPT0wgYWN0aXZlICkKewogICAgUkVDVCAgciA9ICpyZWN0OwogICAgV05EICAgICAqd25kUHRyID0gV0lOX0ZpbmRXbmRQdHIoIGh3bmQgKTsKICAgIGNoYXIgICAgYnVmZmVyWzI1Nl07CiAgICBIUEVOICBoUHJldlBlbjsKICAgIEhNRU5VIGhTeXNNZW51OwoKICAgIGlmICh3bmRQdHItPmZsYWdzICYgV0lOX01BTkFHRUQpCiAgICB7CiAgICAgICAgV0lOX1JlbGVhc2VXbmRQdHIod25kUHRyKTsKICAgICAgICByZXR1cm47CiAgICB9CiAgICBXSU5fUmVsZWFzZVduZFB0cih3bmRQdHIpOwoKICAgIGhQcmV2UGVuID0gU2VsZWN0T2JqZWN0KCBoZGMsIEdldFN5c0NvbG9yUGVuKENPTE9SXzNERkFDRSkgKTsKICAgIE1vdmVUb0V4KCBoZGMsIHIubGVmdCwgci5ib3R0b20gLSAxLCBOVUxMICk7CiAgICBMaW5lVG8oIGhkYywgci5yaWdodCwgci5ib3R0b20gLSAxICk7CiAgICBTZWxlY3RPYmplY3QoIGhkYywgaFByZXZQZW4gKTsKICAgIHIuYm90dG9tLS07CgogICAgRmlsbFJlY3QoIGhkYywgJnIsIEdldFN5c0NvbG9yQnJ1c2goYWN0aXZlID8gQ09MT1JfQUNUSVZFQ0FQVElPTiA6CgkJCQkJICAgIENPTE9SX0lOQUNUSVZFQ0FQVElPTikgKTsKCiAgICBpZiAoIWhiaXRtYXBDbG9zZSkgewoJaWYgKCEoaGJpdG1hcENsb3NlID0gTG9hZEJpdG1hcDE2KCAwLCBNQUtFSU5UUkVTT1VSQ0UxNihPQk1fQ0xPU0UpICkpKQoJICAgIHJldHVybjsKICAgICAgICBoYml0bWFwQ2xvc2VEID0gTG9hZEJpdG1hcDE2KCAwLCBNQUtFSU5UUkVTT1VSQ0UxNihPQk1fQ0xPU0VEKSk7CgloYml0bWFwTWluaW1pemUgID0gTG9hZEJpdG1hcDE2KCAwLCBNQUtFSU5UUkVTT1VSQ0UxNihPQk1fUkVEVUNFKSApOwoJaGJpdG1hcE1pbmltaXplRCA9IExvYWRCaXRtYXAxNiggMCwgTUFLRUlOVFJFU09VUkNFMTYoT0JNX1JFRFVDRUQpICk7CgloYml0bWFwTWF4aW1pemUgID0gTG9hZEJpdG1hcDE2KCAwLCBNQUtFSU5UUkVTT1VSQ0UxNihPQk1fWk9PTSkgKTsKCWhiaXRtYXBNYXhpbWl6ZUQgPSBMb2FkQml0bWFwMTYoIDAsIE1BS0VJTlRSRVNPVVJDRTE2KE9CTV9aT09NRCkgKTsKCWhiaXRtYXBSZXN0b3JlICAgPSBMb2FkQml0bWFwMTYoIDAsIE1BS0VJTlRSRVNPVVJDRTE2KE9CTV9SRVNUT1JFKSApOwoJaGJpdG1hcFJlc3RvcmVEICA9IExvYWRCaXRtYXAxNiggMCwgTUFLRUlOVFJFU09VUkNFMTYoT0JNX1JFU1RPUkVEKSApOwogICAgfQogICAgCiAgICBpZiAoKHN0eWxlICYgV1NfU1lTTUVOVSkgJiYgIShleFN0eWxlICYgV1NfRVhfVE9PTFdJTkRPVykpIHsKCWlmIChOQ19EcmF3U3lzQnV0dG9uOTUgKGh3bmQsIGhkYywgRkFMU0UpKQoJICAgIHIubGVmdCArPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZQ0FQVElPTikgLSAxOwogICAgfQoKICAgIGlmIChzdHlsZSAmIFdTX1NZU01FTlUpIAogICAgewoJVUlOVCBzdGF0ZTsKCgkvKiBHbyBnZXQgdGhlIHN5c21lbnUgKi8KCWhTeXNNZW51ID0gR2V0U3lzdGVtTWVudShod25kLCBGQUxTRSk7CglzdGF0ZSA9IEdldE1lbnVTdGF0ZShoU3lzTWVudSwgU0NfQ0xPU0UsIE1GX0JZQ09NTUFORCk7CgoJLyogRHJhdyBhIGdyYXllZCBjbG9zZSBidXR0b24gaWYgZGlzYWJsZWQgYW5kIGEgbm9ybWFsIG9uZSBpZiBTQ19DTE9TRSBpcyBub3QgdGhlcmUgKi8KCU5DX0RyYXdDbG9zZUJ1dHRvbjk1IChod25kLCBoZGMsIEZBTFNFLCAKCQkJICAgICAgKCgoKHN0YXRlICYgTUZfRElTQUJMRUQpIHx8IChzdGF0ZSAmIE1GX0dSQVlFRCkpKSAmJiAoc3RhdGUgIT0gMHhGRkZGRkZGRikpKTsKCXIucmlnaHQgLT0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWUNBUFRJT04pIC0gMTsKCglpZiAoKHN0eWxlICYgV1NfTUFYSU1JWkVCT1gpIHx8IChzdHlsZSAmIFdTX01JTklNSVpFQk9YKSkKCXsKCSAgICAvKiBJbiB3aW45NSB0aGUgdHdvIGJ1dHRvbnMgYXJlIGFsd2F5cyB0aGVyZSAqLwoJICAgIC8qIEJ1dCBpZiB0aGUgbWVudSBpdGVtIGlzIG5vdCBpbiB0aGUgbWVudSB0aGV5J3JlIGRpc2FibGVkKi8KCgkgICAgTkNfRHJhd01heEJ1dHRvbjk1KCBod25kLCBoZGMsIEZBTFNFLCAoIShzdHlsZSAmIFdTX01BWElNSVpFQk9YKSkpOwoJICAgIHIucmlnaHQgLT0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNJWkUpICsgMTsKCSAgICAKCSAgICBOQ19EcmF3TWluQnV0dG9uOTUoIGh3bmQsIGhkYywgRkFMU0UsICAoIShzdHlsZSAmIFdTX01JTklNSVpFQk9YKSkpOwoJICAgIHIucmlnaHQgLT0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNJWkUpICsgMTsKCX0KICAgIH0KCiAgICBpZiAoR2V0V2luZG93VGV4dEEoIGh3bmQsIGJ1ZmZlciwgc2l6ZW9mKGJ1ZmZlcikgKSkgewoJTk9OQ0xJRU5UTUVUUklDU0EgbmNsbTsKCUhGT05UIGhGb250LCBoT2xkRm9udDsKCW5jbG0uY2JTaXplID0gc2l6ZW9mKE5PTkNMSUVOVE1FVFJJQ1NBKTsKCVN5c3RlbVBhcmFtZXRlcnNJbmZvQSAoU1BJX0dFVE5PTkNMSUVOVE1FVFJJQ1MsIDAsICZuY2xtLCAwKTsKCWlmIChleFN0eWxlICYgV1NfRVhfVE9PTFdJTkRPVykKCSAgICBoRm9udCA9IENyZWF0ZUZvbnRJbmRpcmVjdEEgKCZuY2xtLmxmU21DYXB0aW9uRm9udCk7CgllbHNlCgkgICAgaEZvbnQgPSBDcmVhdGVGb250SW5kaXJlY3RBICgmbmNsbS5sZkNhcHRpb25Gb250KTsKCWhPbGRGb250ID0gU2VsZWN0T2JqZWN0IChoZGMsIGhGb250KTsKCWlmIChhY3RpdmUpIFNldFRleHRDb2xvciggaGRjLCBHZXRTeXNDb2xvciggQ09MT1JfQ0FQVElPTlRFWFQgKSApOwoJZWxzZSBTZXRUZXh0Q29sb3IoIGhkYywgR2V0U3lzQ29sb3IoIENPTE9SX0lOQUNUSVZFQ0FQVElPTlRFWFQgKSApOwoJU2V0QmtNb2RlKCBoZGMsIFRSQU5TUEFSRU5UICk7CglyLmxlZnQgKz0gMjsKCURyYXdUZXh0QSggaGRjLCBidWZmZXIsIC0xLCAmciwKCQkgICAgIERUX1NJTkdMRUxJTkUgfCBEVF9WQ0VOVEVSIHwgRFRfTk9QUkVGSVggfCBEVF9MRUZUICk7CglEZWxldGVPYmplY3QgKFNlbGVjdE9iamVjdCAoaGRjLCBoT2xkRm9udCkpOwogICAgfQp9CgoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTkNfRG9OQ1BhaW50CiAqCiAqIFBhaW50IHRoZSBub24tY2xpZW50IGFyZWEuIGNsaXAgaXMgY3VycmVudGx5IHVudXNlZC4KICovCnN0YXRpYyB2b2lkIE5DX0RvTkNQYWludCggV05EKiB3bmRQdHIsIEhSR04gY2xpcCwgQk9PTCBzdXBwcmVzc19tZW51cGFpbnQgKQp7CiAgICBIREMgaGRjOwogICAgUkVDVCByZWN0OwogICAgQk9PTCBhY3RpdmU7CiAgICBIV05EIGh3bmQgPSB3bmRQdHItPmh3bmRTZWxmOwoKICAgIGlmICggd25kUHRyLT5kd1N0eWxlICYgV1NfTUlOSU1JWkUgfHwKCSFXSU5fSXNXaW5kb3dEcmF3YWJsZSggd25kUHRyLCAwICkpIHJldHVybjsgLyogTm90aGluZyB0byBkbyAqLwoKICAgIGFjdGl2ZSAgPSB3bmRQdHItPmZsYWdzICYgV0lOX05DQUNUSVZBVEVEOwoKICAgIFRSQUNFKCIlMDR4ICVkXG4iLCBod25kLCBhY3RpdmUgKTsKCiAgICBpZiAoIShoZGMgPSBHZXREQ0V4KCBod25kLCAoY2xpcCA+IDEpID8gY2xpcCA6IDAsIERDWF9VU0VTVFlMRSB8IERDWF9XSU5ET1cgfAoJCQkgICAgICAoKGNsaXAgPiAxKSA/IChEQ1hfSU5URVJTRUNUUkdOIHwgRENYX0tFRVBDTElQUkdOKTogMCkgKSkpIHJldHVybjsKCiAgICBpZiAoRXhjbHVkZVZpc1JlY3QxNiggaGRjLCB3bmRQdHItPnJlY3RDbGllbnQubGVmdC13bmRQdHItPnJlY3RXaW5kb3cubGVmdCwKCQkgICAgICAgIHduZFB0ci0+cmVjdENsaWVudC50b3Atd25kUHRyLT5yZWN0V2luZG93LnRvcCwKCQkgICAgICAgIHduZFB0ci0+cmVjdENsaWVudC5yaWdodC13bmRQdHItPnJlY3RXaW5kb3cubGVmdCwKCQkgICAgICAgIHduZFB0ci0+cmVjdENsaWVudC5ib3R0b20td25kUHRyLT5yZWN0V2luZG93LnRvcCApCgk9PSBOVUxMUkVHSU9OKQogICAgewoJUmVsZWFzZURDKCBod25kLCBoZGMgKTsKCXJldHVybjsKICAgIH0KCiAgICByZWN0LnRvcCA9IHJlY3QubGVmdCA9IDA7CiAgICByZWN0LnJpZ2h0ICA9IHduZFB0ci0+cmVjdFdpbmRvdy5yaWdodCAtIHduZFB0ci0+cmVjdFdpbmRvdy5sZWZ0OwogICAgcmVjdC5ib3R0b20gPSB3bmRQdHItPnJlY3RXaW5kb3cuYm90dG9tIC0gd25kUHRyLT5yZWN0V2luZG93LnRvcDsKCiAgICBTZWxlY3RPYmplY3QoIGhkYywgR2V0U3lzQ29sb3JQZW4oQ09MT1JfV0lORE9XRlJBTUUpICk7CgogICAgaWYgKCEod25kUHRyLT5mbGFncyAmIFdJTl9NQU5BR0VEKSkKICAgIHsKICAgICAgICBpZiAoSEFTX0FOWUZSQU1FKCB3bmRQdHItPmR3U3R5bGUsIHduZFB0ci0+ZHdFeFN0eWxlICkpCgl7CgkgICAgU2VsZWN0T2JqZWN0KCBoZGMsIEdldFN0b2NrT2JqZWN0KE5VTExfQlJVU0gpICk7CiAgICAgICAgICAgIFJlY3RhbmdsZSggaGRjLCAwLCAwLCByZWN0LnJpZ2h0LCByZWN0LmJvdHRvbSApOwogICAgICAgICAgICBJbmZsYXRlUmVjdCggJnJlY3QsIC0xLCAtMSApOwogICAgICAgIH0KCglpZiAoSEFTX1RISUNLRlJBTUUoIHduZFB0ci0+ZHdTdHlsZSwgd25kUHRyLT5kd0V4U3R5bGUgKSkKICAgICAgICAgICAgTkNfRHJhd0ZyYW1lKGhkYywgJnJlY3QsIEZBTFNFLCBhY3RpdmUgKTsKCWVsc2UgaWYgKEhBU19ETEdGUkFNRSggd25kUHRyLT5kd1N0eWxlLCB3bmRQdHItPmR3RXhTdHlsZSApKSAKICAgICAgICAgICAgTkNfRHJhd0ZyYW1lKCBoZGMsICZyZWN0LCBUUlVFLCBhY3RpdmUgKTsKCiAgICAgICAgaWYgKCh3bmRQdHItPmR3U3R5bGUgJiBXU19DQVBUSU9OKSA9PSBXU19DQVBUSU9OKQogICAgICAgIHsKICAgICAgICAgICAgUkVDVCByID0gcmVjdDsKICAgICAgICAgICAgci5ib3R0b20gPSByZWN0LnRvcCArIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lTSVpFKTsKICAgICAgICAgICAgcmVjdC50b3AgKz0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNJWkUpICsgR2V0U3lzdGVtTWV0cmljcyhTTV9DWUJPUkRFUik7CiAgICAgICAgICAgIE5DX0RyYXdDYXB0aW9uKCBoZGMsICZyLCBod25kLCB3bmRQdHItPmR3U3R5bGUsIGFjdGl2ZSApOwogICAgICAgIH0KICAgIH0KCiAgICBpZiAoSEFTX01FTlUod25kUHRyKSkKICAgIHsKCVJFQ1QgciA9IHJlY3Q7CglyLmJvdHRvbSA9IHJlY3QudG9wICsgR2V0U3lzdGVtTWV0cmljcyhTTV9DWU1FTlUpOyAgLyogZGVmYXVsdCBoZWlnaHQgKi8KCXJlY3QudG9wICs9IE1FTlVfRHJhd01lbnVCYXIoIGhkYywgJnIsIGh3bmQsIHN1cHByZXNzX21lbnVwYWludCApOwogICAgfQoKICAgICAgLyogRHJhdyB0aGUgc2Nyb2xsLWJhcnMgKi8KCiAgICBpZiAod25kUHRyLT5kd1N0eWxlICYgV1NfVlNDUk9MTCkKICAgICAgICBTQ1JPTExfRHJhd1Njcm9sbEJhciggaHduZCwgaGRjLCBTQl9WRVJULCBUUlVFLCBUUlVFICk7CiAgICBpZiAod25kUHRyLT5kd1N0eWxlICYgV1NfSFNDUk9MTCkKICAgICAgICBTQ1JPTExfRHJhd1Njcm9sbEJhciggaHduZCwgaGRjLCBTQl9IT1JaLCBUUlVFLCBUUlVFICk7CgogICAgICAvKiBEcmF3IHRoZSAic2l6ZS1ib3giICovCgogICAgaWYgKCh3bmRQdHItPmR3U3R5bGUgJiBXU19WU0NST0xMKSAmJiAod25kUHRyLT5kd1N0eWxlICYgV1NfSFNDUk9MTCkpCiAgICB7CiAgICAgICAgUkVDVCByID0gcmVjdDsKICAgICAgICByLmxlZnQgPSByLnJpZ2h0IC0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWFZTQ1JPTEwpICsgMTsKICAgICAgICByLnRvcCAgPSByLmJvdHRvbSAtIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lIU0NST0xMKSArIDE7CglpZih3bmRQdHItPmR3U3R5bGUgJiBXU19CT1JERVIpIHsKCSAgci5sZWZ0Kys7CgkgIHIudG9wKys7Cgl9CiAgICAgICAgRmlsbFJlY3QoIGhkYywgJnIsIEdldFN5c0NvbG9yQnJ1c2goQ09MT1JfU0NST0xMQkFSKSApOwogICAgfSAgICAKCiAgICBSZWxlYXNlREMoIGh3bmQsIGhkYyApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgogKiAgIHZvaWQgIE5DX0RvTkNQYWludDk1KAogKiAgICAgIFdORCAgKnduZFB0ciwKICogICAgICBIUkdOICBjbGlwLAogKiAgICAgIEJPT0wgIHN1cHByZXNzX21lbnVwYWludCApCiAqCiAqICAgUGFpbnQgdGhlIG5vbi1jbGllbnQgYXJlYSBmb3IgV2luOTUgd2luZG93cy4gIFRoZSBjbGlwIHJlZ2lvbiBpcwogKiAgIGN1cnJlbnRseSBpZ25vcmVkLgogKgogKiAgIEJ1Z3MKICogICAgICAgIGdyZXAgLUUgLUExMCAtQjUgXCg5NVwpXHxcKEJ1Z3NcKVx8XChGSVhNRVwpIHdpbmRvd3Mvbm9uY2xpZW50LmMgXAogKiAgICAgICAgICAgbWlzYy90d2Vhay5jIGNvbnRyb2xzL21lbnUuYyAgIyA6LSkKICoKICogICBSZXZpc2lvbiBoaXN0b3J5CiAqICAgICAgICAwMy1KdWwtMTk5NyBEYXZlIEN1dGhiZXJ0IChkYWN1dEBlY2UuY211LmVkdSkKICogICAgICAgICAgICAgT3JpZ2luYWwgaW1wbGVtZW50YXRpb24KICogICAgICAgIDEwLUp1bi0xOTk4IEVyaWMgS29obCAoZWtvaGxAYWJvLnJoZWluLXplaXR1bmcuZGUpCiAqICAgICAgICAgICAgIEZpeGVkIHNvbWUgYnVncy4KICogICAgICAgIDI5LUp1bi0xOTk5IE92ZSBL5XZlbiAob3Zla0BhcmN0aWNuZXQubm8pCiAqICAgICAgICAgICAgIFN0cmVhbWxpbmVkIHdpbmRvdyBzdHlsZSBjaGVja3MuCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCnN0YXRpYyB2b2lkICBOQ19Eb05DUGFpbnQ5NSgKICAgIFdORCAgKnduZFB0ciwKICAgIEhSR04gIGNsaXAsCiAgICBCT09MICBzdXBwcmVzc19tZW51cGFpbnQgKQp7CiAgICBIREMgaGRjOwogICAgUkVDVCByZnV6eiwgcmVjdCwgcmVjdENsaXA7CiAgICBCT09MIGFjdGl2ZTsKICAgIEhXTkQgaHduZCA9IHduZFB0ci0+aHduZFNlbGY7CgogICAgaWYgKCB3bmRQdHItPmR3U3R5bGUgJiBXU19NSU5JTUlaRSB8fAoJIVdJTl9Jc1dpbmRvd0RyYXdhYmxlKCB3bmRQdHIsIDAgKSkgcmV0dXJuOyAvKiBOb3RoaW5nIHRvIGRvICovCgogICAgYWN0aXZlICA9IHduZFB0ci0+ZmxhZ3MgJiBXSU5fTkNBQ1RJVkFURUQ7CgogICAgVFJBQ0UoIiUwNHggJWRcbiIsIGh3bmQsIGFjdGl2ZSApOwoKICAgIC8qIE1TRE4gZG9jcyBhcmUgcHJldHR5IGlkaW90aWMgaGVyZSwgdGhleSBzYXkgYXBwIENBTiB1c2UgY2xpcFJnbiBpbgogICAgICAgdGhlIGNhbGwgdG8gR2V0RENFeCBpbXBseWluZyB0aGF0IGl0IGlzIGFsbG93ZWQgbm90IHRvIHVzZSBpdCBlaXRoZXIuCiAgICAgICBIb3dldmVyLCB0aGUgc3VnZ2VzdGVkIEdldERDRXgoICAgICwgRENYX1dJTkRPVyB8IERDWF9JTlRFUlNFQ1RSR04pCiAgICAgICB3aWxsIGNhdXNlIGNsaXBSZ24gdG8gYmUgZGVsZXRlZCBhZnRlciBSZWxlYXNlREMoKS4KICAgICAgIE5vdywgaG93IGlzIHRoZSAic3lzdGVtIiBzdXBwb3NlZCB0byB0ZWxsIHdoYXQgaGFwcGVuZWQ/CiAgICAgKi8KCiAgICBpZiAoIShoZGMgPSBHZXREQ0V4KCBod25kLCAoY2xpcCA+IDEpID8gY2xpcCA6IDAsIERDWF9VU0VTVFlMRSB8IERDWF9XSU5ET1cgfAoJCQkgICAgICAoKGNsaXAgPiAxKSA/KERDWF9JTlRFUlNFQ1RSR04gfCBEQ1hfS0VFUENMSVBSR04pIDogMCkgKSkpIHJldHVybjsKCgogICAgaWYgKEV4Y2x1ZGVWaXNSZWN0MTYoIGhkYywgd25kUHRyLT5yZWN0Q2xpZW50LmxlZnQtd25kUHRyLT5yZWN0V2luZG93LmxlZnQsCgkJICAgICAgICB3bmRQdHItPnJlY3RDbGllbnQudG9wLXduZFB0ci0+cmVjdFdpbmRvdy50b3AsCgkJICAgICAgICB3bmRQdHItPnJlY3RDbGllbnQucmlnaHQtd25kUHRyLT5yZWN0V2luZG93LmxlZnQsCgkJICAgICAgICB3bmRQdHItPnJlY3RDbGllbnQuYm90dG9tLXduZFB0ci0+cmVjdFdpbmRvdy50b3AgKQoJPT0gTlVMTFJFR0lPTikKICAgIHsKCVJlbGVhc2VEQyggaHduZCwgaGRjICk7CglyZXR1cm47CiAgICB9CgogICAgcmVjdC50b3AgPSByZWN0LmxlZnQgPSAwOwogICAgcmVjdC5yaWdodCAgPSB3bmRQdHItPnJlY3RXaW5kb3cucmlnaHQgLSB3bmRQdHItPnJlY3RXaW5kb3cubGVmdDsKICAgIHJlY3QuYm90dG9tID0gd25kUHRyLT5yZWN0V2luZG93LmJvdHRvbSAtIHduZFB0ci0+cmVjdFdpbmRvdy50b3A7CgogICAgaWYoIGNsaXAgPiAxICkKCUdldFJnbkJveCggY2xpcCwgJnJlY3RDbGlwICk7CiAgICBlbHNlCiAgICB7CgljbGlwID0gMDsKCXJlY3RDbGlwID0gcmVjdDsKICAgIH0KCiAgICBTZWxlY3RPYmplY3QoIGhkYywgR2V0U3lzQ29sb3JQZW4oQ09MT1JfV0lORE9XRlJBTUUpICk7CgogICAgaWYoISh3bmRQdHItPmZsYWdzICYgV0lOX01BTkFHRUQpKSB7CiAgICAgICAgaWYgKEhBU19CSUdGUkFNRSggd25kUHRyLT5kd1N0eWxlLCB3bmRQdHItPmR3RXhTdHlsZSkpIHsKICAgICAgICAgICAgRHJhd0VkZ2UgKGhkYywgJnJlY3QsIEVER0VfUkFJU0VELCBCRl9SRUNUIHwgQkZfQURKVVNUKTsKICAgICAgICB9CglpZiAoSEFTX1RISUNLRlJBTUUoIHduZFB0ci0+ZHdTdHlsZSwgd25kUHRyLT5kd0V4U3R5bGUgKSkKICAgICAgICAgICAgTkNfRHJhd0ZyYW1lOTUoaGRjLCAmcmVjdCwgRkFMU0UsIGFjdGl2ZSApOwogICAgICAgIGVsc2UgaWYgKEhBU19ETEdGUkFNRSggd25kUHRyLT5kd1N0eWxlLCB3bmRQdHItPmR3RXhTdHlsZSApKSAKICAgICAgICAgICAgTkNfRHJhd0ZyYW1lOTUoIGhkYywgJnJlY3QsIFRSVUUsIGFjdGl2ZSApOwoJZWxzZSBpZiAoSEFTX1RISU5GUkFNRSggd25kUHRyLT5kd1N0eWxlICkpIHsKICAgICAgICAgICAgU2VsZWN0T2JqZWN0KCBoZGMsIEdldFN0b2NrT2JqZWN0KE5VTExfQlJVU0gpICk7CiAgICAgICAgICAgIFJlY3RhbmdsZSggaGRjLCAwLCAwLCByZWN0LnJpZ2h0LCByZWN0LmJvdHRvbSApOwoJfQoKICAgICAgICBpZiAoKHduZFB0ci0+ZHdTdHlsZSAmIFdTX0NBUFRJT04pID09IFdTX0NBUFRJT04pCiAgICAgICAgewogICAgICAgICAgICBSRUNUICByID0gcmVjdDsKCSAgICBpZiAod25kUHRyLT5kd0V4U3R5bGUgJiBXU19FWF9UT09MV0lORE9XKSB7CgkJci5ib3R0b20gPSByZWN0LnRvcCArIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lTTUNBUFRJT04pOwoJCXJlY3QudG9wICs9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1lTTUNBUFRJT04pOwoJICAgIH0KCSAgICBlbHNlIHsKCQlyLmJvdHRvbSA9IHJlY3QudG9wICsgR2V0U3lzdGVtTWV0cmljcyhTTV9DWUNBUFRJT04pOwoJCXJlY3QudG9wICs9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1lDQVBUSU9OKTsKCSAgICB9CgkgICAgaWYoICFjbGlwIHx8IEludGVyc2VjdFJlY3QoICZyZnV6eiwgJnIsICZyZWN0Q2xpcCApICkKICAgICAgICAgICAgICAgIE5DX0RyYXdDYXB0aW9uOTUgKGhkYywgJnIsIGh3bmQsIHduZFB0ci0+ZHdTdHlsZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHduZFB0ci0+ZHdFeFN0eWxlLCBhY3RpdmUpOwogICAgICAgIH0KICAgIH0KCiAgICBpZiAoSEFTX01FTlUod25kUHRyKSkKICAgIHsKCVJFQ1QgciA9IHJlY3Q7CglyLmJvdHRvbSA9IHJlY3QudG9wICsgR2V0U3lzdGVtTWV0cmljcyhTTV9DWU1FTlUpOwoJCglUUkFDRSgiQ2FsbGluZyBEcmF3TWVudUJhciB3aXRoIHJlY3QgKCVkLCAlZCktKCVkLCAlZClcbiIsCiAgICAgICAgICAgICAgci5sZWZ0LCByLnRvcCwgci5yaWdodCwgci5ib3R0b20pOwoKCXJlY3QudG9wICs9IE1FTlVfRHJhd01lbnVCYXIoIGhkYywgJnIsIGh3bmQsIHN1cHByZXNzX21lbnVwYWludCApICsgMTsKICAgIH0KCiAgICBUUkFDRSgiQWZ0ZXIgTWVudUJhciwgcmVjdCBpcyAoJWQsICVkKS0oJWQsICVkKS5cbiIsCiAgICAgICAgICByZWN0LmxlZnQsIHJlY3QudG9wLCByZWN0LnJpZ2h0LCByZWN0LmJvdHRvbSApOwoKICAgIGlmICh3bmRQdHItPmR3RXhTdHlsZSAmIFdTX0VYX0NMSUVOVEVER0UpCglEcmF3RWRnZSAoaGRjLCAmcmVjdCwgRURHRV9TVU5LRU4sIEJGX1JFQ1QgfCBCRl9BREpVU1QpOwoKICAgIGlmICh3bmRQdHItPmR3RXhTdHlsZSAmIFdTX0VYX1NUQVRJQ0VER0UpCglEcmF3RWRnZSAoaGRjLCAmcmVjdCwgQkRSX1NVTktFTk9VVEVSLCBCRl9SRUNUIHwgQkZfQURKVVNUKTsKCiAgICAvKiBEcmF3IHRoZSBzY3JvbGwtYmFycyAqLwoKICAgIGlmICh3bmRQdHItPmR3U3R5bGUgJiBXU19WU0NST0xMKQogICAgICAgIFNDUk9MTF9EcmF3U2Nyb2xsQmFyKCBod25kLCBoZGMsIFNCX1ZFUlQsIFRSVUUsIFRSVUUgKTsKICAgIGlmICh3bmRQdHItPmR3U3R5bGUgJiBXU19IU0NST0xMKQogICAgICAgIFNDUk9MTF9EcmF3U2Nyb2xsQmFyKCBod25kLCBoZGMsIFNCX0hPUlosIFRSVUUsIFRSVUUgKTsKCiAgICAvKiBEcmF3IHRoZSAic2l6ZS1ib3giICovCiAgICBpZiAoKHduZFB0ci0+ZHdTdHlsZSAmIFdTX1ZTQ1JPTEwpICYmICh3bmRQdHItPmR3U3R5bGUgJiBXU19IU0NST0xMKSkKICAgIHsKICAgICAgICBSRUNUIHIgPSByZWN0OwogICAgICAgIHIubGVmdCA9IHIucmlnaHQgLSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYVlNDUk9MTCkgKyAxOwogICAgICAgIHIudG9wICA9IHIuYm90dG9tIC0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWUhTQ1JPTEwpICsgMTsKICAgICAgICBGaWxsUmVjdCggaGRjLCAmciwgIEdldFN5c0NvbG9yQnJ1c2goQ09MT1JfU0NST0xMQkFSKSApOwogICAgfSAgICAKCiAgICBSZWxlYXNlREMoIGh3bmQsIGhkYyApOwp9CgoKCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE5DX0hhbmRsZU5DUGFpbnQKICoKICogSGFuZGxlIGEgV01fTkNQQUlOVCBtZXNzYWdlLiBDYWxsZWQgZnJvbSBEZWZXaW5kb3dQcm9jKCkuCiAqLwpMT05HIE5DX0hhbmRsZU5DUGFpbnQoIEhXTkQgaHduZCAsIEhSR04gY2xpcCkKewogICAgV05EKiB3bmRQdHIgPSBXSU5fRmluZFduZFB0ciggaHduZCApOwoKICAgIGlmKCB3bmRQdHIgJiYgd25kUHRyLT5kd1N0eWxlICYgV1NfVklTSUJMRSApCiAgICB7CglpZiggd25kUHRyLT5kd1N0eWxlICYgV1NfTUlOSU1JWkUgKQoJICAgIFdJTlBPU19SZWRyYXdJY29uVGl0bGUoIGh3bmQgKTsKCWVsc2UgaWYgKFRXRUFLX1dpbmVMb29rID09IFdJTjMxX0xPT0spCgkgICAgTkNfRG9OQ1BhaW50KCB3bmRQdHIsIGNsaXAsIEZBTFNFICk7CgllbHNlCgkgICAgTkNfRG9OQ1BhaW50OTUoIHduZFB0ciwgY2xpcCwgRkFMU0UgKTsKICAgIH0KICAgIFdJTl9SZWxlYXNlV25kUHRyKHduZFB0cik7CiAgICByZXR1cm4gMDsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTkNfSGFuZGxlTkNBY3RpdmF0ZQogKgogKiBIYW5kbGUgYSBXTV9OQ0FDVElWQVRFIG1lc3NhZ2UuIENhbGxlZCBmcm9tIERlZldpbmRvd1Byb2MoKS4KICovCkxPTkcgTkNfSGFuZGxlTkNBY3RpdmF0ZSggV05EICp3bmRQdHIsIFdQQVJBTTE2IHdQYXJhbSApCnsKICAgIFdPUkQgd1N0YXRlQ2hhbmdlOwoKICAgIGlmKCB3UGFyYW0gKSB3U3RhdGVDaGFuZ2UgPSAhKHduZFB0ci0+ZmxhZ3MgJiBXSU5fTkNBQ1RJVkFURUQpOwogICAgZWxzZSB3U3RhdGVDaGFuZ2UgPSB3bmRQdHItPmZsYWdzICYgV0lOX05DQUNUSVZBVEVEOwoKICAgIGlmKCB3U3RhdGVDaGFuZ2UgKQogICAgewoJaWYgKHdQYXJhbSkgd25kUHRyLT5mbGFncyB8PSBXSU5fTkNBQ1RJVkFURUQ7CgllbHNlIHduZFB0ci0+ZmxhZ3MgJj0gfldJTl9OQ0FDVElWQVRFRDsKCglpZiggd25kUHRyLT5kd1N0eWxlICYgV1NfTUlOSU1JWkUgKSAKCSAgICBXSU5QT1NfUmVkcmF3SWNvblRpdGxlKCB3bmRQdHItPmh3bmRTZWxmICk7CgllbHNlIGlmIChUV0VBS19XaW5lTG9vayA9PSBXSU4zMV9MT09LKQoJICAgIE5DX0RvTkNQYWludCggd25kUHRyLCAoSFJHTikxLCBGQUxTRSApOwoJZWxzZQoJICAgIE5DX0RvTkNQYWludDk1KCB3bmRQdHIsIChIUkdOKTEsIEZBTFNFICk7CiAgICB9CiAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTkNfSGFuZGxlU2V0Q3Vyc29yCiAqCiAqIEhhbmRsZSBhIFdNX1NFVENVUlNPUiBtZXNzYWdlLiBDYWxsZWQgZnJvbSBEZWZXaW5kb3dQcm9jKCkuCiAqLwpMT05HIE5DX0hhbmRsZVNldEN1cnNvciggSFdORCBod25kLCBXUEFSQU0xNiB3UGFyYW0sIExQQVJBTSBsUGFyYW0gKQp7CiAgICBpZiAoaHduZCAhPSAoSFdORCl3UGFyYW0pIHJldHVybiAwOyAgLyogRG9uJ3Qgc2V0IHRoZSBjdXJzb3IgZm9yIGNoaWxkIHdpbmRvd3MgKi8KCiAgICBzd2l0Y2goTE9XT1JEKGxQYXJhbSkpCiAgICB7CiAgICBjYXNlIEhURVJST1I6Cgl7CgkgICAgV09SRCBtc2cgPSBISVdPUkQoIGxQYXJhbSApOwoJICAgIGlmICgobXNnID09IFdNX0xCVVRUT05ET1dOKSB8fCAobXNnID09IFdNX01CVVRUT05ET1dOKSB8fAoJCShtc2cgPT0gV01fUkJVVFRPTkRPV04pKQoJCU1lc3NhZ2VCZWVwKDApOwoJfQoJYnJlYWs7CgogICAgY2FzZSBIVENMSUVOVDoKCXsKCSAgICBISUNPTjE2IGhDdXJzb3IgPSAoSElDT04xNikgR2V0Q2xhc3NXb3JkKGh3bmQsIEdDV19IQ1VSU09SKTsKCSAgICBpZihoQ3Vyc29yKSB7CgkJU2V0Q3Vyc29yMTYoaEN1cnNvcik7CgkJcmV0dXJuIFRSVUU7CgkgICAgfQogICAgICAgICAgICByZXR1cm4gRkFMU0U7Cgl9CgogICAgY2FzZSBIVExFRlQ6CiAgICBjYXNlIEhUUklHSFQ6CglyZXR1cm4gKExPTkcpU2V0Q3Vyc29yMTYoIExvYWRDdXJzb3IxNiggMCwgSURDX1NJWkVXRTE2ICkgKTsKCiAgICBjYXNlIEhUVE9QOgogICAgY2FzZSBIVEJPVFRPTToKCXJldHVybiAoTE9ORylTZXRDdXJzb3IxNiggTG9hZEN1cnNvcjE2KCAwLCBJRENfU0laRU5TMTYgKSApOwoKICAgIGNhc2UgSFRUT1BMRUZUOgogICAgY2FzZSBIVEJPVFRPTVJJR0hUOgkKCXJldHVybiAoTE9ORylTZXRDdXJzb3IxNiggTG9hZEN1cnNvcjE2KCAwLCBJRENfU0laRU5XU0UxNiApICk7CgogICAgY2FzZSBIVFRPUFJJR0hUOgogICAgY2FzZSBIVEJPVFRPTUxFRlQ6CglyZXR1cm4gKExPTkcpU2V0Q3Vyc29yMTYoIExvYWRDdXJzb3IxNiggMCwgSURDX1NJWkVORVNXMTYgKSApOwogICAgfQoKICAgIC8qIERlZmF1bHQgY3Vyc29yOiBhcnJvdyAqLwogICAgcmV0dXJuIChMT05HKVNldEN1cnNvcjE2KCBMb2FkQ3Vyc29yMTYoIDAsIElEQ19BUlJPVzE2ICkgKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBOQ19HZXRTeXNQb3B1cFBvcwogKi8KQk9PTCBOQ19HZXRTeXNQb3B1cFBvcyggV05EKiB3bmRQdHIsIFJFQ1QqIHJlY3QgKQp7CiAgaWYoIHduZFB0ci0+aFN5c01lbnUgKQogIHsKICAgICAgaWYoIHduZFB0ci0+ZHdTdHlsZSAmIFdTX01JTklNSVpFICkKCSAgR2V0V2luZG93UmVjdCggd25kUHRyLT5od25kU2VsZiwgcmVjdCApOwogICAgICBlbHNlCiAgICAgIHsKICAgICAgICAgIGlmIChUV0VBS19XaW5lTG9vayA9PSBXSU4zMV9MT09LKQogICAgICAgICAgICAgIE5DX0dldEluc2lkZVJlY3QoIHduZFB0ci0+aHduZFNlbGYsIHJlY3QgKTsKICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICBOQ19HZXRJbnNpZGVSZWN0OTUoIHduZFB0ci0+aHduZFNlbGYsIHJlY3QgKTsKICAJICBPZmZzZXRSZWN0KCByZWN0LCB3bmRQdHItPnJlY3RXaW5kb3cubGVmdCwgd25kUHRyLT5yZWN0V2luZG93LnRvcCk7CiAgCSAgaWYgKHduZFB0ci0+ZHdTdHlsZSAmIFdTX0NISUxEKQogICAgIAkgICAgICBDbGllbnRUb1NjcmVlbiggd25kUHRyLT5wYXJlbnQtPmh3bmRTZWxmLCAoUE9JTlQgKilyZWN0ICk7CiAgICAgICAgICBpZiAoVFdFQUtfV2luZUxvb2sgPT0gV0lOMzFfTE9PSykgewogICAgICAgICAgICByZWN0LT5yaWdodCA9IHJlY3QtPmxlZnQgKyBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0laRSk7CiAgICAgICAgICAgIHJlY3QtPmJvdHRvbSA9IHJlY3QtPnRvcCArIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lTSVpFKTsKCSAgfQoJICBlbHNlIHsKICAgICAgICAgICAgcmVjdC0+cmlnaHQgPSByZWN0LT5sZWZ0ICsgR2V0U3lzdGVtTWV0cmljcyhTTV9DWUNBUFRJT04pIC0gMTsKICAgICAgICAgICAgcmVjdC0+Ym90dG9tID0gcmVjdC0+dG9wICsgR2V0U3lzdGVtTWV0cmljcyhTTV9DWUNBUFRJT04pIC0gMTsKCSAgfQogICAgICB9CiAgICAgIHJldHVybiBUUlVFOwogIH0KICByZXR1cm4gRkFMU0U7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTkNfU3RhcnRTaXplTW92ZQogKgogKiBJbml0aWFsaXNhdGlvbiBvZiBhIG1vdmUgb3IgcmVzaXplLCB3aGVuIGluaXRpYXRpZWQgZnJvbSBhIG1lbnUgY2hvaWNlLgogKiBSZXR1cm4gaGl0IHRlc3QgY29kZSBmb3IgY2FwdGlvbiBvciBzaXppbmcgYm9yZGVyLgogKi8Kc3RhdGljIExPTkcgTkNfU3RhcnRTaXplTW92ZSggV05EKiB3bmRQdHIsIFdQQVJBTTE2IHdQYXJhbSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUE9JTlQxNiAqY2FwdHVyZVBvaW50ICkKewogICAgTE9ORyBoaXR0ZXN0ID0gMDsKICAgIFBPSU5UMTYgcHQ7CiAgICBNU0cgbXNnOwogICAgUkVDVCByZWN0V2luZG93OwoKICAgIEdldFdpbmRvd1JlY3Qod25kUHRyLT5od25kU2VsZiwmcmVjdFdpbmRvdyk7CgogICAgaWYgKCh3UGFyYW0gJiAweGZmZjApID09IFNDX01PVkUpCiAgICB7CgkgIC8qIE1vdmUgcG9pbnRlciBhdCB0aGUgY2VudGVyIG9mIHRoZSBjYXB0aW9uICovCglSRUNUIHJlY3Q7CiAgICAgICAgaWYgKFRXRUFLX1dpbmVMb29rID09IFdJTjMxX0xPT0spCiAgICAgICAgICAgIE5DX0dldEluc2lkZVJlY3QoIHduZFB0ci0+aHduZFNlbGYsICZyZWN0ICk7CiAgICAgICAgZWxzZQogICAgICAgICAgICBOQ19HZXRJbnNpZGVSZWN0OTUoIHduZFB0ci0+aHduZFNlbGYsICZyZWN0ICk7CglpZiAod25kUHRyLT5kd1N0eWxlICYgV1NfU1lTTUVOVSkKCSAgICByZWN0LmxlZnQgKz0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNJWkUpICsgMTsKCWlmICh3bmRQdHItPmR3U3R5bGUgJiBXU19NSU5JTUlaRUJPWCkKCSAgICByZWN0LnJpZ2h0IC09IEdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKSArIDE7CglpZiAod25kUHRyLT5kd1N0eWxlICYgV1NfTUFYSU1JWkVCT1gpCgkgICAgcmVjdC5yaWdodCAtPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0laRSkgKyAxOwoJcHQueCA9IHJlY3RXaW5kb3cubGVmdCArIChyZWN0LnJpZ2h0IC0gcmVjdC5sZWZ0KSAvIDI7CglwdC55ID0gcmVjdFdpbmRvdy50b3AgKyByZWN0LnRvcCArIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lTSVpFKS8yOwoJaGl0dGVzdCA9IEhUQ0FQVElPTjsKCSpjYXB0dXJlUG9pbnQgPSBwdDsKICAgIH0KICAgIGVsc2UgIC8qIFNDX1NJWkUgKi8KICAgIHsKCXdoaWxlKCFoaXR0ZXN0KQoJewogICAgICAgICAgICBNU0dfSW50ZXJuYWxHZXRNZXNzYWdlKCBRTVNHX1dJTjMyQSwgJm1zZywgMCwgMCwgTVNHRl9TSVpFLCBQTV9SRU1PVkUsIEZBTFNFLCBOVUxMICk7CgkgICAgc3dpdGNoKG1zZy5tZXNzYWdlKQoJICAgIHsKCSAgICBjYXNlIFdNX01PVVNFTU9WRToKICAgICAgICAgICAgICAgIENPTlZfUE9JTlQzMlRPMTYoJm1zZy5wdCwgJnB0KTsKICAgICAgICAgICAgICAgIGhpdHRlc3QgPSBOQ19IYW5kbGVOQ0hpdFRlc3QoIHduZFB0ci0+aHduZFNlbGYsIHB0ICk7CgkJaWYgKChoaXR0ZXN0IDwgSFRMRUZUKSB8fCAoaGl0dGVzdCA+IEhUQk9UVE9NUklHSFQpKQoJCSAgICBoaXR0ZXN0ID0gMDsKCQlicmVhazsKCgkgICAgY2FzZSBXTV9MQlVUVE9OVVA6CgkJcmV0dXJuIDA7CgoJICAgIGNhc2UgV01fS0VZRE9XTjoKCQlzd2l0Y2gobXNnLndQYXJhbSkKCQl7CgkJY2FzZSBWS19VUDoKCQkgICAgaGl0dGVzdCA9IEhUVE9QOwoJCSAgICBwdC54ID0ocmVjdFdpbmRvdy5sZWZ0K3JlY3RXaW5kb3cucmlnaHQpLzI7CgkJICAgIHB0LnkgPSByZWN0V2luZG93LnRvcCArIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lGUkFNRSkgLyAyOwoJCSAgICBicmVhazsKCQljYXNlIFZLX0RPV046CgkJICAgIGhpdHRlc3QgPSBIVEJPVFRPTTsKCQkgICAgcHQueCA9KHJlY3RXaW5kb3cubGVmdCtyZWN0V2luZG93LnJpZ2h0KS8yOwoJCSAgICBwdC55ID0gcmVjdFdpbmRvdy5ib3R0b20gLSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZRlJBTUUpIC8gMjsKCQkgICAgYnJlYWs7CgkJY2FzZSBWS19MRUZUOgoJCSAgICBoaXR0ZXN0ID0gSFRMRUZUOwoJCSAgICBwdC54ID0gcmVjdFdpbmRvdy5sZWZ0ICsgR2V0U3lzdGVtTWV0cmljcyhTTV9DWEZSQU1FKSAvIDI7CgkJICAgIHB0LnkgPShyZWN0V2luZG93LnRvcCtyZWN0V2luZG93LmJvdHRvbSkvMjsKCQkgICAgYnJlYWs7CgkJY2FzZSBWS19SSUdIVDoKCQkgICAgaGl0dGVzdCA9IEhUUklHSFQ7CgkJICAgIHB0LnggPSByZWN0V2luZG93LnJpZ2h0IC0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWEZSQU1FKSAvIDI7CgkJICAgIHB0LnkgPShyZWN0V2luZG93LnRvcCtyZWN0V2luZG93LmJvdHRvbSkvMjsKCQkgICAgYnJlYWs7CgkJY2FzZSBWS19SRVRVUk46CgkJY2FzZSBWS19FU0NBUEU6IHJldHVybiAwOwoJCX0KCSAgICB9Cgl9CgkqY2FwdHVyZVBvaW50ID0gcHQ7CiAgICB9CiAgICBTZXRDdXJzb3JQb3MoIHB0LngsIHB0LnkgKTsKICAgIE5DX0hhbmRsZVNldEN1cnNvciggd25kUHRyLT5od25kU2VsZiwgCgkJCXduZFB0ci0+aHduZFNlbGYsIE1BS0VMT05HKCBoaXR0ZXN0LCBXTV9NT1VTRU1PVkUgKSk7CiAgICByZXR1cm4gaGl0dGVzdDsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTkNfRG9TaXplTW92ZQogKgogKiBQZXJmb3JtIFNDX01PVkUgYW5kIFNDX1NJWkUgY29tbWFuZHMuICAgICAgICAgICAgICAgYAogKi8Kc3RhdGljIHZvaWQgTkNfRG9TaXplTW92ZSggSFdORCBod25kLCBXT1JEIHdQYXJhbSApCnsKICAgIE1TRyBtc2c7CiAgICBSRUNUIHNpemluZ1JlY3QsIG1vdXNlUmVjdCwgb3JpZ1JlY3Q7CiAgICBIREMgaGRjOwogICAgTE9ORyBoaXR0ZXN0ID0gKExPTkcpKHdQYXJhbSAmIDB4MGYpOwogICAgSENVUlNPUjE2IGhEcmFnQ3Vyc29yID0gMCwgaE9sZEN1cnNvciA9IDA7CiAgICBQT0lOVCBtaW5UcmFjaywgbWF4VHJhY2s7CiAgICBQT0lOVDE2IGNhcHR1cmVQb2ludCwgcHQ7CiAgICBXTkQgKiAgICAgd25kUHRyID0gV0lOX0ZpbmRXbmRQdHIoIGh3bmQgKTsKICAgIEJPT0wgICAgdGhpY2tmcmFtZSA9IEhBU19USElDS0ZSQU1FKCB3bmRQdHItPmR3U3R5bGUsIHduZFB0ci0+ZHdFeFN0eWxlICk7CiAgICBCT09MICAgIGljb25pYyA9IHduZFB0ci0+ZHdTdHlsZSAmIFdTX01JTklNSVpFOwogICAgQk9PTCAgICBtb3ZlZCA9IEZBTFNFOwogICAgRFdPUkQgICAgIGR3UG9pbnQgPSBHZXRNZXNzYWdlUG9zICgpOwogICAgQk9PTCBEcmFnRnVsbFdpbmRvd3MgPSBGQUxTRTsKICAgIGludCBpV25kc0xvY2tzOwogICAgCiAgICBTeXN0ZW1QYXJhbWV0ZXJzSW5mb0EoU1BJX0dFVERSQUdGVUxMV0lORE9XUywgMCwgJkRyYWdGdWxsV2luZG93cywgMCk7CgogICAgY2FwdHVyZVBvaW50ID0gcHQgPSAqKFBPSU5UMTYqKSZkd1BvaW50OwoKICAgIGlmIChJc1pvb21lZChod25kKSB8fCAhSXNXaW5kb3dWaXNpYmxlKGh3bmQpIHx8CiAgICAgICAgKHduZFB0ci0+ZmxhZ3MgJiBXSU5fTUFOQUdFRCkpIGdvdG8gRU5EOwoKICAgIGlmICgod1BhcmFtICYgMHhmZmYwKSA9PSBTQ19NT1ZFKQogICAgewoJaWYgKCFoaXR0ZXN0KSAKCSAgICAgaGl0dGVzdCA9IE5DX1N0YXJ0U2l6ZU1vdmUoIHduZFB0ciwgd1BhcmFtLCAmY2FwdHVyZVBvaW50ICk7CglpZiAoIWhpdHRlc3QpIGdvdG8gRU5EOwogICAgfQogICAgZWxzZSAgLyogU0NfU0laRSAqLwogICAgewoJaWYgKCF0aGlja2ZyYW1lKSBnb3RvIEVORDsKCWlmICggaGl0dGVzdCAmJiBoaXR0ZXN0ICE9IEhUU1lTTUVOVSApIGhpdHRlc3QgKz0gMjsKCWVsc2UKCXsKCSAgICBTZXRDYXB0dXJlKGh3bmQpOwoJICAgIGhpdHRlc3QgPSBOQ19TdGFydFNpemVNb3ZlKCB3bmRQdHIsIHdQYXJhbSwgJmNhcHR1cmVQb2ludCApOwoJICAgIGlmICghaGl0dGVzdCkKCSAgICB7CgkJUmVsZWFzZUNhcHR1cmUoKTsKCQlnb3RvIEVORDsKCSAgICB9Cgl9CiAgICB9CgogICAgICAvKiBHZXQgbWluL21heCBpbmZvICovCgogICAgV0lOUE9TX0dldE1pbk1heEluZm8oIHduZFB0ciwgTlVMTCwgTlVMTCwgJm1pblRyYWNrLCAmbWF4VHJhY2sgKTsKICAgIHNpemluZ1JlY3QgPSB3bmRQdHItPnJlY3RXaW5kb3c7CiAgICBvcmlnUmVjdCA9IHNpemluZ1JlY3Q7CiAgICBpZiAod25kUHRyLT5kd1N0eWxlICYgV1NfQ0hJTEQpCglHZXRDbGllbnRSZWN0KCB3bmRQdHItPnBhcmVudC0+aHduZFNlbGYsICZtb3VzZVJlY3QgKTsKICAgIGVsc2UgCiAgICAgICAgU2V0UmVjdCgmbW91c2VSZWN0LCAwLCAwLCBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0NSRUVOKSwgR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNDUkVFTikpOwogICAgaWYgKE9OX0xFRlRfQk9SREVSKGhpdHRlc3QpKQogICAgewoJbW91c2VSZWN0LmxlZnQgID0gbWF4KCBtb3VzZVJlY3QubGVmdCwgc2l6aW5nUmVjdC5yaWdodC1tYXhUcmFjay54ICk7Cgltb3VzZVJlY3QucmlnaHQgPSBtaW4oIG1vdXNlUmVjdC5yaWdodCwgc2l6aW5nUmVjdC5yaWdodC1taW5UcmFjay54ICk7CiAgICB9CiAgICBlbHNlIGlmIChPTl9SSUdIVF9CT1JERVIoaGl0dGVzdCkpCiAgICB7Cgltb3VzZVJlY3QubGVmdCAgPSBtYXgoIG1vdXNlUmVjdC5sZWZ0LCBzaXppbmdSZWN0LmxlZnQrbWluVHJhY2sueCApOwoJbW91c2VSZWN0LnJpZ2h0ID0gbWluKCBtb3VzZVJlY3QucmlnaHQsIHNpemluZ1JlY3QubGVmdCttYXhUcmFjay54ICk7CiAgICB9CiAgICBpZiAoT05fVE9QX0JPUkRFUihoaXR0ZXN0KSkKICAgIHsKCW1vdXNlUmVjdC50b3AgICAgPSBtYXgoIG1vdXNlUmVjdC50b3AsIHNpemluZ1JlY3QuYm90dG9tLW1heFRyYWNrLnkgKTsKCW1vdXNlUmVjdC5ib3R0b20gPSBtaW4oIG1vdXNlUmVjdC5ib3R0b20sc2l6aW5nUmVjdC5ib3R0b20tbWluVHJhY2sueSk7CiAgICB9CiAgICBlbHNlIGlmIChPTl9CT1RUT01fQk9SREVSKGhpdHRlc3QpKQogICAgewoJbW91c2VSZWN0LnRvcCAgICA9IG1heCggbW91c2VSZWN0LnRvcCwgc2l6aW5nUmVjdC50b3ArbWluVHJhY2sueSApOwoJbW91c2VSZWN0LmJvdHRvbSA9IG1pbiggbW91c2VSZWN0LmJvdHRvbSwgc2l6aW5nUmVjdC50b3ArbWF4VHJhY2sueSApOwogICAgfQogICAgaWYgKHduZFB0ci0+ZHdTdHlsZSAmIFdTX0NISUxEKQogICAgewoJTWFwV2luZG93UG9pbnRzKCB3bmRQdHItPnBhcmVudC0+aHduZFNlbGYsIDAsIAoJCShMUFBPSU5UKSZtb3VzZVJlY3QsIDIgKTsKICAgIH0KICAgIFNlbmRNZXNzYWdlMTYoIGh3bmQsIFdNX0VOVEVSU0laRU1PVkUsIDAsIDAgKTsKCiAgICBpZiAoR2V0Q2FwdHVyZSgpICE9IGh3bmQpIFNldENhcHR1cmUoIGh3bmQgKTsgICAgCgogICAgaWYgKHduZFB0ci0+ZHdTdHlsZSAmIFdTX0NISUxEKQogICAgewogICAgICAgICAgLyogUmV0cmlldmUgYSBkZWZhdWx0IGNhY2hlIERDICh3aXRob3V0IHVzaW5nIHRoZSB3aW5kb3cgc3R5bGUpICovCiAgICAgICAgaGRjID0gR2V0RENFeCggd25kUHRyLT5wYXJlbnQtPmh3bmRTZWxmLCAwLCBEQ1hfQ0FDSEUgKTsKICAgIH0KICAgIGVsc2UKICAgIHsgIC8qIEdyYWIgdGhlIHNlcnZlciBvbmx5IHdoZW4gbW92aW5nIHRvcC1sZXZlbCB3aW5kb3dzIHdpdGhvdXQgZGVza3RvcCAqLwoJaGRjID0gR2V0REMoIDAgKTsKICAgIH0KCiAgICB3bmRQdHItPnBEcml2ZXItPnBQcmVTaXplTW92ZSh3bmRQdHIpOwoKICAgIGlmKCBpY29uaWMgKSAvKiBjcmVhdGUgYSBjdXJzb3IgZm9yIGRyYWdnaW5nICovCiAgICB7CglISUNPTjE2IGhJY29uID0gR2V0Q2xhc3NXb3JkKHduZFB0ci0+aHduZFNlbGYsIEdDV19ISUNPTik7CglpZighaEljb24pIGhJY29uID0gKEhJQ09OMTYpIFNlbmRNZXNzYWdlMTYoIGh3bmQsIFdNX1FVRVJZRFJBR0lDT04sIDAsIDBMKTsKCWlmKCBoSWNvbiApIGhEcmFnQ3Vyc29yID0gIENVUlNPUklDT05fSWNvblRvQ3Vyc29yKCBoSWNvbiwgVFJVRSApOwoJaWYoICFoRHJhZ0N1cnNvciApIGljb25pYyA9IEZBTFNFOwogICAgfQoKICAgIC8qIGludmVydCBmcmFtZSBpZiBXSU4zMV9MT09LIHRvIGluZGljYXRlIG1vdXNlIGNsaWNrIG9uIGNhcHRpb24gKi8KICAgIGlmKCAhaWNvbmljICYmIFRXRUFLX1dpbmVMb29rID09IFdJTjMxX0xPT0sgKQoJaWYoIURyYWdGdWxsV2luZG93cykKCU5DX0RyYXdNb3ZpbmdGcmFtZSggaGRjLCAmc2l6aW5nUmVjdCwgdGhpY2tmcmFtZSApOwoKICAgIHdoaWxlKDEpCiAgICB7CiAgICAgICAgaW50IGR4ID0gMCwgZHkgPSAwOwoKICAgICAgICBNU0dfSW50ZXJuYWxHZXRNZXNzYWdlKCBRTVNHX1dJTjMyQSwgJm1zZywgMCwgMCwgTVNHRl9TSVpFLCBQTV9SRU1PVkUsIEZBTFNFLCBOVUxMICk7CgoJICAvKiBFeGl0IG9uIGJ1dHRvbi11cCwgUmV0dXJuLCBvciBFc2MgKi8KCWlmICgobXNnLm1lc3NhZ2UgPT0gV01fTEJVVFRPTlVQKSB8fAoJICAgICgobXNnLm1lc3NhZ2UgPT0gV01fS0VZRE9XTikgJiYgCgkgICAgICgobXNnLndQYXJhbSA9PSBWS19SRVRVUk4pIHx8IChtc2cud1BhcmFtID09IFZLX0VTQ0FQRSkpKSkgYnJlYWs7CgogICAgICAgIGlmIChtc2cubWVzc2FnZSA9PSBXTV9QQUlOVCkKICAgICAgICB7CiAgICAgICAgICAgIGlmKCFpY29uaWMgJiYgIURyYWdGdWxsV2luZG93cykgTkNfRHJhd01vdmluZ0ZyYW1lKCBoZGMsICZzaXppbmdSZWN0LCB0aGlja2ZyYW1lICk7CiAgICAgICAgICAgIFVwZGF0ZVdpbmRvdyggbXNnLmh3bmQgKTsKICAgICAgICAgICAgaWYoIWljb25pYyAmJiAhRHJhZ0Z1bGxXaW5kb3dzKSBOQ19EcmF3TW92aW5nRnJhbWUoIGhkYywgJnNpemluZ1JlY3QsIHRoaWNrZnJhbWUgKTsKICAgICAgICAgICAgY29udGludWU7CiAgICAgICAgfQoKCWlmICgobXNnLm1lc3NhZ2UgIT0gV01fS0VZRE9XTikgJiYgKG1zZy5tZXNzYWdlICE9IFdNX01PVVNFTU9WRSkpCgkgICAgY29udGludWU7ICAvKiBXZSBhcmUgbm90IGludGVyZXN0ZWQgaW4gb3RoZXIgbWVzc2FnZXMgKi8KCglDT05WX1BPSU5UMzJUTzE2KCZtc2cucHQsICZwdCk7CgkKCWlmIChtc2cubWVzc2FnZSA9PSBXTV9LRVlET1dOKSBzd2l0Y2gobXNnLndQYXJhbSkKCXsKCSAgICBjYXNlIFZLX1VQOiAgICBwdC55IC09IDg7IGJyZWFrOwoJICAgIGNhc2UgVktfRE9XTjogIHB0LnkgKz0gODsgYnJlYWs7CgkgICAgY2FzZSBWS19MRUZUOiAgcHQueCAtPSA4OyBicmVhazsKCSAgICBjYXNlIFZLX1JJR0hUOiBwdC54ICs9IDg7IGJyZWFrOwkJCgl9CgoJcHQueCA9IG1heCggcHQueCwgbW91c2VSZWN0LmxlZnQgKTsKCXB0LnggPSBtaW4oIHB0LngsIG1vdXNlUmVjdC5yaWdodCApOwoJcHQueSA9IG1heCggcHQueSwgbW91c2VSZWN0LnRvcCApOwoJcHQueSA9IG1pbiggcHQueSwgbW91c2VSZWN0LmJvdHRvbSApOwoKCWR4ID0gcHQueCAtIGNhcHR1cmVQb2ludC54OwoJZHkgPSBwdC55IC0gY2FwdHVyZVBvaW50Lnk7CgoJaWYgKGR4IHx8IGR5KQoJewoJICAgIGlmKCAhbW92ZWQgKQoJICAgIHsKCQltb3ZlZCA9IFRSVUU7CgoJCWlmKCBpY29uaWMgKSAvKiBvaywgbm8gc3lzdGVtIHBvcHVwIHRyYWNraW5nICovCgkJewoJCSAgICBoT2xkQ3Vyc29yID0gU2V0Q3Vyc29yKGhEcmFnQ3Vyc29yKTsKCQkgICAgU2hvd0N1cnNvciggVFJVRSApOwoJCSAgICBXSU5QT1NfU2hvd0ljb25UaXRsZSggd25kUHRyLCBGQUxTRSApOwoJCX0gZWxzZSBpZihUV0VBS19XaW5lTG9vayAhPSBXSU4zMV9MT09LKQogICAgICAgICAgICAgICAgewoJCSAgICBpZighRHJhZ0Z1bGxXaW5kb3dzKQoJCSAgICBOQ19EcmF3TW92aW5nRnJhbWUoIGhkYywgJnNpemluZ1JlY3QsIHRoaWNrZnJhbWUgKTsKICAgICAgICAgICAgICAgIH0KCSAgICB9CgoJICAgIGlmIChtc2cubWVzc2FnZSA9PSBXTV9LRVlET1dOKSBTZXRDdXJzb3JQb3MoIHB0LngsIHB0LnkgKTsKCSAgICBlbHNlCgkgICAgewoJCVJFQ1QgbmV3UmVjdCA9IHNpemluZ1JlY3Q7CiAgICAgICAgICAgICAgICBXUEFSQU0gd3BTaXppbmdIaXQgPSAwOwoKCQlpZiAoaGl0dGVzdCA9PSBIVENBUFRJT04pIE9mZnNldFJlY3QoICZuZXdSZWN0LCBkeCwgZHkgKTsKCQlpZiAoT05fTEVGVF9CT1JERVIoaGl0dGVzdCkpIG5ld1JlY3QubGVmdCArPSBkeDsKCQllbHNlIGlmIChPTl9SSUdIVF9CT1JERVIoaGl0dGVzdCkpIG5ld1JlY3QucmlnaHQgKz0gZHg7CgkJaWYgKE9OX1RPUF9CT1JERVIoaGl0dGVzdCkpIG5ld1JlY3QudG9wICs9IGR5OwoJCWVsc2UgaWYgKE9OX0JPVFRPTV9CT1JERVIoaGl0dGVzdCkpIG5ld1JlY3QuYm90dG9tICs9IGR5OwoJCWlmKCFpY29uaWMgJiYgIURyYWdGdWxsV2luZG93cykgTkNfRHJhd01vdmluZ0ZyYW1lKCBoZGMsICZzaXppbmdSZWN0LCB0aGlja2ZyYW1lICk7CgkJY2FwdHVyZVBvaW50ID0gcHQ7CiAgICAgICAgICAgICAgICAKICAgICAgICAgICAgICAgIC8qIGRldGVybWluZSB0aGUgaGl0IGxvY2F0aW9uICovCiAgICAgICAgICAgICAgICBpZiAoaGl0dGVzdCA+PSBIVExFRlQgJiYgaGl0dGVzdCA8PSBIVEJPVFRPTVJJR0hUKQogICAgICAgICAgICAgICAgICAgIHdwU2l6aW5nSGl0ID0gV01TWl9MRUZUICsgKGhpdHRlc3QgLSBIVExFRlQpOwoJCVNlbmRNZXNzYWdlQSggaHduZCwgV01fU0laSU5HLCB3cFNpemluZ0hpdCwgKExQQVJBTSkmbmV3UmVjdCApOwoKCQlpZiAoIWljb25pYykKCQl7CgkJICAgIGlmKCFEcmFnRnVsbFdpbmRvd3MpCgkJCU5DX0RyYXdNb3ZpbmdGcmFtZSggaGRjLCAmbmV3UmVjdCwgdGhpY2tmcmFtZSApOwoJCSAgICBlbHNlIHsKCQkJLyogVG8gYXZvaWQgYW55IGRlYWRsb2NrcywgYWxsIHRoZSBsb2NrcyBvbiB0aGUgd2luZG93cwoJCQkgICBzdHJ1Y3R1cmVzIG11c3QgYmUgc3VzcGVuZGVkIGJlZm9yZSB0aGUgU2V0V2luZG93UG9zICovCgkJCWlXbmRzTG9ja3MgPSBXSU5fU3VzcGVuZFduZHNMb2NrKCk7CgkJCVNldFdpbmRvd1BvcyggaHduZCwgMCwgbmV3UmVjdC5sZWZ0LCBuZXdSZWN0LnRvcCwKCQkJICAgIG5ld1JlY3QucmlnaHQgLSBuZXdSZWN0LmxlZnQsCgkJCSAgICBuZXdSZWN0LmJvdHRvbSAtIG5ld1JlY3QudG9wLAoJCQkgICAgKCBoaXR0ZXN0ID09IEhUQ0FQVElPTiApID8gU1dQX05PU0laRSA6IDAgKTsKCQkJV0lOX1Jlc3RvcmVXbmRzTG9jayhpV25kc0xvY2tzKTsKCQkgICAgfQoJCX0KCQlzaXppbmdSZWN0ID0gbmV3UmVjdDsKCSAgICB9Cgl9CiAgICB9CgogICAgUmVsZWFzZUNhcHR1cmUoKTsKICAgIGlmKCBpY29uaWMgKQogICAgewoJaWYoIG1vdmVkICkgLyogcmVzdG9yZSBjdXJzb3JzLCBzaG93IGljb24gdGl0bGUgbGF0ZXIgb24gKi8KCXsKCSAgICBTaG93Q3Vyc29yKCBGQUxTRSApOwoJICAgIFNldEN1cnNvciggaE9sZEN1cnNvciApOwoJfQogICAgICAgIERlc3Ryb3lDdXJzb3IoIGhEcmFnQ3Vyc29yICk7CiAgICB9CiAgICBlbHNlIGlmKG1vdmVkIHx8IFRXRUFLX1dpbmVMb29rID09IFdJTjMxX0xPT0spCglpZighRHJhZ0Z1bGxXaW5kb3dzKQogICAgICAgIE5DX0RyYXdNb3ZpbmdGcmFtZSggaGRjLCAmc2l6aW5nUmVjdCwgdGhpY2tmcmFtZSApOwoKICAgIGlmICh3bmRQdHItPmR3U3R5bGUgJiBXU19DSElMRCkKICAgICAgICBSZWxlYXNlREMoIHduZFB0ci0+cGFyZW50LT5od25kU2VsZiwgaGRjICk7CiAgICBlbHNlCiAgICAgICAgUmVsZWFzZURDKCAwLCBoZGMgKTsKCiAgICB3bmRQdHItPnBEcml2ZXItPnBQb3N0U2l6ZU1vdmUod25kUHRyKTsKCiAgICBpZiAoSE9PS19Jc0hvb2tlZCggV0hfQ0JUICkpCiAgICB7CglSRUNUMTYqIHByID0gU0VHUFRSX05FVyhSRUNUMTYpOwoJaWYoIHByICkKCXsKICAgICAgICAgICAgQ09OVl9SRUNUMzJUTzE2KCAmc2l6aW5nUmVjdCwgcHIgKTsKCSAgICBpZiggSE9PS19DYWxsSG9va3MxNiggV0hfQ0JULCBIQ0JUX01PVkVTSVpFLCBod25kLAoJCQkgICAgICAgIChMUEFSQU0pU0VHUFRSX0dFVChwcikpICkKCQlzaXppbmdSZWN0ID0gd25kUHRyLT5yZWN0V2luZG93OwoJICAgIGVsc2UKCQlDT05WX1JFQ1QxNlRPMzIoIHByLCAmc2l6aW5nUmVjdCApOwoJICAgIFNFR1BUUl9GUkVFKHByKTsKCX0KICAgIH0KICAgIFNlbmRNZXNzYWdlMTYoIGh3bmQsIFdNX0VYSVRTSVpFTU9WRSwgMCwgMCApOwogICAgU2VuZE1lc3NhZ2UxNiggaHduZCwgV01fU0VUVklTSUJMRSwgIUlzSWNvbmljMTYoaHduZCksIDBMKTsKCiAgICAvKiB3aW5kb3cgbW92ZWQgb3IgcmVzaXplZCAqLwogICAgaWYgKG1vdmVkKQogICAgewoJLyogVG8gYXZvaWQgYW55IGRlYWRsb2NrcywgYWxsIHRoZSBsb2NrcyBvbiB0aGUgd2luZG93cwoJICAgc3RydWN0dXJlcyBtdXN0IGJlIHN1c3BlbmRlZCBiZWZvcmUgdGhlIFNldFdpbmRvd1BvcyAqLwoJaVduZHNMb2NrcyA9IFdJTl9TdXNwZW5kV25kc0xvY2soKTsKCiAgICAgICAgLyogaWYgdGhlIG1vdmluZy9yZXNpemluZyBpc24ndCBjYW5jZWxlZCBjYWxsIFNldFdpbmRvd1BvcwogICAgICAgICAqIHdpdGggdGhlIG5ldyBwb3NpdGlvbiBvciB0aGUgbmV3IHNpemUgb2YgdGhlIHdpbmRvdwogICAgICAgICAqLwogICAgICAgIGlmICghKChtc2cubWVzc2FnZSA9PSBXTV9LRVlET1dOKSAmJiAobXNnLndQYXJhbSA9PSBWS19FU0NBUEUpKSApCiAgICAgICAgewoJLyogTk9URTogU1dQX05PQUNUSVZBVEUgcHJldmVudHMgZG9jdW1lbnQgd2luZG93IGFjdGl2YXRpb24gaW4gV29yZCA2ICovCglpZighRHJhZ0Z1bGxXaW5kb3dzKQoJU2V0V2luZG93UG9zKCBod25kLCAwLCBzaXppbmdSZWN0LmxlZnQsIHNpemluZ1JlY3QudG9wLAoJCQlzaXppbmdSZWN0LnJpZ2h0IC0gc2l6aW5nUmVjdC5sZWZ0LAoJCQlzaXppbmdSZWN0LmJvdHRvbSAtIHNpemluZ1JlY3QudG9wLAoJCSAgICAgICggaGl0dGVzdCA9PSBIVENBUFRJT04gKSA/IFNXUF9OT1NJWkUgOiAwICk7CiAgICAgICAgfQoJZWxzZSB7IC8qIHJlc3RvcmUgcHJldmlvdXMgc2l6ZS9wb3NpdGlvbiAqLwoJICAgIGlmKERyYWdGdWxsV2luZG93cykKCQlTZXRXaW5kb3dQb3MoIGh3bmQsIDAsIG9yaWdSZWN0LmxlZnQsIG9yaWdSZWN0LnRvcCwKCQkJb3JpZ1JlY3QucmlnaHQgLSBvcmlnUmVjdC5sZWZ0LAoJCQlvcmlnUmVjdC5ib3R0b20gLSBvcmlnUmVjdC50b3AsCgkJCSggaGl0dGVzdCA9PSBIVENBUFRJT04gKSA/IFNXUF9OT1NJWkUgOiAwICk7Cgl9CgoJV0lOX1Jlc3RvcmVXbmRzTG9jayhpV25kc0xvY2tzKTsKICAgIH0KCiAgICBpZiggSXNXaW5kb3coaHduZCkgKQoJaWYoIHduZFB0ci0+ZHdTdHlsZSAmIFdTX01JTklNSVpFICkKCXsKCSAgICAvKiBTaW5nbGUgY2xpY2sgYnJpbmdzIHVwIHRoZSBzeXN0ZW0gbWVudSB3aGVuIGljb25pemVkICovCgoJICAgIGlmKCAhbW92ZWQgKSAKCSAgICB7CgkJIGlmKCB3bmRQdHItPmR3U3R5bGUgJiBXU19TWVNNRU5VICkgCgkJICAgICBTZW5kTWVzc2FnZTE2KCBod25kLCBXTV9TWVNDT01NQU5ELAoJCQkJICAgIFNDX01PVVNFTUVOVSArIEhUU1lTTUVOVSwgKigoTFBBUkFNKikmcHQpKTsKCSAgICB9CgkgICAgZWxzZSBXSU5QT1NfU2hvd0ljb25UaXRsZSggd25kUHRyLCBUUlVFICk7Cgl9CgpFTkQ6CiAgICBXSU5fUmVsZWFzZVduZFB0cih3bmRQdHIpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBOQ19UcmFja01pbk1heEJveDk1CiAqCiAqIFRyYWNrIGEgbW91c2UgYnV0dG9uIHByZXNzIG9uIHRoZSBtaW5pbWl6ZSBvciBtYXhpbWl6ZSBib3guCiAqCiAqIFRoZSBiaWcgZGlmZmVyZW5jZSBiZXR3ZWVuIDMuMSBhbmQgOTUgaXMgdGhlIGRpc2FibGVkIGJ1dHRvbiBzdGF0ZS4KICogSW4gd2luOTUgdGhlIHN5c3RlbSBidXR0b24gY2FuIGJlIGRpc2FibGVkLCBzbyBpdCBjYW4gaWdub3JlIHRoZSBtb3VzZQogKiBldmVudC4KICoKICovCnN0YXRpYyB2b2lkIE5DX1RyYWNrTWluTWF4Qm94OTUoIEhXTkQgaHduZCwgV09SRCB3UGFyYW0gKQp7CiAgICBNU0cgbXNnOwogICAgUE9JTlQxNiBwdDE2OwogICAgSERDIGhkYyA9IEdldFdpbmRvd0RDKCBod25kICk7CiAgICBCT09MIHByZXNzZWQgPSBUUlVFOwogICAgVUlOVCBzdGF0ZTsKICAgIERXT1JEIHduZFN0eWxlID0gR2V0V2luZG93TG9uZ0EoIGh3bmQsIEdXTF9TVFlMRSk7CiAgICBITUVOVSBoU3lzTWVudSA9IEdldFN5c3RlbU1lbnUoaHduZCwgRkFMU0UpOwoKICAgIHZvaWQgICgqcGFpbnRCdXR0b24pKEhXTkQsIEhEQzE2LCBCT09MLCBCT09MKTsKCiAgICBpZiAod1BhcmFtID09IEhUTUlOQlVUVE9OKQogICAgewoJLyogSWYgdGhlIHN0eWxlIGlzIG5vdCBwcmVzZW50LCBkbyBub3RoaW5nICovCglpZiAoISh3bmRTdHlsZSAmIFdTX01JTklNSVpFQk9YKSkKCSAgICByZXR1cm47CgoJLyogQ2hlY2sgaWYgdGhlIHN5c21lbnUgaXRlbSBmb3IgbWluaW1pemUgaXMgdGhlcmUgICovCglzdGF0ZSA9IEdldE1lbnVTdGF0ZShoU3lzTWVudSwgU0NfTUlOSU1JWkUsIE1GX0JZQ09NTUFORCk7CgkKCXBhaW50QnV0dG9uID0gJk5DX0RyYXdNaW5CdXR0b245NTsKICAgIH0KICAgIGVsc2UKICAgIHsKCS8qIElmIHRoZSBzdHlsZSBpcyBub3QgcHJlc2VudCwgZG8gbm90aGluZyAqLwoJaWYgKCEod25kU3R5bGUgJiBXU19NQVhJTUlaRUJPWCkpCgkgICAgcmV0dXJuOwoKCS8qIENoZWNrIGlmIHRoZSBzeXNtZW51IGl0ZW0gZm9yIG1heGltaXplIGlzIHRoZXJlICAqLwoJc3RhdGUgPSBHZXRNZW51U3RhdGUoaFN5c01lbnUsIFNDX01BWElNSVpFLCBNRl9CWUNPTU1BTkQpOwoJCglwYWludEJ1dHRvbiA9ICZOQ19EcmF3TWF4QnV0dG9uOTU7CiAgICB9CgogICAgU2V0Q2FwdHVyZSggaHduZCApOwoKICAgICgqcGFpbnRCdXR0b24pKCBod25kLCBoZGMsIFRSVUUsIEZBTFNFKTsKCiAgICBkbwogICAgewoJQk9PTCBvbGRzdGF0ZSA9IHByZXNzZWQ7CiAgICAgICAgTVNHX0ludGVybmFsR2V0TWVzc2FnZSggUU1TR19XSU4zMkEsICZtc2csIDAsIDAsIDAsIFBNX1JFTU9WRSwgRkFMU0UsIE5VTEwgKTsKICAgICAgICBDT05WX1BPSU5UMzJUTzE2KCAmbXNnLnB0LCAmcHQxNiApOwoKCXByZXNzZWQgPSAoTkNfSGFuZGxlTkNIaXRUZXN0KCBod25kLCBwdDE2ICkgPT0gd1BhcmFtKTsKCWlmIChwcmVzc2VkICE9IG9sZHN0YXRlKQoJICAgKCpwYWludEJ1dHRvbikoIGh3bmQsIGhkYywgcHJlc3NlZCwgRkFMU0UpOwogICAgfSB3aGlsZSAobXNnLm1lc3NhZ2UgIT0gV01fTEJVVFRPTlVQKTsKCiAgICAoKnBhaW50QnV0dG9uKSggaHduZCwgaGRjLCBGQUxTRSwgRkFMU0UpOwoKICAgIFJlbGVhc2VDYXB0dXJlKCk7CiAgICBSZWxlYXNlREMoIGh3bmQsIGhkYyApOwoKICAgIC8qIElmIHRoZSBpdGVtIG1pbmltaXplIG9yIG1heGltaXplIG9mIHRoZSBzeXNtZW51IGFyZSBub3QgdGhlcmUgKi8KICAgIC8qIG9yIGlmIHRoZSBzdHlsZSBpcyBub3QgcHJlc2VudCwgZG8gbm90aGluZyAqLwogICAgaWYgKCghcHJlc3NlZCkgfHwgKHN0YXRlID09IDB4RkZGRkZGRkYpKQoJcmV0dXJuOwoKICAgIGlmICh3UGFyYW0gPT0gSFRNSU5CVVRUT04pIAoJU2VuZE1lc3NhZ2UxNiggaHduZCwgV01fU1lTQ09NTUFORCwgU0NfTUlOSU1JWkUsICooTE9ORyopJnB0MTYgKTsKICAgIGVsc2UKCVNlbmRNZXNzYWdlMTYoIGh3bmQsIFdNX1NZU0NPTU1BTkQsIAoJCSAgSXNab29tZWQoaHduZCkgPyBTQ19SRVNUT1JFOlNDX01BWElNSVpFLCAqKExPTkcqKSZwdDE2ICk7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTkNfVHJhY2tNaW5NYXhCb3gKICoKICogVHJhY2sgYSBtb3VzZSBidXR0b24gcHJlc3Mgb24gdGhlIG1pbmltaXplIG9yIG1heGltaXplIGJveC4KICovCnN0YXRpYyB2b2lkIE5DX1RyYWNrTWluTWF4Qm94KCBIV05EIGh3bmQsIFdPUkQgd1BhcmFtICkKewogICAgTVNHIG1zZzsKICAgIFBPSU5UMTYgcHQxNjsKICAgIEhEQyBoZGMgPSBHZXRXaW5kb3dEQyggaHduZCApOwogICAgQk9PTCBwcmVzc2VkID0gVFJVRTsKICAgIHZvaWQgICgqcGFpbnRCdXR0b24pKEhXTkQsIEhEQzE2LCBCT09MKTsKCiAgICBTZXRDYXB0dXJlKCBod25kICk7CgogICAgaWYgKHdQYXJhbSA9PSBIVE1JTkJVVFRPTikKCXBhaW50QnV0dG9uID0gJk5DX0RyYXdNaW5CdXR0b247CiAgICBlbHNlCglwYWludEJ1dHRvbiA9ICZOQ19EcmF3TWF4QnV0dG9uOwoKICAgICgqcGFpbnRCdXR0b24pKCBod25kLCBoZGMsIFRSVUUpOwoKICAgIGRvCiAgICB7CglCT09MIG9sZHN0YXRlID0gcHJlc3NlZDsKICAgICAgICBNU0dfSW50ZXJuYWxHZXRNZXNzYWdlKCBRTVNHX1dJTjMyQSwgJm1zZywgMCwgMCwgMCwgUE1fUkVNT1ZFLCBGQUxTRSwgTlVMTCApOwogICAgICAgIENPTlZfUE9JTlQzMlRPMTYoICZtc2cucHQsICZwdDE2ICk7CgoJcHJlc3NlZCA9IChOQ19IYW5kbGVOQ0hpdFRlc3QoIGh3bmQsIHB0MTYgKSA9PSB3UGFyYW0pOwoJaWYgKHByZXNzZWQgIT0gb2xkc3RhdGUpCgkgICAoKnBhaW50QnV0dG9uKSggaHduZCwgaGRjLCBwcmVzc2VkKTsKICAgIH0gd2hpbGUgKG1zZy5tZXNzYWdlICE9IFdNX0xCVVRUT05VUCk7CgogICAgKCpwYWludEJ1dHRvbikoIGh3bmQsIGhkYywgRkFMU0UpOwoKICAgIFJlbGVhc2VDYXB0dXJlKCk7CiAgICBSZWxlYXNlREMoIGh3bmQsIGhkYyApOwoKICAgIGlmICghcHJlc3NlZCkgcmV0dXJuOwoKICAgIGlmICh3UGFyYW0gPT0gSFRNSU5CVVRUT04pIAoJU2VuZE1lc3NhZ2UxNiggaHduZCwgV01fU1lTQ09NTUFORCwgU0NfTUlOSU1JWkUsICooTE9ORyopJnB0MTYgKTsKICAgIGVsc2UKCVNlbmRNZXNzYWdlMTYoIGh3bmQsIFdNX1NZU0NPTU1BTkQsIAoJCSAgSXNab29tZWQoaHduZCkgPyBTQ19SRVNUT1JFOlNDX01BWElNSVpFLCAqKExPTkcqKSZwdDE2ICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogTkNfVHJhY2tDbG9zZUJ1dHRvbjk1CiAqCiAqIFRyYWNrIGEgbW91c2UgYnV0dG9uIHByZXNzIG9uIHRoZSBXaW45NSBjbG9zZSBidXR0b24uCiAqLwpzdGF0aWMgdm9pZApOQ19UcmFja0Nsb3NlQnV0dG9uOTUgKEhXTkQgaHduZCwgV09SRCB3UGFyYW0pCnsKICAgIE1TRyBtc2c7CiAgICBQT0lOVDE2IHB0MTY7CiAgICBIREMgaGRjOwogICAgQk9PTCBwcmVzc2VkID0gVFJVRTsKICAgIEhNRU5VIGhTeXNNZW51ID0gR2V0U3lzdGVtTWVudShod25kLCBGQUxTRSk7CiAgICBVSU5UIHN0YXRlOwoKICAgIGlmKGhTeXNNZW51ID09IDApCglyZXR1cm47CgogICAgc3RhdGUgPSBHZXRNZW51U3RhdGUoaFN5c01lbnUsIFNDX0NMT1NFLCBNRl9CWUNPTU1BTkQpOwoJICAgIAogICAgLyogSWYgdGhlIGl0ZW0gY2xvc2Ugb2YgdGhlIHN5c21lbnUgaXMgZGlzYWJsZWQgb3Igbm90IHRoZXJlIGRvIG5vdGhpbmcgKi8KICAgIGlmKChzdGF0ZSAmIE1GX0RJU0FCTEVEKSB8fCAoc3RhdGUgJiBNRl9HUkFZRUQpIHx8IChzdGF0ZSA9PSAweEZGRkZGRkZGKSkKCXJldHVybjsKCiAgICBoZGMgPSBHZXRXaW5kb3dEQyggaHduZCApOwoKICAgIFNldENhcHR1cmUoIGh3bmQgKTsKCiAgICBOQ19EcmF3Q2xvc2VCdXR0b245NSAoaHduZCwgaGRjLCBUUlVFLCBGQUxTRSk7CgogICAgZG8KICAgIHsKCUJPT0wgb2xkc3RhdGUgPSBwcmVzc2VkOwogICAgICAgIE1TR19JbnRlcm5hbEdldE1lc3NhZ2UoIFFNU0dfV0lOMzJBLCAmbXNnLCAwLCAwLCAwLCBQTV9SRU1PVkUsIEZBTFNFLCBOVUxMICk7CiAgICAgICAgQ09OVl9QT0lOVDMyVE8xNiggJm1zZy5wdCwgJnB0MTYgKTsKCglwcmVzc2VkID0gKE5DX0hhbmRsZU5DSGl0VGVzdCggaHduZCwgcHQxNiApID09IHdQYXJhbSk7CglpZiAocHJlc3NlZCAhPSBvbGRzdGF0ZSkKCSAgIE5DX0RyYXdDbG9zZUJ1dHRvbjk1IChod25kLCBoZGMsIHByZXNzZWQsIEZBTFNFKTsKICAgIH0gd2hpbGUgKG1zZy5tZXNzYWdlICE9IFdNX0xCVVRUT05VUCk7CgogICAgTkNfRHJhd0Nsb3NlQnV0dG9uOTUgKGh3bmQsIGhkYywgRkFMU0UsIEZBTFNFKTsKCiAgICBSZWxlYXNlQ2FwdHVyZSgpOwogICAgUmVsZWFzZURDKCBod25kLCBoZGMgKTsKICAgIGlmICghcHJlc3NlZCkgcmV0dXJuOwoKICAgIFNlbmRNZXNzYWdlMTYoIGh3bmQsIFdNX1NZU0NPTU1BTkQsIFNDX0NMT1NFLCAqKExPTkcqKSZwdDE2ICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE5DX1RyYWNrU2Nyb2xsQmFyCiAqCiAqIFRyYWNrIGEgbW91c2UgYnV0dG9uIHByZXNzIG9uIHRoZSBob3Jpem9udGFsIG9yIHZlcnRpY2FsIHNjcm9sbC1iYXIuCiAqLwpzdGF0aWMgdm9pZCBOQ19UcmFja1Njcm9sbEJhciggSFdORCBod25kLCBXUEFSQU0gd1BhcmFtLCBQT0lOVCBwdCApCnsKICAgIE1TRzE2ICptc2c7CiAgICBJTlQgc2Nyb2xsYmFyOwogICAgV05EICp3bmRQdHIgPSBXSU5fRmluZFduZFB0ciggaHduZCApOwoKICAgIGlmICgod1BhcmFtICYgMHhmZmYwKSA9PSBTQ19IU0NST0xMKQogICAgewoJaWYgKCh3UGFyYW0gJiAweDBmKSAhPSBIVEhTQ1JPTEwpIGdvdG8gRU5EOwoJc2Nyb2xsYmFyID0gU0JfSE9SWjsKICAgIH0KICAgIGVsc2UgIC8qIFNDX1ZTQ1JPTEwgKi8KICAgIHsKCWlmICgod1BhcmFtICYgMHgwZikgIT0gSFRWU0NST0xMKSBnb3RvIEVORDsKCXNjcm9sbGJhciA9IFNCX1ZFUlQ7CiAgICB9CgogICAgaWYgKCEobXNnID0gU0VHUFRSX05FVyhNU0cxNikpKSBnb3RvIEVORDsKICAgIHB0LnggLT0gd25kUHRyLT5yZWN0V2luZG93LmxlZnQ7CiAgICBwdC55IC09IHduZFB0ci0+cmVjdFdpbmRvdy50b3A7CiAgICBTZXRDYXB0dXJlKCBod25kICk7CiAgICBTQ1JPTExfSGFuZGxlU2Nyb2xsRXZlbnQoIGh3bmQsIHNjcm9sbGJhciwgV01fTEJVVFRPTkRPV04sIHB0ICk7CgogICAgZG8KICAgIHsKICAgICAgICBHZXRNZXNzYWdlMTYoIFNFR1BUUl9HRVQobXNnKSwgMCwgMCwgMCApOwoJc3dpdGNoKG1zZy0+bWVzc2FnZSkKCXsKCWNhc2UgV01fTEJVVFRPTlVQOgoJY2FzZSBXTV9NT1VTRU1PVkU6CiAgICAgICAgY2FzZSBXTV9TWVNUSU1FUjoKICAgICAgICAgICAgcHQueCA9IExPV09SRChtc2ctPmxQYXJhbSkgKyB3bmRQdHItPnJlY3RDbGllbnQubGVmdCAtIAoJICAgICAgd25kUHRyLT5yZWN0V2luZG93LmxlZnQ7CiAgICAgICAgICAgIHB0LnkgPSBISVdPUkQobXNnLT5sUGFyYW0pICsgd25kUHRyLT5yZWN0Q2xpZW50LnRvcCAtIAoJICAgICAgd25kUHRyLT5yZWN0V2luZG93LnRvcDsKICAgICAgICAgICAgU0NST0xMX0hhbmRsZVNjcm9sbEV2ZW50KCBod25kLCBzY3JvbGxiYXIsIG1zZy0+bWVzc2FnZSwgcHQgKTsKCSAgICBicmVhazsKICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICBUcmFuc2xhdGVNZXNzYWdlMTYoIG1zZyApOwogICAgICAgICAgICBEaXNwYXRjaE1lc3NhZ2UxNiggbXNnICk7CiAgICAgICAgICAgIGJyZWFrOwoJfQogICAgICAgIGlmICghSXNXaW5kb3coIGh3bmQgKSkKICAgICAgICB7CiAgICAgICAgICAgIFJlbGVhc2VDYXB0dXJlKCk7CiAgICAgICAgICAgIGJyZWFrOwogICAgICAgIH0KICAgIH0gd2hpbGUgKG1zZy0+bWVzc2FnZSAhPSBXTV9MQlVUVE9OVVApOwogICAgU0VHUFRSX0ZSRUUobXNnKTsKRU5EOgogICAgV0lOX1JlbGVhc2VXbmRQdHIod25kUHRyKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBOQ19IYW5kbGVOQ0xCdXR0b25Eb3duCiAqCiAqIEhhbmRsZSBhIFdNX05DTEJVVFRPTkRPV04gbWVzc2FnZS4gQ2FsbGVkIGZyb20gRGVmV2luZG93UHJvYygpLgogKi8KTE9ORyBOQ19IYW5kbGVOQ0xCdXR0b25Eb3duKCBXTkQqIHBXbmQsIFdQQVJBTTE2IHdQYXJhbSwgTFBBUkFNIGxQYXJhbSApCnsKICAgIEhXTkQgaHduZCA9IHBXbmQtPmh3bmRTZWxmOwoKICAgIHN3aXRjaCh3UGFyYW0pICAvKiBIaXQgdGVzdCAqLwogICAgewogICAgY2FzZSBIVENBUFRJT046CgkgaHduZCA9IFdJTl9HZXRUb3BQYXJlbnQoaHduZCk7CgoJIGlmKCBXSU5QT1NfU2V0QWN0aXZlV2luZG93KGh3bmQsIFRSVUUsIFRSVUUpIHx8IChHZXRBY3RpdmVXaW5kb3coKSA9PSBod25kKSApCgkJU2VuZE1lc3NhZ2UxNiggcFduZC0+aHduZFNlbGYsIFdNX1NZU0NPTU1BTkQsIFNDX01PVkUgKyBIVENBUFRJT04sIGxQYXJhbSApOwoJIGJyZWFrOwoKICAgIGNhc2UgSFRTWVNNRU5VOgoJIGlmKCBwV25kLT5kd1N0eWxlICYgV1NfU1lTTUVOVSApCgkgewoJICAgICBpZiggIShwV25kLT5kd1N0eWxlICYgV1NfTUlOSU1JWkUpICkKCSAgICAgewoJCUhEQyBoREMgPSBHZXRXaW5kb3dEQyhod25kKTsKCQlpZiAoVFdFQUtfV2luZUxvb2sgPT0gV0lOMzFfTE9PSykKCQkgICAgTkNfRHJhd1N5c0J1dHRvbiggaHduZCwgaERDLCBUUlVFICk7CgkJZWxzZQoJCSAgICBOQ19EcmF3U3lzQnV0dG9uOTUoIGh3bmQsIGhEQywgVFJVRSApOwoJCVJlbGVhc2VEQyggaHduZCwgaERDICk7CgkgICAgIH0KCSAgICAgU2VuZE1lc3NhZ2UxNiggaHduZCwgV01fU1lTQ09NTUFORCwgU0NfTU9VU0VNRU5VICsgSFRTWVNNRU5VLCBsUGFyYW0gKTsKCSB9CgkgYnJlYWs7CgogICAgY2FzZSBIVE1FTlU6CglTZW5kTWVzc2FnZTE2KCBod25kLCBXTV9TWVNDT01NQU5ELCBTQ19NT1VTRU1FTlUsIGxQYXJhbSApOwoJYnJlYWs7CgogICAgY2FzZSBIVEhTQ1JPTEw6CglTZW5kTWVzc2FnZTE2KCBod25kLCBXTV9TWVNDT01NQU5ELCBTQ19IU0NST0xMICsgSFRIU0NST0xMLCBsUGFyYW0gKTsKCWJyZWFrOwoKICAgIGNhc2UgSFRWU0NST0xMOgoJU2VuZE1lc3NhZ2UxNiggaHduZCwgV01fU1lTQ09NTUFORCwgU0NfVlNDUk9MTCArIEhUVlNDUk9MTCwgbFBhcmFtICk7CglicmVhazsKCiAgICBjYXNlIEhUTUlOQlVUVE9OOgogICAgY2FzZSBIVE1BWEJVVFRPTjoKCWlmIChUV0VBS19XaW5lTG9vayA9PSBXSU4zMV9MT09LKQoJICAgIE5DX1RyYWNrTWluTWF4Qm94KCBod25kLCB3UGFyYW0gKTsKCWVsc2UKCSAgICBOQ19UcmFja01pbk1heEJveDk1KCBod25kLCB3UGFyYW0gKTsJICAgIAoJYnJlYWs7CgogICAgY2FzZSBIVENMT1NFOgoJaWYgKFRXRUFLX1dpbmVMb29rID49IFdJTjk1X0xPT0spCgkgICAgTkNfVHJhY2tDbG9zZUJ1dHRvbjk1IChod25kLCB3UGFyYW0pOwoJYnJlYWs7CgkKICAgIGNhc2UgSFRMRUZUOgogICAgY2FzZSBIVFJJR0hUOgogICAgY2FzZSBIVFRPUDoKICAgIGNhc2UgSFRUT1BMRUZUOgogICAgY2FzZSBIVFRPUFJJR0hUOgogICAgY2FzZSBIVEJPVFRPTToKICAgIGNhc2UgSFRCT1RUT01MRUZUOgogICAgY2FzZSBIVEJPVFRPTVJJR0hUOgoJLyogbWFrZSBzdXJlIGhpdHRlc3QgZml0cyBpbnRvIDB4ZiBhbmQgZG9lc24ndCBvdmVybGFwIHdpdGggSFRTWVNNRU5VICovCglTZW5kTWVzc2FnZTE2KCBod25kLCBXTV9TWVNDT01NQU5ELCBTQ19TSVpFICsgd1BhcmFtIC0gMiwgbFBhcmFtKTsKCWJyZWFrOwoKICAgIGNhc2UgSFRCT1JERVI6CglicmVhazsKICAgIH0KICAgIHJldHVybiAwOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBOQ19IYW5kbGVOQ0xCdXR0b25EYmxDbGsKICoKICogSGFuZGxlIGEgV01fTkNMQlVUVE9OREJMQ0xLIG1lc3NhZ2UuIENhbGxlZCBmcm9tIERlZldpbmRvd1Byb2MoKS4KICovCkxPTkcgTkNfSGFuZGxlTkNMQnV0dG9uRGJsQ2xrKCBXTkQgKnBXbmQsIFdQQVJBTTE2IHdQYXJhbSwgTFBBUkFNIGxQYXJhbSApCnsKICAgIC8qCiAgICAgKiBpZiB0aGlzIGlzIGFuIGljb24sIHNlbmQgYSByZXN0b3JlIHNpbmNlIHdlIGFyZSBoYW5kbGluZwogICAgICogYSBkb3VibGUgY2xpY2sKICAgICAqLwogICAgaWYgKHBXbmQtPmR3U3R5bGUgJiBXU19NSU5JTUlaRSkKICAgIHsKICAgICAgICBTZW5kTWVzc2FnZTE2KCBwV25kLT5od25kU2VsZiwgV01fU1lTQ09NTUFORCwgU0NfUkVTVE9SRSwgbFBhcmFtICk7CiAgICAgICAgcmV0dXJuIDA7CiAgICB9IAoKICAgIHN3aXRjaCh3UGFyYW0pICAvKiBIaXQgdGVzdCAqLwogICAgewogICAgY2FzZSBIVENBUFRJT046CiAgICAgICAgLyogc3RvcCBwcm9jZXNzaW5nIGlmIFdTX01BWElNSVpFQk9YIGlzIG1pc3NpbmcgKi8KICAgICAgICBpZiAocFduZC0+ZHdTdHlsZSAmIFdTX01BWElNSVpFQk9YKQogICAgICAgICAgICBTZW5kTWVzc2FnZTE2KCBwV25kLT5od25kU2VsZiwgV01fU1lTQ09NTUFORCwKICAgICAgICAgICAgICAgICAgICAgIChwV25kLT5kd1N0eWxlICYgV1NfTUFYSU1JWkUpID8gU0NfUkVTVE9SRSA6IFNDX01BWElNSVpFLAogICAgICAgICAgICAgICAgICAgICAgbFBhcmFtICk7CglicmVhazsKCiAgICBjYXNlIEhUU1lTTUVOVToKICAgICAgICBpZiAoIShHZXRDbGFzc1dvcmQocFduZC0+aHduZFNlbGYsIEdDV19TVFlMRSkgJiBDU19OT0NMT1NFKSkKICAgICAgICAgICAgU2VuZE1lc3NhZ2UxNiggcFduZC0+aHduZFNlbGYsIFdNX1NZU0NPTU1BTkQsIFNDX0NMT1NFLCBsUGFyYW0gKTsKCWJyZWFrOwoKICAgIGNhc2UgSFRIU0NST0xMOgoJU2VuZE1lc3NhZ2UxNiggcFduZC0+aHduZFNlbGYsIFdNX1NZU0NPTU1BTkQsIFNDX0hTQ1JPTEwgKyBIVEhTQ1JPTEwsCgkJICAgICAgIGxQYXJhbSApOwoJYnJlYWs7CgogICAgY2FzZSBIVFZTQ1JPTEw6CglTZW5kTWVzc2FnZTE2KCBwV25kLT5od25kU2VsZiwgV01fU1lTQ09NTUFORCwgU0NfVlNDUk9MTCArIEhUVlNDUk9MTCwKCQkgICAgICAgbFBhcmFtICk7CglicmVhazsKICAgIH0KICAgIHJldHVybiAwOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBOQ19IYW5kbGVTeXNDb21tYW5kCiAqCiAqIEhhbmRsZSBhIFdNX1NZU0NPTU1BTkQgbWVzc2FnZS4gQ2FsbGVkIGZyb20gRGVmV2luZG93UHJvYygpLgogKi8KTE9ORyBOQ19IYW5kbGVTeXNDb21tYW5kKCBIV05EIGh3bmQsIFdQQVJBTTE2IHdQYXJhbSwgUE9JTlQxNiBwdCApCnsKICAgIFdORCAqd25kUHRyID0gV0lOX0ZpbmRXbmRQdHIoIGh3bmQgKTsKICAgIFBPSU5UIHB0MzI7CiAgICBVSU5UMTYgdUNvbW1hbmQgPSB3UGFyYW0gJiAweEZGRjA7CgogICAgVFJBQ0UoIkhhbmRsaW5nIFdNX1NZU0NPTU1BTkQgJXggJWQsJWRcbiIsIHdQYXJhbSwgcHQueCwgcHQueSApOwoKICAgIGlmICh3bmRQdHItPmR3U3R5bGUgJiBXU19DSElMRCAmJiB1Q29tbWFuZCAhPSBTQ19LRVlNRU5VICkKICAgICAgICBTY3JlZW5Ub0NsaWVudDE2KCB3bmRQdHItPnBhcmVudC0+aHduZFNlbGYsICZwdCApOwoKICAgIHN3aXRjaCAodUNvbW1hbmQpCiAgICB7CiAgICBjYXNlIFNDX1NJWkU6CiAgICBjYXNlIFNDX01PVkU6CglOQ19Eb1NpemVNb3ZlKCBod25kLCB3UGFyYW0gKTsKCWJyZWFrOwoKICAgIGNhc2UgU0NfTUlOSU1JWkU6CiAgICAgICAgaWYgKGh3bmQgPT0gR2V0Rm9yZWdyb3VuZFdpbmRvdygpKQogICAgICAgICAgICBTaG93T3duZWRQb3B1cHMoaHduZCxGQUxTRSk7CglTaG93V2luZG93KCBod25kLCBTV19NSU5JTUlaRSApOyAKCWJyZWFrOwoKICAgIGNhc2UgU0NfTUFYSU1JWkU6CiAgICAgICAgaWYgKElzSWNvbmljKGh3bmQpICYmIGh3bmQgPT0gR2V0Rm9yZWdyb3VuZFdpbmRvdygpKQogICAgICAgICAgICBTaG93T3duZWRQb3B1cHMoaHduZCxUUlVFKTsKCVNob3dXaW5kb3coIGh3bmQsIFNXX01BWElNSVpFICk7CglicmVhazsKCiAgICBjYXNlIFNDX1JFU1RPUkU6CiAgICAgICAgaWYgKElzSWNvbmljKGh3bmQpICYmIGh3bmQgPT0gR2V0Rm9yZWdyb3VuZFdpbmRvdygpKQogICAgICAgICAgICBTaG93T3duZWRQb3B1cHMoaHduZCxUUlVFKTsKCVNob3dXaW5kb3coIGh3bmQsIFNXX1JFU1RPUkUgKTsKCWJyZWFrOwoKICAgIGNhc2UgU0NfQ0xPU0U6CiAgICAgICAgV0lOX1JlbGVhc2VXbmRQdHIod25kUHRyKTsKCXJldHVybiBTZW5kTWVzc2FnZTE2KCBod25kLCBXTV9DTE9TRSwgMCwgMCApOwoKICAgIGNhc2UgU0NfVlNDUk9MTDoKICAgIGNhc2UgU0NfSFNDUk9MTDoKICAgICAgICBDT05WX1BPSU5UMTZUTzMyKCAmcHQsICZwdDMyICk7CglOQ19UcmFja1Njcm9sbEJhciggaHduZCwgd1BhcmFtLCBwdDMyICk7CglicmVhazsKCiAgICBjYXNlIFNDX01PVVNFTUVOVToKICAgICAgICBDT05WX1BPSU5UMTZUTzMyKCAmcHQsICZwdDMyICk7CiAgICAgICAgTUVOVV9UcmFja01vdXNlTWVudUJhciggd25kUHRyLCB3UGFyYW0gJiAweDAwMEYsIHB0MzIgKTsKCWJyZWFrOwoKICAgIGNhc2UgU0NfS0VZTUVOVToKCU1FTlVfVHJhY2tLYmRNZW51QmFyKCB3bmRQdHIgLCB3UGFyYW0gLCBwdC54ICk7CglicmVhazsKCQogICAgY2FzZSBTQ19UQVNLTElTVDoKCVdpbkV4ZWMoICJ0YXNrbWFuLmV4ZSIsIFNXX1NIT1dOT1JNQUwgKTsgCglicmVhazsKCiAgICBjYXNlIFNDX1NDUkVFTlNBVkU6CglpZiAod1BhcmFtID09IFNDX0FCT1VUV0lORSkKICAgICAgICB7CiAgICAgICAgICAgIEhNT0RVTEUgaG1vZHVsZSA9IExvYWRMaWJyYXJ5QSggInNoZWxsMzIuZGxsIiApOwogICAgICAgICAgICBpZiAoaG1vZHVsZSkKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgRkFSUFJPQyBhYm91dHByb2MgPSBHZXRQcm9jQWRkcmVzcyggaG1vZHVsZSwgIlNoZWxsQWJvdXRBIiApOwogICAgICAgICAgICAgICAgaWYgKGFib3V0cHJvYykgYWJvdXRwcm9jKCBod25kLCAiV2luZSIsIFdJTkVfUkVMRUFTRV9JTkZPLCAwICk7CiAgICAgICAgICAgICAgICBGcmVlTGlicmFyeSggaG1vZHVsZSApOwogICAgICAgICAgICB9CiAgICAgICAgfQoJZWxzZSAKCSAgaWYgKHdQYXJhbSA9PSBTQ19QVVRNQVJLKQogICAgICAgICAgICBUUkFDRV8oc2hlbGwpKCJNYXJrIHJlcXVlc3RlZCBieSB1c2VyXG4iKTsKCWJyZWFrOwogIAogICAgY2FzZSBTQ19IT1RLRVk6CiAgICBjYXNlIFNDX0FSUkFOR0U6CiAgICBjYXNlIFNDX05FWFRXSU5ET1c6CiAgICBjYXNlIFNDX1BSRVZXSU5ET1c6CiAJRklYTUUoInVuaW1wbGVtZW50ZWQhXG4iKTsKICAgICAgICBicmVhazsKICAgIH0KICAgIFdJTl9SZWxlYXNlV25kUHRyKHduZFB0cik7CiAgICByZXR1cm4gMDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKiAgTkNfRHJhd0dyYXlCdXR0b24KKgoqIFN0dWIgZm9yIHRoZSBncmF5ZWQgYnV0dG9uIG9mIHRoZSBjYXB0aW9uCioKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCkJPT0wgTkNfRHJhd0dyYXlCdXR0b24oSERDIGhkYywgaW50IHgsIGludCB5KQp7CiAgICBIQklUTUFQIGhNYXNrQm1wOwogICAgSERDIGhkY01hc2sgPSBDcmVhdGVDb21wYXRpYmxlREMgKDApOwogICAgSEJSVVNIIGhPbGRCcnVzaDsKCiAgICBoTWFza0JtcCA9IENyZWF0ZUJpdG1hcCAoMTIsIDEwLCAxLCAxLCBscEdyYXlNYXNrKTsKICAgIAogICAgaWYoaE1hc2tCbXAgPT0gMCkKCXJldHVybiBGQUxTRTsKICAgIAogICAgU2VsZWN0T2JqZWN0IChoZGNNYXNrLCBoTWFza0JtcCk7CiAgICAKICAgIC8qIERyYXcgdGhlIGdyYXllZCBiaXRtYXAgdXNpbmcgdGhlIG1hc2sgKi8KICAgIGhPbGRCcnVzaCA9IFNlbGVjdE9iamVjdCAoaGRjLCBSR0IoMTI4LCAxMjgsIDEyOCkpOwogICAgQml0Qmx0IChoZGMsIHgsIHksIDEyLCAxMCwKCSAgICBoZGNNYXNrLCAwLCAwLCAweEI4MDc0QSk7CiAgICAKICAgIC8qIENsZWFuIHVwICovCiAgICBTZWxlY3RPYmplY3QgKGhkYywgaE9sZEJydXNoKTsKICAgIERlbGV0ZU9iamVjdChoTWFza0JtcCk7CiAgICBEZWxldGVEQyAoaGRjTWFzayk7CiAgICAKICAgIHJldHVybiBUUlVFOwp9CgpISUNPTjE2IE5DX0ljb25Gb3JXaW5kb3coV05EICp3bmRQdHIpCnsKCUhJQ09OMTYgaEljb24gPSAoSElDT04pIEdldENsYXNzTG9uZ0Eod25kUHRyLT5od25kU2VsZiwgR0NMX0hJQ09OU00pOwoJaWYoIWhJY29uKSBoSWNvbiA9IChISUNPTikgR2V0Q2xhc3NMb25nQSh3bmRQdHItPmh3bmRTZWxmLCBHQ0xfSElDT04pOwoKCS8qIElmIHRoZXJlIGlzIG5vIGhJY29uIHNwZWNpZmllZCBhbmQgdGhpcyBpcyBhIG1vZGFsIGRpYWxvZywgKi8gCiAgICAgICAgLyogZ2V0IHRoZSBkZWZhdWx0IG9uZS4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqLwoJaWYgKCFoSWNvbiAmJiAod25kUHRyLT5kd1N0eWxlICYgRFNfTU9EQUxGUkFNRSkpCgkJaEljb24gPSBMb2FkSW1hZ2VBKDAsIE1BS0VJTlRSRVNPVVJDRUEoT0lDX1dJTkVJQ09OKSwgSU1BR0VfSUNPTiwgMCwgMCwgTFJfREVGQVVMVENPTE9SKTsKCglyZXR1cm4gaEljb247Cn0K