LyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogKgogKiBUaGlzIGZpbGUgaXMgcHJvdmlkZWQgdW5kZXIgYSBkdWFsIGxpY2Vuc2UuICBXaGVuIHlvdSB1c2Ugb3IKICogZGlzdHJpYnV0ZSB0aGlzIHNvZnR3YXJlLCB5b3UgbWF5IGNob29zZSB0byBiZSBsaWNlbnNlZCB1bmRlcgogKiB2ZXJzaW9uIDIgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbnNlICgiR1BMdjIgTGljZW5zZSIpCiAqIG9yIEJTRCBMaWNlbnNlLgogKgogKiBHUEx2MiBMaWNlbnNlCiAqCiAqIENvcHlyaWdodChDKSAyMDE2IE1lZGlhVGVrIEluYy4KICoKICogVGhpcyBwcm9ncmFtIGlzIGZyZWUgc29mdHdhcmU7IHlvdSBjYW4gcmVkaXN0cmlidXRlIGl0IGFuZC9vciBtb2RpZnkKICogaXQgdW5kZXIgdGhlIHRlcm1zIG9mIHZlcnNpb24gMiBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2UgYXMKICogcHVibGlzaGVkIGJ5IHRoZSBGcmVlIFNvZnR3YXJlIEZvdW5kYXRpb24uCiAqCiAqIFRoaXMgcHJvZ3JhbSBpcyBkaXN0cmlidXRlZCBpbiB0aGUgaG9wZSB0aGF0IGl0IHdpbGwgYmUgdXNlZnVsLCBidXQKICogV0lUSE9VVCBBTlkgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZgogKiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UuCiAqIFNlZSBodHRwOi8vd3d3LmdudS5vcmcvbGljZW5zZXMvZ3BsLTIuMC5odG1sIGZvciBtb3JlIGRldGFpbHMuCiAqCiAqIEJTRCBMSUNFTlNFCiAqCiAqIENvcHlyaWdodChDKSAyMDE2IE1lZGlhVGVrIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KICoKICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CiAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwogKiBhcmUgbWV0OgogKgogKiAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAogKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCiAqICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CiAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbgogKiAgICB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCiAqICAgIGRpc3RyaWJ1dGlvbi4KICogICogTmVpdGhlciB0aGUgbmFtZSBvZiB0aGUgY29weXJpZ2h0IGhvbGRlciBub3IgdGhlIG5hbWVzIG9mIGl0cwogKiAgICBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQKICogICAgZnJvbSB0aGlzIHNvZnR3YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgogKgogKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCiAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UCiAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgogKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAogKiBIT0xERVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCiAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCiAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQogKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCiAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQogKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgogKgogKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi8qCioqIElkOiAvL0RlcGFydG1lbnQvRGFWaW5jaS9CUkFOQ0hFUy9NVDY2MjBfV0lGSV9EUklWRVJfVjJfMy9tZ210L3JsbS5jIzMKKi8KCi8qISBcZmlsZSAgICJybG0uYyIKKiAgICBcYnJpZWYKKgoqLwoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiogICAgICAgICAgICAgICAgICAgICAgICAgQyBPIE0gUCBJIEwgRSBSICAgRiBMIEEgRyBTCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiovCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgoqICAgICAgICAgICAgICAgICAgICBFIFggVCBFIFIgTiBBIEwgICBSIEUgRiBFIFIgRSBOIEMgRSBTCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiovCiNpbmNsdWRlICJwcmVjb21wLmgiCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgoqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQyBPIE4gUyBUIEEgTiBUIFMKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKi8KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiogICAgICAgICAgICAgICAgICAgICAgICAgICAgIEQgQSBUIEEgICBUIFkgUCBFIFMKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKi8KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiogICAgICAgICAgICAgICAgICAgICAgICAgICAgUCBVIEIgTCBJIEMgICBEIEEgVCBBCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiovCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgoqICAgICAgICAgICAgICAgICAgICAgICAgICAgUCBSIEkgViBBIFQgRSAgIEQgQSBUIEEKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKi8KQk9PTEVBTiBnX2JDYXB0dXJlRG9uZSA9IEZBTFNFOwpCT09MRUFOIGdfYkljYXBFbmFibGUgPSBGQUxTRTsKVUlOVF8xNiBnX3UyRHVtcEluZGV4OwpCT09MRUFOIGdfZmdIYXNDaGFubmVsU3dpdGNoSUUgPSBGQUxTRTsKCiNpZiBDRkdfU1VQUE9SVF9RQV9UT09MClVJTlRfMzIgZ19hdTRPZmZzZXRbMl1bMl07ClVJTlRfMzIgZ19hdTRJUURhdGFbMjU2XTsKI2VuZGlmCgojaWYgQ0ZHX1NVUFBPUlRfQ0FMX1JFU1VMVF9CQUNLVVBfVE9fSE9TVApSTE1fQ0FMX1JFU1VMVF9BTExfVjJfVAkJCWdfckJhY2t1cENhbERhdGFBbGxWMjsKI2VuZGlmCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgoqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgTSBBIEMgUiBPIFMKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKi8KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiogICAgICAgICAgICAgICAgICAgRiBVIE4gQyBUIEkgTyBOICAgRCBFIEMgTCBBIFIgQSBUIEkgTyBOIFMKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKi8Kc3RhdGljIFZPSUQgcmxtRmlsbEh0Q2FwSUUoUF9BREFQVEVSX1QgcHJBZGFwdGVyLCBQX0JTU19JTkZPX1QgcHJCc3NJbmZvLCBQX01TRFVfSU5GT19UIHByTXNkdUluZm8pOwoKc3RhdGljIFZPSUQgcmxtRmlsbEV4dENhcElFKFBfQURBUFRFUl9UIHByQWRhcHRlciwgUF9CU1NfSU5GT19UIHByQnNzSW5mbywgUF9NU0RVX0lORk9fVCBwck1zZHVJbmZvKTsKCnN0YXRpYyBWT0lEIHJsbUZpbGxIdE9wSUUoUF9BREFQVEVSX1QgcHJBZGFwdGVyLCBQX0JTU19JTkZPX1QgcHJCc3NJbmZvLCBQX01TRFVfSU5GT19UIHByTXNkdUluZm8pOwoKc3RhdGljIFVJTlRfOCBybG1SZWNJZUluZm9Gb3JDbGllbnQoUF9BREFQVEVSX1QgcHJBZGFwdGVyLCBQX0JTU19JTkZPX1QgcHJCc3NJbmZvLCBQVUlOVF84IHB1Y0lFLCBVSU5UXzE2IHUySUVMZW5ndGgpOwoKc3RhdGljIEJPT0xFQU4KcmxtUmVjQmNuRnJvbU5laWdoYm9yRm9yQ2xpZW50KFBfQURBUFRFUl9UIHByQWRhcHRlciwKCQkJICAgICAgIFBfQlNTX0lORk9fVCBwckJzc0luZm8sIFBfU1dfUkZCX1QgcHJTd1JmYiwgUFVJTlRfOCBwdWNJRSwgVUlOVF8xNiB1MklFTGVuZ3RoKTsKCnN0YXRpYyBCT09MRUFOCnJsbVJlY0JjbkluZm9Gb3JDbGllbnQoUF9BREFQVEVSX1QgcHJBZGFwdGVyLAoJCSAgICAgICBQX0JTU19JTkZPX1QgcHJCc3NJbmZvLCBQX1NXX1JGQl9UIHByU3dSZmIsIFBVSU5UXzggcHVjSUUsIFVJTlRfMTYgdTJJRUxlbmd0aCk7CgpzdGF0aWMgVk9JRCBybG1Cc3NSZXNldChQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfQlNTX0lORk9fVCBwckJzc0luZm8pOwoKI2lmIENGR19TVVBQT1JUXzgwMl8xMUFDCnN0YXRpYyBWT0lEIHJsbUZpbGxWaHRDYXBJRShQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfQlNTX0lORk9fVCBwckJzc0luZm8sIFBfTVNEVV9JTkZPX1QgcHJNc2R1SW5mbyk7CnN0YXRpYyBWT0lEIHJsbUZpbGxWaHRPcE5vdGlmaWNhdGlvbklFKFBfQURBUFRFUl9UIHByQWRhcHRlciwgUF9CU1NfSU5GT19UIHByQnNzSW5mbywKCQlQX01TRFVfSU5GT19UIHByTXNkdUluZm8sIEJPT0xFQU4gZmdJc01heENhcCk7CgojZW5kaWYKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEYgVSBOIEMgVCBJIE8gTiBTCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCiovCgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYKKgoqIFxwYXJhbVtpbl0KKgoqIFxyZXR1cm4gbm9uZQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpWT0lEIHJsbUZzbUV2ZW50SW5pdChQX0FEQVBURVJfVCBwckFkYXB0ZXIpCnsKCUFTU0VSVChwckFkYXB0ZXIpOwoKCS8qIE5vdGU6IGFzc3VtZSBUSU1FUl9UIHN0cnVjdHVyZXMgYXJlIHJlc2V0IHRvIHplcm8gb3Igc3RvcHBlZAoJICogYmVmb3JlIGludm9raW5nIHRoaXMgZnVuY3Rpb24uCgkgKi8KCgkvKiBJbml0aWFsaXplIE9CU1MgRlNNICovCglybG1PYnNzSW5pdChwckFkYXB0ZXIpOwoKI2lmIENGR19TVVBQT1JUX1BXUl9MSU1JVF9DT1VOVFJZCglybG1Eb21haW5DaGVja0NvdW50cnlQb3dlckxpbWl0VGFibGUocHJBZGFwdGVyKTsKI2VuZGlmCgoJZ19mZ0hhc0NoYW5uZWxTd2l0Y2hJRSA9IEZBTFNFOwoJZ19iQ2FwdHVyZURvbmUgPSBGQUxTRTsKCWdfYkljYXBFbmFibGUgPSBGQUxTRTsKCWdfdTJEdW1wSW5kZXggPSAwOwp9CgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYKKgoqIFxwYXJhbVtpbl0KKgoqIFxyZXR1cm4gbm9uZQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpWT0lEIHJsbUZzbUV2ZW50VW5pbml0KFBfQURBUFRFUl9UIHByQWRhcHRlcikKewoJUF9CU1NfSU5GT19UIHByQnNzSW5mbzsKCVVJTlRfOCBpOwoKCUFTU0VSVChwckFkYXB0ZXIpOwoKCWZvciAoaSA9IDA7IGkgPCBCU1NfSU5GT19OVU07IGkrKykgewoJCXByQnNzSW5mbyA9IHByQWRhcHRlci0+YXByQnNzSW5mb1tpXTsKCgkJLyogTm90ZTogYWxsIFJMTSB0aW1lcnMgd2lsbCBhbHNvIGJlIHN0b3BwZWQuCgkJICogICAgICAgTm93IG9ubHkgb25lIE9CU1Mgc2NhbiB0aW1lci4KCQkgKi8KCQlybG1Cc3NSZXNldChwckFkYXB0ZXIsIHByQnNzSW5mbyk7Cgl9Cn0KCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIFxicmllZiBGb3IgcHJvYmUgcmVxdWVzdCwgYXNzb2NpYXRpb24gcmVxdWVzdAoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovClZPSUQgcmxtUmVxR2VuZXJhdGVIdENhcElFKFBfQURBUFRFUl9UIHByQWRhcHRlciwgUF9NU0RVX0lORk9fVCBwck1zZHVJbmZvKQp7CglQX0JTU19JTkZPX1QgcHJCc3NJbmZvOwoJUF9TVEFfUkVDT1JEX1QgcHJTdGFSZWM7CgoJQVNTRVJUKHByQWRhcHRlcik7CglBU1NFUlQocHJNc2R1SW5mbyk7CgoJcHJCc3NJbmZvID0gcHJBZGFwdGVyLT5hcHJCc3NJbmZvW3ByTXNkdUluZm8tPnVjQnNzSW5kZXhdOwoJaWYgKCFwckJzc0luZm8pCgkJcmV0dXJuOwoKCXByU3RhUmVjID0gY25tR2V0U3RhUmVjQnlJbmRleChwckFkYXB0ZXIsIHByTXNkdUluZm8tPnVjU3RhUmVjSW5kZXgpOwoKCWlmICgocHJBZGFwdGVyLT5yV2lmaVZhci51Y0F2YWlsYWJsZVBoeVR5cGVTZXQgJiBQSFlfVFlQRV9TRVRfODAyXzExTikgJiYKCSAgICAoIXByU3RhUmVjIHx8IChwclN0YVJlYy0+dWNQaHlUeXBlU2V0ICYgUEhZX1RZUEVfU0VUXzgwMl8xMU4pKSkKCQlybG1GaWxsSHRDYXBJRShwckFkYXB0ZXIsIHByQnNzSW5mbywgcHJNc2R1SW5mbyk7Cn0KCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIFxicmllZiBGb3IgcHJvYmUgcmVxdWVzdCwgYXNzb2NpYXRpb24gcmVxdWVzdAoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovClZPSUQgcmxtUmVxR2VuZXJhdGVFeHRDYXBJRShQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfTVNEVV9JTkZPX1QgcHJNc2R1SW5mbykKewoJUF9CU1NfSU5GT19UIHByQnNzSW5mbzsKCVBfU1RBX1JFQ09SRF9UIHByU3RhUmVjOwoKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByTXNkdUluZm8pOwoKCXByQnNzSW5mbyA9IHByQWRhcHRlci0+YXByQnNzSW5mb1twck1zZHVJbmZvLT51Y0Jzc0luZGV4XTsKCWlmICghcHJCc3NJbmZvKQoJCXJldHVybjsKCglwclN0YVJlYyA9IGNubUdldFN0YVJlY0J5SW5kZXgocHJBZGFwdGVyLCBwck1zZHVJbmZvLT51Y1N0YVJlY0luZGV4KTsKCglpZiAoKHByQWRhcHRlci0+cldpZmlWYXIudWNBdmFpbGFibGVQaHlUeXBlU2V0ICYgUEhZX1RZUEVfU0VUXzgwMl8xMU4pICYmCgkgICAgKCFwclN0YVJlYyB8fCAocHJTdGFSZWMtPnVjUGh5VHlwZVNldCAmIFBIWV9UWVBFX1NFVF84MDJfMTFOKSkpCgkJcmxtRmlsbEV4dENhcElFKHByQWRhcHRlciwgcHJCc3NJbmZvLCBwck1zZHVJbmZvKTsKI2lmIENGR19TVVBQT1JUX1BBU1NQT0lOVAoJZWxzZSBpZiAocHJBZGFwdGVyLT5wckdsdWVJbmZvLT5mZ0Nvbm5lY3RIUzIwQVAgPT0gVFJVRSkKCQloczIwRmlsbEV4dENhcElFKHByQWRhcHRlciwgcHJCc3NJbmZvLCBwck1zZHVJbmZvKTsKI2VuZGlmIC8qIENGR19TVVBQT1JUX1BBU1NQT0lOVCAqLwp9CgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYgRm9yIHByb2JlIHJlc3BvbnNlIChHTywgSUJTUykgYW5kIGFzc29jaWF0aW9uIHJlc3BvbnNlCioKKiBccGFyYW1baW5dCioKKiBccmV0dXJuIG5vbmUKKi8KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KVk9JRCBybG1Sc3BHZW5lcmF0ZUh0Q2FwSUUoUF9BREFQVEVSX1QgcHJBZGFwdGVyLCBQX01TRFVfSU5GT19UIHByTXNkdUluZm8pCnsKCVBfQlNTX0lORk9fVCBwckJzc0luZm87CglQX1NUQV9SRUNPUkRfVCBwclN0YVJlYzsKCVVJTlRfOCB1Y1BoeVR5cGVTZXQ7CgoJQVNTRVJUKHByQWRhcHRlcik7CglBU1NFUlQocHJNc2R1SW5mbyk7CgoJcHJCc3NJbmZvID0gcHJBZGFwdGVyLT5hcHJCc3NJbmZvW3ByTXNkdUluZm8tPnVjQnNzSW5kZXhdOwoJaWYgKCFwckJzc0luZm8pCgkJcmV0dXJuOwoKCWlmICghSVNfQlNTX0FDVElWRShwckJzc0luZm8pKQoJCXJldHVybjsKCglwclN0YVJlYyA9IGNubUdldFN0YVJlY0J5SW5kZXgocHJBZGFwdGVyLCBwck1zZHVJbmZvLT51Y1N0YVJlY0luZGV4KTsKCgkvKiBEZWNpZGUgUEhZIHR5cGUgc2V0IHNvdXJjZSAqLwoJaWYgKHByU3RhUmVjKSB7CgkJLyogR2V0IFBIWSB0eXBlIHNldCBmcm9tIHRhcmdldCBTVEEgKi8KCQl1Y1BoeVR5cGVTZXQgPSBwclN0YVJlYy0+dWNQaHlUeXBlU2V0OwoJfSBlbHNlIHsKCQkvKiBHZXQgUEhZIHR5cGUgc2V0IGZyb20gY3VycmVudCBCU1MgKi8KCQl1Y1BoeVR5cGVTZXQgPSBwckJzc0luZm8tPnVjUGh5VHlwZVNldDsKCX0KCglpZiAoUkxNX05FVF9JU18xMU4ocHJCc3NJbmZvKSAmJiAodWNQaHlUeXBlU2V0ICYgUEhZX1RZUEVfU0VUXzgwMl8xMU4pKQoJCXJsbUZpbGxIdENhcElFKHByQWRhcHRlciwgcHJCc3NJbmZvLCBwck1zZHVJbmZvKTsKfQoKLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLyohCiogXGJyaWVmIEZvciBwcm9iZSByZXNwb25zZSAoR08sIElCU1MpIGFuZCBhc3NvY2lhdGlvbiByZXNwb25zZQoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovClZPSUQgcmxtUnNwR2VuZXJhdGVFeHRDYXBJRShQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfTVNEVV9JTkZPX1QgcHJNc2R1SW5mbykKewoJUF9CU1NfSU5GT19UIHByQnNzSW5mbzsKCVBfU1RBX1JFQ09SRF9UIHByU3RhUmVjOwoJVUlOVF84IHVjUGh5VHlwZVNldDsKCglBU1NFUlQocHJBZGFwdGVyKTsKCUFTU0VSVChwck1zZHVJbmZvKTsKCglwckJzc0luZm8gPSBwckFkYXB0ZXItPmFwckJzc0luZm9bcHJNc2R1SW5mby0+dWNCc3NJbmRleF07CglpZiAoIXByQnNzSW5mbykKCQlyZXR1cm47CgoJaWYgKCFJU19CU1NfQUNUSVZFKHByQnNzSW5mbykpCgkJcmV0dXJuOwoKCXByU3RhUmVjID0gY25tR2V0U3RhUmVjQnlJbmRleChwckFkYXB0ZXIsIHByTXNkdUluZm8tPnVjU3RhUmVjSW5kZXgpOwoKCS8qIERlY2lkZSBQSFkgdHlwZSBzZXQgc291cmNlICovCglpZiAocHJTdGFSZWMpIHsKCQkvKiBHZXQgUEhZIHR5cGUgc2V0IGZyb20gdGFyZ2V0IFNUQSAqLwoJCXVjUGh5VHlwZVNldCA9IHByU3RhUmVjLT51Y1BoeVR5cGVTZXQ7Cgl9IGVsc2UgewoJCS8qIEdldCBQSFkgdHlwZSBzZXQgZnJvbSBjdXJyZW50IEJTUyAqLwoJCXVjUGh5VHlwZVNldCA9IHByQnNzSW5mby0+dWNQaHlUeXBlU2V0OwoJfQoKCWlmIChSTE1fTkVUX0lTXzExTihwckJzc0luZm8pICYmICh1Y1BoeVR5cGVTZXQgJiBQSFlfVFlQRV9TRVRfODAyXzExTikpCgkJcmxtRmlsbEV4dENhcElFKHByQWRhcHRlciwgcHJCc3NJbmZvLCBwck1zZHVJbmZvKTsKfQoKLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLyohCiogXGJyaWVmIEZvciBwcm9iZSByZXNwb25zZSAoR08sIElCU1MpIGFuZCBhc3NvY2lhdGlvbiByZXNwb25zZQoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovClZPSUQgcmxtUnNwR2VuZXJhdGVIdE9wSUUoUF9BREFQVEVSX1QgcHJBZGFwdGVyLCBQX01TRFVfSU5GT19UIHByTXNkdUluZm8pCnsKCVBfQlNTX0lORk9fVCBwckJzc0luZm87CglQX1NUQV9SRUNPUkRfVCBwclN0YVJlYzsKCVVJTlRfOCB1Y1BoeVR5cGVTZXQ7CgoJQVNTRVJUKHByQWRhcHRlcik7CglBU1NFUlQocHJNc2R1SW5mbyk7CgoJcHJTdGFSZWMgPSBjbm1HZXRTdGFSZWNCeUluZGV4KHByQWRhcHRlciwgcHJNc2R1SW5mby0+dWNTdGFSZWNJbmRleCk7CgoJcHJCc3NJbmZvID0gcHJBZGFwdGVyLT5hcHJCc3NJbmZvW3ByTXNkdUluZm8tPnVjQnNzSW5kZXhdOwoJaWYgKCFwckJzc0luZm8pCgkJcmV0dXJuOwoKCWlmICghSVNfQlNTX0FDVElWRShwckJzc0luZm8pKQoJCXJldHVybjsKCgkvKiBEZWNpZGUgUEhZIHR5cGUgc2V0IHNvdXJjZSAqLwoJaWYgKHByU3RhUmVjKSB7CgkJLyogR2V0IFBIWSB0eXBlIHNldCBmcm9tIHRhcmdldCBTVEEgKi8KCQl1Y1BoeVR5cGVTZXQgPSBwclN0YVJlYy0+dWNQaHlUeXBlU2V0OwoJfSBlbHNlIHsKCQkvKiBHZXQgUEhZIHR5cGUgc2V0IGZyb20gY3VycmVudCBCU1MgKi8KCQl1Y1BoeVR5cGVTZXQgPSBwckJzc0luZm8tPnVjUGh5VHlwZVNldDsKCX0KCglpZiAoUkxNX05FVF9JU18xMU4ocHJCc3NJbmZvKSAmJiAodWNQaHlUeXBlU2V0ICYgUEhZX1RZUEVfU0VUXzgwMl8xMU4pKQoJCXJsbUZpbGxIdE9wSUUocHJBZGFwdGVyLCBwckJzc0luZm8sIHByTXNkdUluZm8pOwp9CgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYgRm9yIHByb2JlIHJlc3BvbnNlIChHTywgSUJTUykgYW5kIGFzc29jaWF0aW9uIHJlc3BvbnNlCioKKiBccGFyYW1baW5dCioKKiBccmV0dXJuIG5vbmUKKi8KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KVk9JRCBybG1Sc3BHZW5lcmF0ZUVycElFKFBfQURBUFRFUl9UIHByQWRhcHRlciwgUF9NU0RVX0lORk9fVCBwck1zZHVJbmZvKQp7CglQX0JTU19JTkZPX1QgcHJCc3NJbmZvOwoJUF9TVEFfUkVDT1JEX1QgcHJTdGFSZWM7CglQX0lFX0VSUF9UIHByRXJwSWU7CglVSU5UXzggdWNQaHlUeXBlU2V0OwoKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByTXNkdUluZm8pOwoKCXByU3RhUmVjID0gY25tR2V0U3RhUmVjQnlJbmRleChwckFkYXB0ZXIsIHByTXNkdUluZm8tPnVjU3RhUmVjSW5kZXgpOwoKCXByQnNzSW5mbyA9IHByQWRhcHRlci0+YXByQnNzSW5mb1twck1zZHVJbmZvLT51Y0Jzc0luZGV4XTsKCWlmICghcHJCc3NJbmZvKQoJCXJldHVybjsKCglpZiAoIUlTX0JTU19BQ1RJVkUocHJCc3NJbmZvKSkKCQlyZXR1cm47CgoJLyogRGVjaWRlIFBIWSB0eXBlIHNldCBzb3VyY2UgKi8KCWlmIChwclN0YVJlYykgewoJCS8qIEdldCBQSFkgdHlwZSBzZXQgZnJvbSB0YXJnZXQgU1RBICovCgkJdWNQaHlUeXBlU2V0ID0gcHJTdGFSZWMtPnVjUGh5VHlwZVNldDsKCX0gZWxzZSB7CgkJLyogR2V0IFBIWSB0eXBlIHNldCBmcm9tIGN1cnJlbnQgQlNTICovCgkJdWNQaHlUeXBlU2V0ID0gcHJCc3NJbmZvLT51Y1BoeVR5cGVTZXQ7Cgl9CgoJaWYgKFJMTV9ORVRfSVNfMTFHTihwckJzc0luZm8pICYmIHByQnNzSW5mby0+ZUJhbmQgPT0gQkFORF8yRzQgJiYgKHVjUGh5VHlwZVNldCAmIFBIWV9UWVBFX1NFVF84MDJfMTFHTikpIHsKCQlwckVycEllID0gKFBfSUVfRVJQX1QpCgkJICAgICgoKFBVSU5UXzgpIHByTXNkdUluZm8tPnByUGFja2V0KSArIHByTXNkdUluZm8tPnUyRnJhbWVMZW5ndGgpOwoKCQkvKiBBZGQgRVJQIElFICovCgkJcHJFcnBJZS0+dWNJZCA9IEVMRU1fSURfRVJQX0lORk87CgkJcHJFcnBJZS0+dWNMZW5ndGggPSAxOwoKCQlwckVycEllLT51Y0VSUCA9IHByQnNzSW5mby0+ZmdPYnNzRXJwUHJvdGVjdE1vZGUgPyBFUlBfSU5GT19VU0VfUFJPVEVDVElPTiA6IDA7CgoJCWlmIChwckJzc0luZm8tPmZnRXJwUHJvdGVjdE1vZGUpCgkJCXByRXJwSWUtPnVjRVJQIHw9IChFUlBfSU5GT19OT05fRVJQX1BSRVNFTlQgfCBFUlBfSU5GT19VU0VfUFJPVEVDVElPTik7CgoJCS8qIEhhbmRsZSBiYXJrZXIgcHJlYW1ibGUgKi8KCQlpZiAoIXByQnNzSW5mby0+ZmdVc2VTaG9ydFByZWFtYmxlKQoJCQlwckVycEllLT51Y0VSUCB8PSBFUlBfSU5GT19CQVJLRVJfUFJFQU1CTEVfTU9ERTsKCgkJQVNTRVJUKElFX1NJWkUocHJFcnBJZSkgPD0gKEVMRU1fSERSX0xFTiArIEVMRU1fTUFYX0xFTl9FUlApKTsKCgkJcHJNc2R1SW5mby0+dTJGcmFtZUxlbmd0aCArPSBJRV9TSVpFKHByRXJwSWUpOwoJfQp9CgojaWYgQ0ZHX1NVUFBPUlRfTVRLX1NZTkVSR1kKLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLyohCiogXGJyaWVmIFRoaXMgZnVuY3Rpb24gaXMgdXNlZCB0byBnZW5lcmF0ZSBNVEsgVmVuZG9yIFNwZWNpZmljIE9VSQoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovClZPSUQgcmxtR2VuZXJhdGVNVEtPdWlJRShQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfTVNEVV9JTkZPX1QgcHJNc2R1SW5mbykKewoJUF9CU1NfSU5GT19UIHByQnNzSW5mbzsKCVBVSU5UXzggcHVjQnVmZmVyOwoJVUlOVF84IGF1Y010a091aVtdID0gVkVORE9SX09VSV9NVEs7CgoJQVNTRVJUKHByQWRhcHRlcik7CglBU1NFUlQocHJNc2R1SW5mbyk7CgoJaWYgKHByQWRhcHRlci0+cldpZmlWYXIudWNNdGtPdWkgPT0gRkVBVFVSRV9ESVNBQkxFRCkKCQlyZXR1cm47CgoJcHJCc3NJbmZvID0gcHJBZGFwdGVyLT5hcHJCc3NJbmZvW3ByTXNkdUluZm8tPnVjQnNzSW5kZXhdOwoJaWYgKCFwckJzc0luZm8pCgkJcmV0dXJuOwoKCXB1Y0J1ZmZlciA9IChQVUlOVF84KSAoKFVMT05HKSBwck1zZHVJbmZvLT5wclBhY2tldCArIChVTE9ORykgcHJNc2R1SW5mby0+dTJGcmFtZUxlbmd0aCk7CgoJTVRLX09VSV9JRShwdWNCdWZmZXIpLT51Y0lkID0gRUxFTV9JRF9WRU5ET1I7CglNVEtfT1VJX0lFKHB1Y0J1ZmZlciktPnVjTGVuZ3RoID0gRUxFTV9NSU5fTEVOX01US19PVUk7CglNVEtfT1VJX0lFKHB1Y0J1ZmZlciktPmF1Y091aVswXSA9IGF1Y010a091aVswXTsKCU1US19PVUlfSUUocHVjQnVmZmVyKS0+YXVjT3VpWzFdID0gYXVjTXRrT3VpWzFdOwoJTVRLX09VSV9JRShwdWNCdWZmZXIpLT5hdWNPdWlbMl0gPSBhdWNNdGtPdWlbMl07CglNVEtfT1VJX0lFKHB1Y0J1ZmZlciktPmF1Y0NhcGFiaWxpdHlbMF0gPSBNVEtfU1lORVJHWV9DQVAwICYgKHByQWRhcHRlci0+cldpZmlWYXIuYXVjTXRrRmVhdHVyZVswXSk7CglNVEtfT1VJX0lFKHB1Y0J1ZmZlciktPmF1Y0NhcGFiaWxpdHlbMV0gPSBNVEtfU1lORVJHWV9DQVAxICYgKHByQWRhcHRlci0+cldpZmlWYXIuYXVjTXRrRmVhdHVyZVsxXSk7CglNVEtfT1VJX0lFKHB1Y0J1ZmZlciktPmF1Y0NhcGFiaWxpdHlbMl0gPSBNVEtfU1lORVJHWV9DQVAyICYgKHByQWRhcHRlci0+cldpZmlWYXIuYXVjTXRrRmVhdHVyZVsyXSk7CglNVEtfT1VJX0lFKHB1Y0J1ZmZlciktPmF1Y0NhcGFiaWxpdHlbM10gPSBNVEtfU1lORVJHWV9DQVAzICYgKHByQWRhcHRlci0+cldpZmlWYXIuYXVjTXRrRmVhdHVyZVszXSk7CgoJcHJNc2R1SW5mby0+dTJGcmFtZUxlbmd0aCArPSBJRV9TSVpFKHB1Y0J1ZmZlcik7CglwdWNCdWZmZXIgKz0gSUVfU0laRShwdWNCdWZmZXIpOwp9CQkJCS8qIHJsbUdlbmVyYXRlTVRLT3VpSUUgKi8KCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIEBicmllZiBUaGlzIGZ1bmN0aW9uIGlzIHVzZWQgdG8gY2hlY2sgTVRLIFZlbmRvciBTcGVjaWZpYyBPVUkKKgoqCiogQHJldHVybiB0cnVlOiAgY29ycmVjdCBNVEsgT1VJCiogICAgICAgICAgICAgZmFsc2U6IGluY29ycmVjdCBNVEsgT1VJCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCkJPT0xFQU4gcmxtUGFyc2VDaGVja01US091aUlFKElOIFBfQURBUFRFUl9UIHByQWRhcHRlciwgSU4gUFVJTlRfOCBwdWNCdWYsIElOIFBVSU5UXzMyIHB1NENhcCkKewoJVUlOVF84IGF1Y010a091aVtdID0gVkVORE9SX09VSV9NVEs7CglQX0lFX01US19PVUlfVCBwck10a091aUlFID0gKFBfSUVfTVRLX09VSV9UKSBOVUxMOwoKCWRvIHsKCQlBU1NFUlRfQlJFQUsoKHByQWRhcHRlciAhPSBOVUxMKSAmJiAocHVjQnVmICE9IE5VTEwpKTsKCgkJcHJNdGtPdWlJRSA9IChQX0lFX01US19PVUlfVCkgcHVjQnVmOwoKCQlpZiAocHJBZGFwdGVyLT5yV2lmaVZhci51Y010a091aSA9PSBGRUFUVVJFX0RJU0FCTEVEKQoJCQlicmVhazsKCQllbHNlIGlmIChJRV9MRU4ocHVjQnVmKSA8IEVMRU1fTUlOX0xFTl9NVEtfT1VJKQoJCQlicmVhazsKCQllbHNlIGlmIChwck10a091aUlFLT5hdWNPdWlbMF0gIT0gYXVjTXRrT3VpWzBdIHx8CgkJCSBwck10a091aUlFLT5hdWNPdWlbMV0gIT0gYXVjTXRrT3VpWzFdIHx8IHByTXRrT3VpSUUtPmF1Y091aVsyXSAhPSBhdWNNdGtPdWlbMl0pCgkJCWJyZWFrOwoJCS8qIGFwcGx5IE52UmFtIHNldHRpbmcgKi8KCQlwck10a091aUlFLT5hdWNDYXBhYmlsaXR5WzBdID0gcHJNdGtPdWlJRS0+YXVjQ2FwYWJpbGl0eVswXSAmIChwckFkYXB0ZXItPnJXaWZpVmFyLmF1Y010a0ZlYXR1cmVbMF0pOwoJCXByTXRrT3VpSUUtPmF1Y0NhcGFiaWxpdHlbMV0gPSBwck10a091aUlFLT5hdWNDYXBhYmlsaXR5WzFdICYgKHByQWRhcHRlci0+cldpZmlWYXIuYXVjTXRrRmVhdHVyZVsxXSk7CgkJcHJNdGtPdWlJRS0+YXVjQ2FwYWJpbGl0eVsyXSA9IHByTXRrT3VpSUUtPmF1Y0NhcGFiaWxpdHlbMl0gJiAocHJBZGFwdGVyLT5yV2lmaVZhci5hdWNNdGtGZWF0dXJlWzJdKTsKCQlwck10a091aUlFLT5hdWNDYXBhYmlsaXR5WzNdID0gcHJNdGtPdWlJRS0+YXVjQ2FwYWJpbGl0eVszXSAmIChwckFkYXB0ZXItPnJXaWZpVmFyLmF1Y010a0ZlYXR1cmVbM10pOwoKCQlrYWxNZW1Db3B5KHB1NENhcCwgcHJNdGtPdWlJRS0+YXVjQ2FwYWJpbGl0eSwgc2l6ZW9mKFVJTlRfMzIpKTsKCgkJcmV0dXJuIFRSVUU7Cgl9IHdoaWxlIChGQUxTRSk7CgoJcmV0dXJuIEZBTFNFOwp9CQkJCS8qIHJsbVBhcnNlQ2hlY2tNVEtPdWlJRSAqLwoKI2VuZGlmCgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYKKgoqIFxwYXJhbVtpbl0KKgoqIFxyZXR1cm4gbm9uZQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpWT0lEIHJsbUdlbmVyYXRlQ3NhSUUoUF9BREFQVEVSX1QgcHJBZGFwdGVyLCBQX01TRFVfSU5GT19UIHByTXNkdUluZm8pCnsKCVBVSU5UXzggcHVjQnVmZmVyOwoKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByTXNkdUluZm8pOwoKCWlmIChwckFkYXB0ZXItPnJXaWZpVmFyLmZnQ3NhSW5Qcm9ncmVzcykgewoKCQlwdWNCdWZmZXIgPSAoUFVJTlRfOCkgKChVTE9ORykgcHJNc2R1SW5mby0+cHJQYWNrZXQgKyAoVUxPTkcpIHByTXNkdUluZm8tPnUyRnJhbWVMZW5ndGgpOwoKCQlDU0FfSUUocHVjQnVmZmVyKS0+dWNJZCA9IEVMRU1fSURfQ0hfU1dfQU5OT1VOQ0VNRU5UOwoJCUNTQV9JRShwdWNCdWZmZXIpLT51Y0xlbmd0aCA9IEVMRU1fTUlOX0xFTl9DU0E7CgkJQ1NBX0lFKHB1Y0J1ZmZlciktPnVjQ2hhbm5lbFN3aXRjaE1vZGUgPSBwckFkYXB0ZXItPnJXaWZpVmFyLnVjQ2hhbm5lbFN3aXRjaE1vZGU7CgkJQ1NBX0lFKHB1Y0J1ZmZlciktPnVjTmV3Q2hhbm5lbE51bSA9IHByQWRhcHRlci0+cldpZmlWYXIudWNOZXdDaGFubmVsTnVtYmVyOwoJCUNTQV9JRShwdWNCdWZmZXIpLT51Y0NoYW5uZWxTd2l0Y2hDb3VudCA9IHByQWRhcHRlci0+cldpZmlWYXIudWNDaGFubmVsU3dpdGNoQ291bnQ7CgoJCXByTXNkdUluZm8tPnUyRnJhbWVMZW5ndGggKz0gSUVfU0laRShwdWNCdWZmZXIpOwoJCXB1Y0J1ZmZlciArPSBJRV9TSVpFKHB1Y0J1ZmZlcik7Cgl9Cgp9CgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYKKgoqIFxwYXJhbVtpbl0KKgoqIFxyZXR1cm4gbm9uZQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpzdGF0aWMgVk9JRCBybG1GaWxsSHRDYXBJRShQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfQlNTX0lORk9fVCBwckJzc0luZm8sIFBfTVNEVV9JTkZPX1QgcHJNc2R1SW5mbykKewoJUF9JRV9IVF9DQVBfVCBwckh0Q2FwOwoJUF9TVVBfTUNTX1NFVF9GSUVMRCBwclN1cE1jc1NldDsKCUJPT0xFQU4gZmc0MG1BbGxvd2VkOwoJVUlOVF84IHVjSWR4OwoKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByQnNzSW5mbyk7CglBU1NFUlQocHJNc2R1SW5mbyk7CgoJZmc0MG1BbGxvd2VkID0gcHJCc3NJbmZvLT5mZ0Fzc29jNDBtQndBbGxvd2VkOwoKCXBySHRDYXAgPSAoUF9JRV9IVF9DQVBfVCkKCSAgICAoKChQVUlOVF84KSBwck1zZHVJbmZvLT5wclBhY2tldCkgKyBwck1zZHVJbmZvLT51MkZyYW1lTGVuZ3RoKTsKCgkvKiBBZGQgSFQgY2FwYWJpbGl0aWVzIElFICovCglwckh0Q2FwLT51Y0lkID0gRUxFTV9JRF9IVF9DQVA7Cglwckh0Q2FwLT51Y0xlbmd0aCA9IHNpemVvZihJRV9IVF9DQVBfVCkgLSBFTEVNX0hEUl9MRU47CgoJcHJIdENhcC0+dTJIdENhcEluZm8gPSBIVF9DQVBfSU5GT19ERUZBVUxUX1ZBTDsKCglpZiAoSVNfRkVBVFVSRV9FTkFCTEVEKHByQWRhcHRlci0+cldpZmlWYXIudWNSeFNob3J0R0kpKQoJCXBySHRDYXAtPnUySHRDYXBJbmZvIHw9IChIVF9DQVBfSU5GT19TSE9SVF9HSV8yME0gfCBIVF9DQVBfSU5GT19TSE9SVF9HSV80ME0pOwoKCWlmIChJU19GRUFUVVJFX0VOQUJMRUQocHJBZGFwdGVyLT5yV2lmaVZhci51Y1J4TGRwYykpCgkJcHJIdENhcC0+dTJIdENhcEluZm8gfD0gSFRfQ0FQX0lORk9fTERQQ19DQVA7CgoJaWYgKElTX0ZFQVRVUkVfRU5BQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjVHhTdGJjKSkKCQlwckh0Q2FwLT51Mkh0Q2FwSW5mbyB8PSBIVF9DQVBfSU5GT19UWF9TVEJDOwoKCWlmIChJU19GRUFUVVJFX0VOQUJMRUQocHJBZGFwdGVyLT5yV2lmaVZhci51Y1J4U3RiYykpIHsKCgkJVUlOVF84IHRlbXBSeFN0YmNOc3M7CgoJCXRlbXBSeFN0YmNOc3MgPSBwckFkYXB0ZXItPnJXaWZpVmFyLnVjUnhTdGJjTnNzOwoJCXRlbXBSeFN0YmNOc3MgPSAodGVtcFJ4U3RiY05zcyA+IHdsYW5HZXRTdXBwb3J0TnNzKHByQWRhcHRlciwgcHJCc3NJbmZvLT51Y0Jzc0luZGV4KSkgPwoJCQl3bGFuR2V0U3VwcG9ydE5zcyhwckFkYXB0ZXIsIHByQnNzSW5mby0+dWNCc3NJbmRleCkgOiAodGVtcFJ4U3RiY05zcyk7CgkJaWYgKHRlbXBSeFN0YmNOc3MgIT0gcHJBZGFwdGVyLT5yV2lmaVZhci51Y1J4U3RiY05zcykgewoJCQlEQkdMT0coUkxNLCBXQVJOLCAiQXBwbHkgTnNzOiVkIGFzIFJ4U3RiY05zcyBpbiBIVCBDYXAiLAoJCQkJd2xhbkdldFN1cHBvcnROc3MocHJBZGFwdGVyLCBwckJzc0luZm8tPnVjQnNzSW5kZXgpKTsKCQkJREJHTE9HKFJMTSwgV0FSTiwgIiBkdWUgdG8gc2V0IFJ4U3RiY05zcyBtb3JlIHRoYW4gTnNzIGlzIG5vdCBhcHByb3ByaWF0ZS5cbiIpOwoJCX0KCQlpZiAodGVtcFJ4U3RiY05zcyA9PSAxKQoJCQlwckh0Q2FwLT51Mkh0Q2FwSW5mbyB8PSBIVF9DQVBfSU5GT19SWF9TVEJDXzFfU1M7CgkJZWxzZSBpZiAodGVtcFJ4U3RiY05zcyA9PSAyKQoJCQlwckh0Q2FwLT51Mkh0Q2FwSW5mbyB8PSBIVF9DQVBfSU5GT19SWF9TVEJDXzJfU1M7CgkJZWxzZSBpZiAodGVtcFJ4U3RiY05zcyA+PSAzKQoJCQlwckh0Q2FwLT51Mkh0Q2FwSW5mbyB8PSBIVF9DQVBfSU5GT19SWF9TVEJDXzNfU1M7Cgl9CgoJaWYgKElTX0ZFQVRVUkVfRU5BQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjUnhHZikpCgkJcHJIdENhcC0+dTJIdENhcEluZm8gfD0gSFRfQ0FQX0lORk9fSFRfR0Y7CgoJaWYgKHByQWRhcHRlci0+cldpZmlWYXIudWNSeE1heE1wZHVMZW4gPiBWSFRfQ0FQX0lORk9fTUFYX01QRFVfTEVOXzNLKQoJCXBySHRDYXAtPnUySHRDYXBJbmZvIHw9IEhUX0NBUF9JTkZPX01BWF9BTVNEVV9MRU47CgoJaWYgKCFmZzQwbUFsbG93ZWQpCgkJcHJIdENhcC0+dTJIdENhcEluZm8gJj0gfihIVF9DQVBfSU5GT19TVVBfQ0hOTF9XSURUSCB8CgkJCQkJICBIVF9DQVBfSU5GT19TSE9SVF9HSV80ME0gfCBIVF9DQVBfSU5GT19EU1NTX0NDS19JTl80ME0pOwoKCS8qIFNNIHBvd2VyIHNhdmluZyAqLyAvKiBUSDNfSHVhbmcgKi8KCWlmIChwckJzc0luZm8tPnVjTnNzIDwgd2xhbkdldFN1cHBvcnROc3MocHJBZGFwdGVyLCBwckJzc0luZm8tPnVjQnNzSW5kZXgpKQoJCXBySHRDYXAtPnUySHRDYXBJbmZvICY9IH5IVF9DQVBfSU5GT19TTV9QT1dFUl9TQVZFOy8qU2V0IGFzIHN0YXRpYyBwb3dlciBzYXZlICovCgoJcHJIdENhcC0+dWNBbXBkdVBhcmFtID0gQU1QRFVfUEFSQU1fREVGQVVMVF9WQUw7CgoJcHJTdXBNY3NTZXQgPSAmcHJIdENhcC0+clN1cE1jc1NldDsKCWthbE1lbVplcm8oKFBWT0lEKSZwclN1cE1jc1NldC0+YXVjUnhNY3NCaXRtYXNrWzBdLCBTVVBfTUNTX1JYX0JJVE1BU0tfT0NURVRfTlVNKTsKCglmb3IgKHVjSWR4ID0gMDsgdWNJZHggPCB3bGFuR2V0U3VwcG9ydE5zcyhwckFkYXB0ZXIsIHByQnNzSW5mby0+dWNCc3NJbmRleCk7IHVjSWR4KyspCgkJcHJTdXBNY3NTZXQtPmF1Y1J4TWNzQml0bWFza1t1Y0lkeF0gPSBCSVRTKDAsIDcpOwoKCS8qIHByU3VwTWNzU2V0LT5hdWNSeE1jc0JpdG1hc2tbMF0gPSBCSVRTKDAsIDcpOyAqLwoKCWlmIChmZzQwbUFsbG93ZWQpCgkJcHJTdXBNY3NTZXQtPmF1Y1J4TWNzQml0bWFza1szMiAvIDhdID0gQklUKDApOwkvKiBNQ1MzMiAqLwoJcHJTdXBNY3NTZXQtPnUyUnhIaWdoZXN0U3VwcG9ydGVkUmF0ZSA9IFNVUF9NQ1NfUlhfREVGQVVMVF9ISUdIRVNUX1JBVEU7CglwclN1cE1jc1NldC0+dTRUeFJhdGVJbmZvID0gU1VQX01DU19UWF9ERUZBVUxUX1ZBTDsKCglwckh0Q2FwLT51Mkh0RXh0ZW5kZWRDYXAgPSBIVF9FWFRfQ0FQX0RFRkFVTFRfVkFMOwoJaWYgKCFmZzQwbUFsbG93ZWQgfHwgcHJCc3NJbmZvLT5lQ3VycmVudE9QTW9kZSAhPSBPUF9NT0RFX0lORlJBU1RSVUNUVVJFKQoJCXBySHRDYXAtPnUySHRFeHRlbmRlZENhcCAmPSB+KEhUX0VYVF9DQVBfUENPIHwgSFRfRVhUX0NBUF9QQ09fVFJBTlNfVElNRV9OT05FKTsKCglwckh0Q2FwLT51NFR4QmVhbWZvcm1pbmdDYXAgPSBUWF9CRUFNRk9STUlOR19DQVBfREVGQVVMVF9WQUw7CglpZiAoKHByQWRhcHRlci0+cldpZmlWYXIudWNEYmRjTW9kZSA9PSBEQkRDX01PREVfRElTQUJMRUQpIHx8CgkJKHByQnNzSW5mby0+ZUJhbmQgPT0gQkFORF81RykpIHsKCQlpZiAoSVNfRkVBVFVSRV9FTkFCTEVEKHByQWRhcHRlci0+cldpZmlWYXIudWNTdGFIdEJmZWUpKQoJCQlwckh0Q2FwLT51NFR4QmVhbWZvcm1pbmdDYXAgPSBUWF9CRUFNRk9STUlOR19DQVBfQkZFRTsKCQlpZiAoSVNfRkVBVFVSRV9FTkFCTEVEKHByQWRhcHRlci0+cldpZmlWYXIudWNTdGFIdEJmZXIpKQoJCQlwckh0Q2FwLT51NFR4QmVhbWZvcm1pbmdDYXAgfD0gVFhfQkVBTUZPUk1JTkdfQ0FQX0JGRVI7Cgl9CgoJcHJIdENhcC0+dWNBc2VsQ2FwID0gQVNFTF9DQVBfREVGQVVMVF9WQUw7CgoJQVNTRVJUKElFX1NJWkUocHJIdENhcCkgPD0gKEVMRU1fSERSX0xFTiArIEVMRU1fTUFYX0xFTl9IVF9DQVApKTsKCglwck1zZHVJbmZvLT51MkZyYW1lTGVuZ3RoICs9IElFX1NJWkUocHJIdENhcCk7Cn0KCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIFxicmllZgoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCnN0YXRpYyBWT0lEIHJsbUZpbGxFeHRDYXBJRShQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfQlNTX0lORk9fVCBwckJzc0luZm8sIFBfTVNEVV9JTkZPX1QgcHJNc2R1SW5mbykKewoJUF9FWFRfQ0FQX1QgcHJFeHRDYXA7CglCT09MRUFOIGZnNDBtQWxsb3dlZCwgZmdBcHBlbmRWaHRDYXA7CglQX1NUQV9SRUNPUkRfVCBwclN0YVJlYzsKCglBU1NFUlQocHJBZGFwdGVyKTsKCUFTU0VSVChwck1zZHVJbmZvKTsKCglmZzQwbUFsbG93ZWQgPSBwckJzc0luZm8tPmZnQXNzb2M0MG1Cd0FsbG93ZWQ7CgoJLyogQWRkIEV4dGVuZGVkIENhcGFiaWxpdGllcyBJRSAqLwoJcHJFeHRDYXAgPSAoUF9FWFRfQ0FQX1QpCgkgICAgKCgoUFVJTlRfOCkgcHJNc2R1SW5mby0+cHJQYWNrZXQpICsgcHJNc2R1SW5mby0+dTJGcmFtZUxlbmd0aCk7CgoJcHJFeHRDYXAtPnVjSWQgPSBFTEVNX0lEX0VYVEVOREVEX0NBUDsKI2lmIDAJCQkJLyogQ0ZHX1NVUFBPUlRfSE9UU1BPVF8yXzAgKi8KCWlmIChwckFkYXB0ZXItPnByR2x1ZUluZm8tPmZnQ29ubmVjdEhTMjBBUCA9PSBUUlVFKQoJCXByRXh0Q2FwLT51Y0xlbmd0aCA9IEVMRU1fTUFYX0xFTl9FWFRfQ0FQOwoJZWxzZQojZW5kaWYKCQlwckV4dENhcC0+dWNMZW5ndGggPSAxOwoKCS8qIFJlc2V0IG1lbW9yeSAqLwoJa2FsTWVtWmVybyhwckV4dENhcC0+YXVjQ2FwYWJpbGl0aWVzLCBFTEVNX01BWF9MRU5fRVhUX0NBUCk7CgoJcHJFeHRDYXAtPmF1Y0NhcGFiaWxpdGllc1swXSA9IEVMRU1fRVhUX0NBUF9ERUZBVUxUX1ZBTDsKCglpZiAoIWZnNDBtQWxsb3dlZCkKCQlwckV4dENhcC0+YXVjQ2FwYWJpbGl0aWVzWzBdICY9IH5FTEVNX0VYVF9DQVBfMjBfNDBfQ09FWElTVF9TVVBQT1JUOwoKCWlmIChwckJzc0luZm8tPmVDdXJyZW50T1BNb2RlICE9IE9QX01PREVfSU5GUkFTVFJVQ1RVUkUpCgkJcHJFeHRDYXAtPmF1Y0NhcGFiaWxpdGllc1swXSAmPSB+RUxFTV9FWFRfQ0FQX1BTTVBfQ0FQOwoKCXByU3RhUmVjID0gY25tR2V0U3RhUmVjQnlJbmRleChwckFkYXB0ZXIsIHByTXNkdUluZm8tPnVjU3RhUmVjSW5kZXgpOwoKI2lmIENGR19TVVBQT1JUXzgwMl8xMUFDCglmZ0FwcGVuZFZodENhcCA9IEZBTFNFOwoKCS8qIENoZWNrIGFwcGVuZCBydWxlICovCglpZiAocHJBZGFwdGVyLT5yV2lmaVZhci51Y0F2YWlsYWJsZVBoeVR5cGVTZXQgJiBQSFlfVFlQRV9TRVRfODAyXzExQUMpIHsKCQkvKiBOb3RlOiBGb3IgQUlTIGNvbm5lY3Rpbmcgc3RhdGUsIHN0cnVjdHVyZSBpbiBCU1NfSU5GTyB3aWxsIG5vdCBiZSBpbml0ZWQgKi8KCQkvKiAgICAgICBTbywgd2UgY2hlY2sgU3RhUmVjIGluc3RlYWQgb2YgQnNzSW5mbyAqLwoJCWlmIChwclN0YVJlYykgewoJCQlpZiAocHJTdGFSZWMtPnVjUGh5VHlwZVNldCAmIFBIWV9UWVBFX1NFVF84MDJfMTFBQykKCQkJCWZnQXBwZW5kVmh0Q2FwID0gVFJVRTsKCQl9IGVsc2UgaWYgKChSTE1fTkVUX0lTXzExQUMocHJCc3NJbmZvKSkgJiYgKChwckJzc0luZm8tPmVDdXJyZW50T1BNb2RlID09IE9QX01PREVfSU5GUkFTVFJVQ1RVUkUpIHx8CgkJKHByQnNzSW5mby0+ZUN1cnJlbnRPUE1vZGUgPT0gT1BfTU9ERV9BQ0NFU1NfUE9JTlQpKSkKCQkJZmdBcHBlbmRWaHRDYXAgPSBUUlVFOwoJfQoKCWlmIChmZ0FwcGVuZFZodENhcCkgewoJCWlmIChwckV4dENhcC0+dWNMZW5ndGggPCBFTEVNX01BWF9MRU5fRVhUX0NBUCkKCQkJcHJFeHRDYXAtPnVjTGVuZ3RoID0gRUxFTV9NQVhfTEVOX0VYVF9DQVA7CgoJCVNFVF9FWFRfQ0FQKHByRXh0Q2FwLT5hdWNDYXBhYmlsaXRpZXMsIEVMRU1fTUFYX0xFTl9FWFRfQ0FQLCBFTEVNX0VYVF9DQVBfT1BfTU9ERV9OT1RJRklDQVRJT05fQklUKTsKCgl9CiNlbmRpZgoKI2lmIENGR19TVVBQT1JUX1BBU1NQT0lOVAoJaWYgKHByQWRhcHRlci0+cHJHbHVlSW5mby0+ZmdDb25uZWN0SFMyMEFQID09IFRSVUUpIHsKCgkJaWYgKHByRXh0Q2FwLT51Y0xlbmd0aCA8IEVMRU1fTUFYX0xFTl9FWFRfQ0FQKQoJCQlwckV4dENhcC0+dWNMZW5ndGggPSBFTEVNX01BWF9MRU5fRVhUX0NBUDsKCgkJU0VUX0VYVF9DQVAocHJFeHRDYXAtPmF1Y0NhcGFiaWxpdGllcywgRUxFTV9NQVhfTEVOX0VYVF9DQVAsIEVMRU1fRVhUX0NBUF9JTlRFUldPUktJTkdfQklUKTsKCgkJLyogRm9yIFIyIFdOTS1Ob3RpZmljYXRpb24gKi8KCQlTRVRfRVhUX0NBUChwckV4dENhcC0+YXVjQ2FwYWJpbGl0aWVzLCBFTEVNX01BWF9MRU5fRVhUX0NBUCwgRUxFTV9FWFRfQ0FQX1dOTV9OT1RJRklDQVRJT05fQklUKTsKCX0KI2VuZGlmIC8qIENGR19TVVBQT1JUX1BBU1NQT0lOVCAqLwoKCUFTU0VSVChJRV9TSVpFKHByRXh0Q2FwKSA8PSAoRUxFTV9IRFJfTEVOICsgRUxFTV9NQVhfTEVOX0VYVF9DQVApKTsKCglwck1zZHVJbmZvLT51MkZyYW1lTGVuZ3RoICs9IElFX1NJWkUocHJFeHRDYXApOwp9CgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYKKgoqIFxwYXJhbVtpbl0KKgoqIFxyZXR1cm4gbm9uZQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpzdGF0aWMgVk9JRCBybG1GaWxsSHRPcElFKFBfQURBUFRFUl9UIHByQWRhcHRlciwgUF9CU1NfSU5GT19UIHByQnNzSW5mbywgUF9NU0RVX0lORk9fVCBwck1zZHVJbmZvKQp7CglQX0lFX0hUX09QX1QgcHJIdE9wOwoJVUlOVF8xNiBpOwoKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByQnNzSW5mbyk7CglBU1NFUlQocHJNc2R1SW5mbyk7CgoJcHJIdE9wID0gKFBfSUVfSFRfT1BfVCkKCSAgICAoKChQVUlOVF84KSBwck1zZHVJbmZvLT5wclBhY2tldCkgKyBwck1zZHVJbmZvLT51MkZyYW1lTGVuZ3RoKTsKCgkvKiBBZGQgSFQgb3BlcmF0aW9uIElFICovCglwckh0T3AtPnVjSWQgPSBFTEVNX0lEX0hUX09QOwoJcHJIdE9wLT51Y0xlbmd0aCA9IHNpemVvZihJRV9IVF9PUF9UKSAtIEVMRU1fSERSX0xFTjsKCgkvKiBSSUZTIGFuZCAyMC80MCBiYW5kd2lkdGggb3BlcmF0aW9ucyBhcmUgaW5jbHVkZWQgKi8KCXBySHRPcC0+dWNQcmltYXJ5Q2hhbm5lbCA9IHByQnNzSW5mby0+dWNQcmltYXJ5Q2hhbm5lbDsKCXBySHRPcC0+dWNJbmZvMSA9IHByQnNzSW5mby0+dWNIdE9wSW5mbzE7CgoJLyogRGVjaWRlIEhUIHByb3RlY3Rpb24gbW9kZSBmaWVsZCAqLwoJaWYgKHByQnNzSW5mby0+ZUh0UHJvdGVjdE1vZGUgPT0gSFRfUFJPVEVDVF9NT0RFX05PTl9IVCkKCQlwckh0T3AtPnUySW5mbzIgPSAoVUlOVF84KSBIVF9QUk9URUNUX01PREVfTk9OX0hUOwoJZWxzZSBpZiAocHJCc3NJbmZvLT5lT2Jzc0h0UHJvdGVjdE1vZGUgPT0gSFRfUFJPVEVDVF9NT0RFX05PTl9NRU1CRVIpCgkJcHJIdE9wLT51MkluZm8yID0gKFVJTlRfOCkgSFRfUFJPVEVDVF9NT0RFX05PTl9NRU1CRVI7CgllbHNlIHsKCQkvKiBJdCBtYXkgYmUgU1lTX1BST1RFQ1RfTU9ERV9OT05FIG9yIFNZU19QUk9URUNUX01PREVfMjBNICovCgkJcHJIdE9wLT51MkluZm8yID0gKFVJTlRfOCkgcHJCc3NJbmZvLT5lSHRQcm90ZWN0TW9kZTsKCX0KCglpZiAocHJCc3NJbmZvLT5lR2ZPcGVyYXRpb25Nb2RlICE9IEdGX01PREVfTk9STUFMKSB7CgkJLyogSXQgbWF5IGJlIEdGX01PREVfUFJPVEVDVCBvciBHRl9NT0RFX0RJU0FMTE9XRUQKCQkgKiBOb3RlOiBpdCB3aWxsIGFsc28gYmUgc2V0IGluIGFkLWhvYyBuZXR3b3JrCgkJICovCgkJcHJIdE9wLT51MkluZm8yIHw9IEhUX09QX0lORk8yX05PTl9HRl9IVF9TVEFfUFJFU0VOVDsKCX0KCglpZiAoMCAvKiBSZWd1bGF0b3J5IGNsYXNzIDE2ICovICAmJgoJICAgIHByQnNzSW5mby0+ZU9ic3NIdFByb3RlY3RNb2RlID09IEhUX1BST1RFQ1RfTU9ERV9OT05fTUVNQkVSKSB7CgkJLyogKFRCRCkgSXQgaXMgSFRfUFJPVEVDVF9NT0RFX05PTl9NRU1CRVIsIHNvIHJlcXVpcmUgcHJvdGVjdGlvbgoJCSAqIGFsdGhvdWdoIGl0IGlzIHBvc3NpYmxlIHRvIGhhdmUgbm8gcHJvdGVjdGlvbiBieSBzcGVjLgoJCSAqLwoJCXBySHRPcC0+dTJJbmZvMiB8PSBIVF9PUF9JTkZPMl9PQlNTX05PTl9IVF9TVEFfUFJFU0VOVDsKCX0KCglwckh0T3AtPnUySW5mbzMgPSBwckJzc0luZm8tPnUySHRPcEluZm8zOwkvKiBUbyBkbzogaGFuZGxlIEwtU0lHIFRYT1AgKi8KCgkvKiBObyBiYXNpYyBNQ1N4IGFyZSBuZWVkZWQgdGVtcG9yYXJpbHkgKi8KCWZvciAoaSA9IDA7IGkgPCAxNjsgaSsrKQoJCXBySHRPcC0+YXVjQmFzaWNNY3NTZXRbaV0gPSAwOwoKCUFTU0VSVChJRV9TSVpFKHBySHRPcCkgPD0gKEVMRU1fSERSX0xFTiArIEVMRU1fTUFYX0xFTl9IVF9PUCkpOwoKCXByTXNkdUluZm8tPnUyRnJhbWVMZW5ndGggKz0gSUVfU0laRShwckh0T3ApOwp9CgojaWYgQ0ZHX1NVUFBPUlRfODAyXzExQUMKCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIFxicmllZiBGb3IgcHJvYmUgcmVxdWVzdCwgYXNzb2NpYXRpb24gcmVxdWVzdAoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovClZPSUQgcmxtUmVxR2VuZXJhdGVWaHRDYXBJRShQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfTVNEVV9JTkZPX1QgcHJNc2R1SW5mbykKewoJUF9CU1NfSU5GT19UIHByQnNzSW5mbzsKCVBfU1RBX1JFQ09SRF9UIHByU3RhUmVjOwoKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByTXNkdUluZm8pOwoKCXByQnNzSW5mbyA9IHByQWRhcHRlci0+YXByQnNzSW5mb1twck1zZHVJbmZvLT51Y0Jzc0luZGV4XTsKCWlmICghcHJCc3NJbmZvKQoJCXJldHVybjsKCglwclN0YVJlYyA9IGNubUdldFN0YVJlY0J5SW5kZXgocHJBZGFwdGVyLCBwck1zZHVJbmZvLT51Y1N0YVJlY0luZGV4KTsKCglpZiAoKHByQWRhcHRlci0+cldpZmlWYXIudWNBdmFpbGFibGVQaHlUeXBlU2V0ICYgUEhZX1RZUEVfU0VUXzgwMl8xMUFDKSAmJgoJICAgICghcHJTdGFSZWMgfHwgKHByU3RhUmVjLT51Y1BoeVR5cGVTZXQgJiBQSFlfVFlQRV9TRVRfODAyXzExQUMpKSkKCQlybG1GaWxsVmh0Q2FwSUUocHJBZGFwdGVyLCBwckJzc0luZm8sIHByTXNkdUluZm8pOwp9CgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYgRm9yIHByb2JlIHJlc3BvbnNlIChHTywgSUJTUykgYW5kIGFzc29jaWF0aW9uIHJlc3BvbnNlCioKKiBccGFyYW1baW5dCioKKiBccmV0dXJuIG5vbmUKKi8KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KVk9JRCBybG1Sc3BHZW5lcmF0ZVZodENhcElFKFBfQURBUFRFUl9UIHByQWRhcHRlciwgUF9NU0RVX0lORk9fVCBwck1zZHVJbmZvKQp7CglQX0JTU19JTkZPX1QgcHJCc3NJbmZvOwoJUF9TVEFfUkVDT1JEX1QgcHJTdGFSZWM7CglVSU5UXzggdWNQaHlUeXBlU2V0OwoKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByTXNkdUluZm8pOwoKCXByQnNzSW5mbyA9IHByQWRhcHRlci0+YXByQnNzSW5mb1twck1zZHVJbmZvLT51Y0Jzc0luZGV4XTsKCWlmICghcHJCc3NJbmZvKQoJCXJldHVybjsKCglpZiAoIUlTX0JTU19BQ1RJVkUocHJCc3NJbmZvKSkKCQlyZXR1cm47CgoJcHJTdGFSZWMgPSBjbm1HZXRTdGFSZWNCeUluZGV4KHByQWRhcHRlciwgcHJNc2R1SW5mby0+dWNTdGFSZWNJbmRleCk7CgoJLyogRGVjaWRlIFBIWSB0eXBlIHNldCBzb3VyY2UgKi8KCWlmIChwclN0YVJlYykgewoJCS8qIEdldCBQSFkgdHlwZSBzZXQgZnJvbSB0YXJnZXQgU1RBICovCgkJdWNQaHlUeXBlU2V0ID0gcHJTdGFSZWMtPnVjUGh5VHlwZVNldDsKCX0gZWxzZSB7CgkJLyogR2V0IFBIWSB0eXBlIHNldCBmcm9tIGN1cnJlbnQgQlNTICovCgkJdWNQaHlUeXBlU2V0ID0gcHJCc3NJbmZvLT51Y1BoeVR5cGVTZXQ7Cgl9CgoJaWYgKFJMTV9ORVRfSVNfMTFBQyhwckJzc0luZm8pICYmICh1Y1BoeVR5cGVTZXQgJiBQSFlfVFlQRV9TRVRfODAyXzExQUMpKQoJCXJsbUZpbGxWaHRDYXBJRShwckFkYXB0ZXIsIHByQnNzSW5mbywgcHJNc2R1SW5mbyk7Cgp9CgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYKKgoqIFxwYXJhbVtpbl0KKgoqIFxyZXR1cm4gbm9uZQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpWT0lEIHJsbVJzcEdlbmVyYXRlVmh0T3BJRShQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfTVNEVV9JTkZPX1QgcHJNc2R1SW5mbykKewoJUF9CU1NfSU5GT19UIHByQnNzSW5mbzsKCVBfU1RBX1JFQ09SRF9UIHByU3RhUmVjOwoJVUlOVF84IHVjUGh5VHlwZVNldDsKCglBU1NFUlQocHJBZGFwdGVyKTsKCUFTU0VSVChwck1zZHVJbmZvKTsKCglwclN0YVJlYyA9IGNubUdldFN0YVJlY0J5SW5kZXgocHJBZGFwdGVyLCBwck1zZHVJbmZvLT51Y1N0YVJlY0luZGV4KTsKCglwckJzc0luZm8gPSBwckFkYXB0ZXItPmFwckJzc0luZm9bcHJNc2R1SW5mby0+dWNCc3NJbmRleF07CglpZiAoIXByQnNzSW5mbykKCQlyZXR1cm47CgoJaWYgKCFJU19CU1NfQUNUSVZFKHByQnNzSW5mbykpCgkJcmV0dXJuOwoKCS8qIERlY2lkZSBQSFkgdHlwZSBzZXQgc291cmNlICovCglpZiAocHJTdGFSZWMpIHsKCQkvKiBHZXQgUEhZIHR5cGUgc2V0IGZyb20gdGFyZ2V0IFNUQSAqLwoJCXVjUGh5VHlwZVNldCA9IHByU3RhUmVjLT51Y1BoeVR5cGVTZXQ7Cgl9IGVsc2UgewoJCS8qIEdldCBQSFkgdHlwZSBzZXQgZnJvbSBjdXJyZW50IEJTUyAqLwoJCXVjUGh5VHlwZVNldCA9IHByQnNzSW5mby0+dWNQaHlUeXBlU2V0OwoJfQoKCWlmIChSTE1fTkVUX0lTXzExQUMocHJCc3NJbmZvKSAmJiAodWNQaHlUeXBlU2V0ICYgUEhZX1RZUEVfU0VUXzgwMl8xMUFDKSkKCQlybG1GaWxsVmh0T3BJRShwckFkYXB0ZXIsIHByQnNzSW5mbywgcHJNc2R1SW5mbyk7Cn0KCgoKLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLyohCiogXGJyaWVmIEZvciBwcm9iZSByZXF1ZXN0LCBhc3NvY2lhdGlvbiByZXF1ZXN0CioKKiBccGFyYW1baW5dCioKKiBccmV0dXJuIG5vbmUKKi8KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KVk9JRCBybG1SZXFHZW5lcmF0ZVZodE9wTm90aWZpY2F0aW9uSUUoUF9BREFQVEVSX1QgcHJBZGFwdGVyLCBQX01TRFVfSU5GT19UIHByTXNkdUluZm8pCnsKCVBfQlNTX0lORk9fVCBwckJzc0luZm87CglQX1NUQV9SRUNPUkRfVCBwclN0YVJlYzsKCglBU1NFUlQocHJBZGFwdGVyKTsKCUFTU0VSVChwck1zZHVJbmZvKTsKCglwckJzc0luZm8gPSBwckFkYXB0ZXItPmFwckJzc0luZm9bcHJNc2R1SW5mby0+dWNCc3NJbmRleF07CglpZiAoIXByQnNzSW5mbykKCQlyZXR1cm47CgoJcHJTdGFSZWMgPSBjbm1HZXRTdGFSZWNCeUluZGV4KHByQWRhcHRlciwgcHJNc2R1SW5mby0+dWNTdGFSZWNJbmRleCk7CgoJaWYgKChwckFkYXB0ZXItPnJXaWZpVmFyLnVjQXZhaWxhYmxlUGh5VHlwZVNldCAmIFBIWV9UWVBFX1NFVF84MDJfMTFBQykgJiYKCSAgICAoIXByU3RhUmVjIHx8IChwclN0YVJlYy0+dWNQaHlUeXBlU2V0ICYgUEhZX1RZUEVfU0VUXzgwMl8xMUFDKSkpCgkJcmxtRmlsbFZodE9wTm90aWZpY2F0aW9uSUUocHJBZGFwdGVyLCBwckJzc0luZm8sIHByTXNkdUluZm8sIFRSVUUpOwp9CgoKLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLyohCiogXGJyaWVmCioKKiBccGFyYW1baW5dCioKKiBccmV0dXJuIG5vbmUKKi8KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KVk9JRCBybG1Sc3BHZW5lcmF0ZVZodE9wTm90aWZpY2F0aW9uSUUoUF9BREFQVEVSX1QgcHJBZGFwdGVyLCBQX01TRFVfSU5GT19UIHByTXNkdUluZm8pCnsKCVBfQlNTX0lORk9fVCBwckJzc0luZm87CglQX1NUQV9SRUNPUkRfVCBwclN0YVJlYzsKCVVJTlRfOCB1Y1BoeVR5cGVTZXQ7CgoJQVNTRVJUKHByQWRhcHRlcik7CglBU1NFUlQocHJNc2R1SW5mbyk7CgoJcHJTdGFSZWMgPSBjbm1HZXRTdGFSZWNCeUluZGV4KHByQWRhcHRlciwgcHJNc2R1SW5mby0+dWNTdGFSZWNJbmRleCk7CgoJcHJCc3NJbmZvID0gcHJBZGFwdGVyLT5hcHJCc3NJbmZvW3ByTXNkdUluZm8tPnVjQnNzSW5kZXhdOwoJaWYgKCFwckJzc0luZm8pCgkJcmV0dXJuOwoKCWlmICghSVNfQlNTX0FDVElWRShwckJzc0luZm8pKQoJCXJldHVybjsKCgkvKiBEZWNpZGUgUEhZIHR5cGUgc2V0IHNvdXJjZSAqLwoJaWYgKHByU3RhUmVjKSB7CgkJLyogR2V0IFBIWSB0eXBlIHNldCBmcm9tIHRhcmdldCBTVEEgKi8KCQl1Y1BoeVR5cGVTZXQgPSBwclN0YVJlYy0+dWNQaHlUeXBlU2V0OwoJfSBlbHNlIHsKCQkvKiBHZXQgUEhZIHR5cGUgc2V0IGZyb20gY3VycmVudCBCU1MgKi8KCQl1Y1BoeVR5cGVTZXQgPSBwckJzc0luZm8tPnVjUGh5VHlwZVNldDsKCX0KCglpZiAoUkxNX05FVF9JU18xMUFDKHByQnNzSW5mbykgJiYgKHVjUGh5VHlwZVNldCAmIFBIWV9UWVBFX1NFVF84MDJfMTFBQykpCgkJcmxtRmlsbFZodE9wTm90aWZpY2F0aW9uSUUocHJBZGFwdGVyLCBwckJzc0luZm8sIHByTXNkdUluZm8sIEZBTFNFKTsKfQoKLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLyohCiogXGJyaWVmCiogYWRkIFZIVCBvcGVyYXRpb24gbm90aWZpY2F0aW9uIElFIGZvciBWSFQtQlc0MCBjYXNlIHNwZWNpZmljCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCnN0YXRpYyBWT0lEIHJsbUZpbGxWaHRPcE5vdGlmaWNhdGlvbklFKFBfQURBUFRFUl9UIHByQWRhcHRlciwgUF9CU1NfSU5GT19UIHByQnNzSW5mbywKCQlQX01TRFVfSU5GT19UIHByTXNkdUluZm8sIEJPT0xFQU4gZmdJc01heENhcCkKewoJUF9JRV9WSFRfT1BfTU9ERV9OT1RJRklDQVRJT05fVCBwclZodE9wTW9kZTsKCVVJTlRfOCB1Y01heEJ3OwoKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByQnNzSW5mbyk7CglBU1NFUlQocHJNc2R1SW5mbyk7CgoJcHJWaHRPcE1vZGUgPSAoUF9JRV9WSFRfT1BfTU9ERV9OT1RJRklDQVRJT05fVCkKCSAgICAoKChQVUlOVF84KSBwck1zZHVJbmZvLT5wclBhY2tldCkgKyBwck1zZHVJbmZvLT51MkZyYW1lTGVuZ3RoKTsKCglrYWxNZW1aZXJvKChQVk9JRCkgcHJWaHRPcE1vZGUsIHNpemVvZihJRV9WSFRfT1BfTU9ERV9OT1RJRklDQVRJT05fVCkpOwoKCXByVmh0T3BNb2RlLT51Y0lkID0gRUxFTV9JRF9PUF9NT0RFOwoJcHJWaHRPcE1vZGUtPnVjTGVuZ3RoID0gc2l6ZW9mKElFX1ZIVF9PUF9NT0RFX05PVElGSUNBVElPTl9UKSAtIEVMRU1fSERSX0xFTjsKCglEQkdMT0coUkxNLCBJTkZPLCAicmxtRmlsbFZodE9wTm90aWZpY2F0aW9uSUUoJWQpICV1ICV1XG4iLAoJCXByQnNzSW5mby0+dWNCc3NJbmRleCwgZmdJc01heENhcCwgcHJCc3NJbmZvLT51Y05zcyk7CgoJaWYgKGZnSXNNYXhDYXApIHsKCgkJdWNNYXhCdyA9IGNubUdldEJzc01heEJ3KHByQWRhcHRlciwgcHJCc3NJbmZvLT51Y0Jzc0luZGV4KTsKCgkJLypoYW5kbGUgODBQODAgY2FzZSovCgkJaWYgKHVjTWF4QncgPj0gTUFYX0JXXzE2ME1IWikKCQkJdWNNYXhCdyA9IE1BWF9CV18xNjBNSFo7CgoJCXByVmh0T3BNb2RlLT51Y09wZXJhdGluZ01vZGUgfD0gdWNNYXhCdzsKCgkJcHJWaHRPcE1vZGUtPnVjT3BlcmF0aW5nTW9kZSB8PQoJCQkoKChwckJzc0luZm8tPnVjTnNzLTEpIDw8IFZIVF9PUF9NT0RFX1JYX05TU19PRkZTRVQpICYgVkhUX09QX01PREVfUlhfTlNTKTsKCgl9IGVsc2UgewoKCQlzd2l0Y2ggKHByQnNzSW5mby0+dWNWaHRDaGFubmVsV2lkdGgpIHsKCQljYXNlIFZIVF9PUF9DSEFOTkVMX1dJRFRIXzgwUDgwOgoJCQl1Y01heEJ3ID0gTUFYX0JXXzE2ME1IWjsKCQkJYnJlYWs7CgoJCWNhc2UgVkhUX09QX0NIQU5ORUxfV0lEVEhfMTYwOgoJCQl1Y01heEJ3ID0gTUFYX0JXXzE2ME1IWjsKCQkJYnJlYWs7CgoJCWNhc2UgVkhUX09QX0NIQU5ORUxfV0lEVEhfODA6CgkJCXVjTWF4QncgPSBNQVhfQldfODBNSFo7CgkJCWJyZWFrOwoKCQljYXNlIFZIVF9PUF9DSEFOTkVMX1dJRFRIXzIwXzQwOgoJCQl7CgkJCQl1Y01heEJ3ID0gTUFYX0JXXzIwTUhaOwoKCQkJCWlmIChwckJzc0luZm8tPmVCc3NTQ08gIT0gQ0hOTF9FWFRfU0NOKQoJCQkJCXVjTWF4QncgPSBNQVhfQldfNDBNSFo7CgkJCX0KCQkJYnJlYWs7CgoJCWRlZmF1bHQ6CgkJCS8qVkhUIGRlZmF1bHQgSUUgc2hvdWxkIHN1cHBvcnQgQlcgODAqLwoJCQl1Y01heEJ3ID0gTUFYX0JXXzgwTUhaOwoJCQlicmVhazsKCQl9CgoJCXByVmh0T3BNb2RlLT51Y09wZXJhdGluZ01vZGUgfD0gdWNNYXhCdzsKCgkJcHJWaHRPcE1vZGUtPnVjT3BlcmF0aW5nTW9kZSB8PSAoKChwckJzc0luZm8tPnVjTnNzLTEpCgkJCTw8IFZIVF9PUF9NT0RFX1JYX05TU19PRkZTRVQpICYgVkhUX09QX01PREVfUlhfTlNTKTsKCX0KCgoJcHJNc2R1SW5mby0+dTJGcmFtZUxlbmd0aCArPSBJRV9TSVpFKHByVmh0T3BNb2RlKTsKCn0KCgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYKKgoqIFxwYXJhbVtpbl0KKgoqIFxyZXR1cm4gbm9uZQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpzdGF0aWMgVk9JRCBybG1GaWxsVmh0Q2FwSUUoUF9BREFQVEVSX1QgcHJBZGFwdGVyLCBQX0JTU19JTkZPX1QgcHJCc3NJbmZvLCBQX01TRFVfSU5GT19UIHByTXNkdUluZm8pCnsKCVBfSUVfVkhUX0NBUF9UIHByVmh0Q2FwOwoJUF9WSFRfU1VQUE9SVEVEX01DU19GSUVMRCBwclZodFN1cHBvcnRlZE1jc1NldDsKCVVJTlRfOCBpOwoJVUlOVF84IHVjTWF4Qnc7CglQX1NUQV9SRUNPUkRfVCBwclN0YVJlYzsKCglBU1NFUlQocHJBZGFwdGVyKTsKCUFTU0VSVChwckJzc0luZm8pOwoJQVNTRVJUKHByTXNkdUluZm8pOwoKCXByVmh0Q2FwID0gKFBfSUVfVkhUX0NBUF9UKQoJICAgICgoKFBVSU5UXzgpIHByTXNkdUluZm8tPnByUGFja2V0KSArIHByTXNkdUluZm8tPnUyRnJhbWVMZW5ndGgpOwoKCXByVmh0Q2FwLT51Y0lkID0gRUxFTV9JRF9WSFRfQ0FQOwoJcHJWaHRDYXAtPnVjTGVuZ3RoID0gc2l6ZW9mKElFX1ZIVF9DQVBfVCkgLSBFTEVNX0hEUl9MRU47CglwclZodENhcC0+dTRWaHRDYXBJbmZvID0gVkhUX0NBUF9JTkZPX0RFRkFVTFRfVkFMOwoKCXVjTWF4QncgPSBjbm1HZXRCc3NNYXhCdyhwckFkYXB0ZXIsIHByQnNzSW5mby0+dWNCc3NJbmRleCk7CgoJcHJWaHRDYXAtPnU0Vmh0Q2FwSW5mbyB8PSAocHJBZGFwdGVyLT5yV2lmaVZhci51Y1J4TWF4TXBkdUxlbiAmIFZIVF9DQVBfSU5GT19NQVhfTVBEVV9MRU5fTUFTSyk7CgoJaWYgKHVjTWF4QncgPT0gTUFYX0JXXzE2ME1IWikKCQlwclZodENhcC0+dTRWaHRDYXBJbmZvIHw9IFZIVF9DQVBfSU5GT19NQVhfU1VQX0NIQU5ORUxfV0lEVEhfU0VUXzE2MDsKCWVsc2UgaWYgKHVjTWF4QncgPT0gTUFYX0JXXzgwXzgwX01IWikKCQlwclZodENhcC0+dTRWaHRDYXBJbmZvIHw9IFZIVF9DQVBfSU5GT19NQVhfU1VQX0NIQU5ORUxfV0lEVEhfU0VUXzE2MF84MFA4MDsKCglpZiAoSVNfRkVBVFVSRV9FTkFCTEVEKHByQWRhcHRlci0+cldpZmlWYXIudWNTdGFWaHRCZmVlKSkgewoJCXByVmh0Q2FwLT51NFZodENhcEluZm8gfD0gRklFTERfVkhUX0NBUF9JTkZPX0JGRUU7CiNpZiBDRkdfU1VQUE9SVF9CRkVFCgkJcHJTdGFSZWMgPSBjbm1HZXRTdGFSZWNCeUluZGV4KHByQWRhcHRlciwgcHJNc2R1SW5mby0+dWNTdGFSZWNJbmRleCk7CgoJCWlmIChwclN0YVJlYykgewoJCQlpZiAoKHByU3RhUmVjLT51Y1ZodENhcE51bVNvdW5kaW5nRGltZW5zaW9ucyA+IDApICYmCgkJCQkocHJTdGFSZWMtPnVjVmh0Q2FwTnVtU291bmRpbmdEaW1lbnNpb25zIDwgVkhUX0NBUF9JTkZPX0JFQU1GT1JNRUVfU1RTX0NBUF9NQVgpKSB7CgkJCQlwclZodENhcC0+dTRWaHRDYXBJbmZvIHw9ICgoKFVJTlRfMzIpcHJTdGFSZWMtPnVjVmh0Q2FwTnVtU291bmRpbmdEaW1lbnNpb25zKSA8PAoJCQkJVkhUX0NBUF9JTkZPX0NPTVBSRVNTRURfU1RFRVJJTkdfTlVNQkVSX09GX0JFQU1GT1JNRVJfQU5URU5OQVNfU1VQUE9FUlRFRF9PRkZTRVQpOwoJCQkJREJHTE9HKFJMTSwgSU5GTywgIlNldCBWSFQgQ2FwIEJGRUUgU1RTIENBUD0lZFxuIiwKCQkJCQlwclN0YVJlYy0+dWNWaHRDYXBOdW1Tb3VuZGluZ0RpbWVuc2lvbnMpOwoJCQl9IGVsc2UgewoJCQkJcHJWaHRDYXAtPnU0Vmh0Q2FwSW5mbyB8PQoJCQkJCVZIVF9DQVBfSU5GT19DT01QUkVTU0VEX1NURUVSSU5HX05VTUJFUl9PRl9CRUFNRk9STUVSX0FOVEVOTkFTXzRfU1VQUE9FUlRFRDsKCQkJCURCR0xPRyhSTE0sIElORk8sICJTZXQgVkhUIENhcCBCRkVFIFNUUyBDQVA9JWRcbiIsIFZIVF9DQVBfSU5GT19CRUFNRk9STUVFX1NUU19DQVBfTUFYKTsKCQkJfQoJCX0gZWxzZSB7CgkJCS8qRFVUIHJvbGUgaXMgQVAgT1IgR08gd2lodCBWSFQgY2FwYWJpbHRpeSBhbmQgZ2VuZXJhdGluZyBCQ04gVkhUIElFIHdpdGggcmxtRmlsbFZodENhcElFIGFwaSovCgkJCXByVmh0Q2FwLT51NFZodENhcEluZm8gfD0KCQkJCQlWSFRfQ0FQX0lORk9fQ09NUFJFU1NFRF9TVEVFUklOR19OVU1CRVJfT0ZfQkVBTUZPUk1FUl9BTlRFTk5BU180X1NVUFBPRVJURUQ7CgkJfQoJCS8qIERCR0xPRyhSTE0sIElORk8sICJWaHRDYXBJbmZvPSV4XG4iLCBwclZodENhcC0+dTRWaHRDYXBJbmZvKTsgKi8KI2VuZGlmCgkJaWYgKElTX0ZFQVRVUkVfRU5BQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjU3RhVmh0TXVCZmVlKSkKCQkJcHJWaHRDYXAtPnU0Vmh0Q2FwSW5mbyB8PSBWSFRfQ0FQX0lORk9fTVVfQkVBTUZPTUVFX0NBUEFCTEU7Cgl9CgoJaWYgKElTX0ZFQVRVUkVfRU5BQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjU3RhVmh0QmZlcikpCgkJcHJWaHRDYXAtPnU0Vmh0Q2FwSW5mbyB8PSBGSUVMRF9WSFRfQ0FQX0lORk9fQkZFUjsKCglpZiAoSVNfRkVBVFVSRV9FTkFCTEVEKHByQWRhcHRlci0+cldpZmlWYXIudWNSeFNob3J0R0kpKSB7CgkJcHJWaHRDYXAtPnU0Vmh0Q2FwSW5mbyB8PSBWSFRfQ0FQX0lORk9fU0hPUlRfR0lfODA7CgoJCWlmICh1Y01heEJ3ID49IE1BWF9CV18xNjBNSFopCgkJCXByVmh0Q2FwLT51NFZodENhcEluZm8gfD0gVkhUX0NBUF9JTkZPX1NIT1JUX0dJXzE2MF84MFA4MDsKCX0KCglpZiAoSVNfRkVBVFVSRV9FTkFCTEVEKHByQWRhcHRlci0+cldpZmlWYXIudWNSeExkcGMpKQoJCXByVmh0Q2FwLT51NFZodENhcEluZm8gfD0gVkhUX0NBUF9JTkZPX1JYX0xEUEM7CgoJaWYgKElTX0ZFQVRVUkVfRU5BQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjUnhTdGJjKSkgewoJCVVJTlRfOCB0ZW1wUnhTdGJjTnNzOwoKCQlpZiAocHJBZGFwdGVyLT5yV2lmaVZhci51NFN3VGVzdE1vZGUgPT0gRU5VTV9TV19URVNUX01PREVfU0lHTUFfQUMpIHsKCQkJdGVtcFJ4U3RiY05zcyA9IDE7CgkJCURCR0xPRyhSTE0sIElORk8sICJTZXQgUnhTdGJjTnNzIHRvIDEgZm9yIDExYWMgY2VydGlmaWNhdGlvbi5cbiIpOwoJCX0gZWxzZSB7CgkJCXRlbXBSeFN0YmNOc3MgPSBwckFkYXB0ZXItPnJXaWZpVmFyLnVjUnhTdGJjTnNzOwoJCQl0ZW1wUnhTdGJjTnNzID0gKHRlbXBSeFN0YmNOc3MgPiB3bGFuR2V0U3VwcG9ydE5zcyhwckFkYXB0ZXIsIHByQnNzSW5mby0+dWNCc3NJbmRleCkpID8KCQkJCXdsYW5HZXRTdXBwb3J0TnNzKHByQWRhcHRlciwgcHJCc3NJbmZvLT51Y0Jzc0luZGV4KSA6ICh0ZW1wUnhTdGJjTnNzKTsKCQkJaWYgKHRlbXBSeFN0YmNOc3MgIT0gcHJBZGFwdGVyLT5yV2lmaVZhci51Y1J4U3RiY05zcykgewoJCQkJREJHTE9HKFJMTSwgV0FSTiwgIkFwcGx5IE5zczolZCBhcyBSeFN0YmNOc3MgaW4gVkhUIENhcCIsCgkJCQkJd2xhbkdldFN1cHBvcnROc3MocHJBZGFwdGVyLCBwckJzc0luZm8tPnVjQnNzSW5kZXgpKTsKCQkJCURCR0xPRyhSTE0sIFdBUk4sICJkdWUgdG8gc2V0IFJ4U3RiY05zcyBtb3JlIHRoYW4gTnNzIGlzIG5vdCBhcHByb3ByaWF0ZS5cbiIpOwoJCQl9CgkJfQoJCXByVmh0Q2FwLT51NFZodENhcEluZm8gfD0gKCh0ZW1wUnhTdGJjTnNzIDw8IFZIVF9DQVBfSU5GT19SWF9TVEJDX09GRlNFVCkgJiBWSFRfQ0FQX0lORk9fUlhfU1RCQ19NQVNLKTsKCX0KCglpZiAoSVNfRkVBVFVSRV9FTkFCTEVEKHByQWRhcHRlci0+cldpZmlWYXIudWNUeFN0YmMpKQoJCXByVmh0Q2FwLT51NFZodENhcEluZm8gfD0gVkhUX0NBUF9JTkZPX1RYX1NUQkM7CgoJLypzZXQgTUNTIG1hcCAqLwoJcHJWaHRTdXBwb3J0ZWRNY3NTZXQgPSAmcHJWaHRDYXAtPnJWaHRTdXBwb3J0ZWRNY3NTZXQ7CglrYWxNZW1aZXJvKChQVk9JRCkgcHJWaHRTdXBwb3J0ZWRNY3NTZXQsIHNpemVvZihWSFRfU1VQUE9SVEVEX01DU19GSUVMRCkpOwoKCWZvciAoaSA9IDA7IGkgPCA4OyBpKyspIHsKCQlVSU5UXzggdWNPZmZzZXQgPSBpICogMjsKCQlVSU5UXzggdWNNY3NNYXA7CgoJCWlmIChpIDwgd2xhbkdldFN1cHBvcnROc3MocHJBZGFwdGVyLCBwckJzc0luZm8tPnVjQnNzSW5kZXgpKQoJCQl1Y01jc01hcCA9IFZIVF9DQVBfSU5GT19NQ1NfTUFQX01DUzk7CgkJZWxzZQoJCQl1Y01jc01hcCA9IFZIVF9DQVBfSU5GT19NQ1NfTk9UX1NVUFBPUlRFRDsKCgkJcHJWaHRTdXBwb3J0ZWRNY3NTZXQtPnUyUnhNY3NNYXAgfD0gKHVjTWNzTWFwIDw8IHVjT2Zmc2V0KTsKCQlwclZodFN1cHBvcnRlZE1jc1NldC0+dTJUeE1jc01hcCB8PSAodWNNY3NNYXAgPDwgdWNPZmZzZXQpOwoJfQoKI2lmIDAKCWZvciAoaSA9IDA7IGkgPCB3bGFuR2V0U3VwcG9ydE5zcyhwckFkYXB0ZXIsIHByQnNzSW5mby0+dWNCc3NJbmRleCk7IGkrKykgewoJCVVJTlRfOCB1Y09mZnNldCA9IGkgKiAyOwoKCQlwclZodFN1cHBvcnRlZE1jc1NldC0+dTJSeE1jc01hcCAmPQoJCQkoKFZIVF9DQVBfSU5GT19NQ1NfTUFQX01DUzkgPDwgdWNPZmZzZXQpICYgQklUUyh1Y09mZnNldCwgdWNPZmZzZXQgKyAxKSk7CgkJcHJWaHRTdXBwb3J0ZWRNY3NTZXQtPnUyVHhNY3NNYXAgJj0KCQkJKChWSFRfQ0FQX0lORk9fTUNTX01BUF9NQ1M5IDw8IHVjT2Zmc2V0KSAmIEJJVFModWNPZmZzZXQsIHVjT2Zmc2V0ICsgMSkpOwoJfQojZW5kaWYKCglwclZodFN1cHBvcnRlZE1jc1NldC0+dTJSeEhpZ2hlc3RTdXBwb3J0ZWREYXRhUmF0ZSA9IFZIVF9DQVBfSU5GT19ERUZBVUxUX0hJR0hFU1RfREFUQV9SQVRFOwoJcHJWaHRTdXBwb3J0ZWRNY3NTZXQtPnUyVHhIaWdoZXN0U3VwcG9ydGVkRGF0YVJhdGUgPSBWSFRfQ0FQX0lORk9fREVGQVVMVF9ISUdIRVNUX0RBVEFfUkFURTsKCglBU1NFUlQoSUVfU0laRShwclZodENhcCkgPD0gKEVMRU1fSERSX0xFTiArIEVMRU1fTUFYX0xFTl9WSFRfQ0FQKSk7CgoJcHJNc2R1SW5mby0+dTJGcmFtZUxlbmd0aCArPSBJRV9TSVpFKHByVmh0Q2FwKTsKCn0KCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIFxicmllZgoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovClZPSUQgcmxtRmlsbFZodE9wSUUoUF9BREFQVEVSX1QgcHJBZGFwdGVyLCBQX0JTU19JTkZPX1QgcHJCc3NJbmZvLCBQX01TRFVfSU5GT19UIHByTXNkdUluZm8pCnsKCVBfSUVfVkhUX09QX1QgcHJWaHRPcDsKCglBU1NFUlQocHJBZGFwdGVyKTsKCUFTU0VSVChwckJzc0luZm8pOwoJQVNTRVJUKHByTXNkdUluZm8pOwoKCXByVmh0T3AgPSAoUF9JRV9WSFRfT1BfVCkKCSAgICAoKChQVUlOVF84KSBwck1zZHVJbmZvLT5wclBhY2tldCkgKyBwck1zZHVJbmZvLT51MkZyYW1lTGVuZ3RoKTsKCgkvKiBBZGQgSFQgb3BlcmF0aW9uIElFICovCglwclZodE9wLT51Y0lkID0gRUxFTV9JRF9WSFRfT1A7CglwclZodE9wLT51Y0xlbmd0aCA9IHNpemVvZihJRV9WSFRfT1BfVCkgLSBFTEVNX0hEUl9MRU47CgoJQVNTRVJUKElFX1NJWkUocHJWaHRPcCkgPD0gKEVMRU1fSERSX0xFTiArIEVMRU1fTUFYX0xFTl9WSFRfT1ApKTsKCglwclZodE9wLT51Y1ZodE9wZXJhdGlvblswXSA9IHByQnNzSW5mby0+dWNWaHRDaGFubmVsV2lkdGg7CS8qIChVSU5UOClWSFRfT1BfQ0hBTk5FTF9XSURUSF84MDsgKi8KCXByVmh0T3AtPnVjVmh0T3BlcmF0aW9uWzFdID0gcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxGcmVxdWVuY3lTMTsKCXByVmh0T3AtPnVjVmh0T3BlcmF0aW9uWzJdID0gcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxGcmVxdWVuY3lTMjsKCiNpZiAwCglpZiAoY25tR2V0QnNzTWF4QncocHJBZGFwdGVyLCBwckJzc0luZm8tPnVjQnNzSW5kZXgpIDwgTUFYX0JXXzgwTUhaKSB7CgkJcHJWaHRPcC0+dWNWaHRPcGVyYXRpb25bMF0gPSBWSFRfT1BfQ0hBTk5FTF9XSURUSF8yMF80MDsKCQlwclZodE9wLT51Y1ZodE9wZXJhdGlvblsxXSA9IDA7CgkJcHJWaHRPcC0+dWNWaHRPcGVyYXRpb25bMl0gPSAwOwoJfSBlbHNlIGlmIChjbm1HZXRCc3NNYXhCdyhwckFkYXB0ZXIsIHByQnNzSW5mby0+dWNCc3NJbmRleCkgPT0gTUFYX0JXXzgwTUhaKSB7CgkJcHJWaHRPcC0+dWNWaHRPcGVyYXRpb25bMF0gPSBWSFRfT1BfQ0hBTk5FTF9XSURUSF84MDsKCQlwclZodE9wLT51Y1ZodE9wZXJhdGlvblsxXSA9IG5pY0dldFZodFMxKHByQnNzSW5mby0+dWNQcmltYXJ5Q2hhbm5lbCk7CgkJcHJWaHRPcC0+dWNWaHRPcGVyYXRpb25bMl0gPSAwOwoJfSBlbHNlIHsKCQkvKiBUT0RPOiBCVzgwICsgODAvMTYwIHN1cHBvcnQgKi8KCX0KI2VuZGlmCgoJcHJWaHRPcC0+dTJWaHRCYXNpY01jc1NldCA9IHByQnNzSW5mby0+dTJWaHRCYXNpY01jc1NldDsKCglwck1zZHVJbmZvLT51MkZyYW1lTGVuZ3RoICs9IElFX1NJWkUocHJWaHRPcCk7Cn0KCiNlbmRpZgoKI2lmIENGR19TVVBQT1JUX0NBTF9SRVNVTFRfQkFDS1VQX1RPX0hPU1QKV0xBTl9TVEFUVVMgcmxtQ2FsQmFja3VwKAoJUF9BREFQVEVSX1QgcHJBZGFwdGVyLAoJVUlOVF84CQl1Y1JlYXNvbiwKCVVJTlRfOAkJdWNBY3Rpb24sCglVSU5UXzgJCXVjUm9tUmFtCgkpCnsKCVdMQU5fU1RBVFVTIHJTdGF0dXMgPSBXTEFOX1NUQVRVU19GQUlMVVJFOwoJUF9HTFVFX0lORk9fVCBwckdsdWVJbmZvID0gTlVMTDsKCVBBUkFNX0NBTF9CQUNLVVBfU1RSVUNUX1YyX1QJckNhbEJhY2t1cERhdGFWMjsKCVVJTlRfMzIgdTRCdWZMZW4gPSAwOwoKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByQWRhcHRlci0+cHJHbHVlSW5mbyk7CgoJcHJHbHVlSW5mbyA9IHByQWRhcHRlci0+cHJHbHVlSW5mbzsKCglyQ2FsQmFja3VwRGF0YVYyLnVjUmVhc29uID0gdWNSZWFzb247CglyQ2FsQmFja3VwRGF0YVYyLnVjQWN0aW9uID0gdWNBY3Rpb247CglyQ2FsQmFja3VwRGF0YVYyLnVjTmVlZFJlc3AgPSAxOwoJckNhbEJhY2t1cERhdGFWMi51Y0ZyYWdOdW0gPSAwOwoJckNhbEJhY2t1cERhdGFWMi51Y1JvbVJhbSA9IHVjUm9tUmFtOwoJckNhbEJhY2t1cERhdGFWMi51NFRoZXJtYWxWYWx1ZSA9IDA7CglyQ2FsQmFja3VwRGF0YVYyLnU0QWRkcmVzcyA9IDA7CglyQ2FsQmFja3VwRGF0YVYyLnU0TGVuZ3RoID0gMDsKCXJDYWxCYWNrdXBEYXRhVjIudTRSZW1haW5MZW5ndGggPSAwOwoKCWlmICh1Y1JlYXNvbiA9PSAwICYmIHVjQWN0aW9uID09IDApIHsKCQlEQkdMT0coUkZURVNULCBJTkZPLCAiUkxNIENNRCA6IEdldCBUaGVybWFsIFRlbXAgZnJvbSBGVy5cbiIpOwoJCS8qIFN0ZXAgMSA6IEdldCBUaGVybWFsIFRlbXAgZnJvbSBGVyAqLwoKCQlyU3RhdHVzID0ga2FsSW9jdGwocHJHbHVlSW5mbywKCQkJCQl3bGFub2lkUXVlcnlDYWxCYWNrdXBWMiwKCQkJCQkmckNhbEJhY2t1cERhdGFWMiwKCQkJCQlzaXplb2YoUEFSQU1fQ0FMX0JBQ0tVUF9TVFJVQ1RfVjJfVCksCgkJCQkJVFJVRSwKCQkJCQlUUlVFLAoJCQkJCVRSVUUsCgkJCQkJJnU0QnVmTGVuKTsKCgkJaWYgKHJTdGF0dXMgIT0gV0xBTl9TVEFUVVNfU1VDQ0VTUykgewoJCQlEQkdMT0coUkZURVNULCBJTkZPLAoJCQkJIlJMTSBDTUQgOiBHZXQgVGhlcm1hbCBUZW1wIGZyb20gRlcgUmV0dXJuIEZhaWwgKDB4JTA4eCkhISEhISEhISEhIVxuIiwgclN0YXR1cyk7CgkJCXJldHVybiByU3RhdHVzOwoJCX0KCgkJREJHTE9HKFJGVEVTVCwgSU5GTywgIkNNRCA6IEdldCBUaGVybWFsIFRlbXAgKCVkKSBmcm9tIEZXLiBGaW5pc2ghISEhISEhISEhIVxuIiwKCQkJckNhbEJhY2t1cERhdGFWMi51NFRoZXJtYWxWYWx1ZSk7Cgl9IGVsc2UgaWYgKHVjUmVhc29uID09IDEgJiYgdWNBY3Rpb24gPT0gMikgewoJCURCR0xPRyhSRlRFU1QsIElORk8sICJSTE0gQ01EIDogVHJpZ2dlciBGVyBEbyBBbGwgQ2FsLlxuIik7CgkJLyogU3RlcCAyIDogVHJpZ2dlciBBbGwgQ2FsIEZ1bmN0aW9uICovCgoJCXJTdGF0dXMgPSBrYWxJb2N0bChwckdsdWVJbmZvLAoJCQkJCXdsYW5vaWRTZXRDYWxCYWNrdXAsCgkJCQkJJnJDYWxCYWNrdXBEYXRhVjIsCgkJCQkJc2l6ZW9mKFBBUkFNX0NBTF9CQUNLVVBfU1RSVUNUX1YyX1QpLAoJCQkJCUZBTFNFLAoJCQkJCUZBTFNFLAoJCQkJCVRSVUUsCgkJCQkJJnU0QnVmTGVuKTsKCgkJaWYgKHJTdGF0dXMgIT0gV0xBTl9TVEFUVVNfU1VDQ0VTUykgewoJCQlEQkdMT0coUkZURVNULCBJTkZPLAoJCQkJIlJMTSBDTUQgOiBUcmlnZ2VyIEZXIERvIEFsbCBDYWwgUmV0dXJuIEZhaWwgKDB4JTA4eCkhISEhISEhISEhIVxuIiwgclN0YXR1cyk7CgkJCXJldHVybiByU3RhdHVzOwoJCX0KCgkJREJHTE9HKFJGVEVTVCwgSU5GTywgIkNNRCA6IFRyaWdnZXIgRlcgRG8gQWxsIENhbC4gRmluaXNoISEhISEhISEhISFcbiIpOwoJfSBlbHNlIGlmICh1Y1JlYXNvbiA9PSAwICYmIHVjQWN0aW9uID09IDEpIHsKCQlEQkdMT0coUkZURVNULCBJTkZPLCAiUkxNIENNRCA6IEdldCBDYWwgRGF0YSAoJXMpIFNpemUgZnJvbSBGVy5cbiIsCgkJCXVjUm9tUmFtID09IDAgPyAiUk9NIiA6ICJSQU0iKTsKCQkvKiBTdGVwIDMgOiBHZXQgQ2FsIERhdGEgU2l6ZSBmcm9tIEZXICovCgoJCXJTdGF0dXMgPSBrYWxJb2N0bChwckdsdWVJbmZvLAoJCQkJCXdsYW5vaWRRdWVyeUNhbEJhY2t1cFYyLAoJCQkJCSZyQ2FsQmFja3VwRGF0YVYyLAoJCQkJCXNpemVvZihQQVJBTV9DQUxfQkFDS1VQX1NUUlVDVF9WMl9UKSwKCQkJCQlUUlVFLAoJCQkJCVRSVUUsCgkJCQkJVFJVRSwKCQkJCQkmdTRCdWZMZW4pOwoKCQlpZiAoclN0YXR1cyAhPSBXTEFOX1NUQVRVU19TVUNDRVNTKSB7CgkJCURCR0xPRyhSRlRFU1QsIElORk8sCgkJCQkiUkxNIENNRCA6IEdldCBDYWwgRGF0YSAoJXMpIFNpemUgZnJvbSBGVyBSZXR1cm4gRmFpbCAoMHglMDh4KSEhISEhISEhISEhXG4iLAoJCQkJdWNSb21SYW0gPT0gMCA/ICJST00iIDogIlJBTSIsIHJTdGF0dXMpOwoJCQlyZXR1cm4gclN0YXR1czsKCQl9CgoJCURCR0xPRyhSRlRFU1QsIElORk8sICJDTUQgOiBHZXQgQ2FsIERhdGEgKCVzKSBTaXplIGZyb20gRlcuIEZpbmlzaCEhISEhISEhISEhXG4iLAoJCQl1Y1JvbVJhbSA9PSAwID8gIlJPTSIgOiAiUkFNIik7Cgl9IGVsc2UgaWYgKHVjUmVhc29uID09IDIgJiYgdWNBY3Rpb24gPT0gNCkgewoJCURCR0xPRyhSRlRFU1QsIElORk8sICJSTE0gQ01EIDogR2V0IENhbCBEYXRhIGZyb20gRlcgKCVzKS4gU3RhcnQhISEhISEhISEhISEhISEhXG4iLAoJCQl1Y1JvbVJhbSA9PSAwID8gIlJPTSIgOiAiUkFNIik7CgkJREJHTE9HKFJGVEVTVCwgSU5GTywgIlRoZXJtYWwgVGVtcCA9ICVkXG4iLCBnX3JCYWNrdXBDYWxEYXRhQWxsVjIudTRUaGVybWFsSW5mbyk7CgkJLyogU3RlcCA0IDogR2V0IENhbCBEYXRhIGZyb20gRlcgKi8KCgkJclN0YXR1cyA9IGthbElvY3RsKHByR2x1ZUluZm8sCgkJCQkJd2xhbm9pZFF1ZXJ5Q2FsQmFja3VwVjIsCgkJCQkJJnJDYWxCYWNrdXBEYXRhVjIsCgkJCQkJc2l6ZW9mKFBBUkFNX0NBTF9CQUNLVVBfU1RSVUNUX1YyX1QpLAoJCQkJCVRSVUUsCgkJCQkJVFJVRSwKCQkJCQlUUlVFLAoJCQkJCSZ1NEJ1Zkxlbik7CgkJaWYgKHJTdGF0dXMgIT0gV0xBTl9TVEFUVVNfU1VDQ0VTUykgewoJCQlEQkdMT0coUkZURVNULCBJTkZPLAoJCQkJIlJMTSBDTUQgOiBHZXQgQ2FsIERhdGEgKCVzKSBTaXplIGZyb20gRlcgUmV0dXJuIEZhaWwgKDB4JTA4eCkhISEhISEhISEhIVxuIiwKCQkJCXVjUm9tUmFtID09IDAgPyAiUk9NIiA6ICJSQU0iLCByU3RhdHVzKTsKCQkJcmV0dXJuIHJTdGF0dXM7CgkJfQoKCQlEQkdMT0coUkZURVNULCBJTkZPLCAiQ01EIDogR2V0IENhbCBEYXRhIGZyb20gRlcgKCVzKS4gRmluaXNoISEhISEhISEhISFcbiIsCgkJCXVjUm9tUmFtID09IDAgPyAiUk9NIiA6ICJSQU0iKTsKCgkJaWYgKHVjUm9tUmFtID09IDApIHsKCQkJREJHTE9HKFJGVEVTVCwgSU5GTywKCQkJCSJDaGVjayBzb21lIG9mIGVsZW1lbnRzICgweCUwOHgpLCAoMHglMDh4KSwgKDB4JTA4eCksICgweCUwOHgpLCAoMHglMDh4KVxuIiwKCQkJCWdfckJhY2t1cENhbERhdGFBbGxWMi5hdTRSb21DYWxEYXRhWzY3MF0sIGdfckJhY2t1cENhbERhdGFBbGxWMi5hdTRSb21DYWxEYXRhWzY3MV0sCgkJCQlnX3JCYWNrdXBDYWxEYXRhQWxsVjIuYXU0Um9tQ2FsRGF0YVs2NzJdLCBnX3JCYWNrdXBDYWxEYXRhQWxsVjIuYXU0Um9tQ2FsRGF0YVs2NzNdLAoJCQkJZ19yQmFja3VwQ2FsRGF0YUFsbFYyLmF1NFJvbUNhbERhdGFbNjc0XSk7CgkJCURCR0xPRyhSRlRFU1QsIElORk8sCgkJCQkiQ2hlY2sgc29tZSBvZiBlbGVtZW50cyAoMHglMDh4KSwgKDB4JTA4eCksICgweCUwOHgpLCAoMHglMDh4KSwgKDB4JTA4eClcbiIsCgkJCQlnX3JCYWNrdXBDYWxEYXRhQWxsVjIuYXU0Um9tQ2FsRGF0YVs2NzVdLCBnX3JCYWNrdXBDYWxEYXRhQWxsVjIuYXU0Um9tQ2FsRGF0YVs2NzZdLAoJCQkJZ19yQmFja3VwQ2FsRGF0YUFsbFYyLmF1NFJvbUNhbERhdGFbNjc3XSwgZ19yQmFja3VwQ2FsRGF0YUFsbFYyLmF1NFJvbUNhbERhdGFbNjc4XSwKCQkJCWdfckJhY2t1cENhbERhdGFBbGxWMi5hdTRSb21DYWxEYXRhWzY3OV0pOwoJCX0KCX0gZWxzZSBpZiAodWNSZWFzb24gPT0gNCAmJiB1Y0FjdGlvbiA9PSA2KSB7CgkJREJHTE9HKFJGVEVTVCwgSU5GTywgIlJMTSBDTUQgOiBQcmludCBDYWwgRGF0YSBpbiBGVyAoJXMpLlxuIiwKCQkJdWNSb21SYW0gPT0gMCA/ICJST00iIDogIlJBTSIpOwoJCS8qIERlYnVnIFVzZSA6IFByaW50IENhbCBEYXRhIGluIEZXICovCgoJCXJTdGF0dXMgPSBrYWxJb2N0bChwckdsdWVJbmZvLAoJCQkJCXdsYW5vaWRTZXRDYWxCYWNrdXAsCgkJCQkJJnJDYWxCYWNrdXBEYXRhVjIsCgkJCQkJc2l6ZW9mKFBBUkFNX0NBTF9CQUNLVVBfU1RSVUNUX1YyX1QpLAoJCQkJCVRSVUUsCgkJCQkJVFJVRSwKCQkJCQlUUlVFLAoJCQkJCSZ1NEJ1Zkxlbik7CgoJCWlmIChyU3RhdHVzICE9IFdMQU5fU1RBVFVTX1NVQ0NFU1MpIHsKCQkJREJHTE9HKFJGVEVTVCwgSU5GTywKCQkJCSJSTE0gQ01EIDogUHJpbnQgQ2FsIERhdGEgaW4gRlcgKCVzKSBSZXR1cm4gRmFpbCAoMHglMDh4KSEhISEhISEhISEhXG4iLAoJCQkJdWNSb21SYW0gPT0gMCA/ICJST00iIDogIlJBTSIsIHJTdGF0dXMpOwoJCQlyZXR1cm4gclN0YXR1czsKCQl9CgoJCURCR0xPRyhSRlRFU1QsIElORk8sICJDTUQgOiBQcmludCBDYWwgRGF0YSBpbiBGVyAoJXMpLiBGaW5pc2ghISEhISEhISEhIVxuIiwKCQkJdWNSb21SYW0gPT0gMCA/ICJST00iIDogIlJBTSIpOwoJfSBlbHNlIGlmICh1Y1JlYXNvbiA9PSAzICYmIHVjQWN0aW9uID09IDUpIHsKCQlEQkdMT0coUkZURVNULCBJTkZPLCAiUkxNIENNRCA6IFNlbmQgQ2FsIERhdGEgdG8gRlcgKCVzKS5cbiIsCgkJCXVjUm9tUmFtID09IDAgPyAiUk9NIiA6ICJSQU0iKTsKCQkvKiBTZW5kIENhbCBEYXRhIHRvIEZXICovCgoJCXJTdGF0dXMgPSBrYWxJb2N0bChwckdsdWVJbmZvLAoJCQkJCXdsYW5vaWRTZXRDYWxCYWNrdXAsCgkJCQkJJnJDYWxCYWNrdXBEYXRhVjIsCgkJCQkJc2l6ZW9mKFBBUkFNX0NBTF9CQUNLVVBfU1RSVUNUX1YyX1QpLAoJCQkJCVRSVUUsCgkJCQkJVFJVRSwKCQkJCQlUUlVFLAoJCQkJCSZ1NEJ1Zkxlbik7CgoJCWlmIChyU3RhdHVzICE9IFdMQU5fU1RBVFVTX1NVQ0NFU1MpIHsKCQkJREJHTE9HKFJGVEVTVCwgSU5GTywKCQkJCSJSTE0gQ01EIDogU2VuZCBDYWwgRGF0YSB0byBGVyAoJXMpIFJldHVybiBGYWlsICgweCUwOHgpISEhISEhISEhISFcbiIsCgkJCQl1Y1JvbVJhbSA9PSAwID8gIlJPTSIgOiAiUkFNIiwgclN0YXR1cyk7CgkJCXJldHVybiByU3RhdHVzOwoJCX0KCgkJREJHTE9HKFJGVEVTVCwgSU5GTywgIkNNRCA6IFNlbmQgQ2FsIERhdGEgdG8gRlcgKCVzKS4gRmluaXNoISEhISEhISEhISFcbiIsCgkJCXVjUm9tUmFtID09IDAgPyAiUk9NIiA6ICJSQU0iKTsKCX0gZWxzZSB7CgkJREJHTE9HKFJGVEVTVCwgSU5GTywgIkNNRCA6IFVuZGVmaW5lZCBSZWFzb24gKCVkKSBhbmQgQWN0aW9uICglZCkgZm9yIENhbCBCYWNrdXAgaW4gSG9zdCBTaWRlIVxuIiwKCQkJdWNSZWFzb24sIHVjQWN0aW9uKTsKCgkJcmV0dXJuIHJTdGF0dXM7Cgl9CgoJcmV0dXJuIHJTdGF0dXM7Cn0KCldMQU5fU1RBVFVTIHJsbVRyaWdnZXJDYWxCYWNrdXAoCglQX0FEQVBURVJfVCBwckFkYXB0ZXIsCglCT09MRUFOCQlmZ0lzQ2FsRGF0YUJhY2t1cGVkCgkpCnsKCVdMQU5fU1RBVFVTIHJTdGF0dXMgPSBXTEFOX1NUQVRVU19TVUNDRVNTOwoKCWlmICghZmdJc0NhbERhdGFCYWNrdXBlZCkgewoJCURCR0xPRyhSRlRFU1QsIElORk8sICI9PT09PT09PSBCb290IFRpbWUgV2ktRmkgRW5hYmxlLi4uLi4uLi5cbiIpOwoJCURCR0xPRyhSRlRFU1QsIElORk8sICJTdGVwIDAgOiBSZXNldCBBbGwgQ2FsIERhdGEgaW4gRHJpdmVyLlxuIik7CgkJbWVtc2V0KCZnX3JCYWNrdXBDYWxEYXRhQWxsVjIsIDEsIHNpemVvZihSTE1fQ0FMX1JFU1VMVF9BTExfVjJfVCkpOwoJCWdfckJhY2t1cENhbERhdGFBbGxWMi51NE1hZ2ljTnVtMSA9IDY2MzI7CgkJZ19yQmFja3VwQ2FsRGF0YUFsbFYyLnU0TWFnaWNOdW0yID0gNjYzMjsKCgkJREJHTE9HKFJGVEVTVCwgSU5GTywgIlN0ZXAgMSA6IEdldCBUaGVybWFsIFRlbXAgZnJvbSBGVy5cbiIpOwoJCWlmIChybG1DYWxCYWNrdXAocHJBZGFwdGVyLCAwLCAwLCAwKSA9PSBXTEFOX1NUQVRVU19GQUlMVVJFKSB7CgkJCURCR0xPRyhSRlRFU1QsIElORk8sICJTdGVwIDEgOiBSZXR1cm4gRmFpbHVyZS5cbiIpOwoJCQlyZXR1cm4gV0xBTl9TVEFUVVNfRkFJTFVSRTsKCQl9CgoJCURCR0xPRyhSRlRFU1QsIElORk8sICJTdGVwIDIgOiBHZXQgUm9tIENhbCBEYXRhIFNpemUgZnJvbSBGVy5cbiIpOwoJCWlmIChybG1DYWxCYWNrdXAocHJBZGFwdGVyLCAwLCAxLCAwKSA9PSBXTEFOX1NUQVRVU19GQUlMVVJFKSB7CgkJCURCR0xPRyhSRlRFU1QsIElORk8sICJTdGVwIDIgOiBSZXR1cm4gRmFpbHVyZS5cbiIpOwoJCQlyZXR1cm4gV0xBTl9TVEFUVVNfRkFJTFVSRTsKCQl9CgoJCURCR0xPRyhSRlRFU1QsIElORk8sICJTdGVwIDMgOiBHZXQgUmFtIENhbCBEYXRhIFNpemUgZnJvbSBGVy5cbiIpOwoJCWlmIChybG1DYWxCYWNrdXAocHJBZGFwdGVyLCAwLCAxLCAxKSA9PSBXTEFOX1NUQVRVU19GQUlMVVJFKSB7CgkJCURCR0xPRyhSRlRFU1QsIElORk8sICJTdGVwIDMgOiBSZXR1cm4gRmFpbHVyZS5cbiIpOwoJCQlyZXR1cm4gV0xBTl9TVEFUVVNfRkFJTFVSRTsKCQl9CgoJCURCR0xPRyhSRlRFU1QsIElORk8sICJTdGVwIDQgOiBUcmlnZ2VyIEZXIERvIEZ1bGwgQ2FsLlxuIik7CgkJaWYgKHJsbUNhbEJhY2t1cChwckFkYXB0ZXIsIDEsIDIsIDApID09IFdMQU5fU1RBVFVTX0ZBSUxVUkUpIHsKCQkJREJHTE9HKFJGVEVTVCwgSU5GTywgIlN0ZXAgNCA6IFJldHVybiBGYWlsdXJlLlxuIik7CgkJCXJldHVybiBXTEFOX1NUQVRVU19GQUlMVVJFOwoJCX0KCX0gZWxzZSB7CgkJREJHTE9HKFJGVEVTVCwgSU5GTywgIj09PT09PT09IE5vcm1hbCBXaS1GaSBFbmFibGUuLi4uLi4uLlxuIik7CgkJREJHTE9HKFJGVEVTVCwgSU5GTywgIlN0ZXAgMCA6IFNlbnQgUm9tIENhbCBkYXRhIHRvIEZXLlxuIik7CgkJaWYgKHJsbUNhbEJhY2t1cChwckFkYXB0ZXIsIDMsIDUsIDApID09IFdMQU5fU1RBVFVTX0ZBSUxVUkUpIHsKCQkJREJHTE9HKFJGVEVTVCwgSU5GTywgIlN0ZXAgMCA6IFJldHVybiBGYWlsdXJlLlxuIik7CgkJCXJldHVybiBXTEFOX1NUQVRVU19GQUlMVVJFOwoJCX0KCgkJREJHTE9HKFJGVEVTVCwgSU5GTywgIlN0ZXAgMSA6IFNlbnQgUmFtIENhbCBkYXRhIHRvIEZXLlxuIik7CgkJaWYgKHJsbUNhbEJhY2t1cChwckFkYXB0ZXIsIDMsIDUsIDEpID09IFdMQU5fU1RBVFVTX0ZBSUxVUkUpIHsKCQkJREJHTE9HKFJGVEVTVCwgSU5GTywgIlN0ZXAgMSA6IFJldHVybiBGYWlsdXJlLlxuIik7CgkJCXJldHVybiBXTEFOX1NUQVRVU19GQUlMVVJFOwoJCX0KCX0KCglyZXR1cm4gclN0YXR1czsKfQojZW5kaWYKClZPSUQgcmxtTW9kaWZ5Vmh0QndQYXJhKAoJUFVJTlRfOCBwdWNWaHRDaGFubmVsRnJlcXVlbmN5UzEsCglQVUlOVF84IHB1Y1ZodENoYW5uZWxGcmVxdWVuY3lTMiwKCVBVSU5UXzggcHVjVmh0Q2hhbm5lbFdpZHRoCgkpCnsKCVVJTlRfOCBpID0gMCwgdWNUZW1wUyA9IDA7CgoJCWlmICgoKnB1Y1ZodENoYW5uZWxGcmVxdWVuY3lTMSAhPSAwKSAmJgoJCQkoKnB1Y1ZodENoYW5uZWxGcmVxdWVuY3lTMiAhPSAwKSkgewoKCQkJVUlOVF84CQl1Y0JXMTYwSW50ZXZhbCA9IDg7CgoJCQlEQkdMT0coUkxNLCBXQVJOLCAiUzE9JWQsIFMyPSVkXG4iLCAqcHVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMxLCAqcHVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMyKTsKCgkJCWlmICgoKCpwdWNWaHRDaGFubmVsRnJlcXVlbmN5UzIgLSAqcHVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMxKSA9PSB1Y0JXMTYwSW50ZXZhbCkgfHwKCQkJCSgoKnB1Y1ZodENoYW5uZWxGcmVxdWVuY3lTMSAtICpwdWNWaHRDaGFubmVsRnJlcXVlbmN5UzIpID09IHVjQlcxNjBJbnRldmFsKSkgewoJCQkJLypDMTYwIGNhc2UqLwoKCQkJCS8qTkVXIHNwZWMgc2hvdWxkIHNldCBjZW50cmFsIGNoIG9mIGJ3ODAgYXQgUzEsCgkJCQkqc2V0IGNlbnRyYWwgY2ggb2YgYncxNjAgYXQgUzIKCQkJCSovCgkJCQlmb3IgKGkgPSAwOyBpIDwgMjsgaSsrKSB7CgoJCQkJCWlmIChpID09IDApCgkJCQkJCXVjVGVtcFMgPSAqcHVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMxOwoJCQkJCWVsc2UKCQkJCQkJdWNUZW1wUyA9ICpwdWNWaHRDaGFubmVsRnJlcXVlbmN5UzI7CgoJCQkJCWlmICgodWNUZW1wUyA9PSA1MCkgfHwgKHVjVGVtcFMgPT0gODIpIHx8CgkJCQkJCSh1Y1RlbXBTID09IDExNCkgfHwgKHVjVGVtcFMgPT0gMTYzKSkKCQkJCQkJYnJlYWs7CgkJCQl9CgoKCQkJCWlmICh1Y1RlbXBTID09IDApIHsKCQkJCQlEQkdMT0coUkxNLCBXQVJOLCAicGxlYXNlIGNoZWNrIEJXMTYwIHNldHRpbmcsIGZpbmQgY2VudHJhbCBmcmVxIGZhaWxcbiIpOwoJCQkJCXJldHVybjsKCQkJCX0KCgkJCQkqcHVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMxID0gIHVjVGVtcFM7CgkJCQkqcHVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMyID0gIDA7CgkJCQkqcHVjVmh0Q2hhbm5lbFdpZHRoID0gQ1dfMTYwTUhaOwoJCQkJREJHTE9HKFJMTSwgV0FSTiwgIltCVzE2MF1bbmV3IHNwZWNdIFMxIGNoYW5nZSB0byAlZFxuIiwgKnB1Y1ZodENoYW5uZWxGcmVxdWVuY3lTMSk7CgkJCX0gZWxzZSB7CgkJCQkvKnJlYWwgODBQODAgY2FzZSovCgkJCX0KCgkJfQoKfQoKc3RhdGljIFZPSUQgcmxtUmV2aXNlUHJlZmVyQmFuZHdpZHRoTnNzKAoJUF9BREFQVEVSX1QgcHJBZGFwdGVyLAoJVUlOVF84IHVjQnNzSW5kZXgsCglQX1NUQV9SRUNPUkRfVCBwclN0YVJlYwoJKQp7CglFTlVNX0NIQU5ORUxfV0lEVEhfVCBlQ2hhbm5lbFdpZHRoID0gQ1dfMjBfNDBNSFo7CglQX0JTU19JTkZPX1QgcHJCc3NJbmZvOwoKI2RlZmluZSBWSFRfTUNTX1RYX1JYX01BWF8yU1MgQklUUygyLCAzKQojZGVmaW5lIFZIVF9NQ1NfVFhfUlhfTUFYXzJTU19TSElGVCAyCgojZGVmaW5lIEFSX1NUQV8yQUNfTUNTKHByU3RhUmVjKSBcCgkJKCgocHJTdGFSZWMpLT51MlZodFJ4TWNzTWFwICYgIFZIVF9NQ1NfVFhfUlhfTUFYXzJTUykgPj4gVkhUX01DU19UWF9SWF9NQVhfMlNTX1NISUZUKQoKI2RlZmluZSBBUl9JU19TVEFfMlNTX0FDKHByU3RhUmVjKSBcCgkJKChBUl9TVEFfMkFDX01DUyhwclN0YVJlYykgIT0gQklUUygwLCAxKSkpCgoKCglwckJzc0luZm8gPSBHRVRfQlNTX0lORk9fQllfSU5ERVgocHJBZGFwdGVyLCB1Y0Jzc0luZGV4KTsKCgllQ2hhbm5lbFdpZHRoID0gcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxXaWR0aDsKCgkvKgoJKlByZWZlciBzZXR0aW5nIG1vZGlmaWNhdGlvbgoJKjgwKzgwIDF4MSBhbmQgODAgMngyIGhhdmUgdGhlIHNhbWUgcGh5IHJhdGUsIGNob29zZSB0aGUgODAgMngyCgkqLwoKCWlmIChBUl9JU19TVEFfMlNTX0FDKHByU3RhUmVjKSkgewoJCS8qCgkJKkRCR0xPRyhSTE0sIFdBUk4sICJzdXBwb3J0IDJzc1xuIik7CgkJKi8KCgkJaWYgKChlQ2hhbm5lbFdpZHRoID09IENXXzgwUDgwTUhaICYmIHByQnNzSW5mby0+dWNWaHRDaGFubmVsRnJlcXVlbmN5UzIgIT0gMCkpIHsKCQkJREJHTE9HKFJMTSwgV0FSTiwgInN1cHBvcnQgKDJOc3MpIGFuZCAoODArODApXG4iKTsKCQkJREJHTE9HKFJMTSwgV0FSTiwgImNob29zZSAoMk5zcykgYW5kICg4MCkgZm9yIEJzc19pbmZvXG4iKTsKCQkJcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxXaWR0aCA9IENXXzgwTUhaOwoJCQlwckJzc0luZm8tPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMyID0gMDsKCQl9Cgl9Cn0KClZPSUQgcmxtUmV2aXNlTWF4QncoCglQX0FEQVBURVJfVCBwckFkYXB0ZXIsCglVSU5UXzggdWNCc3NJbmRleCwKCVBfRU5VTV9DSE5MX0VYVF9UIHBlRXh0ZW5kLAoJUF9FTlVNX0NIQU5ORUxfV0lEVEhfUCBwZUNoYW5uZWxXaWR0aCwKCVBVSU5UXzggcHVjUzEsCglQVUlOVF84IHB1Y1ByaW1hcnlDaCkKewoJVUlOVF84IHVjTWF4QmFuZHdpZHRoID0gTUFYX0JXXzgwTUhaOwoJVUlOVF84IHVjQ3VycmVudEJhbmR3aWR0aCA9IE1BWF9CV18yME1IWjsKCVVJTlRfOCB1Y09mZnNldCA9IChNQVhfQldfODBNSFogLSBDV184ME1IWik7CgoJdWNNYXhCYW5kd2lkdGggPSBjbm1HZXRCc3NNYXhCdyhwckFkYXB0ZXIsIHVjQnNzSW5kZXgpOwoKCWlmICgqcGVDaGFubmVsV2lkdGggPiBDV18yMF80ME1IWikgewoJCS8qY2FzZSBCVyA+IDgwICwgMTYwIDgwUDgwICovCgkJdWNDdXJyZW50QmFuZHdpZHRoID0gKFVJTlRfOCkqcGVDaGFubmVsV2lkdGggKyB1Y09mZnNldDsKCX0gZWxzZSB7CgkJLypjYXNlIEJXMjAgQlc0MCAqLwoJCWlmICgqcGVFeHRlbmQgIT0gQ0hOTF9FWFRfU0NOKSB7CgkJCS8qY2FzZSBCVzQwICovCgkJCXVjQ3VycmVudEJhbmR3aWR0aCA9IE1BWF9CV180ME1IWjsKCQl9Cgl9CgoJaWYgKHVjQ3VycmVudEJhbmR3aWR0aCA+IHVjTWF4QmFuZHdpZHRoKSB7CgkJREJHTE9HKFJMTSwgSU5GTywgIkRlY3JlYXNzZSB0aGUgQlcgdG8gKCVkKVxuIiwgdWNNYXhCYW5kd2lkdGgpOwoKCQlpZiAodWNNYXhCYW5kd2lkdGggPD0gTUFYX0JXXzQwTUhaKSB7CgkJCS8qQlcyMCAqIEJXNDAqLwoJCQkqcGVDaGFubmVsV2lkdGggPSBDV18yMF80ME1IWjsKCgkJCWlmICh1Y01heEJhbmR3aWR0aCA9PSBNQVhfQldfMjBNSFopCgkJCQkqcGVFeHRlbmQgPSBDSE5MX0VYVF9TQ047CgkJfSBlbHNlIHsKCQkJLyogQlc4MCwgQlcxNjAsIEJXODBQODAgKi8KCQkJLyogdWNNYXhCYW5kd2lkdGggTXVzdCBiZSBNQVhfQldfODBNSFosTUFYX0JXXzE2ME1IWixNQVhfQldfODBNSFogKi8KCQkJLyogcGVFeHRlbmQgc2hvdWxkIG5vdCBjaGFuZ2UgKi8KCQkJKnBlQ2hhbm5lbFdpZHRoID0gKHVjTWF4QmFuZHdpZHRoIC0gdWNPZmZzZXQpOwoKCQkJaWYgKHVjTWF4QmFuZHdpZHRoID09IE1BWF9CV184ME1IWikgewoJCQkJLyogbW9kaWZ5IFMxIGZvciBCYW5kd2lkdGggMTYwIGRvd25ncmFkZSA4MCBjYXNlICovCgkJCQlpZiAodWNDdXJyZW50QmFuZHdpZHRoID09IE1BWF9CV18xNjBNSFopIHsKCQkJCQlpZiAoKCpwdWNQcmltYXJ5Q2ggPj0gMzYpICYmICgqcHVjUHJpbWFyeUNoIDw9IDQ4KSkKCQkJCQkJKnB1Y1MxID0gNDI7CgkJCQkJZWxzZSBpZiAoKCpwdWNQcmltYXJ5Q2ggPj0gNTIpICYmICgqcHVjUHJpbWFyeUNoIDw9IDY0KSkKCQkJCQkJKnB1Y1MxID0gNTg7CgkJCQkJZWxzZSBpZiAoKCpwdWNQcmltYXJ5Q2ggPj0gMTAwKSAmJiAoKnB1Y1ByaW1hcnlDaCA8PSAxMTIpKQoJCQkJCQkqcHVjUzEgPSAxMDY7CgkJCQkJZWxzZSBpZiAoKCpwdWNQcmltYXJ5Q2ggPj0gMTE2KSAmJiAoKnB1Y1ByaW1hcnlDaCA8PSAxMjgpKQoJCQkJCQkqcHVjUzEgPSAxMjI7CgkJCQkJZWxzZSBpZiAoKCpwdWNQcmltYXJ5Q2ggPj0gMTMyKSAmJiAoKnB1Y1ByaW1hcnlDaCA8PSAxNDQpKQoJCQkJCQkqcHVjUzEgPSAxMzg7IC8qMTYwIGRvd25ncmFkZSBzaG91bGQgbm90IGluIHRoaXMgY2FzZSovCgkJCQkJZWxzZSBpZiAoKCpwdWNQcmltYXJ5Q2ggPj0gMTQ5KSAmJiAoKnB1Y1ByaW1hcnlDaCA8PSAxNjEpKQoJCQkJCQkqcHVjUzEgPSAxNTU7IC8qMTYwIGRvd25ncmFkZSBzaG91bGQgbm90IGluIHRoaXMgY2FzZSovCgkJCQkJZWxzZQoJCQkJCQlEQkdMT0coUkxNLCBJTkZPLCAiQ2hlY2sgY29ubmVjdCAxNjAgZG93bmdyZGUgKCVkKSBjYXNlXG4iCgkJCQkJCSwgdWNNYXhCYW5kd2lkdGgpOwoKCQkJCQlEQkdMT0coUkxNLCBJTkZPLCAiRGVjcmVhc3NlIHRoZSBCVzE2MCB0byBCVzgwLCBzaGlmdCBTMSB0byAoJWQpXG4iLCAqcHVjUzEpOwoJCQkJfQoJCQl9CgkJfQoKCQlEQkdMT0coUkxNLCBJTkZPLCAiTW9kaWZ5IENoYW5uZWxXaWR0aCAoJWQpIGFuZCBFeHRlbmQgKCVkKVxuIiwgKnBlQ2hhbm5lbFdpZHRoLCAqcGVFeHRlbmQpOwoJfQp9CgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYgQ2hhbmdlIFZIVCBPUCBDaGFubmVsIFdpZHRoLCBTMSwgUzIKKgoqIFxwYXJhbVtpbl0KKgoqIFxyZXR1cm4gbm9uZQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpWT0lEIHJsbUNoYW5nZVZodE9wQndQYXJhKFBfQURBUFRFUl9UIHByQWRhcHRlciwgVUlOVF84IHVjQnNzSW5kZXgsIFVJTlRfOCB1Y0NoYW5uZWxXaWR0aCkKewoJUF9CU1NfSU5GT19UIHByQnNzSW5mbzsKCVVJTlRfOCB1Y1ZodExvd2VyQ2hhbm5lbEZyZXF1ZW5jeSwgdWNWaHRVcHBlckNoYW5uZWxGcmVxdWVuY3kgPSAwOwoKCXByQnNzSW5mbyA9IEdFVF9CU1NfSU5GT19CWV9JTkRFWChwckFkYXB0ZXIsIHVjQnNzSW5kZXgpOwoKCWlmICghcHJCc3NJbmZvKQoJCXJldHVybjsKCglpZiAodWNDaGFubmVsV2lkdGggPT0gTUFYX0JXXzgwXzgwX01IWikKCQlwckJzc0luZm8tPnVjVmh0Q2hhbm5lbFdpZHRoID0gVkhUX09QX0NIQU5ORUxfV0lEVEhfODBQODA7CgllbHNlIGlmICh1Y0NoYW5uZWxXaWR0aCA9PSBNQVhfQldfMTYwTUhaKQoJCXByQnNzSW5mby0+dWNWaHRDaGFubmVsV2lkdGggPSBWSFRfT1BfQ0hBTk5FTF9XSURUSF8xNjA7CgllbHNlIGlmICh1Y0NoYW5uZWxXaWR0aCA9PSBNQVhfQldfODBNSFopIHsKCQlwckJzc0luZm8tPnVjVmh0Q2hhbm5lbFdpZHRoID0gVkhUX09QX0NIQU5ORUxfV0lEVEhfODA7CgkJaWYgKHByQnNzSW5mby0+dWNWaHRQZWVyQ2hhbm5lbFdpZHRoID09IFZIVF9PUF9DSEFOTkVMX1dJRFRIXzE2MCkKCQkJcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxGcmVxdWVuY3lTMSA9CgkJCShwckJzc0luZm8tPnVjVmh0UGVlckNoYW5uZWxGcmVxdWVuY3lTMSA+IHByQnNzSW5mby0+dWNQcmltYXJ5Q2hhbm5lbCkgPwoJCQkocHJCc3NJbmZvLT51Y1ZodFBlZXJDaGFubmVsRnJlcXVlbmN5UzEgLSA4KSA6IChwckJzc0luZm8tPnVjVmh0UGVlckNoYW5uZWxGcmVxdWVuY3lTMSArIDgpOwoJCWVsc2UgaWYgKHByQnNzSW5mby0+dWNWaHRQZWVyQ2hhbm5lbFdpZHRoID09IFZIVF9PUF9DSEFOTkVMX1dJRFRIXzgwUDgwKSB7CgkJCWlmIChwckJzc0luZm8tPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMxIDwgcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxGcmVxdWVuY3lTMikgewoJCQkJdWNWaHRMb3dlckNoYW5uZWxGcmVxdWVuY3kgPSBwckJzc0luZm8tPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMxOwoJCQkJdWNWaHRVcHBlckNoYW5uZWxGcmVxdWVuY3kgPSBwckJzc0luZm8tPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMyOwoJCQl9IGVsc2UgewoJCQkJdWNWaHRMb3dlckNoYW5uZWxGcmVxdWVuY3kgPSBwckJzc0luZm8tPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMyOwoJCQkJdWNWaHRVcHBlckNoYW5uZWxGcmVxdWVuY3kgPSBwckJzc0luZm8tPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMxOwoJCQl9CgkJCXByQnNzSW5mby0+dWNWaHRDaGFubmVsRnJlcXVlbmN5UzEgPSBwckJzc0luZm8tPnVjUHJpbWFyeUNoYW5uZWwgPAoJCQkJCSgodWNWaHRMb3dlckNoYW5uZWxGcmVxdWVuY3kgKyB1Y1ZodFVwcGVyQ2hhbm5lbEZyZXF1ZW5jeSkvMikgPwoJCQkJCXVjVmh0TG93ZXJDaGFubmVsRnJlcXVlbmN5IDogdWNWaHRVcHBlckNoYW5uZWxGcmVxdWVuY3k7CgkJCXByQnNzSW5mby0+dWNWaHRDaGFubmVsRnJlcXVlbmN5UzIgPSAwOwoJCX0KCX0gZWxzZSBpZiAoKHVjQ2hhbm5lbFdpZHRoID09IE1BWF9CV180ME1IWikgfHwgKHVjQ2hhbm5lbFdpZHRoID09IE1BWF9CV18yME1IWikpCgkJcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxXaWR0aCA9IFZIVF9PUF9DSEFOTkVMX1dJRFRIXzIwXzQwOwp9CgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYgVGhpcyBmdW5jdGlvbiBzaG91bGQgYmUgaW52b2tlZCB0byB1cGRhdGUgcGFyYW1ldGVycyBvZiBhc3NvY2lhdGVkIEFQLgoqICAgICAgICAoQXNzb2NpYXRpb24gcmVzcG9uc2UgYW5kIEJlYWNvbikKKgoqIFxwYXJhbVtpbl0KKgoqIFxyZXR1cm4gbm9uZQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpzdGF0aWMgVUlOVF84IHJsbVJlY0llSW5mb0ZvckNsaWVudChQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfQlNTX0lORk9fVCBwckJzc0luZm8sIFBVSU5UXzggcHVjSUUsIFVJTlRfMTYgdTJJRUxlbmd0aCkKewoJVUlOVF8xNiB1Mk9mZnNldDsKCVBfU1RBX1JFQ09SRF9UIHByU3RhUmVjOwoJUF9JRV9IVF9DQVBfVCBwckh0Q2FwOwoJUF9JRV9IVF9PUF9UIHBySHRPcDsKCVBfSUVfT0JTU19TQ0FOX1BBUkFNX1QgcHJPYnNzU2NuUGFyYW07CglVSU5UXzggdWNFUlAsIHVjUHJpbWFyeUNoYW5uZWw7CglQX1dJRklfVkFSX1QgcHJXaWZpVmFyID0gJnByQWRhcHRlci0+cldpZmlWYXI7CiNpZiBDRkdfU1VQUE9SVF9RVUlFVCAmJiAwCglCT09MRUFOIGZnSGFzUXVpZXRJRSA9IEZBTFNFOwojZW5kaWYKCUJPT0xFQU4gSXNmZ0h0Q2FwQ2hhbmdlID0gRkFMU0U7CgojaWYgQ0ZHX1NVUFBPUlRfODAyXzExQUMKCVBfSUVfVkhUX09QX1QgcHJWaHRPcDsKCVBfSUVfVkhUX0NBUF9UIHByVmh0Q2FwOwoJUF9JRV9PUF9NT0RFX05PVElGSUNBVElPTl9UIHByT1BNb2RlTm90aWZpY2F0aW9uOwkvKiBPcGVyYXRpb24gTW9kZSBOb3RpZmljYXRpb24gKi8KCUJPT0xFQU4gZmdIYXNPUE1vZGVJRSA9IEZBTFNFOwoJVUlOVF84IHVjVmh0T3BNb2RlQ2hhbm5lbFdpZHRoID0gMDsKCVVJTlRfOCB1Y1ZodE9wTW9kZVJ4TnNzID0gMDsKCVVJTlRfOCB1Y1ZodENhcE1jc093bk5vdFN1cHBvcnRPZmZzZXQ7CglVSU5UXzggdWNNYXhCd0FsbG93ZWQ7CglVSU5UXzggdWNJbml0Vmh0T3BNb2RlID0gMDsKI2VuZGlmCgojaWYgQ0ZHX1NVUFBPUlRfREZTCglCT09MRUFOIGZnSGFzV2lkZUJhbmRJRSA9IEZBTFNFOwoJQk9PTEVBTiBmZ0hhc1NDT0lFID0gRkFMU0U7CglCT09MRUFOIGZnSGFzQ2hhbm5lbFN3aXRjaElFID0gRkFMU0U7CglVSU5UXzggdWNDaGFubmVsQW5ub3VuY2VQcmk7CglFTlVNX0NITkxfRVhUX1QgZUNoYW5uZWxBbm5vdW5jZVNjbzsKCVVJTlRfOCB1Y0NoYW5uZWxBbm5vdW5jZUNoYW5uZWxTMSA9IDA7CglVSU5UXzggdWNDaGFubmVsQW5ub3VuY2VDaGFubmVsUzIgPSAwOwoJVUlOVF84IHVjQ2hhbm5lbEFubm91bmNlVmh0Qnc7CglQX0lFX0NIQU5ORUxfU1dJVENIX1QgcHJDaGFubmVsU3dpdGNoQW5ub3VuY2VJRTsKCVBfSUVfU0VDT05EQVJZX09GRlNFVF9UIHByU2Vjb25kYXJ5T2Zmc2V0SUU7CglQX0lFX1dJREVfQkFORF9DSEFOTkVMX1QgcHJXaWRlQmFuZENoYW5uZWxJRTsKI2VuZGlmCglQVUlOVF84IHB1Y0R1bXBJRTsKCglBU1NFUlQocHJBZGFwdGVyKTsKCUFTU0VSVChwckJzc0luZm8pOwoJQVNTRVJUKHB1Y0lFKTsKCglwclN0YVJlYyA9IHByQnNzSW5mby0+cHJTdGFSZWNPZkFQOwoJQVNTRVJUKHByU3RhUmVjKTsKCWlmICghcHJTdGFSZWMpCgkJcmV0dXJuIDA7CgoJcHJCc3NJbmZvLT5mZ1VzZVNob3J0UHJlYW1ibGUgPSBwckJzc0luZm8tPmZnSXNTaG9ydFByZWFtYmxlQWxsb3dlZDsKCXVjUHJpbWFyeUNoYW5uZWwgPSAwOwoJcHJPYnNzU2NuUGFyYW0gPSBOVUxMOwoJdWNNYXhCd0FsbG93ZWQgPSBjbm1HZXRCc3NNYXhCdyhwckFkYXB0ZXIsIHByQnNzSW5mby0+dWNCc3NJbmRleCk7CglwdWNEdW1wSUUgPSBwdWNJRTsKCgkvKiBOb3RlOiBIVC1yZWxhdGVkIG1lbWJlcnMgaW4gc3RhUmVjIG1heSBub3QgYmUgemVybyBiZWZvcmUsIHNvCgkgKiAgICAgICBpZiBmb2xsb3dpbmcgSUUgZG9lcyBub3QgZXhpc3QsIHRoZXkgYXJlIHN0aWxsIG5vdCB6ZXJvLgoJICogICAgICAgVGhlc2UgSFQtcmVsYXRlZCBwYXJhbWV0ZXJzIGFyZSB2YWxpZCBvbmx5IHdoZW4gdGhlIGNvcnJlc3BvbmRpbmcKCSAqICAgICAgIEJzc0luZm8gc3VwcG9ydHMgODAyLjExbiwgaS5lLiwgUkxNX05FVF9JU18xMU4oKQoJICovCglJRV9GT1JfRUFDSChwdWNJRSwgdTJJRUxlbmd0aCwgdTJPZmZzZXQpIHsKCQlzd2l0Y2ggKElFX0lEKHB1Y0lFKSkgewoJCWNhc2UgRUxFTV9JRF9IVF9DQVA6CgkJCWlmICghUkxNX05FVF9JU18xMU4ocHJCc3NJbmZvKSB8fCBJRV9MRU4ocHVjSUUpICE9IChzaXplb2YoSUVfSFRfQ0FQX1QpIC0gMikpCgkJCQlicmVhazsKCQkJcHJIdENhcCA9IChQX0lFX0hUX0NBUF9UKSBwdWNJRTsKCQkJcHJTdGFSZWMtPnVjTWNzU2V0ID0gcHJIdENhcC0+clN1cE1jc1NldC5hdWNSeE1jc0JpdG1hc2tbMF07CgkJCXByU3RhUmVjLT5mZ1N1cE1jczMyID0gKHBySHRDYXAtPnJTdXBNY3NTZXQuYXVjUnhNY3NCaXRtYXNrWzMyIC8gOF0gJiBCSVQoMCkpID8gVFJVRSA6IEZBTFNFOwoKCQkJa2FsTWVtQ29weShwclN0YVJlYy0+YXVjUnhNY3NCaXRtYXNrLCBwckh0Q2FwLT5yU3VwTWNzU2V0LmF1Y1J4TWNzQml0bWFzaywKCQkJCSAgIHNpemVvZihwclN0YVJlYy0+YXVjUnhNY3NCaXRtYXNrKSAvKlNVUF9NQ1NfUlhfQklUTUFTS19PQ1RFVF9OVU0gKi8pOwoKCQkJcHJTdGFSZWMtPnUyUnhIaWdoZXN0U3VwcG9ydGVkUmF0ZSA9IHBySHRDYXAtPnJTdXBNY3NTZXQudTJSeEhpZ2hlc3RTdXBwb3J0ZWRSYXRlOwoJCQlwclN0YVJlYy0+dTRUeFJhdGVJbmZvID0gcHJIdENhcC0+clN1cE1jc1NldC51NFR4UmF0ZUluZm87CgoJCQlpZiAoKHByU3RhUmVjLT51Mkh0Q2FwSW5mbyAmIEhUX0NBUF9JTkZPX1NNX1BPV0VSX1NBVkUpICE9CgkJCQkocHJIdENhcC0+dTJIdENhcEluZm8gJiBIVF9DQVBfSU5GT19TTV9QT1dFUl9TQVZFKSkKCQkJCUlzZmdIdENhcENoYW5nZSA9IFRSVUU7LyogUHVycG9zZSA6IFRvIGRldGVjdCBTTVBTIGNoYW5nZSAqLwoKCQkJcHJTdGFSZWMtPnUySHRDYXBJbmZvID0gcHJIdENhcC0+dTJIdENhcEluZm87CgkJCS8qIFNldCBMRFBDIFR4IGNhcGFiaWxpdHkgKi8KCQkJaWYgKElTX0ZFQVRVUkVfRk9SQ0VfRU5BQkxFRChwcldpZmlWYXItPnVjVHhMZHBjKSkKCQkJCXByU3RhUmVjLT51Mkh0Q2FwSW5mbyB8PSBIVF9DQVBfSU5GT19MRFBDX0NBUDsKCQkJZWxzZSBpZiAoSVNfRkVBVFVSRV9ESVNBQkxFRChwcldpZmlWYXItPnVjVHhMZHBjKSkKCQkJCXByU3RhUmVjLT51Mkh0Q2FwSW5mbyAmPSB+SFRfQ0FQX0lORk9fTERQQ19DQVA7CgoJCQkvKiBTZXQgU1RCQyBUeCBjYXBhYmlsaXR5ICovCgkJCWlmIChJU19GRUFUVVJFX0ZPUkNFX0VOQUJMRUQocHJXaWZpVmFyLT51Y1R4U3RiYykpCgkJCQlwclN0YVJlYy0+dTJIdENhcEluZm8gfD0gSFRfQ0FQX0lORk9fUlhfU1RCQzsKCQkJZWxzZSBpZiAoSVNfRkVBVFVSRV9ESVNBQkxFRChwcldpZmlWYXItPnVjVHhTdGJjKSkKCQkJCXByU3RhUmVjLT51Mkh0Q2FwSW5mbyAmPSB+SFRfQ0FQX0lORk9fUlhfU1RCQzsKCgkJCS8qIFNldCBTaG9ydCBHSSBUeCBjYXBhYmlsaXR5ICovCgkJCWlmIChJU19GRUFUVVJFX0ZPUkNFX0VOQUJMRUQocHJXaWZpVmFyLT51Y1R4U2hvcnRHSSkpIHsKCQkJCXByU3RhUmVjLT51Mkh0Q2FwSW5mbyB8PSBIVF9DQVBfSU5GT19TSE9SVF9HSV8yME07CgkJCQlwclN0YVJlYy0+dTJIdENhcEluZm8gfD0gSFRfQ0FQX0lORk9fU0hPUlRfR0lfNDBNOwoJCQl9IGVsc2UgaWYgKElTX0ZFQVRVUkVfRElTQUJMRUQocHJXaWZpVmFyLT51Y1R4U2hvcnRHSSkpIHsKCQkJCXByU3RhUmVjLT51Mkh0Q2FwSW5mbyAmPSB+SFRfQ0FQX0lORk9fU0hPUlRfR0lfMjBNOwoJCQkJcHJTdGFSZWMtPnUySHRDYXBJbmZvICY9IH5IVF9DQVBfSU5GT19TSE9SVF9HSV80ME07CgkJCX0KCgkJCS8qIFNldCBIVCBHcmVlbmZpZWxkIFR4IGNhcGFiaWxpdHkgKi8KCQkJaWYgKElTX0ZFQVRVUkVfRk9SQ0VfRU5BQkxFRChwcldpZmlWYXItPnVjVHhHZikpCgkJCQlwclN0YVJlYy0+dTJIdENhcEluZm8gfD0gSFRfQ0FQX0lORk9fSFRfR0Y7CgkJCWVsc2UgaWYgKElTX0ZFQVRVUkVfRElTQUJMRUQocHJXaWZpVmFyLT51Y1R4R2YpKQoJCQkJcHJTdGFSZWMtPnUySHRDYXBJbmZvICY9IH5IVF9DQVBfSU5GT19IVF9HRjsKCgkJCXByU3RhUmVjLT51Y0FtcGR1UGFyYW0gPSBwckh0Q2FwLT51Y0FtcGR1UGFyYW07CgkJCXByU3RhUmVjLT51Mkh0RXh0ZW5kZWRDYXAgPSBwckh0Q2FwLT51Mkh0RXh0ZW5kZWRDYXA7CgkJCXByU3RhUmVjLT51NFR4QmVhbWZvcm1pbmdDYXAgPSBwckh0Q2FwLT51NFR4QmVhbWZvcm1pbmdDYXA7CgkJCXByU3RhUmVjLT51Y0FzZWxDYXAgPSBwckh0Q2FwLT51Y0FzZWxDYXA7CgkJCWJyZWFrOwoKCQljYXNlIEVMRU1fSURfSFRfT1A6CgkJCWlmICghUkxNX05FVF9JU18xMU4ocHJCc3NJbmZvKSB8fCBJRV9MRU4ocHVjSUUpICE9IChzaXplb2YoSUVfSFRfT1BfVCkgLSAyKSkKCQkJCWJyZWFrOwoJCQlwckh0T3AgPSAoUF9JRV9IVF9PUF9UKSBwdWNJRTsKCQkJLyogV29ya2Fyb3VuZCB0aGF0IHNvbWUgQVBzIGZpbGwgcHJpbWFyeSBjaGFubmVsIGZpZWxkIGJ5IGl0cwoJCQkgKiBzZWNvbmRhcnkgY2hhbm5lbCwgYnV0IGl0cyBEUyBJRSBpcyBjb3JyZWN0IDIwMTEwNjEwCgkJCSAqLwoJCQlpZiAodWNQcmltYXJ5Q2hhbm5lbCA9PSAwKQoJCQkJdWNQcmltYXJ5Q2hhbm5lbCA9IHBySHRPcC0+dWNQcmltYXJ5Q2hhbm5lbDsKCQkJcHJCc3NJbmZvLT51Y0h0T3BJbmZvMSA9IHBySHRPcC0+dWNJbmZvMTsKCQkJcHJCc3NJbmZvLT51Mkh0T3BJbmZvMiA9IHBySHRPcC0+dTJJbmZvMjsKCQkJcHJCc3NJbmZvLT51Mkh0T3BJbmZvMyA9IHBySHRPcC0+dTJJbmZvMzsKCgkJCS8qQmFja3VwIHBlZXIgSFQgT1AgSW5mbyovCgkJCXByQnNzSW5mby0+dWNIdFBlZXJPcEluZm8xID0gcHJIdE9wLT51Y0luZm8xOwoKCQkJaWYgKCFwckJzc0luZm8tPmZnNDBtQndBbGxvd2VkKQoJCQkJcHJCc3NJbmZvLT51Y0h0T3BJbmZvMSAmPSB+KEhUX09QX0lORk8xX1NDTyB8IEhUX09QX0lORk8xX1NUQV9DSE5MX1dJRFRIKTsKCgkJCWlmICgocHJCc3NJbmZvLT51Y0h0T3BJbmZvMSAmIEhUX09QX0lORk8xX1NDTykgIT0gQ0hOTF9FWFRfUkVTKQoJCQkJcHJCc3NJbmZvLT5lQnNzU0NPID0gKEVOVU1fQ0hOTF9FWFRfVCkgKHByQnNzSW5mby0+dWNIdE9wSW5mbzEgJiBIVF9PUF9JTkZPMV9TQ08pOwoKCQkJaWYgKHByQnNzSW5mby0+dWNPcENoYW5nZUNoYW5uZWxXaWR0aCA9PSBNQVhfQldfMjBNSFogJiYgcHJCc3NJbmZvLT5mZ0lzT3BDaGFuZ2VDaGFubmVsV2lkdGgpIHsKCQkJCXByQnNzSW5mby0+dWNIdE9wSW5mbzEgJj0gfihIVF9PUF9JTkZPMV9TQ08gfCBIVF9PUF9JTkZPMV9TVEFfQ0hOTF9XSURUSCk7CgkJCQlwckJzc0luZm8tPmVCc3NTQ08gPSBDSE5MX0VYVF9TQ047CgkJCX0KCgkJCXByQnNzSW5mby0+ZUh0UHJvdGVjdE1vZGUgPSAoRU5VTV9IVF9QUk9URUNUX01PREVfVCkKCQkJICAgIChwckJzc0luZm8tPnUySHRPcEluZm8yICYgSFRfT1BfSU5GTzJfSFRfUFJPVEVDVElPTik7CgoJCQkvKiBUbyBkbzogcHJvY2VzcyByZWd1bGF0b3J5IGNsYXNzIDE2ICovCgkJCWlmICgocHJCc3NJbmZvLT51Mkh0T3BJbmZvMiAmIEhUX09QX0lORk8yX09CU1NfTk9OX0hUX1NUQV9QUkVTRU5UKQoJCQkgICAgJiYgMCAvKiAmJiByZWd1bGF0b3J5IGNsYXNzIGlzIDE2ICovKQoJCQkJcHJCc3NJbmZvLT5lR2ZPcGVyYXRpb25Nb2RlID0gR0ZfTU9ERV9ESVNBTExPV0VEOwoJCQllbHNlIGlmIChwckJzc0luZm8tPnUySHRPcEluZm8yICYgSFRfT1BfSU5GTzJfTk9OX0dGX0hUX1NUQV9QUkVTRU5UKQoJCQkJcHJCc3NJbmZvLT5lR2ZPcGVyYXRpb25Nb2RlID0gR0ZfTU9ERV9QUk9URUNUOwoJCQllbHNlCgkJCQlwckJzc0luZm8tPmVHZk9wZXJhdGlvbk1vZGUgPSBHRl9NT0RFX05PUk1BTDsKCgkJCXByQnNzSW5mby0+ZVJpZnNPcGVyYXRpb25Nb2RlID0KCQkJICAgIChwckJzc0luZm8tPnVjSHRPcEluZm8xICYgSFRfT1BfSU5GTzFfUklGU19NT0RFKSA/IFJJRlNfTU9ERV9OT1JNQUwgOiBSSUZTX01PREVfRElTQUxMT1dFRDsKCgkJCWJyZWFrOwoKI2lmIENGR19TVVBQT1JUXzgwMl8xMUFDCgkJY2FzZSBFTEVNX0lEX1ZIVF9DQVA6CgkJCWlmICghUkxNX05FVF9JU18xMUFDKHByQnNzSW5mbykgfHwgSUVfTEVOKHB1Y0lFKSAhPSAoc2l6ZW9mKElFX1ZIVF9DQVBfVCkgLSAyKSkKCQkJCWJyZWFrOwoKCQkJcHJWaHRDYXAgPSAoUF9JRV9WSFRfQ0FQX1QpIHB1Y0lFOwoKCQkJcHJTdGFSZWMtPnU0Vmh0Q2FwSW5mbyA9IHByVmh0Q2FwLT51NFZodENhcEluZm87CgkJCS8qIFNldCBUeCBMRFBDIGNhcGFiaWxpdHkgKi8KCQkJaWYgKElTX0ZFQVRVUkVfRk9SQ0VfRU5BQkxFRChwcldpZmlWYXItPnVjVHhMZHBjKSkKCQkJCXByU3RhUmVjLT51NFZodENhcEluZm8gfD0gVkhUX0NBUF9JTkZPX1JYX0xEUEM7CgkJCWVsc2UgaWYgKElTX0ZFQVRVUkVfRElTQUJMRUQocHJXaWZpVmFyLT51Y1R4TGRwYykpCgkJCQlwclN0YVJlYy0+dTRWaHRDYXBJbmZvICY9IH5WSFRfQ0FQX0lORk9fUlhfTERQQzsKCgkJCS8qIFNldCBUeCBTVEJDIGNhcGFiaWxpdHkgKi8KCQkJaWYgKElTX0ZFQVRVUkVfRk9SQ0VfRU5BQkxFRChwcldpZmlWYXItPnVjVHhTdGJjKSkKCQkJCXByU3RhUmVjLT51NFZodENhcEluZm8gfD0gVkhUX0NBUF9JTkZPX1JYX1NUQkNfTUFTSzsKCQkJZWxzZSBpZiAoSVNfRkVBVFVSRV9ESVNBQkxFRChwcldpZmlWYXItPnVjVHhTdGJjKSkKCQkJCXByU3RhUmVjLT51NFZodENhcEluZm8gJj0gflZIVF9DQVBfSU5GT19SWF9TVEJDX01BU0s7CgoJCQkvKiBTZXQgVHggVFhPUCBQUyBjYXBhYmlsaXR5ICovCgkJCWlmIChJU19GRUFUVVJFX0ZPUkNFX0VOQUJMRUQocHJXaWZpVmFyLT51Y1R4b3BQc1R4KSkKCQkJCXByU3RhUmVjLT51NFZodENhcEluZm8gfD0gVkhUX0NBUF9JTkZPX1ZIVF9UWE9QX1BTOwoJCQllbHNlIGlmIChJU19GRUFUVVJFX0RJU0FCTEVEKHByV2lmaVZhci0+dWNUeG9wUHNUeCkpCgkJCQlwclN0YVJlYy0+dTRWaHRDYXBJbmZvICY9IH5WSFRfQ0FQX0lORk9fVkhUX1RYT1BfUFM7CgoJCQkvKiBTZXQgVHggU2hvcnQgR0kgY2FwYWJpbGl0eSAqLwoJCQlpZiAoSVNfRkVBVFVSRV9GT1JDRV9FTkFCTEVEKHByV2lmaVZhci0+dWNUeFNob3J0R0kpKSB7CgkJCQlwclN0YVJlYy0+dTRWaHRDYXBJbmZvIHw9IFZIVF9DQVBfSU5GT19TSE9SVF9HSV84MDsKCQkJCXByU3RhUmVjLT51NFZodENhcEluZm8gfD0gVkhUX0NBUF9JTkZPX1NIT1JUX0dJXzE2MF84MFA4MDsKCQkJfSBlbHNlIGlmIChJU19GRUFUVVJFX0RJU0FCTEVEKHByV2lmaVZhci0+dWNUeFNob3J0R0kpKSB7CgkJCQlwclN0YVJlYy0+dTRWaHRDYXBJbmZvICY9IH5WSFRfQ0FQX0lORk9fU0hPUlRfR0lfODA7CgkJCQlwclN0YVJlYy0+dTRWaHRDYXBJbmZvICY9IH5WSFRfQ0FQX0lORk9fU0hPUlRfR0lfMTYwXzgwUDgwOwoJCQl9CgoJCQkvKlNldCBWaHQgUnggTWNzIE1hcCB1cG9uIHBlZXIncyBjYXBhYmlsaXR5IGFuZCBvdXIgY2FwYWJpbGl0eSAqLwoJCQlwclN0YVJlYy0+dTJWaHRSeE1jc01hcCA9IHByVmh0Q2FwLT5yVmh0U3VwcG9ydGVkTWNzU2V0LnUyUnhNY3NNYXA7CgkJCWlmICh3bGFuR2V0U3VwcG9ydE5zcyhwckFkYXB0ZXIsIHByU3RhUmVjLT51Y0Jzc0luZGV4KSA8IDgpIHsKCQkJCXVjVmh0Q2FwTWNzT3duTm90U3VwcG9ydE9mZnNldCA9IHdsYW5HZXRTdXBwb3J0TnNzKHByQWRhcHRlciwgcHJTdGFSZWMtPnVjQnNzSW5kZXgpICogMjsKCQkJCS8qTWFyayBSeCBNY3MgTWFwIHdoaWNoIHdlIGRvbid0IHN1cHBvcnQqLwoJCQkJcHJTdGFSZWMtPnUyVmh0UnhNY3NNYXAgfD0gQklUUyh1Y1ZodENhcE1jc093bk5vdFN1cHBvcnRPZmZzZXQsIDE1KTsKCQkJfQoJCQlpZiAocHJTdGFSZWMtPnUyVmh0UnhNY3NNYXAgIT0gcHJWaHRDYXAtPnJWaHRTdXBwb3J0ZWRNY3NTZXQudTJSeE1jc01hcCkKCQkJCURCR0xPRyhSTE0sIElORk8sICJDaGFuZ2UgVmh0UnhNY3NNYXAgZnJvbSAweCV4IHRvIDB4JXggZHVlIHRvIG91ciBOc3Mgc2V0dGluZ1xuIiwKCQkJCQkJcHJWaHRDYXAtPnJWaHRTdXBwb3J0ZWRNY3NTZXQudTJSeE1jc01hcCwgcHJTdGFSZWMtPnUyVmh0UnhNY3NNYXApOwoKCQkJcHJTdGFSZWMtPnUyVmh0UnhIaWdoZXN0U3VwcG9ydGVkRGF0YVJhdGUgPQoJCQkgICAgcHJWaHRDYXAtPnJWaHRTdXBwb3J0ZWRNY3NTZXQudTJSeEhpZ2hlc3RTdXBwb3J0ZWREYXRhUmF0ZTsKCQkJcHJTdGFSZWMtPnUyVmh0VHhNY3NNYXAgPSBwclZodENhcC0+clZodFN1cHBvcnRlZE1jc1NldC51MlR4TWNzTWFwOwoJCQlwclN0YVJlYy0+dTJWaHRUeEhpZ2hlc3RTdXBwb3J0ZWREYXRhUmF0ZSA9CgkJCQlwclZodENhcC0+clZodFN1cHBvcnRlZE1jc1NldC51MlR4SGlnaGVzdFN1cHBvcnRlZERhdGFSYXRlOwoKCQkJYnJlYWs7CgoJCWNhc2UgRUxFTV9JRF9WSFRfT1A6CgkJCWlmICghUkxNX05FVF9JU18xMUFDKHByQnNzSW5mbykgfHwgSUVfTEVOKHB1Y0lFKSAhPSAoc2l6ZW9mKElFX1ZIVF9PUF9UKSAtIDIpKQoJCQkJYnJlYWs7CgoJCQlwclZodE9wID0gKFBfSUVfVkhUX09QX1QpIHB1Y0lFOwoKCQkJLypCYWNrdXAgcGVlciBWSFQgT3BJbmZvKi8KCQkJcHJCc3NJbmZvLT51Y1ZodFBlZXJDaGFubmVsV2lkdGggPSBwclZodE9wLT51Y1ZodE9wZXJhdGlvblswXTsKCQkJcHJCc3NJbmZvLT51Y1ZodFBlZXJDaGFubmVsRnJlcXVlbmN5UzEgPSBwclZodE9wLT51Y1ZodE9wZXJhdGlvblsxXTsKCQkJcHJCc3NJbmZvLT51Y1ZodFBlZXJDaGFubmVsRnJlcXVlbmN5UzIgPSBwclZodE9wLT51Y1ZodE9wZXJhdGlvblsyXTsKCgkJCXJsbU1vZGlmeVZodEJ3UGFyYSgmcHJCc3NJbmZvLT51Y1ZodFBlZXJDaGFubmVsRnJlcXVlbmN5UzEsCgkJCQkmcHJCc3NJbmZvLT51Y1ZodFBlZXJDaGFubmVsRnJlcXVlbmN5UzIsCgkJCQkmcHJCc3NJbmZvLT51Y1ZodFBlZXJDaGFubmVsV2lkdGgpOwoKCQkJcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxXaWR0aCA9IHByVmh0T3AtPnVjVmh0T3BlcmF0aW9uWzBdOwoJCQlwckJzc0luZm8tPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMxID0gcHJWaHRPcC0+dWNWaHRPcGVyYXRpb25bMV07CgkJCXByQnNzSW5mby0+dWNWaHRDaGFubmVsRnJlcXVlbmN5UzIgPSBwclZodE9wLT51Y1ZodE9wZXJhdGlvblsyXTsKCQkJcHJCc3NJbmZvLT51MlZodEJhc2ljTWNzU2V0ID0gcHJWaHRPcC0+dTJWaHRCYXNpY01jc1NldDsKCgkJCXJsbU1vZGlmeVZodEJ3UGFyYSgmcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxGcmVxdWVuY3lTMSwKCQkJCSZwckJzc0luZm8tPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMyLAoJCQkJJnByQnNzSW5mby0+dWNWaHRDaGFubmVsV2lkdGgpOwoKCQkJaWYgKHByQnNzSW5mby0+ZmdJc09wQ2hhbmdlQ2hhbm5lbFdpZHRoKQoJCQkJcmxtQ2hhbmdlVmh0T3BCd1BhcmEocHJBZGFwdGVyLCBwckJzc0luZm8tPnVjQnNzSW5kZXgsCgkJCQkJCQlwckJzc0luZm8tPnVjT3BDaGFuZ2VDaGFubmVsV2lkdGgpOwoKCQkJLyogU2V0IGluaXRpYWwgdmFsdWUgb2YgVkhUIE9QIG1vZGUgKi8KCQkJdWNJbml0Vmh0T3BNb2RlID0gMDsKCQkJc3dpdGNoIChwckJzc0luZm8tPnVjVmh0Q2hhbm5lbFdpZHRoKSB7CgkJCWNhc2UgVkhUX09QX0NIQU5ORUxfV0lEVEhfMjBfNDA6CgkJCQl1Y0luaXRWaHRPcE1vZGUgfD0gVkhUX09QX01PREVfQ0hBTk5FTF9XSURUSF80MDsKCQkJCWJyZWFrOwoJCQljYXNlIFZIVF9PUF9DSEFOTkVMX1dJRFRIXzgwOgoJCQkJdWNJbml0Vmh0T3BNb2RlIHw9IFZIVF9PUF9NT0RFX0NIQU5ORUxfV0lEVEhfODA7CgkJCQlicmVhazsKCQkJY2FzZSBWSFRfT1BfQ0hBTk5FTF9XSURUSF8xNjA6CgkJCWNhc2UgVkhUX09QX0NIQU5ORUxfV0lEVEhfODBQODA6CgkJCQl1Y0luaXRWaHRPcE1vZGUgfD0gVkhUX09QX01PREVfQ0hBTk5FTF9XSURUSF8xNjBfODBQODA7CgkJCQlicmVhazsKCQkJZGVmYXVsdDoKCQkJCXVjSW5pdFZodE9wTW9kZSB8PSBWSFRfT1BfTU9ERV9DSEFOTkVMX1dJRFRIXzgwOwoJCQkJYnJlYWs7CgkJCX0KCQkJdWNJbml0Vmh0T3BNb2RlIHw9ICgocHJCc3NJbmZvLT51Y05zcy0xKSA8PCBWSFRfT1BfTU9ERV9SWF9OU1NfT0ZGU0VUKSAmIFZIVF9PUF9NT0RFX1JYX05TUzsKCQkJYnJlYWs7CgkJY2FzZSBFTEVNX0lEX09QX01PREU6CgkJCWlmICghUkxNX05FVF9JU18xMUFDKHByQnNzSW5mbykgfHwgSUVfTEVOKHB1Y0lFKSAhPSAoc2l6ZW9mKElFX09QX01PREVfTk9USUZJQ0FUSU9OX1QpIC0gMikpCgkJCQlicmVhazsKCQkJcHJPUE1vZGVOb3RpZmljYXRpb24gPSAoUF9JRV9PUF9NT0RFX05PVElGSUNBVElPTl9UKSBwdWNJRTsKCgkJCWlmICgocHJPUE1vZGVOb3RpZmljYXRpb24tPnVjT3BNb2RlICYgVkhUX09QX01PREVfUlhfTlNTX1RZUEUpCgkJCSAgICAhPSBWSFRfT1BfTU9ERV9SWF9OU1NfVFlQRSkgewoJCQkJaWYgKHByU3RhUmVjLT51Y1ZodE9wTW9kZSAhPSBwck9QTW9kZU5vdGlmaWNhdGlvbi0+dWNPcE1vZGUpIHsKCQkJCQlwclN0YVJlYy0+dWNWaHRPcE1vZGUgPSBwck9QTW9kZU5vdGlmaWNhdGlvbi0+dWNPcE1vZGU7CgkJCQkJZmdIYXNPUE1vZGVJRSA9IFRSVUU7CgkJCQkJdWNWaHRPcE1vZGVDaGFubmVsV2lkdGggPQoJCQkJCSAgICAoKHByT1BNb2RlTm90aWZpY2F0aW9uLT51Y09wTW9kZSkgJiBWSFRfT1BfTU9ERV9DSEFOTkVMX1dJRFRIKTsKCQkJCQl1Y1ZodE9wTW9kZVJ4TnNzID0KCQkJCQkgICAgKChwck9QTW9kZU5vdGlmaWNhdGlvbi0+dWNPcE1vZGUpICYgVkhUX09QX01PREVfUlhfTlNTKSA+PgoJCQkJCQlWSFRfT1BfTU9ERV9SWF9OU1NfT0ZGU0VUOwoJCQkJfSBlbHNlIC8qIExldCB0aGUgZnVydGhlciBmbG93IG5vdCB0byB1cGRhdGUgVmh0T3BNb2RlICovCgkJCQkJdWNJbml0Vmh0T3BNb2RlID0gcHJTdGFSZWMtPnVjVmh0T3BNb2RlOwoJCQl9CgoJCQlicmVhazsKI2lmIENGR19TVVBQT1JUX0RGUwoJCWNhc2UgRUxFTV9JRF9XSURFX0JBTkRfQ0hBTk5FTF9TV0lUQ0g6CgkJCWlmICghUkxNX05FVF9JU18xMUFDKHByQnNzSW5mbykgfHwgSUVfTEVOKHB1Y0lFKSAhPSAoc2l6ZW9mKElFX1dJREVfQkFORF9DSEFOTkVMX1QpIC0gMikpCgkJCQlicmVhazsKCQkJREJHTE9HKFJMTSwgSU5GTywgIltDaGFubmVsIFN3aXRjaF0gRUxFTV9JRF9XSURFX0JBTkRfQ0hBTk5FTF9TV0lUQ0gsIDExQUNcbiIpOwoJCQlwcldpZGVCYW5kQ2hhbm5lbElFID0gKFBfSUVfV0lERV9CQU5EX0NIQU5ORUxfVCkgcHVjSUU7CgkJCXVjQ2hhbm5lbEFubm91bmNlVmh0QncgPSBwcldpZGVCYW5kQ2hhbm5lbElFLT51Y05ld0NoYW5uZWxXaWR0aDsKCQkJdWNDaGFubmVsQW5ub3VuY2VDaGFubmVsUzEgPSBwcldpZGVCYW5kQ2hhbm5lbElFLT51Y0NoYW5uZWxTMTsKCQkJdWNDaGFubmVsQW5ub3VuY2VDaGFubmVsUzIgPSBwcldpZGVCYW5kQ2hhbm5lbElFLT51Y0NoYW5uZWxTMjsKCQkJZmdIYXNXaWRlQmFuZElFID0gVFJVRTsKCQkJREJHTE9HKFJMTSwgSU5GTywKCQkJICAgICAgICJbQ2hdIEJXPSVkLCBzMT0lZCwgczI9JWRcbiIsIHVjQ2hhbm5lbEFubm91bmNlVmh0QncsIHVjQ2hhbm5lbEFubm91bmNlQ2hhbm5lbFMxLAoJCQkgICAgICAgdWNDaGFubmVsQW5ub3VuY2VDaGFubmVsUzIpOwoJCQlicmVhazsKI2VuZGlmCgojZW5kaWYKCQljYXNlIEVMRU1fSURfMjBfNDBfQlNTX0NPRVhJU1RFTkNFOgoJCQlpZiAoIVJMTV9ORVRfSVNfMTFOKHByQnNzSW5mbykpCgkJCQlicmVhazsKCQkJLyogVG8gZG86IHN0b3JlIGlmIHNjYW5uaW5nIGV4ZW1wdGlvbiBncmFudCB0byBCc3NJbmZvICovCgkJCWJyZWFrOwoKCQljYXNlIEVMRU1fSURfT0JTU19TQ0FOX1BBUkFNUzoKCQkJaWYgKCFSTE1fTkVUX0lTXzExTihwckJzc0luZm8pIHx8IElFX0xFTihwdWNJRSkgIT0gKHNpemVvZihJRV9PQlNTX1NDQU5fUEFSQU1fVCkgLSAyKSkKCQkJCWJyZWFrOwoJCQkvKiBTdG9yZSBPQlNTIHBhcmFtZXRlcnMgdG8gQnNzSW5mbyAqLwoJCQlwck9ic3NTY25QYXJhbSA9IChQX0lFX09CU1NfU0NBTl9QQVJBTV9UKSBwdWNJRTsKCQkJYnJlYWs7CgoJCWNhc2UgRUxFTV9JRF9FWFRFTkRFRF9DQVA6CgkJCWlmICghUkxNX05FVF9JU18xMU4ocHJCc3NJbmZvKSkKCQkJCWJyZWFrOwoJCQkvKiBUbyBkbzogc3RvcmUgZXh0ZW5kZWQgY2FwYWJpbGl0eSAoUFNNUCwgY29leGlzdCkgdG8gQnNzSW5mbyAqLwoJCQlicmVhazsKCgkJY2FzZSBFTEVNX0lEX0VSUF9JTkZPOgoJCQlpZiAoSUVfTEVOKHB1Y0lFKSAhPSAoc2l6ZW9mKElFX0VSUF9UKSAtIDIpIHx8IHByQnNzSW5mby0+ZUJhbmQgIT0gQkFORF8yRzQpCgkJCQlicmVhazsKCQkJdWNFUlAgPSBFUlBfSU5GT19JRShwdWNJRSktPnVjRVJQOwoJCQlwckJzc0luZm8tPmZnRXJwUHJvdGVjdE1vZGUgPSAodWNFUlAgJiBFUlBfSU5GT19VU0VfUFJPVEVDVElPTikgPyBUUlVFIDogRkFMU0U7CgoJCQlpZiAodWNFUlAgJiBFUlBfSU5GT19CQVJLRVJfUFJFQU1CTEVfTU9ERSkKCQkJCXByQnNzSW5mby0+ZmdVc2VTaG9ydFByZWFtYmxlID0gRkFMU0U7CgkJCWJyZWFrOwoKCQljYXNlIEVMRU1fSURfRFNfUEFSQU1fU0VUOgoJCQlpZiAoSUVfTEVOKHB1Y0lFKSA9PSBFTEVNX01BWF9MRU5fRFNfUEFSQU1FVEVSX1NFVCkKCQkJCXVjUHJpbWFyeUNoYW5uZWwgPSBEU19QQVJBTV9JRShwdWNJRSktPnVjQ3VyckNobmw7CgkJCWJyZWFrOwojaWYgQ0ZHX1NVUFBPUlRfREZTCgkJY2FzZSBFTEVNX0lEX0NIX1NXX0FOTk9VTkNFTUVOVDoKCQkJaWYgKElFX0xFTihwdWNJRSkgIT0gKHNpemVvZihJRV9DSEFOTkVMX1NXSVRDSF9UKSAtIDIpKQoJCQkJYnJlYWs7CgoJCQlwckNoYW5uZWxTd2l0Y2hBbm5vdW5jZUlFID0gKFBfSUVfQ0hBTk5FTF9TV0lUQ0hfVCkgcHVjSUU7CgoJCQlEQkdMT0coUkxNLCBJTkZPLCAiW0NoXSBDb3VudD0lZFxuIiwgcHJDaGFubmVsU3dpdGNoQW5ub3VuY2VJRS0+dWNDaGFubmVsU3dpdGNoQ291bnQpOwojaWYgMAoJCQlxbVNldFN0YVJlY1R4QWxsb3dlZChwckFkYXB0ZXIsIHByU3RhUmVjLCBGQUxTRSk7CgkJCURCR0xPRyhSTE0sIElORk8sICJbQ2hdIFR4QWxsb3dlZCA9ICVkXG4iLCBwclN0YVJlYy0+ZmdJc1R4QWxsb3dlZCk7CiNlbmRpZgoJCQlpZiAocHJDaGFubmVsU3dpdGNoQW5ub3VuY2VJRS0+dWNDaGFubmVsU3dpdGNoTW9kZSA9PSAxKSB7CgkJCQlpZiAocHJDaGFubmVsU3dpdGNoQW5ub3VuY2VJRS0+dWNDaGFubmVsU3dpdGNoQ291bnQgPD0gMykgewoJCQkJCURCR0xPRyhSTE0sIElORk8sCgkJCQkJICAgICAgICJbQ2hdIHN3aXRjaCBjaGFubmVsIFslZF0tPlslZF1cbiIsIHByQnNzSW5mby0+dWNQcmltYXJ5Q2hhbm5lbCwKCQkJCQkgICAgICAgcHJDaGFubmVsU3dpdGNoQW5ub3VuY2VJRS0+dWNOZXdDaGFubmVsTnVtKTsKCQkJCQl1Y0NoYW5uZWxBbm5vdW5jZVByaSA9IHByQ2hhbm5lbFN3aXRjaEFubm91bmNlSUUtPnVjTmV3Q2hhbm5lbE51bTsKCQkJCQlmZ0hhc0NoYW5uZWxTd2l0Y2hJRSA9IFRSVUU7CgkJCQkJZ19mZ0hhc0NoYW5uZWxTd2l0Y2hJRSA9IFRSVUU7CiNpZiAwCgkJCQkJcW1TZXRTdGFSZWNUeEFsbG93ZWQocHJBZGFwdGVyLCBwclN0YVJlYywgVFJVRSk7CgkJCQkJREJHTE9HKFJMTSwgSU5GTywgIltDaF0gQWZ0ZXIgc3dpdGNoaW5nICwgVHhBbGxvd2VkID0gJWRcbiIsCgkJCQkJICAgICAgIHByU3RhUmVjLT5mZ0lzVHhBbGxvd2VkKTsKI2VuZGlmCgkJCQl9CgkJCQlpZiAoUkxNX05FVF9JU18xMUFDKHByQnNzSW5mbykpIHsKCQkJCQlEQkdMT0coUkxNLCBJTkZPLCAiU2VuZCBPcGVyYXRpb24gQWN0aW9uIEZyYW1lIik7CgkJCQkJcmxtU2VuZE9wTW9kZU5vdGlmaWNhdGlvbkZyYW1lKHByQWRhcHRlciwgcHJTdGFSZWMsCgkJCQkJCQkJICAgICAgIFZIVF9PUF9NT0RFX0NIQU5ORUxfV0lEVEhfMjAsIDEpOwoJCQkJfSBlbHNlIHsKCQkJCQlEQkdMT0coUkxNLCBJTkZPLCAiU2tpcCBTZW5kIE9wZXJhdGlvbiBBY3Rpb24gRnJhbWUiKTsKCQkJCX0KCQkJfQoKCQkJYnJlYWs7CgkJY2FzZSBFTEVNX0lEX1NDTzoKCQkJaWYgKElFX0xFTihwdWNJRSkgIT0gKHNpemVvZihJRV9TRUNPTkRBUllfT0ZGU0VUX1QpIC0gMikpCgkJCQlicmVhazsKCgkJCXByU2Vjb25kYXJ5T2Zmc2V0SUUgPSAoUF9JRV9TRUNPTkRBUllfT0ZGU0VUX1QpIHB1Y0lFOwoJCQlEQkdMT0coUkxNLCBJTkZPLAoJCQkgICAgICAgIltDaGFubmVsIFN3aXRjaF0gU0NPIFslZF0tPlslZF1cbiIsIHByQnNzSW5mby0+ZUJzc1NDTywKCQkJICAgICAgIHByU2Vjb25kYXJ5T2Zmc2V0SUUtPnVjU2Vjb25kYXJ5T2Zmc2V0KTsKCQkJZUNoYW5uZWxBbm5vdW5jZVNjbyA9IChFTlVNX0NITkxfRVhUX1QpIHByU2Vjb25kYXJ5T2Zmc2V0SUUtPnVjU2Vjb25kYXJ5T2Zmc2V0OwoJCQlmZ0hhc1NDT0lFID0gVFJVRTsKCQkJYnJlYWs7CiNlbmRpZgoKI2lmIENGR19TVVBQT1JUX1FVSUVUICYmIDAKCQkJLyogTm90ZTogUlJNIGNvZGUgc2hvdWxkIGJlIG1vdmVkIHRvIGluZGVwZW5kZW50IFJSTSBmdW5jdGlvbiBieQoJCQkgKiAgICAgICBjb21wb25lbnQgZGVzaWduIHJ1bGUuIEJ1dCB3ZSBhdHRhY2ggaXQgdG8gUkxNIHRlbXBvcmFyaWx5CgkJCSAqLwoJCWNhc2UgRUxFTV9JRF9RVUlFVDoKCQkJcnJtUXVpZXRIYW5kbGVRdWlldElFKHByQnNzSW5mbywgKFBfSUVfUVVJRVRfVCkgcHVjSUUpOwoJCQlmZ0hhc1F1aWV0SUUgPSBUUlVFOwoJCQlicmVhazsKI2VuZGlmCgkJZGVmYXVsdDoKCQkJYnJlYWs7CgkJfQkJLyogZW5kIG9mIHN3aXRjaCAqLwoJfQkJCS8qIGVuZCBvZiBJRV9GT1JfRUFDSCAqLwoKCWlmIChJc2ZnSHRDYXBDaGFuZ2UgJiYgKHByU3RhUmVjLT51Y1N0YVN0YXRlID09IFNUQV9TVEFURV8zKSkKCQljbm1TdGFTZW5kVXBkYXRlQ21kKHByQWRhcHRlciwgcHJTdGFSZWMsIE5VTEwsIEZBTFNFKTsKCgkvKiBTb21lIEFQIHdpbGwgaGF2ZSB3cm9uZyBjaGFubmVsIG51bWJlciAoMjU1KSB3aGVuIHJ1bm5pbmcgdGltZS4KCSAqIENoZWNrIGlmIGNvcnJlY3QgY2hhbm5lbCBudW1iZXIgaW5mb3JtYXRpb24uIDIwMTEwNTAxCgkgKi8KCWlmICgocHJCc3NJbmZvLT5lQmFuZCA9PSBCQU5EXzJHNCAmJiB1Y1ByaW1hcnlDaGFubmVsID4gMTQpIHx8CgkgICAgKHByQnNzSW5mby0+ZUJhbmQgIT0gQkFORF8yRzQgJiYgKHVjUHJpbWFyeUNoYW5uZWwgPj0gMjAwIHx8IHVjUHJpbWFyeUNoYW5uZWwgPD0gMTQpKSkKCQl1Y1ByaW1hcnlDaGFubmVsID0gMDsKI2lmIENGR19TVVBQT1JUXzgwMl8xMUFDCgkvKiBDaGVjayB3aGV0aGVyIHRoZSBPcGVyYXRpb24gTW9kZSBJRSBpcyBleGlzdCBvciBub3QuCgkgKiAgSWYgZXhpc3RzLCB0aGVuIHRoZSBjaGFubmVsIGJhbmR3aWR0aCBvZiBWSFQgb3BlcmF0aW9uIGZpZWxkICBpcyBjaGFuZ2VkCgkgKiAgd2l0aCB0aGUgY2hhbm5lbCBiYW5kd2lkdGggc2V0dGluZyBvZiBPcGVyYXRpb24gTW9kZSBmaWVsZC4KCSAqICBUaGUgY2hhbm5lbCBiYW5kd2lkdGggb2YgT1AgTW9kZSBJRSAgaXMgIDAsIHJlcHJlc2VudCBhcyAyME1Iei4KCSAqICBUaGUgY2hhbm5lbCBiYW5kd2lkdGggb2YgT1AgTW9kZSBJRSAgaXMgIDEsIHJlcHJlc2VudCBhcyA0ME1Iei4KCSAqICBUaGUgY2hhbm5lbCBiYW5kd2lkdGggb2YgT1AgTW9kZSBJRSAgaXMgIDIsIHJlcHJlc2VudCBhcyA4ME1Iei4KCSAqICBUaGUgY2hhbm5lbCBiYW5kd2lkdGggb2YgT1AgTW9kZSBJRSAgaXMgIDMsIHJlcHJlc2VudCBhcyAxNjAvODArODBNSHouCgkgKi8KCWlmIChmZ0hhc09QTW9kZUlFID09IFRSVUUpIHsKCQkvKiAxLkNoYW5uZWwgd2lkdGggY2hhbmdlICovCgoJCWlmICh1Y1ZodE9wTW9kZUNoYW5uZWxXaWR0aCA9PSBWSFRfT1BfTU9ERV9DSEFOTkVMX1dJRFRIXzIwKSB7CgkJCXByQnNzSW5mby0+dWNWaHRDaGFubmVsV2lkdGggPSBDV18yMF80ME1IWjsKCQkJcHJCc3NJbmZvLT51Y0h0T3BJbmZvMSAmPSB+SFRfT1BfSU5GTzFfU1RBX0NITkxfV0lEVEg7CgkJCXByU3RhUmVjLT51Mkh0Q2FwSW5mbyAmPSB+SFRfQ0FQX0lORk9fU1VQX0NITkxfV0lEVEg7CgojaWYgQ0ZHX1dPUktBUk9VTkRfT1BNT0RFX0NPTkZMSUNUX09QSU5GTwoJCQlpZiAocHJCc3NJbmZvLT5lQnNzU0NPICE9IENITkxfRVhUX1NDTikgewoJCQkJREJHTE9HKFJMTSwgV0FSTiwgIkhUX09QX0luZm8gIT0gT1Btb2RlX05vdGlmaWZ5LCBmb2xsb3cgT1Btb2RlX05vdGlmeSB0byBCVzIwLlxuIik7CgkJCQlwckJzc0luZm8tPmVCc3NTQ08gPSBDSE5MX0VYVF9TQ047CgkJCX0KI2VuZGlmCgkJfQoKCQllbHNlIGlmICh1Y1ZodE9wTW9kZUNoYW5uZWxXaWR0aCA9PSBWSFRfT1BfTU9ERV9DSEFOTkVMX1dJRFRIXzQwKSB7CgkJCXByQnNzSW5mby0+dWNWaHRDaGFubmVsV2lkdGggPSBDV18yMF80ME1IWjsKCQkJcHJCc3NJbmZvLT51Y0h0T3BJbmZvMSB8PSBIVF9PUF9JTkZPMV9TVEFfQ0hOTF9XSURUSDsKCQkJcHJTdGFSZWMtPnUySHRDYXBJbmZvIHw9IEhUX0NBUF9JTkZPX1NVUF9DSE5MX1dJRFRIOwoKI2lmIENGR19XT1JLQVJPVU5EX09QTU9ERV9DT05GTElDVF9PUElORk8KCQkJaWYgKHByQnNzSW5mby0+ZUJzc1NDTyA9PSBDSE5MX0VYVF9TQ04pIHsKCQkJCXByQnNzSW5mby0+dWNIdE9wSW5mbzEgJj0gfkhUX09QX0lORk8xX1NUQV9DSE5MX1dJRFRIOwoJCQkJcHJTdGFSZWMtPnUySHRDYXBJbmZvICY9IH5IVF9DQVBfSU5GT19TVVBfQ0hOTF9XSURUSDsKCQkJCURCR0xPRyhSTE0sIFdBUk4sICJIVF9PUF9JbmZvICE9IE9QbW9kZV9Ob3RpZmlmeSwgZm9sbG93IEhUX09QX0luZm8gdG8gQlcyMC5cbiIpOwoJCQl9CiNlbmRpZgoJCX0KCgkJZWxzZSBpZiAodWNWaHRPcE1vZGVDaGFubmVsV2lkdGggPT0gVkhUX09QX01PREVfQ0hBTk5FTF9XSURUSF84MCkgewoJCQlwckJzc0luZm8tPnVjVmh0Q2hhbm5lbFdpZHRoID0gQ1dfODBNSFo7CgkJCXByQnNzSW5mby0+dWNIdE9wSW5mbzEgfD0gSFRfT1BfSU5GTzFfU1RBX0NITkxfV0lEVEg7CgkJCXByU3RhUmVjLT51NFZodENhcEluZm8gJj0gflZIVF9DQVBfSU5GT19NQVhfU1VQX0NIQU5ORUxfV0lEVEhfTUFTSzsKCQkJcHJTdGFSZWMtPnUySHRDYXBJbmZvIHw9IEhUX0NBUF9JTkZPX1NVUF9DSE5MX1dJRFRIOwoJCX0KCgkJZWxzZSBpZiAodWNWaHRPcE1vZGVDaGFubmVsV2lkdGggPT0gVkhUX09QX01PREVfQ0hBTk5FTF9XSURUSF8xNjBfODBQODApIHsKCQkJcHJCc3NJbmZvLT51Y0h0T3BJbmZvMSB8PSBIVF9PUF9JTkZPMV9TVEFfQ0hOTF9XSURUSDsKCQkJcHJTdGFSZWMtPnUySHRDYXBJbmZvIHw9IEhUX0NBUF9JTkZPX1NVUF9DSE5MX1dJRFRIOwoKCQkJLyogVXNlIFZIVCBPUCBJbmZvIHRvIGRldGVybWluZSBpdCdzIEJXMTYwIG9yIEJXODArQlc4MCAgKi8KCQkJcHJTdGFSZWMtPnU0Vmh0Q2FwSW5mbyAmPSB+VkhUX0NBUF9JTkZPX01BWF9TVVBfQ0hBTk5FTF9XSURUSF9NQVNLOwoJCQlpZiAocHJCc3NJbmZvLT51Y1ZodENoYW5uZWxXaWR0aCA9PSBWSFRfT1BfQ0hBTk5FTF9XSURUSF8xNjApCgkJCQlwclN0YVJlYy0+dTRWaHRDYXBJbmZvIHw9IFZIVF9DQVBfSU5GT19NQVhfU1VQX0NIQU5ORUxfV0lEVEhfU0VUXzE2MDsKCQkJZWxzZSBpZiAocHJCc3NJbmZvLT51Y1ZodENoYW5uZWxXaWR0aCA9PSBWSFRfT1BfQ0hBTk5FTF9XSURUSF84MFA4MCkKCQkJCXByU3RhUmVjLT51NFZodENhcEluZm8gfD0gVkhUX0NBUF9JTkZPX01BWF9TVVBfQ0hBTk5FTF9XSURUSF9TRVRfMTYwXzgwUDgwOwoJCX0KCgkJaWYgKHByU3RhUmVjLT51Y1N0YVN0YXRlID09IFNUQV9TVEFURV8zKSB7CgkJCURCR0xPRyhSTE0sIElORk8sICJVcGRhdGUgT3BNb2RlIHRvIDB4JXgiLCBwclN0YVJlYy0+dWNWaHRPcE1vZGUpOwoJCQlEQkdMT0coUkxNLCBJTkZPLCAidG8gRlcgZHVlIHRvIE9wTW9kZSBOb3RpZmljYWl0aW9uXG4iKTsKCQkJY25tU3RhU2VuZFVwZGF0ZUNtZChwckFkYXB0ZXIsIHByU3RhUmVjLCBOVUxMLCBGQUxTRSk7CgkJfQoJfSBlbHNlIHsvKiBTZXQgRGVmYXVsdCBpZiB0aGUgVkhUIE9QIG1vZGUgZmllbGQgaXMgbm90IHByZXNlbnQgKi8KCQlpZiAoKHByU3RhUmVjLT51Y1ZodE9wTW9kZSAhPSB1Y0luaXRWaHRPcE1vZGUpICYmIChwclN0YVJlYy0+dWNTdGFTdGF0ZSA9PSBTVEFfU1RBVEVfMykpIHsKCQkJcHJTdGFSZWMtPnVjVmh0T3BNb2RlID0gdWNJbml0Vmh0T3BNb2RlOwoJCQlEQkdMT0coUkxNLCBJTkZPLCAiVXBkYXRlIE9wTW9kZSB0byAweCV4IiwgcHJTdGFSZWMtPnVjVmh0T3BNb2RlKTsKCQkJREJHTE9HKFJMTSwgSU5GTywgInRvIEZXIGR1ZSB0byBOTyBPcE1vZGUgTm90aWZpY2FpdGlvblxuIik7CgkJCWNubVN0YVNlbmRVcGRhdGVDbWQocHJBZGFwdGVyLCBwclN0YVJlYywgTlVMTCwgRkFMU0UpOwoJCX0gZWxzZQoJCQlwclN0YVJlYy0+dWNWaHRPcE1vZGUgPSB1Y0luaXRWaHRPcE1vZGU7Cgl9CiNlbmRpZgoKI2lmIENGR19TVVBQT1JUX0RGUwoJLypDaGVjayB3aGV0aGVyIENoYW5uZWwgQW5ub3VuY2VtZW50IElFLCBTZWNvbmRhcnkgT2Zmc2V0IElFICYKCSAqICBXaWRlIEJhbmR3aWR0aCBDaGFubmVsIFN3aXRjaCBJRSBleGlzdCBvciBub3QuIElmIGV4aXN0LCB0aGUgcHJpb3JpdHkgaXMKCSB0aGUgaGlnaGVzdC4KCSAqLwoKCWlmIChmZ0hhc0NoYW5uZWxTd2l0Y2hJRSAhPSBGQUxTRSkgewoJCVBfQlNTX0RFU0NfVCBwckJzc0Rlc2M7CgoJCXByQnNzSW5mby0+dWNQcmltYXJ5Q2hhbm5lbCA9IHVjQ2hhbm5lbEFubm91bmNlUHJpOwoJCXByQnNzSW5mby0+dWNWaHRDaGFubmVsV2lkdGggPSAwOwoJCXByQnNzSW5mby0+dWNWaHRDaGFubmVsRnJlcXVlbmN5UzEgPSAwOwoJCXByQnNzSW5mby0+dWNWaHRDaGFubmVsRnJlcXVlbmN5UzIgPSAwOwoJCXByQnNzSW5mby0+ZUJzc1NDTyA9IDA7CgoJCXByQnNzRGVzYyA9IHNjYW5TZWFyY2hCc3NEZXNjQnlCc3NpZChwckFkYXB0ZXIsIHByQnNzSW5mby0+YXVjQlNTSUQpOwoKCQlpZiAocHJCc3NEZXNjKSB7CgkJCURCR0xPRyhSTE0sIElORk8sICJERlM6IEJTUzogIiBNQUNTVFIgIiBEZXNjIGZvdW5kLCBjaGFubmVsIGZyb20gJXUgdG8gJXVcbiAiLAoJCQkgICAgICAgTUFDMlNUUihwckJzc0luZm8tPmF1Y0JTU0lEKSwgcHJCc3NEZXNjLT51Y0NoYW5uZWxOdW0sIHVjQ2hhbm5lbEFubm91bmNlUHJpKTsKCQkJcHJCc3NEZXNjLT51Y0NoYW5uZWxOdW0gPSB1Y0NoYW5uZWxBbm5vdW5jZVByaTsKCQl9IGVsc2UgewoJCQlEQkdMT0coUkxNLCBJTkZPLCAiREZTOiBCU1M6ICIgTUFDU1RSICIgRGVzYyBpcyBub3QgZm91bmRcbiAiLCBNQUMyU1RSKHByQnNzSW5mby0+YXVjQlNTSUQpKTsKCQl9CgoJCWlmIChmZ0hhc1dpZGVCYW5kSUUgIT0gRkFMU0UpIHsKCQkJcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxXaWR0aCA9IHVjQ2hhbm5lbEFubm91bmNlVmh0Qnc7CgkJCXByQnNzSW5mby0+dWNWaHRDaGFubmVsRnJlcXVlbmN5UzEgPSB1Y0NoYW5uZWxBbm5vdW5jZUNoYW5uZWxTMTsKCQkJcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxGcmVxdWVuY3lTMiA9IHVjQ2hhbm5lbEFubm91bmNlQ2hhbm5lbFMyOwoJCX0KCQlpZiAoZmdIYXNTQ09JRSAhPSBGQUxTRSkKCQkJcHJCc3NJbmZvLT5lQnNzU0NPID0gZUNoYW5uZWxBbm5vdW5jZVNjbzsKCX0KI2VuZGlmCgojaWYgQ0ZHX1NVUFBPUlRfREZTCgkvKkRGUyBDZXJ0aWZpY2F0aW9uIGZvciBDaGFubmVsIEJhbmR3aWR0aCAyME1IeiAqLwoJREJHTE9HKFJMTSwgSU5GTywgIkNoIDogU3dpdGNoSUUgPSAlZFxuIiwgZ19mZ0hhc0NoYW5uZWxTd2l0Y2hJRSk7CglpZiAoZ19mZ0hhc0NoYW5uZWxTd2l0Y2hJRSA9PSBUUlVFKSB7CgkJcHJCc3NJbmZvLT5lQnNzU0NPID0gQ0hOTF9FWFRfU0NOOwoJCXByQnNzSW5mby0+dWNWaHRDaGFubmVsV2lkdGggPSBDV18yMF80ME1IWjsKCQlwckJzc0luZm8tPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMxID0gMDsKCQlwckJzc0luZm8tPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMyID0gMjU1OwoJCXByQnNzSW5mby0+dWNIdE9wSW5mbzEgJj0gfihIVF9PUF9JTkZPMV9TQ08gfCBIVF9PUF9JTkZPMV9TVEFfQ0hOTF9XSURUSCk7CgkJREJHTE9HKFJMTSwgSU5GTywgIkNoIDogREZTIGhhcyBBcHBlYXJlZFxuIik7Cgl9CiNlbmRpZgoJcmxtUmV2aXNlTWF4QncocHJBZGFwdGVyLCBwckJzc0luZm8tPnVjQnNzSW5kZXgsICZwckJzc0luZm8tPmVCc3NTQ08sCgkJCShQX0VOVU1fQ0hBTk5FTF9XSURUSF9QKSZwckJzc0luZm8tPnVjVmh0Q2hhbm5lbFdpZHRoLAoJCSZwckJzc0luZm8tPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMxLCAmcHJCc3NJbmZvLT51Y1ByaW1hcnlDaGFubmVsKTsKCglybG1SZXZpc2VQcmVmZXJCYW5kd2lkdGhOc3MocHJBZGFwdGVyLCBwckJzc0luZm8tPnVjQnNzSW5kZXgsIHByU3RhUmVjKTsKCgkvKnByaW50aygiTW9kaWZ5IENoYW5uZWxXaWR0aCAoJWQpIGFuZCBFeHRlbmQgKCVkKVxuIixwckJzc0luZm8tPmVCc3NTQ08scHJCc3NJbmZvLT51Y1ZodENoYW5uZWxXaWR0aCk7Ki8KCglpZiAoIXJsbURvbWFpbklzVmFsaWRSZlNldHRpbmcocHJBZGFwdGVyLCBwckJzc0luZm8tPmVCYW5kLAoJCQkJICAgICAgIHByQnNzSW5mby0+dWNQcmltYXJ5Q2hhbm5lbCwgcHJCc3NJbmZvLT5lQnNzU0NPLAoJCQkJICAgICAgIHByQnNzSW5mby0+dWNWaHRDaGFubmVsV2lkdGgsIHByQnNzSW5mby0+dWNWaHRDaGFubmVsRnJlcXVlbmN5UzEsCgkJCQkgICAgICAgcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxGcmVxdWVuY3lTMikpIHsKCgkJLypEdW1wIElFIEluZm9yYW10aW9uICovCgkJREJHTE9HKFJMTSwgV0FSTiwgInJsbVJlY0llSW5mb0ZvckNsaWVudCBJRSBJbmZvcm1hdGlvblxuIik7CgkJREJHTE9HKFJMTSwgV0FSTiwgIklFIExlbmd0aCA9ICVkXG4iLCB1MklFTGVuZ3RoKTsKCQlEQkdMT0dfTUVNOChSTE0sIFdBUk4sIHB1Y0R1bXBJRSwgdTJJRUxlbmd0aCk7CgoJCS8qRXJyb3IgSGFuZGxpbmcgZm9yIE5vbi1wcmVkaWN0ZWQgSUUgLSBGaXhlZCB0byBzZXQgMjBNSHogKi8KCQlwckJzc0luZm8tPnVjVmh0Q2hhbm5lbFdpZHRoID0gQ1dfMjBfNDBNSFo7CgkJcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxGcmVxdWVuY3lTMSA9IDA7CgkJcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxGcmVxdWVuY3lTMiA9IDA7CgkJcHJCc3NJbmZvLT5lQnNzU0NPID0gQ0hOTF9FWFRfU0NOOwoJCXByQnNzSW5mby0+dWNIdE9wSW5mbzEgJj0gfihIVF9PUF9JTkZPMV9TQ08gfCBIVF9PUF9JTkZPMV9TVEFfQ0hOTF9XSURUSCk7Cgl9CiNpZiBDRkdfU1VQUE9SVF9RVUlFVCAmJiAwCglpZiAoIWZnSGFzUXVpZXRJRSkKCQlycm1RdWlldEllTm90RXhpc3QocHJBZGFwdGVyLCBwckJzc0luZm8pOwojZW5kaWYKCgkvKiBDaGVjayBpZiBPQlNTIHNjYW4gcHJvY2VzcyB3aWxsIGxhdW5jaCAqLwoJaWYgKCFwckFkYXB0ZXItPmZnRW5PbmxpbmVTY2FuIHx8ICFwck9ic3NTY25QYXJhbSB8fAoJICAgICEocHJTdGFSZWMtPnUySHRDYXBJbmZvICYgSFRfQ0FQX0lORk9fU1VQX0NITkxfV0lEVEgpIHx8CgkgICAgcHJCc3NJbmZvLT5lQmFuZCAhPSBCQU5EXzJHNCB8fCAhcHJCc3NJbmZvLT5mZzQwbUJ3QWxsb3dlZCkgewoKCQkvKiBOb3RlOiBpdCBpcyBvayBub3QgdG8gc3RvcCByT2Jzc1NjYW5UaW1lcigpIGhlcmUgKi8KCQlwckJzc0luZm8tPnUyT2Jzc1NjYW5JbnRlcnZhbCA9IDA7Cgl9IGVsc2UgewoJCWlmIChwck9ic3NTY25QYXJhbS0+dTJUcmlnZ2VyU2NhbkludGVydmFsIDwgT0JTU19TQ0FOX01JTl9JTlRFUlZBTCkKCQkJcHJPYnNzU2NuUGFyYW0tPnUyVHJpZ2dlclNjYW5JbnRlcnZhbCA9IE9CU1NfU0NBTl9NSU5fSU5URVJWQUw7CgkJaWYgKHByQnNzSW5mby0+dTJPYnNzU2NhbkludGVydmFsICE9IHByT2Jzc1NjblBhcmFtLT51MlRyaWdnZXJTY2FuSW50ZXJ2YWwpIHsKCgkJCXByQnNzSW5mby0+dTJPYnNzU2NhbkludGVydmFsID0gcHJPYnNzU2NuUGFyYW0tPnUyVHJpZ2dlclNjYW5JbnRlcnZhbDsKCgkJCS8qIFN0YXJ0IHRpbWVyIHRvIHRyaWdnZXIgT0JTUyBzY2FubmluZyAqLwoJCQljbm1UaW1lclN0YXJ0VGltZXIocHJBZGFwdGVyLCAmcHJCc3NJbmZvLT5yT2Jzc1NjYW5UaW1lciwKCQkJCQkgICBwckJzc0luZm8tPnUyT2Jzc1NjYW5JbnRlcnZhbCAqIE1TRUNfUEVSX1NFQyk7CgkJfQoJfQoKCXJldHVybiB1Y1ByaW1hcnlDaGFubmVsOwp9CgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYgVXBkYXRlIHBhcmFtZXRlcnMgZnJvbSBBc3NvY2lhdGlvbiBSZXNwb25zZSBmcmFtZQoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCnN0YXRpYyBWT0lECnJsbVJlY0Fzc29jUmVzcEllSW5mb0ZvckNsaWVudChQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfQlNTX0lORk9fVCBwckJzc0luZm8sIFBVSU5UXzggcHVjSUUsIFVJTlRfMTYgdTJJRUxlbmd0aCkKewoJVUlOVF8xNiB1Mk9mZnNldDsKCVBfU1RBX1JFQ09SRF9UIHByU3RhUmVjOwoJQk9PTEVBTiBmZ0lzSGFzSHRDYXAgPSBGQUxTRTsKCUJPT0xFQU4gZmdJc0hhc1ZodENhcCA9IEZBTFNFOwoJUF9CU1NfREVTQ19UIHByQnNzRGVzYzsKCglBU1NFUlQocHJBZGFwdGVyKTsKCUFTU0VSVChwckJzc0luZm8pOwoJQVNTRVJUKHB1Y0lFKTsKCglwclN0YVJlYyA9IHByQnNzSW5mby0+cHJTdGFSZWNPZkFQOwoKCUFTU0VSVChwclN0YVJlYyk7CglpZiAoIXByU3RhUmVjKQoJCXJldHVybjsKCglwckJzc0Rlc2MgPSBzY2FuU2VhcmNoQnNzRGVzY0J5QnNzaWQocHJBZGFwdGVyLCBwclN0YVJlYy0+YXVjTWFjQWRkcik7CgoJSUVfRk9SX0VBQ0gocHVjSUUsIHUySUVMZW5ndGgsIHUyT2Zmc2V0KSB7CgkJc3dpdGNoIChJRV9JRChwdWNJRSkpIHsKCQljYXNlIEVMRU1fSURfSFRfQ0FQOgoJCQlpZiAoIVJMTV9ORVRfSVNfMTFOKHByQnNzSW5mbykgfHwgSUVfTEVOKHB1Y0lFKSAhPSAoc2l6ZW9mKElFX0hUX0NBUF9UKSAtIDIpKQoJCQkJYnJlYWs7CgkJCWZnSXNIYXNIdENhcCA9IFRSVUU7CgkJCWJyZWFrOwojaWYgQ0ZHX1NVUFBPUlRfODAyXzExQUMKCQljYXNlIEVMRU1fSURfVkhUX0NBUDoKCQkJaWYgKCFSTE1fTkVUX0lTXzExQUMocHJCc3NJbmZvKSB8fCBJRV9MRU4ocHVjSUUpICE9IChzaXplb2YoSUVfVkhUX0NBUF9UKSAtIDIpKQoJCQkJYnJlYWs7CgkJCWZnSXNIYXNWaHRDYXAgPSBUUlVFOwoJCQlicmVhazsKI2VuZGlmCgkJZGVmYXVsdDoKCQkJYnJlYWs7CgkJfSAvKiBlbmQgb2Ygc3dpdGNoICovCgl9IC8qIGVuZCBvZiBJRV9GT1JfRUFDSCAqLwoKCWlmICghZmdJc0hhc0h0Q2FwKSB7CgkJcHJTdGFSZWMtPnVjRGVzaXJlZFBoeVR5cGVTZXQgJj0gflBIWV9UWVBFX0JJVF9IVDsKCQlpZiAocHJCc3NEZXNjKSB7CgkJCWlmIChwckJzc0Rlc2MtPnVjUGh5VHlwZVNldCAmJiBQSFlfVFlQRV9CSVRfSFQpIHsKCQkJCURCR0xPRyhSTE0sIFdBUk4sICJQaHlUeXBlU2V0IGluIEJlYWNvbiBhbmQgQXNzb2NSZXNwIGFyZSB1bnN5bmMuICIpOwoJCQkJREJHTE9HKFJMTSwgV0FSTiwgIkZvbGxvdyBBc3NvY1Jlc3AgdG8gZGlzYWJsZSBIVC5cbiIpOwoJCQl9CgkJfQoJfQoJaWYgKCFmZ0lzSGFzVmh0Q2FwKSB7CgkJcHJTdGFSZWMtPnVjRGVzaXJlZFBoeVR5cGVTZXQgJj0gflBIWV9UWVBFX0JJVF9WSFQ7CgkJaWYgKHByQnNzRGVzYykgewoJCQlpZiAocHJCc3NEZXNjLT51Y1BoeVR5cGVTZXQgJiYgUEhZX1RZUEVfQklUX1ZIVCkgewoJCQkJREJHTE9HKFJMTSwgV0FSTiwgIlBoeVR5cGVTZXQgaW4gQmVhY29uIGFuZCBBc3NvY1Jlc3AgYXJlIHVuc3luYy4gIik7CgkJCQlEQkdMT0coUkxNLCBXQVJOLCAiRm9sbG93IEFzc29jUmVzcCB0byBkaXNhYmxlIFZIVC5cbiIpOwoJCQl9CgkJfQoJfQp9CgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYgQUlTIG9yIFAyUCBHQy4KKgoqIFxwYXJhbVtpbl0KKgoqIFxyZXR1cm4gbm9uZQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpzdGF0aWMgQk9PTEVBTgpybG1SZWNCY25Gcm9tTmVpZ2hib3JGb3JDbGllbnQoUF9BREFQVEVSX1QgcHJBZGFwdGVyLAoJCQkgICAgICAgUF9CU1NfSU5GT19UIHByQnNzSW5mbywgUF9TV19SRkJfVCBwclN3UmZiLCBQVUlOVF84IHB1Y0lFLCBVSU5UXzE2IHUySUVMZW5ndGgpCnsKCVVJTlRfMTYgdTJPZmZzZXQsIGk7CglVSU5UXzggdWNQcmlDaGFubmVsLCB1Y1NlY0NoYW5uZWw7CglFTlVNX0NITkxfRVhUX1QgZVNDTzsKCUJPT0xFQU4gZmdIdEJzcywgZmcyMG1SZXE7CgoJQVNTRVJUKHByQWRhcHRlcik7CglBU1NFUlQocHJCc3NJbmZvICYmIHByU3dSZmIpOwoJQVNTRVJUKHB1Y0lFKTsKCgkvKiBSZWNvcmQgaXQgdG8gY2hhbm5lbCBsaXN0IHRvIGNoYW5nZSAyMC80MCBiYW5kd2lkdGggKi8KCXVjUHJpQ2hhbm5lbCA9IDA7CgllU0NPID0gQ0hOTF9FWFRfU0NOOwoKCWZnSHRCc3MgPSBGQUxTRTsKCWZnMjBtUmVxID0gRkFMU0U7CgoJSUVfRk9SX0VBQ0gocHVjSUUsIHUySUVMZW5ndGgsIHUyT2Zmc2V0KSB7CgkJc3dpdGNoIChJRV9JRChwdWNJRSkpIHsKCQljYXNlIEVMRU1fSURfSFRfQ0FQOgoJCQl7CgkJCQlQX0lFX0hUX0NBUF9UIHBySHRDYXA7CgoJCQkJaWYgKElFX0xFTihwdWNJRSkgIT0gKHNpemVvZihJRV9IVF9DQVBfVCkgLSAyKSkKCQkJCQlicmVhazsKCgkJCQlwckh0Q2FwID0gKFBfSUVfSFRfQ0FQX1QpIHB1Y0lFOwoJCQkJaWYgKHBySHRDYXAtPnUySHRDYXBJbmZvICYgSFRfQ0FQX0lORk9fNDBNX0lOVE9MRVJBTlQpCgkJCQkJZmcyMG1SZXEgPSBUUlVFOwoJCQkJZmdIdEJzcyA9IFRSVUU7CgkJCQlicmVhazsKCQkJfQoJCWNhc2UgRUxFTV9JRF9IVF9PUDoKCQkJewoJCQkJUF9JRV9IVF9PUF9UIHBySHRPcDsKCgkJCQlpZiAoSUVfTEVOKHB1Y0lFKSAhPSAoc2l6ZW9mKElFX0hUX09QX1QpIC0gMikpCgkJCQkJYnJlYWs7CgoJCQkJcHJIdE9wID0gKFBfSUVfSFRfT1BfVCkgcHVjSUU7CgkJCQkvKiBXb3JrYXJvdW5kIHRoYXQgc29tZSBBUHMgZmlsbCBwcmltYXJ5IGNoYW5uZWwgZmllbGQgYnkgaXRzCgkJCQkgKiBzZWNvbmRhcnkgY2hhbm5lbCwgYnV0IGl0cyBEUyBJRSBpcyBjb3JyZWN0IDIwMTEwNjEwCgkJCQkgKi8KCQkJCWlmICh1Y1ByaUNoYW5uZWwgPT0gMCkKCQkJCQl1Y1ByaUNoYW5uZWwgPSBwckh0T3AtPnVjUHJpbWFyeUNoYW5uZWw7CgoJCQkJaWYgKChwckh0T3AtPnVjSW5mbzEgJiBIVF9PUF9JTkZPMV9TQ08pICE9IENITkxfRVhUX1JFUykKCQkJCQllU0NPID0gKEVOVU1fQ0hOTF9FWFRfVCkgKHBySHRPcC0+dWNJbmZvMSAmIEhUX09QX0lORk8xX1NDTyk7CgkJCQlicmVhazsKCQkJfQoJCWNhc2UgRUxFTV9JRF8yMF80MF9CU1NfQ09FWElTVEVOQ0U6CgkJCXsKCQkJCVBfSUVfMjBfNDBfQ09FWElTVF9UIHByQ29leGlzdDsKCgkJCQlpZiAoSUVfTEVOKHB1Y0lFKSAhPSAoc2l6ZW9mKElFXzIwXzQwX0NPRVhJU1RfVCkgLSAyKSkKCQkJCQlicmVhazsKCgkJCQlwckNvZXhpc3QgPSAoUF9JRV8yMF80MF9DT0VYSVNUX1QpIHB1Y0lFOwoJCQkJaWYgKHByQ29leGlzdC0+dWNEYXRhICYgQlNTX0NPRVhJU1RfNDBNX0lOVE9MRVJBTlQpCgkJCQkJZmcyMG1SZXEgPSBUUlVFOwoJCQkJYnJlYWs7CgkJCX0KCQljYXNlIEVMRU1fSURfRFNfUEFSQU1fU0VUOgoJCQlpZiAoSUVfTEVOKHB1Y0lFKSAhPSAoc2l6ZW9mKElFX0RTX1BBUkFNX1NFVF9UKSAtIDIpKQoJCQkJYnJlYWs7CgkJCXVjUHJpQ2hhbm5lbCA9IERTX1BBUkFNX0lFKHB1Y0lFKS0+dWNDdXJyQ2hubDsKCQkJYnJlYWs7CgoJCWRlZmF1bHQ6CgkJCWJyZWFrOwoJCX0KCX0KCgkvKiBUbyBkbzogVXBkYXRlIGNoYW5uZWwgbGlzdCBhbmQgNUcgYmFuZC4gQWxsIGNoYW5uZWwgbGlzdHMgaGF2ZSB0aGUgc2FtZQoJICogdXBkYXRlIHByb2NlZHVyZS4gV2Ugc2hvdWxkIGdpdmUgaXQgdGhlIGVudHJ5IHBvaW50ZXIgb2YgZGVzaXJlZAoJICogY2hhbm5lbCBsaXN0LgoJICovCglpZiAoSEFMX1JYX1NUQVRVU19HRVRfUkZfQkFORChwclN3UmZiLT5wclJ4U3RhdHVzKSAhPSBCQU5EXzJHNCkKCQlyZXR1cm4gRkFMU0U7CgoJaWYgKHVjUHJpQ2hhbm5lbCA9PSAwIHx8IHVjUHJpQ2hhbm5lbCA+IDE0KQoJCXVjUHJpQ2hhbm5lbCA9IEhBTF9SWF9TVEFUVVNfR0VUX0NITkxfTlVNKHByU3dSZmItPnByUnhTdGF0dXMpOwoKCWlmIChmZ0h0QnNzKSB7CgkJQVNTRVJUKHByQnNzSW5mby0+YXVjMkdfUHJpQ2hubExpc3RbMF0gPD0gQ0hOTF9MSVNUX1NaXzJHKTsKCQlmb3IgKGkgPSAxOyBpIDw9IHByQnNzSW5mby0+YXVjMkdfUHJpQ2hubExpc3RbMF0gJiYgaSA8PSBDSE5MX0xJU1RfU1pfMkc7IGkrKykgewoJCQlpZiAocHJCc3NJbmZvLT5hdWMyR19QcmlDaG5sTGlzdFtpXSA9PSB1Y1ByaUNoYW5uZWwpCgkJCQlicmVhazsKCQl9CgkJaWYgKChpID4gcHJCc3NJbmZvLT5hdWMyR19QcmlDaG5sTGlzdFswXSkgJiYgKGkgPD0gQ0hOTF9MSVNUX1NaXzJHKSkgewoJCQlwckJzc0luZm8tPmF1YzJHX1ByaUNobmxMaXN0W2ldID0gdWNQcmlDaGFubmVsOwoJCQlwckJzc0luZm8tPmF1YzJHX1ByaUNobmxMaXN0WzBdKys7CgkJfQoKCQkvKiBVcGRhdGUgc2Vjb25kYXJ5IGNoYW5uZWwgKi8KCQlpZiAoZVNDTyAhPSBDSE5MX0VYVF9TQ04pIHsKCQkJdWNTZWNDaGFubmVsID0gKGVTQ08gPT0gQ0hOTF9FWFRfU0NBKSA/ICh1Y1ByaUNoYW5uZWwgKyA0KSA6ICh1Y1ByaUNoYW5uZWwgLSA0KTsKCgkJCUFTU0VSVChwckJzc0luZm8tPmF1YzJHX1NlY0NobmxMaXN0WzBdIDw9IENITkxfTElTVF9TWl8yRyk7CgkJCWZvciAoaSA9IDE7IGkgPD0gcHJCc3NJbmZvLT5hdWMyR19TZWNDaG5sTGlzdFswXSAmJiBpIDw9IENITkxfTElTVF9TWl8yRzsgaSsrKSB7CgkJCQlpZiAocHJCc3NJbmZvLT5hdWMyR19TZWNDaG5sTGlzdFtpXSA9PSB1Y1NlY0NoYW5uZWwpCgkJCQkJYnJlYWs7CgkJCX0KCQkJaWYgKChpID4gcHJCc3NJbmZvLT5hdWMyR19TZWNDaG5sTGlzdFswXSkgJiYgKGkgPD0gQ0hOTF9MSVNUX1NaXzJHKSkgewoJCQkJcHJCc3NJbmZvLT5hdWMyR19TZWNDaG5sTGlzdFtpXSA9IHVjU2VjQ2hhbm5lbDsKCQkJCXByQnNzSW5mby0+YXVjMkdfU2VjQ2hubExpc3RbMF0rKzsKCQkJfQoJCX0KCgkJLyogVXBkYXRlIDIwTSBiYW5kd2lkdGggcmVxdWVzdCBjaGFubmVscyAqLwoJCWlmIChmZzIwbVJlcSkgewoJCQlBU1NFUlQocHJCc3NJbmZvLT5hdWMyR18yMG1SZXFDaG5sTGlzdFswXSA8PSBDSE5MX0xJU1RfU1pfMkcpOwoJCQlmb3IgKGkgPSAxOyBpIDw9IHByQnNzSW5mby0+YXVjMkdfMjBtUmVxQ2hubExpc3RbMF0gJiYgaSA8PSBDSE5MX0xJU1RfU1pfMkc7IGkrKykgewoJCQkJaWYgKHByQnNzSW5mby0+YXVjMkdfMjBtUmVxQ2hubExpc3RbaV0gPT0gdWNQcmlDaGFubmVsKQoJCQkJCWJyZWFrOwoJCQl9CgkJCWlmICgoaSA+IHByQnNzSW5mby0+YXVjMkdfMjBtUmVxQ2hubExpc3RbMF0pICYmIChpIDw9IENITkxfTElTVF9TWl8yRykpIHsKCQkJCXByQnNzSW5mby0+YXVjMkdfMjBtUmVxQ2hubExpc3RbaV0gPSB1Y1ByaUNoYW5uZWw7CgkJCQlwckJzc0luZm8tPmF1YzJHXzIwbVJlcUNobmxMaXN0WzBdKys7CgkJCX0KCQl9Cgl9IGVsc2UgewoJCS8qIFVwZGF0ZSBub24tSFQgY2hhbm5lbCBsaXN0ICovCgkJQVNTRVJUKHByQnNzSW5mby0+YXVjMkdfTm9uSHRDaG5sTGlzdFswXSA8PSBDSE5MX0xJU1RfU1pfMkcpOwoJCWZvciAoaSA9IDE7IGkgPD0gcHJCc3NJbmZvLT5hdWMyR19Ob25IdENobmxMaXN0WzBdICYmIGkgPD0gQ0hOTF9MSVNUX1NaXzJHOyBpKyspIHsKCQkJaWYgKHByQnNzSW5mby0+YXVjMkdfTm9uSHRDaG5sTGlzdFtpXSA9PSB1Y1ByaUNoYW5uZWwpCgkJCQlicmVhazsKCQl9CgkJaWYgKChpID4gcHJCc3NJbmZvLT5hdWMyR19Ob25IdENobmxMaXN0WzBdKSAmJiAoaSA8PSBDSE5MX0xJU1RfU1pfMkcpKSB7CgkJCXByQnNzSW5mby0+YXVjMkdfTm9uSHRDaG5sTGlzdFtpXSA9IHVjUHJpQ2hhbm5lbDsKCQkJcHJCc3NJbmZvLT5hdWMyR19Ob25IdENobmxMaXN0WzBdKys7CgkJfQoKCX0KCglyZXR1cm4gRkFMU0U7Cn0KCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIFxicmllZiBBSVMgb3IgUDJQIEdDLgoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCnN0YXRpYyBCT09MRUFOCnJsbVJlY0JjbkluZm9Gb3JDbGllbnQoUF9BREFQVEVSX1QgcHJBZGFwdGVyLAoJCSAgICAgICBQX0JTU19JTkZPX1QgcHJCc3NJbmZvLCBQX1NXX1JGQl9UIHByU3dSZmIsIFBVSU5UXzggcHVjSUUsIFVJTlRfMTYgdTJJRUxlbmd0aCkKewoJQVNTRVJUKHByQWRhcHRlcik7CglBU1NFUlQocHJCc3NJbmZvICYmIHByU3dSZmIpOwoJQVNTRVJUKHB1Y0lFKTsKCiNpZiAwCQkJCS8qIFNXIG1pZ3JhdGlvbiAyMDEwLzgvMjAgKi8KCS8qIE5vdGU6IHdlIHNoYWxsIG5vdCB1cGRhdGUgcGFyYW1ldGVycyB3aGVuIHNjYW5uaW5nLCBvdGhlcndpc2UKCSAqICAgICAgIGNoYW5uZWwgYW5kIGJhbmR3aWR0aCB3aWxsIG5vdCBiZSBjb3JyZWN0IG9yIGFzc2VydGVkIGZhaWx1cmUKCSAqICAgICAgIGR1cmluZyBzY2FubmluZy4KCSAqIE5vdGU6IHJlbW92ZSBjaGFubmVsIGNoZWNraW5nLiBBbGwgcmVjZWl2ZWQgQmVhY29ucyBzaG91bGQgYmUgcHJvY2Vzc2VkCgkgKiAgICAgICBpZiBtZWFzdXJlbWVudCBvciBvdGhlciBhY3Rpb25zIGFyZSBleGVjdXRlZCBpbiBhZGphY2VudCBjaGFubmVscwoJICogICAgICAgYW5kIEJlYWNvbiBjb250ZW50IGNoZWNraW5nIG1lY2hhbmlzbSBpcyBub3QgZGlzYWJsZWQuCgkgKi8KCWlmIChJU19TQ0FOX0FDVElWRSgpCgkgICAgLyogfHwgcHJCc3NJbmZvLT51Y1ByaW1hcnlDaGFubmVsICE9IENITkxfTlVNX0JZX1NXUkZCKHByU3dSZmIpICovCgkgICAgKSB7CgkJcmV0dXJuIEZBTFNFOwoJfQojZW5kaWYKCgkvKiBIYW5kbGUgY2hhbmdlIG9mIHNsb3QgdGltZSAqLwoJcHJCc3NJbmZvLT51MkNhcEluZm8gPSAoKFBfV0xBTl9CRUFDT05fRlJBTUVfVCkgKHByU3dSZmItPnB2SGVhZGVyKSktPnUyQ2FwSW5mbzsKCXByQnNzSW5mby0+ZmdVc2VTaG9ydFNsb3RUaW1lID0gKChwckJzc0luZm8tPnUyQ2FwSW5mbyAmIENBUF9JTkZPX1NIT1JUX1NMT1RfVElNRSkKCQkJCQkgfHwgKHByQnNzSW5mby0+ZUJhbmQgIT0gQkFORF8yRzQpKSA/IFRSVUUgOiBGQUxTRTsKCglybG1SZWNJZUluZm9Gb3JDbGllbnQocHJBZGFwdGVyLCBwckJzc0luZm8sIHB1Y0lFLCB1MklFTGVuZ3RoKTsKCglyZXR1cm4gVFJVRTsKfQoKLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLyohCiogXGJyaWVmCioKKiBccGFyYW1baW5dCioKKiBccmV0dXJuIG5vbmUKKi8KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KVk9JRCBybG1Qcm9jZXNzQmNuKFBfQURBUFRFUl9UIHByQWRhcHRlciwgUF9TV19SRkJfVCBwclN3UmZiLCBQVUlOVF84IHB1Y0lFLCBVSU5UXzE2IHUySUVMZW5ndGgpCnsKCVBfQlNTX0lORk9fVCBwckJzc0luZm87CglCT09MRUFOIGZnTmV3UGFyYW1ldGVyOwoJVUlOVF84IGk7CgoJQVNTRVJUKHByQWRhcHRlcik7CglBU1NFUlQocHJTd1JmYik7CglBU1NFUlQocHVjSUUpOwoKCWZnTmV3UGFyYW1ldGVyID0gRkFMU0U7CgoJLyogV2hlbiBjb25jdXJyZW50IG5ldHdvcmtzIGV4aXN0LCBHTyBzaGFsbCBoYXZlIHRoZSBzYW1lIGhhbmRsZSBhcwoJICogdGhlIG90aGVyIEJTUywgc28gdGhlIEJlYWNvbiBzaGFsbCBiZSBwcm9jZXNzZWQgZm9yIGJhbmR3aWR0aCBhbmQKCSAqIHByb3RlY3Rpb24gbWVjaGFuaXNtLgoJICogTm90ZTE6IHdlIGRvIG5vdCBoYXZlIDIgQVAgKEdPKSBjYXNlcyBzaW11bHRhbmVvdXNseSBub3cuCgkgKiBOb3RlMjogSWYgd2UgYXJlIEdPLCBjb25jdXJyZW50IEFJUyBBUCBzaG91bGQgZGV0ZWN0IGl0IGFuZCByZWZsZWN0CgkgKiAgICAgICAgYWN0aW9uIGluIGl0cyBCZWFjb24sIHNvIEFJUyBTVEEganVzdCBmb2xsb3dzIEJlYWNvbiBmcm9tIEFQLgoJICovCglmb3IgKGkgPSAwOyBpIDwgQlNTX0lORk9fTlVNOyBpKyspIHsKCQlwckJzc0luZm8gPSBwckFkYXB0ZXItPmFwckJzc0luZm9baV07CgoJCWlmIChJU19CU1NfQk9XKHByQnNzSW5mbykpCgkJCWNvbnRpbnVlOwoKCQlpZiAoSVNfQlNTX0FDVElWRShwckJzc0luZm8pKSB7CgkJCWlmIChwckJzc0luZm8tPmVDdXJyZW50T1BNb2RlID09IE9QX01PREVfSU5GUkFTVFJVQ1RVUkUgJiYKCQkJICAgIHByQnNzSW5mby0+ZUNvbm5lY3Rpb25TdGF0ZSA9PSBQQVJBTV9NRURJQV9TVEFURV9DT05ORUNURUQpIHsKCQkJCS8qIFAyUCBjbGllbnQgb3IgQUlTIGluZnJhIFNUQSAqLwoJCQkJaWYgKEVRVUFMX01BQ19BRERSKHByQnNzSW5mby0+YXVjQlNTSUQsICgoUF9XTEFOX01BQ19NR01UX0hFQURFUl9UKQoJCQkJCQkJCQkgKHByU3dSZmItPnB2SGVhZGVyKSktPmF1Y0JTU0lEKSkgewoKCQkJCQlmZ05ld1BhcmFtZXRlciA9IHJsbVJlY0JjbkluZm9Gb3JDbGllbnQocHJBZGFwdGVyLAoJCQkJCQkJCQkJcHJCc3NJbmZvLCBwclN3UmZiLCBwdWNJRSwgdTJJRUxlbmd0aCk7CgkJCQl9IGVsc2UgewoJCQkJCWZnTmV3UGFyYW1ldGVyID0gcmxtUmVjQmNuRnJvbU5laWdoYm9yRm9yQ2xpZW50KHByQWRhcHRlciwKCQkJCQkJCQkJCQlwckJzc0luZm8sCgkJCQkJCQkJCQkJcHJTd1JmYiwgcHVjSUUsIHUySUVMZW5ndGgpOwoJCQkJfQoJCQl9CiNpZiBDRkdfRU5BQkxFX1dJRklfRElSRUNUCgkJCWVsc2UgaWYgKHByQWRhcHRlci0+ZmdJc1AyUFJlZ2lzdGVyZWQgJiYKCQkJCSAocHJCc3NJbmZvLT5lQ3VycmVudE9QTW9kZSA9PSBPUF9NT0RFX0FDQ0VTU19QT0lOVCB8fAoJCQkJICBwckJzc0luZm8tPmVDdXJyZW50T1BNb2RlID09IE9QX01PREVfUDJQX0RFVklDRSkpIHsKCQkJCS8qIEFQIHNjYW4gdG8gY2hlY2sgaWYgMjAvNDBNIGJhbmR3aWR0aCBpcyBwZXJtaXR0ZWQgKi8KCQkJCXJsbVJlY0JjbkZyb21OZWlnaGJvckZvckNsaWVudChwckFkYXB0ZXIsIHByQnNzSW5mbywgcHJTd1JmYiwgcHVjSUUsIHUySUVMZW5ndGgpOwoJCQl9CiNlbmRpZgoJCQllbHNlIGlmIChwckJzc0luZm8tPmVDdXJyZW50T1BNb2RlID09IE9QX01PREVfSUJTUykgewoJCQkJLyogVG8gZG86IE5vdGhpbmcgKi8KCQkJCS8qIFRvIGRvOiBBZC1ob2MgKi8KCQkJfQoKCQkJLyogQXBweSBuZXcgcGFyYW1ldGVycyBpZiBuZWNlc3NhcnkgKi8KCQkJaWYgKGZnTmV3UGFyYW1ldGVyKSB7CgkJCQlybG1TeW5jT3BlcmF0aW9uUGFyYW1zKHByQWRhcHRlciwgcHJCc3NJbmZvKTsKCQkJCWZnTmV3UGFyYW1ldGVyID0gRkFMU0U7CgkJCX0KCQl9CQkvKiBlbmQgb2YgSVNfQlNTX0FDVElWRSgpICovCgl9Cn0KCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIFxicmllZiBUaGlzIGZ1bmN0aW9uIHNob3VsZCBiZSBpbnZva2VkIGFmdGVyIGp1ZGdpbmcgc3VjY2Vzc2Z1bCBhc3NvY2lhdGlvbi4KKgoqIFxwYXJhbVtpbl0KKgoqIFxyZXR1cm4gbm9uZQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpWT0lEIHJsbVByb2Nlc3NBc3NvY1JzcChQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfU1dfUkZCX1QgcHJTd1JmYiwgUFVJTlRfOCBwdWNJRSwgVUlOVF8xNiB1MklFTGVuZ3RoKQp7CglQX0JTU19JTkZPX1QgcHJCc3NJbmZvOwoJUF9TVEFfUkVDT1JEX1QgcHJTdGFSZWM7CglVSU5UXzggdWNQcmlDaGFubmVsOwoKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByU3dSZmIpOwoJQVNTRVJUKHB1Y0lFKTsKCglwclN0YVJlYyA9IGNubUdldFN0YVJlY0J5SW5kZXgocHJBZGFwdGVyLCBwclN3UmZiLT51Y1N0YVJlY0lkeCk7CglpZiAoIXByU3RhUmVjKQoJCXJldHVybjsKCglwckJzc0luZm8gPSBHRVRfQlNTX0lORk9fQllfSU5ERVgocHJBZGFwdGVyLCBwclN0YVJlYy0+dWNCc3NJbmRleCk7CglpZiAoIXByQnNzSW5mbykKCQlyZXR1cm47CgoJaWYgKHByU3RhUmVjICE9IHByQnNzSW5mby0+cHJTdGFSZWNPZkFQKQoJCXJldHVybjsKCgkvKiBUbyBkbzogdGhlIGludm9rZWQgZnVuY3Rpb24gaXMgdXNlZCB0byBjbGVhciBhbGwgbWVtYmVycy4gSXQgbWF5IGJlCgkgKiAgICAgICAgZG9uZSBieSBjZW50ZXIgbWVjaGFuaXNtIGluIGludm9rZXIuCgkgKi8KCXJsbUJzc1Jlc2V0KHByQWRhcHRlciwgcHJCc3NJbmZvKTsKCglwckJzc0luZm8tPmZnVXNlU2hvcnRTbG90VGltZSA9ICgocHJCc3NJbmZvLT51MkNhcEluZm8gJiBDQVBfSU5GT19TSE9SVF9TTE9UX1RJTUUpCgkJCQkJIHx8IChwckJzc0luZm8tPmVCYW5kICE9IEJBTkRfMkc0KSkgPyBUUlVFIDogRkFMU0U7Cgl1Y1ByaUNoYW5uZWwgPSBybG1SZWNJZUluZm9Gb3JDbGllbnQocHJBZGFwdGVyLCBwckJzc0luZm8sIHB1Y0lFLCB1MklFTGVuZ3RoKTsKCgkvKlVwZGF0ZSB0aGUgcGFyYW1ldGVycyBmcm9tIEFzc29jaWF0aW9uIFJlc3BvbnNlIG9ubHksCgkqaWYgdGhlIHBhcmFtZXRlcnMgbmVlZCB0byBiZSB1cGRhdGVkIGJ5IGJvdGggQmVhY29uIGFuZCBBc3NvY2lhdGlvbiBSZXNwb25zZSwKCSp1c2VyIHNob3VsZCB1c2UgYW5vdGhlciBmdW5jdGlvbiwgcmxtUmVjSWVJbmZvRm9yQ2xpZW50KCkKCSovCglybG1SZWNBc3NvY1Jlc3BJZUluZm9Gb3JDbGllbnQocHJBZGFwdGVyLCBwckJzc0luZm8sIHB1Y0lFLCB1MklFTGVuZ3RoKTsKCglpZiAocHJCc3NJbmZvLT51Y1ByaW1hcnlDaGFubmVsICE9IHVjUHJpQ2hhbm5lbCkgewoJCURCR0xPRyhSTE0sIElORk8sCgkJICAgICAgICJVc2UgUkYgcHJpIGNoYW5uZWxbJXVdLlByaSBjaGFubmVsIGluIEhUIE9QIElFIGlzIDpbJXVdXG4iLCBwckJzc0luZm8tPnVjUHJpbWFyeUNoYW5uZWwsCgkJICAgICAgIHVjUHJpQ2hhbm5lbCk7Cgl9CgkvKkF2b2lkIHdyb25nIHByaW1hcnkgY2hhbm5lbCBpbmZvIGluIEhUIG9wZXJhdGlvbiBJRSBpbmZvIHdoZW4gYWNjZXB0IGFzc29jaWF0aW9uIHJlc3BvbnNlICovCiNpZiAwCglpZiAodWNQcmlDaGFubmVsID4gMCkKCQlwckJzc0luZm8tPnVjUHJpbWFyeUNoYW5uZWwgPSB1Y1ByaUNoYW5uZWw7CiNlbmRpZgoKCWlmICghUkxNX05FVF9JU18xMU4ocHJCc3NJbmZvKSB8fCAhKHByU3RhUmVjLT51Mkh0Q2FwSW5mbyAmIEhUX0NBUF9JTkZPX1NVUF9DSE5MX1dJRFRIKSkKCQlwckJzc0luZm8tPmZnNDBtQndBbGxvd2VkID0gRkFMU0U7CgoJLyogTm90ZTogVXBkYXRlIGl0cyBjYXBhYmlsaXRpZXMgdG8gV1RCTCBieSBjbm1TdGFSZWNDaGFuZ2VTdGF0ZSgpLCB3aGljaAoJICogICAgICAgc2hhbGwgYmUgaW52b2tlZCBhZnRlcndhcmRzLgoJICogICAgICAgVXBkYXRlIGNoYW5uZWwsIGJhbmR3aWR0aCBhbmQgcHJvdGVjdGlvbiBtb2RlIGJ5IG5pY1VwZGF0ZUJzcygpCgkgKi8KfQoKLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLyohCiogXGJyaWVmCioKKiBccGFyYW1baW5dCioKKiBccmV0dXJuIG5vbmUKKi8KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KVk9JRCBybG1Qcm9jZXNzSHRBY3Rpb24oUF9BREFQVEVSX1QgcHJBZGFwdGVyLCBQX1NXX1JGQl9UIHByU3dSZmIpCnsKCVBfQUNUSU9OX05PVElGWV9DSE5MX1dJRFRIX0ZSQU1FIHByUnhGcmFtZTsKCVBfQUNUSU9OX1NNX1BPV0VSX1NBVkVfRlJBTUUgcHJSeFNtcHNGcmFtZTsKCVBfU1RBX1JFQ09SRF9UIHByU3RhUmVjOwoJUF9CU1NfSU5GT19UIHByQnNzSW5mbzsKCVVJTlRfMTYgdTJIdENhcEluZm9CaXRtYXNrID0gMDsKCglBU1NFUlQocHJBZGFwdGVyKTsKCUFTU0VSVChwclN3UmZiKTsKCglwclJ4RnJhbWUgPSAoUF9BQ1RJT05fTk9USUZZX0NITkxfV0lEVEhfRlJBTUUpIHByU3dSZmItPnB2SGVhZGVyOwoJcHJTdGFSZWMgPSBjbm1HZXRTdGFSZWNCeUluZGV4KHByQWRhcHRlciwgcHJTd1JmYi0+dWNTdGFSZWNJZHgpOwoKCWlmICghcHJTdGFSZWMpCgkJcmV0dXJuOwoKCXN3aXRjaCAocHJSeEZyYW1lLT51Y0FjdGlvbikgewoJY2FzZSBBQ1RJT05fSFRfTk9USUZZX0NIQU5ORUxfV0lEVEg6CgkJaWYgKHByU3RhUmVjLT51Y1N0YVN0YXRlICE9IFNUQV9TVEFURV8zIHx8CgkJICAgIHByU3dSZmItPnUyUGFja2V0TGVuIDwgc2l6ZW9mKEFDVElPTl9OT1RJRllfQ0hOTF9XSURUSF9GUkFNRSkpIHsKCQkJcmV0dXJuOwoJCX0KCgkJLyogVG8gZG86IGRlcGVuZGluZyByZWd1bGF0aW9uIGNsYXNzIDEzIGFuZCAxNCBiYXNlZCBvbiBzcGVjCgkJICogTm90ZTogKHVjQ2hhbm5lbFdpZHRoPT0xKSBzaGFsbCByZXN0b3JlZCBiYWNrIHRvIG9yaWdpbmFsIGNhcGFiaWxpdHksCgkJICogICAgICAgbm90IGN1cnJlbnQgc2V0dGluZyB0byA0ME1IeiBCVyBoZXJlCgkJICovCgkJIC8qIDEuIFVwZGF0ZSBTdGFSZWMgZm9yIEFQL1NUQSBtb2RlICovCgkJaWYgKHByUnhGcmFtZS0+dWNDaGFubmVsV2lkdGggPT0gMCkKCQkJcHJTdGFSZWMtPnUySHRDYXBJbmZvICY9IH5IVF9DQVBfSU5GT19TVVBfQ0hOTF9XSURUSDsKCQllbHNlIGlmIChwclJ4RnJhbWUtPnVjQ2hhbm5lbFdpZHRoID09IDEpCgkJCXByU3RhUmVjLT51Mkh0Q2FwSW5mbyB8PSBIVF9DQVBfSU5GT19TVVBfQ0hOTF9XSURUSDsKCgkJY25tU3RhU2VuZFVwZGF0ZUNtZChwckFkYXB0ZXIsIHByU3RhUmVjLCBOVUxMLCBGQUxTRSk7CgoJCS8qIDIuIFVwZGF0ZSBCc3NJbmZvIGZvciBTVEEgbW9kZSAqLwoJCXByQnNzSW5mbyA9IHByQWRhcHRlci0+YXByQnNzSW5mb1twclN0YVJlYy0+dWNCc3NJbmRleF07CgkJaWYgKHByQnNzSW5mby0+ZUN1cnJlbnRPUE1vZGUgPT0gT1BfTU9ERV9JTkZSQVNUUlVDVFVSRSkgewoJCQlpZiAocHJSeEZyYW1lLT51Y0NoYW5uZWxXaWR0aCA9PSAwKQoJCQkJcHJCc3NJbmZvLT51Y0h0T3BJbmZvMSAmPSB+SFRfT1BfSU5GTzFfU1RBX0NITkxfV0lEVEg7CgkJCWlmIChwclJ4RnJhbWUtPnVjQ2hhbm5lbFdpZHRoID09IDEpCgkJCQlwckJzc0luZm8tPnVjSHRPcEluZm8xIHw9IEhUX09QX0lORk8xX1NUQV9DSE5MX1dJRFRIOwoKCQkJbmljVXBkYXRlQnNzKHByQWRhcHRlciwgcHJCc3NJbmZvLT51Y0Jzc0luZGV4KTsKCQl9CglicmVhazsKCS8qIFN1cHBvcnQgU00gcG93ZXIgc2F2ZSAqLyAvKiBUSDNfSHVhbmcgKi8KCWNhc2UgQUNUSU9OX0hUX1NNX1BPV0VSX1NBVkU6CgkJcHJSeFNtcHNGcmFtZSA9IChQX0FDVElPTl9TTV9QT1dFUl9TQVZFX0ZSQU1FKSBwclN3UmZiLT5wdkhlYWRlcjsKCQlpZiAocHJTdGFSZWMtPnVjU3RhU3RhdGUgIT0gU1RBX1NUQVRFXzMgfHwKCQkJcHJTd1JmYi0+dTJQYWNrZXRMZW4gPCBzaXplb2YoQUNUSU9OX1NNX1BPV0VSX1NBVkVfRlJBTUUpKSB7CgkJCXJldHVybjsKCQl9CgoJCS8qIFRoZSBTTSBwb3dlciBlbmFibGUgYml0IGlzIGRpZmZlcmVudCBkZWZpbml0aW9uIGluIEh0Q2FwIGFuZCBTTXBvd2VyIElFIGZpZWxkICovCgkJaWYgKCEocHJSeFNtcHNGcmFtZS0+dWNTbVBvd2VyQ3RybCAmCgkJCSAoSFRfU01fUE9XRVJfU0FWRV9DT05UUk9MX0VOQUJMRUR8SFRfU01fUE9XRVJfU0FWRV9DT05UUk9MX1NNX01PREUpKSkKCQkJdTJIdENhcEluZm9CaXRtYXNrIHw9IEhUX0NBUF9JTkZPX1NNX1BPV0VSX1NBVkU7CgoJCS8qIFN1cHBvcnQgU01QUyBhY3Rpb24gZnJhbWUsIFRIM19IdWFuZyAqLwoJCS8qIFVwZGF0ZSBTdGFSZWMgaWYgU00gcG93ZXIgc3RhdGUgY2hhbmdlZCAqLwoJCWlmICgocHJTdGFSZWMtPnUySHRDYXBJbmZvICYgSFRfQ0FQX0lORk9fU01fUE9XRVJfU0FWRSkgIT0gdTJIdENhcEluZm9CaXRtYXNrKSB7CgkJCXByU3RhUmVjLT51Mkh0Q2FwSW5mbyAmPSB+SFRfQ0FQX0lORk9fU01fUE9XRVJfU0FWRTsKCQkJcHJTdGFSZWMtPnUySHRDYXBJbmZvIHw9IHUySHRDYXBJbmZvQml0bWFzazsKCQkJREJHTE9HKFJMTSwgSU5GTywKCQkJCSJybG1Qcm9jZXNzSHRBY3Rpb24gLS0gU01QUyBjaGFuZ2UgdTJIdENhcEluZm8gdG8gKCV4KVxuIiwKCQkJCSBwclN0YVJlYy0+dTJIdENhcEluZm8pOwoJCQljbm1TdGFTZW5kVXBkYXRlQ21kKHByQWRhcHRlciwgcHJTdGFSZWMsIE5VTEwsIEZBTFNFKTsKCQl9CglicmVhazsKCWRlZmF1bHQ6CglicmVhazsKCX0KfQoKI2lmIENGR19TVVBQT1JUXzgwMl8xMUFDCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIFxicmllZgoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovClZPSUQgcmxtUHJvY2Vzc1ZodEFjdGlvbihQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfU1dfUkZCX1QgcHJTd1JmYikKewoJUF9BQ1RJT05fT1BfTU9ERV9OT1RJRklDQVRJT05fRlJBTUUgcHJSeEZyYW1lOwoJUF9TVEFfUkVDT1JEX1QgcHJTdGFSZWM7CglQX0JTU19JTkZPX1QgcHJCc3NJbmZvOwoKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByU3dSZmIpOwoKCXByUnhGcmFtZSA9IChQX0FDVElPTl9PUF9NT0RFX05PVElGSUNBVElPTl9GUkFNRSkgcHJTd1JmYi0+cHZIZWFkZXI7CglwclN0YVJlYyA9IGNubUdldFN0YVJlY0J5SW5kZXgocHJBZGFwdGVyLCBwclN3UmZiLT51Y1N0YVJlY0lkeCk7CgoJaWYgKCFwclN0YVJlYykKCQlyZXR1cm47CgoJcHJCc3NJbmZvID0gR0VUX0JTU19JTkZPX0JZX0lOREVYKHByQWRhcHRlciwgcHJTdGFSZWMtPnVjQnNzSW5kZXgpOwoKCWlmICghcHJCc3NJbmZvKQoJCXJldHVybjsKCglzd2l0Y2ggKHByUnhGcmFtZS0+dWNBY3Rpb24pIHsKCS8qIFN1cHBvcnQgT3BlcmF0aW5nIG1vZGUgbm90aWZpY2F0aW9uIGFjdGlvbiBmcmFtZSwgVEgzX0h1YW5nICovCgljYXNlIEFDVElPTl9PUEVSQVRJTkdfTU9ERV9OT1RJRklDQVRJT046CgkJaWYgKHByU3RhUmVjLT51Y1N0YVN0YXRlICE9IFNUQV9TVEFURV8zIHx8CgkJICAgIHByU3dSZmItPnUyUGFja2V0TGVuIDwgc2l6ZW9mKEFDVElPTl9PUF9NT0RFX05PVElGSUNBVElPTl9GUkFNRSkpIHsKCQkJcmV0dXJuOwoJCX0KCgkJaWYgKCgocHJSeEZyYW1lLT51Y09wZXJhdGluZ01vZGUgJiBWSFRfT1BfTU9ERV9SWF9OU1NfVFlQRSkKCQkJIT0gVkhUX09QX01PREVfUlhfTlNTX1RZUEUpICYmCgkJCShwclN0YVJlYy0+dWNWaHRPcE1vZGUgIT0gcHJSeEZyYW1lLT51Y09wZXJhdGluZ01vZGUpKSB7CgkJCXByU3RhUmVjLT51Y1ZodE9wTW9kZSA9IHByUnhGcmFtZS0+dWNPcGVyYXRpbmdNb2RlOwoJCQlEQkdMT0coUkxNLCBJTkZPLAoJCQkJInJsbVByb2Nlc3NWaHRBY3Rpb24gLS0gVXBkYXRlIHVjVmh0T3BNb2RlIHRvIDB4JXhcbiIsIHByU3RhUmVjLT51Y1ZodE9wTW9kZSk7CgkJCWNubVN0YVNlbmRVcGRhdGVDbWQocHJBZGFwdGVyLCBwclN0YVJlYywgTlVMTCwgRkFMU0UpOwoJCX0KCWJyZWFrOwoJZGVmYXVsdDoKCWJyZWFrOwoJfQp9CiNlbmRpZgoKLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLyohCiogXGJyaWVmIFRoaXMgZnVuY3Rpb24gc2hvdWxkIGJlIGludm9rZWQgYWZ0ZXIganVkZ2luZyBzdWNjZXNzZnVsIGFzc29jaWF0aW9uLgoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovClZPSUQgcmxtRmlsbFN5bmNDbWRQYXJhbShQX0NNRF9TRVRfQlNTX1JMTV9QQVJBTV9UIHByQ21kQm9keSwgUF9CU1NfSU5GT19UIHByQnNzSW5mbykKewoJQVNTRVJUKHByQ21kQm9keSAmJiBwckJzc0luZm8pOwoJaWYgKCFwckNtZEJvZHkgfHwgIXByQnNzSW5mbykKCQlyZXR1cm47CgoJcHJDbWRCb2R5LT51Y0Jzc0luZGV4ID0gcHJCc3NJbmZvLT51Y0Jzc0luZGV4OwoJcHJDbWRCb2R5LT51Y1JmQmFuZCA9IChVSU5UXzgpIHByQnNzSW5mby0+ZUJhbmQ7CglwckNtZEJvZHktPnVjUHJpbWFyeUNoYW5uZWwgPSBwckJzc0luZm8tPnVjUHJpbWFyeUNoYW5uZWw7CglwckNtZEJvZHktPnVjUmZTY28gPSAoVUlOVF84KSBwckJzc0luZm8tPmVCc3NTQ087CglwckNtZEJvZHktPnVjRXJwUHJvdGVjdE1vZGUgPSAoVUlOVF84KSBwckJzc0luZm8tPmZnRXJwUHJvdGVjdE1vZGU7CglwckNtZEJvZHktPnVjSHRQcm90ZWN0TW9kZSA9IChVSU5UXzgpIHByQnNzSW5mby0+ZUh0UHJvdGVjdE1vZGU7CglwckNtZEJvZHktPnVjR2ZPcGVyYXRpb25Nb2RlID0gKFVJTlRfOCkgcHJCc3NJbmZvLT5lR2ZPcGVyYXRpb25Nb2RlOwoJcHJDbWRCb2R5LT51Y1R4Umlmc01vZGUgPSAoVUlOVF84KSBwckJzc0luZm8tPmVSaWZzT3BlcmF0aW9uTW9kZTsKCXByQ21kQm9keS0+dTJIdE9wSW5mbzMgPSBwckJzc0luZm8tPnUySHRPcEluZm8zOwoJcHJDbWRCb2R5LT51Mkh0T3BJbmZvMiA9IHByQnNzSW5mby0+dTJIdE9wSW5mbzI7CglwckNtZEJvZHktPnVjSHRPcEluZm8xID0gcHJCc3NJbmZvLT51Y0h0T3BJbmZvMTsKCXByQ21kQm9keS0+dWNVc2VTaG9ydFByZWFtYmxlID0gcHJCc3NJbmZvLT5mZ1VzZVNob3J0UHJlYW1ibGU7CglwckNtZEJvZHktPnVjVXNlU2hvcnRTbG90VGltZSA9IHByQnNzSW5mby0+ZmdVc2VTaG9ydFNsb3RUaW1lOwoJcHJDbWRCb2R5LT51Y1ZodENoYW5uZWxXaWR0aCA9IHByQnNzSW5mby0+dWNWaHRDaGFubmVsV2lkdGg7CglwckNtZEJvZHktPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMxID0gcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxGcmVxdWVuY3lTMTsKCXByQ21kQm9keS0+dWNWaHRDaGFubmVsRnJlcXVlbmN5UzIgPSBwckJzc0luZm8tPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMyOwoJcHJDbWRCb2R5LT51MlZodEJhc2ljTWNzU2V0ID0gcHJCc3NJbmZvLT51MkJTU0Jhc2ljUmF0ZVNldDsKCXByQ21kQm9keS0+dWNOc3MgPSBwckJzc0luZm8tPnVjTnNzOwoKCWlmIChSTE1fTkVUX1BBUkFNX1ZBTElEKHByQnNzSW5mbykpIHsKCQlEQkdMT0coUkxNLCBJTkZPLCAiTj0lZCBiPSVkIGM9JWQgcz0lZCBlPSVkIGg9JWQgST0weCUwMnggbD0lZCBwPSVkIHc9JWQgczE9JWQgczI9JWQgbj0lZFxuIiwKCQkgICAgICAgcHJDbWRCb2R5LT51Y0Jzc0luZGV4LCBwckNtZEJvZHktPnVjUmZCYW5kLAoJCSAgICAgICBwckNtZEJvZHktPnVjUHJpbWFyeUNoYW5uZWwsIHByQ21kQm9keS0+dWNSZlNjbywKCQkgICAgICAgcHJDbWRCb2R5LT51Y0VycFByb3RlY3RNb2RlLCBwckNtZEJvZHktPnVjSHRQcm90ZWN0TW9kZSwKCQkgICAgICAgcHJDbWRCb2R5LT51Y0h0T3BJbmZvMSwgcHJDbWRCb2R5LT51Y1VzZVNob3J0U2xvdFRpbWUsCgkJICAgICAgIHByQ21kQm9keS0+dWNVc2VTaG9ydFByZWFtYmxlLAoJCSAgICAgICBwckNtZEJvZHktPnVjVmh0Q2hhbm5lbFdpZHRoLAoJCSAgICAgICBwckNtZEJvZHktPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMxLCBwckNtZEJvZHktPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMyLAoJCSAgICAgICBwckNtZEJvZHktPnVjTnNzKTsKCX0gZWxzZSB7CgkJREJHTE9HKFJMTSwgSU5GTywgIk49JWQgY2xvc2VkXG4iLCBwckNtZEJvZHktPnVjQnNzSW5kZXgpOwoJfQp9CgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYgVGhpcyBmdW5jdGlvbiB3aWxsIG9wZXJhdGlvbiBwYXJhbWV0ZXJzIGJhc2VkIG9uIHNpdHVhdGlvbnMgb2YKKiAgICAgICAgY29uY3VycmVudCBuZXR3b3Jrcy4gQ2hhbm5lbCwgYmFuZHdpZHRoLCBwcm90ZWN0aW9uIG1vZGUsIHN1cHBvcnRlZAoqICAgICAgICByYXRlIHdpbGwgYmUgbW9kaWZpZWQuCioKKiBccGFyYW1baW5dCioKKiBccmV0dXJuIG5vbmUKKi8KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KVk9JRCBybG1TeW5jT3BlcmF0aW9uUGFyYW1zKFBfQURBUFRFUl9UIHByQWRhcHRlciwgUF9CU1NfSU5GT19UIHByQnNzSW5mbykKewoJUF9DTURfU0VUX0JTU19STE1fUEFSQU1fVCBwckNtZEJvZHk7CglXTEFOX1NUQVRVUyByU3RhdHVzOwoKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByQnNzSW5mbyk7CgoJcHJDbWRCb2R5ID0gKFBfQ01EX1NFVF9CU1NfUkxNX1BBUkFNX1QpCgkgICAgY25tTWVtQWxsb2MocHJBZGFwdGVyLCBSQU1fVFlQRV9CVUYsIHNpemVvZihDTURfU0VUX0JTU19STE1fUEFSQU1fVCkpOwoKCS8qIEFTU0VSVChwckNtZEJvZHkpOyAqLwoJLyogVG8gZG86IGV4Y2VwdGlvbiBoYW5kbGUgKi8KCWlmICghcHJDbWRCb2R5KSB7CgkJREJHTE9HKFJMTSwgV0FSTiwgIk5vIGJ1ZiBmb3Igc3luYyBSTE0gcGFyYW1zIChOZXQ9JWQpXG4iLCBwckJzc0luZm8tPnVjQnNzSW5kZXgpOwoJCXJldHVybjsKCX0KCglybG1GaWxsU3luY0NtZFBhcmFtKHByQ21kQm9keSwgcHJCc3NJbmZvKTsKCglyU3RhdHVzID0gd2xhblNlbmRTZXRRdWVyeUNtZChwckFkYXB0ZXIsCS8qIHByQWRhcHRlciAqLwoJCQkJICAgICAgQ01EX0lEX1NFVF9CU1NfUkxNX1BBUkFNLAkvKiB1Y0NJRCAqLwoJCQkJICAgICAgVFJVRSwJLyogZmdTZXRRdWVyeSAqLwoJCQkJICAgICAgRkFMU0UsCS8qIGZnTmVlZFJlc3AgKi8KCQkJCSAgICAgIEZBTFNFLAkvKiBmZ0lzT2lkICovCgkJCQkgICAgICBOVUxMLAkvKiBwZkNtZERvbmVIYW5kbGVyICovCgkJCQkgICAgICBOVUxMLAkvKiBwZkNtZFRpbWVvdXRIYW5kbGVyICovCgkJCQkgICAgICBzaXplb2YoQ01EX1NFVF9CU1NfUkxNX1BBUkFNX1QpLAkvKiB1NFNldFF1ZXJ5SW5mb0xlbiAqLwoJCQkJICAgICAgKFBVSU5UXzgpIHByQ21kQm9keSwJLyogcHVjSW5mb0J1ZmZlciAqLwoJCQkJICAgICAgTlVMTCwJLyogcHZTZXRRdWVyeUJ1ZmZlciAqLwoJCQkJICAgICAgMAkvKiB1NFNldFF1ZXJ5QnVmZmVyTGVuICovCgkgICAgKTsKCgkvKiBBU1NFUlQoclN0YXR1cyA9PSBXTEFOX1NUQVRVU19QRU5ESU5HKTsgKi8KCWlmIChyU3RhdHVzICE9IFdMQU5fU1RBVFVTX1BFTkRJTkcpCgkJREJHTE9HKFJMTSwgV0FSTiwgInJsbVN5bmNPcGVyYXRpb25QYXJhbXMgc2V0IGNtZCBmYWlsXG4iKTsKCgljbm1NZW1GcmVlKHByQWRhcHRlciwgcHJDbWRCb2R5KTsKfQoKI2lmIENGR19TVVBQT1JUX0FBQQovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYgVGhpcyBmdW5jdGlvbiBzaG91bGQgYmUgaW52b2tlZCBhZnRlciBqdWRnaW5nIHN1Y2Nlc3NmdWwgYXNzb2NpYXRpb24uCioKKiBccGFyYW1baW5dCioKKiBccmV0dXJuIG5vbmUKKi8KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KVk9JRCBybG1Qcm9jZXNzQXNzb2NSZXEoUF9BREFQVEVSX1QgcHJBZGFwdGVyLCBQX1NXX1JGQl9UIHByU3dSZmIsIFBVSU5UXzggcHVjSUUsIFVJTlRfMTYgdTJJRUxlbmd0aCkKewoJUF9CU1NfSU5GT19UIHByQnNzSW5mbzsKCVBfU1RBX1JFQ09SRF9UIHByU3RhUmVjOwoJVUlOVF8xNiB1Mk9mZnNldDsKCVBfSUVfSFRfQ0FQX1QgcHJIdENhcDsKI2lmIENGR19TVVBQT1JUXzgwMl8xMUFDCglQX0lFX1ZIVF9DQVBfVCBwclZodENhcDsKCVVJTlRfOCB1Y1ZodENhcE1jc093bk5vdFN1cHBvcnRPZmZzZXQ7CgkvKiBVSU5UXzggdWNWaHRDYXBNY3NQZWVyTm90U3VwcG9ydE9mZnNldDsgKi8KCVBfSUVfT1BfTU9ERV9OT1RJRklDQVRJT05fVCBwck9QTW9kZU5vdGlmaWNhdGlvbjsJLyogT3BlcmF0aW9uIE1vZGUgTm90aWZpY2F0aW9uICovCiNlbmRpZgoKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByU3dSZmIpOwoJQVNTRVJUKHB1Y0lFKTsKCglwclN0YVJlYyA9IGNubUdldFN0YVJlY0J5SW5kZXgocHJBZGFwdGVyLCBwclN3UmZiLT51Y1N0YVJlY0lkeCk7CglpZiAoIXByU3RhUmVjKQoJCXJldHVybjsKCUFTU0VSVChwclN0YVJlYy0+dWNCc3NJbmRleCA8PSBNQVhfQlNTX0lOREVYKTsKCglwckJzc0luZm8gPSBwckFkYXB0ZXItPmFwckJzc0luZm9bcHJTdGFSZWMtPnVjQnNzSW5kZXhdOwoKCUlFX0ZPUl9FQUNIKHB1Y0lFLCB1MklFTGVuZ3RoLCB1Mk9mZnNldCkgewoJCXN3aXRjaCAoSUVfSUQocHVjSUUpKSB7CgkJY2FzZSBFTEVNX0lEX0hUX0NBUDoKCQkJaWYgKCFSTE1fTkVUX0lTXzExTihwckJzc0luZm8pIHx8IElFX0xFTihwdWNJRSkgIT0gKHNpemVvZihJRV9IVF9DQVBfVCkgLSAyKSkKCQkJCWJyZWFrOwoJCQlwckh0Q2FwID0gKFBfSUVfSFRfQ0FQX1QpIHB1Y0lFOwoJCQlwclN0YVJlYy0+dWNNY3NTZXQgPSBwckh0Q2FwLT5yU3VwTWNzU2V0LmF1Y1J4TWNzQml0bWFza1swXTsKCQkJcHJTdGFSZWMtPmZnU3VwTWNzMzIgPSAocHJIdENhcC0+clN1cE1jc1NldC5hdWNSeE1jc0JpdG1hc2tbMzIgLyA4XSAmIEJJVCgwKSkgPyBUUlVFIDogRkFMU0U7CgoJCQlrYWxNZW1Db3B5KHByU3RhUmVjLT5hdWNSeE1jc0JpdG1hc2ssIHBySHRDYXAtPnJTdXBNY3NTZXQuYXVjUnhNY3NCaXRtYXNrLAoJCQkJICAgc2l6ZW9mKHByU3RhUmVjLT5hdWNSeE1jc0JpdG1hc2spIC8qU1VQX01DU19SWF9CSVRNQVNLX09DVEVUX05VTSAqLyk7CgoJCQlwclN0YVJlYy0+dTJIdENhcEluZm8gPSBwckh0Q2FwLT51Mkh0Q2FwSW5mbzsKCgkJCS8qIFNldCBTaG9ydCBMRFBDIFR4IGNhcGFiaWxpdHkgKi8KCQkJaWYgKElTX0ZFQVRVUkVfRk9SQ0VfRU5BQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjVHhMZHBjKSkKCQkJCXByU3RhUmVjLT51Mkh0Q2FwSW5mbyB8PSBIVF9DQVBfSU5GT19MRFBDX0NBUDsKCQkJZWxzZSBpZiAoSVNfRkVBVFVSRV9ESVNBQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjVHhMZHBjKSkKCQkJCXByU3RhUmVjLT51Mkh0Q2FwSW5mbyAmPSB+SFRfQ0FQX0lORk9fTERQQ19DQVA7CgoJCQkvKiBTZXQgU1RCQyBUeCBjYXBhYmlsaXR5ICovCgkJCWlmIChJU19GRUFUVVJFX0ZPUkNFX0VOQUJMRUQocHJBZGFwdGVyLT5yV2lmaVZhci51Y1R4U3RiYykpCgkJCQlwclN0YVJlYy0+dTJIdENhcEluZm8gfD0gSFRfQ0FQX0lORk9fVFhfU1RCQzsKCQkJZWxzZSBpZiAoSVNfRkVBVFVSRV9ESVNBQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjVHhTdGJjKSkKCQkJCXByU3RhUmVjLT51Mkh0Q2FwSW5mbyAmPSB+SFRfQ0FQX0lORk9fVFhfU1RCQzsKCQkJLyogU2V0IFNob3J0IEdJIFR4IGNhcGFiaWxpdHkgKi8KCQkJaWYgKElTX0ZFQVRVUkVfRk9SQ0VfRU5BQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjVHhTaG9ydEdJKSkgewoJCQkJcHJTdGFSZWMtPnUySHRDYXBJbmZvIHw9IEhUX0NBUF9JTkZPX1NIT1JUX0dJXzIwTTsKCQkJCXByU3RhUmVjLT51Mkh0Q2FwSW5mbyB8PSBIVF9DQVBfSU5GT19TSE9SVF9HSV80ME07CgkJCX0gZWxzZSBpZiAoSVNfRkVBVFVSRV9ESVNBQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjVHhTaG9ydEdJKSkgewoJCQkJcHJTdGFSZWMtPnUySHRDYXBJbmZvICY9IH5IVF9DQVBfSU5GT19TSE9SVF9HSV8yME07CgkJCQlwclN0YVJlYy0+dTJIdENhcEluZm8gJj0gfkhUX0NBUF9JTkZPX1NIT1JUX0dJXzQwTTsKCQkJfQoKCQkJLyogU2V0IEhUIEdyZWVuZmllbGQgVHggY2FwYWJpbGl0eSAqLwoJCQlpZiAoSVNfRkVBVFVSRV9GT1JDRV9FTkFCTEVEKHByQWRhcHRlci0+cldpZmlWYXIudWNUeEdmKSkKCQkJCXByU3RhUmVjLT51Mkh0Q2FwSW5mbyB8PSBIVF9DQVBfSU5GT19IVF9HRjsKCQkJZWxzZSBpZiAoSVNfRkVBVFVSRV9ESVNBQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjVHhHZikpCgkJCQlwclN0YVJlYy0+dTJIdENhcEluZm8gJj0gfkhUX0NBUF9JTkZPX0hUX0dGOwoKCQkJcHJTdGFSZWMtPnVjQW1wZHVQYXJhbSA9IHBySHRDYXAtPnVjQW1wZHVQYXJhbTsKCQkJcHJTdGFSZWMtPnUySHRFeHRlbmRlZENhcCA9IHBySHRDYXAtPnUySHRFeHRlbmRlZENhcDsKCQkJcHJTdGFSZWMtPnU0VHhCZWFtZm9ybWluZ0NhcCA9IHBySHRDYXAtPnU0VHhCZWFtZm9ybWluZ0NhcDsKCQkJcHJTdGFSZWMtPnVjQXNlbENhcCA9IHBySHRDYXAtPnVjQXNlbENhcDsKCQkJYnJlYWs7CgojaWYgQ0ZHX1NVUFBPUlRfODAyXzExQUMKCQljYXNlIEVMRU1fSURfVkhUX0NBUDoKCQkJaWYgKCFSTE1fTkVUX0lTXzExQUMocHJCc3NJbmZvKSB8fCBJRV9MRU4ocHVjSUUpICE9IChzaXplb2YoSUVfVkhUX0NBUF9UKSAtIDIpKQoJCQkJYnJlYWs7CgoJCQlwclZodENhcCA9IChQX0lFX1ZIVF9DQVBfVCkgcHVjSUU7CgoJCQlwclN0YVJlYy0+dTRWaHRDYXBJbmZvID0gcHJWaHRDYXAtPnU0Vmh0Q2FwSW5mbzsKCgkJCS8qIFNldCBUeCBMRFBDIGNhcGFiaWxpdHkgKi8KCQkJaWYgKElTX0ZFQVRVUkVfRk9SQ0VfRU5BQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjVHhMZHBjKSkKCQkJCXByU3RhUmVjLT51NFZodENhcEluZm8gfD0gVkhUX0NBUF9JTkZPX1JYX0xEUEM7CgkJCWVsc2UgaWYgKElTX0ZFQVRVUkVfRElTQUJMRUQocHJBZGFwdGVyLT5yV2lmaVZhci51Y1R4TGRwYykpCgkJCQlwclN0YVJlYy0+dTRWaHRDYXBJbmZvICY9IH5WSFRfQ0FQX0lORk9fUlhfTERQQzsKCgkJCS8qIFNldCBUeCBTVEJDIGNhcGFiaWxpdHkgKi8KCQkJaWYgKElTX0ZFQVRVUkVfRk9SQ0VfRU5BQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjVHhTdGJjKSkKCQkJCXByU3RhUmVjLT51NFZodENhcEluZm8gfD0gVkhUX0NBUF9JTkZPX1RYX1NUQkM7CgkJCWVsc2UgaWYgKElTX0ZFQVRVUkVfRElTQUJMRUQocHJBZGFwdGVyLT5yV2lmaVZhci51Y1R4U3RiYykpCgkJCQlwclN0YVJlYy0+dTRWaHRDYXBJbmZvICY9IH5WSFRfQ0FQX0lORk9fVFhfU1RCQzsKCgkJCS8qIFNldCBUeCBUWE9QIFBTIGNhcGFiaWxpdHkgKi8KCQkJaWYgKElTX0ZFQVRVUkVfRk9SQ0VfRU5BQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjVHhvcFBzVHgpKQoJCQkJcHJTdGFSZWMtPnU0Vmh0Q2FwSW5mbyB8PSBWSFRfQ0FQX0lORk9fVkhUX1RYT1BfUFM7CgkJCWVsc2UgaWYgKElTX0ZFQVRVUkVfRElTQUJMRUQocHJBZGFwdGVyLT5yV2lmaVZhci51Y1R4b3BQc1R4KSkKCQkJCXByU3RhUmVjLT51NFZodENhcEluZm8gJj0gflZIVF9DQVBfSU5GT19WSFRfVFhPUF9QUzsKCgkJCS8qIFNldCBUeCBTaG9ydCBHSSBjYXBhYmlsaXR5ICovCgkJCWlmIChJU19GRUFUVVJFX0ZPUkNFX0VOQUJMRUQocHJBZGFwdGVyLT5yV2lmaVZhci51Y1R4U2hvcnRHSSkpIHsKCQkJCXByU3RhUmVjLT51NFZodENhcEluZm8gfD0gVkhUX0NBUF9JTkZPX1NIT1JUX0dJXzgwOwoJCQkJcHJTdGFSZWMtPnU0Vmh0Q2FwSW5mbyB8PSBWSFRfQ0FQX0lORk9fU0hPUlRfR0lfMTYwXzgwUDgwOwoJCQl9IGVsc2UgaWYgKElTX0ZFQVRVUkVfRElTQUJMRUQocHJBZGFwdGVyLT5yV2lmaVZhci51Y1R4U2hvcnRHSSkpIHsKCQkJCXByU3RhUmVjLT51NFZodENhcEluZm8gJj0gflZIVF9DQVBfSU5GT19TSE9SVF9HSV84MDsKCQkJCXByU3RhUmVjLT51NFZodENhcEluZm8gJj0gflZIVF9DQVBfSU5GT19TSE9SVF9HSV8xNjBfODBQODA7CgkJCX0KCgkJCS8qU2V0IFZodCBSeCBNY3MgTWFwIHVwb24gcGVlcidzIGNhcGFiaWxpdHkgYW5kIG91ciBjYXBhYmlsaXR5ICovCgkJCXByU3RhUmVjLT51MlZodFJ4TWNzTWFwID0gcHJWaHRDYXAtPnJWaHRTdXBwb3J0ZWRNY3NTZXQudTJSeE1jc01hcDsKCQkJaWYgKHdsYW5HZXRTdXBwb3J0TnNzKHByQWRhcHRlciwgcHJTdGFSZWMtPnVjQnNzSW5kZXgpIDwgOCkgewoJCQkJdWNWaHRDYXBNY3NPd25Ob3RTdXBwb3J0T2Zmc2V0ID0KCQkJCQl3bGFuR2V0U3VwcG9ydE5zcyhwckFkYXB0ZXIsIHByU3RhUmVjLT51Y0Jzc0luZGV4KSAqIDI7CgkJCQlwclN0YVJlYy0+dTJWaHRSeE1jc01hcCB8PSBCSVRTKHVjVmh0Q2FwTWNzT3duTm90U3VwcG9ydE9mZnNldCwgMTUpOwoJCQkJLypNYXJrIFJ4IE1jcyBNYXAgd2hpY2ggd2UgZG9uJ3Qgc3VwcG9ydCovCgkJCX0KCQkJaWYgKHByU3RhUmVjLT51MlZodFJ4TWNzTWFwICE9IHByVmh0Q2FwLT5yVmh0U3VwcG9ydGVkTWNzU2V0LnUyUnhNY3NNYXApCgkJCQlEQkdMT0coUkxNLCBJTkZPLCAiQ2hhbmdlIFZodFJ4TWNzTWFwIGZyb20gMHgleCB0byAweCV4IGR1ZSB0byBvdXIgTnNzIHNldHRpbmdcbiIsCgkJCQkJCQkJcHJWaHRDYXAtPnJWaHRTdXBwb3J0ZWRNY3NTZXQudTJSeE1jc01hcCwKCQkJCQkJCQlwclN0YVJlYy0+dTJWaHRSeE1jc01hcCk7CgoJCQlwclN0YVJlYy0+dTJWaHRSeEhpZ2hlc3RTdXBwb3J0ZWREYXRhUmF0ZSA9CgkJCSAgICBwclZodENhcC0+clZodFN1cHBvcnRlZE1jc1NldC51MlJ4SGlnaGVzdFN1cHBvcnRlZERhdGFSYXRlOwoJCQlwclN0YVJlYy0+dTJWaHRUeE1jc01hcCA9IHByVmh0Q2FwLT5yVmh0U3VwcG9ydGVkTWNzU2V0LnUyVHhNY3NNYXA7CgkJCXByU3RhUmVjLT51MlZodFR4SGlnaGVzdFN1cHBvcnRlZERhdGFSYXRlID0KCQkJCXByVmh0Q2FwLT5yVmh0U3VwcG9ydGVkTWNzU2V0LnUyVHhIaWdoZXN0U3VwcG9ydGVkRGF0YVJhdGU7CgoJCQkvKiBTZXQgaW5pdGlhbCB2YWx1ZSBvZiBWSFQgT1AgbW9kZSAqLwoJCQlwclN0YVJlYy0+dWNWaHRPcE1vZGUgPSAwOwoJCQlzd2l0Y2ggKHByQnNzSW5mby0+dWNWaHRDaGFubmVsV2lkdGgpIHsKCQkJY2FzZSBWSFRfT1BfQ0hBTk5FTF9XSURUSF8yMF80MDoKCQkJCXByU3RhUmVjLT51Y1ZodE9wTW9kZSB8PSBWSFRfT1BfTU9ERV9DSEFOTkVMX1dJRFRIXzQwOwoJCQkJYnJlYWs7CgkJCWNhc2UgVkhUX09QX0NIQU5ORUxfV0lEVEhfODA6CgkJCQlwclN0YVJlYy0+dWNWaHRPcE1vZGUgfD0gVkhUX09QX01PREVfQ0hBTk5FTF9XSURUSF84MDsKCQkJCWJyZWFrOwoJCQljYXNlIFZIVF9PUF9DSEFOTkVMX1dJRFRIXzE2MDoKCQkJY2FzZSBWSFRfT1BfQ0hBTk5FTF9XSURUSF84MFA4MDoKCQkJCXByU3RhUmVjLT51Y1ZodE9wTW9kZSB8PSBWSFRfT1BfTU9ERV9DSEFOTkVMX1dJRFRIXzE2MF84MFA4MDsKCQkJCWJyZWFrOwoJCQlkZWZhdWx0OgoJCQkJcHJTdGFSZWMtPnVjVmh0T3BNb2RlIHw9IFZIVF9PUF9NT0RFX0NIQU5ORUxfV0lEVEhfODA7CgkJCQlicmVhazsKCQkJfQoJCQlwclN0YVJlYy0+dWNWaHRPcE1vZGUgfD0gKChwckJzc0luZm8tPnVjTnNzLTEpIDw8CgkJCQlWSFRfT1BfTU9ERV9SWF9OU1NfT0ZGU0VUKSAmIFZIVF9PUF9NT0RFX1JYX05TUzsKCgkJCWJyZWFrOwoJCWNhc2UgRUxFTV9JRF9PUF9NT0RFOgoJCQlpZiAoIVJMTV9ORVRfSVNfMTFBQyhwckJzc0luZm8pIHx8IElFX0xFTihwdWNJRSkgIT0gKHNpemVvZihJRV9PUF9NT0RFX05PVElGSUNBVElPTl9UKSAtIDIpKQoJCQkJYnJlYWs7CgkJCXByT1BNb2RlTm90aWZpY2F0aW9uID0gKFBfSUVfT1BfTU9ERV9OT1RJRklDQVRJT05fVCkgcHVjSUU7CgoJCQlpZiAoKHByT1BNb2RlTm90aWZpY2F0aW9uLT51Y09wTW9kZSAmIFZIVF9PUF9NT0RFX1JYX05TU19UWVBFKQoJCQkgICAgIT0gVkhUX09QX01PREVfUlhfTlNTX1RZUEUpIHsKCQkJCXByU3RhUmVjLT51Y1ZodE9wTW9kZSA9IHByT1BNb2RlTm90aWZpY2F0aW9uLT51Y09wTW9kZTsKCQkJfQoKCQkJYnJlYWs7CgojZW5kaWYKCgkJZGVmYXVsdDoKCQkJYnJlYWs7CgkJfQkJLyogZW5kIG9mIHN3aXRjaCAqLwoJfQkJCS8qIGVuZCBvZiBJRV9GT1JfRUFDSCAqLwp9CiNlbmRpZiAvKiBDRkdfU1VQUE9SVF9BQUEgKi8KCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIFxicmllZiBJdCBpcyBmb3IgYm90aCBTVEEgYW5kIEFQIG1vZGVzCioKKiBccGFyYW1baW5dCioKKiBccmV0dXJuIG5vbmUKKi8KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KVk9JRCBybG1Cc3NJbml0Rm9yQVBhbmRJYnNzKFBfQURBUFRFUl9UIHByQWRhcHRlciwgUF9CU1NfSU5GT19UIHByQnNzSW5mbykKewoJQVNTRVJUKHByQWRhcHRlcik7CglBU1NFUlQocHJCc3NJbmZvKTsKCiNpZiBDRkdfRU5BQkxFX1dJRklfRElSRUNUCglpZiAocHJBZGFwdGVyLT5mZ0lzUDJQUmVnaXN0ZXJlZCAmJiBwckJzc0luZm8tPmVDdXJyZW50T1BNb2RlID09IE9QX01PREVfQUNDRVNTX1BPSU5UKQoJCXJsbUJzc0luaXRGb3JBUChwckFkYXB0ZXIsIHByQnNzSW5mbyk7CiNlbmRpZgp9CgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYgSXQgaXMgZm9yIGJvdGggU1RBIGFuZCBBUCBtb2RlcwoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovClZPSUQgcmxtQnNzQWJvcnRlZChQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfQlNTX0lORk9fVCBwckJzc0luZm8pCnsKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByQnNzSW5mbyk7CgoJcmxtQnNzUmVzZXQocHJBZGFwdGVyLCBwckJzc0luZm8pOwoKCXByQnNzSW5mby0+Zmc0MG1Cd0FsbG93ZWQgPSBGQUxTRTsKCXByQnNzSW5mby0+ZmdBc3NvYzQwbUJ3QWxsb3dlZCA9IEZBTFNFOwoKCS8qIEFzc3VtZSBGVyBzdGF0ZSBpcyB1cGRhdGVkIGJ5IENNRF9JRF9TRVRfQlNTX0lORk8sIHNvCgkgKiB0aGUgc3luYyBDTUQgaXMgbm90IG5lZWRlZCBoZXJlLgoJICovCn0KCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIFxicmllZiBBbGwgUkxNIHRpbWVycyB3aWxsIGFsc28gYmUgc3RvcHBlZC4KKgoqIFxwYXJhbVtpbl0KKgoqIFxyZXR1cm4gbm9uZQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpzdGF0aWMgVk9JRCBybG1Cc3NSZXNldChQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfQlNTX0lORk9fVCBwckJzc0luZm8pCnsKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByQnNzSW5mbyk7CgoJLyogSFQgcmVsYXRlZCBwYXJhbWV0ZXJzICovCglwckJzc0luZm8tPnVjSHRPcEluZm8xID0gMDsJLyogUklGUyBkaXNhYmxlZC4gMjBNSHogKi8KCXByQnNzSW5mby0+dTJIdE9wSW5mbzIgPSAwOwoJcHJCc3NJbmZvLT51Mkh0T3BJbmZvMyA9IDA7CgojaWYgQ0ZHX1NVUFBPUlRfODAyXzExQUMKCXByQnNzSW5mby0+dWNWaHRDaGFubmVsV2lkdGggPSAwOwkvKiBWSFRfT1BfQ0hBTk5FTF9XSURUSF84MDsgKi8KCXByQnNzSW5mby0+dWNWaHRDaGFubmVsRnJlcXVlbmN5UzEgPSAwOwkvKiA0MjsgKi8KCXByQnNzSW5mby0+dWNWaHRDaGFubmVsRnJlcXVlbmN5UzIgPSAwOwoJcHJCc3NJbmZvLT51MlZodEJhc2ljTWNzU2V0ID0gMDsJLyogMHhGRkZGOyAqLwojZW5kaWYKCglwckJzc0luZm8tPmVCc3NTQ08gPSAwOwoJcHJCc3NJbmZvLT5mZ0VycFByb3RlY3RNb2RlID0gMDsKCXByQnNzSW5mby0+ZUh0UHJvdGVjdE1vZGUgPSAwOwoJcHJCc3NJbmZvLT5lR2ZPcGVyYXRpb25Nb2RlID0gMDsKCXByQnNzSW5mby0+ZVJpZnNPcGVyYXRpb25Nb2RlID0gMDsKCgkvKiBPQlNTIHJlbGF0ZWQgcGFyYW1ldGVycyAqLwoJcHJCc3NJbmZvLT5hdWMyR18yMG1SZXFDaG5sTGlzdFswXSA9IDA7CglwckJzc0luZm8tPmF1YzJHX05vbkh0Q2hubExpc3RbMF0gPSAwOwoJcHJCc3NJbmZvLT5hdWMyR19QcmlDaG5sTGlzdFswXSA9IDA7CglwckJzc0luZm8tPmF1YzJHX1NlY0NobmxMaXN0WzBdID0gMDsKCXByQnNzSW5mby0+YXVjNUdfMjBtUmVxQ2hubExpc3RbMF0gPSAwOwoJcHJCc3NJbmZvLT5hdWM1R19Ob25IdENobmxMaXN0WzBdID0gMDsKCXByQnNzSW5mby0+YXVjNUdfUHJpQ2hubExpc3RbMF0gPSAwOwoJcHJCc3NJbmZvLT5hdWM1R19TZWNDaG5sTGlzdFswXSA9IDA7CgoJLyogQWxsIFJMTSB0aW1lcnMgd2lsbCBhbHNvIGJlIHN0b3BwZWQgKi8KCWNubVRpbWVyU3RvcFRpbWVyKHByQWRhcHRlciwgJnByQnNzSW5mby0+ck9ic3NTY2FuVGltZXIpOwoJcHJCc3NJbmZvLT51Mk9ic3NTY2FuSW50ZXJ2YWwgPSAwOwoKCXByQnNzSW5mby0+ZmdPYnNzRXJwUHJvdGVjdE1vZGUgPSAwOwkvKiBHTyBvbmx5ICovCglwckJzc0luZm8tPmVPYnNzSHRQcm90ZWN0TW9kZSA9IDA7CS8qIEdPIG9ubHkgKi8KCXByQnNzSW5mby0+ZU9ic3NHZk9wZXJhdGlvbk1vZGUgPSAwOwkvKiBHTyBvbmx5ICovCglwckJzc0luZm8tPmZnT2Jzc1JpZnNPcGVyYXRpb25Nb2RlID0gMDsJLyogR08gb25seSAqLwoJcHJCc3NJbmZvLT5mZ09ic3NBY3Rpb25Gb3JjZWRUbzIwTSA9IDA7CS8qIEdPIG9ubHkgKi8KCXByQnNzSW5mby0+ZmdPYnNzQmVhY29uRm9yY2VkVG8yME0gPSAwOwkvKiBHTyBvbmx5ICovCn0KCiNpZiBDRkdfU1VQUE9SVF9URExTCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIFxicmllZgoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovClVJTlRfMzIgcmxtRmlsbFZodENhcElFQnlBZGFwdGVyKFBfQURBUFRFUl9UIHByQWRhcHRlciwgUF9CU1NfSU5GT19UIHByQnNzSW5mbywgVUlOVF84ICpwT3V0QnVmKQp7CglQX0lFX1ZIVF9DQVBfVCBwclZodENhcDsKCVBfVkhUX1NVUFBPUlRFRF9NQ1NfRklFTEQgcHJWaHRTdXBwb3J0ZWRNY3NTZXQ7CglVSU5UXzggaTsKCglBU1NFUlQocHJBZGFwdGVyKTsKCUFTU0VSVChwckJzc0luZm8pOwoJLyogQVNTRVJUKHByTXNkdUluZm8pOyAqLwoKCXByVmh0Q2FwID0gKFBfSUVfVkhUX0NBUF9UKSBwT3V0QnVmOwoKCXByVmh0Q2FwLT51Y0lkID0gRUxFTV9JRF9WSFRfQ0FQOwoJcHJWaHRDYXAtPnVjTGVuZ3RoID0gc2l6ZW9mKElFX1ZIVF9DQVBfVCkgLSBFTEVNX0hEUl9MRU47CglwclZodENhcC0+dTRWaHRDYXBJbmZvID0gVkhUX0NBUF9JTkZPX0RFRkFVTFRfVkFMOwoKCWlmIChJU19GRUFUVVJFX0VOQUJMRUQocHJBZGFwdGVyLT5yV2lmaVZhci51Y1J4U2hvcnRHSSkpCgkJcHJWaHRDYXAtPnU0Vmh0Q2FwSW5mbyB8PSBWSFRfQ0FQX0lORk9fU0hPUlRfR0lfODA7CgoJaWYgKElTX0ZFQVRVUkVfRU5BQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjUnhMZHBjKSkKCQlwclZodENhcC0+dTRWaHRDYXBJbmZvIHw9IFZIVF9DQVBfSU5GT19SWF9MRFBDOwoKCWlmIChJU19GRUFUVVJFX0VOQUJMRUQocHJBZGFwdGVyLT5yV2lmaVZhci51Y1J4U3RiYykpCgkJcHJWaHRDYXAtPnU0Vmh0Q2FwSW5mbyB8PSBWSFRfQ0FQX0lORk9fUlhfU1RCQ19PTkVfU1RSRUFNOwoKCS8qc2V0IE1DUyBtYXAgKi8KCXByVmh0U3VwcG9ydGVkTWNzU2V0ID0gJnByVmh0Q2FwLT5yVmh0U3VwcG9ydGVkTWNzU2V0OwoJa2FsTWVtWmVybygoUFZPSUQpIHByVmh0U3VwcG9ydGVkTWNzU2V0LCBzaXplb2YoVkhUX1NVUFBPUlRFRF9NQ1NfRklFTEQpKTsKCglmb3IgKGkgPSAwOyBpIDwgODsgaSsrKSB7CgkJcHJWaHRTdXBwb3J0ZWRNY3NTZXQtPnUyUnhNY3NNYXAgfD0gQklUUygyICogaSwgKDIgKiBpICsgMSkpOwoJCXByVmh0U3VwcG9ydGVkTWNzU2V0LT51MlR4TWNzTWFwIHw9IEJJVFMoMiAqIGksICgyICogaSArIDEpKTsKCX0KCglwclZodFN1cHBvcnRlZE1jc1NldC0+dTJSeE1jc01hcCAmPSAoVkhUX0NBUF9JTkZPX01DU19NQVBfTUNTOSA8PCBWSFRfQ0FQX0lORk9fTUNTXzFTU19PRkZTRVQpOwoJcHJWaHRTdXBwb3J0ZWRNY3NTZXQtPnUyVHhNY3NNYXAgJj0gKFZIVF9DQVBfSU5GT19NQ1NfTUFQX01DUzkgPDwgVkhUX0NBUF9JTkZPX01DU18xU1NfT0ZGU0VUKTsKCXByVmh0U3VwcG9ydGVkTWNzU2V0LT51MlJ4SGlnaGVzdFN1cHBvcnRlZERhdGFSYXRlID0gVkhUX0NBUF9JTkZPX0RFRkFVTFRfSElHSEVTVF9EQVRBX1JBVEU7CglwclZodFN1cHBvcnRlZE1jc1NldC0+dTJUeEhpZ2hlc3RTdXBwb3J0ZWREYXRhUmF0ZSA9IFZIVF9DQVBfSU5GT19ERUZBVUxUX0hJR0hFU1RfREFUQV9SQVRFOwoKCUFTU0VSVChJRV9TSVpFKHByVmh0Q2FwKSA8PSAoRUxFTV9IRFJfTEVOICsgRUxFTV9NQVhfTEVOX1ZIVF9DQVApKTsKCglyZXR1cm4gSUVfU0laRShwclZodENhcCk7Cn0KI2VuZGlmCgojaWYgQ0ZHX1NVUFBPUlRfVERMUwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYKKgoqIFxwYXJhbVtpbl0KKgoqIFxyZXR1cm4gbm9uZQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpVSU5UXzMyCnJsbUZpbGxIdENhcElFQnlQYXJhbXMoQk9PTEVBTiBmZzQwbUFsbG93ZWQsCgkJICAgICAgIEJPT0xFQU4gZmdTaG9ydEdJRGlzYWJsZWQsCgkJICAgICAgIFVJTlRfOCB1OFN1cHBvcnRSeFNnaTIwLAoJCSAgICAgICBVSU5UXzggdThTdXBwb3J0UnhTZ2k0MCwgVUlOVF84IHU4U3VwcG9ydFJ4R2YsIEVOVU1fT1BfTU9ERV9UIGVDdXJyZW50T1BNb2RlLCBVSU5UXzggKnBPdXRCdWYpCnsKCVBfSUVfSFRfQ0FQX1QgcHJIdENhcDsKCVBfU1VQX01DU19TRVRfRklFTEQgcHJTdXBNY3NTZXQ7CgoJQVNTRVJUKHBPdXRCdWYpOwoKCXBySHRDYXAgPSAoUF9JRV9IVF9DQVBfVCkgcE91dEJ1ZjsKCgkvKiBBZGQgSFQgY2FwYWJpbGl0aWVzIElFICovCglwckh0Q2FwLT51Y0lkID0gRUxFTV9JRF9IVF9DQVA7Cglwckh0Q2FwLT51Y0xlbmd0aCA9IHNpemVvZihJRV9IVF9DQVBfVCkgLSBFTEVNX0hEUl9MRU47CgoJcHJIdENhcC0+dTJIdENhcEluZm8gPSBIVF9DQVBfSU5GT19ERUZBVUxUX1ZBTDsKCWlmICghZmc0MG1BbGxvd2VkKSB7CgkJcHJIdENhcC0+dTJIdENhcEluZm8gJj0gfihIVF9DQVBfSU5GT19TVVBfQ0hOTF9XSURUSCB8CgkJCQkJICBIVF9DQVBfSU5GT19TSE9SVF9HSV80ME0gfCBIVF9DQVBfSU5GT19EU1NTX0NDS19JTl80ME0pOwoJfQoJaWYgKGZnU2hvcnRHSURpc2FibGVkKQoJCXBySHRDYXAtPnUySHRDYXBJbmZvICY9IH4oSFRfQ0FQX0lORk9fU0hPUlRfR0lfMjBNIHwgSFRfQ0FQX0lORk9fU0hPUlRfR0lfNDBNKTsKCglpZiAodThTdXBwb3J0UnhTZ2kyMCA9PSAyKQoJCXBySHRDYXAtPnUySHRDYXBJbmZvICY9IH4oSFRfQ0FQX0lORk9fU0hPUlRfR0lfMjBNKTsKCWlmICh1OFN1cHBvcnRSeFNnaTQwID09IDIpCgkJcHJIdENhcC0+dTJIdENhcEluZm8gJj0gfihIVF9DQVBfSU5GT19TSE9SVF9HSV80ME0pOwoJaWYgKHU4U3VwcG9ydFJ4R2YgPT0gMikKCQlwckh0Q2FwLT51Mkh0Q2FwSW5mbyAmPSB+KEhUX0NBUF9JTkZPX0hUX0dGKTsKCglwckh0Q2FwLT51Y0FtcGR1UGFyYW0gPSBBTVBEVV9QQVJBTV9ERUZBVUxUX1ZBTDsKCglwclN1cE1jc1NldCA9ICZwckh0Q2FwLT5yU3VwTWNzU2V0OwoJa2FsTWVtWmVybygoUFZPSUQpJnByU3VwTWNzU2V0LT5hdWNSeE1jc0JpdG1hc2tbMF0sIFNVUF9NQ1NfUlhfQklUTUFTS19PQ1RFVF9OVU0pOwoKCXByU3VwTWNzU2V0LT5hdWNSeE1jc0JpdG1hc2tbMF0gPSBCSVRTKDAsIDcpOwoKCWlmIChmZzQwbUFsbG93ZWQpCgkJcHJTdXBNY3NTZXQtPmF1Y1J4TWNzQml0bWFza1szMiAvIDhdID0gQklUKDApOwkvKiBNQ1MzMiAqLwoJcHJTdXBNY3NTZXQtPnUyUnhIaWdoZXN0U3VwcG9ydGVkUmF0ZSA9IFNVUF9NQ1NfUlhfREVGQVVMVF9ISUdIRVNUX1JBVEU7CglwclN1cE1jc1NldC0+dTRUeFJhdGVJbmZvID0gU1VQX01DU19UWF9ERUZBVUxUX1ZBTDsKCglwckh0Q2FwLT51Mkh0RXh0ZW5kZWRDYXAgPSBIVF9FWFRfQ0FQX0RFRkFVTFRfVkFMOwoJaWYgKCFmZzQwbUFsbG93ZWQgfHwgZUN1cnJlbnRPUE1vZGUgIT0gT1BfTU9ERV9JTkZSQVNUUlVDVFVSRSkKCQlwckh0Q2FwLT51Mkh0RXh0ZW5kZWRDYXAgJj0gfihIVF9FWFRfQ0FQX1BDTyB8IEhUX0VYVF9DQVBfUENPX1RSQU5TX1RJTUVfTk9ORSk7CgoJcHJIdENhcC0+dTRUeEJlYW1mb3JtaW5nQ2FwID0gVFhfQkVBTUZPUk1JTkdfQ0FQX0RFRkFVTFRfVkFMOwoKCXBySHRDYXAtPnVjQXNlbENhcCA9IEFTRUxfQ0FQX0RFRkFVTFRfVkFMOwoKCUFTU0VSVChJRV9TSVpFKHBySHRDYXApIDw9IChFTEVNX0hEUl9MRU4gKyBFTEVNX01BWF9MRU5fSFRfQ0FQKSk7CgoJcmV0dXJuIElFX1NJWkUocHJIdENhcCk7Cn0KCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIFxicmllZgoqCiogXHBhcmFtW2luXQoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovClVJTlRfMzIgcmxtRmlsbEh0Q2FwSUVCeUFkYXB0ZXIoUF9BREFQVEVSX1QgcHJBZGFwdGVyLCBQX0JTU19JTkZPX1QgcHJCc3NJbmZvLCBVSU5UXzggKnBPdXRCdWYpCnsKCVBfSUVfSFRfQ0FQX1QgcHJIdENhcDsKCVBfU1VQX01DU19TRVRfRklFTEQgcHJTdXBNY3NTZXQ7CglCT09MRUFOIGZnNDBtQWxsb3dlZDsKCglBU1NFUlQocHJBZGFwdGVyKTsKCUFTU0VSVChwckJzc0luZm8pOwoJQVNTRVJUKHBPdXRCdWYpOwoKCWZnNDBtQWxsb3dlZCA9IHByQnNzSW5mby0+ZmdBc3NvYzQwbUJ3QWxsb3dlZDsKCglwckh0Q2FwID0gKFBfSUVfSFRfQ0FQX1QpIHBPdXRCdWY7CgoJLyogQWRkIEhUIGNhcGFiaWxpdGllcyBJRSAqLwoJcHJIdENhcC0+dWNJZCA9IEVMRU1fSURfSFRfQ0FQOwoJcHJIdENhcC0+dWNMZW5ndGggPSBzaXplb2YoSUVfSFRfQ0FQX1QpIC0gRUxFTV9IRFJfTEVOOwoKCXBySHRDYXAtPnUySHRDYXBJbmZvID0gSFRfQ0FQX0lORk9fREVGQVVMVF9WQUw7CglpZiAoIWZnNDBtQWxsb3dlZCkgewoJCXBySHRDYXAtPnUySHRDYXBJbmZvICY9IH4oSFRfQ0FQX0lORk9fU1VQX0NITkxfV0lEVEggfAoJCQkJCSAgSFRfQ0FQX0lORk9fU0hPUlRfR0lfNDBNIHwgSFRfQ0FQX0lORk9fRFNTU19DQ0tfSU5fNDBNKTsKCX0KCWlmIChJU19GRUFUVVJFX0VOQUJMRUQocHJBZGFwdGVyLT5yV2lmaVZhci51Y1J4U2hvcnRHSSkpCgkJcHJIdENhcC0+dTJIdENhcEluZm8gfD0gKEhUX0NBUF9JTkZPX1NIT1JUX0dJXzIwTSB8IEhUX0NBUF9JTkZPX1NIT1JUX0dJXzQwTSk7CgoJaWYgKElTX0ZFQVRVUkVfRU5BQkxFRChwckFkYXB0ZXItPnJXaWZpVmFyLnVjUnhMZHBjKSkKCQlwckh0Q2FwLT51Mkh0Q2FwSW5mbyB8PSBIVF9DQVBfSU5GT19MRFBDX0NBUDsKCglpZiAoSVNfRkVBVFVSRV9FTkFCTEVEKHByQWRhcHRlci0+cldpZmlWYXIudWNSeFN0YmMpKQoJCXBySHRDYXAtPnUySHRDYXBJbmZvIHw9IEhUX0NBUF9JTkZPX1JYX1NUQkNfMV9TUzsKCglwckh0Q2FwLT51Y0FtcGR1UGFyYW0gPSBBTVBEVV9QQVJBTV9ERUZBVUxUX1ZBTDsKCglwclN1cE1jc1NldCA9ICZwckh0Q2FwLT5yU3VwTWNzU2V0OwoJa2FsTWVtWmVybygoUFZPSUQpJnByU3VwTWNzU2V0LT5hdWNSeE1jc0JpdG1hc2tbMF0sIFNVUF9NQ1NfUlhfQklUTUFTS19PQ1RFVF9OVU0pOwoKCXByU3VwTWNzU2V0LT5hdWNSeE1jc0JpdG1hc2tbMF0gPSBCSVRTKDAsIDcpOwoKCWlmIChmZzQwbUFsbG93ZWQpCgkJcHJTdXBNY3NTZXQtPmF1Y1J4TWNzQml0bWFza1szMiAvIDhdID0gQklUKDApOwkvKiBNQ1MzMiAqLwoJcHJTdXBNY3NTZXQtPnUyUnhIaWdoZXN0U3VwcG9ydGVkUmF0ZSA9IFNVUF9NQ1NfUlhfREVGQVVMVF9ISUdIRVNUX1JBVEU7CglwclN1cE1jc1NldC0+dTRUeFJhdGVJbmZvID0gU1VQX01DU19UWF9ERUZBVUxUX1ZBTDsKCglwckh0Q2FwLT51Mkh0RXh0ZW5kZWRDYXAgPSBIVF9FWFRfQ0FQX0RFRkFVTFRfVkFMOwoJaWYgKCFmZzQwbUFsbG93ZWQgfHwgcHJCc3NJbmZvLT5lQ3VycmVudE9QTW9kZSAhPSBPUF9NT0RFX0lORlJBU1RSVUNUVVJFKQoJCXBySHRDYXAtPnUySHRFeHRlbmRlZENhcCAmPSB+KEhUX0VYVF9DQVBfUENPIHwgSFRfRVhUX0NBUF9QQ09fVFJBTlNfVElNRV9OT05FKTsKCglwckh0Q2FwLT51NFR4QmVhbWZvcm1pbmdDYXAgPSBUWF9CRUFNRk9STUlOR19DQVBfREVGQVVMVF9WQUw7CgoJcHJIdENhcC0+dWNBc2VsQ2FwID0gQVNFTF9DQVBfREVGQVVMVF9WQUw7CgoJQVNTRVJUKElFX1NJWkUocHJIdENhcCkgPD0gKEVMRU1fSERSX0xFTiArIEVMRU1fTUFYX0xFTl9IVF9DQVApKTsKCglyZXR1cm4gSUVfU0laRShwckh0Q2FwKTsKCn0KCiNlbmRpZgoKI2lmIENGR19TVVBQT1JUX0RGUwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBAYnJpZWYgVGhpcyBmdW5jdGlvbiB3aWxsIGNvbXBvc2UgdGhlIFRQQyBSZXBvcnQgZnJhbWUuCioKKiBAcGFyYW1baW5dIHByQWRhcHRlciAgICAgICAgICAgICAgUG9pbnRlciB0byB0aGUgQWRhcHRlciBzdHJ1Y3R1cmUuCiogQHBhcmFtW2luXSBwclN0YVJlYyAgICAgICAgICAgICAgIFBvaW50ZXIgdG8gdGhlIFNUQV9SRUNPUkRfVC4KKgoqIEByZXR1cm4gKG5vbmUpCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCnN0YXRpYyBWT0lECnRwY0NvbXBvc2VSZXBvcnRGcmFtZShJTiBQX0FEQVBURVJfVCBwckFkYXB0ZXIsIElOIFBfU1RBX1JFQ09SRF9UIHByU3RhUmVjLCBJTiBQRk5fVFhfRE9ORV9IQU5ETEVSIHBmVHhEb25lSGFuZGxlcikKewoJUF9NU0RVX0lORk9fVCBwck1zZHVJbmZvOwoJUF9CU1NfSU5GT19UIHByQnNzSW5mbzsKCVBfQUNUSU9OX1RQQ19SRVBPUlRfRlJBTUUgcHJUeEZyYW1lOwoJVUlOVF8xNiB1MlBheWxvYWRMZW47CgoJQVNTRVJUKHByQWRhcHRlcik7CglBU1NFUlQocHJTdGFSZWMpOwoKCXByQnNzSW5mbyA9ICZwckFkYXB0ZXItPnJXaWZpVmFyLmFyQnNzSW5mb1Bvb2xbcHJTdGFSZWMtPnVjQnNzSW5kZXhdOwoJQVNTRVJUKHByQnNzSW5mbyk7CgoJcHJNc2R1SW5mbyA9IChQX01TRFVfSU5GT19UKSBjbm1NZ3RQa3RBbGxvYyhwckFkYXB0ZXIsIE1BQ19UWF9SRVNFUlZFRF9GSUVMRCArIFBVQkxJQ19BQ1RJT05fTUFYX0xFTik7CgoJaWYgKCFwck1zZHVJbmZvKQoJCXJldHVybjsKCglwclR4RnJhbWUgPSAoUF9BQ1RJT05fVFBDX1JFUE9SVF9GUkFNRSkKCSAgICAoKFVMT05HKSAocHJNc2R1SW5mby0+cHJQYWNrZXQpICsgTUFDX1RYX1JFU0VSVkVEX0ZJRUxEKTsKCglwclR4RnJhbWUtPnUyRnJhbWVDdHJsID0gTUFDX0ZSQU1FX0FDVElPTjsKCglDT1BZX01BQ19BRERSKHByVHhGcmFtZS0+YXVjRGVzdEFkZHIsIHByU3RhUmVjLT5hdWNNYWNBZGRyKTsKCUNPUFlfTUFDX0FERFIocHJUeEZyYW1lLT5hdWNTcmNBZGRyLCBwckJzc0luZm8tPmF1Y093bk1hY0FkZHIpOwoJQ09QWV9NQUNfQUREUihwclR4RnJhbWUtPmF1Y0JTU0lELCBwckJzc0luZm8tPmF1Y0JTU0lEKTsKCglwclR4RnJhbWUtPnVjQ2F0ZWdvcnkgPSBDQVRFR09SWV9TUEVDX01HVDsKCXByVHhGcmFtZS0+dWNBY3Rpb24gPSBBQ1RJT05fVFBDX1JFUE9SVDsKCgkvKiAzIENvbXBvc2UgdGhlIGZyYW1lIGJvZHkncyBmcmFtZS4gKi8KCXByVHhGcmFtZS0+dWNEaWFsb2dUb2tlbiA9IHByU3RhUmVjLT51Y1NtRGlhbG9nVG9rZW47CglwclR4RnJhbWUtPnVjRWxlbUlkID0gRUxFTV9JRF9UUENfUkVQT1JUOwoJcHJUeEZyYW1lLT51Y0xlbmd0aCA9IHNpemVvZihwclR4RnJhbWUtPnVjTGlua01hcmdpbikrc2l6ZW9mKHByVHhGcmFtZS0+dWNUcmFuc1B3cik7CglwclR4RnJhbWUtPnVjVHJhbnNQd3IgPSBwckFkYXB0ZXItPnU0R2V0VHhQb3dlcjsKCXByVHhGcmFtZS0+dWNMaW5rTWFyZ2luID0gcHJBZGFwdGVyLT5yTGlua1F1YWxpdHkuY1Jzc2kgLSAoMCAtIE1JTl9SQ1ZfUFdSKTsKCgl1MlBheWxvYWRMZW4gPSBBQ1RJT05fU01fVFBDX1JFUE9SVF9MRU47CgoJLyogNCBVcGRhdGUgaW5mb3JtYXRpb24gb2YgTVNEVV9JTkZPX1QgKi8KCVRYX1NFVF9NTVBEVShwckFkYXB0ZXIsCgkJICAgICBwck1zZHVJbmZvLAoJCSAgICAgcHJTdGFSZWMtPnVjQnNzSW5kZXgsCgkJICAgICBwclN0YVJlYy0+dWNJbmRleCwKCQkgICAgIFdMQU5fTUFDX01HTVRfSEVBREVSX0xFTiwKCQkgICAgIFdMQU5fTUFDX01HTVRfSEVBREVSX0xFTiArIHUyUGF5bG9hZExlbiwgcGZUeERvbmVIYW5kbGVyLCBNU0RVX1JBVEVfTU9ERV9BVVRPKTsKCglEQkdMT0coUkxNLCBUUkFDRSwgInVjRGlhbG9nVG9rZW4gJWQgdWNUcmFuc1B3ciAlZCB1Y0xpbmtNYXJnaW4gJWRcbiIsCgkgICAgICAgcHJUeEZyYW1lLT51Y0RpYWxvZ1Rva2VuLCBwclR4RnJhbWUtPnVjVHJhbnNQd3IsIHByVHhGcmFtZS0+dWNMaW5rTWFyZ2luKTsKCgkvKiA0IEVucXVldWUgdGhlIGZyYW1lIHRvIHNlbmQgdGhpcyBhY3Rpb24gZnJhbWUuICovCgluaWNUeEVucXVldWVNc2R1KHByQWRhcHRlciwgcHJNc2R1SW5mbyk7CgoJcmV0dXJuOwoKfQkJCQkvKiBlbmQgb2YgdHBjQ29tcG9zZVJlcG9ydEZyYW1lKCkgKi8KCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIEBicmllZiBUaGlzIGZ1bmN0aW9uIHdpbGwgY29tcG9zZSB0aGUgTWVhc3VyZW1lbnQgUmVwb3J0IGZyYW1lLgoqCiogQHBhcmFtW2luXSBwckFkYXB0ZXIgICAgICAgICAgICAgIFBvaW50ZXIgdG8gdGhlIEFkYXB0ZXIgc3RydWN0dXJlLgoqIEBwYXJhbVtpbl0gcHJTdGFSZWMgICAgICAgICAgICAgICBQb2ludGVyIHRvIHRoZSBTVEFfUkVDT1JEX1QuCioKKiBAcmV0dXJuIChub25lKQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpzdGF0aWMgVk9JRAptc210Q29tcG9zZVJlcG9ydEZyYW1lKElOIFBfQURBUFRFUl9UIHByQWRhcHRlciwgSU4gUF9TVEFfUkVDT1JEX1QgcHJTdGFSZWMsIElOIFBGTl9UWF9ET05FX0hBTkRMRVIgcGZUeERvbmVIYW5kbGVyKQp7CglQX01TRFVfSU5GT19UIHByTXNkdUluZm87CglQX0JTU19JTkZPX1QgcHJCc3NJbmZvOwoJUF9BQ1RJT05fU01fUkVQT1JUX0ZSQU1FIHByVHhGcmFtZTsKCVBfSUVfTUVBU1VSRU1FTlRfUkVQT1JUX1QgcHJNZWFzdXJlbWVudFJlcElFOwoJUFVJTlRfOCBwdWNJRTsKCVVJTlRfMTYgdTJQYXlsb2FkTGVuOwoKCUFTU0VSVChwckFkYXB0ZXIpOwoJQVNTRVJUKHByU3RhUmVjKTsKCglwckJzc0luZm8gPSAmcHJBZGFwdGVyLT5yV2lmaVZhci5hckJzc0luZm9Qb29sW3ByU3RhUmVjLT51Y0Jzc0luZGV4XTsKCUFTU0VSVChwckJzc0luZm8pOwoKCXByTXNkdUluZm8gPSAoUF9NU0RVX0lORk9fVCkgY25tTWd0UGt0QWxsb2MocHJBZGFwdGVyLCBNQUNfVFhfUkVTRVJWRURfRklFTEQgKyBQVUJMSUNfQUNUSU9OX01BWF9MRU4pOwoKCWlmICghcHJNc2R1SW5mbykKCQlyZXR1cm47CgoJcHJUeEZyYW1lID0gKFBfQUNUSU9OX1NNX1JFUE9SVF9GUkFNRSkKCSAgICAoKFVMT05HKSAocHJNc2R1SW5mby0+cHJQYWNrZXQpICsgTUFDX1RYX1JFU0VSVkVEX0ZJRUxEKTsKCXB1Y0lFID0gcHJUeEZyYW1lLT5hdWNJbmZvRWxlbTsKCXByTWVhc3VyZW1lbnRSZXBJRSA9IFNNX01FQVNVUkVNRU5UX1JFUF9JRShwdWNJRSk7CgoJcHJUeEZyYW1lLT51MkZyYW1lQ3RybCA9IE1BQ19GUkFNRV9BQ1RJT047CgoJQ09QWV9NQUNfQUREUihwclR4RnJhbWUtPmF1Y0Rlc3RBZGRyLCBwclN0YVJlYy0+YXVjTWFjQWRkcik7CglDT1BZX01BQ19BRERSKHByVHhGcmFtZS0+YXVjU3JjQWRkciwgcHJCc3NJbmZvLT5hdWNPd25NYWNBZGRyKTsKCUNPUFlfTUFDX0FERFIocHJUeEZyYW1lLT5hdWNCU1NJRCwgcHJCc3NJbmZvLT5hdWNCU1NJRCk7CgoJcHJUeEZyYW1lLT51Y0NhdGVnb3J5ID0gQ0FURUdPUllfU1BFQ19NR1Q7CglwclR4RnJhbWUtPnVjQWN0aW9uID0gQUNUSU9OX01FQVNVUkVNRU5UX1JFUE9SVDsKCgkvKiAzIENvbXBvc2UgdGhlIGZyYW1lIGJvZHkncyBmcmFtZS4gKi8KCXByVHhGcmFtZS0+dWNEaWFsb2dUb2tlbiA9IHByU3RhUmVjLT51Y1NtRGlhbG9nVG9rZW47Cglwck1lYXN1cmVtZW50UmVwSUUtPnVjSWQgPSBFTEVNX0lEX01FQVNVUkVNRU5UX1JFUE9SVDsKCiNpZiAwCglpZiAocHJTdGFSZWMtPnVjU21Nc210UmVxdWVzdE1vZGUgPT0gRUxFTV9STV9UWVBFX0JBU0lDX1JFUSkgewoJCXByTWVhc3VyZW1lbnRSZXBJRS0+dWNMZW5ndGggPSBzaXplb2YoU01fQkFTSUNfUkVQT1JUX1QpICsgMzsKCQl1MlBheWxvYWRMZW4gPSBBQ1RJT05fU01fTUVBU1VSRV9SRVBPUlRfTEVOK0FDVElPTl9TTV9CQVNJQ19SRVBPUlRfTEVOOwoJfSBlbHNlIGlmIChwclN0YVJlYy0+dWNTbU1zbXRSZXF1ZXN0TW9kZSA9PSBFTEVNX1JNX1RZUEVfQ0NBX1JFUSkgewoJCXByTWVhc3VyZW1lbnRSZXBJRS0+dWNMZW5ndGggPSBzaXplb2YoU01fQ0NBX1JFUE9SVF9UKSArIDM7CgkJdTJQYXlsb2FkTGVuID0gQUNUSU9OX1NNX01FQVNVUkVfUkVQT1JUX0xFTitBQ1RJT05fU01fQ0NBX1JFUE9SVF9MRU47Cgl9IGVsc2UgaWYgKHByU3RhUmVjLT51Y1NtTXNtdFJlcXVlc3RNb2RlID09IEVMRU1fUk1fVFlQRV9SUElfSElTVE9HUkFNX1JFUSkgewoJCXByTWVhc3VyZW1lbnRSZXBJRS0+dWNMZW5ndGggPSBzaXplb2YoU01fUlBJX1JFUE9SVF9UKSArIDM7CgkJdTJQYXlsb2FkTGVuID0gQUNUSU9OX1NNX01FQVNVUkVfUkVQT1JUX0xFTitBQ1RJT05fU01fUFJJX1JFUE9SVF9MRU47Cgl9IGVsc2UgewoJCXByTWVhc3VyZW1lbnRSZXBJRS0+dWNMZW5ndGggPSAzOwoJCXUyUGF5bG9hZExlbiA9IEFDVElPTl9TTV9NRUFTVVJFX1JFUE9SVF9MRU47Cgl9CiNlbHNlCglwck1lYXN1cmVtZW50UmVwSUUtPnVjTGVuZ3RoID0gMzsKCXUyUGF5bG9hZExlbiA9IEFDVElPTl9TTV9NRUFTVVJFX1JFUE9SVF9MRU47Cglwck1lYXN1cmVtZW50UmVwSUUtPnVjVG9rZW4gPSBwclN0YVJlYy0+dWNTbU1zbXRUb2tlbjsKCXByTWVhc3VyZW1lbnRSZXBJRS0+dWNSZXBvcnRNb2RlID0gQklUKDEpOwoJcHJNZWFzdXJlbWVudFJlcElFLT51Y01lYXN1cmVtZW50VHlwZSA9IHByU3RhUmVjLT51Y1NtTXNtdFJlcXVlc3RNb2RlOwojZW5kaWYKCgkvKiA0IFVwZGF0ZSBpbmZvcm1hdGlvbiBvZiBNU0RVX0lORk9fVCAqLwoJVFhfU0VUX01NUERVKHByQWRhcHRlciwKCQkgICAgIHByTXNkdUluZm8sCgkJICAgICBwclN0YVJlYy0+dWNCc3NJbmRleCwKCQkgICAgIHByU3RhUmVjLT51Y0luZGV4LAoJCSAgICAgV0xBTl9NQUNfTUdNVF9IRUFERVJfTEVOLAoJCSAgICAgV0xBTl9NQUNfTUdNVF9IRUFERVJfTEVOICsgdTJQYXlsb2FkTGVuLCBwZlR4RG9uZUhhbmRsZXIsIE1TRFVfUkFURV9NT0RFX0FVVE8pOwoKCURCR0xPRyhSTE0sIFRSQUNFLCAidWNEaWFsb2dUb2tlbiAlZCB1Y1Rva2VuICVkIHVjUmVwb3J0TW9kZSAlZCB1Y01lYXN1cmVtZW50VHlwZSAlZFxuIiwKCSAgICAgICBwclR4RnJhbWUtPnVjRGlhbG9nVG9rZW4sIHByTWVhc3VyZW1lbnRSZXBJRS0+dWNUb2tlbiwKCSAgICAgICBwck1lYXN1cmVtZW50UmVwSUUtPnVjUmVwb3J0TW9kZSwgcHJNZWFzdXJlbWVudFJlcElFLT51Y01lYXN1cmVtZW50VHlwZSk7CgoJLyogNCBFbnF1ZXVlIHRoZSBmcmFtZSB0byBzZW5kIHRoaXMgYWN0aW9uIGZyYW1lLiAqLwoJbmljVHhFbnF1ZXVlTXNkdShwckFkYXB0ZXIsIHByTXNkdUluZm8pOwoKCXJldHVybjsKCn0JCQkJLyogZW5kIG9mIG1zbXRDb21wb3NlUmVwb3J0RnJhbWUoKSAqLwoKLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLyohCiogXGJyaWVmIFRoaXMgZnVuY3Rpb24gaGFuZGxlIHNwZWN0cnVtIG1hbmFnZW1lbnQgYWN0aW9uIGZyYW1lCioKKiBccGFyYW1baW5dCioKKiBccmV0dXJuIG5vbmUKKi8KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KVk9JRCBybG1Qcm9jZXNzU3BlY01ndEFjdGlvbihQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfU1dfUkZCX1QgcHJTd1JmYikKewoJUFVJTlRfOCBwdWNJRTsKCVBfU1RBX1JFQ09SRF9UIHByU3RhUmVjOwoJUF9CU1NfSU5GT19UIHByQnNzSW5mbzsKCVVJTlRfMTYgdTJJRUxlbmd0aDsKCVVJTlRfMTYgdTJPZmZzZXQgPSAwOwoJUF9JRV9DSEFOTkVMX1NXSVRDSF9UIHByQ2hhbm5lbFN3aXRjaEFubm91bmNlSUU7CglQX0lFX1NFQ09OREFSWV9PRkZTRVRfVCBwclNlY29uZGFyeU9mZnNldElFOwoJUF9JRV9XSURFX0JBTkRfQ0hBTk5FTF9UIHByV2lkZUJhbmRDaGFubmVsSUU7CglQX0lFX1RQQ19SRVFfVCBwclRwY1JlcUlFOwoJUF9JRV9UUENfUkVQT1JUX1QgcHJUcGNSZXBJRTsKCVBfSUVfTUVBU1VSRU1FTlRfUkVRX1QgcHJNZWFzdXJlbWVudFJlcUlFOwoJUF9JRV9NRUFTVVJFTUVOVF9SRVBPUlRfVCBwck1lYXN1cmVtZW50UmVwSUU7CglQX0FDVElPTl9TTV9SRVFfRlJBTUUgcHJSeEZyYW1lOwoJQk9PTEVBTiBmZ0hhc1dpZGVCYW5kSUUgPSBGQUxTRTsKCUJPT0xFQU4gZmdIYXNTQ09JRSA9IEZBTFNFOwoJQk9PTEVBTiBmZ0hhc0NoYW5uZWxTd2l0Y2hJRSA9IEZBTFNFOwoKCURCR0xPRyhSTE0sIElORk8sICJbTWd0IEFjdGlvbl1ybG1Qcm9jZXNzU3BlY01ndEFjdGlvblxuIik7CglBU1NFUlQocHJBZGFwdGVyKTsKCUFTU0VSVChwclN3UmZiKTsKCgl1MklFTGVuZ3RoID0gcHJTd1JmYi0+dTJQYWNrZXRMZW4gLQoJCShVSU5UXzE2KSBPRkZTRVRfT0YoQUNUSU9OX1NNX1JFUV9GUkFNRSwgYXVjSW5mb0VsZW1bMF0pOwoKCXByUnhGcmFtZSA9IChQX0FDVElPTl9TTV9SRVFfRlJBTUUpIHByU3dSZmItPnB2SGVhZGVyOwoJcHVjSUUgPSBwclJ4RnJhbWUtPmF1Y0luZm9FbGVtOwoKCXByU3RhUmVjID0gY25tR2V0U3RhUmVjQnlJbmRleChwckFkYXB0ZXIsIHByU3dSZmItPnVjU3RhUmVjSWR4KTsKCWlmICghcHJTdGFSZWMpCgkJcmV0dXJuOwoKCWlmIChwclN0YVJlYy0+dWNCc3NJbmRleCA+IE1BWF9CU1NfSU5ERVgpCgkJcmV0dXJuOwoKCXByQnNzSW5mbyA9IEdFVF9CU1NfSU5GT19CWV9JTkRFWChwckFkYXB0ZXIsIHByU3RhUmVjLT51Y0Jzc0luZGV4KTsKCglwclN0YVJlYy0+dWNTbURpYWxvZ1Rva2VuID0gcHJSeEZyYW1lLT51Y0RpYWxvZ1Rva2VuOwoKCURCR0xPR19NRU04KFJMTSwgSU5GTywgcHVjSUUsIHUySUVMZW5ndGgpOwoJc3dpdGNoIChwclJ4RnJhbWUtPnVjQWN0aW9uKSB7CgljYXNlIEFDVElPTl9NRUFTVVJFTUVOVF9SRVE6CgkJREJHTE9HKFJMTSwgSU5GTywgIltNZ3QgQWN0aW9uXSBNZWFzdXJlIFJlcXVlc3RcbiIpOwoJCXByTWVhc3VyZW1lbnRSZXFJRSA9IFNNX01FQVNVUkVNRU5UX1JFUV9JRShwdWNJRSk7CgkJaWYgKHByTWVhc3VyZW1lbnRSZXFJRS0+dWNJZCA9PSBFTEVNX0lEX01FQVNVUkVNRU5UX1JFUSkgewoJCQlwclN0YVJlYy0+dWNTbU1zbXRSZXF1ZXN0TW9kZSA9IHByTWVhc3VyZW1lbnRSZXFJRS0+dWNSZXF1ZXN0TW9kZTsKCQkJcHJTdGFSZWMtPnVjU21Nc210VG9rZW4gPSBwck1lYXN1cmVtZW50UmVxSUUtPnVjVG9rZW47CgkJCW1zbXRDb21wb3NlUmVwb3J0RnJhbWUocHJBZGFwdGVyLCBwclN0YVJlYywgTlVMTCk7CgkJfQoKCQlicmVhazsKCWNhc2UgQUNUSU9OX01FQVNVUkVNRU5UX1JFUE9SVDoKCQlEQkdMT0coUkxNLCBJTkZPLCAiW01ndCBBY3Rpb25dIE1lYXN1cmUgUmVwb3J0XG4iKTsKCQlwck1lYXN1cmVtZW50UmVwSUUgPSBTTV9NRUFTVVJFTUVOVF9SRVBfSUUocHVjSUUpOwoJCWlmIChwck1lYXN1cmVtZW50UmVwSUUtPnVjSWQgPT0gRUxFTV9JRF9NRUFTVVJFTUVOVF9SRVBPUlQpCgkJCURCR0xPRyhSTE0sIFRSQUNFLCAiW01ndCBBY3Rpb25dIENvcnJlY3QgTWVhc3VyZW1lbnQgcmVwb3J0IElFICEhXG4iKTsKCQlicmVhazsKCWNhc2UgQUNUSU9OX1RQQ19SRVE6CgkJREJHTE9HKFJMTSwgSU5GTywgIltNZ3QgQWN0aW9uXSBUUEMgUmVxdWVzdFxuIik7CgkJcHJUcGNSZXFJRSA9IFNNX1RQQ19SRVFfSUUocHVjSUUpOwoKCQlpZiAocHJUcGNSZXFJRS0+dWNJZCA9PSBFTEVNX0lEX1RQQ19SRVEpCgkJCXRwY0NvbXBvc2VSZXBvcnRGcmFtZShwckFkYXB0ZXIsIHByU3RhUmVjLCBOVUxMKTsKCgkJYnJlYWs7CgljYXNlIEFDVElPTl9UUENfUkVQT1JUOgoJCURCR0xPRyhSTE0sIElORk8sICJbTWd0IEFjdGlvbl0gVFBDIFJlcG9ydFxuIik7CgkJcHJUcGNSZXBJRSA9IFNNX1RQQ19SRVBfSUUocHVjSUUpOwoKCQlpZiAocHJUcGNSZXBJRS0+dWNJZCA9PSBFTEVNX0lEX1RQQ19SRVBPUlQpCgkJCURCR0xPRyhSTE0sIFRSQUNFLCAiW01ndCBBY3Rpb25dIENvcnJlY3QgVFBDIHJlcG9ydCBJRSAhIVxuIik7CgoJCWJyZWFrOwoJY2FzZSBBQ1RJT05fQ0hOTF9TV0lUQ0g6CgkJSUVfRk9SX0VBQ0gocHVjSUUsIHUySUVMZW5ndGgsIHUyT2Zmc2V0KSB7CgkJCXN3aXRjaCAoSUVfSUQocHVjSUUpKSB7CgoJCQljYXNlIEVMRU1fSURfV0lERV9CQU5EX0NIQU5ORUxfU1dJVENIOgoJCQkJaWYgKCFSTE1fTkVUX0lTXzExQUMocHJCc3NJbmZvKSB8fAoJCQkJICAgIElFX0xFTihwdWNJRSkgIT0gKHNpemVvZihJRV9XSURFX0JBTkRfQ0hBTk5FTF9UKSAtIDIpKSB7CgkJCQkJREJHTE9HKFJMTSwgSU5GTywgIltNZ3QgQWN0aW9uXSBFTEVNX0lEX1dJREVfQkFORF9DSEFOTkVMX1NXSVRDSCwgTGVuZ3RoXG4iKTsKCQkJCQlicmVhazsKCQkJCX0KCQkJCURCR0xPRyhSTE0sIElORk8sICJbTWd0IEFjdGlvbl0gRUxFTV9JRF9XSURFX0JBTkRfQ0hBTk5FTF9TV0lUQ0gsIDExQUNcbiIpOwoJCQkJcHJXaWRlQmFuZENoYW5uZWxJRSA9IChQX0lFX1dJREVfQkFORF9DSEFOTkVMX1QpIHB1Y0lFOwoJCQkJcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxXaWR0aCA9IHByV2lkZUJhbmRDaGFubmVsSUUtPnVjTmV3Q2hhbm5lbFdpZHRoOwoJCQkJcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxGcmVxdWVuY3lTMSA9IHByV2lkZUJhbmRDaGFubmVsSUUtPnVjQ2hhbm5lbFMxOwoJCQkJcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxGcmVxdWVuY3lTMiA9IHByV2lkZUJhbmRDaGFubmVsSUUtPnVjQ2hhbm5lbFMyOwoJCQkJZmdIYXNXaWRlQmFuZElFID0gVFJVRTsKCQkJCWJyZWFrOwoKCQkJY2FzZSBFTEVNX0lEX0NIX1NXX0FOTk9VTkNFTUVOVDoKCQkJCWlmIChJRV9MRU4ocHVjSUUpICE9IChzaXplb2YoSUVfQ0hBTk5FTF9TV0lUQ0hfVCkgLSAyKSkgewoJCQkJCURCR0xPRyhSTE0sIElORk8sICJbTWd0IEFjdGlvbl0gRUxFTV9JRF9DSF9TV19BTk5PVU5DRU1FTlQsIExlbmd0aFxuIik7CgkJCQkJYnJlYWs7CgkJCQl9CgoJCQkJcHJDaGFubmVsU3dpdGNoQW5ub3VuY2VJRSA9IChQX0lFX0NIQU5ORUxfU1dJVENIX1QpIHB1Y0lFOwoKCQkJCWlmIChwckNoYW5uZWxTd2l0Y2hBbm5vdW5jZUlFLT51Y0NoYW5uZWxTd2l0Y2hNb2RlID09IDEpIHsKCQkJCQlEQkdMT0coUkxNLCBJTkZPLAoJCQkJCSAgICAgICAiW01ndCBBY3Rpb25dIHN3aXRjaCBjaGFubmVsIFslZF0tPlslZF1cbiIsCgkJCQkJICAgICAgIHByQnNzSW5mby0+dWNQcmltYXJ5Q2hhbm5lbCwgcHJDaGFubmVsU3dpdGNoQW5ub3VuY2VJRS0+dWNOZXdDaGFubmVsTnVtKTsKCQkJCQlwckJzc0luZm8tPnVjUHJpbWFyeUNoYW5uZWwgPSBwckNoYW5uZWxTd2l0Y2hBbm5vdW5jZUlFLT51Y05ld0NoYW5uZWxOdW07CgkJCQl9IGVsc2UgewoJCQkJCURCR0xPRyhSTE0sIElORk8sICJbTWd0IEFjdGlvbl0gdWNDaGFubmVsU3dpdGNoTW9kZSA9IDBcbiIpOwoJCQkJfQoKCQkJCWZnSGFzQ2hhbm5lbFN3aXRjaElFID0gVFJVRTsKCQkJCWJyZWFrOwoJCQljYXNlIEVMRU1fSURfU0NPOgoJCQkJaWYgKElFX0xFTihwdWNJRSkgIT0gKHNpemVvZihJRV9TRUNPTkRBUllfT0ZGU0VUX1QpIC0gMikpIHsKCQkJCQlEQkdMT0coUkxNLCBJTkZPLCAiW01ndCBBY3Rpb25dIEVMRU1fSURfU0NPLCBMZW5ndGhcbiIpOwoJCQkJCWJyZWFrOwoJCQkJfQoJCQkJcHJTZWNvbmRhcnlPZmZzZXRJRSA9IChQX0lFX1NFQ09OREFSWV9PRkZTRVRfVCkgcHVjSUU7CgkJCQlEQkdMT0coUkxNLCBJTkZPLAoJCQkJICAgICAgICJbTWd0IEFjdGlvbl0gU0NPIFslZF0tPlslZF1cbiIsIHByQnNzSW5mby0+ZUJzc1NDTywKCQkJCSAgICAgICBwclNlY29uZGFyeU9mZnNldElFLT51Y1NlY29uZGFyeU9mZnNldCk7CgkJCQlwckJzc0luZm8tPmVCc3NTQ08gPSBwclNlY29uZGFyeU9mZnNldElFLT51Y1NlY29uZGFyeU9mZnNldDsKCQkJCWZnSGFzU0NPSUUgPSBUUlVFOwoJCQkJYnJlYWs7CgkJCWRlZmF1bHQ6CgkJCQlicmVhazsKCQkJfQkvKmVuZCBvZiBzd2l0Y2ggSUVfSUQgKi8KCQl9CQkvKmVuZCBvZiBJRV9GT1JfRUFDSCAqLwoJCWlmIChmZ0hhc0NoYW5uZWxTd2l0Y2hJRSAhPSBGQUxTRSkgewoJCQlpZiAoZmdIYXNXaWRlQmFuZElFID09IEZBTFNFKSB7CgkJCQlwckJzc0luZm8tPnVjVmh0Q2hhbm5lbFdpZHRoID0gMDsKCQkJCXByQnNzSW5mby0+dWNWaHRDaGFubmVsRnJlcXVlbmN5UzEgPSBwckJzc0luZm8tPnVjUHJpbWFyeUNoYW5uZWw7CgkJCQlwckJzc0luZm8tPnVjVmh0Q2hhbm5lbEZyZXF1ZW5jeVMyID0gMDsKCQkJfQoJCQlpZiAoZmdIYXNTQ09JRSA9PSBGQUxTRSkKCQkJCXByQnNzSW5mby0+ZUJzc1NDTyA9IENITkxfRVhUX1NDTjsKCQl9CgkJbmljVXBkYXRlQnNzKHByQWRhcHRlciwgcHJCc3NJbmZvLT51Y0Jzc0luZGV4KTsKCQlicmVhazsKCWRlZmF1bHQ6CgkJYnJlYWs7Cgl9Cn0KCiNlbmRpZgoKCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIFxicmllZiBTZW5kIE9wTW9kZSBOb3JpZmljYXRpb24gZnJhbWUgKFZIVCBhY3Rpb24gZnJhbWUpCioKKiBccGFyYW1baW5dIHVjQ2hhbm5lbFdpZHRoIDA6MjBNSHosIDE6NDBNSHosIDI6ODBNSHosIDM6MTYwTUh6IG9yIDgwKzgwTUh6CioKKiBccmV0dXJuIG5vbmUKKi8KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KVk9JRCBybG1TZW5kT3BNb2RlTm90aWZpY2F0aW9uRnJhbWUoUF9BREFQVEVSX1QgcHJBZGFwdGVyLCBQX1NUQV9SRUNPUkRfVCBwclN0YVJlYywgVUlOVF84IHVjQ2hhbm5lbFdpZHRoLCBVSU5UXzggdWNOc3MpCnsKCglQX01TRFVfSU5GT19UIHByTXNkdUluZm87CglQX0FDVElPTl9PUF9NT0RFX05PVElGSUNBVElPTl9GUkFNRSBwclR4RnJhbWU7CglQX0JTU19JTkZPX1QgcHJCc3NJbmZvOwoJVUlOVF8xNiB1MkVzdGltYXRlZEZyYW1lTGVuOwoJLyogUEZOX1RYX0RPTkVfSEFORExFUiBwZlR4RG9uZUhhbmRsZXIgPSAoUEZOX1RYX0RPTkVfSEFORExFUikgTlVMTDsgKi8KCgkvKiBTYW5pdHkgQ2hlY2sgKi8KCWlmICghcHJTdGFSZWMpCgkJcmV0dXJuOwoKCXByQnNzSW5mbyA9IEdFVF9CU1NfSU5GT19CWV9JTkRFWChwckFkYXB0ZXIsIHByU3RhUmVjLT51Y0Jzc0luZGV4KTsKCWlmICghcHJCc3NJbmZvKQoJCXJldHVybjsKCgkvKiBDYWxjdWxhdGUgTVNEVSBidWZmZXIgbGVuZ3RoICovCgl1MkVzdGltYXRlZEZyYW1lTGVuID0gTUFDX1RYX1JFU0VSVkVEX0ZJRUxEICsgc2l6ZW9mKEFDVElPTl9PUF9NT0RFX05PVElGSUNBVElPTl9GUkFNRSk7CgoJLyogQWxsb2MgTVNEVV9JTkZPICovCglwck1zZHVJbmZvID0gKFBfTVNEVV9JTkZPX1QpIGNubU1ndFBrdEFsbG9jKHByQWRhcHRlciwgdTJFc3RpbWF0ZWRGcmFtZUxlbik7CgoJaWYgKCFwck1zZHVJbmZvKQoJCXJldHVybjsKCglrYWxNZW1aZXJvKHByTXNkdUluZm8tPnByUGFja2V0LCB1MkVzdGltYXRlZEZyYW1lTGVuKTsKCglwclR4RnJhbWUgPSBwck1zZHVJbmZvLT5wclBhY2tldDsKCgkvKiBGaWxsIGZyYW1lIGN0cmwgKi8KCXByVHhGcmFtZS0+dTJGcmFtZUN0cmwgPSBNQUNfRlJBTUVfQUNUSU9OOwoKCUNPUFlfTUFDX0FERFIocHJUeEZyYW1lLT5hdWNEZXN0QWRkciwgcHJTdGFSZWMtPmF1Y01hY0FkZHIpOwoJQ09QWV9NQUNfQUREUihwclR4RnJhbWUtPmF1Y1NyY0FkZHIsIHByQnNzSW5mby0+YXVjT3duTWFjQWRkcik7CglDT1BZX01BQ19BRERSKHByVHhGcmFtZS0+YXVjQlNTSUQsIHByQnNzSW5mby0+YXVjQlNTSUQpOwoKCS8qIDMgQ29tcG9zZSB0aGUgZnJhbWUgYm9keSdzIGZyYW1lICovCglwclR4RnJhbWUtPnVjQ2F0ZWdvcnkgPSBDQVRFR09SWV9WSFRfQUNUSU9OOwoJcHJUeEZyYW1lLT51Y0FjdGlvbiA9IEFDVElPTl9PUEVSQVRJTkdfTU9ERV9OT1RJRklDQVRJT047CgoJcHJUeEZyYW1lLT51Y09wZXJhdGluZ01vZGUgfD0gKHVjQ2hhbm5lbFdpZHRoICYgVkhUX09QX01PREVfQ0hBTk5FTF9XSURUSCk7CgoJaWYgKHVjTnNzID09IDApCgkJdWNOc3MgPSAxOwoJcHJUeEZyYW1lLT51Y09wZXJhdGluZ01vZGUgfD0gKCgodWNOc3MgLSAxKSA8PCA0KSAmIFZIVF9PUF9NT0RFX1JYX05TUyk7CglwclR4RnJhbWUtPnVjT3BlcmF0aW5nTW9kZSAmPSB+VkhUX09QX01PREVfUlhfTlNTX1RZUEU7CgoJLyogNCBVcGRhdGUgaW5mb3JtYXRpb24gb2YgTVNEVV9JTkZPX1QgKi8KCVRYX1NFVF9NTVBEVShwckFkYXB0ZXIsCgkJICAgICBwck1zZHVJbmZvLAoJCSAgICAgcHJCc3NJbmZvLT51Y0Jzc0luZGV4LAoJCSAgICAgcHJTdGFSZWMtPnVjSW5kZXgsCgkJICAgICBXTEFOX01BQ19NR01UX0hFQURFUl9MRU4sIHNpemVvZihBQ1RJT05fT1BfTU9ERV9OT1RJRklDQVRJT05fRlJBTUUpLCBOVUxMLCBNU0RVX1JBVEVfTU9ERV9BVVRPKTsKCgkvKiA0IEVucXVldWUgdGhlIGZyYW1lIHRvIHNlbmQgdGhpcyBhY3Rpb24gZnJhbWUuICovCgluaWNUeEVucXVldWVNc2R1KHByQWRhcHRlciwgcHJNc2R1SW5mbyk7Cgp9CgovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwovKiEKKiBcYnJpZWYgU2VuZCBTTSBQb3dlciBTYXZlIGZyYW1lIChIVCBhY3Rpb24gZnJhbWUpCioKKiBccGFyYW1baW5dCioKKiBccmV0dXJuIG5vbmUKKi8KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KVk9JRCBybG1TZW5kU21Qb3dlclNhdmVGcmFtZShQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfU1RBX1JFQ09SRF9UIHByU3RhUmVjLCBVSU5UXzggdWNOc3MpCnsKCVBfTVNEVV9JTkZPX1QgcHJNc2R1SW5mbzsKCVBfQUNUSU9OX1NNX1BPV0VSX1NBVkVfRlJBTUUgcHJUeEZyYW1lOwoJUF9CU1NfSU5GT19UIHByQnNzSW5mbzsKCVVJTlRfMTYgdTJFc3RpbWF0ZWRGcmFtZUxlbjsKCS8qIFBGTl9UWF9ET05FX0hBTkRMRVIgcGZUeERvbmVIYW5kbGVyID0gKFBGTl9UWF9ET05FX0hBTkRMRVIpIE5VTEw7ICovCgoJLyogU2FuaXR5IENoZWNrICovCglpZiAoIXByU3RhUmVjKQoJCXJldHVybjsKCglwckJzc0luZm8gPSBHRVRfQlNTX0lORk9fQllfSU5ERVgocHJBZGFwdGVyLCBwclN0YVJlYy0+dWNCc3NJbmRleCk7CglpZiAoIXByQnNzSW5mbykKCQlyZXR1cm47CgoJLyogQ2FsY3VsYXRlIE1TRFUgYnVmZmVyIGxlbmd0aCAqLwoJdTJFc3RpbWF0ZWRGcmFtZUxlbiA9IE1BQ19UWF9SRVNFUlZFRF9GSUVMRCArIHNpemVvZihBQ1RJT05fU01fUE9XRVJfU0FWRV9GUkFNRSk7CgoJLyogQWxsb2MgTVNEVV9JTkZPICovCglwck1zZHVJbmZvID0gKFBfTVNEVV9JTkZPX1QpIGNubU1ndFBrdEFsbG9jKHByQWRhcHRlciwgdTJFc3RpbWF0ZWRGcmFtZUxlbik7CgoJaWYgKCFwck1zZHVJbmZvKQoJCXJldHVybjsKCglrYWxNZW1aZXJvKHByTXNkdUluZm8tPnByUGFja2V0LCB1MkVzdGltYXRlZEZyYW1lTGVuKTsKCglwclR4RnJhbWUgPSBwck1zZHVJbmZvLT5wclBhY2tldDsKCgkvKiBGaWxsIGZyYW1lIGN0cmwgKi8KCXByVHhGcmFtZS0+dTJGcmFtZUN0cmwgPSBNQUNfRlJBTUVfQUNUSU9OOwoKCUNPUFlfTUFDX0FERFIocHJUeEZyYW1lLT5hdWNEZXN0QWRkciwgcHJTdGFSZWMtPmF1Y01hY0FkZHIpOwoJQ09QWV9NQUNfQUREUihwclR4RnJhbWUtPmF1Y1NyY0FkZHIsIHByQnNzSW5mby0+YXVjT3duTWFjQWRkcik7CglDT1BZX01BQ19BRERSKHByVHhGcmFtZS0+YXVjQlNTSUQsIHByQnNzSW5mby0+YXVjQlNTSUQpOwoKCS8qIDMgQ29tcG9zZSB0aGUgZnJhbWUgYm9keSdzIGZyYW1lICovCglwclR4RnJhbWUtPnVjQ2F0ZWdvcnkgPSBDQVRFR09SWV9IVF9BQ1RJT047CglwclR4RnJhbWUtPnVjQWN0aW9uID0gQUNUSU9OX0hUX1NNX1BPV0VSX1NBVkU7CgoJaWYgKHVjTnNzID09IDEpCgkJcHJUeEZyYW1lLT51Y1NtUG93ZXJDdHJsIHw9IEhUX1NNX1BPV0VSX1NBVkVfQ09OVFJPTF9FTkFCTEVEOwoJZWxzZSBpZiAodWNOc3MgPT0gMikKCQlwclR4RnJhbWUtPnVjU21Qb3dlckN0cmwgJj0gfkhUX1NNX1BPV0VSX1NBVkVfQ09OVFJPTF9FTkFCTEVEOwoJZWxzZSB7CgkJREJHTE9HKFJMTSwgV0FSTiwgIkNhbid0IHN3aXRjaCB0byBOc3MgPSAlZCBzaW5jZSB3ZSBkb24ndCBzdXBwb3J0LlxuIiwgdWNOc3MpOwoJCXJldHVybjsKCX0KCglwclR4RnJhbWUtPnVjU21Qb3dlckN0cmwgJj0gKH5IVF9TTV9QT1dFUl9TQVZFX0NPTlRST0xfU01fTU9ERSk7IC8qIFN0YXRpYyBTTSBwb3dlciBzYXZlIG1vZGUgKi8KCgkvKiA0IFVwZGF0ZSBpbmZvcm1hdGlvbiBvZiBNU0RVX0lORk9fVCAqLwoJVFhfU0VUX01NUERVKHByQWRhcHRlciwKCQkgICAgIHByTXNkdUluZm8sCgkJICAgICBwckJzc0luZm8tPnVjQnNzSW5kZXgsCgkJICAgICBwclN0YVJlYy0+dWNJbmRleCwKCQkgICAgIFdMQU5fTUFDX01HTVRfSEVBREVSX0xFTiwgc2l6ZW9mKEFDVElPTl9TTV9QT1dFUl9TQVZFX0ZSQU1FKSwgTlVMTCwgTVNEVV9SQVRFX01PREVfQVVUTyk7CgoJLyogNCBFbnF1ZXVlIHRoZSBmcmFtZSB0byBzZW5kIHRoaXMgYWN0aW9uIGZyYW1lLiAqLwoJbmljVHhFbnF1ZXVlTXNkdShwckFkYXB0ZXIsIHByTXNkdUluZm8pOwoKfQoKCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCi8qIQoqIFxicmllZiBTZW5kIE5vdGlmeSBDaGFubmVsIFdpZHRoIGZyYW1lIChIVCBhY3Rpb24gZnJhbWUpCioKKiBccGFyYW1baW5dIHVjQ2hhbm5lbFdpZHRoIDA6MjBNSHosIDE6QW55IGNoYW5uZWwgd2lkdGggaW4gdGhlIFNUQaGmcyBTdXBwb3J0ZWQgQ2hhbm5lbCBXaWR0aCBTZXQgc3ViZmllbGQKKgoqIFxyZXR1cm4gbm9uZQoqLwovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLwpWT0lEIHJsbVNlbmROb3RpZnlDaGFubmVsV2lkdGhGcmFtZShQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFBfU1RBX1JFQ09SRF9UIHByU3RhUmVjLCBVSU5UXzggdWNDaGFubmVsV2lkdGgpCnsKCVBfTVNEVV9JTkZPX1QgcHJNc2R1SW5mbzsKCVBfQUNUSU9OX05PVElGWV9DSEFOTkVMX1dJRFRIX0ZSQU1FIHByVHhGcmFtZTsKCVBfQlNTX0lORk9fVCBwckJzc0luZm87CglVSU5UXzE2IHUyRXN0aW1hdGVkRnJhbWVMZW47CgkvKiBQRk5fVFhfRE9ORV9IQU5ETEVSIHBmVHhEb25lSGFuZGxlciA9IChQRk5fVFhfRE9ORV9IQU5ETEVSKSBOVUxMOyAqLwoKCS8qIFNhbml0eSBDaGVjayAqLwoJaWYgKCFwclN0YVJlYykKCQlyZXR1cm47CgoJcHJCc3NJbmZvID0gR0VUX0JTU19JTkZPX0JZX0lOREVYKHByQWRhcHRlciwgcHJTdGFSZWMtPnVjQnNzSW5kZXgpOwoJaWYgKCFwckJzc0luZm8pCgkJcmV0dXJuOwoKCS8qIENhbGN1bGF0ZSBNU0RVIGJ1ZmZlciBsZW5ndGggKi8KCXUyRXN0aW1hdGVkRnJhbWVMZW4gPSBNQUNfVFhfUkVTRVJWRURfRklFTEQgKyBzaXplb2YoQUNUSU9OX05PVElGWV9DSEFOTkVMX1dJRFRIX0ZSQU1FKTsKCgkvKiBBbGxvYyBNU0RVX0lORk8gKi8KCXByTXNkdUluZm8gPSAoUF9NU0RVX0lORk9fVCkgY25tTWd0UGt0QWxsb2MocHJBZGFwdGVyLCB1MkVzdGltYXRlZEZyYW1lTGVuKTsKCglpZiAoIXByTXNkdUluZm8pCgkJcmV0dXJuOwoKCWthbE1lbVplcm8ocHJNc2R1SW5mby0+cHJQYWNrZXQsIHUyRXN0aW1hdGVkRnJhbWVMZW4pOwoKCXByVHhGcmFtZSA9IHByTXNkdUluZm8tPnByUGFja2V0OwoKCS8qIEZpbGwgZnJhbWUgY3RybCAqLwoJcHJUeEZyYW1lLT51MkZyYW1lQ3RybCA9IE1BQ19GUkFNRV9BQ1RJT047CgoJQ09QWV9NQUNfQUREUihwclR4RnJhbWUtPmF1Y0Rlc3RBZGRyLCBwclN0YVJlYy0+YXVjTWFjQWRkcik7CglDT1BZX01BQ19BRERSKHByVHhGcmFtZS0+YXVjU3JjQWRkciwgcHJCc3NJbmZvLT5hdWNPd25NYWNBZGRyKTsKCUNPUFlfTUFDX0FERFIocHJUeEZyYW1lLT5hdWNCU1NJRCwgcHJCc3NJbmZvLT5hdWNCU1NJRCk7CgoJLyogMyBDb21wb3NlIHRoZSBmcmFtZSBib2R5J3MgZnJhbWUgKi8KCXByVHhGcmFtZS0+dWNDYXRlZ29yeSA9IENBVEVHT1JZX0hUX0FDVElPTjsKCXByVHhGcmFtZS0+dWNBY3Rpb24gPSBBQ1RJT05fSFRfTk9USUZZX0NIQU5ORUxfV0lEVEg7CgoJcHJUeEZyYW1lLT51Y0NoYW5uZWxXaWR0aCA9IHVjQ2hhbm5lbFdpZHRoOwoKCS8qIDQgVXBkYXRlIGluZm9ybWF0aW9uIG9mIE1TRFVfSU5GT19UICovCglUWF9TRVRfTU1QRFUocHJBZGFwdGVyLAoJCSAgICAgcHJNc2R1SW5mbywKCQkgICAgIHByQnNzSW5mby0+dWNCc3NJbmRleCwKCQkgICAgIHByU3RhUmVjLT51Y0luZGV4LAoJCSAgICAgV0xBTl9NQUNfTUdNVF9IRUFERVJfTEVOLCBzaXplb2YoQUNUSU9OX05PVElGWV9DSEFOTkVMX1dJRFRIX0ZSQU1FKSwgTlVMTCwgTVNEVV9SQVRFX01PREVfQVVUTyk7CgoJLyogNCBFbnF1ZXVlIHRoZSBmcmFtZSB0byBzZW5kIHRoaXMgYWN0aW9uIGZyYW1lLiAqLwoJbmljVHhFbnF1ZXVlTXNkdShwckFkYXB0ZXIsIHByTXNkdUluZm8pOwoKfQoKLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8KLyohCiogXGJyaWVmIENoYW5nZSBPcE1vZGUgTnNzL0NoYW5uZWwgV2lkdGgKKgoqIFxwYXJhbVtpbl0gdWNDaGFubmVsV2lkdGggMDoyME1IeiwgMTo0ME1IeiwgMjo4ME1IeiwgMzoxNjBNSHogNDo4MCs4ME1IegoqCiogXHJldHVybiBub25lCiovCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovCkJPT0xFQU4gcmxtQ2hhbmdlT3BlcmF0aW9uTW9kZShQX0FEQVBURVJfVCBwckFkYXB0ZXIsIFVJTlRfOCB1Y0Jzc0luZGV4LCBVSU5UXzggdWNDaGFubmVsV2lkdGgsIFVJTlRfOCB1Y05zcykKewoJUF9CU1NfSU5GT19UIHByQnNzSW5mbzsKCVBfU1RBX1JFQ09SRF9UIHByU3RhUmVjID0gKFBfU1RBX1JFQ09SRF9UKSBOVUxMOwoJLypCT09MRUFOIGZnSXNTdWNjZXNzID0gRkFMU0U7Ki8KCUJPT0xFQU4gZmdJc0NoYW5nZVZodEJ3ID0gVFJVRSwgZmdJc0NoYW5nZUh0QncgPSBUUlVFOwoKCXByQnNzSW5mbyA9IEdFVF9CU1NfSU5GT19CWV9JTkRFWChwckFkYXB0ZXIsIHVjQnNzSW5kZXgpOwoKCS8qIE5vIG5lZWQgdG8gY2hhbmdlIEJTUyA0IHJsbSBwYXJhbWV0ZXIgKi8KCWlmICh1Y0Jzc0luZGV4ID49IEhXX0JTU0lEX05VTSkKCQlyZXR1cm4gRkFMU0U7CgoJaWYgKCFwckJzc0luZm8pCgkJcmV0dXJuIEZBTFNFOwoKCURCR0xPRyhSTE0sIElORk8sICJJbnRlbmQgdG8gY2hhbmdlIEJTU1slZF0gT1AgTW9kZSB0byBCV1slZF0gTnNzWyVkXVxuIiwgdWNCc3NJbmRleCwgdWNDaGFubmVsV2lkdGgsIHVjTnNzKTsKCiNpZiBDRkdfU1VQUE9SVF84MDJfMTFBQwoJLyogQ2hlY2sgcGVlciBWSFQvSFQgT1AgQ2hhbm5lbCBXaWR0aCAqLwoJaWYgKHVjQ2hhbm5lbFdpZHRoID09IHByQnNzSW5mby0+dWNPcENoYW5nZUNoYW5uZWxXaWR0aCkKCQlmZ0lzQ2hhbmdlVmh0QncgPSBGQUxTRTsKCWVsc2UgaWYgKHByQnNzSW5mby0+ZUN1cnJlbnRPUE1vZGUgPT0gT1BfTU9ERV9JTkZSQVNUUlVDVFVSRSkgewoJCXN3aXRjaCAodWNDaGFubmVsV2lkdGgpIHsKCQljYXNlIE1BWF9CV184MF84MF9NSFo6CgkJCWlmIChwckJzc0luZm8tPnVjVmh0UGVlckNoYW5uZWxXaWR0aCAhPSBWSFRfT1BfQ0hBTk5FTF9XSURUSF84MFA4MCkgewoJCQkJREJHTE9HKFJMTSwgSU5GTywKCQkJCSJDYW4ndCBjaGFuZ2UgdG8gQlc4MF84MCBkdWUgdG8gcGVlciBWSFQgT1AgQlcgaXMgQldbJWRdXG4iCgkJCQksIHByQnNzSW5mby0+dWNWaHRQZWVyQ2hhbm5lbFdpZHRoKTsKCQkJCWZnSXNDaGFuZ2VWaHRCdyA9IEZBTFNFOwoJCQl9CgkJCWJyZWFrOwoJCWNhc2UgTUFYX0JXXzE2ME1IWjoKCQkJaWYgKHByQnNzSW5mby0+dWNWaHRQZWVyQ2hhbm5lbFdpZHRoICE9IFZIVF9PUF9DSEFOTkVMX1dJRFRIXzE2MCkgewoJCQkJREJHTE9HKFJMTSwgSU5GTywKCQkJCQkiQ2FuJ3QgY2hhbmdlIHRvIEJXMTYwIGR1ZSB0byBwZWVyIFZIVCBPUCBCVyBpcyBCV1slZF1cbiIsCgkJCQkJcHJCc3NJbmZvLT51Y1ZodFBlZXJDaGFubmVsV2lkdGgpOwoJCQkJZmdJc0NoYW5nZVZodEJ3ID0gRkFMU0U7CgkJCX0KCQkJYnJlYWs7CgkJY2FzZSBNQVhfQldfODBNSFo6CgkJCWlmIChwckJzc0luZm8tPnVjVmh0UGVlckNoYW5uZWxXaWR0aCA8IFZIVF9PUF9DSEFOTkVMX1dJRFRIXzgwKSB7CgkJCQlEQkdMT0coUkxNLCBJTkZPLAoJCQkJCSJDYW4ndCBjaGFuZ2UgdG8gQlc4MCBkdWUgdG8gcGVlciBWSFQgT1AgQlcgaXMgQldbJWRdXG4iLAoJCQkJCXByQnNzSW5mby0+dWNWaHRQZWVyQ2hhbm5lbFdpZHRoKTsKCQkJCWZnSXNDaGFuZ2VWaHRCdyA9IEZBTFNFOwoJCQl9CgkJCWJyZWFrOwoJCWNhc2UgTUFYX0JXXzQwTUhaOgoJCQlpZiAoIShwckJzc0luZm8tPnVjSHRQZWVyT3BJbmZvMSAmIEhUX09QX0lORk8xX1NUQV9DSE5MX1dJRFRIKSB8fAoJCQkJKCFwckJzc0luZm8tPmZnNDBtQndBbGxvd2VkKSkgewoJCQkJREJHTE9HKFJMTSwgSU5GTywKCQkJCSJDYW4ndCBjaGFuZ2UgdG8gQlc0MDogUGVlck9wQndbJWRdIGZnNDBtQndBbGxvd2VkWyVkXVxuIiwKCQkJCShwckJzc0luZm8tPnVjSHRQZWVyT3BJbmZvMSAmIEhUX09QX0lORk8xX1NUQV9DSE5MX1dJRFRIKSwKCQkJCXByQnNzSW5mby0+Zmc0MG1Cd0FsbG93ZWQpOwoJCQkJZmdJc0NoYW5nZVZodEJ3ID0gRkFMU0U7CgkJCX0KCQkJYnJlYWs7CgkJY2FzZSBNQVhfQldfMjBNSFo6CgkJCWJyZWFrOwoJCWRlZmF1bHQ6CgkJCURCR0xPRyhSTE0sIFdBUk4sICJCV1slZF0gaXMgaW52YWxpZCBmb3IgT3BNb2RlIGNoYW5nZVxuIiwgdWNDaGFubmVsV2lkdGgpOwoJCQlmZ0lzQ2hhbmdlVmh0QncgPSBGQUxTRTsKCQl9Cgl9CiNlbmRpZgoKCS8qIENoZWNrIEhUIE9QIENoYW5uZWwgV2lkdGggKi8KCWlmICh1Y0NoYW5uZWxXaWR0aCA9PSBwckJzc0luZm8tPnVjT3BDaGFuZ2VDaGFubmVsV2lkdGgpCgkJZmdJc0NoYW5nZUh0QncgPSBGQUxTRTsKCWVsc2UgaWYgKHVjQ2hhbm5lbFdpZHRoID49IE1BWF9CV184ME1IWikgewoJCURCR0xPRyhSTE0sIFdBUk4sICJCV1slZF0gaXMgaW52YWxpZCBmb3IgSFQgT3BNb2RlIGNoYW5nZVxuIiwgdWNDaGFubmVsV2lkdGgpOwoJCWZnSXNDaGFuZ2VIdEJ3ID0gRkFMU0U7Cgl9IGVsc2UgaWYgKHVjQ2hhbm5lbFdpZHRoID09IE1BWF9CV180ME1IWikgewoJCWlmICghKHByQnNzSW5mby0+dWNIdFBlZXJPcEluZm8xICYgSFRfT1BfSU5GTzFfU1RBX0NITkxfV0lEVEgpIHx8CgkJCSghcHJCc3NJbmZvLT5mZzQwbUJ3QWxsb3dlZCkpIHsKCQkJREJHTE9HKFJMTSwgSU5GTywKCQkJCSJDYW4ndCBjaGFuZ2UgdG8gQlc0MDogUGVlck9wQndbJWRdIGZnNDBtQndBbGxvd2VkWyVkXVxuIiwKCQkJCShwckJzc0luZm8tPnVjSHRQZWVyT3BJbmZvMSAmIEhUX09QX0lORk8xX1NUQV9DSE5MX1dJRFRIKSwKCQkJCXByQnNzSW5mby0+Zmc0MG1Cd0FsbG93ZWQpOwoJCQlmZ0lzQ2hhbmdlSHRCdyA9IEZBTFNFOwoJCX0KCX0KCglpZiAoZmdJc0NoYW5nZUh0QncpIHsKCQkvKiA8ND5VcGRhdGUgSFQgQ2hhbm5lbCBXaWR0aCAqLwoJCWlmICh1Y0NoYW5uZWxXaWR0aCA9PSBNQVhfQldfMjBNSFopIHsKCQkJcHJCc3NJbmZvLT51Y0h0T3BJbmZvMSAmPSB+SFRfT1BfSU5GTzFfU1RBX0NITkxfV0lEVEg7CgkJCXByQnNzSW5mby0+ZUJzc1NDTyA9IENITkxfRVhUX1NDTjsKCQl9IGVsc2UgaWYgKHVjQ2hhbm5lbFdpZHRoID09IE1BWF9CV180ME1IWikgewoJCQlwckJzc0luZm8tPnVjSHRPcEluZm8xIHw9IEhUX09QX0lORk8xX1NUQV9DSE5MX1dJRFRIOwoJCQlpZiAoKHByQnNzSW5mby0+dWNIdFBlZXJPcEluZm8xICYgSFRfT1BfSU5GTzFfU0NPKSAhPSBDSE5MX0VYVF9SRVMpCgkJCQlwckJzc0luZm8tPmVCc3NTQ08gPQoJCQkJKEVOVU1fQ0hOTF9FWFRfVCkgKHByQnNzSW5mby0+dWNIdFBlZXJPcEluZm8xICYgSFRfT1BfSU5GTzFfU0NPKTsKCQl9IGVsc2UKCQkJZmdJc0NoYW5nZUh0QncgPSBGQUxTRTsKCX0KCiNpZiBDRkdfU1VQUE9SVF84MDJfMTFBQwoJaWYgKGZnSXNDaGFuZ2VWaHRCdykgewoJCXByQnNzSW5mby0+dWNPcENoYW5nZUNoYW5uZWxXaWR0aCA9IHVjQ2hhbm5lbFdpZHRoOwoJCXByQnNzSW5mby0+ZmdJc09wQ2hhbmdlQ2hhbm5lbFdpZHRoID0gVFJVRTsKCQkvKiA8Mz5VcGRhdGUgVkhUIENoYW5uZWwgV2lkdGgqLwoJCXJsbUNoYW5nZVZodE9wQndQYXJhKHByQWRhcHRlciwgdWNCc3NJbmRleCwgcHJCc3NJbmZvLT51Y09wQ2hhbmdlQ2hhbm5lbFdpZHRoKTsKCgkJREJHTE9HKFJMTSwgSU5GTywgIlVwZGF0ZSBWSFQgQ2hhbm5lbCBXaWR0aCBJbmZvIHRvIHc9JWQgczE9JWQgczI9JWRcbiIsCgkJCQlwckJzc0luZm8tPnVjVmh0Q2hhbm5lbFdpZHRoLAoJCQkJcHJCc3NJbmZvLT51Y1ZodENoYW5uZWxGcmVxdWVuY3lTMSwKCQkJCXByQnNzSW5mby0+dWNWaHRDaGFubmVsRnJlcXVlbmN5UzIpOwoJfQojZW5kaWYKCWlmIChmZ0lzQ2hhbmdlSHRCdykgewoJCXByQnNzSW5mby0+dWNPcENoYW5nZUNoYW5uZWxXaWR0aCA9IHVjQ2hhbm5lbFdpZHRoOwoJCXByQnNzSW5mby0+ZmdJc09wQ2hhbmdlQ2hhbm5lbFdpZHRoID0gVFJVRTsKCgkJREJHTE9HKFJMTSwgSU5GTywgIlVwZGF0ZSBIVCBDaGFubmVsIFdpZHRoIEluZm8gdG8gYnc9JWQgcz0lZFxuIiwKCQkJKHByQnNzSW5mby0+dWNIdE9wSW5mbzEgJiBIVF9PUF9JTkZPMV9TVEFfQ0hOTF9XSURUSCkgPj4gMiwgcHJCc3NJbmZvLT5lQnNzU0NPKTsKCX0KCglpZiAoKHByQnNzSW5mby0+dWNOc3MgIT0gdWNOc3MpIHx8IGZnSXNDaGFuZ2VWaHRCdyB8fCBmZ0lzQ2hhbmdlSHRCdykgewoJCS8qIDEuIFVwZGF0ZSBCU1MgSW5mbyAqLwoJCXByQnNzSW5mby0+dWNOc3MgPSB1Y05zczsKCQlybG1TeW5jT3BlcmF0aW9uUGFyYW1zKHByQWRhcHRlciwgcHJCc3NJbmZvKTsKCgkJaWYgKHByQnNzSW5mby0+ZUN1cnJlbnRPUE1vZGUgPT0gT1BfTU9ERV9JTkZSQVNUUlVDVFVSRSkgeyAvKiBGb3IgaW5mcmFzdHJ1Y3R1cmUsIEdDICovCgkJCWlmIChwckJzc0luZm8tPnByU3RhUmVjT2ZBUCkgewoJCQkJcHJTdGFSZWMgPSBwckJzc0luZm8tPnByU3RhUmVjT2ZBUDsKI2lmIENGR19TVVBQT1JUXzgwMl8xMUFDCgkJCQkvKiAyLiBDaGVjayBpZiB3ZSBjYW4gY2hhbmdlIE9wTW9kZSBhbmQgU2VuZCBPUG1vZGUgbm90aWZpY2F0aW9uIGZyYW1lICovCgkJCQlpZiAocHJTdGFSZWMtPnVjRGVzaXJlZFBoeVR5cGVTZXQgJiBQSFlfVFlQRV9CSVRfVkhUKSB7IC8qU2VuZCBWSFQgbm90aWZpY2F0aW9uIGZyYW1lKi8KCQkJCQkvKiA8MT4gTm90aWZ5IFZIVCBOc3MgYW5kIENoYW5uZWwgV2lkdGggY2hhbmdlKi8KCQkJCQlybG1TZW5kT3BNb2RlTm90aWZpY2F0aW9uRnJhbWUocHJBZGFwdGVyLCBwclN0YVJlYywgdWNDaGFubmVsV2lkdGgsCgkJCQkJCXByQnNzSW5mby0+dWNOc3MpOwoJCQkJCURCR0xPRyhSTE0sIElORk8sICJTZW5kIFZIVCBPUG1vZGUgbm90aWZpY2F0aW9uIGZyYW1lLCBCVz0lZCwgTnNzPSVkXG4iCgkJCQkJCSwgdWNDaGFubmVsV2lkdGgsIHByQnNzSW5mby0+dWNOc3MpOwoJCQkJfSBlbHNlCiNlbmRpZgoJCQkJaWYgKHByU3RhUmVjLT51Y0Rlc2lyZWRQaHlUeXBlU2V0ICYgUEhZX1RZUEVfQklUX0hUKSB7IC8qU2VuZCBIVCBub3RpZmljYXRpb24gZnJhbWUqLwoJCQkJCS8qIDwxPiBOb3RpZnkgSFQgTnNzIGNoYW5nZSAqLwoJCQkJCXJsbVNlbmRTbVBvd2VyU2F2ZUZyYW1lKHByQWRhcHRlciwgcHJTdGFSZWMsIHByQnNzSW5mby0+dWNOc3MpOwoJCQkJCURCR0xPRyhSTE0sIElORk8sICJTZW5kIEhUIFNNIFBvd2VyIFNhdmUgZnJhbWUsIE5zcz0lZFxuIiwKCQkJCQkJcHJCc3NJbmZvLT51Y05zcyk7CgkJCQl9CgoJCQkJaWYgKGZnSXNDaGFuZ2VIdEJ3KSB7CgkJCQkJLyogPDM+IE5vdGlmeSBIVCBDaGFubmVsIFdpZHRoIGNoYW5nZSAqLwoJCQkJCXJsbVNlbmROb3RpZnlDaGFubmVsV2lkdGhGcmFtZShwckFkYXB0ZXIsIHByU3RhUmVjLCB1Y0NoYW5uZWxXaWR0aCk7CgkJCQkJREJHTE9HKFJMTSwgSU5GTywgIlNlbmQgSFQgTm90aWZ5IENoYW5uZWwgV2lkdGggZnJhbWUsIEJXPSVkXG4iLAoJCQkJCQl1Y0NoYW5uZWxXaWR0aCk7CgkJCQl9CgkJCX0gZWxzZQoJCQkJREJHTE9HKFJMTSwgV0FSTiwgIkNhbid0IGNoYW5nZSBPcE1vZGUgYXQgbGVnYWN5IG1vZGVcbiIpOwoJCX0gZWxzZSBpZiAocHJCc3NJbmZvLT5lQ3VycmVudE9QTW9kZSA9PSBPUF9NT0RFX0FDQ0VTU19QT0lOVCkgewoJCQlQX0xJTktfVCBwckNsaWVudExpc3Q7CgoJCQkvKiA0LiBVcGRhdGUgQkNOL1Byb2JlIFJlc3AgSUUgdG8gbm90aWZ5IHBlZXJzIHRoZSBPUCBpcyBiZSBjaGFuZ2VkICovCgkJCURCR0xPRyhSTE0sIElORk8sICJCZWFjb24gY29udGVudCB1cGRhdGUgd2l0aCBCc3NpZGV4KCVkKVxuIiwKCQkJCXByQnNzSW5mby0+dWNCc3NJbmRleCk7CgoJCQlwckNsaWVudExpc3QgPSAmcHJCc3NJbmZvLT5yU3RhUmVjT2ZDbGllbnRMaXN0OwoKCQkJTElOS19GT1JfRUFDSF9FTlRSWShwclN0YVJlYywgcHJDbGllbnRMaXN0LCByTGlua0VudHJ5LCBTVEFfUkVDT1JEX1QpIHsKI2lmIENGR19TVVBQT1JUXzgwMl8xMUFDCgkJCQkvKiAyLiBDaGVjayBpZiB3ZSBjYW4gY2hhbmdlIE9wTW9kZSBhbmQgU2VuZCBPUG1vZGUgbm90aWZpY2F0aW9uIGZyYW1lICovCgkJCQlpZiAocHJTdGFSZWMtPnVjRGVzaXJlZFBoeVR5cGVTZXQgJiBQSFlfVFlQRV9CSVRfVkhUKSB7IC8qU2VuZCBWSFQgbm90aWZpY2F0aW9uIGZyYW1lKi8KCQkJCQkvKiA8MT4gTm90aWZ5IFZIVCBOc3MgYW5kIENoYW5uZWwgV2lkdGggY2hhbmdlKi8KCQkJCQlybG1TZW5kT3BNb2RlTm90aWZpY2F0aW9uRnJhbWUocHJBZGFwdGVyLCBwclN0YVJlYywgdWNDaGFubmVsV2lkdGgsCgkJCQkJCXByQnNzSW5mby0+dWNOc3MpOwoJCQkJCURCR0xPRyhSTE0sIElORk8sICJTZW5kIFZIVCBPUG1vZGUgbm90aWZpY2F0aW9uIGZyYW1lLCBCVz0lZCwgTnNzPSVkXG4iCgkJCQkJCSwgdWNDaGFubmVsV2lkdGgsIHByQnNzSW5mby0+dWNOc3MpOwoJCQkJfSBlbHNlCiNlbmRpZgoJCQkJaWYgKHByU3RhUmVjLT51Y0Rlc2lyZWRQaHlUeXBlU2V0ICYgUEhZX1RZUEVfQklUX0hUKSB7IC8qU2VuZCBIVCBub3RpZmljYXRpb24gZnJhbWUqLwoJCQkJCS8qIDwxPiBOb3RpZnkgSFQgTnNzIGNoYW5nZSAqLwoJCQkJCXJsbVNlbmRTbVBvd2VyU2F2ZUZyYW1lKHByQWRhcHRlciwgcHJTdGFSZWMsIHByQnNzSW5mby0+dWNOc3MpOwoJCQkJCURCR0xPRyhSTE0sIElORk8sICJTZW5kIEhUIFNNIFBvd2VyIFNhdmUgZnJhbWUsIE5zcz0lZFxuIiwKCQkJCQkJcHJCc3NJbmZvLT51Y05zcyk7CgkJCQl9CgoJCQkJaWYgKGZnSXNDaGFuZ2VIdEJ3KSB7CgkJCQkJLyogPDM+IE5vdGlmeSBIVCBDaGFubmVsIFdpZHRoIGNoYW5nZSAqLwoJCQkJCXJsbVNlbmROb3RpZnlDaGFubmVsV2lkdGhGcmFtZShwckFkYXB0ZXIsIHByU3RhUmVjLCB1Y0NoYW5uZWxXaWR0aCk7CgkJCQkJREJHTE9HKFJMTSwgSU5GTywgIlNlbmQgSFQgTm90aWZ5IENoYW5uZWwgV2lkdGggZnJhbWUsIEJXPSVkXG4iLAoJCQkJCQl1Y0NoYW5uZWxXaWR0aCk7CgkJCQl9CgkJCX0KCgkJCWJzc1VwZGF0ZUJlYWNvbkNvbnRlbnQocHJBZGFwdGVyLCBwckJzc0luZm8tPnVjQnNzSW5kZXgpOwoJCX0gZWxzZQoJCQlyZXR1cm4gRkFMU0U7Cgl9CglyZXR1cm4gVFJVRTsKfQo=