LyoKICogTWVudSBmdW5jdGlvbnMKICoKICogQ29weXJpZ2h0IDE5OTMgTWFydGluIEF5b3R0ZQogKiBDb3B5cmlnaHQgMTk5NCBBbGV4YW5kcmUgSnVsbGlhcmQKICogQ29weXJpZ2h0IDE5OTcgTW9ydGVuIFdlbGluZGVyCiAqIENvcHlyaWdodCAyMDA1IE1heGltZSBCZWxsZW5n6QogKiBDb3B5cmlnaHQgMjAwNiBQaGlsIEtyeWxvdgogKgogKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCiAqIHZlcnNpb24gMi4xIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgogKgogKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYwogKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCiAqIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EKICovCgovKgogKiBOb3RlOiB0aGUgc3R5bGUgTUZfTU9VU0VTRUxFQ1QgaXMgdXNlZCB0byBtYXJrIHBvcHVwIGl0ZW1zIHRoYXQKICogaGF2ZSBiZWVuIHNlbGVjdGVkLCBpLmUuIHRoZWlyIHBvcHVwIG1lbnUgaXMgY3VycmVudGx5IGRpc3BsYXllZC4KICogVGhpcyBpcyBwcm9iYWJseSBub3QgdGhlIG1lYW5pbmcgdGhpcyBzdHlsZSBoYXMgaW4gTVMtV2luZG93cy4KICoKICogTm90ZSAyOiB3aGVyZSB0aGVyZSBpcyBhIGRpZmZlcmVuY2UsIHRoZXNlIG1lbnUgQVBJJ3MgYXJlIGFjY29yZGluZwogKiB0aGUgYmVoYXZpb3Igb2YgV2luZG93cyAyayBhbmQgV2luZG93cyBYUC4gS25vd24gZGlmZmVyZW5jZXMgd2l0aAogKiBXaW5kb3dzIDl4L01FIGFyZSBkb2N1bWVudGVkIGluIHRoZSBjb21tZW50cywgaW4gY2FzZSBhbiBhcHBsaWNhdGlvbgogKiBpcyBmb3VuZCB0byBkZXBlbmQgb24gdGhlIG9sZCBiZWhhdmlvci4KICogCiAqIFRPRE86CiAqICAgIGltcGxlbWVudHMgc3R5bGVzIDoKICogICAgICAgIC0gTU5TX0FVVE9ESVNNSVNTCiAqICAgICAgICAtIE1OU19EUkFHRFJPUAogKiAgICAgICAgLSBNTlNfTU9ERUxFU1MKICovCgojaW5jbHVkZSAiY29uZmlnLmgiCiNpbmNsdWRlICJ3aW5lL3BvcnQuaCIKCiNpbmNsdWRlIDxzdGRhcmcuaD4KI2luY2x1ZGUgPHN0cmluZy5oPgoKI2RlZmluZSBPRU1SRVNPVVJDRQoKI2luY2x1ZGUgIndpbmRlZi5oIgojaW5jbHVkZSAid2luYmFzZS5oIgojaW5jbHVkZSAid2luZ2RpLmgiCiNpbmNsdWRlICJ3aW5ubHMuaCIKI2luY2x1ZGUgIndpbmUvd2luYmFzZTE2LmgiCiNpbmNsdWRlICJ3aW5lL3dpbnVzZXIxNi5oIgojaW5jbHVkZSAid293bnQzMi5oIgojaW5jbHVkZSAid2luZS9zZXJ2ZXIuaCIKI2luY2x1ZGUgIndpbmUvdW5pY29kZS5oIgojaW5jbHVkZSAid2luLmgiCiNpbmNsdWRlICJjb250cm9scy5oIgojaW5jbHVkZSAidXNlcl9wcml2YXRlLmgiCiNpbmNsdWRlICJ3aW5lL2RlYnVnLmgiCgpXSU5FX0RFRkFVTFRfREVCVUdfQ0hBTk5FTChtZW51KTsKV0lORV9ERUNMQVJFX0RFQlVHX0NIQU5ORUwoYWNjZWwpOwoKLyogaW50ZXJuYWwgcG9wdXAgbWVudSB3aW5kb3cgbWVzc2FnZXMgKi8KCiNkZWZpbmUgTU1fU0VUTUVOVUhBTkRMRQkoV01fVVNFUiArIDApCiNkZWZpbmUgTU1fR0VUTUVOVUhBTkRMRQkoV01fVVNFUiArIDEpCgovKiBNZW51IGl0ZW0gc3RydWN0dXJlICovCnR5cGVkZWYgc3RydWN0IHsKICAgIC8qIC0tLS0tLS0tLS0tIE1FTlVJVEVNSU5GTyBTdHVmZiAtLS0tLS0tLS0tLSAqLwogICAgVUlOVCBmVHlwZTsJCQkvKiBJdGVtIHR5cGUuICovCiAgICBVSU5UIGZTdGF0ZTsJCS8qIEl0ZW0gc3RhdGUuICAqLwogICAgVUlOVF9QVFIgd0lEOwkJLyogSXRlbSBpZC4gICovCiAgICBITUVOVSBoU3ViTWVudTsJCS8qIFBvcC11cCBtZW51LiAgKi8KICAgIEhCSVRNQVAgaENoZWNrQml0OwkJLyogQml0bWFwIHdoZW4gY2hlY2tlZC4gICovCiAgICBIQklUTUFQIGhVbkNoZWNrQml0OwkvKiBCaXRtYXAgd2hlbiB1bmNoZWNrZWQuICAqLwogICAgTFBXU1RSIHRleHQ7CQkvKiBJdGVtIHRleHQuICovCiAgICBVTE9OR19QVFIgZHdJdGVtRGF0YTsJLyogQXBwbGljYXRpb24gZGVmaW5lZC4gICovCiAgICBMUFdTVFIgZHdUeXBlRGF0YTsJCS8qIGRlcGVuZHMgb24gZk1hc2sgKi8KICAgIEhCSVRNQVAgaGJtcEl0ZW07CQkvKiBiaXRtYXAgKi8KICAgIC8qIC0tLS0tLS0tLS0tIFdpbmUgc3R1ZmYgLS0tLS0tLS0tLS0gKi8KICAgIFJFQ1QgICAgICByZWN0OwkJLyogSXRlbSBhcmVhIChyZWxhdGl2ZSB0byBtZW51IHdpbmRvdykgKi8KICAgIFVJTlQgICAgICB4VGFiOwkJLyogWCBwb3NpdGlvbiBvZiB0ZXh0IGFmdGVyIFRhYiAqLwogICAgU0laRSAgIGJtcHNpemU7ICAgICAgICAgICAgIC8qIHNpemUgbmVlZGVkIGZvciB0aGUgSEJNTUVOVV9DQUxMQkFDSwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqIGJpdG1hcCAqLyAKfSBNRU5VSVRFTTsKCi8qIFBvcHVwIG1lbnUgc3RydWN0dXJlICovCnR5cGVkZWYgc3RydWN0IHsKICAgIFdPUkQgICAgICAgIHdGbGFnczsgICAgICAgLyogTWVudSBmbGFncyAoTUZfUE9QVVAsIE1GX1NZU01FTlUpICovCiAgICBXT1JEICAgICAgICB3TWFnaWM7ICAgICAgIC8qIE1hZ2ljIG51bWJlciAqLwogICAgV09SRAlXaWR0aDsgICAgICAgIC8qIFdpZHRoIG9mIHRoZSB3aG9sZSBtZW51ICovCiAgICBXT1JECUhlaWdodDsgICAgICAgLyogSGVpZ2h0IG9mIHRoZSB3aG9sZSBtZW51ICovCiAgICBVSU5UICAgICAgICBuSXRlbXM7ICAgICAgIC8qIE51bWJlciBvZiBpdGVtcyBpbiB0aGUgbWVudSAqLwogICAgSFdORCAgICAgICAgaFduZDsgICAgICAgICAvKiBXaW5kb3cgY29udGFpbmluZyB0aGUgbWVudSAqLwogICAgTUVOVUlURU0gICAgKml0ZW1zOyAgICAgICAvKiBBcnJheSBvZiBtZW51IGl0ZW1zICovCiAgICBVSU5UICAgICAgICBGb2N1c2VkSXRlbTsgIC8qIEN1cnJlbnRseSBmb2N1c2VkIGl0ZW0gKi8KICAgIEhXTkQJaHduZE93bmVyOyAgICAvKiB3aW5kb3cgcmVjZWl2aW5nIHRoZSBtZXNzYWdlcyBmb3Igb3duZXJkcmF3ICovCiAgICBCT09MICAgICAgICBiVGltZVRvSGlkZTsgIC8qIFJlcXVlc3QgaGlkaW5nIHdoZW4gcmVjZWl2aW5nIGEgc2Vjb25kIGNsaWNrIGluIHRoZSB0b3AtbGV2ZWwgbWVudSBpdGVtICovCiAgICBCT09MICAgICAgICBiU2Nyb2xsaW5nOyAgIC8qIFNjcm9sbCBhcnJvd3MgYXJlIGFjdGl2ZSAqLwogICAgVUlOVCAgICAgICAgblNjcm9sbFBvczsgICAvKiBDdXJyZW50IHNjcm9sbCBwb3NpdGlvbiAqLwogICAgVUlOVCAgICAgICAgblRvdGFsSGVpZ2h0OyAvKiBUb3RhbCBoZWlnaHQgb2YgbWVudSBpdGVtcyBpbnNpZGUgbWVudSAqLwogICAgLyogLS0tLS0tLS0tLS0tIE1FTlVJTkZPIG1lbWJlcnMgLS0tLS0tICovCiAgICBEV09SRAlkd1N0eWxlOwkvKiBFeHRlbmRlZCBtZW51IHN0eWxlICovCiAgICBVSU5UCWN5TWF4OwkJLyogbWF4IGhlaWdodCBvZiB0aGUgd2hvbGUgbWVudSwgMCBpcyBzY3JlZW4gaGVpZ2h0ICovCiAgICBIQlJVU0gJaGJyQmFjazsJLyogYnJ1c2ggZm9yIG1lbnUgYmFja2dyb3VuZCAqLwogICAgRFdPUkQJZHdDb250ZXh0SGVscElEOwogICAgRFdPUkQJZHdNZW51RGF0YTsJLyogYXBwbGljYXRpb24gZGVmaW5lZCB2YWx1ZSAqLwogICAgSE1FTlUgICAgICAgaFN5c01lbnVPd25lcjsgIC8qIEhhbmRsZSB0byB0aGUgZHVtbXkgc3lzIG1lbnUgaG9sZGVyICovCiAgICBTSVpFICAgICAgICBtYXhCbXBTaXplOyAgICAgLyogTWF4aW11bSBzaXplIG9mIHRoZSBiaXRtYXAgaXRlbXMgKi8KfSBQT1BVUE1FTlUsICpMUFBPUFVQTUVOVTsKCi8qIGludGVybmFsIGZsYWdzIGZvciBtZW51IHRyYWNraW5nICovCgojZGVmaW5lIFRGX0VORE1FTlUgICAgICAgICAgICAgIDB4MDAwMQojZGVmaW5lIFRGX1NVU1BFTkRQT1BVUCAgICAgICAgIDB4MDAwMgojZGVmaW5lIFRGX1NLSVBSRU1PVkUJCTB4MDAwNAoKdHlwZWRlZiBzdHJ1Y3QKewogICAgVUlOVAl0cmFja0ZsYWdzOwogICAgSE1FTlUJaEN1cnJlbnRNZW51OyAvKiBjdXJyZW50IHN1Ym1lbnUgKGNhbiBiZSBlcXVhbCB0byBoVG9wTWVudSkqLwogICAgSE1FTlUJaFRvcE1lbnU7ICAgICAvKiBpbml0aWFsIG1lbnUgKi8KICAgIEhXTkQJaE93bmVyV25kOyAgICAvKiB3aGVyZSBub3RpZmljYXRpb25zIGFyZSBzZW50ICovCiAgICBQT0lOVAlwdDsKfSBNVFJBQ0tFUjsKCiNkZWZpbmUgTUVOVV9NQUdJQyAgIDB4NTU0ZCAgLyogJ01VJyAqLwoKI2RlZmluZSBJVEVNX1BSRVYJCS0xCiNkZWZpbmUgSVRFTV9ORVhUCQkgMQoKICAvKiBJbnRlcm5hbCBNRU5VX1RyYWNrTWVudSgpIGZsYWdzICovCiNkZWZpbmUgVFBNX0lOVEVSTkFMCQkweEYwMDAwMDAwCiNkZWZpbmUgVFBNX0VOVEVSSURMRUVYCSAJMHg4MDAwMDAwMAkJLyogc2V0IG93bmVyIHdpbmRvdyBmb3IgV01fRU5URVJJRExFICovCiNkZWZpbmUgVFBNX0JVVFRPTkRPV04JCTB4NDAwMDAwMDAJCS8qIG1lbnUgd2FzIGNsaWNrZWQgYmVmb3JlIHRyYWNraW5nICovCiNkZWZpbmUgVFBNX1BPUFVQTUVOVSAgICAgICAgICAgMHgyMDAwMDAwMCAgICAgICAgICAgICAgLyogbWVudSBpcyBhIHBvcHVwIG1lbnUgKi8KCiAgLyogU3BhY2UgYmV0d2VlbiAyIGNvbHVtbnMgKi8KI2RlZmluZSBNRU5VX0NPTF9TUEFDRSA0CgogIC8qICB0b3AgYW5kIGJvdHRvbSBtYXJnaW5zIGZvciBwb3B1cCBtZW51cyAqLwojZGVmaW5lIE1FTlVfVE9QX01BUkdJTiAzCiNkZWZpbmUgTUVOVV9CT1RUT01fTUFSR0lOIDIKCiAgLyogKG90aGVyIG1lbnUtPkZvY3VzZWRJdGVtIHZhbHVlcyBnaXZlIHRoZSBwb3NpdGlvbiBvZiB0aGUgZm9jdXNlZCBpdGVtKSAqLwojZGVmaW5lIE5PX1NFTEVDVEVEX0lURU0gIDB4ZmZmZgoKI2RlZmluZSBNRU5VX0lURU1fVFlQRShmbGFncykgXAogICgoZmxhZ3MpICYgKE1GX1NUUklORyB8IE1GX0JJVE1BUCB8IE1GX09XTkVSRFJBVyB8IE1GX1NFUEFSQVRPUikpCgovKiBtYWNybyB0byB0ZXN0IHRoYXQgZmxhZ3MgZG8gbm90IGluZGljYXRlIGJpdG1hcCwgb3duZXJkcmF3IG9yIHNlcGFyYXRvciAqLwojZGVmaW5lIElTX1NUUklOR19JVEVNKGZsYWdzKSAoTUVOVV9JVEVNX1RZUEUgKChmbGFncykpID09IE1GX1NUUklORykKI2RlZmluZSBJU19NQUdJQ19CSVRNQVAoaWQpICAgICAoKGlkKSAmJiAoKElOVF9QVFIpKGlkKSA8IDEyKSAmJiAoKElOVF9QVFIpKGlkKSA+PSAtMSkpCgojZGVmaW5lIElTX1NZU1RFTV9NRU5VKG1lbnUpICBcCgkoISgobWVudSktPndGbGFncyAmIE1GX1BPUFVQKSAmJiAoKG1lbnUpLT53RmxhZ3MgJiBNRl9TWVNNRU5VKSkKCiNkZWZpbmUgTUVOVUlURU1JTkZPX1RZUEVfTUFTSyBcCgkJKE1GVF9TVFJJTkcgfCBNRlRfQklUTUFQIHwgTUZUX09XTkVSRFJBVyB8IE1GVF9TRVBBUkFUT1IgfCBcCgkJTUZUX01FTlVCQVJCUkVBSyB8IE1GVF9NRU5VQlJFQUsgfCBNRlRfUkFESU9DSEVDSyB8IFwKCQlNRlRfUklHSFRPUkRFUiB8IE1GVF9SSUdIVEpVU1RJRlkgLyogc2FtZSBhcyBNRl9IRUxQICovICkKI2RlZmluZSBUWVBFX01BU0sgIChNRU5VSVRFTUlORk9fVFlQRV9NQVNLIHwgTUZfUE9QVVAgfCBNRl9TWVNNRU5VKQojZGVmaW5lIFNUQVRFX01BU0sgKH5UWVBFX01BU0spCiNkZWZpbmUgTUVOVUlURU1JTkZPX1NUQVRFX01BU0sgKFNUQVRFX01BU0sgJiB+KE1GX0JZUE9TSVRJT04gfCBNRl9NT1VTRVNFTEVDVCkpCgojZGVmaW5lIFdJTl9BTExPV0VEX01FTlUoc3R5bGUpICgoc3R5bGUgJiAoV1NfQ0hJTEQgfCBXU19QT1BVUCkpICE9IFdTX0NISUxEKQoKc3RhdGljIFNJWkUgICAgIG1lbnVjaGFyc2l6ZTsKc3RhdGljIFVJTlQgICAgIE9EaXRlbWhlaWdodDsgLyogZGVmYXVsdCBvd25lciBkcmF3biBpdGVtIGhlaWdodCAqLyAgICAgIAoKLyogVXNlIGdsb2JhbCBwb3B1cCB3aW5kb3cgYmVjYXVzZSB0aGVyZSdzIG5vIHdheSAyIG1lbnVzIGNhbgogKiBiZSB0cmFja2VkIGF0IHRoZSBzYW1lIHRpbWUuICAqLwpzdGF0aWMgSFdORCB0b3BfcG9wdXA7CgogIC8qIEZsYWcgc2V0IGJ5IEVuZE1lbnUoKSB0byBmb3JjZSBhbiBleGl0IGZyb20gbWVudSB0cmFja2luZyAqLwpzdGF0aWMgQk9PTCBmRW5kTWVudSA9IEZBTFNFOwoKc3RhdGljIExSRVNVTFQgV0lOQVBJIFBvcHVwTWVudVduZFByb2MoIEhXTkQgaHduZCwgVUlOVCBtZXNzYWdlLCBXUEFSQU0gd1BhcmFtLCBMUEFSQU0gbFBhcmFtICk7CgpEV09SRCBXSU5BUEkgRHJhd01lbnVCYXJUZW1wKEhXTkQgaHduZCwgSERDIGhEQywgTFBSRUNUIGxwcmVjdCwgSE1FTlUgaE1lbnUsIEhGT05UIGhGb250KTsKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogbWVudSBjbGFzcyBkZXNjcmlwdG9yCiAqLwpjb25zdCBzdHJ1Y3QgYnVpbHRpbl9jbGFzc19kZXNjciBNRU5VX2J1aWx0aW5fY2xhc3MgPQp7CiAgICAoTFBDU1RSKVBPUFVQTUVOVV9DTEFTU19BVE9NLCAgLyogbmFtZSAqLwogICAgQ1NfRFJPUFNIQURPVyB8IENTX1NBVkVCSVRTIHwgQ1NfREJMQ0xLUywgIC8qIHN0eWxlICovCiAgICBOVUxMLCAgICAgICAgICAgICAgICAgICAgICAgICAgLyogcHJvY0EgKHdpbnByb2MgaXMgVW5pY29kZSBvbmx5KSAqLwogICAgUG9wdXBNZW51V25kUHJvYywgICAgICAgICAgICAgIC8qIHByb2NXICovCiAgICBzaXplb2YoSE1FTlUpLCAgICAgICAgICAgICAgICAgLyogZXh0cmEgKi8KICAgIElEQ19BUlJPVywgICAgICAgICAgICAgICAgICAgICAvKiBjdXJzb3IgKi8KICAgIChIQlJVU0gpKENPTE9SX01FTlUrMSkgICAgICAgICAvKiBicnVzaCAqLwp9OwoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgZGVidWdfcHJpbnRfbWVudWl0ZW0KICoKICogUHJpbnQgYSBtZW51aXRlbSBpbiByZWFkYWJsZSBmb3JtLgogKi8KCiNkZWZpbmUgZGVidWdfcHJpbnRfbWVudWl0ZW0ocHJlLCBtcCwgcG9zdCkgXAogICAgZG8geyBpZiAoVFJBQ0VfT04obWVudSkpIGRvX2RlYnVnX3ByaW50X21lbnVpdGVtKHByZSwgbXAsIHBvc3QpOyB9IHdoaWxlICgwKQoKI2RlZmluZSBNRU5VT1VUKHRleHQpIFwKICBUUkFDRSgiJXMlcyIsIChjb3VudCsrID8gIiwiIDogIiIpLCAodGV4dCkpCgojZGVmaW5lIE1FTlVGTEFHKGJpdCx0ZXh0KSBcCiAgZG8geyBcCiAgICBpZiAoZmxhZ3MgJiAoYml0KSkgeyBmbGFncyAmPSB+KGJpdCk7IE1FTlVPVVQgKCh0ZXh0KSk7IH0gXAogIH0gd2hpbGUgKDApCgpzdGF0aWMgdm9pZCBkb19kZWJ1Z19wcmludF9tZW51aXRlbShjb25zdCBjaGFyICpwcmVmaXgsIE1FTlVJVEVNICogbXAsCgkJCQkgICAgY29uc3QgY2hhciAqcG9zdGZpeCkKewogICAgc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBoYm1tZW51c1tdID0geyAiSEJNTUVOVV9DQUxMQkFDSyIsICIiLCAiSEJNTUVOVV9TWVNURU0iLAogICAgIkhCTU1FTlVfTUJBUl9SRVNUT1JFIiwgIkhCTU1FTlVfTUJBUl9NSU5JTUlaRSIsICJVTktOT1dOIEJJVE1BUCIsICJIQk1NRU5VX01CQVJfQ0xPU0UiLAogICAgIkhCTU1FTlVfTUJBUl9DTE9TRV9EIiwgIkhCTU1FTlVfTUJBUl9NSU5JTUlaRV9EIiwgIkhCTU1FTlVfUE9QVVBfQ0xPU0UiLAogICAgIkhCTU1FTlVfUE9QVVBfUkVTVE9SRSIsICJIQk1NRU5VX1BPUFVQX01BWElNSVpFIiwgIkhCTU1FTlVfUE9QVVBfTUlOSU1JWkUifTsKICAgIFRSQUNFKCIlcyAiLCBwcmVmaXgpOwogICAgaWYgKG1wKSB7CiAgICAgICAgVUlOVCBmbGFncyA9IG1wLT5mVHlwZTsKICAgICAgICBUUkFDRSggInsgSUQ9MHgleCIsIG1wLT53SUQpOwogICAgICAgIGlmICggbXAtPmhTdWJNZW51KQogICAgICAgICAgICBUUkFDRSggIiwgU3ViPSVwIiwgbXAtPmhTdWJNZW51KTsKICAgICAgICBpZiAoZmxhZ3MpIHsKICAgICAgICAgICAgaW50IGNvdW50ID0gMDsKICAgICAgICAgICAgVFJBQ0UoICIsIGZUeXBlPSIpOwogICAgICAgICAgICBNRU5VRkxBRyggTUZUX1NFUEFSQVRPUiwgInNlcCIpOwogICAgICAgICAgICBNRU5VRkxBRyggTUZUX09XTkVSRFJBVywgIm93biIpOwogICAgICAgICAgICBNRU5VRkxBRyggTUZUX0JJVE1BUCwgImJpdCIpOwogICAgICAgICAgICBNRU5VRkxBRyhNRl9QT1BVUCwgInBvcCIpOwogICAgICAgICAgICBNRU5VRkxBRyhNRlRfTUVOVUJBUkJSRUFLLCAiYmFyYnJrIik7CiAgICAgICAgICAgIE1FTlVGTEFHKE1GVF9NRU5VQlJFQUssICJicmsiKTsKICAgICAgICAgICAgTUVOVUZMQUcoTUZUX1JBRElPQ0hFQ0ssICJyYWRpbyIpOwogICAgICAgICAgICBNRU5VRkxBRyhNRlRfUklHSFRPUkRFUiwgInJvcmRlciIpOwogICAgICAgICAgICBNRU5VRkxBRyhNRl9TWVNNRU5VLCAic3lzIik7CiAgICAgICAgICAgIE1FTlVGTEFHKE1GVF9SSUdIVEpVU1RJRlksICJyaWdodCIpOyAgLyogc2FtZSBhcyBNRl9IRUxQICovCiAgICAgICAgICAgIGlmIChmbGFncykKICAgICAgICAgICAgICAgIFRSQUNFKCAiKzB4JXgiLCBmbGFncyk7CiAgICAgICAgfQogICAgICAgIGZsYWdzID0gbXAtPmZTdGF0ZTsKICAgICAgICBpZiAoZmxhZ3MpIHsKICAgICAgICAgICAgaW50IGNvdW50ID0gMDsKICAgICAgICAgICAgVFJBQ0UoICIsIFN0YXRlPSIpOwogICAgICAgICAgICBNRU5VRkxBRyhNRlNfR1JBWUVELCAiZ3JleSIpOwogICAgICAgICAgICBNRU5VRkxBRyhNRlNfREVGQVVMVCwgImRlZmF1bHQiKTsKICAgICAgICAgICAgTUVOVUZMQUcoTUZTX0RJU0FCTEVELCAiZGlzIik7CiAgICAgICAgICAgIE1FTlVGTEFHKE1GU19DSEVDS0VELCAiY2hlY2siKTsKICAgICAgICAgICAgTUVOVUZMQUcoTUZTX0hJTElURSwgImhpIik7CiAgICAgICAgICAgIE1FTlVGTEFHKE1GX1VTRUNIRUNLQklUTUFQUywgInVzZWJpdCIpOwogICAgICAgICAgICBNRU5VRkxBRyhNRl9NT1VTRVNFTEVDVCwgIm1vdXNlIik7CiAgICAgICAgICAgIGlmIChmbGFncykKICAgICAgICAgICAgICAgIFRSQUNFKCAiKzB4JXgiLCBmbGFncyk7CiAgICAgICAgfQogICAgICAgIGlmIChtcC0+aENoZWNrQml0KQogICAgICAgICAgICBUUkFDRSggIiwgQ2hrPSVwIiwgbXAtPmhDaGVja0JpdCk7CiAgICAgICAgaWYgKG1wLT5oVW5DaGVja0JpdCkKICAgICAgICAgICAgVFJBQ0UoICIsIFVuYz0lcCIsIG1wLT5oVW5DaGVja0JpdCk7CiAgICAgICAgaWYgKG1wLT50ZXh0KQogICAgICAgICAgICBUUkFDRSggIiwgVGV4dD0lcyIsIGRlYnVnc3RyX3cobXAtPnRleHQpKTsKICAgICAgICBpZiAobXAtPmR3SXRlbURhdGEpCiAgICAgICAgICAgIFRSQUNFKCAiLCBJdGVtRGF0YT0weCUwOGx4IiwgbXAtPmR3SXRlbURhdGEpOwogICAgICAgIGlmIChtcC0+aGJtcEl0ZW0pCiAgICAgICAgewogICAgICAgICAgICBpZiggSVNfTUFHSUNfQklUTUFQKG1wLT5oYm1wSXRlbSkpCiAgICAgICAgICAgICAgICBUUkFDRSggIiwgaGJpdG1hcD0lcyIsIGhibW1lbnVzWyAoSU5UX1BUUiltcC0+aGJtcEl0ZW0gKyAxXSk7CiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgIFRSQUNFKCAiLCBoYml0bWFwPSVwIiwgbXAtPmhibXBJdGVtKTsKICAgICAgICB9CiAgICAgICAgVFJBQ0UoICIgfSIpOwogICAgfSBlbHNlCiAgICAgICAgVFJBQ0UoICJOVUxMIik7CiAgICBUUkFDRSgiICVzXG4iLCBwb3N0Zml4KTsKfQoKI3VuZGVmIE1FTlVPVVQKI3VuZGVmIE1FTlVGTEFHCgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0dldE1lbnUKICoKICogVmFsaWRhdGUgdGhlIGdpdmVuIG1lbnUgaGFuZGxlIGFuZCByZXR1cm5zIHRoZSBtZW51IHN0cnVjdHVyZSBwb2ludGVyLgogKi8Kc3RhdGljIFBPUFVQTUVOVSAqTUVOVV9HZXRNZW51KEhNRU5VIGhNZW51KQp7CiAgICBQT1BVUE1FTlUgKm1lbnUgPSBVU0VSX0hFQVBfTElOX0FERFIoaE1lbnUpOwogICAgaWYgKCFtZW51IHx8IG1lbnUtPndNYWdpYyAhPSBNRU5VX01BR0lDKQogICAgewogICAgICAgIFdBUk4oImludmFsaWQgbWVudSBoYW5kbGU9JXAsIHB0cj0lcCwgbWFnaWM9JXhcbiIsIGhNZW51LCBtZW51LCBtZW51PyBtZW51LT53TWFnaWM6MCk7CiAgICAgICAgbWVudSA9IE5VTEw7CiAgICB9CiAgICByZXR1cm4gbWVudTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBnZXRfd2luX3N5c19tZW51CiAqCiAqIEdldCB0aGUgc3lzdGVtIG1lbnUgb2YgYSB3aW5kb3cKICovCnN0YXRpYyBITUVOVSBnZXRfd2luX3N5c19tZW51KCBIV05EIGh3bmQgKQp7CiAgICBITUVOVSByZXQgPSAwOwogICAgV05EICp3aW4gPSBXSU5fR2V0UHRyKCBod25kICk7CiAgICBpZiAod2luICYmIHdpbiAhPSBXTkRfT1RIRVJfUFJPQ0VTUyAmJiB3aW4gIT0gV05EX0RFU0tUT1ApCiAgICB7CiAgICAgICAgcmV0ID0gd2luLT5oU3lzTWVudTsKICAgICAgICBXSU5fUmVsZWFzZVB0ciggd2luICk7CiAgICB9CiAgICByZXR1cm4gcmV0Owp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIGdldF9tZW51X2ZvbnQKICovCnN0YXRpYyBIRk9OVCBnZXRfbWVudV9mb250KCBCT09MIGJvbGQgKQp7CiAgICBzdGF0aWMgSEZPTlQgaE1lbnVGb250LCBoTWVudUZvbnRCb2xkOwoKICAgIEhGT05UIHJldCA9IGJvbGQgPyBoTWVudUZvbnRCb2xkIDogaE1lbnVGb250OwoKICAgIGlmICghcmV0KQogICAgewogICAgICAgIE5PTkNMSUVOVE1FVFJJQ1NXIG5jbTsKICAgICAgICBIRk9OVCBwcmV2OwoKICAgICAgICBuY20uY2JTaXplID0gc2l6ZW9mKE5PTkNMSUVOVE1FVFJJQ1NXKTsKICAgICAgICBTeXN0ZW1QYXJhbWV0ZXJzSW5mb1coU1BJX0dFVE5PTkNMSUVOVE1FVFJJQ1MsIHNpemVvZihOT05DTElFTlRNRVRSSUNTVyksICZuY20sIDApOwoKICAgICAgICBpZiAoYm9sZCkKICAgICAgICB7CiAgICAgICAgICAgIG5jbS5sZk1lbnVGb250LmxmV2VpZ2h0ICs9IDMwMDsKICAgICAgICAgICAgaWYgKG5jbS5sZk1lbnVGb250LmxmV2VpZ2h0ID4gMTAwMCkgbmNtLmxmTWVudUZvbnQubGZXZWlnaHQgPSAxMDAwOwogICAgICAgIH0KICAgICAgICBpZiAoIShyZXQgPSBDcmVhdGVGb250SW5kaXJlY3RXKCAmbmNtLmxmTWVudUZvbnQgKSkpIHJldHVybiAwOwogICAgICAgIHByZXYgPSBJbnRlcmxvY2tlZENvbXBhcmVFeGNoYW5nZVBvaW50ZXIoICh2b2lkICoqKShib2xkID8gJmhNZW51Rm9udEJvbGQgOiAmaE1lbnVGb250KSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXQsIE5VTEwgKTsKICAgICAgICBpZiAocHJldikKICAgICAgICB7CiAgICAgICAgICAgIC8qIGFub3RoZXIgdGhyZWFkIGJlYXQgdXMgdG8gaXQgKi8KICAgICAgICAgICAgRGVsZXRlT2JqZWN0KCByZXQgKTsKICAgICAgICAgICAgcmV0ID0gcHJldjsKICAgICAgICB9CiAgICB9CiAgICByZXR1cm4gcmV0Owp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIGdldF9hcnJvd19iaXRtYXAKICovCnN0YXRpYyBIQklUTUFQIGdldF9hcnJvd19iaXRtYXAodm9pZCkKewogICAgc3RhdGljIEhCSVRNQVAgYXJyb3dfYml0bWFwOwoKICAgIGlmICghYXJyb3dfYml0bWFwKSBhcnJvd19iaXRtYXAgPSBMb2FkQml0bWFwVygwLCBNQUtFSU5UUkVTT1VSQ0VXKE9CTV9NTkFSUk9XKSk7CiAgICByZXR1cm4gYXJyb3dfYml0bWFwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIGdldF9kb3duX2Fycm93X2JpdG1hcAogKi8Kc3RhdGljIEhCSVRNQVAgZ2V0X2Rvd25fYXJyb3dfYml0bWFwKHZvaWQpCnsKICAgIHN0YXRpYyBIQklUTUFQIGFycm93X2JpdG1hcDsKCiAgICBpZiAoIWFycm93X2JpdG1hcCkgYXJyb3dfYml0bWFwID0gTG9hZEJpdG1hcFcoMCwgTUFLRUlOVFJFU09VUkNFVyhPQk1fRE5BUlJPVykpOwogICAgcmV0dXJuIGFycm93X2JpdG1hcDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBnZXRfZG93bl9hcnJvd19pbmFjdGl2ZV9iaXRtYXAKICovCnN0YXRpYyBIQklUTUFQIGdldF9kb3duX2Fycm93X2luYWN0aXZlX2JpdG1hcCh2b2lkKQp7CiAgICBzdGF0aWMgSEJJVE1BUCBhcnJvd19iaXRtYXA7CgogICAgaWYgKCFhcnJvd19iaXRtYXApIGFycm93X2JpdG1hcCA9IExvYWRCaXRtYXBXKDAsIE1BS0VJTlRSRVNPVVJDRVcoT0JNX0ROQVJST1dJKSk7CiAgICByZXR1cm4gYXJyb3dfYml0bWFwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIGdldF91cF9hcnJvd19iaXRtYXAKICovCnN0YXRpYyBIQklUTUFQIGdldF91cF9hcnJvd19iaXRtYXAodm9pZCkKewogICAgc3RhdGljIEhCSVRNQVAgYXJyb3dfYml0bWFwOwoKICAgIGlmICghYXJyb3dfYml0bWFwKSBhcnJvd19iaXRtYXAgPSBMb2FkQml0bWFwVygwLCBNQUtFSU5UUkVTT1VSQ0VXKE9CTV9VUEFSUk9XKSk7CiAgICByZXR1cm4gYXJyb3dfYml0bWFwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIGdldF91cF9hcnJvd19pbmFjdGl2ZV9iaXRtYXAKICovCnN0YXRpYyBIQklUTUFQIGdldF91cF9hcnJvd19pbmFjdGl2ZV9iaXRtYXAodm9pZCkKewogICAgc3RhdGljIEhCSVRNQVAgYXJyb3dfYml0bWFwOwoKICAgIGlmICghYXJyb3dfYml0bWFwKSBhcnJvd19iaXRtYXAgPSBMb2FkQml0bWFwVygwLCBNQUtFSU5UUkVTT1VSQ0VXKE9CTV9VUEFSUk9XSSkpOwogICAgcmV0dXJuIGFycm93X2JpdG1hcDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0NvcHlTeXNQb3B1cAogKgogKiBSZXR1cm4gdGhlIGRlZmF1bHQgc3lzdGVtIG1lbnUuCiAqLwpzdGF0aWMgSE1FTlUgTUVOVV9Db3B5U3lzUG9wdXAodm9pZCkKewogICAgc3RhdGljIGNvbnN0IFdDSEFSIHN5c21lbnVXW10gPSB7J1MnLCdZJywnUycsJ00nLCdFJywnTicsJ1UnLDB9OwogICAgSE1FTlUgaE1lbnUgPSBMb2FkTWVudVcodXNlcjMyX21vZHVsZSwgc3lzbWVudVcpOwoKICAgIGlmKCBoTWVudSApIHsKICAgICAgICBQT1BVUE1FTlUqIG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpOwogICAgICAgIG1lbnUtPndGbGFncyB8PSBNRl9TWVNNRU5VIHwgTUZfUE9QVVA7CglTZXRNZW51RGVmYXVsdEl0ZW0oaE1lbnUsIFNDX0NMT1NFLCBGQUxTRSk7CiAgICB9CiAgICBlbHNlCglFUlIoIlVuYWJsZSB0byBsb2FkIGRlZmF1bHQgc3lzdGVtIG1lbnVcbiIgKTsKCiAgICBUUkFDRSgicmV0dXJuaW5nICVwLlxuIiwgaE1lbnUgKTsKCiAgICByZXR1cm4gaE1lbnU7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9HZXRTeXNNZW51CiAqCiAqIENyZWF0ZSBhIGNvcHkgb2YgdGhlIHN5c3RlbSBtZW51LiBTeXN0ZW0gbWVudSBpbiBXaW5kb3dzIGlzCiAqIGEgc3BlY2lhbCBtZW51IGJhciB3aXRoIHRoZSBzaW5nbGUgZW50cnkgLSBzeXN0ZW0gbWVudSBwb3B1cC4KICogVGhpcyBwb3B1cCBpcyBwcmVzZW50ZWQgdG8gdGhlIG91dHNpZGUgd29ybGQgYXMgYSAic3lzdGVtIG1lbnUiLgogKiBIb3dldmVyLCB0aGUgcmVhbCBzeXN0ZW0gbWVudSBoYW5kbGUgaXMgc29tZXRpbWVzIHNlZW4gaW4gdGhlCiAqIFdNX01FTlVTRUxFQ1QgcGFyYW1ldGVycyAoYW5kIFdvcmQgNiBsaWtlcyBpdCB0aGlzIHdheSkuCiAqLwpITUVOVSBNRU5VX0dldFN5c01lbnUoIEhXTkQgaFduZCwgSE1FTlUgaFBvcHVwTWVudSApCnsKICAgIEhNRU5VIGhNZW51OwoKICAgIFRSQUNFKCJsb2FkaW5nIHN5c3RlbSBtZW51LCBoV25kICVwLCBoUG9wdXBNZW51ICVwXG4iLCBoV25kLCBoUG9wdXBNZW51KTsKICAgIGlmICgoaE1lbnUgPSBDcmVhdGVNZW51KCkpKQogICAgewoJUE9QVVBNRU5VICptZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KTsKCW1lbnUtPndGbGFncyA9IE1GX1NZU01FTlU7CgltZW51LT5oV25kID0gV0lOX0dldEZ1bGxIYW5kbGUoIGhXbmQgKTsKCVRSQUNFKCJoV25kICVwIChoTWVudSAlcClcbiIsIG1lbnUtPmhXbmQsIGhNZW51KTsKCglpZiAoIWhQb3B1cE1lbnUpCgkgICAgaFBvcHVwTWVudSA9IE1FTlVfQ29weVN5c1BvcHVwKCk7CgoJaWYgKGhQb3B1cE1lbnUpCgl7CiAgICAgICAgICAgIGlmIChHZXRDbGFzc0xvbmdXKGhXbmQsIEdDTF9TVFlMRSkgJiBDU19OT0NMT1NFKQogICAgICAgICAgICAgICAgRGVsZXRlTWVudShoUG9wdXBNZW51LCBTQ19DTE9TRSwgTUZfQllDT01NQU5EKTsKCgkgICAgSW5zZXJ0TWVudVcoIGhNZW51LCAtMSwgTUZfU1lTTUVOVSB8IE1GX1BPUFVQIHwgTUZfQllQT1NJVElPTiwKICAgICAgICAgICAgICAgICAgICAgICAgIChVSU5UX1BUUiloUG9wdXBNZW51LCBOVUxMICk7CgogICAgICAgICAgICBtZW51LT5pdGVtc1swXS5mVHlwZSA9IE1GX1NZU01FTlUgfCBNRl9QT1BVUDsKICAgICAgICAgICAgbWVudS0+aXRlbXNbMF0uZlN0YXRlID0gMDsKICAgICAgICAgICAgaWYgKChtZW51ID0gTUVOVV9HZXRNZW51KGhQb3B1cE1lbnUpKSkgbWVudS0+d0ZsYWdzIHw9IE1GX1NZU01FTlU7CgoJICAgIFRSQUNFKCJoTWVudT0lcCAoaFBvcHVwICVwKVxuIiwgaE1lbnUsIGhQb3B1cE1lbnUgKTsKCSAgICByZXR1cm4gaE1lbnU7Cgl9CglEZXN0cm95TWVudSggaE1lbnUgKTsKICAgIH0KICAgIEVSUigiZmFpbGVkIHRvIGxvYWQgc3lzdGVtIG1lbnUhXG4iKTsKICAgIHJldHVybiAwOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0luaXRTeXNNZW51UG9wdXAKICoKICogR3JleSB0aGUgYXBwcm9wcmlhdGUgaXRlbXMgaW4gU3lzdGVtIG1lbnUuCiAqLwpzdGF0aWMgdm9pZCBNRU5VX0luaXRTeXNNZW51UG9wdXAoIEhNRU5VIGhtZW51LCBEV09SRCBzdHlsZSwgRFdPUkQgY2xzU3R5bGUgKQp7CiAgICBCT09MIGdyYXk7CgogICAgZ3JheSA9ICEoc3R5bGUgJiBXU19USElDS0ZSQU1FKSB8fCAoc3R5bGUgJiAoV1NfTUFYSU1JWkUgfCBXU19NSU5JTUlaRSkpOwogICAgRW5hYmxlTWVudUl0ZW0oIGhtZW51LCBTQ19TSVpFLCAoZ3JheSA/IE1GX0dSQVlFRCA6IE1GX0VOQUJMRUQpICk7CiAgICBncmF5ID0gKChzdHlsZSAmIFdTX01BWElNSVpFKSAhPSAwKTsKICAgIEVuYWJsZU1lbnVJdGVtKCBobWVudSwgU0NfTU9WRSwgKGdyYXkgPyBNRl9HUkFZRUQgOiBNRl9FTkFCTEVEKSApOwogICAgZ3JheSA9ICEoc3R5bGUgJiBXU19NSU5JTUlaRUJPWCkgfHwgKHN0eWxlICYgV1NfTUlOSU1JWkUpOwogICAgRW5hYmxlTWVudUl0ZW0oIGhtZW51LCBTQ19NSU5JTUlaRSwgKGdyYXkgPyBNRl9HUkFZRUQgOiBNRl9FTkFCTEVEKSApOwogICAgZ3JheSA9ICEoc3R5bGUgJiBXU19NQVhJTUlaRUJPWCkgfHwgKHN0eWxlICYgV1NfTUFYSU1JWkUpOwogICAgRW5hYmxlTWVudUl0ZW0oIGhtZW51LCBTQ19NQVhJTUlaRSwgKGdyYXkgPyBNRl9HUkFZRUQgOiBNRl9FTkFCTEVEKSApOwogICAgZ3JheSA9ICEoc3R5bGUgJiAoV1NfTUFYSU1JWkUgfCBXU19NSU5JTUlaRSkpOwogICAgRW5hYmxlTWVudUl0ZW0oIGhtZW51LCBTQ19SRVNUT1JFLCAoZ3JheSA/IE1GX0dSQVlFRCA6IE1GX0VOQUJMRUQpICk7CiAgICBncmF5ID0gKGNsc1N0eWxlICYgQ1NfTk9DTE9TRSkgIT0gMDsKCiAgICAvKiBUaGUgbWVudSBpdGVtIG11c3Qga2VlcCBpdHMgc3RhdGUgaWYgaXQncyBkaXNhYmxlZCAqLwogICAgaWYoZ3JheSkKCUVuYWJsZU1lbnVJdGVtKCBobWVudSwgU0NfQ0xPU0UsIE1GX0dSQVlFRCk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCiAqICAgVUlOVCAgTUVOVV9HZXRTdGFydE9mTmV4dENvbHVtbigKICogICAgIEhNRU5VICBoTWVudSApCiAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCnN0YXRpYyBVSU5UICBNRU5VX0dldFN0YXJ0T2ZOZXh0Q29sdW1uKAogICAgSE1FTlUgIGhNZW51ICkKewogICAgUE9QVVBNRU5VICptZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KTsKICAgIFVJTlQgaTsKCiAgICBpZighbWVudSkKCXJldHVybiBOT19TRUxFQ1RFRF9JVEVNOwoKICAgIGkgPSBtZW51LT5Gb2N1c2VkSXRlbSArIDE7CiAgICBpZiggaSA9PSBOT19TRUxFQ1RFRF9JVEVNICkKCXJldHVybiBpOwoKICAgIGZvciggOyBpIDwgbWVudS0+bkl0ZW1zOyArK2kgKSB7CglpZiAobWVudS0+aXRlbXNbaV0uZlR5cGUgJiAoTUZfTUVOVUJSRUFLIHwgTUZfTUVOVUJBUkJSRUFLKSkKCSAgICByZXR1cm4gaTsKICAgIH0KCiAgICByZXR1cm4gTk9fU0VMRUNURURfSVRFTTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoKICogICBVSU5UICBNRU5VX0dldFN0YXJ0T2ZQcmV2Q29sdW1uKAogKiAgICAgSE1FTlUgIGhNZW51ICkKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKc3RhdGljIFVJTlQgIE1FTlVfR2V0U3RhcnRPZlByZXZDb2x1bW4oCiAgICBITUVOVSAgaE1lbnUgKQp7CiAgICBQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpOwogICAgVUlOVCAgaTsKCiAgICBpZiggIW1lbnUgKQoJcmV0dXJuIE5PX1NFTEVDVEVEX0lURU07CgogICAgaWYoIG1lbnUtPkZvY3VzZWRJdGVtID09IDAgfHwgbWVudS0+Rm9jdXNlZEl0ZW0gPT0gTk9fU0VMRUNURURfSVRFTSApCglyZXR1cm4gTk9fU0VMRUNURURfSVRFTTsKCiAgICAvKiBGaW5kIHRoZSBzdGFydCBvZiB0aGUgY29sdW1uICovCgogICAgZm9yKGkgPSBtZW51LT5Gb2N1c2VkSXRlbTsgaSAhPSAwICYmCgkgIShtZW51LT5pdGVtc1tpXS5mVHlwZSAmIChNRl9NRU5VQlJFQUsgfCBNRl9NRU5VQkFSQlJFQUspKTsKCS0taSk7IC8qIGVtcHR5ICovCgogICAgaWYoaSA9PSAwKQoJcmV0dXJuIE5PX1NFTEVDVEVEX0lURU07CgogICAgZm9yKC0taTsgaSAhPSAwOyAtLWkpIHsKCWlmIChtZW51LT5pdGVtc1tpXS5mVHlwZSAmIChNRl9NRU5VQlJFQUsgfCBNRl9NRU5VQkFSQlJFQUspKQoJICAgIGJyZWFrOwogICAgfQoKICAgIFRSQUNFKCJyZXQgJWQuXG4iLCBpICk7CgogICAgcmV0dXJuIGk7Cn0KCgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0ZpbmRJdGVtCiAqCiAqIEZpbmQgYSBtZW51IGl0ZW0uIFJldHVybiBhIHBvaW50ZXIgb24gdGhlIGl0ZW0sIGFuZCBtb2RpZmllcyAqaG1lbnUKICogaW4gY2FzZSB0aGUgaXRlbSB3YXMgaW4gYSBzdWItbWVudS4KICovCnN0YXRpYyBNRU5VSVRFTSAqTUVOVV9GaW5kSXRlbSggSE1FTlUgKmhtZW51LCBVSU5UICpuUG9zLCBVSU5UIHdGbGFncyApCnsKICAgIFBPUFVQTUVOVSAqbWVudTsKICAgIE1FTlVJVEVNICpmYWxsYmFjayA9IE5VTEw7CiAgICBVSU5UIGZhbGxiYWNrX3BvcyA9IDA7CiAgICBVSU5UIGk7CgogICAgaWYgKCgqaG1lbnUgPT0gKEhNRU5VKTB4ZmZmZikgfHwgKCEobWVudSA9IE1FTlVfR2V0TWVudSgqaG1lbnUpKSkpIHJldHVybiBOVUxMOwogICAgaWYgKHdGbGFncyAmIE1GX0JZUE9TSVRJT04pCiAgICB7CglpZiAoKm5Qb3MgPj0gbWVudS0+bkl0ZW1zKSByZXR1cm4gTlVMTDsKCXJldHVybiAmbWVudS0+aXRlbXNbKm5Qb3NdOwogICAgfQogICAgZWxzZQogICAgewogICAgICAgIE1FTlVJVEVNICppdGVtID0gbWVudS0+aXRlbXM7Cglmb3IgKGkgPSAwOyBpIDwgbWVudS0+bkl0ZW1zOyBpKyssIGl0ZW0rKykKCXsKCSAgICBpZiAoaXRlbS0+ZlR5cGUgJiBNRl9QT1BVUCkKCSAgICB7CgkJSE1FTlUgaHN1Ym1lbnUgPSBpdGVtLT5oU3ViTWVudTsKCQlNRU5VSVRFTSAqc3ViaXRlbSA9IE1FTlVfRmluZEl0ZW0oICZoc3VibWVudSwgblBvcywgd0ZsYWdzICk7CgkJaWYgKHN1Yml0ZW0pCgkJewoJCSAgICAqaG1lbnUgPSBoc3VibWVudTsKCQkgICAgcmV0dXJuIHN1Yml0ZW07CgkJfQoJCWVsc2UgaWYgKGl0ZW0tPndJRCA9PSAqblBvcykKCQl7CgkJICAgIC8qIGZhbGxiYWNrIHRvIHRoaXMgaXRlbSBpZiBub3RoaW5nIGVsc2UgZm91bmQgKi8KCQkgICAgZmFsbGJhY2tfcG9zID0gaTsKCQkgICAgZmFsbGJhY2sgPSBpdGVtOwoJCX0KCSAgICB9CgkgICAgZWxzZSBpZiAoaXRlbS0+d0lEID09ICpuUG9zKQoJICAgIHsKCQkqblBvcyA9IGk7CgkJcmV0dXJuIGl0ZW07CgkgICAgfQoJfQogICAgfQoKICAgIGlmIChmYWxsYmFjaykKICAgICAgICAqblBvcyA9IGZhbGxiYWNrX3BvczsKCiAgICByZXR1cm4gZmFsbGJhY2s7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9GaW5kU3ViTWVudQogKgogKiBGaW5kIGEgU3ViIG1lbnUuIFJldHVybiB0aGUgcG9zaXRpb24gb2YgdGhlIHN1Ym1lbnUsIGFuZCBtb2RpZmllcwogKiAqaG1lbnUgaW4gY2FzZSBpdCBpcyBmb3VuZCBpbiBhbm90aGVyIHN1Yi1tZW51LgogKiBJZiB0aGUgc3VibWVudSBjYW5ub3QgYmUgZm91bmQsIE5PX1NFTEVDVEVEX0lURU0gaXMgcmV0dXJuZWQuCiAqLwpVSU5UIE1FTlVfRmluZFN1Yk1lbnUoIEhNRU5VICpobWVudSwgSE1FTlUgaFN1YlRhcmdldCApCnsKICAgIFBPUFVQTUVOVSAqbWVudTsKICAgIFVJTlQgaTsKICAgIE1FTlVJVEVNICppdGVtOwogICAgaWYgKCgoKmhtZW51KT09KEhNRU5VKTB4ZmZmZikgfHwKICAgICAgICAgICAgKCEobWVudSA9IE1FTlVfR2V0TWVudSgqaG1lbnUpKSkpCiAgICAgICAgcmV0dXJuIE5PX1NFTEVDVEVEX0lURU07CiAgICBpdGVtID0gbWVudS0+aXRlbXM7CiAgICBmb3IgKGkgPSAwOyBpIDwgbWVudS0+bkl0ZW1zOyBpKyssIGl0ZW0rKykgewogICAgICAgIGlmKCEoaXRlbS0+ZlR5cGUgJiBNRl9QT1BVUCkpIGNvbnRpbnVlOwogICAgICAgIGlmIChpdGVtLT5oU3ViTWVudSA9PSBoU3ViVGFyZ2V0KSB7CiAgICAgICAgICAgIHJldHVybiBpOwogICAgICAgIH0KICAgICAgICBlbHNlICB7CiAgICAgICAgICAgIEhNRU5VIGhzdWJtZW51ID0gaXRlbS0+aFN1Yk1lbnU7CiAgICAgICAgICAgIFVJTlQgcG9zID0gTUVOVV9GaW5kU3ViTWVudSggJmhzdWJtZW51LCBoU3ViVGFyZ2V0ICk7CiAgICAgICAgICAgIGlmIChwb3MgIT0gTk9fU0VMRUNURURfSVRFTSkgewogICAgICAgICAgICAgICAgKmhtZW51ID0gaHN1Ym1lbnU7CiAgICAgICAgICAgICAgICByZXR1cm4gcG9zOwogICAgICAgICAgICB9CiAgICAgICAgfQogICAgfQogICAgcmV0dXJuIE5PX1NFTEVDVEVEX0lURU07Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9GcmVlSXRlbURhdGEKICovCnN0YXRpYyB2b2lkIE1FTlVfRnJlZUl0ZW1EYXRhKCBNRU5VSVRFTSogaXRlbSApCnsKICAgIC8qIGRlbGV0ZSB0ZXh0ICovCiAgICBIZWFwRnJlZSggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgaXRlbS0+dGV4dCApOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfQWRqdXN0TWVudUl0ZW1SZWN0CiAqCiAqIEFkanVzdCBtZW51IGl0ZW0gcmVjdGFuZ2xlIGFjY29yZGluZyB0byBzY3JvbGxpbmcgc3RhdGUuCiAqLwpzdGF0aWMgdm9pZApNRU5VX0FkanVzdE1lbnVJdGVtUmVjdChjb25zdCBQT1BVUE1FTlUgKm1lbnUsIExQUkVDVCByZWN0KQp7CiAgICBpZiAobWVudS0+YlNjcm9sbGluZykKICAgIHsKICAgICAgICBVSU5UIGFycm93X2JpdG1hcF93aWR0aCwgYXJyb3dfYml0bWFwX2hlaWdodDsKICAgICAgICBCSVRNQVAgYm1wOwoKICAgICAgICBHZXRPYmplY3RXKGdldF91cF9hcnJvd19iaXRtYXAoKSwgc2l6ZW9mKGJtcCksICZibXApOwogICAgICAgIGFycm93X2JpdG1hcF93aWR0aCA9IGJtcC5ibVdpZHRoOwogICAgICAgIGFycm93X2JpdG1hcF9oZWlnaHQgPSBibXAuYm1IZWlnaHQ7CiAgICAgICAgcmVjdC0+dG9wICs9IGFycm93X2JpdG1hcF9oZWlnaHQgLSBtZW51LT5uU2Nyb2xsUG9zOwogICAgICAgIHJlY3QtPmJvdHRvbSArPSBhcnJvd19iaXRtYXBfaGVpZ2h0IC0gbWVudS0+blNjcm9sbFBvczsKICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9GaW5kSXRlbUJ5Q29vcmRzCiAqCiAqIEZpbmQgdGhlIGl0ZW0gYXQgdGhlIHNwZWNpZmllZCBjb29yZGluYXRlcyAoc2NyZWVuIGNvb3JkcykuIERvZXMKICogbm90IHdvcmsgZm9yIGNoaWxkIHdpbmRvd3MgYW5kIHRoZXJlZm9yZSBzaG91bGQgbm90IGJlIGNhbGxlZCBmb3IKICogYW4gYXJiaXRyYXJ5IHN5c3RlbSBtZW51LgogKi8Kc3RhdGljIE1FTlVJVEVNICpNRU5VX0ZpbmRJdGVtQnlDb29yZHMoIGNvbnN0IFBPUFVQTUVOVSAqbWVudSwKCQkJCQlQT0lOVCBwdCwgVUlOVCAqcG9zICkKewogICAgTUVOVUlURU0gKml0ZW07CiAgICBVSU5UIGk7CiAgICBSRUNUIHdyZWN0OwogICAgUkVDVCByZWN0OwoKICAgIGlmICghR2V0V2luZG93UmVjdChtZW51LT5oV25kLCZ3cmVjdCkpIHJldHVybiBOVUxMOwogICAgcHQueCAtPSB3cmVjdC5sZWZ0O3B0LnkgLT0gd3JlY3QudG9wOwogICAgaXRlbSA9IG1lbnUtPml0ZW1zOwogICAgZm9yIChpID0gMDsgaSA8IG1lbnUtPm5JdGVtczsgaSsrLCBpdGVtKyspCiAgICB7CiAgICAgICAgcmVjdCA9IGl0ZW0tPnJlY3Q7CiAgICAgICAgTUVOVV9BZGp1c3RNZW51SXRlbVJlY3QobWVudSwgJnJlY3QpOwoJaWYgKChwdC54ID49IHJlY3QubGVmdCkgJiYgKHB0LnggPCByZWN0LnJpZ2h0KSAmJgoJICAgIChwdC55ID49IHJlY3QudG9wKSAmJiAocHQueSA8IHJlY3QuYm90dG9tKSkKCXsKCSAgICBpZiAocG9zKSAqcG9zID0gaTsKCSAgICByZXR1cm4gaXRlbTsKCX0KICAgIH0KICAgIHJldHVybiBOVUxMOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0ZpbmRJdGVtQnlLZXkKICoKICogRmluZCB0aGUgbWVudSBpdGVtIHNlbGVjdGVkIGJ5IGEga2V5IHByZXNzLgogKiBSZXR1cm4gaXRlbSBpZCwgLTEgaWYgbm9uZSwgLTIgaWYgd2Ugc2hvdWxkIGNsb3NlIHRoZSBtZW51LgogKi8Kc3RhdGljIFVJTlQgTUVOVV9GaW5kSXRlbUJ5S2V5KCBIV05EIGh3bmRPd25lciwgSE1FTlUgaG1lbnUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV0NIQVIga2V5LCBCT09MIGZvcmNlTWVudUNoYXIgKQp7CiAgICBUUkFDRSgiXHRsb29raW5nIGZvciAnJWMnICgweCUwMngpIGluIFslcF1cbiIsIChjaGFyKWtleSwga2V5LCBobWVudSApOwoKICAgIGlmICghSXNNZW51KCBobWVudSApKSBobWVudSA9IEdldFN1Yk1lbnUoIGdldF93aW5fc3lzX21lbnUoaHduZE93bmVyKSwgMCk7CgogICAgaWYgKGhtZW51KQogICAgewoJUE9QVVBNRU5VICptZW51ID0gTUVOVV9HZXRNZW51KCBobWVudSApOwoJTUVOVUlURU0gKml0ZW0gPSBtZW51LT5pdGVtczsKCUxSRVNVTFQgbWVudWNoYXI7CgoJaWYoICFmb3JjZU1lbnVDaGFyICkKCXsKCSAgICAgVUlOVCBpOwoKCSAgICAgZm9yIChpID0gMDsgaSA8IG1lbnUtPm5JdGVtczsgaSsrLCBpdGVtKyspCgkgICAgIHsKCQlpZiggaXRlbS0+dGV4dCkKCQl7CgkJICAgIFdDSEFSICpwID0gaXRlbS0+dGV4dCAtIDI7CgkJICAgIGRvCgkJICAgIHsKCQkgICAgCXAgPSBzdHJjaHJXIChwICsgMiwgJyYnKTsKCQkgICAgfQoJCSAgICB3aGlsZSAocCAhPSBOVUxMICYmIHAgWzFdID09ICcmJyk7CgkJICAgIGlmIChwICYmICh0b3VwcGVyVyhwWzFdKSA9PSB0b3VwcGVyVyhrZXkpKSkgcmV0dXJuIGk7CgkJfQoJICAgICB9Cgl9CgltZW51Y2hhciA9IFNlbmRNZXNzYWdlVyggaHduZE93bmVyLCBXTV9NRU5VQ0hBUiwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTUFLRVdQQVJBTSgga2V5LCBtZW51LT53RmxhZ3MgKSwgKExQQVJBTSlobWVudSApOwoJaWYgKEhJV09SRChtZW51Y2hhcikgPT0gMikgcmV0dXJuIExPV09SRChtZW51Y2hhcik7CglpZiAoSElXT1JEKG1lbnVjaGFyKSA9PSAxKSByZXR1cm4gKFVJTlQpKC0yKTsKICAgIH0KICAgIHJldHVybiAoVUlOVCkoLTEpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0dldEJpdG1hcEl0ZW1TaXplCiAqCiAqIEdldCB0aGUgc2l6ZSBvZiBhIGJpdG1hcCBpdGVtLgogKi8Kc3RhdGljIHZvaWQgTUVOVV9HZXRCaXRtYXBJdGVtU2l6ZSggTUVOVUlURU0gKmxwaXRlbSwgU0laRSAqc2l6ZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSFdORCBod25kT3duZXIpCnsKICAgIEJJVE1BUCBibTsKICAgIEhCSVRNQVAgYm1wID0gbHBpdGVtLT5oYm1wSXRlbTsKCiAgICBzaXplLT5jeCA9IHNpemUtPmN5ID0gMDsKCiAgICAvKiBjaGVjayBpZiB0aGVyZSBpcyBhIG1hZ2ljIG1lbnUgaXRlbSBhc3NvY2lhdGVkIHdpdGggdGhpcyBpdGVtICovCiAgICBzd2l0Y2goIChJTlRfUFRSKSBibXAgKQogICAgewogICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX0NBTExCQUNLOgogICAgICAgIHsKICAgICAgICAgICAgTUVBU1VSRUlURU1TVFJVQ1QgbWVhc0l0ZW07CiAgICAgICAgICAgIG1lYXNJdGVtLkN0bFR5cGUgPSBPRFRfTUVOVTsKICAgICAgICAgICAgbWVhc0l0ZW0uQ3RsSUQgPSAwOwogICAgICAgICAgICBtZWFzSXRlbS5pdGVtSUQgPSBscGl0ZW0tPndJRDsKICAgICAgICAgICAgbWVhc0l0ZW0uaXRlbVdpZHRoID0gbHBpdGVtLT5yZWN0LnJpZ2h0IC0gbHBpdGVtLT5yZWN0LmxlZnQ7CiAgICAgICAgICAgIG1lYXNJdGVtLml0ZW1IZWlnaHQgPSBscGl0ZW0tPnJlY3QuYm90dG9tIC0gbHBpdGVtLT5yZWN0LnRvcDsKICAgICAgICAgICAgbWVhc0l0ZW0uaXRlbURhdGEgPSBscGl0ZW0tPmR3SXRlbURhdGE7CiAgICAgICAgICAgIFNlbmRNZXNzYWdlVyggaHduZE93bmVyLCBXTV9NRUFTVVJFSVRFTSwgbHBpdGVtLT53SUQsIChMUEFSQU0pJm1lYXNJdGVtKTsKICAgICAgICAgICAgc2l6ZS0+Y3ggPSBtZWFzSXRlbS5pdGVtV2lkdGg7CiAgICAgICAgICAgIHNpemUtPmN5ID0gbWVhc0l0ZW0uaXRlbUhlaWdodDsKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgIH0KICAgICAgICBicmVhazsKICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9TWVNURU06CiAgICAgICAgaWYgKGxwaXRlbS0+ZHdJdGVtRGF0YSkKICAgICAgICB7CiAgICAgICAgICAgIGJtcCA9IChIQklUTUFQKWxwaXRlbS0+ZHdJdGVtRGF0YTsKICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgfQogICAgICAgIC8qIGZhbGwgdGhyb3VnaCAqLwogICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX01CQVJfUkVTVE9SRToKICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9NQkFSX01JTklNSVpFOgogICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX01CQVJfTUlOSU1JWkVfRDoKICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9NQkFSX0NMT1NFOgogICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX01CQVJfQ0xPU0VfRDoKICAgICAgICBzaXplLT5jeCA9IEdldFN5c3RlbU1ldHJpY3MoIFNNX0NZTUVOVSApIC0gNDsKICAgICAgICBzaXplLT5jeSA9IHNpemUtPmN4OwogICAgICAgIHJldHVybjsKICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9QT1BVUF9DTE9TRToKICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9QT1BVUF9SRVNUT1JFOgogICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX1BPUFVQX01BWElNSVpFOgogICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX1BPUFVQX01JTklNSVpFOgogICAgICAgIEZJWE1FKCJNYWdpYyAlcCBub3QgaW1wbGVtZW50ZWRcbiIsIGJtcCApOwogICAgICAgIHJldHVybjsKICAgIH0KICAgIGlmIChHZXRPYmplY3RXKGJtcCwgc2l6ZW9mKGJtKSwgJmJtICkpCiAgICB7CiAgICAgICAgc2l6ZS0+Y3ggPSBibS5ibVdpZHRoOwogICAgICAgIHNpemUtPmN5ID0gYm0uYm1IZWlnaHQ7CiAgICB9Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9EcmF3Qml0bWFwSXRlbQogKgogKiBEcmF3IGEgYml0bWFwIGl0ZW0uCiAqLwpzdGF0aWMgdm9pZCBNRU5VX0RyYXdCaXRtYXBJdGVtKCBIREMgaGRjLCBNRU5VSVRFTSAqbHBpdGVtLCBjb25zdCBSRUNUICpyZWN0LAogICAgICAgICAgICAgICAgICAgIEhNRU5VIGhtZW51LCBIV05EIGh3bmRPd25lciwgVUlOVCBvZGFjdGlvbiwgQk9PTCBtZW51QmFyKQp7CiAgICBCSVRNQVAgYm07CiAgICBEV09SRCByb3A7CiAgICBIREMgaGRjTWVtOwogICAgSEJJVE1BUCBibXA7CiAgICBpbnQgdyA9IHJlY3QtPnJpZ2h0IC0gcmVjdC0+bGVmdDsKICAgIGludCBoID0gcmVjdC0+Ym90dG9tIC0gcmVjdC0+dG9wOwogICAgaW50IGJtcF94b2Zmc2V0ID0gMDsKICAgIGludCBsZWZ0LCB0b3A7CiAgICBIQklUTUFQIGhibVRvRHJhdyA9IGxwaXRlbS0+aGJtcEl0ZW07CiAgICBibXAgPSBoYm1Ub0RyYXc7CgogICAgLyogQ2hlY2sgaWYgdGhlcmUgaXMgYSBtYWdpYyBtZW51IGl0ZW0gYXNzb2NpYXRlZCB3aXRoIHRoaXMgaXRlbSAqLwogICAgaWYgKElTX01BR0lDX0JJVE1BUChoYm1Ub0RyYXcpKQogICAgewogICAgICAgIFVJTlQgZmxhZ3MgPSAwOwogICAgICAgIFJFQ1QgcjsKCglzd2l0Y2goKElOVF9QVFIpaGJtVG9EcmF3KQogICAgICAgIHsKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfU1lTVEVNOgogICAgICAgICAgICBpZiAobHBpdGVtLT5kd0l0ZW1EYXRhKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBibXAgPSAoSEJJVE1BUClscGl0ZW0tPmR3SXRlbURhdGE7CiAgICAgICAgICAgICAgICBpZiAoIUdldE9iamVjdFcoIGJtcCwgc2l6ZW9mKGJtKSwgJmJtICkpIHJldHVybjsKICAgICAgICAgICAgfQogICAgICAgICAgICBlbHNlCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIHN0YXRpYyBIQklUTUFQIGhCbXBTeXNNZW51OwoKICAgICAgICAgICAgICAgIGlmICghaEJtcFN5c01lbnUpIGhCbXBTeXNNZW51ID0gTG9hZEJpdG1hcFcoMCwgTUFLRUlOVFJFU09VUkNFVyhPQk1fQ0xPU0UpKTsKICAgICAgICAgICAgICAgIGJtcCA9IGhCbXBTeXNNZW51OwogICAgICAgICAgICAgICAgaWYgKCFHZXRPYmplY3RXKCBibXAsIHNpemVvZihibSksICZibSApKSByZXR1cm47CiAgICAgICAgICAgICAgICAvKiBvbmx5IHVzZSByaWdodCBoYWxmIG9mIHRoZSBiaXRtYXAgKi8KICAgICAgICAgICAgICAgIGJtcF94b2Zmc2V0ID0gYm0uYm1XaWR0aCAvIDI7CiAgICAgICAgICAgICAgICBibS5ibVdpZHRoIC09IGJtcF94b2Zmc2V0OwogICAgICAgICAgICB9CiAgICAgICAgICAgIGdvdG8gZ290X2JpdG1hcDsKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfTUJBUl9SRVNUT1JFOgogICAgICAgICAgICBmbGFncyA9IERGQ1NfQ0FQVElPTlJFU1RPUkU7CiAgICAgICAgICAgIGJyZWFrOwogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9NQkFSX01JTklNSVpFOgogICAgICAgICAgICBmbGFncyA9IERGQ1NfQ0FQVElPTk1JTjsKICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX01CQVJfTUlOSU1JWkVfRDoKICAgICAgICAgICAgZmxhZ3MgPSBERkNTX0NBUFRJT05NSU4gfCBERkNTX0lOQUNUSVZFOwogICAgICAgICAgICBicmVhazsKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfTUJBUl9DTE9TRToKICAgICAgICAgICAgZmxhZ3MgPSBERkNTX0NBUFRJT05DTE9TRTsKICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX01CQVJfQ0xPU0VfRDoKICAgICAgICAgICAgZmxhZ3MgPSBERkNTX0NBUFRJT05DTE9TRSB8IERGQ1NfSU5BQ1RJVkU7CiAgICAgICAgICAgIGJyZWFrOwogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9DQUxMQkFDSzoKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgRFJBV0lURU1TVFJVQ1QgZHJhd0l0ZW07CiAgICAgICAgICAgICAgICBkcmF3SXRlbS5DdGxUeXBlID0gT0RUX01FTlU7CiAgICAgICAgICAgICAgICBkcmF3SXRlbS5DdGxJRCA9IDA7CiAgICAgICAgICAgICAgICBkcmF3SXRlbS5pdGVtSUQgPSBscGl0ZW0tPndJRDsKICAgICAgICAgICAgICAgIGRyYXdJdGVtLml0ZW1BY3Rpb24gPSBvZGFjdGlvbjsKICAgICAgICAgICAgICAgIGRyYXdJdGVtLml0ZW1TdGF0ZSA9IChscGl0ZW0tPmZTdGF0ZSAmIE1GX0NIRUNLRUQpP09EU19DSEVDS0VEOjA7CiAgICAgICAgICAgICAgICBkcmF3SXRlbS5pdGVtU3RhdGUgfD0gKGxwaXRlbS0+ZlN0YXRlICYgTUZfREVGQVVMVCk/T0RTX0RFRkFVTFQ6MDsKICAgICAgICAgICAgICAgIGRyYXdJdGVtLml0ZW1TdGF0ZSB8PSAobHBpdGVtLT5mU3RhdGUgJiBNRl9ESVNBQkxFRCk/T0RTX0RJU0FCTEVEOjA7CiAgICAgICAgICAgICAgICBkcmF3SXRlbS5pdGVtU3RhdGUgfD0gKGxwaXRlbS0+ZlN0YXRlICYgTUZfR1JBWUVEKT9PRFNfR1JBWUVEfE9EU19ESVNBQkxFRDowOwogICAgICAgICAgICAgICAgZHJhd0l0ZW0uaXRlbVN0YXRlIHw9IChscGl0ZW0tPmZTdGF0ZSAmIE1GX0hJTElURSk/T0RTX1NFTEVDVEVEOjA7CiAgICAgICAgICAgICAgICBkcmF3SXRlbS5od25kSXRlbSA9IChIV05EKWhtZW51OwogICAgICAgICAgICAgICAgZHJhd0l0ZW0uaERDID0gaGRjOwogICAgICAgICAgICAgICAgZHJhd0l0ZW0uaXRlbURhdGEgPSBscGl0ZW0tPmR3SXRlbURhdGE7CiAgICAgICAgICAgICAgICBkcmF3SXRlbS5yY0l0ZW0gPSAqcmVjdDsKICAgICAgICAgICAgICAgIFNlbmRNZXNzYWdlVyggaHduZE93bmVyLCBXTV9EUkFXSVRFTSwgMCwgKExQQVJBTSkmZHJhd0l0ZW0pOwogICAgICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGJyZWFrOwogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9QT1BVUF9DTE9TRToKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfUE9QVVBfUkVTVE9SRToKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfUE9QVVBfTUFYSU1JWkU6CiAgICAgICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX1BPUFVQX01JTklNSVpFOgogICAgICAgIGRlZmF1bHQ6CiAgICAgICAgICAgIEZJWE1FKCJNYWdpYyAlcCBub3QgaW1wbGVtZW50ZWRcbiIsIGhibVRvRHJhdyk7CiAgICAgICAgICAgIHJldHVybjsKICAgICAgICB9CiAgICAgICAgciA9ICpyZWN0OwogICAgICAgIEluZmxhdGVSZWN0KCAmciwgLTEsIC0xICk7CiAgICAgICAgaWYgKGxwaXRlbS0+ZlN0YXRlICYgTUZfSElMSVRFKSBmbGFncyB8PSBERkNTX1BVU0hFRDsKICAgICAgICBEcmF3RnJhbWVDb250cm9sKCBoZGMsICZyLCBERkNfQ0FQVElPTiwgZmxhZ3MgKTsKICAgICAgICByZXR1cm47CiAgICB9CgogICAgaWYgKCFibXAgfHwgIUdldE9iamVjdFcoIGJtcCwgc2l6ZW9mKGJtKSwgJmJtICkpIHJldHVybjsKCiBnb3RfYml0bWFwOgogICAgaGRjTWVtID0gQ3JlYXRlQ29tcGF0aWJsZURDKCBoZGMgKTsKICAgIFNlbGVjdE9iamVjdCggaGRjTWVtLCBibXAgKTsKCiAgICAvKiBoYW5kbGUgZm9udHNpemUgPiBiaXRtYXBfaGVpZ2h0ICovCiAgICB0b3AgPSAoaD5ibS5ibUhlaWdodCkgPyByZWN0LT50b3ArKGgtYm0uYm1IZWlnaHQpLzIgOiByZWN0LT50b3A7CiAgICBsZWZ0PXJlY3QtPmxlZnQ7CiAgICByb3A9KChscGl0ZW0tPmZTdGF0ZSAmIE1GX0hJTElURSkgJiYgIUlTX01BR0lDX0JJVE1BUChoYm1Ub0RyYXcpKSA/IE5PVFNSQ0NPUFkgOiBTUkNDT1BZOwogICAgaWYgKChscGl0ZW0tPmZTdGF0ZSAmIE1GX0hJTElURSkgJiYgbHBpdGVtLT5oYm1wSXRlbSkKICAgICAgICBTZXRCa0NvbG9yKGhkYywgR2V0U3lzQ29sb3IoQ09MT1JfSElHSExJR0hUKSk7CiAgICBCaXRCbHQoIGhkYywgbGVmdCwgdG9wLCB3LCBoLCBoZGNNZW0sIGJtcF94b2Zmc2V0LCAwLCByb3AgKTsKICAgIERlbGV0ZURDKCBoZGNNZW0gKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9DYWxjSXRlbVNpemUKICoKICogQ2FsY3VsYXRlIHRoZSBzaXplIG9mIHRoZSBtZW51IGl0ZW0gYW5kIHN0b3JlIGl0IGluIGxwaXRlbS0+cmVjdC4KICovCnN0YXRpYyB2b2lkIE1FTlVfQ2FsY0l0ZW1TaXplKCBIREMgaGRjLCBNRU5VSVRFTSAqbHBpdGVtLCBIV05EIGh3bmRPd25lciwKCQkJICAgICAgIElOVCBvcmdYLCBJTlQgb3JnWSwgQk9PTCBtZW51QmFyLCBQT1BVUE1FTlUqIGxwcG9wICkKewogICAgV0NIQVIgKnA7CiAgICBVSU5UIGNoZWNrX2JpdG1hcF93aWR0aCA9IEdldFN5c3RlbU1ldHJpY3MoIFNNX0NYTUVOVUNIRUNLICk7CiAgICBVSU5UIGFycm93X2JpdG1hcF93aWR0aDsKICAgIEJJVE1BUCBibTsKICAgIElOVCBpdGVtaGVpZ2h0OwoKICAgIFRSQUNFKCJkYz0lcCBvd25lcj0lcCAoJWQsJWQpXG4iLCBoZGMsIGh3bmRPd25lciwgb3JnWCwgb3JnWSk7CiAgICBkZWJ1Z19wcmludF9tZW51aXRlbSgiTUVOVV9DYWxjSXRlbVNpemU6IG1lbnVpdGVtOiIsIGxwaXRlbSwKCQkJIChtZW51QmFyID8gIiAoTWVudUJhcikiIDogIiIpKTsKCiAgICBHZXRPYmplY3RXKCBnZXRfYXJyb3dfYml0bWFwKCksIHNpemVvZihibSksICZibSApOwogICAgYXJyb3dfYml0bWFwX3dpZHRoID0gYm0uYm1XaWR0aDsKCiAgICAvKiBub3QgZG9uZSBpbiBNZW51X0luaXQ6IEdldERpYWxvZ0Jhc2VVbml0cygpIGJyZWFrcyB0aGVyZSAqLwogICAgaWYoICFtZW51Y2hhcnNpemUuY3ggKSB7CiAgICAgICAgbWVudWNoYXJzaXplLmN4ID0gR2RpR2V0Q2hhckRpbWVuc2lvbnMoIGhkYywgTlVMTCwgJm1lbnVjaGFyc2l6ZS5jeSApOwogICAgICAgIC8qIFdpbjk1Lzk4L01FIHdpbGwgdXNlIG1lbnVjaGFyc2l6ZS5jeSBoZXJlLiBUZXN0aW5nIGlzIHBvc3NpYmxlCiAgICAgICAgICogYnV0IGl0IGlzIHVubGlrZWx5IGFuIGFwcGxpY2F0aW9uIHdpbGwgZGVwZW5kIG9uIHRoYXQgKi8KICAgICAgICBPRGl0ZW1oZWlnaHQgPSBISVdPUkQoIEdldERpYWxvZ0Jhc2VVbml0cygpKTsKICAgIH0KCiAgICBTZXRSZWN0KCAmbHBpdGVtLT5yZWN0LCBvcmdYLCBvcmdZLCBvcmdYLCBvcmdZICk7CgogICAgaWYgKGxwaXRlbS0+ZlR5cGUgJiBNRl9PV05FUkRSQVcpCiAgICB7CiAgICAgICAgTUVBU1VSRUlURU1TVFJVQ1QgbWlzOwogICAgICAgIG1pcy5DdGxUeXBlICAgID0gT0RUX01FTlU7CiAgICAgICAgbWlzLkN0bElEICAgICAgPSAwOwogICAgICAgIG1pcy5pdGVtSUQgICAgID0gbHBpdGVtLT53SUQ7CiAgICAgICAgbWlzLml0ZW1EYXRhICAgPSBscGl0ZW0tPmR3SXRlbURhdGE7CiAgICAgICAgbWlzLml0ZW1IZWlnaHQgPSBPRGl0ZW1oZWlnaHQ7CiAgICAgICAgbWlzLml0ZW1XaWR0aCAgPSAwOwogICAgICAgIFNlbmRNZXNzYWdlVyggaHduZE93bmVyLCBXTV9NRUFTVVJFSVRFTSwgMCwgKExQQVJBTSkmbWlzICk7CiAgICAgICAgLyogVGVzdHMgcmV2ZWFsIHRoYXQgV2luZG93cyAoIFdpbjk1IHRocnUgV2luWFApIGFkZHMgdHdpY2UgdGhlIGF2ZXJhZ2UKICAgICAgICAgKiB3aWR0aCBvZiBhIG1lbnVmb250IGNoYXJhY3RlciB0byB0aGUgd2lkdGggb2YgYW4gb3duZXItZHJhd24gbWVudS4gCiAgICAgICAgICovCiAgICAgICAgbHBpdGVtLT5yZWN0LnJpZ2h0ICs9IG1pcy5pdGVtV2lkdGggKyAyICogbWVudWNoYXJzaXplLmN4OwogICAgICAgIGlmIChtZW51QmFyKSB7CiAgICAgICAgICAgIC8qIHVuZGVyIGF0IGxlYXN0IHdpbjk1IHlvdSBzZWVtIHRvIGJlIGdpdmVuIGEgc3RhbmRhcmQKICAgICAgICAgICAgICAgaGVpZ2h0IGZvciB0aGUgbWVudSBhbmQgdGhlIGhlaWdodCB2YWx1ZSBpcyBpZ25vcmVkICovCiAgICAgICAgICAgIGxwaXRlbS0+cmVjdC5ib3R0b20gKz0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWU1FTlVTSVpFKTsKICAgICAgICB9IGVsc2UKICAgICAgICAgICAgbHBpdGVtLT5yZWN0LmJvdHRvbSArPSBtaXMuaXRlbUhlaWdodDsKCiAgICAgICAgVFJBQ0UoImlkPSUwNHggc2l6ZT0lZHglZFxuIiwKICAgICAgICAgICAgICAgIGxwaXRlbS0+d0lELCBscGl0ZW0tPnJlY3QucmlnaHQtbHBpdGVtLT5yZWN0LmxlZnQsCiAgICAgICAgICAgICAgICBscGl0ZW0tPnJlY3QuYm90dG9tLWxwaXRlbS0+cmVjdC50b3ApOwogICAgICAgIHJldHVybjsKICAgIH0KCiAgICBpZiAobHBpdGVtLT5mVHlwZSAmIE1GX1NFUEFSQVRPUikKICAgIHsKICAgICAgICBscGl0ZW0tPnJlY3QuYm90dG9tICs9IEdldFN5c3RlbU1ldHJpY3MoIFNNX0NZTUVOVVNJWkUpLzI7CiAgICAgICAgaWYoICFtZW51QmFyKQogICAgICAgICAgICBscGl0ZW0tPnJlY3QucmlnaHQgKz0gYXJyb3dfYml0bWFwX3dpZHRoICsgbWVudWNoYXJzaXplLmN4OwogICAgICAgIHJldHVybjsKICAgIH0KCiAgICBpdGVtaGVpZ2h0ID0gMDsKICAgIGxwaXRlbS0+eFRhYiA9IDA7CgogICAgaWYgKCFtZW51QmFyKSB7CiAgICAgICAgaWYgKGxwaXRlbS0+aGJtcEl0ZW0pIHsKICAgICAgICAgICAgU0laRSBzaXplOwoKICAgICAgICAgICAgTUVOVV9HZXRCaXRtYXBJdGVtU2l6ZShscGl0ZW0sICZzaXplLCBod25kT3duZXIpOwogICAgICAgICAgICAvKiBLZWVwIHRoZSBzaXplIG9mIHRoZSBiaXRtYXAgaW4gY2FsbGJhY2sgbW9kZSB0byBiZSBhYmxlCiAgICAgICAgICAgICAqIHRvIGRyYXcgaXQgY29ycmVjdGx5ICovCiAgICAgICAgICAgIGxwaXRlbS0+Ym1wc2l6ZSA9IHNpemU7CiAgICAgICAgICAgIGxwcG9wLT5tYXhCbXBTaXplLmN4ID0gbWF4KCBscHBvcC0+bWF4Qm1wU2l6ZS5jeCwgc2l6ZS5jeCk7CiAgICAgICAgICAgIGxwcG9wLT5tYXhCbXBTaXplLmN5ID0gbWF4KCBscHBvcC0+bWF4Qm1wU2l6ZS5jeSwgc2l6ZS5jeSk7CiAgICAgICAgICAgIGxwaXRlbS0+cmVjdC5yaWdodCArPSBzaXplLmN4ICsgMjsKICAgICAgICAgICAgaXRlbWhlaWdodCA9IHNpemUuY3kgKyAyOwogICAgICAgIH0KICAgICAgICBpZiggIShscHBvcC0+ZHdTdHlsZSAmIE1OU19OT0NIRUNLKSkKICAgICAgICAgICAgbHBpdGVtLT5yZWN0LnJpZ2h0ICs9IGNoZWNrX2JpdG1hcF93aWR0aDsgCiAgICAgICAgbHBpdGVtLT5yZWN0LnJpZ2h0ICs9IDQgKyBtZW51Y2hhcnNpemUuY3g7CiAgICAgICAgbHBpdGVtLT54VGFiID0gbHBpdGVtLT5yZWN0LnJpZ2h0OwogICAgICAgIGxwaXRlbS0+cmVjdC5yaWdodCArPSBhcnJvd19iaXRtYXBfd2lkdGg7CiAgICB9IGVsc2UgaWYgKGxwaXRlbS0+aGJtcEl0ZW0pIHsgLyogbWVudUJhciAqLwogICAgICAgIFNJWkUgc2l6ZTsKCiAgICAgICAgTUVOVV9HZXRCaXRtYXBJdGVtU2l6ZSggbHBpdGVtLCAmc2l6ZSwgaHduZE93bmVyICk7CiAgICAgICAgbHBpdGVtLT5ibXBzaXplID0gc2l6ZTsKICAgICAgICBscGl0ZW0tPnJlY3QucmlnaHQgICs9IHNpemUuY3g7CiAgICAgICAgaWYoIGxwaXRlbS0+dGV4dCkgbHBpdGVtLT5yZWN0LnJpZ2h0ICArPSAyOwogICAgICAgIGl0ZW1oZWlnaHQgPSBzaXplLmN5OwogICAgfQoKICAgIC8qIGl0IG11c3QgYmUgYSB0ZXh0IGl0ZW0gLSB1bmxlc3MgaXQncyB0aGUgc3lzdGVtIG1lbnUgKi8KICAgIGlmICghKGxwaXRlbS0+ZlR5cGUgJiBNRl9TWVNNRU5VKSAmJiBscGl0ZW0tPnRleHQpIHsKICAgICAgICBIRk9OVCBoZm9udE9sZCA9IE5VTEw7CiAgICAgICAgUkVDVCByYyA9IGxwaXRlbS0+cmVjdDsKICAgICAgICBMT05HIHR4dGhlaWdodCwgdHh0d2lkdGg7CgoJaWYgKCBscGl0ZW0tPmZTdGF0ZSAmIE1GU19ERUZBVUxUICkgewoJICAgICBoZm9udE9sZCA9IFNlbGVjdE9iamVjdCggaGRjLCBnZXRfbWVudV9mb250KFRSVUUpICk7Cgl9CiAgICAgICAgaWYgKG1lbnVCYXIpIHsKICAgICAgICAgICAgdHh0aGVpZ2h0ID0gRHJhd1RleHRXKCBoZGMsIGxwaXRlbS0+dGV4dCwgLTEsICZyYywKICAgICAgICAgICAgICAgICAgICBEVF9TSU5HTEVMSU5FfERUX0NBTENSRUNUKTsgCiAgICAgICAgICAgIGxwaXRlbS0+cmVjdC5yaWdodCAgKz0gcmMucmlnaHQgLSByYy5sZWZ0OwogICAgICAgICAgICBpdGVtaGVpZ2h0ID0gbWF4KCBtYXgoIGl0ZW1oZWlnaHQsIHR4dGhlaWdodCksCiAgICAgICAgICAgICAgICAgICAgR2V0U3lzdGVtTWV0cmljcyggU01fQ1lNRU5VKSAtIDEpOwogICAgICAgICAgICBscGl0ZW0tPnJlY3QucmlnaHQgKz0gIDIgKiBtZW51Y2hhcnNpemUuY3g7CiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgaWYgKChwID0gc3RyY2hyVyggbHBpdGVtLT50ZXh0LCAnXHQnICkpICE9IE5VTEwpIHsKICAgICAgICAgICAgICAgIFJFQ1QgdG1wcmMgPSByYzsKICAgICAgICAgICAgICAgIExPTkcgdG1waGVpZ2h0OwogICAgICAgICAgICAgICAgaW50IG4gPSAoaW50KSggcCAtIGxwaXRlbS0+dGV4dCk7CiAgICAgICAgICAgICAgICAvKiBJdGVtIGNvbnRhaW5zIGEgdGFiIChvbmx5IG1lYW5pbmdmdWwgaW4gcG9wdXAgbWVudXMpICovCiAgICAgICAgICAgICAgICAvKiBnZXQgdGV4dCBzaXplIGJlZm9yZSB0aGUgdGFiICovCiAgICAgICAgICAgICAgICB0eHRoZWlnaHQgPSBEcmF3VGV4dFcoIGhkYywgbHBpdGVtLT50ZXh0LCBuLCAmcmMsCiAgICAgICAgICAgICAgICAgICAgICAgIERUX1NJTkdMRUxJTkV8RFRfQ0FMQ1JFQ1QpOwogICAgICAgICAgICAgICAgdHh0d2lkdGggPSByYy5yaWdodCAtIHJjLmxlZnQ7CiAgICAgICAgICAgICAgICBwICs9IDE7IC8qIGFkdmFuY2UgcGFzdCB0aGUgVGFiICovCiAgICAgICAgICAgICAgICAvKiBnZXQgdGV4dCBzaXplIGFmdGVyIHRoZSB0YWIgKi8KICAgICAgICAgICAgICAgIHRtcGhlaWdodCA9IERyYXdUZXh0VyggaGRjLCBwLCAtMSwgJnRtcHJjLAogICAgICAgICAgICAgICAgICAgICAgICBEVF9TSU5HTEVMSU5FfERUX0NBTENSRUNUKTsKICAgICAgICAgICAgICAgIGxwaXRlbS0+eFRhYiArPSB0eHR3aWR0aDsKICAgICAgICAgICAgICAgIHR4dGhlaWdodCA9IG1heCggdHh0aGVpZ2h0LCB0bXBoZWlnaHQpOwogICAgICAgICAgICAgICAgdHh0d2lkdGggKz0gbWVudWNoYXJzaXplLmN4ICsgLyogc3BhY2UgZm9yIHRoZSB0YWIgKi8KICAgICAgICAgICAgICAgICAgICB0bXByYy5yaWdodCAtIHRtcHJjLmxlZnQ7IC8qIHNwYWNlIGZvciB0aGUgc2hvcnQgY3V0ICovCiAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICB0eHRoZWlnaHQgPSBEcmF3VGV4dFcoIGhkYywgbHBpdGVtLT50ZXh0LCAtMSwgJnJjLAogICAgICAgICAgICAgICAgICAgICAgICBEVF9TSU5HTEVMSU5FfERUX0NBTENSRUNUKTsKICAgICAgICAgICAgICAgIHR4dHdpZHRoID0gcmMucmlnaHQgLSByYy5sZWZ0OwogICAgICAgICAgICAgICAgbHBpdGVtLT54VGFiICs9IHR4dHdpZHRoOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGxwaXRlbS0+cmVjdC5yaWdodCAgKz0gMiArIHR4dHdpZHRoOwogICAgICAgICAgICBpdGVtaGVpZ2h0ID0gbWF4KCBpdGVtaGVpZ2h0LAogICAgICAgICAgICAgICAgICAgIG1heCggdHh0aGVpZ2h0ICsgMiwgbWVudWNoYXJzaXplLmN5ICsgNCkpOwogICAgICAgIH0KCWlmIChoZm9udE9sZCkgU2VsZWN0T2JqZWN0IChoZGMsIGhmb250T2xkKTsKICAgIH0gZWxzZSBpZiggbWVudUJhcikgewogICAgICAgIGl0ZW1oZWlnaHQgPSBtYXgoIGl0ZW1oZWlnaHQsIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lNRU5VKS0xKTsKICAgIH0KICAgIGxwaXRlbS0+cmVjdC5ib3R0b20gKz0gaXRlbWhlaWdodDsKICAgIFRSQUNFKCIlc1xuIiwgd2luZV9kYmdzdHJfcmVjdCggJmxwaXRlbS0+cmVjdCkpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0dldE1heFBvcHVwSGVpZ2h0CiAqLwpzdGF0aWMgVUlOVApNRU5VX0dldE1heFBvcHVwSGVpZ2h0KExQUE9QVVBNRU5VIGxwcG9wKQp7CiAgICBpZiAobHBwb3AtPmN5TWF4KQogICAgICAgIHJldHVybiBscHBvcC0+Y3lNYXg7CiAgICByZXR1cm4gR2V0U3lzdGVtTWV0cmljcyhTTV9DWVNDUkVFTikgLSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZQk9SREVSKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9Qb3B1cE1lbnVDYWxjU2l6ZQogKgogKiBDYWxjdWxhdGUgdGhlIHNpemUgb2YgYSBwb3B1cCBtZW51LgogKi8Kc3RhdGljIHZvaWQgTUVOVV9Qb3B1cE1lbnVDYWxjU2l6ZSggTFBQT1BVUE1FTlUgbHBwb3AsIEhXTkQgaHduZE93bmVyICkKewogICAgTUVOVUlURU0gKmxwaXRlbTsKICAgIEhEQyBoZGM7CiAgICBpbnQgc3RhcnQsIGk7CiAgICBpbnQgb3JnWCwgb3JnWSwgbWF4WCwgbWF4VGFiLCBtYXhUYWJXaWR0aCwgbWF4SGVpZ2h0OwoKICAgIGxwcG9wLT5XaWR0aCA9IGxwcG9wLT5IZWlnaHQgPSAwOwogICAgaWYgKGxwcG9wLT5uSXRlbXMgPT0gMCkgcmV0dXJuOwogICAgaGRjID0gR2V0REMoIDAgKTsKCiAgICBTZWxlY3RPYmplY3QoIGhkYywgZ2V0X21lbnVfZm9udChGQUxTRSkpOwoKICAgIHN0YXJ0ID0gMDsKICAgIG1heFggPSAyICsgMTsKCiAgICBscHBvcC0+bWF4Qm1wU2l6ZS5jeCA9IDA7CiAgICBscHBvcC0+bWF4Qm1wU2l6ZS5jeSA9IDA7CgogICAgd2hpbGUgKHN0YXJ0IDwgbHBwb3AtPm5JdGVtcykKICAgIHsKCWxwaXRlbSA9ICZscHBvcC0+aXRlbXNbc3RhcnRdOwoJb3JnWCA9IG1heFg7CiAgICAgICAgaWYoIGxwaXRlbS0+ZlR5cGUgJiAoTUZfTUVOVUJSRUFLIHwgTUZfTUVOVUJBUkJSRUFLKSkKICAgICAgICAgICAgb3JnWCArPSBNRU5VX0NPTF9TUEFDRTsgCglvcmdZID0gTUVOVV9UT1BfTUFSR0lOOwoKCW1heFRhYiA9IG1heFRhYldpZHRoID0gMDsKCSAgLyogUGFyc2UgaXRlbXMgdW50aWwgY29sdW1uIGJyZWFrIG9yIGVuZCBvZiBtZW51ICovCglmb3IgKGkgPSBzdGFydDsgaSA8IGxwcG9wLT5uSXRlbXM7IGkrKywgbHBpdGVtKyspCgl7CgkgICAgaWYgKChpICE9IHN0YXJ0KSAmJgoJCShscGl0ZW0tPmZUeXBlICYgKE1GX01FTlVCUkVBSyB8IE1GX01FTlVCQVJCUkVBSykpKSBicmVhazsKCgkgICAgTUVOVV9DYWxjSXRlbVNpemUoIGhkYywgbHBpdGVtLCBod25kT3duZXIsIG9yZ1gsIG9yZ1ksIEZBTFNFLCBscHBvcCApOwoJICAgIG1heFggPSBtYXgoIG1heFgsIGxwaXRlbS0+cmVjdC5yaWdodCApOwoJICAgIG9yZ1kgPSBscGl0ZW0tPnJlY3QuYm90dG9tOwoJICAgIGlmIChJU19TVFJJTkdfSVRFTShscGl0ZW0tPmZUeXBlKSAmJiBscGl0ZW0tPnhUYWIpCgkgICAgewoJCW1heFRhYiA9IG1heCggbWF4VGFiLCBscGl0ZW0tPnhUYWIgKTsKCQltYXhUYWJXaWR0aCA9IG1heChtYXhUYWJXaWR0aCxscGl0ZW0tPnJlY3QucmlnaHQtbHBpdGVtLT54VGFiKTsKCSAgICB9Cgl9CgoJICAvKiBGaW5pc2ggdGhlIGNvbHVtbiAoc2V0IGFsbCBpdGVtcyB0byB0aGUgbGFyZ2VzdCB3aWR0aCBmb3VuZCkgKi8KCW1heFggPSBtYXgoIG1heFgsIG1heFRhYiArIG1heFRhYldpZHRoICk7Cglmb3IgKGxwaXRlbSA9ICZscHBvcC0+aXRlbXNbc3RhcnRdOyBzdGFydCA8IGk7IHN0YXJ0KyssIGxwaXRlbSsrKQoJewoJICAgIGxwaXRlbS0+cmVjdC5yaWdodCA9IG1heFg7CgkgICAgaWYgKElTX1NUUklOR19JVEVNKGxwaXRlbS0+ZlR5cGUpICYmIGxwaXRlbS0+eFRhYikKCQlscGl0ZW0tPnhUYWIgPSBtYXhUYWI7CgoJfQoJbHBwb3AtPkhlaWdodCA9IG1heCggbHBwb3AtPkhlaWdodCwgb3JnWSApOwogICAgfQoKICAgIGxwcG9wLT5XaWR0aCAgPSBtYXhYOwoKICAgIC8qIHNwYWNlIGZvciAzZCBib3JkZXIgKi8KICAgIGxwcG9wLT5IZWlnaHQgKz0gTUVOVV9CT1RUT01fTUFSR0lOOwogICAgbHBwb3AtPldpZHRoICs9IDI7CgogICAgLyogQWRqdXN0IHBvcHVwIGhlaWdodCBpZiBpdCBleGNlZWRzIG1heGltdW0gKi8KICAgIG1heEhlaWdodCA9IE1FTlVfR2V0TWF4UG9wdXBIZWlnaHQobHBwb3ApOwogICAgbHBwb3AtPm5Ub3RhbEhlaWdodCA9IGxwcG9wLT5IZWlnaHQgLSBNRU5VX1RPUF9NQVJHSU47CiAgICBpZiAobHBwb3AtPkhlaWdodCA+PSBtYXhIZWlnaHQpCiAgICB7CiAgICAgICAgbHBwb3AtPkhlaWdodCA9IG1heEhlaWdodDsKICAgICAgICBscHBvcC0+YlNjcm9sbGluZyA9IFRSVUU7CiAgICB9CiAgICBlbHNlCiAgICB7CiAgICAgICAgbHBwb3AtPmJTY3JvbGxpbmcgPSBGQUxTRTsKICAgIH0KCiAgICBSZWxlYXNlREMoIDAsIGhkYyApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX01lbnVCYXJDYWxjU2l6ZQogKgogKiBGSVhNRTogV29yZCA2IGltcGxlbWVudHMgaXRzIG93biBNREkgYW5kIGl0cyBvd24gJ2Nsb3NlIHdpbmRvdycgYml0bWFwCiAqIGhlaWdodCBpcyBvZmYgYnkgMSBwaXhlbCB3aGljaCBjYXVzZXMgbGVuZ3RoeSB3aW5kb3cgcmVsb2NhdGlvbnMgd2hlbgogKiBhY3RpdmUgZG9jdW1lbnQgd2luZG93IGlzIG1heGltaXplZC9yZXN0b3JlZC4KICoKICogQ2FsY3VsYXRlIHRoZSBzaXplIG9mIHRoZSBtZW51IGJhci4KICovCnN0YXRpYyB2b2lkIE1FTlVfTWVudUJhckNhbGNTaXplKCBIREMgaGRjLCBMUFJFQ1QgbHByZWN0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTFBQT1BVUE1FTlUgbHBwb3AsIEhXTkQgaHduZE93bmVyICkKewogICAgTUVOVUlURU0gKmxwaXRlbTsKICAgIGludCBzdGFydCwgaSwgb3JnWCwgb3JnWSwgbWF4WSwgaGVscFBvczsKCiAgICBpZiAoKGxwcmVjdCA9PSBOVUxMKSB8fCAobHBwb3AgPT0gTlVMTCkpIHJldHVybjsKICAgIGlmIChscHBvcC0+bkl0ZW1zID09IDApIHJldHVybjsKICAgIFRSQUNFKCJscHJlY3QgJXAgJXNcbiIsIGxwcmVjdCwgd2luZV9kYmdzdHJfcmVjdCggbHByZWN0KSk7CiAgICBscHBvcC0+V2lkdGggID0gbHByZWN0LT5yaWdodCAtIGxwcmVjdC0+bGVmdDsKICAgIGxwcG9wLT5IZWlnaHQgPSAwOwogICAgbWF4WSA9IGxwcmVjdC0+dG9wKzE7CiAgICBzdGFydCA9IDA7CiAgICBoZWxwUG9zID0gLTE7CiAgICBscHBvcC0+bWF4Qm1wU2l6ZS5jeCA9IDA7CiAgICBscHBvcC0+bWF4Qm1wU2l6ZS5jeSA9IDA7CiAgICB3aGlsZSAoc3RhcnQgPCBscHBvcC0+bkl0ZW1zKQogICAgewoJbHBpdGVtID0gJmxwcG9wLT5pdGVtc1tzdGFydF07CglvcmdYID0gbHByZWN0LT5sZWZ0OwoJb3JnWSA9IG1heFk7CgoJICAvKiBQYXJzZSBpdGVtcyB1bnRpbCBsaW5lIGJyZWFrIG9yIGVuZCBvZiBtZW51ICovCglmb3IgKGkgPSBzdGFydDsgaSA8IGxwcG9wLT5uSXRlbXM7IGkrKywgbHBpdGVtKyspCgl7CgkgICAgaWYgKChoZWxwUG9zID09IC0xKSAmJiAobHBpdGVtLT5mVHlwZSAmIE1GX1JJR0hUSlVTVElGWSkpIGhlbHBQb3MgPSBpOwoJICAgIGlmICgoaSAhPSBzdGFydCkgJiYKCQkobHBpdGVtLT5mVHlwZSAmIChNRl9NRU5VQlJFQUsgfCBNRl9NRU5VQkFSQlJFQUspKSkgYnJlYWs7CgoJICAgIFRSQUNFKCJjYWxsaW5nIE1FTlVfQ2FsY0l0ZW1TaXplIG9yZz0oJWQsICVkKVxuIiwgb3JnWCwgb3JnWSApOwoJICAgIGRlYnVnX3ByaW50X21lbnVpdGVtICgiICBpdGVtOiAiLCBscGl0ZW0sICIiKTsKCSAgICBNRU5VX0NhbGNJdGVtU2l6ZSggaGRjLCBscGl0ZW0sIGh3bmRPd25lciwgb3JnWCwgb3JnWSwgVFJVRSwgbHBwb3AgKTsKCgkgICAgaWYgKGxwaXRlbS0+cmVjdC5yaWdodCA+IGxwcmVjdC0+cmlnaHQpCgkgICAgewoJCWlmIChpICE9IHN0YXJ0KSBicmVhazsKCQllbHNlIGxwaXRlbS0+cmVjdC5yaWdodCA9IGxwcmVjdC0+cmlnaHQ7CgkgICAgfQoJICAgIG1heFkgPSBtYXgoIG1heFksIGxwaXRlbS0+cmVjdC5ib3R0b20gKTsKCSAgICBvcmdYID0gbHBpdGVtLT5yZWN0LnJpZ2h0OwoJfQoKCSAgLyogRmluaXNoIHRoZSBsaW5lIChzZXQgYWxsIGl0ZW1zIHRvIHRoZSBsYXJnZXN0IGhlaWdodCBmb3VuZCkgKi8KCXdoaWxlIChzdGFydCA8IGkpIGxwcG9wLT5pdGVtc1tzdGFydCsrXS5yZWN0LmJvdHRvbSA9IG1heFk7CiAgICB9CgogICAgbHByZWN0LT5ib3R0b20gPSBtYXhZOwogICAgbHBwb3AtPkhlaWdodCA9IGxwcmVjdC0+Ym90dG9tIC0gbHByZWN0LT50b3A7CgogICAgLyogRmx1c2ggcmlnaHQgYWxsIGl0ZW1zIGJldHdlZW4gdGhlIE1GX1JJR0hUSlVTVElGWSBhbmQgKi8KICAgIC8qIHRoZSBsYXN0IGl0ZW0gKGlmIHNldmVyYWwgbGluZXMsIG9ubHkgbW92ZSB0aGUgbGFzdCBsaW5lKSAqLwogICAgbHBpdGVtID0gJmxwcG9wLT5pdGVtc1tscHBvcC0+bkl0ZW1zLTFdOwogICAgb3JnWSA9IGxwaXRlbS0+cmVjdC50b3A7CiAgICBvcmdYID0gbHByZWN0LT5yaWdodDsKICAgIGZvciAoaSA9IGxwcG9wLT5uSXRlbXMgLSAxOyBpID49IGhlbHBQb3M7IGktLSwgbHBpdGVtLS0pIHsKICAgICAgICBpZiAoIChoZWxwUG9zPT0tMSkgfHwgKGhlbHBQb3M+aSkgKQogICAgICAgICAgICBicmVhazsJCQkJLyogZG9uZSAqLwogICAgICAgIGlmIChscGl0ZW0tPnJlY3QudG9wICE9IG9yZ1kpIGJyZWFrOwkvKiBPdGhlciBsaW5lICovCiAgICAgICAgaWYgKGxwaXRlbS0+cmVjdC5yaWdodCA+PSBvcmdYKSBicmVhazsJLyogVG9vIGZhciByaWdodCBhbHJlYWR5ICovCiAgICAgICAgbHBpdGVtLT5yZWN0LmxlZnQgKz0gb3JnWCAtIGxwaXRlbS0+cmVjdC5yaWdodDsKICAgICAgICBscGl0ZW0tPnJlY3QucmlnaHQgPSBvcmdYOwogICAgICAgIG9yZ1ggPSBscGl0ZW0tPnJlY3QubGVmdDsKICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9EcmF3U2Nyb2xsQXJyb3dzCiAqCiAqIERyYXcgc2Nyb2xsIGFycm93cy4KICovCnN0YXRpYyB2b2lkCk1FTlVfRHJhd1Njcm9sbEFycm93cyhMUFBPUFVQTUVOVSBscHBvcCwgSERDIGhkYykKewogICAgSERDIGhkY01lbSA9IENyZWF0ZUNvbXBhdGlibGVEQyhoZGMpOwogICAgSEJJVE1BUCBoT3JpZ0JpdG1hcDsKICAgIFVJTlQgYXJyb3dfYml0bWFwX3dpZHRoLCBhcnJvd19iaXRtYXBfaGVpZ2h0OwogICAgQklUTUFQIGJtcDsKICAgIFJFQ1QgcmVjdDsKCiAgICBHZXRPYmplY3RXKGdldF9kb3duX2Fycm93X2JpdG1hcCgpLCBzaXplb2YoYm1wKSwgJmJtcCk7CiAgICBhcnJvd19iaXRtYXBfd2lkdGggPSBibXAuYm1XaWR0aDsKICAgIGFycm93X2JpdG1hcF9oZWlnaHQgPSBibXAuYm1IZWlnaHQ7CgogICAgCiAgICBpZiAobHBwb3AtPm5TY3JvbGxQb3MpCiAgICAgICAgaE9yaWdCaXRtYXAgPSBTZWxlY3RPYmplY3QoaGRjTWVtLCBnZXRfdXBfYXJyb3dfYml0bWFwKCkpOwogICAgZWxzZQogICAgICAgIGhPcmlnQml0bWFwID0gU2VsZWN0T2JqZWN0KGhkY01lbSwgZ2V0X3VwX2Fycm93X2luYWN0aXZlX2JpdG1hcCgpKTsKICAgIHJlY3QubGVmdCA9IDA7CiAgICByZWN0LnRvcCA9IDA7CiAgICByZWN0LnJpZ2h0ID0gbHBwb3AtPldpZHRoOwogICAgcmVjdC5ib3R0b20gPSBhcnJvd19iaXRtYXBfaGVpZ2h0OwogICAgRmlsbFJlY3QoaGRjLCAmcmVjdCwgR2V0U3lzQ29sb3JCcnVzaChDT0xPUl9NRU5VKSk7CiAgICBCaXRCbHQoaGRjLCAobHBwb3AtPldpZHRoIC0gYXJyb3dfYml0bWFwX3dpZHRoKSAvIDIsIDAsCiAgICAgICAgICAgYXJyb3dfYml0bWFwX3dpZHRoLCBhcnJvd19iaXRtYXBfaGVpZ2h0LCBoZGNNZW0sIDAsIDAsIFNSQ0NPUFkpOwogICAgcmVjdC50b3AgPSBscHBvcC0+SGVpZ2h0IC0gYXJyb3dfYml0bWFwX2hlaWdodDsKICAgIHJlY3QuYm90dG9tID0gbHBwb3AtPkhlaWdodDsKICAgIEZpbGxSZWN0KGhkYywgJnJlY3QsIEdldFN5c0NvbG9yQnJ1c2goQ09MT1JfTUVOVSkpOwogICAgaWYgKGxwcG9wLT5uU2Nyb2xsUG9zIDwgbHBwb3AtPm5Ub3RhbEhlaWdodCAtIChNRU5VX0dldE1heFBvcHVwSGVpZ2h0KGxwcG9wKSAtIDIgKiBhcnJvd19iaXRtYXBfaGVpZ2h0KSkKICAgICAgICBTZWxlY3RPYmplY3QoaGRjTWVtLCBnZXRfZG93bl9hcnJvd19iaXRtYXAoKSk7CiAgICBlbHNlCiAgICAgICAgU2VsZWN0T2JqZWN0KGhkY01lbSwgZ2V0X2Rvd25fYXJyb3dfaW5hY3RpdmVfYml0bWFwKCkpOwogICAgQml0Qmx0KGhkYywgKGxwcG9wLT5XaWR0aCAtIGFycm93X2JpdG1hcF93aWR0aCkgLyAyLAogICAgICAgICAgIGxwcG9wLT5IZWlnaHQgLSBhcnJvd19iaXRtYXBfaGVpZ2h0LAogICAgICAgICAgIGFycm93X2JpdG1hcF93aWR0aCwgYXJyb3dfYml0bWFwX2hlaWdodCwgaGRjTWVtLCAwLCAwLCBTUkNDT1BZKTsKICAgIFNlbGVjdE9iamVjdChoZGNNZW0sIGhPcmlnQml0bWFwKTsKICAgIERlbGV0ZURDKGhkY01lbSk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIGRyYXdfcG9wdXBfYXJyb3cKICoKICogRHJhd3MgdGhlIHBvcHVwLW1lbnUgYXJyb3cuCiAqLwpzdGF0aWMgdm9pZCBkcmF3X3BvcHVwX2Fycm93KCBIREMgaGRjLCBSRUNUIHJlY3QsIFVJTlQgYXJyb3dfYml0bWFwX3dpZHRoLAogICAgICAgIFVJTlQgYXJyb3dfYml0bWFwX2hlaWdodCkKewogICAgSERDIGhkY01lbSA9IENyZWF0ZUNvbXBhdGlibGVEQyggaGRjICk7CiAgICBIQklUTUFQIGhPcmlnQml0bWFwOwoKICAgIGhPcmlnQml0bWFwID0gU2VsZWN0T2JqZWN0KCBoZGNNZW0sIGdldF9hcnJvd19iaXRtYXAoKSApOwogICAgQml0Qmx0KCBoZGMsIHJlY3QucmlnaHQgLSBhcnJvd19iaXRtYXBfd2lkdGggLSAxLAogICAgICAgICAgICAocmVjdC50b3AgKyByZWN0LmJvdHRvbSAtIGFycm93X2JpdG1hcF9oZWlnaHQpIC8gMiwKICAgICAgICAgICAgYXJyb3dfYml0bWFwX3dpZHRoLCBhcnJvd19iaXRtYXBfaGVpZ2h0LAogICAgICAgICAgICBoZGNNZW0sIDAsIDAsIFNSQ0NPUFkgKTsKICAgIFNlbGVjdE9iamVjdCggaGRjTWVtLCBoT3JpZ0JpdG1hcCApOwogICAgRGVsZXRlREMoIGhkY01lbSApOwp9Ci8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9EcmF3TWVudUl0ZW0KICoKICogRHJhdyBhIHNpbmdsZSBtZW51IGl0ZW0uCiAqLwpzdGF0aWMgdm9pZCBNRU5VX0RyYXdNZW51SXRlbSggSFdORCBod25kLCBITUVOVSBobWVudSwgSFdORCBod25kT3duZXIsIEhEQyBoZGMsIE1FTlVJVEVNICpscGl0ZW0sCgkJCSAgICAgICBVSU5UIGhlaWdodCwgQk9PTCBtZW51QmFyLCBVSU5UIG9kYWN0aW9uICkKewogICAgUkVDVCByZWN0OwogICAgQk9PTCBmbGF0X21lbnUgPSBGQUxTRTsKICAgIGludCBia2duZDsKICAgIFVJTlQgYXJyb3dfYml0bWFwX3dpZHRoID0gMCwgYXJyb3dfYml0bWFwX2hlaWdodCA9IDA7CiAgICBQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoaG1lbnUpOwogICAgUkVDVCBibXByYzsKCiAgICBkZWJ1Z19wcmludF9tZW51aXRlbSgiTUVOVV9EcmF3TWVudUl0ZW06ICIsIGxwaXRlbSwgIiIpOwoKICAgIGlmICghbWVudUJhcikgewogICAgICAgIEJJVE1BUCBibXA7CiAgICAgICAgR2V0T2JqZWN0VyggZ2V0X2Fycm93X2JpdG1hcCgpLCBzaXplb2YoYm1wKSwgJmJtcCApOwogICAgICAgIGFycm93X2JpdG1hcF93aWR0aCA9IGJtcC5ibVdpZHRoOwogICAgICAgIGFycm93X2JpdG1hcF9oZWlnaHQgPSBibXAuYm1IZWlnaHQ7CiAgICB9CgogICAgaWYgKGxwaXRlbS0+ZlR5cGUgJiBNRl9TWVNNRU5VKQogICAgewoJaWYoICFJc0ljb25pYyhod25kKSApCgkgICAgTkNfRHJhd1N5c0J1dHRvbiggaHduZCwgaGRjLCBscGl0ZW0tPmZTdGF0ZSAmIChNRl9ISUxJVEUgfCBNRl9NT1VTRVNFTEVDVCkgKTsKCXJldHVybjsKICAgIH0KCiAgICBTeXN0ZW1QYXJhbWV0ZXJzSW5mb1cgKFNQSV9HRVRGTEFUTUVOVSwgMCwgJmZsYXRfbWVudSwgMCk7CiAgICBia2duZCA9IChtZW51QmFyICYmIGZsYXRfbWVudSkgPyBDT0xPUl9NRU5VQkFSIDogQ09MT1JfTUVOVTsKICAKICAgICAgLyogU2V0dXAgY29sb3JzICovCgogICAgaWYgKGxwaXRlbS0+ZlN0YXRlICYgTUZfSElMSVRFKQogICAgewogICAgICAgIGlmKG1lbnVCYXIgJiYgIWZsYXRfbWVudSkgewoJICAgIFNldFRleHRDb2xvcihoZGMsIEdldFN5c0NvbG9yKENPTE9SX01FTlVURVhUKSk7CiAgICAgICAgICAgIFNldEJrQ29sb3IoaGRjLCBHZXRTeXNDb2xvcihDT0xPUl9NRU5VKSk7Cgl9IGVsc2UgewoJICAgIGlmKGxwaXRlbS0+ZlN0YXRlICYgTUZfR1JBWUVEKQoJCVNldFRleHRDb2xvcihoZGMsIEdldFN5c0NvbG9yKENPTE9SX0dSQVlURVhUKSk7CgkgICAgZWxzZQoJCVNldFRleHRDb2xvcihoZGMsIEdldFN5c0NvbG9yKENPTE9SX0hJR0hMSUdIVFRFWFQpKTsKICAgICAgICAgICAgU2V0QmtDb2xvcihoZGMsIEdldFN5c0NvbG9yKENPTE9SX0hJR0hMSUdIVCkpOwoJfQogICAgfQogICAgZWxzZQogICAgewoJaWYgKGxwaXRlbS0+ZlN0YXRlICYgTUZfR1JBWUVEKQoJICAgIFNldFRleHRDb2xvciggaGRjLCBHZXRTeXNDb2xvciggQ09MT1JfR1JBWVRFWFQgKSApOwoJZWxzZQoJICAgIFNldFRleHRDb2xvciggaGRjLCBHZXRTeXNDb2xvciggQ09MT1JfTUVOVVRFWFQgKSApOwoJU2V0QmtDb2xvciggaGRjLCBHZXRTeXNDb2xvciggYmtnbmQgKSApOwogICAgfQoKICAgIFRSQUNFKCJyZWN0PSVzXG4iLCB3aW5lX2RiZ3N0cl9yZWN0KCAmbHBpdGVtLT5yZWN0KSk7CiAgICByZWN0ID0gbHBpdGVtLT5yZWN0OwogICAgTUVOVV9BZGp1c3RNZW51SXRlbVJlY3QoTUVOVV9HZXRNZW51KGhtZW51KSwgJnJlY3QpOwoKICAgIGlmIChscGl0ZW0tPmZUeXBlICYgTUZfT1dORVJEUkFXKQogICAgewogICAgICAgIC8qCiAgICAgICAgKiogRXhwZXJpbWVudGF0aW9uIHVuZGVyIFdpbmRvd3MgcmV2ZWFscyB0aGF0IGFuIG93bmVyLWRyYXduCiAgICAgICAgKiogbWVudSBpcyBnaXZlbiB0aGUgcmVjdGFuZ2xlIHdoaWNoIGluY2x1ZGVzIHRoZSBzcGFjZSBpdCByZXF1ZXN0ZWQKICAgICAgICAqKiBpbiBpdHMgcmVzcG9uc2UgdG8gV01fTUVBU1VSRUlURU0gX3BsdXNfIHdpZHRoIGZvciBhIGNoZWNrbWFyawogICAgICAgICoqIGFuZCBhIHBvcHVwLW1lbnUgYXJyb3cuICBUaGlzIGlzIHRoZSB2YWx1ZSBvZiBscGl0ZW0tPnJlY3QuCiAgICAgICAgKiogV2luZG93cyB3aWxsIGxlYXZlIGFsbCBkcmF3aW5nIHRvIHRoZSBhcHBsaWNhdGlvbiBleGNlcHQgZm9yCiAgICAgICAgKiogdGhlIHBvcHVwLW1lbnUgYXJyb3cuICBXaW5kb3dzIGFsd2F5cyBkcmF3cyB0aGF0IGl0c2VsZiwgYWZ0ZXIKICAgICAgICAqKiB0aGUgbWVudSBvd25lciBoYXMgZmluaXNoZWQgZHJhd2luZy4KICAgICAgICAqLwogICAgICAgIERSQVdJVEVNU1RSVUNUIGRpczsKCiAgICAgICAgZGlzLkN0bFR5cGUgICA9IE9EVF9NRU5VOwoJZGlzLkN0bElEICAgICA9IDA7CiAgICAgICAgZGlzLml0ZW1JRCAgICA9IGxwaXRlbS0+d0lEOwogICAgICAgIGRpcy5pdGVtRGF0YSAgPSBscGl0ZW0tPmR3SXRlbURhdGE7CiAgICAgICAgZGlzLml0ZW1TdGF0ZSA9IDA7CiAgICAgICAgaWYgKGxwaXRlbS0+ZlN0YXRlICYgTUZfQ0hFQ0tFRCkgZGlzLml0ZW1TdGF0ZSB8PSBPRFNfQ0hFQ0tFRDsKICAgICAgICBpZiAobHBpdGVtLT5mU3RhdGUgJiBNRl9HUkFZRUQpICBkaXMuaXRlbVN0YXRlIHw9IE9EU19HUkFZRUR8T0RTX0RJU0FCTEVEOwogICAgICAgIGlmIChscGl0ZW0tPmZTdGF0ZSAmIE1GX0hJTElURSkgIGRpcy5pdGVtU3RhdGUgfD0gT0RTX1NFTEVDVEVEOwogICAgICAgIGRpcy5pdGVtQWN0aW9uID0gb2RhY3Rpb247IC8qIE9EQV9EUkFXRU5USVJFIHwgT0RBX1NFTEVDVCB8IE9EQV9GT0NVUzsgKi8KICAgICAgICBkaXMuaHduZEl0ZW0gICA9IChIV05EKWhtZW51OwogICAgICAgIGRpcy5oREMgICAgICAgID0gaGRjOwogICAgICAgIGRpcy5yY0l0ZW0gICAgID0gcmVjdDsKICAgICAgICBUUkFDRSgiT3duZXJkcmF3OiBvd25lcj0lcCBpdGVtSUQ9JWQsIGl0ZW1TdGF0ZT0lZCwgaXRlbUFjdGlvbj0lZCwgIgoJICAgICAgImh3bmRJdGVtPSVwLCBoZGM9JXAsIHJjSXRlbT0lc1xuIiwgaHduZE93bmVyLAoJICAgICAgZGlzLml0ZW1JRCwgZGlzLml0ZW1TdGF0ZSwgZGlzLml0ZW1BY3Rpb24sIGRpcy5od25kSXRlbSwKCSAgICAgIGRpcy5oREMsIHdpbmVfZGJnc3RyX3JlY3QoICZkaXMucmNJdGVtKSk7CiAgICAgICAgU2VuZE1lc3NhZ2VXKCBod25kT3duZXIsIFdNX0RSQVdJVEVNLCAwLCAoTFBBUkFNKSZkaXMgKTsKICAgICAgICAvKiBEcmF3IHRoZSBwb3B1cC1tZW51IGFycm93ICovCiAgICAgICAgaWYgKGxwaXRlbS0+ZlR5cGUgJiBNRl9QT1BVUCkKICAgICAgICAgICAgZHJhd19wb3B1cF9hcnJvdyggaGRjLCByZWN0LCBhcnJvd19iaXRtYXBfd2lkdGgsCiAgICAgICAgICAgICAgICAgICAgYXJyb3dfYml0bWFwX2hlaWdodCk7CiAgICAgICAgcmV0dXJuOwogICAgfQoKICAgIGlmIChtZW51QmFyICYmIChscGl0ZW0tPmZUeXBlICYgTUZfU0VQQVJBVE9SKSkgcmV0dXJuOwoKICAgIGlmIChscGl0ZW0tPmZTdGF0ZSAmIE1GX0hJTElURSkKICAgIHsKICAgICAgICBpZiAoZmxhdF9tZW51KQogICAgICAgIHsKICAgICAgICAgICAgSW5mbGF0ZVJlY3QgKCZyZWN0LCAtMSwgLTEpOwogICAgICAgICAgICBGaWxsUmVjdChoZGMsICZyZWN0LCBHZXRTeXNDb2xvckJydXNoKENPTE9SX01FTlVISUxJR0hUKSk7CiAgICAgICAgICAgIEluZmxhdGVSZWN0ICgmcmVjdCwgMSwgMSk7CiAgICAgICAgICAgIEZyYW1lUmVjdChoZGMsICZyZWN0LCBHZXRTeXNDb2xvckJydXNoKENPTE9SX0hJR0hMSUdIVCkpOwogICAgICAgIH0KICAgICAgICBlbHNlCiAgICAgICAgewogICAgICAgICAgICBpZihtZW51QmFyKQogICAgICAgICAgICAgICAgRHJhd0VkZ2UoaGRjLCAmcmVjdCwgQkRSX1NVTktFTk9VVEVSLCBCRl9SRUNUKTsKICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgRmlsbFJlY3QoaGRjLCAmcmVjdCwgR2V0U3lzQ29sb3JCcnVzaChDT0xPUl9ISUdITElHSFQpKTsKICAgICAgICB9CiAgICB9CiAgICBlbHNlCiAgICAgICAgRmlsbFJlY3QoIGhkYywgJnJlY3QsIEdldFN5c0NvbG9yQnJ1c2goYmtnbmQpICk7CgogICAgU2V0QmtNb2RlKCBoZGMsIFRSQU5TUEFSRU5UICk7CgogICAgLyogdmVydGljYWwgc2VwYXJhdG9yICovCiAgICBpZiAoIW1lbnVCYXIgJiYgKGxwaXRlbS0+ZlR5cGUgJiBNRl9NRU5VQkFSQlJFQUspKQogICAgewogICAgICAgIEhQRU4gb2xkUGVuOwogICAgICAgIFJFQ1QgcmMgPSByZWN0OwoKICAgICAgICByYy5sZWZ0IC09IE1FTlVfQ09MX1NQQUNFIC8gMiArIDE7CiAgICAgICAgcmMudG9wID0gMzsKICAgICAgICByYy5ib3R0b20gPSBoZWlnaHQgLSAzOwogICAgICAgIGlmIChmbGF0X21lbnUpCiAgICAgICAgewogICAgICAgICAgICBvbGRQZW4gPSBTZWxlY3RPYmplY3QoIGhkYywgU1lTQ09MT1JfR2V0UGVuKENPTE9SX0JUTlNIQURPVykgKTsKICAgICAgICAgICAgTW92ZVRvRXgoIGhkYywgcmMubGVmdCwgcmMudG9wLCBOVUxMICk7CiAgICAgICAgICAgIExpbmVUbyggaGRjLCByYy5sZWZ0LCByYy5ib3R0b20gKTsKICAgICAgICAgICAgU2VsZWN0T2JqZWN0KCBoZGMsIG9sZFBlbiApOwogICAgICAgIH0KICAgICAgICBlbHNlCiAgICAgICAgICAgIERyYXdFZGdlIChoZGMsICZyYywgRURHRV9FVENIRUQsIEJGX0xFRlQpOwogICAgfQoKICAgIC8qIGhvcml6b250YWwgc2VwYXJhdG9yICovCiAgICBpZiAobHBpdGVtLT5mVHlwZSAmIE1GX1NFUEFSQVRPUikKICAgIHsKICAgICAgICBIUEVOIG9sZFBlbjsKICAgICAgICBSRUNUIHJjID0gcmVjdDsKCiAgICAgICAgcmMubGVmdCsrOwogICAgICAgIHJjLnJpZ2h0LS07CiAgICAgICAgcmMudG9wID0gKCByYy50b3AgKyByYy5ib3R0b20pIC8gMjsKICAgICAgICBpZiAoZmxhdF9tZW51KQogICAgICAgIHsKICAgICAgICAgICAgb2xkUGVuID0gU2VsZWN0T2JqZWN0KCBoZGMsIFNZU0NPTE9SX0dldFBlbihDT0xPUl9CVE5TSEFET1cpICk7CiAgICAgICAgICAgIE1vdmVUb0V4KCBoZGMsIHJjLmxlZnQsIHJjLnRvcCwgTlVMTCApOwogICAgICAgICAgICBMaW5lVG8oIGhkYywgcmMucmlnaHQsIHJjLnRvcCApOwogICAgICAgICAgICBTZWxlY3RPYmplY3QoIGhkYywgb2xkUGVuICk7CiAgICAgICAgfQogICAgICAgIGVsc2UKICAgICAgICAgICAgRHJhd0VkZ2UgKGhkYywgJnJjLCBFREdFX0VUQ0hFRCwgQkZfVE9QKTsKICAgICAgICByZXR1cm47CiAgICB9CgoJLyogaGVscGVyIGxpbmVzIGZvciBkZWJ1Z2dpbmcgKi8KLyoJRnJhbWVSZWN0KGhkYywgJnJlY3QsIEdldFN0b2NrT2JqZWN0KEJMQUNLX0JSVVNIKSk7CglTZWxlY3RPYmplY3QoIGhkYywgU1lTQ09MT1JfR2V0UGVuKENPTE9SX1dJTkRPV0ZSQU1FKSApOwoJTW92ZVRvRXgoIGhkYywgcmVjdC5sZWZ0LCAocmVjdC50b3AgKyByZWN0LmJvdHRvbSkvMiwgTlVMTCApOwoJTGluZVRvKCBoZGMsIHJlY3QucmlnaHQsIChyZWN0LnRvcCArIHJlY3QuYm90dG9tKS8yICk7CiovCgogICAgaWYgKGxwaXRlbS0+aGJtcEl0ZW0pIHsKICAgICAgICAvKiBjYWxjdWxhdGUgdGhlIGJpdG1hcCByZWN0YW5nbGUgaW4gY29vcmRpbmF0ZXMgcmVsYXRpdmUKICAgICAgICAgKiB0byB0aGUgaXRlbSByZWN0YW5nbGUgKi8KICAgICAgICBpZiggbWVudUJhcikgewogICAgICAgICAgICBpZiggbHBpdGVtLT5oYm1wSXRlbSA9PSBIQk1NRU5VX0NBTExCQUNLKQogICAgICAgICAgICAgICAgYm1wcmMubGVmdCA9IDM7CiAgICAgICAgICAgIGVsc2UgCiAgICAgICAgICAgICAgICBibXByYy5sZWZ0ID0gbHBpdGVtLT50ZXh0ID8gbWVudWNoYXJzaXplLmN4IDogMDsgICAgICAgICAgCiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgYm1wcmMubGVmdCA9IDQ7CiAgICAgICAgICAgIGlmKCAhKG1lbnUtPmR3U3R5bGUgJiAoIE1OU19DSEVDS09SQk1QIHwgTU5TX05PQ0hFQ0spKSkKICAgICAgICAgICAgICAgIGJtcHJjLmxlZnQgKz0gR2V0U3lzdGVtTWV0cmljcyggU01fQ1hNRU5VQ0hFQ0spOyAKICAgICAgICB9CiAgICAgICAgYm1wcmMucmlnaHQgPSAgYm1wcmMubGVmdCArIGxwaXRlbS0+Ym1wc2l6ZS5jeDsKICAgICAgICBpZiggbWVudUJhciAmJiAhKGxwaXRlbS0+aGJtcEl0ZW0gPT0gSEJNTUVOVV9DQUxMQkFDSykpCiAgICAgICAgICAgIGJtcHJjLnRvcCA9IDA7CiAgICAgICAgZWxzZQogICAgICAgICAgICBibXByYy50b3AgPSAobHBpdGVtLT5yZWN0LmJvdHRvbSAtIGxwaXRlbS0+cmVjdC50b3AgLQogICAgICAgICAgICAgICAgICAgIGxwaXRlbS0+Ym1wc2l6ZS5jeSkgLyAyOyAKICAgICAgICBibXByYy5ib3R0b20gPSAgYm1wcmMudG9wICsgbHBpdGVtLT5ibXBzaXplLmN5OwogICAgfQoKICAgIGlmICghbWVudUJhcikKICAgIHsKICAgICAgICBIQklUTUFQIGJtOwogICAgICAgIElOVCB5ID0gcmVjdC50b3AgKyByZWN0LmJvdHRvbTsKICAgICAgICBSRUNUIHJjID0gcmVjdDsKICAgICAgICBpbnQgY2hlY2tlZCA9IEZBTFNFOwogICAgICAgIFVJTlQgY2hlY2tfYml0bWFwX3dpZHRoID0gR2V0U3lzdGVtTWV0cmljcyggU01fQ1hNRU5VQ0hFQ0sgKTsKICAgICAgICBVSU5UIGNoZWNrX2JpdG1hcF9oZWlnaHQgPSBHZXRTeXN0ZW1NZXRyaWNzKCBTTV9DWU1FTlVDSEVDSyApOwogICAgICAgIC8qIERyYXcgdGhlIGNoZWNrIG1hcmsKICAgICAgICAgKgogICAgICAgICAqIEZJWE1FOgogICAgICAgICAqIEN1c3RvbSBjaGVja21hcmsgYml0bWFwcyBhcmUgbW9ub2Nocm9tZSBidXQgbm90IGFsd2F5cyAxYnBwLgogICAgICAgICAqLwogICAgICAgIGlmKCAhKG1lbnUtPmR3U3R5bGUgJiBNTlNfTk9DSEVDSykpIHsKICAgICAgICAgICAgYm0gPSAobHBpdGVtLT5mU3RhdGUgJiBNRl9DSEVDS0VEKSA/IGxwaXRlbS0+aENoZWNrQml0IDoKICAgICAgICAgICAgICAgIGxwaXRlbS0+aFVuQ2hlY2tCaXQ7CiAgICAgICAgICAgIGlmIChibSkgIC8qIHdlIGhhdmUgYSBjdXN0b20gYml0bWFwICovCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIEhEQyBoZGNNZW0gPSBDcmVhdGVDb21wYXRpYmxlREMoIGhkYyApOwoKICAgICAgICAgICAgICAgIFNlbGVjdE9iamVjdCggaGRjTWVtLCBibSApOwogICAgICAgICAgICAgICAgQml0Qmx0KCBoZGMsIHJjLmxlZnQsICh5IC0gY2hlY2tfYml0bWFwX2hlaWdodCkgLyAyLAogICAgICAgICAgICAgICAgICAgICAgICBjaGVja19iaXRtYXBfd2lkdGgsIGNoZWNrX2JpdG1hcF9oZWlnaHQsCiAgICAgICAgICAgICAgICAgICAgICAgIGhkY01lbSwgMCwgMCwgU1JDQ09QWSApOwogICAgICAgICAgICAgICAgRGVsZXRlREMoIGhkY01lbSApOwogICAgICAgICAgICAgICAgY2hlY2tlZCA9IFRSVUU7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgZWxzZSBpZiAobHBpdGVtLT5mU3RhdGUgJiBNRl9DSEVDS0VEKSAvKiBzdGFuZGFyZCBiaXRtYXBzICovCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIFJFQ1QgcjsKICAgICAgICAgICAgICAgIEhCSVRNQVAgYm0gPSBDcmVhdGVCaXRtYXAoIGNoZWNrX2JpdG1hcF93aWR0aCwKICAgICAgICAgICAgICAgICAgICAgICAgY2hlY2tfYml0bWFwX2hlaWdodCwgMSwgMSwgTlVMTCApOwogICAgICAgICAgICAgICAgSERDIGhkY01lbSA9IENyZWF0ZUNvbXBhdGlibGVEQyggaGRjICk7CgogICAgICAgICAgICAgICAgU2VsZWN0T2JqZWN0KCBoZGNNZW0sIGJtICk7CiAgICAgICAgICAgICAgICBTZXRSZWN0KCAmciwgMCwgMCwgY2hlY2tfYml0bWFwX3dpZHRoLCBjaGVja19iaXRtYXBfaGVpZ2h0KTsKICAgICAgICAgICAgICAgIERyYXdGcmFtZUNvbnRyb2woIGhkY01lbSwgJnIsIERGQ19NRU5VLAogICAgICAgICAgICAgICAgICAgICAgICAobHBpdGVtLT5mVHlwZSAmIE1GVF9SQURJT0NIRUNLKSA/CiAgICAgICAgICAgICAgICAgICAgICAgIERGQ1NfTUVOVUJVTExFVCA6IERGQ1NfTUVOVUNIRUNLICk7CiAgICAgICAgICAgICAgICBCaXRCbHQoIGhkYywgcmMubGVmdCwgKHkgLSByLmJvdHRvbSkgLyAyLCByLnJpZ2h0LCByLmJvdHRvbSwKICAgICAgICAgICAgICAgICAgICAgICAgaGRjTWVtLCAwLCAwLCBTUkNDT1BZICk7CiAgICAgICAgICAgICAgICBEZWxldGVEQyggaGRjTWVtICk7CiAgICAgICAgICAgICAgICBEZWxldGVPYmplY3QoIGJtICk7CiAgICAgICAgICAgICAgICBjaGVja2VkID0gVFJVRTsKICAgICAgICAgICAgfQogICAgICAgIH0KICAgICAgICBpZiggbHBpdGVtLT5oYm1wSXRlbSAmJgogICAgICAgICAgICAgICAgISggY2hlY2tlZCAmJiAobWVudS0+ZHdTdHlsZSAmIE1OU19DSEVDS09SQk1QKSkpIHsKICAgICAgICAgICAgUE9JTlQgb3JpZ29yZzsKICAgICAgICAgICAgLyogc29tZSBhcHBsaWNhdGlvbnMgbWFrZSB0aGlzIGFzc3VtcHRpb24gb24gdGhlIERDJ3Mgb3JpZ2luICovCiAgICAgICAgICAgIFNldFZpZXdwb3J0T3JnRXgoIGhkYywgbHBpdGVtLT5yZWN0LmxlZnQsIGxwaXRlbS0+cmVjdC50b3AsICZvcmlnb3JnKTsKICAgICAgICAgICAgTUVOVV9EcmF3Qml0bWFwSXRlbShoZGMsIGxwaXRlbSwgJmJtcHJjLCBobWVudSwgaHduZE93bmVyLAogICAgICAgICAgICAgICAgICAgIG9kYWN0aW9uLCBGQUxTRSk7CiAgICAgICAgICAgIFNldFZpZXdwb3J0T3JnRXgoIGhkYywgb3JpZ29yZy54LCBvcmlnb3JnLnksIE5VTEwpOwogICAgICAgIH0KCS8qIERyYXcgdGhlIHBvcHVwLW1lbnUgYXJyb3cgKi8KICAgICAgICBpZiAobHBpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKQogICAgICAgICAgICBkcmF3X3BvcHVwX2Fycm93KCBoZGMsIHJlY3QsIGFycm93X2JpdG1hcF93aWR0aCwKICAgICAgICAgICAgICAgICAgICBhcnJvd19iaXRtYXBfaGVpZ2h0KTsKCXJlY3QubGVmdCArPSA0OwogICAgICAgIGlmKCAhKG1lbnUtPmR3U3R5bGUgJiBNTlNfTk9DSEVDSykpCiAgICAgICAgICAgIHJlY3QubGVmdCArPSBjaGVja19iaXRtYXBfd2lkdGg7CglyZWN0LnJpZ2h0IC09IGFycm93X2JpdG1hcF93aWR0aDsKICAgIH0KICAgIGVsc2UgaWYoIGxwaXRlbS0+aGJtcEl0ZW0pCiAgICB7ICAgLyogRHJhdyB0aGUgYml0bWFwICovCiAgICAgICAgUE9JTlQgb3JpZ29yZzsKICAgICAgICAKICAgICAgICBTZXRWaWV3cG9ydE9yZ0V4KCBoZGMsIGxwaXRlbS0+cmVjdC5sZWZ0LCBscGl0ZW0tPnJlY3QudG9wLCAmb3JpZ29yZyk7CiAgICAgICAgTUVOVV9EcmF3Qml0bWFwSXRlbSggaGRjLCBscGl0ZW0sICZibXByYywgaG1lbnUsIGh3bmRPd25lciwKICAgICAgICAgICAgICAgIG9kYWN0aW9uLCBtZW51QmFyKTsKICAgICAgICBTZXRWaWV3cG9ydE9yZ0V4KCBoZGMsIG9yaWdvcmcueCwgb3JpZ29yZy55LCBOVUxMKTsKICAgIH0KICAgIC8qIHByb2Nlc3MgdGV4dCBpZiBwcmVzZW50ICovCiAgICBpZiAobHBpdGVtLT50ZXh0KQogICAgewoJcmVnaXN0ZXIgaW50IGk7CglIRk9OVCBoZm9udE9sZCA9IDA7CgoJVUlOVCB1Rm9ybWF0ID0gKG1lbnVCYXIpID8KCQkJRFRfQ0VOVEVSIHwgRFRfVkNFTlRFUiB8IERUX1NJTkdMRUxJTkUgOgoJCQlEVF9MRUZUIHwgRFRfVkNFTlRFUiB8IERUX1NJTkdMRUxJTkU7CgogICAgICAgIGlmKCAhKG1lbnUtPmR3U3R5bGUgJiBNTlNfQ0hFQ0tPUkJNUCkpCiAgICAgICAgICAgIHJlY3QubGVmdCArPSBtZW51LT5tYXhCbXBTaXplLmN4OwoKCWlmICggbHBpdGVtLT5mU3RhdGUgJiBNRlNfREVGQVVMVCApCgl7CgkgICAgIGhmb250T2xkID0gU2VsZWN0T2JqZWN0KCBoZGMsIGdldF9tZW51X2ZvbnQoVFJVRSkgKTsKCX0KCglpZiAobWVudUJhcikgewogICAgICAgICAgICBpZiggbHBpdGVtLT5oYm1wSXRlbSkKICAgICAgICAgICAgICAgIHJlY3QubGVmdCArPSBscGl0ZW0tPmJtcHNpemUuY3g7CiAgICAgICAgICAgIGlmKCAhKGxwaXRlbS0+aGJtcEl0ZW0gPT0gSEJNTUVOVV9DQUxMQkFDSykpCiAgICAgICAgICAgICAgICByZWN0LmxlZnQgKz0gbWVudWNoYXJzaXplLmN4OwogICAgICAgICAgICByZWN0LnJpZ2h0IC09IG1lbnVjaGFyc2l6ZS5jeDsKCX0KCglmb3IgKGkgPSAwOyBscGl0ZW0tPnRleHRbaV07IGkrKykKCSAgICBpZiAoKGxwaXRlbS0+dGV4dFtpXSA9PSAnXHQnKSB8fCAobHBpdGVtLT50ZXh0W2ldID09ICdcYicpKQoJICAgICAgICBicmVhazsKCglpZihscGl0ZW0tPmZTdGF0ZSAmIE1GX0dSQVlFRCkKCXsKCSAgICBpZiAoIShscGl0ZW0tPmZTdGF0ZSAmIE1GX0hJTElURSkgKQoJICAgIHsKCQkrK3JlY3QubGVmdDsgKytyZWN0LnRvcDsgKytyZWN0LnJpZ2h0OyArK3JlY3QuYm90dG9tOwoJCVNldFRleHRDb2xvcihoZGMsIFJHQigweGZmLCAweGZmLCAweGZmKSk7CgkJRHJhd1RleHRXKCBoZGMsIGxwaXRlbS0+dGV4dCwgaSwgJnJlY3QsIHVGb3JtYXQgKTsKCQktLXJlY3QubGVmdDsgLS1yZWN0LnRvcDsgLS1yZWN0LnJpZ2h0OyAtLXJlY3QuYm90dG9tOwoJICAgIH0KCSAgICBTZXRUZXh0Q29sb3IoaGRjLCBSR0IoMHg4MCwgMHg4MCwgMHg4MCkpOwoJfQoKCURyYXdUZXh0VyggaGRjLCBscGl0ZW0tPnRleHQsIGksICZyZWN0LCB1Rm9ybWF0KTsKCgkvKiBwYWludCB0aGUgc2hvcnRjdXQgdGV4dCAqLwoJaWYgKCFtZW51QmFyICYmIGxwaXRlbS0+dGV4dFtpXSkgIC8qIFRoZXJlJ3MgYSB0YWIgb3IgZmx1c2gtcmlnaHQgY2hhciAqLwoJewoJICAgIGlmIChscGl0ZW0tPnRleHRbaV0gPT0gJ1x0JykKCSAgICB7CgkJcmVjdC5sZWZ0ID0gbHBpdGVtLT54VGFiOwoJCXVGb3JtYXQgPSBEVF9MRUZUIHwgRFRfVkNFTlRFUiB8IERUX1NJTkdMRUxJTkU7CgkgICAgfQoJICAgIGVsc2UKCSAgICB7CgkJcmVjdC5yaWdodCA9IGxwaXRlbS0+eFRhYjsKCQl1Rm9ybWF0ID0gRFRfUklHSFQgfCBEVF9WQ0VOVEVSIHwgRFRfU0lOR0xFTElORTsKCSAgICB9CgoJICAgIGlmKGxwaXRlbS0+ZlN0YXRlICYgTUZfR1JBWUVEKQoJICAgIHsKCQlpZiAoIShscGl0ZW0tPmZTdGF0ZSAmIE1GX0hJTElURSkgKQoJCXsKCQkgICAgKytyZWN0LmxlZnQ7ICsrcmVjdC50b3A7ICsrcmVjdC5yaWdodDsgKytyZWN0LmJvdHRvbTsKCQkgICAgU2V0VGV4dENvbG9yKGhkYywgUkdCKDB4ZmYsIDB4ZmYsIDB4ZmYpKTsKCQkgICAgRHJhd1RleHRXKCBoZGMsIGxwaXRlbS0+dGV4dCArIGkgKyAxLCAtMSwgJnJlY3QsIHVGb3JtYXQgKTsKCQkgICAgLS1yZWN0LmxlZnQ7IC0tcmVjdC50b3A7IC0tcmVjdC5yaWdodDsgLS1yZWN0LmJvdHRvbTsKCQl9CgkJU2V0VGV4dENvbG9yKGhkYywgUkdCKDB4ODAsIDB4ODAsIDB4ODApKTsKCSAgICB9CgkgICAgRHJhd1RleHRXKCBoZGMsIGxwaXRlbS0+dGV4dCArIGkgKyAxLCAtMSwgJnJlY3QsIHVGb3JtYXQgKTsKCX0KCglpZiAoaGZvbnRPbGQpCgkgICAgU2VsZWN0T2JqZWN0IChoZGMsIGhmb250T2xkKTsKICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9EcmF3UG9wdXBNZW51CiAqCiAqIFBhaW50IGEgcG9wdXAgbWVudS4KICovCnN0YXRpYyB2b2lkIE1FTlVfRHJhd1BvcHVwTWVudSggSFdORCBod25kLCBIREMgaGRjLCBITUVOVSBobWVudSApCnsKICAgIEhCUlVTSCBoUHJldkJydXNoID0gMDsKICAgIFJFQ1QgcmVjdDsKCiAgICBUUkFDRSgid25kPSVwIGRjPSVwIG1lbnU9JXBcbiIsIGh3bmQsIGhkYywgaG1lbnUpOwoKICAgIEdldENsaWVudFJlY3QoIGh3bmQsICZyZWN0ICk7CgogICAgaWYoKGhQcmV2QnJ1c2ggPSBTZWxlY3RPYmplY3QoIGhkYywgR2V0U3lzQ29sb3JCcnVzaChDT0xPUl9NRU5VKSApKQogICAgICAgICYmIChTZWxlY3RPYmplY3QoIGhkYywgZ2V0X21lbnVfZm9udChGQUxTRSkpKSkKICAgIHsKCUhQRU4gaFByZXZQZW47CgoJUmVjdGFuZ2xlKCBoZGMsIHJlY3QubGVmdCwgcmVjdC50b3AsIHJlY3QucmlnaHQsIHJlY3QuYm90dG9tICk7CgoJaFByZXZQZW4gPSBTZWxlY3RPYmplY3QoIGhkYywgR2V0U3RvY2tPYmplY3QoIE5VTExfUEVOICkgKTsKCWlmKCBoUHJldlBlbiApCgl7CgkgICAgUE9QVVBNRU5VICptZW51OwoJICAgIEJPT0wgZmxhdF9tZW51ID0gRkFMU0U7CgoJICAgIFN5c3RlbVBhcmFtZXRlcnNJbmZvVyAoU1BJX0dFVEZMQVRNRU5VLCAwLCAmZmxhdF9tZW51LCAwKTsKCSAgICBpZiAoZmxhdF9tZW51KQoJCUZyYW1lUmVjdChoZGMsICZyZWN0LCBHZXRTeXNDb2xvckJydXNoKENPTE9SX0JUTlNIQURPVykpOwoJICAgIGVsc2UKCQlEcmF3RWRnZSAoaGRjLCAmcmVjdCwgRURHRV9SQUlTRUQsIEJGX1JFQ1QpOwoKICAgICAgICAgICAgaWYoIChtZW51ID0gTUVOVV9HZXRNZW51KCBobWVudSApKSkKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgLyogZHJhdyBtZW51IGl0ZW1zICovCiAgICAgICAgICAgICAgICBpZiggbWVudS0+bkl0ZW1zKQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIE1FTlVJVEVNICppdGVtOwogICAgICAgICAgICAgICAgICAgIFVJTlQgdTsKCiAgICAgICAgICAgICAgICAgICAgaXRlbSA9IG1lbnUtPml0ZW1zOwogICAgICAgICAgICAgICAgICAgIGZvciggdSA9IG1lbnUtPm5JdGVtczsgdSA+IDA7IHUtLSwgaXRlbSsrKQogICAgICAgICAgICAgICAgICAgICAgICBNRU5VX0RyYXdNZW51SXRlbSggaHduZCwgaG1lbnUsIG1lbnUtPmh3bmRPd25lciwgaGRjLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGl0ZW0sIG1lbnUtPkhlaWdodCwgRkFMU0UsIE9EQV9EUkFXRU5USVJFICk7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAvKiBkcmF3IHNjcm9sbCBhcnJvd3MgKi8KICAgICAgICAgICAgICAgIGlmIChtZW51LT5iU2Nyb2xsaW5nKQogICAgICAgICAgICAgICAgICAgIE1FTlVfRHJhd1Njcm9sbEFycm93cyhtZW51LCBoZGMpOwogICAgICAgICAgICB9CiAJfSBlbHNlCgl7CgkgICAgU2VsZWN0T2JqZWN0KCBoZGMsIGhQcmV2QnJ1c2ggKTsKCX0KICAgIH0KfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0RyYXdNZW51QmFyCiAqCiAqIFBhaW50IGEgbWVudSBiYXIuIFJldHVybnMgdGhlIGhlaWdodCBvZiB0aGUgbWVudSBiYXIuCiAqIGNhbGxlZCBmcm9tIFt3aW5kb3dzL25vbmNsaWVudC5jXQogKi8KVUlOVCBNRU5VX0RyYXdNZW51QmFyKCBIREMgaERDLCBMUFJFQ1QgbHByZWN0LCBIV05EIGh3bmQsCiAgICAgICAgICAgICAgICAgICAgICAgICBCT09MIHN1cHByZXNzX2RyYXcpCnsKICAgIExQUE9QVVBNRU5VIGxwcG9wOwogICAgSEZPTlQgaGZvbnRPbGQgPSAwOwogICAgSE1FTlUgaE1lbnUgPSBHZXRNZW51KGh3bmQpOwoKICAgIGxwcG9wID0gTUVOVV9HZXRNZW51KCBoTWVudSApOwogICAgaWYgKGxwcG9wID09IE5VTEwgfHwgbHByZWN0ID09IE5VTEwpCiAgICB7CiAgICAgICAgcmV0dXJuIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lNRU5VKTsKICAgIH0KCiAgICBpZiAoc3VwcHJlc3NfZHJhdykKICAgIHsKCWhmb250T2xkID0gU2VsZWN0T2JqZWN0KCBoREMsIGdldF9tZW51X2ZvbnQoRkFMU0UpKTsKCglpZiAobHBwb3AtPkhlaWdodCA9PSAwKQoJCU1FTlVfTWVudUJhckNhbGNTaXplKGhEQywgbHByZWN0LCBscHBvcCwgaHduZCk7CgoJbHByZWN0LT5ib3R0b20gPSBscHJlY3QtPnRvcCArIGxwcG9wLT5IZWlnaHQ7CgogICAgICAgIGlmIChoZm9udE9sZCkgU2VsZWN0T2JqZWN0KCBoREMsIGhmb250T2xkKTsKCXJldHVybiBscHBvcC0+SGVpZ2h0OwogICAgfQogICAgZWxzZQogICAgICAgIHJldHVybiBEcmF3TWVudUJhclRlbXAoaHduZCwgaERDLCBscHJlY3QsIGhNZW51LCBOVUxMKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9TaG93UG9wdXAKICoKICogRGlzcGxheSBhIHBvcHVwIG1lbnUuCiAqLwpzdGF0aWMgQk9PTCBNRU5VX1Nob3dQb3B1cCggSFdORCBod25kT3duZXIsIEhNRU5VIGhtZW51LCBVSU5UIGlkLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBJTlQgeCwgSU5UIHksIElOVCB4YW5jaG9yLCBJTlQgeWFuY2hvciApCnsKICAgIFBPUFVQTUVOVSAqbWVudTsKICAgIElOVCB3aWR0aCwgaGVpZ2h0OwogICAgUE9JTlQgcHQ7CiAgICBITU9OSVRPUiBtb25pdG9yOwogICAgTU9OSVRPUklORk8gaW5mbzsKCiAgICBUUkFDRSgib3duZXI9JXAgaG1lbnU9JXAgaWQ9MHglMDR4IHg9MHglMDR4IHk9MHglMDR4IHhhPTB4JTA0eCB5YT0weCUwNHhcbiIsCiAgICAgICAgICBod25kT3duZXIsIGhtZW51LCBpZCwgeCwgeSwgeGFuY2hvciwgeWFuY2hvcik7CgogICAgaWYgKCEobWVudSA9IE1FTlVfR2V0TWVudSggaG1lbnUgKSkpIHJldHVybiBGQUxTRTsKICAgIGlmIChtZW51LT5Gb2N1c2VkSXRlbSAhPSBOT19TRUxFQ1RFRF9JVEVNKQogICAgewoJbWVudS0+aXRlbXNbbWVudS0+Rm9jdXNlZEl0ZW1dLmZTdGF0ZSAmPSB+KE1GX0hJTElURXxNRl9NT1VTRVNFTEVDVCk7CgltZW51LT5Gb2N1c2VkSXRlbSA9IE5PX1NFTEVDVEVEX0lURU07CiAgICB9CgogICAgLyogc3RvcmUgdGhlIG93bmVyIGZvciBEcmF3SXRlbSAqLwogICAgbWVudS0+aHduZE93bmVyID0gaHduZE93bmVyOwoKICAgIG1lbnUtPm5TY3JvbGxQb3MgPSAwOwogICAgTUVOVV9Qb3B1cE1lbnVDYWxjU2l6ZSggbWVudSwgaHduZE93bmVyICk7CgogICAgLyogYWRqdXN0IHBvcHVwIG1lbnUgcG9zIHNvIHRoYXQgaXQgZml0cyB3aXRoaW4gdGhlIGRlc2t0b3AgKi8KCiAgICB3aWR0aCA9IG1lbnUtPldpZHRoICsgR2V0U3lzdGVtTWV0cmljcyhTTV9DWEJPUkRFUik7CiAgICBoZWlnaHQgPSBtZW51LT5IZWlnaHQgKyBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZQk9SREVSKTsKCiAgICAvKiBGSVhNRTogc2hvdWxkIHVzZSBpdGVtIHJlY3QgKi8KICAgIHB0LnggPSB4OwogICAgcHQueSA9IHk7CiAgICBtb25pdG9yID0gTW9uaXRvckZyb21Qb2ludCggcHQsIE1PTklUT1JfREVGQVVMVFRPTkVBUkVTVCApOwogICAgaW5mby5jYlNpemUgPSBzaXplb2YoaW5mbyk7CiAgICBHZXRNb25pdG9ySW5mb1coIG1vbml0b3IsICZpbmZvICk7CiAgICBpZiggeCArIHdpZHRoID4gaW5mby5yY1dvcmsucmlnaHQpCiAgICB7CiAgICAgICAgaWYoIHhhbmNob3IgJiYgeCA+PSB3aWR0aCAtIHhhbmNob3IgKQogICAgICAgICAgICB4IC09IHdpZHRoIC0geGFuY2hvcjsKCiAgICAgICAgaWYoIHggKyB3aWR0aCA+IGluZm8ucmNXb3JrLnJpZ2h0KQogICAgICAgICAgICB4ID0gaW5mby5yY1dvcmsucmlnaHQgLSB3aWR0aDsKICAgIH0KICAgIGlmKCB4IDwgaW5mby5yY1dvcmsubGVmdCApIHggPSBpbmZvLnJjV29yay5sZWZ0OwoKICAgIGlmKCB5ICsgaGVpZ2h0ID4gaW5mby5yY1dvcmsuYm90dG9tKQogICAgewogICAgICAgIGlmKCB5YW5jaG9yICYmIHkgPj0gaGVpZ2h0ICsgeWFuY2hvciApCiAgICAgICAgICAgIHkgLT0gaGVpZ2h0ICsgeWFuY2hvcjsKCiAgICAgICAgaWYoIHkgKyBoZWlnaHQgPiBpbmZvLnJjV29yay5ib3R0b20pCiAgICAgICAgICAgIHkgPSBpbmZvLnJjV29yay5ib3R0b20gLSBoZWlnaHQ7CiAgICB9CiAgICBpZiggeSA8IGluZm8ucmNXb3JrLnRvcCApIHkgPSBpbmZvLnJjV29yay50b3A7CgogICAgLyogTk9URTogSW4gV2luZG93cywgdG9wIG1lbnUgcG9wdXAgaXMgbm90IG93bmVkLiAqLwogICAgbWVudS0+aFduZCA9IENyZWF0ZVdpbmRvd0V4VyggMCwgKExQQ1dTVFIpUE9QVVBNRU5VX0NMQVNTX0FUT00sIE5VTEwsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgV1NfUE9QVVAsIHgsIHksIHdpZHRoLCBoZWlnaHQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaHduZE93bmVyLCAwLCAoSElOU1RBTkNFKUdldFdpbmRvd0xvbmdQdHJXKGh3bmRPd25lciwgR1dMUF9ISU5TVEFOQ0UpLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChMUFZPSUQpaG1lbnUgKTsKICAgIGlmKCAhbWVudS0+aFduZCApIHJldHVybiBGQUxTRTsKICAgIGlmICghdG9wX3BvcHVwKSB0b3BfcG9wdXAgPSBtZW51LT5oV25kOwoKICAgIC8qIERpc3BsYXkgdGhlIHdpbmRvdyAqLwoKICAgIFNldFdpbmRvd1BvcyggbWVudS0+aFduZCwgSFdORF9UT1AsIDAsIDAsIDAsIDAsCiAgICAgICAgICAgICAgICAgIFNXUF9TSE9XV0lORE9XIHwgU1dQX05PU0laRSB8IFNXUF9OT01PVkUgfCBTV1BfTk9BQ1RJVkFURSApOwogICAgVXBkYXRlV2luZG93KCBtZW51LT5oV25kICk7CiAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9FbnN1cmVNZW51SXRlbVZpc2libGUKICovCnN0YXRpYyB2b2lkCk1FTlVfRW5zdXJlTWVudUl0ZW1WaXNpYmxlKExQUE9QVVBNRU5VIGxwcG9wLCBVSU5UIHdJbmRleCwgSERDIGhkYykKewogICAgaWYgKGxwcG9wLT5iU2Nyb2xsaW5nKQogICAgewogICAgICAgIE1FTlVJVEVNICppdGVtID0gJmxwcG9wLT5pdGVtc1t3SW5kZXhdOwogICAgICAgIFVJTlQgbk1heEhlaWdodCA9IE1FTlVfR2V0TWF4UG9wdXBIZWlnaHQobHBwb3ApOwogICAgICAgIFVJTlQgbk9sZFBvcyA9IGxwcG9wLT5uU2Nyb2xsUG9zOwogICAgICAgIFJFQ1QgcmM7CiAgICAgICAgVUlOVCBhcnJvd19iaXRtYXBfaGVpZ2h0OwogICAgICAgIEJJVE1BUCBibXA7CiAgICAgICAgCiAgICAgICAgR2V0Q2xpZW50UmVjdChscHBvcC0+aFduZCwgJnJjKTsKCiAgICAgICAgR2V0T2JqZWN0VyhnZXRfZG93bl9hcnJvd19iaXRtYXAoKSwgc2l6ZW9mKGJtcCksICZibXApOwogICAgICAgIGFycm93X2JpdG1hcF9oZWlnaHQgPSBibXAuYm1IZWlnaHQ7CgogICAgICAgIHJjLnRvcCArPSBhcnJvd19iaXRtYXBfaGVpZ2h0OwogICAgICAgIHJjLmJvdHRvbSAtPSBhcnJvd19iaXRtYXBfaGVpZ2h0ICsgTUVOVV9CT1RUT01fTUFSR0lOOwogICAgICAgCiAgICAgICAgbk1heEhlaWdodCAtPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZQk9SREVSKSArIDIgKiBhcnJvd19iaXRtYXBfaGVpZ2h0OwogICAgICAgIGlmIChpdGVtLT5yZWN0LmJvdHRvbSA+IGxwcG9wLT5uU2Nyb2xsUG9zICsgbk1heEhlaWdodCkKICAgICAgICB7CiAgICAgICAgICAgIAogICAgICAgICAgICBscHBvcC0+blNjcm9sbFBvcyA9IGl0ZW0tPnJlY3QuYm90dG9tIC0gbk1heEhlaWdodDsKICAgICAgICAgICAgU2Nyb2xsV2luZG93KGxwcG9wLT5oV25kLCAwLCBuT2xkUG9zIC0gbHBwb3AtPm5TY3JvbGxQb3MsICZyYywgJnJjKTsKICAgICAgICAgICAgTUVOVV9EcmF3U2Nyb2xsQXJyb3dzKGxwcG9wLCBoZGMpOwogICAgICAgIH0KICAgICAgICBlbHNlIGlmIChpdGVtLT5yZWN0LnRvcCAtIE1FTlVfVE9QX01BUkdJTiA8IGxwcG9wLT5uU2Nyb2xsUG9zKQogICAgICAgIHsKICAgICAgICAgICAgbHBwb3AtPm5TY3JvbGxQb3MgPSBpdGVtLT5yZWN0LnRvcCAtIE1FTlVfVE9QX01BUkdJTjsKICAgICAgICAgICAgU2Nyb2xsV2luZG93KGxwcG9wLT5oV25kLCAwLCBuT2xkUG9zIC0gbHBwb3AtPm5TY3JvbGxQb3MsICZyYywgJnJjKTsKICAgICAgICAgICAgTUVOVV9EcmF3U2Nyb2xsQXJyb3dzKGxwcG9wLCBoZGMpOwogICAgICAgIH0KICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9TZWxlY3RJdGVtCiAqLwpzdGF0aWMgdm9pZCBNRU5VX1NlbGVjdEl0ZW0oIEhXTkQgaHduZE93bmVyLCBITUVOVSBobWVudSwgVUlOVCB3SW5kZXgsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQk9PTCBzZW5kTWVudVNlbGVjdCwgSE1FTlUgdG9wbWVudSApCnsKICAgIExQUE9QVVBNRU5VIGxwcG9wOwogICAgSERDIGhkYzsKCiAgICBUUkFDRSgib3duZXI9JXAgbWVudT0lcCBpbmRleD0weCUwNHggc2VsZWN0PTB4JTA0eFxuIiwgaHduZE93bmVyLCBobWVudSwgd0luZGV4LCBzZW5kTWVudVNlbGVjdCk7CgogICAgbHBwb3AgPSBNRU5VX0dldE1lbnUoIGhtZW51ICk7CiAgICBpZiAoKCFscHBvcCkgfHwgKCFscHBvcC0+bkl0ZW1zKSB8fCAoIWxwcG9wLT5oV25kKSkgcmV0dXJuOwoKICAgIGlmIChscHBvcC0+Rm9jdXNlZEl0ZW0gPT0gd0luZGV4KSByZXR1cm47CiAgICBpZiAobHBwb3AtPndGbGFncyAmIE1GX1BPUFVQKSBoZGMgPSBHZXREQyggbHBwb3AtPmhXbmQgKTsKICAgIGVsc2UgaGRjID0gR2V0RENFeCggbHBwb3AtPmhXbmQsIDAsIERDWF9DQUNIRSB8IERDWF9XSU5ET1cpOwogICAgaWYgKCF0b3BfcG9wdXApIHRvcF9wb3B1cCA9IGxwcG9wLT5oV25kOwoKICAgIFNlbGVjdE9iamVjdCggaGRjLCBnZXRfbWVudV9mb250KEZBTFNFKSk7CgogICAgICAvKiBDbGVhciBwcmV2aW91cyBoaWdobGlnaHRlZCBpdGVtICovCiAgICBpZiAobHBwb3AtPkZvY3VzZWRJdGVtICE9IE5PX1NFTEVDVEVEX0lURU0pCiAgICB7CglscHBvcC0+aXRlbXNbbHBwb3AtPkZvY3VzZWRJdGVtXS5mU3RhdGUgJj0gfihNRl9ISUxJVEV8TUZfTU9VU0VTRUxFQ1QpOwoJTUVOVV9EcmF3TWVudUl0ZW0obHBwb3AtPmhXbmQsIGhtZW51LCBod25kT3duZXIsIGhkYywmbHBwb3AtPml0ZW1zW2xwcG9wLT5Gb2N1c2VkSXRlbV0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgbHBwb3AtPkhlaWdodCwgIShscHBvcC0+d0ZsYWdzICYgTUZfUE9QVVApLAoJCQkgIE9EQV9TRUxFQ1QgKTsKICAgIH0KCiAgICAgIC8qIEhpZ2hsaWdodCBuZXcgaXRlbSAoaWYgYW55KSAqLwogICAgbHBwb3AtPkZvY3VzZWRJdGVtID0gd0luZGV4OwogICAgaWYgKGxwcG9wLT5Gb2N1c2VkSXRlbSAhPSBOT19TRUxFQ1RFRF9JVEVNKQogICAgewogICAgICAgIGlmKCEobHBwb3AtPml0ZW1zW3dJbmRleF0uZlR5cGUgJiBNRl9TRVBBUkFUT1IpKSB7CiAgICAgICAgICAgIGxwcG9wLT5pdGVtc1t3SW5kZXhdLmZTdGF0ZSB8PSBNRl9ISUxJVEU7CiAgICAgICAgICAgIE1FTlVfRW5zdXJlTWVudUl0ZW1WaXNpYmxlKGxwcG9wLCB3SW5kZXgsIGhkYyk7CiAgICAgICAgICAgIE1FTlVfRHJhd01lbnVJdGVtKCBscHBvcC0+aFduZCwgaG1lbnUsIGh3bmRPd25lciwgaGRjLAogICAgICAgICAgICAgICAgICAgICZscHBvcC0+aXRlbXNbd0luZGV4XSwgbHBwb3AtPkhlaWdodCwKICAgICAgICAgICAgICAgICAgICAhKGxwcG9wLT53RmxhZ3MgJiBNRl9QT1BVUCksIE9EQV9TRUxFQ1QgKTsKICAgICAgICB9CiAgICAgICAgaWYgKHNlbmRNZW51U2VsZWN0KQogICAgICAgIHsKICAgICAgICAgICAgTUVOVUlURU0gKmlwID0gJmxwcG9wLT5pdGVtc1tscHBvcC0+Rm9jdXNlZEl0ZW1dOwoJICAgIFNlbmRNZXNzYWdlVyggaHduZE93bmVyLCBXTV9NRU5VU0VMRUNULAogICAgICAgICAgICAgICAgICAgICBNQUtFTE9ORyhpcC0+ZlR5cGUgJiBNRl9QT1BVUCA/IHdJbmRleDogaXAtPndJRCwKICAgICAgICAgICAgICAgICAgICAgaXAtPmZUeXBlIHwgaXAtPmZTdGF0ZSB8CiAgICAgICAgICAgICAgICAgICAgIChscHBvcC0+d0ZsYWdzICYgTUZfU1lTTUVOVSkpLCAoTFBBUkFNKWhtZW51KTsKICAgICAgICB9CiAgICB9CiAgICBlbHNlIGlmIChzZW5kTWVudVNlbGVjdCkgewogICAgICAgIGlmKHRvcG1lbnUpewogICAgICAgICAgICBpbnQgcG9zOwogICAgICAgICAgICBpZigocG9zPU1FTlVfRmluZFN1Yk1lbnUoJnRvcG1lbnUsIGhtZW51KSkhPU5PX1NFTEVDVEVEX0lURU0pewogICAgICAgICAgICAgICAgUE9QVVBNRU5VICpwdG0gPSBNRU5VX0dldE1lbnUoIHRvcG1lbnUgKTsKICAgICAgICAgICAgICAgIE1FTlVJVEVNICppcCA9ICZwdG0tPml0ZW1zW3Bvc107CiAgICAgICAgICAgICAgICBTZW5kTWVzc2FnZVcoIGh3bmRPd25lciwgV01fTUVOVVNFTEVDVCwgTUFLRUxPTkcocG9zLAogICAgICAgICAgICAgICAgICAgICAgICAgaXAtPmZUeXBlIHwgaXAtPmZTdGF0ZSB8CiAgICAgICAgICAgICAgICAgICAgICAgICAocHRtLT53RmxhZ3MgJiBNRl9TWVNNRU5VKSksIChMUEFSQU0pdG9wbWVudSk7CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICB9CiAgICBSZWxlYXNlREMoIGxwcG9wLT5oV25kLCBoZGMgKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9Nb3ZlU2VsZWN0aW9uCiAqCiAqIE1vdmVzIGN1cnJlbnRseSBzZWxlY3RlZCBpdGVtIGFjY29yZGluZyB0byB0aGUgb2Zmc2V0IHBhcmFtZXRlci4KICogSWYgdGhlcmUgaXMgbm8gc2VsZWN0aW9uIHRoZW4gaXQgc2hvdWxkIHNlbGVjdCB0aGUgbGFzdCBpdGVtIGlmCiAqIG9mZnNldCBpcyBJVEVNX1BSRVYgb3IgdGhlIGZpcnN0IGl0ZW0gaWYgb2Zmc2V0IGlzIElURU1fTkVYVC4KICovCnN0YXRpYyB2b2lkIE1FTlVfTW92ZVNlbGVjdGlvbiggSFdORCBod25kT3duZXIsIEhNRU5VIGhtZW51LCBJTlQgb2Zmc2V0ICkKewogICAgSU5UIGk7CiAgICBQT1BVUE1FTlUgKm1lbnU7CgogICAgVFJBQ0UoImh3bmQ9JXAgaG1lbnU9JXAgb2ZmPTB4JTA0eFxuIiwgaHduZE93bmVyLCBobWVudSwgb2Zmc2V0KTsKCiAgICBtZW51ID0gTUVOVV9HZXRNZW51KCBobWVudSApOwogICAgaWYgKCghbWVudSkgfHwgKCFtZW51LT5pdGVtcykpIHJldHVybjsKCiAgICBpZiAoIG1lbnUtPkZvY3VzZWRJdGVtICE9IE5PX1NFTEVDVEVEX0lURU0gKQogICAgewoJaWYoIG1lbnUtPm5JdGVtcyA9PSAxICkgcmV0dXJuOyBlbHNlCglmb3IgKGkgPSBtZW51LT5Gb2N1c2VkSXRlbSArIG9mZnNldCA7IGkgPj0gMCAmJiBpIDwgbWVudS0+bkl0ZW1zCgkJCQkJICAgIDsgaSArPSBvZmZzZXQpCgkgICAgaWYgKCEobWVudS0+aXRlbXNbaV0uZlR5cGUgJiBNRl9TRVBBUkFUT1IpKQoJICAgIHsKCQlNRU5VX1NlbGVjdEl0ZW0oIGh3bmRPd25lciwgaG1lbnUsIGksIFRSVUUsIDAgKTsKCQlyZXR1cm47CgkgICAgfQogICAgfQoKICAgIGZvciAoIGkgPSAob2Zmc2V0ID4gMCkgPyAwIDogbWVudS0+bkl0ZW1zIC0gMTsKCQkgIGkgPj0gMCAmJiBpIDwgbWVudS0+bkl0ZW1zIDsgaSArPSBvZmZzZXQpCglpZiAoIShtZW51LT5pdGVtc1tpXS5mVHlwZSAmIE1GX1NFUEFSQVRPUikpCgl7CgkgICAgTUVOVV9TZWxlY3RJdGVtKCBod25kT3duZXIsIGhtZW51LCBpLCBUUlVFLCAwICk7CgkgICAgcmV0dXJuOwoJfQp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBNRU5VX1NldEl0ZW1EYXRhCiAqCiAqIFNldCBhbiBpdGVtJ3MgZmxhZ3MsIGlkIGFuZCB0ZXh0IHB0ci4gQ2FsbGVkIGJ5IEluc2VydE1lbnUoKSBhbmQKICogTW9kaWZ5TWVudSgpLgogKi8Kc3RhdGljIEJPT0wgTUVOVV9TZXRJdGVtRGF0YSggTUVOVUlURU0gKml0ZW0sIFVJTlQgZmxhZ3MsIFVJTlRfUFRSIGlkLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIExQQ1dTVFIgc3RyICkKewogICAgZGVidWdfcHJpbnRfbWVudWl0ZW0oIk1FTlVfU2V0SXRlbURhdGEgZnJvbTogIiwgaXRlbSwgIiIpOwogICAgVFJBQ0UoImZsYWdzPSV4IHN0cj0lcFxuIiwgZmxhZ3MsIHN0cik7CgogICAgaWYgKElTX1NUUklOR19JVEVNKGZsYWdzKSkKICAgIHsKICAgICAgICBMUFdTVFIgcHJldlRleHQgPSBpdGVtLT50ZXh0OwogICAgICAgIGlmICghc3RyKQogICAgICAgIHsKICAgICAgICAgICAgZmxhZ3MgfD0gTUZfU0VQQVJBVE9SOwogICAgICAgICAgICBpdGVtLT50ZXh0ID0gTlVMTDsKICAgICAgICB9CiAgICAgICAgZWxzZQogICAgICAgIHsKICAgICAgICAgICAgTFBXU1RSIHRleHQ7CiAgICAgICAgICAgIC8qIEl0ZW0gYmVnaW5uaW5nIHdpdGggYSBiYWNrc3BhY2UgaXMgYSBoZWxwIGl0ZW0gKi8KICAgICAgICAgICAgaWYgKCpzdHIgPT0gJ1xiJykKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgZmxhZ3MgfD0gTUZfSEVMUDsKICAgICAgICAgICAgICAgIHN0cisrOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGlmICghKHRleHQgPSBIZWFwQWxsb2MoIEdldFByb2Nlc3NIZWFwKCksIDAsIChzdHJsZW5XKHN0cikrMSkgKiBzaXplb2YoV0NIQVIpICkpKQogICAgICAgICAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgICAgICAgICBzdHJjcHlXKCB0ZXh0LCBzdHIgKTsKICAgICAgICAgICAgaXRlbS0+dGV4dCA9IHRleHQ7CiAgICAgICAgfQogICAgICAgIGl0ZW0tPmhibXBJdGVtID0gTlVMTDsKICAgICAgICBIZWFwRnJlZSggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgcHJldlRleHQgKTsKICAgIH0KICAgIGVsc2UgaWYoKCBmbGFncyAmIE1GVF9CSVRNQVApKSB7CiAgICAgICAgaXRlbS0+aGJtcEl0ZW0gPSBIQklUTUFQXzMyKExPV09SRChzdHIpKTsKICAgICAgICAvKiBzZXR0aW5nIGJpdG1hcCBjbGVhcnMgdGV4dCAqLwogICAgICAgIEhlYXBGcmVlKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBpdGVtLT50ZXh0ICk7CiAgICAgICAgaXRlbS0+dGV4dCA9IE5VTEw7CiAgICB9CgogICAgaWYgKGZsYWdzICYgTUZfT1dORVJEUkFXKQogICAgICAgIGl0ZW0tPmR3SXRlbURhdGEgPSAoRFdPUkRfUFRSKXN0cjsKICAgIGVsc2UKICAgICAgICBpdGVtLT5kd0l0ZW1EYXRhID0gMDsKCiAgICBpZiAoKGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApICYmIChmbGFncyAmIE1GX1BPUFVQKSAmJiAoaXRlbS0+aFN1Yk1lbnUgIT0gKEhNRU5VKWlkKSApCglEZXN0cm95TWVudSggaXRlbS0+aFN1Yk1lbnUgKTsgICAvKiBNb2RpZnlNZW51KCkgc3BlYyAqLwoKICAgIGlmIChmbGFncyAmIE1GX1BPUFVQKQogICAgewoJUE9QVVBNRU5VICptZW51ID0gTUVOVV9HZXRNZW51KChITUVOVSlpZCk7CiAgICAgICAgaWYgKG1lbnUpIG1lbnUtPndGbGFncyB8PSBNRl9QT1BVUDsKCWVsc2UKICAgICAgICB7CiAgICAgICAgICAgIGl0ZW0tPndJRCA9IDA7CiAgICAgICAgICAgIGl0ZW0tPmhTdWJNZW51ID0gMDsKICAgICAgICAgICAgaXRlbS0+ZlR5cGUgPSAwOwogICAgICAgICAgICBpdGVtLT5mU3RhdGUgPSAwOwoJICAgIHJldHVybiBGQUxTRTsKICAgICAgICB9CiAgICB9CgogICAgaXRlbS0+d0lEID0gaWQ7CiAgICBpZiAoZmxhZ3MgJiBNRl9QT1BVUCkgaXRlbS0+aFN1Yk1lbnUgPSAoSE1FTlUpaWQ7CgogICAgaWYgKChpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKSAmJiAhKGZsYWdzICYgTUZfUE9QVVApICkKICAgICAgZmxhZ3MgfD0gTUZfUE9QVVA7IC8qIGtlZXAgcG9wdXAgKi8KCiAgICBpdGVtLT5mVHlwZSA9IGZsYWdzICYgVFlQRV9NQVNLOwogICAgLyogTUZTX0RFRkFVTFQgaXMgbm90IGFjY2VwdGVkLiBNRl9ISUxJVEUgaXMgbm90IGxpc3RlZCBhcyBhIHZhbGlkIGZsYWcKICAgICAgIGZvciBNb2RpZnlNZW51LCBidXQgV2luZG93cyBhY2NlcHRzIGl0ICovCiAgICBpdGVtLT5mU3RhdGUgPSBmbGFncyAmIE1FTlVJVEVNSU5GT19TVEFURV9NQVNLICYgfk1GU19ERUZBVUxUOwoKICAgIC8qIERvbid0IGNhbGwgU2V0UmVjdEVtcHR5IGhlcmUhICovCgogICAgZGVidWdfcHJpbnRfbWVudWl0ZW0oIk1FTlVfU2V0SXRlbURhdGEgdG8gIDogIiwgaXRlbSwgIiIpOwogICAgcmV0dXJuIFRSVUU7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIE1FTlVfSW5zZXJ0SXRlbQogKgogKiBJbnNlcnQgKGFsbG9jYXRlKSBhIG5ldyBpdGVtIGludG8gYSBtZW51LgogKi8Kc3RhdGljIE1FTlVJVEVNICpNRU5VX0luc2VydEl0ZW0oIEhNRU5VIGhNZW51LCBVSU5UIHBvcywgVUlOVCBmbGFncyApCnsKICAgIE1FTlVJVEVNICpuZXdJdGVtczsKICAgIFBPUFVQTUVOVSAqbWVudTsKCiAgICBpZiAoIShtZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KSkpCiAgICAgICAgcmV0dXJuIE5VTEw7CgogICAgLyogRmluZCB3aGVyZSB0byBpbnNlcnQgbmV3IGl0ZW0gKi8KCiAgICBpZiAoZmxhZ3MgJiBNRl9CWVBPU0lUSU9OKSB7CiAgICAgICAgaWYgKHBvcyA+IG1lbnUtPm5JdGVtcykKICAgICAgICAgICAgcG9zID0gbWVudS0+bkl0ZW1zOwogICAgfSBlbHNlIHsKICAgICAgICBpZiAoIU1FTlVfRmluZEl0ZW0oICZoTWVudSwgJnBvcywgZmxhZ3MgKSkKICAgICAgICAgICAgcG9zID0gbWVudS0+bkl0ZW1zOwogICAgICAgIGVsc2UgewogICAgICAgICAgICBpZiAoIShtZW51ID0gTUVOVV9HZXRNZW51KCBoTWVudSApKSkKICAgICAgICAgICAgICAgIHJldHVybiBOVUxMOwogICAgICAgIH0KICAgIH0KCiAgICAvKiBDcmVhdGUgbmV3IGl0ZW1zIGFycmF5ICovCgogICAgbmV3SXRlbXMgPSBIZWFwQWxsb2MoIEdldFByb2Nlc3NIZWFwKCksIDAsIHNpemVvZihNRU5VSVRFTSkgKiAobWVudS0+bkl0ZW1zKzEpICk7CiAgICBpZiAoIW5ld0l0ZW1zKQogICAgewogICAgICAgIFdBUk4oImFsbG9jYXRpb24gZmFpbGVkXG4iICk7CiAgICAgICAgcmV0dXJuIE5VTEw7CiAgICB9CiAgICBpZiAobWVudS0+bkl0ZW1zID4gMCkKICAgIHsKCSAgLyogQ29weSB0aGUgb2xkIGFycmF5IGludG8gdGhlIG5ldyBvbmUgKi8KCWlmIChwb3MgPiAwKSBtZW1jcHkoIG5ld0l0ZW1zLCBtZW51LT5pdGVtcywgcG9zICogc2l6ZW9mKE1FTlVJVEVNKSApOwoJaWYgKHBvcyA8IG1lbnUtPm5JdGVtcykgbWVtY3B5KCAmbmV3SXRlbXNbcG9zKzFdLCAmbWVudS0+aXRlbXNbcG9zXSwKCQkJCQkobWVudS0+bkl0ZW1zLXBvcykqc2l6ZW9mKE1FTlVJVEVNKSApOwogICAgICAgIEhlYXBGcmVlKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBtZW51LT5pdGVtcyApOwogICAgfQogICAgbWVudS0+aXRlbXMgPSBuZXdJdGVtczsKICAgIG1lbnUtPm5JdGVtcysrOwogICAgbWVtc2V0KCAmbmV3SXRlbXNbcG9zXSwgMCwgc2l6ZW9mKCpuZXdJdGVtcykgKTsKICAgIG1lbnUtPkhlaWdodCA9IDA7IC8qIGZvcmNlIHNpemUgcmVjYWxjdWxhdGUgKi8KICAgIHJldHVybiAmbmV3SXRlbXNbcG9zXTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgTUVOVV9QYXJzZVJlc291cmNlCiAqCiAqIFBhcnNlIGEgc3RhbmRhcmQgbWVudSByZXNvdXJjZSBhbmQgYWRkIGl0ZW1zIHRvIHRoZSBtZW51LgogKiBSZXR1cm4gYSBwb2ludGVyIHRvIHRoZSBlbmQgb2YgdGhlIHJlc291cmNlLgogKgogKiBOT1RFOiBmbGFncyBpcyBlcXVpdmFsZW50IHRvIHRoZSBtdE9wdGlvbiBmaWVsZAogKi8Kc3RhdGljIExQQ1NUUiBNRU5VX1BhcnNlUmVzb3VyY2UoIExQQ1NUUiByZXMsIEhNRU5VIGhNZW51LCBCT09MIHVuaWNvZGUgKQp7CiAgICBXT1JEIGZsYWdzLCBpZCA9IDA7CiAgICBMUENTVFIgc3RyOwogICAgQk9PTCBlbmRfZmxhZzsKCiAgICBkbwogICAgewogICAgICAgIGZsYWdzID0gR0VUX1dPUkQocmVzKTsKICAgICAgICBlbmRfZmxhZyA9IGZsYWdzICYgTUZfRU5EOwogICAgICAgIC8qIFJlbW92ZSBNRl9FTkQgYmVjYXVzZSBpdCBoYXMgdGhlIHNhbWUgdmFsdWUgYXMgTUZfSElMSVRFICovCiAgICAgICAgZmxhZ3MgJj0gfk1GX0VORDsKICAgICAgICByZXMgKz0gc2l6ZW9mKFdPUkQpOwogICAgICAgIGlmICghKGZsYWdzICYgTUZfUE9QVVApKQogICAgICAgIHsKICAgICAgICAgICAgaWQgPSBHRVRfV09SRChyZXMpOwogICAgICAgICAgICByZXMgKz0gc2l6ZW9mKFdPUkQpOwogICAgICAgIH0KICAgICAgICBzdHIgPSByZXM7CiAgICAgICAgaWYgKCF1bmljb2RlKSByZXMgKz0gc3RybGVuKHN0cikgKyAxOwogICAgICAgIGVsc2UgcmVzICs9IChzdHJsZW5XKChMUENXU1RSKXN0cikgKyAxKSAqIHNpemVvZihXQ0hBUik7CiAgICAgICAgaWYgKGZsYWdzICYgTUZfUE9QVVApCiAgICAgICAgewogICAgICAgICAgICBITUVOVSBoU3ViTWVudSA9IENyZWF0ZVBvcHVwTWVudSgpOwogICAgICAgICAgICBpZiAoIWhTdWJNZW51KSByZXR1cm4gTlVMTDsKICAgICAgICAgICAgaWYgKCEocmVzID0gTUVOVV9QYXJzZVJlc291cmNlKCByZXMsIGhTdWJNZW51LCB1bmljb2RlICkpKQogICAgICAgICAgICAgICAgcmV0dXJuIE5VTEw7CiAgICAgICAgICAgIGlmICghdW5pY29kZSkgQXBwZW5kTWVudUEoIGhNZW51LCBmbGFncywgKFVJTlRfUFRSKWhTdWJNZW51LCBzdHIgKTsKICAgICAgICAgICAgZWxzZSBBcHBlbmRNZW51VyggaE1lbnUsIGZsYWdzLCAoVUlOVF9QVFIpaFN1Yk1lbnUsIChMUENXU1RSKXN0ciApOwogICAgICAgIH0KICAgICAgICBlbHNlICAvKiBOb3QgYSBwb3B1cCAqLwogICAgICAgIHsKICAgICAgICAgICAgaWYgKCF1bmljb2RlKSBBcHBlbmRNZW51QSggaE1lbnUsIGZsYWdzLCBpZCwgKnN0ciA/IHN0ciA6IE5VTEwgKTsKICAgICAgICAgICAgZWxzZSBBcHBlbmRNZW51VyggaE1lbnUsIGZsYWdzLCBpZCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqKExQQ1dTVFIpc3RyID8gKExQQ1dTVFIpc3RyIDogTlVMTCApOwogICAgICAgIH0KICAgIH0gd2hpbGUgKCFlbmRfZmxhZyk7CiAgICByZXR1cm4gcmVzOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBNRU5VRVhfUGFyc2VSZXNvdXJjZQogKgogKiBQYXJzZSBhbiBleHRlbmRlZCBtZW51IHJlc291cmNlIGFuZCBhZGQgaXRlbXMgdG8gdGhlIG1lbnUuCiAqIFJldHVybiBhIHBvaW50ZXIgdG8gdGhlIGVuZCBvZiB0aGUgcmVzb3VyY2UuCiAqLwpzdGF0aWMgTFBDU1RSIE1FTlVFWF9QYXJzZVJlc291cmNlKCBMUENTVFIgcmVzLCBITUVOVSBoTWVudSkKewogICAgV09SRCByZXNpbmZvOwogICAgZG8gewoJTUVOVUlURU1JTkZPVyBtaWk7CgoJbWlpLmNiU2l6ZSA9IHNpemVvZihtaWkpOwoJbWlpLmZNYXNrID0gTUlJTV9TVEFURSB8IE1JSU1fSUQgfCBNSUlNX1RZUEU7CgltaWkuZlR5cGUgPSBHRVRfRFdPUkQocmVzKTsKICAgICAgICByZXMgKz0gc2l6ZW9mKERXT1JEKTsKCW1paS5mU3RhdGUgPSBHRVRfRFdPUkQocmVzKTsKICAgICAgICByZXMgKz0gc2l6ZW9mKERXT1JEKTsKCW1paS53SUQgPSBHRVRfRFdPUkQocmVzKTsKICAgICAgICByZXMgKz0gc2l6ZW9mKERXT1JEKTsKCXJlc2luZm8gPSBHRVRfV09SRChyZXMpOyAvKiBGSVhNRTogZm9yIDE2LWJpdCBhcHBzIHRoaXMgaXMgYSBieXRlLiAgKi8KICAgICAgICByZXMgKz0gc2l6ZW9mKFdPUkQpOwoJLyogQWxpZ24gdGhlIHRleHQgb24gYSB3b3JkIGJvdW5kYXJ5LiAgKi8KCXJlcyArPSAofigoVUlOVF9QVFIpcmVzIC0gMSkpICYgMTsKCW1paS5kd1R5cGVEYXRhID0gKExQV1NUUikgcmVzOwoJcmVzICs9ICgxICsgc3RybGVuVyhtaWkuZHdUeXBlRGF0YSkpICogc2l6ZW9mKFdDSEFSKTsKCS8qIEFsaWduIHRoZSBmb2xsb3dpbmcgZmllbGRzIG9uIGEgZHdvcmQgYm91bmRhcnkuICAqLwoJcmVzICs9ICh+KChVSU5UX1BUUilyZXMgLSAxKSkgJiAzOwoKICAgICAgICBUUkFDRSgiTWVudSBpdGVtOiBbJTA4eCwlMDh4LCUwNHgsJTA0eCwlc11cbiIsCiAgICAgICAgICAgICAgbWlpLmZUeXBlLCBtaWkuZlN0YXRlLCBtaWkud0lELCByZXNpbmZvLCBkZWJ1Z3N0cl93KG1paS5kd1R5cGVEYXRhKSk7CgoJaWYgKHJlc2luZm8gJiAxKSB7CS8qIFBvcC11cD8gKi8KCSAgICAvKiBEV09SRCBoZWxwaWQgPSBHRVRfRFdPUkQocmVzKTsgRklYTUU6IHVzZSB0aGlzLiAgKi8KCSAgICByZXMgKz0gc2l6ZW9mKERXT1JEKTsKCSAgICBtaWkuaFN1Yk1lbnUgPSBDcmVhdGVQb3B1cE1lbnUoKTsKCSAgICBpZiAoIW1paS5oU3ViTWVudSkKCQlyZXR1cm4gTlVMTDsKCSAgICBpZiAoIShyZXMgPSBNRU5VRVhfUGFyc2VSZXNvdXJjZShyZXMsIG1paS5oU3ViTWVudSkpKSB7CgkJRGVzdHJveU1lbnUobWlpLmhTdWJNZW51KTsKICAgICAgICAgICAgICAgIHJldHVybiBOVUxMOwoJICAgIH0KCSAgICBtaWkuZk1hc2sgfD0gTUlJTV9TVUJNRU5VOwoJICAgIG1paS5mVHlwZSB8PSBNRl9QT1BVUDsKICAgICAgICB9CgllbHNlIGlmKCEqbWlpLmR3VHlwZURhdGEgJiYgIShtaWkuZlR5cGUgJiBNRl9TRVBBUkFUT1IpKQoJewoJICAgIFdBUk4oIkNvbnZlcnRpbmcgTlVMTCBtZW51IGl0ZW0gJTA0eCwgdHlwZSAlMDR4IHRvIFNFUEFSQVRPUlxuIiwKCQltaWkud0lELCBtaWkuZlR5cGUpOwoJICAgIG1paS5mVHlwZSB8PSBNRl9TRVBBUkFUT1I7Cgl9CglJbnNlcnRNZW51SXRlbVcoaE1lbnUsIC0xLCBNRl9CWVBPU0lUSU9OLCAmbWlpKTsKICAgIH0gd2hpbGUgKCEocmVzaW5mbyAmIE1GX0VORCkpOwogICAgcmV0dXJuIHJlczsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9HZXRTdWJQb3B1cAogKgogKiBSZXR1cm4gdGhlIGhhbmRsZSBvZiB0aGUgc2VsZWN0ZWQgc3ViLXBvcHVwIG1lbnUgKGlmIGFueSkuCiAqLwpzdGF0aWMgSE1FTlUgTUVOVV9HZXRTdWJQb3B1cCggSE1FTlUgaG1lbnUgKQp7CiAgICBQT1BVUE1FTlUgKm1lbnU7CiAgICBNRU5VSVRFTSAqaXRlbTsKCiAgICBtZW51ID0gTUVOVV9HZXRNZW51KCBobWVudSApOwoKICAgIGlmICgoIW1lbnUpIHx8IChtZW51LT5Gb2N1c2VkSXRlbSA9PSBOT19TRUxFQ1RFRF9JVEVNKSkgcmV0dXJuIDA7CgogICAgaXRlbSA9ICZtZW51LT5pdGVtc1ttZW51LT5Gb2N1c2VkSXRlbV07CiAgICBpZiAoKGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApICYmIChpdGVtLT5mU3RhdGUgJiBNRl9NT1VTRVNFTEVDVCkpCiAgICAgICAgcmV0dXJuIGl0ZW0tPmhTdWJNZW51OwogICAgcmV0dXJuIDA7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfSGlkZVN1YlBvcHVwcwogKgogKiBIaWRlIHRoZSBzdWItcG9wdXAgbWVudXMgb2YgdGhpcyBtZW51LgogKi8Kc3RhdGljIHZvaWQgTUVOVV9IaWRlU3ViUG9wdXBzKCBIV05EIGh3bmRPd25lciwgSE1FTlUgaG1lbnUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQk9PTCBzZW5kTWVudVNlbGVjdCApCnsKICAgIFBPUFVQTUVOVSAqbWVudSA9IE1FTlVfR2V0TWVudSggaG1lbnUgKTsKCiAgICBUUkFDRSgib3duZXI9JXAgaG1lbnU9JXAgMHglMDR4XG4iLCBod25kT3duZXIsIGhtZW51LCBzZW5kTWVudVNlbGVjdCk7CgogICAgaWYgKG1lbnUgJiYgdG9wX3BvcHVwKQogICAgewoJSE1FTlUgaHN1Ym1lbnU7CglQT1BVUE1FTlUgKnN1Ym1lbnU7CglNRU5VSVRFTSAqaXRlbTsKCglpZiAobWVudS0+Rm9jdXNlZEl0ZW0gIT0gTk9fU0VMRUNURURfSVRFTSkKCXsKCSAgICBpdGVtID0gJm1lbnUtPml0ZW1zW21lbnUtPkZvY3VzZWRJdGVtXTsKCSAgICBpZiAoIShpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKSB8fAoJCSEoaXRlbS0+ZlN0YXRlICYgTUZfTU9VU0VTRUxFQ1QpKSByZXR1cm47CgkgICAgaXRlbS0+ZlN0YXRlICY9IH5NRl9NT1VTRVNFTEVDVDsKCSAgICBoc3VibWVudSA9IGl0ZW0tPmhTdWJNZW51OwoJfSBlbHNlIHJldHVybjsKCglzdWJtZW51ID0gTUVOVV9HZXRNZW51KCBoc3VibWVudSApOwoJTUVOVV9IaWRlU3ViUG9wdXBzKCBod25kT3duZXIsIGhzdWJtZW51LCBGQUxTRSApOwoJTUVOVV9TZWxlY3RJdGVtKCBod25kT3duZXIsIGhzdWJtZW51LCBOT19TRUxFQ1RFRF9JVEVNLCBzZW5kTWVudVNlbGVjdCwgMCApOwogICAgICAgIERlc3Ryb3lXaW5kb3coIHN1Ym1lbnUtPmhXbmQgKTsKICAgICAgICBzdWJtZW51LT5oV25kID0gMDsKICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9TaG93U3ViUG9wdXAKICoKICogRGlzcGxheSB0aGUgc3ViLW1lbnUgb2YgdGhlIHNlbGVjdGVkIGl0ZW0gb2YgdGhpcyBtZW51LgogKiBSZXR1cm4gdGhlIGhhbmRsZSBvZiB0aGUgc3VibWVudSwgb3IgaG1lbnUgaWYgbm8gc3VibWVudSB0byBkaXNwbGF5LgogKi8Kc3RhdGljIEhNRU5VIE1FTlVfU2hvd1N1YlBvcHVwKCBIV05EIGh3bmRPd25lciwgSE1FTlUgaG1lbnUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBCT09MIHNlbGVjdEZpcnN0LCBVSU5UIHdGbGFncyApCnsKICAgIFJFQ1QgcmVjdDsKICAgIFBPUFVQTUVOVSAqbWVudTsKICAgIE1FTlVJVEVNICppdGVtOwogICAgSERDIGhkYzsKCiAgICBUUkFDRSgib3duZXI9JXAgaG1lbnU9JXAgMHglMDR4XG4iLCBod25kT3duZXIsIGhtZW51LCBzZWxlY3RGaXJzdCk7CgogICAgaWYgKCEobWVudSA9IE1FTlVfR2V0TWVudSggaG1lbnUgKSkpIHJldHVybiBobWVudTsKCiAgICBpZiAobWVudS0+Rm9jdXNlZEl0ZW0gPT0gTk9fU0VMRUNURURfSVRFTSkgcmV0dXJuIGhtZW51OwoKICAgIGl0ZW0gPSAmbWVudS0+aXRlbXNbbWVudS0+Rm9jdXNlZEl0ZW1dOwogICAgaWYgKCEoaXRlbS0+ZlR5cGUgJiBNRl9QT1BVUCkgfHwgKGl0ZW0tPmZTdGF0ZSAmIChNRl9HUkFZRUQgfCBNRl9ESVNBQkxFRCkpKQogICAgICAgIHJldHVybiBobWVudTsKCiAgICAvKiBtZXNzYWdlIG11c3QgYmUgc2VudCBiZWZvcmUgdXNpbmcgaXRlbSwKICAgICAgIGJlY2F1c2UgbmVhcmx5IGV2ZXJ5dGhpbmcgbWF5IGJlIGNoYW5nZWQgYnkgdGhlIGFwcGxpY2F0aW9uICEgKi8KCiAgICAvKiBTZW5kIFdNX0lOSVRNRU5VUE9QVVAgbWVzc2FnZSBvbmx5IGlmIFRQTV9OT05PVElGWSBmbGFnIGlzIG5vdCBzcGVjaWZpZWQgKi8KICAgIGlmICghKHdGbGFncyAmIFRQTV9OT05PVElGWSkpCiAgICAgICBTZW5kTWVzc2FnZVcoIGh3bmRPd25lciwgV01fSU5JVE1FTlVQT1BVUCwgKFdQQVJBTSlpdGVtLT5oU3ViTWVudSwKICAgICAgICAgICAgICAgICAgICAgTUFLRUxPTkcoIG1lbnUtPkZvY3VzZWRJdGVtLCBJU19TWVNURU1fTUVOVShtZW51KSApKTsKCiAgICBpdGVtID0gJm1lbnUtPml0ZW1zW21lbnUtPkZvY3VzZWRJdGVtXTsKICAgIHJlY3QgPSBpdGVtLT5yZWN0OwoKICAgIC8qIGNvcnJlY3QgaXRlbSBpZiBtb2RpZmllZCBhcyBhIHJlYWN0aW9uIHRvIFdNX0lOSVRNRU5VUE9QVVAgbWVzc2FnZSAqLwogICAgaWYgKCEoaXRlbS0+ZlN0YXRlICYgTUZfSElMSVRFKSkKICAgIHsKICAgICAgICBpZiAobWVudS0+d0ZsYWdzICYgTUZfUE9QVVApIGhkYyA9IEdldERDKCBtZW51LT5oV25kICk7CiAgICAgICAgZWxzZSBoZGMgPSBHZXREQ0V4KCBtZW51LT5oV25kLCAwLCBEQ1hfQ0FDSEUgfCBEQ1hfV0lORE9XKTsKCiAgICAgICAgU2VsZWN0T2JqZWN0KCBoZGMsIGdldF9tZW51X2ZvbnQoRkFMU0UpKTsKCiAgICAgICAgaXRlbS0+ZlN0YXRlIHw9IE1GX0hJTElURTsKICAgICAgICBNRU5VX0RyYXdNZW51SXRlbSggbWVudS0+aFduZCwgaG1lbnUsIGh3bmRPd25lciwgaGRjLCBpdGVtLCBtZW51LT5IZWlnaHQsICEobWVudS0+d0ZsYWdzICYgTUZfUE9QVVApLCBPREFfRFJBV0VOVElSRSApOwoJUmVsZWFzZURDKCBtZW51LT5oV25kLCBoZGMgKTsKICAgIH0KICAgIGlmICghaXRlbS0+cmVjdC50b3AgJiYgIWl0ZW0tPnJlY3QubGVmdCAmJiAhaXRlbS0+cmVjdC5ib3R0b20gJiYgIWl0ZW0tPnJlY3QucmlnaHQpCiAgICAgIGl0ZW0tPnJlY3QgPSByZWN0OwoKICAgIGl0ZW0tPmZTdGF0ZSB8PSBNRl9NT1VTRVNFTEVDVDsKCiAgICBpZiAoSVNfU1lTVEVNX01FTlUobWVudSkpCiAgICB7CglNRU5VX0luaXRTeXNNZW51UG9wdXAoaXRlbS0+aFN1Yk1lbnUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEdldFdpbmRvd0xvbmdXKCBtZW51LT5oV25kLCBHV0xfU1RZTEUgKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgR2V0Q2xhc3NMb25nVyggbWVudS0+aFduZCwgR0NMX1NUWUxFKSk7CgoJTkNfR2V0U3lzUG9wdXBQb3MoIG1lbnUtPmhXbmQsICZyZWN0ICk7CglyZWN0LnRvcCA9IHJlY3QuYm90dG9tOwoJcmVjdC5yaWdodCA9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1hTSVpFKTsKICAgICAgICByZWN0LmJvdHRvbSA9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1lTSVpFKTsKICAgIH0KICAgIGVsc2UKICAgIHsKICAgICAgICBHZXRXaW5kb3dSZWN0KCBtZW51LT5oV25kLCAmcmVjdCApOwoJaWYgKG1lbnUtPndGbGFncyAmIE1GX1BPUFVQKQoJewogICAgICAgICAgICBSRUNUIHJjID0gaXRlbS0+cmVjdDsKCiAgICAgICAgICAgIE1FTlVfQWRqdXN0TWVudUl0ZW1SZWN0KG1lbnUsICZyYyk7CgoJICAgIC8qIFRoZSBmaXJzdCBpdGVtIGluIHRoZSBwb3B1cCBtZW51IGhhcyB0byBiZSBhdCB0aGUKCSAgICAgICBzYW1lIHkgcG9zaXRpb24gYXMgdGhlIGZvY3VzZWQgbWVudSBpdGVtICovCgkgICAgcmVjdC5sZWZ0ICs9IHJjLnJpZ2h0IC0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWEJPUkRFUik7CgkgICAgcmVjdC50b3AgKz0gcmMudG9wIC0gTUVOVV9UT1BfTUFSR0lOOwoJICAgIHJlY3QucmlnaHQgPSByYy5sZWZ0IC0gcmMucmlnaHQgKyBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYQk9SREVSKTsKCSAgICByZWN0LmJvdHRvbSA9IHJjLnRvcCAtIHJjLmJvdHRvbSAtIE1FTlVfVE9QX01BUkdJTgoJICAgICAgICAgICAgICAgICAgLSBNRU5VX0JPVFRPTV9NQVJHSU4gLSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZQk9SREVSKTsKCX0KCWVsc2UKCXsKCSAgICByZWN0LmxlZnQgKz0gaXRlbS0+cmVjdC5sZWZ0OwoJICAgIHJlY3QudG9wICs9IGl0ZW0tPnJlY3QuYm90dG9tOwoJICAgIHJlY3QucmlnaHQgPSBpdGVtLT5yZWN0LnJpZ2h0IC0gaXRlbS0+cmVjdC5sZWZ0OwoJICAgIHJlY3QuYm90dG9tID0gaXRlbS0+cmVjdC5ib3R0b20gLSBpdGVtLT5yZWN0LnRvcDsKCX0KICAgIH0KCiAgICBNRU5VX1Nob3dQb3B1cCggaHduZE93bmVyLCBpdGVtLT5oU3ViTWVudSwgbWVudS0+Rm9jdXNlZEl0ZW0sCgkJICAgIHJlY3QubGVmdCwgcmVjdC50b3AsIHJlY3QucmlnaHQsIHJlY3QuYm90dG9tICk7CiAgICBpZiAoc2VsZWN0Rmlyc3QpCiAgICAgICAgTUVOVV9Nb3ZlU2VsZWN0aW9uKCBod25kT3duZXIsIGl0ZW0tPmhTdWJNZW51LCBJVEVNX05FWFQgKTsKICAgIHJldHVybiBpdGVtLT5oU3ViTWVudTsKfQoKCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIE1FTlVfSXNNZW51QWN0aXZlCiAqLwpIV05EIE1FTlVfSXNNZW51QWN0aXZlKHZvaWQpCnsKICAgIHJldHVybiB0b3BfcG9wdXA7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9QdE1lbnUKICoKICogV2Fsa3MgbWVudSBjaGFpbiB0cnlpbmcgdG8gZmluZCBhIG1lbnUgcHQgbWFwcyB0by4KICovCnN0YXRpYyBITUVOVSBNRU5VX1B0TWVudSggSE1FTlUgaE1lbnUsIFBPSU5UIHB0ICkKewogICBQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoIGhNZW51ICk7CiAgIFVJTlQgaXRlbSA9IG1lbnUtPkZvY3VzZWRJdGVtOwogICBITUVOVSByZXQ7CgogICAvKiB0cnkgc3VicG9wdXAgZmlyc3QgKGlmIGFueSkgKi8KICAgcmV0ID0gKGl0ZW0gIT0gTk9fU0VMRUNURURfSVRFTSAmJgogICAgICAgICAgKG1lbnUtPml0ZW1zW2l0ZW1dLmZUeXBlICYgTUZfUE9QVVApICYmCiAgICAgICAgICAobWVudS0+aXRlbXNbaXRlbV0uZlN0YXRlICYgTUZfTU9VU0VTRUxFQ1QpKQogICAgICAgID8gTUVOVV9QdE1lbnUobWVudS0+aXRlbXNbaXRlbV0uaFN1Yk1lbnUsIHB0KSA6IDA7CgogICBpZiAoIXJldCkgIC8qIGNoZWNrIHRoZSBjdXJyZW50IHdpbmRvdyAoYXZvaWRpbmcgV01fSElUVEVTVCkgKi8KICAgewogICAgICAgSU5UIGh0ID0gTkNfSGFuZGxlTkNIaXRUZXN0KCBtZW51LT5oV25kLCBwdCApOwogICAgICAgaWYoIG1lbnUtPndGbGFncyAmIE1GX1BPUFVQICkKICAgICAgIHsKICAgICAgICAgICBpZiAoaHQgIT0gSFROT1dIRVJFICYmIGh0ICE9IEhURVJST1IpIHJldCA9IGhNZW51OwogICAgICAgfQogICAgICAgZWxzZSBpZiAoaHQgPT0gSFRTWVNNRU5VKQogICAgICAgICAgIHJldCA9IGdldF93aW5fc3lzX21lbnUoIG1lbnUtPmhXbmQgKTsKICAgICAgIGVsc2UgaWYgKGh0ID09IEhUTUVOVSkKICAgICAgICAgICByZXQgPSBHZXRNZW51KCBtZW51LT5oV25kICk7CiAgIH0KICAgcmV0dXJuIHJldDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0V4ZWNGb2N1c2VkSXRlbQogKgogKiBFeGVjdXRlIGEgbWVudSBpdGVtIChmb3IgaW5zdGFuY2Ugd2hlbiB1c2VyIHByZXNzZWQgRW50ZXIpLgogKiBSZXR1cm4gdGhlIHdJRCBvZiB0aGUgZXhlY3V0ZWQgaXRlbS4gT3RoZXJ3aXNlLCAtMSBpbmRpY2F0aW5nCiAqIHRoYXQgbm8gbWVudSBpdGVtIHdhcyBleGVjdXRlZCwgLTIgaWYgYSBwb3B1cCBpcyBzaG93bjsKICogSGF2ZSB0byByZWNlaXZlIHRoZSBmbGFncyBmb3IgdGhlIFRyYWNrUG9wdXBNZW51IG9wdGlvbnMgdG8gYXZvaWQKICogc2VuZGluZyB1bndhbnRlZCBtZXNzYWdlLgogKgogKi8Kc3RhdGljIElOVCBNRU5VX0V4ZWNGb2N1c2VkSXRlbSggTVRSQUNLRVIqIHBtdCwgSE1FTlUgaE1lbnUsIFVJTlQgd0ZsYWdzICkKewogICAgTUVOVUlURU0gKml0ZW07CiAgICBQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoIGhNZW51ICk7CgogICAgVFJBQ0UoIiVwIGhtZW51PSVwXG4iLCBwbXQsIGhNZW51KTsKCiAgICBpZiAoIW1lbnUgfHwgIW1lbnUtPm5JdGVtcyB8fAoJKG1lbnUtPkZvY3VzZWRJdGVtID09IE5PX1NFTEVDVEVEX0lURU0pKSByZXR1cm4gLTE7CgogICAgaXRlbSA9ICZtZW51LT5pdGVtc1ttZW51LT5Gb2N1c2VkSXRlbV07CgogICAgVFJBQ0UoImhNZW51ICVwIHdJRCAlMDh4IGhTdWJNZW51ICVwIGZUeXBlICUwNHhcbiIsIGhNZW51LCBpdGVtLT53SUQsIGl0ZW0tPmhTdWJNZW51LCBpdGVtLT5mVHlwZSk7CgogICAgaWYgKCEoaXRlbS0+ZlR5cGUgJiBNRl9QT1BVUCkpCiAgICB7CglpZiAoIShpdGVtLT5mU3RhdGUgJiAoTUZfR1JBWUVEIHwgTUZfRElTQUJMRUQpKSAmJiAhKGl0ZW0tPmZUeXBlICYgTUZfU0VQQVJBVE9SKSkKCXsKCSAgICAvKiBJZiBUUE1fUkVUVVJOQ01EIGlzIHNldCB5b3UgcmV0dXJuIHRoZSBpZCwgYnV0CgkgICAgICAgZG8gbm90IHNlbmQgYSBtZXNzYWdlIHRvIHRoZSBvd25lciAqLwoJICAgIGlmKCEod0ZsYWdzICYgVFBNX1JFVFVSTkNNRCkpCgkgICAgewoJCWlmKCBtZW51LT53RmxhZ3MgJiBNRl9TWVNNRU5VICkKCQkgICAgUG9zdE1lc3NhZ2VXKCBwbXQtPmhPd25lclduZCwgV01fU1lTQ09NTUFORCwgaXRlbS0+d0lELAoJCQkJICBNQUtFTFBBUkFNKChJTlQxNilwbXQtPnB0LngsIChJTlQxNilwbXQtPnB0LnkpICk7CgkJZWxzZQoJCXsKICAgICAgICAgICAgICAgICAgICBpZiAobWVudS0+ZHdTdHlsZSAmIE1OU19OT1RJRllCWVBPUykKICAgICAgICAgICAgICAgICAgICAgICAgUG9zdE1lc3NhZ2VXKCBwbXQtPmhPd25lclduZCwgV01fTUVOVUNPTU1BTkQsIG1lbnUtPkZvY3VzZWRJdGVtLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChMUEFSQU0paE1lbnUpOwogICAgICAgICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgICAgICAgICAgUG9zdE1lc3NhZ2VXKCBwbXQtPmhPd25lclduZCwgV01fQ09NTUFORCwgaXRlbS0+d0lELCAwICk7CgkJfQoJICAgIH0KCSAgICByZXR1cm4gaXRlbS0+d0lEOwoJfQogICAgfQogICAgZWxzZQogICAgewoJcG10LT5oQ3VycmVudE1lbnUgPSBNRU5VX1Nob3dTdWJQb3B1cChwbXQtPmhPd25lclduZCwgaE1lbnUsIFRSVUUsIHdGbGFncyk7CglyZXR1cm4gLTI7CiAgICB9CgogICAgcmV0dXJuIC0xOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfU3dpdGNoVHJhY2tpbmcKICoKICogSGVscGVyIGZ1bmN0aW9uIGZvciBtZW51IG5hdmlnYXRpb24gcm91dGluZXMuCiAqLwpzdGF0aWMgdm9pZCBNRU5VX1N3aXRjaFRyYWNraW5nKCBNVFJBQ0tFUiogcG10LCBITUVOVSBoUHRNZW51LCBVSU5UIGlkICkKewogICAgUE9QVVBNRU5VICpwdG1lbnUgPSBNRU5VX0dldE1lbnUoIGhQdE1lbnUgKTsKICAgIFBPUFVQTUVOVSAqdG9wbWVudSA9IE1FTlVfR2V0TWVudSggcG10LT5oVG9wTWVudSApOwoKICAgIFRSQUNFKCIlcCBobWVudT0lcCAweCUwNHhcbiIsIHBtdCwgaFB0TWVudSwgaWQpOwoKICAgIGlmKCBwbXQtPmhUb3BNZW51ICE9IGhQdE1lbnUgJiYKCSEoKHB0bWVudS0+d0ZsYWdzIHwgdG9wbWVudS0+d0ZsYWdzKSAmIE1GX1BPUFVQKSApCiAgICB7CgkvKiBib3RoIGFyZSB0b3AgbGV2ZWwgbWVudXMgKHN5c3RlbSBhbmQgbWVudS1iYXIpICovCglNRU5VX0hpZGVTdWJQb3B1cHMoIHBtdC0+aE93bmVyV25kLCBwbXQtPmhUb3BNZW51LCBGQUxTRSApOwoJTUVOVV9TZWxlY3RJdGVtKCBwbXQtPmhPd25lclduZCwgcG10LT5oVG9wTWVudSwgTk9fU0VMRUNURURfSVRFTSwgRkFMU0UsIDAgKTsKICAgICAgICBwbXQtPmhUb3BNZW51ID0gaFB0TWVudTsKICAgIH0KICAgIGVsc2UgTUVOVV9IaWRlU3ViUG9wdXBzKCBwbXQtPmhPd25lclduZCwgaFB0TWVudSwgRkFMU0UgKTsKICAgIE1FTlVfU2VsZWN0SXRlbSggcG10LT5oT3duZXJXbmQsIGhQdE1lbnUsIGlkLCBUUlVFLCAwICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfQnV0dG9uRG93bgogKgogKiBSZXR1cm4gVFJVRSBpZiB3ZSBjYW4gZ28gb24gd2l0aCBtZW51IHRyYWNraW5nLgogKi8Kc3RhdGljIEJPT0wgTUVOVV9CdXR0b25Eb3duKCBNVFJBQ0tFUiogcG10LCBITUVOVSBoUHRNZW51LCBVSU5UIHdGbGFncyApCnsKICAgIFRSQUNFKCIlcCBoUHRNZW51PSVwXG4iLCBwbXQsIGhQdE1lbnUpOwoKICAgIGlmIChoUHRNZW51KQogICAgewoJVUlOVCBpZCA9IDA7CglQT1BVUE1FTlUgKnB0bWVudSA9IE1FTlVfR2V0TWVudSggaFB0TWVudSApOwoJTUVOVUlURU0gKml0ZW07CgoJaWYoIElTX1NZU1RFTV9NRU5VKHB0bWVudSkgKQoJICAgIGl0ZW0gPSBwdG1lbnUtPml0ZW1zOwoJZWxzZQoJICAgIGl0ZW0gPSBNRU5VX0ZpbmRJdGVtQnlDb29yZHMoIHB0bWVudSwgcG10LT5wdCwgJmlkICk7CgoJaWYoIGl0ZW0gKQoJewoJICAgIGlmKCBwdG1lbnUtPkZvY3VzZWRJdGVtICE9IGlkICkKCQlNRU5VX1N3aXRjaFRyYWNraW5nKCBwbXQsIGhQdE1lbnUsIGlkICk7CgoJICAgIC8qIElmIHRoZSBwb3B1cCBtZW51IGlzIG5vdCBhbHJlYWR5ICJwb3BwZWQiICovCgkgICAgaWYoIShpdGVtLT5mU3RhdGUgJiBNRl9NT1VTRVNFTEVDVCApKQoJICAgIHsKCQlwbXQtPmhDdXJyZW50TWVudSA9IE1FTlVfU2hvd1N1YlBvcHVwKCBwbXQtPmhPd25lclduZCwgaFB0TWVudSwgRkFMU0UsIHdGbGFncyApOwoJICAgIH0KCgkgICAgcmV0dXJuIFRSVUU7Cgl9CgkvKiBFbHNlIHRoZSBjbGljayB3YXMgb24gdGhlIG1lbnUgYmFyLCBmaW5pc2ggdGhlIHRyYWNraW5nICovCiAgICB9CiAgICByZXR1cm4gRkFMU0U7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9CdXR0b25VcAogKgogKiBSZXR1cm4gdGhlIHZhbHVlIG9mIE1FTlVfRXhlY0ZvY3VzZWRJdGVtIGlmCiAqIHRoZSBzZWxlY3RlZCBpdGVtIHdhcyBub3QgYSBwb3B1cC4gRWxzZSBvcGVuIHRoZSBwb3B1cC4KICogQSAtMSByZXR1cm4gdmFsdWUgaW5kaWNhdGVzIHRoYXQgd2UgZ28gb24gd2l0aCBtZW51IHRyYWNraW5nLgogKgogKi8Kc3RhdGljIElOVCBNRU5VX0J1dHRvblVwKCBNVFJBQ0tFUiogcG10LCBITUVOVSBoUHRNZW51LCBVSU5UIHdGbGFncykKewogICAgVFJBQ0UoIiVwIGhtZW51PSVwXG4iLCBwbXQsIGhQdE1lbnUpOwoKICAgIGlmIChoUHRNZW51KQogICAgewoJVUlOVCBpZCA9IDA7CglQT1BVUE1FTlUgKnB0bWVudSA9IE1FTlVfR2V0TWVudSggaFB0TWVudSApOwoJTUVOVUlURU0gKml0ZW07CgogICAgICAgIGlmKCBJU19TWVNURU1fTUVOVShwdG1lbnUpICkKICAgICAgICAgICAgaXRlbSA9IHB0bWVudS0+aXRlbXM7CiAgICAgICAgZWxzZQogICAgICAgICAgICBpdGVtID0gTUVOVV9GaW5kSXRlbUJ5Q29vcmRzKCBwdG1lbnUsIHBtdC0+cHQsICZpZCApOwoKCWlmKCBpdGVtICYmIChwdG1lbnUtPkZvY3VzZWRJdGVtID09IGlkICkpCgl7CiAgICAgICAgICAgIGRlYnVnX3ByaW50X21lbnVpdGVtICgiRm9jdXNlZEl0ZW06ICIsIGl0ZW0sICIiKTsKCgkgICAgaWYoICEoaXRlbS0+ZlR5cGUgJiBNRl9QT1BVUCkgKQoJICAgIHsKCSAgICAgICAgSU5UIGV4ZWN1dGVkTWVudUlkID0gTUVOVV9FeGVjRm9jdXNlZEl0ZW0oIHBtdCwgaFB0TWVudSwgd0ZsYWdzKTsKICAgICAgICAgICAgICAgIGlmIChleGVjdXRlZE1lbnVJZCA9PSAtMSB8fCBleGVjdXRlZE1lbnVJZCA9PSAtMikgcmV0dXJuIC0xOwogICAgICAgICAgICAgICAgcmV0dXJuIGV4ZWN1dGVkTWVudUlkOwoJICAgIH0KCgkgICAgLyogSWYgd2UgYXJlIGRlYWxpbmcgd2l0aCB0aGUgdG9wLWxldmVsIG1lbnUgICAgICAgICAgICAqLwoJICAgIC8qIGFuZCB0aGlzIGlzIGEgY2xpY2sgb24gYW4gYWxyZWFkeSAicG9wcGVkIiBpdGVtOiAgICAgKi8KCSAgICAvKiBTdG9wIHRoZSBtZW51IHRyYWNraW5nIGFuZCBjbG9zZSB0aGUgb3BlbmVkIHN1Ym1lbnVzICovCgkgICAgaWYoKHBtdC0+aFRvcE1lbnUgPT0gaFB0TWVudSkgJiYgcHRtZW51LT5iVGltZVRvSGlkZSkKCQlyZXR1cm4gMDsKCX0KCXB0bWVudS0+YlRpbWVUb0hpZGUgPSBUUlVFOwogICAgfQogICAgcmV0dXJuIC0xOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX01vdXNlTW92ZQogKgogKiBSZXR1cm4gVFJVRSBpZiB3ZSBjYW4gZ28gb24gd2l0aCBtZW51IHRyYWNraW5nLgogKi8Kc3RhdGljIEJPT0wgTUVOVV9Nb3VzZU1vdmUoIE1UUkFDS0VSKiBwbXQsIEhNRU5VIGhQdE1lbnUsIFVJTlQgd0ZsYWdzICkKewogICAgVUlOVCBpZCA9IE5PX1NFTEVDVEVEX0lURU07CiAgICBQT1BVUE1FTlUgKnB0bWVudSA9IE5VTEw7CgogICAgaWYoIGhQdE1lbnUgKQogICAgewoJcHRtZW51ID0gTUVOVV9HZXRNZW51KCBoUHRNZW51ICk7CiAgICAgICAgaWYoIElTX1NZU1RFTV9NRU5VKHB0bWVudSkgKQoJICAgIGlkID0gMDsKICAgICAgICBlbHNlCiAgICAgICAgICAgIE1FTlVfRmluZEl0ZW1CeUNvb3JkcyggcHRtZW51LCBwbXQtPnB0LCAmaWQgKTsKICAgIH0KCiAgICBpZiggaWQgPT0gTk9fU0VMRUNURURfSVRFTSApCiAgICB7CglNRU5VX1NlbGVjdEl0ZW0oIHBtdC0+aE93bmVyV25kLCBwbXQtPmhDdXJyZW50TWVudSwKCQkJIE5PX1NFTEVDVEVEX0lURU0sIFRSVUUsIHBtdC0+aFRvcE1lbnUpOwoKICAgIH0KICAgIGVsc2UgaWYoIHB0bWVudS0+Rm9jdXNlZEl0ZW0gIT0gaWQgKQogICAgewoJICAgIE1FTlVfU3dpdGNoVHJhY2tpbmcoIHBtdCwgaFB0TWVudSwgaWQgKTsKCSAgICBwbXQtPmhDdXJyZW50TWVudSA9IE1FTlVfU2hvd1N1YlBvcHVwKHBtdC0+aE93bmVyV25kLCBoUHRNZW51LCBGQUxTRSwgd0ZsYWdzKTsKICAgIH0KICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX1NldENhcHR1cmUKICovCnN0YXRpYyB2b2lkIE1FTlVfU2V0Q2FwdHVyZSggSFdORCBod25kICkKewogICAgSFdORCBwcmV2aW91cyA9IDA7CgogICAgU0VSVkVSX1NUQVJUX1JFUSggc2V0X2NhcHR1cmVfd2luZG93ICkKICAgIHsKICAgICAgICByZXEtPmhhbmRsZSA9IGh3bmQ7CiAgICAgICAgcmVxLT5mbGFncyAgPSBDQVBUVVJFX01FTlU7CiAgICAgICAgaWYgKCF3aW5lX3NlcnZlcl9jYWxsX2VyciggcmVxICkpCiAgICAgICAgewogICAgICAgICAgICBwcmV2aW91cyA9IHJlcGx5LT5wcmV2aW91czsKICAgICAgICAgICAgaHduZCA9IHJlcGx5LT5mdWxsX2hhbmRsZTsKICAgICAgICB9CiAgICB9CiAgICBTRVJWRVJfRU5EX1JFUTsKCiAgICBpZiAocHJldmlvdXMgJiYgcHJldmlvdXMgIT0gaHduZCkKICAgICAgICBTZW5kTWVzc2FnZVcoIHByZXZpb3VzLCBXTV9DQVBUVVJFQ0hBTkdFRCwgMCwgKExQQVJBTSlod25kICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfRG9OZXh0TWVudQogKgogKiBOT1RFOiBXTV9ORVhUTUVOVSBkb2N1bWVudGVkIGluIFdpbjMyIGlzIGEgYml0IGRpZmZlcmVudC4KICovCnN0YXRpYyBMUkVTVUxUIE1FTlVfRG9OZXh0TWVudSggTVRSQUNLRVIqIHBtdCwgVUlOVCB2ayApCnsKICAgIFBPUFVQTUVOVSAqbWVudSA9IE1FTlVfR2V0TWVudSggcG10LT5oVG9wTWVudSApOwoKICAgIGlmKCAodmsgPT0gVktfTEVGVCAmJiAgbWVudS0+Rm9jdXNlZEl0ZW0gPT0gMCApIHx8CiAgICAgICAgKHZrID09IFZLX1JJR0hUICYmIG1lbnUtPkZvY3VzZWRJdGVtID09IG1lbnUtPm5JdGVtcyAtIDEpKQogICAgewogICAgICAgIE1ESU5FWFRNRU5VIG5leHRfbWVudTsKCUhNRU5VIGhOZXdNZW51OwoJSFdORCAgaE5ld1duZDsKCVVJTlQgIGlkID0gMDsKCiAgICAgICAgbmV4dF9tZW51LmhtZW51SW4gPSAoSVNfU1lTVEVNX01FTlUobWVudSkpID8gR2V0U3ViTWVudShwbXQtPmhUb3BNZW51LDApIDogcG10LT5oVG9wTWVudTsKICAgICAgICBuZXh0X21lbnUuaG1lbnVOZXh0ID0gMDsKICAgICAgICBuZXh0X21lbnUuaHduZE5leHQgPSAwOwogICAgICAgIFNlbmRNZXNzYWdlVyggcG10LT5oT3duZXJXbmQsIFdNX05FWFRNRU5VLCB2aywgKExQQVJBTSkmbmV4dF9tZW51ICk7CgogICAgICAgIFRSQUNFKCIlcCBbJXBdIC0+ICVwIFslcF1cbiIsCiAgICAgICAgICAgICAgcG10LT5oQ3VycmVudE1lbnUsIHBtdC0+aE93bmVyV25kLCBuZXh0X21lbnUuaG1lbnVOZXh0LCBuZXh0X21lbnUuaHduZE5leHQgKTsKCglpZiAoIW5leHRfbWVudS5obWVudU5leHQgfHwgIW5leHRfbWVudS5od25kTmV4dCkKCXsKICAgICAgICAgICAgRFdPUkQgc3R5bGUgPSBHZXRXaW5kb3dMb25nVyggcG10LT5oT3duZXJXbmQsIEdXTF9TVFlMRSApOwoJICAgIGhOZXdXbmQgPSBwbXQtPmhPd25lclduZDsKCSAgICBpZiggSVNfU1lTVEVNX01FTlUobWVudSkgKQoJICAgIHsKCQkvKiBzd2l0Y2ggdG8gdGhlIG1lbnUgYmFyICovCgogICAgICAgICAgICAgICAgaWYoc3R5bGUgJiBXU19DSElMRCB8fCAhKGhOZXdNZW51ID0gR2V0TWVudShoTmV3V25kKSkpIHJldHVybiBGQUxTRTsKCgkgICAgICAgIGlmKCB2ayA9PSBWS19MRUZUICkKCSAgICAgICAgewoJCSAgICBtZW51ID0gTUVOVV9HZXRNZW51KCBoTmV3TWVudSApOwoJCSAgICBpZCA9IG1lbnUtPm5JdGVtcyAtIDE7CgkgICAgICAgIH0KCSAgICB9CgkgICAgZWxzZSBpZiAoc3R5bGUgJiBXU19TWVNNRU5VICkKCSAgICB7CgkJLyogc3dpdGNoIHRvIHRoZSBzeXN0ZW0gbWVudSAqLwoJICAgICAgICBoTmV3TWVudSA9IGdldF93aW5fc3lzX21lbnUoIGhOZXdXbmQgKTsKCSAgICB9CiAgICAgICAgICAgIGVsc2UgcmV0dXJuIEZBTFNFOwoJfQoJZWxzZSAgICAvKiBhcHBsaWNhdGlvbiByZXR1cm5lZCBhIG5ldyBtZW51IHRvIHN3aXRjaCB0byAqLwoJewogICAgICAgICAgICBoTmV3TWVudSA9IG5leHRfbWVudS5obWVudU5leHQ7CiAgICAgICAgICAgIGhOZXdXbmQgPSBXSU5fR2V0RnVsbEhhbmRsZSggbmV4dF9tZW51Lmh3bmROZXh0ICk7CgoJICAgIGlmKCBJc01lbnUoaE5ld01lbnUpICYmIElzV2luZG93KGhOZXdXbmQpICkKCSAgICB7CiAgICAgICAgICAgICAgICBEV09SRCBzdHlsZSA9IEdldFdpbmRvd0xvbmdXKCBoTmV3V25kLCBHV0xfU1RZTEUgKTsKCgkJaWYgKHN0eWxlICYgV1NfU1lTTUVOVSAmJgoJCSAgICBHZXRTdWJNZW51KGdldF93aW5fc3lzX21lbnUoaE5ld1duZCksIDApID09IGhOZXdNZW51ICkKCQl7CgkgICAgICAgICAgICAvKiBnZXQgdGhlIHJlYWwgc3lzdGVtIG1lbnUgKi8KCQkgICAgaE5ld01lbnUgPSAgZ2V0X3dpbl9zeXNfbWVudShoTmV3V25kKTsKCQl9CgkgICAgICAgIGVsc2UgaWYgKHN0eWxlICYgV1NfQ0hJTEQgfHwgR2V0TWVudShoTmV3V25kKSAhPSBoTmV3TWVudSApCgkJewoJCSAgICAvKiBGSVhNRTogTm90IHN1cmUgd2hhdCB0byBkbyBoZXJlOwoJCSAgICAgKiBwZXJoYXBzIHRyeSB0byB0cmFjayBoTmV3TWVudSBhcyBhIHBvcHVwPyAqLwoKCQkgICAgVFJBQ0UoIiAtLSBnb3QgY29uZnVzZWQuXG4iKTsKCQkgICAgcmV0dXJuIEZBTFNFOwoJCX0KCSAgICB9CgkgICAgZWxzZSByZXR1cm4gRkFMU0U7Cgl9CgoJaWYoIGhOZXdNZW51ICE9IHBtdC0+aFRvcE1lbnUgKQoJewoJICAgIE1FTlVfU2VsZWN0SXRlbSggcG10LT5oT3duZXJXbmQsIHBtdC0+aFRvcE1lbnUsIE5PX1NFTEVDVEVEX0lURU0sCiAgICAgICAgICAgICAgICAgICAgRkFMU0UsIDAgKTsKCSAgICBpZiggcG10LT5oQ3VycmVudE1lbnUgIT0gcG10LT5oVG9wTWVudSApCgkJTUVOVV9IaWRlU3ViUG9wdXBzKCBwbXQtPmhPd25lclduZCwgcG10LT5oVG9wTWVudSwgRkFMU0UgKTsKCX0KCglpZiggaE5ld1duZCAhPSBwbXQtPmhPd25lclduZCApCgl7CgkgICAgcG10LT5oT3duZXJXbmQgPSBoTmV3V25kOwoJICAgIE1FTlVfU2V0Q2FwdHVyZSggcG10LT5oT3duZXJXbmQgKTsKCX0KCglwbXQtPmhUb3BNZW51ID0gcG10LT5oQ3VycmVudE1lbnUgPSBoTmV3TWVudTsgLyogYWxsIHN1YnBvcHVwcyBhcmUgaGlkZGVuICovCglNRU5VX1NlbGVjdEl0ZW0oIHBtdC0+aE93bmVyV25kLCBwbXQtPmhUb3BNZW51LCBpZCwgVFJVRSwgMCApOwoKCXJldHVybiBUUlVFOwogICAgfQogICAgcmV0dXJuIEZBTFNFOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfU3VzcGVuZFBvcHVwCiAqCiAqIFRoZSBpZGVhIGlzIG5vdCB0byBzaG93IHRoZSBwb3B1cCBpZiB0aGUgbmV4dCBpbnB1dCBtZXNzYWdlIGlzCiAqIGdvaW5nIHRvIGhpZGUgaXQgYW55d2F5LgogKi8Kc3RhdGljIEJPT0wgTUVOVV9TdXNwZW5kUG9wdXAoIE1UUkFDS0VSKiBwbXQsIFVJTlQxNiB1TXNnICkKewogICAgTVNHIG1zZzsKCiAgICBtc2cuaHduZCA9IHBtdC0+aE93bmVyV25kOwoKICAgIFBlZWtNZXNzYWdlVyggJm1zZywgMCwgMCwgMCwgUE1fTk9ZSUVMRCB8IFBNX1JFTU9WRSk7CiAgICBwbXQtPnRyYWNrRmxhZ3MgfD0gVEZfU0tJUFJFTU9WRTsKCiAgICBzd2l0Y2goIHVNc2cgKQogICAgewoJY2FzZSBXTV9LRVlET1dOOgoJICAgICBQZWVrTWVzc2FnZVcoICZtc2csIDAsIDAsIDAsIFBNX05PWUlFTEQgfCBQTV9OT1JFTU9WRSk7CgkgICAgIGlmKCBtc2cubWVzc2FnZSA9PSBXTV9LRVlVUCB8fCBtc2cubWVzc2FnZSA9PSBXTV9QQUlOVCApCgkgICAgIHsKCQkgUGVla01lc3NhZ2VXKCAmbXNnLCAwLCAwLCAwLCBQTV9OT1lJRUxEIHwgUE1fUkVNT1ZFKTsKCSAgICAgICAgIFBlZWtNZXNzYWdlVyggJm1zZywgMCwgMCwgMCwgUE1fTk9ZSUVMRCB8IFBNX05PUkVNT1ZFKTsKCSAgICAgICAgIGlmKCBtc2cubWVzc2FnZSA9PSBXTV9LRVlET1dOICYmCgkJICAgIChtc2cud1BhcmFtID09IFZLX0xFRlQgfHwgbXNnLndQYXJhbSA9PSBWS19SSUdIVCkpCgkgICAgICAgICB7CgkJICAgICBwbXQtPnRyYWNrRmxhZ3MgfD0gVEZfU1VTUEVORFBPUFVQOwoJCSAgICAgcmV0dXJuIFRSVUU7CgkgICAgICAgICB9CgkgICAgIH0KCSAgICAgYnJlYWs7CiAgICB9CgogICAgLyogZmFpbHVyZXMgZ28gdGhyb3VnaCB0aGlzICovCiAgICBwbXQtPnRyYWNrRmxhZ3MgJj0gflRGX1NVU1BFTkRQT1BVUDsKICAgIHJldHVybiBGQUxTRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0tleUVzY2FwZQogKgogKiBIYW5kbGUgYSBWS19FU0NBUEUga2V5IGV2ZW50IGluIGEgbWVudS4KICovCnN0YXRpYyBCT09MIE1FTlVfS2V5RXNjYXBlKE1UUkFDS0VSKiBwbXQsIFVJTlQgd0ZsYWdzKQp7CiAgICBCT09MIGJFbmRNZW51ID0gVFJVRTsKCiAgICBpZiAocG10LT5oQ3VycmVudE1lbnUgIT0gcG10LT5oVG9wTWVudSkKICAgIHsKICAgICAgICBQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUocG10LT5oQ3VycmVudE1lbnUpOwoKICAgICAgICBpZiAobWVudS0+d0ZsYWdzICYgTUZfUE9QVVApCiAgICAgICAgewogICAgICAgICAgICBITUVOVSBobWVudXRtcCwgaG1lbnVwcmV2OwoKICAgICAgICAgICAgaG1lbnVwcmV2ID0gaG1lbnV0bXAgPSBwbXQtPmhUb3BNZW51OwoKICAgICAgICAgICAgLyogY2xvc2UgdG9wbW9zdCBwb3B1cCAqLwogICAgICAgICAgICB3aGlsZSAoaG1lbnV0bXAgIT0gcG10LT5oQ3VycmVudE1lbnUpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIGhtZW51cHJldiA9IGhtZW51dG1wOwogICAgICAgICAgICAgICAgaG1lbnV0bXAgPSBNRU5VX0dldFN1YlBvcHVwKCBobWVudXByZXYgKTsKICAgICAgICAgICAgfQoKICAgICAgICAgICAgTUVOVV9IaWRlU3ViUG9wdXBzKCBwbXQtPmhPd25lclduZCwgaG1lbnVwcmV2LCBUUlVFICk7CiAgICAgICAgICAgIHBtdC0+aEN1cnJlbnRNZW51ID0gaG1lbnVwcmV2OwogICAgICAgICAgICBiRW5kTWVudSA9IEZBTFNFOwogICAgICAgIH0KICAgIH0KCiAgICByZXR1cm4gYkVuZE1lbnU7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9LZXlMZWZ0CiAqCiAqIEhhbmRsZSBhIFZLX0xFRlQga2V5IGV2ZW50IGluIGEgbWVudS4KICovCnN0YXRpYyB2b2lkIE1FTlVfS2V5TGVmdCggTVRSQUNLRVIqIHBtdCwgVUlOVCB3RmxhZ3MgKQp7CiAgICBQT1BVUE1FTlUgKm1lbnU7CiAgICBITUVOVSBobWVudXRtcCwgaG1lbnVwcmV2OwogICAgVUlOVCAgcHJldmNvbDsKCiAgICBobWVudXByZXYgPSBobWVudXRtcCA9IHBtdC0+aFRvcE1lbnU7CiAgICBtZW51ID0gTUVOVV9HZXRNZW51KCBobWVudXRtcCApOwoKICAgIC8qIFRyeSB0byBtb3ZlIDEgY29sdW1uIGxlZnQgKGlmIHBvc3NpYmxlKSAqLwogICAgaWYoIChwcmV2Y29sID0gTUVOVV9HZXRTdGFydE9mUHJldkNvbHVtbiggcG10LT5oQ3VycmVudE1lbnUgKSkgIT0KCU5PX1NFTEVDVEVEX0lURU0gKSB7CgoJTUVOVV9TZWxlY3RJdGVtKCBwbXQtPmhPd25lclduZCwgcG10LT5oQ3VycmVudE1lbnUsCgkJCSBwcmV2Y29sLCBUUlVFLCAwICk7CglyZXR1cm47CiAgICB9CgogICAgLyogY2xvc2UgdG9wbW9zdCBwb3B1cCAqLwogICAgd2hpbGUgKGhtZW51dG1wICE9IHBtdC0+aEN1cnJlbnRNZW51KQogICAgewoJaG1lbnVwcmV2ID0gaG1lbnV0bXA7CglobWVudXRtcCA9IE1FTlVfR2V0U3ViUG9wdXAoIGhtZW51cHJldiApOwogICAgfQoKICAgIE1FTlVfSGlkZVN1YlBvcHVwcyggcG10LT5oT3duZXJXbmQsIGhtZW51cHJldiwgVFJVRSApOwogICAgcG10LT5oQ3VycmVudE1lbnUgPSBobWVudXByZXY7CgogICAgaWYgKCAoaG1lbnVwcmV2ID09IHBtdC0+aFRvcE1lbnUpICYmICEobWVudS0+d0ZsYWdzICYgTUZfUE9QVVApICkKICAgIHsKCS8qIG1vdmUgbWVudSBiYXIgc2VsZWN0aW9uIGlmIG5vIG1vcmUgcG9wdXBzIGFyZSBsZWZ0ICovCgoJaWYoICFNRU5VX0RvTmV4dE1lbnUoIHBtdCwgVktfTEVGVCkgKQoJICAgICBNRU5VX01vdmVTZWxlY3Rpb24oIHBtdC0+aE93bmVyV25kLCBwbXQtPmhUb3BNZW51LCBJVEVNX1BSRVYgKTsKCglpZiAoIGhtZW51cHJldiAhPSBobWVudXRtcCB8fCBwbXQtPnRyYWNrRmxhZ3MgJiBURl9TVVNQRU5EUE9QVVAgKQoJewoJICAgLyogQSBzdWJsZXZlbCBtZW51IHdhcyBkaXNwbGF5ZWQgLSBkaXNwbGF5IHRoZSBuZXh0IG9uZQoJICAgICogdW5sZXNzIHRoZXJlIGlzIGFub3RoZXIgZGlzcGxhY2VtZW50IGNvbWluZyB1cCAqLwoKCSAgICBpZiggIU1FTlVfU3VzcGVuZFBvcHVwKCBwbXQsIFdNX0tFWURPV04gKSApCgkJcG10LT5oQ3VycmVudE1lbnUgPSBNRU5VX1Nob3dTdWJQb3B1cChwbXQtPmhPd25lclduZCwKCQkJCQkJcG10LT5oVG9wTWVudSwgVFJVRSwgd0ZsYWdzKTsKCX0KICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9LZXlSaWdodAogKgogKiBIYW5kbGUgYSBWS19SSUdIVCBrZXkgZXZlbnQgaW4gYSBtZW51LgogKi8Kc3RhdGljIHZvaWQgTUVOVV9LZXlSaWdodCggTVRSQUNLRVIqIHBtdCwgVUlOVCB3RmxhZ3MgKQp7CiAgICBITUVOVSBobWVudXRtcDsKICAgIFBPUFVQTUVOVSAqbWVudSA9IE1FTlVfR2V0TWVudSggcG10LT5oVG9wTWVudSApOwogICAgVUlOVCAgbmV4dGNvbDsKCiAgICBUUkFDRSgiTUVOVV9LZXlSaWdodCBjYWxsZWQsIGN1ciAlcCAoJXMpLCB0b3AgJXAgKCVzKS5cbiIsCiAgICAgICAgICBwbXQtPmhDdXJyZW50TWVudSwKICAgICAgICAgIGRlYnVnc3RyX3coKE1FTlVfR2V0TWVudShwbXQtPmhDdXJyZW50TWVudSkpLT5pdGVtc1swXS50ZXh0KSwKICAgICAgICAgIHBtdC0+aFRvcE1lbnUsIGRlYnVnc3RyX3cobWVudS0+aXRlbXNbMF0udGV4dCkgKTsKCiAgICBpZiAoIChtZW51LT53RmxhZ3MgJiBNRl9QT1BVUCkgfHwgKHBtdC0+aEN1cnJlbnRNZW51ICE9IHBtdC0+aFRvcE1lbnUpKQogICAgewoJLyogSWYgYWxyZWFkeSBkaXNwbGF5aW5nIGEgcG9wdXAsIHRyeSB0byBkaXNwbGF5IHN1Yi1wb3B1cCAqLwoKCWhtZW51dG1wID0gcG10LT5oQ3VycmVudE1lbnU7CglwbXQtPmhDdXJyZW50TWVudSA9IE1FTlVfU2hvd1N1YlBvcHVwKHBtdC0+aE93bmVyV25kLCBobWVudXRtcCwgVFJVRSwgd0ZsYWdzKTsKCgkvKiBpZiBzdWJwb3B1cCB3YXMgZGlzcGxheWVkIHRoZW4gd2UgYXJlIGRvbmUgKi8KCWlmIChobWVudXRtcCAhPSBwbXQtPmhDdXJyZW50TWVudSkgcmV0dXJuOwogICAgfQoKICAgIC8qIENoZWNrIHRvIHNlZSBpZiB0aGVyZSdzIGFub3RoZXIgY29sdW1uICovCiAgICBpZiggKG5leHRjb2wgPSBNRU5VX0dldFN0YXJ0T2ZOZXh0Q29sdW1uKCBwbXQtPmhDdXJyZW50TWVudSApKSAhPQoJTk9fU0VMRUNURURfSVRFTSApIHsKCVRSQUNFKCJHb2luZyB0byAlZC5cbiIsIG5leHRjb2wgKTsKCU1FTlVfU2VsZWN0SXRlbSggcG10LT5oT3duZXJXbmQsIHBtdC0+aEN1cnJlbnRNZW51LAoJCQkgbmV4dGNvbCwgVFJVRSwgMCApOwoJcmV0dXJuOwogICAgfQoKICAgIGlmICghKG1lbnUtPndGbGFncyAmIE1GX1BPUFVQKSkJLyogbWVudSBiYXIgdHJhY2tpbmcgKi8KICAgIHsKCWlmKCBwbXQtPmhDdXJyZW50TWVudSAhPSBwbXQtPmhUb3BNZW51ICkKCXsKCSAgICBNRU5VX0hpZGVTdWJQb3B1cHMoIHBtdC0+aE93bmVyV25kLCBwbXQtPmhUb3BNZW51LCBGQUxTRSApOwoJICAgIGhtZW51dG1wID0gcG10LT5oQ3VycmVudE1lbnUgPSBwbXQtPmhUb3BNZW51OwoJfSBlbHNlIGhtZW51dG1wID0gMDsKCgkvKiB0cnkgdG8gbW92ZSB0byB0aGUgbmV4dCBpdGVtICovCglpZiggIU1FTlVfRG9OZXh0TWVudSggcG10LCBWS19SSUdIVCkgKQoJICAgICBNRU5VX01vdmVTZWxlY3Rpb24oIHBtdC0+aE93bmVyV25kLCBwbXQtPmhUb3BNZW51LCBJVEVNX05FWFQgKTsKCglpZiggaG1lbnV0bXAgfHwgcG10LT50cmFja0ZsYWdzICYgVEZfU1VTUEVORFBPUFVQICkKCSAgICBpZiggIU1FTlVfU3VzcGVuZFBvcHVwKHBtdCwgV01fS0VZRE9XTikgKQoJCXBtdC0+aEN1cnJlbnRNZW51ID0gTUVOVV9TaG93U3ViUG9wdXAocG10LT5oT3duZXJXbmQsCgkJCQkJCSAgICAgICBwbXQtPmhUb3BNZW51LCBUUlVFLCB3RmxhZ3MpOwogICAgfQp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfVHJhY2tNZW51CiAqCiAqIE1lbnUgdHJhY2tpbmcgY29kZS4KICovCnN0YXRpYyBCT09MIE1FTlVfVHJhY2tNZW51KCBITUVOVSBobWVudSwgVUlOVCB3RmxhZ3MsIElOVCB4LCBJTlQgeSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgIEhXTkQgaHduZCwgY29uc3QgUkVDVCAqbHByZWN0ICkKewogICAgTVNHIG1zZzsKICAgIFBPUFVQTUVOVSAqbWVudTsKICAgIEJPT0wgZlJlbW92ZTsKICAgIElOVCBleGVjdXRlZE1lbnVJZCA9IC0xOwogICAgTVRSQUNLRVIgbXQ7CiAgICBCT09MIGVudGVySWRsZVNlbnQgPSBGQUxTRTsKCiAgICBtdC50cmFja0ZsYWdzID0gMDsKICAgIG10LmhDdXJyZW50TWVudSA9IGhtZW51OwogICAgbXQuaFRvcE1lbnUgPSBobWVudTsKICAgIG10LmhPd25lclduZCA9IFdJTl9HZXRGdWxsSGFuZGxlKCBod25kICk7CiAgICBtdC5wdC54ID0geDsKICAgIG10LnB0LnkgPSB5OwoKICAgIFRSQUNFKCJobWVudT0lcCBmbGFncz0weCUwOHggKCVkLCVkKSBod25kPSVwICVzXG4iLAogICAgICAgICAgaG1lbnUsIHdGbGFncywgeCwgeSwgaHduZCwgd2luZV9kYmdzdHJfcmVjdCggbHByZWN0KSk7CgogICAgZkVuZE1lbnUgPSBGQUxTRTsKICAgIGlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoIGhtZW51ICkpKQogICAgewogICAgICAgIFdBUk4oIkludmFsaWQgbWVudSBoYW5kbGUgJXBcbiIsIGhtZW51KTsKICAgICAgICBTZXRMYXN0RXJyb3IoRVJST1JfSU5WQUxJRF9NRU5VX0hBTkRMRSk7CiAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgfQoKICAgIGlmICh3RmxhZ3MgJiBUUE1fQlVUVE9ORE9XTikKICAgIHsKCS8qIEdldCB0aGUgcmVzdWx0IGluIG9yZGVyIHRvIHN0YXJ0IHRoZSB0cmFja2luZyBvciBub3QgKi8KCWZSZW1vdmUgPSBNRU5VX0J1dHRvbkRvd24oICZtdCwgaG1lbnUsIHdGbGFncyApOwoJZkVuZE1lbnUgPSAhZlJlbW92ZTsKICAgIH0KCiAgICBpZiAod0ZsYWdzICYgVEZfRU5ETUVOVSkgZkVuZE1lbnUgPSBUUlVFOwoKICAgIE1FTlVfU2V0Q2FwdHVyZSggbXQuaE93bmVyV25kICk7CgogICAgd2hpbGUgKCFmRW5kTWVudSkKICAgIHsKCW1lbnUgPSBNRU5VX0dldE1lbnUoIG10LmhDdXJyZW50TWVudSApOwoJaWYgKCFtZW51KSAvKiBzb21ldGltZXMgaGFwcGVucyBpZiBJIGRvIGEgd2luZG93IG1hbmFnZXIgY2xvc2UgKi8KCSAgICBicmVhazsKCgkvKiB3ZSBoYXZlIHRvIGtlZXAgdGhlIG1lc3NhZ2UgaW4gdGhlIHF1ZXVlIHVudGlsIGl0J3MKCSAqIGNsZWFyIHRoYXQgbWVudSBsb29wIGlzIG5vdCBvdmVyIHlldC4gKi8KCiAgICAgICAgZm9yICg7OykKICAgICAgICB7CiAgICAgICAgICAgIGlmIChQZWVrTWVzc2FnZVcoICZtc2csIDAsIDAsIDAsIFBNX05PUkVNT1ZFICkpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIGlmICghQ2FsbE1zZ0ZpbHRlclcoICZtc2csIE1TR0ZfTUVOVSApKSBicmVhazsKICAgICAgICAgICAgICAgIC8qIHJlbW92ZSB0aGUgbWVzc2FnZSBmcm9tIHRoZSBxdWV1ZSAqLwogICAgICAgICAgICAgICAgUGVla01lc3NhZ2VXKCAmbXNnLCAwLCBtc2cubWVzc2FnZSwgbXNnLm1lc3NhZ2UsIFBNX1JFTU9WRSApOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgaWYgKCFlbnRlcklkbGVTZW50KQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIEhXTkQgd2luID0gKHdGbGFncyAmIFRQTV9FTlRFUklETEVFWCAmJiBtZW51LT53RmxhZ3MgJiBNRl9QT1BVUCkgPyBtZW51LT5oV25kIDogMDsKICAgICAgICAgICAgICAgICAgICBlbnRlcklkbGVTZW50ID0gVFJVRTsKICAgICAgICAgICAgICAgICAgICBTZW5kTWVzc2FnZVcoIG10LmhPd25lclduZCwgV01fRU5URVJJRExFLCBNU0dGX01FTlUsIChMUEFSQU0pd2luICk7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICBXYWl0TWVzc2FnZSgpOwogICAgICAgICAgICB9CiAgICAgICAgfQoKCS8qIGNoZWNrIGlmIEVuZE1lbnUoKSB0cmllZCB0byBjYW5jZWwgdXMsIGJ5IHBvc3RpbmcgdGhpcyBtZXNzYWdlICovCiAgICAgICAgaWYobXNnLm1lc3NhZ2UgPT0gV01fQ0FOQ0VMTU9ERSkKCXsKCSAgICAvKiB3ZSBhcmUgbm93IG91dCBvZiB0aGUgbG9vcCAqLwogICAgCSAgICBmRW5kTWVudSA9IFRSVUU7CgoJICAgIC8qIHJlbW92ZSB0aGUgbWVzc2FnZSBmcm9tIHRoZSBxdWV1ZSAqLwoJICAgIFBlZWtNZXNzYWdlVyggJm1zZywgMCwgbXNnLm1lc3NhZ2UsIG1zZy5tZXNzYWdlLCBQTV9SRU1PVkUgKTsKCgkgICAgLyogYnJlYWsgb3V0IG9mIGludGVybmFsIGxvb3AsIGFsYSBFU0NBUEUgKi8KCSAgICBicmVhazsKCX0KCiAgICAgICAgVHJhbnNsYXRlTWVzc2FnZSggJm1zZyApOwogICAgICAgIG10LnB0ID0gbXNnLnB0OwoKCWlmICggKG1zZy5od25kPT1tZW51LT5oV25kKSB8fCAobXNnLm1lc3NhZ2UhPVdNX1RJTUVSKSApCgkgIGVudGVySWRsZVNlbnQ9RkFMU0U7CgogICAgICAgIGZSZW1vdmUgPSBGQUxTRTsKCWlmICgobXNnLm1lc3NhZ2UgPj0gV01fTU9VU0VGSVJTVCkgJiYgKG1zZy5tZXNzYWdlIDw9IFdNX01PVVNFTEFTVCkpCgl7CiAgICAgICAgICAgIC8qCiAgICAgICAgICAgICAqIFVzZSB0aGUgbW91c2UgY29vcmRpbmF0ZXMgaW4gbFBhcmFtIGluc3RlYWQgb2YgdGhvc2UgaW4gdGhlIE1TRwogICAgICAgICAgICAgKiBzdHJ1Y3QgdG8gcHJvcGVybHkgaGFuZGxlIHN5bnRoZXRpYyBtZXNzYWdlcy4gVGhleSBhcmUgYWxyZWFkeQogICAgICAgICAgICAgKiBpbiBzY3JlZW4gY29vcmRpbmF0ZXMuCiAgICAgICAgICAgICAqLwogICAgICAgICAgICBtdC5wdC54ID0gKHNob3J0KUxPV09SRChtc2cubFBhcmFtKTsKICAgICAgICAgICAgbXQucHQueSA9IChzaG9ydClISVdPUkQobXNnLmxQYXJhbSk7CgoJICAgIC8qIEZpbmQgYSBtZW51IGZvciB0aGlzIG1vdXNlIGV2ZW50ICovCgkgICAgaG1lbnUgPSBNRU5VX1B0TWVudSggbXQuaFRvcE1lbnUsIG10LnB0ICk7CgoJICAgIHN3aXRjaChtc2cubWVzc2FnZSkKCSAgICB7CgkJLyogbm8gV01fTkMuLi4gbWVzc2FnZXMgaW4gY2FwdHVyZWQgc3RhdGUgKi8KCgkJY2FzZSBXTV9SQlVUVE9OREJMQ0xLOgoJCWNhc2UgV01fUkJVVFRPTkRPV046CgkJICAgIGlmICghKHdGbGFncyAmIFRQTV9SSUdIVEJVVFRPTikpIGJyZWFrOwoJCSAgICAvKiBmYWxsIHRocm91Z2ggKi8KCQljYXNlIFdNX0xCVVRUT05EQkxDTEs6CgkJY2FzZSBXTV9MQlVUVE9ORE9XTjoKCQkgICAgLyogSWYgdGhlIG1lc3NhZ2UgYmVsb25ncyB0byB0aGUgbWVudSwgcmVtb3ZlcyBpdCBmcm9tIHRoZSBxdWV1ZSAqLwoJCSAgICAvKiBFbHNlLCBlbmQgbWVudSB0cmFja2luZyAqLwoJCSAgICBmUmVtb3ZlID0gTUVOVV9CdXR0b25Eb3duKCAmbXQsIGhtZW51LCB3RmxhZ3MgKTsKCQkgICAgZkVuZE1lbnUgPSAhZlJlbW92ZTsKCQkgICAgYnJlYWs7CgoJCWNhc2UgV01fUkJVVFRPTlVQOgoJCSAgICBpZiAoISh3RmxhZ3MgJiBUUE1fUklHSFRCVVRUT04pKSBicmVhazsKCQkgICAgLyogZmFsbCB0aHJvdWdoICovCgkJY2FzZSBXTV9MQlVUVE9OVVA6CgkJICAgIC8qIENoZWNrIGlmIGEgbWVudSB3YXMgc2VsZWN0ZWQgYnkgdGhlIG1vdXNlICovCgkJICAgIGlmIChobWVudSkKCQkgICAgewogICAgICAgICAgICAgICAgICAgICAgICBleGVjdXRlZE1lbnVJZCA9IE1FTlVfQnV0dG9uVXAoICZtdCwgaG1lbnUsIHdGbGFncyk7CiAgICAgICAgICAgICAgICAgICAgICAgIFRSQUNFKCJleGVjdXRlZE1lbnVJZCAlZFxuIiwgZXhlY3V0ZWRNZW51SWQpOwoKCQkJLyogRW5kIHRoZSBsb29wIGlmIGV4ZWN1dGVkTWVudUlkIGlzIGFuIGl0ZW0gSUQgKi8KCQkJLyogb3IgaWYgdGhlIGpvYiB3YXMgZG9uZSAoZXhlY3V0ZWRNZW51SWQgPSAwKS4gKi8KICAgICAgICAgICAgICAgICAgICAgICAgZkVuZE1lbnUgPSBmUmVtb3ZlID0gKGV4ZWN1dGVkTWVudUlkICE9IC0xKTsKCQkgICAgfQogICAgICAgICAgICAgICAgICAgIC8qIE5vIG1lbnUgd2FzIHNlbGVjdGVkIGJ5IHRoZSBtb3VzZSAqLwogICAgICAgICAgICAgICAgICAgIC8qIGlmIHRoZSBmdW5jdGlvbiB3YXMgY2FsbGVkIGJ5IFRyYWNrUG9wdXBNZW51LCBjb250aW51ZQogICAgICAgICAgICAgICAgICAgICAgIHdpdGggdGhlIG1lbnUgdHJhY2tpbmcuIElmIG5vdCwgc3RvcCBpdCAqLwogICAgICAgICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgICAgICAgICAgZkVuZE1lbnUgPSAoKHdGbGFncyAmIFRQTV9QT1BVUE1FTlUpID8gRkFMU0UgOiBUUlVFKTsKCgkJICAgIGJyZWFrOwoKCQljYXNlIFdNX01PVVNFTU9WRToKICAgICAgICAgICAgICAgICAgICAvKiB0aGUgc2VsZWN0ZWQgbWVudSBpdGVtIG11c3QgYmUgY2hhbmdlZCBldmVyeSB0aW1lICovCgkJICAgICAvKiB0aGUgbW91c2UgbW92ZXMuICovCgogICAgICAgICAgICAgICAgICAgIGlmIChobWVudSkKCQkJZkVuZE1lbnUgfD0gIU1FTlVfTW91c2VNb3ZlKCAmbXQsIGhtZW51LCB3RmxhZ3MgKTsKCgkgICAgfSAvKiBzd2l0Y2gobXNnLm1lc3NhZ2UpIC0gbW91c2UgKi8KCX0KCWVsc2UgaWYgKChtc2cubWVzc2FnZSA+PSBXTV9LRVlGSVJTVCkgJiYgKG1zZy5tZXNzYWdlIDw9IFdNX0tFWUxBU1QpKQoJewogICAgICAgICAgICBmUmVtb3ZlID0gVFJVRTsgIC8qIEtleWJvYXJkIG1lc3NhZ2VzIGFyZSBhbHdheXMgcmVtb3ZlZCAqLwoJICAgIHN3aXRjaChtc2cubWVzc2FnZSkKCSAgICB7CgkgICAgY2FzZSBXTV9LRVlET1dOOgoJICAgIGNhc2UgV01fU1lTS0VZRE9XTjoKCQlzd2l0Y2gobXNnLndQYXJhbSkKCQl7CgkJY2FzZSBWS19NRU5VOgoJCSAgICBmRW5kTWVudSA9IFRSVUU7CgkJICAgIGJyZWFrOwoKCQljYXNlIFZLX0hPTUU6CgkJY2FzZSBWS19FTkQ6CgkJICAgIE1FTlVfU2VsZWN0SXRlbSggbXQuaE93bmVyV25kLCBtdC5oQ3VycmVudE1lbnUsCgkJCQkgICAgIE5PX1NFTEVDVEVEX0lURU0sIEZBTFNFLCAwICk7CgkJICAgIE1FTlVfTW92ZVNlbGVjdGlvbiggbXQuaE93bmVyV25kLCBtdC5oQ3VycmVudE1lbnUsCgkJCQkgICAgICAgKG1zZy53UGFyYW0gPT0gVktfSE9NRSk/IElURU1fTkVYVCA6IElURU1fUFJFViApOwoJCSAgICBicmVhazsKCgkJY2FzZSBWS19VUDoKCQljYXNlIFZLX0RPV046IC8qIElmIG9uIG1lbnUgYmFyLCBwdWxsLWRvd24gdGhlIG1lbnUgKi8KCgkJICAgIG1lbnUgPSBNRU5VX0dldE1lbnUoIG10LmhDdXJyZW50TWVudSApOwoJCSAgICBpZiAoIShtZW51LT53RmxhZ3MgJiBNRl9QT1BVUCkpCgkJCW10LmhDdXJyZW50TWVudSA9IE1FTlVfU2hvd1N1YlBvcHVwKG10LmhPd25lclduZCwgbXQuaFRvcE1lbnUsIFRSVUUsIHdGbGFncyk7CgkJICAgIGVsc2UgICAgICAvKiBvdGhlcndpc2UgdHJ5IHRvIG1vdmUgc2VsZWN0aW9uICovCgkJCU1FTlVfTW92ZVNlbGVjdGlvbiggbXQuaE93bmVyV25kLCBtdC5oQ3VycmVudE1lbnUsIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAobXNnLndQYXJhbSA9PSBWS19VUCk/IElURU1fUFJFViA6IElURU1fTkVYVCApOwoJCSAgICBicmVhazsKCgkJY2FzZSBWS19MRUZUOgoJCSAgICBNRU5VX0tleUxlZnQoICZtdCwgd0ZsYWdzICk7CgkJICAgIGJyZWFrOwoKCQljYXNlIFZLX1JJR0hUOgoJCSAgICBNRU5VX0tleVJpZ2h0KCAmbXQsIHdGbGFncyApOwoJCSAgICBicmVhazsKCgkJY2FzZSBWS19FU0NBUEU6CiAgICAgICAgICAgICAgICAgICAgZkVuZE1lbnUgPSBNRU5VX0tleUVzY2FwZSgmbXQsIHdGbGFncyk7CgkJICAgIGJyZWFrOwoKCQljYXNlIFZLX0YxOgoJCSAgICB7CgkJCUhFTFBJTkZPIGhpOwoJCQloaS5jYlNpemUgPSBzaXplb2YoSEVMUElORk8pOwoJCQloaS5pQ29udGV4dFR5cGUgPSBIRUxQSU5GT19NRU5VSVRFTTsKCQkJaWYgKG1lbnUtPkZvY3VzZWRJdGVtID09IE5PX1NFTEVDVEVEX0lURU0pCgkJCSAgICBoaS5pQ3RybElkID0gMDsKCQkgICAgICAgIGVsc2UKCQkJICAgIGhpLmlDdHJsSWQgPSBtZW51LT5pdGVtc1ttZW51LT5Gb2N1c2VkSXRlbV0ud0lEOwoJCQloaS5oSXRlbUhhbmRsZSA9IGhtZW51OwoJCQloaS5kd0NvbnRleHRJZCA9IG1lbnUtPmR3Q29udGV4dEhlbHBJRDsKCQkJaGkuTW91c2VQb3MgPSBtc2cucHQ7CgkJCVNlbmRNZXNzYWdlVyhod25kLCBXTV9IRUxQLCAwLCAoTFBBUkFNKSZoaSk7CgkJCWJyZWFrOwoJCSAgICB9CgoJCWRlZmF1bHQ6CgkJICAgIGJyZWFrOwoJCX0KCQlicmVhazsgIC8qIFdNX0tFWURPV04gKi8KCgkgICAgY2FzZSBXTV9DSEFSOgoJICAgIGNhc2UgV01fU1lTQ0hBUjoKCQl7CgkJICAgIFVJTlQJcG9zOwoKCQkgICAgaWYgKG1zZy53UGFyYW0gPT0gJ1xyJyB8fCBtc2cud1BhcmFtID09ICcgJykKCQkgICAgewogICAgICAgICAgICAgICAgICAgICAgICBleGVjdXRlZE1lbnVJZCA9IE1FTlVfRXhlY0ZvY3VzZWRJdGVtKCZtdCxtdC5oQ3VycmVudE1lbnUsIHdGbGFncyk7CiAgICAgICAgICAgICAgICAgICAgICAgIGZFbmRNZW51ID0gKGV4ZWN1dGVkTWVudUlkICE9IC0yKTsKCgkJCWJyZWFrOwoJCSAgICB9CgoJCSAgICAgIC8qIEhhY2sgdG8gYXZvaWQgY29udHJvbCBjaGFycy4gKi8KCQkgICAgICAvKiBXZSB3aWxsIGZpbmQgYSBiZXR0ZXIgd2F5IHJlYWwgc29vbi4uLiAqLwoJCSAgICBpZiAobXNnLndQYXJhbSA8IDMyKSBicmVhazsKCgkJICAgIHBvcyA9IE1FTlVfRmluZEl0ZW1CeUtleSggbXQuaE93bmVyV25kLCBtdC5oQ3VycmVudE1lbnUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBMT1dPUkQobXNnLndQYXJhbSksIEZBTFNFICk7CgkJICAgIGlmIChwb3MgPT0gKFVJTlQpLTIpIGZFbmRNZW51ID0gVFJVRTsKCQkgICAgZWxzZSBpZiAocG9zID09IChVSU5UKS0xKSBNZXNzYWdlQmVlcCgwKTsKCQkgICAgZWxzZQoJCSAgICB7CgkJCU1FTlVfU2VsZWN0SXRlbSggbXQuaE93bmVyV25kLCBtdC5oQ3VycmVudE1lbnUsIHBvcywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBUUlVFLCAwICk7CiAgICAgICAgICAgICAgICAgICAgICAgIGV4ZWN1dGVkTWVudUlkID0gTUVOVV9FeGVjRm9jdXNlZEl0ZW0oJm10LG10LmhDdXJyZW50TWVudSwgd0ZsYWdzKTsKICAgICAgICAgICAgICAgICAgICAgICAgZkVuZE1lbnUgPSAoZXhlY3V0ZWRNZW51SWQgIT0gLTIpOwoJCSAgICB9CgkJfQoJCWJyZWFrOwoJICAgIH0gIC8qIHN3aXRjaChtc2cubWVzc2FnZSkgLSBrYmQgKi8KCX0KCWVsc2UKCXsKCSAgICBQZWVrTWVzc2FnZVcoICZtc2csIDAsIG1zZy5tZXNzYWdlLCBtc2cubWVzc2FnZSwgUE1fUkVNT1ZFICk7CgkgICAgRGlzcGF0Y2hNZXNzYWdlVyggJm1zZyApOwoJICAgIGNvbnRpbnVlOwoJfQoKCWlmICghZkVuZE1lbnUpIGZSZW1vdmUgPSBUUlVFOwoKCS8qIGZpbmFsbHkgcmVtb3ZlIG1lc3NhZ2UgZnJvbSB0aGUgcXVldWUgKi8KCiAgICAgICAgaWYgKGZSZW1vdmUgJiYgIShtdC50cmFja0ZsYWdzICYgVEZfU0tJUFJFTU9WRSkgKQoJICAgIFBlZWtNZXNzYWdlVyggJm1zZywgMCwgbXNnLm1lc3NhZ2UsIG1zZy5tZXNzYWdlLCBQTV9SRU1PVkUgKTsKCWVsc2UgbXQudHJhY2tGbGFncyAmPSB+VEZfU0tJUFJFTU9WRTsKICAgIH0KCiAgICBNRU5VX1NldENhcHR1cmUoMCk7ICAvKiByZWxlYXNlIHRoZSBjYXB0dXJlICovCgogICAgLyogSWYgZHJvcGRvd24gaXMgc3RpbGwgcGFpbnRlZCBhbmQgdGhlIGNsb3NlIGJveCBpcyBjbGlja2VkIG9uCiAgICAgICB0aGVuIHRoZSBtZW51IHdpbGwgYmUgZGVzdHJveWVkIGFzIHBhcnQgb2YgdGhlIERpc3BhdGNoTWVzc2FnZSBhYm92ZS4KICAgICAgIFRoaXMgd2lsbCB0aGVuIGludmFsaWRhdGUgdGhlIG1lbnUgaGFuZGxlIGluIG10LmhUb3BNZW51LiBXZSBzaG91bGQKICAgICAgIGNoZWNrIGZvciB0aGlzIGZpcnN0LiAgKi8KICAgIGlmKCBJc01lbnUoIG10LmhUb3BNZW51ICkgKQogICAgewoJbWVudSA9IE1FTlVfR2V0TWVudSggbXQuaFRvcE1lbnUgKTsKCiAgICAgICAgaWYoIElzV2luZG93KCBtdC5oT3duZXJXbmQgKSApCiAgICAgICAgewoJICAgIE1FTlVfSGlkZVN1YlBvcHVwcyggbXQuaE93bmVyV25kLCBtdC5oVG9wTWVudSwgRkFMU0UgKTsKCgkgICAgaWYgKG1lbnUgJiYgKG1lbnUtPndGbGFncyAmIE1GX1BPUFVQKSkKCSAgICB7CiAgICAgICAgICAgICAgICBEZXN0cm95V2luZG93KCBtZW51LT5oV25kICk7CiAgICAgICAgICAgICAgICBtZW51LT5oV25kID0gMDsKCSAgICB9CgkgICAgTUVOVV9TZWxlY3RJdGVtKCBtdC5oT3duZXJXbmQsIG10LmhUb3BNZW51LCBOT19TRUxFQ1RFRF9JVEVNLCBGQUxTRSwgMCApOwoJICAgIFNlbmRNZXNzYWdlVyggbXQuaE93bmVyV25kLCBXTV9NRU5VU0VMRUNULCBNQUtFTE9ORygwLDB4ZmZmZiksIDAgKTsKICAgICAgICB9CgogICAgICAgIC8qIFJlc2V0IHRoZSB2YXJpYWJsZSBmb3IgaGlkaW5nIG1lbnUgKi8KICAgICAgICBpZiggbWVudSApIG1lbnUtPmJUaW1lVG9IaWRlID0gRkFMU0U7CiAgICB9CgogICAgLyogVGhlIHJldHVybiB2YWx1ZSBpcyBvbmx5IHVzZWQgYnkgVHJhY2tQb3B1cE1lbnUgKi8KICAgIGlmICghKHdGbGFncyAmIFRQTV9SRVRVUk5DTUQpKSByZXR1cm4gVFJVRTsKICAgIGlmIChleGVjdXRlZE1lbnVJZCA9PSAtMSkgZXhlY3V0ZWRNZW51SWQgPSAwOwogICAgcmV0dXJuIGV4ZWN1dGVkTWVudUlkOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfSW5pdFRyYWNraW5nCiAqLwpzdGF0aWMgQk9PTCBNRU5VX0luaXRUcmFja2luZyhIV05EIGhXbmQsIEhNRU5VIGhNZW51LCBCT09MIGJQb3B1cCwgVUlOVCB3RmxhZ3MpCnsKICAgIFBPUFVQTUVOVSAqbWVudTsKICAgIAogICAgVFJBQ0UoImh3bmQ9JXAgaG1lbnU9JXBcbiIsIGhXbmQsIGhNZW51KTsKCiAgICBIaWRlQ2FyZXQoMCk7CgogICAgLyogU2VuZCBXTV9FTlRFUk1FTlVMT09QIGFuZCBXTV9JTklUTUVOVSBtZXNzYWdlIG9ubHkgaWYgVFBNX05PTk9USUZZIGZsYWcgaXMgbm90IHNwZWNpZmllZCAqLwogICAgaWYgKCEod0ZsYWdzICYgVFBNX05PTk9USUZZKSkKICAgICAgIFNlbmRNZXNzYWdlVyggaFduZCwgV01fRU5URVJNRU5VTE9PUCwgYlBvcHVwLCAwICk7CgogICAgU2VuZE1lc3NhZ2VXKCBoV25kLCBXTV9TRVRDVVJTT1IsIChXUEFSQU0paFduZCwgSFRDQVBUSU9OICk7CgogICAgaWYgKCEod0ZsYWdzICYgVFBNX05PTk9USUZZKSkKICAgIHsKICAgICAgIFNlbmRNZXNzYWdlVyggaFduZCwgV01fSU5JVE1FTlUsIChXUEFSQU0paE1lbnUsIDAgKTsKICAgICAgIC8qIElmIGFuIGFwcCBjaGFuZ2VkL3JlY3JlYXRlZCBtZW51IGJhciBlbnRyaWVzIGluIFdNX0lOSVRNRU5VCiAgICAgICAgKiBtZW51IHNpemVzIHdpbGwgYmUgcmVjYWxjdWxhdGVkIG9uY2UgdGhlIG1lbnUgY3JlYXRlZC9zaG93bi4KICAgICAgICAqLwogICAgfQogICAgCiAgICAvKiBUaGlzIG1ha2VzIHRoZSBtZW51cyBvZiBhcHBsaWNhdGlvbnMgYnVpbHQgd2l0aCBEZWxwaGkgd29yay4KICAgICAqIEl0IGFsc28gZW5hYmxlcyBtZW51cyB0byBiZSBkaXNwbGF5ZWQgaW4gbW9yZSB0aGFuIG9uZSB3aW5kb3csCiAgICAgKiBidXQgdGhlcmUgYXJlIHNvbWUgYnVncyBsZWZ0IHRoYXQgbmVlZCB0byBiZSBmaXhlZCBpbiB0aGlzIGNhc2UuCiAgICAgKi8KICAgIGlmICgobWVudSA9IE1FTlVfR2V0TWVudSggaE1lbnUgKSkpIG1lbnUtPmhXbmQgPSBoV25kOwogICAgCiAgICByZXR1cm4gVFJVRTsKfQovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfRXhpdFRyYWNraW5nCiAqLwpzdGF0aWMgQk9PTCBNRU5VX0V4aXRUcmFja2luZyhIV05EIGhXbmQpCnsKICAgIFRSQUNFKCJod25kPSVwXG4iLCBoV25kKTsKCiAgICBTZW5kTWVzc2FnZVcoIGhXbmQsIFdNX0VYSVRNRU5VTE9PUCwgMCwgMCApOwogICAgU2hvd0NhcmV0KDApOwogICAgdG9wX3BvcHVwID0gMDsKICAgIHJldHVybiBUUlVFOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfVHJhY2tNb3VzZU1lbnVCYXIKICoKICogTWVudS1iYXIgdHJhY2tpbmcgdXBvbiBhIG1vdXNlIGV2ZW50LiBDYWxsZWQgZnJvbSBOQ19IYW5kbGVTeXNDb21tYW5kKCkuCiAqLwp2b2lkIE1FTlVfVHJhY2tNb3VzZU1lbnVCYXIoIEhXTkQgaFduZCwgSU5UIGh0LCBQT0lOVCBwdCApCnsKICAgIEhNRU5VIGhNZW51ID0gKGh0ID09IEhUU1lTTUVOVSkgPyBnZXRfd2luX3N5c19tZW51KCBoV25kICkgOiBHZXRNZW51KCBoV25kICk7CiAgICBVSU5UIHdGbGFncyA9IFRQTV9FTlRFUklETEVFWCB8IFRQTV9CVVRUT05ET1dOIHwgVFBNX0xFRlRBTElHTiB8IFRQTV9MRUZUQlVUVE9OOwoKICAgIFRSQUNFKCJ3bmQ9JXAgaHQ9MHglMDR4ICVzXG4iLCBoV25kLCBodCwgd2luZV9kYmdzdHJfcG9pbnQoICZwdCkpOwoKICAgIGlmIChJc01lbnUoaE1lbnUpKQogICAgewoJTUVOVV9Jbml0VHJhY2tpbmcoIGhXbmQsIGhNZW51LCBGQUxTRSwgd0ZsYWdzICk7CglNRU5VX1RyYWNrTWVudSggaE1lbnUsIHdGbGFncywgcHQueCwgcHQueSwgaFduZCwgTlVMTCApOwoJTUVOVV9FeGl0VHJhY2tpbmcoaFduZCk7CiAgICB9Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfVHJhY2tLYmRNZW51QmFyCiAqCiAqIE1lbnUtYmFyIHRyYWNraW5nIHVwb24gYSBrZXlib2FyZCBldmVudC4gQ2FsbGVkIGZyb20gTkNfSGFuZGxlU3lzQ29tbWFuZCgpLgogKi8Kdm9pZCBNRU5VX1RyYWNrS2JkTWVudUJhciggSFdORCBod25kLCBVSU5UIHdQYXJhbSwgV0NIQVIgd0NoYXIpCnsKICAgIFVJTlQgdUl0ZW0gPSBOT19TRUxFQ1RFRF9JVEVNOwogICAgSE1FTlUgaFRyYWNrTWVudTsKICAgIFVJTlQgd0ZsYWdzID0gVFBNX0VOVEVSSURMRUVYIHwgVFBNX0xFRlRBTElHTiB8IFRQTV9MRUZUQlVUVE9OOwoKICAgIFRSQUNFKCJod25kICVwIHdQYXJhbSAweCUwNHggd0NoYXIgMHglMDR4XG4iLCBod25kLCB3UGFyYW0sIHdDaGFyKTsKCiAgICAvKiBmaW5kIHdpbmRvdyB0aGF0IGhhcyBhIG1lbnUgKi8KCiAgICB3aGlsZSAoIVdJTl9BTExPV0VEX01FTlUoR2V0V2luZG93TG9uZ1coIGh3bmQsIEdXTF9TVFlMRSApKSkKICAgICAgICBpZiAoIShod25kID0gR2V0QW5jZXN0b3IoIGh3bmQsIEdBX1BBUkVOVCApKSkgcmV0dXJuOwoKICAgIC8qIGNoZWNrIGlmIHdlIGhhdmUgdG8gdHJhY2sgYSBzeXN0ZW0gbWVudSAqLwoKICAgIGhUcmFja01lbnUgPSBHZXRNZW51KCBod25kICk7CiAgICBpZiAoIWhUcmFja01lbnUgfHwgSXNJY29uaWMoaHduZCkgfHwgd0NoYXIgPT0gJyAnICkKICAgIHsKICAgICAgICBpZiAoIShHZXRXaW5kb3dMb25nVyggaHduZCwgR1dMX1NUWUxFICkgJiBXU19TWVNNRU5VKSkgcmV0dXJuOwogICAgICAgIGhUcmFja01lbnUgPSBnZXRfd2luX3N5c19tZW51KCBod25kICk7CiAgICAgICAgdUl0ZW0gPSAwOwogICAgICAgIHdQYXJhbSB8PSBIVFNZU01FTlU7IC8qIHByZXZlbnQgaXRlbSBsb29rdXAgKi8KICAgIH0KCiAgICBpZiAoIUlzTWVudSggaFRyYWNrTWVudSApKSByZXR1cm47CgogICAgTUVOVV9Jbml0VHJhY2tpbmcoIGh3bmQsIGhUcmFja01lbnUsIEZBTFNFLCB3RmxhZ3MgKTsKCiAgICBpZiggd0NoYXIgJiYgd0NoYXIgIT0gJyAnICkKICAgIHsKICAgICAgICB1SXRlbSA9IE1FTlVfRmluZEl0ZW1CeUtleSggaHduZCwgaFRyYWNrTWVudSwgd0NoYXIsICh3UGFyYW0gJiBIVFNZU01FTlUpICk7CiAgICAgICAgaWYgKCB1SXRlbSA+PSAoVUlOVCkoLTIpICkKICAgICAgICB7CiAgICAgICAgICAgIGlmKCB1SXRlbSA9PSAoVUlOVCkoLTEpICkgTWVzc2FnZUJlZXAoMCk7CiAgICAgICAgICAgIC8qIHNjaGVkdWxlIGVuZCBvZiBtZW51IHRyYWNraW5nICovCiAgICAgICAgICAgIHdGbGFncyB8PSBURl9FTkRNRU5VOwogICAgICAgICAgICBnb3RvIHRyYWNrX21lbnU7CiAgICAgICAgfQogICAgfQoKICAgIE1FTlVfU2VsZWN0SXRlbSggaHduZCwgaFRyYWNrTWVudSwgdUl0ZW0sIFRSVUUsIDAgKTsKCiAgICBpZiAod1BhcmFtICYgSFRTWVNNRU5VKQogICAgewogICAgICAgIC8qIHByZXZlbnQgc3lzbWVudSBhY3RpdmF0aW9uIGZvciBtYW5hZ2VkIHdpbmRvd3Mgb24gQWx0IGRvd24vdXAgKi8KICAgICAgICBpZiAoR2V0UHJvcEEoIGh3bmQsICJfX3dpbmVfeDExX21hbmFnZWQiICkpCiAgICAgICAgICAgIHdGbGFncyB8PSBURl9FTkRNRU5VOyAvKiBzY2hlZHVsZSBlbmQgb2YgbWVudSB0cmFja2luZyAqLwogICAgfQogICAgZWxzZQogICAgewogICAgICAgIGlmKCB1SXRlbSA9PSBOT19TRUxFQ1RFRF9JVEVNICkKICAgICAgICAgICAgTUVOVV9Nb3ZlU2VsZWN0aW9uKCBod25kLCBoVHJhY2tNZW51LCBJVEVNX05FWFQgKTsKICAgICAgICBlbHNlCiAgICAgICAgICAgIFBvc3RNZXNzYWdlVyggaHduZCwgV01fS0VZRE9XTiwgVktfRE9XTiwgMEwgKTsKICAgIH0KCnRyYWNrX21lbnU6CiAgICBNRU5VX1RyYWNrTWVudSggaFRyYWNrTWVudSwgd0ZsYWdzLCAwLCAwLCBod25kLCBOVUxMICk7CiAgICBNRU5VX0V4aXRUcmFja2luZyggaHduZCApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIFRyYWNrUG9wdXBNZW51ICAgKFVTRVIzMi5AKQogKgogKiBMaWtlIHRoZSB3aW4zMiBBUEksIHRoZSBmdW5jdGlvbiByZXR1cm4gdGhlIGNvbW1hbmQgSUQgb25seSBpZiB0aGUKICogZmxhZyBUUE1fUkVUVVJOQ01EIGlzIG9uLgogKgogKi8KQk9PTCBXSU5BUEkgVHJhY2tQb3B1cE1lbnUoIEhNRU5VIGhNZW51LCBVSU5UIHdGbGFncywgSU5UIHgsIElOVCB5LAogICAgICAgICAgICAgICAgICAgICAgICAgICBJTlQgblJlc2VydmVkLCBIV05EIGhXbmQsIGNvbnN0IFJFQ1QgKmxwUmVjdCApCnsKICAgIEJPT0wgcmV0ID0gRkFMU0U7CgogICAgVFJBQ0UoImhtZW51ICVwIGZsYWdzICUwNHggKCVkLCVkKSByZXNlcnZlZCAlZCBod25kICVwIHJlY3QgJXNcbiIsCiAgICAgICAgICAgaE1lbnUsIHdGbGFncywgeCwgeSwgblJlc2VydmVkLCBoV25kLCB3aW5lX2RiZ3N0cl9yZWN0KGxwUmVjdCkpOwoKICAgIE1FTlVfSW5pdFRyYWNraW5nKGhXbmQsIGhNZW51LCBUUlVFLCB3RmxhZ3MpOwoKICAgIC8qIFNlbmQgV01fSU5JVE1FTlVQT1BVUCBtZXNzYWdlIG9ubHkgaWYgVFBNX05PTk9USUZZIGZsYWcgaXMgbm90IHNwZWNpZmllZCAqLwogICAgaWYgKCEod0ZsYWdzICYgVFBNX05PTk9USUZZKSkKICAgICAgICBTZW5kTWVzc2FnZVcoIGhXbmQsIFdNX0lOSVRNRU5VUE9QVVAsIChXUEFSQU0paE1lbnUsIDApOwoKICAgIGlmIChNRU5VX1Nob3dQb3B1cCggaFduZCwgaE1lbnUsIDAsIHgsIHksIDAsIDAgKSkKICAgICAgICByZXQgPSBNRU5VX1RyYWNrTWVudSggaE1lbnUsIHdGbGFncyB8IFRQTV9QT1BVUE1FTlUsIDAsIDAsIGhXbmQsIGxwUmVjdCApOwogICAgTUVOVV9FeGl0VHJhY2tpbmcoaFduZCk7CgogICAgcmV0dXJuIHJldDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIFRyYWNrUG9wdXBNZW51RXggICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBUcmFja1BvcHVwTWVudUV4KCBITUVOVSBoTWVudSwgVUlOVCB3RmxhZ3MsIElOVCB4LCBJTlQgeSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBIV05EIGhXbmQsIExQVFBNUEFSQU1TIGxwVHBtICkKewogICAgRklYTUUoIm5vdCBmdWxseSBpbXBsZW1lbnRlZFxuIiApOwogICAgcmV0dXJuIFRyYWNrUG9wdXBNZW51KCBoTWVudSwgd0ZsYWdzLCB4LCB5LCAwLCBoV25kLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxwVHBtID8gJmxwVHBtLT5yY0V4Y2x1ZGUgOiBOVUxMICk7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgUG9wdXBNZW51V25kUHJvYwogKgogKiBOT1RFOiBXaW5kb3dzIGhhcyB0b3RhbGx5IGRpZmZlcmVudCAoYW5kIHVuZG9jdW1lbnRlZCkgcG9wdXAgd25kcHJvYy4KICovCnN0YXRpYyBMUkVTVUxUIFdJTkFQSSBQb3B1cE1lbnVXbmRQcm9jKCBIV05EIGh3bmQsIFVJTlQgbWVzc2FnZSwgV1BBUkFNIHdQYXJhbSwgTFBBUkFNIGxQYXJhbSApCnsKICAgIFRSQUNFKCJod25kPSVwIG1zZz0weCUwNHggd3A9MHglMDR4IGxwPTB4JTA4bHhcbiIsIGh3bmQsIG1lc3NhZ2UsIHdQYXJhbSwgbFBhcmFtKTsKCiAgICBzd2l0Y2gobWVzc2FnZSkKICAgIHsKICAgIGNhc2UgV01fQ1JFQVRFOgoJewoJICAgIENSRUFURVNUUlVDVFcgKmNzID0gKENSRUFURVNUUlVDVFcqKWxQYXJhbTsKCSAgICBTZXRXaW5kb3dMb25nUHRyVyggaHduZCwgMCwgKExPTkdfUFRSKWNzLT5scENyZWF0ZVBhcmFtcyApOwogICAgICAgICAgICByZXR1cm4gMDsKCX0KCiAgICBjYXNlIFdNX01PVVNFQUNUSVZBVEU6ICAvKiBXZSBkb24ndCB3YW50IHRvIGJlIGFjdGl2YXRlZCAqLwogICAgICAgIHJldHVybiBNQV9OT0FDVElWQVRFOwoKICAgIGNhc2UgV01fUEFJTlQ6Cgl7CgkgICAgUEFJTlRTVFJVQ1QgcHM7CgkgICAgQmVnaW5QYWludCggaHduZCwgJnBzICk7CgkgICAgTUVOVV9EcmF3UG9wdXBNZW51KCBod25kLCBwcy5oZGMsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKEhNRU5VKUdldFdpbmRvd0xvbmdQdHJXKCBod25kLCAwICkgKTsKCSAgICBFbmRQYWludCggaHduZCwgJnBzICk7CiAgICAgICAgICAgIHJldHVybiAwOwoJfQogICAgY2FzZSBXTV9FUkFTRUJLR05EOgogICAgICAgIHJldHVybiAxOwoKICAgIGNhc2UgV01fREVTVFJPWToKICAgICAgICAvKiB6ZXJvIG91dCBnbG9iYWwgcG9pbnRlciBpbiBjYXNlIHJlc2lkZW50IHBvcHVwIHdpbmRvdyB3YXMgZGVzdHJveWVkLiAqLwogICAgICAgIGlmIChod25kID09IHRvcF9wb3B1cCkgdG9wX3BvcHVwID0gMDsKICAgICAgICBicmVhazsKCiAgICBjYXNlIFdNX1NIT1dXSU5ET1c6CgoJaWYoIHdQYXJhbSApCgl7CiAgICAgICAgICAgIGlmICghR2V0V2luZG93TG9uZ1B0clcoIGh3bmQsIDAgKSkgRVJSKCJubyBtZW51IHRvIGRpc3BsYXlcbiIpOwoJfQoJZWxzZQogICAgICAgICAgICBTZXRXaW5kb3dMb25nUHRyVyggaHduZCwgMCwgMCApOwoJYnJlYWs7CgogICAgY2FzZSBNTV9TRVRNRU5VSEFORExFOgogICAgICAgIFNldFdpbmRvd0xvbmdQdHJXKCBod25kLCAwLCB3UGFyYW0gKTsKICAgICAgICBicmVhazsKCiAgICBjYXNlIE1NX0dFVE1FTlVIQU5ETEU6CiAgICAgICAgcmV0dXJuIEdldFdpbmRvd0xvbmdQdHJXKCBod25kLCAwICk7CgogICAgZGVmYXVsdDoKICAgICAgICByZXR1cm4gRGVmV2luZG93UHJvY1coIGh3bmQsIG1lc3NhZ2UsIHdQYXJhbSwgbFBhcmFtICk7CiAgICB9CiAgICByZXR1cm4gMDsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9HZXRNZW51QmFySGVpZ2h0CiAqCiAqIENvbXB1dGUgdGhlIHNpemUgb2YgdGhlIG1lbnUgYmFyIGhlaWdodC4gVXNlZCBieSBOQ19IYW5kbGVOQ0NhbGNTaXplKCkuCiAqLwpVSU5UIE1FTlVfR2V0TWVudUJhckhlaWdodCggSFdORCBod25kLCBVSU5UIG1lbnViYXJXaWR0aCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSU5UIG9yZ1gsIElOVCBvcmdZICkKewogICAgSERDIGhkYzsKICAgIFJFQ1QgcmVjdEJhcjsKICAgIExQUE9QVVBNRU5VIGxwcG9wOwoKICAgIFRSQUNFKCJIV05EICVwLCB3aWR0aCAlZCwgYXQgKCVkLCAlZCkuXG4iLCBod25kLCBtZW51YmFyV2lkdGgsIG9yZ1gsIG9yZ1kgKTsKCiAgICBpZiAoIShscHBvcCA9IE1FTlVfR2V0TWVudSggR2V0TWVudShod25kKSApKSkgcmV0dXJuIDA7CgogICAgaGRjID0gR2V0RENFeCggaHduZCwgMCwgRENYX0NBQ0hFIHwgRENYX1dJTkRPVyApOwogICAgU2VsZWN0T2JqZWN0KCBoZGMsIGdldF9tZW51X2ZvbnQoRkFMU0UpKTsKICAgIFNldFJlY3QoJnJlY3RCYXIsIG9yZ1gsIG9yZ1ksIG9yZ1grbWVudWJhcldpZHRoLCBvcmdZK0dldFN5c3RlbU1ldHJpY3MoU01fQ1lNRU5VKSk7CiAgICBNRU5VX01lbnVCYXJDYWxjU2l6ZSggaGRjLCAmcmVjdEJhciwgbHBwb3AsIGh3bmQgKTsKICAgIFJlbGVhc2VEQyggaHduZCwgaGRjICk7CiAgICByZXR1cm4gbHBwb3AtPkhlaWdodDsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgQ2hhbmdlTWVudUEgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgQ2hhbmdlTWVudUEoIEhNRU5VIGhNZW51LCBVSU5UIHBvcywgTFBDU1RSIGRhdGEsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVUlOVCBpZCwgVUlOVCBmbGFncyApCnsKICAgIFRSQUNFKCJtZW51PSVwIHBvcz0lZCBkYXRhPSVwIGlkPSUwOHggZmxhZ3M9JTA4eFxuIiwgaE1lbnUsIHBvcywgZGF0YSwgaWQsIGZsYWdzICk7CiAgICBpZiAoZmxhZ3MgJiBNRl9BUFBFTkQpIHJldHVybiBBcHBlbmRNZW51QSggaE1lbnUsIGZsYWdzICYgfk1GX0FQUEVORCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlkLCBkYXRhICk7CiAgICBpZiAoZmxhZ3MgJiBNRl9ERUxFVEUpIHJldHVybiBEZWxldGVNZW51KGhNZW51LCBwb3MsIGZsYWdzICYgfk1GX0RFTEVURSk7CiAgICBpZiAoZmxhZ3MgJiBNRl9DSEFOR0UpIHJldHVybiBNb2RpZnlNZW51QShoTWVudSwgcG9zLCBmbGFncyAmIH5NRl9DSEFOR0UsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlkLCBkYXRhICk7CiAgICBpZiAoZmxhZ3MgJiBNRl9SRU1PVkUpIHJldHVybiBSZW1vdmVNZW51KCBoTWVudSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsYWdzICYgTUZfQllQT1NJVElPTiA/IHBvcyA6IGlkLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZmxhZ3MgJiB+TUZfUkVNT1ZFICk7CiAgICAvKiBEZWZhdWx0OiBNRl9JTlNFUlQgKi8KICAgIHJldHVybiBJbnNlcnRNZW51QSggaE1lbnUsIHBvcywgZmxhZ3MsIGlkLCBkYXRhICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIENoYW5nZU1lbnVXICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIENoYW5nZU1lbnVXKCBITUVOVSBoTWVudSwgVUlOVCBwb3MsIExQQ1dTVFIgZGF0YSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVSU5UIGlkLCBVSU5UIGZsYWdzICkKewogICAgVFJBQ0UoIm1lbnU9JXAgcG9zPSVkIGRhdGE9JXAgaWQ9JTA4eCBmbGFncz0lMDh4XG4iLCBoTWVudSwgcG9zLCBkYXRhLCBpZCwgZmxhZ3MgKTsKICAgIGlmIChmbGFncyAmIE1GX0FQUEVORCkgcmV0dXJuIEFwcGVuZE1lbnVXKCBoTWVudSwgZmxhZ3MgJiB+TUZfQVBQRU5ELAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaWQsIGRhdGEgKTsKICAgIGlmIChmbGFncyAmIE1GX0RFTEVURSkgcmV0dXJuIERlbGV0ZU1lbnUoaE1lbnUsIHBvcywgZmxhZ3MgJiB+TUZfREVMRVRFKTsKICAgIGlmIChmbGFncyAmIE1GX0NIQU5HRSkgcmV0dXJuIE1vZGlmeU1lbnVXKGhNZW51LCBwb3MsIGZsYWdzICYgfk1GX0NIQU5HRSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaWQsIGRhdGEgKTsKICAgIGlmIChmbGFncyAmIE1GX1JFTU9WRSkgcmV0dXJuIFJlbW92ZU1lbnUoIGhNZW51LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZmxhZ3MgJiBNRl9CWVBPU0lUSU9OID8gcG9zIDogaWQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmbGFncyAmIH5NRl9SRU1PVkUgKTsKICAgIC8qIERlZmF1bHQ6IE1GX0lOU0VSVCAqLwogICAgcmV0dXJuIEluc2VydE1lbnVXKCBoTWVudSwgcG9zLCBmbGFncywgaWQsIGRhdGEgKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgQ2hlY2tNZW51SXRlbSAgICAoVVNFUjMyLkApCiAqLwpEV09SRCBXSU5BUEkgQ2hlY2tNZW51SXRlbSggSE1FTlUgaE1lbnUsIFVJTlQgaWQsIFVJTlQgZmxhZ3MgKQp7CiAgICBNRU5VSVRFTSAqaXRlbTsKICAgIERXT1JEIHJldDsKCiAgICBUUkFDRSgibWVudT0lcCBpZD0lMDR4IGZsYWdzPSUwNHhcbiIsIGhNZW51LCBpZCwgZmxhZ3MgKTsKICAgIGlmICghKGl0ZW0gPSBNRU5VX0ZpbmRJdGVtKCAmaE1lbnUsICZpZCwgZmxhZ3MgKSkpIHJldHVybiAtMTsKICAgIHJldCA9IGl0ZW0tPmZTdGF0ZSAmIE1GX0NIRUNLRUQ7CiAgICBpZiAoZmxhZ3MgJiBNRl9DSEVDS0VEKSBpdGVtLT5mU3RhdGUgfD0gTUZfQ0hFQ0tFRDsKICAgIGVsc2UgaXRlbS0+ZlN0YXRlICY9IH5NRl9DSEVDS0VEOwogICAgcmV0dXJuIHJldDsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgRW5hYmxlTWVudUl0ZW0gICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgRW5hYmxlTWVudUl0ZW0oIEhNRU5VIGhNZW51LCBVSU5UIHdJdGVtSUQsIFVJTlQgd0ZsYWdzICkKewogICAgVUlOVCAgICBvbGRmbGFnczsKICAgIE1FTlVJVEVNICppdGVtOwogICAgUE9QVVBNRU5VICptZW51OwoKICAgIFRSQUNFKCIoJXAsICUwNHgsICUwNHgpICFcbiIsIGhNZW51LCB3SXRlbUlELCB3RmxhZ3MpOwoKICAgIC8qIEdldCB0aGUgUG9wdXBtZW51IHRvIGFjY2VzcyB0aGUgb3duZXIgbWVudSAqLwogICAgaWYgKCEobWVudSA9IE1FTlVfR2V0TWVudShoTWVudSkpKQoJcmV0dXJuIChVSU5UKS0xOwoKICAgIGlmICghKGl0ZW0gPSBNRU5VX0ZpbmRJdGVtKCAmaE1lbnUsICZ3SXRlbUlELCB3RmxhZ3MgKSkpCglyZXR1cm4gKFVJTlQpLTE7CgogICAgb2xkZmxhZ3MgPSBpdGVtLT5mU3RhdGUgJiAoTUZfR1JBWUVEIHwgTUZfRElTQUJMRUQpOwogICAgaXRlbS0+ZlN0YXRlIF49IChvbGRmbGFncyBeIHdGbGFncykgJiAoTUZfR1JBWUVEIHwgTUZfRElTQUJMRUQpOwoKICAgIC8qIElmIHRoZSBjbG9zZSBpdGVtIGluIHRoZSBzeXN0ZW0gbWVudSBjaGFuZ2UgdXBkYXRlIHRoZSBjbG9zZSBidXR0b24gKi8KICAgIGlmKChpdGVtLT53SUQgPT0gU0NfQ0xPU0UpICYmIChvbGRmbGFncyAhPSB3RmxhZ3MpKQogICAgewoJaWYgKG1lbnUtPmhTeXNNZW51T3duZXIgIT0gMCkKCXsKICAgICAgICAgICAgUkVDVCByYzsKCSAgICBQT1BVUE1FTlUqIHBhcmVudE1lbnU7CgoJICAgIC8qIEdldCB0aGUgcGFyZW50IG1lbnUgdG8gYWNjZXNzKi8KCSAgICBpZiAoIShwYXJlbnRNZW51ID0gTUVOVV9HZXRNZW51KG1lbnUtPmhTeXNNZW51T3duZXIpKSkKCQlyZXR1cm4gKFVJTlQpLTE7CgogICAgICAgICAgICAvKiBSZWZyZXNoIHRoZSBmcmFtZSB0byByZWZsZWN0IHRoZSBjaGFuZ2UgKi8KICAgICAgICAgICAgR2V0V2luZG93UmVjdChwYXJlbnRNZW51LT5oV25kLCAmcmMpOwogICAgICAgICAgICBNYXBXaW5kb3dQb2ludHMoMCwgcGFyZW50TWVudS0+aFduZCwgKFBPSU5UICopJnJjLCAyKTsKICAgICAgICAgICAgcmMuYm90dG9tID0gMDsKICAgICAgICAgICAgUmVkcmF3V2luZG93KHBhcmVudE1lbnUtPmhXbmQsICZyYywgMCwgUkRXX0ZSQU1FIHwgUkRXX0lOVkFMSURBVEUgfCBSRFdfTk9DSElMRFJFTik7Cgl9CiAgICB9CgogICAgcmV0dXJuIG9sZGZsYWdzOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBHZXRNZW51U3RyaW5nQSAgICAoVVNFUjMyLkApCiAqLwpJTlQgV0lOQVBJIEdldE1lbnVTdHJpbmdBKAoJSE1FTlUgaE1lbnUsCS8qIFtpbl0gbWVudWhhbmRsZSAqLwoJVUlOVCB3SXRlbUlELAkvKiBbaW5dIG1lbnUgaXRlbSAoZGVwLiBvbiB3RmxhZ3MpICovCglMUFNUUiBzdHIsCS8qIFtvdXRdIG91dGJ1ZmZlci4gSWYgTlVMTCwgZnVuYyByZXR1cm5zIGVudHJ5IGxlbmd0aCovCglJTlQgbk1heFNpeiwJLyogW2luXSBsZW5ndGggb2YgYnVmZmVyLiBpZiAwLCBmdW5jIHJldHVybnMgZW50cnkgbGVuKi8KCVVJTlQgd0ZsYWdzCS8qIFtpbl0gTUZfIGZsYWdzICovCikgewogICAgTUVOVUlURU0gKml0ZW07CgogICAgVFJBQ0UoIm1lbnU9JXAgaXRlbT0lMDR4IHB0cj0lcCBsZW49JWQgZmxhZ3M9JTA0eFxuIiwgaE1lbnUsIHdJdGVtSUQsIHN0ciwgbk1heFNpeiwgd0ZsYWdzICk7CiAgICBpZiAoc3RyICYmIG5NYXhTaXopIHN0clswXSA9ICdcMCc7CiAgICBpZiAoIShpdGVtID0gTUVOVV9GaW5kSXRlbSggJmhNZW51LCAmd0l0ZW1JRCwgd0ZsYWdzICkpKSB7CiAgICAgICAgU2V0TGFzdEVycm9yKCBFUlJPUl9NRU5VX0lURU1fTk9UX0ZPVU5EKTsKICAgICAgICByZXR1cm4gMDsKICAgIH0KICAgIGlmICghaXRlbS0+dGV4dCkgcmV0dXJuIDA7CiAgICBpZiAoIXN0ciB8fCAhbk1heFNpeikgcmV0dXJuIHN0cmxlblcoaXRlbS0+dGV4dCk7CiAgICBpZiAoIVdpZGVDaGFyVG9NdWx0aUJ5dGUoIENQX0FDUCwgMCwgaXRlbS0+dGV4dCwgLTEsIHN0ciwgbk1heFNpeiwgTlVMTCwgTlVMTCApKQogICAgICAgIHN0cltuTWF4U2l6LTFdID0gMDsKICAgIFRSQUNFKCJyZXR1cm5pbmcgJyVzJ1xuIiwgc3RyICk7CiAgICByZXR1cm4gc3RybGVuKHN0cik7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEdldE1lbnVTdHJpbmdXICAgIChVU0VSMzIuQCkKICovCklOVCBXSU5BUEkgR2V0TWVudVN0cmluZ1coIEhNRU5VIGhNZW51LCBVSU5UIHdJdGVtSUQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBMUFdTVFIgc3RyLCBJTlQgbk1heFNpeiwgVUlOVCB3RmxhZ3MgKQp7CiAgICBNRU5VSVRFTSAqaXRlbTsKCiAgICBUUkFDRSgibWVudT0lcCBpdGVtPSUwNHggcHRyPSVwIGxlbj0lZCBmbGFncz0lMDR4XG4iLCBoTWVudSwgd0l0ZW1JRCwgc3RyLCBuTWF4U2l6LCB3RmxhZ3MgKTsKICAgIGlmIChzdHIgJiYgbk1heFNpeikgc3RyWzBdID0gJ1wwJzsKICAgIGlmICghKGl0ZW0gPSBNRU5VX0ZpbmRJdGVtKCAmaE1lbnUsICZ3SXRlbUlELCB3RmxhZ3MgKSkpIHsKICAgICAgICBTZXRMYXN0RXJyb3IoIEVSUk9SX01FTlVfSVRFTV9OT1RfRk9VTkQpOwogICAgICAgIHJldHVybiAwOwogICAgfQogICAgaWYgKCFzdHIgfHwgIW5NYXhTaXopIHJldHVybiBpdGVtLT50ZXh0ID8gc3RybGVuVyhpdGVtLT50ZXh0KSA6IDA7CiAgICBpZiggIShpdGVtLT50ZXh0KSkgewogICAgICAgIHN0clswXSA9IDA7CiAgICAgICAgcmV0dXJuIDA7CiAgICB9CiAgICBsc3RyY3B5blcoIHN0ciwgaXRlbS0+dGV4dCwgbk1heFNpeiApOwogICAgcmV0dXJuIHN0cmxlblcoc3RyKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgSGlsaXRlTWVudUl0ZW0gICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgSGlsaXRlTWVudUl0ZW0oIEhXTkQgaFduZCwgSE1FTlUgaE1lbnUsIFVJTlQgd0l0ZW1JRCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVSU5UIHdIaWxpdGUgKQp7CiAgICBMUFBPUFVQTUVOVSBtZW51OwogICAgVFJBQ0UoIiglcCwgJXAsICUwNHgsICUwNHgpO1xuIiwgaFduZCwgaE1lbnUsIHdJdGVtSUQsIHdIaWxpdGUpOwogICAgaWYgKCFNRU5VX0ZpbmRJdGVtKCAmaE1lbnUsICZ3SXRlbUlELCB3SGlsaXRlICkpIHJldHVybiBGQUxTRTsKICAgIGlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpKSkgcmV0dXJuIEZBTFNFOwogICAgaWYgKG1lbnUtPkZvY3VzZWRJdGVtID09IHdJdGVtSUQpIHJldHVybiBUUlVFOwogICAgTUVOVV9IaWRlU3ViUG9wdXBzKCBoV25kLCBoTWVudSwgRkFMU0UgKTsKICAgIE1FTlVfU2VsZWN0SXRlbSggaFduZCwgaE1lbnUsIHdJdGVtSUQsIFRSVUUsIDAgKTsKICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBHZXRNZW51U3RhdGUgICAgKFVTRVIzMi5AKQogKi8KVUlOVCBXSU5BUEkgR2V0TWVudVN0YXRlKCBITUVOVSBoTWVudSwgVUlOVCB3SXRlbUlELCBVSU5UIHdGbGFncyApCnsKICAgIE1FTlVJVEVNICppdGVtOwogICAgVFJBQ0UoIihtZW51PSVwLCBpZD0lMDR4LCBmbGFncz0lMDR4KTtcbiIsIGhNZW51LCB3SXRlbUlELCB3RmxhZ3MpOwogICAgaWYgKCEoaXRlbSA9IE1FTlVfRmluZEl0ZW0oICZoTWVudSwgJndJdGVtSUQsIHdGbGFncyApKSkgcmV0dXJuIC0xOwogICAgZGVidWdfcHJpbnRfbWVudWl0ZW0gKCIgIGl0ZW06ICIsIGl0ZW0sICIiKTsKICAgIGlmIChpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKQogICAgewoJUE9QVVBNRU5VICptZW51ID0gTUVOVV9HZXRNZW51KCBpdGVtLT5oU3ViTWVudSApOwoJaWYgKCFtZW51KSByZXR1cm4gLTE7CgllbHNlIHJldHVybiAobWVudS0+bkl0ZW1zIDw8IDgpIHwgKChpdGVtLT5mU3RhdGV8aXRlbS0+ZlR5cGUpICYgMHhmZik7CiAgICB9CiAgICBlbHNlCiAgICB7CgkvKiBXZSB1c2VkIHRvIChmcm9tIHdheSBiYWNrIHRoZW4pIG1hc2sgdGhlIHJlc3VsdCB0byAweGZmLiAgKi8KCS8qIEkgZG9uJ3Qga25vdyB3aHkgYW5kIGl0IHNlZW1zIHdyb25nIGFzIHRoZSBkb2N1bWVudGVkICovCgkvKiByZXR1cm4gZmxhZyBNRl9TRVBBUkFUT1IgaXMgb3V0c2lkZSB0aGF0IG1hc2suICAqLwoJcmV0dXJuIChpdGVtLT5mVHlwZSB8IGl0ZW0tPmZTdGF0ZSk7CiAgICB9Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEdldE1lbnVJdGVtQ291bnQgICAgKFVTRVIzMi5AKQogKi8KSU5UIFdJTkFQSSBHZXRNZW51SXRlbUNvdW50KCBITUVOVSBoTWVudSApCnsKICAgIExQUE9QVVBNRU5VCW1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpOwogICAgaWYgKCFtZW51KSByZXR1cm4gLTE7CiAgICBUUkFDRSgiKCVwKSByZXR1cm5pbmcgJWRcbiIsIGhNZW51LCBtZW51LT5uSXRlbXMgKTsKICAgIHJldHVybiBtZW51LT5uSXRlbXM7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEdldE1lbnVJdGVtSUQgICAgKFVTRVIzMi5AKQogKi8KVUlOVCBXSU5BUEkgR2V0TWVudUl0ZW1JRCggSE1FTlUgaE1lbnUsIElOVCBuUG9zICkKewogICAgTUVOVUlURU0gKiBscG1pOwoKICAgIGlmICghKGxwbWkgPSBNRU5VX0ZpbmRJdGVtKCZoTWVudSwoVUlOVCopJm5Qb3MsTUZfQllQT1NJVElPTikpKSByZXR1cm4gLTE7CiAgICBpZiAobHBtaS0+ZlR5cGUgJiBNRl9QT1BVUCkgcmV0dXJuIC0xOwogICAgcmV0dXJuIGxwbWktPndJRDsKCn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEluc2VydE1lbnVXICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIEluc2VydE1lbnVXKCBITUVOVSBoTWVudSwgVUlOVCBwb3MsIFVJTlQgZmxhZ3MsCiAgICAgICAgICAgICAgICAgICAgICAgICBVSU5UX1BUUiBpZCwgTFBDV1NUUiBzdHIgKQp7CiAgICBNRU5VSVRFTSAqaXRlbTsKCiAgICBpZiAoSVNfU1RSSU5HX0lURU0oZmxhZ3MpICYmIHN0cikKICAgICAgICBUUkFDRSgiaE1lbnUgJXAsIHBvcyAlZCwgZmxhZ3MgJTA4eCwgaWQgJTA0eCwgc3RyICVzXG4iLAogICAgICAgICAgICAgIGhNZW51LCBwb3MsIGZsYWdzLCBpZCwgZGVidWdzdHJfdyhzdHIpICk7CiAgICBlbHNlIFRSQUNFKCJoTWVudSAlcCwgcG9zICVkLCBmbGFncyAlMDh4LCBpZCAlMDR4LCBzdHIgJXAgKG5vdCBhIHN0cmluZylcbiIsCiAgICAgICAgICAgICAgIGhNZW51LCBwb3MsIGZsYWdzLCBpZCwgc3RyICk7CgogICAgaWYgKCEoaXRlbSA9IE1FTlVfSW5zZXJ0SXRlbSggaE1lbnUsIHBvcywgZmxhZ3MgKSkpIHJldHVybiBGQUxTRTsKCiAgICBpZiAoIShNRU5VX1NldEl0ZW1EYXRhKCBpdGVtLCBmbGFncywgaWQsIHN0ciApKSkKICAgIHsKICAgICAgICBSZW1vdmVNZW51KCBoTWVudSwgcG9zLCBmbGFncyApOwogICAgICAgIHJldHVybiBGQUxTRTsKICAgIH0KCiAgICBpZiAoZmxhZ3MgJiBNRl9QT1BVUCkgIC8qIFNldCB0aGUgTUZfUE9QVVAgZmxhZyBvbiB0aGUgcG9wdXAtbWVudSAqLwoJKE1FTlVfR2V0TWVudSgoSE1FTlUpaWQpKS0+d0ZsYWdzIHw9IE1GX1BPUFVQOwoKICAgIGl0ZW0tPmhDaGVja0JpdCA9IGl0ZW0tPmhVbkNoZWNrQml0ID0gMDsKICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBJbnNlcnRNZW51QSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBJbnNlcnRNZW51QSggSE1FTlUgaE1lbnUsIFVJTlQgcG9zLCBVSU5UIGZsYWdzLAogICAgICAgICAgICAgICAgICAgICAgICAgVUlOVF9QVFIgaWQsIExQQ1NUUiBzdHIgKQp7CiAgICBCT09MIHJldCA9IEZBTFNFOwoKICAgIGlmIChJU19TVFJJTkdfSVRFTShmbGFncykgJiYgc3RyKQogICAgewogICAgICAgIElOVCBsZW4gPSBNdWx0aUJ5dGVUb1dpZGVDaGFyKCBDUF9BQ1AsIDAsIHN0ciwgLTEsIE5VTEwsIDAgKTsKICAgICAgICBMUFdTVFIgbmV3c3RyID0gSGVhcEFsbG9jKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBsZW4gKiBzaXplb2YoV0NIQVIpICk7CiAgICAgICAgaWYgKG5ld3N0cikKICAgICAgICB7CiAgICAgICAgICAgIE11bHRpQnl0ZVRvV2lkZUNoYXIoIENQX0FDUCwgMCwgc3RyLCAtMSwgbmV3c3RyLCBsZW4gKTsKICAgICAgICAgICAgcmV0ID0gSW5zZXJ0TWVudVcoIGhNZW51LCBwb3MsIGZsYWdzLCBpZCwgbmV3c3RyICk7CiAgICAgICAgICAgIEhlYXBGcmVlKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBuZXdzdHIgKTsKICAgICAgICB9CiAgICAgICAgcmV0dXJuIHJldDsKICAgIH0KICAgIGVsc2UgcmV0dXJuIEluc2VydE1lbnVXKCBoTWVudSwgcG9zLCBmbGFncywgaWQsIChMUENXU1RSKXN0ciApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBBcHBlbmRNZW51QSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBBcHBlbmRNZW51QSggSE1FTlUgaE1lbnUsIFVJTlQgZmxhZ3MsCiAgICAgICAgICAgICAgICAgICAgICAgICBVSU5UX1BUUiBpZCwgTFBDU1RSIGRhdGEgKQp7CiAgICByZXR1cm4gSW5zZXJ0TWVudUEoIGhNZW51LCAtMSwgZmxhZ3MgfCBNRl9CWVBPU0lUSU9OLCBpZCwgZGF0YSApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBBcHBlbmRNZW51VyAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBBcHBlbmRNZW51VyggSE1FTlUgaE1lbnUsIFVJTlQgZmxhZ3MsCiAgICAgICAgICAgICAgICAgICAgICAgICBVSU5UX1BUUiBpZCwgTFBDV1NUUiBkYXRhICkKewogICAgcmV0dXJuIEluc2VydE1lbnVXKCBoTWVudSwgLTEsIGZsYWdzIHwgTUZfQllQT1NJVElPTiwgaWQsIGRhdGEgKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgUmVtb3ZlTWVudSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBSZW1vdmVNZW51KCBITUVOVSBoTWVudSwgVUlOVCBuUG9zLCBVSU5UIHdGbGFncyApCnsKICAgIExQUE9QVVBNRU5VCW1lbnU7CiAgICBNRU5VSVRFTSAqaXRlbTsKCiAgICBUUkFDRSgiKG1lbnU9JXAgcG9zPSUwNHggZmxhZ3M9JTA0eClcbiIsaE1lbnUsIG5Qb3MsIHdGbGFncyk7CiAgICBpZiAoIShpdGVtID0gTUVOVV9GaW5kSXRlbSggJmhNZW51LCAmblBvcywgd0ZsYWdzICkpKSByZXR1cm4gRkFMU0U7CiAgICBpZiAoIShtZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KSkpIHJldHVybiBGQUxTRTsKCiAgICAgIC8qIFJlbW92ZSBpdGVtICovCgogICAgTUVOVV9GcmVlSXRlbURhdGEoIGl0ZW0gKTsKCiAgICBpZiAoLS1tZW51LT5uSXRlbXMgPT0gMCkKICAgIHsKICAgICAgICBIZWFwRnJlZSggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgbWVudS0+aXRlbXMgKTsKICAgICAgICBtZW51LT5pdGVtcyA9IE5VTEw7CiAgICB9CiAgICBlbHNlCiAgICB7Cgl3aGlsZShuUG9zIDwgbWVudS0+bkl0ZW1zKQoJewoJICAgICppdGVtID0gKihpdGVtKzEpOwoJICAgIGl0ZW0rKzsKCSAgICBuUG9zKys7Cgl9CiAgICAgICAgbWVudS0+aXRlbXMgPSBIZWFwUmVBbGxvYyggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgbWVudS0+aXRlbXMsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbWVudS0+bkl0ZW1zICogc2l6ZW9mKE1FTlVJVEVNKSApOwogICAgfQogICAgcmV0dXJuIFRSVUU7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIERlbGV0ZU1lbnUgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgRGVsZXRlTWVudSggSE1FTlUgaE1lbnUsIFVJTlQgblBvcywgVUlOVCB3RmxhZ3MgKQp7CiAgICBNRU5VSVRFTSAqaXRlbSA9IE1FTlVfRmluZEl0ZW0oICZoTWVudSwgJm5Qb3MsIHdGbGFncyApOwogICAgaWYgKCFpdGVtKSByZXR1cm4gRkFMU0U7CiAgICBpZiAoaXRlbS0+ZlR5cGUgJiBNRl9QT1BVUCkgRGVzdHJveU1lbnUoIGl0ZW0tPmhTdWJNZW51ICk7CiAgICAgIC8qIG5Qb3MgaXMgbm93IHRoZSBwb3NpdGlvbiBvZiB0aGUgaXRlbSAqLwogICAgUmVtb3ZlTWVudSggaE1lbnUsIG5Qb3MsIHdGbGFncyB8IE1GX0JZUE9TSVRJT04gKTsKICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBNb2RpZnlNZW51VyAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBNb2RpZnlNZW51VyggSE1FTlUgaE1lbnUsIFVJTlQgcG9zLCBVSU5UIGZsYWdzLAogICAgICAgICAgICAgICAgICAgICAgICAgVUlOVF9QVFIgaWQsIExQQ1dTVFIgc3RyICkKewogICAgTUVOVUlURU0gKml0ZW07CgogICAgaWYgKElTX1NUUklOR19JVEVNKGZsYWdzKSkKICAgICAgICBUUkFDRSgiJXAgJWQgJTA0eCAlMDR4ICVzXG4iLCBoTWVudSwgcG9zLCBmbGFncywgaWQsIGRlYnVnc3RyX3coc3RyKSApOwogICAgZWxzZQogICAgICAgIFRSQUNFKCIlcCAlZCAlMDR4ICUwNHggJXBcbiIsIGhNZW51LCBwb3MsIGZsYWdzLCBpZCwgc3RyICk7CgogICAgaWYgKCEoaXRlbSA9IE1FTlVfRmluZEl0ZW0oICZoTWVudSwgJnBvcywgZmxhZ3MgKSkpIHJldHVybiBGQUxTRTsKICAgIE1FTlVfR2V0TWVudShoTWVudSktPkhlaWdodCA9IDA7IC8qIGZvcmNlIHNpemUgcmVjYWxjdWxhdGUgKi8KICAgIHJldHVybiBNRU5VX1NldEl0ZW1EYXRhKCBpdGVtLCBmbGFncywgaWQsIHN0ciApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBNb2RpZnlNZW51QSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBNb2RpZnlNZW51QSggSE1FTlUgaE1lbnUsIFVJTlQgcG9zLCBVSU5UIGZsYWdzLAogICAgICAgICAgICAgICAgICAgICAgICAgVUlOVF9QVFIgaWQsIExQQ1NUUiBzdHIgKQp7CiAgICBCT09MIHJldCA9IEZBTFNFOwoKICAgIGlmIChJU19TVFJJTkdfSVRFTShmbGFncykgJiYgc3RyKQogICAgewogICAgICAgIElOVCBsZW4gPSBNdWx0aUJ5dGVUb1dpZGVDaGFyKCBDUF9BQ1AsIDAsIHN0ciwgLTEsIE5VTEwsIDAgKTsKICAgICAgICBMUFdTVFIgbmV3c3RyID0gSGVhcEFsbG9jKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBsZW4gKiBzaXplb2YoV0NIQVIpICk7CiAgICAgICAgaWYgKG5ld3N0cikKICAgICAgICB7CiAgICAgICAgICAgIE11bHRpQnl0ZVRvV2lkZUNoYXIoIENQX0FDUCwgMCwgc3RyLCAtMSwgbmV3c3RyLCBsZW4gKTsKICAgICAgICAgICAgcmV0ID0gTW9kaWZ5TWVudVcoIGhNZW51LCBwb3MsIGZsYWdzLCBpZCwgbmV3c3RyICk7CiAgICAgICAgICAgIEhlYXBGcmVlKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBuZXdzdHIgKTsKICAgICAgICB9CiAgICAgICAgcmV0dXJuIHJldDsKICAgIH0KICAgIGVsc2UgcmV0dXJuIE1vZGlmeU1lbnVXKCBoTWVudSwgcG9zLCBmbGFncywgaWQsIChMUENXU1RSKXN0ciApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBDcmVhdGVQb3B1cE1lbnUgICAgKFVTRVIzMi5AKQogKi8KSE1FTlUgV0lOQVBJIENyZWF0ZVBvcHVwTWVudSh2b2lkKQp7CiAgICBITUVOVSBobWVudTsKICAgIFBPUFVQTUVOVSAqbWVudTsKCiAgICBpZiAoIShobWVudSA9IENyZWF0ZU1lbnUoKSkpIHJldHVybiAwOwogICAgbWVudSA9IE1FTlVfR2V0TWVudSggaG1lbnUgKTsKICAgIG1lbnUtPndGbGFncyB8PSBNRl9QT1BVUDsKICAgIG1lbnUtPmJUaW1lVG9IaWRlID0gRkFMU0U7CiAgICByZXR1cm4gaG1lbnU7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEdldE1lbnVDaGVja01hcmtEaW1lbnNpb25zICAgIChVU0VSLjQxNykKICogICAgICAgICBHZXRNZW51Q2hlY2tNYXJrRGltZW5zaW9ucyAgICAoVVNFUjMyLkApCiAqLwpEV09SRCBXSU5BUEkgR2V0TWVudUNoZWNrTWFya0RpbWVuc2lvbnModm9pZCkKewogICAgcmV0dXJuIE1BS0VMT05HKCBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYTUVOVUNIRUNLKSwgR2V0U3lzdGVtTWV0cmljcyhTTV9DWU1FTlVDSEVDSykgKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgU2V0TWVudUl0ZW1CaXRtYXBzICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIFNldE1lbnVJdGVtQml0bWFwcyggSE1FTlUgaE1lbnUsIFVJTlQgblBvcywgVUlOVCB3RmxhZ3MsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEhCSVRNQVAgaE5ld1VuQ2hlY2ssIEhCSVRNQVAgaE5ld0NoZWNrKQp7CiAgICBNRU5VSVRFTSAqaXRlbTsKICAgIFRSQUNFKCIoJXAsICUwNHgsICUwNHgsICVwLCAlcClcbiIsCiAgICAgICAgICBoTWVudSwgblBvcywgd0ZsYWdzLCBoTmV3Q2hlY2ssIGhOZXdVbkNoZWNrKTsKICAgIGlmICghKGl0ZW0gPSBNRU5VX0ZpbmRJdGVtKCAmaE1lbnUsICZuUG9zLCB3RmxhZ3MgKSkpIHJldHVybiBGQUxTRTsKCiAgICBpZiAoIWhOZXdDaGVjayAmJiAhaE5ld1VuQ2hlY2spCiAgICB7CglpdGVtLT5mU3RhdGUgJj0gfk1GX1VTRUNIRUNLQklUTUFQUzsKICAgIH0KICAgIGVsc2UgIC8qIEluc3RhbGwgbmV3IGJpdG1hcHMgKi8KICAgIHsKCWl0ZW0tPmhDaGVja0JpdCA9IGhOZXdDaGVjazsKCWl0ZW0tPmhVbkNoZWNrQml0ID0gaE5ld1VuQ2hlY2s7CglpdGVtLT5mU3RhdGUgfD0gTUZfVVNFQ0hFQ0tCSVRNQVBTOwogICAgfQogICAgcmV0dXJuIFRSVUU7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIENyZWF0ZU1lbnUgICAgKFVTRVIzMi5AKQogKi8KSE1FTlUgV0lOQVBJIENyZWF0ZU1lbnUodm9pZCkKewogICAgSE1FTlUgaE1lbnU7CiAgICBMUFBPUFVQTUVOVSBtZW51OwogICAgaWYgKCEoaE1lbnUgPSBVU0VSX0hFQVBfQUxMT0MoIHNpemVvZihQT1BVUE1FTlUpICkpKSByZXR1cm4gMDsKICAgIG1lbnUgPSAoTFBQT1BVUE1FTlUpIFVTRVJfSEVBUF9MSU5fQUREUihoTWVudSk7CgogICAgWmVyb01lbW9yeShtZW51LCBzaXplb2YoUE9QVVBNRU5VKSk7CiAgICBtZW51LT53TWFnaWMgPSBNRU5VX01BR0lDOwogICAgbWVudS0+Rm9jdXNlZEl0ZW0gPSBOT19TRUxFQ1RFRF9JVEVNOwogICAgbWVudS0+YlRpbWVUb0hpZGUgPSBGQUxTRTsKCiAgICBUUkFDRSgicmV0dXJuICVwXG4iLCBoTWVudSApOwoKICAgIHJldHVybiBoTWVudTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgRGVzdHJveU1lbnUgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgRGVzdHJveU1lbnUoIEhNRU5VIGhNZW51ICkKewogICAgTFBQT1BVUE1FTlUgbHBwb3AgPSBNRU5VX0dldE1lbnUoaE1lbnUpOwoKICAgIFRSQUNFKCIoJXApXG4iLCBoTWVudSk7CgoKICAgIGlmICghbHBwb3ApIHJldHVybiBGQUxTRTsKCiAgICBscHBvcC0+d01hZ2ljID0gMDsgIC8qIE1hcmsgaXQgYXMgZGVzdHJveWVkICovCgogICAgLyogRGVzdHJveU1lbnUgc2hvdWxkIG5vdCBkZXN0cm95IHN5c3RlbSBtZW51IHBvcHVwIG93bmVyICovCiAgICBpZiAoKGxwcG9wLT53RmxhZ3MgJiAoTUZfUE9QVVAgfCBNRl9TWVNNRU5VKSkgPT0gTUZfUE9QVVAgJiYgbHBwb3AtPmhXbmQpCiAgICB7CiAgICAgICAgRGVzdHJveVdpbmRvdyggbHBwb3AtPmhXbmQgKTsKICAgICAgICBscHBvcC0+aFduZCA9IDA7CiAgICB9CgogICAgaWYgKGxwcG9wLT5pdGVtcykgLyogcmVjdXJzaXZlbHkgZGVzdHJveSBzdWJtZW51cyAqLwogICAgewogICAgICAgIGludCBpOwogICAgICAgIE1FTlVJVEVNICppdGVtID0gbHBwb3AtPml0ZW1zOwogICAgICAgIGZvciAoaSA9IGxwcG9wLT5uSXRlbXM7IGkgPiAwOyBpLS0sIGl0ZW0rKykKICAgICAgICB7CiAgICAgICAgICAgIGlmIChpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKSBEZXN0cm95TWVudShpdGVtLT5oU3ViTWVudSk7CiAgICAgICAgICAgIE1FTlVfRnJlZUl0ZW1EYXRhKCBpdGVtICk7CiAgICAgICAgfQogICAgICAgIEhlYXBGcmVlKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBscHBvcC0+aXRlbXMgKTsKICAgIH0KICAgIFVTRVJfSEVBUF9GUkVFKCBoTWVudSApOwogICAgcmV0dXJuIFRSVUU7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEdldFN5c3RlbU1lbnUgICAgKFVTRVIzMi5AKQogKi8KSE1FTlUgV0lOQVBJIEdldFN5c3RlbU1lbnUoIEhXTkQgaFduZCwgQk9PTCBiUmV2ZXJ0ICkKewogICAgV05EICp3bmRQdHIgPSBXSU5fR2V0UHRyKCBoV25kICk7CiAgICBITUVOVSByZXR2YWx1ZSA9IDA7CgogICAgaWYgKHduZFB0ciA9PSBXTkRfREVTS1RPUCkgcmV0dXJuIDA7CiAgICBpZiAod25kUHRyID09IFdORF9PVEhFUl9QUk9DRVNTKQogICAgewogICAgICAgIGlmIChJc1dpbmRvdyggaFduZCApKSBGSVhNRSggIm5vdCBzdXBwb3J0ZWQgb24gb3RoZXIgcHJvY2VzcyB3aW5kb3cgJXBcbiIsIGhXbmQgKTsKICAgIH0KICAgIGVsc2UgaWYgKHduZFB0cikKICAgIHsKCWlmICh3bmRQdHItPmhTeXNNZW51ICYmIGJSZXZlcnQpCgl7CiAgICAgICAgICAgIERlc3Ryb3lNZW51KHduZFB0ci0+aFN5c01lbnUpOwogICAgICAgICAgICB3bmRQdHItPmhTeXNNZW51ID0gMDsKCX0KCglpZighd25kUHRyLT5oU3lzTWVudSAmJiAod25kUHRyLT5kd1N0eWxlICYgV1NfU1lTTUVOVSkgKQoJICAgIHduZFB0ci0+aFN5c01lbnUgPSBNRU5VX0dldFN5c01lbnUoIGhXbmQsIDAgKTsKCglpZiggd25kUHRyLT5oU3lzTWVudSApCiAgICAgICAgewoJICAgIFBPUFVQTUVOVSAqbWVudTsKCSAgICByZXR2YWx1ZSA9IEdldFN1Yk1lbnUod25kUHRyLT5oU3lzTWVudSwgMCk7CgoJICAgIC8qIFN0b3JlIHRoZSBkdW1teSBzeXNtZW51IGhhbmRsZSB0byBmYWNpbGl0YXRlIHRoZSByZWZyZXNoICovCgkgICAgLyogb2YgdGhlIGNsb3NlIGJ1dHRvbiBpZiB0aGUgU0NfQ0xPU0UgaXRlbSBjaGFuZ2UgKi8KCSAgICBtZW51ID0gTUVOVV9HZXRNZW51KHJldHZhbHVlKTsKCSAgICBpZiAoIG1lbnUgKQoJICAgICAgIG1lbnUtPmhTeXNNZW51T3duZXIgPSB3bmRQdHItPmhTeXNNZW51OwogICAgICAgIH0KICAgICAgICBXSU5fUmVsZWFzZVB0ciggd25kUHRyICk7CiAgICB9CiAgICByZXR1cm4gYlJldmVydCA/IDAgOiByZXR2YWx1ZTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgU2V0U3lzdGVtTWVudSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBTZXRTeXN0ZW1NZW51KCBIV05EIGh3bmQsIEhNRU5VIGhNZW51ICkKewogICAgV05EICp3bmRQdHIgPSBXSU5fR2V0UHRyKCBod25kICk7CgogICAgaWYgKHduZFB0ciAmJiB3bmRQdHIgIT0gV05EX09USEVSX1BST0NFU1MgJiYgd25kUHRyICE9IFdORF9ERVNLVE9QKQogICAgewoJaWYgKHduZFB0ci0+aFN5c01lbnUpIERlc3Ryb3lNZW51KCB3bmRQdHItPmhTeXNNZW51ICk7Cgl3bmRQdHItPmhTeXNNZW51ID0gTUVOVV9HZXRTeXNNZW51KCBod25kLCBoTWVudSApOwogICAgICAgIFdJTl9SZWxlYXNlUHRyKCB3bmRQdHIgKTsKCXJldHVybiBUUlVFOwogICAgfQogICAgcmV0dXJuIEZBTFNFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBHZXRNZW51ICAgIChVU0VSMzIuQCkKICovCkhNRU5VIFdJTkFQSSBHZXRNZW51KCBIV05EIGhXbmQgKQp7CiAgICBITUVOVSByZXR2YWx1ZSA9IChITUVOVSlHZXRXaW5kb3dMb25nUHRyVyggaFduZCwgR1dMUF9JRCApOwogICAgVFJBQ0UoImZvciAlcCByZXR1cm5pbmcgJXBcbiIsIGhXbmQsIHJldHZhbHVlKTsKICAgIHJldHVybiByZXR2YWx1ZTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBHZXRNZW51QmFySW5mbyAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBHZXRNZW51QmFySW5mbyggSFdORCBod25kLCBMT05HIGlkT2JqZWN0LCBMT05HIGlkSXRlbSwgUE1FTlVCQVJJTkZPIHBtYmkgKQp7CiAgICBGSVhNRSggIiglcCwweCUwOHgsMHglMDh4LCVwKVxuIiwgaHduZCwgaWRPYmplY3QsIGlkSXRlbSwgcG1iaSApOwogICAgcmV0dXJuIEZBTFNFOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIE1FTlVfU2V0TWVudQogKgogKiBIZWxwZXIgZm9yIFNldE1lbnUuIEFsc28gY2FsbGVkIGJ5IFdJTl9DcmVhdGVXaW5kb3dFeCB0byBhdm9pZCB0aGUKICogU2V0V2luZG93UG9zIGNhbGwgdGhhdCB3b3VsZCByZXN1bHQgaWYgU2V0TWVudSB3ZXJlIGNhbGxlZCBkaXJlY3RseS4KICovCkJPT0wgTUVOVV9TZXRNZW51KCBIV05EIGhXbmQsIEhNRU5VIGhNZW51ICkKewogICAgVFJBQ0UoIiglcCwgJXApO1xuIiwgaFduZCwgaE1lbnUpOwoKICAgIGlmIChoTWVudSAmJiAhSXNNZW51KGhNZW51KSkKICAgIHsKICAgICAgICBXQVJOKCJoTWVudSAlcCBpcyBub3QgYSBtZW51IGhhbmRsZVxuIiwgaE1lbnUpOwogICAgICAgIHJldHVybiBGQUxTRTsKICAgIH0KICAgIGlmICghV0lOX0FMTE9XRURfTUVOVShHZXRXaW5kb3dMb25nVyggaFduZCwgR1dMX1NUWUxFICkpKQogICAgICAgIHJldHVybiBGQUxTRTsKCiAgICBoV25kID0gV0lOX0dldEZ1bGxIYW5kbGUoIGhXbmQgKTsKICAgIGlmIChHZXRDYXB0dXJlKCkgPT0gaFduZCkgTUVOVV9TZXRDYXB0dXJlKDApOyAgLyogcmVsZWFzZSB0aGUgY2FwdHVyZSAqLwoKICAgIGlmIChoTWVudSAhPSAwKQogICAgewogICAgICAgIExQUE9QVVBNRU5VIGxwbWVudTsKCiAgICAgICAgaWYgKCEobHBtZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KSkpIHJldHVybiBGQUxTRTsKCiAgICAgICAgbHBtZW51LT5oV25kID0gaFduZDsKICAgICAgICBscG1lbnUtPkhlaWdodCA9IDA7ICAvKiBNYWtlIHN1cmUgd2UgcmVjYWxjdWxhdGUgdGhlIHNpemUgKi8KICAgIH0KICAgIFNldFdpbmRvd0xvbmdQdHJXKCBoV25kLCBHV0xQX0lELCAoTE9OR19QVFIpaE1lbnUgKTsKICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBTZXRNZW51ICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIFNldE1lbnUoIEhXTkQgaFduZCwgSE1FTlUgaE1lbnUgKQp7ICAgCiAgICBpZighTUVOVV9TZXRNZW51KGhXbmQsIGhNZW51KSkKICAgICAgICByZXR1cm4gRkFMU0U7CiAKICAgIFNldFdpbmRvd1BvcyggaFduZCwgMCwgMCwgMCwgMCwgMCwgU1dQX05PU0laRSB8IFNXUF9OT01PVkUgfAogICAgICAgICAgICAgICAgICBTV1BfTk9BQ1RJVkFURSB8IFNXUF9OT1pPUkRFUiB8IFNXUF9GUkFNRUNIQU5HRUQgKTsKICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBHZXRTdWJNZW51ICAgIChVU0VSMzIuQCkKICovCkhNRU5VIFdJTkFQSSBHZXRTdWJNZW51KCBITUVOVSBoTWVudSwgSU5UIG5Qb3MgKQp7CiAgICBNRU5VSVRFTSAqIGxwbWk7CgogICAgaWYgKCEobHBtaSA9IE1FTlVfRmluZEl0ZW0oJmhNZW51LChVSU5UKikmblBvcyxNRl9CWVBPU0lUSU9OKSkpIHJldHVybiAwOwogICAgaWYgKCEobHBtaS0+ZlR5cGUgJiBNRl9QT1BVUCkpIHJldHVybiAwOwogICAgcmV0dXJuIGxwbWktPmhTdWJNZW51Owp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBEcmF3TWVudUJhciAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBEcmF3TWVudUJhciggSFdORCBoV25kICkKewogICAgTFBQT1BVUE1FTlUgbHBwb3A7CiAgICBITUVOVSBoTWVudSA9IEdldE1lbnUoaFduZCk7CgogICAgaWYgKCFXSU5fQUxMT1dFRF9NRU5VKEdldFdpbmRvd0xvbmdXKCBoV25kLCBHV0xfU1RZTEUgKSkpCiAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgaWYgKCFoTWVudSB8fCAhKGxwcG9wID0gTUVOVV9HZXRNZW51KCBoTWVudSApKSkgcmV0dXJuIEZBTFNFOwoKICAgIGxwcG9wLT5IZWlnaHQgPSAwOyAvKiBNYWtlIHN1cmUgd2UgY2FsbCBNRU5VX01lbnVCYXJDYWxjU2l6ZSAqLwogICAgbHBwb3AtPmh3bmRPd25lciA9IGhXbmQ7CiAgICBTZXRXaW5kb3dQb3MoIGhXbmQsIDAsIDAsIDAsIDAsIDAsIFNXUF9OT1NJWkUgfCBTV1BfTk9NT1ZFIHwKICAgICAgICAgICAgICAgICAgU1dQX05PQUNUSVZBVEUgfCBTV1BfTk9aT1JERVIgfCBTV1BfRlJBTUVDSEFOR0VEICk7CiAgICByZXR1cm4gVFJVRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBEcmF3TWVudUJhclRlbXAgICAoVVNFUjMyLkApCiAqCiAqIFVORE9DVU1FTlRFRCAhIQogKgogKiBjYWxsZWQgYnkgVzk4U0UgZGVzay5jcGwgQ29udHJvbCBQYW5lbCBBcHBsZXQKICoKICogTm90IDEwMCUgc3VyZSBhYm91dCB0aGUgcGFyYW0gbmFtZXMsIGJ1dCBjbG9zZS4KICovCkRXT1JEIFdJTkFQSSBEcmF3TWVudUJhclRlbXAoSFdORCBod25kLCBIREMgaERDLCBMUFJFQ1QgbHByZWN0LCBITUVOVSBoTWVudSwgSEZPTlQgaEZvbnQpCnsKICAgIExQUE9QVVBNRU5VIGxwcG9wOwogICAgVUlOVCBpLHJldHZhbHVlOwogICAgSEZPTlQgaGZvbnRPbGQgPSAwOwogICAgQk9PTCBmbGF0X21lbnUgPSBGQUxTRTsKCiAgICBTeXN0ZW1QYXJhbWV0ZXJzSW5mb1cgKFNQSV9HRVRGTEFUTUVOVSwgMCwgJmZsYXRfbWVudSwgMCk7CgogICAgaWYgKCFoTWVudSkKICAgICAgICBoTWVudSA9IEdldE1lbnUoaHduZCk7CgogICAgaWYgKCFoRm9udCkKICAgICAgICBoRm9udCA9IGdldF9tZW51X2ZvbnQoRkFMU0UpOwoKICAgIGxwcG9wID0gTUVOVV9HZXRNZW51KCBoTWVudSApOwogICAgaWYgKGxwcG9wID09IE5VTEwgfHwgbHByZWN0ID09IE5VTEwpCiAgICB7CiAgICAgICAgcmV0dmFsdWUgPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZTUVOVSk7CiAgICAgICAgZ290byBFTkQ7CiAgICB9CgogICAgVFJBQ0UoIiglcCwgJXAsICVwLCAlcCwgJXApXG4iLCBod25kLCBoREMsIGxwcmVjdCwgaE1lbnUsIGhGb250KTsKCiAgICBoZm9udE9sZCA9IFNlbGVjdE9iamVjdCggaERDLCBoRm9udCk7CgogICAgaWYgKGxwcG9wLT5IZWlnaHQgPT0gMCkKICAgICAgICBNRU5VX01lbnVCYXJDYWxjU2l6ZShoREMsIGxwcmVjdCwgbHBwb3AsIGh3bmQpOwoKICAgIGxwcmVjdC0+Ym90dG9tID0gbHByZWN0LT50b3AgKyBscHBvcC0+SGVpZ2h0OwoKICAgIEZpbGxSZWN0KGhEQywgbHByZWN0LCBHZXRTeXNDb2xvckJydXNoKGZsYXRfbWVudSA/IENPTE9SX01FTlVCQVIgOiBDT0xPUl9NRU5VKSApOwoKICAgIFNlbGVjdE9iamVjdCggaERDLCBTWVNDT0xPUl9HZXRQZW4oQ09MT1JfM0RGQUNFKSk7CiAgICBNb3ZlVG9FeCggaERDLCBscHJlY3QtPmxlZnQsIGxwcmVjdC0+Ym90dG9tLCBOVUxMICk7CiAgICBMaW5lVG8oIGhEQywgbHByZWN0LT5yaWdodCwgbHByZWN0LT5ib3R0b20gKTsKCiAgICBpZiAobHBwb3AtPm5JdGVtcyA9PSAwKQogICAgewogICAgICAgIHJldHZhbHVlID0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWU1FTlUpOwogICAgICAgIGdvdG8gRU5EOwogICAgfQoKICAgIGZvciAoaSA9IDA7IGkgPCBscHBvcC0+bkl0ZW1zOyBpKyspCiAgICB7CiAgICAgICAgTUVOVV9EcmF3TWVudUl0ZW0oIGh3bmQsIGhNZW51LCBod25kLAogICAgICAgICAgICAgICAgICAgICAgICAgICBoREMsICZscHBvcC0+aXRlbXNbaV0sIGxwcG9wLT5IZWlnaHQsIFRSVUUsIE9EQV9EUkFXRU5USVJFICk7CiAgICB9CiAgICByZXR2YWx1ZSA9IGxwcG9wLT5IZWlnaHQ7CgpFTkQ6CiAgICBpZiAoaGZvbnRPbGQpIFNlbGVjdE9iamVjdCAoaERDLCBoZm9udE9sZCk7CiAgICByZXR1cm4gcmV0dmFsdWU7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgRW5kTWVudSAgIChVU0VSLjE4NykKICogICAgICAgICAgIEVuZE1lbnUgICAoVVNFUjMyLkApCiAqLwp2b2lkIFdJTkFQSSBFbmRNZW51KHZvaWQpCnsKICAgIC8qIGlmIHdlIGFyZSBpbiB0aGUgbWVudSBjb2RlLCBhbmQgaXQgaXMgYWN0aXZlICovCiAgICBpZiAoIWZFbmRNZW51ICYmIHRvcF9wb3B1cCkKICAgIHsKCS8qIHRlcm1pbmF0ZSB0aGUgbWVudSBoYW5kbGluZyBjb2RlICovCiAgICAgICAgZkVuZE1lbnUgPSBUUlVFOwoKCS8qIG5lZWRzIHRvIGJlIHBvc3RlZCB0byB3YWtldXAgdGhlIGludGVybmFsIG1lbnUgaGFuZGxlciAqLwoJLyogd2hpY2ggd2lsbCBub3cgdGVybWluYXRlIHRoZSBtZW51LCBpbiB0aGUgZXZlbnQgdGhhdCAqLwoJLyogdGhlIG1haW4gd2luZG93IHdhcyBtaW5pbWl6ZWQsIG9yIGxvc3QgZm9jdXMsIHNvIHdlICovCgkvKiBkb24ndCBlbmQgdXAgd2l0aCBhbiBvcnBoYW5lZCBtZW51ICovCiAgICAgICAgUG9zdE1lc3NhZ2VXKCB0b3BfcG9wdXAsIFdNX0NBTkNFTE1PREUsIDAsIDApOwogICAgfQp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBMb29rdXBNZW51SGFuZGxlICAgKFVTRVIuMjE3KQogKi8KSE1FTlUxNiBXSU5BUEkgTG9va3VwTWVudUhhbmRsZTE2KCBITUVOVTE2IGhtZW51LCBJTlQxNiBpZCApCnsKICAgIEhNRU5VIGhtZW51MzIgPSBITUVOVV8zMihobWVudSk7CiAgICBVSU5UIGlkMzIgPSBpZDsKICAgIGlmICghTUVOVV9GaW5kSXRlbSggJmhtZW51MzIsICZpZDMyLCBNRl9CWUNPTU1BTkQgKSkgcmV0dXJuIDA7CiAgICBlbHNlIHJldHVybiBITUVOVV8xNihobWVudTMyKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCSAgICBMb2FkTWVudSAgICAoVVNFUi4xNTApCiAqLwpITUVOVTE2IFdJTkFQSSBMb2FkTWVudTE2KCBISU5TVEFOQ0UxNiBpbnN0YW5jZSwgTFBDU1RSIG5hbWUgKQp7CiAgICBIUlNSQzE2IGhSc3JjOwogICAgSEdMT0JBTDE2IGhhbmRsZTsKICAgIEhNRU5VMTYgaE1lbnU7CgogICAgaWYgKEhJV09SRChuYW1lKSAmJiBuYW1lWzBdID09ICcjJykgbmFtZSA9IChMUENTVFIpYXRvaSggbmFtZSArIDEgKTsKICAgIGlmICghbmFtZSkgcmV0dXJuIDA7CgogICAgaW5zdGFuY2UgPSBHZXRFeGVQdHIoIGluc3RhbmNlICk7CiAgICBpZiAoIShoUnNyYyA9IEZpbmRSZXNvdXJjZTE2KCBpbnN0YW5jZSwgbmFtZSwgKExQU1RSKVJUX01FTlUgKSkpIHJldHVybiAwOwogICAgaWYgKCEoaGFuZGxlID0gTG9hZFJlc291cmNlMTYoIGluc3RhbmNlLCBoUnNyYyApKSkgcmV0dXJuIDA7CiAgICBoTWVudSA9IExvYWRNZW51SW5kaXJlY3QxNihMb2NrUmVzb3VyY2UxNihoYW5kbGUpKTsKICAgIEZyZWVSZXNvdXJjZTE2KCBoYW5kbGUgKTsKICAgIHJldHVybiBoTWVudTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgTG9hZE1lbnVBICAgKFVTRVIzMi5AKQogKi8KSE1FTlUgV0lOQVBJIExvYWRNZW51QSggSElOU1RBTkNFIGluc3RhbmNlLCBMUENTVFIgbmFtZSApCnsKICAgIEhSU1JDIGhyc3JjID0gRmluZFJlc291cmNlQSggaW5zdGFuY2UsIG5hbWUsIChMUFNUUilSVF9NRU5VICk7CiAgICBpZiAoIWhyc3JjKSByZXR1cm4gMDsKICAgIHJldHVybiBMb2FkTWVudUluZGlyZWN0QSggKExQQ1ZPSUQpTG9hZFJlc291cmNlKCBpbnN0YW5jZSwgaHJzcmMgKSk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgIExvYWRNZW51VyAgIChVU0VSMzIuQCkKICovCkhNRU5VIFdJTkFQSSBMb2FkTWVudVcoIEhJTlNUQU5DRSBpbnN0YW5jZSwgTFBDV1NUUiBuYW1lICkKewogICAgSFJTUkMgaHJzcmMgPSBGaW5kUmVzb3VyY2VXKCBpbnN0YW5jZSwgbmFtZSwgKExQV1NUUilSVF9NRU5VICk7CiAgICBpZiAoIWhyc3JjKSByZXR1cm4gMDsKICAgIHJldHVybiBMb2FkTWVudUluZGlyZWN0VyggKExQQ1ZPSUQpTG9hZFJlc291cmNlKCBpbnN0YW5jZSwgaHJzcmMgKSk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkgICAgTG9hZE1lbnVJbmRpcmVjdCAgICAoVVNFUi4yMjApCiAqLwpITUVOVTE2IFdJTkFQSSBMb2FkTWVudUluZGlyZWN0MTYoIExQQ1ZPSUQgdGVtcGxhdGUgKQp7CiAgICBITUVOVSBoTWVudTsKICAgIFdPUkQgdmVyc2lvbiwgb2Zmc2V0OwogICAgTFBDU1RSIHAgPSAoTFBDU1RSKXRlbXBsYXRlOwoKICAgIFRSQUNFKCIoJXApXG4iLCB0ZW1wbGF0ZSApOwogICAgdmVyc2lvbiA9IEdFVF9XT1JEKHApOwogICAgcCArPSBzaXplb2YoV09SRCk7CiAgICBpZiAodmVyc2lvbikKICAgIHsKICAgICAgICBXQVJOKCJ2ZXJzaW9uIG11c3QgYmUgMCBmb3IgV2luMTZcbiIgKTsKICAgICAgICByZXR1cm4gMDsKICAgIH0KICAgIG9mZnNldCA9IEdFVF9XT1JEKHApOwogICAgcCArPSBzaXplb2YoV09SRCkgKyBvZmZzZXQ7CiAgICBpZiAoIShoTWVudSA9IENyZWF0ZU1lbnUoKSkpIHJldHVybiAwOwogICAgaWYgKCFNRU5VX1BhcnNlUmVzb3VyY2UoIHAsIGhNZW51LCBGQUxTRSApKQogICAgewogICAgICAgIERlc3Ryb3lNZW51KCBoTWVudSApOwogICAgICAgIHJldHVybiAwOwogICAgfQogICAgcmV0dXJuIEhNRU5VXzE2KGhNZW51KTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCSAgICBMb2FkTWVudUluZGlyZWN0VyAgICAoVVNFUjMyLkApCiAqLwpITUVOVSBXSU5BUEkgTG9hZE1lbnVJbmRpcmVjdFcoIExQQ1ZPSUQgdGVtcGxhdGUgKQp7CiAgICBITUVOVSBoTWVudTsKICAgIFdPUkQgdmVyc2lvbiwgb2Zmc2V0OwogICAgTFBDU1RSIHAgPSAoTFBDU1RSKXRlbXBsYXRlOwoKICAgIHZlcnNpb24gPSBHRVRfV09SRChwKTsKICAgIHAgKz0gc2l6ZW9mKFdPUkQpOwogICAgVFJBQ0UoIiVwLCB2ZXIgJWRcbiIsIHRlbXBsYXRlLCB2ZXJzaW9uICk7CiAgICBzd2l0Y2ggKHZlcnNpb24pCiAgICB7CiAgICAgIGNhc2UgMDogLyogc3RhbmRhcmQgZm9ybWF0IGlzIHZlcnNpb24gb2YgMCAqLwoJb2Zmc2V0ID0gR0VUX1dPUkQocCk7CglwICs9IHNpemVvZihXT1JEKSArIG9mZnNldDsKCWlmICghKGhNZW51ID0gQ3JlYXRlTWVudSgpKSkgcmV0dXJuIDA7CglpZiAoIU1FTlVfUGFyc2VSZXNvdXJjZSggcCwgaE1lbnUsIFRSVUUgKSkKCSAgewoJICAgIERlc3Ryb3lNZW51KCBoTWVudSApOwoJICAgIHJldHVybiAwOwoJICB9CglyZXR1cm4gaE1lbnU7CiAgICAgIGNhc2UgMTogLyogZXh0ZW5kZWQgZm9ybWF0IGlzIHZlcnNpb24gb2YgMSAqLwoJb2Zmc2V0ID0gR0VUX1dPUkQocCk7CglwICs9IHNpemVvZihXT1JEKSArIG9mZnNldDsKCWlmICghKGhNZW51ID0gQ3JlYXRlTWVudSgpKSkgcmV0dXJuIDA7CglpZiAoIU1FTlVFWF9QYXJzZVJlc291cmNlKCBwLCBoTWVudSkpCgkgIHsKCSAgICBEZXN0cm95TWVudSggaE1lbnUgKTsKCSAgICByZXR1cm4gMDsKCSAgfQoJcmV0dXJuIGhNZW51OwogICAgICBkZWZhdWx0OgogICAgICAgIEVSUigidmVyc2lvbiAlZCBub3Qgc3VwcG9ydGVkLlxuIiwgdmVyc2lvbik7CiAgICAgICAgcmV0dXJuIDA7CiAgICB9Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkgICAgTG9hZE1lbnVJbmRpcmVjdEEgICAgKFVTRVIzMi5AKQogKi8KSE1FTlUgV0lOQVBJIExvYWRNZW51SW5kaXJlY3RBKCBMUENWT0lEIHRlbXBsYXRlICkKewogICAgcmV0dXJuIExvYWRNZW51SW5kaXJlY3RXKCB0ZW1wbGF0ZSApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCUlzTWVudSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBJc01lbnUoSE1FTlUgaG1lbnUpCnsKICAgIExQUE9QVVBNRU5VIG1lbnUgPSBNRU5VX0dldE1lbnUoaG1lbnUpOwoKICAgIGlmICghbWVudSkKICAgIHsKICAgICAgICBTZXRMYXN0RXJyb3IoRVJST1JfSU5WQUxJRF9NRU5VX0hBTkRMRSk7CiAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgfQogICAgcmV0dXJuIFRSVUU7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCQlHZXRNZW51SXRlbUluZm9fY29tbW9uCiAqLwoKc3RhdGljIEJPT0wgR2V0TWVudUl0ZW1JbmZvX2NvbW1vbiAoIEhNRU5VIGhtZW51LCBVSU5UIGl0ZW0sIEJPT0wgYnlwb3MsCgkJCQkJTFBNRU5VSVRFTUlORk9XIGxwbWlpLCBCT09MIHVuaWNvZGUpCnsKICAgIE1FTlVJVEVNICptZW51ID0gTUVOVV9GaW5kSXRlbSAoJmhtZW51LCAmaXRlbSwgYnlwb3MgPyBNRl9CWVBPU0lUSU9OIDogMCk7CgogICAgZGVidWdfcHJpbnRfbWVudWl0ZW0oIkdldE1lbnVJdGVtSW5mb19jb21tb246ICIsIG1lbnUsICIiKTsKCiAgICBpZiAoIW1lbnUpCglyZXR1cm4gRkFMU0U7CiAgICAKICAgIGlmKCBscG1paS0+Zk1hc2sgJiBNSUlNX1RZUEUpIHsKICAgICAgICBpZiggbHBtaWktPmZNYXNrICYgKCBNSUlNX1NUUklORyB8IE1JSU1fRlRZUEUgfCBNSUlNX0JJVE1BUCkpIHsKICAgICAgICAgICAgV0FSTigiaW52YWxpZCBjb21iaW5hdGlvbiBvZiBmTWFzayBiaXRzIHVzZWRcbiIpOwogICAgICAgICAgICAvKiB0aGlzIGRvZXMgbm90IGhhcHBlbiBvbiBXaW45eC9NRSAqLwogICAgICAgICAgICBTZXRMYXN0RXJyb3IoIEVSUk9SX0lOVkFMSURfUEFSQU1FVEVSKTsKICAgICAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgICAgIH0KCWxwbWlpLT5mVHlwZSA9IG1lbnUtPmZUeXBlICYgTUVOVUlURU1JTkZPX1RZUEVfTUFTSzsKICAgICAgICBpZiggbWVudS0+aGJtcEl0ZW0pIGxwbWlpLT5mVHlwZSB8PSBNRlRfQklUTUFQOwoJbHBtaWktPmhibXBJdGVtID0gbWVudS0+aGJtcEl0ZW07IC8qIG5vdCBvbiBXaW45eC9NRSAqLwogICAgICAgIGlmKCBscG1paS0+ZlR5cGUgJiBNRlRfQklUTUFQKSB7CgkgICAgbHBtaWktPmR3VHlwZURhdGEgPSAoTFBXU1RSKSBtZW51LT5oYm1wSXRlbTsKCSAgICBscG1paS0+Y2NoID0gMDsKICAgICAgICB9IGVsc2UgaWYoIGxwbWlpLT5mVHlwZSAmIChNRlRfT1dORVJEUkFXIHwgTUZUX1NFUEFSQVRPUikpIHsKICAgICAgICAgICAgLyogdGhpcyBkb2VzIG5vdCBoYXBwZW4gb24gV2luOXgvTUUgKi8KCSAgICBscG1paS0+ZHdUeXBlRGF0YSA9IDA7CgkgICAgbHBtaWktPmNjaCA9IDA7CiAgICAgICAgfQogICAgfQoKICAgIC8qIGNvcHkgdGhlIHRleHQgc3RyaW5nICovCiAgICBpZiAoKGxwbWlpLT5mTWFzayAmIChNSUlNX1RZUEV8TUlJTV9TVFJJTkcpKSkgewogICAgICAgICBpZiggIW1lbnUtPnRleHQgKSB7CiAgICAgICAgICAgICAgICBpZihscG1paS0+ZHdUeXBlRGF0YSAmJiBscG1paS0+Y2NoKSB7CiAgICAgICAgICAgICAgICAgICAgbHBtaWktPmNjaCA9IDA7CiAgICAgICAgICAgICAgICAgICAgaWYoIHVuaWNvZGUpCiAgICAgICAgICAgICAgICAgICAgICAgICooKFdDSEFSICopbHBtaWktPmR3VHlwZURhdGEpID0gMDsKICAgICAgICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICAgICAgICAgICooKENIQVIgKilscG1paS0+ZHdUeXBlRGF0YSkgPSAwOwogICAgICAgICAgICAgICAgfQogICAgICAgICB9IGVsc2UgewogICAgICAgICAgICBpbnQgbGVuOwogICAgICAgICAgICBpZiAodW5pY29kZSkKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgbGVuID0gc3RybGVuVyhtZW51LT50ZXh0KTsKICAgICAgICAgICAgICAgIGlmKGxwbWlpLT5kd1R5cGVEYXRhICYmIGxwbWlpLT5jY2gpCiAgICAgICAgICAgICAgICAgICAgbHN0cmNweW5XKGxwbWlpLT5kd1R5cGVEYXRhLCBtZW51LT50ZXh0LCBscG1paS0+Y2NoKTsKICAgICAgICAgICAgfQogICAgICAgICAgICBlbHNlCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIGxlbiA9IFdpZGVDaGFyVG9NdWx0aUJ5dGUoIENQX0FDUCwgMCwgbWVudS0+dGV4dCwgLTEsIE5VTEwsCiAgICAgICAgICAgICAgICAgICAgICAgIDAsIE5VTEwsIE5VTEwgKSAtIDE7CiAgICAgICAgICAgICAgICBpZihscG1paS0+ZHdUeXBlRGF0YSAmJiBscG1paS0+Y2NoKQogICAgICAgICAgICAgICAgICAgIGlmICghV2lkZUNoYXJUb011bHRpQnl0ZSggQ1BfQUNQLCAwLCBtZW51LT50ZXh0LCAtMSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgIChMUFNUUilscG1paS0+ZHdUeXBlRGF0YSwgbHBtaWktPmNjaCwgTlVMTCwgTlVMTCApKQogICAgICAgICAgICAgICAgICAgICAgICAoKExQU1RSKWxwbWlpLT5kd1R5cGVEYXRhKVtscG1paS0+Y2NoIC0gMV0gPSAwOwogICAgICAgICAgICB9CiAgICAgICAgICAgIC8qIGlmIHdlJ3ZlIGNvcGllZCBhIHN1YnN0cmluZyB3ZSByZXR1cm4gaXRzIGxlbmd0aCAqLwogICAgICAgICAgICBpZihscG1paS0+ZHdUeXBlRGF0YSAmJiBscG1paS0+Y2NoKQogICAgICAgICAgICAgICAgaWYgKGxwbWlpLT5jY2ggPD0gbGVuICsgMSkKICAgICAgICAgICAgICAgICAgICBscG1paS0+Y2NoLS07CiAgICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICAgICAgbHBtaWktPmNjaCA9IGxlbjsKICAgICAgICAgICAgZWxzZSB7CiAgICAgICAgICAgICAgICAvKiByZXR1cm4gbGVuZ3RoIG9mIHN0cmluZyAqLwogICAgICAgICAgICAgICAgLyogbm90IG9uIFdpbjl4L01FIGlmIGZUeXBlICYgTUZUX0JJVE1BUCAqLwogICAgICAgICAgICAgICAgbHBtaWktPmNjaCA9IGxlbjsKICAgICAgICAgICAgfQogICAgICAgIH0KICAgIH0KCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9GVFlQRSkKCWxwbWlpLT5mVHlwZSA9IG1lbnUtPmZUeXBlICYgTUVOVUlURU1JTkZPX1RZUEVfTUFTSzsKCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9CSVRNQVApCglscG1paS0+aGJtcEl0ZW0gPSBtZW51LT5oYm1wSXRlbTsKCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9TVEFURSkKCWxwbWlpLT5mU3RhdGUgPSBtZW51LT5mU3RhdGUgJiBNRU5VSVRFTUlORk9fU1RBVEVfTUFTSzsKCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9JRCkKCWxwbWlpLT53SUQgPSBtZW51LT53SUQ7CgogICAgaWYgKGxwbWlpLT5mTWFzayAmIE1JSU1fU1VCTUVOVSkKCWxwbWlpLT5oU3ViTWVudSA9IG1lbnUtPmhTdWJNZW51OwogICAgZWxzZSB7CiAgICAgICAgLyogaFN1Yk1lbnUgaXMgYWx3YXlzIGNsZWFyZWQgCiAgICAgICAgICogKG5vdCBvbiBXaW45eC9NRSApICovCiAgICAgICAgbHBtaWktPmhTdWJNZW51ID0gMDsKICAgIH0KCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9DSEVDS01BUktTKSB7CglscG1paS0+aGJtcENoZWNrZWQgPSBtZW51LT5oQ2hlY2tCaXQ7CglscG1paS0+aGJtcFVuY2hlY2tlZCA9IG1lbnUtPmhVbkNoZWNrQml0OwogICAgfQogICAgaWYgKGxwbWlpLT5mTWFzayAmIE1JSU1fREFUQSkKCWxwbWlpLT5kd0l0ZW1EYXRhID0gbWVudS0+ZHdJdGVtRGF0YTsKCiAgcmV0dXJuIFRSVUU7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCQlHZXRNZW51SXRlbUluZm9BICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIEdldE1lbnVJdGVtSW5mb0EoIEhNRU5VIGhtZW51LCBVSU5UIGl0ZW0sIEJPT0wgYnlwb3MsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBMUE1FTlVJVEVNSU5GT0EgbHBtaWkpCnsKICAgIEJPT0wgcmV0OwogICAgTUVOVUlURU1JTkZPQSBtaWk7CiAgICBpZiggbHBtaWktPmNiU2l6ZSAhPSBzaXplb2YoIG1paSkgJiYKICAgICAgICAgICAgbHBtaWktPmNiU2l6ZSAhPSBzaXplb2YoIG1paSkgLSBzaXplb2YgKCBtaWkuaGJtcEl0ZW0pKSB7CiAgICAgICAgU2V0TGFzdEVycm9yKCBFUlJPUl9JTlZBTElEX1BBUkFNRVRFUik7CiAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgfQogICAgbWVtY3B5KCAmbWlpLCBscG1paSwgbHBtaWktPmNiU2l6ZSk7CiAgICBtaWkuY2JTaXplID0gc2l6ZW9mKCBtaWkpOwogICAgcmV0ID0gR2V0TWVudUl0ZW1JbmZvX2NvbW1vbiAoaG1lbnUsIGl0ZW0sIGJ5cG9zLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoTFBNRU5VSVRFTUlORk9XKSZtaWksIEZBTFNFKTsKICAgIG1paS5jYlNpemUgPSBscG1paS0+Y2JTaXplOwogICAgbWVtY3B5KCBscG1paSwgJm1paSwgbWlpLmNiU2l6ZSk7CiAgICByZXR1cm4gcmV0Owp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJR2V0TWVudUl0ZW1JbmZvVyAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBHZXRNZW51SXRlbUluZm9XKCBITUVOVSBobWVudSwgVUlOVCBpdGVtLCBCT09MIGJ5cG9zLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTFBNRU5VSVRFTUlORk9XIGxwbWlpKQp7CiAgICBCT09MIHJldDsKICAgIE1FTlVJVEVNSU5GT1cgbWlpOwogICAgaWYoIGxwbWlpLT5jYlNpemUgIT0gc2l6ZW9mKCBtaWkpICYmCiAgICAgICAgICAgIGxwbWlpLT5jYlNpemUgIT0gc2l6ZW9mKCBtaWkpIC0gc2l6ZW9mICggbWlpLmhibXBJdGVtKSkgewogICAgICAgIFNldExhc3RFcnJvciggRVJST1JfSU5WQUxJRF9QQVJBTUVURVIpOwogICAgICAgIHJldHVybiBGQUxTRTsKICAgIH0KICAgIG1lbWNweSggJm1paSwgbHBtaWksIGxwbWlpLT5jYlNpemUpOwogICAgbWlpLmNiU2l6ZSA9IHNpemVvZiggbWlpKTsKICAgIHJldCA9IEdldE1lbnVJdGVtSW5mb19jb21tb24gKGhtZW51LCBpdGVtLCBieXBvcywgJm1paSwgVFJVRSk7CiAgICBtaWkuY2JTaXplID0gbHBtaWktPmNiU2l6ZTsKICAgIG1lbWNweSggbHBtaWksICZtaWksIG1paS5jYlNpemUpOwogICAgcmV0dXJuIHJldDsKfQoKCi8qIHNldCBhIG1lbnUgaXRlbSB0ZXh0IGZyb20gYSBBU0NJSSBvciBVbmljb2RlIHN0cmluZyAqLwppbmxpbmUgc3RhdGljIHZvaWQgc2V0X21lbnVfaXRlbV90ZXh0KCBNRU5VSVRFTSAqbWVudSwgTFBDV1NUUiB0ZXh0LCBCT09MIHVuaWNvZGUgKQp7CiAgICBpZiAoIXRleHQpCiAgICAgICAgbWVudS0+dGV4dCA9IE5VTEw7CiAgICBlbHNlIGlmICh1bmljb2RlKQogICAgewogICAgICAgIGlmICgobWVudS0+dGV4dCA9IEhlYXBBbGxvYyggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgKHN0cmxlblcodGV4dCkrMSkgKiBzaXplb2YoV0NIQVIpICkpKQogICAgICAgICAgICBzdHJjcHlXKCBtZW51LT50ZXh0LCB0ZXh0ICk7CiAgICB9CiAgICBlbHNlCiAgICB7CiAgICAgICAgTFBDU1RSIHN0ciA9IChMUENTVFIpdGV4dDsKICAgICAgICBpbnQgbGVuID0gTXVsdGlCeXRlVG9XaWRlQ2hhciggQ1BfQUNQLCAwLCBzdHIsIC0xLCBOVUxMLCAwICk7CiAgICAgICAgaWYgKChtZW51LT50ZXh0ID0gSGVhcEFsbG9jKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBsZW4gKiBzaXplb2YoV0NIQVIpICkpKQogICAgICAgICAgICBNdWx0aUJ5dGVUb1dpZGVDaGFyKCBDUF9BQ1AsIDAsIHN0ciwgLTEsIG1lbnUtPnRleHQsIGxlbiApOwogICAgfQp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCVNldE1lbnVJdGVtSW5mb19jb21tb24KICovCgpzdGF0aWMgQk9PTCBTZXRNZW51SXRlbUluZm9fY29tbW9uKE1FTlVJVEVNICogbWVudSwKCQkJCSAgICAgICBjb25zdCBNRU5VSVRFTUlORk9XICpscG1paSwKCQkJCSAgICAgICBCT09MIHVuaWNvZGUpCnsKICAgIGlmICghbWVudSkgcmV0dXJuIEZBTFNFOwoKICAgIGRlYnVnX3ByaW50X21lbnVpdGVtKCJTZXRNZW51SXRlbUluZm9fY29tbW9uIGZyb206ICIsIG1lbnUsICIiKTsKCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9UWVBFICkgewogICAgICAgIGlmKCBscG1paS0+Zk1hc2sgJiAoIE1JSU1fU1RSSU5HIHwgTUlJTV9GVFlQRSB8IE1JSU1fQklUTUFQKSkgewogICAgICAgICAgICBXQVJOKCJpbnZhbGlkIGNvbWJpbmF0aW9uIG9mIGZNYXNrIGJpdHMgdXNlZFxuIik7CiAgICAgICAgICAgIC8qIHRoaXMgZG9lcyBub3QgaGFwcGVuIG9uIFdpbjl4L01FICovCiAgICAgICAgICAgIFNldExhc3RFcnJvciggRVJST1JfSU5WQUxJRF9QQVJBTUVURVIpOwogICAgICAgICAgICByZXR1cm4gRkFMU0U7CiAgICAgICAgfQoKICAgICAgICAvKiBSZW1vdmUgdGhlIG9sZCB0eXBlIGJpdHMgYW5kIHJlcGxhY2UgdGhlbSB3aXRoIHRoZSBuZXcgb25lcyAqLwogICAgICAgIG1lbnUtPmZUeXBlICY9IH5NRU5VSVRFTUlORk9fVFlQRV9NQVNLOwogICAgICAgIG1lbnUtPmZUeXBlIHw9IGxwbWlpLT5mVHlwZSAmIE1FTlVJVEVNSU5GT19UWVBFX01BU0s7CgogICAgICAgIGlmIChJU19TVFJJTkdfSVRFTShtZW51LT5mVHlwZSkpIHsKCSAgICBIZWFwRnJlZShHZXRQcm9jZXNzSGVhcCgpLCAwLCBtZW51LT50ZXh0KTsKICAgICAgICAgICAgc2V0X21lbnVfaXRlbV90ZXh0KCBtZW51LCBscG1paS0+ZHdUeXBlRGF0YSwgdW5pY29kZSApOwogICAgICAgIH0gZWxzZSBpZiggKG1lbnUtPmZUeXBlKSAmIE1GVF9CSVRNQVApCiAgICAgICAgICAgICAgICBtZW51LT5oYm1wSXRlbSA9IEhCSVRNQVBfMzIoTE9XT1JEKGxwbWlpLT5kd1R5cGVEYXRhKSk7CiAgICB9CgogICAgaWYgKGxwbWlpLT5mTWFzayAmIE1JSU1fRlRZUEUgKSB7CiAgICAgICAgaWYoKCBscG1paS0+ZlR5cGUgJiBNRlRfQklUTUFQKSkgewogICAgICAgICAgICBTZXRMYXN0RXJyb3IoIEVSUk9SX0lOVkFMSURfUEFSQU1FVEVSKTsKICAgICAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgICAgIH0KICAgICAgICBtZW51LT5mVHlwZSAmPSB+TUVOVUlURU1JTkZPX1RZUEVfTUFTSzsKICAgICAgICBtZW51LT5mVHlwZSB8PSBscG1paS0+ZlR5cGUgJiBNRU5VSVRFTUlORk9fVFlQRV9NQVNLOwogICAgfQogICAgaWYgKGxwbWlpLT5mTWFzayAmIE1JSU1fU1RSSU5HICkgewogICAgICAgIC8qIGZyZWUgdGhlIHN0cmluZyB3aGVuIHVzZWQgKi8KICAgICAgICBIZWFwRnJlZShHZXRQcm9jZXNzSGVhcCgpLCAwLCBtZW51LT50ZXh0KTsKICAgICAgICBzZXRfbWVudV9pdGVtX3RleHQoIG1lbnUsIGxwbWlpLT5kd1R5cGVEYXRhLCB1bmljb2RlICk7CiAgICB9CgogICAgaWYgKGxwbWlpLT5mTWFzayAmIE1JSU1fU1RBVEUpCiAgICB7CiAgICAgICAgIC8qIE90aGVyIG1lbnUgaXRlbXMgaGF2aW5nIE1GU19ERUZBVUxUIGFyZSBub3QgY29udmVydGVkCiAgICAgICAgICAgdG8gbm9ybWFsIGl0ZW1zICovCiAgICAgICAgIG1lbnUtPmZTdGF0ZSA9IGxwbWlpLT5mU3RhdGUgJiBNRU5VSVRFTUlORk9fU1RBVEVfTUFTSzsKICAgIH0KCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9JRCkKCW1lbnUtPndJRCA9IGxwbWlpLT53SUQ7CgogICAgaWYgKGxwbWlpLT5mTWFzayAmIE1JSU1fU1VCTUVOVSkgewoJbWVudS0+aFN1Yk1lbnUgPSBscG1paS0+aFN1Yk1lbnU7CglpZiAobWVudS0+aFN1Yk1lbnUpIHsKCSAgICBQT1BVUE1FTlUgKnN1Yk1lbnUgPSBNRU5VX0dldE1lbnUobWVudS0+aFN1Yk1lbnUpOwoJICAgIGlmIChzdWJNZW51KSB7CgkJc3ViTWVudS0+d0ZsYWdzIHw9IE1GX1BPUFVQOwoJCW1lbnUtPmZUeXBlIHw9IE1GX1BPUFVQOwoJICAgIH0KCSAgICBlbHNlIHsKICAgICAgICAgICAgICAgIFNldExhc3RFcnJvciggRVJST1JfSU5WQUxJRF9QQVJBTUVURVIpOwogICAgICAgICAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgICAgICAgICB9Cgl9CgllbHNlCgkgICAgbWVudS0+ZlR5cGUgJj0gfk1GX1BPUFVQOwogICAgfQoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX0NIRUNLTUFSS1MpCiAgICB7CgltZW51LT5oQ2hlY2tCaXQgPSBscG1paS0+aGJtcENoZWNrZWQ7CgltZW51LT5oVW5DaGVja0JpdCA9IGxwbWlpLT5oYm1wVW5jaGVja2VkOwogICAgfQogICAgaWYgKGxwbWlpLT5mTWFzayAmIE1JSU1fREFUQSkKCW1lbnUtPmR3SXRlbURhdGEgPSBscG1paS0+ZHdJdGVtRGF0YTsKCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9CSVRNQVApCgltZW51LT5oYm1wSXRlbSA9IGxwbWlpLT5oYm1wSXRlbTsKCiAgICBpZiggIW1lbnUtPnRleHQgJiYgIShtZW51LT5mVHlwZSAmIE1GVF9PV05FUkRSQVcpICYmICFtZW51LT5oYm1wSXRlbSkKICAgICAgICBtZW51LT5mVHlwZSB8PSBNRlRfU0VQQVJBVE9SOwoKICAgIGRlYnVnX3ByaW50X21lbnVpdGVtKCJTZXRNZW51SXRlbUluZm9fY29tbW9uIHRvIDogIiwgbWVudSwgIiIpOwogICAgcmV0dXJuIFRSVUU7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCQlTZXRNZW51SXRlbUluZm9BICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIFNldE1lbnVJdGVtSW5mb0EoSE1FTlUgaG1lbnUsIFVJTlQgaXRlbSwgQk9PTCBieXBvcywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgTUVOVUlURU1JTkZPQSAqbHBtaWkpCnsKICAgIE1FTlVJVEVNSU5GT0EgbWlpOwogICAgaWYoIGxwbWlpLT5jYlNpemUgIT0gc2l6ZW9mKCBtaWkpICYmCiAgICAgICAgICAgIGxwbWlpLT5jYlNpemUgIT0gc2l6ZW9mKCBtaWkpIC0gc2l6ZW9mICggbWlpLmhibXBJdGVtKSkgewogICAgICAgIFNldExhc3RFcnJvciggRVJST1JfSU5WQUxJRF9QQVJBTUVURVIpOwogICAgICAgIHJldHVybiBGQUxTRTsKICAgIH0KICAgIG1lbWNweSggJm1paSwgbHBtaWksIGxwbWlpLT5jYlNpemUpOwogICAgaWYoIGxwbWlpLT5jYlNpemUgIT0gc2l6ZW9mKCBtaWkpKSB7CiAgICAgICAgbWlpLmNiU2l6ZSA9IHNpemVvZiggbWlpKTsKICAgICAgICBtaWkuaGJtcEl0ZW0gPSBOVUxMOwogICAgfQogICAgcmV0dXJuIFNldE1lbnVJdGVtSW5mb19jb21tb24oTUVOVV9GaW5kSXRlbSgmaG1lbnUsICZpdGVtLCBieXBvcz8gTUZfQllQT1NJVElPTiA6IDApLAoJCQkJICAgIChjb25zdCBNRU5VSVRFTUlORk9XICopJm1paSwgRkFMU0UpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJU2V0TWVudUl0ZW1JbmZvVyAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBTZXRNZW51SXRlbUluZm9XKEhNRU5VIGhtZW51LCBVSU5UIGl0ZW0sIEJPT0wgYnlwb3MsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IE1FTlVJVEVNSU5GT1cgKmxwbWlpKQp7CiAgICBNRU5VSVRFTUlORk9XIG1paTsKICAgIGlmKCBscG1paS0+Y2JTaXplICE9IHNpemVvZiggbWlpKSAmJgogICAgICAgICAgICBscG1paS0+Y2JTaXplICE9IHNpemVvZiggbWlpKSAtIHNpemVvZiAoIG1paS5oYm1wSXRlbSkpIHsKICAgICAgICBTZXRMYXN0RXJyb3IoIEVSUk9SX0lOVkFMSURfUEFSQU1FVEVSKTsKICAgICAgICByZXR1cm4gRkFMU0U7CiAgICB9CiAgICBtZW1jcHkoICZtaWksIGxwbWlpLCBscG1paS0+Y2JTaXplKTsKICAgIGlmKCBscG1paS0+Y2JTaXplICE9IHNpemVvZiggbWlpKSkgewogICAgICAgIG1paS5jYlNpemUgPSBzaXplb2YoIG1paSk7CiAgICAgICAgbWlpLmhibXBJdGVtID0gTlVMTDsKICAgIH0KICAgIHJldHVybiBTZXRNZW51SXRlbUluZm9fY29tbW9uKE1FTlVfRmluZEl0ZW0oJmhtZW51LAogICAgICAgICAgICAgICAgJml0ZW0sIGJ5cG9zPyBNRl9CWVBPU0lUSU9OIDogMCksICZtaWksIFRSVUUpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJU2V0TWVudURlZmF1bHRJdGVtICAgIChVU0VSMzIuQCkKICoKICovCkJPT0wgV0lOQVBJIFNldE1lbnVEZWZhdWx0SXRlbShITUVOVSBobWVudSwgVUlOVCB1SXRlbSwgVUlOVCBieXBvcykKewoJVUlOVCBpOwoJUE9QVVBNRU5VICptZW51OwoJTUVOVUlURU0gKml0ZW07CgoJVFJBQ0UoIiglcCwlZCwlZClcbiIsIGhtZW51LCB1SXRlbSwgYnlwb3MpOwoKCWlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoaG1lbnUpKSkgcmV0dXJuIEZBTFNFOwoKCS8qIHJlc2V0IGFsbCBkZWZhdWx0LWl0ZW0gZmxhZ3MgKi8KCWl0ZW0gPSBtZW51LT5pdGVtczsKCWZvciAoaSA9IDA7IGkgPCBtZW51LT5uSXRlbXM7IGkrKywgaXRlbSsrKQoJewoJICAgIGl0ZW0tPmZTdGF0ZSAmPSB+TUZTX0RFRkFVTFQ7Cgl9CgoJLyogbm8gZGVmYXVsdCBpdGVtICovCglpZiAoIC0xID09IHVJdGVtKQoJewoJICAgIHJldHVybiBUUlVFOwoJfQoKCWl0ZW0gPSBtZW51LT5pdGVtczsKCWlmICggYnlwb3MgKQoJewoJICAgIGlmICggdUl0ZW0gPj0gbWVudS0+bkl0ZW1zICkgcmV0dXJuIEZBTFNFOwoJICAgIGl0ZW1bdUl0ZW1dLmZTdGF0ZSB8PSBNRlNfREVGQVVMVDsKCSAgICByZXR1cm4gVFJVRTsKCX0KCWVsc2UKCXsKCSAgICBmb3IgKGkgPSAwOyBpIDwgbWVudS0+bkl0ZW1zOyBpKyssIGl0ZW0rKykKCSAgICB7CgkJaWYgKGl0ZW0tPndJRCA9PSB1SXRlbSkKCQl7CgkJICAgICBpdGVtLT5mU3RhdGUgfD0gTUZTX0RFRkFVTFQ7CgkJICAgICByZXR1cm4gVFJVRTsKCQl9CgkgICAgfQoKCX0KCXJldHVybiBGQUxTRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCUdldE1lbnVEZWZhdWx0SXRlbSAgICAoVVNFUjMyLkApCiAqLwpVSU5UIFdJTkFQSSBHZXRNZW51RGVmYXVsdEl0ZW0oSE1FTlUgaG1lbnUsIFVJTlQgYnlwb3MsIFVJTlQgZmxhZ3MpCnsKCVBPUFVQTUVOVSAqbWVudTsKCU1FTlVJVEVNICogaXRlbTsKCVVJTlQgaSA9IDA7CgoJVFJBQ0UoIiglcCwlZCwlZClcbiIsIGhtZW51LCBieXBvcywgZmxhZ3MpOwoKCWlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoaG1lbnUpKSkgcmV0dXJuIC0xOwoKCS8qIGZpbmQgZGVmYXVsdCBpdGVtICovCglpdGVtID0gbWVudS0+aXRlbXM7CgoJLyogZW1wdHkgbWVudSAqLwoJaWYgKCEgaXRlbSkgcmV0dXJuIC0xOwoKCXdoaWxlICggISggaXRlbS0+ZlN0YXRlICYgTUZTX0RFRkFVTFQgKSApCgl7CgkgICAgaSsrOyBpdGVtKys7CgkgICAgaWYgIChpID49IG1lbnUtPm5JdGVtcyApIHJldHVybiAtMTsKCX0KCgkvKiBkZWZhdWx0OiBkb24ndCByZXR1cm4gZGlzYWJsZWQgaXRlbXMgKi8KCWlmICggKCEoR01ESV9VU0VESVNBQkxFRCAmIGZsYWdzKSkgJiYgKGl0ZW0tPmZTdGF0ZSAmIE1GU19ESVNBQkxFRCApKSByZXR1cm4gLTE7CgoJLyogc2VhcmNoIHJla3Vyc2l2IHdoZW4gbmVlZGVkICovCglpZiAoIChpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKSAmJiAgKGZsYWdzICYgR01ESV9HT0lOVE9QT1BVUFMpICkKCXsKCSAgICBVSU5UIHJldDsKCSAgICByZXQgPSBHZXRNZW51RGVmYXVsdEl0ZW0oIGl0ZW0tPmhTdWJNZW51LCBieXBvcywgZmxhZ3MgKTsKCSAgICBpZiAoIC0xICE9IHJldCApIHJldHVybiByZXQ7CgoJICAgIC8qIHdoZW4gaXRlbSBub3QgZm91bmQgaW4gc3VibWVudSwgcmV0dXJuIHRoZSBwb3B1cCBpdGVtICovCgl9CglyZXR1cm4gKCBieXBvcyApID8gaSA6IGl0ZW0tPndJRDsKCn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJSW5zZXJ0TWVudUl0ZW1BICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIEluc2VydE1lbnVJdGVtQShITUVOVSBoTWVudSwgVUlOVCB1SXRlbSwgQk9PTCBieXBvcywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBNRU5VSVRFTUlORk9BICpscG1paSkKewogICAgTUVOVUlURU0gKml0ZW0gPSBNRU5VX0luc2VydEl0ZW0oaE1lbnUsIHVJdGVtLCBieXBvcyA/IE1GX0JZUE9TSVRJT04gOiAwICk7CiAgICBNRU5VSVRFTUlORk9BIG1paTsKICAgIGlmKCBscG1paS0+Y2JTaXplICE9IHNpemVvZiggbWlpKSAmJgogICAgICAgICAgICBscG1paS0+Y2JTaXplICE9IHNpemVvZiggbWlpKSAtIHNpemVvZiAoIG1paS5oYm1wSXRlbSkpIHsKICAgICAgICBTZXRMYXN0RXJyb3IoIEVSUk9SX0lOVkFMSURfUEFSQU1FVEVSKTsKICAgICAgICByZXR1cm4gRkFMU0U7CiAgICB9CiAgICBtZW1jcHkoICZtaWksIGxwbWlpLCBscG1paS0+Y2JTaXplKTsKICAgIGlmKCBscG1paS0+Y2JTaXplICE9IHNpemVvZiggbWlpKSkgewogICAgICAgIG1paS5jYlNpemUgPSBzaXplb2YoIG1paSk7CiAgICAgICAgbWlpLmhibXBJdGVtID0gTlVMTDsKICAgIH0KICAgIHJldHVybiBTZXRNZW51SXRlbUluZm9fY29tbW9uKGl0ZW0sIChjb25zdCBNRU5VSVRFTUlORk9XICopJm1paSwgRkFMU0UpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCUluc2VydE1lbnVJdGVtVyAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBJbnNlcnRNZW51SXRlbVcoSE1FTlUgaE1lbnUsIFVJTlQgdUl0ZW0sIEJPT0wgYnlwb3MsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgTUVOVUlURU1JTkZPVyAqbHBtaWkpCnsKICAgIE1FTlVJVEVNICppdGVtID0gTUVOVV9JbnNlcnRJdGVtKGhNZW51LCB1SXRlbSwgYnlwb3MgPyBNRl9CWVBPU0lUSU9OIDogMCApOwogICAgTUVOVUlURU1JTkZPVyBtaWk7CiAgICBpZiggbHBtaWktPmNiU2l6ZSAhPSBzaXplb2YoIG1paSkgJiYKICAgICAgICAgICAgbHBtaWktPmNiU2l6ZSAhPSBzaXplb2YoIG1paSkgLSBzaXplb2YgKCBtaWkuaGJtcEl0ZW0pKSB7CiAgICAgICAgU2V0TGFzdEVycm9yKCBFUlJPUl9JTlZBTElEX1BBUkFNRVRFUik7CiAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgfQogICAgbWVtY3B5KCAmbWlpLCBscG1paSwgbHBtaWktPmNiU2l6ZSk7CiAgICBpZiggbHBtaWktPmNiU2l6ZSAhPSBzaXplb2YoIG1paSkpIHsKICAgICAgICBtaWkuY2JTaXplID0gc2l6ZW9mKCBtaWkpOwogICAgICAgIG1paS5oYm1wSXRlbSA9IE5VTEw7CiAgICB9CiAgICByZXR1cm4gU2V0TWVudUl0ZW1JbmZvX2NvbW1vbihpdGVtLCAmbWlpLCBUUlVFKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCUNoZWNrTWVudVJhZGlvSXRlbSAgICAoVVNFUjMyLkApCiAqLwoKQk9PTCBXSU5BUEkgQ2hlY2tNZW51UmFkaW9JdGVtKEhNRU5VIGhNZW51LAoJCQkJICAgVUlOVCBmaXJzdCwgVUlOVCBsYXN0LCBVSU5UIGNoZWNrLAoJCQkJICAgVUlOVCBieXBvcykKewogICAgIE1FTlVJVEVNICptaWZpcnN0LCAqbWlsYXN0LCAqbWljaGVjazsKICAgICBITUVOVSBtZmlyc3QgPSBoTWVudSwgbWxhc3QgPSBoTWVudSwgbWNoZWNrID0gaE1lbnU7CgogICAgIFRSQUNFKCIlcDogJWQtJWQsIGNoZWNrICVkLCBieXBvcz0lZFxuIiwgaE1lbnUsIGZpcnN0LCBsYXN0LCBjaGVjaywgYnlwb3MpOwoKICAgICBtaWZpcnN0ID0gTUVOVV9GaW5kSXRlbSAoJm1maXJzdCwgJmZpcnN0LCBieXBvcyk7CiAgICAgbWlsYXN0ID0gTUVOVV9GaW5kSXRlbSAoJm1sYXN0LCAmbGFzdCwgYnlwb3MpOwogICAgIG1pY2hlY2sgPSBNRU5VX0ZpbmRJdGVtICgmbWNoZWNrLCAmY2hlY2ssIGJ5cG9zKTsKCiAgICAgaWYgKG1pZmlyc3QgPT0gTlVMTCB8fCBtaWxhc3QgPT0gTlVMTCB8fCBtaWNoZWNrID09IE5VTEwgfHwKCSBtaWZpcnN0ID4gbWlsYXN0IHx8IG1maXJzdCAhPSBtbGFzdCB8fCBtZmlyc3QgIT0gbWNoZWNrIHx8CgkgbWljaGVjayA+IG1pbGFzdCB8fCBtaWNoZWNrIDwgbWlmaXJzdCkKCSAgcmV0dXJuIEZBTFNFOwoKICAgICB3aGlsZSAobWlmaXJzdCA8PSBtaWxhc3QpCiAgICAgewoJICBpZiAobWlmaXJzdCA9PSBtaWNoZWNrKQoJICB7CgkgICAgICAgbWlmaXJzdC0+ZlR5cGUgfD0gTUZUX1JBRElPQ0hFQ0s7CgkgICAgICAgbWlmaXJzdC0+ZlN0YXRlIHw9IE1GU19DSEVDS0VEOwoJICB9IGVsc2UgewoJICAgICAgIG1pZmlyc3QtPmZUeXBlICY9IH5NRlRfUkFESU9DSEVDSzsKCSAgICAgICBtaWZpcnN0LT5mU3RhdGUgJj0gfk1GU19DSEVDS0VEOwoJICB9CgkgIG1pZmlyc3QrKzsKICAgICB9CgogICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCUdldE1lbnVJdGVtUmVjdCAgICAoVVNFUjMyLkApCiAqCiAqICAgICAgQVRURU5USU9OOiBIZXJlLCB0aGUgcmV0dXJuZWQgdmFsdWVzIGluIHJlY3QgYXJlIHRoZSBzY3JlZW4KICogICAgICAgICAgICAgICAgIGNvb3JkaW5hdGVzIG9mIHRoZSBpdGVtIGp1c3QgbGlrZSBpZiB0aGUgbWVudSB3YXMKICogICAgICAgICAgICAgICAgIGFsd2F5cyBvbiB0aGUgdXBwZXIgbGVmdCBzaWRlIG9mIHRoZSBhcHBsaWNhdGlvbi4KICoKICovCkJPT0wgV0lOQVBJIEdldE1lbnVJdGVtUmVjdCAoSFdORCBod25kLCBITUVOVSBoTWVudSwgVUlOVCB1SXRlbSwKCQkJCSBMUFJFQ1QgcmVjdCkKewogICAgIFBPUFVQTUVOVSAqaXRlbU1lbnU7CiAgICAgTUVOVUlURU0gKml0ZW07CiAgICAgSFdORCByZWZlcmVuY2VId25kOwoKICAgICBUUkFDRSgiKCVwLCVwLCVkLCVwKVxuIiwgaHduZCwgaE1lbnUsIHVJdGVtLCByZWN0KTsKCiAgICAgaXRlbSA9IE1FTlVfRmluZEl0ZW0gKCZoTWVudSwgJnVJdGVtLCBNRl9CWVBPU0lUSU9OKTsKICAgICByZWZlcmVuY2VId25kID0gaHduZDsKCiAgICAgaWYoIWh3bmQpCiAgICAgewoJIGl0ZW1NZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KTsKCSBpZiAoaXRlbU1lbnUgPT0gTlVMTCkKCSAgICAgcmV0dXJuIEZBTFNFOwoKCSBpZihpdGVtTWVudS0+aFduZCA9PSAwKQoJICAgICByZXR1cm4gRkFMU0U7CgkgcmVmZXJlbmNlSHduZCA9IGl0ZW1NZW51LT5oV25kOwogICAgIH0KCiAgICAgaWYgKChyZWN0ID09IE5VTEwpIHx8IChpdGVtID09IE5VTEwpKQoJIHJldHVybiBGQUxTRTsKCiAgICAgKnJlY3QgPSBpdGVtLT5yZWN0OwoKICAgICBNYXBXaW5kb3dQb2ludHMocmVmZXJlbmNlSHduZCwgMCwgKExQUE9JTlQpcmVjdCwgMik7CgogICAgIHJldHVybiBUUlVFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCVNldE1lbnVJbmZvICAgIChVU0VSMzIuQCkKICoKICogRklYTUUKICoJTUlNX0FQUExZVE9TVUJNRU5VUwogKglhY3R1YWxseSB1c2UgdGhlIGl0ZW1zIHRvIGRyYXcgdGhlIG1lbnUKICovCkJPT0wgV0lOQVBJIFNldE1lbnVJbmZvIChITUVOVSBoTWVudSwgTFBDTUVOVUlORk8gbHBtaSkKewogICAgUE9QVVBNRU5VICptZW51OwoKICAgIFRSQUNFKCIoJXAgJXApXG4iLCBoTWVudSwgbHBtaSk7CgogICAgaWYgKGxwbWkgJiYgKGxwbWktPmNiU2l6ZT09c2l6ZW9mKE1FTlVJTkZPKSkgJiYgKG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpKSkKICAgIHsKCglpZiAobHBtaS0+Zk1hc2sgJiBNSU1fQkFDS0dST1VORCkKCSAgICBtZW51LT5oYnJCYWNrID0gbHBtaS0+aGJyQmFjazsKCglpZiAobHBtaS0+Zk1hc2sgJiBNSU1fSEVMUElEKQoJICAgIG1lbnUtPmR3Q29udGV4dEhlbHBJRCA9IGxwbWktPmR3Q29udGV4dEhlbHBJRDsKCglpZiAobHBtaS0+Zk1hc2sgJiBNSU1fTUFYSEVJR0hUKQoJICAgIG1lbnUtPmN5TWF4ID0gbHBtaS0+Y3lNYXg7CgoJaWYgKGxwbWktPmZNYXNrICYgTUlNX01FTlVEQVRBKQoJICAgIG1lbnUtPmR3TWVudURhdGEgPSBscG1pLT5kd01lbnVEYXRhOwoKCWlmIChscG1pLT5mTWFzayAmIE1JTV9TVFlMRSkKCXsKCSAgICBtZW51LT5kd1N0eWxlID0gbHBtaS0+ZHdTdHlsZTsKCSAgICBpZiAobWVudS0+ZHdTdHlsZSAmIE1OU19BVVRPRElTTUlTUykgRklYTUUoIk1OU19BVVRPRElTTUlTUyB1bmltcGxlbWVudGVkXG4iKTsKCSAgICBpZiAobWVudS0+ZHdTdHlsZSAmIE1OU19EUkFHRFJPUCkgRklYTUUoIk1OU19EUkFHRFJPUCB1bmltcGxlbWVudGVkXG4iKTsKCSAgICBpZiAobWVudS0+ZHdTdHlsZSAmIE1OU19NT0RFTEVTUykgRklYTUUoIk1OU19NT0RFTEVTUyB1bmltcGxlbWVudGVkXG4iKTsKCSAgICBpZiAobWVudS0+ZHdTdHlsZSAmIE1OU19OT1RJRllCWVBPUykgRklYTUUoIk1OU19OT1RJRllCWVBPUyBwYXJ0aWFsbHkgaW1wbGVtZW50ZWRcbiIpOwoJfQoKCXJldHVybiBUUlVFOwogICAgfQogICAgcmV0dXJuIEZBTFNFOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJR2V0TWVudUluZm8gICAgKFVTRVIzMi5AKQogKgogKiAgTk9URVMKICoJd2luOTgvTlQ1LjAKICoKICovCkJPT0wgV0lOQVBJIEdldE1lbnVJbmZvIChITUVOVSBoTWVudSwgTFBNRU5VSU5GTyBscG1pKQp7ICAgUE9QVVBNRU5VICptZW51OwoKICAgIFRSQUNFKCIoJXAgJXApXG4iLCBoTWVudSwgbHBtaSk7CgogICAgaWYgKGxwbWkgJiYgKG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpKSkKICAgIHsKCglpZiAobHBtaS0+Zk1hc2sgJiBNSU1fQkFDS0dST1VORCkKCSAgICBscG1pLT5oYnJCYWNrID0gbWVudS0+aGJyQmFjazsKCglpZiAobHBtaS0+Zk1hc2sgJiBNSU1fSEVMUElEKQoJICAgIGxwbWktPmR3Q29udGV4dEhlbHBJRCA9IG1lbnUtPmR3Q29udGV4dEhlbHBJRDsKCglpZiAobHBtaS0+Zk1hc2sgJiBNSU1fTUFYSEVJR0hUKQoJICAgIGxwbWktPmN5TWF4ID0gbWVudS0+Y3lNYXg7CgoJaWYgKGxwbWktPmZNYXNrICYgTUlNX01FTlVEQVRBKQoJICAgIGxwbWktPmR3TWVudURhdGEgPSBtZW51LT5kd01lbnVEYXRhOwoKCWlmIChscG1pLT5mTWFzayAmIE1JTV9TVFlMRSkKCSAgICBscG1pLT5kd1N0eWxlID0gbWVudS0+ZHdTdHlsZTsKCglyZXR1cm4gVFJVRTsKICAgIH0KICAgIHJldHVybiBGQUxTRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgU2V0TWVudUNvbnRleHRIZWxwSWQgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgU2V0TWVudUNvbnRleHRIZWxwSWQoIEhNRU5VIGhNZW51LCBEV09SRCBkd0NvbnRleHRIZWxwSUQpCnsKICAgIExQUE9QVVBNRU5VIG1lbnU7CgogICAgVFJBQ0UoIiglcCAweCUwOHgpXG4iLCBoTWVudSwgZHdDb250ZXh0SGVscElEKTsKCiAgICBpZiAoKG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpKSkKICAgIHsKCW1lbnUtPmR3Q29udGV4dEhlbHBJRCA9IGR3Q29udGV4dEhlbHBJRDsKCXJldHVybiBUUlVFOwogICAgfQogICAgcmV0dXJuIEZBTFNFOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBHZXRNZW51Q29udGV4dEhlbHBJZCAgICAoVVNFUjMyLkApCiAqLwpEV09SRCBXSU5BUEkgR2V0TWVudUNvbnRleHRIZWxwSWQoIEhNRU5VIGhNZW51ICkKewogICAgTFBQT1BVUE1FTlUgbWVudTsKCiAgICBUUkFDRSgiKCVwKVxuIiwgaE1lbnUpOwoKICAgIGlmICgobWVudSA9IE1FTlVfR2V0TWVudShoTWVudSkpKQogICAgewoJcmV0dXJuIG1lbnUtPmR3Q29udGV4dEhlbHBJRDsKICAgIH0KICAgIHJldHVybiAwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIE1lbnVJdGVtRnJvbVBvaW50ICAgIChVU0VSMzIuQCkKICovCklOVCBXSU5BUEkgTWVudUl0ZW1Gcm9tUG9pbnQoSFdORCBoV25kLCBITUVOVSBoTWVudSwgUE9JTlQgcHRTY3JlZW4pCnsKICAgIFBPUFVQTUVOVSAqbWVudSA9IE1FTlVfR2V0TWVudShoTWVudSk7CiAgICBVSU5UIHBvczsKCiAgICAvKkZJWE1FOiBEbyB3ZSBoYXZlIHRvIGhhbmRsZSBoV25kIGhlcmU/ICovCiAgICBpZiAoIW1lbnUpIHJldHVybiAtMTsKICAgIGlmICghTUVOVV9GaW5kSXRlbUJ5Q29vcmRzKG1lbnUsIHB0U2NyZWVuLCAmcG9zKSkgcmV0dXJuIC0xOwogICAgcmV0dXJuIHBvczsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICB0cmFuc2xhdGVfYWNjZWxlcmF0b3IKICovCnN0YXRpYyBCT09MIHRyYW5zbGF0ZV9hY2NlbGVyYXRvciggSFdORCBoV25kLCBVSU5UIG1lc3NhZ2UsIFdQQVJBTSB3UGFyYW0sIExQQVJBTSBsUGFyYW0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQllURSBmVmlydCwgV09SRCBrZXksIFdPUkQgY21kICkKewogICAgSU5UIG1hc2sgPSAwOwogICAgVUlOVCBtZXNnID0gMDsKCiAgICBpZiAod1BhcmFtICE9IGtleSkgcmV0dXJuIEZBTFNFOwoKICAgIGlmIChHZXRLZXlTdGF0ZShWS19DT05UUk9MKSAmIDB4ODAwMCkgbWFzayB8PSBGQ09OVFJPTDsKICAgIGlmIChHZXRLZXlTdGF0ZShWS19NRU5VKSAmIDB4ODAwMCkgbWFzayB8PSBGQUxUOwogICAgaWYgKEdldEtleVN0YXRlKFZLX1NISUZUKSAmIDB4ODAwMCkgbWFzayB8PSBGU0hJRlQ7CgogICAgaWYgKG1lc3NhZ2UgPT0gV01fQ0hBUiB8fCBtZXNzYWdlID09IFdNX1NZU0NIQVIpCiAgICB7CiAgICAgICAgaWYgKCAhKGZWaXJ0ICYgRlZJUlRLRVkpICYmIChtYXNrICYgRkFMVCkgPT0gKGZWaXJ0ICYgRkFMVCkgKQogICAgICAgIHsKICAgICAgICAgICAgVFJBQ0VfKGFjY2VsKSgiZm91bmQgYWNjZWwgZm9yIFdNX0NIQVI6ICgnJWMnKVxuIiwgd1BhcmFtICYgMHhmZik7CiAgICAgICAgICAgIGdvdG8gZm91bmQ7CiAgICAgICAgfQogICAgfQogICAgZWxzZQogICAgewogICAgICAgIGlmKGZWaXJ0ICYgRlZJUlRLRVkpCiAgICAgICAgewogICAgICAgICAgICBUUkFDRV8oYWNjZWwpKCJmb3VuZCBhY2NlbCBmb3IgdmlydF9rZXkgJTA0eCAoc2NhbiAlMDR4KVxuIiwKICAgICAgICAgICAgICAgICAgICAgICAgICB3UGFyYW0sIDB4ZmYgJiBISVdPUkQobFBhcmFtKSk7CgogICAgICAgICAgICBpZihtYXNrID09IChmVmlydCAmIChGU0hJRlQgfCBGQ09OVFJPTCB8IEZBTFQpKSkgZ290byBmb3VuZDsKICAgICAgICAgICAgVFJBQ0VfKGFjY2VsKSgiLCBidXQgaW5jb3JyZWN0IFNISUZUL0NUUkwvQUxULXN0YXRlXG4iKTsKICAgICAgICB9CiAgICAgICAgZWxzZQogICAgICAgIHsKICAgICAgICAgICAgaWYgKCEobFBhcmFtICYgMHgwMTAwMDAwMCkpICAvKiBubyBzcGVjaWFsX2tleSAqLwogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBpZiAoKGZWaXJ0ICYgRkFMVCkgJiYgKGxQYXJhbSAmIDB4MjAwMDAwMDApKQogICAgICAgICAgICAgICAgeyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIF5eIEFMVCBwcmVzc2VkICovCiAgICAgICAgICAgICAgICAgICAgVFJBQ0VfKGFjY2VsKSgiZm91bmQgYWNjZWwgZm9yIEFsdC0lY1xuIiwgd1BhcmFtICYgMHhmZik7CiAgICAgICAgICAgICAgICAgICAgZ290byBmb3VuZDsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfQogICAgICAgIH0KICAgIH0KICAgIHJldHVybiBGQUxTRTsKCiBmb3VuZDoKICAgIGlmIChtZXNzYWdlID09IFdNX0tFWVVQIHx8IG1lc3NhZ2UgPT0gV01fU1lTS0VZVVApCiAgICAgICAgbWVzZyA9IDE7CiAgICBlbHNlCiAgICB7CiAgICAgICAgSE1FTlUgaE1lbnUsIGhTdWJNZW51LCBoU3lzTWVudTsKICAgICAgICBVSU5UIHVTeXNTdGF0ID0gKFVJTlQpLTEsIHVTdGF0ID0gKFVJTlQpLTEsIG5Qb3M7CgogICAgICAgIGhNZW51ID0gKEdldFdpbmRvd0xvbmdXKCBoV25kLCBHV0xfU1RZTEUgKSAmIFdTX0NISUxEKSA/IDAgOiBHZXRNZW51KGhXbmQpOwogICAgICAgIGhTeXNNZW51ID0gZ2V0X3dpbl9zeXNfbWVudSggaFduZCApOwoKICAgICAgICAvKiBmaW5kIG1lbnUgaXRlbSBhbmQgYXNrIGFwcGxpY2F0aW9uIHRvIGluaXRpYWxpemUgaXQgKi8KICAgICAgICAvKiAxLiBpbiB0aGUgc3lzdGVtIG1lbnUgKi8KICAgICAgICBoU3ViTWVudSA9IGhTeXNNZW51OwogICAgICAgIG5Qb3MgPSBjbWQ7CiAgICAgICAgaWYoTUVOVV9GaW5kSXRlbSgmaFN1Yk1lbnUsICZuUG9zLCBNRl9CWUNPTU1BTkQpKQogICAgICAgIHsKICAgICAgICAgICAgaWYgKEdldENhcHR1cmUoKSkKICAgICAgICAgICAgICAgIG1lc2cgPSAyOwogICAgICAgICAgICBpZiAoIUlzV2luZG93RW5hYmxlZChoV25kKSkKICAgICAgICAgICAgICAgIG1lc2cgPSAzOwogICAgICAgICAgICBlbHNlCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIFNlbmRNZXNzYWdlVyhoV25kLCBXTV9JTklUTUVOVSwgKFdQQVJBTSloU3lzTWVudSwgMEwpOwogICAgICAgICAgICAgICAgaWYoaFN1Yk1lbnUgIT0gaFN5c01lbnUpCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgblBvcyA9IE1FTlVfRmluZFN1Yk1lbnUoJmhTeXNNZW51LCBoU3ViTWVudSk7CiAgICAgICAgICAgICAgICAgICAgVFJBQ0VfKGFjY2VsKSgiaFN5c01lbnUgPSAlcCwgaFN1Yk1lbnUgPSAlcCwgblBvcyA9ICVkXG4iLCBoU3lzTWVudSwgaFN1Yk1lbnUsIG5Qb3MpOwogICAgICAgICAgICAgICAgICAgIFNlbmRNZXNzYWdlVyhoV25kLCBXTV9JTklUTUVOVVBPUFVQLCAoV1BBUkFNKWhTdWJNZW51LCBNQUtFTFBBUkFNKG5Qb3MsIFRSVUUpKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIHVTeXNTdGF0ID0gR2V0TWVudVN0YXRlKEdldFN1Yk1lbnUoaFN5c01lbnUsIDApLCBjbWQsIE1GX0JZQ09NTUFORCk7CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICAgICAgZWxzZSAvKiAyLiBpbiB0aGUgd2luZG93J3MgbWVudSAqLwogICAgICAgIHsKICAgICAgICAgICAgaFN1Yk1lbnUgPSBoTWVudTsKICAgICAgICAgICAgblBvcyA9IGNtZDsKICAgICAgICAgICAgaWYoTUVOVV9GaW5kSXRlbSgmaFN1Yk1lbnUsICZuUG9zLCBNRl9CWUNPTU1BTkQpKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBpZiAoR2V0Q2FwdHVyZSgpKQogICAgICAgICAgICAgICAgICAgIG1lc2cgPSAyOwogICAgICAgICAgICAgICAgaWYgKCFJc1dpbmRvd0VuYWJsZWQoaFduZCkpCiAgICAgICAgICAgICAgICAgICAgbWVzZyA9IDM7CiAgICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgU2VuZE1lc3NhZ2VXKGhXbmQsIFdNX0lOSVRNRU5VLCAoV1BBUkFNKWhNZW51LCAwTCk7CiAgICAgICAgICAgICAgICAgICAgaWYoaFN1Yk1lbnUgIT0gaE1lbnUpCiAgICAgICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAgICBuUG9zID0gTUVOVV9GaW5kU3ViTWVudSgmaE1lbnUsIGhTdWJNZW51KTsKICAgICAgICAgICAgICAgICAgICAgICAgVFJBQ0VfKGFjY2VsKSgiaE1lbnUgPSAlcCwgaFN1Yk1lbnUgPSAlcCwgblBvcyA9ICVkXG4iLCBoTWVudSwgaFN1Yk1lbnUsIG5Qb3MpOwogICAgICAgICAgICAgICAgICAgICAgICBTZW5kTWVzc2FnZVcoaFduZCwgV01fSU5JVE1FTlVQT1BVUCwgKFdQQVJBTSloU3ViTWVudSwgTUFLRUxQQVJBTShuUG9zLCBGQUxTRSkpOwogICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICB1U3RhdCA9IEdldE1lbnVTdGF0ZShoTWVudSwgY21kLCBNRl9CWUNPTU1BTkQpOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CiAgICAgICAgfQoKICAgICAgICBpZiAobWVzZyA9PSAwKQogICAgICAgIHsKICAgICAgICAgICAgaWYgKHVTeXNTdGF0ICE9IChVSU5UKS0xKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBpZiAodVN5c1N0YXQgJiAoTUZfRElTQUJMRUR8TUZfR1JBWUVEKSkKICAgICAgICAgICAgICAgICAgICBtZXNnPTQ7CiAgICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICAgICAgbWVzZz1XTV9TWVNDT01NQU5EOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgaWYgKHVTdGF0ICE9IChVSU5UKS0xKQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIGlmIChJc0ljb25pYyhoV25kKSkKICAgICAgICAgICAgICAgICAgICAgICAgbWVzZz01OwogICAgICAgICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgICAgIGlmICh1U3RhdCAmIChNRl9ESVNBQkxFRHxNRl9HUkFZRUQpKQogICAgICAgICAgICAgICAgICAgICAgICAgICAgbWVzZz02OwogICAgICAgICAgICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBtZXNnPVdNX0NPTU1BTkQ7CiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgICAgIG1lc2c9V01fQ09NTUFORDsKICAgICAgICAgICAgfQogICAgICAgIH0KICAgIH0KCiAgICBpZiggbWVzZz09V01fQ09NTUFORCApCiAgICB7CiAgICAgICAgVFJBQ0VfKGFjY2VsKSgiLCBzZW5kaW5nIFdNX0NPTU1BTkQsIHdQYXJhbT0lMHhcbiIsIDB4MTAwMDAgfCBjbWQpOwogICAgICAgIFNlbmRNZXNzYWdlVyhoV25kLCBtZXNnLCAweDEwMDAwIHwgY21kLCAwTCk7CiAgICB9CiAgICBlbHNlIGlmKCBtZXNnPT1XTV9TWVNDT01NQU5EICkKICAgIHsKICAgICAgICBUUkFDRV8oYWNjZWwpKCIsIHNlbmRpbmcgV01fU1lTQ09NTUFORCwgd1BhcmFtPSUweFxuIiwgY21kKTsKICAgICAgICBTZW5kTWVzc2FnZVcoaFduZCwgbWVzZywgY21kLCAweDAwMDEwMDAwTCk7CiAgICB9CiAgICBlbHNlCiAgICB7CiAgICAgICAgLyogIHNvbWUgcmVhc29ucyBmb3IgTk9UIHNlbmRpbmcgdGhlIFdNX3tTWVN9Q09NTUFORCBtZXNzYWdlOgogICAgICAgICAqICAgIzA6IHVua25vd24gKHBsZWFzZSByZXBvcnQhKQogICAgICAgICAqICAgIzE6IGZvciBXTV9LRVlVUCxXTV9TWVNLRVlVUAogICAgICAgICAqICAgIzI6IG1vdXNlIGlzIGNhcHR1cmVkCiAgICAgICAgICogICAjMzogd2luZG93IGlzIGRpc2FibGVkCiAgICAgICAgICogICAjNDogaXQncyBhIGRpc2FibGVkIHN5c3RlbSBtZW51IG9wdGlvbgogICAgICAgICAqICAgIzU6IGl0J3MgYSBtZW51IG9wdGlvbiwgYnV0IHdpbmRvdyBpcyBpY29uaWMKICAgICAgICAgKiAgICM2OiBpdCdzIGEgbWVudSBvcHRpb24sIGJ1dCBkaXNhYmxlZAogICAgICAgICAqLwogICAgICAgIFRSQUNFXyhhY2NlbCkoIiwgYnV0IHdvbid0IHNlbmQgV01fe1NZU31DT01NQU5ELCByZWFzb24gaXMgIyVkXG4iLG1lc2cpOwogICAgICAgIGlmKG1lc2c9PTApCiAgICAgICAgICAgIEVSUl8oYWNjZWwpKCIgdW5rbm93biByZWFzb24gLSBwbGVhc2UgcmVwb3J0IVxuIik7CiAgICB9CiAgICByZXR1cm4gVFJVRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICBUcmFuc2xhdGVBY2NlbGVyYXRvckEgICAgIChVU0VSMzIuQCkKICogICAgICBUcmFuc2xhdGVBY2NlbGVyYXRvciAgICAgIChVU0VSMzIuQCkKICovCklOVCBXSU5BUEkgVHJhbnNsYXRlQWNjZWxlcmF0b3JBKCBIV05EIGhXbmQsIEhBQ0NFTCBoQWNjZWwsIExQTVNHIG1zZyApCnsKICAgIC8qIFlFUywgQWNjZWwxNiEgKi8KICAgIExQQUNDRUwxNiBscEFjY2VsVGJsOwogICAgaW50IGk7CiAgICBXUEFSQU0gd1BhcmFtOwoKICAgIGlmICghaFduZCB8fCAhbXNnKSByZXR1cm4gMDsKCiAgICBpZiAoIWhBY2NlbCB8fCAhKGxwQWNjZWxUYmwgPSAoTFBBQ0NFTDE2KSBMb2NrUmVzb3VyY2UxNihIQUNDRUxfMTYoaEFjY2VsKSkpKQogICAgewogICAgICAgIFdBUk5fKGFjY2VsKSgiaW52YWxpZCBhY2NlbCBoYW5kbGU9JXBcbiIsIGhBY2NlbCk7CiAgICAgICAgcmV0dXJuIDA7CiAgICB9CgogICAgd1BhcmFtID0gbXNnLT53UGFyYW07CgogICAgc3dpdGNoIChtc2ctPm1lc3NhZ2UpCiAgICB7CiAgICBjYXNlIFdNX0tFWURPV046CiAgICBjYXNlIFdNX1NZU0tFWURPV046CiAgICAgICAgYnJlYWs7CgogICAgY2FzZSBXTV9DSEFSOgogICAgY2FzZSBXTV9TWVNDSEFSOgogICAgICAgIHsKICAgICAgICAgICAgY2hhciBjaCA9IExPV09SRCh3UGFyYW0pOwogICAgICAgICAgICBXQ0hBUiB3Y2g7CiAgICAgICAgICAgIE11bHRpQnl0ZVRvV2lkZUNoYXIoQ1BfQUNQLCAwLCAmY2gsIDEsICZ3Y2gsIDEpOwogICAgICAgICAgICB3UGFyYW0gPSBNQUtFV1BBUkFNKHdjaCwgSElXT1JEKHdQYXJhbSkpOwogICAgICAgIH0KICAgICAgICBicmVhazsKCiAgICBkZWZhdWx0OgogICAgICAgIHJldHVybiAwOwogICAgfQoKICAgIFRSQUNFXyhhY2NlbCkoImhBY2NlbCAlcCwgaFduZCAlcCwgbXNnLT5od25kICVwLCBtc2ctPm1lc3NhZ2UgJTA0eCwgd1BhcmFtICUwOHgsIGxQYXJhbSAlMDhseFxuIiwKICAgICAgICAgICAgICAgICAgaEFjY2VsLGhXbmQsbXNnLT5od25kLG1zZy0+bWVzc2FnZSxtc2ctPndQYXJhbSxtc2ctPmxQYXJhbSk7CiAgICBpID0gMDsKICAgIGRvCiAgICB7CiAgICAgICAgaWYgKHRyYW5zbGF0ZV9hY2NlbGVyYXRvciggaFduZCwgbXNnLT5tZXNzYWdlLCB3UGFyYW0sIG1zZy0+bFBhcmFtLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxwQWNjZWxUYmxbaV0uZlZpcnQsIGxwQWNjZWxUYmxbaV0ua2V5LCBscEFjY2VsVGJsW2ldLmNtZCkpCiAgICAgICAgICAgIHJldHVybiAxOwogICAgfSB3aGlsZSAoKGxwQWNjZWxUYmxbaSsrXS5mVmlydCAmIDB4ODApID09IDApOwoKICAgIHJldHVybiAwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgIFRyYW5zbGF0ZUFjY2VsZXJhdG9yVyAgICAgKFVTRVIzMi5AKQogKi8KSU5UIFdJTkFQSSBUcmFuc2xhdGVBY2NlbGVyYXRvclcoIEhXTkQgaFduZCwgSEFDQ0VMIGhBY2NlbCwgTFBNU0cgbXNnICkKewogICAgLyogWUVTLCBBY2NlbDE2ISAqLwogICAgTFBBQ0NFTDE2IGxwQWNjZWxUYmw7CiAgICBpbnQgaTsKCiAgICBpZiAoIWhXbmQgfHwgIW1zZykgcmV0dXJuIDA7CgogICAgaWYgKCFoQWNjZWwgfHwgIShscEFjY2VsVGJsID0gKExQQUNDRUwxNikgTG9ja1Jlc291cmNlMTYoSEFDQ0VMXzE2KGhBY2NlbCkpKSkKICAgIHsKICAgICAgICBXQVJOXyhhY2NlbCkoImludmFsaWQgYWNjZWwgaGFuZGxlPSVwXG4iLCBoQWNjZWwpOwogICAgICAgIHJldHVybiAwOwogICAgfQoKICAgIHN3aXRjaCAobXNnLT5tZXNzYWdlKQogICAgewogICAgY2FzZSBXTV9LRVlET1dOOgogICAgY2FzZSBXTV9TWVNLRVlET1dOOgogICAgY2FzZSBXTV9DSEFSOgogICAgY2FzZSBXTV9TWVNDSEFSOgogICAgICAgIGJyZWFrOwoKICAgIGRlZmF1bHQ6CiAgICAgICAgcmV0dXJuIDA7CiAgICB9CgogICAgVFJBQ0VfKGFjY2VsKSgiaEFjY2VsICVwLCBoV25kICVwLCBtc2ctPmh3bmQgJXAsIG1zZy0+bWVzc2FnZSAlMDR4LCB3UGFyYW0gJTA4eCwgbFBhcmFtICUwOGx4XG4iLAogICAgICAgICAgICAgICAgICBoQWNjZWwsaFduZCxtc2ctPmh3bmQsbXNnLT5tZXNzYWdlLG1zZy0+d1BhcmFtLG1zZy0+bFBhcmFtKTsKICAgIGkgPSAwOwogICAgZG8KICAgIHsKICAgICAgICBpZiAodHJhbnNsYXRlX2FjY2VsZXJhdG9yKCBoV25kLCBtc2ctPm1lc3NhZ2UsIG1zZy0+d1BhcmFtLCBtc2ctPmxQYXJhbSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBscEFjY2VsVGJsW2ldLmZWaXJ0LCBscEFjY2VsVGJsW2ldLmtleSwgbHBBY2NlbFRibFtpXS5jbWQpKQogICAgICAgICAgICByZXR1cm4gMTsKICAgIH0gd2hpbGUgKChscEFjY2VsVGJsW2krK10uZlZpcnQgJiAweDgwKSA9PSAwKTsKCiAgICByZXR1cm4gMDsKfQo=