LyoKICogTWVudSBmdW5jdGlvbnMKICoKICogQ29weXJpZ2h0IDE5OTMgTWFydGluIEF5b3R0ZQogKiBDb3B5cmlnaHQgMTk5NCBBbGV4YW5kcmUgSnVsbGlhcmQKICogQ29weXJpZ2h0IDE5OTcgTW9ydGVuIFdlbGluZGVyCiAqIENvcHlyaWdodCAyMDA1IE1heGltZSBCZWxsZW5n6QogKgogKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCiAqIHZlcnNpb24gMi4xIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgogKgogKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYwogKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCiAqIEZvdW5kYXRpb24sIEluYy4sIDU5IFRlbXBsZSBQbGFjZSwgU3VpdGUgMzMwLCBCb3N0b24sIE1BICAwMjExMS0xMzA3ICBVU0EKICovCgovKgogKiBOb3RlOiB0aGUgc3R5bGUgTUZfTU9VU0VTRUxFQ1QgaXMgdXNlZCB0byBtYXJrIHBvcHVwIGl0ZW1zIHRoYXQKICogaGF2ZSBiZWVuIHNlbGVjdGVkLCBpLmUuIHRoZWlyIHBvcHVwIG1lbnUgaXMgY3VycmVudGx5IGRpc3BsYXllZC4KICogVGhpcyBpcyBwcm9iYWJseSBub3QgdGhlIG1lYW5pbmcgdGhpcyBzdHlsZSBoYXMgaW4gTVMtV2luZG93cy4KICoKICogVE9ETzoKICogICAgaW1wbGVtZW50cyBzdHlsZXMgOgogKiAgICAgICAgLSBNTlNfQVVUT0RJU01JU1MKICogICAgICAgIC0gTU5TX0RSQUdEUk9QCiAqICAgICAgICAtIE1OU19NT0RFTEVTUwogKiAgICAgICAgLSBNTlNfTk9DSEVDSwogKiAgICAgICAgLSBNTlNfTk9USUZZQllQT1MKICovCgojaW5jbHVkZSAiY29uZmlnLmgiCiNpbmNsdWRlICJ3aW5lL3BvcnQuaCIKCiNpbmNsdWRlIDxzdGRhcmcuaD4KI2luY2x1ZGUgPHN0cmluZy5oPgoKI2luY2x1ZGUgIndpbmRlZi5oIgojaW5jbHVkZSAid2luYmFzZS5oIgojaW5jbHVkZSAid2luZ2RpLmgiCiNpbmNsdWRlICJ3aW5ubHMuaCIKI2luY2x1ZGUgIndpbmUvd2luYmFzZTE2LmgiCiNpbmNsdWRlICJ3aW5lL3dpbnVzZXIxNi5oIgojaW5jbHVkZSAid293bnQzMi5oIgojaW5jbHVkZSAid2luZS9zZXJ2ZXIuaCIKI2luY2x1ZGUgIndpbmUvdW5pY29kZS5oIgojaW5jbHVkZSAid2luLmgiCiNpbmNsdWRlICJjb250cm9scy5oIgojaW5jbHVkZSAidXNlcl9wcml2YXRlLmgiCiNpbmNsdWRlICJ3aW5lL2RlYnVnLmgiCgpXSU5FX0RFRkFVTFRfREVCVUdfQ0hBTk5FTChtZW51KTsKV0lORV9ERUNMQVJFX0RFQlVHX0NIQU5ORUwoYWNjZWwpOwoKLyogaW50ZXJuYWwgcG9wdXAgbWVudSB3aW5kb3cgbWVzc2FnZXMgKi8KCiNkZWZpbmUgTU1fU0VUTUVOVUhBTkRMRQkoV01fVVNFUiArIDApCiNkZWZpbmUgTU1fR0VUTUVOVUhBTkRMRQkoV01fVVNFUiArIDEpCgovKiBNZW51IGl0ZW0gc3RydWN0dXJlICovCnR5cGVkZWYgc3RydWN0IHsKICAgIC8qIC0tLS0tLS0tLS0tIE1FTlVJVEVNSU5GTyBTdHVmZiAtLS0tLS0tLS0tLSAqLwogICAgVUlOVCBmVHlwZTsJCQkvKiBJdGVtIHR5cGUuICovCiAgICBVSU5UIGZTdGF0ZTsJCS8qIEl0ZW0gc3RhdGUuICAqLwogICAgVUlOVF9QVFIgd0lEOwkJLyogSXRlbSBpZC4gICovCiAgICBITUVOVSBoU3ViTWVudTsJCS8qIFBvcC11cCBtZW51LiAgKi8KICAgIEhCSVRNQVAgaENoZWNrQml0OwkJLyogQml0bWFwIHdoZW4gY2hlY2tlZC4gICovCiAgICBIQklUTUFQIGhVbkNoZWNrQml0OwkvKiBCaXRtYXAgd2hlbiB1bmNoZWNrZWQuICAqLwogICAgTFBXU1RSIHRleHQ7CQkJLyogSXRlbSB0ZXh0IG9yIGJpdG1hcCBoYW5kbGUuICAqLwogICAgRFdPUkQgZHdJdGVtRGF0YTsJCS8qIEFwcGxpY2F0aW9uIGRlZmluZWQuICAqLwogICAgRFdPUkQgZHdUeXBlRGF0YTsJCS8qIGRlcGVuZHMgb24gZk1hc2sgKi8KICAgIEhCSVRNQVAgaGJtcEl0ZW07CQkvKiBiaXRtYXAgaW4gd2luOTggc3R5bGUgbWVudXMgKi8KICAgIC8qIC0tLS0tLS0tLS0tIFdpbmUgc3R1ZmYgLS0tLS0tLS0tLS0gKi8KICAgIFJFQ1QgICAgICByZWN0OwkJLyogSXRlbSBhcmVhIChyZWxhdGl2ZSB0byBtZW51IHdpbmRvdykgKi8KICAgIFVJTlQgICAgICB4VGFiOwkJLyogWCBwb3NpdGlvbiBvZiB0ZXh0IGFmdGVyIFRhYiAqLwp9IE1FTlVJVEVNOwoKLyogUG9wdXAgbWVudSBzdHJ1Y3R1cmUgKi8KdHlwZWRlZiBzdHJ1Y3QgewogICAgV09SRCAgICAgICAgd0ZsYWdzOyAgICAgICAvKiBNZW51IGZsYWdzIChNRl9QT1BVUCwgTUZfU1lTTUVOVSkgKi8KICAgIFdPUkQgICAgICAgIHdNYWdpYzsgICAgICAgLyogTWFnaWMgbnVtYmVyICovCiAgICBXT1JECVdpZHRoOyAgICAgICAgLyogV2lkdGggb2YgdGhlIHdob2xlIG1lbnUgKi8KICAgIFdPUkQJSGVpZ2h0OyAgICAgICAvKiBIZWlnaHQgb2YgdGhlIHdob2xlIG1lbnUgKi8KICAgIFVJTlQgICAgICAgIG5JdGVtczsgICAgICAgLyogTnVtYmVyIG9mIGl0ZW1zIGluIHRoZSBtZW51ICovCiAgICBIV05EICAgICAgICBoV25kOyAgICAgICAgIC8qIFdpbmRvdyBjb250YWluaW5nIHRoZSBtZW51ICovCiAgICBNRU5VSVRFTSAgICAqaXRlbXM7ICAgICAgIC8qIEFycmF5IG9mIG1lbnUgaXRlbXMgKi8KICAgIFVJTlQgICAgICAgIEZvY3VzZWRJdGVtOyAgLyogQ3VycmVudGx5IGZvY3VzZWQgaXRlbSAqLwogICAgSFdORAlod25kT3duZXI7ICAgIC8qIHdpbmRvdyByZWNlaXZpbmcgdGhlIG1lc3NhZ2VzIGZvciBvd25lcmRyYXcgKi8KICAgIEJPT0wgICAgICAgIGJUaW1lVG9IaWRlOyAgLyogUmVxdWVzdCBoaWRpbmcgd2hlbiByZWNlaXZpbmcgYSBzZWNvbmQgY2xpY2sgaW4gdGhlIHRvcC1sZXZlbCBtZW51IGl0ZW0gKi8KICAgIC8qIC0tLS0tLS0tLS0tLSBNRU5VSU5GTyBtZW1iZXJzIC0tLS0tLSAqLwogICAgRFdPUkQJZHdTdHlsZTsJLyogRXh0ZW5kZWQgbWVubnUgc3R5bGUgKi8KICAgIFVJTlQJY3lNYXg7CQkvKiBtYXggaGlnaHQgb2YgdGhlIHdob2xlIG1lbnUsIDAgaXMgc2NyZWVuIGhpZ2h0ICovCiAgICBIQlJVU0gJaGJyQmFjazsJLyogYnJ1c2ggZm9yIG1lbnUgYmFja2dyb3VuZCAqLwogICAgRFdPUkQJZHdDb250ZXh0SGVscElEOwogICAgRFdPUkQJZHdNZW51RGF0YTsJLyogYXBwbGljYXRpb24gZGVmaW5lZCB2YWx1ZSAqLwogICAgSE1FTlUgICAgICAgaFN5c01lbnVPd25lcjsgIC8qIEhhbmRsZSB0byB0aGUgZHVtbXkgc3lzIG1lbnUgaG9sZGVyICovCiAgICBTSVpFICAgICAgICBtYXhCbXBTaXplOyAgICAgLyogTWF4aW11bSBzaXplIG9mIHRoZSBiaXRtYXAgaXRlbXMgaW4gTUlJTV9CSVRNQVAgc3RhdGUgKi8KfSBQT1BVUE1FTlUsICpMUFBPUFVQTUVOVTsKCi8qIGludGVybmFsIGZsYWdzIGZvciBtZW51IHRyYWNraW5nICovCgojZGVmaW5lIFRGX0VORE1FTlUgICAgICAgICAgICAgIDB4MDAwMQojZGVmaW5lIFRGX1NVU1BFTkRQT1BVUCAgICAgICAgIDB4MDAwMgojZGVmaW5lIFRGX1NLSVBSRU1PVkUJCTB4MDAwNAoKdHlwZWRlZiBzdHJ1Y3QKewogICAgVUlOVAl0cmFja0ZsYWdzOwogICAgSE1FTlUJaEN1cnJlbnRNZW51OyAvKiBjdXJyZW50IHN1Ym1lbnUgKGNhbiBiZSBlcXVhbCB0byBoVG9wTWVudSkqLwogICAgSE1FTlUJaFRvcE1lbnU7ICAgICAvKiBpbml0aWFsIG1lbnUgKi8KICAgIEhXTkQJaE93bmVyV25kOyAgICAvKiB3aGVyZSBub3RpZmljYXRpb25zIGFyZSBzZW50ICovCiAgICBQT0lOVAlwdDsKfSBNVFJBQ0tFUjsKCiNkZWZpbmUgTUVOVV9NQUdJQyAgIDB4NTU0ZCAgLyogJ01VJyAqLwoKI2RlZmluZSBJVEVNX1BSRVYJCS0xCiNkZWZpbmUgSVRFTV9ORVhUCQkgMQoKICAvKiBJbnRlcm5hbCBNRU5VX1RyYWNrTWVudSgpIGZsYWdzICovCiNkZWZpbmUgVFBNX0lOVEVSTkFMCQkweEYwMDAwMDAwCiNkZWZpbmUgVFBNX0VOVEVSSURMRUVYCSAJMHg4MDAwMDAwMAkJLyogc2V0IG93bmVyIHdpbmRvdyBmb3IgV01fRU5URVJJRExFICovCiNkZWZpbmUgVFBNX0JVVFRPTkRPV04JCTB4NDAwMDAwMDAJCS8qIG1lbnUgd2FzIGNsaWNrZWQgYmVmb3JlIHRyYWNraW5nICovCiNkZWZpbmUgVFBNX1BPUFVQTUVOVSAgICAgICAgICAgMHgyMDAwMDAwMCAgICAgICAgICAgICAgLyogbWVudSBpcyBhIHBvcHVwIG1lbnUgKi8KCiAgLyogcG9wdXAgbWVudSBzaGFkZSB0aGlja25lc3MgKi8KI2RlZmluZSBQT1BVUF9YU0hBREUJCTQKI2RlZmluZSBQT1BVUF9ZU0hBREUJCTQKCiAgLyogU3BhY2UgYmV0d2VlbiAyIG1lbnUgYmFyIGl0ZW1zICovCiNkZWZpbmUgTUVOVV9CQVJfSVRFTVNfU1BBQ0UgMTIKCiAgLyogTWluaW11bSB3aWR0aCBvZiBhIHRhYiBjaGFyYWN0ZXIgKi8KI2RlZmluZSBNRU5VX1RBQl9TUEFDRSA4CgogIC8qIEhlaWdodCBvZiBhIHNlcGFyYXRvciBpdGVtICovCiNkZWZpbmUgU0VQQVJBVE9SX0hFSUdIVCA1CgogIC8qIChvdGhlciBtZW51LT5Gb2N1c2VkSXRlbSB2YWx1ZXMgZ2l2ZSB0aGUgcG9zaXRpb24gb2YgdGhlIGZvY3VzZWQgaXRlbSkgKi8KI2RlZmluZSBOT19TRUxFQ1RFRF9JVEVNICAweGZmZmYKCiNkZWZpbmUgTUVOVV9JVEVNX1RZUEUoZmxhZ3MpIFwKICAoKGZsYWdzKSAmIChNRl9TVFJJTkcgfCBNRl9CSVRNQVAgfCBNRl9PV05FUkRSQVcgfCBNRl9TRVBBUkFUT1IpKQoKI2RlZmluZSBJU19TVFJJTkdfSVRFTShmbGFncykgKE1FTlVfSVRFTV9UWVBFICgoZmxhZ3MpKSA9PSBNRl9TVFJJTkcpCiNkZWZpbmUgSVNfQklUTUFQX0lURU0oZmxhZ3MpIChNRU5VX0lURU1fVFlQRSAoKGZsYWdzKSkgPT0gTUZfQklUTUFQKQojZGVmaW5lIElTX01BR0lDX0lURU0odGV4dCkgICAoTE9XT1JEKChpbnQpdGV4dCk8MTIpCgojZGVmaW5lIElTX1NZU1RFTV9NRU5VKG1lbnUpICBcCgkoISgobWVudSktPndGbGFncyAmIE1GX1BPUFVQKSAmJiAoKG1lbnUpLT53RmxhZ3MgJiBNRl9TWVNNRU5VKSkKCiNkZWZpbmUgVFlQRV9NQVNLIChNRlRfU1RSSU5HIHwgTUZUX0JJVE1BUCB8IE1GVF9PV05FUkRSQVcgfCBNRlRfU0VQQVJBVE9SIHwgXAoJCSAgIE1GVF9NRU5VQkFSQlJFQUsgfCBNRlRfTUVOVUJSRUFLIHwgTUZUX1JBRElPQ0hFQ0sgfCBcCgkJICAgTUZUX1JJR0hUT1JERVIgfCBNRlRfUklHSFRKVVNUSUZZIHwgXAoJCSAgIE1GX1BPUFVQIHwgTUZfU1lTTUVOVSB8IE1GX0hFTFApCiNkZWZpbmUgU1RBVEVfTUFTSyAoflRZUEVfTUFTSykKCiAgLyogRGltZW5zaW9uIG9mIHRoZSBtZW51IGJpdG1hcHMgKi8Kc3RhdGljIFdPUkQgYXJyb3dfYml0bWFwX3dpZHRoID0gMCwgYXJyb3dfYml0bWFwX2hlaWdodCA9IDA7CgpzdGF0aWMgSEJJVE1BUCBoU3RkTW5BcnJvdyA9IDA7CnN0YXRpYyBIQklUTUFQIGhCbXBTeXNNZW51ID0gMDsKCnN0YXRpYyBIQlJVU0gJaFNoYWRlQnJ1c2ggPSAwOwpzdGF0aWMgSEZPTlQJaE1lbnVGb250ID0gMDsKc3RhdGljIEhGT05UCWhNZW51Rm9udEJvbGQgPSAwOwoKc3RhdGljIEhNRU5VIE1FTlVfRGVmU3lzUG9wdXAgPSAwOyAgLyogRGVmYXVsdCBzeXN0ZW0gbWVudSBwb3B1cCAqLwoKLyogVXNlIGdsb2JhbCBwb3B1cCB3aW5kb3cgYmVjYXVzZSB0aGVyZSdzIG5vIHdheSAyIG1lbnVzIGNhbgogKiBiZSB0cmFja2VkIGF0IHRoZSBzYW1lIHRpbWUuICAqLwpzdGF0aWMgSFdORCB0b3BfcG9wdXA7CgogIC8qIEZsYWcgc2V0IGJ5IEVuZE1lbnUoKSB0byBmb3JjZSBhbiBleGl0IGZyb20gbWVudSB0cmFja2luZyAqLwpzdGF0aWMgQk9PTCBmRW5kTWVudSA9IEZBTFNFOwoKc3RhdGljIExSRVNVTFQgV0lOQVBJIFBvcHVwTWVudVduZFByb2MoIEhXTkQgaHduZCwgVUlOVCBtZXNzYWdlLCBXUEFSQU0gd1BhcmFtLCBMUEFSQU0gbFBhcmFtICk7CgpEV09SRCBXSU5BUEkgRHJhd01lbnVCYXJUZW1wKEhXTkQgaHduZCwgSERDIGhEQywgTFBSRUNUIGxwcmVjdCwgSE1FTlUgaE1lbnUsIEhGT05UIGhGb250KTsKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogbWVudSBjbGFzcyBkZXNjcmlwdG9yCiAqLwpjb25zdCBzdHJ1Y3QgYnVpbHRpbl9jbGFzc19kZXNjciBNRU5VX2J1aWx0aW5fY2xhc3MgPQp7CiAgICBQT1BVUE1FTlVfQ0xBU1NfQVRPTUEsICAgICAgICAgLyogbmFtZSAqLwogICAgQ1NfRFJPUFNIQURPVyB8IENTX1NBVkVCSVRTIHwgQ1NfREJMQ0xLUywgIC8qIHN0eWxlICovCiAgICBOVUxMLCAgICAgICAgICAgICAgICAgICAgICAgICAgLyogcHJvY0EgKHdpbnByb2MgaXMgVW5pY29kZSBvbmx5KSAqLwogICAgUG9wdXBNZW51V25kUHJvYywgICAgICAgICAgICAgIC8qIHByb2NXICovCiAgICBzaXplb2YoSE1FTlUpLCAgICAgICAgICAgICAgICAgLyogZXh0cmEgKi8KICAgIElEQ19BUlJPVywgICAgICAgICAgICAgICAgICAgICAvKiBjdXJzb3IgKi8KICAgIChIQlJVU0gpKENPTE9SX01FTlUrMSkgICAgICAgICAvKiBicnVzaCAqLwp9OwoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgZGVidWdfcHJpbnRfbWVudWl0ZW0KICoKICogUHJpbnQgYSBtZW51aXRlbSBpbiByZWFkYWJsZSBmb3JtLgogKi8KCiNkZWZpbmUgZGVidWdfcHJpbnRfbWVudWl0ZW0ocHJlLCBtcCwgcG9zdCkgXAogIGlmKCFUUkFDRV9PTihtZW51KSkgOyBlbHNlIGRvX2RlYnVnX3ByaW50X21lbnVpdGVtKHByZSwgbXAsIHBvc3QpCgojZGVmaW5lIE1FTlVPVVQodGV4dCkgXAogIERQUklOVEYoIiVzJXMiLCAoY291bnQrKyA/ICIsIiA6ICIiKSwgKHRleHQpKQoKI2RlZmluZSBNRU5VRkxBRyhiaXQsdGV4dCkgXAogIGRvIHsgXAogICAgaWYgKGZsYWdzICYgKGJpdCkpIHsgZmxhZ3MgJj0gfihiaXQpOyBNRU5VT1VUICgodGV4dCkpOyB9IFwKICB9IHdoaWxlICgwKQoKc3RhdGljIHZvaWQgZG9fZGVidWdfcHJpbnRfbWVudWl0ZW0oY29uc3QgY2hhciAqcHJlZml4LCBNRU5VSVRFTSAqIG1wLAoJCQkJICAgIGNvbnN0IGNoYXIgKnBvc3RmaXgpCnsKICAgIFRSQUNFKCIlcyAiLCBwcmVmaXgpOwogICAgaWYgKG1wKSB7CglVSU5UIGZsYWdzID0gbXAtPmZUeXBlOwoJaW50IHR5cGUgPSBNRU5VX0lURU1fVFlQRShmbGFncyk7CglEUFJJTlRGKCAieyBJRD0weCV4IiwgbXAtPndJRCk7CglpZiAoZmxhZ3MgJiBNRl9QT1BVUCkKCSAgICBEUFJJTlRGKCAiLCBTdWI9JXAiLCBtcC0+aFN1Yk1lbnUpOwoJaWYgKGZsYWdzKSB7CgkgICAgaW50IGNvdW50ID0gMDsKCSAgICBEUFJJTlRGKCAiLCBUeXBlPSIpOwoJICAgIGlmICh0eXBlID09IE1GVF9TVFJJTkcpCgkJLyogTm90aGluZyAqLyA7CgkgICAgZWxzZSBpZiAodHlwZSA9PSBNRlRfU0VQQVJBVE9SKQoJCU1FTlVPVVQoInNlcCIpOwoJICAgIGVsc2UgaWYgKHR5cGUgPT0gTUZUX09XTkVSRFJBVykKCQlNRU5VT1VUKCJvd24iKTsKCSAgICBlbHNlIGlmICh0eXBlID09IE1GVF9CSVRNQVApCgkJTUVOVU9VVCgiYml0Iik7CgkgICAgZWxzZQoJCU1FTlVPVVQoIj8/PyIpOwoJICAgIGZsYWdzIC09IHR5cGU7CgoJICAgIE1FTlVGTEFHKE1GX1BPUFVQLCAicG9wIik7CgkgICAgTUVOVUZMQUcoTUZUX01FTlVCQVJCUkVBSywgImJhcmJyayIpOwoJICAgIE1FTlVGTEFHKE1GVF9NRU5VQlJFQUssICJicmsiKTsKCSAgICBNRU5VRkxBRyhNRlRfUkFESU9DSEVDSywgInJhZGlvIik7CgkgICAgTUVOVUZMQUcoTUZUX1JJR0hUT1JERVIsICJyb3JkZXIiKTsKCSAgICBNRU5VRkxBRyhNRl9TWVNNRU5VLCAic3lzIik7CgkgICAgTUVOVUZMQUcoTUZUX1JJR0hUSlVTVElGWSwgInJpZ2h0Iik7CS8qIHNhbWUgYXMgTUZfSEVMUCAqLwoKCSAgICBpZiAoZmxhZ3MpCgkJRFBSSU5URiggIisweCV4IiwgZmxhZ3MpOwoJfQoJZmxhZ3MgPSBtcC0+ZlN0YXRlOwoJaWYgKGZsYWdzKSB7CgkgICAgaW50IGNvdW50ID0gMDsKCSAgICBEUFJJTlRGKCAiLCBTdGF0ZT0iKTsKCSAgICBNRU5VRkxBRyhNRlNfR1JBWUVELCAiZ3JleSIpOwoJICAgIE1FTlVGTEFHKE1GU19ERUZBVUxULCAiZGVmYXVsdCIpOwoJICAgIE1FTlVGTEFHKE1GU19ESVNBQkxFRCwgImRpcyIpOwoJICAgIE1FTlVGTEFHKE1GU19DSEVDS0VELCAiY2hlY2siKTsKCSAgICBNRU5VRkxBRyhNRlNfSElMSVRFLCAiaGkiKTsKCSAgICBNRU5VRkxBRyhNRl9VU0VDSEVDS0JJVE1BUFMsICJ1c2ViaXQiKTsKCSAgICBNRU5VRkxBRyhNRl9NT1VTRVNFTEVDVCwgIm1vdXNlIik7CgkgICAgaWYgKGZsYWdzKQoJCURQUklOVEYoICIrMHgleCIsIGZsYWdzKTsKCX0KCWlmIChtcC0+aENoZWNrQml0KQoJICAgIERQUklOVEYoICIsIENoaz0lcCIsIG1wLT5oQ2hlY2tCaXQpOwoJaWYgKG1wLT5oVW5DaGVja0JpdCkKCSAgICBEUFJJTlRGKCAiLCBVbmM9JXAiLCBtcC0+aFVuQ2hlY2tCaXQpOwoKCWlmICh0eXBlID09IE1GVF9TVFJJTkcpIHsKCSAgICBpZiAobXAtPnRleHQpCgkJRFBSSU5URiggIiwgVGV4dD0lcyIsIGRlYnVnc3RyX3cobXAtPnRleHQpKTsKCSAgICBlbHNlCgkJRFBSSU5URiggIiwgVGV4dD1OdWxsIik7Cgl9IGVsc2UgaWYgKG1wLT50ZXh0ID09IE5VTEwpCgkgICAgLyogTm90aGluZyAqLyA7CgllbHNlCgkgICAgRFBSSU5URiggIiwgVGV4dD0lcCIsIG1wLT50ZXh0KTsKCWlmIChtcC0+ZHdJdGVtRGF0YSkKCSAgICBEUFJJTlRGKCAiLCBJdGVtRGF0YT0weCUwOGx4IiwgbXAtPmR3SXRlbURhdGEpOwoJRFBSSU5URiggIiB9Iik7CiAgICB9IGVsc2UgewoJRFBSSU5URiggIk5VTEwiKTsKICAgIH0KCiAgICBEUFJJTlRGKCIgJXNcbiIsIHBvc3RmaXgpOwp9CgojdW5kZWYgTUVOVU9VVAojdW5kZWYgTUVOVUZMQUcKCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfR2V0TWVudQogKgogKiBWYWxpZGF0ZSB0aGUgZ2l2ZW4gbWVudSBoYW5kbGUgYW5kIHJldHVybnMgdGhlIG1lbnUgc3RydWN0dXJlIHBvaW50ZXIuCiAqLwpzdGF0aWMgUE9QVVBNRU5VICpNRU5VX0dldE1lbnUoSE1FTlUgaE1lbnUpCnsKICAgIFBPUFVQTUVOVSAqbWVudSA9IFVTRVJfSEVBUF9MSU5fQUREUihoTWVudSk7CiAgICBpZiAoIW1lbnUgfHwgbWVudS0+d01hZ2ljICE9IE1FTlVfTUFHSUMpCiAgICB7CiAgICAgICAgV0FSTigiaW52YWxpZCBtZW51IGhhbmRsZT0lcCwgcHRyPSVwLCBtYWdpYz0leFxuIiwgaE1lbnUsIG1lbnUsIG1lbnU/IG1lbnUtPndNYWdpYzowKTsKICAgICAgICBtZW51ID0gTlVMTDsKICAgIH0KICAgIHJldHVybiBtZW51Owp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIGdldF93aW5fc3lzX21lbnUKICoKICogR2V0IHRoZSBzeXN0ZW0gbWVudSBvZiBhIHdpbmRvdwogKi8Kc3RhdGljIEhNRU5VIGdldF93aW5fc3lzX21lbnUoIEhXTkQgaHduZCApCnsKICAgIEhNRU5VIHJldCA9IDA7CiAgICBXTkQgKndpbiA9IFdJTl9HZXRQdHIoIGh3bmQgKTsKICAgIGlmICh3aW4gJiYgd2luICE9IFdORF9PVEhFUl9QUk9DRVNTKQogICAgewogICAgICAgIHJldCA9IHdpbi0+aFN5c01lbnU7CiAgICAgICAgV0lOX1JlbGVhc2VQdHIoIHdpbiApOwogICAgfQogICAgcmV0dXJuIHJldDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0NvcHlTeXNQb3B1cAogKgogKiBSZXR1cm4gdGhlIGRlZmF1bHQgc3lzdGVtIG1lbnUuCiAqLwpzdGF0aWMgSE1FTlUgTUVOVV9Db3B5U3lzUG9wdXAodm9pZCkKewogICAgc3RhdGljIGNvbnN0IFdDSEFSIHN5c21lbnVXW10gPSB7J1MnLCdZJywnUycsJ00nLCdFJywnTicsJ1UnLDB9OwogICAgSE1FTlUgaE1lbnUgPSBMb2FkTWVudVcodXNlcjMyX21vZHVsZSwgc3lzbWVudVcpOwoKICAgIGlmKCBoTWVudSApIHsKICAgICAgICBQT1BVUE1FTlUqIG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpOwogICAgICAgIG1lbnUtPndGbGFncyB8PSBNRl9TWVNNRU5VIHwgTUZfUE9QVVA7CglTZXRNZW51RGVmYXVsdEl0ZW0oaE1lbnUsIFNDX0NMT1NFLCBGQUxTRSk7CiAgICB9CiAgICBlbHNlCglFUlIoIlVuYWJsZSB0byBsb2FkIGRlZmF1bHQgc3lzdGVtIG1lbnVcbiIgKTsKCiAgICBUUkFDRSgicmV0dXJuaW5nICVwLlxuIiwgaE1lbnUgKTsKCiAgICByZXR1cm4gaE1lbnU7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9HZXRTeXNNZW51CiAqCiAqIENyZWF0ZSBhIGNvcHkgb2YgdGhlIHN5c3RlbSBtZW51LiBTeXN0ZW0gbWVudSBpbiBXaW5kb3dzIGlzCiAqIGEgc3BlY2lhbCBtZW51IGJhciB3aXRoIHRoZSBzaW5nbGUgZW50cnkgLSBzeXN0ZW0gbWVudSBwb3B1cC4KICogVGhpcyBwb3B1cCBpcyBwcmVzZW50ZWQgdG8gdGhlIG91dHNpZGUgd29ybGQgYXMgYSAic3lzdGVtIG1lbnUiLgogKiBIb3dldmVyLCB0aGUgcmVhbCBzeXN0ZW0gbWVudSBoYW5kbGUgaXMgc29tZXRpbWVzIHNlZW4gaW4gdGhlCiAqIFdNX01FTlVTRUxFQ1QgcGFyYW1ldGVycyAoYW5kIFdvcmQgNiBsaWtlcyBpdCB0aGlzIHdheSkuCiAqLwpITUVOVSBNRU5VX0dldFN5c01lbnUoIEhXTkQgaFduZCwgSE1FTlUgaFBvcHVwTWVudSApCnsKICAgIEhNRU5VIGhNZW51OwoKICAgIFRSQUNFKCJsb2FkaW5nIHN5c3RlbSBtZW51LCBoV25kICVwLCBoUG9wdXBNZW51ICVwXG4iLCBoV25kLCBoUG9wdXBNZW51KTsKICAgIGlmICgoaE1lbnUgPSBDcmVhdGVNZW51KCkpKQogICAgewoJUE9QVVBNRU5VICptZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KTsKCW1lbnUtPndGbGFncyA9IE1GX1NZU01FTlU7CgltZW51LT5oV25kID0gV0lOX0dldEZ1bGxIYW5kbGUoIGhXbmQgKTsKCVRSQUNFKCJoV25kICVwIChoTWVudSAlcClcbiIsIG1lbnUtPmhXbmQsIGhNZW51KTsKCglpZiAoaFBvcHVwTWVudSA9PSAoSE1FTlUpKC0xKSkKCSAgICBoUG9wdXBNZW51ID0gTUVOVV9Db3B5U3lzUG9wdXAoKTsKCWVsc2UgaWYoICFoUG9wdXBNZW51ICkgaFBvcHVwTWVudSA9IE1FTlVfRGVmU3lzUG9wdXA7CgoJaWYgKGhQb3B1cE1lbnUpCgl7CgkgICAgSW5zZXJ0TWVudVcoIGhNZW51LCAtMSwgTUZfU1lTTUVOVSB8IE1GX1BPUFVQIHwgTUZfQllQT1NJVElPTiwKICAgICAgICAgICAgICAgICAgICAgICAgIChVSU5UX1BUUiloUG9wdXBNZW51LCBOVUxMICk7CgogICAgICAgICAgICBtZW51LT5pdGVtc1swXS5mVHlwZSA9IE1GX1NZU01FTlUgfCBNRl9QT1BVUDsKICAgICAgICAgICAgbWVudS0+aXRlbXNbMF0uZlN0YXRlID0gMDsKICAgICAgICAgICAgaWYgKChtZW51ID0gTUVOVV9HZXRNZW51KGhQb3B1cE1lbnUpKSkgbWVudS0+d0ZsYWdzIHw9IE1GX1NZU01FTlU7CgoJICAgIFRSQUNFKCJoTWVudT0lcCAoaFBvcHVwICVwKVxuIiwgaE1lbnUsIGhQb3B1cE1lbnUgKTsKCSAgICByZXR1cm4gaE1lbnU7Cgl9CglEZXN0cm95TWVudSggaE1lbnUgKTsKICAgIH0KICAgIEVSUigiZmFpbGVkIHRvIGxvYWQgc3lzdGVtIG1lbnUhXG4iKTsKICAgIHJldHVybiAwOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0luaXQKICoKICogTWVudXMgaW5pdGlhbGlzYXRpb24uCiAqLwpCT09MIE1FTlVfSW5pdCh2b2lkKQp7CiAgICBIQklUTUFQIGhCaXRtYXA7CiAgICBOT05DTElFTlRNRVRSSUNTVyBuY207CgogICAgc3RhdGljIHVuc2lnbmVkIGNoYXIgc2hhZGVfYml0c1sxNl0gPSB7IDB4NTUsIDAsIDB4QUEsIDAsCgkJCQkJICAgIDB4NTUsIDAsIDB4QUEsIDAsCgkJCQkJICAgIDB4NTUsIDAsIDB4QUEsIDAsCgkJCQkJICAgIDB4NTUsIDAsIDB4QUEsIDAgfTsKCiAgICAvKiBMb2FkIG1lbnUgYml0bWFwcyAqLwogICAgaFN0ZE1uQXJyb3cgPSBMb2FkQml0bWFwVygwLCBNQUtFSU5UUkVTT1VSQ0VXKE9CTV9NTkFSUk9XKSk7CiAgICAvKiBMb2FkIHN5c3RlbSBidXR0b25zIGJpdG1hcHMgKi8KICAgIGhCbXBTeXNNZW51ID0gTG9hZEJpdG1hcFcoMCwgTUFLRUlOVFJFU09VUkNFVyhPQk1fQ0xPU0UpKTsKCiAgICBpZiAoaFN0ZE1uQXJyb3cpCiAgICB7CglCSVRNQVAgYm07CglHZXRPYmplY3RXKCBoU3RkTW5BcnJvdywgc2l6ZW9mKGJtKSwgJmJtICk7CglhcnJvd19iaXRtYXBfd2lkdGggPSBibS5ibVdpZHRoOwoJYXJyb3dfYml0bWFwX2hlaWdodCA9IGJtLmJtSGVpZ2h0OwogICAgfSBlbHNlCglyZXR1cm4gRkFMU0U7CgogICAgaWYgKCEgKGhCaXRtYXAgPSBDcmVhdGVCaXRtYXAoIDgsIDgsIDEsIDEsIHNoYWRlX2JpdHMpKSkKCXJldHVybiBGQUxTRTsKCiAgICBpZighKGhTaGFkZUJydXNoID0gQ3JlYXRlUGF0dGVybkJydXNoKCBoQml0bWFwICkpKQoJcmV0dXJuIEZBTFNFOwoKICAgIERlbGV0ZU9iamVjdCggaEJpdG1hcCApOwogICAgaWYgKCEoTUVOVV9EZWZTeXNQb3B1cCA9IE1FTlVfQ29weVN5c1BvcHVwKCkpKQoJcmV0dXJuIEZBTFNFOwoKICAgIG5jbS5jYlNpemUgPSBzaXplb2YoTk9OQ0xJRU5UTUVUUklDU1cpOwogICAgaWYgKCEoU3lzdGVtUGFyYW1ldGVyc0luZm9XKFNQSV9HRVROT05DTElFTlRNRVRSSUNTLCBzaXplb2YoTk9OQ0xJRU5UTUVUUklDU1cpLCAmbmNtLCAwKSkpCglyZXR1cm4gRkFMU0U7CgogICAgaWYgKCEoaE1lbnVGb250ID0gQ3JlYXRlRm9udEluZGlyZWN0VyggJm5jbS5sZk1lbnVGb250ICkpKQoJcmV0dXJuIEZBTFNFOwoKICAgIG5jbS5sZk1lbnVGb250LmxmV2VpZ2h0ICs9IDMwMDsKICAgIGlmICggbmNtLmxmTWVudUZvbnQubGZXZWlnaHQgPiAxMDAwKQoJbmNtLmxmTWVudUZvbnQubGZXZWlnaHQgPSAxMDAwOwoKICAgIGlmICghKGhNZW51Rm9udEJvbGQgPSBDcmVhdGVGb250SW5kaXJlY3RXKCAmbmNtLmxmTWVudUZvbnQgKSkpCglyZXR1cm4gRkFMU0U7CgogICAgcmV0dXJuIFRSVUU7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9Jbml0U3lzTWVudVBvcHVwCiAqCiAqIEdyZXkgdGhlIGFwcHJvcHJpYXRlIGl0ZW1zIGluIFN5c3RlbSBtZW51LgogKi8Kc3RhdGljIHZvaWQgTUVOVV9Jbml0U3lzTWVudVBvcHVwKCBITUVOVSBobWVudSwgRFdPUkQgc3R5bGUsIERXT1JEIGNsc1N0eWxlICkKewogICAgQk9PTCBncmF5OwoKICAgIGdyYXkgPSAhKHN0eWxlICYgV1NfVEhJQ0tGUkFNRSkgfHwgKHN0eWxlICYgKFdTX01BWElNSVpFIHwgV1NfTUlOSU1JWkUpKTsKICAgIEVuYWJsZU1lbnVJdGVtKCBobWVudSwgU0NfU0laRSwgKGdyYXkgPyBNRl9HUkFZRUQgOiBNRl9FTkFCTEVEKSApOwogICAgZ3JheSA9ICgoc3R5bGUgJiBXU19NQVhJTUlaRSkgIT0gMCk7CiAgICBFbmFibGVNZW51SXRlbSggaG1lbnUsIFNDX01PVkUsIChncmF5ID8gTUZfR1JBWUVEIDogTUZfRU5BQkxFRCkgKTsKICAgIGdyYXkgPSAhKHN0eWxlICYgV1NfTUlOSU1JWkVCT1gpIHx8IChzdHlsZSAmIFdTX01JTklNSVpFKTsKICAgIEVuYWJsZU1lbnVJdGVtKCBobWVudSwgU0NfTUlOSU1JWkUsIChncmF5ID8gTUZfR1JBWUVEIDogTUZfRU5BQkxFRCkgKTsKICAgIGdyYXkgPSAhKHN0eWxlICYgV1NfTUFYSU1JWkVCT1gpIHx8IChzdHlsZSAmIFdTX01BWElNSVpFKTsKICAgIEVuYWJsZU1lbnVJdGVtKCBobWVudSwgU0NfTUFYSU1JWkUsIChncmF5ID8gTUZfR1JBWUVEIDogTUZfRU5BQkxFRCkgKTsKICAgIGdyYXkgPSAhKHN0eWxlICYgKFdTX01BWElNSVpFIHwgV1NfTUlOSU1JWkUpKTsKICAgIEVuYWJsZU1lbnVJdGVtKCBobWVudSwgU0NfUkVTVE9SRSwgKGdyYXkgPyBNRl9HUkFZRUQgOiBNRl9FTkFCTEVEKSApOwogICAgZ3JheSA9IChjbHNTdHlsZSAmIENTX05PQ0xPU0UpICE9IDA7CgogICAgLyogVGhlIG1lbnUgaXRlbSBtdXN0IGtlZXAgaXRzIHN0YXRlIGlmIGl0J3MgZGlzYWJsZWQgKi8KICAgIGlmKGdyYXkpCglFbmFibGVNZW51SXRlbSggaG1lbnUsIFNDX0NMT1NFLCBNRl9HUkFZRUQpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgogKiAgIFVJTlQgIE1FTlVfR2V0U3RhcnRPZk5leHRDb2x1bW4oCiAqICAgICBITUVOVSAgaE1lbnUgKQogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgpzdGF0aWMgVUlOVCAgTUVOVV9HZXRTdGFydE9mTmV4dENvbHVtbigKICAgIEhNRU5VICBoTWVudSApCnsKICAgIFBPUFVQTUVOVSAqbWVudSA9IE1FTlVfR2V0TWVudShoTWVudSk7CiAgICBVSU5UIGk7CgogICAgaWYoIW1lbnUpCglyZXR1cm4gTk9fU0VMRUNURURfSVRFTTsKCiAgICBpID0gbWVudS0+Rm9jdXNlZEl0ZW0gKyAxOwogICAgaWYoIGkgPT0gTk9fU0VMRUNURURfSVRFTSApCglyZXR1cm4gaTsKCiAgICBmb3IoIDsgaSA8IG1lbnUtPm5JdGVtczsgKytpICkgewoJaWYgKG1lbnUtPml0ZW1zW2ldLmZUeXBlICYgTUZfTUVOVUJBUkJSRUFLKQoJICAgIHJldHVybiBpOwogICAgfQoKICAgIHJldHVybiBOT19TRUxFQ1RFRF9JVEVNOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgogKiAgIFVJTlQgIE1FTlVfR2V0U3RhcnRPZlByZXZDb2x1bW4oCiAqICAgICBITUVOVSAgaE1lbnUgKQogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgpzdGF0aWMgVUlOVCAgTUVOVV9HZXRTdGFydE9mUHJldkNvbHVtbigKICAgIEhNRU5VICBoTWVudSApCnsKICAgIFBPUFVQTUVOVSAqbWVudSA9IE1FTlVfR2V0TWVudShoTWVudSk7CiAgICBVSU5UICBpOwoKICAgIGlmKCAhbWVudSApCglyZXR1cm4gTk9fU0VMRUNURURfSVRFTTsKCiAgICBpZiggbWVudS0+Rm9jdXNlZEl0ZW0gPT0gMCB8fCBtZW51LT5Gb2N1c2VkSXRlbSA9PSBOT19TRUxFQ1RFRF9JVEVNICkKCXJldHVybiBOT19TRUxFQ1RFRF9JVEVNOwoKICAgIC8qIEZpbmQgdGhlIHN0YXJ0IG9mIHRoZSBjb2x1bW4gKi8KCiAgICBmb3IoaSA9IG1lbnUtPkZvY3VzZWRJdGVtOyBpICE9IDAgJiYKCSAhKG1lbnUtPml0ZW1zW2ldLmZUeXBlICYgTUZfTUVOVUJBUkJSRUFLKTsKCS0taSk7IC8qIGVtcHR5ICovCgogICAgaWYoaSA9PSAwKQoJcmV0dXJuIE5PX1NFTEVDVEVEX0lURU07CgogICAgZm9yKC0taTsgaSAhPSAwOyAtLWkpIHsKCWlmIChtZW51LT5pdGVtc1tpXS5mVHlwZSAmIE1GX01FTlVCQVJCUkVBSykKCSAgICBicmVhazsKICAgIH0KCiAgICBUUkFDRSgicmV0ICVkLlxuIiwgaSApOwoKICAgIHJldHVybiBpOwp9CgoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9GaW5kSXRlbQogKgogKiBGaW5kIGEgbWVudSBpdGVtLiBSZXR1cm4gYSBwb2ludGVyIG9uIHRoZSBpdGVtLCBhbmQgbW9kaWZpZXMgKmhtZW51CiAqIGluIGNhc2UgdGhlIGl0ZW0gd2FzIGluIGEgc3ViLW1lbnUuCiAqLwpzdGF0aWMgTUVOVUlURU0gKk1FTlVfRmluZEl0ZW0oIEhNRU5VICpobWVudSwgVUlOVCAqblBvcywgVUlOVCB3RmxhZ3MgKQp7CiAgICBQT1BVUE1FTlUgKm1lbnU7CiAgICBVSU5UIGk7CgogICAgaWYgKCgqaG1lbnUgPT0gKEhNRU5VKTB4ZmZmZikgfHwgKCEobWVudSA9IE1FTlVfR2V0TWVudSgqaG1lbnUpKSkpIHJldHVybiBOVUxMOwogICAgaWYgKHdGbGFncyAmIE1GX0JZUE9TSVRJT04pCiAgICB7CglpZiAoKm5Qb3MgPj0gbWVudS0+bkl0ZW1zKSByZXR1cm4gTlVMTDsKCXJldHVybiAmbWVudS0+aXRlbXNbKm5Qb3NdOwogICAgfQogICAgZWxzZQogICAgewogICAgICAgIE1FTlVJVEVNICppdGVtID0gbWVudS0+aXRlbXM7Cglmb3IgKGkgPSAwOyBpIDwgbWVudS0+bkl0ZW1zOyBpKyssIGl0ZW0rKykKCXsKCSAgICBpZiAoaXRlbS0+d0lEID09ICpuUG9zKQoJICAgIHsKCQkqblBvcyA9IGk7CgkJcmV0dXJuIGl0ZW07CgkgICAgfQoJICAgIGVsc2UgaWYgKGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApCgkgICAgewoJCUhNRU5VIGhzdWJtZW51ID0gaXRlbS0+aFN1Yk1lbnU7CgkJTUVOVUlURU0gKnN1Yml0ZW0gPSBNRU5VX0ZpbmRJdGVtKCAmaHN1Ym1lbnUsIG5Qb3MsIHdGbGFncyApOwoJCWlmIChzdWJpdGVtKQoJCXsKCQkgICAgKmhtZW51ID0gaHN1Ym1lbnU7CgkJICAgIHJldHVybiBzdWJpdGVtOwoJCX0KCSAgICB9Cgl9CiAgICB9CiAgICByZXR1cm4gTlVMTDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0ZpbmRTdWJNZW51CiAqCiAqIEZpbmQgYSBTdWIgbWVudS4gUmV0dXJuIHRoZSBwb3NpdGlvbiBvZiB0aGUgc3VibWVudSwgYW5kIG1vZGlmaWVzCiAqICpobWVudSBpbiBjYXNlIGl0IGlzIGZvdW5kIGluIGFub3RoZXIgc3ViLW1lbnUuCiAqIElmIHRoZSBzdWJtZW51IGNhbm5vdCBiZSBmb3VuZCwgTk9fU0VMRUNURURfSVRFTSBpcyByZXR1cm5lZC4KICovClVJTlQgTUVOVV9GaW5kU3ViTWVudSggSE1FTlUgKmhtZW51LCBITUVOVSBoU3ViVGFyZ2V0ICkKewogICAgUE9QVVBNRU5VICptZW51OwogICAgVUlOVCBpOwogICAgTUVOVUlURU0gKml0ZW07CiAgICBpZiAoKCgqaG1lbnUpPT0oSE1FTlUpMHhmZmZmKSB8fAogICAgICAgICAgICAoIShtZW51ID0gTUVOVV9HZXRNZW51KCpobWVudSkpKSkKICAgICAgICByZXR1cm4gTk9fU0VMRUNURURfSVRFTTsKICAgIGl0ZW0gPSBtZW51LT5pdGVtczsKICAgIGZvciAoaSA9IDA7IGkgPCBtZW51LT5uSXRlbXM7IGkrKywgaXRlbSsrKSB7CiAgICAgICAgaWYoIShpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKSkgY29udGludWU7CiAgICAgICAgaWYgKGl0ZW0tPmhTdWJNZW51ID09IGhTdWJUYXJnZXQpIHsKICAgICAgICAgICAgcmV0dXJuIGk7CiAgICAgICAgfQogICAgICAgIGVsc2UgIHsKICAgICAgICAgICAgSE1FTlUgaHN1Ym1lbnUgPSBpdGVtLT5oU3ViTWVudTsKICAgICAgICAgICAgVUlOVCBwb3MgPSBNRU5VX0ZpbmRTdWJNZW51KCAmaHN1Ym1lbnUsIGhTdWJUYXJnZXQgKTsKICAgICAgICAgICAgaWYgKHBvcyAhPSBOT19TRUxFQ1RFRF9JVEVNKSB7CiAgICAgICAgICAgICAgICAqaG1lbnUgPSBoc3VibWVudTsKICAgICAgICAgICAgICAgIHJldHVybiBwb3M7CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICB9CiAgICByZXR1cm4gTk9fU0VMRUNURURfSVRFTTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0ZyZWVJdGVtRGF0YQogKi8Kc3RhdGljIHZvaWQgTUVOVV9GcmVlSXRlbURhdGEoIE1FTlVJVEVNKiBpdGVtICkKewogICAgLyogZGVsZXRlIHRleHQgKi8KICAgIGlmIChJU19TVFJJTkdfSVRFTShpdGVtLT5mVHlwZSkgJiYgaXRlbS0+dGV4dCkKICAgICAgICBIZWFwRnJlZSggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgaXRlbS0+dGV4dCApOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfRmluZEl0ZW1CeUNvb3JkcwogKgogKiBGaW5kIHRoZSBpdGVtIGF0IHRoZSBzcGVjaWZpZWQgY29vcmRpbmF0ZXMgKHNjcmVlbiBjb29yZHMpLiBEb2VzCiAqIG5vdCB3b3JrIGZvciBjaGlsZCB3aW5kb3dzIGFuZCB0aGVyZWZvcmUgc2hvdWxkIG5vdCBiZSBjYWxsZWQgZm9yCiAqIGFuIGFyYml0cmFyeSBzeXN0ZW0gbWVudS4KICovCnN0YXRpYyBNRU5VSVRFTSAqTUVOVV9GaW5kSXRlbUJ5Q29vcmRzKCBjb25zdCBQT1BVUE1FTlUgKm1lbnUsCgkJCQkJUE9JTlQgcHQsIFVJTlQgKnBvcyApCnsKICAgIE1FTlVJVEVNICppdGVtOwogICAgVUlOVCBpOwogICAgUkVDVCB3cmVjdDsKCiAgICBpZiAoIUdldFdpbmRvd1JlY3QobWVudS0+aFduZCwmd3JlY3QpKSByZXR1cm4gTlVMTDsKICAgIHB0LnggLT0gd3JlY3QubGVmdDtwdC55IC09IHdyZWN0LnRvcDsKICAgIGl0ZW0gPSBtZW51LT5pdGVtczsKICAgIGZvciAoaSA9IDA7IGkgPCBtZW51LT5uSXRlbXM7IGkrKywgaXRlbSsrKQogICAgewoJaWYgKChwdC54ID49IGl0ZW0tPnJlY3QubGVmdCkgJiYgKHB0LnggPCBpdGVtLT5yZWN0LnJpZ2h0KSAmJgoJICAgIChwdC55ID49IGl0ZW0tPnJlY3QudG9wKSAmJiAocHQueSA8IGl0ZW0tPnJlY3QuYm90dG9tKSkKCXsKCSAgICBpZiAocG9zKSAqcG9zID0gaTsKCSAgICByZXR1cm4gaXRlbTsKCX0KICAgIH0KICAgIHJldHVybiBOVUxMOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0ZpbmRJdGVtQnlLZXkKICoKICogRmluZCB0aGUgbWVudSBpdGVtIHNlbGVjdGVkIGJ5IGEga2V5IHByZXNzLgogKiBSZXR1cm4gaXRlbSBpZCwgLTEgaWYgbm9uZSwgLTIgaWYgd2Ugc2hvdWxkIGNsb3NlIHRoZSBtZW51LgogKi8Kc3RhdGljIFVJTlQgTUVOVV9GaW5kSXRlbUJ5S2V5KCBIV05EIGh3bmRPd25lciwgSE1FTlUgaG1lbnUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0NIQVIga2V5LCBCT09MIGZvcmNlTWVudUNoYXIgKQp7CiAgICBUUkFDRSgiXHRsb29raW5nIGZvciAnJWMnICgweCUwMngpIGluIFslcF1cbiIsIChjaGFyKWtleSwga2V5LCBobWVudSApOwoKICAgIGlmICghSXNNZW51KCBobWVudSApKSBobWVudSA9IEdldFN1Yk1lbnUoIGdldF93aW5fc3lzX21lbnUoaHduZE93bmVyKSwgMCk7CgogICAgaWYgKGhtZW51KQogICAgewoJUE9QVVBNRU5VICptZW51ID0gTUVOVV9HZXRNZW51KCBobWVudSApOwoJTUVOVUlURU0gKml0ZW0gPSBtZW51LT5pdGVtczsKCUxSRVNVTFQgbWVudWNoYXI7CgoJaWYoICFmb3JjZU1lbnVDaGFyICkKCXsKCSAgICAgVUlOVCBpOwoKCSAgICAgZm9yIChpID0gMDsgaSA8IG1lbnUtPm5JdGVtczsgaSsrLCBpdGVtKyspCgkgICAgIHsKCQlpZiAoSVNfU1RSSU5HX0lURU0oaXRlbS0+ZlR5cGUpICYmIGl0ZW0tPnRleHQpCgkJewoJCSAgICBXQ0hBUiAqcCA9IGl0ZW0tPnRleHQgLSAyOwoJCSAgICBkbwoJCSAgICB7CgkJICAgIAlwID0gc3RyY2hyVyAocCArIDIsICcmJyk7CgkJICAgIH0KCQkgICAgd2hpbGUgKHAgIT0gTlVMTCAmJiBwIFsxXSA9PSAnJicpOwoJCSAgICBpZiAocCAmJiAodG91cHBlclcocFsxXSkgPT0gdG91cHBlclcoa2V5KSkpIHJldHVybiBpOwoJCX0KCSAgICAgfQoJfQoJbWVudWNoYXIgPSBTZW5kTWVzc2FnZVcoIGh3bmRPd25lciwgV01fTUVOVUNIQVIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE1BS0VXUEFSQU0oIGtleSwgbWVudS0+d0ZsYWdzICksIChMUEFSQU0paG1lbnUgKTsKCWlmIChISVdPUkQobWVudWNoYXIpID09IDIpIHJldHVybiBMT1dPUkQobWVudWNoYXIpOwoJaWYgKEhJV09SRChtZW51Y2hhcikgPT0gMSkgcmV0dXJuIChVSU5UKSgtMik7CiAgICB9CiAgICByZXR1cm4gKFVJTlQpKC0xKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9HZXRCaXRtYXBJdGVtU2l6ZQogKgogKiBHZXQgdGhlIHNpemUgb2YgYSBiaXRtYXAgaXRlbS4KICovCnN0YXRpYyB2b2lkIE1FTlVfR2V0Qml0bWFwSXRlbVNpemUoIFVJTlQgaWQsIERXT1JEIGRhdGEsIFNJWkUgKnNpemUgKQp7CiAgICBCSVRNQVAgYm07CiAgICBIQklUTUFQIGJtcCA9IChIQklUTUFQKWlkOwoKICAgIHNpemUtPmN4ID0gc2l6ZS0+Y3kgPSAwOwoKICAgIC8qIGNoZWNrIGlmIHRoZXJlIGlzIGEgbWFnaWMgbWVudSBpdGVtIGFzc29jaWF0ZWQgd2l0aCB0aGlzIGl0ZW0gKi8KICAgIGlmIChpZCAmJiBJU19NQUdJQ19JVEVNKCBpZCApKQogICAgewogICAgICAgIHN3aXRjaChMT1dPUkQoaWQpKQogICAgICAgIHsKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfU1lTVEVNOgogICAgICAgICAgICBpZiAoZGF0YSkKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgYm1wID0gKEhCSVRNQVApZGF0YTsKICAgICAgICAgICAgICAgIGJyZWFrOwogICAgICAgICAgICB9CiAgICAgICAgICAgIC8qIGZhbGwgdGhyb3VnaCAqLwogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9NQkFSX1JFU1RPUkU6CiAgICAgICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX01CQVJfTUlOSU1JWkU6CiAgICAgICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX01CQVJfTUlOSU1JWkVfRDoKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfTUJBUl9DTE9TRToKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfTUJBUl9DTE9TRV9EOgogICAgICAgICAgICBzaXplLT5jeCA9IEdldFN5c3RlbU1ldHJpY3MoIFNNX0NZTUVOVSApIC0gNDsKICAgICAgICAgICAgc2l6ZS0+Y3kgPSBzaXplLT5jeDsKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9DQUxMQkFDSzoKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfUE9QVVBfQ0xPU0U6CiAgICAgICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX1BPUFVQX1JFU1RPUkU6CiAgICAgICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX1BPUFVQX01BWElNSVpFOgogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9QT1BVUF9NSU5JTUlaRToKICAgICAgICBkZWZhdWx0OgogICAgICAgICAgICBGSVhNRSgiTWFnaWMgMHglMDh4IG5vdCBpbXBsZW1lbnRlZFxuIiwgaWQpOwogICAgICAgICAgICByZXR1cm47CiAgICAgICAgfQogICAgfQogICAgaWYgKEdldE9iamVjdFcoYm1wLCBzaXplb2YoYm0pLCAmYm0gKSkKICAgIHsKICAgICAgICBzaXplLT5jeCA9IGJtLmJtV2lkdGg7CiAgICAgICAgc2l6ZS0+Y3kgPSBibS5ibUhlaWdodDsKICAgIH0KfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0RyYXdCaXRtYXBJdGVtCiAqCiAqIERyYXcgYSBiaXRtYXAgaXRlbS4KICogZHJhd2hibWJpdG1hcCA6IFRydWUgdG8gZHJhdyB0aGUgaGJtYml0bWFwKE1JSU1fQklUTUFQKS9GYWxzZSB0byBkcmF3IHRoZSBNRl9CSVRNQVAKICovCnN0YXRpYyB2b2lkIE1FTlVfRHJhd0JpdG1hcEl0ZW0oIEhEQyBoZGMsIE1FTlVJVEVNICpscGl0ZW0sIGNvbnN0IFJFQ1QgKnJlY3QsIEJPT0wgbWVudUJhciwgQk9PTCBkcmF3aGJtYml0bWFwICkKewogICAgQklUTUFQIGJtOwogICAgRFdPUkQgcm9wOwogICAgSERDIGhkY01lbTsKICAgIEhCSVRNQVAgYm1wID0gKEhCSVRNQVApbHBpdGVtLT50ZXh0OwogICAgaW50IHcgPSByZWN0LT5yaWdodCAtIHJlY3QtPmxlZnQ7CiAgICBpbnQgaCA9IHJlY3QtPmJvdHRvbSAtIHJlY3QtPnRvcDsKICAgIGludCBibXBfeG9mZnNldCA9IDA7CiAgICBpbnQgbGVmdCwgdG9wOwogICAgSEJJVE1BUCBoYm1Ub0RyYXcgPSAoZHJhd2hibWJpdG1hcCk/bHBpdGVtLT5oYm1wSXRlbTooSEJJVE1BUClscGl0ZW0tPnRleHQ7ICAgIAoKICAgIC8qIENoZWNrIGlmIHRoZXJlIGlzIGEgbWFnaWMgbWVudSBpdGVtIGFzc29jaWF0ZWQgd2l0aCB0aGlzIGl0ZW0gKi8KICAgIGlmIChoYm1Ub0RyYXcgJiYgSVNfTUFHSUNfSVRFTShoYm1Ub0RyYXcpKQogICAgewogICAgICAgIFVJTlQgZmxhZ3MgPSAwOwogICAgICAgIFJFQ1QgcjsKCglzd2l0Y2goTE9XT1JEKGhibVRvRHJhdykpCiAgICAgICAgewogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9TWVNURU06CiAgICAgICAgICAgIGlmIChscGl0ZW0tPmR3SXRlbURhdGEpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIGJtcCA9IChIQklUTUFQKWxwaXRlbS0+ZHdJdGVtRGF0YTsKICAgICAgICAgICAgICAgIGlmICghR2V0T2JqZWN0VyggYm1wLCBzaXplb2YoYm0pLCAmYm0gKSkgcmV0dXJuOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgYm1wID0gaEJtcFN5c01lbnU7CiAgICAgICAgICAgICAgICBpZiAoIUdldE9iamVjdFcoIGJtcCwgc2l6ZW9mKGJtKSwgJmJtICkpIHJldHVybjsKICAgICAgICAgICAgICAgIC8qIG9ubHkgdXNlIHJpZ2h0IGhhbGYgb2YgdGhlIGJpdG1hcCAqLwogICAgICAgICAgICAgICAgYm1wX3hvZmZzZXQgPSBibS5ibVdpZHRoIC8gMjsKICAgICAgICAgICAgICAgIGJtLmJtV2lkdGggLT0gYm1wX3hvZmZzZXQ7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgZ290byBnb3RfYml0bWFwOwogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9NQkFSX1JFU1RPUkU6CiAgICAgICAgICAgIGZsYWdzID0gREZDU19DQVBUSU9OUkVTVE9SRTsKICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX01CQVJfTUlOSU1JWkU6CiAgICAgICAgICAgIGZsYWdzID0gREZDU19DQVBUSU9OTUlOOwogICAgICAgICAgICBicmVhazsKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfTUJBUl9NSU5JTUlaRV9EOgogICAgICAgICAgICBmbGFncyA9IERGQ1NfQ0FQVElPTk1JTiB8IERGQ1NfSU5BQ1RJVkU7CiAgICAgICAgICAgIGJyZWFrOwogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9NQkFSX0NMT1NFOgogICAgICAgICAgICBmbGFncyA9IERGQ1NfQ0FQVElPTkNMT1NFOwogICAgICAgICAgICBicmVhazsKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfTUJBUl9DTE9TRV9EOgogICAgICAgICAgICBmbGFncyA9IERGQ1NfQ0FQVElPTkNMT1NFIHwgREZDU19JTkFDVElWRTsKICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX0NBTExCQUNLOgogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9QT1BVUF9DTE9TRToKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfUE9QVVBfUkVTVE9SRToKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfUE9QVVBfTUFYSU1JWkU6CiAgICAgICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX1BPUFVQX01JTklNSVpFOgogICAgICAgIGRlZmF1bHQ6CgkgICAgRklYTUUoIk1hZ2ljIDB4JTA4eCBub3QgaW1wbGVtZW50ZWRcbiIsIExPV09SRChoYm1Ub0RyYXcpKTsgCiAgICAgICAgICAgIHJldHVybjsKICAgICAgICB9CiAgICAgICAgciA9ICpyZWN0OwogICAgICAgIEluZmxhdGVSZWN0KCAmciwgLTEsIC0xICk7CiAgICAgICAgaWYgKGxwaXRlbS0+ZlN0YXRlICYgTUZfSElMSVRFKSBmbGFncyB8PSBERkNTX1BVU0hFRDsKICAgICAgICBEcmF3RnJhbWVDb250cm9sKCBoZGMsICZyLCBERkNfQ0FQVElPTiwgZmxhZ3MgKTsKICAgICAgICByZXR1cm47CiAgICB9CgogICAgaWYgKCFibXAgfHwgIUdldE9iamVjdFcoIGJtcCwgc2l6ZW9mKGJtKSwgJmJtICkpIHJldHVybjsKCiBnb3RfYml0bWFwOgogICAgaGRjTWVtID0gQ3JlYXRlQ29tcGF0aWJsZURDKCBoZGMgKTsKICAgIFNlbGVjdE9iamVjdCggaGRjTWVtLCBibXAgKTsKCiAgICAvKiBoYW5kbGUgZm9udHNpemUgPiBiaXRtYXBfaGVpZ2h0ICovCiAgICB0b3AgPSAoaD5ibS5ibUhlaWdodCkgPyByZWN0LT50b3ArKGgtYm0uYm1IZWlnaHQpLzIgOiByZWN0LT50b3A7CiAgICBsZWZ0PXJlY3QtPmxlZnQ7CiAgICByb3A9KChscGl0ZW0tPmZTdGF0ZSAmIE1GX0hJTElURSkgJiYgIUlTX01BR0lDX0lURU0oaGJtVG9EcmF3KSkgPyBOT1RTUkNDT1BZIDogU1JDQ09QWTsKICAgIGlmICgobHBpdGVtLT5mU3RhdGUgJiBNRl9ISUxJVEUpICYmIElTX0JJVE1BUF9JVEVNKGxwaXRlbS0+ZlR5cGUpKQogICAgICAgIFNldEJrQ29sb3IoaGRjLCBHZXRTeXNDb2xvcihDT0xPUl9ISUdITElHSFQpKTsKICAgIEJpdEJsdCggaGRjLCBsZWZ0LCB0b3AsIHcsIGgsIGhkY01lbSwgYm1wX3hvZmZzZXQsIDAsIHJvcCApOwogICAgRGVsZXRlREMoIGhkY01lbSApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0NhbGNJdGVtU2l6ZQogKgogKiBDYWxjdWxhdGUgdGhlIHNpemUgb2YgdGhlIG1lbnUgaXRlbSBhbmQgc3RvcmUgaXQgaW4gbHBpdGVtLT5yZWN0LgogKi8Kc3RhdGljIHZvaWQgTUVOVV9DYWxjSXRlbVNpemUoIEhEQyBoZGMsIE1FTlVJVEVNICpscGl0ZW0sIEhXTkQgaHduZE93bmVyLAoJCQkgICAgICAgSU5UIG9yZ1gsIElOVCBvcmdZLCBCT09MIG1lbnVCYXIsIFBPUFVQTUVOVSogbHBwb3AgKQp7CiAgICBXQ0hBUiAqcDsKICAgIFVJTlQgY2hlY2tfYml0bWFwX3dpZHRoID0gR2V0U3lzdGVtTWV0cmljcyggU01fQ1hNRU5VQ0hFQ0sgKTsKCiAgICBUUkFDRSgiZGM9JXAgb3duZXI9JXAgKCVkLCVkKVxuIiwgaGRjLCBod25kT3duZXIsIG9yZ1gsIG9yZ1kpOwogICAgZGVidWdfcHJpbnRfbWVudWl0ZW0oIk1FTlVfQ2FsY0l0ZW1TaXplOiBtZW51aXRlbToiLCBscGl0ZW0sCgkJCSAobWVudUJhciA/ICIgKE1lbnVCYXIpIiA6ICIiKSk7CgogICAgU2V0UmVjdCggJmxwaXRlbS0+cmVjdCwgb3JnWCwgb3JnWSwgb3JnWCwgb3JnWSApOwoKICAgIGlmIChscGl0ZW0tPmZUeXBlICYgTUZfT1dORVJEUkFXKQogICAgewogICAgICAgIC8qCiAgICAgICAgKiogRXhwZXJpbWVudGF0aW9uIHVuZGVyIFdpbmRvd3MgcmV2ZWFscyB0aGF0IGFuIG93bmVyLWRyYXduCiAgICAgICAgKiogbWVudSBpcyBleHBlY3RlZCB0byByZXR1cm4gdGhlIHNpemUgb2YgdGhlIGNvbnRlbnQgcGFydCBvZgogICAgICAgICoqIHRoZSBtZW51IGl0ZW0sIG5vdCBpbmNsdWRpbmcgdGhlIGNoZWNrbWFyayBub3IgdGhlIHN1Ym1lbnUKICAgICAgICAqKiBhcnJvdy4gIFdpbmRvd3MgYWRkcyB0aG9zZSB2YWx1ZXMgaXRzZWxmIGFuZCByZXR1cm5zIHRoZQogICAgICAgICoqIGVubGFyZ2VkIHJlY3RhbmdsZSBvbiBzdWJzZXF1ZW50IFdNX0RSQVdJVEVNIG1lc3NhZ2VzLgogICAgICAgICovCiAgICAgICAgTUVBU1VSRUlURU1TVFJVQ1QgbWlzOwogICAgICAgIG1pcy5DdGxUeXBlICAgID0gT0RUX01FTlU7CiAgICAgICAgbWlzLkN0bElEICAgICAgPSAwOwogICAgICAgIG1pcy5pdGVtSUQgICAgID0gbHBpdGVtLT53SUQ7CiAgICAgICAgbWlzLml0ZW1EYXRhICAgPSAoRFdPUkQpbHBpdGVtLT5kd0l0ZW1EYXRhOwogICAgICAgIG1pcy5pdGVtSGVpZ2h0ID0gMDsKICAgICAgICBtaXMuaXRlbVdpZHRoICA9IDA7CiAgICAgICAgU2VuZE1lc3NhZ2VXKCBod25kT3duZXIsIFdNX01FQVNVUkVJVEVNLCAwLCAoTFBBUkFNKSZtaXMgKTsKICAgICAgICBscGl0ZW0tPnJlY3QucmlnaHQgICs9IG1pcy5pdGVtV2lkdGg7CgogCWlmIChtZW51QmFyKQoJewoJICAgICBscGl0ZW0tPnJlY3QucmlnaHQgKz0gTUVOVV9CQVJfSVRFTVNfU1BBQ0U7CgoKICAgICAgICAgICAgIC8qIHVuZGVyIGF0IGxlYXN0IHdpbjk1IHlvdSBzZWVtIHRvIGJlIGdpdmVuIGEgc3RhbmRhcmQKICAgICAgICAgICAgICAgIGhlaWdodCBmb3IgdGhlIG1lbnUgYW5kIHRoZSBoZWlnaHQgdmFsdWUgaXMgaWdub3JlZCAqLwoJICAgICBscGl0ZW0tPnJlY3QuYm90dG9tICs9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1lNRU5VKS0xOwogICAgICAgIH0KICAgICAgICBlbHNlCiAgICAgICAgICAgIGxwaXRlbS0+cmVjdC5ib3R0b20gKz0gbWlzLml0ZW1IZWlnaHQ7CgoJVFJBQ0UoImlkPSUwNHggc2l6ZT0lZHglZFxuIiwKICAgICAgICAgICAgICAgICAgICAgbHBpdGVtLT53SUQsIG1pcy5pdGVtV2lkdGgsIG1pcy5pdGVtSGVpZ2h0KTsKICAgICAgICAvKiBGYWxsIHRocm91Z2ggdG8gZ2V0IGNoZWNrL2Fycm93IHdpZHRoIGNhbGN1bGF0aW9uLiAqLwogICAgfQoKICAgIGlmIChscGl0ZW0tPmZUeXBlICYgTUZfU0VQQVJBVE9SKQogICAgewoJbHBpdGVtLT5yZWN0LmJvdHRvbSArPSBTRVBBUkFUT1JfSEVJR0hUOwoJcmV0dXJuOwogICAgfQoKICAgIGlmICghbWVudUJhcikKICAgIHsKCS8qIE5ldyBzdHlsZSBNSUlNX0JJVE1BUCAqLwoJaWYgKGxwaXRlbS0+aGJtcEl0ZW0pIAoJewoJICAgIGlmIChscGl0ZW0tPmhibXBJdGVtID09IEhCTU1FTlVfQ0FMTEJBQ0spCgkgICAgewoJCU1FQVNVUkVJVEVNU1RSVUNUIG1lYXNJdGVtOwoJCW1lYXNJdGVtLkN0bFR5cGUgPSBPRFRfTUVOVTsKCQltZWFzSXRlbS5DdGxJRCA9IDA7CgkJbWVhc0l0ZW0uaXRlbUlEID0gbHBpdGVtLT53SUQ7CgkJbWVhc0l0ZW0uaXRlbVdpZHRoID0gbHBpdGVtLT5yZWN0LnJpZ2h0IC0gbHBpdGVtLT5yZWN0LmxlZnQ7CgkJbWVhc0l0ZW0uaXRlbUhlaWdodCA9IGxwaXRlbS0+cmVjdC5ib3R0b20gLSBscGl0ZW0tPnJlY3QudG9wOwoJCW1lYXNJdGVtLml0ZW1EYXRhID0gbHBpdGVtLT5kd0l0ZW1EYXRhOwoJCQoJCVNlbmRNZXNzYWdlVyggaHduZE93bmVyLCBXTV9NRUFTVVJFSVRFTSwgbHBpdGVtLT53SUQsIChMUEFSQU0pJm1lYXNJdGVtKTsKCSAgICAKCQkvKiBLZWVwIHRoZSBzaXplIG9mIHRoZSBiaXRtYXAgaW4gY2FsbGJhY2sgbW9kZSB0byBiZSBhYmxlIHRvIGRyYXcgaXQgY29ycmVjdGx5ICovCgkJbHBwb3AtPm1heEJtcFNpemUuY3ggPSBtYXgobHBwb3AtPm1heEJtcFNpemUuY3gsIG1lYXNJdGVtLml0ZW1XaWR0aCAtIChscGl0ZW0tPnJlY3QucmlnaHQgLSBscGl0ZW0tPnJlY3QubGVmdCkpOwoJCWxwcG9wLT5tYXhCbXBTaXplLmN5ID0gbWF4KGxwcG9wLT5tYXhCbXBTaXplLmN5LCBtZWFzSXRlbS5pdGVtSGVpZ2h0IC0gKGxwaXRlbS0+cmVjdC5ib3R0b20gLSBscGl0ZW0tPnJlY3QudG9wKSk7CgkJbHBpdGVtLT5yZWN0LnJpZ2h0ID0gbHBpdGVtLT5yZWN0LmxlZnQgKyBtZWFzSXRlbS5pdGVtV2lkdGg7CgkgICAgfSBlbHNlIHsKCQlTSVpFIHNpemU7CgkJTUVOVV9HZXRCaXRtYXBJdGVtU2l6ZSgoVUlOVClscGl0ZW0tPmhibXBJdGVtLCBscGl0ZW0tPmR3SXRlbURhdGEsICZzaXplKTsKCQlscHBvcC0+bWF4Qm1wU2l6ZS5jeCA9IG1heChscHBvcC0+bWF4Qm1wU2l6ZS5jeCwgc2l6ZS5jeCk7CgkJbHBwb3AtPm1heEJtcFNpemUuY3kgPSBtYXgobHBwb3AtPm1heEJtcFNpemUuY3ksIHNpemUuY3kpOwoJCWxwaXRlbS0+cmVjdC5yaWdodCAgKz0gc2l6ZS5jeDsKCQlscGl0ZW0tPnJlY3QuYm90dG9tICs9IHNpemUuY3k7CgkgICAgfQoJICAgIGlmIChscHBvcC0+ZHdTdHlsZSAmIE1OU19DSEVDS09SQk1QKSAKCQlscGl0ZW0tPnJlY3QucmlnaHQgKz0gY2hlY2tfYml0bWFwX3dpZHRoOwoJICAgIGVsc2UKCQlscGl0ZW0tPnJlY3QucmlnaHQgKz0gMiAqIGNoZWNrX2JpdG1hcF93aWR0aDsKCX0gZWxzZQoJICAgIGxwaXRlbS0+cmVjdC5yaWdodCArPSAyICogY2hlY2tfYml0bWFwX3dpZHRoOwoJaWYgKGxwaXRlbS0+ZlR5cGUgJiBNRl9QT1BVUCkKCSAgICBscGl0ZW0tPnJlY3QucmlnaHQgKz0gYXJyb3dfYml0bWFwX3dpZHRoOwogICAgfQoKICAgIGlmIChscGl0ZW0tPmZUeXBlICYgTUZfT1dORVJEUkFXKQogICAgICAgIHJldHVybjsKCiAgICBpZiAoSVNfQklUTUFQX0lURU0obHBpdGVtLT5mVHlwZSkpCiAgICB7CiAgICAgICAgU0laRSBzaXplOwoKICAgICAgICBNRU5VX0dldEJpdG1hcEl0ZW1TaXplKCAoaW50KWxwaXRlbS0+dGV4dCwgbHBpdGVtLT5kd0l0ZW1EYXRhLCAmc2l6ZSApOwogICAgICAgIGxwaXRlbS0+cmVjdC5yaWdodCAgKz0gc2l6ZS5jeDsKICAgICAgICBscGl0ZW0tPnJlY3QuYm90dG9tICs9IHNpemUuY3k7CiAgICAgICAgLyogTGVhdmUgc3BhY2UgZm9yIHRoZSBzdW5rZW4gYm9yZGVyICovCiAgICAgICAgbHBpdGVtLT5yZWN0LnJpZ2h0ICArPSAyOwogICAgICAgIGxwaXRlbS0+cmVjdC5ib3R0b20gKz0gMjsKICAgIH0KCgogICAgLyogaXQgbXVzdCBiZSBhIHRleHQgaXRlbSAtIHVubGVzcyBpdCdzIHRoZSBzeXN0ZW0gbWVudSAqLwogICAgaWYgKCEobHBpdGVtLT5mVHlwZSAmIE1GX1NZU01FTlUpICYmIElTX1NUUklOR19JVEVNKCBscGl0ZW0tPmZUeXBlICkpCiAgICB7ICAgU0laRSBzaXplOwoKCUdldFRleHRFeHRlbnRQb2ludDMyVyhoZGMsIGxwaXRlbS0+dGV4dCwgIHN0cmxlblcobHBpdGVtLT50ZXh0KSwgJnNpemUpOwoKCWxwaXRlbS0+cmVjdC5yaWdodCAgKz0gc2l6ZS5jeDsKCWxwaXRlbS0+cmVjdC5ib3R0b20gKz0gbWF4KG1heChzaXplLmN5LCBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZTUVOVSktMSksIGxwcG9wLT5tYXhCbXBTaXplLmN5KTsKCWxwaXRlbS0+eFRhYiA9IDA7CgoJaWYgKG1lbnVCYXIpCgl7CgkgICAgIGxwaXRlbS0+cmVjdC5yaWdodCArPSBNRU5VX0JBUl9JVEVNU19TUEFDRTsKCX0KCWVsc2UgaWYgKChwID0gc3RyY2hyVyggbHBpdGVtLT50ZXh0LCAnXHQnICkpICE9IE5VTEwpCgl7CgkgICAgLyogSXRlbSBjb250YWlucyBhIHRhYiAob25seSBtZWFuaW5nZnVsIGluIHBvcHVwIG1lbnVzKSAqLwoJICAgIEdldFRleHRFeHRlbnRQb2ludDMyVyhoZGMsIGxwaXRlbS0+dGV4dCwgKGludCkocCAtIGxwaXRlbS0+dGV4dCkgLCAmc2l6ZSk7CgkgICAgbHBpdGVtLT54VGFiID0gY2hlY2tfYml0bWFwX3dpZHRoICsgTUVOVV9UQUJfU1BBQ0UgKyBzaXplLmN4OwoJICAgIGxwaXRlbS0+cmVjdC5yaWdodCArPSBNRU5VX1RBQl9TUEFDRTsKCX0KCWVsc2UKCXsKCSAgICBpZiAoc3RyY2hyVyggbHBpdGVtLT50ZXh0LCAnXGInICkpCgkgICAgICAgIGxwaXRlbS0+cmVjdC5yaWdodCArPSBNRU5VX1RBQl9TUEFDRTsKCSAgICBscGl0ZW0tPnhUYWIgPSBscGl0ZW0tPnJlY3QucmlnaHQgLSBjaGVja19iaXRtYXBfd2lkdGgKCSAgICAgICAgICAgICAgICAgICAtIGFycm93X2JpdG1hcF93aWR0aDsKCX0KICAgIH0KICAgIFRSQUNFKCIoJWxkLCVsZCktKCVsZCwlbGQpXG4iLCBscGl0ZW0tPnJlY3QubGVmdCwgbHBpdGVtLT5yZWN0LnRvcCwgbHBpdGVtLT5yZWN0LnJpZ2h0LCBscGl0ZW0tPnJlY3QuYm90dG9tKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9Qb3B1cE1lbnVDYWxjU2l6ZQogKgogKiBDYWxjdWxhdGUgdGhlIHNpemUgb2YgYSBwb3B1cCBtZW51LgogKi8Kc3RhdGljIHZvaWQgTUVOVV9Qb3B1cE1lbnVDYWxjU2l6ZSggTFBQT1BVUE1FTlUgbHBwb3AsIEhXTkQgaHduZE93bmVyICkKewogICAgTUVOVUlURU0gKmxwaXRlbTsKICAgIEhEQyBoZGM7CiAgICBpbnQgc3RhcnQsIGk7CiAgICBpbnQgb3JnWCwgb3JnWSwgbWF4WCwgbWF4VGFiLCBtYXhUYWJXaWR0aDsKCiAgICBscHBvcC0+V2lkdGggPSBscHBvcC0+SGVpZ2h0ID0gMDsKICAgIGlmIChscHBvcC0+bkl0ZW1zID09IDApIHJldHVybjsKICAgIGhkYyA9IEdldERDKCAwICk7CgogICAgU2VsZWN0T2JqZWN0KCBoZGMsIGhNZW51Rm9udCk7CgogICAgc3RhcnQgPSAwOwogICAgbWF4WCA9IDIgKyAxOwoKICAgIGxwcG9wLT5tYXhCbXBTaXplLmN4ID0gMDsKICAgIGxwcG9wLT5tYXhCbXBTaXplLmN5ID0gMDsKCiAgICB3aGlsZSAoc3RhcnQgPCBscHBvcC0+bkl0ZW1zKQogICAgewoJbHBpdGVtID0gJmxwcG9wLT5pdGVtc1tzdGFydF07CglvcmdYID0gbWF4WDsKCW9yZ1kgPSAzOwoKCW1heFRhYiA9IG1heFRhYldpZHRoID0gMDsKCSAgLyogUGFyc2UgaXRlbXMgdW50aWwgY29sdW1uIGJyZWFrIG9yIGVuZCBvZiBtZW51ICovCglmb3IgKGkgPSBzdGFydDsgaSA8IGxwcG9wLT5uSXRlbXM7IGkrKywgbHBpdGVtKyspCgl7CgkgICAgaWYgKChpICE9IHN0YXJ0KSAmJgoJCShscGl0ZW0tPmZUeXBlICYgKE1GX01FTlVCUkVBSyB8IE1GX01FTlVCQVJCUkVBSykpKSBicmVhazsKCgkgICAgTUVOVV9DYWxjSXRlbVNpemUoIGhkYywgbHBpdGVtLCBod25kT3duZXIsIG9yZ1gsIG9yZ1ksIEZBTFNFLCBscHBvcCApOwoKCSAgICBpZiAobHBpdGVtLT5mVHlwZSAmIE1GX01FTlVCQVJCUkVBSykgb3JnWCsrOwoJICAgIG1heFggPSBtYXgoIG1heFgsIGxwaXRlbS0+cmVjdC5yaWdodCApOwoJICAgIG9yZ1kgPSBscGl0ZW0tPnJlY3QuYm90dG9tOwoJICAgIGlmIChJU19TVFJJTkdfSVRFTShscGl0ZW0tPmZUeXBlKSAmJiBscGl0ZW0tPnhUYWIpCgkgICAgewoJCW1heFRhYiA9IG1heCggbWF4VGFiLCBscGl0ZW0tPnhUYWIgKTsKCQltYXhUYWJXaWR0aCA9IG1heChtYXhUYWJXaWR0aCxscGl0ZW0tPnJlY3QucmlnaHQtbHBpdGVtLT54VGFiKTsKCSAgICB9Cgl9CgoJICAvKiBGaW5pc2ggdGhlIGNvbHVtbiAoc2V0IGFsbCBpdGVtcyB0byB0aGUgbGFyZ2VzdCB3aWR0aCBmb3VuZCkgKi8KCW1heFggPSBtYXgoIG1heFgsIG1heFRhYiArIG1heFRhYldpZHRoICk7Cglmb3IgKGxwaXRlbSA9ICZscHBvcC0+aXRlbXNbc3RhcnRdOyBzdGFydCA8IGk7IHN0YXJ0KyssIGxwaXRlbSsrKQoJewoJICAgIGxwaXRlbS0+cmVjdC5yaWdodCA9IG1heFg7CgkgICAgaWYgKElTX1NUUklOR19JVEVNKGxwaXRlbS0+ZlR5cGUpICYmIGxwaXRlbS0+eFRhYikKCQlscGl0ZW0tPnhUYWIgPSBtYXhUYWI7CgoJfQoJbHBwb3AtPkhlaWdodCA9IG1heCggbHBwb3AtPkhlaWdodCwgb3JnWSApOwogICAgfQoKICAgIGxwcG9wLT5XaWR0aCAgPSBtYXhYOwoKICAgIC8qIHNwYWNlIGZvciAzZCBib3JkZXIgKi8KICAgIGxwcG9wLT5IZWlnaHQgKz0gMjsKICAgIGxwcG9wLT5XaWR0aCArPSAyOwoKICAgIFJlbGVhc2VEQyggMCwgaGRjICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfTWVudUJhckNhbGNTaXplCiAqCiAqIEZJWE1FOiBXb3JkIDYgaW1wbGVtZW50cyBpdHMgb3duIE1ESSBhbmQgaXRzIG93biAnY2xvc2Ugd2luZG93JyBiaXRtYXAKICogaGVpZ2h0IGlzIG9mZiBieSAxIHBpeGVsIHdoaWNoIGNhdXNlcyBsZW5ndGh5IHdpbmRvdyByZWxvY2F0aW9ucyB3aGVuCiAqIGFjdGl2ZSBkb2N1bWVudCB3aW5kb3cgaXMgbWF4aW1pemVkL3Jlc3RvcmVkLgogKgogKiBDYWxjdWxhdGUgdGhlIHNpemUgb2YgdGhlIG1lbnUgYmFyLgogKi8Kc3RhdGljIHZvaWQgTUVOVV9NZW51QmFyQ2FsY1NpemUoIEhEQyBoZGMsIExQUkVDVCBscHJlY3QsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBMUFBPUFVQTUVOVSBscHBvcCwgSFdORCBod25kT3duZXIgKQp7CiAgICBNRU5VSVRFTSAqbHBpdGVtOwogICAgaW50IHN0YXJ0LCBpLCBvcmdYLCBvcmdZLCBtYXhZLCBoZWxwUG9zOwoKICAgIGlmICgobHByZWN0ID09IE5VTEwpIHx8IChscHBvcCA9PSBOVUxMKSkgcmV0dXJuOwogICAgaWYgKGxwcG9wLT5uSXRlbXMgPT0gMCkgcmV0dXJuOwogICAgVFJBQ0UoImxlZnQ9JWxkIHRvcD0lbGQgcmlnaHQ9JWxkIGJvdHRvbT0lbGRcbiIsCiAgICAgICAgICBscHJlY3QtPmxlZnQsIGxwcmVjdC0+dG9wLCBscHJlY3QtPnJpZ2h0LCBscHJlY3QtPmJvdHRvbSk7CiAgICBscHBvcC0+V2lkdGggID0gbHByZWN0LT5yaWdodCAtIGxwcmVjdC0+bGVmdDsKICAgIGxwcG9wLT5IZWlnaHQgPSAwOwogICAgbWF4WSA9IGxwcmVjdC0+dG9wKzE7CiAgICBzdGFydCA9IDA7CiAgICBoZWxwUG9zID0gLTE7CiAgICBscHBvcC0+bWF4Qm1wU2l6ZS5jeCA9IDA7CiAgICBscHBvcC0+bWF4Qm1wU2l6ZS5jeSA9IDA7CiAgICB3aGlsZSAoc3RhcnQgPCBscHBvcC0+bkl0ZW1zKQogICAgewoJbHBpdGVtID0gJmxwcG9wLT5pdGVtc1tzdGFydF07CglvcmdYID0gbHByZWN0LT5sZWZ0OwoJb3JnWSA9IG1heFk7CgoJICAvKiBQYXJzZSBpdGVtcyB1bnRpbCBsaW5lIGJyZWFrIG9yIGVuZCBvZiBtZW51ICovCglmb3IgKGkgPSBzdGFydDsgaSA8IGxwcG9wLT5uSXRlbXM7IGkrKywgbHBpdGVtKyspCgl7CgkgICAgaWYgKChoZWxwUG9zID09IC0xKSAmJiAobHBpdGVtLT5mVHlwZSAmIE1GX1JJR0hUSlVTVElGWSkpIGhlbHBQb3MgPSBpOwoJICAgIGlmICgoaSAhPSBzdGFydCkgJiYKCQkobHBpdGVtLT5mVHlwZSAmIChNRl9NRU5VQlJFQUsgfCBNRl9NRU5VQkFSQlJFQUspKSkgYnJlYWs7CgoJICAgIFRSQUNFKCJjYWxsaW5nIE1FTlVfQ2FsY0l0ZW1TaXplIG9yZz0oJWQsICVkKVxuIiwKCQkJIG9yZ1gsIG9yZ1kgKTsKCSAgICBkZWJ1Z19wcmludF9tZW51aXRlbSAoIiAgaXRlbTogIiwgbHBpdGVtLCAiIik7CgkgICAgTUVOVV9DYWxjSXRlbVNpemUoIGhkYywgbHBpdGVtLCBod25kT3duZXIsIG9yZ1gsIG9yZ1ksIFRSVUUsIGxwcG9wICk7CgoJICAgIGlmIChscGl0ZW0tPnJlY3QucmlnaHQgPiBscHJlY3QtPnJpZ2h0KQoJICAgIHsKCQlpZiAoaSAhPSBzdGFydCkgYnJlYWs7CgkJZWxzZSBscGl0ZW0tPnJlY3QucmlnaHQgPSBscHJlY3QtPnJpZ2h0OwoJICAgIH0KCSAgICBtYXhZID0gbWF4KCBtYXhZLCBscGl0ZW0tPnJlY3QuYm90dG9tICk7CgkgICAgb3JnWCA9IGxwaXRlbS0+cmVjdC5yaWdodDsKCX0KCgkgIC8qIEZpbmlzaCB0aGUgbGluZSAoc2V0IGFsbCBpdGVtcyB0byB0aGUgbGFyZ2VzdCBoZWlnaHQgZm91bmQpICovCgl3aGlsZSAoc3RhcnQgPCBpKSBscHBvcC0+aXRlbXNbc3RhcnQrK10ucmVjdC5ib3R0b20gPSBtYXhZOwogICAgfQoKICAgIGxwcmVjdC0+Ym90dG9tID0gbWF4WTsKICAgIGxwcG9wLT5IZWlnaHQgPSBscHJlY3QtPmJvdHRvbSAtIGxwcmVjdC0+dG9wOwoKICAgIC8qIEZsdXNoIHJpZ2h0IGFsbCBpdGVtcyBiZXR3ZWVuIHRoZSBNRl9SSUdIVEpVU1RJRlkgYW5kICovCiAgICAvKiB0aGUgbGFzdCBpdGVtIChpZiBzZXZlcmFsIGxpbmVzLCBvbmx5IG1vdmUgdGhlIGxhc3QgbGluZSkgKi8KICAgIGxwaXRlbSA9ICZscHBvcC0+aXRlbXNbbHBwb3AtPm5JdGVtcy0xXTsKICAgIG9yZ1kgPSBscGl0ZW0tPnJlY3QudG9wOwogICAgb3JnWCA9IGxwcmVjdC0+cmlnaHQ7CiAgICBmb3IgKGkgPSBscHBvcC0+bkl0ZW1zIC0gMTsgaSA+PSBoZWxwUG9zOyBpLS0sIGxwaXRlbS0tKSB7CiAgICAgICAgaWYgKCAoaGVscFBvcz09LTEpIHx8IChoZWxwUG9zPmkpICkKICAgICAgICAgICAgYnJlYWs7CQkJCS8qIGRvbmUgKi8KICAgICAgICBpZiAobHBpdGVtLT5yZWN0LnRvcCAhPSBvcmdZKSBicmVhazsJLyogT3RoZXIgbGluZSAqLwogICAgICAgIGlmIChscGl0ZW0tPnJlY3QucmlnaHQgPj0gb3JnWCkgYnJlYWs7CS8qIFRvbyBmYXIgcmlnaHQgYWxyZWFkeSAqLwogICAgICAgIGxwaXRlbS0+cmVjdC5sZWZ0ICs9IG9yZ1ggLSBscGl0ZW0tPnJlY3QucmlnaHQ7CiAgICAgICAgbHBpdGVtLT5yZWN0LnJpZ2h0ID0gb3JnWDsKICAgICAgICBvcmdYID0gbHBpdGVtLT5yZWN0LmxlZnQ7CiAgICB9Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9EcmF3TWVudUl0ZW0KICoKICogRHJhdyBhIHNpbmdsZSBtZW51IGl0ZW0uCiAqLwpzdGF0aWMgdm9pZCBNRU5VX0RyYXdNZW51SXRlbSggSFdORCBod25kLCBITUVOVSBobWVudSwgSFdORCBod25kT3duZXIsIEhEQyBoZGMsIE1FTlVJVEVNICpscGl0ZW0sCgkJCSAgICAgICBVSU5UIGhlaWdodCwgQk9PTCBtZW51QmFyLCBVSU5UIG9kYWN0aW9uICkKewogICAgUkVDVCByZWN0OwoKICAgIGRlYnVnX3ByaW50X21lbnVpdGVtKCJNRU5VX0RyYXdNZW51SXRlbTogIiwgbHBpdGVtLCAiIik7CgogICAgaWYgKGxwaXRlbS0+ZlR5cGUgJiBNRl9TWVNNRU5VKQogICAgewoJaWYoICFJc0ljb25pYyhod25kKSApCgkgICAgTkNfRHJhd1N5c0J1dHRvbiggaHduZCwgaGRjLCBscGl0ZW0tPmZTdGF0ZSAmIChNRl9ISUxJVEUgfCBNRl9NT1VTRVNFTEVDVCkgKTsKCXJldHVybjsKICAgIH0KCiAgICAgIC8qIFNldHVwIGNvbG9ycyAqLwoKICAgIGlmIChscGl0ZW0tPmZTdGF0ZSAmIE1GX0hJTElURSkKICAgIHsKICAgICAgICBpZihtZW51QmFyKSB7CgkgICAgU2V0VGV4dENvbG9yKGhkYywgR2V0U3lzQ29sb3IoQ09MT1JfTUVOVVRFWFQpKTsKICAgICAgICAgICAgU2V0QmtDb2xvcihoZGMsIEdldFN5c0NvbG9yKENPTE9SX01FTlUpKTsKCX0gZWxzZSB7CgkgICAgaWYobHBpdGVtLT5mU3RhdGUgJiBNRl9HUkFZRUQpCgkJU2V0VGV4dENvbG9yKGhkYywgR2V0U3lzQ29sb3IoQ09MT1JfR1JBWVRFWFQpKTsKCSAgICBlbHNlCgkJU2V0VGV4dENvbG9yKGhkYywgR2V0U3lzQ29sb3IoQ09MT1JfSElHSExJR0hUVEVYVCkpOwogICAgICAgICAgICBTZXRCa0NvbG9yKGhkYywgR2V0U3lzQ29sb3IoQ09MT1JfSElHSExJR0hUKSk7Cgl9CiAgICB9CiAgICBlbHNlCiAgICB7CglpZiAobHBpdGVtLT5mU3RhdGUgJiBNRl9HUkFZRUQpCgkgICAgU2V0VGV4dENvbG9yKCBoZGMsIEdldFN5c0NvbG9yKCBDT0xPUl9HUkFZVEVYVCApICk7CgllbHNlCgkgICAgU2V0VGV4dENvbG9yKCBoZGMsIEdldFN5c0NvbG9yKCBDT0xPUl9NRU5VVEVYVCApICk7CglTZXRCa0NvbG9yKCBoZGMsIEdldFN5c0NvbG9yKCBDT0xPUl9NRU5VICkgKTsKICAgIH0KCiAgICBpZiAobHBpdGVtLT5mVHlwZSAmIE1GX09XTkVSRFJBVykKICAgIHsKICAgICAgICAvKgogICAgICAgICoqIEV4cGVyaW1lbnRhdGlvbiB1bmRlciBXaW5kb3dzIHJldmVhbHMgdGhhdCBhbiBvd25lci1kcmF3bgogICAgICAgICoqIG1lbnUgaXMgZ2l2ZW4gdGhlIHJlY3RhbmdsZSB3aGljaCBpbmNsdWRlcyB0aGUgc3BhY2UgaXQgcmVxdWVzdGVkCiAgICAgICAgKiogaW4gaXRzIHJlc3BvbnNlIHRvIFdNX01FQVNVUkVJVEVNIF9wbHVzXyB3aWR0aCBmb3IgYSBjaGVja21hcmsKICAgICAgICAqKiBhbmQgYSBwb3B1cC1tZW51IGFycm93LiAgVGhpcyBpcyB0aGUgdmFsdWUgb2YgbHBpdGVtLT5yZWN0LgogICAgICAgICoqIFdpbmRvd3Mgd2lsbCBsZWF2ZSBhbGwgZHJhd2luZyB0byB0aGUgYXBwbGljYXRpb24gZXhjZXB0IGZvcgogICAgICAgICoqIHRoZSBwb3B1cC1tZW51IGFycm93LiAgV2luZG93cyBhbHdheXMgZHJhd3MgdGhhdCBpdHNlbGYsIGFmdGVyCiAgICAgICAgKiogdGhlIG1lbnUgb3duZXIgaGFzIGZpbmlzaGVkIGRyYXdpbmcuCiAgICAgICAgKi8KICAgICAgICBEUkFXSVRFTVNUUlVDVCBkaXM7CgogICAgICAgIGRpcy5DdGxUeXBlICAgPSBPRFRfTUVOVTsKCWRpcy5DdGxJRCAgICAgPSAwOwogICAgICAgIGRpcy5pdGVtSUQgICAgPSBscGl0ZW0tPndJRDsKICAgICAgICBkaXMuaXRlbURhdGEgID0gKERXT1JEKWxwaXRlbS0+ZHdJdGVtRGF0YTsKICAgICAgICBkaXMuaXRlbVN0YXRlID0gMDsKICAgICAgICBpZiAobHBpdGVtLT5mU3RhdGUgJiBNRl9DSEVDS0VEKSBkaXMuaXRlbVN0YXRlIHw9IE9EU19DSEVDS0VEOwogICAgICAgIGlmIChscGl0ZW0tPmZTdGF0ZSAmIE1GX0dSQVlFRCkgIGRpcy5pdGVtU3RhdGUgfD0gT0RTX0dSQVlFRHxPRFNfRElTQUJMRUQ7CiAgICAgICAgaWYgKGxwaXRlbS0+ZlN0YXRlICYgTUZfSElMSVRFKSAgZGlzLml0ZW1TdGF0ZSB8PSBPRFNfU0VMRUNURUQ7CiAgICAgICAgZGlzLml0ZW1BY3Rpb24gPSBvZGFjdGlvbjsgLyogT0RBX0RSQVdFTlRJUkUgfCBPREFfU0VMRUNUIHwgT0RBX0ZPQ1VTOyAqLwogICAgICAgIGRpcy5od25kSXRlbSAgID0gKEhXTkQpaG1lbnU7CiAgICAgICAgZGlzLmhEQyAgICAgICAgPSBoZGM7CiAgICAgICAgZGlzLnJjSXRlbSAgICAgPSBscGl0ZW0tPnJlY3Q7CiAgICAgICAgVFJBQ0UoIk93bmVyZHJhdzogb3duZXI9JXAgaXRlbUlEPSVkLCBpdGVtU3RhdGU9JWQsIGl0ZW1BY3Rpb249JWQsICIKCSAgICAgICJod25kSXRlbT0lcCwgaGRjPSVwLCByY0l0ZW09eyVsZCwlbGQsJWxkLCVsZH1cbiIsIGh3bmRPd25lciwKCSAgICAgIGRpcy5pdGVtSUQsIGRpcy5pdGVtU3RhdGUsIGRpcy5pdGVtQWN0aW9uLCBkaXMuaHduZEl0ZW0sCgkgICAgICBkaXMuaERDLCBkaXMucmNJdGVtLmxlZnQsIGRpcy5yY0l0ZW0udG9wLCBkaXMucmNJdGVtLnJpZ2h0LAoJICAgICAgZGlzLnJjSXRlbS5ib3R0b20pOwogICAgICAgIFNlbmRNZXNzYWdlVyggaHduZE93bmVyLCBXTV9EUkFXSVRFTSwgMCwgKExQQVJBTSkmZGlzICk7CiAgICAgICAgLyogRmFsbCB0aHJvdWdoIHRvIGRyYXcgcG9wdXAtbWVudSBhcnJvdyAqLwogICAgfQoKICAgIFRSQUNFKCJyZWN0PXslbGQsJWxkLCVsZCwlbGR9XG4iLCBscGl0ZW0tPnJlY3QubGVmdCwgbHBpdGVtLT5yZWN0LnRvcCwKCQkJCQlscGl0ZW0tPnJlY3QucmlnaHQsbHBpdGVtLT5yZWN0LmJvdHRvbSk7CgogICAgaWYgKG1lbnVCYXIgJiYgKGxwaXRlbS0+ZlR5cGUgJiBNRl9TRVBBUkFUT1IpKSByZXR1cm47CgogICAgcmVjdCA9IGxwaXRlbS0+cmVjdDsKCiAgICBpZiAoIShscGl0ZW0tPmZUeXBlICYgTUZfT1dORVJEUkFXKSkKICAgIHsKCWlmIChscGl0ZW0tPmZTdGF0ZSAmIE1GX0hJTElURSkKCXsKCSAgICAgaWYobWVudUJhcikKCQlEcmF3RWRnZShoZGMsICZyZWN0LCBCRFJfU1VOS0VOT1VURVIsIEJGX1JFQ1QpOwoJICAgICBlbHNlCgkJRmlsbFJlY3QoaGRjLCAmcmVjdCwgR2V0U3lzQ29sb3JCcnVzaChDT0xPUl9ISUdITElHSFQpKTsKCX0KICAgICAgICBlbHNlCgkgICAgRmlsbFJlY3QoIGhkYywgJnJlY3QsIEdldFN5c0NvbG9yQnJ1c2goQ09MT1JfTUVOVSkgKTsKICAgIH0KCiAgICBTZXRCa01vZGUoIGhkYywgVFJBTlNQQVJFTlQgKTsKCiAgICBpZiAoIShscGl0ZW0tPmZUeXBlICYgTUZfT1dORVJEUkFXKSkKICAgIHsKICAgICAgICAvKiB2ZXJ0aWNhbCBzZXBhcmF0b3IgKi8KICAgICAgICBpZiAoIW1lbnVCYXIgJiYgKGxwaXRlbS0+ZlR5cGUgJiBNRl9NRU5VQkFSQlJFQUspKQogICAgICAgIHsKCSAgICBSRUNUIHJjID0gcmVjdDsKCSAgICByYy50b3AgPSAzOwoJICAgIHJjLmJvdHRvbSA9IGhlaWdodCAtIDM7CgkgICAgRHJhd0VkZ2UgKGhkYywgJnJjLCBFREdFX0VUQ0hFRCwgQkZfTEVGVCk7CiAgICAgICAgfQoKICAgICAgICAvKiBob3Jpem9udGFsIHNlcGFyYXRvciAqLwogICAgICAgIGlmIChscGl0ZW0tPmZUeXBlICYgTUZfU0VQQVJBVE9SKQogICAgICAgIHsKCSAgICBSRUNUIHJjID0gcmVjdDsKCSAgICByYy5sZWZ0Kys7CgkgICAgcmMucmlnaHQtLTsKCSAgICByYy50b3AgKz0gU0VQQVJBVE9SX0hFSUdIVCAvIDI7CgkgICAgRHJhd0VkZ2UgKGhkYywgJnJjLCBFREdFX0VUQ0hFRCwgQkZfVE9QKTsKCSAgICByZXR1cm47CiAgICAgICAgfQogICAgfQoKCS8qIGhlbHBlciBsaW5lcyBmb3IgZGVidWdnaW5nICovCi8qCUZyYW1lUmVjdChoZGMsICZyZWN0LCBHZXRTdG9ja09iamVjdChCTEFDS19CUlVTSCkpOwoJU2VsZWN0T2JqZWN0KCBoZGMsIFNZU0NPTE9SX0dldFBlbihDT0xPUl9XSU5ET1dGUkFNRSkgKTsKCU1vdmVUb0V4KCBoZGMsIHJlY3QubGVmdCwgKHJlY3QudG9wICsgcmVjdC5ib3R0b20pLzIsIE5VTEwgKTsKCUxpbmVUbyggaGRjLCByZWN0LnJpZ2h0LCAocmVjdC50b3AgKyByZWN0LmJvdHRvbSkvMiApOwoqLwoKICAgIGlmICghbWVudUJhcikKICAgIHsKICAgICAgICBIQklUTUFQIGJtOwogICAgICAgIElOVCB5ID0gcmVjdC50b3AgKyByZWN0LmJvdHRvbTsKICAgICAgICBVSU5UIGNoZWNrX2JpdG1hcF93aWR0aCA9IEdldFN5c3RlbU1ldHJpY3MoIFNNX0NYTUVOVUNIRUNLICk7CiAgICAgICAgVUlOVCBjaGVja19iaXRtYXBfaGVpZ2h0ID0gR2V0U3lzdGVtTWV0cmljcyggU01fQ1lNRU5VQ0hFQ0sgKTsKCiAgICAgICAgaWYgKCEobHBpdGVtLT5mVHlwZSAmIE1GX09XTkVSRFJBVykpCiAgICAgICAgewogICAgICAgICAgICAvKiBOZXcgc3R5bGUgTUlJTV9CSVRNQVAgKi8KICAgICAgICAgICAgaWYgKGxwaXRlbS0+aGJtcEl0ZW0pCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIFBPUFVQTUVOVSAqbWVudSA9IE1FTlVfR2V0TWVudShobWVudSk7CiAgICAgICAgICAgICAgICBIQklUTUFQIGhibSA9IGxwaXRlbS0+aGJtcEl0ZW07CgogICAgICAgICAgICAgICAgaWYgKGhibSA9PSBIQk1NRU5VX0NBTExCQUNLKQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIERSQVdJVEVNU1RSVUNUIGRyYXdJdGVtOwogICAgICAgICAgICAgICAgICAgIGRyYXdJdGVtLkN0bFR5cGUgPSBPRFRfTUVOVTsKICAgICAgICAgICAgICAgICAgICBkcmF3SXRlbS5DdGxJRCA9IDA7CiAgICAgICAgICAgICAgICAgICAgZHJhd0l0ZW0uaXRlbUlEID0gbHBpdGVtLT53SUQ7CiAgICAgICAgICAgICAgICAgICAgZHJhd0l0ZW0uaXRlbUFjdGlvbiA9IG9kYWN0aW9uOwogICAgICAgICAgICAgICAgICAgIGRyYXdJdGVtLml0ZW1TdGF0ZSB8PSAobHBpdGVtLT5mU3RhdGUgJiBNRl9DSEVDS0VEKT9PRFNfQ0hFQ0tFRDowOwogICAgICAgICAgICAgICAgICAgIGRyYXdJdGVtLml0ZW1TdGF0ZSB8PSAobHBpdGVtLT5mU3RhdGUgJiBNRl9ERUZBVUxUKT9PRFNfREVGQVVMVDowOwogICAgICAgICAgICAgICAgICAgIGRyYXdJdGVtLml0ZW1TdGF0ZSB8PSAobHBpdGVtLT5mU3RhdGUgJiBNRl9ESVNBQkxFRCk/T0RTX0RJU0FCTEVEOjA7CiAgICAgICAgICAgICAgICAgICAgZHJhd0l0ZW0uaXRlbVN0YXRlIHw9IChscGl0ZW0tPmZTdGF0ZSAmIE1GX0dSQVlFRCk/T0RTX0dSQVlFRHxPRFNfRElTQUJMRUQ6MDsKICAgICAgICAgICAgICAgICAgICBkcmF3SXRlbS5pdGVtU3RhdGUgfD0gKGxwaXRlbS0+ZlN0YXRlICYgTUZfSElMSVRFKT9PRFNfU0VMRUNURUQ6MDsKICAgICAgICAgICAgICAgICAgICBkcmF3SXRlbS5od25kSXRlbSA9IChIV05EKWhtZW51OwogICAgICAgICAgICAgICAgICAgIGRyYXdJdGVtLmhEQyA9IGhkYzsKICAgICAgICAgICAgICAgICAgICBkcmF3SXRlbS5yY0l0ZW0gPSBscGl0ZW0tPnJlY3Q7CiAgICAgICAgICAgICAgICAgICAgZHJhd0l0ZW0uaXRlbURhdGEgPSBscGl0ZW0tPmR3SXRlbURhdGE7CgogICAgICAgICAgICAgICAgICAgIGlmICghKGxwaXRlbS0+ZlN0YXRlICYgTUZfQ0hFQ0tFRCkpCiAgICAgICAgICAgICAgICAgICAgICAgIFNlbmRNZXNzYWdlVyggaHduZE93bmVyLCBXTV9EUkFXSVRFTSwgMCwgKExQQVJBTSkmZHJhd0l0ZW0pOwoKICAgICAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICAgICAgTUVOVV9EcmF3Qml0bWFwSXRlbShoZGMsIGxwaXRlbSwgJnJlY3QsIEZBTFNFLCBUUlVFKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIGlmIChtZW51LT5kd1N0eWxlICYgTU5TX0NIRUNLT1JCTVApCiAgICAgICAgICAgICAgICAgICAgcmVjdC5sZWZ0ICs9IG1lbnUtPm1heEJtcFNpemUuY3ggLSBjaGVja19iaXRtYXBfd2lkdGg7CiAgICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICAgICAgcmVjdC5sZWZ0ICs9IG1lbnUtPm1heEJtcFNpemUuY3g7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgLyogRHJhdyB0aGUgY2hlY2sgbWFyawogICAgICAgICAgICAgKgogICAgICAgICAgICAgKiBGSVhNRToKICAgICAgICAgICAgICogQ3VzdG9tIGNoZWNrbWFyayBiaXRtYXBzIGFyZSBtb25vY2hyb21lIGJ1dCBub3QgYWx3YXlzIDFicHAuCiAgICAgICAgICAgICAqLwogICAgICAgICAgICBibSA9IChscGl0ZW0tPmZTdGF0ZSAmIE1GX0NIRUNLRUQpID8gbHBpdGVtLT5oQ2hlY2tCaXQgOiBscGl0ZW0tPmhVbkNoZWNrQml0OwogICAgICAgICAgICBpZiAoYm0pICAvKiB3ZSBoYXZlIGEgY3VzdG9tIGJpdG1hcCAqLwogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBIREMgaGRjTWVtID0gQ3JlYXRlQ29tcGF0aWJsZURDKCBoZGMgKTsKICAgICAgICAgICAgICAgIFNlbGVjdE9iamVjdCggaGRjTWVtLCBibSApOwogICAgICAgICAgICAgICAgQml0Qmx0KCBoZGMsIHJlY3QubGVmdCwgKHkgLSBjaGVja19iaXRtYXBfaGVpZ2h0KSAvIDIsCiAgICAgICAgICAgICAgICAgICAgICAgIGNoZWNrX2JpdG1hcF93aWR0aCwgY2hlY2tfYml0bWFwX2hlaWdodCwKICAgICAgICAgICAgICAgICAgICAgICAgaGRjTWVtLCAwLCAwLCBTUkNDT1BZICk7CiAgICAgICAgICAgICAgICBEZWxldGVEQyggaGRjTWVtICk7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgZWxzZSBpZiAobHBpdGVtLT5mU3RhdGUgJiBNRl9DSEVDS0VEKSAgLyogc3RhbmRhcmQgYml0bWFwcyAqLwogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBSRUNUIHI7CiAgICAgICAgICAgICAgICBIQklUTUFQIGJtID0gQ3JlYXRlQml0bWFwKCBjaGVja19iaXRtYXBfd2lkdGgsIGNoZWNrX2JpdG1hcF9oZWlnaHQsIDEsIDEsIE5VTEwgKTsKICAgICAgICAgICAgICAgIEhEQyBoZGNNZW0gPSBDcmVhdGVDb21wYXRpYmxlREMoIGhkYyApOwogICAgICAgICAgICAgICAgU2VsZWN0T2JqZWN0KCBoZGNNZW0sIGJtICk7CiAgICAgICAgICAgICAgICBTZXRSZWN0KCAmciwgMCwgMCwgY2hlY2tfYml0bWFwX3dpZHRoLCBjaGVja19iaXRtYXBfaGVpZ2h0ICk7CiAgICAgICAgICAgICAgICBEcmF3RnJhbWVDb250cm9sKCBoZGNNZW0sICZyLCBERkNfTUVOVSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChscGl0ZW0tPmZUeXBlICYgTUZUX1JBRElPQ0hFQ0spID8KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIERGQ1NfTUVOVUJVTExFVCA6IERGQ1NfTUVOVUNIRUNLICk7CiAgICAgICAgICAgICAgICBCaXRCbHQoIGhkYywgcmVjdC5sZWZ0LCAoeSAtIHIuYm90dG9tKSAvIDIsIHIucmlnaHQsIHIuYm90dG9tLAogICAgICAgICAgICAgICAgICAgICAgICBoZGNNZW0sIDAsIDAsIFNSQ0NPUFkgKTsKICAgICAgICAgICAgICAgIERlbGV0ZURDKCBoZGNNZW0gKTsKICAgICAgICAgICAgICAgIERlbGV0ZU9iamVjdCggYm0gKTsKICAgICAgICAgICAgfQogICAgICAgIH0KCgkgIC8qIERyYXcgdGhlIHBvcHVwLW1lbnUgYXJyb3cgKi8KCWlmIChscGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApCgl7CgkgICAgSERDIGhkY01lbSA9IENyZWF0ZUNvbXBhdGlibGVEQyggaGRjICk7CgkgICAgSEJJVE1BUCBoT3JpZ0JpdG1hcDsKCgkgICAgaE9yaWdCaXRtYXAgPSBTZWxlY3RPYmplY3QoIGhkY01lbSwgaFN0ZE1uQXJyb3cgKTsKCSAgICBCaXRCbHQoIGhkYywgcmVjdC5yaWdodCAtIGFycm93X2JpdG1hcF93aWR0aCAtIDEsCgkJICAgICAgKHkgLSBhcnJvd19iaXRtYXBfaGVpZ2h0KSAvIDIsCgkJICAgICAgYXJyb3dfYml0bWFwX3dpZHRoLCBhcnJvd19iaXRtYXBfaGVpZ2h0LAoJCSAgICAgIGhkY01lbSwgMCwgMCwgU1JDQ09QWSApOwogICAgICAgICAgICBTZWxlY3RPYmplY3QoIGhkY01lbSwgaE9yaWdCaXRtYXAgKTsKCSAgICBEZWxldGVEQyggaGRjTWVtICk7Cgl9CgoJcmVjdC5sZWZ0ICs9IGNoZWNrX2JpdG1hcF93aWR0aDsKCXJlY3QucmlnaHQgLT0gYXJyb3dfYml0bWFwX3dpZHRoOwogICAgfQoKICAgIC8qIERvbmUgZm9yIG93bmVyLWRyYXduICovCiAgICBpZiAobHBpdGVtLT5mVHlwZSAmIE1GX09XTkVSRFJBVykKICAgICAgICByZXR1cm47CgogICAgLyogRHJhdyB0aGUgaXRlbSB0ZXh0IG9yIGJpdG1hcCAqLwogICAgaWYgKElTX0JJVE1BUF9JVEVNKGxwaXRlbS0+ZlR5cGUpKQogICAgewoJTUVOVV9EcmF3Qml0bWFwSXRlbSggaGRjLCBscGl0ZW0sICZyZWN0LCBtZW51QmFyLCBGQUxTRSk7CglyZXR1cm47CiAgICB9CiAgICAvKiBObyBiaXRtYXAgLSBwcm9jZXNzIHRleHQgaWYgcHJlc2VudCAqLwogICAgZWxzZSBpZiAoSVNfU1RSSU5HX0lURU0obHBpdGVtLT5mVHlwZSkpCiAgICB7CglyZWdpc3RlciBpbnQgaTsKCUhGT05UIGhmb250T2xkID0gMDsKCglVSU5UIHVGb3JtYXQgPSAobWVudUJhcikgPwoJCQlEVF9DRU5URVIgfCBEVF9WQ0VOVEVSIHwgRFRfU0lOR0xFTElORSA6CgkJCURUX0xFRlQgfCBEVF9WQ0VOVEVSIHwgRFRfU0lOR0xFTElORTsKCglpZiAoIGxwaXRlbS0+ZlN0YXRlICYgTUZTX0RFRkFVTFQgKQoJewoJICAgICBoZm9udE9sZCA9IFNlbGVjdE9iamVjdCggaGRjLCBoTWVudUZvbnRCb2xkKTsKCX0KCglpZiAobWVudUJhcikKCXsKCSAgICByZWN0LmxlZnQgKz0gTUVOVV9CQVJfSVRFTVNfU1BBQ0UgLyAyOwoJICAgIHJlY3QucmlnaHQgLT0gTUVOVV9CQVJfSVRFTVNfU1BBQ0UgLyAyOwoJfQoKCWZvciAoaSA9IDA7IGxwaXRlbS0+dGV4dFtpXTsgaSsrKQoJICAgIGlmICgobHBpdGVtLT50ZXh0W2ldID09ICdcdCcpIHx8IChscGl0ZW0tPnRleHRbaV0gPT0gJ1xiJykpCgkgICAgICAgIGJyZWFrOwoKCWlmKGxwaXRlbS0+ZlN0YXRlICYgTUZfR1JBWUVEKQoJewoJICAgIGlmICghKGxwaXRlbS0+ZlN0YXRlICYgTUZfSElMSVRFKSApCgkgICAgewoJCSsrcmVjdC5sZWZ0OyArK3JlY3QudG9wOyArK3JlY3QucmlnaHQ7ICsrcmVjdC5ib3R0b207CgkJU2V0VGV4dENvbG9yKGhkYywgUkdCKDB4ZmYsIDB4ZmYsIDB4ZmYpKTsKCQlEcmF3VGV4dFcoIGhkYywgbHBpdGVtLT50ZXh0LCBpLCAmcmVjdCwgdUZvcm1hdCApOwoJCS0tcmVjdC5sZWZ0OyAtLXJlY3QudG9wOyAtLXJlY3QucmlnaHQ7IC0tcmVjdC5ib3R0b207CgkgICAgfQoJICAgIFNldFRleHRDb2xvcihoZGMsIFJHQigweDgwLCAweDgwLCAweDgwKSk7Cgl9CgoJRHJhd1RleHRXKCBoZGMsIGxwaXRlbS0+dGV4dCwgaSwgJnJlY3QsIHVGb3JtYXQpOwoKCS8qIHBhaW50IHRoZSBzaG9ydGN1dCB0ZXh0ICovCglpZiAoIW1lbnVCYXIgJiYgbHBpdGVtLT50ZXh0W2ldKSAgLyogVGhlcmUncyBhIHRhYiBvciBmbHVzaC1yaWdodCBjaGFyICovCgl7CgkgICAgaWYgKGxwaXRlbS0+dGV4dFtpXSA9PSAnXHQnKQoJICAgIHsKCQlyZWN0LmxlZnQgPSBscGl0ZW0tPnhUYWI7CgkJdUZvcm1hdCA9IERUX0xFRlQgfCBEVF9WQ0VOVEVSIHwgRFRfU0lOR0xFTElORTsKCSAgICB9CgkgICAgZWxzZQoJICAgIHsKCQl1Rm9ybWF0ID0gRFRfUklHSFQgfCBEVF9WQ0VOVEVSIHwgRFRfU0lOR0xFTElORTsKCSAgICB9CgoJICAgIGlmKGxwaXRlbS0+ZlN0YXRlICYgTUZfR1JBWUVEKQoJICAgIHsKCQlpZiAoIShscGl0ZW0tPmZTdGF0ZSAmIE1GX0hJTElURSkgKQoJCXsKCQkgICAgKytyZWN0LmxlZnQ7ICsrcmVjdC50b3A7ICsrcmVjdC5yaWdodDsgKytyZWN0LmJvdHRvbTsKCQkgICAgU2V0VGV4dENvbG9yKGhkYywgUkdCKDB4ZmYsIDB4ZmYsIDB4ZmYpKTsKCQkgICAgRHJhd1RleHRXKCBoZGMsIGxwaXRlbS0+dGV4dCArIGkgKyAxLCAtMSwgJnJlY3QsIHVGb3JtYXQgKTsKCQkgICAgLS1yZWN0LmxlZnQ7IC0tcmVjdC50b3A7IC0tcmVjdC5yaWdodDsgLS1yZWN0LmJvdHRvbTsKCQl9CgkJU2V0VGV4dENvbG9yKGhkYywgUkdCKDB4ODAsIDB4ODAsIDB4ODApKTsKCSAgICB9CgkgICAgRHJhd1RleHRXKCBoZGMsIGxwaXRlbS0+dGV4dCArIGkgKyAxLCAtMSwgJnJlY3QsIHVGb3JtYXQgKTsKCX0KCglpZiAoaGZvbnRPbGQpCgkgICAgU2VsZWN0T2JqZWN0IChoZGMsIGhmb250T2xkKTsKICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9EcmF3UG9wdXBNZW51CiAqCiAqIFBhaW50IGEgcG9wdXAgbWVudS4KICovCnN0YXRpYyB2b2lkIE1FTlVfRHJhd1BvcHVwTWVudSggSFdORCBod25kLCBIREMgaGRjLCBITUVOVSBobWVudSApCnsKICAgIEhCUlVTSCBoUHJldkJydXNoID0gMDsKICAgIFJFQ1QgcmVjdDsKCiAgICBUUkFDRSgid25kPSVwIGRjPSVwIG1lbnU9JXBcbiIsIGh3bmQsIGhkYywgaG1lbnUpOwoKICAgIEdldENsaWVudFJlY3QoIGh3bmQsICZyZWN0ICk7CgogICAgaWYoKGhQcmV2QnJ1c2ggPSBTZWxlY3RPYmplY3QoIGhkYywgR2V0U3lzQ29sb3JCcnVzaChDT0xPUl9NRU5VKSApKQogICAgICAgICYmIChTZWxlY3RPYmplY3QoIGhkYywgaE1lbnVGb250KSkpCiAgICB7CglIUEVOIGhQcmV2UGVuOwoKCVJlY3RhbmdsZSggaGRjLCByZWN0LmxlZnQsIHJlY3QudG9wLCByZWN0LnJpZ2h0LCByZWN0LmJvdHRvbSApOwoKCWhQcmV2UGVuID0gU2VsZWN0T2JqZWN0KCBoZGMsIEdldFN0b2NrT2JqZWN0KCBOVUxMX1BFTiApICk7CglpZiggaFByZXZQZW4gKQoJewoJICAgIFBPUFVQTUVOVSAqbWVudTsKCgkgICAgRHJhd0VkZ2UgKGhkYywgJnJlY3QsIEVER0VfUkFJU0VELCBCRl9SRUNUKTsKCgkgICAgLyogZHJhdyBtZW51IGl0ZW1zICovCgoJICAgIG1lbnUgPSBNRU5VX0dldE1lbnUoIGhtZW51ICk7CgkgICAgaWYgKG1lbnUgJiYgbWVudS0+bkl0ZW1zKQoJICAgIHsKCQlNRU5VSVRFTSAqaXRlbTsKCQlVSU5UIHU7CgoJCWZvciAodSA9IG1lbnUtPm5JdGVtcywgaXRlbSA9IG1lbnUtPml0ZW1zOyB1ID4gMDsgdS0tLCBpdGVtKyspCgkJICAgIE1FTlVfRHJhd01lbnVJdGVtKCBod25kLCBobWVudSwgbWVudS0+aHduZE93bmVyLCBoZGMsIGl0ZW0sCgkJCQkgICAgICAgbWVudS0+SGVpZ2h0LCBGQUxTRSwgT0RBX0RSQVdFTlRJUkUgKTsKCgkgICAgfQoJfSBlbHNlCgl7CgkgICAgU2VsZWN0T2JqZWN0KCBoZGMsIGhQcmV2QnJ1c2ggKTsKCX0KICAgIH0KfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0RyYXdNZW51QmFyCiAqCiAqIFBhaW50IGEgbWVudSBiYXIuIFJldHVybnMgdGhlIGhlaWdodCBvZiB0aGUgbWVudSBiYXIuCiAqIGNhbGxlZCBmcm9tIFt3aW5kb3dzL25vbmNsaWVudC5jXQogKi8KVUlOVCBNRU5VX0RyYXdNZW51QmFyKCBIREMgaERDLCBMUFJFQ1QgbHByZWN0LCBIV05EIGh3bmQsCiAgICAgICAgICAgICAgICAgICAgICAgICBCT09MIHN1cHByZXNzX2RyYXcpCnsKICAgIExQUE9QVVBNRU5VIGxwcG9wOwogICAgSEZPTlQgaGZvbnRPbGQgPSAwOwogICAgSE1FTlUgaE1lbnUgPSBHZXRNZW51KGh3bmQpOwoKICAgIGxwcG9wID0gTUVOVV9HZXRNZW51KCBoTWVudSApOwogICAgaWYgKGxwcG9wID09IE5VTEwgfHwgbHByZWN0ID09IE5VTEwpCiAgICB7CiAgICAgICAgcmV0dXJuIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lNRU5VKTsKICAgIH0KCiAgICBpZiAoc3VwcHJlc3NfZHJhdykKICAgIHsKCWhmb250T2xkID0gU2VsZWN0T2JqZWN0KCBoREMsIGhNZW51Rm9udCk7CgoJaWYgKGxwcG9wLT5IZWlnaHQgPT0gMCkKCQlNRU5VX01lbnVCYXJDYWxjU2l6ZShoREMsIGxwcmVjdCwgbHBwb3AsIGh3bmQpOwoKCWxwcmVjdC0+Ym90dG9tID0gbHByZWN0LT50b3AgKyBscHBvcC0+SGVpZ2h0OwoKICAgICAgICBpZiAoaGZvbnRPbGQpIFNlbGVjdE9iamVjdCggaERDLCBoZm9udE9sZCk7CglyZXR1cm4gbHBwb3AtPkhlaWdodDsKICAgIH0KICAgIGVsc2UKICAgICAgICByZXR1cm4gRHJhd01lbnVCYXJUZW1wKGh3bmQsIGhEQywgbHByZWN0LCBoTWVudSwgTlVMTCk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfU2hvd1BvcHVwCiAqCiAqIERpc3BsYXkgYSBwb3B1cCBtZW51LgogKi8Kc3RhdGljIEJPT0wgTUVOVV9TaG93UG9wdXAoIEhXTkQgaHduZE93bmVyLCBITUVOVSBobWVudSwgVUlOVCBpZCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSU5UIHgsIElOVCB5LCBJTlQgeGFuY2hvciwgSU5UIHlhbmNob3IgKQp7CiAgICBQT1BVUE1FTlUgKm1lbnU7CiAgICBVSU5UIHdpZHRoLCBoZWlnaHQ7CgogICAgVFJBQ0UoIm93bmVyPSVwIGhtZW51PSVwIGlkPTB4JTA0eCB4PTB4JTA0eCB5PTB4JTA0eCB4YT0weCUwNHggeWE9MHglMDR4XG4iLAogICAgICAgICAgaHduZE93bmVyLCBobWVudSwgaWQsIHgsIHksIHhhbmNob3IsIHlhbmNob3IpOwoKICAgIGlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoIGhtZW51ICkpKSByZXR1cm4gRkFMU0U7CiAgICBpZiAobWVudS0+Rm9jdXNlZEl0ZW0gIT0gTk9fU0VMRUNURURfSVRFTSkKICAgIHsKCW1lbnUtPml0ZW1zW21lbnUtPkZvY3VzZWRJdGVtXS5mU3RhdGUgJj0gfihNRl9ISUxJVEV8TUZfTU9VU0VTRUxFQ1QpOwoJbWVudS0+Rm9jdXNlZEl0ZW0gPSBOT19TRUxFQ1RFRF9JVEVNOwogICAgfQoKICAgIC8qIHN0b3JlIHRoZSBvd25lciBmb3IgRHJhd0l0ZW0gKi8KICAgIG1lbnUtPmh3bmRPd25lciA9IGh3bmRPd25lcjsKCiAgICBNRU5VX1BvcHVwTWVudUNhbGNTaXplKCBtZW51LCBod25kT3duZXIgKTsKCiAgICAvKiBhZGp1c3QgcG9wdXAgbWVudSBwb3Mgc28gdGhhdCBpdCBmaXRzIHdpdGhpbiB0aGUgZGVza3RvcCAqLwoKICAgIHdpZHRoID0gbWVudS0+V2lkdGggKyBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYQk9SREVSKTsKICAgIGhlaWdodCA9IG1lbnUtPkhlaWdodCArIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lCT1JERVIpOwoKICAgIGlmKCB4ICsgd2lkdGggPiBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0NSRUVOICkpCiAgICB7CiAgICAgICAgaWYoIHhhbmNob3IgKQogICAgICAgICAgICB4IC09IHdpZHRoIC0geGFuY2hvcjsKICAgICAgICBpZiggeCArIHdpZHRoID4gR2V0U3lzdGVtTWV0cmljcyhTTV9DWFNDUkVFTikpCiAgICAgICAgICAgIHggPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0NSRUVOKSAtIHdpZHRoOwogICAgfQogICAgaWYoIHggPCAwICkgeCA9IDA7CgogICAgaWYoIHkgKyBoZWlnaHQgPiBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU0NSRUVOICkpCiAgICB7CiAgICAgICAgaWYoIHlhbmNob3IgKQogICAgICAgICAgICB5IC09IGhlaWdodCArIHlhbmNob3I7CiAgICAgICAgaWYoIHkgKyBoZWlnaHQgPiBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU0NSRUVOICkpCiAgICAgICAgICAgIHkgPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU0NSRUVOKSAtIGhlaWdodDsKICAgIH0KICAgIGlmKCB5IDwgMCApIHkgPSAwOwoKICAgIC8qIE5PVEU6IEluIFdpbmRvd3MsIHRvcCBtZW51IHBvcHVwIGlzIG5vdCBvd25lZC4gKi8KICAgIG1lbnUtPmhXbmQgPSBDcmVhdGVXaW5kb3dFeFcoIDAsIFBPUFVQTUVOVV9DTEFTU19BVE9NVywgTlVMTCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXU19QT1BVUCwgeCwgeSwgd2lkdGgsIGhlaWdodCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBod25kT3duZXIsIDAsIChISU5TVEFOQ0UpR2V0V2luZG93TG9uZ1B0clcoaHduZE93bmVyLCBHV0xQX0hJTlNUQU5DRSksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKExQVk9JRClobWVudSApOwogICAgaWYoICFtZW51LT5oV25kICkgcmV0dXJuIEZBTFNFOwogICAgaWYgKCF0b3BfcG9wdXApIHRvcF9wb3B1cCA9IG1lbnUtPmhXbmQ7CgogICAgLyogRGlzcGxheSB0aGUgd2luZG93ICovCgogICAgU2V0V2luZG93UG9zKCBtZW51LT5oV25kLCBIV05EX1RPUCwgMCwgMCwgMCwgMCwKICAgICAgICAgICAgICAgICAgU1dQX1NIT1dXSU5ET1cgfCBTV1BfTk9TSVpFIHwgU1dQX05PTU9WRSB8IFNXUF9OT0FDVElWQVRFICk7CiAgICBVcGRhdGVXaW5kb3coIG1lbnUtPmhXbmQgKTsKICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX1NlbGVjdEl0ZW0KICovCnN0YXRpYyB2b2lkIE1FTlVfU2VsZWN0SXRlbSggSFdORCBod25kT3duZXIsIEhNRU5VIGhtZW51LCBVSU5UIHdJbmRleCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBCT09MIHNlbmRNZW51U2VsZWN0LCBITUVOVSB0b3BtZW51ICkKewogICAgTFBQT1BVUE1FTlUgbHBwb3A7CiAgICBIREMgaGRjOwoKICAgIFRSQUNFKCJvd25lcj0lcCBtZW51PSVwIGluZGV4PTB4JTA0eCBzZWxlY3Q9MHglMDR4XG4iLCBod25kT3duZXIsIGhtZW51LCB3SW5kZXgsIHNlbmRNZW51U2VsZWN0KTsKCiAgICBscHBvcCA9IE1FTlVfR2V0TWVudSggaG1lbnUgKTsKICAgIGlmICgoIWxwcG9wKSB8fCAoIWxwcG9wLT5uSXRlbXMpIHx8ICghbHBwb3AtPmhXbmQpKSByZXR1cm47CgogICAgaWYgKGxwcG9wLT5Gb2N1c2VkSXRlbSA9PSB3SW5kZXgpIHJldHVybjsKICAgIGlmIChscHBvcC0+d0ZsYWdzICYgTUZfUE9QVVApIGhkYyA9IEdldERDKCBscHBvcC0+aFduZCApOwogICAgZWxzZSBoZGMgPSBHZXREQ0V4KCBscHBvcC0+aFduZCwgMCwgRENYX0NBQ0hFIHwgRENYX1dJTkRPVyk7CiAgICBpZiAoIXRvcF9wb3B1cCkgdG9wX3BvcHVwID0gbHBwb3AtPmhXbmQ7CgogICAgU2VsZWN0T2JqZWN0KCBoZGMsIGhNZW51Rm9udCk7CgogICAgICAvKiBDbGVhciBwcmV2aW91cyBoaWdobGlnaHRlZCBpdGVtICovCiAgICBpZiAobHBwb3AtPkZvY3VzZWRJdGVtICE9IE5PX1NFTEVDVEVEX0lURU0pCiAgICB7CglscHBvcC0+aXRlbXNbbHBwb3AtPkZvY3VzZWRJdGVtXS5mU3RhdGUgJj0gfihNRl9ISUxJVEV8TUZfTU9VU0VTRUxFQ1QpOwoJTUVOVV9EcmF3TWVudUl0ZW0obHBwb3AtPmhXbmQsIGhtZW51LCBod25kT3duZXIsIGhkYywmbHBwb3AtPml0ZW1zW2xwcG9wLT5Gb2N1c2VkSXRlbV0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgbHBwb3AtPkhlaWdodCwgIShscHBvcC0+d0ZsYWdzICYgTUZfUE9QVVApLAoJCQkgIE9EQV9TRUxFQ1QgKTsKICAgIH0KCiAgICAgIC8qIEhpZ2hsaWdodCBuZXcgaXRlbSAoaWYgYW55KSAqLwogICAgbHBwb3AtPkZvY3VzZWRJdGVtID0gd0luZGV4OwogICAgaWYgKGxwcG9wLT5Gb2N1c2VkSXRlbSAhPSBOT19TRUxFQ1RFRF9JVEVNKQogICAgewogICAgICAgIGlmKCEobHBwb3AtPml0ZW1zW3dJbmRleF0uZlR5cGUgJiBNRl9TRVBBUkFUT1IpKSB7CiAgICAgICAgICAgIGxwcG9wLT5pdGVtc1t3SW5kZXhdLmZTdGF0ZSB8PSBNRl9ISUxJVEU7CiAgICAgICAgICAgIE1FTlVfRHJhd01lbnVJdGVtKCBscHBvcC0+aFduZCwgaG1lbnUsIGh3bmRPd25lciwgaGRjLAogICAgICAgICAgICAgICAgICAgICZscHBvcC0+aXRlbXNbd0luZGV4XSwgbHBwb3AtPkhlaWdodCwKICAgICAgICAgICAgICAgICAgICAhKGxwcG9wLT53RmxhZ3MgJiBNRl9QT1BVUCksIE9EQV9TRUxFQ1QgKTsKICAgICAgICB9CiAgICAgICAgaWYgKHNlbmRNZW51U2VsZWN0KQogICAgICAgIHsKICAgICAgICAgICAgTUVOVUlURU0gKmlwID0gJmxwcG9wLT5pdGVtc1tscHBvcC0+Rm9jdXNlZEl0ZW1dOwoJICAgIFNlbmRNZXNzYWdlVyggaHduZE93bmVyLCBXTV9NRU5VU0VMRUNULAogICAgICAgICAgICAgICAgICAgICBNQUtFTE9ORyhpcC0+ZlR5cGUgJiBNRl9QT1BVUCA/IHdJbmRleDogaXAtPndJRCwKICAgICAgICAgICAgICAgICAgICAgaXAtPmZUeXBlIHwgaXAtPmZTdGF0ZSB8CiAgICAgICAgICAgICAgICAgICAgIChscHBvcC0+d0ZsYWdzICYgTUZfU1lTTUVOVSkpLCAoTFBBUkFNKWhtZW51KTsKICAgICAgICB9CiAgICB9CiAgICBlbHNlIGlmIChzZW5kTWVudVNlbGVjdCkgewogICAgICAgIGlmKHRvcG1lbnUpewogICAgICAgICAgICBpbnQgcG9zOwogICAgICAgICAgICBpZigocG9zPU1FTlVfRmluZFN1Yk1lbnUoJnRvcG1lbnUsIGhtZW51KSkhPU5PX1NFTEVDVEVEX0lURU0pewogICAgICAgICAgICAgICAgUE9QVVBNRU5VICpwdG0gPSBNRU5VX0dldE1lbnUoIHRvcG1lbnUgKTsKICAgICAgICAgICAgICAgIE1FTlVJVEVNICppcCA9ICZwdG0tPml0ZW1zW3Bvc107CiAgICAgICAgICAgICAgICBTZW5kTWVzc2FnZVcoIGh3bmRPd25lciwgV01fTUVOVVNFTEVDVCwgTUFLRUxPTkcocG9zLAogICAgICAgICAgICAgICAgICAgICAgICAgaXAtPmZUeXBlIHwgaXAtPmZTdGF0ZSB8CiAgICAgICAgICAgICAgICAgICAgICAgICAocHRtLT53RmxhZ3MgJiBNRl9TWVNNRU5VKSksIChMUEFSQU0pdG9wbWVudSk7CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICB9CiAgICBSZWxlYXNlREMoIGxwcG9wLT5oV25kLCBoZGMgKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9Nb3ZlU2VsZWN0aW9uCiAqCiAqIE1vdmVzIGN1cnJlbnRseSBzZWxlY3RlZCBpdGVtIGFjY29yZGluZyB0byB0aGUgb2Zmc2V0IHBhcmFtZXRlci4KICogSWYgdGhlcmUgaXMgbm8gc2VsZWN0aW9uIHRoZW4gaXQgc2hvdWxkIHNlbGVjdCB0aGUgbGFzdCBpdGVtIGlmCiAqIG9mZnNldCBpcyBJVEVNX1BSRVYgb3IgdGhlIGZpcnN0IGl0ZW0gaWYgb2Zmc2V0IGlzIElURU1fTkVYVC4KICovCnN0YXRpYyB2b2lkIE1FTlVfTW92ZVNlbGVjdGlvbiggSFdORCBod25kT3duZXIsIEhNRU5VIGhtZW51LCBJTlQgb2Zmc2V0ICkKewogICAgSU5UIGk7CiAgICBQT1BVUE1FTlUgKm1lbnU7CgogICAgVFJBQ0UoImh3bmQ9JXAgaG1lbnU9JXAgb2ZmPTB4JTA0eFxuIiwgaHduZE93bmVyLCBobWVudSwgb2Zmc2V0KTsKCiAgICBtZW51ID0gTUVOVV9HZXRNZW51KCBobWVudSApOwogICAgaWYgKCghbWVudSkgfHwgKCFtZW51LT5pdGVtcykpIHJldHVybjsKCiAgICBpZiAoIG1lbnUtPkZvY3VzZWRJdGVtICE9IE5PX1NFTEVDVEVEX0lURU0gKQogICAgewoJaWYoIG1lbnUtPm5JdGVtcyA9PSAxICkgcmV0dXJuOyBlbHNlCglmb3IgKGkgPSBtZW51LT5Gb2N1c2VkSXRlbSArIG9mZnNldCA7IGkgPj0gMCAmJiBpIDwgbWVudS0+bkl0ZW1zCgkJCQkJICAgIDsgaSArPSBvZmZzZXQpCgkgICAgaWYgKCEobWVudS0+aXRlbXNbaV0uZlR5cGUgJiBNRl9TRVBBUkFUT1IpKQoJICAgIHsKCQlNRU5VX1NlbGVjdEl0ZW0oIGh3bmRPd25lciwgaG1lbnUsIGksIFRSVUUsIDAgKTsKCQlyZXR1cm47CgkgICAgfQogICAgfQoKICAgIGZvciAoIGkgPSAob2Zmc2V0ID4gMCkgPyAwIDogbWVudS0+bkl0ZW1zIC0gMTsKCQkgIGkgPj0gMCAmJiBpIDwgbWVudS0+bkl0ZW1zIDsgaSArPSBvZmZzZXQpCglpZiAoIShtZW51LT5pdGVtc1tpXS5mVHlwZSAmIE1GX1NFUEFSQVRPUikpCgl7CgkgICAgTUVOVV9TZWxlY3RJdGVtKCBod25kT3duZXIsIGhtZW51LCBpLCBUUlVFLCAwICk7CgkgICAgcmV0dXJuOwoJfQp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBNRU5VX1NldEl0ZW1EYXRhCiAqCiAqIFNldCBhbiBpdGVtJ3MgZmxhZ3MsIGlkIGFuZCB0ZXh0IHB0ci4gQ2FsbGVkIGJ5IEluc2VydE1lbnUoKSBhbmQKICogTW9kaWZ5TWVudSgpLgogKi8Kc3RhdGljIEJPT0wgTUVOVV9TZXRJdGVtRGF0YSggTUVOVUlURU0gKml0ZW0sIFVJTlQgZmxhZ3MsIFVJTlRfUFRSIGlkLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIExQQ1dTVFIgc3RyICkKewogICAgTFBXU1RSIHByZXZUZXh0ID0gSVNfU1RSSU5HX0lURU0oaXRlbS0+ZlR5cGUpID8gaXRlbS0+dGV4dCA6IE5VTEw7CgogICAgZGVidWdfcHJpbnRfbWVudWl0ZW0oIk1FTlVfU2V0SXRlbURhdGEgZnJvbTogIiwgaXRlbSwgIiIpOwogICAgVFJBQ0UoImZsYWdzPSV4IHN0cj0lcFxuIiwgZmxhZ3MsIHN0cik7CgogICAgaWYgKElTX1NUUklOR19JVEVNKGZsYWdzKSkKICAgIHsKICAgICAgICBpZiAoIXN0cikKICAgICAgICB7CiAgICAgICAgICAgIGZsYWdzIHw9IE1GX1NFUEFSQVRPUjsKICAgICAgICAgICAgaXRlbS0+dGV4dCA9IE5VTEw7CiAgICAgICAgfQogICAgICAgIGVsc2UKICAgICAgICB7CiAgICAgICAgICAgIExQV1NUUiB0ZXh0OwogICAgICAgICAgICAvKiBJdGVtIGJlZ2lubmluZyB3aXRoIGEgYmFja3NwYWNlIGlzIGEgaGVscCBpdGVtICovCiAgICAgICAgICAgIGlmICgqc3RyID09ICdcYicpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIGZsYWdzIHw9IE1GX0hFTFA7CiAgICAgICAgICAgICAgICBzdHIrKzsKICAgICAgICAgICAgfQogICAgICAgICAgICBpZiAoISh0ZXh0ID0gSGVhcEFsbG9jKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCAoc3RybGVuVyhzdHIpKzEpICogc2l6ZW9mKFdDSEFSKSApKSkKICAgICAgICAgICAgICAgIHJldHVybiBGQUxTRTsKICAgICAgICAgICAgc3RyY3B5VyggdGV4dCwgc3RyICk7CiAgICAgICAgICAgIGl0ZW0tPnRleHQgPSB0ZXh0OwogICAgICAgIH0KICAgIH0KICAgIGVsc2UgaWYgKElTX0JJVE1BUF9JVEVNKGZsYWdzKSkKICAgICAgICBpdGVtLT50ZXh0ID0gKExQV1NUUilIQklUTUFQXzMyKExPV09SRChzdHIpKTsKICAgIGVsc2UgaXRlbS0+dGV4dCA9IE5VTEw7CgogICAgaWYgKGZsYWdzICYgTUZfT1dORVJEUkFXKQogICAgICAgIGl0ZW0tPmR3SXRlbURhdGEgPSAoRFdPUkQpc3RyOwogICAgZWxzZQogICAgICAgIGl0ZW0tPmR3SXRlbURhdGEgPSAwOwoKICAgIGlmICgoaXRlbS0+ZlR5cGUgJiBNRl9QT1BVUCkgJiYgKGZsYWdzICYgTUZfUE9QVVApICYmIChpdGVtLT5oU3ViTWVudSAhPSAoSE1FTlUpaWQpICkKCURlc3Ryb3lNZW51KCBpdGVtLT5oU3ViTWVudSApOyAgIC8qIE1vZGlmeU1lbnUoKSBzcGVjICovCgogICAgaWYgKGZsYWdzICYgTUZfUE9QVVApCiAgICB7CglQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoKEhNRU5VKWlkKTsKICAgICAgICBpZiAobWVudSkgbWVudS0+d0ZsYWdzIHw9IE1GX1BPUFVQOwoJZWxzZQogICAgICAgIHsKICAgICAgICAgICAgaXRlbS0+d0lEID0gMDsKICAgICAgICAgICAgaXRlbS0+aFN1Yk1lbnUgPSAwOwogICAgICAgICAgICBpdGVtLT5mVHlwZSA9IDA7CiAgICAgICAgICAgIGl0ZW0tPmZTdGF0ZSA9IDA7CgkgICAgcmV0dXJuIEZBTFNFOwogICAgICAgIH0KICAgIH0KCiAgICBpdGVtLT53SUQgPSBpZDsKICAgIGlmIChmbGFncyAmIE1GX1BPUFVQKSBpdGVtLT5oU3ViTWVudSA9IChITUVOVSlpZDsKCiAgICBpZiAoKGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApICYmICEoZmxhZ3MgJiBNRl9QT1BVUCkgKQogICAgICBmbGFncyB8PSBNRl9QT1BVUDsgLyoga2VlcCBwb3B1cCAqLwoKICAgIGl0ZW0tPmZUeXBlID0gZmxhZ3MgJiBUWVBFX01BU0s7CiAgICBpdGVtLT5mU3RhdGUgPSAoZmxhZ3MgJiBTVEFURV9NQVNLKSAmCiAgICAgICAgfihNRl9ISUxJVEUgfCBNRl9NT1VTRVNFTEVDVCB8IE1GX0JZUE9TSVRJT04pOwoKCiAgICAvKiBEb24ndCBjYWxsIFNldFJlY3RFbXB0eSBoZXJlISAqLwoKCiAgICBIZWFwRnJlZSggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgcHJldlRleHQgKTsKCiAgICBkZWJ1Z19wcmludF9tZW51aXRlbSgiTUVOVV9TZXRJdGVtRGF0YSB0byAgOiAiLCBpdGVtLCAiIik7CiAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgTUVOVV9JbnNlcnRJdGVtCiAqCiAqIEluc2VydCAoYWxsb2NhdGUpIGEgbmV3IGl0ZW0gaW50byBhIG1lbnUuCiAqLwpzdGF0aWMgTUVOVUlURU0gKk1FTlVfSW5zZXJ0SXRlbSggSE1FTlUgaE1lbnUsIFVJTlQgcG9zLCBVSU5UIGZsYWdzICkKewogICAgTUVOVUlURU0gKm5ld0l0ZW1zOwogICAgUE9QVVBNRU5VICptZW51OwoKICAgIGlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpKSkKICAgICAgICByZXR1cm4gTlVMTDsKCiAgICAvKiBGaW5kIHdoZXJlIHRvIGluc2VydCBuZXcgaXRlbSAqLwoKICAgIGlmIChmbGFncyAmIE1GX0JZUE9TSVRJT04pIHsKICAgICAgICBpZiAocG9zID4gbWVudS0+bkl0ZW1zKQogICAgICAgICAgICBwb3MgPSBtZW51LT5uSXRlbXM7CiAgICB9IGVsc2UgewogICAgICAgIGlmICghTUVOVV9GaW5kSXRlbSggJmhNZW51LCAmcG9zLCBmbGFncyApKQogICAgICAgICAgICBwb3MgPSBtZW51LT5uSXRlbXM7CiAgICAgICAgZWxzZSB7CiAgICAgICAgICAgIGlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoIGhNZW51ICkpKQogICAgICAgICAgICAgICAgcmV0dXJuIE5VTEw7CiAgICAgICAgfQogICAgfQoKICAgIC8qIENyZWF0ZSBuZXcgaXRlbXMgYXJyYXkgKi8KCiAgICBuZXdJdGVtcyA9IEhlYXBBbGxvYyggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgc2l6ZW9mKE1FTlVJVEVNKSAqIChtZW51LT5uSXRlbXMrMSkgKTsKICAgIGlmICghbmV3SXRlbXMpCiAgICB7CiAgICAgICAgV0FSTigiYWxsb2NhdGlvbiBmYWlsZWRcbiIgKTsKICAgICAgICByZXR1cm4gTlVMTDsKICAgIH0KICAgIGlmIChtZW51LT5uSXRlbXMgPiAwKQogICAgewoJICAvKiBDb3B5IHRoZSBvbGQgYXJyYXkgaW50byB0aGUgbmV3IG9uZSAqLwoJaWYgKHBvcyA+IDApIG1lbWNweSggbmV3SXRlbXMsIG1lbnUtPml0ZW1zLCBwb3MgKiBzaXplb2YoTUVOVUlURU0pICk7CglpZiAocG9zIDwgbWVudS0+bkl0ZW1zKSBtZW1jcHkoICZuZXdJdGVtc1twb3MrMV0sICZtZW51LT5pdGVtc1twb3NdLAoJCQkJCShtZW51LT5uSXRlbXMtcG9zKSpzaXplb2YoTUVOVUlURU0pICk7CiAgICAgICAgSGVhcEZyZWUoIEdldFByb2Nlc3NIZWFwKCksIDAsIG1lbnUtPml0ZW1zICk7CiAgICB9CiAgICBtZW51LT5pdGVtcyA9IG5ld0l0ZW1zOwogICAgbWVudS0+bkl0ZW1zKys7CiAgICBtZW1zZXQoICZuZXdJdGVtc1twb3NdLCAwLCBzaXplb2YoKm5ld0l0ZW1zKSApOwogICAgbWVudS0+SGVpZ2h0ID0gMDsgLyogZm9yY2Ugc2l6ZSByZWNhbGN1bGF0ZSAqLwogICAgcmV0dXJuICZuZXdJdGVtc1twb3NdOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBNRU5VX1BhcnNlUmVzb3VyY2UKICoKICogUGFyc2UgYSBzdGFuZGFyZCBtZW51IHJlc291cmNlIGFuZCBhZGQgaXRlbXMgdG8gdGhlIG1lbnUuCiAqIFJldHVybiBhIHBvaW50ZXIgdG8gdGhlIGVuZCBvZiB0aGUgcmVzb3VyY2UuCiAqCiAqIE5PVEU6IGZsYWdzIGlzIGVxdWl2YWxlbnQgdG8gdGhlIG10T3B0aW9uIGZpZWxkCiAqLwpzdGF0aWMgTFBDU1RSIE1FTlVfUGFyc2VSZXNvdXJjZSggTFBDU1RSIHJlcywgSE1FTlUgaE1lbnUsIEJPT0wgdW5pY29kZSApCnsKICAgIFdPUkQgZmxhZ3MsIGlkID0gMDsKICAgIExQQ1NUUiBzdHI7CgogICAgZG8KICAgIHsKICAgICAgICBmbGFncyA9IEdFVF9XT1JEKHJlcyk7CiAgICAgICAgcmVzICs9IHNpemVvZihXT1JEKTsKICAgICAgICBpZiAoIShmbGFncyAmIE1GX1BPUFVQKSkKICAgICAgICB7CiAgICAgICAgICAgIGlkID0gR0VUX1dPUkQocmVzKTsKICAgICAgICAgICAgcmVzICs9IHNpemVvZihXT1JEKTsKICAgICAgICB9CiAgICAgICAgc3RyID0gcmVzOwogICAgICAgIGlmICghdW5pY29kZSkgcmVzICs9IHN0cmxlbihzdHIpICsgMTsKICAgICAgICBlbHNlIHJlcyArPSAoc3RybGVuVygoTFBDV1NUUilzdHIpICsgMSkgKiBzaXplb2YoV0NIQVIpOwogICAgICAgIGlmIChmbGFncyAmIE1GX1BPUFVQKQogICAgICAgIHsKICAgICAgICAgICAgSE1FTlUgaFN1Yk1lbnUgPSBDcmVhdGVQb3B1cE1lbnUoKTsKICAgICAgICAgICAgaWYgKCFoU3ViTWVudSkgcmV0dXJuIE5VTEw7CiAgICAgICAgICAgIGlmICghKHJlcyA9IE1FTlVfUGFyc2VSZXNvdXJjZSggcmVzLCBoU3ViTWVudSwgdW5pY29kZSApKSkKICAgICAgICAgICAgICAgIHJldHVybiBOVUxMOwogICAgICAgICAgICBpZiAoIXVuaWNvZGUpIEFwcGVuZE1lbnVBKCBoTWVudSwgZmxhZ3MsIChVSU5UKWhTdWJNZW51LCBzdHIgKTsKICAgICAgICAgICAgZWxzZSBBcHBlbmRNZW51VyggaE1lbnUsIGZsYWdzLCAoVUlOVCloU3ViTWVudSwgKExQQ1dTVFIpc3RyICk7CiAgICAgICAgfQogICAgICAgIGVsc2UgIC8qIE5vdCBhIHBvcHVwICovCiAgICAgICAgewogICAgICAgICAgICBpZiAoIXVuaWNvZGUpIEFwcGVuZE1lbnVBKCBoTWVudSwgZmxhZ3MsIGlkLCAqc3RyID8gc3RyIDogTlVMTCApOwogICAgICAgICAgICBlbHNlIEFwcGVuZE1lbnVXKCBoTWVudSwgZmxhZ3MsIGlkLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICooTFBDV1NUUilzdHIgPyAoTFBDV1NUUilzdHIgOiBOVUxMICk7CiAgICAgICAgfQogICAgfSB3aGlsZSAoIShmbGFncyAmIE1GX0VORCkpOwogICAgcmV0dXJuIHJlczsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgTUVOVUVYX1BhcnNlUmVzb3VyY2UKICoKICogUGFyc2UgYW4gZXh0ZW5kZWQgbWVudSByZXNvdXJjZSBhbmQgYWRkIGl0ZW1zIHRvIHRoZSBtZW51LgogKiBSZXR1cm4gYSBwb2ludGVyIHRvIHRoZSBlbmQgb2YgdGhlIHJlc291cmNlLgogKi8Kc3RhdGljIExQQ1NUUiBNRU5VRVhfUGFyc2VSZXNvdXJjZSggTFBDU1RSIHJlcywgSE1FTlUgaE1lbnUpCnsKICAgIFdPUkQgcmVzaW5mbzsKICAgIGRvIHsKCU1FTlVJVEVNSU5GT1cgbWlpOwoKCW1paS5jYlNpemUgPSBzaXplb2YobWlpKTsKCW1paS5mTWFzayA9IE1JSU1fU1RBVEUgfCBNSUlNX0lEIHwgTUlJTV9UWVBFOwoJbWlpLmZUeXBlID0gR0VUX0RXT1JEKHJlcyk7CiAgICAgICAgcmVzICs9IHNpemVvZihEV09SRCk7CgltaWkuZlN0YXRlID0gR0VUX0RXT1JEKHJlcyk7CiAgICAgICAgcmVzICs9IHNpemVvZihEV09SRCk7CgltaWkud0lEID0gR0VUX0RXT1JEKHJlcyk7CiAgICAgICAgcmVzICs9IHNpemVvZihEV09SRCk7CglyZXNpbmZvID0gR0VUX1dPUkQocmVzKTsgLyogRklYTUU6IGZvciAxNi1iaXQgYXBwcyB0aGlzIGlzIGEgYnl0ZS4gICovCiAgICAgICAgcmVzICs9IHNpemVvZihXT1JEKTsKCS8qIEFsaWduIHRoZSB0ZXh0IG9uIGEgd29yZCBib3VuZGFyeS4gICovCglyZXMgKz0gKH4oKGludClyZXMgLSAxKSkgJiAxOwoJbWlpLmR3VHlwZURhdGEgPSAoTFBXU1RSKSByZXM7CglyZXMgKz0gKDEgKyBzdHJsZW5XKG1paS5kd1R5cGVEYXRhKSkgKiBzaXplb2YoV0NIQVIpOwoJLyogQWxpZ24gdGhlIGZvbGxvd2luZyBmaWVsZHMgb24gYSBkd29yZCBib3VuZGFyeS4gICovCglyZXMgKz0gKH4oKGludClyZXMgLSAxKSkgJiAzOwoKICAgICAgICBUUkFDRSgiTWVudSBpdGVtOiBbJTA4eCwlMDh4LCUwNHgsJTA0eCwlc11cbiIsCiAgICAgICAgICAgICAgbWlpLmZUeXBlLCBtaWkuZlN0YXRlLCBtaWkud0lELCByZXNpbmZvLCBkZWJ1Z3N0cl93KG1paS5kd1R5cGVEYXRhKSk7CgoJaWYgKHJlc2luZm8gJiAxKSB7CS8qIFBvcC11cD8gKi8KCSAgICAvKiBEV09SRCBoZWxwaWQgPSBHRVRfRFdPUkQocmVzKTsgRklYTUU6IHVzZSB0aGlzLiAgKi8KCSAgICByZXMgKz0gc2l6ZW9mKERXT1JEKTsKCSAgICBtaWkuaFN1Yk1lbnUgPSBDcmVhdGVQb3B1cE1lbnUoKTsKCSAgICBpZiAoIW1paS5oU3ViTWVudSkKCQlyZXR1cm4gTlVMTDsKCSAgICBpZiAoIShyZXMgPSBNRU5VRVhfUGFyc2VSZXNvdXJjZShyZXMsIG1paS5oU3ViTWVudSkpKSB7CgkJRGVzdHJveU1lbnUobWlpLmhTdWJNZW51KTsKICAgICAgICAgICAgICAgIHJldHVybiBOVUxMOwoJICAgIH0KCSAgICBtaWkuZk1hc2sgfD0gTUlJTV9TVUJNRU5VOwoJICAgIG1paS5mVHlwZSB8PSBNRl9QT1BVUDsKICAgICAgICB9CgllbHNlIGlmKCEqbWlpLmR3VHlwZURhdGEgJiYgIShtaWkuZlR5cGUgJiBNRl9TRVBBUkFUT1IpKQoJewoJICAgIFdBUk4oIkNvbnZlcnRpbmcgTlVMTCBtZW51IGl0ZW0gJTA0eCwgdHlwZSAlMDR4IHRvIFNFUEFSQVRPUlxuIiwKCQltaWkud0lELCBtaWkuZlR5cGUpOwoJICAgIG1paS5mVHlwZSB8PSBNRl9TRVBBUkFUT1I7Cgl9CglJbnNlcnRNZW51SXRlbVcoaE1lbnUsIC0xLCBNRl9CWVBPU0lUSU9OLCAmbWlpKTsKICAgIH0gd2hpbGUgKCEocmVzaW5mbyAmIE1GX0VORCkpOwogICAgcmV0dXJuIHJlczsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9HZXRTdWJQb3B1cAogKgogKiBSZXR1cm4gdGhlIGhhbmRsZSBvZiB0aGUgc2VsZWN0ZWQgc3ViLXBvcHVwIG1lbnUgKGlmIGFueSkuCiAqLwpzdGF0aWMgSE1FTlUgTUVOVV9HZXRTdWJQb3B1cCggSE1FTlUgaG1lbnUgKQp7CiAgICBQT1BVUE1FTlUgKm1lbnU7CiAgICBNRU5VSVRFTSAqaXRlbTsKCiAgICBtZW51ID0gTUVOVV9HZXRNZW51KCBobWVudSApOwoKICAgIGlmICgoIW1lbnUpIHx8IChtZW51LT5Gb2N1c2VkSXRlbSA9PSBOT19TRUxFQ1RFRF9JVEVNKSkgcmV0dXJuIDA7CgogICAgaXRlbSA9ICZtZW51LT5pdGVtc1ttZW51LT5Gb2N1c2VkSXRlbV07CiAgICBpZiAoKGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApICYmIChpdGVtLT5mU3RhdGUgJiBNRl9NT1VTRVNFTEVDVCkpCiAgICAgICAgcmV0dXJuIGl0ZW0tPmhTdWJNZW51OwogICAgcmV0dXJuIDA7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfSGlkZVN1YlBvcHVwcwogKgogKiBIaWRlIHRoZSBzdWItcG9wdXAgbWVudXMgb2YgdGhpcyBtZW51LgogKi8Kc3RhdGljIHZvaWQgTUVOVV9IaWRlU3ViUG9wdXBzKCBIV05EIGh3bmRPd25lciwgSE1FTlUgaG1lbnUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQk9PTCBzZW5kTWVudVNlbGVjdCApCnsKICAgIFBPUFVQTUVOVSAqbWVudSA9IE1FTlVfR2V0TWVudSggaG1lbnUgKTsKCiAgICBUUkFDRSgib3duZXI9JXAgaG1lbnU9JXAgMHglMDR4XG4iLCBod25kT3duZXIsIGhtZW51LCBzZW5kTWVudVNlbGVjdCk7CgogICAgaWYgKG1lbnUgJiYgdG9wX3BvcHVwKQogICAgewoJSE1FTlUgaHN1Ym1lbnU7CglQT1BVUE1FTlUgKnN1Ym1lbnU7CglNRU5VSVRFTSAqaXRlbTsKCglpZiAobWVudS0+Rm9jdXNlZEl0ZW0gIT0gTk9fU0VMRUNURURfSVRFTSkKCXsKCSAgICBpdGVtID0gJm1lbnUtPml0ZW1zW21lbnUtPkZvY3VzZWRJdGVtXTsKCSAgICBpZiAoIShpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKSB8fAoJCSEoaXRlbS0+ZlN0YXRlICYgTUZfTU9VU0VTRUxFQ1QpKSByZXR1cm47CgkgICAgaXRlbS0+ZlN0YXRlICY9IH5NRl9NT1VTRVNFTEVDVDsKCSAgICBoc3VibWVudSA9IGl0ZW0tPmhTdWJNZW51OwoJfSBlbHNlIHJldHVybjsKCglzdWJtZW51ID0gTUVOVV9HZXRNZW51KCBoc3VibWVudSApOwoJTUVOVV9IaWRlU3ViUG9wdXBzKCBod25kT3duZXIsIGhzdWJtZW51LCBGQUxTRSApOwoJTUVOVV9TZWxlY3RJdGVtKCBod25kT3duZXIsIGhzdWJtZW51LCBOT19TRUxFQ1RFRF9JVEVNLCBzZW5kTWVudVNlbGVjdCwgMCApOwogICAgICAgIERlc3Ryb3lXaW5kb3coIHN1Ym1lbnUtPmhXbmQgKTsKICAgICAgICBzdWJtZW51LT5oV25kID0gMDsKICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9TaG93U3ViUG9wdXAKICoKICogRGlzcGxheSB0aGUgc3ViLW1lbnUgb2YgdGhlIHNlbGVjdGVkIGl0ZW0gb2YgdGhpcyBtZW51LgogKiBSZXR1cm4gdGhlIGhhbmRsZSBvZiB0aGUgc3VibWVudSwgb3IgaG1lbnUgaWYgbm8gc3VibWVudSB0byBkaXNwbGF5LgogKi8Kc3RhdGljIEhNRU5VIE1FTlVfU2hvd1N1YlBvcHVwKCBIV05EIGh3bmRPd25lciwgSE1FTlUgaG1lbnUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBCT09MIHNlbGVjdEZpcnN0LCBVSU5UIHdGbGFncyApCnsKICAgIFJFQ1QgcmVjdDsKICAgIFBPUFVQTUVOVSAqbWVudTsKICAgIE1FTlVJVEVNICppdGVtOwogICAgSERDIGhkYzsKCiAgICBUUkFDRSgib3duZXI9JXAgaG1lbnU9JXAgMHglMDR4XG4iLCBod25kT3duZXIsIGhtZW51LCBzZWxlY3RGaXJzdCk7CgogICAgaWYgKCEobWVudSA9IE1FTlVfR2V0TWVudSggaG1lbnUgKSkpIHJldHVybiBobWVudTsKCiAgICBpZiAobWVudS0+Rm9jdXNlZEl0ZW0gPT0gTk9fU0VMRUNURURfSVRFTSkgcmV0dXJuIGhtZW51OwoKICAgIGl0ZW0gPSAmbWVudS0+aXRlbXNbbWVudS0+Rm9jdXNlZEl0ZW1dOwogICAgaWYgKCEoaXRlbS0+ZlR5cGUgJiBNRl9QT1BVUCkgfHwgKGl0ZW0tPmZTdGF0ZSAmIChNRl9HUkFZRUQgfCBNRl9ESVNBQkxFRCkpKQogICAgICAgIHJldHVybiBobWVudTsKCiAgICAvKiBtZXNzYWdlIG11c3QgYmUgc2VudCBiZWZvcmUgdXNpbmcgaXRlbSwKICAgICAgIGJlY2F1c2UgbmVhcmx5IGV2ZXJ5dGhpbmcgbWF5IGJlIGNoYW5nZWQgYnkgdGhlIGFwcGxpY2F0aW9uICEgKi8KCiAgICAvKiBTZW5kIFdNX0lOSVRNRU5VUE9QVVAgbWVzc2FnZSBvbmx5IGlmIFRQTV9OT05PVElGWSBmbGFnIGlzIG5vdCBzcGVjaWZpZWQgKi8KICAgIGlmICghKHdGbGFncyAmIFRQTV9OT05PVElGWSkpCiAgICAgICBTZW5kTWVzc2FnZVcoIGh3bmRPd25lciwgV01fSU5JVE1FTlVQT1BVUCwgKFdQQVJBTSlpdGVtLT5oU3ViTWVudSwKICAgICAgICAgICAgICAgICAgICAgTUFLRUxPTkcoIG1lbnUtPkZvY3VzZWRJdGVtLCBJU19TWVNURU1fTUVOVShtZW51KSApKTsKCiAgICBpdGVtID0gJm1lbnUtPml0ZW1zW21lbnUtPkZvY3VzZWRJdGVtXTsKICAgIHJlY3QgPSBpdGVtLT5yZWN0OwoKICAgIC8qIGNvcnJlY3QgaXRlbSBpZiBtb2RpZmllZCBhcyBhIHJlYWN0aW9uIHRvIFdNX0lOSVRNRU5VUE9QVVAgbWVzc2FnZSAqLwogICAgaWYgKCEoaXRlbS0+ZlN0YXRlICYgTUZfSElMSVRFKSkKICAgIHsKICAgICAgICBpZiAobWVudS0+d0ZsYWdzICYgTUZfUE9QVVApIGhkYyA9IEdldERDKCBtZW51LT5oV25kICk7CiAgICAgICAgZWxzZSBoZGMgPSBHZXREQ0V4KCBtZW51LT5oV25kLCAwLCBEQ1hfQ0FDSEUgfCBEQ1hfV0lORE9XKTsKCiAgICAgICAgU2VsZWN0T2JqZWN0KCBoZGMsIGhNZW51Rm9udCk7CgogICAgICAgIGl0ZW0tPmZTdGF0ZSB8PSBNRl9ISUxJVEU7CiAgICAgICAgTUVOVV9EcmF3TWVudUl0ZW0oIG1lbnUtPmhXbmQsIGhtZW51LCBod25kT3duZXIsIGhkYywgaXRlbSwgbWVudS0+SGVpZ2h0LCAhKG1lbnUtPndGbGFncyAmIE1GX1BPUFVQKSwgT0RBX0RSQVdFTlRJUkUgKTsKCVJlbGVhc2VEQyggbWVudS0+aFduZCwgaGRjICk7CiAgICB9CiAgICBpZiAoIWl0ZW0tPnJlY3QudG9wICYmICFpdGVtLT5yZWN0LmxlZnQgJiYgIWl0ZW0tPnJlY3QuYm90dG9tICYmICFpdGVtLT5yZWN0LnJpZ2h0KQogICAgICBpdGVtLT5yZWN0ID0gcmVjdDsKCiAgICBpdGVtLT5mU3RhdGUgfD0gTUZfTU9VU0VTRUxFQ1Q7CgogICAgaWYgKElTX1NZU1RFTV9NRU5VKG1lbnUpKQogICAgewoJTUVOVV9Jbml0U3lzTWVudVBvcHVwKGl0ZW0tPmhTdWJNZW51LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBHZXRXaW5kb3dMb25nVyggbWVudS0+aFduZCwgR1dMX1NUWUxFICksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdldENsYXNzTG9uZ1coIG1lbnUtPmhXbmQsIEdDTF9TVFlMRSkpOwoKCU5DX0dldFN5c1BvcHVwUG9zKCBtZW51LT5oV25kLCAmcmVjdCApOwoJcmVjdC50b3AgPSByZWN0LmJvdHRvbTsKCXJlY3QucmlnaHQgPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYU0laRSk7CiAgICAgICAgcmVjdC5ib3R0b20gPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU0laRSk7CiAgICB9CiAgICBlbHNlCiAgICB7CiAgICAgICAgR2V0V2luZG93UmVjdCggbWVudS0+aFduZCwgJnJlY3QgKTsKCWlmIChtZW51LT53RmxhZ3MgJiBNRl9QT1BVUCkKCXsKCSAgICByZWN0LmxlZnQgKz0gaXRlbS0+cmVjdC5yaWdodCAtIEdldFN5c3RlbU1ldHJpY3MoU01fQ1hCT1JERVIpOwoJICAgIHJlY3QudG9wICs9IGl0ZW0tPnJlY3QudG9wOwoJICAgIHJlY3QucmlnaHQgPSBpdGVtLT5yZWN0LmxlZnQgLSBpdGVtLT5yZWN0LnJpZ2h0ICsgR2V0U3lzdGVtTWV0cmljcyhTTV9DWEJPUkRFUik7CgkgICAgcmVjdC5ib3R0b20gPSBpdGVtLT5yZWN0LnRvcCAtIGl0ZW0tPnJlY3QuYm90dG9tOwoJfQoJZWxzZQoJewoJICAgIHJlY3QubGVmdCArPSBpdGVtLT5yZWN0LmxlZnQ7CgkgICAgcmVjdC50b3AgKz0gaXRlbS0+cmVjdC5ib3R0b207CgkgICAgcmVjdC5yaWdodCA9IGl0ZW0tPnJlY3QucmlnaHQgLSBpdGVtLT5yZWN0LmxlZnQ7CgkgICAgcmVjdC5ib3R0b20gPSBpdGVtLT5yZWN0LmJvdHRvbSAtIGl0ZW0tPnJlY3QudG9wOwoJfQogICAgfQoKICAgIE1FTlVfU2hvd1BvcHVwKCBod25kT3duZXIsIGl0ZW0tPmhTdWJNZW51LCBtZW51LT5Gb2N1c2VkSXRlbSwKCQkgICAgcmVjdC5sZWZ0LCByZWN0LnRvcCwgcmVjdC5yaWdodCwgcmVjdC5ib3R0b20gKTsKICAgIGlmIChzZWxlY3RGaXJzdCkKICAgICAgICBNRU5VX01vdmVTZWxlY3Rpb24oIGh3bmRPd25lciwgaXRlbS0+aFN1Yk1lbnUsIElURU1fTkVYVCApOwogICAgcmV0dXJuIGl0ZW0tPmhTdWJNZW51Owp9CgoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgTUVOVV9Jc01lbnVBY3RpdmUKICovCkhXTkQgTUVOVV9Jc01lbnVBY3RpdmUodm9pZCkKewogICAgcmV0dXJuIHRvcF9wb3B1cDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX1B0TWVudQogKgogKiBXYWxrcyBtZW51IGNoYWluIHRyeWluZyB0byBmaW5kIGEgbWVudSBwdCBtYXBzIHRvLgogKi8Kc3RhdGljIEhNRU5VIE1FTlVfUHRNZW51KCBITUVOVSBoTWVudSwgUE9JTlQgcHQgKQp7CiAgIFBPUFVQTUVOVSAqbWVudSA9IE1FTlVfR2V0TWVudSggaE1lbnUgKTsKICAgVUlOVCBpdGVtID0gbWVudS0+Rm9jdXNlZEl0ZW07CiAgIEhNRU5VIHJldDsKCiAgIC8qIHRyeSBzdWJwb3B1cCBmaXJzdCAoaWYgYW55KSAqLwogICByZXQgPSAoaXRlbSAhPSBOT19TRUxFQ1RFRF9JVEVNICYmCiAgICAgICAgICAobWVudS0+aXRlbXNbaXRlbV0uZlR5cGUgJiBNRl9QT1BVUCkgJiYKICAgICAgICAgIChtZW51LT5pdGVtc1tpdGVtXS5mU3RhdGUgJiBNRl9NT1VTRVNFTEVDVCkpCiAgICAgICAgPyBNRU5VX1B0TWVudShtZW51LT5pdGVtc1tpdGVtXS5oU3ViTWVudSwgcHQpIDogMDsKCiAgIGlmICghcmV0KSAgLyogY2hlY2sgdGhlIGN1cnJlbnQgd2luZG93IChhdm9pZGluZyBXTV9ISVRURVNUKSAqLwogICB7CiAgICAgICBJTlQgaHQgPSBOQ19IYW5kbGVOQ0hpdFRlc3QoIG1lbnUtPmhXbmQsIHB0ICk7CiAgICAgICBpZiggbWVudS0+d0ZsYWdzICYgTUZfUE9QVVAgKQogICAgICAgewogICAgICAgICAgIGlmIChodCAhPSBIVE5PV0hFUkUgJiYgaHQgIT0gSFRFUlJPUikgcmV0ID0gaE1lbnU7CiAgICAgICB9CiAgICAgICBlbHNlIGlmIChodCA9PSBIVFNZU01FTlUpCiAgICAgICAgICAgcmV0ID0gZ2V0X3dpbl9zeXNfbWVudSggbWVudS0+aFduZCApOwogICAgICAgZWxzZSBpZiAoaHQgPT0gSFRNRU5VKQogICAgICAgICAgIHJldCA9IEdldE1lbnUoIG1lbnUtPmhXbmQgKTsKICAgfQogICByZXR1cm4gcmV0Owp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfRXhlY0ZvY3VzZWRJdGVtCiAqCiAqIEV4ZWN1dGUgYSBtZW51IGl0ZW0gKGZvciBpbnN0YW5jZSB3aGVuIHVzZXIgcHJlc3NlZCBFbnRlcikuCiAqIFJldHVybiB0aGUgd0lEIG9mIHRoZSBleGVjdXRlZCBpdGVtLiBPdGhlcndpc2UsIC0xIGluZGljYXRpbmcKICogdGhhdCBubyBtZW51IGl0ZW0gd2FzIGV4ZWN1dGVkOwogKiBIYXZlIHRvIHJlY2VpdmUgdGhlIGZsYWdzIGZvciB0aGUgVHJhY2tQb3B1cE1lbnUgb3B0aW9ucyB0byBhdm9pZAogKiBzZW5kaW5nIHVud2FudGVkIG1lc3NhZ2UuCiAqCiAqLwpzdGF0aWMgSU5UIE1FTlVfRXhlY0ZvY3VzZWRJdGVtKCBNVFJBQ0tFUiogcG10LCBITUVOVSBoTWVudSwgVUlOVCB3RmxhZ3MgKQp7CiAgICBNRU5VSVRFTSAqaXRlbTsKICAgIFBPUFVQTUVOVSAqbWVudSA9IE1FTlVfR2V0TWVudSggaE1lbnUgKTsKCiAgICBUUkFDRSgiJXAgaG1lbnU9JXBcbiIsIHBtdCwgaE1lbnUpOwoKICAgIGlmICghbWVudSB8fCAhbWVudS0+bkl0ZW1zIHx8CgkobWVudS0+Rm9jdXNlZEl0ZW0gPT0gTk9fU0VMRUNURURfSVRFTSkpIHJldHVybiAtMTsKCiAgICBpdGVtID0gJm1lbnUtPml0ZW1zW21lbnUtPkZvY3VzZWRJdGVtXTsKCiAgICBUUkFDRSgiJXAgJTA4eCAlcFxuIiwgaE1lbnUsIGl0ZW0tPndJRCwgaXRlbS0+aFN1Yk1lbnUpOwoKICAgIGlmICghKGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApKQogICAgewoJaWYgKCEoaXRlbS0+ZlN0YXRlICYgKE1GX0dSQVlFRCB8IE1GX0RJU0FCTEVEKSkgJiYgIShpdGVtLT5mVHlwZSAmIE1GX1NFUEFSQVRPUikpCgl7CgkgICAgLyogSWYgVFBNX1JFVFVSTkNNRCBpcyBzZXQgeW91IHJldHVybiB0aGUgaWQsIGJ1dAoJICAgICAgIGRvIG5vdCBzZW5kIGEgbWVzc2FnZSB0byB0aGUgb3duZXIgKi8KCSAgICBpZighKHdGbGFncyAmIFRQTV9SRVRVUk5DTUQpKQoJICAgIHsKCQlpZiggbWVudS0+d0ZsYWdzICYgTUZfU1lTTUVOVSApCgkJICAgIFBvc3RNZXNzYWdlVyggcG10LT5oT3duZXJXbmQsIFdNX1NZU0NPTU1BTkQsIGl0ZW0tPndJRCwKCQkJCSAgTUFLRUxQQVJBTSgoSU5UMTYpcG10LT5wdC54LCAoSU5UMTYpcG10LT5wdC55KSApOwoJCWVsc2UKCQkgICAgUG9zdE1lc3NhZ2VXKCBwbXQtPmhPd25lclduZCwgV01fQ09NTUFORCwgaXRlbS0+d0lELCAwICk7CgkgICAgfQoJICAgIHJldHVybiBpdGVtLT53SUQ7Cgl9CiAgICB9CiAgICBlbHNlCglwbXQtPmhDdXJyZW50TWVudSA9IE1FTlVfU2hvd1N1YlBvcHVwKHBtdC0+aE93bmVyV25kLCBoTWVudSwgVFJVRSwgd0ZsYWdzKTsKCiAgICByZXR1cm4gLTE7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9Td2l0Y2hUcmFja2luZwogKgogKiBIZWxwZXIgZnVuY3Rpb24gZm9yIG1lbnUgbmF2aWdhdGlvbiByb3V0aW5lcy4KICovCnN0YXRpYyB2b2lkIE1FTlVfU3dpdGNoVHJhY2tpbmcoIE1UUkFDS0VSKiBwbXQsIEhNRU5VIGhQdE1lbnUsIFVJTlQgaWQgKQp7CiAgICBQT1BVUE1FTlUgKnB0bWVudSA9IE1FTlVfR2V0TWVudSggaFB0TWVudSApOwogICAgUE9QVVBNRU5VICp0b3BtZW51ID0gTUVOVV9HZXRNZW51KCBwbXQtPmhUb3BNZW51ICk7CgogICAgVFJBQ0UoIiVwIGhtZW51PSVwIDB4JTA0eFxuIiwgcG10LCBoUHRNZW51LCBpZCk7CgogICAgaWYoIHBtdC0+aFRvcE1lbnUgIT0gaFB0TWVudSAmJgoJISgocHRtZW51LT53RmxhZ3MgfCB0b3BtZW51LT53RmxhZ3MpICYgTUZfUE9QVVApICkKICAgIHsKCS8qIGJvdGggYXJlIHRvcCBsZXZlbCBtZW51cyAoc3lzdGVtIGFuZCBtZW51LWJhcikgKi8KCU1FTlVfSGlkZVN1YlBvcHVwcyggcG10LT5oT3duZXJXbmQsIHBtdC0+aFRvcE1lbnUsIEZBTFNFICk7CglNRU5VX1NlbGVjdEl0ZW0oIHBtdC0+aE93bmVyV25kLCBwbXQtPmhUb3BNZW51LCBOT19TRUxFQ1RFRF9JVEVNLCBGQUxTRSwgMCApOwogICAgICAgIHBtdC0+aFRvcE1lbnUgPSBoUHRNZW51OwogICAgfQogICAgZWxzZSBNRU5VX0hpZGVTdWJQb3B1cHMoIHBtdC0+aE93bmVyV25kLCBoUHRNZW51LCBGQUxTRSApOwogICAgTUVOVV9TZWxlY3RJdGVtKCBwbXQtPmhPd25lclduZCwgaFB0TWVudSwgaWQsIFRSVUUsIDAgKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9CdXR0b25Eb3duCiAqCiAqIFJldHVybiBUUlVFIGlmIHdlIGNhbiBnbyBvbiB3aXRoIG1lbnUgdHJhY2tpbmcuCiAqLwpzdGF0aWMgQk9PTCBNRU5VX0J1dHRvbkRvd24oIE1UUkFDS0VSKiBwbXQsIEhNRU5VIGhQdE1lbnUsIFVJTlQgd0ZsYWdzICkKewogICAgVFJBQ0UoIiVwIGhQdE1lbnU9JXBcbiIsIHBtdCwgaFB0TWVudSk7CgogICAgaWYgKGhQdE1lbnUpCiAgICB7CglVSU5UIGlkID0gMDsKCVBPUFVQTUVOVSAqcHRtZW51ID0gTUVOVV9HZXRNZW51KCBoUHRNZW51ICk7CglNRU5VSVRFTSAqaXRlbTsKCglpZiggSVNfU1lTVEVNX01FTlUocHRtZW51KSApCgkgICAgaXRlbSA9IHB0bWVudS0+aXRlbXM7CgllbHNlCgkgICAgaXRlbSA9IE1FTlVfRmluZEl0ZW1CeUNvb3JkcyggcHRtZW51LCBwbXQtPnB0LCAmaWQgKTsKCglpZiggaXRlbSApCgl7CgkgICAgaWYoIHB0bWVudS0+Rm9jdXNlZEl0ZW0gIT0gaWQgKQoJCU1FTlVfU3dpdGNoVHJhY2tpbmcoIHBtdCwgaFB0TWVudSwgaWQgKTsKCgkgICAgLyogSWYgdGhlIHBvcHVwIG1lbnUgaXMgbm90IGFscmVhZHkgInBvcHBlZCIgKi8KCSAgICBpZighKGl0ZW0tPmZTdGF0ZSAmIE1GX01PVVNFU0VMRUNUICkpCgkgICAgewoJCXBtdC0+aEN1cnJlbnRNZW51ID0gTUVOVV9TaG93U3ViUG9wdXAoIHBtdC0+aE93bmVyV25kLCBoUHRNZW51LCBGQUxTRSwgd0ZsYWdzICk7CgkgICAgfQoKCSAgICByZXR1cm4gVFJVRTsKCX0KCS8qIEVsc2UgdGhlIGNsaWNrIHdhcyBvbiB0aGUgbWVudSBiYXIsIGZpbmlzaCB0aGUgdHJhY2tpbmcgKi8KICAgIH0KICAgIHJldHVybiBGQUxTRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0J1dHRvblVwCiAqCiAqIFJldHVybiB0aGUgdmFsdWUgb2YgTUVOVV9FeGVjRm9jdXNlZEl0ZW0gaWYKICogdGhlIHNlbGVjdGVkIGl0ZW0gd2FzIG5vdCBhIHBvcHVwLiBFbHNlIG9wZW4gdGhlIHBvcHVwLgogKiBBIC0xIHJldHVybiB2YWx1ZSBpbmRpY2F0ZXMgdGhhdCB3ZSBnbyBvbiB3aXRoIG1lbnUgdHJhY2tpbmcuCiAqCiAqLwpzdGF0aWMgSU5UIE1FTlVfQnV0dG9uVXAoIE1UUkFDS0VSKiBwbXQsIEhNRU5VIGhQdE1lbnUsIFVJTlQgd0ZsYWdzKQp7CiAgICBUUkFDRSgiJXAgaG1lbnU9JXBcbiIsIHBtdCwgaFB0TWVudSk7CgogICAgaWYgKGhQdE1lbnUpCiAgICB7CglVSU5UIGlkID0gMDsKCVBPUFVQTUVOVSAqcHRtZW51ID0gTUVOVV9HZXRNZW51KCBoUHRNZW51ICk7CglNRU5VSVRFTSAqaXRlbTsKCiAgICAgICAgaWYoIElTX1NZU1RFTV9NRU5VKHB0bWVudSkgKQogICAgICAgICAgICBpdGVtID0gcHRtZW51LT5pdGVtczsKICAgICAgICBlbHNlCiAgICAgICAgICAgIGl0ZW0gPSBNRU5VX0ZpbmRJdGVtQnlDb29yZHMoIHB0bWVudSwgcG10LT5wdCwgJmlkICk7CgoJaWYoIGl0ZW0gJiYgKHB0bWVudS0+Rm9jdXNlZEl0ZW0gPT0gaWQgKSkKCXsKCSAgICBpZiggIShpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKSApCgkJcmV0dXJuIE1FTlVfRXhlY0ZvY3VzZWRJdGVtKCBwbXQsIGhQdE1lbnUsIHdGbGFncyk7CgoJICAgIC8qIElmIHdlIGFyZSBkZWFsaW5nIHdpdGggdGhlIHRvcC1sZXZlbCBtZW51ICAgICAgICAgICAgKi8KCSAgICAvKiBhbmQgdGhpcyBpcyBhIGNsaWNrIG9uIGFuIGFscmVhZHkgInBvcHBlZCIgaXRlbTogICAgICovCgkgICAgLyogU3RvcCB0aGUgbWVudSB0cmFja2luZyBhbmQgY2xvc2UgdGhlIG9wZW5lZCBzdWJtZW51cyAqLwoJICAgIGlmKChwbXQtPmhUb3BNZW51ID09IGhQdE1lbnUpICYmIHB0bWVudS0+YlRpbWVUb0hpZGUpCgkJcmV0dXJuIDA7Cgl9CglwdG1lbnUtPmJUaW1lVG9IaWRlID0gVFJVRTsKICAgIH0KICAgIHJldHVybiAtMTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9Nb3VzZU1vdmUKICoKICogUmV0dXJuIFRSVUUgaWYgd2UgY2FuIGdvIG9uIHdpdGggbWVudSB0cmFja2luZy4KICovCnN0YXRpYyBCT09MIE1FTlVfTW91c2VNb3ZlKCBNVFJBQ0tFUiogcG10LCBITUVOVSBoUHRNZW51LCBVSU5UIHdGbGFncyApCnsKICAgIFVJTlQgaWQgPSBOT19TRUxFQ1RFRF9JVEVNOwogICAgUE9QVVBNRU5VICpwdG1lbnUgPSBOVUxMOwoKICAgIGlmKCBoUHRNZW51ICkKICAgIHsKCXB0bWVudSA9IE1FTlVfR2V0TWVudSggaFB0TWVudSApOwogICAgICAgIGlmKCBJU19TWVNURU1fTUVOVShwdG1lbnUpICkKCSAgICBpZCA9IDA7CiAgICAgICAgZWxzZQogICAgICAgICAgICBNRU5VX0ZpbmRJdGVtQnlDb29yZHMoIHB0bWVudSwgcG10LT5wdCwgJmlkICk7CiAgICB9CgogICAgaWYoIGlkID09IE5PX1NFTEVDVEVEX0lURU0gKQogICAgewoJTUVOVV9TZWxlY3RJdGVtKCBwbXQtPmhPd25lclduZCwgcG10LT5oQ3VycmVudE1lbnUsCgkJCSBOT19TRUxFQ1RFRF9JVEVNLCBUUlVFLCBwbXQtPmhUb3BNZW51KTsKCiAgICB9CiAgICBlbHNlIGlmKCBwdG1lbnUtPkZvY3VzZWRJdGVtICE9IGlkICkKICAgIHsKCSAgICBNRU5VX1N3aXRjaFRyYWNraW5nKCBwbXQsIGhQdE1lbnUsIGlkICk7CgkgICAgcG10LT5oQ3VycmVudE1lbnUgPSBNRU5VX1Nob3dTdWJQb3B1cChwbXQtPmhPd25lclduZCwgaFB0TWVudSwgRkFMU0UsIHdGbGFncyk7CiAgICB9CiAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9TZXRDYXB0dXJlCiAqLwpzdGF0aWMgdm9pZCBNRU5VX1NldENhcHR1cmUoIEhXTkQgaHduZCApCnsKICAgIEhXTkQgcHJldmlvdXMgPSAwOwoKICAgIFNFUlZFUl9TVEFSVF9SRVEoIHNldF9jYXB0dXJlX3dpbmRvdyApCiAgICB7CiAgICAgICAgcmVxLT5oYW5kbGUgPSBod25kOwogICAgICAgIHJlcS0+ZmxhZ3MgID0gQ0FQVFVSRV9NRU5VOwogICAgICAgIGlmICghd2luZV9zZXJ2ZXJfY2FsbF9lcnIoIHJlcSApKQogICAgICAgIHsKICAgICAgICAgICAgcHJldmlvdXMgPSByZXBseS0+cHJldmlvdXM7CiAgICAgICAgICAgIGh3bmQgPSByZXBseS0+ZnVsbF9oYW5kbGU7CiAgICAgICAgfQogICAgfQogICAgU0VSVkVSX0VORF9SRVE7CgogICAgaWYgKHByZXZpb3VzICYmIHByZXZpb3VzICE9IGh3bmQpCiAgICAgICAgU2VuZE1lc3NhZ2VXKCBwcmV2aW91cywgV01fQ0FQVFVSRUNIQU5HRUQsIDAsIChMUEFSQU0paHduZCApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0RvTmV4dE1lbnUKICoKICogTk9URTogV01fTkVYVE1FTlUgZG9jdW1lbnRlZCBpbiBXaW4zMiBpcyBhIGJpdCBkaWZmZXJlbnQuCiAqLwpzdGF0aWMgTFJFU1VMVCBNRU5VX0RvTmV4dE1lbnUoIE1UUkFDS0VSKiBwbXQsIFVJTlQgdmsgKQp7CiAgICBQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoIHBtdC0+aFRvcE1lbnUgKTsKCiAgICBpZiggKHZrID09IFZLX0xFRlQgJiYgIG1lbnUtPkZvY3VzZWRJdGVtID09IDAgKSB8fAogICAgICAgICh2ayA9PSBWS19SSUdIVCAmJiBtZW51LT5Gb2N1c2VkSXRlbSA9PSBtZW51LT5uSXRlbXMgLSAxKSkKICAgIHsKICAgICAgICBNRElORVhUTUVOVSBuZXh0X21lbnU7CglITUVOVSBoTmV3TWVudTsKCUhXTkQgIGhOZXdXbmQ7CglVSU5UICBpZCA9IDA7CgogICAgICAgIG5leHRfbWVudS5obWVudUluID0gKElTX1NZU1RFTV9NRU5VKG1lbnUpKSA/IEdldFN1Yk1lbnUocG10LT5oVG9wTWVudSwwKSA6IHBtdC0+aFRvcE1lbnU7CiAgICAgICAgbmV4dF9tZW51LmhtZW51TmV4dCA9IDA7CiAgICAgICAgbmV4dF9tZW51Lmh3bmROZXh0ID0gMDsKICAgICAgICBTZW5kTWVzc2FnZVcoIHBtdC0+aE93bmVyV25kLCBXTV9ORVhUTUVOVSwgdmssIChMUEFSQU0pJm5leHRfbWVudSApOwoKICAgICAgICBUUkFDRSgiJXAgWyVwXSAtPiAlcCBbJXBdXG4iLAogICAgICAgICAgICAgIHBtdC0+aEN1cnJlbnRNZW51LCBwbXQtPmhPd25lclduZCwgbmV4dF9tZW51LmhtZW51TmV4dCwgbmV4dF9tZW51Lmh3bmROZXh0ICk7CgoJaWYgKCFuZXh0X21lbnUuaG1lbnVOZXh0IHx8ICFuZXh0X21lbnUuaHduZE5leHQpCgl7CiAgICAgICAgICAgIERXT1JEIHN0eWxlID0gR2V0V2luZG93TG9uZ1coIHBtdC0+aE93bmVyV25kLCBHV0xfU1RZTEUgKTsKCSAgICBoTmV3V25kID0gcG10LT5oT3duZXJXbmQ7CgkgICAgaWYoIElTX1NZU1RFTV9NRU5VKG1lbnUpICkKCSAgICB7CgkJLyogc3dpdGNoIHRvIHRoZSBtZW51IGJhciAqLwoKICAgICAgICAgICAgICAgIGlmKHN0eWxlICYgV1NfQ0hJTEQgfHwgIShoTmV3TWVudSA9IEdldE1lbnUoaE5ld1duZCkpKSByZXR1cm4gRkFMU0U7CgoJICAgICAgICBpZiggdmsgPT0gVktfTEVGVCApCgkgICAgICAgIHsKCQkgICAgbWVudSA9IE1FTlVfR2V0TWVudSggaE5ld01lbnUgKTsKCQkgICAgaWQgPSBtZW51LT5uSXRlbXMgLSAxOwoJICAgICAgICB9CgkgICAgfQoJICAgIGVsc2UgaWYgKHN0eWxlICYgV1NfU1lTTUVOVSApCgkgICAgewoJCS8qIHN3aXRjaCB0byB0aGUgc3lzdGVtIG1lbnUgKi8KCSAgICAgICAgaE5ld01lbnUgPSBnZXRfd2luX3N5c19tZW51KCBoTmV3V25kICk7CgkgICAgfQogICAgICAgICAgICBlbHNlIHJldHVybiBGQUxTRTsKCX0KCWVsc2UgICAgLyogYXBwbGljYXRpb24gcmV0dXJuZWQgYSBuZXcgbWVudSB0byBzd2l0Y2ggdG8gKi8KCXsKICAgICAgICAgICAgaE5ld01lbnUgPSBuZXh0X21lbnUuaG1lbnVOZXh0OwogICAgICAgICAgICBoTmV3V25kID0gV0lOX0dldEZ1bGxIYW5kbGUoIG5leHRfbWVudS5od25kTmV4dCApOwoKCSAgICBpZiggSXNNZW51KGhOZXdNZW51KSAmJiBJc1dpbmRvdyhoTmV3V25kKSApCgkgICAgewogICAgICAgICAgICAgICAgRFdPUkQgc3R5bGUgPSBHZXRXaW5kb3dMb25nVyggaE5ld1duZCwgR1dMX1NUWUxFICk7CgoJCWlmIChzdHlsZSAmIFdTX1NZU01FTlUgJiYKCQkgICAgR2V0U3ViTWVudShnZXRfd2luX3N5c19tZW51KGhOZXdXbmQpLCAwKSA9PSBoTmV3TWVudSApCgkJewoJICAgICAgICAgICAgLyogZ2V0IHRoZSByZWFsIHN5c3RlbSBtZW51ICovCgkJICAgIGhOZXdNZW51ID0gIGdldF93aW5fc3lzX21lbnUoaE5ld1duZCk7CgkJfQoJICAgICAgICBlbHNlIGlmIChzdHlsZSAmIFdTX0NISUxEIHx8IEdldE1lbnUoaE5ld1duZCkgIT0gaE5ld01lbnUgKQoJCXsKCQkgICAgLyogRklYTUU6IE5vdCBzdXJlIHdoYXQgdG8gZG8gaGVyZTsKCQkgICAgICogcGVyaGFwcyB0cnkgdG8gdHJhY2sgaE5ld01lbnUgYXMgYSBwb3B1cD8gKi8KCgkJICAgIFRSQUNFKCIgLS0gZ290IGNvbmZ1c2VkLlxuIik7CgkJICAgIHJldHVybiBGQUxTRTsKCQl9CgkgICAgfQoJICAgIGVsc2UgcmV0dXJuIEZBTFNFOwoJfQoKCWlmKCBoTmV3TWVudSAhPSBwbXQtPmhUb3BNZW51ICkKCXsKCSAgICBNRU5VX1NlbGVjdEl0ZW0oIHBtdC0+aE93bmVyV25kLCBwbXQtPmhUb3BNZW51LCBOT19TRUxFQ1RFRF9JVEVNLAogICAgICAgICAgICAgICAgICAgIEZBTFNFLCAwICk7CgkgICAgaWYoIHBtdC0+aEN1cnJlbnRNZW51ICE9IHBtdC0+aFRvcE1lbnUgKQoJCU1FTlVfSGlkZVN1YlBvcHVwcyggcG10LT5oT3duZXJXbmQsIHBtdC0+aFRvcE1lbnUsIEZBTFNFICk7Cgl9CgoJaWYoIGhOZXdXbmQgIT0gcG10LT5oT3duZXJXbmQgKQoJewoJICAgIHBtdC0+aE93bmVyV25kID0gaE5ld1duZDsKCSAgICBNRU5VX1NldENhcHR1cmUoIHBtdC0+aE93bmVyV25kICk7Cgl9CgoJcG10LT5oVG9wTWVudSA9IHBtdC0+aEN1cnJlbnRNZW51ID0gaE5ld01lbnU7IC8qIGFsbCBzdWJwb3B1cHMgYXJlIGhpZGRlbiAqLwoJTUVOVV9TZWxlY3RJdGVtKCBwbXQtPmhPd25lclduZCwgcG10LT5oVG9wTWVudSwgaWQsIFRSVUUsIDAgKTsKCglyZXR1cm4gVFJVRTsKICAgIH0KICAgIHJldHVybiBGQUxTRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX1N1c3BlbmRQb3B1cAogKgogKiBUaGUgaWRlYSBpcyBub3QgdG8gc2hvdyB0aGUgcG9wdXAgaWYgdGhlIG5leHQgaW5wdXQgbWVzc2FnZSBpcwogKiBnb2luZyB0byBoaWRlIGl0IGFueXdheS4KICovCnN0YXRpYyBCT09MIE1FTlVfU3VzcGVuZFBvcHVwKCBNVFJBQ0tFUiogcG10LCBVSU5UMTYgdU1zZyApCnsKICAgIE1TRyBtc2c7CgogICAgbXNnLmh3bmQgPSBwbXQtPmhPd25lclduZDsKCiAgICBQZWVrTWVzc2FnZVcoICZtc2csIDAsIDAsIDAsIFBNX05PWUlFTEQgfCBQTV9SRU1PVkUpOwogICAgcG10LT50cmFja0ZsYWdzIHw9IFRGX1NLSVBSRU1PVkU7CgogICAgc3dpdGNoKCB1TXNnICkKICAgIHsKCWNhc2UgV01fS0VZRE9XTjoKCSAgICAgUGVla01lc3NhZ2VXKCAmbXNnLCAwLCAwLCAwLCBQTV9OT1lJRUxEIHwgUE1fTk9SRU1PVkUpOwoJICAgICBpZiggbXNnLm1lc3NhZ2UgPT0gV01fS0VZVVAgfHwgbXNnLm1lc3NhZ2UgPT0gV01fUEFJTlQgKQoJICAgICB7CgkJIFBlZWtNZXNzYWdlVyggJm1zZywgMCwgMCwgMCwgUE1fTk9ZSUVMRCB8IFBNX1JFTU9WRSk7CgkgICAgICAgICBQZWVrTWVzc2FnZVcoICZtc2csIDAsIDAsIDAsIFBNX05PWUlFTEQgfCBQTV9OT1JFTU9WRSk7CgkgICAgICAgICBpZiggbXNnLm1lc3NhZ2UgPT0gV01fS0VZRE9XTiAmJgoJCSAgICAobXNnLndQYXJhbSA9PSBWS19MRUZUIHx8IG1zZy53UGFyYW0gPT0gVktfUklHSFQpKQoJICAgICAgICAgewoJCSAgICAgcG10LT50cmFja0ZsYWdzIHw9IFRGX1NVU1BFTkRQT1BVUDsKCQkgICAgIHJldHVybiBUUlVFOwoJICAgICAgICAgfQoJICAgICB9CgkgICAgIGJyZWFrOwogICAgfQoKICAgIC8qIGZhaWx1cmVzIGdvIHRocm91Z2ggdGhpcyAqLwogICAgcG10LT50cmFja0ZsYWdzICY9IH5URl9TVVNQRU5EUE9QVVA7CiAgICByZXR1cm4gRkFMU0U7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9LZXlFc2NhcGUKICoKICogSGFuZGxlIGEgVktfRVNDQVBFIGtleSBldmVudCBpbiBhIG1lbnUuCiAqLwpzdGF0aWMgQk9PTCBNRU5VX0tleUVzY2FwZShNVFJBQ0tFUiogcG10LCBVSU5UIHdGbGFncykKewogICAgQk9PTCBiRW5kTWVudSA9IFRSVUU7CgogICAgaWYgKHBtdC0+aEN1cnJlbnRNZW51ICE9IHBtdC0+aFRvcE1lbnUpCiAgICB7CiAgICAgICAgUE9QVVBNRU5VICptZW51ID0gTUVOVV9HZXRNZW51KHBtdC0+aEN1cnJlbnRNZW51KTsKCiAgICAgICAgaWYgKG1lbnUtPndGbGFncyAmIE1GX1BPUFVQKQogICAgICAgIHsKICAgICAgICAgICAgSE1FTlUgaG1lbnV0bXAsIGhtZW51cHJldjsKCiAgICAgICAgICAgIGhtZW51cHJldiA9IGhtZW51dG1wID0gcG10LT5oVG9wTWVudTsKCiAgICAgICAgICAgIC8qIGNsb3NlIHRvcG1vc3QgcG9wdXAgKi8KICAgICAgICAgICAgd2hpbGUgKGhtZW51dG1wICE9IHBtdC0+aEN1cnJlbnRNZW51KQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBobWVudXByZXYgPSBobWVudXRtcDsKICAgICAgICAgICAgICAgIGhtZW51dG1wID0gTUVOVV9HZXRTdWJQb3B1cCggaG1lbnVwcmV2ICk7CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgIE1FTlVfSGlkZVN1YlBvcHVwcyggcG10LT5oT3duZXJXbmQsIGhtZW51cHJldiwgVFJVRSApOwogICAgICAgICAgICBwbXQtPmhDdXJyZW50TWVudSA9IGhtZW51cHJldjsKICAgICAgICAgICAgYkVuZE1lbnUgPSBGQUxTRTsKICAgICAgICB9CiAgICB9CgogICAgcmV0dXJuIGJFbmRNZW51Owp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfS2V5TGVmdAogKgogKiBIYW5kbGUgYSBWS19MRUZUIGtleSBldmVudCBpbiBhIG1lbnUuCiAqLwpzdGF0aWMgdm9pZCBNRU5VX0tleUxlZnQoIE1UUkFDS0VSKiBwbXQsIFVJTlQgd0ZsYWdzICkKewogICAgUE9QVVBNRU5VICptZW51OwogICAgSE1FTlUgaG1lbnV0bXAsIGhtZW51cHJldjsKICAgIFVJTlQgIHByZXZjb2w7CgogICAgaG1lbnVwcmV2ID0gaG1lbnV0bXAgPSBwbXQtPmhUb3BNZW51OwogICAgbWVudSA9IE1FTlVfR2V0TWVudSggaG1lbnV0bXAgKTsKCiAgICAvKiBUcnkgdG8gbW92ZSAxIGNvbHVtbiBsZWZ0IChpZiBwb3NzaWJsZSkgKi8KICAgIGlmKCAocHJldmNvbCA9IE1FTlVfR2V0U3RhcnRPZlByZXZDb2x1bW4oIHBtdC0+aEN1cnJlbnRNZW51ICkpICE9CglOT19TRUxFQ1RFRF9JVEVNICkgewoKCU1FTlVfU2VsZWN0SXRlbSggcG10LT5oT3duZXJXbmQsIHBtdC0+aEN1cnJlbnRNZW51LAoJCQkgcHJldmNvbCwgVFJVRSwgMCApOwoJcmV0dXJuOwogICAgfQoKICAgIC8qIGNsb3NlIHRvcG1vc3QgcG9wdXAgKi8KICAgIHdoaWxlIChobWVudXRtcCAhPSBwbXQtPmhDdXJyZW50TWVudSkKICAgIHsKCWhtZW51cHJldiA9IGhtZW51dG1wOwoJaG1lbnV0bXAgPSBNRU5VX0dldFN1YlBvcHVwKCBobWVudXByZXYgKTsKICAgIH0KCiAgICBNRU5VX0hpZGVTdWJQb3B1cHMoIHBtdC0+aE93bmVyV25kLCBobWVudXByZXYsIFRSVUUgKTsKICAgIHBtdC0+aEN1cnJlbnRNZW51ID0gaG1lbnVwcmV2OwoKICAgIGlmICggKGhtZW51cHJldiA9PSBwbXQtPmhUb3BNZW51KSAmJiAhKG1lbnUtPndGbGFncyAmIE1GX1BPUFVQKSApCiAgICB7CgkvKiBtb3ZlIG1lbnUgYmFyIHNlbGVjdGlvbiBpZiBubyBtb3JlIHBvcHVwcyBhcmUgbGVmdCAqLwoKCWlmKCAhTUVOVV9Eb05leHRNZW51KCBwbXQsIFZLX0xFRlQpICkKCSAgICAgTUVOVV9Nb3ZlU2VsZWN0aW9uKCBwbXQtPmhPd25lclduZCwgcG10LT5oVG9wTWVudSwgSVRFTV9QUkVWICk7CgoJaWYgKCBobWVudXByZXYgIT0gaG1lbnV0bXAgfHwgcG10LT50cmFja0ZsYWdzICYgVEZfU1VTUEVORFBPUFVQICkKCXsKCSAgIC8qIEEgc3VibGV2ZWwgbWVudSB3YXMgZGlzcGxheWVkIC0gZGlzcGxheSB0aGUgbmV4dCBvbmUKCSAgICAqIHVubGVzcyB0aGVyZSBpcyBhbm90aGVyIGRpc3BsYWNlbWVudCBjb21pbmcgdXAgKi8KCgkgICAgaWYoICFNRU5VX1N1c3BlbmRQb3B1cCggcG10LCBXTV9LRVlET1dOICkgKQoJCXBtdC0+aEN1cnJlbnRNZW51ID0gTUVOVV9TaG93U3ViUG9wdXAocG10LT5oT3duZXJXbmQsCgkJCQkJCXBtdC0+aFRvcE1lbnUsIFRSVUUsIHdGbGFncyk7Cgl9CiAgICB9Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfS2V5UmlnaHQKICoKICogSGFuZGxlIGEgVktfUklHSFQga2V5IGV2ZW50IGluIGEgbWVudS4KICovCnN0YXRpYyB2b2lkIE1FTlVfS2V5UmlnaHQoIE1UUkFDS0VSKiBwbXQsIFVJTlQgd0ZsYWdzICkKewogICAgSE1FTlUgaG1lbnV0bXA7CiAgICBQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoIHBtdC0+aFRvcE1lbnUgKTsKICAgIFVJTlQgIG5leHRjb2w7CgogICAgVFJBQ0UoIk1FTlVfS2V5UmlnaHQgY2FsbGVkLCBjdXIgJXAgKCVzKSwgdG9wICVwICglcykuXG4iLAogICAgICAgICAgcG10LT5oQ3VycmVudE1lbnUsCiAgICAgICAgICBkZWJ1Z3N0cl93KChNRU5VX0dldE1lbnUocG10LT5oQ3VycmVudE1lbnUpKS0+aXRlbXNbMF0udGV4dCksCiAgICAgICAgICBwbXQtPmhUb3BNZW51LCBkZWJ1Z3N0cl93KG1lbnUtPml0ZW1zWzBdLnRleHQpICk7CgogICAgaWYgKCAobWVudS0+d0ZsYWdzICYgTUZfUE9QVVApIHx8IChwbXQtPmhDdXJyZW50TWVudSAhPSBwbXQtPmhUb3BNZW51KSkKICAgIHsKCS8qIElmIGFscmVhZHkgZGlzcGxheWluZyBhIHBvcHVwLCB0cnkgdG8gZGlzcGxheSBzdWItcG9wdXAgKi8KCglobWVudXRtcCA9IHBtdC0+aEN1cnJlbnRNZW51OwoJcG10LT5oQ3VycmVudE1lbnUgPSBNRU5VX1Nob3dTdWJQb3B1cChwbXQtPmhPd25lclduZCwgaG1lbnV0bXAsIFRSVUUsIHdGbGFncyk7CgoJLyogaWYgc3VicG9wdXAgd2FzIGRpc3BsYXllZCB0aGVuIHdlIGFyZSBkb25lICovCglpZiAoaG1lbnV0bXAgIT0gcG10LT5oQ3VycmVudE1lbnUpIHJldHVybjsKICAgIH0KCiAgICAvKiBDaGVjayB0byBzZWUgaWYgdGhlcmUncyBhbm90aGVyIGNvbHVtbiAqLwogICAgaWYoIChuZXh0Y29sID0gTUVOVV9HZXRTdGFydE9mTmV4dENvbHVtbiggcG10LT5oQ3VycmVudE1lbnUgKSkgIT0KCU5PX1NFTEVDVEVEX0lURU0gKSB7CglUUkFDRSgiR29pbmcgdG8gJWQuXG4iLCBuZXh0Y29sICk7CglNRU5VX1NlbGVjdEl0ZW0oIHBtdC0+aE93bmVyV25kLCBwbXQtPmhDdXJyZW50TWVudSwKCQkJIG5leHRjb2wsIFRSVUUsIDAgKTsKCXJldHVybjsKICAgIH0KCiAgICBpZiAoIShtZW51LT53RmxhZ3MgJiBNRl9QT1BVUCkpCS8qIG1lbnUgYmFyIHRyYWNraW5nICovCiAgICB7CglpZiggcG10LT5oQ3VycmVudE1lbnUgIT0gcG10LT5oVG9wTWVudSApCgl7CgkgICAgTUVOVV9IaWRlU3ViUG9wdXBzKCBwbXQtPmhPd25lclduZCwgcG10LT5oVG9wTWVudSwgRkFMU0UgKTsKCSAgICBobWVudXRtcCA9IHBtdC0+aEN1cnJlbnRNZW51ID0gcG10LT5oVG9wTWVudTsKCX0gZWxzZSBobWVudXRtcCA9IDA7CgoJLyogdHJ5IHRvIG1vdmUgdG8gdGhlIG5leHQgaXRlbSAqLwoJaWYoICFNRU5VX0RvTmV4dE1lbnUoIHBtdCwgVktfUklHSFQpICkKCSAgICAgTUVOVV9Nb3ZlU2VsZWN0aW9uKCBwbXQtPmhPd25lclduZCwgcG10LT5oVG9wTWVudSwgSVRFTV9ORVhUICk7CgoJaWYoIGhtZW51dG1wIHx8IHBtdC0+dHJhY2tGbGFncyAmIFRGX1NVU1BFTkRQT1BVUCApCgkgICAgaWYoICFNRU5VX1N1c3BlbmRQb3B1cChwbXQsIFdNX0tFWURPV04pICkKCQlwbXQtPmhDdXJyZW50TWVudSA9IE1FTlVfU2hvd1N1YlBvcHVwKHBtdC0+aE93bmVyV25kLAoJCQkJCQkgICAgICAgcG10LT5oVG9wTWVudSwgVFJVRSwgd0ZsYWdzKTsKICAgIH0KfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX1RyYWNrTWVudQogKgogKiBNZW51IHRyYWNraW5nIGNvZGUuCiAqLwpzdGF0aWMgQk9PTCBNRU5VX1RyYWNrTWVudSggSE1FTlUgaG1lbnUsIFVJTlQgd0ZsYWdzLCBJTlQgeCwgSU5UIHksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBIV05EIGh3bmQsIGNvbnN0IFJFQ1QgKmxwcmVjdCApCnsKICAgIE1TRyBtc2c7CiAgICBQT1BVUE1FTlUgKm1lbnU7CiAgICBCT09MIGZSZW1vdmU7CiAgICBJTlQgZXhlY3V0ZWRNZW51SWQgPSAtMTsKICAgIE1UUkFDS0VSIG10OwogICAgQk9PTCBlbnRlcklkbGVTZW50ID0gRkFMU0U7CgogICAgbXQudHJhY2tGbGFncyA9IDA7CiAgICBtdC5oQ3VycmVudE1lbnUgPSBobWVudTsKICAgIG10LmhUb3BNZW51ID0gaG1lbnU7CiAgICBtdC5oT3duZXJXbmQgPSBXSU5fR2V0RnVsbEhhbmRsZSggaHduZCApOwogICAgbXQucHQueCA9IHg7CiAgICBtdC5wdC55ID0geTsKCiAgICBUUkFDRSgiaG1lbnU9JXAgZmxhZ3M9MHglMDh4ICglZCwlZCkgaHduZD0lcCAoJWxkLCVsZCktKCVsZCwlbGQpXG4iLAogICAgICAgICAgaG1lbnUsIHdGbGFncywgeCwgeSwgaHduZCwgKGxwcmVjdCkgPyBscHJlY3QtPmxlZnQgOiAwLCAobHByZWN0KSA/IGxwcmVjdC0+dG9wIDogMCwKICAgICAgICAgIChscHJlY3QpID8gbHByZWN0LT5yaWdodCA6IDAsICAobHByZWN0KSA/IGxwcmVjdC0+Ym90dG9tIDogMCk7CgogICAgZkVuZE1lbnUgPSBGQUxTRTsKICAgIGlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoIGhtZW51ICkpKQogICAgewogICAgICAgIFdBUk4oIkludmFsaWQgbWVudSBoYW5kbGUgJXBcbiIsIGhtZW51KTsKICAgICAgICBTZXRMYXN0RXJyb3IoRVJST1JfSU5WQUxJRF9NRU5VX0hBTkRMRSk7CiAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgfQoKICAgIGlmICh3RmxhZ3MgJiBUUE1fQlVUVE9ORE9XTikKICAgIHsKCS8qIEdldCB0aGUgcmVzdWx0IGluIG9yZGVyIHRvIHN0YXJ0IHRoZSB0cmFja2luZyBvciBub3QgKi8KCWZSZW1vdmUgPSBNRU5VX0J1dHRvbkRvd24oICZtdCwgaG1lbnUsIHdGbGFncyApOwoJZkVuZE1lbnUgPSAhZlJlbW92ZTsKICAgIH0KCiAgICBpZiAod0ZsYWdzICYgVEZfRU5ETUVOVSkgZkVuZE1lbnUgPSBUUlVFOwoKICAgIE1FTlVfU2V0Q2FwdHVyZSggbXQuaE93bmVyV25kICk7CgogICAgd2hpbGUgKCFmRW5kTWVudSkKICAgIHsKCW1lbnUgPSBNRU5VX0dldE1lbnUoIG10LmhDdXJyZW50TWVudSApOwoJaWYgKCFtZW51KSAvKiBzb21ldGltZXMgaGFwcGVucyBpZiBJIGRvIGEgd2luZG93IG1hbmFnZXIgY2xvc2UgKi8KCSAgICBicmVhazsKCgkvKiB3ZSBoYXZlIHRvIGtlZXAgdGhlIG1lc3NhZ2UgaW4gdGhlIHF1ZXVlIHVudGlsIGl0J3MKCSAqIGNsZWFyIHRoYXQgbWVudSBsb29wIGlzIG5vdCBvdmVyIHlldC4gKi8KCiAgICAgICAgZm9yICg7OykKICAgICAgICB7CiAgICAgICAgICAgIGlmIChQZWVrTWVzc2FnZVcoICZtc2csIDAsIDAsIDAsIFBNX05PUkVNT1ZFICkpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIGlmICghQ2FsbE1zZ0ZpbHRlclcoICZtc2csIE1TR0ZfTUVOVSApKSBicmVhazsKICAgICAgICAgICAgICAgIC8qIHJlbW92ZSB0aGUgbWVzc2FnZSBmcm9tIHRoZSBxdWV1ZSAqLwogICAgICAgICAgICAgICAgUGVla01lc3NhZ2VXKCAmbXNnLCAwLCBtc2cubWVzc2FnZSwgbXNnLm1lc3NhZ2UsIFBNX1JFTU9WRSApOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgaWYgKCFlbnRlcklkbGVTZW50KQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIEhXTkQgd2luID0gKHdGbGFncyAmIFRQTV9FTlRFUklETEVFWCAmJiBtZW51LT53RmxhZ3MgJiBNRl9QT1BVUCkgPyBtZW51LT5oV25kIDogMDsKICAgICAgICAgICAgICAgICAgICBlbnRlcklkbGVTZW50ID0gVFJVRTsKICAgICAgICAgICAgICAgICAgICBTZW5kTWVzc2FnZVcoIG10LmhPd25lclduZCwgV01fRU5URVJJRExFLCBNU0dGX01FTlUsIChMUEFSQU0pd2luICk7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICBXYWl0TWVzc2FnZSgpOwogICAgICAgICAgICB9CiAgICAgICAgfQoKCS8qIGNoZWNrIGlmIEVuZE1lbnUoKSB0cmllZCB0byBjYW5jZWwgdXMsIGJ5IHBvc3RpbmcgdGhpcyBtZXNzYWdlICovCiAgICAgICAgaWYobXNnLm1lc3NhZ2UgPT0gV01fQ0FOQ0VMTU9ERSkKCXsKCSAgICAvKiB3ZSBhcmUgbm93IG91dCBvZiB0aGUgbG9vcCAqLwogICAgCSAgICBmRW5kTWVudSA9IFRSVUU7CgoJICAgIC8qIHJlbW92ZSB0aGUgbWVzc2FnZSBmcm9tIHRoZSBxdWV1ZSAqLwoJICAgIFBlZWtNZXNzYWdlVyggJm1zZywgMCwgbXNnLm1lc3NhZ2UsIG1zZy5tZXNzYWdlLCBQTV9SRU1PVkUgKTsKCgkgICAgLyogYnJlYWsgb3V0IG9mIGludGVybmFsIGxvb3AsIGFsYSBFU0NBUEUgKi8KCSAgICBicmVhazsKCX0KCiAgICAgICAgVHJhbnNsYXRlTWVzc2FnZSggJm1zZyApOwogICAgICAgIG10LnB0ID0gbXNnLnB0OwoKCWlmICggKG1zZy5od25kPT1tZW51LT5oV25kKSB8fCAobXNnLm1lc3NhZ2UhPVdNX1RJTUVSKSApCgkgIGVudGVySWRsZVNlbnQ9RkFMU0U7CgogICAgICAgIGZSZW1vdmUgPSBGQUxTRTsKCWlmICgobXNnLm1lc3NhZ2UgPj0gV01fTU9VU0VGSVJTVCkgJiYgKG1zZy5tZXNzYWdlIDw9IFdNX01PVVNFTEFTVCkpCgl7CiAgICAgICAgICAgIC8qCiAgICAgICAgICAgICAqIFVzZSB0aGUgbW91c2UgY29vcmRpbmF0ZXMgaW4gbFBhcmFtIGluc3RlYWQgb2YgdGhvc2UgaW4gdGhlIE1TRwogICAgICAgICAgICAgKiBzdHJ1Y3QgdG8gcHJvcGVybHkgaGFuZGxlIHN5bnRoZXRpYyBtZXNzYWdlcy4gVGhleSBhcmUgYWxyZWFkeQogICAgICAgICAgICAgKiBpbiBzY3JlZW4gY29vcmRpbmF0ZXMuCiAgICAgICAgICAgICAqLwogICAgICAgICAgICBtdC5wdC54ID0gKHNob3J0KUxPV09SRChtc2cubFBhcmFtKTsKICAgICAgICAgICAgbXQucHQueSA9IChzaG9ydClISVdPUkQobXNnLmxQYXJhbSk7CgoJICAgIC8qIEZpbmQgYSBtZW51IGZvciB0aGlzIG1vdXNlIGV2ZW50ICovCgkgICAgaG1lbnUgPSBNRU5VX1B0TWVudSggbXQuaFRvcE1lbnUsIG10LnB0ICk7CgoJICAgIHN3aXRjaChtc2cubWVzc2FnZSkKCSAgICB7CgkJLyogbm8gV01fTkMuLi4gbWVzc2FnZXMgaW4gY2FwdHVyZWQgc3RhdGUgKi8KCgkJY2FzZSBXTV9SQlVUVE9OREJMQ0xLOgoJCWNhc2UgV01fUkJVVFRPTkRPV046CgkJICAgIGlmICghKHdGbGFncyAmIFRQTV9SSUdIVEJVVFRPTikpIGJyZWFrOwoJCSAgICAvKiBmYWxsIHRocm91Z2ggKi8KCQljYXNlIFdNX0xCVVRUT05EQkxDTEs6CgkJY2FzZSBXTV9MQlVUVE9ORE9XTjoKCQkgICAgLyogSWYgdGhlIG1lc3NhZ2UgYmVsb25ncyB0byB0aGUgbWVudSwgcmVtb3ZlcyBpdCBmcm9tIHRoZSBxdWV1ZSAqLwoJCSAgICAvKiBFbHNlLCBlbmQgbWVudSB0cmFja2luZyAqLwoJCSAgICBmUmVtb3ZlID0gTUVOVV9CdXR0b25Eb3duKCAmbXQsIGhtZW51LCB3RmxhZ3MgKTsKCQkgICAgZkVuZE1lbnUgPSAhZlJlbW92ZTsKCQkgICAgYnJlYWs7CgoJCWNhc2UgV01fUkJVVFRPTlVQOgoJCSAgICBpZiAoISh3RmxhZ3MgJiBUUE1fUklHSFRCVVRUT04pKSBicmVhazsKCQkgICAgLyogZmFsbCB0aHJvdWdoICovCgkJY2FzZSBXTV9MQlVUVE9OVVA6CgkJICAgIC8qIENoZWNrIGlmIGEgbWVudSB3YXMgc2VsZWN0ZWQgYnkgdGhlIG1vdXNlICovCgkJICAgIGlmIChobWVudSkKCQkgICAgewogICAgICAgICAgICAgICAgICAgICAgICBleGVjdXRlZE1lbnVJZCA9IE1FTlVfQnV0dG9uVXAoICZtdCwgaG1lbnUsIHdGbGFncyk7CgoJCQkvKiBFbmQgdGhlIGxvb3AgaWYgZXhlY3V0ZWRNZW51SWQgaXMgYW4gaXRlbSBJRCAqLwoJCQkvKiBvciBpZiB0aGUgam9iIHdhcyBkb25lIChleGVjdXRlZE1lbnVJZCA9IDApLiAqLwogICAgICAgICAgICAgICAgICAgICAgICBmRW5kTWVudSA9IGZSZW1vdmUgPSAoZXhlY3V0ZWRNZW51SWQgIT0gLTEpOwoJCSAgICB9CiAgICAgICAgICAgICAgICAgICAgLyogTm8gbWVudSB3YXMgc2VsZWN0ZWQgYnkgdGhlIG1vdXNlICovCiAgICAgICAgICAgICAgICAgICAgLyogaWYgdGhlIGZ1bmN0aW9uIHdhcyBjYWxsZWQgYnkgVHJhY2tQb3B1cE1lbnUsIGNvbnRpbnVlCiAgICAgICAgICAgICAgICAgICAgICAgd2l0aCB0aGUgbWVudSB0cmFja2luZy4gSWYgbm90LCBzdG9wIGl0ICovCiAgICAgICAgICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgICAgICAgICBmRW5kTWVudSA9ICgod0ZsYWdzICYgVFBNX1BPUFVQTUVOVSkgPyBGQUxTRSA6IFRSVUUpOwoKCQkgICAgYnJlYWs7CgoJCWNhc2UgV01fTU9VU0VNT1ZFOgogICAgICAgICAgICAgICAgICAgIC8qIHRoZSBzZWxlY3RlZCBtZW51IGl0ZW0gbXVzdCBiZSBjaGFuZ2VkIGV2ZXJ5IHRpbWUgKi8KCQkgICAgIC8qIHRoZSBtb3VzZSBtb3Zlcy4gKi8KCiAgICAgICAgICAgICAgICAgICAgaWYgKGhtZW51KQoJCQlmRW5kTWVudSB8PSAhTUVOVV9Nb3VzZU1vdmUoICZtdCwgaG1lbnUsIHdGbGFncyApOwoKCSAgICB9IC8qIHN3aXRjaChtc2cubWVzc2FnZSkgLSBtb3VzZSAqLwoJfQoJZWxzZSBpZiAoKG1zZy5tZXNzYWdlID49IFdNX0tFWUZJUlNUKSAmJiAobXNnLm1lc3NhZ2UgPD0gV01fS0VZTEFTVCkpCgl7CiAgICAgICAgICAgIGZSZW1vdmUgPSBUUlVFOyAgLyogS2V5Ym9hcmQgbWVzc2FnZXMgYXJlIGFsd2F5cyByZW1vdmVkICovCgkgICAgc3dpdGNoKG1zZy5tZXNzYWdlKQoJICAgIHsKCSAgICBjYXNlIFdNX0tFWURPV046CgkgICAgY2FzZSBXTV9TWVNLRVlET1dOOgoJCXN3aXRjaChtc2cud1BhcmFtKQoJCXsKCQljYXNlIFZLX01FTlU6CgkJICAgIGZFbmRNZW51ID0gVFJVRTsKCQkgICAgYnJlYWs7CgoJCWNhc2UgVktfSE9NRToKCQljYXNlIFZLX0VORDoKCQkgICAgTUVOVV9TZWxlY3RJdGVtKCBtdC5oT3duZXJXbmQsIG10LmhDdXJyZW50TWVudSwKCQkJCSAgICAgTk9fU0VMRUNURURfSVRFTSwgRkFMU0UsIDAgKTsKCQkvKiBmYWxsIHRocm91Z2ggKi8KCQljYXNlIFZLX1VQOgoJCSAgICBNRU5VX01vdmVTZWxlY3Rpb24oIG10LmhPd25lclduZCwgbXQuaEN1cnJlbnRNZW51LAoJCQkJICAgICAgIChtc2cud1BhcmFtID09IFZLX0hPTUUpPyBJVEVNX05FWFQgOiBJVEVNX1BSRVYgKTsKCQkgICAgYnJlYWs7CgoJCWNhc2UgVktfRE9XTjogLyogSWYgb24gbWVudSBiYXIsIHB1bGwtZG93biB0aGUgbWVudSAqLwoKCQkgICAgbWVudSA9IE1FTlVfR2V0TWVudSggbXQuaEN1cnJlbnRNZW51ICk7CgkJICAgIGlmICghKG1lbnUtPndGbGFncyAmIE1GX1BPUFVQKSkKCQkJbXQuaEN1cnJlbnRNZW51ID0gTUVOVV9TaG93U3ViUG9wdXAobXQuaE93bmVyV25kLCBtdC5oVG9wTWVudSwgVFJVRSwgd0ZsYWdzKTsKCQkgICAgZWxzZSAgICAgIC8qIG90aGVyd2lzZSB0cnkgdG8gbW92ZSBzZWxlY3Rpb24gKi8KCQkJTUVOVV9Nb3ZlU2VsZWN0aW9uKCBtdC5oT3duZXJXbmQsIG10LmhDdXJyZW50TWVudSwgSVRFTV9ORVhUICk7CgkJICAgIGJyZWFrOwoKCQljYXNlIFZLX0xFRlQ6CgkJICAgIE1FTlVfS2V5TGVmdCggJm10LCB3RmxhZ3MgKTsKCQkgICAgYnJlYWs7CgoJCWNhc2UgVktfUklHSFQ6CgkJICAgIE1FTlVfS2V5UmlnaHQoICZtdCwgd0ZsYWdzICk7CgkJICAgIGJyZWFrOwoKCQljYXNlIFZLX0VTQ0FQRToKICAgICAgICAgICAgICAgICAgICBmRW5kTWVudSA9IE1FTlVfS2V5RXNjYXBlKCZtdCwgd0ZsYWdzKTsKCQkgICAgYnJlYWs7CgoJCWNhc2UgVktfRjE6CgkJICAgIHsKCQkJSEVMUElORk8gaGk7CgkJCWhpLmNiU2l6ZSA9IHNpemVvZihIRUxQSU5GTyk7CgkJCWhpLmlDb250ZXh0VHlwZSA9IEhFTFBJTkZPX01FTlVJVEVNOwoJCQlpZiAobWVudS0+Rm9jdXNlZEl0ZW0gPT0gTk9fU0VMRUNURURfSVRFTSkKCQkJICAgIGhpLmlDdHJsSWQgPSAwOwoJCSAgICAgICAgZWxzZQoJCQkgICAgaGkuaUN0cmxJZCA9IG1lbnUtPml0ZW1zW21lbnUtPkZvY3VzZWRJdGVtXS53SUQ7CgkJCWhpLmhJdGVtSGFuZGxlID0gaG1lbnU7CgkJCWhpLmR3Q29udGV4dElkID0gbWVudS0+ZHdDb250ZXh0SGVscElEOwoJCQloaS5Nb3VzZVBvcyA9IG1zZy5wdDsKCQkJU2VuZE1lc3NhZ2VXKGh3bmQsIFdNX0hFTFAsIDAsIChMUEFSQU0pJmhpKTsKCQkJYnJlYWs7CgkJICAgIH0KCgkJZGVmYXVsdDoKCQkgICAgYnJlYWs7CgkJfQoJCWJyZWFrOyAgLyogV01fS0VZRE9XTiAqLwoKCSAgICBjYXNlIFdNX0NIQVI6CgkgICAgY2FzZSBXTV9TWVNDSEFSOgoJCXsKCQkgICAgVUlOVAlwb3M7CgoJCSAgICBpZiAobXNnLndQYXJhbSA9PSAnXHInIHx8IG1zZy53UGFyYW0gPT0gJyAnKQoJCSAgICB7CiAgICAgICAgICAgICAgICAgICAgICAgIGV4ZWN1dGVkTWVudUlkID0gTUVOVV9FeGVjRm9jdXNlZEl0ZW0oJm10LG10LmhDdXJyZW50TWVudSwgd0ZsYWdzKTsKICAgICAgICAgICAgICAgICAgICAgICAgZkVuZE1lbnUgPSAoZXhlY3V0ZWRNZW51SWQgIT0gLTEpOwoKCQkJYnJlYWs7CgkJICAgIH0KCgkJICAgICAgLyogSGFjayB0byBhdm9pZCBjb250cm9sIGNoYXJzLiAqLwoJCSAgICAgIC8qIFdlIHdpbGwgZmluZCBhIGJldHRlciB3YXkgcmVhbCBzb29uLi4uICovCgkJICAgIGlmIChtc2cud1BhcmFtIDwgMzIpIGJyZWFrOwoKCQkgICAgcG9zID0gTUVOVV9GaW5kSXRlbUJ5S2V5KCBtdC5oT3duZXJXbmQsIG10LmhDdXJyZW50TWVudSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIExPV09SRChtc2cud1BhcmFtKSwgRkFMU0UgKTsKCQkgICAgaWYgKHBvcyA9PSAoVUlOVCktMikgZkVuZE1lbnUgPSBUUlVFOwoJCSAgICBlbHNlIGlmIChwb3MgPT0gKFVJTlQpLTEpIE1lc3NhZ2VCZWVwKDApOwoJCSAgICBlbHNlCgkJICAgIHsKCQkJTUVOVV9TZWxlY3RJdGVtKCBtdC5oT3duZXJXbmQsIG10LmhDdXJyZW50TWVudSwgcG9zLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFRSVUUsIDAgKTsKICAgICAgICAgICAgICAgICAgICAgICAgZXhlY3V0ZWRNZW51SWQgPSBNRU5VX0V4ZWNGb2N1c2VkSXRlbSgmbXQsbXQuaEN1cnJlbnRNZW51LCB3RmxhZ3MpOwogICAgICAgICAgICAgICAgICAgICAgICBmRW5kTWVudSA9IChleGVjdXRlZE1lbnVJZCAhPSAtMSk7CgkJICAgIH0KCQl9CgkJYnJlYWs7CgkgICAgfSAgLyogc3dpdGNoKG1zZy5tZXNzYWdlKSAtIGtiZCAqLwoJfQoJZWxzZQoJewoJICAgIERpc3BhdGNoTWVzc2FnZVcoICZtc2cgKTsKCX0KCglpZiAoIWZFbmRNZW51KSBmUmVtb3ZlID0gVFJVRTsKCgkvKiBmaW5hbGx5IHJlbW92ZSBtZXNzYWdlIGZyb20gdGhlIHF1ZXVlICovCgogICAgICAgIGlmIChmUmVtb3ZlICYmICEobXQudHJhY2tGbGFncyAmIFRGX1NLSVBSRU1PVkUpICkKCSAgICBQZWVrTWVzc2FnZVcoICZtc2csIDAsIG1zZy5tZXNzYWdlLCBtc2cubWVzc2FnZSwgUE1fUkVNT1ZFICk7CgllbHNlIG10LnRyYWNrRmxhZ3MgJj0gflRGX1NLSVBSRU1PVkU7CiAgICB9CgogICAgTUVOVV9TZXRDYXB0dXJlKDApOyAgLyogcmVsZWFzZSB0aGUgY2FwdHVyZSAqLwoKICAgIC8qIElmIGRyb3Bkb3duIGlzIHN0aWxsIHBhaW50ZWQgYW5kIHRoZSBjbG9zZSBib3ggaXMgY2xpY2tlZCBvbgogICAgICAgdGhlbiB0aGUgbWVudSB3aWxsIGJlIGRlc3Ryb3llZCBhcyBwYXJ0IG9mIHRoZSBEaXNwYXRjaE1lc3NhZ2UgYWJvdmUuCiAgICAgICBUaGlzIHdpbGwgdGhlbiBpbnZhbGlkYXRlIHRoZSBtZW51IGhhbmRsZSBpbiBtdC5oVG9wTWVudS4gV2Ugc2hvdWxkCiAgICAgICBjaGVjayBmb3IgdGhpcyBmaXJzdC4gICovCiAgICBpZiggSXNNZW51KCBtdC5oVG9wTWVudSApICkKICAgIHsKCW1lbnUgPSBNRU5VX0dldE1lbnUoIG10LmhUb3BNZW51ICk7CgogICAgICAgIGlmKCBJc1dpbmRvdyggbXQuaE93bmVyV25kICkgKQogICAgICAgIHsKCSAgICBNRU5VX0hpZGVTdWJQb3B1cHMoIG10LmhPd25lclduZCwgbXQuaFRvcE1lbnUsIEZBTFNFICk7CgoJICAgIGlmIChtZW51ICYmIChtZW51LT53RmxhZ3MgJiBNRl9QT1BVUCkpCgkgICAgewogICAgICAgICAgICAgICAgRGVzdHJveVdpbmRvdyggbWVudS0+aFduZCApOwogICAgICAgICAgICAgICAgbWVudS0+aFduZCA9IDA7CgkgICAgfQoJICAgIE1FTlVfU2VsZWN0SXRlbSggbXQuaE93bmVyV25kLCBtdC5oVG9wTWVudSwgTk9fU0VMRUNURURfSVRFTSwgRkFMU0UsIDAgKTsKCSAgICBTZW5kTWVzc2FnZVcoIG10LmhPd25lclduZCwgV01fTUVOVVNFTEVDVCwgTUFLRUxPTkcoMCwweGZmZmYpLCAwICk7CiAgICAgICAgfQoKICAgICAgICAvKiBSZXNldCB0aGUgdmFyaWFibGUgZm9yIGhpZGluZyBtZW51ICovCiAgICAgICAgaWYoIG1lbnUgKSBtZW51LT5iVGltZVRvSGlkZSA9IEZBTFNFOwogICAgfQoKICAgIC8qIFRoZSByZXR1cm4gdmFsdWUgaXMgb25seSB1c2VkIGJ5IFRyYWNrUG9wdXBNZW51ICovCiAgICBpZiAoISh3RmxhZ3MgJiBUUE1fUkVUVVJOQ01EKSkgcmV0dXJuIFRSVUU7CiAgICBpZiAoZXhlY3V0ZWRNZW51SWQgPT0gLTEpIGV4ZWN1dGVkTWVudUlkID0gMDsKICAgIHJldHVybiBleGVjdXRlZE1lbnVJZDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0luaXRUcmFja2luZwogKi8Kc3RhdGljIEJPT0wgTUVOVV9Jbml0VHJhY2tpbmcoSFdORCBoV25kLCBITUVOVSBoTWVudSwgQk9PTCBiUG9wdXAsIFVJTlQgd0ZsYWdzKQp7CiAgICBQT1BVUE1FTlUgKm1lbnU7CiAgICAKICAgIFRSQUNFKCJod25kPSVwIGhtZW51PSVwXG4iLCBoV25kLCBoTWVudSk7CgogICAgSGlkZUNhcmV0KDApOwoKICAgIC8qIFNlbmQgV01fRU5URVJNRU5VTE9PUCBhbmQgV01fSU5JVE1FTlUgbWVzc2FnZSBvbmx5IGlmIFRQTV9OT05PVElGWSBmbGFnIGlzIG5vdCBzcGVjaWZpZWQgKi8KICAgIGlmICghKHdGbGFncyAmIFRQTV9OT05PVElGWSkpCiAgICAgICBTZW5kTWVzc2FnZVcoIGhXbmQsIFdNX0VOVEVSTUVOVUxPT1AsIGJQb3B1cCwgMCApOwoKICAgIFNlbmRNZXNzYWdlVyggaFduZCwgV01fU0VUQ1VSU09SLCAoV1BBUkFNKWhXbmQsIEhUQ0FQVElPTiApOwoKICAgIGlmICghKHdGbGFncyAmIFRQTV9OT05PVElGWSkpCiAgICB7CiAgICAgICBTZW5kTWVzc2FnZVcoIGhXbmQsIFdNX0lOSVRNRU5VLCAoV1BBUkFNKWhNZW51LCAwICk7CiAgICAgICAvKiBJZiBhbiBhcHAgY2hhbmdlZC9yZWNyZWF0ZWQgbWVudSBiYXIgZW50cmllcyBpbiBXTV9JTklUTUVOVQogICAgICAgICogbWVudSBzaXplcyB3aWxsIGJlIHJlY2FsY3VsYXRlZCBvbmNlIHRoZSBtZW51IGNyZWF0ZWQvc2hvd24uCiAgICAgICAgKi8KICAgIH0KICAgIAogICAgLyogVGhpcyBtYWtlcyB0aGUgbWVudXMgb2YgYXBwbGljYXRpb25zIGJ1aWx0IHdpdGggRGVscGhpIHdvcmsuCiAgICAgKiBJdCBhbHNvIGVuYWJsZXMgbWVudXMgdG8gYmUgZGlzcGxheWVkIGluIG1vcmUgdGhhbiBvbmUgd2luZG93LAogICAgICogYnV0IHRoZXJlIGFyZSBzb21lIGJ1Z3MgbGVmdCB0aGF0IG5lZWQgdG8gYmUgZml4ZWQgaW4gdGhpcyBjYXNlLgogICAgICovCiAgICBpZiAoKG1lbnUgPSBNRU5VX0dldE1lbnUoIGhNZW51ICkpKSBtZW51LT5oV25kID0gaFduZDsKICAgIAogICAgcmV0dXJuIFRSVUU7Cn0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0V4aXRUcmFja2luZwogKi8Kc3RhdGljIEJPT0wgTUVOVV9FeGl0VHJhY2tpbmcoSFdORCBoV25kKQp7CiAgICBUUkFDRSgiaHduZD0lcFxuIiwgaFduZCk7CgogICAgU2VuZE1lc3NhZ2VXKCBoV25kLCBXTV9FWElUTUVOVUxPT1AsIDAsIDAgKTsKICAgIFNob3dDYXJldCgwKTsKICAgIHRvcF9wb3B1cCA9IDA7CiAgICByZXR1cm4gVFJVRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX1RyYWNrTW91c2VNZW51QmFyCiAqCiAqIE1lbnUtYmFyIHRyYWNraW5nIHVwb24gYSBtb3VzZSBldmVudC4gQ2FsbGVkIGZyb20gTkNfSGFuZGxlU3lzQ29tbWFuZCgpLgogKi8Kdm9pZCBNRU5VX1RyYWNrTW91c2VNZW51QmFyKCBIV05EIGhXbmQsIElOVCBodCwgUE9JTlQgcHQgKQp7CiAgICBITUVOVSBoTWVudSA9IChodCA9PSBIVFNZU01FTlUpID8gZ2V0X3dpbl9zeXNfbWVudSggaFduZCApIDogR2V0TWVudSggaFduZCApOwogICAgVUlOVCB3RmxhZ3MgPSBUUE1fRU5URVJJRExFRVggfCBUUE1fQlVUVE9ORE9XTiB8IFRQTV9MRUZUQUxJR04gfCBUUE1fTEVGVEJVVFRPTjsKCiAgICBUUkFDRSgid25kPSVwIGh0PTB4JTA0eCAoJWxkLCVsZClcbiIsIGhXbmQsIGh0LCBwdC54LCBwdC55KTsKCiAgICBpZiAoSXNNZW51KGhNZW51KSkKICAgIHsKICAgICAgICAvKiBtYXAgcG9pbnQgdG8gcGFyZW50IGNsaWVudCBjb29yZGluYXRlcyAqLwogICAgICAgIEhXTkQgcGFyZW50ID0gR2V0QW5jZXN0b3IoIGhXbmQsIEdBX1BBUkVOVCApOwogICAgICAgIGlmIChwYXJlbnQgIT0gR2V0RGVza3RvcFdpbmRvdygpKSBTY3JlZW5Ub0NsaWVudCggcGFyZW50LCAmcHQgKTsKCglNRU5VX0luaXRUcmFja2luZyggaFduZCwgaE1lbnUsIEZBTFNFLCB3RmxhZ3MgKTsKCU1FTlVfVHJhY2tNZW51KCBoTWVudSwgd0ZsYWdzLCBwdC54LCBwdC55LCBoV25kLCBOVUxMICk7CglNRU5VX0V4aXRUcmFja2luZyhoV25kKTsKICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9UcmFja0tiZE1lbnVCYXIKICoKICogTWVudS1iYXIgdHJhY2tpbmcgdXBvbiBhIGtleWJvYXJkIGV2ZW50LiBDYWxsZWQgZnJvbSBOQ19IYW5kbGVTeXNDb21tYW5kKCkuCiAqLwp2b2lkIE1FTlVfVHJhY2tLYmRNZW51QmFyKCBIV05EIGh3bmQsIFVJTlQgd1BhcmFtLCBXQ0hBUiB3Q2hhcikKewogICAgVUlOVCB1SXRlbSA9IE5PX1NFTEVDVEVEX0lURU07CiAgICBITUVOVSBoVHJhY2tNZW51OwogICAgVUlOVCB3RmxhZ3MgPSBUUE1fRU5URVJJRExFRVggfCBUUE1fTEVGVEFMSUdOIHwgVFBNX0xFRlRCVVRUT047CgogICAgVFJBQ0UoImh3bmQgJXAgd1BhcmFtIDB4JTA0eCB3Q2hhciAweCUwNHhcbiIsIGh3bmQsIHdQYXJhbSwgd0NoYXIpOwoKICAgIC8qIGZpbmQgd2luZG93IHRoYXQgaGFzIGEgbWVudSAqLwoKICAgIHdoaWxlIChHZXRXaW5kb3dMb25nVyggaHduZCwgR1dMX1NUWUxFICkgJiBXU19DSElMRCkKICAgICAgICBpZiAoIShod25kID0gR2V0UGFyZW50KCBod25kICkpKSByZXR1cm47CgogICAgLyogY2hlY2sgaWYgd2UgaGF2ZSB0byB0cmFjayBhIHN5c3RlbSBtZW51ICovCgogICAgaFRyYWNrTWVudSA9IEdldE1lbnUoIGh3bmQgKTsKICAgIGlmICghaFRyYWNrTWVudSB8fCBJc0ljb25pYyhod25kKSB8fCB3Q2hhciA9PSAnICcgKQogICAgewogICAgICAgIGlmICghKEdldFdpbmRvd0xvbmdXKCBod25kLCBHV0xfU1RZTEUgKSAmIFdTX1NZU01FTlUpKSByZXR1cm47CiAgICAgICAgaFRyYWNrTWVudSA9IGdldF93aW5fc3lzX21lbnUoIGh3bmQgKTsKICAgICAgICB1SXRlbSA9IDA7CiAgICAgICAgd1BhcmFtIHw9IEhUU1lTTUVOVTsgLyogcHJldmVudCBpdGVtIGxvb2t1cCAqLwogICAgfQoKICAgIGlmICghSXNNZW51KCBoVHJhY2tNZW51ICkpIHJldHVybjsKCiAgICBNRU5VX0luaXRUcmFja2luZyggaHduZCwgaFRyYWNrTWVudSwgRkFMU0UsIHdGbGFncyApOwoKICAgIGlmKCB3Q2hhciAmJiB3Q2hhciAhPSAnICcgKQogICAgewogICAgICAgIHVJdGVtID0gTUVOVV9GaW5kSXRlbUJ5S2V5KCBod25kLCBoVHJhY2tNZW51LCB3Q2hhciwgKHdQYXJhbSAmIEhUU1lTTUVOVSkgKTsKICAgICAgICBpZiAoIHVJdGVtID49IChVSU5UKSgtMikgKQogICAgICAgIHsKICAgICAgICAgICAgaWYoIHVJdGVtID09IChVSU5UKSgtMSkgKSBNZXNzYWdlQmVlcCgwKTsKICAgICAgICAgICAgLyogc2NoZWR1bGUgZW5kIG9mIG1lbnUgdHJhY2tpbmcgKi8KICAgICAgICAgICAgd0ZsYWdzIHw9IFRGX0VORE1FTlU7CiAgICAgICAgICAgIGdvdG8gdHJhY2tfbWVudTsKICAgICAgICB9CiAgICB9CgogICAgTUVOVV9TZWxlY3RJdGVtKCBod25kLCBoVHJhY2tNZW51LCB1SXRlbSwgVFJVRSwgMCApOwoKICAgIGlmICh3UGFyYW0gJiBIVFNZU01FTlUpCiAgICB7CiAgICAgICAgLyogcHJldmVudCBzeXNtZW51IGFjdGl2YXRpb24gZm9yIG1hbmFnZWQgd2luZG93cyBvbiBBbHQgZG93bi91cCAqLwogICAgICAgIGlmIChHZXRQcm9wQSggaHduZCwgIl9fd2luZV94MTFfbWFuYWdlZCIgKSkKICAgICAgICAgICAgd0ZsYWdzIHw9IFRGX0VORE1FTlU7IC8qIHNjaGVkdWxlIGVuZCBvZiBtZW51IHRyYWNraW5nICovCiAgICB9CiAgICBlbHNlCiAgICB7CiAgICAgICAgaWYoIHVJdGVtID09IE5PX1NFTEVDVEVEX0lURU0gKQogICAgICAgICAgICBNRU5VX01vdmVTZWxlY3Rpb24oIGh3bmQsIGhUcmFja01lbnUsIElURU1fTkVYVCApOwogICAgICAgIGVsc2UKICAgICAgICAgICAgUG9zdE1lc3NhZ2VXKCBod25kLCBXTV9LRVlET1dOLCBWS19ET1dOLCAwTCApOwogICAgfQoKdHJhY2tfbWVudToKICAgIE1FTlVfVHJhY2tNZW51KCBoVHJhY2tNZW51LCB3RmxhZ3MsIDAsIDAsIGh3bmQsIE5VTEwgKTsKICAgIE1FTlVfRXhpdFRyYWNraW5nKCBod25kICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgVHJhY2tQb3B1cE1lbnUgICAoVVNFUjMyLkApCiAqCiAqIExpa2UgdGhlIHdpbjMyIEFQSSwgdGhlIGZ1bmN0aW9uIHJldHVybiB0aGUgY29tbWFuZCBJRCBvbmx5IGlmIHRoZQogKiBmbGFnIFRQTV9SRVRVUk5DTUQgaXMgb24uCiAqCiAqLwpCT09MIFdJTkFQSSBUcmFja1BvcHVwTWVudSggSE1FTlUgaE1lbnUsIFVJTlQgd0ZsYWdzLCBJTlQgeCwgSU5UIHksCiAgICAgICAgICAgICAgICAgICAgICAgICAgIElOVCBuUmVzZXJ2ZWQsIEhXTkQgaFduZCwgY29uc3QgUkVDVCAqbHBSZWN0ICkKewogICAgQk9PTCByZXQgPSBGQUxTRTsKCiAgICBNRU5VX0luaXRUcmFja2luZyhoV25kLCBoTWVudSwgVFJVRSwgd0ZsYWdzKTsKCiAgICAvKiBTZW5kIFdNX0lOSVRNRU5VUE9QVVAgbWVzc2FnZSBvbmx5IGlmIFRQTV9OT05PVElGWSBmbGFnIGlzIG5vdCBzcGVjaWZpZWQgKi8KICAgIGlmICghKHdGbGFncyAmIFRQTV9OT05PVElGWSkpCiAgICAgICAgU2VuZE1lc3NhZ2VXKCBoV25kLCBXTV9JTklUTUVOVVBPUFVQLCAoV1BBUkFNKWhNZW51LCAwKTsKCiAgICBpZiAoTUVOVV9TaG93UG9wdXAoIGhXbmQsIGhNZW51LCAwLCB4LCB5LCAwLCAwICkpCiAgICAgICAgcmV0ID0gTUVOVV9UcmFja01lbnUoIGhNZW51LCB3RmxhZ3MgfCBUUE1fUE9QVVBNRU5VLCAwLCAwLCBoV25kLCBscFJlY3QgKTsKICAgIE1FTlVfRXhpdFRyYWNraW5nKGhXbmQpOwoKICAgIHJldHVybiByZXQ7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBUcmFja1BvcHVwTWVudUV4ICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgVHJhY2tQb3B1cE1lbnVFeCggSE1FTlUgaE1lbnUsIFVJTlQgd0ZsYWdzLCBJTlQgeCwgSU5UIHksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSFdORCBoV25kLCBMUFRQTVBBUkFNUyBscFRwbSApCnsKICAgIEZJWE1FKCJub3QgZnVsbHkgaW1wbGVtZW50ZWRcbiIgKTsKICAgIHJldHVybiBUcmFja1BvcHVwTWVudSggaE1lbnUsIHdGbGFncywgeCwgeSwgMCwgaFduZCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBscFRwbSA/ICZscFRwbS0+cmNFeGNsdWRlIDogTlVMTCApOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIFBvcHVwTWVudVduZFByb2MKICoKICogTk9URTogV2luZG93cyBoYXMgdG90YWxseSBkaWZmZXJlbnQgKGFuZCB1bmRvY3VtZW50ZWQpIHBvcHVwIHduZHByb2MuCiAqLwpzdGF0aWMgTFJFU1VMVCBXSU5BUEkgUG9wdXBNZW51V25kUHJvYyggSFdORCBod25kLCBVSU5UIG1lc3NhZ2UsIFdQQVJBTSB3UGFyYW0sIExQQVJBTSBsUGFyYW0gKQp7CiAgICBUUkFDRSgiaHduZD0lcCBtc2c9MHglMDR4IHdwPTB4JTA0eCBscD0weCUwOGx4XG4iLCBod25kLCBtZXNzYWdlLCB3UGFyYW0sIGxQYXJhbSk7CgogICAgc3dpdGNoKG1lc3NhZ2UpCiAgICB7CiAgICBjYXNlIFdNX0NSRUFURToKCXsKCSAgICBDUkVBVEVTVFJVQ1RXICpjcyA9IChDUkVBVEVTVFJVQ1RXKilsUGFyYW07CgkgICAgU2V0V2luZG93TG9uZ1coIGh3bmQsIDAsIChMT05HKWNzLT5scENyZWF0ZVBhcmFtcyApOwogICAgICAgICAgICByZXR1cm4gMDsKCX0KCiAgICBjYXNlIFdNX01PVVNFQUNUSVZBVEU6ICAvKiBXZSBkb24ndCB3YW50IHRvIGJlIGFjdGl2YXRlZCAqLwogICAgICAgIHJldHVybiBNQV9OT0FDVElWQVRFOwoKICAgIGNhc2UgV01fUEFJTlQ6Cgl7CgkgICAgUEFJTlRTVFJVQ1QgcHM7CgkgICAgQmVnaW5QYWludCggaHduZCwgJnBzICk7CgkgICAgTUVOVV9EcmF3UG9wdXBNZW51KCBod25kLCBwcy5oZGMsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKEhNRU5VKUdldFdpbmRvd0xvbmdXKCBod25kLCAwICkgKTsKCSAgICBFbmRQYWludCggaHduZCwgJnBzICk7CiAgICAgICAgICAgIHJldHVybiAwOwoJfQogICAgY2FzZSBXTV9FUkFTRUJLR05EOgogICAgICAgIHJldHVybiAxOwoKICAgIGNhc2UgV01fREVTVFJPWToKICAgICAgICAvKiB6ZXJvIG91dCBnbG9iYWwgcG9pbnRlciBpbiBjYXNlIHJlc2lkZW50IHBvcHVwIHdpbmRvdyB3YXMgZGVzdHJveWVkLiAqLwogICAgICAgIGlmIChod25kID09IHRvcF9wb3B1cCkgdG9wX3BvcHVwID0gMDsKICAgICAgICBicmVhazsKCiAgICBjYXNlIFdNX1NIT1dXSU5ET1c6CgoJaWYoIHdQYXJhbSApCgl7CiAgICAgICAgICAgIGlmICghR2V0V2luZG93TG9uZ1coIGh3bmQsIDAgKSkgRVJSKCJubyBtZW51IHRvIGRpc3BsYXlcbiIpOwoJfQoJZWxzZQogICAgICAgICAgICBTZXRXaW5kb3dMb25nVyggaHduZCwgMCwgMCApOwoJYnJlYWs7CgogICAgY2FzZSBNTV9TRVRNRU5VSEFORExFOgogICAgICAgIFNldFdpbmRvd0xvbmdXKCBod25kLCAwLCB3UGFyYW0gKTsKICAgICAgICBicmVhazsKCiAgICBjYXNlIE1NX0dFVE1FTlVIQU5ETEU6CiAgICAgICAgcmV0dXJuIEdldFdpbmRvd0xvbmdXKCBod25kLCAwICk7CgogICAgZGVmYXVsdDoKICAgICAgICByZXR1cm4gRGVmV2luZG93UHJvY1coIGh3bmQsIG1lc3NhZ2UsIHdQYXJhbSwgbFBhcmFtICk7CiAgICB9CiAgICByZXR1cm4gMDsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9HZXRNZW51QmFySGVpZ2h0CiAqCiAqIENvbXB1dGUgdGhlIHNpemUgb2YgdGhlIG1lbnUgYmFyIGhlaWdodC4gVXNlZCBieSBOQ19IYW5kbGVOQ0NhbGNTaXplKCkuCiAqLwpVSU5UIE1FTlVfR2V0TWVudUJhckhlaWdodCggSFdORCBod25kLCBVSU5UIG1lbnViYXJXaWR0aCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSU5UIG9yZ1gsIElOVCBvcmdZICkKewogICAgSERDIGhkYzsKICAgIFJFQ1QgcmVjdEJhcjsKICAgIExQUE9QVVBNRU5VIGxwcG9wOwoKICAgIFRSQUNFKCJIV05EICVwLCB3aWR0aCAlZCwgYXQgKCVkLCAlZCkuXG4iLCBod25kLCBtZW51YmFyV2lkdGgsIG9yZ1gsIG9yZ1kgKTsKCiAgICBpZiAoIShscHBvcCA9IE1FTlVfR2V0TWVudSggR2V0TWVudShod25kKSApKSkgcmV0dXJuIDA7CgogICAgaGRjID0gR2V0RENFeCggaHduZCwgMCwgRENYX0NBQ0hFIHwgRENYX1dJTkRPVyApOwogICAgU2VsZWN0T2JqZWN0KCBoZGMsIGhNZW51Rm9udCk7CiAgICBTZXRSZWN0KCZyZWN0QmFyLCBvcmdYLCBvcmdZLCBvcmdYK21lbnViYXJXaWR0aCwgb3JnWStHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZTUVOVSkpOwogICAgTUVOVV9NZW51QmFyQ2FsY1NpemUoIGhkYywgJnJlY3RCYXIsIGxwcG9wLCBod25kICk7CiAgICBSZWxlYXNlREMoIGh3bmQsIGhkYyApOwogICAgcmV0dXJuIGxwcG9wLT5IZWlnaHQ7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIENoYW5nZU1lbnVBICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIENoYW5nZU1lbnVBKCBITUVOVSBoTWVudSwgVUlOVCBwb3MsIExQQ1NUUiBkYXRhLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVJTlQgaWQsIFVJTlQgZmxhZ3MgKQp7CiAgICBUUkFDRSgibWVudT0lcCBwb3M9JWQgZGF0YT0lcCBpZD0lMDh4IGZsYWdzPSUwOHhcbiIsIGhNZW51LCBwb3MsIGRhdGEsIGlkLCBmbGFncyApOwogICAgaWYgKGZsYWdzICYgTUZfQVBQRU5EKSByZXR1cm4gQXBwZW5kTWVudUEoIGhNZW51LCBmbGFncyAmIH5NRl9BUFBFTkQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpZCwgZGF0YSApOwogICAgaWYgKGZsYWdzICYgTUZfREVMRVRFKSByZXR1cm4gRGVsZXRlTWVudShoTWVudSwgcG9zLCBmbGFncyAmIH5NRl9ERUxFVEUpOwogICAgaWYgKGZsYWdzICYgTUZfQ0hBTkdFKSByZXR1cm4gTW9kaWZ5TWVudUEoaE1lbnUsIHBvcywgZmxhZ3MgJiB+TUZfQ0hBTkdFLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpZCwgZGF0YSApOwogICAgaWYgKGZsYWdzICYgTUZfUkVNT1ZFKSByZXR1cm4gUmVtb3ZlTWVudSggaE1lbnUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmbGFncyAmIE1GX0JZUE9TSVRJT04gPyBwb3MgOiBpZCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsYWdzICYgfk1GX1JFTU9WRSApOwogICAgLyogRGVmYXVsdDogTUZfSU5TRVJUICovCiAgICByZXR1cm4gSW5zZXJ0TWVudUEoIGhNZW51LCBwb3MsIGZsYWdzLCBpZCwgZGF0YSApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBDaGFuZ2VNZW51VyAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBDaGFuZ2VNZW51VyggSE1FTlUgaE1lbnUsIFVJTlQgcG9zLCBMUENXU1RSIGRhdGEsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVUlOVCBpZCwgVUlOVCBmbGFncyApCnsKICAgIFRSQUNFKCJtZW51PSVwIHBvcz0lZCBkYXRhPSVwIGlkPSUwOHggZmxhZ3M9JTA4eFxuIiwgaE1lbnUsIHBvcywgZGF0YSwgaWQsIGZsYWdzICk7CiAgICBpZiAoZmxhZ3MgJiBNRl9BUFBFTkQpIHJldHVybiBBcHBlbmRNZW51VyggaE1lbnUsIGZsYWdzICYgfk1GX0FQUEVORCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlkLCBkYXRhICk7CiAgICBpZiAoZmxhZ3MgJiBNRl9ERUxFVEUpIHJldHVybiBEZWxldGVNZW51KGhNZW51LCBwb3MsIGZsYWdzICYgfk1GX0RFTEVURSk7CiAgICBpZiAoZmxhZ3MgJiBNRl9DSEFOR0UpIHJldHVybiBNb2RpZnlNZW51VyhoTWVudSwgcG9zLCBmbGFncyAmIH5NRl9DSEFOR0UsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlkLCBkYXRhICk7CiAgICBpZiAoZmxhZ3MgJiBNRl9SRU1PVkUpIHJldHVybiBSZW1vdmVNZW51KCBoTWVudSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsYWdzICYgTUZfQllQT1NJVElPTiA/IHBvcyA6IGlkLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZmxhZ3MgJiB+TUZfUkVNT1ZFICk7CiAgICAvKiBEZWZhdWx0OiBNRl9JTlNFUlQgKi8KICAgIHJldHVybiBJbnNlcnRNZW51VyggaE1lbnUsIHBvcywgZmxhZ3MsIGlkLCBkYXRhICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIENoZWNrTWVudUl0ZW0gICAgKFVTRVIzMi5AKQogKi8KRFdPUkQgV0lOQVBJIENoZWNrTWVudUl0ZW0oIEhNRU5VIGhNZW51LCBVSU5UIGlkLCBVSU5UIGZsYWdzICkKewogICAgTUVOVUlURU0gKml0ZW07CiAgICBEV09SRCByZXQ7CgogICAgVFJBQ0UoIm1lbnU9JXAgaWQ9JTA0eCBmbGFncz0lMDR4XG4iLCBoTWVudSwgaWQsIGZsYWdzICk7CiAgICBpZiAoIShpdGVtID0gTUVOVV9GaW5kSXRlbSggJmhNZW51LCAmaWQsIGZsYWdzICkpKSByZXR1cm4gLTE7CiAgICByZXQgPSBpdGVtLT5mU3RhdGUgJiBNRl9DSEVDS0VEOwogICAgaWYgKGZsYWdzICYgTUZfQ0hFQ0tFRCkgaXRlbS0+ZlN0YXRlIHw9IE1GX0NIRUNLRUQ7CiAgICBlbHNlIGl0ZW0tPmZTdGF0ZSAmPSB+TUZfQ0hFQ0tFRDsKICAgIHJldHVybiByZXQ7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEVuYWJsZU1lbnVJdGVtICAgIChVU0VSMzIuQCkKICovClVJTlQgV0lOQVBJIEVuYWJsZU1lbnVJdGVtKCBITUVOVSBoTWVudSwgVUlOVCB3SXRlbUlELCBVSU5UIHdGbGFncyApCnsKICAgIFVJTlQgICAgb2xkZmxhZ3M7CiAgICBNRU5VSVRFTSAqaXRlbTsKICAgIFBPUFVQTUVOVSAqbWVudTsKCiAgICBUUkFDRSgiKCVwLCAlMDR4LCAlMDR4KSAhXG4iLCBoTWVudSwgd0l0ZW1JRCwgd0ZsYWdzKTsKCiAgICAvKiBHZXQgdGhlIFBvcHVwbWVudSB0byBhY2Nlc3MgdGhlIG93bmVyIG1lbnUgKi8KICAgIGlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpKSkKCXJldHVybiAoVUlOVCktMTsKCiAgICBpZiAoIShpdGVtID0gTUVOVV9GaW5kSXRlbSggJmhNZW51LCAmd0l0ZW1JRCwgd0ZsYWdzICkpKQoJcmV0dXJuIChVSU5UKS0xOwoKICAgIG9sZGZsYWdzID0gaXRlbS0+ZlN0YXRlICYgKE1GX0dSQVlFRCB8IE1GX0RJU0FCTEVEKTsKICAgIGl0ZW0tPmZTdGF0ZSBePSAob2xkZmxhZ3MgXiB3RmxhZ3MpICYgKE1GX0dSQVlFRCB8IE1GX0RJU0FCTEVEKTsKCiAgICAvKiBJZiB0aGUgY2xvc2UgaXRlbSBpbiB0aGUgc3lzdGVtIG1lbnUgY2hhbmdlIHVwZGF0ZSB0aGUgY2xvc2UgYnV0dG9uICovCiAgICBpZigoaXRlbS0+d0lEID09IFNDX0NMT1NFKSAmJiAob2xkZmxhZ3MgIT0gd0ZsYWdzKSkKICAgIHsKCWlmIChtZW51LT5oU3lzTWVudU93bmVyICE9IDApCgl7CgkgICAgUE9QVVBNRU5VKiBwYXJlbnRNZW51OwoKCSAgICAvKiBHZXQgdGhlIHBhcmVudCBtZW51IHRvIGFjY2VzcyovCgkgICAgaWYgKCEocGFyZW50TWVudSA9IE1FTlVfR2V0TWVudShtZW51LT5oU3lzTWVudU93bmVyKSkpCgkJcmV0dXJuIChVSU5UKS0xOwoKCSAgICAvKiBSZWZyZXNoIHRoZSBmcmFtZSB0byByZWZsZWN0IHRoZSBjaGFuZ2UqLwoJICAgIFNldFdpbmRvd1BvcyhwYXJlbnRNZW51LT5oV25kLCAwLCAwLCAwLCAwLCAwLAoJCSAgICAgICAgIFNXUF9OT0FDVElWQVRFIHwgU1dQX05PTU9WRSB8IFNXUF9OT1NJWkUgfCBTV1BfTk9aT1JERVIpOwoJfQogICAgfQoKICAgIHJldHVybiBvbGRmbGFnczsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgR2V0TWVudVN0cmluZ0EgICAgKFVTRVIzMi5AKQogKi8KSU5UIFdJTkFQSSBHZXRNZW51U3RyaW5nQSgKCUhNRU5VIGhNZW51LAkvKiBbaW5dIG1lbnVoYW5kbGUgKi8KCVVJTlQgd0l0ZW1JRCwJLyogW2luXSBtZW51IGl0ZW0gKGRlcC4gb24gd0ZsYWdzKSAqLwoJTFBTVFIgc3RyLAkvKiBbb3V0XSBvdXRidWZmZXIuIElmIE5VTEwsIGZ1bmMgcmV0dXJucyBlbnRyeSBsZW5ndGgqLwoJSU5UIG5NYXhTaXosCS8qIFtpbl0gbGVuZ3RoIG9mIGJ1ZmZlci4gaWYgMCwgZnVuYyByZXR1cm5zIGVudHJ5IGxlbiovCglVSU5UIHdGbGFncwkvKiBbaW5dIE1GXyBmbGFncyAqLwopIHsKICAgIE1FTlVJVEVNICppdGVtOwoKICAgIFRSQUNFKCJtZW51PSVwIGl0ZW09JTA0eCBwdHI9JXAgbGVuPSVkIGZsYWdzPSUwNHhcbiIsIGhNZW51LCB3SXRlbUlELCBzdHIsIG5NYXhTaXosIHdGbGFncyApOwogICAgaWYgKCEoaXRlbSA9IE1FTlVfRmluZEl0ZW0oICZoTWVudSwgJndJdGVtSUQsIHdGbGFncyApKSkgcmV0dXJuIDA7CiAgICBpZiAoIUlTX1NUUklOR19JVEVNKGl0ZW0tPmZUeXBlKSkgcmV0dXJuIDA7CiAgICBpZiAoIXN0ciB8fCAhbk1heFNpeikgcmV0dXJuIHN0cmxlblcoaXRlbS0+dGV4dCk7CiAgICBzdHJbMF0gPSAnXDAnOwogICAgaWYgKCFXaWRlQ2hhclRvTXVsdGlCeXRlKCBDUF9BQ1AsIDAsIGl0ZW0tPnRleHQsIC0xLCBzdHIsIG5NYXhTaXosIE5VTEwsIE5VTEwgKSkKICAgICAgICBzdHJbbk1heFNpei0xXSA9IDA7CiAgICBUUkFDRSgicmV0dXJuaW5nICclcydcbiIsIHN0ciApOwogICAgcmV0dXJuIHN0cmxlbihzdHIpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBHZXRNZW51U3RyaW5nVyAgICAoVVNFUjMyLkApCiAqLwpJTlQgV0lOQVBJIEdldE1lbnVTdHJpbmdXKCBITUVOVSBoTWVudSwgVUlOVCB3SXRlbUlELAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTFBXU1RSIHN0ciwgSU5UIG5NYXhTaXosIFVJTlQgd0ZsYWdzICkKewogICAgTUVOVUlURU0gKml0ZW07CgogICAgVFJBQ0UoIm1lbnU9JXAgaXRlbT0lMDR4IHB0cj0lcCBsZW49JWQgZmxhZ3M9JTA0eFxuIiwgaE1lbnUsIHdJdGVtSUQsIHN0ciwgbk1heFNpeiwgd0ZsYWdzICk7CiAgICBpZiAoIShpdGVtID0gTUVOVV9GaW5kSXRlbSggJmhNZW51LCAmd0l0ZW1JRCwgd0ZsYWdzICkpKSByZXR1cm4gMDsKICAgIGlmICghSVNfU1RSSU5HX0lURU0oaXRlbS0+ZlR5cGUpKSByZXR1cm4gMDsKICAgIGlmICghc3RyIHx8ICFuTWF4U2l6KSByZXR1cm4gc3RybGVuVyhpdGVtLT50ZXh0KTsKICAgIHN0clswXSA9ICdcMCc7CiAgICBsc3RyY3B5blcoIHN0ciwgaXRlbS0+dGV4dCwgbk1heFNpeiApOwogICAgcmV0dXJuIHN0cmxlblcoc3RyKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgSGlsaXRlTWVudUl0ZW0gICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgSGlsaXRlTWVudUl0ZW0oIEhXTkQgaFduZCwgSE1FTlUgaE1lbnUsIFVJTlQgd0l0ZW1JRCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVSU5UIHdIaWxpdGUgKQp7CiAgICBMUFBPUFVQTUVOVSBtZW51OwogICAgVFJBQ0UoIiglcCwgJXAsICUwNHgsICUwNHgpO1xuIiwgaFduZCwgaE1lbnUsIHdJdGVtSUQsIHdIaWxpdGUpOwogICAgaWYgKCFNRU5VX0ZpbmRJdGVtKCAmaE1lbnUsICZ3SXRlbUlELCB3SGlsaXRlICkpIHJldHVybiBGQUxTRTsKICAgIGlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpKSkgcmV0dXJuIEZBTFNFOwogICAgaWYgKG1lbnUtPkZvY3VzZWRJdGVtID09IHdJdGVtSUQpIHJldHVybiBUUlVFOwogICAgTUVOVV9IaWRlU3ViUG9wdXBzKCBoV25kLCBoTWVudSwgRkFMU0UgKTsKICAgIE1FTlVfU2VsZWN0SXRlbSggaFduZCwgaE1lbnUsIHdJdGVtSUQsIFRSVUUsIDAgKTsKICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBHZXRNZW51U3RhdGUgICAgKFVTRVIzMi5AKQogKi8KVUlOVCBXSU5BUEkgR2V0TWVudVN0YXRlKCBITUVOVSBoTWVudSwgVUlOVCB3SXRlbUlELCBVSU5UIHdGbGFncyApCnsKICAgIE1FTlVJVEVNICppdGVtOwogICAgVFJBQ0UoIihtZW51PSVwLCBpZD0lMDR4LCBmbGFncz0lMDR4KTtcbiIsIGhNZW51LCB3SXRlbUlELCB3RmxhZ3MpOwogICAgaWYgKCEoaXRlbSA9IE1FTlVfRmluZEl0ZW0oICZoTWVudSwgJndJdGVtSUQsIHdGbGFncyApKSkgcmV0dXJuIC0xOwogICAgZGVidWdfcHJpbnRfbWVudWl0ZW0gKCIgIGl0ZW06ICIsIGl0ZW0sICIiKTsKICAgIGlmIChpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKQogICAgewoJUE9QVVBNRU5VICptZW51ID0gTUVOVV9HZXRNZW51KCBpdGVtLT5oU3ViTWVudSApOwoJaWYgKCFtZW51KSByZXR1cm4gLTE7CgllbHNlIHJldHVybiAobWVudS0+bkl0ZW1zIDw8IDgpIHwgKChpdGVtLT5mU3RhdGV8aXRlbS0+ZlR5cGUpICYgMHhmZik7CiAgICB9CiAgICBlbHNlCiAgICB7CgkvKiBXZSB1c2VkIHRvIChmcm9tIHdheSBiYWNrIHRoZW4pIG1hc2sgdGhlIHJlc3VsdCB0byAweGZmLiAgKi8KCS8qIEkgZG9uJ3Qga25vdyB3aHkgYW5kIGl0IHNlZW1zIHdyb25nIGFzIHRoZSBkb2N1bWVudGVkICovCgkvKiByZXR1cm4gZmxhZyBNRl9TRVBBUkFUT1IgaXMgb3V0c2lkZSB0aGF0IG1hc2suICAqLwoJcmV0dXJuIChpdGVtLT5mVHlwZSB8IGl0ZW0tPmZTdGF0ZSk7CiAgICB9Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEdldE1lbnVJdGVtQ291bnQgICAgKFVTRVIzMi5AKQogKi8KSU5UIFdJTkFQSSBHZXRNZW51SXRlbUNvdW50KCBITUVOVSBoTWVudSApCnsKICAgIExQUE9QVVBNRU5VCW1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpOwogICAgaWYgKCFtZW51KSByZXR1cm4gLTE7CiAgICBUUkFDRSgiKCVwKSByZXR1cm5pbmcgJWRcbiIsIGhNZW51LCBtZW51LT5uSXRlbXMgKTsKICAgIHJldHVybiBtZW51LT5uSXRlbXM7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEdldE1lbnVJdGVtSUQgICAgKFVTRVIzMi5AKQogKi8KVUlOVCBXSU5BUEkgR2V0TWVudUl0ZW1JRCggSE1FTlUgaE1lbnUsIElOVCBuUG9zICkKewogICAgTUVOVUlURU0gKiBscG1pOwoKICAgIGlmICghKGxwbWkgPSBNRU5VX0ZpbmRJdGVtKCZoTWVudSwmblBvcyxNRl9CWVBPU0lUSU9OKSkpIHJldHVybiAtMTsKICAgIGlmIChscG1pLT5mVHlwZSAmIE1GX1BPUFVQKSByZXR1cm4gLTE7CiAgICByZXR1cm4gbHBtaS0+d0lEOwoKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgSW5zZXJ0TWVudVcgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgSW5zZXJ0TWVudVcoIEhNRU5VIGhNZW51LCBVSU5UIHBvcywgVUlOVCBmbGFncywKICAgICAgICAgICAgICAgICAgICAgICAgIFVJTlRfUFRSIGlkLCBMUENXU1RSIHN0ciApCnsKICAgIE1FTlVJVEVNICppdGVtOwoKICAgIGlmIChJU19TVFJJTkdfSVRFTShmbGFncykgJiYgc3RyKQogICAgICAgIFRSQUNFKCJoTWVudSAlcCwgcG9zICVkLCBmbGFncyAlMDh4LCBpZCAlMDR4LCBzdHIgJXNcbiIsCiAgICAgICAgICAgICAgaE1lbnUsIHBvcywgZmxhZ3MsIGlkLCBkZWJ1Z3N0cl93KHN0cikgKTsKICAgIGVsc2UgVFJBQ0UoImhNZW51ICVwLCBwb3MgJWQsIGZsYWdzICUwOHgsIGlkICUwNHgsIHN0ciAlMDhseCAobm90IGEgc3RyaW5nKVxuIiwKICAgICAgICAgICAgICAgaE1lbnUsIHBvcywgZmxhZ3MsIGlkLCAoRFdPUkQpc3RyICk7CgogICAgaWYgKCEoaXRlbSA9IE1FTlVfSW5zZXJ0SXRlbSggaE1lbnUsIHBvcywgZmxhZ3MgKSkpIHJldHVybiBGQUxTRTsKCiAgICBpZiAoIShNRU5VX1NldEl0ZW1EYXRhKCBpdGVtLCBmbGFncywgaWQsIHN0ciApKSkKICAgIHsKICAgICAgICBSZW1vdmVNZW51KCBoTWVudSwgcG9zLCBmbGFncyApOwogICAgICAgIHJldHVybiBGQUxTRTsKICAgIH0KCiAgICBpZiAoZmxhZ3MgJiBNRl9QT1BVUCkgIC8qIFNldCB0aGUgTUZfUE9QVVAgZmxhZyBvbiB0aGUgcG9wdXAtbWVudSAqLwoJKE1FTlVfR2V0TWVudSgoSE1FTlUpaWQpKS0+d0ZsYWdzIHw9IE1GX1BPUFVQOwoKICAgIGl0ZW0tPmhDaGVja0JpdCA9IGl0ZW0tPmhVbkNoZWNrQml0ID0gMDsKICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBJbnNlcnRNZW51QSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBJbnNlcnRNZW51QSggSE1FTlUgaE1lbnUsIFVJTlQgcG9zLCBVSU5UIGZsYWdzLAogICAgICAgICAgICAgICAgICAgICAgICAgVUlOVF9QVFIgaWQsIExQQ1NUUiBzdHIgKQp7CiAgICBCT09MIHJldCA9IEZBTFNFOwoKICAgIGlmIChJU19TVFJJTkdfSVRFTShmbGFncykgJiYgc3RyKQogICAgewogICAgICAgIElOVCBsZW4gPSBNdWx0aUJ5dGVUb1dpZGVDaGFyKCBDUF9BQ1AsIDAsIHN0ciwgLTEsIE5VTEwsIDAgKTsKICAgICAgICBMUFdTVFIgbmV3c3RyID0gSGVhcEFsbG9jKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBsZW4gKiBzaXplb2YoV0NIQVIpICk7CiAgICAgICAgaWYgKG5ld3N0cikKICAgICAgICB7CiAgICAgICAgICAgIE11bHRpQnl0ZVRvV2lkZUNoYXIoIENQX0FDUCwgMCwgc3RyLCAtMSwgbmV3c3RyLCBsZW4gKTsKICAgICAgICAgICAgcmV0ID0gSW5zZXJ0TWVudVcoIGhNZW51LCBwb3MsIGZsYWdzLCBpZCwgbmV3c3RyICk7CiAgICAgICAgICAgIEhlYXBGcmVlKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBuZXdzdHIgKTsKICAgICAgICB9CiAgICAgICAgcmV0dXJuIHJldDsKICAgIH0KICAgIGVsc2UgcmV0dXJuIEluc2VydE1lbnVXKCBoTWVudSwgcG9zLCBmbGFncywgaWQsIChMUENXU1RSKXN0ciApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBBcHBlbmRNZW51QSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBBcHBlbmRNZW51QSggSE1FTlUgaE1lbnUsIFVJTlQgZmxhZ3MsCiAgICAgICAgICAgICAgICAgICAgICAgICBVSU5UX1BUUiBpZCwgTFBDU1RSIGRhdGEgKQp7CiAgICByZXR1cm4gSW5zZXJ0TWVudUEoIGhNZW51LCAtMSwgZmxhZ3MgfCBNRl9CWVBPU0lUSU9OLCBpZCwgZGF0YSApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBBcHBlbmRNZW51VyAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBBcHBlbmRNZW51VyggSE1FTlUgaE1lbnUsIFVJTlQgZmxhZ3MsCiAgICAgICAgICAgICAgICAgICAgICAgICBVSU5UX1BUUiBpZCwgTFBDV1NUUiBkYXRhICkKewogICAgcmV0dXJuIEluc2VydE1lbnVXKCBoTWVudSwgLTEsIGZsYWdzIHwgTUZfQllQT1NJVElPTiwgaWQsIGRhdGEgKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgUmVtb3ZlTWVudSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBSZW1vdmVNZW51KCBITUVOVSBoTWVudSwgVUlOVCBuUG9zLCBVSU5UIHdGbGFncyApCnsKICAgIExQUE9QVVBNRU5VCW1lbnU7CiAgICBNRU5VSVRFTSAqaXRlbTsKCiAgICBUUkFDRSgiKG1lbnU9JXAgcG9zPSUwNHggZmxhZ3M9JTA0eClcbiIsaE1lbnUsIG5Qb3MsIHdGbGFncyk7CiAgICBpZiAoIShpdGVtID0gTUVOVV9GaW5kSXRlbSggJmhNZW51LCAmblBvcywgd0ZsYWdzICkpKSByZXR1cm4gRkFMU0U7CiAgICBpZiAoIShtZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KSkpIHJldHVybiBGQUxTRTsKCiAgICAgIC8qIFJlbW92ZSBpdGVtICovCgogICAgTUVOVV9GcmVlSXRlbURhdGEoIGl0ZW0gKTsKCiAgICBpZiAoLS1tZW51LT5uSXRlbXMgPT0gMCkKICAgIHsKICAgICAgICBIZWFwRnJlZSggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgbWVudS0+aXRlbXMgKTsKICAgICAgICBtZW51LT5pdGVtcyA9IE5VTEw7CiAgICB9CiAgICBlbHNlCiAgICB7Cgl3aGlsZShuUG9zIDwgbWVudS0+bkl0ZW1zKQoJewoJICAgICppdGVtID0gKihpdGVtKzEpOwoJICAgIGl0ZW0rKzsKCSAgICBuUG9zKys7Cgl9CiAgICAgICAgbWVudS0+aXRlbXMgPSBIZWFwUmVBbGxvYyggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgbWVudS0+aXRlbXMsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbWVudS0+bkl0ZW1zICogc2l6ZW9mKE1FTlVJVEVNKSApOwogICAgfQogICAgcmV0dXJuIFRSVUU7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIERlbGV0ZU1lbnUgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgRGVsZXRlTWVudSggSE1FTlUgaE1lbnUsIFVJTlQgblBvcywgVUlOVCB3RmxhZ3MgKQp7CiAgICBNRU5VSVRFTSAqaXRlbSA9IE1FTlVfRmluZEl0ZW0oICZoTWVudSwgJm5Qb3MsIHdGbGFncyApOwogICAgaWYgKCFpdGVtKSByZXR1cm4gRkFMU0U7CiAgICBpZiAoaXRlbS0+ZlR5cGUgJiBNRl9QT1BVUCkgRGVzdHJveU1lbnUoIGl0ZW0tPmhTdWJNZW51ICk7CiAgICAgIC8qIG5Qb3MgaXMgbm93IHRoZSBwb3NpdGlvbiBvZiB0aGUgaXRlbSAqLwogICAgUmVtb3ZlTWVudSggaE1lbnUsIG5Qb3MsIHdGbGFncyB8IE1GX0JZUE9TSVRJT04gKTsKICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBNb2RpZnlNZW51VyAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBNb2RpZnlNZW51VyggSE1FTlUgaE1lbnUsIFVJTlQgcG9zLCBVSU5UIGZsYWdzLAogICAgICAgICAgICAgICAgICAgICAgICAgVUlOVF9QVFIgaWQsIExQQ1dTVFIgc3RyICkKewogICAgTUVOVUlURU0gKml0ZW07CgogICAgaWYgKElTX1NUUklOR19JVEVNKGZsYWdzKSkKICAgIHsKICAgICAgICBUUkFDRSgiJXAgJWQgJTA0eCAlMDR4ICVzXG4iLCBoTWVudSwgcG9zLCBmbGFncywgaWQsIGRlYnVnc3RyX3coc3RyKSApOwogICAgfQogICAgZWxzZQogICAgewogICAgICAgIFRSQUNFKCIlcCAlZCAlMDR4ICUwNHggJTA4bHhcbiIsIGhNZW51LCBwb3MsIGZsYWdzLCBpZCwgKERXT1JEKXN0ciApOwogICAgfQoKICAgIGlmICghKGl0ZW0gPSBNRU5VX0ZpbmRJdGVtKCAmaE1lbnUsICZwb3MsIGZsYWdzICkpKSByZXR1cm4gRkFMU0U7CiAgICByZXR1cm4gTUVOVV9TZXRJdGVtRGF0YSggaXRlbSwgZmxhZ3MsIGlkLCBzdHIgKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgTW9kaWZ5TWVudUEgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgTW9kaWZ5TWVudUEoIEhNRU5VIGhNZW51LCBVSU5UIHBvcywgVUlOVCBmbGFncywKICAgICAgICAgICAgICAgICAgICAgICAgIFVJTlRfUFRSIGlkLCBMUENTVFIgc3RyICkKewogICAgQk9PTCByZXQgPSBGQUxTRTsKCiAgICBpZiAoSVNfU1RSSU5HX0lURU0oZmxhZ3MpICYmIHN0cikKICAgIHsKICAgICAgICBJTlQgbGVuID0gTXVsdGlCeXRlVG9XaWRlQ2hhciggQ1BfQUNQLCAwLCBzdHIsIC0xLCBOVUxMLCAwICk7CiAgICAgICAgTFBXU1RSIG5ld3N0ciA9IEhlYXBBbGxvYyggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgbGVuICogc2l6ZW9mKFdDSEFSKSApOwogICAgICAgIGlmIChuZXdzdHIpCiAgICAgICAgewogICAgICAgICAgICBNdWx0aUJ5dGVUb1dpZGVDaGFyKCBDUF9BQ1AsIDAsIHN0ciwgLTEsIG5ld3N0ciwgbGVuICk7CiAgICAgICAgICAgIHJldCA9IE1vZGlmeU1lbnVXKCBoTWVudSwgcG9zLCBmbGFncywgaWQsIG5ld3N0ciApOwogICAgICAgICAgICBIZWFwRnJlZSggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgbmV3c3RyICk7CiAgICAgICAgfQogICAgICAgIHJldHVybiByZXQ7CiAgICB9CiAgICBlbHNlIHJldHVybiBNb2RpZnlNZW51VyggaE1lbnUsIHBvcywgZmxhZ3MsIGlkLCAoTFBDV1NUUilzdHIgKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgQ3JlYXRlUG9wdXBNZW51ICAgIChVU0VSMzIuQCkKICovCkhNRU5VIFdJTkFQSSBDcmVhdGVQb3B1cE1lbnUodm9pZCkKewogICAgSE1FTlUgaG1lbnU7CiAgICBQT1BVUE1FTlUgKm1lbnU7CgogICAgaWYgKCEoaG1lbnUgPSBDcmVhdGVNZW51KCkpKSByZXR1cm4gMDsKICAgIG1lbnUgPSBNRU5VX0dldE1lbnUoIGhtZW51ICk7CiAgICBtZW51LT53RmxhZ3MgfD0gTUZfUE9QVVA7CiAgICBtZW51LT5iVGltZVRvSGlkZSA9IEZBTFNFOwogICAgcmV0dXJuIGhtZW51Owp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBHZXRNZW51Q2hlY2tNYXJrRGltZW5zaW9ucyAgICAoVVNFUi40MTcpCiAqICAgICAgICAgR2V0TWVudUNoZWNrTWFya0RpbWVuc2lvbnMgICAgKFVTRVIzMi5AKQogKi8KRFdPUkQgV0lOQVBJIEdldE1lbnVDaGVja01hcmtEaW1lbnNpb25zKHZvaWQpCnsKICAgIHJldHVybiBNQUtFTE9ORyggR2V0U3lzdGVtTWV0cmljcyhTTV9DWE1FTlVDSEVDSyksIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lNRU5VQ0hFQ0spICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIFNldE1lbnVJdGVtQml0bWFwcyAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBTZXRNZW51SXRlbUJpdG1hcHMoIEhNRU5VIGhNZW51LCBVSU5UIG5Qb3MsIFVJTlQgd0ZsYWdzLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBIQklUTUFQIGhOZXdVbkNoZWNrLCBIQklUTUFQIGhOZXdDaGVjaykKewogICAgTUVOVUlURU0gKml0ZW07CiAgICBUUkFDRSgiKCVwLCAlMDR4LCAlMDR4LCAlcCwgJXApXG4iLAogICAgICAgICAgaE1lbnUsIG5Qb3MsIHdGbGFncywgaE5ld0NoZWNrLCBoTmV3VW5DaGVjayk7CiAgICBpZiAoIShpdGVtID0gTUVOVV9GaW5kSXRlbSggJmhNZW51LCAmblBvcywgd0ZsYWdzICkpKSByZXR1cm4gRkFMU0U7CgogICAgaWYgKCFoTmV3Q2hlY2sgJiYgIWhOZXdVbkNoZWNrKQogICAgewoJaXRlbS0+ZlN0YXRlICY9IH5NRl9VU0VDSEVDS0JJVE1BUFM7CiAgICB9CiAgICBlbHNlICAvKiBJbnN0YWxsIG5ldyBiaXRtYXBzICovCiAgICB7CglpdGVtLT5oQ2hlY2tCaXQgPSBoTmV3Q2hlY2s7CglpdGVtLT5oVW5DaGVja0JpdCA9IGhOZXdVbkNoZWNrOwoJaXRlbS0+ZlN0YXRlIHw9IE1GX1VTRUNIRUNLQklUTUFQUzsKICAgIH0KICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBDcmVhdGVNZW51ICAgIChVU0VSMzIuQCkKICovCkhNRU5VIFdJTkFQSSBDcmVhdGVNZW51KHZvaWQpCnsKICAgIEhNRU5VIGhNZW51OwogICAgTFBQT1BVUE1FTlUgbWVudTsKICAgIGlmICghKGhNZW51ID0gVVNFUl9IRUFQX0FMTE9DKCBzaXplb2YoUE9QVVBNRU5VKSApKSkgcmV0dXJuIDA7CiAgICBtZW51ID0gKExQUE9QVVBNRU5VKSBVU0VSX0hFQVBfTElOX0FERFIoaE1lbnUpOwoKICAgIFplcm9NZW1vcnkobWVudSwgc2l6ZW9mKFBPUFVQTUVOVSkpOwogICAgbWVudS0+d01hZ2ljID0gTUVOVV9NQUdJQzsKICAgIG1lbnUtPkZvY3VzZWRJdGVtID0gTk9fU0VMRUNURURfSVRFTTsKICAgIG1lbnUtPmJUaW1lVG9IaWRlID0gRkFMU0U7CgogICAgVFJBQ0UoInJldHVybiAlcFxuIiwgaE1lbnUgKTsKCiAgICByZXR1cm4gaE1lbnU7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIERlc3Ryb3lNZW51ICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIERlc3Ryb3lNZW51KCBITUVOVSBoTWVudSApCnsKICAgIFRSQUNFKCIoJXApXG4iLCBoTWVudSk7CgogICAgLyogU2lsZW50bHkgaWdub3JlIGF0dGVtcHRzIHRvIGRlc3Ryb3kgZGVmYXVsdCBzeXN0ZW0gcG9wdXAgKi8KCiAgICBpZiAoaE1lbnUgJiYgaE1lbnUgIT0gTUVOVV9EZWZTeXNQb3B1cCkKICAgIHsKICAgICAgICBMUFBPUFVQTUVOVSBscHBvcCA9IE1FTlVfR2V0TWVudShoTWVudSk7CgogICAgICAgIGlmICghbHBwb3ApIHJldHVybiBGQUxTRTsKCiAgICAgICAgbHBwb3AtPndNYWdpYyA9IDA7ICAvKiBNYXJrIGl0IGFzIGRlc3Ryb3llZCAqLwoKICAgICAgICAvKiBEZXN0cm95TWVudSBzaG91bGQgbm90IGRlc3Ryb3kgc3lzdGVtIG1lbnUgcG9wdXAgb3duZXIgKi8KICAgICAgICBpZiAoKGxwcG9wLT53RmxhZ3MgJiAoTUZfUE9QVVAgfCBNRl9TWVNNRU5VKSkgPT0gTUZfUE9QVVAgJiYgbHBwb3AtPmhXbmQpCiAgICAgICAgewogICAgICAgICAgICBEZXN0cm95V2luZG93KCBscHBvcC0+aFduZCApOwogICAgICAgICAgICBscHBvcC0+aFduZCA9IDA7CiAgICAgICAgfQoKICAgICAgICBpZiAobHBwb3AtPml0ZW1zKSAvKiByZWN1cnNpdmVseSBkZXN0cm95IHN1Ym1lbnVzICovCiAgICAgICAgewogICAgICAgICAgICBpbnQgaTsKICAgICAgICAgICAgTUVOVUlURU0gKml0ZW0gPSBscHBvcC0+aXRlbXM7CiAgICAgICAgICAgIGZvciAoaSA9IGxwcG9wLT5uSXRlbXM7IGkgPiAwOyBpLS0sIGl0ZW0rKykKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgaWYgKGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApIERlc3Ryb3lNZW51KGl0ZW0tPmhTdWJNZW51KTsKICAgICAgICAgICAgICAgIE1FTlVfRnJlZUl0ZW1EYXRhKCBpdGVtICk7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgSGVhcEZyZWUoIEdldFByb2Nlc3NIZWFwKCksIDAsIGxwcG9wLT5pdGVtcyApOwogICAgICAgIH0KICAgICAgICBVU0VSX0hFQVBfRlJFRSggaE1lbnUgKTsKICAgIH0KICAgIHJldHVybiAoaE1lbnUgIT0gTUVOVV9EZWZTeXNQb3B1cCk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEdldFN5c3RlbU1lbnUgICAgKFVTRVIzMi5AKQogKi8KSE1FTlUgV0lOQVBJIEdldFN5c3RlbU1lbnUoIEhXTkQgaFduZCwgQk9PTCBiUmV2ZXJ0ICkKewogICAgV05EICp3bmRQdHIgPSBXSU5fR2V0UHRyKCBoV25kICk7CiAgICBITUVOVSByZXR2YWx1ZSA9IDA7CgogICAgaWYgKHduZFB0ciA9PSBXTkRfT1RIRVJfUFJPQ0VTUykKICAgIHsKICAgICAgICBpZiAoSXNXaW5kb3coIGhXbmQgKSkgRklYTUUoICJub3Qgc3VwcG9ydGVkIG9uIG90aGVyIHByb2Nlc3Mgd2luZG93ICVwXG4iLCBoV25kICk7CiAgICB9CiAgICBlbHNlIGlmICh3bmRQdHIpCiAgICB7CglpZiggd25kUHRyLT5oU3lzTWVudSApCgl7CgkgICAgaWYoIGJSZXZlcnQgKQoJICAgIHsKCQlEZXN0cm95TWVudSh3bmRQdHItPmhTeXNNZW51KTsKCQl3bmRQdHItPmhTeXNNZW51ID0gMDsKCSAgICB9CgkgICAgZWxzZQoJICAgIHsKCQlQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoIHduZFB0ci0+aFN5c01lbnUgKTsKCQlpZiggbWVudSApCiAgICAgICAgICAgICAgICB7CgkJICAgaWYoIG1lbnUtPm5JdGVtcyA+IDAgJiYgbWVudS0+aXRlbXNbMF0uaFN1Yk1lbnUgPT0gTUVOVV9EZWZTeXNQb3B1cCApCgkJICAgICAgbWVudS0+aXRlbXNbMF0uaFN1Yk1lbnUgPSBNRU5VX0NvcHlTeXNQb3B1cCgpOwoJCX0KCQllbHNlCgkJewoJCSAgIFdBUk4oIkN1cnJlbnQgc3lzLW1lbnUgKCVwKSBvZiB3bmQgJXAgaXMgYnJva2VuXG4iLAoJCQl3bmRQdHItPmhTeXNNZW51LCBoV25kKTsKCQkgICB3bmRQdHItPmhTeXNNZW51ID0gMDsKCQl9CgkgICAgfQoJfQoKCWlmKCF3bmRQdHItPmhTeXNNZW51ICYmICh3bmRQdHItPmR3U3R5bGUgJiBXU19TWVNNRU5VKSApCgkgICAgd25kUHRyLT5oU3lzTWVudSA9IE1FTlVfR2V0U3lzTWVudSggaFduZCwgKEhNRU5VKSgtMSkgKTsKCglpZiggd25kUHRyLT5oU3lzTWVudSApCiAgICAgICAgewoJICAgIFBPUFVQTUVOVSAqbWVudTsKCSAgICByZXR2YWx1ZSA9IEdldFN1Yk1lbnUod25kUHRyLT5oU3lzTWVudSwgMCk7CgoJICAgIC8qIFN0b3JlIHRoZSBkdW1teSBzeXNtZW51IGhhbmRsZSB0byBmYWNpbGl0YXRlIHRoZSByZWZyZXNoICovCgkgICAgLyogb2YgdGhlIGNsb3NlIGJ1dHRvbiBpZiB0aGUgU0NfQ0xPU0UgaXRlbSBjaGFuZ2UgKi8KCSAgICBtZW51ID0gTUVOVV9HZXRNZW51KHJldHZhbHVlKTsKCSAgICBpZiAoIG1lbnUgKQoJICAgICAgIG1lbnUtPmhTeXNNZW51T3duZXIgPSB3bmRQdHItPmhTeXNNZW51OwogICAgICAgIH0KICAgICAgICBXSU5fUmVsZWFzZVB0ciggd25kUHRyICk7CiAgICB9CiAgICByZXR1cm4gYlJldmVydCA/IDAgOiByZXR2YWx1ZTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgU2V0U3lzdGVtTWVudSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBTZXRTeXN0ZW1NZW51KCBIV05EIGh3bmQsIEhNRU5VIGhNZW51ICkKewogICAgV05EICp3bmRQdHIgPSBXSU5fR2V0UHRyKCBod25kICk7CgogICAgaWYgKHduZFB0ciAmJiB3bmRQdHIgIT0gV05EX09USEVSX1BST0NFU1MpCiAgICB7CglpZiAod25kUHRyLT5oU3lzTWVudSkgRGVzdHJveU1lbnUoIHduZFB0ci0+aFN5c01lbnUgKTsKCXduZFB0ci0+aFN5c01lbnUgPSBNRU5VX0dldFN5c01lbnUoIGh3bmQsIGhNZW51ICk7CiAgICAgICAgV0lOX1JlbGVhc2VQdHIoIHduZFB0ciApOwoJcmV0dXJuIFRSVUU7CiAgICB9CiAgICByZXR1cm4gRkFMU0U7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEdldE1lbnUgICAgKFVTRVIzMi5AKQogKi8KSE1FTlUgV0lOQVBJIEdldE1lbnUoIEhXTkQgaFduZCApCnsKICAgIEhNRU5VIHJldHZhbHVlID0gKEhNRU5VKUdldFdpbmRvd0xvbmdQdHJXKCBoV25kLCBHV0xQX0lEICk7CiAgICBUUkFDRSgiZm9yICVwIHJldHVybmluZyAlcFxuIiwgaFduZCwgcmV0dmFsdWUpOwogICAgcmV0dXJuIHJldHZhbHVlOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBNRU5VX1NldE1lbnUKICoKICogSGVscGVyIGZvciBTZXRNZW51LiBBbHNvIGNhbGxlZCBieSBXSU5fQ3JlYXRlV2luZG93RXggdG8gYXZvaWQgdGhlCiAqIFNldFdpbmRvd1BvcyBjYWxsIHRoYXQgd291bGQgcmVzdWx0IGlmIFNldE1lbnUgd2VyZSBjYWxsZWQgZGlyZWN0bHkuCiAqLwpCT09MIE1FTlVfU2V0TWVudSggSFdORCBoV25kLCBITUVOVSBoTWVudSApCnsKICAgIFRSQUNFKCIoJXAsICVwKTtcbiIsIGhXbmQsIGhNZW51KTsKCiAgICBpZiAoaE1lbnUgJiYgIUlzTWVudShoTWVudSkpCiAgICB7CiAgICAgICAgV0FSTigiaE1lbnUgJXAgaXMgbm90IGEgbWVudSBoYW5kbGVcbiIsIGhNZW51KTsKICAgICAgICByZXR1cm4gRkFMU0U7CiAgICB9CiAgICBpZiAoR2V0V2luZG93TG9uZ1coIGhXbmQsIEdXTF9TVFlMRSApICYgV1NfQ0hJTEQpIHJldHVybiBGQUxTRTsKCiAgICBoV25kID0gV0lOX0dldEZ1bGxIYW5kbGUoIGhXbmQgKTsKICAgIGlmIChHZXRDYXB0dXJlKCkgPT0gaFduZCkgTUVOVV9TZXRDYXB0dXJlKDApOyAgLyogcmVsZWFzZSB0aGUgY2FwdHVyZSAqLwoKICAgIGlmIChoTWVudSAhPSAwKQogICAgewogICAgICAgIExQUE9QVVBNRU5VIGxwbWVudTsKCiAgICAgICAgaWYgKCEobHBtZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KSkpIHJldHVybiBGQUxTRTsKCiAgICAgICAgbHBtZW51LT5oV25kID0gaFduZDsKICAgICAgICBscG1lbnUtPkhlaWdodCA9IDA7ICAvKiBNYWtlIHN1cmUgd2UgcmVjYWxjdWxhdGUgdGhlIHNpemUgKi8KICAgIH0KICAgIFNldFdpbmRvd0xvbmdQdHJXKCBoV25kLCBHV0xQX0lELCAoTE9OR19QVFIpaE1lbnUgKTsKICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBTZXRNZW51ICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIFNldE1lbnUoIEhXTkQgaFduZCwgSE1FTlUgaE1lbnUgKQp7ICAgCiAgICBpZighTUVOVV9TZXRNZW51KGhXbmQsIGhNZW51KSkKICAgICAgICByZXR1cm4gRkFMU0U7CiAKICAgIFNldFdpbmRvd1BvcyggaFduZCwgMCwgMCwgMCwgMCwgMCwgU1dQX05PU0laRSB8IFNXUF9OT01PVkUgfAogICAgICAgICAgICAgICAgICBTV1BfTk9BQ1RJVkFURSB8IFNXUF9OT1pPUkRFUiB8IFNXUF9GUkFNRUNIQU5HRUQgKTsKICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBHZXRTdWJNZW51ICAgIChVU0VSMzIuQCkKICovCkhNRU5VIFdJTkFQSSBHZXRTdWJNZW51KCBITUVOVSBoTWVudSwgSU5UIG5Qb3MgKQp7CiAgICBNRU5VSVRFTSAqIGxwbWk7CgogICAgaWYgKCEobHBtaSA9IE1FTlVfRmluZEl0ZW0oJmhNZW51LCZuUG9zLE1GX0JZUE9TSVRJT04pKSkgcmV0dXJuIDA7CiAgICBpZiAoIShscG1pLT5mVHlwZSAmIE1GX1BPUFVQKSkgcmV0dXJuIDA7CiAgICByZXR1cm4gbHBtaS0+aFN1Yk1lbnU7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIERyYXdNZW51QmFyICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIERyYXdNZW51QmFyKCBIV05EIGhXbmQgKQp7CiAgICBMUFBPUFVQTUVOVSBscHBvcDsKICAgIEhNRU5VIGhNZW51ID0gR2V0TWVudShoV25kKTsKCiAgICBpZiAoR2V0V2luZG93TG9uZ1coIGhXbmQsIEdXTF9TVFlMRSApICYgV1NfQ0hJTEQpIHJldHVybiBGQUxTRTsKICAgIGlmICghaE1lbnUgfHwgIShscHBvcCA9IE1FTlVfR2V0TWVudSggaE1lbnUgKSkpIHJldHVybiBGQUxTRTsKCiAgICBscHBvcC0+SGVpZ2h0ID0gMDsgLyogTWFrZSBzdXJlIHdlIGNhbGwgTUVOVV9NZW51QmFyQ2FsY1NpemUgKi8KICAgIGxwcG9wLT5od25kT3duZXIgPSBoV25kOwogICAgU2V0V2luZG93UG9zKCBoV25kLCAwLCAwLCAwLCAwLCAwLCBTV1BfTk9TSVpFIHwgU1dQX05PTU9WRSB8CiAgICAgICAgICAgICAgICAgIFNXUF9OT0FDVElWQVRFIHwgU1dQX05PWk9SREVSIHwgU1dQX0ZSQU1FQ0hBTkdFRCApOwogICAgcmV0dXJuIFRSVUU7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgRHJhd01lbnVCYXJUZW1wICAgKFVTRVIzMi5AKQogKgogKiBVTkRPQ1VNRU5URUQgISEKICoKICogY2FsbGVkIGJ5IFc5OFNFIGRlc2suY3BsIENvbnRyb2wgUGFuZWwgQXBwbGV0CiAqCiAqIE5vdCAxMDAlIHN1cmUgYWJvdXQgdGhlIHBhcmFtIG5hbWVzLCBidXQgY2xvc2UuCiAqLwpEV09SRCBXSU5BUEkgRHJhd01lbnVCYXJUZW1wKEhXTkQgaHduZCwgSERDIGhEQywgTFBSRUNUIGxwcmVjdCwgSE1FTlUgaE1lbnUsIEhGT05UIGhGb250KQp7CiAgICBMUFBPUFVQTUVOVSBscHBvcDsKICAgIFVJTlQgaSxyZXR2YWx1ZTsKICAgIEhGT05UIGhmb250T2xkID0gMDsKCiAgICBpZiAoIWhNZW51KQogICAgICAgIGhNZW51ID0gR2V0TWVudShod25kKTsKCiAgICBpZiAoIWhGb250KQogICAgICAgIGhGb250ID0gaE1lbnVGb250OwoKICAgIGxwcG9wID0gTUVOVV9HZXRNZW51KCBoTWVudSApOwogICAgaWYgKGxwcG9wID09IE5VTEwgfHwgbHByZWN0ID09IE5VTEwpCiAgICB7CiAgICAgICAgcmV0dmFsdWUgPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZTUVOVSk7CiAgICAgICAgZ290byBFTkQ7CiAgICB9CgogICAgVFJBQ0UoIiglcCwgJXAsICVwLCAlcCwgJXApXG4iLCBod25kLCBoREMsIGxwcmVjdCwgaE1lbnUsIGhGb250KTsKCiAgICBoZm9udE9sZCA9IFNlbGVjdE9iamVjdCggaERDLCBoRm9udCk7CgogICAgaWYgKGxwcG9wLT5IZWlnaHQgPT0gMCkKICAgICAgICBNRU5VX01lbnVCYXJDYWxjU2l6ZShoREMsIGxwcmVjdCwgbHBwb3AsIGh3bmQpOwoKICAgIGxwcmVjdC0+Ym90dG9tID0gbHByZWN0LT50b3AgKyBscHBvcC0+SGVpZ2h0OwoKICAgIEZpbGxSZWN0KGhEQywgbHByZWN0LCBHZXRTeXNDb2xvckJydXNoKENPTE9SX01FTlUpICk7CgogICAgU2VsZWN0T2JqZWN0KCBoREMsIFNZU0NPTE9SX0dldFBlbihDT0xPUl8zREZBQ0UpKTsKICAgIE1vdmVUb0V4KCBoREMsIGxwcmVjdC0+bGVmdCwgbHByZWN0LT5ib3R0b20sIE5VTEwgKTsKICAgIExpbmVUbyggaERDLCBscHJlY3QtPnJpZ2h0LCBscHJlY3QtPmJvdHRvbSApOwoKICAgIGlmIChscHBvcC0+bkl0ZW1zID09IDApCiAgICB7CiAgICAgICAgcmV0dmFsdWUgPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZTUVOVSk7CiAgICAgICAgZ290byBFTkQ7CiAgICB9CgogICAgZm9yIChpID0gMDsgaSA8IGxwcG9wLT5uSXRlbXM7IGkrKykKICAgIHsKICAgICAgICBNRU5VX0RyYXdNZW51SXRlbSggaHduZCwgaE1lbnUsIGh3bmQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgIGhEQywgJmxwcG9wLT5pdGVtc1tpXSwgbHBwb3AtPkhlaWdodCwgVFJVRSwgT0RBX0RSQVdFTlRJUkUgKTsKICAgIH0KICAgIHJldHZhbHVlID0gbHBwb3AtPkhlaWdodDsKCkVORDoKICAgIGlmIChoZm9udE9sZCkgU2VsZWN0T2JqZWN0IChoREMsIGhmb250T2xkKTsKICAgIHJldHVybiByZXR2YWx1ZTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBFbmRNZW51ICAgKFVTRVIuMTg3KQogKiAgICAgICAgICAgRW5kTWVudSAgIChVU0VSMzIuQCkKICovCnZvaWQgV0lOQVBJIEVuZE1lbnUodm9pZCkKewogICAgLyogaWYgd2UgYXJlIGluIHRoZSBtZW51IGNvZGUsIGFuZCBpdCBpcyBhY3RpdmUgKi8KICAgIGlmICghZkVuZE1lbnUgJiYgdG9wX3BvcHVwKQogICAgewoJLyogdGVybWluYXRlIHRoZSBtZW51IGhhbmRsaW5nIGNvZGUgKi8KICAgICAgICBmRW5kTWVudSA9IFRSVUU7CgoJLyogbmVlZHMgdG8gYmUgcG9zdGVkIHRvIHdha2V1cCB0aGUgaW50ZXJuYWwgbWVudSBoYW5kbGVyICovCgkvKiB3aGljaCB3aWxsIG5vdyB0ZXJtaW5hdGUgdGhlIG1lbnUsIGluIHRoZSBldmVudCB0aGF0ICovCgkvKiB0aGUgbWFpbiB3aW5kb3cgd2FzIG1pbmltaXplZCwgb3IgbG9zdCBmb2N1cywgc28gd2UgKi8KCS8qIGRvbid0IGVuZCB1cCB3aXRoIGFuIG9ycGhhbmVkIG1lbnUgKi8KICAgICAgICBQb3N0TWVzc2FnZVcoIHRvcF9wb3B1cCwgV01fQ0FOQ0VMTU9ERSwgMCwgMCk7CiAgICB9Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIExvb2t1cE1lbnVIYW5kbGUgICAoVVNFUi4yMTcpCiAqLwpITUVOVTE2IFdJTkFQSSBMb29rdXBNZW51SGFuZGxlMTYoIEhNRU5VMTYgaG1lbnUsIElOVDE2IGlkICkKewogICAgSE1FTlUgaG1lbnUzMiA9IEhNRU5VXzMyKGhtZW51KTsKICAgIFVJTlQgaWQzMiA9IGlkOwogICAgaWYgKCFNRU5VX0ZpbmRJdGVtKCAmaG1lbnUzMiwgJmlkMzIsIE1GX0JZQ09NTUFORCApKSByZXR1cm4gMDsKICAgIGVsc2UgcmV0dXJuIEhNRU5VXzE2KGhtZW51MzIpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJICAgIExvYWRNZW51ICAgIChVU0VSLjE1MCkKICovCkhNRU5VMTYgV0lOQVBJIExvYWRNZW51MTYoIEhJTlNUQU5DRTE2IGluc3RhbmNlLCBMUENTVFIgbmFtZSApCnsKICAgIEhSU1JDMTYgaFJzcmM7CiAgICBIR0xPQkFMMTYgaGFuZGxlOwogICAgSE1FTlUxNiBoTWVudTsKCiAgICBpZiAoSElXT1JEKG5hbWUpICYmIG5hbWVbMF0gPT0gJyMnKSBuYW1lID0gKExQQ1NUUilhdG9pKCBuYW1lICsgMSApOwogICAgaWYgKCFuYW1lKSByZXR1cm4gMDsKCiAgICBpbnN0YW5jZSA9IEdldEV4ZVB0ciggaW5zdGFuY2UgKTsKICAgIGlmICghKGhSc3JjID0gRmluZFJlc291cmNlMTYoIGluc3RhbmNlLCBuYW1lLCAoTFBTVFIpUlRfTUVOVSApKSkgcmV0dXJuIDA7CiAgICBpZiAoIShoYW5kbGUgPSBMb2FkUmVzb3VyY2UxNiggaW5zdGFuY2UsIGhSc3JjICkpKSByZXR1cm4gMDsKICAgIGhNZW51ID0gTG9hZE1lbnVJbmRpcmVjdDE2KExvY2tSZXNvdXJjZTE2KGhhbmRsZSkpOwogICAgRnJlZVJlc291cmNlMTYoIGhhbmRsZSApOwogICAgcmV0dXJuIGhNZW51Owp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICBMb2FkTWVudUEgICAoVVNFUjMyLkApCiAqLwpITUVOVSBXSU5BUEkgTG9hZE1lbnVBKCBISU5TVEFOQ0UgaW5zdGFuY2UsIExQQ1NUUiBuYW1lICkKewogICAgSFJTUkMgaHJzcmMgPSBGaW5kUmVzb3VyY2VBKCBpbnN0YW5jZSwgbmFtZSwgKExQU1RSKVJUX01FTlUgKTsKICAgIGlmICghaHJzcmMpIHJldHVybiAwOwogICAgcmV0dXJuIExvYWRNZW51SW5kaXJlY3RBKCAoTFBDVk9JRClMb2FkUmVzb3VyY2UoIGluc3RhbmNlLCBocnNyYyApKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgTG9hZE1lbnVXICAgKFVTRVIzMi5AKQogKi8KSE1FTlUgV0lOQVBJIExvYWRNZW51VyggSElOU1RBTkNFIGluc3RhbmNlLCBMUENXU1RSIG5hbWUgKQp7CiAgICBIUlNSQyBocnNyYyA9IEZpbmRSZXNvdXJjZVcoIGluc3RhbmNlLCBuYW1lLCAoTFBXU1RSKVJUX01FTlUgKTsKICAgIGlmICghaHJzcmMpIHJldHVybiAwOwogICAgcmV0dXJuIExvYWRNZW51SW5kaXJlY3RXKCAoTFBDVk9JRClMb2FkUmVzb3VyY2UoIGluc3RhbmNlLCBocnNyYyApKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCSAgICBMb2FkTWVudUluZGlyZWN0ICAgIChVU0VSLjIyMCkKICovCkhNRU5VMTYgV0lOQVBJIExvYWRNZW51SW5kaXJlY3QxNiggTFBDVk9JRCB0ZW1wbGF0ZSApCnsKICAgIEhNRU5VIGhNZW51OwogICAgV09SRCB2ZXJzaW9uLCBvZmZzZXQ7CiAgICBMUENTVFIgcCA9IChMUENTVFIpdGVtcGxhdGU7CgogICAgVFJBQ0UoIiglcClcbiIsIHRlbXBsYXRlICk7CiAgICB2ZXJzaW9uID0gR0VUX1dPUkQocCk7CiAgICBwICs9IHNpemVvZihXT1JEKTsKICAgIGlmICh2ZXJzaW9uKQogICAgewogICAgICAgIFdBUk4oInZlcnNpb24gbXVzdCBiZSAwIGZvciBXaW4xNlxuIiApOwogICAgICAgIHJldHVybiAwOwogICAgfQogICAgb2Zmc2V0ID0gR0VUX1dPUkQocCk7CiAgICBwICs9IHNpemVvZihXT1JEKSArIG9mZnNldDsKICAgIGlmICghKGhNZW51ID0gQ3JlYXRlTWVudSgpKSkgcmV0dXJuIDA7CiAgICBpZiAoIU1FTlVfUGFyc2VSZXNvdXJjZSggcCwgaE1lbnUsIEZBTFNFICkpCiAgICB7CiAgICAgICAgRGVzdHJveU1lbnUoIGhNZW51ICk7CiAgICAgICAgcmV0dXJuIDA7CiAgICB9CiAgICByZXR1cm4gSE1FTlVfMTYoaE1lbnUpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJICAgIExvYWRNZW51SW5kaXJlY3RXICAgIChVU0VSMzIuQCkKICovCkhNRU5VIFdJTkFQSSBMb2FkTWVudUluZGlyZWN0VyggTFBDVk9JRCB0ZW1wbGF0ZSApCnsKICAgIEhNRU5VIGhNZW51OwogICAgV09SRCB2ZXJzaW9uLCBvZmZzZXQ7CiAgICBMUENTVFIgcCA9IChMUENTVFIpdGVtcGxhdGU7CgogICAgdmVyc2lvbiA9IEdFVF9XT1JEKHApOwogICAgcCArPSBzaXplb2YoV09SRCk7CiAgICBUUkFDRSgiJXAsIHZlciAlZFxuIiwgdGVtcGxhdGUsIHZlcnNpb24gKTsKICAgIHN3aXRjaCAodmVyc2lvbikKICAgIHsKICAgICAgY2FzZSAwOiAvKiBzdGFuZGFyZCBmb3JtYXQgaXMgdmVyc2lvbiBvZiAwICovCglvZmZzZXQgPSBHRVRfV09SRChwKTsKCXAgKz0gc2l6ZW9mKFdPUkQpICsgb2Zmc2V0OwoJaWYgKCEoaE1lbnUgPSBDcmVhdGVNZW51KCkpKSByZXR1cm4gMDsKCWlmICghTUVOVV9QYXJzZVJlc291cmNlKCBwLCBoTWVudSwgVFJVRSApKQoJICB7CgkgICAgRGVzdHJveU1lbnUoIGhNZW51ICk7CgkgICAgcmV0dXJuIDA7CgkgIH0KCXJldHVybiBoTWVudTsKICAgICAgY2FzZSAxOiAvKiBleHRlbmRlZCBmb3JtYXQgaXMgdmVyc2lvbiBvZiAxICovCglvZmZzZXQgPSBHRVRfV09SRChwKTsKCXAgKz0gc2l6ZW9mKFdPUkQpICsgb2Zmc2V0OwoJaWYgKCEoaE1lbnUgPSBDcmVhdGVNZW51KCkpKSByZXR1cm4gMDsKCWlmICghTUVOVUVYX1BhcnNlUmVzb3VyY2UoIHAsIGhNZW51KSkKCSAgewoJICAgIERlc3Ryb3lNZW51KCBoTWVudSApOwoJICAgIHJldHVybiAwOwoJICB9CglyZXR1cm4gaE1lbnU7CiAgICAgIGRlZmF1bHQ6CiAgICAgICAgRVJSKCJ2ZXJzaW9uICVkIG5vdCBzdXBwb3J0ZWQuXG4iLCB2ZXJzaW9uKTsKICAgICAgICByZXR1cm4gMDsKICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCSAgICBMb2FkTWVudUluZGlyZWN0QSAgICAoVVNFUjMyLkApCiAqLwpITUVOVSBXSU5BUEkgTG9hZE1lbnVJbmRpcmVjdEEoIExQQ1ZPSUQgdGVtcGxhdGUgKQp7CiAgICByZXR1cm4gTG9hZE1lbnVJbmRpcmVjdFcoIHRlbXBsYXRlICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJSXNNZW51ICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIElzTWVudShITUVOVSBobWVudSkKewogICAgTFBQT1BVUE1FTlUgbWVudSA9IE1FTlVfR2V0TWVudShobWVudSk7CiAgICByZXR1cm4gbWVudSAhPSBOVUxMOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJR2V0TWVudUl0ZW1JbmZvX2NvbW1vbgogKi8KCnN0YXRpYyBCT09MIEdldE1lbnVJdGVtSW5mb19jb21tb24gKCBITUVOVSBobWVudSwgVUlOVCBpdGVtLCBCT09MIGJ5cG9zLAoJCQkJCUxQTUVOVUlURU1JTkZPVyBscG1paSwgQk9PTCB1bmljb2RlKQp7CiAgICBNRU5VSVRFTSAqbWVudSA9IE1FTlVfRmluZEl0ZW0gKCZobWVudSwgJml0ZW0sIGJ5cG9zPyBNRl9CWVBPU0lUSU9OIDogMCk7CgogICAgZGVidWdfcHJpbnRfbWVudWl0ZW0oIkdldE1lbnVJdGVtSW5mb19jb21tb246ICIsIG1lbnUsICIiKTsKCiAgICBpZiAoIW1lbnUpCglyZXR1cm4gRkFMU0U7CgogICAgaWYgKGxwbWlpLT5mTWFzayAmIE1JSU1fVFlQRSkgewoJbHBtaWktPmZUeXBlID0gbWVudS0+ZlR5cGU7Cglzd2l0Y2ggKE1FTlVfSVRFTV9UWVBFKG1lbnUtPmZUeXBlKSkgewoJY2FzZSBNRl9TVFJJTkc6CiAgICAgICAgICAgIGJyZWFrOyAgLyogd2lsbCBiZSBkb25lIGJlbG93ICovCgljYXNlIE1GX09XTkVSRFJBVzoKCWNhc2UgTUZfQklUTUFQOgoJICAgIGxwbWlpLT5kd1R5cGVEYXRhID0gbWVudS0+dGV4dDsKCSAgICAvKiBmYWxsIHRocm91Z2ggKi8KCWRlZmF1bHQ6CgkgICAgbHBtaWktPmNjaCA9IDA7Cgl9CiAgICB9CgogICAgLyogY29weSB0aGUgdGV4dCBzdHJpbmcgKi8KICAgIGlmICgobHBtaWktPmZNYXNrICYgKE1JSU1fVFlQRXxNSUlNX1NUUklORykpICYmCiAgICAgICAgIChNRU5VX0lURU1fVFlQRShtZW51LT5mVHlwZSkgPT0gTUZfU1RSSU5HKSAmJiBtZW51LT50ZXh0KQogICAgewogICAgICAgIGludCBsZW47CiAgICAgICAgaWYgKHVuaWNvZGUpCiAgICAgICAgewogICAgICAgICAgICBsZW4gPSBzdHJsZW5XKG1lbnUtPnRleHQpOwogICAgICAgICAgICBpZihscG1paS0+ZHdUeXBlRGF0YSAmJiBscG1paS0+Y2NoKQogICAgICAgICAgICAgICAgbHN0cmNweW5XKGxwbWlpLT5kd1R5cGVEYXRhLCBtZW51LT50ZXh0LCBscG1paS0+Y2NoKTsKICAgICAgICB9CiAgICAgICAgZWxzZQogICAgICAgIHsKICAgICAgICAgICAgbGVuID0gV2lkZUNoYXJUb011bHRpQnl0ZSggQ1BfQUNQLCAwLCBtZW51LT50ZXh0LCAtMSwgTlVMTCwgMCwgTlVMTCwgTlVMTCApOwogICAgICAgICAgICBpZihscG1paS0+ZHdUeXBlRGF0YSAmJiBscG1paS0+Y2NoKQogICAgICAgICAgICAgICAgaWYgKCFXaWRlQ2hhclRvTXVsdGlCeXRlKCBDUF9BQ1AsIDAsIG1lbnUtPnRleHQsIC0xLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoTFBTVFIpbHBtaWktPmR3VHlwZURhdGEsIGxwbWlpLT5jY2gsIE5VTEwsIE5VTEwgKSkKICAgICAgICAgICAgICAgICAgICAoKExQU1RSKWxwbWlpLT5kd1R5cGVEYXRhKVtscG1paS0+Y2NoLTFdID0gMDsKICAgICAgICB9CiAgICAgICAgLyogaWYgd2UndmUgY29waWVkIGEgc3Vic3RyaW5nIHdlIHJldHVybiBpdHMgbGVuZ3RoICovCiAgICAgICAgaWYobHBtaWktPmR3VHlwZURhdGEgJiYgbHBtaWktPmNjaCkKICAgICAgICB7CiAgICAgICAgICAgIGlmIChscG1paS0+Y2NoIDw9IGxlbikgbHBtaWktPmNjaC0tOwogICAgICAgIH0KICAgICAgICBlbHNlIC8qIHJldHVybiBsZW5ndGggb2Ygc3RyaW5nICovCiAgICAgICAgICAgIGxwbWlpLT5jY2ggPSBsZW47CiAgICB9CgogICAgaWYgKGxwbWlpLT5mTWFzayAmIE1JSU1fRlRZUEUpCglscG1paS0+ZlR5cGUgPSBtZW51LT5mVHlwZTsKCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9CSVRNQVApCglscG1paS0+aGJtcEl0ZW0gPSBtZW51LT5oYm1wSXRlbTsKCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9TVEFURSkKCWxwbWlpLT5mU3RhdGUgPSBtZW51LT5mU3RhdGU7CgogICAgaWYgKGxwbWlpLT5mTWFzayAmIE1JSU1fSUQpCglscG1paS0+d0lEID0gbWVudS0+d0lEOwoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX1NVQk1FTlUpCglscG1paS0+aFN1Yk1lbnUgPSBtZW51LT5oU3ViTWVudTsKCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9DSEVDS01BUktTKSB7CglscG1paS0+aGJtcENoZWNrZWQgPSBtZW51LT5oQ2hlY2tCaXQ7CglscG1paS0+aGJtcFVuY2hlY2tlZCA9IG1lbnUtPmhVbkNoZWNrQml0OwogICAgfQogICAgaWYgKGxwbWlpLT5mTWFzayAmIE1JSU1fREFUQSkKCWxwbWlpLT5kd0l0ZW1EYXRhID0gbWVudS0+ZHdJdGVtRGF0YTsKCiAgcmV0dXJuIFRSVUU7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCQlHZXRNZW51SXRlbUluZm9BICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIEdldE1lbnVJdGVtSW5mb0EoIEhNRU5VIGhtZW51LCBVSU5UIGl0ZW0sIEJPT0wgYnlwb3MsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBMUE1FTlVJVEVNSU5GT0EgbHBtaWkpCnsKICAgIHJldHVybiBHZXRNZW51SXRlbUluZm9fY29tbW9uIChobWVudSwgaXRlbSwgYnlwb3MsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChMUE1FTlVJVEVNSU5GT1cpbHBtaWksIEZBTFNFKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCUdldE1lbnVJdGVtSW5mb1cgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgR2V0TWVudUl0ZW1JbmZvVyggSE1FTlUgaG1lbnUsIFVJTlQgaXRlbSwgQk9PTCBieXBvcywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIExQTUVOVUlURU1JTkZPVyBscG1paSkKewogICAgcmV0dXJuIEdldE1lbnVJdGVtSW5mb19jb21tb24gKGhtZW51LCBpdGVtLCBieXBvcywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxwbWlpLCBUUlVFKTsKfQoKCi8qIHNldCBhIG1lbnUgaXRlbSB0ZXh0IGZyb20gYSBBU0NJSSBvciBVbmljb2RlIHN0cmluZyAqLwppbmxpbmUgc3RhdGljIHZvaWQgc2V0X21lbnVfaXRlbV90ZXh0KCBNRU5VSVRFTSAqbWVudSwgTFBDV1NUUiB0ZXh0LCBCT09MIHVuaWNvZGUgKQp7CiAgICBpZiAoIXRleHQpCiAgICB7CiAgICAgICAgbWVudS0+dGV4dCA9IE5VTEw7CiAgICAgICAgbWVudS0+ZlR5cGUgfD0gTUZfU0VQQVJBVE9SOwogICAgfQogICAgZWxzZSBpZiAodW5pY29kZSkKICAgIHsKICAgICAgICBpZiAoKG1lbnUtPnRleHQgPSBIZWFwQWxsb2MoIEdldFByb2Nlc3NIZWFwKCksIDAsIChzdHJsZW5XKHRleHQpKzEpICogc2l6ZW9mKFdDSEFSKSApKSkKICAgICAgICAgICAgc3RyY3B5VyggbWVudS0+dGV4dCwgdGV4dCApOwogICAgfQogICAgZWxzZQogICAgewogICAgICAgIExQQ1NUUiBzdHIgPSAoTFBDU1RSKXRleHQ7CiAgICAgICAgaW50IGxlbiA9IE11bHRpQnl0ZVRvV2lkZUNoYXIoIENQX0FDUCwgMCwgc3RyLCAtMSwgTlVMTCwgMCApOwogICAgICAgIGlmICgobWVudS0+dGV4dCA9IEhlYXBBbGxvYyggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgbGVuICogc2l6ZW9mKFdDSEFSKSApKSkKICAgICAgICAgICAgTXVsdGlCeXRlVG9XaWRlQ2hhciggQ1BfQUNQLCAwLCBzdHIsIC0xLCBtZW51LT50ZXh0LCBsZW4gKTsKICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCQlTZXRNZW51SXRlbUluZm9fY29tbW9uCiAqLwoKc3RhdGljIEJPT0wgU2V0TWVudUl0ZW1JbmZvX2NvbW1vbihNRU5VSVRFTSAqIG1lbnUsCgkJCQkgICAgICAgY29uc3QgTUVOVUlURU1JTkZPVyAqbHBtaWksCgkJCQkgICAgICAgQk9PTCB1bmljb2RlKQp7CiAgICBpZiAoIW1lbnUpIHJldHVybiBGQUxTRTsKCiAgICBkZWJ1Z19wcmludF9tZW51aXRlbSgiTUVOVV9TZXRJdGVtSW5mb19jb21tb24gZnJvbTogIiwgbWVudSwgIiIpOwoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX1RZUEUgKSB7CgkvKiBHZXQgcmlkIG9mIG9sZCBzdHJpbmcuICovCglpZiAoSVNfU1RSSU5HX0lURU0obWVudS0+ZlR5cGUpICYmIG1lbnUtPnRleHQpIHsKCSAgICBIZWFwRnJlZShHZXRQcm9jZXNzSGVhcCgpLCAwLCBtZW51LT50ZXh0KTsKCSAgICBtZW51LT50ZXh0ID0gTlVMTDsKCX0KCgkvKiBtYWtlIG9ubHkgTUVOVV9JVEVNX1RZUEUgYml0cyBpbiBtZW51LT5mVHlwZSBlcXVhbCBscG1paS0+ZlR5cGUgKi8KCW1lbnUtPmZUeXBlICY9IH5NRU5VX0lURU1fVFlQRShtZW51LT5mVHlwZSk7CgltZW51LT5mVHlwZSB8PSBNRU5VX0lURU1fVFlQRShscG1paS0+ZlR5cGUpOwoKCW1lbnUtPnRleHQgPSBscG1paS0+ZHdUeXBlRGF0YTsKCiAgICAgICBpZiAoSVNfU1RSSU5HX0lURU0obWVudS0+ZlR5cGUpKQogICAgICAgICAgIHNldF9tZW51X2l0ZW1fdGV4dCggbWVudSwgbHBtaWktPmR3VHlwZURhdGEsIHVuaWNvZGUgKTsKICAgIH0KCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9GVFlQRSApIHsKCS8qIGZyZWUgdGhlIHN0cmluZyB3aGVuIHRoZSB0eXBlIGlzIGNoYW5naW5nICovCglpZiAoICghSVNfU1RSSU5HX0lURU0obHBtaWktPmZUeXBlKSkgJiYgSVNfU1RSSU5HX0lURU0obWVudS0+ZlR5cGUpICYmIG1lbnUtPnRleHQpIHsKCSAgICBIZWFwRnJlZShHZXRQcm9jZXNzSGVhcCgpLCAwLCBtZW51LT50ZXh0KTsKCSAgICBtZW51LT50ZXh0ID0gTlVMTDsKCX0KCW1lbnUtPmZUeXBlICY9IH5NRU5VX0lURU1fVFlQRShtZW51LT5mVHlwZSk7CgltZW51LT5mVHlwZSB8PSBNRU5VX0lURU1fVFlQRShscG1paS0+ZlR5cGUpOwogICAgICAgIGlmICggSVNfU1RSSU5HX0lURU0obWVudS0+ZlR5cGUpICYmICFtZW51LT50ZXh0ICkKICAgICAgICAgICAgbWVudS0+ZlR5cGUgfD0gTUZfU0VQQVJBVE9SOwogICAgfQoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX1NUUklORyApIHsKCWlmIChJU19TVFJJTkdfSVRFTShtZW51LT5mVHlwZSkpIHsKICAgICAgICAgICAgLyogZnJlZSB0aGUgc3RyaW5nIHdoZW4gdXNlZCAqLwogICAgICAgICAgICBIZWFwRnJlZShHZXRQcm9jZXNzSGVhcCgpLCAwLCBtZW51LT50ZXh0KTsKICAgICAgICAgICAgc2V0X21lbnVfaXRlbV90ZXh0KCBtZW51LCBscG1paS0+ZHdUeXBlRGF0YSwgdW5pY29kZSApOwoJfQogICAgfQoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX1NUQVRFKQogICAgewoJLyogRklYTUU6IE1GU19ERUZBVUxUIGRvIHdlIGhhdmUgdG8gcmVzZXQgdGhlIG90aGVyIG1lbnUgaXRlbXM/ICovCgltZW51LT5mU3RhdGUgPSBscG1paS0+ZlN0YXRlOwogICAgfQoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX0lEKQoJbWVudS0+d0lEID0gbHBtaWktPndJRDsKCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9TVUJNRU5VKSB7CgltZW51LT5oU3ViTWVudSA9IGxwbWlpLT5oU3ViTWVudTsKCWlmIChtZW51LT5oU3ViTWVudSkgewoJICAgIFBPUFVQTUVOVSAqc3ViTWVudSA9IE1FTlVfR2V0TWVudShtZW51LT5oU3ViTWVudSk7CgkgICAgaWYgKHN1Yk1lbnUpIHsKCQlzdWJNZW51LT53RmxhZ3MgfD0gTUZfUE9QVVA7CgkJbWVudS0+ZlR5cGUgfD0gTUZfUE9QVVA7CgkgICAgfQoJICAgIGVsc2UKCQkvKiBGSVhNRTogUmV0dXJuIGFuIGVycm9yID8gKi8KCQltZW51LT5mVHlwZSAmPSB+TUZfUE9QVVA7Cgl9CgllbHNlCgkgICAgbWVudS0+ZlR5cGUgJj0gfk1GX1BPUFVQOwogICAgfQoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX0NIRUNLTUFSS1MpCiAgICB7CiAgICAgICAgaWYgKGxwbWlpLT5mVHlwZSAmIE1GVF9SQURJT0NIRUNLKQogICAgICAgICAgICBtZW51LT5mVHlwZSB8PSBNRlRfUkFESU9DSEVDSzsKCgltZW51LT5oQ2hlY2tCaXQgPSBscG1paS0+aGJtcENoZWNrZWQ7CgltZW51LT5oVW5DaGVja0JpdCA9IGxwbWlpLT5oYm1wVW5jaGVja2VkOwogICAgfQogICAgaWYgKGxwbWlpLT5mTWFzayAmIE1JSU1fREFUQSkKCW1lbnUtPmR3SXRlbURhdGEgPSBscG1paS0+ZHdJdGVtRGF0YTsKCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9CSVRNQVApCgltZW51LT5oYm1wSXRlbSA9IGxwbWlpLT5oYm1wSXRlbTsKCiAgICBkZWJ1Z19wcmludF9tZW51aXRlbSgiU2V0TWVudUl0ZW1JbmZvX2NvbW1vbiB0byA6ICIsIG1lbnUsICIiKTsKICAgIHJldHVybiBUUlVFOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJU2V0TWVudUl0ZW1JbmZvQSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBTZXRNZW51SXRlbUluZm9BKEhNRU5VIGhtZW51LCBVSU5UIGl0ZW0sIEJPT0wgYnlwb3MsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IE1FTlVJVEVNSU5GT0EgKmxwbWlpKQp7CiAgICByZXR1cm4gU2V0TWVudUl0ZW1JbmZvX2NvbW1vbihNRU5VX0ZpbmRJdGVtKCZobWVudSwgJml0ZW0sIGJ5cG9zPyBNRl9CWVBPU0lUSU9OIDogMCksCgkJCQkgICAgKGNvbnN0IE1FTlVJVEVNSU5GT1cgKilscG1paSwgRkFMU0UpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJU2V0TWVudUl0ZW1JbmZvVyAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBTZXRNZW51SXRlbUluZm9XKEhNRU5VIGhtZW51LCBVSU5UIGl0ZW0sIEJPT0wgYnlwb3MsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IE1FTlVJVEVNSU5GT1cgKmxwbWlpKQp7CiAgICByZXR1cm4gU2V0TWVudUl0ZW1JbmZvX2NvbW1vbihNRU5VX0ZpbmRJdGVtKCZobWVudSwgJml0ZW0sIGJ5cG9zPyBNRl9CWVBPU0lUSU9OIDogMCksCgkJCQkgICAgbHBtaWksIFRSVUUpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJU2V0TWVudURlZmF1bHRJdGVtICAgIChVU0VSMzIuQCkKICoKICovCkJPT0wgV0lOQVBJIFNldE1lbnVEZWZhdWx0SXRlbShITUVOVSBobWVudSwgVUlOVCB1SXRlbSwgVUlOVCBieXBvcykKewoJVUlOVCBpOwoJUE9QVVBNRU5VICptZW51OwoJTUVOVUlURU0gKml0ZW07CgoJVFJBQ0UoIiglcCwlZCwlZClcbiIsIGhtZW51LCB1SXRlbSwgYnlwb3MpOwoKCWlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoaG1lbnUpKSkgcmV0dXJuIEZBTFNFOwoKCS8qIHJlc2V0IGFsbCBkZWZhdWx0LWl0ZW0gZmxhZ3MgKi8KCWl0ZW0gPSBtZW51LT5pdGVtczsKCWZvciAoaSA9IDA7IGkgPCBtZW51LT5uSXRlbXM7IGkrKywgaXRlbSsrKQoJewoJICAgIGl0ZW0tPmZTdGF0ZSAmPSB+TUZTX0RFRkFVTFQ7Cgl9CgoJLyogbm8gZGVmYXVsdCBpdGVtICovCglpZiAoIC0xID09IHVJdGVtKQoJewoJICAgIHJldHVybiBUUlVFOwoJfQoKCWl0ZW0gPSBtZW51LT5pdGVtczsKCWlmICggYnlwb3MgKQoJewoJICAgIGlmICggdUl0ZW0gPj0gbWVudS0+bkl0ZW1zICkgcmV0dXJuIEZBTFNFOwoJICAgIGl0ZW1bdUl0ZW1dLmZTdGF0ZSB8PSBNRlNfREVGQVVMVDsKCSAgICByZXR1cm4gVFJVRTsKCX0KCWVsc2UKCXsKCSAgICBmb3IgKGkgPSAwOyBpIDwgbWVudS0+bkl0ZW1zOyBpKyssIGl0ZW0rKykKCSAgICB7CgkJaWYgKGl0ZW0tPndJRCA9PSB1SXRlbSkKCQl7CgkJICAgICBpdGVtLT5mU3RhdGUgfD0gTUZTX0RFRkFVTFQ7CgkJICAgICByZXR1cm4gVFJVRTsKCQl9CgkgICAgfQoKCX0KCXJldHVybiBGQUxTRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCUdldE1lbnVEZWZhdWx0SXRlbSAgICAoVVNFUjMyLkApCiAqLwpVSU5UIFdJTkFQSSBHZXRNZW51RGVmYXVsdEl0ZW0oSE1FTlUgaG1lbnUsIFVJTlQgYnlwb3MsIFVJTlQgZmxhZ3MpCnsKCVBPUFVQTUVOVSAqbWVudTsKCU1FTlVJVEVNICogaXRlbTsKCVVJTlQgaSA9IDA7CgoJVFJBQ0UoIiglcCwlZCwlZClcbiIsIGhtZW51LCBieXBvcywgZmxhZ3MpOwoKCWlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoaG1lbnUpKSkgcmV0dXJuIC0xOwoKCS8qIGZpbmQgZGVmYXVsdCBpdGVtICovCglpdGVtID0gbWVudS0+aXRlbXM7CgoJLyogZW1wdHkgbWVudSAqLwoJaWYgKCEgaXRlbSkgcmV0dXJuIC0xOwoKCXdoaWxlICggISggaXRlbS0+ZlN0YXRlICYgTUZTX0RFRkFVTFQgKSApCgl7CgkgICAgaSsrOyBpdGVtKys7CgkgICAgaWYgIChpID49IG1lbnUtPm5JdGVtcyApIHJldHVybiAtMTsKCX0KCgkvKiBkZWZhdWx0OiBkb24ndCByZXR1cm4gZGlzYWJsZWQgaXRlbXMgKi8KCWlmICggKCEoR01ESV9VU0VESVNBQkxFRCAmIGZsYWdzKSkgJiYgKGl0ZW0tPmZTdGF0ZSAmIE1GU19ESVNBQkxFRCApKSByZXR1cm4gLTE7CgoJLyogc2VhcmNoIHJla3Vyc2l2IHdoZW4gbmVlZGVkICovCglpZiAoIChpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKSAmJiAgKGZsYWdzICYgR01ESV9HT0lOVE9QT1BVUFMpICkKCXsKCSAgICBVSU5UIHJldDsKCSAgICByZXQgPSBHZXRNZW51RGVmYXVsdEl0ZW0oIGl0ZW0tPmhTdWJNZW51LCBieXBvcywgZmxhZ3MgKTsKCSAgICBpZiAoIC0xICE9IHJldCApIHJldHVybiByZXQ7CgoJICAgIC8qIHdoZW4gaXRlbSBub3QgZm91bmQgaW4gc3VibWVudSwgcmV0dXJuIHRoZSBwb3B1cCBpdGVtICovCgl9CglyZXR1cm4gKCBieXBvcyApID8gaSA6IGl0ZW0tPndJRDsKCn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJSW5zZXJ0TWVudUl0ZW1BICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIEluc2VydE1lbnVJdGVtQShITUVOVSBoTWVudSwgVUlOVCB1SXRlbSwgQk9PTCBieXBvcywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBNRU5VSVRFTUlORk9BICpscG1paSkKewogICAgTUVOVUlURU0gKml0ZW0gPSBNRU5VX0luc2VydEl0ZW0oaE1lbnUsIHVJdGVtLCBieXBvcyA/IE1GX0JZUE9TSVRJT04gOiAwICk7CiAgICByZXR1cm4gU2V0TWVudUl0ZW1JbmZvX2NvbW1vbihpdGVtLCAoY29uc3QgTUVOVUlURU1JTkZPVyAqKWxwbWlpLCBGQUxTRSk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJSW5zZXJ0TWVudUl0ZW1XICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIEluc2VydE1lbnVJdGVtVyhITUVOVSBoTWVudSwgVUlOVCB1SXRlbSwgQk9PTCBieXBvcywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBNRU5VSVRFTUlORk9XICpscG1paSkKewogICAgTUVOVUlURU0gKml0ZW0gPSBNRU5VX0luc2VydEl0ZW0oaE1lbnUsIHVJdGVtLCBieXBvcyA/IE1GX0JZUE9TSVRJT04gOiAwICk7CiAgICByZXR1cm4gU2V0TWVudUl0ZW1JbmZvX2NvbW1vbihpdGVtLCBscG1paSwgVFJVRSk7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCQlDaGVja01lbnVSYWRpb0l0ZW0gICAgKFVTRVIzMi5AKQogKi8KCkJPT0wgV0lOQVBJIENoZWNrTWVudVJhZGlvSXRlbShITUVOVSBoTWVudSwKCQkJCSAgIFVJTlQgZmlyc3QsIFVJTlQgbGFzdCwgVUlOVCBjaGVjaywKCQkJCSAgIFVJTlQgYnlwb3MpCnsKICAgICBNRU5VSVRFTSAqbWlmaXJzdCwgKm1pbGFzdCwgKm1pY2hlY2s7CiAgICAgSE1FTlUgbWZpcnN0ID0gaE1lbnUsIG1sYXN0ID0gaE1lbnUsIG1jaGVjayA9IGhNZW51OwoKICAgICBUUkFDRSgiJXA6ICVkLSVkLCBjaGVjayAlZCwgYnlwb3M9JWRcbiIsIGhNZW51LCBmaXJzdCwgbGFzdCwgY2hlY2ssIGJ5cG9zKTsKCiAgICAgbWlmaXJzdCA9IE1FTlVfRmluZEl0ZW0gKCZtZmlyc3QsICZmaXJzdCwgYnlwb3MpOwogICAgIG1pbGFzdCA9IE1FTlVfRmluZEl0ZW0gKCZtbGFzdCwgJmxhc3QsIGJ5cG9zKTsKICAgICBtaWNoZWNrID0gTUVOVV9GaW5kSXRlbSAoJm1jaGVjaywgJmNoZWNrLCBieXBvcyk7CgogICAgIGlmIChtaWZpcnN0ID09IE5VTEwgfHwgbWlsYXN0ID09IE5VTEwgfHwgbWljaGVjayA9PSBOVUxMIHx8CgkgbWlmaXJzdCA+IG1pbGFzdCB8fCBtZmlyc3QgIT0gbWxhc3QgfHwgbWZpcnN0ICE9IG1jaGVjayB8fAoJIG1pY2hlY2sgPiBtaWxhc3QgfHwgbWljaGVjayA8IG1pZmlyc3QpCgkgIHJldHVybiBGQUxTRTsKCiAgICAgd2hpbGUgKG1pZmlyc3QgPD0gbWlsYXN0KQogICAgIHsKCSAgaWYgKG1pZmlyc3QgPT0gbWljaGVjaykKCSAgewoJICAgICAgIG1pZmlyc3QtPmZUeXBlIHw9IE1GVF9SQURJT0NIRUNLOwoJICAgICAgIG1pZmlyc3QtPmZTdGF0ZSB8PSBNRlNfQ0hFQ0tFRDsKCSAgfSBlbHNlIHsKCSAgICAgICBtaWZpcnN0LT5mVHlwZSAmPSB+TUZUX1JBRElPQ0hFQ0s7CgkgICAgICAgbWlmaXJzdC0+ZlN0YXRlICY9IH5NRlNfQ0hFQ0tFRDsKCSAgfQoJICBtaWZpcnN0Kys7CiAgICAgfQoKICAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCQlHZXRNZW51SXRlbVJlY3QgICAgKFVTRVIzMi5AKQogKgogKiAgICAgIEFUVEVOVElPTjogSGVyZSwgdGhlIHJldHVybmVkIHZhbHVlcyBpbiByZWN0IGFyZSB0aGUgc2NyZWVuCiAqICAgICAgICAgICAgICAgICBjb29yZGluYXRlcyBvZiB0aGUgaXRlbSBqdXN0IGxpa2UgaWYgdGhlIG1lbnUgd2FzCiAqICAgICAgICAgICAgICAgICBhbHdheXMgb24gdGhlIHVwcGVyIGxlZnQgc2lkZSBvZiB0aGUgYXBwbGljYXRpb24uCiAqCiAqLwpCT09MIFdJTkFQSSBHZXRNZW51SXRlbVJlY3QgKEhXTkQgaHduZCwgSE1FTlUgaE1lbnUsIFVJTlQgdUl0ZW0sCgkJCQkgTFBSRUNUIHJlY3QpCnsKICAgICBQT1BVUE1FTlUgKml0ZW1NZW51OwogICAgIE1FTlVJVEVNICppdGVtOwogICAgIEhXTkQgcmVmZXJlbmNlSHduZDsKCiAgICAgVFJBQ0UoIiglcCwlcCwlZCwlcClcbiIsIGh3bmQsIGhNZW51LCB1SXRlbSwgcmVjdCk7CgogICAgIGl0ZW0gPSBNRU5VX0ZpbmRJdGVtICgmaE1lbnUsICZ1SXRlbSwgTUZfQllQT1NJVElPTik7CiAgICAgcmVmZXJlbmNlSHduZCA9IGh3bmQ7CgogICAgIGlmKCFod25kKQogICAgIHsKCSBpdGVtTWVudSA9IE1FTlVfR2V0TWVudShoTWVudSk7CgkgaWYgKGl0ZW1NZW51ID09IE5VTEwpCgkgICAgIHJldHVybiBGQUxTRTsKCgkgaWYoaXRlbU1lbnUtPmhXbmQgPT0gMCkKCSAgICAgcmV0dXJuIEZBTFNFOwoJIHJlZmVyZW5jZUh3bmQgPSBpdGVtTWVudS0+aFduZDsKICAgICB9CgogICAgIGlmICgocmVjdCA9PSBOVUxMKSB8fCAoaXRlbSA9PSBOVUxMKSkKCSByZXR1cm4gRkFMU0U7CgogICAgICpyZWN0ID0gaXRlbS0+cmVjdDsKCiAgICAgTWFwV2luZG93UG9pbnRzKHJlZmVyZW5jZUh3bmQsIDAsIChMUFBPSU5UKXJlY3QsIDIpOwoKICAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCQlTZXRNZW51SW5mbyAgICAoVVNFUjMyLkApCiAqCiAqIEZJWE1FCiAqCU1JTV9BUFBMWVRPU1VCTUVOVVMKICoJYWN0dWFsbHkgdXNlIHRoZSBpdGVtcyB0byBkcmF3IHRoZSBtZW51CiAqLwpCT09MIFdJTkFQSSBTZXRNZW51SW5mbyAoSE1FTlUgaE1lbnUsIExQQ01FTlVJTkZPIGxwbWkpCnsKICAgIFBPUFVQTUVOVSAqbWVudTsKCiAgICBUUkFDRSgiKCVwICVwKVxuIiwgaE1lbnUsIGxwbWkpOwoKICAgIGlmIChscG1pICYmIChscG1pLT5jYlNpemU9PXNpemVvZihNRU5VSU5GTykpICYmIChtZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KSkpCiAgICB7CgoJaWYgKGxwbWktPmZNYXNrICYgTUlNX0JBQ0tHUk9VTkQpCgkgICAgbWVudS0+aGJyQmFjayA9IGxwbWktPmhickJhY2s7CgoJaWYgKGxwbWktPmZNYXNrICYgTUlNX0hFTFBJRCkKCSAgICBtZW51LT5kd0NvbnRleHRIZWxwSUQgPSBscG1pLT5kd0NvbnRleHRIZWxwSUQ7CgoJaWYgKGxwbWktPmZNYXNrICYgTUlNX01BWEhFSUdIVCkKCSAgICBtZW51LT5jeU1heCA9IGxwbWktPmN5TWF4OwoKCWlmIChscG1pLT5mTWFzayAmIE1JTV9NRU5VREFUQSkKCSAgICBtZW51LT5kd01lbnVEYXRhID0gbHBtaS0+ZHdNZW51RGF0YTsKCglpZiAobHBtaS0+Zk1hc2sgJiBNSU1fU1RZTEUpCgl7CgkgICAgbWVudS0+ZHdTdHlsZSA9IGxwbWktPmR3U3R5bGU7CgkgICAgaWYgKG1lbnUtPmR3U3R5bGUgJiBNTlNfQVVUT0RJU01JU1MpIEZJWE1FKCJNTlNfQVVUT0RJU01JU1MgdW5pbXBsZW1lbnRlZFxuIik7CgkgICAgaWYgKG1lbnUtPmR3U3R5bGUgJiBNTlNfRFJBR0RST1ApIEZJWE1FKCJNTlNfRFJBR0RST1AgdW5pbXBsZW1lbnRlZFxuIik7CgkgICAgaWYgKG1lbnUtPmR3U3R5bGUgJiBNTlNfTU9ERUxFU1MpIEZJWE1FKCJNTlNfTU9ERUxFU1MgdW5pbXBsZW1lbnRlZFxuIik7CgkgICAgaWYgKG1lbnUtPmR3U3R5bGUgJiBNTlNfTk9DSEVDSykgRklYTUUoIk1OU19OT0NIRUNLIHVuaW1wbGVtZW50ZWRcbiIpOwoJICAgIGlmIChtZW51LT5kd1N0eWxlICYgTU5TX05PVElGWUJZUE9TKSBGSVhNRSgiTU5TX05PVElGWUJZUE9TIHVuaW1wbGVtZW50ZWRcbiIpOwoJfQoKCXJldHVybiBUUlVFOwogICAgfQogICAgcmV0dXJuIEZBTFNFOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJR2V0TWVudUluZm8gICAgKFVTRVIzMi5AKQogKgogKiAgTk9URVMKICoJd2luOTgvTlQ1LjAKICoKICovCkJPT0wgV0lOQVBJIEdldE1lbnVJbmZvIChITUVOVSBoTWVudSwgTFBNRU5VSU5GTyBscG1pKQp7ICAgUE9QVVBNRU5VICptZW51OwoKICAgIFRSQUNFKCIoJXAgJXApXG4iLCBoTWVudSwgbHBtaSk7CgogICAgaWYgKGxwbWkgJiYgKG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpKSkKICAgIHsKCglpZiAobHBtaS0+Zk1hc2sgJiBNSU1fQkFDS0dST1VORCkKCSAgICBscG1pLT5oYnJCYWNrID0gbWVudS0+aGJyQmFjazsKCglpZiAobHBtaS0+Zk1hc2sgJiBNSU1fSEVMUElEKQoJICAgIGxwbWktPmR3Q29udGV4dEhlbHBJRCA9IG1lbnUtPmR3Q29udGV4dEhlbHBJRDsKCglpZiAobHBtaS0+Zk1hc2sgJiBNSU1fTUFYSEVJR0hUKQoJICAgIGxwbWktPmN5TWF4ID0gbWVudS0+Y3lNYXg7CgoJaWYgKGxwbWktPmZNYXNrICYgTUlNX01FTlVEQVRBKQoJICAgIGxwbWktPmR3TWVudURhdGEgPSBtZW51LT5kd01lbnVEYXRhOwoKCWlmIChscG1pLT5mTWFzayAmIE1JTV9TVFlMRSkKCSAgICBscG1pLT5kd1N0eWxlID0gbWVudS0+ZHdTdHlsZTsKCglyZXR1cm4gVFJVRTsKICAgIH0KICAgIHJldHVybiBGQUxTRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgU2V0TWVudUNvbnRleHRIZWxwSWQgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgU2V0TWVudUNvbnRleHRIZWxwSWQoIEhNRU5VIGhNZW51LCBEV09SRCBkd0NvbnRleHRIZWxwSUQpCnsKICAgIExQUE9QVVBNRU5VIG1lbnU7CgogICAgVFJBQ0UoIiglcCAweCUwOGx4KVxuIiwgaE1lbnUsIGR3Q29udGV4dEhlbHBJRCk7CgogICAgaWYgKChtZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KSkpCiAgICB7CgltZW51LT5kd0NvbnRleHRIZWxwSUQgPSBkd0NvbnRleHRIZWxwSUQ7CglyZXR1cm4gVFJVRTsKICAgIH0KICAgIHJldHVybiBGQUxTRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgR2V0TWVudUNvbnRleHRIZWxwSWQgICAgKFVTRVIzMi5AKQogKi8KRFdPUkQgV0lOQVBJIEdldE1lbnVDb250ZXh0SGVscElkKCBITUVOVSBoTWVudSApCnsKICAgIExQUE9QVVBNRU5VIG1lbnU7CgogICAgVFJBQ0UoIiglcClcbiIsIGhNZW51KTsKCiAgICBpZiAoKG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpKSkKICAgIHsKCXJldHVybiBtZW51LT5kd0NvbnRleHRIZWxwSUQ7CiAgICB9CiAgICByZXR1cm4gMDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBNZW51SXRlbUZyb21Qb2ludCAgICAoVVNFUjMyLkApCiAqLwpJTlQgV0lOQVBJIE1lbnVJdGVtRnJvbVBvaW50KEhXTkQgaFduZCwgSE1FTlUgaE1lbnUsIFBPSU5UIHB0U2NyZWVuKQp7CiAgICBQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpOwogICAgVUlOVCBwb3M7CgogICAgLypGSVhNRTogRG8gd2UgaGF2ZSB0byBoYW5kbGUgaFduZCBoZXJlPyAqLwogICAgaWYgKCFtZW51KSByZXR1cm4gLTE7CiAgICBpZiAoIU1FTlVfRmluZEl0ZW1CeUNvb3JkcyhtZW51LCBwdFNjcmVlbiwgJnBvcykpIHJldHVybiAtMTsKICAgIHJldHVybiBwb3M7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgdHJhbnNsYXRlX2FjY2VsZXJhdG9yCiAqLwpzdGF0aWMgQk9PTCB0cmFuc2xhdGVfYWNjZWxlcmF0b3IoIEhXTkQgaFduZCwgVUlOVCBtZXNzYWdlLCBXUEFSQU0gd1BhcmFtLCBMUEFSQU0gbFBhcmFtLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEJZVEUgZlZpcnQsIFdPUkQga2V5LCBXT1JEIGNtZCApCnsKICAgIElOVCBtYXNrID0gMDsKICAgIFVJTlQgbWVzZyA9IDA7CgogICAgaWYgKHdQYXJhbSAhPSBrZXkpIHJldHVybiBGQUxTRTsKCiAgICBpZiAoR2V0S2V5U3RhdGUoVktfQ09OVFJPTCkgJiAweDgwMDApIG1hc2sgfD0gRkNPTlRST0w7CiAgICBpZiAoR2V0S2V5U3RhdGUoVktfTUVOVSkgJiAweDgwMDApIG1hc2sgfD0gRkFMVDsKICAgIGlmIChHZXRLZXlTdGF0ZShWS19TSElGVCkgJiAweDgwMDApIG1hc2sgfD0gRlNISUZUOwoKICAgIGlmIChtZXNzYWdlID09IFdNX0NIQVIgfHwgbWVzc2FnZSA9PSBXTV9TWVNDSEFSKQogICAgewogICAgICAgIGlmICggIShmVmlydCAmIEZWSVJUS0VZKSAmJiAobWFzayAmIEZBTFQpID09IChmVmlydCAmIEZBTFQpICkKICAgICAgICB7CiAgICAgICAgICAgIFRSQUNFXyhhY2NlbCkoImZvdW5kIGFjY2VsIGZvciBXTV9DSEFSOiAoJyVjJylcbiIsIHdQYXJhbSAmIDB4ZmYpOwogICAgICAgICAgICBnb3RvIGZvdW5kOwogICAgICAgIH0KICAgIH0KICAgIGVsc2UKICAgIHsKICAgICAgICBpZihmVmlydCAmIEZWSVJUS0VZKQogICAgICAgIHsKICAgICAgICAgICAgVFJBQ0VfKGFjY2VsKSgiZm91bmQgYWNjZWwgZm9yIHZpcnRfa2V5ICUwNHggKHNjYW4gJTA0eClcbiIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgd1BhcmFtLCAweGZmICYgSElXT1JEKGxQYXJhbSkpOwoKICAgICAgICAgICAgaWYobWFzayA9PSAoZlZpcnQgJiAoRlNISUZUIHwgRkNPTlRST0wgfCBGQUxUKSkpIGdvdG8gZm91bmQ7CiAgICAgICAgICAgIFRSQUNFXyhhY2NlbCkoIiwgYnV0IGluY29ycmVjdCBTSElGVC9DVFJML0FMVC1zdGF0ZVxuIik7CiAgICAgICAgfQogICAgICAgIGVsc2UKICAgICAgICB7CiAgICAgICAgICAgIGlmICghKGxQYXJhbSAmIDB4MDEwMDAwMDApKSAgLyogbm8gc3BlY2lhbF9rZXkgKi8KICAgICAgICAgICAgewogICAgICAgICAgICAgICAgaWYgKChmVmlydCAmIEZBTFQpICYmIChsUGFyYW0gJiAweDIwMDAwMDAwKSkKICAgICAgICAgICAgICAgIHsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiBeXiBBTFQgcHJlc3NlZCAqLwogICAgICAgICAgICAgICAgICAgIFRSQUNFXyhhY2NlbCkoImZvdW5kIGFjY2VsIGZvciBBbHQtJWNcbiIsIHdQYXJhbSAmIDB4ZmYpOwogICAgICAgICAgICAgICAgICAgIGdvdG8gZm91bmQ7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICB9CiAgICByZXR1cm4gRkFMU0U7CgogZm91bmQ6CiAgICBpZiAobWVzc2FnZSA9PSBXTV9LRVlVUCB8fCBtZXNzYWdlID09IFdNX1NZU0tFWVVQKQogICAgICAgIG1lc2cgPSAxOwogICAgZWxzZQogICAgewogICAgICAgIEhNRU5VIGhNZW51LCBoU3ViTWVudSwgaFN5c01lbnU7CiAgICAgICAgVUlOVCB1U3lzU3RhdCA9IChVSU5UKS0xLCB1U3RhdCA9IChVSU5UKS0xLCBuUG9zOwoKICAgICAgICBoTWVudSA9IChHZXRXaW5kb3dMb25nVyggaFduZCwgR1dMX1NUWUxFICkgJiBXU19DSElMRCkgPyAwIDogR2V0TWVudShoV25kKTsKICAgICAgICBoU3lzTWVudSA9IGdldF93aW5fc3lzX21lbnUoIGhXbmQgKTsKCiAgICAgICAgLyogZmluZCBtZW51IGl0ZW0gYW5kIGFzayBhcHBsaWNhdGlvbiB0byBpbml0aWFsaXplIGl0ICovCiAgICAgICAgLyogMS4gaW4gdGhlIHN5c3RlbSBtZW51ICovCiAgICAgICAgaFN1Yk1lbnUgPSBoU3lzTWVudTsKICAgICAgICBuUG9zID0gY21kOwogICAgICAgIGlmKE1FTlVfRmluZEl0ZW0oJmhTdWJNZW51LCAmblBvcywgTUZfQllDT01NQU5EKSkKICAgICAgICB7CiAgICAgICAgICAgIGlmIChHZXRDYXB0dXJlKCkpCiAgICAgICAgICAgICAgICBtZXNnID0gMjsKICAgICAgICAgICAgaWYgKCFJc1dpbmRvd0VuYWJsZWQoaFduZCkpCiAgICAgICAgICAgICAgICBtZXNnID0gMzsKICAgICAgICAgICAgZWxzZQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBTZW5kTWVzc2FnZVcoaFduZCwgV01fSU5JVE1FTlUsIChXUEFSQU0paFN5c01lbnUsIDBMKTsKICAgICAgICAgICAgICAgIGlmKGhTdWJNZW51ICE9IGhTeXNNZW51KQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIG5Qb3MgPSBNRU5VX0ZpbmRTdWJNZW51KCZoU3lzTWVudSwgaFN1Yk1lbnUpOwogICAgICAgICAgICAgICAgICAgIFRSQUNFXyhhY2NlbCkoImhTeXNNZW51ID0gJXAsIGhTdWJNZW51ID0gJXAsIG5Qb3MgPSAlZFxuIiwgaFN5c01lbnUsIGhTdWJNZW51LCBuUG9zKTsKICAgICAgICAgICAgICAgICAgICBTZW5kTWVzc2FnZVcoaFduZCwgV01fSU5JVE1FTlVQT1BVUCwgKFdQQVJBTSloU3ViTWVudSwgTUFLRUxQQVJBTShuUG9zLCBUUlVFKSk7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICB1U3lzU3RhdCA9IEdldE1lbnVTdGF0ZShHZXRTdWJNZW51KGhTeXNNZW51LCAwKSwgY21kLCBNRl9CWUNPTU1BTkQpOwogICAgICAgICAgICB9CiAgICAgICAgfQogICAgICAgIGVsc2UgLyogMi4gaW4gdGhlIHdpbmRvdydzIG1lbnUgKi8KICAgICAgICB7CiAgICAgICAgICAgIGhTdWJNZW51ID0gaE1lbnU7CiAgICAgICAgICAgIG5Qb3MgPSBjbWQ7CiAgICAgICAgICAgIGlmKE1FTlVfRmluZEl0ZW0oJmhTdWJNZW51LCAmblBvcywgTUZfQllDT01NQU5EKSkKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgaWYgKEdldENhcHR1cmUoKSkKICAgICAgICAgICAgICAgICAgICBtZXNnID0gMjsKICAgICAgICAgICAgICAgIGlmICghSXNXaW5kb3dFbmFibGVkKGhXbmQpKQogICAgICAgICAgICAgICAgICAgIG1lc2cgPSAzOwogICAgICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIFNlbmRNZXNzYWdlVyhoV25kLCBXTV9JTklUTUVOVSwgKFdQQVJBTSloTWVudSwgMEwpOwogICAgICAgICAgICAgICAgICAgIGlmKGhTdWJNZW51ICE9IGhNZW51KQogICAgICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAgICAgblBvcyA9IE1FTlVfRmluZFN1Yk1lbnUoJmhNZW51LCBoU3ViTWVudSk7CiAgICAgICAgICAgICAgICAgICAgICAgIFRSQUNFXyhhY2NlbCkoImhNZW51ID0gJXAsIGhTdWJNZW51ID0gJXAsIG5Qb3MgPSAlZFxuIiwgaE1lbnUsIGhTdWJNZW51LCBuUG9zKTsKICAgICAgICAgICAgICAgICAgICAgICAgU2VuZE1lc3NhZ2VXKGhXbmQsIFdNX0lOSVRNRU5VUE9QVVAsIChXUEFSQU0paFN1Yk1lbnUsIE1BS0VMUEFSQU0oblBvcywgRkFMU0UpKTsKICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgdVN0YXQgPSBHZXRNZW51U3RhdGUoaE1lbnUsIGNtZCwgTUZfQllDT01NQU5EKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfQogICAgICAgIH0KCiAgICAgICAgaWYgKG1lc2cgPT0gMCkKICAgICAgICB7CiAgICAgICAgICAgIGlmICh1U3lzU3RhdCAhPSAoVUlOVCktMSkKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgaWYgKHVTeXNTdGF0ICYgKE1GX0RJU0FCTEVEfE1GX0dSQVlFRCkpCiAgICAgICAgICAgICAgICAgICAgbWVzZz00OwogICAgICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgICAgIG1lc2c9V01fU1lTQ09NTUFORDsKICAgICAgICAgICAgfQogICAgICAgICAgICBlbHNlCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIGlmICh1U3RhdCAhPSAoVUlOVCktMSkKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICBpZiAoSXNJY29uaWMoaFduZCkpCiAgICAgICAgICAgICAgICAgICAgICAgIG1lc2c9NTsKICAgICAgICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAgICBpZiAodVN0YXQgJiAoTUZfRElTQUJMRUR8TUZfR1JBWUVEKSkKICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1lc2c9NjsKICAgICAgICAgICAgICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgICAgICAgICAgICAgbWVzZz1XTV9DT01NQU5EOwogICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgICAgICBtZXNnPVdNX0NPTU1BTkQ7CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICB9CgogICAgaWYoIG1lc2c9PVdNX0NPTU1BTkQgKQogICAgewogICAgICAgIFRSQUNFXyhhY2NlbCkoIiwgc2VuZGluZyBXTV9DT01NQU5ELCB3UGFyYW09JTB4XG4iLCAweDEwMDAwIHwgY21kKTsKICAgICAgICBTZW5kTWVzc2FnZVcoaFduZCwgbWVzZywgMHgxMDAwMCB8IGNtZCwgMEwpOwogICAgfQogICAgZWxzZSBpZiggbWVzZz09V01fU1lTQ09NTUFORCApCiAgICB7CiAgICAgICAgVFJBQ0VfKGFjY2VsKSgiLCBzZW5kaW5nIFdNX1NZU0NPTU1BTkQsIHdQYXJhbT0lMHhcbiIsIGNtZCk7CiAgICAgICAgU2VuZE1lc3NhZ2VXKGhXbmQsIG1lc2csIGNtZCwgMHgwMDAxMDAwMEwpOwogICAgfQogICAgZWxzZQogICAgewogICAgICAgIC8qICBzb21lIHJlYXNvbnMgZm9yIE5PVCBzZW5kaW5nIHRoZSBXTV97U1lTfUNPTU1BTkQgbWVzc2FnZToKICAgICAgICAgKiAgICMwOiB1bmtub3duIChwbGVhc2UgcmVwb3J0ISkKICAgICAgICAgKiAgICMxOiBmb3IgV01fS0VZVVAsV01fU1lTS0VZVVAKICAgICAgICAgKiAgICMyOiBtb3VzZSBpcyBjYXB0dXJlZAogICAgICAgICAqICAgIzM6IHdpbmRvdyBpcyBkaXNhYmxlZAogICAgICAgICAqICAgIzQ6IGl0J3MgYSBkaXNhYmxlZCBzeXN0ZW0gbWVudSBvcHRpb24KICAgICAgICAgKiAgICM1OiBpdCdzIGEgbWVudSBvcHRpb24sIGJ1dCB3aW5kb3cgaXMgaWNvbmljCiAgICAgICAgICogICAjNjogaXQncyBhIG1lbnUgb3B0aW9uLCBidXQgZGlzYWJsZWQKICAgICAgICAgKi8KICAgICAgICBUUkFDRV8oYWNjZWwpKCIsIGJ1dCB3b24ndCBzZW5kIFdNX3tTWVN9Q09NTUFORCwgcmVhc29uIGlzICMlZFxuIixtZXNnKTsKICAgICAgICBpZihtZXNnPT0wKQogICAgICAgICAgICBFUlJfKGFjY2VsKSgiIHVua25vd24gcmVhc29uIC0gcGxlYXNlIHJlcG9ydCFcbiIpOwogICAgfQogICAgcmV0dXJuIFRSVUU7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgVHJhbnNsYXRlQWNjZWxlcmF0b3IgICAgICAoVVNFUjMyLkApCiAqICAgICAgVHJhbnNsYXRlQWNjZWxlcmF0b3JBICAgICAoVVNFUjMyLkApCiAqLwpJTlQgV0lOQVBJIFRyYW5zbGF0ZUFjY2VsZXJhdG9yQSggSFdORCBoV25kLCBIQUNDRUwgaEFjY2VsLCBMUE1TRyBtc2cgKQp7CiAgICAvKiBZRVMsIEFjY2VsMTYhICovCiAgICBMUEFDQ0VMMTYgbHBBY2NlbFRibDsKICAgIGludCBpOwogICAgV1BBUkFNIHdQYXJhbTsKCiAgICBpZiAoIWhXbmQgfHwgIW1zZykgcmV0dXJuIDA7CgogICAgaWYgKCFoQWNjZWwgfHwgIShscEFjY2VsVGJsID0gKExQQUNDRUwxNikgTG9ja1Jlc291cmNlMTYoSEFDQ0VMXzE2KGhBY2NlbCkpKSkKICAgIHsKICAgICAgICBXQVJOXyhhY2NlbCkoImludmFsaWQgYWNjZWwgaGFuZGxlPSVwXG4iLCBoQWNjZWwpOwogICAgICAgIHJldHVybiAwOwogICAgfQoKICAgIHdQYXJhbSA9IG1zZy0+d1BhcmFtOwoKICAgIHN3aXRjaCAobXNnLT5tZXNzYWdlKQogICAgewogICAgY2FzZSBXTV9LRVlET1dOOgogICAgY2FzZSBXTV9TWVNLRVlET1dOOgogICAgICAgIGJyZWFrOwoKICAgIGNhc2UgV01fQ0hBUjoKICAgIGNhc2UgV01fU1lTQ0hBUjoKICAgICAgICB7CiAgICAgICAgICAgIGNoYXIgY2ggPSBMT1dPUkQod1BhcmFtKTsKICAgICAgICAgICAgV0NIQVIgd2NoOwogICAgICAgICAgICBNdWx0aUJ5dGVUb1dpZGVDaGFyKENQX0FDUCwgMCwgJmNoLCAxLCAmd2NoLCAxKTsKICAgICAgICAgICAgd1BhcmFtID0gTUFLRVdQQVJBTSh3Y2gsIEhJV09SRCh3UGFyYW0pKTsKICAgICAgICB9CiAgICAgICAgYnJlYWs7CgogICAgZGVmYXVsdDoKICAgICAgICByZXR1cm4gMDsKICAgIH0KCiAgICBUUkFDRV8oYWNjZWwpKCJoQWNjZWwgJXAsIGhXbmQgJXAsIG1zZy0+aHduZCAlcCwgbXNnLT5tZXNzYWdlICUwNHgsIHdQYXJhbSAlMDh4LCBsUGFyYW0gJTA4bHhcbiIsCiAgICAgICAgICAgICAgICAgIGhBY2NlbCxoV25kLG1zZy0+aHduZCxtc2ctPm1lc3NhZ2UsbXNnLT53UGFyYW0sbXNnLT5sUGFyYW0pOwogICAgaSA9IDA7CiAgICBkbwogICAgewogICAgICAgIGlmICh0cmFuc2xhdGVfYWNjZWxlcmF0b3IoIGhXbmQsIG1zZy0+bWVzc2FnZSwgd1BhcmFtLCBtc2ctPmxQYXJhbSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBscEFjY2VsVGJsW2ldLmZWaXJ0LCBscEFjY2VsVGJsW2ldLmtleSwgbHBBY2NlbFRibFtpXS5jbWQpKQogICAgICAgICAgICByZXR1cm4gMTsKICAgIH0gd2hpbGUgKChscEFjY2VsVGJsW2krK10uZlZpcnQgJiAweDgwKSA9PSAwKTsKCiAgICByZXR1cm4gMDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICBUcmFuc2xhdGVBY2NlbGVyYXRvclcgICAgIChVU0VSMzIuQCkKICovCklOVCBXSU5BUEkgVHJhbnNsYXRlQWNjZWxlcmF0b3JXKCBIV05EIGhXbmQsIEhBQ0NFTCBoQWNjZWwsIExQTVNHIG1zZyApCnsKICAgIC8qIFlFUywgQWNjZWwxNiEgKi8KICAgIExQQUNDRUwxNiBscEFjY2VsVGJsOwogICAgaW50IGk7CgogICAgaWYgKCFoV25kIHx8ICFtc2cpIHJldHVybiAwOwoKICAgIGlmICghaEFjY2VsIHx8ICEobHBBY2NlbFRibCA9IChMUEFDQ0VMMTYpIExvY2tSZXNvdXJjZTE2KEhBQ0NFTF8xNihoQWNjZWwpKSkpCiAgICB7CiAgICAgICAgV0FSTl8oYWNjZWwpKCJpbnZhbGlkIGFjY2VsIGhhbmRsZT0lcFxuIiwgaEFjY2VsKTsKICAgICAgICByZXR1cm4gMDsKICAgIH0KCiAgICBzd2l0Y2ggKG1zZy0+bWVzc2FnZSkKICAgIHsKICAgIGNhc2UgV01fS0VZRE9XTjoKICAgIGNhc2UgV01fU1lTS0VZRE9XTjoKICAgIGNhc2UgV01fQ0hBUjoKICAgIGNhc2UgV01fU1lTQ0hBUjoKICAgICAgICBicmVhazsKCiAgICBkZWZhdWx0OgogICAgICAgIHJldHVybiAwOwogICAgfQoKICAgIFRSQUNFXyhhY2NlbCkoImhBY2NlbCAlcCwgaFduZCAlcCwgbXNnLT5od25kICVwLCBtc2ctPm1lc3NhZ2UgJTA0eCwgd1BhcmFtICUwOHgsIGxQYXJhbSAlMDhseFxuIiwKICAgICAgICAgICAgICAgICAgaEFjY2VsLGhXbmQsbXNnLT5od25kLG1zZy0+bWVzc2FnZSxtc2ctPndQYXJhbSxtc2ctPmxQYXJhbSk7CiAgICBpID0gMDsKICAgIGRvCiAgICB7CiAgICAgICAgaWYgKHRyYW5zbGF0ZV9hY2NlbGVyYXRvciggaFduZCwgbXNnLT5tZXNzYWdlLCBtc2ctPndQYXJhbSwgbXNnLT5sUGFyYW0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbHBBY2NlbFRibFtpXS5mVmlydCwgbHBBY2NlbFRibFtpXS5rZXksIGxwQWNjZWxUYmxbaV0uY21kKSkKICAgICAgICAgICAgcmV0dXJuIDE7CiAgICB9IHdoaWxlICgobHBBY2NlbFRibFtpKytdLmZWaXJ0ICYgMHg4MCkgPT0gMCk7CgogICAgcmV0dXJuIDA7Cn0K