LyoKICogTWVudSBmdW5jdGlvbnMKICoKICogQ29weXJpZ2h0IDE5OTMgTWFydGluIEF5b3R0ZQogKiBDb3B5cmlnaHQgMTk5NCBBbGV4YW5kcmUgSnVsbGlhcmQKICogQ29weXJpZ2h0IDE5OTcgTW9ydGVuIFdlbGluZGVyCiAqIENvcHlyaWdodCAyMDA1IE1heGltZSBCZWxsZW5n6QogKiBDb3B5cmlnaHQgMjAwNiBQaGlsIEtyeWxvdgogKgogKiBUaGlzIGxpYnJhcnkgaXMgZnJlZSBzb2Z0d2FyZTsgeW91IGNhbiByZWRpc3RyaWJ1dGUgaXQgYW5kL29yCiAqIG1vZGlmeSBpdCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBMZXNzZXIgR2VuZXJhbCBQdWJsaWMKICogTGljZW5zZSBhcyBwdWJsaXNoZWQgYnkgdGhlIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbjsgZWl0aGVyCiAqIHZlcnNpb24gMi4xIG9mIHRoZSBMaWNlbnNlLCBvciAoYXQgeW91ciBvcHRpb24pIGFueSBsYXRlciB2ZXJzaW9uLgogKgogKiBUaGlzIGxpYnJhcnkgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwKICogYnV0IFdJVEhPVVQgQU5ZIFdBUlJBTlRZOyB3aXRob3V0IGV2ZW4gdGhlIGltcGxpZWQgd2FycmFudHkgb2YKICogTUVSQ0hBTlRBQklMSVRZIG9yIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFLiAgU2VlIHRoZSBHTlUKICogTGVzc2VyIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgZm9yIG1vcmUgZGV0YWlscy4KICoKICogWW91IHNob3VsZCBoYXZlIHJlY2VpdmVkIGEgY29weSBvZiB0aGUgR05VIExlc3NlciBHZW5lcmFsIFB1YmxpYwogKiBMaWNlbnNlIGFsb25nIHdpdGggdGhpcyBsaWJyYXJ5OyBpZiBub3QsIHdyaXRlIHRvIHRoZSBGcmVlIFNvZnR3YXJlCiAqIEZvdW5kYXRpb24sIEluYy4sIDUxIEZyYW5rbGluIFN0LCBGaWZ0aCBGbG9vciwgQm9zdG9uLCBNQSAwMjExMC0xMzAxLCBVU0EKICovCgovKgogKiBOb3RlOiB0aGUgc3R5bGUgTUZfTU9VU0VTRUxFQ1QgaXMgdXNlZCB0byBtYXJrIHBvcHVwIGl0ZW1zIHRoYXQKICogaGF2ZSBiZWVuIHNlbGVjdGVkLCBpLmUuIHRoZWlyIHBvcHVwIG1lbnUgaXMgY3VycmVudGx5IGRpc3BsYXllZC4KICogVGhpcyBpcyBwcm9iYWJseSBub3QgdGhlIG1lYW5pbmcgdGhpcyBzdHlsZSBoYXMgaW4gTVMtV2luZG93cy4KICoKICogTm90ZSAyOiB3aGVyZSB0aGVyZSBpcyBhIGRpZmZlcmVuY2UsIHRoZXNlIG1lbnUgQVBJJ3MgYXJlIGFjY29yZGluZwogKiB0aGUgYmVoYXZpb3Igb2YgV2luZG93cyAyayBhbmQgV2luZG93cyBYUC4gS25vd24gZGlmZmVyZW5jZXMgd2l0aAogKiBXaW5kb3dzIDl4L01FIGFyZSBkb2N1bWVudGVkIGluIHRoZSBjb21tZW50cywgaW4gY2FzZSBhbiBhcHBsaWNhdGlvbgogKiBpcyBmb3VuZCB0byBkZXBlbmQgb24gdGhlIG9sZCBiZWhhdmlvci4KICogCiAqIFRPRE86CiAqICAgIGltcGxlbWVudHMgc3R5bGVzIDoKICogICAgICAgIC0gTU5TX0FVVE9ESVNNSVNTCiAqICAgICAgICAtIE1OU19EUkFHRFJPUAogKiAgICAgICAgLSBNTlNfTU9ERUxFU1MKICovCgojaW5jbHVkZSAiY29uZmlnLmgiCiNpbmNsdWRlICJ3aW5lL3BvcnQuaCIKCiNpbmNsdWRlIDxzdGRhcmcuaD4KI2luY2x1ZGUgPHN0cmluZy5oPgoKI2RlZmluZSBPRU1SRVNPVVJDRQoKI2luY2x1ZGUgIndpbmRlZi5oIgojaW5jbHVkZSAid2luYmFzZS5oIgojaW5jbHVkZSAid2luZ2RpLmgiCiNpbmNsdWRlICJ3aW5ubHMuaCIKI2luY2x1ZGUgIndpbmUvd2luYmFzZTE2LmgiCiNpbmNsdWRlICJ3aW5lL3dpbnVzZXIxNi5oIgojaW5jbHVkZSAid293bnQzMi5oIgojaW5jbHVkZSAid2luZS9zZXJ2ZXIuaCIKI2luY2x1ZGUgIndpbmUvdW5pY29kZS5oIgojaW5jbHVkZSAid2luLmgiCiNpbmNsdWRlICJjb250cm9scy5oIgojaW5jbHVkZSAidXNlcl9wcml2YXRlLmgiCiNpbmNsdWRlICJ3aW5lL2RlYnVnLmgiCgpXSU5FX0RFRkFVTFRfREVCVUdfQ0hBTk5FTChtZW51KTsKV0lORV9ERUNMQVJFX0RFQlVHX0NIQU5ORUwoYWNjZWwpOwoKLyogaW50ZXJuYWwgcG9wdXAgbWVudSB3aW5kb3cgbWVzc2FnZXMgKi8KCiNkZWZpbmUgTU1fU0VUTUVOVUhBTkRMRQkoV01fVVNFUiArIDApCiNkZWZpbmUgTU1fR0VUTUVOVUhBTkRMRQkoV01fVVNFUiArIDEpCgovKiBNZW51IGl0ZW0gc3RydWN0dXJlICovCnR5cGVkZWYgc3RydWN0IHsKICAgIC8qIC0tLS0tLS0tLS0tIE1FTlVJVEVNSU5GTyBTdHVmZiAtLS0tLS0tLS0tLSAqLwogICAgVUlOVCBmVHlwZTsJCQkvKiBJdGVtIHR5cGUuICovCiAgICBVSU5UIGZTdGF0ZTsJCS8qIEl0ZW0gc3RhdGUuICAqLwogICAgVUlOVF9QVFIgd0lEOwkJLyogSXRlbSBpZC4gICovCiAgICBITUVOVSBoU3ViTWVudTsJCS8qIFBvcC11cCBtZW51LiAgKi8KICAgIEhCSVRNQVAgaENoZWNrQml0OwkJLyogQml0bWFwIHdoZW4gY2hlY2tlZC4gICovCiAgICBIQklUTUFQIGhVbkNoZWNrQml0OwkvKiBCaXRtYXAgd2hlbiB1bmNoZWNrZWQuICAqLwogICAgTFBXU1RSIHRleHQ7CQkvKiBJdGVtIHRleHQuICovCiAgICBVTE9OR19QVFIgZHdJdGVtRGF0YTsJLyogQXBwbGljYXRpb24gZGVmaW5lZC4gICovCiAgICBMUFdTVFIgZHdUeXBlRGF0YTsJCS8qIGRlcGVuZHMgb24gZk1hc2sgKi8KICAgIEhCSVRNQVAgaGJtcEl0ZW07CQkvKiBiaXRtYXAgKi8KICAgIC8qIC0tLS0tLS0tLS0tIFdpbmUgc3R1ZmYgLS0tLS0tLS0tLS0gKi8KICAgIFJFQ1QgICAgICByZWN0OwkJLyogSXRlbSBhcmVhIChyZWxhdGl2ZSB0byBtZW51IHdpbmRvdykgKi8KICAgIFVJTlQgICAgICB4VGFiOwkJLyogWCBwb3NpdGlvbiBvZiB0ZXh0IGFmdGVyIFRhYiAqLwogICAgU0laRSAgIGJtcHNpemU7ICAgICAgICAgICAgIC8qIHNpemUgbmVlZGVkIGZvciB0aGUgSEJNTUVOVV9DQUxMQkFDSwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqIGJpdG1hcCAqLyAKfSBNRU5VSVRFTTsKCi8qIFBvcHVwIG1lbnUgc3RydWN0dXJlICovCnR5cGVkZWYgc3RydWN0IHsKICAgIFdPUkQgICAgICAgIHdGbGFnczsgICAgICAgLyogTWVudSBmbGFncyAoTUZfUE9QVVAsIE1GX1NZU01FTlUpICovCiAgICBXT1JEICAgICAgICB3TWFnaWM7ICAgICAgIC8qIE1hZ2ljIG51bWJlciAqLwogICAgV09SRAlXaWR0aDsgICAgICAgIC8qIFdpZHRoIG9mIHRoZSB3aG9sZSBtZW51ICovCiAgICBXT1JECUhlaWdodDsgICAgICAgLyogSGVpZ2h0IG9mIHRoZSB3aG9sZSBtZW51ICovCiAgICBVSU5UICAgICAgICBuSXRlbXM7ICAgICAgIC8qIE51bWJlciBvZiBpdGVtcyBpbiB0aGUgbWVudSAqLwogICAgSFdORCAgICAgICAgaFduZDsgICAgICAgICAvKiBXaW5kb3cgY29udGFpbmluZyB0aGUgbWVudSAqLwogICAgTUVOVUlURU0gICAgKml0ZW1zOyAgICAgICAvKiBBcnJheSBvZiBtZW51IGl0ZW1zICovCiAgICBVSU5UICAgICAgICBGb2N1c2VkSXRlbTsgIC8qIEN1cnJlbnRseSBmb2N1c2VkIGl0ZW0gKi8KICAgIEhXTkQJaHduZE93bmVyOyAgICAvKiB3aW5kb3cgcmVjZWl2aW5nIHRoZSBtZXNzYWdlcyBmb3Igb3duZXJkcmF3ICovCiAgICBCT09MICAgICAgICBiVGltZVRvSGlkZTsgIC8qIFJlcXVlc3QgaGlkaW5nIHdoZW4gcmVjZWl2aW5nIGEgc2Vjb25kIGNsaWNrIGluIHRoZSB0b3AtbGV2ZWwgbWVudSBpdGVtICovCiAgICBCT09MICAgICAgICBiU2Nyb2xsaW5nOyAgIC8qIFNjcm9sbCBhcnJvd3MgYXJlIGFjdGl2ZSAqLwogICAgVUlOVCAgICAgICAgblNjcm9sbFBvczsgICAvKiBDdXJyZW50IHNjcm9sbCBwb3NpdGlvbiAqLwogICAgVUlOVCAgICAgICAgblRvdGFsSGVpZ2h0OyAvKiBUb3RhbCBoZWlnaHQgb2YgbWVudSBpdGVtcyBpbnNpZGUgbWVudSAqLwogICAgLyogLS0tLS0tLS0tLS0tIE1FTlVJTkZPIG1lbWJlcnMgLS0tLS0tICovCiAgICBEV09SRAlkd1N0eWxlOwkvKiBFeHRlbmRlZCBtZW51IHN0eWxlICovCiAgICBVSU5UCWN5TWF4OwkJLyogbWF4IGhlaWdodCBvZiB0aGUgd2hvbGUgbWVudSwgMCBpcyBzY3JlZW4gaGVpZ2h0ICovCiAgICBIQlJVU0gJaGJyQmFjazsJLyogYnJ1c2ggZm9yIG1lbnUgYmFja2dyb3VuZCAqLwogICAgRFdPUkQJZHdDb250ZXh0SGVscElEOwogICAgRFdPUkQJZHdNZW51RGF0YTsJLyogYXBwbGljYXRpb24gZGVmaW5lZCB2YWx1ZSAqLwogICAgSE1FTlUgICAgICAgaFN5c01lbnVPd25lcjsgIC8qIEhhbmRsZSB0byB0aGUgZHVtbXkgc3lzIG1lbnUgaG9sZGVyICovCiAgICBTSVpFICAgICAgICBtYXhCbXBTaXplOyAgICAgLyogTWF4aW11bSBzaXplIG9mIHRoZSBiaXRtYXAgaXRlbXMgKi8KfSBQT1BVUE1FTlUsICpMUFBPUFVQTUVOVTsKCi8qIGludGVybmFsIGZsYWdzIGZvciBtZW51IHRyYWNraW5nICovCgojZGVmaW5lIFRGX0VORE1FTlUgICAgICAgICAgICAgIDB4MDAwMQojZGVmaW5lIFRGX1NVU1BFTkRQT1BVUCAgICAgICAgIDB4MDAwMgojZGVmaW5lIFRGX1NLSVBSRU1PVkUJCTB4MDAwNAoKdHlwZWRlZiBzdHJ1Y3QKewogICAgVUlOVAl0cmFja0ZsYWdzOwogICAgSE1FTlUJaEN1cnJlbnRNZW51OyAvKiBjdXJyZW50IHN1Ym1lbnUgKGNhbiBiZSBlcXVhbCB0byBoVG9wTWVudSkqLwogICAgSE1FTlUJaFRvcE1lbnU7ICAgICAvKiBpbml0aWFsIG1lbnUgKi8KICAgIEhXTkQJaE93bmVyV25kOyAgICAvKiB3aGVyZSBub3RpZmljYXRpb25zIGFyZSBzZW50ICovCiAgICBQT0lOVAlwdDsKfSBNVFJBQ0tFUjsKCiNkZWZpbmUgTUVOVV9NQUdJQyAgIDB4NTU0ZCAgLyogJ01VJyAqLwoKI2RlZmluZSBJVEVNX1BSRVYJCS0xCiNkZWZpbmUgSVRFTV9ORVhUCQkgMQoKICAvKiBJbnRlcm5hbCBNRU5VX1RyYWNrTWVudSgpIGZsYWdzICovCiNkZWZpbmUgVFBNX0lOVEVSTkFMCQkweEYwMDAwMDAwCiNkZWZpbmUgVFBNX0VOVEVSSURMRUVYCSAJMHg4MDAwMDAwMAkJLyogc2V0IG93bmVyIHdpbmRvdyBmb3IgV01fRU5URVJJRExFICovCiNkZWZpbmUgVFBNX0JVVFRPTkRPV04JCTB4NDAwMDAwMDAJCS8qIG1lbnUgd2FzIGNsaWNrZWQgYmVmb3JlIHRyYWNraW5nICovCiNkZWZpbmUgVFBNX1BPUFVQTUVOVSAgICAgICAgICAgMHgyMDAwMDAwMCAgICAgICAgICAgICAgLyogbWVudSBpcyBhIHBvcHVwIG1lbnUgKi8KCiAgLyogU3BhY2UgYmV0d2VlbiAyIGNvbHVtbnMgKi8KI2RlZmluZSBNRU5VX0NPTF9TUEFDRSA0CgogIC8qICB0b3AgYW5kIGJvdHRvbSBtYXJnaW5zIGZvciBwb3B1cCBtZW51cyAqLwojZGVmaW5lIE1FTlVfVE9QX01BUkdJTiAzCiNkZWZpbmUgTUVOVV9CT1RUT01fTUFSR0lOIDIKCiAgLyogKG90aGVyIG1lbnUtPkZvY3VzZWRJdGVtIHZhbHVlcyBnaXZlIHRoZSBwb3NpdGlvbiBvZiB0aGUgZm9jdXNlZCBpdGVtKSAqLwojZGVmaW5lIE5PX1NFTEVDVEVEX0lURU0gIDB4ZmZmZgoKI2RlZmluZSBNRU5VX0lURU1fVFlQRShmbGFncykgXAogICgoZmxhZ3MpICYgKE1GX1NUUklORyB8IE1GX0JJVE1BUCB8IE1GX09XTkVSRFJBVyB8IE1GX1NFUEFSQVRPUikpCgovKiBtYWNybyB0byB0ZXN0IHRoYXQgZmxhZ3MgZG8gbm90IGluZGljYXRlIGJpdG1hcCwgb3duZXJkcmF3IG9yIHNlcGFyYXRvciAqLwojZGVmaW5lIElTX1NUUklOR19JVEVNKGZsYWdzKSAoTUVOVV9JVEVNX1RZUEUgKChmbGFncykpID09IE1GX1NUUklORykKI2RlZmluZSBJU19NQUdJQ19CSVRNQVAoaWQpICAgICAoKGlkKSAmJiAoKElOVF9QVFIpKGlkKSA8IDEyKSAmJiAoKElOVF9QVFIpKGlkKSA+PSAtMSkpCgojZGVmaW5lIElTX1NZU1RFTV9NRU5VKG1lbnUpICBcCgkoISgobWVudSktPndGbGFncyAmIE1GX1BPUFVQKSAmJiAoKG1lbnUpLT53RmxhZ3MgJiBNRl9TWVNNRU5VKSkKCiNkZWZpbmUgTUVOVUlURU1JTkZPX1RZUEVfTUFTSyBcCgkJKE1GVF9TVFJJTkcgfCBNRlRfQklUTUFQIHwgTUZUX09XTkVSRFJBVyB8IE1GVF9TRVBBUkFUT1IgfCBcCgkJTUZUX01FTlVCQVJCUkVBSyB8IE1GVF9NRU5VQlJFQUsgfCBNRlRfUkFESU9DSEVDSyB8IFwKCQlNRlRfUklHSFRPUkRFUiB8IE1GVF9SSUdIVEpVU1RJRlkgLyogc2FtZSBhcyBNRl9IRUxQICovICkKI2RlZmluZSBUWVBFX01BU0sgIChNRU5VSVRFTUlORk9fVFlQRV9NQVNLIHwgTUZfUE9QVVAgfCBNRl9TWVNNRU5VKQojZGVmaW5lIFNUQVRFX01BU0sgKH5UWVBFX01BU0spCiNkZWZpbmUgTUVOVUlURU1JTkZPX1NUQVRFX01BU0sgKFNUQVRFX01BU0sgJiB+KE1GX0JZUE9TSVRJT04gfCBNRl9NT1VTRVNFTEVDVCkpCgojZGVmaW5lIFdJTl9BTExPV0VEX01FTlUoc3R5bGUpICgoc3R5bGUgJiAoV1NfQ0hJTEQgfCBXU19QT1BVUCkpICE9IFdTX0NISUxEKQoKc3RhdGljIFNJWkUgICAgIG1lbnVjaGFyc2l6ZTsKc3RhdGljIFVJTlQgICAgIE9EaXRlbWhlaWdodDsgLyogZGVmYXVsdCBvd25lciBkcmF3biBpdGVtIGhlaWdodCAqLyAgICAgIAoKLyogVXNlIGdsb2JhbCBwb3B1cCB3aW5kb3cgYmVjYXVzZSB0aGVyZSdzIG5vIHdheSAyIG1lbnVzIGNhbgogKiBiZSB0cmFja2VkIGF0IHRoZSBzYW1lIHRpbWUuICAqLwpzdGF0aWMgSFdORCB0b3BfcG9wdXA7CgogIC8qIEZsYWcgc2V0IGJ5IEVuZE1lbnUoKSB0byBmb3JjZSBhbiBleGl0IGZyb20gbWVudSB0cmFja2luZyAqLwpzdGF0aWMgQk9PTCBmRW5kTWVudSA9IEZBTFNFOwoKc3RhdGljIExSRVNVTFQgV0lOQVBJIFBvcHVwTWVudVduZFByb2MoIEhXTkQgaHduZCwgVUlOVCBtZXNzYWdlLCBXUEFSQU0gd1BhcmFtLCBMUEFSQU0gbFBhcmFtICk7CgpEV09SRCBXSU5BUEkgRHJhd01lbnVCYXJUZW1wKEhXTkQgaHduZCwgSERDIGhEQywgTFBSRUNUIGxwcmVjdCwgSE1FTlUgaE1lbnUsIEhGT05UIGhGb250KTsKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogbWVudSBjbGFzcyBkZXNjcmlwdG9yCiAqLwpjb25zdCBzdHJ1Y3QgYnVpbHRpbl9jbGFzc19kZXNjciBNRU5VX2J1aWx0aW5fY2xhc3MgPQp7CiAgICAoTFBDV1NUUilQT1BVUE1FTlVfQ0xBU1NfQVRPTSwgIC8qIG5hbWUgKi8KICAgIENTX0RST1BTSEFET1cgfCBDU19TQVZFQklUUyB8IENTX0RCTENMS1MsICAvKiBzdHlsZSAqLwogICAgTlVMTCwgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIHByb2NBICh3aW5wcm9jIGlzIFVuaWNvZGUgb25seSkgKi8KICAgIFBvcHVwTWVudVduZFByb2MsICAgICAgICAgICAgICAvKiBwcm9jVyAqLwogICAgc2l6ZW9mKEhNRU5VKSwgICAgICAgICAgICAgICAgIC8qIGV4dHJhICovCiAgICBJRENfQVJST1csICAgICAgICAgICAgICAgICAgICAgLyogY3Vyc29yICovCiAgICAoSEJSVVNIKShDT0xPUl9NRU5VKzEpICAgICAgICAgLyogYnJ1c2ggKi8KfTsKCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIGRlYnVnX3ByaW50X21lbnVpdGVtCiAqCiAqIFByaW50IGEgbWVudWl0ZW0gaW4gcmVhZGFibGUgZm9ybS4KICovCgojZGVmaW5lIGRlYnVnX3ByaW50X21lbnVpdGVtKHByZSwgbXAsIHBvc3QpIFwKICAgIGRvIHsgaWYgKFRSQUNFX09OKG1lbnUpKSBkb19kZWJ1Z19wcmludF9tZW51aXRlbShwcmUsIG1wLCBwb3N0KTsgfSB3aGlsZSAoMCkKCiNkZWZpbmUgTUVOVU9VVCh0ZXh0KSBcCiAgVFJBQ0UoIiVzJXMiLCAoY291bnQrKyA/ICIsIiA6ICIiKSwgKHRleHQpKQoKI2RlZmluZSBNRU5VRkxBRyhiaXQsdGV4dCkgXAogIGRvIHsgXAogICAgaWYgKGZsYWdzICYgKGJpdCkpIHsgZmxhZ3MgJj0gfihiaXQpOyBNRU5VT1VUICgodGV4dCkpOyB9IFwKICB9IHdoaWxlICgwKQoKc3RhdGljIHZvaWQgZG9fZGVidWdfcHJpbnRfbWVudWl0ZW0oY29uc3QgY2hhciAqcHJlZml4LCBjb25zdCBNRU5VSVRFTSAqbXAsCgkJCQkgICAgY29uc3QgY2hhciAqcG9zdGZpeCkKewogICAgc3RhdGljIGNvbnN0IGNoYXIgKiBjb25zdCBoYm1tZW51c1tdID0geyAiSEJNTUVOVV9DQUxMQkFDSyIsICIiLCAiSEJNTUVOVV9TWVNURU0iLAogICAgIkhCTU1FTlVfTUJBUl9SRVNUT1JFIiwgIkhCTU1FTlVfTUJBUl9NSU5JTUlaRSIsICJVTktOT1dOIEJJVE1BUCIsICJIQk1NRU5VX01CQVJfQ0xPU0UiLAogICAgIkhCTU1FTlVfTUJBUl9DTE9TRV9EIiwgIkhCTU1FTlVfTUJBUl9NSU5JTUlaRV9EIiwgIkhCTU1FTlVfUE9QVVBfQ0xPU0UiLAogICAgIkhCTU1FTlVfUE9QVVBfUkVTVE9SRSIsICJIQk1NRU5VX1BPUFVQX01BWElNSVpFIiwgIkhCTU1FTlVfUE9QVVBfTUlOSU1JWkUifTsKICAgIFRSQUNFKCIlcyAiLCBwcmVmaXgpOwogICAgaWYgKG1wKSB7CiAgICAgICAgVUlOVCBmbGFncyA9IG1wLT5mVHlwZTsKICAgICAgICBUUkFDRSggInsgSUQ9MHglbHgiLCBtcC0+d0lEKTsKICAgICAgICBpZiAoIG1wLT5oU3ViTWVudSkKICAgICAgICAgICAgVFJBQ0UoICIsIFN1Yj0lcCIsIG1wLT5oU3ViTWVudSk7CiAgICAgICAgaWYgKGZsYWdzKSB7CiAgICAgICAgICAgIGludCBjb3VudCA9IDA7CiAgICAgICAgICAgIFRSQUNFKCAiLCBmVHlwZT0iKTsKICAgICAgICAgICAgTUVOVUZMQUcoIE1GVF9TRVBBUkFUT1IsICJzZXAiKTsKICAgICAgICAgICAgTUVOVUZMQUcoIE1GVF9PV05FUkRSQVcsICJvd24iKTsKICAgICAgICAgICAgTUVOVUZMQUcoIE1GVF9CSVRNQVAsICJiaXQiKTsKICAgICAgICAgICAgTUVOVUZMQUcoTUZfUE9QVVAsICJwb3AiKTsKICAgICAgICAgICAgTUVOVUZMQUcoTUZUX01FTlVCQVJCUkVBSywgImJhcmJyayIpOwogICAgICAgICAgICBNRU5VRkxBRyhNRlRfTUVOVUJSRUFLLCAiYnJrIik7CiAgICAgICAgICAgIE1FTlVGTEFHKE1GVF9SQURJT0NIRUNLLCAicmFkaW8iKTsKICAgICAgICAgICAgTUVOVUZMQUcoTUZUX1JJR0hUT1JERVIsICJyb3JkZXIiKTsKICAgICAgICAgICAgTUVOVUZMQUcoTUZfU1lTTUVOVSwgInN5cyIpOwogICAgICAgICAgICBNRU5VRkxBRyhNRlRfUklHSFRKVVNUSUZZLCAicmlnaHQiKTsgIC8qIHNhbWUgYXMgTUZfSEVMUCAqLwogICAgICAgICAgICBpZiAoZmxhZ3MpCiAgICAgICAgICAgICAgICBUUkFDRSggIisweCV4IiwgZmxhZ3MpOwogICAgICAgIH0KICAgICAgICBmbGFncyA9IG1wLT5mU3RhdGU7CiAgICAgICAgaWYgKGZsYWdzKSB7CiAgICAgICAgICAgIGludCBjb3VudCA9IDA7CiAgICAgICAgICAgIFRSQUNFKCAiLCBTdGF0ZT0iKTsKICAgICAgICAgICAgTUVOVUZMQUcoTUZTX0dSQVlFRCwgImdyZXkiKTsKICAgICAgICAgICAgTUVOVUZMQUcoTUZTX0RFRkFVTFQsICJkZWZhdWx0Iik7CiAgICAgICAgICAgIE1FTlVGTEFHKE1GU19ESVNBQkxFRCwgImRpcyIpOwogICAgICAgICAgICBNRU5VRkxBRyhNRlNfQ0hFQ0tFRCwgImNoZWNrIik7CiAgICAgICAgICAgIE1FTlVGTEFHKE1GU19ISUxJVEUsICJoaSIpOwogICAgICAgICAgICBNRU5VRkxBRyhNRl9VU0VDSEVDS0JJVE1BUFMsICJ1c2ViaXQiKTsKICAgICAgICAgICAgTUVOVUZMQUcoTUZfTU9VU0VTRUxFQ1QsICJtb3VzZSIpOwogICAgICAgICAgICBpZiAoZmxhZ3MpCiAgICAgICAgICAgICAgICBUUkFDRSggIisweCV4IiwgZmxhZ3MpOwogICAgICAgIH0KICAgICAgICBpZiAobXAtPmhDaGVja0JpdCkKICAgICAgICAgICAgVFJBQ0UoICIsIENoaz0lcCIsIG1wLT5oQ2hlY2tCaXQpOwogICAgICAgIGlmIChtcC0+aFVuQ2hlY2tCaXQpCiAgICAgICAgICAgIFRSQUNFKCAiLCBVbmM9JXAiLCBtcC0+aFVuQ2hlY2tCaXQpOwogICAgICAgIGlmIChtcC0+dGV4dCkKICAgICAgICAgICAgVFJBQ0UoICIsIFRleHQ9JXMiLCBkZWJ1Z3N0cl93KG1wLT50ZXh0KSk7CiAgICAgICAgaWYgKG1wLT5kd0l0ZW1EYXRhKQogICAgICAgICAgICBUUkFDRSggIiwgSXRlbURhdGE9MHglMDhseCIsIG1wLT5kd0l0ZW1EYXRhKTsKICAgICAgICBpZiAobXAtPmhibXBJdGVtKQogICAgICAgIHsKICAgICAgICAgICAgaWYoIElTX01BR0lDX0JJVE1BUChtcC0+aGJtcEl0ZW0pKQogICAgICAgICAgICAgICAgVFJBQ0UoICIsIGhiaXRtYXA9JXMiLCBoYm1tZW51c1sgKElOVF9QVFIpbXAtPmhibXBJdGVtICsgMV0pOwogICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICBUUkFDRSggIiwgaGJpdG1hcD0lcCIsIG1wLT5oYm1wSXRlbSk7CiAgICAgICAgfQogICAgICAgIFRSQUNFKCAiIH0iKTsKICAgIH0gZWxzZQogICAgICAgIFRSQUNFKCAiTlVMTCIpOwogICAgVFJBQ0UoIiAlc1xuIiwgcG9zdGZpeCk7Cn0KCiN1bmRlZiBNRU5VT1VUCiN1bmRlZiBNRU5VRkxBRwoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9HZXRNZW51CiAqCiAqIFZhbGlkYXRlIHRoZSBnaXZlbiBtZW51IGhhbmRsZSBhbmQgcmV0dXJucyB0aGUgbWVudSBzdHJ1Y3R1cmUgcG9pbnRlci4KICovCnN0YXRpYyBQT1BVUE1FTlUgKk1FTlVfR2V0TWVudShITUVOVSBoTWVudSkKewogICAgUE9QVVBNRU5VICptZW51ID0gVVNFUl9IRUFQX0xJTl9BRERSKGhNZW51KTsKICAgIGlmICghbWVudSB8fCBtZW51LT53TWFnaWMgIT0gTUVOVV9NQUdJQykKICAgIHsKICAgICAgICBXQVJOKCJpbnZhbGlkIG1lbnUgaGFuZGxlPSVwLCBwdHI9JXAsIG1hZ2ljPSV4XG4iLCBoTWVudSwgbWVudSwgbWVudT8gbWVudS0+d01hZ2ljOjApOwogICAgICAgIG1lbnUgPSBOVUxMOwogICAgfQogICAgcmV0dXJuIG1lbnU7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgZ2V0X3dpbl9zeXNfbWVudQogKgogKiBHZXQgdGhlIHN5c3RlbSBtZW51IG9mIGEgd2luZG93CiAqLwpzdGF0aWMgSE1FTlUgZ2V0X3dpbl9zeXNfbWVudSggSFdORCBod25kICkKewogICAgSE1FTlUgcmV0ID0gMDsKICAgIFdORCAqd2luID0gV0lOX0dldFB0ciggaHduZCApOwogICAgaWYgKHdpbiAmJiB3aW4gIT0gV05EX09USEVSX1BST0NFU1MgJiYgd2luICE9IFdORF9ERVNLVE9QKQogICAgewogICAgICAgIHJldCA9IHdpbi0+aFN5c01lbnU7CiAgICAgICAgV0lOX1JlbGVhc2VQdHIoIHdpbiApOwogICAgfQogICAgcmV0dXJuIHJldDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBnZXRfbWVudV9mb250CiAqLwpzdGF0aWMgSEZPTlQgZ2V0X21lbnVfZm9udCggQk9PTCBib2xkICkKewogICAgc3RhdGljIEhGT05UIGhNZW51Rm9udCwgaE1lbnVGb250Qm9sZDsKCiAgICBIRk9OVCByZXQgPSBib2xkID8gaE1lbnVGb250Qm9sZCA6IGhNZW51Rm9udDsKCiAgICBpZiAoIXJldCkKICAgIHsKICAgICAgICBOT05DTElFTlRNRVRSSUNTVyBuY207CiAgICAgICAgSEZPTlQgcHJldjsKCiAgICAgICAgbmNtLmNiU2l6ZSA9IHNpemVvZihOT05DTElFTlRNRVRSSUNTVyk7CiAgICAgICAgU3lzdGVtUGFyYW1ldGVyc0luZm9XKFNQSV9HRVROT05DTElFTlRNRVRSSUNTLCBzaXplb2YoTk9OQ0xJRU5UTUVUUklDU1cpLCAmbmNtLCAwKTsKCiAgICAgICAgaWYgKGJvbGQpCiAgICAgICAgewogICAgICAgICAgICBuY20ubGZNZW51Rm9udC5sZldlaWdodCArPSAzMDA7CiAgICAgICAgICAgIGlmIChuY20ubGZNZW51Rm9udC5sZldlaWdodCA+IDEwMDApIG5jbS5sZk1lbnVGb250LmxmV2VpZ2h0ID0gMTAwMDsKICAgICAgICB9CiAgICAgICAgaWYgKCEocmV0ID0gQ3JlYXRlRm9udEluZGlyZWN0VyggJm5jbS5sZk1lbnVGb250ICkpKSByZXR1cm4gMDsKICAgICAgICBwcmV2ID0gSW50ZXJsb2NrZWRDb21wYXJlRXhjaGFuZ2VQb2ludGVyKCAodm9pZCAqKikoYm9sZCA/ICZoTWVudUZvbnRCb2xkIDogJmhNZW51Rm9udCksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmV0LCBOVUxMICk7CiAgICAgICAgaWYgKHByZXYpCiAgICAgICAgewogICAgICAgICAgICAvKiBhbm90aGVyIHRocmVhZCBiZWF0IHVzIHRvIGl0ICovCiAgICAgICAgICAgIERlbGV0ZU9iamVjdCggcmV0ICk7CiAgICAgICAgICAgIHJldCA9IHByZXY7CiAgICAgICAgfQogICAgfQogICAgcmV0dXJuIHJldDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBnZXRfYXJyb3dfYml0bWFwCiAqLwpzdGF0aWMgSEJJVE1BUCBnZXRfYXJyb3dfYml0bWFwKHZvaWQpCnsKICAgIHN0YXRpYyBIQklUTUFQIGFycm93X2JpdG1hcDsKCiAgICBpZiAoIWFycm93X2JpdG1hcCkgYXJyb3dfYml0bWFwID0gTG9hZEJpdG1hcFcoMCwgTUFLRUlOVFJFU09VUkNFVyhPQk1fTU5BUlJPVykpOwogICAgcmV0dXJuIGFycm93X2JpdG1hcDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBnZXRfZG93bl9hcnJvd19iaXRtYXAKICovCnN0YXRpYyBIQklUTUFQIGdldF9kb3duX2Fycm93X2JpdG1hcCh2b2lkKQp7CiAgICBzdGF0aWMgSEJJVE1BUCBhcnJvd19iaXRtYXA7CgogICAgaWYgKCFhcnJvd19iaXRtYXApIGFycm93X2JpdG1hcCA9IExvYWRCaXRtYXBXKDAsIE1BS0VJTlRSRVNPVVJDRVcoT0JNX0ROQVJST1cpKTsKICAgIHJldHVybiBhcnJvd19iaXRtYXA7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgZ2V0X2Rvd25fYXJyb3dfaW5hY3RpdmVfYml0bWFwCiAqLwpzdGF0aWMgSEJJVE1BUCBnZXRfZG93bl9hcnJvd19pbmFjdGl2ZV9iaXRtYXAodm9pZCkKewogICAgc3RhdGljIEhCSVRNQVAgYXJyb3dfYml0bWFwOwoKICAgIGlmICghYXJyb3dfYml0bWFwKSBhcnJvd19iaXRtYXAgPSBMb2FkQml0bWFwVygwLCBNQUtFSU5UUkVTT1VSQ0VXKE9CTV9ETkFSUk9XSSkpOwogICAgcmV0dXJuIGFycm93X2JpdG1hcDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBnZXRfdXBfYXJyb3dfYml0bWFwCiAqLwpzdGF0aWMgSEJJVE1BUCBnZXRfdXBfYXJyb3dfYml0bWFwKHZvaWQpCnsKICAgIHN0YXRpYyBIQklUTUFQIGFycm93X2JpdG1hcDsKCiAgICBpZiAoIWFycm93X2JpdG1hcCkgYXJyb3dfYml0bWFwID0gTG9hZEJpdG1hcFcoMCwgTUFLRUlOVFJFU09VUkNFVyhPQk1fVVBBUlJPVykpOwogICAgcmV0dXJuIGFycm93X2JpdG1hcDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBnZXRfdXBfYXJyb3dfaW5hY3RpdmVfYml0bWFwCiAqLwpzdGF0aWMgSEJJVE1BUCBnZXRfdXBfYXJyb3dfaW5hY3RpdmVfYml0bWFwKHZvaWQpCnsKICAgIHN0YXRpYyBIQklUTUFQIGFycm93X2JpdG1hcDsKCiAgICBpZiAoIWFycm93X2JpdG1hcCkgYXJyb3dfYml0bWFwID0gTG9hZEJpdG1hcFcoMCwgTUFLRUlOVFJFU09VUkNFVyhPQk1fVVBBUlJPV0kpKTsKICAgIHJldHVybiBhcnJvd19iaXRtYXA7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9Db3B5U3lzUG9wdXAKICoKICogUmV0dXJuIHRoZSBkZWZhdWx0IHN5c3RlbSBtZW51LgogKi8Kc3RhdGljIEhNRU5VIE1FTlVfQ29weVN5c1BvcHVwKHZvaWQpCnsKICAgIHN0YXRpYyBjb25zdCBXQ0hBUiBzeXNtZW51V1tdID0geydTJywnWScsJ1MnLCdNJywnRScsJ04nLCdVJywwfTsKICAgIEhNRU5VIGhNZW51ID0gTG9hZE1lbnVXKHVzZXIzMl9tb2R1bGUsIHN5c21lbnVXKTsKCiAgICBpZiggaE1lbnUgKSB7CiAgICAgICAgUE9QVVBNRU5VKiBtZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KTsKICAgICAgICBtZW51LT53RmxhZ3MgfD0gTUZfU1lTTUVOVSB8IE1GX1BPUFVQOwoJU2V0TWVudURlZmF1bHRJdGVtKGhNZW51LCBTQ19DTE9TRSwgRkFMU0UpOwogICAgfQogICAgZWxzZQoJRVJSKCJVbmFibGUgdG8gbG9hZCBkZWZhdWx0IHN5c3RlbSBtZW51XG4iICk7CgogICAgVFJBQ0UoInJldHVybmluZyAlcC5cbiIsIGhNZW51ICk7CgogICAgcmV0dXJuIGhNZW51Owp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfR2V0U3lzTWVudQogKgogKiBDcmVhdGUgYSBjb3B5IG9mIHRoZSBzeXN0ZW0gbWVudS4gU3lzdGVtIG1lbnUgaW4gV2luZG93cyBpcwogKiBhIHNwZWNpYWwgbWVudSBiYXIgd2l0aCB0aGUgc2luZ2xlIGVudHJ5IC0gc3lzdGVtIG1lbnUgcG9wdXAuCiAqIFRoaXMgcG9wdXAgaXMgcHJlc2VudGVkIHRvIHRoZSBvdXRzaWRlIHdvcmxkIGFzIGEgInN5c3RlbSBtZW51Ii4KICogSG93ZXZlciwgdGhlIHJlYWwgc3lzdGVtIG1lbnUgaGFuZGxlIGlzIHNvbWV0aW1lcyBzZWVuIGluIHRoZQogKiBXTV9NRU5VU0VMRUNUIHBhcmFtZXRlcnMgKGFuZCBXb3JkIDYgbGlrZXMgaXQgdGhpcyB3YXkpLgogKi8Kc3RhdGljIEhNRU5VIE1FTlVfR2V0U3lzTWVudSggSFdORCBoV25kLCBITUVOVSBoUG9wdXBNZW51ICkKewogICAgSE1FTlUgaE1lbnU7CgogICAgVFJBQ0UoImxvYWRpbmcgc3lzdGVtIG1lbnUsIGhXbmQgJXAsIGhQb3B1cE1lbnUgJXBcbiIsIGhXbmQsIGhQb3B1cE1lbnUpOwogICAgaWYgKChoTWVudSA9IENyZWF0ZU1lbnUoKSkpCiAgICB7CglQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpOwoJbWVudS0+d0ZsYWdzID0gTUZfU1lTTUVOVTsKCW1lbnUtPmhXbmQgPSBXSU5fR2V0RnVsbEhhbmRsZSggaFduZCApOwoJVFJBQ0UoImhXbmQgJXAgKGhNZW51ICVwKVxuIiwgbWVudS0+aFduZCwgaE1lbnUpOwoKCWlmICghaFBvcHVwTWVudSkKCSAgICBoUG9wdXBNZW51ID0gTUVOVV9Db3B5U3lzUG9wdXAoKTsKCglpZiAoaFBvcHVwTWVudSkKCXsKICAgICAgICAgICAgaWYgKEdldENsYXNzTG9uZ1coaFduZCwgR0NMX1NUWUxFKSAmIENTX05PQ0xPU0UpCiAgICAgICAgICAgICAgICBEZWxldGVNZW51KGhQb3B1cE1lbnUsIFNDX0NMT1NFLCBNRl9CWUNPTU1BTkQpOwoKCSAgICBJbnNlcnRNZW51VyggaE1lbnUsIC0xLCBNRl9TWVNNRU5VIHwgTUZfUE9QVVAgfCBNRl9CWVBPU0lUSU9OLAogICAgICAgICAgICAgICAgICAgICAgICAgKFVJTlRfUFRSKWhQb3B1cE1lbnUsIE5VTEwgKTsKCiAgICAgICAgICAgIG1lbnUtPml0ZW1zWzBdLmZUeXBlID0gTUZfU1lTTUVOVSB8IE1GX1BPUFVQOwogICAgICAgICAgICBtZW51LT5pdGVtc1swXS5mU3RhdGUgPSAwOwogICAgICAgICAgICBpZiAoKG1lbnUgPSBNRU5VX0dldE1lbnUoaFBvcHVwTWVudSkpKSBtZW51LT53RmxhZ3MgfD0gTUZfU1lTTUVOVTsKCgkgICAgVFJBQ0UoImhNZW51PSVwIChoUG9wdXAgJXApXG4iLCBoTWVudSwgaFBvcHVwTWVudSApOwoJICAgIHJldHVybiBoTWVudTsKCX0KCURlc3Ryb3lNZW51KCBoTWVudSApOwogICAgfQogICAgRVJSKCJmYWlsZWQgdG8gbG9hZCBzeXN0ZW0gbWVudSFcbiIpOwogICAgcmV0dXJuIDA7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfSW5pdFN5c01lbnVQb3B1cAogKgogKiBHcmV5IHRoZSBhcHByb3ByaWF0ZSBpdGVtcyBpbiBTeXN0ZW0gbWVudS4KICovCnN0YXRpYyB2b2lkIE1FTlVfSW5pdFN5c01lbnVQb3B1cCggSE1FTlUgaG1lbnUsIERXT1JEIHN0eWxlLCBEV09SRCBjbHNTdHlsZSApCnsKICAgIEJPT0wgZ3JheTsKCiAgICBncmF5ID0gIShzdHlsZSAmIFdTX1RISUNLRlJBTUUpIHx8IChzdHlsZSAmIChXU19NQVhJTUlaRSB8IFdTX01JTklNSVpFKSk7CiAgICBFbmFibGVNZW51SXRlbSggaG1lbnUsIFNDX1NJWkUsIChncmF5ID8gTUZfR1JBWUVEIDogTUZfRU5BQkxFRCkgKTsKICAgIGdyYXkgPSAoKHN0eWxlICYgV1NfTUFYSU1JWkUpICE9IDApOwogICAgRW5hYmxlTWVudUl0ZW0oIGhtZW51LCBTQ19NT1ZFLCAoZ3JheSA/IE1GX0dSQVlFRCA6IE1GX0VOQUJMRUQpICk7CiAgICBncmF5ID0gIShzdHlsZSAmIFdTX01JTklNSVpFQk9YKSB8fCAoc3R5bGUgJiBXU19NSU5JTUlaRSk7CiAgICBFbmFibGVNZW51SXRlbSggaG1lbnUsIFNDX01JTklNSVpFLCAoZ3JheSA/IE1GX0dSQVlFRCA6IE1GX0VOQUJMRUQpICk7CiAgICBncmF5ID0gIShzdHlsZSAmIFdTX01BWElNSVpFQk9YKSB8fCAoc3R5bGUgJiBXU19NQVhJTUlaRSk7CiAgICBFbmFibGVNZW51SXRlbSggaG1lbnUsIFNDX01BWElNSVpFLCAoZ3JheSA/IE1GX0dSQVlFRCA6IE1GX0VOQUJMRUQpICk7CiAgICBncmF5ID0gIShzdHlsZSAmIChXU19NQVhJTUlaRSB8IFdTX01JTklNSVpFKSk7CiAgICBFbmFibGVNZW51SXRlbSggaG1lbnUsIFNDX1JFU1RPUkUsIChncmF5ID8gTUZfR1JBWUVEIDogTUZfRU5BQkxFRCkgKTsKICAgIGdyYXkgPSAoY2xzU3R5bGUgJiBDU19OT0NMT1NFKSAhPSAwOwoKICAgIC8qIFRoZSBtZW51IGl0ZW0gbXVzdCBrZWVwIGl0cyBzdGF0ZSBpZiBpdCdzIGRpc2FibGVkICovCiAgICBpZihncmF5KQoJRW5hYmxlTWVudUl0ZW0oIGhtZW51LCBTQ19DTE9TRSwgTUZfR1JBWUVEKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoKICogICBVSU5UICBNRU5VX0dldFN0YXJ0T2ZOZXh0Q29sdW1uKAogKiAgICAgSE1FTlUgIGhNZW51ICkKICoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwoKc3RhdGljIFVJTlQgIE1FTlVfR2V0U3RhcnRPZk5leHRDb2x1bW4oCiAgICBITUVOVSAgaE1lbnUgKQp7CiAgICBQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpOwogICAgVUlOVCBpOwoKICAgIGlmKCFtZW51KQoJcmV0dXJuIE5PX1NFTEVDVEVEX0lURU07CgogICAgaSA9IG1lbnUtPkZvY3VzZWRJdGVtICsgMTsKICAgIGlmKCBpID09IE5PX1NFTEVDVEVEX0lURU0gKQoJcmV0dXJuIGk7CgogICAgZm9yKCA7IGkgPCBtZW51LT5uSXRlbXM7ICsraSApIHsKCWlmIChtZW51LT5pdGVtc1tpXS5mVHlwZSAmIChNRl9NRU5VQlJFQUsgfCBNRl9NRU5VQkFSQlJFQUspKQoJICAgIHJldHVybiBpOwogICAgfQoKICAgIHJldHVybiBOT19TRUxFQ1RFRF9JVEVNOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgogKiAgIFVJTlQgIE1FTlVfR2V0U3RhcnRPZlByZXZDb2x1bW4oCiAqICAgICBITUVOVSAgaE1lbnUgKQogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCgpzdGF0aWMgVUlOVCAgTUVOVV9HZXRTdGFydE9mUHJldkNvbHVtbigKICAgIEhNRU5VICBoTWVudSApCnsKICAgIFBPUFVQTUVOVSAqbWVudSA9IE1FTlVfR2V0TWVudShoTWVudSk7CiAgICBVSU5UICBpOwoKICAgIGlmKCAhbWVudSApCglyZXR1cm4gTk9fU0VMRUNURURfSVRFTTsKCiAgICBpZiggbWVudS0+Rm9jdXNlZEl0ZW0gPT0gMCB8fCBtZW51LT5Gb2N1c2VkSXRlbSA9PSBOT19TRUxFQ1RFRF9JVEVNICkKCXJldHVybiBOT19TRUxFQ1RFRF9JVEVNOwoKICAgIC8qIEZpbmQgdGhlIHN0YXJ0IG9mIHRoZSBjb2x1bW4gKi8KCiAgICBmb3IoaSA9IG1lbnUtPkZvY3VzZWRJdGVtOyBpICE9IDAgJiYKCSAhKG1lbnUtPml0ZW1zW2ldLmZUeXBlICYgKE1GX01FTlVCUkVBSyB8IE1GX01FTlVCQVJCUkVBSykpOwoJLS1pKTsgLyogZW1wdHkgKi8KCiAgICBpZihpID09IDApCglyZXR1cm4gTk9fU0VMRUNURURfSVRFTTsKCiAgICBmb3IoLS1pOyBpICE9IDA7IC0taSkgewoJaWYgKG1lbnUtPml0ZW1zW2ldLmZUeXBlICYgKE1GX01FTlVCUkVBSyB8IE1GX01FTlVCQVJCUkVBSykpCgkgICAgYnJlYWs7CiAgICB9CgogICAgVFJBQ0UoInJldCAlZC5cbiIsIGkgKTsKCiAgICByZXR1cm4gaTsKfQoKCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfRmluZEl0ZW0KICoKICogRmluZCBhIG1lbnUgaXRlbS4gUmV0dXJuIGEgcG9pbnRlciBvbiB0aGUgaXRlbSwgYW5kIG1vZGlmaWVzICpobWVudQogKiBpbiBjYXNlIHRoZSBpdGVtIHdhcyBpbiBhIHN1Yi1tZW51LgogKi8Kc3RhdGljIE1FTlVJVEVNICpNRU5VX0ZpbmRJdGVtKCBITUVOVSAqaG1lbnUsIFVJTlQgKm5Qb3MsIFVJTlQgd0ZsYWdzICkKewogICAgUE9QVVBNRU5VICptZW51OwogICAgTUVOVUlURU0gKmZhbGxiYWNrID0gTlVMTDsKICAgIFVJTlQgZmFsbGJhY2tfcG9zID0gMDsKICAgIFVJTlQgaTsKCiAgICBpZiAoKCpobWVudSA9PSAoSE1FTlUpMHhmZmZmKSB8fCAoIShtZW51ID0gTUVOVV9HZXRNZW51KCpobWVudSkpKSkgcmV0dXJuIE5VTEw7CiAgICBpZiAod0ZsYWdzICYgTUZfQllQT1NJVElPTikKICAgIHsKCWlmICgqblBvcyA+PSBtZW51LT5uSXRlbXMpIHJldHVybiBOVUxMOwoJcmV0dXJuICZtZW51LT5pdGVtc1sqblBvc107CiAgICB9CiAgICBlbHNlCiAgICB7CiAgICAgICAgTUVOVUlURU0gKml0ZW0gPSBtZW51LT5pdGVtczsKCWZvciAoaSA9IDA7IGkgPCBtZW51LT5uSXRlbXM7IGkrKywgaXRlbSsrKQoJewoJICAgIGlmIChpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKQoJICAgIHsKCQlITUVOVSBoc3VibWVudSA9IGl0ZW0tPmhTdWJNZW51OwoJCU1FTlVJVEVNICpzdWJpdGVtID0gTUVOVV9GaW5kSXRlbSggJmhzdWJtZW51LCBuUG9zLCB3RmxhZ3MgKTsKCQlpZiAoc3ViaXRlbSkKCQl7CgkJICAgICpobWVudSA9IGhzdWJtZW51OwoJCSAgICByZXR1cm4gc3ViaXRlbTsKCQl9CgkJZWxzZSBpZiAoaXRlbS0+d0lEID09ICpuUG9zKQoJCXsKCQkgICAgLyogZmFsbGJhY2sgdG8gdGhpcyBpdGVtIGlmIG5vdGhpbmcgZWxzZSBmb3VuZCAqLwoJCSAgICBmYWxsYmFja19wb3MgPSBpOwoJCSAgICBmYWxsYmFjayA9IGl0ZW07CgkJfQoJICAgIH0KCSAgICBlbHNlIGlmIChpdGVtLT53SUQgPT0gKm5Qb3MpCgkgICAgewoJCSpuUG9zID0gaTsKCQlyZXR1cm4gaXRlbTsKCSAgICB9Cgl9CiAgICB9CgogICAgaWYgKGZhbGxiYWNrKQogICAgICAgICpuUG9zID0gZmFsbGJhY2tfcG9zOwoKICAgIHJldHVybiBmYWxsYmFjazsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0ZpbmRTdWJNZW51CiAqCiAqIEZpbmQgYSBTdWIgbWVudS4gUmV0dXJuIHRoZSBwb3NpdGlvbiBvZiB0aGUgc3VibWVudSwgYW5kIG1vZGlmaWVzCiAqICpobWVudSBpbiBjYXNlIGl0IGlzIGZvdW5kIGluIGFub3RoZXIgc3ViLW1lbnUuCiAqIElmIHRoZSBzdWJtZW51IGNhbm5vdCBiZSBmb3VuZCwgTk9fU0VMRUNURURfSVRFTSBpcyByZXR1cm5lZC4KICovClVJTlQgTUVOVV9GaW5kU3ViTWVudSggSE1FTlUgKmhtZW51LCBITUVOVSBoU3ViVGFyZ2V0ICkKewogICAgUE9QVVBNRU5VICptZW51OwogICAgVUlOVCBpOwogICAgTUVOVUlURU0gKml0ZW07CiAgICBpZiAoKCgqaG1lbnUpPT0oSE1FTlUpMHhmZmZmKSB8fAogICAgICAgICAgICAoIShtZW51ID0gTUVOVV9HZXRNZW51KCpobWVudSkpKSkKICAgICAgICByZXR1cm4gTk9fU0VMRUNURURfSVRFTTsKICAgIGl0ZW0gPSBtZW51LT5pdGVtczsKICAgIGZvciAoaSA9IDA7IGkgPCBtZW51LT5uSXRlbXM7IGkrKywgaXRlbSsrKSB7CiAgICAgICAgaWYoIShpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKSkgY29udGludWU7CiAgICAgICAgaWYgKGl0ZW0tPmhTdWJNZW51ID09IGhTdWJUYXJnZXQpIHsKICAgICAgICAgICAgcmV0dXJuIGk7CiAgICAgICAgfQogICAgICAgIGVsc2UgIHsKICAgICAgICAgICAgSE1FTlUgaHN1Ym1lbnUgPSBpdGVtLT5oU3ViTWVudTsKICAgICAgICAgICAgVUlOVCBwb3MgPSBNRU5VX0ZpbmRTdWJNZW51KCAmaHN1Ym1lbnUsIGhTdWJUYXJnZXQgKTsKICAgICAgICAgICAgaWYgKHBvcyAhPSBOT19TRUxFQ1RFRF9JVEVNKSB7CiAgICAgICAgICAgICAgICAqaG1lbnUgPSBoc3VibWVudTsKICAgICAgICAgICAgICAgIHJldHVybiBwb3M7CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICB9CiAgICByZXR1cm4gTk9fU0VMRUNURURfSVRFTTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0ZyZWVJdGVtRGF0YQogKi8Kc3RhdGljIHZvaWQgTUVOVV9GcmVlSXRlbURhdGEoIE1FTlVJVEVNKiBpdGVtICkKewogICAgLyogZGVsZXRlIHRleHQgKi8KICAgIEhlYXBGcmVlKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBpdGVtLT50ZXh0ICk7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9BZGp1c3RNZW51SXRlbVJlY3QKICoKICogQWRqdXN0IG1lbnUgaXRlbSByZWN0YW5nbGUgYWNjb3JkaW5nIHRvIHNjcm9sbGluZyBzdGF0ZS4KICovCnN0YXRpYyB2b2lkCk1FTlVfQWRqdXN0TWVudUl0ZW1SZWN0KGNvbnN0IFBPUFVQTUVOVSAqbWVudSwgTFBSRUNUIHJlY3QpCnsKICAgIGlmIChtZW51LT5iU2Nyb2xsaW5nKQogICAgewogICAgICAgIFVJTlQgYXJyb3dfYml0bWFwX3dpZHRoLCBhcnJvd19iaXRtYXBfaGVpZ2h0OwogICAgICAgIEJJVE1BUCBibXA7CgogICAgICAgIEdldE9iamVjdFcoZ2V0X3VwX2Fycm93X2JpdG1hcCgpLCBzaXplb2YoYm1wKSwgJmJtcCk7CiAgICAgICAgYXJyb3dfYml0bWFwX3dpZHRoID0gYm1wLmJtV2lkdGg7CiAgICAgICAgYXJyb3dfYml0bWFwX2hlaWdodCA9IGJtcC5ibUhlaWdodDsKICAgICAgICByZWN0LT50b3AgKz0gYXJyb3dfYml0bWFwX2hlaWdodCAtIG1lbnUtPm5TY3JvbGxQb3M7CiAgICAgICAgcmVjdC0+Ym90dG9tICs9IGFycm93X2JpdG1hcF9oZWlnaHQgLSBtZW51LT5uU2Nyb2xsUG9zOwogICAgfQp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0ZpbmRJdGVtQnlDb29yZHMKICoKICogRmluZCB0aGUgaXRlbSBhdCB0aGUgc3BlY2lmaWVkIGNvb3JkaW5hdGVzIChzY3JlZW4gY29vcmRzKS4gRG9lcwogKiBub3Qgd29yayBmb3IgY2hpbGQgd2luZG93cyBhbmQgdGhlcmVmb3JlIHNob3VsZCBub3QgYmUgY2FsbGVkIGZvcgogKiBhbiBhcmJpdHJhcnkgc3lzdGVtIG1lbnUuCiAqLwpzdGF0aWMgTUVOVUlURU0gKk1FTlVfRmluZEl0ZW1CeUNvb3JkcyggY29uc3QgUE9QVVBNRU5VICptZW51LAoJCQkJCVBPSU5UIHB0LCBVSU5UICpwb3MgKQp7CiAgICBNRU5VSVRFTSAqaXRlbTsKICAgIFVJTlQgaTsKICAgIFJFQ1QgcmVjdDsKCiAgICBpZiAoIUdldFdpbmRvd1JlY3QobWVudS0+aFduZCwgJnJlY3QpKSByZXR1cm4gTlVMTDsKICAgIHB0LnggLT0gcmVjdC5sZWZ0OwogICAgcHQueSAtPSByZWN0LnRvcDsKICAgIGl0ZW0gPSBtZW51LT5pdGVtczsKICAgIGZvciAoaSA9IDA7IGkgPCBtZW51LT5uSXRlbXM7IGkrKywgaXRlbSsrKQogICAgewogICAgICAgIHJlY3QgPSBpdGVtLT5yZWN0OwogICAgICAgIE1FTlVfQWRqdXN0TWVudUl0ZW1SZWN0KG1lbnUsICZyZWN0KTsKCWlmIChQdEluUmVjdCgmcmVjdCwgcHQpKQoJewoJICAgIGlmIChwb3MpICpwb3MgPSBpOwoJICAgIHJldHVybiBpdGVtOwoJfQogICAgfQogICAgcmV0dXJuIE5VTEw7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfRmluZEl0ZW1CeUtleQogKgogKiBGaW5kIHRoZSBtZW51IGl0ZW0gc2VsZWN0ZWQgYnkgYSBrZXkgcHJlc3MuCiAqIFJldHVybiBpdGVtIGlkLCAtMSBpZiBub25lLCAtMiBpZiB3ZSBzaG91bGQgY2xvc2UgdGhlIG1lbnUuCiAqLwpzdGF0aWMgVUlOVCBNRU5VX0ZpbmRJdGVtQnlLZXkoIEhXTkQgaHduZE93bmVyLCBITUVOVSBobWVudSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXQ0hBUiBrZXksIEJPT0wgZm9yY2VNZW51Q2hhciApCnsKICAgIFRSQUNFKCJcdGxvb2tpbmcgZm9yICclYycgKDB4JTAyeCkgaW4gWyVwXVxuIiwgKGNoYXIpa2V5LCBrZXksIGhtZW51ICk7CgogICAgaWYgKCFJc01lbnUoIGhtZW51ICkpIGhtZW51ID0gR2V0U3ViTWVudSggZ2V0X3dpbl9zeXNfbWVudShod25kT3duZXIpLCAwKTsKCiAgICBpZiAoaG1lbnUpCiAgICB7CglQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoIGhtZW51ICk7CglNRU5VSVRFTSAqaXRlbSA9IG1lbnUtPml0ZW1zOwoJTFJFU1VMVCBtZW51Y2hhcjsKCglpZiggIWZvcmNlTWVudUNoYXIgKQoJewoJICAgICBVSU5UIGk7CgoJICAgICBmb3IgKGkgPSAwOyBpIDwgbWVudS0+bkl0ZW1zOyBpKyssIGl0ZW0rKykKCSAgICAgewoJCWlmKCBpdGVtLT50ZXh0KQoJCXsKCQkgICAgV0NIQVIgKnAgPSBpdGVtLT50ZXh0IC0gMjsKCQkgICAgZG8KCQkgICAgewoJCSAgICAJcCA9IHN0cmNoclcgKHAgKyAyLCAnJicpOwoJCSAgICB9CgkJICAgIHdoaWxlIChwICE9IE5VTEwgJiYgcCBbMV0gPT0gJyYnKTsKCQkgICAgaWYgKHAgJiYgKHRvdXBwZXJXKHBbMV0pID09IHRvdXBwZXJXKGtleSkpKSByZXR1cm4gaTsKCQl9CgkgICAgIH0KCX0KCW1lbnVjaGFyID0gU2VuZE1lc3NhZ2VXKCBod25kT3duZXIsIFdNX01FTlVDSEFSLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBNQUtFV1BBUkFNKCBrZXksIG1lbnUtPndGbGFncyApLCAoTFBBUkFNKWhtZW51ICk7CglpZiAoSElXT1JEKG1lbnVjaGFyKSA9PSAyKSByZXR1cm4gTE9XT1JEKG1lbnVjaGFyKTsKCWlmIChISVdPUkQobWVudWNoYXIpID09IDEpIHJldHVybiAoVUlOVCkoLTIpOwogICAgfQogICAgcmV0dXJuIChVSU5UKSgtMSk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfR2V0Qml0bWFwSXRlbVNpemUKICoKICogR2V0IHRoZSBzaXplIG9mIGEgYml0bWFwIGl0ZW0uCiAqLwpzdGF0aWMgdm9pZCBNRU5VX0dldEJpdG1hcEl0ZW1TaXplKCBNRU5VSVRFTSAqbHBpdGVtLCBTSVpFICpzaXplLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBIV05EIGh3bmRPd25lcikKewogICAgQklUTUFQIGJtOwogICAgSEJJVE1BUCBibXAgPSBscGl0ZW0tPmhibXBJdGVtOwoKICAgIHNpemUtPmN4ID0gc2l6ZS0+Y3kgPSAwOwoKICAgIC8qIGNoZWNrIGlmIHRoZXJlIGlzIGEgbWFnaWMgbWVudSBpdGVtIGFzc29jaWF0ZWQgd2l0aCB0aGlzIGl0ZW0gKi8KICAgIHN3aXRjaCggKElOVF9QVFIpIGJtcCApCiAgICB7CiAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfQ0FMTEJBQ0s6CiAgICAgICAgewogICAgICAgICAgICBNRUFTVVJFSVRFTVNUUlVDVCBtZWFzSXRlbTsKICAgICAgICAgICAgbWVhc0l0ZW0uQ3RsVHlwZSA9IE9EVF9NRU5VOwogICAgICAgICAgICBtZWFzSXRlbS5DdGxJRCA9IDA7CiAgICAgICAgICAgIG1lYXNJdGVtLml0ZW1JRCA9IGxwaXRlbS0+d0lEOwogICAgICAgICAgICBtZWFzSXRlbS5pdGVtV2lkdGggPSBscGl0ZW0tPnJlY3QucmlnaHQgLSBscGl0ZW0tPnJlY3QubGVmdDsKICAgICAgICAgICAgbWVhc0l0ZW0uaXRlbUhlaWdodCA9IGxwaXRlbS0+cmVjdC5ib3R0b20gLSBscGl0ZW0tPnJlY3QudG9wOwogICAgICAgICAgICBtZWFzSXRlbS5pdGVtRGF0YSA9IGxwaXRlbS0+ZHdJdGVtRGF0YTsKICAgICAgICAgICAgU2VuZE1lc3NhZ2VXKCBod25kT3duZXIsIFdNX01FQVNVUkVJVEVNLCBscGl0ZW0tPndJRCwgKExQQVJBTSkmbWVhc0l0ZW0pOwogICAgICAgICAgICBzaXplLT5jeCA9IG1lYXNJdGVtLml0ZW1XaWR0aDsKICAgICAgICAgICAgc2l6ZS0+Y3kgPSBtZWFzSXRlbS5pdGVtSGVpZ2h0OwogICAgICAgICAgICByZXR1cm47CiAgICAgICAgfQogICAgICAgIGJyZWFrOwogICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX1NZU1RFTToKICAgICAgICBpZiAobHBpdGVtLT5kd0l0ZW1EYXRhKQogICAgICAgIHsKICAgICAgICAgICAgYm1wID0gKEhCSVRNQVApbHBpdGVtLT5kd0l0ZW1EYXRhOwogICAgICAgICAgICBicmVhazsKICAgICAgICB9CiAgICAgICAgLyogZmFsbCB0aHJvdWdoICovCiAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfTUJBUl9SRVNUT1JFOgogICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX01CQVJfTUlOSU1JWkU6CiAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfTUJBUl9NSU5JTUlaRV9EOgogICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX01CQVJfQ0xPU0U6CiAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfTUJBUl9DTE9TRV9EOgogICAgICAgIHNpemUtPmN4ID0gR2V0U3lzdGVtTWV0cmljcyggU01fQ1lNRU5VICkgLSA0OwogICAgICAgIHNpemUtPmN5ID0gc2l6ZS0+Y3g7CiAgICAgICAgcmV0dXJuOwogICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX1BPUFVQX0NMT1NFOgogICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX1BPUFVQX1JFU1RPUkU6CiAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfUE9QVVBfTUFYSU1JWkU6CiAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfUE9QVVBfTUlOSU1JWkU6CiAgICAgICAgRklYTUUoIk1hZ2ljICVwIG5vdCBpbXBsZW1lbnRlZFxuIiwgYm1wICk7CiAgICAgICAgcmV0dXJuOwogICAgfQogICAgaWYgKEdldE9iamVjdFcoYm1wLCBzaXplb2YoYm0pLCAmYm0gKSkKICAgIHsKICAgICAgICBzaXplLT5jeCA9IGJtLmJtV2lkdGg7CiAgICAgICAgc2l6ZS0+Y3kgPSBibS5ibUhlaWdodDsKICAgIH0KfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0RyYXdCaXRtYXBJdGVtCiAqCiAqIERyYXcgYSBiaXRtYXAgaXRlbS4KICovCnN0YXRpYyB2b2lkIE1FTlVfRHJhd0JpdG1hcEl0ZW0oIEhEQyBoZGMsIE1FTlVJVEVNICpscGl0ZW0sIGNvbnN0IFJFQ1QgKnJlY3QsCiAgICAgICAgICAgICAgICAgICAgSE1FTlUgaG1lbnUsIEhXTkQgaHduZE93bmVyLCBVSU5UIG9kYWN0aW9uLCBCT09MIG1lbnVCYXIpCnsKICAgIEJJVE1BUCBibTsKICAgIERXT1JEIHJvcDsKICAgIEhEQyBoZGNNZW07CiAgICBIQklUTUFQIGJtcDsKICAgIGludCB3ID0gcmVjdC0+cmlnaHQgLSByZWN0LT5sZWZ0OwogICAgaW50IGggPSByZWN0LT5ib3R0b20gLSByZWN0LT50b3A7CiAgICBpbnQgYm1wX3hvZmZzZXQgPSAwOwogICAgaW50IGxlZnQsIHRvcDsKICAgIEhCSVRNQVAgaGJtVG9EcmF3ID0gbHBpdGVtLT5oYm1wSXRlbTsKICAgIGJtcCA9IGhibVRvRHJhdzsKCiAgICAvKiBDaGVjayBpZiB0aGVyZSBpcyBhIG1hZ2ljIG1lbnUgaXRlbSBhc3NvY2lhdGVkIHdpdGggdGhpcyBpdGVtICovCiAgICBpZiAoSVNfTUFHSUNfQklUTUFQKGhibVRvRHJhdykpCiAgICB7CiAgICAgICAgVUlOVCBmbGFncyA9IDA7CiAgICAgICAgUkVDVCByOwoKCXN3aXRjaCgoSU5UX1BUUiloYm1Ub0RyYXcpCiAgICAgICAgewogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9TWVNURU06CiAgICAgICAgICAgIGlmIChscGl0ZW0tPmR3SXRlbURhdGEpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIGJtcCA9IChIQklUTUFQKWxwaXRlbS0+ZHdJdGVtRGF0YTsKICAgICAgICAgICAgICAgIGlmICghR2V0T2JqZWN0VyggYm1wLCBzaXplb2YoYm0pLCAmYm0gKSkgcmV0dXJuOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgc3RhdGljIEhCSVRNQVAgaEJtcFN5c01lbnU7CgogICAgICAgICAgICAgICAgaWYgKCFoQm1wU3lzTWVudSkgaEJtcFN5c01lbnUgPSBMb2FkQml0bWFwVygwLCBNQUtFSU5UUkVTT1VSQ0VXKE9CTV9DTE9TRSkpOwogICAgICAgICAgICAgICAgYm1wID0gaEJtcFN5c01lbnU7CiAgICAgICAgICAgICAgICBpZiAoIUdldE9iamVjdFcoIGJtcCwgc2l6ZW9mKGJtKSwgJmJtICkpIHJldHVybjsKICAgICAgICAgICAgICAgIC8qIG9ubHkgdXNlIHJpZ2h0IGhhbGYgb2YgdGhlIGJpdG1hcCAqLwogICAgICAgICAgICAgICAgYm1wX3hvZmZzZXQgPSBibS5ibVdpZHRoIC8gMjsKICAgICAgICAgICAgICAgIGJtLmJtV2lkdGggLT0gYm1wX3hvZmZzZXQ7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgZ290byBnb3RfYml0bWFwOwogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9NQkFSX1JFU1RPUkU6CiAgICAgICAgICAgIGZsYWdzID0gREZDU19DQVBUSU9OUkVTVE9SRTsKICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX01CQVJfTUlOSU1JWkU6CiAgICAgICAgICAgIGZsYWdzID0gREZDU19DQVBUSU9OTUlOOwogICAgICAgICAgICBicmVhazsKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfTUJBUl9NSU5JTUlaRV9EOgogICAgICAgICAgICBmbGFncyA9IERGQ1NfQ0FQVElPTk1JTiB8IERGQ1NfSU5BQ1RJVkU7CiAgICAgICAgICAgIGJyZWFrOwogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9NQkFSX0NMT1NFOgogICAgICAgICAgICBmbGFncyA9IERGQ1NfQ0FQVElPTkNMT1NFOwogICAgICAgICAgICBicmVhazsKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfTUJBUl9DTE9TRV9EOgogICAgICAgICAgICBmbGFncyA9IERGQ1NfQ0FQVElPTkNMT1NFIHwgREZDU19JTkFDVElWRTsKICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX0NBTExCQUNLOgogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBEUkFXSVRFTVNUUlVDVCBkcmF3SXRlbTsKICAgICAgICAgICAgICAgIGRyYXdJdGVtLkN0bFR5cGUgPSBPRFRfTUVOVTsKICAgICAgICAgICAgICAgIGRyYXdJdGVtLkN0bElEID0gMDsKICAgICAgICAgICAgICAgIGRyYXdJdGVtLml0ZW1JRCA9IGxwaXRlbS0+d0lEOwogICAgICAgICAgICAgICAgZHJhd0l0ZW0uaXRlbUFjdGlvbiA9IG9kYWN0aW9uOwogICAgICAgICAgICAgICAgZHJhd0l0ZW0uaXRlbVN0YXRlID0gKGxwaXRlbS0+ZlN0YXRlICYgTUZfQ0hFQ0tFRCk/T0RTX0NIRUNLRUQ6MDsKICAgICAgICAgICAgICAgIGRyYXdJdGVtLml0ZW1TdGF0ZSB8PSAobHBpdGVtLT5mU3RhdGUgJiBNRl9ERUZBVUxUKT9PRFNfREVGQVVMVDowOwogICAgICAgICAgICAgICAgZHJhd0l0ZW0uaXRlbVN0YXRlIHw9IChscGl0ZW0tPmZTdGF0ZSAmIE1GX0RJU0FCTEVEKT9PRFNfRElTQUJMRUQ6MDsKICAgICAgICAgICAgICAgIGRyYXdJdGVtLml0ZW1TdGF0ZSB8PSAobHBpdGVtLT5mU3RhdGUgJiBNRl9HUkFZRUQpP09EU19HUkFZRUR8T0RTX0RJU0FCTEVEOjA7CiAgICAgICAgICAgICAgICBkcmF3SXRlbS5pdGVtU3RhdGUgfD0gKGxwaXRlbS0+ZlN0YXRlICYgTUZfSElMSVRFKT9PRFNfU0VMRUNURUQ6MDsKICAgICAgICAgICAgICAgIGRyYXdJdGVtLmh3bmRJdGVtID0gKEhXTkQpaG1lbnU7CiAgICAgICAgICAgICAgICBkcmF3SXRlbS5oREMgPSBoZGM7CiAgICAgICAgICAgICAgICBkcmF3SXRlbS5pdGVtRGF0YSA9IGxwaXRlbS0+ZHdJdGVtRGF0YTsKICAgICAgICAgICAgICAgIGRyYXdJdGVtLnJjSXRlbSA9ICpyZWN0OwogICAgICAgICAgICAgICAgU2VuZE1lc3NhZ2VXKCBod25kT3duZXIsIFdNX0RSQVdJVEVNLCAwLCAoTFBBUkFNKSZkcmF3SXRlbSk7CiAgICAgICAgICAgICAgICByZXR1cm47CiAgICAgICAgICAgIH0KICAgICAgICAgICAgYnJlYWs7CiAgICAgICAgY2FzZSAoSU5UX1BUUilIQk1NRU5VX1BPUFVQX0NMT1NFOgogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9QT1BVUF9SRVNUT1JFOgogICAgICAgIGNhc2UgKElOVF9QVFIpSEJNTUVOVV9QT1BVUF9NQVhJTUlaRToKICAgICAgICBjYXNlIChJTlRfUFRSKUhCTU1FTlVfUE9QVVBfTUlOSU1JWkU6CiAgICAgICAgZGVmYXVsdDoKICAgICAgICAgICAgRklYTUUoIk1hZ2ljICVwIG5vdCBpbXBsZW1lbnRlZFxuIiwgaGJtVG9EcmF3KTsKICAgICAgICAgICAgcmV0dXJuOwogICAgICAgIH0KICAgICAgICByID0gKnJlY3Q7CiAgICAgICAgSW5mbGF0ZVJlY3QoICZyLCAtMSwgLTEgKTsKICAgICAgICBpZiAobHBpdGVtLT5mU3RhdGUgJiBNRl9ISUxJVEUpIGZsYWdzIHw9IERGQ1NfUFVTSEVEOwogICAgICAgIERyYXdGcmFtZUNvbnRyb2woIGhkYywgJnIsIERGQ19DQVBUSU9OLCBmbGFncyApOwogICAgICAgIHJldHVybjsKICAgIH0KCiAgICBpZiAoIWJtcCB8fCAhR2V0T2JqZWN0VyggYm1wLCBzaXplb2YoYm0pLCAmYm0gKSkgcmV0dXJuOwoKIGdvdF9iaXRtYXA6CiAgICBoZGNNZW0gPSBDcmVhdGVDb21wYXRpYmxlREMoIGhkYyApOwogICAgU2VsZWN0T2JqZWN0KCBoZGNNZW0sIGJtcCApOwoKICAgIC8qIGhhbmRsZSBmb250c2l6ZSA+IGJpdG1hcF9oZWlnaHQgKi8KICAgIHRvcCA9IChoPmJtLmJtSGVpZ2h0KSA/IHJlY3QtPnRvcCsoaC1ibS5ibUhlaWdodCkvMiA6IHJlY3QtPnRvcDsKICAgIGxlZnQ9cmVjdC0+bGVmdDsKICAgIHJvcD0oKGxwaXRlbS0+ZlN0YXRlICYgTUZfSElMSVRFKSAmJiAhSVNfTUFHSUNfQklUTUFQKGhibVRvRHJhdykpID8gTk9UU1JDQ09QWSA6IFNSQ0NPUFk7CiAgICBpZiAoKGxwaXRlbS0+ZlN0YXRlICYgTUZfSElMSVRFKSAmJiBscGl0ZW0tPmhibXBJdGVtKQogICAgICAgIFNldEJrQ29sb3IoaGRjLCBHZXRTeXNDb2xvcihDT0xPUl9ISUdITElHSFQpKTsKICAgIEJpdEJsdCggaGRjLCBsZWZ0LCB0b3AsIHcsIGgsIGhkY01lbSwgYm1wX3hvZmZzZXQsIDAsIHJvcCApOwogICAgRGVsZXRlREMoIGhkY01lbSApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0NhbGNJdGVtU2l6ZQogKgogKiBDYWxjdWxhdGUgdGhlIHNpemUgb2YgdGhlIG1lbnUgaXRlbSBhbmQgc3RvcmUgaXQgaW4gbHBpdGVtLT5yZWN0LgogKi8Kc3RhdGljIHZvaWQgTUVOVV9DYWxjSXRlbVNpemUoIEhEQyBoZGMsIE1FTlVJVEVNICpscGl0ZW0sIEhXTkQgaHduZE93bmVyLAoJCQkgICAgICAgSU5UIG9yZ1gsIElOVCBvcmdZLCBCT09MIG1lbnVCYXIsIFBPUFVQTUVOVSogbHBwb3AgKQp7CiAgICBXQ0hBUiAqcDsKICAgIFVJTlQgY2hlY2tfYml0bWFwX3dpZHRoID0gR2V0U3lzdGVtTWV0cmljcyggU01fQ1hNRU5VQ0hFQ0sgKTsKICAgIFVJTlQgYXJyb3dfYml0bWFwX3dpZHRoOwogICAgQklUTUFQIGJtOwogICAgSU5UIGl0ZW1oZWlnaHQ7CgogICAgVFJBQ0UoImRjPSVwIG93bmVyPSVwICglZCwlZClcbiIsIGhkYywgaHduZE93bmVyLCBvcmdYLCBvcmdZKTsKICAgIGRlYnVnX3ByaW50X21lbnVpdGVtKCJNRU5VX0NhbGNJdGVtU2l6ZTogbWVudWl0ZW06IiwgbHBpdGVtLAoJCQkgKG1lbnVCYXIgPyAiIChNZW51QmFyKSIgOiAiIikpOwoKICAgIEdldE9iamVjdFcoIGdldF9hcnJvd19iaXRtYXAoKSwgc2l6ZW9mKGJtKSwgJmJtICk7CiAgICBhcnJvd19iaXRtYXBfd2lkdGggPSBibS5ibVdpZHRoOwoKICAgIC8qIG5vdCBkb25lIGluIE1lbnVfSW5pdDogR2V0RGlhbG9nQmFzZVVuaXRzKCkgYnJlYWtzIHRoZXJlICovCiAgICBpZiggIW1lbnVjaGFyc2l6ZS5jeCApIHsKICAgICAgICBtZW51Y2hhcnNpemUuY3ggPSBHZGlHZXRDaGFyRGltZW5zaW9ucyggaGRjLCBOVUxMLCAmbWVudWNoYXJzaXplLmN5ICk7CiAgICAgICAgLyogV2luOTUvOTgvTUUgd2lsbCB1c2UgbWVudWNoYXJzaXplLmN5IGhlcmUuIFRlc3RpbmcgaXMgcG9zc2libGUKICAgICAgICAgKiBidXQgaXQgaXMgdW5saWtlbHkgYW4gYXBwbGljYXRpb24gd2lsbCBkZXBlbmQgb24gdGhhdCAqLwogICAgICAgIE9EaXRlbWhlaWdodCA9IEhJV09SRCggR2V0RGlhbG9nQmFzZVVuaXRzKCkpOwogICAgfQoKICAgIFNldFJlY3QoICZscGl0ZW0tPnJlY3QsIG9yZ1gsIG9yZ1ksIG9yZ1gsIG9yZ1kgKTsKCiAgICBpZiAobHBpdGVtLT5mVHlwZSAmIE1GX09XTkVSRFJBVykKICAgIHsKICAgICAgICBNRUFTVVJFSVRFTVNUUlVDVCBtaXM7CiAgICAgICAgbWlzLkN0bFR5cGUgICAgPSBPRFRfTUVOVTsKICAgICAgICBtaXMuQ3RsSUQgICAgICA9IDA7CiAgICAgICAgbWlzLml0ZW1JRCAgICAgPSBscGl0ZW0tPndJRDsKICAgICAgICBtaXMuaXRlbURhdGEgICA9IGxwaXRlbS0+ZHdJdGVtRGF0YTsKICAgICAgICBtaXMuaXRlbUhlaWdodCA9IE9EaXRlbWhlaWdodDsKICAgICAgICBtaXMuaXRlbVdpZHRoICA9IDA7CiAgICAgICAgU2VuZE1lc3NhZ2VXKCBod25kT3duZXIsIFdNX01FQVNVUkVJVEVNLCAwLCAoTFBBUkFNKSZtaXMgKTsKICAgICAgICAvKiBUZXN0cyByZXZlYWwgdGhhdCBXaW5kb3dzICggV2luOTUgdGhydSBXaW5YUCkgYWRkcyB0d2ljZSB0aGUgYXZlcmFnZQogICAgICAgICAqIHdpZHRoIG9mIGEgbWVudWZvbnQgY2hhcmFjdGVyIHRvIHRoZSB3aWR0aCBvZiBhbiBvd25lci1kcmF3biBtZW51LiAKICAgICAgICAgKi8KICAgICAgICBscGl0ZW0tPnJlY3QucmlnaHQgKz0gbWlzLml0ZW1XaWR0aCArIDIgKiBtZW51Y2hhcnNpemUuY3g7CiAgICAgICAgaWYgKG1lbnVCYXIpIHsKICAgICAgICAgICAgLyogdW5kZXIgYXQgbGVhc3Qgd2luOTUgeW91IHNlZW0gdG8gYmUgZ2l2ZW4gYSBzdGFuZGFyZAogICAgICAgICAgICAgICBoZWlnaHQgZm9yIHRoZSBtZW51IGFuZCB0aGUgaGVpZ2h0IHZhbHVlIGlzIGlnbm9yZWQgKi8KICAgICAgICAgICAgbHBpdGVtLT5yZWN0LmJvdHRvbSArPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZTUVOVVNJWkUpOwogICAgICAgIH0gZWxzZQogICAgICAgICAgICBscGl0ZW0tPnJlY3QuYm90dG9tICs9IG1pcy5pdGVtSGVpZ2h0OwoKICAgICAgICBUUkFDRSgiaWQ9JTA0bHggc2l6ZT0lZHglZFxuIiwKICAgICAgICAgICAgICAgIGxwaXRlbS0+d0lELCBscGl0ZW0tPnJlY3QucmlnaHQtbHBpdGVtLT5yZWN0LmxlZnQsCiAgICAgICAgICAgICAgICBscGl0ZW0tPnJlY3QuYm90dG9tLWxwaXRlbS0+cmVjdC50b3ApOwogICAgICAgIHJldHVybjsKICAgIH0KCiAgICBpZiAobHBpdGVtLT5mVHlwZSAmIE1GX1NFUEFSQVRPUikKICAgIHsKICAgICAgICBscGl0ZW0tPnJlY3QuYm90dG9tICs9IEdldFN5c3RlbU1ldHJpY3MoIFNNX0NZTUVOVVNJWkUpLzI7CiAgICAgICAgaWYoICFtZW51QmFyKQogICAgICAgICAgICBscGl0ZW0tPnJlY3QucmlnaHQgKz0gYXJyb3dfYml0bWFwX3dpZHRoICsgbWVudWNoYXJzaXplLmN4OwogICAgICAgIHJldHVybjsKICAgIH0KCiAgICBpdGVtaGVpZ2h0ID0gMDsKICAgIGxwaXRlbS0+eFRhYiA9IDA7CgogICAgaWYgKCFtZW51QmFyKSB7CiAgICAgICAgaWYgKGxwaXRlbS0+aGJtcEl0ZW0pIHsKICAgICAgICAgICAgU0laRSBzaXplOwoKICAgICAgICAgICAgTUVOVV9HZXRCaXRtYXBJdGVtU2l6ZShscGl0ZW0sICZzaXplLCBod25kT3duZXIpOwogICAgICAgICAgICAvKiBLZWVwIHRoZSBzaXplIG9mIHRoZSBiaXRtYXAgaW4gY2FsbGJhY2sgbW9kZSB0byBiZSBhYmxlCiAgICAgICAgICAgICAqIHRvIGRyYXcgaXQgY29ycmVjdGx5ICovCiAgICAgICAgICAgIGxwaXRlbS0+Ym1wc2l6ZSA9IHNpemU7CiAgICAgICAgICAgIGxwcG9wLT5tYXhCbXBTaXplLmN4ID0gbWF4KCBscHBvcC0+bWF4Qm1wU2l6ZS5jeCwgc2l6ZS5jeCk7CiAgICAgICAgICAgIGxwcG9wLT5tYXhCbXBTaXplLmN5ID0gbWF4KCBscHBvcC0+bWF4Qm1wU2l6ZS5jeSwgc2l6ZS5jeSk7CiAgICAgICAgICAgIGxwaXRlbS0+cmVjdC5yaWdodCArPSBzaXplLmN4ICsgMjsKICAgICAgICAgICAgaXRlbWhlaWdodCA9IHNpemUuY3kgKyAyOwogICAgICAgIH0KICAgICAgICBpZiggIShscHBvcC0+ZHdTdHlsZSAmIE1OU19OT0NIRUNLKSkKICAgICAgICAgICAgbHBpdGVtLT5yZWN0LnJpZ2h0ICs9IGNoZWNrX2JpdG1hcF93aWR0aDsgCiAgICAgICAgbHBpdGVtLT5yZWN0LnJpZ2h0ICs9IDQgKyBtZW51Y2hhcnNpemUuY3g7CiAgICAgICAgbHBpdGVtLT54VGFiID0gbHBpdGVtLT5yZWN0LnJpZ2h0OwogICAgICAgIGxwaXRlbS0+cmVjdC5yaWdodCArPSBhcnJvd19iaXRtYXBfd2lkdGg7CiAgICB9IGVsc2UgaWYgKGxwaXRlbS0+aGJtcEl0ZW0pIHsgLyogbWVudUJhciAqLwogICAgICAgIFNJWkUgc2l6ZTsKCiAgICAgICAgTUVOVV9HZXRCaXRtYXBJdGVtU2l6ZSggbHBpdGVtLCAmc2l6ZSwgaHduZE93bmVyICk7CiAgICAgICAgbHBpdGVtLT5ibXBzaXplID0gc2l6ZTsKICAgICAgICBscGl0ZW0tPnJlY3QucmlnaHQgICs9IHNpemUuY3g7CiAgICAgICAgaWYoIGxwaXRlbS0+dGV4dCkgbHBpdGVtLT5yZWN0LnJpZ2h0ICArPSAyOwogICAgICAgIGl0ZW1oZWlnaHQgPSBzaXplLmN5OwogICAgfQoKICAgIC8qIGl0IG11c3QgYmUgYSB0ZXh0IGl0ZW0gLSB1bmxlc3MgaXQncyB0aGUgc3lzdGVtIG1lbnUgKi8KICAgIGlmICghKGxwaXRlbS0+ZlR5cGUgJiBNRl9TWVNNRU5VKSAmJiBscGl0ZW0tPnRleHQpIHsKICAgICAgICBIRk9OVCBoZm9udE9sZCA9IE5VTEw7CiAgICAgICAgUkVDVCByYyA9IGxwaXRlbS0+cmVjdDsKICAgICAgICBMT05HIHR4dGhlaWdodCwgdHh0d2lkdGg7CgoJaWYgKCBscGl0ZW0tPmZTdGF0ZSAmIE1GU19ERUZBVUxUICkgewoJICAgICBoZm9udE9sZCA9IFNlbGVjdE9iamVjdCggaGRjLCBnZXRfbWVudV9mb250KFRSVUUpICk7Cgl9CiAgICAgICAgaWYgKG1lbnVCYXIpIHsKICAgICAgICAgICAgdHh0aGVpZ2h0ID0gRHJhd1RleHRXKCBoZGMsIGxwaXRlbS0+dGV4dCwgLTEsICZyYywKICAgICAgICAgICAgICAgICAgICBEVF9TSU5HTEVMSU5FfERUX0NBTENSRUNUKTsgCiAgICAgICAgICAgIGxwaXRlbS0+cmVjdC5yaWdodCAgKz0gcmMucmlnaHQgLSByYy5sZWZ0OwogICAgICAgICAgICBpdGVtaGVpZ2h0ID0gbWF4KCBtYXgoIGl0ZW1oZWlnaHQsIHR4dGhlaWdodCksCiAgICAgICAgICAgICAgICAgICAgR2V0U3lzdGVtTWV0cmljcyggU01fQ1lNRU5VKSAtIDEpOwogICAgICAgICAgICBscGl0ZW0tPnJlY3QucmlnaHQgKz0gIDIgKiBtZW51Y2hhcnNpemUuY3g7CiAgICAgICAgfSBlbHNlIHsKICAgICAgICAgICAgaWYgKChwID0gc3RyY2hyVyggbHBpdGVtLT50ZXh0LCAnXHQnICkpICE9IE5VTEwpIHsKICAgICAgICAgICAgICAgIFJFQ1QgdG1wcmMgPSByYzsKICAgICAgICAgICAgICAgIExPTkcgdG1waGVpZ2h0OwogICAgICAgICAgICAgICAgaW50IG4gPSAoaW50KSggcCAtIGxwaXRlbS0+dGV4dCk7CiAgICAgICAgICAgICAgICAvKiBJdGVtIGNvbnRhaW5zIGEgdGFiIChvbmx5IG1lYW5pbmdmdWwgaW4gcG9wdXAgbWVudXMpICovCiAgICAgICAgICAgICAgICAvKiBnZXQgdGV4dCBzaXplIGJlZm9yZSB0aGUgdGFiICovCiAgICAgICAgICAgICAgICB0eHRoZWlnaHQgPSBEcmF3VGV4dFcoIGhkYywgbHBpdGVtLT50ZXh0LCBuLCAmcmMsCiAgICAgICAgICAgICAgICAgICAgICAgIERUX1NJTkdMRUxJTkV8RFRfQ0FMQ1JFQ1QpOwogICAgICAgICAgICAgICAgdHh0d2lkdGggPSByYy5yaWdodCAtIHJjLmxlZnQ7CiAgICAgICAgICAgICAgICBwICs9IDE7IC8qIGFkdmFuY2UgcGFzdCB0aGUgVGFiICovCiAgICAgICAgICAgICAgICAvKiBnZXQgdGV4dCBzaXplIGFmdGVyIHRoZSB0YWIgKi8KICAgICAgICAgICAgICAgIHRtcGhlaWdodCA9IERyYXdUZXh0VyggaGRjLCBwLCAtMSwgJnRtcHJjLAogICAgICAgICAgICAgICAgICAgICAgICBEVF9TSU5HTEVMSU5FfERUX0NBTENSRUNUKTsKICAgICAgICAgICAgICAgIGxwaXRlbS0+eFRhYiArPSB0eHR3aWR0aDsKICAgICAgICAgICAgICAgIHR4dGhlaWdodCA9IG1heCggdHh0aGVpZ2h0LCB0bXBoZWlnaHQpOwogICAgICAgICAgICAgICAgdHh0d2lkdGggKz0gbWVudWNoYXJzaXplLmN4ICsgLyogc3BhY2UgZm9yIHRoZSB0YWIgKi8KICAgICAgICAgICAgICAgICAgICB0bXByYy5yaWdodCAtIHRtcHJjLmxlZnQ7IC8qIHNwYWNlIGZvciB0aGUgc2hvcnQgY3V0ICovCiAgICAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgICAgICB0eHRoZWlnaHQgPSBEcmF3VGV4dFcoIGhkYywgbHBpdGVtLT50ZXh0LCAtMSwgJnJjLAogICAgICAgICAgICAgICAgICAgICAgICBEVF9TSU5HTEVMSU5FfERUX0NBTENSRUNUKTsKICAgICAgICAgICAgICAgIHR4dHdpZHRoID0gcmMucmlnaHQgLSByYy5sZWZ0OwogICAgICAgICAgICAgICAgbHBpdGVtLT54VGFiICs9IHR4dHdpZHRoOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGxwaXRlbS0+cmVjdC5yaWdodCAgKz0gMiArIHR4dHdpZHRoOwogICAgICAgICAgICBpdGVtaGVpZ2h0ID0gbWF4KCBpdGVtaGVpZ2h0LAogICAgICAgICAgICAgICAgICAgIG1heCggdHh0aGVpZ2h0ICsgMiwgbWVudWNoYXJzaXplLmN5ICsgNCkpOwogICAgICAgIH0KCWlmIChoZm9udE9sZCkgU2VsZWN0T2JqZWN0IChoZGMsIGhmb250T2xkKTsKICAgIH0gZWxzZSBpZiggbWVudUJhcikgewogICAgICAgIGl0ZW1oZWlnaHQgPSBtYXgoIGl0ZW1oZWlnaHQsIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lNRU5VKS0xKTsKICAgIH0KICAgIGxwaXRlbS0+cmVjdC5ib3R0b20gKz0gaXRlbWhlaWdodDsKICAgIFRSQUNFKCIlc1xuIiwgd2luZV9kYmdzdHJfcmVjdCggJmxwaXRlbS0+cmVjdCkpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0dldE1heFBvcHVwSGVpZ2h0CiAqLwpzdGF0aWMgVUlOVApNRU5VX0dldE1heFBvcHVwSGVpZ2h0KGNvbnN0IFBPUFVQTUVOVSAqbHBwb3ApCnsKICAgIGlmIChscHBvcC0+Y3lNYXgpCiAgICAgICAgcmV0dXJuIGxwcG9wLT5jeU1heDsKICAgIHJldHVybiBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZU0NSRUVOKSAtIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lCT1JERVIpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX1BvcHVwTWVudUNhbGNTaXplCiAqCiAqIENhbGN1bGF0ZSB0aGUgc2l6ZSBvZiBhIHBvcHVwIG1lbnUuCiAqLwpzdGF0aWMgdm9pZCBNRU5VX1BvcHVwTWVudUNhbGNTaXplKCBMUFBPUFVQTUVOVSBscHBvcCApCnsKICAgIE1FTlVJVEVNICpscGl0ZW07CiAgICBIREMgaGRjOwogICAgaW50IHN0YXJ0LCBpOwogICAgaW50IG9yZ1gsIG9yZ1ksIG1heFgsIG1heFRhYiwgbWF4VGFiV2lkdGgsIG1heEhlaWdodDsKCiAgICBscHBvcC0+V2lkdGggPSBscHBvcC0+SGVpZ2h0ID0gMDsKICAgIGlmIChscHBvcC0+bkl0ZW1zID09IDApIHJldHVybjsKICAgIGhkYyA9IEdldERDKCAwICk7CgogICAgU2VsZWN0T2JqZWN0KCBoZGMsIGdldF9tZW51X2ZvbnQoRkFMU0UpKTsKCiAgICBzdGFydCA9IDA7CiAgICBtYXhYID0gMiArIDE7CgogICAgbHBwb3AtPm1heEJtcFNpemUuY3ggPSAwOwogICAgbHBwb3AtPm1heEJtcFNpemUuY3kgPSAwOwoKICAgIHdoaWxlIChzdGFydCA8IGxwcG9wLT5uSXRlbXMpCiAgICB7CglscGl0ZW0gPSAmbHBwb3AtPml0ZW1zW3N0YXJ0XTsKCW9yZ1ggPSBtYXhYOwogICAgICAgIGlmKCBscGl0ZW0tPmZUeXBlICYgKE1GX01FTlVCUkVBSyB8IE1GX01FTlVCQVJCUkVBSykpCiAgICAgICAgICAgIG9yZ1ggKz0gTUVOVV9DT0xfU1BBQ0U7IAoJb3JnWSA9IE1FTlVfVE9QX01BUkdJTjsKCgltYXhUYWIgPSBtYXhUYWJXaWR0aCA9IDA7CgkgIC8qIFBhcnNlIGl0ZW1zIHVudGlsIGNvbHVtbiBicmVhayBvciBlbmQgb2YgbWVudSAqLwoJZm9yIChpID0gc3RhcnQ7IGkgPCBscHBvcC0+bkl0ZW1zOyBpKyssIGxwaXRlbSsrKQoJewoJICAgIGlmICgoaSAhPSBzdGFydCkgJiYKCQkobHBpdGVtLT5mVHlwZSAmIChNRl9NRU5VQlJFQUsgfCBNRl9NRU5VQkFSQlJFQUspKSkgYnJlYWs7CgoJICAgIE1FTlVfQ2FsY0l0ZW1TaXplKCBoZGMsIGxwaXRlbSwgbHBwb3AtPmh3bmRPd25lciwgb3JnWCwgb3JnWSwgRkFMU0UsIGxwcG9wICk7CgkgICAgbWF4WCA9IG1heCggbWF4WCwgbHBpdGVtLT5yZWN0LnJpZ2h0ICk7CgkgICAgb3JnWSA9IGxwaXRlbS0+cmVjdC5ib3R0b207CgkgICAgaWYgKElTX1NUUklOR19JVEVNKGxwaXRlbS0+ZlR5cGUpICYmIGxwaXRlbS0+eFRhYikKCSAgICB7CgkJbWF4VGFiID0gbWF4KCBtYXhUYWIsIGxwaXRlbS0+eFRhYiApOwoJCW1heFRhYldpZHRoID0gbWF4KG1heFRhYldpZHRoLGxwaXRlbS0+cmVjdC5yaWdodC1scGl0ZW0tPnhUYWIpOwoJICAgIH0KCX0KCgkgIC8qIEZpbmlzaCB0aGUgY29sdW1uIChzZXQgYWxsIGl0ZW1zIHRvIHRoZSBsYXJnZXN0IHdpZHRoIGZvdW5kKSAqLwoJbWF4WCA9IG1heCggbWF4WCwgbWF4VGFiICsgbWF4VGFiV2lkdGggKTsKCWZvciAobHBpdGVtID0gJmxwcG9wLT5pdGVtc1tzdGFydF07IHN0YXJ0IDwgaTsgc3RhcnQrKywgbHBpdGVtKyspCgl7CgkgICAgbHBpdGVtLT5yZWN0LnJpZ2h0ID0gbWF4WDsKCSAgICBpZiAoSVNfU1RSSU5HX0lURU0obHBpdGVtLT5mVHlwZSkgJiYgbHBpdGVtLT54VGFiKQoJCWxwaXRlbS0+eFRhYiA9IG1heFRhYjsKCgl9CglscHBvcC0+SGVpZ2h0ID0gbWF4KCBscHBvcC0+SGVpZ2h0LCBvcmdZICk7CiAgICB9CgogICAgbHBwb3AtPldpZHRoICA9IG1heFg7CgogICAgLyogc3BhY2UgZm9yIDNkIGJvcmRlciAqLwogICAgbHBwb3AtPkhlaWdodCArPSBNRU5VX0JPVFRPTV9NQVJHSU47CiAgICBscHBvcC0+V2lkdGggKz0gMjsKCiAgICAvKiBBZGp1c3QgcG9wdXAgaGVpZ2h0IGlmIGl0IGV4Y2VlZHMgbWF4aW11bSAqLwogICAgbWF4SGVpZ2h0ID0gTUVOVV9HZXRNYXhQb3B1cEhlaWdodChscHBvcCk7CiAgICBscHBvcC0+blRvdGFsSGVpZ2h0ID0gbHBwb3AtPkhlaWdodCAtIE1FTlVfVE9QX01BUkdJTjsKICAgIGlmIChscHBvcC0+SGVpZ2h0ID49IG1heEhlaWdodCkKICAgIHsKICAgICAgICBscHBvcC0+SGVpZ2h0ID0gbWF4SGVpZ2h0OwogICAgICAgIGxwcG9wLT5iU2Nyb2xsaW5nID0gVFJVRTsKICAgIH0KICAgIGVsc2UKICAgIHsKICAgICAgICBscHBvcC0+YlNjcm9sbGluZyA9IEZBTFNFOwogICAgfQoKICAgIFJlbGVhc2VEQyggMCwgaGRjICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfTWVudUJhckNhbGNTaXplCiAqCiAqIEZJWE1FOiBXb3JkIDYgaW1wbGVtZW50cyBpdHMgb3duIE1ESSBhbmQgaXRzIG93biAnY2xvc2Ugd2luZG93JyBiaXRtYXAKICogaGVpZ2h0IGlzIG9mZiBieSAxIHBpeGVsIHdoaWNoIGNhdXNlcyBsZW5ndGh5IHdpbmRvdyByZWxvY2F0aW9ucyB3aGVuCiAqIGFjdGl2ZSBkb2N1bWVudCB3aW5kb3cgaXMgbWF4aW1pemVkL3Jlc3RvcmVkLgogKgogKiBDYWxjdWxhdGUgdGhlIHNpemUgb2YgdGhlIG1lbnUgYmFyLgogKi8Kc3RhdGljIHZvaWQgTUVOVV9NZW51QmFyQ2FsY1NpemUoIEhEQyBoZGMsIExQUkVDVCBscHJlY3QsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBMUFBPUFVQTUVOVSBscHBvcCwgSFdORCBod25kT3duZXIgKQp7CiAgICBNRU5VSVRFTSAqbHBpdGVtOwogICAgaW50IHN0YXJ0LCBpLCBvcmdYLCBvcmdZLCBtYXhZLCBoZWxwUG9zOwoKICAgIGlmICgobHByZWN0ID09IE5VTEwpIHx8IChscHBvcCA9PSBOVUxMKSkgcmV0dXJuOwogICAgaWYgKGxwcG9wLT5uSXRlbXMgPT0gMCkgcmV0dXJuOwogICAgVFJBQ0UoImxwcmVjdCAlcCAlc1xuIiwgbHByZWN0LCB3aW5lX2RiZ3N0cl9yZWN0KCBscHJlY3QpKTsKICAgIGxwcG9wLT5XaWR0aCAgPSBscHJlY3QtPnJpZ2h0IC0gbHByZWN0LT5sZWZ0OwogICAgbHBwb3AtPkhlaWdodCA9IDA7CiAgICBtYXhZID0gbHByZWN0LT50b3ArMTsKICAgIHN0YXJ0ID0gMDsKICAgIGhlbHBQb3MgPSAtMTsKICAgIGxwcG9wLT5tYXhCbXBTaXplLmN4ID0gMDsKICAgIGxwcG9wLT5tYXhCbXBTaXplLmN5ID0gMDsKICAgIHdoaWxlIChzdGFydCA8IGxwcG9wLT5uSXRlbXMpCiAgICB7CglscGl0ZW0gPSAmbHBwb3AtPml0ZW1zW3N0YXJ0XTsKCW9yZ1ggPSBscHJlY3QtPmxlZnQ7CglvcmdZID0gbWF4WTsKCgkgIC8qIFBhcnNlIGl0ZW1zIHVudGlsIGxpbmUgYnJlYWsgb3IgZW5kIG9mIG1lbnUgKi8KCWZvciAoaSA9IHN0YXJ0OyBpIDwgbHBwb3AtPm5JdGVtczsgaSsrLCBscGl0ZW0rKykKCXsKCSAgICBpZiAoKGhlbHBQb3MgPT0gLTEpICYmIChscGl0ZW0tPmZUeXBlICYgTUZfUklHSFRKVVNUSUZZKSkgaGVscFBvcyA9IGk7CgkgICAgaWYgKChpICE9IHN0YXJ0KSAmJgoJCShscGl0ZW0tPmZUeXBlICYgKE1GX01FTlVCUkVBSyB8IE1GX01FTlVCQVJCUkVBSykpKSBicmVhazsKCgkgICAgVFJBQ0UoImNhbGxpbmcgTUVOVV9DYWxjSXRlbVNpemUgb3JnPSglZCwgJWQpXG4iLCBvcmdYLCBvcmdZICk7CgkgICAgZGVidWdfcHJpbnRfbWVudWl0ZW0gKCIgIGl0ZW06ICIsIGxwaXRlbSwgIiIpOwoJICAgIE1FTlVfQ2FsY0l0ZW1TaXplKCBoZGMsIGxwaXRlbSwgaHduZE93bmVyLCBvcmdYLCBvcmdZLCBUUlVFLCBscHBvcCApOwoKCSAgICBpZiAobHBpdGVtLT5yZWN0LnJpZ2h0ID4gbHByZWN0LT5yaWdodCkKCSAgICB7CgkJaWYgKGkgIT0gc3RhcnQpIGJyZWFrOwoJCWVsc2UgbHBpdGVtLT5yZWN0LnJpZ2h0ID0gbHByZWN0LT5yaWdodDsKCSAgICB9CgkgICAgbWF4WSA9IG1heCggbWF4WSwgbHBpdGVtLT5yZWN0LmJvdHRvbSApOwoJICAgIG9yZ1ggPSBscGl0ZW0tPnJlY3QucmlnaHQ7Cgl9CgoJICAvKiBGaW5pc2ggdGhlIGxpbmUgKHNldCBhbGwgaXRlbXMgdG8gdGhlIGxhcmdlc3QgaGVpZ2h0IGZvdW5kKSAqLwoJd2hpbGUgKHN0YXJ0IDwgaSkgbHBwb3AtPml0ZW1zW3N0YXJ0KytdLnJlY3QuYm90dG9tID0gbWF4WTsKICAgIH0KCiAgICBscHJlY3QtPmJvdHRvbSA9IG1heFk7CiAgICBscHBvcC0+SGVpZ2h0ID0gbHByZWN0LT5ib3R0b20gLSBscHJlY3QtPnRvcDsKCiAgICAvKiBGbHVzaCByaWdodCBhbGwgaXRlbXMgYmV0d2VlbiB0aGUgTUZfUklHSFRKVVNUSUZZIGFuZCAqLwogICAgLyogdGhlIGxhc3QgaXRlbSAoaWYgc2V2ZXJhbCBsaW5lcywgb25seSBtb3ZlIHRoZSBsYXN0IGxpbmUpICovCiAgICBscGl0ZW0gPSAmbHBwb3AtPml0ZW1zW2xwcG9wLT5uSXRlbXMtMV07CiAgICBvcmdZID0gbHBpdGVtLT5yZWN0LnRvcDsKICAgIG9yZ1ggPSBscHJlY3QtPnJpZ2h0OwogICAgZm9yIChpID0gbHBwb3AtPm5JdGVtcyAtIDE7IGkgPj0gaGVscFBvczsgaS0tLCBscGl0ZW0tLSkgewogICAgICAgIGlmICggKGhlbHBQb3M9PS0xKSB8fCAoaGVscFBvcz5pKSApCiAgICAgICAgICAgIGJyZWFrOwkJCQkvKiBkb25lICovCiAgICAgICAgaWYgKGxwaXRlbS0+cmVjdC50b3AgIT0gb3JnWSkgYnJlYWs7CS8qIE90aGVyIGxpbmUgKi8KICAgICAgICBpZiAobHBpdGVtLT5yZWN0LnJpZ2h0ID49IG9yZ1gpIGJyZWFrOwkvKiBUb28gZmFyIHJpZ2h0IGFscmVhZHkgKi8KICAgICAgICBscGl0ZW0tPnJlY3QubGVmdCArPSBvcmdYIC0gbHBpdGVtLT5yZWN0LnJpZ2h0OwogICAgICAgIGxwaXRlbS0+cmVjdC5yaWdodCA9IG9yZ1g7CiAgICAgICAgb3JnWCA9IGxwaXRlbS0+cmVjdC5sZWZ0OwogICAgfQp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0RyYXdTY3JvbGxBcnJvd3MKICoKICogRHJhdyBzY3JvbGwgYXJyb3dzLgogKi8Kc3RhdGljIHZvaWQKTUVOVV9EcmF3U2Nyb2xsQXJyb3dzKGNvbnN0IFBPUFVQTUVOVSAqbHBwb3AsIEhEQyBoZGMpCnsKICAgIEhEQyBoZGNNZW0gPSBDcmVhdGVDb21wYXRpYmxlREMoaGRjKTsKICAgIEhCSVRNQVAgaE9yaWdCaXRtYXA7CiAgICBVSU5UIGFycm93X2JpdG1hcF93aWR0aCwgYXJyb3dfYml0bWFwX2hlaWdodDsKICAgIEJJVE1BUCBibXA7CiAgICBSRUNUIHJlY3Q7CgogICAgR2V0T2JqZWN0VyhnZXRfZG93bl9hcnJvd19iaXRtYXAoKSwgc2l6ZW9mKGJtcCksICZibXApOwogICAgYXJyb3dfYml0bWFwX3dpZHRoID0gYm1wLmJtV2lkdGg7CiAgICBhcnJvd19iaXRtYXBfaGVpZ2h0ID0gYm1wLmJtSGVpZ2h0OwoKICAgIAogICAgaWYgKGxwcG9wLT5uU2Nyb2xsUG9zKQogICAgICAgIGhPcmlnQml0bWFwID0gU2VsZWN0T2JqZWN0KGhkY01lbSwgZ2V0X3VwX2Fycm93X2JpdG1hcCgpKTsKICAgIGVsc2UKICAgICAgICBoT3JpZ0JpdG1hcCA9IFNlbGVjdE9iamVjdChoZGNNZW0sIGdldF91cF9hcnJvd19pbmFjdGl2ZV9iaXRtYXAoKSk7CiAgICByZWN0LmxlZnQgPSAwOwogICAgcmVjdC50b3AgPSAwOwogICAgcmVjdC5yaWdodCA9IGxwcG9wLT5XaWR0aDsKICAgIHJlY3QuYm90dG9tID0gYXJyb3dfYml0bWFwX2hlaWdodDsKICAgIEZpbGxSZWN0KGhkYywgJnJlY3QsIEdldFN5c0NvbG9yQnJ1c2goQ09MT1JfTUVOVSkpOwogICAgQml0Qmx0KGhkYywgKGxwcG9wLT5XaWR0aCAtIGFycm93X2JpdG1hcF93aWR0aCkgLyAyLCAwLAogICAgICAgICAgIGFycm93X2JpdG1hcF93aWR0aCwgYXJyb3dfYml0bWFwX2hlaWdodCwgaGRjTWVtLCAwLCAwLCBTUkNDT1BZKTsKICAgIHJlY3QudG9wID0gbHBwb3AtPkhlaWdodCAtIGFycm93X2JpdG1hcF9oZWlnaHQ7CiAgICByZWN0LmJvdHRvbSA9IGxwcG9wLT5IZWlnaHQ7CiAgICBGaWxsUmVjdChoZGMsICZyZWN0LCBHZXRTeXNDb2xvckJydXNoKENPTE9SX01FTlUpKTsKICAgIGlmIChscHBvcC0+blNjcm9sbFBvcyA8IGxwcG9wLT5uVG90YWxIZWlnaHQgLSAoTUVOVV9HZXRNYXhQb3B1cEhlaWdodChscHBvcCkgLSAyICogYXJyb3dfYml0bWFwX2hlaWdodCkpCiAgICAgICAgU2VsZWN0T2JqZWN0KGhkY01lbSwgZ2V0X2Rvd25fYXJyb3dfYml0bWFwKCkpOwogICAgZWxzZQogICAgICAgIFNlbGVjdE9iamVjdChoZGNNZW0sIGdldF9kb3duX2Fycm93X2luYWN0aXZlX2JpdG1hcCgpKTsKICAgIEJpdEJsdChoZGMsIChscHBvcC0+V2lkdGggLSBhcnJvd19iaXRtYXBfd2lkdGgpIC8gMiwKICAgICAgICAgICBscHBvcC0+SGVpZ2h0IC0gYXJyb3dfYml0bWFwX2hlaWdodCwKICAgICAgICAgICBhcnJvd19iaXRtYXBfd2lkdGgsIGFycm93X2JpdG1hcF9oZWlnaHQsIGhkY01lbSwgMCwgMCwgU1JDQ09QWSk7CiAgICBTZWxlY3RPYmplY3QoaGRjTWVtLCBoT3JpZ0JpdG1hcCk7CiAgICBEZWxldGVEQyhoZGNNZW0pOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBkcmF3X3BvcHVwX2Fycm93CiAqCiAqIERyYXdzIHRoZSBwb3B1cC1tZW51IGFycm93LgogKi8Kc3RhdGljIHZvaWQgZHJhd19wb3B1cF9hcnJvdyggSERDIGhkYywgUkVDVCByZWN0LCBVSU5UIGFycm93X2JpdG1hcF93aWR0aCwKICAgICAgICBVSU5UIGFycm93X2JpdG1hcF9oZWlnaHQpCnsKICAgIEhEQyBoZGNNZW0gPSBDcmVhdGVDb21wYXRpYmxlREMoIGhkYyApOwogICAgSEJJVE1BUCBoT3JpZ0JpdG1hcDsKCiAgICBoT3JpZ0JpdG1hcCA9IFNlbGVjdE9iamVjdCggaGRjTWVtLCBnZXRfYXJyb3dfYml0bWFwKCkgKTsKICAgIEJpdEJsdCggaGRjLCByZWN0LnJpZ2h0IC0gYXJyb3dfYml0bWFwX3dpZHRoIC0gMSwKICAgICAgICAgICAgKHJlY3QudG9wICsgcmVjdC5ib3R0b20gLSBhcnJvd19iaXRtYXBfaGVpZ2h0KSAvIDIsCiAgICAgICAgICAgIGFycm93X2JpdG1hcF93aWR0aCwgYXJyb3dfYml0bWFwX2hlaWdodCwKICAgICAgICAgICAgaGRjTWVtLCAwLCAwLCBTUkNDT1BZICk7CiAgICBTZWxlY3RPYmplY3QoIGhkY01lbSwgaE9yaWdCaXRtYXAgKTsKICAgIERlbGV0ZURDKCBoZGNNZW0gKTsKfQovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfRHJhd01lbnVJdGVtCiAqCiAqIERyYXcgYSBzaW5nbGUgbWVudSBpdGVtLgogKi8Kc3RhdGljIHZvaWQgTUVOVV9EcmF3TWVudUl0ZW0oIEhXTkQgaHduZCwgSE1FTlUgaG1lbnUsIEhXTkQgaHduZE93bmVyLCBIREMgaGRjLCBNRU5VSVRFTSAqbHBpdGVtLAoJCQkgICAgICAgVUlOVCBoZWlnaHQsIEJPT0wgbWVudUJhciwgVUlOVCBvZGFjdGlvbiApCnsKICAgIFJFQ1QgcmVjdDsKICAgIEJPT0wgZmxhdF9tZW51ID0gRkFMU0U7CiAgICBpbnQgYmtnbmQ7CiAgICBVSU5UIGFycm93X2JpdG1hcF93aWR0aCA9IDAsIGFycm93X2JpdG1hcF9oZWlnaHQgPSAwOwogICAgUE9QVVBNRU5VICptZW51ID0gTUVOVV9HZXRNZW51KGhtZW51KTsKICAgIFJFQ1QgYm1wcmM7CgogICAgZGVidWdfcHJpbnRfbWVudWl0ZW0oIk1FTlVfRHJhd01lbnVJdGVtOiAiLCBscGl0ZW0sICIiKTsKCiAgICBpZiAoIW1lbnVCYXIpIHsKICAgICAgICBCSVRNQVAgYm1wOwogICAgICAgIEdldE9iamVjdFcoIGdldF9hcnJvd19iaXRtYXAoKSwgc2l6ZW9mKGJtcCksICZibXAgKTsKICAgICAgICBhcnJvd19iaXRtYXBfd2lkdGggPSBibXAuYm1XaWR0aDsKICAgICAgICBhcnJvd19iaXRtYXBfaGVpZ2h0ID0gYm1wLmJtSGVpZ2h0OwogICAgfQoKICAgIGlmIChscGl0ZW0tPmZUeXBlICYgTUZfU1lTTUVOVSkKICAgIHsKCWlmKCAhSXNJY29uaWMoaHduZCkgKQoJICAgIE5DX0RyYXdTeXNCdXR0b24oIGh3bmQsIGhkYywgbHBpdGVtLT5mU3RhdGUgJiAoTUZfSElMSVRFIHwgTUZfTU9VU0VTRUxFQ1QpICk7CglyZXR1cm47CiAgICB9CgogICAgU3lzdGVtUGFyYW1ldGVyc0luZm9XIChTUElfR0VURkxBVE1FTlUsIDAsICZmbGF0X21lbnUsIDApOwogICAgYmtnbmQgPSAobWVudUJhciAmJiBmbGF0X21lbnUpID8gQ09MT1JfTUVOVUJBUiA6IENPTE9SX01FTlU7CiAgCiAgICAgIC8qIFNldHVwIGNvbG9ycyAqLwoKICAgIGlmIChscGl0ZW0tPmZTdGF0ZSAmIE1GX0hJTElURSkKICAgIHsKICAgICAgICBpZihtZW51QmFyICYmICFmbGF0X21lbnUpIHsKCSAgICBTZXRUZXh0Q29sb3IoaGRjLCBHZXRTeXNDb2xvcihDT0xPUl9NRU5VVEVYVCkpOwogICAgICAgICAgICBTZXRCa0NvbG9yKGhkYywgR2V0U3lzQ29sb3IoQ09MT1JfTUVOVSkpOwoJfSBlbHNlIHsKCSAgICBpZihscGl0ZW0tPmZTdGF0ZSAmIE1GX0dSQVlFRCkKCQlTZXRUZXh0Q29sb3IoaGRjLCBHZXRTeXNDb2xvcihDT0xPUl9HUkFZVEVYVCkpOwoJICAgIGVsc2UKCQlTZXRUZXh0Q29sb3IoaGRjLCBHZXRTeXNDb2xvcihDT0xPUl9ISUdITElHSFRURVhUKSk7CiAgICAgICAgICAgIFNldEJrQ29sb3IoaGRjLCBHZXRTeXNDb2xvcihDT0xPUl9ISUdITElHSFQpKTsKCX0KICAgIH0KICAgIGVsc2UKICAgIHsKCWlmIChscGl0ZW0tPmZTdGF0ZSAmIE1GX0dSQVlFRCkKCSAgICBTZXRUZXh0Q29sb3IoIGhkYywgR2V0U3lzQ29sb3IoIENPTE9SX0dSQVlURVhUICkgKTsKCWVsc2UKCSAgICBTZXRUZXh0Q29sb3IoIGhkYywgR2V0U3lzQ29sb3IoIENPTE9SX01FTlVURVhUICkgKTsKCVNldEJrQ29sb3IoIGhkYywgR2V0U3lzQ29sb3IoIGJrZ25kICkgKTsKICAgIH0KCiAgICBUUkFDRSgicmVjdD0lc1xuIiwgd2luZV9kYmdzdHJfcmVjdCggJmxwaXRlbS0+cmVjdCkpOwogICAgcmVjdCA9IGxwaXRlbS0+cmVjdDsKICAgIE1FTlVfQWRqdXN0TWVudUl0ZW1SZWN0KE1FTlVfR2V0TWVudShobWVudSksICZyZWN0KTsKCiAgICBpZiAobHBpdGVtLT5mVHlwZSAmIE1GX09XTkVSRFJBVykKICAgIHsKICAgICAgICAvKgogICAgICAgICoqIEV4cGVyaW1lbnRhdGlvbiB1bmRlciBXaW5kb3dzIHJldmVhbHMgdGhhdCBhbiBvd25lci1kcmF3bgogICAgICAgICoqIG1lbnUgaXMgZ2l2ZW4gdGhlIHJlY3RhbmdsZSB3aGljaCBpbmNsdWRlcyB0aGUgc3BhY2UgaXQgcmVxdWVzdGVkCiAgICAgICAgKiogaW4gaXRzIHJlc3BvbnNlIHRvIFdNX01FQVNVUkVJVEVNIF9wbHVzXyB3aWR0aCBmb3IgYSBjaGVja21hcmsKICAgICAgICAqKiBhbmQgYSBwb3B1cC1tZW51IGFycm93LiAgVGhpcyBpcyB0aGUgdmFsdWUgb2YgbHBpdGVtLT5yZWN0LgogICAgICAgICoqIFdpbmRvd3Mgd2lsbCBsZWF2ZSBhbGwgZHJhd2luZyB0byB0aGUgYXBwbGljYXRpb24gZXhjZXB0IGZvcgogICAgICAgICoqIHRoZSBwb3B1cC1tZW51IGFycm93LiAgV2luZG93cyBhbHdheXMgZHJhd3MgdGhhdCBpdHNlbGYsIGFmdGVyCiAgICAgICAgKiogdGhlIG1lbnUgb3duZXIgaGFzIGZpbmlzaGVkIGRyYXdpbmcuCiAgICAgICAgKi8KICAgICAgICBEUkFXSVRFTVNUUlVDVCBkaXM7CgogICAgICAgIGRpcy5DdGxUeXBlICAgPSBPRFRfTUVOVTsKCWRpcy5DdGxJRCAgICAgPSAwOwogICAgICAgIGRpcy5pdGVtSUQgICAgPSBscGl0ZW0tPndJRDsKICAgICAgICBkaXMuaXRlbURhdGEgID0gbHBpdGVtLT5kd0l0ZW1EYXRhOwogICAgICAgIGRpcy5pdGVtU3RhdGUgPSAwOwogICAgICAgIGlmIChscGl0ZW0tPmZTdGF0ZSAmIE1GX0NIRUNLRUQpIGRpcy5pdGVtU3RhdGUgfD0gT0RTX0NIRUNLRUQ7CiAgICAgICAgaWYgKGxwaXRlbS0+ZlN0YXRlICYgTUZfR1JBWUVEKSAgZGlzLml0ZW1TdGF0ZSB8PSBPRFNfR1JBWUVEfE9EU19ESVNBQkxFRDsKICAgICAgICBpZiAobHBpdGVtLT5mU3RhdGUgJiBNRl9ISUxJVEUpICBkaXMuaXRlbVN0YXRlIHw9IE9EU19TRUxFQ1RFRDsKICAgICAgICBkaXMuaXRlbUFjdGlvbiA9IG9kYWN0aW9uOyAvKiBPREFfRFJBV0VOVElSRSB8IE9EQV9TRUxFQ1QgfCBPREFfRk9DVVM7ICovCiAgICAgICAgZGlzLmh3bmRJdGVtICAgPSAoSFdORClobWVudTsKICAgICAgICBkaXMuaERDICAgICAgICA9IGhkYzsKICAgICAgICBkaXMucmNJdGVtICAgICA9IHJlY3Q7CiAgICAgICAgVFJBQ0UoIk93bmVyZHJhdzogb3duZXI9JXAgaXRlbUlEPSVkLCBpdGVtU3RhdGU9JWQsIGl0ZW1BY3Rpb249JWQsICIKCSAgICAgICJod25kSXRlbT0lcCwgaGRjPSVwLCByY0l0ZW09JXNcbiIsIGh3bmRPd25lciwKCSAgICAgIGRpcy5pdGVtSUQsIGRpcy5pdGVtU3RhdGUsIGRpcy5pdGVtQWN0aW9uLCBkaXMuaHduZEl0ZW0sCgkgICAgICBkaXMuaERDLCB3aW5lX2RiZ3N0cl9yZWN0KCAmZGlzLnJjSXRlbSkpOwogICAgICAgIFNlbmRNZXNzYWdlVyggaHduZE93bmVyLCBXTV9EUkFXSVRFTSwgMCwgKExQQVJBTSkmZGlzICk7CiAgICAgICAgLyogRHJhdyB0aGUgcG9wdXAtbWVudSBhcnJvdyAqLwogICAgICAgIGlmIChscGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApCiAgICAgICAgICAgIGRyYXdfcG9wdXBfYXJyb3coIGhkYywgcmVjdCwgYXJyb3dfYml0bWFwX3dpZHRoLAogICAgICAgICAgICAgICAgICAgIGFycm93X2JpdG1hcF9oZWlnaHQpOwogICAgICAgIHJldHVybjsKICAgIH0KCiAgICBpZiAobWVudUJhciAmJiAobHBpdGVtLT5mVHlwZSAmIE1GX1NFUEFSQVRPUikpIHJldHVybjsKCiAgICBpZiAobHBpdGVtLT5mU3RhdGUgJiBNRl9ISUxJVEUpCiAgICB7CiAgICAgICAgaWYgKGZsYXRfbWVudSkKICAgICAgICB7CiAgICAgICAgICAgIEluZmxhdGVSZWN0ICgmcmVjdCwgLTEsIC0xKTsKICAgICAgICAgICAgRmlsbFJlY3QoaGRjLCAmcmVjdCwgR2V0U3lzQ29sb3JCcnVzaChDT0xPUl9NRU5VSElMSUdIVCkpOwogICAgICAgICAgICBJbmZsYXRlUmVjdCAoJnJlY3QsIDEsIDEpOwogICAgICAgICAgICBGcmFtZVJlY3QoaGRjLCAmcmVjdCwgR2V0U3lzQ29sb3JCcnVzaChDT0xPUl9ISUdITElHSFQpKTsKICAgICAgICB9CiAgICAgICAgZWxzZQogICAgICAgIHsKICAgICAgICAgICAgaWYobWVudUJhcikKICAgICAgICAgICAgICAgIERyYXdFZGdlKGhkYywgJnJlY3QsIEJEUl9TVU5LRU5PVVRFUiwgQkZfUkVDVCk7CiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgIEZpbGxSZWN0KGhkYywgJnJlY3QsIEdldFN5c0NvbG9yQnJ1c2goQ09MT1JfSElHSExJR0hUKSk7CiAgICAgICAgfQogICAgfQogICAgZWxzZQogICAgICAgIEZpbGxSZWN0KCBoZGMsICZyZWN0LCBHZXRTeXNDb2xvckJydXNoKGJrZ25kKSApOwoKICAgIFNldEJrTW9kZSggaGRjLCBUUkFOU1BBUkVOVCApOwoKICAgIC8qIHZlcnRpY2FsIHNlcGFyYXRvciAqLwogICAgaWYgKCFtZW51QmFyICYmIChscGl0ZW0tPmZUeXBlICYgTUZfTUVOVUJBUkJSRUFLKSkKICAgIHsKICAgICAgICBIUEVOIG9sZFBlbjsKICAgICAgICBSRUNUIHJjID0gcmVjdDsKCiAgICAgICAgcmMubGVmdCAtPSBNRU5VX0NPTF9TUEFDRSAvIDIgKyAxOwogICAgICAgIHJjLnRvcCA9IDM7CiAgICAgICAgcmMuYm90dG9tID0gaGVpZ2h0IC0gMzsKICAgICAgICBpZiAoZmxhdF9tZW51KQogICAgICAgIHsKICAgICAgICAgICAgb2xkUGVuID0gU2VsZWN0T2JqZWN0KCBoZGMsIFNZU0NPTE9SX0dldFBlbihDT0xPUl9CVE5TSEFET1cpICk7CiAgICAgICAgICAgIE1vdmVUb0V4KCBoZGMsIHJjLmxlZnQsIHJjLnRvcCwgTlVMTCApOwogICAgICAgICAgICBMaW5lVG8oIGhkYywgcmMubGVmdCwgcmMuYm90dG9tICk7CiAgICAgICAgICAgIFNlbGVjdE9iamVjdCggaGRjLCBvbGRQZW4gKTsKICAgICAgICB9CiAgICAgICAgZWxzZQogICAgICAgICAgICBEcmF3RWRnZSAoaGRjLCAmcmMsIEVER0VfRVRDSEVELCBCRl9MRUZUKTsKICAgIH0KCiAgICAvKiBob3Jpem9udGFsIHNlcGFyYXRvciAqLwogICAgaWYgKGxwaXRlbS0+ZlR5cGUgJiBNRl9TRVBBUkFUT1IpCiAgICB7CiAgICAgICAgSFBFTiBvbGRQZW47CiAgICAgICAgUkVDVCByYyA9IHJlY3Q7CgogICAgICAgIHJjLmxlZnQrKzsKICAgICAgICByYy5yaWdodC0tOwogICAgICAgIHJjLnRvcCA9ICggcmMudG9wICsgcmMuYm90dG9tKSAvIDI7CiAgICAgICAgaWYgKGZsYXRfbWVudSkKICAgICAgICB7CiAgICAgICAgICAgIG9sZFBlbiA9IFNlbGVjdE9iamVjdCggaGRjLCBTWVNDT0xPUl9HZXRQZW4oQ09MT1JfQlROU0hBRE9XKSApOwogICAgICAgICAgICBNb3ZlVG9FeCggaGRjLCByYy5sZWZ0LCByYy50b3AsIE5VTEwgKTsKICAgICAgICAgICAgTGluZVRvKCBoZGMsIHJjLnJpZ2h0LCByYy50b3AgKTsKICAgICAgICAgICAgU2VsZWN0T2JqZWN0KCBoZGMsIG9sZFBlbiApOwogICAgICAgIH0KICAgICAgICBlbHNlCiAgICAgICAgICAgIERyYXdFZGdlIChoZGMsICZyYywgRURHRV9FVENIRUQsIEJGX1RPUCk7CiAgICAgICAgcmV0dXJuOwogICAgfQoKCS8qIGhlbHBlciBsaW5lcyBmb3IgZGVidWdnaW5nICovCi8qCUZyYW1lUmVjdChoZGMsICZyZWN0LCBHZXRTdG9ja09iamVjdChCTEFDS19CUlVTSCkpOwoJU2VsZWN0T2JqZWN0KCBoZGMsIFNZU0NPTE9SX0dldFBlbihDT0xPUl9XSU5ET1dGUkFNRSkgKTsKCU1vdmVUb0V4KCBoZGMsIHJlY3QubGVmdCwgKHJlY3QudG9wICsgcmVjdC5ib3R0b20pLzIsIE5VTEwgKTsKCUxpbmVUbyggaGRjLCByZWN0LnJpZ2h0LCAocmVjdC50b3AgKyByZWN0LmJvdHRvbSkvMiApOwoqLwoKICAgIGlmIChscGl0ZW0tPmhibXBJdGVtKSB7CiAgICAgICAgLyogY2FsY3VsYXRlIHRoZSBiaXRtYXAgcmVjdGFuZ2xlIGluIGNvb3JkaW5hdGVzIHJlbGF0aXZlCiAgICAgICAgICogdG8gdGhlIGl0ZW0gcmVjdGFuZ2xlICovCiAgICAgICAgaWYoIG1lbnVCYXIpIHsKICAgICAgICAgICAgaWYoIGxwaXRlbS0+aGJtcEl0ZW0gPT0gSEJNTUVOVV9DQUxMQkFDSykKICAgICAgICAgICAgICAgIGJtcHJjLmxlZnQgPSAzOwogICAgICAgICAgICBlbHNlIAogICAgICAgICAgICAgICAgYm1wcmMubGVmdCA9IGxwaXRlbS0+dGV4dCA/IG1lbnVjaGFyc2l6ZS5jeCA6IDA7ICAgICAgICAgIAogICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgIGJtcHJjLmxlZnQgPSA0OwogICAgICAgICAgICBpZiggIShtZW51LT5kd1N0eWxlICYgKCBNTlNfQ0hFQ0tPUkJNUCB8IE1OU19OT0NIRUNLKSkpCiAgICAgICAgICAgICAgICBibXByYy5sZWZ0ICs9IEdldFN5c3RlbU1ldHJpY3MoIFNNX0NYTUVOVUNIRUNLKTsgCiAgICAgICAgfQogICAgICAgIGJtcHJjLnJpZ2h0ID0gIGJtcHJjLmxlZnQgKyBscGl0ZW0tPmJtcHNpemUuY3g7CiAgICAgICAgaWYoIG1lbnVCYXIgJiYgIShscGl0ZW0tPmhibXBJdGVtID09IEhCTU1FTlVfQ0FMTEJBQ0spKQogICAgICAgICAgICBibXByYy50b3AgPSAwOwogICAgICAgIGVsc2UKICAgICAgICAgICAgYm1wcmMudG9wID0gKHJlY3QuYm90dG9tIC0gcmVjdC50b3AgLQogICAgICAgICAgICAgICAgICAgIGxwaXRlbS0+Ym1wc2l6ZS5jeSkgLyAyOyAKICAgICAgICBibXByYy5ib3R0b20gPSAgYm1wcmMudG9wICsgbHBpdGVtLT5ibXBzaXplLmN5OwogICAgfQoKICAgIGlmICghbWVudUJhcikKICAgIHsKICAgICAgICBIQklUTUFQIGJtOwogICAgICAgIElOVCB5ID0gcmVjdC50b3AgKyByZWN0LmJvdHRvbTsKICAgICAgICBSRUNUIHJjID0gcmVjdDsKICAgICAgICBpbnQgY2hlY2tlZCA9IEZBTFNFOwogICAgICAgIFVJTlQgY2hlY2tfYml0bWFwX3dpZHRoID0gR2V0U3lzdGVtTWV0cmljcyggU01fQ1hNRU5VQ0hFQ0sgKTsKICAgICAgICBVSU5UIGNoZWNrX2JpdG1hcF9oZWlnaHQgPSBHZXRTeXN0ZW1NZXRyaWNzKCBTTV9DWU1FTlVDSEVDSyApOwogICAgICAgIC8qIERyYXcgdGhlIGNoZWNrIG1hcmsKICAgICAgICAgKgogICAgICAgICAqIEZJWE1FOgogICAgICAgICAqIEN1c3RvbSBjaGVja21hcmsgYml0bWFwcyBhcmUgbW9ub2Nocm9tZSBidXQgbm90IGFsd2F5cyAxYnBwLgogICAgICAgICAqLwogICAgICAgIGlmKCAhKG1lbnUtPmR3U3R5bGUgJiBNTlNfTk9DSEVDSykpIHsKICAgICAgICAgICAgYm0gPSAobHBpdGVtLT5mU3RhdGUgJiBNRl9DSEVDS0VEKSA/IGxwaXRlbS0+aENoZWNrQml0IDoKICAgICAgICAgICAgICAgIGxwaXRlbS0+aFVuQ2hlY2tCaXQ7CiAgICAgICAgICAgIGlmIChibSkgIC8qIHdlIGhhdmUgYSBjdXN0b20gYml0bWFwICovCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIEhEQyBoZGNNZW0gPSBDcmVhdGVDb21wYXRpYmxlREMoIGhkYyApOwoKICAgICAgICAgICAgICAgIFNlbGVjdE9iamVjdCggaGRjTWVtLCBibSApOwogICAgICAgICAgICAgICAgQml0Qmx0KCBoZGMsIHJjLmxlZnQsICh5IC0gY2hlY2tfYml0bWFwX2hlaWdodCkgLyAyLAogICAgICAgICAgICAgICAgICAgICAgICBjaGVja19iaXRtYXBfd2lkdGgsIGNoZWNrX2JpdG1hcF9oZWlnaHQsCiAgICAgICAgICAgICAgICAgICAgICAgIGhkY01lbSwgMCwgMCwgU1JDQ09QWSApOwogICAgICAgICAgICAgICAgRGVsZXRlREMoIGhkY01lbSApOwogICAgICAgICAgICAgICAgY2hlY2tlZCA9IFRSVUU7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgZWxzZSBpZiAobHBpdGVtLT5mU3RhdGUgJiBNRl9DSEVDS0VEKSAvKiBzdGFuZGFyZCBiaXRtYXBzICovCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIFJFQ1QgcjsKICAgICAgICAgICAgICAgIEhCSVRNQVAgYm0gPSBDcmVhdGVCaXRtYXAoIGNoZWNrX2JpdG1hcF93aWR0aCwKICAgICAgICAgICAgICAgICAgICAgICAgY2hlY2tfYml0bWFwX2hlaWdodCwgMSwgMSwgTlVMTCApOwogICAgICAgICAgICAgICAgSERDIGhkY01lbSA9IENyZWF0ZUNvbXBhdGlibGVEQyggaGRjICk7CgogICAgICAgICAgICAgICAgU2VsZWN0T2JqZWN0KCBoZGNNZW0sIGJtICk7CiAgICAgICAgICAgICAgICBTZXRSZWN0KCAmciwgMCwgMCwgY2hlY2tfYml0bWFwX3dpZHRoLCBjaGVja19iaXRtYXBfaGVpZ2h0KTsKICAgICAgICAgICAgICAgIERyYXdGcmFtZUNvbnRyb2woIGhkY01lbSwgJnIsIERGQ19NRU5VLAogICAgICAgICAgICAgICAgICAgICAgICAobHBpdGVtLT5mVHlwZSAmIE1GVF9SQURJT0NIRUNLKSA/CiAgICAgICAgICAgICAgICAgICAgICAgIERGQ1NfTUVOVUJVTExFVCA6IERGQ1NfTUVOVUNIRUNLICk7CiAgICAgICAgICAgICAgICBCaXRCbHQoIGhkYywgcmMubGVmdCwgKHkgLSByLmJvdHRvbSkgLyAyLCByLnJpZ2h0LCByLmJvdHRvbSwKICAgICAgICAgICAgICAgICAgICAgICAgaGRjTWVtLCAwLCAwLCBTUkNDT1BZICk7CiAgICAgICAgICAgICAgICBEZWxldGVEQyggaGRjTWVtICk7CiAgICAgICAgICAgICAgICBEZWxldGVPYmplY3QoIGJtICk7CiAgICAgICAgICAgICAgICBjaGVja2VkID0gVFJVRTsKICAgICAgICAgICAgfQogICAgICAgIH0KICAgICAgICBpZiggbHBpdGVtLT5oYm1wSXRlbSAmJgogICAgICAgICAgICAgICAgISggY2hlY2tlZCAmJiAobWVudS0+ZHdTdHlsZSAmIE1OU19DSEVDS09SQk1QKSkpIHsKICAgICAgICAgICAgUE9JTlQgb3JpZ29yZzsKICAgICAgICAgICAgLyogc29tZSBhcHBsaWNhdGlvbnMgbWFrZSB0aGlzIGFzc3VtcHRpb24gb24gdGhlIERDJ3Mgb3JpZ2luICovCiAgICAgICAgICAgIFNldFZpZXdwb3J0T3JnRXgoIGhkYywgcmVjdC5sZWZ0LCByZWN0LnRvcCwgJm9yaWdvcmcpOwogICAgICAgICAgICBNRU5VX0RyYXdCaXRtYXBJdGVtKGhkYywgbHBpdGVtLCAmYm1wcmMsIGhtZW51LCBod25kT3duZXIsCiAgICAgICAgICAgICAgICAgICAgb2RhY3Rpb24sIEZBTFNFKTsKICAgICAgICAgICAgU2V0Vmlld3BvcnRPcmdFeCggaGRjLCBvcmlnb3JnLngsIG9yaWdvcmcueSwgTlVMTCk7CiAgICAgICAgfQoJLyogRHJhdyB0aGUgcG9wdXAtbWVudSBhcnJvdyAqLwogICAgICAgIGlmIChscGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApCiAgICAgICAgICAgIGRyYXdfcG9wdXBfYXJyb3coIGhkYywgcmVjdCwgYXJyb3dfYml0bWFwX3dpZHRoLAogICAgICAgICAgICAgICAgICAgIGFycm93X2JpdG1hcF9oZWlnaHQpOwoJcmVjdC5sZWZ0ICs9IDQ7CiAgICAgICAgaWYoICEobWVudS0+ZHdTdHlsZSAmIE1OU19OT0NIRUNLKSkKICAgICAgICAgICAgcmVjdC5sZWZ0ICs9IGNoZWNrX2JpdG1hcF93aWR0aDsKCXJlY3QucmlnaHQgLT0gYXJyb3dfYml0bWFwX3dpZHRoOwogICAgfQogICAgZWxzZSBpZiggbHBpdGVtLT5oYm1wSXRlbSkKICAgIHsgICAvKiBEcmF3IHRoZSBiaXRtYXAgKi8KICAgICAgICBQT0lOVCBvcmlnb3JnOwogICAgICAgIAogICAgICAgIFNldFZpZXdwb3J0T3JnRXgoIGhkYywgcmVjdC5sZWZ0LCByZWN0LnRvcCwgJm9yaWdvcmcpOwogICAgICAgIE1FTlVfRHJhd0JpdG1hcEl0ZW0oIGhkYywgbHBpdGVtLCAmYm1wcmMsIGhtZW51LCBod25kT3duZXIsCiAgICAgICAgICAgICAgICBvZGFjdGlvbiwgbWVudUJhcik7CiAgICAgICAgU2V0Vmlld3BvcnRPcmdFeCggaGRjLCBvcmlnb3JnLngsIG9yaWdvcmcueSwgTlVMTCk7CiAgICB9CiAgICAvKiBwcm9jZXNzIHRleHQgaWYgcHJlc2VudCAqLwogICAgaWYgKGxwaXRlbS0+dGV4dCkKICAgIHsKCXJlZ2lzdGVyIGludCBpOwoJSEZPTlQgaGZvbnRPbGQgPSAwOwoKCVVJTlQgdUZvcm1hdCA9IChtZW51QmFyKSA/CgkJCURUX0NFTlRFUiB8IERUX1ZDRU5URVIgfCBEVF9TSU5HTEVMSU5FIDoKCQkJRFRfTEVGVCB8IERUX1ZDRU5URVIgfCBEVF9TSU5HTEVMSU5FOwoKICAgICAgICBpZiggIShtZW51LT5kd1N0eWxlICYgTU5TX0NIRUNLT1JCTVApKQogICAgICAgICAgICByZWN0LmxlZnQgKz0gbWVudS0+bWF4Qm1wU2l6ZS5jeDsKCglpZiAoIGxwaXRlbS0+ZlN0YXRlICYgTUZTX0RFRkFVTFQgKQoJewoJICAgICBoZm9udE9sZCA9IFNlbGVjdE9iamVjdCggaGRjLCBnZXRfbWVudV9mb250KFRSVUUpICk7Cgl9CgoJaWYgKG1lbnVCYXIpIHsKICAgICAgICAgICAgaWYoIGxwaXRlbS0+aGJtcEl0ZW0pCiAgICAgICAgICAgICAgICByZWN0LmxlZnQgKz0gbHBpdGVtLT5ibXBzaXplLmN4OwogICAgICAgICAgICBpZiggIShscGl0ZW0tPmhibXBJdGVtID09IEhCTU1FTlVfQ0FMTEJBQ0spKQogICAgICAgICAgICAgICAgcmVjdC5sZWZ0ICs9IG1lbnVjaGFyc2l6ZS5jeDsKICAgICAgICAgICAgcmVjdC5yaWdodCAtPSBtZW51Y2hhcnNpemUuY3g7Cgl9CgoJZm9yIChpID0gMDsgbHBpdGVtLT50ZXh0W2ldOyBpKyspCgkgICAgaWYgKChscGl0ZW0tPnRleHRbaV0gPT0gJ1x0JykgfHwgKGxwaXRlbS0+dGV4dFtpXSA9PSAnXGInKSkKCSAgICAgICAgYnJlYWs7CgoJaWYobHBpdGVtLT5mU3RhdGUgJiBNRl9HUkFZRUQpCgl7CgkgICAgaWYgKCEobHBpdGVtLT5mU3RhdGUgJiBNRl9ISUxJVEUpICkKCSAgICB7CgkJKytyZWN0LmxlZnQ7ICsrcmVjdC50b3A7ICsrcmVjdC5yaWdodDsgKytyZWN0LmJvdHRvbTsKCQlTZXRUZXh0Q29sb3IoaGRjLCBSR0IoMHhmZiwgMHhmZiwgMHhmZikpOwoJCURyYXdUZXh0VyggaGRjLCBscGl0ZW0tPnRleHQsIGksICZyZWN0LCB1Rm9ybWF0ICk7CgkJLS1yZWN0LmxlZnQ7IC0tcmVjdC50b3A7IC0tcmVjdC5yaWdodDsgLS1yZWN0LmJvdHRvbTsKCSAgICB9CgkgICAgU2V0VGV4dENvbG9yKGhkYywgUkdCKDB4ODAsIDB4ODAsIDB4ODApKTsKCX0KCglEcmF3VGV4dFcoIGhkYywgbHBpdGVtLT50ZXh0LCBpLCAmcmVjdCwgdUZvcm1hdCk7CgoJLyogcGFpbnQgdGhlIHNob3J0Y3V0IHRleHQgKi8KCWlmICghbWVudUJhciAmJiBscGl0ZW0tPnRleHRbaV0pICAvKiBUaGVyZSdzIGEgdGFiIG9yIGZsdXNoLXJpZ2h0IGNoYXIgKi8KCXsKCSAgICBpZiAobHBpdGVtLT50ZXh0W2ldID09ICdcdCcpCgkgICAgewoJCXJlY3QubGVmdCA9IGxwaXRlbS0+eFRhYjsKCQl1Rm9ybWF0ID0gRFRfTEVGVCB8IERUX1ZDRU5URVIgfCBEVF9TSU5HTEVMSU5FOwoJICAgIH0KCSAgICBlbHNlCgkgICAgewoJCXJlY3QucmlnaHQgPSBscGl0ZW0tPnhUYWI7CgkJdUZvcm1hdCA9IERUX1JJR0hUIHwgRFRfVkNFTlRFUiB8IERUX1NJTkdMRUxJTkU7CgkgICAgfQoKCSAgICBpZihscGl0ZW0tPmZTdGF0ZSAmIE1GX0dSQVlFRCkKCSAgICB7CgkJaWYgKCEobHBpdGVtLT5mU3RhdGUgJiBNRl9ISUxJVEUpICkKCQl7CgkJICAgICsrcmVjdC5sZWZ0OyArK3JlY3QudG9wOyArK3JlY3QucmlnaHQ7ICsrcmVjdC5ib3R0b207CgkJICAgIFNldFRleHRDb2xvcihoZGMsIFJHQigweGZmLCAweGZmLCAweGZmKSk7CgkJICAgIERyYXdUZXh0VyggaGRjLCBscGl0ZW0tPnRleHQgKyBpICsgMSwgLTEsICZyZWN0LCB1Rm9ybWF0ICk7CgkJICAgIC0tcmVjdC5sZWZ0OyAtLXJlY3QudG9wOyAtLXJlY3QucmlnaHQ7IC0tcmVjdC5ib3R0b207CgkJfQoJCVNldFRleHRDb2xvcihoZGMsIFJHQigweDgwLCAweDgwLCAweDgwKSk7CgkgICAgfQoJICAgIERyYXdUZXh0VyggaGRjLCBscGl0ZW0tPnRleHQgKyBpICsgMSwgLTEsICZyZWN0LCB1Rm9ybWF0ICk7Cgl9CgoJaWYgKGhmb250T2xkKQoJICAgIFNlbGVjdE9iamVjdCAoaGRjLCBoZm9udE9sZCk7CiAgICB9Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfRHJhd1BvcHVwTWVudQogKgogKiBQYWludCBhIHBvcHVwIG1lbnUuCiAqLwpzdGF0aWMgdm9pZCBNRU5VX0RyYXdQb3B1cE1lbnUoIEhXTkQgaHduZCwgSERDIGhkYywgSE1FTlUgaG1lbnUgKQp7CiAgICBIQlJVU0ggaFByZXZCcnVzaCA9IDA7CiAgICBSRUNUIHJlY3Q7CgogICAgVFJBQ0UoInduZD0lcCBkYz0lcCBtZW51PSVwXG4iLCBod25kLCBoZGMsIGhtZW51KTsKCiAgICBHZXRDbGllbnRSZWN0KCBod25kLCAmcmVjdCApOwoKICAgIGlmKChoUHJldkJydXNoID0gU2VsZWN0T2JqZWN0KCBoZGMsIEdldFN5c0NvbG9yQnJ1c2goQ09MT1JfTUVOVSkgKSkKICAgICAgICAmJiAoU2VsZWN0T2JqZWN0KCBoZGMsIGdldF9tZW51X2ZvbnQoRkFMU0UpKSkpCiAgICB7CglIUEVOIGhQcmV2UGVuOwoKCVJlY3RhbmdsZSggaGRjLCByZWN0LmxlZnQsIHJlY3QudG9wLCByZWN0LnJpZ2h0LCByZWN0LmJvdHRvbSApOwoKCWhQcmV2UGVuID0gU2VsZWN0T2JqZWN0KCBoZGMsIEdldFN0b2NrT2JqZWN0KCBOVUxMX1BFTiApICk7CglpZiggaFByZXZQZW4gKQoJewoJICAgIFBPUFVQTUVOVSAqbWVudTsKCSAgICBCT09MIGZsYXRfbWVudSA9IEZBTFNFOwoKCSAgICBTeXN0ZW1QYXJhbWV0ZXJzSW5mb1cgKFNQSV9HRVRGTEFUTUVOVSwgMCwgJmZsYXRfbWVudSwgMCk7CgkgICAgaWYgKGZsYXRfbWVudSkKCQlGcmFtZVJlY3QoaGRjLCAmcmVjdCwgR2V0U3lzQ29sb3JCcnVzaChDT0xPUl9CVE5TSEFET1cpKTsKCSAgICBlbHNlCgkJRHJhd0VkZ2UgKGhkYywgJnJlY3QsIEVER0VfUkFJU0VELCBCRl9SRUNUKTsKCiAgICAgICAgICAgIGlmKCAobWVudSA9IE1FTlVfR2V0TWVudSggaG1lbnUgKSkpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIC8qIGRyYXcgbWVudSBpdGVtcyAqLwogICAgICAgICAgICAgICAgaWYoIG1lbnUtPm5JdGVtcykKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICBNRU5VSVRFTSAqaXRlbTsKICAgICAgICAgICAgICAgICAgICBVSU5UIHU7CgogICAgICAgICAgICAgICAgICAgIGl0ZW0gPSBtZW51LT5pdGVtczsKICAgICAgICAgICAgICAgICAgICBmb3IoIHUgPSBtZW51LT5uSXRlbXM7IHUgPiAwOyB1LS0sIGl0ZW0rKykKICAgICAgICAgICAgICAgICAgICAgICAgTUVOVV9EcmF3TWVudUl0ZW0oIGh3bmQsIGhtZW51LCBtZW51LT5od25kT3duZXIsIGhkYywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpdGVtLCBtZW51LT5IZWlnaHQsIEZBTFNFLCBPREFfRFJBV0VOVElSRSApOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgLyogZHJhdyBzY3JvbGwgYXJyb3dzICovCiAgICAgICAgICAgICAgICBpZiAobWVudS0+YlNjcm9sbGluZykKICAgICAgICAgICAgICAgICAgICBNRU5VX0RyYXdTY3JvbGxBcnJvd3MobWVudSwgaGRjKTsKICAgICAgICAgICAgfQogCX0gZWxzZQoJewoJICAgIFNlbGVjdE9iamVjdCggaGRjLCBoUHJldkJydXNoICk7Cgl9CiAgICB9Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9EcmF3TWVudUJhcgogKgogKiBQYWludCBhIG1lbnUgYmFyLiBSZXR1cm5zIHRoZSBoZWlnaHQgb2YgdGhlIG1lbnUgYmFyLgogKiBjYWxsZWQgZnJvbSBbd2luZG93cy9ub25jbGllbnQuY10KICovClVJTlQgTUVOVV9EcmF3TWVudUJhciggSERDIGhEQywgTFBSRUNUIGxwcmVjdCwgSFdORCBod25kLAogICAgICAgICAgICAgICAgICAgICAgICAgQk9PTCBzdXBwcmVzc19kcmF3KQp7CiAgICBMUFBPUFVQTUVOVSBscHBvcDsKICAgIEhGT05UIGhmb250T2xkID0gMDsKICAgIEhNRU5VIGhNZW51ID0gR2V0TWVudShod25kKTsKCiAgICBscHBvcCA9IE1FTlVfR2V0TWVudSggaE1lbnUgKTsKICAgIGlmIChscHBvcCA9PSBOVUxMIHx8IGxwcmVjdCA9PSBOVUxMKQogICAgewogICAgICAgIHJldHVybiBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZTUVOVSk7CiAgICB9CgogICAgaWYgKHN1cHByZXNzX2RyYXcpCiAgICB7CgloZm9udE9sZCA9IFNlbGVjdE9iamVjdCggaERDLCBnZXRfbWVudV9mb250KEZBTFNFKSk7CgoJaWYgKGxwcG9wLT5IZWlnaHQgPT0gMCkKCQlNRU5VX01lbnVCYXJDYWxjU2l6ZShoREMsIGxwcmVjdCwgbHBwb3AsIGh3bmQpOwoKCWxwcmVjdC0+Ym90dG9tID0gbHByZWN0LT50b3AgKyBscHBvcC0+SGVpZ2h0OwoKICAgICAgICBpZiAoaGZvbnRPbGQpIFNlbGVjdE9iamVjdCggaERDLCBoZm9udE9sZCk7CglyZXR1cm4gbHBwb3AtPkhlaWdodDsKICAgIH0KICAgIGVsc2UKICAgICAgICByZXR1cm4gRHJhd01lbnVCYXJUZW1wKGh3bmQsIGhEQywgbHByZWN0LCBoTWVudSwgTlVMTCk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfU2hvd1BvcHVwCiAqCiAqIERpc3BsYXkgYSBwb3B1cCBtZW51LgogKi8Kc3RhdGljIEJPT0wgTUVOVV9TaG93UG9wdXAoIEhXTkQgaHduZE93bmVyLCBITUVOVSBobWVudSwgVUlOVCBpZCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSU5UIHgsIElOVCB5LCBJTlQgeGFuY2hvciwgSU5UIHlhbmNob3IgKQp7CiAgICBQT1BVUE1FTlUgKm1lbnU7CiAgICBJTlQgd2lkdGgsIGhlaWdodDsKICAgIFBPSU5UIHB0OwogICAgSE1PTklUT1IgbW9uaXRvcjsKICAgIE1PTklUT1JJTkZPIGluZm87CgogICAgVFJBQ0UoIm93bmVyPSVwIGhtZW51PSVwIGlkPTB4JTA0eCB4PTB4JTA0eCB5PTB4JTA0eCB4YT0weCUwNHggeWE9MHglMDR4XG4iLAogICAgICAgICAgaHduZE93bmVyLCBobWVudSwgaWQsIHgsIHksIHhhbmNob3IsIHlhbmNob3IpOwoKICAgIGlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoIGhtZW51ICkpKSByZXR1cm4gRkFMU0U7CiAgICBpZiAobWVudS0+Rm9jdXNlZEl0ZW0gIT0gTk9fU0VMRUNURURfSVRFTSkKICAgIHsKCW1lbnUtPml0ZW1zW21lbnUtPkZvY3VzZWRJdGVtXS5mU3RhdGUgJj0gfihNRl9ISUxJVEV8TUZfTU9VU0VTRUxFQ1QpOwoJbWVudS0+Rm9jdXNlZEl0ZW0gPSBOT19TRUxFQ1RFRF9JVEVNOwogICAgfQoKICAgIC8qIHN0b3JlIHRoZSBvd25lciBmb3IgRHJhd0l0ZW0gKi8KICAgIG1lbnUtPmh3bmRPd25lciA9IGh3bmRPd25lcjsKCiAgICBtZW51LT5uU2Nyb2xsUG9zID0gMDsKICAgIE1FTlVfUG9wdXBNZW51Q2FsY1NpemUoIG1lbnUgKTsKCiAgICAvKiBhZGp1c3QgcG9wdXAgbWVudSBwb3Mgc28gdGhhdCBpdCBmaXRzIHdpdGhpbiB0aGUgZGVza3RvcCAqLwoKICAgIHdpZHRoID0gbWVudS0+V2lkdGggKyBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NYQk9SREVSKTsKICAgIGhlaWdodCA9IG1lbnUtPkhlaWdodCArIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lCT1JERVIpOwoKICAgIC8qIEZJWE1FOiBzaG91bGQgdXNlIGl0ZW0gcmVjdCAqLwogICAgcHQueCA9IHg7CiAgICBwdC55ID0geTsKICAgIG1vbml0b3IgPSBNb25pdG9yRnJvbVBvaW50KCBwdCwgTU9OSVRPUl9ERUZBVUxUVE9ORUFSRVNUICk7CiAgICBpbmZvLmNiU2l6ZSA9IHNpemVvZihpbmZvKTsKICAgIEdldE1vbml0b3JJbmZvVyggbW9uaXRvciwgJmluZm8gKTsKICAgIGlmKCB4ICsgd2lkdGggPiBpbmZvLnJjV29yay5yaWdodCkKICAgIHsKICAgICAgICBpZiggeGFuY2hvciAmJiB4ID49IHdpZHRoIC0geGFuY2hvciApCiAgICAgICAgICAgIHggLT0gd2lkdGggLSB4YW5jaG9yOwoKICAgICAgICBpZiggeCArIHdpZHRoID4gaW5mby5yY1dvcmsucmlnaHQpCiAgICAgICAgICAgIHggPSBpbmZvLnJjV29yay5yaWdodCAtIHdpZHRoOwogICAgfQogICAgaWYoIHggPCBpbmZvLnJjV29yay5sZWZ0ICkgeCA9IGluZm8ucmNXb3JrLmxlZnQ7CgogICAgaWYoIHkgKyBoZWlnaHQgPiBpbmZvLnJjV29yay5ib3R0b20pCiAgICB7CiAgICAgICAgaWYoIHlhbmNob3IgJiYgeSA+PSBoZWlnaHQgKyB5YW5jaG9yICkKICAgICAgICAgICAgeSAtPSBoZWlnaHQgKyB5YW5jaG9yOwoKICAgICAgICBpZiggeSArIGhlaWdodCA+IGluZm8ucmNXb3JrLmJvdHRvbSkKICAgICAgICAgICAgeSA9IGluZm8ucmNXb3JrLmJvdHRvbSAtIGhlaWdodDsKICAgIH0KICAgIGlmKCB5IDwgaW5mby5yY1dvcmsudG9wICkgeSA9IGluZm8ucmNXb3JrLnRvcDsKCiAgICAvKiBOT1RFOiBJbiBXaW5kb3dzLCB0b3AgbWVudSBwb3B1cCBpcyBub3Qgb3duZWQuICovCiAgICBtZW51LT5oV25kID0gQ3JlYXRlV2luZG93RXhXKCAwLCAoTFBDV1NUUilQT1BVUE1FTlVfQ0xBU1NfQVRPTSwgTlVMTCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBXU19QT1BVUCwgeCwgeSwgd2lkdGgsIGhlaWdodCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBod25kT3duZXIsIDAsIChISU5TVEFOQ0UpR2V0V2luZG93TG9uZ1B0clcoaHduZE93bmVyLCBHV0xQX0hJTlNUQU5DRSksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKExQVk9JRClobWVudSApOwogICAgaWYoICFtZW51LT5oV25kICkgcmV0dXJuIEZBTFNFOwogICAgaWYgKCF0b3BfcG9wdXApIHRvcF9wb3B1cCA9IG1lbnUtPmhXbmQ7CgogICAgLyogRGlzcGxheSB0aGUgd2luZG93ICovCgogICAgU2V0V2luZG93UG9zKCBtZW51LT5oV25kLCBIV05EX1RPUE1PU1QsIDAsIDAsIDAsIDAsCiAgICAgICAgICAgICAgICAgIFNXUF9TSE9XV0lORE9XIHwgU1dQX05PU0laRSB8IFNXUF9OT01PVkUgfCBTV1BfTk9BQ1RJVkFURSApOwogICAgVXBkYXRlV2luZG93KCBtZW51LT5oV25kICk7CiAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9FbnN1cmVNZW51SXRlbVZpc2libGUKICovCnN0YXRpYyB2b2lkCk1FTlVfRW5zdXJlTWVudUl0ZW1WaXNpYmxlKExQUE9QVVBNRU5VIGxwcG9wLCBVSU5UIHdJbmRleCwgSERDIGhkYykKewogICAgaWYgKGxwcG9wLT5iU2Nyb2xsaW5nKQogICAgewogICAgICAgIE1FTlVJVEVNICppdGVtID0gJmxwcG9wLT5pdGVtc1t3SW5kZXhdOwogICAgICAgIFVJTlQgbk1heEhlaWdodCA9IE1FTlVfR2V0TWF4UG9wdXBIZWlnaHQobHBwb3ApOwogICAgICAgIFVJTlQgbk9sZFBvcyA9IGxwcG9wLT5uU2Nyb2xsUG9zOwogICAgICAgIFJFQ1QgcmM7CiAgICAgICAgVUlOVCBhcnJvd19iaXRtYXBfaGVpZ2h0OwogICAgICAgIEJJVE1BUCBibXA7CiAgICAgICAgCiAgICAgICAgR2V0Q2xpZW50UmVjdChscHBvcC0+aFduZCwgJnJjKTsKCiAgICAgICAgR2V0T2JqZWN0VyhnZXRfZG93bl9hcnJvd19iaXRtYXAoKSwgc2l6ZW9mKGJtcCksICZibXApOwogICAgICAgIGFycm93X2JpdG1hcF9oZWlnaHQgPSBibXAuYm1IZWlnaHQ7CgogICAgICAgIHJjLnRvcCArPSBhcnJvd19iaXRtYXBfaGVpZ2h0OwogICAgICAgIHJjLmJvdHRvbSAtPSBhcnJvd19iaXRtYXBfaGVpZ2h0ICsgTUVOVV9CT1RUT01fTUFSR0lOOwogICAgICAgCiAgICAgICAgbk1heEhlaWdodCAtPSBHZXRTeXN0ZW1NZXRyaWNzKFNNX0NZQk9SREVSKSArIDIgKiBhcnJvd19iaXRtYXBfaGVpZ2h0OwogICAgICAgIGlmIChpdGVtLT5yZWN0LmJvdHRvbSA+IGxwcG9wLT5uU2Nyb2xsUG9zICsgbk1heEhlaWdodCkKICAgICAgICB7CiAgICAgICAgICAgIAogICAgICAgICAgICBscHBvcC0+blNjcm9sbFBvcyA9IGl0ZW0tPnJlY3QuYm90dG9tIC0gbk1heEhlaWdodDsKICAgICAgICAgICAgU2Nyb2xsV2luZG93KGxwcG9wLT5oV25kLCAwLCBuT2xkUG9zIC0gbHBwb3AtPm5TY3JvbGxQb3MsICZyYywgJnJjKTsKICAgICAgICAgICAgTUVOVV9EcmF3U2Nyb2xsQXJyb3dzKGxwcG9wLCBoZGMpOwogICAgICAgIH0KICAgICAgICBlbHNlIGlmIChpdGVtLT5yZWN0LnRvcCAtIE1FTlVfVE9QX01BUkdJTiA8IGxwcG9wLT5uU2Nyb2xsUG9zKQogICAgICAgIHsKICAgICAgICAgICAgbHBwb3AtPm5TY3JvbGxQb3MgPSBpdGVtLT5yZWN0LnRvcCAtIE1FTlVfVE9QX01BUkdJTjsKICAgICAgICAgICAgU2Nyb2xsV2luZG93KGxwcG9wLT5oV25kLCAwLCBuT2xkUG9zIC0gbHBwb3AtPm5TY3JvbGxQb3MsICZyYywgJnJjKTsKICAgICAgICAgICAgTUVOVV9EcmF3U2Nyb2xsQXJyb3dzKGxwcG9wLCBoZGMpOwogICAgICAgIH0KICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9TZWxlY3RJdGVtCiAqLwpzdGF0aWMgdm9pZCBNRU5VX1NlbGVjdEl0ZW0oIEhXTkQgaHduZE93bmVyLCBITUVOVSBobWVudSwgVUlOVCB3SW5kZXgsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQk9PTCBzZW5kTWVudVNlbGVjdCwgSE1FTlUgdG9wbWVudSApCnsKICAgIExQUE9QVVBNRU5VIGxwcG9wOwogICAgSERDIGhkYzsKCiAgICBUUkFDRSgib3duZXI9JXAgbWVudT0lcCBpbmRleD0weCUwNHggc2VsZWN0PTB4JTA0eFxuIiwgaHduZE93bmVyLCBobWVudSwgd0luZGV4LCBzZW5kTWVudVNlbGVjdCk7CgogICAgbHBwb3AgPSBNRU5VX0dldE1lbnUoIGhtZW51ICk7CiAgICBpZiAoKCFscHBvcCkgfHwgKCFscHBvcC0+bkl0ZW1zKSB8fCAoIWxwcG9wLT5oV25kKSkgcmV0dXJuOwoKICAgIGlmIChscHBvcC0+Rm9jdXNlZEl0ZW0gPT0gd0luZGV4KSByZXR1cm47CiAgICBpZiAobHBwb3AtPndGbGFncyAmIE1GX1BPUFVQKSBoZGMgPSBHZXREQyggbHBwb3AtPmhXbmQgKTsKICAgIGVsc2UgaGRjID0gR2V0RENFeCggbHBwb3AtPmhXbmQsIDAsIERDWF9DQUNIRSB8IERDWF9XSU5ET1cpOwogICAgaWYgKCF0b3BfcG9wdXApIHRvcF9wb3B1cCA9IGxwcG9wLT5oV25kOwoKICAgIFNlbGVjdE9iamVjdCggaGRjLCBnZXRfbWVudV9mb250KEZBTFNFKSk7CgogICAgICAvKiBDbGVhciBwcmV2aW91cyBoaWdobGlnaHRlZCBpdGVtICovCiAgICBpZiAobHBwb3AtPkZvY3VzZWRJdGVtICE9IE5PX1NFTEVDVEVEX0lURU0pCiAgICB7CglscHBvcC0+aXRlbXNbbHBwb3AtPkZvY3VzZWRJdGVtXS5mU3RhdGUgJj0gfihNRl9ISUxJVEV8TUZfTU9VU0VTRUxFQ1QpOwoJTUVOVV9EcmF3TWVudUl0ZW0obHBwb3AtPmhXbmQsIGhtZW51LCBod25kT3duZXIsIGhkYywmbHBwb3AtPml0ZW1zW2xwcG9wLT5Gb2N1c2VkSXRlbV0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgbHBwb3AtPkhlaWdodCwgIShscHBvcC0+d0ZsYWdzICYgTUZfUE9QVVApLAoJCQkgIE9EQV9TRUxFQ1QgKTsKICAgIH0KCiAgICAgIC8qIEhpZ2hsaWdodCBuZXcgaXRlbSAoaWYgYW55KSAqLwogICAgbHBwb3AtPkZvY3VzZWRJdGVtID0gd0luZGV4OwogICAgaWYgKGxwcG9wLT5Gb2N1c2VkSXRlbSAhPSBOT19TRUxFQ1RFRF9JVEVNKQogICAgewogICAgICAgIGlmKCEobHBwb3AtPml0ZW1zW3dJbmRleF0uZlR5cGUgJiBNRl9TRVBBUkFUT1IpKSB7CiAgICAgICAgICAgIGxwcG9wLT5pdGVtc1t3SW5kZXhdLmZTdGF0ZSB8PSBNRl9ISUxJVEU7CiAgICAgICAgICAgIE1FTlVfRW5zdXJlTWVudUl0ZW1WaXNpYmxlKGxwcG9wLCB3SW5kZXgsIGhkYyk7CiAgICAgICAgICAgIE1FTlVfRHJhd01lbnVJdGVtKCBscHBvcC0+aFduZCwgaG1lbnUsIGh3bmRPd25lciwgaGRjLAogICAgICAgICAgICAgICAgICAgICZscHBvcC0+aXRlbXNbd0luZGV4XSwgbHBwb3AtPkhlaWdodCwKICAgICAgICAgICAgICAgICAgICAhKGxwcG9wLT53RmxhZ3MgJiBNRl9QT1BVUCksIE9EQV9TRUxFQ1QgKTsKICAgICAgICB9CiAgICAgICAgaWYgKHNlbmRNZW51U2VsZWN0KQogICAgICAgIHsKICAgICAgICAgICAgTUVOVUlURU0gKmlwID0gJmxwcG9wLT5pdGVtc1tscHBvcC0+Rm9jdXNlZEl0ZW1dOwoJICAgIFNlbmRNZXNzYWdlVyggaHduZE93bmVyLCBXTV9NRU5VU0VMRUNULAogICAgICAgICAgICAgICAgICAgICBNQUtFTE9ORyhpcC0+ZlR5cGUgJiBNRl9QT1BVUCA/IHdJbmRleDogaXAtPndJRCwKICAgICAgICAgICAgICAgICAgICAgaXAtPmZUeXBlIHwgaXAtPmZTdGF0ZSB8CiAgICAgICAgICAgICAgICAgICAgIChscHBvcC0+d0ZsYWdzICYgTUZfU1lTTUVOVSkpLCAoTFBBUkFNKWhtZW51KTsKICAgICAgICB9CiAgICB9CiAgICBlbHNlIGlmIChzZW5kTWVudVNlbGVjdCkgewogICAgICAgIGlmKHRvcG1lbnUpewogICAgICAgICAgICBpbnQgcG9zOwogICAgICAgICAgICBpZigocG9zPU1FTlVfRmluZFN1Yk1lbnUoJnRvcG1lbnUsIGhtZW51KSkhPU5PX1NFTEVDVEVEX0lURU0pewogICAgICAgICAgICAgICAgUE9QVVBNRU5VICpwdG0gPSBNRU5VX0dldE1lbnUoIHRvcG1lbnUgKTsKICAgICAgICAgICAgICAgIE1FTlVJVEVNICppcCA9ICZwdG0tPml0ZW1zW3Bvc107CiAgICAgICAgICAgICAgICBTZW5kTWVzc2FnZVcoIGh3bmRPd25lciwgV01fTUVOVVNFTEVDVCwgTUFLRUxPTkcocG9zLAogICAgICAgICAgICAgICAgICAgICAgICAgaXAtPmZUeXBlIHwgaXAtPmZTdGF0ZSB8CiAgICAgICAgICAgICAgICAgICAgICAgICAocHRtLT53RmxhZ3MgJiBNRl9TWVNNRU5VKSksIChMUEFSQU0pdG9wbWVudSk7CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICB9CiAgICBSZWxlYXNlREMoIGxwcG9wLT5oV25kLCBoZGMgKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9Nb3ZlU2VsZWN0aW9uCiAqCiAqIE1vdmVzIGN1cnJlbnRseSBzZWxlY3RlZCBpdGVtIGFjY29yZGluZyB0byB0aGUgb2Zmc2V0IHBhcmFtZXRlci4KICogSWYgdGhlcmUgaXMgbm8gc2VsZWN0aW9uIHRoZW4gaXQgc2hvdWxkIHNlbGVjdCB0aGUgbGFzdCBpdGVtIGlmCiAqIG9mZnNldCBpcyBJVEVNX1BSRVYgb3IgdGhlIGZpcnN0IGl0ZW0gaWYgb2Zmc2V0IGlzIElURU1fTkVYVC4KICovCnN0YXRpYyB2b2lkIE1FTlVfTW92ZVNlbGVjdGlvbiggSFdORCBod25kT3duZXIsIEhNRU5VIGhtZW51LCBJTlQgb2Zmc2V0ICkKewogICAgSU5UIGk7CiAgICBQT1BVUE1FTlUgKm1lbnU7CgogICAgVFJBQ0UoImh3bmQ9JXAgaG1lbnU9JXAgb2ZmPTB4JTA0eFxuIiwgaHduZE93bmVyLCBobWVudSwgb2Zmc2V0KTsKCiAgICBtZW51ID0gTUVOVV9HZXRNZW51KCBobWVudSApOwogICAgaWYgKCghbWVudSkgfHwgKCFtZW51LT5pdGVtcykpIHJldHVybjsKCiAgICBpZiAoIG1lbnUtPkZvY3VzZWRJdGVtICE9IE5PX1NFTEVDVEVEX0lURU0gKQogICAgewoJaWYoIG1lbnUtPm5JdGVtcyA9PSAxICkgcmV0dXJuOyBlbHNlCglmb3IgKGkgPSBtZW51LT5Gb2N1c2VkSXRlbSArIG9mZnNldCA7IGkgPj0gMCAmJiBpIDwgbWVudS0+bkl0ZW1zCgkJCQkJICAgIDsgaSArPSBvZmZzZXQpCgkgICAgaWYgKCEobWVudS0+aXRlbXNbaV0uZlR5cGUgJiBNRl9TRVBBUkFUT1IpKQoJICAgIHsKCQlNRU5VX1NlbGVjdEl0ZW0oIGh3bmRPd25lciwgaG1lbnUsIGksIFRSVUUsIDAgKTsKCQlyZXR1cm47CgkgICAgfQogICAgfQoKICAgIGZvciAoIGkgPSAob2Zmc2V0ID4gMCkgPyAwIDogbWVudS0+bkl0ZW1zIC0gMTsKCQkgIGkgPj0gMCAmJiBpIDwgbWVudS0+bkl0ZW1zIDsgaSArPSBvZmZzZXQpCglpZiAoIShtZW51LT5pdGVtc1tpXS5mVHlwZSAmIE1GX1NFUEFSQVRPUikpCgl7CgkgICAgTUVOVV9TZWxlY3RJdGVtKCBod25kT3duZXIsIGhtZW51LCBpLCBUUlVFLCAwICk7CgkgICAgcmV0dXJuOwoJfQp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBNRU5VX1NldEl0ZW1EYXRhCiAqCiAqIFNldCBhbiBpdGVtJ3MgZmxhZ3MsIGlkIGFuZCB0ZXh0IHB0ci4gQ2FsbGVkIGJ5IEluc2VydE1lbnUoKSBhbmQKICogTW9kaWZ5TWVudSgpLgogKi8Kc3RhdGljIEJPT0wgTUVOVV9TZXRJdGVtRGF0YSggTUVOVUlURU0gKml0ZW0sIFVJTlQgZmxhZ3MsIFVJTlRfUFRSIGlkLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIExQQ1dTVFIgc3RyICkKewogICAgZGVidWdfcHJpbnRfbWVudWl0ZW0oIk1FTlVfU2V0SXRlbURhdGEgZnJvbTogIiwgaXRlbSwgIiIpOwogICAgVFJBQ0UoImZsYWdzPSV4IHN0cj0lcFxuIiwgZmxhZ3MsIHN0cik7CgogICAgaWYgKElTX1NUUklOR19JVEVNKGZsYWdzKSkKICAgIHsKICAgICAgICBMUFdTVFIgcHJldlRleHQgPSBpdGVtLT50ZXh0OwogICAgICAgIGlmICghc3RyKQogICAgICAgIHsKICAgICAgICAgICAgZmxhZ3MgfD0gTUZfU0VQQVJBVE9SOwogICAgICAgICAgICBpdGVtLT50ZXh0ID0gTlVMTDsKICAgICAgICB9CiAgICAgICAgZWxzZQogICAgICAgIHsKICAgICAgICAgICAgTFBXU1RSIHRleHQ7CiAgICAgICAgICAgIC8qIEl0ZW0gYmVnaW5uaW5nIHdpdGggYSBiYWNrc3BhY2UgaXMgYSBoZWxwIGl0ZW0gKi8KICAgICAgICAgICAgaWYgKCpzdHIgPT0gJ1xiJykKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgZmxhZ3MgfD0gTUZfSEVMUDsKICAgICAgICAgICAgICAgIHN0cisrOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGlmICghKHRleHQgPSBIZWFwQWxsb2MoIEdldFByb2Nlc3NIZWFwKCksIDAsIChzdHJsZW5XKHN0cikrMSkgKiBzaXplb2YoV0NIQVIpICkpKQogICAgICAgICAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgICAgICAgICBzdHJjcHlXKCB0ZXh0LCBzdHIgKTsKICAgICAgICAgICAgaXRlbS0+dGV4dCA9IHRleHQ7CiAgICAgICAgfQogICAgICAgIGl0ZW0tPmhibXBJdGVtID0gTlVMTDsKICAgICAgICBIZWFwRnJlZSggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgcHJldlRleHQgKTsKICAgIH0KICAgIGVsc2UgaWYoKCBmbGFncyAmIE1GVF9CSVRNQVApKSB7CiAgICAgICAgaXRlbS0+aGJtcEl0ZW0gPSBIQklUTUFQXzMyKExPV09SRChzdHIpKTsKICAgICAgICAvKiBzZXR0aW5nIGJpdG1hcCBjbGVhcnMgdGV4dCAqLwogICAgICAgIEhlYXBGcmVlKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBpdGVtLT50ZXh0ICk7CiAgICAgICAgaXRlbS0+dGV4dCA9IE5VTEw7CiAgICB9CgogICAgaWYgKGZsYWdzICYgTUZfU0VQQVJBVE9SKSBmbGFncyB8PSBNRl9HUkFZRUQgfCBNRl9ESVNBQkxFRDsKCiAgICBpZiAoZmxhZ3MgJiBNRl9PV05FUkRSQVcpCiAgICAgICAgaXRlbS0+ZHdJdGVtRGF0YSA9IChEV09SRF9QVFIpc3RyOwogICAgZWxzZQogICAgICAgIGl0ZW0tPmR3SXRlbURhdGEgPSAwOwoKICAgIGlmICgoaXRlbS0+ZlR5cGUgJiBNRl9QT1BVUCkgJiYgKGZsYWdzICYgTUZfUE9QVVApICYmIChpdGVtLT5oU3ViTWVudSAhPSAoSE1FTlUpaWQpICkKCURlc3Ryb3lNZW51KCBpdGVtLT5oU3ViTWVudSApOyAgIC8qIE1vZGlmeU1lbnUoKSBzcGVjICovCgogICAgaWYgKGZsYWdzICYgTUZfUE9QVVApCiAgICB7CglQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoKEhNRU5VKWlkKTsKICAgICAgICBpZiAobWVudSkgbWVudS0+d0ZsYWdzIHw9IE1GX1BPUFVQOwoJZWxzZQogICAgICAgIHsKICAgICAgICAgICAgaXRlbS0+d0lEID0gMDsKICAgICAgICAgICAgaXRlbS0+aFN1Yk1lbnUgPSAwOwogICAgICAgICAgICBpdGVtLT5mVHlwZSA9IDA7CiAgICAgICAgICAgIGl0ZW0tPmZTdGF0ZSA9IDA7CgkgICAgcmV0dXJuIEZBTFNFOwogICAgICAgIH0KICAgIH0KCiAgICBpdGVtLT53SUQgPSBpZDsKICAgIGlmIChmbGFncyAmIE1GX1BPUFVQKSBpdGVtLT5oU3ViTWVudSA9IChITUVOVSlpZDsKCiAgICBpZiAoKGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApICYmICEoZmxhZ3MgJiBNRl9QT1BVUCkgKQogICAgICBmbGFncyB8PSBNRl9QT1BVUDsgLyoga2VlcCBwb3B1cCAqLwoKICAgIGl0ZW0tPmZUeXBlID0gZmxhZ3MgJiBUWVBFX01BU0s7CiAgICAvKiBNRlNfREVGQVVMVCBpcyBub3QgYWNjZXB0ZWQuIE1GX0hJTElURSBpcyBub3QgbGlzdGVkIGFzIGEgdmFsaWQgZmxhZwogICAgICAgZm9yIE1vZGlmeU1lbnUsIGJ1dCBXaW5kb3dzIGFjY2VwdHMgaXQgKi8KICAgIGl0ZW0tPmZTdGF0ZSA9IGZsYWdzICYgTUVOVUlURU1JTkZPX1NUQVRFX01BU0sgJiB+TUZTX0RFRkFVTFQ7CgogICAgLyogRG9uJ3QgY2FsbCBTZXRSZWN0RW1wdHkgaGVyZSEgKi8KCiAgICBkZWJ1Z19wcmludF9tZW51aXRlbSgiTUVOVV9TZXRJdGVtRGF0YSB0byAgOiAiLCBpdGVtLCAiIik7CiAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgTUVOVV9JbnNlcnRJdGVtCiAqCiAqIEluc2VydCAoYWxsb2NhdGUpIGEgbmV3IGl0ZW0gaW50byBhIG1lbnUuCiAqLwpzdGF0aWMgTUVOVUlURU0gKk1FTlVfSW5zZXJ0SXRlbSggSE1FTlUgaE1lbnUsIFVJTlQgcG9zLCBVSU5UIGZsYWdzICkKewogICAgTUVOVUlURU0gKm5ld0l0ZW1zOwogICAgUE9QVVBNRU5VICptZW51OwoKICAgIGlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpKSkKICAgICAgICByZXR1cm4gTlVMTDsKCiAgICAvKiBGaW5kIHdoZXJlIHRvIGluc2VydCBuZXcgaXRlbSAqLwoKICAgIGlmIChmbGFncyAmIE1GX0JZUE9TSVRJT04pIHsKICAgICAgICBpZiAocG9zID4gbWVudS0+bkl0ZW1zKQogICAgICAgICAgICBwb3MgPSBtZW51LT5uSXRlbXM7CiAgICB9IGVsc2UgewogICAgICAgIGlmICghTUVOVV9GaW5kSXRlbSggJmhNZW51LCAmcG9zLCBmbGFncyApKQogICAgICAgICAgICBwb3MgPSBtZW51LT5uSXRlbXM7CiAgICAgICAgZWxzZSB7CiAgICAgICAgICAgIGlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoIGhNZW51ICkpKQogICAgICAgICAgICAgICAgcmV0dXJuIE5VTEw7CiAgICAgICAgfQogICAgfQoKICAgIC8qIE1ha2Ugc3VyZSB0aGF0IE1ESSBzeXN0ZW0gYnV0dG9ucyBzdGF5IG9uIHRoZSByaWdodCBzaWRlLgogICAgICogTm90ZTogWFAgdHJlYXRzIG9ubHkgYml0bWFwIGhhbmRsZXMgMSAtIDYgYXMgIm1hZ2ljIiBvbmVzCiAgICAgKiByZWdhcmRsZXNzIG9mIHRoZWlyIGlkLgogICAgICovCiAgICB3aGlsZSAocG9zID4gMCAmJiAobWVudS0+aXRlbXNbcG9zIC0gMV0uZlR5cGUgJiBNRlRfQklUTUFQKSAmJgogICAgICAgICAgIChJTlRfUFRSKW1lbnUtPml0ZW1zW3BvcyAtIDFdLmhibXBJdGVtID49IChJTlRfUFRSKUhCTU1FTlVfU1lTVEVNICYmCiAgICAgICAgICAgKElOVF9QVFIpbWVudS0+aXRlbXNbcG9zIC0gMV0uaGJtcEl0ZW0gPD0gKElOVF9QVFIpSEJNTUVOVV9NQkFSX0NMT1NFX0QpCiAgICAgICAgcG9zLS07CgogICAgVFJBQ0UoImluc2VydGluZyBhdCAldSBieSBwb3MgJXVcbiIsIHBvcywgZmxhZ3MgJiBNRl9CWVBPU0lUSU9OKTsKCiAgICAvKiBDcmVhdGUgbmV3IGl0ZW1zIGFycmF5ICovCgogICAgbmV3SXRlbXMgPSBIZWFwQWxsb2MoIEdldFByb2Nlc3NIZWFwKCksIDAsIHNpemVvZihNRU5VSVRFTSkgKiAobWVudS0+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+aXRlbXNbaXRlbV0uaFN1Yk1lbnUsIHB0KSA6IDA7CgogICBpZiAoIXJldCkgIC8qIGNoZWNrIHRoZSBjdXJyZW50IHdpbmRvdyAoYXZvaWRpbmcgV01fSElUVEVTVCkgKi8KICAgewogICAgICAgSU5UIGh0ID0gTkNfSGFuZGxlTkNIaXRUZXN0KCBtZW51LT5oV25kLCBwdCApOwogICAgICAgaWYoIG1lbnUtPndGbGFncyAmIE1GX1BPUFVQICkKICAgICAgIHsKICAgICAgICAgICBpZiAoaHQgIT0gSFROT1dIRVJFICYmIGh0ICE9IEhURVJST1IpIHJldCA9IGhNZW51OwogICAgICAgfQogICAgICAgZWxzZSBpZiAoaHQgPT0gSFRTWVNNRU5VKQogICAgICAgICAgIHJldCA9IGdldF93aW5fc3lzX21lbnUoIG1lbnUtPmhXbmQgKTsKICAgICAgIGVsc2UgaWYgKGh0ID09IEhUTUVOVSkKICAgICAgICAgICByZXQgPSBHZXRNZW51KCBtZW51LT5oV25kICk7CiAgIH0KICAgcmV0dXJuIHJldDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0V4ZWNGb2N1c2VkSXRlbQogKgogKiBFeGVjdXRlIGEgbWVudSBpdGVtIChmb3IgaW5zdGFuY2Ugd2hlbiB1c2VyIHByZXNzZWQgRW50ZXIpLgogKiBSZXR1cm4gdGhlIHdJRCBvZiB0aGUgZXhlY3V0ZWQgaXRlbS4gT3RoZXJ3aXNlLCAtMSBpbmRpY2F0aW5nCiAqIHRoYXQgbm8gbWVudSBpdGVtIHdhcyBleGVjdXRlZCwgLTIgaWYgYSBwb3B1cCBpcyBzaG93bjsKICogSGF2ZSB0byByZWNlaXZlIHRoZSBmbGFncyBmb3IgdGhlIFRyYWNrUG9wdXBNZW51IG9wdGlvbnMgdG8gYXZvaWQKICogc2VuZGluZyB1bndhbnRlZCBtZXNzYWdlLgogKgogKi8Kc3RhdGljIElOVCBNRU5VX0V4ZWNGb2N1c2VkSXRlbSggTVRSQUNLRVIqIHBtdCwgSE1FTlUgaE1lbnUsIFVJTlQgd0ZsYWdzICkKewogICAgTUVOVUlURU0gKml0ZW07CiAgICBQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoIGhNZW51ICk7CgogICAgVFJBQ0UoIiVwIGhtZW51PSVwXG4iLCBwbXQsIGhNZW51KTsKCiAgICBpZiAoIW1lbnUgfHwgIW1lbnUtPm5JdGVtcyB8fAoJKG1lbnUtPkZvY3VzZWRJdGVtID09IE5PX1NFTEVDVEVEX0lURU0pKSByZXR1cm4gLTE7CgogICAgaXRlbSA9ICZtZW51LT5pdGVtc1ttZW51LT5Gb2N1c2VkSXRlbV07CgogICAgVFJBQ0UoImhNZW51ICVwIHdJRCAlMDhseCBoU3ViTWVudSAlcCBmVHlwZSAlMDR4XG4iLCBoTWVudSwgaXRlbS0+d0lELCBpdGVtLT5oU3ViTWVudSwgaXRlbS0+ZlR5cGUpOwoKICAgIGlmICghKGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApKQogICAgewoJaWYgKCEoaXRlbS0+ZlN0YXRlICYgKE1GX0dSQVlFRCB8IE1GX0RJU0FCTEVEKSkgJiYgIShpdGVtLT5mVHlwZSAmIE1GX1NFUEFSQVRPUikpCgl7CgkgICAgLyogSWYgVFBNX1JFVFVSTkNNRCBpcyBzZXQgeW91IHJldHVybiB0aGUgaWQsIGJ1dAoJICAgICAgIGRvIG5vdCBzZW5kIGEgbWVzc2FnZSB0byB0aGUgb3duZXIgKi8KCSAgICBpZighKHdGbGFncyAmIFRQTV9SRVRVUk5DTUQpKQoJICAgIHsKCQlpZiggbWVudS0+d0ZsYWdzICYgTUZfU1lTTUVOVSApCgkJICAgIFBvc3RNZXNzYWdlVyggcG10LT5oT3duZXJXbmQsIFdNX1NZU0NPTU1BTkQsIGl0ZW0tPndJRCwKCQkJCSAgTUFLRUxQQVJBTSgoSU5UMTYpcG10LT5wdC54LCAoSU5UMTYpcG10LT5wdC55KSApOwoJCWVsc2UKCQl7CiAgICAgICAgICAgICAgICAgICAgaWYgKG1lbnUtPmR3U3R5bGUgJiBNTlNfTk9USUZZQllQT1MpCiAgICAgICAgICAgICAgICAgICAgICAgIFBvc3RNZXNzYWdlVyggcG10LT5oT3duZXJXbmQsIFdNX01FTlVDT01NQU5ELCBtZW51LT5Gb2N1c2VkSXRlbSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAoTFBBUkFNKWhNZW51KTsKICAgICAgICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICAgICAgICAgIFBvc3RNZXNzYWdlVyggcG10LT5oT3duZXJXbmQsIFdNX0NPTU1BTkQsIGl0ZW0tPndJRCwgMCApOwoJCX0KCSAgICB9CgkgICAgcmV0dXJuIGl0ZW0tPndJRDsKCX0KICAgIH0KICAgIGVsc2UKICAgIHsKCXBtdC0+aEN1cnJlbnRNZW51ID0gTUVOVV9TaG93U3ViUG9wdXAocG10LT5oT3duZXJXbmQsIGhNZW51LCBUUlVFLCB3RmxhZ3MpOwoJcmV0dXJuIC0yOwogICAgfQoKICAgIHJldHVybiAtMTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX1N3aXRjaFRyYWNraW5nCiAqCiAqIEhlbHBlciBmdW5jdGlvbiBmb3IgbWVudSBuYXZpZ2F0aW9uIHJvdXRpbmVzLgogKi8Kc3RhdGljIHZvaWQgTUVOVV9Td2l0Y2hUcmFja2luZyggTVRSQUNLRVIqIHBtdCwgSE1FTlUgaFB0TWVudSwgVUlOVCBpZCApCnsKICAgIFBPUFVQTUVOVSAqcHRtZW51ID0gTUVOVV9HZXRNZW51KCBoUHRNZW51ICk7CiAgICBQT1BVUE1FTlUgKnRvcG1lbnUgPSBNRU5VX0dldE1lbnUoIHBtdC0+aFRvcE1lbnUgKTsKCiAgICBUUkFDRSgiJXAgaG1lbnU9JXAgMHglMDR4XG4iLCBwbXQsIGhQdE1lbnUsIGlkKTsKCiAgICBpZiggcG10LT5oVG9wTWVudSAhPSBoUHRNZW51ICYmCgkhKChwdG1lbnUtPndGbGFncyB8IHRvcG1lbnUtPndGbGFncykgJiBNRl9QT1BVUCkgKQogICAgewoJLyogYm90aCBhcmUgdG9wIGxldmVsIG1lbnVzIChzeXN0ZW0gYW5kIG1lbnUtYmFyKSAqLwoJTUVOVV9IaWRlU3ViUG9wdXBzKCBwbXQtPmhPd25lclduZCwgcG10LT5oVG9wTWVudSwgRkFMU0UgKTsKCU1FTlVfU2VsZWN0SXRlbSggcG10LT5oT3duZXJXbmQsIHBtdC0+aFRvcE1lbnUsIE5PX1NFTEVDVEVEX0lURU0sIEZBTFNFLCAwICk7CiAgICAgICAgcG10LT5oVG9wTWVudSA9IGhQdE1lbnU7CiAgICB9CiAgICBlbHNlIE1FTlVfSGlkZVN1YlBvcHVwcyggcG10LT5oT3duZXJXbmQsIGhQdE1lbnUsIEZBTFNFICk7CiAgICBNRU5VX1NlbGVjdEl0ZW0oIHBtdC0+aE93bmVyV25kLCBoUHRNZW51LCBpZCwgVFJVRSwgMCApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0J1dHRvbkRvd24KICoKICogUmV0dXJuIFRSVUUgaWYgd2UgY2FuIGdvIG9uIHdpdGggbWVudSB0cmFja2luZy4KICovCnN0YXRpYyBCT09MIE1FTlVfQnV0dG9uRG93biggTVRSQUNLRVIqIHBtdCwgSE1FTlUgaFB0TWVudSwgVUlOVCB3RmxhZ3MgKQp7CiAgICBUUkFDRSgiJXAgaFB0TWVudT0lcFxuIiwgcG10LCBoUHRNZW51KTsKCiAgICBpZiAoaFB0TWVudSkKICAgIHsKCVVJTlQgaWQgPSAwOwoJUE9QVVBNRU5VICpwdG1lbnUgPSBNRU5VX0dldE1lbnUoIGhQdE1lbnUgKTsKCU1FTlVJVEVNICppdGVtOwoKCWlmKCBJU19TWVNURU1fTUVOVShwdG1lbnUpICkKCSAgICBpdGVtID0gcHRtZW51LT5pdGVtczsKCWVsc2UKCSAgICBpdGVtID0gTUVOVV9GaW5kSXRlbUJ5Q29vcmRzKCBwdG1lbnUsIHBtdC0+cHQsICZpZCApOwoKCWlmKCBpdGVtICkKCXsKCSAgICBpZiggcHRtZW51LT5Gb2N1c2VkSXRlbSAhPSBpZCApCgkJTUVOVV9Td2l0Y2hUcmFja2luZyggcG10LCBoUHRNZW51LCBpZCApOwoKCSAgICAvKiBJZiB0aGUgcG9wdXAgbWVudSBpcyBub3QgYWxyZWFkeSAicG9wcGVkIiAqLwoJICAgIGlmKCEoaXRlbS0+ZlN0YXRlICYgTUZfTU9VU0VTRUxFQ1QgKSkKCSAgICB7CgkJcG10LT5oQ3VycmVudE1lbnUgPSBNRU5VX1Nob3dTdWJQb3B1cCggcG10LT5oT3duZXJXbmQsIGhQdE1lbnUsIEZBTFNFLCB3RmxhZ3MgKTsKCSAgICB9CgoJICAgIHJldHVybiBUUlVFOwoJfQoJLyogRWxzZSB0aGUgY2xpY2sgd2FzIG9uIHRoZSBtZW51IGJhciwgZmluaXNoIHRoZSB0cmFja2luZyAqLwogICAgfQogICAgcmV0dXJuIEZBTFNFOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfQnV0dG9uVXAKICoKICogUmV0dXJuIHRoZSB2YWx1ZSBvZiBNRU5VX0V4ZWNGb2N1c2VkSXRlbSBpZgogKiB0aGUgc2VsZWN0ZWQgaXRlbSB3YXMgbm90IGEgcG9wdXAuIEVsc2Ugb3BlbiB0aGUgcG9wdXAuCiAqIEEgLTEgcmV0dXJuIHZhbHVlIGluZGljYXRlcyB0aGF0IHdlIGdvIG9uIHdpdGggbWVudSB0cmFja2luZy4KICoKICovCnN0YXRpYyBJTlQgTUVOVV9CdXR0b25VcCggTVRSQUNLRVIqIHBtdCwgSE1FTlUgaFB0TWVudSwgVUlOVCB3RmxhZ3MpCnsKICAgIFRSQUNFKCIlcCBobWVudT0lcFxuIiwgcG10LCBoUHRNZW51KTsKCiAgICBpZiAoaFB0TWVudSkKICAgIHsKCVVJTlQgaWQgPSAwOwoJUE9QVVBNRU5VICpwdG1lbnUgPSBNRU5VX0dldE1lbnUoIGhQdE1lbnUgKTsKCU1FTlVJVEVNICppdGVtOwoKICAgICAgICBpZiggSVNfU1lTVEVNX01FTlUocHRtZW51KSApCiAgICAgICAgICAgIGl0ZW0gPSBwdG1lbnUtPml0ZW1zOwogICAgICAgIGVsc2UKICAgICAgICAgICAgaXRlbSA9IE1FTlVfRmluZEl0ZW1CeUNvb3JkcyggcHRtZW51LCBwbXQtPnB0LCAmaWQgKTsKCglpZiggaXRlbSAmJiAocHRtZW51LT5Gb2N1c2VkSXRlbSA9PSBpZCApKQoJewogICAgICAgICAgICBkZWJ1Z19wcmludF9tZW51aXRlbSAoIkZvY3VzZWRJdGVtOiAiLCBpdGVtLCAiIik7CgoJICAgIGlmKCAhKGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApICkKCSAgICB7CgkgICAgICAgIElOVCBleGVjdXRlZE1lbnVJZCA9IE1FTlVfRXhlY0ZvY3VzZWRJdGVtKCBwbXQsIGhQdE1lbnUsIHdGbGFncyk7CiAgICAgICAgICAgICAgICBpZiAoZXhlY3V0ZWRNZW51SWQgPT0gLTEgfHwgZXhlY3V0ZWRNZW51SWQgPT0gLTIpIHJldHVybiAtMTsKICAgICAgICAgICAgICAgIHJldHVybiBleGVjdXRlZE1lbnVJZDsKCSAgICB9CgoJICAgIC8qIElmIHdlIGFyZSBkZWFsaW5nIHdpdGggdGhlIHRvcC1sZXZlbCBtZW51ICAgICAgICAgICAgKi8KCSAgICAvKiBhbmQgdGhpcyBpcyBhIGNsaWNrIG9uIGFuIGFscmVhZHkgInBvcHBlZCIgaXRlbTogICAgICovCgkgICAgLyogU3RvcCB0aGUgbWVudSB0cmFja2luZyBhbmQgY2xvc2UgdGhlIG9wZW5lZCBzdWJtZW51cyAqLwoJICAgIGlmKChwbXQtPmhUb3BNZW51ID09IGhQdE1lbnUpICYmIHB0bWVudS0+YlRpbWVUb0hpZGUpCgkJcmV0dXJuIDA7Cgl9CglwdG1lbnUtPmJUaW1lVG9IaWRlID0gVFJVRTsKICAgIH0KICAgIHJldHVybiAtMTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9Nb3VzZU1vdmUKICoKICogUmV0dXJuIFRSVUUgaWYgd2UgY2FuIGdvIG9uIHdpdGggbWVudSB0cmFja2luZy4KICovCnN0YXRpYyBCT09MIE1FTlVfTW91c2VNb3ZlKCBNVFJBQ0tFUiogcG10LCBITUVOVSBoUHRNZW51LCBVSU5UIHdGbGFncyApCnsKICAgIFVJTlQgaWQgPSBOT19TRUxFQ1RFRF9JVEVNOwogICAgUE9QVVBNRU5VICpwdG1lbnUgPSBOVUxMOwoKICAgIGlmKCBoUHRNZW51ICkKICAgIHsKCXB0bWVudSA9IE1FTlVfR2V0TWVudSggaFB0TWVudSApOwogICAgICAgIGlmKCBJU19TWVNURU1fTUVOVShwdG1lbnUpICkKCSAgICBpZCA9IDA7CiAgICAgICAgZWxzZQogICAgICAgICAgICBNRU5VX0ZpbmRJdGVtQnlDb29yZHMoIHB0bWVudSwgcG10LT5wdCwgJmlkICk7CiAgICB9CgogICAgaWYoIGlkID09IE5PX1NFTEVDVEVEX0lURU0gKQogICAgewoJTUVOVV9TZWxlY3RJdGVtKCBwbXQtPmhPd25lclduZCwgcG10LT5oQ3VycmVudE1lbnUsCgkJCSBOT19TRUxFQ1RFRF9JVEVNLCBUUlVFLCBwbXQtPmhUb3BNZW51KTsKCiAgICB9CiAgICBlbHNlIGlmKCBwdG1lbnUtPkZvY3VzZWRJdGVtICE9IGlkICkKICAgIHsKCSAgICBNRU5VX1N3aXRjaFRyYWNraW5nKCBwbXQsIGhQdE1lbnUsIGlkICk7CgkgICAgcG10LT5oQ3VycmVudE1lbnUgPSBNRU5VX1Nob3dTdWJQb3B1cChwbXQtPmhPd25lclduZCwgaFB0TWVudSwgRkFMU0UsIHdGbGFncyk7CiAgICB9CiAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9Eb05leHRNZW51CiAqCiAqIE5PVEU6IFdNX05FWFRNRU5VIGRvY3VtZW50ZWQgaW4gV2luMzIgaXMgYSBiaXQgZGlmZmVyZW50LgogKi8Kc3RhdGljIExSRVNVTFQgTUVOVV9Eb05leHRNZW51KCBNVFJBQ0tFUiogcG10LCBVSU5UIHZrICkKewogICAgUE9QVVBNRU5VICptZW51ID0gTUVOVV9HZXRNZW51KCBwbXQtPmhUb3BNZW51ICk7CiAgICBCT09MIGF0RW5kID0gRkFMU0U7CgogICAgLyogV2hlbiBza2lwcGluZyBsZWZ0LCB3ZSBuZWVkIHRvIGRvIHNvbWV0aGluZyBzcGVjaWFsIGFmdGVyIHRoZQogICAgICAgZmlyc3QgbWVudS4gICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICovCiAgICBpZiAodmsgPT0gVktfTEVGVCAmJiBtZW51LT5Gb2N1c2VkSXRlbSA9PSAwKQogICAgewogICAgICAgIGF0RW5kID0gVFJVRTsKICAgIH0KICAgIC8qIFdoZW4gc2tpcHBpbmcgcmlnaHQsIGZvciB0aGUgbm9uLXN5c3RlbSBtZW51LCB3ZSBuZWVkIHRvCiAgICAgICBoYW5kbGUgdGhlIGxhc3Qgbm9uLXNwZWNpYWwgbWVudSBpdGVtIChpZSBza2lwIGFueSB3aW5kb3cKICAgICAgIGljb25zIHN1Y2ggYXMgTURJIG1heGltaXplLCByZXN0b3JlIG9yIGNsb3NlKSAgICAgICAgICAgICAqLwogICAgZWxzZSBpZiAoKHZrID09IFZLX1JJR0hUKSAmJiAhSVNfU1lTVEVNX01FTlUobWVudSkpCiAgICB7CiAgICAgICAgaW50IGkgPSBtZW51LT5Gb2N1c2VkSXRlbSArIDE7CiAgICAgICAgd2hpbGUgKGkgPCBtZW51LT5uSXRlbXMpIHsKICAgICAgICAgICAgaWYgKChtZW51LT5pdGVtc1tpXS53SUQgPj0gU0NfU0laRSAmJgogICAgICAgICAgICAgICAgIG1lbnUtPml0ZW1zW2ldLndJRCA8PSBTQ19SRVNUT1JFKSkgewogICAgICAgICAgICAgICAgaSsrOwogICAgICAgICAgICB9IGVsc2UgYnJlYWs7CiAgICAgICAgfQogICAgICAgIGlmIChpID09IG1lbnUtPm5JdGVtcykgewogICAgICAgICAgICBhdEVuZCA9IFRSVUU7CiAgICAgICAgfQogICAgfQogICAgLyogV2hlbiBza2lwcGluZyByaWdodCwgd2UgbmVlZCB0byBjYXRlciBmb3IgdGhlIHN5c3RlbSBtZW51ICovCiAgICBlbHNlIGlmICgodmsgPT0gVktfUklHSFQpICYmIElTX1NZU1RFTV9NRU5VKG1lbnUpKQogICAgewogICAgICAgIGlmIChtZW51LT5Gb2N1c2VkSXRlbSA9PSAobWVudS0+bkl0ZW1zIC0gMSkpIHsKICAgICAgICAgICAgYXRFbmQgPSBUUlVFOwogICAgICAgIH0KICAgIH0KCiAgICBpZiggYXRFbmQgKQogICAgewogICAgICAgIE1ESU5FWFRNRU5VIG5leHRfbWVudTsKCUhNRU5VIGhOZXdNZW51OwoJSFdORCAgaE5ld1duZDsKCVVJTlQgIGlkID0gMDsKCiAgICAgICAgbmV4dF9tZW51LmhtZW51SW4gPSAoSVNfU1lTVEVNX01FTlUobWVudSkpID8gR2V0U3ViTWVudShwbXQtPmhUb3BNZW51LDApIDogcG10LT5oVG9wTWVudTsKICAgICAgICBuZXh0X21lbnUuaG1lbnVOZXh0ID0gMDsKICAgICAgICBuZXh0X21lbnUuaHduZE5leHQgPSAwOwogICAgICAgIFNlbmRNZXNzYWdlVyggcG10LT5oT3duZXJXbmQsIFdNX05FWFRNRU5VLCB2aywgKExQQVJBTSkmbmV4dF9tZW51ICk7CgogICAgICAgIFRSQUNFKCIlcCBbJXBdIC0+ICVwIFslcF1cbiIsCiAgICAgICAgICAgICAgcG10LT5oQ3VycmVudE1lbnUsIHBtdC0+aE93bmVyV25kLCBuZXh0X21lbnUuaG1lbnVOZXh0LCBuZXh0X21lbnUuaHduZE5leHQgKTsKCglpZiAoIW5leHRfbWVudS5obWVudU5leHQgfHwgIW5leHRfbWVudS5od25kTmV4dCkKCXsKICAgICAgICAgICAgRFdPUkQgc3R5bGUgPSBHZXRXaW5kb3dMb25nVyggcG10LT5oT3duZXJXbmQsIEdXTF9TVFlMRSApOwoJICAgIGhOZXdXbmQgPSBwbXQtPmhPd25lclduZDsKCSAgICBpZiggSVNfU1lTVEVNX01FTlUobWVudSkgKQoJICAgIHsKCQkvKiBzd2l0Y2ggdG8gdGhlIG1lbnUgYmFyICovCgogICAgICAgICAgICAgICAgaWYoc3R5bGUgJiBXU19DSElMRCB8fCAhKGhOZXdNZW51ID0gR2V0TWVudShoTmV3V25kKSkpIHJldHVybiBGQUxTRTsKCgkgICAgICAgIGlmKCB2ayA9PSBWS19MRUZUICkKCSAgICAgICAgewoJCSAgICBtZW51ID0gTUVOVV9HZXRNZW51KCBoTmV3TWVudSApOwoJCSAgICBpZCA9IG1lbnUtPm5JdGVtcyAtIDE7CgogICAgICAgICAgICAgICAgICAgIC8qIFNraXAgYmFja3dhcmRzIG92ZXIgYW55IHN5c3RlbSBwcmVkZWZpbmVkIGljb25zLAogICAgICAgICAgICAgICAgICAgICAgIGVnLiBNREkgY2xvc2UsIHJlc3RvcmUgZXRjIGljb25zICAgICAgICAgICAgICAgICAqLwogICAgICAgICAgICAgICAgICAgIHdoaWxlICgoaWQgPiAwKSAmJgogICAgICAgICAgICAgICAgICAgICAgICAgICAobWVudS0+aXRlbXNbaWRdLndJRCA+PSBTQ19TSVpFICYmCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBtZW51LT5pdGVtc1tpZF0ud0lEIDw9IFNDX1JFU1RPUkUpKSBpZC0tOwoJICAgICAgICB9CgkgICAgfQoJICAgIGVsc2UgaWYgKHN0eWxlICYgV1NfU1lTTUVOVSApCgkgICAgewoJCS8qIHN3aXRjaCB0byB0aGUgc3lzdGVtIG1lbnUgKi8KCSAgICAgICAgaE5ld01lbnUgPSBnZXRfd2luX3N5c19tZW51KCBoTmV3V25kICk7CgkgICAgfQogICAgICAgICAgICBlbHNlIHJldHVybiBGQUxTRTsKCX0KCWVsc2UgICAgLyogYXBwbGljYXRpb24gcmV0dXJuZWQgYSBuZXcgbWVudSB0byBzd2l0Y2ggdG8gKi8KCXsKICAgICAgICAgICAgaE5ld01lbnUgPSBuZXh0X21lbnUuaG1lbnVOZXh0OwogICAgICAgICAgICBoTmV3V25kID0gV0lOX0dldEZ1bGxIYW5kbGUoIG5leHRfbWVudS5od25kTmV4dCApOwoKCSAgICBpZiggSXNNZW51KGhOZXdNZW51KSAmJiBJc1dpbmRvdyhoTmV3V25kKSApCgkgICAgewogICAgICAgICAgICAgICAgRFdPUkQgc3R5bGUgPSBHZXRXaW5kb3dMb25nVyggaE5ld1duZCwgR1dMX1NUWUxFICk7CgoJCWlmIChzdHlsZSAmIFdTX1NZU01FTlUgJiYKCQkgICAgR2V0U3ViTWVudShnZXRfd2luX3N5c19tZW51KGhOZXdXbmQpLCAwKSA9PSBoTmV3TWVudSApCgkJewoJICAgICAgICAgICAgLyogZ2V0IHRoZSByZWFsIHN5c3RlbSBtZW51ICovCgkJICAgIGhOZXdNZW51ID0gIGdldF93aW5fc3lzX21lbnUoaE5ld1duZCk7CgkJfQoJICAgICAgICBlbHNlIGlmIChzdHlsZSAmIFdTX0NISUxEIHx8IEdldE1lbnUoaE5ld1duZCkgIT0gaE5ld01lbnUgKQoJCXsKCQkgICAgLyogRklYTUU6IE5vdCBzdXJlIHdoYXQgdG8gZG8gaGVyZTsKCQkgICAgICogcGVyaGFwcyB0cnkgdG8gdHJhY2sgaE5ld01lbnUgYXMgYSBwb3B1cD8gKi8KCgkJICAgIFRSQUNFKCIgLS0gZ290IGNvbmZ1c2VkLlxuIik7CgkJICAgIHJldHVybiBGQUxTRTsKCQl9CgkgICAgfQoJICAgIGVsc2UgcmV0dXJuIEZBTFNFOwoJfQoKCWlmKCBoTmV3TWVudSAhPSBwbXQtPmhUb3BNZW51ICkKCXsKCSAgICBNRU5VX1NlbGVjdEl0ZW0oIHBtdC0+aE93bmVyV25kLCBwbXQtPmhUb3BNZW51LCBOT19TRUxFQ1RFRF9JVEVNLAogICAgICAgICAgICAgICAgICAgIEZBTFNFLCAwICk7CgkgICAgaWYoIHBtdC0+aEN1cnJlbnRNZW51ICE9IHBtdC0+aFRvcE1lbnUgKQoJCU1FTlVfSGlkZVN1YlBvcHVwcyggcG10LT5oT3duZXJXbmQsIHBtdC0+aFRvcE1lbnUsIEZBTFNFICk7Cgl9CgoJaWYoIGhOZXdXbmQgIT0gcG10LT5oT3duZXJXbmQgKQoJewoJICAgIHBtdC0+aE93bmVyV25kID0gaE5ld1duZDsKICAgICAgICAgICAgc2V0X2NhcHR1cmVfd2luZG93KCBwbXQtPmhPd25lclduZCwgR1VJX0lOTUVOVU1PREUsIE5VTEwgKTsKCX0KCglwbXQtPmhUb3BNZW51ID0gcG10LT5oQ3VycmVudE1lbnUgPSBoTmV3TWVudTsgLyogYWxsIHN1YnBvcHVwcyBhcmUgaGlkZGVuICovCglNRU5VX1NlbGVjdEl0ZW0oIHBtdC0+aE93bmVyV25kLCBwbXQtPmhUb3BNZW51LCBpZCwgVFJVRSwgMCApOwoKCXJldHVybiBUUlVFOwogICAgfQogICAgcmV0dXJuIEZBTFNFOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfU3VzcGVuZFBvcHVwCiAqCiAqIFRoZSBpZGVhIGlzIG5vdCB0byBzaG93IHRoZSBwb3B1cCBpZiB0aGUgbmV4dCBpbnB1dCBtZXNzYWdlIGlzCiAqIGdvaW5nIHRvIGhpZGUgaXQgYW55d2F5LgogKi8Kc3RhdGljIEJPT0wgTUVOVV9TdXNwZW5kUG9wdXAoIE1UUkFDS0VSKiBwbXQsIFVJTlQxNiB1TXNnICkKewogICAgTVNHIG1zZzsKCiAgICBtc2cuaHduZCA9IHBtdC0+aE93bmVyV25kOwoKICAgIFBlZWtNZXNzYWdlVyggJm1zZywgMCwgMCwgMCwgUE1fTk9ZSUVMRCB8IFBNX1JFTU9WRSk7CiAgICBwbXQtPnRyYWNrRmxhZ3MgfD0gVEZfU0tJUFJFTU9WRTsKCiAgICBzd2l0Y2goIHVNc2cgKQogICAgewoJY2FzZSBXTV9LRVlET1dOOgoJICAgICBQZWVrTWVzc2FnZVcoICZtc2csIDAsIDAsIDAsIFBNX05PWUlFTEQgfCBQTV9OT1JFTU9WRSk7CgkgICAgIGlmKCBtc2cubWVzc2FnZSA9PSBXTV9LRVlVUCB8fCBtc2cubWVzc2FnZSA9PSBXTV9QQUlOVCApCgkgICAgIHsKCQkgUGVla01lc3NhZ2VXKCAmbXNnLCAwLCAwLCAwLCBQTV9OT1lJRUxEIHwgUE1fUkVNT1ZFKTsKCSAgICAgICAgIFBlZWtNZXNzYWdlVyggJm1zZywgMCwgMCwgMCwgUE1fTk9ZSUVMRCB8IFBNX05PUkVNT1ZFKTsKCSAgICAgICAgIGlmKCBtc2cubWVzc2FnZSA9PSBXTV9LRVlET1dOICYmCgkJICAgIChtc2cud1BhcmFtID09IFZLX0xFRlQgfHwgbXNnLndQYXJhbSA9PSBWS19SSUdIVCkpCgkgICAgICAgICB7CgkJICAgICBwbXQtPnRyYWNrRmxhZ3MgfD0gVEZfU1VTUEVORFBPUFVQOwoJCSAgICAgcmV0dXJuIFRSVUU7CgkgICAgICAgICB9CgkgICAgIH0KCSAgICAgYnJlYWs7CiAgICB9CgogICAgLyogZmFpbHVyZXMgZ28gdGhyb3VnaCB0aGlzICovCiAgICBwbXQtPnRyYWNrRmxhZ3MgJj0gflRGX1NVU1BFTkRQT1BVUDsKICAgIHJldHVybiBGQUxTRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0tleUVzY2FwZQogKgogKiBIYW5kbGUgYSBWS19FU0NBUEUga2V5IGV2ZW50IGluIGEgbWVudS4KICovCnN0YXRpYyBCT09MIE1FTlVfS2V5RXNjYXBlKE1UUkFDS0VSKiBwbXQsIFVJTlQgd0ZsYWdzKQp7CiAgICBCT09MIGJFbmRNZW51ID0gVFJVRTsKCiAgICBpZiAocG10LT5oQ3VycmVudE1lbnUgIT0gcG10LT5oVG9wTWVudSkKICAgIHsKICAgICAgICBQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUocG10LT5oQ3VycmVudE1lbnUpOwoKICAgICAgICBpZiAobWVudS0+d0ZsYWdzICYgTUZfUE9QVVApCiAgICAgICAgewogICAgICAgICAgICBITUVOVSBobWVudXRtcCwgaG1lbnVwcmV2OwoKICAgICAgICAgICAgaG1lbnVwcmV2ID0gaG1lbnV0bXAgPSBwbXQtPmhUb3BNZW51OwoKICAgICAgICAgICAgLyogY2xvc2UgdG9wbW9zdCBwb3B1cCAqLwogICAgICAgICAgICB3aGlsZSAoaG1lbnV0bXAgIT0gcG10LT5oQ3VycmVudE1lbnUpCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIGhtZW51cHJldiA9IGhtZW51dG1wOwogICAgICAgICAgICAgICAgaG1lbnV0bXAgPSBNRU5VX0dldFN1YlBvcHVwKCBobWVudXByZXYgKTsKICAgICAgICAgICAgfQoKICAgICAgICAgICAgTUVOVV9IaWRlU3ViUG9wdXBzKCBwbXQtPmhPd25lclduZCwgaG1lbnVwcmV2LCBUUlVFICk7CiAgICAgICAgICAgIHBtdC0+aEN1cnJlbnRNZW51ID0gaG1lbnVwcmV2OwogICAgICAgICAgICBiRW5kTWVudSA9IEZBTFNFOwogICAgICAgIH0KICAgIH0KCiAgICByZXR1cm4gYkVuZE1lbnU7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9LZXlMZWZ0CiAqCiAqIEhhbmRsZSBhIFZLX0xFRlQga2V5IGV2ZW50IGluIGEgbWVudS4KICovCnN0YXRpYyB2b2lkIE1FTlVfS2V5TGVmdCggTVRSQUNLRVIqIHBtdCwgVUlOVCB3RmxhZ3MgKQp7CiAgICBQT1BVUE1FTlUgKm1lbnU7CiAgICBITUVOVSBobWVudXRtcCwgaG1lbnVwcmV2OwogICAgVUlOVCAgcHJldmNvbDsKCiAgICBobWVudXByZXYgPSBobWVudXRtcCA9IHBtdC0+aFRvcE1lbnU7CiAgICBtZW51ID0gTUVOVV9HZXRNZW51KCBobWVudXRtcCApOwoKICAgIC8qIFRyeSB0byBtb3ZlIDEgY29sdW1uIGxlZnQgKGlmIHBvc3NpYmxlKSAqLwogICAgaWYoIChwcmV2Y29sID0gTUVOVV9HZXRTdGFydE9mUHJldkNvbHVtbiggcG10LT5oQ3VycmVudE1lbnUgKSkgIT0KCU5PX1NFTEVDVEVEX0lURU0gKSB7CgoJTUVOVV9TZWxlY3RJdGVtKCBwbXQtPmhPd25lclduZCwgcG10LT5oQ3VycmVudE1lbnUsCgkJCSBwcmV2Y29sLCBUUlVFLCAwICk7CglyZXR1cm47CiAgICB9CgogICAgLyogY2xvc2UgdG9wbW9zdCBwb3B1cCAqLwogICAgd2hpbGUgKGhtZW51dG1wICE9IHBtdC0+aEN1cnJlbnRNZW51KQogICAgewoJaG1lbnVwcmV2ID0gaG1lbnV0bXA7CglobWVudXRtcCA9IE1FTlVfR2V0U3ViUG9wdXAoIGhtZW51cHJldiApOwogICAgfQoKICAgIE1FTlVfSGlkZVN1YlBvcHVwcyggcG10LT5oT3duZXJXbmQsIGhtZW51cHJldiwgVFJVRSApOwogICAgcG10LT5oQ3VycmVudE1lbnUgPSBobWVudXByZXY7CgogICAgaWYgKCAoaG1lbnVwcmV2ID09IHBtdC0+aFRvcE1lbnUpICYmICEobWVudS0+d0ZsYWdzICYgTUZfUE9QVVApICkKICAgIHsKCS8qIG1vdmUgbWVudSBiYXIgc2VsZWN0aW9uIGlmIG5vIG1vcmUgcG9wdXBzIGFyZSBsZWZ0ICovCgoJaWYoICFNRU5VX0RvTmV4dE1lbnUoIHBtdCwgVktfTEVGVCkgKQoJICAgICBNRU5VX01vdmVTZWxlY3Rpb24oIHBtdC0+aE93bmVyV25kLCBwbXQtPmhUb3BNZW51LCBJVEVNX1BSRVYgKTsKCglpZiAoIGhtZW51cHJldiAhPSBobWVudXRtcCB8fCBwbXQtPnRyYWNrRmxhZ3MgJiBURl9TVVNQRU5EUE9QVVAgKQoJewoJICAgLyogQSBzdWJsZXZlbCBtZW51IHdhcyBkaXNwbGF5ZWQgLSBkaXNwbGF5IHRoZSBuZXh0IG9uZQoJICAgICogdW5sZXNzIHRoZXJlIGlzIGFub3RoZXIgZGlzcGxhY2VtZW50IGNvbWluZyB1cCAqLwoKCSAgICBpZiggIU1FTlVfU3VzcGVuZFBvcHVwKCBwbXQsIFdNX0tFWURPV04gKSApCgkJcG10LT5oQ3VycmVudE1lbnUgPSBNRU5VX1Nob3dTdWJQb3B1cChwbXQtPmhPd25lclduZCwKCQkJCQkJcG10LT5oVG9wTWVudSwgVFJVRSwgd0ZsYWdzKTsKCX0KICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9LZXlSaWdodAogKgogKiBIYW5kbGUgYSBWS19SSUdIVCBrZXkgZXZlbnQgaW4gYSBtZW51LgogKi8Kc3RhdGljIHZvaWQgTUVOVV9LZXlSaWdodCggTVRSQUNLRVIqIHBtdCwgVUlOVCB3RmxhZ3MgKQp7CiAgICBITUVOVSBobWVudXRtcDsKICAgIFBPUFVQTUVOVSAqbWVudSA9IE1FTlVfR2V0TWVudSggcG10LT5oVG9wTWVudSApOwogICAgVUlOVCAgbmV4dGNvbDsKCiAgICBUUkFDRSgiTUVOVV9LZXlSaWdodCBjYWxsZWQsIGN1ciAlcCAoJXMpLCB0b3AgJXAgKCVzKS5cbiIsCiAgICAgICAgICBwbXQtPmhDdXJyZW50TWVudSwKICAgICAgICAgIGRlYnVnc3RyX3coKE1FTlVfR2V0TWVudShwbXQtPmhDdXJyZW50TWVudSkpLT5pdGVtc1swXS50ZXh0KSwKICAgICAgICAgIHBtdC0+aFRvcE1lbnUsIGRlYnVnc3RyX3cobWVudS0+aXRlbXNbMF0udGV4dCkgKTsKCiAgICBpZiAoIChtZW51LT53RmxhZ3MgJiBNRl9QT1BVUCkgfHwgKHBtdC0+aEN1cnJlbnRNZW51ICE9IHBtdC0+aFRvcE1lbnUpKQogICAgewoJLyogSWYgYWxyZWFkeSBkaXNwbGF5aW5nIGEgcG9wdXAsIHRyeSB0byBkaXNwbGF5IHN1Yi1wb3B1cCAqLwoKCWhtZW51dG1wID0gcG10LT5oQ3VycmVudE1lbnU7CglwbXQtPmhDdXJyZW50TWVudSA9IE1FTlVfU2hvd1N1YlBvcHVwKHBtdC0+aE93bmVyV25kLCBobWVudXRtcCwgVFJVRSwgd0ZsYWdzKTsKCgkvKiBpZiBzdWJwb3B1cCB3YXMgZGlzcGxheWVkIHRoZW4gd2UgYXJlIGRvbmUgKi8KCWlmIChobWVudXRtcCAhPSBwbXQtPmhDdXJyZW50TWVudSkgcmV0dXJuOwogICAgfQoKICAgIC8qIENoZWNrIHRvIHNlZSBpZiB0aGVyZSdzIGFub3RoZXIgY29sdW1uICovCiAgICBpZiggKG5leHRjb2wgPSBNRU5VX0dldFN0YXJ0T2ZOZXh0Q29sdW1uKCBwbXQtPmhDdXJyZW50TWVudSApKSAhPQoJTk9fU0VMRUNURURfSVRFTSApIHsKCVRSQUNFKCJHb2luZyB0byAlZC5cbiIsIG5leHRjb2wgKTsKCU1FTlVfU2VsZWN0SXRlbSggcG10LT5oT3duZXJXbmQsIHBtdC0+aEN1cnJlbnRNZW51LAoJCQkgbmV4dGNvbCwgVFJVRSwgMCApOwoJcmV0dXJuOwogICAgfQoKICAgIGlmICghKG1lbnUtPndGbGFncyAmIE1GX1BPUFVQKSkJLyogbWVudSBiYXIgdHJhY2tpbmcgKi8KICAgIHsKCWlmKCBwbXQtPmhDdXJyZW50TWVudSAhPSBwbXQtPmhUb3BNZW51ICkKCXsKCSAgICBNRU5VX0hpZGVTdWJQb3B1cHMoIHBtdC0+aE93bmVyV25kLCBwbXQtPmhUb3BNZW51LCBGQUxTRSApOwoJICAgIGhtZW51dG1wID0gcG10LT5oQ3VycmVudE1lbnUgPSBwbXQtPmhUb3BNZW51OwoJfSBlbHNlIGhtZW51dG1wID0gMDsKCgkvKiB0cnkgdG8gbW92ZSB0byB0aGUgbmV4dCBpdGVtICovCglpZiggIU1FTlVfRG9OZXh0TWVudSggcG10LCBWS19SSUdIVCkgKQoJICAgICBNRU5VX01vdmVTZWxlY3Rpb24oIHBtdC0+aE93bmVyV25kLCBwbXQtPmhUb3BNZW51LCBJVEVNX05FWFQgKTsKCglpZiggaG1lbnV0bXAgfHwgcG10LT50cmFja0ZsYWdzICYgVEZfU1VTUEVORFBPUFVQICkKCSAgICBpZiggIU1FTlVfU3VzcGVuZFBvcHVwKHBtdCwgV01fS0VZRE9XTikgKQoJCXBtdC0+aEN1cnJlbnRNZW51ID0gTUVOVV9TaG93U3ViUG9wdXAocG10LT5oT3duZXJXbmQsCgkJCQkJCSAgICAgICBwbXQtPmhUb3BNZW51LCBUUlVFLCB3RmxhZ3MpOwogICAgfQp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIE1FTlVfVHJhY2tNZW51CiAqCiAqIE1lbnUgdHJhY2tpbmcgY29kZS4KICovCnN0YXRpYyBCT09MIE1FTlVfVHJhY2tNZW51KCBITUVOVSBobWVudSwgVUlOVCB3RmxhZ3MsIElOVCB4LCBJTlQgeSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgIEhXTkQgaHduZCwgY29uc3QgUkVDVCAqbHByZWN0ICkKewogICAgTVNHIG1zZzsKICAgIFBPUFVQTUVOVSAqbWVudTsKICAgIEJPT0wgZlJlbW92ZTsKICAgIElOVCBleGVjdXRlZE1lbnVJZCA9IC0xOwogICAgTVRSQUNLRVIgbXQ7CiAgICBCT09MIGVudGVySWRsZVNlbnQgPSBGQUxTRTsKCiAgICBtdC50cmFja0ZsYWdzID0gMDsKICAgIG10LmhDdXJyZW50TWVudSA9IGhtZW51OwogICAgbXQuaFRvcE1lbnUgPSBobWVudTsKICAgIG10LmhPd25lclduZCA9IFdJTl9HZXRGdWxsSGFuZGxlKCBod25kICk7CiAgICBtdC5wdC54ID0geDsKICAgIG10LnB0LnkgPSB5OwoKICAgIFRSQUNFKCJobWVudT0lcCBmbGFncz0weCUwOHggKCVkLCVkKSBod25kPSVwICVzXG4iLAogICAgICAgICAgaG1lbnUsIHdGbGFncywgeCwgeSwgaHduZCwgd2luZV9kYmdzdHJfcmVjdCggbHByZWN0KSk7CgogICAgZkVuZE1lbnUgPSBGQUxTRTsKICAgIGlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoIGhtZW51ICkpKQogICAgewogICAgICAgIFdBUk4oIkludmFsaWQgbWVudSBoYW5kbGUgJXBcbiIsIGhtZW51KTsKICAgICAgICBTZXRMYXN0RXJyb3IoRVJST1JfSU5WQUxJRF9NRU5VX0hBTkRMRSk7CiAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgfQoKICAgIGlmICh3RmxhZ3MgJiBUUE1fQlVUVE9ORE9XTikKICAgIHsKCS8qIEdldCB0aGUgcmVzdWx0IGluIG9yZGVyIHRvIHN0YXJ0IHRoZSB0cmFja2luZyBvciBub3QgKi8KCWZSZW1vdmUgPSBNRU5VX0J1dHRvbkRvd24oICZtdCwgaG1lbnUsIHdGbGFncyApOwoJZkVuZE1lbnUgPSAhZlJlbW92ZTsKICAgIH0KCiAgICBpZiAod0ZsYWdzICYgVEZfRU5ETUVOVSkgZkVuZE1lbnUgPSBUUlVFOwoKICAgIHNldF9jYXB0dXJlX3dpbmRvdyggbXQuaE93bmVyV25kLCBHVUlfSU5NRU5VTU9ERSwgTlVMTCApOwoKICAgIHdoaWxlICghZkVuZE1lbnUpCiAgICB7CgltZW51ID0gTUVOVV9HZXRNZW51KCBtdC5oQ3VycmVudE1lbnUgKTsKCWlmICghbWVudSkgLyogc29tZXRpbWVzIGhhcHBlbnMgaWYgSSBkbyBhIHdpbmRvdyBtYW5hZ2VyIGNsb3NlICovCgkgICAgYnJlYWs7CgoJLyogd2UgaGF2ZSB0byBrZWVwIHRoZSBtZXNzYWdlIGluIHRoZSBxdWV1ZSB1bnRpbCBpdCdzCgkgKiBjbGVhciB0aGF0IG1lbnUgbG9vcCBpcyBub3Qgb3ZlciB5ZXQuICovCgogICAgICAgIGZvciAoOzspCiAgICAgICAgewogICAgICAgICAgICBpZiAoUGVla01lc3NhZ2VXKCAmbXNnLCAwLCAwLCAwLCBQTV9OT1JFTU9WRSApKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBpZiAoIUNhbGxNc2dGaWx0ZXJXKCAmbXNnLCBNU0dGX01FTlUgKSkgYnJlYWs7CiAgICAgICAgICAgICAgICAvKiByZW1vdmUgdGhlIG1lc3NhZ2UgZnJvbSB0aGUgcXVldWUgKi8KICAgICAgICAgICAgICAgIFBlZWtNZXNzYWdlVyggJm1zZywgMCwgbXNnLm1lc3NhZ2UsIG1zZy5tZXNzYWdlLCBQTV9SRU1PVkUgKTsKICAgICAgICAgICAgfQogICAgICAgICAgICBlbHNlCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIGlmICghZW50ZXJJZGxlU2VudCkKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICBIV05EIHdpbiA9ICh3RmxhZ3MgJiBUUE1fRU5URVJJRExFRVggJiYgbWVudS0+d0ZsYWdzICYgTUZfUE9QVVApID8gbWVudS0+aFduZCA6IDA7CiAgICAgICAgICAgICAgICAgICAgZW50ZXJJZGxlU2VudCA9IFRSVUU7CiAgICAgICAgICAgICAgICAgICAgU2VuZE1lc3NhZ2VXKCBtdC5oT3duZXJXbmQsIFdNX0VOVEVSSURMRSwgTVNHRl9NRU5VLCAoTFBBUkFNKXdpbiApOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgV2FpdE1lc3NhZ2UoKTsKICAgICAgICAgICAgfQogICAgICAgIH0KCgkvKiBjaGVjayBpZiBFbmRNZW51KCkgdHJpZWQgdG8gY2FuY2VsIHVzLCBieSBwb3N0aW5nIHRoaXMgbWVzc2FnZSAqLwogICAgICAgIGlmKG1zZy5tZXNzYWdlID09IFdNX0NBTkNFTE1PREUpCgl7CgkgICAgLyogd2UgYXJlIG5vdyBvdXQgb2YgdGhlIGxvb3AgKi8KICAgIAkgICAgZkVuZE1lbnUgPSBUUlVFOwoKCSAgICAvKiByZW1vdmUgdGhlIG1lc3NhZ2UgZnJvbSB0aGUgcXVldWUgKi8KCSAgICBQZWVrTWVzc2FnZVcoICZtc2csIDAsIG1zZy5tZXNzYWdlLCBtc2cubWVzc2FnZSwgUE1fUkVNT1ZFICk7CgoJICAgIC8qIGJyZWFrIG91dCBvZiBpbnRlcm5hbCBsb29wLCBhbGEgRVNDQVBFICovCgkgICAgYnJlYWs7Cgl9CgogICAgICAgIFRyYW5zbGF0ZU1lc3NhZ2UoICZtc2cgKTsKICAgICAgICBtdC5wdCA9IG1zZy5wdDsKCglpZiAoIChtc2cuaHduZD09bWVudS0+aFduZCkgfHwgKG1zZy5tZXNzYWdlIT1XTV9USU1FUikgKQoJICBlbnRlcklkbGVTZW50PUZBTFNFOwoKICAgICAgICBmUmVtb3ZlID0gRkFMU0U7CglpZiAoKG1zZy5tZXNzYWdlID49IFdNX01PVVNFRklSU1QpICYmIChtc2cubWVzc2FnZSA8PSBXTV9NT1VTRUxBU1QpKQoJewogICAgICAgICAgICAvKgogICAgICAgICAgICAgKiBVc2UgdGhlIG1vdXNlIGNvb3JkaW5hdGVzIGluIGxQYXJhbSBpbnN0ZWFkIG9mIHRob3NlIGluIHRoZSBNU0cKICAgICAgICAgICAgICogc3RydWN0IHRvIHByb3Blcmx5IGhhbmRsZSBzeW50aGV0aWMgbWVzc2FnZXMuIFRoZXkgYXJlIGFscmVhZHkKICAgICAgICAgICAgICogaW4gc2NyZWVuIGNvb3JkaW5hdGVzLgogICAgICAgICAgICAgKi8KICAgICAgICAgICAgbXQucHQueCA9IChzaG9ydClMT1dPUkQobXNnLmxQYXJhbSk7CiAgICAgICAgICAgIG10LnB0LnkgPSAoc2hvcnQpSElXT1JEKG1zZy5sUGFyYW0pOwoKCSAgICAvKiBGaW5kIGEgbWVudSBmb3IgdGhpcyBtb3VzZSBldmVudCAqLwoJICAgIGhtZW51ID0gTUVOVV9QdE1lbnUoIG10LmhUb3BNZW51LCBtdC5wdCApOwoKCSAgICBzd2l0Y2gobXNnLm1lc3NhZ2UpCgkgICAgewoJCS8qIG5vIFdNX05DLi4uIG1lc3NhZ2VzIGluIGNhcHR1cmVkIHN0YXRlICovCgoJCWNhc2UgV01fUkJVVFRPTkRCTENMSzoKCQljYXNlIFdNX1JCVVRUT05ET1dOOgoJCSAgICBpZiAoISh3RmxhZ3MgJiBUUE1fUklHSFRCVVRUT04pKSBicmVhazsKCQkgICAgLyogZmFsbCB0aHJvdWdoICovCgkJY2FzZSBXTV9MQlVUVE9OREJMQ0xLOgoJCWNhc2UgV01fTEJVVFRPTkRPV046CgkJICAgIC8qIElmIHRoZSBtZXNzYWdlIGJlbG9uZ3MgdG8gdGhlIG1lbnUsIHJlbW92ZXMgaXQgZnJvbSB0aGUgcXVldWUgKi8KCQkgICAgLyogRWxzZSwgZW5kIG1lbnUgdHJhY2tpbmcgKi8KCQkgICAgZlJlbW92ZSA9IE1FTlVfQnV0dG9uRG93biggJm10LCBobWVudSwgd0ZsYWdzICk7CgkJICAgIGZFbmRNZW51ID0gIWZSZW1vdmU7CgkJICAgIGJyZWFrOwoKCQljYXNlIFdNX1JCVVRUT05VUDoKCQkgICAgaWYgKCEod0ZsYWdzICYgVFBNX1JJR0hUQlVUVE9OKSkgYnJlYWs7CgkJICAgIC8qIGZhbGwgdGhyb3VnaCAqLwoJCWNhc2UgV01fTEJVVFRPTlVQOgoJCSAgICAvKiBDaGVjayBpZiBhIG1lbnUgd2FzIHNlbGVjdGVkIGJ5IHRoZSBtb3VzZSAqLwoJCSAgICBpZiAoaG1lbnUpCgkJICAgIHsKICAgICAgICAgICAgICAgICAgICAgICAgZXhlY3V0ZWRNZW51SWQgPSBNRU5VX0J1dHRvblVwKCAmbXQsIGhtZW51LCB3RmxhZ3MpOwogICAgICAgICAgICAgICAgICAgICAgICBUUkFDRSgiZXhlY3V0ZWRNZW51SWQgJWRcbiIsIGV4ZWN1dGVkTWVudUlkKTsKCgkJCS8qIEVuZCB0aGUgbG9vcCBpZiBleGVjdXRlZE1lbnVJZCBpcyBhbiBpdGVtIElEICovCgkJCS8qIG9yIGlmIHRoZSBqb2Igd2FzIGRvbmUgKGV4ZWN1dGVkTWVudUlkID0gMCkuICovCiAgICAgICAgICAgICAgICAgICAgICAgIGZFbmRNZW51ID0gZlJlbW92ZSA9IChleGVjdXRlZE1lbnVJZCAhPSAtMSk7CgkJICAgIH0KICAgICAgICAgICAgICAgICAgICAvKiBObyBtZW51IHdhcyBzZWxlY3RlZCBieSB0aGUgbW91c2UgKi8KICAgICAgICAgICAgICAgICAgICAvKiBpZiB0aGUgZnVuY3Rpb24gd2FzIGNhbGxlZCBieSBUcmFja1BvcHVwTWVudSwgY29udGludWUKICAgICAgICAgICAgICAgICAgICAgICB3aXRoIHRoZSBtZW51IHRyYWNraW5nLiBJZiBub3QsIHN0b3AgaXQgKi8KICAgICAgICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICAgICAgICAgIGZFbmRNZW51ID0gKCh3RmxhZ3MgJiBUUE1fUE9QVVBNRU5VKSA/IEZBTFNFIDogVFJVRSk7CgoJCSAgICBicmVhazsKCgkJY2FzZSBXTV9NT1VTRU1PVkU6CiAgICAgICAgICAgICAgICAgICAgLyogdGhlIHNlbGVjdGVkIG1lbnUgaXRlbSBtdXN0IGJlIGNoYW5nZWQgZXZlcnkgdGltZSAqLwoJCSAgICAgLyogdGhlIG1vdXNlIG1vdmVzLiAqLwoKICAgICAgICAgICAgICAgICAgICBpZiAoaG1lbnUpCgkJCWZFbmRNZW51IHw9ICFNRU5VX01vdXNlTW92ZSggJm10LCBobWVudSwgd0ZsYWdzICk7CgoJICAgIH0gLyogc3dpdGNoKG1zZy5tZXNzYWdlKSAtIG1vdXNlICovCgl9CgllbHNlIGlmICgobXNnLm1lc3NhZ2UgPj0gV01fS0VZRklSU1QpICYmIChtc2cubWVzc2FnZSA8PSBXTV9LRVlMQVNUKSkKCXsKICAgICAgICAgICAgZlJlbW92ZSA9IFRSVUU7ICAvKiBLZXlib2FyZCBtZXNzYWdlcyBhcmUgYWx3YXlzIHJlbW92ZWQgKi8KCSAgICBzd2l0Y2gobXNnLm1lc3NhZ2UpCgkgICAgewoJICAgIGNhc2UgV01fS0VZRE9XTjoKCSAgICBjYXNlIFdNX1NZU0tFWURPV046CgkJc3dpdGNoKG1zZy53UGFyYW0pCgkJewoJCWNhc2UgVktfTUVOVToKCQkgICAgZkVuZE1lbnUgPSBUUlVFOwoJCSAgICBicmVhazsKCgkJY2FzZSBWS19IT01FOgoJCWNhc2UgVktfRU5EOgoJCSAgICBNRU5VX1NlbGVjdEl0ZW0oIG10LmhPd25lclduZCwgbXQuaEN1cnJlbnRNZW51LAoJCQkJICAgICBOT19TRUxFQ1RFRF9JVEVNLCBGQUxTRSwgMCApOwoJCSAgICBNRU5VX01vdmVTZWxlY3Rpb24oIG10LmhPd25lclduZCwgbXQuaEN1cnJlbnRNZW51LAoJCQkJICAgICAgIChtc2cud1BhcmFtID09IFZLX0hPTUUpPyBJVEVNX05FWFQgOiBJVEVNX1BSRVYgKTsKCQkgICAgYnJlYWs7CgoJCWNhc2UgVktfVVA6CgkJY2FzZSBWS19ET1dOOiAvKiBJZiBvbiBtZW51IGJhciwgcHVsbC1kb3duIHRoZSBtZW51ICovCgoJCSAgICBtZW51ID0gTUVOVV9HZXRNZW51KCBtdC5oQ3VycmVudE1lbnUgKTsKCQkgICAgaWYgKCEobWVudS0+d0ZsYWdzICYgTUZfUE9QVVApKQoJCQltdC5oQ3VycmVudE1lbnUgPSBNRU5VX1Nob3dTdWJQb3B1cChtdC5oT3duZXJXbmQsIG10LmhUb3BNZW51LCBUUlVFLCB3RmxhZ3MpOwoJCSAgICBlbHNlICAgICAgLyogb3RoZXJ3aXNlIHRyeSB0byBtb3ZlIHNlbGVjdGlvbiAqLwoJCQlNRU5VX01vdmVTZWxlY3Rpb24oIG10LmhPd25lclduZCwgbXQuaEN1cnJlbnRNZW51LCAKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKG1zZy53UGFyYW0gPT0gVktfVVApPyBJVEVNX1BSRVYgOiBJVEVNX05FWFQgKTsKCQkgICAgYnJlYWs7CgoJCWNhc2UgVktfTEVGVDoKCQkgICAgTUVOVV9LZXlMZWZ0KCAmbXQsIHdGbGFncyApOwoJCSAgICBicmVhazsKCgkJY2FzZSBWS19SSUdIVDoKCQkgICAgTUVOVV9LZXlSaWdodCggJm10LCB3RmxhZ3MgKTsKCQkgICAgYnJlYWs7CgoJCWNhc2UgVktfRVNDQVBFOgogICAgICAgICAgICAgICAgICAgIGZFbmRNZW51ID0gTUVOVV9LZXlFc2NhcGUoJm10LCB3RmxhZ3MpOwoJCSAgICBicmVhazsKCgkJY2FzZSBWS19GMToKCQkgICAgewoJCQlIRUxQSU5GTyBoaTsKCQkJaGkuY2JTaXplID0gc2l6ZW9mKEhFTFBJTkZPKTsKCQkJaGkuaUNvbnRleHRUeXBlID0gSEVMUElORk9fTUVOVUlURU07CgkJCWlmIChtZW51LT5Gb2N1c2VkSXRlbSA9PSBOT19TRUxFQ1RFRF9JVEVNKQoJCQkgICAgaGkuaUN0cmxJZCA9IDA7CgkJICAgICAgICBlbHNlCgkJCSAgICBoaS5pQ3RybElkID0gbWVudS0+aXRlbXNbbWVudS0+Rm9jdXNlZEl0ZW1dLndJRDsKCQkJaGkuaEl0ZW1IYW5kbGUgPSBobWVudTsKCQkJaGkuZHdDb250ZXh0SWQgPSBtZW51LT5kd0NvbnRleHRIZWxwSUQ7CgkJCWhpLk1vdXNlUG9zID0gbXNnLnB0OwoJCQlTZW5kTWVzc2FnZVcoaHduZCwgV01fSEVMUCwgMCwgKExQQVJBTSkmaGkpOwoJCQlicmVhazsKCQkgICAgfQoKCQlkZWZhdWx0OgoJCSAgICBicmVhazsKCQl9CgkJYnJlYWs7ICAvKiBXTV9LRVlET1dOICovCgoJICAgIGNhc2UgV01fQ0hBUjoKCSAgICBjYXNlIFdNX1NZU0NIQVI6CgkJewoJCSAgICBVSU5UCXBvczsKCgkJICAgIGlmIChtc2cud1BhcmFtID09ICdccicgfHwgbXNnLndQYXJhbSA9PSAnICcpCgkJICAgIHsKICAgICAgICAgICAgICAgICAgICAgICAgZXhlY3V0ZWRNZW51SWQgPSBNRU5VX0V4ZWNGb2N1c2VkSXRlbSgmbXQsbXQuaEN1cnJlbnRNZW51LCB3RmxhZ3MpOwogICAgICAgICAgICAgICAgICAgICAgICBmRW5kTWVudSA9IChleGVjdXRlZE1lbnVJZCAhPSAtMik7CgoJCQlicmVhazsKCQkgICAgfQoKCQkgICAgICAvKiBIYWNrIHRvIGF2b2lkIGNvbnRyb2wgY2hhcnMuICovCgkJICAgICAgLyogV2Ugd2lsbCBmaW5kIGEgYmV0dGVyIHdheSByZWFsIHNvb24uLi4gKi8KCQkgICAgaWYgKG1zZy53UGFyYW0gPCAzMikgYnJlYWs7CgoJCSAgICBwb3MgPSBNRU5VX0ZpbmRJdGVtQnlLZXkoIG10LmhPd25lclduZCwgbXQuaEN1cnJlbnRNZW51LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTE9XT1JEKG1zZy53UGFyYW0pLCBGQUxTRSApOwoJCSAgICBpZiAocG9zID09IChVSU5UKS0yKSBmRW5kTWVudSA9IFRSVUU7CgkJICAgIGVsc2UgaWYgKHBvcyA9PSAoVUlOVCktMSkgTWVzc2FnZUJlZXAoMCk7CgkJICAgIGVsc2UKCQkgICAgewoJCQlNRU5VX1NlbGVjdEl0ZW0oIG10LmhPd25lclduZCwgbXQuaEN1cnJlbnRNZW51LCBwb3MsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVFJVRSwgMCApOwogICAgICAgICAgICAgICAgICAgICAgICBleGVjdXRlZE1lbnVJZCA9IE1FTlVfRXhlY0ZvY3VzZWRJdGVtKCZtdCxtdC5oQ3VycmVudE1lbnUsIHdGbGFncyk7CiAgICAgICAgICAgICAgICAgICAgICAgIGZFbmRNZW51ID0gKGV4ZWN1dGVkTWVudUlkICE9IC0yKTsKCQkgICAgfQoJCX0KCQlicmVhazsKCSAgICB9ICAvKiBzd2l0Y2gobXNnLm1lc3NhZ2UpIC0ga2JkICovCgl9CgllbHNlCgl7CgkgICAgUGVla01lc3NhZ2VXKCAmbXNnLCAwLCBtc2cubWVzc2FnZSwgbXNnLm1lc3NhZ2UsIFBNX1JFTU9WRSApOwoJICAgIERpc3BhdGNoTWVzc2FnZVcoICZtc2cgKTsKCSAgICBjb250aW51ZTsKCX0KCglpZiAoIWZFbmRNZW51KSBmUmVtb3ZlID0gVFJVRTsKCgkvKiBmaW5hbGx5IHJlbW92ZSBtZXNzYWdlIGZyb20gdGhlIHF1ZXVlICovCgogICAgICAgIGlmIChmUmVtb3ZlICYmICEobXQudHJhY2tGbGFncyAmIFRGX1NLSVBSRU1PVkUpICkKCSAgICBQZWVrTWVzc2FnZVcoICZtc2csIDAsIG1zZy5tZXNzYWdlLCBtc2cubWVzc2FnZSwgUE1fUkVNT1ZFICk7CgllbHNlIG10LnRyYWNrRmxhZ3MgJj0gflRGX1NLSVBSRU1PVkU7CiAgICB9CgogICAgc2V0X2NhcHR1cmVfd2luZG93KCAwLCBHVUlfSU5NRU5VTU9ERSwgTlVMTCApOwoKICAgIC8qIElmIGRyb3Bkb3duIGlzIHN0aWxsIHBhaW50ZWQgYW5kIHRoZSBjbG9zZSBib3ggaXMgY2xpY2tlZCBvbgogICAgICAgdGhlbiB0aGUgbWVudSB3aWxsIGJlIGRlc3Ryb3llZCBhcyBwYXJ0IG9mIHRoZSBEaXNwYXRjaE1lc3NhZ2UgYWJvdmUuCiAgICAgICBUaGlzIHdpbGwgdGhlbiBpbnZhbGlkYXRlIHRoZSBtZW51IGhhbmRsZSBpbiBtdC5oVG9wTWVudS4gV2Ugc2hvdWxkCiAgICAgICBjaGVjayBmb3IgdGhpcyBmaXJzdC4gICovCiAgICBpZiggSXNNZW51KCBtdC5oVG9wTWVudSApICkKICAgIHsKCW1lbnUgPSBNRU5VX0dldE1lbnUoIG10LmhUb3BNZW51ICk7CgogICAgICAgIGlmKCBJc1dpbmRvdyggbXQuaE93bmVyV25kICkgKQogICAgICAgIHsKCSAgICBNRU5VX0hpZGVTdWJQb3B1cHMoIG10LmhPd25lclduZCwgbXQuaFRvcE1lbnUsIEZBTFNFICk7CgoJICAgIGlmIChtZW51ICYmIChtZW51LT53RmxhZ3MgJiBNRl9QT1BVUCkpCgkgICAgewogICAgICAgICAgICAgICAgRGVzdHJveVdpbmRvdyggbWVudS0+aFduZCApOwogICAgICAgICAgICAgICAgbWVudS0+aFduZCA9IDA7CgkgICAgfQoJICAgIE1FTlVfU2VsZWN0SXRlbSggbXQuaE93bmVyV25kLCBtdC5oVG9wTWVudSwgTk9fU0VMRUNURURfSVRFTSwgRkFMU0UsIDAgKTsKCSAgICBTZW5kTWVzc2FnZVcoIG10LmhPd25lclduZCwgV01fTUVOVVNFTEVDVCwgTUFLRUxPTkcoMCwweGZmZmYpLCAwICk7CiAgICAgICAgfQoKICAgICAgICAvKiBSZXNldCB0aGUgdmFyaWFibGUgZm9yIGhpZGluZyBtZW51ICovCiAgICAgICAgaWYoIG1lbnUgKSBtZW51LT5iVGltZVRvSGlkZSA9IEZBTFNFOwogICAgfQoKICAgIC8qIFRoZSByZXR1cm4gdmFsdWUgaXMgb25seSB1c2VkIGJ5IFRyYWNrUG9wdXBNZW51ICovCiAgICBpZiAoISh3RmxhZ3MgJiBUUE1fUkVUVVJOQ01EKSkgcmV0dXJuIFRSVUU7CiAgICBpZiAoZXhlY3V0ZWRNZW51SWQgPT0gLTEpIGV4ZWN1dGVkTWVudUlkID0gMDsKICAgIHJldHVybiBleGVjdXRlZE1lbnVJZDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0luaXRUcmFja2luZwogKi8Kc3RhdGljIEJPT0wgTUVOVV9Jbml0VHJhY2tpbmcoSFdORCBoV25kLCBITUVOVSBoTWVudSwgQk9PTCBiUG9wdXAsIFVJTlQgd0ZsYWdzKQp7CiAgICBQT1BVUE1FTlUgKm1lbnU7CiAgICAKICAgIFRSQUNFKCJod25kPSVwIGhtZW51PSVwXG4iLCBoV25kLCBoTWVudSk7CgogICAgSGlkZUNhcmV0KDApOwoKICAgIC8qIFNlbmQgV01fRU5URVJNRU5VTE9PUCBhbmQgV01fSU5JVE1FTlUgbWVzc2FnZSBvbmx5IGlmIFRQTV9OT05PVElGWSBmbGFnIGlzIG5vdCBzcGVjaWZpZWQgKi8KICAgIGlmICghKHdGbGFncyAmIFRQTV9OT05PVElGWSkpCiAgICAgICBTZW5kTWVzc2FnZVcoIGhXbmQsIFdNX0VOVEVSTUVOVUxPT1AsIGJQb3B1cCwgMCApOwoKICAgIFNlbmRNZXNzYWdlVyggaFduZCwgV01fU0VUQ1VSU09SLCAoV1BBUkFNKWhXbmQsIEhUQ0FQVElPTiApOwoKICAgIGlmICghKHdGbGFncyAmIFRQTV9OT05PVElGWSkpCiAgICB7CiAgICAgICBTZW5kTWVzc2FnZVcoIGhXbmQsIFdNX0lOSVRNRU5VLCAoV1BBUkFNKWhNZW51LCAwICk7CiAgICAgICAvKiBJZiBhbiBhcHAgY2hhbmdlZC9yZWNyZWF0ZWQgbWVudSBiYXIgZW50cmllcyBpbiBXTV9JTklUTUVOVQogICAgICAgICogbWVudSBzaXplcyB3aWxsIGJlIHJlY2FsY3VsYXRlZCBvbmNlIHRoZSBtZW51IGNyZWF0ZWQvc2hvd24uCiAgICAgICAgKi8KICAgIH0KICAgIAogICAgLyogVGhpcyBtYWtlcyB0aGUgbWVudXMgb2YgYXBwbGljYXRpb25zIGJ1aWx0IHdpdGggRGVscGhpIHdvcmsuCiAgICAgKiBJdCBhbHNvIGVuYWJsZXMgbWVudXMgdG8gYmUgZGlzcGxheWVkIGluIG1vcmUgdGhhbiBvbmUgd2luZG93LAogICAgICogYnV0IHRoZXJlIGFyZSBzb21lIGJ1Z3MgbGVmdCB0aGF0IG5lZWQgdG8gYmUgZml4ZWQgaW4gdGhpcyBjYXNlLgogICAgICovCiAgICBpZiAoKG1lbnUgPSBNRU5VX0dldE1lbnUoIGhNZW51ICkpKSBtZW51LT5oV25kID0gaFduZDsKICAgIAogICAgcmV0dXJuIFRSVUU7Cn0KLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX0V4aXRUcmFja2luZwogKi8Kc3RhdGljIEJPT0wgTUVOVV9FeGl0VHJhY2tpbmcoSFdORCBoV25kKQp7CiAgICBUUkFDRSgiaHduZD0lcFxuIiwgaFduZCk7CgogICAgU2VuZE1lc3NhZ2VXKCBoV25kLCBXTV9FWElUTUVOVUxPT1AsIDAsIDAgKTsKICAgIFNob3dDYXJldCgwKTsKICAgIHRvcF9wb3B1cCA9IDA7CiAgICByZXR1cm4gVFJVRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX1RyYWNrTW91c2VNZW51QmFyCiAqCiAqIE1lbnUtYmFyIHRyYWNraW5nIHVwb24gYSBtb3VzZSBldmVudC4gQ2FsbGVkIGZyb20gTkNfSGFuZGxlU3lzQ29tbWFuZCgpLgogKi8Kdm9pZCBNRU5VX1RyYWNrTW91c2VNZW51QmFyKCBIV05EIGhXbmQsIElOVCBodCwgUE9JTlQgcHQgKQp7CiAgICBITUVOVSBoTWVudSA9IChodCA9PSBIVFNZU01FTlUpID8gZ2V0X3dpbl9zeXNfbWVudSggaFduZCApIDogR2V0TWVudSggaFduZCApOwogICAgVUlOVCB3RmxhZ3MgPSBUUE1fRU5URVJJRExFRVggfCBUUE1fQlVUVE9ORE9XTiB8IFRQTV9MRUZUQUxJR04gfCBUUE1fTEVGVEJVVFRPTjsKCiAgICBUUkFDRSgid25kPSVwIGh0PTB4JTA0eCAlc1xuIiwgaFduZCwgaHQsIHdpbmVfZGJnc3RyX3BvaW50KCAmcHQpKTsKCiAgICBpZiAoSXNNZW51KGhNZW51KSkKICAgIHsKCU1FTlVfSW5pdFRyYWNraW5nKCBoV25kLCBoTWVudSwgRkFMU0UsIHdGbGFncyApOwoJTUVOVV9UcmFja01lbnUoIGhNZW51LCB3RmxhZ3MsIHB0LngsIHB0LnksIGhXbmQsIE5VTEwgKTsKCU1FTlVfRXhpdFRyYWNraW5nKGhXbmQpOwogICAgfQp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBNRU5VX1RyYWNrS2JkTWVudUJhcgogKgogKiBNZW51LWJhciB0cmFja2luZyB1cG9uIGEga2V5Ym9hcmQgZXZlbnQuIENhbGxlZCBmcm9tIE5DX0hhbmRsZVN5c0NvbW1hbmQoKS4KICovCnZvaWQgTUVOVV9UcmFja0tiZE1lbnVCYXIoIEhXTkQgaHduZCwgVUlOVCB3UGFyYW0sIFdDSEFSIHdDaGFyKQp7CiAgICBVSU5UIHVJdGVtID0gTk9fU0VMRUNURURfSVRFTTsKICAgIEhNRU5VIGhUcmFja01lbnU7CiAgICBVSU5UIHdGbGFncyA9IFRQTV9FTlRFUklETEVFWCB8IFRQTV9MRUZUQUxJR04gfCBUUE1fTEVGVEJVVFRPTjsKCiAgICBUUkFDRSgiaHduZCAlcCB3UGFyYW0gMHglMDR4IHdDaGFyIDB4JTA0eFxuIiwgaHduZCwgd1BhcmFtLCB3Q2hhcik7CgogICAgLyogZmluZCB3aW5kb3cgdGhhdCBoYXMgYSBtZW51ICovCgogICAgd2hpbGUgKCFXSU5fQUxMT1dFRF9NRU5VKEdldFdpbmRvd0xvbmdXKCBod25kLCBHV0xfU1RZTEUgKSkpCiAgICAgICAgaWYgKCEoaHduZCA9IEdldEFuY2VzdG9yKCBod25kLCBHQV9QQVJFTlQgKSkpIHJldHVybjsKCiAgICAvKiBjaGVjayBpZiB3ZSBoYXZlIHRvIHRyYWNrIGEgc3lzdGVtIG1lbnUgKi8KCiAgICBoVHJhY2tNZW51ID0gR2V0TWVudSggaHduZCApOwogICAgaWYgKCFoVHJhY2tNZW51IHx8IElzSWNvbmljKGh3bmQpIHx8IHdDaGFyID09ICcgJyApCiAgICB7CiAgICAgICAgaWYgKCEoR2V0V2luZG93TG9uZ1coIGh3bmQsIEdXTF9TVFlMRSApICYgV1NfU1lTTUVOVSkpIHJldHVybjsKICAgICAgICBoVHJhY2tNZW51ID0gZ2V0X3dpbl9zeXNfbWVudSggaHduZCApOwogICAgICAgIHVJdGVtID0gMDsKICAgICAgICB3UGFyYW0gfD0gSFRTWVNNRU5VOyAvKiBwcmV2ZW50IGl0ZW0gbG9va3VwICovCiAgICB9CgogICAgaWYgKCFJc01lbnUoIGhUcmFja01lbnUgKSkgcmV0dXJuOwoKICAgIE1FTlVfSW5pdFRyYWNraW5nKCBod25kLCBoVHJhY2tNZW51LCBGQUxTRSwgd0ZsYWdzICk7CgogICAgaWYoIHdDaGFyICYmIHdDaGFyICE9ICcgJyApCiAgICB7CiAgICAgICAgdUl0ZW0gPSBNRU5VX0ZpbmRJdGVtQnlLZXkoIGh3bmQsIGhUcmFja01lbnUsIHdDaGFyLCAod1BhcmFtICYgSFRTWVNNRU5VKSApOwogICAgICAgIGlmICggdUl0ZW0gPj0gKFVJTlQpKC0yKSApCiAgICAgICAgewogICAgICAgICAgICBpZiggdUl0ZW0gPT0gKFVJTlQpKC0xKSApIE1lc3NhZ2VCZWVwKDApOwogICAgICAgICAgICAvKiBzY2hlZHVsZSBlbmQgb2YgbWVudSB0cmFja2luZyAqLwogICAgICAgICAgICB3RmxhZ3MgfD0gVEZfRU5ETUVOVTsKICAgICAgICAgICAgZ290byB0cmFja19tZW51OwogICAgICAgIH0KICAgIH0KCiAgICBNRU5VX1NlbGVjdEl0ZW0oIGh3bmQsIGhUcmFja01lbnUsIHVJdGVtLCBUUlVFLCAwICk7CgogICAgaWYgKHdQYXJhbSAmIEhUU1lTTUVOVSAmJiB3Q2hhciAhPSAnICcpCiAgICB7CiAgICAgICAgLyogcHJldmVudCBzeXNtZW51IGFjdGl2YXRpb24gZm9yIG1hbmFnZWQgd2luZG93cyBvbiBBbHQgZG93bi91cCAqLwogICAgICAgIGlmIChHZXRQcm9wQSggaHduZCwgIl9fd2luZV94MTFfbWFuYWdlZCIgKSkKICAgICAgICAgICAgd0ZsYWdzIHw9IFRGX0VORE1FTlU7IC8qIHNjaGVkdWxlIGVuZCBvZiBtZW51IHRyYWNraW5nICovCiAgICB9CiAgICBlbHNlCiAgICB7CiAgICAgICAgaWYoIHVJdGVtID09IE5PX1NFTEVDVEVEX0lURU0gKQogICAgICAgICAgICBNRU5VX01vdmVTZWxlY3Rpb24oIGh3bmQsIGhUcmFja01lbnUsIElURU1fTkVYVCApOwogICAgICAgIGVsc2UKICAgICAgICAgICAgUG9zdE1lc3NhZ2VXKCBod25kLCBXTV9LRVlET1dOLCBWS19ET1dOLCAwTCApOwogICAgfQoKdHJhY2tfbWVudToKICAgIE1FTlVfVHJhY2tNZW51KCBoVHJhY2tNZW51LCB3RmxhZ3MsIDAsIDAsIGh3bmQsIE5VTEwgKTsKICAgIE1FTlVfRXhpdFRyYWNraW5nKCBod25kICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgVHJhY2tQb3B1cE1lbnUgICAoVVNFUjMyLkApCiAqCiAqIExpa2UgdGhlIHdpbjMyIEFQSSwgdGhlIGZ1bmN0aW9uIHJldHVybiB0aGUgY29tbWFuZCBJRCBvbmx5IGlmIHRoZQogKiBmbGFnIFRQTV9SRVRVUk5DTUQgaXMgb24uCiAqCiAqLwpCT09MIFdJTkFQSSBUcmFja1BvcHVwTWVudSggSE1FTlUgaE1lbnUsIFVJTlQgd0ZsYWdzLCBJTlQgeCwgSU5UIHksCiAgICAgICAgICAgICAgICAgICAgICAgICAgIElOVCBuUmVzZXJ2ZWQsIEhXTkQgaFduZCwgY29uc3QgUkVDVCAqbHBSZWN0ICkKewogICAgQk9PTCByZXQgPSBGQUxTRTsKCiAgICBUUkFDRSgiaG1lbnUgJXAgZmxhZ3MgJTA0eCAoJWQsJWQpIHJlc2VydmVkICVkIGh3bmQgJXAgcmVjdCAlc1xuIiwKICAgICAgICAgICBoTWVudSwgd0ZsYWdzLCB4LCB5LCBuUmVzZXJ2ZWQsIGhXbmQsIHdpbmVfZGJnc3RyX3JlY3QobHBSZWN0KSk7CgogICAgTUVOVV9Jbml0VHJhY2tpbmcoaFduZCwgaE1lbnUsIFRSVUUsIHdGbGFncyk7CgogICAgLyogU2VuZCBXTV9JTklUTUVOVVBPUFVQIG1lc3NhZ2Ugb25seSBpZiBUUE1fTk9OT1RJRlkgZmxhZyBpcyBub3Qgc3BlY2lmaWVkICovCiAgICBpZiAoISh3RmxhZ3MgJiBUUE1fTk9OT1RJRlkpKQogICAgICAgIFNlbmRNZXNzYWdlVyggaFduZCwgV01fSU5JVE1FTlVQT1BVUCwgKFdQQVJBTSloTWVudSwgMCk7CgogICAgaWYgKE1FTlVfU2hvd1BvcHVwKCBoV25kLCBoTWVudSwgMCwgeCwgeSwgMCwgMCApKQogICAgICAgIHJldCA9IE1FTlVfVHJhY2tNZW51KCBoTWVudSwgd0ZsYWdzIHwgVFBNX1BPUFVQTUVOVSwgMCwgMCwgaFduZCwgbHBSZWN0ICk7CiAgICBNRU5VX0V4aXRUcmFja2luZyhoV25kKTsKCiAgICByZXR1cm4gcmV0Owp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgVHJhY2tQb3B1cE1lbnVFeCAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIFRyYWNrUG9wdXBNZW51RXgoIEhNRU5VIGhNZW51LCBVSU5UIHdGbGFncywgSU5UIHgsIElOVCB5LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEhXTkQgaFduZCwgTFBUUE1QQVJBTVMgbHBUcG0gKQp7CiAgICBGSVhNRSgibm90IGZ1bGx5IGltcGxlbWVudGVkXG4iICk7CiAgICByZXR1cm4gVHJhY2tQb3B1cE1lbnUoIGhNZW51LCB3RmxhZ3MsIHgsIHksIDAsIGhXbmQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbHBUcG0gPyAmbHBUcG0tPnJjRXhjbHVkZSA6IE5VTEwgKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgICBQb3B1cE1lbnVXbmRQcm9jCiAqCiAqIE5PVEU6IFdpbmRvd3MgaGFzIHRvdGFsbHkgZGlmZmVyZW50IChhbmQgdW5kb2N1bWVudGVkKSBwb3B1cCB3bmRwcm9jLgogKi8Kc3RhdGljIExSRVNVTFQgV0lOQVBJIFBvcHVwTWVudVduZFByb2MoIEhXTkQgaHduZCwgVUlOVCBtZXNzYWdlLCBXUEFSQU0gd1BhcmFtLCBMUEFSQU0gbFBhcmFtICkKewogICAgVFJBQ0UoImh3bmQ9JXAgbXNnPTB4JTA0eCB3cD0weCUwNGx4IGxwPTB4JTA4bHhcbiIsIGh3bmQsIG1lc3NhZ2UsIHdQYXJhbSwgbFBhcmFtKTsKCiAgICBzd2l0Y2gobWVzc2FnZSkKICAgIHsKICAgIGNhc2UgV01fQ1JFQVRFOgoJewoJICAgIENSRUFURVNUUlVDVFcgKmNzID0gKENSRUFURVNUUlVDVFcqKWxQYXJhbTsKCSAgICBTZXRXaW5kb3dMb25nUHRyVyggaHduZCwgMCwgKExPTkdfUFRSKWNzLT5scENyZWF0ZVBhcmFtcyApOwogICAgICAgICAgICByZXR1cm4gMDsKCX0KCiAgICBjYXNlIFdNX01PVVNFQUNUSVZBVEU6ICAvKiBXZSBkb24ndCB3YW50IHRvIGJlIGFjdGl2YXRlZCAqLwogICAgICAgIHJldHVybiBNQV9OT0FDVElWQVRFOwoKICAgIGNhc2UgV01fUEFJTlQ6Cgl7CgkgICAgUEFJTlRTVFJVQ1QgcHM7CgkgICAgQmVnaW5QYWludCggaHduZCwgJnBzICk7CgkgICAgTUVOVV9EcmF3UG9wdXBNZW51KCBod25kLCBwcy5oZGMsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKEhNRU5VKUdldFdpbmRvd0xvbmdQdHJXKCBod25kLCAwICkgKTsKCSAgICBFbmRQYWludCggaHduZCwgJnBzICk7CiAgICAgICAgICAgIHJldHVybiAwOwoJfQogICAgY2FzZSBXTV9FUkFTRUJLR05EOgogICAgICAgIHJldHVybiAxOwoKICAgIGNhc2UgV01fREVTVFJPWToKICAgICAgICAvKiB6ZXJvIG91dCBnbG9iYWwgcG9pbnRlciBpbiBjYXNlIHJlc2lkZW50IHBvcHVwIHdpbmRvdyB3YXMgZGVzdHJveWVkLiAqLwogICAgICAgIGlmIChod25kID09IHRvcF9wb3B1cCkgdG9wX3BvcHVwID0gMDsKICAgICAgICBicmVhazsKCiAgICBjYXNlIFdNX1NIT1dXSU5ET1c6CgoJaWYoIHdQYXJhbSApCgl7CiAgICAgICAgICAgIGlmICghR2V0V2luZG93TG9uZ1B0clcoIGh3bmQsIDAgKSkgRVJSKCJubyBtZW51IHRvIGRpc3BsYXlcbiIpOwoJfQoJZWxzZQogICAgICAgICAgICBTZXRXaW5kb3dMb25nUHRyVyggaHduZCwgMCwgMCApOwoJYnJlYWs7CgogICAgY2FzZSBNTV9TRVRNRU5VSEFORExFOgogICAgICAgIFNldFdpbmRvd0xvbmdQdHJXKCBod25kLCAwLCB3UGFyYW0gKTsKICAgICAgICBicmVhazsKCiAgICBjYXNlIE1NX0dFVE1FTlVIQU5ETEU6CiAgICAgICAgcmV0dXJuIEdldFdpbmRvd0xvbmdQdHJXKCBod25kLCAwICk7CgogICAgZGVmYXVsdDoKICAgICAgICByZXR1cm4gRGVmV2luZG93UHJvY1coIGh3bmQsIG1lc3NhZ2UsIHdQYXJhbSwgbFBhcmFtICk7CiAgICB9CiAgICByZXR1cm4gMDsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTUVOVV9HZXRNZW51QmFySGVpZ2h0CiAqCiAqIENvbXB1dGUgdGhlIHNpemUgb2YgdGhlIG1lbnUgYmFyIGhlaWdodC4gVXNlZCBieSBOQ19IYW5kbGVOQ0NhbGNTaXplKCkuCiAqLwpVSU5UIE1FTlVfR2V0TWVudUJhckhlaWdodCggSFdORCBod25kLCBVSU5UIG1lbnViYXJXaWR0aCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgSU5UIG9yZ1gsIElOVCBvcmdZICkKewogICAgSERDIGhkYzsKICAgIFJFQ1QgcmVjdEJhcjsKICAgIExQUE9QVVBNRU5VIGxwcG9wOwoKICAgIFRSQUNFKCJIV05EICVwLCB3aWR0aCAlZCwgYXQgKCVkLCAlZCkuXG4iLCBod25kLCBtZW51YmFyV2lkdGgsIG9yZ1gsIG9yZ1kgKTsKCiAgICBpZiAoIShscHBvcCA9IE1FTlVfR2V0TWVudSggR2V0TWVudShod25kKSApKSkgcmV0dXJuIDA7CgogICAgaGRjID0gR2V0RENFeCggaHduZCwgMCwgRENYX0NBQ0hFIHwgRENYX1dJTkRPVyApOwogICAgU2VsZWN0T2JqZWN0KCBoZGMsIGdldF9tZW51X2ZvbnQoRkFMU0UpKTsKICAgIFNldFJlY3QoJnJlY3RCYXIsIG9yZ1gsIG9yZ1ksIG9yZ1grbWVudWJhcldpZHRoLCBvcmdZK0dldFN5c3RlbU1ldHJpY3MoU01fQ1lNRU5VKSk7CiAgICBNRU5VX01lbnVCYXJDYWxjU2l6ZSggaGRjLCAmcmVjdEJhciwgbHBwb3AsIGh3bmQgKTsKICAgIFJlbGVhc2VEQyggaHduZCwgaGRjICk7CiAgICByZXR1cm4gbHBwb3AtPkhlaWdodDsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgQ2hhbmdlTWVudUEgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgQ2hhbmdlTWVudUEoIEhNRU5VIGhNZW51LCBVSU5UIHBvcywgTFBDU1RSIGRhdGEsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVUlOVCBpZCwgVUlOVCBmbGFncyApCnsKICAgIFRSQUNFKCJtZW51PSVwIHBvcz0lZCBkYXRhPSVwIGlkPSUwOHggZmxhZ3M9JTA4eFxuIiwgaE1lbnUsIHBvcywgZGF0YSwgaWQsIGZsYWdzICk7CiAgICBpZiAoZmxhZ3MgJiBNRl9BUFBFTkQpIHJldHVybiBBcHBlbmRNZW51QSggaE1lbnUsIGZsYWdzICYgfk1GX0FQUEVORCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlkLCBkYXRhICk7CiAgICBpZiAoZmxhZ3MgJiBNRl9ERUxFVEUpIHJldHVybiBEZWxldGVNZW51KGhNZW51LCBwb3MsIGZsYWdzICYgfk1GX0RFTEVURSk7CiAgICBpZiAoZmxhZ3MgJiBNRl9DSEFOR0UpIHJldHVybiBNb2RpZnlNZW51QShoTWVudSwgcG9zLCBmbGFncyAmIH5NRl9DSEFOR0UsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGlkLCBkYXRhICk7CiAgICBpZiAoZmxhZ3MgJiBNRl9SRU1PVkUpIHJldHVybiBSZW1vdmVNZW51KCBoTWVudSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZsYWdzICYgTUZfQllQT1NJVElPTiA/IHBvcyA6IGlkLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZmxhZ3MgJiB+TUZfUkVNT1ZFICk7CiAgICAvKiBEZWZhdWx0OiBNRl9JTlNFUlQgKi8KICAgIHJldHVybiBJbnNlcnRNZW51QSggaE1lbnUsIHBvcywgZmxhZ3MsIGlkLCBkYXRhICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIENoYW5nZU1lbnVXICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIENoYW5nZU1lbnVXKCBITUVOVSBoTWVudSwgVUlOVCBwb3MsIExQQ1dTVFIgZGF0YSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVSU5UIGlkLCBVSU5UIGZsYWdzICkKewogICAgVFJBQ0UoIm1lbnU9JXAgcG9zPSVkIGRhdGE9JXAgaWQ9JTA4eCBmbGFncz0lMDh4XG4iLCBoTWVudSwgcG9zLCBkYXRhLCBpZCwgZmxhZ3MgKTsKICAgIGlmIChmbGFncyAmIE1GX0FQUEVORCkgcmV0dXJuIEFwcGVuZE1lbnVXKCBoTWVudSwgZmxhZ3MgJiB+TUZfQVBQRU5ELAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaWQsIGRhdGEgKTsKICAgIGlmIChmbGFncyAmIE1GX0RFTEVURSkgcmV0dXJuIERlbGV0ZU1lbnUoaE1lbnUsIHBvcywgZmxhZ3MgJiB+TUZfREVMRVRFKTsKICAgIGlmIChmbGFncyAmIE1GX0NIQU5HRSkgcmV0dXJuIE1vZGlmeU1lbnVXKGhNZW51LCBwb3MsIGZsYWdzICYgfk1GX0NIQU5HRSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaWQsIGRhdGEgKTsKICAgIGlmIChmbGFncyAmIE1GX1JFTU9WRSkgcmV0dXJuIFJlbW92ZU1lbnUoIGhNZW51LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgZmxhZ3MgJiBNRl9CWVBPU0lUSU9OID8gcG9zIDogaWQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBmbGFncyAmIH5NRl9SRU1PVkUgKTsKICAgIC8qIERlZmF1bHQ6IE1GX0lOU0VSVCAqLwogICAgcmV0dXJuIEluc2VydE1lbnVXKCBoTWVudSwgcG9zLCBmbGFncywgaWQsIGRhdGEgKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgQ2hlY2tNZW51SXRlbSAgICAoVVNFUjMyLkApCiAqLwpEV09SRCBXSU5BUEkgQ2hlY2tNZW51SXRlbSggSE1FTlUgaE1lbnUsIFVJTlQgaWQsIFVJTlQgZmxhZ3MgKQp7CiAgICBNRU5VSVRFTSAqaXRlbTsKICAgIERXT1JEIHJldDsKCiAgICBpZiAoIShpdGVtID0gTUVOVV9GaW5kSXRlbSggJmhNZW51LCAmaWQsIGZsYWdzICkpKSByZXR1cm4gLTE7CiAgICByZXQgPSBpdGVtLT5mU3RhdGUgJiBNRl9DSEVDS0VEOwogICAgaWYgKGZsYWdzICYgTUZfQ0hFQ0tFRCkgaXRlbS0+ZlN0YXRlIHw9IE1GX0NIRUNLRUQ7CiAgICBlbHNlIGl0ZW0tPmZTdGF0ZSAmPSB+TUZfQ0hFQ0tFRDsKICAgIHJldHVybiByZXQ7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEVuYWJsZU1lbnVJdGVtICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIEVuYWJsZU1lbnVJdGVtKCBITUVOVSBoTWVudSwgVUlOVCB3SXRlbUlELCBVSU5UIHdGbGFncyApCnsKICAgIFVJTlQgICAgb2xkZmxhZ3M7CiAgICBNRU5VSVRFTSAqaXRlbTsKICAgIFBPUFVQTUVOVSAqbWVudTsKCiAgICBUUkFDRSgiKCVwLCAlMDR4LCAlMDR4KSAhXG4iLCBoTWVudSwgd0l0ZW1JRCwgd0ZsYWdzKTsKCiAgICAvKiBHZXQgdGhlIFBvcHVwbWVudSB0byBhY2Nlc3MgdGhlIG93bmVyIG1lbnUgKi8KICAgIGlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpKSkKCXJldHVybiAoVUlOVCktMTsKCiAgICBpZiAoIShpdGVtID0gTUVOVV9GaW5kSXRlbSggJmhNZW51LCAmd0l0ZW1JRCwgd0ZsYWdzICkpKQoJcmV0dXJuIChVSU5UKS0xOwoKICAgIG9sZGZsYWdzID0gaXRlbS0+ZlN0YXRlICYgKE1GX0dSQVlFRCB8IE1GX0RJU0FCTEVEKTsKICAgIGl0ZW0tPmZTdGF0ZSBePSAob2xkZmxhZ3MgXiB3RmxhZ3MpICYgKE1GX0dSQVlFRCB8IE1GX0RJU0FCTEVEKTsKCiAgICAvKiBJZiB0aGUgY2xvc2UgaXRlbSBpbiB0aGUgc3lzdGVtIG1lbnUgY2hhbmdlIHVwZGF0ZSB0aGUgY2xvc2UgYnV0dG9uICovCiAgICBpZigoaXRlbS0+d0lEID09IFNDX0NMT1NFKSAmJiAob2xkZmxhZ3MgIT0gd0ZsYWdzKSkKICAgIHsKCWlmIChtZW51LT5oU3lzTWVudU93bmVyICE9IDApCgl7CiAgICAgICAgICAgIFJFQ1QgcmM7CgkgICAgUE9QVVBNRU5VKiBwYXJlbnRNZW51OwoKCSAgICAvKiBHZXQgdGhlIHBhcmVudCBtZW51IHRvIGFjY2VzcyovCgkgICAgaWYgKCEocGFyZW50TWVudSA9IE1FTlVfR2V0TWVudShtZW51LT5oU3lzTWVudU93bmVyKSkpCgkJcmV0dXJuIChVSU5UKS0xOwoKICAgICAgICAgICAgLyogUmVmcmVzaCB0aGUgZnJhbWUgdG8gcmVmbGVjdCB0aGUgY2hhbmdlICovCiAgICAgICAgICAgIEdldFdpbmRvd1JlY3QocGFyZW50TWVudS0+aFduZCwgJnJjKTsKICAgICAgICAgICAgTWFwV2luZG93UG9pbnRzKDAsIHBhcmVudE1lbnUtPmhXbmQsIChQT0lOVCAqKSZyYywgMik7CiAgICAgICAgICAgIHJjLmJvdHRvbSA9IDA7CiAgICAgICAgICAgIFJlZHJhd1dpbmRvdyhwYXJlbnRNZW51LT5oV25kLCAmcmMsIDAsIFJEV19GUkFNRSB8IFJEV19JTlZBTElEQVRFIHwgUkRXX05PQ0hJTERSRU4pOwoJfQogICAgfQoKICAgIHJldHVybiBvbGRmbGFnczsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgR2V0TWVudVN0cmluZ0EgICAgKFVTRVIzMi5AKQogKi8KSU5UIFdJTkFQSSBHZXRNZW51U3RyaW5nQSgKCUhNRU5VIGhNZW51LAkvKiBbaW5dIG1lbnVoYW5kbGUgKi8KCVVJTlQgd0l0ZW1JRCwJLyogW2luXSBtZW51IGl0ZW0gKGRlcC4gb24gd0ZsYWdzKSAqLwoJTFBTVFIgc3RyLAkvKiBbb3V0XSBvdXRidWZmZXIuIElmIE5VTEwsIGZ1bmMgcmV0dXJucyBlbnRyeSBsZW5ndGgqLwoJSU5UIG5NYXhTaXosCS8qIFtpbl0gbGVuZ3RoIG9mIGJ1ZmZlci4gaWYgMCwgZnVuYyByZXR1cm5zIGVudHJ5IGxlbiovCglVSU5UIHdGbGFncwkvKiBbaW5dIE1GXyBmbGFncyAqLwopIHsKICAgIE1FTlVJVEVNICppdGVtOwoKICAgIFRSQUNFKCJtZW51PSVwIGl0ZW09JTA0eCBwdHI9JXAgbGVuPSVkIGZsYWdzPSUwNHhcbiIsIGhNZW51LCB3SXRlbUlELCBzdHIsIG5NYXhTaXosIHdGbGFncyApOwogICAgaWYgKHN0ciAmJiBuTWF4U2l6KSBzdHJbMF0gPSAnXDAnOwogICAgaWYgKCEoaXRlbSA9IE1FTlVfRmluZEl0ZW0oICZoTWVudSwgJndJdGVtSUQsIHdGbGFncyApKSkgewogICAgICAgIFNldExhc3RFcnJvciggRVJST1JfTUVOVV9JVEVNX05PVF9GT1VORCk7CiAgICAgICAgcmV0dXJuIDA7CiAgICB9CiAgICBpZiAoIWl0ZW0tPnRleHQpIHJldHVybiAwOwogICAgaWYgKCFzdHIgfHwgIW5NYXhTaXopIHJldHVybiBzdHJsZW5XKGl0ZW0tPnRleHQpOwogICAgaWYgKCFXaWRlQ2hhclRvTXVsdGlCeXRlKCBDUF9BQ1AsIDAsIGl0ZW0tPnRleHQsIC0xLCBzdHIsIG5NYXhTaXosIE5VTEwsIE5VTEwgKSkKICAgICAgICBzdHJbbk1heFNpei0xXSA9IDA7CiAgICBUUkFDRSgicmV0dXJuaW5nICVzXG4iLCBkZWJ1Z3N0cl9hKHN0cikpOwogICAgcmV0dXJuIHN0cmxlbihzdHIpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBHZXRNZW51U3RyaW5nVyAgICAoVVNFUjMyLkApCiAqLwpJTlQgV0lOQVBJIEdldE1lbnVTdHJpbmdXKCBITUVOVSBoTWVudSwgVUlOVCB3SXRlbUlELAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTFBXU1RSIHN0ciwgSU5UIG5NYXhTaXosIFVJTlQgd0ZsYWdzICkKewogICAgTUVOVUlURU0gKml0ZW07CgogICAgVFJBQ0UoIm1lbnU9JXAgaXRlbT0lMDR4IHB0cj0lcCBsZW49JWQgZmxhZ3M9JTA0eFxuIiwgaE1lbnUsIHdJdGVtSUQsIHN0ciwgbk1heFNpeiwgd0ZsYWdzICk7CiAgICBpZiAoc3RyICYmIG5NYXhTaXopIHN0clswXSA9ICdcMCc7CiAgICBpZiAoIShpdGVtID0gTUVOVV9GaW5kSXRlbSggJmhNZW51LCAmd0l0ZW1JRCwgd0ZsYWdzICkpKSB7CiAgICAgICAgU2V0TGFzdEVycm9yKCBFUlJPUl9NRU5VX0lURU1fTk9UX0ZPVU5EKTsKICAgICAgICByZXR1cm4gMDsKICAgIH0KICAgIGlmICghc3RyIHx8ICFuTWF4U2l6KSByZXR1cm4gaXRlbS0+dGV4dCA/IHN0cmxlblcoaXRlbS0+dGV4dCkgOiAwOwogICAgaWYoICEoaXRlbS0+dGV4dCkpIHsKICAgICAgICBzdHJbMF0gPSAwOwogICAgICAgIHJldHVybiAwOwogICAgfQogICAgbHN0cmNweW5XKCBzdHIsIGl0ZW0tPnRleHQsIG5NYXhTaXogKTsKICAgIFRSQUNFKCJyZXR1cm5pbmcgJXNcbiIsIGRlYnVnc3RyX3coc3RyKSk7CiAgICByZXR1cm4gc3RybGVuVyhzdHIpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBIaWxpdGVNZW51SXRlbSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBIaWxpdGVNZW51SXRlbSggSFdORCBoV25kLCBITUVOVSBoTWVudSwgVUlOVCB3SXRlbUlELAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVJTlQgd0hpbGl0ZSApCnsKICAgIExQUE9QVVBNRU5VIG1lbnU7CiAgICBUUkFDRSgiKCVwLCAlcCwgJTA0eCwgJTA0eCk7XG4iLCBoV25kLCBoTWVudSwgd0l0ZW1JRCwgd0hpbGl0ZSk7CiAgICBpZiAoIU1FTlVfRmluZEl0ZW0oICZoTWVudSwgJndJdGVtSUQsIHdIaWxpdGUgKSkgcmV0dXJuIEZBTFNFOwogICAgaWYgKCEobWVudSA9IE1FTlVfR2V0TWVudShoTWVudSkpKSByZXR1cm4gRkFMU0U7CiAgICBpZiAobWVudS0+Rm9jdXNlZEl0ZW0gPT0gd0l0ZW1JRCkgcmV0dXJuIFRSVUU7CiAgICBNRU5VX0hpZGVTdWJQb3B1cHMoIGhXbmQsIGhNZW51LCBGQUxTRSApOwogICAgTUVOVV9TZWxlY3RJdGVtKCBoV25kLCBoTWVudSwgd0l0ZW1JRCwgVFJVRSwgMCApOwogICAgcmV0dXJuIFRSVUU7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEdldE1lbnVTdGF0ZSAgICAoVVNFUjMyLkApCiAqLwpVSU5UIFdJTkFQSSBHZXRNZW51U3RhdGUoIEhNRU5VIGhNZW51LCBVSU5UIHdJdGVtSUQsIFVJTlQgd0ZsYWdzICkKewogICAgTUVOVUlURU0gKml0ZW07CiAgICBUUkFDRSgiKG1lbnU9JXAsIGlkPSUwNHgsIGZsYWdzPSUwNHgpO1xuIiwgaE1lbnUsIHdJdGVtSUQsIHdGbGFncyk7CiAgICBpZiAoIShpdGVtID0gTUVOVV9GaW5kSXRlbSggJmhNZW51LCAmd0l0ZW1JRCwgd0ZsYWdzICkpKSByZXR1cm4gLTE7CiAgICBkZWJ1Z19wcmludF9tZW51aXRlbSAoIiAgaXRlbTogIiwgaXRlbSwgIiIpOwogICAgaWYgKGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApCiAgICB7CglQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoIGl0ZW0tPmhTdWJNZW51ICk7CglpZiAoIW1lbnUpIHJldHVybiAtMTsKCWVsc2UgcmV0dXJuIChtZW51LT5uSXRlbXMgPDwgOCkgfCAoKGl0ZW0tPmZTdGF0ZXxpdGVtLT5mVHlwZSkgJiAweGZmKTsKICAgIH0KICAgIGVsc2UKICAgIHsKCS8qIFdlIHVzZWQgdG8gKGZyb20gd2F5IGJhY2sgdGhlbikgbWFzayB0aGUgcmVzdWx0IHRvIDB4ZmYuICAqLwoJLyogSSBkb24ndCBrbm93IHdoeSBhbmQgaXQgc2VlbXMgd3JvbmcgYXMgdGhlIGRvY3VtZW50ZWQgKi8KCS8qIHJldHVybiBmbGFnIE1GX1NFUEFSQVRPUiBpcyBvdXRzaWRlIHRoYXQgbWFzay4gICovCglyZXR1cm4gKGl0ZW0tPmZUeXBlIHwgaXRlbS0+ZlN0YXRlKTsKICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgR2V0TWVudUl0ZW1Db3VudCAgICAoVVNFUjMyLkApCiAqLwpJTlQgV0lOQVBJIEdldE1lbnVJdGVtQ291bnQoIEhNRU5VIGhNZW51ICkKewogICAgTFBQT1BVUE1FTlUJbWVudSA9IE1FTlVfR2V0TWVudShoTWVudSk7CiAgICBpZiAoIW1lbnUpIHJldHVybiAtMTsKICAgIFRSQUNFKCIoJXApIHJldHVybmluZyAlZFxuIiwgaE1lbnUsIG1lbnUtPm5JdGVtcyApOwogICAgcmV0dXJuIG1lbnUtPm5JdGVtczsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgR2V0TWVudUl0ZW1JRCAgICAoVVNFUjMyLkApCiAqLwpVSU5UIFdJTkFQSSBHZXRNZW51SXRlbUlEKCBITUVOVSBoTWVudSwgSU5UIG5Qb3MgKQp7CiAgICBNRU5VSVRFTSAqIGxwbWk7CgogICAgaWYgKCEobHBtaSA9IE1FTlVfRmluZEl0ZW0oJmhNZW51LChVSU5UKikmblBvcyxNRl9CWVBPU0lUSU9OKSkpIHJldHVybiAtMTsKICAgIGlmIChscG1pLT5mVHlwZSAmIE1GX1BPUFVQKSByZXR1cm4gLTE7CiAgICByZXR1cm4gbHBtaS0+d0lEOwoKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgSW5zZXJ0TWVudVcgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgSW5zZXJ0TWVudVcoIEhNRU5VIGhNZW51LCBVSU5UIHBvcywgVUlOVCBmbGFncywKICAgICAgICAgICAgICAgICAgICAgICAgIFVJTlRfUFRSIGlkLCBMUENXU1RSIHN0ciApCnsKICAgIE1FTlVJVEVNICppdGVtOwoKICAgIGlmIChJU19TVFJJTkdfSVRFTShmbGFncykgJiYgc3RyKQogICAgICAgIFRSQUNFKCJoTWVudSAlcCwgcG9zICVkLCBmbGFncyAlMDh4LCBpZCAlMDRseCwgc3RyICVzXG4iLAogICAgICAgICAgICAgIGhNZW51LCBwb3MsIGZsYWdzLCBpZCwgZGVidWdzdHJfdyhzdHIpICk7CiAgICBlbHNlIFRSQUNFKCJoTWVudSAlcCwgcG9zICVkLCBmbGFncyAlMDh4LCBpZCAlMDRseCwgc3RyICVwIChub3QgYSBzdHJpbmcpXG4iLAogICAgICAgICAgICAgICBoTWVudSwgcG9zLCBmbGFncywgaWQsIHN0ciApOwoKICAgIGlmICghKGl0ZW0gPSBNRU5VX0luc2VydEl0ZW0oIGhNZW51LCBwb3MsIGZsYWdzICkpKSByZXR1cm4gRkFMU0U7CgogICAgaWYgKCEoTUVOVV9TZXRJdGVtRGF0YSggaXRlbSwgZmxhZ3MsIGlkLCBzdHIgKSkpCiAgICB7CiAgICAgICAgUmVtb3ZlTWVudSggaE1lbnUsIHBvcywgZmxhZ3MgKTsKICAgICAgICByZXR1cm4gRkFMU0U7CiAgICB9CgogICAgaXRlbS0+aENoZWNrQml0ID0gaXRlbS0+aFVuQ2hlY2tCaXQgPSAwOwogICAgcmV0dXJuIFRSVUU7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEluc2VydE1lbnVBICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIEluc2VydE1lbnVBKCBITUVOVSBoTWVudSwgVUlOVCBwb3MsIFVJTlQgZmxhZ3MsCiAgICAgICAgICAgICAgICAgICAgICAgICBVSU5UX1BUUiBpZCwgTFBDU1RSIHN0ciApCnsKICAgIEJPT0wgcmV0ID0gRkFMU0U7CgogICAgaWYgKElTX1NUUklOR19JVEVNKGZsYWdzKSAmJiBzdHIpCiAgICB7CiAgICAgICAgSU5UIGxlbiA9IE11bHRpQnl0ZVRvV2lkZUNoYXIoIENQX0FDUCwgMCwgc3RyLCAtMSwgTlVMTCwgMCApOwogICAgICAgIExQV1NUUiBuZXdzdHIgPSBIZWFwQWxsb2MoIEdldFByb2Nlc3NIZWFwKCksIDAsIGxlbiAqIHNpemVvZihXQ0hBUikgKTsKICAgICAgICBpZiAobmV3c3RyKQogICAgICAgIHsKICAgICAgICAgICAgTXVsdGlCeXRlVG9XaWRlQ2hhciggQ1BfQUNQLCAwLCBzdHIsIC0xLCBuZXdzdHIsIGxlbiApOwogICAgICAgICAgICByZXQgPSBJbnNlcnRNZW51VyggaE1lbnUsIHBvcywgZmxhZ3MsIGlkLCBuZXdzdHIgKTsKICAgICAgICAgICAgSGVhcEZyZWUoIEdldFByb2Nlc3NIZWFwKCksIDAsIG5ld3N0ciApOwogICAgICAgIH0KICAgICAgICByZXR1cm4gcmV0OwogICAgfQogICAgZWxzZSByZXR1cm4gSW5zZXJ0TWVudVcoIGhNZW51LCBwb3MsIGZsYWdzLCBpZCwgKExQQ1dTVFIpc3RyICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEFwcGVuZE1lbnVBICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIEFwcGVuZE1lbnVBKCBITUVOVSBoTWVudSwgVUlOVCBmbGFncywKICAgICAgICAgICAgICAgICAgICAgICAgIFVJTlRfUFRSIGlkLCBMUENTVFIgZGF0YSApCnsKICAgIHJldHVybiBJbnNlcnRNZW51QSggaE1lbnUsIC0xLCBmbGFncyB8IE1GX0JZUE9TSVRJT04sIGlkLCBkYXRhICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEFwcGVuZE1lbnVXICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIEFwcGVuZE1lbnVXKCBITUVOVSBoTWVudSwgVUlOVCBmbGFncywKICAgICAgICAgICAgICAgICAgICAgICAgIFVJTlRfUFRSIGlkLCBMUENXU1RSIGRhdGEgKQp7CiAgICByZXR1cm4gSW5zZXJ0TWVudVcoIGhNZW51LCAtMSwgZmxhZ3MgfCBNRl9CWVBPU0lUSU9OLCBpZCwgZGF0YSApOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBSZW1vdmVNZW51ICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIFJlbW92ZU1lbnUoIEhNRU5VIGhNZW51LCBVSU5UIG5Qb3MsIFVJTlQgd0ZsYWdzICkKewogICAgTFBQT1BVUE1FTlUJbWVudTsKICAgIE1FTlVJVEVNICppdGVtOwoKICAgIFRSQUNFKCIobWVudT0lcCBwb3M9JTA0eCBmbGFncz0lMDR4KVxuIixoTWVudSwgblBvcywgd0ZsYWdzKTsKICAgIGlmICghKGl0ZW0gPSBNRU5VX0ZpbmRJdGVtKCAmaE1lbnUsICZuUG9zLCB3RmxhZ3MgKSkpIHJldHVybiBGQUxTRTsKICAgIGlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpKSkgcmV0dXJuIEZBTFNFOwoKICAgICAgLyogUmVtb3ZlIGl0ZW0gKi8KCiAgICBNRU5VX0ZyZWVJdGVtRGF0YSggaXRlbSApOwoKICAgIGlmICgtLW1lbnUtPm5JdGVtcyA9PSAwKQogICAgewogICAgICAgIEhlYXBGcmVlKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBtZW51LT5pdGVtcyApOwogICAgICAgIG1lbnUtPml0ZW1zID0gTlVMTDsKICAgIH0KICAgIGVsc2UKICAgIHsKCXdoaWxlKG5Qb3MgPCBtZW51LT5uSXRlbXMpCgl7CgkgICAgKml0ZW0gPSAqKGl0ZW0rMSk7CgkgICAgaXRlbSsrOwoJICAgIG5Qb3MrKzsKCX0KICAgICAgICBtZW51LT5pdGVtcyA9IEhlYXBSZUFsbG9jKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCBtZW51LT5pdGVtcywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtZW51LT5uSXRlbXMgKiBzaXplb2YoTUVOVUlURU0pICk7CiAgICB9CiAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgRGVsZXRlTWVudSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBEZWxldGVNZW51KCBITUVOVSBoTWVudSwgVUlOVCBuUG9zLCBVSU5UIHdGbGFncyApCnsKICAgIE1FTlVJVEVNICppdGVtID0gTUVOVV9GaW5kSXRlbSggJmhNZW51LCAmblBvcywgd0ZsYWdzICk7CiAgICBpZiAoIWl0ZW0pIHJldHVybiBGQUxTRTsKICAgIGlmIChpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKSBEZXN0cm95TWVudSggaXRlbS0+aFN1Yk1lbnUgKTsKICAgICAgLyogblBvcyBpcyBub3cgdGhlIHBvc2l0aW9uIG9mIHRoZSBpdGVtICovCiAgICBSZW1vdmVNZW51KCBoTWVudSwgblBvcywgd0ZsYWdzIHwgTUZfQllQT1NJVElPTiApOwogICAgcmV0dXJuIFRSVUU7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIE1vZGlmeU1lbnVXICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIE1vZGlmeU1lbnVXKCBITUVOVSBoTWVudSwgVUlOVCBwb3MsIFVJTlQgZmxhZ3MsCiAgICAgICAgICAgICAgICAgICAgICAgICBVSU5UX1BUUiBpZCwgTFBDV1NUUiBzdHIgKQp7CiAgICBNRU5VSVRFTSAqaXRlbTsKCiAgICBpZiAoSVNfU1RSSU5HX0lURU0oZmxhZ3MpKQogICAgICAgIFRSQUNFKCIlcCAlZCAlMDR4ICUwNGx4ICVzXG4iLCBoTWVudSwgcG9zLCBmbGFncywgaWQsIGRlYnVnc3RyX3coc3RyKSApOwogICAgZWxzZQogICAgICAgIFRSQUNFKCIlcCAlZCAlMDR4ICUwNGx4ICVwXG4iLCBoTWVudSwgcG9zLCBmbGFncywgaWQsIHN0ciApOwoKICAgIGlmICghKGl0ZW0gPSBNRU5VX0ZpbmRJdGVtKCAmaE1lbnUsICZwb3MsIGZsYWdzICkpKSByZXR1cm4gRkFMU0U7CiAgICBNRU5VX0dldE1lbnUoaE1lbnUpLT5IZWlnaHQgPSAwOyAvKiBmb3JjZSBzaXplIHJlY2FsY3VsYXRlICovCiAgICByZXR1cm4gTUVOVV9TZXRJdGVtRGF0YSggaXRlbSwgZmxhZ3MsIGlkLCBzdHIgKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgTW9kaWZ5TWVudUEgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgTW9kaWZ5TWVudUEoIEhNRU5VIGhNZW51LCBVSU5UIHBvcywgVUlOVCBmbGFncywKICAgICAgICAgICAgICAgICAgICAgICAgIFVJTlRfUFRSIGlkLCBMUENTVFIgc3RyICkKewogICAgQk9PTCByZXQgPSBGQUxTRTsKCiAgICBpZiAoSVNfU1RSSU5HX0lURU0oZmxhZ3MpICYmIHN0cikKICAgIHsKICAgICAgICBJTlQgbGVuID0gTXVsdGlCeXRlVG9XaWRlQ2hhciggQ1BfQUNQLCAwLCBzdHIsIC0xLCBOVUxMLCAwICk7CiAgICAgICAgTFBXU1RSIG5ld3N0ciA9IEhlYXBBbGxvYyggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgbGVuICogc2l6ZW9mKFdDSEFSKSApOwogICAgICAgIGlmIChuZXdzdHIpCiAgICAgICAgewogICAgICAgICAgICBNdWx0aUJ5dGVUb1dpZGVDaGFyKCBDUF9BQ1AsIDAsIHN0ciwgLTEsIG5ld3N0ciwgbGVuICk7CiAgICAgICAgICAgIHJldCA9IE1vZGlmeU1lbnVXKCBoTWVudSwgcG9zLCBmbGFncywgaWQsIG5ld3N0ciApOwogICAgICAgICAgICBIZWFwRnJlZSggR2V0UHJvY2Vzc0hlYXAoKSwgMCwgbmV3c3RyICk7CiAgICAgICAgfQogICAgICAgIHJldHVybiByZXQ7CiAgICB9CiAgICBlbHNlIHJldHVybiBNb2RpZnlNZW51VyggaE1lbnUsIHBvcywgZmxhZ3MsIGlkLCAoTFBDV1NUUilzdHIgKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgQ3JlYXRlUG9wdXBNZW51ICAgIChVU0VSMzIuQCkKICovCkhNRU5VIFdJTkFQSSBDcmVhdGVQb3B1cE1lbnUodm9pZCkKewogICAgSE1FTlUgaG1lbnU7CiAgICBQT1BVUE1FTlUgKm1lbnU7CgogICAgaWYgKCEoaG1lbnUgPSBDcmVhdGVNZW51KCkpKSByZXR1cm4gMDsKICAgIG1lbnUgPSBNRU5VX0dldE1lbnUoIGhtZW51ICk7CiAgICBtZW51LT53RmxhZ3MgfD0gTUZfUE9QVVA7CiAgICBtZW51LT5iVGltZVRvSGlkZSA9IEZBTFNFOwogICAgcmV0dXJuIGhtZW51Owp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBHZXRNZW51Q2hlY2tNYXJrRGltZW5zaW9ucyAgICAoVVNFUi40MTcpCiAqICAgICAgICAgR2V0TWVudUNoZWNrTWFya0RpbWVuc2lvbnMgICAgKFVTRVIzMi5AKQogKi8KRFdPUkQgV0lOQVBJIEdldE1lbnVDaGVja01hcmtEaW1lbnNpb25zKHZvaWQpCnsKICAgIHJldHVybiBNQUtFTE9ORyggR2V0U3lzdGVtTWV0cmljcyhTTV9DWE1FTlVDSEVDSyksIEdldFN5c3RlbU1ldHJpY3MoU01fQ1lNRU5VQ0hFQ0spICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIFNldE1lbnVJdGVtQml0bWFwcyAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBTZXRNZW51SXRlbUJpdG1hcHMoIEhNRU5VIGhNZW51LCBVSU5UIG5Qb3MsIFVJTlQgd0ZsYWdzLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBIQklUTUFQIGhOZXdVbkNoZWNrLCBIQklUTUFQIGhOZXdDaGVjaykKewogICAgTUVOVUlURU0gKml0ZW07CgogICAgaWYgKCEoaXRlbSA9IE1FTlVfRmluZEl0ZW0oICZoTWVudSwgJm5Qb3MsIHdGbGFncyApKSkgcmV0dXJuIEZBTFNFOwoKICAgIGlmICghaE5ld0NoZWNrICYmICFoTmV3VW5DaGVjaykKICAgIHsKCWl0ZW0tPmZTdGF0ZSAmPSB+TUZfVVNFQ0hFQ0tCSVRNQVBTOwogICAgfQogICAgZWxzZSAgLyogSW5zdGFsbCBuZXcgYml0bWFwcyAqLwogICAgewoJaXRlbS0+aENoZWNrQml0ID0gaE5ld0NoZWNrOwoJaXRlbS0+aFVuQ2hlY2tCaXQgPSBoTmV3VW5DaGVjazsKCWl0ZW0tPmZTdGF0ZSB8PSBNRl9VU0VDSEVDS0JJVE1BUFM7CiAgICB9CiAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgQ3JlYXRlTWVudSAgICAoVVNFUjMyLkApCiAqLwpITUVOVSBXSU5BUEkgQ3JlYXRlTWVudSh2b2lkKQp7CiAgICBITUVOVSBoTWVudTsKICAgIExQUE9QVVBNRU5VIG1lbnU7CiAgICBpZiAoIShoTWVudSA9IFVTRVJfSEVBUF9BTExPQyggc2l6ZW9mKFBPUFVQTUVOVSkgKSkpIHJldHVybiAwOwogICAgbWVudSA9IChMUFBPUFVQTUVOVSkgVVNFUl9IRUFQX0xJTl9BRERSKGhNZW51KTsKCiAgICBaZXJvTWVtb3J5KG1lbnUsIHNpemVvZihQT1BVUE1FTlUpKTsKICAgIG1lbnUtPndNYWdpYyA9IE1FTlVfTUFHSUM7CiAgICBtZW51LT5Gb2N1c2VkSXRlbSA9IE5PX1NFTEVDVEVEX0lURU07CiAgICBtZW51LT5iVGltZVRvSGlkZSA9IEZBTFNFOwoKICAgIFRSQUNFKCJyZXR1cm4gJXBcbiIsIGhNZW51ICk7CgogICAgcmV0dXJuIGhNZW51Owp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBEZXN0cm95TWVudSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBEZXN0cm95TWVudSggSE1FTlUgaE1lbnUgKQp7CiAgICBMUFBPUFVQTUVOVSBscHBvcCA9IE1FTlVfR2V0TWVudShoTWVudSk7CgogICAgVFJBQ0UoIiglcClcbiIsIGhNZW51KTsKCgogICAgaWYgKCFscHBvcCkgcmV0dXJuIEZBTFNFOwoKICAgIGxwcG9wLT53TWFnaWMgPSAwOyAgLyogTWFyayBpdCBhcyBkZXN0cm95ZWQgKi8KCiAgICAvKiBEZXN0cm95TWVudSBzaG91bGQgbm90IGRlc3Ryb3kgc3lzdGVtIG1lbnUgcG9wdXAgb3duZXIgKi8KICAgIGlmICgobHBwb3AtPndGbGFncyAmIChNRl9QT1BVUCB8IE1GX1NZU01FTlUpKSA9PSBNRl9QT1BVUCAmJiBscHBvcC0+aFduZCkKICAgIHsKICAgICAgICBEZXN0cm95V2luZG93KCBscHBvcC0+aFduZCApOwogICAgICAgIGxwcG9wLT5oV25kID0gMDsKICAgIH0KCiAgICBpZiAobHBwb3AtPml0ZW1zKSAvKiByZWN1cnNpdmVseSBkZXN0cm95IHN1Ym1lbnVzICovCiAgICB7CiAgICAgICAgaW50IGk7CiAgICAgICAgTUVOVUlURU0gKml0ZW0gPSBscHBvcC0+aXRlbXM7CiAgICAgICAgZm9yIChpID0gbHBwb3AtPm5JdGVtczsgaSA+IDA7IGktLSwgaXRlbSsrKQogICAgICAgIHsKICAgICAgICAgICAgaWYgKGl0ZW0tPmZUeXBlICYgTUZfUE9QVVApIERlc3Ryb3lNZW51KGl0ZW0tPmhTdWJNZW51KTsKICAgICAgICAgICAgTUVOVV9GcmVlSXRlbURhdGEoIGl0ZW0gKTsKICAgICAgICB9CiAgICAgICAgSGVhcEZyZWUoIEdldFByb2Nlc3NIZWFwKCksIDAsIGxwcG9wLT5pdGVtcyApOwogICAgfQogICAgVVNFUl9IRUFQX0ZSRUUoIGhNZW51ICk7CiAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgR2V0U3lzdGVtTWVudSAgICAoVVNFUjMyLkApCiAqLwpITUVOVSBXSU5BUEkgR2V0U3lzdGVtTWVudSggSFdORCBoV25kLCBCT09MIGJSZXZlcnQgKQp7CiAgICBXTkQgKnduZFB0ciA9IFdJTl9HZXRQdHIoIGhXbmQgKTsKICAgIEhNRU5VIHJldHZhbHVlID0gMDsKCiAgICBpZiAod25kUHRyID09IFdORF9ERVNLVE9QKSByZXR1cm4gMDsKICAgIGlmICh3bmRQdHIgPT0gV05EX09USEVSX1BST0NFU1MpCiAgICB7CiAgICAgICAgaWYgKElzV2luZG93KCBoV25kICkpIEZJWE1FKCAibm90IHN1cHBvcnRlZCBvbiBvdGhlciBwcm9jZXNzIHdpbmRvdyAlcFxuIiwgaFduZCApOwogICAgfQogICAgZWxzZSBpZiAod25kUHRyKQogICAgewoJaWYgKHduZFB0ci0+aFN5c01lbnUgJiYgYlJldmVydCkKCXsKICAgICAgICAgICAgRGVzdHJveU1lbnUod25kUHRyLT5oU3lzTWVudSk7CiAgICAgICAgICAgIHduZFB0ci0+aFN5c01lbnUgPSAwOwoJfQoKCWlmKCF3bmRQdHItPmhTeXNNZW51ICYmICh3bmRQdHItPmR3U3R5bGUgJiBXU19TWVNNRU5VKSApCgkgICAgd25kUHRyLT5oU3lzTWVudSA9IE1FTlVfR2V0U3lzTWVudSggaFduZCwgMCApOwoKCWlmKCB3bmRQdHItPmhTeXNNZW51ICkKICAgICAgICB7CgkgICAgUE9QVVBNRU5VICptZW51OwoJICAgIHJldHZhbHVlID0gR2V0U3ViTWVudSh3bmRQdHItPmhTeXNNZW51LCAwKTsKCgkgICAgLyogU3RvcmUgdGhlIGR1bW15IHN5c21lbnUgaGFuZGxlIHRvIGZhY2lsaXRhdGUgdGhlIHJlZnJlc2ggKi8KCSAgICAvKiBvZiB0aGUgY2xvc2UgYnV0dG9uIGlmIHRoZSBTQ19DTE9TRSBpdGVtIGNoYW5nZSAqLwoJICAgIG1lbnUgPSBNRU5VX0dldE1lbnUocmV0dmFsdWUpOwoJICAgIGlmICggbWVudSApCgkgICAgICAgbWVudS0+aFN5c01lbnVPd25lciA9IHduZFB0ci0+aFN5c01lbnU7CiAgICAgICAgfQogICAgICAgIFdJTl9SZWxlYXNlUHRyKCB3bmRQdHIgKTsKICAgIH0KICAgIHJldHVybiBiUmV2ZXJ0ID8gMCA6IHJldHZhbHVlOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBTZXRTeXN0ZW1NZW51ICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIFNldFN5c3RlbU1lbnUoIEhXTkQgaHduZCwgSE1FTlUgaE1lbnUgKQp7CiAgICBXTkQgKnduZFB0ciA9IFdJTl9HZXRQdHIoIGh3bmQgKTsKCiAgICBpZiAod25kUHRyICYmIHduZFB0ciAhPSBXTkRfT1RIRVJfUFJPQ0VTUyAmJiB3bmRQdHIgIT0gV05EX0RFU0tUT1ApCiAgICB7CglpZiAod25kUHRyLT5oU3lzTWVudSkgRGVzdHJveU1lbnUoIHduZFB0ci0+aFN5c01lbnUgKTsKCXduZFB0ci0+aFN5c01lbnUgPSBNRU5VX0dldFN5c01lbnUoIGh3bmQsIGhNZW51ICk7CiAgICAgICAgV0lOX1JlbGVhc2VQdHIoIHduZFB0ciApOwoJcmV0dXJuIFRSVUU7CiAgICB9CiAgICByZXR1cm4gRkFMU0U7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEdldE1lbnUgICAgKFVTRVIzMi5AKQogKi8KSE1FTlUgV0lOQVBJIEdldE1lbnUoIEhXTkQgaFduZCApCnsKICAgIEhNRU5VIHJldHZhbHVlID0gKEhNRU5VKUdldFdpbmRvd0xvbmdQdHJXKCBoV25kLCBHV0xQX0lEICk7CiAgICBUUkFDRSgiZm9yICVwIHJldHVybmluZyAlcFxuIiwgaFduZCwgcmV0dmFsdWUpOwogICAgcmV0dXJuIHJldHZhbHVlOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIEdldE1lbnVCYXJJbmZvICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIEdldE1lbnVCYXJJbmZvKCBIV05EIGh3bmQsIExPTkcgaWRPYmplY3QsIExPTkcgaWRJdGVtLCBQTUVOVUJBUklORk8gcG1iaSApCnsKICAgIEZJWE1FKCAiKCVwLDB4JTA4eCwweCUwOHgsJXApXG4iLCBod25kLCBpZE9iamVjdCwgaWRJdGVtLCBwbWJpICk7CiAgICByZXR1cm4gRkFMU0U7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgTUVOVV9TZXRNZW51CiAqCiAqIEhlbHBlciBmb3IgU2V0TWVudS4gQWxzbyBjYWxsZWQgYnkgV0lOX0NyZWF0ZVdpbmRvd0V4IHRvIGF2b2lkIHRoZQogKiBTZXRXaW5kb3dQb3MgY2FsbCB0aGF0IHdvdWxkIHJlc3VsdCBpZiBTZXRNZW51IHdlcmUgY2FsbGVkIGRpcmVjdGx5LgogKi8KQk9PTCBNRU5VX1NldE1lbnUoIEhXTkQgaFduZCwgSE1FTlUgaE1lbnUgKQp7CiAgICBUUkFDRSgiKCVwLCAlcCk7XG4iLCBoV25kLCBoTWVudSk7CgogICAgaWYgKGhNZW51ICYmICFJc01lbnUoaE1lbnUpKQogICAgewogICAgICAgIFdBUk4oImhNZW51ICVwIGlzIG5vdCBhIG1lbnUgaGFuZGxlXG4iLCBoTWVudSk7CiAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgfQogICAgaWYgKCFXSU5fQUxMT1dFRF9NRU5VKEdldFdpbmRvd0xvbmdXKCBoV25kLCBHV0xfU1RZTEUgKSkpCiAgICAgICAgcmV0dXJuIEZBTFNFOwoKICAgIGhXbmQgPSBXSU5fR2V0RnVsbEhhbmRsZSggaFduZCApOwogICAgaWYgKEdldENhcHR1cmUoKSA9PSBoV25kKQogICAgICAgIHNldF9jYXB0dXJlX3dpbmRvdyggMCwgR1VJX0lOTUVOVU1PREUsIE5VTEwgKTsgIC8qIHJlbGVhc2UgdGhlIGNhcHR1cmUgKi8KCiAgICBpZiAoaE1lbnUgIT0gMCkKICAgIHsKICAgICAgICBMUFBPUFVQTUVOVSBscG1lbnU7CgogICAgICAgIGlmICghKGxwbWVudSA9IE1FTlVfR2V0TWVudShoTWVudSkpKSByZXR1cm4gRkFMU0U7CgogICAgICAgIGxwbWVudS0+aFduZCA9IGhXbmQ7CiAgICAgICAgbHBtZW51LT5IZWlnaHQgPSAwOyAgLyogTWFrZSBzdXJlIHdlIHJlY2FsY3VsYXRlIHRoZSBzaXplICovCiAgICB9CiAgICBTZXRXaW5kb3dMb25nUHRyVyggaFduZCwgR1dMUF9JRCwgKExPTkdfUFRSKWhNZW51ICk7CiAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgU2V0TWVudSAgICAoVVNFUjMyLkApCiAqLwpCT09MIFdJTkFQSSBTZXRNZW51KCBIV05EIGhXbmQsIEhNRU5VIGhNZW51ICkKeyAgIAogICAgaWYoIU1FTlVfU2V0TWVudShoV25kLCBoTWVudSkpCiAgICAgICAgcmV0dXJuIEZBTFNFOwogCiAgICBTZXRXaW5kb3dQb3MoIGhXbmQsIDAsIDAsIDAsIDAsIDAsIFNXUF9OT1NJWkUgfCBTV1BfTk9NT1ZFIHwKICAgICAgICAgICAgICAgICAgU1dQX05PQUNUSVZBVEUgfCBTV1BfTk9aT1JERVIgfCBTV1BfRlJBTUVDSEFOR0VEICk7CiAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgR2V0U3ViTWVudSAgICAoVVNFUjMyLkApCiAqLwpITUVOVSBXSU5BUEkgR2V0U3ViTWVudSggSE1FTlUgaE1lbnUsIElOVCBuUG9zICkKewogICAgTUVOVUlURU0gKiBscG1pOwoKICAgIGlmICghKGxwbWkgPSBNRU5VX0ZpbmRJdGVtKCZoTWVudSwoVUlOVCopJm5Qb3MsTUZfQllQT1NJVElPTikpKSByZXR1cm4gMDsKICAgIGlmICghKGxwbWktPmZUeXBlICYgTUZfUE9QVVApKSByZXR1cm4gMDsKICAgIHJldHVybiBscG1pLT5oU3ViTWVudTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgRHJhd01lbnVCYXIgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgRHJhd01lbnVCYXIoIEhXTkQgaFduZCApCnsKICAgIExQUE9QVVBNRU5VIGxwcG9wOwogICAgSE1FTlUgaE1lbnUgPSBHZXRNZW51KGhXbmQpOwoKICAgIGlmICghV0lOX0FMTE9XRURfTUVOVShHZXRXaW5kb3dMb25nVyggaFduZCwgR1dMX1NUWUxFICkpKQogICAgICAgIHJldHVybiBGQUxTRTsKICAgIGlmICghaE1lbnUgfHwgIShscHBvcCA9IE1FTlVfR2V0TWVudSggaE1lbnUgKSkpIHJldHVybiBGQUxTRTsKCiAgICBscHBvcC0+SGVpZ2h0ID0gMDsgLyogTWFrZSBzdXJlIHdlIGNhbGwgTUVOVV9NZW51QmFyQ2FsY1NpemUgKi8KICAgIGxwcG9wLT5od25kT3duZXIgPSBoV25kOwogICAgU2V0V2luZG93UG9zKCBoV25kLCAwLCAwLCAwLCAwLCAwLCBTV1BfTk9TSVpFIHwgU1dQX05PTU9WRSB8CiAgICAgICAgICAgICAgICAgIFNXUF9OT0FDVElWQVRFIHwgU1dQX05PWk9SREVSIHwgU1dQX0ZSQU1FQ0hBTkdFRCApOwogICAgcmV0dXJuIFRSVUU7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgRHJhd01lbnVCYXJUZW1wICAgKFVTRVIzMi5AKQogKgogKiBVTkRPQ1VNRU5URUQgISEKICoKICogY2FsbGVkIGJ5IFc5OFNFIGRlc2suY3BsIENvbnRyb2wgUGFuZWwgQXBwbGV0CiAqCiAqIE5vdCAxMDAlIHN1cmUgYWJvdXQgdGhlIHBhcmFtIG5hbWVzLCBidXQgY2xvc2UuCiAqLwpEV09SRCBXSU5BUEkgRHJhd01lbnVCYXJUZW1wKEhXTkQgaHduZCwgSERDIGhEQywgTFBSRUNUIGxwcmVjdCwgSE1FTlUgaE1lbnUsIEhGT05UIGhGb250KQp7CiAgICBMUFBPUFVQTUVOVSBscHBvcDsKICAgIFVJTlQgaSxyZXR2YWx1ZTsKICAgIEhGT05UIGhmb250T2xkID0gMDsKICAgIEJPT0wgZmxhdF9tZW51ID0gRkFMU0U7CgogICAgU3lzdGVtUGFyYW1ldGVyc0luZm9XIChTUElfR0VURkxBVE1FTlUsIDAsICZmbGF0X21lbnUsIDApOwoKICAgIGlmICghaE1lbnUpCiAgICAgICAgaE1lbnUgPSBHZXRNZW51KGh3bmQpOwoKICAgIGlmICghaEZvbnQpCiAgICAgICAgaEZvbnQgPSBnZXRfbWVudV9mb250KEZBTFNFKTsKCiAgICBscHBvcCA9IE1FTlVfR2V0TWVudSggaE1lbnUgKTsKICAgIGlmIChscHBvcCA9PSBOVUxMIHx8IGxwcmVjdCA9PSBOVUxMKQogICAgewogICAgICAgIHJldHZhbHVlID0gR2V0U3lzdGVtTWV0cmljcyhTTV9DWU1FTlUpOwogICAgICAgIGdvdG8gRU5EOwogICAgfQoKICAgIFRSQUNFKCIoJXAsICVwLCAlcCwgJXAsICVwKVxuIiwgaHduZCwgaERDLCBscHJlY3QsIGhNZW51LCBoRm9udCk7CgogICAgaGZvbnRPbGQgPSBTZWxlY3RPYmplY3QoIGhEQywgaEZvbnQpOwoKICAgIGlmIChscHBvcC0+SGVpZ2h0ID09IDApCiAgICAgICAgTUVOVV9NZW51QmFyQ2FsY1NpemUoaERDLCBscHJlY3QsIGxwcG9wLCBod25kKTsKCiAgICBscHJlY3QtPmJvdHRvbSA9IGxwcmVjdC0+dG9wICsgbHBwb3AtPkhlaWdodDsKCiAgICBGaWxsUmVjdChoREMsIGxwcmVjdCwgR2V0U3lzQ29sb3JCcnVzaChmbGF0X21lbnUgPyBDT0xPUl9NRU5VQkFSIDogQ09MT1JfTUVOVSkgKTsKCiAgICBTZWxlY3RPYmplY3QoIGhEQywgU1lTQ09MT1JfR2V0UGVuKENPTE9SXzNERkFDRSkpOwogICAgTW92ZVRvRXgoIGhEQywgbHByZWN0LT5sZWZ0LCBscHJlY3QtPmJvdHRvbSwgTlVMTCApOwogICAgTGluZVRvKCBoREMsIGxwcmVjdC0+cmlnaHQsIGxwcmVjdC0+Ym90dG9tICk7CgogICAgaWYgKGxwcG9wLT5uSXRlbXMgPT0gMCkKICAgIHsKICAgICAgICByZXR2YWx1ZSA9IEdldFN5c3RlbU1ldHJpY3MoU01fQ1lNRU5VKTsKICAgICAgICBnb3RvIEVORDsKICAgIH0KCiAgICBmb3IgKGkgPSAwOyBpIDwgbHBwb3AtPm5JdGVtczsgaSsrKQogICAgewogICAgICAgIE1FTlVfRHJhd01lbnVJdGVtKCBod25kLCBoTWVudSwgaHduZCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgaERDLCAmbHBwb3AtPml0ZW1zW2ldLCBscHBvcC0+SGVpZ2h0LCBUUlVFLCBPREFfRFJBV0VOVElSRSApOwogICAgfQogICAgcmV0dmFsdWUgPSBscHBvcC0+SGVpZ2h0OwoKRU5EOgogICAgaWYgKGhmb250T2xkKSBTZWxlY3RPYmplY3QgKGhEQywgaGZvbnRPbGQpOwogICAgcmV0dXJuIHJldHZhbHVlOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICAgIEVuZE1lbnUgICAoVVNFUi4xODcpCiAqICAgICAgICAgICBFbmRNZW51ICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgRW5kTWVudSh2b2lkKQp7CiAgICAvKiBpZiB3ZSBhcmUgaW4gdGhlIG1lbnUgY29kZSwgYW5kIGl0IGlzIGFjdGl2ZSAqLwogICAgaWYgKCFmRW5kTWVudSAmJiB0b3BfcG9wdXApCiAgICB7CgkvKiB0ZXJtaW5hdGUgdGhlIG1lbnUgaGFuZGxpbmcgY29kZSAqLwogICAgICAgIGZFbmRNZW51ID0gVFJVRTsKCgkvKiBuZWVkcyB0byBiZSBwb3N0ZWQgdG8gd2FrZXVwIHRoZSBpbnRlcm5hbCBtZW51IGhhbmRsZXIgKi8KCS8qIHdoaWNoIHdpbGwgbm93IHRlcm1pbmF0ZSB0aGUgbWVudSwgaW4gdGhlIGV2ZW50IHRoYXQgKi8KCS8qIHRoZSBtYWluIHdpbmRvdyB3YXMgbWluaW1pemVkLCBvciBsb3N0IGZvY3VzLCBzbyB3ZSAqLwoJLyogZG9uJ3QgZW5kIHVwIHdpdGggYW4gb3JwaGFuZWQgbWVudSAqLwogICAgICAgIFBvc3RNZXNzYWdlVyggdG9wX3BvcHVwLCBXTV9DQU5DRUxNT0RFLCAwLCAwKTsKICAgIH0KICAgIHJldHVybiBmRW5kTWVudTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgTG9va3VwTWVudUhhbmRsZSAgIChVU0VSLjIxNykKICovCkhNRU5VMTYgV0lOQVBJIExvb2t1cE1lbnVIYW5kbGUxNiggSE1FTlUxNiBobWVudSwgSU5UMTYgaWQgKQp7CiAgICBITUVOVSBobWVudTMyID0gSE1FTlVfMzIoaG1lbnUpOwogICAgVUlOVCBpZDMyID0gaWQ7CiAgICBpZiAoIU1FTlVfRmluZEl0ZW0oICZobWVudTMyLCAmaWQzMiwgTUZfQllDT01NQU5EICkpIHJldHVybiAwOwogICAgZWxzZSByZXR1cm4gSE1FTlVfMTYoaG1lbnUzMik7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkgICAgTG9hZE1lbnUgICAgKFVTRVIuMTUwKQogKi8KSE1FTlUxNiBXSU5BUEkgTG9hZE1lbnUxNiggSElOU1RBTkNFMTYgaW5zdGFuY2UsIExQQ1NUUiBuYW1lICkKewogICAgSFJTUkMxNiBoUnNyYzsKICAgIEhHTE9CQUwxNiBoYW5kbGU7CiAgICBITUVOVTE2IGhNZW51OwoKICAgIGlmIChISVdPUkQobmFtZSkgJiYgbmFtZVswXSA9PSAnIycpIG5hbWUgPSBVTG9uZ1RvUHRyKGF0b2koIG5hbWUgKyAxICkpOwogICAgaWYgKCFuYW1lKSByZXR1cm4gMDsKCiAgICBpbnN0YW5jZSA9IEdldEV4ZVB0ciggaW5zdGFuY2UgKTsKICAgIGlmICghKGhSc3JjID0gRmluZFJlc291cmNlMTYoIGluc3RhbmNlLCBuYW1lLCAoTFBTVFIpUlRfTUVOVSApKSkgcmV0dXJuIDA7CiAgICBpZiAoIShoYW5kbGUgPSBMb2FkUmVzb3VyY2UxNiggaW5zdGFuY2UsIGhSc3JjICkpKSByZXR1cm4gMDsKICAgIGhNZW51ID0gTG9hZE1lbnVJbmRpcmVjdDE2KExvY2tSZXNvdXJjZTE2KGhhbmRsZSkpOwogICAgRnJlZVJlc291cmNlMTYoIGhhbmRsZSApOwogICAgcmV0dXJuIGhNZW51Owp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICBMb2FkTWVudUEgICAoVVNFUjMyLkApCiAqLwpITUVOVSBXSU5BUEkgTG9hZE1lbnVBKCBISU5TVEFOQ0UgaW5zdGFuY2UsIExQQ1NUUiBuYW1lICkKewogICAgSFJTUkMgaHJzcmMgPSBGaW5kUmVzb3VyY2VBKCBpbnN0YW5jZSwgbmFtZSwgKExQU1RSKVJUX01FTlUgKTsKICAgIGlmICghaHJzcmMpIHJldHVybiAwOwogICAgcmV0dXJuIExvYWRNZW51SW5kaXJlY3RBKCAoTFBDVk9JRClMb2FkUmVzb3VyY2UoIGluc3RhbmNlLCBocnNyYyApKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgTG9hZE1lbnVXICAgKFVTRVIzMi5AKQogKi8KSE1FTlUgV0lOQVBJIExvYWRNZW51VyggSElOU1RBTkNFIGluc3RhbmNlLCBMUENXU1RSIG5hbWUgKQp7CiAgICBIUlNSQyBocnNyYyA9IEZpbmRSZXNvdXJjZVcoIGluc3RhbmNlLCBuYW1lLCAoTFBXU1RSKVJUX01FTlUgKTsKICAgIGlmICghaHJzcmMpIHJldHVybiAwOwogICAgcmV0dXJuIExvYWRNZW51SW5kaXJlY3RXKCAoTFBDVk9JRClMb2FkUmVzb3VyY2UoIGluc3RhbmNlLCBocnNyYyApKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCSAgICBMb2FkTWVudUluZGlyZWN0ICAgIChVU0VSLjIyMCkKICovCkhNRU5VMTYgV0lOQVBJIExvYWRNZW51SW5kaXJlY3QxNiggTFBDVk9JRCB0ZW1wbGF0ZSApCnsKICAgIEhNRU5VIGhNZW51OwogICAgV09SRCB2ZXJzaW9uLCBvZmZzZXQ7CiAgICBMUENTVFIgcCA9IChMUENTVFIpdGVtcGxhdGU7CgogICAgVFJBQ0UoIiglcClcbiIsIHRlbXBsYXRlICk7CiAgICB2ZXJzaW9uID0gR0VUX1dPUkQocCk7CiAgICBwICs9IHNpemVvZihXT1JEKTsKICAgIGlmICh2ZXJzaW9uKQogICAgewogICAgICAgIFdBUk4oInZlcnNpb24gbXVzdCBiZSAwIGZvciBXaW4xNlxuIiApOwogICAgICAgIHJldHVybiAwOwogICAgfQogICAgb2Zmc2V0ID0gR0VUX1dPUkQocCk7CiAgICBwICs9IHNpemVvZihXT1JEKSArIG9mZnNldDsKICAgIGlmICghKGhNZW51ID0gQ3JlYXRlTWVudSgpKSkgcmV0dXJuIDA7CiAgICBpZiAoIU1FTlVfUGFyc2VSZXNvdXJjZSggcCwgaE1lbnUsIEZBTFNFICkpCiAgICB7CiAgICAgICAgRGVzdHJveU1lbnUoIGhNZW51ICk7CiAgICAgICAgcmV0dXJuIDA7CiAgICB9CiAgICByZXR1cm4gSE1FTlVfMTYoaE1lbnUpOwp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJICAgIExvYWRNZW51SW5kaXJlY3RXICAgIChVU0VSMzIuQCkKICovCkhNRU5VIFdJTkFQSSBMb2FkTWVudUluZGlyZWN0VyggTFBDVk9JRCB0ZW1wbGF0ZSApCnsKICAgIEhNRU5VIGhNZW51OwogICAgV09SRCB2ZXJzaW9uLCBvZmZzZXQ7CiAgICBMUENTVFIgcCA9IChMUENTVFIpdGVtcGxhdGU7CgogICAgdmVyc2lvbiA9IEdFVF9XT1JEKHApOwogICAgcCArPSBzaXplb2YoV09SRCk7CiAgICBUUkFDRSgiJXAsIHZlciAlZFxuIiwgdGVtcGxhdGUsIHZlcnNpb24gKTsKICAgIHN3aXRjaCAodmVyc2lvbikKICAgIHsKICAgICAgY2FzZSAwOiAvKiBzdGFuZGFyZCBmb3JtYXQgaXMgdmVyc2lvbiBvZiAwICovCglvZmZzZXQgPSBHRVRfV09SRChwKTsKCXAgKz0gc2l6ZW9mKFdPUkQpICsgb2Zmc2V0OwoJaWYgKCEoaE1lbnUgPSBDcmVhdGVNZW51KCkpKSByZXR1cm4gMDsKCWlmICghTUVOVV9QYXJzZVJlc291cmNlKCBwLCBoTWVudSwgVFJVRSApKQoJICB7CgkgICAgRGVzdHJveU1lbnUoIGhNZW51ICk7CgkgICAgcmV0dXJuIDA7CgkgIH0KCXJldHVybiBoTWVudTsKICAgICAgY2FzZSAxOiAvKiBleHRlbmRlZCBmb3JtYXQgaXMgdmVyc2lvbiBvZiAxICovCglvZmZzZXQgPSBHRVRfV09SRChwKTsKCXAgKz0gc2l6ZW9mKFdPUkQpICsgb2Zmc2V0OwoJaWYgKCEoaE1lbnUgPSBDcmVhdGVNZW51KCkpKSByZXR1cm4gMDsKCWlmICghTUVOVUVYX1BhcnNlUmVzb3VyY2UoIHAsIGhNZW51KSkKCSAgewoJICAgIERlc3Ryb3lNZW51KCBoTWVudSApOwoJICAgIHJldHVybiAwOwoJICB9CglyZXR1cm4gaE1lbnU7CiAgICAgIGRlZmF1bHQ6CiAgICAgICAgRVJSKCJ2ZXJzaW9uICVkIG5vdCBzdXBwb3J0ZWQuXG4iLCB2ZXJzaW9uKTsKICAgICAgICByZXR1cm4gMDsKICAgIH0KfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCSAgICBMb2FkTWVudUluZGlyZWN0QSAgICAoVVNFUjMyLkApCiAqLwpITUVOVSBXSU5BUEkgTG9hZE1lbnVJbmRpcmVjdEEoIExQQ1ZPSUQgdGVtcGxhdGUgKQp7CiAgICByZXR1cm4gTG9hZE1lbnVJbmRpcmVjdFcoIHRlbXBsYXRlICk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJSXNNZW51ICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIElzTWVudShITUVOVSBobWVudSkKewogICAgTFBQT1BVUE1FTlUgbWVudSA9IE1FTlVfR2V0TWVudShobWVudSk7CgogICAgaWYgKCFtZW51KQogICAgewogICAgICAgIFNldExhc3RFcnJvcihFUlJPUl9JTlZBTElEX01FTlVfSEFORExFKTsKICAgICAgICByZXR1cm4gRkFMU0U7CiAgICB9CiAgICByZXR1cm4gVFJVRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCUdldE1lbnVJdGVtSW5mb19jb21tb24KICovCgpzdGF0aWMgQk9PTCBHZXRNZW51SXRlbUluZm9fY29tbW9uICggSE1FTlUgaG1lbnUsIFVJTlQgaXRlbSwgQk9PTCBieXBvcywKCQkJCQlMUE1FTlVJVEVNSU5GT1cgbHBtaWksIEJPT0wgdW5pY29kZSkKewogICAgTUVOVUlURU0gKm1lbnUgPSBNRU5VX0ZpbmRJdGVtICgmaG1lbnUsICZpdGVtLCBieXBvcyA/IE1GX0JZUE9TSVRJT04gOiAwKTsKCiAgICBkZWJ1Z19wcmludF9tZW51aXRlbSgiR2V0TWVudUl0ZW1JbmZvX2NvbW1vbjogIiwgbWVudSwgIiIpOwoKICAgIGlmICghbWVudSkKCXJldHVybiBGQUxTRTsKICAgIAogICAgaWYoIGxwbWlpLT5mTWFzayAmIE1JSU1fVFlQRSkgewogICAgICAgIGlmKCBscG1paS0+Zk1hc2sgJiAoIE1JSU1fU1RSSU5HIHwgTUlJTV9GVFlQRSB8IE1JSU1fQklUTUFQKSkgewogICAgICAgICAgICBXQVJOKCJpbnZhbGlkIGNvbWJpbmF0aW9uIG9mIGZNYXNrIGJpdHMgdXNlZFxuIik7CiAgICAgICAgICAgIC8qIHRoaXMgZG9lcyBub3QgaGFwcGVuIG9uIFdpbjl4L01FICovCiAgICAgICAgICAgIFNldExhc3RFcnJvciggRVJST1JfSU5WQUxJRF9QQVJBTUVURVIpOwogICAgICAgICAgICByZXR1cm4gRkFMU0U7CiAgICAgICAgfQoJbHBtaWktPmZUeXBlID0gbWVudS0+ZlR5cGUgJiBNRU5VSVRFTUlORk9fVFlQRV9NQVNLOwogICAgICAgIGlmKCBtZW51LT5oYm1wSXRlbSkgbHBtaWktPmZUeXBlIHw9IE1GVF9CSVRNQVA7CglscG1paS0+aGJtcEl0ZW0gPSBtZW51LT5oYm1wSXRlbTsgLyogbm90IG9uIFdpbjl4L01FICovCiAgICAgICAgaWYoIGxwbWlpLT5mVHlwZSAmIE1GVF9CSVRNQVApIHsKCSAgICBscG1paS0+ZHdUeXBlRGF0YSA9IChMUFdTVFIpIG1lbnUtPmhibXBJdGVtOwoJICAgIGxwbWlpLT5jY2ggPSAwOwogICAgICAgIH0gZWxzZSBpZiggbHBtaWktPmZUeXBlICYgKE1GVF9PV05FUkRSQVcgfCBNRlRfU0VQQVJBVE9SKSkgewogICAgICAgICAgICAvKiB0aGlzIGRvZXMgbm90IGhhcHBlbiBvbiBXaW45eC9NRSAqLwoJICAgIGxwbWlpLT5kd1R5cGVEYXRhID0gMDsKCSAgICBscG1paS0+Y2NoID0gMDsKICAgICAgICB9CiAgICB9CgogICAgLyogY29weSB0aGUgdGV4dCBzdHJpbmcgKi8KICAgIGlmICgobHBtaWktPmZNYXNrICYgKE1JSU1fVFlQRXxNSUlNX1NUUklORykpKSB7CiAgICAgICAgIGlmKCAhbWVudS0+dGV4dCApIHsKICAgICAgICAgICAgICAgIGlmKGxwbWlpLT5kd1R5cGVEYXRhICYmIGxwbWlpLT5jY2gpIHsKICAgICAgICAgICAgICAgICAgICBscG1paS0+Y2NoID0gMDsKICAgICAgICAgICAgICAgICAgICBpZiggdW5pY29kZSkKICAgICAgICAgICAgICAgICAgICAgICAgKigoV0NIQVIgKilscG1paS0+ZHdUeXBlRGF0YSkgPSAwOwogICAgICAgICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgICAgICAgICAgKigoQ0hBUiAqKWxwbWlpLT5kd1R5cGVEYXRhKSA9IDA7CiAgICAgICAgICAgICAgICB9CiAgICAgICAgIH0gZWxzZSB7CiAgICAgICAgICAgIGludCBsZW47CiAgICAgICAgICAgIGlmICh1bmljb2RlKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBsZW4gPSBzdHJsZW5XKG1lbnUtPnRleHQpOwogICAgICAgICAgICAgICAgaWYobHBtaWktPmR3VHlwZURhdGEgJiYgbHBtaWktPmNjaCkKICAgICAgICAgICAgICAgICAgICBsc3RyY3B5blcobHBtaWktPmR3VHlwZURhdGEsIG1lbnUtPnRleHQsIGxwbWlpLT5jY2gpOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgbGVuID0gV2lkZUNoYXJUb011bHRpQnl0ZSggQ1BfQUNQLCAwLCBtZW51LT50ZXh0LCAtMSwgTlVMTCwKICAgICAgICAgICAgICAgICAgICAgICAgMCwgTlVMTCwgTlVMTCApIC0gMTsKICAgICAgICAgICAgICAgIGlmKGxwbWlpLT5kd1R5cGVEYXRhICYmIGxwbWlpLT5jY2gpCiAgICAgICAgICAgICAgICAgICAgaWYgKCFXaWRlQ2hhclRvTXVsdGlCeXRlKCBDUF9BQ1AsIDAsIG1lbnUtPnRleHQsIC0xLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgKExQU1RSKWxwbWlpLT5kd1R5cGVEYXRhLCBscG1paS0+Y2NoLCBOVUxMLCBOVUxMICkpCiAgICAgICAgICAgICAgICAgICAgICAgICgoTFBTVFIpbHBtaWktPmR3VHlwZURhdGEpW2xwbWlpLT5jY2ggLSAxXSA9IDA7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgLyogaWYgd2UndmUgY29waWVkIGEgc3Vic3RyaW5nIHdlIHJldHVybiBpdHMgbGVuZ3RoICovCiAgICAgICAgICAgIGlmKGxwbWlpLT5kd1R5cGVEYXRhICYmIGxwbWlpLT5jY2gpCiAgICAgICAgICAgICAgICBpZiAobHBtaWktPmNjaCA8PSBsZW4gKyAxKQogICAgICAgICAgICAgICAgICAgIGxwbWlpLT5jY2gtLTsKICAgICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgICAgICBscG1paS0+Y2NoID0gbGVuOwogICAgICAgICAgICBlbHNlIHsKICAgICAgICAgICAgICAgIC8qIHJldHVybiBsZW5ndGggb2Ygc3RyaW5nICovCiAgICAgICAgICAgICAgICAvKiBub3Qgb24gV2luOXgvTUUgaWYgZlR5cGUgJiBNRlRfQklUTUFQICovCiAgICAgICAgICAgICAgICBscG1paS0+Y2NoID0gbGVuOwogICAgICAgICAgICB9CiAgICAgICAgfQogICAgfQoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX0ZUWVBFKQoJbHBtaWktPmZUeXBlID0gbWVudS0+ZlR5cGUgJiBNRU5VSVRFTUlORk9fVFlQRV9NQVNLOwoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX0JJVE1BUCkKCWxwbWlpLT5oYm1wSXRlbSA9IG1lbnUtPmhibXBJdGVtOwoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX1NUQVRFKQoJbHBtaWktPmZTdGF0ZSA9IG1lbnUtPmZTdGF0ZSAmIE1FTlVJVEVNSU5GT19TVEFURV9NQVNLOwoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX0lEKQoJbHBtaWktPndJRCA9IG1lbnUtPndJRDsKCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9TVUJNRU5VKQoJbHBtaWktPmhTdWJNZW51ID0gbWVudS0+aFN1Yk1lbnU7CiAgICBlbHNlIHsKICAgICAgICAvKiBoU3ViTWVudSBpcyBhbHdheXMgY2xlYXJlZCAKICAgICAgICAgKiAobm90IG9uIFdpbjl4L01FICkgKi8KICAgICAgICBscG1paS0+aFN1Yk1lbnUgPSAwOwogICAgfQoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX0NIRUNLTUFSS1MpIHsKCWxwbWlpLT5oYm1wQ2hlY2tlZCA9IG1lbnUtPmhDaGVja0JpdDsKCWxwbWlpLT5oYm1wVW5jaGVja2VkID0gbWVudS0+aFVuQ2hlY2tCaXQ7CiAgICB9CiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9EQVRBKQoJbHBtaWktPmR3SXRlbURhdGEgPSBtZW51LT5kd0l0ZW1EYXRhOwoKICByZXR1cm4gVFJVRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCUdldE1lbnVJdGVtSW5mb0EgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgR2V0TWVudUl0ZW1JbmZvQSggSE1FTlUgaG1lbnUsIFVJTlQgaXRlbSwgQk9PTCBieXBvcywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIExQTUVOVUlURU1JTkZPQSBscG1paSkKewogICAgQk9PTCByZXQ7CiAgICBNRU5VSVRFTUlORk9BIG1paTsKICAgIGlmKCBscG1paS0+Y2JTaXplICE9IHNpemVvZiggbWlpKSAmJgogICAgICAgICAgICBscG1paS0+Y2JTaXplICE9IHNpemVvZiggbWlpKSAtIHNpemVvZiAoIG1paS5oYm1wSXRlbSkpIHsKICAgICAgICBTZXRMYXN0RXJyb3IoIEVSUk9SX0lOVkFMSURfUEFSQU1FVEVSKTsKICAgICAgICByZXR1cm4gRkFMU0U7CiAgICB9CiAgICBtZW1jcHkoICZtaWksIGxwbWlpLCBscG1paS0+Y2JTaXplKTsKICAgIG1paS5jYlNpemUgPSBzaXplb2YoIG1paSk7CiAgICByZXQgPSBHZXRNZW51SXRlbUluZm9fY29tbW9uIChobWVudSwgaXRlbSwgYnlwb3MsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChMUE1FTlVJVEVNSU5GT1cpJm1paSwgRkFMU0UpOwogICAgbWlpLmNiU2l6ZSA9IGxwbWlpLT5jYlNpemU7CiAgICBtZW1jcHkoIGxwbWlpLCAmbWlpLCBtaWkuY2JTaXplKTsKICAgIHJldHVybiByZXQ7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCQlHZXRNZW51SXRlbUluZm9XICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIEdldE1lbnVJdGVtSW5mb1coIEhNRU5VIGhtZW51LCBVSU5UIGl0ZW0sIEJPT0wgYnlwb3MsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBMUE1FTlVJVEVNSU5GT1cgbHBtaWkpCnsKICAgIEJPT0wgcmV0OwogICAgTUVOVUlURU1JTkZPVyBtaWk7CiAgICBpZiggbHBtaWktPmNiU2l6ZSAhPSBzaXplb2YoIG1paSkgJiYKICAgICAgICAgICAgbHBtaWktPmNiU2l6ZSAhPSBzaXplb2YoIG1paSkgLSBzaXplb2YgKCBtaWkuaGJtcEl0ZW0pKSB7CiAgICAgICAgU2V0TGFzdEVycm9yKCBFUlJPUl9JTlZBTElEX1BBUkFNRVRFUik7CiAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgfQogICAgbWVtY3B5KCAmbWlpLCBscG1paSwgbHBtaWktPmNiU2l6ZSk7CiAgICBtaWkuY2JTaXplID0gc2l6ZW9mKCBtaWkpOwogICAgcmV0ID0gR2V0TWVudUl0ZW1JbmZvX2NvbW1vbiAoaG1lbnUsIGl0ZW0sIGJ5cG9zLCAmbWlpLCBUUlVFKTsKICAgIG1paS5jYlNpemUgPSBscG1paS0+Y2JTaXplOwogICAgbWVtY3B5KCBscG1paSwgJm1paSwgbWlpLmNiU2l6ZSk7CiAgICByZXR1cm4gcmV0Owp9CgoKLyogc2V0IGEgbWVudSBpdGVtIHRleHQgZnJvbSBhIEFTQ0lJIG9yIFVuaWNvZGUgc3RyaW5nICovCnN0YXRpYyBpbmxpbmUgdm9pZCBzZXRfbWVudV9pdGVtX3RleHQoIE1FTlVJVEVNICptZW51LCBMUENXU1RSIHRleHQsIEJPT0wgdW5pY29kZSApCnsKICAgIGlmICghdGV4dCkKICAgICAgICBtZW51LT50ZXh0ID0gTlVMTDsKICAgIGVsc2UgaWYgKHVuaWNvZGUpCiAgICB7CiAgICAgICAgaWYgKChtZW51LT50ZXh0ID0gSGVhcEFsbG9jKCBHZXRQcm9jZXNzSGVhcCgpLCAwLCAoc3RybGVuVyh0ZXh0KSsxKSAqIHNpemVvZihXQ0hBUikgKSkpCiAgICAgICAgICAgIHN0cmNweVcoIG1lbnUtPnRleHQsIHRleHQgKTsKICAgIH0KICAgIGVsc2UKICAgIHsKICAgICAgICBMUENTVFIgc3RyID0gKExQQ1NUUil0ZXh0OwogICAgICAgIGludCBsZW4gPSBNdWx0aUJ5dGVUb1dpZGVDaGFyKCBDUF9BQ1AsIDAsIHN0ciwgLTEsIE5VTEwsIDAgKTsKICAgICAgICBpZiAoKG1lbnUtPnRleHQgPSBIZWFwQWxsb2MoIEdldFByb2Nlc3NIZWFwKCksIDAsIGxlbiAqIHNpemVvZihXQ0hBUikgKSkpCiAgICAgICAgICAgIE11bHRpQnl0ZVRvV2lkZUNoYXIoIENQX0FDUCwgMCwgc3RyLCAtMSwgbWVudS0+dGV4dCwgbGVuICk7CiAgICB9Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJU2V0TWVudUl0ZW1JbmZvX2NvbW1vbgogKi8KCnN0YXRpYyBCT09MIFNldE1lbnVJdGVtSW5mb19jb21tb24oTUVOVUlURU0gKiBtZW51LAoJCQkJICAgICAgIGNvbnN0IE1FTlVJVEVNSU5GT1cgKmxwbWlpLAoJCQkJICAgICAgIEJPT0wgdW5pY29kZSkKewogICAgaWYgKCFtZW51KSByZXR1cm4gRkFMU0U7CgogICAgZGVidWdfcHJpbnRfbWVudWl0ZW0oIlNldE1lbnVJdGVtSW5mb19jb21tb24gZnJvbTogIiwgbWVudSwgIiIpOwoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX1RZUEUgKSB7CiAgICAgICAgaWYoIGxwbWlpLT5mTWFzayAmICggTUlJTV9TVFJJTkcgfCBNSUlNX0ZUWVBFIHwgTUlJTV9CSVRNQVApKSB7CiAgICAgICAgICAgIFdBUk4oImludmFsaWQgY29tYmluYXRpb24gb2YgZk1hc2sgYml0cyB1c2VkXG4iKTsKICAgICAgICAgICAgLyogdGhpcyBkb2VzIG5vdCBoYXBwZW4gb24gV2luOXgvTUUgKi8KICAgICAgICAgICAgU2V0TGFzdEVycm9yKCBFUlJPUl9JTlZBTElEX1BBUkFNRVRFUik7CiAgICAgICAgICAgIHJldHVybiBGQUxTRTsKICAgICAgICB9CgogICAgICAgIC8qIFJlbW92ZSB0aGUgb2xkIHR5cGUgYml0cyBhbmQgcmVwbGFjZSB0aGVtIHdpdGggdGhlIG5ldyBvbmVzICovCiAgICAgICAgbWVudS0+ZlR5cGUgJj0gfk1FTlVJVEVNSU5GT19UWVBFX01BU0s7CiAgICAgICAgbWVudS0+ZlR5cGUgfD0gbHBtaWktPmZUeXBlICYgTUVOVUlURU1JTkZPX1RZUEVfTUFTSzsKCiAgICAgICAgaWYgKElTX1NUUklOR19JVEVNKG1lbnUtPmZUeXBlKSkgewoJICAgIEhlYXBGcmVlKEdldFByb2Nlc3NIZWFwKCksIDAsIG1lbnUtPnRleHQpOwogICAgICAgICAgICBzZXRfbWVudV9pdGVtX3RleHQoIG1lbnUsIGxwbWlpLT5kd1R5cGVEYXRhLCB1bmljb2RlICk7CiAgICAgICAgfSBlbHNlIGlmKCAobWVudS0+ZlR5cGUpICYgTUZUX0JJVE1BUCkKICAgICAgICAgICAgICAgIG1lbnUtPmhibXBJdGVtID0gSEJJVE1BUF8zMihMT1dPUkQobHBtaWktPmR3VHlwZURhdGEpKTsKICAgIH0KCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9GVFlQRSApIHsKICAgICAgICBpZigoIGxwbWlpLT5mVHlwZSAmIE1GVF9CSVRNQVApKSB7CiAgICAgICAgICAgIFNldExhc3RFcnJvciggRVJST1JfSU5WQUxJRF9QQVJBTUVURVIpOwogICAgICAgICAgICByZXR1cm4gRkFMU0U7CiAgICAgICAgfQogICAgICAgIG1lbnUtPmZUeXBlICY9IH5NRU5VSVRFTUlORk9fVFlQRV9NQVNLOwogICAgICAgIG1lbnUtPmZUeXBlIHw9IGxwbWlpLT5mVHlwZSAmIE1FTlVJVEVNSU5GT19UWVBFX01BU0s7CiAgICB9CiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9TVFJJTkcgKSB7CiAgICAgICAgLyogZnJlZSB0aGUgc3RyaW5nIHdoZW4gdXNlZCAqLwogICAgICAgIEhlYXBGcmVlKEdldFByb2Nlc3NIZWFwKCksIDAsIG1lbnUtPnRleHQpOwogICAgICAgIHNldF9tZW51X2l0ZW1fdGV4dCggbWVudSwgbHBtaWktPmR3VHlwZURhdGEsIHVuaWNvZGUgKTsKICAgIH0KCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9TVEFURSkKICAgIHsKICAgICAgICAgLyogT3RoZXIgbWVudSBpdGVtcyBoYXZpbmcgTUZTX0RFRkFVTFQgYXJlIG5vdCBjb252ZXJ0ZWQKICAgICAgICAgICB0byBub3JtYWwgaXRlbXMgKi8KICAgICAgICAgbWVudS0+ZlN0YXRlID0gbHBtaWktPmZTdGF0ZSAmIE1FTlVJVEVNSU5GT19TVEFURV9NQVNLOwogICAgfQoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX0lEKQoJbWVudS0+d0lEID0gbHBtaWktPndJRDsKCiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9TVUJNRU5VKSB7CgltZW51LT5oU3ViTWVudSA9IGxwbWlpLT5oU3ViTWVudTsKCWlmIChtZW51LT5oU3ViTWVudSkgewoJICAgIFBPUFVQTUVOVSAqc3ViTWVudSA9IE1FTlVfR2V0TWVudShtZW51LT5oU3ViTWVudSk7CgkgICAgaWYgKHN1Yk1lbnUpIHsKCQlzdWJNZW51LT53RmxhZ3MgfD0gTUZfUE9QVVA7CgkJbWVudS0+ZlR5cGUgfD0gTUZfUE9QVVA7CgkgICAgfQoJICAgIGVsc2UgewogICAgICAgICAgICAgICAgU2V0TGFzdEVycm9yKCBFUlJPUl9JTlZBTElEX1BBUkFNRVRFUik7CiAgICAgICAgICAgICAgICByZXR1cm4gRkFMU0U7CiAgICAgICAgICAgIH0KCX0KCWVsc2UKCSAgICBtZW51LT5mVHlwZSAmPSB+TUZfUE9QVVA7CiAgICB9CgogICAgaWYgKGxwbWlpLT5mTWFzayAmIE1JSU1fQ0hFQ0tNQVJLUykKICAgIHsKCW1lbnUtPmhDaGVja0JpdCA9IGxwbWlpLT5oYm1wQ2hlY2tlZDsKCW1lbnUtPmhVbkNoZWNrQml0ID0gbHBtaWktPmhibXBVbmNoZWNrZWQ7CiAgICB9CiAgICBpZiAobHBtaWktPmZNYXNrICYgTUlJTV9EQVRBKQoJbWVudS0+ZHdJdGVtRGF0YSA9IGxwbWlpLT5kd0l0ZW1EYXRhOwoKICAgIGlmIChscG1paS0+Zk1hc2sgJiBNSUlNX0JJVE1BUCkKCW1lbnUtPmhibXBJdGVtID0gbHBtaWktPmhibXBJdGVtOwoKICAgIGlmKCAhbWVudS0+dGV4dCAmJiAhKG1lbnUtPmZUeXBlICYgTUZUX09XTkVSRFJBVykgJiYgIW1lbnUtPmhibXBJdGVtKQogICAgICAgIG1lbnUtPmZUeXBlIHw9IE1GVF9TRVBBUkFUT1I7CgogICAgZGVidWdfcHJpbnRfbWVudWl0ZW0oIlNldE1lbnVJdGVtSW5mb19jb21tb24gdG8gOiAiLCBtZW51LCAiIik7CiAgICByZXR1cm4gVFJVRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCVNldE1lbnVJdGVtSW5mb0EgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgU2V0TWVudUl0ZW1JbmZvQShITUVOVSBobWVudSwgVUlOVCBpdGVtLCBCT09MIGJ5cG9zLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBNRU5VSVRFTUlORk9BICpscG1paSkKewogICAgTUVOVUlURU1JTkZPQSBtaWk7CgogICAgVFJBQ0UoImhtZW51ICVwLCBpdGVtICV1LCBieSBwb3MgJWQsIGluZm8gJXBcbiIsIGhtZW51LCBpdGVtLCBieXBvcywgbHBtaWkpOwoKICAgIGlmKCBscG1paS0+Y2JTaXplICE9IHNpemVvZiggbWlpKSAmJgogICAgICAgICAgICBscG1paS0+Y2JTaXplICE9IHNpemVvZiggbWlpKSAtIHNpemVvZiAoIG1paS5oYm1wSXRlbSkpIHsKICAgICAgICBTZXRMYXN0RXJyb3IoIEVSUk9SX0lOVkFMSURfUEFSQU1FVEVSKTsKICAgICAgICByZXR1cm4gRkFMU0U7CiAgICB9CiAgICBtZW1jcHkoICZtaWksIGxwbWlpLCBscG1paS0+Y2JTaXplKTsKICAgIGlmKCBscG1paS0+Y2JTaXplICE9IHNpemVvZiggbWlpKSkgewogICAgICAgIG1paS5jYlNpemUgPSBzaXplb2YoIG1paSk7CiAgICAgICAgbWlpLmhibXBJdGVtID0gTlVMTDsKICAgIH0KICAgIHJldHVybiBTZXRNZW51SXRlbUluZm9fY29tbW9uKE1FTlVfRmluZEl0ZW0oJmhtZW51LCAmaXRlbSwgYnlwb3M/IE1GX0JZUE9TSVRJT04gOiAwKSwKCQkJCSAgICAoY29uc3QgTUVOVUlURU1JTkZPVyAqKSZtaWksIEZBTFNFKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCVNldE1lbnVJdGVtSW5mb1cgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgU2V0TWVudUl0ZW1JbmZvVyhITUVOVSBobWVudSwgVUlOVCBpdGVtLCBCT09MIGJ5cG9zLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBNRU5VSVRFTUlORk9XICpscG1paSkKewogICAgTUVOVUlURU1JTkZPVyBtaWk7CgogICAgVFJBQ0UoImhtZW51ICVwLCBpdGVtICV1LCBieSBwb3MgJWQsIGluZm8gJXBcbiIsIGhtZW51LCBpdGVtLCBieXBvcywgbHBtaWkpOwoKICAgIGlmKCBscG1paS0+Y2JTaXplICE9IHNpemVvZiggbWlpKSAmJgogICAgICAgICAgICBscG1paS0+Y2JTaXplICE9IHNpemVvZiggbWlpKSAtIHNpemVvZiAoIG1paS5oYm1wSXRlbSkpIHsKICAgICAgICBTZXRMYXN0RXJyb3IoIEVSUk9SX0lOVkFMSURfUEFSQU1FVEVSKTsKICAgICAgICByZXR1cm4gRkFMU0U7CiAgICB9CiAgICBtZW1jcHkoICZtaWksIGxwbWlpLCBscG1paS0+Y2JTaXplKTsKICAgIGlmKCBscG1paS0+Y2JTaXplICE9IHNpemVvZiggbWlpKSkgewogICAgICAgIG1paS5jYlNpemUgPSBzaXplb2YoIG1paSk7CiAgICAgICAgbWlpLmhibXBJdGVtID0gTlVMTDsKICAgIH0KICAgIHJldHVybiBTZXRNZW51SXRlbUluZm9fY29tbW9uKE1FTlVfRmluZEl0ZW0oJmhtZW51LAogICAgICAgICAgICAgICAgJml0ZW0sIGJ5cG9zPyBNRl9CWVBPU0lUSU9OIDogMCksICZtaWksIFRSVUUpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJU2V0TWVudURlZmF1bHRJdGVtICAgIChVU0VSMzIuQCkKICoKICovCkJPT0wgV0lOQVBJIFNldE1lbnVEZWZhdWx0SXRlbShITUVOVSBobWVudSwgVUlOVCB1SXRlbSwgVUlOVCBieXBvcykKewoJVUlOVCBpOwoJUE9QVVBNRU5VICptZW51OwoJTUVOVUlURU0gKml0ZW07CgoJVFJBQ0UoIiglcCwlZCwlZClcbiIsIGhtZW51LCB1SXRlbSwgYnlwb3MpOwoKCWlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoaG1lbnUpKSkgcmV0dXJuIEZBTFNFOwoKCS8qIHJlc2V0IGFsbCBkZWZhdWx0LWl0ZW0gZmxhZ3MgKi8KCWl0ZW0gPSBtZW51LT5pdGVtczsKCWZvciAoaSA9IDA7IGkgPCBtZW51LT5uSXRlbXM7IGkrKywgaXRlbSsrKQoJewoJICAgIGl0ZW0tPmZTdGF0ZSAmPSB+TUZTX0RFRkFVTFQ7Cgl9CgoJLyogbm8gZGVmYXVsdCBpdGVtICovCglpZiAoIC0xID09IHVJdGVtKQoJewoJICAgIHJldHVybiBUUlVFOwoJfQoKCWl0ZW0gPSBtZW51LT5pdGVtczsKCWlmICggYnlwb3MgKQoJewoJICAgIGlmICggdUl0ZW0gPj0gbWVudS0+bkl0ZW1zICkgcmV0dXJuIEZBTFNFOwoJICAgIGl0ZW1bdUl0ZW1dLmZTdGF0ZSB8PSBNRlNfREVGQVVMVDsKCSAgICByZXR1cm4gVFJVRTsKCX0KCWVsc2UKCXsKCSAgICBmb3IgKGkgPSAwOyBpIDwgbWVudS0+bkl0ZW1zOyBpKyssIGl0ZW0rKykKCSAgICB7CgkJaWYgKGl0ZW0tPndJRCA9PSB1SXRlbSkKCQl7CgkJICAgICBpdGVtLT5mU3RhdGUgfD0gTUZTX0RFRkFVTFQ7CgkJICAgICByZXR1cm4gVFJVRTsKCQl9CgkgICAgfQoKCX0KCXJldHVybiBGQUxTRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCUdldE1lbnVEZWZhdWx0SXRlbSAgICAoVVNFUjMyLkApCiAqLwpVSU5UIFdJTkFQSSBHZXRNZW51RGVmYXVsdEl0ZW0oSE1FTlUgaG1lbnUsIFVJTlQgYnlwb3MsIFVJTlQgZmxhZ3MpCnsKCVBPUFVQTUVOVSAqbWVudTsKCU1FTlVJVEVNICogaXRlbTsKCVVJTlQgaSA9IDA7CgoJVFJBQ0UoIiglcCwlZCwlZClcbiIsIGhtZW51LCBieXBvcywgZmxhZ3MpOwoKCWlmICghKG1lbnUgPSBNRU5VX0dldE1lbnUoaG1lbnUpKSkgcmV0dXJuIC0xOwoKCS8qIGZpbmQgZGVmYXVsdCBpdGVtICovCglpdGVtID0gbWVudS0+aXRlbXM7CgoJLyogZW1wdHkgbWVudSAqLwoJaWYgKCEgaXRlbSkgcmV0dXJuIC0xOwoKCXdoaWxlICggISggaXRlbS0+ZlN0YXRlICYgTUZTX0RFRkFVTFQgKSApCgl7CgkgICAgaSsrOyBpdGVtKys7CgkgICAgaWYgIChpID49IG1lbnUtPm5JdGVtcyApIHJldHVybiAtMTsKCX0KCgkvKiBkZWZhdWx0OiBkb24ndCByZXR1cm4gZGlzYWJsZWQgaXRlbXMgKi8KCWlmICggKCEoR01ESV9VU0VESVNBQkxFRCAmIGZsYWdzKSkgJiYgKGl0ZW0tPmZTdGF0ZSAmIE1GU19ESVNBQkxFRCApKSByZXR1cm4gLTE7CgoJLyogc2VhcmNoIHJla3Vyc2l2IHdoZW4gbmVlZGVkICovCglpZiAoIChpdGVtLT5mVHlwZSAmIE1GX1BPUFVQKSAmJiAgKGZsYWdzICYgR01ESV9HT0lOVE9QT1BVUFMpICkKCXsKCSAgICBVSU5UIHJldDsKCSAgICByZXQgPSBHZXRNZW51RGVmYXVsdEl0ZW0oIGl0ZW0tPmhTdWJNZW51LCBieXBvcywgZmxhZ3MgKTsKCSAgICBpZiAoIC0xICE9IHJldCApIHJldHVybiByZXQ7CgoJICAgIC8qIHdoZW4gaXRlbSBub3QgZm91bmQgaW4gc3VibWVudSwgcmV0dXJuIHRoZSBwb3B1cCBpdGVtICovCgl9CglyZXR1cm4gKCBieXBvcyApID8gaSA6IGl0ZW0tPndJRDsKCn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJSW5zZXJ0TWVudUl0ZW1BICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIEluc2VydE1lbnVJdGVtQShITUVOVSBoTWVudSwgVUlOVCB1SXRlbSwgQk9PTCBieXBvcywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBNRU5VSVRFTUlORk9BICpscG1paSkKewogICAgTUVOVUlURU0gKml0ZW07CiAgICBNRU5VSVRFTUlORk9BIG1paTsKCiAgICBUUkFDRSgiaG1lbnUgJXAsIGl0ZW0gJTA0eCwgYnkgcG9zICVkLCBpbmZvICVwXG4iLCBoTWVudSwgdUl0ZW0sIGJ5cG9zLCBscG1paSk7CgogICAgaWYoIGxwbWlpLT5jYlNpemUgIT0gc2l6ZW9mKCBtaWkpICYmCiAgICAgICAgICAgIGxwbWlpLT5jYlNpemUgIT0gc2l6ZW9mKCBtaWkpIC0gc2l6ZW9mICggbWlpLmhibXBJdGVtKSkgewogICAgICAgIFNldExhc3RFcnJvciggRVJST1JfSU5WQUxJRF9QQVJBTUVURVIpOwogICAgICAgIHJldHVybiBGQUxTRTsKICAgIH0KICAgIG1lbWNweSggJm1paSwgbHBtaWksIGxwbWlpLT5jYlNpemUpOwogICAgaWYoIGxwbWlpLT5jYlNpemUgIT0gc2l6ZW9mKCBtaWkpKSB7CiAgICAgICAgbWlpLmNiU2l6ZSA9IHNpemVvZiggbWlpKTsKICAgICAgICBtaWkuaGJtcEl0ZW0gPSBOVUxMOwogICAgfQoKICAgIGl0ZW0gPSBNRU5VX0luc2VydEl0ZW0oaE1lbnUsIHVJdGVtLCBieXBvcyA/IE1GX0JZUE9TSVRJT04gOiAwICk7CiAgICByZXR1cm4gU2V0TWVudUl0ZW1JbmZvX2NvbW1vbihpdGVtLCAoY29uc3QgTUVOVUlURU1JTkZPVyAqKSZtaWksIEZBTFNFKTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCQlJbnNlcnRNZW51SXRlbVcgICAgKFVTRVIzMi5AKQogKi8KQk9PTCBXSU5BUEkgSW5zZXJ0TWVudUl0ZW1XKEhNRU5VIGhNZW51LCBVSU5UIHVJdGVtLCBCT09MIGJ5cG9zLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IE1FTlVJVEVNSU5GT1cgKmxwbWlpKQp7CiAgICBNRU5VSVRFTSAqaXRlbTsKICAgIE1FTlVJVEVNSU5GT1cgbWlpOwoKICAgIFRSQUNFKCJobWVudSAlcCwgaXRlbSAlMDR4LCBieSBwb3MgJWQsIGluZm8gJXBcbiIsIGhNZW51LCB1SXRlbSwgYnlwb3MsIGxwbWlpKTsKCiAgICBpZiggbHBtaWktPmNiU2l6ZSAhPSBzaXplb2YoIG1paSkgJiYKICAgICAgICAgICAgbHBtaWktPmNiU2l6ZSAhPSBzaXplb2YoIG1paSkgLSBzaXplb2YgKCBtaWkuaGJtcEl0ZW0pKSB7CiAgICAgICAgU2V0TGFzdEVycm9yKCBFUlJPUl9JTlZBTElEX1BBUkFNRVRFUik7CiAgICAgICAgcmV0dXJuIEZBTFNFOwogICAgfQogICAgbWVtY3B5KCAmbWlpLCBscG1paSwgbHBtaWktPmNiU2l6ZSk7CiAgICBpZiggbHBtaWktPmNiU2l6ZSAhPSBzaXplb2YoIG1paSkpIHsKICAgICAgICBtaWkuY2JTaXplID0gc2l6ZW9mKCBtaWkpOwogICAgICAgIG1paS5oYm1wSXRlbSA9IE5VTEw7CiAgICB9CgogICAgaXRlbSA9IE1FTlVfSW5zZXJ0SXRlbShoTWVudSwgdUl0ZW0sIGJ5cG9zID8gTUZfQllQT1NJVElPTiA6IDAgKTsKICAgIHJldHVybiBTZXRNZW51SXRlbUluZm9fY29tbW9uKGl0ZW0sICZtaWksIFRSVUUpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgkJQ2hlY2tNZW51UmFkaW9JdGVtICAgIChVU0VSMzIuQCkKICovCgpCT09MIFdJTkFQSSBDaGVja01lbnVSYWRpb0l0ZW0oSE1FTlUgaE1lbnUsCgkJCQkgICBVSU5UIGZpcnN0LCBVSU5UIGxhc3QsIFVJTlQgY2hlY2ssCgkJCQkgICBVSU5UIGJ5cG9zKQp7CiAgICBCT09MIGRvbmUgPSBGQUxTRTsKICAgIFVJTlQgaTsKICAgIE1FTlVJVEVNICptaV9maXJzdCA9IE5VTEwsICptaV9jaGVjazsKICAgIEhNRU5VIG1fZmlyc3QsIG1fY2hlY2s7CgogICAgZm9yIChpID0gZmlyc3Q7IGkgPD0gbGFzdDsgaSsrKQogICAgewogICAgICAgIFVJTlQgcG9zID0gaTsKCiAgICAgICAgaWYgKCFtaV9maXJzdCkKICAgICAgICB7CiAgICAgICAgICAgIG1fZmlyc3QgPSBoTWVudTsKICAgICAgICAgICAgbWlfZmlyc3QgPSBNRU5VX0ZpbmRJdGVtKCZtX2ZpcnN0LCAmcG9zLCBieXBvcyk7CiAgICAgICAgICAgIGlmICghbWlfZmlyc3QpIGNvbnRpbnVlOwogICAgICAgICAgICBtaV9jaGVjayA9IG1pX2ZpcnN0OwogICAgICAgICAgICBtX2NoZWNrID0gbV9maXJzdDsKICAgICAgICB9CiAgICAgICAgZWxzZQogICAgICAgIHsKICAgICAgICAgICAgbV9jaGVjayA9IGhNZW51OwogICAgICAgICAgICBtaV9jaGVjayA9IE1FTlVfRmluZEl0ZW0oJm1fY2hlY2ssICZwb3MsIGJ5cG9zKTsKICAgICAgICAgICAgaWYgKCFtaV9jaGVjaykgY29udGludWU7CiAgICAgICAgfQoKICAgICAgICBpZiAobV9maXJzdCAhPSBtX2NoZWNrKSBjb250aW51ZTsKICAgICAgICBpZiAobWlfY2hlY2stPmZUeXBlID09IE1GVF9TRVBBUkFUT1IpIGNvbnRpbnVlOwoKICAgICAgICBpZiAoaSA9PSBjaGVjaykKICAgICAgICB7CiAgICAgICAgICAgIG1pX2NoZWNrLT5mVHlwZSB8PSBNRlRfUkFESU9DSEVDSzsKICAgICAgICAgICAgbWlfY2hlY2stPmZTdGF0ZSB8PSBNRlNfQ0hFQ0tFRDsKICAgICAgICAgICAgZG9uZSA9IFRSVUU7CiAgICAgICAgfQogICAgICAgIGVsc2UKICAgICAgICB7CiAgICAgICAgICAgIC8qIE1TRE4gaXMgd3JvbmcsIFdpbmRvd3MgZG9lcyBub3QgcmVtb3ZlIE1GVF9SQURJT0NIRUNLICovCiAgICAgICAgICAgIG1pX2NoZWNrLT5mU3RhdGUgJj0gfk1GU19DSEVDS0VEOwogICAgICAgIH0KICAgIH0KCiAgICByZXR1cm4gZG9uZTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCQlHZXRNZW51SXRlbVJlY3QgICAgKFVTRVIzMi5AKQogKgogKiAgICAgIEFUVEVOVElPTjogSGVyZSwgdGhlIHJldHVybmVkIHZhbHVlcyBpbiByZWN0IGFyZSB0aGUgc2NyZWVuCiAqICAgICAgICAgICAgICAgICBjb29yZGluYXRlcyBvZiB0aGUgaXRlbSBqdXN0IGxpa2UgaWYgdGhlIG1lbnUgd2FzCiAqICAgICAgICAgICAgICAgICBhbHdheXMgb24gdGhlIHVwcGVyIGxlZnQgc2lkZSBvZiB0aGUgYXBwbGljYXRpb24uCiAqCiAqLwpCT09MIFdJTkFQSSBHZXRNZW51SXRlbVJlY3QgKEhXTkQgaHduZCwgSE1FTlUgaE1lbnUsIFVJTlQgdUl0ZW0sCgkJCQkgTFBSRUNUIHJlY3QpCnsKICAgICBQT1BVUE1FTlUgKml0ZW1NZW51OwogICAgIE1FTlVJVEVNICppdGVtOwogICAgIEhXTkQgcmVmZXJlbmNlSHduZDsKCiAgICAgVFJBQ0UoIiglcCwlcCwlZCwlcClcbiIsIGh3bmQsIGhNZW51LCB1SXRlbSwgcmVjdCk7CgogICAgIGl0ZW0gPSBNRU5VX0ZpbmRJdGVtICgmaE1lbnUsICZ1SXRlbSwgTUZfQllQT1NJVElPTik7CiAgICAgcmVmZXJlbmNlSHduZCA9IGh3bmQ7CgogICAgIGlmKCFod25kKQogICAgIHsKCSBpdGVtTWVudSA9IE1FTlVfR2V0TWVudShoTWVudSk7CgkgaWYgKGl0ZW1NZW51ID09IE5VTEwpCgkgICAgIHJldHVybiBGQUxTRTsKCgkgaWYoaXRlbU1lbnUtPmhXbmQgPT0gMCkKCSAgICAgcmV0dXJuIEZBTFNFOwoJIHJlZmVyZW5jZUh3bmQgPSBpdGVtTWVudS0+aFduZDsKICAgICB9CgogICAgIGlmICgocmVjdCA9PSBOVUxMKSB8fCAoaXRlbSA9PSBOVUxMKSkKCSByZXR1cm4gRkFMU0U7CgogICAgICpyZWN0ID0gaXRlbS0+cmVjdDsKCiAgICAgTWFwV2luZG93UG9pbnRzKHJlZmVyZW5jZUh3bmQsIDAsIChMUFBPSU5UKXJlY3QsIDIpOwoKICAgICByZXR1cm4gVFJVRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqCQlTZXRNZW51SW5mbyAgICAoVVNFUjMyLkApCiAqCiAqIEZJWE1FCiAqCU1JTV9BUFBMWVRPU1VCTUVOVVMKICoJYWN0dWFsbHkgdXNlIHRoZSBpdGVtcyB0byBkcmF3IHRoZSBtZW51CiAqLwpCT09MIFdJTkFQSSBTZXRNZW51SW5mbyAoSE1FTlUgaE1lbnUsIExQQ01FTlVJTkZPIGxwbWkpCnsKICAgIFBPUFVQTUVOVSAqbWVudTsKCiAgICBUUkFDRSgiKCVwICVwKVxuIiwgaE1lbnUsIGxwbWkpOwoKICAgIGlmIChscG1pICYmIChscG1pLT5jYlNpemU9PXNpemVvZihNRU5VSU5GTykpICYmIChtZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KSkpCiAgICB7CgoJaWYgKGxwbWktPmZNYXNrICYgTUlNX0JBQ0tHUk9VTkQpCgkgICAgbWVudS0+aGJyQmFjayA9IGxwbWktPmhickJhY2s7CgoJaWYgKGxwbWktPmZNYXNrICYgTUlNX0hFTFBJRCkKCSAgICBtZW51LT5kd0NvbnRleHRIZWxwSUQgPSBscG1pLT5kd0NvbnRleHRIZWxwSUQ7CgoJaWYgKGxwbWktPmZNYXNrICYgTUlNX01BWEhFSUdIVCkKCSAgICBtZW51LT5jeU1heCA9IGxwbWktPmN5TWF4OwoKCWlmIChscG1pLT5mTWFzayAmIE1JTV9NRU5VREFUQSkKCSAgICBtZW51LT5kd01lbnVEYXRhID0gbHBtaS0+ZHdNZW51RGF0YTsKCglpZiAobHBtaS0+Zk1hc2sgJiBNSU1fU1RZTEUpCgl7CgkgICAgbWVudS0+ZHdTdHlsZSA9IGxwbWktPmR3U3R5bGU7CgkgICAgaWYgKG1lbnUtPmR3U3R5bGUgJiBNTlNfQVVUT0RJU01JU1MpIEZJWE1FKCJNTlNfQVVUT0RJU01JU1MgdW5pbXBsZW1lbnRlZFxuIik7CgkgICAgaWYgKG1lbnUtPmR3U3R5bGUgJiBNTlNfRFJBR0RST1ApIEZJWE1FKCJNTlNfRFJBR0RST1AgdW5pbXBsZW1lbnRlZFxuIik7CgkgICAgaWYgKG1lbnUtPmR3U3R5bGUgJiBNTlNfTU9ERUxFU1MpIEZJWE1FKCJNTlNfTU9ERUxFU1MgdW5pbXBsZW1lbnRlZFxuIik7CgkgICAgaWYgKG1lbnUtPmR3U3R5bGUgJiBNTlNfTk9USUZZQllQT1MpIEZJWE1FKCJNTlNfTk9USUZZQllQT1MgcGFydGlhbGx5IGltcGxlbWVudGVkXG4iKTsKCX0KCglyZXR1cm4gVFJVRTsKICAgIH0KICAgIHJldHVybiBGQUxTRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICoJCUdldE1lbnVJbmZvICAgIChVU0VSMzIuQCkKICoKICogIE5PVEVTCiAqCXdpbjk4L05UNS4wCiAqCiAqLwpCT09MIFdJTkFQSSBHZXRNZW51SW5mbyAoSE1FTlUgaE1lbnUsIExQTUVOVUlORk8gbHBtaSkKeyAgIFBPUFVQTUVOVSAqbWVudTsKCiAgICBUUkFDRSgiKCVwICVwKVxuIiwgaE1lbnUsIGxwbWkpOwoKICAgIGlmIChscG1pICYmIChtZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KSkpCiAgICB7CgoJaWYgKGxwbWktPmZNYXNrICYgTUlNX0JBQ0tHUk9VTkQpCgkgICAgbHBtaS0+aGJyQmFjayA9IG1lbnUtPmhickJhY2s7CgoJaWYgKGxwbWktPmZNYXNrICYgTUlNX0hFTFBJRCkKCSAgICBscG1pLT5kd0NvbnRleHRIZWxwSUQgPSBtZW51LT5kd0NvbnRleHRIZWxwSUQ7CgoJaWYgKGxwbWktPmZNYXNrICYgTUlNX01BWEhFSUdIVCkKCSAgICBscG1pLT5jeU1heCA9IG1lbnUtPmN5TWF4OwoKCWlmIChscG1pLT5mTWFzayAmIE1JTV9NRU5VREFUQSkKCSAgICBscG1pLT5kd01lbnVEYXRhID0gbWVudS0+ZHdNZW51RGF0YTsKCglpZiAobHBtaS0+Zk1hc2sgJiBNSU1fU1RZTEUpCgkgICAgbHBtaS0+ZHdTdHlsZSA9IG1lbnUtPmR3U3R5bGU7CgoJcmV0dXJuIFRSVUU7CiAgICB9CiAgICByZXR1cm4gRkFMU0U7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgIFNldE1lbnVDb250ZXh0SGVscElkICAgIChVU0VSMzIuQCkKICovCkJPT0wgV0lOQVBJIFNldE1lbnVDb250ZXh0SGVscElkKCBITUVOVSBoTWVudSwgRFdPUkQgZHdDb250ZXh0SGVscElEKQp7CiAgICBMUFBPUFVQTUVOVSBtZW51OwoKICAgIFRSQUNFKCIoJXAgMHglMDh4KVxuIiwgaE1lbnUsIGR3Q29udGV4dEhlbHBJRCk7CgogICAgaWYgKChtZW51ID0gTUVOVV9HZXRNZW51KGhNZW51KSkpCiAgICB7CgltZW51LT5kd0NvbnRleHRIZWxwSUQgPSBkd0NvbnRleHRIZWxwSUQ7CglyZXR1cm4gVFJVRTsKICAgIH0KICAgIHJldHVybiBGQUxTRTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqICAgICAgICAgR2V0TWVudUNvbnRleHRIZWxwSWQgICAgKFVTRVIzMi5AKQogKi8KRFdPUkQgV0lOQVBJIEdldE1lbnVDb250ZXh0SGVscElkKCBITUVOVSBoTWVudSApCnsKICAgIExQUE9QVVBNRU5VIG1lbnU7CgogICAgVFJBQ0UoIiglcClcbiIsIGhNZW51KTsKCiAgICBpZiAoKG1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpKSkKICAgIHsKCXJldHVybiBtZW51LT5kd0NvbnRleHRIZWxwSUQ7CiAgICB9CiAgICByZXR1cm4gMDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICAgICBNZW51SXRlbUZyb21Qb2ludCAgICAoVVNFUjMyLkApCiAqLwpJTlQgV0lOQVBJIE1lbnVJdGVtRnJvbVBvaW50KEhXTkQgaFduZCwgSE1FTlUgaE1lbnUsIFBPSU5UIHB0U2NyZWVuKQp7CiAgICBQT1BVUE1FTlUgKm1lbnUgPSBNRU5VX0dldE1lbnUoaE1lbnUpOwogICAgVUlOVCBwb3M7CgogICAgLypGSVhNRTogRG8gd2UgaGF2ZSB0byBoYW5kbGUgaFduZCBoZXJlPyAqLwogICAgaWYgKCFtZW51KSByZXR1cm4gLTE7CiAgICBpZiAoIU1FTlVfRmluZEl0ZW1CeUNvb3JkcyhtZW51LCBwdFNjcmVlbiwgJnBvcykpIHJldHVybiAtMTsKICAgIHJldHVybiBwb3M7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgdHJhbnNsYXRlX2FjY2VsZXJhdG9yCiAqLwpzdGF0aWMgQk9PTCB0cmFuc2xhdGVfYWNjZWxlcmF0b3IoIEhXTkQgaFduZCwgVUlOVCBtZXNzYWdlLCBXUEFSQU0gd1BhcmFtLCBMUEFSQU0gbFBhcmFtLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEJZVEUgZlZpcnQsIFdPUkQga2V5LCBXT1JEIGNtZCApCnsKICAgIElOVCBtYXNrID0gMDsKICAgIFVJTlQgbWVzZyA9IDA7CgogICAgaWYgKHdQYXJhbSAhPSBrZXkpIHJldHVybiBGQUxTRTsKCiAgICBpZiAoR2V0S2V5U3RhdGUoVktfQ09OVFJPTCkgJiAweDgwMDApIG1hc2sgfD0gRkNPTlRST0w7CiAgICBpZiAoR2V0S2V5U3RhdGUoVktfTUVOVSkgJiAweDgwMDApIG1hc2sgfD0gRkFMVDsKICAgIGlmIChHZXRLZXlTdGF0ZShWS19TSElGVCkgJiAweDgwMDApIG1hc2sgfD0gRlNISUZUOwoKICAgIGlmIChtZXNzYWdlID09IFdNX0NIQVIgfHwgbWVzc2FnZSA9PSBXTV9TWVNDSEFSKQogICAgewogICAgICAgIGlmICggIShmVmlydCAmIEZWSVJUS0VZKSAmJiAobWFzayAmIEZBTFQpID09IChmVmlydCAmIEZBTFQpICkKICAgICAgICB7CiAgICAgICAgICAgIFRSQUNFXyhhY2NlbCkoImZvdW5kIGFjY2VsIGZvciBXTV9DSEFSOiAoJyVjJylcbiIsIExPV09SRCh3UGFyYW0pICYgMHhmZik7CiAgICAgICAgICAgIGdvdG8gZm91bmQ7CiAgICAgICAgfQogICAgfQogICAgZWxzZQogICAgewogICAgICAgIGlmKGZWaXJ0ICYgRlZJUlRLRVkpCiAgICAgICAgewogICAgICAgICAgICBUUkFDRV8oYWNjZWwpKCJmb3VuZCBhY2NlbCBmb3IgdmlydF9rZXkgJTA0bHggKHNjYW4gJTA0eClcbiIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgd1BhcmFtLCAweGZmICYgSElXT1JEKGxQYXJhbSkpOwoKICAgICAgICAgICAgaWYobWFzayA9PSAoZlZpcnQgJiAoRlNISUZUIHwgRkNPTlRST0wgfCBGQUxUKSkpIGdvdG8gZm91bmQ7CiAgICAgICAgICAgIFRSQUNFXyhhY2NlbCkoIiwgYnV0IGluY29ycmVjdCBTSElGVC9DVFJML0FMVC1zdGF0ZVxuIik7CiAgICAgICAgfQogICAgICAgIGVsc2UKICAgICAgICB7CiAgICAgICAgICAgIGlmICghKGxQYXJhbSAmIDB4MDEwMDAwMDApKSAgLyogbm8gc3BlY2lhbF9rZXkgKi8KICAgICAgICAgICAgewogICAgICAgICAgICAgICAgaWYgKChmVmlydCAmIEZBTFQpICYmIChsUGFyYW0gJiAweDIwMDAwMDAwKSkKICAgICAgICAgICAgICAgIHsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAvKiBeXiBBTFQgcHJlc3NlZCAqLwogICAgICAgICAgICAgICAgICAgIFRSQUNFXyhhY2NlbCkoImZvdW5kIGFjY2VsIGZvciBBbHQtJWNcbiIsIExPV09SRCh3UGFyYW0pICYgMHhmZik7CiAgICAgICAgICAgICAgICAgICAgZ290byBmb3VuZDsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfQogICAgICAgIH0KICAgIH0KICAgIHJldHVybiBGQUxTRTsKCiBmb3VuZDoKICAgIGlmIChtZXNzYWdlID09IFdNX0tFWVVQIHx8IG1lc3NhZ2UgPT0gV01fU1lTS0VZVVApCiAgICAgICAgbWVzZyA9IDE7CiAgICBlbHNlCiAgICB7CiAgICAgICAgSE1FTlUgaE1lbnUsIGhTdWJNZW51LCBoU3lzTWVudTsKICAgICAgICBVSU5UIHVTeXNTdGF0ID0gKFVJTlQpLTEsIHVTdGF0ID0gKFVJTlQpLTEsIG5Qb3M7CgogICAgICAgIGhNZW51ID0gKEdldFdpbmRvd0xvbmdXKCBoV25kLCBHV0xfU1RZTEUgKSAmIFdTX0NISUxEKSA/IDAgOiBHZXRNZW51KGhXbmQpOwogICAgICAgIGhTeXNNZW51ID0gZ2V0X3dpbl9zeXNfbWVudSggaFduZCApOwoKICAgICAgICAvKiBmaW5kIG1lbnUgaXRlbSBhbmQgYXNrIGFwcGxpY2F0aW9uIHRvIGluaXRpYWxpemUgaXQgKi8KICAgICAgICAvKiAxLiBpbiB0aGUgc3lzdGVtIG1lbnUgKi8KICAgICAgICBoU3ViTWVudSA9IGhTeXNNZW51OwogICAgICAgIG5Qb3MgPSBjbWQ7CiAgICAgICAgaWYoTUVOVV9GaW5kSXRlbSgmaFN1Yk1lbnUsICZuUG9zLCBNRl9CWUNPTU1BTkQpKQogICAgICAgIHsKICAgICAgICAgICAgaWYgKEdldENhcHR1cmUoKSkKICAgICAgICAgICAgICAgIG1lc2cgPSAyOwogICAgICAgICAgICBpZiAoIUlzV2luZG93RW5hYmxlZChoV25kKSkKICAgICAgICAgICAgICAgIG1lc2cgPSAzOwogICAgICAgICAgICBlbHNlCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIFNlbmRNZXNzYWdlVyhoV25kLCBXTV9JTklUTUVOVSwgKFdQQVJBTSloU3lzTWVudSwgMEwpOwogICAgICAgICAgICAgICAgaWYoaFN1Yk1lbnUgIT0gaFN5c01lbnUpCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgblBvcyA9IE1FTlVfRmluZFN1Yk1lbnUoJmhTeXNNZW51LCBoU3ViTWVudSk7CiAgICAgICAgICAgICAgICAgICAgVFJBQ0VfKGFjY2VsKSgiaFN5c01lbnUgPSAlcCwgaFN1Yk1lbnUgPSAlcCwgblBvcyA9ICVkXG4iLCBoU3lzTWVudSwgaFN1Yk1lbnUsIG5Qb3MpOwogICAgICAgICAgICAgICAgICAgIFNlbmRNZXNzYWdlVyhoV25kLCBXTV9JTklUTUVOVVBPUFVQLCAoV1BBUkFNKWhTdWJNZW51LCBNQUtFTFBBUkFNKG5Qb3MsIFRSVUUpKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIHVTeXNTdGF0ID0gR2V0TWVudVN0YXRlKEdldFN1Yk1lbnUoaFN5c01lbnUsIDApLCBjbWQsIE1GX0JZQ09NTUFORCk7CiAgICAgICAgICAgIH0KICAgICAgICB9CiAgICAgICAgZWxzZSAvKiAyLiBpbiB0aGUgd2luZG93J3MgbWVudSAqLwogICAgICAgIHsKICAgICAgICAgICAgaFN1Yk1lbnUgPSBoTWVudTsKICAgICAgICAgICAgblBvcyA9IGNtZDsKICAgICAgICAgICAgaWYoTUVOVV9GaW5kSXRlbSgmaFN1Yk1lbnUsICZuUG9zLCBNRl9CWUNPTU1BTkQpKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBpZiAoR2V0Q2FwdHVyZSgpKQogICAgICAgICAgICAgICAgICAgIG1lc2cgPSAyOwogICAgICAgICAgICAgICAgaWYgKCFJc1dpbmRvd0VuYWJsZWQoaFduZCkpCiAgICAgICAgICAgICAgICAgICAgbWVzZyA9IDM7CiAgICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgU2VuZE1lc3NhZ2VXKGhXbmQsIFdNX0lOSVRNRU5VLCAoV1BBUkFNKWhNZW51LCAwTCk7CiAgICAgICAgICAgICAgICAgICAgaWYoaFN1Yk1lbnUgIT0gaE1lbnUpCiAgICAgICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgICAgICBuUG9zID0gTUVOVV9GaW5kU3ViTWVudSgmaE1lbnUsIGhTdWJNZW51KTsKICAgICAgICAgICAgICAgICAgICAgICAgVFJBQ0VfKGFjY2VsKSgiaE1lbnUgPSAlcCwgaFN1Yk1lbnUgPSAlcCwgblBvcyA9ICVkXG4iLCBoTWVudSwgaFN1Yk1lbnUsIG5Qb3MpOwogICAgICAgICAgICAgICAgICAgICAgICBTZW5kTWVzc2FnZVcoaFduZCwgV01fSU5JVE1FTlVQT1BVUCwgKFdQQVJBTSloU3ViTWVudSwgTUFLRUxQQVJBTShuUG9zLCBGQUxTRSkpOwogICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICB1U3RhdCA9IEdldE1lbnVTdGF0ZShoTWVudSwgY21kLCBNRl9CWUNPTU1BTkQpOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CiAgICAgICAgfQoKICAgICAgICBpZiAobWVzZyA9PSAwKQogICAgICAgIHsKICAgICAgICAgICAgaWYgKHVTeXNTdGF0ICE9IChVSU5UKS0xKQogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICBpZiAodVN5c1N0YXQgJiAoTUZfRElTQUJMRUR8TUZfR1JBWUVEKSkKICAgICAgICAgICAgICAgICAgICBtZXNnPTQ7CiAgICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICAgICAgbWVzZz1XTV9TWVNDT01NQU5EOwogICAgICAgICAgICB9CiAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgaWYgKHVTdGF0ICE9IChVSU5UKS0xKQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIGlmIChJc0ljb25pYyhoV25kKSkKICAgICAgICAgICAgICAgICAgICAgICAgbWVzZz01OwogICAgICAgICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgICAgIGlmICh1U3RhdCAmIChNRl9ESVNBQkxFRHxNRl9HUkFZRUQpKQogICAgICAgICAgICAgICAgICAgICAgICAgICAgbWVzZz02OwogICAgICAgICAgICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBtZXNnPVdNX0NPTU1BTkQ7CiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICAgICAgIG1lc2c9V01fQ09NTUFORDsKICAgICAgICAgICAgfQogICAgICAgIH0KICAgIH0KCiAgICBpZiggbWVzZz09V01fQ09NTUFORCApCiAgICB7CiAgICAgICAgVFJBQ0VfKGFjY2VsKSgiLCBzZW5kaW5nIFdNX0NPTU1BTkQsIHdQYXJhbT0lMHhcbiIsIDB4MTAwMDAgfCBjbWQpOwogICAgICAgIFNlbmRNZXNzYWdlVyhoV25kLCBtZXNnLCAweDEwMDAwIHwgY21kLCAwTCk7CiAgICB9CiAgICBlbHNlIGlmKCBtZXNnPT1XTV9TWVNDT01NQU5EICkKICAgIHsKICAgICAgICBUUkFDRV8oYWNjZWwpKCIsIHNlbmRpbmcgV01fU1lTQ09NTUFORCwgd1BhcmFtPSUweFxuIiwgY21kKTsKICAgICAgICBTZW5kTWVzc2FnZVcoaFduZCwgbWVzZywgY21kLCAweDAwMDEwMDAwTCk7CiAgICB9CiAgICBlbHNlCiAgICB7CiAgICAgICAgLyogIHNvbWUgcmVhc29ucyBmb3IgTk9UIHNlbmRpbmcgdGhlIFdNX3tTWVN9Q09NTUFORCBtZXNzYWdlOgogICAgICAgICAqICAgIzA6IHVua25vd24gKHBsZWFzZSByZXBvcnQhKQogICAgICAgICAqICAgIzE6IGZvciBXTV9LRVlVUCxXTV9TWVNLRVlVUAogICAgICAgICAqICAgIzI6IG1vdXNlIGlzIGNhcHR1cmVkCiAgICAgICAgICogICAjMzogd2luZG93IGlzIGRpc2FibGVkCiAgICAgICAgICogICAjNDogaXQncyBhIGRpc2FibGVkIHN5c3RlbSBtZW51IG9wdGlvbgogICAgICAgICAqICAgIzU6IGl0J3MgYSBtZW51IG9wdGlvbiwgYnV0IHdpbmRvdyBpcyBpY29uaWMKICAgICAgICAgKiAgICM2OiBpdCdzIGEgbWVudSBvcHRpb24sIGJ1dCBkaXNhYmxlZAogICAgICAgICAqLwogICAgICAgIFRSQUNFXyhhY2NlbCkoIiwgYnV0IHdvbid0IHNlbmQgV01fe1NZU31DT01NQU5ELCByZWFzb24gaXMgIyVkXG4iLG1lc2cpOwogICAgICAgIGlmKG1lc2c9PTApCiAgICAgICAgICAgIEVSUl8oYWNjZWwpKCIgdW5rbm93biByZWFzb24gLSBwbGVhc2UgcmVwb3J0IVxuIik7CiAgICB9CiAgICByZXR1cm4gVFJVRTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICBUcmFuc2xhdGVBY2NlbGVyYXRvckEgICAgIChVU0VSMzIuQCkKICogICAgICBUcmFuc2xhdGVBY2NlbGVyYXRvciAgICAgIChVU0VSMzIuQCkKICovCklOVCBXSU5BUEkgVHJhbnNsYXRlQWNjZWxlcmF0b3JBKCBIV05EIGhXbmQsIEhBQ0NFTCBoQWNjZWwsIExQTVNHIG1zZyApCnsKICAgIC8qIFlFUywgQWNjZWwxNiEgKi8KICAgIExQQUNDRUwxNiBscEFjY2VsVGJsOwogICAgaW50IGk7CiAgICBXUEFSQU0gd1BhcmFtOwoKICAgIGlmICghaFduZCB8fCAhbXNnKSByZXR1cm4gMDsKCiAgICBpZiAoIWhBY2NlbCB8fCAhKGxwQWNjZWxUYmwgPSAoTFBBQ0NFTDE2KSBMb2NrUmVzb3VyY2UxNihIQUNDRUxfMTYoaEFjY2VsKSkpKQogICAgewogICAgICAgIFdBUk5fKGFjY2VsKSgiaW52YWxpZCBhY2NlbCBoYW5kbGU9JXBcbiIsIGhBY2NlbCk7CiAgICAgICAgcmV0dXJuIDA7CiAgICB9CgogICAgd1BhcmFtID0gbXNnLT53UGFyYW07CgogICAgc3dpdGNoIChtc2ctPm1lc3NhZ2UpCiAgICB7CiAgICBjYXNlIFdNX0tFWURPV046CiAgICBjYXNlIFdNX1NZU0tFWURPV046CiAgICAgICAgYnJlYWs7CgogICAgY2FzZSBXTV9DSEFSOgogICAgY2FzZSBXTV9TWVNDSEFSOgogICAgICAgIHsKICAgICAgICAgICAgY2hhciBjaCA9IExPV09SRCh3UGFyYW0pOwogICAgICAgICAgICBXQ0hBUiB3Y2g7CiAgICAgICAgICAgIE11bHRpQnl0ZVRvV2lkZUNoYXIoQ1BfQUNQLCAwLCAmY2gsIDEsICZ3Y2gsIDEpOwogICAgICAgICAgICB3UGFyYW0gPSBNQUtFV1BBUkFNKHdjaCwgSElXT1JEKHdQYXJhbSkpOwogICAgICAgIH0KICAgICAgICBicmVhazsKCiAgICBkZWZhdWx0OgogICAgICAgIHJldHVybiAwOwogICAgfQoKICAgIFRSQUNFXyhhY2NlbCkoImhBY2NlbCAlcCwgaFduZCAlcCwgbXNnLT5od25kICVwLCBtc2ctPm1lc3NhZ2UgJTA0eCwgd1BhcmFtICUwOGx4LCBsUGFyYW0gJTA4bHhcbiIsCiAgICAgICAgICAgICAgICAgIGhBY2NlbCxoV25kLG1zZy0+aHduZCxtc2ctPm1lc3NhZ2UsbXNnLT53UGFyYW0sbXNnLT5sUGFyYW0pOwogICAgaSA9IDA7CiAgICBkbwogICAgewogICAgICAgIGlmICh0cmFuc2xhdGVfYWNjZWxlcmF0b3IoIGhXbmQsIG1zZy0+bWVzc2FnZSwgd1BhcmFtLCBtc2ctPmxQYXJhbSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBscEFjY2VsVGJsW2ldLmZWaXJ0LCBscEFjY2VsVGJsW2ldLmtleSwgbHBBY2NlbFRibFtpXS5jbWQpKQogICAgICAgICAgICByZXR1cm4gMTsKICAgIH0gd2hpbGUgKChscEFjY2VsVGJsW2krK10uZlZpcnQgJiAweDgwKSA9PSAwKTsKCiAgICByZXR1cm4gMDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogICAgICBUcmFuc2xhdGVBY2NlbGVyYXRvclcgICAgIChVU0VSMzIuQCkKICovCklOVCBXSU5BUEkgVHJhbnNsYXRlQWNjZWxlcmF0b3JXKCBIV05EIGhXbmQsIEhBQ0NFTCBoQWNjZWwsIExQTVNHIG1zZyApCnsKICAgIC8qIFlFUywgQWNjZWwxNiEgKi8KICAgIExQQUNDRUwxNiBscEFjY2VsVGJsOwogICAgaW50IGk7CgogICAgaWYgKCFoV25kIHx8ICFtc2cpIHJldHVybiAwOwoKICAgIGlmICghaEFjY2VsIHx8ICEobHBBY2NlbFRibCA9IChMUEFDQ0VMMTYpIExvY2tSZXNvdXJjZTE2KEhBQ0NFTF8xNihoQWNjZWwpKSkpCiAgICB7CiAgICAgICAgV0FSTl8oYWNjZWwpKCJpbnZhbGlkIGFjY2VsIGhhbmRsZT0lcFxuIiwgaEFjY2VsKTsKICAgICAgICByZXR1cm4gMDsKICAgIH0KCiAgICBzd2l0Y2ggKG1zZy0+bWVzc2FnZSkKICAgIHsKICAgIGNhc2UgV01fS0VZRE9XTjoKICAgIGNhc2UgV01fU1lTS0VZRE9XTjoKICAgIGNhc2UgV01fQ0hBUjoKICAgIGNhc2UgV01fU1lTQ0hBUjoKICAgICAgICBicmVhazsKCiAgICBkZWZhdWx0OgogICAgICAgIHJldHVybiAwOwogICAgfQoKICAgIFRSQUNFXyhhY2NlbCkoImhBY2NlbCAlcCwgaFduZCAlcCwgbXNnLT5od25kICVwLCBtc2ctPm1lc3NhZ2UgJTA0eCwgd1BhcmFtICUwOGx4LCBsUGFyYW0gJTA4bHhcbiIsCiAgICAgICAgICAgICAgICAgIGhBY2NlbCxoV25kLG1zZy0+aHduZCxtc2ctPm1lc3NhZ2UsbXNnLT53UGFyYW0sbXNnLT5sUGFyYW0pOwogICAgaSA9IDA7CiAgICBkbwogICAgewogICAgICAgIGlmICh0cmFuc2xhdGVfYWNjZWxlcmF0b3IoIGhXbmQsIG1zZy0+bWVzc2FnZSwgbXNnLT53UGFyYW0sIG1zZy0+bFBhcmFtLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGxwQWNjZWxUYmxbaV0uZlZpcnQsIGxwQWNjZWxUYmxbaV0ua2V5LCBscEFjY2VsVGJsW2ldLmNtZCkpCiAgICAgICAgICAgIHJldHVybiAxOwogICAgfSB3aGlsZSAoKGxwQWNjZWxUYmxbaSsrXS5mVmlydCAmIDB4ODApID09IDApOwoKICAgIHJldHVybiAwOwp9Cg==