PWhlYWQxIE5BTUUKCm1vZF9wZXJsX3R1bmluZyAtIG1vZF9wZXJsIHBlcmZvcm1hbmNlIHR1bmluZwoKPWhlYWQxIERFU0NSSVBUSU9OCgpEZXNjcmliZWQgaGVyZSBhcmUgZXhhbXBsZXMgYW5kIGhpbnRzIG9uIGhvdyB0byBjb25maWd1cmUgYSBtb2RfcGVybAplbmFibGVkIEFwYWNoZSBzZXJ2ZXIsIGNvbmNlbnRyYXRpbmcgb24gdGlwcyBmb3IgY29uZmlndXJhdGlvbiBmb3IKaGlnaC1zcGVlZCBwZXJmb3JtYW5jZS4gIFRoZSBwcmltYXJ5IHdheSB0byBhY2hpZXZlIG1heGltYWwKcGVyZm9ybWFuY2UgaXMgdG8gcmVkdWNlIHRoZSByZXNvdXJjZXMgY29uc3VtZWQgYnkgdGhlIG1vZF9wZXJsCmVuYWJsZWQgSFRUUEQgcHJvY2Vzc2VzLgoKVGhpcyBkb2N1bWVudCBhc3N1bWVzIGZhbWlsaWFyaXR5IHdpdGggQXBhY2hlIGNvbmZpZ3VyYXRpb24gZGlyZWN0aXZlcwpzb21lIGZhbWlsaWFyaXR5IHdpdGggdGhlIG1vZF9wZXJsIGNvbmZpZ3VyYXRpb24gZGlyZWN0aXZlcywgYW5kIHRoYXQKeW91IGhhdmUgYWxyZWFkeSBidWlsdCBhbmQgaW5zdGFsbGVkIGEgbW9kX3BlcmwgZW5hYmxlZCBBcGFjaGUgc2VydmVyLgpQbGVhc2UgYWxzbyByZWFkIHRoZSBtb2RfcGVybCBkb2N1bWVudGF0aW9uIHRoYXQgY29tZXMgd2l0aCBtb2RfcGVybApmb3IgcHJvZ3JhbW1pbmcgdGlwcy4gIFNvbWUgY29uZmlndXJhdGlvbnMgYmVsb3cgdXNlIGZlYXR1cmVzIGZyb20KbW9kX3BlcmwgdmVyc2lvbiAxLjAzIHdoaWNoIHdlcmUgbm90IHByZXNlbnQgaW4gZWFybGllciB2ZXJzaW9ucy4KClRoZXNlIHBlcmZvcm1hbmNlIHR1bmluZyBoaW50cyBhcmUgY29sbGVjdGVkIGZyb20gbXkgZXhwZXJpZW5jZXMgaW4Kc2V0dGluZyB1cCBhbmQgcnVubmluZyBzZXJ2ZXJzIGZvciBoYW5kbGluZyBsYXJnZSBwcm9tb3Rpb25hbCBzaXRlcywKc3VjaCBhcyBUaGUgV2VhdGhlciBDaGFubmVsJ3MgIkJsaW1wIFNpdGUtaW5ncyIgZ2FtZSwgdGhlIE1TSUUgNC4wCiJTdWJzY3JpYmUgdG8gV2luIiBnYW1lLCBhbmQgdGhlIE1TTiBNaWxsaW9uIERvbGxhciBNYWRuZXNzIGdhbWUuCgo9aGVhZDEgQkFTSUMgQ09ORklHVVJBVElPTgoKVGhlIGJhc2ljIGNvbmZpZ3VyYXRpb24gZm9yIG1vZF9wZXJsIGlzIGFzIGZvbGxvd3MuICBJbiB0aGUKRjxodHRwZC5jb25mPiBmaWxlLCBJIGFkZCBjb25maWd1cmF0aW9uIHBhcmFtZXRlcnMgdG8gbWFrZSB0aGUKQzxodHRwOi8vd3d3LmRvbWFpbi5jb20vcHJvZ3JhbXM+IFVSTCBiZSB0aGUgYmFzZSBsb2NhdGlvbiBmb3IgYWxsCm1vZF9wZXJsIHByb2dyYW1zLiAgVGh1cywgYWNjZXNzIHRvCkM8aHR0cDovL3d3dy5kb21haW4uY29tL3Byb2dyYW1zL3ByaW50ZW52PiB3aWxsIHJ1biB0aGUgcHJpbnRlbnYKc2NyaXB0LCBhcyB3ZSdsbCBzZWUgYmVsb3cuICBBbHNvLCBhbnkgKi5wZXJsIGZpbGUgd2lsbCBiZSBpbnRlcnByZXRlZAphcyBhIG1vZF9wZXJsIHByb2dyYW0ganVzdCBhcyBpZiBpdCB3ZXJlIGluIHRoZSBwcm9ncmFtcyBkaXJlY3RvcnksCmFuZCAqLnJwZXJsIHdpbGwgYmUgbW9kX3BlcmwsIGJ1dCBJPHdpdGhvdXQ+IGFueSBIVFRQIGhlYWRlcnMKYXV0b21hdGljYWxseSBzZW50OyB5b3UgbXVzdCBkbyB0aGlzIGV4cGxpY2l0bHkuICBJZiB5b3UgZG9uJ3Qgd2FudAp0aGVzZSBsYXN0IHR3bywganVzdCBsZWF2ZSBpdCBvdXQgb2YgeW91ciBjb25maWd1cmF0aW9uLgoKSW4gdGhlIGNvbmZpZ3VyYXRpb24gZmlsZXMsIEkgdXNlIEY8L3Zhci93d3c+IGFzIHRoZSBDPFNlcnZlclJvb3Q+CmRpcmVjdG9yeSwgYW5kIEY8L3Zhci93d3cvZG9jcz4gYXMgdGhlIEM8RG9jdW1lbnRSb290Pi4gIFlvdSB3aWxsIG5lZWQKdG8gY2hhbmdlIGl0IHRvIG1hdGNoIHlvdXIgcGFydGljdWxhciBzZXR1cC4gIFRoZSBuZXR3b3JrIGFkZHJlc3MgYmVsb3cKaW4gdGhlIGFjY2VzcyB0byBwZXJsLXN0YXR1cyBzaG91bGQgYWxzbyBiZSBjaGFuZ2VkIHRvIG1hdGNoIHlvdXJzLgoKQWRkaXRpb25zIHRvIEY8aHR0cGQuY29uZj46CgogIyBwdXQgbW9kX3BlcmwgcHJvZ3JhbXMgaGVyZQogIyBzdGFydHVwLnBlcmwgbG9hZHMgYWxsIGZ1bmN0aW9ucyB0aGF0IHdlIHdhbnQgdG8gdXNlIHdpdGhpbiBtb2RfcGVybAogUGVybHJlcXVpcmUgL3Zhci93d3cvcGVybGxpYi9zdGFydHVwLnBlcmwKIDxEaXJlY3RvcnkgL3Zhci93d3cvZG9jcy9wcm9ncmFtcz4KICAgQWxsb3dPdmVycmlkZSBOb25lCiAgIE9wdGlvbnMgRXhlY0NHSQogICBTZXRIYW5kbGVyIHBlcmwtc2NyaXB0CiAgIFBlcmxIYW5kbGVyIEFwYWNoZTo6UmVnaXN0cnkKICAgUGVybFNlbmRIZWFkZXIgT24KIDwvRGlyZWN0b3J5PgoKICMgbGlrZSBhYm92ZSwgYnV0IG5vIFBlcmxTZW5kSGVhZGVycwogPERpcmVjdG9yeSAvdmFyL3d3dy9kb2NzL3Jwcm9ncmFtcz4KICAgQWxsb3dPdmVycmlkZSBOb25lCiAgIE9wdGlvbnMgRXhlY0NHSQogICBTZXRIYW5kbGVyIHBlcmwtc2NyaXB0CiAgIFBlcmxIYW5kbGVyIEFwYWNoZTo6UmVnaXN0cnkKICAgUGVybFNlbmRIZWFkZXIgT2ZmCiA8L0RpcmVjdG9yeT4KCiAjIGFsbG93IGFyYml0cmFyeSAqLnBlcmwgZmlsZXMgdG8gYmUgc2NhdHRlcmVkIHRocm91Z2hvdXQgdGhlIHNpdGUuCiA8RmlsZXMgKi5wZXJsPgogICBTZXRIYW5kbGVyIHBlcmwtc2NyaXB0CiAgIFBlcmxIYW5kbGVyIEFwYWNoZTo6UmVnaXN0cnkKICAgUGVybFNlbmRIZWFkZXIgT24KICAgT3B0aW9ucyArRXhlY0NHSQogPC9GaWxlcz4KCiAjIGxpa2UgKi5wZXJsLCBidXQgZG8gbm90IHNlbmQgSFRUUCBoZWFkZXJzCiA8RmlsZXMgKi5ycGVybD4KICAgU2V0SGFuZGxlciBwZXJsLXNjcmlwdAogICBQZXJsSGFuZGxlciBBcGFjaGU6OlJlZ2lzdHJ5CiAgIFBlcmxTZW5kSGVhZGVyIE9mZgogICBPcHRpb25zICtFeGVjQ0dJCiA8L0ZpbGVzPgoKIDxMb2NhdGlvbiAvcGVybC1zdGF0dXM+CiAgIFNldEhhbmRsZXIgcGVybC1zY3JpcHQKICAgUGVybEhhbmRsZXIgQXBhY2hlOjpTdGF0dXMKICAgb3JkZXIgZGVueSxhbGxvdwogICBkZW55IGZyb20gYWxsCiAgIGFsbG93IGZyb20gMjA0LjExNy44Mi4KIDwvTG9jYXRpb24+CgpOb3csIHlvdSdsbCBub3RpY2UgdGhhdCBJIHVzZSBhIEM8UGVybFJlcXVpcmU+IGRpcmVjdGl2ZSB0byBsb2FkIGluIHRoZQpmaWxlIEY8c3RhcnR1cC5wZXJsPi4gIEluIHRoYXQgZmlsZSwgSSBpbmNsdWRlIGFsbCBvZiB0aGUgQzx1c2U+CnN0YXRlbWVudHMgdGhhdCBvY2N1ciBpbiBhbnkgb2YgbXkgbW9kX3BlcmwgcHJvZ3JhbXMgKGVpdGhlciBmcm9tIHRoZQpwcm9ncmFtcyBkaXJlY3RvcnksIG9yIHRoZSAqLnBlcmwgZmlsZXMpLiAgSGVyZSBpcyBhbiBleGFtcGxlOgoKICMhIC91c3IvbG9jYWwvYmluL3BlcmwKIHVzZSBzdHJpY3Q7CgogIyBsb2FkIHVwIG5lY2Vzc2FyeSBwZXJsIGZ1bmN0aW9uIG1vZHVsZXMgdG8gYmUgYWJsZSB0byBjYWxsIGZyb20gUGVybC1TU0kKICMgZmlsZXMuICBUaGVzZSBvYmplY3RzIGFyZSByZWxvYWRlZCB1cG9uIHNlcnZlciByZXN0YXJ0IChTSUdIVVAgb3IgU0lHVVNSMSkKICMgaWYgUGVybEZyZXNoUmVzdGFydCBpcyAiT24iIGluIGh0dHBkLmNvbmYgKGFzIG9mIG1vZF9wZXJsIDEuMDMpLgoKICMgb25seSBsaWJyYXJ5LXR5cGUgcm91dGluZXMgc2hvdWxkIGdvIGluIHRoaXMgZGlyZWN0b3J5LgoKIHVzZSBsaWIgIi92YXIvd3d3L3BlcmxsaWIiOwoKICMgbWFrZSBzdXJlIHdlIGFyZSBpbiBhIHNhbmUgZW52aXJvbm1lbnQuCiAkRU5We0dBVEVXQVlfSU5URVJGQUNFfSA9fiAvXkNHSS1QZXJsLyBvciBkaWUgIkdBVEVXQVlfSU5URVJGQUNFIG5vdCBQZXJsISI7CgogdXNlIEFwYWNoZTo6UmVnaXN0cnkgKCk7CSMgZm9yIHRoaW5ncyBpbiB0aGUgIi9wcm9ncmFtcyIgVVJMCgogIyBwdWxsIGluIHRoaW5ncyB3ZSB3aWxsIHVzZSBpbiBtb3N0IHJlcXVlc3RzIHNvIGl0IGlzIHJlYWQgYW5kIGNvbXBpbGVkCiAjIGV4YWN0bHkgb25jZQogdXNlIENHSSAoKTsgQ0dJLT5jb21waWxlKCc6YWxsJyk7CiB1c2UgQ0dJOjpDYXJwICgpOwogdXNlIERCSSAoKTsKIHVzZSBEQkQ6Om15c3FsICgpOwoKIDE7CgpXaGF0IHRoaXMgZG9lcyBpcyBwdWxsIGluIGFsbCBvZiB0aGUgY29kZSB1c2VkIGJ5IHRoZSBwcm9ncmFtcyAoYnV0CmRvZXMgbm90IEM8aW1wb3J0PiBhbnkgb2YgdGhlIG1vZHVsZSBtZXRob2RzKSBpbnRvIHRoZSBtYWluIEhUVFBECnByb2Nlc3MsIHdoaWNoIHRoZW4gY3JlYXRlcyB0aGUgY2hpbGQgcHJvY2Vzc2VzIHdpdGggdGhlIGNvZGUgYWxyZWFkeQppbiBwbGFjZS4gIFlvdSBjYW4gYWxzbyBwdXQgYW55IG5ldyBtb2R1bGVzIHlvdSBsaWtlIGludG8gdGhlCkY8L3Zhci93d3cvcGVybGxpYj4gZGlyZWN0b3J5IGFuZCBzaW1wbHkgQzx1c2U+IHRoZW0gaW4geW91cgpwcm9ncmFtcy4gIFRoZXJlIGlzIG5vIG5lZWQgdG8gcHV0IEM8dXNlIGxpYiAiL3Zhci93d3cvcGVybGxpYiI7PiBpbgphbGwgb2YgeW91ciBwcm9ncmFtcy4gIFlvdSBkbywgaG93ZXZlciwgc3RpbGwgbmVlZCB0byBDPHVzZT4gdGhlCm1vZHVsZXMgaW4geW91ciBwcm9ncmFtcy4gIFBlcmwgaXMgc21hcnQgZW5vdWdoIHRvIGtub3cgaXQgZG9lc24ndApuZWVkIHRvIHJlY29tcGlsZSB0aGUgY29kZSwgYnV0IGl0IGRvZXMgbmVlZCB0byBDPGltcG9ydD4gdGhlIG1vZHVsZQptZXRob2RzIGludG8geW91ciBwcm9ncmFtJ3MgbmFtZSBzcGFjZS4KCklmIHlvdSBvbmx5IGhhdmUgYSBmZXcgbW9kdWxlcyB0byBsb2FkLCB5b3UgY2FuIHVzZSB0aGUgUGVybE1vZHVsZQpkaXJlY3RpdmUgdG8gcHJlLWxvYWQgdGhlbSB3aXRoIHRoZSBzYW1lIGVmZmVjdC4KClRoZSBiaWdnZXN0IGJlbmVmaXQgaGVyZSBpcyB0aGF0IHRoZSBjaGlsZCBwcm9jZXNzIG5ldmVyIG5lZWRzIHRvCnJlY29tcGlsZSB0aGUgY29kZSwgc28gaXQgaXMgZmFzdGVyIHRvIHN0YXJ0LCBhbmQgdGhlIGNoaWxkIHByb2Nlc3MKYWN0dWFsbHkgc2hhcmVzIHRoZSBzYW1lIHBoeXNpY2FsIGNvcHkgb2YgdGhlIGNvZGUgaW4gbWVtb3J5IGR1ZSB0bwp0aGUgd2F5IHRoZSB2aXJ0dWFsIG1lbW9yeSBzeXN0ZW0gaW4gbW9kZXJuIG9wZXJhdGluZyBzeXN0ZW1zIHdvcmtzLgoKWW91IHdpbGwgd2FudCB0byByZXBsYWNlIHRoZSBDPHVzZT4gbGluZXMgYWJvdmUgd2l0aCBtb2R1bGVzIHlvdQphY3R1YWxseSBuZWVkLgoKPWhlYWQyIFNpbXBsZSBUZXN0IFByb2dyYW0KCkhlcmUncyBhIHNhbXBsZSBzY3JpcHQgY2FsbGVkIEY8cHJpbnRlbnY+IHRoYXQgeW91IGNhbiBzdGljayBpbiB0aGUKRjxwcm9ncmFtcz4gZGlyZWN0b3J5IHRvIHRlc3QgdGhlIGZ1bmN0aW9uYWxpdHkgb2YgdGhlIGNvbmZpZ3VyYXRpb24uCgogIyEgL3Vzci9sb2NhbC9iaW4vcGVybAogdXNlIHN0cmljdDsKICMgcHJpbnQgdGhlIGVudmlyb25tZW50IGluIGEgbW9kX3BlcmwgcHJvZ3JhbSB1bmRlciBBcGFjaGU6OlJlZ2lzdHJ5CgogcHJpbnQgIkNvbnRlbnQtdHlwZTogdGV4dC9odG1sXG5cbiI7CgogcHJpbnQgIjxIRUFEPjxUSVRMRT5BcGFjaGU6OlJlZ2lzdHJ5IEVudmlyb25tZW50PC9USVRMRT48L0hFQUQ+XG4iOwoKIHByaW50ICI8Qk9EWT48UFJFPlxuIjsKIHByaW50IG1hcCB7ICIkXyA9ICRFTlZ7JF99XG4iIH0gc29ydCBrZXlzICVFTlY7CiBwcmludCAiPC9QUkU+PC9CT0RZPlxuIjsKCldoZW4geW91IHJ1biB0aGlzLCBjaGVjayB0aGUgdmFsdWUgb2YgdGhlIEdBVEVXQVlfSU5URVJGQUNFIHZhcmlhYmxlCnRvIHNlZSB0aGF0IHlvdSBhcmUgaW5kZWVkIHJ1bm5pbmcgbW9kX3BlcmwuCgo9aGVhZDEgUkVEVUNJTkcgTUVNT1JZIFVTRQoKQXMgYSBzaWRlIGVmZmVjdCBvZiB1c2luZyBtb2RfcGVybCwgeW91ciBIVFRQRCBwcm9jZXNzZXMgd2lsbCBiZQpsYXJnZXIgdGhhbiB3aXRob3V0IGl0LiAgVGhlcmUgaXMganVzdCBubyB3YXkgYXJvdW5kIGl0LCBhcyB5b3UgaGF2ZQp0aGlzIGV4dHJhIGNvZGUgdG8gc3VwcG9ydCB5b3VyIGFkZGVkIGZ1bmN0aW9uYWxpdHkuCgpPbiBhIHZlcnkgYnVzeSBzaXRlLCB0aGUgbnVtYmVyIG9mIEhUVFBEIHByb2Nlc3NlcyBjYW4gZ3JvdyB0byBiZQpxdWl0ZSBsYXJnZS4gIEZvciBleGFtcGxlLCBvbiBvbmUgbGFyZ2Ugc2l0ZSwgdGhlIHR5cGljYWwgSFRUUEQgd2FzCmFib3V0IDVNYiBsYXJnZS4gIFdpdGggMzAgb2YgdGhlc2UsIGFsbCBvZiBSQU0gd2FzIGV4aGF1c3RlZCwgYW5kIHdlCnN0YXJ0ZWQgdG8gZ28gdG8gc3dhcC4gIFdpdGggNjAgb2YgdGhlc2UsIHN3YXBwaW5nIHR1cm5lZCBpbnRvCnRocmFzaGluZywgYW5kIHRoZSB3aG9sZSBtYWNoaW5lIHNsb3dlZCB0byBhIGNyYXdsLgoKVG8gcmVkdWNlIHRocmFzaGluZywgbGltaXRpbmcgdGhlIG1heGltdW0gbnVtYmVyIG9mIEhUVFBEIHByb2Nlc3NlcyB0bwphIG51bWJlciB0aGF0IGlzIGp1c3QgbGFyZ2VyIHRoYW4gd2hhdCB3aWxsIGZpdCBpbnRvIFJBTSAoaW4gdGhpcwpjYXNlLCA0NSkgaXMgbmVjZXNzYXJ5LiAgVGhlIGRyYXdiYWNrIGlzIHRoYXQgd2hlbiB0aGUgc2VydmVyIGlzCnNlcnZpbmcgNDUgcmVxdWVzdHMsIG5ldyByZXF1ZXN0cyB3aWxsIHF1ZXVlIHVwIGFuZCB3YWl0OyBob3dldmVyLCBpZgp5b3UgbGV0IHRoZSBtYXhpbXVtIG51bWJlciBvZiBwcm9jZXNzZXMgZ3JvdywgdGhlIG5ldyByZXF1ZXN0cyB3aWxsCnN0YXJ0IHRvIGdldCBzZXJ2ZWQgcmlnaHQgYXdheSwgSTxidXQ+IHRoZXkgd2lsbCB0YWtlIG11Y2ggbG9uZ2VyIHRvCmNvbXBsZXRlLgoKT25lIHdheSB0byByZWR1Y2UgdGhlIGFtb3VudCBvZiByZWFsIG1lbW9yeSB0YWtlbiB1cCBieSBlYWNoIHByb2Nlc3MKaXMgdG8gcHJlLWxvYWQgY29tbW9ubHkgdXNlZCBtb2R1bGVzIGludG8gdGhlIHByaW1hcnkgSFRUUEQgcHJvY2VzcyBzbwp0aGF0IHRoZSBjb2RlIGlzIHNoYXJlZCBieSBhbGwgcHJvY2Vzc2VzLiAgVGhpcyBpcyBhY2NvbXBsaXNoZWQgYnkKaW5zZXJ0aW5nIHRoZSBDPHVzZSBGb28gKCk7PiBsaW5lcyBpbnRvIHRoZSBGPHN0YXJ0dXAucGVybD4gZmlsZSBmb3IKYW55IEM8dXNlIEZvbzs+IHN0YXRlbWVudCBpbiBhbnkgY29tbW9ubHkgdXNlZCBSZWdpc3RyeSBwcm9ncmFtLiAgVGhlCmlkZWEgaXMgdGhhdCB0aGUgb3BlcmF0aW5nIHN5c3RlbSdzIFZNIHN1YnN5c3RlbSB3aWxsIHNoYXJlIHRoZSBkYXRhCmFjcm9zcyB0aGUgcHJvY2Vzc2VzLgoKWW91IGNhbiBhbHNvIHByZS1sb2FkIEFwYWNoZTo6UmVnaXN0cnkgcHJvZ3JhbXMgdXNpbmcgdGhlCkM8QXBhY2hlOjpSZWdpc3RyeUxvYWRlcj4gbW9kdWxlIHNvIHRoYXQgdGhlIGNvZGUgZm9yIHRoZXNlIHByb2dyYW1zCmlzIHNoYXJlZCBieSBhbGwgSFRUUEQgcHJvY2Vzc2VzIGFzIHdlbGwuCgpCPE5PVEU+OiBXaGVuIHlvdSBwcmUtbG9hZCBtb2R1bGVzIGluIHRoZSBzdGFydHVwIHNjcmlwdCwgeW91IG1heQpuZWVkIHRvIGtpbGwgYW5kIHJlc3RhcnQgSFRUUEQgZm9yIGNoYW5nZXMgdG8gdGFrZSBlZmZlY3QuICBBIHNpbXBsZQpDPGtpbGwgLUhVUD4gb3IgQzxraWxsIC1VU1IxPiB3aWxsIG5vdCByZWxvYWQgdGhhdCBjb2RlIHVubGVzcyB5b3UKaGF2ZSBzZXQgdGhlIEM8UGVybEZyZXNoUmVzdGFydD4gY29uZmlndXJhdGlvbiBwYXJhbWV0ZXIgaW4KRjxodHRwZC5jb25mPiB0byBiZSAiT24iLgoKPWhlYWQxIFJFRFVDSU5HIFRIRSBOVU1CRVIgT0YgTEFSR0UgUFJPQ0VTU0VTCgpVbmZvcnR1bmF0ZWx5LCBzaW1wbHkgcmVkdWNpbmcgdGhlIHNpemUgb2YgZWFjaCBIVFRQRCBwcm9jZXNzIGlzIG5vdAplbm91Z2ggb24gYSB2ZXJ5IGJ1c3kgc2l0ZS4gIFlvdSBhbHNvIG5lZWQgdG8gcmVkdWNlIHRoZSBxdWFudGl0eSBvZgp0aGVzZSBwcm9jZXNzZXMuICBUaGlzIHJlZHVjZXMgbWVtb3J5IGNvbnN1bXB0aW9uIGV2ZW4gbW9yZSwgYW5kCnJlc3VsdHMgaW4gZmV3ZXIgcHJvY2Vzc2VzIGZpZ2h0aW5nIGZvciB0aGUgYXR0ZW50aW9uIG9mIHRoZSBDUFUuICBJZgp5b3UgY2FuIHJlZHVjZSB0aGUgcXVhbnRpdHkgb2YgcHJvY2Vzc2VzIHRvIGZpdCBpbnRvIFJBTSwgeW91cgpyZXNwb25zZSB0aW1lIGlzIGluY3JlYXNlZCBldmVuIG1vcmUuCgpUaGUgaWRlYSBvZiB0aGUgdGVjaG5pcXVlcyBvdXRsaW5lZCBiZWxvdyBpcyB0byBvZmZsb2FkIHRoZSBub3JtYWwKZG9jdW1lbnQgZGVsaXZlcnkgKHN1Y2ggYXMgc3RhdGljIEhUTUwgYW5kIEdJRiBmaWxlcykgZnJvbSB0aGUKbW9kX3BlcmwgSFRUUEQsIGFuZCBsZXQgaXQgb25seSBoYW5kbGUgdGhlIG1vZF9wZXJsIHJlcXVlc3RzLiAgVGhpcwp3YXksIHlvdXIgbGFyZ2UgbW9kX3BlcmwgSFRUUEQgcHJvY2Vzc2VzIGFyZSBub3QgdGllZCB1cCBkZWxpdmVyaW5nCnNpbXBsZSBjb250ZW50IHdoZW4gYSBzbWFsbGVyIHByb2Nlc3MgY291bGQgcGVyZm9ybSB0aGUgc2FtZSBqb2IgbW9yZQplZmZpY2llbnRseS4KCkluIHRoZSB0ZWNobmlxdWVzIGJlbG93IHdoZXJlIHRoZXJlIGFyZSB0d28gSFRUUEQgY29uZmlndXJhdGlvbnMsIHRoZQpzYW1lIGh0dHBkIGV4ZWN1dGFibGUgY2FuIGJlIHVzZWQgZm9yIGJvdGggY29uZmlndXJhdGlvbnM7IHRoZXJlIGlzIG5vCm5lZWQgdG8gYnVpbGQgSFRUUEQgYm90aCB3aXRoIGFuZCB3aXRob3V0IG1vZF9wZXJsIGNvbXBpbGVkIGludG8gaXQuCldpdGggQXBhY2hlIDEuMyB0aGlzIGNhbiBiZSBkb25lIHdpdGggdGhlIERTTyBjb25maWd1cmF0aW9uIC0tIGp1c3QKY29uZmlndXJlIG9uZSBodHRwZCBpbnZvY2F0aW9uIHRvIGR5bmFtaWNhbGx5IGxvYWQgbW9kX3BlcmwgYW5kIHRoZQpvdGhlciBub3QgdG8gZG8gc28uCgpUaGVzZSBhcHByb2FjaGVzIHdvcmsgYmVzdCB3aGVuIG1vc3Qgb2YgdGhlIHJlcXVlc3RzIGFyZSBmb3Igc3RhdGljCmNvbnRlbnQgcmF0aGVyIHRoYW4gbW9kX3BlcmwgcHJvZ3JhbXMuICBMb2cgZmlsZSBhbmFseXNpcyBiZWNvbWUgYSBiaXQKb2YgYSBjaGFsbGVuZ2Ugd2hlbiB5b3UgaGF2ZSBtdWx0aXBsZSBzZXJ2ZXJzIHJ1bm5pbmcgb24gdGhlIHNhbWUKaG9zdCwgc2luY2UgeW91IG11c3QgbG9nIHRvIGRpZmZlcmVudCBmaWxlcy4KCj1oZWFkMiBUV08gTUFDSElORVMKClRoZSBzaW1wbGVzdCB3YXkgaXMgdG8gcHV0IGFsbCBzdGF0aWMgY29udGVudCBvbiBvbmUgbWFjaGluZSwgYW5kIGFsbAptb2RfcGVybCBwcm9ncmFtcyBvbiBhbm90aGVyLiAgVGhlIG9ubHkgdHJpY2sgaXMgdG8gbWFrZSBzdXJlIGFsbApsaW5rcyBhcmUgcHJvcGVybHkgY29kZWQgdG8gcmVmZXIgdG8gdGhlIHByb3BlciBob3N0LiAgVGhlIHN0YXRpYwpjb250ZW50IHdpbGwgYmUgc2VydmVkIHVwIGJ5IGxvdHMgb2Ygc21hbGwgSFRUUEQgcHJvY2Vzc2VzIChjb25maWd1cmVkCkk8bm90PiB0byB1c2UgbW9kX3BlcmwpLCBhbmQgdGhlIHJlbGF0aXZlbHkgZmV3IG1vZF9wZXJsIHJlcXVlc3RzCmNhbiBiZSBoYW5kbGVkIGJ5IHRoZSBzbWFsbGVyIG51bWJlciBvZiBsYXJnZSBIVFRQRCBwcm9jZXNzZXMgb24gdGhlCm90aGVyIG1hY2hpbmUuCgpUaGUgZHJhd2JhY2sgaXMgdGhhdCB5b3UgbXVzdCBtYWludGFpbiB0d28gbWFjaGluZXMsIGFuZCB0aGlzIGNhbiBnZXQKZXhwZW5zaXZlLiAgRm9yIGV4dHJlbWVseSBsYXJnZSBwcm9qZWN0cywgdGhpcyBpcyB0aGUgYmVzdCB3YXkgdG8gZ28uCgo9aGVhZDIgVFdPIElQIEFERFJFU1NFUwoKU2ltaWxhciB0byBhYm92ZSwgYnV0IG9uZSBIVFRQRCBydW5zIGJvdW5kIHRvIG9uZSBJUCBhZGRyZXNzLCB3aGlsZQp0aGUgb3RoZXIgcnVucyBib3VuZCB0byBhbm90aGVyIElQIGFkZHJlc3MuICBUaGUgb25seSBkaWZmZXJlbmNlIGlzCnRoYXQgb25lIG1hY2hpbmUgcnVucyBib3RoIHNlcnZlcnMuICBUb3RhbCBtZW1vcnkgdXNhZ2UgaXMgcmVkdWNlZApiZWNhdXNlIHRoZSBtYWpvcml0eSBvZiBmaWxlcyBhcmUgc2VydmVkIGJ5IHRoZSBzbWFsbGVyIEhUVFBECnByb2Nlc3Nlcywgc28gdGhlcmUgYXJlIGZld2VyIGxhcmdlIG1vZF9wZXJsIEhUVFBEIHByb2Nlc3NlcyBzaXR0aW5nCmFyb3VuZC4KClRoaXMgaXMgYWNjb21wbGlzaGVkIHVzaW5nIHRoZSBGPGh0dHBkLmNvbmY+IGRpcmVjdGl2ZSBDPEJpbmRBZGRyZXNzPgp0byBtYWtlIGVhY2ggSFRUUEQgcmVzcG9uZCBvbmx5IHRvIG9uZSBJUCBhZGRyZXNzIG9uIHRoaXMgaG9zdC4gIE9uZQp3aWxsIGhhdmUgbW9kX3BlcmwgZW5hYmxlZCwgYW5kIHRoZSBvdGhlciB3aWxsIG5vdC4KCj1oZWFkMiBUV08gUE9SVCBOVU1CRVJTCgpJZiB5b3UgY2Fubm90IGdldCB0d28gSVAgYWRkcmVzc2VzLCB5b3UgY2FuIGFsc28gc3BsaXQgdGhlIEhUVFBECnByb2Nlc3NlcyBhcyBhYm92ZSBieSBwdXR0aW5nIG9uZSBvbiB0aGUgc3RhbmRhcmQgcG9ydCA4MCwgYW5kIHRoZQpvdGhlciBvbiBzb21lIG90aGVyIHBvcnQsIHN1Y2ggYXMgODA0Mi4gIFRoZSBvbmx5IGNvbmZpZ3VyYXRpb24KY2hhbmdlcyB3aWxsIGJlIHRoZSBDPFBvcnQ+IGFuZCBsb2cgZmlsZSBkaXJlY3RpdmVzIGluIHRoZSBodHRwZC5jb25mCmZpbGUgKGFuZCBhbHNvIG9uZSBvZiB0aGVtIGRvZXMgbm90IGhhdmUgYW55IG1vZF9wZXJsIGRpcmVjdGl2ZXMpLgoKVGhlIG1ham9yIGZsYXcgd2l0aCB0aGlzIHNjaGVtZSBpcyB0aGF0IHNvbWUgZmlyZXdhbGxzIHdpbGwgbm90IGFsbG93CmFjY2VzcyB0byB0aGUgc2VydmVyIHJ1bm5pbmcgb24gdGhlIGFsdGVybmF0ZSBwb3J0LCBzbyBzb21lIHBlb3BsZQp3aWxsIG5vdCBiZSBhYmxlIHRvIGFjY2VzcyBhbGwgb2YgeW91ciBwYWdlcy4KCklmIHlvdSB1c2UgdGhpcyBhcHByb2FjaCBvciB0aGUgb25lIGFib3ZlIHdpdGggZHVhbCBJUCBhZGRyZXNzZXMsIHlvdQpwcm9iYWJseSBkbyBub3Qgd2FudCB0byBoYXZlIHRoZSAqLnBlcmwgYW5kICoucnBlcmwgc2VjdGlvbnMgZnJvbSB0aGUKc2FtcGxlIGNvbmZpZ3VyYXRpb24gYWJvdmUsIGFzIHRoaXMgd291bGQgcmVxdWlyZSB0aGF0IHlvdXIgcHJpbWFyeQpIVFRQRCBzZXJ2ZXIgYmUgbW9kX3BlcmwgZW5hYmxlZCBhcyB3ZWxsLgoKVGhhbmtzIHRvIEdlcmQgS25vcHMgZm9yIHRoaXMgaWRlYS4KCj1oZWFkMiBVU0lORyBQcm94eVBhc3MgV0lUSCBUV08gU0VSVkVSUwoKVG8gb3ZlcmNvbWUgdGhlIGxpbWl0YXRpb24gb2YgdGhlIGFsdGVybmF0ZSBwb3J0IGFib3ZlLCB5b3UgY2FuIHVzZQpkdWFsIEFwYWNoZSBIVFRQRCBzZXJ2ZXJzIHdpdGgganVzdCBzbGlnaHQgZGlmZmVyZW5jZSBpbgpjb25maWd1cmF0aW9uLiAgRXNzZW50aWFsbHksIHlvdSBzZXQgdXAgdHdvIHNlcnZlcnMganVzdCBhcyB5b3Ugd291bGQKd2l0aCB0aGUgdHdvIHBvcnQgb24gc2FtZSBJUCBhZGRyZXNzIG1ldGhvZCBhYm92ZS4gIEhvd2V2ZXIsIGluIHlvdXIKcHJpbWFyeSBIVFRQRCBjb25maWd1cmF0aW9uIHlvdSBhZGQgYSBsaW5lIGxpa2UgdGhpczoKCiBQcm94eVBhc3MgL3Byb2dyYW1zIGh0dHA6Ly9sb2NhbGhvc3Q6ODA0Mi9wcm9ncmFtcwoKV2hlcmUgeW91ciBtb2RfcGVybCBlbmFibGVkIEhUVFBEIGlzIHJ1bm5pbmcgb24gcG9ydCA4MDQyLCBhbmQgaGFzCm9ubHkgdGhlIGRpcmVjdG9yeSBGPHByb2dyYW1zPiB3aXRoaW4gaXRzIERvY3VtZW50Um9vdC4gIFRoaXMgYXNzdW1lcwp0aGF0IHlvdSBoYXZlIGluY2x1ZGVkIHRoZSBtb2RfcHJveHkgbW9kdWxlIGluIHlvdXIgc2VydmVyIHdoZW4gaXQgd2FzCmJ1aWx0LgoKTm93LCB3aGVuIHlvdSBhY2Nlc3MgaHR0cDovL3d3dy5kb21haW4uY29tL3Byb2dyYW1zL3ByaW50ZW52IGl0IHdpbGwKaW50ZXJuYWxseSBiZSBwYXNzZWQgdGhyb3VnaCB0byB5b3VyIEhUVFBEIHJ1bm5pbmcgb24gcG9ydCA4MDQyIGFzIHRoZQpVUkwgaHR0cDovL2xvY2FsaG9zdDo4MDQyL3Byb2dyYW1zL3ByaW50ZW52IGFuZCB0aGUgcmVzdWx0IHJlbGF5ZWQKYmFjayB0cmFuc3BhcmVudGx5LiAgVG8gdGhlIGNsaWVudCwgaXQgYWxsIHNlZW1zIGFzIGlmIGl0IGlzIGp1c3Qgb25lCnNlcnZlciBydW5uaW5nLiAgVGhpcyBjYW4gYWxzbyBiZSB1c2VkIG9uIHRoZSBkdWFsLWhvc3QgdmVyc2lvbiB0bwpoaWRlIHRoZSBzZWNvbmQgc2VydmVyIGZyb20gdmlldyBpZiBkZXNpcmVkLgoKPWJlZ2luIGh0bWwKPFA+CkEgY29tcGxldGUgY29uZmlndXJhdGlvbiBleGFtcGxlIG9mIHRoaXMgdGVjaG5pcXVlIGlzIHByb3ZpZGVkIGJ5CnR3byBIVFRQRCBjb25maWd1cmF0aW9uIGZpbGVzLgo8QSBIUkVGPSJodHRwZC5jb25mLnR4dCI+aHR0cGQuY29uZjwvQT4gaXMgZm9yIHRoZSBtYWluIHNlcnZlciBmb3IgYWxsCnJlZ3VsYXIgcGFnZXMsIGFuZCA8QSBIUkVGPSJodHRwZCUyYnBlcmwuY29uZi50eHQiPmh0dHBkK3BlcmwuY29uZjwvQT4gaXMKZm9yIHRoZSBtb2RfcGVybCBwcm9ncmFtcyBhY2Nlc3NlZCBpbiB0aGUgPENPREU+L3Byb2dyYW1zPC9DT0RFPiBVUkwuCjwvUD4KClRoZSBkaXJlY3Rvcnkgc3RydWN0dXJlIGFzc3VtZXMgdGhhdCBGPC92YXIvd3d3L2RvY3VtZW50cz4gaXMgdGhlCkM8RG9jdW1lbnRSb290PiBkaXJlY3RvcnksIGFuZCB0aGUgdGhlIG1vZF9wZXJsIHByb2dyYW1zIGFyZSBpbgpGPC92YXIvd3d3L3Byb2dyYW1zPiBhbmQgRjwvdmFyL3d3dy9ycHJvZ3JhbXM+LiAgSSBzdGFydCB0aGVtIGFzCmZvbGxvd3M6CgogZGFlbW9uIGh0dHBkCiBkYWVtb24gaHR0cGQgLWYgY29uZi9odHRwZCtwZXJsLmNvbmYKCj1lbmQgaHRtbAoKVGhhbmtzIHRvIEJvd2VuIER3ZWxsZSBmb3IgdGhpcyBpZGVhLgoKPWhlYWQyIFNRVUlEIEFDQ0VMRVJBVE9SCgpBbm90aGVyIGFwcHJvYWNoIHRvIHJlZHVjaW5nIHRoZSBudW1iZXIgb2YgbGFyZ2UgSFRUUEQgcHJvY2Vzc2VzIG9uCm9uZSBtYWNoaW5lIGlzIHRvIHVzZSBhbiBhY2NlbGVyYXRvciBzdWNoIGFzIFNxdWlkICh3aGljaCBjYW4gYmUgZm91bmQKYXQgaHR0cDovL3NxdWlkLm5sYW5yLm5ldC9TcXVpZC8gb24gdGhlIHdlYikgYmV0d2VlbiB0aGUgY2xpZW50cyBhbmQKeW91ciBsYXJnZSBtb2RfcGVybCBIVFRQRCBwcm9jZXNzZXMuICBUaGUgaWRlYSBoZXJlIGlzIHRoYXQgc3F1aWQgd2lsbApoYW5kbGUgdGhlIHN0YXRpYyBvYmplY3RzIGZyb20gaXRzIGNhY2hlIHdoaWxlIHRoZSBIVFRQRCBwcm9jZXNzZXMKd2lsbCBoYW5kbGUgbW9zdGx5IGp1c3QgdGhlIG1vZF9wZXJsIHJlcXVlc3RzIG9uY2UgdGhlIGNhY2hlIGlzCnByaW1lZC4gIFRoaXMgcmVkdWNlcyB0aGUgbnVtYmVyIG9mIEhUVFBEIHByb2Nlc3NlcyBhbmQgdGh1cyByZWR1Y2VzCnRoZSBhbW91bnQgb2YgbWVtb3J5IHVzZWQuCgpUbyBzZXQgdGhpcyB1cCwganVzdCBpbnN0YWxsIHRoZSBjdXJyZW50IHZlcnNpb24gb2YgU3F1aWQgKGF0IHRoaXMKd3JpdGluZywgdGhpcyBpcyB2ZXJzaW9uIDEuMS4yMikgYW5kIHVzZSB0aGUgUnVuQWNjZWwgc2NyaXB0IHRvIHN0YXJ0Cml0LiAgWW91IHdpbGwgbmVlZCB0byByZWNvbmZpZ3VyZSB5b3VyIEhUVFBEIHRvIHVzZSBhbiBhbHRlcm5hdGUgcG9ydCwKc3VjaCBhcyA4MDQyLCByYXRoZXIgdGhhbiBpdHMgZGVmYXVsdCBwb3J0IDgwLiAgVG8gZG8gdGhpcywgeW91IGNhbgplaXRoZXIgY2hhbmdlIHRoZSBGPGh0dHBkLmNvbmY+IGxpbmUgQzxQb3J0PiBvciBhZGQgYSBDPExpc3Rlbj4KZGlyZWN0aXZlIHRvIG1hdGNoIHRoZSBwb3J0IHNwZWNpZmllZCBpbiB0aGUgRjxzcXVpZC5jb25mPiBmaWxlLgpZb3VyIFVSTHMgZG8gbm90IG5lZWQgdG8gY2hhbmdlLiAgVGhlIGJlbmVmaXQgb2YgdXNpbmcgdGhlIEM8TGlzdGVuPgpkaXJlY3RpdmUgaXMgdGhhdCByZWRpcmVjdGVkIFVSTHMgd2lsbCBzdGlsbCB1c2UgdGhlIGRlZmF1bHQgcG9ydCA4MApyYXRoZXIgdGhhbiB5b3VyIGFsdGVybmF0ZSBwb3J0LCB3aGljaCBtaWdodCByZXZlYWwgeW91ciByZWFsIHNlcnZlcgpsb2NhdGlvbiB0byB0aGUgb3V0c2lkZSB3b3JsZCBhbmQgYnlwYXNzIHRoZSBhY2NlbGVyYXRvci4KCkluIHRoZSBGPHNxdWlkLmNvbmY+IGZpbGUsIHlvdSB3aWxsIHByb2JhYmx5IHdhbnQgdG8gYWRkIEM8cHJvZ3JhbXM+CmFuZCBDPHBlcmw+IHRvIHRoZSBDPGNhY2hlX3N0b3BsaXN0PiBwYXJhbWV0ZXIgc28gdGhhdCB0aGVzZSBhcmUKYWx3YXlzIHBhc3NlZCB0aHJvdWdoIHRvIHRoZSBIVFRQRCBzZXJ2ZXIgdW5kZXIgdGhlIGFzc3VtcHRpb24gdGhhdAp0aGV5IGFsd2F5cyBwcm9kdWNlIGRpZmZlcmVudCByZXN1bHRzLgoKVGhpcyBpcyB2ZXJ5IHNpbWlsYXIgdG8gdGhlIHR3byBwb3J0LCBQcm94eVBhc3MgdmVyc2lvbiBhYm92ZSwgYnV0IHRoZQpTcXVpZCBjYWNoZSBtYXkgYmUgbW9yZSBmbGV4aWJsZSB0byBmaW5lIHR1bmUgZm9yIGR5bmFtaWMgZG9jdW1lbnRzCnRoYXQgZG8gbm90IGNoYW5nZSBvbiBldmVyeSB2aWV3LiAgVGhlIFNxdWlkIHByb3h5IHNlcnZlciBhbHNvIHNlZW1zCnRvIGJlIG1vcmUgc3RhYmxlIGFuZCByb2J1c3QgdGhhbiB0aGUgQXBhY2hlIDEuMi40IHByb3h5IG1vZHVsZS4KCk9uZSBkcmF3YmFjayB0byB1c2luZyB0aGlzIGFjY2VsZXJhdG9yIGlzIHRoYXQgdGhlIGxvZ2ZpbGVzIHdpbGwKYWx3YXlzIHJlcG9ydCBhY2Nlc3MgZnJvbSBJUCBhZGRyZXNzIDEyNy4wLjAuMSwgd2hpY2ggaXMgdGhlIGxvY2FsCmhvc3QgbG9vcGJhY2sgYWRkcmVzcy4gIEFsc28sIGFueSBhY2Nlc3MgcGVybWlzc2lvbnMgb3Igb3RoZXIgdXNlcgp0cmFja2luZyB0aGF0IHJlcXVpcmVzIHRoZSByZW1vdGUgSVAgYWRkcmVzcyB3aWxsIGFsd2F5cyBzZWUgdGhlIGxvY2FsCmFkZHJlc3MuICBUaGUgZm9sbG93aW5nIGNvZGUgdXNlcyBhIGZlYXR1cmUgb2YgcmVjZW50IG1vZF9wZXJsCnZlcnNpb25zICh0ZXN0ZWQgd2l0aCBtb2RfcGVybCAxLjE2IGFuZCBBcGFjaGUgMS4zLjMpIHRvIHRyaWNrIEFwYWNoZQppbnRvIGxvZ2dpbmcgdGhlIHJlYWwgY2xpZW50IGFkZHJlc3MgYW5kIGdpdmluZyB0aGF0IGluZm9ybWF0aW9uIHRvCm1vZF9wZXJsIHByb2dyYW1zIGZvciB0aGVpciBwdXJwb3Nlcy4KCkZpcnN0LCBpbiB5b3VyIEY8c3RhcnR1cC5wZXJsPiBmaWxlIGFkZCB0aGUgZm9sbG93aW5nIGNvZGU6CgogdXNlIEFwYWNoZTo6Q29uc3RhbnRzIHF3KE9LKTsKCiBzdWIgTXk6OlNxdWlkUmVtb3RlQWRkciAoJCkgewogICBteSAkciA9IHNoaWZ0OwoKICAgaWYgKG15ICgkaXApID0gJHItPmhlYWRlcl9pbignWC1Gb3J3YXJkZWQtRm9yJykgPX4gLyhbXixcc10rKSQvKSB7CiAgICAgJHItPmNvbm5lY3Rpb24tPnJlbW90ZV9pcCgkaXApOwogICB9CgogICByZXR1cm4gT0s7CiB9CgpOZXh0LCBhZGQgdGhpcyB0byB5b3VyIEY8aHR0cGQuY29uZj4gZmlsZToKCiBQZXJsUG9zdFJlYWRSZXF1ZXN0SGFuZGxlciBNeTo6U3F1aWRSZW1vdGVBZGRyCgpUaGlzIHdpbGwgY2F1c2UgZXZlcnkgcmVxdWVzdCB0byBoYXZlIGl0cyBDPHJlbW90ZV9pcD4gYWRkcmVzcwpvdmVycmlkZGVuIGJ5IHRoZSB2YWx1ZSBzZXQgaW4gdGhlIEM8WC1Gb3J3YXJkZWQtRm9yPiBoZWFkZXIgYWRkZWQgYnkKU3F1aWQuICBOb3RlIHRoYXQgaWYgeW91IGhhdmUgbXVsdGlwbGUgcHJveGllcyBiZXR3ZWVuIHRoZSBjbGllbnQgYW5kCnRoZSBzZXJ2ZXIsIHlvdSB3YW50IHRoZSBJUCBhZGRyZXNzIG9mIHRoZSBsYXN0IG1hY2hpbmUgYmVmb3JlIHlvdXIKYWNjZWxlcmF0b3IuICBUaGlzIHdpbGwgYmUgdGhlIHJpZ2h0LW1vc3QgYWRkcmVzcyBpbiB0aGUKWC1Gb3J3YXJkZWQtRm9yIGhlYWRlciAoYXNzdW1pbmcgdGhlIG90aGVyIHByb3hpZXMgYXBwZW5kIHRoZWlyCmFkZHJlc3NlcyB0byB0aGlzIHNhbWUgaGVhZGVyLCBsaWtlIFNxdWlkIGRvZXMuKQoKSWYgeW91IHVzZSBhcGFjaGUgd2l0aCBtb2RfcHJveHkgYXQgeW91ciBmcm9udGVuZCwgeW91IGNhbiB1c2UgQXNrCkJq+HJuIEhhbnNlbidzIG1vZF9wcm94eV9hZGRfZm9yd2FyZCBtb2R1bGUgZnJvbQpmdHA6Ly9mdHAubmV0Y2V0ZXJhLmRrL3B1Yi9hcGFjaGUvIHRvIG1ha2UgaXQgaW5zZXJ0IHRoZQpDPFgtRm9yd2FyZGVkLUZvcj4gaGVhZGVyLgoKPWhlYWQxIFNVTU1BUlkKClRvIGdhaW4gbWF4aW1hbCBwZXJmb3JtYW5jZSBvZiBtb2RfcGVybCBvbiBhIGJ1c3kgc2l0ZSwgb25lIG11c3QKcmVkdWNlIHRoZSBhbW91bnQgb2YgcmVzb3VyY2VzIHVzZWQgYnkgdGhlIEhUVFBEIHRvIGZpdCB3aXRoaW4gd2hhdAp0aGUgbWFjaGluZSBoYXMgYXZhaWxhYmxlLiAgVGhlIGJlc3Qgd2F5IHRvIGRvIHRoaXMgaXMgdG8gcmVkdWNlCm1lbW9yeSB1c2FnZS4gIElmIHlvdXIgbW9kX3BlcmwgcmVxdWVzdHMgYXJlIGZld2VyIHRoYW4geW91ciBzdGF0aWMKcGFnZSByZXF1ZXN0cywgdGhlbiBzcGxpdHRpbmcgdGhlIHNlcnZlcnMgaW50byBtb2RfcGVybCBhbmQKbm9uLW1vZF9wZXJsIHZlcnNpb25zIGZ1cnRoZXIgYWxsb3dzIHlvdSB0byB0dW5lIHRoZSBhbW91bnQgb2YKcmVzb3VyY2VzIHVzZWQgYnkgZWFjaCB0eXBlIG9mIHJlcXVlc3QuICBVc2luZyB0aGUgQzxQcm94eVBhc3M+CmRpcmVjdGl2ZSBhbGxvd3MgdGhlc2UgbXVsdGlwbGUgc2VydmVycyB0byBhcHBlYXIgYXMgb25lIHRvIHRoZQp1c2Vycy4gIFVzaW5nIHRoZSBTcXVpZCBhY2NlbGVyYXRvciBhbHNvIGFjaGlldmVzIHRoaXMgZWZmZWN0LCBidXQKU3F1aWQgdGFrZXMgY2FyZSBvZiBkZWNpZGluZyB3aGVuIHRvIGFjY2Nlc3MgdGhlIGxhcmdlIHNlcnZlcgphdXRvbWF0aWNhbGx5LgoKSWYgYWxsIG9mIHlvdXIgcmVxdWVzdHMgcmVxdWlyZSBwcm9jZXNzaW5nIGJ5IG1vZF9wZXJsLCB0aGVuIHRoZSBvbmx5CnRoaW5nIHlvdSBjYW4gcmVhbGx5IGRvIGlzIHRocm93IGEgSTxsb3Q+IG9mIG1lbW9yeSBvbiB5b3VyIG1hY2hpbmUKYW5kIHRyeSB0byB0d2VhayB0aGUgcGVybCBjb2RlIHRvIGJlIGFzIHNtYWxsIGFuZCBsZWFuIGFzIHBvc3NpYmxlLAphbmQgdG8gc2hhcmUgdGhlIHZpcnR1YWwgbWVtb3J5IHBhZ2VzIGJ5IHByZS1sb2FkaW5nIHRoZSBjb2RlLgoKPWhlYWQxIEFVVEhPUgoKVGhpcyBkb2N1bWVudCBpcyB3cml0dGVuIGJ5IFZpdmVrIEtoZXJhLiAgSWYgeW91IG5lZWQgdG8gY29udGFjdCBtZSwKanVzdCBzZW5kIGVtYWlsIHRvIHRoZSBtb2RfcGVybCBtYWlsaW5nIGxpc3QuCgpUaGlzIGRvY3VtZW50IGlzIGNvcHlyaWdodCAoYykgMTk5Ny0xOTk4IGJ5IFZpdmVrIEtoZXJhLgoKSWYgeW91IGhhdmUgY29udHJpYnV0aW9ucyBmb3IgdGhpcyBkb2N1bWVudCwgcGxlYXNlIHBvc3QgdGhlbSB0byB0aGUKbWFpbGluZyBsaXN0LiAgUGVybCBQT0QgZm9ybWF0IGlzIGJlc3QsIGJ1dCBwbGFpbiB0ZXh0IHdpbGwgZG8sIHRvby4KCklmIHlvdSBuZWVkIGFzc2lzdGFuY2UsIGNvbnRhY3QgdGhlIG1vZF9wZXJsIG1haWxpbmcgbGlzdCBhdAptb2RwZXJsQHBlcmwuYXBhY2hlLm9yZyBmaXJzdCAoc2VuZCAnc3Vic2NyaWJlJyB0byBtb2RwZXJsLXJlcXVlc3RAYXBhY2hlLm9yZwp0byBzdWJzY3JpYmUpLiBUaGVyZSBhcmUgbG90cyBvZiBwZW9wbGUgdGhlcmUgdGhhdCBjYW4gaGVscC4gQWxzbywgCmNoZWNrIHRoZSB3ZWIgcGFnZXMgaHR0cDovL3BlcmwuYXBhY2hlLm9yZy8gYW5kIGh0dHA6Ly93d3cuYXBhY2hlLm9yZy8KZm9yIGV4cGxhbmF0aW9ucyBvZiB0aGUgY29uZmlndXJhdGlvbiBvcHRpb25zLgoKJFJldmlzaW9uJAokRGF0ZSQK