ZGlmZiAtLWdpdCBhL3Rvb2xzL3NjYW4tYnVpbGQvYysrLWFuYWx5emVyIGIvdG9vbHMvc2Nhbi1idWlsZC9jKystYW5hbHl6ZXIKbmV3IGZpbGUgbW9kZSAxMDA3NTUKaW5kZXggMDAwMDAwMC4uZGRhNWRiOQotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3NjYW4tYnVpbGQvYysrLWFuYWx5emVyCkBAIC0wLDAgKzEsOCBAQAorIyEvdXNyL2Jpbi9lbnYgcGVybAorCit1c2UgQ3dkIHF3LyBhYnNfcGF0aCAvOwordXNlIEZpbGU6OkJhc2VuYW1lIHF3LyBkaXJuYW1lIC87CisjIEFkZCBzY2FuLWJ1aWxkIGRpciB0byB0aGUgbGlzdCBvZiBwbGFjZXMgd2hlcmUgcGVybCBsb29rcyBmb3IgbW9kdWxlcy4KK3VzZSBsaWIgZGlybmFtZShhYnNfcGF0aCgkMCkpOworCitkbyAnY2NjLWFuYWx5emVyJzsKZGlmZiAtLWdpdCBhL3Rvb2xzL3NjYW4tYnVpbGQvYysrLWFuYWx5emVyLmJhdCBiL3Rvb2xzL3NjYW4tYnVpbGQvYysrLWFuYWx5emVyLmJhdApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi44M2M3MTcyCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvc2Nhbi1idWlsZC9jKystYW5hbHl6ZXIuYmF0CkBAIC0wLDAgKzEgQEAKK3BlcmwgLVMgYysrLWFuYWx5emVyICUqCmRpZmYgLS1naXQgYS90b29scy9zY2FuLWJ1aWxkL2NjYy1hbmFseXplciBiL3Rvb2xzL3NjYW4tYnVpbGQvY2NjLWFuYWx5emVyCm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAuLjQ1NDliMjkKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9zY2FuLWJ1aWxkL2NjYy1hbmFseXplcgpAQCAtMCwwICsxLDc2MCBAQAorIyEvdXNyL2Jpbi9lbnYgcGVybAorIworIyAgICAgICAgICAgICAgICAgICAgIFRoZSBMTFZNIENvbXBpbGVyIEluZnJhc3RydWN0dXJlCisjCisjIFRoaXMgZmlsZSBpcyBkaXN0cmlidXRlZCB1bmRlciB0aGUgVW5pdmVyc2l0eSBvZiBJbGxpbm9pcyBPcGVuIFNvdXJjZQorIyBMaWNlbnNlLiBTZWUgTElDRU5TRS5UWFQgZm9yIGRldGFpbHMuCisjCisjIz09PS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS09PT0jIworIworIyAgQSBzY3JpcHQgZGVzaWduZWQgdG8gaW50ZXJwb3NlIGJldHdlZW4gdGhlIGJ1aWxkIHN5c3RlbSBhbmQgZ2NjLiAgSXQgaW52b2tlcworIyAgYm90aCBnY2MgYW5kIHRoZSBzdGF0aWMgYW5hbHl6ZXIuCisjCisjIz09PS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS09PT0jIworCit1c2Ugc3RyaWN0OwordXNlIHdhcm5pbmdzOwordXNlIEZpbmRCaW47Cit1c2UgQ3dkIHF3LyBnZXRjd2QgYWJzX3BhdGggLzsKK3VzZSBGaWxlOjpUZW1wIHF3LyB0ZW1wZmlsZSAvOwordXNlIEZpbGU6OlBhdGggcXcgLyBta3BhdGggLzsKK3VzZSBGaWxlOjpCYXNlbmFtZTsKK3VzZSBUZXh0OjpQYXJzZVdvcmRzOworCisjIz09PS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS09PT0jIworIyBDb21waWxlciBjb21tYW5kIHNldHVwLgorIyM9PT0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPT09IyMKKworIyBTZWFyY2ggaW4gdGhlIFBBVEggaWYgdGhlIGNvbXBpbGVyIGV4aXN0cworc3ViIFNlYXJjaEluUGF0aCB7CisgICAgbXkgJGZpbGUgPSBzaGlmdDsKKyAgICBmb3JlYWNoIG15ICRkaXIgKHNwbGl0ICgnOicsICRFTlZ7UEFUSH0pKSB7CisgICAgICAgIGlmICgteCAiJGRpci8kZmlsZSIpIHsKKyAgICAgICAgICAgIHJldHVybiAxOworICAgICAgICB9CisgICAgfQorICAgIHJldHVybiAwOworfQorCitteSAkQ29tcGlsZXI7CitteSAkQ2xhbmc7CitteSAkRGVmYXVsdENDb21waWxlcjsKK215ICREZWZhdWx0Q1hYQ29tcGlsZXI7CitteSAkSXNDWFg7CisKKyMgSWYgb24gT1NYLCB1c2UgeGNydW4gdG8gZGV0ZXJtaW5lIHRoZSBTREsgcm9vdC4KK215ICRVc2VYQ1JVTiA9IDA7CisKK2lmIChgdW5hbWUgLWFgID1+IG0vRGFyd2luLykgeworICAkRGVmYXVsdENDb21waWxlciA9ICdjbGFuZyc7CisgICREZWZhdWx0Q1hYQ29tcGlsZXIgPSAnY2xhbmcrKyc7CisgICMgT2xkZXIgdmVyc2lvbnMgb2YgT1NYIGRvIG5vdCBoYXZlIHhjcnVuIHRvCisgICMgcXVlcnkgdGhlIFNESyBsb2NhdGlvbi4KKyAgaWYgKC14ICIvdXNyL2Jpbi94Y3J1biIpIHsKKyAgICAkVXNlWENSVU4gPSAxOworICB9Cit9IGVsc2UgeworICAkRGVmYXVsdENDb21waWxlciA9ICdnY2MnOworICAkRGVmYXVsdENYWENvbXBpbGVyID0gJ2crKyc7Cit9CisKK2lmICgkRmluZEJpbjo6U2NyaXB0ID1+IC9jXCtcKy1hbmFseXplci8pIHsKKyAgJENvbXBpbGVyID0gJEVOVnsnQ0NDX0NYWCd9OworICBpZiAoIWRlZmluZWQgJENvbXBpbGVyIHx8ICghIC14ICRDb21waWxlciAmJiAhIFNlYXJjaEluUGF0aCgkQ29tcGlsZXIpKSkgeyAkQ29tcGlsZXIgPSAkRGVmYXVsdENYWENvbXBpbGVyOyB9CisKKyAgJENsYW5nID0gJEVOVnsnQ0xBTkdfQ1hYJ307CisgIGlmICghZGVmaW5lZCAkQ2xhbmcgfHwgISAteCAkQ2xhbmcpIHsgJENsYW5nID0gJ2NsYW5nKysnOyB9CisKKyAgJElzQ1hYID0gMQorfQorZWxzZSB7CisgICRDb21waWxlciA9ICRFTlZ7J0NDQ19DQyd9OworICBpZiAoIWRlZmluZWQgJENvbXBpbGVyIHx8ICghIC14ICRDb21waWxlciAmJiAhIFNlYXJjaEluUGF0aCgkQ29tcGlsZXIpKSkgeyAkQ29tcGlsZXIgPSAkRGVmYXVsdENDb21waWxlcjsgfQorCisgICRDbGFuZyA9ICRFTlZ7J0NMQU5HJ307CisgIGlmICghZGVmaW5lZCAkQ2xhbmcgfHwgISAteCAkQ2xhbmcpIHsgJENsYW5nID0gJ2NsYW5nJzsgfQorCisgICRJc0NYWCA9IDAKK30KKworIyM9PT0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPT09IyMKKyMgQ2xlYW51cC4KKyMjPT09LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLT09PSMjCisKK215ICRSZXBvcnRGYWlsdXJlcyA9ICRFTlZ7J0NDQ19SRVBPUlRfRkFJTFVSRVMnfTsKK2lmICghZGVmaW5lZCAkUmVwb3J0RmFpbHVyZXMpIHsgJFJlcG9ydEZhaWx1cmVzID0gMTsgfQorCitteSAkQ2xlYW51cEZpbGU7CitteSAkUmVzdWx0RmlsZTsKKworIyBSZW1vdmUgYW55IHN0YWxlIGZpbGVzIGF0IGV4aXQuCitFTkQgeworICBpZiAoZGVmaW5lZCAkUmVzdWx0RmlsZSAmJiAteiAkUmVzdWx0RmlsZSkgeworICAgIHVubGluaygkUmVzdWx0RmlsZSk7CisgIH0KKyAgaWYgKGRlZmluZWQgJENsZWFudXBGaWxlKSB7CisgICAgdW5saW5rKCRDbGVhbnVwRmlsZSk7CisgIH0KK30KKworIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKyMgIFByb2Nlc3MgQ2xhbmcgQ3Jhc2hlcy4KKyMjLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSMjCisKK3N1YiBHZXRQUEV4dCB7CisgIG15ICRMYW5nID0gc2hpZnQ7CisgIGlmICgkTGFuZyA9fiAvb2JqZWN0aXZlLWNcK1wrLykgeyByZXR1cm4gIi5taWkiIH07CisgIGlmICgkTGFuZyA9fiAvb2JqZWN0aXZlLWMvKSB7IHJldHVybiAiLm1pIjsgfQorICBpZiAoJExhbmcgPX4gL2NcK1wrLykgeyByZXR1cm4gIi5paSI7IH0KKyAgcmV0dXJuICIuaSI7Cit9CisKKyMgU2V0IHRoaXMgdG8gMSBpZiB3ZSB3YW50IHRvIGluY2x1ZGUgJ3BhcnNlciByZWplY3RzJyBmaWxlcy4KK215ICRJbmNsdWRlUGFyc2VyUmVqZWN0cyA9IDA7CitteSAkUGFyc2VyUmVqZWN0cyA9ICJQYXJzZXIgUmVqZWN0cyI7CitteSAkQXR0cmlidXRlSWdub3JlZCA9ICJBdHRyaWJ1dGUgSWdub3JlZCI7CitteSAkT3RoZXJFcnJvciA9ICJPdGhlciBFcnJvciI7CisKK3N1YiBQcm9jZXNzQ2xhbmdGYWlsdXJlIHsKKyAgbXkgKCRDbGFuZywgJExhbmcsICRmaWxlLCAkQXJncywgJEh0bWxEaXIsICRFcnJvclR5cGUsICRvZmlsZSkgPSBAXzsKKyAgbXkgJERpciA9ICIkSHRtbERpci9mYWlsdXJlcyI7CisgIG1rcGF0aCAkRGlyOworCisgIG15ICRwcmVmaXggPSAiY2xhbmdfY3Jhc2giOworICBpZiAoJEVycm9yVHlwZSBlcSAkUGFyc2VyUmVqZWN0cykgeworICAgICRwcmVmaXggPSAiY2xhbmdfcGFyc2VyX3JlamVjdHMiOworICB9CisgIGVsc2lmICgkRXJyb3JUeXBlIGVxICRBdHRyaWJ1dGVJZ25vcmVkKSB7CisgICAgJHByZWZpeCA9ICJjbGFuZ19hdHRyaWJ1dGVfaWdub3JlZCI7CisgIH0KKyAgZWxzaWYgKCRFcnJvclR5cGUgZXEgJE90aGVyRXJyb3IpIHsKKyAgICAkcHJlZml4ID0gImNsYW5nX290aGVyX2Vycm9yIjsKKyAgfQorCisgICMgR2VuZXJhdGUgdGhlIHByZXByb2Nlc3NlZCBmaWxlIHdpdGggQ2xhbmcuCisgIG15ICgkUFBILCAkUFBGaWxlKSA9IHRlbXBmaWxlKCAkcHJlZml4IC4gIl9YWFhYWFgiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgU1VGRklYID0+IEdldFBQRXh0KCRMYW5nKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIERJUiA9PiAkRGlyKTsKKyAgc3lzdGVtICRDbGFuZywgQCRBcmdzLCAiLUUiLCAiLW8iLCAkUFBGaWxlOworICBjbG9zZSAoJFBQSCk7CisKKyAgIyBDcmVhdGUgdGhlIGluZm8gZmlsZS4KKyAgb3BlbiAoT1VULCAiPiIsICIkUFBGaWxlLmluZm8udHh0Iikgb3IgZGllICJDYW5ub3Qgb3BlbiAkUFBGaWxlLmluZm8udHh0XG4iOworICBwcmludCBPVVQgYWJzX3BhdGgoJGZpbGUpLCAiXG4iOworICBwcmludCBPVVQgIiRFcnJvclR5cGVcbiI7CisgIHByaW50IE9VVCAiQCRBcmdzXG4iOworICBjbG9zZSBPVVQ7CisgIGB1bmFtZSAtYSA+PiAkUFBGaWxlLmluZm8udHh0IDI+JjFgOworICBgJENvbXBpbGVyIC12ID4+ICRQUEZpbGUuaW5mby50eHQgMj4mMWA7CisgIHJlbmFtZSgkb2ZpbGUsICIkUFBGaWxlLnN0ZGVyci50eHQiKTsKKyAgcmV0dXJuIChiYXNlbmFtZSAkUFBGaWxlKTsKK30KKworIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKyMgIFJ1bm5pbmcgdGhlIGFuYWx5emVyLgorIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKworc3ViIEdldENDQXJncyB7CisgIG15ICRtb2RlID0gc2hpZnQ7CisgIG15ICRBcmdzID0gc2hpZnQ7CisKKyAgcGlwZSAoRlJPTV9DSElMRCwgVE9fUEFSRU5UKTsKKyAgbXkgJHBpZCA9IGZvcmsoKTsKKyAgaWYgKCRwaWQgPT0gMCkgeworICAgIGNsb3NlIEZST01fQ0hJTEQ7CisgICAgb3BlbihTVERPVVQsIj4mIiwgXCpUT19QQVJFTlQpOworICAgIG9wZW4oU1RERVJSLCI+JiIsIFwqVE9fUEFSRU5UKTsKKyAgICBleGVjICRDbGFuZywgIi0jIyMiLCAkbW9kZSwgQCRBcmdzOworICB9CisgIGNsb3NlKFRPX1BBUkVOVCk7CisgIG15ICRsaW5lOworICB3aGlsZSAoPEZST01fQ0hJTEQ+KSB7CisgICAgbmV4dCBpZiAoIS9ccyI/LWNjMSI/XHMvKTsKKyAgICAkbGluZSA9ICRfOworICB9CisKKyAgd2FpdHBpZCgkcGlkLDApOworICBjbG9zZShGUk9NX0NISUxEKTsKKworICBkaWUgImNvdWxkIG5vdCBmaW5kIGNsYW5nIGxpbmVcbiIgaWYgKCFkZWZpbmVkICRsaW5lKTsKKyAgIyBTdHJpcCBsZWFkaW5nIGFuZCB0cmFpbGluZyB3aGl0ZXNwYWNlIGNoYXJhY3RlcnMuCisgICRsaW5lID1+IHMvXlxzK3xccyskLy9nOworICBteSBAaXRlbXMgPSBxdW90ZXdvcmRzKCdccysnLCAwLCAkbGluZSk7CisgIG15ICRjbWQgPSBzaGlmdCBAaXRlbXM7CisgIGRpZSAiY2Fubm90IGZpbmQgJ2NsYW5nJyBpbiAnY2xhbmcnIGNvbW1hbmRcbiIgaWYgKCEoJGNtZCA9fiAvY2xhbmcvKSk7CisgIHJldHVybiBcQGl0ZW1zOworfQorCitzdWIgQW5hbHl6ZSB7CisgIG15ICgkQ2xhbmcsICRPcmlnaW5hbEFyZ3MsICRBbmFseXplQXJncywgJExhbmcsICRPdXRwdXQsICRWZXJib3NlLCAkSHRtbERpciwKKyAgICAgICRmaWxlKSA9IEBfOworCisgIG15IEBBcmdzID0gQCRPcmlnaW5hbEFyZ3M7CisgIG15ICRDbWQ7CisgIG15IEBDbWRBcmdzOworICBteSBAQ21kQXJnc1NhbnNBbmFseXNlczsKKworICBpZiAoJExhbmcgPX4gL2hlYWRlci8pIHsKKyAgICBleGl0IDAgaWYgKCFkZWZpbmVkICgkT3V0cHV0KSk7CisgICAgJENtZCA9ICdjcCc7CisgICAgcHVzaCBAQ21kQXJncywgJGZpbGU7CisgICAgIyBSZW1vdmUgdGhlIFBDSCBleHRlbnNpb24uCisgICAgJE91dHB1dCA9fiBzL1suXWdjaCQvLzsKKyAgICBwdXNoIEBDbWRBcmdzLCAkT3V0cHV0OworICAgIEBDbWRBcmdzU2Fuc0FuYWx5c2VzID0gQENtZEFyZ3M7CisgIH0KKyAgZWxzZSB7CisgICAgJENtZCA9ICRDbGFuZzsKKworICAgICMgQ3JlYXRlIGFyZ3VtZW50cyBmb3IgZG9pbmcgcmVndWxhciBwYXJzaW5nLgorICAgIG15ICRTeW50YXhBcmdzID0gR2V0Q0NBcmdzKCItZnN5bnRheC1vbmx5IiwgXEBBcmdzKTsKKyAgICBAQ21kQXJnc1NhbnNBbmFseXNlcyA9IEAkU3ludGF4QXJnczsKKworICAgICMgQ3JlYXRlIGFyZ3VtZW50cyBmb3IgZG9pbmcgc3RhdGljIGFuYWx5c2lzLgorICAgIGlmIChkZWZpbmVkICRSZXN1bHRGaWxlKSB7CisgICAgICBwdXNoIEBBcmdzLCAnLW8nLCAkUmVzdWx0RmlsZTsKKyAgICB9CisgICAgZWxzaWYgKGRlZmluZWQgJEh0bWxEaXIpIHsKKyAgICAgIHB1c2ggQEFyZ3MsICctbycsICRIdG1sRGlyOworICAgIH0KKyAgICBpZiAoJFZlcmJvc2UpIHsKKyAgICAgIHB1c2ggQEFyZ3MsICItWGNsYW5nIiwgIi1hbmFseXplci1kaXNwbGF5LXByb2dyZXNzIjsKKyAgICB9CisKKyAgICBmb3JlYWNoIG15ICRhcmcgKEAkQW5hbHl6ZUFyZ3MpIHsKKyAgICAgIHB1c2ggQEFyZ3MsICItWGNsYW5nIiwgJGFyZzsKKyAgICB9CisKKyAgICAjIERpc3BsYXkgVWJpdml6IGdyYXBoPworICAgIGlmIChkZWZpbmVkICRFTlZ7J0NDQ19VQkknfSkgeworICAgICAgcHVzaCBAQXJncywgIi1YY2xhbmciLCAiLWFuYWx5emVyLXZpei1lZ3JhcGgtdWJpZ3JhcGgiOworICAgIH0KKworICAgIG15ICRBbmFseXNpc0FyZ3MgPSBHZXRDQ0FyZ3MoIi0tYW5hbHl6ZSIsIFxAQXJncyk7CisgICAgQENtZEFyZ3MgPSBAJEFuYWx5c2lzQXJnczsKKyAgfQorCisgIG15IEBQcmludEFyZ3M7CisgIG15ICRkaXI7CisKKyAgaWYgKCRWZXJib3NlKSB7CisgICAgJGRpciA9IGdldGN3ZCgpOworICAgIHByaW50IFNUREVSUiAiXG5bTE9DQVRJT05dOiAkZGlyXG4iOworICAgIHB1c2ggQFByaW50QXJncywiJyRDbWQnIjsKKyAgICBmb3JlYWNoIG15ICRhcmcgKEBDbWRBcmdzKSB7CisgICAgICAgIHB1c2ggQFByaW50QXJncywiXCckYXJnXCciOworICAgIH0KKyAgfQorICBpZiAoJFZlcmJvc2UgPT0gMSkgeworICAgICMgV2UgTVVTVCBwcmludCB0byBzdGRlcnIuICBTb21lIGNsaWVudHMgdXNlIHRoZSBzdGRvdXQgb3V0cHV0IG9mCisgICAgIyBnY2MgZm9yIHZhcmlvdXMgcHVycG9zZXMuCisgICAgcHJpbnQgU1RERVJSIGpvaW4oJyAnLCBAUHJpbnRBcmdzKTsKKyAgICBwcmludCBTVERFUlIgIlxuIjsKKyAgfQorICBlbHNpZiAoJFZlcmJvc2UgPT0gMikgeworICAgIHByaW50IFNUREVSUiAiI1NIRUxMIChjZCAnJGRpcicgJiYgQFByaW50QXJncylcbiI7CisgIH0KKworICAjIENhcHR1cmUgdGhlIFNUREVSUiBvZiBjbGFuZyBhbmQgc2VuZCBpdCB0byBhIHRlbXBvcmFyeSBmaWxlLgorICAjIENhcHR1cmUgdGhlIFNURE9VVCBvZiBjbGFuZyBhbmQgcmVyb3V0ZSBpdCB0byBjY2MtYW5hbHl6ZXIncyBTVERFUlIuCisgICMgV2Ugc2F2ZSB0aGUgb3V0cHV0IGZpbGUgaW4gdGhlICdjcmFzaGVzJyBkaXJlY3RvcnkgaWYgY2xhbmcgZW5jb3VudGVycworICAjIGFueSBwcm9ibGVtcyB3aXRoIHRoZSBmaWxlLgorICBwaXBlIChGUk9NX0NISUxELCBUT19QQVJFTlQpOworICBteSAkcGlkID0gZm9yaygpOworICBpZiAoJHBpZCA9PSAwKSB7CisgICAgY2xvc2UgRlJPTV9DSElMRDsKKyAgICBvcGVuKFNURE9VVCwiPiYiLCBcKlRPX1BBUkVOVCk7CisgICAgb3BlbihTVERFUlIsIj4mIiwgXCpUT19QQVJFTlQpOworICAgIGV4ZWMgJENtZCwgQENtZEFyZ3M7CisgIH0KKworICBjbG9zZSBUT19QQVJFTlQ7CisgIG15ICgkb2ZoLCAkb2ZpbGUpID0gdGVtcGZpbGUoImNsYW5nX291dHB1dF9YWFhYWFgiLCBESVIgPT4gJEh0bWxEaXIpOworCisgIHdoaWxlICg8RlJPTV9DSElMRD4pIHsKKyAgICBwcmludCAkb2ZoICRfOworICAgIHByaW50IFNUREVSUiAkXzsKKyAgfQorICBjbG9zZSAkb2ZoOworCisgIHdhaXRwaWQoJHBpZCwwKTsKKyAgY2xvc2UoRlJPTV9DSElMRCk7CisgIG15ICRSZXN1bHQgPSAkPzsKKworICAjIERpZCB0aGUgY29tbWFuZCBkaWUgYmVjYXVzZSBvZiBhIHNpZ25hbD8KKyAgaWYgKCRSZXBvcnRGYWlsdXJlcykgeworICAgIGlmICgkUmVzdWx0ICYgMTI3IGFuZCAkQ21kIGVxICRDbGFuZyBhbmQgZGVmaW5lZCAkSHRtbERpcikgeworICAgICAgUHJvY2Vzc0NsYW5nRmFpbHVyZSgkQ2xhbmcsICRMYW5nLCAkZmlsZSwgXEBDbWRBcmdzU2Fuc0FuYWx5c2VzLAorICAgICAgICAgICAgICAgICAgICAgICAgICAkSHRtbERpciwgIkNyYXNoIiwgJG9maWxlKTsKKyAgICB9CisgICAgZWxzaWYgKCRSZXN1bHQpIHsKKyAgICAgIGlmICgkSW5jbHVkZVBhcnNlclJlamVjdHMgJiYgISgkZmlsZSA9fi9jb25mdGVzdC8pKSB7CisgICAgICAgIFByb2Nlc3NDbGFuZ0ZhaWx1cmUoJENsYW5nLCAkTGFuZywgJGZpbGUsIFxAQ21kQXJnc1NhbnNBbmFseXNlcywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAkSHRtbERpciwgJFBhcnNlclJlamVjdHMsICRvZmlsZSk7CisgICAgICB9IGVsc2UgeworICAgICAgICBQcm9jZXNzQ2xhbmdGYWlsdXJlKCRDbGFuZywgJExhbmcsICRmaWxlLCBcQENtZEFyZ3NTYW5zQW5hbHlzZXMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgJEh0bWxEaXIsICRPdGhlckVycm9yLCAkb2ZpbGUpOworICAgICAgfQorICAgIH0KKyAgICBlbHNlIHsKKyAgICAgICMgQ2hlY2sgaWYgdGhlcmUgd2VyZSBhbnkgdW5oYW5kbGVkIGF0dHJpYnV0ZXMuCisgICAgICBpZiAob3BlbihDSElMRCwgJG9maWxlKSkgeworICAgICAgICBteSAlYXR0cmlidXRlc19ub3RfaGFuZGxlZDsKKworICAgICAgICAjIERvbid0IGZsYWcgd2FybmluZ3MgYWJvdXQgdGhlIGZvbGxvd2luZyBhdHRyaWJ1dGVzIHRoYXQgd2UKKyAgICAgICAgIyBrbm93IGFyZSBjdXJyZW50bHkgbm90IHN1cHBvcnRlZCBieSBDbGFuZy4KKyAgICAgICAgJGF0dHJpYnV0ZXNfbm90X2hhbmRsZWR7ImNkZWNsIn0gPSAxOworCisgICAgICAgIG15ICRwcGZpbGU7CisgICAgICAgIHdoaWxlICg8Q0hJTEQ+KSB7CisgICAgICAgICAgbmV4dCBpZiAoISAvd2FybmluZzogJyhbXlwnXSspJyBhdHRyaWJ1dGUgaWdub3JlZC8pOworCisgICAgICAgICAgIyBIYXZlIHdlIGFscmVhZHkgc3BvdHRlZCB0aGlzIHVuaGFuZGxlZCBhdHRyaWJ1dGU/CisgICAgICAgICAgbmV4dCBpZiAoZGVmaW5lZCAkYXR0cmlidXRlc19ub3RfaGFuZGxlZHskMX0pOworICAgICAgICAgICRhdHRyaWJ1dGVzX25vdF9oYW5kbGVkeyQxfSA9IDE7CisKKyAgICAgICAgICAjIEdldCB0aGUgbmFtZSBvZiB0aGUgYXR0cmlidXRlIGZpbGUuCisgICAgICAgICAgbXkgJGRpciA9ICIkSHRtbERpci9mYWlsdXJlcyI7CisgICAgICAgICAgbXkgJGFmaWxlID0gIiRkaXIvYXR0cmlidXRlX2lnbm9yZWRfJDEudHh0IjsKKworICAgICAgICAgICMgT25seSBjcmVhdGUgYW5vdGhlciBwcmVwcm9jZXNzZWQgZmlsZSBpZiB0aGUgYXR0cmlidXRlIGZpbGUKKyAgICAgICAgICAjIGRvZXNuJ3QgZXhpc3QgeWV0LgorICAgICAgICAgIG5leHQgaWYgKC1lICRhZmlsZSk7CisKKyAgICAgICAgICAjIEFkZCB0aGlzIGZpbGUgdG8gdGhlIGxpc3Qgb2YgZmlsZXMgdGhhdCBjb250YWluZWQgdGhpcyBhdHRyaWJ1dGUuCisgICAgICAgICAgIyBHZW5lcmF0ZSBhIHByZXByb2Nlc3NlZCBmaWxlIGlmIHdlIGhhdmVuJ3QgYWxyZWFkeS4KKyAgICAgICAgICBpZiAoIShkZWZpbmVkICRwcGZpbGUpKSB7CisgICAgICAgICAgICAkcHBmaWxlID0gUHJvY2Vzc0NsYW5nRmFpbHVyZSgkQ2xhbmcsICRMYW5nLCAkZmlsZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFxAQ21kQXJnc1NhbnNBbmFseXNlcywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICRIdG1sRGlyLCAkQXR0cmlidXRlSWdub3JlZCwgJG9maWxlKTsKKyAgICAgICAgICB9CisKKyAgICAgICAgICBta3BhdGggJGRpcjsKKyAgICAgICAgICBvcGVuKEFGSUxFLCAiPiRhZmlsZSIpOworICAgICAgICAgIHByaW50IEFGSUxFICIkcHBmaWxlXG4iOworICAgICAgICAgIGNsb3NlKEFGSUxFKTsKKyAgICAgICAgfQorICAgICAgICBjbG9zZSBDSElMRDsKKyAgICAgIH0KKyAgICB9CisgIH0KKworICB1bmxpbmsoJG9maWxlKTsKK30KKworIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKyMgIExvb2t1cCB0YWJsZXMuCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworCitteSAlQ29tcGlsZU9wdGlvbk1hcCA9ICgKKyAgJy1ub3N0ZGluYycgPT4gMCwKKyAgJy1pbmNsdWRlJyA9PiAxLAorICAnLWlkaXJhZnRlcicgPT4gMSwKKyAgJy1pbWFjcm9zJyA9PiAxLAorICAnLWlwcmVmaXgnID0+IDEsCisgICctaXF1b3RlJyA9PiAxLAorICAnLWl3aXRocHJlZml4JyA9PiAxLAorICAnLWl3aXRocHJlZml4YmVmb3JlJyA9PiAxCispOworCitteSAlTGlua2VyT3B0aW9uTWFwID0gKAorICAnLWZyYW1ld29yaycgPT4gMSwKKyAgJy1mb2JqYy1saW5rLXJ1bnRpbWUnID0+IDAKKyk7CisKK215ICVDb21waWxlckxpbmtlck9wdGlvbk1hcCA9ICgKKyAgJy1Xd3JpdGUtc3RyaW5ncycgPT4gMCwKKyAgJy1mdHJhcHYtaGFuZGxlcicgPT4gMSwgIyBzcGVjaWZpY2FsbHkgY2FsbCBvdXQgc2VwYXJhdGVkIC1mIGZsYWcKKyAgJy1taW9zLXNpbXVsYXRvci12ZXJzaW9uLW1pbicgPT4gMCwgIyBUaGlzIHJlYWxseSBoYXMgMSBhcmd1bWVudCwgYnV0IGFsd2F5cyBoYXMgJz0nCisgICctaXN5c3Jvb3QnID0+IDEsCisgICctYXJjaCcgPT4gMSwKKyAgJy1tMzInID0+IDAsCisgICctbTY0JyA9PiAwLAorICAnLXN0ZGxpYicgPT4gMCwgIyBUaGlzIGlzIHJlYWxseSBhIDEgYXJndW1lbnQsIGJ1dCBhbHdheXMgaGFzICc9JworICAnLS1zeXNyb290JyA9PiAxLAorICAnLXRhcmdldCcgPT4gMSwKKyAgJy12JyA9PiAwLAorICAnLW1tYWNvc3gtdmVyc2lvbi1taW4nID0+IDAsICMgVGhpcyBpcyByZWFsbHkgYSAxIGFyZ3VtZW50LCBidXQgYWx3YXlzIGhhcyAnPScKKyAgJy1taXBob25lb3MtdmVyc2lvbi1taW4nID0+IDAgIyBUaGlzIGlzIHJlYWxseSBhIDEgYXJndW1lbnQsIGJ1dCBhbHdheXMgaGFzICc9JworKTsKKworbXkgJUlnbm9yZWRPcHRpb25NYXAgPSAoCisgICctTVQnID0+IDEsICAjIElnbm9yZSB0aGVzZSBwcmVwcm9jZXNzb3Igb3B0aW9ucy4KKyAgJy1NRicgPT4gMSwKKworICAnLWZzeW50YXgtb25seScgPT4gMCwKKyAgJy1zYXZlLXRlbXBzJyA9PiAwLAorICAnLWluc3RhbGxfbmFtZScgPT4gMSwKKyAgJy1leHBvcnRlZF9zeW1ib2xzX2xpc3QnID0+IDEsCisgICctY3VycmVudF92ZXJzaW9uJyA9PiAxLAorICAnLWNvbXBhdGliaWxpdHlfdmVyc2lvbicgPT4gMSwKKyAgJy1pbml0JyA9PiAxLAorICAnLWUnID0+IDEsCisgICctc2VnMWFkZHInID0+IDEsCisgICctYnVuZGxlX2xvYWRlcicgPT4gMSwKKyAgJy1tdWx0aXBseV9kZWZpbmVkJyA9PiAxLAorICAnLXNlY3RvcmRlcicgPT4gMywKKyAgJy0tcGFyYW0nID0+IDEsCisgICctdScgPT4gMSwKKyAgJy0tc2VyaWFsaXplLWRpYWdub3N0aWNzJyA9PiAxCispOworCitteSAlTGFuZ01hcCA9ICgKKyAgJ2MnICAgPT4gJElzQ1hYID8gJ2MrKycgOiAnYycsCisgICdjcCcgID0+ICdjKysnLAorICAnY3BwJyA9PiAnYysrJywKKyAgJ2N4eCcgPT4gJ2MrKycsCisgICd0eHgnID0+ICdjKysnLAorICAnY2MnICA9PiAnYysrJywKKyAgJ0MnICAgPT4gJ2MrKycsCisgICdpaScgID0+ICdjKystY3BwLW91dHB1dCcsCisgICdpJyAgID0+ICRJc0NYWCA/ICdjKystY3BwLW91dHB1dCcgOiAnYy1jcHAtb3V0cHV0JywKKyAgJ20nICAgPT4gJ29iamVjdGl2ZS1jJywKKyAgJ21pJyAgPT4gJ29iamVjdGl2ZS1jLWNwcC1vdXRwdXQnLAorICAnbW0nICA9PiAnb2JqZWN0aXZlLWMrKycsCisgICdtaWknID0+ICdvYmplY3RpdmUtYysrLWNwcC1vdXRwdXQnLAorKTsKKworbXkgJVVuaXF1ZU9wdGlvbnMgPSAoCisgICctaXN5c3Jvb3QnID0+IDAKKyk7CisKKyMjLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSMjCisjIExhbmd1YWdlcyBhY2NlcHRlZC4KKyMjLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSMjCisKK215ICVMYW5nc0FjY2VwdGVkID0gKAorICAib2JqZWN0aXZlLWMiID0+IDEsCisgICJjIiA9PiAxLAorICAiYysrIiA9PiAxLAorICAib2JqZWN0aXZlLWMrKyIgPT4gMSwKKyAgImMtY3BwLW91dHB1dCIgPT4gMSwKKyAgIm9iamVjdGl2ZS1jLWNwcC1vdXRwdXQiID0+IDEsCisgICJjKystY3BwLW91dHB1dCIgPT4gMQorKTsKKworIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKyMgIE1haW4gTG9naWMuCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworCitteSAkQWN0aW9uID0gJ2xpbmsnOworbXkgQENvbXBpbGVPcHRzOworbXkgQExpbmtPcHRzOworbXkgQEZpbGVzOworbXkgJExhbmc7CitteSAkT3V0cHV0OworbXkgJVVuaXF1ZWQ7CisKKyMgRm9yd2FyZCBhcmd1bWVudHMgdG8gZ2NjLgorbXkgJFN0YXR1cyA9IHN5c3RlbSgkQ29tcGlsZXIsQEFSR1YpOworaWYgKGRlZmluZWQgJEVOVnsnQ0NDX0FOQUxZWkVSX0xPRyd9KSB7CisgIHByaW50IFNUREVSUiAiJENvbXBpbGVyIEBBUkdWXG4iOworfQoraWYgKCRTdGF0dXMpIHsgZXhpdCgkU3RhdHVzID4+IDgpOyB9CisKKyMgR2V0IHRoZSBhbmFseXNpcyBvcHRpb25zLgorbXkgJEFuYWx5c2VzID0gJEVOVnsnQ0NDX0FOQUxZWkVSX0FOQUxZU0lTJ307CisKKyMgR2V0IHRoZSBwbHVnaW5zIHRvIGxvYWQuCitteSAkUGx1Z2lucyA9ICRFTlZ7J0NDQ19BTkFMWVpFUl9QTFVHSU5TJ307CisKKyMgR2V0IHRoZSBzdG9yZSBtb2RlbC4KK215ICRTdG9yZU1vZGVsID0gJEVOVnsnQ0NDX0FOQUxZWkVSX1NUT1JFX01PREVMJ307CisKKyMgR2V0IHRoZSBjb25zdHJhaW50cyBlbmdpbmUuCitteSAkQ29uc3RyYWludHNNb2RlbCA9ICRFTlZ7J0NDQ19BTkFMWVpFUl9DT05TVFJBSU5UU19NT0RFTCd9OworCisjR2V0IHRoZSBpbnRlcm5hbCBzdGF0cyBzZXR0aW5nLgorbXkgJEludGVybmFsU3RhdHMgPSAkRU5WeydDQ0NfQU5BTFlaRVJfSU5URVJOQUxfU1RBVFMnfTsKKworIyBHZXQgdGhlIG91dHB1dCBmb3JtYXQuCitteSAkT3V0cHV0Rm9ybWF0ID0gJEVOVnsnQ0NDX0FOQUxZWkVSX09VVFBVVF9GT1JNQVQnfTsKK2lmICghZGVmaW5lZCAkT3V0cHV0Rm9ybWF0KSB7ICRPdXRwdXRGb3JtYXQgPSAiaHRtbCI7IH0KKworIyBHZXQgdGhlIGNvbmZpZyBvcHRpb25zLgorbXkgJENvbmZpZ09wdGlvbnMgPSAkRU5WeydDQ0NfQU5BTFlaRVJfQ09ORklHJ307CisKKyMgRGV0ZXJtaW5lIHRoZSBsZXZlbCBvZiB2ZXJib3NpdHkuCitteSAkVmVyYm9zZSA9IDA7CitpZiAoZGVmaW5lZCAkRU5WeydDQ0NfQU5BTFlaRVJfVkVSQk9TRSd9KSB7ICRWZXJib3NlID0gMTsgfQoraWYgKGRlZmluZWQgJEVOVnsnQ0NDX0FOQUxZWkVSX0xPRyd9KSB7ICRWZXJib3NlID0gMjsgfQorCisjIEdldCB0aGUgSFRNTCBvdXRwdXQgZGlyZWN0b3J5LgorbXkgJEh0bWxEaXIgPSAkRU5WeydDQ0NfQU5BTFlaRVJfSFRNTCd9OworCitteSAlRGlzYWJsZWRBcmNocyA9ICgncHBjJyA9PiAxLCAncHBjNjQnID0+IDEpOworbXkgJUFyY2hzU2VlbjsKK215ICRIYWRBcmNoID0gMDsKK215ICRIYXNTREsgPSAwOworCisjIFByb2Nlc3MgdGhlIGFyZ3VtZW50cy4KK2ZvcmVhY2ggKG15ICRpID0gMDsgJGkgPCBzY2FsYXIoQEFSR1YpOyArKyRpKSB7CisgIG15ICRBcmcgPSAkQVJHVlskaV07CisgIG15ICgkQXJnS2V5KSA9IHNwbGl0IC89LywkQXJnLDI7CisKKyAgIyBCZSBmcmllbmRseSB0byAiIiBpbiB0aGUgYXJndW1lbnQgbGlzdC4KKyAgaWYgKCFkZWZpbmVkKCRBcmdLZXkpKSB7CisgICAgbmV4dDsKKyAgfQorCisgICMgTW9kZXMgY2NjLWFuYWx5emVyIHN1cHBvcnRzCisgIGlmICgkQXJnID1+IC9eLShFfE1NPykkLykgeyAkQWN0aW9uID0gJ3ByZXByb2Nlc3MnOyB9CisgIGVsc2lmICgkQXJnIGVxICctYycpIHsgJEFjdGlvbiA9ICdjb21waWxlJzsgfQorICBlbHNpZiAoJEFyZyA9fiAvXi1wcmludC1wcm9nLW5hbWUvKSB7IGV4aXQgMDsgfQorCisgICMgU3BlY2lhbGx5IGhhbmRsZSBkdXBsaWNhdGUgY2FzZXMgb2YgLWFyY2gKKyAgaWYgKCRBcmcgZXEgIi1hcmNoIikgeworICAgIG15ICRhcmNoID0gJEFSR1ZbJGkrMV07CisgICAgIyBXZSBkb24ndCB3YW50IHRvIHByb2Nlc3MgJ3BwYycgYmVjYXVzZSBvZiBDbGFuZydzIGxhY2sgb2Ygc3VwcG9ydAorICAgICMgZm9yIEFsdGl2ZWMgKGFsc28gc29tZSAjZGVmaW5lcyB3b24ndCBsaWtlbHkgYmUgZGVmaW5lZCBjb3JyZWN0bHksIGV0Yy4pCisgICAgaWYgKCEoZGVmaW5lZCAkRGlzYWJsZWRBcmNoc3skYXJjaH0pKSB7ICRBcmNoc1NlZW57JGFyY2h9ID0gMTsgfQorICAgICRIYWRBcmNoID0gMTsKKyAgICArKyRpOworICAgIG5leHQ7CisgIH0KKworICAjIE9uIE9TWC9pT1MsIHJlY29yZCBpZiBhbiBTREsgcGF0aCB3YXMgc3BlY2lmaWVkLiAgVGhpcworICAjIGlzIGlubm9jdW91cyBmb3Igb3RoZXIgcGxhdGZvcm1zLCBzbyB0aGUgY2hlY2sganVzdCBoYXBwZW5zLgorICBpZiAoJEFyZyA9fiAvXi1pc3lzcm9vdC8pIHsKKyAgICAkSGFzU0RLID0gMTsKKyAgfQorCisgICMgT3B0aW9ucyB3aXRoIHBvc3NpYmxlIGFyZ3VtZW50cyB0aGF0IHNob3VsZCBwYXNzIHRocm91Z2ggdG8gY29tcGlsZXIuCisgIGlmIChkZWZpbmVkICRDb21waWxlT3B0aW9uTWFweyRBcmdLZXl9KSB7CisgICAgbXkgJENudCA9ICRDb21waWxlT3B0aW9uTWFweyRBcmdLZXl9OworICAgIHB1c2ggQENvbXBpbGVPcHRzLCRBcmc7CisgICAgd2hpbGUgKCRDbnQgPiAwKSB7ICsrJGk7IC0tJENudDsgcHVzaCBAQ29tcGlsZU9wdHMsICRBUkdWWyRpXTsgfQorICAgIG5leHQ7CisgIH0KKyAgIyBIYW5kbGUgdGhlIGNhc2Ugd2hlcmUgdGhlcmUgaXNuJ3QgYSBzcGFjZSBhZnRlciAtaXF1b3RlCisgIGlmICgkQXJnID1+IC9eLWlxdW90ZS4qLykgeworICAgIHB1c2ggQENvbXBpbGVPcHRzLCRBcmc7CisgICAgbmV4dDsKKyAgfQorCisgICMgT3B0aW9ucyB3aXRoIHBvc3NpYmxlIGFyZ3VtZW50cyB0aGF0IHNob3VsZCBwYXNzIHRocm91Z2ggdG8gbGlua2VyLgorICBpZiAoZGVmaW5lZCAkTGlua2VyT3B0aW9uTWFweyRBcmdLZXl9KSB7CisgICAgbXkgJENudCA9ICRMaW5rZXJPcHRpb25NYXB7JEFyZ0tleX07CisgICAgcHVzaCBATGlua09wdHMsJEFyZzsKKyAgICB3aGlsZSAoJENudCA+IDApIHsgKyskaTsgLS0kQ250OyBwdXNoIEBMaW5rT3B0cywgJEFSR1ZbJGldOyB9CisgICAgbmV4dDsKKyAgfQorCisgICMgT3B0aW9ucyB3aXRoIHBvc3NpYmxlIGFyZ3VtZW50cyB0aGF0IHNob3VsZCBwYXNzIHRocm91Z2ggdG8gYm90aCBjb21waWxlcgorICAjIGFuZCB0aGUgbGlua2VyLgorICBpZiAoZGVmaW5lZCAkQ29tcGlsZXJMaW5rZXJPcHRpb25NYXB7JEFyZ0tleX0pIHsKKyAgICBteSAkQ250ID0gJENvbXBpbGVyTGlua2VyT3B0aW9uTWFweyRBcmdLZXl9OworCisgICAgIyBDaGVjayBpZiB0aGlzIGlzIGFuIG9wdGlvbiB0aGF0IHNob3VsZCBoYXZlIGEgdW5pcXVlIHZhbHVlLCBhbmQgaWYgc28KKyAgICAjIGRldGVybWluZSBpZiB0aGUgdmFsdWUgd2FzIGNoZWNrZWQgYmVmb3JlLgorICAgIGlmICgkVW5pcXVlT3B0aW9uc3skQXJnfSkgeworICAgICAgaWYgKGRlZmluZWQgJFVuaXF1ZWR7JEFyZ30pIHsKKyAgICAgICAgJGkgKz0gJENudDsKKyAgICAgICAgbmV4dDsKKyAgICAgIH0KKyAgICAgICRVbmlxdWVkeyRBcmd9ID0gMTsKKyAgICB9CisKKyAgICBwdXNoIEBDb21waWxlT3B0cywkQXJnOworICAgIHB1c2ggQExpbmtPcHRzLCRBcmc7CisKKyAgICB3aGlsZSAoJENudCA+IDApIHsKKyAgICAgICsrJGk7IC0tJENudDsKKyAgICAgIHB1c2ggQENvbXBpbGVPcHRzLCAkQVJHVlskaV07CisgICAgICBwdXNoIEBMaW5rT3B0cywgJEFSR1ZbJGldOworICAgIH0KKyAgICBuZXh0OworICB9CisKKyAgIyBJZ25vcmVkIG9wdGlvbnMuCisgIGlmIChkZWZpbmVkICRJZ25vcmVkT3B0aW9uTWFweyRBcmdLZXl9KSB7CisgICAgbXkgJENudCA9ICRJZ25vcmVkT3B0aW9uTWFweyRBcmdLZXl9OworICAgIHdoaWxlICgkQ250ID4gMCkgeworICAgICAgKyskaTsgLS0kQ250OworICAgIH0KKyAgICBuZXh0OworICB9CisKKyAgIyBDb21waWxlIG1vZGUgZmxhZ3MuCisgIGlmICgkQXJnID1+IC9eLVtELEksVSxpc3lzdGVtXSguKikkLykgeworICAgIG15ICRUbXAgPSAkQXJnOworICAgIGlmICgkMSBlcSAnJykgeworICAgICAgIyBGSVhNRTogQ2hlY2sgaWYgd2UgYXJlIGdvaW5nIG9mZiB0aGUgZW5kLgorICAgICAgKyskaTsKKyAgICAgICRUbXAgPSAkQXJnIC4gJEFSR1ZbJGldOworICAgIH0KKyAgICBwdXNoIEBDb21waWxlT3B0cywkVG1wOworICAgIG5leHQ7CisgIH0KKworICBpZiAoJEFyZyA9fiAvXi1tLiovKSB7CisgICAgcHVzaCBAQ29tcGlsZU9wdHMsJEFyZzsKKyAgICBuZXh0OworICB9CisKKyAgIyBMYW5ndWFnZS4KKyAgaWYgKCRBcmcgZXEgJy14JykgeworICAgICRMYW5nID0gJEFSR1ZbJGkrMV07CisgICAgKyskaTsgbmV4dDsKKyAgfQorCisgICMgT3V0cHV0IGZpbGUuCisgIGlmICgkQXJnIGVxICctbycpIHsKKyAgICArKyRpOworICAgICRPdXRwdXQgPSAkQVJHVlskaV07CisgICAgbmV4dDsKKyAgfQorCisgICMgR2V0IHRoZSBsaW5rIG1vZGUuCisgIGlmICgkQXJnID1+IC9eLVtsLEwsT10vKSB7CisgICAgaWYgKCRBcmcgZXEgJy1PJykgeyBwdXNoIEBMaW5rT3B0cywnLU8xJzsgfQorICAgIGVsc2lmICgkQXJnIGVxICctT3MnKSB7IHB1c2ggQExpbmtPcHRzLCctTzInOyB9CisgICAgZWxzZSB7IHB1c2ggQExpbmtPcHRzLCRBcmc7IH0KKworICAgICMgTXVzdCBwYXNzIHRoaXMgYWxvbmcgZm9yIHRoZSBfX09QVElNSVpFX18gbWFjcm8KKyAgICBpZiAoJEFyZyA9fiAvXi1PLykgeyBwdXNoIEBDb21waWxlT3B0cywkQXJnOyB9CisgICAgbmV4dDsKKyAgfQorCisgIGlmICgkQXJnID1+IC9eLXN0ZD0vKSB7CisgICAgcHVzaCBAQ29tcGlsZU9wdHMsJEFyZzsKKyAgICBuZXh0OworICB9CisKKyAgIyBHZXQgdGhlIGNvbXBpbGVyL2xpbmsgbW9kZS4KKyAgaWYgKCRBcmcgPX4gL14tRiguKykkLykgeworICAgIG15ICRUbXAgPSAkQXJnOworICAgIGlmICgkMSBlcSAnJykgeworICAgICAgIyBGSVhNRTogQ2hlY2sgaWYgd2UgYXJlIGdvaW5nIG9mZiB0aGUgZW5kLgorICAgICAgKyskaTsKKyAgICAgICRUbXAgPSAkQXJnIC4gJEFSR1ZbJGldOworICAgIH0KKyAgICBwdXNoIEBDb21waWxlT3B0cywkVG1wOworICAgIHB1c2ggQExpbmtPcHRzLCRUbXA7CisgICAgbmV4dDsKKyAgfQorCisgICMgSW5wdXQgZmlsZXMuCisgIGlmICgkQXJnIGVxICctZmlsZWxpc3QnKSB7CisgICAgIyBGSVhNRTogTWFrZSBzdXJlIHdlIGFyZW4ndCB3YWxraW5nIG9mZiB0aGUgZW5kLgorICAgIG9wZW4oSU4sICRBUkdWWyRpKzFdKTsKKyAgICB3aGlsZSAoPElOPikgeyBzL1wwMTU/XDAxMi8vOyBwdXNoIEBGaWxlcywkXzsgfQorICAgIGNsb3NlKElOKTsKKyAgICArKyRpOworICAgIG5leHQ7CisgIH0KKworICBpZiAoJEFyZyA9fiAvXi1mLykgeworICAgIHB1c2ggQENvbXBpbGVPcHRzLCRBcmc7CisgICAgcHVzaCBATGlua09wdHMsJEFyZzsKKyAgICBuZXh0OworICB9CisKKyAgIyBIYW5kbGUgLVduby0uICBXZSBkb24ndCBjYXJlIGFib3V0IGV4dHJhIHdhcm5pbmdzLCBidXQKKyAgIyB3ZSBzaG91bGQgc3VwcHJlc3Mgb25lcyB0aGF0IHdlIGRvbid0IHdhbnQgdG8gc2VlLgorICBpZiAoJEFyZyA9fiAvXi1Xbm8tLykgeworICAgIHB1c2ggQENvbXBpbGVPcHRzLCAkQXJnOworICAgIG5leHQ7CisgIH0KKworICBpZiAoISgkQXJnID1+IC9eLS8pKSB7CisgICAgcHVzaCBARmlsZXMsICRBcmc7CisgICAgbmV4dDsKKyAgfQorfQorCisjIElmIHdlIGFyZSBvbiBPU1ggYW5kIGhhdmUgYW4gaW5zdGFsbGF0aW9uIHdoZXJlIHRoZQorIyBkZWZhdWx0IFNESyBpcyBpbmZlcnJlZCBieSB4Y3J1biB1c2UgeGNydW4gdG8gaW5mZXIKKyMgdGhlIFNESy4KK2lmIChub3QgJEhhc1NESyBhbmQgJFVzZVhDUlVOKSB7CisgIG15ICRzZGsgPSBgL3Vzci9iaW4veGNydW4gLS1zaG93LXNkay1wYXRoIC1zZGsgbWFjb3N4YDsKKyAgY2hvbXAgJHNkazsKKyAgcHVzaCBAQ29tcGlsZU9wdHMsICItaXN5c3Jvb3QiLCAkc2RrOworfQorCitpZiAoJEFjdGlvbiBlcSAnY29tcGlsZScgb3IgJEFjdGlvbiBlcSAnbGluaycpIHsKKyAgbXkgQEFyY2hzID0ga2V5cyAlQXJjaHNTZWVuOworICAjIFNraXAgdGhlIGZpbGUgaWYgd2UgZG9uJ3Qgc3VwcG9ydCB0aGUgYXJjaGl0ZWN0dXJlcyBzcGVjaWZpZWQuCisgIGV4aXQgMCBpZiAoJEhhZEFyY2ggJiYgc2NhbGFyKEBBcmNocykgPT0gMCk7CisKKyAgZm9yZWFjaCBteSAkZmlsZSAoQEZpbGVzKSB7CisgICAgIyBEZXRlcm1pbmUgdGhlIGxhbmd1YWdlIGZvciB0aGUgZmlsZS4KKyAgICBteSAkRmlsZUxhbmcgPSAkTGFuZzsKKworICAgIGlmICghZGVmaW5lZCgkRmlsZUxhbmcpKSB7CisgICAgICAjIEluZmVyIHRoZSBsYW5ndWFnZSBmcm9tIHRoZSBleHRlbnNpb24uCisgICAgICBpZiAoJGZpbGUgPX4gL1suXShbXi5dKykkLykgeworICAgICAgICAkRmlsZUxhbmcgPSAkTGFuZ01hcHskMX07CisgICAgICB9CisgICAgfQorCisgICAgIyBGaWxlTGFuZyBzdGlsbCBub3QgZGVmaW5lZD8gIFNraXAgdGhlIGZpbGUuCisgICAgbmV4dCBpZiAoIWRlZmluZWQgJEZpbGVMYW5nKTsKKworICAgICMgTGFuZ3VhZ2Ugbm90IGFjY2VwdGVkPworICAgIG5leHQgaWYgKCFkZWZpbmVkICRMYW5nc0FjY2VwdGVkeyRGaWxlTGFuZ30pOworCisgICAgbXkgQENtZEFyZ3M7CisgICAgbXkgQEFuYWx5emVBcmdzOworCisgICAgaWYgKCRGaWxlTGFuZyBuZSAndW5rbm93bicpIHsKKyAgICAgIHB1c2ggQENtZEFyZ3MsICcteCcsICRGaWxlTGFuZzsKKyAgICB9CisKKyAgICBpZiAoZGVmaW5lZCAkU3RvcmVNb2RlbCkgeworICAgICAgcHVzaCBAQW5hbHl6ZUFyZ3MsICItYW5hbHl6ZXItc3RvcmU9JFN0b3JlTW9kZWwiOworICAgIH0KKworICAgIGlmIChkZWZpbmVkICRDb25zdHJhaW50c01vZGVsKSB7CisgICAgICBwdXNoIEBBbmFseXplQXJncywgIi1hbmFseXplci1jb25zdHJhaW50cz0kQ29uc3RyYWludHNNb2RlbCI7CisgICAgfQorCisgICAgaWYgKGRlZmluZWQgJEludGVybmFsU3RhdHMpIHsKKyAgICAgIHB1c2ggQEFuYWx5emVBcmdzLCAiLWFuYWx5emVyLXN0YXRzIjsKKyAgICB9CisKKyAgICBpZiAoZGVmaW5lZCAkQW5hbHlzZXMpIHsKKyAgICAgIHB1c2ggQEFuYWx5emVBcmdzLCBzcGxpdCAnXHMrJywgJEFuYWx5c2VzOworICAgIH0KKworICAgIGlmIChkZWZpbmVkICRQbHVnaW5zKSB7CisgICAgICBwdXNoIEBBbmFseXplQXJncywgc3BsaXQgJ1xzKycsICRQbHVnaW5zOworICAgIH0KKworICAgIGlmIChkZWZpbmVkICRPdXRwdXRGb3JtYXQpIHsKKyAgICAgIHB1c2ggQEFuYWx5emVBcmdzLCAiLWFuYWx5emVyLW91dHB1dD0iIC4gJE91dHB1dEZvcm1hdDsKKyAgICAgIGlmICgkT3V0cHV0Rm9ybWF0ID1+IC9wbGlzdC8pIHsKKyAgICAgICAgIyBDaGFuZ2UgIk91dHB1dCIgdG8gYmUgYSBmaWxlLgorICAgICAgICBteSAoJGgsICRmKSA9IHRlbXBmaWxlKCJyZXBvcnQtWFhYWFhYIiwgU1VGRklYID0+ICIucGxpc3QiLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIERJUiA9PiAkSHRtbERpcik7CisgICAgICAgICRSZXN1bHRGaWxlID0gJGY7CisgICAgICAgICMgSWYgdGhlIEh0bWxEaXIgaXMgbm90IHNldCwgd2Ugc2hvdWxkIGNsZWFuIHVwIHRoZSBwbGlzdCBmaWxlcy4KKyAgICAgICAgaWYgKCFkZWZpbmVkICRIdG1sRGlyIHx8IC16ICRIdG1sRGlyKSB7CisgICAgICAgICAgJENsZWFudXBGaWxlID0gJGY7CisgICAgICAgIH0KKyAgICAgIH0KKyAgICB9CisgICAgaWYgKGRlZmluZWQgJENvbmZpZ09wdGlvbnMpIHsKKyAgICAgIHB1c2ggQEFuYWx5emVBcmdzLCBzcGxpdCAnXHMrJywgJENvbmZpZ09wdGlvbnM7CisgICAgfQorCisgICAgcHVzaCBAQ21kQXJncywgQENvbXBpbGVPcHRzOworICAgIHB1c2ggQENtZEFyZ3MsICRmaWxlOworCisgICAgaWYgKHNjYWxhciBAQXJjaHMpIHsKKyAgICAgIGZvcmVhY2ggbXkgJGFyY2ggKEBBcmNocykgeworICAgICAgICBteSBATmV3QXJnczsKKyAgICAgICAgcHVzaCBATmV3QXJncywgJy1hcmNoJywgJGFyY2g7CisgICAgICAgIHB1c2ggQE5ld0FyZ3MsIEBDbWRBcmdzOworICAgICAgICBBbmFseXplKCRDbGFuZywgXEBOZXdBcmdzLCBcQEFuYWx5emVBcmdzLCAkRmlsZUxhbmcsICRPdXRwdXQsCisgICAgICAgICAgICAgICAgJFZlcmJvc2UsICRIdG1sRGlyLCAkZmlsZSk7CisgICAgICB9CisgICAgfQorICAgIGVsc2UgeworICAgICAgQW5hbHl6ZSgkQ2xhbmcsIFxAQ21kQXJncywgXEBBbmFseXplQXJncywgJEZpbGVMYW5nLCAkT3V0cHV0LAorICAgICAgICAgICAgICAkVmVyYm9zZSwgJEh0bWxEaXIsICRmaWxlKTsKKyAgICB9CisgIH0KK30KKworZXhpdCgkU3RhdHVzID4+IDgpOwpkaWZmIC0tZ2l0IGEvdG9vbHMvc2Nhbi1idWlsZC9jY2MtYW5hbHl6ZXIuYmF0IGIvdG9vbHMvc2Nhbi1idWlsZC9jY2MtYW5hbHl6ZXIuYmF0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmZkZDM2ZjMKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9zY2FuLWJ1aWxkL2NjYy1hbmFseXplci5iYXQKQEAgLTAsMCArMSBAQAorcGVybCAtUyBjY2MtYW5hbHl6ZXIgJSoKZGlmZiAtLWdpdCBhL3Rvb2xzL3NjYW4tYnVpbGQvc2Nhbi1idWlsZCBiL3Rvb2xzL3NjYW4tYnVpbGQvc2Nhbi1idWlsZApuZXcgZmlsZSBtb2RlIDEwMDc1NQppbmRleCAwMDAwMDAwLi5kNTJkOGY1Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvc2Nhbi1idWlsZC9zY2FuLWJ1aWxkCkBAIC0wLDAgKzEsMTc0MiBAQAorIyEvdXNyL2Jpbi9lbnYgcGVybAorIworIyAgICAgICAgICAgICAgICAgICAgIFRoZSBMTFZNIENvbXBpbGVyIEluZnJhc3RydWN0dXJlCisjCisjIFRoaXMgZmlsZSBpcyBkaXN0cmlidXRlZCB1bmRlciB0aGUgVW5pdmVyc2l0eSBvZiBJbGxpbm9pcyBPcGVuIFNvdXJjZQorIyBMaWNlbnNlLiBTZWUgTElDRU5TRS5UWFQgZm9yIGRldGFpbHMuCisjCisjIz09PS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS09PT0jIworIworIyBBIHNjcmlwdCBkZXNpZ25lZCB0byB3cmFwIGEgYnVpbGQgc28gdGhhdCBhbGwgY2FsbHMgdG8gZ2NjIGFyZSBpbnRlcmNlcHRlZAorIyBhbmQgcGlwZWQgdG8gdGhlIHN0YXRpYyBhbmFseXplci4KKyMKKyMjPT09LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLT09PSMjCisKK3VzZSBzdHJpY3Q7Cit1c2Ugd2FybmluZ3M7Cit1c2UgRmluZEJpbiBxdygkUmVhbEJpbik7Cit1c2UgRGlnZXN0OjpNRDU7Cit1c2UgRmlsZTo6QmFzZW5hbWU7Cit1c2UgRmlsZTo6RmluZDsKK3VzZSBGaWxlOjpDb3B5IHF3KGNvcHkpOwordXNlIEZpbGU6OlBhdGggcXcoIHJtdHJlZSBta3BhdGggKTsKK3VzZSBUZXJtOjpBTlNJQ29sb3I7Cit1c2UgVGVybTo6QU5TSUNvbG9yIHF3KDpjb25zdGFudHMpOwordXNlIEN3ZCBxdy8gZ2V0Y3dkIGFic19wYXRoIC87Cit1c2UgU3lzOjpIb3N0bmFtZTsKKworbXkgJFZlcmJvc2UgPSAwOyAgICAgICAjIFZlcmJvc2Ugb3V0cHV0IGZyb20gdGhpcyBzY3JpcHQuCitteSAkUHJvZyA9ICJzY2FuLWJ1aWxkIjsKK215ICRCdWlsZE5hbWU7CitteSAkQnVpbGREYXRlOworCitteSAkVEVSTSA9ICRFTlZ7J1RFUk0nfTsKK215ICRVc2VDb2xvciA9IChkZWZpbmVkICRURVJNIGFuZCAkVEVSTSA9fiAneHRlcm0tLipjb2xvcicgYW5kIC10IFNURE9VVAorICAgICAgICAgICAgICAgIGFuZCBkZWZpbmVkICRFTlZ7J1NDQU5fQlVJTERfQ09MT1InfSk7CisKKyMgUG9ydGFiaWxpdHk6IGdldHB3dWlkIGlzIG5vdCBpbXBsZW1lbnRlZCBmb3IgV2luMzIgKHNlZSBQZXJsIGxhbmd1YWdlCisjIHJlZmVyZW5jZSwgcGVybHBvcnQpLCB1c2UgZ2V0bG9naW4gaW5zdGVhZC4KK215ICRVc2VyTmFtZSA9IEh0bWxFc2NhcGUoZ2V0bG9naW4oKSB8fCBnZXRwd3VpZCgkPCkgfHwgJ3Vua25vd24nKTsKK215ICRIb3N0TmFtZSA9IEh0bWxFc2NhcGUoaG9zdG5hbWUoKSB8fCAndW5rbm93bicpOworbXkgJEN1cnJlbnREaXIgPSBIdG1sRXNjYXBlKGdldGN3ZCgpKTsKK215ICRDdXJyZW50RGlyU3VmZml4ID0gYmFzZW5hbWUoJEN1cnJlbnREaXIpOworCitteSBAUGx1Z2luc1RvTG9hZDsKK215ICRDbWRBcmdzOworCitteSAkSHRtbFRpdGxlOworCitteSAkRGF0ZSA9IGxvY2FsdGltZSgpOworCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworIyBEaWFnbm9zdGljcworIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKworc3ViIERpYWcgeworICBpZiAoJFVzZUNvbG9yKSB7CisgICAgcHJpbnQgQk9MRCwgTUFHRU5UQSAiJFByb2c6IEBfIjsKKyAgICBwcmludCBSRVNFVDsKKyAgfQorICBlbHNlIHsKKyAgICBwcmludCAiJFByb2c6IEBfIjsKKyAgfQorfQorCitzdWIgRXJyb3JEaWFnIHsKKyAgaWYgKCRVc2VDb2xvcikgeworICAgIHByaW50IFNUREVSUiBCT0xELCBSRUQgIiRQcm9nOiAiOworICAgIHByaW50IFNUREVSUiBSRVNFVCwgUkVEIEBfOworICAgIHByaW50IFNUREVSUiBSRVNFVDsKKyAgfSBlbHNlIHsKKyAgICBwcmludCBTVERFUlIgIiRQcm9nOiBAXyI7CisgIH0KK30KKworc3ViIERpYWdDcmFzaGVzIHsKKyAgbXkgJERpciA9IHNoaWZ0OworICBEaWFnICgiVGhlIGFuYWx5emVyIGVuY291bnRlcmVkIHByb2JsZW1zIG9uIHNvbWUgc291cmNlIGZpbGVzLlxuIik7CisgIERpYWcgKCJQcmVwcm9jZXNzZWQgdmVyc2lvbnMgb2YgdGhlc2Ugc291cmNlcyB3ZXJlIGRlcG9zaXRlZCBpbiAnJERpci9mYWlsdXJlcycuXG4iKTsKKyAgRGlhZyAoIlBsZWFzZSBjb25zaWRlciBzdWJtaXR0aW5nIGEgYnVnIHJlcG9ydCB1c2luZyB0aGVzZSBmaWxlczpcbiIpOworICBEaWFnICgiICBodHRwOi8vY2xhbmctYW5hbHl6ZXIubGx2bS5vcmcvZmlsaW5nX2J1Z3MuaHRtbFxuIikKK30KKworc3ViIERpZURpYWcgeworICBpZiAoJFVzZUNvbG9yKSB7CisgICAgcHJpbnQgU1RERVJSIEJPTEQsIFJFRCAiJFByb2c6ICI7CisgICAgcHJpbnQgU1RERVJSIFJFU0VULCBSRUQgQF87CisgICAgcHJpbnQgU1RERVJSIFJFU0VUOworICB9CisgIGVsc2UgeworICAgIHByaW50IFNUREVSUiAiJFByb2c6ICIsIEBfOworICB9CisgIGV4aXQgMTsKK30KKworIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKyMgUHJpbnQgZGVmYXVsdCBjaGVja2VyIG5hbWVzCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworCitpZiAoZ3JlcCAvXi0taGVscC1jaGVja2VycyQvLCBAQVJHVikgeworICAgIG15IEBvcHRpb25zID0gcXgoJDAgLWgpOworICAgIGZvcmVhY2ggKEBvcHRpb25zKSB7CisgICAgbmV4dCB1bmxlc3MgL14gXCsvOworICAgIHMvXlxzKi8vOworICAgIG15ICgkc2lnbiwgJG5hbWUsIEB0ZXh0KSA9IHNwbGl0ICcgJywgJF87CisgICAgcHJpbnQgJG5hbWUsICQvIGlmICRzaWduIGVxICcrJzsKKyAgICB9CisgICAgZXhpdCAwOworfQorCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworIyBEZWNsYXJhdGlvbiBvZiBDbGFuZyBvcHRpb25zLiAgUG9wdWxhdGVkIGxhdGVyLgorIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKworbXkgJENsYW5nOworbXkgJENsYW5nU0I7CitteSAkQ2xhbmdDWFg7CitteSAkQ2xhbmdWZXJzaW9uOworCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworIyBHZXRIVE1MUnVuRGlyIC0gQ29uc3RydWN0IGFuIEhUTUwgZGlyZWN0b3J5IG5hbWUgZm9yIHRoZSBjdXJyZW50IHN1Yi1ydW4uCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworCitzdWIgR2V0SFRNTFJ1bkRpciB7CisgIGRpZSAiTm90IGVub3VnaCBhcmd1bWVudHMuIiBpZiAoQF8gPT0gMCk7CisgIG15ICREaXIgPSBzaGlmdCBAXzsKKyAgbXkgJFRtcE1vZGUgPSAwOworICBpZiAoIWRlZmluZWQgJERpcikgeworICAgICREaXIgPSAkRU5WeydUTVBESVInfSB8fCAkRU5WeydURU1QJ30gfHwgJEVOVnsnVE1QJ30gfHwgIi90bXAiOworICAgICRUbXBNb2RlID0gMTsKKyAgfQorCisgICMgQ2hvcCBvZmYgYW55IHRyYWlsaW5nICcvJyBjaGFyYWN0ZXJzLgorICB3aGlsZSAoJERpciA9fiAvXC8kLykgeyBjaG9wICREaXI7IH0KKworICAjIEdldCBjdXJyZW50IGRhdGUgYW5kIHRpbWUuCisgIG15IEBDdXJyZW50VGltZSA9IGxvY2FsdGltZSgpOworICBteSAkeWVhciAgPSAkQ3VycmVudFRpbWVbNV0gKyAxOTAwOworICBteSAkZGF5ICAgPSAkQ3VycmVudFRpbWVbM107CisgIG15ICRtb250aCA9ICRDdXJyZW50VGltZVs0XSArIDE7CisgIG15ICRob3VyID0gICRDdXJyZW50VGltZVsyXTsKKyAgbXkgJG1pbiA9ICAgJEN1cnJlbnRUaW1lWzFdOworICBteSAkc2VjID0gICAkQ3VycmVudFRpbWVbMF07CisKKyAgbXkgJFRpbWVTdHJpbmcgPSBzcHJpbnRmKCIlMDJkJTAyZCUwMmQiLCAkaG91ciwgJG1pbiwgJHNlYyk7CisgIG15ICREYXRlU3RyaW5nID0gc3ByaW50ZigiJWQtJTAyZC0lMDJkLSVzLSQkIiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICR5ZWFyLCAkbW9udGgsICRkYXksICRUaW1lU3RyaW5nKTsKKworICAjIERldGVybWluZSB0aGUgcnVuIG51bWJlci4KKyAgbXkgJFJ1bk51bWJlcjsKKworICBpZiAoLWQgJERpcikgeworICAgIGlmICghIC1yICREaXIpIHsKKyAgICAgIERpZURpYWcoImRpcmVjdG9yeSAnJERpcicgZXhpc3RzIGJ1dCBpcyBub3QgcmVhZGFibGUuXG4iKTsKKyAgICB9CisgICAgIyBJdGVyYXRlIG92ZXIgYWxsIGZpbGVzIGluIHRoZSBzcGVjaWZpZWQgZGlyZWN0b3J5LgorICAgIG15ICRtYXggPSAwOworICAgIG9wZW5kaXIoRElSLCAkRGlyKTsKKyAgICBteSBARklMRVMgPSBncmVwIHsgLWQgIiREaXIvJF8iIH0gcmVhZGRpcihESVIpOworICAgIGNsb3NlZGlyKERJUik7CisKKyAgICBmb3JlYWNoIG15ICRmIChARklMRVMpIHsKKyAgICAgICMgU3RyaXAgdGhlIHByZWZpeCAnJFByb2ctJyBpZiB3ZSBhcmUgZHVtcGluZyBmaWxlcyB0byAvdG1wLgorICAgICAgaWYgKCRUbXBNb2RlKSB7CisgICAgICAgIG5leHQgaWYgKCEoJGYgPX4gL14kUHJvZy0oLispLykpOworICAgICAgICAkZiA9ICQxOworICAgICAgfQorCisgICAgICBteSBAeCA9IHNwbGl0Ly0vLCAkZjsKKyAgICAgIG5leHQgaWYgKHNjYWxhcihAeCkgIT0gNCk7CisgICAgICBuZXh0IGlmICgkeFswXSAhPSAkeWVhcik7CisgICAgICBuZXh0IGlmICgkeFsxXSAhPSAkbW9udGgpOworICAgICAgbmV4dCBpZiAoJHhbMl0gIT0gJGRheSk7CisgICAgICBuZXh0IGlmICgkeFszXSAhPSAkVGltZVN0cmluZyk7CisgICAgICBuZXh0IGlmICgkeFs0XSAhPSAkJCk7CisKKyAgICAgIGlmICgkeFs1XSA+ICRtYXgpIHsKKyAgICAgICAgJG1heCA9ICR4WzVdOworICAgICAgfQorICAgIH0KKworICAgICRSdW5OdW1iZXIgPSAkbWF4ICsgMTsKKyAgfQorICBlbHNlIHsKKworICAgIGlmICgteCAkRGlyKSB7CisgICAgICBEaWVEaWFnKCInJERpcicgZXhpc3RzIGJ1dCBpcyBub3QgYSBkaXJlY3RvcnkuXG4iKTsKKyAgICB9CisKKyAgICBpZiAoJFRtcE1vZGUpIHsKKyAgICAgIERpZURpYWcoIlRoZSBkaXJlY3RvcnkgJy90bXAnIGRvZXMgbm90IGV4aXN0IG9yIGNhbm5vdCBiZSBhY2Nlc3NlZC5cbiIpOworICAgIH0KKworICAgICMgJERpciBkb2VzIG5vdCBleGlzdC4gIEl0IHdpbGwgYmUgYXV0b21hdGljYWxseSBjcmVhdGVkIGJ5IHRoZQorICAgICMgY2xhbmcgZHJpdmVyLiAgU2V0IHRoZSBydW4gbnVtYmVyIHRvIDEuCisKKyAgICAkUnVuTnVtYmVyID0gMTsKKyAgfQorCisgIGRpZSAiUnVuTnVtYmVyIG11c3QgYmUgZGVmaW5lZCEiIGlmICghZGVmaW5lZCAkUnVuTnVtYmVyKTsKKworICAjIEFwcGVuZCB0aGUgcnVuIG51bWJlci4KKyAgbXkgJE5ld0RpcjsKKyAgaWYgKCRUbXBNb2RlKSB7CisgICAgJE5ld0RpciA9ICIkRGlyLyRQcm9nLSREYXRlU3RyaW5nLSRSdW5OdW1iZXIiOworICB9CisgIGVsc2UgeworICAgICROZXdEaXIgPSAiJERpci8kRGF0ZVN0cmluZy0kUnVuTnVtYmVyIjsKKyAgfQorCisgICMgTWFrZSBzdXJlIHRoYXQgdGhlIGRpcmVjdG9yeSBkb2VzIG5vdCBleGlzdCBpbiBvcmRlciB0byBhdm9pZCBoaWphY2suCisgIGlmICgtZSAkTmV3RGlyKSB7CisgICAgICBEaWVEaWFnKCJUaGUgZGlyZWN0b3J5ICckTmV3RGlyJyBhbHJlYWR5IGV4aXN0cy5cbiIpOworICB9CisKKyAgbWtwYXRoKCROZXdEaXIpOworICByZXR1cm4gJE5ld0RpcjsKK30KKworc3ViIFNldEh0bWxFbnYgeworCisgIGRpZSAiV3JvbmcgbnVtYmVyIG9mIGFyZ3VtZW50cy4iIGlmIChzY2FsYXIoQF8pICE9IDIpOworCisgIG15ICRBcmdzID0gc2hpZnQ7CisgIG15ICREaXIgPSBzaGlmdDsKKworICBkaWUgIk5vIGJ1aWxkIGNvbW1hbmQuIiBpZiAoc2NhbGFyKEAkQXJncykgPT0gMCk7CisKKyAgbXkgJENtZCA9ICQkQXJnc1swXTsKKworICBpZiAoJENtZCA9fiAvY29uZmlndXJlLyB8fCAkQ21kID1+IC9hdXRvZ2VuLykgeworICAgIHJldHVybjsKKyAgfQorCisgIGlmICgkVmVyYm9zZSkgeworICAgIERpYWcoIkVtaXR0aW5nIHJlcG9ydHMgZm9yIHRoaXMgcnVuIHRvICckRGlyJy5cbiIpOworICB9CisKKyAgJEVOVnsnQ0NDX0FOQUxZWkVSX0hUTUwnfSA9ICREaXI7Cit9CisKKyMjLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSMjCisjIENvbXB1dGVEaWdlc3QgLSBDb21wdXRlIGEgZGlnZXN0IG9mIHRoZSBzcGVjaWZpZWQgZmlsZS4KKyMjLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSMjCisKK3N1YiBDb21wdXRlRGlnZXN0IHsKKyAgbXkgJEZOYW1lID0gc2hpZnQ7CisgIERpZURpYWcoIkNhbm5vdCByZWFkICRGTmFtZSB0byBjb21wdXRlIERpZ2VzdC5cbiIpIGlmICghIC1yICRGTmFtZSk7CisKKyAgIyBVc2UgRGlnZXN0OjpNRDUuICBXZSBkb24ndCBoYXZlIHRvIGJlIGNyeXB0b2dyYXBoaWNhbGx5IHNlY3VyZS4gIFdlJ3JlCisgICMganVzdCBsb29raW5nIGZvciBkdXBsaWNhdGUgZmlsZXMgdGhhdCBjb21lIGZyb20gYSBub24tbWFsaWNpb3VzIHNvdXJjZS4KKyAgIyBXZSB1c2UgRGlnZXN0OjpNRDUgYmVjYXVzZSBpdCBpcyBhIHN0YW5kYXJkIFBlcmwgbW9kdWxlIHRoYXQgc2hvdWxkCisgICMgY29tZSBidW5kbGVkIG9uIG1vc3Qgc3lzdGVtcy4KKyAgb3BlbihGSUxFLCAkRk5hbWUpIG9yIERpZURpYWcoIkNhbm5vdCBvcGVuICRGTmFtZSB3aGVuIGNvbXB1dGluZyBEaWdlc3QuXG4iKTsKKyAgYmlubW9kZSBGSUxFOworICBteSAkUmVzdWx0ID0gRGlnZXN0OjpNRDUtPm5ldy0+YWRkZmlsZSgqRklMRSktPmhleGRpZ2VzdDsKKyAgY2xvc2UoRklMRSk7CisKKyAgIyBSZXR1cm4gdGhlIGRpZ2VzdC4KKyAgcmV0dXJuICRSZXN1bHQ7Cit9CisKKyMjLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSMjCisjICBVcGRhdGVQcmVmaXggLSBDb21wdXRlIHRoZSBjb21tb24gcHJlZml4IG9mIGZpbGVzLgorIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKworbXkgJFByZWZpeDsKKworc3ViIFVwZGF0ZVByZWZpeCB7CisgIG15ICR4ID0gc2hpZnQ7CisgIG15ICR5ID0gYmFzZW5hbWUoJHgpOworICAkeCA9fiBzL1xRJHlcRSQvLzsKKworICBpZiAoIWRlZmluZWQgJFByZWZpeCkgeworICAgICRQcmVmaXggPSAkeDsKKyAgICByZXR1cm47CisgIH0KKworICBjaG9wICRQcmVmaXggd2hpbGUgKCEoJHggPX4gL15cUSRQcmVmaXgvKSk7Cit9CisKK3N1YiBHZXRQcmVmaXggeworICByZXR1cm4gJFByZWZpeDsKK30KKworIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKyMgIFVwZGF0ZUluRmlsZVBhdGggLSBVcGRhdGUgdGhlIHBhdGggaW4gdGhlIHJlcG9ydCBmaWxlLgorIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKworc3ViIFVwZGF0ZUluRmlsZVBhdGggeworICBteSAkZm5hbWUgPSBzaGlmdDsKKyAgbXkgJHJlZ2V4ID0gc2hpZnQ7CisgIG15ICRuZXd0ZXh0ID0gc2hpZnQ7CisKKyAgb3BlbiAoUklOLCAkZm5hbWUpIG9yIGRpZSAiY2Fubm90IG9wZW4gJGZuYW1lIjsKKyAgb3BlbiAoUk9VVCwgIj4iLCAiJGZuYW1lLnRtcCIpIG9yIGRpZSAiY2Fubm90IG9wZW4gJGZuYW1lLnRtcCI7CisKKyAgd2hpbGUgKDxSSU4+KSB7CisgICAgcy8kcmVnZXgvJG5ld3RleHQvOworICAgIHByaW50IFJPVVQgJF87CisgIH0KKworICBjbG9zZSAoUk9VVCk7CisgIGNsb3NlIChSSU4pOworICByZW5hbWUoIiRmbmFtZS50bXAiLCAkZm5hbWUpCit9CisKKyMjLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSMjCisjIEFkZFN0YXRMaW5lIC0gRGVjb2RlIGFuZCBpbnNlcnQgYSBzdGF0aXN0aWNzIGxpbmUgaW50byB0aGUgZGF0YWJhc2UuCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworCitzdWIgQWRkU3RhdExpbmUgeworICBteSAkTGluZSAgPSBzaGlmdDsKKyAgbXkgJFN0YXRzID0gc2hpZnQ7CisgIG15ICRGaWxlICA9IHNoaWZ0OworCisgIHByaW50ICRMaW5lIC4gIlxuIjsKKworICBteSAkUmVnZXggPSBxci8oLio/KVwgLT5cIFRvdGFsXCBDRkdCbG9ja3M6XCAoXGQrKVwgXHxcIFVucmVhY2hhYmxlCisgICAgICBcIENGR0Jsb2NrczpcIChcZCspXCBcfFwgRXhoYXVzdGVkXCBCbG9jazpcICh5ZXN8bm8pXCBcfFwgRW1wdHlcIFdvcmtMaXN0OgorICAgICAgXCAoeWVzfG5vKS94OworCisgIGlmICgkTGluZSAhfiAkUmVnZXgpIHsKKyAgICByZXR1cm47CisgIH0KKworICAjIENyZWF0ZSBhIGhhc2ggb2YgdGhlIGludGVyZXN0aW5nIGZpZWxkcworICBteSAkUm93ID0geworICAgIEZpbGVuYW1lICAgID0+ICRGaWxlLAorICAgIEZ1bmN0aW9uICAgID0+ICQxLAorICAgIFRvdGFsICAgICAgID0+ICQyLAorICAgIFVucmVhY2hhYmxlID0+ICQzLAorICAgIEFib3J0ZWQgICAgID0+ICQ0LAorICAgIEVtcHR5ICAgICAgID0+ICQ1CisgIH07CisKKyAgIyBBZGQgdGhlbSB0byB0aGUgc3RhdHMgYXJyYXkKKyAgcHVzaCBAJFN0YXRzLCAkUm93OworfQorCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworIyBTY2FuRmlsZSAtIFNjYW4gYSByZXBvcnQgZmlsZSBmb3IgdmFyaW91cyBpZGVudGlmeWluZyBhdHRyaWJ1dGVzLgorIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKworIyBTb21ldGltZXMgYSBzb3VyY2UgZmlsZSBpcyBzY2FubmVkIG1vcmUgdGhhbiBvbmNlLCBhbmQgdGh1cyBwcm9kdWNlcworIyBtdWx0aXBsZSBlcnJvciByZXBvcnRzLiAgV2UgdXNlIGEgY2FjaGUgdG8gc29sdmUgdGhpcyBwcm9ibGVtLgorCitteSAlQWxyZWFkeVNjYW5uZWQ7CisKK3N1YiBTY2FuRmlsZSB7CisKKyAgbXkgJEluZGV4ID0gc2hpZnQ7CisgIG15ICREaXIgPSBzaGlmdDsKKyAgbXkgJEZOYW1lID0gc2hpZnQ7CisgIG15ICRTdGF0cyA9IHNoaWZ0OworCisgICMgQ29tcHV0ZSBhIGRpZ2VzdCBmb3IgdGhlIHJlcG9ydCBmaWxlLiAgRGV0ZXJtaW5lIGlmIHdlIGhhdmUgYWxyZWFkeQorICAjIHNjYW5uZWQgYSBmaWxlIHRoYXQgbG9va3MganVzdCBsaWtlIGl0LgorCisgIG15ICRkaWdlc3QgPSBDb21wdXRlRGlnZXN0KCIkRGlyLyRGTmFtZSIpOworCisgIGlmIChkZWZpbmVkICRBbHJlYWR5U2Nhbm5lZHskZGlnZXN0fSkgeworICAgICMgUmVkdW5kYW50IGZpbGUuICBSZW1vdmUgaXQuCisgICAgdW5saW5rKCIkRGlyLyRGTmFtZSIpOworICAgIHJldHVybjsKKyAgfQorCisgICRBbHJlYWR5U2Nhbm5lZHskZGlnZXN0fSA9IDE7CisKKyAgIyBBdCB0aGlzIHBvaW50IHRoZSByZXBvcnQgZmlsZSBpcyBub3Qgd29ybGQgcmVhZGFibGUuICBNYWtlIGl0IGhhcHBlbi4KKyAgY2htb2QoMDY0NCwgIiREaXIvJEZOYW1lIik7CisKKyAgIyBTY2FuIHRoZSByZXBvcnQgZmlsZSBmb3IgdGFncy4KKyAgb3BlbihJTiwgIiREaXIvJEZOYW1lIikgb3IgRGllRGlhZygiQ2Fubm90IG9wZW4gJyREaXIvJEZOYW1lJ1xuIik7CisKKyAgbXkgJEJ1Z1R5cGUgICAgICAgID0gIiI7CisgIG15ICRCdWdGaWxlICAgICAgICA9ICIiOworICBteSAkQnVnRnVuY3Rpb24gICAgPSAiIjsKKyAgbXkgJEJ1Z0NhdGVnb3J5ICAgID0gIiI7CisgIG15ICRCdWdEZXNjcmlwdGlvbiA9ICIiOworICBteSAkQnVnUGF0aExlbmd0aCAgPSAxOworICBteSAkQnVnTGluZSAgICAgICAgPSAwOworCisgIHdoaWxlICg8SU4+KSB7CisgICAgbGFzdCBpZiAoLzwhLS0gQlVHTUVUQUVORCAtLT4vKTsKKworICAgIGlmICgvPCEtLSBCVUdUWVBFICguKikgLS0+JC8pIHsKKyAgICAgICRCdWdUeXBlID0gJDE7CisgICAgfQorICAgIGVsc2lmICgvPCEtLSBCVUdGSUxFICguKikgLS0+JC8pIHsKKyAgICAgICRCdWdGaWxlID0gYWJzX3BhdGgoJDEpOworICAgICAgaWYgKCFkZWZpbmVkICRCdWdGaWxlKSB7CisgICAgICAgICAjIFRoZSBmaWxlIG5vIGxvbmdlciBleGlzdHM6IHVzZSB0aGUgb3JpZ2luYWwgcGF0aC4KKyAgICAgICAgICRCdWdGaWxlID0gJDE7CisgICAgICB9CisgICAgICBVcGRhdGVQcmVmaXgoJEJ1Z0ZpbGUpOworICAgIH0KKyAgICBlbHNpZiAoLzwhLS0gQlVHUEFUSExFTkdUSCAoLiopIC0tPiQvKSB7CisgICAgICAkQnVnUGF0aExlbmd0aCA9ICQxOworICAgIH0KKyAgICBlbHNpZiAoLzwhLS0gQlVHTElORSAoLiopIC0tPiQvKSB7CisgICAgICAkQnVnTGluZSA9ICQxOworICAgIH0KKyAgICBlbHNpZiAoLzwhLS0gQlVHQ0FURUdPUlkgKC4qKSAtLT4kLykgeworICAgICAgJEJ1Z0NhdGVnb3J5ID0gJDE7CisgICAgfQorICAgIGVsc2lmICgvPCEtLSBCVUdERVNDICguKikgLS0+JC8pIHsKKyAgICAgICRCdWdEZXNjcmlwdGlvbiA9ICQxOworICAgIH0KKyAgICBlbHNpZiAoLzwhLS0gRlVOQ1RJT05OQU1FICguKikgLS0+JC8pIHsKKyAgICAgICRCdWdGdW5jdGlvbiA9ICQxOworICAgIH0KKworICB9CisKKworICBjbG9zZShJTik7CisKKyAgaWYgKCFkZWZpbmVkICRCdWdDYXRlZ29yeSkgeworICAgICRCdWdDYXRlZ29yeSA9ICJPdGhlciI7CisgIH0KKworICAjIERvbid0IGFkZCBpbnRlcm5hbCBzdGF0aXN0aWNzIHRvIHRoZSBidWcgcmVwb3J0cworICBpZiAoJEJ1Z0NhdGVnb3J5ID1+IC9zdGF0aXN0aWNzL2kpIHsKKyAgICBBZGRTdGF0TGluZSgkQnVnRGVzY3JpcHRpb24sICRTdGF0cywgJEJ1Z0ZpbGUpOworICAgIHJldHVybjsKKyAgfQorCisgIHB1c2ggQCRJbmRleCxbICRGTmFtZSwgJEJ1Z0NhdGVnb3J5LCAkQnVnVHlwZSwgJEJ1Z0ZpbGUsICRCdWdGdW5jdGlvbiwgJEJ1Z0xpbmUsCisgICAgICAgICAgICAgICAgICRCdWdQYXRoTGVuZ3RoIF07Cit9CisKKyMjLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSMjCisjIENvcHlGaWxlcyAtIENvcHkgcmVzb3VyY2UgZmlsZXMgdG8gdGFyZ2V0IGRpcmVjdG9yeS4KKyMjLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSMjCisKK3N1YiBDb3B5RmlsZXMgeworCisgIG15ICREaXIgPSBzaGlmdDsKKworICBteSAkSlMgPSBDd2Q6OnJlYWxwYXRoKCIkUmVhbEJpbi9zb3J0dGFibGUuanMiKTsKKworICBEaWVEaWFnKCJDYW5ub3QgZmluZCAnc29ydHRhYmxlLmpzJy5cbiIpCisgICAgaWYgKCEgLXIgJEpTKTsKKworICBjb3B5KCRKUywgIiREaXIiKTsKKworICBEaWVEaWFnKCJDb3VsZCBub3QgY29weSAnc29ydHRhYmxlLmpzJyB0byAnJERpcicuXG4iKQorICAgIGlmICghIC1yICIkRGlyL3NvcnR0YWJsZS5qcyIpOworCisgIG15ICRDU1MgPSBDd2Q6OnJlYWxwYXRoKCIkUmVhbEJpbi9zY2Fudmlldy5jc3MiKTsKKworICBEaWVEaWFnKCJDYW5ub3QgZmluZCAnc2NhbnZpZXcuY3NzJy5cbiIpCisgICAgaWYgKCEgLXIgJENTUyk7CisKKyAgY29weSgkQ1NTLCAiJERpciIpOworCisgIERpZURpYWcoIkNvdWxkIG5vdCBjb3B5ICdzY2Fudmlldy5jc3MnIHRvICckRGlyJy5cbiIpCisgICAgaWYgKCEgLXIgJENTUyk7Cit9CisKKyMjLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSMjCisjIENhbGNTdGF0cyAtIENhbGN1bGF0ZXMgdmlzaXRhdGlvbiBzdGF0aXN0aWNzIGFuZCByZXR1cm5zIHRoZSBzdHJpbmcuCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworCitzdWIgQ2FsY1N0YXRzIHsKKyAgbXkgJFN0YXRzID0gc2hpZnQ7CisKKyAgbXkgJFRvdGFsQmxvY2tzID0gMDsKKyAgbXkgJFVucmVhY2hlZEJsb2NrcyA9IDA7CisgIG15ICRUb3RhbEZ1bmN0aW9ucyA9IHNjYWxhcihAJFN0YXRzKTsKKyAgbXkgJEJsb2NrQWJvcnRlZCA9IDA7CisgIG15ICRXb3JrTGlzdEFib3J0ZWQgPSAwOworICBteSAkQWJvcnRlZCA9IDA7CisKKyAgIyBDYWxjdWxhdGUgdGhlIHVuaXF1ZSBmaWxlcworICBteSAkRmlsZXNIYXNoID0ge307CisKKyAgZm9yZWFjaCBteSAkUm93IChAJFN0YXRzKSB7CisgICAgJEZpbGVzSGFzaC0+eyRSb3ctPntGaWxlbmFtZX19ID0gMTsKKyAgICAkVG90YWxCbG9ja3MgKz0gJFJvdy0+e1RvdGFsfTsKKyAgICAkVW5yZWFjaGVkQmxvY2tzICs9ICRSb3ctPntVbnJlYWNoYWJsZX07CisgICAgJEJsb2NrQWJvcnRlZCsrIGlmICRSb3ctPntBYm9ydGVkfSBlcSAneWVzJzsKKyAgICAkV29ya0xpc3RBYm9ydGVkKysgaWYgJFJvdy0+e0VtcHR5fSBlcSAnbm8nOworICAgICRBYm9ydGVkKysgaWYgJFJvdy0+e0Fib3J0ZWR9IGVxICd5ZXMnIHx8ICRSb3ctPntFbXB0eX0gZXEgJ25vJzsKKyAgfQorCisgIG15ICRUb3RhbEZpbGVzID0gc2NhbGFyKGtleXMoJSRGaWxlc0hhc2gpKTsKKworICAjIENhbGN1bGF0aW9ucworICBteSAkUGVyY2VudEFib3J0ZWQgPSBzcHJpbnRmKCIlLjJmIiwgJEFib3J0ZWQgLyAkVG90YWxGdW5jdGlvbnMgKiAxMDApOworICBteSAkUGVyY2VudEJsb2NrQWJvcnRlZCA9IHNwcmludGYoIiUuMmYiLCAkQmxvY2tBYm9ydGVkIC8gJFRvdGFsRnVuY3Rpb25zCisgICAgICAqIDEwMCk7CisgIG15ICRQZXJjZW50V29ya0xpc3RBYm9ydGVkID0gc3ByaW50ZigiJS4yZiIsICRXb3JrTGlzdEFib3J0ZWQgLworICAgICAgJFRvdGFsRnVuY3Rpb25zICogMTAwKTsKKyAgbXkgJFBlcmNlbnRCbG9ja3NVbnJlYWNoZWQgPSBzcHJpbnRmKCIlLjJmIiwgJFVucmVhY2hlZEJsb2NrcyAvICRUb3RhbEJsb2NrcworICAgICAgKiAxMDApOworCisgIG15ICRTdGF0c1N0cmluZyA9ICJBbmFseXplZCAkVG90YWxCbG9ja3MgYmxvY2tzIGluICRUb3RhbEZ1bmN0aW9ucyBmdW5jdGlvbnMiCisgICAgLiAiIGluICRUb3RhbEZpbGVzIGZpbGVzXG4iCisgICAgLiAiJEFib3J0ZWQgZnVuY3Rpb25zIGFib3J0ZWQgZWFybHkgKCRQZXJjZW50QWJvcnRlZCUpXG4iCisgICAgLiAiJEJsb2NrQWJvcnRlZCBoYWQgYWJvcnRlZCBibG9ja3MgKCRQZXJjZW50QmxvY2tBYm9ydGVkJSlcbiIKKyAgICAuICIkV29ya0xpc3RBYm9ydGVkIGhhZCB1bmZpbmlzaGVkIHdvcmtsaXN0cyAoJFBlcmNlbnRXb3JrTGlzdEFib3J0ZWQlKVxuIgorICAgIC4gIiRVbnJlYWNoZWRCbG9ja3MgYmxvY2tzIHdlcmUgbmV2ZXIgcmVhY2hlZCAoJFBlcmNlbnRCbG9ja3NVbnJlYWNoZWQlKVxuIjsKKworICByZXR1cm4gJFN0YXRzU3RyaW5nOworfQorCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworIyBQb3N0cHJvY2VzcyAtIFBvc3Rwcm9jZXNzIHRoZSByZXN1bHRzIG9mIGFuIGFuYWx5c2lzIHNjYW4uCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworCitteSBAZmlsZXNGb3VuZDsKK215ICRiYXNlRGlyOworc3ViIEZpbGVXYW50ZWQgeworICAgIG15ICRiYXNlRGlyUmVnRXggPSBxdW90ZW1ldGEgJGJhc2VEaXI7CisgICAgbXkgJGZpbGUgPSAkRmlsZTo6RmluZDo6bmFtZTsKKworICAgICMgVGhlIG5hbWUgb2YgdGhlIGZpbGUgaXMgZ2VuZXJhdGVkIGJ5IGNsYW5nIGJpbmFyeSAoSFRNTERpYWdub3N0aWNzLmNwcCkKKyAgICBpZiAoJGZpbGUgPX4gL3JlcG9ydC0uKlwuaHRtbCQvKSB7CisgICAgICAgbXkgJHJlbGF0aXZlX2ZpbGUgPSAkZmlsZTsKKyAgICAgICAkcmVsYXRpdmVfZmlsZSA9fiBzLyRiYXNlRGlyUmVnRXgvL2c7CisgICAgICAgcHVzaCBAZmlsZXNGb3VuZCwgJHJlbGF0aXZlX2ZpbGU7CisgICAgfQorfQorCitzdWIgUG9zdHByb2Nlc3MgeworCisgIG15ICREaXIgICAgICAgICAgID0gc2hpZnQ7CisgIG15ICRCYXNlRGlyICAgICAgID0gc2hpZnQ7CisgIG15ICRBbmFseXplclN0YXRzID0gc2hpZnQ7CisgIG15ICRLZWVwRW1wdHkgICAgID0gc2hpZnQ7CisKKyAgZGllICJObyBkaXJlY3Rvcnkgc3BlY2lmaWVkLiIgaWYgKCFkZWZpbmVkICREaXIpOworCisgIGlmICghIC1kICREaXIpIHsKKyAgICBEaWFnKCJObyBidWdzIGZvdW5kLlxuIik7CisgICAgcmV0dXJuIDA7CisgIH0KKworICAkYmFzZURpciA9ICREaXIgLiAiLyI7CisgIGZpbmQoeyB3YW50ZWQgPT4gXCZGaWxlV2FudGVkLCBmb2xsb3cgPT4gMH0sICREaXIpOworCisgIGlmIChzY2FsYXIoQGZpbGVzRm91bmQpID09IDAgYW5kICEgLWUgIiREaXIvZmFpbHVyZXMiKSB7CisgICAgaWYgKCEgJEtlZXBFbXB0eSkgeworICAgICAgRGlhZygiUmVtb3ZpbmcgZGlyZWN0b3J5ICckRGlyJyBiZWNhdXNlIGl0IGNvbnRhaW5zIG5vIHJlcG9ydHMuXG4iKTsKKyAgICAgIHJtdHJlZSgkRGlyKSBvciBkaWUgIkNhbm5vdCBybXRyZWUgJyREaXInIDogJCEiOworICAgIH0KKyAgICBEaWFnKCJObyBidWdzIGZvdW5kLlxuIik7CisgICAgcmV0dXJuIDA7CisgIH0KKworICAjIFNjYW4gZWFjaCByZXBvcnQgZmlsZSBhbmQgYnVpbGQgYW4gaW5kZXguCisgIG15IEBJbmRleDsKKyAgbXkgQFN0YXRzOworICBmb3JlYWNoIG15ICRmaWxlIChAZmlsZXNGb3VuZCkgeyBTY2FuRmlsZShcQEluZGV4LCAkRGlyLCAkZmlsZSwgXEBTdGF0cyk7IH0KKworICAjIFNjYW4gdGhlIGZhaWx1cmVzIGRpcmVjdG9yeSBhbmQgdXNlIHRoZSBpbmZvcm1hdGlvbiBpbiB0aGUgLmluZm8gZmlsZXMKKyAgIyB0byB1cGRhdGUgdGhlIGNvbW1vbiBwcmVmaXggZGlyZWN0b3J5LgorICBteSBAZmFpbHVyZXM7CisgIG15IEBhdHRyaWJ1dGVzX2lnbm9yZWQ7CisgIGlmICgtZCAiJERpci9mYWlsdXJlcyIpIHsKKyAgICBvcGVuZGlyKERJUiwgIiREaXIvZmFpbHVyZXMiKTsKKyAgICBAZmFpbHVyZXMgPSBncmVwIHsgL1suXWluZm8udHh0JC8gJiYgIS9hdHRyaWJ1dGVfaWdub3JlZC87IH0gcmVhZGRpcihESVIpOworICAgIGNsb3NlZGlyKERJUik7CisgICAgb3BlbmRpcihESVIsICIkRGlyL2ZhaWx1cmVzIik7CisgICAgQGF0dHJpYnV0ZXNfaWdub3JlZCA9IGdyZXAgeyAvXmF0dHJpYnV0ZV9pZ25vcmVkLzsgfSByZWFkZGlyKERJUik7CisgICAgY2xvc2VkaXIoRElSKTsKKyAgICBmb3JlYWNoIG15ICRmaWxlIChAZmFpbHVyZXMpIHsKKyAgICAgIG9wZW4gSU4sICIkRGlyL2ZhaWx1cmVzLyRmaWxlIiBvciBEaWVEaWFnKCJjYW5ub3Qgb3BlbiAkZmlsZVxuIik7CisgICAgICBteSAkUGF0aCA9IDxJTj47CisgICAgICBpZiAoZGVmaW5lZCAkUGF0aCkgeyBVcGRhdGVQcmVmaXgoJFBhdGgpOyB9CisgICAgICBjbG9zZSBJTjsKKyAgICB9CisgIH0KKworICAjIEdlbmVyYXRlIGFuIGluZGV4Lmh0bWwgZmlsZS4KKyAgbXkgJEZOYW1lID0gIiREaXIvaW5kZXguaHRtbCI7CisgIG9wZW4oT1VULCAiPiIsICRGTmFtZSkgb3IgRGllRGlhZygiQ2Fubm90IGNyZWF0ZSBmaWxlICckRk5hbWUnXG4iKTsKKworICAjIFByaW50IG91dCB0aGUgaGVhZGVyLgorCitwcmludCBPVVQgPDxFTkRURVhUOworPGh0bWw+Cis8aGVhZD4KKzx0aXRsZT4ke0h0bWxUaXRsZX08L3RpdGxlPgorPGxpbmsgdHlwZT0idGV4dC9jc3MiIHJlbD0ic3R5bGVzaGVldCIgaHJlZj0ic2NhbnZpZXcuY3NzIi8+Cis8c2NyaXB0IHNyYz0ic29ydHRhYmxlLmpzIj48L3NjcmlwdD4KKzxzY3JpcHQgbGFuZ3VhZ2U9J2phdmFzY3JpcHQnIHR5cGU9InRleHQvamF2YXNjcmlwdCI+CitmdW5jdGlvbiBTZXREaXNwbGF5KFJvd0NsYXNzLCBEaXNwbGF5VmFsKQoreworICB2YXIgUm93cyA9IGRvY3VtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJ0ciIpOworICBmb3IgKCB2YXIgaSA9IDAgOyBpIDwgUm93cy5sZW5ndGg7ICsraSApIHsKKyAgICBpZiAoUm93c1tpXS5jbGFzc05hbWUgPT0gUm93Q2xhc3MpIHsKKyAgICAgIFJvd3NbaV0uc3R5bGUuZGlzcGxheSA9IERpc3BsYXlWYWw7CisgICAgfQorICB9Cit9CisKK2Z1bmN0aW9uIENvcHlDaGVja2VkU3RhdGVUb0NoZWNrQnV0dG9ucyhTdW1tYXJ5Q2hlY2tCdXR0b24pIHsKKyAgdmFyIElucHV0cyA9IGRvY3VtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKCJpbnB1dCIpOworICBmb3IgKCB2YXIgaSA9IDAgOyBpIDwgSW5wdXRzLmxlbmd0aDsgKytpICkgeworICAgIGlmIChJbnB1dHNbaV0udHlwZSA9PSAiY2hlY2tib3giKSB7CisgICAgICBpZihJbnB1dHNbaV0gIT0gU3VtbWFyeUNoZWNrQnV0dG9uKSB7CisgICAgICAgIElucHV0c1tpXS5jaGVja2VkID0gU3VtbWFyeUNoZWNrQnV0dG9uLmNoZWNrZWQ7CisgICAgICAgIElucHV0c1tpXS5vbmNsaWNrKCk7CisgICAgICB9CisgICAgfQorICB9Cit9CisKK2Z1bmN0aW9uIHJldHVybk9iakJ5SWQoIGlkICkgeworICAgIGlmIChkb2N1bWVudC5nZXRFbGVtZW50QnlJZCkKKyAgICAgICAgdmFyIHJldHVyblZhciA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKGlkKTsKKyAgICBlbHNlIGlmIChkb2N1bWVudC5hbGwpCisgICAgICAgIHZhciByZXR1cm5WYXIgPSBkb2N1bWVudC5hbGxbaWRdOworICAgIGVsc2UgaWYgKGRvY3VtZW50LmxheWVycykKKyAgICAgICAgdmFyIHJldHVyblZhciA9IGRvY3VtZW50LmxheWVyc1tpZF07CisgICAgcmV0dXJuIHJldHVyblZhcjsKK30KKwordmFyIE51bVVuY2hlY2tlZCA9IDA7CisKK2Z1bmN0aW9uIFRvZ2dsZURpc3BsYXkoQ2hlY2tCdXR0b24sIENsYXNzTmFtZSkgeworICBpZiAoQ2hlY2tCdXR0b24uY2hlY2tlZCkgeworICAgIFNldERpc3BsYXkoQ2xhc3NOYW1lLCAiIik7CisgICAgaWYgKC0tTnVtVW5jaGVja2VkID09IDApIHsKKyAgICAgIHJldHVybk9iakJ5SWQoIkFsbEJ1Z3NDaGVjayIpLmNoZWNrZWQgPSB0cnVlOworICAgIH0KKyAgfQorICBlbHNlIHsKKyAgICBTZXREaXNwbGF5KENsYXNzTmFtZSwgIm5vbmUiKTsKKyAgICBOdW1VbmNoZWNrZWQrKzsKKyAgICByZXR1cm5PYmpCeUlkKCJBbGxCdWdzQ2hlY2siKS5jaGVja2VkID0gZmFsc2U7CisgIH0KK30KKzwvc2NyaXB0PgorPCEtLSBTVU1NQVJZRU5ESEVBRCAtLT4KKzwvaGVhZD4KKzxib2R5PgorPGgxPiR7SHRtbFRpdGxlfTwvaDE+CisKKzx0YWJsZT4KKzx0cj48dGg+VXNlcjo8L3RoPjx0ZD4ke1VzZXJOYW1lfVxAJHtIb3N0TmFtZX08L3RkPjwvdHI+Cis8dHI+PHRoPldvcmtpbmcgRGlyZWN0b3J5OjwvdGg+PHRkPiR7Q3VycmVudERpcn08L3RkPjwvdHI+Cis8dHI+PHRoPkNvbW1hbmQgTGluZTo8L3RoPjx0ZD4ke0NtZEFyZ3N9PC90ZD48L3RyPgorPHRyPjx0aD5DbGFuZyBWZXJzaW9uOjwvdGg+PHRkPiR7Q2xhbmdWZXJzaW9ufTwvdGQ+PC90cj4KKzx0cj48dGg+RGF0ZTo8L3RoPjx0ZD4ke0RhdGV9PC90ZD48L3RyPgorRU5EVEVYVAorCitwcmludCBPVVQgIjx0cj48dGg+VmVyc2lvbjo8L3RoPjx0ZD4ke0J1aWxkTmFtZX0gKCR7QnVpbGREYXRlfSk8L3RkPjwvdHI+XG4iCisgIGlmIChkZWZpbmVkKCRCdWlsZE5hbWUpICYmIGRlZmluZWQoJEJ1aWxkRGF0ZSkpOworCitwcmludCBPVVQgPDxFTkRURVhUOworPC90YWJsZT4KK0VORFRFWFQKKworICBpZiAoc2NhbGFyKEBmaWxlc0ZvdW5kKSkgeworICAgICMgUHJpbnQgb3V0IHRoZSBzdW1tYXJ5IHRhYmxlLgorICAgIG15ICVUb3RhbHM7CisKKyAgICBmb3IgbXkgJHJvdyAoIEBJbmRleCApIHsKKyAgICAgIG15ICRidWdfdHlwZSA9ICgkcm93LT5bMl0pOworICAgICAgbXkgJGJ1Z19jYXRlZ29yeSA9ICgkcm93LT5bMV0pOworICAgICAgbXkgJGtleSA9ICIkYnVnX2NhdGVnb3J5OiRidWdfdHlwZSI7CisKKyAgICAgIGlmICghZGVmaW5lZCAkVG90YWxzeyRrZXl9KSB7ICRUb3RhbHN7JGtleX0gPSBbMSwkYnVnX2NhdGVnb3J5LCRidWdfdHlwZV07IH0KKyAgICAgIGVsc2UgeyAkVG90YWxzeyRrZXl9LT5bMF0rKzsgfQorICAgIH0KKworICAgIHByaW50IE9VVCAiPGgyPkJ1ZyBTdW1tYXJ5PC9oMj4iOworCisgICAgaWYgKGRlZmluZWQgJEJ1aWxkTmFtZSkgeworICAgICAgcHJpbnQgT1VUICJcbjxwPlJlc3VsdHMgaW4gdGhpcyBhbmFseXNpcyBydW4gYXJlIGJhc2VkIG9uIGFuYWx5emVyIGJ1aWxkIDxiPiRCdWlsZE5hbWU8L2I+LjwvcD5cbiIKKyAgICB9CisKKyAgbXkgJFRvdGFsQnVncyA9IHNjYWxhcihASW5kZXgpOworcHJpbnQgT1VUIDw8RU5EVEVYVDsKKzx0YWJsZT4KKzx0aGVhZD48dHI+PHRkPkJ1ZyBUeXBlPC90ZD48dGQ+UXVhbnRpdHk8L3RkPjx0ZCBjbGFzcz0ic29ydHRhYmxlX25vc29ydCI+RGlzcGxheT88L3RkPjwvdHI+PC90aGVhZD4KKzx0ciBzdHlsZT0iZm9udC13ZWlnaHQ6Ym9sZCI+PHRkIGNsYXNzPSJTVU1NX0RFU0MiPkFsbCBCdWdzPC90ZD48dGQgY2xhc3M9IlEiPiRUb3RhbEJ1Z3M8L3RkPjx0ZD48Y2VudGVyPjxpbnB1dCB0eXBlPSJjaGVja2JveCIgaWQ9IkFsbEJ1Z3NDaGVjayIgb25DbGljaz0iQ29weUNoZWNrZWRTdGF0ZVRvQ2hlY2tCdXR0b25zKHRoaXMpOyIgY2hlY2tlZC8+PC9jZW50ZXI+PC90ZD48L3RyPgorRU5EVEVYVAorCisgICAgbXkgJGxhc3RfY2F0ZWdvcnk7CisKKyAgICBmb3IgbXkgJGtleSAoCisgICAgICBzb3J0IHsKKyAgICAgICAgbXkgJHggPSAkVG90YWxzeyRhfTsKKyAgICAgICAgbXkgJHkgPSAkVG90YWxzeyRifTsKKyAgICAgICAgbXkgJHJlcyA9ICR4LT5bMV0gY21wICR5LT5bMV07CisgICAgICAgICRyZXMgPSAkeC0+WzJdIGNtcCAkeS0+WzJdIGlmICgkcmVzID09IDApOworICAgICAgICAkcmVzCisgICAgICB9IGtleXMgJVRvdGFscyApCisgICAgeworICAgICAgbXkgJHZhbCA9ICRUb3RhbHN7JGtleX07CisgICAgICBteSAkY2F0ZWdvcnkgPSAkdmFsLT5bMV07CisgICAgICBpZiAoIWRlZmluZWQgJGxhc3RfY2F0ZWdvcnkgb3IgJGxhc3RfY2F0ZWdvcnkgbmUgJGNhdGVnb3J5KSB7CisgICAgICAgICRsYXN0X2NhdGVnb3J5ID0gJGNhdGVnb3J5OworICAgICAgICBwcmludCBPVVQgIjx0cj48dGg+JGNhdGVnb3J5PC90aD48dGggY29sc3Bhbj0yPjwvdGg+PC90cj5cbiI7CisgICAgICB9CisgICAgICBteSAkeCA9IGxjICRrZXk7CisgICAgICAkeCA9fiBzL1sgLCciOlwvKCldKy9fL2c7CisgICAgICBwcmludCBPVVQgIjx0cj48dGQgY2xhc3M9XCJTVU1NX0RFU0NcIj4iOworICAgICAgcHJpbnQgT1VUICR2YWwtPlsyXTsKKyAgICAgIHByaW50IE9VVCAiPC90ZD48dGQgY2xhc3M9XCJRXCI+IjsKKyAgICAgIHByaW50IE9VVCAkdmFsLT5bMF07CisgICAgICBwcmludCBPVVQgIjwvdGQ+PHRkPjxjZW50ZXI+PGlucHV0IHR5cGU9XCJjaGVja2JveFwiIG9uQ2xpY2s9XCJUb2dnbGVEaXNwbGF5KHRoaXMsJ2J0XyR4Jyk7XCIgY2hlY2tlZC8+PC9jZW50ZXI+PC90ZD48L3RyPlxuIjsKKyAgICB9CisKKyAgIyBQcmludCBvdXQgdGhlIHRhYmxlIG9mIGVycm9ycy4KKworcHJpbnQgT1VUIDw8RU5EVEVYVDsKKzwvdGFibGU+Cis8aDI+UmVwb3J0czwvaDI+CisKKzx0YWJsZSBjbGFzcz0ic29ydGFibGUiIHN0eWxlPSJ0YWJsZS1sYXlvdXQ6YXV0b21hdGljIj4KKzx0aGVhZD48dHI+CisgIDx0ZD5CdWcgR3JvdXA8L3RkPgorICA8dGQgY2xhc3M9InNvcnR0YWJsZV9zb3J0ZWQiPkJ1ZyBUeXBlPHNwYW4gaWQ9InNvcnR0YWJsZV9zb3J0ZndkaW5kIj4mbmJzcDsmI3gyNUJFOzwvc3Bhbj48L3RkPgorICA8dGQ+RmlsZTwvdGQ+CisgIDx0ZD5GdW5jdGlvbi9NZXRob2Q8L3RkPgorICA8dGQgY2xhc3M9IlEiPkxpbmU8L3RkPgorICA8dGQgY2xhc3M9IlEiPlBhdGggTGVuZ3RoPC90ZD4KKyAgPHRkIGNsYXNzPSJzb3J0dGFibGVfbm9zb3J0Ij48L3RkPgorICA8IS0tIFJFUE9SVEJVR0NPTCAtLT4KKzwvdHI+PC90aGVhZD4KKzx0Ym9keT4KK0VORFRFWFQKKworICAgIG15ICRwcmVmaXggPSBHZXRQcmVmaXgoKTsKKyAgICBteSAkcmVnZXg7CisgICAgbXkgJEluRmlsZVJlZ2V4OworICAgIG15ICRJbkZpbGVQcmVmaXggPSAiRmlsZTo8L3RkPjx0ZD4iOworCisgICAgaWYgKGRlZmluZWQgJHByZWZpeCkgeworICAgICAgJHJlZ2V4ID0gcXIvXlxRJHByZWZpeFxFL2lzOworICAgICAgJEluRmlsZVJlZ2V4ID0gcXIvXFEkSW5GaWxlUHJlZml4JHByZWZpeFxFL2lzOworICAgIH0KKworICAgIGZvciBteSAkcm93ICggc29ydCB7ICRhLT5bMl0gY21wICRiLT5bMl0gfSBASW5kZXggKSB7CisgICAgICBteSAkeCA9ICIkcm93LT5bMV06JHJvdy0+WzJdIjsKKyAgICAgICR4ID0gbGMgJHg7CisgICAgICAkeCA9fiBzL1sgLCciOlwvKCldKy9fL2c7CisKKyAgICAgIG15ICRSZXBvcnRGaWxlID0gJHJvdy0+WzBdOworCisgICAgICBwcmludCBPVVQgIjx0ciBjbGFzcz1cImJ0XyR4XCI+IjsKKyAgICAgIHByaW50IE9VVCAiPHRkIGNsYXNzPVwiREVTQ1wiPiI7CisgICAgICBwcmludCBPVVQgJHJvdy0+WzFdOworICAgICAgcHJpbnQgT1VUICI8L3RkPiI7CisgICAgICBwcmludCBPVVQgIjx0ZCBjbGFzcz1cIkRFU0NcIj4iOworICAgICAgcHJpbnQgT1VUICRyb3ctPlsyXTsKKyAgICAgIHByaW50IE9VVCAiPC90ZD4iOworCisgICAgICAjIFVwZGF0ZSB0aGUgZmlsZSBwcmVmaXguCisgICAgICBteSAkZm5hbWUgPSAkcm93LT5bM107CisKKyAgICAgIGlmIChkZWZpbmVkICRyZWdleCkgeworICAgICAgICAkZm5hbWUgPX4gcy8kcmVnZXgvLzsKKyAgICAgICAgVXBkYXRlSW5GaWxlUGF0aCgiJERpci8kUmVwb3J0RmlsZSIsICRJbkZpbGVSZWdleCwgJEluRmlsZVByZWZpeCkKKyAgICAgIH0KKworICAgICAgcHJpbnQgT1VUICI8dGQ+IjsKKyAgICAgIG15IEBmbmFtZSA9IHNwbGl0IC9cLy8sJGZuYW1lOworICAgICAgaWYgKCQjZm5hbWUgPiAwKSB7CisgICAgICAgIHdoaWxlICgkI2ZuYW1lID49IDApIHsKKyAgICAgICAgICBteSAkeCA9IHNoaWZ0IEBmbmFtZTsKKyAgICAgICAgICBwcmludCBPVVQgJHg7CisgICAgICAgICAgaWYgKCQjZm5hbWUgPj0gMCkgeworICAgICAgICAgICAgcHJpbnQgT1VUICI8c3BhbiBjbGFzcz1cIldcIj4gPC9zcGFuPi8iOworICAgICAgICAgIH0KKyAgICAgICAgfQorICAgICAgfQorICAgICAgZWxzZSB7CisgICAgICAgIHByaW50IE9VVCAkZm5hbWU7CisgICAgICB9CisgICAgICBwcmludCBPVVQgIjwvdGQ+IjsKKworICAgICAgcHJpbnQgT1VUICI8dGQgY2xhc3M9XCJERVNDXCI+IjsKKyAgICAgIHByaW50IE9VVCAkcm93LT5bNF07CisgICAgICBwcmludCBPVVQgIjwvdGQ+IjsKKworICAgICAgIyBQcmludCBvdXQgdGhlIHF1YW50aXRpZXMuCisgICAgICBmb3IgbXkgJGogKCA1IC4uIDYgKSB7CisgICAgICAgIHByaW50IE9VVCAiPHRkIGNsYXNzPVwiUVwiPiRyb3ctPlskal08L3RkPiI7CisgICAgICB9CisKKyAgICAgICMgUHJpbnQgdGhlIHJlc3Qgb2YgdGhlIGNvbHVtbnMuCisgICAgICBmb3IgKG15ICRqID0gNzsgJGogPD0gJCN7JHJvd307ICsrJGopIHsKKyAgICAgICAgcHJpbnQgT1VUICI8dGQ+JHJvdy0+WyRqXTwvdGQ+IgorICAgICAgfQorCisgICAgICAjIEVtaXQgdGhlICJWaWV3IiBsaW5rLgorICAgICAgcHJpbnQgT1VUICI8dGQ+PGEgaHJlZj1cIiRSZXBvcnRGaWxlI0VuZFBhdGhcIj5WaWV3IFJlcG9ydDwvYT48L3RkPiI7CisKKyAgICAgICMgRW1pdCBSRVBPUlRCVUcgbWFya2Vycy4KKyAgICAgIHByaW50IE9VVCAiXG48IS0tIFJFUE9SVEJVRyBpZD1cIiRSZXBvcnRGaWxlXCIgLS0+XG4iOworCisgICAgICAjIEVuZCB0aGUgcm93LgorICAgICAgcHJpbnQgT1VUICI8L3RyPlxuIjsKKyAgICB9CisKKyAgICBwcmludCBPVVQgIjwvdGJvZHk+XG48L3RhYmxlPlxuXG4iOworICB9CisKKyAgaWYgKHNjYWxhciAoQGZhaWx1cmVzKSB8fCBzY2FsYXIoQGF0dHJpYnV0ZXNfaWdub3JlZCkpIHsKKyAgICBwcmludCBPVVQgIjxoMj5BbmFseXplciBGYWlsdXJlczwvaDI+XG4iOworCisgICAgaWYgKHNjYWxhciBAYXR0cmlidXRlc19pZ25vcmVkKSB7CisgICAgICBwcmludCBPVVQgIlRoZSBhbmFseXplcidzIHBhcnNlciBpZ25vcmVkIHRoZSBmb2xsb3dpbmcgYXR0cmlidXRlczo8cD5cbiI7CisgICAgICBwcmludCBPVVQgIjx0YWJsZT5cbiI7CisgICAgICBwcmludCBPVVQgIjx0aGVhZD48dHI+PHRkPkF0dHJpYnV0ZTwvdGQ+PHRkPlNvdXJjZSBGaWxlPC90ZD48dGQ+UHJlcHJvY2Vzc2VkIEZpbGU8L3RkPjx0ZD5TVERFUlIgT3V0cHV0PC90ZD48L3RyPjwvdGhlYWQ+XG4iOworICAgICAgZm9yZWFjaCBteSAkZmlsZSAoc29ydCBAYXR0cmlidXRlc19pZ25vcmVkKSB7CisgICAgICAgIGRpZSAiY2Fubm90IGRlbWFuZ2xlIGF0dHJpYnV0ZSBuYW1lXG4iIGlmICghICgkZmlsZSA9fiAvXmF0dHJpYnV0ZV9pZ25vcmVkXyguKykudHh0LykpOworICAgICAgICBteSAkYXR0cmlidXRlID0gJDE7CisgICAgICAgICMgT3BlbiB0aGUgYXR0cmlidXRlIGZpbGUgdG8gZ2V0IHRoZSBmaXJzdCBmaWxlIHRoYXQgZmFpbGVkLgorICAgICAgICBuZXh0IGlmICghb3BlbiAoQVRUUiwgIiREaXIvZmFpbHVyZXMvJGZpbGUiKSk7CisgICAgICAgIG15ICRwcGZpbGUgPSA8QVRUUj47CisgICAgICAgIGNob21wICRwcGZpbGU7CisgICAgICAgIGNsb3NlIEFUVFI7CisgICAgICAgIG5leHQgaWYgKCEgLWUgIiREaXIvZmFpbHVyZXMvJHBwZmlsZSIpOworICAgICAgICAjIE9wZW4gdGhlIGluZm8gZmlsZSBhbmQgZ2V0IHRoZSBuYW1lIG9mIHRoZSBzb3VyY2UgZmlsZS4KKyAgICAgICAgb3BlbiAoSU5GTywgIiREaXIvZmFpbHVyZXMvJHBwZmlsZS5pbmZvLnR4dCIpIG9yCisgICAgICAgICAgZGllICJDYW5ub3Qgb3BlbiAkRGlyL2ZhaWx1cmVzLyRwcGZpbGUuaW5mby50eHRcbiI7CisgICAgICAgIG15ICRzcmNmaWxlID0gPElORk8+OworICAgICAgICBjaG9tcCAkc3JjZmlsZTsKKyAgICAgICAgY2xvc2UgKElORk8pOworICAgICAgICAjIFByaW50IHRoZSBpbmZvcm1hdGlvbiBpbiB0aGUgdGFibGUuCisgICAgICAgIG15ICRwcmVmaXggPSBHZXRQcmVmaXgoKTsKKyAgICAgICAgaWYgKGRlZmluZWQgJHByZWZpeCkgeyAkc3JjZmlsZSA9fiBzL15cUSRwcmVmaXgvLzsgfQorICAgICAgICBwcmludCBPVVQgIjx0cj48dGQ+JGF0dHJpYnV0ZTwvdGQ+PHRkPiRzcmNmaWxlPC90ZD48dGQ+PGEgaHJlZj1cImZhaWx1cmVzLyRwcGZpbGVcIj4kcHBmaWxlPC9hPjwvdGQ+PHRkPjxhIGhyZWY9XCJmYWlsdXJlcy8kcHBmaWxlLnN0ZGVyci50eHRcIj4kcHBmaWxlLnN0ZGVyci50eHQ8L2E+PC90ZD48L3RyPlxuIjsKKyAgICAgICAgbXkgJHBwZmlsZV9jbGFuZyA9ICRwcGZpbGU7CisgICAgICAgICRwcGZpbGVfY2xhbmcgPX4gcy9bLl0oLispJC8uY2xhbmcuJDEvOworICAgICAgICBwcmludCBPVVQgIiAgPCEtLSBSRVBPUlRQUk9CTEVNIHNyYz1cIiRzcmNmaWxlXCIgZmlsZT1cImZhaWx1cmVzLyRwcGZpbGVcIiBjbGFuZ2ZpbGU9XCJmYWlsdXJlcy8kcHBmaWxlX2NsYW5nXCIgc3RkZXJyPVwiZmFpbHVyZXMvJHBwZmlsZS5zdGRlcnIudHh0XCIgaW5mbz1cImZhaWx1cmVzLyRwcGZpbGUuaW5mby50eHRcIiAtLT5cbiI7CisgICAgICB9CisgICAgICBwcmludCBPVVQgIjwvdGFibGU+XG4iOworICAgIH0KKworICAgIGlmIChzY2FsYXIgQGZhaWx1cmVzKSB7CisgICAgICBwcmludCBPVVQgIjxwPlRoZSBhbmFseXplciBoYWQgcHJvYmxlbXMgcHJvY2Vzc2luZyB0aGUgZm9sbG93aW5nIGZpbGVzOjwvcD5cbiI7CisgICAgICBwcmludCBPVVQgIjx0YWJsZT5cbiI7CisgICAgICBwcmludCBPVVQgIjx0aGVhZD48dHI+PHRkPlByb2JsZW08L3RkPjx0ZD5Tb3VyY2UgRmlsZTwvdGQ+PHRkPlByZXByb2Nlc3NlZCBGaWxlPC90ZD48dGQ+U1RERVJSIE91dHB1dDwvdGQ+PC90cj48L3RoZWFkPlxuIjsKKyAgICAgIGZvcmVhY2ggbXkgJGZpbGUgKHNvcnQgQGZhaWx1cmVzKSB7CisgICAgICAgICRmaWxlID1+IC8oLispLmluZm8udHh0JC87CisgICAgICAgICMgR2V0IHRoZSBwcmVwcm9jZXNzZWQgZmlsZS4KKyAgICAgICAgbXkgJHBwZmlsZSA9ICQxOworICAgICAgICAjIE9wZW4gdGhlIGluZm8gZmlsZSBhbmQgZ2V0IHRoZSBuYW1lIG9mIHRoZSBzb3VyY2UgZmlsZS4KKyAgICAgICAgb3BlbiAoSU5GTywgIiREaXIvZmFpbHVyZXMvJGZpbGUiKSBvcgorICAgICAgICAgIGRpZSAiQ2Fubm90IG9wZW4gJERpci9mYWlsdXJlcy8kZmlsZVxuIjsKKyAgICAgICAgbXkgJHNyY2ZpbGUgPSA8SU5GTz47CisgICAgICAgIGNob21wICRzcmNmaWxlOworICAgICAgICBteSAkcHJvYmxlbSA9IDxJTkZPPjsKKyAgICAgICAgY2hvbXAgJHByb2JsZW07CisgICAgICAgIGNsb3NlIChJTkZPKTsKKyAgICAgICAgIyBQcmludCB0aGUgaW5mb3JtYXRpb24gaW4gdGhlIHRhYmxlLgorICAgICAgICBteSAkcHJlZml4ID0gR2V0UHJlZml4KCk7CisgICAgICAgIGlmIChkZWZpbmVkICRwcmVmaXgpIHsgJHNyY2ZpbGUgPX4gcy9eXFEkcHJlZml4Ly87IH0KKyAgICAgICAgcHJpbnQgT1VUICI8dHI+PHRkPiRwcm9ibGVtPC90ZD48dGQ+JHNyY2ZpbGU8L3RkPjx0ZD48YSBocmVmPVwiZmFpbHVyZXMvJHBwZmlsZVwiPiRwcGZpbGU8L2E+PC90ZD48dGQ+PGEgaHJlZj1cImZhaWx1cmVzLyRwcGZpbGUuc3RkZXJyLnR4dFwiPiRwcGZpbGUuc3RkZXJyLnR4dDwvYT48L3RkPjwvdHI+XG4iOworICAgICAgICBteSAkcHBmaWxlX2NsYW5nID0gJHBwZmlsZTsKKyAgICAgICAgJHBwZmlsZV9jbGFuZyA9fiBzL1suXSguKykkLy5jbGFuZy4kMS87CisgICAgICAgIHByaW50IE9VVCAiICA8IS0tIFJFUE9SVFBST0JMRU0gc3JjPVwiJHNyY2ZpbGVcIiBmaWxlPVwiZmFpbHVyZXMvJHBwZmlsZVwiIGNsYW5nZmlsZT1cImZhaWx1cmVzLyRwcGZpbGVfY2xhbmdcIiBzdGRlcnI9XCJmYWlsdXJlcy8kcHBmaWxlLnN0ZGVyci50eHRcIiBpbmZvPVwiZmFpbHVyZXMvJHBwZmlsZS5pbmZvLnR4dFwiIC0tPlxuIjsKKyAgICAgIH0KKyAgICAgIHByaW50IE9VVCAiPC90YWJsZT5cbiI7CisgICAgfQorICAgIHByaW50IE9VVCAiPHA+UGxlYXNlIGNvbnNpZGVyIHN1Ym1pdHRpbmcgcHJlcHJvY2Vzc2VkIGZpbGVzIGFzIDxhIGhyZWY9XCJodHRwOi8vY2xhbmctYW5hbHl6ZXIubGx2bS5vcmcvZmlsaW5nX2J1Z3MuaHRtbFwiPmJ1ZyByZXBvcnRzPC9hPi4gPCEtLSBSRVBPUlRDUkFTSEVTIC0tPiA8L3A+XG4iOworICB9CisKKyAgcHJpbnQgT1VUICI8L2JvZHk+PC9odG1sPlxuIjsKKyAgY2xvc2UoT1VUKTsKKyAgQ29weUZpbGVzKCREaXIpOworCisgICMgTWFrZSBzdXJlICREaXIgYW5kICRCYXNlRGlyIGFyZSB3b3JsZCByZWFkYWJsZS9leGVjdXRhYmxlLgorICBjaG1vZCgwNzU1LCAkRGlyKTsKKyAgaWYgKGRlZmluZWQgJEJhc2VEaXIpIHsgY2htb2QoMDc1NSwgJEJhc2VEaXIpOyB9CisKKyAgIyBQcmludCBzdGF0aXN0aWNzCisgIHByaW50IENhbGNTdGF0cyhcQFN0YXRzKSBpZiAkQW5hbHl6ZXJTdGF0czsKKworICBteSAkTnVtID0gc2NhbGFyKEBJbmRleCk7CisgIGlmICgkTnVtID09IDEpIHsKKyAgICBEaWFnKCIkTnVtIGJ1ZyBmb3VuZC5cbiIpOworICB9IGVsc2UgeworICAgIERpYWcoIiROdW0gYnVncyBmb3VuZC5cbiIpOworICB9CisgIGlmICgkTnVtID4gMCAmJiAtciAiJERpci9pbmRleC5odG1sIikgeworICAgIERpYWcoIlJ1biAnc2Nhbi12aWV3ICREaXInIHRvIGV4YW1pbmUgYnVnIHJlcG9ydHMuXG4iKTsKKyAgfQorCisgIERpYWdDcmFzaGVzKCREaXIpIGlmIChzY2FsYXIgQGZhaWx1cmVzIHx8IHNjYWxhciBAYXR0cmlidXRlc19pZ25vcmVkKTsKKworICByZXR1cm4gJE51bTsKK30KKworIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKyMgUnVuQnVpbGRDb21tYW5kIC0gUnVuIHRoZSBidWlsZCBjb21tYW5kLgorIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKworc3ViIEFkZElmTm90UHJlc2VudCB7CisgIG15ICRBcmdzID0gc2hpZnQ7CisgIG15ICRBcmcgPSBzaGlmdDsKKyAgbXkgJGZvdW5kID0gMDsKKworICBmb3JlYWNoIG15ICRrIChAJEFyZ3MpIHsKKyAgICBpZiAoJGsgZXEgJEFyZykgeworICAgICAgJGZvdW5kID0gMTsKKyAgICAgIGxhc3Q7CisgICAgfQorICB9CisKKyAgaWYgKCRmb3VuZCA9PSAwKSB7CisgICAgcHVzaCBAJEFyZ3MsICRBcmc7CisgIH0KK30KKworc3ViIFNldEVudiB7CisgIG15ICRPcHRpb25zID0gc2hpZnQgQF87CisgIGZvcmVhY2ggbXkgJG9wdCAoJ0NDJywgJ0NYWCcsICdDTEFORycsICdDTEFOR19DWFgnLAorICAgICAgICAgICAgICAgICAgICAnQ0NDX0FOQUxZWkVSX0FOQUxZU0lTJywgJ0NDQ19BTkFMWVpFUl9QTFVHSU5TJywKKyAgICAgICAgICAgICAgICAgICAgJ0NDQ19BTkFMWVpFUl9DT05GSUcnKSB7CisgICAgZGllICIkb3B0IGlzIHVuZGVmaW5lZFxuIiBpZiAoIWRlZmluZWQgJG9wdCk7CisgICAgJEVOVnskb3B0fSA9ICRPcHRpb25zLT57JG9wdH07CisgIH0KKyAgZm9yZWFjaCBteSAkb3B0ICgnQ0NDX0FOQUxZWkVSX1NUT1JFX01PREVMJywKKyAgICAgICAgICAgICAgICAgICAgJ0NDQ19BTkFMWVpFUl9QTFVHSU5TJywKKyAgICAgICAgICAgICAgICAgICAgJ0NDQ19BTkFMWVpFUl9JTlRFUk5BTF9TVEFUUycsCisgICAgICAgICAgICAgICAgICAgICdDQ0NfQU5BTFlaRVJfT1VUUFVUX0ZPUk1BVCcpIHsKKyAgICBteSAkeCA9ICRPcHRpb25zLT57JG9wdH07CisgICAgaWYgKGRlZmluZWQgJHgpIHsgJEVOVnskb3B0fSA9ICR4IH0KKyAgfQorICBteSAkVmVyYm9zZSA9ICRPcHRpb25zLT57J1ZFUkJPU0UnfTsKKyAgaWYgKCRWZXJib3NlID49IDIpIHsKKyAgICAkRU5WeydDQ0NfQU5BTFlaRVJfVkVSQk9TRSd9ID0gMTsKKyAgfQorICBpZiAoJFZlcmJvc2UgPj0gMykgeworICAgICRFTlZ7J0NDQ19BTkFMWVpFUl9MT0cnfSA9IDE7CisgIH0KK30KKworIyBUaGUgZmxhZyBjb3JyZXNwb25kaW5nIHRvIHRoZSAtLW92ZXJyaWRlLWNvbXBpbGVyIGNvbW1hbmQgbGluZSBvcHRpb24uCitteSAkT3ZlcnJpZGVDb21waWxlciA9IDA7CisKK3N1YiBSdW5YY29kZWJ1aWxkIHsKKyAgbXkgJEFyZ3MgPSBzaGlmdDsKKyAgbXkgJElnbm9yZUVycm9ycyA9IHNoaWZ0OworICBteSAkQ0NBbmFseXplciA9IHNoaWZ0OworICBteSAkQ1hYQW5hbHl6ZXIgPSBzaGlmdDsKKyAgbXkgJE9wdGlvbnMgPSBzaGlmdDsKKworICBpZiAoJElnbm9yZUVycm9ycykgeworICAgIEFkZElmTm90UHJlc2VudCgkQXJncywiLVBCWEJ1aWxkc0NvbnRpbnVlQWZ0ZXJFcnJvcnM9WUVTIik7CisgIH0KKworICAjIERldGVjdCB0aGUgdmVyc2lvbiBvZiBYY29kZS4gIElmIFhjb2RlIDQuNiBvciBoaWdoZXIsIHVzZSBuZXcKKyAgIyBpbiBzaXR1IHN1cHBvcnQgZm9yIGFuYWx5emVyIGludGVycG9zaXRpb24gd2l0aG91dCBuZWVkZWQgdG8gb3ZlcnJpZGUKKyAgIyB0aGUgY29tcGlsZXIuCisgIG9wZW4oREVURUNUX1hDT0RFLCAiLXwiLCAkQXJncy0+WzBdLCAiLXZlcnNpb24iKSBvcgorICAgIGRpZSAiZXJyb3I6IGNhbm5vdCBkZXRlY3QgdmVyc2lvbiBvZiB4Y29kZWJ1aWxkXG4iOworCisgIG15ICRvbGRCZWhhdmlvciA9IDE7CisKKyAgd2hpbGUoPERFVEVDVF9YQ09ERT4pIHsKKyAgICBpZiAoL15YY29kZSAoLispJC8pIHsKKyAgICAgIG15ICR2ZXIgPSAkMTsKKyAgICAgIGlmICgkdmVyID1+IC9eKFswLTldK1suXVswLTldKylbXjAtOV0/LykgeworICAgICAgICBpZiAoJDEgPj0gNC42KSB7CisgICAgICAgICAgJG9sZEJlaGF2aW9yID0gMDsKKyAgICAgICAgICBsYXN0OworICAgICAgICB9CisgICAgICB9CisgICAgfQorICB9CisgIGNsb3NlKERFVEVDVF9YQ09ERSk7CisKKyAgIyBJZiAtLW92ZXJyaWRlLWNvbXBpbGVyIGlzIGV4cGxpY2l0ZWx5IHJlcXVlc3RlZCwgcmVzb3J0IHRvIHRoZSBvbGQKKyAgIyBiZWhhdmlvciByZWdhcmRsZXNzIG9mIFhjb2RlIHZlcnNpb24uCisgIGlmICgkT3ZlcnJpZGVDb21waWxlcikgeworICAgICRvbGRCZWhhdmlvciA9IDE7CisgIH0KKworICBpZiAoJG9sZEJlaGF2aW9yID09IDApIHsKKyAgICBteSAkT3V0cHV0RGlyID0gJE9wdGlvbnMtPnsiT1VUUFVUX0RJUiJ9OworICAgIG15ICRDTEFORyA9ICRPcHRpb25zLT57IkNMQU5HIn07CisgICAgbXkgJE90aGVyRmxhZ3MgPSAkT3B0aW9ucy0+eyJDQ0NfQU5BTFlaRVJfQU5BTFlTSVMifTsKKyAgICBwdXNoIEAkQXJncywKKyAgICAgICAgIlJVTl9DTEFOR19TVEFUSUNfQU5BTFlaRVI9WUVTIiwKKyAgICAgICAgIkNMQU5HX0FOQUxZWkVSX09VVFBVVD1wbGlzdC1odG1sIiwKKyAgICAgICAgIkNMQU5HX0FOQUxZWkVSX0VYRUM9JENMQU5HIiwKKyAgICAgICAgIkNMQU5HX0FOQUxZWkVSX09VVFBVVF9ESVI9JE91dHB1dERpciIsCisgICAgICAgICJDTEFOR19BTkFMWVpFUl9PVEhFUl9GTEFHUz0kT3RoZXJGbGFncyI7CisKKyAgICByZXR1cm4gKHN5c3RlbShAJEFyZ3MpID4+IDgpOworICB9CisKKyAgIyBEZWZhdWx0IHRvIG9sZCBiZWhhdmlvciB3aGVyZSB3ZSBpbnNlcnQgYSBib2d1cyBjb21waWxlci4KKyAgU2V0RW52KCRPcHRpb25zKTsKKworICAjIENoZWNrIGlmIHVzaW5nIGlQaG9uZSBTREsgMy4wIChzaW11bGF0b3IpLiAgSWYgc28gdGhlIGNvbXBpbGVyIGJlaW5nCisgICMgdXNlZCBzaG91bGQgYmUgZ2NjLTQuMi4KKyAgaWYgKCFkZWZpbmVkICRFTlZ7IkNDQ19DQyJ9KSB7CisgICAgZm9yIChteSAkaSA9IDAgOyAkaSA8IHNjYWxhcihAJEFyZ3MpOyArKyRpKSB7CisgICAgICBpZiAoJEFyZ3MtPlskaV0gZXEgIi1zZGsiICYmICRpICsgMSA8IHNjYWxhcihAJEFyZ3MpKSB7CisgICAgICAgIGlmIChAJEFyZ3NbJGkrMV0gPX4gL15pcGhvbmVzaW11bGF0b3IzLykgeworICAgICAgICAgICRFTlZ7IkNDQ19DQyJ9ID0gImdjYy00LjIiOworICAgICAgICAgICRFTlZ7IkNDQ19DWFgifSA9ICJnKystNC4yIjsKKyAgICAgICAgfQorICAgICAgfQorICAgIH0KKyAgfQorCisgICMgRGlzYWJsZSBQQ0ggZmlsZXMgdW50aWwgY2xhbmcgc3VwcG9ydHMgdGhlbS4KKyAgQWRkSWZOb3RQcmVzZW50KCRBcmdzLCJHQ0NfUFJFQ09NUElMRV9QUkVGSVhfSEVBREVSPU5PIik7CisKKyAgIyBXaGVuICdDQycgaXMgc2V0LCB4Y29kZWJ1aWxkIHVzZXMgaXQgdG8gZG8gYWxsIGxpbmtpbmcsIGV2ZW4gaWYgd2UgYXJlCisgICMgbGlua2luZyBDKysgb2JqZWN0IGZpbGVzLiAgU2V0ICdMRFBMVVNQTFVTJyBzbyB0aGF0IHhjb2RlYnVpbGQgdXNlcyAnZysrJworICAjICh2aWEgYysrLWFuYWx5emVyKSB3aGVuIGxpbmtpbmcgc3VjaCBmaWxlcy4KKyAgJEVOVnsiTERQTFVTUExVUyJ9ID0gJENYWEFuYWx5emVyOworCisgIHJldHVybiAoc3lzdGVtKEAkQXJncykgPj4gOCk7Cit9CisKK3N1YiBSdW5CdWlsZENvbW1hbmQgeworICBteSAkQXJncyA9IHNoaWZ0OworICBteSAkSWdub3JlRXJyb3JzID0gc2hpZnQ7CisgIG15ICRDbWQgPSAkQXJncy0+WzBdOworICBteSAkQ0NBbmFseXplciA9IHNoaWZ0OworICBteSAkQ1hYQW5hbHl6ZXIgPSBzaGlmdDsKKyAgbXkgJE9wdGlvbnMgPSBzaGlmdDsKKworICBpZiAoJENtZCA9fiAvXGJ4Y29kZWJ1aWxkJC8pIHsKKyAgICByZXR1cm4gUnVuWGNvZGVidWlsZCgkQXJncywgJElnbm9yZUVycm9ycywgJENDQW5hbHl6ZXIsICRDWFhBbmFseXplciwgJE9wdGlvbnMpOworICB9CisKKyAgIyBTZXR1cCB0aGUgZW52aXJvbm1lbnQuCisgIFNldEVudigkT3B0aW9ucyk7CisKKyAgaWYgKCRDbWQgPX4gLyguKlwvP2djY1teXC9dKiQpLyBvcgorICAgICAgJENtZCA9fiAvKC4qXC8/Y2NbXlwvXSokKS8gb3IKKyAgICAgICRDbWQgPX4gLyguKlwvP2xsdm0tZ2NjW15cL10qJCkvIG9yCisgICAgICAkQ21kID1+IC8oLipcLz9jbGFuZyQpLyBvcgorICAgICAgJENtZCA9fiAvKC4qXC8/Y2NjLWFuYWx5emVyW15cL10qJCkvKSB7CisKKyAgICBpZiAoISgkQ21kID1+IC9jY2MtYW5hbHl6ZXIvKSBhbmQgIWRlZmluZWQgJEVOVnsiQ0NDX0NDIn0pIHsKKyAgICAgICRFTlZ7IkNDQ19DQyJ9ID0gJDE7CisgICAgfQorCisgICAgc2hpZnQgQCRBcmdzOworICAgIHVuc2hpZnQgQCRBcmdzLCAkQ0NBbmFseXplcjsKKyAgfQorICBlbHNpZiAoJENtZCA9fiAvKC4qXC8/Z1wrXCtbXlwvXSokKS8gb3IKKyAgICAgICAgJENtZCA9fiAvKC4qXC8/Y1wrXCtbXlwvXSokKS8gb3IKKyAgICAgICAgJENtZCA9fiAvKC4qXC8/bGx2bS1nXCtcK1teXC9dKiQpLyBvcgorICAgICAgICAkQ21kID1+IC8oLipcLz9jbGFuZ1wrXCskKS8gb3IKKyAgICAgICAgJENtZCA9fiAvKC4qXC8/Y1wrXCstYW5hbHl6ZXJbXlwvXSokKS8pIHsKKyAgICBpZiAoISgkQ21kID1+IC9jXCtcKy1hbmFseXplci8pIGFuZCAhZGVmaW5lZCAkRU5WeyJDQ0NfQ1hYIn0pIHsKKyAgICAgICRFTlZ7IkNDQ19DWFgifSA9ICQxOworICAgIH0KKyAgICBzaGlmdCBAJEFyZ3M7CisgICAgdW5zaGlmdCBAJEFyZ3MsICRDWFhBbmFseXplcjsKKyAgfQorICBlbHNpZiAoJENtZCBlcSAibWFrZSIgb3IgJENtZCBlcSAiZ21ha2UiIG9yICRDbWQgZXEgIm1pbmd3MzItbWFrZSIpIHsKKyAgICBBZGRJZk5vdFByZXNlbnQoJEFyZ3MsICJDQz0kQ0NBbmFseXplciIpOworICAgIEFkZElmTm90UHJlc2VudCgkQXJncywgIkNYWD0kQ1hYQW5hbHl6ZXIiKTsKKyAgICBpZiAoJElnbm9yZUVycm9ycykgeworICAgICAgQWRkSWZOb3RQcmVzZW50KCRBcmdzLCItayIpOworICAgICAgQWRkSWZOb3RQcmVzZW50KCRBcmdzLCItaSIpOworICAgIH0KKyAgfQorCisgIHJldHVybiAoc3lzdGVtKEAkQXJncykgPj4gOCk7Cit9CisKKyMjLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSMjCisjIERpc3BsYXlIZWxwIC0gVXRpbGl0eSBmdW5jdGlvbiB0byBkaXNwbGF5IGFsbCBoZWxwIG9wdGlvbnMuCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworCitzdWIgRGlzcGxheUhlbHAgeworCitwcmludCA8PEVORFRFWFQ7CitVU0FHRTogJFByb2cgW29wdGlvbnNdIDxidWlsZCBjb21tYW5kPiBbYnVpbGQgb3B0aW9uc10KKworRU5EVEVYVAorCisgIGlmIChkZWZpbmVkICRCdWlsZE5hbWUpIHsKKyAgICBwcmludCAiQU5BTFlaRVIgQlVJTEQ6ICRCdWlsZE5hbWUgKCRCdWlsZERhdGUpXG5cbiI7CisgIH0KKworcHJpbnQgPDxFTkRURVhUOworT1BUSU9OUzoKKworIC1hbmFseXplLWhlYWRlcnMKKworICAgQWxzbyBhbmFseXplIGZ1bmN0aW9ucyBpbiAjaW5jbHVkZWQgZmlsZXMuICBCeSBkZWZhdWx0LCBzdWNoIGZ1bmN0aW9ucworICAgYXJlIHNraXBwZWQgdW5sZXNzIHRoZXkgYXJlIGNhbGxlZCBieSBmdW5jdGlvbnMgd2l0aGluIHRoZSBtYWluIHNvdXJjZSBmaWxlLgorCisgLW8gPG91dHB1dCBsb2NhdGlvbj4KKworICAgU3BlY2lmaWVzIHRoZSBvdXRwdXQgZGlyZWN0b3J5IGZvciBhbmFseXplciByZXBvcnRzLiBTdWJkaXJlY3RvcmllcyB3aWxsIGJlCisgICBjcmVhdGVkIGFzIG5lZWRlZCB0byByZXByZXNlbnQgc2VwYXJhdGUgInJ1bnMiIG9mIHRoZSBhbmFseXplci4gSWYgdGhpcworICAgb3B0aW9uIGlzIG5vdCBzcGVjaWZpZWQsIGEgZGlyZWN0b3J5IGlzIGNyZWF0ZWQgaW4gL3RtcCAoVE1QRElSIG9uIE1hYyBPUyBYKQorICAgdG8gc3RvcmUgdGhlIHJlcG9ydHMuCisKKyAtaAorIC0taGVscAorCisgICBEaXNwbGF5IHRoaXMgbWVzc2FnZS4KKworIC1rCisgLS1rZWVwLWdvaW5nCisKKyAgIEFkZCBhICJrZWVwIG9uIGdvaW5nIiBvcHRpb24gdG8gdGhlIHNwZWNpZmllZCBidWlsZCBjb21tYW5kLiBUaGlzIG9wdGlvbgorICAgY3VycmVudGx5IHN1cHBvcnRzIG1ha2UgYW5kIHhjb2RlYnVpbGQuIFRoaXMgaXMgYSBjb252ZW5pZW5jZSBvcHRpb247IG9uZQorICAgY2FuIHNwZWNpZnkgdGhpcyBiZWhhdmlvciBkaXJlY3RseSB1c2luZyBidWlsZCBvcHRpb25zLgorCisgLS1odG1sLXRpdGxlIFt0aXRsZV0KKyAtLWh0bWwtdGl0bGU9W3RpdGxlXQorCisgICBTcGVjaWZ5IHRoZSB0aXRsZSB1c2VkIG9uIGdlbmVyYXRlZCBIVE1MIHBhZ2VzLiBJZiBub3Qgc3BlY2lmaWVkLCBhIGRlZmF1bHQKKyAgIHRpdGxlIHdpbGwgYmUgdXNlZC4KKworIC1wbGlzdAorCisgICBCeSBkZWZhdWx0IHRoZSBvdXRwdXQgb2Ygc2Nhbi1idWlsZCBpcyBhIHNldCBvZiBIVE1MIGZpbGVzLiBUaGlzIG9wdGlvbgorICAgb3V0cHV0cyB0aGUgcmVzdWx0cyBhcyBhIHNldCBvZiAucGxpc3QgZmlsZXMuCisKKyAtcGxpc3QtaHRtbAorCisgICBCeSBkZWZhdWx0IHRoZSBvdXRwdXQgb2Ygc2Nhbi1idWlsZCBpcyBhIHNldCBvZiBIVE1MIGZpbGVzLiBUaGlzIG9wdGlvbgorICAgb3V0cHV0cyB0aGUgcmVzdWx0cyBhcyBhIHNldCBvZiBIVE1MIGFuZCAucGxpc3QgZmlsZXMuCisKKyAtLXN0YXR1cy1idWdzCisKKyAgIEJ5IGRlZmF1bHQsIHRoZSBleGl0IHN0YXR1cyBvZiBzY2FuLWJ1aWxkIGlzIHRoZSBzYW1lIGFzIHRoZSBleGVjdXRlZCBidWlsZAorICAgY29tbWFuZC4gU3BlY2lmeWluZyB0aGlzIG9wdGlvbiBjYXVzZXMgdGhlIGV4aXQgc3RhdHVzIG9mIHNjYW4tYnVpbGQgdG8gYmUgMQorICAgaWYgaXQgZm91bmQgcG90ZW50aWFsIGJ1Z3MgYW5kIDAgb3RoZXJ3aXNlLgorCisgLS11c2UtY2MgW2NvbXBpbGVyIHBhdGhdCisgLS11c2UtY2M9W2NvbXBpbGVyIHBhdGhdCisKKyAgIHNjYW4tYnVpbGQgYW5hbHl6ZXMgYSBwcm9qZWN0IGJ5IGludGVycG9zaW5nIGEgImZha2UgY29tcGlsZXIiLCB3aGljaAorICAgZXhlY3V0ZXMgYSByZWFsIGNvbXBpbGVyIGZvciBjb21waWxhdGlvbiBhbmQgdGhlIHN0YXRpYyBhbmFseXplciBmb3IgYW5hbHlzaXMuCisgICBCZWNhdXNlIG9mIHRoZSBjdXJyZW50IGltcGxlbWVudGF0aW9uIG9mIGludGVycG9zaXRpb24sIHNjYW4tYnVpbGQgZG9lcyBub3QKKyAgIGtub3cgd2hhdCBjb21waWxlciB5b3VyIHByb2plY3Qgbm9ybWFsbHkgdXNlcy4gIEluc3RlYWQsIGl0IHNpbXBseSBvdmVycmlkZXMKKyAgIHRoZSBDQyBlbnZpcm9ubWVudCB2YXJpYWJsZSwgYW5kIGd1ZXNzZXMgeW91ciBkZWZhdWx0IGNvbXBpbGVyLgorCisgICBJbiB0aGUgZnV0dXJlLCB0aGlzIGludGVycG9zaXRpb24gbWVjaGFuaXNtIHRvIGJlIGltcHJvdmVkLCBidXQgaWYgeW91IG5lZWQKKyAgIHNjYW4tYnVpbGQgdG8gdXNlIGEgc3BlY2lmaWMgY29tcGlsZXIgZm9yICpjb21waWxhdGlvbiogdGhlbiB5b3UgY2FuIHVzZQorICAgdGhpcyBvcHRpb24gdG8gc3BlY2lmeSBhIHBhdGggdG8gdGhhdCBjb21waWxlci4KKworIC0tdXNlLWMrKyBbY29tcGlsZXIgcGF0aF0KKyAtLXVzZS1jKys9W2NvbXBpbGVyIHBhdGhdCisKKyAgIFRoaXMgaXMgdGhlIHNhbWUgYXMgIi11c2UtY2MiIGJ1dCBmb3IgQysrIGNvZGUuCisKKyAtdgorCisgICBFbmFibGUgdmVyYm9zZSBvdXRwdXQgZnJvbSBzY2FuLWJ1aWxkLiBBIHNlY29uZCBhbmQgdGhpcmQgJy12JyBpbmNyZWFzZXMKKyAgIHZlcmJvc2l0eS4KKworIC1WCisgLS12aWV3CisKKyAgIFZpZXcgYW5hbHlzaXMgcmVzdWx0cyBpbiBhIHdlYiBicm93c2VyIHdoZW4gdGhlIGJ1aWxkIGNvbXBsZXRlcy4KKworQURWQU5DRUQgT1BUSU9OUzoKKworIC1uby1mYWlsdXJlLXJlcG9ydHMKKworICAgRG8gbm90IGNyZWF0ZSBhICdmYWlsdXJlcycgc3ViZGlyZWN0b3J5IHRoYXQgaW5jbHVkZXMgYW5hbHl6ZXIgY3Jhc2ggcmVwb3J0cworICAgYW5kIHByZXByb2Nlc3NlZCBzb3VyY2UgZmlsZXMuCisKKyAtc3RhdHMKKworICAgR2VuZXJhdGVzIHZpc2l0YXRpb24gc3RhdGlzdGljcyBmb3IgdGhlIHByb2plY3QgYmVpbmcgYW5hbHl6ZWQuCisKKyAtbWF4bG9vcCA8bG9vcCBjb3VudD4KKworICAgU3BlY2lmaXkgdGhlIG51bWJlciBvZiB0aW1lcyBhIGJsb2NrIGNhbiBiZSB2aXNpdGVkIGJlZm9yZSBnaXZpbmcgdXAuCisgICBEZWZhdWx0IGlzIDQuIEluY3JlYXNlIGZvciBtb3JlIGNvbXByZWhlbnNpdmUgY292ZXJhZ2UgYXQgYSBjb3N0IG9mIHNwZWVkLgorCisgLWludGVybmFsLXN0YXRzCisKKyAgIEdlbmVyYXRlIGludGVybmFsIGFuYWx5emVyIHN0YXRpc3RpY3MuCisKKyAtLXVzZS1hbmFseXplciBbWGNvZGV8cGF0aCB0byBjbGFuZ10KKyAtLXVzZS1hbmFseXplcj1bWGNvZGV8cGF0aCB0byBjbGFuZ10KKworICAgc2Nhbi1idWlsZCB1c2VzIHRoZSAnY2xhbmcnIGV4ZWN1dGFibGUgcmVsYXRpdmUgdG8gaXRzZWxmIGZvciBzdGF0aWMKKyAgIGFuYWx5c2lzLiBPbmUgY2FuIG92ZXJyaWRlIHRoaXMgYmVoYXZpb3Igd2l0aCB0aGlzIG9wdGlvbiBieSB1c2luZyB0aGUKKyAgICdjbGFuZycgcGFja2FnZWQgd2l0aCBYY29kZSAob24gT1MgWCkgb3IgZnJvbSB0aGUgUEFUSC4KKworIC0ta2VlcC1lbXB0eQorCisgICBEb24ndCByZW1vdmUgdGhlIGJ1aWxkIHJlc3VsdHMgZGlyZWN0b3J5IGV2ZW4gaWYgbm8gaXNzdWVzIHdlcmUgcmVwb3J0ZWQuCisKKyAtLW92ZXJyaWRlLWNvbXBpbGVyCisgICBBbHdheXMgcmVzb3J0IHRvIHRoZSBjY2MtYW5hbHl6ZXIgZXZlbiB3aGVuIGJldHRlciBpbnRlcnBvc2l0aW9uIG1ldGhvZHMKKyAgIGFyZSBhdmFpbGFibGUuCisKKyAtYW5hbHl6ZXItY29uZmlnIDxvcHRpb25zPgorCisgICBQcm92aWRlIG9wdGlvbnMgdG8gcGFzcyB0aHJvdWdoIHRvIHRoZSBhbmFseXplcidzIC1hbmFseXplci1jb25maWcgZmxhZy4KKyAgIFNldmVyYWwgb3B0aW9ucyBhcmUgc2VwYXJhdGVkIHdpdGggY29tbWE6ICdrZXkxPXZhbDEsa2V5Mj12YWwyJworCisgICBBdmFpbGFibGUgb3B0aW9uczoKKyAgICAgKiBzdGFibGUtcmVwb3J0LWZpbGVuYW1lPXRydWUgb3IgZmFsc2UgKGRlZmF1bHQpCisgICAgICAgU3dpdGNoIHRoZSBwYWdlIG5hbWluZyB0bzoKKyAgICAgICByZXBvcnQtPGZpbGVuYW1lPi08ZnVuY3Rpb24vbWV0aG9kIG5hbWU+LTxpZD4uaHRtbAorICAgICAgIGluc3RlYWQgb2YgcmVwb3J0LVhYWFhYWC5odG1sCisKK0NPTlRST0xMSU5HIENIRUNLRVJTOgorCisgQSBkZWZhdWx0IGdyb3VwIG9mIGNoZWNrZXJzIGFyZSBhbHdheXMgcnVuIHVubGVzcyBleHBsaWNpdGx5IGRpc2FibGVkLgorIENoZWNrZXJzIG1heSBiZSBlbmFibGVkL2Rpc2FibGVkIHVzaW5nIHRoZSBmb2xsb3dpbmcgb3B0aW9uczoKKworIC1lbmFibGUtY2hlY2tlciBbY2hlY2tlciBuYW1lXQorIC1kaXNhYmxlLWNoZWNrZXIgW2NoZWNrZXIgbmFtZV0KKworTE9BRElORyBDSEVDS0VSUzoKKworIExvYWRpbmcgZXh0ZXJuYWwgY2hlY2tlcnMgdXNpbmcgdGhlIGNsYW5nIHBsdWdpbiBpbnRlcmZhY2U6CisKKyAtbG9hZC1wbHVnaW4gW3BsdWdpbiBsaWJyYXJ5XQorRU5EVEVYVAorCisgICMgUXVlcnkgY2xhbmcgZm9yIGxpc3Qgb2YgY2hlY2tlcnMgdGhhdCBhcmUgZW5hYmxlZC4KKworICAjIGNyZWF0ZSBhIGxpc3QgdG8gbG9hZCB0aGUgcGx1Z2lucyB2aWEgdGhlICdYY2xhbmcnIGNvbW1hbmQgbGluZQorICAjIGFyZ3VtZW50CisgIG15IEBQbHVnaW5Mb2FkQ29tbWFuZGxpbmVfeGNsYW5nOworICBmb3JlYWNoIG15ICRwYXJhbSAoIEBQbHVnaW5zVG9Mb2FkICkgeworICAgIHB1c2ggKCBAUGx1Z2luTG9hZENvbW1hbmRsaW5lX3hjbGFuZywgIi1YY2xhbmciICk7CisgICAgcHVzaCAoIEBQbHVnaW5Mb2FkQ29tbWFuZGxpbmVfeGNsYW5nLCAkcGFyYW0gKTsKKyAgfQorICBteSAlRW5hYmxlZENoZWNrZXJzOworICBmb3JlYWNoIG15ICRsYW5nICgiYyIsICJvYmplY3RpdmUtYyIsICJvYmplY3RpdmUtYysrIiwgImMrKyIpIHsKKyAgICBwaXBlKEZST01fQ0hJTEQsIFRPX1BBUkVOVCk7CisgICAgbXkgJHBpZCA9IGZvcmsoKTsKKyAgICBpZiAoJHBpZCA9PSAwKSB7CisgICAgICBjbG9zZSBGUk9NX0NISUxEOworICAgICAgb3BlbihTVERPVVQsIj4mIiwgXCpUT19QQVJFTlQpOworICAgICAgb3BlbihTVERFUlIsIj4mIiwgXCpUT19QQVJFTlQpOworICAgICAgZXhlYyAkQ2xhbmcsICggQFBsdWdpbkxvYWRDb21tYW5kbGluZV94Y2xhbmcsICctLWFuYWx5emUnLCAnLXgnLCAkbGFuZywgJy0nLCAnLSMjIycpOworICAgIH0KKyAgICBjbG9zZShUT19QQVJFTlQpOworICAgIHdoaWxlKDxGUk9NX0NISUxEPikgeworICAgICAgZm9yZWFjaCBteSAkdmFsIChzcGxpdCAvXHMrLykgeworICAgICAgICAkdmFsID1+IHMvXCIvL2c7CisgICAgICAgIGlmICgkdmFsID1+IC8tYW5hbHl6ZXItY2hlY2tlclw9KFteXHNdKykvKSB7CisgICAgICAgICAgJEVuYWJsZWRDaGVja2Vyc3skMX0gPSAxOworICAgICAgICB9CisgICAgICB9CisgICAgfQorICAgIHdhaXRwaWQoJHBpZCwwKTsKKyAgICBjbG9zZShGUk9NX0NISUxEKTsKKyAgfQorCisgICMgUXVlcnkgY2xhbmcgZm9yIGNvbXBsZXRlIGxpc3Qgb2YgY2hlY2tlcnMuCisgIGlmIChkZWZpbmVkICRDbGFuZyAmJiAteCAkQ2xhbmcpIHsKKyAgICBwaXBlKEZST01fQ0hJTEQsIFRPX1BBUkVOVCk7CisgICAgbXkgJHBpZCA9IGZvcmsoKTsKKyAgICBpZiAoJHBpZCA9PSAwKSB7CisgICAgICBjbG9zZSBGUk9NX0NISUxEOworICAgICAgb3BlbihTVERPVVQsIj4mIiwgXCpUT19QQVJFTlQpOworICAgICAgb3BlbihTVERFUlIsIj4mIiwgXCpUT19QQVJFTlQpOworICAgICAgZXhlYyAkQ2xhbmcsICgnLWNjMScsIEBQbHVnaW5zVG9Mb2FkICwgJy1hbmFseXplci1jaGVja2VyLWhlbHAnKTsKKyAgICB9CisgICAgY2xvc2UoVE9fUEFSRU5UKTsKKyAgICBteSAkZm91bmRDaGVja2VycyA9IDA7CisgICAgd2hpbGUoPEZST01fQ0hJTEQ+KSB7CisgICAgICBpZiAoL0NIRUNLRVJTOi8pIHsKKyAgICAgICAgJGZvdW5kQ2hlY2tlcnMgPSAxOworICAgICAgICBsYXN0OworICAgICAgfQorICAgIH0KKyAgICBpZiAoISRmb3VuZENoZWNrZXJzKSB7CisgICAgICBwcmludCAiICAqKiogQ291bGQgbm90IHF1ZXJ5IENsYW5nIGZvciB0aGUgbGlzdCBvZiBhdmFpbGFibGUgY2hlY2tlcnMuIjsKKyAgICB9CisgICAgZWxzZSB7CisgICAgICBwcmludCgiXG5BVkFJTEFCTEUgQ0hFQ0tFUlM6XG5cbiIpOworICAgICAgbXkgJHNraXAgPSAwOworICAgICAgd2hpbGUoPEZST01fQ0hJTEQ+KSB7CisgICAgICAgIGlmICgvZXhwZXJpbWVudGFsLykgeworICAgICAgICAgICRza2lwID0gMTsKKyAgICAgICAgICBuZXh0OworICAgICAgICB9CisgICAgICAgIGlmICgkc2tpcCkgeworICAgICAgICAgIG5leHQgaWYgKCEvXlxzXHNbXlxzXS8pOworICAgICAgICAgICRza2lwID0gMDsKKyAgICAgICAgfQorICAgICAgICBzL15cc1xzLy87CisgICAgICAgIGlmICgvXihbXlxzXSspLykgeworICAgICAgICAgICMgSXMgdGhlIGNoZWNrZXIgZW5hYmxlZD8KKyAgICAgICAgICBteSAkY2hlY2tlciA9ICQxOworICAgICAgICAgIG15ICRlbmFibGVkID0gMDsKKyAgICAgICAgICBteSAkYWdncmVnYXRlID0gIiI7CisgICAgICAgICAgZm9yZWFjaCBteSAkZG9tYWluIChzcGxpdCAvXC4vLCAkY2hlY2tlcikgeworICAgICAgICAgICAgJGFnZ3JlZ2F0ZSAuPSAkZG9tYWluOworICAgICAgICAgICAgaWYgKCRFbmFibGVkQ2hlY2tlcnN7JGFnZ3JlZ2F0ZX0pIHsKKyAgICAgICAgICAgICAgJGVuYWJsZWQgPTE7CisgICAgICAgICAgICAgIGxhc3Q7CisgICAgICAgICAgICB9CisgICAgICAgICAgICAjIGFwcGVuZCBhIGRvdCwgaWYgYW4gYWRkaXRpb25hbCBkb21haW4gaXMgYWRkZWQgaW4gdGhlIG5leHQgaXRlcmF0aW9uCisgICAgICAgICAgICAkYWdncmVnYXRlIC49ICIuIjsKKyAgICAgICAgICB9CisKKyAgICAgICAgICBpZiAoJGVuYWJsZWQpIHsKKyAgICAgICAgICAgIHByaW50ICIgKyAiOworICAgICAgICAgIH0KKyAgICAgICAgICBlbHNlIHsKKyAgICAgICAgICAgIHByaW50ICIgICAiOworICAgICAgICAgIH0KKyAgICAgICAgfQorICAgICAgICBlbHNlIHsKKyAgICAgICAgICBwcmludCAiICAgIjsKKyAgICAgICAgfQorICAgICAgICBwcmludCAkXzsKKyAgICAgIH0KKyAgICAgIHByaW50ICJcbk5PVEU6IFwiK1wiIGluZGljYXRlcyB0aGF0IGFuIGFuYWx5c2lzIGlzIGVuYWJsZWQgYnkgZGVmYXVsdC5cbiIKKyAgICB9CisgICAgd2FpdHBpZCgkcGlkLDApOworICAgIGNsb3NlKEZST01fQ0hJTEQpOworICB9CisKK3ByaW50IDw8RU5EVEVYVAorCitCVUlMRCBPUFRJT05TCisKKyBZb3UgY2FuIHNwZWNpZnkgYW55IGJ1aWxkIG9wdGlvbiBhY2NlcHRhYmxlIHRvIHRoZSBidWlsZCBjb21tYW5kLgorCitFWEFNUExFCisKKyBzY2FuLWJ1aWxkIC1vIC90bXAvbXlodG1sZGlyIG1ha2UgLWo0CisKK1RoZSBhYm92ZSBleGFtcGxlIGNhdXNlcyBhbmFseXNpcyByZXBvcnRzIHRvIGJlIGRlcG9zaXRlZCBpbnRvIGEgc3ViZGlyZWN0b3J5CitvZiAiL3RtcC9teWh0bWxkaXIiIGFuZCB0byBydW4gIm1ha2UiIHdpdGggdGhlICItajQiIG9wdGlvbi4gQSBkaWZmZXJlbnQKK3N1YmRpcmVjdG9yeSBpcyBjcmVhdGVkIGVhY2ggdGltZSBzY2FuLWJ1aWxkIGFuYWx5emVzIGEgcHJvamVjdC4gVGhlIGFuYWx5emVyCitzaG91bGQgc3VwcG9ydCBtb3N0IHBhcmFsbGVsIGJ1aWxkcywgYnV0IG5vdCBkaXN0cmlidXRlZCBidWlsZHMuCisKK0VORFRFWFQKK30KKworIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKyMgSHRtbEVzY2FwZSAtIEhUTUwgZW50aXR5IGVuY29kZSBjaGFyYWN0ZXJzIHRoYXQgYXJlIHNwZWNpYWwgaW4gSFRNTAorIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKworc3ViIEh0bWxFc2NhcGUgeworICAjIGNvcHkgYXJndW1lbnQgdG8gbmV3IHZhcmlhYmxlIHNvIHdlIGRvbid0IGNsb2JiZXIgdGhlIG9yaWdpbmFsCisgIG15ICRhcmcgPSBzaGlmdCB8fCAnJzsKKyAgbXkgJHRtcCA9ICRhcmc7CisgICR0bXAgPX4gcy8mLyZhbXA7L2c7CisgICR0bXAgPX4gcy88LyZsdDsvZzsKKyAgJHRtcCA9fiBzLz4vJmd0Oy9nOworICByZXR1cm4gJHRtcDsKK30KKworIyMtLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tIyMKKyMgU2hlbGxFc2NhcGUgLSBiYWNrc2xhc2ggZXNjYXBlIGNoYXJhY3RlcnMgdGhhdCBhcmUgc3BlY2lhbCB0byB0aGUgc2hlbGwKKyMjLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSMjCisKK3N1YiBTaGVsbEVzY2FwZSB7CisgICMgY29weSBhcmd1bWVudCB0byBuZXcgdmFyaWFibGUgc28gd2UgZG9uJ3QgY2xvYmJlciB0aGUgb3JpZ2luYWwKKyAgbXkgJGFyZyA9IHNoaWZ0IHx8ICcnOworICBpZiAoJGFyZyA9fiAvWyJcc10vKSB7IHJldHVybiAiJyIgLiAkYXJnIC4gIiciOyB9CisgIHJldHVybiAkYXJnOworfQorCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworIyBQcm9jZXNzIGNvbW1hbmQtbGluZSBhcmd1bWVudHMuCisjIy0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0jIworCitteSAkQW5hbHl6ZUhlYWRlcnMgPSAwOworbXkgJEh0bWxEaXI7ICAgICAgICAgICAjIFBhcmVudCBkaXJlY3RvcnkgdG8gc3RvcmUgSFRNTCBmaWxlcy4KK215ICRJZ25vcmVFcnJvcnMgPSAwOyAgIyBJZ25vcmUgYnVpbGQgZXJyb3JzLgorbXkgJFZpZXdSZXN1bHRzICA9IDA7ICAjIFZpZXcgcmVzdWx0cyB3aGVuIHRoZSBidWlsZCB0ZXJtaW5hdGVzLgorbXkgJEV4aXRTdGF0dXNGb3VuZEJ1Z3MgPSAwOyAjIEV4aXQgc3RhdHVzIHJlZmxlY3RzIHdoZXRoZXIgYnVncyB3ZXJlIGZvdW5kCitteSAkS2VlcEVtcHR5ICAgID0gMDsgICMgRG9uJ3QgcmVtb3ZlIG91dHB1dCBkaXJlY3RvcnkgZXZlbiB3aXRoIDAgcmVzdWx0cy4KK215IEBBbmFseXNlc1RvUnVuOworbXkgJFN0b3JlTW9kZWw7CitteSAkQ29uc3RyYWludHNNb2RlbDsKK215ICRJbnRlcm5hbFN0YXRzOworbXkgQENvbmZpZ09wdGlvbnM7CitteSAkT3V0cHV0Rm9ybWF0ID0gImh0bWwiOworbXkgJEFuYWx5emVyU3RhdHMgPSAwOworbXkgJE1heExvb3AgPSAwOworbXkgJFJlcXVlc3REaXNwbGF5SGVscCA9IDA7CitteSAkRm9yY2VEaXNwbGF5SGVscCA9IDA7CitteSAkQW5hbHl6ZXJEaXNjb3ZlcnlNZXRob2Q7CisKK2lmICghQEFSR1YpIHsKKyAgJEZvcmNlRGlzcGxheUhlbHAgPSAxCit9CisKK3doaWxlIChAQVJHVikgeworCisgICMgU2NhbiBmb3Igb3B0aW9ucyB3ZSByZWNvZ25pemUuCisKKyAgbXkgJGFyZyA9ICRBUkdWWzBdOworCisgIGlmICgkYXJnIGVxICItaCIgb3IgJGFyZyBlcSAiLS1oZWxwIikgeworICAgICRSZXF1ZXN0RGlzcGxheUhlbHAgPSAxOworICAgIHNoaWZ0IEBBUkdWOworICAgIG5leHQ7CisgIH0KKworICBpZiAoJGFyZyBlcSAnLWFuYWx5emUtaGVhZGVycycpIHsKKyAgICBzaGlmdCBAQVJHVjsKKyAgICAkQW5hbHl6ZUhlYWRlcnMgPSAxOworICAgIG5leHQ7CisgIH0KKworICBpZiAoJGFyZyBlcSAiLW8iKSB7CisgICAgc2hpZnQgQEFSR1Y7CisKKyAgICBpZiAoIUBBUkdWKSB7CisgICAgICBEaWVEaWFnKCInLW8nIG9wdGlvbiByZXF1aXJlcyBhIHRhcmdldCBkaXJlY3RvcnkgbmFtZS5cbiIpOworICAgIH0KKworICAgICMgQ29uc3RydWN0IGFuIGFic29sdXRlIHBhdGguICBVc2VzIHRoZSBjdXJyZW50IHdvcmtpbmcgZGlyZWN0b3J5CisgICAgIyBhcyBhIGJhc2UgaWYgdGhlIG9yaWdpbmFsIHBhdGggd2FzIG5vdCBhYnNvbHV0ZS4KKyAgICAkSHRtbERpciA9IGFic19wYXRoKHNoaWZ0IEBBUkdWKTsKKworICAgIG5leHQ7CisgIH0KKworICBpZiAoJGFyZyA9fiAvXi0taHRtbC10aXRsZSg9KC4rKSk/JC8pIHsKKyAgICBzaGlmdCBAQVJHVjsKKworICAgIGlmICghZGVmaW5lZCAkMiB8fCAkMiBlcSAnJykgeworICAgICAgaWYgKCFAQVJHVikgeworICAgICAgICBEaWVEaWFnKCInLS1odG1sLXRpdGxlJyBvcHRpb24gcmVxdWlyZXMgYSBzdHJpbmcuXG4iKTsKKyAgICAgIH0KKworICAgICAgJEh0bWxUaXRsZSA9IHNoaWZ0IEBBUkdWOworICAgIH0gZWxzZSB7CisgICAgICAkSHRtbFRpdGxlID0gJDI7CisgICAgfQorCisgICAgbmV4dDsKKyAgfQorCisgIGlmICgkYXJnIGVxICItayIgb3IgJGFyZyBlcSAiLS1rZWVwLWdvaW5nIikgeworICAgIHNoaWZ0IEBBUkdWOworICAgICRJZ25vcmVFcnJvcnMgPSAxOworICAgIG5leHQ7CisgIH0KKworICBpZiAoJGFyZyA9fiAvXi0tdXNlLWNjKD0oLispKT8kLykgeworICAgIHNoaWZ0IEBBUkdWOworICAgIG15ICRjYzsKKworICAgIGlmICghZGVmaW5lZCAkMiB8fCAkMiBlcSAiIikgeworICAgICAgaWYgKCFAQVJHVikgeworICAgICAgICBEaWVEaWFnKCInLS11c2UtY2MnIG9wdGlvbiByZXF1aXJlcyBhIGNvbXBpbGVyIGV4ZWN1dGFibGUgbmFtZS5cbiIpOworICAgICAgfQorICAgICAgJGNjID0gc2hpZnQgQEFSR1Y7CisgICAgfQorICAgIGVsc2UgeworICAgICAgJGNjID0gJDI7CisgICAgfQorCisgICAgJEVOVnsiQ0NDX0NDIn0gPSAkY2M7CisgICAgbmV4dDsKKyAgfQorCisgIGlmICgkYXJnID1+IC9eLS11c2UtY1wrXCsoPSguKykpPyQvKSB7CisgICAgc2hpZnQgQEFSR1Y7CisgICAgbXkgJGN4eDsKKworICAgIGlmICghZGVmaW5lZCAkMiB8fCAkMiBlcSAiIikgeworICAgICAgaWYgKCFAQVJHVikgeworICAgICAgICBEaWVEaWFnKCInLS11c2UtYysrJyBvcHRpb24gcmVxdWlyZXMgYSBjb21waWxlciBleGVjdXRhYmxlIG5hbWUuXG4iKTsKKyAgICAgIH0KKyAgICAgICRjeHggPSBzaGlmdCBAQVJHVjsKKyAgICB9CisgICAgZWxzZSB7CisgICAgICAkY3h4ID0gJDI7CisgICAgfQorCisgICAgJEVOVnsiQ0NDX0NYWCJ9ID0gJGN4eDsKKyAgICBuZXh0OworICB9CisKKyAgaWYgKCRhcmcgZXEgIi12IikgeworICAgIHNoaWZ0IEBBUkdWOworICAgICRWZXJib3NlKys7CisgICAgbmV4dDsKKyAgfQorCisgIGlmICgkYXJnIGVxICItViIgb3IgJGFyZyBlcSAiLS12aWV3IikgeworICAgIHNoaWZ0IEBBUkdWOworICAgICRWaWV3UmVzdWx0cyA9IDE7CisgICAgbmV4dDsKKyAgfQorCisgIGlmICgkYXJnIGVxICItLXN0YXR1cy1idWdzIikgeworICAgIHNoaWZ0IEBBUkdWOworICAgICRFeGl0U3RhdHVzRm91bmRCdWdzID0gMTsKKyAgICBuZXh0OworICB9CisKKyAgaWYgKCRhcmcgZXEgIi1zdG9yZSIpIHsKKyAgICBzaGlmdCBAQVJHVjsKKyAgICAkU3RvcmVNb2RlbCA9IHNoaWZ0IEBBUkdWOworICAgIG5leHQ7CisgIH0KKworICBpZiAoJGFyZyBlcSAiLWNvbnN0cmFpbnRzIikgeworICAgIHNoaWZ0IEBBUkdWOworICAgICRDb25zdHJhaW50c01vZGVsID0gc2hpZnQgQEFSR1Y7CisgICAgbmV4dDsKKyAgfQorCisgIGlmICgkYXJnIGVxICItaW50ZXJuYWwtc3RhdHMiKSB7CisgICAgc2hpZnQgQEFSR1Y7CisgICAgJEludGVybmFsU3RhdHMgPSAxOworICAgIG5leHQ7CisgIH0KKworICBpZiAoJGFyZyBlcSAiLXBsaXN0IikgeworICAgIHNoaWZ0IEBBUkdWOworICAgICRPdXRwdXRGb3JtYXQgPSAicGxpc3QiOworICAgIG5leHQ7CisgIH0KKyAgaWYgKCRhcmcgZXEgIi1wbGlzdC1odG1sIikgeworICAgIHNoaWZ0IEBBUkdWOworICAgICRPdXRwdXRGb3JtYXQgPSAicGxpc3QtaHRtbCI7CisgICAgbmV4dDsKKyAgfQorCisgIGlmICgkYXJnIGVxICItYW5hbHl6ZXItY29uZmlnIikgeworICAgIHNoaWZ0IEBBUkdWOworICAgIHB1c2ggQENvbmZpZ09wdGlvbnMsICItYW5hbHl6ZXItY29uZmlnIiwgc2hpZnQgQEFSR1Y7CisgICAgbmV4dDsKKyAgfQorCisgIGlmICgkYXJnIGVxICItbm8tZmFpbHVyZS1yZXBvcnRzIikgeworICAgIHNoaWZ0IEBBUkdWOworICAgICRFTlZ7IkNDQ19SRVBPUlRfRkFJTFVSRVMifSA9IDA7CisgICAgbmV4dDsKKyAgfQorICBpZiAoJGFyZyBlcSAiLXN0YXRzIikgeworICAgIHNoaWZ0IEBBUkdWOworICAgICRBbmFseXplclN0YXRzID0gMTsKKyAgICBuZXh0OworICB9CisgIGlmICgkYXJnIGVxICItbWF4bG9vcCIpIHsKKyAgICBzaGlmdCBAQVJHVjsKKyAgICAkTWF4TG9vcCA9IHNoaWZ0IEBBUkdWOworICAgIG5leHQ7CisgIH0KKyAgaWYgKCRhcmcgZXEgIi1lbmFibGUtY2hlY2tlciIpIHsKKyAgICBzaGlmdCBAQVJHVjsKKyAgICBwdXNoIEBBbmFseXNlc1RvUnVuLCAiLWFuYWx5emVyLWNoZWNrZXIiLCBzaGlmdCBAQVJHVjsKKyAgICBuZXh0OworICB9CisgIGlmICgkYXJnIGVxICItZGlzYWJsZS1jaGVja2VyIikgeworICAgIHNoaWZ0IEBBUkdWOworICAgIHB1c2ggQEFuYWx5c2VzVG9SdW4sICItYW5hbHl6ZXItZGlzYWJsZS1jaGVja2VyIiwgc2hpZnQgQEFSR1Y7CisgICAgbmV4dDsKKyAgfQorICBpZiAoJGFyZyBlcSAiLWxvYWQtcGx1Z2luIikgeworICAgIHNoaWZ0IEBBUkdWOworICAgIHB1c2ggQFBsdWdpbnNUb0xvYWQsICItbG9hZCIsIHNoaWZ0IEBBUkdWOworICAgIG5leHQ7CisgIH0KKyAgaWYgKCRhcmcgZXEgIi0tdXNlLWFuYWx5emVyIikgeworICAgICBzaGlmdCBAQVJHVjsKKyAgICAgICRBbmFseXplckRpc2NvdmVyeU1ldGhvZCA9IHNoaWZ0IEBBUkdWOworICAgIG5leHQ7CisgIH0KKyAgaWYgKCRhcmcgPX4gL14tLXVzZS1hbmFseXplcj0oLispJC8pIHsKKyAgICBzaGlmdCBAQVJHVjsKKyAgICAkQW5hbHl6ZXJEaXNjb3ZlcnlNZXRob2QgPSAkMTsKKyAgICBuZXh0OworICB9CisgIGlmICgkYXJnIGVxICItLWtlZXAtZW1wdHkiKSB7CisgICAgc2hpZnQgQEFSR1Y7CisgICAgJEtlZXBFbXB0eSA9IDE7CisgICAgbmV4dDsKKyAgfQorCisgIGlmICgkYXJnIGVxICItLW92ZXJyaWRlLWNvbXBpbGVyIikgeworICAgIHNoaWZ0IEBBUkdWOworICAgICRPdmVycmlkZUNvbXBpbGVyID0gMTsKKyAgICBuZXh0OworICB9CisKKyAgRGllRGlhZygidW5yZWNvZ25pemVkIG9wdGlvbiAnJGFyZydcbiIpIGlmICgkYXJnID1+IC9eLS8pOworCisgIGxhc3Q7Cit9CisKK2lmICghQEFSR1YgYW5kICEkUmVxdWVzdERpc3BsYXlIZWxwKSB7CisgIEVycm9yRGlhZygiTm8gYnVpbGQgY29tbWFuZCBzcGVjaWZpZWQuXG5cbiIpOworICAkRm9yY2VEaXNwbGF5SGVscCA9IDE7Cit9CisKKyMgRmluZCAnY2xhbmcnCitpZiAoIWRlZmluZWQgJEFuYWx5emVyRGlzY292ZXJ5TWV0aG9kKSB7CisgICRDbGFuZyA9IEN3ZDo6cmVhbHBhdGgoIiRSZWFsQmluL2Jpbi9jbGFuZyIpOworICBpZiAoIWRlZmluZWQgJENsYW5nIHx8ICEgLXggJENsYW5nKSB7CisgICAgJENsYW5nID0gQ3dkOjpyZWFscGF0aCgiJFJlYWxCaW4vY2xhbmciKTsKKyAgfQorICBpZiAoIWRlZmluZWQgJENsYW5nIHx8ICEgLXggJENsYW5nKSB7CisgICAgaWYgKCEkUmVxdWVzdERpc3BsYXlIZWxwICYmICEkRm9yY2VEaXNwbGF5SGVscCkgeworICAgICAgRGllRGlhZygiZXJyb3I6IENhbm5vdCBmaW5kIGFuIGV4ZWN1dGFibGUgJ2NsYW5nJyByZWxhdGl2ZSB0byBzY2FuLWJ1aWxkLiIgLgorICAgICAgICAgICAgICAgICAiICBDb25zaWRlciB1c2luZyAtLXVzZS1hbmFseXplciB0byBwaWNrIGEgdmVyc2lvbiBvZiAnY2xhbmcnIHRvIHVzZSBmb3Igc3RhdGljIGFuYWx5c2lzLlxuIik7CisgICAgfQorICB9Cit9CitlbHNlIHsKKyAgaWYgKCRBbmFseXplckRpc2NvdmVyeU1ldGhvZCA9fiAvXltYeF1jb2RlJC8pIHsKKyAgICBteSAkeGNydW4gPSBgd2hpY2ggeGNydW5gOworICAgIGNob21wICR4Y3J1bjsKKyAgICBpZiAoJHhjcnVuIGVxICIiKSB7CisgICAgICAgIERpZURpYWcoIkNhbm5vdCBmaW5kICd4Y3J1bicgdG8gZmluZCAnY2xhbmcnIGZvciBhbmFseXNpcy5cbiIpOworICAgIH0KKyAgICAkQ2xhbmcgPSBgJHhjcnVuIC10b29sY2hhaW4gWGNvZGVEZWZhdWx0IC1maW5kIGNsYW5nYDsKKyAgICBjaG9tcCAkQ2xhbmc7CisgICAgaWYgKCRDbGFuZyBlcSAiIikgeworICAgICAgRGllRGlhZygiTm8gJ2NsYW5nJyBleGVjdXRhYmxlIGZvdW5kIGJ5ICd4Y3J1bidcbiIpOworICAgIH0KKyAgfQorICBlbHNlIHsKKyAgICAkQ2xhbmcgPSAkQW5hbHl6ZXJEaXNjb3ZlcnlNZXRob2Q7CisgICAgaWYgKCFkZWZpbmVkICRDbGFuZyBvciBub3QgLXggJENsYW5nKSB7CisgICAgICAgICBEaWVEaWFnKCJDYW5ub3QgZmluZCBhbiBleGVjdXRhYmxlIGNsYW5nIGF0ICckQW5hbHl6ZXJEaXNjb3ZlcnlNZXRob2QnXG4iKTsKKyAgICB9CisgIH0KK30KKworaWYgKCRGb3JjZURpc3BsYXlIZWxwIHx8ICRSZXF1ZXN0RGlzcGxheUhlbHApIHsKKyAgRGlzcGxheUhlbHAoKTsKKyAgZXhpdCAkRm9yY2VEaXNwbGF5SGVscDsKK30KKworJENsYW5nQ1hYID0gJENsYW5nOworIyBEZXRlcm1pbmUgb3BlcmF0aW5nIHN5c3RlbSB1bmRlciB3aGljaCB0aGlzIGNvcHkgb2YgUGVybCB3YXMgYnVpbHQuCitteSAkSXNXaW5CdWlsZCA9ICgkXk8gPX4vbXN5c3xjeWd3aW58TVNXaW4zMi8pOworaWYoJElzV2luQnVpbGQpIHsKKyAgJENsYW5nQ1hYID1+IHMvLmV4ZSQvKysuZXhlLzsKK30KK2Vsc2UgeworICAkQ2xhbmdDWFggPX4gcy9cLVxkK1wuXGQrJC8vOworICAkQ2xhbmdDWFggLj0gIisrIjsKK30KKworIyBNYWtlIHN1cmUgdG8gdXNlICIiIHRvIGhhbmRsZSBwYXRocyB3aXRoIHNwYWNlcy4KKyRDbGFuZ1ZlcnNpb24gPSBIdG1sRXNjYXBlKGAiJENsYW5nIiAtLXZlcnNpb25gKTsKKworIyBEZXRlcm1pbmUgd2hlcmUgcmVzdWx0cyBnby4KKyRDbWRBcmdzID0gSHRtbEVzY2FwZShqb2luKCcgJywgbWFwKFNoZWxsRXNjYXBlKCRfKSwgQEFSR1YpKSk7CiskSHRtbFRpdGxlID0gIiR7Q3VycmVudERpclN1ZmZpeH0gLSBzY2FuLWJ1aWxkIHJlc3VsdHMiCisgIHVubGVzcyAoZGVmaW5lZCgkSHRtbFRpdGxlKSk7CisKKyMgRGV0ZXJtaW5lIHRoZSBvdXRwdXQgZGlyZWN0b3J5IGZvciB0aGUgSFRNTCByZXBvcnRzLgorbXkgJEJhc2VEaXIgPSAkSHRtbERpcjsKKyRIdG1sRGlyID0gR2V0SFRNTFJ1bkRpcigkSHRtbERpcik7CisKKyMgRGV0ZXJtaW5lIHRoZSBsb2NhdGlvbiBvZiBjY2MtYW5hbHl6ZXIuCitteSAkQWJzUmVhbEJpbiA9IEN3ZDo6cmVhbHBhdGgoJFJlYWxCaW4pOworbXkgJENtZCA9ICIkQWJzUmVhbEJpbi9saWJleGVjL2NjYy1hbmFseXplciI7CitteSAkQ21kQ1hYID0gIiRBYnNSZWFsQmluL2xpYmV4ZWMvYysrLWFuYWx5emVyIjsKKworIyBQb3J0YWJpbGl0eTogdXNlIGxlc3Mgc3RyaWN0IGJ1dCBwb3J0YWJsZSBjaGVjayAtZSAoZmlsZSBleGlzdHMpIGluc3RlYWQgb2YKKyMgbm9uLXBvcnRhYmxlIC14IChmaWxlIGlzIGV4ZWN1dGFibGUpLiBPbiBzb21lIHdpbmRvd3MgcG9ydHMgLXgganVzdCBjaGVja3MKKyMgZmlsZSBleHRlbnNpb24gdG8gZGV0ZXJtaW5lIGlmIGEgZmlsZSBpcyBleGVjdXRhYmxlIChzZWUgUGVybCBsYW5ndWFnZQorIyByZWZlcmVuY2UsIHBlcmxwb3J0KQoraWYgKCFkZWZpbmVkICRDbWQgfHwgISAtZSAkQ21kKSB7CisgICRDbWQgPSAiJEFic1JlYWxCaW4vY2NjLWFuYWx5emVyIjsKKyAgRGllRGlhZygiJ2NjYy1hbmFseXplcicgZG9lcyBub3QgZXhpc3QgYXQgJyRDbWQnXG4iKSBpZighIC1lICRDbWQpOworfQoraWYgKCFkZWZpbmVkICRDbWRDWFggfHwgISAtZSAkQ21kQ1hYKSB7CisgICRDbWRDWFggPSAiJEFic1JlYWxCaW4vYysrLWFuYWx5emVyIjsKKyAgRGllRGlhZygiJ2MrKy1hbmFseXplcicgZG9lcyBub3QgZXhpc3QgYXQgJyRDbWRDWFgnXG4iKSBpZighIC1lICRDbWRDWFgpOworfQorCitEaWFnKCJVc2luZyAnJENsYW5nJyBmb3Igc3RhdGljIGFuYWx5c2lzXG4iKTsKKworU2V0SHRtbEVudihcQEFSR1YsICRIdG1sRGlyKTsKK2lmICgkQW5hbHl6ZUhlYWRlcnMpIHsgcHVzaCBAQW5hbHlzZXNUb1J1biwiLWFuYWx5emVyLW9wdC1hbmFseXplLWhlYWRlcnMiOyB9CitpZiAoJEFuYWx5emVyU3RhdHMpIHsgcHVzaCBAQW5hbHlzZXNUb1J1biwgJy1hbmFseXplci1jaGVja2VyPWRlYnVnLlN0YXRzJzsgfQoraWYgKCRNYXhMb29wID4gMCkgeyBwdXNoIEBBbmFseXNlc1RvUnVuLCAiLWFuYWx5emVyLW1heC1sb29wICRNYXhMb29wIjsgfQorCisjIERlbGF5IHNldHRpbmcgdXAgb3RoZXIgZW52aXJvbm1lbnQgdmFyaWFibGVzIGluIGNhc2Ugd2UgY2FuIGRvIHRydWUKKyMgaW50ZXJwb3NpdGlvbi4KK215ICRDQ0NfQU5BTFlaRVJfQU5BTFlTSVMgPSBqb2luICcgJyxAQW5hbHlzZXNUb1J1bjsKK215ICRDQ0NfQU5BTFlaRVJfUExVR0lOUyA9IGpvaW4gJyAnLEBQbHVnaW5zVG9Mb2FkOworbXkgJENDQ19BTkFMWVpFUl9DT05GSUcgPSBqb2luICcgJyxAQ29uZmlnT3B0aW9uczsKK215ICVPcHRpb25zID0gKAorICAnQ0MnID0+ICRDbWQsCisgICdDWFgnID0+ICRDbWRDWFgsCisgICdDTEFORycgPT4gJENsYW5nLAorICAnQ0xBTkdfQ1hYJyA9PiAkQ2xhbmdDWFgsCisgICdWRVJCT1NFJyA9PiAkVmVyYm9zZSwKKyAgJ0NDQ19BTkFMWVpFUl9BTkFMWVNJUycgPT4gJENDQ19BTkFMWVpFUl9BTkFMWVNJUywKKyAgJ0NDQ19BTkFMWVpFUl9QTFVHSU5TJyA9PiAkQ0NDX0FOQUxZWkVSX1BMVUdJTlMsCisgICdDQ0NfQU5BTFlaRVJfQ09ORklHJyA9PiAkQ0NDX0FOQUxZWkVSX0NPTkZJRywKKyAgJ09VVFBVVF9ESVInID0+ICRIdG1sRGlyCispOworCitpZiAoZGVmaW5lZCAkU3RvcmVNb2RlbCkgeworICAkT3B0aW9uc3snQ0NDX0FOQUxZWkVSX1NUT1JFX01PREVMJ30gPSAkU3RvcmVNb2RlbDsKK30KK2lmIChkZWZpbmVkICRDb25zdHJhaW50c01vZGVsKSB7CisgICRPcHRpb25zeydDQ0NfQU5BTFlaRVJfQ09OU1RSQUlOVFNfTU9ERUwnfSA9ICRDb25zdHJhaW50c01vZGVsOworfQoraWYgKGRlZmluZWQgJEludGVybmFsU3RhdHMpIHsKKyAgJE9wdGlvbnN7J0NDQ19BTkFMWVpFUl9JTlRFUk5BTF9TVEFUUyd9ID0gMTsKK30KK2lmIChkZWZpbmVkICRPdXRwdXRGb3JtYXQpIHsKKyAgJE9wdGlvbnN7J0NDQ19BTkFMWVpFUl9PVVRQVVRfRk9STUFUJ30gPSAkT3V0cHV0Rm9ybWF0OworfQorCisjIFJ1biB0aGUgYnVpbGQuCitteSAkRXhpdFN0YXR1cyA9IFJ1bkJ1aWxkQ29tbWFuZChcQEFSR1YsICRJZ25vcmVFcnJvcnMsICRDbWQsICRDbWRDWFgsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIFwlT3B0aW9ucyk7CisKK2lmIChkZWZpbmVkICRPdXRwdXRGb3JtYXQpIHsKKyAgaWYgKCRPdXRwdXRGb3JtYXQgPX4gL3BsaXN0LykgeworICAgIERpYWcgIkFuYWx5c2lzIHJ1biBjb21wbGV0ZS5cbiI7CisgICAgRGlhZyAiQW5hbHlzaXMgcmVzdWx0cyAocGxpc3QgZmlsZXMpIGRlcG9zaXRlZCBpbiAnJEh0bWxEaXInXG4iOworICB9CisgIGlmICgkT3V0cHV0Rm9ybWF0ID1+IC9odG1sLykgeworICAgICMgUG9zdHByb2Nlc3MgdGhlIEhUTUwgZGlyZWN0b3J5LgorICAgIG15ICROdW1CdWdzID0gUG9zdHByb2Nlc3MoJEh0bWxEaXIsICRCYXNlRGlyLCAkQW5hbHl6ZXJTdGF0cywgJEtlZXBFbXB0eSk7CisKKyAgICBpZiAoJFZpZXdSZXN1bHRzIGFuZCAtciAiJEh0bWxEaXIvaW5kZXguaHRtbCIpIHsKKyAgICAgIERpYWcgIkFuYWx5c2lzIHJ1biBjb21wbGV0ZS5cbiI7CisgICAgICBEaWFnICJWaWV3aW5nIGFuYWx5c2lzIHJlc3VsdHMgaW4gJyRIdG1sRGlyJyB1c2luZyBzY2FuLXZpZXcuXG4iOworICAgICAgbXkgJFNjYW5WaWV3ID0gQ3dkOjpyZWFscGF0aCgiJFJlYWxCaW4vc2Nhbi12aWV3Iik7CisgICAgICBpZiAoISAteCAkU2NhblZpZXcpIHsgJFNjYW5WaWV3ID0gInNjYW4tdmlldyI7IH0KKyAgICAgIGV4ZWMgJFNjYW5WaWV3LCAiJEh0bWxEaXIiOworICAgIH0KKworICAgIGlmICgkRXhpdFN0YXR1c0ZvdW5kQnVncykgeworICAgICAgZXhpdCAxIGlmICgkTnVtQnVncyA+IDApOworICAgICAgZXhpdCAwOworICAgIH0KKyAgfQorfQorCitleGl0ICRFeGl0U3RhdHVzOwpkaWZmIC0tZ2l0IGEvdG9vbHMvc2Nhbi1idWlsZC9zY2FuLWJ1aWxkLjEgYi90b29scy9zY2FuLWJ1aWxkL3NjYW4tYnVpbGQuMQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zZDNhOWY4Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvc2Nhbi1idWlsZC9zY2FuLWJ1aWxkLjEKQEAgLTAsMCArMSwzNDkgQEAKKy5cIiBUaGlzIGZpbGUgaXMgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIFVuaXZlcnNpdHkgb2YgSWxsaW5vaXMgT3BlbiBTb3VyY2UKKy5cIiBMaWNlbnNlLiBTZWUgTElDRU5TRS5UWFQgZm9yIGRldGFpbHMuCisuXCIgJElkJAorLkRkIE1heSAyNSwgMjAxMgorLkR0IFNDQU4tQlVJTEQgMQorLk9zICJjbGFuZyIgIjMuNSIKKy5TaCBOQU1FCisuTm0gc2Nhbi1idWlsZAorLk5kIENsYW5nIHN0YXRpYyBhbmFseXplcgorLlNoIFNZTk9QU0lTCisuTm0KKy5PcCBGbCBvaGt2VgorLk9wIEZsIGFuYWx5emUtaGVhZGVycworLk9wIEZsIGVuYWJsZS1jaGVja2VyIE9wIEFyIGNoZWNrZXJfbmFtZQorLk9wIEZsIGRpc2FibGUtY2hlY2tlciBPcCBBciBjaGVja2VyX25hbWUKKy5PcCBGbCBGbCBoZWxwCisuT3AgRmwgRmwgaGVscC1jaGVja2VycworLk9wIEZsIEZsIGh0bWwtdGl0bGUgT3AgQXIgPXRpdGxlCisuT3AgRmwgRmwga2VlcC1nb2luZworLk9wIEZsIHBsaXN0CisuT3AgRmwgcGxpc3QtaHRtbAorLk9wIEZsIEZsIHN0YXR1cy1idWdzCisuT3AgRmwgRmwgdXNlLWMrKyBPcCBBciA9Y29tcGlsZXJfcGF0aAorLk9wIEZsIEZsIHVzZS1jYyBPcCBBciA9Y29tcGlsZXJfcGF0aAorLk9wIEZsIEZsIHZpZXcKKy5PcCBGbCBjb25zdHJhaW50cyBPcCBBciBtb2RlbAorLk9wIEZsIG1heGxvb3AgQXIgTgorLk9wIEZsIG5vLWZhaWx1cmUtcmVwb3J0cworLk9wIEZsIHN0YXRzCisuT3AgRmwgc3RvcmUgT3AgQXIgbW9kZWwKKy5BciBidWlsZF9jb21tYW5kCisuT3AgYnVpbGRfb3B0aW9ucworLlwiCisuXCIgU2ggREVTQ1JJUFRJT04KKy5TaCBERVNDUklQVElPTgorLk5tCitpcyBhIFBlcmwgc2NyaXB0IHRoYXQgaW52b2tlcyB0aGUgQ2xhbmcgc3RhdGljIGFuYWx5emVyLiAgT3B0aW9ucyB1c2VkIGJ5CisuTm0KK29yIGJ5IHRoZSBhbmFseXplciBhcHBlYXIgZmlyc3QsIGZvbGxvd2VkIGJ5IHRoZQorLkFyIGJ1aWxkX2NvbW1hbmQKK2FuZCBhbnkKKy5BciBidWlsZF9vcHRpb25zCitub3JtYWxseSB1c2VkIHRvIGJ1aWxkIHRoZSB0YXJnZXQgc3lzdGVtLgorLlBwCitUaGUgc3RhdGljIGFuYWx5emVyIGVtcGxveXMgYSBsb25nIGxpc3Qgb2YgY2hlY2tpbmcgYWxnb3JpdGhtcywgc2VlCisuU3ggQ0hFQ0tFUlMgLgorT3V0cHV0IGNhbiBiZSB3cml0dGVuIGluIHN0YW5kYXJkCisuTGkgLnBsaXN0CithbmQvb3IgSFRNTCBmb3JtYXQuCisuUHAKK1RoZSBmb2xsb3dpbmcgb3B0aW9ucyBhcmUgc3VwcG9ydGVkOgorLkJsIC10YWcgLXdpZHRoIGluZGVudAorLkl0IEZsIGFuYWx5emUtaGVhZGVycworQWxzbyBhbmFseXplIGZ1bmN0aW9ucyBpbiAjaW5jbHVkZWQgZmlsZXMuCisuSXQgRmwgZW5hYmxlLWNoZWNrZXIgQXIgY2hlY2tlcl9uYW1lICwgRmwgZGlzYWJsZS1jaGVja2VyIEFyIGNoZWNrZXJfbmFtZQorRW5hYmxlL2Rpc2FibGUKKy5BciBjaGVja2VyX25hbWUgLgorU2VlCisuU3ggQ0hFQ0tFUlMgLgorLkl0IEZsIGggLCBGbCBGbCBoZWxwCitEaXNwbGF5IHRoaXMgbWVzc2FnZS4KKy5JdCBGbCBGbCBoZWxwLWNoZWNrZXJzCitMaXN0IGRlZmF1bHQgY2hlY2tlcnMsIHNlZQorLlN4IENIRUNLRVJTIC4KKy5JdCBGbCBGbCBodG1sLXRpdGxlIE5zIE9wID0gTnMgQXIgdGl0bGUKK1NwZWNpZnkgdGhlIHRpdGxlIHVzZWQgb24gZ2VuZXJhdGVkIEhUTUwgcGFnZXMuCitBIGRlZmF1bHQgdGl0bGUgaXMgZ2VuZXJhdGVkIGlmCisuQXIgdGl0bGUKK2lzIG5vdCBzcGVjaWZpZWQuCisuSXQgRmwgayAsIEZsIEZsIGtlZXAtZ29pbmcKK0FkZCBhCisuRHEga2VlcCBvbiBnb2luZworb3B0aW9uIHRvCisuQXIgYnVpbGRfY29tbWFuZCAuCitDdXJyZW50bHkgc3VwcG9ydHMgbWFrZSBhbmQgeGNvZGVidWlsZC4gVGhpcyBpcyBhIGNvbnZlbmllbmNlIG9wdGlvbjsKK29uZSBjYW4gc3BlY2lmeSB0aGlzIGJlaGF2aW9yIGRpcmVjdGx5IHVzaW5nIGJ1aWxkIG9wdGlvbnMuCisuSXQgRmwgbworVGFyZ2V0IGRpcmVjdG9yeSBmb3IgSFRNTCByZXBvcnQgZmlsZXMuICBTdWJkaXJlY3RvcmllcyB3aWxsIGJlCitjcmVhdGVkIGFzIG5lZWRlZCB0byByZXByZXNlbnQgc2VwYXJhdGUgaW52b2NhdGlvbnMKK29mIHRoZSBhbmFseXplci4gIElmIHRoaXMgb3B0aW9uIGlzIG5vdCBzcGVjaWZpZWQsIGEgZGlyZWN0b3J5IGlzCitjcmVhdGVkIGluIC90bXAgKFRNUERJUiBvbiBNYWMgT1MgWCkgdG8gc3RvcmUgdGhlIHJlcG9ydHMuCisuSXQgRmwgcGxpc3QKK091dHB1dCB0aGUgcmVzdWx0cyBhcyBhIHNldCBvZgorLkxpIC5wbGlzdAorZmlsZXMuIChCeSBkZWZhdWx0IHRoZSBvdXRwdXQgb2YKKy5ObQoraXMgYSBzZXQgb2YgSFRNTCBmaWxlcy4pCisuSXQgRmwgcGxpc3QtaHRtbAorT3V0cHV0IHRoZSByZXN1bHRzIGFzIGEgc2V0IG9mIEhUTUwgYW5kIC5wbGlzdCBmaWxlcworLkl0IEZsIEZsIHN0YXR1cy1idWdzCitTZXQgZXhpdCBzdGF0dXMgdG8gMSBpZiBpdCBmb3VuZCBwb3RlbnRpYWwgYnVncyBhbmQgMCBvdGhlcndpc2UuIEJ5CitkZWZhdWx0IHRoZSBleGl0IHN0YXR1cyBvZgorLk5tCitpcyB0aGF0IHJldHVybmVkIGJ5CisuQXIgYnVpbGRfY29tbWFuZCAuCisuSXQgRmwgRmwgdXNlLWMrKyBOcyBPcCA9IE5zIEFyIGNvbXBpbGVyX3BhdGgKK0d1ZXNzIHRoZSBkZWZhdWx0IGNvbXBpbGVyIGZvciB5b3VyIEMrKyBhbmQgT2JqZWN0aXZlLUMrKyBjb2RlLiBVc2UgdGhpcworb3B0aW9uIHRvIHNwZWNpZnkgYW4gYWx0ZXJuYXRlIGNvbXBpbGVyLgorLkl0IEZsIEZsIHVzZS1jYyBOcyBPcCA9IE5zIEFyIGNvbXBpbGVyX3BhdGgKK0d1ZXNzIHRoZSBkZWZhdWx0IGNvbXBpbGVyIGZvciB5b3VyIEMgYW5kIE9iamVjdGl2ZS1DIGNvZGUuIFVzZSB0aGlzCitvcHRpb24gdG8gc3BlY2lmeSBhbiBhbHRlcm5hdGUgY29tcGlsZXIuCisuSXQgRmwgdgorVmVyYm9zZSBvdXRwdXQgZnJvbQorLk5tCithbmQgdGhlIGFuYWx5emVyLiBBIHNlY29uZCBhbmQKK3RoaXJkCisuQXIgdgoraW5jcmVhc2VzIHZlcmJvc2l0eS4KKy5JdCBGbCBWICwgRmwgRmwgdmlldworVmlldyBhbmFseXNpcyByZXN1bHRzIGluIGEgd2ViIGJyb3dzZXIgd2hlbiB0aGUgYnVpbGQgY29tcGxldGVzLgorLkl0IEZsIGNvbnN0cmFpbnRzIE9wIEFyIG1vZGVsCitTcGVjaWZ5IHRoZSBjb250cmFpbnQgZW5naW5lIHVzZWQgYnkgdGhlIGFuYWx5emVyLiAgQnkgZGVmYXVsdCB0aGUKKy5RbCByYW5nZQorbW9kZWwgaXMgdXNlZC4gIFNwZWNpZnlpbmcKKy5RbCBiYXNpYwordXNlcyBhIHNpbXBsZXIsIGxlc3MgcG93ZXJmdWwgY29uc3RyYWludCBtb2RlbCB1c2VkIGJ5IGNoZWNrZXItMC4xNjAKK2FuZCBlYXJsaWVyLgorLkl0IEZsIG1heGxvb3AgQXIgTgorU3BlY2lmaXkgdGhlIG51bWJlciBvZiB0aW1lcyBhIGJsb2NrIGNhbiBiZSB2aXNpdGVkIGJlZm9yZSBnaXZpbmcKK3VwLiBEZWZhdWx0IGlzIDQuIEluY3JlYXNlIGZvciBtb3JlIGNvbXByZWhlbnNpdmUgY292ZXJhZ2UgYXQgYQorY29zdCBvZiBzcGVlZC4KKy5JdCBGbCBuby1mYWlsdXJlLXJlcG9ydHMKK0RvIG5vdCBjcmVhdGUgYQorLlFsIGZhaWx1cmVzCitzdWJkaXJlY3RvcnkgdGhhdCBpbmNsdWRlcyBhbmFseXplciBjcmFzaCByZXBvcnRzIGFuZCBwcmVwcm9jZXNzZWQKK3NvdXJjZSBmaWxlcy4KKy5JdCBGbCBzdGF0cworR2VuZXJhdGVzIHZpc2l0YXRpb24gc3RhdGlzdGljcyBmb3IgdGhlIHByb2plY3QgYmVpbmcgYW5hbHl6ZWQuCisuSXQgRmwgc3RvcmUgT3AgQXIgbW9kZWwKK1NwZWNpZnkgdGhlIHN0b3JlIG1vZGVsIHVzZWQgYnkgdGhlIGFuYWx5emVyLiBCeSBkZWZhdWx0LCB0aGUKKy5RbCByZWdpb24KK3N0b3JlIG1vZGVsIGlzIHVzZWQuCisuUWwgcmVnaW9uCitzcGVjaWZpZXMgYSBmaWVsZC0KK3NlbnNpdGl2ZSBzdG9yZSBtb2RlbC4gVXNlcnMgY2FuIGFsc28gc3BlY2lmeQorLlFsIGJhc2ljCit3aGljaCBpcyBmYXIgbGVzcyBwcmVjaXNlIGJ1dCBjYW4gbW9yZSBxdWlja2x5IGFuYWx5emUgY29kZS4KKy5RbCBiYXNpYword2FzIHRoZSBkZWZhdWx0IHN0b3JlIG1vZGVsIGZvciBjaGVja2VyLTAuMjIxIGFuZCBlYXJsaWVyLgorLlwiCisuRWwKKy5TaCBFWElUIFNUQVRVUworLk5tCityZXR1cm5zIHRoZSB2YWx1ZSByZXR1cm5lZCBieQorLkFyIGJ1aWxkX2NvbW1hbmQKK3VubGVzcworLkZsIEZsIHN0YXR1cy1idWdzCitvcgorLkZsIEZsIGtlZXAtZ29pbmcKK2lzIHVzZWQuCisuXCIKKy5cIiBPdGhlciBzZWN0aW9ucyBub3QgeWV0IHVzZWQgLi4uCisuXCIgLlNoIEVOVklST05NRU5UCisuXCIgLlNoIEZJTEVTCisuXCIgLlNoIERJQUdOT1NUSUNTCisuXCIgLlNoIENPTVBBVElCSUxJVFkKKy5cIiAuU2ggSElTVE9SWQorLlwiIC5TaCBCVUdTCisuXCIKKy5TaCBDSEVDS0VSUworVGhlIGNoZWNrZXJzIGxpc3RlZCBiZWxvdyBtYXkgYmUgZW5hYmxlZC9kaXNhYmxlZCB1c2luZyB0aGUKKy5GbCBlbmFibGUtY2hlY2tlcgorYW5kCisuRmwgZGlzYWJsZS1jaGVja2VyCitvcHRpb25zLgorQSBkZWZhdWx0IGdyb3VwIG9mIGNoZWNrZXJzIGlzIHJ1biB1bmxlc3MgZXhwbGljaXRseSBkaXNhYmxlZC4KK0V4YWN0bHkgd2hpY2ggY2hlY2tlcnMgY29uc3RpdHV0ZSB0aGUgZGVmYXVsdCBncm91cCBpcyBhIGZ1bmN0aW9uCitvZiB0aGUgb3BlcmF0aW5nIHN5c3RlbSBpbiB1c2U7IHRoZXkgYXJlIGxpc3RlZCB3aXRoCisuRmwgRmwgaGVscC1jaGVja2VycyAuCisuQmwgLXRhZyAtd2lkdGggaW5kZW50LgorLkl0IGNvcmUuQWRqdXN0ZWRSZXR1cm5WYWx1ZQorQ2hlY2sgdG8gc2VlIGlmIHRoZSByZXR1cm4gdmFsdWUgb2YgYSBmdW5jdGlvbiBjYWxsIGlzIGRpZmZlcmVudCB0aGFuCit0aGUgY2FsbGVyIGV4cGVjdHMgKGUuZy4sIGZyb20gY2FsbHMgdGhyb3VnaCBmdW5jdGlvbiBwb2ludGVycykuCisuSXQgY29yZS5BdHRyaWJ1dGVOb25OdWxsCitDaGVjayBmb3IgbnVsbCBwb2ludGVycyBwYXNzZWQgYXMgYXJndW1lbnRzIHRvIGEgZnVuY3Rpb24gd2hvc2UgYXJndW1lbnRzIGFyZSBtYXJrZWQgd2l0aCB0aGUKKy5RbCBub25udWxsCithdHRyaWJ1dGUuCisuSXQgY29yZS5DYWxsQW5kTWVzc2FnZQorQ2hlY2sgZm9yIGxvZ2ljYWwgZXJyb3JzIGZvciBmdW5jdGlvbiBjYWxscyBhbmQgT2JqZWN0aXZlLUMgbWVzc2FnZSBleHByZXNzaW9ucyAoZS5nLiwgdW5pbml0aWFsaXplZCBhcmd1bWVudHMsIG51bGwgZnVuY3Rpb24gcG9pbnRlcnMpLgorLkl0IGNvcmUuRGl2aWRlWmVybworQ2hlY2sgZm9yIGRpdmlzaW9uIGJ5IHplcm8uCisuSXQgY29yZS5OdWxsRGVyZWZlcmVuY2UKK0NoZWNrIGZvciBkZXJlZmVyZW5jZXMgb2YgbnVsbCBwb2ludGVycy4KKy5JdCBjb3JlLlN0YWNrQWRkcmVzc0VzY2FwZQorQ2hlY2sgdGhhdCBhZGRyZXNzZXMgdG8gc3RhY2sgbWVtb3J5IGRvIG5vdCBlc2NhcGUgdGhlIGZ1bmN0aW9uLgorLkl0IGNvcmUuVW5kZWZpbmVkQmluYXJ5T3BlcmF0b3JSZXN1bHQKK0NoZWNrIGZvciB1bmRlZmluZWQgcmVzdWx0cyBvZiBiaW5hcnkgb3BlcmF0b3JzLgorLkl0IGNvcmUuVkxBU2l6ZQorQ2hlY2sgZm9yIGRlY2xhcmF0aW9ucyBvZiBWTEEgb2YgdW5kZWZpbmVkIG9yIHplcm8gc2l6ZS4KKy5JdCBjb3JlLmJ1aWx0aW4uQnVpbHRpbkZ1bmN0aW9ucworRXZhbHVhdGUgY29tcGlsZXIgYnVpbHRpbiBmdW5jdGlvbnMsIGUuZy4KKy5GbiBhbGxvY2EgLgorLkl0IGNvcmUuYnVpbHRpbi5Ob1JldHVybkZ1bmN0aW9ucworRXZhbHVhdGUKKy5RbCBwYW5pYworZnVuY3Rpb25zIHRoYXQgYXJlIGtub3duIHRvIG5vdCByZXR1cm4gdG8gdGhlIGNhbGxlci4KKy5JdCBjb3JlLnVuaW5pdGlhbGl6ZWQuQXJyYXlTdWJzY3JpcHQKK0NoZWNrIGZvciB1bmluaXRpYWxpemVkIHZhbHVlcyB1c2VkIGFzIGFycmF5IHN1YnNjcmlwdHMuCisuSXQgY29yZS51bmluaXRpYWxpemVkLkFzc2lnbgorQ2hlY2sgZm9yIGFzc2lnbmluZyB1bmluaXRpYWxpemVkIHZhbHVlcy4KKy5JdCBjb3JlLnVuaW5pdGlhbGl6ZWQuQnJhbmNoCitDaGVjayBmb3IgdW5pbml0aWFsaXplZCB2YWx1ZXMgdXNlZCBhcyBicmFuY2ggY29uZGl0aW9ucy4KKy5JdCBjb3JlLnVuaW5pdGlhbGl6ZWQuQ2FwdHVyZWRCbG9ja1ZhcmlhYmxlCitDaGVjayBmb3IgYmxvY2tzIHRoYXQgY2FwdHVyZSB1bmluaXRpYWxpemVkIHZhbHVlcy4KKy5JdCBjb3JlLnVuaW5pdGlhbGl6ZWQuVW5kZWZSZXR1cm4KK0NoZWNrIGZvciB1bmluaXRpYWxpemVkIHZhbHVlcyBiZWluZyByZXR1cm5lZCB0byB0aGUgY2FsbGVyLgorLkl0IGRlYWRjb2RlLkRlYWRTdG9yZXMKK0NoZWNrIGZvciB2YWx1ZXMgc3RvcmVkIHRvIHZhcmlhYmxlcyB0aGF0IGFyZSBuZXZlciByZWFkIGFmdGVyd2FyZHMuCisuSXQgZGVidWcuRHVtcENGRworRGlzcGxheSBDb250cm9sLUZsb3cgR3JhcGhzLgorLkl0IGRlYnVnLkR1bXBDYWxsR3JhcGgKK0Rpc3BsYXkgQ2FsbCBHcmFwaC4KKy5JdCBkZWJ1Zy5EdW1wRG9taW5hdG9ycworUHJpbnQgdGhlIGRvbWluYW5jZSB0cmVlIGZvciBhIGdpdmVuIENvbnRyb2wtRmxvdyBHcmFwaC4KKy5JdCBkZWJ1Zy5EdW1wTGl2ZVZhcnMKK1ByaW50IHJlc3VsdHMgb2YgbGl2ZSB2YXJpYWJsZSBhbmFseXNpcy4KKy5JdCBkZWJ1Zy5TdGF0cworRW1pdCB3YXJuaW5ncyB3aXRoIGFuYWx5emVyIHN0YXRpc3RpY3MuCisuSXQgZGVidWcuVGFpbnRUZXN0CitNYXJrIHRhaW50ZWQgc3ltYm9scyBhcyBzdWNoLgorLkl0IGRlYnVnLlZpZXdDRkcKK1ZpZXcgQ29udHJvbC1GbG93IEdyYXBocyB1c2luZworLkljIEdyYXBoVml6IC4KKy5JdCBkZWJ1Zy5WaWV3Q2FsbEdyYXBoCitWaWV3IENhbGwgR3JhcGggdXNpbmcKKy5JYyBHcmFwaFZpeiAuCisuSXQgbGx2bS5Db252ZW50aW9ucworQ2hlY2sgY29kZSBmb3IgTExWTSBjb2RlYmFzZSBjb252ZW50aW9ucy4KKy5JdCBvc3guQVBJCitDaGVjayBmb3IgcHJvcGVyIHVzZXMgb2YgdmFyaW91cyBNYWMgT1MgWCBBUElzLgorLkl0IG9zeC5BdG9taWNDQVMKK0V2YWx1YXRlIGNhbGxzIHRvCisuVnQgT1NBdG9taWMKK2Z1bmN0aW9ucy4KKy5JdCBvc3guU2VjS2V5Y2hhaW5BUEkKK0NoZWNrIGZvciBwcm9wZXIgdXNlcyBvZiBTZWN1cmUgS2V5Y2hhaW4gQVBJcy4KKy5JdCBvc3guY29jb2EuQXRTeW5jCitDaGVjayBmb3IgbnVsbCBwb2ludGVycyB1c2VkIGFzIG11dGV4ZXMgZm9yIEBzeW5jaHJvbml6ZWQuCisuSXQgb3N4LmNvY29hLkNsYXNzUmVsZWFzZQorQ2hlY2sgZm9yIHNlbmRpbmcKKy5RbCByZXRhaW4gLAorLlFsIHJlbGVhc2UsCitvcgorLlFsIGF1dG9yZWxlYXNlCitkaXJlY3RseSB0byBhIENsYXNzLgorLkl0IG9zeC5jb2NvYS5JbmNvbXBhdGlibGVNZXRob2RUeXBlcworV2FybiBhYm91dCBPYmplY3RpdmUtQyBtZXRob2Qgc2lnbmF0dXJlcyB3aXRoIHR5cGUgaW5jb21wYXRpYmlsaXRpZXMuCisuSXQgb3N4LmNvY29hLk5TQXV0b3JlbGVhc2VQb29sCitXYXJuIGZvciBzdWJvcHRpbWFsIHVzZXMgb2YKKy5WdCBOU0F1dG9yZWxlYXNlUG9vbAoraW4gT2JqZWN0aXZlLUMgR0MgbW9kZS4KKy5JdCBvc3guY29jb2EuTlNFcnJvcgorQ2hlY2sgdXNhZ2Ugb2YgTlNFcnJvcioqIHBhcmFtZXRlcnMuCisuSXQgb3N4LmNvY29hLk5pbEFyZworQ2hlY2sgZm9yIHByb2hpYml0ZWQgbmlsIGFyZ3VtZW50cyB0byBPYmplY3RpdmUtQyBtZXRob2QgY2FsbHMuCisuSXQgb3N4LmNvY29hLlJldGFpbkNvdW50CitDaGVjayBmb3IgbGVha3MgYW5kIGltcHJvcGVyIHJlZmVyZW5jZSBjb3VudCBtYW5hZ2VtZW50LgorLkl0IG9zeC5jb2NvYS5TZWxmSW5pdAorQ2hlY2sgdGhhdAorLlFsIHNlbGYKK2lzIHByb3Blcmx5IGluaXRpYWxpemVkIGluc2lkZSBhbiBpbml0aWFsaXplciBtZXRob2QuCisuSXQgb3N4LmNvY29hLlVudXNlZEl2YXJzCitXYXJuIGFib3V0IHByaXZhdGUgaXZhcnMgdGhhdCBhcmUgbmV2ZXIgdXNlZC4KKy5JdCBvc3guY29jb2EuVmFyaWFkaWNNZXRob2RUeXBlcworQ2hlY2sgZm9yIHBhc3Npbmcgbm9uLU9iamVjdGl2ZS1DIHR5cGVzIHRvIHZhcmlhZGljIG1ldGhvZHMgdGhhdCBleHBlY3Qgb25seSBPYmplY3RpdmUtQyB0eXBlcy4KKy5JdCBvc3guY29yZUZvdW5kYXRpb24uQ0ZFcnJvcgorQ2hlY2sgdXNhZ2Ugb2YgQ0ZFcnJvclJlZiogcGFyYW1ldGVycy4KKy5JdCBvc3guY29yZUZvdW5kYXRpb24uQ0ZOdW1iZXIKK0NoZWNrIGZvciBwcm9wZXIgdXNlcyBvZgorLkZuIENGTnVtYmVyQ3JlYXRlIC4KKy5JdCBvc3guY29yZUZvdW5kYXRpb24uQ0ZSZXRhaW5SZWxlYXNlCitDaGVjayBmb3IgbnVsbCBhcmd1bWVudHMgdG8KKy5GbiBDRlJldGFpbiAsCisuRm4gQ0ZSZWxlYXNlICwKK2FuZAorLkZuIENGTWFrZUNvbGxlY3RhYmxlIC4KKy5JdCBvc3guY29yZUZvdW5kYXRpb24uY29udGFpbmVycy5PdXRPZkJvdW5kcworQ2hlY2tzIGZvciBpbmRleCBvdXQtb2YtYm91bmRzIHdoZW4gdXNpbmcgdGhlCisuVnQgQ0ZBcnJheQorQVBJLgorLkl0IG9zeC5jb3JlRm91bmRhdGlvbi5jb250YWluZXJzLlBvaW50ZXJTaXplZFZhbHVlcworV2FybnMgaWYKKy5WdCBDRkFycmF5ICwKKy5WdCBDRkRpY3Rpb25hcnkgLAorb3IKKy5WdCBDRlNldAorYXJlIGNyZWF0ZWQgd2l0aCBub24tcG9pbnRlci1zaXplIHZhbHVlcy4KKy5JdCBzZWN1cml0eS5GbG9hdExvb3BDb3VudGVyCitXYXJuIG9uIHVzaW5nIGEgZmxvYXRpbmcgcG9pbnQgdmFsdWUgYXMgYSBsb29wIGNvdW50ZXIgKENFUlQ6IEZMUDMwLUMsIEZMUDMwLUNQUCkuCisuSXQgc2VjdXJpdHkuaW5zZWN1cmVBUEkuVW5jaGVja2VkUmV0dXJuCitXYXJuIG9uIHVzZXMgb2YgZnVuY3Rpb25zIHdob3NlIHJldHVybiB2YWx1ZXMgbXVzdCBiZSBhbHdheXMgY2hlY2tlZC4KKy5JdCBzZWN1cml0eS5pbnNlY3VyZUFQSS5nZXRwdworV2FybiBvbiB1c2VzIG9mCisuRm4gZ2V0cHcgLgorLkl0IHNlY3VyaXR5Lmluc2VjdXJlQVBJLmdldHMKK1dhcm4gb24gdXNlcyBvZgorLkZuIGdldHMgLgorLkl0IHNlY3VyaXR5Lmluc2VjdXJlQVBJLm1rc3RlbXAKK1dhcm4gd2hlbgorLkZuIG1rc3RlbXAKK2lzIHBhc3NlZCBmZXdlciB0aGFuIDYgWCdzIGluIHRoZSBmb3JtYXQgc3RyaW5nLgorLkl0IHNlY3VyaXR5Lmluc2VjdXJlQVBJLm1rdGVtcAorV2FybiBvbiB1c2VzIG9mCisuRm4gbWt0ZW1wIC4KKy5JdCBzZWN1cml0eS5pbnNlY3VyZUFQSS5yYW5kCitXYXJuIG9uIHVzZXMgb2YKKy5GbiByYW5kICwKKy5GbiByYW5kb20gLAorYW5kIHJlbGF0ZWQgZnVuY3Rpb25zLgorLkl0IHNlY3VyaXR5Lmluc2VjdXJlQVBJLnN0cmNweQorV2FybiBvbiB1c2VzIG9mCisuRm4gc3RyY3B5CithbmQKKy5GbiBzdHJjYXQgLgorLkl0IHNlY3VyaXR5Lmluc2VjdXJlQVBJLnZmb3JrCitXYXJuIG9uIHVzZXMgb2YKKy5GbiB2Zm9yayAuCisuSXQgdW5peC5BUEkKK0NoZWNrIGNhbGxzIHRvIHZhcmlvdXMgVU5JWC9Qb3NpeCBmdW5jdGlvbnMuCisuSXQgdW5peC5NYWxsb2MKK0NoZWNrIGZvciBtZW1vcnkgbGVha3MsIGRvdWJsZSBmcmVlLCBhbmQgdXNlLWFmdGVyLWZyZWUuCisuSXQgdW5peC5jc3RyaW5nLkJhZFNpemVBcmcKK0NoZWNrIHRoZSBzaXplIGFyZ3VtZW50IHBhc3NlZCBpbnRvIEMgc3RyaW5nIGZ1bmN0aW9ucyBmb3IgY29tbW9uCitlcnJvbmVvdXMgcGF0dGVybnMuCisuSXQgdW5peC5jc3RyaW5nLk51bGxBcmcKK0NoZWNrIGZvciBudWxsIHBvaW50ZXJzIGJlaW5nIHBhc3NlZCBhcyBhcmd1bWVudHMgdG8gQyBzdHJpbmcgZnVuY3Rpb25zLgorLkVsCisuXCIKKy5TaCBFWEFNUExFCisuSWMgc2Nhbi1idWlsZCAtbyAvdG1wL215aHRtbGRpciBtYWtlIC1qNAorLlBwCitUaGUgYWJvdmUgZXhhbXBsZSBjYXVzZXMgYW5hbHlzaXMgcmVwb3J0cyB0byBiZSBkZXBvc2l0ZWQgaW50bworYSBzdWJkaXJlY3Rvcnkgb2YKKy5QYSAvdG1wL215aHRtbGRpcgorYW5kIHRvIHJ1bgorLkljIG1ha2UKK3dpdGggdGhlCisuRmwgajQKK29wdGlvbi4KK0EgZGlmZmVyZW50IHN1YmRpcmVjdG9yeSBpcyBjcmVhdGVkIGVhY2ggdGltZQorLk5tCithbmFseXplcyBhIHByb2plY3QuCitUaGUgYW5hbHl6ZXIgc2hvdWxkIHN1cHBvcnQgbW9zdCBwYXJhbGxlbCBidWlsZHMsIGJ1dCBub3QgZGlzdHJpYnV0ZWQgYnVpbGRzLgorLlNoIEFVVEhPUlMKKy5ObQord2FzIHdyaXR0ZW4gYnkKKy5BbiAiVGVkIEtyZW1lbmVrIiAuCitEb2N1bWVudGF0aW9uIGNvbnRyaWJ1dGVkIGJ5CisuQW4gIkphbWVzIEsuIExvd2RlbiIgQXEgamtsb3dkZW5Ac2NoZW1hbWFuaWEub3JnIC4KZGlmZiAtLWdpdCBhL3Rvb2xzL3NjYW4tYnVpbGQvc2Nhbi1idWlsZC5iYXQgYi90b29scy9zY2FuLWJ1aWxkL3NjYW4tYnVpbGQuYmF0Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLmY3NjVmMjAKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9zY2FuLWJ1aWxkL3NjYW4tYnVpbGQuYmF0CkBAIC0wLDAgKzEgQEAKK3BlcmwgLVMgc2Nhbi1idWlsZCAlKgpkaWZmIC0tZ2l0IGEvdG9vbHMvc2Nhbi1idWlsZC9zY2Fudmlldy5jc3MgYi90b29scy9zY2FuLWJ1aWxkL3NjYW52aWV3LmNzcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5jZjhhNWE2Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvc2Nhbi1idWlsZC9zY2Fudmlldy5jc3MKQEAgLTAsMCArMSw2MiBAQAorYm9keSB7IGNvbG9yOiMwMDAwMDA7IGJhY2tncm91bmQtY29sb3I6I2ZmZmZmZiB9Citib2R5IHsgZm9udC1mYW1pbHk6IEhlbHZldGljYSwgc2Fucy1zZXJpZjsgZm9udC1zaXplOjlwdCB9CitoMSB7IGZvbnQtc2l6ZTogMTRwdDsgfQoraDIgeyBmb250LXNpemU6IDEycHQ7IH0KK3RhYmxlIHsgZm9udC1zaXplOjlwdCB9Cit0YWJsZSB7IGJvcmRlci1zcGFjaW5nOiAwcHg7IGJvcmRlcjogMXB4IHNvbGlkIGJsYWNrIH0KK3RoLCB0YWJsZSB0aGVhZCB7CisgIGJhY2tncm91bmQtY29sb3I6I2VlZTsgY29sb3I6IzY2NjY2NjsKKyAgZm9udC13ZWlnaHQ6IGJvbGQ7IGN1cnNvcjogZGVmYXVsdDsKKyAgdGV4dC1hbGlnbjpjZW50ZXI7CisgIGZvbnQtd2VpZ2h0OiBib2xkOyBmb250LWZhbWlseTogVmVyZGFuYTsKKyAgd2hpdGUtc3BhY2U6bm93cmFwOworfQorLlcgeyBmb250LXNpemU6MHB4IH0KK3RoLCB0ZCB7IHBhZGRpbmc6NXB4OyBwYWRkaW5nLWxlZnQ6OHB4OyB0ZXh0LWFsaWduOmxlZnQgfQordGQuU1VNTV9ERVNDIHsgcGFkZGluZy1sZWZ0OjEycHggfQordGQuREVTQyB7IHdoaXRlLXNwYWNlOnByZSB9Cit0ZC5RIHsgdGV4dC1hbGlnbjpyaWdodCB9Cit0ZCB7IHRleHQtYWxpZ246bGVmdCB9Cit0Ym9keS5zY3JvbGxDb250ZW50IHsgb3ZlcmZsb3c6YXV0byB9CisKK3RhYmxlLmZvcm1fZ3JvdXAgeworICAgIGJhY2tncm91bmQtY29sb3I6ICNjY2M7CisgICAgYm9yZGVyOiAxcHggc29saWQgIzMzMzsKKyAgICBwYWRkaW5nOiAycHg7Cit9CisKK3RhYmxlLmZvcm1faW5uZXJfZ3JvdXAgeworICAgIGJhY2tncm91bmQtY29sb3I6ICNjY2M7CisgICAgYm9yZGVyOiAxcHggc29saWQgIzMzMzsKKyAgICBwYWRkaW5nOiAwcHg7Cit9CisKK3RhYmxlLmZvcm0geworICAgIGJhY2tncm91bmQtY29sb3I6ICM5OTk7CisgICAgYm9yZGVyOiAxcHggc29saWQgIzMzMzsKKyAgICBwYWRkaW5nOiAycHg7Cit9CisKK3RkLmZvcm1fbGFiZWwgeworICAgIHRleHQtYWxpZ246IHJpZ2h0OworICAgIHZlcnRpY2FsLWFsaWduOiB0b3A7Cit9CisvKiBGb3Igb25lIGxpbmUgZW50aXJlcyAqLwordGQuZm9ybV9jbGFiZWwgeworICAgIHRleHQtYWxpZ246IHJpZ2h0OworICAgIHZlcnRpY2FsLWFsaWduOiBjZW50ZXI7Cit9Cit0ZC5mb3JtX3ZhbHVlIHsKKyAgICB0ZXh0LWFsaWduOiBsZWZ0OworICAgIHZlcnRpY2FsLWFsaWduOiB0b3A7Cit9Cit0ZC5mb3JtX3N1Ym1pdCB7CisgICAgdGV4dC1hbGlnbjogcmlnaHQ7CisgICAgdmVydGljYWwtYWxpZ246IHRvcDsKK30KKworaDEuU3VibWl0RmFpbCB7CisgICAgY29sb3I6ICNmMDA7Cit9CitoMS5TdWJtaXRPayB7Cit9CmRpZmYgLS1naXQgYS90b29scy9zY2FuLWJ1aWxkL3NldC14Y29kZS1hbmFseXplciBiL3Rvb2xzL3NjYW4tYnVpbGQvc2V0LXhjb2RlLWFuYWx5emVyCm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAuLjhlNjc0ODIKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9zY2FuLWJ1aWxkL3NldC14Y29kZS1hbmFseXplcgpAQCAtMCwwICsxLDExNCBAQAorIyEvdXNyL2Jpbi9weXRob24KKworIyBbUFIgMTE2NjFdIE5vdGUgdGhhdCB3ZSBoYXJkd2lyZSB0byAvdXNyL2Jpbi9weXRob24gYmVjYXVzZSB3ZQorIyB3YW50IHRvIHRoZSB1c2UgdGhlIHN5c3RlbSB2ZXJzaW9uIG9mIFB5dGhvbiBvbiBNYWMgT1MgWC4KKyMgVGhpcyBvbmUgaGFzIHRoZSBzY3JpcHRpbmcgYnJpZGdlIGVuYWJsZWQuCisKK2ltcG9ydCBzeXMKK2lmIHN5cy52ZXJzaW9uX2luZm8gPCAoMiwgNyk6CisgICAgcHJpbnQgInNldC14Y29kZS1hbmFseXplciByZXF1aXJlcyBQeXRob24gMi43IG9yIGxhdGVyIgorICAgIHN5cy5leGl0KDEpCisKK2ltcG9ydCBvcworaW1wb3J0IHN1YnByb2Nlc3MKK2ltcG9ydCByZQoraW1wb3J0IHRlbXBmaWxlCitpbXBvcnQgc2h1dGlsCitpbXBvcnQgc3RhdAorZnJvbSBBcHBLaXQgaW1wb3J0ICoKKworZGVmIEZpbmRDbGFuZ1NwZWNzKHBhdGgpOgorICBwcmludCAiKCspIFNlYXJjaGluZyBmb3IgeGNzcGVjIGZpbGUgaW46ICIsIHBhdGgKKyAgZm9yIHJvb3QsIGRpcnMsIGZpbGVzIGluIG9zLndhbGsocGF0aCk6CisgICAgZm9yIGYgaW4gZmlsZXM6CisgICAgICBpZiBmLmVuZHN3aXRoKCIueGNzcGVjIikgYW5kIGYuc3RhcnRzd2l0aCgiQ2xhbmcgTExWTSIpOgorICAgICAgICB5aWVsZCBvcy5wYXRoLmpvaW4ocm9vdCwgZikKKworZGVmIE1vZGlmeVNwZWMocGF0aCwgaXNCdWlsdGluQW5hbHl6ZXIsIHBhdGhUb0NoZWNrZXIpOgorICB0ID0gdGVtcGZpbGUuTmFtZWRUZW1wb3JhcnlGaWxlKGRlbGV0ZT1GYWxzZSkKKyAgZm91bmRBbmFseXplciA9IEZhbHNlCisgIHdpdGggb3BlbihwYXRoKSBhcyBmOgorICAgIGlmIGlzQnVpbHRpbkFuYWx5emVyOgorICAgICAgIyBGaXJzdCBzZWFyY2ggZm9yIENMQU5HX0FOQUxZWkVSX0VYRUMuICBOZXdlcgorICAgICAgIyB2ZXJzaW9ucyBvZiBYY29kZSBzZXQgRVhFQ19QQVRIIHRvIGJlIENMQU5HX0FOQUxZWkVSX0VYRUMuCisgICAgICB3aXRoIG9wZW4ocGF0aCkgYXMgZjI6CisgICAgICAgIGZvciBsaW5lIGluIGYyOgorICAgICAgICAgIGlmIGxpbmUuZmluZCgiQ0xBTkdfQU5BTFlaRVJfRVhFQyIpID49IDA6CisgICAgICAgICAgICBwYXRoVG9DaGVja2VyID0gIiQoQ0xBTkdfQU5BTFlaRVJfRVhFQykiCisgICAgICAgICAgICBicmVhaworICAgICMgTm93IGNyZWF0ZSBhIG5ldyBmaWxlLgorICAgIGZvciBsaW5lIGluIGY6CisgICAgICBpZiBub3QgZm91bmRBbmFseXplcjoKKyAgICAgICAgaWYgbGluZS5maW5kKCJTdGF0aWMgQW5hbHl6ZXIiKSA+PSAwOgorICAgICAgICAgIGZvdW5kQW5hbHl6ZXIgPSBUcnVlCisgICAgICBlbHNlOgorICAgICAgICBtID0gcmUuc2VhcmNoKCdeKFxzKkV4ZWNQYXRoXHMqPVxzKiIpJywgbGluZSkKKyAgICAgICAgaWYgbToKKyAgICAgICAgICBsaW5lID0gIiIuam9pbihbbS5ncm91cCgwKSwgcGF0aFRvQ2hlY2tlciwgJyI7XG4nXSkKKyAgICAgICAgICAjIERvIG5vdCBtb2RpZnkgZnVydGhlciBFeGVjUGF0aCdzIGxhdGVyIGluIHRoZSB4Y3NwZWMuCisgICAgICAgICAgZm91bmRBbmFseXplciA9IEZhbHNlCisgICAgICB0LndyaXRlKGxpbmUpCisgIHQuY2xvc2UoKQorICBwcmludCAiKCspIHByb2Nlc3Npbmc6IiwgcGF0aAorICB0cnk6CisgICAgc2h1dGlsLmNvcHkodC5uYW1lLCBwYXRoKQorICAgIG9zLmNobW9kKHBhdGgsIHN0YXQuU19JUlVTUiB8IHN0YXQuU19JV1VTUiB8IHN0YXQuU19JUkdSUCB8IHN0YXQuU19JUk9USCkKKyAgZXhjZXB0IElPRXJyb3IsIHdoeToKKyAgICBwcmludCAiICAgICgtKSBDYW5ub3QgdXBkYXRlIGZpbGU6Iiwgd2h5LCAiXG4iCisgIGV4Y2VwdCBPU0Vycm9yLCB3aHk6CisgICAgcHJpbnQgIiAgICAoLSkgQ2Fubm90IHVwZGF0ZSBmaWxlOiIsIHdoeSwgIlxuIgorICBvcy51bmxpbmsodC5uYW1lKQorCitkZWYgbWFpbigpOgorICBmcm9tIG9wdHBhcnNlIGltcG9ydCBPcHRpb25QYXJzZXIKKyAgcGFyc2VyID0gT3B0aW9uUGFyc2VyKCd1c2FnZTogJXByb2cgW29wdGlvbnNdJykKKyAgcGFyc2VyLnNldF9kZXNjcmlwdGlvbihfX2RvY19fKQorICBwYXJzZXIuYWRkX29wdGlvbigiLS11c2UtY2hlY2tlci1idWlsZCIsIGRlc3Q9InBhdGgiLAorICAgICAgICAgICAgICAgICAgICBoZWxwPSJVc2UgdGhlIENsYW5nIGxvY2F0ZWQgYXQgdGhlIHByb3ZpZGVkIGFic29sdXRlIHBhdGgsIGUuZy4gL1VzZXJzL2Zvby9jaGVja2VyLTEiKQorICBwYXJzZXIuYWRkX29wdGlvbigiLS11c2UteGNvZGUtY2xhbmciLCBhY3Rpb249InN0b3JlX2NvbnN0IiwKKyAgICAgICAgICAgICAgICAgICAgY29uc3Q9IiQoQ0xBTkcpIiwgZGVzdD0iZGVmYXVsdCIsCisgICAgICAgICAgICAgICAgICAgIGhlbHA9IlVzZSB0aGUgQ2xhbmcgYnVuZGxlZCB3aXRoIFhjb2RlIikKKyAgKG9wdGlvbnMsIGFyZ3MpID0gcGFyc2VyLnBhcnNlX2FyZ3MoKQorICBpZiBvcHRpb25zLnBhdGggaXMgTm9uZSBhbmQgb3B0aW9ucy5kZWZhdWx0IGlzIE5vbmU6CisgICAgcGFyc2VyLmVycm9yKCJZb3UgbXVzdCBzcGVjaWZ5IGEgdmVyc2lvbiBvZiBDbGFuZyB0byB1c2UgZm9yIHN0YXRpYyBhbmFseXNpcy4gIFNwZWNpZnkgJy1oJyBmb3IgZGV0YWlscyIpCisKKyAgIyBkZXRlcm1pbmUgaWYgWGNvZGUgaXMgcnVubmluZworICBmb3IgeCBpbiBOU1dvcmtzcGFjZS5zaGFyZWRXb3Jrc3BhY2UoKS5ydW5uaW5nQXBwbGljYXRpb25zKCk6CisgICAgaWYgeC5sb2NhbGl6ZWROYW1lKCkuZmluZCgiWGNvZGUiKSA+PSAwOgorICAgICAgcHJpbnQgIigtKSBZb3UgbXVzdCBxdWl0IFhjb2RlIGZpcnN0IGJlZm9yZSBtb2RpZnlpbmcgaXRzIGNvbmZpZ3VyYXRpb24gZmlsZXMuIgorICAgICAgc3lzLmV4aXQoMSkKKworICBpc0J1aWx0aW5BbmFseXplciA9IEZhbHNlCisgIGlmIG9wdGlvbnMucGF0aDoKKyAgICAjIEV4cGFuZCB0aWxkZXMuCisgICAgcGF0aCA9IG9zLnBhdGguZXhwYW5kdXNlcihvcHRpb25zLnBhdGgpCisgICAgaWYgbm90IHBhdGguZW5kc3dpdGgoImNsYW5nIik6CisgICAgICBwcmludCAiKCspIFVzaW5nIENsYW5nIGJ1bmRsZWQgd2l0aCBjaGVja2VyIGJ1aWxkOiIsIHBhdGgKKyAgICAgIHBhdGggPSBvcy5wYXRoLmpvaW4ocGF0aCwgImJpbiIsICJjbGFuZyIpOworICAgIGVsc2U6CisgICAgICBwcmludCAiKCspIFVzaW5nIENsYW5nIGxvY2F0ZWQgYXQ6IiwgcGF0aAorICBlbHNlOgorICAgIHByaW50ICIoKykgVXNpbmcgdGhlIENsYW5nIGJ1bmRsZWQgd2l0aCBYY29kZSIKKyAgICBwYXRoID0gb3B0aW9ucy5kZWZhdWx0CisgICAgaXNCdWlsdGluQW5hbHl6ZXIgPSBUcnVlCisKKyAgdHJ5OgorICAgIHhjb2RlX3BhdGggPSBzdWJwcm9jZXNzLmNoZWNrX291dHB1dChbInhjb2RlLXNlbGVjdCIsICItcHJpbnQtcGF0aCJdKQorICBleGNlcHQgQXR0cmlidXRlRXJyb3I6CisgICAgIyBGYWxsIGJhY2sgdG8gdGhlIGRlZmF1bHQgaW5zdGFsbCBsb2NhdGlvbiB3aGVuIHVzaW5nIFB5dGhvbiA8IDIuNy4wCisgICAgeGNvZGVfcGF0aCA9ICIvRGV2ZWxvcGVyIgorICBpZiAoeGNvZGVfcGF0aC5maW5kKCIuYXBwLyIpICE9IC0xKToKKyAgICAjIEN1dCBvZmYgdGhlICdEZXZlbG9wZXInIGRpciwgYXMgdGhlIHhjc3BlYyBsaWVzIGluIGFub3RoZXIgcGFydAorICAgICMgb2YgdGhlIFhjb2RlLmFwcCBzdWJ0cmVlLgorICAgIHhjb2RlX3BhdGggPSB4Y29kZV9wYXRoLnJzcGxpdCgnL0RldmVsb3BlcicsIDEpWzBdCisKKyAgZm91bmRTcGVjID0gRmFsc2UKKyAgZm9yIHggaW4gRmluZENsYW5nU3BlY3MoeGNvZGVfcGF0aCk6CisgICAgZm91bmRTcGVjID0gVHJ1ZQorICAgIE1vZGlmeVNwZWMoeCwgaXNCdWlsdGluQW5hbHl6ZXIsIHBhdGgpCisKKyAgaWYgZm91bmRTcGVjID09IEZhbHNlOgorICAgICAgcHJpbnQgIigtKSBObyBjb21waWxlciBjb25maWd1cmF0aW9uIGZpbGUgd2FzIGZvdW5kLiAgWGNvZGUncyBhbmFseXplciBoYXMgbm90IGJlZW4gdXBkYXRlZC4iCisKK2lmIF9fbmFtZV9fID09ICdfX21haW5fXyc6CisgIG1haW4oKQpkaWZmIC0tZ2l0IGEvdG9vbHMvc2Nhbi1idWlsZC9zb3J0dGFibGUuanMgYi90b29scy9zY2FuLWJ1aWxkL3NvcnR0YWJsZS5qcwpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi4zMmZhYTA3Ci0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvc2Nhbi1idWlsZC9zb3J0dGFibGUuanMKQEAgLTAsMCArMSw0OTIgQEAKKy8qCisgIFNvcnRUYWJsZQorICB2ZXJzaW9uIDIKKyAgN3RoIEFwcmlsIDIwMDcKKyAgU3R1YXJ0IExhbmdyaWRnZSwgaHR0cDovL3d3dy5rcnlvZ2VuaXgub3JnL2NvZGUvYnJvd3Nlci9zb3J0dGFibGUvCisKKyAgSW5zdHJ1Y3Rpb25zOgorICBEb3dubG9hZCB0aGlzIGZpbGUKKyAgQWRkIDxzY3JpcHQgc3JjPSJzb3J0dGFibGUuanMiPjwvc2NyaXB0PiB0byB5b3VyIEhUTUwKKyAgQWRkIGNsYXNzPSJzb3J0YWJsZSIgdG8gYW55IHRhYmxlIHlvdSdkIGxpa2UgdG8gbWFrZSBzb3J0YWJsZQorICBDbGljayBvbiB0aGUgaGVhZGVycyB0byBzb3J0CisKKyAgVGhhbmtzIHRvIG1hbnksIG1hbnkgcGVvcGxlIGZvciBjb250cmlidXRpb25zIGFuZCBzdWdnZXN0aW9ucy4KKyAgTGljZW5jZWQgYXMgWDExOiBodHRwOi8vd3d3LmtyeW9nZW5peC5vcmcvY29kZS9icm93c2VyL2xpY2VuY2UuaHRtbAorICBUaGlzIGJhc2ljYWxseSBtZWFuczogZG8gd2hhdCB5b3Ugd2FudCB3aXRoIGl0LgorKi8KKworCit2YXIgc3RJc0lFID0gLypAY2Nfb24hQCovZmFsc2U7CisKK3NvcnR0YWJsZSA9IHsKKyAgaW5pdDogZnVuY3Rpb24oKSB7CisgICAgLy8gcXVpdCBpZiB0aGlzIGZ1bmN0aW9uIGhhcyBhbHJlYWR5IGJlZW4gY2FsbGVkCisgICAgaWYgKGFyZ3VtZW50cy5jYWxsZWUuZG9uZSkgcmV0dXJuOworICAgIC8vIGZsYWcgdGhpcyBmdW5jdGlvbiBzbyB3ZSBkb24ndCBkbyB0aGUgc2FtZSB0aGluZyB0d2ljZQorICAgIGFyZ3VtZW50cy5jYWxsZWUuZG9uZSA9IHRydWU7CisgICAgLy8ga2lsbCB0aGUgdGltZXIKKyAgICBpZiAoX3RpbWVyKSBjbGVhckludGVydmFsKF90aW1lcik7CisKKyAgICBpZiAoIWRvY3VtZW50LmNyZWF0ZUVsZW1lbnQgfHwgIWRvY3VtZW50LmdldEVsZW1lbnRzQnlUYWdOYW1lKSByZXR1cm47CisKKyAgICBzb3J0dGFibGUuREFURV9SRSA9IC9eKFxkXGQ/KVtcL1wuLV0oXGRcZD8pW1wvXC4tXSgoXGRcZCk/XGRcZCkkLzsKKworICAgIGZvckVhY2goZG9jdW1lbnQuZ2V0RWxlbWVudHNCeVRhZ05hbWUoJ3RhYmxlJyksIGZ1bmN0aW9uKHRhYmxlKSB7CisgICAgICBpZiAodGFibGUuY2xhc3NOYW1lLnNlYXJjaCgvXGJzb3J0YWJsZVxiLykgIT0gLTEpIHsKKyAgICAgICAgc29ydHRhYmxlLm1ha2VTb3J0YWJsZSh0YWJsZSk7CisgICAgICB9CisgICAgfSk7CisKKyAgfSwKKworICBtYWtlU29ydGFibGU6IGZ1bmN0aW9uKHRhYmxlKSB7CisgICAgaWYgKHRhYmxlLmdldEVsZW1lbnRzQnlUYWdOYW1lKCd0aGVhZCcpLmxlbmd0aCA9PSAwKSB7CisgICAgICAvLyB0YWJsZSBkb2Vzbid0IGhhdmUgYSB0SGVhZC4gU2luY2UgaXQgc2hvdWxkIGhhdmUsIGNyZWF0ZSBvbmUgYW5kCisgICAgICAvLyBwdXQgdGhlIGZpcnN0IHRhYmxlIHJvdyBpbiBpdC4KKyAgICAgIHRoZSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ3RoZWFkJyk7CisgICAgICB0aGUuYXBwZW5kQ2hpbGQodGFibGUucm93c1swXSk7CisgICAgICB0YWJsZS5pbnNlcnRCZWZvcmUodGhlLHRhYmxlLmZpcnN0Q2hpbGQpOworICAgIH0KKyAgICAvLyBTYWZhcmkgZG9lc24ndCBzdXBwb3J0IHRhYmxlLnRIZWFkLCBzaWdoCisgICAgaWYgKHRhYmxlLnRIZWFkID09IG51bGwpIHRhYmxlLnRIZWFkID0gdGFibGUuZ2V0RWxlbWVudHNCeVRhZ05hbWUoJ3RoZWFkJylbMF07CisKKyAgICBpZiAodGFibGUudEhlYWQucm93cy5sZW5ndGggIT0gMSkgcmV0dXJuOyAvLyBjYW4ndCBjb3BlIHdpdGggdHdvIGhlYWRlciByb3dzCisKKyAgICAvLyBTb3J0dGFibGUgdjEgcHV0IHJvd3Mgd2l0aCBhIGNsYXNzIG9mICJzb3J0Ym90dG9tIiBhdCB0aGUgYm90dG9tIChhcworICAgIC8vICJ0b3RhbCIgcm93cywgZm9yIGV4YW1wbGUpLiBUaGlzIGlzIEImUiwgc2luY2Ugd2hhdCB5b3UncmUgc3VwcG9zZWQKKyAgICAvLyB0byBkbyBpcyBwdXQgdGhlbSBpbiBhIHRmb290LiBTbywgaWYgdGhlcmUgYXJlIHNvcnRib3R0b20gcm93cywKKyAgICAvLyBmb3IgYmFja3dhcmQgY29tcGF0aWJpbGl0eSwgbW92ZSB0aGVtIHRvIHRmb290IChjcmVhdGluZyBpdCBpZiBuZWVkZWQpLgorICAgIHNvcnRib3R0b21yb3dzID0gW107CisgICAgZm9yICh2YXIgaT0wOyBpPHRhYmxlLnJvd3MubGVuZ3RoOyBpKyspIHsKKyAgICAgIGlmICh0YWJsZS5yb3dzW2ldLmNsYXNzTmFtZS5zZWFyY2goL1xic29ydGJvdHRvbVxiLykgIT0gLTEpIHsKKyAgICAgICAgc29ydGJvdHRvbXJvd3Nbc29ydGJvdHRvbXJvd3MubGVuZ3RoXSA9IHRhYmxlLnJvd3NbaV07CisgICAgICB9CisgICAgfQorICAgIGlmIChzb3J0Ym90dG9tcm93cykgeworICAgICAgaWYgKHRhYmxlLnRGb290ID09IG51bGwpIHsKKyAgICAgICAgLy8gdGFibGUgZG9lc24ndCBoYXZlIGEgdGZvb3QuIENyZWF0ZSBvbmUuCisgICAgICAgIHRmbyA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ3Rmb290Jyk7CisgICAgICAgIHRhYmxlLmFwcGVuZENoaWxkKHRmbyk7CisgICAgICB9CisgICAgICBmb3IgKHZhciBpPTA7IGk8c29ydGJvdHRvbXJvd3MubGVuZ3RoOyBpKyspIHsKKyAgICAgICAgdGZvLmFwcGVuZENoaWxkKHNvcnRib3R0b21yb3dzW2ldKTsKKyAgICAgIH0KKyAgICAgIGRlbGV0ZSBzb3J0Ym90dG9tcm93czsKKyAgICB9CisKKyAgICAvLyB3b3JrIHRocm91Z2ggZWFjaCBjb2x1bW4gYW5kIGNhbGN1bGF0ZSBpdHMgdHlwZQorICAgIGhlYWRyb3cgPSB0YWJsZS50SGVhZC5yb3dzWzBdLmNlbGxzOworICAgIGZvciAodmFyIGk9MDsgaTxoZWFkcm93Lmxlbmd0aDsgaSsrKSB7CisgICAgICAvLyBtYW51YWxseSBvdmVycmlkZSB0aGUgdHlwZSB3aXRoIGEgc29ydHRhYmxlX3R5cGUgYXR0cmlidXRlCisgICAgICBpZiAoIWhlYWRyb3dbaV0uY2xhc3NOYW1lLm1hdGNoKC9cYnNvcnR0YWJsZV9ub3NvcnRcYi8pKSB7IC8vIHNraXAgdGhpcyBjb2wKKyAgICAgICAgbXRjaCA9IGhlYWRyb3dbaV0uY2xhc3NOYW1lLm1hdGNoKC9cYnNvcnR0YWJsZV8oW2EtejAtOV0rKVxiLyk7CisgICAgICAgIGlmIChtdGNoKSB7IG92ZXJyaWRlID0gbXRjaFsxXTsgfQorCSAgICAgIGlmIChtdGNoICYmIHR5cGVvZiBzb3J0dGFibGVbInNvcnRfIitvdmVycmlkZV0gPT0gJ2Z1bmN0aW9uJykgeworCSAgICAgICAgaGVhZHJvd1tpXS5zb3J0dGFibGVfc29ydGZ1bmN0aW9uID0gc29ydHRhYmxlWyJzb3J0XyIrb3ZlcnJpZGVdOworCSAgICAgIH0gZWxzZSB7CisJICAgICAgICBoZWFkcm93W2ldLnNvcnR0YWJsZV9zb3J0ZnVuY3Rpb24gPSBzb3J0dGFibGUuZ3Vlc3NUeXBlKHRhYmxlLGkpOworCSAgICAgIH0KKwkgICAgICAvLyBtYWtlIGl0IGNsaWNrYWJsZSB0byBzb3J0CisJICAgICAgaGVhZHJvd1tpXS5zb3J0dGFibGVfY29sdW1uaW5kZXggPSBpOworCSAgICAgIGhlYWRyb3dbaV0uc29ydHRhYmxlX3Rib2R5ID0gdGFibGUudEJvZGllc1swXTsKKwkgICAgICBkZWFuX2FkZEV2ZW50KGhlYWRyb3dbaV0sImNsaWNrIiwgZnVuY3Rpb24oZSkgeworCisgICAgICAgICAgaWYgKHRoaXMuY2xhc3NOYW1lLnNlYXJjaCgvXGJzb3J0dGFibGVfc29ydGVkXGIvKSAhPSAtMSkgeworICAgICAgICAgICAgLy8gaWYgd2UncmUgYWxyZWFkeSBzb3J0ZWQgYnkgdGhpcyBjb2x1bW4sIGp1c3QKKyAgICAgICAgICAgIC8vIHJldmVyc2UgdGhlIHRhYmxlLCB3aGljaCBpcyBxdWlja2VyCisgICAgICAgICAgICBzb3J0dGFibGUucmV2ZXJzZSh0aGlzLnNvcnR0YWJsZV90Ym9keSk7CisgICAgICAgICAgICB0aGlzLmNsYXNzTmFtZSA9IHRoaXMuY2xhc3NOYW1lLnJlcGxhY2UoJ3NvcnR0YWJsZV9zb3J0ZWQnLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdzb3J0dGFibGVfc29ydGVkX3JldmVyc2UnKTsKKyAgICAgICAgICAgIHRoaXMucmVtb3ZlQ2hpbGQoZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoJ3NvcnR0YWJsZV9zb3J0ZndkaW5kJykpOworICAgICAgICAgICAgc29ydHJldmluZCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ3NwYW4nKTsKKyAgICAgICAgICAgIHNvcnRyZXZpbmQuaWQgPSAic29ydHRhYmxlX3NvcnRyZXZpbmQiOworICAgICAgICAgICAgc29ydHJldmluZC5pbm5lckhUTUwgPSBzdElzSUUgPyAnJm5ic3A8Zm9udCBmYWNlPSJ3ZWJkaW5ncyI+NTwvZm9udD4nIDogJyZuYnNwOyYjeDI1QjQ7JzsKKyAgICAgICAgICAgIHRoaXMuYXBwZW5kQ2hpbGQoc29ydHJldmluZCk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgICAgfQorICAgICAgICAgIGlmICh0aGlzLmNsYXNzTmFtZS5zZWFyY2goL1xic29ydHRhYmxlX3NvcnRlZF9yZXZlcnNlXGIvKSAhPSAtMSkgeworICAgICAgICAgICAgLy8gaWYgd2UncmUgYWxyZWFkeSBzb3J0ZWQgYnkgdGhpcyBjb2x1bW4gaW4gcmV2ZXJzZSwganVzdAorICAgICAgICAgICAgLy8gcmUtcmV2ZXJzZSB0aGUgdGFibGUsIHdoaWNoIGlzIHF1aWNrZXIKKyAgICAgICAgICAgIHNvcnR0YWJsZS5yZXZlcnNlKHRoaXMuc29ydHRhYmxlX3Rib2R5KTsKKyAgICAgICAgICAgIHRoaXMuY2xhc3NOYW1lID0gdGhpcy5jbGFzc05hbWUucmVwbGFjZSgnc29ydHRhYmxlX3NvcnRlZF9yZXZlcnNlJywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnc29ydHRhYmxlX3NvcnRlZCcpOworICAgICAgICAgICAgdGhpcy5yZW1vdmVDaGlsZChkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnc29ydHRhYmxlX3NvcnRyZXZpbmQnKSk7CisgICAgICAgICAgICBzb3J0ZndkaW5kID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnc3BhbicpOworICAgICAgICAgICAgc29ydGZ3ZGluZC5pZCA9ICJzb3J0dGFibGVfc29ydGZ3ZGluZCI7CisgICAgICAgICAgICBzb3J0ZndkaW5kLmlubmVySFRNTCA9IHN0SXNJRSA/ICcmbmJzcDxmb250IGZhY2U9IndlYmRpbmdzIj42PC9mb250PicgOiAnJm5ic3A7JiN4MjVCRTsnOworICAgICAgICAgICAgdGhpcy5hcHBlbmRDaGlsZChzb3J0ZndkaW5kKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgICB9CisKKyAgICAgICAgICAvLyByZW1vdmUgc29ydHRhYmxlX3NvcnRlZCBjbGFzc2VzCisgICAgICAgICAgdGhlYWRyb3cgPSB0aGlzLnBhcmVudE5vZGU7CisgICAgICAgICAgZm9yRWFjaCh0aGVhZHJvdy5jaGlsZE5vZGVzLCBmdW5jdGlvbihjZWxsKSB7CisgICAgICAgICAgICBpZiAoY2VsbC5ub2RlVHlwZSA9PSAxKSB7IC8vIGFuIGVsZW1lbnQKKyAgICAgICAgICAgICAgY2VsbC5jbGFzc05hbWUgPSBjZWxsLmNsYXNzTmFtZS5yZXBsYWNlKCdzb3J0dGFibGVfc29ydGVkX3JldmVyc2UnLCcnKTsKKyAgICAgICAgICAgICAgY2VsbC5jbGFzc05hbWUgPSBjZWxsLmNsYXNzTmFtZS5yZXBsYWNlKCdzb3J0dGFibGVfc29ydGVkJywnJyk7CisgICAgICAgICAgICB9CisgICAgICAgICAgfSk7CisgICAgICAgICAgc29ydGZ3ZGluZCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdzb3J0dGFibGVfc29ydGZ3ZGluZCcpOworICAgICAgICAgIGlmIChzb3J0ZndkaW5kKSB7IHNvcnRmd2RpbmQucGFyZW50Tm9kZS5yZW1vdmVDaGlsZChzb3J0ZndkaW5kKTsgfQorICAgICAgICAgIHNvcnRyZXZpbmQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgnc29ydHRhYmxlX3NvcnRyZXZpbmQnKTsKKyAgICAgICAgICBpZiAoc29ydHJldmluZCkgeyBzb3J0cmV2aW5kLnBhcmVudE5vZGUucmVtb3ZlQ2hpbGQoc29ydHJldmluZCk7IH0KKworICAgICAgICAgIHRoaXMuY2xhc3NOYW1lICs9ICcgc29ydHRhYmxlX3NvcnRlZCc7CisgICAgICAgICAgc29ydGZ3ZGluZCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ3NwYW4nKTsKKyAgICAgICAgICBzb3J0ZndkaW5kLmlkID0gInNvcnR0YWJsZV9zb3J0ZndkaW5kIjsKKyAgICAgICAgICBzb3J0ZndkaW5kLmlubmVySFRNTCA9IHN0SXNJRSA/ICcmbmJzcDxmb250IGZhY2U9IndlYmRpbmdzIj42PC9mb250PicgOiAnJm5ic3A7JiN4MjVCRTsnOworICAgICAgICAgIHRoaXMuYXBwZW5kQ2hpbGQoc29ydGZ3ZGluZCk7CisKKwkgICAgICAgIC8vIGJ1aWxkIGFuIGFycmF5IHRvIHNvcnQuIFRoaXMgaXMgYSBTY2h3YXJ0emlhbiB0cmFuc2Zvcm0gdGhpbmcsCisJICAgICAgICAvLyBpLmUuLCB3ZSAiZGVjb3JhdGUiIGVhY2ggcm93IHdpdGggdGhlIGFjdHVhbCBzb3J0IGtleSwKKwkgICAgICAgIC8vIHNvcnQgYmFzZWQgb24gdGhlIHNvcnQga2V5cywgYW5kIHRoZW4gcHV0IHRoZSByb3dzIGJhY2sgaW4gb3JkZXIKKwkgICAgICAgIC8vIHdoaWNoIGlzIGEgbG90IGZhc3RlciBiZWNhdXNlIHlvdSBvbmx5IGRvIGdldElubmVyVGV4dCBvbmNlIHBlciByb3cKKwkgICAgICAgIHJvd19hcnJheSA9IFtdOworCSAgICAgICAgY29sID0gdGhpcy5zb3J0dGFibGVfY29sdW1uaW5kZXg7CisJICAgICAgICByb3dzID0gdGhpcy5zb3J0dGFibGVfdGJvZHkucm93czsKKwkgICAgICAgIGZvciAodmFyIGo9MDsgajxyb3dzLmxlbmd0aDsgaisrKSB7CisJICAgICAgICAgIHJvd19hcnJheVtyb3dfYXJyYXkubGVuZ3RoXSA9IFtzb3J0dGFibGUuZ2V0SW5uZXJUZXh0KHJvd3Nbal0uY2VsbHNbY29sXSksIHJvd3Nbal1dOworCSAgICAgICAgfQorCSAgICAgICAgLyogSWYgeW91IHdhbnQgYSBzdGFibGUgc29ydCwgdW5jb21tZW50IHRoZSBmb2xsb3dpbmcgbGluZSAqLworCSAgICAgICAgc29ydHRhYmxlLnNoYWtlcl9zb3J0KHJvd19hcnJheSwgdGhpcy5zb3J0dGFibGVfc29ydGZ1bmN0aW9uKTsKKwkgICAgICAgIC8qIGFuZCBjb21tZW50IG91dCB0aGlzIG9uZSAqLworCSAgICAgICAgLy9yb3dfYXJyYXkuc29ydCh0aGlzLnNvcnR0YWJsZV9zb3J0ZnVuY3Rpb24pOworCisJICAgICAgICB0YiA9IHRoaXMuc29ydHRhYmxlX3Rib2R5OworCSAgICAgICAgZm9yICh2YXIgaj0wOyBqPHJvd19hcnJheS5sZW5ndGg7IGorKykgeworCSAgICAgICAgICB0Yi5hcHBlbmRDaGlsZChyb3dfYXJyYXlbal1bMV0pOworCSAgICAgICAgfQorCisJICAgICAgICBkZWxldGUgcm93X2FycmF5OworCSAgICAgIH0pOworCSAgICB9CisgICAgfQorICB9LAorCisgIGd1ZXNzVHlwZTogZnVuY3Rpb24odGFibGUsIGNvbHVtbikgeworICAgIC8vIGd1ZXNzIHRoZSB0eXBlIG9mIGEgY29sdW1uIGJhc2VkIG9uIGl0cyBmaXJzdCBub24tYmxhbmsgcm93CisgICAgc29ydGZuID0gc29ydHRhYmxlLnNvcnRfYWxwaGE7CisgICAgZm9yICh2YXIgaT0wOyBpPHRhYmxlLnRCb2RpZXNbMF0ucm93cy5sZW5ndGg7IGkrKykgeworICAgICAgdGV4dCA9IHNvcnR0YWJsZS5nZXRJbm5lclRleHQodGFibGUudEJvZGllc1swXS5yb3dzW2ldLmNlbGxzW2NvbHVtbl0pOworICAgICAgaWYgKHRleHQgIT0gJycpIHsKKyAgICAgICAgaWYgKHRleHQubWF0Y2goL14tP1ujJKRdP1tcZCwuXSslPyQvKSkgeworICAgICAgICAgIHJldHVybiBzb3J0dGFibGUuc29ydF9udW1lcmljOworICAgICAgICB9CisgICAgICAgIC8vIGNoZWNrIGZvciBhIGRhdGU6IGRkL21tL3l5eXkgb3IgZGQvbW0veXkKKyAgICAgICAgLy8gY2FuIGhhdmUgLyBvciAuIG9yIC0gYXMgc2VwYXJhdG9yCisgICAgICAgIC8vIGNhbiBiZSBtbS9kZCBhcyB3ZWxsCisgICAgICAgIHBvc3NkYXRlID0gdGV4dC5tYXRjaChzb3J0dGFibGUuREFURV9SRSkKKyAgICAgICAgaWYgKHBvc3NkYXRlKSB7CisgICAgICAgICAgLy8gbG9va3MgbGlrZSBhIGRhdGUKKyAgICAgICAgICBmaXJzdCA9IHBhcnNlSW50KHBvc3NkYXRlWzFdKTsKKyAgICAgICAgICBzZWNvbmQgPSBwYXJzZUludChwb3NzZGF0ZVsyXSk7CisgICAgICAgICAgaWYgKGZpcnN0ID4gMTIpIHsKKyAgICAgICAgICAgIC8vIGRlZmluaXRlbHkgZGQvbW0KKyAgICAgICAgICAgIHJldHVybiBzb3J0dGFibGUuc29ydF9kZG1tOworICAgICAgICAgIH0gZWxzZSBpZiAoc2Vjb25kID4gMTIpIHsKKyAgICAgICAgICAgIHJldHVybiBzb3J0dGFibGUuc29ydF9tbWRkOworICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAvLyBsb29rcyBsaWtlIGEgZGF0ZSwgYnV0IHdlIGNhbid0IHRlbGwgd2hpY2gsIHNvIGFzc3VtZQorICAgICAgICAgICAgLy8gdGhhdCBpdCdzIGRkL21tIChFbmdsaXNoIGltcGVyaWFsaXNtISkgYW5kIGtlZXAgbG9va2luZworICAgICAgICAgICAgc29ydGZuID0gc29ydHRhYmxlLnNvcnRfZGRtbTsKKyAgICAgICAgICB9CisgICAgICAgIH0KKyAgICAgIH0KKyAgICB9CisgICAgcmV0dXJuIHNvcnRmbjsKKyAgfSwKKworICBnZXRJbm5lclRleHQ6IGZ1bmN0aW9uKG5vZGUpIHsKKyAgICAvLyBnZXRzIHRoZSB0ZXh0IHdlIHdhbnQgdG8gdXNlIGZvciBzb3J0aW5nIGZvciBhIGNlbGwuCisgICAgLy8gc3RyaXBzIGxlYWRpbmcgYW5kIHRyYWlsaW5nIHdoaXRlc3BhY2UuCisgICAgLy8gdGhpcyBpcyAqbm90KiBhIGdlbmVyaWMgZ2V0SW5uZXJUZXh0IGZ1bmN0aW9uOyBpdCdzIHNwZWNpYWwgdG8gc29ydHRhYmxlLgorICAgIC8vIGZvciBleGFtcGxlLCB5b3UgY2FuIG92ZXJyaWRlIHRoZSBjZWxsIHRleHQgd2l0aCBhIGN1c3RvbWtleSBhdHRyaWJ1dGUuCisgICAgLy8gaXQgYWxzbyBnZXRzIC52YWx1ZSBmb3IgPGlucHV0PiBmaWVsZHMuCisKKyAgICBoYXNJbnB1dHMgPSAodHlwZW9mIG5vZGUuZ2V0RWxlbWVudHNCeVRhZ05hbWUgPT0gJ2Z1bmN0aW9uJykgJiYKKyAgICAgICAgICAgICAgICAgbm9kZS5nZXRFbGVtZW50c0J5VGFnTmFtZSgnaW5wdXQnKS5sZW5ndGg7CisKKyAgICBpZiAobm9kZS5nZXRBdHRyaWJ1dGUoInNvcnR0YWJsZV9jdXN0b21rZXkiKSAhPSBudWxsKSB7CisgICAgICByZXR1cm4gbm9kZS5nZXRBdHRyaWJ1dGUoInNvcnR0YWJsZV9jdXN0b21rZXkiKTsKKyAgICB9CisgICAgZWxzZSBpZiAodHlwZW9mIG5vZGUudGV4dENvbnRlbnQgIT0gJ3VuZGVmaW5lZCcgJiYgIWhhc0lucHV0cykgeworICAgICAgcmV0dXJuIG5vZGUudGV4dENvbnRlbnQucmVwbGFjZSgvXlxzK3xccyskL2csICcnKTsKKyAgICB9CisgICAgZWxzZSBpZiAodHlwZW9mIG5vZGUuaW5uZXJUZXh0ICE9ICd1bmRlZmluZWQnICYmICFoYXNJbnB1dHMpIHsKKyAgICAgIHJldHVybiBub2RlLmlubmVyVGV4dC5yZXBsYWNlKC9eXHMrfFxzKyQvZywgJycpOworICAgIH0KKyAgICBlbHNlIGlmICh0eXBlb2Ygbm9kZS50ZXh0ICE9ICd1bmRlZmluZWQnICYmICFoYXNJbnB1dHMpIHsKKyAgICAgIHJldHVybiBub2RlLnRleHQucmVwbGFjZSgvXlxzK3xccyskL2csICcnKTsKKyAgICB9CisgICAgZWxzZSB7CisgICAgICBzd2l0Y2ggKG5vZGUubm9kZVR5cGUpIHsKKyAgICAgICAgY2FzZSAzOgorICAgICAgICAgIGlmIChub2RlLm5vZGVOYW1lLnRvTG93ZXJDYXNlKCkgPT0gJ2lucHV0JykgeworICAgICAgICAgICAgcmV0dXJuIG5vZGUudmFsdWUucmVwbGFjZSgvXlxzK3xccyskL2csICcnKTsKKyAgICAgICAgICB9CisgICAgICAgIGNhc2UgNDoKKyAgICAgICAgICByZXR1cm4gbm9kZS5ub2RlVmFsdWUucmVwbGFjZSgvXlxzK3xccyskL2csICcnKTsKKyAgICAgICAgICBicmVhazsKKyAgICAgICAgY2FzZSAxOgorICAgICAgICBjYXNlIDExOgorICAgICAgICAgIHZhciBpbm5lclRleHQgPSAnJzsKKyAgICAgICAgICBmb3IgKHZhciBpID0gMDsgaSA8IG5vZGUuY2hpbGROb2Rlcy5sZW5ndGg7IGkrKykgeworICAgICAgICAgICAgaW5uZXJUZXh0ICs9IHNvcnR0YWJsZS5nZXRJbm5lclRleHQobm9kZS5jaGlsZE5vZGVzW2ldKTsKKyAgICAgICAgICB9CisgICAgICAgICAgcmV0dXJuIGlubmVyVGV4dC5yZXBsYWNlKC9eXHMrfFxzKyQvZywgJycpOworICAgICAgICAgIGJyZWFrOworICAgICAgICBkZWZhdWx0OgorICAgICAgICAgIHJldHVybiAnJzsKKyAgICAgIH0KKyAgICB9CisgIH0sCisKKyAgcmV2ZXJzZTogZnVuY3Rpb24odGJvZHkpIHsKKyAgICAvLyByZXZlcnNlIHRoZSByb3dzIGluIGEgdGJvZHkKKyAgICBuZXdyb3dzID0gW107CisgICAgZm9yICh2YXIgaT0wOyBpPHRib2R5LnJvd3MubGVuZ3RoOyBpKyspIHsKKyAgICAgIG5ld3Jvd3NbbmV3cm93cy5sZW5ndGhdID0gdGJvZHkucm93c1tpXTsKKyAgICB9CisgICAgZm9yICh2YXIgaT1uZXdyb3dzLmxlbmd0aC0xOyBpPj0wOyBpLS0pIHsKKyAgICAgICB0Ym9keS5hcHBlbmRDaGlsZChuZXdyb3dzW2ldKTsKKyAgICB9CisgICAgZGVsZXRlIG5ld3Jvd3M7CisgIH0sCisKKyAgLyogc29ydCBmdW5jdGlvbnMKKyAgICAgZWFjaCBzb3J0IGZ1bmN0aW9uIHRha2VzIHR3byBwYXJhbWV0ZXJzLCBhIGFuZCBiCisgICAgIHlvdSBhcmUgY29tcGFyaW5nIGFbMF0gYW5kIGJbMF0gKi8KKyAgc29ydF9udW1lcmljOiBmdW5jdGlvbihhLGIpIHsKKyAgICBhYSA9IHBhcnNlRmxvYXQoYVswXS5yZXBsYWNlKC9bXjAtOS4tXS9nLCcnKSk7CisgICAgaWYgKGlzTmFOKGFhKSkgYWEgPSAwOworICAgIGJiID0gcGFyc2VGbG9hdChiWzBdLnJlcGxhY2UoL1teMC05Li1dL2csJycpKTsKKyAgICBpZiAoaXNOYU4oYmIpKSBiYiA9IDA7CisgICAgcmV0dXJuIGFhLWJiOworICB9LAorICBzb3J0X2FscGhhOiBmdW5jdGlvbihhLGIpIHsKKyAgICBpZiAoYVswXT09YlswXSkgcmV0dXJuIDA7CisgICAgaWYgKGFbMF08YlswXSkgcmV0dXJuIC0xOworICAgIHJldHVybiAxOworICB9LAorICBzb3J0X2RkbW06IGZ1bmN0aW9uKGEsYikgeworICAgIG10Y2ggPSBhWzBdLm1hdGNoKHNvcnR0YWJsZS5EQVRFX1JFKTsKKyAgICB5ID0gbXRjaFszXTsgbSA9IG10Y2hbMl07IGQgPSBtdGNoWzFdOworICAgIGlmIChtLmxlbmd0aCA9PSAxKSBtID0gJzAnK207CisgICAgaWYgKGQubGVuZ3RoID09IDEpIGQgPSAnMCcrZDsKKyAgICBkdDEgPSB5K20rZDsKKyAgICBtdGNoID0gYlswXS5tYXRjaChzb3J0dGFibGUuREFURV9SRSk7CisgICAgeSA9IG10Y2hbM107IG0gPSBtdGNoWzJdOyBkID0gbXRjaFsxXTsKKyAgICBpZiAobS5sZW5ndGggPT0gMSkgbSA9ICcwJyttOworICAgIGlmIChkLmxlbmd0aCA9PSAxKSBkID0gJzAnK2Q7CisgICAgZHQyID0geSttK2Q7CisgICAgaWYgKGR0MT09ZHQyKSByZXR1cm4gMDsKKyAgICBpZiAoZHQxPGR0MikgcmV0dXJuIC0xOworICAgIHJldHVybiAxOworICB9LAorICBzb3J0X21tZGQ6IGZ1bmN0aW9uKGEsYikgeworICAgIG10Y2ggPSBhWzBdLm1hdGNoKHNvcnR0YWJsZS5EQVRFX1JFKTsKKyAgICB5ID0gbXRjaFszXTsgZCA9IG10Y2hbMl07IG0gPSBtdGNoWzFdOworICAgIGlmIChtLmxlbmd0aCA9PSAxKSBtID0gJzAnK207CisgICAgaWYgKGQubGVuZ3RoID09IDEpIGQgPSAnMCcrZDsKKyAgICBkdDEgPSB5K20rZDsKKyAgICBtdGNoID0gYlswXS5tYXRjaChzb3J0dGFibGUuREFURV9SRSk7CisgICAgeSA9IG10Y2hbM107IGQgPSBtdGNoWzJdOyBtID0gbXRjaFsxXTsKKyAgICBpZiAobS5sZW5ndGggPT0gMSkgbSA9ICcwJyttOworICAgIGlmIChkLmxlbmd0aCA9PSAxKSBkID0gJzAnK2Q7CisgICAgZHQyID0geSttK2Q7CisgICAgaWYgKGR0MT09ZHQyKSByZXR1cm4gMDsKKyAgICBpZiAoZHQxPGR0MikgcmV0dXJuIC0xOworICAgIHJldHVybiAxOworICB9LAorCisgIHNoYWtlcl9zb3J0OiBmdW5jdGlvbihsaXN0LCBjb21wX2Z1bmMpIHsKKyAgICAvLyBBIHN0YWJsZSBzb3J0IGZ1bmN0aW9uIHRvIGFsbG93IG11bHRpLWxldmVsIHNvcnRpbmcgb2YgZGF0YQorICAgIC8vIHNlZTogaHR0cDovL2VuLndpa2lwZWRpYS5vcmcvd2lraS9Db2NrdGFpbF9zb3J0CisgICAgLy8gdGhhbmtzIHRvIEpvc2VwaCBOYWhtaWFzCisgICAgdmFyIGIgPSAwOworICAgIHZhciB0ID0gbGlzdC5sZW5ndGggLSAxOworICAgIHZhciBzd2FwID0gdHJ1ZTsKKworICAgIHdoaWxlKHN3YXApIHsKKyAgICAgICAgc3dhcCA9IGZhbHNlOworICAgICAgICBmb3IodmFyIGkgPSBiOyBpIDwgdDsgKytpKSB7CisgICAgICAgICAgICBpZiAoIGNvbXBfZnVuYyhsaXN0W2ldLCBsaXN0W2krMV0pID4gMCApIHsKKyAgICAgICAgICAgICAgICB2YXIgcSA9IGxpc3RbaV07IGxpc3RbaV0gPSBsaXN0W2krMV07IGxpc3RbaSsxXSA9IHE7CisgICAgICAgICAgICAgICAgc3dhcCA9IHRydWU7CisgICAgICAgICAgICB9CisgICAgICAgIH0gLy8gZm9yCisgICAgICAgIHQtLTsKKworICAgICAgICBpZiAoIXN3YXApIGJyZWFrOworCisgICAgICAgIGZvcih2YXIgaSA9IHQ7IGkgPiBiOyAtLWkpIHsKKyAgICAgICAgICAgIGlmICggY29tcF9mdW5jKGxpc3RbaV0sIGxpc3RbaS0xXSkgPCAwICkgeworICAgICAgICAgICAgICAgIHZhciBxID0gbGlzdFtpXTsgbGlzdFtpXSA9IGxpc3RbaS0xXTsgbGlzdFtpLTFdID0gcTsKKyAgICAgICAgICAgICAgICBzd2FwID0gdHJ1ZTsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfSAvLyBmb3IKKyAgICAgICAgYisrOworCisgICAgfSAvLyB3aGlsZShzd2FwKQorICB9Cit9CisKKy8qICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKgorICAgU3VwcG9ydGluZyBmdW5jdGlvbnM6IGJ1bmRsZWQgaGVyZSB0byBhdm9pZCBkZXBlbmRpbmcgb24gYSBsaWJyYXJ5CisgICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKiogKi8KKworLy8gRGVhbiBFZHdhcmRzL01hdHRoaWFzIE1pbGxlci9Kb2huIFJlc2lnCisKKy8qIGZvciBNb3ppbGxhL09wZXJhOSAqLworaWYgKGRvY3VtZW50LmFkZEV2ZW50TGlzdGVuZXIpIHsKKyAgICBkb2N1bWVudC5hZGRFdmVudExpc3RlbmVyKCJET01Db250ZW50TG9hZGVkIiwgc29ydHRhYmxlLmluaXQsIGZhbHNlKTsKK30KKworLyogZm9yIEludGVybmV0IEV4cGxvcmVyICovCisvKkBjY19vbiBAKi8KKy8qQGlmIChAX3dpbjMyKQorICAgIGRvY3VtZW50LndyaXRlKCI8c2NyaXB0IGlkPV9faWVfb25sb2FkIGRlZmVyIHNyYz1qYXZhc2NyaXB0OnZvaWQoMCk+PFwvc2NyaXB0PiIpOworICAgIHZhciBzY3JpcHQgPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZCgiX19pZV9vbmxvYWQiKTsKKyAgICBzY3JpcHQub25yZWFkeXN0YXRlY2hhbmdlID0gZnVuY3Rpb24oKSB7CisgICAgICAgIGlmICh0aGlzLnJlYWR5U3RhdGUgPT0gImNvbXBsZXRlIikgeworICAgICAgICAgICAgc29ydHRhYmxlLmluaXQoKTsgLy8gY2FsbCB0aGUgb25sb2FkIGhhbmRsZXIKKyAgICAgICAgfQorICAgIH07CisvKkBlbmQgQCovCisKKy8qIGZvciBTYWZhcmkgKi8KK2lmICgvV2ViS2l0L2kudGVzdChuYXZpZ2F0b3IudXNlckFnZW50KSkgeyAvLyBzbmlmZgorICAgIHZhciBfdGltZXIgPSBzZXRJbnRlcnZhbChmdW5jdGlvbigpIHsKKyAgICAgICAgaWYgKC9sb2FkZWR8Y29tcGxldGUvLnRlc3QoZG9jdW1lbnQucmVhZHlTdGF0ZSkpIHsKKyAgICAgICAgICAgIHNvcnR0YWJsZS5pbml0KCk7IC8vIGNhbGwgdGhlIG9ubG9hZCBoYW5kbGVyCisgICAgICAgIH0KKyAgICB9LCAxMCk7Cit9CisKKy8qIGZvciBvdGhlciBicm93c2VycyAqLword2luZG93Lm9ubG9hZCA9IHNvcnR0YWJsZS5pbml0OworCisvLyB3cml0dGVuIGJ5IERlYW4gRWR3YXJkcywgMjAwNQorLy8gd2l0aCBpbnB1dCBmcm9tIFRpbm8gWmlqZGVsLCBNYXR0aGlhcyBNaWxsZXIsIERpZWdvIFBlcmluaQorCisvLyBodHRwOi8vZGVhbi5lZHdhcmRzLm5hbWUvd2VibG9nLzIwMDUvMTAvYWRkLWV2ZW50LworCitmdW5jdGlvbiBkZWFuX2FkZEV2ZW50KGVsZW1lbnQsIHR5cGUsIGhhbmRsZXIpIHsKKwlpZiAoZWxlbWVudC5hZGRFdmVudExpc3RlbmVyKSB7CisJCWVsZW1lbnQuYWRkRXZlbnRMaXN0ZW5lcih0eXBlLCBoYW5kbGVyLCBmYWxzZSk7CisJfSBlbHNlIHsKKwkJLy8gYXNzaWduIGVhY2ggZXZlbnQgaGFuZGxlciBhIHVuaXF1ZSBJRAorCQlpZiAoIWhhbmRsZXIuJCRndWlkKSBoYW5kbGVyLiQkZ3VpZCA9IGRlYW5fYWRkRXZlbnQuZ3VpZCsrOworCQkvLyBjcmVhdGUgYSBoYXNoIHRhYmxlIG9mIGV2ZW50IHR5cGVzIGZvciB0aGUgZWxlbWVudAorCQlpZiAoIWVsZW1lbnQuZXZlbnRzKSBlbGVtZW50LmV2ZW50cyA9IHt9OworCQkvLyBjcmVhdGUgYSBoYXNoIHRhYmxlIG9mIGV2ZW50IGhhbmRsZXJzIGZvciBlYWNoIGVsZW1lbnQvZXZlbnQgcGFpcgorCQl2YXIgaGFuZGxlcnMgPSBlbGVtZW50LmV2ZW50c1t0eXBlXTsKKwkJaWYgKCFoYW5kbGVycykgeworCQkJaGFuZGxlcnMgPSBlbGVtZW50LmV2ZW50c1t0eXBlXSA9IHt9OworCQkJLy8gc3RvcmUgdGhlIGV4aXN0aW5nIGV2ZW50IGhhbmRsZXIgKGlmIHRoZXJlIGlzIG9uZSkKKwkJCWlmIChlbGVtZW50WyJvbiIgKyB0eXBlXSkgeworCQkJCWhhbmRsZXJzWzBdID0gZWxlbWVudFsib24iICsgdHlwZV07CisJCQl9CisJCX0KKwkJLy8gc3RvcmUgdGhlIGV2ZW50IGhhbmRsZXIgaW4gdGhlIGhhc2ggdGFibGUKKwkJaGFuZGxlcnNbaGFuZGxlci4kJGd1aWRdID0gaGFuZGxlcjsKKwkJLy8gYXNzaWduIGEgZ2xvYmFsIGV2ZW50IGhhbmRsZXIgdG8gZG8gYWxsIHRoZSB3b3JrCisJCWVsZW1lbnRbIm9uIiArIHR5cGVdID0gaGFuZGxlRXZlbnQ7CisJfQorfTsKKy8vIGEgY291bnRlciB1c2VkIHRvIGNyZWF0ZSB1bmlxdWUgSURzCitkZWFuX2FkZEV2ZW50Lmd1aWQgPSAxOworCitmdW5jdGlvbiByZW1vdmVFdmVudChlbGVtZW50LCB0eXBlLCBoYW5kbGVyKSB7CisJaWYgKGVsZW1lbnQucmVtb3ZlRXZlbnRMaXN0ZW5lcikgeworCQllbGVtZW50LnJlbW92ZUV2ZW50TGlzdGVuZXIodHlwZSwgaGFuZGxlciwgZmFsc2UpOworCX0gZWxzZSB7CisJCS8vIGRlbGV0ZSB0aGUgZXZlbnQgaGFuZGxlciBmcm9tIHRoZSBoYXNoIHRhYmxlCisJCWlmIChlbGVtZW50LmV2ZW50cyAmJiBlbGVtZW50LmV2ZW50c1t0eXBlXSkgeworCQkJZGVsZXRlIGVsZW1lbnQuZXZlbnRzW3R5cGVdW2hhbmRsZXIuJCRndWlkXTsKKwkJfQorCX0KK307CisKK2Z1bmN0aW9uIGhhbmRsZUV2ZW50KGV2ZW50KSB7CisJdmFyIHJldHVyblZhbHVlID0gdHJ1ZTsKKwkvLyBncmFiIHRoZSBldmVudCBvYmplY3QgKElFIHVzZXMgYSBnbG9iYWwgZXZlbnQgb2JqZWN0KQorCWV2ZW50ID0gZXZlbnQgfHwgZml4RXZlbnQoKCh0aGlzLm93bmVyRG9jdW1lbnQgfHwgdGhpcy5kb2N1bWVudCB8fCB0aGlzKS5wYXJlbnRXaW5kb3cgfHwgd2luZG93KS5ldmVudCk7CisJLy8gZ2V0IGEgcmVmZXJlbmNlIHRvIHRoZSBoYXNoIHRhYmxlIG9mIGV2ZW50IGhhbmRsZXJzCisJdmFyIGhhbmRsZXJzID0gdGhpcy5ldmVudHNbZXZlbnQudHlwZV07CisJLy8gZXhlY3V0ZSBlYWNoIGV2ZW50IGhhbmRsZXIKKwlmb3IgKHZhciBpIGluIGhhbmRsZXJzKSB7CisJCXRoaXMuJCRoYW5kbGVFdmVudCA9IGhhbmRsZXJzW2ldOworCQlpZiAodGhpcy4kJGhhbmRsZUV2ZW50KGV2ZW50KSA9PT0gZmFsc2UpIHsKKwkJCXJldHVyblZhbHVlID0gZmFsc2U7CisJCX0KKwl9CisJcmV0dXJuIHJldHVyblZhbHVlOworfTsKKworZnVuY3Rpb24gZml4RXZlbnQoZXZlbnQpIHsKKwkvLyBhZGQgVzNDIHN0YW5kYXJkIGV2ZW50IG1ldGhvZHMKKwlldmVudC5wcmV2ZW50RGVmYXVsdCA9IGZpeEV2ZW50LnByZXZlbnREZWZhdWx0OworCWV2ZW50LnN0b3BQcm9wYWdhdGlvbiA9IGZpeEV2ZW50LnN0b3BQcm9wYWdhdGlvbjsKKwlyZXR1cm4gZXZlbnQ7Cit9OworZml4RXZlbnQucHJldmVudERlZmF1bHQgPSBmdW5jdGlvbigpIHsKKwl0aGlzLnJldHVyblZhbHVlID0gZmFsc2U7Cit9OworZml4RXZlbnQuc3RvcFByb3BhZ2F0aW9uID0gZnVuY3Rpb24oKSB7CisgIHRoaXMuY2FuY2VsQnViYmxlID0gdHJ1ZTsKK30KKworLy8gRGVhbidzIGZvckVhY2g6IGh0dHA6Ly9kZWFuLmVkd2FyZHMubmFtZS9iYXNlL2ZvckVhY2guanMKKy8qCisJZm9yRWFjaCwgdmVyc2lvbiAxLjAKKwlDb3B5cmlnaHQgMjAwNiwgRGVhbiBFZHdhcmRzCisJTGljZW5zZTogaHR0cDovL3d3dy5vcGVuc291cmNlLm9yZy9saWNlbnNlcy9taXQtbGljZW5zZS5waHAKKyovCisKKy8vIGFycmF5LWxpa2UgZW51bWVyYXRpb24KK2lmICghQXJyYXkuZm9yRWFjaCkgeyAvLyBtb3ppbGxhIGFscmVhZHkgc3VwcG9ydHMgdGhpcworCUFycmF5LmZvckVhY2ggPSBmdW5jdGlvbihhcnJheSwgYmxvY2ssIGNvbnRleHQpIHsKKwkJZm9yICh2YXIgaSA9IDA7IGkgPCBhcnJheS5sZW5ndGg7IGkrKykgeworCQkJYmxvY2suY2FsbChjb250ZXh0LCBhcnJheVtpXSwgaSwgYXJyYXkpOworCQl9CisJfTsKK30KKworLy8gZ2VuZXJpYyBlbnVtZXJhdGlvbgorRnVuY3Rpb24ucHJvdG90eXBlLmZvckVhY2ggPSBmdW5jdGlvbihvYmplY3QsIGJsb2NrLCBjb250ZXh0KSB7CisJZm9yICh2YXIga2V5IGluIG9iamVjdCkgeworCQlpZiAodHlwZW9mIHRoaXMucHJvdG90eXBlW2tleV0gPT0gInVuZGVmaW5lZCIpIHsKKwkJCWJsb2NrLmNhbGwoY29udGV4dCwgb2JqZWN0W2tleV0sIGtleSwgb2JqZWN0KTsKKwkJfQorCX0KK307CisKKy8vIGNoYXJhY3RlciBlbnVtZXJhdGlvbgorU3RyaW5nLmZvckVhY2ggPSBmdW5jdGlvbihzdHJpbmcsIGJsb2NrLCBjb250ZXh0KSB7CisJQXJyYXkuZm9yRWFjaChzdHJpbmcuc3BsaXQoIiIpLCBmdW5jdGlvbihjaHIsIGluZGV4KSB7CisJCWJsb2NrLmNhbGwoY29udGV4dCwgY2hyLCBpbmRleCwgc3RyaW5nKTsKKwl9KTsKK307CisKKy8vIGdsb2JhbGx5IHJlc29sdmUgZm9yRWFjaCBlbnVtZXJhdGlvbgordmFyIGZvckVhY2ggPSBmdW5jdGlvbihvYmplY3QsIGJsb2NrLCBjb250ZXh0KSB7CisJaWYgKG9iamVjdCkgeworCQl2YXIgcmVzb2x2ZSA9IE9iamVjdDsgLy8gZGVmYXVsdAorCQlpZiAob2JqZWN0IGluc3RhbmNlb2YgRnVuY3Rpb24pIHsKKwkJCS8vIGZ1bmN0aW9ucyBoYXZlIGEgImxlbmd0aCIgcHJvcGVydHkKKwkJCXJlc29sdmUgPSBGdW5jdGlvbjsKKwkJfSBlbHNlIGlmIChvYmplY3QuZm9yRWFjaCBpbnN0YW5jZW9mIEZ1bmN0aW9uKSB7CisJCQkvLyB0aGUgb2JqZWN0IGltcGxlbWVudHMgYSBjdXN0b20gZm9yRWFjaCBtZXRob2Qgc28gdXNlIHRoYXQKKwkJCW9iamVjdC5mb3JFYWNoKGJsb2NrLCBjb250ZXh0KTsKKwkJCXJldHVybjsKKwkJfSBlbHNlIGlmICh0eXBlb2Ygb2JqZWN0ID09ICJzdHJpbmciKSB7CisJCQkvLyB0aGUgb2JqZWN0IGlzIGEgc3RyaW5nCisJCQlyZXNvbHZlID0gU3RyaW5nOworCQl9IGVsc2UgaWYgKHR5cGVvZiBvYmplY3QubGVuZ3RoID09ICJudW1iZXIiKSB7CisJCQkvLyB0aGUgb2JqZWN0IGlzIGFycmF5LWxpa2UKKwkJCXJlc29sdmUgPSBBcnJheTsKKwkJfQorCQlyZXNvbHZlLmZvckVhY2gob2JqZWN0LCBibG9jaywgY29udGV4dCk7CisJfQorfTsKZGlmZiAtLWdpdCBhL3Rvb2xzL3NjYW4tdmlldy9SZXBvcnRlci5weSBiL3Rvb2xzL3NjYW4tdmlldy9SZXBvcnRlci5weQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi45NTYwZmMxCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvc2Nhbi12aWV3L1JlcG9ydGVyLnB5CkBAIC0wLDAgKzEsMjQ4IEBACisiIiJNZXRob2RzIGZvciByZXBvcnRpbmcgYnVncy4iIiIKKworaW1wb3J0IHN1YnByb2Nlc3MsIHN5cywgb3MKKworX19hbGxfXyA9IFsnUmVwb3J0RmFpbHVyZScsICdCdWdSZXBvcnQnLCAnZ2V0UmVwb3J0ZXJzJ10KKworIworCitjbGFzcyBSZXBvcnRGYWlsdXJlKEV4Y2VwdGlvbik6CisgICAgIiIiR2VuZXJpYyBleGNlcHRpb24gZm9yIGZhaWx1cmVzIGluIGJ1ZyByZXBvcnRpbmcuIiIiCisgICAgZGVmIF9faW5pdF9fKHNlbGYsIHZhbHVlKTogICAgICAgIAorICAgICAgICBzZWxmLnZhbHVlID0gdmFsdWUKKworIyBDb2xsZWN0IGluZm9ybWF0aW9uIGFib3V0IGEgYnVnLgorCitjbGFzcyBCdWdSZXBvcnQ6CisgICAgZGVmIF9faW5pdF9fKHNlbGYsIHRpdGxlLCBkZXNjcmlwdGlvbiwgZmlsZXMpOgorICAgICAgICBzZWxmLnRpdGxlID0gdGl0bGUKKyAgICAgICAgc2VsZi5kZXNjcmlwdGlvbiA9IGRlc2NyaXB0aW9uCisgICAgICAgIHNlbGYuZmlsZXMgPSBmaWxlcworCisjIFJlcG9ydGVyIGludGVyZmFjZXMuCisKK2ltcG9ydCBvcworCitpbXBvcnQgZW1haWwsIG1pbWV0eXBlcywgc210cGxpYgorZnJvbSBlbWFpbCBpbXBvcnQgZW5jb2RlcnMKK2Zyb20gZW1haWwubWVzc2FnZSBpbXBvcnQgTWVzc2FnZQorZnJvbSBlbWFpbC5taW1lLmJhc2UgaW1wb3J0IE1JTUVCYXNlCitmcm9tIGVtYWlsLm1pbWUubXVsdGlwYXJ0IGltcG9ydCBNSU1FTXVsdGlwYXJ0Citmcm9tIGVtYWlsLm1pbWUudGV4dCBpbXBvcnQgTUlNRVRleHQKKworIz09PS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLT09PSMKKyMgUmVwb3J0ZXJQYXJhbWV0ZXIKKyM9PT0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS09PT0jCisKK2NsYXNzIFJlcG9ydGVyUGFyYW1ldGVyOgorICBkZWYgX19pbml0X18oc2VsZiwgbik6CisgICAgc2VsZi5uYW1lID0gbgorICBkZWYgZ2V0TmFtZShzZWxmKToKKyAgICByZXR1cm4gc2VsZi5uYW1lCisgIGRlZiBnZXRWYWx1ZShzZWxmLHIsYnVndHlwZSxnZXRDb25maWdPcHRpb24pOgorICAgICByZXR1cm4gZ2V0Q29uZmlnT3B0aW9uKHIuZ2V0TmFtZSgpLHNlbGYuZ2V0TmFtZSgpKQorICBkZWYgc2F2ZUNvbmZpZ1ZhbHVlKHNlbGYpOgorICAgIHJldHVybiBUcnVlCisKK2NsYXNzIFRleHRQYXJhbWV0ZXIgKFJlcG9ydGVyUGFyYW1ldGVyKToKKyAgZGVmIGdldEhUTUwoc2VsZixyLGJ1Z3R5cGUsZ2V0Q29uZmlnT3B0aW9uKToKKyAgICByZXR1cm4gIiIiXAorPHRyPgorPHRkIGNsYXNzPSJmb3JtX2NsYWJlbCI+JXM6PC90ZD4KKzx0ZCBjbGFzcz0iZm9ybV92YWx1ZSI+PGlucHV0IHR5cGU9InRleHQiIG5hbWU9IiVzXyVzIiB2YWx1ZT0iJXMiPjwvdGQ+Cis8L3RyPiIiIiUoc2VsZi5nZXROYW1lKCksci5nZXROYW1lKCksc2VsZi5nZXROYW1lKCksc2VsZi5nZXRWYWx1ZShyLGJ1Z3R5cGUsZ2V0Q29uZmlnT3B0aW9uKSkKKworY2xhc3MgU2VsZWN0aW9uUGFyYW1ldGVyIChSZXBvcnRlclBhcmFtZXRlcik6CisgIGRlZiBfX2luaXRfXyhzZWxmLCBuLCB2YWx1ZXMpOgorICAgIFJlcG9ydGVyUGFyYW1ldGVyLl9faW5pdF9fKHNlbGYsbikKKyAgICBzZWxmLnZhbHVlcyA9IHZhbHVlcworICAgIAorICBkZWYgZ2V0SFRNTChzZWxmLHIsYnVndHlwZSxnZXRDb25maWdPcHRpb24pOgorICAgIGRlZmF1bHQgPSBzZWxmLmdldFZhbHVlKHIsYnVndHlwZSxnZXRDb25maWdPcHRpb24pCisgICAgcmV0dXJuICIiIlwKKzx0cj4KKzx0ZCBjbGFzcz0iZm9ybV9jbGFiZWwiPiVzOjwvdGQ+PHRkIGNsYXNzPSJmb3JtX3ZhbHVlIj48c2VsZWN0IG5hbWU9IiVzXyVzIj4KKyVzCis8L3NlbGVjdD48L3RkPiIiIiUoc2VsZi5nZXROYW1lKCksci5nZXROYW1lKCksc2VsZi5nZXROYW1lKCksJ1xuJy5qb2luKFsiIiJcCis8b3B0aW9uIHZhbHVlPSIlcyIlcz4lczwvb3B0aW9uPiIiIiUob1swXSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBvWzBdID09IGRlZmF1bHQgYW5kICcgc2VsZWN0ZWQ9InNlbGVjdGVkIicgb3IgJycsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgb1sxXSkgZm9yIG8gaW4gc2VsZi52YWx1ZXNdKSkKKworIz09PS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLT09PSMKKyMgUmVwb3J0ZXJzCisjPT09LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tPT09IworCitjbGFzcyBFbWFpbFJlcG9ydGVyOgorICAgIGRlZiBnZXROYW1lKHNlbGYpOgorICAgICAgICByZXR1cm4gJ0VtYWlsJworCisgICAgZGVmIGdldFBhcmFtZXRlcnMoc2VsZik6CisgICAgICAgIHJldHVybiBtYXAobGFtYmRhIHg6VGV4dFBhcmFtZXRlcih4KSxbJ1RvJywgJ0Zyb20nLCAnU01UUCBTZXJ2ZXInLCAnU01UUCBQb3J0J10pCisKKyAgICAjIExpZnRlZCBmcm9tIHB5dGhvbiBlbWFpbCBtb2R1bGUgZXhhbXBsZXMuCisgICAgZGVmIGF0dGFjaEZpbGUoc2VsZiwgb3V0ZXIsIHBhdGgpOgorICAgICAgICAjIEd1ZXNzIHRoZSBjb250ZW50IHR5cGUgYmFzZWQgb24gdGhlIGZpbGUncyBleHRlbnNpb24uICBFbmNvZGluZworICAgICAgICAjIHdpbGwgYmUgaWdub3JlZCwgYWx0aG91Z2ggd2Ugc2hvdWxkIGNoZWNrIGZvciBzaW1wbGUgdGhpbmdzIGxpa2UKKyAgICAgICAgIyBnemlwJ2Qgb3IgY29tcHJlc3NlZCBmaWxlcy4KKyAgICAgICAgY3R5cGUsIGVuY29kaW5nID0gbWltZXR5cGVzLmd1ZXNzX3R5cGUocGF0aCkKKyAgICAgICAgaWYgY3R5cGUgaXMgTm9uZSBvciBlbmNvZGluZyBpcyBub3QgTm9uZToKKyAgICAgICAgICAgICMgTm8gZ3Vlc3MgY291bGQgYmUgbWFkZSwgb3IgdGhlIGZpbGUgaXMgZW5jb2RlZCAoY29tcHJlc3NlZCksIHNvCisgICAgICAgICAgICAjIHVzZSBhIGdlbmVyaWMgYmFnLW9mLWJpdHMgdHlwZS4KKyAgICAgICAgICAgIGN0eXBlID0gJ2FwcGxpY2F0aW9uL29jdGV0LXN0cmVhbScKKyAgICAgICAgbWFpbnR5cGUsIHN1YnR5cGUgPSBjdHlwZS5zcGxpdCgnLycsIDEpCisgICAgICAgIGlmIG1haW50eXBlID09ICd0ZXh0JzoKKyAgICAgICAgICAgIGZwID0gb3BlbihwYXRoKQorICAgICAgICAgICAgIyBOb3RlOiB3ZSBzaG91bGQgaGFuZGxlIGNhbGN1bGF0aW5nIHRoZSBjaGFyc2V0CisgICAgICAgICAgICBtc2cgPSBNSU1FVGV4dChmcC5yZWFkKCksIF9zdWJ0eXBlPXN1YnR5cGUpCisgICAgICAgICAgICBmcC5jbG9zZSgpCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICBmcCA9IG9wZW4ocGF0aCwgJ3JiJykKKyAgICAgICAgICAgIG1zZyA9IE1JTUVCYXNlKG1haW50eXBlLCBzdWJ0eXBlKQorICAgICAgICAgICAgbXNnLnNldF9wYXlsb2FkKGZwLnJlYWQoKSkKKyAgICAgICAgICAgIGZwLmNsb3NlKCkKKyAgICAgICAgICAgICMgRW5jb2RlIHRoZSBwYXlsb2FkIHVzaW5nIEJhc2U2NAorICAgICAgICAgICAgZW5jb2RlcnMuZW5jb2RlX2Jhc2U2NChtc2cpCisgICAgICAgICMgU2V0IHRoZSBmaWxlbmFtZSBwYXJhbWV0ZXIKKyAgICAgICAgbXNnLmFkZF9oZWFkZXIoJ0NvbnRlbnQtRGlzcG9zaXRpb24nLCAnYXR0YWNobWVudCcsIGZpbGVuYW1lPW9zLnBhdGguYmFzZW5hbWUocGF0aCkpCisgICAgICAgIG91dGVyLmF0dGFjaChtc2cpCisKKyAgICBkZWYgZmlsZVJlcG9ydChzZWxmLCByZXBvcnQsIHBhcmFtZXRlcnMpOgorICAgICAgICBtYWluTXNnID0gIiIiXAorQlVHIFJFUE9SVAorLS0tCitUaXRsZTogJXMKK0Rlc2NyaXB0aW9uOiAlcworIiIiJShyZXBvcnQudGl0bGUsIHJlcG9ydC5kZXNjcmlwdGlvbikKKworICAgICAgICBpZiBub3QgcGFyYW1ldGVycy5nZXQoJ1RvJyk6CisgICAgICAgICAgICByYWlzZSBSZXBvcnRGYWlsdXJlKCdObyAiVG8iIGFkZHJlc3Mgc3BlY2lmaWVkLicpCisgICAgICAgIGlmIG5vdCBwYXJhbWV0ZXJzLmdldCgnRnJvbScpOgorICAgICAgICAgICAgcmFpc2UgUmVwb3J0RmFpbHVyZSgnTm8gIkZyb20iIGFkZHJlc3Mgc3BlY2lmaWVkLicpCisKKyAgICAgICAgbXNnID0gTUlNRU11bHRpcGFydCgpCisgICAgICAgIG1zZ1snU3ViamVjdCddID0gJ0JVRyBSRVBPUlQ6ICVzJyUocmVwb3J0LnRpdGxlKQorICAgICAgICAjIEZJWE1FOiBHZXQgY29uZmlnIHBhcmFtZXRlcnMKKyAgICAgICAgbXNnWydUbyddID0gcGFyYW1ldGVycy5nZXQoJ1RvJykKKyAgICAgICAgbXNnWydGcm9tJ10gPSBwYXJhbWV0ZXJzLmdldCgnRnJvbScpCisgICAgICAgIG1zZy5wcmVhbWJsZSA9IG1haW5Nc2cKKworICAgICAgICBtc2cuYXR0YWNoKE1JTUVUZXh0KG1haW5Nc2csIF9zdWJ0eXBlPSd0ZXh0L3BsYWluJykpCisgICAgICAgIGZvciBmaWxlIGluIHJlcG9ydC5maWxlczoKKyAgICAgICAgICAgIHNlbGYuYXR0YWNoRmlsZShtc2csIGZpbGUpCisKKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgcyA9IHNtdHBsaWIuU01UUChob3N0PXBhcmFtZXRlcnMuZ2V0KCdTTVRQIFNlcnZlcicpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwb3J0PXBhcmFtZXRlcnMuZ2V0KCdTTVRQIFBvcnQnKSkKKyAgICAgICAgICAgIHMuc2VuZG1haWwobXNnWydGcm9tJ10sIG1zZ1snVG8nXSwgbXNnLmFzX3N0cmluZygpKQorICAgICAgICAgICAgcy5jbG9zZSgpCisgICAgICAgIGV4Y2VwdDoKKyAgICAgICAgICAgIHJhaXNlIFJlcG9ydEZhaWx1cmUoJ1VuYWJsZSB0byBzZW5kIG1lc3NhZ2UgdmlhIFNNVFAuJykKKworICAgICAgICByZXR1cm4gIk1lc3NhZ2Ugc2VudCEiCisKK2NsYXNzIEJ1Z3ppbGxhUmVwb3J0ZXI6CisgICAgZGVmIGdldE5hbWUoc2VsZik6CisgICAgICAgIHJldHVybiAnQnVnemlsbGEnCisgICAgCisgICAgZGVmIGdldFBhcmFtZXRlcnMoc2VsZik6CisgICAgICAgIHJldHVybiBtYXAobGFtYmRhIHg6VGV4dFBhcmFtZXRlcih4KSxbJ1VSTCcsJ1Byb2R1Y3QnXSkKKworICAgIGRlZiBmaWxlUmVwb3J0KHNlbGYsIHJlcG9ydCwgcGFyYW1ldGVycyk6CisgICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJyb3IKKyAKKworY2xhc3MgUmFkYXJDbGFzc2lmaWNhdGlvblBhcmFtZXRlcihTZWxlY3Rpb25QYXJhbWV0ZXIpOgorICBkZWYgX19pbml0X18oc2VsZik6CisgICAgU2VsZWN0aW9uUGFyYW1ldGVyLl9faW5pdF9fKHNlbGYsIkNsYXNzaWZpY2F0aW9uIiwKKyAgICAgICAgICAgIFtbJzEnLCAnU2VjdXJpdHknXSwgWycyJywgJ0NyYXNoL0hhbmcvRGF0YSBMb3NzJ10sCisgICAgICAgICAgICAgWyczJywgJ1BlcmZvcm1hbmNlJ10sIFsnNCcsICdVSS9Vc2FiaWxpdHknXSwgCisgICAgICAgICAgICAgWyc2JywgJ1NlcmlvdXMgQnVnJ10sIFsnNycsICdPdGhlciddXSkKKworICBkZWYgc2F2ZUNvbmZpZ1ZhbHVlKHNlbGYpOgorICAgIHJldHVybiBGYWxzZQorICAgIAorICBkZWYgZ2V0VmFsdWUoc2VsZixyLGJ1Z3R5cGUsZ2V0Q29uZmlnT3B0aW9uKToKKyAgICBpZiBidWd0eXBlLmZpbmQoImxlYWsiKSAhPSAtMToKKyAgICAgIHJldHVybiAnMycKKyAgICBlbGlmIGJ1Z3R5cGUuZmluZCgiZGVyZWZlcmVuY2UiKSAhPSAtMToKKyAgICAgIHJldHVybiAnMicKKyAgICBlbGlmIGJ1Z3R5cGUuZmluZCgibWlzc2luZyBpdmFyIHJlbGVhc2UiKSAhPSAtMToKKyAgICAgIHJldHVybiAnMycKKyAgICBlbHNlOgorICAgICAgcmV0dXJuICc3JworCitjbGFzcyBSYWRhclJlcG9ydGVyOgorICAgIEBzdGF0aWNtZXRob2QKKyAgICBkZWYgaXNBdmFpbGFibGUoKToKKyAgICAgICAgIyBGSVhNRTogRmluZCB0aGlzIC5zY3B0IGJldHRlcgorICAgICAgICBwYXRoID0gb3MucGF0aC5qb2luKG9zLnBhdGguZGlybmFtZShfX2ZpbGVfXyksJ1Jlc291cmNlcy9HZXRSYWRhclZlcnNpb24uc2NwdCcpCisgICAgICAgIHRyeToKKyAgICAgICAgICBwID0gc3VicHJvY2Vzcy5Qb3BlbihbJ29zYXNjcmlwdCcscGF0aF0sIAorICAgICAgICAgIHN0ZG91dD1zdWJwcm9jZXNzLlBJUEUsIHN0ZGVycj1zdWJwcm9jZXNzLlBJUEUpCisgICAgICAgIGV4Y2VwdDoKKyAgICAgICAgICAgIHJldHVybiBGYWxzZQorICAgICAgICBkYXRhLGVyciA9IHAuY29tbXVuaWNhdGUoKQorICAgICAgICByZXMgPSBwLndhaXQoKQorICAgICAgICAjIEZJWE1FOiBDaGVjayB2ZXJzaW9uPyBDaGVjayBmb3Igbm8gZXJyb3JzPworICAgICAgICByZXR1cm4gcmVzID09IDAKKworICAgIGRlZiBnZXROYW1lKHNlbGYpOgorICAgICAgICByZXR1cm4gJ1JhZGFyJworCisgICAgZGVmIGdldFBhcmFtZXRlcnMoc2VsZik6CisgICAgICAgIHJldHVybiBbIFRleHRQYXJhbWV0ZXIoJ0NvbXBvbmVudCcpLCBUZXh0UGFyYW1ldGVyKCdDb21wb25lbnQgVmVyc2lvbicpLAorICAgICAgICAgICAgICAgICBSYWRhckNsYXNzaWZpY2F0aW9uUGFyYW1ldGVyKCkgXQorCisgICAgZGVmIGZpbGVSZXBvcnQoc2VsZiwgcmVwb3J0LCBwYXJhbWV0ZXJzKToKKyAgICAgICAgY29tcG9uZW50ID0gcGFyYW1ldGVycy5nZXQoJ0NvbXBvbmVudCcsICcnKQorICAgICAgICBjb21wb25lbnRWZXJzaW9uID0gcGFyYW1ldGVycy5nZXQoJ0NvbXBvbmVudCBWZXJzaW9uJywgJycpCisgICAgICAgIGNsYXNzaWZpY2F0aW9uID0gcGFyYW1ldGVycy5nZXQoJ0NsYXNzaWZpY2F0aW9uJywgJycpCisgICAgICAgIHBlcnNvbklEID0gIiIKKyAgICAgICAgZGlhZ25vc2lzID0gIiIKKyAgICAgICAgY29uZmlnID0gIiIKKworICAgICAgICBpZiBub3QgY29tcG9uZW50LnN0cmlwKCk6CisgICAgICAgICAgICBjb21wb25lbnQgPSAnQnVncyBmb3VuZCBieSBjbGFuZyBBbmFseXplcicKKyAgICAgICAgaWYgbm90IGNvbXBvbmVudFZlcnNpb24uc3RyaXAoKToKKyAgICAgICAgICAgIGNvbXBvbmVudFZlcnNpb24gPSAnWCcKKworICAgICAgICBzY3JpcHQgPSBvcy5wYXRoLmpvaW4ob3MucGF0aC5kaXJuYW1lKF9fZmlsZV9fKSwnUmVzb3VyY2VzL0ZpbGVSYWRhci5zY3B0JykKKyAgICAgICAgYXJncyA9IFsnb3Nhc2NyaXB0Jywgc2NyaXB0LCBjb21wb25lbnQsIGNvbXBvbmVudFZlcnNpb24sIGNsYXNzaWZpY2F0aW9uLCBwZXJzb25JRCwgcmVwb3J0LnRpdGxlLAorICAgICAgICAgICAgICAgIHJlcG9ydC5kZXNjcmlwdGlvbiwgZGlhZ25vc2lzLCBjb25maWddICsgbWFwKG9zLnBhdGguYWJzcGF0aCwgcmVwb3J0LmZpbGVzKQorIyAgICAgICAgcHJpbnQgPj5zeXMuc3RkZXJyLCBhcmdzCisgICAgICAgIHRyeToKKyAgICAgICAgICBwID0gc3VicHJvY2Vzcy5Qb3BlbihhcmdzLCBzdGRvdXQ9c3VicHJvY2Vzcy5QSVBFLCBzdGRlcnI9c3VicHJvY2Vzcy5QSVBFKQorICAgICAgICBleGNlcHQ6CisgICAgICAgICAgICByYWlzZSBSZXBvcnRGYWlsdXJlKCJVbmFibGUgdG8gZmlsZSByYWRhciAoQXBwbGVTY3JpcHQgZmFpbHVyZSkuIikKKyAgICAgICAgZGF0YSwgZXJyID0gcC5jb21tdW5pY2F0ZSgpCisgICAgICAgIHJlcyA9IHAud2FpdCgpCisKKyAgICAgICAgaWYgcmVzOgorICAgICAgICAgICAgcmFpc2UgUmVwb3J0RmFpbHVyZSgiVW5hYmxlIHRvIGZpbGUgcmFkYXIgKEFwcGxlU2NyaXB0IGZhaWx1cmUpLiIpCisKKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgdmFsdWVzID0gZXZhbChkYXRhKQorICAgICAgICBleGNlcHQ6CisgICAgICAgICAgICByYWlzZSBSZXBvcnRGYWlsdXJlKCJVbmFibGUgdG8gcHJvY2VzcyByYWRhciByZXN1bHRzLiIpCisKKyAgICAgICAgIyBXZSBleHBlY3QgKGludDogYnVnSUQsIHN0cjogbWVzc2FnZSkKKyAgICAgICAgaWYgbGVuKHZhbHVlcykgIT0gMiBvciBub3QgaXNpbnN0YW5jZSh2YWx1ZXNbMF0sIGludCk6CisgICAgICAgICAgICByYWlzZSBSZXBvcnRGYWlsdXJlKCJVbmFibGUgdG8gcHJvY2VzcyByYWRhciByZXN1bHRzLiIpCisKKyAgICAgICAgYnVnSUQsbWVzc2FnZSA9IHZhbHVlcworICAgICAgICBidWdJRCA9IGludChidWdJRCkKKyAgICAgICAgCisgICAgICAgIGlmIG5vdCBidWdJRDoKKyAgICAgICAgICAgIHJhaXNlIFJlcG9ydEZhaWx1cmUobWVzc2FnZSkKKyAgICAgICAgCisgICAgICAgIHJldHVybiAiRmlsZWQ6IDxhIGhyZWY9XCJyZGFyOi8vJWQvXCI+JWQ8L2E+IiUoYnVnSUQsYnVnSUQpCisKKyMjIworCitkZWYgZ2V0UmVwb3J0ZXJzKCk6CisgICAgcmVwb3J0ZXJzID0gW10KKyAgICBpZiBSYWRhclJlcG9ydGVyLmlzQXZhaWxhYmxlKCk6CisgICAgICAgIHJlcG9ydGVycy5hcHBlbmQoUmFkYXJSZXBvcnRlcigpKQorICAgIHJlcG9ydGVycy5hcHBlbmQoRW1haWxSZXBvcnRlcigpKQorICAgIHJldHVybiByZXBvcnRlcnMKKwpkaWZmIC0tZ2l0IGEvdG9vbHMvc2Nhbi12aWV3L1Jlc291cmNlcy9GaWxlUmFkYXIuc2NwdCBiL3Rvb2xzL3NjYW4tdmlldy9SZXNvdXJjZXMvRmlsZVJhZGFyLnNjcHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uMWM3NDU1MgotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3NjYW4tdmlldy9SZXNvdXJjZXMvRmlsZVJhZGFyLnNjcHQKQmluYXJ5IGZpbGVzIGRpZmZlcgpkaWZmIC0tZ2l0IGEvdG9vbHMvc2Nhbi12aWV3L1Jlc291cmNlcy9HZXRSYWRhclZlcnNpb24uc2NwdCBiL3Rvb2xzL3NjYW4tdmlldy9SZXNvdXJjZXMvR2V0UmFkYXJWZXJzaW9uLnNjcHQKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZTY5ZGUyOQotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3NjYW4tdmlldy9SZXNvdXJjZXMvR2V0UmFkYXJWZXJzaW9uLnNjcHQKZGlmZiAtLWdpdCBhL3Rvb2xzL3NjYW4tdmlldy9SZXNvdXJjZXMvYnVnY2F0Y2hlci5pY28gYi90b29scy9zY2FuLXZpZXcvUmVzb3VyY2VzL2J1Z2NhdGNoZXIuaWNvCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjIyZDM5YjUKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9zY2FuLXZpZXcvUmVzb3VyY2VzL2J1Z2NhdGNoZXIuaWNvCkJpbmFyeSBmaWxlcyBkaWZmZXIKZGlmZiAtLWdpdCBhL3Rvb2xzL3NjYW4tdmlldy9TY2FuVmlldy5weSBiL3Rvb2xzL3NjYW4tdmlldy9TY2FuVmlldy5weQpuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5lZTA4YmFhCi0tLSAvZGV2L251bGwKKysrIGIvdG9vbHMvc2Nhbi12aWV3L1NjYW5WaWV3LnB5CkBAIC0wLDAgKzEsNzY3IEBACitpbXBvcnQgQmFzZUhUVFBTZXJ2ZXIKK2ltcG9ydCBTaW1wbGVIVFRQU2VydmVyCitpbXBvcnQgb3MKK2ltcG9ydCBzeXMKK2ltcG9ydCB1cmxsaWIsIHVybHBhcnNlCitpbXBvcnQgcG9zaXhwYXRoCitpbXBvcnQgU3RyaW5nSU8KK2ltcG9ydCByZQoraW1wb3J0IHNodXRpbAoraW1wb3J0IHRocmVhZGluZworaW1wb3J0IHRpbWUKK2ltcG9ydCBzb2NrZXQKK2ltcG9ydCBpdGVydG9vbHMKKworaW1wb3J0IFJlcG9ydGVyCitpbXBvcnQgQ29uZmlnUGFyc2VyCisKKyMjIworIyBWYXJpb3VzIHBhdHRlcm5zIG1hdGNoZWQgb3IgcmVwbGFjZWQgYnkgc2VydmVyLgorCitrUmVwb3J0RmlsZVJFID0gcmUuY29tcGlsZSgnKC4qLyk/cmVwb3J0LSguKilcXC5odG1sJykKKwora0J1Z0tleVZhbHVlUkUgPSByZS5jb21waWxlKCc8IS0tIEJVRyhbXiBdKikgKC4qKSAtLT4nKQorCisjICA8IS0tIFJFUE9SVFBST0JMRU0gZmlsZT0iY3Jhc2hlcy9jbGFuZ19jcmFzaF9uZFNHRjkubWkiIHN0ZGVycj0iY3Jhc2hlcy9jbGFuZ19jcmFzaF9uZFNHRjkubWkuc3RkZXJyLnR4dCIgaW5mbz0iY3Jhc2hlcy9jbGFuZ19jcmFzaF9uZFNHRjkubWkuaW5mbyIgLS0+CisKK2tSZXBvcnRDcmFzaEVudHJ5UkUgPSByZS5jb21waWxlKCc8IS0tIFJFUE9SVFBST0JMRU0gKC4qPyktLT4nKQora1JlcG9ydENyYXNoRW50cnlLZXlWYWx1ZVJFID0gcmUuY29tcGlsZSgnID8oW149XSspPSIoLio/KSInKQorCitrUmVwb3J0UmVwbGFjZW1lbnRzID0gW10KKworIyBBZGQgY3VzdG9tIGphdmFzY3JpcHQuCitrUmVwb3J0UmVwbGFjZW1lbnRzLmFwcGVuZCgocmUuY29tcGlsZSgnPCEtLSBTVU1NQVJZRU5ESEVBRCAtLT4nKSwgIiIiXAorPHNjcmlwdCBsYW5ndWFnZT0iamF2YXNjcmlwdCIgdHlwZT0idGV4dC9qYXZhc2NyaXB0Ij4KK2Z1bmN0aW9uIGxvYWQodXJsKSB7CisgIGlmICh3aW5kb3cuWE1MSHR0cFJlcXVlc3QpIHsKKyAgICByZXEgPSBuZXcgWE1MSHR0cFJlcXVlc3QoKTsKKyAgfSBlbHNlIGlmICh3aW5kb3cuQWN0aXZlWE9iamVjdCkgeworICAgIHJlcSA9IG5ldyBBY3RpdmVYT2JqZWN0KCJNaWNyb3NvZnQuWE1MSFRUUCIpOworICB9CisgIGlmIChyZXEgIT0gdW5kZWZpbmVkKSB7CisgICAgcmVxLm9wZW4oIkdFVCIsIHVybCwgdHJ1ZSk7CisgICAgcmVxLnNlbmQoIiIpOworICB9Cit9Cis8L3NjcmlwdD4iIiIpKQorCisjIEluc2VydCBhZGRpdGlvbmFsIGNvbHVtbnMuCitrUmVwb3J0UmVwbGFjZW1lbnRzLmFwcGVuZCgocmUuY29tcGlsZSgnPCEtLSBSRVBPUlRCVUdDT0wgLS0+JyksIAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICc8dGQ+PC90ZD48dGQ+PC90ZD4nKSkKKworIyBJbnNlcnQgcmVwb3J0IGJ1ZyBhbmQgb3BlbiBmaWxlIGxpbmtzLgora1JlcG9ydFJlcGxhY2VtZW50cy5hcHBlbmQoKHJlLmNvbXBpbGUoJzwhLS0gUkVQT1JUQlVHIGlkPSJyZXBvcnQtKC4qKVxcLmh0bWwiIC0tPicpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICgnPHRkIGNsYXNzPSJCdXR0b24iPjxhIGhyZWY9InJlcG9ydC9cXDEiPlJlcG9ydCBCdWc8L2E+PC90ZD4nICsgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICc8dGQgY2xhc3M9IkJ1dHRvbiI+PGEgaHJlZj0iamF2YXNjcmlwdDpsb2FkKFwnb3Blbi9cXDFcJykiPk9wZW4gRmlsZTwvYT48L3RkPicpKSkKKwora1JlcG9ydFJlcGxhY2VtZW50cy5hcHBlbmQoKHJlLmNvbXBpbGUoJzwhLS0gUkVQT1JUSEVBREVSIC0tPicpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgJzxoMz48YSBocmVmPSIvIj5TdW1tYXJ5PC9hPiA+IFJlcG9ydCAlKHJlcG9ydClzPC9oMz4nKSkKKwora1JlcG9ydFJlcGxhY2VtZW50cy5hcHBlbmQoKHJlLmNvbXBpbGUoJzwhLS0gUkVQT1JUU1VNTUFSWUVYVFJBIC0tPicpLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICc8dGQgY2xhc3M9IkJ1dHRvbiI+PGEgaHJlZj0icmVwb3J0LyUocmVwb3J0KXMiPlJlcG9ydCBCdWc8L2E+PC90ZD4nKSkKKworIyBJbnNlcnQgcmVwb3J0IGNyYXNoZXMgbGluay4KKworIyBEaXNhYmxlZCBmb3IgdGhlIHRpbWUgYmVpbmcgdW50aWwgd2UgZGVjaWRlIGV4YWN0bHkgd2hlbiB0aGlzIHNob3VsZAorIyBiZSBlbmFibGVkLiBBbHNvIHRoZSByYWRhciByZXBvcnRlciBuZWVkcyB0byBiZSBmaXhlZCB0byByZXBvcnQKKyMgbXVsdGlwbGUgZmlsZXMuCisKKyNrUmVwb3J0UmVwbGFjZW1lbnRzLmFwcGVuZCgocmUuY29tcGlsZSgnPCEtLSBSRVBPUlRDUkFTSEVTIC0tPicpLAorIyAgICAgICAgICAgICAgICAgICAgICAgICAgICAnPGJyPlRoZXNlIGZpbGVzIHdpbGwgYXV0b21hdGljYWxseSBiZSBhdHRhY2hlZCB0byAnICsKKyMgICAgICAgICAgICAgICAgICAgICAgICAgICAgJ3JlcG9ydHMgZmlsZWQgaGVyZTogPGEgaHJlZj0icmVwb3J0X2NyYXNoZXMiPlJlcG9ydCBDcmFzaGVzPC9hPi4nKSkKKworIyMjCisjIE90aGVyIHNpbXBsZSBwYXJhbWV0ZXJzCisKK2tSZXNvdXJjZXMgPSBwb3NpeHBhdGguam9pbihwb3NpeHBhdGguZGlybmFtZShfX2ZpbGVfXyksICdSZXNvdXJjZXMnKQora0NvbmZpZ1BhdGggPSBvcy5wYXRoLmV4cGFuZHVzZXIoJ34vLnNjYW52aWV3LmNmZycpCisKKyMjIworCitfX3ZlcnNpb25fXyA9ICIwLjEiCisKK19fYWxsX18gPSBbImNyZWF0ZV9zZXJ2ZXIiXQorCitjbGFzcyBSZXBvcnRlclRocmVhZCh0aHJlYWRpbmcuVGhyZWFkKToKKyAgICBkZWYgX19pbml0X18oc2VsZiwgcmVwb3J0LCByZXBvcnRlciwgcGFyYW1ldGVycywgc2VydmVyKToKKyAgICAgICAgdGhyZWFkaW5nLlRocmVhZC5fX2luaXRfXyhzZWxmKQorICAgICAgICBzZWxmLnJlcG9ydCA9IHJlcG9ydAorICAgICAgICBzZWxmLnNlcnZlciA9IHNlcnZlcgorICAgICAgICBzZWxmLnJlcG9ydGVyID0gcmVwb3J0ZXIKKyAgICAgICAgc2VsZi5wYXJhbWV0ZXJzID0gcGFyYW1ldGVycworICAgICAgICBzZWxmLnN1Y2Nlc3MgPSBGYWxzZQorICAgICAgICBzZWxmLnN0YXR1cyA9IE5vbmUKKworICAgIGRlZiBydW4oc2VsZik6CisgICAgICAgIHJlc3VsdCA9IE5vbmUKKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgaWYgc2VsZi5zZXJ2ZXIub3B0aW9ucy5kZWJ1ZzoKKyAgICAgICAgICAgICAgICBwcmludCA+PnN5cy5zdGRlcnIsICIlczogU0VSVkVSOiBzdWJtaXR0aW5nIGJ1Zy4iJShzeXMuYXJndlswXSwpCisgICAgICAgICAgICBzZWxmLnN0YXR1cyA9IHNlbGYucmVwb3J0ZXIuZmlsZVJlcG9ydChzZWxmLnJlcG9ydCwgc2VsZi5wYXJhbWV0ZXJzKQorICAgICAgICAgICAgc2VsZi5zdWNjZXNzID0gVHJ1ZQorICAgICAgICAgICAgdGltZS5zbGVlcCgzKQorICAgICAgICAgICAgaWYgc2VsZi5zZXJ2ZXIub3B0aW9ucy5kZWJ1ZzoKKyAgICAgICAgICAgICAgICBwcmludCA+PnN5cy5zdGRlcnIsICIlczogU0VSVkVSOiBzdWJtaXNzaW9uIGNvbXBsZXRlLiIlKHN5cy5hcmd2WzBdLCkKKyAgICAgICAgZXhjZXB0IFJlcG9ydGVyLlJlcG9ydEZhaWx1cmUsZToKKyAgICAgICAgICAgIHNlbGYuc3RhdHVzID0gZS52YWx1ZQorICAgICAgICBleGNlcHQgRXhjZXB0aW9uLGU6CisgICAgICAgICAgICBzID0gU3RyaW5nSU8uU3RyaW5nSU8oKQorICAgICAgICAgICAgaW1wb3J0IHRyYWNlYmFjaworICAgICAgICAgICAgcHJpbnQgPj5zLCc8Yj5VbmhhbmRsZWQgRXhjZXB0aW9uPC9iPjxicj48cHJlPicKKyAgICAgICAgICAgIHRyYWNlYmFjay5wcmludF9leGMoZSxmaWxlPXMpCisgICAgICAgICAgICBwcmludCA+PnMsJzwvcHJlPicKKyAgICAgICAgICAgIHNlbGYuc3RhdHVzID0gcy5nZXR2YWx1ZSgpCisKK2NsYXNzIFNjYW5WaWV3U2VydmVyKEJhc2VIVFRQU2VydmVyLkhUVFBTZXJ2ZXIpOgorICAgIGRlZiBfX2luaXRfXyhzZWxmLCBhZGRyZXNzLCBoYW5kbGVyLCByb290LCByZXBvcnRlcnMsIG9wdGlvbnMpOgorICAgICAgICBCYXNlSFRUUFNlcnZlci5IVFRQU2VydmVyLl9faW5pdF9fKHNlbGYsIGFkZHJlc3MsIGhhbmRsZXIpCisgICAgICAgIHNlbGYucm9vdCA9IHJvb3QKKyAgICAgICAgc2VsZi5yZXBvcnRlcnMgPSByZXBvcnRlcnMKKyAgICAgICAgc2VsZi5vcHRpb25zID0gb3B0aW9ucyAgICAgICAgCisgICAgICAgIHNlbGYuaGFsdGVkID0gRmFsc2UKKyAgICAgICAgc2VsZi5jb25maWcgPSBOb25lCisgICAgICAgIHNlbGYubG9hZF9jb25maWcoKQorCisgICAgZGVmIGxvYWRfY29uZmlnKHNlbGYpOgorICAgICAgICBzZWxmLmNvbmZpZyA9IENvbmZpZ1BhcnNlci5SYXdDb25maWdQYXJzZXIoKQorCisgICAgICAgICMgQWRkIGRlZmF1bHRzCisgICAgICAgIHNlbGYuY29uZmlnLmFkZF9zZWN0aW9uKCdTY2FuVmlldycpCisgICAgICAgIGZvciByIGluIHNlbGYucmVwb3J0ZXJzOgorICAgICAgICAgICAgc2VsZi5jb25maWcuYWRkX3NlY3Rpb24oci5nZXROYW1lKCkpCisgICAgICAgICAgICBmb3IgcCBpbiByLmdldFBhcmFtZXRlcnMoKToKKyAgICAgICAgICAgICAgaWYgcC5zYXZlQ29uZmlnVmFsdWUoKToKKyAgICAgICAgICAgICAgICBzZWxmLmNvbmZpZy5zZXQoci5nZXROYW1lKCksIHAuZ2V0TmFtZSgpLCAnJykKKworICAgICAgICAjIElnbm9yZSBwYXJzZSBlcnJvcnMKKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgc2VsZi5jb25maWcucmVhZChba0NvbmZpZ1BhdGhdKQorICAgICAgICBleGNlcHQ6CisgICAgICAgICAgICBwYXNzCisKKyAgICAgICAgIyBTYXZlIG9uIGV4aXQKKyAgICAgICAgaW1wb3J0IGF0ZXhpdAorICAgICAgICBhdGV4aXQucmVnaXN0ZXIobGFtYmRhOiBzZWxmLnNhdmVfY29uZmlnKCkpCisgICAgICAgIAorICAgIGRlZiBzYXZlX2NvbmZpZyhzZWxmKToKKyAgICAgICAgIyBJZ25vcmUgZXJyb3JzIChvbmx5IGNhbGxlZCBvbiBleGl0KS4KKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgZiA9IG9wZW4oa0NvbmZpZ1BhdGgsJ3cnKQorICAgICAgICAgICAgc2VsZi5jb25maWcud3JpdGUoZikKKyAgICAgICAgICAgIGYuY2xvc2UoKQorICAgICAgICBleGNlcHQ6CisgICAgICAgICAgICBwYXNzCisgICAgICAgIAorICAgIGRlZiBoYWx0KHNlbGYpOgorICAgICAgICBzZWxmLmhhbHRlZCA9IFRydWUKKyAgICAgICAgaWYgc2VsZi5vcHRpb25zLmRlYnVnOgorICAgICAgICAgICAgcHJpbnQgPj5zeXMuc3RkZXJyLCAiJXM6IFNFUlZFUjogaGFsdGluZy4iICUgKHN5cy5hcmd2WzBdLCkKKworICAgIGRlZiBzZXJ2ZV9mb3JldmVyKHNlbGYpOgorICAgICAgICB3aGlsZSBub3Qgc2VsZi5oYWx0ZWQ6CisgICAgICAgICAgICBpZiBzZWxmLm9wdGlvbnMuZGVidWcgPiAxOgorICAgICAgICAgICAgICAgIHByaW50ID4+c3lzLnN0ZGVyciwgIiVzOiBTRVJWRVI6IHdhaXRpbmcuLi4iICUgKHN5cy5hcmd2WzBdLCkKKyAgICAgICAgICAgIHRyeToKKyAgICAgICAgICAgICAgICBzZWxmLmhhbmRsZV9yZXF1ZXN0KCkKKyAgICAgICAgICAgIGV4Y2VwdCBPU0Vycm9yLGU6CisgICAgICAgICAgICAgICAgcHJpbnQgJ09TRXJyb3InLGUuZXJybm8KKworICAgIGRlZiBmaW5pc2hfcmVxdWVzdChzZWxmLCByZXF1ZXN0LCBjbGllbnRfYWRkcmVzcyk6CisgICAgICAgIGlmIHNlbGYub3B0aW9ucy5hdXRvUmVsb2FkOgorICAgICAgICAgICAgaW1wb3J0IFNjYW5WaWV3CisgICAgICAgICAgICBzZWxmLlJlcXVlc3RIYW5kbGVyQ2xhc3MgPSByZWxvYWQoU2NhblZpZXcpLlNjYW5WaWV3UmVxdWVzdEhhbmRsZXIKKyAgICAgICAgQmFzZUhUVFBTZXJ2ZXIuSFRUUFNlcnZlci5maW5pc2hfcmVxdWVzdChzZWxmLCByZXF1ZXN0LCBjbGllbnRfYWRkcmVzcykKKworICAgIGRlZiBoYW5kbGVfZXJyb3Ioc2VsZiwgcmVxdWVzdCwgY2xpZW50X2FkZHJlc3MpOgorICAgICAgICAjIElnbm9yZSBzb2NrZXQgZXJyb3JzCisgICAgICAgIGluZm8gPSBzeXMuZXhjX2luZm8oKQorICAgICAgICBpZiBpbmZvIGFuZCBpc2luc3RhbmNlKGluZm9bMV0sIHNvY2tldC5lcnJvcik6CisgICAgICAgICAgICBpZiBzZWxmLm9wdGlvbnMuZGVidWcgPiAxOgorICAgICAgICAgICAgICAgIHByaW50ID4+c3lzLnN0ZGVyciwgIiVzOiBTRVJWRVI6IGlnbm9yZWQgc29ja2V0IGVycm9yLiIgJSAoc3lzLmFyZ3ZbMF0sKQorICAgICAgICAgICAgcmV0dXJuCisgICAgICAgIEJhc2VIVFRQU2VydmVyLkhUVFBTZXJ2ZXIuaGFuZGxlX2Vycm9yKHNlbGYsIHJlcXVlc3QsIGNsaWVudF9hZGRyZXNzKQorCisjIEJvcnJvd2VkIGZyb20gUXVpeG90ZSwgd2l0aCBzaW1wbGlmaWNhdGlvbnMuCitkZWYgcGFyc2VfcXVlcnkocXMsIGZpZWxkcz1Ob25lKToKKyAgICBpZiBmaWVsZHMgaXMgTm9uZToKKyAgICAgICAgZmllbGRzID0ge30KKyAgICBmb3IgY2h1bmsgaW4gZmlsdGVyKE5vbmUsIHFzLnNwbGl0KCcmJykpOgorICAgICAgICBpZiAnPScgbm90IGluIGNodW5rOgorICAgICAgICAgICAgbmFtZSA9IGNodW5rCisgICAgICAgICAgICB2YWx1ZSA9ICcnCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICBuYW1lLCB2YWx1ZSA9IGNodW5rLnNwbGl0KCc9JywgMSkKKyAgICAgICAgbmFtZSA9IHVybGxpYi51bnF1b3RlKG5hbWUucmVwbGFjZSgnKycsICcgJykpCisgICAgICAgIHZhbHVlID0gdXJsbGliLnVucXVvdGUodmFsdWUucmVwbGFjZSgnKycsICcgJykpCisgICAgICAgIGl0ZW0gPSBmaWVsZHMuZ2V0KG5hbWUpCisgICAgICAgIGlmIGl0ZW0gaXMgTm9uZToKKyAgICAgICAgICAgIGZpZWxkc1tuYW1lXSA9IFt2YWx1ZV0KKyAgICAgICAgZWxzZToKKyAgICAgICAgICAgIGl0ZW0uYXBwZW5kKHZhbHVlKQorICAgIHJldHVybiBmaWVsZHMKKworY2xhc3MgU2NhblZpZXdSZXF1ZXN0SGFuZGxlcihTaW1wbGVIVFRQU2VydmVyLlNpbXBsZUhUVFBSZXF1ZXN0SGFuZGxlcik6CisgICAgc2VydmVyX3ZlcnNpb24gPSAiU2NhblZpZXdTZXJ2ZXIvIiArIF9fdmVyc2lvbl9fCisgICAgZHluYW1pY19tdGltZSA9IHRpbWUudGltZSgpCisKKyAgICBkZWYgZG9fSEVBRChzZWxmKToKKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgU2ltcGxlSFRUUFNlcnZlci5TaW1wbGVIVFRQUmVxdWVzdEhhbmRsZXIuZG9fSEVBRChzZWxmKQorICAgICAgICBleGNlcHQgRXhjZXB0aW9uLGU6CisgICAgICAgICAgICBzZWxmLmhhbmRsZV9leGNlcHRpb24oZSkKKyAgICAgICAgICAgIAorICAgIGRlZiBkb19HRVQoc2VsZik6CisgICAgICAgIHRyeToKKyAgICAgICAgICAgIFNpbXBsZUhUVFBTZXJ2ZXIuU2ltcGxlSFRUUFJlcXVlc3RIYW5kbGVyLmRvX0dFVChzZWxmKQorICAgICAgICBleGNlcHQgRXhjZXB0aW9uLGU6CisgICAgICAgICAgICBzZWxmLmhhbmRsZV9leGNlcHRpb24oZSkKKyAgICAgICAgICAgIAorICAgIGRlZiBkb19QT1NUKHNlbGYpOgorICAgICAgICAiIiJTZXJ2ZSBhIFBPU1QgcmVxdWVzdC4iIiIKKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgbGVuZ3RoID0gc2VsZi5oZWFkZXJzLmdldGhlYWRlcignY29udGVudC1sZW5ndGgnKSBvciAiMCIKKyAgICAgICAgICAgIHRyeToKKyAgICAgICAgICAgICAgICBsZW5ndGggPSBpbnQobGVuZ3RoKQorICAgICAgICAgICAgZXhjZXB0OgorICAgICAgICAgICAgICAgIGxlbmd0aCA9IDAKKyAgICAgICAgICAgIGNvbnRlbnQgPSBzZWxmLnJmaWxlLnJlYWQobGVuZ3RoKQorICAgICAgICAgICAgZmllbGRzID0gcGFyc2VfcXVlcnkoY29udGVudCkKKyAgICAgICAgICAgIGYgPSBzZWxmLnNlbmRfaGVhZChmaWVsZHMpCisgICAgICAgICAgICBpZiBmOgorICAgICAgICAgICAgICAgIHNlbGYuY29weWZpbGUoZiwgc2VsZi53ZmlsZSkKKyAgICAgICAgICAgICAgICBmLmNsb3NlKCkKKyAgICAgICAgZXhjZXB0IEV4Y2VwdGlvbixlOgorICAgICAgICAgICAgc2VsZi5oYW5kbGVfZXhjZXB0aW9uKGUpICAgICAgICAgICAgCisKKyAgICBkZWYgbG9nX21lc3NhZ2Uoc2VsZiwgZm9ybWF0LCAqYXJncyk6CisgICAgICAgIGlmIHNlbGYuc2VydmVyLm9wdGlvbnMuZGVidWc6CisgICAgICAgICAgICBzeXMuc3RkZXJyLndyaXRlKCIlczogU0VSVkVSOiAlcyAtIC0gWyVzXSAlc1xuIiAlCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgIChzeXMuYXJndlswXSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlbGYuYWRkcmVzc19zdHJpbmcoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHNlbGYubG9nX2RhdGVfdGltZV9zdHJpbmcoKSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZvcm1hdCVhcmdzKSkKKworICAgIGRlZiBsb2FkX3JlcG9ydChzZWxmLCByZXBvcnQpOgorICAgICAgICBwYXRoID0gb3MucGF0aC5qb2luKHNlbGYuc2VydmVyLnJvb3QsICdyZXBvcnQtJXMuaHRtbCclcmVwb3J0KQorICAgICAgICBkYXRhID0gb3BlbihwYXRoKS5yZWFkKCkKKyAgICAgICAga2V5cyA9IHt9CisgICAgICAgIGZvciBpdGVtIGluIGtCdWdLZXlWYWx1ZVJFLmZpbmRpdGVyKGRhdGEpOgorICAgICAgICAgICAgayx2ID0gaXRlbS5ncm91cHMoKQorICAgICAgICAgICAga2V5c1trXSA9IHYKKyAgICAgICAgcmV0dXJuIGtleXMKKworICAgIGRlZiBsb2FkX2NyYXNoZXMoc2VsZik6CisgICAgICAgIHBhdGggPSBwb3NpeHBhdGguam9pbihzZWxmLnNlcnZlci5yb290LCAnaW5kZXguaHRtbCcpCisgICAgICAgIGRhdGEgPSBvcGVuKHBhdGgpLnJlYWQoKQorICAgICAgICBwcm9ibGVtcyA9IFtdCisgICAgICAgIGZvciBpdGVtIGluIGtSZXBvcnRDcmFzaEVudHJ5UkUuZmluZGl0ZXIoZGF0YSk6CisgICAgICAgICAgICBmaWVsZERhdGEgPSBpdGVtLmdyb3VwKDEpCisgICAgICAgICAgICBmaWVsZHMgPSBkaWN0KFtpLmdyb3VwcygpIGZvciBpIGluIAorICAgICAgICAgICAgICAgICAgICAgICAgICAga1JlcG9ydENyYXNoRW50cnlLZXlWYWx1ZVJFLmZpbmRpdGVyKGZpZWxkRGF0YSldKQorICAgICAgICAgICAgcHJvYmxlbXMuYXBwZW5kKGZpZWxkcykKKyAgICAgICAgcmV0dXJuIHByb2JsZW1zCisKKyAgICBkZWYgaGFuZGxlX2V4Y2VwdGlvbihzZWxmLCBleGMpOgorICAgICAgICBpbXBvcnQgdHJhY2ViYWNrCisgICAgICAgIHMgPSBTdHJpbmdJTy5TdHJpbmdJTygpCisgICAgICAgIHByaW50ID4+cywgIklOVEVSTkFMIEVSUk9SXG4iCisgICAgICAgIHRyYWNlYmFjay5wcmludF9leGMoZXhjLCBzKQorICAgICAgICBmID0gc2VsZi5zZW5kX3N0cmluZyhzLmdldHZhbHVlKCksICd0ZXh0L3BsYWluJykKKyAgICAgICAgaWYgZjoKKyAgICAgICAgICAgIHNlbGYuY29weWZpbGUoZiwgc2VsZi53ZmlsZSkKKyAgICAgICAgICAgIGYuY2xvc2UoKSAgICAgICAgCisgICAgICAgICAgICAKKyAgICBkZWYgZ2V0X3NjYWxhcl9maWVsZChzZWxmLCBuYW1lKToKKyAgICAgICAgaWYgbmFtZSBpbiBzZWxmLmZpZWxkczoKKyAgICAgICAgICAgIHJldHVybiBzZWxmLmZpZWxkc1tuYW1lXVswXQorICAgICAgICBlbHNlOgorICAgICAgICAgICAgcmV0dXJuIE5vbmUKKworICAgIGRlZiBzdWJtaXRfYnVnKHNlbGYsIGMpOgorICAgICAgICB0aXRsZSA9IHNlbGYuZ2V0X3NjYWxhcl9maWVsZCgndGl0bGUnKQorICAgICAgICBkZXNjcmlwdGlvbiA9IHNlbGYuZ2V0X3NjYWxhcl9maWVsZCgnZGVzY3JpcHRpb24nKQorICAgICAgICByZXBvcnQgPSBzZWxmLmdldF9zY2FsYXJfZmllbGQoJ3JlcG9ydCcpCisgICAgICAgIHJlcG9ydGVySW5kZXggPSBzZWxmLmdldF9zY2FsYXJfZmllbGQoJ3JlcG9ydGVyJykKKyAgICAgICAgZmlsZXMgPSBbXQorICAgICAgICBmb3IgZmlsZUlEIGluIHNlbGYuZmllbGRzLmdldCgnZmlsZXMnLFtdKToKKyAgICAgICAgICAgIHRyeToKKyAgICAgICAgICAgICAgICBpID0gaW50KGZpbGVJRCkKKyAgICAgICAgICAgIGV4Y2VwdDoKKyAgICAgICAgICAgICAgICBpID0gTm9uZQorICAgICAgICAgICAgaWYgaSBpcyBOb25lIG9yIGk8MCBvciBpPj1sZW4oYy5maWxlcyk6CisgICAgICAgICAgICAgICAgcmV0dXJuIChGYWxzZSwgJ0ludmFsaWQgZmlsZSBJRCcpCisgICAgICAgICAgICBmaWxlcy5hcHBlbmQoYy5maWxlc1tpXSkKKyAgICAgICAgCisgICAgICAgIGlmIG5vdCB0aXRsZToKKyAgICAgICAgICAgIHJldHVybiAoRmFsc2UsICJNaXNzaW5nIHRpdGxlLiIpCisgICAgICAgIGlmIG5vdCBkZXNjcmlwdGlvbjoKKyAgICAgICAgICAgIHJldHVybiAoRmFsc2UsICJNaXNzaW5nIGRlc2NyaXB0aW9uLiIpCisgICAgICAgIHRyeToKKyAgICAgICAgICAgIHJlcG9ydGVySW5kZXggPSBpbnQocmVwb3J0ZXJJbmRleCkKKyAgICAgICAgZXhjZXB0OgorICAgICAgICAgICAgcmV0dXJuIChGYWxzZSwgIkludmFsaWQgcmVwb3J0IG1ldGhvZC4iKQorICAgICAgICAKKyAgICAgICAgIyBHZXQgdGhlIHJlcG9ydGVyIGFuZCBwYXJhbWV0ZXJzLgorICAgICAgICByZXBvcnRlciA9IHNlbGYuc2VydmVyLnJlcG9ydGVyc1tyZXBvcnRlckluZGV4XQorICAgICAgICBwYXJhbWV0ZXJzID0ge30KKyAgICAgICAgZm9yIG8gaW4gcmVwb3J0ZXIuZ2V0UGFyYW1ldGVycygpOgorICAgICAgICAgICAgbmFtZSA9ICclc18lcyclKHJlcG9ydGVyLmdldE5hbWUoKSxvLmdldE5hbWUoKSkKKyAgICAgICAgICAgIGlmIG5hbWUgbm90IGluIHNlbGYuZmllbGRzOgorICAgICAgICAgICAgICAgIHJldHVybiAoRmFsc2UsIAorICAgICAgICAgICAgICAgICAgICAgICAgJ01pc3NpbmcgZmllbGQgIiVzIiBmb3IgJXMgcmVwb3J0IG1ldGhvZC4nJShuYW1lLAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICByZXBvcnRlci5nZXROYW1lKCkpKQorICAgICAgICAgICAgcGFyYW1ldGVyc1tvLmdldE5hbWUoKV0gPSBzZWxmLmdldF9zY2FsYXJfZmllbGQobmFtZSkKKworICAgICAgICAjIFVwZGF0ZSBjb25maWcgZGVmYXVsdHMuCisgICAgICAgIGlmIHJlcG9ydCAhPSAnTm9uZSc6CisgICAgICAgICAgICBzZWxmLnNlcnZlci5jb25maWcuc2V0KCdTY2FuVmlldycsICdyZXBvcnRlcicsIHJlcG9ydGVySW5kZXgpCisgICAgICAgICAgICBmb3IgbyBpbiByZXBvcnRlci5nZXRQYXJhbWV0ZXJzKCk6CisgICAgICAgICAgICAgIGlmIG8uc2F2ZUNvbmZpZ1ZhbHVlKCk6CisgICAgICAgICAgICAgICAgbmFtZSA9IG8uZ2V0TmFtZSgpCisgICAgICAgICAgICAgICAgc2VsZi5zZXJ2ZXIuY29uZmlnLnNldChyZXBvcnRlci5nZXROYW1lKCksIG5hbWUsIHBhcmFtZXRlcnNbbmFtZV0pCisKKyAgICAgICAgIyBDcmVhdGUgdGhlIHJlcG9ydC4KKyAgICAgICAgYnVnID0gUmVwb3J0ZXIuQnVnUmVwb3J0KHRpdGxlLCBkZXNjcmlwdGlvbiwgZmlsZXMpCisKKyAgICAgICAgIyBLaWNrIG9mZiBhIHJlcG9ydGluZyB0aHJlYWQuCisgICAgICAgIHQgPSBSZXBvcnRlclRocmVhZChidWcsIHJlcG9ydGVyLCBwYXJhbWV0ZXJzLCBzZWxmLnNlcnZlcikKKyAgICAgICAgdC5zdGFydCgpCisKKyAgICAgICAgIyBXYWl0IGZvciB0aHJlYWQgdG8gZGllLi4uCisgICAgICAgIHdoaWxlIHQuaXNBbGl2ZSgpOgorICAgICAgICAgICAgdGltZS5zbGVlcCguMjUpCisgICAgICAgIHN1Ym1pdFN0YXR1cyA9IHQuc3RhdHVzCisKKyAgICAgICAgcmV0dXJuICh0LnN1Y2Nlc3MsIHQuc3RhdHVzKQorCisgICAgZGVmIHNlbmRfcmVwb3J0X3N1Ym1pdChzZWxmKToKKyAgICAgICAgcmVwb3J0ID0gc2VsZi5nZXRfc2NhbGFyX2ZpZWxkKCdyZXBvcnQnKQorICAgICAgICBjID0gc2VsZi5nZXRfcmVwb3J0X2NvbnRleHQocmVwb3J0KQorICAgICAgICBpZiBjLnJlcG9ydFNvdXJjZSBpcyBOb25lOgorICAgICAgICAgICAgcmVwb3J0aW5nRm9yID0gIlJlcG9ydCBDcmFzaGVzID4gIgorICAgICAgICAgICAgZmlsZUJ1ZyA9ICIiIlwKKzxhIGhyZWY9Ii9yZXBvcnRfY3Jhc2hlcyI+RmlsZSBCdWc8L2E+ID4gIiIiJWxvY2FscygpCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICByZXBvcnRpbmdGb3IgPSAnPGEgaHJlZj0iLyVzIj5SZXBvcnQgJXM8L2E+ID4gJyAlIChjLnJlcG9ydFNvdXJjZSwgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgcmVwb3J0KQorICAgICAgICAgICAgZmlsZUJ1ZyA9ICc8YSBocmVmPSIvcmVwb3J0LyVzIj5GaWxlIEJ1ZzwvYT4gPiAnICUgcmVwb3J0CisgICAgICAgIHRpdGxlID0gc2VsZi5nZXRfc2NhbGFyX2ZpZWxkKCd0aXRsZScpCisgICAgICAgIGRlc2NyaXB0aW9uID0gc2VsZi5nZXRfc2NhbGFyX2ZpZWxkKCdkZXNjcmlwdGlvbicpCisKKyAgICAgICAgcmVzLG1lc3NhZ2UgPSBzZWxmLnN1Ym1pdF9idWcoYykKKworICAgICAgICBpZiByZXM6CisgICAgICAgICAgICBzdGF0dXNDbGFzcyA9ICdTdWJtaXRPaycKKyAgICAgICAgICAgIHN0YXR1c05hbWUgPSAnU3VjY2VlZGVkJworICAgICAgICBlbHNlOgorICAgICAgICAgICAgc3RhdHVzQ2xhc3MgPSAnU3VibWl0RmFpbCcKKyAgICAgICAgICAgIHN0YXR1c05hbWUgPSAnRmFpbGVkJworCisgICAgICAgIHJlc3VsdCA9ICIiIgorPGhlYWQ+CisgIDx0aXRsZT5CdWcgU3VibWlzc2lvbjwvdGl0bGU+CisgIDxsaW5rIHJlbD0ic3R5bGVzaGVldCIgdHlwZT0idGV4dC9jc3MiIGhyZWY9Ii9zY2Fudmlldy5jc3MiIC8+Cis8L2hlYWQ+Cis8Ym9keT4KKzxoMz4KKzxhIGhyZWY9Ii8iPlN1bW1hcnk8L2E+ID4gCislKHJlcG9ydGluZ0ZvcilzCislKGZpbGVCdWcpcworU3VibWl0PC9oMz4KKzxmb3JtIG5hbWU9ImZvcm0iIGFjdGlvbj0iIj4KKzx0YWJsZSBjbGFzcz0iZm9ybSI+Cis8dHI+PHRkPgorPHRhYmxlIGNsYXNzPSJmb3JtX2dyb3VwIj4KKzx0cj4KKyAgPHRkIGNsYXNzPSJmb3JtX2NsYWJlbCI+VGl0bGU6PC90ZD4KKyAgPHRkIGNsYXNzPSJmb3JtX3ZhbHVlIj4KKyAgICA8aW5wdXQgdHlwZT0idGV4dCIgbmFtZT0idGl0bGUiIHNpemU9IjUwIiB2YWx1ZT0iJSh0aXRsZSlzIiBkaXNhYmxlZD4KKyAgPC90ZD4KKzwvdHI+Cis8dHI+CisgIDx0ZCBjbGFzcz0iZm9ybV9sYWJlbCI+RGVzY3JpcHRpb246PC90ZD4KKyAgPHRkIGNsYXNzPSJmb3JtX3ZhbHVlIj4KKzx0ZXh0YXJlYSByb3dzPSIxMCIgY29scz0iODAiIG5hbWU9ImRlc2NyaXB0aW9uIiBkaXNhYmxlZD4KKyUoZGVzY3JpcHRpb24pcworPC90ZXh0YXJlYT4KKyAgPC90ZD4KKzwvdGFibGU+Cis8L3RkPjwvdHI+Cis8L3RhYmxlPgorPC9mb3JtPgorPGgxIGNsYXNzPSIlKHN0YXR1c0NsYXNzKXMiPlN1Ym1pc3Npb24gJShzdGF0dXNOYW1lKXM8L2gxPgorJShtZXNzYWdlKXMKKzxwPgorPGhyPgorPGEgaHJlZj0iLyI+UmV0dXJuIHRvIFN1bW1hcnk8L2E+Cis8L2JvZHk+Cis8L2h0bWw+IiIiJWxvY2FscygpCisgICAgICAgIHJldHVybiBzZWxmLnNlbmRfc3RyaW5nKHJlc3VsdCkKKworICAgIGRlZiBzZW5kX29wZW5fcmVwb3J0KHNlbGYsIHJlcG9ydCk6CisgICAgICAgIHRyeToKKyAgICAgICAgICAgIGtleXMgPSBzZWxmLmxvYWRfcmVwb3J0KHJlcG9ydCkKKyAgICAgICAgZXhjZXB0IElPRXJyb3I6CisgICAgICAgICAgICByZXR1cm4gc2VsZi5zZW5kX2Vycm9yKDQwMCwgJ0ludmFsaWQgcmVwb3J0LicpCisKKyAgICAgICAgZmlsZSA9IGtleXMuZ2V0KCdGSUxFJykKKyAgICAgICAgaWYgbm90IGZpbGUgb3Igbm90IHBvc2l4cGF0aC5leGlzdHMoZmlsZSk6CisgICAgICAgICAgICByZXR1cm4gc2VsZi5zZW5kX2Vycm9yKDQwMCwgJ0ZpbGUgZG9lcyBub3QgZXhpc3Q6ICIlcyInICUgZmlsZSkKKworICAgICAgICBpbXBvcnQgc3RhcnRmaWxlCisgICAgICAgIGlmIHNlbGYuc2VydmVyLm9wdGlvbnMuZGVidWc6CisgICAgICAgICAgICBwcmludCA+PnN5cy5zdGRlcnIsICclczogU0VSVkVSOiBvcGVuaW5nICIlcyInJShzeXMuYXJndlswXSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGZpbGUpCisKKyAgICAgICAgc3RhdHVzID0gc3RhcnRmaWxlLm9wZW4oZmlsZSkKKyAgICAgICAgaWYgc3RhdHVzOgorICAgICAgICAgICAgcmVzID0gJ09wZW5lZDogIiVzIicgJSBmaWxlCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICByZXMgPSAnT3BlbiBmYWlsZWQ6ICIlcyInICUgZmlsZQorCisgICAgICAgIHJldHVybiBzZWxmLnNlbmRfc3RyaW5nKHJlcywgJ3RleHQvcGxhaW4nKQorCisgICAgZGVmIGdldF9yZXBvcnRfY29udGV4dChzZWxmLCByZXBvcnQpOgorICAgICAgICBjbGFzcyBDb250ZXh0OgorICAgICAgICAgICAgcGFzcworICAgICAgICBpZiByZXBvcnQgaXMgTm9uZSBvciByZXBvcnQgPT0gJ05vbmUnOgorICAgICAgICAgICAgZGF0YSA9IHNlbGYubG9hZF9jcmFzaGVzKCkKKyAgICAgICAgICAgICMgRG9uJ3QgYWxsb3cgZW1wdHkgcmVwb3J0cy4KKyAgICAgICAgICAgIGlmIG5vdCBkYXRhOgorICAgICAgICAgICAgICAgIHJhaXNlIFZhbHVlRXJyb3IsICdObyBjcmFzaGVzIGRldGVjdGVkIScKKyAgICAgICAgICAgIGMgPSBDb250ZXh0KCkKKyAgICAgICAgICAgIGMudGl0bGUgPSAnY2xhbmcgc3RhdGljIGFuYWx5emVyIGZhaWx1cmVzJworCisgICAgICAgICAgICBzdGRlcnJTdW1tYXJ5ID0gIiIKKyAgICAgICAgICAgIGZvciBpdGVtIGluIGRhdGE6CisgICAgICAgICAgICAgICAgaWYgJ3N0ZGVycicgaW4gaXRlbToKKyAgICAgICAgICAgICAgICAgICAgcGF0aCA9IHBvc2l4cGF0aC5qb2luKHNlbGYuc2VydmVyLnJvb3QsIGl0ZW1bJ3N0ZGVyciddKQorICAgICAgICAgICAgICAgICAgICBpZiBvcy5wYXRoLmV4aXN0cyhwYXRoKToKKyAgICAgICAgICAgICAgICAgICAgICAgIGxucyA9IGl0ZXJ0b29scy5pc2xpY2Uob3BlbihwYXRoKSwgMCwgMTApCisgICAgICAgICAgICAgICAgICAgICAgICBzdGRlcnJTdW1tYXJ5ICs9ICclc1xuLS1cbiVzJyAlIChpdGVtLmdldCgnc3JjJywgCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnPHVua25vd24+JyksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnJy5qb2luKGxucykpCisKKyAgICAgICAgICAgIGMuZGVzY3JpcHRpb24gPSAiIiJcCitUaGUgY2xhbmcgc3RhdGljIGFuYWx5emVyIGZhaWxlZCBvbiB0aGVzZSBpbnB1dHM6CislcworCitTVERFUlIgU3VtbWFyeQorLS0tLS0tLS0tLS0tLS0KKyVzCisiIiIgJSAoJ1xuJy5qb2luKFtpdGVtLmdldCgnc3JjJywnPHVua25vd24+JykgZm9yIGl0ZW0gaW4gZGF0YV0pLAorICAgICAgIHN0ZGVyclN1bW1hcnkpCisgICAgICAgICAgICBjLnJlcG9ydFNvdXJjZSA9IE5vbmUKKyAgICAgICAgICAgIGMubmF2TWFya3VwID0gIlJlcG9ydCBDcmFzaGVzID4gIgorICAgICAgICAgICAgYy5maWxlcyA9IFtdCisgICAgICAgICAgICBmb3IgaXRlbSBpbiBkYXRhOiAgICAgICAgICAgICAgICAKKyAgICAgICAgICAgICAgICBjLmZpbGVzLmFwcGVuZChpdGVtLmdldCgnc3JjJywnJykpCisgICAgICAgICAgICAgICAgYy5maWxlcy5hcHBlbmQocG9zaXhwYXRoLmpvaW4oc2VsZi5zZXJ2ZXIucm9vdCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpdGVtLmdldCgnZmlsZScsJycpKSkKKyAgICAgICAgICAgICAgICBjLmZpbGVzLmFwcGVuZChwb3NpeHBhdGguam9pbihzZWxmLnNlcnZlci5yb290LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGl0ZW0uZ2V0KCdjbGFuZ2ZpbGUnLCcnKSkpCisgICAgICAgICAgICAgICAgYy5maWxlcy5hcHBlbmQocG9zaXhwYXRoLmpvaW4oc2VsZi5zZXJ2ZXIucm9vdCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBpdGVtLmdldCgnc3RkZXJyJywnJykpKQorICAgICAgICAgICAgICAgIGMuZmlsZXMuYXBwZW5kKHBvc2l4cGF0aC5qb2luKHNlbGYuc2VydmVyLnJvb3QsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgaXRlbS5nZXQoJ2luZm8nLCcnKSkpCisgICAgICAgICAgICAjIEp1c3QgaW4gY2FzZSBzb21ldGhpbmcgZmFpbGVkLCBpZ25vcmUgZmlsZXMgd2hpY2ggZG9uJ3QKKyAgICAgICAgICAgICMgZXhpc3QuCisgICAgICAgICAgICBjLmZpbGVzID0gW2YgZm9yIGYgaW4gYy5maWxlcworICAgICAgICAgICAgICAgICAgICAgICBpZiBvcy5wYXRoLmV4aXN0cyhmKSBhbmQgb3MucGF0aC5pc2ZpbGUoZildCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICAjIENoZWNrIHRoYXQgdGhpcyBpcyBhIHZhbGlkIHJlcG9ydC4gICAgICAgICAgICAKKyAgICAgICAgICAgIHBhdGggPSBwb3NpeHBhdGguam9pbihzZWxmLnNlcnZlci5yb290LCAncmVwb3J0LSVzLmh0bWwnICUgcmVwb3J0KQorICAgICAgICAgICAgaWYgbm90IHBvc2l4cGF0aC5leGlzdHMocGF0aCk6CisgICAgICAgICAgICAgICAgcmFpc2UgVmFsdWVFcnJvciwgJ0ludmFsaWQgcmVwb3J0IElEJworICAgICAgICAgICAga2V5cyA9IHNlbGYubG9hZF9yZXBvcnQocmVwb3J0KQorICAgICAgICAgICAgYyA9IENvbnRleHQoKQorICAgICAgICAgICAgYy50aXRsZSA9IGtleXMuZ2V0KCdERVNDJywnY2xhbmcgZXJyb3IgKHVucmVjb2duaXplZCcpCisgICAgICAgICAgICBjLmRlc2NyaXB0aW9uID0gIiIiXAorQnVnIHJlcG9ydGVkIGJ5IHRoZSBjbGFuZyBzdGF0aWMgYW5hbHl6ZXIuCisKK0Rlc2NyaXB0aW9uOiAlcworRmlsZTogJXMKK0xpbmU6ICVzCisiIiIlKGMudGl0bGUsIGtleXMuZ2V0KCdGSUxFJywnPHVua25vd24+JyksIGtleXMuZ2V0KCdMSU5FJywgJzx1bmtub3duPicpKQorICAgICAgICAgICAgYy5yZXBvcnRTb3VyY2UgPSAncmVwb3J0LSVzLmh0bWwnICUgcmVwb3J0CisgICAgICAgICAgICBjLm5hdk1hcmt1cCA9ICIiIjxhIGhyZWY9Ii8lcyI+UmVwb3J0ICVzPC9hPiA+ICIiIiAlIChjLnJlcG9ydFNvdXJjZSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHJlcG9ydCkKKworICAgICAgICAgICAgYy5maWxlcyA9IFtwYXRoXQorICAgICAgICByZXR1cm4gYworCisgICAgZGVmIHNlbmRfcmVwb3J0KHNlbGYsIHJlcG9ydCwgY29uZmlnT3ZlcnJpZGVzPU5vbmUpOgorICAgICAgICBkZWYgZ2V0Q29uZmlnT3B0aW9uKHNlY3Rpb24sIGZpZWxkKTogICAgICAgICAgICAKKyAgICAgICAgICAgIGlmIChjb25maWdPdmVycmlkZXMgaXMgbm90IE5vbmUgYW5kCisgICAgICAgICAgICAgICAgc2VjdGlvbiBpbiBjb25maWdPdmVycmlkZXMgYW5kCisgICAgICAgICAgICAgICAgZmllbGQgaW4gY29uZmlnT3ZlcnJpZGVzW3NlY3Rpb25dKToKKyAgICAgICAgICAgICAgICByZXR1cm4gY29uZmlnT3ZlcnJpZGVzW3NlY3Rpb25dW2ZpZWxkXQorICAgICAgICAgICAgcmV0dXJuIHNlbGYuc2VydmVyLmNvbmZpZy5nZXQoc2VjdGlvbiwgZmllbGQpCisKKyAgICAgICAgIyByZXBvcnQgaXMgTm9uZSBpcyB1c2VkIGZvciBjcmFzaGVzCisgICAgICAgIHRyeToKKyAgICAgICAgICAgIGMgPSBzZWxmLmdldF9yZXBvcnRfY29udGV4dChyZXBvcnQpCisgICAgICAgIGV4Y2VwdCBWYWx1ZUVycm9yLCBlOgorICAgICAgICAgICAgcmV0dXJuIHNlbGYuc2VuZF9lcnJvcig0MDAsIGUubWVzc2FnZSkKKworICAgICAgICB0aXRsZSA9IGMudGl0bGUKKyAgICAgICAgZGVzY3JpcHRpb249IGMuZGVzY3JpcHRpb24KKyAgICAgICAgcmVwb3J0aW5nRm9yID0gYy5uYXZNYXJrdXAKKyAgICAgICAgaWYgYy5yZXBvcnRTb3VyY2UgaXMgTm9uZToKKyAgICAgICAgICAgIGV4dHJhSUZyYW1lID0gIiIKKyAgICAgICAgZWxzZToKKyAgICAgICAgICAgIGV4dHJhSUZyYW1lID0gIiIiXAorPGlmcmFtZSBzcmM9Ii8lcyIgd2lkdGg9IjEwMCUlIiBoZWlnaHQ9IjQwJSUiCisgICAgICAgIHNjcm9sbGluZz0iYXV0byIgZnJhbWVib3JkZXI9IjEiPgorICA8YSBocmVmPSIvJXMiPlZpZXcgQnVnIFJlcG9ydDwvYT4KKzwvaWZyYW1lPiIiIiAlIChjLnJlcG9ydFNvdXJjZSwgYy5yZXBvcnRTb3VyY2UpCisKKyAgICAgICAgcmVwb3J0ZXJTZWxlY3Rpb25zID0gW10KKyAgICAgICAgcmVwb3J0ZXJPcHRpb25zID0gW10KKworICAgICAgICB0cnk6CisgICAgICAgICAgICBhY3RpdmUgPSBpbnQoZ2V0Q29uZmlnT3B0aW9uKCdTY2FuVmlldycsJ3JlcG9ydGVyJykpCisgICAgICAgIGV4Y2VwdDoKKyAgICAgICAgICAgIGFjdGl2ZSA9IDAKKyAgICAgICAgZm9yIGksciBpbiBlbnVtZXJhdGUoc2VsZi5zZXJ2ZXIucmVwb3J0ZXJzKToKKyAgICAgICAgICAgIHNlbGVjdGVkID0gKGkgPT0gYWN0aXZlKQorICAgICAgICAgICAgaWYgc2VsZWN0ZWQ6CisgICAgICAgICAgICAgICAgc2VsZWN0ZWRTdHIgPSAnIHNlbGVjdGVkJworICAgICAgICAgICAgZWxzZToKKyAgICAgICAgICAgICAgICBzZWxlY3RlZFN0ciA9ICcnCisgICAgICAgICAgICByZXBvcnRlclNlbGVjdGlvbnMuYXBwZW5kKCc8b3B0aW9uIHZhbHVlPSIlZCIlcz4lczwvb3B0aW9uPiclKGksc2VsZWN0ZWRTdHIsci5nZXROYW1lKCkpKQorICAgICAgICAgICAgb3B0aW9ucyA9ICdcbicuam9pbihbIG8uZ2V0SFRNTChyLHRpdGxlLGdldENvbmZpZ09wdGlvbikgZm9yIG8gaW4gci5nZXRQYXJhbWV0ZXJzKCldKQorICAgICAgICAgICAgZGlzcGxheSA9ICgnbm9uZScsJycpW3NlbGVjdGVkXQorICAgICAgICAgICAgcmVwb3J0ZXJPcHRpb25zLmFwcGVuZCgiIiJcCis8dHIgaWQ9IiVzUmVwb3J0ZXJPcHRpb25zIiBzdHlsZT0iZGlzcGxheTolcyI+CisgIDx0ZCBjbGFzcz0iZm9ybV9sYWJlbCI+JXMgT3B0aW9uczwvdGQ+CisgIDx0ZCBjbGFzcz0iZm9ybV92YWx1ZSI+CisgICAgPHRhYmxlIGNsYXNzPSJmb3JtX2lubmVyX2dyb3VwIj4KKyVzCisgICAgPC90YWJsZT4KKyAgPC90ZD4KKzwvdHI+CisiIiIlKHIuZ2V0TmFtZSgpLGRpc3BsYXksci5nZXROYW1lKCksb3B0aW9ucykpCisgICAgICAgIHJlcG9ydGVyU2VsZWN0aW9ucyA9ICdcbicuam9pbihyZXBvcnRlclNlbGVjdGlvbnMpCisgICAgICAgIHJlcG9ydGVyT3B0aW9uc0RpdnMgPSAnXG4nLmpvaW4ocmVwb3J0ZXJPcHRpb25zKQorICAgICAgICByZXBvcnRlcnNBcnJheSA9ICdbJXNdJyUoJywnLmpvaW4oW2ByLmdldE5hbWUoKWAgZm9yIHIgaW4gc2VsZi5zZXJ2ZXIucmVwb3J0ZXJzXSkpCisKKyAgICAgICAgaWYgYy5maWxlczoKKyAgICAgICAgICAgIGZpZWxkU2l6ZSA9IG1pbig1LCBsZW4oYy5maWxlcykpCisgICAgICAgICAgICBhdHRhY2hGaWxlT3B0aW9ucyA9ICdcbicuam9pbihbIiIiXAorPG9wdGlvbiB2YWx1ZT0iJWQiIHNlbGVjdGVkPiVzPC9vcHRpb24+IiIiICUgKGksdikgZm9yIGksdiBpbiBlbnVtZXJhdGUoYy5maWxlcyldKQorICAgICAgICAgICAgYXR0YWNoRmlsZVJvdyA9ICIiIlwKKzx0cj4KKyAgPHRkIGNsYXNzPSJmb3JtX2xhYmVsIj5BdHRhY2g6PC90ZD4KKyAgPHRkIGNsYXNzPSJmb3JtX3ZhbHVlIj4KKzxzZWxlY3Qgc3R5bGU9IndpZHRoOjEwMCUlIiBuYW1lPSJmaWxlcyIgbXVsdGlwbGUgc2l6ZT0lZD4KKyVzCis8L3NlbGVjdD4KKyAgPC90ZD4KKzwvdHI+CisiIiIgJSAobWluKDUsIGxlbihjLmZpbGVzKSksIGF0dGFjaEZpbGVPcHRpb25zKQorICAgICAgICBlbHNlOgorICAgICAgICAgICAgYXR0YWNoRmlsZVJvdyA9ICIiCisKKyAgICAgICAgcmVzdWx0ID0gIiIiPGh0bWw+Cis8aGVhZD4KKyAgPHRpdGxlPkZpbGUgQnVnPC90aXRsZT4KKyAgPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiB0eXBlPSJ0ZXh0L2NzcyIgaHJlZj0iL3NjYW52aWV3LmNzcyIgLz4KKzwvaGVhZD4KKzxzY3JpcHQgbGFuZ3VhZ2U9ImphdmFzY3JpcHQiIHR5cGU9InRleHQvamF2YXNjcmlwdCI+Cit2YXIgcmVwb3J0ZXJzID0gJShyZXBvcnRlcnNBcnJheSlzOworZnVuY3Rpb24gdXBkYXRlUmVwb3J0ZXJPcHRpb25zKCkgeworICBpbmRleCA9IGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCdyZXBvcnRlcicpLnNlbGVjdGVkSW5kZXg7CisgIGZvciAodmFyIGk9MDsgaSA8IHJlcG9ydGVycy5sZW5ndGg7ICsraSkgeworICAgIG8gPSBkb2N1bWVudC5nZXRFbGVtZW50QnlJZChyZXBvcnRlcnNbaV0gKyAiUmVwb3J0ZXJPcHRpb25zIik7CisgICAgaWYgKGkgPT0gaW5kZXgpIHsKKyAgICAgIG8uc3R5bGUuZGlzcGxheSA9ICIiOworICAgIH0gZWxzZSB7CisgICAgICBvLnN0eWxlLmRpc3BsYXkgPSAibm9uZSI7CisgICAgfQorICB9Cit9Cis8L3NjcmlwdD4KKzxib2R5IG9uTG9hZD0idXBkYXRlUmVwb3J0ZXJPcHRpb25zKCkiPgorPGgzPgorPGEgaHJlZj0iLyI+U3VtbWFyeTwvYT4gPiAKKyUocmVwb3J0aW5nRm9yKXMKK0ZpbGUgQnVnPC9oMz4KKzxmb3JtIG5hbWU9ImZvcm0iIGFjdGlvbj0iL3JlcG9ydF9zdWJtaXQiIG1ldGhvZD0icG9zdCI+Cis8aW5wdXQgdHlwZT0iaGlkZGVuIiBuYW1lPSJyZXBvcnQiIHZhbHVlPSIlKHJlcG9ydClzIj4KKworPHRhYmxlIGNsYXNzPSJmb3JtIj4KKzx0cj48dGQ+Cis8dGFibGUgY2xhc3M9ImZvcm1fZ3JvdXAiPgorPHRyPgorICA8dGQgY2xhc3M9ImZvcm1fY2xhYmVsIj5UaXRsZTo8L3RkPgorICA8dGQgY2xhc3M9ImZvcm1fdmFsdWUiPgorICAgIDxpbnB1dCB0eXBlPSJ0ZXh0IiBuYW1lPSJ0aXRsZSIgc2l6ZT0iNTAiIHZhbHVlPSIlKHRpdGxlKXMiPgorICA8L3RkPgorPC90cj4KKzx0cj4KKyAgPHRkIGNsYXNzPSJmb3JtX2xhYmVsIj5EZXNjcmlwdGlvbjo8L3RkPgorICA8dGQgY2xhc3M9ImZvcm1fdmFsdWUiPgorPHRleHRhcmVhIHJvd3M9IjEwIiBjb2xzPSI4MCIgbmFtZT0iZGVzY3JpcHRpb24iPgorJShkZXNjcmlwdGlvbilzCis8L3RleHRhcmVhPgorICA8L3RkPgorPC90cj4KKworJShhdHRhY2hGaWxlUm93KXMKKworPC90YWJsZT4KKzxicj4KKzx0YWJsZSBjbGFzcz0iZm9ybV9ncm91cCI+Cis8dHI+CisgIDx0ZCBjbGFzcz0iZm9ybV9jbGFiZWwiPk1ldGhvZDo8L3RkPgorICA8dGQgY2xhc3M9ImZvcm1fdmFsdWUiPgorICAgIDxzZWxlY3QgaWQ9InJlcG9ydGVyIiBuYW1lPSJyZXBvcnRlciIgb25DaGFuZ2U9InVwZGF0ZVJlcG9ydGVyT3B0aW9ucygpIj4KKyAgICAlKHJlcG9ydGVyU2VsZWN0aW9ucylzCisgICAgPC9zZWxlY3Q+CisgIDwvdGQ+Cis8L3RyPgorJShyZXBvcnRlck9wdGlvbnNEaXZzKXMKKzwvdGFibGU+Cis8YnI+Cis8L3RkPjwvdHI+Cis8dHI+PHRkIGNsYXNzPSJmb3JtX3N1Ym1pdCI+CisgIDxpbnB1dCBhbGlnbj0icmlnaHQiIHR5cGU9InN1Ym1pdCIgbmFtZT0iU3VibWl0IiB2YWx1ZT0iU3VibWl0Ij4KKzwvdGQ+PC90cj4KKzwvdGFibGU+Cis8L2Zvcm0+CisKKyUoZXh0cmFJRnJhbWUpcworCis8L2JvZHk+Cis8L2h0bWw+IiIiJWxvY2FscygpCisKKyAgICAgICAgcmV0dXJuIHNlbGYuc2VuZF9zdHJpbmcocmVzdWx0KQorCisgICAgZGVmIHNlbmRfaGVhZChzZWxmLCBmaWVsZHM9Tm9uZSk6CisgICAgICAgIGlmIChzZWxmLnNlcnZlci5vcHRpb25zLm9ubHlTZXJ2ZUxvY2FsIGFuZAorICAgICAgICAgICAgc2VsZi5jbGllbnRfYWRkcmVzc1swXSAhPSAnMTI3LjAuMC4xJyk6CisgICAgICAgICAgICByZXR1cm4gc2VsZi5zZW5kX2Vycm9yKDQwMSwgJ1VuYXV0aG9yaXplZCBob3N0LicpCisKKyAgICAgICAgaWYgZmllbGRzIGlzIE5vbmU6CisgICAgICAgICAgICBmaWVsZHMgPSB7fQorICAgICAgICBzZWxmLmZpZWxkcyA9IGZpZWxkcworCisgICAgICAgIG8gPSB1cmxwYXJzZS51cmxwYXJzZShzZWxmLnBhdGgpCisgICAgICAgIHNlbGYuZmllbGRzID0gcGFyc2VfcXVlcnkoby5xdWVyeSwgZmllbGRzKQorICAgICAgICBwYXRoID0gcG9zaXhwYXRoLm5vcm1wYXRoKHVybGxpYi51bnF1b3RlKG8ucGF0aCkpCisKKyAgICAgICAgIyBTcGxpdCB0aGUgY29tcG9uZW50cyBhbmQgc3RyaXAgdGhlIHJvb3QgcHJlZml4LgorICAgICAgICBjb21wb25lbnRzID0gcGF0aC5zcGxpdCgnLycpWzE6XQorICAgICAgICAKKyAgICAgICAgIyBTcGVjaWFsIGNhc2Ugc29tZSB0b3AtbGV2ZWwgZW50cmllcy4KKyAgICAgICAgaWYgY29tcG9uZW50czoKKyAgICAgICAgICAgIG5hbWUgPSBjb21wb25lbnRzWzBdCisgICAgICAgICAgICBpZiBsZW4oY29tcG9uZW50cyk9PTI6CisgICAgICAgICAgICAgICAgaWYgbmFtZT09J3JlcG9ydCc6CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBzZWxmLnNlbmRfcmVwb3J0KGNvbXBvbmVudHNbMV0pCisgICAgICAgICAgICAgICAgZWxpZiBuYW1lPT0nb3Blbic6CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBzZWxmLnNlbmRfb3Blbl9yZXBvcnQoY29tcG9uZW50c1sxXSkKKyAgICAgICAgICAgIGVsaWYgbGVuKGNvbXBvbmVudHMpPT0xOgorICAgICAgICAgICAgICAgIGlmIG5hbWU9PSdxdWl0JzoKKyAgICAgICAgICAgICAgICAgICAgc2VsZi5zZXJ2ZXIuaGFsdCgpCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBzZWxmLnNlbmRfc3RyaW5nKCdHb29kYnllLicsICd0ZXh0L3BsYWluJykKKyAgICAgICAgICAgICAgICBlbGlmIG5hbWU9PSdyZXBvcnRfc3VibWl0JzoKKyAgICAgICAgICAgICAgICAgICAgcmV0dXJuIHNlbGYuc2VuZF9yZXBvcnRfc3VibWl0KCkKKyAgICAgICAgICAgICAgICBlbGlmIG5hbWU9PSdyZXBvcnRfY3Jhc2hlcyc6CisgICAgICAgICAgICAgICAgICAgIG92ZXJyaWRlcyA9IHsgJ1NjYW5WaWV3JyA6IHt9LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICdSYWRhcicgOiB7fSwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAnRW1haWwnIDoge30gfQorICAgICAgICAgICAgICAgICAgICBmb3IgaSxyIGluIGVudW1lcmF0ZShzZWxmLnNlcnZlci5yZXBvcnRlcnMpOgorICAgICAgICAgICAgICAgICAgICAgICAgaWYgci5nZXROYW1lKCkgPT0gJ1JhZGFyJzoKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICBvdmVycmlkZXNbJ1NjYW5WaWV3J11bJ3JlcG9ydGVyJ10gPSBpCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgYnJlYWsKKyAgICAgICAgICAgICAgICAgICAgb3ZlcnJpZGVzWydSYWRhciddWydDb21wb25lbnQnXSA9ICdsbHZtIC0gY2hlY2tlcicKKyAgICAgICAgICAgICAgICAgICAgb3ZlcnJpZGVzWydSYWRhciddWydDb21wb25lbnQgVmVyc2lvbiddID0gJ1gnCisgICAgICAgICAgICAgICAgICAgIHJldHVybiBzZWxmLnNlbmRfcmVwb3J0KE5vbmUsIG92ZXJyaWRlcykKKyAgICAgICAgICAgICAgICBlbGlmIG5hbWU9PSdmYXZpY29uLmljbyc6CisgICAgICAgICAgICAgICAgICAgIHJldHVybiBzZWxmLnNlbmRfcGF0aChwb3NpeHBhdGguam9pbihrUmVzb3VyY2VzLCdidWdjYXRjaGVyLmljbycpKQorICAgICAgICAKKyAgICAgICAgIyBNYXRjaCBkaXJlY3RvcnkgZW50cmllcy4KKyAgICAgICAgaWYgY29tcG9uZW50c1stMV0gPT0gJyc6CisgICAgICAgICAgICBjb21wb25lbnRzWy0xXSA9ICdpbmRleC5odG1sJworCisgICAgICAgIHJlbHBhdGggPSAnLycuam9pbihjb21wb25lbnRzKQorICAgICAgICBwYXRoID0gcG9zaXhwYXRoLmpvaW4oc2VsZi5zZXJ2ZXIucm9vdCwgcmVscGF0aCkKKworICAgICAgICBpZiBzZWxmLnNlcnZlci5vcHRpb25zLmRlYnVnID4gMToKKyAgICAgICAgICAgIHByaW50ID4+c3lzLnN0ZGVyciwgJyVzOiBTRVJWRVI6IHNlbmRpbmcgcGF0aCAiJXMiJyUoc3lzLmFyZ3ZbMF0sCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHBhdGgpCisgICAgICAgIHJldHVybiBzZWxmLnNlbmRfcGF0aChwYXRoKQorCisgICAgZGVmIHNlbmRfNDA0KHNlbGYpOgorICAgICAgICBzZWxmLnNlbmRfZXJyb3IoNDA0LCAiRmlsZSBub3QgZm91bmQiKQorICAgICAgICByZXR1cm4gTm9uZQorCisgICAgZGVmIHNlbmRfcGF0aChzZWxmLCBwYXRoKToKKyAgICAgICAgIyBJZiB0aGUgcmVxdWVzdGVkIHBhdGggaXMgb3V0c2lkZSB0aGUgcm9vdCBkaXJlY3RvcnksIGRvIG5vdCBvcGVuIGl0CisgICAgICAgIHJlbCA9IG9zLnBhdGguYWJzcGF0aChwYXRoKQorICAgICAgICBpZiBub3QgcmVsLnN0YXJ0c3dpdGgob3MucGF0aC5hYnNwYXRoKHNlbGYuc2VydmVyLnJvb3QpKToKKyAgICAgICAgICByZXR1cm4gc2VsZi5zZW5kXzQwNCgpCisgICAgICAgIAorICAgICAgICBjdHlwZSA9IHNlbGYuZ3Vlc3NfdHlwZShwYXRoKQorICAgICAgICBpZiBjdHlwZS5zdGFydHN3aXRoKCd0ZXh0LycpOgorICAgICAgICAgICAgIyBQYXRjaCBmaWxlIGluc3RlYWQKKyAgICAgICAgICAgIHJldHVybiBzZWxmLnNlbmRfcGF0Y2hlZF9maWxlKHBhdGgsIGN0eXBlKQorICAgICAgICBlbHNlOgorICAgICAgICAgICAgbW9kZSA9ICdyYicKKyAgICAgICAgdHJ5OgorICAgICAgICAgICAgZiA9IG9wZW4ocGF0aCwgbW9kZSkKKyAgICAgICAgZXhjZXB0IElPRXJyb3I6CisgICAgICAgICAgICByZXR1cm4gc2VsZi5zZW5kXzQwNCgpCisgICAgICAgIHJldHVybiBzZWxmLnNlbmRfZmlsZShmLCBjdHlwZSkKKworICAgIGRlZiBzZW5kX2ZpbGUoc2VsZiwgZiwgY3R5cGUpOgorICAgICAgICAjIFBhdGNoIGZpbGVzIHRvIGFkZCBsaW5rcywgYnV0IHNraXAgYmluYXJ5IGZpbGVzLgorICAgICAgICBzZWxmLnNlbmRfcmVzcG9uc2UoMjAwKQorICAgICAgICBzZWxmLnNlbmRfaGVhZGVyKCJDb250ZW50LXR5cGUiLCBjdHlwZSkKKyAgICAgICAgZnMgPSBvcy5mc3RhdChmLmZpbGVubygpKQorICAgICAgICBzZWxmLnNlbmRfaGVhZGVyKCJDb250ZW50LUxlbmd0aCIsIHN0cihmc1s2XSkpCisgICAgICAgIHNlbGYuc2VuZF9oZWFkZXIoIkxhc3QtTW9kaWZpZWQiLCBzZWxmLmRhdGVfdGltZV9zdHJpbmcoZnMuc3RfbXRpbWUpKQorICAgICAgICBzZWxmLmVuZF9oZWFkZXJzKCkKKyAgICAgICAgcmV0dXJuIGYKKworICAgIGRlZiBzZW5kX3N0cmluZyhzZWxmLCBzLCBjdHlwZT0ndGV4dC9odG1sJywgaGVhZGVycz1UcnVlLCBtdGltZT1Ob25lKToKKyAgICAgICAgaWYgaGVhZGVyczoKKyAgICAgICAgICAgIHNlbGYuc2VuZF9yZXNwb25zZSgyMDApCisgICAgICAgICAgICBzZWxmLnNlbmRfaGVhZGVyKCJDb250ZW50LXR5cGUiLCBjdHlwZSkKKyAgICAgICAgICAgIHNlbGYuc2VuZF9oZWFkZXIoIkNvbnRlbnQtTGVuZ3RoIiwgc3RyKGxlbihzKSkpCisgICAgICAgICAgICBpZiBtdGltZSBpcyBOb25lOgorICAgICAgICAgICAgICAgIG10aW1lID0gc2VsZi5keW5hbWljX210aW1lCisgICAgICAgICAgICBzZWxmLnNlbmRfaGVhZGVyKCJMYXN0LU1vZGlmaWVkIiwgc2VsZi5kYXRlX3RpbWVfc3RyaW5nKG10aW1lKSkKKyAgICAgICAgICAgIHNlbGYuZW5kX2hlYWRlcnMoKQorICAgICAgICByZXR1cm4gU3RyaW5nSU8uU3RyaW5nSU8ocykKKworICAgIGRlZiBzZW5kX3BhdGNoZWRfZmlsZShzZWxmLCBwYXRoLCBjdHlwZSk6CisgICAgICAgICMgQWxsb3cgYSB2ZXJ5IGxpbWl0ZWQgc2V0IG9mIHZhcmlhYmxlcy4gVGhpcyBpcyBwcmV0dHkgZ3Jvc3MuCisgICAgICAgIHZhcmlhYmxlcyA9IHt9CisgICAgICAgIHZhcmlhYmxlc1sncmVwb3J0J10gPSAnJworICAgICAgICBtID0ga1JlcG9ydEZpbGVSRS5tYXRjaChwYXRoKQorICAgICAgICBpZiBtOgorICAgICAgICAgICAgdmFyaWFibGVzWydyZXBvcnQnXSA9IG0uZ3JvdXAoMikKKworICAgICAgICB0cnk6CisgICAgICAgICAgICBmID0gb3BlbihwYXRoLCdyJykKKyAgICAgICAgZXhjZXB0IElPRXJyb3I6CisgICAgICAgICAgICByZXR1cm4gc2VsZi5zZW5kXzQwNCgpCisgICAgICAgIGZzID0gb3MuZnN0YXQoZi5maWxlbm8oKSkKKyAgICAgICAgZGF0YSA9IGYucmVhZCgpCisgICAgICAgIGZvciBhLGIgaW4ga1JlcG9ydFJlcGxhY2VtZW50czoKKyAgICAgICAgICAgIGRhdGEgPSBhLnN1YihiICUgdmFyaWFibGVzLCBkYXRhKQorICAgICAgICByZXR1cm4gc2VsZi5zZW5kX3N0cmluZyhkYXRhLCBjdHlwZSwgbXRpbWU9ZnMuc3RfbXRpbWUpCisKKworZGVmIGNyZWF0ZV9zZXJ2ZXIoYWRkcmVzcywgb3B0aW9ucywgcm9vdCk6CisgICAgaW1wb3J0IFJlcG9ydGVyCisKKyAgICByZXBvcnRlcnMgPSBSZXBvcnRlci5nZXRSZXBvcnRlcnMoKQorCisgICAgcmV0dXJuIFNjYW5WaWV3U2VydmVyKGFkZHJlc3MsIFNjYW5WaWV3UmVxdWVzdEhhbmRsZXIsCisgICAgICAgICAgICAgICAgICAgICAgICAgIHJvb3QsCisgICAgICAgICAgICAgICAgICAgICAgICAgIHJlcG9ydGVycywKKyAgICAgICAgICAgICAgICAgICAgICAgICAgb3B0aW9ucykKZGlmZiAtLWdpdCBhL3Rvb2xzL3NjYW4tdmlldy9zY2FuLXZpZXcgYi90b29scy9zY2FuLXZpZXcvc2Nhbi12aWV3Cm5ldyBmaWxlIG1vZGUgMTAwNzU1CmluZGV4IDAwMDAwMDAuLmZiMjdkYTYKLS0tIC9kZXYvbnVsbAorKysgYi90b29scy9zY2FuLXZpZXcvc2Nhbi12aWV3CkBAIC0wLDAgKzEsMTMxIEBACisjIS91c3IvYmluL2VudiBweXRob24KKworIiIiVGhlIGNsYW5nIHN0YXRpYyBhbmFseXplciByZXN1bHRzIHZpZXdlci4KKyIiIgorCitpbXBvcnQgc3lzCitpbXBvcnQgcG9zaXhwYXRoCitpbXBvcnQgdGhyZWFkCitpbXBvcnQgdGltZQoraW1wb3J0IHVybGxpYgoraW1wb3J0IHdlYmJyb3dzZXIKKworIyBIb3cgbG9uZyB0byB3YWl0IGZvciBzZXJ2ZXIgdG8gc3RhcnQuCitrU2xlZXBUaW1lb3V0ID0gLjA1CitrTWF4U2xlZXBzID0gaW50KDYwIC8ga1NsZWVwVGltZW91dCkKKworIyBEZWZhdWx0IHNlcnZlciBwYXJhbWV0ZXJzCisKK2tEZWZhdWx0SG9zdCA9ICcxMjcuMC4wLjEnCitrRGVmYXVsdFBvcnQgPSA4MTgxCitrTWF4UG9ydHNUb1RyeSA9IDEwMAorCisjIyMKKworZGVmIHVybF9pc191cCh1cmwpOgorICAgIHRyeToKKyAgICAgICAgbyA9IHVybGxpYi51cmxvcGVuKHVybCkKKyAgICBleGNlcHQgSU9FcnJvcjoKKyAgICAgICAgcmV0dXJuIEZhbHNlCisgICAgby5jbG9zZSgpCisgICAgcmV0dXJuIFRydWUKKworZGVmIHN0YXJ0X2Jyb3dzZXIocG9ydCwgb3B0aW9ucyk6CisgICAgaW1wb3J0IHVybGxpYiwgd2ViYnJvd3NlcgorCisgICAgdXJsID0gJ2h0dHA6Ly8lczolZCclKG9wdGlvbnMuaG9zdCwgcG9ydCkKKyAgICAKKyAgICAjIFdhaXQgZm9yIHNlcnZlciB0byBzdGFydC4uLgorICAgIGlmIG9wdGlvbnMuZGVidWc6CisgICAgICAgIHN5cy5zdGRlcnIud3JpdGUoJyVzOiBXYWl0aW5nIGZvciBzZXJ2ZXIuJyAlIHN5cy5hcmd2WzBdKQorICAgICAgICBzeXMuc3RkZXJyLmZsdXNoKCkKKyAgICBmb3IgaSBpbiByYW5nZShrTWF4U2xlZXBzKToKKyAgICAgICAgaWYgdXJsX2lzX3VwKHVybCk6CisgICAgICAgICAgICBicmVhaworICAgICAgICBpZiBvcHRpb25zLmRlYnVnOgorICAgICAgICAgICAgc3lzLnN0ZGVyci53cml0ZSgnLicpCisgICAgICAgICAgICBzeXMuc3RkZXJyLmZsdXNoKCkKKyAgICAgICAgdGltZS5zbGVlcChrU2xlZXBUaW1lb3V0KQorICAgIGVsc2U6CisgICAgICAgIHByaW50ID4+c3lzLnN0ZGVyciwnV0FSTklORzogVW5hYmxlIHRvIGRldGVjdCB0aGF0IHNlcnZlciBzdGFydGVkLicKKworICAgIGlmIG9wdGlvbnMuZGVidWc6CisgICAgICAgIHByaW50ID4+c3lzLnN0ZGVyciwnJXM6IFN0YXJ0aW5nIHdlYmJyb3dzZXIuLi4nICUgc3lzLmFyZ3ZbMF0KKyAgICB3ZWJicm93c2VyLm9wZW4odXJsKQorCitkZWYgcnVuKHBvcnQsIG9wdGlvbnMsIHJvb3QpOgorICAgIGltcG9ydCBTY2FuVmlldworICAgIHRyeToKKyAgICAgICAgcHJpbnQgJ1N0YXJ0aW5nIHNjYW4tdmlldyBhdDogaHR0cDovLyVzOiVkJyUob3B0aW9ucy5ob3N0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBwb3J0KQorICAgICAgICBwcmludCAnICBVc2UgQ3RybC1DIHRvIGV4aXQuJworICAgICAgICBodHRwZCA9IFNjYW5WaWV3LmNyZWF0ZV9zZXJ2ZXIoKG9wdGlvbnMuaG9zdCwgcG9ydCksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBvcHRpb25zLCByb290KQorICAgICAgICBodHRwZC5zZXJ2ZV9mb3JldmVyKCkKKyAgICBleGNlcHQgS2V5Ym9hcmRJbnRlcnJ1cHQ6CisgICAgICAgIHBhc3MKKworZGVmIHBvcnRfaXNfb3Blbihwb3J0KToKKyAgICBpbXBvcnQgU29ja2V0U2VydmVyCisgICAgdHJ5OgorICAgICAgICB0ID0gU29ja2V0U2VydmVyLlRDUFNlcnZlcigoa0RlZmF1bHRIb3N0LHBvcnQpLE5vbmUpCisgICAgZXhjZXB0OgorICAgICAgICByZXR1cm4gRmFsc2UKKyAgICB0LnNlcnZlcl9jbG9zZSgpCisgICAgcmV0dXJuIFRydWUKKworZGVmIG1haW4oKTogICAgCisgICAgZnJvbSBvcHRwYXJzZSBpbXBvcnQgT3B0aW9uUGFyc2VyCisgICAgcGFyc2VyID0gT3B0aW9uUGFyc2VyKCd1c2FnZTogJXByb2cgW29wdGlvbnNdIDxyZXN1bHRzIGRpcmVjdG9yeT4nKQorICAgIHBhcnNlci5zZXRfZGVzY3JpcHRpb24oX19kb2NfXykKKyAgICBwYXJzZXIuYWRkX29wdGlvbigKKyAgICAgICAgJy0taG9zdCcsIGRlc3Q9Imhvc3QiLCBkZWZhdWx0PWtEZWZhdWx0SG9zdCwgdHlwZT0ic3RyaW5nIiwKKyAgICAgICAgaGVscD0iSG9zdCBpbnRlcmZhY2UgdG8gbGlzdGVuIG9uLiAoZGVmYXVsdD0lcykiICUga0RlZmF1bHRIb3N0KQorICAgIHBhcnNlci5hZGRfb3B0aW9uKAorICAgICAgICAnLS1wb3J0JywgZGVzdD0icG9ydCIsIGRlZmF1bHQ9Tm9uZSwgdHlwZT0iaW50IiwKKyAgICAgICAgaGVscD0iUG9ydCB0byBsaXN0ZW4gb24uIChkZWZhdWx0PSVzKSIgJSBrRGVmYXVsdFBvcnQpCisgICAgcGFyc2VyLmFkZF9vcHRpb24oIi0tZGVidWciLCBkZXN0PSJkZWJ1ZyIsIGRlZmF1bHQ9MCwgCisgICAgICAgICAgICAgICAgICAgICAgYWN0aW9uPSJjb3VudCIsCisgICAgICAgICAgICAgICAgICAgICAgaGVscD0iUHJpbnQgYWRkaXRpb25hbCBkZWJ1Z2dpbmcgaW5mb3JtYXRpb24uIikKKyAgICBwYXJzZXIuYWRkX29wdGlvbigiLS1hdXRvLXJlbG9hZCIsIGRlc3Q9ImF1dG9SZWxvYWQiLCBkZWZhdWx0PUZhbHNlLCAKKyAgICAgICAgICAgICAgICAgICAgICBhY3Rpb249InN0b3JlX3RydWUiLAorICAgICAgICAgICAgICAgICAgICAgIGhlbHA9IkF1dG9tYXRpY2FsbHkgdXBkYXRlIG1vZHVsZSBmb3IgZWFjaCByZXF1ZXN0LiIpCisgICAgcGFyc2VyLmFkZF9vcHRpb24oIi0tbm8tYnJvd3NlciIsIGRlc3Q9InN0YXJ0QnJvd3NlciIsIGRlZmF1bHQ9VHJ1ZSwgCisgICAgICAgICAgICAgICAgICAgICAgYWN0aW9uPSJzdG9yZV9mYWxzZSIsCisgICAgICAgICAgICAgICAgICAgICAgaGVscD0iRG9uJ3Qgb3BlbiBhIHdlYmJyb3dzZXIgb24gc3RhcnR1cC4iKQorICAgIHBhcnNlci5hZGRfb3B0aW9uKCItLWFsbG93LWFsbC1ob3N0cyIsIGRlc3Q9Im9ubHlTZXJ2ZUxvY2FsIiwgZGVmYXVsdD1UcnVlLCAKKyAgICAgICAgICAgICAgICAgICAgICBhY3Rpb249InN0b3JlX2ZhbHNlIiwKKyAgICAgICAgICAgICAgICAgICAgICBoZWxwPSdBbGxvdyBjb25uZWN0aW9ucyBmcm9tIGFueSBob3N0IChhY2Nlc3MgcmVzdHJpY3RlZCB0byAiMTI3LjAuMC4xIiBieSBkZWZhdWx0KScpCisgICAgKG9wdGlvbnMsIGFyZ3MpID0gcGFyc2VyLnBhcnNlX2FyZ3MoKQorCisgICAgaWYgbGVuKGFyZ3MpICE9IDE6CisgICAgICAgIHBhcnNlci5lcnJvcignTm8gcmVzdWx0cyBkaXJlY3Rvcnkgc3BlY2lmaWVkLicpCisgICAgcm9vdCwgPSBhcmdzCisKKyAgICAjIE1ha2Ugc3VyZSB0aGlzIGRpcmVjdG9yeSBpcyBpbiBhIHJlYXNvbmFibGUgc3RhdGUgdG8gdmlldy4KKyAgICBpZiBub3QgcG9zaXhwYXRoLmV4aXN0cyhwb3NpeHBhdGguam9pbihyb290LCdpbmRleC5odG1sJykpOgorICAgICAgICBwYXJzZXIuZXJyb3IoJ0ludmFsaWQgZGlyZWN0b3J5LCBhbmFseXNpcyByZXN1bHRzIG5vdCBmb3VuZCEnKQorCisgICAgIyBGaW5kIGFuIG9wZW4gcG9ydC4gV2UgYXJlbid0IHBhcnRpY3VsYXJseSB3b3JyaWVkIGFib3V0IHJhY2UKKyAgICAjIGNvbmRpdGlvbnMgaGVyZS4gTm90ZSB0aGF0IGlmIHRoZSB1c2VyIHNwZWNpZmllZCBhIHBvcnQgd2Ugb25seQorICAgICMgdXNlIHRoYXQgb25lLgorICAgIGlmIG9wdGlvbnMucG9ydCBpcyBub3QgTm9uZToKKyAgICAgICAgcG9ydCA9IG9wdGlvbnMucG9ydAorICAgIGVsc2U6ICAgIAorICAgICAgICBmb3IgaSBpbiByYW5nZShrTWF4UG9ydHNUb1RyeSk6CisgICAgICAgICAgICBpZiBwb3J0X2lzX29wZW4oa0RlZmF1bHRQb3J0ICsgaSk6CisgICAgICAgICAgICAgICAgcG9ydCA9IGtEZWZhdWx0UG9ydCArIGkKKyAgICAgICAgICAgICAgICBicmVhaworICAgICAgICBlbHNlOgorICAgICAgICAgICAgcGFyc2VyLmVycm9yKCdVbmFibGUgdG8gZmluZCB1c2FibGUgcG9ydCBpbiBbJWQsJWQpJyUoa0RlZmF1bHRQb3J0LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAga0RlZmF1bHRQb3J0K2tNYXhQb3J0c1RvVHJ5KSkKKworICAgICMgS2ljayBvZmYgdGhyZWFkIHRvIHdhaXQgZm9yIHNlcnZlciBhbmQgc3RhcnQgd2ViIGJyb3dzZXIsIGlmCisgICAgIyByZXF1ZXN0ZWQuCisgICAgaWYgb3B0aW9ucy5zdGFydEJyb3dzZXI6CisgICAgICAgIHQgPSB0aHJlYWQuc3RhcnRfbmV3X3RocmVhZChzdGFydF9icm93c2VyLCAocG9ydCxvcHRpb25zKSkKKworICAgIHJ1bihwb3J0LCBvcHRpb25zLCByb290KQorCitpZiBfX25hbWVfXyA9PSAnX19tYWluX18nOgorICAgIG1haW4oKQpkaWZmIC0tZ2l0IGEvdG9vbHMvc2Nhbi12aWV3L3N0YXJ0ZmlsZS5weSBiL3Rvb2xzL3NjYW4tdmlldy9zdGFydGZpbGUucHkKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZThmYmUyZAotLS0gL2Rldi9udWxsCisrKyBiL3Rvb2xzL3NjYW4tdmlldy9zdGFydGZpbGUucHkKQEAgLTAsMCArMSwyMDMgQEAKKyIiIlV0aWxpdHkgZm9yIG9wZW5pbmcgYSBmaWxlIHVzaW5nIHRoZSBkZWZhdWx0IGFwcGxpY2F0aW9uIGluIGEgY3Jvc3MtcGxhdGZvcm0KK21hbm5lci4gTW9kaWZpZWQgZnJvbSBodHRwOi8vY29kZS5hY3RpdmVzdGF0ZS5jb20vcmVjaXBlcy81MTE0NDMvLgorIiIiCisKK19fdmVyc2lvbl9fID0gJzEuMXgnCitfX2FsbF9fID0gWydvcGVuJ10KKworaW1wb3J0IG9zCitpbXBvcnQgc3lzCitpbXBvcnQgd2ViYnJvd3NlcgoraW1wb3J0IHN1YnByb2Nlc3MKKworX2NvbnRyb2xsZXJzID0ge30KK19vcGVuID0gTm9uZQorCisKK2NsYXNzIEJhc2VDb250cm9sbGVyKG9iamVjdCk6CisgICAgJycnQmFzZSBjbGFzcyBmb3Igb3BlbiBwcm9ncmFtIGNvbnRyb2xsZXJzLicnJworCisgICAgZGVmIF9faW5pdF9fKHNlbGYsIG5hbWUpOgorICAgICAgICBzZWxmLm5hbWUgPSBuYW1lCisKKyAgICBkZWYgb3BlbihzZWxmLCBmaWxlbmFtZSk6CisgICAgICAgIHJhaXNlIE5vdEltcGxlbWVudGVkRXJyb3IKKworCitjbGFzcyBDb250cm9sbGVyKEJhc2VDb250cm9sbGVyKToKKyAgICAnJydDb250cm9sbGVyIGZvciBhIGdlbmVyaWMgb3BlbiBwcm9ncmFtLicnJworCisgICAgZGVmIF9faW5pdF9fKHNlbGYsICphcmdzKToKKyAgICAgICAgc3VwZXIoQ29udHJvbGxlciwgc2VsZikuX19pbml0X18ob3MucGF0aC5iYXNlbmFtZShhcmdzWzBdKSkKKyAgICAgICAgc2VsZi5hcmdzID0gbGlzdChhcmdzKQorCisgICAgZGVmIF9pbnZva2Uoc2VsZiwgY21kbGluZSk6CisgICAgICAgIGlmIHN5cy5wbGF0Zm9ybVs6M10gPT0gJ3dpbic6CisgICAgICAgICAgICBjbG9zZWZkcyA9IEZhbHNlCisgICAgICAgICAgICBzdGFydHVwaW5mbyA9IHN1YnByb2Nlc3MuU1RBUlRVUElORk8oKQorICAgICAgICAgICAgc3RhcnR1cGluZm8uZHdGbGFncyB8PSBzdWJwcm9jZXNzLlNUQVJURl9VU0VTSE9XV0lORE9XCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICBjbG9zZWZkcyA9IFRydWUKKyAgICAgICAgICAgIHN0YXJ0dXBpbmZvID0gTm9uZQorCisgICAgICAgIGlmIChvcy5lbnZpcm9uLmdldCgnRElTUExBWScpIG9yIHN5cy5wbGF0Zm9ybVs6M10gPT0gJ3dpbicgb3IKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBzeXMucGxhdGZvcm0gPT0gJ2RhcndpbicpOgorICAgICAgICAgICAgaW5vdXQgPSBmaWxlKG9zLmRldm51bGwsICdyKycpCisgICAgICAgIGVsc2U6CisgICAgICAgICAgICAjIGZvciBUVFkgcHJvZ3JhbXMsIHdlIG5lZWQgc3RkaW4vb3V0CisgICAgICAgICAgICBpbm91dCA9IE5vbmUKKworICAgICAgICAjIGlmIHBvc3NpYmxlLCBwdXQgdGhlIGNoaWxkIHByZWNlc3MgaW4gc2VwYXJhdGUgcHJvY2VzcyBncm91cCwKKyAgICAgICAgIyBzbyBrZXlib2FyZCBpbnRlcnJ1cHRzIGRvbid0IGFmZmVjdCBjaGlsZCBwcmVjZXNzIGFzIHdlbGwgYXMKKyAgICAgICAgIyBQeXRob24KKyAgICAgICAgc2V0c2lkID0gZ2V0YXR0cihvcywgJ3NldHNpZCcsIE5vbmUpCisgICAgICAgIGlmIG5vdCBzZXRzaWQ6CisgICAgICAgICAgICBzZXRzaWQgPSBnZXRhdHRyKG9zLCAnc2V0cGdycCcsIE5vbmUpCisKKyAgICAgICAgcGlwZSA9IHN1YnByb2Nlc3MuUG9wZW4oY21kbGluZSwgc3RkaW49aW5vdXQsIHN0ZG91dD1pbm91dCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgc3RkZXJyPWlub3V0LCBjbG9zZV9mZHM9Y2xvc2VmZHMsCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHByZWV4ZWNfZm49c2V0c2lkLCBzdGFydHVwaW5mbz1zdGFydHVwaW5mbykKKworICAgICAgICAjIEl0IGlzIGFzc3VtZWQgdGhhdCB0aGlzIGtpbmQgb2YgdG9vbHMgKGdub21lLW9wZW4sIGtmbWNsaWVudCwKKyAgICAgICAgIyBleG8tb3BlbiwgeGRnLW9wZW4gYW5kIG9wZW4gZm9yIE9TWCkgaW1tZWRpYXRlbHkgZXhpdCBhZnRlciBsYXVjaGluZworICAgICAgICAjIHRoZSBzcGVjaWZpYyBhcHBsaWNhdGlvbgorICAgICAgICByZXR1cm5jb2RlID0gcGlwZS53YWl0KCkKKyAgICAgICAgaWYgaGFzYXR0cihzZWxmLCAnZml4cmV0dXJuY29kZScpOgorICAgICAgICAgICAgcmV0dXJuY29kZSA9IHNlbGYuZml4cmV0dXJuY29kZShyZXR1cm5jb2RlKQorICAgICAgICByZXR1cm4gbm90IHJldHVybmNvZGUKKworICAgIGRlZiBvcGVuKHNlbGYsIGZpbGVuYW1lKToKKyAgICAgICAgaWYgaXNpbnN0YW5jZShmaWxlbmFtZSwgYmFzZXN0cmluZyk6CisgICAgICAgICAgICBjbWRsaW5lID0gc2VsZi5hcmdzICsgW2ZpbGVuYW1lXQorICAgICAgICBlbHNlOgorICAgICAgICAgICAgIyBhc3N1bWUgaXQgaXMgYSBzZXF1ZW5jZQorICAgICAgICAgICAgY21kbGluZSA9IHNlbGYuYXJncyArIGZpbGVuYW1lCisgICAgICAgIHRyeToKKyAgICAgICAgICAgIHJldHVybiBzZWxmLl9pbnZva2UoY21kbGluZSkKKyAgICAgICAgZXhjZXB0IE9TRXJyb3I6CisgICAgICAgICAgICByZXR1cm4gRmFsc2UKKworCisjIFBsYXRmb3JtIHN1cHBvcnQgZm9yIFdpbmRvd3MKK2lmIHN5cy5wbGF0Zm9ybVs6M10gPT0gJ3dpbic6CisKKyAgICBjbGFzcyBTdGFydChCYXNlQ29udHJvbGxlcik6CisgICAgICAgICcnJ0NvbnRyb2xsZXIgZm9yIHRoZSB3aW4zMiBzdGFydCBwcm9nYW0gdGhyb3VnaCBvcy5zdGFydGZpbGUuJycnCisKKyAgICAgICAgZGVmIG9wZW4oc2VsZiwgZmlsZW5hbWUpOgorICAgICAgICAgICAgdHJ5OgorICAgICAgICAgICAgICAgIG9zLnN0YXJ0ZmlsZShmaWxlbmFtZSkKKyAgICAgICAgICAgIGV4Y2VwdCBXaW5kb3dzRXJyb3I6CisgICAgICAgICAgICAgICAgIyBbRXJyb3IgMjJdIE5vIGFwcGxpY2F0aW9uIGlzIGFzc29jaWF0ZWQgd2l0aCB0aGUgc3BlY2lmaWVkCisgICAgICAgICAgICAgICAgIyBmaWxlIGZvciB0aGlzIG9wZXJhdGlvbjogJzxVUkw+JworICAgICAgICAgICAgICAgIHJldHVybiBGYWxzZQorICAgICAgICAgICAgZWxzZToKKyAgICAgICAgICAgICAgICByZXR1cm4gVHJ1ZQorCisgICAgX2NvbnRyb2xsZXJzWyd3aW5kb3dzLWRlZmF1bHQnXSA9IFN0YXJ0KCdzdGFydCcpCisgICAgX29wZW4gPSBfY29udHJvbGxlcnNbJ3dpbmRvd3MtZGVmYXVsdCddLm9wZW4KKworCisjIFBsYXRmb3JtIHN1cHBvcnQgZm9yIE1hY09TCitlbGlmIHN5cy5wbGF0Zm9ybSA9PSAnZGFyd2luJzoKKyAgICBfY29udHJvbGxlcnNbJ29wZW4nXT0gQ29udHJvbGxlcignb3BlbicpCisgICAgX29wZW4gPSBfY29udHJvbGxlcnNbJ29wZW4nXS5vcGVuCisKKworIyBQbGF0Zm9ybSBzdXBwb3J0IGZvciBVbml4CitlbHNlOgorCisgICAgaW1wb3J0IGNvbW1hbmRzCisKKyAgICAjIEBXQVJOSU5HOiB1c2UgdGhlIHByaXZhdGUgQVBJIG9mIHRoZSB3ZWJicm93c2VyIG1vZHVsZQorICAgIGZyb20gd2ViYnJvd3NlciBpbXBvcnQgX2lzY29tbWFuZAorCisgICAgY2xhc3MgS2ZtQ2xpZW50KENvbnRyb2xsZXIpOgorICAgICAgICAnJydDb250cm9sbGVyIGZvciB0aGUgS0RFIGtmbWNsaWVudCBwcm9ncmFtLicnJworCisgICAgICAgIGRlZiBfX2luaXRfXyhzZWxmLCBrZm1jbGllbnQ9J2tmbWNsaWVudCcpOgorICAgICAgICAgICAgc3VwZXIoS2ZtQ2xpZW50LCBzZWxmKS5fX2luaXRfXyhrZm1jbGllbnQsICdleGVjJykKKyAgICAgICAgICAgIHNlbGYua2RlX3ZlcnNpb24gPSBzZWxmLmRldGVjdF9rZGVfdmVyc2lvbigpCisKKyAgICAgICAgZGVmIGRldGVjdF9rZGVfdmVyc2lvbihzZWxmKToKKyAgICAgICAgICAgIGtkZV92ZXJzaW9uID0gTm9uZQorICAgICAgICAgICAgdHJ5OgorICAgICAgICAgICAgICAgIGluZm8gPSBjb21tYW5kcy5nZXRvdXRwdXQoJ2tkZS1jb25maWcgLS12ZXJzaW9uJykKKworICAgICAgICAgICAgICAgIGZvciBsaW5lIGluIGluZm8uc3BsaXRsaW5lcygpOgorICAgICAgICAgICAgICAgICAgICBpZiBsaW5lLnN0YXJ0c3dpdGgoJ0tERScpOgorICAgICAgICAgICAgICAgICAgICAgICAga2RlX3ZlcnNpb24gPSBsaW5lLnNwbGl0KCc6JylbLTFdLnN0cmlwKCkKKyAgICAgICAgICAgICAgICAgICAgICAgIGJyZWFrCisgICAgICAgICAgICBleGNlcHQgKE9TRXJyb3IsIFJ1bnRpbWVFcnJvcik6CisgICAgICAgICAgICAgICAgcGFzcworCisgICAgICAgICAgICByZXR1cm4ga2RlX3ZlcnNpb24KKworICAgICAgICBkZWYgZml4cmV0dXJuY29kZShzZWxmLCByZXR1cm5jb2RlKToKKyAgICAgICAgICAgIGlmIHJldHVybmNvZGUgaXMgbm90IE5vbmUgYW5kIHNlbGYua2RlX3ZlcnNpb24gPiAnMy41LjQnOgorICAgICAgICAgICAgICAgIHJldHVybiByZXR1cm5jb2RlCisgICAgICAgICAgICBlbHNlOgorICAgICAgICAgICAgICAgIHJldHVybiBvcy5FWF9PSworCisgICAgZGVmIGRldGVjdF9kZXNrdG9wX2Vudmlyb25tZW50KCk6CisgICAgICAgICcnJ0NoZWNrcyBmb3Iga25vd24gZGVza3RvcCBlbnZpcm9ubWVudHMKKworICAgICAgICBSZXR1cm4gdGhlIGRlc2t0b3AgZW52aXJvbm1lbnRzIG5hbWUsIGxvd2VyY2FzZSAoa2RlLCBnbm9tZSwgeGZjZSkKKyAgICAgICAgb3IgImdlbmVyaWMiCisKKyAgICAgICAgJycnCisKKyAgICAgICAgZGVza3RvcF9lbnZpcm9ubWVudCA9ICdnZW5lcmljJworCisgICAgICAgIGlmIG9zLmVudmlyb24uZ2V0KCdLREVfRlVMTF9TRVNTSU9OJykgPT0gJ3RydWUnOgorICAgICAgICAgICAgZGVza3RvcF9lbnZpcm9ubWVudCA9ICdrZGUnCisgICAgICAgIGVsaWYgb3MuZW52aXJvbi5nZXQoJ0dOT01FX0RFU0tUT1BfU0VTU0lPTl9JRCcpOgorICAgICAgICAgICAgZGVza3RvcF9lbnZpcm9ubWVudCA9ICdnbm9tZScKKyAgICAgICAgZWxzZToKKyAgICAgICAgICAgIHRyeToKKyAgICAgICAgICAgICAgICBpbmZvID0gY29tbWFuZHMuZ2V0b3V0cHV0KCd4cHJvcCAtcm9vdCBfRFRfU0FWRV9NT0RFJykKKyAgICAgICAgICAgICAgICBpZiAnID0gInhmY2U0IicgaW4gaW5mbzoKKyAgICAgICAgICAgICAgICAgICAgZGVza3RvcF9lbnZpcm9ubWVudCA9ICd4ZmNlJworICAgICAgICAgICAgZXhjZXB0IChPU0Vycm9yLCBSdW50aW1lRXJyb3IpOgorICAgICAgICAgICAgICAgIHBhc3MKKworICAgICAgICByZXR1cm4gZGVza3RvcF9lbnZpcm9ubWVudAorCisKKyAgICBkZWYgcmVnaXN0ZXJfWF9jb250cm9sbGVycygpOgorICAgICAgICBpZiBfaXNjb21tYW5kKCdrZm1jbGllbnQnKToKKyAgICAgICAgICAgIF9jb250cm9sbGVyc1sna2RlLW9wZW4nXSA9IEtmbUNsaWVudCgpCisKKyAgICAgICAgZm9yIGNvbW1hbmQgaW4gKCdnbm9tZS1vcGVuJywgJ2V4by1vcGVuJywgJ3hkZy1vcGVuJyk6CisgICAgICAgICAgICBpZiBfaXNjb21tYW5kKGNvbW1hbmQpOgorICAgICAgICAgICAgICAgIF9jb250cm9sbGVyc1tjb21tYW5kXSA9IENvbnRyb2xsZXIoY29tbWFuZCkKKworICAgIGRlZiBnZXQoKToKKyAgICAgICAgY29udHJvbGxlcnNfbWFwID0geworICAgICAgICAgICAgJ2dub21lJzogJ2dub21lLW9wZW4nLAorICAgICAgICAgICAgJ2tkZSc6ICdrZGUtb3BlbicsCisgICAgICAgICAgICAneGZjZSc6ICdleG8tb3BlbicsCisgICAgICAgIH0KKworICAgICAgICBkZXNrdG9wX2Vudmlyb25tZW50ID0gZGV0ZWN0X2Rlc2t0b3BfZW52aXJvbm1lbnQoKQorCisgICAgICAgIHRyeToKKyAgICAgICAgICAgIGNvbnRyb2xsZXJfbmFtZSA9IGNvbnRyb2xsZXJzX21hcFtkZXNrdG9wX2Vudmlyb25tZW50XQorICAgICAgICAgICAgcmV0dXJuIF9jb250cm9sbGVyc1tjb250cm9sbGVyX25hbWVdLm9wZW4KKworICAgICAgICBleGNlcHQgS2V5RXJyb3I6CisgICAgICAgICAgICBpZiBfY29udHJvbGxlcnMuaGFzX2tleSgneGRnLW9wZW4nKToKKyAgICAgICAgICAgICAgICByZXR1cm4gX2NvbnRyb2xsZXJzWyd4ZGctb3BlbiddLm9wZW4KKyAgICAgICAgICAgIGVsc2U6CisgICAgICAgICAgICAgICAgcmV0dXJuIHdlYmJyb3dzZXIub3BlbgorCisKKyAgICBpZiBvcy5lbnZpcm9uLmdldCgiRElTUExBWSIpOgorICAgICAgICByZWdpc3Rlcl9YX2NvbnRyb2xsZXJzKCkKKyAgICBfb3BlbiA9IGdldCgpCisKKworZGVmIG9wZW4oZmlsZW5hbWUpOgorICAgICcnJ09wZW4gYSBmaWxlIG9yIGFuIFVSTCBpbiB0aGUgcmVnaXN0ZXJlZCBkZWZhdWx0IGFwcGxpY2F0aW9uLicnJworCisgICAgcmV0dXJuIF9vcGVuKGZpbGVuYW1lKQo=