LyoKICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICogUmFsaW5rIFRlY2ggSW5jLgogKiA1Ri4sIE5vLjM2LCBUYWl5dWFuIFN0LiwgSmh1YmVpIENpdHksCiAqIEhzaW5jaHUgQ291bnR5IDMwMiwKICogVGFpd2FuLCBSLk8uQy4KICoKICogKGMpIENvcHlyaWdodCAyMDAyLTIwMDcsIFJhbGluayBUZWNobm9sb2d5LCBJbmMuCiAqCiAqIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5ICAqCiAqIGl0IHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMgcHVibGlzaGVkIGJ5ICAqCiAqIHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb247IGVpdGhlciB2ZXJzaW9uIDIgb2YgdGhlIExpY2Vuc2UsIG9yICAgICAqCiAqIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqCiAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCAgICAgICAqCiAqIGJ1dCBXSVRIT1VUIEFOWSBXQVJSQU5UWTsgd2l0aG91dCBldmVuIHRoZSBpbXBsaWVkIHdhcnJhbnR5IG9mICAgICAgICAqCiAqIE1FUkNIQU5UQUJJTElUWSBvciBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIFNlZSB0aGUgICAgICAgICAqCiAqIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlIGZvciBtb3JlIGRldGFpbHMuICAgICAgICAgICAgICAgICAgICAgICAgICAqCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqCiAqIFlvdSBzaG91bGQgaGF2ZSByZWNlaXZlZCBhIGNvcHkgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlICAgICAqCiAqIGFsb25nIHdpdGggdGhpcyBwcm9ncmFtOyBpZiBub3QsIHdyaXRlIHRvIHRoZSAgICAgICAgICAgICAgICAgICAgICAgICAqCiAqIEZyZWUgU29mdHdhcmUgRm91bmRhdGlvbiwgSW5jLiwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqCiAqIDU5IFRlbXBsZSBQbGFjZSAtIFN1aXRlIDMzMCwgQm9zdG9uLCBNQSAgMDIxMTEtMTMwNywgVVNBLiAgICAgICAgICAgICAqCiAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqCiAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCgoJTW9kdWxlIE5hbWU6Cglhc3NvYy5jCgoJQWJzdHJhY3Q6CgoJUmV2aXNpb24gSGlzdG9yeToKCVdobwkJCVdoZW4JCQlXaGF0CgktLS0tLS0tLQktLS0tLS0tLS0tCQktLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCglKb2huCQkyMDA0LTktMwkJcG9ydGluZyBmcm9tIFJUMjUwMAoqLwojaW5jbHVkZSAiLi4vcnRfY29uZmlnLmgiCgpVQ0hBUglDaXBoZXJXcGFUZW1wbGF0ZVtdID0gewoJCTB4ZGQsIAkJCQkJLy8gV1BBIElFCgkJMHgxNiwJCQkJCS8vIExlbmd0aAoJCTB4MDAsIDB4NTAsIDB4ZjIsIDB4MDEsCS8vIG91aQoJCTB4MDEsIDB4MDAsCQkJCS8vIFZlcnNpb24KCQkweDAwLCAweDUwLCAweGYyLCAweDAyLAkvLyBNdWx0aWNhc3QKCQkweDAxLCAweDAwLAkJCQkvLyBOdW1iZXIgb2YgdW5pY2FzdAoJCTB4MDAsIDB4NTAsIDB4ZjIsIDB4MDIsCS8vIHVuaWNhc3QKCQkweDAxLCAweDAwLAkJCQkvLyBudW1iZXIgb2YgYXV0aGVudGljYXRpb24gbWV0aG9kCgkJMHgwMCwgMHg1MCwgMHhmMiwgMHgwMQkvLyBhdXRoZW50aWNhdGlvbgoJCX07CgpVQ0hBUglDaXBoZXJXcGEyVGVtcGxhdGVbXSA9IHsKCQkweDMwLAkJCQkJLy8gUlNOIElFCgkJMHgxNCwJCQkJCS8vIExlbmd0aAoJCTB4MDEsIDB4MDAsCQkJCS8vIFZlcnNpb24KCQkweDAwLCAweDBmLCAweGFjLCAweDAyLAkvLyBncm91cCBjaXBoZXIsIFRLSVAKCQkweDAxLCAweDAwLAkJCQkvLyBudW1iZXIgb2YgcGFpcndpc2UKCQkweDAwLCAweDBmLCAweGFjLCAweDAyLAkvLyB1bmljYXN0CgkJMHgwMSwgMHgwMCwJCQkJLy8gbnVtYmVyIG9mIGF1dGhlbnRpY2F0aW9uIG1ldGhvZAoJCTB4MDAsIDB4MGYsIDB4YWMsIDB4MDIsCS8vIGF1dGhlbnRpY2F0aW9uCgkJMHgwMCwgMHgwMCwJCQkJLy8gUlNOIGNhcGFiaWxpdHkKCQl9OwoKVUNIQVIJQ2N4MkllSW5mb1tdID0geyAweDAwLCAweDQwLCAweDk2LCAweDAzLCAweDAyfTsKCi8qCgk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQoJRGVzY3JpcHRpb246CgkJYXNzb2NpYXRpb24gc3RhdGUgbWFjaGluZSBpbml0LCBpbmNsdWRpbmcgc3RhdGUgdHJhbnNpdGlvbiBhbmQgdGltZXIgaW5pdAoJUGFyYW1ldGVyczoKCQlTIC0gcG9pbnRlciB0byB0aGUgYXNzb2NpYXRpb24gc3RhdGUgbWFjaGluZQoKCUlSUUwgPSBQQVNTSVZFX0xFVkVMCgoJPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KICovClZPSUQgQXNzb2NTdGF0ZU1hY2hpbmVJbml0KAoJSU4JUFJUTVBfQURBUFRFUglwQWQsCglJTiAgU1RBVEVfTUFDSElORSAqUywKCU9VVCBTVEFURV9NQUNISU5FX0ZVTkMgVHJhbnNbXSkKewoJU3RhdGVNYWNoaW5lSW5pdChTLCBUcmFucywgTUFYX0FTU09DX1NUQVRFLCBNQVhfQVNTT0NfTVNHLCAoU1RBVEVfTUFDSElORV9GVU5DKURyb3AsIEFTU09DX0lETEUsIEFTU09DX01BQ0hJTkVfQkFTRSk7CgoJLy8gZmlyc3QgY29sdW1uCglTdGF0ZU1hY2hpbmVTZXRBY3Rpb24oUywgQVNTT0NfSURMRSwgTVQyX01MTUVfQVNTT0NfUkVRLCAoU1RBVEVfTUFDSElORV9GVU5DKU1sbWVBc3NvY1JlcUFjdGlvbik7CglTdGF0ZU1hY2hpbmVTZXRBY3Rpb24oUywgQVNTT0NfSURMRSwgTVQyX01MTUVfUkVBU1NPQ19SRVEsIChTVEFURV9NQUNISU5FX0ZVTkMpTWxtZVJlYXNzb2NSZXFBY3Rpb24pOwoJU3RhdGVNYWNoaW5lU2V0QWN0aW9uKFMsIEFTU09DX0lETEUsIE1UMl9NTE1FX0RJU0FTU09DX1JFUSwgKFNUQVRFX01BQ0hJTkVfRlVOQylNbG1lRGlzYXNzb2NSZXFBY3Rpb24pOwoJU3RhdGVNYWNoaW5lU2V0QWN0aW9uKFMsIEFTU09DX0lETEUsIE1UMl9QRUVSX0RJU0FTU09DX1JFUSwgKFNUQVRFX01BQ0hJTkVfRlVOQylQZWVyRGlzYXNzb2NBY3Rpb24pOwoKCS8vIHNlY29uZCBjb2x1bW4KCVN0YXRlTWFjaGluZVNldEFjdGlvbihTLCBBU1NPQ19XQUlUX1JTUCwgTVQyX01MTUVfQVNTT0NfUkVRLCAoU1RBVEVfTUFDSElORV9GVU5DKUludmFsaWRTdGF0ZVdoZW5Bc3NvYyk7CglTdGF0ZU1hY2hpbmVTZXRBY3Rpb24oUywgQVNTT0NfV0FJVF9SU1AsIE1UMl9NTE1FX1JFQVNTT0NfUkVRLCAoU1RBVEVfTUFDSElORV9GVU5DKUludmFsaWRTdGF0ZVdoZW5SZWFzc29jKTsKCVN0YXRlTWFjaGluZVNldEFjdGlvbihTLCBBU1NPQ19XQUlUX1JTUCwgTVQyX01MTUVfRElTQVNTT0NfUkVRLCAoU1RBVEVfTUFDSElORV9GVU5DKUludmFsaWRTdGF0ZVdoZW5EaXNhc3NvY2lhdGUpOwoJU3RhdGVNYWNoaW5lU2V0QWN0aW9uKFMsIEFTU09DX1dBSVRfUlNQLCBNVDJfUEVFUl9ESVNBU1NPQ19SRVEsIChTVEFURV9NQUNISU5FX0ZVTkMpUGVlckRpc2Fzc29jQWN0aW9uKTsKCVN0YXRlTWFjaGluZVNldEFjdGlvbihTLCBBU1NPQ19XQUlUX1JTUCwgTVQyX1BFRVJfQVNTT0NfUlNQLCAoU1RBVEVfTUFDSElORV9GVU5DKVBlZXJBc3NvY1JzcEFjdGlvbik7CgkvLwoJLy8gUGF0Y2ggM0NvbSBBUCBNT2RlOjNDUldFNDU0RzcyCgkvLyBXZSBzZW5kIEFzc29jIHJlcXVlc3QgZnJhbWUgdG8gdGhpcyBBUCwgaXQgYWx3YXlzIHNlbmQgUmVhc3NvYyBSc3Agbm90IEFzc29jaWF0ZSBSc3AuCgkvLwoJU3RhdGVNYWNoaW5lU2V0QWN0aW9uKFMsIEFTU09DX1dBSVRfUlNQLCBNVDJfUEVFUl9SRUFTU09DX1JTUCwgKFNUQVRFX01BQ0hJTkVfRlVOQylQZWVyQXNzb2NSc3BBY3Rpb24pOwoJU3RhdGVNYWNoaW5lU2V0QWN0aW9uKFMsIEFTU09DX1dBSVRfUlNQLCBNVDJfQVNTT0NfVElNRU9VVCwgKFNUQVRFX01BQ0hJTkVfRlVOQylBc3NvY1RpbWVvdXRBY3Rpb24pOwoKCS8vIHRoaXJkIGNvbHVtbgoJU3RhdGVNYWNoaW5lU2V0QWN0aW9uKFMsIFJFQVNTT0NfV0FJVF9SU1AsIE1UMl9NTE1FX0FTU09DX1JFUSwgKFNUQVRFX01BQ0hJTkVfRlVOQylJbnZhbGlkU3RhdGVXaGVuQXNzb2MpOwoJU3RhdGVNYWNoaW5lU2V0QWN0aW9uKFMsIFJFQVNTT0NfV0FJVF9SU1AsIE1UMl9NTE1FX1JFQVNTT0NfUkVRLCAoU1RBVEVfTUFDSElORV9GVU5DKUludmFsaWRTdGF0ZVdoZW5SZWFzc29jKTsKCVN0YXRlTWFjaGluZVNldEFjdGlvbihTLCBSRUFTU09DX1dBSVRfUlNQLCBNVDJfTUxNRV9ESVNBU1NPQ19SRVEsIChTVEFURV9NQUNISU5FX0ZVTkMpSW52YWxpZFN0YXRlV2hlbkRpc2Fzc29jaWF0ZSk7CglTdGF0ZU1hY2hpbmVTZXRBY3Rpb24oUywgUkVBU1NPQ19XQUlUX1JTUCwgTVQyX1BFRVJfRElTQVNTT0NfUkVRLCAoU1RBVEVfTUFDSElORV9GVU5DKVBlZXJEaXNhc3NvY0FjdGlvbik7CglTdGF0ZU1hY2hpbmVTZXRBY3Rpb24oUywgUkVBU1NPQ19XQUlUX1JTUCwgTVQyX1BFRVJfUkVBU1NPQ19SU1AsIChTVEFURV9NQUNISU5FX0ZVTkMpUGVlclJlYXNzb2NSc3BBY3Rpb24pOwoJLy8KCS8vIFBhdGNoLCBBUCBkb2Vzbid0IHNlbmQgUmVhc3NvY2lhdGUgUnNwIGZyYW1lIHRvIFN0YXRpb24uCgkvLwoJU3RhdGVNYWNoaW5lU2V0QWN0aW9uKFMsIFJFQVNTT0NfV0FJVF9SU1AsIE1UMl9QRUVSX0FTU09DX1JTUCwgKFNUQVRFX01BQ0hJTkVfRlVOQylQZWVyUmVhc3NvY1JzcEFjdGlvbik7CglTdGF0ZU1hY2hpbmVTZXRBY3Rpb24oUywgUkVBU1NPQ19XQUlUX1JTUCwgTVQyX1JFQVNTT0NfVElNRU9VVCwgKFNUQVRFX01BQ0hJTkVfRlVOQylSZWFzc29jVGltZW91dEFjdGlvbik7CgoJLy8gZm91cnRoIGNvbHVtbgoJU3RhdGVNYWNoaW5lU2V0QWN0aW9uKFMsIERJU0FTU09DX1dBSVRfUlNQLCBNVDJfTUxNRV9BU1NPQ19SRVEsIChTVEFURV9NQUNISU5FX0ZVTkMpSW52YWxpZFN0YXRlV2hlbkFzc29jKTsKCVN0YXRlTWFjaGluZVNldEFjdGlvbihTLCBESVNBU1NPQ19XQUlUX1JTUCwgTVQyX01MTUVfUkVBU1NPQ19SRVEsIChTVEFURV9NQUNISU5FX0ZVTkMpSW52YWxpZFN0YXRlV2hlblJlYXNzb2MpOwoJU3RhdGVNYWNoaW5lU2V0QWN0aW9uKFMsIERJU0FTU09DX1dBSVRfUlNQLCBNVDJfTUxNRV9ESVNBU1NPQ19SRVEsIChTVEFURV9NQUNISU5FX0ZVTkMpSW52YWxpZFN0YXRlV2hlbkRpc2Fzc29jaWF0ZSk7CglTdGF0ZU1hY2hpbmVTZXRBY3Rpb24oUywgRElTQVNTT0NfV0FJVF9SU1AsIE1UMl9QRUVSX0RJU0FTU09DX1JFUSwgKFNUQVRFX01BQ0hJTkVfRlVOQylQZWVyRGlzYXNzb2NBY3Rpb24pOwoJU3RhdGVNYWNoaW5lU2V0QWN0aW9uKFMsIERJU0FTU09DX1dBSVRfUlNQLCBNVDJfRElTQVNTT0NfVElNRU9VVCwgKFNUQVRFX01BQ0hJTkVfRlVOQylEaXNhc3NvY1RpbWVvdXRBY3Rpb24pOwoKCS8vIGluaXRpYWxpemUgdGhlIHRpbWVyCglSVE1QSW5pdFRpbWVyKHBBZCwgJnBBZC0+TWxtZUF1eC5Bc3NvY1RpbWVyLCBHRVRfVElNRVJfRlVOQ1RJT04oQXNzb2NUaW1lb3V0KSwgcEFkLCBGQUxTRSk7CglSVE1QSW5pdFRpbWVyKHBBZCwgJnBBZC0+TWxtZUF1eC5SZWFzc29jVGltZXIsIEdFVF9USU1FUl9GVU5DVElPTihSZWFzc29jVGltZW91dCksIHBBZCwgRkFMU0UpOwoJUlRNUEluaXRUaW1lcihwQWQsICZwQWQtPk1sbWVBdXguRGlzYXNzb2NUaW1lciwgR0VUX1RJTUVSX0ZVTkNUSU9OKERpc2Fzc29jVGltZW91dCksIHBBZCwgRkFMU0UpOwp9CgovKgoJPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KCURlc2NyaXB0aW9uOgoJCUFzc29jaWF0aW9uIHRpbWVvdXQgcHJvY2VkdXJlLiBBZnRlciBhc3NvY2lhdGlvbiB0aW1lb3V0LCB0aGlzIGZ1bmN0aW9uCgkJd2lsbCBiZSBjYWxsZWQgYW5kIGl0IHdpbGwgcHV0IGEgbWVzc2FnZSBpbnRvIHRoZSBNTE1FIHF1ZXVlCglQYXJhbWV0ZXJzOgoJCVN0YW5kYXJkIHRpbWVyIHBhcmFtZXRlcnMKCglJUlFMID0gRElTUEFUQ0hfTEVWRUwKCgk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogKi8KVk9JRCBBc3NvY1RpbWVvdXQoSU4gUFZPSUQgU3lzdGVtU3BlY2lmaWMxLAoJCQkJIElOIFBWT0lEIEZ1bmN0aW9uQ29udGV4dCwKCQkJCSBJTiBQVk9JRCBTeXN0ZW1TcGVjaWZpYzIsCgkJCQkgSU4gUFZPSUQgU3lzdGVtU3BlY2lmaWMzKQp7CglSVE1QX0FEQVBURVIgKnBBZCA9IChSVE1QX0FEQVBURVIgKilGdW5jdGlvbkNvbnRleHQ7CgoJLy8gRG8gbm90aGluZyBpZiB0aGUgZHJpdmVyIGlzIHN0YXJ0aW5nIGhhbHQgc3RhdGUuCgkvLyBUaGlzIG1pZ2h0IGhhcHBlbiB3aGVuIHRpbWVyIGFscmVhZHkgYmVlbiBmaXJlZCBiZWZvcmUgY2FuY2VsIHRpbWVyIHdpdGggbWxtZWhhbHQKCWlmIChSVE1QX1RFU1RfRkxBRyhwQWQsIGZSVE1QX0FEQVBURVJfSEFMVF9JTl9QUk9HUkVTUyB8IGZSVE1QX0FEQVBURVJfTklDX05PVF9FWElTVCkpCgkJcmV0dXJuOwoKCU1sbWVFbnF1ZXVlKHBBZCwgQVNTT0NfU1RBVEVfTUFDSElORSwgTVQyX0FTU09DX1RJTUVPVVQsIDAsIE5VTEwpOwoJUlQyOFhYX01MTUVfSEFORExFUihwQWQpOwp9CgovKgoJPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KCURlc2NyaXB0aW9uOgoJCVJlYXNzb2NpYXRpb24gdGltZW91dCBwcm9jZWR1cmUuIEFmdGVyIHJlYXNzb2NpYXRpb24gdGltZW91dCwgdGhpcwoJCWZ1bmN0aW9uIHdpbGwgYmUgY2FsbGVkIGFuZCBwdXQgYSBtZXNzYWdlIGludG8gdGhlIE1MTUUgcXVldWUKCVBhcmFtZXRlcnM6CgkJU3RhbmRhcmQgdGltZXIgcGFyYW1ldGVycwoKCUlSUUwgPSBESVNQQVRDSF9MRVZFTAoKCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAqLwpWT0lEIFJlYXNzb2NUaW1lb3V0KElOIFBWT0lEIFN5c3RlbVNwZWNpZmljMSwKCQkJCQlJTiBQVk9JRCBGdW5jdGlvbkNvbnRleHQsCgkJCQkJSU4gUFZPSUQgU3lzdGVtU3BlY2lmaWMyLAoJCQkJCUlOIFBWT0lEIFN5c3RlbVNwZWNpZmljMykKewoJUlRNUF9BREFQVEVSICpwQWQgPSAoUlRNUF9BREFQVEVSICopRnVuY3Rpb25Db250ZXh0OwoKCS8vIERvIG5vdGhpbmcgaWYgdGhlIGRyaXZlciBpcyBzdGFydGluZyBoYWx0IHN0YXRlLgoJLy8gVGhpcyBtaWdodCBoYXBwZW4gd2hlbiB0aW1lciBhbHJlYWR5IGJlZW4gZmlyZWQgYmVmb3JlIGNhbmNlbCB0aW1lciB3aXRoIG1sbWVoYWx0CglpZiAoUlRNUF9URVNUX0ZMQUcocEFkLCBmUlRNUF9BREFQVEVSX0hBTFRfSU5fUFJPR1JFU1MgfCBmUlRNUF9BREFQVEVSX05JQ19OT1RfRVhJU1QpKQoJCXJldHVybjsKCglNbG1lRW5xdWV1ZShwQWQsIEFTU09DX1NUQVRFX01BQ0hJTkUsIE1UMl9SRUFTU09DX1RJTUVPVVQsIDAsIE5VTEwpOwoJUlQyOFhYX01MTUVfSEFORExFUihwQWQpOwp9CgovKgoJPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KCURlc2NyaXB0aW9uOgoJCURpc2Fzc29jaWF0aW9uIHRpbWVvdXQgcHJvY2VkdXJlLiBBZnRlciBkaXNhc3NvY2lhdGlvbiB0aW1lb3V0LCB0aGlzCgkJZnVuY3Rpb24gd2lsbCBiZSBjYWxsZWQgYW5kIHB1dCBhIG1lc3NhZ2UgaW50byB0aGUgTUxNRSBxdWV1ZQoJUGFyYW1ldGVyczoKCQlTdGFuZGFyZCB0aW1lciBwYXJhbWV0ZXJzCgoJSVJRTCA9IERJU1BBVENIX0xFVkVMCgoJPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KICovClZPSUQgRGlzYXNzb2NUaW1lb3V0KElOIFBWT0lEIFN5c3RlbVNwZWNpZmljMSwKCQkJCQlJTiBQVk9JRCBGdW5jdGlvbkNvbnRleHQsCgkJCQkJSU4gUFZPSUQgU3lzdGVtU3BlY2lmaWMyLAoJCQkJCUlOIFBWT0lEIFN5c3RlbVNwZWNpZmljMykKewoJUlRNUF9BREFQVEVSICpwQWQgPSAoUlRNUF9BREFQVEVSICopRnVuY3Rpb25Db250ZXh0OwoKCS8vIERvIG5vdGhpbmcgaWYgdGhlIGRyaXZlciBpcyBzdGFydGluZyBoYWx0IHN0YXRlLgoJLy8gVGhpcyBtaWdodCBoYXBwZW4gd2hlbiB0aW1lciBhbHJlYWR5IGJlZW4gZmlyZWQgYmVmb3JlIGNhbmNlbCB0aW1lciB3aXRoIG1sbWVoYWx0CglpZiAoUlRNUF9URVNUX0ZMQUcocEFkLCBmUlRNUF9BREFQVEVSX0hBTFRfSU5fUFJPR1JFU1MgfCBmUlRNUF9BREFQVEVSX05JQ19OT1RfRVhJU1QpKQoJCXJldHVybjsKCglNbG1lRW5xdWV1ZShwQWQsIEFTU09DX1NUQVRFX01BQ0hJTkUsIE1UMl9ESVNBU1NPQ19USU1FT1VULCAwLCBOVUxMKTsKCVJUMjhYWF9NTE1FX0hBTkRMRVIocEFkKTsKfQoKLyoKCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CglEZXNjcmlwdGlvbjoKCQltbG1lIGFzc29jIHJlcSBoYW5kbGluZyBwcm9jZWR1cmUKCVBhcmFtZXRlcnM6CgkJQWRhcHRlciAtIEFkYXB0ZXIgcG9pbnRlcgoJCUVsZW0gLSBNTE1FIFF1ZXVlIEVsZW1lbnQKCVByZToKCQl0aGUgc3RhdGlvbiBoYXMgYmVlbiBhdXRoZW50aWNhdGVkIGFuZCB0aGUgZm9sbG93aW5nIGluZm9ybWF0aW9uIGlzIHN0b3JlZCBpbiB0aGUgY29uZmlnCgkJCS0jIFNTSUQKCQkJLSMgc3VwcG9ydGVkIHJhdGVzIGFuZCB0aGVpciBsZW5ndGgKCQkJLSMgbGlzdGVuIGludGVydmFsIChBZGFwdGVyLT5TdGFDZmcuZGVmYXVsdF9saXN0ZW5fY291bnQpCgkJCS0jIFRyYW5zbWl0IHBvd2VyICAoQWRhcHRlci0+U3RhQ2ZnLnR4X3Bvd2VyKQoJUG9zdCAgOgoJCS0jIEFuIGFzc29jaWF0aW9uIHJlcXVlc3QgZnJhbWUgaXMgZ2VuZXJhdGVkIGFuZCBzZW50IHRvIHRoZSBhaXIKCQktIyBBc3NvY2lhdGlvbiB0aW1lciBzdGFydHMKCQktIyBBc3NvY2lhdGlvbiBzdGF0ZSAtPiBBU1NPQ19XQUlUX1JTUAoKCUlSUUwgPSBESVNQQVRDSF9MRVZFTAoKCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAqLwpWT0lEIE1sbWVBc3NvY1JlcUFjdGlvbigKCUlOIFBSVE1QX0FEQVBURVIgcEFkLAoJSU4gTUxNRV9RVUVVRV9FTEVNICpFbGVtKQp7CglVQ0hBUgkJCUFwQWRkcls2XTsKCUhFQURFUl84MDJfMTEJQXNzb2NIZHI7CglVQ0hBUgkJCUNjeDJMZW4gPSA1OwoJVUNIQVIJCQlXbWVJZVs5XSA9IHtJRV9WRU5ET1JfU1BFQ0lGSUMsIDB4MDcsIDB4MDAsIDB4NTAsIDB4ZjIsIDB4MDIsIDB4MDAsIDB4MDEsIDB4MDB9OwoJVVNIT1JUCQkJTGlzdGVuSW50djsKCVVMT05HCQkJVGltZW91dDsKCVVTSE9SVAkJCUNhcGFiaWxpdHlJbmZvOwoJQk9PTEVBTgkJCVRpbWVyQ2FuY2VsbGVkOwoJUFVDSEFSCQkJcE91dEJ1ZmZlciA9IE5VTEw7CglORElTX1NUQVRVUwkJTlN0YXR1czsKCVVMT05HCQkJRnJhbWVMZW4gPSAwOwoJVUxPTkcJCQl0bXA7CglVU0hPUlQJCQlWYXJJZXNPZmZzZXQ7CglVQ0hBUgkJCUNraXBGbGFnOwoJVUNIQVIJCQlDa2lwTmVnb3RpYXRpb25CdWZmZXJbQ0tJUF9ORUdPVElBVElPTl9MRU5HVEhdOwoJVUNIQVIJCQlBaXJvbmV0Q2tpcEllID0gSUVfQUlST05FVF9DS0lQOwoJVUNIQVIJCQlBaXJvbmV0Q2tpcExlbiA9IENLSVBfTkVHT1RJQVRJT05fTEVOR1RIOwoJVUNIQVIJCQlBaXJvbmV0SVBBZGRyZXNzSUUgPSBJRV9BSVJPTkVUX0lQQUREUkVTUzsKCVVDSEFSCQkJQWlyb25ldElQQWRkcmVzc0xlbiA9IEFJUk9ORVRfSVBBRERSRVNTX0xFTkdUSDsKCVVDSEFSCQkJQWlyb25ldElQQWRkcmVzc0J1ZmZlcltBSVJPTkVUX0lQQUREUkVTU19MRU5HVEhdID0gezB4MDAsIDB4NDAsIDB4OTYsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDIsIDB4MDB9OwoJVVNIT1JUCQkJU3RhdHVzOwoKCS8vIEJsb2NrIGFsbCBhdXRoZW50aWNhdGlvbiByZXF1ZXN0IGR1cm5pbmcgV1BBIGJsb2NrIHBlcmlvZAoJaWYgKHBBZC0+U3RhQ2ZnLmJCbG9ja0Fzc29jID09IFRSVUUpCgl7CgkJREJHUFJJTlQoUlRfREVCVUdfVFJBQ0UsICgiQVNTT0MgLSBCbG9jayBBc3NvYyByZXF1ZXN0IGR1cm5pbmcgV1BBIGJsb2NrIHBlcmlvZCFcbiIpKTsKCQlwQWQtPk1sbWUuQXNzb2NNYWNoaW5lLkN1cnJTdGF0ZSA9IEFTU09DX0lETEU7CgkJU3RhdHVzID0gTUxNRV9TVEFURV9NQUNISU5FX1JFSkVDVDsKCQlNbG1lRW5xdWV1ZShwQWQsIE1MTUVfQ05UTF9TVEFURV9NQUNISU5FLCBNVDJfQVNTT0NfQ09ORiwgMiwgJlN0YXR1cyk7Cgl9CgkvLyBjaGVjayBzYW5pdHkgZmlyc3QKCWVsc2UgaWYgKE1sbWVBc3NvY1JlcVNhbml0eShwQWQsIEVsZW0tPk1zZywgRWxlbS0+TXNnTGVuLCBBcEFkZHIsICZDYXBhYmlsaXR5SW5mbywgJlRpbWVvdXQsICZMaXN0ZW5JbnR2KSkKCXsKCQlSVE1QQ2FuY2VsVGltZXIoJnBBZC0+TWxtZUF1eC5Bc3NvY1RpbWVyLCAmVGltZXJDYW5jZWxsZWQpOwoJCUNPUFlfTUFDX0FERFIocEFkLT5NbG1lQXV4LkJzc2lkLCBBcEFkZHIpOwoKCQkvLyBHZXQgYW4gdW51c2VkIG5vbnBhZ2VkIG1lbW9yeQoJCU5TdGF0dXMgPSBNbG1lQWxsb2NhdGVNZW1vcnkocEFkLCAmcE91dEJ1ZmZlcik7CgkJaWYgKE5TdGF0dXMgIT0gTkRJU19TVEFUVVNfU1VDQ0VTUykKCQl7CgkJCURCR1BSSU5UKFJUX0RFQlVHX1RSQUNFLCgiQVNTT0MgLSBNbG1lQXNzb2NSZXFBY3Rpb24oKSBhbGxvY2F0ZSBtZW1vcnkgZmFpbGVkIFxuIikpOwoJCQlwQWQtPk1sbWUuQXNzb2NNYWNoaW5lLkN1cnJTdGF0ZSA9IEFTU09DX0lETEU7CgkJCVN0YXR1cyA9IE1MTUVfRkFJTF9OT19SRVNPVVJDRTsKCQkJTWxtZUVucXVldWUocEFkLCBNTE1FX0NOVExfU1RBVEVfTUFDSElORSwgTVQyX0FTU09DX0NPTkYsIDIsICZTdGF0dXMpOwoJCQlyZXR1cm47CgkJfQoKCQkvLyBBZGQgYnkgSmFtZXMgMDMvMDYvMjcKCQlwQWQtPlN0YUNmZy5Bc3NvY0luZm8uTGVuZ3RoID0gc2l6ZW9mKE5ESVNfODAyXzExX0FTU09DSUFUSU9OX0lORk9STUFUSU9OKTsKCQkvLyBBc3NvY2lhdGlvbiBkb24ndCBuZWVkIHRvIHJlcG9ydCBNQUMgYWRkcmVzcwoJCXBBZC0+U3RhQ2ZnLkFzc29jSW5mby5BdmFpbGFibGVSZXF1ZXN0Rml4ZWRJRXMgPQoJCQlORElTXzgwMl8xMV9BSV9SRVFGSV9DQVBBQklMSVRJRVMgfCBORElTXzgwMl8xMV9BSV9SRVFGSV9MSVNURU5JTlRFUlZBTDsKCQlwQWQtPlN0YUNmZy5Bc3NvY0luZm8uUmVxdWVzdEZpeGVkSUVzLkNhcGFiaWxpdGllcyA9IENhcGFiaWxpdHlJbmZvOwoJCXBBZC0+U3RhQ2ZnLkFzc29jSW5mby5SZXF1ZXN0Rml4ZWRJRXMuTGlzdGVuSW50ZXJ2YWwgPSBMaXN0ZW5JbnR2OwoJCS8vIE9ubHkgcmVhc3NvY2lhdGUgbmVlZCB0aGlzCgkJLy9DT1BZX01BQ19BRERSKHBBZC0+U3RhQ2ZnLkFzc29jSW5mby5SZXF1ZXN0Rml4ZWRJRXMuQ3VycmVudEFQQWRkcmVzcywgQXBBZGRyKTsKCQlwQWQtPlN0YUNmZy5Bc3NvY0luZm8uT2Zmc2V0UmVxdWVzdElFcyA9IHNpemVvZihORElTXzgwMl8xMV9BU1NPQ0lBVElPTl9JTkZPUk1BVElPTik7CgogICAgICAgIE5kaXNaZXJvTWVtb3J5KHBBZC0+U3RhQ2ZnLlJlcVZhcklFcywgTUFYX1ZJRV9MRU4pOwoJCS8vIEZpcnN0IGFkZCBTU0lECgkJVmFySWVzT2Zmc2V0ID0gMDsKCQlOZGlzTW92ZU1lbW9yeShwQWQtPlN0YUNmZy5SZXFWYXJJRXMgKyBWYXJJZXNPZmZzZXQsICZTc2lkSWUsIDEpOwoJCVZhckllc09mZnNldCArPSAxOwoJCU5kaXNNb3ZlTWVtb3J5KHBBZC0+U3RhQ2ZnLlJlcVZhcklFcyArIFZhckllc09mZnNldCwgJnBBZC0+TWxtZUF1eC5Tc2lkTGVuLCAxKTsKCQlWYXJJZXNPZmZzZXQgKz0gMTsKCQlOZGlzTW92ZU1lbW9yeShwQWQtPlN0YUNmZy5SZXFWYXJJRXMgKyBWYXJJZXNPZmZzZXQsIHBBZC0+TWxtZUF1eC5Tc2lkLCBwQWQtPk1sbWVBdXguU3NpZExlbik7CgkJVmFySWVzT2Zmc2V0ICs9IHBBZC0+TWxtZUF1eC5Tc2lkTGVuOwoKCQkvLyBTZWNvbmQgYWRkIFN1cHBvcnRlZCByYXRlcwoJCU5kaXNNb3ZlTWVtb3J5KHBBZC0+U3RhQ2ZnLlJlcVZhcklFcyArIFZhckllc09mZnNldCwgJlN1cFJhdGVJZSwgMSk7CgkJVmFySWVzT2Zmc2V0ICs9IDE7CgkJTmRpc01vdmVNZW1vcnkocEFkLT5TdGFDZmcuUmVxVmFySUVzICsgVmFySWVzT2Zmc2V0LCAmcEFkLT5NbG1lQXV4LlN1cFJhdGVMZW4sIDEpOwoJCVZhckllc09mZnNldCArPSAxOwoJCU5kaXNNb3ZlTWVtb3J5KHBBZC0+U3RhQ2ZnLlJlcVZhcklFcyArIFZhckllc09mZnNldCwgcEFkLT5NbG1lQXV4LlN1cFJhdGUsIHBBZC0+TWxtZUF1eC5TdXBSYXRlTGVuKTsKCQlWYXJJZXNPZmZzZXQgKz0gcEFkLT5NbG1lQXV4LlN1cFJhdGVMZW47CgkJLy8gRW5kIEFkZCBieSBKYW1lcwoKICAgICAgICBpZiAoKHBBZC0+Q29tbW9uQ2ZnLkNoYW5uZWwgPiAxNCkgJiYKICAgICAgICAgICAgKHBBZC0+Q29tbW9uQ2ZnLmJJRUVFODAyMTFIID09IFRSVUUpKQogICAgICAgICAgICBDYXBhYmlsaXR5SW5mbyB8PSAweDAxMDA7CgoJCURCR1BSSU5UKFJUX0RFQlVHX1RSQUNFLCAoIkFTU09DIC0gU2VuZCBBU1NPQyByZXF1ZXN0Li4uXG4iKSk7CgkJTWd0TWFjSGVhZGVySW5pdChwQWQsICZBc3NvY0hkciwgU1VCVFlQRV9BU1NPQ19SRVEsIDAsIEFwQWRkciwgQXBBZGRyKTsKCgkJLy8gQnVpbGQgYmFzaWMgZnJhbWUgZmlyc3QKCQlNYWtlT3V0Z29pbmdGcmFtZShwT3V0QnVmZmVyLAkJCQkmRnJhbWVMZW4sCgkJCQkJCSAgc2l6ZW9mKEhFQURFUl84MDJfMTEpLAkmQXNzb2NIZHIsCgkJCQkJCSAgMiwJCQkJCQkmQ2FwYWJpbGl0eUluZm8sCgkJCQkJCSAgMiwJCQkJCQkmTGlzdGVuSW50diwKCQkJCQkJICAxLAkJCQkJCSZTc2lkSWUsCgkJCQkJCSAgMSwJCQkJCQkmcEFkLT5NbG1lQXV4LlNzaWRMZW4sCgkJCQkJCSAgcEFkLT5NbG1lQXV4LlNzaWRMZW4sIAlwQWQtPk1sbWVBdXguU3NpZCwKCQkJCQkJICAxLAkJCQkJCSZTdXBSYXRlSWUsCgkJCQkJCSAgMSwJCQkJCQkmcEFkLT5NbG1lQXV4LlN1cFJhdGVMZW4sCgkJCQkJCSAgcEFkLT5NbG1lQXV4LlN1cFJhdGVMZW4sICBwQWQtPk1sbWVBdXguU3VwUmF0ZSwKCQkJCQkJICBFTkRfT0ZfQVJHUyk7CgoJCWlmIChwQWQtPk1sbWVBdXguRXh0UmF0ZUxlbiAhPSAwKQoJCXsKCQkJTWFrZU91dGdvaW5nRnJhbWUocE91dEJ1ZmZlciArIEZyYW1lTGVuLCAgICAmdG1wLAoJCQkJCQkJICAxLCAgICAgICAgICAgICAgICAgICAgICAgICZFeHRSYXRlSWUsCgkJCQkJCQkgIDEsICAgICAgICAgICAgICAgICAgICAgICAgJnBBZC0+TWxtZUF1eC5FeHRSYXRlTGVuLAoJCQkJCQkJICBwQWQtPk1sbWVBdXguRXh0UmF0ZUxlbiwgIHBBZC0+TWxtZUF1eC5FeHRSYXRlLAoJCQkJCQkJICBFTkRfT0ZfQVJHUyk7CgkJCUZyYW1lTGVuICs9IHRtcDsKCQl9CgoJCS8vIEhUCgkJaWYgKChwQWQtPk1sbWVBdXguSHRDYXBhYmlsaXR5TGVuID4gMCkgJiYgKHBBZC0+Q29tbW9uQ2ZnLlBoeU1vZGUgPj0gUEhZXzExQUJHTl9NSVhFRCkpCgkJewoJCQlVTE9ORyBUbXBMZW47CgkJCVVDSEFSIEh0TGVuOwoJCQlVQ0hBUiBCUk9BRENPTVs0XSA9IHsweDAsIDB4OTAsIDB4NGMsIDB4MzN9OwoJCQlpZiAocEFkLT5TdGFBY3RpdmUuU3VwcG9ydGVkUGh5SW5mby5iUHJlTkh0ID09IFRSVUUpCgkJCXsKCQkJCUh0TGVuID0gU0laRV9IVF9DQVBfSUUgKyA0OwoJCQkJTWFrZU91dGdvaW5nRnJhbWUocE91dEJ1ZmZlciArIEZyYW1lTGVuLCAgICAgICAgICAgICZUbXBMZW4sCgkJCQkJCQkgIDEsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmV3BhSWUsCgkJCQkJCQkgIDEsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmSHRMZW4sCgkJCQkJCQkgIDQsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmQlJPQURDT01bMF0sCgkJCQkJCQkgcEFkLT5NbG1lQXV4Lkh0Q2FwYWJpbGl0eUxlbiwgICAgICAgICAgJnBBZC0+TWxtZUF1eC5IdENhcGFiaWxpdHksCgkJCQkJCQkgIEVORF9PRl9BUkdTKTsKCQkJfQoJCQllbHNlCgkJCXsKCQkJCU1ha2VPdXRnb2luZ0ZyYW1lKHBPdXRCdWZmZXIgKyBGcmFtZUxlbiwgICAgICAgICAgICAmVG1wTGVuLAoJCQkJCQkJICAxLCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJkh0Q2FwSWUsCgkJCQkJCQkgIDEsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmcEFkLT5NbG1lQXV4Lkh0Q2FwYWJpbGl0eUxlbiwKCQkJCQkJCSBwQWQtPk1sbWVBdXguSHRDYXBhYmlsaXR5TGVuLCAgICAgICAgICAmcEFkLT5NbG1lQXV4Lkh0Q2FwYWJpbGl0eSwKCQkJCQkJCSAgRU5EX09GX0FSR1MpOwoJCQl9CgkJCUZyYW1lTGVuICs9IFRtcExlbjsKCQl9CgoJCS8vIGFkZCBSYWxpbmsgcHJvcHJpZXRhcnkgSUUgdG8gaW5mb3JtIEFQIHRoaXMgU1RBIGlzIGdvaW5nIHRvIHVzZSBBR0dSRUdBVElPTiBvciBQSUdHWS1CQUNLK0FHR1JFR0FUSU9OCgkJLy8gQ2FzZSBJOiAoQWdncmVnYXRpb24gKyBQaWdneS1CYWNrKQoJCS8vIDEuIHVzZXIgZW5hYmxlIGFnZ3JlZ2F0aW9uLCBBTkQKCQkvLyAyLiBNYWMgc3VwcG9ydCBwaWdneS1iYWNrCgkJLy8gMy4gQVAgYW5ub3VjZXMgaXQncyBQSUdHWS1CQUNLK0FHR1JFR0FUSU9OLWNhcGFibGUgaW4gQkVBQ09OCgkJLy8gQ2FzZSBJSTogKEFnZ3JlZ2F0aW9uKQoJCS8vIDEuIHVzZXIgZW5hYmxlIGFnZ3JlZ2F0aW9uLCBBTkQKCQkvLyAyLiBBUCBhbm5vdWNlcyBpdCdzIEFHR1JFR0FUSU9OLWNhcGFibGUgaW4gQkVBQ09OCgkJaWYgKHBBZC0+Q29tbW9uQ2ZnLmJBZ2dyZWdhdGlvbkNhcGFibGUpCgkJewoJCQlpZiAoKHBBZC0+Q29tbW9uQ2ZnLmJQaWdneUJhY2tDYXBhYmxlKSAmJiAoKHBBZC0+TWxtZUF1eC5BUFJhbGlua0llICYgMHgwMDAwMDAwMykgPT0gMykpCgkJCXsKCQkJCVVMT05HIFRtcExlbjsKCQkJCVVDSEFSIFJhbGlua0llWzldID0ge0lFX1ZFTkRPUl9TUEVDSUZJQywgNywgMHgwMCwgMHgwYywgMHg0MywgMHgwMywgMHgwMCwgMHgwMCwgMHgwMH07CgkJCQlNYWtlT3V0Z29pbmdGcmFtZShwT3V0QnVmZmVyK0ZyYW1lTGVuLCAgICAgICAgICAgJlRtcExlbiwKCQkJCQkJCQkgIDksICAgICAgICAgICAgICAgICAgICAgICAgICAgICBSYWxpbmtJZSwKCQkJCQkJCQkgIEVORF9PRl9BUkdTKTsKCQkJCUZyYW1lTGVuICs9IFRtcExlbjsKCQkJfQoJCQllbHNlIGlmIChwQWQtPk1sbWVBdXguQVBSYWxpbmtJZSAmIDB4MDAwMDAwMDEpCgkJCXsKCQkJCVVMT05HIFRtcExlbjsKCQkJCVVDSEFSIFJhbGlua0llWzldID0ge0lFX1ZFTkRPUl9TUEVDSUZJQywgNywgMHgwMCwgMHgwYywgMHg0MywgMHgwMSwgMHgwMCwgMHgwMCwgMHgwMH07CgkJCQlNYWtlT3V0Z29pbmdGcmFtZShwT3V0QnVmZmVyK0ZyYW1lTGVuLCAgICAgICAgICAgJlRtcExlbiwKCQkJCQkJCQkgIDksICAgICAgICAgICAgICAgICAgICAgICAgICAgICBSYWxpbmtJZSwKCQkJCQkJCQkgIEVORF9PRl9BUkdTKTsKCQkJCUZyYW1lTGVuICs9IFRtcExlbjsKCQkJfQoJCX0KCQllbHNlCgkJewoJCQlVTE9ORyBUbXBMZW47CgkJCVVDSEFSIFJhbGlua0llWzldID0ge0lFX1ZFTkRPUl9TUEVDSUZJQywgNywgMHgwMCwgMHgwYywgMHg0MywgMHgwNiwgMHgwMCwgMHgwMCwgMHgwMH07CgkJCU1ha2VPdXRnb2luZ0ZyYW1lKHBPdXRCdWZmZXIrRnJhbWVMZW4sCQkgJlRtcExlbiwKCQkJCQkJCSAgOSwJCQkJCQkgUmFsaW5rSWUsCgkJCQkJCQkgIEVORF9PRl9BUkdTKTsKCQkJRnJhbWVMZW4gKz0gVG1wTGVuOwoJCX0KCgkJaWYgKHBBZC0+TWxtZUF1eC5BUEVkY2FQYXJtLmJWYWxpZCkKCQl7CgkJCWlmIChwQWQtPkNvbW1vbkNmZy5iQVBTRENhcGFibGUgJiYgcEFkLT5NbG1lQXV4LkFQRWRjYVBhcm0uYkFQU0RDYXBhYmxlKQoJCQl7CgkJCQlRQlNTX1NUQV9JTkZPX1BBUk0gUW9zSW5mbzsKCgkJCQlOZGlzWmVyb01lbW9yeSgmUW9zSW5mbywgc2l6ZW9mKFFCU1NfU1RBX0lORk9fUEFSTSkpOwoJCQkJUW9zSW5mby5VQVBTRF9BQ19CRSA9IHBBZC0+Q29tbW9uQ2ZnLmJBUFNEQUNfQkU7CgkJCQlRb3NJbmZvLlVBUFNEX0FDX0JLID0gcEFkLT5Db21tb25DZmcuYkFQU0RBQ19CSzsKCQkJCVFvc0luZm8uVUFQU0RfQUNfVkkgPSBwQWQtPkNvbW1vbkNmZy5iQVBTREFDX1ZJOwoJCQkJUW9zSW5mby5VQVBTRF9BQ19WTyA9IHBBZC0+Q29tbW9uQ2ZnLmJBUFNEQUNfVk87CgkJCQlRb3NJbmZvLk1heFNQTGVuZ3RoID0gcEFkLT5Db21tb25DZmcuTWF4U1BMZW5ndGg7CgkJCQlXbWVJZVs4XSB8PSAqKFBVQ0hBUikmUW9zSW5mbzsKCQkJfQoJCQllbHNlCgkJCXsKICAgICAgICAgICAgICAgIC8vIFRoZSBQYXJhbWV0ZXIgU2V0IENvdW50IGlzIHNldCB0byChpzChqCBpbiB0aGUgYXNzb2NpYXRpb24gcmVxdWVzdCBmcmFtZXMKICAgICAgICAgICAgICAgIC8vIFdtZUllWzhdIHw9IChwQWQtPk1sbWVBdXguQVBFZGNhUGFybS5FZGNhVXBkYXRlQ291bnQgJiAweDBmKTsKCQkJfQoKCQkJTWFrZU91dGdvaW5nRnJhbWUocE91dEJ1ZmZlciArIEZyYW1lTGVuLCAgICAmdG1wLAoJCQkJCQkJICA5LCAgICAgICAgICAgICAgICAgICAgICAgICZXbWVJZVswXSwKCQkJCQkJCSAgRU5EX09GX0FSR1MpOwoJCQlGcmFtZUxlbiArPSB0bXA7CgkJfQoKCQkvLwoJCS8vIExldCBXUEEoIzIyMSkgRWxlbWVudCBJRCBvbiB0aGUgZW5kIG9mIHRoaXMgYXNzb2NpYXRpb24gZnJhbWUuCgkJLy8gT3RoZXJ3aXNlIHNvbWUgQVAgd2lsbCBmYWlsIG9uIHBhcnNpbmcgRWxlbWVudCBJRCBhbmQgc2V0IHN0YXR1cyBmYWlsIG9uIEFzc29jIFJzcC4KCQkvLyBGb3IgZXhhbXBsZTogUHV0IFZlbmRvciBTcGVjaWZpYyBJRSBvbiB0aGUgZnJvbnQgb2YgV1BBIElFLgoJCS8vIFRoaXMgaGFwcGVucyBvbiBBUCAoTW9kZWwgTm86TGlua3N5cyBXUks1NEcpCgkJLy8KCQlpZiAoKChwQWQtPlN0YUNmZy5BdXRoTW9kZSA9PSBOZGlzODAyXzExQXV0aE1vZGVXUEFQU0spIHx8CiAgICAgICAgICAgIChwQWQtPlN0YUNmZy5BdXRoTW9kZSA9PSBOZGlzODAyXzExQXV0aE1vZGVXUEEyUFNLKSB8fAogICAgICAgICAgICAocEFkLT5TdGFDZmcuQXV0aE1vZGUgPT0gTmRpczgwMl8xMUF1dGhNb2RlV1BBKSB8fAogICAgICAgICAgICAocEFkLT5TdGFDZmcuQXV0aE1vZGUgPT0gTmRpczgwMl8xMUF1dGhNb2RlV1BBMikKCQkJKQogICAgICAgICAgICApCgkJewoJCQlVQ0hBUiBSU05JZSA9IElFX1dQQTsKCgkJCWlmICgocEFkLT5TdGFDZmcuQXV0aE1vZGUgPT0gTmRpczgwMl8xMUF1dGhNb2RlV1BBMlBTSykgfHwKICAgICAgICAgICAgICAgIChwQWQtPlN0YUNmZy5BdXRoTW9kZSA9PSBOZGlzODAyXzExQXV0aE1vZGVXUEEyKSkKCQkJewoJCQkJUlNOSWUgPSBJRV9XUEEyOwoJCQl9CgoJCQlpZiAocEFkLT5TdGFDZmcuV3BhU3VwcGxpY2FudFVQICE9IDEpCiAgICAgICAgICAgIFJUTVBNYWtlUlNOSUUocEFkLCBwQWQtPlN0YUNmZy5BdXRoTW9kZSwgcEFkLT5TdGFDZmcuV2VwU3RhdHVzLCBCU1MwKTsKCiAgICAgICAgICAgIC8vIENoZWNrIGZvciBXUEEgUE1LIGNhY2hlIGxpc3QKCQkJaWYgKHBBZC0+U3RhQ2ZnLkF1dGhNb2RlID09IE5kaXM4MDJfMTFBdXRoTW9kZVdQQTIpCgkJCXsKCQkJICAgIElOVCAgICAgaWR4OwogICAgICAgICAgICAgICAgQk9PTEVBTiBGb3VuZFBNSyA9IEZBTFNFOwoJCQkJLy8gU2VhcmNoIGNoY2hlZCBQTUtJRCwgYXBwZW5kIGl0IGlmIGV4aXN0ZWQKCQkJCWZvciAoaWR4ID0gMDsgaWR4IDwgUE1LSURfTk87IGlkeCsrKQoJCQkJewoJCQkJCWlmIChOZGlzRXF1YWxNZW1vcnkoQXBBZGRyLCAmcEFkLT5TdGFDZmcuU2F2ZWRQTUtbaWR4XS5CU1NJRCwgNikpCgkJCQkJewoJCQkJCQlGb3VuZFBNSyA9IFRSVUU7CgkJCQkJCWJyZWFrOwoJCQkJCX0KCQkJCX0KCgkJCQlpZiAoRm91bmRQTUspCgkJCQl7CgkJCQkJLy8gU2V0IFBNSyBudW1iZXIKCQkJCQkqKFBVU0hPUlQpICZwQWQtPlN0YUNmZy5SU05fSUVbcEFkLT5TdGFDZmcuUlNOSUVfTGVuXSA9IDE7CgkJCQkJTmRpc01vdmVNZW1vcnkoJnBBZC0+U3RhQ2ZnLlJTTl9JRVtwQWQtPlN0YUNmZy5SU05JRV9MZW4gKyAyXSwgJnBBZC0+U3RhQ2ZnLlNhdmVkUE1LW2lkeF0uUE1LSUQsIDE2KTsKICAgICAgICAgICAgICAgICAgICBwQWQtPlN0YUNmZy5SU05JRV9MZW4gKz0gMTg7CgkJCQl9CgkJCX0KCgkJCWlmIChwQWQtPlN0YUNmZy5XcGFTdXBwbGljYW50VVAgPT0gMSkKCQkJewoJCQkJTWFrZU91dGdvaW5nRnJhbWUocE91dEJ1ZmZlciArIEZyYW1lTGVuLCAgICAJCSZ0bXAsCgkJICAgICAgICAgICAgICAgICAgICAgICAgCXBBZC0+U3RhQ2ZnLlJTTklFX0xlbiwJCQlwQWQtPlN0YUNmZy5SU05fSUUsCgkJICAgICAgICAgICAgICAgICAgICAgICAgCUVORF9PRl9BUkdTKTsKCQkJfQoJCQllbHNlCgkJCXsKCQkJCU1ha2VPdXRnb2luZ0ZyYW1lKHBPdXRCdWZmZXIgKyBGcmFtZUxlbiwgICAgCQkmdG1wLAoJCQkJICAgICAgICAgICAgICAJCTEsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJlJTTkllLAoJCSAgICAgICAgICAgICAgICAgICAgICAgIAkxLCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZwQWQtPlN0YUNmZy5SU05JRV9MZW4sCgkJICAgICAgICAgICAgICAgICAgICAgICAgCXBBZC0+U3RhQ2ZnLlJTTklFX0xlbiwJCQlwQWQtPlN0YUNmZy5SU05fSUUsCgkJICAgICAgICAgICAgICAgICAgICAgICAgCUVORF9PRl9BUkdTKTsKCQkJfQoKCQkJRnJhbWVMZW4gKz0gdG1wOwoKCQkJaWYgKHBBZC0+U3RhQ2ZnLldwYVN1cHBsaWNhbnRVUCAhPSAxKQoJCQl7CgkgICAgICAgICAgICAvLyBBcHBlbmQgVmFyaWFibGUgSUUKCSAgICAgICAgICAgIE5kaXNNb3ZlTWVtb3J5KHBBZC0+U3RhQ2ZnLlJlcVZhcklFcyArIFZhckllc09mZnNldCwgJlJTTkllLCAxKTsKCSAgICAgICAgICAgIFZhckllc09mZnNldCArPSAxOwoJICAgICAgICAgICAgTmRpc01vdmVNZW1vcnkocEFkLT5TdGFDZmcuUmVxVmFySUVzICsgVmFySWVzT2Zmc2V0LCAmcEFkLT5TdGFDZmcuUlNOSUVfTGVuLCAxKTsKCSAgICAgICAgICAgIFZhckllc09mZnNldCArPSAxOwoJCQl9CgkJCU5kaXNNb3ZlTWVtb3J5KHBBZC0+U3RhQ2ZnLlJlcVZhcklFcyArIFZhckllc09mZnNldCwgcEFkLT5TdGFDZmcuUlNOX0lFLCBwQWQtPlN0YUNmZy5SU05JRV9MZW4pOwoJCQlWYXJJZXNPZmZzZXQgKz0gcEFkLT5TdGFDZmcuUlNOSUVfTGVuOwoKCQkJLy8gU2V0IFZhcmlhYmxlIElFcyBMZW5ndGgKCQkJcEFkLT5TdGFDZmcuUmVxVmFySUVMZW4gPSBWYXJJZXNPZmZzZXQ7CgkJfQoKCQkvLyBXZSBoYXZlIHVwZGF0ZSB0aGF0IGF0IFBlZXJCZWFjb25BdEpvaW5SZXF1ZXN0KCkKCQlDa2lwRmxhZyA9IHBBZC0+U3RhQ2ZnLkNraXBGbGFnOwoJCWlmIChDa2lwRmxhZyAhPSAwKQoJCXsKCQkJTmRpc1plcm9NZW1vcnkoQ2tpcE5lZ290aWF0aW9uQnVmZmVyLCBDS0lQX05FR09USUFUSU9OX0xFTkdUSCk7CgkJCUNraXBOZWdvdGlhdGlvbkJ1ZmZlclsyXSA9IDB4NjY7CgkJCS8vIE1ha2UgaXQgdHJ5IEtQICYgTUlDLCBzaW5jZSB3ZSBoYXZlIHRvIGZvbGxvdyB0aGUgcmVzdWx0IGZyb20gQXNzb2NSc3AKCQkJQ2tpcE5lZ290aWF0aW9uQnVmZmVyWzhdID0gMHgxODsKCQkJQ2tpcE5lZ290aWF0aW9uQnVmZmVyW0NLSVBfTkVHT1RJQVRJT05fTEVOR1RIIC0gMV0gPSAweDIyOwoJCQlDa2lwRmxhZyA9IDB4MTg7CgoJCQlNYWtlT3V0Z29pbmdGcmFtZShwT3V0QnVmZmVyICsgRnJhbWVMZW4sIAkmdG1wLAoJCQkJCQkxLAkJCQkJCSAgCQkmQWlyb25ldENraXBJZSwKCQkJCQkJMSwJCQkJCQkgIAkJJkFpcm9uZXRDa2lwTGVuLAoJCQkJCQlBaXJvbmV0Q2tpcExlbiwgCQkgIAkJQ2tpcE5lZ290aWF0aW9uQnVmZmVyLAoJCQkJCQlFTkRfT0ZfQVJHUyk7CgkJCUZyYW1lTGVuICs9IHRtcDsKCQl9CgoJCS8vIEFkZCBDQ1ggdjIgcmVxdWVzdCBpZiBDQ1gyIGFkbWluIHN0YXRlIGlzIG9uCgkJaWYgKHBBZC0+U3RhQ2ZnLkNDWENvbnRyb2wuZmllbGQuRW5hYmxlID09IDEpCgkJewoKCQkJLy8KCQkJLy8gQWRkIEFpcm9uZXRJUEFkZHJlc3NJRSBmb3IgQ2lzY28gQ0NYIDIuWAoJCQkvLyBBZGQgQ0NYIFZlcnNpb24KCQkJLy8KCQkJTWFrZU91dGdvaW5nRnJhbWUocE91dEJ1ZmZlciArIEZyYW1lTGVuLCAmdG1wLAoJCQkJCQkxLAkJCQkJCQkmQWlyb25ldElQQWRkcmVzc0lFLAoJCQkJCQkxLAkJCQkJCQkmQWlyb25ldElQQWRkcmVzc0xlbiwKCQkJCQkJQWlyb25ldElQQWRkcmVzc0xlbiwJCUFpcm9uZXRJUEFkZHJlc3NCdWZmZXIsCgkJCQkJCTEsCQkJCQkJCSZDY3gySWUsCgkJCQkJCTEsCQkJCQkJCSZDY3gyTGVuLAoJCQkJCQlDY3gyTGVuLAkJCQkgICAgQ2N4MkllSW5mbywKCQkJCQkJRU5EX09GX0FSR1MpOwoJCQlGcmFtZUxlbiArPSB0bXA7CgoJCQkvLyBBZGQgYnkgSmFtZXMgMDMvMDYvMjcKCQkJLy8gU2V0IFZhcmlhYmxlIElFcyBMZW5ndGgKCQkJcEFkLT5TdGFDZmcuUmVxVmFySUVMZW4gPSBWYXJJZXNPZmZzZXQ7CgkJCXBBZC0+U3RhQ2ZnLkFzc29jSW5mby5SZXF1ZXN0SUVMZW5ndGggPSBWYXJJZXNPZmZzZXQ7CgoJCQkvLyBPZmZzZXRSZXNwb25zZUlFcyBmb2xsb3cgUmVxVmFySUUKCQkJcEFkLT5TdGFDZmcuQXNzb2NJbmZvLk9mZnNldFJlc3BvbnNlSUVzID0gc2l6ZW9mKE5ESVNfODAyXzExX0FTU09DSUFUSU9OX0lORk9STUFUSU9OKSArIHBBZC0+U3RhQ2ZnLlJlcVZhcklFTGVuOwoJCQkvLyBFbmQgQWRkIGJ5IEphbWVzCgkJfQoKCgkJTWluaXBvcnRNTVJlcXVlc3QocEFkLCAwLCBwT3V0QnVmZmVyLCBGcmFtZUxlbik7CgkJTWxtZUZyZWVNZW1vcnkocEFkLCBwT3V0QnVmZmVyKTsKCgkJUlRNUFNldFRpbWVyKCZwQWQtPk1sbWVBdXguQXNzb2NUaW1lciwgVGltZW91dCk7CgkJcEFkLT5NbG1lLkFzc29jTWFjaGluZS5DdXJyU3RhdGUgPSBBU1NPQ19XQUlUX1JTUDsKCX0KCWVsc2UKCXsKCQlEQkdQUklOVChSVF9ERUJVR19UUkFDRSwoIkFTU09DIC0gTWxtZUFzc29jUmVxQWN0aW9uKCkgc2FuaXR5IGNoZWNrIGZhaWxlZC4gQlVHISEhISEhIFxuIikpOwoJCXBBZC0+TWxtZS5Bc3NvY01hY2hpbmUuQ3VyclN0YXRlID0gQVNTT0NfSURMRTsKCQlTdGF0dXMgPSBNTE1FX0lOVkFMSURfRk9STUFUOwoJCU1sbWVFbnF1ZXVlKHBBZCwgTUxNRV9DTlRMX1NUQVRFX01BQ0hJTkUsIE1UMl9BU1NPQ19DT05GLCAyLCAmU3RhdHVzKTsKCX0KCn0KCi8qCgk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQoJRGVzY3JpcHRpb246CgkJbWxtZSByZWFzc29jIHJlcSBoYW5kbGluZyBwcm9jZWR1cmUKCVBhcmFtZXRlcnM6CgkJRWxlbSAtCglQcmU6CgkJLSMgU1NJRCAgKEFkYXB0ZXItPlN0YUNmZy5zc2lkW10pCgkJLSMgQlNTSUQgKEFQIGFkZHJlc3MsIEFkYXB0ZXItPlN0YUNmZy5ic3NpZCkKCQktIyBTdXBwb3J0ZWQgcmF0ZXMgKEFkYXB0ZXItPlN0YUNmZy5zdXBwb3J0ZWRfcmF0ZXNbXSkKCQktIyBTdXBwb3J0ZWQgcmF0ZXMgbGVuZ3RoIChBZGFwdGVyLT5TdGFDZmcuc3VwcG9ydGVkX3JhdGVzX2xlbikKCQktIyBUeCBwb3dlciAoQWRhcHRlci0+U3RhQ2ZnLnR4X3Bvd2VyKQoKCUlSUUwgPSBESVNQQVRDSF9MRVZFTAoKCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAqLwpWT0lEIE1sbWVSZWFzc29jUmVxQWN0aW9uKAoJSU4gUFJUTVBfQURBUFRFUiBwQWQsCglJTiBNTE1FX1FVRVVFX0VMRU0gKkVsZW0pCnsKCVVDSEFSCQkJQXBBZGRyWzZdOwoJSEVBREVSXzgwMl8xMQlSZWFzc29jSGRyOwoJVUNIQVIJCQlDY3gyTGVuID0gNTsKCVVDSEFSCQkJV21lSWVbOV0gPSB7SUVfVkVORE9SX1NQRUNJRklDLCAweDA3LCAweDAwLCAweDUwLCAweGYyLCAweDAyLCAweDAwLCAweDAxLCAweDAwfTsKCVVTSE9SVAkJCUNhcGFiaWxpdHlJbmZvLCBMaXN0ZW5JbnR2OwoJVUxPTkcJCQlUaW1lb3V0OwoJVUxPTkcJCQlGcmFtZUxlbiA9IDA7CglCT09MRUFOCQkJVGltZXJDYW5jZWxsZWQ7CglORElTX1NUQVRVUwkJTlN0YXR1czsKCVVMT05HCQkJdG1wOwoJUFVDSEFSCQkJcE91dEJ1ZmZlciA9IE5VTEw7CglVU0hPUlQJCQlTdGF0dXM7CgoJLy8gQmxvY2sgYWxsIGF1dGhlbnRpY2F0aW9uIHJlcXVlc3QgZHVybmluZyBXUEEgYmxvY2sgcGVyaW9kCglpZiAocEFkLT5TdGFDZmcuYkJsb2NrQXNzb2MgPT0gVFJVRSkKCXsKCQlEQkdQUklOVChSVF9ERUJVR19UUkFDRSwgKCJBU1NPQyAtIEJsb2NrIFJlQXNzb2MgcmVxdWVzdCBkdXJuaW5nIFdQQSBibG9jayBwZXJpb2QhXG4iKSk7CgkJcEFkLT5NbG1lLkFzc29jTWFjaGluZS5DdXJyU3RhdGUgPSBBU1NPQ19JRExFOwoJCVN0YXR1cyA9IE1MTUVfU1RBVEVfTUFDSElORV9SRUpFQ1Q7CgkJTWxtZUVucXVldWUocEFkLCBNTE1FX0NOVExfU1RBVEVfTUFDSElORSwgTVQyX1JFQVNTT0NfQ09ORiwgMiwgJlN0YXR1cyk7Cgl9CgkvLyB0aGUgcGFyYW1ldGVycyBhcmUgdGhlIHNhbWUgYXMgdGhlIGFzc29jaWF0aW9uCgllbHNlIGlmKE1sbWVBc3NvY1JlcVNhbml0eShwQWQsIEVsZW0tPk1zZywgRWxlbS0+TXNnTGVuLCBBcEFkZHIsICZDYXBhYmlsaXR5SW5mbywgJlRpbWVvdXQsICZMaXN0ZW5JbnR2KSkKCXsKCQlSVE1QQ2FuY2VsVGltZXIoJnBBZC0+TWxtZUF1eC5SZWFzc29jVGltZXIsICZUaW1lckNhbmNlbGxlZCk7CgoJCU5TdGF0dXMgPSBNbG1lQWxsb2NhdGVNZW1vcnkocEFkLCAmcE91dEJ1ZmZlcik7ICAvL0dldCBhbiB1bnVzZWQgbm9ucGFnZWQgbWVtb3J5CgkJaWYoTlN0YXR1cyAhPSBORElTX1NUQVRVU19TVUNDRVNTKQoJCXsKCQkJREJHUFJJTlQoUlRfREVCVUdfVFJBQ0UsKCJBU1NPQyAtIE1sbWVSZWFzc29jUmVxQWN0aW9uKCkgYWxsb2NhdGUgbWVtb3J5IGZhaWxlZCBcbiIpKTsKCQkJcEFkLT5NbG1lLkFzc29jTWFjaGluZS5DdXJyU3RhdGUgPSBBU1NPQ19JRExFOwoJCQlTdGF0dXMgPSBNTE1FX0ZBSUxfTk9fUkVTT1VSQ0U7CgkJCU1sbWVFbnF1ZXVlKHBBZCwgTUxNRV9DTlRMX1NUQVRFX01BQ0hJTkUsIE1UMl9SRUFTU09DX0NPTkYsIDIsICZTdGF0dXMpOwoJCQlyZXR1cm47CgkJfQoKCQlDT1BZX01BQ19BRERSKHBBZC0+TWxtZUF1eC5Cc3NpZCwgQXBBZGRyKTsKCgkJLy8gbWFrZSBmcmFtZSwgdXNlIGJzc2lkIGFzIHRoZSBBUCBhZGRyZXNzPz8KCQlEQkdQUklOVChSVF9ERUJVR19UUkFDRSwgKCJBU1NPQyAtIFNlbmQgUkUtQVNTT0MgcmVxdWVzdC4uLlxuIikpOwoJCU1ndE1hY0hlYWRlckluaXQocEFkLCAmUmVhc3NvY0hkciwgU1VCVFlQRV9SRUFTU09DX1JFUSwgMCwgQXBBZGRyLCBBcEFkZHIpOwoJCU1ha2VPdXRnb2luZ0ZyYW1lKHBPdXRCdWZmZXIsICAgICAgICAgICAgICAgJkZyYW1lTGVuLAoJCQkJCQkgIHNpemVvZihIRUFERVJfODAyXzExKSwgICAgJlJlYXNzb2NIZHIsCgkJCQkJCSAgMiwgICAgICAgICAgICAgICAgICAgICAgICAmQ2FwYWJpbGl0eUluZm8sCgkJCQkJCSAgMiwgICAgICAgICAgICAgICAgICAgICAgICAmTGlzdGVuSW50diwKCQkJCQkJICBNQUNfQUREUl9MRU4sICAgICAgICAgICAgIEFwQWRkciwKCQkJCQkJICAxLCAgICAgICAgICAgICAgICAgICAgICAgICZTc2lkSWUsCgkJCQkJCSAgMSwgICAgICAgICAgICAgICAgICAgICAgICAmcEFkLT5NbG1lQXV4LlNzaWRMZW4sCgkJCQkJCSAgcEFkLT5NbG1lQXV4LlNzaWRMZW4sICAgICBwQWQtPk1sbWVBdXguU3NpZCwKCQkJCQkJICAxLCAgICAgICAgICAgICAgICAgICAgICAgICZTdXBSYXRlSWUsCgkJCQkJCSAgMSwJCQkJCQkmcEFkLT5NbG1lQXV4LlN1cFJhdGVMZW4sCgkJCQkJCSAgcEFkLT5NbG1lQXV4LlN1cFJhdGVMZW4sICBwQWQtPk1sbWVBdXguU3VwUmF0ZSwKCQkJCQkJICBFTkRfT0ZfQVJHUyk7CgoJCWlmIChwQWQtPk1sbWVBdXguRXh0UmF0ZUxlbiAhPSAwKQoJCXsKCQkJTWFrZU91dGdvaW5nRnJhbWUocE91dEJ1ZmZlciArIEZyYW1lTGVuLCAgICAgICAgJnRtcCwKCQkJCQkJCSAgMSwgICAgICAgICAgICAgICAgICAgICAgICAgICAgJkV4dFJhdGVJZSwKCQkJCQkJCSAgMSwgICAgICAgICAgICAgICAgICAgICAgICAgICAgJnBBZC0+TWxtZUF1eC5FeHRSYXRlTGVuLAoJCQkJCQkJICBwQWQtPk1sbWVBdXguRXh0UmF0ZUxlbiwJICAgIHBBZC0+TWxtZUF1eC5FeHRSYXRlLAoJCQkJCQkJICBFTkRfT0ZfQVJHUyk7CgkJCUZyYW1lTGVuICs9IHRtcDsKCQl9CgoJCWlmIChwQWQtPk1sbWVBdXguQVBFZGNhUGFybS5iVmFsaWQpCgkJewoJCQlpZiAocEFkLT5Db21tb25DZmcuYkFQU0RDYXBhYmxlICYmIHBBZC0+TWxtZUF1eC5BUEVkY2FQYXJtLmJBUFNEQ2FwYWJsZSkKCQkJewoJCQkJUUJTU19TVEFfSU5GT19QQVJNIFFvc0luZm87CgoJCQkJTmRpc1plcm9NZW1vcnkoJlFvc0luZm8sIHNpemVvZihRQlNTX1NUQV9JTkZPX1BBUk0pKTsKCQkJCVFvc0luZm8uVUFQU0RfQUNfQkUgPSBwQWQtPkNvbW1vbkNmZy5iQVBTREFDX0JFOwoJCQkJUW9zSW5mby5VQVBTRF9BQ19CSyA9IHBBZC0+Q29tbW9uQ2ZnLmJBUFNEQUNfQks7CgkJCQlRb3NJbmZvLlVBUFNEX0FDX1ZJID0gcEFkLT5Db21tb25DZmcuYkFQU0RBQ19WSTsKCQkJCVFvc0luZm8uVUFQU0RfQUNfVk8gPSBwQWQtPkNvbW1vbkNmZy5iQVBTREFDX1ZPOwoJCQkJUW9zSW5mby5NYXhTUExlbmd0aCA9IHBBZC0+Q29tbW9uQ2ZnLk1heFNQTGVuZ3RoOwoJCQkJV21lSWVbOF0gfD0gKihQVUNIQVIpJlFvc0luZm87CgkJCX0KCgkJCU1ha2VPdXRnb2luZ0ZyYW1lKHBPdXRCdWZmZXIgKyBGcmFtZUxlbiwgICAgJnRtcCwKCQkJCQkJCSAgOSwgICAgICAgICAgICAgICAgICAgICAgICAmV21lSWVbMF0sCgkJCQkJCQkgIEVORF9PRl9BUkdTKTsKCQkJRnJhbWVMZW4gKz0gdG1wOwoJCX0KCgkJLy8gSFQKCQlpZiAoKHBBZC0+TWxtZUF1eC5IdENhcGFiaWxpdHlMZW4gPiAwKSAmJiAocEFkLT5Db21tb25DZmcuUGh5TW9kZSA+PSBQSFlfMTFBQkdOX01JWEVEKSkKCQl7CgkJCVVMT05HIFRtcExlbjsKCQkJVUNIQVIgSHRMZW47CgkJCVVDSEFSIEJST0FEQ09NWzRdID0gezB4MCwgMHg5MCwgMHg0YywgMHgzM307CgkJCWlmIChwQWQtPlN0YUFjdGl2ZS5TdXBwb3J0ZWRQaHlJbmZvLmJQcmVOSHQgPT0gVFJVRSkKCQkJewoJCQkJSHRMZW4gPSBTSVpFX0hUX0NBUF9JRSArIDQ7CgkJCQlNYWtlT3V0Z29pbmdGcmFtZShwT3V0QnVmZmVyICsgRnJhbWVMZW4sICAgICAgICAgICAgJlRtcExlbiwKCQkJCQkJCSAgMSwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZXcGFJZSwKCQkJCQkJCSAgMSwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZIdExlbiwKCQkJCQkJCSAgNCwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZCUk9BRENPTVswXSwKCQkJCQkJCSBwQWQtPk1sbWVBdXguSHRDYXBhYmlsaXR5TGVuLCAgICAgICAgICAmcEFkLT5NbG1lQXV4Lkh0Q2FwYWJpbGl0eSwKCQkJCQkJCSAgRU5EX09GX0FSR1MpOwoJCQl9CgkJCWVsc2UKCQkJewoJCQkJTWFrZU91dGdvaW5nRnJhbWUocE91dEJ1ZmZlciArIEZyYW1lTGVuLCAgICAgICAgICAgICZUbXBMZW4sCgkJCQkJCQkgIDEsICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmSHRDYXBJZSwKCQkJCQkJCSAgMSwgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZwQWQtPk1sbWVBdXguSHRDYXBhYmlsaXR5TGVuLAoJCQkJCQkJIHBBZC0+TWxtZUF1eC5IdENhcGFiaWxpdHlMZW4sICAgICAgICAgICZwQWQtPk1sbWVBdXguSHRDYXBhYmlsaXR5LAoJCQkJCQkJICBFTkRfT0ZfQVJHUyk7CgkJCX0KCQkJRnJhbWVMZW4gKz0gVG1wTGVuOwoJCX0KCgkJLy8gYWRkIFJhbGluayBwcm9wcmlldGFyeSBJRSB0byBpbmZvcm0gQVAgdGhpcyBTVEEgaXMgZ29pbmcgdG8gdXNlIEFHR1JFR0FUSU9OIG9yIFBJR0dZLUJBQ0srQUdHUkVHQVRJT04KCQkvLyBDYXNlIEk6IChBZ2dyZWdhdGlvbiArIFBpZ2d5LUJhY2spCgkJLy8gMS4gdXNlciBlbmFibGUgYWdncmVnYXRpb24sIEFORAoJCS8vIDIuIE1hYyBzdXBwb3J0IHBpZ2d5LWJhY2sKCQkvLyAzLiBBUCBhbm5vdWNlcyBpdCdzIFBJR0dZLUJBQ0srQUdHUkVHQVRJT04tY2FwYWJsZSBpbiBCRUFDT04KCQkvLyBDYXNlIElJOiAoQWdncmVnYXRpb24pCgkJLy8gMS4gdXNlciBlbmFibGUgYWdncmVnYXRpb24sIEFORAoJCS8vIDIuIEFQIGFubm91Y2VzIGl0J3MgQUdHUkVHQVRJT04tY2FwYWJsZSBpbiBCRUFDT04KCQlpZiAocEFkLT5Db21tb25DZmcuYkFnZ3JlZ2F0aW9uQ2FwYWJsZSkKCQl7CgkJCWlmICgocEFkLT5Db21tb25DZmcuYlBpZ2d5QmFja0NhcGFibGUpICYmICgocEFkLT5NbG1lQXV4LkFQUmFsaW5rSWUgJiAweDAwMDAwMDAzKSA9PSAzKSkKCQkJewoJCQkJVUxPTkcgVG1wTGVuOwoJCQkJVUNIQVIgUmFsaW5rSWVbOV0gPSB7SUVfVkVORE9SX1NQRUNJRklDLCA3LCAweDAwLCAweDBjLCAweDQzLCAweDAzLCAweDAwLCAweDAwLCAweDAwfTsKCQkJCU1ha2VPdXRnb2luZ0ZyYW1lKHBPdXRCdWZmZXIrRnJhbWVMZW4sICAgICAgICAgICAmVG1wTGVuLAoJCQkJCQkJCSAgOSwgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFJhbGlua0llLAoJCQkJCQkJCSAgRU5EX09GX0FSR1MpOwoJCQkJRnJhbWVMZW4gKz0gVG1wTGVuOwoJCQl9CgkJCWVsc2UgaWYgKHBBZC0+TWxtZUF1eC5BUFJhbGlua0llICYgMHgwMDAwMDAwMSkKCQkJewoJCQkJVUxPTkcgVG1wTGVuOwoJCQkJVUNIQVIgUmFsaW5rSWVbOV0gPSB7SUVfVkVORE9SX1NQRUNJRklDLCA3LCAweDAwLCAweDBjLCAweDQzLCAweDAxLCAweDAwLCAweDAwLCAweDAwfTsKCQkJCU1ha2VPdXRnb2luZ0ZyYW1lKHBPdXRCdWZmZXIrRnJhbWVMZW4sICAgICAgICAgICAmVG1wTGVuLAoJCQkJCQkJCSAgOSwgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFJhbGlua0llLAoJCQkJCQkJCSAgRU5EX09GX0FSR1MpOwoJCQkJRnJhbWVMZW4gKz0gVG1wTGVuOwoJCQl9CgkJfQoJCWVsc2UKCQl7CgkJCVVMT05HIFRtcExlbjsKCQkJVUNIQVIgUmFsaW5rSWVbOV0gPSB7SUVfVkVORE9SX1NQRUNJRklDLCA3LCAweDAwLCAweDBjLCAweDQzLCAweDA0LCAweDAwLCAweDAwLCAweDAwfTsKCQkJTWFrZU91dGdvaW5nRnJhbWUocE91dEJ1ZmZlcitGcmFtZUxlbiwJCSAmVG1wTGVuLAoJCQkJCQkJICA5LAkJCQkJCSBSYWxpbmtJZSwKCQkJCQkJCSAgRU5EX09GX0FSR1MpOwoJCQlGcmFtZUxlbiArPSBUbXBMZW47CgkJfQoKCQkvLyBBZGQgQ0NYIHYyIHJlcXVlc3QgaWYgQ0NYMiBhZG1pbiBzdGF0ZSBpcyBvbgoJCWlmIChwQWQtPlN0YUNmZy5DQ1hDb250cm9sLmZpZWxkLkVuYWJsZSA9PSAxKQoJCXsKCQkJLy8KCQkJLy8gQWRkIENDWCBWZXJzaW9uCgkJCS8vCgkJCU1ha2VPdXRnb2luZ0ZyYW1lKHBPdXRCdWZmZXIgKyBGcmFtZUxlbiwgJnRtcCwKCQkJCQkJMSwJCQkJCQkJJkNjeDJJZSwKCQkJCQkJMSwJCQkJCQkJJkNjeDJMZW4sCgkJCQkJCUNjeDJMZW4sCQkJCSAgICBDY3gySWVJbmZvLAoJCQkJCQlFTkRfT0ZfQVJHUyk7CgkJCUZyYW1lTGVuICs9IHRtcDsKCQl9CgoJCU1pbmlwb3J0TU1SZXF1ZXN0KHBBZCwgMCwgcE91dEJ1ZmZlciwgRnJhbWVMZW4pOwoJCU1sbWVGcmVlTWVtb3J5KHBBZCwgcE91dEJ1ZmZlcik7CgoJCVJUTVBTZXRUaW1lcigmcEFkLT5NbG1lQXV4LlJlYXNzb2NUaW1lciwgVGltZW91dCk7IC8qIGluIG1TZWMgKi8KCQlwQWQtPk1sbWUuQXNzb2NNYWNoaW5lLkN1cnJTdGF0ZSA9IFJFQVNTT0NfV0FJVF9SU1A7Cgl9CgllbHNlCgl7CgkJREJHUFJJTlQoUlRfREVCVUdfVFJBQ0UsKCJBU1NPQyAtIE1sbWVSZWFzc29jUmVxQWN0aW9uKCkgc2FuaXR5IGNoZWNrIGZhaWxlZC4gQlVHISEhISBcbiIpKTsKCQlwQWQtPk1sbWUuQXNzb2NNYWNoaW5lLkN1cnJTdGF0ZSA9IEFTU09DX0lETEU7CgkJU3RhdHVzID0gTUxNRV9JTlZBTElEX0ZPUk1BVDsKCQlNbG1lRW5xdWV1ZShwQWQsIE1MTUVfQ05UTF9TVEFURV9NQUNISU5FLCBNVDJfUkVBU1NPQ19DT05GLCAyLCAmU3RhdHVzKTsKCX0KfQoKLyoKCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CglEZXNjcmlwdGlvbjoKCQlVcHBlciBsYXllciBpc3N1ZXMgZGlzYXNzb2MgcmVxdWVzdAoJUGFyYW1ldGVyczoKCQlFbGVtIC0KCglJUlFMID0gUEFTU0lWRV9MRVZFTAoKCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAqLwpWT0lEIE1sbWVEaXNhc3NvY1JlcUFjdGlvbigKCUlOIFBSVE1QX0FEQVBURVIgcEFkLAoJSU4gTUxNRV9RVUVVRV9FTEVNICpFbGVtKQp7CglQTUxNRV9ESVNBU1NPQ19SRVFfU1RSVUNUIHBEaXNhc3NvY1JlcTsKCUhFQURFUl84MDJfMTEgICAgICAgICBEaXNhc3NvY0hkcjsKCVBIRUFERVJfODAyXzExICAgICAgICBwRGlzYXNzb2NIZHI7CglQVUNIQVIgICAgICAgICAgICAgICAgcE91dEJ1ZmZlciA9IE5VTEw7CglVTE9ORyAgICAgICAgICAgICAgICAgRnJhbWVMZW4gPSAwOwoJTkRJU19TVEFUVVMgICAgICAgICAgIE5TdGF0dXM7CglCT09MRUFOICAgICAgICAgICAgICAgVGltZXJDYW5jZWxsZWQ7CglVTE9ORyAgICAgICAgICAgICAgICAgVGltZW91dCA9IDA7CglVU0hPUlQgICAgICAgICAgICAgICAgU3RhdHVzOwoKCS8vIHNraXAgc2FuaXR5IGNoZWNrCglwRGlzYXNzb2NSZXEgPSAoUE1MTUVfRElTQVNTT0NfUkVRX1NUUlVDVCkoRWxlbS0+TXNnKTsKCglOU3RhdHVzID0gTWxtZUFsbG9jYXRlTWVtb3J5KHBBZCwgJnBPdXRCdWZmZXIpOyAgLy9HZXQgYW4gdW51c2VkIG5vbnBhZ2VkIG1lbW9yeQoJaWYgKE5TdGF0dXMgIT0gTkRJU19TVEFUVVNfU1VDQ0VTUykKCXsKCQlEQkdQUklOVChSVF9ERUJVR19UUkFDRSwgKCJBU1NPQyAtIE1sbWVEaXNhc3NvY1JlcUFjdGlvbigpIGFsbG9jYXRlIG1lbW9yeSBmYWlsZWRcbiIpKTsKCQlwQWQtPk1sbWUuQXNzb2NNYWNoaW5lLkN1cnJTdGF0ZSA9IEFTU09DX0lETEU7CgkJU3RhdHVzID0gTUxNRV9GQUlMX05PX1JFU09VUkNFOwoJCU1sbWVFbnF1ZXVlKHBBZCwgTUxNRV9DTlRMX1NUQVRFX01BQ0hJTkUsIE1UMl9ESVNBU1NPQ19DT05GLCAyLCAmU3RhdHVzKTsKCQlyZXR1cm47Cgl9CgoKCglSVE1QQ2FuY2VsVGltZXIoJnBBZC0+TWxtZUF1eC5EaXNhc3NvY1RpbWVyLCAmVGltZXJDYW5jZWxsZWQpOwoKCURCR1BSSU5UKFJUX0RFQlVHX1RSQUNFLCAoIkFTU09DIC0gU2VuZCBESVNBU1NPQyByZXF1ZXN0W0JTU0lEOjolMDJ4OiUwMng6JTAyeDolMDJ4OiUwMng6JTAyeCAoUmVhc29uPSVkKVxuIiwKCQkJCXBEaXNhc3NvY1JlcS0+QWRkclswXSwgcERpc2Fzc29jUmVxLT5BZGRyWzFdLCBwRGlzYXNzb2NSZXEtPkFkZHJbMl0sCgkJCQlwRGlzYXNzb2NSZXEtPkFkZHJbM10sIHBEaXNhc3NvY1JlcS0+QWRkcls0XSwgcERpc2Fzc29jUmVxLT5BZGRyWzVdLCBwRGlzYXNzb2NSZXEtPlJlYXNvbikpOwoJTWd0TWFjSGVhZGVySW5pdChwQWQsICZEaXNhc3NvY0hkciwgU1VCVFlQRV9ESVNBU1NPQywgMCwgcERpc2Fzc29jUmVxLT5BZGRyLCBwRGlzYXNzb2NSZXEtPkFkZHIpOwkvLyBwYXRjaCBwZWFwIHR0bHMgc3dpdGNoaW5nIGlzc3VlCglNYWtlT3V0Z29pbmdGcmFtZShwT3V0QnVmZmVyLCAgICAgICAgICAgJkZyYW1lTGVuLAoJCQkJCSAgc2l6ZW9mKEhFQURFUl84MDJfMTEpLCZEaXNhc3NvY0hkciwKCQkJCQkgIDIsICAgICAgICAgICAgICAgICAgICAmcERpc2Fzc29jUmVxLT5SZWFzb24sCgkJCQkJICBFTkRfT0ZfQVJHUyk7CglNaW5pcG9ydE1NUmVxdWVzdChwQWQsIDAsIHBPdXRCdWZmZXIsIEZyYW1lTGVuKTsKCgkvLyBUbyBwYXRjaCBJbnN0YW5jZSBhbmQgQnVmZmFsbyhOKSBBUAoJLy8gRHJpdmVyIGhhcyB0byBzZW5kIGRlYXV0aCB0byBJbnN0YW5jZSBBUCwgYnV0IEJ1ZmZhbG8oTikgbmVlZHMgdG8gc2VuZCBkaXNhc3NvYyB0byByZXNldCBBdXRoZW50aWNhdG9yJ3Mgc3RhdGUgbWFjaGluZQoJLy8gVGhlcmVmb3JlLCB3ZSBzZW5kIGJvdGggb2YgdGhlbS4KCXBEaXNhc3NvY0hkciA9IChQSEVBREVSXzgwMl8xMSlwT3V0QnVmZmVyOwoJcERpc2Fzc29jSGRyLT5GQy5TdWJUeXBlID0gU1VCVFlQRV9ERUFVVEg7CglNaW5pcG9ydE1NUmVxdWVzdChwQWQsIDAsIHBPdXRCdWZmZXIsIEZyYW1lTGVuKTsKCglNbG1lRnJlZU1lbW9yeShwQWQsIHBPdXRCdWZmZXIpOwoKCXBBZC0+U3RhQ2ZnLkRpc2Fzc29jUmVhc29uID0gUkVBU09OX0RJU0FTU09DX1NUQV9MRUFWSU5HOwoJQ09QWV9NQUNfQUREUihwQWQtPlN0YUNmZy5EaXNhc3NvY1N0YSwgcERpc2Fzc29jUmVxLT5BZGRyKTsKCglSVE1QU2V0VGltZXIoJnBBZC0+TWxtZUF1eC5EaXNhc3NvY1RpbWVyLCBUaW1lb3V0KTsgLyogaW4gbVNlYyAqLwoJcEFkLT5NbG1lLkFzc29jTWFjaGluZS5DdXJyU3RhdGUgPSBESVNBU1NPQ19XQUlUX1JTUDsKCiAgICB7CiAgICAgICAgdW5pb24gaXdyZXFfZGF0YSAgICB3cnF1OwogICAgICAgIG1lbXNldCh3cnF1LmFwX2FkZHIuc2FfZGF0YSwgMCwgTUFDX0FERFJfTEVOKTsKICAgICAgICB3aXJlbGVzc19zZW5kX2V2ZW50KHBBZC0+bmV0X2RldiwgU0lPQ0dJV0FQLCAmd3JxdSwgTlVMTCk7CiAgICB9Cn0KCi8qCgk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQoJRGVzY3JpcHRpb246CgkJcGVlciBzZW5kcyBhc3NvYyByc3AgYmFjawoJUGFyYW1ldGVyczoKCQlFbG1lIC0gTUxNRSBtZXNzYWdlIGNvbnRhaW5pbmcgdGhlIHJlY2VpdmVkIGZyYW1lCgoJSVJRTCA9IERJU1BBVENIX0xFVkVMCgoJPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KICovClZPSUQgUGVlckFzc29jUnNwQWN0aW9uKAoJSU4gUFJUTVBfQURBUFRFUiBwQWQsCglJTiBNTE1FX1FVRVVFX0VMRU0gKkVsZW0pCnsKCVVTSE9SVCAgICAgICAgQ2FwYWJpbGl0eUluZm8sIFN0YXR1cywgQWlkOwoJVUNIQVIgICAgICAgICBTdXBSYXRlW01BWF9MRU5fT0ZfU1VQUE9SVEVEX1JBVEVTXSwgU3VwUmF0ZUxlbjsKCVVDSEFSICAgICAgICAgRXh0UmF0ZVtNQVhfTEVOX09GX1NVUFBPUlRFRF9SQVRFU10sIEV4dFJhdGVMZW47CglVQ0hBUiAgICAgICAgIEFkZHIyW01BQ19BRERSX0xFTl07CglCT09MRUFOICAgICAgIFRpbWVyQ2FuY2VsbGVkOwoJVUNIQVIgICAgICAgICBDa2lwRmxhZzsKCUVEQ0FfUEFSTSAgICAgRWRjYVBhcm07CglIVF9DQVBBQklMSVRZX0lFCQlIdENhcGFiaWxpdHk7CglBRERfSFRfSU5GT19JRQkJQWRkSHRJbmZvOwkvLyBBUCBtaWdodCB1c2UgdGhpcyBhZGRpdGlvbmFsIGh0IGluZm8gSUUKCVVDSEFSCQkJSHRDYXBhYmlsaXR5TGVuOwoJVUNIQVIJCQlBZGRIdEluZm9MZW47CglVQ0hBUgkJCU5ld0V4dENoYW5uZWxPZmZzZXQgPSAweGZmOwoKCWlmIChQZWVyQXNzb2NSc3BTYW5pdHkocEFkLCBFbGVtLT5Nc2csIEVsZW0tPk1zZ0xlbiwgQWRkcjIsICZDYXBhYmlsaXR5SW5mbywgJlN0YXR1cywgJkFpZCwgU3VwUmF0ZSwgJlN1cFJhdGVMZW4sIEV4dFJhdGUsICZFeHRSYXRlTGVuLAoJCSZIdENhcGFiaWxpdHksJkFkZEh0SW5mbywgJkh0Q2FwYWJpbGl0eUxlbiwmQWRkSHRJbmZvTGVuLCZOZXdFeHRDaGFubmVsT2Zmc2V0LCAmRWRjYVBhcm0sICZDa2lwRmxhZykpCgl7CgkJLy8gVGhlIGZyYW1lIGlzIGZvciBtZSA/CgkJaWYoTUFDX0FERFJfRVFVQUwoQWRkcjIsIHBBZC0+TWxtZUF1eC5Cc3NpZCkpCgkJewoJCQlEQkdQUklOVChSVF9ERUJVR19UUkFDRSwgKCJQZWVyQXNzb2NSc3BBY3Rpb24oKTpBU1NPQyAtIHJlY2VpdmUgQVNTT0NfUlNQIHRvIG1lIChzdGF0dXM9JWQpXG4iLCBTdGF0dXMpKTsKCQkJREJHUFJJTlQoUlRfREVCVUdfVFJBQ0UsICgiUGVlckFzc29jUnNwQWN0aW9uKCk6TWFjVGFibGUgWyVkXS5BTXNkdVNpemUgPSAlZC4gQ2xpZW50U3RhdHVzRmxhZ3MgPSAweCVseCBcbiIsRWxlbS0+V2NpZCwgcEFkLT5NYWNUYWIuQ29udGVudFtCU1NJRF9XQ0lEXS5BTXNkdVNpemUsIHBBZC0+TWFjVGFiLkNvbnRlbnRbQlNTSURfV0NJRF0uQ2xpZW50U3RhdHVzRmxhZ3MpKTsKCQkJUlRNUENhbmNlbFRpbWVyKCZwQWQtPk1sbWVBdXguQXNzb2NUaW1lciwgJlRpbWVyQ2FuY2VsbGVkKTsKCQkJaWYoU3RhdHVzID09IE1MTUVfU1VDQ0VTUykKCQkJewojaWZkZWYgUlQyODYwCgkJCQkvLyBnbyB0byBwcm9jZWR1cmUgbGlzdGVkIG9uIHBhZ2UgMzc2CgkJCQlBc3NvY1Bvc3RQcm9jKHBBZCwgQWRkcjIsIENhcGFiaWxpdHlJbmZvLCBBaWQsIFN1cFJhdGUsIFN1cFJhdGVMZW4sIEV4dFJhdGUsIEV4dFJhdGVMZW4sCgkJCQkJJkVkY2FQYXJtLCAmSHRDYXBhYmlsaXR5LCBIdENhcGFiaWxpdHlMZW4sICZBZGRIdEluZm8pOwoKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICB1bmlvbiBpd3JlcV9kYXRhICAgIHdycXU7CiAgICAgICAgICAgICAgICAgICAgd2V4dF9ub3RpZnlfZXZlbnRfYXNzb2MocEFkKTsKCiAgICAgICAgICAgICAgICAgICAgbWVtc2V0KHdycXUuYXBfYWRkci5zYV9kYXRhLCAwLCBNQUNfQUREUl9MRU4pOwogICAgICAgICAgICAgICAgICAgIG1lbWNweSh3cnF1LmFwX2FkZHIuc2FfZGF0YSwgcEFkLT5NbG1lQXV4LkJzc2lkLCBNQUNfQUREUl9MRU4pOwogICAgICAgICAgICAgICAgICAgIHdpcmVsZXNzX3NlbmRfZXZlbnQocEFkLT5uZXRfZGV2LCBTSU9DR0lXQVAsICZ3cnF1LCBOVUxMKTsKCiAgICAgICAgICAgICAgICB9CiNlbmRpZgojaWZkZWYgUlQyODcwCgkJCQlVQ0hBUgkJCU1heFN1cHBvcnRlZFJhdGVJbjUwMEticHMgPSAwOwoJCQkJVUNIQVIJCQlpZHg7CgoJCQkJLy8gc3VwcG9ydGVkIHJhdGVzIGFycmF5IG1heSBub3QgYmUgc29ydGVkLiBzb3J0IGl0IGFuZCBmaW5kIHRoZSBtYXhpbXVtIHJhdGUKCQkJICAgIGZvciAoaWR4PTA7IGlkeDxTdXBSYXRlTGVuOyBpZHgrKykKICAgICAgICAgICAgICAgIHsKCQkJICAgICAgICBpZiAoTWF4U3VwcG9ydGVkUmF0ZUluNTAwS2JwcyA8IChTdXBSYXRlW2lkeF0gJiAweDdmKSkKCQkJICAgICAgICAgICAgTWF4U3VwcG9ydGVkUmF0ZUluNTAwS2JwcyA9IFN1cFJhdGVbaWR4XSAmIDB4N2Y7CgkJCSAgICB9CgoJCQkJZm9yIChpZHg9MDsgaWR4PEV4dFJhdGVMZW47IGlkeCsrKQoJCQkgICAgewoJCQkgICAgICAgIGlmIChNYXhTdXBwb3J0ZWRSYXRlSW41MDBLYnBzIDwgKEV4dFJhdGVbaWR4XSAmIDB4N2YpKQoJCQkgICAgICAgICAgICBNYXhTdXBwb3J0ZWRSYXRlSW41MDBLYnBzID0gRXh0UmF0ZVtpZHhdICYgMHg3ZjsKICAgICAgICAgICAgICAgIH0KCQkJCS8vIGdvIHRvIHByb2NlZHVyZSBsaXN0ZWQgb24gcGFnZSAzNzYKCQkJCUFzc29jUG9zdFByb2MocEFkLCBBZGRyMiwgQ2FwYWJpbGl0eUluZm8sIEFpZCwgU3VwUmF0ZSwgU3VwUmF0ZUxlbiwgRXh0UmF0ZSwgRXh0UmF0ZUxlbiwKCQkJCQkmRWRjYVBhcm0sICZIdENhcGFiaWxpdHksIEh0Q2FwYWJpbGl0eUxlbiwgJkFkZEh0SW5mbyk7CgoJCQkJU3RhQWRkTWFjVGFibGVFbnRyeShwQWQsICZwQWQtPk1hY1RhYi5Db250ZW50W0JTU0lEX1dDSURdLCBNYXhTdXBwb3J0ZWRSYXRlSW41MDBLYnBzLCAmSHRDYXBhYmlsaXR5LCBIdENhcGFiaWxpdHlMZW4sIENhcGFiaWxpdHlJbmZvKTsKI2VuZGlmCgkJCQlwQWQtPlN0YUNmZy5Da2lwRmxhZyA9IENraXBGbGFnOwoJCQkJaWYgKENraXBGbGFnICYgMHgxOCkKCQkJCXsKCQkJCQlOZGlzWmVyb01lbW9yeShwQWQtPlN0YUNmZy5UeFNFUSwgNCk7CgkJCQkJTmRpc1plcm9NZW1vcnkocEFkLT5TdGFDZmcuUnhTRVEsIDQpOwoJCQkJCU5kaXNaZXJvTWVtb3J5KHBBZC0+U3RhQ2ZnLkNLSVBNSUMsIDQpOwoJCQkJCXBBZC0+U3RhQ2ZnLkdJVlswXSA9IFJhbmRvbUJ5dGUocEFkKTsKCQkJCQlwQWQtPlN0YUNmZy5HSVZbMV0gPSBSYW5kb21CeXRlKHBBZCk7CgkJCQkJcEFkLT5TdGFDZmcuR0lWWzJdID0gUmFuZG9tQnl0ZShwQWQpOwoJCQkJCXBBZC0+U3RhQ2ZnLmJDa2lwT24gPSBUUlVFOwoJCQkJCURCR1BSSU5UKFJUX0RFQlVHX1RSQUNFLCAoIjxDQ1g+IHBBZC0+U3RhQ2ZnLkNraXBGbGFnID0gMHglMDJ4XG4iLCBwQWQtPlN0YUNmZy5Da2lwRmxhZykpOwoJCQkJfQoJCQl9CgkJCWVsc2UKCQkJewoJCQl9CgkJCXBBZC0+TWxtZS5Bc3NvY01hY2hpbmUuQ3VyclN0YXRlID0gQVNTT0NfSURMRTsKCQkJTWxtZUVucXVldWUocEFkLCBNTE1FX0NOVExfU1RBVEVfTUFDSElORSwgTVQyX0FTU09DX0NPTkYsIDIsICZTdGF0dXMpOwoJCX0KCX0KCWVsc2UKCXsKCQlEQkdQUklOVChSVF9ERUJVR19UUkFDRSwgKCJBU1NPQyAtIFBlZXJBc3NvY1JzcEFjdGlvbigpIHNhbml0eSBjaGVjayBmYWlsXG4iKSk7Cgl9Cn0KCi8qCgk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQoJRGVzY3JpcHRpb246CgkJcGVlciBzZW5kcyByZWFzc29jIHJzcAoJUGFyYW1ldHJzOgoJCUVsZW0gLSBNTE1FIG1lc3NhZ2UgY250YWluaW5nIHRoZSByZWNlaXZlZCBmcmFtZQoKCUlSUUwgPSBESVNQQVRDSF9MRVZFTAoKCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAqLwpWT0lEIFBlZXJSZWFzc29jUnNwQWN0aW9uKAoJSU4gUFJUTVBfQURBUFRFUiBwQWQsCglJTiBNTE1FX1FVRVVFX0VMRU0gKkVsZW0pCnsKCVVTSE9SVCAgICAgIENhcGFiaWxpdHlJbmZvOwoJVVNIT1JUICAgICAgU3RhdHVzOwoJVVNIT1JUICAgICAgQWlkOwoJVUNIQVIgICAgICAgU3VwUmF0ZVtNQVhfTEVOX09GX1NVUFBPUlRFRF9SQVRFU10sIFN1cFJhdGVMZW47CglVQ0hBUiAgICAgICBFeHRSYXRlW01BWF9MRU5fT0ZfU1VQUE9SVEVEX1JBVEVTXSwgRXh0UmF0ZUxlbjsKCVVDSEFSICAgICAgIEFkZHIyW01BQ19BRERSX0xFTl07CglVQ0hBUiAgICAgICBDa2lwRmxhZzsKCUJPT0xFQU4gICAgIFRpbWVyQ2FuY2VsbGVkOwoJRURDQV9QQVJNICAgRWRjYVBhcm07CglIVF9DQVBBQklMSVRZX0lFCQlIdENhcGFiaWxpdHk7CglBRERfSFRfSU5GT19JRQkJQWRkSHRJbmZvOwkvLyBBUCBtaWdodCB1c2UgdGhpcyBhZGRpdGlvbmFsIGh0IGluZm8gSUUKCVVDSEFSCQkJSHRDYXBhYmlsaXR5TGVuOwoJVUNIQVIJCQlBZGRIdEluZm9MZW47CglVQ0hBUgkJCU5ld0V4dENoYW5uZWxPZmZzZXQgPSAweGZmOwoKCWlmKFBlZXJBc3NvY1JzcFNhbml0eShwQWQsIEVsZW0tPk1zZywgRWxlbS0+TXNnTGVuLCBBZGRyMiwgJkNhcGFiaWxpdHlJbmZvLCAmU3RhdHVzLCAmQWlkLCBTdXBSYXRlLCAmU3VwUmF0ZUxlbiwgRXh0UmF0ZSwgJkV4dFJhdGVMZW4sCgkJCQkJCQkJJkh0Q2FwYWJpbGl0eSwJJkFkZEh0SW5mbywgJkh0Q2FwYWJpbGl0eUxlbiwgJkFkZEh0SW5mb0xlbiwmTmV3RXh0Q2hhbm5lbE9mZnNldCwgJkVkY2FQYXJtLCAmQ2tpcEZsYWcpKQoJewoJCWlmKE1BQ19BRERSX0VRVUFMKEFkZHIyLCBwQWQtPk1sbWVBdXguQnNzaWQpKSAvLyBUaGUgZnJhbWUgaXMgZm9yIG1lID8KCQl7CgkJCURCR1BSSU5UKFJUX0RFQlVHX1RSQUNFLCAoIkFTU09DIC0gcmVjZWl2ZSBSRUFTU09DX1JTUCB0byBtZSAoc3RhdHVzPSVkKVxuIiwgU3RhdHVzKSk7CgkJCVJUTVBDYW5jZWxUaW1lcigmcEFkLT5NbG1lQXV4LlJlYXNzb2NUaW1lciwgJlRpbWVyQ2FuY2VsbGVkKTsKCgkJCWlmKFN0YXR1cyA9PSBNTE1FX1NVQ0NFU1MpCgkJCXsKCQkJCS8vIGdvIHRvIHByb2NlZHVyZSBsaXN0ZWQgb24gcGFnZSAzNzYKCQkJCUFzc29jUG9zdFByb2MocEFkLCBBZGRyMiwgQ2FwYWJpbGl0eUluZm8sIEFpZCwgU3VwUmF0ZSwgU3VwUmF0ZUxlbiwgRXh0UmF0ZSwgRXh0UmF0ZUxlbiwKCQkJCQkgJkVkY2FQYXJtLCAmSHRDYXBhYmlsaXR5LCBIdENhcGFiaWxpdHlMZW4sICZBZGRIdEluZm8pOwoKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICB1bmlvbiBpd3JlcV9kYXRhICAgIHdycXU7CiAgICAgICAgICAgICAgICAgICAgd2V4dF9ub3RpZnlfZXZlbnRfYXNzb2MocEFkKTsKCiAgICAgICAgICAgICAgICAgICAgbWVtc2V0KHdycXUuYXBfYWRkci5zYV9kYXRhLCAwLCBNQUNfQUREUl9MRU4pOwogICAgICAgICAgICAgICAgICAgIG1lbWNweSh3cnF1LmFwX2FkZHIuc2FfZGF0YSwgcEFkLT5NbG1lQXV4LkJzc2lkLCBNQUNfQUREUl9MRU4pOwogICAgICAgICAgICAgICAgICAgIHdpcmVsZXNzX3NlbmRfZXZlbnQocEFkLT5uZXRfZGV2LCBTSU9DR0lXQVAsICZ3cnF1LCBOVUxMKTsKCiAgICAgICAgICAgICAgICB9CgoJCQl9CgoJCQl7CgkJCQkvLyBDa2lwRmxhZyBpcyBubyB1c2UgZm9yIHJlYXNzb2NpYXRlCgkJCQlwQWQtPk1sbWUuQXNzb2NNYWNoaW5lLkN1cnJTdGF0ZSA9IEFTU09DX0lETEU7CgkJCQlNbG1lRW5xdWV1ZShwQWQsIE1MTUVfQ05UTF9TVEFURV9NQUNISU5FLCBNVDJfUkVBU1NPQ19DT05GLCAyLCAmU3RhdHVzKTsKCQkJfQoJCX0KCX0KCWVsc2UKCXsKCQlEQkdQUklOVChSVF9ERUJVR19UUkFDRSwgKCJBU1NPQyAtIFBlZXJSZWFzc29jUnNwQWN0aW9uKCkgc2FuaXR5IGNoZWNrIGZhaWxcbiIpKTsKCX0KCn0KCi8qCgk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQoJRGVzY3JpcHRpb246CgkJcHJvY2VkdXJlcyBvbiBJRUVFIDgwMi4xMS8xOTk5IHAuMzc2CglQYXJhbWV0cnM6CgoJSVJRTCA9IERJU1BBVENIX0xFVkVMCgoJPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KICovClZPSUQgQXNzb2NQb3N0UHJvYygKCUlOIFBSVE1QX0FEQVBURVIgcEFkLAoJSU4gUFVDSEFSIHBBZGRyMiwKCUlOIFVTSE9SVCBDYXBhYmlsaXR5SW5mbywKCUlOIFVTSE9SVCBBaWQsCglJTiBVQ0hBUiBTdXBSYXRlW10sCglJTiBVQ0hBUiBTdXBSYXRlTGVuLAoJSU4gVUNIQVIgRXh0UmF0ZVtdLAoJSU4gVUNIQVIgRXh0UmF0ZUxlbiwKCUlOIFBFRENBX1BBUk0gcEVkY2FQYXJtLAoJSU4gSFRfQ0FQQUJJTElUWV9JRQkJKnBIdENhcGFiaWxpdHksCglJTiBVQ0hBUiBIdENhcGFiaWxpdHlMZW4sCglJTiBBRERfSFRfSU5GT19JRQkJKnBBZGRIdEluZm8pCS8vIEFQIG1pZ2h0IHVzZSB0aGlzIGFkZGl0aW9uYWwgaHQgaW5mbyBJRQp7CglVTE9ORyBJZHg7CgoJcEFkLT5NbG1lQXV4LkJzc1R5cGUgPSBCU1NfSU5GUkE7CglDT1BZX01BQ19BRERSKHBBZC0+TWxtZUF1eC5Cc3NpZCwgcEFkZHIyKTsKCXBBZC0+TWxtZUF1eC5BaWQgPSBBaWQ7CglwQWQtPk1sbWVBdXguQ2FwYWJpbGl0eUluZm8gPSBDYXBhYmlsaXR5SW5mbyAmIFNVUFBPUlRFRF9DQVBBQklMSVRZX0lORk87CgoJLy8gU29tZSBIVCBBUCBtaWdodCBsb3N0IFdNTSBJRS4gV2UgYWRkIFdNTSBvdXJzZWx2ZXMuIGJlYWN1YXNlIEhUIHJlcXVpcmVzIFFvUyBvbi4KCWlmICgoSHRDYXBhYmlsaXR5TGVuID4gMCkgJiYgKHBFZGNhUGFybS0+YlZhbGlkID09IEZBTFNFKSkKCXsKCQlwRWRjYVBhcm0tPmJWYWxpZCA9IFRSVUU7CgkJcEVkY2FQYXJtLT5BaWZzblswXSA9IDM7CgkJcEVkY2FQYXJtLT5BaWZzblsxXSA9IDc7CgkJcEVkY2FQYXJtLT5BaWZzblsyXSA9IDI7CgkJcEVkY2FQYXJtLT5BaWZzblszXSA9IDI7CgoJCXBFZGNhUGFybS0+Q3dtaW5bMF0gPSA0OwoJCXBFZGNhUGFybS0+Q3dtaW5bMV0gPSA0OwoJCXBFZGNhUGFybS0+Q3dtaW5bMl0gPSAzOwoJCXBFZGNhUGFybS0+Q3dtaW5bM10gPSAyOwoKCQlwRWRjYVBhcm0tPkN3bWF4WzBdID0gMTA7CgkJcEVkY2FQYXJtLT5Dd21heFsxXSA9IDEwOwoJCXBFZGNhUGFybS0+Q3dtYXhbMl0gPSA0OwoJCXBFZGNhUGFybS0+Q3dtYXhbM10gPSAzOwoKCQlwRWRjYVBhcm0tPlR4b3BbMF0gID0gMDsKCQlwRWRjYVBhcm0tPlR4b3BbMV0gID0gMDsKCQlwRWRjYVBhcm0tPlR4b3BbMl0gID0gOTY7CgkJcEVkY2FQYXJtLT5UeG9wWzNdICA9IDQ4OwoKCX0KCglOZGlzTW92ZU1lbW9yeSgmcEFkLT5NbG1lQXV4LkFQRWRjYVBhcm0sIHBFZGNhUGFybSwgc2l6ZW9mKEVEQ0FfUEFSTSkpOwoKCS8vIGZpbHRlciBvdXQgdW4tc3VwcG9ydGVkIHJhdGVzCglwQWQtPk1sbWVBdXguU3VwUmF0ZUxlbiA9IFN1cFJhdGVMZW47CglOZGlzTW92ZU1lbW9yeShwQWQtPk1sbWVBdXguU3VwUmF0ZSwgU3VwUmF0ZSwgU3VwUmF0ZUxlbik7CglSVE1QQ2hlY2tSYXRlcyhwQWQsIHBBZC0+TWxtZUF1eC5TdXBSYXRlLCAmcEFkLT5NbG1lQXV4LlN1cFJhdGVMZW4pOwoKCS8vIGZpbHRlciBvdXQgdW4tc3VwcG9ydGVkIHJhdGVzCglwQWQtPk1sbWVBdXguRXh0UmF0ZUxlbiA9IEV4dFJhdGVMZW47CglOZGlzTW92ZU1lbW9yeShwQWQtPk1sbWVBdXguRXh0UmF0ZSwgRXh0UmF0ZSwgRXh0UmF0ZUxlbik7CglSVE1QQ2hlY2tSYXRlcyhwQWQsIHBBZC0+TWxtZUF1eC5FeHRSYXRlLCAmcEFkLT5NbG1lQXV4LkV4dFJhdGVMZW4pOwoKCWlmIChIdENhcGFiaWxpdHlMZW4gPiAwKQoJewoJCVJUTVBDaGVja0h0KHBBZCwgQlNTSURfV0NJRCwgcEh0Q2FwYWJpbGl0eSwgcEFkZEh0SW5mbyk7Cgl9CglEQkdQUklOVChSVF9ERUJVR19UUkFDRSwgKCJBc3NvY1Bvc3RQcm9jPT09PiAgQVAuQU1zZHVTaXplID0gJWQuIENsaWVudFN0YXR1c0ZsYWdzID0gMHglbHggXG4iLCBwQWQtPk1hY1RhYi5Db250ZW50W0JTU0lEX1dDSURdLkFNc2R1U2l6ZSwgcEFkLT5NYWNUYWIuQ29udGVudFtCU1NJRF9XQ0lEXS5DbGllbnRTdGF0dXNGbGFncykpOwoKCURCR1BSSU5UKFJUX0RFQlVHX1RSQUNFLCAoIkFzc29jUG9zdFByb2M9PT0+ICAgIChNbXBzPSVkLCBBbXNkdVNpemU9JWQsIClcbiIsCgkJcEFkLT5NYWNUYWIuQ29udGVudFtCU1NJRF9XQ0lEXS5NbXBzTW9kZSwgcEFkLT5NYWNUYWIuQ29udGVudFtCU1NJRF9XQ0lEXS5BTXNkdVNpemUpKTsKCgkvLyBTZXQgTmV3IFdQQSBpbmZvcm1hdGlvbgoJSWR4ID0gQnNzVGFibGVTZWFyY2goJnBBZC0+U2NhblRhYiwgcEFkZHIyLCBwQWQtPk1sbWVBdXguQ2hhbm5lbCk7CglpZiAoSWR4ID09IEJTU19OT1RfRk9VTkQpCgl7CgkJREJHUFJJTlRfRVJSKCgiQVNTT0MgLSBDYW4ndCBmaW5kIEJTUyBhZnRlciByZWNlaXZpbmcgQXNzb2MgcmVzcG9uc2VcbiIpKTsKCX0KCWVsc2UKCXsKCQkvLyBJbml0IHZhcmlhYmxlCgkJcEFkLT5NYWNUYWIuQ29udGVudFtCU1NJRF9XQ0lEXS5SU05JRV9MZW4gPSAwOwoJCU5kaXNaZXJvTWVtb3J5KHBBZC0+TWFjVGFiLkNvbnRlbnRbQlNTSURfV0NJRF0uUlNOX0lFLCBNQVhfTEVOX09GX1JTTklFKTsKCgkJLy8gU3RvcmUgYXBwcm9wcmlhdGUgUlNOX0lFIGZvciBXUEEgU00gbmVnb3RpYXRpb24gbGF0ZXIKCQlpZiAoKHBBZC0+U3RhQ2ZnLkF1dGhNb2RlID49IE5kaXM4MDJfMTFBdXRoTW9kZVdQQSkgJiYgKHBBZC0+U2NhblRhYi5Cc3NFbnRyeVtJZHhdLlZhcklFTGVuICE9IDApKQoJCXsKCQkJUFVDSEFSICAgICAgICAgICAgICBwVklFOwoJCQlVU0hPUlQgICAgICAgICAgICAgIGxlbjsKCQkJUEVJRF9TVFJVQ1QgICAgICAgICBwRWlkOwoKCQkJcFZJRSA9IHBBZC0+U2NhblRhYi5Cc3NFbnRyeVtJZHhdLlZhcklFczsKCQkJbGVuCSA9IHBBZC0+U2NhblRhYi5Cc3NFbnRyeVtJZHhdLlZhcklFTGVuOwoKCQkJd2hpbGUgKGxlbiA+IDApCgkJCXsKCQkJCXBFaWQgPSAoUEVJRF9TVFJVQ1QpIHBWSUU7CgkJCQkvLyBGb3IgV1BBL1dQQVBTSwoJCQkJaWYgKChwRWlkLT5FaWQgPT0gSUVfV1BBKSAmJiAoTmRpc0VxdWFsTWVtb3J5KHBFaWQtPk9jdGV0LCBXUEFfT1VJLCA0KSkKCQkJCQkmJiAocEFkLT5TdGFDZmcuQXV0aE1vZGUgPT0gTmRpczgwMl8xMUF1dGhNb2RlV1BBIHx8IHBBZC0+U3RhQ2ZnLkF1dGhNb2RlID09IE5kaXM4MDJfMTFBdXRoTW9kZVdQQVBTSykpCgkJCQl7CgkJCQkJTmRpc01vdmVNZW1vcnkocEFkLT5NYWNUYWIuQ29udGVudFtCU1NJRF9XQ0lEXS5SU05fSUUsIHBWSUUsIChwRWlkLT5MZW4gKyAyKSk7CgkJCQkJcEFkLT5NYWNUYWIuQ29udGVudFtCU1NJRF9XQ0lEXS5SU05JRV9MZW4gPSAocEVpZC0+TGVuICsgMik7CgkJCQkJREJHUFJJTlQoUlRfREVCVUdfVFJBQ0UsICgiQXNzb2NQb3N0UHJvYz09PT4gU3RvcmUgUlNOX0lFIGZvciBXUEEgU00gbmVnb3RpYXRpb24gXG4iKSk7CgkJCQl9CgkJCQkvLyBGb3IgV1BBMi9XUEEyUFNLCgkJCQllbHNlIGlmICgocEVpZC0+RWlkID09IElFX1JTTikgJiYgKE5kaXNFcXVhbE1lbW9yeShwRWlkLT5PY3RldCArIDIsIFJTTl9PVUksIDMpKQoJCQkJCSYmIChwQWQtPlN0YUNmZy5BdXRoTW9kZSA9PSBOZGlzODAyXzExQXV0aE1vZGVXUEEyIHx8IHBBZC0+U3RhQ2ZnLkF1dGhNb2RlID09IE5kaXM4MDJfMTFBdXRoTW9kZVdQQTJQU0spKQoJCQkJewoJCQkJCU5kaXNNb3ZlTWVtb3J5KHBBZC0+TWFjVGFiLkNvbnRlbnRbQlNTSURfV0NJRF0uUlNOX0lFLCBwVklFLCAocEVpZC0+TGVuICsgMikpOwoJCQkJCXBBZC0+TWFjVGFiLkNvbnRlbnRbQlNTSURfV0NJRF0uUlNOSUVfTGVuID0gKHBFaWQtPkxlbiArIDIpOwoJCQkJCURCR1BSSU5UKFJUX0RFQlVHX1RSQUNFLCAoIkFzc29jUG9zdFByb2M9PT0+IFN0b3JlIFJTTl9JRSBmb3IgV1BBMiBTTSBuZWdvdGlhdGlvbiBcbiIpKTsKCQkJCX0KCgkJCQlwVklFICs9IChwRWlkLT5MZW4gKyAyKTsKCQkJCWxlbiAgLT0gKHBFaWQtPkxlbiArIDIpOwoJCQl9CgkJfQoKCQlpZiAocEFkLT5NYWNUYWIuQ29udGVudFtCU1NJRF9XQ0lEXS5SU05JRV9MZW4gPT0gMCkKCQl7CgkJCURCR1BSSU5UKFJUX0RFQlVHX1RSQUNFLCAoIkFzc29jUG9zdFByb2M9PT0+IG5vIFJTTl9JRSBcbiIpKTsKCQl9CgkJZWxzZQoJCXsKCQkJaGV4X2R1bXAoIlJTTl9JRSIsIHBBZC0+TWFjVGFiLkNvbnRlbnRbQlNTSURfV0NJRF0uUlNOX0lFLCBwQWQtPk1hY1RhYi5Db250ZW50W0JTU0lEX1dDSURdLlJTTklFX0xlbik7CgkJfQoJfQp9CgovKgoJPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KCURlc2NyaXB0aW9uOgoJCWxlZnQgcGFydCBvZiBJRUVFIDgwMi4xMS8xOTk5IHAuMzc0CglQYXJhbWV0ZXJzOgoJCUVsZW0gLSBNTE1FIG1lc3NhZ2UgY29udGFpbmluZyB0aGUgcmVjZWl2ZWQgZnJhbWUKCglJUlFMID0gRElTUEFUQ0hfTEVWRUwKCgk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogKi8KVk9JRCBQZWVyRGlzYXNzb2NBY3Rpb24oCglJTiBQUlRNUF9BREFQVEVSIHBBZCwKCUlOIE1MTUVfUVVFVUVfRUxFTSAqRWxlbSkKewoJVUNIQVIgICAgICAgICBBZGRyMltNQUNfQUREUl9MRU5dOwoJVVNIT1JUICAgICAgICBSZWFzb247CgoJREJHUFJJTlQoUlRfREVCVUdfVFJBQ0UsICgiQVNTT0MgLSBQZWVyRGlzYXNzb2NBY3Rpb24oKVxuIikpOwoJaWYoUGVlckRpc2Fzc29jU2FuaXR5KHBBZCwgRWxlbS0+TXNnLCBFbGVtLT5Nc2dMZW4sIEFkZHIyLCAmUmVhc29uKSkKCXsKCQlEQkdQUklOVChSVF9ERUJVR19UUkFDRSwgKCJBU1NPQyAtIFBlZXJEaXNhc3NvY0FjdGlvbigpIFJlYXNvbiA9ICVkXG4iLCBSZWFzb24pKTsKCQlpZiAoSU5GUkFfT04ocEFkKSAmJiBNQUNfQUREUl9FUVVBTChwQWQtPkNvbW1vbkNmZy5Cc3NpZCwgQWRkcjIpKQoJCXsKCgkJCWlmIChwQWQtPkNvbW1vbkNmZy5iV2lyZWxlc3NFdmVudCkKCQkJewoJCQkJUlRNUFNlbmRXaXJlbGVzc0V2ZW50KHBBZCwgSVdfRElTQVNTT0NfRVZFTlRfRkxBRywgcEFkLT5NYWNUYWIuQ29udGVudFtCU1NJRF9XQ0lEXS5BZGRyLCBCU1MwLCAwKTsKCQkJfQoKCQkJLy8KCQkJLy8gR2V0IEN1cnJlbnQgU3lzdGVtIHRpbWUgYW5kIFR1cm4gb24gQWRqYWNlbnRBUFJlcG9ydAoJCQkvLwoJCQlOZGlzR2V0U3lzdGVtVXBUaW1lKCZwQWQtPlN0YUNmZy5DQ1hBZGphY2VudEFQTGlua0Rvd25UaW1lKTsKCQkJcEFkLT5TdGFDZmcuQ0NYQWRqYWNlbnRBUFJlcG9ydEZsYWcgPSBUUlVFOwoJCQlMaW5rRG93bihwQWQsIFRSVUUpOwoJCQlwQWQtPk1sbWUuQXNzb2NNYWNoaW5lLkN1cnJTdGF0ZSA9IEFTU09DX0lETEU7CgogICAgICAgICAgICB7CiAgICAgICAgICAgICAgICB1bmlvbiBpd3JlcV9kYXRhICAgIHdycXU7CiAgICAgICAgICAgICAgICBtZW1zZXQod3JxdS5hcF9hZGRyLnNhX2RhdGEsIDAsIE1BQ19BRERSX0xFTik7CiAgICAgICAgICAgICAgICB3aXJlbGVzc19zZW5kX2V2ZW50KHBBZC0+bmV0X2RldiwgU0lPQ0dJV0FQLCAmd3JxdSwgTlVMTCk7CiAgICAgICAgICAgIH0KCQl9Cgl9CgllbHNlCgl7CgkJREJHUFJJTlQoUlRfREVCVUdfVFJBQ0UsICgiQVNTT0MgLSBQZWVyRGlzYXNzb2NBY3Rpb24oKSBzYW5pdHkgY2hlY2sgZmFpbFxuIikpOwoJfQoKfQoKLyoKCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CglEZXNjcmlwdGlvbjoKCQl3aGF0IHRoZSBzdGF0ZSBtYWNoaW5lIHdpbGwgZG8gYWZ0ZXIgYXNzb2MgdGltZW91dAoJUGFyYW1ldGVyczoKCQlFbG1lIC0KCglJUlFMID0gRElTUEFUQ0hfTEVWRUwKCgk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogKi8KVk9JRCBBc3NvY1RpbWVvdXRBY3Rpb24oCglJTiBQUlRNUF9BREFQVEVSIHBBZCwKCUlOIE1MTUVfUVVFVUVfRUxFTSAqRWxlbSkKewoJVVNIT1JUICBTdGF0dXM7CglEQkdQUklOVChSVF9ERUJVR19UUkFDRSwgKCJBU1NPQyAtIEFzc29jVGltZW91dEFjdGlvblxuIikpOwoJcEFkLT5NbG1lLkFzc29jTWFjaGluZS5DdXJyU3RhdGUgPSBBU1NPQ19JRExFOwoJU3RhdHVzID0gTUxNRV9SRUpfVElNRU9VVDsKCU1sbWVFbnF1ZXVlKHBBZCwgTUxNRV9DTlRMX1NUQVRFX01BQ0hJTkUsIE1UMl9BU1NPQ19DT05GLCAyLCAmU3RhdHVzKTsKfQoKLyoKCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CglEZXNjcmlwdGlvbjoKCQl3aGF0IHRoZSBzdGF0ZSBtYWNoaW5lIHdpbGwgZG8gYWZ0ZXIgcmVhc3NvYyB0aW1lb3V0CgoJSVJRTCA9IERJU1BBVENIX0xFVkVMCgoJPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KICovClZPSUQgUmVhc3NvY1RpbWVvdXRBY3Rpb24oCglJTiBQUlRNUF9BREFQVEVSIHBBZCwKCUlOIE1MTUVfUVVFVUVfRUxFTSAqRWxlbSkKewoJVVNIT1JUICBTdGF0dXM7CglEQkdQUklOVChSVF9ERUJVR19UUkFDRSwgKCJBU1NPQyAtIFJlYXNzb2NUaW1lb3V0QWN0aW9uXG4iKSk7CglwQWQtPk1sbWUuQXNzb2NNYWNoaW5lLkN1cnJTdGF0ZSA9IEFTU09DX0lETEU7CglTdGF0dXMgPSBNTE1FX1JFSl9USU1FT1VUOwoJTWxtZUVucXVldWUocEFkLCBNTE1FX0NOVExfU1RBVEVfTUFDSElORSwgTVQyX1JFQVNTT0NfQ09ORiwgMiwgJlN0YXR1cyk7Cn0KCi8qCgk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQoJRGVzY3JpcHRpb246CgkJd2hhdCB0aGUgc3RhdGUgbWFjaGluZSB3aWxsIGRvIGFmdGVyIGRpc2Fzc29jIHRpbWVvdXQKCglJUlFMID0gRElTUEFUQ0hfTEVWRUwKCgk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogKi8KVk9JRCBEaXNhc3NvY1RpbWVvdXRBY3Rpb24oCglJTiBQUlRNUF9BREFQVEVSIHBBZCwKCUlOIE1MTUVfUVVFVUVfRUxFTSAqRWxlbSkKewoJVVNIT1JUICBTdGF0dXM7CglEQkdQUklOVChSVF9ERUJVR19UUkFDRSwgKCJBU1NPQyAtIERpc2Fzc29jVGltZW91dEFjdGlvblxuIikpOwoJcEFkLT5NbG1lLkFzc29jTWFjaGluZS5DdXJyU3RhdGUgPSBBU1NPQ19JRExFOwoJU3RhdHVzID0gTUxNRV9TVUNDRVNTOwoJTWxtZUVucXVldWUocEFkLCBNTE1FX0NOVExfU1RBVEVfTUFDSElORSwgTVQyX0RJU0FTU09DX0NPTkYsIDIsICZTdGF0dXMpOwp9CgpWT0lEIEludmFsaWRTdGF0ZVdoZW5Bc3NvYygKCUlOIFBSVE1QX0FEQVBURVIgcEFkLAoJSU4gTUxNRV9RVUVVRV9FTEVNICpFbGVtKQp7CglVU0hPUlQgIFN0YXR1czsKCURCR1BSSU5UKFJUX0RFQlVHX1RSQUNFLCAoIkFTU09DIC0gSW52YWxpZFN0YXRlV2hlbkFzc29jKHN0YXRlPSVsZCksIHJlc2V0IEFTU09DIHN0YXRlIG1hY2hpbmVcbiIsCgkJcEFkLT5NbG1lLkFzc29jTWFjaGluZS5DdXJyU3RhdGUpKTsKCXBBZC0+TWxtZS5Bc3NvY01hY2hpbmUuQ3VyclN0YXRlID0gQVNTT0NfSURMRTsKCVN0YXR1cyA9IE1MTUVfU1RBVEVfTUFDSElORV9SRUpFQ1Q7CglNbG1lRW5xdWV1ZShwQWQsIE1MTUVfQ05UTF9TVEFURV9NQUNISU5FLCBNVDJfQVNTT0NfQ09ORiwgMiwgJlN0YXR1cyk7Cn0KClZPSUQgSW52YWxpZFN0YXRlV2hlblJlYXNzb2MoCglJTiBQUlRNUF9BREFQVEVSIHBBZCwKCUlOIE1MTUVfUVVFVUVfRUxFTSAqRWxlbSkKewoJVVNIT1JUIFN0YXR1czsKCURCR1BSSU5UKFJUX0RFQlVHX1RSQUNFLCAoIkFTU09DIC0gSW52YWxpZFN0YXRlV2hlblJlYXNzb2Moc3RhdGU9JWxkKSwgcmVzZXQgQVNTT0Mgc3RhdGUgbWFjaGluZVxuIiwKCQlwQWQtPk1sbWUuQXNzb2NNYWNoaW5lLkN1cnJTdGF0ZSkpOwoJcEFkLT5NbG1lLkFzc29jTWFjaGluZS5DdXJyU3RhdGUgPSBBU1NPQ19JRExFOwoJU3RhdHVzID0gTUxNRV9TVEFURV9NQUNISU5FX1JFSkVDVDsKCU1sbWVFbnF1ZXVlKHBBZCwgTUxNRV9DTlRMX1NUQVRFX01BQ0hJTkUsIE1UMl9SRUFTU09DX0NPTkYsIDIsICZTdGF0dXMpOwp9CgpWT0lEIEludmFsaWRTdGF0ZVdoZW5EaXNhc3NvY2lhdGUoCglJTiBQUlRNUF9BREFQVEVSIHBBZCwKCUlOIE1MTUVfUVVFVUVfRUxFTSAqRWxlbSkKewoJVVNIT1JUIFN0YXR1czsKCURCR1BSSU5UKFJUX0RFQlVHX1RSQUNFLCAoIkFTU09DIC0gSW52YWxpZFN0YXRlV2hlbkRpc2Fzc29jKHN0YXRlPSVsZCksIHJlc2V0IEFTU09DIHN0YXRlIG1hY2hpbmVcbiIsCgkJcEFkLT5NbG1lLkFzc29jTWFjaGluZS5DdXJyU3RhdGUpKTsKCXBBZC0+TWxtZS5Bc3NvY01hY2hpbmUuQ3VyclN0YXRlID0gQVNTT0NfSURMRTsKCVN0YXR1cyA9IE1MTUVfU1RBVEVfTUFDSElORV9SRUpFQ1Q7CglNbG1lRW5xdWV1ZShwQWQsIE1MTUVfQ05UTF9TVEFURV9NQUNISU5FLCBNVDJfRElTQVNTT0NfQ09ORiwgMiwgJlN0YXR1cyk7Cn0KCi8qCgk9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQoJRGVzY3JpcHRpb246CgkJcmlnaHQgcGFydCBvZiBJRUVFIDgwMi4xMS8xOTk5IHBhZ2UgMzc0CglOb3RlOgoJCVRoaXMgZXZlbnQgc2hvdWxkIG5ldmVyIGNhdXNlIEFTU09DIHN0YXRlIG1hY2hpbmUgcGVyZm9ybSBzdGF0ZQoJCXRyYW5zaXRpb24sIGFuZCBoYXMgbm8gcmVsYXRpb25zaGlwIHdpdGggQ05UTCBtYWNoaW5lLiBTbyB3ZSBzZXBhcmF0ZQoJCXRoaXMgcm91dGluZSBhcyBhIHNlcnZpY2Ugb3V0c2lkZSBvZiBBU1NPQyBzdGF0ZSB0cmFuc2l0aW9uIHRhYmxlLgoKCUlSUUwgPSBESVNQQVRDSF9MRVZFTAoKCT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09CiAqLwpWT0lEIENsczNlcnJBY3Rpb24oCglJTiBQUlRNUF9BREFQVEVSIHBBZCwKCUlOIFBVQ0hBUiAgICAgICAgcEFkZHIpCnsKCUhFQURFUl84MDJfMTEgICAgICAgICBEaXNhc3NvY0hkcjsKCVBIRUFERVJfODAyXzExICAgICAgICBwRGlzYXNzb2NIZHI7CglQVUNIQVIgICAgICAgICAgICAgICAgcE91dEJ1ZmZlciA9IE5VTEw7CglVTE9ORyAgICAgICAgICAgICAgICAgRnJhbWVMZW4gPSAwOwoJTkRJU19TVEFUVVMgICAgICAgICAgIE5TdGF0dXM7CglVU0hPUlQgICAgICAgICAgICAgICAgUmVhc29uID0gUkVBU09OX0NMUzNFUlI7CgoJTlN0YXR1cyA9IE1sbWVBbGxvY2F0ZU1lbW9yeShwQWQsICZwT3V0QnVmZmVyKTsgIC8vR2V0IGFuIHVudXNlZCBub25wYWdlZCBtZW1vcnkKCWlmIChOU3RhdHVzICE9IE5ESVNfU1RBVFVTX1NVQ0NFU1MpCgkJcmV0dXJuOwoKCURCR1BSSU5UKFJUX0RFQlVHX1RSQUNFLCAoIkFTU09DIC0gQ2xhc3MgMyBFcnJvciwgU2VuZCBESVNBU1NPQyBmcmFtZVxuIikpOwoJTWd0TWFjSGVhZGVySW5pdChwQWQsICZEaXNhc3NvY0hkciwgU1VCVFlQRV9ESVNBU1NPQywgMCwgcEFkZHIsIHBBZC0+Q29tbW9uQ2ZnLkJzc2lkKTsJLy8gcGF0Y2ggcGVhcCB0dGxzIHN3aXRjaGluZyBpc3N1ZQoJTWFrZU91dGdvaW5nRnJhbWUocE91dEJ1ZmZlciwgICAgICAgICAgICZGcmFtZUxlbiwKCQkJCQkgIHNpemVvZihIRUFERVJfODAyXzExKSwmRGlzYXNzb2NIZHIsCgkJCQkJICAyLCAgICAgICAgICAgICAgICAgICAgJlJlYXNvbiwKCQkJCQkgIEVORF9PRl9BUkdTKTsKCU1pbmlwb3J0TU1SZXF1ZXN0KHBBZCwgMCwgcE91dEJ1ZmZlciwgRnJhbWVMZW4pOwoKCS8vIFRvIHBhdGNoIEluc3RhbmNlIGFuZCBCdWZmYWxvKE4pIEFQCgkvLyBEcml2ZXIgaGFzIHRvIHNlbmQgZGVhdXRoIHRvIEluc3RhbmNlIEFQLCBidXQgQnVmZmFsbyhOKSBuZWVkcyB0byBzZW5kIGRpc2Fzc29jIHRvIHJlc2V0IEF1dGhlbnRpY2F0b3IncyBzdGF0ZSBtYWNoaW5lCgkvLyBUaGVyZWZvcmUsIHdlIHNlbmQgYm90aCBvZiB0aGVtLgoJcERpc2Fzc29jSGRyID0gKFBIRUFERVJfODAyXzExKXBPdXRCdWZmZXI7CglwRGlzYXNzb2NIZHItPkZDLlN1YlR5cGUgPSBTVUJUWVBFX0RFQVVUSDsKCU1pbmlwb3J0TU1SZXF1ZXN0KHBBZCwgMCwgcE91dEJ1ZmZlciwgRnJhbWVMZW4pOwoKCU1sbWVGcmVlTWVtb3J5KHBBZCwgcE91dEJ1ZmZlcik7CgoJcEFkLT5TdGFDZmcuRGlzYXNzb2NSZWFzb24gPSBSRUFTT05fQ0xTM0VSUjsKCUNPUFlfTUFDX0FERFIocEFkLT5TdGFDZmcuRGlzYXNzb2NTdGEsIHBBZGRyKTsKfQoKIC8qCgkgPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KCSBEZXNjcmlwdGlvbjoKCQkgU3dpdGNoIGJldHdlZW4gV0VQIGFuZCBDS0lQIHVwb24gbmV3IGFzc29jaWF0aW9uIHVwLgoJIFBhcmFtZXRlcnM6CgoJIElSUUwgPSBESVNQQVRDSF9MRVZFTAoKCSA9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogICovClZPSUQgU3dpdGNoQmV0d2VlbldlcEFuZENraXAoCglJTiBQUlRNUF9BREFQVEVSIHBBZCkKewoJaW50ICAgICAgICAgICAgaTsKCVNIQVJFREtFWV9NT0RFX1NUUlVDICBjc3IxOwoKCS8vIGlmIEtQIGlzIHJlcXVpcmVkLiBjaGFuZ2UgdGhlIENpcGhlckFsZyBpbiBoYXJkd2FyZSBzaGFyZCBrZXkgdGFibGUgZnJvbSBXRVAKCS8vIHRvIENLSVAuIGVsc2UgcmVtYWluIGFzIFdFUAoJaWYgKHBBZC0+U3RhQ2ZnLmJDa2lwT24gJiYgKHBBZC0+U3RhQ2ZnLkNraXBGbGFnICYgMHgxMCkpCgl7CgkJLy8gbW9kaWZ5IGhhcmR3YXJlIGtleSB0YWJsZSBzbyB0aGF0IE1BQyB1c2UgY29ycmVjdCBhbGdvcml0aG0gdG8gZGVjcnlwdCBSWAoJCVJUTVBfSU9fUkVBRDMyKHBBZCwgU0hBUkVEX0tFWV9NT0RFX0JBU0UsICZjc3IxLndvcmQpOwoJCWlmIChjc3IxLmZpZWxkLkJzczBLZXkwQ2lwaGVyQWxnID09IENJUEhFUl9XRVA2NCkKCQkJY3NyMS5maWVsZC5Cc3MwS2V5MENpcGhlckFsZyA9IENJUEhFUl9DS0lQNjQ7CgkJZWxzZSBpZiAoY3NyMS5maWVsZC5Cc3MwS2V5MENpcGhlckFsZyA9PSBDSVBIRVJfV0VQMTI4KQoJCQljc3IxLmZpZWxkLkJzczBLZXkwQ2lwaGVyQWxnID0gQ0lQSEVSX0NLSVAxMjg7CgoJCWlmIChjc3IxLmZpZWxkLkJzczBLZXkxQ2lwaGVyQWxnID09IENJUEhFUl9XRVA2NCkKCQkJY3NyMS5maWVsZC5Cc3MwS2V5MUNpcGhlckFsZyA9IENJUEhFUl9DS0lQNjQ7CgkJZWxzZSBpZiAoY3NyMS5maWVsZC5Cc3MwS2V5MUNpcGhlckFsZyA9PSBDSVBIRVJfV0VQMTI4KQoJCQljc3IxLmZpZWxkLkJzczBLZXkxQ2lwaGVyQWxnID0gQ0lQSEVSX0NLSVAxMjg7CgoJCWlmIChjc3IxLmZpZWxkLkJzczBLZXkyQ2lwaGVyQWxnID09IENJUEhFUl9XRVA2NCkKCQkJY3NyMS5maWVsZC5Cc3MwS2V5MkNpcGhlckFsZyA9IENJUEhFUl9DS0lQNjQ7CgkJZWxzZSBpZiAoY3NyMS5maWVsZC5Cc3MwS2V5MkNpcGhlckFsZyA9PSBDSVBIRVJfV0VQMTI4KQoJCQljc3IxLmZpZWxkLkJzczBLZXkyQ2lwaGVyQWxnID0gQ0lQSEVSX0NLSVAxMjg7CgoJCWlmIChjc3IxLmZpZWxkLkJzczBLZXkzQ2lwaGVyQWxnID09IENJUEhFUl9XRVA2NCkKCQkJY3NyMS5maWVsZC5Cc3MwS2V5M0NpcGhlckFsZyA9IENJUEhFUl9DS0lQNjQ7CgkJZWxzZSBpZiAoY3NyMS5maWVsZC5Cc3MwS2V5M0NpcGhlckFsZyA9PSBDSVBIRVJfV0VQMTI4KQoJCQljc3IxLmZpZWxkLkJzczBLZXkzQ2lwaGVyQWxnID0gQ0lQSEVSX0NLSVAxMjg7CgkJUlRNUF9JT19XUklURTMyKHBBZCwgU0hBUkVEX0tFWV9NT0RFX0JBU0UsIGNzcjEud29yZCk7CgkJREJHUFJJTlQoUlRfREVCVUdfVFJBQ0UsICgiU3dpdGNoQmV0d2VlbldlcEFuZENraXA6IG1vZGlmeSBCU1MwIGNpcGhlciB0byAlc1xuIiwgQ2lwaGVyTmFtZVtjc3IxLmZpZWxkLkJzczBLZXkwQ2lwaGVyQWxnXSkpOwoKCQkvLyBtb2RpZnkgc29mdHdhcmUga2V5IHRhYmxlIHNvIHRoYXQgZHJpdmVyIGNhbiBzcGVjaWZ5IGNvcnJlY3QgYWxnb3JpdGhtIGluIFRYRCB1cG9uIFRYCgkJZm9yIChpPTA7IGk8U0hBUkVfS0VZX05VTTsgaSsrKQoJCXsKCQkJaWYgKHBBZC0+U2hhcmVkS2V5W0JTUzBdW2ldLkNpcGhlckFsZyA9PSBDSVBIRVJfV0VQNjQpCgkJCQlwQWQtPlNoYXJlZEtleVtCU1MwXVtpXS5DaXBoZXJBbGcgPSBDSVBIRVJfQ0tJUDY0OwoJCQllbHNlIGlmIChwQWQtPlNoYXJlZEtleVtCU1MwXVtpXS5DaXBoZXJBbGcgPT0gQ0lQSEVSX1dFUDEyOCkKCQkJCXBBZC0+U2hhcmVkS2V5W0JTUzBdW2ldLkNpcGhlckFsZyA9IENJUEhFUl9DS0lQMTI4OwoJCX0KCX0KCgkvLyBlbHNlIGlmIEtQIE5PVCBpbnVzZWQuIGNoYW5nZSB0aGUgQ2lwaGVyQWxnIGluIGhhcmR3YXJlIHNoYXJkIGtleSB0YWJsZSBmcm9tIENLSVAKCS8vIHRvIFdFUC4KCWVsc2UKCXsKCQkvLyBtb2RpZnkgaGFyZHdhcmUga2V5IHRhYmxlIHNvIHRoYXQgTUFDIHVzZSBjb3JyZWN0IGFsZ29yaXRobSB0byBkZWNyeXB0IFJYCgkJUlRNUF9JT19SRUFEMzIocEFkLCBTSEFSRURfS0VZX01PREVfQkFTRSwgJmNzcjEud29yZCk7CgkJaWYgKGNzcjEuZmllbGQuQnNzMEtleTBDaXBoZXJBbGcgPT0gQ0lQSEVSX0NLSVA2NCkKCQkJY3NyMS5maWVsZC5Cc3MwS2V5MENpcGhlckFsZyA9IENJUEhFUl9XRVA2NDsKCQllbHNlIGlmIChjc3IxLmZpZWxkLkJzczBLZXkwQ2lwaGVyQWxnID09IENJUEhFUl9DS0lQMTI4KQoJCQljc3IxLmZpZWxkLkJzczBLZXkwQ2lwaGVyQWxnID0gQ0lQSEVSX1dFUDEyODsKCgkJaWYgKGNzcjEuZmllbGQuQnNzMEtleTFDaXBoZXJBbGcgPT0gQ0lQSEVSX0NLSVA2NCkKCQkJY3NyMS5maWVsZC5Cc3MwS2V5MUNpcGhlckFsZyA9IENJUEhFUl9XRVA2NDsKCQllbHNlIGlmIChjc3IxLmZpZWxkLkJzczBLZXkxQ2lwaGVyQWxnID09IENJUEhFUl9DS0lQMTI4KQoJCQljc3IxLmZpZWxkLkJzczBLZXkxQ2lwaGVyQWxnID0gQ0lQSEVSX1dFUDEyODsKCgkJaWYgKGNzcjEuZmllbGQuQnNzMEtleTJDaXBoZXJBbGcgPT0gQ0lQSEVSX0NLSVA2NCkKCQkJY3NyMS5maWVsZC5Cc3MwS2V5MkNpcGhlckFsZyA9IENJUEhFUl9XRVA2NDsKCQllbHNlIGlmIChjc3IxLmZpZWxkLkJzczBLZXkyQ2lwaGVyQWxnID09IENJUEhFUl9DS0lQMTI4KQoJCQljc3IxLmZpZWxkLkJzczBLZXkyQ2lwaGVyQWxnID0gQ0lQSEVSX1dFUDEyODsKCgkJaWYgKGNzcjEuZmllbGQuQnNzMEtleTNDaXBoZXJBbGcgPT0gQ0lQSEVSX0NLSVA2NCkKCQkJY3NyMS5maWVsZC5Cc3MwS2V5M0NpcGhlckFsZyA9IENJUEhFUl9XRVA2NDsKCQllbHNlIGlmIChjc3IxLmZpZWxkLkJzczBLZXkzQ2lwaGVyQWxnID09IENJUEhFUl9DS0lQMTI4KQoJCQljc3IxLmZpZWxkLkJzczBLZXkzQ2lwaGVyQWxnID0gQ0lQSEVSX1dFUDEyODsKCgkJLy8gbW9kaWZ5IHNvZnR3YXJlIGtleSB0YWJsZSBzbyB0aGF0IGRyaXZlciBjYW4gc3BlY2lmeSBjb3JyZWN0IGFsZ29yaXRobSBpbiBUWEQgdXBvbiBUWAoJCWZvciAoaT0wOyBpPFNIQVJFX0tFWV9OVU07IGkrKykKCQl7CgkJCWlmIChwQWQtPlNoYXJlZEtleVtCU1MwXVtpXS5DaXBoZXJBbGcgPT0gQ0lQSEVSX0NLSVA2NCkKCQkJCXBBZC0+U2hhcmVkS2V5W0JTUzBdW2ldLkNpcGhlckFsZyA9IENJUEhFUl9XRVA2NDsKCQkJZWxzZSBpZiAocEFkLT5TaGFyZWRLZXlbQlNTMF1baV0uQ2lwaGVyQWxnID09IENJUEhFUl9DS0lQMTI4KQoJCQkJcEFkLT5TaGFyZWRLZXlbQlNTMF1baV0uQ2lwaGVyQWxnID0gQ0lQSEVSX1dFUDEyODsKCQl9CgoJCS8vCgkJLy8gT24gV1BBLU5PTkUsIG11c3QgdXBkYXRlIENpcGhlckFsZy4KCQkvLyBCZWNhdXNlIHRoZSBPSURfODAyXzExX1dFUF9TVEFUVVMgd2FzIGJlZW4gc2V0IGFmdGVyIE9JRF84MDJfMTFfQUREX0tFWQoJCS8vIGFuZCBDaXBoZXJBbGcgd2lsbCBiZSBDSVBIRVJfTk9ORSBieSBXaW5kb3dzIFplcm9Db25maWcuCgkJLy8gU28gd2UgbmVlZCB0byB1cGRhdGUgQ2lwaGVyQWxnIGFmdGVyIGNvbm5lY3QuCgkJLy8KCQlpZiAocEFkLT5TdGFDZmcuQXV0aE1vZGUgPT0gTmRpczgwMl8xMUF1dGhNb2RlV1BBTm9uZSkKCQl7CgkJCWZvciAoaSA9IDA7IGkgPCBTSEFSRV9LRVlfTlVNOyBpKyspCgkJCXsKCQkJCWlmIChwQWQtPlNoYXJlZEtleVtCU1MwXVtpXS5LZXlMZW4gIT0gMCkKCQkJCXsKCQkJCQlpZiAocEFkLT5TdGFDZmcuV2VwU3RhdHVzID09IE5kaXM4MDJfMTFFbmNyeXB0aW9uMkVuYWJsZWQpCgkJCQkJewoJCQkJCQlwQWQtPlNoYXJlZEtleVtCU1MwXVtpXS5DaXBoZXJBbGcgPSBDSVBIRVJfVEtJUDsKCQkJCQl9CgkJCQkJZWxzZSBpZiAocEFkLT5TdGFDZmcuV2VwU3RhdHVzID09IE5kaXM4MDJfMTFFbmNyeXB0aW9uM0VuYWJsZWQpCgkJCQkJewoJCQkJCQlwQWQtPlNoYXJlZEtleVtCU1MwXVtpXS5DaXBoZXJBbGcgPSBDSVBIRVJfQUVTOwoJCQkJCX0KCQkJCX0KCQkJCWVsc2UKCQkJCXsKCQkJCQlwQWQtPlNoYXJlZEtleVtCU1MwXVtpXS5DaXBoZXJBbGcgPSBDSVBIRVJfTk9ORTsKCQkJCX0KCQkJfQoKCQkJY3NyMS5maWVsZC5Cc3MwS2V5MENpcGhlckFsZyA9IHBBZC0+U2hhcmVkS2V5W0JTUzBdWzBdLkNpcGhlckFsZzsKCQkJY3NyMS5maWVsZC5Cc3MwS2V5MUNpcGhlckFsZyA9IHBBZC0+U2hhcmVkS2V5W0JTUzBdWzFdLkNpcGhlckFsZzsKCQkJY3NyMS5maWVsZC5Cc3MwS2V5MkNpcGhlckFsZyA9IHBBZC0+U2hhcmVkS2V5W0JTUzBdWzJdLkNpcGhlckFsZzsKCQkJY3NyMS5maWVsZC5Cc3MwS2V5M0NpcGhlckFsZyA9IHBBZC0+U2hhcmVkS2V5W0JTUzBdWzNdLkNpcGhlckFsZzsKCQl9CgkJUlRNUF9JT19XUklURTMyKHBBZCwgU0hBUkVEX0tFWV9NT0RFX0JBU0UsIGNzcjEud29yZCk7CgkJREJHUFJJTlQoUlRfREVCVUdfVFJBQ0UsICgiU3dpdGNoQmV0d2VlbldlcEFuZENraXA6IG1vZGlmeSBCU1MwIGNpcGhlciB0byAlc1xuIiwgQ2lwaGVyTmFtZVtjc3IxLmZpZWxkLkJzczBLZXkwQ2lwaGVyQWxnXSkpOwoJfQp9CgppbnQgd2V4dF9ub3RpZnlfZXZlbnRfYXNzb2MoCglJTiAgUlRNUF9BREFQVEVSICpwQWQpCnsKICAgIHVuaW9uIGl3cmVxX2RhdGEgICAgd3JxdTsKICAgIGNoYXIgY3VzdG9tW0lXX0NVU1RPTV9NQVhdID0gezB9OwoKICAgIGlmIChwQWQtPlN0YUNmZy5SZXFWYXJJRUxlbiA8PSBJV19DVVNUT01fTUFYKQogICAgewogICAgICAgIHdycXUuZGF0YS5sZW5ndGggPSBwQWQtPlN0YUNmZy5SZXFWYXJJRUxlbjsKICAgICAgICBtZW1jcHkoY3VzdG9tLCBwQWQtPlN0YUNmZy5SZXFWYXJJRXMsIHBBZC0+U3RhQ2ZnLlJlcVZhcklFTGVuKTsKICAgICAgICB3aXJlbGVzc19zZW5kX2V2ZW50KHBBZC0+bmV0X2RldiwgSVdFVkFTU09DUkVRSUUsICZ3cnF1LCBjdXN0b20pOwogICAgfQogICAgZWxzZQogICAgICAgIERCR1BSSU5UKFJUX0RFQlVHX1RSQUNFLCAoInBBZC0+U3RhQ2ZnLlJlcVZhcklFTGVuID4gTUFYX0NVU1RPTV9MRU5cbiIpKTsKCglyZXR1cm4gMDsKCn0KCiNpZmRlZiBSVDI4NzAKQk9PTEVBTiBTdGFBZGRNYWNUYWJsZUVudHJ5KAoJSU4gIFBSVE1QX0FEQVBURVIJCXBBZCwKCUlOICBQTUFDX1RBQkxFX0VOVFJZCXBFbnRyeSwKCUlOICBVQ0hBUgkJCQlNYXhTdXBwb3J0ZWRSYXRlSW41MDBLYnBzLAoJSU4gIEhUX0NBUEFCSUxJVFlfSUUJKnBIdENhcGFiaWxpdHksCglJTiAgVUNIQVIJCQkJSHRDYXBhYmlsaXR5TGVuLAoJSU4gIFVTSE9SVCAgICAgICAgCQlDYXBhYmlsaXR5SW5mbykKewoJVUNIQVIgICAgICAgICAgICBNYXhTdXBwb3J0ZWRSYXRlID0gUkFURV8xMTsKCglpZiAoQURIT0NfT04ocEFkKSkKCQlDTElFTlRfU1RBVFVTX0NMRUFSX0ZMQUcocEVudHJ5LCBmQ0xJRU5UX1NUQVRVU19XTU1fQ0FQQUJMRSk7CgoJc3dpdGNoIChNYXhTdXBwb3J0ZWRSYXRlSW41MDBLYnBzKQogICAgewogICAgICAgIGNhc2UgMTA4OiBNYXhTdXBwb3J0ZWRSYXRlID0gUkFURV81NDsgICBicmVhazsKICAgICAgICBjYXNlIDk2OiAgTWF4U3VwcG9ydGVkUmF0ZSA9IFJBVEVfNDg7ICAgYnJlYWs7CiAgICAgICAgY2FzZSA3MjogIE1heFN1cHBvcnRlZFJhdGUgPSBSQVRFXzM2OyAgIGJyZWFrOwogICAgICAgIGNhc2UgNDg6ICBNYXhTdXBwb3J0ZWRSYXRlID0gUkFURV8yNDsgICBicmVhazsKICAgICAgICBjYXNlIDM2OiAgTWF4U3VwcG9ydGVkUmF0ZSA9IFJBVEVfMTg7ICAgYnJlYWs7CiAgICAgICAgY2FzZSAyNDogIE1heFN1cHBvcnRlZFJhdGUgPSBSQVRFXzEyOyAgIGJyZWFrOwogICAgICAgIGNhc2UgMTg6ICBNYXhTdXBwb3J0ZWRSYXRlID0gUkFURV85OyAgICBicmVhazsKICAgICAgICBjYXNlIDEyOiAgTWF4U3VwcG9ydGVkUmF0ZSA9IFJBVEVfNjsgICAgYnJlYWs7CiAgICAgICAgY2FzZSAyMjogIE1heFN1cHBvcnRlZFJhdGUgPSBSQVRFXzExOyAgIGJyZWFrOwogICAgICAgIGNhc2UgMTE6ICBNYXhTdXBwb3J0ZWRSYXRlID0gUkFURV81XzU7ICBicmVhazsKICAgICAgICBjYXNlIDQ6ICAgTWF4U3VwcG9ydGVkUmF0ZSA9IFJBVEVfMjsgICAgYnJlYWs7CiAgICAgICAgY2FzZSAyOiAgIE1heFN1cHBvcnRlZFJhdGUgPSBSQVRFXzE7ICAgIGJyZWFrOwogICAgICAgIGRlZmF1bHQ6ICBNYXhTdXBwb3J0ZWRSYXRlID0gUkFURV8xMTsgICBicmVhazsKICAgIH0KCiAgICBpZiAoKHBBZC0+Q29tbW9uQ2ZnLlBoeU1vZGUgPT0gUEhZXzExRykgJiYgKE1heFN1cHBvcnRlZFJhdGUgPCBSQVRFX0ZJUlNUX09GRE1fUkFURSkpCiAgICAgICAgcmV0dXJuIEZBTFNFOwoKCS8vIDExbiBvbmx5CglpZiAoKChwQWQtPkNvbW1vbkNmZy5QaHlNb2RlID09IFBIWV8xMU5fMl80RykgfHwgKHBBZC0+Q29tbW9uQ2ZnLlBoeU1vZGUgPT0gUEhZXzExTl81RykpJiYgKEh0Q2FwYWJpbGl0eUxlbiA9PSAwKSkKCQlyZXR1cm4gRkFMU0U7CgoJaWYgKCFwRW50cnkpCiAgICAgICAgcmV0dXJuIEZBTFNFOwoKCU5kaXNBY3F1aXJlU3BpbkxvY2soJnBBZC0+TWFjVGFiTG9jayk7CglpZiAocEVudHJ5KQoJewoJCXBFbnRyeS0+UG9ydFNlY3VyZWQgPSBXUEFfODAyXzFYX1BPUlRfU0VDVVJFRDsKCQlpZiAoKE1heFN1cHBvcnRlZFJhdGUgPCBSQVRFX0ZJUlNUX09GRE1fUkFURSkgfHwKCQkJKHBBZC0+Q29tbW9uQ2ZnLlBoeU1vZGUgPT0gUEhZXzExQikpCgkJewoJCQlwRW50cnktPlJhdGVMZW4gPSA0OwoJCQlpZiAoTWF4U3VwcG9ydGVkUmF0ZSA+PSBSQVRFX0ZJUlNUX09GRE1fUkFURSkKCQkJCU1heFN1cHBvcnRlZFJhdGUgPSBSQVRFXzExOwoJCX0KCQllbHNlCgkJCXBFbnRyeS0+UmF0ZUxlbiA9IDEyOwoKCQlwRW50cnktPk1heEhUUGh5TW9kZS53b3JkID0gMDsKCQlwRW50cnktPk1pbkhUUGh5TW9kZS53b3JkID0gMDsKCQlwRW50cnktPkhUUGh5TW9kZS53b3JkID0gMDsKCQlwRW50cnktPk1heFN1cHBvcnRlZFJhdGUgPSBNYXhTdXBwb3J0ZWRSYXRlOwoJCWlmIChwRW50cnktPk1heFN1cHBvcnRlZFJhdGUgPCBSQVRFX0ZJUlNUX09GRE1fUkFURSkKCQl7CgkJCXBFbnRyeS0+TWF4SFRQaHlNb2RlLmZpZWxkLk1PREUgPSBNT0RFX0NDSzsKCQkJcEVudHJ5LT5NYXhIVFBoeU1vZGUuZmllbGQuTUNTID0gcEVudHJ5LT5NYXhTdXBwb3J0ZWRSYXRlOwoJCQlwRW50cnktPk1pbkhUUGh5TW9kZS5maWVsZC5NT0RFID0gTU9ERV9DQ0s7CgkJCXBFbnRyeS0+TWluSFRQaHlNb2RlLmZpZWxkLk1DUyA9IHBFbnRyeS0+TWF4U3VwcG9ydGVkUmF0ZTsKCQkJcEVudHJ5LT5IVFBoeU1vZGUuZmllbGQuTU9ERSA9IE1PREVfQ0NLOwoJCQlwRW50cnktPkhUUGh5TW9kZS5maWVsZC5NQ1MgPSBwRW50cnktPk1heFN1cHBvcnRlZFJhdGU7CgkJfQoJCWVsc2UKCQl7CgkJCXBFbnRyeS0+TWF4SFRQaHlNb2RlLmZpZWxkLk1PREUgPSBNT0RFX09GRE07CgkJCXBFbnRyeS0+TWF4SFRQaHlNb2RlLmZpZWxkLk1DUyA9IE9mZG1SYXRlVG9SeHdpTUNTW3BFbnRyeS0+TWF4U3VwcG9ydGVkUmF0ZV07CgkJCXBFbnRyeS0+TWluSFRQaHlNb2RlLmZpZWxkLk1PREUgPSBNT0RFX09GRE07CgkJCXBFbnRyeS0+TWluSFRQaHlNb2RlLmZpZWxkLk1DUyA9IE9mZG1SYXRlVG9SeHdpTUNTW3BFbnRyeS0+TWF4U3VwcG9ydGVkUmF0ZV07CgkJCXBFbnRyeS0+SFRQaHlNb2RlLmZpZWxkLk1PREUgPSBNT0RFX09GRE07CgkJCXBFbnRyeS0+SFRQaHlNb2RlLmZpZWxkLk1DUyA9IE9mZG1SYXRlVG9SeHdpTUNTW3BFbnRyeS0+TWF4U3VwcG9ydGVkUmF0ZV07CgkJfQoJCXBFbnRyeS0+Q2FwYWJpbGl0eUluZm8gPSBDYXBhYmlsaXR5SW5mbzsKCQlDTElFTlRfU1RBVFVTX0NMRUFSX0ZMQUcocEVudHJ5LCBmQ0xJRU5UX1NUQVRVU19BR0dSRUdBVElPTl9DQVBBQkxFKTsKCQlDTElFTlRfU1RBVFVTX0NMRUFSX0ZMQUcocEVudHJ5LCBmQ0xJRU5UX1NUQVRVU19QSUdHWUJBQ0tfQ0FQQUJMRSk7Cgl9CgoJLy8gSWYgdGhpcyBFbnRyeSBzdXBwb3J0cyA4MDIuMTFuLCB1cGdyYWRlIHRvIEhUIHJhdGUuCglpZiAoKEh0Q2FwYWJpbGl0eUxlbiAhPSAwKSAmJiAocEFkLT5Db21tb25DZmcuUGh5TW9kZSA+PSBQSFlfMTFBQkdOX01JWEVEKSkKCXsKCQlVQ0hBUglqLCBiaXRtYXNrOyAvL2ssYml0bWFzazsKCQlDSEFSICAgIGk7CgoJCWlmIChBREhPQ19PTihwQWQpKQoJCQlDTElFTlRfU1RBVFVTX1NFVF9GTEFHKHBFbnRyeSwgZkNMSUVOVF9TVEFUVVNfV01NX0NBUEFCTEUpOwoJCWlmICgocEh0Q2FwYWJpbGl0eS0+SHRDYXBJbmZvLkdGKSAmJiAocEFkLT5Db21tb25DZmcuRGVzaXJlZEh0UGh5LkdGKSkKCQl7CgkJCXBFbnRyeS0+TWF4SFRQaHlNb2RlLmZpZWxkLk1PREUgPSBNT0RFX0hUR1JFRU5GSUVMRDsKCQl9CgkJZWxzZQoJCXsKCQkJcEVudHJ5LT5NYXhIVFBoeU1vZGUuZmllbGQuTU9ERSA9IE1PREVfSFRNSVg7CgkJCXBBZC0+TWFjVGFiLmZBbnlTdGF0aW9uTm9uR0YgPSBUUlVFOwoJCQlwQWQtPkNvbW1vbkNmZy5BZGRIVEluZm8uQWRkSHRJbmZvMi5Ob25HZlByZXNlbnQgPSAxOwoJCX0KCgkJaWYgKChwSHRDYXBhYmlsaXR5LT5IdENhcEluZm8uQ2hhbm5lbFdpZHRoKSAmJiAocEFkLT5Db21tb25DZmcuRGVzaXJlZEh0UGh5LkNoYW5uZWxXaWR0aCkpCgkJewoJCQlwRW50cnktPk1heEhUUGh5TW9kZS5maWVsZC5CVz0gQldfNDA7CgkJCXBFbnRyeS0+TWF4SFRQaHlNb2RlLmZpZWxkLlNob3J0R0kgPSAoKHBBZC0+Q29tbW9uQ2ZnLkRlc2lyZWRIdFBoeS5TaG9ydEdJZm9yNDApJihwSHRDYXBhYmlsaXR5LT5IdENhcEluZm8uU2hvcnRHSWZvcjQwKSk7CgkJfQoJCWVsc2UKCQl7CgkJCXBFbnRyeS0+TWF4SFRQaHlNb2RlLmZpZWxkLkJXID0gQldfMjA7CgkJCXBFbnRyeS0+TWF4SFRQaHlNb2RlLmZpZWxkLlNob3J0R0kgPSAoKHBBZC0+Q29tbW9uQ2ZnLkRlc2lyZWRIdFBoeS5TaG9ydEdJZm9yMjApJihwSHRDYXBhYmlsaXR5LT5IdENhcEluZm8uU2hvcnRHSWZvcjIwKSk7CgkJCXBBZC0+TWFjVGFiLmZBbnlTdGF0aW9uMjBPbmx5ID0gVFJVRTsKCQl9CgoJCS8vIDMqMwoJCWlmIChwQWQtPk1BQ1ZlcnNpb24gPj0gUkFMSU5LXzI4ODNfVkVSU0lPTiAmJiBwQWQtPk1BQ1ZlcnNpb24gPCBSQUxJTktfMzA3MF9WRVJTSU9OKQoJCQlwRW50cnktPk1heEhUUGh5TW9kZS5maWVsZC5UeEJGID0gcEFkLT5Db21tb25DZmcuUmVnVHJhbnNtaXRTZXR0aW5nLmZpZWxkLlR4QkY7CgoJCS8vIGZpbmQgbWF4IGZpeGVkIHJhdGUKCQlmb3IgKGk9MjM7IGk+PTA7IGktLSkgLy8gMyozCgkJewoJCQlqID0gaS84OwoJCQliaXRtYXNrID0gKDE8PChpLShqKjgpKSk7CgkJCWlmICgocEFkLT5TdGFDZmcuRGVzaXJlZEh0UGh5SW5mby5NQ1NTZXRbal0gJiBiaXRtYXNrKSAmJiAocEh0Q2FwYWJpbGl0eS0+TUNTU2V0W2pdICYgYml0bWFzaykpCgkJCXsKCQkJCXBFbnRyeS0+TWF4SFRQaHlNb2RlLmZpZWxkLk1DUyA9IGk7CgkJCQlicmVhazsKCQkJfQoJCQlpZiAoaT09MCkKCQkJCWJyZWFrOwoJCX0KCgoJCWlmIChwQWQtPlN0YUNmZy5EZXNpcmVkVHJhbnNtaXRTZXR0aW5nLmZpZWxkLk1DUyAhPSBNQ1NfQVVUTykKCQl7CgkJCWlmIChwQWQtPlN0YUNmZy5EZXNpcmVkVHJhbnNtaXRTZXR0aW5nLmZpZWxkLk1DUyA9PSAzMikKCQkJewoJCQkJLy8gRml4IE1DUyBhcyBIVCBEdXBsaWNhdGVkIE1vZGUKCQkJCXBFbnRyeS0+TWF4SFRQaHlNb2RlLmZpZWxkLkJXID0gMTsKCQkJCXBFbnRyeS0+TWF4SFRQaHlNb2RlLmZpZWxkLk1PREUgPSBNT0RFX0hUTUlYOwoJCQkJcEVudHJ5LT5NYXhIVFBoeU1vZGUuZmllbGQuU1RCQyA9IDA7CgkJCQlwRW50cnktPk1heEhUUGh5TW9kZS5maWVsZC5TaG9ydEdJID0gMDsKCQkJCXBFbnRyeS0+TWF4SFRQaHlNb2RlLmZpZWxkLk1DUyA9IDMyOwoJCQl9CgkJCWVsc2UgaWYgKHBFbnRyeS0+TWF4SFRQaHlNb2RlLmZpZWxkLk1DUyA+IHBBZC0+U3RhQ2ZnLkhUUGh5TW9kZS5maWVsZC5NQ1MpCgkJCXsKCQkJCS8vIFNUQSBzdXBwb3J0cyBmaXhlZCBNQ1MKCQkJCXBFbnRyeS0+TWF4SFRQaHlNb2RlLmZpZWxkLk1DUyA9IHBBZC0+U3RhQ2ZnLkhUUGh5TW9kZS5maWVsZC5NQ1M7CgkJCX0KCQl9CgoJCXBFbnRyeS0+TWF4SFRQaHlNb2RlLmZpZWxkLlNUQkMgPSAocEh0Q2FwYWJpbGl0eS0+SHRDYXBJbmZvLlJ4U1RCQyAmIChwQWQtPkNvbW1vbkNmZy5EZXNpcmVkSHRQaHkuVHhTVEJDKSk7CgkJcEVudHJ5LT5NcGR1RGVuc2l0eSA9IHBIdENhcGFiaWxpdHktPkh0Q2FwUGFybS5NcGR1RGVuc2l0eTsKCQlwRW50cnktPk1heFJBbXBkdUZhY3RvciA9IHBIdENhcGFiaWxpdHktPkh0Q2FwUGFybS5NYXhSQW1wZHVGYWN0b3I7CgkJcEVudHJ5LT5NbXBzTW9kZSA9IChVQ0hBUilwSHRDYXBhYmlsaXR5LT5IdENhcEluZm8uTWltb1BzOwoJCXBFbnRyeS0+QU1zZHVTaXplID0gKFVDSEFSKXBIdENhcGFiaWxpdHktPkh0Q2FwSW5mby5BTXNkdVNpemU7CgkJcEVudHJ5LT5IVFBoeU1vZGUud29yZCA9IHBFbnRyeS0+TWF4SFRQaHlNb2RlLndvcmQ7CgoJCWlmIChwQWQtPkNvbW1vbkNmZy5EZXNpcmVkSHRQaHkuQW1zZHVFbmFibGUgJiYgKHBBZC0+Q29tbW9uQ2ZnLlJFR0JBQ2FwYWJpbGl0eS5maWVsZC5BdXRvQkEgPT0gRkFMU0UpKQoJCQlDTElFTlRfU1RBVFVTX1NFVF9GTEFHKHBFbnRyeSwgZkNMSUVOVF9TVEFUVVNfQU1TRFVfSU5VU0VEKTsKCQlpZiAocEh0Q2FwYWJpbGl0eS0+SHRDYXBJbmZvLlNob3J0R0lmb3IyMCkKCQkJQ0xJRU5UX1NUQVRVU19TRVRfRkxBRyhwRW50cnksIGZDTElFTlRfU1RBVFVTX1NHSTIwX0NBUEFCTEUpOwoJCWlmIChwSHRDYXBhYmlsaXR5LT5IdENhcEluZm8uU2hvcnRHSWZvcjQwKQoJCQlDTElFTlRfU1RBVFVTX1NFVF9GTEFHKHBFbnRyeSwgZkNMSUVOVF9TVEFUVVNfU0dJNDBfQ0FQQUJMRSk7CgkJaWYgKHBIdENhcGFiaWxpdHktPkh0Q2FwSW5mby5UeFNUQkMpCgkJCUNMSUVOVF9TVEFUVVNfU0VUX0ZMQUcocEVudHJ5LCBmQ0xJRU5UX1NUQVRVU19UeFNUQkNfQ0FQQUJMRSk7CgkJaWYgKHBIdENhcGFiaWxpdHktPkh0Q2FwSW5mby5SeFNUQkMpCgkJCUNMSUVOVF9TVEFUVVNfU0VUX0ZMQUcocEVudHJ5LCBmQ0xJRU5UX1NUQVRVU19SeFNUQkNfQ0FQQUJMRSk7CgkJaWYgKHBIdENhcGFiaWxpdHktPkV4dEh0Q2FwSW5mby5QbHVzSFRDKQoJCQlDTElFTlRfU1RBVFVTX1NFVF9GTEFHKHBFbnRyeSwgZkNMSUVOVF9TVEFUVVNfSFRDX0NBUEFCTEUpOwoJCWlmIChwQWQtPkNvbW1vbkNmZy5iUmRnICYmIHBIdENhcGFiaWxpdHktPkV4dEh0Q2FwSW5mby5SREdTdXBwb3J0KQoJCQlDTElFTlRfU1RBVFVTX1NFVF9GTEFHKHBFbnRyeSwgZkNMSUVOVF9TVEFUVVNfUkRHX0NBUEFCTEUpOwoJCWlmIChwSHRDYXBhYmlsaXR5LT5FeHRIdENhcEluZm8uTUNTRmVlZGJhY2sgPT0gMHgwMykKCQkJQ0xJRU5UX1NUQVRVU19TRVRfRkxBRyhwRW50cnksIGZDTElFTlRfU1RBVFVTX01DU0ZFRURCQUNLX0NBUEFCTEUpOwoJfQoJZWxzZQoJewoJCXBBZC0+TWFjVGFiLmZBbnlTdGF0aW9uSXNMZWdhY3kgPSBUUlVFOwoJfQoKCU5kaXNNb3ZlTWVtb3J5KCZwRW50cnktPkhUQ2FwYWJpbGl0eSwgcEh0Q2FwYWJpbGl0eSwgc2l6ZW9mKEhUX0NBUEFCSUxJVFlfSUUpKTsKCglwRW50cnktPkhUUGh5TW9kZS53b3JkID0gcEVudHJ5LT5NYXhIVFBoeU1vZGUud29yZDsKCXBFbnRyeS0+Q3VyclR4UmF0ZSA9IHBFbnRyeS0+TWF4U3VwcG9ydGVkUmF0ZTsKCgkvLyBTZXQgYXNpYyBhdXRvIGZhbGwgYmFjawoJaWYgKHBBZC0+U3RhQ2ZnLmJBdXRvVHhSYXRlU3dpdGNoID09IFRSVUUpCgl7CgkJUFVDSEFSCQkJCQlwVGFibGU7CgkJVUNIQVIJCQkJCVRhYmxlU2l6ZSA9IDA7CgoJCU1sbWVTZWxlY3RUeFJhdGVUYWJsZShwQWQsIHBFbnRyeSwgJnBUYWJsZSwgJlRhYmxlU2l6ZSwgJnBFbnRyeS0+Q3VyclR4UmF0ZUluZGV4KTsKCQlwRW50cnktPmJBdXRvVHhSYXRlU3dpdGNoID0gVFJVRTsKCX0KCWVsc2UKCXsKCQlwRW50cnktPkhUUGh5TW9kZS5maWVsZC5NT0RFCT0gcEFkLT5TdGFDZmcuSFRQaHlNb2RlLmZpZWxkLk1PREU7CgkJcEVudHJ5LT5IVFBoeU1vZGUuZmllbGQuTUNTCT0gcEFkLT5TdGFDZmcuSFRQaHlNb2RlLmZpZWxkLk1DUzsKCQlwRW50cnktPmJBdXRvVHhSYXRlU3dpdGNoID0gRkFMU0U7CgoJCS8vIElmIHRoZSBsZWdhY3kgbW9kZSBpcyBzZXQsIG92ZXJ3cml0ZSB0aGUgdHJhbnNtaXQgc2V0dGluZyBvZiB0aGlzIGVudHJ5LgoJCVJUTVBVcGRhdGVMZWdhY3lUeFNldHRpbmcoKFVDSEFSKXBBZC0+U3RhQ2ZnLkRlc2lyZWRUcmFuc21pdFNldHRpbmcuZmllbGQuRml4ZWRUeE1vZGUsIHBFbnRyeSk7Cgl9CgoJcEVudHJ5LT5Qb3J0U2VjdXJlZCA9IFdQQV84MDJfMVhfUE9SVF9TRUNVUkVEOwoJcEVudHJ5LT5Tc3QgPSBTU1RfQVNTT0M7CglwRW50cnktPkF1dGhTdGF0ZSA9IEFTX0FVVEhfT1BFTjsKCXBFbnRyeS0+QXV0aE1vZGUgPSBwQWQtPlN0YUNmZy5BdXRoTW9kZTsKCXBFbnRyeS0+V2VwU3RhdHVzID0gcEFkLT5TdGFDZmcuV2VwU3RhdHVzOwoKCU5kaXNSZWxlYXNlU3BpbkxvY2soJnBBZC0+TWFjVGFiTG9jayk7CgogICAgewogICAgICAgIHVuaW9uIGl3cmVxX2RhdGEgICAgd3JxdTsKICAgICAgICB3ZXh0X25vdGlmeV9ldmVudF9hc3NvYyhwQWQpOwoKICAgICAgICBtZW1zZXQod3JxdS5hcF9hZGRyLnNhX2RhdGEsIDAsIE1BQ19BRERSX0xFTik7CiAgICAgICAgbWVtY3B5KHdycXUuYXBfYWRkci5zYV9kYXRhLCBwQWQtPk1sbWVBdXguQnNzaWQsIE1BQ19BRERSX0xFTik7CiAgICAgICAgd2lyZWxlc3Nfc2VuZF9ldmVudChwQWQtPm5ldF9kZXYsIFNJT0NHSVdBUCwgJndycXUsIE5VTEwpOwoKICAgIH0KCXJldHVybiBUUlVFOwp9CiNlbmRpZiAvKiBSVDI4NzAgKi8K