LyoKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCioKKiAgIENvcHlyaWdodCAoQykgMTk5Ni0yMDAxLCBJbnRlcm5hdGlvbmFsIEJ1c2luZXNzIE1hY2hpbmVzCiogICBDb3Jwb3JhdGlvbiBhbmQgb3RoZXJzLiAgQWxsIFJpZ2h0cyBSZXNlcnZlZC4KKgoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKgoqIEZpbGUgbG9jaWQuaAoqCiogQ3JlYXRlZCBieTogSGVsZW5hIFNoaWgKKgoqIE1vZGlmaWNhdGlvbiBIaXN0b3J5OgoqCiogICBEYXRlICAgICAgICBOYW1lICAgICAgICBEZXNjcmlwdGlvbgoqICAgMDIvMTEvOTcgICAgYWxpdSAgICAgICAgQ2hhbmdlZCBnTG9jUGF0aCB0byBmZ0xvY1BhdGggYW5kIGFkZGVkIG1ldGhvZHMgdG8KKiAgICAgICAgICAgICAgICAgICAgICAgICAgIGdldCBhbmQgc2V0IGl0LgoqICAgMDQvMDIvOTcgICAgYWxpdSAgICAgICAgTWFkZSBvcGVyYXRvciE9IGlubGluZTsgZml4ZWQgcmV0dXJuIHZhbHVlIG9mIGdldE5hbWUoKS4KKiAgIDA0LzE1Lzk3ICAgIGFsaXUgICAgICAgIENsZWFudXAgZm9yIEFJWC9XaW4zMi4KKiAgIDA0LzI0Lzk3ICAgIGFsaXUgICAgICAgIE51bWVyb3VzIGNoYW5nZXMgcGVyIGNvZGUgcmV2aWV3LgoqICAgMDgvMTgvOTggICAgc3RlcGhlbiAgICAgQWRkZWQgdG9rZW5pemVTdHJpbmcoKSxjaGFuZ2VkIGdldERpc3BsYXlOYW1lKCkKKiAgIDA5LzA4Lzk4ICAgIHN0ZXBoZW4gICAgIE1vdmVkIGRlZmluaXRpb24gb2Yga0VtcHR5U3RyaW5nIGZvciBNYWMgUG9ydAoqICAgMTEvMDkvOTkgICAgd2VpdiAgICAgICAgQWRkZWQgY29uc3QgY2hhciAqIGdldE5hbWUoKSBjb25zdDsKKiAgIDA0LzEyLzAwICAgIHNybCAgICAgICAgIHJlbW92aW5nIHVuaWNvZGVzdHJpbmcgYXBpJ3MgYW5kIGNhY2hlZCBoYXNoIGNvZGUKKiAgIDA4LzEwLzAxICAgIGdyaG90ZW4gICAgIENoYW5nZSB0aGUgc3RhdGljIExvY2FsZXMgdG8gYWNjZXNzb3IgZnVuY3Rpb25zCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgoqLwoKI2lmbmRlZiBMT0NJRF9ICiNkZWZpbmUgTE9DSURfSAoKCiNpbmNsdWRlICJ1bmljb2RlL3B1dGlsLmgiCgoKI2RlZmluZSBVTE9DX0xBTkdfQ0FQQUNJVFkgMTIKI2RlZmluZSBVTE9DX0NPVU5UUllfQ0FQQUNJVFkgNAojZGVmaW5lIFVMT0NfRlVMTE5BTUVfQ0FQQUNJVFkgNTAKCiNpZmRlZiBYUF9DUExVU1BMVVMKCiNpbmNsdWRlICJ1bmljb2RlL3VuaXN0ci5oIgoKLyoqCiAqIEEgPGNvZGU+TG9jYWxlPC9jb2RlPiBvYmplY3QgcmVwcmVzZW50cyBhIHNwZWNpZmljIGdlb2dyYXBoaWNhbCwgcG9saXRpY2FsLAogKiBvciBjdWx0dXJhbCByZWdpb24uIEFuIG9wZXJhdGlvbiB0aGF0IHJlcXVpcmVzIGEgPGNvZGU+TG9jYWxlPC9jb2RlPiB0byBwZXJmb3JtCiAqIGl0cyB0YXNrIGlzIGNhbGxlZCA8ZW0+bG9jYWxlLXNlbnNpdGl2ZTwvZW0+IGFuZCB1c2VzIHRoZSA8Y29kZT5Mb2NhbGU8L2NvZGU+CiAqIHRvIHRhaWxvciBpbmZvcm1hdGlvbiBmb3IgdGhlIHVzZXIuIEZvciBleGFtcGxlLCBkaXNwbGF5aW5nIGEgbnVtYmVyCiAqIGlzIGEgbG9jYWxlLXNlbnNpdGl2ZSBvcGVyYXRpb24tLXRoZSBudW1iZXIgc2hvdWxkIGJlIGZvcm1hdHRlZAogKiBhY2NvcmRpbmcgdG8gdGhlIGN1c3RvbXMvY29udmVudGlvbnMgb2YgdGhlIHVzZXIncyBuYXRpdmUgY291bnRyeSwKICogcmVnaW9uLCBvciBjdWx0dXJlLgogKgogKiA8UD4KICogWW91IGNyZWF0ZSBhIDxjb2RlPkxvY2FsZTwvY29kZT4gb2JqZWN0IHVzaW5nIHRoZSBjb25zdHJ1Y3RvciBpbgogKiB0aGlzIGNsYXNzOgogKiA8YmxvY2txdW90ZT4KICogPHByZT4KICogLiAgICAgIExvY2FsZSggY29uc3QgICBjaGFyKiAgbGFuZ3VhZ2UsIAogKiAuICAgICAgICAgICAgICBjb25zdCAgIGNoYXIqICBjb3VudHJ5LCAKICogLiAgICAgICAgICAgICAgY29uc3QgICBjaGFyKiAgdmFyaWFudCk7CiAqIDwvcHJlPgogKiA8L2Jsb2NrcXVvdGU+CiAqIFRoZSBmaXJzdCBhcmd1bWVudCB0byB0aGUgY29uc3RydWN0b3JzIGlzIGEgdmFsaWQgPFNUUk9ORz5JU08KICogTGFuZ3VhZ2UgQ29kZS48L1NUUk9ORz4gVGhlc2UgY29kZXMgYXJlIHRoZSBsb3dlci1jYXNlIHR3by1sZXR0ZXIKICogY29kZXMgYXMgZGVmaW5lZCBieSBJU08tNjM5LgogKiBZb3UgY2FuIGZpbmQgYSBmdWxsIGxpc3Qgb2YgdGhlc2UgY29kZXMgYXQgYSBudW1iZXIgb2Ygc2l0ZXMsIHN1Y2ggYXM6CiAqIDxCUj48YSBocmVmID0iaHR0cDovL3d3dy5pY3MudWNpLmVkdS9wdWIvaWV0Zi9odHRwL3JlbGF0ZWQvaXNvNjM5LnR4dCI+CiAqIDxjb2RlPmh0dHA6Ly93d3cuaWNzLnVjaS5lZHUvcHViL2lldGYvaHR0cC9yZWxhdGVkL2lzbzYzOS50eHQ8L2NvZGU+PC9hPgogKgogKiA8UD4KICogVGhlIHNlY29uZCBhcmd1bWVudCB0byB0aGUgY29uc3RydWN0b3JzIGlzIGEgdmFsaWQgPFNUUk9ORz5JU08gQ291bnRyeQogKiBDb2RlLjwvU1RST05HPiBUaGVzZSBjb2RlcyBhcmUgdGhlIHVwcGVyLWNhc2UgdHdvLWxldHRlciBjb2RlcwogKiBhcyBkZWZpbmVkIGJ5IElTTy0zMTY2LgogKiBZb3UgY2FuIGZpbmQgYSBmdWxsIGxpc3Qgb2YgdGhlc2UgY29kZXMgYXQgYSBudW1iZXIgb2Ygc2l0ZXMsIHN1Y2ggYXM6CiAqIDxCUj48YSBocmVmPSJodHRwOi8vd3d3LmNoZW1pZS5mdS1iZXJsaW4uZGUvZGl2ZXJzZS9kb2MvSVNPXzMxNjYuaHRtbCI+CiAqIDxjb2RlPmh0dHA6Ly93d3cuY2hlbWllLmZ1LWJlcmxpbi5kZS9kaXZlcnNlL2RvYy9JU09fMzE2Ni5odG1sPC9jb2RlPjwvYT4KICoKICogPFA+CiAqIFRoZSB0aGlyZCBjb25zdHJ1Y3RvciByZXF1aXJlcyBhIHRoaXJkIGFyZ3VtZW50LS10aGUgPFNUUk9ORz5WYXJpYW50LjwvU1RST05HPgogKiBUaGUgVmFyaWFudCBjb2RlcyBhcmUgdmVuZG9yIGFuZCBicm93c2VyLXNwZWNpZmljLgogKiBGb3IgZXhhbXBsZSwgdXNlIFdJTiBmb3IgV2luZG93cywgTUFDIGZvciBNYWNpbnRvc2gsIGFuZCBQT1NJWCBmb3IgUE9TSVguCiAqIFdoZXJlIHRoZXJlIGFyZSB0d28gdmFyaWFudHMsIHNlcGFyYXRlIHRoZW0gd2l0aCBhbiB1bmRlcnNjb3JlLCBhbmQKICogcHV0IHRoZSBtb3N0IGltcG9ydGFudCBvbmUgZmlyc3QuIEZvcgogKiBleGFtcGxlLCBhIFRyYWRpdGlvbmFsIFNwYW5pc2ggY29sbGF0aW9uIG1pZ2h0IGJlIHJlZmVyZW5jZWQsIHdpdGgKICogIkVTIiwgIkVTIiwgIlRyYWRpdGlvbmFsX1dJTiIuCiAqCiAqIDxQPgogKiBCZWNhdXNlIGEgPGNvZGU+TG9jYWxlPC9jb2RlPiBvYmplY3QgaXMganVzdCBhbiBpZGVudGlmaWVyIGZvciBhIHJlZ2lvbiwKICogbm8gdmFsaWRpdHkgY2hlY2sgaXMgcGVyZm9ybWVkIHdoZW4geW91IGNvbnN0cnVjdCBhIDxjb2RlPkxvY2FsZTwvY29kZT4uCiAqIElmIHlvdSB3YW50IHRvIHNlZSB3aGV0aGVyIHBhcnRpY3VsYXIgcmVzb3VyY2VzIGFyZSBhdmFpbGFibGUgZm9yIHRoZQogKiA8Y29kZT5Mb2NhbGU8L2NvZGU+IHlvdSBjb25zdHJ1Y3QsIHlvdSBtdXN0IHF1ZXJ5IHRob3NlIHJlc291cmNlcy4gRm9yCiAqIGV4YW1wbGUsIGFzayB0aGUgPGNvZGU+TnVtYmVyRm9ybWF0PC9jb2RlPiBmb3IgdGhlIGxvY2FsZXMgaXQgc3VwcG9ydHMKICogdXNpbmcgaXRzIDxjb2RlPmdldEF2YWlsYWJsZUxvY2FsZXM8L2NvZGU+IG1ldGhvZC4KICogPEJSPjxTVFJPTkc+Tm90ZTo8L1NUUk9ORz4gV2hlbiB5b3UgYXNrIGZvciBhIHJlc291cmNlIGZvciBhIHBhcnRpY3VsYXIKICogbG9jYWxlLCB5b3UgZ2V0IGJhY2sgdGhlIGJlc3QgYXZhaWxhYmxlIG1hdGNoLCBub3QgbmVjZXNzYXJpbHkKICogcHJlY2lzZWx5IHdoYXQgeW91IGFza2VkIGZvci4gRm9yIG1vcmUgaW5mb3JtYXRpb24sIGxvb2sgYXQKICogPGEgaHJlZj0iamF2YS51dGlsLlJlc291cmNlQnVuZGxlLmh0bWwiPjxjb2RlPlJlc291cmNlQnVuZGxlPC9jb2RlPjwvYT4uCiAqCiAqIDxQPgogKiBUaGUgPGNvZGU+TG9jYWxlPC9jb2RlPiBjbGFzcyBwcm92aWRlcyBhIG51bWJlciBvZiBjb252ZW5pZW50IGNvbnN0YW50cwogKiB0aGF0IHlvdSBjYW4gdXNlIHRvIGNyZWF0ZSA8Y29kZT5Mb2NhbGU8L2NvZGU+IG9iamVjdHMgZm9yIGNvbW1vbmx5IHVzZWQKICogbG9jYWxlcy4gRm9yIGV4YW1wbGUsIHRoZSBmb2xsb3dpbmcgcmVmZXJzIHRvIGEgPGNvZGU+TG9jYWxlPC9jb2RlPiBvYmplY3QKICogZm9yIHRoZSBVbml0ZWQgU3RhdGVzOgogKiA8YmxvY2txdW90ZT4KICogPHByZT4KICogICAgICAgTG9jYWxlOjpnZXRVUygpCiAqIDwvcHJlPgogKiA8L2Jsb2NrcXVvdGU+CiAqCiAqIDxQPgogKiBPbmNlIHlvdSd2ZSBjcmVhdGVkIGEgPGNvZGU+TG9jYWxlPC9jb2RlPiB5b3UgY2FuIHF1ZXJ5IGl0IGZvciBpbmZvcm1hdGlvbiBhYm91dAogKiBpdHNlbGYuIFVzZSA8Y29kZT5nZXRDb3VudHJ5PC9jb2RlPiB0byBnZXQgdGhlIElTTyBDb3VudHJ5IENvZGUgYW5kCiAqIDxjb2RlPmdldExhbmd1YWdlPC9jb2RlPiB0byBnZXQgdGhlIElTTyBMYW5ndWFnZSBDb2RlLiBZb3UgY2FuCiAqIHVzZSA8Y29kZT5nZXREaXNwbGF5Q291bnRyeTwvY29kZT4gdG8gZ2V0IHRoZQogKiBuYW1lIG9mIHRoZSBjb3VudHJ5IHN1aXRhYmxlIGZvciBkaXNwbGF5aW5nIHRvIHRoZSB1c2VyLiBTaW1pbGFybHksCiAqIHlvdSBjYW4gdXNlIDxjb2RlPmdldERpc3BsYXlMYW5ndWFnZTwvY29kZT4gdG8gZ2V0IHRoZSBuYW1lIG9mCiAqIHRoZSBsYW5ndWFnZSBzdWl0YWJsZSBmb3IgZGlzcGxheWluZyB0byB0aGUgdXNlci4gSW50ZXJlc3RpbmdseSwKICogdGhlIDxjb2RlPmdldERpc3BsYXlYWFg8L2NvZGU+IG1ldGhvZHMgYXJlIHRoZW1zZWx2ZXMgbG9jYWxlLXNlbnNpdGl2ZQogKiBhbmQgaGF2ZSB0d28gdmVyc2lvbnM6IG9uZSB0aGF0IHVzZXMgdGhlIGRlZmF1bHQgbG9jYWxlIGFuZCBvbmUKICogdGhhdCB0YWtlcyBhIGxvY2FsZSBhcyBhbiBhcmd1bWVudCBhbmQgZGlzcGxheXMgdGhlIG5hbWUgb3IgY291bnRyeSBpbgogKiBhIGxhbmd1YWdlIGFwcHJvcHJpYXRlIHRvIHRoYXQgbG9jYWxlLgogKgogKiA8UD4KICogVGhlIFRJRkMgcHJvdmlkZXMgYSBudW1iZXIgb2YgY2xhc3NlcyB0aGF0IHBlcmZvcm0gbG9jYWxlLXNlbnNpdGl2ZQogKiBvcGVyYXRpb25zLiBGb3IgZXhhbXBsZSwgdGhlIDxjb2RlPk51bWJlckZvcm1hdDwvY29kZT4gY2xhc3MgZm9ybWF0cwogKiBudW1iZXJzLCBjdXJyZW5jeSwgb3IgcGVyY2VudGFnZXMgaW4gYSBsb2NhbGUtc2Vuc2l0aXZlIG1hbm5lci4gQ2xhc3NlcwogKiBzdWNoIGFzIDxjb2RlPk51bWJlckZvcm1hdDwvY29kZT4gaGF2ZSBhIG51bWJlciBvZiBjb252ZW5pZW5jZSBtZXRob2RzCiAqIGZvciBjcmVhdGluZyBhIGRlZmF1bHQgb2JqZWN0IG9mIHRoYXQgdHlwZS4gRm9yIGV4YW1wbGUsIHRoZQogKiA8Y29kZT5OdW1iZXJGb3JtYXQ8L2NvZGU+IGNsYXNzIHByb3ZpZGVzIHRoZXNlIHRocmVlIGNvbnZlbmllbmNlIG1ldGhvZHMKICogZm9yIGNyZWF0aW5nIGEgZGVmYXVsdCA8Y29kZT5OdW1iZXJGb3JtYXQ8L2NvZGU+IG9iamVjdDoKICogPGJsb2NrcXVvdGU+CiAqIDxwcmU+CiAqICAgICBVRXJyb3JDb2RlIHN1Y2Nlc3MgPSBVX1pFUk9fRVJST1I7CiAqICAgICBMb2NhbGUgbXlMb2NhbGU7CiAqICAgICBOdW1iZXJGb3JtYXQgKm5mOwogKiAKICogICAgIG5mID0gTnVtYmVyRm9ybWF0OjpjcmVhdGVJbnN0YW5jZSggc3VjY2VzcyApOyAgICAgICAgICBkZWxldGUgbmY7CiAqICAgICBuZiA9IE51bWJlckZvcm1hdDo6Y3JlYXRlQ3VycmVuY3lJbnN0YW5jZSggc3VjY2VzcyApOyAgZGVsZXRlIG5mOwogKiAgICAgbmYgPSBOdW1iZXJGb3JtYXQ6OmNyZWF0ZVBlcmNlbnRJbnN0YW5jZSggc3VjY2VzcyApOyAgIGRlbGV0ZSBuZjsKICogPC9wcmU+CiAqIDwvYmxvY2txdW90ZT4KICogRWFjaCBvZiB0aGVzZSBtZXRob2RzIGhhcyB0d28gdmFyaWFudHM7IG9uZSB3aXRoIGFuIGV4cGxpY2l0IGxvY2FsZQogKiBhbmQgb25lIHdpdGhvdXQ7IHRoZSBsYXR0ZXIgdXNpbmcgdGhlIGRlZmF1bHQgbG9jYWxlLgogKiA8YmxvY2txdW90ZT4KICogPHByZT4KICogICAgIG5mID0gTnVtYmVyRm9ybWF0OjpjcmVhdGVJbnN0YW5jZSggbXlMb2NhbGUsIHN1Y2Nlc3MgKTsgICAgICAgICAgZGVsZXRlIG5mOwogKiAgICAgbmYgPSBOdW1iZXJGb3JtYXQ6OmNyZWF0ZUN1cnJlbmN5SW5zdGFuY2UoIG15TG9jYWxlLCBzdWNjZXNzICk7ICBkZWxldGUgbmY7CiAqICAgICBuZiA9IE51bWJlckZvcm1hdDo6Y3JlYXRlUGVyY2VudEluc3RhbmNlKCBteUxvY2FsZSwgc3VjY2VzcyApOyAgIGRlbGV0ZSBuZjsKICogPC9wcmU+CiAqIDwvYmxvY2txdW90ZT4KICogQSA8Y29kZT5Mb2NhbGU8L2NvZGU+IGlzIHRoZSBtZWNoYW5pc20gZm9yIGlkZW50aWZ5aW5nIHRoZSBraW5kIG9mIG9iamVjdAogKiAoPGNvZGU+TnVtYmVyRm9ybWF0PC9jb2RlPikgdGhhdCB5b3Ugd291bGQgbGlrZSB0byBnZXQuIFRoZSBsb2NhbGUgaXMKICogPFNUUk9ORz5qdXN0PC9TVFJPTkc+IGEgbWVjaGFuaXNtIGZvciBpZGVudGlmeWluZyBvYmplY3RzLAogKiA8U1RST05HPm5vdDwvU1RST05HPiBhIGNvbnRhaW5lciBmb3IgdGhlIG9iamVjdHMgdGhlbXNlbHZlcy4KICoKICogPFA+CiAqIEVhY2ggY2xhc3MgdGhhdCBwZXJmb3JtcyBsb2NhbGUtc2Vuc2l0aXZlIG9wZXJhdGlvbnMgYWxsb3dzIHlvdQogKiB0byBnZXQgYWxsIHRoZSBhdmFpbGFibGUgb2JqZWN0cyBvZiB0aGF0IHR5cGUuIFlvdSBjYW4gc2lmdAogKiB0aHJvdWdoIHRoZXNlIG9iamVjdHMgYnkgbGFuZ3VhZ2UsIGNvdW50cnksIG9yIHZhcmlhbnQsCiAqIGFuZCB1c2UgdGhlIGRpc3BsYXkgbmFtZXMgdG8gcHJlc2VudCBhIG1lbnUgdG8gdGhlIHVzZXIuCiAqIEZvciBleGFtcGxlLCB5b3UgY2FuIGNyZWF0ZSBhIG1lbnUgb2YgYWxsIHRoZSBjb2xsYXRpb24gb2JqZWN0cwogKiBzdWl0YWJsZSBmb3IgYSBnaXZlbiBsYW5ndWFnZS4gU3VjaCBjbGFzc2VzIGltcGxlbWVudCB0aGVzZQogKiB0aHJlZSBjbGFzcyBtZXRob2RzOgogKiA8YmxvY2txdW90ZT4KICogPHByZT4KICogICAgICAgc3RhdGljIExvY2FsZSogZ2V0QXZhaWxhYmxlTG9jYWxlcyhpbnQzMl90JiBudW1Mb2NhbGVzKQogKiAgICAgICBzdGF0aWMgVW5pY29kZVN0cmluZyYgZ2V0RGlzcGxheU5hbWUoY29uc3QgTG9jYWxlJiAgb2JqZWN0TG9jYWxlLAogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgTG9jYWxlJiAgZGlzcGxheUxvY2FsZSwKICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmIGRpc3BsYXlOYW1lKQogKiAgICAgICBzdGF0aWMgVW5pY29kZVN0cmluZyYgZ2V0RGlzcGxheU5hbWUoY29uc3QgTG9jYWxlJiAgb2JqZWN0TG9jYWxlLAogKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVW5pY29kZVN0cmluZyYgZGlzcGxheU5hbWUpCiAqIDwvcHJlPgogKiA8L2Jsb2NrcXVvdGU+CiAqLwpVX05BTUVTUEFDRV9CRUdJTgpjbGFzcyBVX0NPTU1PTl9BUEkgTG9jYWxlCnsKcHVibGljOgojaWZkZWYgSUNVX0xPQ0lEX1VTRV9ERVBSRUNBVEVTCiAgICAvKioKICAgICAqIFVzZWZ1bCBjb25zdGFudHMgZm9yIGxhbmd1YWdlLgogICAgICovCiAgICBzdGF0aWMgY29uc3QgTG9jYWxlIEVOR0xJU0g7CiAgICBzdGF0aWMgY29uc3QgTG9jYWxlIEZSRU5DSDsKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgR0VSTUFOOwogICAgc3RhdGljIGNvbnN0IExvY2FsZSBJVEFMSUFOOwogICAgc3RhdGljIGNvbnN0IExvY2FsZSBKQVBBTkVTRTsKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgS09SRUFOOwogICAgc3RhdGljIGNvbnN0IExvY2FsZSBDSElORVNFOwogICAgc3RhdGljIGNvbnN0IExvY2FsZSBTSU1QTElGSUVEX0NISU5FU0U7CiAgICBzdGF0aWMgY29uc3QgTG9jYWxlIFRSQURJVElPTkFMX0NISU5FU0U7CgogICAgLyoqCiAgICAgKiBVc2VmdWwgY29uc3RhbnRzIGZvciBjb3VudHJ5LgogICAgICovCiAgICBzdGF0aWMgY29uc3QgTG9jYWxlIEZSQU5DRTsKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgR0VSTUFOWTsKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgSVRBTFk7CiAgICBzdGF0aWMgY29uc3QgTG9jYWxlIEpBUEFOOwogICAgc3RhdGljIGNvbnN0IExvY2FsZSBLT1JFQTsKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgQ0hJTkE7ICAgICAgLyogQWxpYXMgZm9yIFBSQyAqLwogICAgc3RhdGljIGNvbnN0IExvY2FsZSBQUkM7ICAgICAgICAvKiBQZW9wbGVzIFJlcHVibGljIG9mIENoaW5hICovCiAgICBzdGF0aWMgY29uc3QgTG9jYWxlIFRBSVdBTjsKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgVUs7CiAgICBzdGF0aWMgY29uc3QgTG9jYWxlIFVTOwogICAgc3RhdGljIGNvbnN0IExvY2FsZSBDQU5BREE7CiAgICBzdGF0aWMgY29uc3QgTG9jYWxlIENBTkFEQV9GUkVOQ0g7CiNlbHNlCiAgICAvKioKICAgICAqIEEgcHJveHkgZm9yIHRoZSBMb2NhbGUuIAogICAgICogVGhpcyBpcyBkZWZpbmVkIHRvIHN0YXkgc291cmNlIGNvZGUgY29tcGF0aWJsZSBhbmQgdG8gcmVtb3ZlIHN0YXRpYyBpbml0aWFsaXphdGlvbi4KICAgICAqIFRyZWF0IGl0IGp1c3QgbGlrZSBhIExvY2FsZS4KICAgICAqIEBkZXByZWNhdGVkIFJlbW92ZSBhZnRlciAyMDAyLWF1Zy0zMS4gVXNlIG9uZSBvZiB0aGUgb3RoZXIgTG9jYWxlIGdldCBmdW5jdGlvbnMuCiAgICAgKi8KICAgIHR5cGVkZWYgc3RydWN0IFVfQ09NTU9OX0FQSSBMb2NhbGVQcm94eSB7CgogICAgICAgIGludDMyX3QgbWFnaWNMb2NhbGVOdW1iZXI7ICAvKiBUcnkgbm90IHRvIGFjY2VzcyB0aGlzLiBUaGlzIGlzIG5vdCBtZWFudCBmb3Igbm9ybWFsIHVzZS4gKi8KCiAgICAgICAgLyoqIENhbGxzIExvY2FsZSdzIGVxdWl2YWxlbnQgZnVuY3Rpb24gKi8KICAgICAgICBpbmxpbmUgY29uc3QgY2hhciAqZ2V0TGFuZ3VhZ2UoICkgY29uc3Q7CiAgICAgICAgLyoqIENhbGxzIExvY2FsZSdzIGVxdWl2YWxlbnQgZnVuY3Rpb24gKi8KICAgICAgICBpbmxpbmUgY29uc3QgY2hhciAqZ2V0Q291bnRyeSggKSBjb25zdDsKICAgICAgICAvKiogQ2FsbHMgTG9jYWxlJ3MgZXF1aXZhbGVudCBmdW5jdGlvbiAqLwogICAgICAgIGlubGluZSBjb25zdCBjaGFyICpnZXRWYXJpYW50KCApIGNvbnN0OwogICAgICAgIC8qKiBDYWxscyBMb2NhbGUncyBlcXVpdmFsZW50IGZ1bmN0aW9uICovCiAgICAgICAgaW5saW5lIGNvbnN0IGNoYXIgKmdldE5hbWUoKSBjb25zdDsKICAgICAgICAvKiogQ2FsbHMgTG9jYWxlJ3MgZXF1aXZhbGVudCBmdW5jdGlvbiAqLwogICAgICAgIGlubGluZSBjb25zdCBjaGFyICpnZXRJU08zTGFuZ3VhZ2UoKSBjb25zdDsKICAgICAgICAvKiogQ2FsbHMgTG9jYWxlJ3MgZXF1aXZhbGVudCBmdW5jdGlvbiAqLwogICAgICAgIGlubGluZSBjb25zdCBjaGFyICpnZXRJU08zQ291bnRyeSgpIGNvbnN0OwogICAgICAgIC8qKiBDYWxscyBMb2NhbGUncyBlcXVpdmFsZW50IGZ1bmN0aW9uICovCiAgICAgICAgaW5saW5lIHVpbnQzMl90IGdldExDSUQodm9pZCkgY29uc3Q7CiAgICAgICAgLyoqIENhbGxzIExvY2FsZSdzIGVxdWl2YWxlbnQgZnVuY3Rpb24gKi8KICAgICAgICBpbmxpbmUgVW5pY29kZVN0cmluZyYgIGdldERpc3BsYXlMYW5ndWFnZShVbmljb2RlU3RyaW5nJiAgIGRpc3BMYW5nKSBjb25zdDsKICAgICAgICAvKiogQ2FsbHMgTG9jYWxlJ3MgZXF1aXZhbGVudCBmdW5jdGlvbiAqLwogICAgICAgIGlubGluZSBVbmljb2RlU3RyaW5nJiAgZ2V0RGlzcGxheUxhbmd1YWdlKCBjb25zdCAgIExvY2FsZSYgICAgICAgICBpbkxvY2FsZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBkaXNwTGFuZykgY29uc3Q7CiAgICAgICAgLyoqIENhbGxzIExvY2FsZSdzIGVxdWl2YWxlbnQgZnVuY3Rpb24gKi8KICAgICAgICBpbmxpbmUgVW5pY29kZVN0cmluZyYgIGdldERpc3BsYXlDb3VudHJ5KCAgICAgICAgICBVbmljb2RlU3RyaW5nJiBkaXNwQ291bnRyeSkgY29uc3Q7CiAgICAgICAgLyoqIENhbGxzIExvY2FsZSdzIGVxdWl2YWxlbnQgZnVuY3Rpb24gKi8KICAgICAgICBpbmxpbmUgVW5pY29kZVN0cmluZyYgIGdldERpc3BsYXlDb3VudHJ5KCAgY29uc3QgICBMb2NhbGUmICAgICAgICAgaW5Mb2NhbGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVbmljb2RlU3RyaW5nJiAgZGlzcENvdW50cnkpIGNvbnN0OwogICAgICAgIC8qKiBDYWxscyBMb2NhbGUncyBlcXVpdmFsZW50IGZ1bmN0aW9uICovCiAgICAgICAgaW5saW5lIFVuaWNvZGVTdHJpbmcmICBnZXREaXNwbGF5VmFyaWFudCggICAgICBVbmljb2RlU3RyaW5nJiBkaXNwVmFyKSBjb25zdDsKICAgICAgICAvKiogQ2FsbHMgTG9jYWxlJ3MgZXF1aXZhbGVudCBmdW5jdGlvbiAqLwogICAgICAgIGlubGluZSBVbmljb2RlU3RyaW5nJiAgZ2V0RGlzcGxheVZhcmlhbnQoICBjb25zdCAgIExvY2FsZSYgICAgICAgICBpbkxvY2FsZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBkaXNwVmFyKSBjb25zdDsKCiAgICAgICAgLyoqIENhbGxzIExvY2FsZSdzIGVxdWl2YWxlbnQgZnVuY3Rpb24gKi8KICAgICAgICBpbmxpbmUgVW5pY29kZVN0cmluZyYgIGdldERpc3BsYXlOYW1lKCAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBuYW1lKSBjb25zdDsKICAgICAgICAvKiogQ2FsbHMgTG9jYWxlJ3MgZXF1aXZhbGVudCBmdW5jdGlvbiAqLwogICAgICAgIGlubGluZSBVbmljb2RlU3RyaW5nJiAgZ2V0RGlzcGxheU5hbWUoIGNvbnN0ICAgTG9jYWxlJiAgICAgICAgIGluTG9jYWxlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVbmljb2RlU3RyaW5nJiAgbmFtZSkgY29uc3Q7CiAgICAgICAgLyoqIENhbGxzIExvY2FsZSdzIGVxdWl2YWxlbnQgZnVuY3Rpb24gKi8KICAgICAgICBpbmxpbmUgaW50MzJfdCAgICAgICAgIGhhc2hDb2RlKHZvaWQpIGNvbnN0OwoKICAgICAgICAvKiogQ2FzdCBhIExvY2FsZVByb3h5IGludG8gYSBMb2NhbGUuIFRoaXMgaXMgdGhlIG1hZ2ljIGJlaGluZCB0aGlzIHByb3h5LiAqLwogICAgICAgIG9wZXJhdG9yIGNvbnN0IExvY2FsZSYoKSBjb25zdDsKICAgIH0gTG9jYWxlUHJveHk7CgogICAgLyoqCiAgICAgKiBVc2VmdWwgY29uc3RhbnRzIGZvciBsYW5ndWFnZS4KICAgICAqLwogICAgLyogQGRlcHJlY2F0ZWQgUmVtb3ZlIGFmdGVyIDIwMDItYXVnLTMxLiBVc2UgZ2V0RW5nbGlzaCgpIGluc3RlYWQuKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGVQcm94eSBFTkdMSVNIOwogICAgLyogQGRlcHJlY2F0ZWQgUmVtb3ZlIGFmdGVyIDIwMDItYXVnLTMxLiBVc2UgZ2V0RnJlbmNoKCkgaW5zdGVhZC4qLwogICAgc3RhdGljIGNvbnN0IExvY2FsZVByb3h5IEZSRU5DSDsKICAgIC8qIEBkZXByZWNhdGVkIFJlbW92ZSBhZnRlciAyMDAyLWF1Zy0zMS4gVXNlIGdldEdlcm1hbigpIGluc3RlYWQuKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGVQcm94eSBHRVJNQU47CiAgICAvKiBAZGVwcmVjYXRlZCBSZW1vdmUgYWZ0ZXIgMjAwMi1hdWctMzEuIFVzZSBnZXRJdGFsaWFuKCkgaW5zdGVhZC4qLwogICAgc3RhdGljIGNvbnN0IExvY2FsZVByb3h5IElUQUxJQU47CiAgICAvKiBAZGVwcmVjYXRlZCBSZW1vdmUgYWZ0ZXIgMjAwMi1hdWctMzEuIFVzZSBnZXRKYXBhbmVzZSgpIGluc3RlYWQuKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGVQcm94eSBKQVBBTkVTRTsKICAgIC8qIEBkZXByZWNhdGVkIFJlbW92ZSBhZnRlciAyMDAyLWF1Zy0zMS4gVXNlIGdldEtvcmVhbigpIGluc3RlYWQuKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGVQcm94eSBLT1JFQU47CiAgICAvKiBAZGVwcmVjYXRlZCBSZW1vdmUgYWZ0ZXIgMjAwMi1hdWctMzEuIFVzZSBnZXRDaGluZXNlKCkgaW5zdGVhZC4qLwogICAgc3RhdGljIGNvbnN0IExvY2FsZVByb3h5IENISU5FU0U7CiAgICAvKiBAZGVwcmVjYXRlZCBSZW1vdmUgYWZ0ZXIgMjAwMi1hdWctMzEuIFVzZSBnZXRTaW1wbGlmaWVkQ2hpbmVzZSgpIGluc3RlYWQuKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGVQcm94eSBTSU1QTElGSUVEX0NISU5FU0U7CiAgICAvKiBAZGVwcmVjYXRlZCBSZW1vdmUgYWZ0ZXIgMjAwMi1hdWctMzEuIFVzZSBnZXRUcmFkaXRpb25hbENoaW5lc2UoKSBpbnN0ZWFkLiovCiAgICBzdGF0aWMgY29uc3QgTG9jYWxlUHJveHkgVFJBRElUSU9OQUxfQ0hJTkVTRTsKCiAgICAvKioKICAgICAqIFVzZWZ1bCBjb25zdGFudHMgZm9yIGNvdW50cnkuCiAgICAgKi8KICAgIC8qIEBkZXByZWNhdGVkIFJlbW92ZSBhZnRlciAyMDAyLWF1Zy0zMS4gVXNlIGdldEZyYW5jZSgpIGluc3RlYWQuKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGVQcm94eSBGUkFOQ0U7CiAgICAvKiBAZGVwcmVjYXRlZCBSZW1vdmUgYWZ0ZXIgMjAwMi1hdWctMzEuIFVzZSBnZXRHZXJtYW55KCkgaW5zdGVhZC4qLwogICAgc3RhdGljIGNvbnN0IExvY2FsZVByb3h5IEdFUk1BTlk7CiAgICAvKiBAZGVwcmVjYXRlZCBSZW1vdmUgYWZ0ZXIgMjAwMi1hdWctMzEuIFVzZSBnZXRJdGFseSgpIGluc3RlYWQuKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGVQcm94eSBJVEFMWTsKICAgIC8qIEBkZXByZWNhdGVkIFJlbW92ZSBhZnRlciAyMDAyLWF1Zy0zMS4gVXNlIGdldEphcGFuKCkgaW5zdGVhZC4qLwogICAgc3RhdGljIGNvbnN0IExvY2FsZVByb3h5IEpBUEFOOwogICAgLyogQGRlcHJlY2F0ZWQgUmVtb3ZlIGFmdGVyIDIwMDItYXVnLTMxLiBVc2UgZ2V0S29yZWEoKSBpbnN0ZWFkLiovCiAgICBzdGF0aWMgY29uc3QgTG9jYWxlUHJveHkgS09SRUE7CiAgICAvKiBAZGVwcmVjYXRlZCBSZW1vdmUgYWZ0ZXIgMjAwMi1hdWctMzEuIFVzZSBnZXRDaGluYSgpIGluc3RlYWQuKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGVQcm94eSBDSElOQTsgICAgICAvKiBBbGlhcyBmb3IgUFJDICovCiAgICAvKiBAZGVwcmVjYXRlZCBSZW1vdmUgYWZ0ZXIgMjAwMi1hdWctMzEuIFVzZSBnZXRQUkMoKSBpbnN0ZWFkLiovCiAgICBzdGF0aWMgY29uc3QgTG9jYWxlUHJveHkgUFJDOyAgICAgICAgLyogUGVvcGxlcyBSZXB1YmxpYyBvZiBDaGluYSAqLwogICAgLyogQGRlcHJlY2F0ZWQgUmVtb3ZlIGFmdGVyIDIwMDItYXVnLTMxLiBVc2UgZ2V0VGFpd2FuKCkgaW5zdGVhZC4qLwogICAgc3RhdGljIGNvbnN0IExvY2FsZVByb3h5IFRBSVdBTjsKICAgIC8qIEBkZXByZWNhdGVkIFJlbW92ZSBhZnRlciAyMDAyLWF1Zy0zMS4gVXNlIGdldFVLKCkgaW5zdGVhZC4qLwogICAgc3RhdGljIGNvbnN0IExvY2FsZVByb3h5IFVLOwogICAgLyogQGRlcHJlY2F0ZWQgUmVtb3ZlIGFmdGVyIDIwMDItYXVnLTMxLiBVc2UgZ2V0VVMoKSBpbnN0ZWFkLiovCiAgICBzdGF0aWMgY29uc3QgTG9jYWxlUHJveHkgVVM7CiAgICAvKiBAZGVwcmVjYXRlZCBSZW1vdmUgYWZ0ZXIgMjAwMi1hdWctMzEuIFVzZSBnZXRDYW5hZGEoKSBpbnN0ZWFkLiovCiAgICBzdGF0aWMgY29uc3QgTG9jYWxlUHJveHkgQ0FOQURBOwogICAgLyogQGRlcHJlY2F0ZWQgUmVtb3ZlIGFmdGVyIDIwMDItYXVnLTMxLiBVc2UgZ2V0Q2FuYWRhRnJlbmNoKCkgaW5zdGVhZC4qLwogICAgc3RhdGljIGNvbnN0IExvY2FsZVByb3h5IENBTkFEQV9GUkVOQ0g7CgojZW5kaWYgLyogSUNVX0xPQ0lEX1VTRV9ERVBSRUNBVEVTICovCgogICAgLyoqIFVzZWZ1bCBjb25zdGFudCBmb3IgdGhpcyBsYW5ndWFnZS4gKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgJmdldEVuZ2xpc2godm9pZCk7CiAgICAvKiogVXNlZnVsIGNvbnN0YW50IGZvciB0aGlzIGxhbmd1YWdlLiAqLwogICAgc3RhdGljIGNvbnN0IExvY2FsZSAmZ2V0RnJlbmNoKHZvaWQpOwogICAgLyoqIFVzZWZ1bCBjb25zdGFudCBmb3IgdGhpcyBsYW5ndWFnZS4gKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgJmdldEdlcm1hbih2b2lkKTsKICAgIC8qKiBVc2VmdWwgY29uc3RhbnQgZm9yIHRoaXMgbGFuZ3VhZ2UuICovCiAgICBzdGF0aWMgY29uc3QgTG9jYWxlICZnZXRJdGFsaWFuKHZvaWQpOwogICAgLyoqIFVzZWZ1bCBjb25zdGFudCBmb3IgdGhpcyBsYW5ndWFnZS4gKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgJmdldEphcGFuZXNlKHZvaWQpOwogICAgLyoqIFVzZWZ1bCBjb25zdGFudCBmb3IgdGhpcyBsYW5ndWFnZS4gKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgJmdldEtvcmVhbih2b2lkKTsKICAgIC8qKiBVc2VmdWwgY29uc3RhbnQgZm9yIHRoaXMgbGFuZ3VhZ2UuICovCiAgICBzdGF0aWMgY29uc3QgTG9jYWxlICZnZXRDaGluZXNlKHZvaWQpOwogICAgLyoqIFVzZWZ1bCBjb25zdGFudCBmb3IgdGhpcyBsYW5ndWFnZS4gKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgJmdldFNpbXBsaWZpZWRDaGluZXNlKHZvaWQpOwogICAgLyoqIFVzZWZ1bCBjb25zdGFudCBmb3IgdGhpcyBsYW5ndWFnZS4gKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgJmdldFRyYWRpdGlvbmFsQ2hpbmVzZSh2b2lkKTsKCiAgICAvKiogVXNlZnVsIGNvbnN0YW50IGZvciB0aGlzIGNvdW50cnkvcmVnaW9uLiAqLwogICAgc3RhdGljIGNvbnN0IExvY2FsZSAmZ2V0RnJhbmNlKHZvaWQpOwogICAgLyoqIFVzZWZ1bCBjb25zdGFudCBmb3IgdGhpcyBjb3VudHJ5L3JlZ2lvbi4gKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgJmdldEdlcm1hbnkodm9pZCk7CiAgICAvKiogVXNlZnVsIGNvbnN0YW50IGZvciB0aGlzIGNvdW50cnkvcmVnaW9uLiAqLwogICAgc3RhdGljIGNvbnN0IExvY2FsZSAmZ2V0SXRhbHkodm9pZCk7CiAgICAvKiogVXNlZnVsIGNvbnN0YW50IGZvciB0aGlzIGNvdW50cnkvcmVnaW9uLiAqLwogICAgc3RhdGljIGNvbnN0IExvY2FsZSAmZ2V0SmFwYW4odm9pZCk7CiAgICAvKiogVXNlZnVsIGNvbnN0YW50IGZvciB0aGlzIGNvdW50cnkvcmVnaW9uLiAqLwogICAgc3RhdGljIGNvbnN0IExvY2FsZSAmZ2V0S29yZWEodm9pZCk7CiAgICAvKiogVXNlZnVsIGNvbnN0YW50IGZvciB0aGlzIGNvdW50cnkvcmVnaW9uLiAqLwogICAgc3RhdGljIGNvbnN0IExvY2FsZSAmZ2V0Q2hpbmEodm9pZCk7CiAgICAvKiogVXNlZnVsIGNvbnN0YW50IGZvciB0aGlzIGNvdW50cnkvcmVnaW9uLiAqLwogICAgc3RhdGljIGNvbnN0IExvY2FsZSAmZ2V0UFJDKHZvaWQpOwogICAgLyoqIFVzZWZ1bCBjb25zdGFudCBmb3IgdGhpcyBjb3VudHJ5L3JlZ2lvbi4gKi8KICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgJmdldFRhaXdhbih2b2lkKTsKICAgIC8qKiBVc2VmdWwgY29uc3RhbnQgZm9yIHRoaXMgY291bnRyeS9yZWdpb24uICovCiAgICBzdGF0aWMgY29uc3QgTG9jYWxlICZnZXRVSyh2b2lkKTsKICAgIC8qKiBVc2VmdWwgY29uc3RhbnQgZm9yIHRoaXMgY291bnRyeS9yZWdpb24uICovCiAgICBzdGF0aWMgY29uc3QgTG9jYWxlICZnZXRVUyh2b2lkKTsKICAgIC8qKiBVc2VmdWwgY29uc3RhbnQgZm9yIHRoaXMgY291bnRyeS9yZWdpb24uICovCiAgICBzdGF0aWMgY29uc3QgTG9jYWxlICZnZXRDYW5hZGEodm9pZCk7CiAgICAvKiogVXNlZnVsIGNvbnN0YW50IGZvciB0aGlzIGNvdW50cnkvcmVnaW9uLiAqLwogICAgc3RhdGljIGNvbnN0IExvY2FsZSAmZ2V0Q2FuYWRhRnJlbmNoKHZvaWQpOwoKCiAgIC8qKgogICAgKiBDb25zdHJ1Y3QgYW4gZW1wdHkgbG9jYWxlLiBJdCdzIG9ubHkgdXNlZCB3aGVuIGEgZmlsbC1pbiBwYXJhbWV0ZXIgaXMKICAgICogbmVlZGVkLgogICAgKiBAc3RhYmxlCiAgICAqLwogICAgTG9jYWxlKCk7IAoKICAgIC8qKgogICAgICogQ29uc3RydWN0IGEgbG9jYWxlIGZyb20gbGFuZ3VhZ2UsIGNvdW50cnksIHZhcmlhbnQuCiAgICAgKgogICAgICogQHBhcmFtIGxhbmd1YWdlIExvd2VyY2FzZSB0d28tbGV0dGVyIElTTy02MzkgY29kZS4gIFRoaXMgcGFyYW1ldGVyIGNhbgogICAgICogIGluc3RlYWQgYmUgYW4gSUNVIHN0eWxlIEMgbG9jYWxlIChlLmcuICJlbl9VUyIpLCBidXQgdGhlIG90aGVyCiAgICAgKiAgcGFyYW1ldGVycyBtdXN0IG5vdCBiZSB1c2VkLgogICAgICogQHBhcmFtIGNvdW50cnkgIFVwcGVyY2FzZSB0d28tbGV0dGVyIElTTy0zMTY2IGNvZGUuIChvcHRpb25hbCkKICAgICAqIEBwYXJhbSB2YXJpYW50ICBVcHBlcmNhc2UgdmVuZG9yIGFuZCBicm93c2VyIHNwZWNpZmljIGNvZGUuIFNlZSBjbGFzcwogICAgICogICAgICAgICAgICAgICAgIGRlc2NyaXB0aW9uLiAob3B0aW9uYWwpCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgIExvY2FsZSggY29uc3QgICBjaGFyICogbGFuZ3VhZ2UsCiAgICAgICAgICAgIGNvbnN0ICAgY2hhciAqIGNvdW50cnkgID0gMCwgCiAgICAgICAgICAgIGNvbnN0ICAgY2hhciAqIHZhcmlhbnQgID0gMCk7CgogICAgLyoqCiAgICAgKiBJbml0aWFsaXplcyBhIExvY2FsZSBvYmplY3QgZnJvbSBhbm90aGVyIExvY2FsZSBvYmplY3QuCiAgICAgKgogICAgICogQHBhcmFtIG90aGVyIFRoZSBMb2NhbGUgb2JqZWN0IGJlaW5nIGNvcGllZCBpbi4KICAgICAqIEBzdGFibGUKICAgICAqLwogICAgTG9jYWxlKGNvbnN0ICAgIExvY2FsZSYgb3RoZXIpOwoKCiAgICAvKioKICAgICAqIERlc3RydWN0b3IKICAgICAqIEBzdGFibGUKICAgICAqLwogICAgfkxvY2FsZSgpIDsKCiAgICAvKioKICAgICAqIFJlcGxhY2VzIHRoZSBlbnRpcmUgY29udGVudHMgb2YgKnRoaXMgd2l0aCB0aGUgc3BlY2lmaWVkIHZhbHVlLgogICAgICoKICAgICAqIEBwYXJhbSBvdGhlciBUaGUgTG9jYWxlIG9iamVjdCBiZWluZyBjb3BpZWQgaW4uCiAgICAgKiBAcmV0dXJuICAgICAgKnRoaXMKICAgICAqIEBzdGFibGUKICAgICAqLwogICAgTG9jYWxlJiBvcGVyYXRvcj0oY29uc3QgTG9jYWxlJiBvdGhlcik7CgogICAgLyoqCiAgICAgKiBDaGVja3MgaWYgdHdvIGxvY2FsZSBrZXlzIGFyZSB0aGUgc2FtZS4KICAgICAqCiAgICAgKiBAcGFyYW0gb3RoZXIgVGhlIGxvY2FsZSBrZXkgb2JqZWN0IHRvIGJlIGNvbXBhcmVkIHdpdGggdGhpcy4KICAgICAqIEByZXR1cm4gICAgICBUcnVlIGlmIHRoZSB0d28gbG9jYWxlIGtleXMgYXJlIHRoZSBzYW1lLCBmYWxzZSBvdGhlcndpc2UuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgIFVCb29sICAgb3BlcmF0b3I9PShjb25zdCAgICBMb2NhbGUmICAgICBvdGhlcikgY29uc3Q7CgogICAgLyoqCiAgICAgKiBDaGVja3MgaWYgdHdvIGxvY2FsZSBrZXlzIGFyZSBub3QgdGhlIHNhbWUuCiAgICAgKgogICAgICogQHBhcmFtIG90aGVyIFRoZSBsb2NhbGUga2V5IG9iamVjdCB0byBiZSBjb21wYXJlZCB3aXRoIHRoaXMuCiAgICAgKiBAcmV0dXJuICAgICAgVHJ1ZSBpZiB0aGUgdHdvIGxvY2FsZSBrZXlzIGFyZSBub3QgdGhlIHNhbWUsIGZhbHNlCiAgICAgKiAgICAgICAgICAgICAgb3RoZXJ3aXNlLgogICAgICogQHN0YWJsZQogICAgICovCiAgICBVQm9vbCAgIG9wZXJhdG9yIT0oY29uc3QgICAgTG9jYWxlJiAgICAgb3RoZXIpIGNvbnN0OwoKICAgIC8qKgogICAgICogQ29tbW9uIG1ldGhvZHMgb2YgZ2V0dGluZyB0aGUgY3VycmVudCBkZWZhdWx0IExvY2FsZS4gVXNlZCBmb3IgdGhlCiAgICAgKiBwcmVzZW50YXRpb246IG1lbnVzLCBkaWFsb2dzLCBldGMuIEdlbmVyYWxseSBzZXQgb25jZSB3aGVuIHlvdXIgYXBwbGV0IG9yCiAgICAgKiBhcHBsaWNhdGlvbiBpcyBpbml0aWFsaXplZCwgdGhlbiBuZXZlciByZXNldC4gKElmIHlvdSBkbyByZXNldCB0aGUKICAgICAqIGRlZmF1bHQgbG9jYWxlLCB5b3UgcHJvYmFibHkgd2FudCB0byByZWxvYWQgeW91ciBHVUksIHNvIHRoYXQgdGhlIGNoYW5nZQogICAgICogaXMgcmVmbGVjdGVkIGluIHlvdXIgaW50ZXJmYWNlLikKICAgICAqCiAgICAgKiBNb3JlIGFkdmFuY2VkIHByb2dyYW1zIHdpbGwgYWxsb3cgdXNlcnMgdG8gdXNlIGRpZmZlcmVudCBsb2NhbGVzIGZvcgogICAgICogZGlmZmVyZW50IGZpZWxkcywgZS5nLiBpbiBhIHNwcmVhZHNoZWV0LgogICAgICoKICAgICAqIE5vdGUgdGhhdCB0aGUgaW5pdGlhbCBzZXR0aW5nIHdpbGwgbWF0Y2ggdGhlIGhvc3Qgc3lzdGVtLgogICAgICogQHN5c3RlbQogICAgICogQHN0YWJsZQogICAgICovCiAgICBzdGF0aWMgIGNvbnN0IExvY2FsZSYgZ2V0RGVmYXVsdCh2b2lkKTsKCiAgICAvKioKICAgICAqIFNldHMgdGhlIGRlZmF1bHQuIE5vcm1hbGx5IHNldCBvbmNlIGF0IHRoZSBiZWdpbm5pbmcgb2YgYXBwbGV0IG9yCiAgICAgKiBhcHBsaWNhdGlvbiwgdGhlbiBuZXZlciByZXNldC4gc2V0RGVmYXVsdCBkb2VzIE5PVCByZXNldCB0aGUgaG9zdCBsb2NhbGUuCiAgICAgKgogICAgICogQHBhcmFtIG5ld0xvY2FsZSBMb2NhbGUgdG8gc2V0IHRvLgogICAgICogQHN5c3RlbQogICAgICogQHN0YWJsZQogICAgICovCiAgICBzdGF0aWMgIHZvaWQgICAgc2V0RGVmYXVsdChjb25zdCAgICBMb2NhbGUmICAgICBuZXdMb2NhbGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVRXJyb3JDb2RlJiAgc3VjY2Vzcyk7CgogICAgCiAgICAvKioKICAgICAqIENyZWF0ZXMgYSBsb2NhbGUgd2hpY2ggaGFzIGhhZCBtaW5pbWFsIGNhbm9uaWNhbGl6YXRpb24gCiAgICAgKiBhcyBwZXIgdWxvY19nZXROYW1lKCkuIAogICAgICogQHBhcmFtIG5hbWUgVGhlIG5hbWUgdG8gY3JlYXRlIGZyb20uICBJZiBuYW1lIGlzIG51bGwsCiAgICAgKiAgdGhlIGRlZmF1bHQgTG9jYWxlIGlzIHVzZWQuCiAgICAgKiBAcmV0dXJuIG5ldyBsb2NhbGUgb2JqZWN0CiAgICAgKiBAc3RhYmxlCiAgICAgKiBAc2VlIHVsb2NfZ2V0TmFtZQogICAgICovCiAgICBzdGF0aWMgTG9jYWxlIGNyZWF0ZUZyb21OYW1lKGNvbnN0IGNoYXIgKm5hbWUpOwoKICAgIAogICAgLyoqCiAgICAgKiBSZXR1cm5zIHRoZSBsb2NhbGUncyBJU08tNjM5IGxhbmd1YWdlIGNvZGUuCiAgICAgKiBAcmV0dXJuICAgICAgQW4gYWxpYXMgdG8gdGhlIGNvZGUKICAgICAqIEBzdGFibGUKICAgICAqLwogICAgaW5saW5lIGNvbnN0IGNoYXIgKiAgZ2V0TGFuZ3VhZ2UoICkgY29uc3Q7CgogICAgLyoqCiAgICAgKiBSZXR1cm5zIHRoZSBsb2NhbGUncyBJU08tMzE2NiBjb3VudHJ5IGNvZGUuCiAgICAgKiBAcmV0dXJuICAgICAgQW4gYWxpYXMgdG8gdGhlIGNvZGUKICAgICAqIEBzdGFibGUKICAgICAqLwogICAgaW5saW5lIGNvbnN0IGNoYXIgKiAgZ2V0Q291bnRyeSggKSBjb25zdDsKCiAgICAvKioKICAgICAqIFJldHVybnMgdGhlIGxvY2FsZSdzIHZhcmlhbnQgY29kZS4KICAgICAqIEByZXR1cm4gICAgICBBbiBhbGlhcyB0byB0aGUgY29kZQogICAgICogQHN0YWJsZQogICAgICovCiAgICBpbmxpbmUgY29uc3QgY2hhciAqICBnZXRWYXJpYW50KCApIGNvbnN0OwoKICAgIC8qKgogICAgICogUmV0dXJucyB0aGUgcHJvZ3JhbW1hdGljIG5hbWUgb2YgdGhlIGVudGlyZSBsb2NhbGUsIHdpdGggdGhlIGxhbmd1YWdlLAogICAgICogY291bnRyeSBhbmQgdmFyaWFudCBzZXBhcmF0ZWQgYnkgdW5kZXJiYXJzLiBJZiBhIGZpZWxkIGlzIG1pc3NpbmcsIHVwCiAgICAgKiB0byB0d28gbGVhZGluZyB1bmRlcmJhcnMgd2lsbCBvY2N1ci4gRXhhbXBsZTogImVuIiwgImRlX0RFIiwgImVuX1VTX1dJTiIsCiAgICAgKiAiZGVfX1BPU0lYIiwgImZyX19NQUMiLCAiX19NQUMiLCAiX01UIiwgIl9GUl9FVVJPIgogICAgICogQHJldHVybiAgICAgIEEgcG9pbnRlciB0byAibmFtZSIuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgIGlubGluZSBjb25zdCBjaGFyICogZ2V0TmFtZSgpIGNvbnN0OwoKICAgIC8qKgogICAgICogcmV0dXJucyB0aGUgbG9jYWxlJ3MgdGhyZWUtbGV0dGVyIGxhbmd1YWdlIGNvZGUsIGFzIHNwZWNpZmllZAogICAgICogaW4gSVNPIGRyYWZ0IHN0YW5kYXJkIElTTy02MzktMi4uCiAgICAgKiBAcmV0dXJuICAgICAgQW4gYWxpYXMgdG8gdGhlIGNvZGUsIG9yIE5VTEwKICAgICAqIEBzdGFibGUKICAgICAqLwogICAgY29uc3QgY2hhciAqIGdldElTTzNMYW5ndWFnZSgpIGNvbnN0OwoKICAgIC8qKgogICAgICogRmlsbHMgaW4gIm5hbWUiIHdpdGggdGhlIGxvY2FsZSdzIHRocmVlLWxldHRlciBJU08tMzE2NiBjb3VudHJ5IGNvZGUuCiAgICAgKiBAcmV0dXJuICAgICAgQW4gYWxpYXMgdG8gdGhlIGNvZGUsIG9yIE5VTEwKICAgICAqIEBzdGFibGUKICAgICAqLwogICAgY29uc3QgY2hhciAqIGdldElTTzNDb3VudHJ5KCkgY29uc3Q7CgogICAgLyoqCiAgICAgKiBSZXR1cm5zIHRoZSBXaW5kb3dzIExDSUQgdmFsdWUgY29ycmVzcG9uZGluZyB0byB0aGlzIGxvY2FsZS4KICAgICAqIFRoaXMgdmFsdWUgaXMgc3RvcmVkIGluIHRoZSByZXNvdXJjZSBkYXRhIGZvciB0aGUgbG9jYWxlIGFzIGEgb25lLXRvLWZvdXItZGlnaXQKICAgICAqIGhleGFkZWNpbWFsIG51bWJlci4gIElmIHRoZSByZXNvdXJjZSBpcyBtaXNzaW5nLCBpbiB0aGUgd3JvbmcgZm9ybWF0LCBvcgogICAgICogdGhlcmUgaXMgbm8gV2luZG93cyBMQ0lEIHZhbHVlIHRoYXQgY29ycmVzcG9uZHMgdG8gdGhpcyBsb2NhbGUsIHJldHVybnMgMC4KICAgICAqIEBzdGFibGUKICAgICAqLwogICAgdWludDMyX3QgICAgICAgIGdldExDSUQodm9pZCkgY29uc3Q7CgogICAgLyoqCiAgICAgKiBGaWxscyBpbiAiZGlzcExhbmciIHdpdGggdGhlIG5hbWUgb2YgdGhpcyBsb2NhbGUncyBsYW5ndWFnZSBpbiBhIGZvcm1hdCBzdWl0YWJsZSBmb3IKICAgICAqIHVzZXIgZGlzcGxheSBpbiB0aGUgZGVmYXVsdCBsb2NhbGUuICBGb3IgZXhhbXBsZSwgaWYgdGhlIGxvY2FsZSdzIGxhbmd1YWdlIGNvZGUgaXMKICAgICAqICJmciIgYW5kIHRoZSBkZWZhdWx0IGxvY2FsZSdzIGxhbmd1YWdlIGNvZGUgaXMgImVuIiwgdGhpcyBmdW5jdGlvbiB3b3VsZCBzZXQKICAgICAqIGRpc3BMYW5nIHRvICJGcmVuY2giLgogICAgICogQHBhcmFtIGRpc3BMYW5nICBSZWNlaXZlcyB0aGUgbGFuZ3VhZ2UncyBkaXNwbGF5IG5hbWUuCiAgICAgKiBAcmV0dXJuICAgICAgICAgIEEgcmVmZXJlbmNlIHRvICJkaXNwTGFuZyIuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgIFVuaWNvZGVTdHJpbmcmICBnZXREaXNwbGF5TGFuZ3VhZ2UoVW5pY29kZVN0cmluZyYgICBkaXNwTGFuZykgY29uc3Q7CgogICAgLyoqCiAgICAgKiBGaWxscyBpbiAiZGlzcExhbmciIHdpdGggdGhlIG5hbWUgb2YgdGhpcyBsb2NhbGUncyBsYW5ndWFnZSBpbiBhIGZvcm1hdCBzdWl0YWJsZSBmb3IKICAgICAqIHVzZXIgZGlzcGxheSBpbiB0aGUgbG9jYWxlIHNwZWNpZmllZCBieSAiaW5Mb2NhbGUiLiAgRm9yIGV4YW1wbGUsIGlmIHRoZSBsb2NhbGUncwogICAgICogbGFuZ3VhZ2UgY29kZSBpcyAiZW4iIGFuZCBpbkxvY2FsZSdzIGxhbmd1YWdlIGNvZGUgaXMgImZyIiwgdGhpcyBmdW5jdGlvbiB3b3VsZCBzZXQKICAgICAqIGRpc3BMYW5nIHRvICJBbmdsYWlzIi4KICAgICAqIEBwYXJhbSBpbkxvY2FsZSAgU3BlY2lmaWVzIHRoZSBsb2NhbGUgdG8gYmUgdXNlZCB0byBkaXNwbGF5IHRoZSBuYW1lLiAgSW4gb3RoZXIgd29yZHMsCiAgICAgKiAgICAgICAgICAgICAgICAgIGlmIHRoZSBsb2NhbGUncyBsYW5ndWFnZSBjb2RlIGlzICJlbiIsIHBhc3NpbmcgTG9jYWxlOjpnZXRGcmVuY2goKSBmb3IKICAgICAqICAgICAgICAgICAgICAgICAgaW5Mb2NhbGUgd291bGQgcmVzdWx0IGluICJBbmdsYWlzIiwgd2hpbGUgcGFzc2luZyBMb2NhbGU6OmdldEdlcm1hbigpCiAgICAgKiAgICAgICAgICAgICAgICAgIGZvciBpbkxvY2FsZSB3b3VsZCByZXN1bHQgaW4gIkVuZ2xpc2NoIi4KICAgICAqIEBwYXJhbSBkaXNwTGFuZyAgUmVjZWl2ZXMgdGhlIGxhbmd1YWdlJ3MgZGlzcGxheSBuYW1lLgogICAgICogQHJldHVybiAgICAgICAgICBBIHJlZmVyZW5jZSB0byAiZGlzcExhbmciLgogICAgICogQHN0YWJsZQogICAgICovCiAgICBVbmljb2RlU3RyaW5nJiAgZ2V0RGlzcGxheUxhbmd1YWdlKCBjb25zdCAgIExvY2FsZSYgICAgICAgICBpbkxvY2FsZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVW5pY29kZVN0cmluZyYgIGRpc3BMYW5nKSBjb25zdDsKCiAgICAvKioKICAgICAqIEZpbGxzIGluICJkaXNwQ291bnRyeSIgd2l0aCB0aGUgbmFtZSBvZiB0aGlzIGxvY2FsZSdzIGNvdW50cnkgaW4gYSBmb3JtYXQgc3VpdGFibGUKICAgICAqIGZvciB1c2VyIGRpc3BsYXkgaW4gdGhlIGRlZmF1bHQgbG9jYWxlLiAgRm9yIGV4YW1wbGUsIGlmIHRoZSBsb2NhbGUncyBjb3VudHJ5IGNvZGUKICAgICAqIGlzICJGUiIgYW5kIHRoZSBkZWZhdWx0IGxvY2FsZSdzIGxhbmd1YWdlIGNvZGUgaXMgImVuIiwgdGhpcyBmdW5jdGlvbiB3b3VsZCBzZXQKICAgICAqIGRpc3BDb3VudHJ5IHRvICJGcmFuY2UiLgogICAgICogQHBhcmFtIGRpc3BDb3VudHJ5ICAgUmVjZWl2ZXMgdGhlIGNvdW50cnkncyBkaXNwbGF5IG5hbWUuCiAgICAgKiBAcmV0dXJuICAgICAgICAgICAgICBBIHJlZmVyZW5jZSB0byAiZGlzcENvdW50cnkiLgogICAgICogQHN0YWJsZQogICAgICovCiAgICBVbmljb2RlU3RyaW5nJiAgZ2V0RGlzcGxheUNvdW50cnkoICAgICAgICAgIFVuaWNvZGVTdHJpbmcmIGRpc3BDb3VudHJ5KSBjb25zdDsKCiAgICAvKioKICAgICAqIEZpbGxzIGluICJkaXNwQ291bnRyeSIgd2l0aCB0aGUgbmFtZSBvZiB0aGlzIGxvY2FsZSdzIGNvdW50cnkgaW4gYSBmb3JtYXQgc3VpdGFibGUKICAgICAqIGZvciB1c2VyIGRpc3BsYXkgaW4gdGhlIGxvY2FsZSBzcGVjaWZpZWQgYnkgImluTG9jYWxlIi4gIEZvciBleGFtcGxlLCBpZiB0aGUgbG9jYWxlJ3MKICAgICAqIGNvdW50cnkgY29kZSBpcyAiVVMiIGFuZCBpbkxvY2FsZSdzIGxhbmd1YWdlIGNvZGUgaXMgImZyIiwgdGhpcyBmdW5jdGlvbiB3b3VsZCBzZXQKICAgICAqIGRpc3BDb3VudHJ5IHRvICJFdGF0cy1VbmlzIi4KICAgICAqIEBwYXJhbSBpbkxvY2FsZSAgICAgIFNwZWNpZmllcyB0aGUgbG9jYWxlIHRvIGJlIHVzZWQgdG8gZGlzcGxheSB0aGUgbmFtZS4gIEluIG90aGVyCiAgICAgKiAgICAgICAgICAgICAgICAgICAgICB3b3JkcywgaWYgdGhlIGxvY2FsZSdzIGNvdW50cnkgY29kZSBpcyAiVVMiLCBwYXNzaW5nCiAgICAgKiAgICAgICAgICAgICAgICAgICAgICBMb2NhbGU6OmdldEZyZW5jaCgpIGZvciBpbkxvY2FsZSB3b3VsZCByZXN1bHQgaW4gIsl0YXRzLVVuaXMiLCB3aGlsZQogICAgICogICAgICAgICAgICAgICAgICAgICAgcGFzc2luZyBMb2NhbGU6OmdldEdlcm1hbigpIGZvciBpbkxvY2FsZSB3b3VsZCByZXN1bHQgaW4KICAgICAqICAgICAgICAgICAgICAgICAgICAgICJWZXJlaW5pZ3RlIFN0YWF0ZW4iLgogICAgICogQHBhcmFtIGRpc3BDb3VudHJ5ICAgUmVjZWl2ZXMgdGhlIGNvdW50cnkncyBkaXNwbGF5IG5hbWUuCiAgICAgKiBAcmV0dXJuICAgICAgICAgICAgICBBIHJlZmVyZW5jZSB0byAiZGlzcENvdW50cnkiLgogICAgICogQHN0YWJsZQogICAgICovCiAgICBVbmljb2RlU3RyaW5nJiAgZ2V0RGlzcGxheUNvdW50cnkoICBjb25zdCAgIExvY2FsZSYgICAgICAgICBpbkxvY2FsZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVW5pY29kZVN0cmluZyYgIGRpc3BDb3VudHJ5KSBjb25zdDsKCiAgICAvKioKICAgICAqIEZpbGxzIGluICJkaXNwVmFyIiB3aXRoIHRoZSBuYW1lIG9mIHRoaXMgbG9jYWxlJ3MgdmFyaWFudCBjb2RlIGluIGEgZm9ybWF0IHN1aXRhYmxlCiAgICAgKiBmb3IgdXNlciBkaXNwbGF5IGluIHRoZSBkZWZhdWx0IGxvY2FsZS4KICAgICAqIEBwYXJhbSBkaXNwVmFyICAgUmVjZWl2ZXMgdGhlIHZhcmlhbnQncyBuYW1lLgogICAgICogQHJldHVybiAgICAgICAgICBBIHJlZmVyZW5jZSB0byAiZGlzcFZhciIuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgIFVuaWNvZGVTdHJpbmcmICBnZXREaXNwbGF5VmFyaWFudCggICAgICBVbmljb2RlU3RyaW5nJiBkaXNwVmFyKSBjb25zdDsKCiAgICAvKioKICAgICAqIEZpbGxzIGluICJkaXNwVmFyIiB3aXRoIHRoZSBuYW1lIG9mIHRoaXMgbG9jYWxlJ3MgdmFyaWFudCBjb2RlIGluIGEgZm9ybWF0CiAgICAgKiBzdWl0YWJsZSBmb3IgdXNlciBkaXNwbGF5IGluIHRoZSBsb2NhbGUgc3BlY2lmaWVkIGJ5ICJpbkxvY2FsZSIuCiAgICAgKiBAcGFyYW0gaW5Mb2NhbGUgIFNwZWNpZmllcyB0aGUgbG9jYWxlIHRvIGJlIHVzZWQgdG8gZGlzcGxheSB0aGUgbmFtZS4KICAgICAqIEBwYXJhbSBkaXNwVmFyICAgUmVjZWl2ZXMgdGhlIHZhcmlhbnQncyBkaXNwbGF5IG5hbWUuCiAgICAgKiBAcmV0dXJuICAgICAgICAgIEEgcmVmZXJlbmNlIHRvICJkaXNwVmFyIi4KICAgICAqIEBzdGFibGUKICAgICAqLwogICAgVW5pY29kZVN0cmluZyYgIGdldERpc3BsYXlWYXJpYW50KCAgY29uc3QgICBMb2NhbGUmICAgICAgICAgaW5Mb2NhbGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBkaXNwVmFyKSBjb25zdDsKCiAgICAvKioKICAgICAqIEZpbGxzIGluICJuYW1lIiB3aXRoIHRoZSBuYW1lIG9mIHRoaXMgbG9jYWxlIGluIGEgZm9ybWF0IHN1aXRhYmxlIGZvciB1c2VyIGRpc3BsYXkgCiAgICAgKiBpbiB0aGUgZGVmYXVsdCBsb2NhbGUuICBUaGlzIGZ1bmN0aW9uIHVzZXMgZ2V0RGlzcGxheUxhbmd1YWdlKCksIGdldERpc3BsYXlDb3VudHJ5KCksCiAgICAgKiBhbmQgZ2V0RGlzcGxheVZhcmlhbnQoKSB0byBkbyBpdHMgd29yaywgYW5kIG91dHB1dHMgdGhlIGRpc3BsYXkgbmFtZSBpbiB0aGUgZm9ybWF0CiAgICAgKiAibGFuZ3VhZ2UgKGNvdW50cnlbLHZhcmlhbnRdKSIuICBGb3IgZXhhbXBsZSwgaWYgdGhlIGRlZmF1bHQgbG9jYWxlIGlzIGVuX1VTLCB0aGVuCiAgICAgKiBmcl9GUidzIGRpc3BsYXkgbmFtZSB3b3VsZCBiZSAiRnJlbmNoIChGcmFuY2UpIiwgYW5kIGVzX01YX1RyYWRpdGlvbmFsJ3MgZGlzcGxheSBuYW1lCiAgICAgKiB3b3VsZCBiZSAiU3BhbmlzaCAoTWV4aWNvLFRyYWRpdGlvbmFsKSIuCiAgICAgKiBAcGFyYW0gbmFtZSAgUmVjZWl2ZXMgdGhlIGxvY2FsZSdzIGRpc3BsYXkgbmFtZS4KICAgICAqIEByZXR1cm4gICAgICBBIHJlZmVyZW5jZSB0byAibmFtZSIuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgIFVuaWNvZGVTdHJpbmcmICBnZXREaXNwbGF5TmFtZSggICAgICAgICBVbmljb2RlU3RyaW5nJiAgbmFtZSkgY29uc3Q7CgogICAgLyoqCiAgICAgKiBGaWxscyBpbiAibmFtZSIgd2l0aCB0aGUgbmFtZSBvZiB0aGlzIGxvY2FsZSBpbiBhIGZvcm1hdCBzdWl0YWJsZSBmb3IgdXNlciBkaXNwbGF5IAogICAgICogaW4gdGhlIGxvY2FsZSBzcGVjZmllZCBieSAiaW5Mb2NhbGUiLiAgVGhpcyBmdW5jdGlvbiB1c2VzIGdldERpc3BsYXlMYW5ndWFnZSgpLAogICAgICogZ2V0RGlzcGxheUNvdW50cnkoKSwgYW5kIGdldERpc3BsYXlWYXJpYW50KCkgdG8gZG8gaXRzIHdvcmssIGFuZCBvdXRwdXRzIHRoZSBkaXNwbGF5CiAgICAgKiBuYW1lIGluIHRoZSBmb3JtYXQgImxhbmd1YWdlIChjb3VudHJ5Wyx2YXJpYW50XSkiLiAgRm9yIGV4YW1wbGUsIGlmIGluTG9jYWxlIGlzCiAgICAgKiBmcl9GUiwgdGhlbiBlbl9VUydzIGRpc3BsYXkgbmFtZSB3b3VsZCBiZSAiQW5nbGFpcyAoyXRhdHMtVW5pcykiLCBhbmQgbm9fTk9fTlkncwogICAgICogZGlzcGxheSBuYW1lIHdvdWxkIGJlICJub3J26WdpZW4gKE5vcnboZ2UsTlkpIi4KICAgICAqIEBwYXJhbSBpbkxvY2FsZSAgU3BlY2lmaWVzIHRoZSBsb2NhbGUgdG8gYmUgdXNlZCB0byBkaXNwbGF5IHRoZSBuYW1lLgogICAgICogQHBhcmFtIG5hbWUgICAgICBSZWNlaXZlcyB0aGUgbG9jYWxlJ3MgZGlzcGxheSBuYW1lLgogICAgICogQHJldHVybiAgICAgICAgICBBIHJlZmVyZW5jZSB0byAibmFtZSIuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgIFVuaWNvZGVTdHJpbmcmICBnZXREaXNwbGF5TmFtZSggY29uc3QgICBMb2NhbGUmICAgICAgICAgaW5Mb2NhbGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVW5pY29kZVN0cmluZyYgIG5hbWUpIGNvbnN0OwoKICAgIC8qKgogICAgICogR2VuZXJhdGVzIGEgaGFzaCBjb2RlIGZvciB0aGUgbG9jYWxlLgogICAgICogQHN0YWJsZQogICAgICovCiAgICBpbnQzMl90ICAgICAgICAgaGFzaENvZGUodm9pZCkgY29uc3Q7CgogICAgLyoqCiAgICAgKiBSZXR1cm5zIGEgbGlzdCBvZiBhbGwgaW5zdGFsbGVkIGxvY2FsZXMuCiAgICAgKiBAcGFyYW0gY291bnQgUmVjZWl2ZXMgdGhlIG51bWJlciBvZiBsb2NhbGVzIGluIHRoZSBsaXN0LgogICAgICogQHJldHVybiAgICAgIEEgcG9pbnRlciB0byBhbiBhcnJheSBvZiBMb2NhbGUgb2JqZWN0cy4gIFRoaXMgYXJyYXkgaXMgdGhlIGxpc3QKICAgICAqICAgICAgICAgICAgICBvZiBhbGwgbG9jYWxlcyB3aXRoIGluc3RhbGxlZCByZXNvdXJjZSBmaWxlcy4gIFRoZSBjYWxsZWQgZG9lcyBOT1QKICAgICAqICAgICAgICAgICAgICBnZXQgb3duZXJzaGlwIG9mIHRoaXMgbGlzdCwgYW5kIG11c3QgTk9UIGRlbGV0ZSBpdC4KICAgICAqIEBzdGFibGUKICAgICAqLwogICAgc3RhdGljICBjb25zdCAgIExvY2FsZSogICAgIGdldEF2YWlsYWJsZUxvY2FsZXMoaW50MzJfdCYgY291bnQpOwoKICAgIC8qKgogICAgICogR2V0cyBhIGxpc3Qgb2YgYWxsIGF2YWlsYWJsZSAyLWxldHRlciBjb3VudHJ5IGNvZGVzIGRlZmluZWQgaW4gSVNPIDYzOS4gIFRoaXMgaXMgYQogICAgICogcG9pbnRlciB0byBhbiBhcnJheSBvZiBwb2ludGVycyB0byBhcnJheXMgb2YgY2hhci4gIEFsbCBvZiB0aGVzZSBwb2ludGVycyBhcmUKICAgICAqIG93bmVkIGJ5IElDVS0tIGRvIG5vdCBkZWxldGUgdGhlbSwgYW5kIGRvIG5vdCB3cml0ZSB0aHJvdWdoIHRoZW0uICBUaGUgYXJyYXkgaXMKICAgICAqIHRlcm1pbmF0ZWQgd2l0aCBhIG51bGwgcG9pbnRlci4KICAgICAqIEByZXR1cm4gYSBsaXN0IG9mIGFsbCBhdmFpbGFibGUgY291bnRyeSBjb2RlcwogICAgICogQHN0YWJsZQogICAgICovCiAgICBzdGF0aWMgY29uc3QgY2hhciogY29uc3QqIGdldElTT0NvdW50cmllcygpOwoKICAgIC8qKgogICAgICogR2V0cyBhIGxpc3Qgb2YgYWxsIGF2YWlsYWJsZSBsYW5ndWFnZSBjb2RlcyBkZWZpbmVkIGluIElTTyA2MzkuICBUaGlzIGlzIGEgcG9pbnRlcgogICAgICogdG8gYW4gYXJyYXkgb2YgcG9pbnRlcnMgdG8gYXJyYXlzIG9mIGNoYXIuICBBbGwgb2YgdGhlc2UgcG9pbnRlcnMgYXJlIG93bmVkCiAgICAgKiBieSBJQ1UtLSBkbyBub3QgZGVsZXRlIHRoZW0sIGFuZCBkbyBub3Qgd3JpdGUgdGhyb3VnaCB0aGVtLiAgVGhlIGFycmF5IGlzCiAgICAgKiB0ZXJtaW5hdGVkIHdpdGggYSBudWxsIHBvaW50ZXIuCiAgICAgKiBAcmV0dXJuIGEgbGlzdCBvZiBhbGwgYXZhaWxhYmxlIGxhbmd1YWdlIGNvZGVzCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgIHN0YXRpYyBjb25zdCBjaGFyKiBjb25zdCogIGdldElTT0xhbmd1YWdlcygpOwoKcHJvdGVjdGVkOiAvKiBvbmx5IHByb3RlY3RlZCBmb3IgdGVzdGluZyBwdXJwb3Nlcy4gRE8gTk9UIFVTRS4gKi8KICAgIC8qKiBzZXQgaXQgZnJvbSBhIHNpbmdsZSBzdHJpbmcuICovCiAgICB2b2lkIHNldEZyb21QT1NJWElEKGNvbnN0IGNoYXIgKnBvc2l4SUQpOwoKcHJpdmF0ZToKICAgIC8qKgogICAgICogSW5pdGlhbGl6ZSB0aGUgbG9jYWxlIG9iamVjdCB3aXRoIGEgbmV3IG5hbWUuCiAgICAgKiBXYXMgZGVwcmVjYXRlZCAtIHVzZWQgaW4gaW1wbGVtZW50YXRpb24gLSBtb3ZlZCBpbnRlcm5hbAogICAgICoKICAgICAqIEBwYXJhbSBjTG9jYWxlSUQgVGhlIG5ldyBsb2NhbGUgbmFtZS4KICAgICAqLwogICAgTG9jYWxlJiBpbml0KGNvbnN0IGNoYXIqIGNMb2NhbGVJRCk7CgogICAgLyoqCiAgICAgKiBJbml0aWFsaXplIHRoZSBsb2NhbGUgY2FjaGUgZm9yIGNvbW1vbmx5IHVzZWQgbG9jYWxlcwogICAgICovCiAgICBzdGF0aWMgdm9pZCBpbml0TG9jYWxlQ2FjaGUodm9pZCk7CgogICAgY2hhciBsYW5ndWFnZVtVTE9DX0xBTkdfQ0FQQUNJVFldOwogICAgY2hhciBjb3VudHJ5W1VMT0NfQ09VTlRSWV9DQVBBQ0lUWV07CiAgICBpbnQzMl90IHZhcmlhbnRCZWdpbjsKICAgIGNoYXIqIGZ1bGxOYW1lOwogICAgY2hhciBmdWxsTmFtZUJ1ZmZlcltVTE9DX0ZVTExOQU1FX0NBUEFDSVRZXTsKICAgIAovLyAgICBzdGF0aWMgTG9jYWxlICpsb2NhbGVMaXN0OwovLyAgICBzdGF0aWMgaW50MzJfdCBsb2NhbGVMaXN0Q291bnQ7CgojaWZkZWYgSUNVX0xPQ0lEX1VTRV9ERVBSRUNBVEVTCiAgICBzdGF0aWMgTG9jYWxlIGZnRGVmYXVsdExvY2FsZTsKI2Vsc2UKICAgIGZyaWVuZCBzdHJ1Y3QgTG9jYWxlUHJveHk7CiNlbmRpZgoKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgJmdldExvY2FsZShpbnQgbG9jaWQpOwoKICAgIGZyaWVuZCB2b2lkIGxvY2FsZV9zZXRfZGVmYXVsdF9pbnRlcm5hbChjb25zdCBjaGFyICopOwp9OwoKaW5saW5lIFVCb29sCkxvY2FsZTo6b3BlcmF0b3IhPShjb25zdCAgICBMb2NhbGUmICAgICBvdGhlcikgY29uc3QKewogICAgcmV0dXJuICFvcGVyYXRvcj09KG90aGVyKTsKfQoKaW5saW5lIGNvbnN0IGNoYXIgKgpMb2NhbGU6OmdldENvdW50cnkoKSBjb25zdAp7CiAgICByZXR1cm4gY291bnRyeTsKfQoKaW5saW5lIGNvbnN0IGNoYXIgKgpMb2NhbGU6OmdldExhbmd1YWdlKCkgY29uc3QKewogICAgcmV0dXJuIGxhbmd1YWdlOwp9CgppbmxpbmUgY29uc3QgY2hhciAqCkxvY2FsZTo6Z2V0VmFyaWFudCgpIGNvbnN0CnsKICAgIHJldHVybiAmZnVsbE5hbWVbdmFyaWFudEJlZ2luXTsKfQoKaW5saW5lIGNvbnN0IGNoYXIgKiAKTG9jYWxlOjpnZXROYW1lKCkgY29uc3QKewogICAgcmV0dXJuIGZ1bGxOYW1lOwp9CgojaWZuZGVmIElDVV9MT0NJRF9VU0VfREVQUkVDQVRFUwovKiBQcm94eSBmdW5jdGlvbnMgKi8KaW5saW5lIGNvbnN0IGNoYXIgKkxvY2FsZTo6TG9jYWxlUHJveHk6OmdldExhbmd1YWdlKCApIGNvbnN0CnsKICAgIHJldHVybiAoKGNvbnN0IExvY2FsZSkqdGhpcykuZ2V0TGFuZ3VhZ2UoKTsKfQoKaW5saW5lIGNvbnN0IGNoYXIgKkxvY2FsZTo6TG9jYWxlUHJveHk6OmdldENvdW50cnkoICkgY29uc3QKewogICAgcmV0dXJuICgoY29uc3QgTG9jYWxlKSp0aGlzKS5nZXRDb3VudHJ5KCk7Cn0KCmlubGluZSBjb25zdCBjaGFyICpMb2NhbGU6OkxvY2FsZVByb3h5OjpnZXRWYXJpYW50KCApIGNvbnN0CnsKICAgIHJldHVybiAoKGNvbnN0IExvY2FsZSkqdGhpcykuZ2V0VmFyaWFudCgpOwp9CgppbmxpbmUgY29uc3QgY2hhciAqTG9jYWxlOjpMb2NhbGVQcm94eTo6Z2V0TmFtZSgpIGNvbnN0CnsKICAgIHJldHVybiAoKGNvbnN0IExvY2FsZSkqdGhpcykuZ2V0TmFtZSgpOwp9CgppbmxpbmUgY29uc3QgY2hhciAqTG9jYWxlOjpMb2NhbGVQcm94eTo6Z2V0SVNPM0xhbmd1YWdlKCkgY29uc3QKewogICAgcmV0dXJuICgoY29uc3QgTG9jYWxlKSp0aGlzKS5nZXRJU08zTGFuZ3VhZ2UoKTsKfQoKaW5saW5lIGNvbnN0IGNoYXIgKkxvY2FsZTo6TG9jYWxlUHJveHk6OmdldElTTzNDb3VudHJ5KCkgY29uc3QKewogICAgcmV0dXJuICgoY29uc3QgTG9jYWxlKSp0aGlzKS5nZXRJU08zQ291bnRyeSgpOwp9CgppbmxpbmUgdWludDMyX3QgTG9jYWxlOjpMb2NhbGVQcm94eTo6Z2V0TENJRCh2b2lkKSBjb25zdAp7CiAgICByZXR1cm4gKChjb25zdCBMb2NhbGUpKnRoaXMpLmdldExDSUQoKTsKfQoKaW5saW5lIFVuaWNvZGVTdHJpbmcmICBMb2NhbGU6OkxvY2FsZVByb3h5OjpnZXREaXNwbGF5TGFuZ3VhZ2UoVW5pY29kZVN0cmluZyYgICBkaXNwTGFuZykgY29uc3QKewogICAgcmV0dXJuICgoY29uc3QgTG9jYWxlKSp0aGlzKS5nZXREaXNwbGF5TGFuZ3VhZ2UoZGlzcExhbmcpOwp9CgppbmxpbmUgVW5pY29kZVN0cmluZyYgIExvY2FsZTo6TG9jYWxlUHJveHk6OmdldERpc3BsYXlMYW5ndWFnZSggY29uc3QgICBMb2NhbGUmICAgICAgICAgaW5Mb2NhbGUsCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVW5pY29kZVN0cmluZyYgIGRpc3BMYW5nKSBjb25zdAp7CiAgICByZXR1cm4gKChjb25zdCBMb2NhbGUpKnRoaXMpLmdldERpc3BsYXlMYW5ndWFnZShpbkxvY2FsZSwgZGlzcExhbmcpOwp9CgppbmxpbmUgVW5pY29kZVN0cmluZyYgIExvY2FsZTo6TG9jYWxlUHJveHk6OmdldERpc3BsYXlDb3VudHJ5KFVuaWNvZGVTdHJpbmcmIGRpc3BDb3VudHJ5KSBjb25zdAp7CiAgICByZXR1cm4gKChjb25zdCBMb2NhbGUpKnRoaXMpLmdldERpc3BsYXlDb3VudHJ5KGRpc3BDb3VudHJ5KTsKfQoKaW5saW5lIFVuaWNvZGVTdHJpbmcmICBMb2NhbGU6OkxvY2FsZVByb3h5OjpnZXREaXNwbGF5Q291bnRyeShjb25zdCAgIExvY2FsZSYgICAgICAgICBpbkxvY2FsZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVbmljb2RlU3RyaW5nJiAgZGlzcENvdW50cnkpIGNvbnN0CnsKICAgIHJldHVybiAoKGNvbnN0IExvY2FsZSkqdGhpcykuZ2V0RGlzcGxheUNvdW50cnkoaW5Mb2NhbGUsIGRpc3BDb3VudHJ5KTsKfQoKaW5saW5lIFVuaWNvZGVTdHJpbmcmICBMb2NhbGU6OkxvY2FsZVByb3h5OjpnZXREaXNwbGF5VmFyaWFudChVbmljb2RlU3RyaW5nJiBkaXNwVmFyKSBjb25zdAp7CiAgICByZXR1cm4gKChjb25zdCBMb2NhbGUpKnRoaXMpLmdldERpc3BsYXlWYXJpYW50KGRpc3BWYXIpOwp9CgppbmxpbmUgVW5pY29kZVN0cmluZyYgIExvY2FsZTo6TG9jYWxlUHJveHk6OmdldERpc3BsYXlWYXJpYW50KGNvbnN0ICAgTG9jYWxlJiAgICAgICAgIGluTG9jYWxlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBkaXNwVmFyKSBjb25zdAp7CiAgICByZXR1cm4gKChjb25zdCBMb2NhbGUpKnRoaXMpLmdldERpc3BsYXlWYXJpYW50KGluTG9jYWxlLCBkaXNwVmFyKTsKfQoKaW5saW5lIFVuaWNvZGVTdHJpbmcmICBMb2NhbGU6OkxvY2FsZVByb3h5OjpnZXREaXNwbGF5TmFtZShVbmljb2RlU3RyaW5nJiAgbmFtZSkgY29uc3QKewogICAgcmV0dXJuICgoY29uc3QgTG9jYWxlKSp0aGlzKS5nZXREaXNwbGF5TmFtZShuYW1lKTsKfQoKaW5saW5lIFVuaWNvZGVTdHJpbmcmICBMb2NhbGU6OkxvY2FsZVByb3h5OjpnZXREaXNwbGF5TmFtZShjb25zdCAgIExvY2FsZSYgICAgICAgICBpbkxvY2FsZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBuYW1lKSBjb25zdAp7CiAgICByZXR1cm4gKChjb25zdCBMb2NhbGUpKnRoaXMpLmdldERpc3BsYXlOYW1lKGluTG9jYWxlLCBuYW1lKTsKfQoKaW5saW5lIGludDMyX3QgICAgICAgICBMb2NhbGU6OkxvY2FsZVByb3h5OjpoYXNoQ29kZSh2b2lkKSBjb25zdAp7CiAgICByZXR1cm4gKChjb25zdCBMb2NhbGUpKnRoaXMpLmhhc2hDb2RlKCk7Cn0KI2VuZGlmIC8qICFJQ1VfTE9DSURfVVNFX0RFUFJFQ0FURVMgKi8KVV9OQU1FU1BBQ0VfRU5ECgojZW5kaWYgIC8qIFhQX0NQTFVTUExVUyAqLwojZW5kaWYKCg==