LyoKICogTU1JTyBmdW5jdGlvbnMKICoKICogQ29weXJpZ2h0IDE5OTggQW5kcmV3IFRheWxvcgogKiBDb3B5cmlnaHQgMTk5OCBPdmUgS+V2ZW4KICoKICovCgoKI2luY2x1ZGUgPHN0ZGxpYi5oPgojaW5jbHVkZSA8c3RyaW5nLmg+CiNpbmNsdWRlIDxlcnJuby5oPgojaW5jbHVkZSAid2luZG93cy5oIgojaW5jbHVkZSAid2luLmgiCiNpbmNsdWRlICJoZWFwLmgiCiNpbmNsdWRlICJ1c2VyLmgiCiNpbmNsdWRlICJmaWxlLmgiCiNpbmNsdWRlICJtbXN5c3RlbS5oIgojaW5jbHVkZSAiZGVidWcuaCIKI2luY2x1ZGUgInhtYWxsb2MuaCIKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAgICAgICAgICAgICAgIG1taW9Eb3NJT1Byb2MgICAgICAgICAgIFtpbnRlcm5hbF0KICovCnN0YXRpYyBMUkVTVUxUIG1taW9Eb3NJT1Byb2MoTFBNTUlPSU5GTzE2IGxwbW1pb2luZm8sIFVJTlQxNiB1TWVzc2FnZSwgTFBBUkFNIGxQYXJhbTEsIExQQVJBTSBsUGFyYW0yKSB7CglUUkFDRShtbWlvLCAiKCVwLCAlWCwgJWxkLCAlbGQpO1xuIiwgbHBtbWlvaW5mbywgdU1lc3NhZ2UsIGxQYXJhbTEsIGxQYXJhbTIpOwoKCXN3aXRjaCAodU1lc3NhZ2UpIHsKCgkJY2FzZSBNTUlPTV9PUEVOOiB7CgkJCS8qIFBhcmFtZXRlcnM6CgkJCSAqIGxQYXJhbTEgPSBzekZpbGVOYW1lIHBhcmFtZXRlciBmcm9tIG1taW9PcGVuCgkJCSAqIGxQYXJhbTIgPSByZXNlcnZlZCAod2UgdXNlIGl0IGZvciAxNi1iaXRuZXNzKQoJCQkgKiBSZXR1cm5zOiB6ZXJvIG9uIHN1Y2Nlc3MsIGVycm9yIGNvZGUgb24gZXJyb3IKCQkJICogTk9URTogbERpc2tPZmZzZXQgYXV0b21hdGljYWxseSBzZXQgdG8gemVybwoJCQkgKi8KCgkJCU9GU1RSVUNUIG9mczsKCQkJTFBTVFIgc3pGaWxlTmFtZSA9IChMUFNUUikgbFBhcmFtMTsKCgkJCWlmIChscG1taW9pbmZvLT5kd0ZsYWdzICYgTU1JT19HRVRURU1QKSB7CgkJCQlGSVhNRShtbWlvLCAiTU1JT19HRVRURU1QIG5vdCBpbXBsZW1lbnRlZFxuIik7CgkJCQlyZXR1cm4gTU1JT0VSUl9DQU5OT1RPUEVOOwoJCQl9CgoJCQkvKiBpZiBmaWxlbmFtZSBOVUxMLCBhc3N1bWUgb3BlbiBmaWxlIGhhbmRsZSBpbiBhZHdJbmZvWzBdICovCgkJCWlmICghc3pGaWxlTmFtZSkgewoJCQkJaWYgKGxQYXJhbTIpIGxwbW1pb2luZm8tPmFkd0luZm9bMF0gPQoJCQkJCUZJTEVfR2V0SGFuZGxlMzIobHBtbWlvaW5mby0+YWR3SW5mb1swXSk7CgkJCQlyZXR1cm4gMDsKCQkJfQoKCQkJbHBtbWlvaW5mby0+YWR3SW5mb1swXSA9CgkJCQkoRFdPUkQpIE9wZW5GaWxlMzIoc3pGaWxlTmFtZSwgJm9mcywgbHBtbWlvaW5mby0+ZHdGbGFncyk7CgkJCWlmIChscG1taW9pbmZvLT5hZHdJbmZvWzBdID09IC0xKQoJCQkJcmV0dXJuIE1NSU9FUlJfQ0FOTk9UT1BFTjsKCgkJCXJldHVybiAwOwoJCX0KCgkJY2FzZSBNTUlPTV9DTE9TRTogewoJCQkvKiBQYXJhbWV0ZXJzOgoJCQkgKiBsUGFyYW0xID0gd0ZsYWdzIHBhcmFtZXRlciBmcm9tIG1taW9DbG9zZQoJCQkgKiBsUGFyYW0yID0gdW51c2VkCgkJCSAqIFJldHVybnM6IHplcm8gb24gc3VjY2VzcywgZXJyb3IgY29kZSBvbiBlcnJvcgoJCQkgKi8KCgkJCVVJTlQxNiB1RmxhZ3MgPSAoVUlOVDE2KSBsUGFyYW0xOwoKCQkJaWYgKHVGbGFncyAmIE1NSU9fRkhPUEVOKQoJCQkJcmV0dXJuIDA7CgoJCQlfbGNsb3NlMzIoKEhGSUxFMzIpbHBtbWlvaW5mby0+YWR3SW5mb1swXSk7CgkJCXJldHVybiAwOwoKCQl9CgoJCWNhc2UgTU1JT01fUkVBRDogewoJCQkvKiBQYXJhbWV0ZXJzOgoJCQkgKiBsUGFyYW0xID0gaHVnZSBwb2ludGVyIHRvIHJlYWQgYnVmZmVyCgkJCSAqIGxQYXJhbTIgPSBudW1iZXIgb2YgYnl0ZXMgdG8gcmVhZAoJCQkgKiBSZXR1cm5zOiBudW1iZXIgb2YgYnl0ZXMgcmVhZCwgMCBmb3IgRU9GLCAtMSBmb3IgZXJyb3IgKGVycm9yIGNvZGUKCQkJICoJICAgaW4gd0Vycm9yUmV0KQoJCQkgKiBOT1RFOiBsRGlza09mZnNldCBzaG91bGQgYmUgdXBkYXRlZAoJCQkgKi8KCgkJCUhQU1RSIHBjaCA9IChIUFNUUikgbFBhcmFtMTsKCQkJTE9ORyBjY2ggPSAoTE9ORykgbFBhcmFtMjsKCQkJTE9ORyBjb3VudDsKCgkJCWNvdW50ID0gX2xyZWFkMzIoKEhGSUxFMzIpbHBtbWlvaW5mby0+YWR3SW5mb1swXSwgcGNoLCBjY2gpOwoJCQlpZiAoY291bnQgIT0gLTEpCgkJCQlscG1taW9pbmZvLT5sRGlza09mZnNldCArPSBjb3VudDsKCgkJCXJldHVybiBjb3VudDsKCQl9CgoJCWNhc2UgTU1JT01fV1JJVEU6CgkJY2FzZSBNTUlPTV9XUklURUZMVVNIOiB7IAoJCQkvKiBubyBpbnRlcm5hbCBidWZmZXJpbmcsIHNvIFdSSVRFRkxVU0ggaGFuZGxlZCBzYW1lIGFzIFdSSVRFICovCgoJCQkvKiBQYXJhbWV0ZXJzOgoJCQkgKiBsUGFyYW0xID0gaHVnZSBwb2ludGVyIHRvIHdyaXRlIGJ1ZmZlcgoJCQkgKiBsUGFyYW0yID0gbnVtYmVyIG9mIGJ5dGVzIHRvIHdyaXRlCgkJCSAqIFJldHVybnM6IG51bWJlciBvZiBieXRlcyB3cml0dGVuLCAtMSBmb3IgZXJyb3IgKGVycm9yIGNvZGUgaW4KCQkJICoJCXdFcnJvclJldCkKCQkJICogTk9URTogbERpc2tPZmZzZXQgc2hvdWxkIGJlIHVwZGF0ZWQKCQkJICovCgoJCQlIUFNUUiBwY2ggPSAoSFBTVFIpIGxQYXJhbTE7CgkJCUxPTkcgY2NoID0gKExPTkcpIGxQYXJhbTI7CgkJCUxPTkcgY291bnQ7CgoJCQljb3VudCA9IF9od3JpdGUzMigoSEZJTEUzMilscG1taW9pbmZvLT5hZHdJbmZvWzBdLCBwY2gsIGNjaCk7CgkJCWlmIChjb3VudCAhPSAtMSkKCQkJCWxwbW1pb2luZm8tPmxEaXNrT2Zmc2V0ICs9IGNvdW50OwoKCQkJcmV0dXJuIGNvdW50OwoJCX0KCgkJY2FzZSBNTUlPTV9TRUVLOiB7CiAgICAgICAgICAgIC8qIFBhcmFtZXRlcnM6CiAgICAgICAgICAgICAqIGxQYXJhbTEgPSBuZXcgcG9zaXRpb24KICAgICAgICAgICAgICogbFBhcmFtMiA9IGZyb20gd2hlbmNlIHRvIHNlZWsgKFNFRUtfU0VULCBTRUVLX0NVUiwgU0VFS19FTkQpCiAgICAgICAgICAgICAqIFJldHVybnM6IG5ldyBmaWxlIHBvc3Rpb24sIC0xIG9uIGVycm9yCiAgICAgICAgICAgICAqIE5PVEU6IGxEaXNrT2Zmc2V0IHNob3VsZCBiZSB1cGRhdGVkCiAgICAgICAgICAgICAqLwoKICAgICAgICAgICAgTE9ORyBPZmZzZXQgPSAoTE9ORykgbFBhcmFtMTsgCiAgICAgICAgICAgIExPTkcgV2hlbmNlID0gKExPTkcpIGxQYXJhbTI7IAogICAgICAgICAgICBMT05HIHBvczsKCiAgICAgICAgICAgIHBvcyA9IF9sbHNlZWszMigoSEZJTEUzMilscG1taW9pbmZvLT5hZHdJbmZvWzBdLCBPZmZzZXQsIFdoZW5jZSk7CiAgICAgICAgICAgIGlmIChwb3MgIT0gLTEpCiAgICAgICAgICAgICAgICBscG1taW9pbmZvLT5sRGlza09mZnNldCA9IHBvczsKCiAgICAgICAgICAgIHJldHVybiBwb3M7CgkJfQoJCSAgCgkJY2FzZSBNTUlPTV9SRU5BTUU6IHsKICAgICAgICAgICAgLyogUGFyYW1ldGVyczoKICAgICAgICAgICAgICogbFBhcmFtMSA9IG9sZCBuYW1lCiAgICAgICAgICAgICAqIGxQYXJhbTIgPSBuZXcgbmFtZQogICAgICAgICAgICAgKiBSZXR1cm5zOiB6ZXJvIG9uIHN1Y2Nlc3MsIG5vbi16ZXJvIG9uIGZhaWx1cmUKICAgICAgICAgICAgICovCgogICAgICAgICAgICBGSVhNRShtbWlvLCAiTU1JT01fUkVOQU1FIHVuaW1wbGVtZW50ZWRcbiIpOwogICAgICAgICAgICByZXR1cm4gTU1JT0VSUl9GSUxFTk9URk9VTkQ7CgkJfQoKCQlkZWZhdWx0OgoJCQlGSVhNRShtbWlvLCAidW5leHBlY3RlZCBtZXNzYWdlICV1XG4iLCB1TWVzc2FnZSk7CgkJCXJldHVybiAwOwoJfQoJCglyZXR1cm4gMDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiogICAgICAgICAgICAgICBtbWlvTWVtSU9Qcm9jICAgICAgICAgICBbaW50ZXJuYWxdCiovCnN0YXRpYyBMUkVTVUxUIG1taW9NZW1JT1Byb2MoTFBNTUlPSU5GTzE2IGxwbW1pb2luZm8sIFVJTlQxNiB1TWVzc2FnZSwgTFBBUkFNIGxQYXJhbTEsIExQQVJBTSBsUGFyYW0yKSB7CglUUkFDRShtbWlvLCIoJXAsMHglMDR4LDB4JTA4bHgsMHglMDhseClcbiIsbHBtbWlvaW5mbyx1TWVzc2FnZSxsUGFyYW0xLGxQYXJhbTIpOwoJc3dpdGNoICh1TWVzc2FnZSkgewoKCQljYXNlIE1NSU9NX09QRU46IHsKCQkJLyogUGFyYW1ldGVyczoKCQkJICogbFBhcmFtMSA9IGZpbGVuYW1lIChtdXN0IGJlIE5VTEwpCgkJCSAqIGxQYXJhbTIgPSByZXNlcnZlZCAod2UgdXNlIGl0IGZvciAxNi1iaXRuZXNzKQoJCQkgKiBSZXR1cm5zOiB6ZXJvIG9uIHN1Y2Nlc3MsIGVycm9yIGNvZGUgb24gZXJyb3IKCQkJICogTk9URTogbERpc2tPZmZzZXQgYXV0b21hdGljYWxseSBzZXQgdG8gemVybwoJCQkgKi8KCgkJCWlmICghKGxwbW1pb2luZm8tPmR3RmxhZ3MgJiBNTUlPX0NSRUFURSkpCgkJCQlscG1taW9pbmZvLT5wY2hFbmRSZWFkID0gbHBtbWlvaW5mby0+cGNoRW5kV3JpdGU7CgoJCQlyZXR1cm4gMDsKCQl9CgoJCWNhc2UgTU1JT01fQ0xPU0U6IHsKCQkJLyogUGFyYW1ldGVyczoKCQkJICogbFBhcmFtMSA9IHdGbGFncyBwYXJhbWV0ZXIgZnJvbSBtbWlvQ2xvc2UKCQkJICogbFBhcmFtMiA9IHVudXNlZAoJCQkgKiBSZXR1cm5zOiB6ZXJvIG9uIHN1Y2Nlc3MsIGVycm9yIGNvZGUgb24gZXJyb3IKCQkJICovCgoJCQlyZXR1cm4gMDsKCgkJfQoKCQljYXNlIE1NSU9NX1JFQUQ6IHsKCQkJLyogUGFyYW1ldGVyczoKCQkJICogbFBhcmFtMSA9IGh1Z2UgcG9pbnRlciB0byByZWFkIGJ1ZmZlcgoJCQkgKiBsUGFyYW0yID0gbnVtYmVyIG9mIGJ5dGVzIHRvIHJlYWQKCQkJICogUmV0dXJuczogbnVtYmVyIG9mIGJ5dGVzIHJlYWQsIDAgZm9yIEVPRiwgLTEgZm9yIGVycm9yIChlcnJvciBjb2RlCgkJCSAqCSAgIGluIHdFcnJvclJldCkKCQkJICogTk9URTogbERpc2tPZmZzZXQgc2hvdWxkIGJlIHVwZGF0ZWQKCQkJICovCgoJCQkvKiBIUFNUUiBwY2ggPSAoSFBTVFIpIGxQYXJhbTE7ICovCgkJCS8qIExPTkcgY2NoID0gKExPTkcpIGxQYXJhbTI7ICovCgoJCQlGSVhNRShtbWlvLCJNTUlPTV9SRUFEIG9uIG1lbW9yeSBmaWxlcyBzaG91bGQgbm90IG9jY3VyLCBidWZmZXIgbWF5IGJlIGxvc3QhXG4iKTsKCQkJcmV0dXJuIDA7CgkJfQoKCQljYXNlIE1NSU9NX1dSSVRFOgoJCWNhc2UgTU1JT01fV1JJVEVGTFVTSDogeyAKCQkJLyogbm8gaW50ZXJuYWwgYnVmZmVyaW5nLCBzbyBXUklURUZMVVNIIGhhbmRsZWQgc2FtZSBhcyBXUklURSAqLwoKCQkJLyogUGFyYW1ldGVyczoKCQkJICogbFBhcmFtMSA9IGh1Z2UgcG9pbnRlciB0byB3cml0ZSBidWZmZXIKCQkJICogbFBhcmFtMiA9IG51bWJlciBvZiBieXRlcyB0byB3cml0ZQoJCQkgKiBSZXR1cm5zOiBudW1iZXIgb2YgYnl0ZXMgd3JpdHRlbiwgLTEgZm9yIGVycm9yIChlcnJvciBjb2RlIGluCgkJCSAqCQl3RXJyb3JSZXQpCgkJCSAqIE5PVEU6IGxEaXNrT2Zmc2V0IHNob3VsZCBiZSB1cGRhdGVkCgkJCSAqLwoKCQkJLyogSFBTVFIgcGNoID0gKEhQU1RSKSBsUGFyYW0xOyAqLwoJCQkvKiBMT05HIGNjaCA9IChMT05HKSBsUGFyYW0yOyAqLwoKCQkJRklYTUUobW1pbywiTU1JT01fV1JJVEUgb24gbWVtb3J5IGZpbGVzIHNob3VsZCBub3Qgb2NjdXIsIGJ1ZmZlciBtYXkgYmUgbG9zdCFcbiIpOwoJCQlyZXR1cm4gMDsKCQl9CgoJCWNhc2UgTU1JT01fU0VFSzogewoJCQkvKiBQYXJhbWV0ZXJzOgoJCQkgKiBsUGFyYW0xID0gbmV3IHBvc2l0aW9uCgkJCSAqIGxQYXJhbTIgPSBmcm9tIHdoZW5jZSB0byBzZWVrIChTRUVLX1NFVCwgU0VFS19DVVIsIFNFRUtfRU5EKQoJCQkgKiBSZXR1cm5zOiBuZXcgZmlsZSBwb3N0aW9uLCAtMSBvbiBlcnJvcgoJCQkgKiBOT1RFOiBsRGlza09mZnNldCBzaG91bGQgYmUgdXBkYXRlZAoJCQkgKi8KCgkJCS8qIExPTkcgT2Zmc2V0ID0gKExPTkcpIGxQYXJhbTE7ICovCgkJCS8qIExPTkcgV2hlbmNlID0gKExPTkcpIGxQYXJhbTI7ICovCgoJCQlGSVhNRShtbWlvLCJNTUlPTV9TRUVLIG9uIG1lbW9yeSBmaWxlcyBzaG91bGQgbm90IG9jY3VyLCBidWZmZXIgbWF5IGJlIGxvc3QhXG4iKTsKCQkJcmV0dXJuIC0xOwoJCX0KCQkgIAoJCWRlZmF1bHQ6CgkJCUZJWE1FKG1taW8sICJ1bmV4cGVjdGVkIG1lc3NhZ2UgJXVcbiIsIHVNZXNzYWdlKTsKCQkJcmV0dXJuIDA7Cgl9CgkKCXJldHVybiAwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQlNTUlPX09wZW4gICAgICAJCVtpbnRlcm5hbF0KICovCnN0YXRpYyBITU1JTzE2IE1NSU9fT3BlbihMUFNUUiBzekZpbGVOYW1lLCBNTUlPSU5GTzE2ICogbHBtbWlvaW5mbywKCQkJRFdPUkQgZHdPcGVuRmxhZ3MsIGludCB1c2UxNikKewoJTFBNTUlPSU5GTzE2IGxwbW1pbmZvOwoJSE1NSU8xNiBobW1pbzsKCVVJTlQxNiByZXN1bHQ7CgoJVFJBQ0UobW1pbywgIignJXMnLCAlcCwgJTA4bFgpO1xuIiwgc3pGaWxlTmFtZSwgbHBtbWlvaW5mbywgZHdPcGVuRmxhZ3MpOwoKCWhtbWlvID0gR2xvYmFsQWxsb2MxNihHSE5ELCBzaXplb2YoTU1JT0lORk8xNikpOwoJbHBtbWluZm8gPSAoTFBNTUlPSU5GTzE2KUdsb2JhbExvY2sxNihobW1pbyk7CglpZiAobHBtbWluZm8gPT0gTlVMTCkKCQlyZXR1cm4gMDsKCW1lbXNldChscG1taW5mbywgMCwgc2l6ZW9mKE1NSU9JTkZPMTYpKTsKCgkvKiBhc3N1bWUgRE9TIGZpbGUgaWYgbm90IG90aGVyd2lzZSBzcGVjaWZpZWQgKi8KCWlmICghbHBtbWlvaW5mbyB8fAoJCShscG1taW9pbmZvLT5mY2NJT1Byb2MgPT0gMCAmJiBscG1taW9pbmZvLT5wSU9Qcm9jID09IE5VTEwpKSB7CgoJCWxwbW1pbmZvLT5mY2NJT1Byb2MgPSBGT1VSQ0NfRE9TOwoJCWxwbW1pbmZvLT5wSU9Qcm9jID0gKExQTU1JT1BST0MxNikgbW1pb0Rvc0lPUHJvYzsKCX0KCS8qIGlmIGp1c3QgdGhlIGZvdXIgY2hhcmFjdGVyIGNvZGUgaXMgcHJlc2VudCwgbG9vayB1cCBJTyBwcm9jICovCgllbHNlIGlmIChscG1taW9pbmZvLT5wSU9Qcm9jID09IE5VTEwpIHsKCgkJbHBtbWluZm8tPmZjY0lPUHJvYyA9IGxwbW1pb2luZm8tPmZjY0lPUHJvYzsKCQlscG1taW5mby0+cElPUHJvYyA9IG1taW9JbnN0YWxsSU9Qcm9jMTYobHBtbWlvaW5mby0+ZmNjSU9Qcm9jLCBOVUxMLCBNTUlPX0ZJTkRQUk9DKTsKCgl9IAoJLyogaWYgSU8gcHJvYyBzcGVjaWZpZWQsIHVzZSBpdCBhbmQgc3BlY2lmaWVkIGZvdXIgY2hhcmFjdGVyIGNvZGUgKi8KCWVsc2UgewoKCQlscG1taW5mby0+ZmNjSU9Qcm9jID0gbHBtbWlvaW5mby0+ZmNjSU9Qcm9jOwoJCWxwbW1pbmZvLT5wSU9Qcm9jID0gbHBtbWlvaW5mby0+cElPUHJvYzsKCX0KCglpZiAoZHdPcGVuRmxhZ3MgJiBNTUlPX0FMTE9DQlVGKSB7CgkJaWYgKChyZXN1bHQgPSBtbWlvU2V0QnVmZmVyMTYoaG1taW8sIE5VTEwsIE1NSU9fREVGQVVMVEJVRkZFUiwgMCkpKSB7CgkJCWlmIChscG1taW9pbmZvKQoJCQkJbHBtbWlvaW5mby0+d0Vycm9yUmV0ID0gcmVzdWx0OwoJCQlyZXR1cm4gMDsKCQl9Cgl9IGVsc2UKCWlmIChscG1taW5mby0+ZmNjSU9Qcm9jID09IEZPVVJDQ19NRU0pIHsKCQlpZiAoKHJlc3VsdCA9IG1taW9TZXRCdWZmZXIxNihobW1pbywgbHBtbWlvaW5mby0+cGNoQnVmZmVyLCBscG1taW9pbmZvLT5jY2hCdWZmZXIsIDApKSkgewoJCQlpZiAobHBtbWlvaW5mbykKCQkJCWxwbW1pb2luZm8tPndFcnJvclJldCA9IHJlc3VsdDsKCQkJcmV0dXJuIDA7CgkJfQoJfQoKCWxwbW1pbmZvLT5kd0ZsYWdzID0gZHdPcGVuRmxhZ3M7CglscG1taW5mby0+aG1taW8gPSBobW1pbzsKCgkvKiBjYWxsIElPIHByb2MgdG8gYWN0dWFsbHkgb3BlbiBmaWxlICovCglyZXN1bHQgPSAoVUlOVDE2KSBtbWlvU2VuZE1lc3NhZ2UoaG1taW8sIE1NSU9NX09QRU4sIChMUEFSQU0pIHN6RmlsZU5hbWUsIChMUEFSQU0pIHVzZTE2KTsKCglHbG9iYWxVbmxvY2sxNihobW1pbyk7CgoJaWYgKHJlc3VsdCAhPSAwKSB7CgkJR2xvYmFsRnJlZTE2KGhtbWlvKTsKCQlyZXR1cm4gMDsKCX0KCglyZXR1cm4gaG1taW87Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJbW1pb09wZW5XICAgICAgIAkJW1dJTk1NLjEyM10KICovCkhNTUlPMzIgV0lOQVBJIG1taW9PcGVuMzJXKExQV1NUUiBzekZpbGVOYW1lLCBNTUlPSU5GTzMyICogbHBtbWlvaW5mbywKICAgICAgICAgICAgICAgICAgICAgICAgICBEV09SRCBkd09wZW5GbGFncykKewoJTFBTVFIJc3pGbiA9IEhFQVBfc3RyZHVwV3RvQShHZXRQcm9jZXNzSGVhcCgpLDAsc3pGaWxlTmFtZSk7CglITU1JTzMyIHJldCA9IE1NSU9fT3BlbihzekZuLChMUE1NSU9JTkZPMTYpbHBtbWlvaW5mbyxkd09wZW5GbGFncyxGQUxTRSk7CgoJSGVhcEZyZWUoR2V0UHJvY2Vzc0hlYXAoKSwwLHN6Rm4pOwoJcmV0dXJuIHJldDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQltbWlvT3BlbkEgICAgICAgCQlbV0lOTU0uMTIyXQogKi8KSE1NSU8zMiBXSU5BUEkgbW1pb09wZW4zMkEoTFBTVFIgc3pGaWxlTmFtZSwgTU1JT0lORk8zMiAqIGxwbW1pb2luZm8sCiAgICAgICAgICAgICAgICAgICAgICAgICAgRFdPUkQgZHdPcGVuRmxhZ3MpCnsKCXJldHVybiBNTUlPX09wZW4oc3pGaWxlTmFtZSwoTFBNTUlPSU5GTzE2KWxwbW1pb2luZm8sZHdPcGVuRmxhZ3MsRkFMU0UpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCW1taW9PcGVuICAgICAgIAkJW01NU1lTVEVNLjEyMTBdCiAqLwpITU1JTzE2IFdJTkFQSSBtbWlvT3BlbjE2KExQU1RSIHN6RmlsZU5hbWUsIE1NSU9JTkZPMTYgKiBscG1taW9pbmZvLAogICAgICAgICAgICAgICAgICAgICAgICAgIERXT1JEIGR3T3BlbkZsYWdzKQp7CglyZXR1cm4gTU1JT19PcGVuKHN6RmlsZU5hbWUsKExQTU1JT0lORk8xNilscG1taW9pbmZvLGR3T3BlbkZsYWdzLFRSVUUpOwp9CgogICAgCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJbW1pb0Nsb3NlICAgICAgCQlbV0lOTU0uMTE0XQogKi8KTU1SRVNVTFQzMiBXSU5BUEkgbW1pb0Nsb3NlMzIoSE1NSU8zMiBobW1pbywgVUlOVDMyIHVGbGFncykKewoJTFBNTUlPSU5GTzE2IGxwbW1pbmZvOwoJTU1SRVNVTFQzMiByZXN1bHQ7CgoJVFJBQ0UobW1pbywgIiglMDRYLCAlMDRYKTtcbiIsIGhtbWlvLCB1RmxhZ3MpOwoKCWxwbW1pbmZvID0gKExQTU1JT0lORk8xNikgR2xvYmFsTG9jazE2KGhtbWlvKTsKCWlmIChscG1taW5mbyA9PSBOVUxMKQoJCXJldHVybiAwOwoKCS8qIGZsdXNoIHRoZSBmaWxlIC0gaWYgZXJyb3IgcmVwb3J0ZWQsIGlnbm9yZSAqLwoJaWYgKG1taW9GbHVzaDMyKGhtbWlvLCBNTUlPX0VNUFRZQlVGKSAhPSAwKQoJCWxwbW1pbmZvLT5kd0ZsYWdzICY9IH5NTUlPX0RJUlRZOwoKCXJlc3VsdCA9IG1taW9TZW5kTWVzc2FnZShobW1pbyxNTUlPTV9DTE9TRSwoTFBBUkFNKXVGbGFncywoTFBBUkFNKTApOwoKCW1taW9TZXRCdWZmZXIxNihobW1pbywgTlVMTCwgMCwgMCk7CgoJR2xvYmFsVW5sb2NrMTYoaG1taW8pOwoJR2xvYmFsRnJlZTE2KGhtbWlvKTsKCglyZXR1cm4gcmVzdWx0Owp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQltbWlvQ2xvc2UgICAgICAJCVtNTVNZU1RFTS4xMjExXQogKi8KTU1SRVNVTFQxNiBXSU5BUEkgbW1pb0Nsb3NlMTYoSE1NSU8xNiBobW1pbywgVUlOVDE2IHVGbGFncykKewoJcmV0dXJuIG1taW9DbG9zZTMyKGhtbWlvLHVGbGFncyk7Cn0KCgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQltbWlvUmVhZAkgICAgICAgCVtXSU5NTS4xMjRdCiAqLwpMT05HIFdJTkFQSSBtbWlvUmVhZDMyKEhNTUlPMzIgaG1taW8sIEhQU1RSIHBjaCwgTE9ORyBjY2gpCnsKCUxPTkcgY291bnQ7CglMUE1NSU9JTkZPMTYgbHBtbWluZm87CgoJVFJBQ0UobW1pbywgIiglMDRYLCAlcCwgJWxkKTtcbiIsIGhtbWlvLCBwY2gsIGNjaCk7CgoJbHBtbWluZm8gPSAoTFBNTUlPSU5GTzE2KUdsb2JhbExvY2sxNihobW1pbyk7CglpZiAobHBtbWluZm8gPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgoJaWYgKGxwbW1pbmZvLT5wY2hOZXh0ICE9IGxwbW1pbmZvLT5wY2hFbmRSZWFkKSB7CgkJY291bnQgPSBscG1taW5mby0+cGNoRW5kUmVhZCAtIGxwbW1pbmZvLT5wY2hOZXh0OwoJCWlmIChjb3VudCA+IGNjaCB8fCBjb3VudCA8IDApIGNvdW50ID0gY2NoOwoJCW1lbWNweShwY2gsIGxwbW1pbmZvLT5wY2hOZXh0LCBjb3VudCk7CgkJbHBtbWluZm8tPnBjaE5leHQgKz0gY291bnQ7CgkJcGNoICs9IGNvdW50OwoJCWNjaCAtPSBjb3VudDsKCX0gZWxzZQoJCWNvdW50ID0gMDsKCglpZiAoY2NoJiYobHBtbWluZm8tPmZjY0lPUHJvYyE9Rk9VUkNDX01FTSkpIHsKCQlpZiAobHBtbWluZm8tPmNjaEJ1ZmZlcikgewoJCQltbWlvRmx1c2gzMihobW1pbywgTU1JT19FTVBUWUJVRik7CgoJCQl3aGlsZSAoY2NoKSB7CgkJCQlMT05HIHNpemU7CgkJCQlscG1taW5mby0+bEJ1Zk9mZnNldCA9IGxwbW1pbmZvLT5sRGlza09mZnNldDsKCQkJCWxwbW1pbmZvLT5wY2hOZXh0ID0gbHBtbWluZm8tPnBjaEJ1ZmZlcjsKCQkJCWxwbW1pbmZvLT5wY2hFbmRSZWFkID0gbHBtbWluZm8tPnBjaEJ1ZmZlcjsKCQkJCXNpemUgPSBtbWlvU2VuZE1lc3NhZ2UoaG1taW8sIE1NSU9NX1JFQUQsCgkJCQkJCShMUEFSQU0pIGxwbW1pbmZvLT5wY2hCdWZmZXIsCgkJCQkJCShMUEFSQU0pIGxwbW1pbmZvLT5jY2hCdWZmZXIpOwoJCQkJaWYgKHNpemU8PTApIGJyZWFrOwoJCQkJbHBtbWluZm8tPnBjaEVuZFJlYWQgPSBscG1taW5mby0+cGNoQnVmZmVyICsgc2l6ZTsKCQkJCWlmIChzaXplID4gY2NoKSBzaXplID0gY2NoOwoJCQkJbWVtY3B5KHBjaCwgbHBtbWluZm8tPnBjaE5leHQsIHNpemUpOwoJCQkJbHBtbWluZm8tPnBjaE5leHQgKz0gc2l6ZTsKCQkJCXBjaCArPSBzaXplOwoJCQkJY2NoIC09IHNpemU7CgkJCQljb3VudCArPSBzaXplOwoJCQl9CgkJfSBlbHNlIHsKCQkJY291bnQgKz0gbW1pb1NlbmRNZXNzYWdlKGhtbWlvLCBNTUlPTV9SRUFELCAoTFBBUkFNKSBwY2gsIChMUEFSQU0pIGNjaCk7CgkJCWlmIChjb3VudD4wKSBscG1taW5mby0+bEJ1Zk9mZnNldCArPSBjb3VudDsKCQl9Cgl9CgoJR2xvYmFsVW5sb2NrMTYoaG1taW8pOwoJVFJBQ0UobW1pbywgImNvdW50PSVsZFxuIiwgY291bnQpOwoJcmV0dXJuIGNvdW50Owp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCW1taW9SZWFkCSAgICAgICAJW01NU1lTVEVNLjEyMTJdCiAqLwpMT05HIFdJTkFQSSBtbWlvUmVhZDE2KEhNTUlPMTYgaG1taW8sIEhQU1RSIHBjaCwgTE9ORyBjY2gpCnsKCXJldHVybiBtbWlvUmVhZDMyKGhtbWlvLHBjaCxjY2gpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCW1taW9Xcml0ZSAgICAgIAkJW1dJTk1NLjEzM10KICovCkxPTkcgV0lOQVBJIG1taW9Xcml0ZTMyKEhNTUlPMzIgaG1taW8sIEhQQ1NUUiBwY2gsIExPTkcgY2NoKQp7CglMT05HIGNvdW50OwoJTFBNTUlPSU5GTzE2IGxwbW1pbmZvOwoKCVRSQUNFKG1taW8sICIoJTA0WCwgJXAsICVsZCk7XG4iLCBobW1pbywgcGNoLCBjY2gpOwoKCWxwbW1pbmZvID0gKExQTU1JT0lORk8xNilHbG9iYWxMb2NrMTYoaG1taW8pOwoJaWYgKGxwbW1pbmZvID09IE5VTEwpCgkJcmV0dXJuIC0xOwoKCWlmIChscG1taW5mby0+Y2NoQnVmZmVyKSB7CgkJY291bnQgPSAwOwoJCXdoaWxlIChjY2gpIHsKCQkJaWYgKGxwbW1pbmZvLT5wY2hOZXh0ICE9IGxwbW1pbmZvLT5wY2hFbmRXcml0ZSkgewoJCQkJY291bnQgPSBscG1taW5mby0+cGNoRW5kV3JpdGUgLSBscG1taW5mby0+cGNoTmV4dDsKCQkJCWlmIChjb3VudCA+IGNjaCB8fCBjb3VudCA8IDApIGNvdW50ID0gY2NoOwoJCQkJbWVtY3B5KGxwbW1pbmZvLT5wY2hOZXh0LCBwY2gsIGNvdW50KTsKCQkJCWxwbW1pbmZvLT5wY2hOZXh0ICs9IGNvdW50OwoJCQkJcGNoICs9IGNvdW50OwoJCQkJY2NoIC09IGNvdW50OwoJCQkJbHBtbWluZm8tPmR3RmxhZ3MgfD0gTU1JT19ESVJUWTsKCQkJfSBlbHNlCgkJCWlmIChscG1taW5mby0+ZmNjSU9Qcm9jPT1GT1VSQ0NfTUVNKSB7CgkJCQlpZiAobHBtbWluZm8tPmFkd0luZm9bMF0pIHsKCQkJCQkvKiBmcm9tIHdoZXJlIHdvdWxkIHdlIGdldCB0aGUgbWVtb3J5IGhhbmRsZT8gKi8KCQkJCQlGSVhNRShtbWlvLCAibWVtb3J5IGZpbGUgZXhwYW5zaW9uIG5vdCBpbXBsZW1lbnRlZCFcbiIpOwoJCQkJfSBlbHNlIGJyZWFrOwoJCQl9CgoJCQlpZiAobHBtbWluZm8tPnBjaE5leHQgPT0gbHBtbWluZm8tPnBjaEVuZFdyaXRlCgkJCQkmJiBtbWlvRmx1c2gzMihobW1pbywgTU1JT19FTVBUWUJVRikpIGJyZWFrOwoJCX0KCX0gZWxzZSB7CgkJY291bnQgPSBtbWlvU2VuZE1lc3NhZ2UoaG1taW8sIE1NSU9NX1dSSVRFLCAoTFBBUkFNKSBwY2gsIChMUEFSQU0pIGNjaCk7CgkJbHBtbWluZm8tPmxCdWZPZmZzZXQgPSBscG1taW5mby0+bERpc2tPZmZzZXQ7Cgl9CgoJR2xvYmFsVW5sb2NrMTYoaG1taW8pOwoJVFJBQ0UobW1pbywgImNvdW50PSVsZFxuIiwgY291bnQpOwoJcmV0dXJuIGNvdW50Owp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCW1taW9Xcml0ZSAgICAgIAkJW01NU1lTVEVNLjEyMTNdCiAqLwpMT05HIFdJTkFQSSBtbWlvV3JpdGUxNihITU1JTzE2IGhtbWlvLCBIUENTVFIgcGNoLCBMT05HIGNjaCkKewoJcmV0dXJuIG1taW9Xcml0ZTMyKGhtbWlvLHBjaCxjY2gpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCW1taW9TZWVrICAgICAgIAkJW01NU1lTVEVNLjEyMTRdCiAqLwpMT05HIFdJTkFQSSBtbWlvU2VlazMyKEhNTUlPMzIgaG1taW8sIExPTkcgbE9mZnNldCwgSU5UMzIgaU9yaWdpbikKewoJaW50IG9mZnNldDsKCUxQTU1JT0lORk8xNiBscG1taW5mbzsKCglUUkFDRShtbWlvLCAiKCUwNFgsICUwOGxYLCAlZCk7XG4iLCBobW1pbywgbE9mZnNldCwgaU9yaWdpbik7CgoJbHBtbWluZm8gPSAoTFBNTUlPSU5GTzE2KUdsb2JhbExvY2sxNihobW1pbyk7CglpZiAobHBtbWluZm8gPT0gTlVMTCkKCQlyZXR1cm4gLTE7CgoJb2Zmc2V0ID0gKGlPcmlnaW49PVNFRUtfU0VUKT8obE9mZnNldCAtIGxwbW1pbmZvLT5sQnVmT2Zmc2V0KToKCQkgKGlPcmlnaW49PVNFRUtfQ1VSKT8obE9mZnNldCArCgkJIChscG1taW5mby0+cGNoTmV4dCAtIGxwbW1pbmZvLT5wY2hCdWZmZXIpKTotMTsKCglpZiAoKGxwbW1pbmZvLT5jY2hCdWZmZXI8MCl8fAoJICAgICgob2Zmc2V0Pj0wKSYmKG9mZnNldDw9KGxwbW1pbmZvLT5wY2hFbmRSZWFkLWxwbW1pbmZvLT5wY2hCdWZmZXIpKSkpIHsKCQlscG1taW5mby0+cGNoTmV4dCA9IGxwbW1pbmZvLT5wY2hCdWZmZXIgKyBvZmZzZXQ7CgkJR2xvYmFsVW5sb2NrMTYoaG1taW8pOwoJCXJldHVybiBscG1taW5mby0+bEJ1Zk9mZnNldCArIG9mZnNldDsKCX0KCglpZiAoKGxwbW1pbmZvLT5mY2NJT1Byb2M9PUZPVVJDQ19NRU0pfHxtbWlvRmx1c2gzMihobW1pbywgTU1JT19FTVBUWUJVRikpIHsKCQlHbG9iYWxVbmxvY2sxNihobW1pbyk7CgkJcmV0dXJuIC0xOwoJfQoKCW9mZnNldCA9IG1taW9TZW5kTWVzc2FnZShobW1pbywgTU1JT01fU0VFSywgKExQQVJBTSkgbE9mZnNldCwgKExQQVJBTSkgaU9yaWdpbik7CglscG1taW5mby0+bEJ1Zk9mZnNldCA9IGxwbW1pbmZvLT5sRGlza09mZnNldDsKCglHbG9iYWxVbmxvY2sxNihobW1pbyk7CglyZXR1cm4gb2Zmc2V0Owp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCW1taW9TZWVrICAgICAgIAkJW01NU1lTVEVNLjEyMTRdCiAqLwpMT05HIFdJTkFQSSBtbWlvU2VlazE2KEhNTUlPMTYgaG1taW8sIExPTkcgbE9mZnNldCwgSU5UMTYgaU9yaWdpbikKewoJcmV0dXJuIG1taW9TZWVrMzIoaG1taW8sbE9mZnNldCxpT3JpZ2luKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQltbWlvR2V0SW5mbwkgICAgICAgCVtNTVNZU1RFTS4xMjE1XQogKi8KVUlOVDE2IFdJTkFQSSBtbWlvR2V0SW5mbzE2KEhNTUlPMTYgaG1taW8sIE1NSU9JTkZPMTYgKiBscG1taW9pbmZvLCBVSU5UMTYgdUZsYWdzKQp7CglMUE1NSU9JTkZPMTYJbHBtbWluZm87CglUUkFDRShtbWlvLCAibW1pb0dldEluZm9cbiIpOwoJbHBtbWluZm8gPSAoTFBNTUlPSU5GTzE2KUdsb2JhbExvY2sxNihobW1pbyk7CglpZiAobHBtbWluZm8gPT0gTlVMTCkgcmV0dXJuIDA7CgltZW1jcHkobHBtbWlvaW5mbywgbHBtbWluZm8sIHNpemVvZihNTUlPSU5GTzE2KSk7CglHbG9iYWxVbmxvY2sxNihobW1pbyk7CglyZXR1cm4gMDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQltbWlvR2V0SW5mbwkgICAgICAgCVtXSU5NTS4xMThdCiAqLwpVSU5UMzIgV0lOQVBJIG1taW9HZXRJbmZvMzIoSE1NSU8zMiBobW1pbywgTU1JT0lORk8zMipscG1taW9pbmZvLCBVSU5UMzIgdUZsYWdzKQp7CglNTUlPSU5GTzE2CW1taW9pbmZvOwoJTFBNTUlPSU5GTzE2CWxwbW1pbmZvPSZtbWlvaW5mbzsKCVVJTlQxNgkJcmV0OwoKCVRSQUNFKG1taW8sICIoMHglMDR4LCVwLDB4JTA4eClcbiIsaG1taW8sbHBtbWlvaW5mbyx1RmxhZ3MpOwoJcmV0ID0gbW1pb0dldEluZm8xNihobW1pbywmbW1pb2luZm8sdUZsYWdzKTsKCWlmICghcmV0KQoJCXJldHVybiAwOwoJbHBtbWlvaW5mby0+ZHdGbGFncwk9IGxwbW1pbmZvLT5kd0ZsYWdzOwoJbHBtbWlvaW5mby0+ZmNjSU9Qcm9jCT0gbHBtbWluZm8tPmZjY0lPUHJvYzsKCWxwbW1pb2luZm8tPnBJT1Byb2MJPSAoTFBNTUlPUFJPQzMyKWxwbW1pbmZvLT5wSU9Qcm9jOwoJbHBtbWlvaW5mby0+d0Vycm9yUmV0CT0gbHBtbWluZm8tPndFcnJvclJldDsKCWxwbW1pb2luZm8tPmh0YXNrCT0gbHBtbWluZm8tPmh0YXNrOwoJbHBtbWlvaW5mby0+Y2NoQnVmZmVyCT0gbHBtbWluZm8tPmNjaEJ1ZmZlcjsKCWxwbW1pb2luZm8tPnBjaEJ1ZmZlcgk9IGxwbW1pbmZvLT5wY2hCdWZmZXI7CglscG1taW9pbmZvLT5wY2hOZXh0CT0gbHBtbWluZm8tPnBjaE5leHQ7CglscG1taW9pbmZvLT5wY2hFbmRSZWFkCT0gbHBtbWluZm8tPnBjaEVuZFJlYWQ7CglscG1taW9pbmZvLT5wY2hFbmRXcml0ZQk9IGxwbW1pbmZvLT5wY2hFbmRXcml0ZTsKCWxwbW1pb2luZm8tPmxCdWZPZmZzZXQJPSBscG1taW5mby0+bEJ1Zk9mZnNldDsKCWxwbW1pb2luZm8tPmxEaXNrT2Zmc2V0CT0gbHBtbWluZm8tPmxEaXNrT2Zmc2V0OwoJbWVtY3B5KGxwbW1pb2luZm8tPmFkd0luZm8sbHBtbWluZm8tPmFkd0luZm8sc2l6ZW9mKGxwbW1pbmZvLT5hZHdJbmZvKSk7CglscG1taW9pbmZvLT5kd1Jlc2VydmVkMQk9IGxwbW1pbmZvLT5kd1Jlc2VydmVkMTsKCWxwbW1pb2luZm8tPmR3UmVzZXJ2ZWQyCT0gbHBtbWluZm8tPmR3UmVzZXJ2ZWQyOwoJbHBtbWlvaW5mby0+aG1taW8JPSBscG1taW5mby0+aG1taW87CglyZXR1cm4gMDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQltbWlvU2V0SW5mbyAgICAJCVtNTVNZU1RFTS4xMjE2XQogKi8KVUlOVDE2IFdJTkFQSSBtbWlvU2V0SW5mbzE2KEhNTUlPMTYgaG1taW8sIGNvbnN0IE1NSU9JTkZPMTYgKiBscG1taW9pbmZvLCBVSU5UMTYgdUZsYWdzKQp7CglMUE1NSU9JTkZPMTYJbHBtbWluZm87CglUUkFDRShtbWlvLCAibW1pb1NldEluZm9cbiIpOwoJbHBtbWluZm8gPSAoTFBNTUlPSU5GTzE2KUdsb2JhbExvY2sxNihobW1pbyk7CglpZiAobHBtbWluZm8gPT0gTlVMTCkgcmV0dXJuIDA7CglscG1taW5mby0+cGNoTmV4dAk9IGxwbW1pb2luZm8tPnBjaE5leHQ7CglscG1taW5mby0+cGNoRW5kUmVhZAk9IGxwbW1pb2luZm8tPnBjaEVuZFJlYWQ7CglHbG9iYWxVbmxvY2sxNihobW1pbyk7CglyZXR1cm4gMDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQltbWlvU2V0SW5mbyAgICAJCVtXSU5NTS4xMzBdCiAqLwpVSU5UMzIgV0lOQVBJIG1taW9TZXRJbmZvMzIoSE1NSU8zMiBobW1pbywgY29uc3QgTU1JT0lORk8zMiAqIGxwbW1pb2luZm8sIFVJTlQzMiB1RmxhZ3MpCnsKCUxQTU1JT0lORk8xNglscG1taW5mbzsKCVRSQUNFKG1taW8sICJtbWlvU2V0SW5mb1xuIik7CglscG1taW5mbyA9IChMUE1NSU9JTkZPMTYpR2xvYmFsTG9jazE2KGhtbWlvKTsKCWlmIChscG1taW5mbyA9PSBOVUxMKSByZXR1cm4gMDsKCWxwbW1pbmZvLT5wY2hOZXh0CT0gbHBtbWlvaW5mby0+cGNoTmV4dDsKCWxwbW1pbmZvLT5wY2hFbmRSZWFkCT0gbHBtbWlvaW5mby0+cGNoRW5kUmVhZDsKCUdsb2JhbFVubG9jazE2KGhtbWlvKTsKCXJldHVybiAwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKiAJCQkJbW1pb1NldEJ1ZmZlcgkJW1dJTk1NLjEyOV0KKi8KVUlOVDMyIFdJTkFQSSBtbWlvU2V0QnVmZmVyMzIoSE1NSU8zMiBobW1pbywgTFBTVFIgcGNoQnVmZmVyLCAKCQkJCQkJCQkJCUxPTkcgY2NoQnVmZmVyLCBVSU5UMzIgdUZsYWdzKQp7CglMUE1NSU9JTkZPMTYJbHBtbWluZm87CgoJaWYgKG1taW9GbHVzaDMyKGhtbWlvLCBNTUlPX0VNUFRZQlVGKSAhPSAwKQoJCXJldHVybiBNTUlPRVJSX0NBTk5PVFdSSVRFOwoKCVRSQUNFKG1taW8sICIoaG1taW89JTA0eCwgcGNoQnVmPSVwLCBjY2hCdWY9JWxkLCB1RmxhZ3M9JSMwOHgpXG4iLAoJICAgICAgaG1taW8sIHBjaEJ1ZmZlciwgY2NoQnVmZmVyLCB1RmxhZ3MpOwoKCWxwbW1pbmZvID0gKExQTU1JT0lORk8xNilHbG9iYWxMb2NrMTYoaG1taW8pOwoJaWYgKGxwbW1pbmZvID09IE5VTEwpIHJldHVybiAwOwoJaWYgKCghY2NoQnVmZmVyIHx8IHBjaEJ1ZmZlcikgJiYgbHBtbWluZm8tPmR3RmxhZ3MmTU1JT19BTExPQ0JVRikgewoJCUdsb2JhbFVubG9jazE2KGxwbW1pbmZvLT5kd1Jlc2VydmVkMSk7CgkJR2xvYmFsRnJlZTE2KGxwbW1pbmZvLT5kd1Jlc2VydmVkMSk7CgkJbHBtbWluZm8tPmR3RmxhZ3MgJj0gfk1NSU9fQUxMT0NCVUY7Cgl9CglpZiAocGNoQnVmZmVyKSB7CgkJbHBtbWluZm8tPnBjaEJ1ZmZlciA9IHBjaEJ1ZmZlcjsKCX0gZWxzZSBpZiAobHBtbWluZm8tPmR3RmxhZ3MmTU1JT19BTExPQ0JVRikgewoJCUhHTE9CQUwxNiBoTmV3QnVmOwoJCUdsb2JhbFVubG9jazE2KGxwbW1pbmZvLT5kd1Jlc2VydmVkMSk7CgkJaE5ld0J1ZiA9IEdsb2JhbFJlQWxsb2MxNihscG1taW5mby0+ZHdSZXNlcnZlZDEsIGNjaEJ1ZmZlciwgMCk7CgkJaWYgKCFoTmV3QnVmKSB7CgkJCS8qIEZJWE1FOiB0aGlzIGFzc3VtZXMgdGhlIG1lbW9yeSBibG9jayBkaWRuJ3QgbW92ZSAqLwoJCQlHbG9iYWxMb2NrMTYobHBtbWluZm8tPmR3UmVzZXJ2ZWQxKTsKCQkJR2xvYmFsVW5sb2NrMTYoaG1taW8pOwoJCQlyZXR1cm4gTU1JT0VSUl9PVVRPRk1FTU9SWTsKCQl9CgkJbHBtbWluZm8tPmR3UmVzZXJ2ZWQxID0gaE5ld0J1ZjsKCQlscG1taW5mby0+cGNoQnVmZmVyID0gR2xvYmFsTG9jazE2KGhOZXdCdWYpOwoJfSBlbHNlIGlmIChjY2hCdWZmZXIpIHsKCQlIR0xPQkFMMTYgaE5ld0J1ZiA9IEdsb2JhbEFsbG9jMTYoR01FTV9NT1ZFQUJMRSwgY2NoQnVmZmVyKTsKCQlpZiAoIWhOZXdCdWYpIHsKCQkJR2xvYmFsVW5sb2NrMTYoaG1taW8pOwoJCQlyZXR1cm4gTU1JT0VSUl9PVVRPRk1FTU9SWTsKCQl9CgkJbHBtbWluZm8tPmR3UmVzZXJ2ZWQxID0gaE5ld0J1ZjsKCQlscG1taW5mby0+cGNoQnVmZmVyID0gR2xvYmFsTG9jazE2KGhOZXdCdWYpOwoJCWxwbW1pbmZvLT5kd0ZsYWdzIHw9IE1NSU9fQUxMT0NCVUY7Cgl9IGVsc2UKCQlscG1taW5mby0+cGNoQnVmZmVyID0gTlVMTDsKCWxwbW1pbmZvLT5jY2hCdWZmZXIgPSBjY2hCdWZmZXI7CglscG1taW5mby0+cGNoTmV4dCA9IGxwbW1pbmZvLT5wY2hCdWZmZXI7CglscG1taW5mby0+cGNoRW5kUmVhZCA9IGxwbW1pbmZvLT5wY2hCdWZmZXI7CglscG1taW5mby0+cGNoRW5kV3JpdGUgPSBscG1taW5mby0+cGNoQnVmZmVyICsgY2NoQnVmZmVyOwoJbHBtbWluZm8tPmxCdWZPZmZzZXQgPSAwOwoKCUdsb2JhbFVubG9jazE2KGhtbWlvKTsKCXJldHVybiAoVUlOVDE2KSAwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKiAJCQkJbW1pb1NldEJ1ZmZlcgkJW01NU1lTVEVNLjEyMTddCiovClVJTlQxNiBXSU5BUEkgbW1pb1NldEJ1ZmZlcjE2KEhNTUlPMTYgaG1taW8sIExQU1RSIHBjaEJ1ZmZlciwgCgkJCQkJCQkJCQlMT05HIGNjaEJ1ZmZlciwgVUlOVDE2IHVGbGFncykKewoJcmV0dXJuIG1taW9TZXRCdWZmZXIzMihobW1pbywgcGNoQnVmZmVyLCBjY2hCdWZmZXIsIHVGbGFncyk7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJbW1pb0ZsdXNoICAgICAgCQlbV0lOTU0uMTE3XQogKi8KVUlOVDMyIFdJTkFQSSBtbWlvRmx1c2gzMihITU1JTzMyIGhtbWlvLCBVSU5UMzIgdUZsYWdzKQp7CglMUE1NSU9JTkZPMTYJbHBtbWluZm87CglUUkFDRShtbWlvLCAiKCUwNFgsICUwNFgpXG4iLCBobW1pbywgdUZsYWdzKTsKCWxwbW1pbmZvID0gKExQTU1JT0lORk8xNilHbG9iYWxMb2NrMTYoaG1taW8pOwoJaWYgKGxwbW1pbmZvID09IE5VTEwpIHJldHVybiAwOwoKCWlmICgoIWxwbW1pbmZvLT5jY2hCdWZmZXIpfHwobHBtbWluZm8tPmZjY0lPUHJvYz09Rk9VUkNDX01FTSkpIHsKCQlHbG9iYWxVbmxvY2sxNihobW1pbyk7CgkJcmV0dXJuIDA7Cgl9CgkvKiBub3QgcXVpdGUgc3VyZSB3aGF0IHRvIGRvIGhlcmUsIGJ1dCBJJ2xsIGd1ZXNzICovCglpZiAobHBtbWluZm8tPmR3RmxhZ3MgJiBNTUlPX0RJUlRZKSB7CgkJbW1pb1NlbmRNZXNzYWdlKGhtbWlvLCBNTUlPTV9TRUVLLAoJCQkoTFBBUkFNKSBscG1taW5mby0+bEJ1Zk9mZnNldCwKCQkJKExQQVJBTSkgU0VFS19TRVQpOwoJCW1taW9TZW5kTWVzc2FnZShobW1pbywgTU1JT01fV1JJVEUsCgkJCShMUEFSQU0pIGxwbW1pbmZvLT5wY2hCdWZmZXIsCgkJCShMUEFSQU0pIChscG1taW5mby0+cGNoTmV4dCAtIGxwbW1pbmZvLT5wY2hCdWZmZXIpICk7CgkJbHBtbWluZm8tPmR3RmxhZ3MgJj0gfk1NSU9fRElSVFk7Cgl9CglpZiAodUZsYWdzICYgTU1JT19FTVBUWUJVRikgewoJCS8qIHNlZW1zIFdpbmRvd3MgZG9lc24ndCBkbyBhbnkgc2Vla2luZyBoZXJlLCBob3BlZnVsbHkgdGhpcwoJCSAgIHdvbid0IG1hdHRlciwgb3RoZXJ3aXNlIGEgc2xpZ2h0IHJld3JpdGUgaXMgbmVjZXNzYXJ5ICovCgkJbW1pb1NlbmRNZXNzYWdlKGhtbWlvLCBNTUlPTV9TRUVLLAoJCQkoTFBBUkFNKSAobHBtbWluZm8tPmxCdWZPZmZzZXQgKwoJCQkJICAobHBtbWluZm8tPnBjaE5leHQgLSBscG1taW5mby0+cGNoQnVmZmVyKSksCgkJCShMUEFSQU0pIFNFRUtfU0VUKTsKCQlscG1taW5mby0+cGNoTmV4dCA9IGxwbW1pbmZvLT5wY2hCdWZmZXI7CgkJbHBtbWluZm8tPnBjaEVuZFJlYWQgPSBscG1taW5mby0+cGNoQnVmZmVyOwoJCWxwbW1pbmZvLT5sQnVmT2Zmc2V0ID0gbHBtbWluZm8tPmxEaXNrT2Zmc2V0OwoJfQoKCUdsb2JhbFVubG9jazE2KGhtbWlvKTsKCXJldHVybiAwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCW1taW9GbHVzaCAgICAgIAkJW01NU1lTVEVNLjEyMThdCiAqLwpVSU5UMTYgV0lOQVBJIG1taW9GbHVzaDE2KEhNTUlPMTYgaG1taW8sIFVJTlQxNiB1RmxhZ3MpCnsKCXJldHVybiBtbWlvRmx1c2gzMihobW1pbyx1RmxhZ3MpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCW1taW9BZHZhbmNlICAgIAkJW01NU1lTVEVNLjEyMTldCiAqLwpVSU5UMzIgV0lOQVBJIG1taW9BZHZhbmNlMzIoSE1NSU8zMiBobW1pbyxNTUlPSU5GTzMyKmxwbW1pb2luZm8sVUlOVDMyIHVGbGFncykKewoJTFBNTUlPSU5GTzE2CWxwbW1pbmZvOwoJVFJBQ0UobW1pbywgIm1taW9BZHZhbmNlXG4iKTsKCWxwbW1pbmZvID0gKExQTU1JT0lORk8xNilHbG9iYWxMb2NrMTYoaG1taW8pOwoJaWYgKGxwbW1pbmZvID09IE5VTEwpIHJldHVybiAwOwoJaWYgKCFscG1taW5mby0+Y2NoQnVmZmVyKSB7CgkJR2xvYmFsVW5sb2NrMTYoaG1taW8pOwoJCXJldHVybiBNTUlPRVJSX1VOQlVGRkVSRUQ7Cgl9CglscG1taW5mby0+cGNoTmV4dCA9IGxwbW1pb2luZm8tPnBjaE5leHQ7CglpZiAobW1pb0ZsdXNoMzIoaG1taW8sIE1NSU9fRU1QVFlCVUYpKSB7CgkJR2xvYmFsVW5sb2NrMTYoaG1taW8pOwoJCXJldHVybiBNTUlPRVJSX0NBTk5PVFdSSVRFOwoJfQoJaWYgKHVGbGFncyA9PSBNTUlPX1JFQUQpCgkgICAgICAgIGxwbW1pb2luZm8tPnBjaEVuZFJlYWQgPSBscG1taW9pbmZvLT5wY2hCdWZmZXIgKwoJICAgICAgICAgICAgbW1pb1NlbmRNZXNzYWdlKGhtbWlvLCBNTUlPTV9SRUFELAoJICAgICAgICAgICAgICAgIChMUEFSQU0pIGxwbW1pb2luZm8tPnBjaEJ1ZmZlciwKCSAgICAgICAgICAgICAgICAoTFBBUkFNKSBscG1taW9pbmZvLT5jY2hCdWZmZXIpOwojaWYgMCAgIC8qIG1taW9GbHVzaDMyIGFscmVhZHkgZGlkIHRoZSB3cml0aW5nICovCglpZiAodUZsYWdzID09IE1NSU9fV1JJVEUpCgkgICAgICAgICAgICBtbWlvU2VuZE1lc3NhZ2UoaG1taW8sIE1NSU9NX1dSSVRFLAoJICAgICAgICAgICAgICAgIChMUEFSQU0pIGxwbW1pb2luZm8tPnBjaEJ1ZmZlciwKCSAgICAgICAgICAgICAgICAoTFBBUkFNKSBscG1taW9pbmZvLT5jY2hCdWZmZXIpOwojZW5kaWYKCWxwbW1pb2luZm8tPnBjaE5leHQgPSBscG1taW9pbmZvLT5wY2hCdWZmZXI7CglHbG9iYWxVbmxvY2sxNihobW1pbyk7CglyZXR1cm4gMDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQltbWlvQWR2YW5jZSAgICAJCVtNTVNZU1RFTS4xMjE5XQogKi8KVUlOVDE2IFdJTkFQSSBtbWlvQWR2YW5jZTE2KEhNTUlPMTYgaG1taW8sTU1JT0lORk8xNipscG1taW9pbmZvLFVJTlQxNiB1RmxhZ3MpCnsKCUxQTU1JT0lORk8xNglscG1taW5mbzsKCVRSQUNFKG1taW8sICJtbWlvQWR2YW5jZVxuIik7CglscG1taW5mbyA9IChMUE1NSU9JTkZPMTYpR2xvYmFsTG9jazE2KGhtbWlvKTsKCWlmIChscG1taW5mbyA9PSBOVUxMKSByZXR1cm4gMDsKCWlmICghbHBtbWluZm8tPmNjaEJ1ZmZlcikgewoJCUdsb2JhbFVubG9jazE2KGhtbWlvKTsKCQlyZXR1cm4gTU1JT0VSUl9VTkJVRkZFUkVEOwoJfQoJbHBtbWluZm8tPnBjaE5leHQgPSBscG1taW9pbmZvLT5wY2hOZXh0OwoJaWYgKG1taW9GbHVzaDMyKGhtbWlvLCBNTUlPX0VNUFRZQlVGKSkgewoJCUdsb2JhbFVubG9jazE2KGhtbWlvKTsKCQlyZXR1cm4gTU1JT0VSUl9DQU5OT1RXUklURTsKCX0KCWlmICh1RmxhZ3MgPT0gTU1JT19SRUFEKQoJICAgICAgICBscG1taW9pbmZvLT5wY2hFbmRSZWFkID0gbHBtbWlvaW5mby0+cGNoQnVmZmVyICsKCSAgICAgICAgICAgIG1taW9TZW5kTWVzc2FnZShobW1pbywgTU1JT01fUkVBRCwKCSAgICAgICAgICAgICAgICAoTFBBUkFNKSBscG1taW9pbmZvLT5wY2hCdWZmZXIsCgkgICAgICAgICAgICAgICAgKExQQVJBTSkgbHBtbWlvaW5mby0+Y2NoQnVmZmVyKTsKI2lmIDAgICAvKiBtbWlvRmx1c2gzMiBhbHJlYWR5IGRpZCB0aGUgd3JpdGluZyAqLwoJaWYgKHVGbGFncyA9PSBNTUlPX1dSSVRFKQoJICAgICAgICAgICAgbW1pb1NlbmRNZXNzYWdlKGhtbWlvLCBNTUlPTV9XUklURSwKCSAgICAgICAgICAgICAgICAoTFBBUkFNKSBscG1taW9pbmZvLT5wY2hCdWZmZXIsCgkgICAgICAgICAgICAgICAgKExQQVJBTSkgbHBtbWlvaW5mby0+Y2NoQnVmZmVyKTsKI2VuZGlmCglscG1taW9pbmZvLT5wY2hOZXh0ID0gbHBtbWlvaW5mby0+cGNoQnVmZmVyOwoJR2xvYmFsVW5sb2NrMTYoaG1taW8pOwoJcmV0dXJuIDA7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJbW1pb1N0cmluZ1RvRk9VUkNDQQlbV0lOTU0uMTMxXQogKi8KRk9VUkNDIFdJTkFQSSBtbWlvU3RyaW5nVG9GT1VSQ0MzMkEoTFBDU1RSIHN6LCBVSU5UMzIgdUZsYWdzKQp7CglyZXR1cm4gbW1pb1N0cmluZ1RvRk9VUkNDMTYoc3osdUZsYWdzKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiAqIAkJCQltbWlvU3RyaW5nVG9GT1VSQ0NXCVtXSU5NTS4xMzJdCiAqLwpGT1VSQ0MgV0lOQVBJIG1taW9TdHJpbmdUb0ZPVVJDQzMyVyhMUENXU1RSIHN6LCBVSU5UMzIgdUZsYWdzKQp7CglMUFNUUglzekEgPSBIRUFQX3N0cmR1cFd0b0EoR2V0UHJvY2Vzc0hlYXAoKSwwLHN6KTsKCUZPVVJDQwlyZXQgPSBtbWlvU3RyaW5nVG9GT1VSQ0MzMkEoc3pBLHVGbGFncyk7CgoJSGVhcEZyZWUoR2V0UHJvY2Vzc0hlYXAoKSwwLHN6QSk7CglyZXR1cm4gcmV0Owp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCW1taW9TdHJpbmdUb0ZPVVJDQwlbTU1TWVNURU0uMTIyMF0KICovCkZPVVJDQyBXSU5BUEkgbW1pb1N0cmluZ1RvRk9VUkNDMTYoTFBDU1RSIHN6LCBVSU5UMTYgdUZsYWdzKQp7CglyZXR1cm4gbW1pb0ZPVVJDQyhzelswXSxzelsxXSxzelsyXSxzelszXSk7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgoqIAkJCQltbWlvSW5zdGFsbElPUHJvYzE2CVtNTVNZU1RFTS4xMjIxXQoqLwpMUE1NSU9QUk9DMTYgV0lOQVBJIG1taW9JbnN0YWxsSU9Qcm9jMTYoRk9VUkNDIGZjY0lPUHJvYywgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBMUE1NSU9QUk9DMTYgcElPUHJvYywgRFdPUkQgZHdGbGFncykKewoJVFJBQ0UobW1pbywgIiglbGQsICVwLCAlMDhsWClcbiIsCgkJCQkgZmNjSU9Qcm9jLCBwSU9Qcm9jLCBkd0ZsYWdzKTsKCglpZiAoZHdGbGFncyAmIE1NSU9fR0xPQkFMUFJPQykgewoJCUZJWE1FKG1taW8sICIgZ2xvYmFsIHByb2NlZHVyZXMgbm90IGltcGxlbWVudGVkXG4iKTsKCX0KCgkvKiBqdXN0IGhhbmRsZSB0aGUga25vd24gcHJvY2VkdXJlcyBmb3Igbm93ICovCglzd2l0Y2goZHdGbGFncyAmIChNTUlPX0lOU1RBTExQUk9DfE1NSU9fUkVNT1ZFUFJPQ3xNTUlPX0ZJTkRQUk9DKSkgewoJCWNhc2UgTU1JT19JTlNUQUxMUFJPQzoKCQkJcmV0dXJuIE5VTEw7CgkJY2FzZSBNTUlPX1JFTU9WRVBST0M6CgkJCXJldHVybiBOVUxMOwoJCWNhc2UgTU1JT19GSU5EUFJPQzoKCQkJaWYgKGZjY0lPUHJvYyA9PSBGT1VSQ0NfRE9TKQoJCQkJcmV0dXJuIChMUE1NSU9QUk9DMTYpIG1taW9Eb3NJT1Byb2M7CgkJCWVsc2UgaWYgKGZjY0lPUHJvYyA9PSBGT1VSQ0NfTUVNKQoJCQkJcmV0dXJuIChMUE1NSU9QUk9DMTYpIG1taW9NZW1JT1Byb2M7CgkJCWVsc2UKCQkJCXJldHVybiBOVUxMOwoJCWRlZmF1bHQ6CgkJCXJldHVybiBOVUxMOwoJfQp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCW1taW9JbnN0YWxsSU9Qcm9jMzJBICAgW1dJTk1NLjEyMF0KICovCkxQTU1JT1BST0MzMiBXSU5BUEkgbW1pb0luc3RhbGxJT1Byb2MzMkEoRk9VUkNDIGZjY0lPUHJvYywgCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTFBNTUlPUFJPQzMyIHBJT1Byb2MsIERXT1JEIGR3RmxhZ3MpCnsKCUZJWE1FKG1taW8sICIoJWMlYyVjJWMsJXAsMHglMDhseCkgLS0gZW1wdHkgc3R1YiBcbiIsCiAgICAgICAgICAgICAgICAgICAgIChjaGFyKSgoZmNjSU9Qcm9jJjB4ZmYwMDAwMDApPj4yNCksCiAgICAgICAgICAgICAgICAgICAgIChjaGFyKSgoZmNjSU9Qcm9jJjB4MDBmZjAwMDApPj4xNiksCiAgICAgICAgICAgICAgICAgICAgIChjaGFyKSgoZmNjSU9Qcm9jJjB4MDAwMGZmMDApPj4gOCksCiAgICAgICAgICAgICAgICAgICAgIChjaGFyKShmY2NJT1Byb2MmMHgwMDAwMDBmZiksCiAgICAgICAgICAgICAgICAgICAgIHBJT1Byb2MsIGR3RmxhZ3MgKTsKCXJldHVybiAwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKiAJCQkJbW1pb1NlbmRNZXNzYWdlCQlbTU1TWVNURU0uMTIyMl0KKi8KTFJFU1VMVCBXSU5BUEkgbW1pb1NlbmRNZXNzYWdlKEhNTUlPMTYgaG1taW8sIFVJTlQxNiB1TWVzc2FnZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIExQQVJBTSBsUGFyYW0xLCBMUEFSQU0gbFBhcmFtMikKewoJTFBNTUlPSU5GTzE2IGxwbW1pbmZvOwoJTFJFU1VMVCByZXN1bHQ7Cgljb25zdCBjaGFyICptc2cgPSBOVUxMOwoKI2lmZGVmIERFQlVHX1JVTlRJTUUKCXN3aXRjaCAodU1lc3NhZ2UpIHsKI2RlZmluZSBtc2duYW1lKHgpIGNhc2UgeDogbXNnID0gI3g7IGJyZWFrOwoJCW1zZ25hbWUoTU1JT01fT1BFTik7CgkJbXNnbmFtZShNTUlPTV9DTE9TRSk7CgkJbXNnbmFtZShNTUlPTV9SRUFEKTsKCQltc2duYW1lKE1NSU9NX1dSSVRFKTsKCQltc2duYW1lKE1NSU9NX1dSSVRFRkxVU0gpOwoJCW1zZ25hbWUoTU1JT01fU0VFSyk7CgkJbXNnbmFtZShNTUlPTV9SRU5BTUUpOwojdW5kZWYgbXNnbmFtZQoJfQojZW5kaWYKCglpZiAobXNnKQoJCVRSQUNFKG1taW8sICIoJTA0WCwgJXMsICVsZCwgJWxkKVxuIiwKCQkJCQkgaG1taW8sIG1zZywgbFBhcmFtMSwgbFBhcmFtMik7CgllbHNlCgkJVFJBQ0UobW1pbywgIiglMDRYLCAldSwgJWxkLCAlbGQpXG4iLAoJCQkJCSBobW1pbywgdU1lc3NhZ2UsIGxQYXJhbTEsIGxQYXJhbTIpOwoJCglscG1taW5mbyA9IChMUE1NSU9JTkZPMTYpR2xvYmFsTG9jazE2KGhtbWlvKTsKCglpZiAobHBtbWluZm8gJiYgbHBtbWluZm8tPnBJT1Byb2MpCgkJcmVzdWx0ID0gKCpscG1taW5mby0+cElPUHJvYykoKExQU1RSKWxwbW1pbmZvLCB1TWVzc2FnZSwgbFBhcmFtMSwgbFBhcmFtMik7CgllbHNlCgkJcmVzdWx0ID0gTU1TWVNFUlJfSU5WQUxQQVJBTTsKCglHbG9iYWxVbmxvY2sxNihobW1pbyk7CgoJcmV0dXJuIHJlc3VsdDsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiogCQkJCW1taW9EZXNjZW5kCSAgICAgICAJW01NU1lTVEVNLjEyMjNdCiovClVJTlQxNiBXSU5BUEkgbW1pb0Rlc2NlbmQoSE1NSU8xNiBobW1pbywgTU1DS0lORk8gKiBscGNrLAogICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IE1NQ0tJTkZPICogbHBja1BhcmVudCwgVUlOVDE2IHVGbGFncykKewoJRFdPUkQJZHdmY2MsIGR3T2xkUG9zOwoKCVRSQUNFKG1taW8sICIoJTA0WCwgJXAsICVwLCAlMDRYKTtcbiIsIAoJCQkJaG1taW8sIGxwY2ssIGxwY2tQYXJlbnQsIHVGbGFncyk7CgoJaWYgKGxwY2sgPT0gTlVMTCkKCSAgICByZXR1cm4gMDsKCglkd2ZjYyA9IGxwY2stPmNraWQ7CglUUkFDRShtbWlvLCAiZHdmY2M9JTA4bFhcbiIsIGR3ZmNjKTsKCglkd09sZFBvcyA9IG1taW9TZWVrMzIoaG1taW8sIDAsIFNFRUtfQ1VSKTsKCVRSQUNFKG1taW8sICJkd09sZFBvcz0lbGRcbiIsIGR3T2xkUG9zKTsKCglpZiAobHBja1BhcmVudCAhPSBOVUxMKSB7CgkJVFJBQ0UobW1pbywgInNlZWsgaW5zaWRlIHBhcmVudCBhdCAlbGQgIVxuIiwgbHBja1BhcmVudC0+ZHdEYXRhT2Zmc2V0KTsKCQlkd09sZFBvcyA9IG1taW9TZWVrMzIoaG1taW8sbHBja1BhcmVudC0+ZHdEYXRhT2Zmc2V0LFNFRUtfU0VUKTsKCX0KLyoKCiAgIEl0IHNlZW1zIHRvIGJlIHRoYXQgRklORFJJRkYgc2hvdWxkIG5vdCBiZSB0cmVhdGVkIHRoZSBzYW1lIGFzIHRoZSAKICAgb3RoZXIgRklORHh4eCBzbyBJIHRyZWF0IGl0IGFzIGEgTU1JT19GSU5EeHh4CgoJaWYgKCh1RmxhZ3MgJiBNTUlPX0ZJTkRDSFVOSykgfHwgKHVGbGFncyAmIE1NSU9fRklORFJJRkYpIHx8IAoJCSh1RmxhZ3MgJiBNTUlPX0ZJTkRMSVNUKSkgewoqLwoJaWYgKCh1RmxhZ3MgJiBNTUlPX0ZJTkRDSFVOSykgfHwgKHVGbGFncyAmIE1NSU9fRklORExJU1QpKSB7CgkJVFJBQ0UobW1pbywgIk1NSU9fRklORHh4eHggZHdmY2M9JTA4bFggIVxuIiwgZHdmY2MpOwoJCXdoaWxlIChUUlVFKSB7CgkJICAgICAgICBMT05HIGl4OwoKCQkJaXggPSBtbWlvUmVhZDMyKGhtbWlvLCAoTFBTVFIpbHBjaywgMyAqIHNpemVvZihEV09SRCkpOwoJCQlUUkFDRShtbWlvLCAiYWZ0ZXIgX2xyZWFkMzIgaXggPSAlbGQgcmVxID0gJWQsIGVycm5vID0gJWRcbiIsaXgsMyAqIHNpemVvZihEV09SRCksZXJybm8pOwoJCQlpZiAoaXggPCBzaXplb2YoRFdPUkQpKSB7CgkJCQltbWlvU2VlazMyKGhtbWlvLCBkd09sZFBvcywgU0VFS19TRVQpOwoJCQkJV0FSTihtbWlvLCAicmV0dXJuIENodW5rTm90Rm91bmRcbiIpOwoJCQkJcmV0dXJuIE1NSU9FUlJfQ0hVTktOT1RGT1VORDsKCQkJfQoJCQlscGNrLT5kd0RhdGFPZmZzZXQgPSBkd09sZFBvcyArIDIgKiBzaXplb2YoRFdPUkQpOwoJCQlpZiAobHBjay0+Y2tpZCA9PSBGT1VSQ0NfUklGRiB8fCBscGNrLT5ja2lkID09IEZPVVJDQ19MSVNUKSAKCQkJCWxwY2stPmR3RGF0YU9mZnNldCArPSBzaXplb2YoRFdPUkQpOwoJCQlpZiAoaXggPCBscGNrLT5kd0RhdGFPZmZzZXQgLSBkd09sZFBvcykgewoJCQkJbW1pb1NlZWszMihobW1pbywgZHdPbGRQb3MsIFNFRUtfU0VUKTsKCQkJCVdBUk4obW1pbywgInJldHVybiBDaHVua05vdEZvdW5kXG4iKTsKCQkJCXJldHVybiBNTUlPRVJSX0NIVU5LTk9URk9VTkQ7CgkJCX0KCQkJVFJBQ0UobW1pbywgImR3ZmNjPSUwOGxYIGNraWQ9JTA4bFggY2tzaXplPSUwOGxYICFcbiIsIAoJCQkJCQkJCQlkd2ZjYywgbHBjay0+Y2tpZCwgbHBjay0+Y2tzaXplKTsKCQkJaWYgKGR3ZmNjID09IGxwY2stPmNraWQpCgkJCQlicmVhazsKCgkJCWR3T2xkUG9zID0gbHBjay0+ZHdEYXRhT2Zmc2V0ICsgbHBjay0+Y2tzaXplOwoJCQltbWlvU2VlazMyKGhtbWlvLCBkd09sZFBvcywgU0VFS19TRVQpOwoJCX0KCX0KCWVsc2UgewoJCWlmIChtbWlvUmVhZDMyKGhtbWlvLCAoTFBTVFIpbHBjaywgc2l6ZW9mKE1NQ0tJTkZPKSkgPCBzaXplb2YoTU1DS0lORk8pKSB7CgkJCW1taW9TZWVrMzIoaG1taW8sIGR3T2xkUG9zLCBTRUVLX1NFVCk7CgkJCVdBUk4obW1pbywgInJldHVybiBDaHVua05vdEZvdW5kIDJuZFxuIik7CgkJCXJldHVybiBNTUlPRVJSX0NIVU5LTk9URk9VTkQ7CgkJfQoJCWxwY2stPmR3RGF0YU9mZnNldCA9IGR3T2xkUG9zICsgMiAqIHNpemVvZihEV09SRCk7CgkJaWYgKGxwY2stPmNraWQgPT0gRk9VUkNDX1JJRkYgfHwgbHBjay0+Y2tpZCA9PSBGT1VSQ0NfTElTVCkgCgkJCWxwY2stPmR3RGF0YU9mZnNldCArPSBzaXplb2YoRFdPUkQpOwoJfQoJbW1pb1NlZWszMihobW1pbywgbHBjay0+ZHdEYXRhT2Zmc2V0LCBTRUVLX1NFVCk7CgoJVFJBQ0UobW1pbywgImxwY2stPmNraWQ9JTA4bFggbHBjay0+Y2tzaXplPSVsZCAhXG4iLCAKCQkJCQkJCQlscGNrLT5ja2lkLCBscGNrLT5ja3NpemUpOwoJVFJBQ0UobW1pbywgImxwY2stPmZjY1R5cGU9JTA4bFggIVxuIiwgbHBjay0+ZmNjVHlwZSk7CgoJcmV0dXJuIDA7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJbW1pb0FzY2VuZCAgICAgCQlbV0lOTU0uMTEzXQogKi8KVUlOVDMyIFdJTkFQSSBtbWlvQXNjZW5kMzIoSE1NSU8zMiBobW1pbywgTU1DS0lORk8gKiBscGNrLCBVSU5UMzIgdUZsYWdzKQp7CglUUkFDRShtbWlvLCAiKCUwNFgsICVwLCAlMDRYKTtcbiIsIAoJCQkJaG1taW8sIGxwY2ssIHVGbGFncyk7CglpZiAobHBjay0+ZHdGbGFncyZNTUlPX0RJUlRZKSB7CgkJRFdPUkQJZHdPbGRQb3MsIGR3TmV3U2l6ZSwgZHdTaXplUG9zOwoKCQlUUkFDRShtbWlvLCAiY2h1bmsgaXMgbWFya2VkIE1NSU9fRElSVFksIGNvcnJlY3RpbmcgY2h1bmsgc2l6ZVxuIik7CgkJZHdPbGRQb3MgPSBtbWlvU2VlazMyKGhtbWlvLCAwLCBTRUVLX0NVUik7CgkJVFJBQ0UobW1pbywgImR3T2xkUG9zPSVsZFxuIiwgZHdPbGRQb3MpOwoJCWR3TmV3U2l6ZSA9IGR3T2xkUG9zIC0gbHBjay0+ZHdEYXRhT2Zmc2V0OwoJCWlmIChkd05ld1NpemUgIT0gbHBjay0+Y2tzaXplKSB7CgkJCVRSQUNFKG1taW8sICJkd05ld1NpemU9JWxkXG4iLCBkd05ld1NpemUpOwoJCQlscGNrLT5ja3NpemUgPSBkd05ld1NpemU7CgoJCQlkd1NpemVQb3MgPSBscGNrLT5kd0RhdGFPZmZzZXQgLSBzaXplb2YoRFdPUkQpOwoJCQlpZiAobHBjay0+Y2tpZCA9PSBGT1VSQ0NfUklGRiB8fCBscGNrLT5ja2lkID09IEZPVVJDQ19MSVNUKSAKCQkJCWR3U2l6ZVBvcyAtPSBzaXplb2YoRFdPUkQpOwoJCQlUUkFDRShtbWlvLCAiZHdTaXplUG9zPSVsZFxuIiwgZHdTaXplUG9zKTsKCgkJCW1taW9TZWVrMzIoaG1taW8sIGR3U2l6ZVBvcywgU0VFS19TRVQpOwoJCQltbWlvV3JpdGUzMihobW1pbywgKExQU1RSKSZkd05ld1NpemUsIHNpemVvZihEV09SRCkpOwoJCX0KCX0KCW1taW9TZWVrMzIoaG1taW8sbHBjay0+ZHdEYXRhT2Zmc2V0K2xwY2stPmNrc2l6ZSxTRUVLX1NFVCk7CgoJcmV0dXJuIDA7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJbW1pb0FzY2VuZCAgICAgCQlbTU1TWVNURU0uMTIyNF0KICovClVJTlQxNiBXSU5BUEkgbW1pb0FzY2VuZDE2KEhNTUlPMTYgaG1taW8sIE1NQ0tJTkZPICogbHBjaywgVUlOVDE2IHVGbGFncykKewoJcmV0dXJuIG1taW9Bc2NlbmQzMihobW1pbyxscGNrLHVGbGFncyk7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKiAJCQkJbW1pb0NyZWF0ZUNodW5rCQlbTU1TWVNURU0uMTIyNV0KICovClVJTlQxNiBXSU5BUEkgbW1pb0NyZWF0ZUNodW5rMTYoSE1NSU8xNiBobW1pbywgTU1DS0lORk8gKiBscGNrLCBVSU5UMTYgdUZsYWdzKQp7CglEV09SRAlkd09sZFBvczsKCUxPTkcgaXg7CgoJVFJBQ0UobW1pbywgIiglMDRYLCAlcCwgJTA0WCk7XG4iLCAKCQkJCWhtbWlvLCBscGNrLCB1RmxhZ3MpOwoKCWR3T2xkUG9zID0gbW1pb1NlZWszMihobW1pbywgMCwgU0VFS19DVVIpOwoJVFJBQ0UobW1pbywgImR3T2xkUG9zPSVsZFxuIiwgZHdPbGRQb3MpOwoKCWlmICh1RmxhZ3MgPT0gTU1JT19DUkVBVEVMSVNUKQoJCWxwY2stPmNraWQgPSBGT1VSQ0NfTElTVDsKCWVsc2UgaWYgKHVGbGFncyA9PSBNTUlPX0NSRUFURVJJRkYpCgkJbHBjay0+Y2tpZCA9IEZPVVJDQ19SSUZGOwoKCVRSQUNFKG1taW8sICJja2lkPSUwOGxYXG4iLCBscGNrLT5ja2lkKTsKCglscGNrLT5kd0RhdGFPZmZzZXQgPSBkd09sZFBvcyArIDIgKiBzaXplb2YoRFdPUkQpOwoJaWYgKGxwY2stPmNraWQgPT0gRk9VUkNDX1JJRkYgfHwgbHBjay0+Y2tpZCA9PSBGT1VSQ0NfTElTVCkgCgkJbHBjay0+ZHdEYXRhT2Zmc2V0ICs9IHNpemVvZihEV09SRCk7CglscGNrLT5kd0ZsYWdzID0gTU1JT19ESVJUWTsKCglpeCA9IG1taW9Xcml0ZTMyKGhtbWlvLCAoTFBTVFIpbHBjaywgbHBjay0+ZHdEYXRhT2Zmc2V0IC0gZHdPbGRQb3MpOwoJVFJBQ0UobW1pbywgImFmdGVyIF9sd3JpdGUzMiBpeCA9ICVsZCByZXEgPSAlbGQsIGVycm5vID0gJWRcbiIsaXgsbHBjay0+ZHdEYXRhT2Zmc2V0IC0gZHdPbGRQb3MsZXJybm8pOwoJaWYgKGl4IDwgbHBjay0+ZHdEYXRhT2Zmc2V0IC0gZHdPbGRQb3MpIHsKCgkJbW1pb1NlZWszMihobW1pbywgZHdPbGRQb3MsIFNFRUtfU0VUKTsKCQlXQVJOKG1taW8sICJyZXR1cm4gQ2Fubm90V3JpdGVcbiIpOwoJCXJldHVybiBNTUlPRVJSX0NBTk5PVFdSSVRFOwoJfQoKCXJldHVybiAwOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCQltbWlvQ3JlYXRlQ2h1bmsJCQkJCVtXSU5NTS4xMTVdCiAqLwpVSU5UMzIgV0lOQVBJIG1taW9DcmVhdGVDaHVuazMyKEhNTUlPMzIgaG1taW8sIE1NQ0tJTkZPICogbHBjaywgVUlOVDMyIHVGbGFncykKewoJcmV0dXJuIG1taW9DcmVhdGVDaHVuazE2KGhtbWlvLCBscGNrLCB1RmxhZ3MpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCW1taW9SZW5hbWUgICAgIAkJW01NU1lTVEVNLjEyMjZdCiAqLwpVSU5UMTYgV0lOQVBJIG1taW9SZW5hbWUxNihMUENTVFIgc3pGaWxlTmFtZSwgTFBDU1RSIHN6TmV3RmlsZU5hbWUsCiAgICAgICAgICAgICAgICAgICAgICAgICBNTUlPSU5GTzE2ICogbHBtbWlvaW5mbywgRFdPUkQgZHdSZW5hbWVGbGFncykKewoJVUlOVDE2IHJlc3VsdDsKCUxQTU1JT0lORk8xNiBscG1taW5mbzsKCUhNTUlPMTYgaG1taW87CgoJVFJBQ0UobW1pbywgIignJXMnLCAnJXMnLCAlcCwgJTA4bFgpO1xuIiwKCQkJCSBzekZpbGVOYW1lLCBzek5ld0ZpbGVOYW1lLCBscG1taW9pbmZvLCBkd1JlbmFtZUZsYWdzKTsKCglobW1pbyA9IEdsb2JhbEFsbG9jMTYoR0hORCwgc2l6ZW9mKE1NSU9JTkZPMTYpKTsKCWxwbW1pbmZvID0gKExQTU1JT0lORk8xNikgR2xvYmFsTG9jazE2KGhtbWlvKTsKCglpZiAobHBtbWlvaW5mbykKCQltZW1jcHkobHBtbWluZm8sIGxwbW1pb2luZm8sIHNpemVvZihNTUlPSU5GTzE2KSk7CgkKCS8qIGFzc3VtZSBET1MgZmlsZSBpZiBub3Qgb3RoZXJ3aXNlIHNwZWNpZmllZCAqLwoJaWYgKGxwbW1pbmZvLT5mY2NJT1Byb2MgPT0gMCAmJiBscG1taW5mby0+cElPUHJvYyA9PSBOVUxMKSB7CgoJCWxwbW1pbmZvLT5mY2NJT1Byb2MgPSBtbWlvRk9VUkNDKCdEJywgJ08nLCAnUycsICcgJyk7CgkJbHBtbWluZm8tPnBJT1Byb2MgPSAoTFBNTUlPUFJPQzE2KSBtbWlvRG9zSU9Qcm9jOwoKCX0KCS8qIGlmIGp1c3QgdGhlIGZvdXIgY2hhcmFjdGVyIGNvZGUgaXMgcHJlc2VudCwgbG9vayB1cCBJTyBwcm9jICovCgllbHNlIGlmIChscG1taW5mby0+cElPUHJvYyA9PSBOVUxMKSB7CgoJCWxwbW1pbmZvLT5wSU9Qcm9jID0gbW1pb0luc3RhbGxJT1Byb2MxNihscG1taW5mby0+ZmNjSU9Qcm9jLCBOVUxMLCBNTUlPX0ZJTkRQUk9DKTsKCgl9IAoJLyogKGlmIElPIHByb2Mgc3BlY2lmaWVkLCB1c2UgaXQgYW5kIHNwZWNpZmllZCBmb3VyIGNoYXJhY3RlciBjb2RlKSAqLwoKCXJlc3VsdCA9IChVSU5UMTYpIG1taW9TZW5kTWVzc2FnZShobW1pbywgTU1JT01fUkVOQU1FLCAoTFBBUkFNKSBzekZpbGVOYW1lLCAoTFBBUkFNKSBzek5ld0ZpbGVOYW1lKTsKCQoJR2xvYmFsVW5sb2NrMTYoaG1taW8pOwoJR2xvYmFsRnJlZTE2KGhtbWlvKTsKCglyZXR1cm4gcmVzdWx0Owp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCW1taW9SZW5hbWVBICAgICAJCQlbV0lOTU0uMTI1XQogKi8KVUlOVDMyIFdJTkFQSSBtbWlvUmVuYW1lMzJBKExQQ1NUUiBzekZpbGVOYW1lLCBMUENTVFIgc3pOZXdGaWxlTmFtZSwKICAgICAgICAgICAgICAgICAgICAgICAgIE1NSU9JTkZPMzIqIGxwbW1pb2luZm8sIERXT1JEIGR3UmVuYW1lRmxhZ3MpCnsKCUZJWE1FKG1taW8sICJUaGlzIG1heSBmYWlsXG4iKTsKCXJldHVybiBtbWlvUmVuYW1lMTYoc3pGaWxlTmFtZSwgc3pOZXdGaWxlTmFtZSwgKE1NSU9JTkZPMTYqKWxwbW1pb2luZm8sIGR3UmVuYW1lRmxhZ3MpOwp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogCQkJCW1taW9SZW5hbWVXICAgICAJCQlbV0lOTU0uMTI2XQogKi8KVUlOVDMyIFdJTkFQSSBtbWlvUmVuYW1lMzJXKExQQ1dTVFIgc3pGaWxlTmFtZSwgTFBDV1NUUiBzek5ld0ZpbGVOYW1lLAoJCQkJCQkJCQkgTU1JT0lORk8zMiogbHBtbWlvaW5mbywgRFdPUkQgZHdSZW5hbWVGbGFncykKewoJTFBTVFIJCXN6Rm4gPSBIRUFQX3N0cmR1cFd0b0EoR2V0UHJvY2Vzc0hlYXAoKSwgMCwgc3pGaWxlTmFtZSk7CglMUFNUUgkJc3puRm4gPSBIRUFQX3N0cmR1cFd0b0EoR2V0UHJvY2Vzc0hlYXAoKSwgMCwgc3pOZXdGaWxlTmFtZSk7CglVSU5UMzIJcmV0ID0gbW1pb1JlbmFtZTMyQShzekZuLCBzem5GbiwgbHBtbWlvaW5mbywgZHdSZW5hbWVGbGFncyk7CgoJSGVhcEZyZWUoR2V0UHJvY2Vzc0hlYXAoKSwwLHN6Rm4pOwoJSGVhcEZyZWUoR2V0UHJvY2Vzc0hlYXAoKSwwLHN6bkZuKTsKCXJldHVybiByZXQ7Cn0K