Ci8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tClNvZnR3YXJlIExpY2Vuc2UgZm9yIFRoZSBGcmF1bmhvZmVyIEZESyBBQUMgQ29kZWMgTGlicmFyeSBmb3IgQW5kcm9pZAoKqSBDb3B5cmlnaHQgIDE5OTUgLSAyMDEyIEZyYXVuaG9mZXItR2VzZWxsc2NoYWZ0IHp1ciBG9nJkZXJ1bmcgZGVyIGFuZ2V3YW5kdGVuIEZvcnNjaHVuZyBlLlYuCiAgQWxsIHJpZ2h0cyByZXNlcnZlZC4KCiAxLiAgICBJTlRST0RVQ1RJT04KVGhlIEZyYXVuaG9mZXIgRkRLIEFBQyBDb2RlYyBMaWJyYXJ5IGZvciBBbmRyb2lkICgiRkRLIEFBQyBDb2RlYyIpIGlzIHNvZnR3YXJlIHRoYXQgaW1wbGVtZW50cwp0aGUgTVBFRyBBZHZhbmNlZCBBdWRpbyBDb2RpbmcgKCJBQUMiKSBlbmNvZGluZyBhbmQgZGVjb2Rpbmcgc2NoZW1lIGZvciBkaWdpdGFsIGF1ZGlvLgpUaGlzIEZESyBBQUMgQ29kZWMgc29mdHdhcmUgaXMgaW50ZW5kZWQgdG8gYmUgdXNlZCBvbiBhIHdpZGUgdmFyaWV0eSBvZiBBbmRyb2lkIGRldmljZXMuCgpBQUMncyBIRS1BQUMgYW5kIEhFLUFBQyB2MiB2ZXJzaW9ucyBhcmUgcmVnYXJkZWQgYXMgdG9kYXkncyBtb3N0IGVmZmljaWVudCBnZW5lcmFsIHBlcmNlcHR1YWwKYXVkaW8gY29kZWNzLiBBQUMtRUxEIGlzIGNvbnNpZGVyZWQgdGhlIGJlc3QtcGVyZm9ybWluZyBmdWxsLWJhbmR3aWR0aCBjb21tdW5pY2F0aW9ucyBjb2RlYyBieQppbmRlcGVuZGVudCBzdHVkaWVzIGFuZCBpcyB3aWRlbHkgZGVwbG95ZWQuIEFBQyBoYXMgYmVlbiBzdGFuZGFyZGl6ZWQgYnkgSVNPIGFuZCBJRUMgYXMgcGFydApvZiB0aGUgTVBFRyBzcGVjaWZpY2F0aW9ucy4KClBhdGVudCBsaWNlbnNlcyBmb3IgbmVjZXNzYXJ5IHBhdGVudCBjbGFpbXMgZm9yIHRoZSBGREsgQUFDIENvZGVjIChpbmNsdWRpbmcgdGhvc2Ugb2YgRnJhdW5ob2ZlcikKbWF5IGJlIG9idGFpbmVkIHRocm91Z2ggVmlhIExpY2Vuc2luZyAod3d3LnZpYWxpY2Vuc2luZy5jb20pIG9yIHRocm91Z2ggdGhlIHJlc3BlY3RpdmUgcGF0ZW50IG93bmVycwppbmRpdmlkdWFsbHkgZm9yIHRoZSBwdXJwb3NlIG9mIGVuY29kaW5nIG9yIGRlY29kaW5nIGJpdCBzdHJlYW1zIGluIHByb2R1Y3RzIHRoYXQgYXJlIGNvbXBsaWFudCB3aXRoCnRoZSBJU08vSUVDIE1QRUcgYXVkaW8gc3RhbmRhcmRzLiBQbGVhc2Ugbm90ZSB0aGF0IG1vc3QgbWFudWZhY3R1cmVycyBvZiBBbmRyb2lkIGRldmljZXMgYWxyZWFkeSBsaWNlbnNlCnRoZXNlIHBhdGVudCBjbGFpbXMgdGhyb3VnaCBWaWEgTGljZW5zaW5nIG9yIGRpcmVjdGx5IGZyb20gdGhlIHBhdGVudCBvd25lcnMsIGFuZCB0aGVyZWZvcmUgRkRLIEFBQyBDb2RlYwpzb2Z0d2FyZSBtYXkgYWxyZWFkeSBiZSBjb3ZlcmVkIHVuZGVyIHRob3NlIHBhdGVudCBsaWNlbnNlcyB3aGVuIGl0IGlzIHVzZWQgZm9yIHRob3NlIGxpY2Vuc2VkIHB1cnBvc2VzIG9ubHkuCgpDb21tZXJjaWFsbHktbGljZW5zZWQgQUFDIHNvZnR3YXJlIGxpYnJhcmllcywgaW5jbHVkaW5nIGZsb2F0aW5nLXBvaW50IHZlcnNpb25zIHdpdGggZW5oYW5jZWQgc291bmQgcXVhbGl0eSwKYXJlIGFsc28gYXZhaWxhYmxlIGZyb20gRnJhdW5ob2Zlci4gVXNlcnMgYXJlIGVuY291cmFnZWQgdG8gY2hlY2sgdGhlIEZyYXVuaG9mZXIgd2Vic2l0ZSBmb3IgYWRkaXRpb25hbAphcHBsaWNhdGlvbnMgaW5mb3JtYXRpb24gYW5kIGRvY3VtZW50YXRpb24uCgoyLiAgICBDT1BZUklHSFQgTElDRU5TRQoKUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCB3aXRob3V0CnBheW1lbnQgb2YgY29weXJpZ2h0IGxpY2Vuc2UgZmVlcyBwcm92aWRlZCB0aGF0IHlvdSBzYXRpc2Z5IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9uczoKCllvdSBtdXN0IHJldGFpbiB0aGUgY29tcGxldGUgdGV4dCBvZiB0aGlzIHNvZnR3YXJlIGxpY2Vuc2UgaW4gcmVkaXN0cmlidXRpb25zIG9mIHRoZSBGREsgQUFDIENvZGVjIG9yCnlvdXIgbW9kaWZpY2F0aW9ucyB0aGVyZXRvIGluIHNvdXJjZSBjb2RlIGZvcm0uCgpZb3UgbXVzdCByZXRhaW4gdGhlIGNvbXBsZXRlIHRleHQgb2YgdGhpcyBzb2Z0d2FyZSBsaWNlbnNlIGluIHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMKcHJvdmlkZWQgd2l0aCByZWRpc3RyaWJ1dGlvbnMgb2YgdGhlIEZESyBBQUMgQ29kZWMgb3IgeW91ciBtb2RpZmljYXRpb25zIHRoZXJldG8gaW4gYmluYXJ5IGZvcm0uCllvdSBtdXN0IG1ha2UgYXZhaWxhYmxlIGZyZWUgb2YgY2hhcmdlIGNvcGllcyBvZiB0aGUgY29tcGxldGUgc291cmNlIGNvZGUgb2YgdGhlIEZESyBBQUMgQ29kZWMgYW5kIHlvdXIKbW9kaWZpY2F0aW9ucyB0aGVyZXRvIHRvIHJlY2lwaWVudHMgb2YgY29waWVzIGluIGJpbmFyeSBmb3JtLgoKVGhlIG5hbWUgb2YgRnJhdW5ob2ZlciBtYXkgbm90IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbSB0aGlzIGxpYnJhcnkgd2l0aG91dApwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCgpZb3UgbWF5IG5vdCBjaGFyZ2UgY29weXJpZ2h0IGxpY2Vuc2UgZmVlcyBmb3IgYW55b25lIHRvIHVzZSwgY29weSBvciBkaXN0cmlidXRlIHRoZSBGREsgQUFDIENvZGVjCnNvZnR3YXJlIG9yIHlvdXIgbW9kaWZpY2F0aW9ucyB0aGVyZXRvLgoKWW91ciBtb2RpZmllZCB2ZXJzaW9ucyBvZiB0aGUgRkRLIEFBQyBDb2RlYyBtdXN0IGNhcnJ5IHByb21pbmVudCBub3RpY2VzIHN0YXRpbmcgdGhhdCB5b3UgY2hhbmdlZCB0aGUgc29mdHdhcmUKYW5kIHRoZSBkYXRlIG9mIGFueSBjaGFuZ2UuIEZvciBtb2RpZmllZCB2ZXJzaW9ucyBvZiB0aGUgRkRLIEFBQyBDb2RlYywgdGhlIHRlcm0KIkZyYXVuaG9mZXIgRkRLIEFBQyBDb2RlYyBMaWJyYXJ5IGZvciBBbmRyb2lkIiBtdXN0IGJlIHJlcGxhY2VkIGJ5IHRoZSB0ZXJtCiJUaGlyZC1QYXJ0eSBNb2RpZmllZCBWZXJzaW9uIG9mIHRoZSBGcmF1bmhvZmVyIEZESyBBQUMgQ29kZWMgTGlicmFyeSBmb3IgQW5kcm9pZC4iCgozLiAgICBOTyBQQVRFTlQgTElDRU5TRQoKTk8gRVhQUkVTUyBPUiBJTVBMSUVEIExJQ0VOU0VTIFRPIEFOWSBQQVRFTlQgQ0xBSU1TLCBpbmNsdWRpbmcgd2l0aG91dCBsaW1pdGF0aW9uIHRoZSBwYXRlbnRzIG9mIEZyYXVuaG9mZXIsCkFSRSBHUkFOVEVEIEJZIFRISVMgU09GVFdBUkUgTElDRU5TRS4gRnJhdW5ob2ZlciBwcm92aWRlcyBubyB3YXJyYW50eSBvZiBwYXRlbnQgbm9uLWluZnJpbmdlbWVudCB3aXRoCnJlc3BlY3QgdG8gdGhpcyBzb2Z0d2FyZS4KCllvdSBtYXkgdXNlIHRoaXMgRkRLIEFBQyBDb2RlYyBzb2Z0d2FyZSBvciBtb2RpZmljYXRpb25zIHRoZXJldG8gb25seSBmb3IgcHVycG9zZXMgdGhhdCBhcmUgYXV0aG9yaXplZApieSBhcHByb3ByaWF0ZSBwYXRlbnQgbGljZW5zZXMuCgo0LiAgICBESVNDTEFJTUVSCgpUaGlzIEZESyBBQUMgQ29kZWMgc29mdHdhcmUgaXMgcHJvdmlkZWQgYnkgRnJhdW5ob2ZlciBvbiBiZWhhbGYgb2YgdGhlIGNvcHlyaWdodCBob2xkZXJzIGFuZCBjb250cmlidXRvcnMKIkFTIElTIiBhbmQgV0lUSE9VVCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIGluY2x1ZGluZyBidXQgbm90IGxpbWl0ZWQgdG8gdGhlIGltcGxpZWQgd2FycmFudGllcwpvZiBtZXJjaGFudGFiaWxpdHkgYW5kIGZpdG5lc3MgZm9yIGEgcGFydGljdWxhciBwdXJwb3NlLiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUIEhPTERFUiBPUgpDT05UUklCVVRPUlMgQkUgTElBQkxFIGZvciBhbnkgZGlyZWN0LCBpbmRpcmVjdCwgaW5jaWRlbnRhbCwgc3BlY2lhbCwgZXhlbXBsYXJ5LCBvciBjb25zZXF1ZW50aWFsIGRhbWFnZXMsCmluY2x1ZGluZyBidXQgbm90IGxpbWl0ZWQgdG8gcHJvY3VyZW1lbnQgb2Ygc3Vic3RpdHV0ZSBnb29kcyBvciBzZXJ2aWNlczsgbG9zcyBvZiB1c2UsIGRhdGEsIG9yIHByb2ZpdHMsCm9yIGJ1c2luZXNzIGludGVycnVwdGlvbiwgaG93ZXZlciBjYXVzZWQgYW5kIG9uIGFueSB0aGVvcnkgb2YgbGlhYmlsaXR5LCB3aGV0aGVyIGluIGNvbnRyYWN0LCBzdHJpY3QKbGlhYmlsaXR5LCBvciB0b3J0IChpbmNsdWRpbmcgbmVnbGlnZW5jZSksIGFyaXNpbmcgaW4gYW55IHdheSBvdXQgb2YgdGhlIHVzZSBvZiB0aGlzIHNvZnR3YXJlLCBldmVuIGlmCmFkdmlzZWQgb2YgdGhlIHBvc3NpYmlsaXR5IG9mIHN1Y2ggZGFtYWdlLgoKNS4gICAgQ09OVEFDVCBJTkZPUk1BVElPTgoKRnJhdW5ob2ZlciBJbnN0aXR1dGUgZm9yIEludGVncmF0ZWQgQ2lyY3VpdHMgSUlTCkF0dGVudGlvbjogQXVkaW8gYW5kIE11bHRpbWVkaWEgRGVwYXJ0bWVudHMgLSBGREsgQUFDIExMCkFtIFdvbGZzbWFudGVsIDMzCjkxMDU4IEVybGFuZ2VuLCBHZXJtYW55Cgp3d3cuaWlzLmZyYXVuaG9mZXIuZGUvYW1tCmFtbS1pbmZvQGlpcy5mcmF1bmhvZmVyLmRlCi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiogTVBFRyBBdWRpbyBFbmNvZGVyICoqKioqKioqKioqKioqKioqKioqKioqKioqCgogICAgSW5pdGlhbCBhdXRob3I6ICAgICAgIE0uIFdlcm5lcgogICAgY29udGVudHMvZGVzY3JpcHRpb246IFRocmVzaG9sZCBjb21wZW5zYXRpb24KCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KCiNpbmNsdWRlICJjb21tb25fZml4LmgiCgojaW5jbHVkZSAiYWRqX3Rocl9kYXRhLmgiCiNpbmNsdWRlICJhZGpfdGhyLmgiCiNpbmNsdWRlICJxY19kYXRhLmgiCiNpbmNsdWRlICJzZl9lc3RpbS5oIgojaW5jbHVkZSAiYWFjRW5jX3JhbS5oIgoKCgoKI2RlZmluZSBJTlZfSU5UX1RBQl9TSVpFICAoOCkKc3RhdGljIGNvbnN0IEZJWFBfREJMIGludkludFtJTlZfSU5UX1RBQl9TSVpFXSA9CnsKICAweDdmZmZmZmZmLCAweDdmZmZmZmZmLCAweDQwMDAwMDAwLCAweDJhYWFhYWFhLCAweDIwMDAwMDAwLCAweDE5OTk5OTk5LCAweDE1NTU1NTU1LCAweDEyNDkyNDkyCn07CgoKI2RlZmluZSBJTlZfU1FSVDRfVEFCX1NJWkUgICg4KQpzdGF0aWMgY29uc3QgRklYUF9EQkwgaW52U3FydDRbSU5WX1NRUlQ0X1RBQl9TSVpFXSA9CnsKICAweDdmZmZmZmZmLCAweDdmZmZmZmZmLCAweDZiYTI3ZTY1LCAweDYxNDI0YmI1LCAweDVhODI3OTk5LCAweDU1OTk0ODQ1LCAweDUxYzhlMzNjLCAweDRlYjE2MGQxCn07CgoKLypzdGF0aWMgY29uc3QgSU5UICAgICAgaW52UmVkRXhwID0gNDsqLwpzdGF0aWMgY29uc3QgRklYUF9EQkwgIFNuckxkTWluMSA9IChGSVhQX0RCTCkweGZjYWQwZGRmOyAvKkZMMkZYQ09OU1RfREJMKEZES2xvZygwLjMxNikvRkRLbG9nKDIuMCkvTERfREFUQV9TQ0FMSU5HKTsqLwpzdGF0aWMgY29uc3QgRklYUF9EQkwgIFNuckxkTWluMiA9IChGSVhQX0RCTCkweDAzNTFlMWEyOyAvKkZMMkZYQ09OU1RfREJMKEZES2xvZygzLjE2KSAvRkRLbG9nKDIuMCkvTERfREFUQV9TQ0FMSU5HKTsqLwpzdGF0aWMgY29uc3QgRklYUF9EQkwgIFNuckxkRmFjICA9IChGSVhQX0RCTCkweGZmNWIyYzNlOyAvKkZMMkZYQ09OU1RfREJMKEZES2xvZygwLjgpICAvRkRLbG9nKDIuMCkvTERfREFUQV9TQ0FMSU5HKTsqLwoKc3RhdGljIGNvbnN0IEZJWFBfREJMICBTbnJMZE1pbjMgPSAoRklYUF9EQkwpMHhmZTAwMDAwMDsgLypGTDJGWENPTlNUX0RCTChGREtsb2coMC41KSAgL0ZES2xvZygyLjApL0xEX0RBVEFfU0NBTElORyk7Ki8Kc3RhdGljIGNvbnN0IEZJWFBfREJMICBTbnJMZE1pbjQgPSAoRklYUF9EQkwpMHgwMjAwMDAwMDsgLypGTDJGWENPTlNUX0RCTChGREtsb2coMi4wKSAgL0ZES2xvZygyLjApL0xEX0RBVEFfU0NBTElORyk7Ki8Kc3RhdGljIGNvbnN0IEZJWFBfREJMICBTbnJMZE1pbjUgPSAoRklYUF9EQkwpMHhmYzAwMDAwMDsgLypGTDJGWENPTlNUX0RCTChGREtsb2coMC4yNSkgL0ZES2xvZygyLjApL0xEX0RBVEFfU0NBTElORyk7Ki8KCgovKiB2YWx1ZXMgZm9yIGF2b2lkIGhvbGUgZmxhZyAqLwplbnVtIF9hdm9pZF9ob2xlX3N0YXRlIHsKICAgIE5PX0FIICAgICAgICAgICAgICA9MCwKICAgIEFIX0lOQUNUSVZFICAgICAgICA9MSwKICAgIEFIX0FDVElWRSAgICAgICAgICA9Mgp9OwoKCi8qICBRIGZvcm1hdCBkZWZpbml0aW9ucyAqLwojZGVmaW5lIFFfQklURkFDICAgICgyNCkgICAvKiBRIHNjYWxpbmcgdXNlZCBpbiBGREthYWNFbmNfYml0cmVzQ2FsY0JpdEZhYygpIGNhbGN1bGF0aW9uICovCiNkZWZpbmUgUV9BVkdCSVRTICAgKDE3KSAgIC8qIHNjYWxlIGJpdCB2YWx1ZXMgKi8KCnN0YXRpYyBJTlQgRkRLYWFjRW5jX2JpdHMycGUyKAogICAgICAgIGNvbnN0IElOVCAgICAgICAgICAgICAgICAgYml0cywKICAgICAgICBjb25zdCBGSVhQX0RCTCAgICAgICAgICAgIGZhY3Rvcl9tLAogICAgICAgIGNvbnN0IElOVCAgICAgICAgICAgICAgICAgZmFjdG9yX2UKICAgICAgICApCnsKICAgcmV0dXJuIChJTlQpKGZNdWx0KGZhY3Rvcl9tLCAoRklYUF9EQkwpKGJpdHM8PFFfQVZHQklUUykpID4+IChRX0FWR0JJVFMtZmFjdG9yX2UpKTsKfQoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCmZ1bmN0aW9ubmFtZTogRkRLYWFjRW5jX2NhbGNUaHJlc2hFeHAKZGVzY3JpcHRpb246ICBsb3VkbmVzcyBjYWxjdWxhdGlvbiAodGhyZXNob2xkIHRvIHRoZSBwb3dlciBvZiByZWRFeHApCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwpzdGF0aWMgdm9pZCBGREthYWNFbmNfY2FsY1RocmVzaEV4cChGSVhQX0RCTCB0aHJFeHBbKDIpXVtNQVhfR1JPVVBFRF9TRkJdLAogICAgICAgICAgICAgICAgICAgICAgICAgIFFDX09VVF9DSEFOTkVMKiAgcWNPdXRDaGFubmVsWygyKV0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgUFNZX09VVF9DSEFOTkVMKiAgcHN5T3V0Q2hhbm5lbFsoMildLAogICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IElOVCBuQ2hhbm5lbHMpCnsKICAgSU5UIGNoLCBzZmIsIHNmYkdycDsKICAgRklYUF9EQkwgdGhyRXhwTGREYXRhOwoKICAgZm9yIChjaD0wOyBjaDxuQ2hhbm5lbHM7IGNoKyspIHsKICAgICBmb3Ioc2ZiR3JwID0gMDtzZmJHcnAgPCBwc3lPdXRDaGFubmVsW2NoXS0+c2ZiQ250O3NmYkdycCs9IHBzeU91dENoYW5uZWxbY2hdLT5zZmJQZXJHcm91cCkgewogICAgICAgZm9yIChzZmI9MDsgc2ZiPHBzeU91dENoYW5uZWxbY2hdLT5tYXhTZmJQZXJHcm91cDsgc2ZiKyspIHsKICAgICAgICAgdGhyRXhwTGREYXRhID0gcHN5T3V0Q2hhbm5lbFtjaF0tPnNmYlRocmVzaG9sZExkRGF0YVtzZmJHcnArc2ZiXT4+MiA7CiAgICAgICAgIHRockV4cFtjaF1bc2ZiR3JwK3NmYl0gPSBDYWxjSW52TGREYXRhKHRockV4cExkRGF0YSk7CiAgICAgICB9CiAgICAgfQogICB9Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAgIGZ1bmN0aW9ubmFtZTogRkRLYWFjRW5jX2FkYXB0TWluU25yCiAgICBkZXNjcmlwdGlvbjogIHJlZHVjZSBtaW5TbnIgcmVxdWlyZW1lbnRzIGZvciBiYW5kcyB3aXRoIHJlbGF0aXZlIGxvdyBlbmVyZ2llcwoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8Kc3RhdGljIHZvaWQgRkRLYWFjRW5jX2FkYXB0TWluU25yKFFDX09VVF9DSEFOTkVMICAgICAqcWNPdXRDaGFubmVsWygyKV0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBQU1lfT1VUX0NIQU5ORUwgICAgKnBzeU91dENoYW5uZWxbKDIpXSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIE1JTlNOUl9BREFQVF9QQVJBTSAqbXNhUGFyYW0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBJTlQgICAgICAgICAgIG5DaGFubmVscykKewogIElOVCBjaCwgc2ZiLCBzZmJHcnAsIG5TZmI7CiAgRklYUF9EQkwgYXZnRW5MRDY0LCBkYlJhdGlvLCBtaW5TbnJSZWQ7CiAgRklYUF9EQkwgbWluU25yTGltaXRMRDY0ID0gRkwyRlhDT05TVF9EQkwoLTAuMDA1MDMwMTI2NDgyNjJmKTsgLyogbGQ2NCgwLjhmKSAqLwogIEZJWFBfREJMIG5TZmJMRDY0OwogIEZJWFBfREJMIGFjY3U7CgogIGZvciAoY2g9MDsgY2g8bkNoYW5uZWxzOyBjaCsrKSB7CiAgICAvKiBjYWxjIGF2ZXJhZ2UgZW5lcmd5IHBlciBzY2FsZWZhY3RvciBiYW5kICovCiAgICBuU2ZiID0gMDsKICAgIGFjY3UgPSBGTDJGWENPTlNUX0RCTCgwLjBmKTsKCiAgICBmb3IgKHNmYkdycD0wOyBzZmJHcnAgPCBwc3lPdXRDaGFubmVsW2NoXS0+c2ZiQ250OyBzZmJHcnArPXBzeU91dENoYW5uZWxbY2hdLT5zZmJQZXJHcm91cCkgewogICAgICBmb3IgKHNmYj0wOyBzZmI8cHN5T3V0Q2hhbm5lbFtjaF0tPm1heFNmYlBlckdyb3VwOyBzZmIrKykgewogICAgICAgIGFjY3UgKz0gcHN5T3V0Q2hhbm5lbFtjaF0tPnNmYkVuZXJneVtzZmJHcnArc2ZiXT4+NjsKCQkJCSBuU2ZiKys7CgkJCSB9CiAgICB9CgogICAgaWYgKChhY2N1ID09IEZMMkZYQ09OU1RfREJMKDAuMGYpKSB8fCAoblNmYiA9PSAwKSkgewogICAgICBhdmdFbkxENjQgPSBGTDJGWENPTlNUX0RCTCgtMS4wZik7CiAgICB9CiAgICBlbHNlIHsKICAgICAgblNmYkxENjQgID0gQ2FsY0xkSW50KG5TZmIpOwogICAgICBhdmdFbkxENjQgPSBDYWxjTGREYXRhKGFjY3UpOwogICAgICBhdmdFbkxENjQgPSBhdmdFbkxENjQgKyBGTDJGWENPTlNUX0RCTCgwLjA5Mzc1ZikgLSBuU2ZiTEQ2NDsgIC8qIDAuMDkzNzVmOiBjb21wZW5zYXRlIHNoaWZ0IHdpdGggNiAqLwogICAgfQoKICAgIC8qIHJlZHVjZSBtaW5TbnIgcmVxdWlyZW1lbnQgYnkgbWluU25yXm1pblNuclJlZCBkZXBlbmRlbnQgb24gYXZnRW4vc2ZiRW4gKi8KICAgIGZvciAoc2ZiR3JwPTA7IHNmYkdycCA8IHBzeU91dENoYW5uZWxbY2hdLT5zZmJDbnQ7IHNmYkdycCs9cHN5T3V0Q2hhbm5lbFtjaF0tPnNmYlBlckdyb3VwKSB7CiAgICAgIGZvciAoc2ZiPTA7IHNmYjxwc3lPdXRDaGFubmVsW2NoXS0+bWF4U2ZiUGVyR3JvdXA7IHNmYisrKSB7CiAgICAgICAgaWYgKCAobXNhUGFyYW0tPnN0YXJ0UmF0aW8gKyBxY091dENoYW5uZWxbY2hdLT5zZmJFbmVyZ3lMZERhdGFbc2ZiR3JwK3NmYl0pIDwgYXZnRW5MRDY0ICkgewogICAgICAgICAgZGJSYXRpbyA9IGZNdWx0KChhdmdFbkxENjQgLSBxY091dENoYW5uZWxbY2hdLT5zZmJFbmVyZ3lMZERhdGFbc2ZiR3JwK3NmYl0pLEZMMkZYQ09OU1RfREJMKDAuMzAxMDI5OTk1NmYpKTsgLyogc2NhbGVkIGJ5ICgxLjBmLygxMC4wZio2NC4wZikpICovCiAgICAgICAgICBtaW5TbnJSZWQgPSBtc2FQYXJhbS0+cmVkT2ZmcyArIGZNdWx0KG1zYVBhcmFtLT5yZWRSYXRpb0ZhYyxkYlJhdGlvKTsgLyogc2NhbGVkIGJ5IDEuMGYvNjQuMGYqLwogICAgICAgICAgbWluU25yUmVkID0gZml4TWF4KG1pblNuclJlZCwgbXNhUGFyYW0tPm1heFJlZCk7IC8qIHNjYWxlZCBieSAxLjBmLzY0LjBmKi8KICAgICAgICAgIHFjT3V0Q2hhbm5lbFtjaF0tPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXSA9IChmTXVsdChxY091dENoYW5uZWxbY2hdLT5zZmJNaW5TbnJMZERhdGFbc2ZiR3JwK3NmYl0sbWluU25yUmVkKSkgPDwgNjsKICAgICAgICAgIHFjT3V0Q2hhbm5lbFtjaF0tPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXSA9IGZpeE1pbihtaW5TbnJMaW1pdExENjQsIHFjT3V0Q2hhbm5lbFtjaF0tPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXSk7CiAgICAgICAgfQogICAgICB9CiAgICB9CiAgfQp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCmZ1bmN0aW9ubmFtZTogRkRLYWFjRW5jX2luaXRBdm9pZEhvbGVGbGFnCmRlc2NyaXB0aW9uOiAgZGV0ZXJtaW5lIGJhbmRzIHdoZXJlIGF2b2lkIGhvbGUgaXMgbm90IG5lY2Vzc2FyeSByZXNwLiBwb3NzaWJsZQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8Kc3RhdGljIHZvaWQgRkRLYWFjRW5jX2luaXRBdm9pZEhvbGVGbGFnKFFDX09VVF9DSEFOTkVMICAqcWNPdXRDaGFubmVsWygyKV0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBTWV9PVVRfQ0hBTk5FTCAqcHN5T3V0Q2hhbm5lbFsoMildLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVQ0hBUiBhaEZsYWdbKDIpXVtNQVhfR1JPVVBFRF9TRkJdLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgVE9PTFNJTkZPICp0b29sc0luZm8sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IElOVCBuQ2hhbm5lbHMsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IFBFX0RBVEEgKnBlRGF0YSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQUhfUEFSQU0gKmFoUGFyYW0pCnsKICAgSU5UIGNoLCBzZmIsIHNmYkdycDsKICAgRklYUF9EQkwgc2ZiRW4sIHNmYkVubTE7CiAgIEZJWFBfREJMIHNmYkVuTGREYXRhOwogICBGSVhQX0RCTCBhdmdFbkxkRGF0YTsKCiAgIC8qIGRlY3JlYXNlIHNwcmVhZCBlbmVyZ3kgYnkgM2RCIGZvciBsb25nIGJsb2NrcywgcmVzcC4gMmRCIGZvciBzaG9ydHMKICAgICAgKGF2b2lkIG1vcmUgaG9sZXMgaW4gbG9uZyBibG9ja3MpICovCiAgIGZvciAoY2g9MDsgY2g8bkNoYW5uZWxzOyBjaCsrKSB7CiAgICAgIElOVCBzZmJHcnAsIHNmYjsKICAgICAgUUNfT1VUX0NIQU5ORUwqICBxY091dENoYW4gID0gcWNPdXRDaGFubmVsW2NoXTsKCiAgICAgIGlmIChwc3lPdXRDaGFubmVsW2NoXS0+bGFzdFdpbmRvd1NlcXVlbmNlICE9IFNIT1JUX1dJTkRPVykgewogICAgICAgICBmb3IgKHNmYkdycCA9IDA7c2ZiR3JwIDwgcHN5T3V0Q2hhbm5lbFtjaF0tPnNmYkNudDtzZmJHcnArPSBwc3lPdXRDaGFubmVsW2NoXS0+c2ZiUGVyR3JvdXApCiAgICAgICAgICAgZm9yIChzZmI9MDsgc2ZiPHBzeU91dENoYW5uZWxbY2hdLT5tYXhTZmJQZXJHcm91cDsgc2ZiKyspCiAgICAgICAgICAgICAgcWNPdXRDaGFuLT5zZmJTcHJlYWRFbmVyZ3lbc2ZiR3JwK3NmYl0gPj49IDEgOwogICAgICB9CiAgICAgIGVsc2UgewogICAgICAgICBmb3IgKHNmYkdycCA9IDA7c2ZiR3JwIDwgcHN5T3V0Q2hhbm5lbFtjaF0tPnNmYkNudDtzZmJHcnArPSBwc3lPdXRDaGFubmVsW2NoXS0+c2ZiUGVyR3JvdXApCiAgICAgICAgICAgZm9yIChzZmI9MDsgc2ZiPHBzeU91dENoYW5uZWxbY2hdLT5tYXhTZmJQZXJHcm91cDsgc2ZiKyspCiAgICAgICAgICAgICAgcWNPdXRDaGFuLT5zZmJTcHJlYWRFbmVyZ3lbc2ZiR3JwK3NmYl0gPQogICAgICAgICAgICAgICAgICAgZk11bHQoRkwyRlhDT05TVF9EQkwoMC42M2YpLAogICAgICAgICAgICAgICAgICAgICAgICAgcWNPdXRDaGFuLT5zZmJTcHJlYWRFbmVyZ3lbc2ZiR3JwK3NmYl0pIDsKICAgICAgfQogICB9CgogICAvKiBpbmNyZWFzZSBtaW5TbnIgZm9yIGxvY2FsIHBlYWtzLCBkZWNyZWFzZSBpdCBmb3IgdmFsbGV5cyAqLwogICBpZiAoYWhQYXJhbS0+bW9kaWZ5TWluU25yKSB7CiAgICAgIGZvcihjaD0wOyBjaDxuQ2hhbm5lbHM7IGNoKyspIHsKICAgICAgICAgUUNfT1VUX0NIQU5ORUwqICBxY091dENoYW4gID0gcWNPdXRDaGFubmVsW2NoXTsKICAgICAgICAgZm9yKHNmYkdycCA9IDA7c2ZiR3JwIDwgcHN5T3V0Q2hhbm5lbFtjaF0tPnNmYkNudDtzZmJHcnArPSBwc3lPdXRDaGFubmVsW2NoXS0+c2ZiUGVyR3JvdXApewogICAgICAgICAgICBmb3IgKHNmYj0wOyBzZmI8cHN5T3V0Q2hhbm5lbFtjaF0tPm1heFNmYlBlckdyb3VwOyBzZmIrKykgewogICAgICAgICAgICAgICBGSVhQX0RCTCBzZmJFbnAxLCBhdmdFbjsKICAgICAgICAgICAgICAgaWYgKHNmYiA+IDApCiAgICAgICAgICAgICAgICAgIHNmYkVubTEgPSBxY091dENoYW4tPnNmYkVuZXJneVtzZmJHcnArc2ZiLTFdOwogICAgICAgICAgICAgICBlbHNlCiAgICAgICAgICAgICAgICAgIHNmYkVubTEgPSBxY091dENoYW4tPnNmYkVuZXJneVtzZmJHcnArc2ZiXTsKCiAgICAgICAgICAgICAgIGlmIChzZmIgPCBwc3lPdXRDaGFubmVsW2NoXS0+bWF4U2ZiUGVyR3JvdXAtMSkKICAgICAgICAgICAgICAgICAgc2ZiRW5wMSA9IHFjT3V0Q2hhbi0+c2ZiRW5lcmd5W3NmYkdycCtzZmIrMV07CiAgICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgICAgc2ZiRW5wMSA9IHFjT3V0Q2hhbi0+c2ZiRW5lcmd5W3NmYkdycCtzZmJdOwoKICAgICAgICAgICAgICAgYXZnRW4gPSAoc2ZiRW5tMT4+MSkgKyAoc2ZiRW5wMT4+MSk7CiAgICAgICAgICAgICAgIGF2Z0VuTGREYXRhID0gQ2FsY0xkRGF0YShhdmdFbik7CiAgICAgICAgICAgICAgIHNmYkVuID0gcWNPdXRDaGFuLT5zZmJFbmVyZ3lbc2ZiR3JwK3NmYl07CiAgICAgICAgICAgICAgIHNmYkVuTGREYXRhID0gcWNPdXRDaGFuLT5zZmJFbmVyZ3lMZERhdGFbc2ZiR3JwK3NmYl07CiAgICAgICAgICAgICAgIC8qIHBlYWsgPyAqLwogICAgICAgICAgICAgICBpZiAoc2ZiRW4gPiBhdmdFbikgewogICAgICAgICAgICAgICAgICBGSVhQX0RCTCB0bXBNaW5TbnJMZERhdGE7CiAgICAgICAgICAgICAgICAgIGlmIChwc3lPdXRDaGFubmVsW2NoXS0+bGFzdFdpbmRvd1NlcXVlbmNlPT1MT05HX1dJTkRPVykKICAgICAgICAgICAgICAgICAgICAgdG1wTWluU25yTGREYXRhID0gZml4TWF4KCBTbnJMZEZhYyArIChGSVhQX0RCTCkoYXZnRW5MZERhdGEgLSBzZmJFbkxkRGF0YSksIChGSVhQX0RCTClTbnJMZE1pbjEgKSA7CiAgICAgICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgICAgICAgdG1wTWluU25yTGREYXRhID0gZml4TWF4KCBTbnJMZEZhYyArIChGSVhQX0RCTCkoYXZnRW5MZERhdGEgLSBzZmJFbkxkRGF0YSksIChGSVhQX0RCTClTbnJMZE1pbjMgKSA7CgogICAgICAgICAgICAgICAgICBxY091dENoYW4tPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXSA9CiAgICAgICAgICAgICAgICAgICAgIGZpeE1pbihxY091dENoYW4tPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXSwgdG1wTWluU25yTGREYXRhKTsKICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAvKiB2YWxsZXkgPyAqLwogICAgICAgICAgICAgICBpZiAoICgoc2ZiRW5MZERhdGErKEZJWFBfREJMKVNuckxkTWluNCkgPCAoRklYUF9EQkwpYXZnRW5MZERhdGEpICYmIChzZmJFbiA+IEZMMkZYQ09OU1RfREJMKDAuMCkpICkgewogICAgICAgICAgICAgICAgICBGSVhQX0RCTCB0bXBNaW5TbnJMZERhdGEgPSBhdmdFbkxkRGF0YSAtIHNmYkVuTGREYXRhIC0oRklYUF9EQkwpU25yTGRNaW40ICsgcWNPdXRDaGFuLT5zZmJNaW5TbnJMZERhdGFbc2ZiR3JwK3NmYl07CiAgICAgICAgICAgICAgICAgIHRtcE1pblNuckxkRGF0YSA9IGZpeE1pbigoRklYUF9EQkwpU25yTGRGYWMsIHRtcE1pblNuckxkRGF0YSk7CiAgICAgICAgICAgICAgICAgIHFjT3V0Q2hhbi0+c2ZiTWluU25yTGREYXRhW3NmYkdycCtzZmJdID0gZml4TWluKHRtcE1pblNuckxkRGF0YSwKICAgICAgICAgICAgICAgICAgICAgICAgKEZJWFBfREJMKShxY091dENoYW4tPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXSArIFNuckxkTWluMiApKTsKICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CiAgICAgICAgIH0KICAgICAgfQogICB9CgogICAvKiBzdGVyZW86IGFkYXB0IHRoZSBtaW5pbXVtIHJlcXVpcmVtZW50cyBzZmJNaW5TbnIgb2YgbWlkIGFuZAogICAgICBzaWRlIGNoYW5uZWxzIHRvIGF2b2lkIHNwZW5kaW5nIHVubm90aWNhYmxlIGJpdHMgKi8KICAgaWYgKG5DaGFubmVscyA9PSAyKSB7CiAgICAgIFFDX09VVF9DSEFOTkVMKiAgcWNPdXRDaGFuTSAgPSBxY091dENoYW5uZWxbMF07CiAgICAgIFFDX09VVF9DSEFOTkVMKiAgcWNPdXRDaGFuUyAgPSBxY091dENoYW5uZWxbMV07CiAgICAgIFBTWV9PVVRfQ0hBTk5FTCogIHBzeU91dENoYW5NICA9IHBzeU91dENoYW5uZWxbMF07CiAgICAgIGZvcihzZmJHcnAgPSAwO3NmYkdycCA8IHBzeU91dENoYW5NLT5zZmJDbnQ7c2ZiR3JwKz0gcHN5T3V0Q2hhbk0tPnNmYlBlckdyb3VwKXsKICAgICAgICBmb3IgKHNmYj0wOyBzZmI8cHN5T3V0Q2hhbk0tPm1heFNmYlBlckdyb3VwOyBzZmIrKykgewogICAgICAgICAgaWYgKHRvb2xzSW5mby0+bXNNYXNrW3NmYkdycCtzZmJdKSB7CiAgICAgICAgICAgICBGSVhQX0RCTCBtYXhTZmJFbkxkID0gZml4TWF4KHFjT3V0Q2hhbk0tPnNmYkVuZXJneUxkRGF0YVtzZmJHcnArc2ZiXSxxY091dENoYW5TLT5zZmJFbmVyZ3lMZERhdGFbc2ZiR3JwK3NmYl0pOwogICAgICAgICAgICAgRklYUF9EQkwgbWF4VGhyTGQsIHNmYk1pblNuclRtcExkOwoKICAgICAgICAgICAgIGlmICggKChTbnJMZE1pbjU+PjEpICsgKG1heFNmYkVuTGQ+PjEpICsgKHFjT3V0Q2hhbk0tPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXT4+MSkpIDw9IEZMMkZYQ09OU1RfREJMKC0wLjVmKSkKICAgICAgICAgICAgICAgbWF4VGhyTGQgPSBGTDJGWENPTlNUX0RCTCgtMS4wZikgOwogICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICBtYXhUaHJMZCA9IFNuckxkTWluNSArIG1heFNmYkVuTGQgKyBxY091dENoYW5NLT5zZmJNaW5TbnJMZERhdGFbc2ZiR3JwK3NmYl07CgogICAgICAgICAgICAgaWYgKHFjT3V0Q2hhbk0tPnNmYkVuZXJneVtzZmJHcnArc2ZiXSA+IEZMMkZYQ09OU1RfREJMKDAuMGYpKQogICAgICAgICAgICAgICBzZmJNaW5TbnJUbXBMZCA9IG1heFRockxkIC0gcWNPdXRDaGFuTS0+c2ZiRW5lcmd5TGREYXRhW3NmYkdycCtzZmJdOwogICAgICAgICAgICAgZWxzZQogICAgICAgICAgICAgICBzZmJNaW5TbnJUbXBMZCA9IEZMMkZYQ09OU1RfREJMKDAuMGYpOwoKICAgICAgICAgICAgIHFjT3V0Q2hhbk0tPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXSA9IGZpeE1heChxY091dENoYW5NLT5zZmJNaW5TbnJMZERhdGFbc2ZiR3JwK3NmYl0sc2ZiTWluU25yVG1wTGQpOwoKICAgICAgICAgICAgIGlmIChxY091dENoYW5NLT5zZmJNaW5TbnJMZERhdGFbc2ZiR3JwK3NmYl0gPD0gRkwyRlhDT05TVF9EQkwoMC4wZikpCiAgICAgICAgICAgICAgICBxY091dENoYW5NLT5zZmJNaW5TbnJMZERhdGFbc2ZiR3JwK3NmYl0gPSBmaXhNaW4ocWNPdXRDaGFuTS0+c2ZiTWluU25yTGREYXRhW3NmYkdycCtzZmJdLCAoRklYUF9EQkwpU25yTGRGYWMpOwoKICAgICAgICAgICAgIGlmIChxY091dENoYW5TLT5zZmJFbmVyZ3lbc2ZiR3JwK3NmYl0gPiBGTDJGWENPTlNUX0RCTCgwLjBmKSkKICAgICAgICAgICAgICAgc2ZiTWluU25yVG1wTGQgPSBtYXhUaHJMZCAtIHFjT3V0Q2hhblMtPnNmYkVuZXJneUxkRGF0YVtzZmJHcnArc2ZiXTsKICAgICAgICAgICAgIGVsc2UKICAgICAgICAgICAgICAgc2ZiTWluU25yVG1wTGQgPSBGTDJGWENPTlNUX0RCTCgwLjBmKTsKCiAgICAgICAgICAgICBxY091dENoYW5TLT5zZmJNaW5TbnJMZERhdGFbc2ZiR3JwK3NmYl0gPSBmaXhNYXgocWNPdXRDaGFuUy0+c2ZiTWluU25yTGREYXRhW3NmYkdycCtzZmJdLHNmYk1pblNuclRtcExkKTsKCiAgICAgICAgICAgICBpZiAocWNPdXRDaGFuUy0+c2ZiTWluU25yTGREYXRhW3NmYkdycCtzZmJdIDw9IEZMMkZYQ09OU1RfREJMKDAuMGYpKQogICAgICAgICAgICAgICAgcWNPdXRDaGFuUy0+c2ZiTWluU25yTGREYXRhW3NmYkdycCtzZmJdID0gZml4TWluKHFjT3V0Q2hhblMtPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXSwoRklYUF9EQkwpU25yTGRGYWMpOwoKICAgICAgICAgICAgIGlmIChxY091dENoYW5NLT5zZmJFbmVyZ3lbc2ZiR3JwK3NmYl0+cWNPdXRDaGFuTS0+c2ZiU3ByZWFkRW5lcmd5W3NmYkdycCtzZmJdKQogICAgICAgICAgICAgICAgcWNPdXRDaGFuUy0+c2ZiU3ByZWFkRW5lcmd5W3NmYkdycCtzZmJdID0KICAgICAgICAgICAgICAgICAgIGZNdWx0KHFjT3V0Q2hhblMtPnNmYkVuZXJneVtzZmJHcnArc2ZiXSwgRkwyRlhDT05TVF9EQkwoMC45ZikpOwoKICAgICAgICAgICAgIGlmIChxY091dENoYW5TLT5zZmJFbmVyZ3lbc2ZiR3JwK3NmYl0+cWNPdXRDaGFuUy0+c2ZiU3ByZWFkRW5lcmd5W3NmYkdycCtzZmJdKQogICAgICAgICAgICAgICAgcWNPdXRDaGFuTS0+c2ZiU3ByZWFkRW5lcmd5W3NmYkdycCtzZmJdID0KICAgICAgICAgICAgICAgICAgIGZNdWx0KHFjT3V0Q2hhbk0tPnNmYkVuZXJneVtzZmJHcnArc2ZiXSwgRkwyRlhDT05TVF9EQkwoMC45ZikpOwogICAgICAgICAgfQogICAgICAgIH0KICAgICAgfQogICB9CgogICAvKiBpbml0IGFoRmxhZyAoMDogbm8gYWggbmVjZXNzYXJ5LCAxOiBhaCBwb3NzaWJsZSwgMjogYWggYWN0aXZlICovCiAgIGZvcihjaD0wOyBjaDxuQ2hhbm5lbHM7IGNoKyspIHsKICAgICAgUUNfT1VUX0NIQU5ORUwgICpxY091dENoYW4gID0gcWNPdXRDaGFubmVsW2NoXTsKICAgICAgUFNZX09VVF9DSEFOTkVMICAqcHN5T3V0Q2hhbiAgPSBwc3lPdXRDaGFubmVsW2NoXTsKICAgICAgZm9yKHNmYkdycCA9IDA7c2ZiR3JwIDwgcHN5T3V0Q2hhbi0+c2ZiQ250O3NmYkdycCs9IHBzeU91dENoYW4tPnNmYlBlckdyb3VwKXsKICAgICAgICBmb3IgKHNmYj0wOyBzZmI8cHN5T3V0Q2hhbi0+bWF4U2ZiUGVyR3JvdXA7IHNmYisrKSB7CiAgICAgICAgICBpZiAoKHFjT3V0Q2hhbi0+c2ZiU3ByZWFkRW5lcmd5W3NmYkdycCtzZmJdID4gcWNPdXRDaGFuLT5zZmJFbmVyZ3lbc2ZiR3JwK3NmYl0pCiAgICAgICAgICAgICAgfHwgKHFjT3V0Q2hhbi0+c2ZiTWluU25yTGREYXRhW3NmYkdycCtzZmJdID4gRkwyRlhDT05TVF9EQkwoMC4wZikpKSB7CiAgICAgICAgICAgICBhaEZsYWdbY2hdW3NmYkdycCtzZmJdID0gTk9fQUg7CiAgICAgICAgICB9CiAgICAgICAgICBlbHNlIHsKICAgICAgICAgICAgIGFoRmxhZ1tjaF1bc2ZiR3JwK3NmYl0gPSBBSF9JTkFDVElWRTsKICAgICAgICAgIH0KICAgICAgICB9CiAgICAgIH0KICAgfQp9CgoKCi8qKgogKiBcYnJpZWYgIENhbGN1bGF0ZSBjb25zdGFudHMgdGhhdCBkbyBub3QgY2hhbmdlIGR1cmluZyBzdWNjZXNzaXZlIHBlIGNhbGN1bGF0aW9ucy4KICoKICogXHBhcmFtIHBlRGF0YSAgICAgICAgICAgICAgICBQb2ludGVyIHRvIHN0cnVjdHVyZSBjb250YWluaW5nIFBFIGRhdGEgb2YgY3VycmVudCBlbGVtZW50LgogKiBccGFyYW0gcHN5T3V0Q2hhbm5lbCAgICAgICAgIFBvaW50ZXIgdG8gUFNZX09VVF9DSEFOTkVMIHN0cnVjdCBob2xkaW5nIG5DaGFubmVscyBlbGVtZW50cy4KICogXHBhcmFtIHFjT3V0Q2hhbm5lbCAgICAgICAgICBQb2ludGVyIHRvIFFDX09VVF9DSEFOTkVMIHN0cnVjdCBob2xkaW5nIG5DaGFubmVscyBlbGVtZW50cy4KICogXHBhcmFtIG5DaGFubmVscyAgICAgICAgICAgICBOdW1iZXIgb2YgY2hhbm5lbHMgaW4gZWxlbWVudC4KICogXHBhcmFtIHBlT2Zmc2V0ICAgICAgICAgICAgICBGaXhlZCBQRSBvZmZzZXQgZGVmaW5lZCB3aGlsZSBGREthYWNFbmNfQWRqVGhySW5pdCgpIGRlcGVuZGluZyBvbiBiaXRyYXRlLgogKgogKiBccmV0dXJuICB2b2lkCiAqLwpzdGF0aWMKdm9pZCBGREthYWNFbmNfcHJlcGFyZVBlKFBFX0RBVEEgKnBlRGF0YSwKICAgICAgICAgICAgICAgUFNZX09VVF9DSEFOTkVMKiBwc3lPdXRDaGFubmVsWygyKV0sCiAgICAgICAgICAgICAgIFFDX09VVF9DSEFOTkVMKiBxY091dENoYW5uZWxbKDIpXSwKICAgICAgICAgICAgICAgY29uc3QgSU5UIG5DaGFubmVscywKICAgICAgICAgICAgICAgY29uc3QgSU5UIHBlT2Zmc2V0KQp7CiAgICBJTlQgY2g7CgogICAgZm9yKGNoPTA7IGNoPG5DaGFubmVsczsgY2grKykgewogICAgICAgIFBTWV9PVVRfQ0hBTk5FTCAqcHN5T3V0Q2hhbiA9IHBzeU91dENoYW5uZWxbY2hdOwogICAgICAgIEZES2FhY0VuY19wcmVwYXJlU2ZiUGUoJnBlRGF0YS0+cGVDaGFubmVsRGF0YVtjaF0sCiAgICAgICAgICAgIHBzeU91dENoYW4tPnNmYkVuZXJneUxkRGF0YSwKICAgICAgICAgICAgcHN5T3V0Q2hhbi0+c2ZiVGhyZXNob2xkTGREYXRhLAogICAgICAgICAgICBxY091dENoYW5uZWxbY2hdLT5zZmJGb3JtRmFjdG9yTGREYXRhLAogICAgICAgICAgICBwc3lPdXRDaGFuLT5zZmJPZmZzZXRzLAogICAgICAgICAgICBwc3lPdXRDaGFuLT5zZmJDbnQsCiAgICAgICAgICAgIHBzeU91dENoYW4tPnNmYlBlckdyb3VwLAogICAgICAgICAgICBwc3lPdXRDaGFuLT5tYXhTZmJQZXJHcm91cCk7CiAgICB9CiAgICBwZURhdGEtPm9mZnNldCA9IHBlT2Zmc2V0Owp9CgovKioKICogXGJyaWVmICBDYWxjdWxhdGUgd2VpZ2h0aW5nIGZhY3RvciBmb3IgdGhyZXNob2xkIGFkanVzdG1lbnQuCiAqCiAqIENhbGN1bGF0ZSB3ZWlnaHRpbmcgZmFjdG9yIHRvIGJlIGFwcGxpZWQgYXQgZW5lcmdpZXMgYW5kIHRocmVzaG9sZHMgaW4gbGQ2NCBmb3JtYXQuCiAqCiAqIFxwYXJhbSBwZURhdGEsICAgICAgICAgICAgICAgUG9pbnRlciB0byBQRSBkYXRhIGluIGN1cnJlbnQgZWxlbWVudC4KICogXHBhcmFtIHBzeU91dENoYW5uZWwgICAgICAgICBQb2ludGVyIHRvIFBTWV9PVVRfQ0hBTk5FTCBzdHJ1Y3QgaG9sZGluZyBuQ2hhbm5lbHMgZWxlbWVudHMuCiAqIFxwYXJhbSBxY091dENoYW5uZWwgICAgICAgICAgUG9pbnRlciB0byBRQ19PVVRfQ0hBTk5FTCBzdHJ1Y3QgaG9sZGluZyBuQ2hhbm5lbHMgZWxlbWVudHMuCiAqIFxwYXJhbSB0b29sc0luZm8gICAgICAgICAgICAgUG9pbnRlciB0byB0b29scyBpbmZvIHN0cnVjdCBvZiBjdXJyZW50IGVsZW1lbnQuCiAqIFxwYXJhbSBhZGpUaHJTdGF0ZUVsZW1lbnQgICAgUG9pbnRlciB0byBBVFNfRUxFTUVOVCBob2xkaW5nIGVuRmFjUGF0Y2ggc3RhdGVzLgogKiBccGFyYW0gbkNoYW5uZWxzICAgICAgICAgICAgIE51bWJlciBvZiBjaGFubmVscyBpbiBlbGVtZW50LgogKiBccGFyYW0gdXNlUGF0Y2hUb29sICAgICAgICAgIEFwcGx5IHRoZSB3ZWlnaHRpbmcgdG9vbCAwIChubykgZWxzZSAoeWVzKS4KICoKICogXHJldHVybiAgdm9pZAogKi8Kc3RhdGljCnZvaWQgRkRLYWFjRW5jX2NhbGNXZWlnaHRpbmcoUEVfREFUQSAqcGVEYXRhLAogICAgICAgICAgICAgICBQU1lfT1VUX0NIQU5ORUwqIHBzeU91dENoYW5uZWxbKDIpXSwKICAgICAgICAgICAgICAgUUNfT1VUX0NIQU5ORUwqIHFjT3V0Q2hhbm5lbFsoMildLAogICAgICAgICAgICAgICBzdHJ1Y3QgVE9PTFNJTkZPICp0b29sc0luZm8sCiAgICAgICAgICAgICAgIEFUU19FTEVNRU5UKiBhZGpUaHJTdGF0ZUVsZW1lbnQsCiAgICAgICAgICAgICAgIGNvbnN0IElOVCBuQ2hhbm5lbHMsCiAgICAgICAgICAgICAgIGNvbnN0IElOVCB1c2VQYXRjaFRvb2wpCnsKICAgIGludCBjaCwgbm9TaG9ydFdpbmRvd0luRnJhbWUgPSBUUlVFOwogICAgSU5UIGV4ZVBhdGNoTSA9IDA7CgogICAgZm9yIChjaD0wOyBjaDxuQ2hhbm5lbHM7IGNoKyspIHsKICAgICAgICBpZiAocHN5T3V0Q2hhbm5lbFtjaF0tPmxhc3RXaW5kb3dTZXF1ZW5jZSA9PSBTSE9SVF9XSU5ET1cpIHsKICAgICAgICAgICAgbm9TaG9ydFdpbmRvd0luRnJhbWUgPSBGQUxTRTsKICAgICAgICB9CiAgICAgICAgRkRLbWVtY2xlYXIocWNPdXRDaGFubmVsW2NoXS0+c2ZiRW5GYWNMZCwgTUFYX0dST1VQRURfU0ZCKnNpemVvZihGSVhQX0RCTCkpOwogICAgfQoKICAgIGlmICh1c2VQYXRjaFRvb2w9PTApIHsKICAgICAgICByZXR1cm47IC8qIHRvb2wgaXMgZGlzYWJsZWQgKi8KICAgIH0KCiAgICBmb3IgKGNoPTA7IGNoPG5DaGFubmVsczsgY2grKykgewoKICAgICAgICBQU1lfT1VUX0NIQU5ORUwgKnBzeU91dENoYW4gPSBwc3lPdXRDaGFubmVsW2NoXTsKCiAgICAgICAgaWYgKG5vU2hvcnRXaW5kb3dJbkZyYW1lKSB7IC8qIHJldGFpbiBlbmVyZ3kgcmF0aW8gYmV0d2VlbiBibG9ja3Mgb2YgZGlmZmVyZW50IGxlbmd0aCAqLwoKICAgICAgICAgICAgRklYUF9EQkwgbnJnU3VtMTQsIG5yZ1N1bTEyLCBucmdTdW0zNCwgbnJnVG90YWw7CiAgICAgICAgICAgIEZJWFBfREJMIG5yZ0ZhY0xkXzE0LCBucmdGYWNMZF8xMiwgbnJnRmFjTGRfMzQ7CiAgICAgICAgICAgIElOVCB1c2VQYXRjaCwgZXhlUGF0Y2g7CiAgICAgICAgICAgIGludCBzZmIsIG5MaW5lc1N1bSA9IDA7CgogICAgICAgICAgICBucmdTdW0xNCA9IG5yZ1N1bTEyID0gbnJnU3VtMzQgPSBucmdUb3RhbCA9IEZMMkZYQ09OU1RfREJMKDAuZik7CgogICAgICAgICAgICAvKiBjYWxjdWxhdGUgZmxhdG5lc3Mgb2YgYXVkaWJsZSBzcGVjdHJ1bSwgaS5lLiBzcGVjdHJ1bSBhYm92ZSBtYXNraW5nIHRocmVzaG9sZC4gKi8KICAgICAgICAgICAgZm9yIChzZmIgPSAwOyBzZmIgPCBwc3lPdXRDaGFuLT5zZmJDbnQ7IHNmYisrKSB7CgogICAgICAgICAgICAgICAgRklYUF9EQkwgbnJnRmFjMTIgPSBDYWxjSW52TGREYXRhKHBzeU91dENoYW4tPnNmYkVuZXJneUxkRGF0YVtzZmJdPj4xKTsgICAvKiBucmdeKDEvMikgKi8KICAgICAgICAgICAgICAgIEZJWFBfREJMIG5yZ0ZhYzE0ID0gQ2FsY0ludkxkRGF0YShwc3lPdXRDaGFuLT5zZmJFbmVyZ3lMZERhdGFbc2ZiXT4+Mik7ICAgLyogbnJnXigxLzQpICovCgogICAgICAgICAgICAgICAgLyogbWF4aW1hbCBudW1iZXIgb2YgYmFuZHMgaXMgNjQsIHJlc3VsdHMgc2NhbGluZyBmYWN0b3IgNiAqLwogICAgICAgICAgICAgICAgbkxpbmVzU3VtICs9IHBlRGF0YS0+cGVDaGFubmVsRGF0YVtjaF0uc2ZiTkxpbmVzW3NmYl07ICAgICAgICAgICAgICAgICAgICAvKiByZWxldmFudCBsaW5lcyAqLwogICAgICAgICAgICAgICAgbnJnVG90YWwgICs9ICggcHN5T3V0Q2hhbi0+c2ZiRW5lcmd5W3NmYl0gPj4gNiApOyAgICAgICAgICAgICAgICAgICAgICAgICAvKiBzdW0gdXAgbnJnICovCiAgICAgICAgICAgICAgICBucmdTdW0xMiAgKz0gKCBucmdGYWMxMiA+PiA2ICk7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIHN1bSB1cCBucmdeKDIvNCkgKi8KICAgICAgICAgICAgICAgIG5yZ1N1bTE0ICArPSAoIG5yZ0ZhYzE0ID4+IDYgKTsgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogc3VtIHVwIG5yZ14oMS80KSAqLwogICAgICAgICAgICAgICAgbnJnU3VtMzQgICs9ICggZk11bHQobnJnRmFjMTQsIG5yZ0ZhYzEyKSA+PiA2ICk7ICAgICAgICAgICAgICAgICAgICAgICAgICAvKiBzdW0gdXAgbnJnXigzLzQpICovCiAgICAgICAgICAgIH0KCiAgICAgICAgICAgIG5yZ1RvdGFsID0gQ2FsY0xkRGF0YShucmdUb3RhbCk7ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC8qIGdldCBsZDY0IG9mIHRvdGFsIG5yZyAqLwoKICAgICAgICAgICAgbnJnRmFjTGRfMTQgPSBDYWxjTGREYXRhKG5yZ1N1bTE0KSAtIG5yZ1RvdGFsOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogbGQ2NChucmdTdW0xNC9ucmdUb3RhbCkgKi8KICAgICAgICAgICAgbnJnRmFjTGRfMTIgPSBDYWxjTGREYXRhKG5yZ1N1bTEyKSAtIG5yZ1RvdGFsOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogbGQ2NChucmdTdW0xMi9ucmdUb3RhbCkgKi8KICAgICAgICAgICAgbnJnRmFjTGRfMzQgPSBDYWxjTGREYXRhKG5yZ1N1bTM0KSAtIG5yZ1RvdGFsOyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLyogbGQ2NChucmdTdW0zNC9ucmdUb3RhbCkgKi8KCiAgICAgICAgICAgIGFkalRoclN0YXRlRWxlbWVudC0+Y2hhb3NNZWFzdXJlRW5GYWNbY2hdID0gRkRLbWF4KCBGTDJGWENPTlNUX0RCTCgwLjE4NzVmKSwgZkRpdk5vcm0obkxpbmVzU3VtLHBzeU91dENoYW4tPnNmYk9mZnNldHNbcHN5T3V0Q2hhbi0+c2ZiQ250XSkgKTsKCiAgICAgICAgICAgIHVzZVBhdGNoID0gKGFkalRoclN0YXRlRWxlbWVudC0+Y2hhb3NNZWFzdXJlRW5GYWNbY2hdID4gRkwyRlhDT05TVF9EQkwoMC43ODEyNWYpKTsKICAgICAgICAgICAgZXhlUGF0Y2ggPSAoKHVzZVBhdGNoKSAmJiAoYWRqVGhyU3RhdGVFbGVtZW50LT5sYXN0RW5GYWNQYXRjaFtjaF0pKTsKCiAgICAgICAgICAgIGZvciAoc2ZiID0gMDsgc2ZiIDwgcHN5T3V0Q2hhbi0+c2ZiQ250OyBzZmIrKykgewogICAgICAgICAgICAgICAgSU5UIHNmYkV4ZVBhdGNoOwoKICAgICAgICAgICAgICAgIC8qIGZvciBNUyBjb3VwbGVkIFNGQnMsIGFsc28gZXhlY3V0ZSBwYXRjaCBpbiBzaWRlIGNoYW5uZWwgaWYgZG9uZSBpbiBtaWQgY2hhbm5lbCAqLwogICAgICAgICAgICAgICAgaWYgKChjaCA9PSAxKSAmJiAodG9vbHNJbmZvLT5tc01hc2tbc2ZiXSkpIHsKICAgICAgICAgICAgICAgICAgICBzZmJFeGVQYXRjaCA9IGV4ZVBhdGNoTTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIGVsc2UgewogICAgICAgICAgICAgICAgICAgIHNmYkV4ZVBhdGNoID0gZXhlUGF0Y2g7CiAgICAgICAgICAgICAgICB9CgogICAgICAgICAgICAgICAgaWYgKCAoc2ZiRXhlUGF0Y2gpICYmIChwc3lPdXRDaGFuLT5zZmJFbmVyZ3lbc2ZiXT5GTDJGWENPTlNUX0RCTCgwLmYpKSApCiAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICAgLyogZXhlY3V0ZSBwYXRjaCBiYXNlZCBvbiBzcGVjdHJhbCBmbGF0bmVzcyBjYWxjdWxhdGVkIGFib3ZlICovCiAgICAgICAgICAgICAgICAgICAgaWYgKGFkalRoclN0YXRlRWxlbWVudC0+Y2hhb3NNZWFzdXJlRW5GYWNbY2hdID4gRkwyRlhDT05TVF9EQkwoMC44MTI1ZikpIHsKICAgICAgICAgICAgICAgICAgICAgICAgcWNPdXRDaGFubmVsW2NoXS0+c2ZiRW5GYWNMZFtzZmJdID0gKCAobnJnRmFjTGRfMTQgKyAocHN5T3V0Q2hhbi0+c2ZiRW5lcmd5TGREYXRhW3NmYl0rKHBzeU91dENoYW4tPnNmYkVuZXJneUxkRGF0YVtzZmJdPj4xKSkpPj4xICk7IC8qIHNmYkVuZXJneV4oMy80KSAqLwogICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICBlbHNlIGlmIChhZGpUaHJTdGF0ZUVsZW1lbnQtPmNoYW9zTWVhc3VyZUVuRmFjW2NoXSA+IEZMMkZYQ09OU1RfREJMKDAuNzk2ODc1ZikpIHsKICAgICAgICAgICAgICAgICAgICAgICAgcWNPdXRDaGFubmVsW2NoXS0+c2ZiRW5GYWNMZFtzZmJdID0gKCAobnJnRmFjTGRfMTIgKyBwc3lPdXRDaGFuLT5zZmJFbmVyZ3lMZERhdGFbc2ZiXSk+PjEgKTsgICAgICAgICAgLyogc2ZiRW5lcmd5XigyLzQpICovCiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgIGVsc2UgewogICAgICAgICAgICAgICAgICAgICAgICBxY091dENoYW5uZWxbY2hdLT5zZmJFbkZhY0xkW3NmYl0gPSAoIChucmdGYWNMZF8zNCArIChwc3lPdXRDaGFuLT5zZmJFbmVyZ3lMZERhdGFbc2ZiXT4+MSkpPj4xICk7ICAgICAvKiBzZmJFbmVyZ3leKDEvNCkgKi8KICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICAgcWNPdXRDaGFubmVsW2NoXS0+c2ZiRW5GYWNMZFtzZmJdID0gZml4TWluKHFjT3V0Q2hhbm5lbFtjaF0tPnNmYkVuRmFjTGRbc2ZiXSwoRklYUF9EQkwpMCk7CgogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9IC8qIHNmYiBsb29wICovCgogICAgICAgICAgICBhZGpUaHJTdGF0ZUVsZW1lbnQtPmxhc3RFbkZhY1BhdGNoW2NoXSA9IHVzZVBhdGNoOwogICAgICAgICAgICBleGVQYXRjaE0gPSBleGVQYXRjaDsKICAgICAgICB9CiAgICAgICAgZWxzZSB7CiAgICAgICAgICAgIC8qICFub1Nob3J0V2luZG93SW5GcmFtZSAqLwogICAgICAgICAgICBhZGpUaHJTdGF0ZUVsZW1lbnQtPmNoYW9zTWVhc3VyZUVuRmFjW2NoXSA9IEZMMkZYQ09OU1RfREJMKDAuNzVmKTsKICAgICAgICAgICAgYWRqVGhyU3RhdGVFbGVtZW50LT5sYXN0RW5GYWNQYXRjaFtjaF0gPSBUUlVFOyAvKiBhbGxvdyB1c2Ugb2Ygc2ZiRW5GYWMgcGF0Y2ggaW4gdXBjb21pbmcgZnJhbWUgKi8KICAgICAgICB9CgogICAgfSAvKiBjaCBsb29wICovCgp9CgoKCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKZnVuY3Rpb25uYW1lOiBGREthYWNFbmNfY2FsY1BlCmRlc2NyaXB0aW9uOiAgY2FsY3VsYXRlIHBlIGZvciBib3RoIGNoYW5uZWxzCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwpzdGF0aWMKdm9pZCBGREthYWNFbmNfY2FsY1BlKFBTWV9PVVRfQ0hBTk5FTCogcHN5T3V0Q2hhbm5lbFsoMildLAogICAgICAgICAgICBRQ19PVVRfQ0hBTk5FTCogcWNPdXRDaGFubmVsWygyKV0sCiAgICAgICAgICAgIFBFX0RBVEEgKnBlRGF0YSwKICAgICAgICAgICAgY29uc3QgSU5UIG5DaGFubmVscykKewogICBJTlQgY2g7CgogICBwZURhdGEtPnBlID0gcGVEYXRhLT5vZmZzZXQ7CiAgIHBlRGF0YS0+Y29uc3RQYXJ0ID0gMDsKICAgcGVEYXRhLT5uQWN0aXZlTGluZXMgPSAwOwogICBmb3IoY2g9MDsgY2g8bkNoYW5uZWxzOyBjaCsrKSB7CiAgICAgIFBFX0NIQU5ORUxfREFUQSAqcGVDaGFuRGF0YSA9ICZwZURhdGEtPnBlQ2hhbm5lbERhdGFbY2hdOwogICAgICBGREthYWNFbmNfY2FsY1NmYlBlKCZwZURhdGEtPnBlQ2hhbm5lbERhdGFbY2hdLAogICAgICAgICAgICAgICAgcWNPdXRDaGFubmVsW2NoXS0+c2ZiV2VpZ2h0ZWRFbmVyZ3lMZERhdGEsCiAgICAgICAgICAgICAgICBxY091dENoYW5uZWxbY2hdLT5zZmJUaHJlc2hvbGRMZERhdGEsCiAgICAgICAgICAgICAgICBwc3lPdXRDaGFubmVsW2NoXS0+c2ZiQ250LAogICAgICAgICAgICAgICAgcHN5T3V0Q2hhbm5lbFtjaF0tPnNmYlBlckdyb3VwLAogICAgICAgICAgICAgICAgcHN5T3V0Q2hhbm5lbFtjaF0tPm1heFNmYlBlckdyb3VwLAogICAgICAgICAgICAgICAgcHN5T3V0Q2hhbm5lbFtjaF0tPmlzQm9vaywKICAgICAgICAgICAgICAgIHBzeU91dENoYW5uZWxbY2hdLT5pc1NjYWxlKTsKCiAgICAgIHBlRGF0YS0+cGUgKz0gcGVDaGFuRGF0YS0+cGU7CiAgICAgIHBlRGF0YS0+Y29uc3RQYXJ0ICs9IHBlQ2hhbkRhdGEtPmNvbnN0UGFydDsKICAgICAgcGVEYXRhLT5uQWN0aXZlTGluZXMgKz0gcGVDaGFuRGF0YS0+bkFjdGl2ZUxpbmVzOwogICB9Cn0KCnZvaWQgRkRLYWFjRW5jX3BlQ2FsY3VsYXRpb24oUEVfREFUQSAqcGVEYXRhLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBTWV9PVVRfQ0hBTk5FTCogcHN5T3V0Q2hhbm5lbFsoMildLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgIFFDX09VVF9DSEFOTkVMKiBxY091dENoYW5uZWxbKDIpXSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzdHJ1Y3QgVE9PTFNJTkZPICp0b29sc0luZm8sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQVRTX0VMRU1FTlQqIGFkalRoclN0YXRlRWxlbWVudCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBJTlQgbkNoYW5uZWxzKQp7CiAgLyogY29uc3RhbnRzIHRoYXQgd2lsbCBub3QgY2hhbmdlIGR1cmluZyBzdWNjZXNzaXZlIHBlIGNhbGN1bGF0aW9ucyAqLwogIEZES2FhY0VuY19wcmVwYXJlUGUocGVEYXRhLCBwc3lPdXRDaGFubmVsLCBxY091dENoYW5uZWwsIG5DaGFubmVscywgYWRqVGhyU3RhdGVFbGVtZW50LT5wZU9mZnNldCk7CgogIC8qIGNhbGN1bGF0ZSB3ZWlnaHRpbmcgZmFjdG9yIGZvciB0aHJlc2hvbGQgYWRqdXN0bWVudCAqLwogIEZES2FhY0VuY19jYWxjV2VpZ2h0aW5nKHBlRGF0YSwgcHN5T3V0Q2hhbm5lbCwgcWNPdXRDaGFubmVsLCB0b29sc0luZm8sIGFkalRoclN0YXRlRWxlbWVudCwgbkNoYW5uZWxzLCAxKTsKewogICAgLyogbm8gd2VpZ2h0aW5nIG9mIHRocmVob2xkcyBhbmQgZW5lcmdpZXMgZm9yIG1sb3V0ICovCiAgICAvKiB3ZWlnaHQgZW5lcmdpZXMgYW5kIHRocmVzaG9sZHMgKi8KICAgIGludCBjaDsKICAgIGZvciAoY2g9MDsgY2g8bkNoYW5uZWxzOyBjaCsrKSB7CgogICAgICAgIGludCBzZmIsIHNmYkdycDsKICAgICAgICBRQ19PVVRfQ0hBTk5FTCogcFFjT3V0Q2ggPSBxY091dENoYW5uZWxbY2hdOwoKICAgICAgICBmb3IgKHNmYkdycCA9IDA7c2ZiR3JwIDwgcHN5T3V0Q2hhbm5lbFtjaF0tPnNmYkNudDsgc2ZiR3JwKz1wc3lPdXRDaGFubmVsW2NoXS0+c2ZiUGVyR3JvdXApIHsKICAgICAgICAgIGZvciAoc2ZiPTA7IHNmYjxwc3lPdXRDaGFubmVsW2NoXS0+bWF4U2ZiUGVyR3JvdXA7IHNmYisrKSB7CiAgICAgICAgICAgIHBRY091dENoLT5zZmJXZWlnaHRlZEVuZXJneUxkRGF0YVtzZmIrc2ZiR3JwXSA9IHBRY091dENoLT5zZmJFbmVyZ3lMZERhdGFbc2ZiK3NmYkdycF0gLSBwUWNPdXRDaC0+c2ZiRW5GYWNMZFtzZmIrc2ZiR3JwXTsKICAgICAgICAgICAgcFFjT3V0Q2gtPnNmYlRocmVzaG9sZExkRGF0YVtzZmIrc2ZiR3JwXSAgICAgLT0gcFFjT3V0Q2gtPnNmYkVuRmFjTGRbc2ZiK3NmYkdycF07CiAgICAgICAgICB9CiAgICAgICAgfQogICAgfQp9CgogIC8qIHBlIHdpdGhvdXQgcmVkdWN0aW9uICovCiAgRkRLYWFjRW5jX2NhbGNQZShwc3lPdXRDaGFubmVsLCBxY091dENoYW5uZWwsIHBlRGF0YSwgbkNoYW5uZWxzKTsKfQoKCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKZnVuY3Rpb25uYW1lOiBGREthYWNFbmNfRkRLYWFjRW5jX2NhbGNQZU5vQUgKZGVzY3JpcHRpb246ICBzdW0gdGhlIHBlIGRhdGEgb25seSBmb3IgYmFuZHMgd2hlcmUgYXZvaWQgaG9sZSBpcyBpbmFjdGl2ZQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8Kc3RhdGljIHZvaWQgRkRLYWFjRW5jX0ZES2FhY0VuY19jYWxjUGVOb0FIKElOVCAqcGUsCiAgICAgICAgICAgICAgICAgICAgICAgSU5UICpjb25zdFBhcnQsCiAgICAgICAgICAgICAgICAgICAgICAgSU5UICAgICpuQWN0aXZlTGluZXMsCiAgICAgICAgICAgICAgICAgICAgICAgUEVfREFUQSAqcGVEYXRhLAogICAgICAgICAgICAgICAgICAgICAgIFVDSEFSIGFoRmxhZ1soMildW01BWF9HUk9VUEVEX1NGQl0sCiAgICAgICAgICAgICAgICAgICAgICAgUFNZX09VVF9DSEFOTkVMKiBwc3lPdXRDaGFubmVsWygyKV0sCiAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgSU5UIG5DaGFubmVscykKewogICAgSU5UIGNoLCBzZmIsc2ZiR3JwOwoKICAgIElOVCBwZV90bXAgPSBwZURhdGEtPm9mZnNldDsKICAgIElOVCBjb25zdFBhcnRfdG1wID0gMDsKICAgIElOVCBuQWN0aXZlTGluZXNfdG1wID0gMDsKICAgIGZvcihjaD0wOyBjaDxuQ2hhbm5lbHM7IGNoKyspIHsKICAgICAgICBQRV9DSEFOTkVMX0RBVEEgKnBlQ2hhbkRhdGEgPSAmcGVEYXRhLT5wZUNoYW5uZWxEYXRhW2NoXTsKICAgICAgICBmb3Ioc2ZiR3JwID0gMDtzZmJHcnAgPCBwc3lPdXRDaGFubmVsW2NoXS0+c2ZiQ250O3NmYkdycCs9IHBzeU91dENoYW5uZWxbY2hdLT5zZmJQZXJHcm91cCl7CiAgICAgICAgICAgIGZvciAoc2ZiPTA7IHNmYjxwc3lPdXRDaGFubmVsW2NoXS0+bWF4U2ZiUGVyR3JvdXA7IHNmYisrKSB7CiAgICAgICAgICAgICAgICBpZihhaEZsYWdbY2hdW3NmYkdycCtzZmJdIDwgQUhfQUNUSVZFKSB7CiAgICAgICAgICAgICAgICAgICAgcGVfdG1wICs9IHBlQ2hhbkRhdGEtPnNmYlBlW3NmYkdycCtzZmJdOwogICAgICAgICAgICAgICAgICAgIGNvbnN0UGFydF90bXAgKz0gcGVDaGFuRGF0YS0+c2ZiQ29uc3RQYXJ0W3NmYkdycCtzZmJdOwogICAgICAgICAgICAgICAgICAgIG5BY3RpdmVMaW5lc190bXAgKz0gcGVDaGFuRGF0YS0+c2ZiTkFjdGl2ZUxpbmVzW3NmYkdycCtzZmJdOwogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CiAgICAgICAgfQogICAgfQogICAgLyogY29ycmVjdCBzY2FsZWQgcGUgYW5kIGNvbnN0UGFydCB2YWx1ZXMgKi8KICAgICpwZSA9IHBlX3RtcCA+PiBQRV9DT05TVFBBUlRfU0hJRlQ7CiAgICAqY29uc3RQYXJ0ID0gY29uc3RQYXJ0X3RtcCA+PiBQRV9DT05TVFBBUlRfU0hJRlQ7CgoJKm5BY3RpdmVMaW5lcyA9IG5BY3RpdmVMaW5lc190bXA7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKZnVuY3Rpb25uYW1lOiBGREthYWNFbmNfcmVkdWNlVGhyZXNob2xkc0NCUgpkZXNjcmlwdGlvbjogIGFwcGx5IHJlZHVjdGlvbiBmb3JtdWxhCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwpzdGF0aWMgY29uc3QgRklYUF9EQkwgbGltaXRUaHJSZWR1Y2VkTGREYXRhID0gKEZJWFBfREJMKTB4MDAwMDgwMDA7IC8qRkwyRlhDT05TVF9EQkwoRkRLcG93KDIuMCwtTERfREFUQV9TQ0FMSU5HLzQuMCkpOyovCgpzdGF0aWMgdm9pZCBGREthYWNFbmNfcmVkdWNlVGhyZXNob2xkc0NCUihRQ19PVVRfQ0hBTk5FTCogIHFjT3V0Q2hhbm5lbFsoMildLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBTWV9PVVRfQ0hBTk5FTCogcHN5T3V0Q2hhbm5lbFsoMildLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVDSEFSIGFoRmxhZ1soMildW01BWF9HUk9VUEVEX1NGQl0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgRklYUF9EQkwgdGhyRXhwWygyKV1bTUFYX0dST1VQRURfU0ZCXSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBJTlQgbkNoYW5uZWxzLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IEZJWFBfREJMIHJlZFZhbCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBTQ0hBUiByZWRWYWxTY2FsaW5nKQp7CiAgIElOVCBjaCwgc2ZiLCBzZmJHcnA7CiAgIEZJWFBfREJMIHNmYkVuTGREYXRhLCBzZmJUaHJMZERhdGEsIHNmYlRoclJlZHVjZWRMZERhdGE7CiAgIEZJWFBfREJMIHNmYlRockV4cDsKCiAgICBmb3IoY2g9MDsgY2g8bkNoYW5uZWxzOyBjaCsrKSB7CiAgICAgIFFDX09VVF9DSEFOTkVMICpxY091dENoYW4gPSBxY091dENoYW5uZWxbY2hdOwogICAgICBmb3Ioc2ZiR3JwID0gMDsgc2ZiR3JwIDwgcHN5T3V0Q2hhbm5lbFtjaF0tPnNmYkNudDsgc2ZiR3JwKz0gcHN5T3V0Q2hhbm5lbFtjaF0tPnNmYlBlckdyb3VwKXsKICAgICAgICBmb3IgKHNmYj0wOyBzZmI8cHN5T3V0Q2hhbm5lbFtjaF0tPm1heFNmYlBlckdyb3VwOyBzZmIrKykgewogICAgICAgICBzZmJFbkxkRGF0YSAgPSBxY091dENoYW4tPnNmYldlaWdodGVkRW5lcmd5TGREYXRhW3NmYkdycCtzZmJdOwogICAgICAgICBzZmJUaHJMZERhdGEgPSBxY091dENoYW4tPnNmYlRocmVzaG9sZExkRGF0YVtzZmJHcnArc2ZiXTsKICAgICAgICAgc2ZiVGhyRXhwICAgID0gdGhyRXhwW2NoXVtzZmJHcnArc2ZiXTsKICAgICAgICAgaWYgKChzZmJFbkxkRGF0YSA+IHNmYlRockxkRGF0YSkgJiYgKGFoRmxhZ1tjaF1bc2ZiR3JwK3NmYl0gIT0gQUhfQUNUSVZFKSkgewoKICAgICAgICAgICAgLyogdGhyZXNob2xkIHJlZHVjdGlvbiBmb3JtdWxhOgogICAgICAgICAgICAgZmxvYXQgdG1wID0gdGhyRXhwW2NoXVtzZmJdK3JlZFZhbDsKICAgICAgICAgICAgIHRtcCAqPSB0bXA7CiAgICAgICAgICAgICBzZmJUaHJSZWR1Y2VkID0gdG1wKnRtcDsKICAgICAgICAgICAgKi8KICAgICAgICAgICAgaW50IG1pblNjYWxlID0gZml4TWluKENvdW50TGVhZGluZ0JpdHMoc2ZiVGhyRXhwKSwgQ291bnRMZWFkaW5nQml0cyhyZWRWYWwpIC0gKERGUkFDVF9CSVRTLTEtcmVkVmFsU2NhbGluZykgKS0xOwoKICAgICAgICAgICAgLyogNCpsb2coIHNmYlRockV4cCArIHJlZFZhbCApICovCiAgICAgICAgICAgIHNmYlRoclJlZHVjZWRMZERhdGEgPSBDYWxjTGREYXRhKGZBYnMoc2NhbGVWYWx1ZShzZmJUaHJFeHAsIG1pblNjYWxlKSArIHNjYWxlVmFsdWUocmVkVmFsLChERlJBQ1RfQklUUy0xLXJlZFZhbFNjYWxpbmcpK21pblNjYWxlKSkpCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIC0gKEZJWFBfREJMKShtaW5TY2FsZTw8KERGUkFDVF9CSVRTLTEtTERfREFUQV9TSElGVCkpOwogICAgICAgICAgICBzZmJUaHJSZWR1Y2VkTGREYXRhIDw8PSAyOwoKICAgICAgICAgICAgLyogYXZvaWQgaG9sZXMgKi8KICAgICAgICAgICAgaWYgKCAoKHNmYlRoclJlZHVjZWRMZERhdGEgLSBzZmJFbkxkRGF0YSkgPiBxY091dENoYW4tPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXSApCiAgICAgICAgICAgICAgICAgICAgJiYgKGFoRmxhZ1tjaF1bc2ZiR3JwK3NmYl0gIT0gTk9fQUgpICkKICAgICAgICAgICAgewogICAgICAgICAgICAgIGlmIChxY091dENoYW4tPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXSAgPiAoRkwyRlhDT05TVF9EQkwoLTEuMGYpIC0gc2ZiRW5MZERhdGEpICl7CiAgICAgICAgICAgICAgICAgICBzZmJUaHJSZWR1Y2VkTGREYXRhID0gZml4TWF4KChxY091dENoYW4tPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXSArIHNmYkVuTGREYXRhKSwgc2ZiVGhyTGREYXRhKTsKICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgZWxzZSBzZmJUaHJSZWR1Y2VkTGREYXRhID0gc2ZiVGhyTGREYXRhOwogICAgICAgICAgICAgIGFoRmxhZ1tjaF1bc2ZiR3JwK3NmYl0gPSBBSF9BQ1RJVkU7CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgIC8qIG1pbmltdW0gb2YgMjkgZEIgUmF0aW8gZm9yIFRocmVzaG9sZHMgKi8KICAgICAgICAgICAgaWYgKChzZmJFbkxkRGF0YSsoRklYUF9EQkwpTUFYVkFMX0RCTCkgPiBGTDJGWENPTlNUX0RCTCg5LjYzMzYyMDYvTERfREFUQV9TQ0FMSU5HKSl7CiAgICAgICAgICAgICAgICBzZmJUaHJSZWR1Y2VkTGREYXRhID0gZml4TWF4KHNmYlRoclJlZHVjZWRMZERhdGEsIChzZmJFbkxkRGF0YSAtIEZMMkZYQ09OU1RfREJMKDkuNjMzNjIwNi9MRF9EQVRBX1NDQUxJTkcpKSk7CiAgICAgICAgICAgIH0KCiAgICAgICAgICAgIHFjT3V0Q2hhbi0+c2ZiVGhyZXNob2xkTGREYXRhW3NmYkdycCtzZmJdID0gc2ZiVGhyUmVkdWNlZExkRGF0YTsKICAgICAgICAgfQogICAgICAgIH0KICAgICAgfQogICB9Cn0KCi8qIHNpbWlsYXIgdG8gcHJlcGFyZVNmYlBlMSgpICovCnN0YXRpYyBGSVhQX0RCTCBGREthYWNFbmNfY2FsY0NoYW9zTWVhc3VyZShQU1lfT1VUX0NIQU5ORUwgKnBzeU91dENoYW5uZWwsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IEZJWFBfREJMICAqc2ZiRm9ybUZhY3RvckxkRGF0YSkKewogICNkZWZpbmUgU0NBTEVfRk9STV9GQUMgICAgICg0KSAgICAvKiAoU0NBTEVfRk9STV9GQUMrRk9STV9GQUNfU0hJRlQpID49IGxkKEZSQU1FX0xFTkdUSCkqLwogICNkZWZpbmUgU0NBTEVfTlJHUyAgICAgICAgICg4KQogICNkZWZpbmUgU0NBTEVfTkxJTkVTICAgICAgKDE2KQogICNkZWZpbmUgU0NBTEVfTlJHU19TUVJUNCAgICgyKSAgICAvKiAwLjI1ICogU0NBTEVfTlJHUyAqLwogICNkZWZpbmUgU0NBTEVfTkxJTkVTX1AzNCAgKDEyKSAgICAvKiAwLjc1ICogU0NBTEVfTkxJTkVTICovCgogIElOVCAgIHNmYkdycCwgc2ZiOwogIEZJWFBfREJMIGNoYW9zTWVhc3VyZTsKICBJTlQgZnJhbWVOTGluZXMgPSAwOwogIEZJWFBfREJMIGZyYW1lRm9ybUZhY3RvciA9IEZMMkZYQ09OU1RfREJMKDAuZik7CiAgRklYUF9EQkwgZnJhbWVFbmVyZ3kgPSBGTDJGWENPTlNUX0RCTCgwLmYpOwoKICBmb3IgKHNmYkdycD0wOyBzZmJHcnA8cHN5T3V0Q2hhbm5lbC0+c2ZiQ250OyBzZmJHcnArPXBzeU91dENoYW5uZWwtPnNmYlBlckdyb3VwKSB7CiAgICBmb3IgKHNmYj0wOyBzZmI8cHN5T3V0Q2hhbm5lbC0+bWF4U2ZiUGVyR3JvdXA7IHNmYisrKXsKICAgICAgaWYgKHBzeU91dENoYW5uZWwtPnNmYkVuZXJneUxkRGF0YVtzZmJHcnArc2ZiXSA+IHBzeU91dENoYW5uZWwtPnNmYlRocmVzaG9sZExkRGF0YVtzZmJHcnArc2ZiXSkgewogICAgICAgIGZyYW1lRm9ybUZhY3RvciArPSAoQ2FsY0ludkxkRGF0YShzZmJGb3JtRmFjdG9yTGREYXRhW3NmYkdycCtzZmJdKT4+U0NBTEVfRk9STV9GQUMpOwogICAgICAgIGZyYW1lTkxpbmVzICAgICArPSAocHN5T3V0Q2hhbm5lbC0+c2ZiT2Zmc2V0c1tzZmJHcnArc2ZiKzFdIC0gcHN5T3V0Q2hhbm5lbC0+c2ZiT2Zmc2V0c1tzZmJHcnArc2ZiXSk7CiAgICAgICAgZnJhbWVFbmVyZ3kgICAgICs9IChwc3lPdXRDaGFubmVsLT5zZmJFbmVyZ3lbc2ZiR3JwK3NmYl0+PlNDQUxFX05SR1MpOwogICAgICB9CiAgICB9CiAgfQoKICBpZihmcmFtZU5MaW5lcyA+IDApewoKICAgIC8qICBmcmFtZU5BY3RpdmVMaW5lcyA9IGZyYW1lRm9ybUZhY3RvcioyXkZPUk1fRkFDX1NISUZUICogKChmcmFtZUVuZXJneSAqMl5TQ0FMRV9OUkdTKS9mcmFtZU5MaW5lcyleLTAuMjUKICAgICAgICBjaGFvc01lYXN1cmUgICAgICA9IGZyYW1lTkFjdGl2ZUxpbmVzIC8gZnJhbWVOTGluZXMgKi8KICAgIGNoYW9zTWVhc3VyZSA9CiAgICAgICAgICAgQ2FsY0ludkxkRGF0YSggKCgoQ2FsY0xkRGF0YShmcmFtZUZvcm1GYWN0b3IpPj4xKSAtCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAoQ2FsY0xkRGF0YShmcmFtZUVuZXJneSk+PigyKzEpKSkgLQogICAgICAgICAgICAgICAgICAgICAgICAgICAoZk11bHREaXYyKEZMMkZYQ09OU1RfREJMKDAuNzVmKSxDYWxjTGREYXRhKChGSVhQX0RCTClmcmFtZU5MaW5lczw8KERGUkFDVF9CSVRTLTEtU0NBTEVfTkxJTkVTKSkpIC0KICAgICAgICAgICAgICAgICAgICAgICAgICAgICgoKEZJWFBfREJMKShTQ0FMRV9GT1JNX0ZBQy1TQ0FMRV9OUkdTX1NRUlQ0K0ZPUk1fRkFDX1NISUZULShTQ0FMRV9OTElORVNfUDM0KSk8PChERlJBQ1RfQklUUy0xLUxEX0RBVEFfU0hJRlQpKT4+MSkpCiAgICAgICAgICAgICAgICAgICAgICAgICAgKTw8MSApOwogIH0gZWxzZSB7CgogICAgLyogYXNzdW1pbmcgdG90YWwgY2hhb3MsIGlmIG5vIHNmYiBpcyBhYm92ZSB0aHJlc2hvbGRzICovCiAgICBjaGFvc01lYXN1cmUgPSBGTDJGWENPTlNUX0RCTCgxLmYpOwogIH0KCiAgcmV0dXJuIGNoYW9zTWVhc3VyZTsKfQoKCi8qIGFwcGx5IHJlZHVjdGlvbiBmb3JtdWxhIGZvciBWQlItbW9kZSAqLwpzdGF0aWMgdm9pZCBGREthYWNFbmNfcmVkdWNlVGhyZXNob2xkc1ZCUihRQ19PVVRfQ0hBTk5FTCogcWNPdXRDaGFubmVsWygyKV0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUFNZX09VVF9DSEFOTkVMKiBwc3lPdXRDaGFubmVsWygyKV0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVUNIQVIgYWhGbGFnWygyKV1bTUFYX0dST1VQRURfU0ZCXSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBGSVhQX0RCTCB0aHJFeHBbKDIpXVtNQVhfR1JPVVBFRF9TRkJdLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IElOVCBuQ2hhbm5lbHMsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgRklYUF9EQkwgIHZiclF1YWxGYWN0b3IsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgRklYUF9EQkwqIGNoYW9zTWVhc3VyZU9sZCkKewogIElOVCBjaCwgc2ZiR3JwLCBzZmI7CiAgRklYUF9EQkwgY2hHcm91cEVuZXJneVtUUkFOU19GQUNdWzJdOy8qZW5lcmd5IGZvciBlYWNoIGdyb3VwIGFuZCBjaGFubmVsKi8KICBGSVhQX0RCTCBjaENoYW9zTWVhc3VyZVsyXTsKICBGSVhQX0RCTCBmcmFtZUVuZXJneSA9IEZMMkZYQ09OU1RfREJMKDFlLTEwZik7CiAgRklYUF9EQkwgY2hhb3NNZWFzdXJlID0gRkwyRlhDT05TVF9EQkwoMC5mKTsKICBGSVhQX0RCTCBzZmJFbkxkRGF0YSwgc2ZiVGhyTGREYXRhLCBzZmJUaHJFeHA7CiAgRklYUF9EQkwgc2ZiVGhyUmVkdWNlZExkRGF0YTsKICBGSVhQX0RCTCBjaGFvc01lYXN1cmVBdmc7CiAgSU5UIGdyb3VwQ250OyAvKiBsb29wIGNvdW50ZXIgKi8KICBGSVhQX0RCTCByZWRWYWxbVFJBTlNfRkFDXTsgLyogcmVkdWN0aW9uIHZhbHVlczsgaW4gc2hvcnQtYmxvY2sgY2FzZSBvbmUgcmVkVmFsIGZvciBlYWNoIGdyb3VwICovCiAgUUNfT1VUX0NIQU5ORUwgICpxY091dENoYW4gID0gTlVMTDsKICBQU1lfT1VUX0NIQU5ORUwgICpwc3lPdXRDaGFuICA9IE5VTEw7CgojZGVmaW5lIFNDQUxFX0dST1VQX0VORVJHWSAgICg4KQoKI2RlZmluZSBDT05TVF9DSEFPU19NRUFTX0FWR19GQUNfMCAgKEZMMkZYQ09OU1RfREJMKDAuMjVmKSkKI2RlZmluZSBDT05TVF9DSEFPU19NRUFTX0FWR19GQUNfMSAgKEZMMkZYQ09OU1RfREJMKDEuZi0wLjI1ZikpCgojZGVmaW5lIE1JTl9MRFRIUkVTSCAgICAgICAgICAgICAgICAoRkwyRlhDT05TVF9EQkwoLTAuNTE1NjI1ZikpCgoKICBmb3IoY2g9MDsgY2g8bkNoYW5uZWxzOyBjaCsrKXsKICAgIHFjT3V0Q2hhbiAgPSBxY091dENoYW5uZWxbY2hdOwogICAgcHN5T3V0Q2hhbiAgPSBwc3lPdXRDaGFubmVsW2NoXTsKCiAgICAvKiBhZGRpbmcgdXAgZW5lcmd5IGZvciBlYWNoIGNoYW5uZWwgYW5kIGVhY2ggZ3JvdXAgc2VwYXJhdGVseSAqLwogICAgRklYUF9EQkwgY2hFbmVyZ3kgPSBGTDJGWENPTlNUX0RCTCgwLmYpOwogICAgZ3JvdXBDbnQ9MDsKCiAgICBmb3IgKHNmYkdycD0wOyBzZmJHcnA8cHN5T3V0Q2hhbi0+c2ZiQ250OyBzZmJHcnArPXBzeU91dENoYW4tPnNmYlBlckdyb3VwLCBncm91cENudCsrKSB7CiAgICAgIGNoR3JvdXBFbmVyZ3lbZ3JvdXBDbnRdW2NoXSA9IEZMMkZYQ09OU1RfREJMKDAuZik7CiAgICAgIGZvciAoc2ZiPTA7IHNmYjxwc3lPdXRDaGFuLT5tYXhTZmJQZXJHcm91cDsgc2ZiKyspewogICAgICAgIGNoR3JvdXBFbmVyZ3lbZ3JvdXBDbnRdW2NoXSArPSAocHN5T3V0Q2hhbi0+c2ZiRW5lcmd5W3NmYkdycCtzZmJdPj5TQ0FMRV9HUk9VUF9FTkVSR1kpOwogICAgICB9CiAgICAgIGNoRW5lcmd5ICs9IGNoR3JvdXBFbmVyZ3lbZ3JvdXBDbnRdW2NoXTsKICAgIH0KICAgIGZyYW1lRW5lcmd5ICs9IGNoRW5lcmd5OwoKICAgIC8qIGNoYW9zTWVhc3VyZSAqLwogICAgaWYgKHBzeU91dENoYW5uZWxbMF0tPmxhc3RXaW5kb3dTZXF1ZW5jZSA9PSBTSE9SVF9XSU5ET1cpIHsKICAgICAgY2hDaGFvc01lYXN1cmVbY2hdID0gRkwyRlhDT05TVF9EQkwoMC41Zik7IC8qIGFzc3VtZSBhIGNvbnN0YW50IGNoYW9zIG1lYXN1cmUgb2YgMC41ZiBmb3Igc2hvcnQgYmxvY2tzICovCiAgICB9IGVsc2UgewogICAgICBjaENoYW9zTWVhc3VyZVtjaF0gPSBGREthYWNFbmNfY2FsY0NoYW9zTWVhc3VyZShwc3lPdXRDaGFubmVsW2NoXSwgcWNPdXRDaGFubmVsW2NoXS0+c2ZiRm9ybUZhY3RvckxkRGF0YSk7CiAgICB9CiAgICBjaGFvc01lYXN1cmUgKz0gZk11bHQoY2hDaGFvc01lYXN1cmVbY2hdLCBjaEVuZXJneSk7CiAgfQoKICBpZihmcmFtZUVuZXJneSA+IGNoYW9zTWVhc3VyZSkgewogICAgSU5UIHNjYWxlID0gQ250TGVhZGluZ1plcm9zKGZyYW1lRW5lcmd5KSAtIDE7CiAgICBGSVhQX0RCTCBudW0gICA9IGNoYW9zTWVhc3VyZTw8c2NhbGU7CiAgICBGSVhQX0RCTCBkZW51bSA9IGZyYW1lRW5lcmd5PDxzY2FsZTsKICAgIGNoYW9zTWVhc3VyZSAgID0gc2NodXJfZGl2KG51bSxkZW51bSwxNik7CiAgfQogIGVsc2UgewogICAgY2hhb3NNZWFzdXJlID0gRkwyRlhDT05TVF9EQkwoMS5mKTsKICB9CgogIGNoYW9zTWVhc3VyZUF2ZyA9IGZNdWx0KENPTlNUX0NIQU9TX01FQVNfQVZHX0ZBQ18wLCBjaGFvc01lYXN1cmUpICsKICAgICAgICAgICAgICAgICAgICBmTXVsdChDT05TVF9DSEFPU19NRUFTX0FWR19GQUNfMSwgKmNoYW9zTWVhc3VyZU9sZCk7ICAgICAgLyogYXZlcmFnaW5nIGNoYW9zIG1lYXN1cmUgKi8KICAqY2hhb3NNZWFzdXJlT2xkID0gY2hhb3NNZWFzdXJlID0gKGZpeE1pbihjaGFvc01lYXN1cmUsIGNoYW9zTWVhc3VyZUF2ZykpOyAgLyogdXNlIG1pbi12YWx1ZSwgc2FmZSBmb3IgbmV4dCBmcmFtZSAqLwoKICAvKiBjaGFyYWN0ZXJpc3RpYyBjdXJ2ZQogICAgIGNoYW9zTWVhc3VyZSA9IDAuMmYgKyAwLjdmLzAuM2YgKiAoY2hhb3NNZWFzdXJlIC0gMC4yZik7CiAgICAgY2hhb3NNZWFzdXJlID0gZml4TWluKDEuMGYsIGZpeE1heCgwLjFmLCBjaGFvc01lYXN1cmUpKTsKICAgICBjb25zdGFudHMgc2NhbGVkIGJ5IDQuZgogICovCiAgY2hhb3NNZWFzdXJlID0gKChGTDJGWENPTlNUX0RCTCgwLjJmKT4+MikgKyBmTXVsdChGTDJGWENPTlNUX0RCTCgwLjdmLyg0LmYqMC4zZikpLCAoY2hhb3NNZWFzdXJlIC0gRkwyRlhDT05TVF9EQkwoMC4yZikpKSk7CiAgY2hhb3NNZWFzdXJlID0gKGZpeE1pbigoRklYUF9EQkwpKEZMMkZYQ09OU1RfREJMKDEuMGYpPj4yKSwgZml4TWF4KChGSVhQX0RCTCkoRkwyRlhDT05TVF9EQkwoMC4xZik+PjIpLCBjaGFvc01lYXN1cmUpKSk8PDI7CgogIC8qIGNhbGN1bGF0aW9uIG9mIHJlZHVjdGlvbiB2YWx1ZSAqLwogIGlmIChwc3lPdXRDaGFubmVsWzBdLT5sYXN0V2luZG93U2VxdWVuY2UgPT0gU0hPUlRfV0lORE9XKXsgLyogc2hvcnQtYmxvY2tzICovCiAgICBGREtfQVNTRVJUKFRSQU5TX0ZBQz09OCk7CiAgICAjZGVmaW5lICAgV0lOX1RZUEVfU0NBTEUgICAoMykKCiAgICBJTlQgc2ZiR3JwLCBncm91cENudD0wOwogICAgZm9yIChzZmJHcnA9MDsgc2ZiR3JwPHBzeU91dENoYW4tPnNmYkNudDsgc2ZiR3JwKz1wc3lPdXRDaGFuLT5zZmJQZXJHcm91cCxncm91cENudCsrKSB7CgogICAgICBGSVhQX0RCTCBncm91cEVuZXJneSA9IEZMMkZYQ09OU1RfREJMKDAuZik7CgogICAgICBmb3IoY2g9MDtjaDxuQ2hhbm5lbHM7Y2grKyl7CiAgICAgICAgZ3JvdXBFbmVyZ3kgKz0gY2hHcm91cEVuZXJneVtncm91cENudF1bY2hdOyAgIC8qIGFkZGluZyB1cCB0aGUgY2hhbm5lbHMgZ3JvdXBFbmVyZ3kgKi8KICAgICAgfQoKICAgICAgRkRLX0FTU0VSVChwc3lPdXRDaGFubmVsWzBdLT5ncm91cExlbltncm91cENudF08PUlOVl9JTlRfVEFCX1NJWkUpOwogICAgICBncm91cEVuZXJneSA9IGZNdWx0KGdyb3VwRW5lcmd5LGludkludFtwc3lPdXRDaGFubmVsWzBdLT5ncm91cExlbltncm91cENudF1dKTsgIC8qIGNvcnJlY3Rpb24gb2YgZ3JvdXAgZW5lcmd5ICovCiAgICAgIGdyb3VwRW5lcmd5ID0gZml4TWluKGdyb3VwRW5lcmd5LCBmcmFtZUVuZXJneT4+V0lOX1RZUEVfU0NBTEUpOyAgICAgICAgICAgICAgICAgLyogZG8gbm90IGFsbG93IGFuIGhpZ2hlciByZWRWYWwgYXMgY2FsY3VsYXRlZCBmcmFtZXdpc2UgKi8KCiAgICAgIGdyb3VwRW5lcmd5Pj49MjsgLyogMipXSU5fVFlQRV9TQ0FMRSA9IDYgPT4gNisyID0gOCA9PT4gOC80ID0gaW50IG51bWJlciAqLwoKICAgICAgcmVkVmFsW2dyb3VwQ250XSA9IGZNdWx0KGZNdWx0KHZiclF1YWxGYWN0b3IsY2hhb3NNZWFzdXJlKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENhbGNJbnZMZERhdGEoQ2FsY0xkRGF0YShncm91cEVuZXJneSk+PjIpICkKICAgICAgICAgICAgICAgICAgICAgICAgIDw8IChpbnQpKCAoIDIgKyAoMipXSU5fVFlQRV9TQ0FMRSkgKyBTQ0FMRV9HUk9VUF9FTkVSR1kgKT4+MiApIDsKCiAgICB9CiAgfSBlbHNlIHsgLyogbG9uZy1ibG9jayAqLwoKICAgIHJlZFZhbFswXSA9IGZNdWx0KCBmTXVsdCh2YnJRdWFsRmFjdG9yLGNoYW9zTWVhc3VyZSksCiAgICAgICAgICAgICAgICAgICAgICAgQ2FsY0ludkxkRGF0YShDYWxjTGREYXRhKGZyYW1lRW5lcmd5KT4+MikgKQogICAgICAgICAgICAgICAgPDwgKGludCkoIFNDQUxFX0dST1VQX0VORVJHWT4+MiApIDsKICB9CgogIGZvcihjaD0wOyBjaDxuQ2hhbm5lbHM7IGNoKyspIHsKICAgIHFjT3V0Q2hhbiAgPSBxY091dENoYW5uZWxbY2hdOwogICAgcHN5T3V0Q2hhbiAgPSBwc3lPdXRDaGFubmVsW2NoXTsKCiAgICBmb3IgKHNmYkdycD0wOyBzZmJHcnA8cHN5T3V0Q2hhbi0+c2ZiQ250OyBzZmJHcnArPXBzeU91dENoYW4tPnNmYlBlckdyb3VwKSB7CiAgICAgIGZvciAoc2ZiPTA7IHNmYjxwc3lPdXRDaGFuLT5tYXhTZmJQZXJHcm91cDsgc2ZiKyspewoKICAgICAgICBzZmJFbkxkRGF0YSAgPSAocWNPdXRDaGFuLT5zZmJXZWlnaHRlZEVuZXJneUxkRGF0YVtzZmJHcnArc2ZiXSk7CiAgICAgICAgc2ZiVGhyTGREYXRhID0gKHFjT3V0Q2hhbi0+c2ZiVGhyZXNob2xkTGREYXRhW3NmYkdycCtzZmJdKTsKICAgICAgICBzZmJUaHJFeHAgICAgPSB0aHJFeHBbY2hdW3NmYkdycCtzZmJdOwoKICAgICAgICBpZiAoIChzZmJUaHJMZERhdGE+PU1JTl9MRFRIUkVTSCkgJiYgKHNmYkVuTGREYXRhID4gc2ZiVGhyTGREYXRhKSAmJiAoYWhGbGFnW2NoXVtzZmJHcnArc2ZiXSAhPSBBSF9BQ1RJVkUpKSB7CgogICAgICAgICAgLyogU2hvcnQtV2luZG93ICovCiAgICAgICAgICBpZiAocHN5T3V0Q2hhbm5lbFtjaF0tPmxhc3RXaW5kb3dTZXF1ZW5jZSA9PSBTSE9SVF9XSU5ET1cpIHsKICAgICAgICAgICAgY29uc3QgaW50IGdyb3VwTnVtYmVyID0gKGludCkgc2ZiL3BzeU91dENoYW4tPnNmYlBlckdyb3VwOwoKICAgICAgICAgICAgRkRLX0FTU0VSVChJTlZfU1FSVDRfVEFCX1NJWkU+cHN5T3V0Q2hhbi0+Z3JvdXBMZW5bZ3JvdXBOdW1iZXJdKTsKCiAgICAgICAgICAgIHNmYlRockV4cCA9IGZNdWx0KHNmYlRockV4cCwgZk11bHQoIEZMMkZYQ09OU1RfREJMKDIuODJmLzQuZiksIGludlNxcnQ0W3BzeU91dENoYW4tPmdyb3VwTGVuW2dyb3VwTnVtYmVyXV0pKTw8MiA7CgogICAgICAgICAgICBpZiAoIHNmYlRockV4cCA8PSAobGltaXRUaHJSZWR1Y2VkTGREYXRhLXJlZFZhbFtncm91cE51bWJlcl0pICkgewogICAgICAgICAgICAgICAgc2ZiVGhyUmVkdWNlZExkRGF0YSA9IEZMMkZYQ09OU1RfREJMKC0xLjBmKTsKICAgICAgICAgICAgfQogICAgICAgICAgICBlbHNlIHsKICAgICAgICAgICAgICAgIGlmICgoRklYUF9EQkwpcmVkVmFsW2dyb3VwTnVtYmVyXSA+PSBGTDJGWENPTlNUX0RCTCgxLjBmKS1zZmJUaHJFeHApCiAgICAgICAgICAgICAgICAgICAgc2ZiVGhyUmVkdWNlZExkRGF0YSA9IEZMMkZYQ09OU1RfREJMKDAuMGYpOwogICAgICAgICAgICAgICAgZWxzZSB7CiAgICAgICAgICAgICAgICAgICAgLyogdGhyZXNob2xkIHJlZHVjdGlvbiBmb3JtdWxhICovCiAgICAgICAgICAgICAgICAgICAgc2ZiVGhyUmVkdWNlZExkRGF0YSA9IENhbGNMZERhdGEoc2ZiVGhyRXhwICsgcmVkVmFsW2dyb3VwTnVtYmVyXSk7CiAgICAgICAgICAgICAgICAgICAgc2ZiVGhyUmVkdWNlZExkRGF0YSA8PD0gMjsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgfQogICAgICAgICAgICBzZmJUaHJSZWR1Y2VkTGREYXRhICs9ICggQ2FsY0xkSW50KHBzeU91dENoYW4tPmdyb3VwTGVuW2dyb3VwTnVtYmVyXSkgLQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKChGSVhQX0RCTCk2PDwoREZSQUNUX0JJVFMtMS1MRF9EQVRBX1NISUZUKSkgKTsKICAgICAgICAgIH0KCiAgICAgICAgICAvKiBMb25nLVdpbmRvdyAqLwogICAgICAgICAgZWxzZSB7CiAgICAgICAgICAgIGlmICgoRklYUF9EQkwpcmVkVmFsWzBdID49IEZMMkZYQ09OU1RfREJMKDEuMGYpLXNmYlRockV4cCkgewogICAgICAgICAgICAgIHNmYlRoclJlZHVjZWRMZERhdGEgPSBGTDJGWENPTlNUX0RCTCgwLjBmKTsKICAgICAgICAgICAgfQogICAgICAgICAgICBlbHNlIHsKICAgICAgICAgICAgICAvKiB0aHJlc2hvbGQgcmVkdWN0aW9uIGZvcm11bGEgKi8KICAgICAgICAgICAgICBzZmJUaHJSZWR1Y2VkTGREYXRhID0gQ2FsY0xkRGF0YShzZmJUaHJFeHAgKyByZWRWYWxbMF0pOwogICAgICAgICAgICAgIHNmYlRoclJlZHVjZWRMZERhdGEgPDw9IDI7CiAgICAgICAgICAgIH0KICAgICAgICAgIH0KCiAgICAgICAgICAvKiBhdm9pZCBob2xlcyAqLwogICAgICAgICAgaWYgKCAoKHNmYlRoclJlZHVjZWRMZERhdGEgLSBzZmJFbkxkRGF0YSkgPiBxY091dENoYW4tPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXSApCiAgICAgICAgICAgICAgICAgICYmIChhaEZsYWdbY2hdW3NmYkdycCtzZmJdICE9IE5PX0FIKSApCiAgICAgICAgICB7CiAgICAgICAgICAgIGlmIChxY091dENoYW4tPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXSAgPiAoRkwyRlhDT05TVF9EQkwoLTEuMGYpIC0gc2ZiRW5MZERhdGEpICl7CiAgICAgICAgICAgICAgICAgc2ZiVGhyUmVkdWNlZExkRGF0YSA9IGZpeE1heCgocWNPdXRDaGFuLT5zZmJNaW5TbnJMZERhdGFbc2ZiR3JwK3NmYl0gKyBzZmJFbkxkRGF0YSksIHNmYlRockxkRGF0YSk7CiAgICAgICAgICAgIH0KICAgICAgICAgICAgZWxzZSBzZmJUaHJSZWR1Y2VkTGREYXRhID0gc2ZiVGhyTGREYXRhOwogICAgICAgICAgICBhaEZsYWdbY2hdW3NmYkdycCtzZmJdID0gQUhfQUNUSVZFOwogICAgICAgICAgfQoKICAgICAgICAgIGlmIChzZmJUaHJSZWR1Y2VkTGREYXRhPEZMMkZYQ09OU1RfREJMKC0wLjVmKSkKICAgICAgICAgICAgICAgc2ZiVGhyUmVkdWNlZExkRGF0YSA9IEZMMkZYQ09OU1RfREJMKC0xLmYpOwoKICAgICAgICAgIC8qIG1pbmltdW0gb2YgMjkgZEIgUmF0aW8gZm9yIFRocmVzaG9sZHMgKi8KICAgICAgICAgIGlmICgoc2ZiRW5MZERhdGErRkwyRlhDT05TVF9EQkwoMS4wZikpID4gRkwyRlhDT05TVF9EQkwoOS42MzM2MjA2L0xEX0RBVEFfU0NBTElORykpewogICAgICAgICAgICBzZmJUaHJSZWR1Y2VkTGREYXRhID0gZml4TWF4KHNmYlRoclJlZHVjZWRMZERhdGEsIHNmYkVuTGREYXRhIC0gRkwyRlhDT05TVF9EQkwoOS42MzM2MjA2L0xEX0RBVEFfU0NBTElORykpOwogICAgICAgICAgfQoKICAgICAgICAgIHNmYlRoclJlZHVjZWRMZERhdGEgPSBmaXhNYXgoTUlOX0xEVEhSRVNILHNmYlRoclJlZHVjZWRMZERhdGEpOwoKICAgICAgICAgIHFjT3V0Q2hhbi0+c2ZiVGhyZXNob2xkTGREYXRhW3NmYkdycCtzZmJdID0gc2ZiVGhyUmVkdWNlZExkRGF0YTsKICAgICAgICB9CiAgICAgIH0KICAgIH0KICB9Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKZnVuY3Rpb25uYW1lOiBGREthYWNFbmNfY29ycmVjdFRocmVzaApkZXNjcmlwdGlvbjogIGlmIHBlIGRpZmZlcmVuY2UgZGVsdGFQZSBiZXR3ZWVuIGRlc2lyZWQgcGUgYW5kIHJlYWwgcGUgaXMgc21hbGwgZW5vdWdoLAp0aGUgZGlmZmVyZW5jZSBjYW4gYmUgZGlzdHJpYnV0ZWQgYW1vbmcgdGhlIHNjYWxlIGZhY3RvciBiYW5kcy4KTmV3IHRocmVzaG9sZHMgY2FuIGJlIGRlcml2ZWQgZnJvbSB0aGlzIHBlLWRpZmZlcmVuY2UKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCnN0YXRpYyB2b2lkIEZES2FhY0VuY19jb3JyZWN0VGhyZXNoKENIQU5ORUxfTUFQUElORyogY20sCiAgICAgICAgICAgICAgICAgICAgICAgICAgUUNfT1VUX0VMRU1FTlQqICBxY0VsZW1lbnRbKDYpXSwKICAgICAgICAgICAgICAgICAgICAgICAgICBQU1lfT1VUX0VMRU1FTlQqIHBzeU91dEVsZW1lbnRbKDYpXSwKICAgICAgICAgICAgICAgICAgICAgICAgICBVQ0hBUiAgICAgICAgICAgIGFoRmxhZ1soNildWygyKV1bTUFYX0dST1VQRURfU0ZCXSwKICAgICAgICAgICAgICAgICAgICAgICAgICBGSVhQX0RCTCAgICAgICAgIHRockV4cFsoNildWygyKV1bTUFYX0dST1VQRURfU0ZCXSwKICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCAgICAgICAgICAgIEZJWFBfREJMIHJlZFZhbFsoNildLAogICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0ICAgICAgICAgICAgU0NIQVIgcmVkVmFsU2NhbGluZ1soNildLAogICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0ICAgICAgICAgICAgSU5UIGRlbHRhUGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgICAgICAgICAgICBJTlQgcHJvY2Vzc0VsZW1lbnRzLAogICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0ICAgICAgICAgICAgSU5UIGVsZW1lbnRPZmZzZXQpCnsKICAgSU5UIGNoLCBzZmIsIHNmYkdycDsKICAgUUNfT1VUX0NIQU5ORUwgKnFjT3V0Q2hhbjsKICAgUFNZX09VVF9DSEFOTkVMICpwc3lPdXRDaGFuOwogICBQRV9DSEFOTkVMX0RBVEEgKnBlQ2hhbkRhdGE7CiAgIEZJWFBfREJMIHRockZhY3RvckxkRGF0YTsKICAgRklYUF9EQkwgc2ZiRW5MZERhdGEsIHNmYlRockxkRGF0YSwgc2ZiVGhyUmVkdWNlZExkRGF0YTsKICAgRklYUF9EQkwgKnNmYlBlRmFjdG9yc0xkRGF0YVsoNildWygyKV07CiAgIEZJWFBfREJMIHNmYk5BY3RpdmVMaW5lc0xkRGF0YVsoMildW01BWF9HUk9VUEVEX1NGQl07CiAgIElOVCAgICAgIG5vcm1GYWN0b3JJbnQ7CiAgIEZJWFBfREJMIG5vcm1GYWN0b3JMZERhdGE7CgogICBJTlQgbkVsZW1lbnRzID0gZWxlbWVudE9mZnNldCtwcm9jZXNzRWxlbWVudHM7CiAgIElOVCBlbGVtZW50SWQ7CgogICAvKiBzY3JhdGNoIGlzIGVtcHR5OyB1c2UgdGVtcG9yYWwgbWVtb3J5IGZyb20gcXVhbnRTcGVjIGluIFFDX09VVF9DSEFOTkVMICovCiAgIGZvcihlbGVtZW50SWQ9ZWxlbWVudE9mZnNldDtlbGVtZW50SWQ8bkVsZW1lbnRzO2VsZW1lbnRJZCsrKSB7CiAgICAgZm9yKGNoPTA7IGNoPGNtLT5lbEluZm9bZWxlbWVudElkXS5uQ2hhbm5lbHNJbkVsOyBjaCsrKSB7CiAgICAgICBTSE9SVCogcHRyID0gcWNFbGVtZW50W2VsZW1lbnRJZF0tPnFjT3V0Q2hhbm5lbFtjaF0tPnF1YW50U3BlYzsKICAgICAgIHNmYlBlRmFjdG9yc0xkRGF0YVtlbGVtZW50SWRdW2NoXSA9IChGSVhQX0RCTCopcHRyOwogICAgIH0KICAgfQoKICAgLyogZm9yIGVhY2ggc2ZiIGNhbGMgcmVsYXRpdmUgZmFjdG9ycyBmb3IgcGUgY2hhbmdlcyAqLwogICBub3JtRmFjdG9ySW50ID0gMDsKCiAgIGZvcihlbGVtZW50SWQ9ZWxlbWVudE9mZnNldDtlbGVtZW50SWQ8bkVsZW1lbnRzO2VsZW1lbnRJZCsrKSB7CiAgICAgaWYgKGNtLT5lbEluZm9bZWxlbWVudElkXS5lbFR5cGUgIT0gSURfRFNFKSB7CgogICAgICAgZm9yKGNoPTA7IGNoPGNtLT5lbEluZm9bZWxlbWVudElkXS5uQ2hhbm5lbHNJbkVsOyBjaCsrKSB7CgogICAgICAgICAgcWNPdXRDaGFuID0gcWNFbGVtZW50W2VsZW1lbnRJZF0tPnFjT3V0Q2hhbm5lbFtjaF07CiAgICAgICAgICBwc3lPdXRDaGFuID0gcHN5T3V0RWxlbWVudFtlbGVtZW50SWRdLT5wc3lPdXRDaGFubmVsW2NoXTsKICAgICAgICAgIHBlQ2hhbkRhdGEgPSAmcWNFbGVtZW50W2VsZW1lbnRJZF0tPnBlRGF0YS5wZUNoYW5uZWxEYXRhW2NoXTsKCiAgICAgICAgICBmb3Ioc2ZiR3JwID0gMDsgc2ZiR3JwIDwgcHN5T3V0Q2hhbi0+c2ZiQ250OyBzZmJHcnArPSBwc3lPdXRDaGFuLT5zZmJQZXJHcm91cCl7CiAgICAgICAgICAgIGZvciAoc2ZiPTA7IHNmYjxwc3lPdXRDaGFuLT5tYXhTZmJQZXJHcm91cDsgc2ZiKyspIHsKCiAgICAgICAgICAgICBpZiAoIHBlQ2hhbkRhdGEtPnNmYk5BY3RpdmVMaW5lc1tzZmJHcnArc2ZiXSA9PSAwICkgewogICAgICAgICAgICAgICAgc2ZiTkFjdGl2ZUxpbmVzTGREYXRhW2NoXVtzZmJHcnArc2ZiXSA9IEZMMkZYQ09OU1RfREJMKC0xLjBmKTsKICAgICAgICAgICAgIH0KICAgICAgICAgICAgIGVsc2UgewogICAgICAgICAgICAgICAgLyogQm90aCBDYWxjTGRJbnQgYW5kIENhbGNMZERhdGEgY2FuIGJlIHVzZWQhCiAgICAgICAgICAgICAgICAgKiBObyBvZmZzZXQgaGFzIHRvIGJlIHN1YnRyYWN0ZWQsIGJlY2F1c2Ugc2ZiTkFjdGl2ZUxpbmVzTGREYXRhCiAgICAgICAgICAgICAgICAgKiBpcyBzaG9ydGVkIHdoaWxlIHRockZhY3RvciBjYWxjdWxhdGlvbiAqLwogICAgICAgICAgICAgICAgc2ZiTkFjdGl2ZUxpbmVzTGREYXRhW2NoXVtzZmJHcnArc2ZiXSA9IENhbGNMZEludChwZUNoYW5EYXRhLT5zZmJOQWN0aXZlTGluZXNbc2ZiR3JwK3NmYl0pOwogICAgICAgICAgICAgfQogICAgICAgICAgICAgaWYgKCAoKGFoRmxhZ1tlbGVtZW50SWRdW2NoXVtzZmJHcnArc2ZiXSA8IEFIX0FDVElWRSkgfHwgKGRlbHRhUGUgPiAwKSkgJiYKICAgICAgICAgICAgICAgICAgIHBlQ2hhbkRhdGEtPnNmYk5BY3RpdmVMaW5lc1tzZmJHcnArc2ZiXSAhPSAwICkKICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIGlmICh0aHJFeHBbZWxlbWVudElkXVtjaF1bc2ZiR3JwK3NmYl0gPiAtcmVkVmFsW2VsZW1lbnRJZF0pIHsKCiAgICAgICAgICAgICAgICAgICAvKiBzZmJQZUZhY3RvcnNbY2hdW3NmYkdycCtzZmJdID0gcGVDaGFuRGF0YS0+c2ZiTkFjdGl2ZUxpbmVzW3NmYkdycCtzZmJdIC8KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICh0aHJFeHBbZWxlbWVudElkXVtjaF1bc2ZiR3JwK3NmYl0gKyByZWRWYWxbZWxlbWVudElkXSk7ICovCgogICAgICAgICAgICAgICAgICAgaW50IG1pblNjYWxlID0gZml4TWluKENvdW50TGVhZGluZ0JpdHModGhyRXhwW2VsZW1lbnRJZF1bY2hdW3NmYkdycCtzZmJdKSwgQ291bnRMZWFkaW5nQml0cyhyZWRWYWxbZWxlbWVudElkXSkgLSAoREZSQUNUX0JJVFMtMS1yZWRWYWxTY2FsaW5nW2VsZW1lbnRJZF0pICkgLSAxOwoKICAgICAgICAgICAgICAgICAgIC8qIHN1bWxkID0gbGQ2NCggc2ZiVGhyRXhwICsgcmVkVmFsICkgKi8KICAgICAgICAgICAgICAgICAgIEZJWFBfREJMIHN1bUxkID0gQ2FsY0xkRGF0YShzY2FsZVZhbHVlKHRockV4cFtlbGVtZW50SWRdW2NoXVtzZmJHcnArc2ZiXSwgbWluU2NhbGUpICsgc2NhbGVWYWx1ZShyZWRWYWxbZWxlbWVudElkXSwgKERGUkFDVF9CSVRTLTEtcmVkVmFsU2NhbGluZ1tlbGVtZW50SWRdKSttaW5TY2FsZSkpCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgLSAoRklYUF9EQkwpKG1pblNjYWxlPDwoREZSQUNUX0JJVFMtMS1MRF9EQVRBX1NISUZUKSk7CgogICAgICAgICAgICAgICAgICAgaWYgKHN1bUxkIDwgRkwyRlhDT05TVF9EQkwoMC5mKSkgewogICAgICAgICAgICAgICAgICAgICAgc2ZiUGVGYWN0b3JzTGREYXRhW2VsZW1lbnRJZF1bY2hdW3NmYkdycCtzZmJdID0gc2ZiTkFjdGl2ZUxpbmVzTGREYXRhW2NoXVtzZmJHcnArc2ZiXSAtIHN1bUxkOwogICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgZWxzZSB7CiAgICAgICAgICAgICAgICAgICAgIGlmICggc2ZiTkFjdGl2ZUxpbmVzTGREYXRhW2NoXVtzZmJHcnArc2ZiXSA+IChGTDJGWENPTlNUX0RCTCgtMS5mKSArIHN1bUxkKSApIHsKICAgICAgICAgICAgICAgICAgICAgICBzZmJQZUZhY3RvcnNMZERhdGFbZWxlbWVudElkXVtjaF1bc2ZiR3JwK3NmYl0gPSBzZmJOQWN0aXZlTGluZXNMZERhdGFbY2hdW3NmYkdycCtzZmJdIC0gc3VtTGQ7CiAgICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICAgZWxzZSB7CiAgICAgICAgICAgICAgICAgICAgICBzZmJQZUZhY3RvcnNMZERhdGFbZWxlbWVudElkXVtjaF1bc2ZiR3JwK3NmYl0gPSBzZmJOQWN0aXZlTGluZXNMZERhdGFbY2hdW3NmYkdycCtzZmJdOwogICAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICB9CgogICAgICAgICAgICAgICAgICAgbm9ybUZhY3RvckludCArPSAoSU5UKUNhbGNJbnZMZERhdGEoc2ZiUGVGYWN0b3JzTGREYXRhW2VsZW1lbnRJZF1bY2hdW3NmYkdycCtzZmJdKTsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgIGVsc2Ugc2ZiUGVGYWN0b3JzTGREYXRhW2VsZW1lbnRJZF1bY2hdW3NmYkdycCtzZmJdID0gRkwyRlhDT05TVF9EQkwoMS4wZik7CiAgICAgICAgICAgICB9CiAgICAgICAgICAgICBlbHNlIHNmYlBlRmFjdG9yc0xkRGF0YVtlbGVtZW50SWRdW2NoXVtzZmJHcnArc2ZiXSA9IEZMMkZYQ09OU1RfREJMKC0xLjBmKTsKICAgICAgICAgICAgfQogICAgICAgICAgfQogICAgICAgfQogICAgIH0KICAgfQoKICAgLyogbm9ybUZhY3RvckxkRGF0YSA9IGxkNjQoZGVsdGFQZS9ub3JtRmFjdG9ySW50KSAqLwogICBub3JtRmFjdG9yTGREYXRhID0gQ2FsY0xkRGF0YSgoRklYUF9EQkwpKChkZWx0YVBlPDApID8gKC1kZWx0YVBlKSA6IChkZWx0YVBlKSkpIC0gQ2FsY0xkRGF0YSgoRklYUF9EQkwpbm9ybUZhY3RvckludCk7CgogICAvKiBkaXN0cmlidXRlIHRoZSBwZSBkaWZmZXJlbmNlIHRvIHRoZSBzY2FsZWZhY3RvcnMKICAgICAgYW5kIGNhbGN1bGF0ZSB0aGUgYWNjb3JkaW5nIHRocmVzaG9sZHMgKi8KICAgZm9yKGVsZW1lbnRJZD1lbGVtZW50T2Zmc2V0O2VsZW1lbnRJZDxuRWxlbWVudHM7ZWxlbWVudElkKyspIHsKICAgICBpZiAoY20tPmVsSW5mb1tlbGVtZW50SWRdLmVsVHlwZSAhPSBJRF9EU0UpIHsKCiAgICAgICBmb3IoY2g9MDsgY2g8Y20tPmVsSW5mb1tlbGVtZW50SWRdLm5DaGFubmVsc0luRWw7IGNoKyspIHsKICAgICAgICAgIHFjT3V0Q2hhbiA9IHFjRWxlbWVudFtlbGVtZW50SWRdLT5xY091dENoYW5uZWxbY2hdOwogICAgICAgICAgcHN5T3V0Q2hhbiA9IHBzeU91dEVsZW1lbnRbZWxlbWVudElkXS0+cHN5T3V0Q2hhbm5lbFtjaF07CiAgICAgICAgICBwZUNoYW5EYXRhID0gJnFjRWxlbWVudFtlbGVtZW50SWRdLT5wZURhdGEucGVDaGFubmVsRGF0YVtjaF07CgogICAgICAgICAgZm9yKHNmYkdycCA9IDA7c2ZiR3JwIDwgcHN5T3V0Q2hhbi0+c2ZiQ250O3NmYkdycCs9IHBzeU91dENoYW4tPnNmYlBlckdyb3VwKXsKICAgICAgICAgICAgZm9yIChzZmI9MDsgc2ZiPHBzeU91dENoYW4tPm1heFNmYlBlckdyb3VwOyBzZmIrKykgewoKICAgICAgICAgICAgICBpZiAocGVDaGFuRGF0YS0+c2ZiTkFjdGl2ZUxpbmVzW3NmYkdycCtzZmJdID4gMCkgewoKICAgICAgICAgICAgICAgICAvKiBwZSBkaWZmZXJlbmNlIGZvciB0aGlzIHNmYiAqLwogICAgICAgICAgICAgICAgIGlmICggKHNmYlBlRmFjdG9yc0xkRGF0YVtlbGVtZW50SWRdW2NoXVtzZmJHcnArc2ZiXT09RkwyRlhDT05TVF9EQkwoLTEuMGYpKSB8fAogICAgICAgICAgICAgICAgICAgICAgKGRlbHRhUGU9PTApICkKICAgICAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgICB0aHJGYWN0b3JMZERhdGEgPSBGTDJGWENPTlNUX0RCTCgwLmYpOwogICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICBlbHNlIHsKICAgICAgICAgICAgICAgICAgIC8qIG5ldyB0aHJlc2hvbGQgKi8KICAgICAgICAgICAgICAgICAgIEZJWFBfREJMIHRtcCA9IENhbGNJbnZMZERhdGEoc2ZiUGVGYWN0b3JzTGREYXRhW2VsZW1lbnRJZF1bY2hdW3NmYkdycCtzZmJdICsgbm9ybUZhY3RvckxkRGF0YSAtIHNmYk5BY3RpdmVMaW5lc0xkRGF0YVtjaF1bc2ZiR3JwK3NmYl0gLSBGTDJGWENPTlNUX0RCTCgoZmxvYXQpTERfREFUQV9TSElGVC9MRF9EQVRBX1NDQUxJTkcpKTsKCiAgICAgICAgICAgICAgICAgICAvKiBsaW1pdCB0aHJGYWN0b3IgdG8gNjBkQiAqLwogICAgICAgICAgICAgICAgICAgdG1wID0gKGRlbHRhUGU8MCkgPyB0bXAgOiAoLXRtcCk7CiAgICAgICAgICAgICAgICAgICB0aHJGYWN0b3JMZERhdGEgPSBGREttaW4odG1wLCBGTDJGWENPTlNUX0RCTCgyMC5mL0xEX0RBVEFfU0NBTElORykpOwogICAgICAgICAgICAgICAgIH0KCiAgICAgICAgICAgICAgICAgLyogbmV3IHRocmVzaG9sZCAqLwogICAgICAgICAgICAgICAgIHNmYlRockxkRGF0YSA9IHFjT3V0Q2hhbi0+c2ZiVGhyZXNob2xkTGREYXRhW3NmYkdycCtzZmJdOwogICAgICAgICAgICAgICAgIHNmYkVuTGREYXRhICA9IHFjT3V0Q2hhbi0+c2ZiV2VpZ2h0ZWRFbmVyZ3lMZERhdGFbc2ZiR3JwK3NmYl07CgogICAgICAgICAgICAgICAgIGlmICh0aHJGYWN0b3JMZERhdGEgPCBGTDJGWENPTlNUX0RCTCgwLmYpKSB7CiAgICAgICAgICAgICAgICAgICBpZiggc2ZiVGhyTGREYXRhID4gKEZMMkZYQ09OU1RfREJMKC0xLmYpLXRockZhY3RvckxkRGF0YSkgKSB7CiAgICAgICAgICAgICAgICAgICAgIHNmYlRoclJlZHVjZWRMZERhdGEgPSBzZmJUaHJMZERhdGEgKyB0aHJGYWN0b3JMZERhdGE7CiAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICAgICBlbHNlIHsKICAgICAgICAgICAgICAgICAgICAgc2ZiVGhyUmVkdWNlZExkRGF0YSA9IEZMMkZYQ09OU1RfREJMKC0xLmYpOwogICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICBlbHNlewogICAgICAgICAgICAgICAgICAgIHNmYlRoclJlZHVjZWRMZERhdGEgPSBzZmJUaHJMZERhdGEgKyB0aHJGYWN0b3JMZERhdGE7CiAgICAgICAgICAgICAgICAgfQoKICAgICAgICAgICAgICAgICAvKiBhdm9pZCBob2xlICovCiAgICAgICAgICAgICAgICAgaWYgKCAoc2ZiVGhyUmVkdWNlZExkRGF0YSAtIHNmYkVuTGREYXRhID4gcWNPdXRDaGFuLT5zZmJNaW5TbnJMZERhdGFbc2ZiR3JwK3NmYl0pICYmCiAgICAgICAgICAgICAgICAgICAgICAoYWhGbGFnW2VsZW1lbnRJZF1bY2hdW3NmYkdycCtzZmJdID09IEFIX0lOQUNUSVZFKSApCiAgICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIC8qIHNmYlRoclJlZHVjZWQgPSBtYXgocHN5T3V0Q2hhbltjaF0tPnNmYk1pblNucltpXSAqIHNmYkVuLCBzZmJUaHIpOyAqLwogICAgICAgICAgICAgICAgICAgIGlmICggc2ZiRW5MZERhdGEgPiAoc2ZiVGhyTGREYXRhLXFjT3V0Q2hhbi0+c2ZiTWluU25yTGREYXRhW3NmYkdycCtzZmJdKSApIHsKICAgICAgICAgICAgICAgICAgICAgICAgc2ZiVGhyUmVkdWNlZExkRGF0YSA9IHFjT3V0Q2hhbi0+c2ZiTWluU25yTGREYXRhW3NmYkdycCtzZmJdICsgc2ZiRW5MZERhdGE7CiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgICAgIGVsc2UgewogICAgICAgICAgICAgICAgICAgICAgICBzZmJUaHJSZWR1Y2VkTGREYXRhID0gc2ZiVGhyTGREYXRhOwogICAgICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICAgICAgICBhaEZsYWdbZWxlbWVudElkXVtjaF1bc2ZiR3JwK3NmYl0gPSBBSF9BQ1RJVkU7CiAgICAgICAgICAgICAgICAgfQoKICAgICAgICAgICAgICAgICBxY091dENoYW4tPnNmYlRocmVzaG9sZExkRGF0YVtzZmJHcnArc2ZiXSA9IHNmYlRoclJlZHVjZWRMZERhdGE7CiAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CiAgICAgICAgICB9CiAgICAgICB9CiAgICAgfQogICB9Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICAgZnVuY3Rpb25uYW1lOiBGREthYWNFbmNfcmVkdWNlTWluU25yCiAgICBkZXNjcmlwdGlvbjogIGlmIHRoZSBkZXNpcmVkIHBlIGNhbiBub3QgYmUgcmVhY2hlZCwgcmVkdWNlIHBlIGJ5CiAgICAgICAgICAgICAgICAgIHJlZHVjaW5nIG1pblNucgoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8Kdm9pZCBGREthYWNFbmNfcmVkdWNlTWluU25yKENIQU5ORUxfTUFQUElORyogY20sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBRQ19PVVRfRUxFTUVOVCogIHFjRWxlbWVudFsoNildLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgUFNZX09VVF9FTEVNRU5UKiBwc3lPdXRFbGVtZW50Wyg2KV0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBVQ0hBUiAgICAgICAgICAgIGFoRmxhZ1soNildWygyKV1bTUFYX0dST1VQRURfU0ZCXSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0ICAgICAgICAgICAgSU5UIGRlc2lyZWRQZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgIElOVCogICAgICAgICAgICAgcmVkUGVHbG9iYWwsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCAgICAgICAgICAgIElOVCBwcm9jZXNzRWxlbWVudHMsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCAgICAgICAgICAgIElOVCBlbGVtZW50T2Zmc2V0KQoKewogICBJTlQgZWxlbWVudElkOwogICBJTlQgbkVsZW1lbnRzID0gZWxlbWVudE9mZnNldCtwcm9jZXNzRWxlbWVudHM7CgogICBJTlQgbmV3R2xvYmFsUGUgPSAqcmVkUGVHbG9iYWw7CgogICBmb3IoZWxlbWVudElkPWVsZW1lbnRPZmZzZXQ7ZWxlbWVudElkPG5FbGVtZW50cztlbGVtZW50SWQrKykgewogICAgIGlmIChjbS0+ZWxJbmZvW2VsZW1lbnRJZF0uZWxUeXBlICE9IElEX0RTRSkgewogICAgICAgSU5UIGNoOwogICAgICAgSU5UIG1heFNmYlBlckdyb3VwWzJdOwogICAgICAgSU5UIHNmYkNudFsyXTsKICAgICAgIElOVCBzZmJQZXJHcm91cFsyXTsKCiAgICAgICBmb3IoY2g9MDsgY2g8Y20tPmVsSW5mb1tlbGVtZW50SWRdLm5DaGFubmVsc0luRWw7IGNoKyspIHsKICAgICAgICAgbWF4U2ZiUGVyR3JvdXBbY2hdID0gcHN5T3V0RWxlbWVudFtlbGVtZW50SWRdLT5wc3lPdXRDaGFubmVsW2NoXS0+bWF4U2ZiUGVyR3JvdXAtMTsKICAgICAgICAgc2ZiQ250W2NoXSAgICAgICAgID0gcHN5T3V0RWxlbWVudFtlbGVtZW50SWRdLT5wc3lPdXRDaGFubmVsW2NoXS0+c2ZiQ250OwogICAgICAgICBzZmJQZXJHcm91cFtjaF0gICAgPSBwc3lPdXRFbGVtZW50W2VsZW1lbnRJZF0tPnBzeU91dENoYW5uZWxbY2hdLT5zZmJQZXJHcm91cDsKICAgICAgIH0KCiAgICAgICBQRV9EQVRBICpwZURhdGEgPSAmcWNFbGVtZW50W2VsZW1lbnRJZF0tPnBlRGF0YTsKCiAgICAgICBkbwogICAgICAgewogICAgICAgICBmb3IoY2g9MDsgY2g8Y20tPmVsSW5mb1tlbGVtZW50SWRdLm5DaGFubmVsc0luRWw7IGNoKyspIHsKCiAgICAgICAgICAgIElOVCBzZmIsIHNmYkdycDsKICAgICAgICAgICAgUUNfT1VUX0NIQU5ORUwgICpxY091dENoYW4gPSBxY0VsZW1lbnRbZWxlbWVudElkXS0+cWNPdXRDaGFubmVsW2NoXTsKICAgICAgICAgICAgSU5UIG5vUmVkdWN0aW9uID0gMTsKCiAgICAgICAgICAgIGlmIChtYXhTZmJQZXJHcm91cFtjaF0+PTApIHsgIC8qIHNmYiBpbiBuZXh0IGNoYW5uZWwgKi8KICAgICAgICAgICAgICBJTlQgZGVsdGFQZSA9IDA7CiAgICAgICAgICAgICAgc2ZiID0gbWF4U2ZiUGVyR3JvdXBbY2hdLS07CiAgICAgICAgICAgICAgbm9SZWR1Y3Rpb24gPSAwOwoKICAgICAgICAgICAgICBmb3IgKHNmYkdycCA9IDA7IHNmYkdycCA8IHNmYkNudFtjaF07IHNmYkdycCArPSBzZmJQZXJHcm91cFtjaF0pIHsKCiAgICAgICAgICAgICAgICBpZiAoYWhGbGFnW2VsZW1lbnRJZF1bY2hdW3NmYkdycCtzZmJdICE9IE5PX0FIICYmCiAgICAgICAgICAgICAgICAgICAgcWNPdXRDaGFuLT5zZmJNaW5TbnJMZERhdGFbc2ZiR3JwK3NmYl0gPCBTbnJMZEZhYykKICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgLyogaW5jcmVhc2UgdGhyZXNob2xkIHRvIG5ldyBtaW5TbnIgb2YgMWRCICovCiAgICAgICAgICAgICAgICAgIHFjT3V0Q2hhbi0+c2ZiTWluU25yTGREYXRhW3NmYkdycCtzZmJdID0gU25yTGRGYWM7CgogICAgICAgICAgICAgICAgICAvKiBzZmJUaHJSZWR1Y2VkID0gbWF4KHBzeU91dENoYW5bY2hdLT5zZmJNaW5TbnJbaV0gKiBzZmJFbiwgc2ZiVGhyKTsgKi8KICAgICAgICAgICAgICAgICAgaWYgKCBxY091dENoYW4tPnNmYldlaWdodGVkRW5lcmd5TGREYXRhW3NmYkdycCtzZmJdID49IHFjT3V0Q2hhbi0+c2ZiVGhyZXNob2xkTGREYXRhW3NmYkdycCtzZmJdIC0gcWNPdXRDaGFuLT5zZmJNaW5TbnJMZERhdGFbc2ZiR3JwK3NmYl0gKSB7CgogICAgICAgICAgICAgICAgICAgICBxY091dENoYW4tPnNmYlRocmVzaG9sZExkRGF0YVtzZmJHcnArc2ZiXSA9IHFjT3V0Q2hhbi0+c2ZiV2VpZ2h0ZWRFbmVyZ3lMZERhdGFbc2ZiR3JwK3NmYl0gKyBxY091dENoYW4tPnNmYk1pblNuckxkRGF0YVtzZmJHcnArc2ZiXTsKCiAgICAgICAgICAgICAgICAgICAgIC8qIGNhbGMgbmV3IHBlICovCiAgICAgICAgICAgICAgICAgICAgIC8qIEMyICsgQzMqbGQoMS8wLjgpID0gMS41ICovCiAgICAgICAgICAgICAgICAgICAgIGRlbHRhUGUgLT0gKHBlRGF0YS0+cGVDaGFubmVsRGF0YVtjaF0uc2ZiUGVbc2ZiR3JwK3NmYl0+PlBFX0NPTlNUUEFSVF9TSElGVCk7CgogICAgICAgICAgICAgICAgICAgICAvKiBzZmJQZSA9IDEuNSAqIHNmYk5MaW5lcyAqLwogICAgICAgICAgICAgICAgICAgICBwZURhdGEtPnBlQ2hhbm5lbERhdGFbY2hdLnNmYlBlW3NmYkdycCtzZmJdID0gKDMqcGVEYXRhLT5wZUNoYW5uZWxEYXRhW2NoXS5zZmJOTGluZXNbc2ZiR3JwK3NmYl0pIDw8IChQRV9DT05TVFBBUlRfU0hJRlQtMSk7CiAgICAgICAgICAgICAgICAgICAgIGRlbHRhUGUgKz0gKHBlRGF0YS0+cGVDaGFubmVsRGF0YVtjaF0uc2ZiUGVbc2ZiR3JwK3NmYl0+PlBFX0NPTlNUUEFSVF9TSElGVCk7CiAgICAgICAgICAgICAgICAgICB9CiAgICAgICAgICAgICAgICB9CgogICAgICAgICAgICAgIH0gLyogc2ZiR3JwIGxvb3AgKi8KCiAgICAgICAgICAgICAgcGVEYXRhLT5wZSArPSBkZWx0YVBlOwogICAgICAgICAgICAgIHBlRGF0YS0+cGVDaGFubmVsRGF0YVtjaF0ucGUgKz0gZGVsdGFQZTsKICAgICAgICAgICAgICBuZXdHbG9iYWxQZSArPSBkZWx0YVBlOwoKICAgICAgICAgICAgICAvKiBzdG9wIGlmIGVub3VnaCBoYXMgYmVlbiBzYXZlZCAqLwogICAgICAgICAgICAgIGlmIChwZURhdGEtPnBlIDw9IGRlc2lyZWRQZSkgewogICAgICAgICAgICAgICAgZ290byBiYWlsOwogICAgICAgICAgICAgIH0KCiAgICAgICAgICAgIH0gLyogc2ZiID4gMCAqLwoKICAgICAgICAgICAgaWYgKCAoY2g9PShjbS0+ZWxJbmZvW2VsZW1lbnRJZF0ubkNoYW5uZWxzSW5FbC0xKSkgJiYgbm9SZWR1Y3Rpb24gKSB7CiAgICAgICAgICAgICAgZ290byBiYWlsOwogICAgICAgICAgICB9CgogICAgICAgICB9IC8qIGNoIGxvb3AgKi8KCiAgICAgICB9IHdoaWxlICggcGVEYXRhLT5wZSA+IGRlc2lyZWRQZSk7CgogICAgIH0gLyogIT0gSURfRFNFICovCiAgIH0gLyogZWxlbWVudCBsb29wICovCgoKYmFpbDoKICAgLyogdXBkYXRlIGdsb2JhbCBQRSAqLwogICAqcmVkUGVHbG9iYWwgPSBuZXdHbG9iYWxQZTsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgogICAgZnVuY3Rpb25uYW1lOiBGREthYWNFbmNfYWxsb3dNb3JlSG9sZXMKICAgIGRlc2NyaXB0aW9uOiAgaWYgdGhlIGRlc2lyZWQgcGUgY2FuIG5vdCBiZSByZWFjaGVkLCBzb21lIG1vcmUgc2NhbGVmYWN0b3IKICAgICAgICAgICAgICAgICAgYmFuZHMgaGF2ZSB0byBiZSBxdWFudGl6ZWQgdG8gemVybwoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8Kc3RhdGljIHZvaWQgRkRLYWFjRW5jX2FsbG93TW9yZUhvbGVzKENIQU5ORUxfTUFQUElORyogY20sCiAgICAgICAgICAgICAgICAgICAgICAgICAgIFFDX09VVF9FTEVNRU5UKiAgcWNFbGVtZW50Wyg2KV0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgIFBTWV9PVVRfRUxFTUVOVCogcHN5T3V0RWxlbWVudFsoNildLAogICAgICAgICAgICAgICAgICAgICAgICAgICBBVFNfRUxFTUVOVCogICAgIEFkalRoclN0YXRlRWxlbWVudFsoNildLAogICAgICAgICAgICAgICAgICAgICAgICAgICBVQ0hBUiAgICAgICAgICAgIGFoRmxhZ1soNildWygyKV1bTUFYX0dST1VQRURfU0ZCXSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgSU5UICAgICAgICBkZXNpcmVkUGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IElOVCAgICAgICAgY3VycmVudFBlLAogICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBpbnQgICAgICAgIHByb2Nlc3NFbGVtZW50cywKICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgaW50ICAgICAgICBlbGVtZW50T2Zmc2V0KQp7CiAgSU5UIGVsZW1lbnRJZDsKICBJTlQgbkVsZW1lbnRzID0gZWxlbWVudE9mZnNldCtwcm9jZXNzRWxlbWVudHM7CiAgSU5UIGFjdFBlID0gY3VycmVudFBlOwoKICBpZiAoYWN0UGUgPD0gZGVzaXJlZFBlKSB7CiAgICByZXR1cm47IC8qIG5vdGhpbmcgdG8gZG8gKi8KICB9CgogIGZvciAoZWxlbWVudElkID0gZWxlbWVudE9mZnNldDtlbGVtZW50SWQ8bkVsZW1lbnRzO2VsZW1lbnRJZCsrKSB7CiAgICBpZiAoY20tPmVsSW5mb1tlbGVtZW50SWRdLmVsVHlwZSAhPSBJRF9EU0UpIHsKCiAgICAgIElOVCBjaCwgc2ZiLCBzZmJHcnA7CgogICAgICBQRV9EQVRBICpwZURhdGEgPSAmcWNFbGVtZW50W2VsZW1lbnRJZF0tPnBlRGF0YTsKICAgICAgY29uc3QgSU5UIG5DaGFubmVscyA9IGNtLT5lbEluZm9bZWxlbWVudElkXS5uQ2hhbm5lbHNJbkVsOwoKICAgICAgUUNfT1VUX0NIQU5ORUwqICBxY091dENoYW5uZWxbKDIpXSA9IHtOVUxMfTsKICAgICAgUFNZX09VVF9DSEFOTkVMKiBwc3lPdXRDaGFubmVsWygyKV0gPSB7TlVMTH07CgogICAgICBmb3IgKGNoPTA7IGNoPG5DaGFubmVsczsgY2grKykgewoKICAgICAgICAvKiBpbml0IHBvaW50ZXJzICovCiAgICAgICAgcWNPdXRDaGFubmVsW2NoXSA9IHFjRWxlbWVudFtlbGVtZW50SWRdLT5xY091dENoYW5uZWxbY2hdOwogICAgICAgIHBzeU91dENoYW5uZWxbY2hdID0gcHN5T3V0RWxlbWVudFtlbGVtZW50SWRdLT5wc3lPdXRDaGFubmVsW2NoXTsKCiAgICAgICAgZm9yKHNmYkdycD0wOyBzZmJHcnAgPCBwc3lPdXRDaGFubmVsW2NoXS0+c2ZiQ250OyBzZmJHcnArPSBwc3lPdXRDaGFubmVsW2NoXS0+c2ZiUGVyR3JvdXApIHsKICAgICAgICAgIGZvciAoc2ZiPXBzeU91dENoYW5uZWxbY2hdLT5tYXhTZmJQZXJHcm91cDsgc2ZiPHBzeU91dENoYW5uZWxbY2hdLT5zZmJQZXJHcm91cDsgc2ZiKyspIHsKICAgICAgICAgICAgcGVEYXRhLT5wZUNoYW5uZWxEYXRhW2NoXS5zZmJQZVtzZmJHcnArc2ZiXSA9IDA7CiAgICAgICAgICB9CiAgICAgICAgfQogICAgICB9CgogICAgICAvKiBmb3IgTVMgYWxsb3cgaG9sZSBpbiB0aGUgY2hhbm5lbCB3aXRoIGxlc3MgZW5lcmd5ICovCiAgICAgIGlmICggbkNoYW5uZWxzPT0yICYmIHBzeU91dENoYW5uZWxbMF0tPmxhc3RXaW5kb3dTZXF1ZW5jZT09cHN5T3V0Q2hhbm5lbFsxXS0+bGFzdFdpbmRvd1NlcXVlbmNlICkgewoKICAgICAgICBmb3IgKHNmYj0wOyBzZmI8cHN5T3V0Q2hhbm5lbFswXS0+bWF4U2ZiUGVyR3JvdXA7IHNmYisrKSB7CiAgICAgICAgICBmb3Ioc2ZiR3JwPTA7IHNmYkdycCA8IHBzeU91dENoYW5uZWxbMF0tPnNmYkNudDsgc2ZiR3JwKz1wc3lPdXRDaGFubmVsWzBdLT5zZmJQZXJHcm91cCkgewogICAgICAgICAgICBpZiAocHN5T3V0RWxlbWVudFtlbGVtZW50SWRdLT50b29sc0luZm8ubXNNYXNrW3NmYkdycCtzZmJdKSB7CiAgICAgICAgICAgICAgRklYUF9EQkwgRW5lcmd5TGRfTCA9IHFjT3V0Q2hhbm5lbFswXS0+c2ZiV2VpZ2h0ZWRFbmVyZ3lMZERhdGFbc2ZiR3JwK3NmYl07CiAgICAgICAgICAgICAgRklYUF9EQkwgRW5lcmd5TGRfUiA9IHFjT3V0Q2hhbm5lbFsxXS0+c2ZiV2VpZ2h0ZWRFbmVyZ3lMZERhdGFbc2ZiR3JwK3NmYl07CgogICAgICAgICAgICAgIC8qIGFsbG93IGhvbGUgaW4gc2lkZSBjaGFubmVsID8gKi8KICAgICAgICAgICAgICBpZiAoIChhaEZsYWdbZWxlbWVudElkXVsxXVtzZmJHcnArc2ZiXSAhPSBOT19BSCkgJiYKICAgICAgICAgICAgICAgICAgICgoKEZMMkZYQ09OU1RfREJMKC0wLjAyMDY1NTEyNjQ4Zik+PjEpICsgKHFjT3V0Q2hhbm5lbFswXS0+c2ZiTWluU25yTGREYXRhW3NmYkdycCtzZmJdPj4xKSkKICAgICAgICAgICAgICAgICAgICAgICAgPiAoKEVuZXJneUxkX1I+PjEpIC0gKEVuZXJneUxkX0w+PjEpKSkgKQogICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgYWhGbGFnW2VsZW1lbnRJZF1bMV1bc2ZiR3JwK3NmYl0gPSBOT19BSDsKICAgICAgICAgICAgICAgICAgcWNPdXRDaGFubmVsWzFdLT5zZmJUaHJlc2hvbGRMZERhdGFbc2ZiR3JwK3NmYl0gPSBGTDJGWENPTlNUX0RCTCgwLjAxNTYyNWYpICsgRW5lcmd5TGRfUjsKICAgICAgICAgICAgICAgICAgYWN0UGUgLT0gcGVEYXRhLT5wZUNoYW5uZWxEYXRhWzFdLnNmYlBlW3NmYkdycCtzZmJdPj5QRV9DT05TVFBBUlRfU0hJRlQ7CiAgICAgICAgICAgICAgfQogICAgICAgICAgICAgIC8qIGFsbG93IGhvbGUgaW4gbWlkIGNoYW5uZWwgPyAqLwogICAgICAgICAgICAgIGVsc2UgaWYgKCAoYWhGbGFnW2VsZW1lbnRJZF1bMF1bc2ZiR3JwK3NmYl0gIT0gTk9fQUgpICYmCiAgICAgICAgICAgICAgICAgICAgICAgICgoKEZMMkZYQ09OU1RfREJMKC0wLjAyMDY1NTEyNjQ4Zik+PjEpICsgKHFjT3V0Q2hhbm5lbFsxXS0+c2ZiTWluU25yTGREYXRhW3NmYkdycCtzZmJdPj4xKSkKICAgICAgICAgICAgICAgICAgICAgICAgICAgICA+ICgoRW5lcmd5TGRfTD4+MSkgLSAoRW5lcmd5TGRfUj4+MSkpKSApCiAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICBhaEZsYWdbZWxlbWVudElkXVswXVtzZmJHcnArc2ZiXSA9IE5PX0FIOwogICAgICAgICAgICAgICAgICBxY091dENoYW5uZWxbMF0tPnNmYlRocmVzaG9sZExkRGF0YVtzZmJHcnArc2ZiXSA9IEZMMkZYQ09OU1RfREJMKDAuMDE1NjI1ZikgKyBFbmVyZ3lMZF9MOwogICAgICAgICAgICAgICAgICBhY3RQZSAtPSBwZURhdGEtPnBlQ2hhbm5lbERhdGFbMF0uc2ZiUGVbc2ZiR3JwK3NmYl0+PlBFX0NPTlNUUEFSVF9TSElGVDsKICAgICAgICAgICAgICB9IC8qIGlmIChhaEZsYWcpICovCiAgICAgICAgICAgIH0gLyogaWYgTVMgKi8KICAgICAgICAgIH0gLyogc2ZiR3JwICovCiAgICAgICAgICBpZiAoYWN0UGUgPD0gZGVzaXJlZFBlKSB7CiAgICAgICAgICAgIHJldHVybjsgLyogc3RvcCBpZiBlbm91Z2ggaGFzIGJlZW4gc2F2ZWQgKi8KICAgICAgICAgIH0KICAgICAgICB9IC8qIHNmYiAqLwogICAgICB9IC8qIE1TIHBvc3NpYmxlID8gKi8KCiAgICAgIC8qIG1vcmUgaG9sZXMgbmVjZXNzYXJ5PyBzdWJzZXF1ZW50bHkgZXJhc2UgYmFuZHMKICAgICAgICAgc3RhcnRpbmcgd2l0aCBsb3cgZW5lcmdpZXMgKi8KICAgICAgSU5UIHN0YXJ0U2ZiWzJdOwogICAgICBGSVhQX0RCTCBhdmdFbkxENjQsbWluRW5MRDY0OwogICAgICBJTlQgYWhDbnQ7CiAgICAgIEZJWFBfREJMIGFoQ250TEQ2NDsKICAgICAgSU5UIGVuSWR4OwogICAgICBGSVhQX0RCTCBlbkxENjRbNF07CiAgICAgIEZJWFBfREJMIGF2Z0VuOwoKICAgICAgLyogZG8gbm90IGdvIGJlbG93IHN0YXJ0U2ZiICovCiAgICAgIGZvciAoY2g9MDsgY2g8bkNoYW5uZWxzOyBjaCsrKSB7CiAgICAgICAgaWYgKHBzeU91dENoYW5uZWxbY2hdLT5sYXN0V2luZG93U2VxdWVuY2UgIT0gU0hPUlRfV0lORE9XKQogICAgICAgICAgc3RhcnRTZmJbY2hdID0gQWRqVGhyU3RhdGVFbGVtZW50W2VsZW1lbnRJZF0tPmFoUGFyYW0uc3RhcnRTZmJMOwogICAgICAgIGVsc2UKICAgICAgICAgIHN0YXJ0U2ZiW2NoXSA9IEFkalRoclN0YXRlRWxlbWVudFtlbGVtZW50SWRdLT5haFBhcmFtLnN0YXJ0U2ZiUzsKICAgICAgfQoKICAgICAgLyogY2FsYyBhdmcgYW5kIG1pbiBlbmVyZ2llcyBvZiBiYW5kcyB0aGF0IGF2b2lkIGhvbGVzICovCiAgICAgIGF2Z0VuID0gRkwyRlhDT05TVF9EQkwoMC4wZik7CiAgICAgIG1pbkVuTEQ2NCA9IEZMMkZYQ09OU1RfREJMKDAuMGYpOwogICAgICBhaENudCA9IDA7CgogICAgICBmb3IgKGNoPTA7IGNoPG5DaGFubmVsczsgY2grKykgewoKICAgICAgICBzZmJHcnA9MDsKICAgICAgICBzZmI9c3RhcnRTZmJbY2hdOwoKICAgICAgICBkbyB7CiAgICAgICAgICBmb3IgKDsgc2ZiPHBzeU91dENoYW5uZWxbY2hdLT5tYXhTZmJQZXJHcm91cDsgc2ZiKyspIHsKICAgICAgICAgICAgaWYgKChhaEZsYWdbZWxlbWVudElkXVtjaF1bc2ZiR3JwK3NmYl0hPU5PX0FIKSAmJgogICAgICAgICAgICAgICAgKHFjT3V0Q2hhbm5lbFtjaF0tPnNmYldlaWdodGVkRW5lcmd5TGREYXRhW3NmYkdycCtzZmJdID4gcWNPdXRDaGFubmVsW2NoXS0+c2ZiVGhyZXNob2xkTGREYXRhW3NmYkdycCtzZmJdKSl7CiAgICAgICAgICAgICAgbWluRW5MRDY0ID0gZml4TWluKG1pbkVuTEQ2NCxxY091dENoYW5uZWxbY2hdLT5zZmJFbmVyZ3lMZERhdGFbc2ZiR3JwK3NmYl0pOwogICAgICAgICAgICAgIGF2Z0VuICs9IHFjT3V0Q2hhbm5lbFtjaF0tPnNmYkVuZXJneVtzZmJHcnArc2ZiXSA+PiA2OwogICAgICAgICAgICAgIGFoQ250Kys7CiAgICAgICAgICAgIH0KICAgICAgICAgIH0KCiAgICAgICAgICBzZmJHcnAgKz0gcHN5T3V0Q2hhbm5lbFtjaF0tPnNmYlBlckdyb3VwOwogICAgICAgICAgc2ZiPTA7CgogICAgICAgIH0gd2hpbGUgKHNmYkdycCA8IHBzeU91dENoYW5uZWxbY2hdLT5zZmJDbnQpOwogICAgICB9CgogICAgICBpZiAoIChhdmdFbiA9PSBGTDJGWENPTlNUX0RCTCgwLjBmKSkgfHwgKGFoQ250ID09IDApICkgewogICAgICAgIGF2Z0VuTEQ2NCA9IEZMMkZYQ09OU1RfREJMKDAuMGYpOwogICAgICB9CiAgICAgIGVsc2UgewogICAgICAgIGF2Z0VuTEQ2NCA9IENhbGNMZERhdGEoYXZnRW4pOwogICAgICAgIGFoQ250TEQ2NCA9IENhbGNMZEludChhaENudCk7CiAgICAgICAgYXZnRW5MRDY0ID0gYXZnRW5MRDY0ICsgRkwyRlhDT05TVF9EQkwoMC4wOTM3NWYpIC0gYWhDbnRMRDY0OyAvKiBjb21wZW5zYXRlIHNoaWZ0IHdpdGggNiAqLwogICAgICB9CgogICAgICAvKiBjYWxjIHNvbWUgZW5lcmd5IGJvcmRlcnMgYmV0d2VlbiBtaW5FbiBhbmQgYXZnRW4gKi8KICAgICAgLyogZm9yIChlbklkeD0wOyBlbklkeDw0OyBlbklkeCsrKSAqLwogICAgICAgIC8qIGVuW2VuSWR4XSA9IG1pbkVuICogKGZsb2F0KUZES3BvdyhhdmdFbi8obWluRW4rRkxUX01JTiksICgyKmVuSWR4KzEpLzcuMGYpOyAqLwogICAgICBlbkxENjRbMF0gPSBtaW5FbkxENjQgKyBmTXVsdCgoYXZnRW5MRDY0LW1pbkVuTEQ2NCksRkwyRlhDT05TVF9EQkwoMC4xNDI4NTcxNDI4NWYpKTsKICAgICAgZW5MRDY0WzFdID0gbWluRW5MRDY0ICsgZk11bHQoKGF2Z0VuTEQ2NC1taW5FbkxENjQpLEZMMkZYQ09OU1RfREJMKDAuNDI4NTcxNDI4NTdmKSk7CiAgICAgIGVuTEQ2NFsyXSA9IG1pbkVuTEQ2NCArIGZNdWx0KChhdmdFbkxENjQtbWluRW5MRDY0KSxGTDJGWENPTlNUX0RCTCgwLjcxNDI4NTcxNDI4ZikpOwogICAgICBlbkxENjRbM10gPSBtaW5FbkxENjQgKyAoYXZnRW5MRDY0LW1pbkVuTEQ2NCk7CgogICAgICBmb3IgKGVuSWR4PTA7IGVuSWR4PDQ7IGVuSWR4KyspIHsKICAgICAgICBJTlQgbm9SZWR1Y3Rpb24gPSAxOwoKICAgICAgICBJTlQgbWF4U2ZiUGVyR3JvdXBbMl07CiAgICAgICAgSU5UIHNmYkNudFsyXTsKICAgICAgICBJTlQgc2ZiUGVyR3JvdXBbMl07CgogICAgICAgIGZvcihjaD0wOyBjaDxjbS0+ZWxJbmZvW2VsZW1lbnRJZF0ubkNoYW5uZWxzSW5FbDsgY2grKykgewogICAgICAgICAgbWF4U2ZiUGVyR3JvdXBbY2hdID0gcHN5T3V0RWxlbWVudFtlbGVtZW50SWRdLT5wc3lPdXRDaGFubmVsW2NoXS0+bWF4U2ZiUGVyR3JvdXAtMTsKICAgICAgICAgIHNmYkNudFtjaF0gICAgICAgICA9IHBzeU91dEVsZW1lbnRbZWxlbWVudElkXS0+cHN5T3V0Q2hhbm5lbFtjaF0tPnNmYkNudDsKICAgICAgICAgIHNmYlBlckdyb3VwW2NoXSAgICA9IHBzeU91dEVsZW1lbnRbZWxlbWVudElkXS0+cHN5T3V0Q2hhbm5lbFtjaF0tPnNmYlBlckdyb3VwOwogICAgICAgIH0KCiAgICAgICAgZG8gewoKICAgICAgICAgIG5vUmVkdWN0aW9uID0gMTsKCiAgICAgICAgICBmb3IoY2g9MDsgY2g8Y20tPmVsSW5mb1tlbGVtZW50SWRdLm5DaGFubmVsc0luRWw7IGNoKyspIHsKCiAgICAgICAgICAgIElOVCBzZmIsIHNmYkdycDsKCiAgICAgICAgICAgIC8qIHN0YXJ0IHdpdGggbG93ZXN0IGVuZXJneSBib3JkZXIgYXQgaGlnaGVzdCBzZmIgKi8KICAgICAgICAgICAgaWYgKG1heFNmYlBlckdyb3VwW2NoXT49c3RhcnRTZmJbY2hdKSB7ICAvKiBzZmIgaW4gbmV4dCBjaGFubmVsICovCiAgICAgICAgICAgICAgc2ZiID0gbWF4U2ZiUGVyR3JvdXBbY2hdLS07CiAgICAgICAgICAgICAgbm9SZWR1Y3Rpb24gPSAwOwoKICAgICAgICAgICAgICBmb3IgKHNmYkdycCA9IDA7IHNmYkdycCA8IHNmYkNudFtjaF07IHNmYkdycCArPSBzZmJQZXJHcm91cFtjaF0pIHsKICAgICAgICAgICAgICAgIC8qIHNmYiBlbmVyZ3kgYmVsb3cgYm9yZGVyID8gKi8KICAgICAgICAgICAgICAgIGlmIChhaEZsYWdbZWxlbWVudElkXVtjaF1bc2ZiR3JwK3NmYl0gIT0gTk9fQUggJiYgcWNPdXRDaGFubmVsW2NoXS0+c2ZiRW5lcmd5TGREYXRhW3NmYkdycCtzZmJdIDwgZW5MRDY0W2VuSWR4XSkgewogICAgICAgICAgICAgICAgICAvKiBhbGxvdyBob2xlICovCiAgICAgICAgICAgICAgICAgIGFoRmxhZ1tlbGVtZW50SWRdW2NoXVtzZmJHcnArc2ZiXSA9IE5PX0FIOwogICAgICAgICAgICAgICAgICBxY091dENoYW5uZWxbY2hdLT5zZmJUaHJlc2hvbGRMZERhdGFbc2ZiR3JwK3NmYl0gPSBGTDJGWENPTlNUX0RCTCgwLjAxNTYyNWYpICsgcWNPdXRDaGFubmVsW2NoXS0+c2ZiV2VpZ2h0ZWRFbmVyZ3lMZERhdGFbc2ZiR3JwK3NmYl07CiAgICAgICAgICAgICAgICAgIGFjdFBlIC09IHBlRGF0YS0+cGVDaGFubmVsRGF0YVtjaF0uc2ZiUGVbc2ZiR3JwK3NmYl0+PlBFX0NPTlNUUEFSVF9TSElGVDsKICAgICAgICAgICAgICAgIH0KICAgICAgICAgICAgICB9IC8qIHNmYkdycCAgKi8KCiAgICAgICAgICAgICAgaWYgKGFjdFBlIDw9IGRlc2lyZWRQZSkgewogICAgICAgICAgICAgICAgcmV0dXJuOyAvKiBzdG9wIGlmIGVub3VnaCBoYXMgYmVlbiBzYXZlZCAqLwogICAgICAgICAgICAgIH0KICAgICAgICAgICAgfSAvKiBzZmIgPiAwICovCiAgICAgICAgICB9IC8qIGNoIGxvb3AgKi8KCiAgICAgICAgfSB3aGlsZSggKG5vUmVkdWN0aW9uID09IDApICYmIChhY3RQZSA+IGRlc2lyZWRQZSkgKTsKCiAgICAgICAgaWYgKGFjdFBlIDw9IGRlc2lyZWRQZSkgewogICAgICAgICAgcmV0dXJuOyAvKiBzdG9wIGlmIGVub3VnaCBoYXMgYmVlbiBzYXZlZCAqLwogICAgICAgIH0KCiAgICAgIH0gLyogZW5JZHggbG9vcCAqLwoKICAgIH0gLyogRU9GIERTRS1zdXBwcmVzc2lvbiAqLwogIH0gLyogRU9GIGZvciBhbGwgZWxlbWVudHMuLi4gKi8KCn0KCi8qIHJlc2V0IGF2b2lkIGhvbGUgZmxhZ3MgZnJvbSBBSF9BQ1RJVkUgdG8gQUhfSU5BQ1RJVkUgICovCnN0YXRpYyB2b2lkIEZES2FhY0VuY19yZXNldEFIRmxhZ3MoIFVDSEFSIGFoRmxhZ1soMildW01BWF9HUk9VUEVEX1NGQl0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgaW50IG5DaGFubmVscywKICAgICAgICAgICAgICAgICAgICAgICAgICBQU1lfT1VUX0NIQU5ORUwgICpwc3lPdXRDaGFubmVsWygyKV0pCnsKICBpbnQgY2gsIHNmYiwgc2ZiR3JwOwoKICBmb3IoY2g9MDsgY2g8bkNoYW5uZWxzOyBjaCsrKSB7CiAgICBmb3IgKHNmYkdycD0wOyBzZmJHcnAgPCBwc3lPdXRDaGFubmVsW2NoXS0+c2ZiQ250OyBzZmJHcnArPXBzeU91dENoYW5uZWxbY2hdLT5zZmJQZXJHcm91cCkgewogICAgICBmb3IgKHNmYj0wOyBzZmI8cHN5T3V0Q2hhbm5lbFtjaF0tPm1heFNmYlBlckdyb3VwOyBzZmIrKykgewogICAgICAgIGlmICggYWhGbGFnW2NoXVtzZmJHcnArc2ZiXSA9PSBBSF9BQ1RJVkUpIHsKICAgICAgICAgIGFoRmxhZ1tjaF1bc2ZiR3JwK3NmYl0gPSBBSF9JTkFDVElWRTsKICAgICAgICB9CiAgICAgIH0KICAgIH0KICB9Cn0KCgpzdGF0aWMgRklYUF9EQkwgQ2FsY1JlZFZhbFBvd2VyKEZJWFBfREJMIG51bSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBGSVhQX0RCTCBkZW51bSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBJTlQqICAgICBzY2FsaW5nICkKewogICAgRklYUF9EQkwgdmFsdWUgPSBGTDJGWENPTlNUX0RCTCgwLmYpOwoKICAgIGlmIChudW0+PUZMMkZYQ09OU1RfREJMKDAuZikpIHsKICAgICAgdmFsdWUgPSBmRGl2Tm9ybSggbnVtLCBkZW51bSwgc2NhbGluZyk7CiAgICB9CiAgICBlbHNlIHsKICAgICAgdmFsdWUgPSAtZkRpdk5vcm0oIC1udW0sIGRlbnVtLCBzY2FsaW5nKTsKICAgIH0KICAgIHZhbHVlID0gZjJQb3codmFsdWUsICpzY2FsaW5nLCBzY2FsaW5nKTsKICAgICpzY2FsaW5nID0gREZSQUNUX0JJVFMtMS0qc2NhbGluZzsKCiAgICByZXR1cm4gdmFsdWU7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKZnVuY3Rpb25uYW1lOiBGREthYWNFbmNfYWRhcHRUaHJlc2hvbGRzVG9QZQpkZXNjcmlwdGlvbjogIHR3byBndWVzc2VzIGZvciB0aGUgcmVkdWN0aW9uIHZhbHVlIGFuZCBvbmUgZmluYWwgY29ycmVjdGlvbiBvZiB0aGUgdGhyZXNob2xkcwoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8Kc3RhdGljIHZvaWQgRkRLYWFjRW5jX2FkYXB0VGhyZXNob2xkc1RvUGUoQ0hBTk5FTF9NQVBQSU5HKiAgY20sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQVRTX0VMRU1FTlQqICAgICAgQWRqVGhyU3RhdGVFbGVtZW50Wyg2KV0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUUNfT1VUX0VMRU1FTlQqICAgcWNFbGVtZW50Wyg2KV0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUFNZX09VVF9FTEVNRU5UKiAgcHN5T3V0RWxlbWVudFsoNildLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IElOVCAgICAgICAgIGRlc2lyZWRQZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBJTlQgICAgICAgICBwcm9jZXNzRWxlbWVudHMsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgSU5UICAgICAgICAgZWxlbWVudE9mZnNldCkKewogICBGSVhQX0RCTCByZWRWYWx1ZVsoNildOwogICBTQ0hBUiAgICByZWRWYWxTY2FsaW5nWyg2KV07CiAgIFVDSEFSICAgIHBBaEZsYWdbKDYpXVsoMildW01BWF9HUk9VUEVEX1NGQl07CiAgIEZJWFBfREJMIHBUaHJFeHBbKDYpXVsoMildW01BWF9HUk9VUEVEX1NGQl07CiAgIGludCBpdGVyOwoKICAgSU5UIGNvbnN0UGFydEdsb2JhbCwgbm9SZWRQZUdsb2JhbCwgbkFjdGl2ZUxpbmVzR2xvYmFsLCByZWRQZUdsb2JhbDsKICAgY29uc3RQYXJ0R2xvYmFsID0gbm9SZWRQZUdsb2JhbCA9IG5BY3RpdmVMaW5lc0dsb2JhbCA9IHJlZFBlR2xvYmFsID0gMDsKCiAgIGludCBlbGVtZW50SWQ7CgogICBpbnQgbkVsZW1lbnRzID0gZWxlbWVudE9mZnNldCtwcm9jZXNzRWxlbWVudHM7CiAgIGlmKG5FbGVtZW50cyA+IGNtLT5uRWxlbWVudHMpIHsKICAgICBuRWxlbWVudHMgPSBjbS0+bkVsZW1lbnRzOwogICB9CgogICAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAgIC8qIFBhcnQgSTogSW5pdGlhbGl6ZSBkYXRhIHN0cnVjdHVyZXMgYW5kIHZhcmlhYmxlcy4uLiAqLwogICAvKiAtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAgIGZvciAoZWxlbWVudElkID0gZWxlbWVudE9mZnNldDtlbGVtZW50SWQ8bkVsZW1lbnRzO2VsZW1lbnRJZCsrKSB7CiAgICAgaWYgKGNtLT5lbEluZm9bZWxlbWVudElkXS5lbFR5cGUgIT0gSURfRFNFKSB7CgogICAgICAgSU5UIG5DaGFubmVscyA9IGNtLT5lbEluZm9bZWxlbWVudElkXS5uQ2hhbm5lbHNJbkVsOwogICAgICAgUEVfREFUQSAqcGVEYXRhICAgID0gJnFjRWxlbWVudFtlbGVtZW50SWRdLT5wZURhdGE7CgogICAgICAgLyogdGhyZXNob2xkcyB0byB0aGUgcG93ZXIgb2YgcmVkRXhwICovCiAgICAgICBGREthYWNFbmNfY2FsY1RocmVzaEV4cChwVGhyRXhwW2VsZW1lbnRJZF0sIHFjRWxlbWVudFtlbGVtZW50SWRdLT5xY091dENoYW5uZWwsIHBzeU91dEVsZW1lbnRbZWxlbWVudElkXS0+cHN5T3V0Q2hhbm5lbCwgbkNoYW5uZWxzKTsKCiAgICAgICAvKiBsb3dlciB0aGUgbWluU25yIHJlcXVpcmVtZW50cyBmb3IgbG93IGVuZXJnaWVzIGNvbXBhcmVkIHRvIHRoZSBhdmVyYWdlCiAgICAgICAgICBlbmVyZ3kgaW4gdGhpcyBmcmFtZSAqLwogICAgICAgRkRLYWFjRW5jX2FkYXB0TWluU25yKHFjRWxlbWVudFtlbGVtZW50SWRdLT5xY091dENoYW5uZWwsIHBzeU91dEVsZW1lbnRbZWxlbWVudElkXS0+cHN5T3V0Q2hhbm5lbCwgJkFkalRoclN0YXRlRWxlbWVudFtlbGVtZW50SWRdLT5taW5TbnJBZGFwdFBhcmFtLCBuQ2hhbm5lbHMpOwoKICAgICAgIC8qIGluaXQgYWhGbGFnICgwOiBubyBhaCBuZWNlc3NhcnksIDE6IGFoIHBvc3NpYmxlLCAyOiBhaCBhY3RpdmUgKi8KICAgICAgIEZES2FhY0VuY19pbml0QXZvaWRIb2xlRmxhZyhxY0VsZW1lbnRbZWxlbWVudElkXS0+cWNPdXRDaGFubmVsLCBwc3lPdXRFbGVtZW50W2VsZW1lbnRJZF0tPnBzeU91dENoYW5uZWwsIHBBaEZsYWdbZWxlbWVudElkXSwgJnBzeU91dEVsZW1lbnRbZWxlbWVudElkXS0+dG9vbHNJbmZvLCBuQ2hhbm5lbHMsIHBlRGF0YSwgJkFkalRoclN0YXRlRWxlbWVudFtlbGVtZW50SWRdLT5haFBhcmFtKTsKCiAgICAgICAvKiBzdW0gdXAgKi8KICAgICAgIGNvbnN0UGFydEdsb2JhbCAgICArPSBwZURhdGEtPmNvbnN0UGFydDsKICAgICAgIG5vUmVkUGVHbG9iYWwgICAgICArPSBwZURhdGEtPnBlOwogICAgICAgbkFjdGl2ZUxpbmVzR2xvYmFsICs9IGZpeE1heCgoSU5UKXBlRGF0YS0+bkFjdGl2ZUxpbmVzLCAxKTsKCiAgICAgfSAvKiBFT0YgRFNFLXN1cHByZXNzaW9uICovCiAgIH0gLyogRU9GIGZvciBhbGwgZWxlbWVudHMuLi4gKi8KCiAgIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tICovCiAgIC8qIFBhcnQgSUk6IENhbGN1bGF0ZSBiaXQgY29uc3VtcHRpb24gb2YgaW5pdGlhbCBiaXQgY29uc3RyYWludHMgc2V0dXAgKi8KICAgLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KICAgZm9yIChlbGVtZW50SWQgPSBlbGVtZW50T2Zmc2V0O2VsZW1lbnRJZDxuRWxlbWVudHM7ZWxlbWVudElkKyspIHsKICAgICBpZiAoY20tPmVsSW5mb1tlbGVtZW50SWRdLmVsVHlwZSAhPSBJRF9EU0UpIHsKICAgICAgIC8qCiAgICAgICByZWRWYWwgPSAoIDIgXiAoIChjb25zdFBhcnRHbG9iYWwtZGVzaXJlZFBlKSAvIChpbnZSZWRFeHAqbkFjdGl2ZUxpbmVzR2xvYmFsKSApCiAgICAgICAgICAgICAgICAtIDIgXiAoIChjb25zdFBhcnRHbG9iYWwtbm9SZWRQZUdsb2JhbCkgLyAoaW52UmVkRXhwKm5BY3RpdmVMaW5lc0dsb2JhbCkgKSApCiAgICAgICAqLwoKCiAgICAgICBJTlQgbkNoYW5uZWxzID0gY20tPmVsSW5mb1tlbGVtZW50SWRdLm5DaGFubmVsc0luRWw7CiAgICAgICBQRV9EQVRBICpwZURhdGEgICAgPSAmcWNFbGVtZW50W2VsZW1lbnRJZF0tPnBlRGF0YTsKCiAgICAgICAvKiBmaXJzdCBndWVzcyBvZiByZWR1Y3Rpb24gdmFsdWUgKi8KICAgICAgIGludCBzY2FsZTA9MCwgc2NhbGUxPTA7CiAgICAgICBGSVhQX0RCTCB0bXAwID0gQ2FsY1JlZFZhbFBvd2VyKCBjb25zdFBhcnRHbG9iYWwtZGVzaXJlZFBlLCA0Km5BY3RpdmVMaW5lc0dsb2JhbCwgJnNjYWxlMCApOwogICAgICAgRklYUF9EQkwgdG1wMSA9IENhbGNSZWRWYWxQb3dlciggY29uc3RQYXJ0R2xvYmFsLW5vUmVkUGVHbG9iYWwsIDQqbkFjdGl2ZUxpbmVzR2xvYmFsLCAmc2NhbGUxICk7CgogICAgICAgaW50IHNjYWxNaW4gPSBGREttaW4oc2NhbGUwLCBzY2FsZTEpLTE7CgogICAgICAgcmVkVmFsdWVbZWxlbWVudElkXSAgPSBzY2FsZVZhbHVlKHRtcDAsKHNjYWxNaW4tc2NhbGUwKSkgLSBzY2FsZVZhbHVlKHRtcDEsKHNjYWxNaW4tc2NhbGUxKSk7CiAgICAgICByZWRWYWxTY2FsaW5nW2VsZW1lbnRJZF0gPSBzY2FsTWluOwoKICAgICAgIC8qIHJlZHVjZSB0aHJlc2hvbGRzICovCiAgICAgICBGREthYWNFbmNfcmVkdWNlVGhyZXNob2xkc0NCUihxY0VsZW1lbnRbZWxlbWVudElkXS0+cWNPdXRDaGFubmVsLCBwc3lPdXRFbGVtZW50W2VsZW1lbnRJZF0tPnBzeU91dENoYW5uZWwsIHBBaEZsYWdbZWxlbWVudElkXSwgcFRockV4cFtlbGVtZW50SWRdLCBuQ2hhbm5lbHMsIHJlZFZhbHVlW2VsZW1lbnRJZF0sIHJlZFZhbFNjYWxpbmdbZWxlbWVudElkXSk7CgogICAgICAgLyogcGUgYWZ0ZXIgZmlyc3QgZ3Vlc3MgKi8KICAgICAgIEZES2FhY0VuY19jYWxjUGUocHN5T3V0RWxlbWVudFtlbGVtZW50SWRdLT5wc3lPdXRDaGFubmVsLCBxY0VsZW1lbnRbZWxlbWVudElkXS0+cWNPdXRDaGFubmVsLCBwZURhdGEsIG5DaGFubmVscyk7CgogICAgICAgcmVkUGVHbG9iYWwgKz0gcGVEYXRhLT5wZTsKICAgICB9IC8qIEVPRiBEU0Utc3VwcHJlc3Npb24gKi8KICAgfSAvKiBFT0YgZm9yIGFsbCBlbGVtZW50cy4uLiAqLwoKICAgLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KICAgLyogUGFydCBJSUk6IEl0ZXJhdGUgdW50aWwgYml0IGNvbnN0cmFpbnRzIGFyZSBtZXQgKi8KICAgLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KICAgaXRlciA9IDA7CiAgIHdoaWxlICgoZml4cF9hYnMocmVkUGVHbG9iYWwgLSBkZXNpcmVkUGUpID4gZk11bHRJKEZMMkZYQ09OU1RfREJMKDAuMDVmKSxkZXNpcmVkUGUpKSAmJiAoaXRlciA8IDEpKSB7CgogICAgIElOVCBkZXNpcmVkUGVOb0FIR2xvYmFsOwogICAgIElOVCByZWRQZU5vQUhHbG9iYWwgPSAwOwogICAgIElOVCBjb25zdFBhcnROb0FIR2xvYmFsID0gMDsKICAgICBJTlQgbkFjdGl2ZUxpbmVzTm9BSEdsb2JhbCA9IDA7CgogICAgIGZvciAoZWxlbWVudElkID0gZWxlbWVudE9mZnNldDtlbGVtZW50SWQ8bkVsZW1lbnRzO2VsZW1lbnRJZCsrKSB7CiAgICAgICBpZiAoY20tPmVsSW5mb1tlbGVtZW50SWRdLmVsVHlwZSAhPSBJRF9EU0UpIHsKCiAgICAgICAgIElOVCByZWRQZU5vQUgsIGNvbnN0UGFydE5vQUgsIG5BY3RpdmVMaW5lc05vQUg7CiAgICAgICAgIElOVCBuQ2hhbm5lbHMgPSBjbS0+ZWxJbmZvW2VsZW1lbnRJZF0ubkNoYW5uZWxzSW5FbDsKICAgICAgICAgUEVfREFUQSAqcGVEYXRhICAgID0gJnFjRWxlbWVudFtlbGVtZW50SWRdLT5wZURhdGE7CgogICAgICAgICAvKiBwZSBmb3IgYmFuZHMgd2hlcmUgYXZvaWQgaG9sZSBpcyBpbmFjdGl2ZSAqLwogICAgICAgICBGREthYWNFbmNfRkRLYWFjRW5jX2NhbGNQZU5vQUgoJnJlZFBlTm9BSCwgJmNvbnN0UGFydE5vQUgsICZuQWN0aXZlTGluZXNOb0FILAogICAgICAgICAgICAgICAgICAgIHBlRGF0YSwgcEFoRmxhZ1tlbGVtZW50SWRdLCBwc3lPdXRFbGVtZW50W2VsZW1lbnRJZF0tPnBzeU91dENoYW5uZWwsIG5DaGFubmVscyk7CgogICAgICAgICByZWRQZU5vQUhHbG9iYWwgKz0gcmVkUGVOb0FIOwogICAgICAgICBjb25zdFBhcnROb0FIR2xvYmFsICs9IGNvbnN0UGFydE5vQUg7CiAgICAgICAgIG5BY3RpdmVMaW5lc05vQUhHbG9iYWwgKz0gbkFjdGl2ZUxpbmVzTm9BSDsKICAgICAgIH0gLyogRU9GIERTRS1zdXBwcmVzc2lvbiAqLwogICAgIH0gLyogRU9GIGZvciBhbGwgZWxlbWVudHMuLi4gKi8KCiAgICAgLyogQ2FsY3VsYXRlIG5ldyByZWRWYWwgLi4uICovCiAgICAgaWYoZGVzaXJlZFBlIDwgcmVkUGVHbG9iYWwpIHsKCiAgICAgICAvKiBuZXcgZGVzaXJlZCBwZSB3aXRob3V0IGJhbmRzIHdoZXJlIGF2b2lkIGhvbGUgaXMgYWN0aXZlICovCiAgICAgICBkZXNpcmVkUGVOb0FIR2xvYmFsID0gZGVzaXJlZFBlIC0gKHJlZFBlR2xvYmFsIC0gcmVkUGVOb0FIR2xvYmFsKTsKCiAgICAgICAvKiBsaW1pdCBkZXNpcmVkUGVOb0FIIHRvIHBvc2l0aXZlIHZhbHVlcywgYXMgdGhlIFBFIGNhbiBub3QgYmVjb21lIG5lZ2F0aXZlICovCiAgICAgICBkZXNpcmVkUGVOb0FIR2xvYmFsID0gRkRLbWF4KDAsZGVzaXJlZFBlTm9BSEdsb2JhbCk7CgogICAgICAgLyogc2Vjb25kIGd1ZXNzIChvbmx5IGlmIHRoZXJlIGFyZSBiYW5kcyBsZWZ0IHdoZXJlIGF2b2lkIGhvbGUgaXMgaW5hY3RpdmUpKi8KICAgICAgIGlmIChuQWN0aXZlTGluZXNOb0FIR2xvYmFsID4gMCkgewogICAgICAgICBmb3IgKGVsZW1lbnRJZCA9IGVsZW1lbnRPZmZzZXQ7ZWxlbWVudElkPG5FbGVtZW50cztlbGVtZW50SWQrKykgewogICAgICAgICAgIGlmIChjbS0+ZWxJbmZvW2VsZW1lbnRJZF0uZWxUeXBlICE9IElEX0RTRSkgewogICAgICAgICAgICAgLyoKICAgICAgICAgICAgIHJlZFZhbCArPSAoIDIgXiAoIChjb25zdFBhcnROb0FIR2xvYmFsLWRlc2lyZWRQZU5vQUhHbG9iYWwpIC8gKGludlJlZEV4cCpuQWN0aXZlTGluZXNOb0FIR2xvYmFsKSApCiAgICAgICAgICAgICAgICAgICAgICAgLSAyIF4gKCAoY29uc3RQYXJ0Tm9BSEdsb2JhbC1yZWRQZU5vQUhHbG9iYWwpIC8gKGludlJlZEV4cCpuQWN0aXZlTGluZXNOb0FIR2xvYmFsKSApICkKICAgICAgICAgICAgICovCiAgICAgICAgICAgICBpbnQgc2NhbGUwID0gMDsKICAgICAgICAgICAgIGludCBzY2FsZTEgPSAwOwoKICAgICAgICAgICAgIEZJWFBfREJMIHRtcDAgPSBDYWxjUmVkVmFsUG93ZXIoIGNvbnN0UGFydE5vQUhHbG9iYWwtZGVzaXJlZFBlTm9BSEdsb2JhbCwgNCpuQWN0aXZlTGluZXNOb0FIR2xvYmFsLCAmc2NhbGUwICk7CiAgICAgICAgICAgICBGSVhQX0RCTCB0bXAxID0gQ2FsY1JlZFZhbFBvd2VyKCBjb25zdFBhcnROb0FIR2xvYmFsLXJlZFBlTm9BSEdsb2JhbCwgNCpuQWN0aXZlTGluZXNOb0FIR2xvYmFsLCAmc2NhbGUxICk7CgogICAgICAgICAgICAgaW50IHNjYWxNaW4gPSBGREttaW4oc2NhbGUwLCBzY2FsZTEpLTE7CgogICAgICAgICAgICAgdG1wMCA9IHNjYWxlVmFsdWUodG1wMCwoc2NhbE1pbi1zY2FsZTApKSAtIHNjYWxlVmFsdWUodG1wMSwoc2NhbE1pbi1zY2FsZTEpKTsKICAgICAgICAgICAgIHNjYWxlMCA9IHNjYWxNaW47CgogICAgICAgICAgICAgLyogb2xkIHJlZHVjdGlvbiB2YWx1ZSAqLwogICAgICAgICAgICAgdG1wMSA9IHJlZFZhbHVlW2VsZW1lbnRJZF07CiAgICAgICAgICAgICBzY2FsZTEgPSByZWRWYWxTY2FsaW5nW2VsZW1lbnRJZF07CgogICAgICAgICAgICAgc2NhbE1pbiA9IGZpeE1pbihzY2FsZTAsc2NhbGUxKS0xOwoKICAgICAgICAgICAgIC8qIHN1bSB1cCBvbGQgYW5kIG5ldyByZWR1Y3Rpb24gdmFsdWUgKi8KICAgICAgICAgICAgIHJlZFZhbHVlW2VsZW1lbnRJZF0gPSBzY2FsZVZhbHVlKHRtcDAsKHNjYWxNaW4tc2NhbGUwKSkgKyBzY2FsZVZhbHVlKHRtcDEsKHNjYWxNaW4tc2NhbGUxKSk7CiAgICAgICAgICAgICByZWRWYWxTY2FsaW5nW2VsZW1lbnRJZF0gPSBzY2FsTWluOwoKICAgICAgICAgICB9IC8qIEVPRiBEU0Utc3VwcHJlc3Npb24gKi8KICAgICAgICAgfSAvKiBFT0YgZm9yIGFsbCBlbGVtZW50cy4uLiAqLwogICAgICAgfSAvKiBuQWN0aXZlTGluZXNOb0FIR2xvYmFsID4gMCAqLwogICAgIH0KICAgICBlbHNlIHsKICAgICAgICAvKiBkZXNpcmVkUGUgPj0gcmVkUGVHbG9iYWwgKi8KICAgICAgICBmb3IgKGVsZW1lbnRJZCA9IGVsZW1lbnRPZmZzZXQ7ZWxlbWVudElkPG5FbGVtZW50cztlbGVtZW50SWQrKykgewogICAgICAgICAgaWYgKGNtLT5lbEluZm9bZWxlbWVudElkXS5lbFR5cGUgIT0gSURfRFNFKSB7CgogICAgICAgICAgICBJTlQgcmVkVmFsX3NjYWxlID0gMDsKICAgICAgICAgICAgRklYUF9EQkwgdG1wID0gZkRpdk5vcm0oKEZJWFBfREJMKXJlZFBlR2xvYmFsLCAoRklYUF9EQkwpZGVzaXJlZFBlLCAmcmVkVmFsX3NjYWxlKTsKCiAgICAgICAgICAgIC8qIHJlZFZhbCAqPSByZWRQZUdsb2JhbC9kZXNpcmVkUGU7ICovCiAgICAgICAgICAgIHJlZFZhbHVlW2VsZW1lbnRJZF0gPSBmTXVsdChyZWRWYWx1ZVtlbGVtZW50SWRdLCB0bXApOwogICAgICAgICAgICByZWRWYWxTY2FsaW5nW2VsZW1lbnRJZF0gLT0gcmVkVmFsX3NjYWxlOwoKICAgICAgICAgICAgRkRLYWFjRW5jX3Jlc2V0QUhGbGFncyhwQWhGbGFnW2VsZW1lbnRJZF0sIGNtLT5lbEluZm9bZWxlbWVudElkXS5uQ2hhbm5lbHNJbkVsLCBwc3lPdXRFbGVtZW50W2VsZW1lbnRJZF0tPnBzeU91dENoYW5uZWwpOwogICAgICAgICAgfSAvKiBFT0YgRFNFLXN1cHByZXNzaW9uICovCiAgICAgICAgfSAvKiBFT0YgZm9yIGFsbCBlbGVtZW50cy4uLiAqLwogICAgIH0KCiAgICAgcmVkUGVHbG9iYWwgPSAwOwogICAgIC8qIENhbGN1bGF0ZSBuZXcgcmVkVmFsJ3MgUEUuLi4gKi8KICAgICBmb3IgKGVsZW1lbnRJZCA9IGVsZW1lbnRPZmZzZXQ7ZWxlbWVudElkPG5FbGVtZW50cztlbGVtZW50SWQrKykgewogICAgICAgaWYgKGNtLT5lbEluZm9bZWxlbWVudElkXS5lbFR5cGUgIT0gSURfRFNFKSB7CgogICAgICAgICBJTlQgbkNoYW5uZWxzID0gY20tPmVsSW5mb1tlbGVtZW50SWRdLm5DaGFubmVsc0luRWw7CiAgICAgICAgIFBFX0RBVEEgKnBlRGF0YSAgICA9ICZxY0VsZW1lbnRbZWxlbWVudElkXS0+cGVEYXRhOwoKICAgICAgICAgLyogcmVkdWNlIHRocmVzaG9sZHMgKi8KICAgICAgICAgRkRLYWFjRW5jX3JlZHVjZVRocmVzaG9sZHNDQlIocWNFbGVtZW50W2VsZW1lbnRJZF0tPnFjT3V0Q2hhbm5lbCwgcHN5T3V0RWxlbWVudFtlbGVtZW50SWRdLT5wc3lPdXRDaGFubmVsLCBwQWhGbGFnW2VsZW1lbnRJZF0sIHBUaHJFeHBbZWxlbWVudElkXSwgbkNoYW5uZWxzLCByZWRWYWx1ZVtlbGVtZW50SWRdLCByZWRWYWxTY2FsaW5nW2VsZW1lbnRJZF0pOwoKICAgICAgICAgLyogcGUgYWZ0ZXIgc2Vjb25kIGd1ZXNzICovCiAgICAgICAgIEZES2FhY0VuY19jYWxjUGUocHN5T3V0RWxlbWVudFtlbGVtZW50SWRdLT5wc3lPdXRDaGFubmVsLCBxY0VsZW1lbnRbZWxlbWVudElkXS0+cWNPdXRDaGFubmVsLCBwZURhdGEsIG5DaGFubmVscyk7CiAgICAgICAgIHJlZFBlR2xvYmFsICs9IHBlRGF0YS0+cGU7CgogICAgICAgfSAvKiBFT0YgRFNFLXN1cHByZXNzaW9uICovCiAgICAgfSAvKiBFT0YgZm9yIGFsbCBlbGVtZW50cy4uLiAqLwoKICAgICBpdGVyKys7CiAgIH0gLyogRU9GIHdoaWxlICovCgoKICAgLyogLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSAqLwogICAvKiBQYXJ0IElWOiBpZiBzdGlsbCByZXF1aXJlZCwgZnVydGhlciByZWR1Y2UgY29uc3RyYWludHMgICovCiAgIC8qIC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0gKi8KICAgLyogICAgICAgICAgICAgICAgICAxLjAqICAgICAgICAxLjE1KiAgICAgICAxLjIwKgogICAgKiAgICAgICAgICAgICAgIGRlc2lyZWRQZSAgIGRlc2lyZWRQZSAgIGRlc2lyZWRQZQogICAgKiAgICAgICAgICAgICAgICAgICB8ICAgICAgICAgICB8ICAgICAgICAgICB8CiAgICAqIC4uLlhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWFhYWHwgICAgICAgICAgIHwKICAgICogICAgICAgICAgICAgICAgICAgfCAgICAgICAgICAgfCAgICAgICAgICAgfFhYWFhYWFhYWFhYLi4uCiAgICAqICAgICAgICAgICAgICAgICAgIHwgICAgICAgICAgIHxYWFhYWFhYWFhYWHwKICAgICogICAgICAgICAgICAtLS0gQSAtLS0gICAgICAgICAgfCAtLS0gQiAtLS0gfCAtLS0gQyAtLS0KICAgICoKICAgICogKFgpOiByZWRQZUdsb2JhbAogICAgKiAoQSk6IEZES2FhY0VuY19jb3JyZWN0VGhyZXNoKCkKICAgICogKEIpOiBGREthYWNFbmNfYWxsb3dNb3JlSG9sZXMoKQogICAgKiAoQyk6IEZES2FhY0VuY19yZWR1Y2VNaW5TbnIoKQogICAqLwoKICAgLyogY29ycmVjdCB0aHJlc2hvbGRzIHRvIGdldCBjbG9zZXIgdG8gdGhlIGRlc2lyZWQgcGUgKi8KICAgaWYgKCByZWRQZUdsb2JhbCA+IGRlc2lyZWRQZSApIHsKICAgICBGREthYWNFbmNfY29ycmVjdFRocmVzaChjbSwgcWNFbGVtZW50LCBwc3lPdXRFbGVtZW50LCBwQWhGbGFnLCBwVGhyRXhwLCByZWRWYWx1ZSwgcmVkVmFsU2NhbGluZywKICAgICAgICAgICAgICAgICAgIGRlc2lyZWRQZSAtIHJlZFBlR2xvYmFsLCBwcm9jZXNzRWxlbWVudHMsIGVsZW1lbnRPZmZzZXQpOwoKICAgICAvKiB1cGRhdGUgUEUgKi8KICAgICByZWRQZUdsb2JhbCA9IDA7CiAgICAgZm9yKGVsZW1lbnRJZD1lbGVtZW50T2Zmc2V0O2VsZW1lbnRJZDxuRWxlbWVudHM7ZWxlbWVudElkKyspIHsKICAgICAgIGlmIChjbS0+ZWxJbmZvW2VsZW1lbnRJZF0uZWxUeXBlICE9IElEX0RTRSkgewoKICAgICAgICAgSU5UIG5DaGFubmVscyA9IGNtLT5lbEluZm9bZWxlbWVudElkXS5uQ2hhbm5lbHNJbkVsOwogICAgICAgICBQRV9EQVRBICpwZURhdGEgICAgPSAmcWNFbGVtZW50W2VsZW1lbnRJZF0tPnBlRGF0YTsKCiAgICAgICAgIC8qIHBlIGFmdGVyIGNvcnJlY3RUaHJlc2ggKi8KICAgICAgICAgRkRLYWFjRW5jX2NhbGNQZShwc3lPdXRFbGVtZW50W2VsZW1lbnRJZF0tPnBzeU91dENoYW5uZWwsIHFjRWxlbWVudFtlbGVtZW50SWRdLT5xY091dENoYW5uZWwsIHBlRGF0YSwgbkNoYW5uZWxzKTsKICAgICAgICAgcmVkUGVHbG9iYWwgKz0gcGVEYXRhLT5wZTsKCiAgICAgICB9IC8qIEVPRiBEU0Utc3VwcHJlc3Npb24gKi8KICAgICB9IC8qIEVPRiBmb3IgYWxsIGVsZW1lbnRzLi4uICovCiAgIH0KCiAgIGlmICggcmVkUGVHbG9iYWwgPiBkZXNpcmVkUGUgKSB7CiAgICAgLyogcmVkdWNlIHBlIGJ5IHJlZHVjaW5nIG1pblNuciByZXF1aXJlbWVudHMgKi8KICAgICBGREthYWNFbmNfcmVkdWNlTWluU25yKGNtLCBxY0VsZW1lbnQsIHBzeU91dEVsZW1lbnQsIHBBaEZsYWcsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAoZk11bHRJKEZMMkZYQ09OU1RfREJMKDAuMTVmKSxkZXNpcmVkUGUpICsgZGVzaXJlZFBlKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICZyZWRQZUdsb2JhbCwgcHJvY2Vzc0VsZW1lbnRzLCBlbGVtZW50T2Zmc2V0KTsKCiAgICAgLyogcmVkdWNlIHBlIGJ5IGFsbG93aW5nIGFkZGl0aW9uYWwgc3BlY3RyYWwgaG9sZXMgKi8KICAgICBGREthYWNFbmNfYWxsb3dNb3JlSG9sZXMoY20sIHFjRWxlbWVudCwgcHN5T3V0RWxlbWVudCwgQWRqVGhyU3RhdGVFbGVtZW50LCBwQWhGbGFnLAogICAgICAgICAgICAgICAgICAgIGRlc2lyZWRQZSwgcmVkUGVHbG9iYWwsIHByb2Nlc3NFbGVtZW50cywgZWxlbWVudE9mZnNldCk7CiAgIH0KCn0KCgovKiBzaW1pbGFyIHRvIEZES2FhY0VuY19hZGFwdFRocmVzaG9sZHNUb1BlKCksIGZvciAgVkJSLW1vZGUgKi8Kdm9pZCBGREthYWNFbmNfQWRhcHRUaHJlc2hvbGRzVkJSKFFDX09VVF9DSEFOTkVMKiBxY091dENoYW5uZWxbKDIpXSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBTWV9PVVRfQ0hBTk5FTCogcHN5T3V0Q2hhbm5lbFsoMildLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQVRTX0VMRU1FTlQqIEFkalRoclN0YXRlRWxlbWVudCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHN0cnVjdCBUT09MU0lORk8gKnRvb2xzSW5mbywKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBFX0RBVEEgKnBlRGF0YSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IElOVCBuQ2hhbm5lbHMpCnsKICAgVUNIQVIgICAgcEFoRmxhZ1soMildW01BWF9HUk9VUEVEX1NGQl07CiAgIEZJWFBfREJMIHBUaHJFeHBbKDIpXVtNQVhfR1JPVVBFRF9TRkJdOwoKICAgLyogdGhyZXNob2xkcyB0byB0aGUgcG93ZXIgb2YgcmVkRXhwICovCiAgIEZES2FhY0VuY19jYWxjVGhyZXNoRXhwKHBUaHJFeHAsIHFjT3V0Q2hhbm5lbCwgcHN5T3V0Q2hhbm5lbCwgbkNoYW5uZWxzKTsKCiAgIC8qIGxvd2VyIHRoZSBtaW5TbnIgcmVxdWlyZW1lbnRzIGZvciBsb3cgZW5lcmdpZXMgY29tcGFyZWQgdG8gdGhlIGF2ZXJhZ2UKICAgICAgZW5lcmd5IGluIHRoaXMgZnJhbWUgKi8KICAgRkRLYWFjRW5jX2FkYXB0TWluU25yKHFjT3V0Q2hhbm5lbCwgcHN5T3V0Q2hhbm5lbCwgJkFkalRoclN0YXRlRWxlbWVudC0+bWluU25yQWRhcHRQYXJhbSwgbkNoYW5uZWxzKTsKCiAgIC8qIGluaXQgYWhGbGFnICgwOiBubyBhaCBuZWNlc3NhcnksIDE6IGFoIHBvc3NpYmxlLCAyOiBhaCBhY3RpdmUgKi8KICAgRkRLYWFjRW5jX2luaXRBdm9pZEhvbGVGbGFnKHFjT3V0Q2hhbm5lbCwgcHN5T3V0Q2hhbm5lbCwgcEFoRmxhZywgdG9vbHNJbmZvLAogICAgICAgICAgICAgICAgICAgICBuQ2hhbm5lbHMsIHBlRGF0YSwgJkFkalRoclN0YXRlRWxlbWVudC0+YWhQYXJhbSk7CgogICAvKiByZWR1Y2UgdGhyZXNob2xkcyAqLwogICBGREthYWNFbmNfcmVkdWNlVGhyZXNob2xkc1ZCUihxY091dENoYW5uZWwsIHBzeU91dENoYW5uZWwsIHBBaEZsYWcsIHBUaHJFeHAsIG5DaGFubmVscywKICAgICAgICAgICAgICAgICAgICAgICBBZGpUaHJTdGF0ZUVsZW1lbnQtPnZiclF1YWxGYWN0b3IsCiAgICAgICAgICAgICAgICAgICAgICAgJkFkalRoclN0YXRlRWxlbWVudC0+Y2hhb3NNZWFzdXJlT2xkKTsKCn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKCiAgZnVuY3Rpb25uYW1lOiBGREthYWNFbmNfY2FsY0JpdFNhdmUKICBkZXNjcmlwdGlvbjogIENhbGN1bGF0ZXMgcGVyY2VudGFnZSBvZiBiaXQgc2F2ZSwgc2VlIGZpZ3VyZSBiZWxvdwogIHJldHVybnM6CiAgaW5wdXQ6ICAgICAgICBwYXJhbWV0ZXJzIGFuZCBiaXRyZXMtZnVsbG5lc3MKICBvdXRwdXQ6ICAgICAgIHBlcmNlbnRhZ2Ugb2YgYml0IHNhdmUKCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwovKgogICAgICAgIGJpdHNhdmUKICAgICAgICAgICAgICAgICAgICBtYXhCaXRTYXZlKCUpfCAgIGNsaXBMb3cKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfC0tLVwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICBcCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgIFwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAgIFwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAgICBcCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwtLS0tLS0tLVwtLS0tLS0tLS0tLS0tLT4gYml0cmVzCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAgICAgICBcCiAgICAgICAgICAgICAgICAgICAgbWluQml0U2F2ZSglKXwgICAgICAgICAgXC0tLS0tLS0tLS0tLQogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjbGlwSGlnaCAgICAgIG1heEJpdHJlcwoqLwpzdGF0aWMgRklYUF9EQkwgRkRLYWFjRW5jX2NhbGNCaXRTYXZlKEZJWFBfREJMIGZpbGxMZXZlbCwKICAgIGNvbnN0IEZJWFBfREJMIGNsaXBMb3csCiAgICBjb25zdCBGSVhQX0RCTCBjbGlwSGlnaCwKICAgIGNvbnN0IEZJWFBfREJMIG1pbkJpdFNhdmUsCiAgICBjb25zdCBGSVhQX0RCTCBtYXhCaXRTYXZlLAogICAgY29uc3QgRklYUF9EQkwgYml0c2F2ZV9zbG9wZSkKewogICAgRklYUF9EQkwgYml0c2F2ZTsKCiAgICBmaWxsTGV2ZWwgPSBmaXhNYXgoZmlsbExldmVsLCBjbGlwTG93KTsKICAgIGZpbGxMZXZlbCA9IGZpeE1pbihmaWxsTGV2ZWwsIGNsaXBIaWdoKTsKCiAgICBiaXRzYXZlID0gbWF4Qml0U2F2ZSAtIGZNdWx0KChmaWxsTGV2ZWwtY2xpcExvdyksIGJpdHNhdmVfc2xvcGUpOwoKICAgIHJldHVybiAoYml0c2F2ZSk7Cn0KCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgoKICBmdW5jdGlvbm5hbWU6IEZES2FhY0VuY19jYWxjQml0U3BlbmQKICBkZXNjcmlwdGlvbjogIENhbGN1bGF0ZXMgcGVyY2VudGFnZSBvZiBiaXQgc3BlbmQsIHNlZSBmaWd1cmUgYmVsb3cKICByZXR1cm5zOgogIGlucHV0OiAgICAgICAgcGFyYW1ldGVycyBhbmQgYml0cmVzLWZ1bGxuZXNzCiAgb3V0cHV0OiAgICAgICBwZXJjZW50YWdlIG9mIGJpdCBzcGVuZAoKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCi8qCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGJpdHNwZW5kICAgICAgY2xpcEhpZ2gKICAgICAgICAgICAgICAgICAgIG1heEJpdFNwZW5kKCUpfCAgICAgICAgICAvLS0tLS0tLS0tLS1tYXhCaXRyZXMKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAgICAgIC8KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAgICAgLwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgICAgIC8KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAgIC8KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAgLwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8LS0tLS8tLS0tLS0tLS0tLS0tLS0tLT4gYml0cmVzCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAvCiAgICAgICAgICAgICAgICAgICBtaW5CaXRTcGVuZCglKXwtLS8KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjbGlwTG93CiovCnN0YXRpYyBGSVhQX0RCTCBGREthYWNFbmNfY2FsY0JpdFNwZW5kKEZJWFBfREJMIGZpbGxMZXZlbCwKICAgIGNvbnN0IEZJWFBfREJMIGNsaXBMb3csCiAgICBjb25zdCBGSVhQX0RCTCBjbGlwSGlnaCwKICAgIGNvbnN0IEZJWFBfREJMIG1pbkJpdFNwZW5kLAogICAgY29uc3QgRklYUF9EQkwgbWF4Qml0U3BlbmQsCiAgICBjb25zdCBGSVhQX0RCTCBiaXRzcGVuZF9zbG9wZSkKewogICAgRklYUF9EQkwgYml0c3BlbmQ7CgogICAgZmlsbExldmVsID0gZml4TWF4KGZpbGxMZXZlbCwgY2xpcExvdyk7CiAgICBmaWxsTGV2ZWwgPSBmaXhNaW4oZmlsbExldmVsLCBjbGlwSGlnaCk7CgogICAgYml0c3BlbmQgPSBtaW5CaXRTcGVuZCArIGZNdWx0KGZpbGxMZXZlbC1jbGlwTG93LCBiaXRzcGVuZF9zbG9wZSk7CgogICAgcmV0dXJuIChiaXRzcGVuZCk7Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKCiAgZnVuY3Rpb25uYW1lOiBGREthYWNFbmNfYWRqdXN0UGVNaW5NYXgoKQogIGRlc2NyaXB0aW9uOiAgYWRqdXN0cyBwZU1pbiBhbmQgcGVNYXggcGFyYW1ldGVycyBvdmVyIHRpbWUKICByZXR1cm5zOgogIGlucHV0OiAgICAgICAgY3VycmVudCBwZSwgcGVNaW4sIHBlTWF4LCBiaXRyZXMgc2l6ZQogIG91dHB1dDogICAgICAgYWRqdXN0ZWQgcGVNaW4vcGVNYXgKCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwpzdGF0aWMgdm9pZCBGREthYWNFbmNfYWRqdXN0UGVNaW5NYXgoY29uc3QgSU5UIGN1cnJQZSwKICAgIElOVCAgICAgICpwZU1pbiwKICAgIElOVCAgICAgICpwZU1heCkKewogIEZJWFBfREJMIG1pbkZhY0hpID0gRkwyRlhDT05TVF9EQkwoMC4zZiksIG1heEZhY0hpID0gKEZJWFBfREJMKU1BWFZBTF9EQkwsIG1pbkZhY0xvID0gRkwyRlhDT05TVF9EQkwoMC4xNGYpLCBtYXhGYWNMbyA9IEZMMkZYQ09OU1RfREJMKDAuMDdmKTsKICAgIElOVCBkaWZmOwoKICAgIElOVCBtaW5EaWZmX2ZpeCA9IGZNdWx0SShGTDJGWENPTlNUX0RCTCgwLjE2NjY2NjY2NjdmKSwgY3VyclBlKTsKCiAgICBpZiAoY3VyclBlID4gKnBlTWF4KQogICAgewogICAgICAgIGRpZmYgPSAoY3VyclBlLSpwZU1heCkgOwogICAgICAgICpwZU1pbiArPSBmTXVsdEkobWluRmFjSGksZGlmZik7CiAgICAgICAgKnBlTWF4ICs9IGZNdWx0SShtYXhGYWNIaSxkaWZmKTsKICAgIH0KICAgIGVsc2UgaWYgKGN1cnJQZSA8ICpwZU1pbikKICAgIHsKICAgICAgICBkaWZmID0gKCpwZU1pbi1jdXJyUGUpIDsKICAgICAgICAqcGVNaW4gLT0gZk11bHRJKG1pbkZhY0xvLGRpZmYpOwogICAgICAgICpwZU1heCAtPSBmTXVsdEkobWF4RmFjTG8sZGlmZik7CiAgICB9CiAgICBlbHNlCiAgICB7CiAgICAgICAgKnBlTWluICs9IGZNdWx0SShtaW5GYWNIaSwgKGN1cnJQZSAtICpwZU1pbikpOwogICAgICAgICpwZU1heCAtPSBmTXVsdEkobWF4RmFjTG8sICgqcGVNYXggLSBjdXJyUGUpKTsKICAgIH0KCiAgICBpZiAoKCpwZU1heCAtICpwZU1pbikgPCBtaW5EaWZmX2ZpeCkKICAgIHsKICAgICAgICBJTlQgcGVNYXhfZml4ID0gKnBlTWF4LCBwZU1pbl9maXggPSAqcGVNaW47CiAgICAgICAgRklYUF9EQkwgcGFydExvX2ZpeCwgcGFydEhpX2ZpeDsKCiAgICAgICAgcGFydExvX2ZpeCA9IChGSVhQX0RCTClmaXhNYXgoMCwgY3VyclBlIC0gcGVNaW5fZml4KTsKICAgICAgICBwYXJ0SGlfZml4ID0gKEZJWFBfREJMKWZpeE1heCgwLCBwZU1heF9maXggLSBjdXJyUGUpOwoKICAgICAgICBwZU1heF9maXggPSAoSU5UKShjdXJyUGUgKyBmTXVsdEkoZkRpdk5vcm0ocGFydEhpX2ZpeCwgKHBhcnRMb19maXgrcGFydEhpX2ZpeCkpLCBtaW5EaWZmX2ZpeCkpOwogICAgICAgIHBlTWluX2ZpeCA9IChJTlQpKGN1cnJQZSAtIGZNdWx0SShmRGl2Tm9ybShwYXJ0TG9fZml4LCAocGFydExvX2ZpeCtwYXJ0SGlfZml4KSksIG1pbkRpZmZfZml4KSk7CiAgICAgICAgcGVNaW5fZml4ID0gZml4TWF4KDAsIHBlTWluX2ZpeCk7CgogICAgICAgICpwZU1heCA9IHBlTWF4X2ZpeDsKICAgICAgICAqcGVNaW4gPSBwZU1pbl9maXg7CiAgICB9Cn0KCgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCgogIGZ1bmN0aW9ubmFtZTogQml0cmVzQ2FsY0JpdEZhYwogIGRlc2NyaXB0aW9uOiAgY2FsY3VsYXRlcyBmYWN0b3Igb2Ygc3BlbmRpbmcgYml0cyBmb3Igb25lIGZyYW1lCiAgMS4wIDogdGFrZSBhbGwgZnJhbWUgZHlucGFydCBiaXRzCiAgPjEuMCA6IHRha2UgYWxsIGZyYW1lIGR5bnBhcnQgYml0cyArIGJpdHJlcwogIDwxLjAgOiBwdXQgYml0cyBpbiBiaXRyZXNlcnZvaXIKICByZXR1cm5zOiAgICAgIEJpdEZhYwogIGlucHV0OiAgICAgICAgYml0cmVzLWZ1bGxuZXNzLCBwZSwgYmxvY2tUeXBlLCBwYXJhbWV0ZXItc2V0dGluZ3MKICBvdXRwdXQ6CgoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8KLyoKICAgICAgICAgICAgICAgICAgICAgYml0ZmFjKCUpICAgICAgICAgICAgcGVtYXgKICAgICAgICAgICAgICAgICAgIGJpdHNwZW5kKCUpICAgfCAgICAgICAgICAvLS0tLS0tLS0tLS1tYXhCaXRyZXMKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAgICAgIC8KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAgICAgLwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8ICAgICAgIC8KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAgIC8KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgICAgLwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB8LS0tLS8tLS0tLS0tLS0tLS0tLS0tLT4gcGUKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIC8KICAgICAgICAgICAgICAgICAgIGJpdHNhdmUoJSkgICAgfC0tLwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwZW1pbgoqLwoKc3RhdGljIEZJWFBfREJMIEZES2FhY0VuY19iaXRyZXNDYWxjQml0RmFjKGNvbnN0IElOVCAgICAgICBiaXRyZXNCaXRzLAogICAgY29uc3QgSU5UICAgICAgICBtYXhCaXRyZXNCaXRzLAogICAgY29uc3QgSU5UICAgICAgICBwZSwKICAgIGNvbnN0IElOVCAgICAgICAgbGFzdFdpbmRvd1NlcXVlbmNlLAogICAgY29uc3QgSU5UICAgICAgICBhdmdCaXRzLAogICAgY29uc3QgRklYUF9EQkwgICBtYXhCaXRGYWMsCiAgICBBREpfVEhSX1NUQVRFICAgKkFkalRociwKICAgIEFUU19FTEVNRU5UICAgICAqYWRqVGhyQ2hhbikKewogICAgQlJFU19QQVJBTSAqYnJlc1BhcmFtOwogICAgSU5UIHBleDsKCiAgICBJTlQgcW1pbiwgcWJyLCBxYnJlcywgcW1icjsKICAgIEZJWFBfREJMIGJpdFNhdmUsIGJpdFNwZW5kOwoKICAgIEZJWFBfREJMIGJpdHJlc0ZhY19maXgsIHRtcF9jc3QsIHRtcF9maXg7CiAgICBGSVhQX0RCTCBwZV9wZXJzLCBiaXRzX3JhdGlvLCBtYXhCclZhbDsKICAgIEZJWFBfREJMIGJpdHNhdmVfc2xvcGUsIGJpdHNwZW5kX3Nsb3BlLCBtYXhCaXRGYWNfdG1wOwogICAgRklYUF9EQkwgZmlsbExldmVsX2ZpeCA9IChGSVhQX0RCTCkweDdmZmZmZmZmOwogICAgRklYUF9EQkwgVU5JVFkgPSAoRklYUF9EQkwpMHg3ZmZmZmZmZjsKICAgIEZJWFBfREJMIFBPSU5UNyA9IChGSVhQX0RCTCkweDU5OTk5OTlBOwoKICAgIGlmIChtYXhCaXRyZXNCaXRzID4gYml0cmVzQml0cykgewogICAgICBmaWxsTGV2ZWxfZml4ID0gZkRpdk5vcm0oYml0cmVzQml0cywgbWF4Qml0cmVzQml0cyk7CiAgICB9CgogICAgaWYgKGxhc3RXaW5kb3dTZXF1ZW5jZSAhPSBTSE9SVF9XSU5ET1cpCiAgICB7CiAgICAgICAgYnJlc1BhcmFtID0gJihBZGpUaHItPmJyZXNQYXJhbUxvbmcpOwogICAgICAgIGJpdHNhdmVfc2xvcGUgPSAoRklYUF9EQkwpMHgzQkJCQkJCQzsKICAgICAgICBiaXRzcGVuZF9zbG9wZSA9IChGSVhQX0RCTCkweDU1NTU1NTU1OwogICAgfQogICAgZWxzZQogICAgewogICAgICAgIGJyZXNQYXJhbSA9ICYoQWRqVGhyLT5icmVzUGFyYW1TaG9ydCk7CiAgICAgICAgYml0c2F2ZV9zbG9wZSA9IChGSVhQX0RCTCkweDJFOEJBMkU5OwogICAgICAgIGJpdHNwZW5kX3Nsb3BlID0gKEZJWFBfREJMKTB4N2ZmZmZmZmY7CiAgICB9CgogICAgcGV4ID0gZml4TWF4KHBlLCBhZGpUaHJDaGFuLT5wZU1pbik7CiAgICBwZXggPSBmaXhNaW4ocGV4LCBhZGpUaHJDaGFuLT5wZU1heCk7CgogICAgYml0U2F2ZSA9IEZES2FhY0VuY19jYWxjQml0U2F2ZShmaWxsTGV2ZWxfZml4LAogICAgICAgIGJyZXNQYXJhbS0+Y2xpcFNhdmVMb3csIGJyZXNQYXJhbS0+Y2xpcFNhdmVIaWdoLAogICAgICAgIGJyZXNQYXJhbS0+bWluQml0U2F2ZSwgYnJlc1BhcmFtLT5tYXhCaXRTYXZlLCBiaXRzYXZlX3Nsb3BlKTsKCiAgICBiaXRTcGVuZCA9IEZES2FhY0VuY19jYWxjQml0U3BlbmQoZmlsbExldmVsX2ZpeCwKICAgICAgICBicmVzUGFyYW0tPmNsaXBTcGVuZExvdywgYnJlc1BhcmFtLT5jbGlwU3BlbmRIaWdoLAogICAgICAgIGJyZXNQYXJhbS0+bWluQml0U3BlbmQsIGJyZXNQYXJhbS0+bWF4Qml0U3BlbmQsIGJpdHNwZW5kX3Nsb3BlKTsKCiAgICBwZV9wZXJzID0gZkRpdk5vcm0ocGV4IC0gYWRqVGhyQ2hhbi0+cGVNaW4sIGFkalRockNoYW4tPnBlTWF4IC0gYWRqVGhyQ2hhbi0+cGVNaW4pOwogICAgdG1wX2ZpeCA9IGZNdWx0KCgoRklYUF9EQkwpYml0U3BlbmQgKyAoRklYUF9EQkwpYml0U2F2ZSksIHBlX3BlcnMpOwogICAgYml0cmVzRmFjX2ZpeCA9IChVTklUWT4+MSkgLSAoKEZJWFBfREJMKWJpdFNhdmU+PjEpICsgKHRtcF9maXg+PjEpOyBxYnJlcyA9IChERlJBQ1RfQklUUy0yKTsKCiAgICAvKiAoZmxvYXQpYml0cmVzQml0cy8oZmxvYXQpYXZnQml0cyAqLwogICAgYml0c19yYXRpbyA9IGZEaXZOb3JtKGJpdHJlc0JpdHMsIGF2Z0JpdHMsICZxYnIpOwogICAgcWJyID0gREZSQUNUX0JJVFMtMS1xYnI7CgogICAgLyogQWRkIDAuNyBpbiBxMzEgdG8gYml0c19yYXRpbyBpbiBxYnIgKi8KICAgIC8qIDAuN2YgKyAoZmxvYXQpYml0cmVzQml0cy8oZmxvYXQpYXZnQml0cyAqLwogICAgcW1pbiA9IGZpeE1pbihxYnIsIChERlJBQ1RfQklUUy0xKSk7CiAgICBiaXRzX3JhdGlvID0gYml0c19yYXRpbyA+PiAocWJyIC0gcW1pbik7CiAgICB0bXBfY3N0ID0gUE9JTlQ3ID4+ICgoREZSQUNUX0JJVFMtMSkgLSBxbWluKTsKICAgIG1heEJyVmFsID0gKGJpdHNfcmF0aW8+PjEpICsgKHRtcF9jc3Q+PjEpOyBxbWJyID0gcW1pbiAtIDE7CgogICAgLyogYml0cmVzRmFjX2ZpeCA9IGZpeE1pbihiaXRyZXNGYWNfZml4LCAwLjcgKyBiaXRyZXNCaXRzL2F2Z0JpdHMpOyAqLwogICAgYml0cmVzRmFjX2ZpeCA9IGJpdHJlc0ZhY19maXggPj4gKHFicmVzIC0gcW1icik7IHFicmVzID0gcW1icjsKICAgIGJpdHJlc0ZhY19maXggPSBmaXhNaW4oYml0cmVzRmFjX2ZpeCwgbWF4QnJWYWwpOwoKICAgIC8qIENvbXBhcmUgd2l0aCBtYXhCaXRGYWMgKi8KICAgIHFtaW4gPSBmaXhNaW4oUV9CSVRGQUMsIHFicmVzKTsKICAgIGJpdHJlc0ZhY19maXggPSBiaXRyZXNGYWNfZml4ID4+IChxYnJlcyAtIHFtaW4pOwogICAgbWF4Qml0RmFjX3RtcCA9IG1heEJpdEZhYyA+PiAoUV9CSVRGQUMgLSBxbWluKTsKICAgIGlmKG1heEJpdEZhY190bXAgPCBiaXRyZXNGYWNfZml4KQogICAgewogICAgICAgIGJpdHJlc0ZhY19maXggPSBtYXhCaXRGYWM7CiAgICB9CiAgICBlbHNlCiAgICB7CiAgICAgICAgaWYocW1pbiA8IFFfQklURkFDKQogICAgICAgIHsKICAgICAgICAgICAgYml0cmVzRmFjX2ZpeCA9IGJpdHJlc0ZhY19maXggPDwgKFFfQklURkFDLXFtaW4pOwogICAgICAgIH0KICAgICAgICBlbHNlCiAgICAgICAgewogICAgICAgICAgICBiaXRyZXNGYWNfZml4ID0gYml0cmVzRmFjX2ZpeCA+PiAocW1pbi1RX0JJVEZBQyk7CiAgICAgICAgfQogICAgfQoKICAgIEZES2FhY0VuY19hZGp1c3RQZU1pbk1heChwZSwgJmFkalRockNoYW4tPnBlTWluLCAmYWRqVGhyQ2hhbi0+cGVNYXgpOwoKICAgIHJldHVybiBiaXRyZXNGYWNfZml4Owp9CgoKLyoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCmZ1bmN0aW9ubmFtZTogRkRLYWFjRW5jX0FkalRock5ldwpkZXNjcmlwdGlvbjogIGFsbG9jYXRlIEFESl9USFJfU1RBVEUKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiovCklOVCBGREthYWNFbmNfQWRqVGhyTmV3KEFESl9USFJfU1RBVEUqKiBwaEFkalRociwKICAgICAgICAgICAgICAgICAgICAgICAgSU5UICAgICAgICAgICAgIG5FbGVtZW50cykKewogICAgSU5UIGVyciA9IDA7CiAgICBJTlQgaTsKICAgIEFESl9USFJfU1RBVEUqIGhBZGpUaHIgPSBHZXRSYW1fYWFjRW5jX0FkanVzdFRocmVzaG9sZCgpOwogICAgaWYgKGhBZGpUaHI9PU5VTEwpIHsKICAgICAgICBlcnIgPSAxOwogICAgICAgIGdvdG8gYmFpbDsKICAgIH0KCiAgICBmb3IgKGk9MDsgaTxuRWxlbWVudHM7IGkrKykgewogICAgICAgIGhBZGpUaHItPmFkalRoclN0YXRlRWxlbVtpXSA9ICBHZXRSYW1fYWFjRW5jX0FkalRoclN0YXRlRWxlbWVudChpKTsKICAgICAgICBpZiAoaEFkalRoci0+YWRqVGhyU3RhdGVFbGVtW2ldPT1OVUxMKSB7CiAgICAgICAgICBlcnIgPSAxOwogICAgICAgICAgZ290byBiYWlsOwogICAgICAgIH0KICAgIH0KCmJhaWw6CiAgICAqcGhBZGpUaHIgPSBoQWRqVGhyOwogICAgcmV0dXJuIGVycjsKfQoKCi8qKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgpmdW5jdGlvbm5hbWU6IEZES2FhY0VuY19BZGpUaHJJbml0CmRlc2NyaXB0aW9uOiAgaW5pdGlhbGl6ZSBBREpfVEhSX1NUQVRFCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwp2b2lkIEZES2FhY0VuY19BZGpUaHJJbml0KEFESl9USFJfU1RBVEUgICAqaEFkalRociwKICAgIGNvbnN0IElOVCAgICAgICBtZWFuUGUsCiAgICBFTEVNRU5UX0JJVFMgICAgKmVsQml0c1soNildLAogICAgSU5UICAgICAgICAgICAgIG5FbGVtZW50cywKICAgIEZJWFBfREJMICAgICAgICB2YnJRdWFsRmFjdG9yKQp7CiAgICBJTlQgaTsKCiAgICBGSVhQX0RCTCBQT0lOVDggPSBGTDJGWENPTlNUX0RCTCgwLjhmKTsKICAgIEZJWFBfREJMIFBPSU5UNiA9IEZMMkZYQ09OU1RfREJMKDAuNmYpOwoKICAgIC8qIGNvbW1vbiBmb3IgYWxsIGVsZW1lbnRzOiAqLwogICAgLyogcGFyYW1ldGVycyBmb3IgYml0cmVzIGNvbnRyb2wgKi8KICAgIGhBZGpUaHItPmJyZXNQYXJhbUxvbmcuY2xpcFNhdmVMb3cgICA9IChGSVhQX0RCTCkweDE5OTk5OTlhOyAvKiBGTDJGWENPTlNUX0RCTCgwLjJmKTsgKi8KICAgIGhBZGpUaHItPmJyZXNQYXJhbUxvbmcuY2xpcFNhdmVIaWdoICA9IChGSVhQX0RCTCkweDc5OTk5OTlhOyAvKiBGTDJGWENPTlNUX0RCTCgwLjk1Zik7ICovCiAgICBoQWRqVGhyLT5icmVzUGFyYW1Mb25nLm1pbkJpdFNhdmUgICAgPSAoRklYUF9EQkwpMHhmOTk5OTk5YTsgLyogRkwyRlhDT05TVF9EQkwoLTAuMDVmKTsgKi8KICAgIGhBZGpUaHItPmJyZXNQYXJhbUxvbmcubWF4Qml0U2F2ZSAgICA9IChGSVhQX0RCTCkweDI2NjY2NjY2OyAvKiBGTDJGWENPTlNUX0RCTCgwLjNmKTsgKi8KICAgIGhBZGpUaHItPmJyZXNQYXJhbUxvbmcuY2xpcFNwZW5kTG93ICA9IChGSVhQX0RCTCkweDE5OTk5OTlhOyAvKiBGTDJGWENPTlNUX0RCTCgwLjJmKTsgKi8KICAgIGhBZGpUaHItPmJyZXNQYXJhbUxvbmcuY2xpcFNwZW5kSGlnaCA9IChGSVhQX0RCTCkweDc5OTk5OTlhOyAvKiBGTDJGWENPTlNUX0RCTCgwLjk1Zik7ICovCiAgICBoQWRqVGhyLT5icmVzUGFyYW1Mb25nLm1pbkJpdFNwZW5kICAgPSAoRklYUF9EQkwpMHhmMzMzMzMzMzsgLyogRkwyRlhDT05TVF9EQkwoLTAuMTBmKTsgKi8KICAgIGhBZGpUaHItPmJyZXNQYXJhbUxvbmcubWF4Qml0U3BlbmQgICA9IChGSVhQX0RCTCkweDMzMzMzMzMzOyAvKiBGTDJGWENPTlNUX0RCTCgwLjRmKTsgKi8KCiAgICBoQWRqVGhyLT5icmVzUGFyYW1TaG9ydC5jbGlwU2F2ZUxvdyAgID0gKEZJWFBfREJMKTB4MTk5OTk5YTA7IC8qIEZMMkZYQ09OU1RfREJMKDAuMmYpOyAqLwogICAgaEFkalRoci0+YnJlc1BhcmFtU2hvcnQuY2xpcFNhdmVIaWdoICA9IChGSVhQX0RCTCkweDVmZmZmZmZmOyAvKiBGTDJGWENPTlNUX0RCTCgwLjc1Zik7ICovCiAgICBoQWRqVGhyLT5icmVzUGFyYW1TaG9ydC5taW5CaXRTYXZlICAgID0gKEZJWFBfREJMKTB4MDAwMDAwMDA7IC8qIEZMMkZYQ09OU1RfREJMKDAuMGYpOyAqLwogICAgaEFkalRoci0+YnJlc1BhcmFtU2hvcnQubWF4Qml0U2F2ZSAgICA9IChGSVhQX0RCTCkweDE5OTk5OWEwOyAvKiBGTDJGWENPTlNUX0RCTCgwLjJmKTsgKi8KICAgIGhBZGpUaHItPmJyZXNQYXJhbVNob3J0LmNsaXBTcGVuZExvdyAgPSAoRklYUF9EQkwpMHgxOTk5OTlhMDsgLyogRkwyRlhDT05TVF9EQkwoMC4yZik7ICovCiAgICBoQWRqVGhyLT5icmVzUGFyYW1TaG9ydC5jbGlwU3BlbmRIaWdoID0gKEZJWFBfREJMKTB4NWZmZmZmZmY7IC8qIEZMMkZYQ09OU1RfREJMKDAuNzVmKTsgKi8KICAgIGhBZGpUaHItPmJyZXNQYXJhbVNob3J0Lm1pbkJpdFNwZW5kICAgPSAoRklYUF9EQkwpMHhmOTk5OTk5ODsgLyogRkwyRlhDT05TVF9EQkwoLTAuMDVmKTsgKi8KICAgIGhBZGpUaHItPmJyZXNQYXJhbVNob3J0Lm1heEJpdFNwZW5kICAgPSAoRklYUF9EQkwpMHg0MDAwMDAwMDsgLyogRkwyRlhDT05TVF9EQkwoMC41Zik7ICovCgogICAgLyogc3BlY2lmaWMgZm9yIGVhY2ggZWxlbWVudDogKi8KICAgIGZvciAoaT0wOyBpPG5FbGVtZW50czsgaSsrKSB7CiAgICAgICAgQVRTX0VMRU1FTlQqIGF0c0VsZW0gPSBoQWRqVGhyLT5hZGpUaHJTdGF0ZUVsZW1baV07CiAgICAgICAgTUlOU05SX0FEQVBUX1BBUkFNICptc2FQYXJhbSA9ICZhdHNFbGVtLT5taW5TbnJBZGFwdFBhcmFtOwogICAgICAgIElOVCBjaEJpdHJhdGUgPSBlbEJpdHNbaV0tPmNoQml0cmF0ZUVsOwoKICAgICAgICAvKiBwYXJhbWV0ZXJzIGZvciBiaXRyZXMgY29udHJvbCAqLwogICAgICAgIGF0c0VsZW0tPnBlTWluID0gZk11bHRJKFBPSU5UOCwgbWVhblBlKSA+PiAxOwogICAgICAgIGF0c0VsZW0tPnBlTWF4ID0gZk11bHRJKFBPSU5UNiwgbWVhblBlKTsKCiAgICAgICAgLyogZm9yIHVzZSBpbiBGREthYWNFbmNfcmVkdWNlVGhyZXNob2xkc1ZCUiAqLwogICAgICAgIGF0c0VsZW0tPmNoYW9zTWVhc3VyZU9sZCA9IEZMMkZYQ09OU1RfREJMKDAuM2YpOwoKICAgICAgICAvKiBhZGRpdGlvbmFsIHBlIG9mZnNldCB0byBjb3JyZWN0IHBlMmJpdHMgZm9yIGxvdyBiaXRyYXRlcyAqLwogICAgICAgIGF0c0VsZW0tPnBlT2Zmc2V0ID0gMDsKCiAgICAgICAgLyogdmJyIGluaXRpYWxpc2F0aW9uICovCiAgICAgICAgYXRzRWxlbS0+dmJyUXVhbEZhY3RvciA9IHZiclF1YWxGYWN0b3I7CiAgICAgICAgaWYgKGNoQml0cmF0ZSA8IDMyMDAwKQogICAgICAgIHsKICAgICAgICAgICAgYXRzRWxlbS0+cGVPZmZzZXQgPSBmaXhNYXgoNTAsIDEwMC1mTXVsdEkoKEZJWFBfREJMKTB4NjY2NjY3LCBjaEJpdHJhdGUpKTsKICAgICAgICB9CgogICAgICAgIC8qIGF2b2lkIGhvbGUgcGFyYW1ldGVycyAqLwogICAgICAgIGlmIChjaEJpdHJhdGUgPiAyMDAwMCkgewogICAgICAgICAgICBhdHNFbGVtLT5haFBhcmFtLm1vZGlmeU1pblNuciA9IFRSVUU7CiAgICAgICAgICAgIGF0c0VsZW0tPmFoUGFyYW0uc3RhcnRTZmJMID0gMTU7CiAgICAgICAgICAgIGF0c0VsZW0tPmFoUGFyYW0uc3RhcnRTZmJTID0gMzsKICAgICAgICB9CiAgICAgICAgZWxzZSB7CiAgICAgICAgICAgIGF0c0VsZW0tPmFoUGFyYW0ubW9kaWZ5TWluU25yID0gRkFMU0U7CiAgICAgICAgICAgIGF0c0VsZW0tPmFoUGFyYW0uc3RhcnRTZmJMID0gMDsKICAgICAgICAgICAgYXRzRWxlbS0+YWhQYXJhbS5zdGFydFNmYlMgPSAwOwogICAgICAgIH0KCiAgICAJCSAgLyogbWluU25yIGFkYXB0YXRpb24gKi8KICAgICAgICBtc2FQYXJhbS0+bWF4UmVkID0gRkwyRlhDT05TVF9EQkwoMC4wMDM5MDYyNWYpOyAvKiAwLjI1Zi82NC4wZiAqLwogICAgICAgIC8qIHN0YXJ0IGFkYXB0YXRpb24gb2YgbWluU25yIGZvciBhdmdFbi9zZmJFbiA+IHN0YXJ0UmF0aW8gKi8KICAgICAgICBtc2FQYXJhbS0+c3RhcnRSYXRpbyA9IEZMMkZYQ09OU1RfREJMKDAuMDUxOTA1MTI2NDhmKTsgLyogbGQ2NCgxMC4wZikgKi8KICAgICAgICAvKiBtYXhpbXVtIG1pblNuciByZWR1Y3Rpb24gdG8gbWluU25yXm1heFJlZCBpcyByZWFjaGVkIGZvcgogICAgICAgICAgIGF2Z0VuL3NmYkVuID49IG1heFJhdGlvICovCiAgICAgICAgLyogbXNhUGFyYW0tPm1heFJhdGlvID0gMTAwMC4wZjsgKi8KICAgICAgICAvKm1zYVBhcmFtLT5yZWRSYXRpb0ZhYyA9ICgoZmxvYXQpMS4wZiAtIG1zYVBhcmFtLT5tYXhSZWQpIC8gKChmbG9hdCkxMC4wZipsb2cxMChtc2FQYXJhbS0+c3RhcnRSYXRpby9tc2FQYXJhbS0+bWF4UmF0aW8pL2xvZzEwKDIuMGYpKihmbG9hdCkwLjMwMTAyOTk5NTZmKTsqLwogICAgICAgIG1zYVBhcmFtLT5yZWRSYXRpb0ZhYyA9IEZMMkZYQ09OU1RfREJMKC0wLjM3NWYpOyAvKiAtMC4wMzc1ZiAqIDEwLjBmICovCiAgICAgICAgLyptc2FQYXJhbS0+cmVkT2ZmcyA9IChmbG9hdCkxLjBmIC0gbXNhUGFyYW0tPnJlZFJhdGlvRmFjICogKGZsb2F0KTEwLjBmICogbG9nMTAobXNhUGFyYW0tPnN0YXJ0UmF0aW8pL2xvZzEwKDIuMGYpICogKGZsb2F0KTAuMzAxMDI5OTk1NmY7Ki8KICAgICAgICBtc2FQYXJhbS0+cmVkT2ZmcyA9IEZMMkZYQ09OU1RfREJMKDAuMDIxNDg0Mzc1KTsgLyogMS4zNzVmLzY0LjBmICovCgogICAgICAgIC8qIGluaXQgcGUgY29ycmVjdGlvbiAqLwogICAgICAgIGF0c0VsZW0tPnBlQ29ycmVjdGlvbkZhY3Rvcl9tID0gRkwyRlhDT05TVF9EQkwoMC41Zik7IC8qIDEuMCAqLwogICAgICAgIGF0c0VsZW0tPnBlQ29ycmVjdGlvbkZhY3Rvcl9lID0gMTsKCiAgICAgICAgYXRzRWxlbS0+ZHluQml0c0xhc3QgPSAtMTsKICAgICAgICBhdHNFbGVtLT5wZUxhc3QgPSAwOwoKICAgICAgICAvKiBpbml0IGJpdHMgdG8gcGUgZmFjdG9yICovCiAgICAgICAgYXRzRWxlbS0+Yml0czJQZUZhY3Rvcl9tID0gRkwyRlhDT05TVF9EQkwoMS4xOGYvKDE8PCgxKSkpOwogICAgICAgIGF0c0VsZW0tPmJpdHMyUGVGYWN0b3JfZSA9IDE7CiAgICB9Cn0KCgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKICAgIGZ1bmN0aW9ubmFtZTogRkRLYWFjRW5jX0ZES2FhY0VuY19jYWxjUGVDb3JyZWN0aW9uCiAgICBkZXNjcmlwdGlvbjogIGNhbGMgZGVzaXJlZCBwZQoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKi8Kc3RhdGljIHZvaWQgRkRLYWFjRW5jX0ZES2FhY0VuY19jYWxjUGVDb3JyZWN0aW9uKAogICAgICAgIEZJWFBfREJMICpjb25zdCAgICAgICAgICAgY29ycmVjdGlvbkZhY19tLAogICAgICAgIElOVCAqY29uc3QgICAgICAgICAgICAgICAgY29ycmVjdGlvbkZhY19lLAogICAgICAgIGNvbnN0IElOVCAgICAgICAgICAgICAgICAgcGVBY3QsCiAgICAgICAgY29uc3QgSU5UICAgICAgICAgICAgICAgICBwZUxhc3QsCiAgICAgICAgY29uc3QgSU5UICAgICAgICAgICAgICAgICBiaXRzTGFzdCwKICAgICAgICBjb25zdCBGSVhQX0RCTCAgICAgICAgICAgIGJpdHMyUGVGYWN0b3JfbSwKICAgICAgICBjb25zdCBJTlQgICAgICAgICAgICAgICAgIGJpdHMyUGVGYWN0b3JfZQogICAgICAgICkKewogIGlmICggKGJpdHNMYXN0ID4gMCkgJiYgKHBlQWN0IDwgMS41ZipwZUxhc3QpICYmIChwZUFjdCA+IDAuN2YqcGVMYXN0KSAmJgogICAgICAgKEZES2FhY0VuY19iaXRzMnBlMihiaXRzTGFzdCwgZk11bHQoRkwyRlhDT05TVF9EQkwoMS4yZi8yLmYpLCBiaXRzMlBlRmFjdG9yX20pLCBiaXRzMlBlRmFjdG9yX2UrMSkgPiBwZUxhc3QpICYmCiAgICAgICAoRkRLYWFjRW5jX2JpdHMycGUyKGJpdHNMYXN0LCBmTXVsdChGTDJGWENPTlNUX0RCTCgwLjY1ZiksICAgIGJpdHMyUGVGYWN0b3JfbSksIGJpdHMyUGVGYWN0b3JfZSAgKSA8IHBlTGFzdCkgKQogIHsKICAgIEZJWFBfREJMIGNvcnJGYWMgPSAqY29ycmVjdGlvbkZhY19tOwoKICAgIGludCBzY2FsaW5nID0gMDsKICAgIEZJWFBfREJMIGRlbnVtID0gKEZJWFBfREJMKUZES2FhY0VuY19iaXRzMnBlMihiaXRzTGFzdCwgYml0czJQZUZhY3Rvcl9tLCBiaXRzMlBlRmFjdG9yX2UpOwogICAgRklYUF9EQkwgbmV3RmFjID0gZkRpdk5vcm0oKEZJWFBfREJMKXBlTGFzdCwgZGVudW0sICZzY2FsaW5nKTsKCiAgICAvKiBkZWFkIHpvbmUsIG5ld0ZhYyBhbmQgY29yckZhYyBhcmUgc2NhbGVkIGJ5IDAuNSAqLwogICAgaWYgKChGSVhQX0RCTClwZUxhc3QgPD0gZGVudW0pIHsgLyogcmF0aW8gPD0gMS5mICovCiAgICAgIG5ld0ZhYyA9IGZpeE1heChzY2FsZVZhbHVlKGZpeE1pbiggZk11bHQoRkwyRlhDT05TVF9EQkwoMS4xZi8yLmYpLCBuZXdGYWMpLCBzY2FsZVZhbHVlKEZMMkZYQ09OU1RfREJMKCAgMS5mLzIuZiksIC1zY2FsaW5nKSksIHNjYWxpbmcpLCBGTDJGWENPTlNUX0RCTCgwLjg1Zi8yLmYpICk7CiAgICB9CiAgICBlbHNlIHsgLyogcmF0aW8gPCAxLmYgKi8KICAgICBuZXdGYWMgPSBmaXhNYXgoIGZpeE1pbiggc2NhbGVWYWx1ZShmTXVsdChGTDJGWENPTlNUX0RCTCgwLjlmLzIuZiksIG5ld0ZhYyksIHNjYWxpbmcpLCBGTDJGWENPTlNUX0RCTCgxLjE1Zi8yLmYpICksIEZMMkZYQ09OU1RfREJMKCAgIDEuZi8yLmYpICk7CiAgICB9CgogICAgaWYgKCAgICgobmV3RmFjID4gRkwyRlhDT05TVF9EQkwoMS5mLzIuZikpICYmIChjb3JyRmFjIDwgRkwyRlhDT05TVF9EQkwoMS5mLzIuZikpKQogICAgICAgIHx8ICgobmV3RmFjIDwgRkwyRlhDT05TVF9EQkwoMS5mLzIuZikpICYmIChjb3JyRmFjID4gRkwyRlhDT05TVF9EQkwoMS5mLzIuZikpKSkKICAgIHsKICAgICAgY29yckZhYyA9IEZMMkZYQ09OU1RfREJMKDEuZi8yLmYpOwogICAgfQoKICAgIC8qIGZhc3RlciBhZGFwdGF0aW9uIHRvd2FyZHMgMS4wLCBzbG93ZXIgaW4gdGhlIG90aGVyIGRpcmVjdGlvbiAqLwogICAgaWYgKCAoY29yckZhYyA8IEZMMkZYQ09OU1RfREJMKDEuZi8yLmYpICYmIG5ld0ZhYyA8IGNvcnJGYWMpCiAgICAgIHx8IChjb3JyRmFjID4gRkwyRlhDT05TVF9EQkwoMS5mLzIuZikgJiYgbmV3RmFjID4gY29yckZhYykgKQogICAgewogICAgICBjb3JyRmFjID0gZk11bHQoRkwyRlhDT05TVF9EQkwoMC44NWYpLCBjb3JyRmFjKSArIGZNdWx0KEZMMkZYQ09OU1RfREJMKDAuMTVmKSwgbmV3RmFjKTsKICAgIH0KICAgIGVsc2UgewogICAgICBjb3JyRmFjID0gZk11bHQoRkwyRlhDT05TVF9EQkwoMC43ZiksIGNvcnJGYWMpICsgZk11bHQoRkwyRlhDT05TVF9EQkwoMC4zZiksIG5ld0ZhYyk7CiAgICB9CgogICAgY29yckZhYyA9IGZpeE1heCggZml4TWluKCBjb3JyRmFjLCBGTDJGWENPTlNUX0RCTCgxLjE1Zi8yLmYpICksIEZMMkZYQ09OU1RfREJMKDAuODUvMi5mKSApOwoKICAgICpjb3JyZWN0aW9uRmFjX20gPSBjb3JyRmFjOwogICAgKmNvcnJlY3Rpb25GYWNfZSA9IDE7CiAgfQogIGVsc2UgewogICAgKmNvcnJlY3Rpb25GYWNfbSA9IEZMMkZYQ09OU1RfREJMKDEuZi8yLmYpOwogICAgKmNvcnJlY3Rpb25GYWNfZSA9IDE7CiAgfQp9CgoKdm9pZCBGREthYWNFbmNfRGlzdHJpYnV0ZUJpdHMoQURKX1RIUl9TVEFURSAqYWRqVGhyU3RhdGUsCiAgICBBVFNfRUxFTUVOVCAgICAgICAqQWRqVGhyU3RhdGVFbGVtZW50LAogICAgUFNZX09VVF9DSEFOTkVMICAgKnBzeU91dENoYW5uZWxbKDIpXSwKICAgIFBFX0RBVEEgICAgICAgICAgICpwZURhdGEsCiAgICBJTlQgICAgICAgICAgICAgICAqZ3JhbnRlZFBlLAogICAgSU5UICAgICAgICAgICAgICAgKmdyYW50ZWRQZUNvcnIsCiAgICBjb25zdCBJTlQgICAgICAgICBuQ2hhbm5lbHMsCiAgICBjb25zdCBJTlQgICAgICAgICBjb21tb25XaW5kb3csCiAgICBjb25zdCBJTlQgICAgICAgICBncmFudGVkRHluQml0cywKICAgIGNvbnN0IElOVCAgICAgICAgIGJpdHJlc0JpdHMsCiAgICBjb25zdCBJTlQgICAgICAgICBtYXhCaXRyZXNCaXRzLAogICAgY29uc3QgRklYUF9EQkwgICAgbWF4Qml0RmFjLAogICAgY29uc3QgSU5UICAgICAgICAgYml0RGlzdHJpYnV0ZW5Nb2RlKQp7CiAgRklYUF9EQkwgYml0RmFjdG9yOwogIElOVCBub1JlZFBlID0gcGVEYXRhLT5wZTsKCiAgLyogcHJlZmVyIHNob3J0IHdpbmRvd3MgZm9yIGNhbGN1bGF0aW9uIG9mIGJpdEZhY3RvciAqLwogIElOVCBjdXJXaW5kb3dTZXF1ZW5jZSA9IExPTkdfV0lORE9XOwogIGlmIChuQ2hhbm5lbHM9PTIpIHsKICAgIGlmICgocHN5T3V0Q2hhbm5lbFswXS0+bGFzdFdpbmRvd1NlcXVlbmNlID09IFNIT1JUX1dJTkRPVykgfHwKICAgICAgICAocHN5T3V0Q2hhbm5lbFsxXS0+bGFzdFdpbmRvd1NlcXVlbmNlID09IFNIT1JUX1dJTkRPVykpIHsKICAgICAgICBjdXJXaW5kb3dTZXF1ZW5jZSA9IFNIT1JUX1dJTkRPVzsKICAgIH0KICB9CiAgZWxzZSB7CiAgICBjdXJXaW5kb3dTZXF1ZW5jZSA9IHBzeU91dENoYW5uZWxbMF0tPmxhc3RXaW5kb3dTZXF1ZW5jZTsKICB9CgogIGlmIChncmFudGVkRHluQml0cyA+PSAxKSB7CiAgICBpZiAoYml0RGlzdHJpYnV0ZW5Nb2RlIT0wKSB7CiAgICAgICpncmFudGVkUGUgPSBGREthYWNFbmNfYml0czJwZTIoZ3JhbnRlZER5bkJpdHMsIEFkalRoclN0YXRlRWxlbWVudC0+Yml0czJQZUZhY3Rvcl9tLCBBZGpUaHJTdGF0ZUVsZW1lbnQtPmJpdHMyUGVGYWN0b3JfZSk7CiAgICB9CiAgICBlbHNlCiAgICB7CiAgICAvKiBmYWN0b3IgZGVwZW5kZW5kIG9uIGN1cnJlbnQgZmlsbCBsZXZlbCBhbmQgcGUgKi8KICAgIGJpdEZhY3RvciA9IEZES2FhY0VuY19iaXRyZXNDYWxjQml0RmFjKGJpdHJlc0JpdHMsIG1heEJpdHJlc0JpdHMsIG5vUmVkUGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGN1cldpbmRvd1NlcXVlbmNlLCBncmFudGVkRHluQml0cywgbWF4Qml0RmFjLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBhZGpUaHJTdGF0ZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQWRqVGhyU3RhdGVFbGVtZW50CiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICk7CgogICAgLyogZGVzaXJlZCBwZSBmb3IgYWN0dWFsIGZyYW1lICovCiAgICAvKiBXb3JzdCBjYXNlIG1heCBvZiBncmFudGVkRHluQml0cyBpcyA9IDEwMjQgKiA1LjI3ICogMiAqLwogICAgKmdyYW50ZWRQZSA9IEZES2FhY0VuY19iaXRzMnBlMihncmFudGVkRHluQml0cywKICAgICAgICAgICAgICAgICAgICAgZk11bHQoYml0RmFjdG9yLCBBZGpUaHJTdGF0ZUVsZW1lbnQtPmJpdHMyUGVGYWN0b3JfbSksIEFkalRoclN0YXRlRWxlbWVudC0+Yml0czJQZUZhY3Rvcl9lKyhERlJBQ1RfQklUUy0xLVFfQklURkFDKQogICAgICAgICAgICAgICAgICAgICApOwogICAgfQogIH0KICBlbHNlIHsKICAgICpncmFudGVkUGUgPSAwOyAvKiBwcmV2ZW50IGRpdnNpb24gYnkgMCAqLwogIH0KCiAgLyogY29ycmVjdGlvbiBvZiBwZSB2YWx1ZSAqLwogIHsKICAgIEZES2FhY0VuY19GREthYWNFbmNfY2FsY1BlQ29ycmVjdGlvbigKICAgICAgICZBZGpUaHJTdGF0ZUVsZW1lbnQtPnBlQ29ycmVjdGlvbkZhY3Rvcl9tLAogICAgICAgJkFkalRoclN0YXRlRWxlbWVudC0+cGVDb3JyZWN0aW9uRmFjdG9yX2UsCiAgICAgICAgZml4TWluKCpncmFudGVkUGUsIG5vUmVkUGUpLAogICAgICAgIEFkalRoclN0YXRlRWxlbWVudC0+cGVMYXN0LAogICAgICAgIEFkalRoclN0YXRlRWxlbWVudC0+ZHluQml0c0xhc3QsCiAgICAgICAgQWRqVGhyU3RhdGVFbGVtZW50LT5iaXRzMlBlRmFjdG9yX20sCiAgICAgICAgQWRqVGhyU3RhdGVFbGVtZW50LT5iaXRzMlBlRmFjdG9yX2UKICAgICAgICApOwogIH0KCiAgKmdyYW50ZWRQZUNvcnIgPSAoSU5UKShmTXVsdCgoRklYUF9EQkwpKCpncmFudGVkUGU8PFFfQVZHQklUUyksIEFkalRoclN0YXRlRWxlbWVudC0+cGVDb3JyZWN0aW9uRmFjdG9yX20pID4+IChRX0FWR0JJVFMtQWRqVGhyU3RhdGVFbGVtZW50LT5wZUNvcnJlY3Rpb25GYWN0b3JfZSkpOwoKICAvKiB1cGRhdGUgbGFzdCBwZSAqLwogIEFkalRoclN0YXRlRWxlbWVudC0+cGVMYXN0ID0gKmdyYW50ZWRQZTsKICBBZGpUaHJTdGF0ZUVsZW1lbnQtPmR5bkJpdHNMYXN0ID0gLTE7Cgp9CgovKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKZnVuY3Rpb25uYW1lOiBGREthYWNFbmNfQWRqdXN0VGhyZXNob2xkcwpkZXNjcmlwdGlvbjogIGFkanVzdCB0aHJlc2hvbGRzCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqLwp2b2lkIEZES2FhY0VuY19BZGp1c3RUaHJlc2hvbGRzKEFUU19FTEVNRU5UKiAgICAgICAgQWRqVGhyU3RhdGVFbGVtZW50Wyg2KV0sCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgUUNfT1VUX0VMRU1FTlQqICAgICBxY0VsZW1lbnRbKDYpXSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBRQ19PVVQqICAgICAgICAgICAgIHFjT3V0LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFBTWV9PVVRfRUxFTUVOVCogICAgcHN5T3V0RWxlbWVudFsoNildLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIElOVCAgICAgICAgICAgICAgICAgQ0JSYml0cmF0ZU1vZGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ0hBTk5FTF9NQVBQSU5HKiAgICBjbSkKewogICAgaW50IGk7CiAgICBpZiAoQ0JSYml0cmF0ZU1vZGUpCiAgICB7CiAgICAgICAgLyogSW4gY2FzZSwgbm8gYml0cyBtdXN0IGJlIHNoaWZ0ZWQgYmV0d2VlbiBkaWZmZXJlbnQgZWxlbWVudHMsICovCiAgICAgICAgLyogYW4gZWxlbWVudC13aXNlIGV4ZWN1dGlvbiBvZiB0aGUgcGUtZGVwZW5kZW50IHRocmVzaG9sZC0gKi8KICAgICAgICAvKiBhZGFwdGlvbiBiZWNvbWVzIG5lY2Vzc2FyeS4uLiAqLwogICAgICAgICAgICBmb3IgKGk9MDsgaTxjbS0+bkVsZW1lbnRzOyBpKyspCiAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgIEVMRU1FTlRfSU5GTyBlbEluZm8gPSBjbS0+ZWxJbmZvW2ldOwoKICAgICAgICAgICAgICAgIGlmICgoZWxJbmZvLmVsVHlwZSA9PSBJRF9TQ0UpIHx8IChlbEluZm8uZWxUeXBlID09IElEX0NQRSkgfHwKICAgICAgICAgICAgICAgICAgICAoZWxJbmZvLmVsVHlwZSA9PSBJRF9MRkUpKQogICAgICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAgIC8qIHFjRWxlbWVudFtpXS0+Z3JhbnRlZFBlID0gMjAwMDsgKi8gIC8qIFVzZSB0aGlzIG9ubHkgZm9yIGRlYnVnZ2luZyAqLwogICAgICAgICAgICAgICAgICAgIC8vaWYgKHRvdGFsR3JhbnRlZFBlQ29yciA8IHRvdGFsTm9SZWRQZSkgewogICAgICAgICAgICAgICAgICAgIGlmIChxY0VsZW1lbnRbaV0tPmdyYW50ZWRQZSA8IHFjRWxlbWVudFtpXS0+cGVEYXRhLnBlKQogICAgICAgICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICAgICAgICAgLyogY2FsYyB0aHJlc2hvbGQgbmVjZXNzYXJ5IGZvciBkZXNpcmVkIHBlICovCiAgICAgICAgICAgICAgICAgICAgICAgIEZES2FhY0VuY19hZGFwdFRocmVzaG9sZHNUb1BlKGNtLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEFkalRoclN0YXRlRWxlbWVudCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBxY0VsZW1lbnQsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcHN5T3V0RWxlbWVudCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBxY0VsZW1lbnRbaV0tPmdyYW50ZWRQZUNvcnIsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgMSwgICAgICAgICAvKiBQcm9jZXNzIG9ubHkgMSBlbGVtZW50ICovCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaSk7ICAgICAgICAvKiBQcm9jZXNzIGV4YWN0bHkgVEhJUyBlbGVtZW50ICovCgogICAgICAgICAgICAgICAgICAgIH0KCiAgICAgICAgICAgICAgICB9ICAvKiAgLWVuZC0gaWYoSURfU0NFIHx8IElEX0NQRSB8fCBJRF9MRkUpICovCgogICAgICAgICAgICB9ICAvKiAtZW5kLSBlbGVtZW50IGxvb3AgKi8KICAgIH0KICAgIGVsc2UgewogICAgICAgIGZvciAoaT0wOyBpPGNtLT5uRWxlbWVudHM7IGkrKykKICAgICAgICB7CiAgICAgICAgICAgIEVMRU1FTlRfSU5GTyBlbEluZm8gPSBjbS0+ZWxJbmZvW2ldOwoKICAgICAgICAgICAgaWYgKChlbEluZm8uZWxUeXBlID09IElEX1NDRSkgfHwgKGVsSW5mby5lbFR5cGUgPT0gSURfQ1BFKSB8fAogICAgICAgICAgICAgICAgKGVsSW5mby5lbFR5cGUgPT0gSURfTEZFKSkKICAgICAgICAgICAgewogICAgICAgICAgICAgICAgICAvKiBmb3IgVkJSLW1vZGUgKi8KICAgICAgICAgICAgICAgICAgRkRLYWFjRW5jX0FkYXB0VGhyZXNob2xkc1ZCUihxY0VsZW1lbnRbaV0tPnFjT3V0Q2hhbm5lbCwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwc3lPdXRFbGVtZW50W2ldLT5wc3lPdXRDaGFubmVsLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIEFkalRoclN0YXRlRWxlbWVudFtpXSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAmcHN5T3V0RWxlbWVudFtpXS0+dG9vbHNJbmZvLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICZxY0VsZW1lbnRbaV0tPnBlRGF0YSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjbS0+ZWxJbmZvW2ldLm5DaGFubmVsc0luRWwpOwogICAgICAgICAgICB9ICAvKiAgLWVuZC0gaWYoSURfU0NFIHx8IElEX0NQRSB8fCBJRF9MRkUpICovCgogICAgICAgIH0gIC8qIC1lbmQtIGVsZW1lbnQgbG9vcCAqLwoKICAgIH0KICAgICAgICBmb3IgKGk9MDsgaTxjbS0+bkVsZW1lbnRzOyBpKyspIHsKICAgICAgICAgICAgaW50IGNoLHNmYixzZmJHcnA7CiAgICAgICAgICAgIC8qIG5vIHdlaWdodGluZyBvZiB0aHJlaG9sZHMgYW5kIGVuZXJnaWVzIGZvciBtbG91dCAqLwogICAgICAgICAgICAvKiB3ZWlnaHQgZW5lcmdpZXMgYW5kIHRocmVzaG9sZHMgKi8KICAgICAgICAgICAgZm9yIChjaD0wOyBjaDxjbS0+ZWxJbmZvW2ldLm5DaGFubmVsc0luRWw7IGNoKyspIHsKICAgICAgICAgICAgICAgIFFDX09VVF9DSEFOTkVMKiBwUWNPdXRDaCA9IHFjRWxlbWVudFtpXS0+cWNPdXRDaGFubmVsW2NoXTsKICAgICAgICAgICAgICAgIGZvciAoc2ZiR3JwID0gMDtzZmJHcnAgPCBwc3lPdXRFbGVtZW50W2ldLT5wc3lPdXRDaGFubmVsW2NoXS0+c2ZiQ250OyBzZmJHcnArPXBzeU91dEVsZW1lbnRbaV0tPnBzeU91dENoYW5uZWxbY2hdLT5zZmJQZXJHcm91cCkgewogICAgICAgICAgICAgICAgICAgIGZvciAoc2ZiPTA7IHNmYjxwc3lPdXRFbGVtZW50W2ldLT5wc3lPdXRDaGFubmVsW2NoXS0+bWF4U2ZiUGVyR3JvdXA7IHNmYisrKSB7CiAgICAgICAgICAgICAgICAgICAgICAgIHBRY091dENoLT5zZmJUaHJlc2hvbGRMZERhdGFbc2ZiK3NmYkdycF0gKz0gcFFjT3V0Q2gtPnNmYkVuRmFjTGRbc2ZiK3NmYkdycF07CiAgICAgICAgICAgICAgICAgICAgfQogICAgICAgICAgICAgICAgfQogICAgICAgICAgICB9CiAgICAgICAgfQoKfQoKdm9pZCBGREthYWNFbmNfQWRqVGhyQ2xvc2UoQURKX1RIUl9TVEFURSoqIHBoQWRqVGhyKQp7CiAgICBJTlQgaTsKICAgIEFESl9USFJfU1RBVEUqIGhBZGpUaHIgPSAqcGhBZGpUaHI7CgogICAgaWYgKGhBZGpUaHIhPU5VTEwpIHsKICAgICAgZm9yIChpPTA7IGk8KDYpOyBpKyspIHsKICAgICAgICBpZiAoaEFkalRoci0+YWRqVGhyU3RhdGVFbGVtW2ldIT1OVUxMKSB7CiAgICAgICAgICBGcmVlUmFtX2FhY0VuY19BZGpUaHJTdGF0ZUVsZW1lbnQoJmhBZGpUaHItPmFkalRoclN0YXRlRWxlbVtpXSk7CiAgICAgICAgfQogICAgICB9CiAgICAgIEZyZWVSYW1fYWFjRW5jX0FkanVzdFRocmVzaG9sZChwaEFkalRocik7CiAgICB9Cn0KCg==