LyoKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgoqIENvcHlyaWdodCCpIHsxOTk2LTE5OTl9LCBJbnRlcm5hdGlvbmFsIEJ1c2luZXNzIE1hY2hpbmVzIENvcnBvcmF0aW9uIGFuZCBvdGhlcnMuIEFsbCBSaWdodHMgUmVzZXJ2ZWQuCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKi8KCiNpZm5kZWYgVUNPTF9ICiNkZWZpbmUgVUNPTF9ICgojaW5jbHVkZSAidW5pY29kZS91dHlwZXMuaCIKLyoqCiAqIEBuYW1lIENvbGxhdG9yIEMgQVBJCiAqCiAqIFRoZSBDIEFQSSBmb3IgQ29sbGF0b3IgcGVyZm9ybXMgbG9jYWxlLXNlbnNpdGl2ZQogKiA8Y29kZT5TdHJpbmc8L2NvZGU+IGNvbXBhcmlzb24uIFlvdSB1c2UgdGhpcyBjbGFzcyB0byBidWlsZAogKiBzZWFyY2hpbmcgYW5kIHNvcnRpbmcgcm91dGluZXMgZm9yIG5hdHVyYWwgbGFuZ3VhZ2UgdGV4dC4KICoKICogIAogKiA8cD4KICogTGlrZSBvdGhlciBsb2NhbGUtc2Vuc2l0aXZlIGNsYXNzZXMsIHlvdSBjYW4gdXNlIHRoZSBmdW5jdGlvbgogKiA8Y29kZT51Y29sX29wZW4oKTwvY29kZT4sIHRvIG9idGFpbiB0aGUgYXBwcm9wcmlhdGUgcG9pbnRlciB0byAKICogPGNvZGU+VUNvbGxhdG9yPC9jb2RlPiBvYmplY3QgZm9yIGEgZ2l2ZW4gbG9jYWxlLiBJZiB5b3UgbmVlZAogKiB0byB1bmRlcnN0YW5kIHRoZSBkZXRhaWxzIG9mIGEgcGFydGljdWxhciBjb2xsYXRpb24gc3RyYXRlZ3kgb3IKICogaWYgeW91IG5lZWQgdG8gbW9kaWZ5IHRoYXQgc3RyYXRlZ3kuCiAqCiAqIDxwPgogKiBUaGUgZm9sbG93aW5nIGV4YW1wbGUgc2hvd3MgaG93IHRvIGNvbXBhcmUgdHdvIHN0cmluZ3MgdXNpbmcKICogdGhlIDxjb2RlPlVDb2xsYXRvcjwvY29kZT4gZm9yIHRoZSBkZWZhdWx0IGxvY2FsZS4KICogPGJsb2NrcXVvdGU+CiAqIDxwcmU+CiAqIC8vIENvbXBhcmUgdHdvIHN0cmluZ3MgaW4gdGhlIGRlZmF1bHQgbG9jYWxlCiAqIFVFcnJvckNvZGUgc3VjY2VzcyA9IFVfWkVST19FUlJPUjsKICogVUNvbGxhdG9yKiBteUNvbGxhdG9yID0gdWNvbF9vcGVuKE5VTEwsICZzdWNjZXNzKTsKICogVUNoYXIgc291cmNlWzRdLCB0YXJnZXRbNF07CiAqIHVfdWFzdHJjcHkoc291cmNlLCAiYWJjIik7CiAqIHVfdWFzdHJjcHkodGFyZ2V0LCAiQUJDIik7CiAqIGlmKCB1X3N0cmNvbGwobXlDb2xsYXRvciwgc291cmNlLCB1X3N0cmxlbihzb3VyY2UpLCB0YXJnZXQsIHVfc3RybGVuKHRhcmdldCkpID09IFVDT0xfTEVTUykgewogKiAgICAgcHJpbnRmKCJhYmMgaXMgbGVzcyB0aGFuIEFCQ1xuIik7CiAqIH1lbHNlewogKiAgICAgcHJpbnRmKCJhYmMgaXMgZ3JlYXRlciB0aGFuIG9yIGVxdWFsIHRvIEFCQ1xuIik7CiAqIH0KICogPC9wcmU+CiAqIDwvYmxvY2txdW90ZT4KICoKICogPHA+CiAqIFlvdSBjYW4gc2V0IGEgPGNvZGU+Q29sbGF0b3I8L2NvZGU+J3MgPGVtPnN0cmVuZ3RoPC9lbT4gcHJvcGVydHkKICogdG8gZGV0ZXJtaW5lIHRoZSBsZXZlbCBvZiBkaWZmZXJlbmNlIGNvbnNpZGVyZWQgc2lnbmlmaWNhbnQgaW4KICogY29tcGFyaXNvbnMuIEZvdXIgc3RyZW5ndGhzIGFyZSBwcm92aWRlZDogPGNvZGU+VUNPTF9QUklNQVJZPC9jb2RlPiwKICogPGNvZGU+VUNPTF9TRUNPTkRBUlk8L2NvZGU+LCA8Y29kZT5VQ09MX1RFUlRJQVJZPC9jb2RlPiwgYW5kIAogKiA8Y29kZT5VQ09MX0lERU5USUNBTDwvY29kZT4uIFRoZSBleGFjdCBhc3NpZ25tZW50IG9mIHN0cmVuZ3RocyB0byAKICogbGFuZ3VhZ2UgZmVhdHVyZXMgaXMgbG9jYWxlIGRlcGVuZGFudC4gIEZvciBleGFtcGxlLCBpbiBDemVjaCwgCiAqICJlIiBhbmQgImYiIGFyZSBjb25zaWRlcmVkIHByaW1hcnkgZGlmZmVyZW5jZXMsIHdoaWxlICJlIiBhbmQgIlx1MDBFQSIKICogYXJlIHNlY29uZGFyeSBkaWZmZXJlbmNlcywgImUiIGFuZCAiRSIgYXJlIHRlcnRpYXJ5IGRpZmZlcmVuY2VzIGFuZCAKICogImUiIGFuZCAiZSIgYXJlIGlkZW50aWNhbC4KICogVGhlIGZvbGxvd2luZyBzaG93cyBob3cgYm90aCBjYXNlIGFuZCBhY2NlbnRzIGNvdWxkIGJlIGlnbm9yZWQgZm9yCiAqIFVTIEVuZ2xpc2guCiAqIDxibG9ja3F1b3RlPgogKiA8cHJlPgogKiAvL0dldCB0aGUgQ29sbGF0b3IgZm9yIFVTIEVuZ2xpc2ggYW5kIHNldCBpdHMgc3RyZW5ndGggdG8gVUNPTF9QUklNQVJZCiAqIFVFcnJvckNvZGUgc3VjY2VzcyA9IFVfWkVST19FUlJPUjsKICogVUNvbGxhdG9yKiB1c0NvbGxhdG9yID0gdWNvbF9vcGVuKCJlbl9VUyIsICZzdWNjZXNzKTsKICogdWNvbF9zZXRTdHJlbmd0aCh1c0NvbGxhdG9yLCBVQ09MX1BSSU1BUlkpOwogKiBVQ2hhciBzb3VyY2VbNF0sIHRhcmdldFs0XTsKICogdV91YXN0cmNweShzb3VyY2UsICJhYmMiKTsKICogdV91YXN0cmNweSh0YXJnZXQsICJBQkMiKTsKICogaWYoIHVfc3RyY29sbChteUNvbGxhdG9yLCBzb3VyY2UsIHVfc3RybGVuKHNvdXJjZSksIHRhcmdldCwgdV9zdHJsZW4odGFyZ2V0KSkgPT0gVUNPTF9FUVVBTCkgewogKiAgICAgcHJpbnRmKCInYWJjJyBhbmQgJ0FCQycgc3RyaW5ncyBhcmUgZXF1aXZhbGVudCB3aXRoIHN0cmVuZ3RoIFVDT0xfUFJJTUFSWVxuIik7CiAqIH0KICogPC9wcmU+CiAqIDwvYmxvY2txdW90ZT4KICogPHA+CiAqIEZvciBjb21wYXJpbmcgPGNvZGU+U3RyaW5nPC9jb2RlPnMgZXhhY3RseSBvbmNlLCB0aGUgPGNvZGU+dV9zdHJjb2xsPC9jb2RlPgogKiBtZXRob2QgcHJvdmlkZXMgdGhlIGJlc3QgcGVyZm9ybWFuY2UuIFdoZW4gc29ydGluZyBhIGxpc3Qgb2YKICogPGNvZGU+U3RyaW5nPC9jb2RlPnMgaG93ZXZlciwgaXQgaXMgZ2VuZXJhbGx5IG5lY2Vzc2FyeSB0byBjb21wYXJlIGVhY2gKICogPGNvZGU+U3RyaW5nPC9jb2RlPiBtdWx0aXBsZSB0aW1lcy4gSW4gdGhpcyBjYXNlLCA8Y29kZT5zb3J0S2V5PC9jb2RlPnMKICogcHJvdmlkZSBiZXR0ZXIgcGVyZm9ybWFuY2UuIFRoZSA8Y29kZT51Y29sX2dldHNvcnRLZXk8L2NvZGU+IG1ldGhvZCBjb252ZXJ0cwogKiBhIDxjb2RlPlN0cmluZzwvY29kZT4gdG8gYSBzZXJpZXMgb2YgYml0cyB0aGF0IGNhbiBiZSBjb21wYXJlZCBiaXR3aXNlCiAqIGFnYWluc3Qgb3RoZXIgPGNvZGU+c29ydEtleTwvY29kZT5zIHVzaW5nIDxjb2RlPm1lbWNtcCgpPC9jb2RlPiAKICogPHA+CiAqIDxzdHJvbmc+Tm90ZTo8L3N0cm9uZz4gPGNvZGU+VUNvbGxhdG9yPC9jb2RlPnMgd2l0aCBkaWZmZXJlbnQgTG9jYWxlLAogKiBDb2xsYXRpb24gU3RyZW5ndGggYW5kIERlY29tcG9zaXRpb24gTW9kZSBzZXR0aW5ncyB3aWxsIHJldHVybiBkaWZmZXJlbnQKICogc29ydCBvcmRlcnMgZm9yIHRoZSBzYW1lIHNldCBvZiBzdHJpbmdzLiBMb2NhbGVzIGhhdmUgc3BlY2lmaWMgCiAqIGNvbGxhdGlvbiBydWxlcywgYW5kIHRoZSB3YXkgaW4gd2hpY2ggc2Vjb25kYXJ5IGFuZCB0ZXJ0aWFyeSBkaWZmZXJlbmNlcyAKICogYXJlIHRha2VuIGludG8gYWNjb3VudCwgZm9yIGV4YW1wbGUsIHdpbGwgcmVzdWx0IGluIGEgZGlmZmVyZW50IHNvcnRpbmcgb3JkZXIKICogZm9yIHNhbWUgc3RyaW5ncy4KICogPHA+CiAqIEBzZWUgICAgICAgICBVQ29sbGF0aW9uUmVzdWx0CiAqIEBzZWUgICAgICAgICBVTm9ybWFsaXphdGlvbk1vZGUKICogQHNlZSAgICAgICAgICAgIFVDb2xsYXRpb25TdHJlbmd0aAogKiBAc2VlICAgICAgICAgVUNvbGxhdGlvbkVsZW1lbnRzCiAqLwoKIC8qKiBBIGNvbGxhdG9yLgogKiAgRm9yIHVzYWdlIGluIEMgcHJvZ3JhbXMuCiAqLwp0eXBlZGVmIHZvaWQqIFVDb2xsYXRvcjsKCiAgICAvKioKICAgICAqIFVDT0xfTEVTUyBpcyByZXR1cm5lZCBpZiBzb3VyY2Ugc3RyaW5nIGlzIGNvbXBhcmVkIHRvIGJlIGxlc3MgdGhhbiB0YXJnZXQKICAgICAqIHN0cmluZyBpbiB0aGUgdV9zdHJjb2xsKCkgbWV0aG9kLgogICAgICogVUNPTF9FUVVBTCBpcyByZXR1cm5lZCBpZiBzb3VyY2Ugc3RyaW5nIGlzIGNvbXBhcmVkIHRvIGJlIGVxdWFsIHRvIHRhcmdldAogICAgICogc3RyaW5nIGluIHRoZSB1X3N0cmNvbGwoKSBtZXRob2QuCiAgICAgKiBVQ09MX0dSRUFURVIgaXMgcmV0dXJuZWQgaWYgc291cmNlIHN0cmluZyBpcyBjb21wYXJlZCB0byBiZSBncmVhdGVyIHRoYW4KICAgICAqIHRhcmdldCBzdHJpbmcgaW4gdGhlIHVfc3RyY29sbCgpIG1ldGhvZC4KICAgICAqIEBzZWUgdV9zdHJjb2xsKCkKICAgICAqKi8KLyoqIFBvc3NpYmxlIHZhbHVlcyBmb3IgYSBjb21wYXJpc29uIHJlc3VsdCAqLwplbnVtIFVDb2xsYXRpb25SZXN1bHQgewogIC8qKiBzdHJpbmcgYSA9PSBzdHJpbmcgYiAqLwogIFVDT0xfRVFVQUwgICAgPSAwLAogIC8qKiBzdHJpbmcgYSA+IHN0cmluZyBiICovCiAgVUNPTF9HUkVBVEVSICAgID0gMSwKICAvKiogc3RyaW5nIGEgPCBzdHJpbmcgYiAqLwogIFVDT0xfTEVTUyAgICA9IC0xCn07CnR5cGVkZWYgZW51bSBVQ29sbGF0aW9uUmVzdWx0IFVDb2xsYXRpb25SZXN1bHQ7CiAgLyoqCiAgICAqIFVDT0xfTk9fTk9STUFMSVpBVElPTiA6IEFjY2VudGVkIGNoYXJhY3RlcnMgd2lsbCBub3QgYmUgZGVjb21wb3NlZCBmb3Igc29ydGluZy4gIAogICAgKiBVQ09MX0RFQ09NX0NBTiAgICAgICAgICA6IENoYXJhY3RlcnMgdGhhdCBhcmUgY2Fub25pY2FsIHZhcmlhbnRzIGFjY29yZGluZyAKICAgICogdG8gVW5pY29kZSAyLjAgd2lsbCBiZSBkZWNvbXBvc2VkIGZvciBzb3J0aW5nLiAKICAgICogVUNPTF9ERUNPTVBfQ09NUEFUICAgIDogQ2hhcmFjdGVycyB0aGF0IGFyZSBjb21wYXRpYmlsaXR5IHZhcmlhbnRzIHdpbGwgYmUKICAgICogZGVjb21wb3NlZCBmb3Igc29ydGluZy4gVGhpcyBpcyB0aGUgZGVmYXVsdCBub3JtYWxpemF0aW9uIG1vZGUgdXNlZC4KICAgICogVUNPTF9ERUNPTVBfQ0FOX0NPTVBfQ09NUEFUIDogQ2Fub25pY2FsIGRlY29tcG9zaXRpb24gZm9sbG93ZWQgYnkgY2Fub25pY2FsIGNvbXBvc2l0aW9uIAogICAgKiBVQ09MX0RFQ09NUF9DT01QQVRfQ09NUF9DQU4gOiBDb21wYXRpYmlsaXR5IGRlY29tcG9zaXRpb24gZm9sbG93ZWQgYnkgY2Fub25pY2FsIGNvbXBvc2l0aW9uCiAgICAqCiAgICAqKi8KLyoqIFBvc3NpYmxlIGNvbGxhdGlvbiBub3JtYWxpemF0aW9uIG1vZGVzICovCmVudW0gVU5vcm1hbGl6YXRpb25Nb2RlIHsKICAvKiogTm8gZGVjb21wb3NpdGlvbi9jb21wb3NpdGlvbiAqLwogIFVDT0xfTk9fTk9STUFMSVpBVElPTiwKICAvKiogQ2Fub25pY2FsIGRlY29tcG9zaXRpb24gKi8KICBVQ09MX0RFQ09NUF9DQU4sCiAgLyoqIENvbXBhdGliaWxpdHkgZGVjb21wb3NpdGlvbiAqLwogIFVDT0xfREVDT01QX0NPTVBBVCwKICAvKiogQ2Fub25pY2FsIGRlY29tcG9zaXRpb24gZm9sbG93ZWQgYnkgY2Fub25pY2FsIGNvbXBvc2l0aW9uICovCiAgVUNPTF9ERUNPTVBfQ0FOX0NPTVBfQ09NUEFULAogIC8qKiBDb21wYXRpYmlsaXR5IGRlY29tcG9zaXRpb24gZm9sbG93ZWQgYnkgY2Fub25pY2FsIGNvbXBvc2l0aW9uICovCiAgVUNPTF9ERUNPTVBfQ09NUEFUX0NPTVBfQ0FOLAogIC8qKiBEZWZhdWx0IG5vcm1hbGl6YXRpb24gKi8KICBVQ09MX0RFRkFVTFRfTk9STUFMSVpBVElPTiA9IFVDT0xfREVDT01QX0NPTVBBVAp9Owp0eXBlZGVmIGVudW0gVU5vcm1hbGl6YXRpb25Nb2RlIFVOb3JtYWxpemF0aW9uTW9kZTsKCi8qKiBQb3NzaWJsZSBub3JtYWxpemF0aW9uIG9wdGlvbnMgKi8KZW51bSBVTm9ybWFsaXphdGlvbk9wdGlvbiB7CiAgLyoqIERvIG5vdCBub3JtYWxpemUgSGFuZ3VsICovCiAgVUNPTF9JR05PUkVfSEFOR1VMICAgID0gMQp9Owp0eXBlZGVmIGVudW0gVU5vcm1hbGl6YXRpb25PcHRpb24gVU5vcm1hbGl6YXRpb25PcHRpb247CiAgICAvKioKICAgICAqIEJhc2UgbGV0dGVyIHJlcHJlc2VudHMgYSBwcmltYXJ5IGRpZmZlcmVuY2UuICBTZXQgY29tcGFyaXNvbgogICAgICogbGV2ZWwgdG8gVUNPTF9QUklNQVJZIHRvIGlnbm9yZSBzZWNvbmRhcnkgYW5kIHRlcnRpYXJ5IGRpZmZlcmVuY2VzLgogICAgICogVXNlIHRoaXMgdG8gc2V0IHRoZSBzdHJlbmd0aCBvZiBhIENvbGxhdG9yIG9iamVjdC4KICAgICAqIEV4YW1wbGUgb2YgcHJpbWFyeSBkaWZmZXJlbmNlLCAiYWJjIiAmbHQ7ICJhYmQiCiAgICAgKiAKICAgICAqIERpYWNyaXRpY2FsIGRpZmZlcmVuY2VzIG9uIHRoZSBzYW1lIGJhc2UgbGV0dGVyIHJlcHJlc2VudCBhIHNlY29uZGFyeQogICAgICogZGlmZmVyZW5jZS4gIFNldCBjb21wYXJpc29uIGxldmVsIHRvIFVDT0xfU0VDT05EQVJZIHRvIGlnbm9yZSB0ZXJ0aWFyeQogICAgICogZGlmZmVyZW5jZXMuIFVzZSB0aGlzIHRvIHNldCB0aGUgc3RyZW5ndGggb2YgYSBDb2xsYXRvciBvYmplY3QuCiAgICAgKiBFeGFtcGxlIG9mIHNlY29uZGFyeSBkaWZmZXJlbmNlLCAi5CIgPj4gImEiLgogICAgICoKICAgICAqIFVwcGVyY2FzZSBhbmQgbG93ZXJjYXNlIHZlcnNpb25zIG9mIHRoZSBzYW1lIGNoYXJhY3RlciByZXByZXNlbnRzIGEKICAgICAqIHRlcnRpYXJ5IGRpZmZlcmVuY2UuICBTZXQgY29tcGFyaXNvbiBsZXZlbCB0byBVQ09MX1RFUlRJQVJZIHRvIGluY2x1ZGUKICAgICAqIGFsbCBjb21wYXJpc29uIGRpZmZlcmVuY2VzLiBVc2UgdGhpcyB0byBzZXQgdGhlIHN0cmVuZ3RoIG9mIGEgQ29sbGF0b3IKICAgICAqIG9iamVjdC4KICAgICAqIEV4YW1wbGUgb2YgdGVydGlhcnkgZGlmZmVyZW5jZSwgImFiYyIgJmx0OyZsdDsmbHQ7ICJBQkMiLgogICAgICoKICAgICAqIFR3byBjaGFyYWN0ZXJzIGFyZSBjb25zaWRlcmVkICJpZGVudGljYWwiIHdoZW4gdGhleSBoYXZlIHRoZSBzYW1lCiAgICAgKiB1bmljb2RlIHNwZWxsaW5ncy4gIFVDT0xfSURFTlRJQ0FMLgogICAgICogRm9yIGV4YW1wbGUsICLkIiA9PSAi5CIuCiAgICAgKgogICAgICogVUNvbGxhdGlvblN0cmVuZ3RoIGlzIGFsc28gdXNlZCB0byBkZXRlcm1pbmUgdGhlIHN0cmVuZ3RoIG9mIHNvcnQga2V5cyAKICAgICAqIGdlbmVyYXRlZCBmcm9tIFVDb2xsYXRvciBvYmplY3RzCiAgICAgKiovCi8qKiBQb3NzaWJsZSBjb2xsYXRpb24gc3RyZW5ndGhzICovCmVudW0gVUNvbGxhdGlvblN0cmVuZ3RoIHsKICAvKiogUHJpbWFyeSBjb2xsYXRpb24gc3RyZW5ndGggKi8KICBVQ09MX1BSSU1BUlkgPSAwLAogIC8qKiBTZWNvbmRhcnkgY29sbGF0aW9uIHN0cmVuZ3RoICovCiAgVUNPTF9TRUNPTkRBUlkgPSAxLAogIC8qKiBUZXJ0aWFyeSBjb2xsYXRpb24gc3RyZW5ndGggKi8KICBVQ09MX1RFUlRJQVJZID0gMiwKICAvKiogSWRlbnRpY2FsIGNvbGxhdGlvbiBzdHJlbmd0aCAqLwogIFVDT0xfSURFTlRJQ0FMID0gMywKICAvKiogRGVmYXVsdCBjb2xsYXRpb24gc3RyZW5ndGggKi8KICBVQ09MX0RFRkFVTFRfU1RSRU5HVEggPSBVQ09MX1RFUlRJQVJZCn0gOwp0eXBlZGVmIGVudW0gVUNvbGxhdGlvblN0cmVuZ3RoIFVDb2xsYXRpb25TdHJlbmd0aDsKCi8qPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQogICAgLS0tPiBNT1ZFIFNPTUVXSEVSRSBFTFNFICEhISA8LS0tCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0qLwovKioKICogQG5hbWUgVW5pY29kZSBub3JtYWxpemF0aW9uIEFQSQogKgogKiA8dHQ+dV9ub3JtYWxpemU8L3R0PiB0cmFuc2Zvcm1zIFVuaWNvZGUgdGV4dCBpbnRvIGFuIGVxdWl2YWxlbnQgY29tcG9zZWQgb3IKICogZGVjb21wb3NlZCBmb3JtLCBhbGxvd2luZyBmb3IgZWFzaWVyIHNvcnRpbmcgYW5kIHNlYXJjaGluZyBvZiB0ZXh0LgogKiA8dHQ+dV9ub3JtYWxpemU8L3R0PiBzdXBwb3J0cyB0aGUgc3RhbmRhcmQgbm9ybWFsaXphdGlvbiBmb3JtcyBkZXNjcmliZWQgaW4KICogPGEgaHJlZj0iaHR0cDovL3d3dy51bmljb2RlLm9yZy91bmljb2RlL3JlcG9ydHMvdHIxNS8iIHRhcmdldD0idW5pY29kZSI+CiAqIFVuaWNvZGUgVGVjaG5pY2FsIFJlcG9ydCAjMTU8L2E+LgogKiA8cD4KICogQ2hhcmFjdGVycyB3aXRoIGFjY2VudHMgb3Igb3RoZXIgYWRvcm5tZW50cyBjYW4gYmUgZW5jb2RlZCBpbgogKiBzZXZlcmFsIGRpZmZlcmVudCB3YXlzIGluIFVuaWNvZGUuICBGb3IgZXhhbXBsZSwgdGFrZSB0aGUgY2hhcmFjdGVyICLBIgogKiAoQS1hY3V0ZSkuICAgSW4gVW5pY29kZSwgdGhpcyBjYW4gYmUgZW5jb2RlZCBhcyBhIHNpbmdsZSBjaGFyYWN0ZXIgKHRoZQogKiAiY29tcG9zZWQiIGZvcm0pOgogKiA8cHJlPgogKiAgICAgIDAwQzEgICAgTEFUSU4gQ0FQSVRBTCBMRVRURVIgQSBXSVRIIEFDVVRFPC9wcmU+CiAqIG9yIGFzIHR3byBzZXBhcmF0ZSBjaGFyYWN0ZXJzICh0aGUgImRlY29tcG9zZWQiIGZvcm0pOgogKiA8cHJlPgogKiAgICAgIDAwNDEgICAgTEFUSU4gQ0FQSVRBTCBMRVRURVIgQQogKiAgICAgIDAzMDEgICAgQ09NQklOSU5HIEFDVVRFIEFDQ0VOVDwvcHJlPgogKiA8cD4KICogVG8gYSB1c2VyIG9mIHlvdXIgcHJvZ3JhbSwgaG93ZXZlciwgYm90aCBvZiB0aGVzZSBzZXF1ZW5jZXMgc2hvdWxkIGJlCiAqIHRyZWF0ZWQgYXMgdGhlIHNhbWUgInVzZXItbGV2ZWwiIGNoYXJhY3RlciAiwSIuICBXaGVuIHlvdSBhcmUgc2VhcmNoaW5nIG9yCiAqIGNvbXBhcmluZyB0ZXh0LCB5b3UgbXVzdCBlbnN1cmUgdGhhdCB0aGVzZSB0d28gc2VxdWVuY2VzIGFyZSB0cmVhdGVkIAogKiBlcXVpdmFsZW50bHkuICBJbiBhZGRpdGlvbiwgeW91IG11c3QgaGFuZGxlIGNoYXJhY3RlcnMgd2l0aCBtb3JlIHRoYW4gb25lCiAqIGFjY2VudC4gIFNvbWV0aW1lcyB0aGUgb3JkZXIgb2YgYSBjaGFyYWN0ZXIncyBjb21iaW5pbmcgYWNjZW50cyBpcwogKiBzaWduaWZpY2FudCwgd2hpbGUgaW4gb3RoZXIgY2FzZXMgYWNjZW50IHNlcXVlbmNlcyBpbiBkaWZmZXJlbnQgb3JkZXJzIGFyZQogKiByZWFsbHkgZXF1aXZhbGVudC4KICogPHA+CiAqIFNpbWlsYXJseSwgdGhlIHN0cmluZyAiZmZpIiBjYW4gYmUgZW5jb2RlZCBhcyB0aHJlZSBzZXBhcmF0ZSBsZXR0ZXJzOgogKiA8cHJlPgogKiAgICAgIDAwNjYgICAgTEFUSU4gU01BTEwgTEVUVEVSIEYKICogICAgICAwMDY2ICAgIExBVElOIFNNQUxMIExFVFRFUiBGCiAqICAgICAgMDA2OSAgICBMQVRJTiBTTUFMTCBMRVRURVIgSTwvcHJlPgogKiBvciBhcyB0aGUgc2luZ2xlIGNoYXJhY3RlcgogKiA8cHJlPgogKiAgICAgIEZCMDMgICAgTEFUSU4gU01BTEwgTElHQVRVUkUgRkZJPC9wcmU+CiAqIDxwPgogKiBUaGUgZmZpIGxpZ2F0dXJlIGlzIG5vdCBhIGRpc3RpbmN0IHNlbWFudGljIGNoYXJhY3RlciwgYW5kIHN0cmljdGx5IHNwZWFraW5nCiAqIGl0IHNob3VsZG4ndCBiZSBpbiBVbmljb2RlIGF0IGFsbCwgYnV0IGl0IHdhcyBpbmNsdWRlZCBmb3IgY29tcGF0aWJpbGl0eQogKiB3aXRoIGV4aXN0aW5nIGNoYXJhY3RlciBzZXRzIHRoYXQgYWxyZWFkeSBwcm92aWRlZCBpdC4gIFRoZSBVbmljb2RlIHN0YW5kYXJkCiAqIGlkZW50aWZpZXMgc3VjaCBjaGFyYWN0ZXJzIGJ5IGdpdmluZyB0aGVtICJjb21wYXRpYmlsaXR5IiBkZWNvbXBvc2l0aW9ucwogKiBpbnRvIHRoZSBjb3JyZXNwb25kaW5nIHNlbWFudGljIGNoYXJhY3RlcnMuICBXaGVuIHNvcnRpbmcgYW5kIHNlYXJjaGluZywgeW91CiAqIHdpbGwgb2Z0ZW4gd2FudCB0byB1c2UgdGhlc2UgbWFwcGluZ3MuCiAqIDxwPgogKiA8dHQ+dV9ub3JtYWxpemU8L3R0PiBoZWxwcyBzb2x2ZSB0aGVzZSBwcm9ibGVtcyBieSB0cmFuc2Zvcm1pbmcgdGV4dCBpbnRvIHRoZQogKiBjYW5vbmljYWwgY29tcG9zZWQgYW5kIGRlY29tcG9zZWQgZm9ybXMgYXMgc2hvd24gaW4gdGhlIGZpcnN0IGV4YW1wbGUgYWJvdmUuICAKICogSW4gYWRkaXRpb24sIHlvdSBjYW4gaGF2ZSBpdCBwZXJmb3JtIGNvbXBhdGliaWxpdHkgZGVjb21wb3NpdGlvbnMgc28gdGhhdCAKICogeW91IGNhbiB0cmVhdCBjb21wYXRpYmlsaXR5IGNoYXJhY3RlcnMgdGhlIHNhbWUgYXMgdGhlaXIgZXF1aXZhbGVudHMuCiAqIEZpbmFsbHksIDx0dD51X25vcm1hbGl6ZTwvdHQ+IHJlYXJyYW5nZXMgYWNjZW50cyBpbnRvIHRoZSBwcm9wZXIgY2Fub25pY2FsCiAqIG9yZGVyLCBzbyB0aGF0IHlvdSBkbyBub3QgaGF2ZSB0byB3b3JyeSBhYm91dCBhY2NlbnQgcmVhcnJhbmdlbWVudCBvbiB5b3VyCiAqIG93bi4KICogPHA+CiAqIDx0dD51X25vcm1hbGl6ZTwvdHQ+IGFkZHMgb25lIG9wdGlvbmFsIGJlaGF2aW9yLCB7QGxpbmsgI1VDT0xfSUdOT1JFX0hBTkdVTH0sCiAqIHRoYXQgZGlmZmVycyBmcm9tCiAqIHRoZSBzdGFuZGFyZCBVbmljb2RlIE5vcm1hbGl6YXRpb24gRm9ybXMuIAogKiovCiAKIAovKioKICogTm9ybWFsaXplIGEgc3RyaW5nLgogKiBUaGUgc3RyaW5nIHdpbGwgYmUgbm9ybWFsaXplZCBhY2NvcmRpbmcgdGhlIHRoZSBzcGVjaWZpZWQgbm9ybWFsaXphdGlvbiBtb2RlCiAqIGFuZCBvcHRpb25zLgogKiBAcGFyYW0gc291cmNlIFRoZSBzdHJpbmcgdG8gbm9ybWFsaXplLgogKiBAcGFyYW0gc291cmNlTGVuZ3RoIFRoZSBsZW5ndGggb2Ygc291cmNlLCBvciAtMSBpZiBudWxsLXRlcm1pbmF0ZWQuCiAqIEBwYXJhbSBtb2RlIFRoZSBub3JtYWxpemF0aW9uIG1vZGU7IG9uZSBvZiBVQ09MX05PX05PUk1BTElaQVRJT04sIAogKiBVQ09MX0NBTl9ERUNPTVAsIFVDT0xfQ09NUEFUX0RFQ09NUCwgVUNPTF9DQU5fREVDT01QX0NPTVBBVF9DT01QLCAKICogVUNPTF9DT01QQVRfREVDT01QX0NBTl9DT01QLCBVQ09MX0RFRkFVTFRfTk9STUFMSVpBVElPTgogKiBAcGFyYW0gb3B0aW9ucyBUaGUgbm9ybWFsaXphdGlvbiBvcHRpb25zLCBPUmVkIHRvZ2V0aGVyOyBwb3NzaWJsZSB2YWx1ZXMKICogYXJlIFVDT0xfSUdOT1JFX0hBTkdVTAogKiBAcGFyYW0gcmVzdWx0IEEgcG9pbnRlciB0byBhIGJ1ZmZlciB0byByZWNlaXZlIHRoZSBhdHRyaWJ1dGUuCiAqIEBwYXJhbSByZXN1bHRMZW5ndGggVGhlIG1heGltdW0gc2l6ZSBvZiByZXN1bHQuCiAqIEBwYXJhbSBzdGF0dXMgQSBwb2ludGVyIHRvIGFuIFVFcnJvckNvZGUgdG8gcmVjZWl2ZSBhbnkgZXJyb3JzCiAqIEByZXR1cm4gVGhlIHRvdGFsIGJ1ZmZlciBzaXplIG5lZWRlZDsgaWYgZ3JlYXRlciB0aGFuIHJlc3VsdExlbmd0aCwKICogdGhlIG91dHB1dCB3YXMgdHJ1bmNhdGVkLgogKiBAc3RhYmxlCiAqLwpVX0NBUEkgaW50MzJfdAp1X25vcm1hbGl6ZShjb25zdCBVQ2hhciogICAgICAgICAgIHNvdXJjZSwKICAgICAgICBpbnQzMl90ICAgICAgICAgICAgICAgICBzb3VyY2VMZW5ndGgsIAogICAgICAgIFVOb3JtYWxpemF0aW9uTW9kZSAgICAgIG1vZGUsIAogICAgICAgIGludDMyX3QgICAgICAgICAgICBvcHRpb25zLAogICAgICAgIFVDaGFyKiAgICAgICAgICAgICAgICAgIHJlc3VsdCwKICAgICAgICBpbnQzMl90ICAgICAgICAgICAgICAgICByZXN1bHRMZW5ndGgsCiAgICAgICAgVUVycm9yQ29kZSogICAgICAgICAgICAgc3RhdHVzKTsgICAgCgovKioKICogT3BlbiBhIFVDb2xsYXRvciBmb3IgY29tcGFyaW5nIHN0cmluZ3MuCiAqIFRoZSBVQ29sbGF0b3IgbWF5IGJlIHVzZWQgaW4gY2FsbHMgdG8gXFJlZnt1Y29sX3N0cmNvbGx9LgogKiBAcGFyYW0gbG9jIFRoZSBsb2NhbGUgY29udGFpbmluZyB0aGUgY29tcGFyaXNvbiBjb252ZW50aW9ucy4KICogQHBhcmFtIHN0YXR1cyBBIHBvaW50ZXIgdG8gYW4gVUVycm9yQ29kZSB0byByZWNlaXZlIGFueSBlcnJvcnMKICogQHJldHVybiBBIHBvaW50ZXIgdG8gYSBVQ29sbGF0b3IsIG9yIDAgaWYgYW4gZXJyb3Igb2NjdXJyZWQuCiAqIEBzZWUgdWNvbF9vcGVuUnVsZXMKICogQHN0YWJsZQogKi8KVV9DQVBJIFVDb2xsYXRvcioKdWNvbF9vcGVuKCAgICBjb25zdCAgICBjaGFyICAgICAgICAgKmxvYywKICAgICAgICBVRXJyb3JDb2RlICAgICAgKnN0YXR1cyk7CgovKioKICogT3BlbiBhIFVDb2xsYXRvciBmb3IgY29tcGFyaW5nIHN0cmluZ3MuCiAqIFRoZSBVQ29sbGF0b3IgbWF5IGJlIHVzZWQgaW4gY2FsbHMgdG8gXFJlZnt1Y29sX3N0cmNvbGx9LgogKiBAcGFyYW0gcnVsZXMgQSBzdHJpbmcgZGVzY3JpYmluZyB0aGUgY29sbGF0aW9uIHJ1bGVzLgogKiBAcGFyYW0gcnVsZXNMZW5ndGggVGhlIGxlbmd0aCBvZiBydWxlcywgb3IgLTEgaWYgbnVsbC10ZXJtaW5hdGVkLgogKiBAcGFyYW0gbW9kZSBUaGUgbm9ybWFsaXphdGlvbiBtb2RlOyBvbmUgb2YgVUNPTF9OT19OT1JNQUxJWkFUSU9OLAogKiBVQ09MX0NBTl9ERUNPTVAsIFVDT0xfQ09NUEFUX0RFQ09NUCwgVUNPTF9DQU5fREVDT01QX0NPTVBBVF9DT01QLAogKiBVQ09MX0NPTVBBVF9ERUNPTVBfQ0FOX0NPTVAsIFVDT0xfREVGQVVMVF9OT1JNQUxJWkFUSU9OCiAqIEBwYXJhbSBzdHJlbmd0aCBUaGUgY29sbGF0aW9uIHN0cmVuZ3RoOyBvbmUgb2YgVUNPTF9QUklNQVJZLCBVQ09MX1NFQ09OREFSWSwKICogVUNPTF9URVJUSUFSWSwgVUNPTF9JREVOVElDQUwsVUNPTF9ERUZBVUxUX1NUUkVOR1RICiAqIEBwYXJhbSBzdGF0dXMgQSBwb2ludGVyIHRvIGFuIFVFcnJvckNvZGUgdG8gcmVjZWl2ZSBhbnkgZXJyb3JzCiAqIEByZXR1cm4gQSBwb2ludGVyIHRvIGEgVUNvbGxhdG9yLCBvciAwIGlmIGFuIGVycm9yIG9jY3VycmVkLgogKiBAc2VlIHVjb2xfb3BlbgogKiBAc3RhYmxlCiAqLwpVX0NBUEkgVUNvbGxhdG9yKgp1Y29sX29wZW5SdWxlcyggICAgY29uc3QgICAgVUNoYXIgICAgICAgICpydWxlcywKICAgICAgICBpbnQzMl90ICAgICAgICAgICAgICAgICBydWxlc0xlbmd0aCwKICAgICAgICBVTm9ybWFsaXphdGlvbk1vZGUgICAgICBtb2RlLAogICAgICAgIFVDb2xsYXRpb25TdHJlbmd0aCAgICAgIHN0cmVuZ3RoLAogICAgICAgIFVFcnJvckNvZGUgICAgICAgICAgICAgICpzdGF0dXMpOwoKLyoqIAogKiBDbG9zZSBhIFVDb2xsYXRvci4KICogT25jZSBjbG9zZWQsIGEgVUNvbGxhdG9yIHNob3VsZCBub3QgYmUgdXNlZC4KICogQHBhcmFtIGNvbGwgVGhlIFVDb2xsYXRvciB0byBjbG9zZS4KICogQHN0YWJsZQogKi8KVV9DQVBJIHZvaWQKdWNvbF9jbG9zZShVQ29sbGF0b3IgKmNvbGwpOwoKLyoqCiAqIENvbXBhcmUgdHdvIHN0cmluZ3MuCiAqIFRoZSBzdHJpbmdzIHdpbGwgYmUgY29tcGFyZWQgdXNpbmcgdGhlIG5vcm1hbGl6YXRpb24gbW9kZSBhbmQgb3B0aW9ucwogKiBzcGVjaWZpZWQgaW4gXFJlZnt1Y29sX29wZW59IG9yIFxSZWZ7dWNvbF9vcGVuUnVsZXN9CiAqIEBwYXJhbSBjb2xsIFRoZSBVQ29sbGF0b3IgY29udGFpbmluZyB0aGUgY29tcGFyaXNvbiBydWxlcy4KICogQHBhcmFtIHNvdXJjZSBUaGUgc291cmNlIHN0cmluZy4KICogQHBhcmFtIHNvdXJjZUxlbmd0aCBUaGUgbGVuZ3RoIG9mIHNvdXJjZSwgb3IgLTEgaWYgbnVsbC10ZXJtaW5hdGVkLgogKiBAcGFyYW0gdGFyZ2V0IFRoZSB0YXJnZXQgc3RyaW5nLgogKiBAcGFyYW0gdGFyZ2V0TGVuZ3RoIFRoZSBsZW5ndGggb2YgdGFyZ2V0LCBvciAtMSBpZiBudWxsLXRlcm1pbmF0ZWQuCiAqIEByZXR1cm4gVGhlIHJlc3VsdCBvZiBjb21wYXJpbmcgdGhlIHN0cmluZ3M7IG9uZSBvZiBVQ09MX0VRVUFMLAogKiBVQ09MX0dSRUFURVIsIFVDT0xfTEVTUwogKiBAc2VlIHVjb2xfZ3JlYXRlcgogKiBAc2VlIHVjb2xfZ3JlYXRlck9yRXF1YWwKICogQHNlZSB1Y29sX2VxdWFsCiAqIEBzdGFibGUKICovClVfQ0FQSSBVQ29sbGF0aW9uUmVzdWx0CnVjb2xfc3RyY29sbCggICAgY29uc3QgICAgVUNvbGxhdG9yICAgICpjb2xsLAogICAgICAgIGNvbnN0ICAgIFVDaGFyICAgICAgICAqc291cmNlLAogICAgICAgIGludDMyX3QgICAgICAgICAgICBzb3VyY2VMZW5ndGgsCiAgICAgICAgY29uc3QgICAgVUNoYXIgICAgICAgICp0YXJnZXQsCiAgICAgICAgaW50MzJfdCAgICAgICAgICAgIHRhcmdldExlbmd0aCk7CgovKioKICogRGV0ZXJtaW5lIGlmIG9uZSBzdHJpbmcgaXMgZ3JlYXRlciB0aGFuIGFub3RoZXIuCiAqIFRoaXMgZnVuY3Rpb24gaXMgZXF1aXZhbGVudCB0byBcUmVme3Vjb2xfc3RyY29sbH0gPT0gVUNPTF9HUkVBVEVSCiAqIEBwYXJhbSBjb2xsIFRoZSBVQ29sbGF0b3IgY29udGFpbmluZyB0aGUgY29tcGFyaXNvbiBydWxlcy4KICogQHBhcmFtIHNvdXJjZSBUaGUgc291cmNlIHN0cmluZy4KICogQHBhcmFtIHNvdXJjZUxlbmd0aCBUaGUgbGVuZ3RoIG9mIHNvdXJjZSwgb3IgLTEgaWYgbnVsbC10ZXJtaW5hdGVkLgogKiBAcGFyYW0gdGFyZ2V0IFRoZSB0YXJnZXQgc3RyaW5nLgogKiBAcGFyYW0gdGFyZ2V0TGVuZ3RoIFRoZSBsZW5ndGggb2YgdGFyZ2V0LCBvciAtMSBpZiBudWxsLXRlcm1pbmF0ZWQuCiAqIEByZXR1cm4gVFJVRSBpZiBzb3VyY2UgaXMgZ3JlYXRlciB0aGFuIHRhcmdldCwgRkFMU0Ugb3RoZXJ3aXNlLgogKiBAc2VlIHVjb2xfc3RyY29sbAogKiBAc2VlIHVjb2xfZ3JlYXRlck9yRXF1YWwKICogQHNlZSB1Y29sX2VxdWFsCiAqIEBzdGFibGUKICovClVfQ0FQSSBib29sX3QKdWNvbF9ncmVhdGVyKCAgICBjb25zdCAgICBVQ29sbGF0b3IgICAgKmNvbGwsCiAgICAgICAgY29uc3QgICAgVUNoYXIgICAgICAgICpzb3VyY2UsCiAgICAgICAgaW50MzJfdCAgICAgICAgICAgIHNvdXJjZUxlbmd0aCwKICAgICAgICBjb25zdCAgICBVQ2hhciAgICAgICAgKnRhcmdldCwKICAgICAgICBpbnQzMl90ICAgICAgICAgICAgdGFyZ2V0TGVuZ3RoKTsKCi8qKgogKiBEZXRlcm1pbmUgaWYgb25lIHN0cmluZyBpcyBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gYW5vdGhlci4KICogVGhpcyBmdW5jdGlvbiBpcyBlcXVpdmFsZW50IHRvIFxSZWZ7dWNvbF9zdHJjb2xsfSAhPSBVQ09MX0xFU1MKICogQHBhcmFtIGNvbGwgVGhlIFVDb2xsYXRvciBjb250YWluaW5nIHRoZSBjb21wYXJpc29uIHJ1bGVzLgogKiBAcGFyYW0gc291cmNlIFRoZSBzb3VyY2Ugc3RyaW5nLgogKiBAcGFyYW0gc291cmNlTGVuZ3RoIFRoZSBsZW5ndGggb2Ygc291cmNlLCBvciAtMSBpZiBudWxsLXRlcm1pbmF0ZWQuCiAqIEBwYXJhbSB0YXJnZXQgVGhlIHRhcmdldCBzdHJpbmcuCiAqIEBwYXJhbSB0YXJnZXRMZW5ndGggVGhlIGxlbmd0aCBvZiB0YXJnZXQsIG9yIC0xIGlmIG51bGwtdGVybWluYXRlZC4KICogQHJldHVybiBUUlVFIGlmIHNvdXJjZSBpcyBncmVhdGVyIHRoYW4gb3IgZXF1YWwgdG8gdGFyZ2V0LCBGQUxTRSBvdGhlcndpc2UuCiAqIEBzZWUgdWNvbF9zdHJjb2xsCiAqIEBzZWUgdWNvbF9ncmVhdGVyCiAqIEBzZWUgdWNvbF9lcXVhbAogKiBAc3RhYmxlCiAqLwpVX0NBUEkgYm9vbF90CnVjb2xfZ3JlYXRlck9yRXF1YWwoICAgIGNvbnN0ICAgIFVDb2xsYXRvciAgICAqY29sbCwKICAgICAgICAgICAgY29uc3QgICAgVUNoYXIgICAgICAgICpzb3VyY2UsCiAgICAgICAgICAgIGludDMyX3QgICAgICAgICAgICBzb3VyY2VMZW5ndGgsCiAgICAgICAgICAgIGNvbnN0ICAgIFVDaGFyICAgICAgICAqdGFyZ2V0LAogICAgICAgICAgICBpbnQzMl90ICAgICAgICAgICAgdGFyZ2V0TGVuZ3RoKTsKCi8qKgogKiBDb21wYXJlIHR3byBzdHJpbmdzIGZvciBlcXVhbGl0eS4KICogVGhpcyBmdW5jdGlvbiBpcyBlcXVpdmFsZW50IHRvIFxSZWZ7dWNvbF9zdHJjb2xsfSA9PSBVQ09MX0VRVUFMCiAqIEBwYXJhbSBjb2xsIFRoZSBVQ29sbGF0b3IgY29udGFpbmluZyB0aGUgY29tcGFyaXNvbiBydWxlcy4KICogQHBhcmFtIHNvdXJjZSBUaGUgc291cmNlIHN0cmluZy4KICogQHBhcmFtIHNvdXJjZUxlbmd0aCBUaGUgbGVuZ3RoIG9mIHNvdXJjZSwgb3IgLTEgaWYgbnVsbC10ZXJtaW5hdGVkLgogKiBAcGFyYW0gdGFyZ2V0IFRoZSB0YXJnZXQgc3RyaW5nLgogKiBAcGFyYW0gdGFyZ2V0TGVuZ3RoIFRoZSBsZW5ndGggb2YgdGFyZ2V0LCBvciAtMSBpZiBudWxsLXRlcm1pbmF0ZWQuCiAqIEByZXR1cm4gVFJVRSBpZiBzb3VyY2UgaXMgZXF1YWwgdG8gdGFyZ2V0LCBGQUxTRSBvdGhlcndpc2UKICogQHNlZSB1Y29sX3N0cmNvbGwKICogQHNlZSB1Y29sX2dyZWF0ZXIKICogQHNlZSB1Y29sX2dyZWF0ZXJPckVxdWFsCiAqIEBzdGFibGUKICovClVfQ0FQSSBib29sX3QKdWNvbF9lcXVhbCggICAgY29uc3QgICAgVUNvbGxhdG9yICAgICpjb2xsLAogICAgICAgIGNvbnN0ICAgIFVDaGFyICAgICAgICAqc291cmNlLAogICAgICAgIGludDMyX3QgICAgICAgICAgICBzb3VyY2VMZW5ndGgsCiAgICAgICAgY29uc3QgICAgVUNoYXIgICAgICAgICp0YXJnZXQsCiAgICAgICAgaW50MzJfdCAgICAgICAgICAgIHRhcmdldExlbmd0aCk7CgovKioKICogR2V0IHRoZSBjb2xsYXRpb24gc3RyZW5ndGggdXNlZCBpbiBhIFVDb2xsYXRvci4KICogVGhlIHN0cmVuZ3RoIGluZmx1ZW5jZXMgaG93IHN0cmluZ3MgYXJlIGNvbXBhcmVkLgogKiBAcGFyYW0gY29sbCBUaGUgVUNvbGxhdG9yIHRvIHF1ZXJ5LgogKiBAcmV0dXJuIFRoZSBjb2xsYXRpb24gc3RyZW5ndGg7IG9uZSBvZiBVQ09MX1BSSU1BUlksIFVDT0xfU0VDT05EQVJZLAogKiBVQ09MX1RFUlRJQVJZLCBVQ09MX0lERU5USUNBTCwgVUNPTF9ERUZBVUxUX1NUUkVOR1RICiAqIEBzZWUgdWNvbF9zZXRTdHJlbmd0aAogKiBAc3RhYmxlCiAqLwpVX0NBUEkgVUNvbGxhdGlvblN0cmVuZ3RoCnVjb2xfZ2V0U3RyZW5ndGgoY29uc3QgVUNvbGxhdG9yICpjb2xsKTsKCi8qKgogKiBTZXQgdGhlIGNvbGxhdGlvbiBzdHJlbmd0aCB1c2VkIGluIGEgVUNvbGxhdG9yLgogKiBUaGUgc3RyZW5ndGggaW5mbHVlbmNlcyBob3cgc3RyaW5ncyBhcmUgY29tcGFyZWQuCiAqIDxwPkV4YW1wbGUgb2YgdXNlOgogKiA8cHJlPgogKiAuICAgICAgIFVDb2xsYXRpb25SZXN1bHQgcmVzdWx0OwogKiAuICAgICAgIFVDaGFyICpzb3VyY2UsICp0YXJnZXQ7CiAqIC4gICAgICAgVUVycm9yQ29kZSBzdGF0dXMgPSBVX1pFUk9fRVJST1I7CiAqIC4gICAgICAgVUNvbGxhdG9yICpteUNvbGxhdGlvbiA9IHVjb2xfb3BlbigiZW5fVVMiLCBzdGF0dXMpOwogKiAuICAgICAgIGlmIChVX0ZBSUxVUkUoJnN0YXR1cykpIHJldHVybjsKICogLiAgICAgICB1Y29sX3NldFN0cmVuZ3RoKG15Q29sbGF0aW9uLCBVQ09MX1BSSU1BUlkpOwogKiAuICAgICAgIHVfdWFzdHJjcHkoc291cmNlLCAiYWJjIik7CiAqIC4gICAgICAgdV91YXN0cmNweSh0YXJnZXQsICJBQkMiKTsKICogLiAgICAgICAvLyByZXN1bHQgd2lsbCBiZSAiYWJjIiA9PSAiQUJDIgogKiAuICAgICAgIC8vIHRlcnRpYXJ5IGRpZmZlcmVuY2VzIHdpbGwgYmUgaWdub3JlZAogKiAuICAgICAgIHJlc3VsdCA9IHVjb2xfc3RyY29sbChteUNvbGxhdGlvbiwgc291cmNlLCB1X3N0cmxlbihzb3VyY2UpLCB0YXJnZXQsIHVfc3RybGVuKHRhcmdldCkpOwogKiA8L3ByZT4KICogQHBhcmFtIGNvbGwgVGhlIFVDb2xsYXRvciB0byBzZXQuCiAqIEBwYXJhbSBzdHJlbmd0aCBUaGUgZGVzaXJlZCBjb2xsYXRpb24gc3RyZW5ndGg7IG9uZSBvZiBVQ09MX1BSSU1BUlksIAogKiBVQ09MX1NFQ09OREFSWSwgVUNPTF9URVJUSUFSWSwgVUNPTF9JREVOVElDQUwsIFVDT0xfREVGQVVMVF9TVFJFTkdUSAogKiBAc2VlIHVjb2xfZ2V0U3RyZW5ndGgKICogQHN0YWJsZQogKi8KVV9DQVBJIHZvaWQKdWNvbF9zZXRTdHJlbmd0aCggICAgVUNvbGxhdG9yICAgICAgICAgICAgKmNvbGwsCiAgICAgICAgICAgIFVDb2xsYXRpb25TdHJlbmd0aCAgICAgICAgc3RyZW5ndGgpOwoKLyoqCiAqIEdldCB0aGUgbm9ybWFsaXphdGlvbiBtb2RlIHVzZWQgaW4gYSBVQ29sbGF0b3IuCiAqIFRoZSBub3JtYWxpemF0aW9uIG1vZGUgaW5mbHVlbmNlcyBob3cgc3RyaW5ncyBhcmUgY29tcGFyZWQuCiAqIEBwYXJhbSBjb2xsIFRoZSBVQ29sbGF0b3IgdG8gcXVlcnkuCiAqIEByZXR1cm4gVGhlIG5vcm1hbGl6YXRpb24gbW9kZTsgb25lIG9mIFVDT0xfTk9fTk9STUFMSVpBVElPTiwgCiAqIFVDT0xfQ0FOX0RFQ09NUCwgVUNPTF9DT01QQVRfREVDT01QLCBVQ09MX0NBTl9ERUNPTVBfQ09NUEFUX0NPTVAsCiAqIFVDT0xfQ09NUEFUX0RFQ09NUF9DQU5fQ09NUCwgVUNPTF9ERUZBVUxUX05PUk1BTElaQVRJT04KICogQHNlZSB1Y29sX3NldE5vcm1hbGl6YXRpb24KICogQHN0YWJsZQogKi8KVV9DQVBJIFVOb3JtYWxpemF0aW9uTW9kZQp1Y29sX2dldE5vcm1hbGl6YXRpb24oY29uc3QgVUNvbGxhdG9yKiBjb2xsKTsKCi8qKgogKiBTZXQgdGhlIG5vcm1hbGl6YXRpb24gbW9kZSB1c2VkIGluIGEgVUNvbGxhdG9yLgogKiBUaGUgbm9ybWFsaXphdGlvbiBtb2RlIGluZmx1ZW5jZXMgaG93IHN0cmluZ3MgYXJlIGNvbXBhcmVkLgogKiBAcGFyYW0gY29sbCBUaGUgVUNvbGxhdG9yIHRvIHNldC4KICogQHBhcmFtIG1vZGUgVGhlIGRlc2lyZWQgbm9ybWFsaXphdGlvbiBtb2RlOyBvbmUgb2YgVUNPTF9OT19OT1JNQUxJWkFUSU9OLAogKiBVQ09MX0NBTl9ERUNPTVAsIFVDT0xfQ09NUEFUX0RFQ09NUCwgVUNPTF9DQU5fREVDT01QX0NPTVBBVF9DT01QLCAKICogVUNPTF9DT01QQVRfREVDT01QX0NBTl9DT01QLCBVQ09MX0RFRkFVTFRfTk9STUFMSVpBVElPTgogKiBAc2VlIHVjb2xfZ2V0Tm9ybWFsaXphdGlvbgogKiBAc3RhYmxlCiAqLwpVX0NBUEkgdm9pZAp1Y29sX3NldE5vcm1hbGl6YXRpb24oICBVQ29sbGF0b3IgICAgICAgICpjb2xsLAogICAgICAgICAgICBVTm9ybWFsaXphdGlvbk1vZGUgICAgbW9kZSk7CgovKioKICogR2V0IHRoZSBkaXNwbGF5IG5hbWUgZm9yIGEgVUNvbGxhdG9yLgogKiBUaGUgZGlzcGxheSBuYW1lIGlzIHN1aXRhYmxlIGZvciBwcmVzZW50YXRpb24gdG8gYSB1c2VyLgogKiBAcGFyYW0gb2JqTG9jIFRoZSBsb2NhbGUgb2YgdGhlIGNvbGxhdG9yIGluIHF1ZXN0aW9uLgogKiBAcGFyYW0gZGlzcExvYyBUaGUgbG9jYWxlIGZvciBkaXNwbGF5LgogKiBAcGFyYW0gcmVzdWx0IEEgcG9pbnRlciB0byBhIGJ1ZmZlciB0byByZWNlaXZlIHRoZSBhdHRyaWJ1dGUuCiAqIEBwYXJhbSByZXN1bHRMZW5ndGggVGhlIG1heGltdW0gc2l6ZSBvZiByZXN1bHQuCiAqIEBwYXJhbSBzdGF0dXMgQSBwb2ludGVyIHRvIGFuIFVFcnJvckNvZGUgdG8gcmVjZWl2ZSBhbnkgZXJyb3JzCiAqIEByZXR1cm4gVGhlIHRvdGFsIGJ1ZmZlciBzaXplIG5lZWRlZDsgaWYgZ3JlYXRlciB0aGFuIHJlc3VsdExlbmd0aCwKICogdGhlIG91dHB1dCB3YXMgdHJ1bmNhdGVkLgogKiBAc3RhYmxlCiAqLwpVX0NBUEkgaW50MzJfdAp1Y29sX2dldERpc3BsYXlOYW1lKCAgICBjb25zdCAgICBjaGFyICAgICAgICAqb2JqTG9jLAogICAgICAgICAgICBjb25zdCAgICBjaGFyICAgICAgICAqZGlzcExvYywKICAgICAgICAgICAgVUNoYXIgICAgICAgICAgICAgKnJlc3VsdCwKICAgICAgICAgICAgaW50MzJfdCAgICAgICAgIHJlc3VsdExlbmd0aCwKICAgICAgICAgICAgVUVycm9yQ29kZSAgICAgICAgKnN0YXR1cyk7CgovKioKICogR2V0IGEgbG9jYWxlIGZvciB3aGljaCBjb2xsYXRpb24gcnVsZXMgYXJlIGF2YWlsYWJsZS4KICogQSBVQ29sbGF0b3IgaW4gYSBsb2NhbGUgcmV0dXJuZWQgYnkgdGhpcyBmdW5jdGlvbiB3aWxsIHBlcmZvcm0gdGhlIGNvcnJlY3QKICogY29sbGF0aW9uIGZvciB0aGUgbG9jYWxlLgogKiBAcGFyYW0gaW5kZXggVGhlIGluZGV4IG9mIHRoZSBkZXNpcmVkIGxvY2FsZS4KICogQHJldHVybiBBIGxvY2FsZSBmb3Igd2hpY2ggY29sbGF0aW9uIHJ1bGVzIGFyZSBhdmFpbGFibGUsIG9yIDAgaWYgbm9uZS4KICogQHNlZSB1Y29sX2NvdW50QXZhaWxhYmxlCiAqIEBzdGFibGUKICovClVfQ0FQSSBjb25zdCBjaGFyKgp1Y29sX2dldEF2YWlsYWJsZShpbnQzMl90IGluZGV4KTsKCi8qKgogKiBEZXRlcm1pbmUgaG93IG1hbnkgbG9jYWxlcyBoYXZlIGNvbGxhdGlvbiBydWxlcyBhdmFpbGFibGUuCiAqIFRoaXMgZnVuY3Rpb24gaXMgbW9zdCB1c2VmdWwgYXMgZGV0ZXJtaW5pbmcgdGhlIGxvb3AgZW5kaW5nIGNvbmRpdGlvbiBmb3IKICogY2FsbHMgdG8gXFJlZnt1Y29sX2dldEF2YWlsYWJsZX0uCiAqIEByZXR1cm4gVGhlIG51bWJlciBvZiBsb2NhbGVzIGZvciB3aGljaCBjb2xsYXRpb24gcnVsZXMgYXJlIGF2YWlsYWJsZS4KICogQHNlZSB1Y29sX2dldEF2YWlsYWJsZQogKiBAc3RhYmxlCiAqLwpVX0NBUEkgaW50MzJfdAp1Y29sX2NvdW50QXZhaWxhYmxlKHZvaWQpOwoKLyoqCiAqIEdldCB0aGUgY29sbGF0aW9uIHJ1bGVzIGZyb20gYSBVQ29sbGF0b3IuCiAqIFRoZSBydWxlcyB3aWxsIGZvbGxvdyB0aGUgcnVsZSBzeW50YXguCiAqIEBwYXJhbSBjb2xsIFRoZSBVQ29sbGF0b3IgdG8gcXVlcnkuCiAqIEBwYXJhbSBsZW5ndGggCiAqIEByZXR1cm4gVGhlIGNvbGxhdGlvbiBydWxlcy4KICogQHN0YWJsZQogKi8KVV9DQVBJIGNvbnN0IFVDaGFyKgp1Y29sX2dldFJ1bGVzKCAgICBjb25zdCAgICBVQ29sbGF0b3IgICAgKmNvbGwsIAogICAgICAgIGludDMyX3QgICAgICAgICAgICAqbGVuZ3RoKTsKCi8qKgogKiBHZXQgYSBzb3J0IGtleSBmb3IgYSBzdHJpbmcgZnJvbSBhIFVDb2xsYXRvci4KICogU29ydCBrZXlzIG1heSBiZSBjb21wYXJlZCB1c2luZyA8VFQ+bWVtY21wPC9UVD4uCiAqIEBwYXJhbSBjb2xsIFRoZSBVQ29sbGF0b3IgY29udGFpbmluZyB0aGUgY29sbGF0aW9uIHJ1bGVzLgogKiBAcGFyYW0gc291cmNlIFRoZSBzdHJpbmcgdG8gdHJhbnNmb3JtLgogKiBAcGFyYW0gc291cmVjTGVuZ3RoIFRoZSBsZW5ndGggb2Ygc291cmNlLCBvciAtMSBpZiBudWxsLXRlcm1pbmF0ZWQuCiAqIEBwYXJhbSByZXN1bHQgQSBwb2ludGVyIHRvIGEgYnVmZmVyIHRvIHJlY2VpdmUgdGhlIGF0dHJpYnV0ZS4KICogQHBhcmFtIHJlc3VsdExlbmd0aCBUaGUgbWF4aW11bSBzaXplIG9mIHJlc3VsdC4KICogQHJldHVybiBUaGUgc2l6ZSBuZWVkZWQgdG8gZnVsbHkgc3RvcmUgdGhlIHNvcnQga2V5Li4KICogQHNlZSB1Y29sX2tleUhhc2hDb2RlCiAqIEBzdGFibGUKICovClVfQ0FQSSBpbnQzMl90CnVjb2xfZ2V0U29ydEtleShjb25zdCAgICBVQ29sbGF0b3IgICAgKmNvbGwsCiAgICAgICAgY29uc3QgICAgVUNoYXIgICAgICAgICpzb3VyY2UsCiAgICAgICAgaW50MzJfdCAgICAgICAgICAgIHNvdXJjZUxlbmd0aCwKICAgICAgICB1aW50OF90ICAgICAgICAgICAgKnJlc3VsdCwKICAgICAgICBpbnQzMl90ICAgICAgICAgICAgcmVzdWx0TGVuZ3RoKTsKCi8qKgogKiBHZW5lcmF0ZSBhIGhhc2ggY29kZSBmb3IgYSBjb2xsYXRpb24ga2V5LgogKiBBIGhhc2ggY29kZSBpcyBhIDMyLWJpdCB2YWx1ZSBzdWl0YWJsZSBmb3IgdXNlIGFzIGEga2V5IGluIGEgaGFzaHRhYmxlLgogKiBAcGFyYW0ga2V5IFRoZSBjb2xsYXRpb24ga2V5LgogKiBAcGFyYW0ga2V5TGVuZ3RoIFRoZSBsZW5ndGggb2Yga2V5LgogKiBAcmV0dXJuIEEgaGFzaCBjb2RlIGZvciBrZXkuCiAqIEBzZWUgdWNvbF9nZXRTb3J0S2V5CiAqIEBkZXByZWNhdGVkID8gIHdoeSBpcyBoYXNoQ29kZSB1c2VmdWwgZm9yIEMgdXNlcnM/CiAqLwpVX0NBUEkgaW50MzJfdAp1Y29sX2tleUhhc2hDb2RlKCAgICBjb25zdCAgICB1aW50OF90KiAgICBrZXksIAogICAgICAgICAgICBpbnQzMl90ICAgICAgICBsZW5ndGgpOwoKCi8qKiBUaGUgVUNvbGxhdGlvbkVsZW1lbnRzIHN0cnVjdC4KICogIEZvciB1c2FnZSBpbiBDIHByb2dyYW1zLgogKi8Kc3RydWN0IFVDb2xsYXRpb25FbGVtZW50czsKdHlwZWRlZiBzdHJ1Y3QgVUNvbGxhdGlvbkVsZW1lbnRzIFVDb2xsYXRpb25FbGVtZW50czsKLyoqCiAqIFRoZSBVQ29sbGF0aW9uRWxlbWVudHMgIGlzIHVzZWQgYXMgYW4gaXRlcmF0b3IgdG8gd2FsayB0aHJvdWdoCiAqIGVhY2ggY2hhcmFjdGVyIG9mIGFuIGludGVybmF0aW9uYWwgc3RyaW5nLiBVc2UgdGhlIGl0ZXJhdG9yIHRvIHJldHVybiB0aGUKICogb3JkZXJpbmcgcHJpb3JpdHkgb2YgdGhlIHBvc2l0aW9uZWQgY2hhcmFjdGVyLiBUaGUgb3JkZXJpbmcgcHJpb3JpdHkgb2YKICogYSBjaGFyYWN0ZXIsIHdoaWNoIHdlIHJlZmVyIHRvIGFzIGEga2V5LCBkZWZpbmVzIGhvdyBhIGNoYXJhY3RlciBpcwogKiBjb2xsYXRlZCBpbiB0aGUgZ2l2ZW4gY29sbGF0aW9uIG9iamVjdC4KICogRm9yIGV4YW1wbGUsIGNvbnNpZGVyIHRoZSBmb2xsb3dpbmcgaW4gU3BhbmlzaDoKICogPHByZT4KICogLiAgICAgICAiY2EiIC0+IHRoZSBmaXJzdCBrZXkgaXMga2V5KCdjJykgYW5kIHNlY29uZCBrZXkgaXMga2V5KCdhJykuCiAqIC4gICAgICAgImNoYSIgLT4gdGhlIGZpcnN0IGtleSBpcyBrZXkoJ2NoJykgYW5kIHNlY29uZCBrZXkgaXMga2V5KCdhJykuCiAqIDwvcHJlPgogKiBBbmQgaW4gR2VybWFuLAogKiA8cHJlPgogKiAuICAgICAgICLmYiItPiB0aGUgZmlyc3Qga2V5IGlzIGtleSgnYScpLCB0aGUgc2Vjb25kIGtleSBpcyBrZXkoJ2UnKSwgYW5kCiAqIC4gICAgICAgdGhlIHRoaXJkIGtleSBpcyBrZXkoJ2InKS4KICogPC9wcmU+CiAqIFRoZSBrZXkgb2YgYSBjaGFyYWN0ZXIsIGlzIGFuIGNvbnN0IFVDT0xfUFJJTUFSWU1BU0ssIFVDT0xfU0VDT05EQVJZX01BU0ssCiAqIFVDT0xfVEVSVElBUllNQVNLLiAgICAKICogPHA+RXhhbXBsZSBvZiB0aGUgaXRlcmF0b3IgdXNhZ2U6ICh3aXRob3V0IGVycm9yIGNoZWNraW5nKQogKiA8cHJlPgogKiAuICB2b2lkIENvbGxhdGlvbkVsZW1lbnRJdGVyYXRvcl9FeGFtcGxlKCkKICogLiAgewogKiAuICAgICAgVUNoYXIgKnM7CiAqIC4gICAgICB0X2ludDMyIG9yZGVyLCBwcmltYXJ5T3JkZXI7CiAqIC4gICAgICBVQ29sbGF0aW9uRWxlbWVudHMgKmM7CiAqIC4gICAgICBVQ29sbGF0b3IgKmNvbGw7CiAqIC4gICAgICBVRXJyb3JDb2RlIHN1Y2Nlc3MgPSBVX1pFUk9fRVJST1I7CiAqIC4gICAgICBzPShVQ2hhciopbWFsbG9jKHNpemVvZihVQ2hhcikgKiAoc3RybGVuKCJUaGlzIGlzIGEgdGVzdCIpKzEpICk7CiAqIC4gICAgICB1X3Vhc3RyY3B5KHMsICJUaGlzIGlzIGEgdGVzdCIpOwogKiAuICAgICAgY29sbCA9IHVjb2xfb3BlbihOVUxMLCAmc3VjY2Vzcyk7CiAqIC4gICAgICBjID0gdWNvbF9vcGVuRWxlbWVudHMoY29sbCwgc3RyLCB1X3N0cmxlbihzdHIpLCAmc3RhdHVzKTsKICogLiAgICAgIG9yZGVyID0gdWNvbF9uZXh0KGMsICZzdWNjZXNzKTsKICogLiAgICAgIHByaW1hcnlPcmRlciA9IG9yZGVyICYgVUNPTF9QUklNQVJZTUFTSzsKICogLiAgICAgIGZyZWUocyk7CiAqIC4gICAgICB1Y29sX2Nsb3NlKGNvbGwpOwogKiAuICAgICAgdWNvbF9jbG9zZUVsZW1lbnRzKGMpOwogKiAuICB9CiAqIDwvcHJlPgogKiA8cD4KICogdWNvbF9uZXh0KCkgcmV0dXJucyB0aGUgY29sbGF0aW9uIG9yZGVyIG9mIHRoZSBuZXh0CiAqIGNoYXJhY3RlciBiYXNlZCBvbiB0aGUgY29tcGFyaXNvbiBsZXZlbCBvZiB0aGUgY29sbGF0b3IuICBBIGNvbGxhdGlvbiBvcmRlciAKICogY29uc2lzdHMgb2YgcHJpbWFyeSBvcmRlciwgc2Vjb25kYXJ5IG9yZGVyIGFuZCB0ZXJ0aWFyeSBvcmRlci4gIFRoZSBkYXRhIAogKiB0eXBlIG9mIHRoZSBjb2xsYXRpb24gb3JkZXIgaXMgPHN0cm9uZz50X2ludDMyPC9zdHJvbmc+LiAgVGhlIGZpcnN0IDE2IGJpdHMgb2YgCiAqIGEgY29sbGF0aW9uIG9yZGVyIGlzIGl0cyBwcmltYXJ5IG9yZGVyOyB0aGUgbmV4dCA4IGJpdHMgaXMgdGhlIHNlY29uZGFyeSAKICogb3JkZXIgYW5kIHRoZSBsYXN0IDggYml0cyBpcyB0aGUgdGVydGlhcnkgb3JkZXIuCiAqCiAqIEBzZWUgICAgICAgICAgICAgICAgQ29sbGF0b3IKICovCgovKioKICogT3BlbiB0aGUgY29sbGF0aW9uIGVsZW1lbnRzIGZvciBhIHN0cmluZy4KICoKICogQHBhcmFtIGNvbGwgVGhlIGNvbGxhdG9yIGNvbnRhaW5pbmcgdGhlIGRlc2lyZWQgY29sbGF0aW9uIHJ1bGVzLgogKiBAcGFyYW0gdGV4dCBUaGUgdGV4dCB0byBpdGVyYXRlIG92ZXIuCiAqIEBwYXJhbSB0ZXh0TGVuZ3RoIFRoZSBudW1iZXIgb2YgY2hhcmFjdGVycyBpbiB0ZXh0LCBvciAtMSBpZiBudWxsLXRlcm1pbmF0ZWQKICogQHBhcmFtIHN0YXR1cyBBIHBvaW50ZXIgdG8gYW4gVUVycm9yQ29kZSB0byByZWNlaXZlIGFueSBlcnJvcnMuCiAqIEBzdGFibGUKICovClVfQ0FQSSBVQ29sbGF0aW9uRWxlbWVudHMqCnVjb2xfb3BlbkVsZW1lbnRzKCAgICBjb25zdCAgICBVQ29sbGF0b3IgICAgICAgKmNvbGwsCiAgICAgICAgICAgIGNvbnN0ICAgIFVDaGFyICAgICAgICAgICAqdGV4dCwKICAgICAgICAgICAgaW50MzJfdCAgICAgICAgICAgICAgICAgIHRleHRMZW5ndGgsCiAgICAgICAgICAgIFVFcnJvckNvZGUgICAgICAgICAqc3RhdHVzKTsKCi8qIEJpdCBtYXNrIGZvciBwcmltYXJ5IGNvbGxhdGlvbiBzdHJlbmd0aC4gKi8KI2RlZmluZSBVQ09MX1BSSU1BUllNQVNLICAgIDB4RkZGRjAwMDAKCi8qIEJpdCBtYXNrIGZvciBzZWNvbmRhcnkgY29sbGF0aW9uIHN0cmVuZ3RoLiAqLwojZGVmaW5lIFVDT0xfU0VDT05EQVJZTUFTSyAgMHgwMDAwRkYwMAoKLyogQml0IG1hc2sgZm9yIHRlcnRpYXJ5IGNvbGxhdGlvbiBzdHJlbmd0aC4gKi8KI2RlZmluZSBVQ09MX1RFUlRJQVJZTUFTSyAgIDB4MDAwMDAwRkYKCi8qKiBUaGlzIGluZGljYXRlcyB0aGUgbGFzdCBlbGVtZW50IGluIGEgVUNvbGxhdGlvbkVsZW1lbnRzIGhhcyBiZWVuIGNvbnN1bWVkLiAKICoKICovCiNkZWZpbmUgVUNPTF9OVUxMT1JERVIgICAgICAgIDB4RkZGRkZGRkYKCi8qKgogKiBDbG9zZSBhIFVDb2xsYXRpb25FbGVtZW50cy4KICogT25jZSBjbG9zZWQsIGEgVUNvbGxhdGlvbkVsZW1lbnRzIG1heSBubyBsb25nZXIgYmUgdXNlZC4KICogQHBhcmFtIGVsZW1zIFRoZSBVQ29sbGF0aW9uRWxlbWVudHMgdG8gY2xvc2UuCiAqIEBzdGFibGUKICovClVfQ0FQSSB2b2lkCnVjb2xfY2xvc2VFbGVtZW50cyhVQ29sbGF0aW9uRWxlbWVudHMgKmVsZW1zKTsKCi8qKgogKiBSZXNldCB0aGUgY29sbGF0aW9uIGVsZW1lbnRzIHRvIHRoZWlyIGluaXRpYWwgc3RhdGUuCiAqIFRoaXMgd2lsbCBtb3ZlIHRoZSAnY3Vyc29yJyB0byB0aGUgYmVnaW5uaW5nIG9mIHRoZSB0ZXh0LgogKiBAcGFyYW0gZWxlbXMgVGhlIFVDb2xsYXRpb25FbGVtZW50cyB0byByZXNldC4KICogQHNlZSB1Y29sX25leHQKICogQHNlZSB1Y29sX3ByZXZpb3VzCiAqIEBzdGFibGUKICovClVfQ0FQSSB2b2lkCnVjb2xfcmVzZXQoVUNvbGxhdGlvbkVsZW1lbnRzICplbGVtcyk7CgovKioKICogR2V0IHRoZSBvcmRlcmluZyBwcmlvcml0eSBvZiB0aGUgbmV4dCBjb2xsYXRpb24gZWxlbWVudCBpbiB0aGUgdGV4dC4KICogQSBzaW5nbGUgY2hhcmFjdGVyIG1heSBjb250YWluIG1vcmUgdGhhbiBvbmUgY29sbGF0aW9uIGVsZW1lbnQuCiAqIEBwYXJhbSBlbGVtcyBUaGUgVUNvbGxhdGlvbkVsZW1lbnRzIGNvbnRhaW5pbmcgdGhlIHRleHQuCiAqIEBwYXJhbSBzdGF0dXMgQSBwb2ludGVyIHRvIGFuIFVFcnJvckNvZGUgdG8gcmVjZWl2ZSBhbnkgZXJyb3JzLgogKiBAcmV0dXJuIFRoZSBuZXh0IGNvbGxhdGlvbiBlbGVtZW50cyBvcmRlcmluZywgb3IgXFJlZntVQ09MX05VTExPUkRFUn0gaWYgdGhlCiAqIGVuZCBvZiB0aGUgdGV4dCBpcyByZWFjaGVkLgogKiBAc3RhYmxlCiAqLwpVX0NBUEkgaW50MzJfdAp1Y29sX25leHQoICAgIFVDb2xsYXRpb25FbGVtZW50cyAgICAqZWxlbXMsCiAgICAgICAgVUVycm9yQ29kZSAgICAgICAgKnN0YXR1cyk7CgovKioKICogR2V0IHRoZSBvcmRlcmluZyBwcmlvcml0eSBvZiB0aGUgcHJldmlvdXMgY29sbGF0aW9uIGVsZW1lbnQgaW4gdGhlIHRleHQuCiAqIEEgc2luZ2xlIGNoYXJhY3RlciBtYXkgY29udGFpbiBtb3JlIHRoYW4gb25lIGNvbGxhdGlvbiBlbGVtZW50LgogKiBAcGFyYW0gZWxlbXMgVGhlIFVDb2xsYXRpb25FbGVtZW50cyBjb250YWluaW5nIHRoZSB0ZXh0LgogKiBAcGFyYW0gc3RhdHVzIEEgcG9pbnRlciB0byBhbiBVRXJyb3JDb2RlIHRvIHJlY2VpdmUgYW55IGVycm9ycy4KICogQHJldHVybiBUaGUgcHJldmlvdXMgY29sbGF0aW9uIGVsZW1lbnRzIG9yZGVyaW5nLCBvciBcUmVme1VDT0xfTlVMTE9SREVSfQogKiBpZiB0aGUgZW5kIG9mIHRoZSB0ZXh0IGlzIHJlYWNoZWQuCiAqIEBzdGFibGUKICovClVfQ0FQSSBpbnQzMl90CnVjb2xfcHJldmlvdXMoICAgIFVDb2xsYXRpb25FbGVtZW50cyAgICAqZWxlbXMsCiAgICAgICAgVUVycm9yQ29kZSAgICAgICAgKnN0YXR1cyk7CgovKioKICogR2V0IHRoZSBtYXhpbXVtIGxlbmd0aCBvZiBhbnkgZXhwYW5zaW9uIHNlcXVlbmNlcyB0aGF0IGVuZCB3aXRoIHRoZSAKICogc3BlY2lmaWVkIGNvbXBhcmlzb24gb3JkZXIuCiAqIFRoaXMgaXMgdXNlZnVsIGZvciAuLi4uID8KICogQHBhcmFtIGVsZW1zIFRoZSBVQ29sbGF0aW9uRWxlbWVudHMgY29udGFpbmluZyB0aGUgdGV4dC4KICogQHBhcmFtIG9yZGVyIEEgY29sbGF0aW9uIG9yZGVyIHJldHVybmVkIGJ5IHByZXZpb3VzIG9yIG5leHQuCiAqIEByZXR1cm4gVGhlIG1heGltdW0gbGVuZ3RoIG9mIGFueSBleHBhbnNpb24gc2VxdWVuY2VzIGVuZGluZyB3aXRoIHRoZSAKICogc3BlY2lmaWVkIG9yZGVyLgogKiBAc3RhYmxlCiAqLwpVX0NBUEkgaW50MzJfdAp1Y29sX2dldE1heEV4cGFuc2lvbiggICAgY29uc3QgICAgVUNvbGxhdGlvbkVsZW1lbnRzICAgICplbGVtcywKICAgICAgICAgICAgaW50MzJfdCAgICAgICAgICAgICAgICBvcmRlcik7CgovKioKICogU2V0IHRoZSB0ZXh0IGNvbnRhaW5pbmcgdGhlIGNvbGxhdGlvbiBlbGVtZW50cy4KICogVGhpcyAKICogQHBhcmFtIGVsZW1zIFRoZSBVQ29sbGF0aW9uRWxlbWVudHMgdG8gc2V0LgogKiBAcGFyYW0gdGV4dCBUaGUgc291cmNlIHRleHQgY29udGFpbmluZyB0aGUgY29sbGF0aW9uIGVsZW1lbnRzLgogKiBAcGFyYW0gdGV4dExlbmd0aCBUaGUgbGVuZ3RoIG9mIHRleHQsIG9yIC0xIGlmIG51bGwtdGVybWluYXRlZC4KICogQHBhcmFtIHN0YXR1cyBBIHBvaW50ZXIgdG8gYW4gVUVycm9yQ29kZSB0byByZWNlaXZlIGFueSBlcnJvcnMuCiAqIEBzZWUgdWNvbF9nZXRUZXh0CiAqIEBzdGFibGUKICovClVfQ0FQSSB2b2lkCnVjb2xfc2V0VGV4dCggICAgVUNvbGxhdGlvbkVsZW1lbnRzICAgICplbGVtcywKICAgICAgICBjb25zdCAgICBVQ2hhciAgICAgICAgKnRleHQsCiAgICAgICAgaW50MzJfdCAgICAgICAgICAgIHRleHRMZW5ndGgsCiAgICAgICAgVUVycm9yQ29kZSAgICAgICAgKnN0YXR1cyk7CgovKioKICogR2V0IHRoZSBvZmZzZXQgb2YgdGhlIGN1cnJlbnQgc291cmNlIGNoYXJhY3Rlci4KICogVGhpcyBpcyBhbiBvZmZzZXQgaW50byB0aGUgdGV4dCBvZiB0aGUgY2hhcmFjdGVyIGNvbnRhaW5pbmcgdGhlIGN1cnJlbnQKICogY29sbGF0aW9uIGVsZW1lbnRzLgogKiBAcGFyYW0gZWxlbXMgVGhlIFVDb2xsYXRpb25FbGVtZW50cyB0byBxdWVyeS4KICogQHJldHVybiBUaGUgb2Zmc2V0IG9mIHRoZSBjdXJyZW50IHNvdXJjZSBjaGFyYWN0ZXIuCiAqIEBzZWUgdWNvbF9zZXRPZmZzZXQKICogQHN0YWJsZQogKi8KVV9DQVBJIFVUZXh0T2Zmc2V0CnVjb2xfZ2V0T2Zmc2V0KGNvbnN0IFVDb2xsYXRpb25FbGVtZW50cyAqZWxlbXMpOwoKLyoqCiAqIFNldCB0aGUgb2Zmc2V0IG9mIHRoZSBjdXJyZW50IHNvdXJjZSBjaGFyYWN0ZXIuCiAqIFRoaXMgaXMgYW4gb2Zmc2V0IGludG8gdGhlIHRleHQgb2YgdGhlIGNoYXJhY3RlciB0byBiZSBwcm9jZXNzZWQuCiAqIEBwYXJhbSBlbGVtcyBUaGUgVUNvbGxhdGlvbkVsZW1lbnRzIHRvIHNldC4KICogQHBhcmFtIG9mZnNldCBUaGUgZGVzaXJlZCBjaGFyYWN0ZXIgb2Zmc2V0LgogKiBAcGFyYW0gc3RhdHVzIEEgcG9pbnRlciB0byBhbiBVRXJyb3JDb2RlIHRvIHJlY2VpdmUgYW55IGVycm9ycy4KICogQHNlZSB1Y29sX2dldE9mZnNldAogKiBAc3RhYmxlCiAqLwpVX0NBUEkgdm9pZAp1Y29sX3NldE9mZnNldCggICAgVUNvbGxhdGlvbkVsZW1lbnRzICAgICplbGVtcywKICAgICAgICBVVGV4dE9mZnNldCAgICAgICAgb2Zmc2V0LAogICAgICAgIFVFcnJvckNvZGUgICAgICAgICpzdGF0dXMpOwoKI2VuZGlmCg==