LyoKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgoqIENvcHlyaWdodCCpIHsxOTk2LTE5OTl9LCBJbnRlcm5hdGlvbmFsIEJ1c2luZXNzIE1hY2hpbmVzIENvcnBvcmF0aW9uIGFuZCBvdGhlcnMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKi8KCiNpZm5kZWYgVUNPTF9ICiNkZWZpbmUgVUNPTF9ICgojaW5jbHVkZSAidW5pY29kZS91dHlwZXMuaCIKI2luY2x1ZGUgInVuaWNvZGUvdW5vcm0uaCIKLyoqCiAqIFxmaWxlCiAqIFxicmllZiBEZXNjcmlwdGlvbiBvZiBDb2xsYXRvciBDIEFQSQogKgogKiA8aDI+IENvbGxhdG9yIEMgQVBJIDwvaDI+CiAqCiAqIFRoZSBDIEFQSSBmb3IgQ29sbGF0b3IgcGVyZm9ybXMgbG9jYWxlLXNlbnNpdGl2ZQogKiA8Y29kZT5TdHJpbmc8L2NvZGU+IGNvbXBhcmlzb24uIFlvdSB1c2UgdGhpcyBjbGFzcyB0byBidWlsZAogKiBzZWFyY2hpbmcgYW5kIHNvcnRpbmcgcm91dGluZXMgZm9yIG5hdHVyYWwgbGFuZ3VhZ2UgdGV4dC4KICoKICogIAogKiA8cD4KICogTGlrZSBvdGhlciBsb2NhbGUtc2Vuc2l0aXZlIGNsYXNzZXMsIHlvdSBjYW4gdXNlIHRoZSBmdW5jdGlvbgogKiA8Y29kZT51Y29sX29wZW4oKTwvY29kZT4sIHRvIG9idGFpbiB0aGUgYXBwcm9wcmlhdGUgcG9pbnRlciB0byAKICogPGNvZGU+VUNvbGxhdG9yPC9jb2RlPiBvYmplY3QgZm9yIGEgZ2l2ZW4gbG9jYWxlLiBJZiB5b3UgbmVlZAogKiB0byB1bmRlcnN0YW5kIHRoZSBkZXRhaWxzIG9mIGEgcGFydGljdWxhciBjb2xsYXRpb24gc3RyYXRlZ3kgb3IKICogaWYgeW91IG5lZWQgdG8gbW9kaWZ5IHRoYXQgc3RyYXRlZ3kuCiAqCiAqIDxwPgogKiBUaGUgZm9sbG93aW5nIGV4YW1wbGUgc2hvd3MgaG93IHRvIGNvbXBhcmUgdHdvIHN0cmluZ3MgdXNpbmcKICogdGhlIDxjb2RlPlVDb2xsYXRvcjwvY29kZT4gZm9yIHRoZSBkZWZhdWx0IGxvY2FsZS4KICogPGJsb2NrcXVvdGU+CiAqIDxwcmU+CiAqIFxjb2RlCiAqIC8vIENvbXBhcmUgdHdvIHN0cmluZ3MgaW4gdGhlIGRlZmF1bHQgbG9jYWxlCiAqIFVFcnJvckNvZGUgc3VjY2VzcyA9IFVfWkVST19FUlJPUjsKICogVUNvbGxhdG9yKiBteUNvbGxhdG9yID0gdWNvbF9vcGVuKE5VTEwsICZzdWNjZXNzKTsKICogVUNoYXIgc291cmNlWzRdLCB0YXJnZXRbNF07CiAqIHVfdWFzdHJjcHkoc291cmNlLCAiYWJjIik7CiAqIHVfdWFzdHJjcHkodGFyZ2V0LCAiQUJDIik7CiAqIGlmKCB1X3N0cmNvbGwobXlDb2xsYXRvciwgc291cmNlLCB1X3N0cmxlbihzb3VyY2UpLCB0YXJnZXQsIHVfc3RybGVuKHRhcmdldCkpID09IFVDT0xfTEVTUykgewogKiAgICAgcHJpbnRmKCJhYmMgaXMgbGVzcyB0aGFuIEFCQ1xuIik7CiAqIH1lbHNlewogKiAgICAgcHJpbnRmKCJhYmMgaXMgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvIEFCQ1xuIik7CiAqIH0KICogXGVuZGNvZGUKICogPC9wcmU+CiAqIDwvYmxvY2txdW90ZT4KICoKICogPHA+CiAqIFlvdSBjYW4gc2V0IGEgPGNvZGU+Q29sbGF0b3I8L2NvZGU+J3MgPGVtPnN0cmVuZ3RoPC9lbT4gcHJvcGVydHkKICogdG8gZGV0ZXJtaW5lIHRoZSBsZXZlbCBvZiBkaWZmZXJlbmNlIGNvbnNpZGVyZWQgc2lnbmlmaWNhbnQgaW4KICogY29tcGFyaXNvbnMuIEZvdXIgc3RyZW5ndGhzIGFyZSBwcm92aWRlZDogPGNvZGU+VUNPTF9QUklNQVJZPC9jb2RlPiwKICogPGNvZGU+VUNPTF9TRUNPTkRBUlk8L2NvZGU+LCA8Y29kZT5VQ09MX1RFUlRJQVJZPC9jb2RlPiwgYW5kIAogKiA8Y29kZT5VQ09MX0lERU5USUNBTDwvY29kZT4uIFRoZSBleGFjdCBhc3NpZ25tZW50IG9mIHN0cmVuZ3RocyB0byAKICogbGFuZ3VhZ2UgZmVhdHVyZXMgaXMgbG9jYWxlIGRlcGVuZGFudC4gIEZvciBleGFtcGxlLCBpbiBDemVjaCwgCiAqICJlIiBhbmQgImYiIGFyZSBjb25zaWRlcmVkIHByaW1hcnkgZGlmZmVyZW5jZXMsIHdoaWxlICJlIiBhbmQgIlx1MDBFQSIKICogYXJlIHNlY29uZGFyeSBkaWZmZXJlbmNlcywgImUiIGFuZCAiRSIgYXJlIHRlcnRpYXJ5IGRpZmZlcmVuY2VzIGFuZCAKICogImUiIGFuZCAiZSIgYXJlIGlkZW50aWNhbC4KICogVGhlIGZvbGxvd2luZyBzaG93cyBob3cgYm90aCBjYXNlIGFuZCBhY2NlbnRzIGNvdWxkIGJlIGlnbm9yZWQgZm9yCiAqIFVTIEVuZ2xpc2guCiAqIDxibG9ja3F1b3RlPgogKiA8cHJlPgogKiBcY29kZQogKiAvL0dldCB0aGUgQ29sbGF0b3IgZm9yIFVTIEVuZ2xpc2ggYW5kIHNldCBpdHMgc3RyZW5ndGggdG8gVUNPTF9QUklNQVJZCiAqIFVFcnJvckNvZGUgc3VjY2VzcyA9IFVfWkVST19FUlJPUjsKICogVUNvbGxhdG9yKiB1c0NvbGxhdG9yID0gdWNvbF9vcGVuKCJlbl9VUyIsICZzdWNjZXNzKTsKICogdWNvbF9zZXRTdHJlbmd0aCh1c0NvbGxhdG9yLCBVQ09MX1BSSU1BUlkpOwogKiBVQ2hhciBzb3VyY2VbNF0sIHRhcmdldFs0XTsKICogdV91YXN0cmNweShzb3VyY2UsICJhYmMiKTsKICogdV91YXN0cmNweSh0YXJnZXQsICJBQkMiKTsKICogaWYoIHVfc3RyY29sbChteUNvbGxhdG9yLCBzb3VyY2UsIHVfc3RybGVuKHNvdXJjZSksIHRhcmdldCwgdV9zdHJsZW4odGFyZ2V0KSkgPT0gVUNPTF9FUVVBTCkgewogKiAgICAgcHJpbnRmKCInYWJjJyBhbmQgJ0FCQycgc3RyaW5ncyBhcmUgZXF1aXZhbGVudCB3aXRoIHN0cmVuZ3RoIFVDT0xfUFJJTUFSWVxuIik7CiAqIH0KICogXGVuZGNvZGUKICogPC9wcmU+CiAqIDwvYmxvY2txdW90ZT4KICogPHA+CiAqIEZvciBjb21wYXJpbmcgPGNvZGU+U3RyaW5nPC9jb2RlPnMgZXhhY3RseSBvbmNlLCB0aGUgPGNvZGU+dV9zdHJjb2xsPC9jb2RlPgogKiBtZXRob2QgcHJvdmlkZXMgdGhlIGJlc3QgcGVyZm9ybWFuY2UuIFdoZW4gc29ydGluZyBhIGxpc3Qgb2YKICogPGNvZGU+U3RyaW5nPC9jb2RlPnMgaG93ZXZlciwgaXQgaXMgZ2VuZXJhbGx5IG5lY2Vzc2FyeSB0byBjb21wYXJlIGVhY2gKICogPGNvZGU+U3RyaW5nPC9jb2RlPiBtdWx0aXBsZSB0aW1lcy4gSW4gdGhpcyBjYXNlLCA8Y29kZT5zb3J0S2V5PC9jb2RlPnMKICogcHJvdmlkZSBiZXR0ZXIgcGVyZm9ybWFuY2UuIFRoZSA8Y29kZT51Y29sX2dldHNvcnRLZXk8L2NvZGU+IG1ldGhvZCBjb252ZXJ0cwogKiBhIDxjb2RlPlN0cmluZzwvY29kZT4gdG8gYSBzZXJpZXMgb2YgYml0cyB0aGF0IGNhbiBiZSBjb21wYXJlZCBiaXR3aXNlCiAqIGFnYWluc3Qgb3RoZXIgPGNvZGU+c29ydEtleTwvY29kZT5zIHVzaW5nIDxjb2RlPm1lbWNtcCgpPC9jb2RlPiAKICogPHA+CiAqIDxzdHJvbmc+Tm90ZTo8L3N0cm9uZz4gPGNvZGU+VUNvbGxhdG9yPC9jb2RlPnMgd2l0aCBkaWZmZXJlbnQgTG9jYWxlLAogKiBDb2xsYXRpb24gU3RyZW5ndGggYW5kIERlY29tcG9zaXRpb24gTW9kZSBzZXR0aW5ncyB3aWxsIHJldHVybiBkaWZmZXJlbnQKICogc29ydCBvcmRlcnMgZm9yIHRoZSBzYW1lIHNldCBvZiBzdHJpbmdzLiBMb2NhbGVzIGhhdmUgc3BlY2lmaWMgCiAqIGNvbGxhdGlvbiBydWxlcywgYW5kIHRoZSB3YXkgaW4gd2hpY2ggc2Vjb25kYXJ5IGFuZCB0ZXJ0aWFyeSBkaWZmZXJlbmNlcyAKICogYXJlIHRha2VuIGludG8gYWNjb3VudCwgZm9yIGV4YW1wbGUsIHdpbGwgcmVzdWx0IGluIGEgZGlmZmVyZW50IHNvcnRpbmcgb3JkZXIKICogZm9yIHNhbWUgc3RyaW5ncy4KICogPHA+CiAqIEBzZWUgICAgICAgICBVQ29sbGF0aW9uUmVzdWx0CiAqIEBzZWUgICAgICAgICBVTm9ybWFsaXphdGlvbk1vZGUKICogQHNlZSAgICAgICAgICAgIFVDb2xsYXRpb25TdHJlbmd0aAogKiBAc2VlICAgICAgICAgVUNvbGxhdGlvbkVsZW1lbnRzCiAqLwpzdHJ1Y3QgY29sbEl0ZXJhdGU7CnR5cGVkZWYgc3RydWN0IGNvbGxJdGVyYXRlIGNvbGxJdGVyYXRlOwoKc3RydWN0IGluY3JlbWVudGFsQ29udGV4dDsKdHlwZWRlZiBzdHJ1Y3QgaW5jcmVtZW50YWxDb250ZXh0IGluY3JlbWVudGFsQ29udGV4dDsKCiAvKiogQSBjb2xsYXRvci4KICogIEZvciB1c2FnZSBpbiBDIHByb2dyYW1zLgogKi8KdHlwZWRlZiB2b2lkKiBVQ29sbGF0b3I7CgogICAgLyoqCiAgICAgKiBVQ09MX0xFU1MgaXMgcmV0dXJuZWQgaWYgc291cmNlIHN0cmluZyBpcyBjb21wYXJlZCB0byBiZSBsZXNzIHRoYW4gdGFyZ2V0CiAgICAgKiBzdHJpbmcgaW4gdGhlIHVfc3RyY29sbCgpIG1ldGhvZC4KICAgICAqIFVDT0xfRVFVQUwgaXMgcmV0dXJuZWQgaWYgc291cmNlIHN0cmluZyBpcyBjb21wYXJlZCB0byBiZSBlcXVhbCB0byB0YXJnZXQKICAgICAqIHN0cmluZyBpbiB0aGUgdV9zdHJjb2xsKCkgbWV0aG9kLgogICAgICogVUNPTF9HUkVBVEVSIGlzIHJldHVybmVkIGlmIHNvdXJjZSBzdHJpbmcgaXMgY29tcGFyZWQgdG8gYmUgZ3JlYXRlciB0aGFuCiAgICAgKiB0YXJnZXQgc3RyaW5nIGluIHRoZSB1X3N0cmNvbGwoKSBtZXRob2QuCiAgICAgKiBAc2VlIHVfc3RyY29sbCgpCiAgICAgKiovCi8qKiBQb3NzaWJsZSB2YWx1ZXMgZm9yIGEgY29tcGFyaXNvbiByZXN1bHQgKi8KdHlwZWRlZiBlbnVtIHsKICAvKiogc3RyaW5nIGEgPT0gc3RyaW5nIGIgKi8KICBVQ09MX0VRVUFMICAgID0gMCwKICAvKiogc3RyaW5nIGEgPiBzdHJpbmcgYiAqLwogIFVDT0xfR1JFQVRFUiAgICA9IDEsCiAgLyoqIHN0cmluZyBhIDwgc3RyaW5nIGIgKi8KICBVQ09MX0xFU1MgICAgPSAtMQp9IFVDb2xsYXRpb25SZXN1bHQgOwoKCnR5cGVkZWYgZW51bSB7CiAgLyogYWNjZXB0ZWQgYnkgbW9zdCBhdHRyaWJ1dGVzICovCiAgVUNPTF9ERUZBVUxUID0gLTEsCgogIC8qIGZvciBVQ09MX1NUUkVOR1RIICovCiAgLyoqIFByaW1hcnkgY29sbGF0aW9uIHN0cmVuZ3RoICovCiAgVUNPTF9QUklNQVJZID0gMCwKICAvKiogU2Vjb25kYXJ5IGNvbGxhdGlvbiBzdHJlbmd0aCAqLwogIFVDT0xfU0VDT05EQVJZID0gMSwKICAvKiogVGVydGlhcnkgY29sbGF0aW9uIHN0cmVuZ3RoICovCiAgVUNPTF9URVJUSUFSWSA9IDIsCiAgLyoqIERlZmF1bHQgY29sbGF0aW9uIHN0cmVuZ3RoICovCiAgVUNPTF9ERUZBVUxUX1NUUkVOR1RIID0gVUNPTF9URVJUSUFSWSwKICAvKiogUXVhdGVybmFyeSBjb2xsYXRpb24gc3RyZW5ndGggKi8KICBVQ09MX1FVQVRFUk5BUlk9MywKICAvKiogSWRlbnRpY2FsIGNvbGxhdGlvbiBzdHJlbmd0aCAqLwogIFVDT0xfSURFTlRJQ0FMPTE1LAoKICAvKiBmb3IgVUNPTF9GUkVOQ0hfQ09MTEFUSU9OLCBVQ09MX0NBU0VfTEVWRUwgJiBVQ09MX0RFQ09NUE9TSVRJT05fTU9ERSovCiAgVUNPTF9PRkYgPSAxNiwKICBVQ09MX09OID0gMTcsCiAgCiAgLyogZm9yIFVDT0xfQUxURVJOQVRFX0hBTkRMSU5HICovCiAgVUNPTF9TSElGVEVEID0gMjAsCiAgVUNPTF9OT05fSUdOT1JBQkxFID0gMjEsCgogIC8qIGZvciBVQ09MX0NBU0VfRklSU1QgKi8KICBVQ09MX0xPV0VSX0ZJUlNUID0gMjQsCiAgVUNPTF9VUFBFUl9GSVJTVCA9IDI1LAoKICAvKiBmb3IgVUNPTF9OT1JNQUxJWkFUSU9OX01PREUgKi8KICBVQ09MX09OX1dJVEhPVVRfSEFOR1VMID0gMjgsCgogIC8qKiBObyBtb3JlIGF0dHJpYnV0ZSB2YWx1ZXMgYWZ0ZXIgdGhpcyovCiAgVUNPTF9BVFRSSUJVVEVfVkFMVUVfQ09VTlQKCn0gVUNvbEF0dHJpYnV0ZVZhbHVlOwoKICAgIC8qKgogICAgICogQmFzZSBsZXR0ZXIgcmVwcmVzZW50cyBhIHByaW1hcnkgZGlmZmVyZW5jZS4gIFNldCBjb21wYXJpc29uCiAgICAgKiBsZXZlbCB0byBVQ09MX1BSSU1BUlkgdG8gaWdub3JlIHNlY29uZGFyeSBhbmQgdGVydGlhcnkgZGlmZmVyZW5jZXMuCiAgICAgKiBVc2UgdGhpcyB0byBzZXQgdGhlIHN0cmVuZ3RoIG9mIGEgQ29sbGF0b3Igb2JqZWN0LgogICAgICogRXhhbXBsZSBvZiBwcmltYXJ5IGRpZmZlcmVuY2UsICJhYmMiICZsdDsgImFiZCIKICAgICAqIAogICAgICogRGlhY3JpdGljYWwgZGlmZmVyZW5jZXMgb24gdGhlIHNhbWUgYmFzZSBsZXR0ZXIgcmVwcmVzZW50IGEgc2Vjb25kYXJ5CiAgICAgKiBkaWZmZXJlbmNlLiAgU2V0IGNvbXBhcmlzb24gbGV2ZWwgdG8gVUNPTF9TRUNPTkRBUlkgdG8gaWdub3JlIHRlcnRpYXJ5CiAgICAgKiBkaWZmZXJlbmNlcy4gVXNlIHRoaXMgdG8gc2V0IHRoZSBzdHJlbmd0aCBvZiBhIENvbGxhdG9yIG9iamVjdC4KICAgICAqIEV4YW1wbGUgb2Ygc2Vjb25kYXJ5IGRpZmZlcmVuY2UsICLkIiA+PiAiYSIuCiAgICAgKgogICAgICogVXBwZXJjYXNlIGFuZCBsb3dlcmNhc2UgdmVyc2lvbnMgb2YgdGhlIHNhbWUgY2hhcmFjdGVyIHJlcHJlc2VudHMgYQogICAgICogdGVydGlhcnkgZGlmZmVyZW5jZS4gIFNldCBjb21wYXJpc29uIGxldmVsIHRvIFVDT0xfVEVSVElBUlkgdG8gaW5jbHVkZQogICAgICogYWxsIGNvbXBhcmlzb24gZGlmZmVyZW5jZXMuIFVzZSB0aGlzIHRvIHNldCB0aGUgc3RyZW5ndGggb2YgYSBDb2xsYXRvcgogICAgICogb2JqZWN0LgogICAgICogRXhhbXBsZSBvZiB0ZXJ0aWFyeSBkaWZmZXJlbmNlLCAiYWJjIiAmbHQ7Jmx0OyZsdDsgIkFCQyIuCiAgICAgKgogICAgICogVHdvIGNoYXJhY3RlcnMgYXJlIGNvbnNpZGVyZWQgImlkZW50aWNhbCIgd2hlbiB0aGV5IGhhdmUgdGhlIHNhbWUKICAgICAqIHVuaWNvZGUgc3BlbGxpbmdzLiAgVUNPTF9JREVOVElDQUwuCiAgICAgKiBGb3IgZXhhbXBsZSwgIuQiID09ICLkIi4KICAgICAqCiAgICAgKiBVQ29sbGF0aW9uU3RyZW5ndGggaXMgYWxzbyB1c2VkIHRvIGRldGVybWluZSB0aGUgc3RyZW5ndGggb2Ygc29ydCBrZXlzIAogICAgICogZ2VuZXJhdGVkIGZyb20gVUNvbGxhdG9yIG9iamVjdHMKICAgICAqKi8KLyoqIFBvc3NpYmxlIGNvbGxhdGlvbiBzdHJlbmd0aHMgIC0gYWxsIHVuZGVyIFVDb2xBdHRyaWJ1dGVWYWx1ZSovCnR5cGVkZWYgVUNvbEF0dHJpYnV0ZVZhbHVlIFVDb2xsYXRpb25TdHJlbmd0aDsKCnR5cGVkZWYgZW51bSB7CiAgICAgVUNPTF9GUkVOQ0hfQ09MTEFUSU9OLCAvKiBhdHRyaWJ1dGUgZm9yIGRpcmVjdGlvbiBvZiBzZWNvbmRhcnkgd2VpZ2h0cyovCiAgICAgVUNPTF9BTFRFUk5BVEVfSEFORExJTkcsIC8qIGF0dHJpYnV0ZSBmb3IgaGFuZGxpbmcgdmFyaWFibGUgZWxlbWVudHMqLwogICAgIFVDT0xfQ0FTRV9GSVJTVCwgLyogd2hvIGdvZXMgZmlyc3QsIGxvd2VyIGNhc2Ugb3IgdXBwZXJjYXNlICovCiAgICAgVUNPTF9DQVNFX0xFVkVMLCAvKiBkbyB3ZSBoYXZlIGFuIGV4dHJhIGNhc2UgbGV2ZWwgKi8KICAgICBVQ09MX05PUk1BTElaQVRJT05fTU9ERSwgLyogYXR0cmlidXRlIGZvciBub3JtYWxpemF0aW9uICovCiAgICAgVUNPTF9TVFJFTkdUSCwgICAgICAgICAvKiBhdHRyaWJ1dGUgZm9yIHN0cmVuZ3RoICovCiAgICAgVUNPTF9BVFRSSUJVVEVfQ09VTlQKfSBVQ29sQXR0cmlidXRlOwoKdHlwZWRlZiBlbnVtIHsKCVVDT0xfVEFJTE9SSU5HX09OTFksCglVQ09MX0ZVTExfUlVMRVMKfSAgVUNvbFJ1bGVPcHRpb24gOwoKLyoqCiAqIE9wZW4gYSBVQ29sbGF0b3IgZm9yIGNvbXBhcmluZyBzdHJpbmdzLgogKiBUaGUgVUNvbGxhdG9yIG1heSBiZSB1c2VkIGluIGNhbGxzIHRvIFxSZWZ7dWNvbF9zdHJjb2xsfS4KICogQHBhcmFtIGxvYyBUaGUgbG9jYWxlIGNvbnRhaW5pbmcgdGhlIGNvbXBhcmlzb24gY29udmVudGlvbnMuCiAqIEBwYXJhbSBzdGF0dXMgQSBwb2ludGVyIHRvIGFuIFVFcnJvckNvZGUgdG8gcmVjZWl2ZSBhbnkgZXJyb3JzCiAqIEByZXR1cm4gQSBwb2ludGVyIHRvIGEgVUNvbGxhdG9yLCBvciAwIGlmIGFuIGVycm9yIG9jY3VycmVkLgogKiBAc2VlIHVjb2xfb3BlblJ1bGVzCiAqIEBzdGFibGUKICovClVfQ0FQSSBVQ29sbGF0b3IqCnVjb2xfb3BlbiggICAgY29uc3QgICAgY2hhciAgICAgICAgICpsb2MsCiAgICAgICAgVUVycm9yQ29kZSAgICAgICpzdGF0dXMpOwoKLyoqCiAqIE9wZW4gYSBVQ29sbGF0b3IgZm9yIGNvbXBhcmluZyBzdHJpbmdzLgogKiBUaGUgVUNvbGxhdG9yIG1heSBiZSB1c2VkIGluIGNhbGxzIHRvIFxSZWZ7dWNvbF9zdHJjb2xsfS4KICogQHBhcmFtIHJ1bGVzIEEgc3RyaW5nIGRlc2NyaWJpbmcgdGhlIGNvbGxhdGlvbiBydWxlcy4KICogQHBhcmFtIHJ1bGVzTGVuZ3RoIFRoZSBsZW5ndGggb2YgcnVsZXMsIG9yIC0xIGlmIG51bGwtdGVybWluYXRlZC4KICogQHBhcmFtIG1vZGUgVGhlIG5vcm1hbGl6YXRpb24gbW9kZTsgb25lIG9mIFVDT0xfTk9fTk9STUFMSVpBVElPTiwKICogVUNPTF9DQU5fREVDT01QLCBVQ09MX0NPTVBBVF9ERUNPTVAsIFVDT0xfQ0FOX0RFQ09NUF9DT01QQVRfQ09NUCwKICogVUNPTF9DT01QQVRfREVDT01QX0NBTl9DT01QLCBVQ09MX0RFRkFVTFRfTk9STUFMSVpBVElPTgogKiBAcGFyYW0gc3RyZW5ndGggVGhlIGNvbGxhdGlvbiBzdHJlbmd0aDsgb25lIG9mIFVDT0xfUFJJTUFSWSwgVUNPTF9TRUNPTkRBUlksCiAqIFVDT0xfVEVSVElBUlksIFVDT0xfSURFTlRJQ0FMLFVDT0xfREVGQVVMVF9TVFJFTkdUSAogKiBAcGFyYW0gc3RhdHVzIEEgcG9pbnRlciB0byBhbiBVRXJyb3JDb2RlIHRvIHJlY2VpdmUgYW55IGVycm9ycwogKiBAcmV0dXJuIEEgcG9pbnRlciB0byBhIFVDb2xsYXRvciwgb3IgMCBpZiBhbiBlcnJvciBvY2N1cnJlZC4KICogQHNlZSB1Y29sX29wZW4KICogQHN0YWJsZQogKi8KVV9DQVBJIFVDb2xsYXRvcioKdWNvbF9vcGVuUnVsZXMoICAgIGNvbnN0ICAgIFVDaGFyICAgICAgICAqcnVsZXMsCiAgICAgICAgaW50MzJfdCAgICAgICAgICAgICAgICAgcnVsZXNMZW5ndGgsCiAgICAgICAgVU5vcm1hbGl6YXRpb25Nb2RlICAgICAgbW9kZSwKICAgICAgICBVQ29sbGF0aW9uU3RyZW5ndGggICAgICBzdHJlbmd0aCwKICAgICAgICBVRXJyb3JDb2RlICAgICAgICAgICAgICAqc3RhdHVzKTsKCi8qKiAKICogQ2xvc2UgYSBVQ29sbGF0b3IuCiAqIE9uY2UgY2xvc2VkLCBhIFVDb2xsYXRvciBzaG91bGQgbm90IGJlIHVzZWQuCiAqIEBwYXJhbSBjb2xsIFRoZSBVQ29sbGF0b3IgdG8gY2xvc2UuCiAqIEBzdGFibGUKICovClVfQ0FQSSB2b2lkCnVjb2xfY2xvc2UoVUNvbGxhdG9yICpjb2xsKTsKCi8qKgogKiBDb21wYXJlIHR3byBzdHJpbmdzLgogKiBUaGUgc3RyaW5ncyB3aWxsIGJlIGNvbXBhcmVkIHVzaW5nIHRoZSBub3JtYWxpemF0aW9uIG1vZGUgYW5kIG9wdGlvbnMKICogc3BlY2lmaWVkIGluIFxSZWZ7dWNvbF9vcGVufSBvciBcUmVme3Vjb2xfb3BlblJ1bGVzfQogKiBAcGFyYW0gY29sbCBUaGUgVUNvbGxhdG9yIGNvbnRhaW5pbmcgdGhlIGNvbXBhcmlzb24gcnVsZXMuCiAqIEBwYXJhbSBzb3VyY2UgVGhlIHNvdXJjZSBzdHJpbmcuCiAqIEBwYXJhbSBzb3VyY2VMZW5ndGggVGhlIGxlbmd0aCBvZiBzb3VyY2UsIG9yIC0xIGlmIG51bGwtdGVybWluYXRlZC4KICogQHBhcmFtIHRhcmdldCBUaGUgdGFyZ2V0IHN0cmluZy4KICogQHBhcmFtIHRhcmdldExlbmd0aCBUaGUgbGVuZ3RoIG9mIHRhcmdldCwgb3IgLTEgaWYgbnVsbC10ZXJtaW5hdGVkLgogKiBAcmV0dXJuIFRoZSByZXN1bHQgb2YgY29tcGFyaW5nIHRoZSBzdHJpbmdzOyBvbmUgb2YgVUNPTF9FUVVBTCwKICogVUNPTF9HUkVBVEVSLCBVQ09MX0xFU1MKICogQHNlZSB1Y29sX2dyZWF0ZXIKICogQHNlZSB1Y29sX2dyZWF0ZXJPckVxdWFsCiAqIEBzZWUgdWNvbF9lcXVhbAogKiBAc3RhYmxlCiAqLwpVX0NBUEkgVUNvbGxhdGlvblJlc3VsdAp1Y29sX3N0cmNvbGwoICAgIGNvbnN0ICAgIFVDb2xsYXRvciAgICAqY29sbCwKICAgICAgICBjb25zdCAgICBVQ2hhciAgICAgICAgKnNvdXJjZSwKICAgICAgICBpbnQzMl90ICAgICAgICAgICAgc291cmNlTGVuZ3RoLAogICAgICAgIGNvbnN0ICAgIFVDaGFyICAgICAgICAqdGFyZ2V0LAogICAgICAgIGludDMyX3QgICAgICAgICAgICB0YXJnZXRMZW5ndGgpOwoKLyoqCiAqIERPIE5PVCBVU0UgVEhJUyBBUEkhISEgSXQgaXMgdGhlIG9sZCBpbXBsZW1lbnRhdGlvbiBvZiB1Y29sX3N0cmNvbGwKICogYW5kIGlzIHVzZWQgb25seSBmb3IgdGVzdGluZyBwdXJwb3Nlcy4KICogQGludGVybmFsIERPIE5PVCBVU0UhISEgV2lsbCBiZSByZW1vdmVkIGJ5IDEuOCByZWxlYXNlLgogKi8KVV9DQVBJIFVDb2xsYXRpb25SZXN1bHQKdWNvbF9zdHJjb2xsRXgoICAgIGNvbnN0ICAgIFVDb2xsYXRvciAgICAqY29sbCwKICAgICAgICBjb25zdCAgICBVQ2hhciAgICAgICAgKnNvdXJjZSwKICAgICAgICBpbnQzMl90ICAgICAgICAgICAgc291cmNlTGVuZ3RoLAogICAgICAgIGNvbnN0ICAgIFVDaGFyICAgICAgICAqdGFyZ2V0LAogICAgICAgIGludDMyX3QgICAgICAgICAgICB0YXJnZXRMZW5ndGgpOwoKLyoqCiAqIERldGVybWluZSBpZiBvbmUgc3RyaW5nIGlzIGdyZWF0ZXIgdGhhbiBhbm90aGVyLgogKiBUaGlzIGZ1bmN0aW9uIGlzIGVxdWl2YWxlbnQgdG8gXFJlZnt1Y29sX3N0cmNvbGx9ID09IFVDT0xfR1JFQVRFUgogKiBAcGFyYW0gY29sbCBUaGUgVUNvbGxhdG9yIGNvbnRhaW5pbmcgdGhlIGNvbXBhcmlzb24gcnVsZXMuCiAqIEBwYXJhbSBzb3VyY2UgVGhlIHNvdXJjZSBzdHJpbmcuCiAqIEBwYXJhbSBzb3VyY2VMZW5ndGggVGhlIGxlbmd0aCBvZiBzb3VyY2UsIG9yIC0xIGlmIG51bGwtdGVybWluYXRlZC4KICogQHBhcmFtIHRhcmdldCBUaGUgdGFyZ2V0IHN0cmluZy4KICogQHBhcmFtIHRhcmdldExlbmd0aCBUaGUgbGVuZ3RoIG9mIHRhcmdldCwgb3IgLTEgaWYgbnVsbC10ZXJtaW5hdGVkLgogKiBAcmV0dXJuIFRSVUUgaWYgc291cmNlIGlzIGdyZWF0ZXIgdGhhbiB0YXJnZXQsIEZBTFNFIG90aGVyd2lzZS4KICogQHNlZSB1Y29sX3N0cmNvbGwKICogQHNlZSB1Y29sX2dyZWF0ZXJPckVxdWFsCiAqIEBzZWUgdWNvbF9lcXVhbAogKiBAc3RhYmxlCiAqLwpVX0NBUEkgVUJvb2wKdWNvbF9ncmVhdGVyKCAgICBjb25zdCAgICBVQ29sbGF0b3IgICAgKmNvbGwsCiAgICAgICAgY29uc3QgICAgVUNoYXIgICAgICAgICpzb3VyY2UsCiAgICAgICAgaW50MzJfdCAgICAgICAgICAgIHNvdXJjZUxlbmd0aCwKICAgICAgICBjb25zdCAgICBVQ2hhciAgICAgICAgKnRhcmdldCwKICAgICAgICBpbnQzMl90ICAgICAgICAgICAgdGFyZ2V0TGVuZ3RoKTsKCi8qKgogKiBEZXRlcm1pbmUgaWYgb25lIHN0cmluZyBpcyBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gYW5vdGhlci4KICogVGhpcyBmdW5jdGlvbiBpcyBlcXVpdmFsZW50IHRvIFxSZWZ7dWNvbF9zdHJjb2xsfSAhPSBVQ09MX0xFU1MKICogQHBhcmFtIGNvbGwgVGhlIFVDb2xsYXRvciBjb250YWluaW5nIHRoZSBjb21wYXJpc29uIHJ1bGVzLgogKiBAcGFyYW0gc291cmNlIFRoZSBzb3VyY2Ugc3RyaW5nLgogKiBAcGFyYW0gc291cmNlTGVuZ3RoIFRoZSBsZW5ndGggb2Ygc291cmNlLCBvciAtMSBpZiBudWxsLXRlcm1pbmF0ZWQuCiAqIEBwYXJhbSB0YXJnZXQgVGhlIHRhcmdldCBzdHJpbmcuCiAqIEBwYXJhbSB0YXJnZXRMZW5ndGggVGhlIGxlbmd0aCBvZiB0YXJnZXQsIG9yIC0xIGlmIG51bGwtdGVybWluYXRlZC4KICogQHJldHVybiBUUlVFIGlmIHNvdXJjZSBpcyBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gdGFyZ2V0LCBGQUxTRSBvdGhlcndpc2UuCiAqIEBzZWUgdWNvbF9zdHJjb2xsCiAqIEBzZWUgdWNvbF9ncmVhdGVyCiAqIEBzZWUgdWNvbF9lcXVhbAogKiBAc3RhYmxlCiAqLwpVX0NBUEkgVUJvb2wKdWNvbF9ncmVhdGVyT3JFcXVhbCggICAgY29uc3QgICAgVUNvbGxhdG9yICAgICpjb2xsLAogICAgICAgICAgICBjb25zdCAgICBVQ2hhciAgICAgICAgKnNvdXJjZSwKICAgICAgICAgICAgaW50MzJfdCAgICAgICAgICAgIHNvdXJjZUxlbmd0aCwKICAgICAgICAgICAgY29uc3QgICAgVUNoYXIgICAgICAgICp0YXJnZXQsCiAgICAgICAgICAgIGludDMyX3QgICAgICAgICAgICB0YXJnZXRMZW5ndGgpOwoKLyoqCiAqIENvbXBhcmUgdHdvIHN0cmluZ3MgZm9yIGVxdWFsaXR5LgogKiBUaGlzIGZ1bmN0aW9uIGlzIGVxdWl2YWxlbnQgdG8gXFJlZnt1Y29sX3N0cmNvbGx9ID09IFVDT0xfRVFVQUwKICogQHBhcmFtIGNvbGwgVGhlIFVDb2xsYXRvciBjb250YWluaW5nIHRoZSBjb21wYXJpc29uIHJ1bGVzLgogKiBAcGFyYW0gc291cmNlIFRoZSBzb3VyY2Ugc3RyaW5nLgogKiBAcGFyYW0gc291cmNlTGVuZ3RoIFRoZSBsZW5ndGggb2Ygc291cmNlLCBvciAtMSBpZiBudWxsLXRlcm1pbmF0ZWQuCiAqIEBwYXJhbSB0YXJnZXQgVGhlIHRhcmdldCBzdHJpbmcuCiAqIEBwYXJhbSB0YXJnZXRMZW5ndGggVGhlIGxlbmd0aCBvZiB0YXJnZXQsIG9yIC0xIGlmIG51bGwtdGVybWluYXRlZC4KICogQHJldHVybiBUUlVFIGlmIHNvdXJjZSBpcyBlcXVhbCB0byB0YXJnZXQsIEZBTFNFIG90aGVyd2lzZQogKiBAc2VlIHVjb2xfc3RyY29sbAogKiBAc2VlIHVjb2xfZ3JlYXRlcgogKiBAc2VlIHVjb2xfZ3JlYXRlck9yRXF1YWwKICogQHN0YWJsZQogKi8KVV9DQVBJIFVCb29sCnVjb2xfZXF1YWwoICAgIGNvbnN0ICAgIFVDb2xsYXRvciAgICAqY29sbCwKICAgICAgICBjb25zdCAgICBVQ2hhciAgICAgICAgKnNvdXJjZSwKICAgICAgICBpbnQzMl90ICAgICAgICAgICAgc291cmNlTGVuZ3RoLAogICAgICAgIGNvbnN0ICAgIFVDaGFyICAgICAgICAqdGFyZ2V0LAogICAgICAgIGludDMyX3QgICAgICAgICAgICB0YXJnZXRMZW5ndGgpOwoKLyoqCiAqIEdldCB0aGUgY29sbGF0aW9uIHN0cmVuZ3RoIHVzZWQgaW4gYSBVQ29sbGF0b3IuCiAqIFRoZSBzdHJlbmd0aCBpbmZsdWVuY2VzIGhvdyBzdHJpbmdzIGFyZSBjb21wYXJlZC4KICogQHBhcmFtIGNvbGwgVGhlIFVDb2xsYXRvciB0byBxdWVyeS4KICogQHJldHVybiBUaGUgY29sbGF0aW9uIHN0cmVuZ3RoOyBvbmUgb2YgVUNPTF9QUklNQVJZLCBVQ09MX1NFQ09OREFSWSwKICogVUNPTF9URVJUSUFSWSwgVUNPTF9JREVOVElDQUwsIFVDT0xfREVGQVVMVF9TVFJFTkdUSAogKiBAc2VlIHVjb2xfc2V0U3RyZW5ndGgKICogQHN0YWJsZQogKi8KVV9DQVBJIFVDb2xsYXRpb25TdHJlbmd0aAp1Y29sX2dldFN0cmVuZ3RoKGNvbnN0IFVDb2xsYXRvciAqY29sbCk7CgovKioKICogU2V0IHRoZSBjb2xsYXRpb24gc3RyZW5ndGggdXNlZCBpbiBhIFVDb2xsYXRvci4KICogVGhlIHN0cmVuZ3RoIGluZmx1ZW5jZXMgaG93IHN0cmluZ3MgYXJlIGNvbXBhcmVkLgogKiA8cD5FeGFtcGxlIG9mIHVzZToKICogPHByZT4KICogLiAgICAgICBVQ29sbGF0aW9uUmVzdWx0IHJlc3VsdDsKICogLiAgICAgICBVQ2hhciAqc291cmNlLCAqdGFyZ2V0OwogKiAuICAgICAgIFVFcnJvckNvZGUgc3RhdHVzID0gVV9aRVJPX0VSUk9SOwogKiAuICAgICAgIFVDb2xsYXRvciAqbXlDb2xsYXRpb24gPSB1Y29sX29wZW4oImVuX1VTIiwgc3RhdHVzKTsKICogLiAgICAgICBpZiAoVV9GQUlMVVJFKCZzdGF0dXMpKSByZXR1cm47CiAqIC4gICAgICAgdWNvbF9zZXRTdHJlbmd0aChteUNvbGxhdGlvbiwgVUNPTF9QUklNQVJZKTsKICogLiAgICAgICB1X3Vhc3RyY3B5KHNvdXJjZSwgImFiYyIpOwogKiAuICAgICAgIHVfdWFzdHJjcHkodGFyZ2V0LCAiQUJDIik7CiAqIC4gICAgICAgLy8gcmVzdWx0IHdpbGwgYmUgImFiYyIgPT0gIkFCQyIKICogLiAgICAgICAvLyB0ZXJ0aWFyeSBkaWZmZXJlbmNlcyB3aWxsIGJlIGlnbm9yZWQKICogLiAgICAgICByZXN1bHQgPSB1Y29sX3N0cmNvbGwobXlDb2xsYXRpb24sIHNvdXJjZSwgdV9zdHJsZW4oc291cmNlKSwgdGFyZ2V0LCB1X3N0cmxlbih0YXJnZXQpKTsKICogPC9wcmU+CiAqIEBwYXJhbSBjb2xsIFRoZSBVQ29sbGF0b3IgdG8gc2V0LgogKiBAcGFyYW0gc3RyZW5ndGggVGhlIGRlc2lyZWQgY29sbGF0aW9uIHN0cmVuZ3RoOyBvbmUgb2YgVUNPTF9QUklNQVJZLCAKICogVUNPTF9TRUNPTkRBUlksIFVDT0xfVEVSVElBUlksIFVDT0xfSURFTlRJQ0FMLCBVQ09MX0RFRkFVTFRfU1RSRU5HVEgKICogQHNlZSB1Y29sX2dldFN0cmVuZ3RoCiAqIEBzdGFibGUKICovClVfQ0FQSSB2b2lkCnVjb2xfc2V0U3RyZW5ndGgoICAgIFVDb2xsYXRvciAgICAgICAgICAgICpjb2xsLAogICAgICAgICAgICBVQ29sbGF0aW9uU3RyZW5ndGggICAgICAgIHN0cmVuZ3RoKTsKCi8qKgogKiBHZXQgdGhlIG5vcm1hbGl6YXRpb24gbW9kZSB1c2VkIGluIGEgVUNvbGxhdG9yLgogKiBUaGUgbm9ybWFsaXphdGlvbiBtb2RlIGluZmx1ZW5jZXMgaG93IHN0cmluZ3MgYXJlIGNvbXBhcmVkLgogKiBAcGFyYW0gY29sbCBUaGUgVUNvbGxhdG9yIHRvIHF1ZXJ5LgogKiBAcmV0dXJuIFRoZSBub3JtYWxpemF0aW9uIG1vZGU7IG9uZSBvZiBVQ09MX05PX05PUk1BTElaQVRJT04sIAogKiBVQ09MX0NBTl9ERUNPTVAsIFVDT0xfQ09NUEFUX0RFQ09NUCwgVUNPTF9DQU5fREVDT01QX0NPTVBBVF9DT01QLAogKiBVQ09MX0NPTVBBVF9ERUNPTVBfQ0FOX0NPTVAsIFVDT0xfREVGQVVMVF9OT1JNQUxJWkFUSU9OCiAqIEBzZWUgdWNvbF9zZXROb3JtYWxpemF0aW9uCiAqIEBzdGFibGUKICovClVfQ0FQSSBVTm9ybWFsaXphdGlvbk1vZGUKdWNvbF9nZXROb3JtYWxpemF0aW9uKGNvbnN0IFVDb2xsYXRvciogY29sbCk7CgovKioKICogU2V0IHRoZSBub3JtYWxpemF0aW9uIG1vZGUgdXNlZCBpbiBhIFVDb2xsYXRvci4KICogVGhlIG5vcm1hbGl6YXRpb24gbW9kZSBpbmZsdWVuY2VzIGhvdyBzdHJpbmdzIGFyZSBjb21wYXJlZC4KICogQHBhcmFtIGNvbGwgVGhlIFVDb2xsYXRvciB0byBzZXQuCiAqIEBwYXJhbSBtb2RlIFRoZSBkZXNpcmVkIG5vcm1hbGl6YXRpb24gbW9kZTsgb25lIG9mIFVDT0xfTk9fTk9STUFMSVpBVElPTiwKICogVUNPTF9DQU5fREVDT01QLCBVQ09MX0NPTVBBVF9ERUNPTVAsIFVDT0xfQ0FOX0RFQ09NUF9DT01QQVRfQ09NUCwgCiAqIFVDT0xfQ09NUEFUX0RFQ09NUF9DQU5fQ09NUCwgVUNPTF9ERUZBVUxUX05PUk1BTElaQVRJT04KICogQHNlZSB1Y29sX2dldE5vcm1hbGl6YXRpb24KICogQHN0YWJsZQogKi8KVV9DQVBJIHZvaWQKdWNvbF9zZXROb3JtYWxpemF0aW9uKCAgVUNvbGxhdG9yICAgICAgICAqY29sbCwKICAgICAgICAgICAgVU5vcm1hbGl6YXRpb25Nb2RlICAgIG1vZGUpOwoKLyoqCiAqIEdldCB0aGUgZGlzcGxheSBuYW1lIGZvciBhIFVDb2xsYXRvci4KICogVGhlIGRpc3BsYXkgbmFtZSBpcyBzdWl0YWJsZSBmb3IgcHJlc2VudGF0aW9uIHRvIGEgdXNlci4KICogQHBhcmFtIG9iakxvYyBUaGUgbG9jYWxlIG9mIHRoZSBjb2xsYXRvciBpbiBxdWVzdGlvbi4KICogQHBhcmFtIGRpc3BMb2MgVGhlIGxvY2FsZSBmb3IgZGlzcGxheS4KICogQHBhcmFtIHJlc3VsdCBBIHBvaW50ZXIgdG8gYSBidWZmZXIgdG8gcmVjZWl2ZSB0aGUgYXR0cmlidXRlLgogKiBAcGFyYW0gcmVzdWx0TGVuZ3RoIFRoZSBtYXhpbXVtIHNpemUgb2YgcmVzdWx0LgogKiBAcGFyYW0gc3RhdHVzIEEgcG9pbnRlciB0byBhbiBVRXJyb3JDb2RlIHRvIHJlY2VpdmUgYW55IGVycm9ycwogKiBAcmV0dXJuIFRoZSB0b3RhbCBidWZmZXIgc2l6ZSBuZWVkZWQ7IGlmIGdyZWF0ZXIgdGhhbiByZXN1bHRMZW5ndGgsCiAqIHRoZSBvdXRwdXQgd2FzIHRydW5jYXRlZC4KICogQHN0YWJsZQogKi8KVV9DQVBJIGludDMyX3QKdWNvbF9nZXREaXNwbGF5TmFtZSggICAgY29uc3QgICAgY2hhciAgICAgICAgKm9iakxvYywKICAgICAgICAgICAgY29uc3QgICAgY2hhciAgICAgICAgKmRpc3BMb2MsCiAgICAgICAgICAgIFVDaGFyICAgICAgICAgICAgICpyZXN1bHQsCiAgICAgICAgICAgIGludDMyX3QgICAgICAgICByZXN1bHRMZW5ndGgsCiAgICAgICAgICAgIFVFcnJvckNvZGUgICAgICAgICpzdGF0dXMpOwoKLyoqCiAqIEdldCBhIGxvY2FsZSBmb3Igd2hpY2ggY29sbGF0aW9uIHJ1bGVzIGFyZSBhdmFpbGFibGUuCiAqIEEgVUNvbGxhdG9yIGluIGEgbG9jYWxlIHJldHVybmVkIGJ5IHRoaXMgZnVuY3Rpb24gd2lsbCBwZXJmb3JtIHRoZSBjb3JyZWN0CiAqIGNvbGxhdGlvbiBmb3IgdGhlIGxvY2FsZS4KICogQHBhcmFtIGluZGV4IFRoZSBpbmRleCBvZiB0aGUgZGVzaXJlZCBsb2NhbGUuCiAqIEByZXR1cm4gQSBsb2NhbGUgZm9yIHdoaWNoIGNvbGxhdGlvbiBydWxlcyBhcmUgYXZhaWxhYmxlLCBvciAwIGlmIG5vbmUuCiAqIEBzZWUgdWNvbF9jb3VudEF2YWlsYWJsZQogKiBAc3RhYmxlCiAqLwpVX0NBUEkgY29uc3QgY2hhcioKdWNvbF9nZXRBdmFpbGFibGUoaW50MzJfdCBpbmRleCk7CgovKioKICogRGV0ZXJtaW5lIGhvdyBtYW55IGxvY2FsZXMgaGF2ZSBjb2xsYXRpb24gcnVsZXMgYXZhaWxhYmxlLgogKiBUaGlzIGZ1bmN0aW9uIGlzIG1vc3QgdXNlZnVsIGFzIGRldGVybWluaW5nIHRoZSBsb29wIGVuZGluZyBjb25kaXRpb24gZm9yCiAqIGNhbGxzIHRvIFxSZWZ7dWNvbF9nZXRBdmFpbGFibGV9LgogKiBAcmV0dXJuIFRoZSBudW1iZXIgb2YgbG9jYWxlcyBmb3Igd2hpY2ggY29sbGF0aW9uIHJ1bGVzIGFyZSBhdmFpbGFibGUuCiAqIEBzZWUgdWNvbF9nZXRBdmFpbGFibGUKICogQHN0YWJsZQogKi8KVV9DQVBJIGludDMyX3QKdWNvbF9jb3VudEF2YWlsYWJsZSh2b2lkKTsKCi8qKgogKiBHZXQgdGhlIGNvbGxhdGlvbiBydWxlcyBmcm9tIGEgVUNvbGxhdG9yLgogKiBUaGUgcnVsZXMgd2lsbCBmb2xsb3cgdGhlIHJ1bGUgc3ludGF4LgogKiBAcGFyYW0gY29sbCBUaGUgVUNvbGxhdG9yIHRvIHF1ZXJ5LgogKiBAcGFyYW0gbGVuZ3RoIAogKiBAcmV0dXJuIFRoZSBjb2xsYXRpb24gcnVsZXMuCiAqIEBzdGFibGUKICovClVfQ0FQSSBjb25zdCBVQ2hhcioKdWNvbF9nZXRSdWxlcyggICAgY29uc3QgICAgVUNvbGxhdG9yICAgICpjb2xsLCAKICAgICAgICBpbnQzMl90ICAgICAgICAgICAgKmxlbmd0aCk7CgovKioKICogR2V0IGEgc29ydCBrZXkgZm9yIGEgc3RyaW5nIGZyb20gYSBVQ29sbGF0b3IuCiAqIFNvcnQga2V5cyBtYXkgYmUgY29tcGFyZWQgdXNpbmcgPFRUPm1lbWNtcDwvVFQ+LgogKiBAcGFyYW0gY29sbCBUaGUgVUNvbGxhdG9yIGNvbnRhaW5pbmcgdGhlIGNvbGxhdGlvbiBydWxlcy4KICogQHBhcmFtIHNvdXJjZSBUaGUgc3RyaW5nIHRvIHRyYW5zZm9ybS4KICogQHBhcmFtIHNvdXJlY0xlbmd0aCBUaGUgbGVuZ3RoIG9mIHNvdXJjZSwgb3IgLTEgaWYgbnVsbC10ZXJtaW5hdGVkLgogKiBAcGFyYW0gcmVzdWx0IEEgcG9pbnRlciB0byBhIGJ1ZmZlciB0byByZWNlaXZlIHRoZSBhdHRyaWJ1dGUuCiAqIEBwYXJhbSByZXN1bHRMZW5ndGggVGhlIG1heGltdW0gc2l6ZSBvZiByZXN1bHQuCiAqIEByZXR1cm4gVGhlIHNpemUgbmVlZGVkIHRvIGZ1bGx5IHN0b3JlIHRoZSBzb3J0IGtleS4uCiAqIEBzZWUgdWNvbF9rZXlIYXNoQ29kZQogKiBAc3RhYmxlCiAqLwpVX0NBUEkgaW50MzJfdAp1Y29sX2dldFNvcnRLZXkoY29uc3QgICAgVUNvbGxhdG9yICAgICpjb2xsLAogICAgICAgIGNvbnN0ICAgIFVDaGFyICAgICAgICAqc291cmNlLAogICAgICAgIGludDMyX3QgICAgICAgICAgICBzb3VyY2VMZW5ndGgsCiAgICAgICAgdWludDhfdCAgICAgICAgICAgICpyZXN1bHQsCiAgICAgICAgaW50MzJfdCAgICAgICAgICAgIHJlc3VsdExlbmd0aCk7CgovKioKICogRE8gTk9UIFVTRSBUSElTIEFQSSEhISBJdCBpcyB0aGUgb2xkIGltcGxlbWVudGF0aW9uIG9mIHVjb2xfZ2V0U29ydEtleQogKiBhbmQgaXMgdXNlZCBvbmx5IGZvciB0ZXN0aW5nIHB1cnBvc2VzLgogKiBAaW50ZXJuYWwgRE8gTk9UIFVTRSEhISBXaWxsIGJlIHJlbW92ZWQgYnkgMS44IHJlbGVhc2UuCiAqLwpVX0NBUEkgaW50MzJfdAp1Y29sX2dldFNvcnRLZXlFeChjb25zdCAgICBVQ29sbGF0b3IgICAgKmNvbGwsCiAgICAgICAgY29uc3QgICAgVUNoYXIgICAgICAgICpzb3VyY2UsCiAgICAgICAgaW50MzJfdCAgICAgICAgc291cmNlTGVuZ3RoLAogICAgICAgIHVpbnQ4X3QgICAgICAgICpyZXN1bHQsCiAgICAgICAgaW50MzJfdCAgICAgICAgcmVzdWx0TGVuZ3RoKTsKCi8qKgogKiBHZW5lcmF0ZSBhIGhhc2ggY29kZSBmb3IgYSBjb2xsYXRpb24ga2V5LgogKiBBIGhhc2ggY29kZSBpcyBhIDMyLWJpdCB2YWx1ZSBzdWl0YWJsZSBmb3IgdXNlIGFzIGEga2V5IGluIGEgaGFzaHRhYmxlLgogKiBAcGFyYW0ga2V5IFRoZSBjb2xsYXRpb24ga2V5LgogKiBAcGFyYW0ga2V5TGVuZ3RoIFRoZSBsZW5ndGggb2Yga2V5LgogKiBAcmV0dXJuIEEgaGFzaCBjb2RlIGZvciBrZXkuCiAqIEBzZWUgdWNvbF9nZXRTb3J0S2V5CiAqIEBkZXByZWNhdGVkID8gIHdoeSBpcyBoYXNoQ29kZSB1c2VmdWwgZm9yIEMgdXNlcnM/CiAqLwpVX0NBUEkgaW50MzJfdAp1Y29sX2tleUhhc2hDb2RlKCAgICBjb25zdCAgICB1aW50OF90KiAgICBrZXksIAogICAgICAgICAgICBpbnQzMl90ICAgICAgICBsZW5ndGgpOwoKCi8qKiBUaGUgVUNvbGxhdGlvbkVsZW1lbnRzIHN0cnVjdC4KICogIEZvciB1c2FnZSBpbiBDIHByb2dyYW1zLgogKi8Kc3RydWN0IFVDb2xsYXRpb25FbGVtZW50czsKdHlwZWRlZiBzdHJ1Y3QgVUNvbGxhdGlvbkVsZW1lbnRzIFVDb2xsYXRpb25FbGVtZW50czsKCi8qKgogKiBUaGUgVUNvbGxhdGlvbkVsZW1lbnRzICBpcyB1c2VkIGFzIGFuIGl0ZXJhdG9yIHRvIHdhbGsgdGhyb3VnaAogKiBlYWNoIGNoYXJhY3RlciBvZiBhbiBpbnRlcm5hdGlvbmFsIHN0cmluZy4gVXNlIHRoZSBpdGVyYXRvciB0byByZXR1cm4gdGhlCiAqIG9yZGVyaW5nIHByaW9yaXR5IG9mIHRoZSBwb3NpdGlvbmVkIGNoYXJhY3Rlci4gVGhlIG9yZGVyaW5nIHByaW9yaXR5IG9mCiAqIGEgY2hhcmFjdGVyLCB3aGljaCB3ZSByZWZlciB0byBhcyBhIGtleSwgZGVmaW5lcyBob3cgYSBjaGFyYWN0ZXIgaXMKICogY29sbGF0ZWQgaW4gdGhlIGdpdmVuIGNvbGxhdGlvbiBvYmplY3QuCiAqIEZvciBleGFtcGxlLCBjb25zaWRlciB0aGUgZm9sbG93aW5nIGluIFNwYW5pc2g6CiAqIDxwcmU+CiAqIC4gICAgICAgImNhIiAtPiB0aGUgZmlyc3Qga2V5IGlzIGtleSgnYycpIGFuZCBzZWNvbmQga2V5IGlzIGtleSgnYScpLgogKiAuICAgICAgICJjaGEiIC0+IHRoZSBmaXJzdCBrZXkgaXMga2V5KCdjaCcpIGFuZCBzZWNvbmQga2V5IGlzIGtleSgnYScpLgogKiA8L3ByZT4KICogQW5kIGluIEdlcm1hbiwKICogPHByZT4KICogLiAgICAgICAi5mIiLT4gdGhlIGZpcnN0IGtleSBpcyBrZXkoJ2EnKSwgdGhlIHNlY29uZCBrZXkgaXMga2V5KCdlJyksIGFuZAogKiAuICAgICAgIHRoZSB0aGlyZCBrZXkgaXMga2V5KCdiJykuCiAqIDwvcHJlPgogKiBUaGUga2V5IG9mIGEgY2hhcmFjdGVyLCBpcyBhbiBjb25zdCBVQ09MX1BSSU1BUllNQVNLLCBVQ09MX1NFQ09OREFSWV9NQVNLLAogKiBVQ09MX1RFUlRJQVJZTUFTSy4gICAgCiAqIDxwPkV4YW1wbGUgb2YgdGhlIGl0ZXJhdG9yIHVzYWdlOiAod2l0aG91dCBlcnJvciBjaGVja2luZykKICogPHByZT4KICogLiAgdm9pZCBDb2xsYXRpb25FbGVtZW50SXRlcmF0b3JfRXhhbXBsZSgpCiAqIC4gIHsKICogLiAgICAgIFVDaGFyICpzOwogKiAuICAgICAgdF9pbnQzMiBvcmRlciwgcHJpbWFyeU9yZGVyOwogKiAuICAgICAgVUNvbGxhdGlvbkVsZW1lbnRzICpjOwogKiAuICAgICAgVUNvbGxhdG9yICpjb2xsOwogKiAuICAgICAgVUVycm9yQ29kZSBzdWNjZXNzID0gVV9aRVJPX0VSUk9SOwogKiAuICAgICAgcz0oVUNoYXIqKW1hbGxvYyhzaXplb2YoVUNoYXIpICogKHN0cmxlbigiVGhpcyBpcyBhIHRlc3QiKSsxKSApOwogKiAuICAgICAgdV91YXN0cmNweShzLCAiVGhpcyBpcyBhIHRlc3QiKTsKICogLiAgICAgIGNvbGwgPSB1Y29sX29wZW4oTlVMTCwgJnN1Y2Nlc3MpOwogKiAuICAgICAgYyA9IHVjb2xfb3BlbkVsZW1lbnRzKGNvbGwsIHN0ciwgdV9zdHJsZW4oc3RyKSwgJnN0YXR1cyk7CiAqIC4gICAgICBvcmRlciA9IHVjb2xfbmV4dChjLCAmc3VjY2Vzcyk7CiAqIC4gICAgICBwcmltYXJ5T3JkZXIgPSBvcmRlciAmIFVDT0xfUFJJTUFSWU1BU0s7CiAqIC4gICAgICBmcmVlKHMpOwogKiAuICAgICAgdWNvbF9jbG9zZShjb2xsKTsKICogLiAgICAgIHVjb2xfY2xvc2VFbGVtZW50cyhjKTsKICogLiAgfQogKiA8L3ByZT4KICogPHA+CiAqIHVjb2xfbmV4dCgpIHJldHVybnMgdGhlIGNvbGxhdGlvbiBvcmRlciBvZiB0aGUgbmV4dAogKiBjaGFyYWN0ZXIgYmFzZWQgb24gdGhlIGNvbXBhcmlzb24gbGV2ZWwgb2YgdGhlIGNvbGxhdG9yLiAgQSBjb2xsYXRpb24gb3JkZXIgCiAqIGNvbnNpc3RzIG9mIHByaW1hcnkgb3JkZXIsIHNlY29uZGFyeSBvcmRlciBhbmQgdGVydGlhcnkgb3JkZXIuICBUaGUgZGF0YSAKICogdHlwZSBvZiB0aGUgY29sbGF0aW9uIG9yZGVyIGlzIDxzdHJvbmc+dF9pbnQzMjwvc3Ryb25nPi4gIFRoZSBmaXJzdCAxNiBiaXRzIG9mIAogKiBhIGNvbGxhdGlvbiBvcmRlciBpcyBpdHMgcHJpbWFyeSBvcmRlcjsgdGhlIG5leHQgOCBiaXRzIGlzIHRoZSBzZWNvbmRhcnkgCiAqIG9yZGVyIGFuZCB0aGUgbGFzdCA4IGJpdHMgaXMgdGhlIHRlcnRpYXJ5IG9yZGVyLgogKgogKiBAc2VlICAgICAgICAgICAgICAgIENvbGxhdG9yCiAqLwoKLyoqCiAqIE9wZW4gdGhlIGNvbGxhdGlvbiBlbGVtZW50cyBmb3IgYSBzdHJpbmcuCiAqCiAqIEBwYXJhbSBjb2xsIFRoZSBjb2xsYXRvciBjb250YWluaW5nIHRoZSBkZXNpcmVkIGNvbGxhdGlvbiBydWxlcy4KICogQHBhcmFtIHRleHQgVGhlIHRleHQgdG8gaXRlcmF0ZSBvdmVyLgogKiBAcGFyYW0gdGV4dExlbmd0aCBUaGUgbnVtYmVyIG9mIGNoYXJhY3RlcnMgaW4gdGV4dCwgb3IgLTEgaWYgbnVsbC10ZXJtaW5hdGVkCiAqIEBwYXJhbSBzdGF0dXMgQSBwb2ludGVyIHRvIGFuIFVFcnJvckNvZGUgdG8gcmVjZWl2ZSBhbnkgZXJyb3JzLgogKiBAc3RhYmxlCiAqLwpVX0NBUEkgVUNvbGxhdGlvbkVsZW1lbnRzKgp1Y29sX29wZW5FbGVtZW50cyggICAgY29uc3QgICAgVUNvbGxhdG9yICAgICAgICpjb2xsLAogICAgICAgICAgICBjb25zdCAgICBVQ2hhciAgICAgICAgICAgKnRleHQsCiAgICAgICAgICAgIGludDMyX3QgICAgICAgICAgICAgICAgICB0ZXh0TGVuZ3RoLAogICAgICAgICAgICBVRXJyb3JDb2RlICAgICAgICAgKnN0YXR1cyk7CgovKiBCaXQgbWFzayBmb3IgcHJpbWFyeSBjb2xsYXRpb24gc3RyZW5ndGguICovCiNkZWZpbmUgVUNPTF9QUklNQVJZTUFTSyAgICAweEZGRkYwMDAwCgovKiBCaXQgbWFzayBmb3Igc2Vjb25kYXJ5IGNvbGxhdGlvbiBzdHJlbmd0aC4gKi8KI2RlZmluZSBVQ09MX1NFQ09OREFSWU1BU0sgIDB4MDAwMEZGMDAKCi8qIEJpdCBtYXNrIGZvciB0ZXJ0aWFyeSBjb2xsYXRpb24gc3RyZW5ndGguICovCiNkZWZpbmUgVUNPTF9URVJUSUFSWU1BU0sgICAweDAwMDAwMEZGCgovKiogVGhpcyBpbmRpY2F0ZXMgdGhlIGxhc3QgZWxlbWVudCBpbiBhIFVDb2xsYXRpb25FbGVtZW50cyBoYXMgYmVlbiBjb25zdW1lZC4gCiAqCiAqLwojZGVmaW5lIFVDT0xfTlVMTE9SREVSICAgICAgICAweEZGRkZGRkZGCgovKioKICogQ2xvc2UgYSBVQ29sbGF0aW9uRWxlbWVudHMuCiAqIE9uY2UgY2xvc2VkLCBhIFVDb2xsYXRpb25FbGVtZW50cyBtYXkgbm8gbG9uZ2VyIGJlIHVzZWQuCiAqIEBwYXJhbSBlbGVtcyBUaGUgVUNvbGxhdGlvbkVsZW1lbnRzIHRvIGNsb3NlLgogKiBAc3RhYmxlCiAqLwpVX0NBUEkgdm9pZAp1Y29sX2Nsb3NlRWxlbWVudHMoVUNvbGxhdGlvbkVsZW1lbnRzICplbGVtcyk7CgovKioKICogUmVzZXQgdGhlIGNvbGxhdGlvbiBlbGVtZW50cyB0byB0aGVpciBpbml0aWFsIHN0YXRlLgogKiBUaGlzIHdpbGwgbW92ZSB0aGUgJ2N1cnNvcicgdG8gdGhlIGJlZ2lubmluZyBvZiB0aGUgdGV4dC4KICogQHBhcmFtIGVsZW1zIFRoZSBVQ29sbGF0aW9uRWxlbWVudHMgdG8gcmVzZXQuCiAqIEBzZWUgdWNvbF9uZXh0CiAqIEBzZWUgdWNvbF9wcmV2aW91cwogKiBAc3RhYmxlCiAqLwpVX0NBUEkgdm9pZAp1Y29sX3Jlc2V0KFVDb2xsYXRpb25FbGVtZW50cyAqZWxlbXMpOwoKLyoqCiAqIEdldCB0aGUgb3JkZXJpbmcgcHJpb3JpdHkgb2YgdGhlIG5leHQgY29sbGF0aW9uIGVsZW1lbnQgaW4gdGhlIHRleHQuCiAqIEEgc2luZ2xlIGNoYXJhY3RlciBtYXkgY29udGFpbiBtb3JlIHRoYW4gb25lIGNvbGxhdGlvbiBlbGVtZW50LgogKiBAcGFyYW0gZWxlbXMgVGhlIFVDb2xsYXRpb25FbGVtZW50cyBjb250YWluaW5nIHRoZSB0ZXh0LgogKiBAcGFyYW0gc3RhdHVzIEEgcG9pbnRlciB0byBhbiBVRXJyb3JDb2RlIHRvIHJlY2VpdmUgYW55IGVycm9ycy4KICogQHJldHVybiBUaGUgbmV4dCBjb2xsYXRpb24gZWxlbWVudHMgb3JkZXJpbmcsIG9yIFxSZWZ7VUNPTF9OVUxMT1JERVJ9IGlmIHRoZQogKiBlbmQgb2YgdGhlIHRleHQgaXMgcmVhY2hlZC4KICogQHN0YWJsZQogKi8KVV9DQVBJIGludDMyX3QKdWNvbF9uZXh0KCAgICBVQ29sbGF0aW9uRWxlbWVudHMgICAgKmVsZW1zLAogICAgICAgIFVFcnJvckNvZGUgICAgICAgICpzdGF0dXMpOwoKLyoqCiAqIEdldCB0aGUgb3JkZXJpbmcgcHJpb3JpdHkgb2YgdGhlIHByZXZpb3VzIGNvbGxhdGlvbiBlbGVtZW50IGluIHRoZSB0ZXh0LgogKiBBIHNpbmdsZSBjaGFyYWN0ZXIgbWF5IGNvbnRhaW4gbW9yZSB0aGFuIG9uZSBjb2xsYXRpb24gZWxlbWVudC4KICogQHBhcmFtIGVsZW1zIFRoZSBVQ29sbGF0aW9uRWxlbWVudHMgY29udGFpbmluZyB0aGUgdGV4dC4KICogQHBhcmFtIHN0YXR1cyBBIHBvaW50ZXIgdG8gYW4gVUVycm9yQ29kZSB0byByZWNlaXZlIGFueSBlcnJvcnMuCiAqIEByZXR1cm4gVGhlIHByZXZpb3VzIGNvbGxhdGlvbiBlbGVtZW50cyBvcmRlcmluZywgb3IgXFJlZntVQ09MX05VTExPUkRFUn0KICogaWYgdGhlIGVuZCBvZiB0aGUgdGV4dCBpcyByZWFjaGVkLgogKiBAc3RhYmxlCiAqLwpVX0NBUEkgaW50MzJfdAp1Y29sX3ByZXZpb3VzKCAgICBVQ29sbGF0aW9uRWxlbWVudHMgICAgKmVsZW1zLAogICAgICAgIFVFcnJvckNvZGUgICAgICAgICpzdGF0dXMpOwoKLyoqCiAqIEdldCB0aGUgbWF4aW11bSBsZW5ndGggb2YgYW55IGV4cGFuc2lvbiBzZXF1ZW5jZXMgdGhhdCBlbmQgd2l0aCB0aGUgCiAqIHNwZWNpZmllZCBjb21wYXJpc29uIG9yZGVyLgogKiBUaGlzIGlzIHVzZWZ1bCBmb3IgLi4uLiA/CiAqIEBwYXJhbSBlbGVtcyBUaGUgVUNvbGxhdGlvbkVsZW1lbnRzIGNvbnRhaW5pbmcgdGhlIHRleHQuCiAqIEBwYXJhbSBvcmRlciBBIGNvbGxhdGlvbiBvcmRlciByZXR1cm5lZCBieSBwcmV2aW91cyBvciBuZXh0LgogKiBAcmV0dXJuIFRoZSBtYXhpbXVtIGxlbmd0aCBvZiBhbnkgZXhwYW5zaW9uIHNlcXVlbmNlcyBlbmRpbmcgd2l0aCB0aGUgCiAqIHNwZWNpZmllZCBvcmRlci4KICogQHN0YWJsZQogKi8KVV9DQVBJIGludDMyX3QKdWNvbF9nZXRNYXhFeHBhbnNpb24oICAgIGNvbnN0ICAgIFVDb2xsYXRpb25FbGVtZW50cyAgICAqZWxlbXMsCiAgICAgICAgICAgIGludDMyX3QgICAgICAgICAgICAgICAgb3JkZXIpOwoKLyoqCiAqIFNldCB0aGUgdGV4dCBjb250YWluaW5nIHRoZSBjb2xsYXRpb24gZWxlbWVudHMuCiAqIFRoaXMgCiAqIEBwYXJhbSBlbGVtcyBUaGUgVUNvbGxhdGlvbkVsZW1lbnRzIHRvIHNldC4KICogQHBhcmFtIHRleHQgVGhlIHNvdXJjZSB0ZXh0IGNvbnRhaW5pbmcgdGhlIGNvbGxhdGlvbiBlbGVtZW50cy4KICogQHBhcmFtIHRleHRMZW5ndGggVGhlIGxlbmd0aCBvZiB0ZXh0LCBvciAtMSBpZiBudWxsLXRlcm1pbmF0ZWQuCiAqIEBwYXJhbSBzdGF0dXMgQSBwb2ludGVyIHRvIGFuIFVFcnJvckNvZGUgdG8gcmVjZWl2ZSBhbnkgZXJyb3JzLgogKiBAc2VlIHVjb2xfZ2V0VGV4dAogKiBAc3RhYmxlCiAqLwpVX0NBUEkgdm9pZAp1Y29sX3NldFRleHQoICAgIFVDb2xsYXRpb25FbGVtZW50cyAgICAqZWxlbXMsCiAgICAgICAgY29uc3QgICAgVUNoYXIgICAgICAgICp0ZXh0LAogICAgICAgIGludDMyX3QgICAgICAgICAgICB0ZXh0TGVuZ3RoLAogICAgICAgIFVFcnJvckNvZGUgICAgICAgICpzdGF0dXMpOwoKLyoqCiAqIEdldCB0aGUgb2Zmc2V0IG9mIHRoZSBjdXJyZW50IHNvdXJjZSBjaGFyYWN0ZXIuCiAqIFRoaXMgaXMgYW4gb2Zmc2V0IGludG8gdGhlIHRleHQgb2YgdGhlIGNoYXJhY3RlciBjb250YWluaW5nIHRoZSBjdXJyZW50CiAqIGNvbGxhdGlvbiBlbGVtZW50cy4KICogQHBhcmFtIGVsZW1zIFRoZSBVQ29sbGF0aW9uRWxlbWVudHMgdG8gcXVlcnkuCiAqIEByZXR1cm4gVGhlIG9mZnNldCBvZiB0aGUgY3VycmVudCBzb3VyY2UgY2hhcmFjdGVyLgogKiBAc2VlIHVjb2xfc2V0T2Zmc2V0CiAqIEBzdGFibGUKICovClVfQ0FQSSBVVGV4dE9mZnNldAp1Y29sX2dldE9mZnNldChjb25zdCBVQ29sbGF0aW9uRWxlbWVudHMgKmVsZW1zKTsKCi8qKgogKiBTZXQgdGhlIG9mZnNldCBvZiB0aGUgY3VycmVudCBzb3VyY2UgY2hhcmFjdGVyLgogKiBUaGlzIGlzIGFuIG9mZnNldCBpbnRvIHRoZSB0ZXh0IG9mIHRoZSBjaGFyYWN0ZXIgdG8gYmUgcHJvY2Vzc2VkLgogKiBAcGFyYW0gZWxlbXMgVGhlIFVDb2xsYXRpb25FbGVtZW50cyB0byBzZXQuCiAqIEBwYXJhbSBvZmZzZXQgVGhlIGRlc2lyZWQgY2hhcmFjdGVyIG9mZnNldC4KICogQHBhcmFtIHN0YXR1cyBBIHBvaW50ZXIgdG8gYW4gVUVycm9yQ29kZSB0byByZWNlaXZlIGFueSBlcnJvcnMuCiAqIEBzZWUgdWNvbF9nZXRPZmZzZXQKICogQHN0YWJsZQogKi8KVV9DQVBJIHZvaWQKdWNvbF9zZXRPZmZzZXQoICAgIFVDb2xsYXRpb25FbGVtZW50cyAgICAqZWxlbXMsCiAgICAgICAgVVRleHRPZmZzZXQgICAgICAgIG9mZnNldCwKICAgICAgICBVRXJyb3JDb2RlICAgICAgICAqc3RhdHVzKTsKCi8qKgogKiBHZXRzIHRoZSB2ZXJzaW9uIGluZm9ybWF0aW9uIGZvciBhIENvbGxhdG9yLiAKICogQHBhcmFtIGluZm8gdGhlIHZlcnNpb24gIyBpbmZvcm1hdGlvbiwgdGhlIHJlc3VsdCB3aWxsIGJlIGZpbGxlZCBpbgogKiBAc3RhYmxlCiAqLwpVX0NBUEkgdm9pZCBVX0VYUE9SVDIKdWNvbF9nZXRWZXJzaW9uKGNvbnN0IFVDb2xsYXRvciogY29sbCwgVVZlcnNpb25JbmZvIGluZm8pOwoKCi8qIEZvbGxvd2luZyBhcmUgdGhlIG5ldyBBUElzIGZvciAxLjcuIFRoZXkgYXJlIGFsbCBkcmFmdCBhbmQgbW9zdCBhcmUgbm90IGV2ZW4gaW1wbGVtZW50ZWQgKi8KCi8qKgogKiBVbml2ZXJzYWwgYXR0cmlidXRlIHNldHRlcgogKiBAcGFyYW0gY29sbCBjb2xsYXRvciB3aGljaCBhdHRyaWJ1dGVzIGFyZSB0byBiZSBjaGFuZ2VkCiAqIEBwYXJhbSBhdHRyIGF0dHJpYnV0ZSB0eXBlIAogKiBAcGFyYW0gdmFsdWUgYXR0cmlidXRlIHZhbHVlCiAqIEBwYXJhbSBzdGF0dXMgdG8gaW5kaWNhdGUgd2hldGhlciB0aGUgb3BlcmF0aW9uIHdlbnQgb24gc21vb3RobHkgb3IgdGhlcmUgd2VyZSBlcnJvcnMKICogQGRyYWZ0IEFQSSAxLjcgZnJlZXplCiAqLwpVX0NBUEkgdm9pZCB1Y29sX3NldEF0dHJpYnV0ZShVQ29sbGF0b3IgKmNvbGwsIFVDb2xBdHRyaWJ1dGUgYXR0ciwgVUNvbEF0dHJpYnV0ZVZhbHVlIHZhbHVlLCBVRXJyb3JDb2RlICpzdGF0dXMpOwoKLyoqCiAqIFVuaXZlcnNhbCBhdHRyaWJ1dGUgZ2V0dGVyCiAqIEBwYXJhbSBjb2xsIGNvbGxhdG9yIHdoaWNoIGF0dHJpYnV0ZXMgYXJlIHRvIGJlIGNoYW5nZWQKICogQHBhcmFtIGF0dHIgYXR0cmlidXRlIHR5cGUKICogQHJldHVybiBhdHRyaWJ1dGUgdmFsdWUKICogQHBhcmFtIHN0YXR1cyB0byBpbmRpY2F0ZSB3aGV0aGVyIHRoZSBvcGVyYXRpb24gd2VudCBvbiBzbW9vdGhseSBvciB0aGVyZSB3ZXJlIGVycm9ycwogKiBAZHJhZnQgQVBJIDEuNyBmcmVlemUKICovClVfQ0FQSSBVQ29sQXR0cmlidXRlVmFsdWUgdWNvbF9nZXRBdHRyaWJ1dGUoY29uc3QgVUNvbGxhdG9yICpjb2xsLCBVQ29sQXR0cmlidXRlIGF0dHIsIFVFcnJvckNvZGUgKnN0YXR1cyk7CgovKioKICogVGhyZWFkIHNhZmUgY2xvbmluZyBvcGVyYXRpb24KICogQHBhcmFtIGNvbGwgY29sbGF0b3IgdG8gYmUgY2xvbmVkCiAqIEBwYXJhbSBzdGFja0J1ZmZlciB1c2VyIGFsbG9jYXRlZCBzcGFjZSBmb3IgdGhlIG5ldyBjbG9uZS4gSWYgTlVMTCBuZXcgbWVtb3J5IHdpbGwgYmUgYWxsb2NhdGVkCiAqIEBwYXJhbSBidWZmZXJTaXplIHNpemUgb2YgYWxsb2NhdGVkIHNwYWNlLiBJZiBub3QgZW5vdWdoIG5ldyBtZW1vcnkgd2lsbCBiZSBhbGxvY2F0ZWQuCiAqIEBwYXJhbSBzdGF0dXMgdG8gaW5kaWNhdGUgd2hldGhlciB0aGUgb3BlcmF0aW9uIHdlbnQgb24gc21vb3RobHkgb3IgdGhlcmUgd2VyZSBlcnJvcnMKICogQHJldHVybiBwb2ludGVyIHRvIHRoZSBuZXcgY2xvbmUKICogQGRyYWZ0IEFQSSAxLjcgZnJlZXplCiAqLwpVX0NBUEkgVUNvbGxhdG9yICp1Y29sX3NhZmVDbG9uZShjb25zdCBVQ29sbGF0b3IgKmNvbGwsIHZvaWQgKnN0YWNrQnVmZmVyLCB1aW50MzJfdCBidWZmZXJTaXplLCBVRXJyb3JDb2RlICpzdGF0dXMpOwoKLyogZGVjbGFyYXRpb24gZm9yIGZvcndhcmQgaXRlcmF0aW5nIGZ1bmN0aW9uICovCnR5cGVkZWYgVUNoYXIgVUNoYXJGb3J3YXJkSXRlcmF0b3Iodm9pZCAqY29udGV4dCk7CgovKioKICogU3RyaW5nIGNvbXBhcmUgdGhhdCB1c2VzIHVzZXIgc3VwcGxpZWQgY2hhcmFjdGVyIGl0ZXJhdGlvbi4KICogVGhlIGlkZWEgaXMgdG8gcHJldmVudCB1c2VycyBmcm9tIGhhdmluZyB0byBjb252ZXJ0IHRoZSB3aG9sZSBzdHJpbmcgaW50byBVQ2hhcidzIGJlZm9yZSBjb21wYXJpbmcKICogc2luY2Ugc29tZXRpbWVzIHN0cmluZ3MgZGlmZmVyIG9uIGZpcnN0IGNvdXBsZSBvZiBjaGFyYWN0ZXJzLgogKiBAcGFyYW0gY29sbCBjb2xsYXRvciB0byBiZSB1c2VkIGZvciBjb21wYXJpbmcKICogQHBhcmFtIHNvdXJjZSBwb2ludGVyIHRvIGZ1bmN0aW9uIGZvciBpdGVyYXRpbmcgb3ZlciB0aGUgZmlyc3Qgc3RyaW5nCiAqIEBwYXJhbSBzb3VyY2VDb250ZXh0IGRhdGEgdG8gYmUgcGFzc2VkIHRvIHRoZSBmaXJzdCBpdGVyYXRpbmcgZnVuY3Rpb24uCiAqIEBwYXJhbSB0YXJnZXQgcG9pbnRlciB0byBmdW5jdGlvbiBmb3IgaXRlcmF0aW5nIG92ZXIgdGhlIHNlY29uZCBzdHJpbmcKICogQHBhcmFtIHRhcmdldENvbnRleHQgZGF0YSB0byBiZSBwYXNzZWQgdG8gdGhlIHNlY29uZCBpdGVyYXRpbmcgZnVuY3Rpb24uCiAqIEByZXR1cm4gVGhlIHJlc3VsdCBvZiBjb21wYXJpbmcgdGhlIHN0cmluZ3M7IG9uZSBvZiBVQ09MX0VRVUFMLAogKiBVQ09MX0dSRUFURVIsIFVDT0xfTEVTUwogKi8KVV9DQVBJIFVDb2xsYXRpb25SZXN1bHQgdWNvbF9zdHJjb2xsaW5jKGNvbnN0IFVDb2xsYXRvciAqY29sbCwgCgkJCQkJCQkJIFVDaGFyRm9yd2FyZEl0ZXJhdG9yICpzb3VyY2UsIHZvaWQgKnNvdXJjZUNvbnRleHQsCgkJCQkJCQkJIFVDaGFyRm9yd2FyZEl0ZXJhdG9yICp0YXJnZXQsIHZvaWQgKnRhcmdldENvbnRleHQpOwoKLyoqCiAqIFJldHVybnMgY3VycmVudCBydWxlcy4gRGVsdGEgZGVmaW5lcyB3aGV0aGVyIGZ1bGwgcnVsZXMgYXJlIHJldHVybmVkIG9yIGp1c3QgdGhlIHRhaWxvcmluZy4gCiAqIFJldHVybnMgbnVtYmVyIG9mIFVDaGFycyBuZWVkZWQgdG8gc3RvcmUgcnVsZXMuIElmIGJ1ZmZlciBpcyBOVUxMIG9yIGJ1ZmZlckxlbiBpcyBub3QgZW5vdWdoIAogKiB0byBzdG9yZSBydWxlcywgd2lsbCBzdG9yZSB1cCB0byBhdmFpbGFibGUgc3BhY2UuCiAqIEBwYXJhbSBjb2xsIGNvbGxhdG9yIHRvIGdldCB0aGUgcnVsZXMgZnJvbQogKiBAcGFyYW0gZGVsdGEgb25lIG9mIAlVQ09MX1RBSUxPUklOR19PTkxZLCBVQ09MX0ZVTExfUlVMRVMuIAogKiBAcGFyYW0gYnVmZmVyIGJ1ZmZlciB0byBzdG9yZSB0aGUgcmVzdWx0IGluLiBJZiBOVUxMLCB5b3UnbGwgZ2V0IG5vIHJ1bGVzLgogKiBAcGFyYW0gYnVmZmVyTGVuIGxlbmdodCBvZiBidWZmZXIgdG8gc3RvcmUgcnVsZXMgaW4uIElmIGxlc3MgdGhlbiBuZWVkZWQgeW91J2xsIGdldCBvbmx5IHRoZSBwYXJ0IHRoYXQgZml0cyBpbi4KICovClVfQ0FQSSBpbnQzMl90IHVjb2xfZ2V0UnVsZXNFeChjb25zdCBVQ29sbGF0b3IgKmNvbGwsIFVDb2xSdWxlT3B0aW9uIGRlbHRhLCBVQ2hhciAqYnVmZmVyLCBpbnQzMl90IGJ1ZmZlckxlbik7CgoKI2VuZGlmCg==