LyoKKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioKKgoqICAgQ29weXJpZ2h0IChDKSAxOTk2LTE5OTksIEludGVybmF0aW9uYWwgQnVzaW5lc3MgTWFjaGluZXMKKiAgIENvcnBvcmF0aW9uIGFuZCBvdGhlcnMuICBBbGwgUmlnaHRzIFJlc2VydmVkLgoqCioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqCioKKiBGaWxlIGxvY2lkLmgKKgoqIENyZWF0ZWQgYnk6IEhlbGVuYSBTaGloCioKKiBNb2RpZmljYXRpb24gSGlzdG9yeToKKgoqICAgRGF0ZSAgICAgICAgTmFtZSAgICAgICAgRGVzY3JpcHRpb24KKiAgIDAyLzExLzk3ICAgIGFsaXUgICAgICAgIENoYW5nZWQgZ0xvY1BhdGggdG8gZmdMb2NQYXRoIGFuZCBhZGRlZCBtZXRob2RzIHRvCiogICAgICAgICAgICAgICAgICAgICAgICAgICBnZXQgYW5kIHNldCBpdC4KKiAgIDA0LzAyLzk3ICAgIGFsaXUgICAgICAgIE1hZGUgb3BlcmF0b3IhPSBpbmxpbmU7IGZpeGVkIHJldHVybiB2YWx1ZSBvZiBnZXROYW1lKCkuCiogICAwNC8xNS85NyAgICBhbGl1ICAgICAgICBDbGVhbnVwIGZvciBBSVgvV2luMzIuCiogICAwNC8yNC85NyAgICBhbGl1ICAgICAgICBOdW1lcm91cyBjaGFuZ2VzIHBlciBjb2RlIHJldmlldy4KKiAgIDA4LzE4Lzk4ICAgIHN0ZXBoZW4gICAgIEFkZGVkIHRva2VuaXplU3RyaW5nKCksY2hhbmdlZCBnZXREaXNwbGF5TmFtZSgpCiogICAwOS8wOC85OCAgICBzdGVwaGVuICAgICBNb3ZlZCBkZWZpbml0aW9uIG9mIGtFbXB0eVN0cmluZyBmb3IgTWFjIFBvcnQKKgkxMS8wOS85OQl3ZWl2CQlBZGRlZCBjb25zdCBjaGFyICogZ2V0TmFtZSgpIGNvbnN0OwoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgoqLwoKI2lmbmRlZiBMT0NJRF9ICiNkZWZpbmUgTE9DSURfSAoKCiNpbmNsdWRlICJ1bmljb2RlL3VuaXN0ci5oIgoKdHlwZWRlZiBzdHJ1Y3QgVUxvY2FsZSBVTG9jYWxlOwp0eXBlZGVmIHN0cnVjdCBVSGFzaHRhYmxlIFVIYXNodGFibGU7CgojZGVmaW5lIFVMT0NfTEFOR19DQVBBQ0lUWSAzCiNkZWZpbmUgVUxPQ19DT1VOVFJZX0NBUEFDSVRZIDMKI2RlZmluZSBVTE9DX0ZVTExOQU1FX0NBUEFDSVRZIDUwCgovKiogICAgCiAqCiAqIEEgPGNvZGU+TG9jYWxlPC9jb2RlPiBvYmplY3QgcmVwcmVzZW50cyBhIHNwZWNpZmljIGdlb2dyYXBoaWNhbCwgcG9saXRpY2FsLAogKiBvciBjdWx0dXJhbCByZWdpb24uIEFuIG9wZXJhdGlvbiB0aGF0IHJlcXVpcmVzIGEgPGNvZGU+TG9jYWxlPC9jb2RlPiB0byBwZXJmb3JtCiAqIGl0cyB0YXNrIGlzIGNhbGxlZCA8ZW0+bG9jYWxlLXNlbnNpdGl2ZTwvZW0+IGFuZCB1c2VzIHRoZSA8Y29kZT5Mb2NhbGU8L2NvZGU+CiAqIHRvIHRhaWxvciBpbmZvcm1hdGlvbiBmb3IgdGhlIHVzZXIuIEZvciBleGFtcGxlLCBkaXNwbGF5aW5nIGEgbnVtYmVyCiAqIGlzIGEgbG9jYWxlLXNlbnNpdGl2ZSBvcGVyYXRpb24tLXRoZSBudW1iZXIgc2hvdWxkIGJlIGZvcm1hdHRlZAogKiBhY2NvcmRpbmcgdG8gdGhlIGN1c3RvbXMvY29udmVudGlvbnMgb2YgdGhlIHVzZXIncyBuYXRpdmUgY291bnRyeSwKICogcmVnaW9uLCBvciBjdWx0dXJlLgogKgogKiA8UD4KICogWW91IGNyZWF0ZSBhIDxjb2RlPkxvY2FsZTwvY29kZT4gb2JqZWN0IHVzaW5nIG9uZSBvZiB0aGUgdGhyZWUgY29uc3RydWN0b3JzIGluCiAqIHRoaXMgY2xhc3M6CiAqIDxibG9ja3F1b3RlPgogKiA8cHJlPgogKiAuICAgICAgTG9jYWxlKCBjb25zdCAgIFVuaWNvZGVTdHJpbmcmICBuZXdMYW5ndWFnZSk7CiAqIC4KICogLiAgICAgIExvY2FsZSggY29uc3QgICBVbmljb2RlU3RyaW5nJiAgbGFuZ3VhZ2UsIAogKiAuICAgICAgICAgICAgICBjb25zdCAgIFVuaWNvZGVTdHJpbmcmICBjb3VudHJ5KTsKICogLgogKiAuICAgICAgTG9jYWxlKCBjb25zdCAgIFVuaWNvZGVTdHJpbmcmICBsYW5ndWFnZSwgCiAqIC4gICAgICAgICAgICAgIGNvbnN0ICAgVW5pY29kZVN0cmluZyYgIGNvdW50cnksIAogKiAuICAgICAgICAgICAgICBjb25zdCAgIFVuaWNvZGVTdHJpbmcmICB2YXJpYW50KTsKICogPC9wcmU+CiAqIDwvYmxvY2txdW90ZT4KICogVGhlIGZpcnN0IGFyZ3VtZW50IHRvIHRoZSBjb25zdHJ1Y3RvcnMgaXMgYSB2YWxpZCA8U1RST05HPklTTwogKiBMYW5ndWFnZSBDb2RlLjwvU1RST05HPiBUaGVzZSBjb2RlcyBhcmUgdGhlIGxvd2VyLWNhc2UgdHdvLWxldHRlcgogKiBjb2RlcyBhcyBkZWZpbmVkIGJ5IElTTy02MzkuCiAqIFlvdSBjYW4gZmluZCBhIGZ1bGwgbGlzdCBvZiB0aGVzZSBjb2RlcyBhdCBhIG51bWJlciBvZiBzaXRlcywgc3VjaCBhczoKICogPEJSPjxhIGhyZWYgPSJodHRwOi8vd3d3Lmljcy51Y2kuZWR1L3B1Yi9pZXRmL2h0dHAvcmVsYXRlZC9pc282MzkudHh0Ij4KICogPGNvZGU+aHR0cDovL3d3dy5pY3MudWNpLmVkdS9wdWIvaWV0Zi9odHRwL3JlbGF0ZWQvaXNvNjM5LnR4dDwvY29kZT48L2E+CiAqCiAqIDxQPgogKiBUaGUgc2Vjb25kIGFyZ3VtZW50IHRvIHRoZSBjb25zdHJ1Y3RvcnMgaXMgYSB2YWxpZCA8U1RST05HPklTTyBDb3VudHJ5CiAqIENvZGUuPC9TVFJPTkc+IFRoZXNlIGNvZGVzIGFyZSB0aGUgdXBwZXItY2FzZSB0d28tbGV0dGVyIGNvZGVzCiAqIGFzIGRlZmluZWQgYnkgSVNPLTMxNjYuCiAqIFlvdSBjYW4gZmluZCBhIGZ1bGwgbGlzdCBvZiB0aGVzZSBjb2RlcyBhdCBhIG51bWJlciBvZiBzaXRlcywgc3VjaCBhczoKICogPEJSPjxhIGhyZWY9Imh0dHA6Ly93d3cuY2hlbWllLmZ1LWJlcmxpbi5kZS9kaXZlcnNlL2RvYy9JU09fMzE2Ni5odG1sIj4KICogPGNvZGU+aHR0cDovL3d3dy5jaGVtaWUuZnUtYmVybGluLmRlL2RpdmVyc2UvZG9jL0lTT18zMTY2Lmh0bWw8L2NvZGU+PC9hPgogKgogKiA8UD4KICogVGhlIHRoaXJkIGNvbnN0cnVjdG9yIHJlcXVpcmVzIGEgdGhpcmQgYXJndW1lbnQtLXRoZSA8U1RST05HPlZhcmlhbnQuPC9TVFJPTkc+CiAqIFRoZSBWYXJpYW50IGNvZGVzIGFyZSB2ZW5kb3IgYW5kIGJyb3dzZXItc3BlY2lmaWMuCiAqIEZvciBleGFtcGxlLCB1c2UgV0lOIGZvciBXaW5kb3dzLCBNQUMgZm9yIE1hY2ludG9zaCwgYW5kIFBPU0lYIGZvciBQT1NJWC4KICogV2hlcmUgdGhlcmUgYXJlIHR3byB2YXJpYW50cywgc2VwYXJhdGUgdGhlbSB3aXRoIGFuIHVuZGVyc2NvcmUsIGFuZAogKiBwdXQgdGhlIG1vc3QgaW1wb3J0YW50IG9uZSBmaXJzdC4gRm9yCiAqIGV4YW1wbGUsIGEgVHJhZGl0aW9uYWwgU3BhbmlzaCBjb2xsYXRpb24gbWlnaHQgYmUgcmVmZXJlbmNlZCwgd2l0aAogKiAiRVMiLCAiRVMiLCAiVHJhZGl0aW9uYWxfV0lOIi4KICoKICogPFA+CiAqIEJlY2F1c2UgYSA8Y29kZT5Mb2NhbGU8L2NvZGU+IG9iamVjdCBpcyBqdXN0IGFuIGlkZW50aWZpZXIgZm9yIGEgcmVnaW9uLAogKiBubyB2YWxpZGl0eSBjaGVjayBpcyBwZXJmb3JtZWQgd2hlbiB5b3UgY29uc3RydWN0IGEgPGNvZGU+TG9jYWxlPC9jb2RlPi4KICogSWYgeW91IHdhbnQgdG8gc2VlIHdoZXRoZXIgcGFydGljdWxhciByZXNvdXJjZXMgYXJlIGF2YWlsYWJsZSBmb3IgdGhlCiAqIDxjb2RlPkxvY2FsZTwvY29kZT4geW91IGNvbnN0cnVjdCwgeW91IG11c3QgcXVlcnkgdGhvc2UgcmVzb3VyY2VzLiBGb3IKICogZXhhbXBsZSwgYXNrIHRoZSA8Y29kZT5OdW1iZXJGb3JtYXQ8L2NvZGU+IGZvciB0aGUgbG9jYWxlcyBpdCBzdXBwb3J0cwogKiB1c2luZyBpdHMgPGNvZGU+Z2V0QXZhaWxhYmxlTG9jYWxlczwvY29kZT4gbWV0aG9kLgogKiA8QlI+PFNUUk9ORz5Ob3RlOjwvU1RST05HPiBXaGVuIHlvdSBhc2sgZm9yIGEgcmVzb3VyY2UgZm9yIGEgcGFydGljdWxhcgogKiBsb2NhbGUsIHlvdSBnZXQgYmFjayB0aGUgYmVzdCBhdmFpbGFibGUgbWF0Y2gsIG5vdCBuZWNlc3NhcmlseQogKiBwcmVjaXNlbHkgd2hhdCB5b3UgYXNrZWQgZm9yLiBGb3IgbW9yZSBpbmZvcm1hdGlvbiwgbG9vayBhdAogKiA8YSBocmVmPSJqYXZhLnV0aWwuUmVzb3VyY2VCdW5kbGUuaHRtbCI+PGNvZGU+UmVzb3VyY2VCdW5kbGU8L2NvZGU+PC9hPi4KICoKICogPFA+CiAqIFRoZSA8Y29kZT5Mb2NhbGU8L2NvZGU+IGNsYXNzIHByb3ZpZGVzIGEgbnVtYmVyIG9mIGNvbnZlbmllbnQgY29uc3RhbnRzCiAqIHRoYXQgeW91IGNhbiB1c2UgdG8gY3JlYXRlIDxjb2RlPkxvY2FsZTwvY29kZT4gb2JqZWN0cyBmb3IgY29tbW9ubHkgdXNlZAogKiBsb2NhbGVzLiBGb3IgZXhhbXBsZSwgdGhlIGZvbGxvd2luZyByZWZlcnMgdG8gYSA8Y29kZT5Mb2NhbGU8L2NvZGU+IG9iamVjdAogKiBmb3IgdGhlIFVuaXRlZCBTdGF0ZXM6CiAqIDxibG9ja3F1b3RlPgogKiA8cHJlPgogKiAuICAgICAgTG9jYWxlOjpVUwogKiA8L3ByZT4KICogPC9ibG9ja3F1b3RlPgogKgogKiA8UD4KICogT25jZSB5b3UndmUgY3JlYXRlZCBhIDxjb2RlPkxvY2FsZTwvY29kZT4geW91IGNhbiBxdWVyeSBpdCBmb3IgaW5mb3JtYXRpb24gYWJvdXQKICogaXRzZWxmLiBVc2UgPGNvZGU+Z2V0Q291bnRyeTwvY29kZT4gdG8gZ2V0IHRoZSBJU08gQ291bnRyeSBDb2RlIGFuZAogKiA8Y29kZT5nZXRMYW5ndWFnZTwvY29kZT4gdG8gZ2V0IHRoZSBJU08gTGFuZ3VhZ2UgQ29kZS4gWW91IGNhbgogKiB1c2UgPGNvZGU+Z2V0RGlzcGxheUNvdW50cnk8L2NvZGU+IHRvIGdldCB0aGUKICogbmFtZSBvZiB0aGUgY291bnRyeSBzdWl0YWJsZSBmb3IgZGlzcGxheWluZyB0byB0aGUgdXNlci4gU2ltaWxhcmx5LAogKiB5b3UgY2FuIHVzZSA8Y29kZT5nZXREaXNwbGF5TGFuZ3VhZ2U8L2NvZGU+IHRvIGdldCB0aGUgbmFtZSBvZgogKiB0aGUgbGFuZ3VhZ2Ugc3VpdGFibGUgZm9yIGRpc3BsYXlpbmcgdG8gdGhlIHVzZXIuIEludGVyZXN0aW5nbHksCiAqIHRoZSA8Y29kZT5nZXREaXNwbGF5WFhYPC9jb2RlPiBtZXRob2RzIGFyZSB0aGVtc2VsdmVzIGxvY2FsZS1zZW5zaXRpdmUKICogYW5kIGhhdmUgdHdvIHZlcnNpb25zOiBvbmUgdGhhdCB1c2VzIHRoZSBkZWZhdWx0IGxvY2FsZSBhbmQgb25lCiAqIHRoYXQgdGFrZXMgYSBsb2NhbGUgYXMgYW4gYXJndW1lbnQgYW5kIGRpc3BsYXlzIHRoZSBuYW1lIG9yIGNvdW50cnkgaW4KICogYSBsYW5ndWFnZSBhcHByb3ByaWF0ZSB0byB0aGF0IGxvY2FsZS4KICoKICogPFA+CiAqIFRoZSBUSUZDIHByb3ZpZGVzIGEgbnVtYmVyIG9mIGNsYXNzZXMgdGhhdCBwZXJmb3JtIGxvY2FsZS1zZW5zaXRpdmUKICogb3BlcmF0aW9ucy4gRm9yIGV4YW1wbGUsIHRoZSA8Y29kZT5OdW1iZXJGb3JtYXQ8L2NvZGU+IGNsYXNzIGZvcm1hdHMKICogbnVtYmVycywgY3VycmVuY3ksIG9yIHBlcmNlbnRhZ2VzIGluIGEgbG9jYWxlLXNlbnNpdGl2ZSBtYW5uZXIuIENsYXNzZXMKICogc3VjaCBhcyA8Y29kZT5OdW1iZXJGb3JtYXQ8L2NvZGU+IGhhdmUgYSBudW1iZXIgb2YgY29udmVuaWVuY2UgbWV0aG9kcwogKiBmb3IgY3JlYXRpbmcgYSBkZWZhdWx0IG9iamVjdCBvZiB0aGF0IHR5cGUuIEZvciBleGFtcGxlLCB0aGUKICogPGNvZGU+TnVtYmVyRm9ybWF0PC9jb2RlPiBjbGFzcyBwcm92aWRlcyB0aGVzZSB0aHJlZSBjb252ZW5pZW5jZSBtZXRob2RzCiAqIGZvciBjcmVhdGluZyBhIGRlZmF1bHQgPGNvZGU+TnVtYmVyRm9ybWF0PC9jb2RlPiBvYmplY3Q6CiAqIDxibG9ja3F1b3RlPgogKiA8cHJlPgogKiAuICAgIFVFcnJvckNvZGUgc3VjY2VzcyA9IFVfWkVST19FUlJPUjsKICogLiAgICBMb2NhbGUgbXlMb2NhbGU7CiAqIC4gICAgTnVtYmVyRm9ybWF0ICpuZjsKICogLgogKiAuICAgIG5mID0gTnVtYmVyRm9ybWF0OjpjcmVhdGVJbnN0YW5jZSggc3VjY2VzcyApOyAgICAgICAgICBkZWxldGUgbmY7CiAqIC4gICAgbmYgPSBOdW1iZXJGb3JtYXQ6OmNyZWF0ZUN1cnJlbmN5SW5zdGFuY2UoIHN1Y2Nlc3MgKTsgIGRlbGV0ZSBuZjsKICogLiAgICBuZiA9IE51bWJlckZvcm1hdDo6Y3JlYXRlUGVyY2VudEluc3RhbmNlKCBzdWNjZXNzICk7ICAgZGVsZXRlIG5mOwogKiA8L3ByZT4KICogPC9ibG9ja3F1b3RlPgogKiBFYWNoIG9mIHRoZXNlIG1ldGhvZHMgaGFzIHR3byB2YXJpYW50czsgb25lIHdpdGggYW4gZXhwbGljaXQgbG9jYWxlCiAqIGFuZCBvbmUgd2l0aG91dDsgdGhlIGxhdHRlciB1c2luZyB0aGUgZGVmYXVsdCBsb2NhbGUuCiAqIDxibG9ja3F1b3RlPgogKiA8cHJlPgogKiAuICAgIG5mID0gTnVtYmVyRm9ybWF0OjpjcmVhdGVJbnN0YW5jZSggbXlMb2NhbGUsIHN1Y2Nlc3MgKTsgICAgICAgICAgZGVsZXRlIG5mOwogKiAuICAgIG5mID0gTnVtYmVyRm9ybWF0OjpjcmVhdGVDdXJyZW5jeUluc3RhbmNlKCBteUxvY2FsZSwgc3VjY2VzcyApOyAgZGVsZXRlIG5mOwogKiAuICAgIG5mID0gTnVtYmVyRm9ybWF0OjpjcmVhdGVQZXJjZW50SW5zdGFuY2UoIG15TG9jYWxlLCBzdWNjZXNzICk7ICAgZGVsZXRlIG5mOwogKiA8L3ByZT4KICogPC9ibG9ja3F1b3RlPgogKiBBIDxjb2RlPkxvY2FsZTwvY29kZT4gaXMgdGhlIG1lY2hhbmlzbSBmb3IgaWRlbnRpZnlpbmcgdGhlIGtpbmQgb2Ygb2JqZWN0CiAqICg8Y29kZT5OdW1iZXJGb3JtYXQ8L2NvZGU+KSB0aGF0IHlvdSB3b3VsZCBsaWtlIHRvIGdldC4gVGhlIGxvY2FsZSBpcwogKiA8U1RST05HPmp1c3Q8L1NUUk9ORz4gYSBtZWNoYW5pc20gZm9yIGlkZW50aWZ5aW5nIG9iamVjdHMsCiAqIDxTVFJPTkc+bm90PC9TVFJPTkc+IGEgY29udGFpbmVyIGZvciB0aGUgb2JqZWN0cyB0aGVtc2VsdmVzLgogKgogKiA8UD4KICogRWFjaCBjbGFzcyB0aGF0IHBlcmZvcm1zIGxvY2FsZS1zZW5zaXRpdmUgb3BlcmF0aW9ucyBhbGxvd3MgeW91CiAqIHRvIGdldCBhbGwgdGhlIGF2YWlsYWJsZSBvYmplY3RzIG9mIHRoYXQgdHlwZS4gWW91IGNhbiBzaWZ0CiAqIHRocm91Z2ggdGhlc2Ugb2JqZWN0cyBieSBsYW5ndWFnZSwgY291bnRyeSwgb3IgdmFyaWFudCwKICogYW5kIHVzZSB0aGUgZGlzcGxheSBuYW1lcyB0byBwcmVzZW50IGEgbWVudSB0byB0aGUgdXNlci4KICogRm9yIGV4YW1wbGUsIHlvdSBjYW4gY3JlYXRlIGEgbWVudSBvZiBhbGwgdGhlIGNvbGxhdGlvbiBvYmplY3RzCiAqIHN1aXRhYmxlIGZvciBhIGdpdmVuIGxhbmd1YWdlLiBTdWNoIGNsYXNzZXMgaW1wbGVtZW50IHRoZXNlCiAqIHRocmVlIGNsYXNzIG1ldGhvZHM6CiAqIDxibG9ja3F1b3RlPgogKiA8cHJlPgogKiAuICAgICAgc3RhdGljIExvY2FsZSogZ2V0QXZhaWxhYmxlTG9jYWxlcyhpbnQzMl90JiBudW1Mb2NhbGVzKQogKiAuICAgICAgc3RhdGljIFVuaWNvZGVTdHJpbmcmIGdldERpc3BsYXlOYW1lKGNvbnN0IExvY2FsZSYgIG9iamVjdExvY2FsZSwKICogLiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBjb25zdCBMb2NhbGUmICBkaXNwbGF5TG9jYWxlLAogKiAuICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmIGRpc3BsYXlOYW1lKQogKiAuICAgICAgc3RhdGljIFVuaWNvZGVTdHJpbmcmIGdldERpc3BsYXlOYW1lKGNvbnN0IExvY2FsZSYgIG9iamVjdExvY2FsZSwKICogLiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVbmljb2RlU3RyaW5nJiBkaXNwbGF5TmFtZSkKICogPC9wcmU+CiAqIDwvYmxvY2txdW90ZT4KICovCmNsYXNzIFVfQ09NTU9OX0FQSSBMb2NhbGUgCnsKcHVibGljOgogICAgLyoqCiAgICAgKiBVc2VmdWwgY29uc3RhbnRzIGZvciBsYW5ndWFnZS4KICAgICAqLwogICAgc3RhdGljIGNvbnN0IExvY2FsZSBFTkdMSVNIOwogICAgc3RhdGljIGNvbnN0IExvY2FsZSBGUkVOQ0g7CiAgICBzdGF0aWMgY29uc3QgTG9jYWxlIEdFUk1BTjsKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgSVRBTElBTjsKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgSkFQQU5FU0U7CiAgICBzdGF0aWMgY29uc3QgTG9jYWxlIEtPUkVBTjsKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgQ0hJTkVTRTsKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgU0lNUExJRklFRF9DSElORVNFOwogICAgc3RhdGljIGNvbnN0IExvY2FsZSBUUkFESVRJT05BTF9DSElORVNFOwoKICAgIC8qKgogICAgICogVXNlZnVsIGNvbnN0YW50cyBmb3IgY291bnRyeS4KICAgICAqLwogICAgc3RhdGljIGNvbnN0IExvY2FsZSBGUkFOQ0U7CiAgICBzdGF0aWMgY29uc3QgTG9jYWxlIEdFUk1BTlk7CiAgICBzdGF0aWMgY29uc3QgTG9jYWxlIElUQUxZOwogICAgc3RhdGljIGNvbnN0IExvY2FsZSBKQVBBTjsKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgS09SRUE7CiAgICBzdGF0aWMgY29uc3QgTG9jYWxlIENISU5BOyAgICAgIC8vIEFsaWFzIGZvciBQUkMKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgUFJDOyAgICAgICAgLy8gUGVvcGxlcyBSZXB1YmxpYyBvZiBDaGluYQogICAgc3RhdGljIGNvbnN0IExvY2FsZSBUQUlXQU47ICAgICAvLyBSZXB1YmxpYyBvZiBDaGluYQogICAgc3RhdGljIGNvbnN0IExvY2FsZSBVSzsKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgVVM7CiAgICBzdGF0aWMgY29uc3QgTG9jYWxlIENBTkFEQTsKICAgIHN0YXRpYyBjb25zdCBMb2NhbGUgQ0FOQURBX0ZSRU5DSDsKCiAgIC8qKgogICAgKiBDb25zdHJ1Y3QgYW4gZW1wdHkgbG9jYWxlLiBJdCdzIG9ubHkgdXNlZCB3aGVuIGEgZmlsbC1pbiBwYXJhbWV0ZXIgaXMKICAgICogbmVlZGVkLgogICAgKiBAc3RhYmxlCiAgICAqLwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIExvY2FsZSgpOyAKCiAgICAvKioKICAgICAqIENvbnN0cnVjdCBhIGxvY2FsZSBmcm9tIGxhbmd1YWdlLCBjb3VudHJ5LCB2YXJpYW50LgogICAgICoKICAgICAqIEBwYXJhbSBsYW5ndWFnZSBMb3dlcmNhc2UgdHdvLWxldHRlciBJU08tNjM5IGNvZGUuCiAgICAgKiBAcGFyYW0gY291bnRyeSAgVXBwZXJjYXNlIHR3by1sZXR0ZXIgSVNPLTMxNjYgY29kZS4gKG9wdGlvbmFsKQogICAgICogQHBhcmFtIHZhcmlhbnQgIFVwcGVyY2FzZSB2ZW5kb3IgYW5kIGJyb3dzZXIgc3BlY2lmaWMgY29kZS4gU2VlIGNsYXNzCiAgICAgKiAgICAgICAgICAgICAgICAgZGVzY3JpcHRpb24uIChvcHRpb25hbCkKICAgICAqIEBzdGFibGUKICAgICAqLwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIExvY2FsZSggY29uc3QgICBVbmljb2RlU3RyaW5nJiAgbGFuZ3VhZ2UsIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgICBVbmljb2RlU3RyaW5nJiAgY291bnRyeSAsIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgICBVbmljb2RlU3RyaW5nJiAgdmFyaWFudCApOwoKICAgICAvKioKICAgICAqIENvbnN0cnVjdCBhIGxvY2FsZSBmcm9tIGxhbmd1YWdlLCBjb3VudHJ5LgogICAgICoKICAgICAqIEBwYXJhbSBsYW5ndWFnZSBMb3dlcmNhc2UgdHdvLWxldHRlciBJU08tNjM5IGNvZGUuCiAgICAgKiBAcGFyYW0gY291bnRyeSAgVXBwZXJjYXNlIHR3by1sZXR0ZXIgSVNPLTMxNjYgY29kZS4gKG9wdGlvbmFsKQogICAgICogQHN0YWJsZQogICAgICovCiAgICAgICAgICAgICAgIExvY2FsZSggY29uc3QgICBVbmljb2RlU3RyaW5nJiAgbGFuZ3VhZ2UsIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgY29uc3QgICBVbmljb2RlU3RyaW5nJiAgY291bnRyeSApOwogICAgICAgICAgICAgICAgCiAgICAvKioKICAgICAqIENvbnN0cnVjdCBhIGxvY2FsZSBmcm9tIGxhbmd1YWdlLgogICAgICoKICAgICAqIEBwYXJhbSBsYW5ndWFnZSBMb3dlcmNhc2UgdHdvLWxldHRlciBJU08tNjM5IGNvZGUuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgICAgICAgICAgICAgIExvY2FsZSggY29uc3QgICBVbmljb2RlU3RyaW5nJiAgbGFuZ3VhZ2UpOwoKCgogICAgLyoqCiAgICAgKiBJbml0aWFsaXplcyBhIExvY2FsZSBvYmplY3QgZnJvbSBhbm90aGVyIExvY2FsZSBvYmplY3QuCiAgICAgKgogICAgICogQHBhcmFtIG90aGVyIFRoZSBMb2NhbGUgb2JqZWN0IGJlaW5nIGNvcGllZCBpbi4KICAgICAqIEBzdGFibGUKICAgICAqLwogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIExvY2FsZShjb25zdCAgICBMb2NhbGUmIG90aGVyKTsKCgogICAgLyoqCiAgICAgKiBEZXN0cnVjdG9yCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICB+TG9jYWxlKCkgOwogICAgICAgICAgICAgICAgICAKICAgIC8qKgogICAgICogUmVwbGFjZXMgdGhlIGVudGlyZSBjb250ZW50cyBvZiAqdGhpcyB3aXRoIHRoZSBzcGVjaWZpZWQgdmFsdWUuCiAgICAgKgogICAgICogQHBhcmFtIG90aGVyIFRoZSBMb2NhbGUgb2JqZWN0IGJlaW5nIGNvcGllZCBpbi4KICAgICAqIEByZXR1cm4gICAgICAqdGhpcwogICAgICogQHN0YWJsZQogICAgICovCiAgICBMb2NhbGUmICAgICAgICAgICAgICAgICAgICAgb3BlcmF0b3I9KGNvbnN0IExvY2FsZSYgb3RoZXIpOwoKICAgIC8qKgogICAgICogQ2hlY2tzIGlmIHR3byBsb2NhbGUga2V5cyBhcmUgdGhlIHNhbWUuCiAgICAgKgogICAgICogQHBhcmFtIG90aGVyIFRoZSBsb2NhbGUga2V5IG9iamVjdCB0byBiZSBjb21wYXJlZCB3aXRoIHRoaXMuCiAgICAgKiBAcmV0dXJuICAgICAgVHJ1ZSBpZiB0aGUgdHdvIGxvY2FsZSBrZXlzIGFyZSB0aGUgc2FtZSwgZmFsc2Ugb3RoZXJ3aXNlLgogICAgICogQHN0YWJsZQogICAgICovCiAgICAgICAgICAgICAgICBib29sX3QgICAgICAgICAgb3BlcmF0b3I9PShjb25zdCAgICBMb2NhbGUmICAgICBvdGhlcikgY29uc3Q7ICAgCgogICAgLyoqCiAgICAgKiBDaGVja3MgaWYgdHdvIGxvY2FsZSBrZXlzIGFyZSBub3QgdGhlIHNhbWUuCiAgICAgKgogICAgICogQHBhcmFtIG90aGVyIFRoZSBsb2NhbGUga2V5IG9iamVjdCB0byBiZSBjb21wYXJlZCB3aXRoIHRoaXMuCiAgICAgKiBAcmV0dXJuICAgICAgVHJ1ZSBpZiB0aGUgdHdvIGxvY2FsZSBrZXlzIGFyZSBub3QgdGhlIHNhbWUsIGZhbHNlCiAgICAgKiAgICAgICAgICAgICAgb3RoZXJ3aXNlLgogICAgICogQHN0YWJsZQogICAgICovCiAgICAgICAgICAgICAgICBib29sX3QgICAgICAgICAgb3BlcmF0b3IhPShjb25zdCAgICBMb2NhbGUmICAgICBvdGhlcikgY29uc3Q7CgogICAgLyoqCiAgICAgKiBDb21tb24gbWV0aG9kcyBvZiBnZXR0aW5nIHRoZSBjdXJyZW50IGRlZmF1bHQgTG9jYWxlLiBVc2VkIGZvciB0aGUKICAgICAqIHByZXNlbnRhdGlvbjogbWVudXMsIGRpYWxvZ3MsIGV0Yy4gR2VuZXJhbGx5IHNldCBvbmNlIHdoZW4geW91ciBhcHBsZXQgb3IKICAgICAqIGFwcGxpY2F0aW9uIGlzIGluaXRpYWxpemVkLCB0aGVuIG5ldmVyIHJlc2V0LiAoSWYgeW91IGRvIHJlc2V0IHRoZQogICAgICogZGVmYXVsdCBsb2NhbGUsIHlvdSBwcm9iYWJseSB3YW50IHRvIHJlbG9hZCB5b3VyIEdVSSwgc28gdGhhdCB0aGUgY2hhbmdlCiAgICAgKiBpcyByZWZsZWN0ZWQgaW4geW91ciBpbnRlcmZhY2UuKQogICAgICoKICAgICAqIE1vcmUgYWR2YW5jZWQgcHJvZ3JhbXMgd2lsbCBhbGxvdyB1c2VycyB0byB1c2UgZGlmZmVyZW50IGxvY2FsZXMgZm9yCiAgICAgKiBkaWZmZXJlbnQgZmllbGRzLCBlLmcuIGluIGEgc3ByZWFkc2hlZXQuCiAgICAgKgogICAgICogTm90ZSB0aGF0IHRoZSBpbml0aWFsIHNldHRpbmcgd2lsbCBtYXRjaCB0aGUgaG9zdCBzeXN0ZW0uCiAgICAgKiBAc3lzdGVtCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgIHN0YXRpYyAgTG9jYWxlJiAgICAgICAgICAgICBnZXREZWZhdWx0KHZvaWQpOwoKICAgIC8qKgogICAgICogU2V0cyB0aGUgZGVmYXVsdC4gTm9ybWFsbHkgc2V0IG9uY2UgYXQgdGhlIGJlZ2lubmluZyBvZiBhcHBsZXQgb3IKICAgICAqIGFwcGxpY2F0aW9uLCB0aGVuIG5ldmVyIHJlc2V0LiBzZXREZWZhdWx0IGRvZXMgTk9UIHJlc2V0IHRoZSBob3N0IGxvY2FsZS4KICAgICAqCiAgICAgKiBAcGFyYW0gbmV3TG9jYWxlIExvY2FsZSB0byBzZXQgdG8uCiAgICAgKiBAc3lzdGVtCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgIHN0YXRpYyAgICAgIHZvaWQgICAgICAgICAgICBzZXREZWZhdWx0KGNvbnN0ICAgIExvY2FsZSYgICAgIG5ld0xvY2FsZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFVFcnJvckNvZGUmICBzdWNjZXNzKTsKCiAgICAvKioKICAgICAqIEZpbGxzIGluICJsYW5nIiB3aXRoIHRoZSBsb2NhbGUncyB0d28tbGV0dGVyIElTTy02MzkgbGFuZ3VhZ2UgY29kZS4KICAgICAqIEBwYXJhbSBsYW5nICBSZWNlaXZlcyB0aGUgbGFuZ3VhZ2UgY29kZS4KICAgICAqIEByZXR1cm4gICAgICBBIHJlZmVyZW5jZSB0byAibGFuZyIuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBnZXRMYW5ndWFnZSggICAgICAgIFVuaWNvZGVTdHJpbmcmICBsYW5nKSBjb25zdDsKICAgIC8qKgogICAgICogRmlsbHMgaW4gImNudHJ5IiB3aXRoIHRoZSBsb2NhbGUncyB0d28tbGV0dGVyIElTTy0zMTY2IGNvdW50cnkgY29kZS4KICAgICAqIEBwYXJhbSBjbnRyeSBSZWNlaXZlcyB0aGUgY291bnRyeSBjb2RlLgogICAgICogQHJldHVybiAgICAgIEEgcmVmZXJlbmNlIHRvICJjbnRyeSIuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBnZXRDb3VudHJ5KCAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBjbnRyeSkgY29uc3Q7CiAgICAvKioKICAgICAqIEZpbGxzIGluICJ2YXIiIHdpdGggdGhlIGxvY2FsZSdzIHZhcmlhbnQgY29kZS4KICAgICAqIEBwYXJhbSB2YXIgICBSZWNlaXZlcyB0aGUgdmFyaWFudCBjb2RlLgogICAgICogQHJldHVybiAgICAgIEEgcmVmZXJlbmNlIHRvICJ2YXIiLgogICAgICogQHN0YWJsZQogICAgICovCiAgICAgICAgICAgICAgICBVbmljb2RlU3RyaW5nJiAgZ2V0VmFyaWFudCggICAgICAgICBVbmljb2RlU3RyaW5nJiAgdmFyKSBjb25zdDsKCiAgICAvKioKICAgICAqIEZpbGxzIGluICJuYW1lIiB0aGUgcHJvZ3JhbW1hdGljIG5hbWUgb2YgdGhlIGVudGlyZSBsb2NhbGUsIHdpdGggdGhlIGxhbmd1YWdlLAogICAgICogY291bnRyeSBhbmQgdmFyaWFudCBzZXBhcmF0ZWQgYnkgdW5kZXJiYXJzLiBJZiBhIGZpZWxkIGlzIG1pc3NpbmcsIGF0CiAgICAgKiBtb3N0IG9uZSB1bmRlcmJhciB3aWxsIG9jY3VyLiBFeGFtcGxlOiAiZW4iLCAiZGVfREUiLCAiZW5fVVNfV0lOIiwKICAgICAqICJkZV9QT1NJWCIsICJmcl9NQUMiCiAgICAgKiBAcGFyYW0gdmFyICAgUmVjZWl2ZXMgdGhlIHByb2dyYW1tYXRpYyBsb2NhbGUgbmFtZS4KICAgICAqIEByZXR1cm4gICAgICBBIHJlZmVyZW5jZSB0byAibmFtZSIuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBnZXROYW1lKCAgICAgICAgVW5pY29kZVN0cmluZyYgIG5hbWUpIGNvbnN0OwoKCS8qKgogICAgICogUmV0dXJucyB0aGUgcHJvZ3JhbW1hdGljIG5hbWUgb2YgdGhlIGVudGlyZSBsb2NhbGUsIHdpdGggdGhlIGxhbmd1YWdlLAogICAgICogY291bnRyeSBhbmQgdmFyaWFudCBzZXBhcmF0ZWQgYnkgdW5kZXJiYXJzLiBJZiBhIGZpZWxkIGlzIG1pc3NpbmcsIGF0CiAgICAgKiBtb3N0IG9uZSB1bmRlcmJhciB3aWxsIG9jY3VyLiBFeGFtcGxlOiAiZW4iLCAiZGVfREUiLCAiZW5fVVNfV0lOIiwKICAgICAqICJkZV9QT1NJWCIsICJmcl9NQUMiCiAgICAgKiBAcmV0dXJuICAgICAgQSBwb2ludGVyIHRvICJuYW1lIi4KICAgICAqLwoJCQkJY29uc3QgY2hhciAqIGdldE5hbWUoKSBjb25zdDsKCiAgICAvKioKICAgICAqIEZpbGxzIGluICJuYW1lIiB3aXRoIHRoZSBsb2NhbGUncyB0aHJlZS1sZXR0ZXIgbGFuZ3VhZ2UgY29kZSwgYXMgc3BlY2lmaWVkCiAgICAgKiBpbiBJU08gZHJhZnQgc3RhbmRhcmQgSVNPLTYzOS0yLi4KICAgICAqIEBwYXJhbSBuYW1lICBSZWNlaXZlcyB0aGUgdGhyZWUtbGV0dGVyIGxhbmd1YWdlIGNvZGUuCiAgICAgKiBAcGFyYW0gc3RhdHVzIEFuIFVFcnJvckNvZGUgdG8gcmVjZWl2ZSBhbnkgTUlTU0lOR19SRVNPVVJDRV9FUlJPUnMKICAgICAqIEByZXR1cm4gICAgICBBIHJlZmVyZW5jZSB0byAibmFtZSIuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBnZXRJU08zTGFuZ3VhZ2UoVW5pY29kZVN0cmluZyYgIG5hbWUsIFVFcnJvckNvZGUmIHN0YXR1cykgY29uc3Q7CgogICAgLyoqCiAgICAgKiBAZGVwcmVjYXRlZCB1c2UgZ2V0SVNPM0xhbmd1YWdlKFVuaWNvZGVTdHJpbmcmLCBVRXJyb3JDb2RlJikgaW5zdGVhZAogICAgICovCiAgICAgICAgICAgICAgICBVbmljb2RlU3RyaW5nJiAgZ2V0SVNPM0xhbmd1YWdlKFVuaWNvZGVTdHJpbmcmICBuYW1lKSBjb25zdDsKCiAgICAvKioKICAgICAqIEZpbGxzIGluICJuYW1lIiB3aXRoIHRoZSBsb2NhbGUncyB0aHJlZS1sZXR0ZXIgSVNPLTMxNjYgY291bnRyeSBjb2RlLgogICAgICogQHBhcmFtIG5hbWUgIFJlY2VpdmVzIHRoZSB0aHJlZS1sZXR0ZXIgY291bnRyeSBjb2RlLgogICAgICogQHBhcmFtIHN0YXR1cyBBbiBVRXJyb3JDb2RlIHRvIHJlY2VpdmUgYW55IE1JU1NJTkdfUkVTT1VSQ0VfRVJST1JzCiAgICAgKiBAcmV0dXJuICAgICAgQSByZWZlcmVuY2UgdG8gIm5hbWUiLgogICAgICogQHN0YWJsZQogICAgICovCiAgICAgICAgICAgICAgICBVbmljb2RlU3RyaW5nJiAgZ2V0SVNPM0NvdW50cnkoIFVuaWNvZGVTdHJpbmcmICBuYW1lLCBVRXJyb3JDb2RlJiBzdGF0dXMpIGNvbnN0OwoKICAgIC8qKgogICAgICogQGRlcHJlY2F0ZWQgdXNlIGdldElTTzNDb3VudHJ5KFVuaWNvZGVTdHJpbmcmLCBVRXJyb3JDb2RlJik7IGluc3RlYWQKICAgICAqLwogICAgICAgICAgICAgICAgVW5pY29kZVN0cmluZyYgIGdldElTTzNDb3VudHJ5KCBVbmljb2RlU3RyaW5nJiAgbmFtZSkgY29uc3Q7CgogICAgLyoqCiAgICAgKiBSZXR1cm5zIHRoZSBXaW5kb3dzIExDSUQgdmFsdWUgY29ycmVzcG9uZGluZyB0byB0aGlzIGxvY2FsZS4KICAgICAqIFRoaXMgdmFsdWUgaXMgc3RvcmVkIGluIHRoZSByZXNvdXJjZSBkYXRhIGZvciB0aGUgbG9jYWxlIGFzIGEgb25lLXRvLWZvdXItZGlnaXQKICAgICAqIGhleGFkZWNpbWFsIG51bWJlci4gIElmIHRoZSByZXNvdXJjZSBpcyBtaXNzaW5nLCBpbiB0aGUgd3JvbmcgZm9ybWF0LCBvcgogICAgICogdGhlcmUgaXMgbm8gV2luZG93cyBMQ0lEIHZhbHVlIHRoYXQgY29ycmVzcG9uZHMgdG8gdGhpcyBsb2NhbGUsIHJldHVybnMgMC4KICAgICAqIEBzdGFibGUKICAgICAqLwogICAgICAgICAgICAgICAgdWludDMyX3QgICAgICAgIGdldExDSUQodm9pZCkgY29uc3Q7CgogICAgLyoqCiAgICAgKiBGaWxscyBpbiAiZGlzcExhbmciIHdpdGggdGhlIG5hbWUgb2YgdGhpcyBsb2NhbGUncyBsYW5ndWFnZSBpbiBhIGZvcm1hdCBzdWl0YWJsZSBmb3IKICAgICAqIHVzZXIgZGlzcGxheSBpbiB0aGUgZGVmYXVsdCBsb2NhbGUuICBGb3IgZXhhbXBsZSwgaWYgdGhlIGxvY2FsZSdzIGxhbmd1YWdlIGNvZGUgaXMKICAgICAqICJmciIgYW5kIHRoZSBkZWZhdWx0IGxvY2FsZSdzIGxhbmd1YWdlIGNvZGUgaXMgImVuIiwgdGhpcyBmdW5jdGlvbiB3b3VsZCBzZXQKICAgICAqIGRpc3BMYW5nIHRvICJGcmVuY2giLgogICAgICogQHBhcmFtIGRpc3BMYW5nICBSZWNlaXZlcyB0aGUgbGFuZ3VhZ2UncyBkaXNwbGF5IG5hbWUuCiAgICAgKiBAcmV0dXJuICAgICAgICAgIEEgcmVmZXJlbmNlIHRvICJkaXNwTGFuZyIuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBnZXREaXNwbGF5TGFuZ3VhZ2UoVW5pY29kZVN0cmluZyYgICBkaXNwTGFuZykgY29uc3Q7CgogICAgLyoqCiAgICAgKiBGaWxscyBpbiAiZGlzcExhbmciIHdpdGggdGhlIG5hbWUgb2YgdGhpcyBsb2NhbGUncyBsYW5ndWFnZSBpbiBhIGZvcm1hdCBzdWl0YWJsZSBmb3IKICAgICAqIHVzZXIgZGlzcGxheSBpbiB0aGUgbG9jYWxlIHNwZWNpZmllZCBieSAiaW5Mb2NhbGUiLiAgRm9yIGV4YW1wbGUsIGlmIHRoZSBsb2NhbGUncwogICAgICogbGFuZ3VhZ2UgY29kZSBpcyAiZW4iIGFuZCBpbkxvY2FsZSdzIGxhbmd1YWdlIGNvZGUgaXMgImZyIiwgdGhpcyBmdW5jdGlvbiB3b3VsZCBzZXQKICAgICAqIGRpc3BMYW5nIHRvICJBbmdsYWlzIi4KICAgICAqIEBwYXJhbSBpbkxvY2FsZSAgU3BlY2lmaWVzIHRoZSBsb2NhbGUgdG8gYmUgdXNlZCB0byBkaXNwbGF5IHRoZSBuYW1lLiAgSW4gb3RoZXIgd29yZHMsCiAgICAgKiAgICAgICAgICAgICAgICAgIGlmIHRoZSBsb2NhbGUncyBsYW5ndWFnZSBjb2RlIGlzICJlbiIsIHBhc3NpbmcgTG9jYWxlOjpGUkVOQ0ggZm9yCiAgICAgKiAgICAgICAgICAgICAgICAgIGluTG9jYWxlIHdvdWxkIHJlc3VsdCBpbiAiQW5nbGFpcyIsIHdoaWxlIHBhc3NpbmcgTG9jYWxlOjpHRVJNQU4KICAgICAqICAgICAgICAgICAgICAgICAgZm9yIGluTG9jYWxlIHdvdWxkIHJlc3VsdCBpbiAiRW5nbGlzY2giLgogICAgICogQHBhcmFtIGRpc3BMYW5nICBSZWNlaXZlcyB0aGUgbGFuZ3VhZ2UncyBkaXNwbGF5IG5hbWUuCiAgICAgKiBAcmV0dXJuICAgICAgICAgIEEgcmVmZXJlbmNlIHRvICJkaXNwTGFuZyIuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBnZXREaXNwbGF5TGFuZ3VhZ2UoIGNvbnN0ICAgTG9jYWxlJiAgICAgICAgIGluTG9jYWxlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVbmljb2RlU3RyaW5nJiAgZGlzcExhbmcpIGNvbnN0OwogICAgLyoqCiAgICAgKiBGaWxscyBpbiAiZGlzcENvdW50cnkiIHdpdGggdGhlIG5hbWUgb2YgdGhpcyBsb2NhbGUncyBjb3VudHJ5IGluIGEgZm9ybWF0IHN1aXRhYmxlCiAgICAgKiBmb3IgdXNlciBkaXNwbGF5IGluIHRoZSBkZWZhdWx0IGxvY2FsZS4gIEZvciBleGFtcGxlLCBpZiB0aGUgbG9jYWxlJ3MgY291bnRyeSBjb2RlCiAgICAgKiBpcyAiRlIiIGFuZCB0aGUgZGVmYXVsdCBsb2NhbGUncyBsYW5ndWFnZSBjb2RlIGlzICJlbiIsIHRoaXMgZnVuY3Rpb24gd291bGQgc2V0CiAgICAgKiBkaXNwQ291bnRyeSB0byAiRnJhbmNlIi4KICAgICAqIEBwYXJhbSBkaXNwQ291bnRyeSAgIFJlY2VpdmVzIHRoZSBjb3VudHJ5J3MgZGlzcGxheSBuYW1lLgogICAgICogQHJldHVybiAgICAgICAgICAgICAgQSByZWZlcmVuY2UgdG8gImRpc3BDb3VudHJ5Ii4KICAgICAqIEBzdGFibGUKICAgICAqLwogICAgICAgICAgICAgICAgVW5pY29kZVN0cmluZyYgIGdldERpc3BsYXlDb3VudHJ5KCAgICAgICAgICBVbmljb2RlU3RyaW5nJiBkaXNwQ291bnRyeSkgY29uc3Q7CiAgICAvKioKICAgICAqIEZpbGxzIGluICJkaXNwQ291bnRyeSIgd2l0aCB0aGUgbmFtZSBvZiB0aGlzIGxvY2FsZSdzIGNvdW50cnkgaW4gYSBmb3JtYXQgc3VpdGFibGUKICAgICAqIGZvciB1c2VyIGRpc3BsYXkgaW4gdGhlIGxvY2FsZSBzcGVjaWZpZWQgYnkgImluTG9jYWxlIi4gIEZvciBleGFtcGxlLCBpZiB0aGUgbG9jYWxlJ3MKICAgICAqIGNvdW50cnkgY29kZSBpcyAiVVMiIGFuZCBpbkxvY2FsZSdzIGxhbmd1YWdlIGNvZGUgaXMgImZyIiwgdGhpcyBmdW5jdGlvbiB3b3VsZCBzZXQKICAgICAqIGRpc3BDb3VudHJ5IHRvICJFdGF0cy1VbmlzIi4KICAgICAqIEBwYXJhbSBpbkxvY2FsZSAgICAgIFNwZWNpZmllcyB0aGUgbG9jYWxlIHRvIGJlIHVzZWQgdG8gZGlzcGxheSB0aGUgbmFtZS4gIEluIG90aGVyCiAgICAgKiAgICAgICAgICAgICAgICAgICAgICB3b3JkcywgaWYgdGhlIGxvY2FsZSdzIGNvdW50cnkgY29kZSBpcyAiVVMiLCBwYXNzaW5nCiAgICAgKiAgICAgICAgICAgICAgICAgICAgICBMb2NhbGU6OkZSRU5DSCBmb3IgaW5Mb2NhbGUgd291bGQgcmVzdWx0IGluICLJdGF0cy1VbmlzIiwgd2hpbGUKICAgICAqICAgICAgICAgICAgICAgICAgICAgIHBhc3NpbmcgTG9jYWxlOjpHRVJNQU4gZm9yIGluTG9jYWxlIHdvdWxkIHJlc3VsdCBpbgogICAgICogICAgICAgICAgICAgICAgICAgICAgIlZlcmVpbmlndGUgU3RhYXRlbiIuCiAgICAgKiBAcGFyYW0gZGlzcENvdW50cnkgICBSZWNlaXZlcyB0aGUgY291bnRyeSdzIGRpc3BsYXkgbmFtZS4KICAgICAqIEByZXR1cm4gICAgICAgICAgICAgIEEgcmVmZXJlbmNlIHRvICJkaXNwQ291bnRyeSIuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBnZXREaXNwbGF5Q291bnRyeSggIGNvbnN0ICAgTG9jYWxlJiAgICAgICAgIGluTG9jYWxlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVbmljb2RlU3RyaW5nJiAgZGlzcENvdW50cnkpIGNvbnN0OwoKICAgIC8qKgogICAgICogRmlsbHMgaW4gImRpc3BWYXIiIHdpdGggdGhlIG5hbWUgb2YgdGhpcyBsb2NhbGUncyB2YXJpYW50IGNvZGUgaW4gYSBmb3JtYXQgc3VpdGFibGUKICAgICAqIGZvciB1c2VyIGRpc3BsYXkgaW4gdGhlIGRlZmF1bHQgbG9jYWxlLgogICAgICogQHBhcmFtIGRpc3BWYXIgICBSZWNlaXZlcyB0aGUgdmFyaWFudCdzIG5hbWUuCiAgICAgKiBAcmV0dXJuICAgICAgICAgIEEgcmVmZXJlbmNlIHRvICJkaXNwVmFyIi4KICAgICAqIEBzdGFibGUKICAgICAqLwogICAgICAgICAgICAgICAgVW5pY29kZVN0cmluZyYgIGdldERpc3BsYXlWYXJpYW50KCAgICAgIFVuaWNvZGVTdHJpbmcmIGRpc3BWYXIpIGNvbnN0OwogICAgLyoqCiAgICAgKiBGaWxscyBpbiAiZGlzcFZhciIgd2l0aCB0aGUgbmFtZSBvZiB0aGlzIGxvY2FsZSdzIHZhcmlhbnQgY29kZSBpbiBhIGZvcm1hdAogICAgICogc3VpdGFibGUgZm9yIHVzZXIgZGlzcGxheSBpbiB0aGUgbG9jYWxlIHNwZWNpZmllZCBieSAiaW5Mb2NhbGUiLgogICAgICogQHBhcmFtIGluTG9jYWxlICBTcGVjaWZpZXMgdGhlIGxvY2FsZSB0byBiZSB1c2VkIHRvIGRpc3BsYXkgdGhlIG5hbWUuCiAgICAgKiBAcGFyYW0gZGlzcFZhciAgIFJlY2VpdmVzIHRoZSB2YXJpYW50J3MgZGlzcGxheSBuYW1lLgogICAgICogQHJldHVybiAgICAgICAgICBBIHJlZmVyZW5jZSB0byAiZGlzcFZhciIuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBnZXREaXNwbGF5VmFyaWFudCggIGNvbnN0ICAgTG9jYWxlJiAgICAgICAgIGluTG9jYWxlLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVbmljb2RlU3RyaW5nJiAgZGlzcFZhcikgY29uc3Q7CiAgICAvKioKICAgICAqIEZpbGxzIGluICJuYW1lIiB3aXRoIHRoZSBuYW1lIG9mIHRoaXMgbG9jYWxlIGluIGEgZm9ybWF0IHN1aXRhYmxlIGZvciB1c2VyIGRpc3BsYXkgCiAgICAgKiBpbiB0aGUgZGVmYXVsdCBsb2NhbGUuICBUaGlzIGZ1bmN0aW9uIHVzZXMgZ2V0RGlzcGxheUxhbmd1YWdlKCksIGdldERpc3BsYXlDb3VudHJ5KCksCiAgICAgKiBhbmQgZ2V0RGlzcGxheVZhcmlhbnQoKSB0byBkbyBpdHMgd29yaywgYW5kIG91dHB1dHMgdGhlIGRpc3BsYXkgbmFtZSBpbiB0aGUgZm9ybWF0CiAgICAgKiAibGFuZ3VhZ2UgKGNvdW50cnlbLHZhcmlhbnRdKSIuICBGb3IgZXhhbXBsZSwgaWYgdGhlIGRlZmF1bHQgbG9jYWxlIGlzIGVuX1VTLCB0aGVuCiAgICAgKiBmcl9GUidzIGRpc3BsYXkgbmFtZSB3b3VsZCBiZSAiRnJlbmNoIChGcmFuY2UpIiwgYW5kIGVzX01YX1RyYWRpdGlvbmFsJ3MgZGlzcGxheSBuYW1lCiAgICAgKiB3b3VsZCBiZSAiU3BhbmlzaCAoTWV4aWNvLFRyYWRpdGlvbmFsKSIuCiAgICAgKiBAcGFyYW0gbmFtZSAgUmVjZWl2ZXMgdGhlIGxvY2FsZSdzIGRpc3BsYXkgbmFtZS4KICAgICAqIEByZXR1cm4gICAgICBBIHJlZmVyZW5jZSB0byAibmFtZSIuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgICAgICAgICAgICAgIFVuaWNvZGVTdHJpbmcmICBnZXREaXNwbGF5TmFtZSggICAgICAgICBVbmljb2RlU3RyaW5nJiAgbmFtZSkgY29uc3Q7CiAgICAvKioKICAgICAqIEZpbGxzIGluICJuYW1lIiB3aXRoIHRoZSBuYW1lIG9mIHRoaXMgbG9jYWxlIGluIGEgZm9ybWF0IHN1aXRhYmxlIGZvciB1c2VyIGRpc3BsYXkgCiAgICAgKiBpbiB0aGUgbG9jYWxlIHNwZWNmaWVkIGJ5ICJpbkxvY2FsZSIuICBUaGlzIGZ1bmN0aW9uIHVzZXMgZ2V0RGlzcGxheUxhbmd1YWdlKCksCiAgICAgKiBnZXREaXNwbGF5Q291bnRyeSgpLCBhbmQgZ2V0RGlzcGxheVZhcmlhbnQoKSB0byBkbyBpdHMgd29yaywgYW5kIG91dHB1dHMgdGhlIGRpc3BsYXkKICAgICAqIG5hbWUgaW4gdGhlIGZvcm1hdCAibGFuZ3VhZ2UgKGNvdW50cnlbLHZhcmlhbnRdKSIuICBGb3IgZXhhbXBsZSwgaWYgaW5Mb2NhbGUgaXMKICAgICAqIGZyX0ZSLCB0aGVuIGVuX1VTJ3MgZGlzcGxheSBuYW1lIHdvdWxkIGJlICJBbmdsYWlzICjJdGF0cy1VbmlzKSIsIGFuZCBub19OT19OWSdzCiAgICAgKiBkaXNwbGF5IG5hbWUgd291bGQgYmUgIm5vcnbpZ2llbiAoTm9yduhnZSxOWSkiLgogICAgICogQHBhcmFtIGluTG9jYWxlICBTcGVjaWZpZXMgdGhlIGxvY2FsZSB0byBiZSB1c2VkIHRvIGRpc3BsYXkgdGhlIG5hbWUuCiAgICAgKiBAcGFyYW0gbmFtZSAgICAgIFJlY2VpdmVzIHRoZSBsb2NhbGUncyBkaXNwbGF5IG5hbWUuCiAgICAgKiBAcmV0dXJuICAgICAgICAgIEEgcmVmZXJlbmNlIHRvICJuYW1lIi4KICAgICAqIEBzdGFibGUKICAgICAqLwogICAgICAgICAgICAgICAgVW5pY29kZVN0cmluZyYgIGdldERpc3BsYXlOYW1lKCBjb25zdCAgIExvY2FsZSYgICAgICAgICBpbkxvY2FsZSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBVbmljb2RlU3RyaW5nJiAgbmFtZSkgY29uc3Q7CiAgICAvKioKICAgICAqIEdlbmVyYXRlcyBhIGhhc2ggY29kZSBmb3IgdGhlIGxvY2FsZS4gU2luY2UgTG9jYWxlcyBhcmUgb2Z0ZW4gdXNlZCBpbiBoYXNodGFibGVzLCAKICAgICAqIGNhY2hlcyB0aGUgdmFsdWUgZm9yIHNwZWVkLgogICAgICogQHN0YWJsZQogICAgICovCiAgICAgICAgICAgICAgICBpbnQzMl90ICAgICAgICAgaGFzaENvZGUodm9pZCkgY29uc3Q7CgogICAgLyoqCiAgICAgKiBSZXR1cm5zIGEgbGlzdCBvZiBhbGwgaW5zdGFsbGVkIGxvY2FsZXMuCiAgICAgKiBAcGFyYW0gY291bnQgUmVjZWl2ZXMgdGhlIG51bWJlciBvZiBsb2NhbGVzIGluIHRoZSBsaXN0LgogICAgICogQHJldHVybiAgICAgIEEgcG9pbnRlciB0byBhbiBhcnJheSBvZiBMb2NhbGUgb2JqZWN0cy4gIFRoaXMgYXJyYXkgaXMgdGhlIGxpc3QKICAgICAqICAgICAgICAgICAgICBvZiBhbGwgbG9jYWxlcyB3aXRoIGluc3RhbGxlZCByZXNvdXJjZSBmaWxlcy4gIFRoZSBjYWxsZWQgZG9lcyBOT1QKICAgICAqICAgICAgICAgICAgICBnZXQgb3duZXJzaGlwIG9mIHRoaXMgbGlzdCwgYW5kIG11c3QgTk9UIGRlbGV0ZSBpdC4KICAgICAqIEBzdGFibGUKICAgICAqLwogICAgc3RhdGljICBjb25zdCAgIExvY2FsZSogICAgIGdldEF2YWlsYWJsZUxvY2FsZXMoaW50MzJfdCYgY291bnQpOwoKICAgIC8qKgogICAgICogUmV0dXJucyBhIGxpc3Qgb2YgYWxsIDItbGV0dGVyIGNvdW50cnkgY29kZXMgZGVmaW5lZCBpbiBJU08gMzE2Ni4KICAgICAqIENhbiBiZSB1c2VkIHRvIGNyZWF0ZSBMb2NhbGVzLgogICAgICogQHBhcmFtIGNvdW50IFJlY2VpdmVzIHRoZSBudW1iZXIgb2YgY291bnRyaWVzIGluIHRoZSBsaXN0LgogICAgICogQHJldHVybiBBIHBvaW50ZXIgdG8gYW4gYXJyYXkgb2YgVW5pY29kZVN0cmluZyBvYmplY3RzLiBUaGUgY2FsbGVyIGRvZXMgTk9UCiAgICAgKiAgZ2V0IG93bmVyc2hpcCBvZiB0aGlzIGxpc3QsIGFuZCBtdXN0IE5PVCBkZWxldGUgaXQuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgIHN0YXRpYyBjb25zdCBVbmljb2RlU3RyaW5nKiBnZXRJU09Db3VudHJpZXMoaW50MzJfdCYgY291bnQpOwoKICAgIC8qKgogICAgICogUmV0dXJucyBhIGxpc3Qgb2YgYWxsIDItbGV0dGVyIGxhbmd1YWdlIGNvZGVzIGRlZmluZWQgaW4gSVNPIDYzOS4KICAgICAqIENhbiBiZSB1c2VkIHRvIGNyZWF0ZSBMb2NhbGVzLgogICAgICogW05PVEU6ICBJU08gNjM5IGlzIG5vdCBhIHN0YWJsZSBzdGFuZGFyZC0tIHNvbWUgbGFuZ3VhZ2VzJyBjb2RlcyBoYXZlIGNoYW5nZWQuCiAgICAgKiBUaGUgbGlzdCB0aGlzIGZ1bmN0aW9uIHJldHVybnMgaW5jbHVkZXMgYm90aCB0aGUgbmV3IGFuZCB0aGUgb2xkIGNvZGVzIGZvciB0aGUKICAgICAqIGxhbmd1YWdlcyB3aG9zZSBjb2RlcyBoYXZlIGNoYW5nZWQuXQogICAgICogQHBhcmFtIGNvdW50IFJlY2VpdmVzIHRoZSBudW1iZXIgb2YgbGFuZ3VhZ2VzIGluIHRoZSBsaXN0LgogICAgICogQHJldHVybiBBIHBvaW50ZXIgdG8gYW4gYXJyYXkgb2YgVW5pY29kZVN0cmluZyBvYmplY3RzLiBUaGUgY2FsbGVyIGRvZXMgTk9UCiAgICAgKiAgZ2V0IG93bmVyc2hpcCBvZiB0aGlzIGxpc3QsIGFuZCBtdXN0IE5PVCBkZWxldGUgaXQuCiAgICAgKiBAc3RhYmxlCiAgICAgKi8KICAgIHN0YXRpYyBjb25zdCBVbmljb2RlU3RyaW5nKiBnZXRJU09MYW5ndWFnZXMoaW50MzJfdCYgY291bnQpOwogICAgCiAgICAvKioKICAgICAqIERlcHJlY2F0ZWQgMTk5OWRlYzE0IC0gR2V0IHRoZSBwYXRoIHRvIHRoZSBSZXNvdXJjZUJ1bmRsZSBsb2NhbGUgZmlsZXMuIFRoaXMgcGF0aCB3aWxsIGJlIGEKICAgICAqIHBsYXRmb3JtLXNwZWNpZmljIHBhdGggbmFtZSBlbmRpbmcgaW4gYSBkaXJlY3Rvcnkgc2VwYXJhdG9yLCBzbyB0aGF0IGZpbGUKICAgICAqIG5hbWVzIG1heSBiZSBjb25jYXRlbmF0ZWQgdG8gaXQuIFRoaXMgcGF0aCBtYXkgYmUgY2hhbmdlZCBieSBjYWxsaW5nCiAgICAgKiBzZXREYXRhRGlyZWN0b3J5KCkuIElmIHNldERhdGFEaXJlY3RvcnkoKSBoYXMgbm90IGJlZW4gY2FsbGVkIHlldCwKICAgICAqIGdldERhdGFEaXJlY3RvcnkoKSB3aWxsIHJldHVybiBhIHBsYXRmb3JtLWRlcGVuZGVudCBkZWZhdWx0IHBhdGggYXMKICAgICAqIHNwZWNpZmllZCBieSBUUGxhdGZvcm1VdGlsaXRpZXM6OmdldERlZmF1bHREYXRhRGlyZWN0b3J5KCkuCiAgICAgKgogICAgICogQHJldHVybiBDdXJyZW50IGRhdGEgcGF0aC4KICAgICAqIEBkZXByZWNhdGVkIDE5OTlkZWMxNAogICAgICovCiAgICBzdGF0aWMgIGNvbnN0ICAgY2hhciogICAgICAgZ2V0RGF0YURpcmVjdG9yeSh2b2lkKTsKCiAgICAvKioKICAgICAqIERlcHJlY2F0ZWQgMTk5OWRlYzE0IC0gU2V0IHRoZSBwYXRoIHRvIHRoZSBSZXNvdXJjZUJ1bmRsZSBsb2NhbGUgZmlsZXMuIEFmdGVyIG1ha2luZyB0aGlzIGNhbGwsCiAgICAgKiBhbGwgb2JqZWN0cyBpbiB0aGUgVW5pY29kZSBBbmFseXRpY3MgcGFja2FnZSB3aWxsIHJlYWQgUmVzb3VyY2VCdW5kbGUKICAgICAqIGRhdGEgZmlsZXMgaW4gdGhlIHNwZWNpZmllZCBkaXJlY3RvcnkgaW4gb3JkZXIgdG8gb2J0YWluIGxvY2FsZSBkYXRhLgogICAgICoKICAgICAqIEBwYXJhbSBwYXRoIFRoZSBuZXcgZGF0YSBwYXRoIHRvIGJlIHNldCB0by4KICAgICAqIEBkZXByZWNhdGVkIDE5OTlkZWMxNAogICAgICovCiAgICBzdGF0aWMgIHZvaWQgICAgICAgICAgICAgICAgc2V0RGF0YURpcmVjdG9yeShjb25zdCBjaGFyKiBwYXRoKTsKCiAgICAvKioKICAgICAqIEluaXRpYWxpemUgdGhlIGxvY2FsZSBvYmplY3Qgd2l0aCBhIG5ldyBuYW1lLgogICAgICoKICAgICAqIEBwYXJhbSBjTG9jYWxlSUQgVGhlIG5ldyBsb2NhbGUgbmFtZS4KICAgICAqIEBkZXByZWNhdGVkCiAgICAgKi8KICAgIExvY2FsZSYgaW5pdChjb25zdCBjaGFyKiBjTG9jYWxlSUQpOwogICAgCnByb3RlY3RlZDogLy8gb25seSBwcm90ZWN0ZWQgZm9yIHRlc3RpbmcgcHVycG9zZXMuIERPIE5PVCBVU0UuCiAgICB2b2lkIHNldEZyb21QT1NJWElEKGNvbnN0IFVuaWNvZGVTdHJpbmcmIHBvc2l4SUQpOyAvLyBzZXQgaXQgZnJvbSBhIHNpbmdsZSBzdHJpbmcuCiAgICB2b2lkIHNldEZyb21QT1NJWElEKGNvbnN0IGNoYXIgKnBvc2l4SUQpOyAvLyBzZXQgaXQgZnJvbSBhIHNpbmdsZSBzdHJpbmcuCgogICAgLyoqCiAgICAgKiBHaXZlbiBhbiBJU08gY291bnRyeSBjb2RlLCByZXR1cm5zIGFuIGFycmF5IG9mIFN0cmluZ3MgY29udGFpbmluZyB0aGUgSVNPCiAgICAgKiBjb2RlcyBvZiB0aGUgbGFuZ3VhZ2VzIHNwb2tlbiBpbiB0aGF0IGNvdW50cnkuICBPZmZpY2lhbCBsYW5ndWFnZXMgYXJlIGxpc3RlZAogICAgICogaW4gdGhlIHJldHVybmVkIHRhYmxlIGJlZm9yZSB1bm9mZmljaWFsIGxhbmd1YWdlcywgYnV0IG90aGVyIHRoYW4gdGhhdCwgdGhlCiAgICAgKiBvcmRlciBvZiB0aGUgcmV0dXJuZWQgbGlzdCBpcyBpbmRldGVybWluYXRlLiAgSWYgdGhlIHZhbHVlIHRoZSB1c2VyIHBhc3NlcyBpbgogICAgICogZm9yICJjb3VudHJ5IiBpcyBub3QgYSB2YWxpZCBJU08gMzE2IGNvdW50cnkgY29kZSwgb3IgaWYgd2UgZG9uJ3QgaGF2ZSBsYW5ndWFnZQogICAgICogaW5mb3JtYXRpb24gZm9yIHRoZSBzcGVjaWZpZWQgY291bnRyeSwgdGhpcyBmdW5jdGlvbiByZXR1cm5zIGFuIGVtcHR5IGFycmF5LgogICAgICoKICAgICAqIFtUaGlzIGZ1bmN0aW9uIGlzIG5vdCBjdXJyZW50bHkgcGFydCBvZiBMb2NhbGUncyBBUEksIGJ1dCBpcyBuZWVkZWQgaW4gdGhlCiAgICAgKiBpbXBsZW1lbnRhdGlvbi4gIFdlIGhvcGUgdG8gYWRkIGl0IHRvIHRoZSBBUEkgaW4gYSBmdXR1cmUgcmVsZWFzZS5dCiAgICAgKiBAcGFyYW0gY291bnRyeSBUaGUgSVNPIDItbGV0dGVyIGNvdW50cnkgY29kZSBvZiB0aGUgZGVzaXJlZCBjb3VudHJ5CiAgICAgKiBAcGFyYW0gY291bnQgUmVjZWl2ZXMgdGhlIG51bWJlciBvZiBsYW5ndWFnZXMgaW4gdGhlIGxpc3QuCiAgICAgKiBAcmV0dXJuIEEgcG9pbnRlciB0byBhbiBhcnJheSBvZiBVbmljb2RlU3RyaW5nIG9iamVjdHMuIFRoZSBjYWxsZXIgZG9lcyBOT1QKICAgICAqICBnZXQgb3duZXJzaGlwIG9mIHRoaXMgbGlzdCwgYW5kIG11c3QgTk9UIGRlbGV0ZSBpdC4KICAgICAqLwogICAgc3RhdGljIGNvbnN0IFVuaWNvZGVTdHJpbmcqIGdldExhbmd1YWdlc0ZvckNvdW50cnkoICAgIGNvbnN0IFVuaWNvZGVTdHJpbmcmIGNvdW50cnksIAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGludDMyX3QmIGNvdW50KTsKCgpwcml2YXRlOgogICAgCiAgICAvKioKICAgICAqIEluaXRpYWxpemVzIGEgTG9jYWxlIG9iamVjdCBmcm9tIGEgVUxvY2FsZSBzdHJ1Y3QsIHdoaWNoIGlzIHRoZSBDIGxvY2FsZSBvYmplY3QsCiAgICAgKiBhbmQgd2hlcmUgdGhlIGFjdHVhbCBpbXBsZW1lbnRhdGlvbiBpcy4KICAgICAqLwogICAgCiAgICB2b2lkIHNldEhhc2hDb2RlKHZvaWQpOwogICAgY2hhciBsYW5ndWFnZVtVTE9DX0xBTkdfQ0FQQUNJVFldOwogICAgY2hhciBjb3VudHJ5W1VMT0NfQ09VTlRSWV9DQVBBQ0lUWV07CiAgICBjaGFyKiB2YXJpYW50OwogICAgY2hhciogZnVsbE5hbWU7CiAgICBjaGFyIGZ1bGxOYW1lQnVmZmVyW1VMT0NfRlVMTE5BTUVfQ0FQQUNJVFldOwogICAgaW50MzJfdCBraGFzaENvZGU7CiAgICAKICAgIHN0YXRpYyBMb2NhbGUgKmxvY2FsZUxpc3Q7CiAgICBzdGF0aWMgaW50MzJfdCBsb2NhbGVMaXN0Q291bnQ7CiAgICBzdGF0aWMgVW5pY29kZVN0cmluZyAqaXNvTGFuZ3VhZ2VzOwogICAgc3RhdGljIGludDMyX3QgaXNvTGFuZ3VhZ2VzQ291bnQ7CiAgICBzdGF0aWMgVW5pY29kZVN0cmluZyAqaXNvQ291bnRyaWVzOwogICAgc3RhdGljIGludDMyX3QgaXNvQ291bnRyaWVzQ291bnQ7CiAgICBzdGF0aWMgVUhhc2h0YWJsZSAqY3RyeTJMYW5nTWFwcGluZzsKICAgIHN0YXRpYyBjb25zdCBVbmljb2RlU3RyaW5nIGNvbXByZXNzZWRDdHJ5MkxhbmdNYXBwaW5nOwoKICAgIHN0YXRpYyBMb2NhbGUgZmdEZWZhdWx0TG9jYWxlOwp9OwoKaW5saW5lIGJvb2xfdApMb2NhbGU6Om9wZXJhdG9yIT0oY29uc3QgICAgTG9jYWxlJiAgICAgb3RoZXIpIGNvbnN0CnsKICAgIHJldHVybiAhb3BlcmF0b3I9PShvdGhlcik7Cn0KCiNlbmRpZgoKCg==