IyEvYmluL3NoCiMgVGNsIGlnbm9yZXMgdGhlIG5leHQgbGluZSAtKi0gdGNsIC0qLSBcCmV4ZWMgd2lzaCAiJDAiIC0tICIkQCIKCiMgQ29weXJpZ2h0IChDKSAyMDA1LTIwMDYgUGF1bCBNYWNrZXJyYXMuICBBbGwgcmlnaHRzIHJlc2VydmVkLgojIFRoaXMgcHJvZ3JhbSBpcyBmcmVlIHNvZnR3YXJlOyBpdCBtYXkgYmUgdXNlZCwgY29waWVkLCBtb2RpZmllZAojIGFuZCBkaXN0cmlidXRlZCB1bmRlciB0aGUgdGVybXMgb2YgdGhlIEdOVSBHZW5lcmFsIFB1YmxpYyBMaWNlbmNlLAojIGVpdGhlciB2ZXJzaW9uIDIsIG9yIChhdCB5b3VyIG9wdGlvbikgYW55IGxhdGVyIHZlcnNpb24uCgpwcm9jIGdpdGRpciB7fSB7CiAgICBnbG9iYWwgZW52CiAgICBpZiB7W2luZm8gZXhpc3RzIGVudihHSVRfRElSKV19IHsKCXJldHVybiAkZW52KEdJVF9ESVIpCiAgICB9IGVsc2UgewoJcmV0dXJuIFtleGVjIGdpdCByZXYtcGFyc2UgLS1naXQtZGlyXQogICAgfQp9CgojIEEgc2ltcGxlIHNjaGVkdWxlciBmb3IgY29tcHV0ZS1pbnRlbnNpdmUgc3R1ZmYuCiMgVGhlIGFpbSBpcyB0byBtYWtlIHN1cmUgdGhhdCBldmVudCBoYW5kbGVycyBmb3IgR1VJIGFjdGlvbnMgY2FuCiMgcnVuIGF0IGxlYXN0IGV2ZXJ5IDUwLTEwMCBtcy4gIFVuZm9ydHVuYXRlbHkgZmlsZWV2ZW50IGhhbmRsZXJzIGFyZQojIHJ1biBiZWZvcmUgWCBldmVudCBoYW5kbGVycywgc28gcmVhZGluZyBmcm9tIGEgZmFzdCBzb3VyY2UgY2FuCiMgbWFrZSB0aGUgR1VJIGNvbXBsZXRlbHkgdW5yZXNwb25zaXZlLgpwcm9jIHJ1biBhcmdzIHsKICAgIGdsb2JhbCBpc29ucnVucSBydW5xCgogICAgc2V0IHNjcmlwdCAkYXJncwogICAgaWYge1tpbmZvIGV4aXN0cyBpc29ucnVucSgkc2NyaXB0KV19IHJldHVybgogICAgaWYgeyRydW5xIGVxIHt9fSB7CglhZnRlciBpZGxlIGRvcnVucQogICAgfQogICAgbGFwcGVuZCBydW5xIFtsaXN0IHt9ICRzY3JpcHRdCiAgICBzZXQgaXNvbnJ1bnEoJHNjcmlwdCkgMQp9Cgpwcm9jIGZpbGVydW4ge2ZkIHNjcmlwdH0gewogICAgZmlsZWV2ZW50ICRmZCByZWFkYWJsZSBbbGlzdCBmaWxlcmVhZGFibGUgJGZkICRzY3JpcHRdCn0KCnByb2MgZmlsZXJlYWRhYmxlIHtmZCBzY3JpcHR9IHsKICAgIGdsb2JhbCBydW5xCgogICAgZmlsZWV2ZW50ICRmZCByZWFkYWJsZSB7fQogICAgaWYgeyRydW5xIGVxIHt9fSB7CglhZnRlciBpZGxlIGRvcnVucQogICAgfQogICAgbGFwcGVuZCBydW5xIFtsaXN0ICRmZCAkc2NyaXB0XQp9Cgpwcm9jIGRvcnVucSB7fSB7CiAgICBnbG9iYWwgaXNvbnJ1bnEgcnVucQoKICAgIHNldCB0c3RhcnQgW2Nsb2NrIGNsaWNrcyAtbWlsbGlzZWNvbmRzXQogICAgc2V0IHQwICR0c3RhcnQKICAgIHdoaWxlIHskcnVucSBuZSB7fX0gewoJc2V0IGZkIFtsaW5kZXggJHJ1bnEgMCAwXQoJc2V0IHNjcmlwdCBbbGluZGV4ICRydW5xIDAgMV0KCXNldCByZXBlYXQgW2V2YWwgJHNjcmlwdF0KCXNldCB0MSBbY2xvY2sgY2xpY2tzIC1taWxsaXNlY29uZHNdCglzZXQgdCBbZXhwciB7JHQxIC0gJHQwfV0KCXNldCBydW5xIFtscmFuZ2UgJHJ1bnEgMSBlbmRdCglpZiB7JHJlcGVhdCBuZSB7fSAmJiAkcmVwZWF0fSB7CgkgICAgaWYgeyRmZCBlcSB7fSB8fCAkcmVwZWF0ID09IDJ9IHsKCQkjIHNjcmlwdCByZXR1cm5zIDEgaWYgaXQgd2FudHMgdG8gYmUgcmVhZGRlZAoJCSMgZmlsZSByZWFkZXJzIHJldHVybiAyIGlmIHRoZXkgY291bGQgZG8gbW9yZSBzdHJhaWdodCBhd2F5CgkJbGFwcGVuZCBydW5xIFtsaXN0ICRmZCAkc2NyaXB0XQoJICAgIH0gZWxzZSB7CgkJZmlsZWV2ZW50ICRmZCByZWFkYWJsZSBbbGlzdCBmaWxlcmVhZGFibGUgJGZkICRzY3JpcHRdCgkgICAgfQoJfSBlbHNlaWYgeyRmZCBlcSB7fX0gewoJICAgIHVuc2V0IGlzb25ydW5xKCRzY3JpcHQpCgl9CglzZXQgdDAgJHQxCglpZiB7JHQxIC0gJHRzdGFydCA+PSA4MH0gYnJlYWsKICAgIH0KICAgIGlmIHskcnVucSBuZSB7fX0gewoJYWZ0ZXIgaWRsZSBkb3J1bnEKICAgIH0KfQoKIyBTdGFydCBvZmYgYSBnaXQgcmV2LWxpc3QgcHJvY2VzcyBhbmQgYXJyYW5nZSB0byByZWFkIGl0cyBvdXRwdXQKcHJvYyBzdGFydF9yZXZfbGlzdCB7dmlld30gewogICAgZ2xvYmFsIHN0YXJ0bXNlY3MKICAgIGdsb2JhbCBjb21tZmQgbGVmdG92ZXIgdGNsZW5jb2RpbmcgZGF0ZW1vZGUKICAgIGdsb2JhbCB2aWV3YXJncyB2aWV3ZmlsZXMgY29tbWl0aWR4CiAgICBnbG9iYWwgbG9va2luZ2ZvcmhlYWQgc2hvd2xvY2FsY2hhbmdlcwoKICAgIHNldCBzdGFydG1zZWNzIFtjbG9jayBjbGlja3MgLW1pbGxpc2Vjb25kc10KICAgIHNldCBjb21taXRpZHgoJHZpZXcpIDAKICAgIHNldCBvcmRlciAiLS10b3BvLW9yZGVyIgogICAgaWYgeyRkYXRlbW9kZX0gewoJc2V0IG9yZGVyICItLWRhdGUtb3JkZXIiCiAgICB9CiAgICBpZiB7W2NhdGNoIHsKCXNldCBmZCBbb3BlbiBbY29uY2F0IHwgZ2l0IGxvZyAteiAtLXByZXR0eT1yYXcgJG9yZGVyIC0tcGFyZW50cyBcCgkJCSAtLWJvdW5kYXJ5ICR2aWV3YXJncygkdmlldykgIi0tIiAkdmlld2ZpbGVzKCR2aWV3KV0gcl0KICAgIH0gZXJyXX0gewoJZXJyb3JfcG9wdXAgIkVycm9yIGV4ZWN1dGluZyBnaXQgcmV2LWxpc3Q6ICRlcnIiCglleGl0IDEKICAgIH0KICAgIHNldCBjb21tZmQoJHZpZXcpICRmZAogICAgc2V0IGxlZnRvdmVyKCR2aWV3KSB7fQogICAgc2V0IGxvb2tpbmdmb3JoZWFkICRzaG93bG9jYWxjaGFuZ2VzCiAgICBmY29uZmlndXJlICRmZCAtYmxvY2tpbmcgMCAtdHJhbnNsYXRpb24gbGYgLWVvZmNoYXIge30KICAgIGlmIHskdGNsZW5jb2RpbmcgIT0ge319IHsKCWZjb25maWd1cmUgJGZkIC1lbmNvZGluZyAkdGNsZW5jb2RpbmcKICAgIH0KICAgIGZpbGVydW4gJGZkIFtsaXN0IGdldGNvbW1pdGxpbmVzICRmZCAkdmlld10KICAgIG5vd2J1c3kgJHZpZXcKfQoKcHJvYyBzdG9wX3Jldl9saXN0IHt9IHsKICAgIGdsb2JhbCBjb21tZmQgY3VydmlldwoKICAgIGlmIHshW2luZm8gZXhpc3RzIGNvbW1mZCgkY3VydmlldyldfSByZXR1cm4KICAgIHNldCBmZCAkY29tbWZkKCRjdXJ2aWV3KQogICAgY2F0Y2ggewoJc2V0IHBpZCBbcGlkICRmZF0KCWV4ZWMga2lsbCAkcGlkCiAgICB9CiAgICBjYXRjaCB7Y2xvc2UgJGZkfQogICAgdW5zZXQgY29tbWZkKCRjdXJ2aWV3KQp9Cgpwcm9jIGdldGNvbW1pdHMge30gewogICAgZ2xvYmFsIHBoYXNlIGNhbnYgbWFpbmZvbnQgY3VydmlldwoKICAgIHNldCBwaGFzZSBnZXRjb21taXRzCiAgICBpbml0bGF5b3V0CiAgICBzdGFydF9yZXZfbGlzdCAkY3VydmlldwogICAgc2hvd19zdGF0dXMgIlJlYWRpbmcgY29tbWl0cy4uLiIKfQoKcHJvYyBnZXRjb21taXRsaW5lcyB7ZmQgdmlld30gIHsKICAgIGdsb2JhbCBjb21taXRsaXN0ZWQKICAgIGdsb2JhbCBsZWZ0b3ZlciBjb21tZmQKICAgIGdsb2JhbCBkaXNwbGF5b3JkZXIgY29tbWl0aWR4IGNvbW1pdHJvdyBjb21taXRkYXRhCiAgICBnbG9iYWwgcGFyZW50bGlzdCBjaGlsZHJlbiBjdXJ2aWV3IGhsdmlldwogICAgZ2xvYmFsIHZwYXJlbnRsaXN0IHZkaXNwb3JkZXIgdmNtaXRsaXN0ZWQKCiAgICBzZXQgc3R1ZmYgW3JlYWQgJGZkIDUwMDAwMF0KICAgICMgZ2l0IGxvZyBkb2Vzbid0IHRlcm1pbmF0ZSB0aGUgbGFzdCBjb21taXQgd2l0aCBhIG51bGwuLi4KICAgIGlmIHskc3R1ZmYgPT0ge30gJiYgJGxlZnRvdmVyKCR2aWV3KSBuZSB7fSAmJiBbZW9mICRmZF19IHsKCXNldCBzdHVmZiAiXDAiCiAgICB9CiAgICBpZiB7JHN0dWZmID09IHt9fSB7CglpZiB7IVtlb2YgJGZkXX0gewoJICAgIHJldHVybiAxCgl9CglnbG9iYWwgdmlld25hbWUKCXVuc2V0IGNvbW1mZCgkdmlldykKCW5vdGJ1c3kgJHZpZXcKCSMgc2V0IGl0IGJsb2NraW5nIHNvIHdlIHdhaXQgZm9yIHRoZSBwcm9jZXNzIHRvIHRlcm1pbmF0ZQoJZmNvbmZpZ3VyZSAkZmQgLWJsb2NraW5nIDEKCWlmIHtbY2F0Y2gge2Nsb3NlICRmZH0gZXJyXX0gewoJICAgIHNldCBmdiB7fQoJICAgIGlmIHskdmlldyAhPSAkY3Vydmlld30gewoJCXNldCBmdiAiIGZvciB0aGUgXCIkdmlld25hbWUoJHZpZXcpXCIgdmlldyIKCSAgICB9CgkgICAgaWYge1tzdHJpbmcgcmFuZ2UgJGVyciAwIDRdID09ICJ1c2FnZSJ9IHsKCQlzZXQgZXJyICJHaXRrOiBlcnJvciByZWFkaW5nIGNvbW1pdHMkZnY6XAoJCQliYWQgYXJndW1lbnRzIHRvIGdpdCByZXYtbGlzdC4iCgkJaWYgeyR2aWV3bmFtZSgkdmlldykgZXEgIkNvbW1hbmQgbGluZSJ9IHsKCQkgICAgYXBwZW5kIGVyciBcCgkJCSIgIChOb3RlOiBhcmd1bWVudHMgdG8gZ2l0ayBhcmUgcGFzc2VkIHRvIGdpdCByZXYtbGlzdFwKCQkJIHRvIGFsbG93IHNlbGVjdGlvbiBvZiBjb21taXRzIHRvIGJlIGRpc3BsYXllZC4pIgoJCX0KCSAgICB9IGVsc2UgewoJCXNldCBlcnIgIkVycm9yIHJlYWRpbmcgY29tbWl0cyRmdjogJGVyciIKCSAgICB9CgkgICAgZXJyb3JfcG9wdXAgJGVycgoJfQoJaWYgeyR2aWV3ID09ICRjdXJ2aWV3fSB7CgkgICAgcnVuIGNoZXdjb21taXRzICR2aWV3Cgl9CglyZXR1cm4gMAogICAgfQogICAgc2V0IHN0YXJ0IDAKICAgIHNldCBnb3Rzb21lIDAKICAgIHdoaWxlIDEgewoJc2V0IGkgW3N0cmluZyBmaXJzdCAiXDAiICRzdHVmZiAkc3RhcnRdCglpZiB7JGkgPCAwfSB7CgkgICAgYXBwZW5kIGxlZnRvdmVyKCR2aWV3KSBbc3RyaW5nIHJhbmdlICRzdHVmZiAkc3RhcnQgZW5kXQoJICAgIGJyZWFrCgl9CglpZiB7JHN0YXJ0ID09IDB9IHsKCSAgICBzZXQgY21pdCAkbGVmdG92ZXIoJHZpZXcpCgkgICAgYXBwZW5kIGNtaXQgW3N0cmluZyByYW5nZSAkc3R1ZmYgMCBbZXhwciB7JGkgLSAxfV1dCgkgICAgc2V0IGxlZnRvdmVyKCR2aWV3KSB7fQoJfSBlbHNlIHsKCSAgICBzZXQgY21pdCBbc3RyaW5nIHJhbmdlICRzdHVmZiAkc3RhcnQgW2V4cHIgeyRpIC0gMX1dXQoJfQoJc2V0IHN0YXJ0IFtleHByIHskaSArIDF9XQoJc2V0IGogW3N0cmluZyBmaXJzdCAiXG4iICRjbWl0XQoJc2V0IG9rIDAKCXNldCBsaXN0ZWQgMQoJaWYgeyRqID49IDAgJiYgW3N0cmluZyBtYXRjaCAiY29tbWl0ICoiICRjbWl0XX0gewoJICAgIHNldCBpZHMgW3N0cmluZyByYW5nZSAkY21pdCA3IFtleHByIHskaiAtIDF9XV0KCSAgICBpZiB7W3N0cmluZyBtYXRjaCB7Wy08Pl0qfSAkaWRzXX0gewoJCXN3aXRjaCAtLSBbc3RyaW5nIGluZGV4ICRpZHMgMF0gewoJCSAgICAiLSIge3NldCBsaXN0ZWQgMH0KCQkgICAgIjwiIHtzZXQgbGlzdGVkIDJ9CgkJICAgICI+IiB7c2V0IGxpc3RlZCAzfQoJCX0KCQlzZXQgaWRzIFtzdHJpbmcgcmFuZ2UgJGlkcyAxIGVuZF0KCSAgICB9CgkgICAgc2V0IG9rIDEKCSAgICBmb3JlYWNoIGlkICRpZHMgewoJCWlmIHtbc3RyaW5nIGxlbmd0aCAkaWRdICE9IDQwfSB7CgkJICAgIHNldCBvayAwCgkJICAgIGJyZWFrCgkJfQoJICAgIH0KCX0KCWlmIHshJG9rfSB7CgkgICAgc2V0IHNob3J0Y21pdCAkY21pdAoJICAgIGlmIHtbc3RyaW5nIGxlbmd0aCAkc2hvcnRjbWl0XSA+IDgwfSB7CgkJc2V0IHNob3J0Y21pdCAiW3N0cmluZyByYW5nZSAkc2hvcnRjbWl0IDAgODBdLi4uIgoJICAgIH0KCSAgICBlcnJvcl9wb3B1cCAiQ2FuJ3QgcGFyc2UgZ2l0IGxvZyBvdXRwdXQ6IHskc2hvcnRjbWl0fSIKCSAgICBleGl0IDEKCX0KCXNldCBpZCBbbGluZGV4ICRpZHMgMF0KCWlmIHskbGlzdGVkfSB7CgkgICAgc2V0IG9sZHMgW2xyYW5nZSAkaWRzIDEgZW5kXQoJICAgIHNldCBpIDAKCSAgICBmb3JlYWNoIHAgJG9sZHMgewoJCWlmIHskaSA9PSAwIHx8IFtsc2VhcmNoIC1leGFjdCAkb2xkcyAkcF0gPj0gJGl9IHsKCQkgICAgbGFwcGVuZCBjaGlsZHJlbigkdmlldywkcCkgJGlkCgkJfQoJCWluY3IgaQoJICAgIH0KCX0gZWxzZSB7CgkgICAgc2V0IG9sZHMge30KCX0KCWlmIHshW2luZm8gZXhpc3RzIGNoaWxkcmVuKCR2aWV3LCRpZCldfSB7CgkgICAgc2V0IGNoaWxkcmVuKCR2aWV3LCRpZCkge30KCX0KCXNldCBjb21taXRkYXRhKCRpZCkgW3N0cmluZyByYW5nZSAkY21pdCBbZXhwciB7JGogKyAxfV0gZW5kXQoJc2V0IGNvbW1pdHJvdygkdmlldywkaWQpICRjb21taXRpZHgoJHZpZXcpCglpbmNyIGNvbW1pdGlkeCgkdmlldykKCWlmIHskdmlldyA9PSAkY3Vydmlld30gewoJICAgIGxhcHBlbmQgcGFyZW50bGlzdCAkb2xkcwoJICAgIGxhcHBlbmQgZGlzcGxheW9yZGVyICRpZAoJICAgIGxhcHBlbmQgY29tbWl0bGlzdGVkICRsaXN0ZWQKCX0gZWxzZSB7CgkgICAgbGFwcGVuZCB2cGFyZW50bGlzdCgkdmlldykgJG9sZHMKCSAgICBsYXBwZW5kIHZkaXNwb3JkZXIoJHZpZXcpICRpZAoJICAgIGxhcHBlbmQgdmNtaXRsaXN0ZWQoJHZpZXcpICRsaXN0ZWQKCX0KCXNldCBnb3Rzb21lIDEKICAgIH0KICAgIGlmIHskZ290c29tZX0gewoJcnVuIGNoZXdjb21taXRzICR2aWV3CiAgICB9CiAgICByZXR1cm4gMgp9Cgpwcm9jIGNoZXdjb21taXRzIHt2aWV3fSB7CiAgICBnbG9iYWwgY3VydmlldyBobHZpZXcgY29tbWZkCiAgICBnbG9iYWwgc2VsZWN0ZWRsaW5lIHBlbmRpbmdfc2VsZWN0CgogICAgc2V0IG1vcmUgMAogICAgaWYgeyR2aWV3ID09ICRjdXJ2aWV3fSB7CglzZXQgYWxscmVhZCBbZXhwciB7IVtpbmZvIGV4aXN0cyBjb21tZmQoJHZpZXcpXX1dCglzZXQgdGxpbWl0IFtleHByIHtbY2xvY2sgY2xpY2tzIC1taWxsaXNlY29uZHNdICsgNTB9XQoJc2V0IG1vcmUgW2xheW91dG1vcmUgJHRsaW1pdCAkYWxscmVhZF0KCWlmIHskYWxscmVhZCAmJiAhJG1vcmV9IHsKCSAgICBnbG9iYWwgZGlzcGxheW9yZGVyIGNvbW1pdGlkeCBwaGFzZQoJICAgIGdsb2JhbCBudW1jb21taXRzIHN0YXJ0bXNlY3MKCgkgICAgaWYge1tpbmZvIGV4aXN0cyBwZW5kaW5nX3NlbGVjdF19IHsKCQlzZXQgcm93IFtmaXJzdF9yZWFsX3Jvd10KCQlzZWxlY3RsaW5lICRyb3cgMQoJICAgIH0KCSAgICBpZiB7JGNvbW1pdGlkeCgkY3VydmlldykgPiAwfSB7CgkJI3NldCBtcyBbZXhwciB7W2Nsb2NrIGNsaWNrcyAtbWlsbGlzZWNvbmRzXSAtICRzdGFydG1zZWNzfV0KCQkjcHV0cyAib3ZlcmFsbCAkbXMgbXMgZm9yICRudW1jb21taXRzIGNvbW1pdHMiCgkgICAgfSBlbHNlIHsKCQlzaG93X3N0YXR1cyAiTm8gY29tbWl0cyBzZWxlY3RlZCIKCSAgICB9CgkgICAgbm90YnVzeSBsYXlvdXQKCSAgICBzZXQgcGhhc2Uge30KCX0KICAgIH0KICAgIGlmIHtbaW5mbyBleGlzdHMgaGx2aWV3XSAmJiAkdmlldyA9PSAkaGx2aWV3fSB7Cgl2aGlnaGxpZ2h0bW9yZQogICAgfQogICAgcmV0dXJuICRtb3JlCn0KCnByb2MgcmVhZGNvbW1pdCB7aWR9IHsKICAgIGlmIHtbY2F0Y2gge3NldCBjb250ZW50cyBbZXhlYyBnaXQgY2F0LWZpbGUgY29tbWl0ICRpZF19XX0gcmV0dXJuCiAgICBwYXJzZWNvbW1pdCAkaWQgJGNvbnRlbnRzIDAKfQoKcHJvYyB1cGRhdGVjb21taXRzIHt9IHsKICAgIGdsb2JhbCB2aWV3ZGF0YSBjdXJ2aWV3IHBoYXNlIGRpc3BsYXlvcmRlcgogICAgZ2xvYmFsIGNoaWxkcmVuIGNvbW1pdHJvdyBzZWxlY3RlZGxpbmUgdGhpY2tlcmxpbmUKCiAgICBpZiB7JHBoYXNlIG5lIHt9fSB7CglzdG9wX3Jldl9saXN0CglzZXQgcGhhc2Uge30KICAgIH0KICAgIHNldCBuICRjdXJ2aWV3CiAgICBmb3JlYWNoIGlkICRkaXNwbGF5b3JkZXIgewoJY2F0Y2gge3Vuc2V0IGNoaWxkcmVuKCRuLCRpZCl9CgljYXRjaCB7dW5zZXQgY29tbWl0cm93KCRuLCRpZCl9CiAgICB9CiAgICBzZXQgY3VydmlldyAtMQogICAgY2F0Y2gge3Vuc2V0IHNlbGVjdGVkbGluZX0KICAgIGNhdGNoIHt1bnNldCB0aGlja2VybGluZX0KICAgIGNhdGNoIHt1bnNldCB2aWV3ZGF0YSgkbil9CiAgICByZWFkcmVmcwogICAgY2hhbmdlZHJlZnMKICAgIHJlZ2V0YWxsY29tbWl0cwogICAgc2hvd3ZpZXcgJG4KfQoKcHJvYyBwYXJzZWNvbW1pdCB7aWQgY29udGVudHMgbGlzdGVkfSB7CiAgICBnbG9iYWwgY29tbWl0aW5mbyBjZGF0ZQoKICAgIHNldCBpbmhkciAxCiAgICBzZXQgY29tbWVudCB7fQogICAgc2V0IGhlYWRsaW5lIHt9CiAgICBzZXQgYXVuYW1lIHt9CiAgICBzZXQgYXVkYXRlIHt9CiAgICBzZXQgY29tbmFtZSB7fQogICAgc2V0IGNvbWRhdGUge30KICAgIHNldCBoZHJlbmQgW3N0cmluZyBmaXJzdCAiXG5cbiIgJGNvbnRlbnRzXQogICAgaWYgeyRoZHJlbmQgPCAwfSB7CgkjIHNob3VsZCBuZXZlciBoYXBwZW4uLi4KCXNldCBoZHJlbmQgW3N0cmluZyBsZW5ndGggJGNvbnRlbnRzXQogICAgfQogICAgc2V0IGhlYWRlciBbc3RyaW5nIHJhbmdlICRjb250ZW50cyAwIFtleHByIHskaGRyZW5kIC0gMX1dXQogICAgc2V0IGNvbW1lbnQgW3N0cmluZyByYW5nZSAkY29udGVudHMgW2V4cHIgeyRoZHJlbmQgKyAyfV0gZW5kXQogICAgZm9yZWFjaCBsaW5lIFtzcGxpdCAkaGVhZGVyICJcbiJdIHsKCXNldCB0YWcgW2xpbmRleCAkbGluZSAwXQoJaWYgeyR0YWcgPT0gImF1dGhvciJ9IHsKCSAgICBzZXQgYXVkYXRlIFtsaW5kZXggJGxpbmUgZW5kLTFdCgkgICAgc2V0IGF1bmFtZSBbbHJhbmdlICRsaW5lIDEgZW5kLTJdCgl9IGVsc2VpZiB7JHRhZyA9PSAiY29tbWl0dGVyIn0gewoJICAgIHNldCBjb21kYXRlIFtsaW5kZXggJGxpbmUgZW5kLTFdCgkgICAgc2V0IGNvbW5hbWUgW2xyYW5nZSAkbGluZSAxIGVuZC0yXQoJfQogICAgfQogICAgc2V0IGhlYWRsaW5lIHt9CiAgICAjIHRha2UgdGhlIGZpcnN0IG5vbi1ibGFuayBsaW5lIG9mIHRoZSBjb21tZW50IGFzIHRoZSBoZWFkbGluZQogICAgc2V0IGhlYWRsaW5lIFtzdHJpbmcgdHJpbWxlZnQgJGNvbW1lbnRdCiAgICBzZXQgaSBbc3RyaW5nIGZpcnN0ICJcbiIgJGhlYWRsaW5lXQogICAgaWYgeyRpID49IDB9IHsKCXNldCBoZWFkbGluZSBbc3RyaW5nIHJhbmdlICRoZWFkbGluZSAwICRpXQogICAgfQogICAgc2V0IGhlYWRsaW5lIFtzdHJpbmcgdHJpbXJpZ2h0ICRoZWFkbGluZV0KICAgIHNldCBpIFtzdHJpbmcgZmlyc3QgIlxyIiAkaGVhZGxpbmVdCiAgICBpZiB7JGkgPj0gMH0gewoJc2V0IGhlYWRsaW5lIFtzdHJpbmcgdHJpbXJpZ2h0IFtzdHJpbmcgcmFuZ2UgJGhlYWRsaW5lIDAgJGldXQogICAgfQogICAgaWYgeyEkbGlzdGVkfSB7CgkjIGdpdCByZXYtbGlzdCBpbmRlbnRzIHRoZSBjb21tZW50IGJ5IDQgc3BhY2VzOwoJIyBpZiB3ZSBnb3QgdGhpcyB2aWEgZ2l0IGNhdC1maWxlLCBhZGQgdGhlIGluZGVudGF0aW9uCglzZXQgbmV3Y29tbWVudCB7fQoJZm9yZWFjaCBsaW5lIFtzcGxpdCAkY29tbWVudCAiXG4iXSB7CgkgICAgYXBwZW5kIG5ld2NvbW1lbnQgIiAgICAiCgkgICAgYXBwZW5kIG5ld2NvbW1lbnQgJGxpbmUKCSAgICBhcHBlbmQgbmV3Y29tbWVudCAiXG4iCgl9CglzZXQgY29tbWVudCAkbmV3Y29tbWVudAogICAgfQogICAgaWYgeyRjb21kYXRlICE9IHt9fSB7CglzZXQgY2RhdGUoJGlkKSAkY29tZGF0ZQogICAgfQogICAgc2V0IGNvbW1pdGluZm8oJGlkKSBbbGlzdCAkaGVhZGxpbmUgJGF1bmFtZSAkYXVkYXRlIFwKCQkJICAgICAkY29tbmFtZSAkY29tZGF0ZSAkY29tbWVudF0KfQoKcHJvYyBnZXRjb21taXQge2lkfSB7CiAgICBnbG9iYWwgY29tbWl0ZGF0YSBjb21taXRpbmZvCgogICAgaWYge1tpbmZvIGV4aXN0cyBjb21taXRkYXRhKCRpZCldfSB7CglwYXJzZWNvbW1pdCAkaWQgJGNvbW1pdGRhdGEoJGlkKSAxCiAgICB9IGVsc2UgewoJcmVhZGNvbW1pdCAkaWQKCWlmIHshW2luZm8gZXhpc3RzIGNvbW1pdGluZm8oJGlkKV19IHsKCSAgICBzZXQgY29tbWl0aW5mbygkaWQpIHsiTm8gY29tbWl0IGluZm9ybWF0aW9uIGF2YWlsYWJsZSJ9Cgl9CiAgICB9CiAgICByZXR1cm4gMQp9Cgpwcm9jIHJlYWRyZWZzIHt9IHsKICAgIGdsb2JhbCB0YWdpZHMgaWR0YWdzIGhlYWRpZHMgaWRoZWFkcyB0YWdvYmppZAogICAgZ2xvYmFsIG90aGVycmVmaWRzIGlkb3RoZXJyZWZzIG1haW5oZWFkIG1haW5oZWFkaWQKCiAgICBmb3JlYWNoIHYge3RhZ2lkcyBpZHRhZ3MgaGVhZGlkcyBpZGhlYWRzIG90aGVycmVmaWRzIGlkb3RoZXJyZWZzfSB7CgljYXRjaCB7dW5zZXQgJHZ9CiAgICB9CiAgICBzZXQgcmVmZCBbb3BlbiBbbGlzdCB8IGdpdCBzaG93LXJlZiAtZF0gcl0KICAgIHdoaWxlIHtbZ2V0cyAkcmVmZCBsaW5lXSA+PSAwfSB7CglpZiB7W3N0cmluZyBpbmRleCAkbGluZSA0MF0gbmUgIiAifSBjb250aW51ZQoJc2V0IGlkIFtzdHJpbmcgcmFuZ2UgJGxpbmUgMCAzOV0KCXNldCByZWYgW3N0cmluZyByYW5nZSAkbGluZSA0MSBlbmRdCglpZiB7IVtzdHJpbmcgbWF0Y2ggInJlZnMvKiIgJHJlZl19IGNvbnRpbnVlCglzZXQgbmFtZSBbc3RyaW5nIHJhbmdlICRyZWYgNSBlbmRdCglpZiB7W3N0cmluZyBtYXRjaCAicmVtb3Rlcy8qIiAkbmFtZV19IHsKCSAgICBpZiB7IVtzdHJpbmcgbWF0Y2ggIiovSEVBRCIgJG5hbWVdfSB7CgkJc2V0IGhlYWRpZHMoJG5hbWUpICRpZAoJCWxhcHBlbmQgaWRoZWFkcygkaWQpICRuYW1lCgkgICAgfQoJfSBlbHNlaWYge1tzdHJpbmcgbWF0Y2ggImhlYWRzLyoiICRuYW1lXX0gewoJICAgIHNldCBuYW1lIFtzdHJpbmcgcmFuZ2UgJG5hbWUgNiBlbmRdCgkgICAgc2V0IGhlYWRpZHMoJG5hbWUpICRpZAoJICAgIGxhcHBlbmQgaWRoZWFkcygkaWQpICRuYW1lCgl9IGVsc2VpZiB7W3N0cmluZyBtYXRjaCAidGFncy8qIiAkbmFtZV19IHsKCSAgICAjIHRoaXMgbGV0cyByZWZzL3RhZ3MvZm9vXnt9IG92ZXJ3cml0ZSByZWZzL3RhZ3MvZm9vLAoJICAgICMgd2hpY2ggaXMgd2hhdCB3ZSB3YW50IHNpbmNlIHRoZSBmb3JtZXIgaXMgdGhlIGNvbW1pdCBJRAoJICAgIHNldCBuYW1lIFtzdHJpbmcgcmFuZ2UgJG5hbWUgNSBlbmRdCgkgICAgaWYge1tzdHJpbmcgbWF0Y2ggIipee30iICRuYW1lXX0gewoJCXNldCBuYW1lIFtzdHJpbmcgcmFuZ2UgJG5hbWUgMCBlbmQtM10KCSAgICB9IGVsc2UgewoJCXNldCB0YWdvYmppZCgkbmFtZSkgJGlkCgkgICAgfQoJICAgIHNldCB0YWdpZHMoJG5hbWUpICRpZAoJICAgIGxhcHBlbmQgaWR0YWdzKCRpZCkgJG5hbWUKCX0gZWxzZSB7CgkgICAgc2V0IG90aGVycmVmaWRzKCRuYW1lKSAkaWQKCSAgICBsYXBwZW5kIGlkb3RoZXJyZWZzKCRpZCkgJG5hbWUKCX0KICAgIH0KICAgIGNsb3NlICRyZWZkCiAgICBzZXQgbWFpbmhlYWQge30KICAgIHNldCBtYWluaGVhZGlkIHt9CiAgICBjYXRjaCB7CglzZXQgdGhlaGVhZCBbZXhlYyBnaXQgc3ltYm9saWMtcmVmIEhFQURdCglpZiB7W3N0cmluZyBtYXRjaCAicmVmcy9oZWFkcy8qIiAkdGhlaGVhZF19IHsKCSAgICBzZXQgbWFpbmhlYWQgW3N0cmluZyByYW5nZSAkdGhlaGVhZCAxMSBlbmRdCgkgICAgaWYge1tpbmZvIGV4aXN0cyBoZWFkaWRzKCRtYWluaGVhZCldfSB7CgkJc2V0IG1haW5oZWFkaWQgJGhlYWRpZHMoJG1haW5oZWFkKQoJICAgIH0KCX0KICAgIH0KfQoKIyBza2lwIG92ZXIgZmFrZSBjb21taXRzCnByb2MgZmlyc3RfcmVhbF9yb3cge30gewogICAgZ2xvYmFsIG51bGxpZCBudWxsaWQyIGRpc3BsYXlvcmRlciBudW1jb21taXRzCgogICAgZm9yIHtzZXQgcm93IDB9IHskcm93IDwgJG51bWNvbW1pdHN9IHtpbmNyIHJvd30gewoJc2V0IGlkIFtsaW5kZXggJGRpc3BsYXlvcmRlciAkcm93XQoJaWYgeyRpZCBuZSAkbnVsbGlkICYmICRpZCBuZSAkbnVsbGlkMn0gewoJICAgIGJyZWFrCgl9CiAgICB9CiAgICByZXR1cm4gJHJvdwp9CgojIHVwZGF0ZSB0aGluZ3MgZm9yIGEgaGVhZCBtb3ZlZCB0byBhIGNoaWxkIG9mIGl0cyBwcmV2aW91cyBsb2NhdGlvbgpwcm9jIG1vdmVoZWFkIHtpZCBuYW1lfSB7CiAgICBnbG9iYWwgaGVhZGlkcyBpZGhlYWRzCgogICAgcmVtb3ZlaGVhZCAkaGVhZGlkcygkbmFtZSkgJG5hbWUKICAgIHNldCBoZWFkaWRzKCRuYW1lKSAkaWQKICAgIGxhcHBlbmQgaWRoZWFkcygkaWQpICRuYW1lCn0KCiMgdXBkYXRlIHRoaW5ncyB3aGVuIGEgaGVhZCBoYXMgYmVlbiByZW1vdmVkCnByb2MgcmVtb3ZlaGVhZCB7aWQgbmFtZX0gewogICAgZ2xvYmFsIGhlYWRpZHMgaWRoZWFkcwoKICAgIGlmIHskaWRoZWFkcygkaWQpIGVxICRuYW1lfSB7Cgl1bnNldCBpZGhlYWRzKCRpZCkKICAgIH0gZWxzZSB7CglzZXQgaSBbbHNlYXJjaCAtZXhhY3QgJGlkaGVhZHMoJGlkKSAkbmFtZV0KCWlmIHskaSA+PSAwfSB7CgkgICAgc2V0IGlkaGVhZHMoJGlkKSBbbHJlcGxhY2UgJGlkaGVhZHMoJGlkKSAkaSAkaV0KCX0KICAgIH0KICAgIHVuc2V0IGhlYWRpZHMoJG5hbWUpCn0KCnByb2Mgc2hvd19lcnJvciB7dyB0b3AgbXNnfSB7CiAgICBtZXNzYWdlICR3Lm0gLXRleHQgJG1zZyAtanVzdGlmeSBjZW50ZXIgLWFzcGVjdCA0MDAKICAgIHBhY2sgJHcubSAtc2lkZSB0b3AgLWZpbGwgeCAtcGFkeCAyMCAtcGFkeSAyMAogICAgYnV0dG9uICR3Lm9rIC10ZXh0IE9LIC1jb21tYW5kICJkZXN0cm95ICR0b3AiCiAgICBwYWNrICR3Lm9rIC1zaWRlIGJvdHRvbSAtZmlsbCB4CiAgICBiaW5kICR0b3AgPFZpc2liaWxpdHk+ICJncmFiICR0b3A7IGZvY3VzICR0b3AiCiAgICBiaW5kICR0b3AgPEtleS1SZXR1cm4+ICJkZXN0cm95ICR0b3AiCiAgICB0a3dhaXQgd2luZG93ICR0b3AKfQoKcHJvYyBlcnJvcl9wb3B1cCBtc2cgewogICAgc2V0IHcgLmVycm9yCiAgICB0b3BsZXZlbCAkdwogICAgd20gdHJhbnNpZW50ICR3IC4KICAgIHNob3dfZXJyb3IgJHcgJHcgJG1zZwp9Cgpwcm9jIGNvbmZpcm1fcG9wdXAgbXNnIHsKICAgIGdsb2JhbCBjb25maXJtX29rCiAgICBzZXQgY29uZmlybV9vayAwCiAgICBzZXQgdyAuY29uZmlybQogICAgdG9wbGV2ZWwgJHcKICAgIHdtIHRyYW5zaWVudCAkdyAuCiAgICBtZXNzYWdlICR3Lm0gLXRleHQgJG1zZyAtanVzdGlmeSBjZW50ZXIgLWFzcGVjdCA0MDAKICAgIHBhY2sgJHcubSAtc2lkZSB0b3AgLWZpbGwgeCAtcGFkeCAyMCAtcGFkeSAyMAogICAgYnV0dG9uICR3Lm9rIC10ZXh0IE9LIC1jb21tYW5kICJzZXQgY29uZmlybV9vayAxOyBkZXN0cm95ICR3IgogICAgcGFjayAkdy5vayAtc2lkZSBsZWZ0IC1maWxsIHgKICAgIGJ1dHRvbiAkdy5jYW5jZWwgLXRleHQgQ2FuY2VsIC1jb21tYW5kICJkZXN0cm95ICR3IgogICAgcGFjayAkdy5jYW5jZWwgLXNpZGUgcmlnaHQgLWZpbGwgeAogICAgYmluZCAkdyA8VmlzaWJpbGl0eT4gImdyYWIgJHc7IGZvY3VzICR3IgogICAgdGt3YWl0IHdpbmRvdyAkdwogICAgcmV0dXJuICRjb25maXJtX29rCn0KCnByb2MgbWFrZXdpbmRvdyB7fSB7CiAgICBnbG9iYWwgY2FudiBjYW52MiBjYW52MyBsaW5lc3BjIGNoYXJzcGMgY3RleHQgY2ZsaXN0CiAgICBnbG9iYWwgdGV4dGZvbnQgbWFpbmZvbnQgdWlmb250IHRhYnN0b3AKICAgIGdsb2JhbCBmaW5kdHlwZSBmaW5kdHlwZW1lbnUgZmluZGxvYyBmaW5kc3RyaW5nIGZzdHJpbmcgZ2VvbWV0cnkKICAgIGdsb2JhbCBlbnRyaWVzIHNoYTFlbnRyeSBzaGExc3RyaW5nIHNoYTFidXQKICAgIGdsb2JhbCBtYWluY3Vyc29yIHRleHRjdXJzb3IgY3VydGV4dGN1cnNvcgogICAgZ2xvYmFsIHJvd2N0eG1lbnUgZmFrZXJvd21lbnUgbWVyZ2VtYXggd3JhcGNvbW1lbnQKICAgIGdsb2JhbCBoaWdobGlnaHRfZmlsZXMgZ2R0dHlwZQogICAgZ2xvYmFsIHNlYXJjaHN0cmluZyBzc3RyaW5nCiAgICBnbG9iYWwgYmdjb2xvciBmZ2NvbG9yIGJnbGlzdCBmZ2xpc3QgZGlmZmNvbG9ycyBzZWxlY3RiZ2NvbG9yCiAgICBnbG9iYWwgaGVhZGN0eG1lbnUKCiAgICBtZW51IC5iYXIKICAgIC5iYXIgYWRkIGNhc2NhZGUgLWxhYmVsICJGaWxlIiAtbWVudSAuYmFyLmZpbGUKICAgIC5iYXIgY29uZmlndXJlIC1mb250ICR1aWZvbnQKICAgIG1lbnUgLmJhci5maWxlCiAgICAuYmFyLmZpbGUgYWRkIGNvbW1hbmQgLWxhYmVsICJVcGRhdGUiIC1jb21tYW5kIHVwZGF0ZWNvbW1pdHMKICAgIC5iYXIuZmlsZSBhZGQgY29tbWFuZCAtbGFiZWwgIlJlcmVhZCByZWZlcmVuY2VzIiAtY29tbWFuZCByZXJlYWRyZWZzCiAgICAuYmFyLmZpbGUgYWRkIGNvbW1hbmQgLWxhYmVsICJRdWl0IiAtY29tbWFuZCBkb3F1aXQKICAgIC5iYXIuZmlsZSBjb25maWd1cmUgLWZvbnQgJHVpZm9udAogICAgbWVudSAuYmFyLmVkaXQKICAgIC5iYXIgYWRkIGNhc2NhZGUgLWxhYmVsICJFZGl0IiAtbWVudSAuYmFyLmVkaXQKICAgIC5iYXIuZWRpdCBhZGQgY29tbWFuZCAtbGFiZWwgIlByZWZlcmVuY2VzIiAtY29tbWFuZCBkb3ByZWZzCiAgICAuYmFyLmVkaXQgY29uZmlndXJlIC1mb250ICR1aWZvbnQKCiAgICBtZW51IC5iYXIudmlldyAtZm9udCAkdWlmb250CiAgICAuYmFyIGFkZCBjYXNjYWRlIC1sYWJlbCAiVmlldyIgLW1lbnUgLmJhci52aWV3CiAgICAuYmFyLnZpZXcgYWRkIGNvbW1hbmQgLWxhYmVsICJOZXcgdmlldy4uLiIgLWNvbW1hbmQge25ld3ZpZXcgMH0KICAgIC5iYXIudmlldyBhZGQgY29tbWFuZCAtbGFiZWwgIkVkaXQgdmlldy4uLiIgLWNvbW1hbmQgZWRpdHZpZXcgXAoJLXN0YXRlIGRpc2FibGVkCiAgICAuYmFyLnZpZXcgYWRkIGNvbW1hbmQgLWxhYmVsICJEZWxldGUgdmlldyIgLWNvbW1hbmQgZGVsdmlldyAtc3RhdGUgZGlzYWJsZWQKICAgIC5iYXIudmlldyBhZGQgc2VwYXJhdG9yCiAgICAuYmFyLnZpZXcgYWRkIHJhZGlvYnV0dG9uIC1sYWJlbCAiQWxsIGZpbGVzIiAtY29tbWFuZCB7c2hvd3ZpZXcgMH0gXAoJLXZhcmlhYmxlIHNlbGVjdGVkdmlldyAtdmFsdWUgMAoKICAgIG1lbnUgLmJhci5oZWxwCiAgICAuYmFyIGFkZCBjYXNjYWRlIC1sYWJlbCAiSGVscCIgLW1lbnUgLmJhci5oZWxwCiAgICAuYmFyLmhlbHAgYWRkIGNvbW1hbmQgLWxhYmVsICJBYm91dCBnaXRrIiAtY29tbWFuZCBhYm91dAogICAgLmJhci5oZWxwIGFkZCBjb21tYW5kIC1sYWJlbCAiS2V5IGJpbmRpbmdzIiAtY29tbWFuZCBrZXlzCiAgICAuYmFyLmhlbHAgY29uZmlndXJlIC1mb250ICR1aWZvbnQKICAgIC4gY29uZmlndXJlIC1tZW51IC5iYXIKCiAgICAjIHRoZSBndWkgaGFzIHVwcGVyIGFuZCBsb3dlciBoYWxmLCBwYXJ0cyBvZiBhIHBhbmVkIHdpbmRvdy4KICAgIHBhbmVkd2luZG93IC5jdG9wIC1vcmllbnQgdmVydGljYWwKCiAgICAjIHBvc3NpYmx5IHVzZSBhc3N1bWVkIGdlb21ldHJ5CiAgICBpZiB7IVtpbmZvIGV4aXN0cyBnZW9tZXRyeShwd3Nhc2gwKV19IHsKICAgICAgICBzZXQgZ2VvbWV0cnkodG9waGVpZ2h0KSBbZXhwciB7MTUgKiAkbGluZXNwY31dCiAgICAgICAgc2V0IGdlb21ldHJ5KHRvcHdpZHRoKSBbZXhwciB7ODAgKiAkY2hhcnNwY31dCiAgICAgICAgc2V0IGdlb21ldHJ5KGJvdGhlaWdodCkgW2V4cHIgezE1ICogJGxpbmVzcGN9XQogICAgICAgIHNldCBnZW9tZXRyeShib3R3aWR0aCkgW2V4cHIgezUwICogJGNoYXJzcGN9XQogICAgICAgIHNldCBnZW9tZXRyeShwd3Nhc2gwKSAiW2V4cHIgezQwICogJGNoYXJzcGN9XSAyIgogICAgICAgIHNldCBnZW9tZXRyeShwd3Nhc2gxKSAiW2V4cHIgezYwICogJGNoYXJzcGN9XSAyIgogICAgfQoKICAgICMgdGhlIHVwcGVyIGhhbGYgd2lsbCBoYXZlIGEgcGFuZWQgd2luZG93LCBhIHNjcm9sbCBiYXIgdG8gdGhlIHJpZ2h0LCBhbmQgc29tZSBzdHVmZiBiZWxvdwogICAgZnJhbWUgLnRmIC1oZWlnaHQgJGdlb21ldHJ5KHRvcGhlaWdodCkgLXdpZHRoICRnZW9tZXRyeSh0b3B3aWR0aCkKICAgIGZyYW1lIC50Zi5oaXN0ZnJhbWUKICAgIHBhbmVkd2luZG93IC50Zi5oaXN0ZnJhbWUucHdjbGlzdCAtb3JpZW50IGhvcml6b250YWwgLXNhc2hwYWQgMCAtaGFuZGxlc2l6ZSA0CgogICAgIyBjcmVhdGUgdGhyZWUgY2FudmFzZXMKICAgIHNldCBjc2Nyb2xsIC50Zi5oaXN0ZnJhbWUuY3NiCiAgICBzZXQgY2FudiAudGYuaGlzdGZyYW1lLnB3Y2xpc3QuY2FudgogICAgY2FudmFzICRjYW52IFwKCS1zZWxlY3RiYWNrZ3JvdW5kICRzZWxlY3RiZ2NvbG9yIFwKCS1iYWNrZ3JvdW5kICRiZ2NvbG9yIC1iZCAwIFwKCS15c2Nyb2xsaW5jciAkbGluZXNwYyAteXNjcm9sbGNvbW1hbmQgInNjcm9sbGNhbnYgJGNzY3JvbGwiCiAgICAudGYuaGlzdGZyYW1lLnB3Y2xpc3QgYWRkICRjYW52CiAgICBzZXQgY2FudjIgLnRmLmhpc3RmcmFtZS5wd2NsaXN0LmNhbnYyCiAgICBjYW52YXMgJGNhbnYyIFwKCS1zZWxlY3RiYWNrZ3JvdW5kICRzZWxlY3RiZ2NvbG9yIFwKCS1iYWNrZ3JvdW5kICRiZ2NvbG9yIC1iZCAwIC15c2Nyb2xsaW5jciAkbGluZXNwYwogICAgLnRmLmhpc3RmcmFtZS5wd2NsaXN0IGFkZCAkY2FudjIKICAgIHNldCBjYW52MyAudGYuaGlzdGZyYW1lLnB3Y2xpc3QuY2FudjMKICAgIGNhbnZhcyAkY2FudjMgXAoJLXNlbGVjdGJhY2tncm91bmQgJHNlbGVjdGJnY29sb3IgXAoJLWJhY2tncm91bmQgJGJnY29sb3IgLWJkIDAgLXlzY3JvbGxpbmNyICRsaW5lc3BjCiAgICAudGYuaGlzdGZyYW1lLnB3Y2xpc3QgYWRkICRjYW52MwogICAgZXZhbCAudGYuaGlzdGZyYW1lLnB3Y2xpc3Qgc2FzaCBwbGFjZSAwICRnZW9tZXRyeShwd3Nhc2gwKQogICAgZXZhbCAudGYuaGlzdGZyYW1lLnB3Y2xpc3Qgc2FzaCBwbGFjZSAxICRnZW9tZXRyeShwd3Nhc2gxKQoKICAgICMgYSBzY3JvbGwgYmFyIHRvIHJ1bGUgdGhlbQogICAgc2Nyb2xsYmFyICRjc2Nyb2xsIC1jb21tYW5kIHthbGxjYW52cyB5dmlld30gLWhpZ2hsaWdodHRoaWNrbmVzcyAwCiAgICBwYWNrICRjc2Nyb2xsIC1zaWRlIHJpZ2h0IC1maWxsIHkKICAgIGJpbmQgLnRmLmhpc3RmcmFtZS5wd2NsaXN0IDxDb25maWd1cmU+IHtyZXNpemVjbGlzdHBhbmVzICVXICV3fQogICAgbGFwcGVuZCBiZ2xpc3QgJGNhbnYgJGNhbnYyICRjYW52MwogICAgcGFjayAudGYuaGlzdGZyYW1lLnB3Y2xpc3QgLWZpbGwgYm90aCAtZXhwYW5kIDEgLXNpZGUgbGVmdAoKICAgICMgd2UgaGF2ZSB0d28gYnV0dG9uIGJhcnMgYXQgYm90dG9tIG9mIHRvcCBmcmFtZS4gQmFyIDEKICAgIGZyYW1lIC50Zi5iYXIKICAgIGZyYW1lIC50Zi5sYmFyIC1oZWlnaHQgMTUKCiAgICBzZXQgc2hhMWVudHJ5IC50Zi5iYXIuc2hhMQogICAgc2V0IGVudHJpZXMgJHNoYTFlbnRyeQogICAgc2V0IHNoYTFidXQgLnRmLmJhci5zaGExbGFiZWwKICAgIGJ1dHRvbiAkc2hhMWJ1dCAtdGV4dCAiU0hBMSBJRDogIiAtc3RhdGUgZGlzYWJsZWQgLXJlbGllZiBmbGF0IFwKCS1jb21tYW5kIGdvdG9jb21taXQgLXdpZHRoIDggLWZvbnQgJHVpZm9udAogICAgJHNoYTFidXQgY29uZiAtZGlzYWJsZWRmb3JlZ3JvdW5kIFskc2hhMWJ1dCBjZ2V0IC1mb3JlZ3JvdW5kXQogICAgcGFjayAudGYuYmFyLnNoYTFsYWJlbCAtc2lkZSBsZWZ0CiAgICBlbnRyeSAkc2hhMWVudHJ5IC13aWR0aCA0MCAtZm9udCAkdGV4dGZvbnQgLXRleHR2YXJpYWJsZSBzaGExc3RyaW5nCiAgICB0cmFjZSBhZGQgdmFyaWFibGUgc2hhMXN0cmluZyB3cml0ZSBzaGExY2hhbmdlCiAgICBwYWNrICRzaGExZW50cnkgLXNpZGUgbGVmdCAtcGFkeSAyCgogICAgaW1hZ2UgY3JlYXRlIGJpdG1hcCBibS1sZWZ0IC1kYXRhIHsKCSNkZWZpbmUgbGVmdF93aWR0aCAxNgoJI2RlZmluZSBsZWZ0X2hlaWdodCAxNgoJc3RhdGljIHVuc2lnbmVkIGNoYXIgbGVmdF9iaXRzW10gPSB7CgkweDAwLCAweDAwLCAweGMwLCAweDAxLCAweGUwLCAweDAwLCAweDcwLCAweDAwLCAweDM4LCAweDAwLCAweDFjLCAweDAwLAoJMHgwZSwgMHgwMCwgMHhmZiwgMHg3ZiwgMHhmZiwgMHg3ZiwgMHhmZiwgMHg3ZiwgMHgwZSwgMHgwMCwgMHgxYywgMHgwMCwKCTB4MzgsIDB4MDAsIDB4NzAsIDB4MDAsIDB4ZTAsIDB4MDAsIDB4YzAsIDB4MDF9OwogICAgfQogICAgaW1hZ2UgY3JlYXRlIGJpdG1hcCBibS1yaWdodCAtZGF0YSB7CgkjZGVmaW5lIHJpZ2h0X3dpZHRoIDE2CgkjZGVmaW5lIHJpZ2h0X2hlaWdodCAxNgoJc3RhdGljIHVuc2lnbmVkIGNoYXIgcmlnaHRfYml0c1tdID0gewoJMHgwMCwgMHgwMCwgMHhjMCwgMHgwMSwgMHg4MCwgMHgwMywgMHgwMCwgMHgwNywgMHgwMCwgMHgwZSwgMHgwMCwgMHgxYywKCTB4MDAsIDB4MzgsIDB4ZmYsIDB4N2YsIDB4ZmYsIDB4N2YsIDB4ZmYsIDB4N2YsIDB4MDAsIDB4MzgsIDB4MDAsIDB4MWMsCgkweDAwLCAweDBlLCAweDAwLCAweDA3LCAweDgwLCAweDAzLCAweGMwLCAweDAxfTsKICAgIH0KICAgIGJ1dHRvbiAudGYuYmFyLmxlZnRidXQgLWltYWdlIGJtLWxlZnQgLWNvbW1hbmQgZ29iYWNrIFwKCS1zdGF0ZSBkaXNhYmxlZCAtd2lkdGggMjYKICAgIHBhY2sgLnRmLmJhci5sZWZ0YnV0IC1zaWRlIGxlZnQgLWZpbGwgeQogICAgYnV0dG9uIC50Zi5iYXIucmlnaHRidXQgLWltYWdlIGJtLXJpZ2h0IC1jb21tYW5kIGdvZm9ydyBcCgktc3RhdGUgZGlzYWJsZWQgLXdpZHRoIDI2CiAgICBwYWNrIC50Zi5iYXIucmlnaHRidXQgLXNpZGUgbGVmdCAtZmlsbCB5CgogICAgYnV0dG9uIC50Zi5iYXIuZmluZGJ1dCAtdGV4dCAiRmluZCIgLWNvbW1hbmQgZG9maW5kIC1mb250ICR1aWZvbnQKICAgIHBhY2sgLnRmLmJhci5maW5kYnV0IC1zaWRlIGxlZnQKICAgIHNldCBmaW5kc3RyaW5nIHt9CiAgICBzZXQgZnN0cmluZyAudGYuYmFyLmZpbmRzdHJpbmcKICAgIGxhcHBlbmQgZW50cmllcyAkZnN0cmluZwogICAgZW50cnkgJGZzdHJpbmcgLXdpZHRoIDMwIC1mb250ICR0ZXh0Zm9udCAtdGV4dHZhcmlhYmxlIGZpbmRzdHJpbmcKICAgIHRyYWNlIGFkZCB2YXJpYWJsZSBmaW5kc3RyaW5nIHdyaXRlIGZpbmRfY2hhbmdlCiAgICBwYWNrICRmc3RyaW5nIC1zaWRlIGxlZnQgLWV4cGFuZCAxIC1maWxsIHggLWluIC50Zi5iYXIKICAgIHNldCBmaW5kdHlwZSBFeGFjdAogICAgc2V0IGZpbmR0eXBlbWVudSBbdGtfb3B0aW9uTWVudSAudGYuYmFyLmZpbmR0eXBlIFwKCQkgICAgICBmaW5kdHlwZSBFeGFjdCBJZ25DYXNlIFJlZ2V4cF0KICAgIHRyYWNlIGFkZCB2YXJpYWJsZSBmaW5kdHlwZSB3cml0ZSBmaW5kX2NoYW5nZQogICAgLnRmLmJhci5maW5kdHlwZSBjb25maWd1cmUgLWZvbnQgJHVpZm9udAogICAgLnRmLmJhci5maW5kdHlwZS5tZW51IGNvbmZpZ3VyZSAtZm9udCAkdWlmb250CiAgICBzZXQgZmluZGxvYyAiQWxsIGZpZWxkcyIKICAgIHRrX29wdGlvbk1lbnUgLnRmLmJhci5maW5kbG9jIGZpbmRsb2MgIkFsbCBmaWVsZHMiIEhlYWRsaW5lIFwKCUNvbW1lbnRzIEF1dGhvciBDb21taXR0ZXIKICAgIHRyYWNlIGFkZCB2YXJpYWJsZSBmaW5kbG9jIHdyaXRlIGZpbmRfY2hhbmdlCiAgICAudGYuYmFyLmZpbmRsb2MgY29uZmlndXJlIC1mb250ICR1aWZvbnQKICAgIC50Zi5iYXIuZmluZGxvYy5tZW51IGNvbmZpZ3VyZSAtZm9udCAkdWlmb250CiAgICBwYWNrIC50Zi5iYXIuZmluZGxvYyAtc2lkZSByaWdodAogICAgcGFjayAudGYuYmFyLmZpbmR0eXBlIC1zaWRlIHJpZ2h0CgogICAgIyBidWlsZCB1cCB0aGUgYm90dG9tIGJhciBvZiB1cHBlciB3aW5kb3cKICAgIGxhYmVsIC50Zi5sYmFyLmZsYWJlbCAtdGV4dCAiSGlnaGxpZ2h0OiAgQ29tbWl0cyAiIFwKICAgIC1mb250ICR1aWZvbnQKICAgIHBhY2sgLnRmLmxiYXIuZmxhYmVsIC1zaWRlIGxlZnQgLWZpbGwgeQogICAgc2V0IGdkdHR5cGUgInRvdWNoaW5nIHBhdGhzOiIKICAgIHNldCBnbSBbdGtfb3B0aW9uTWVudSAudGYubGJhci5nZHR0eXBlIGdkdHR5cGUgInRvdWNoaW5nIHBhdGhzOiIgXAoJImFkZGluZy9yZW1vdmluZyBzdHJpbmc6Il0KICAgIHRyYWNlIGFkZCB2YXJpYWJsZSBnZHR0eXBlIHdyaXRlIGhmaWxlc19jaGFuZ2UKICAgICRnbSBjb25mIC1mb250ICR1aWZvbnQKICAgIC50Zi5sYmFyLmdkdHR5cGUgY29uZiAtZm9udCAkdWlmb250CiAgICBwYWNrIC50Zi5sYmFyLmdkdHR5cGUgLXNpZGUgbGVmdCAtZmlsbCB5CiAgICBlbnRyeSAudGYubGJhci5mZW50IC13aWR0aCAyNSAtZm9udCAkdGV4dGZvbnQgXAoJLXRleHR2YXJpYWJsZSBoaWdobGlnaHRfZmlsZXMKICAgIHRyYWNlIGFkZCB2YXJpYWJsZSBoaWdobGlnaHRfZmlsZXMgd3JpdGUgaGZpbGVzX2NoYW5nZQogICAgbGFwcGVuZCBlbnRyaWVzIC50Zi5sYmFyLmZlbnQKICAgIHBhY2sgLnRmLmxiYXIuZmVudCAtc2lkZSBsZWZ0IC1maWxsIHggLWV4cGFuZCAxCiAgICBsYWJlbCAudGYubGJhci52bGFiZWwgLXRleHQgIiBPUiBpbiB2aWV3IiAtZm9udCAkdWlmb250CiAgICBwYWNrIC50Zi5sYmFyLnZsYWJlbCAtc2lkZSBsZWZ0IC1maWxsIHkKICAgIGdsb2JhbCB2aWV3aGxtZW51IHNlbGVjdGVkaGx2aWV3CiAgICBzZXQgdmlld2hsbWVudSBbdGtfb3B0aW9uTWVudSAudGYubGJhci52aGwgc2VsZWN0ZWRobHZpZXcgTm9uZV0KICAgICR2aWV3aGxtZW51IGVudHJ5Y29uZiBOb25lIC1jb21tYW5kIGRlbHZoaWdobGlnaHQKICAgICR2aWV3aGxtZW51IGNvbmYgLWZvbnQgJHVpZm9udAogICAgLnRmLmxiYXIudmhsIGNvbmYgLWZvbnQgJHVpZm9udAogICAgcGFjayAudGYubGJhci52aGwgLXNpZGUgbGVmdCAtZmlsbCB5CiAgICBsYWJlbCAudGYubGJhci5ybGFiZWwgLXRleHQgIiBPUiAiIC1mb250ICR1aWZvbnQKICAgIHBhY2sgLnRmLmxiYXIucmxhYmVsIC1zaWRlIGxlZnQgLWZpbGwgeQogICAgZ2xvYmFsIGhpZ2hsaWdodF9yZWxhdGVkCiAgICBzZXQgbSBbdGtfb3B0aW9uTWVudSAudGYubGJhci5yZWxtIGhpZ2hsaWdodF9yZWxhdGVkIE5vbmUgXAoJIkRlc2NlbmRlbnQiICJOb3QgZGVzY2VuZGVudCIgIkFuY2VzdG9yIiAiTm90IGFuY2VzdG9yIl0KICAgICRtIGNvbmYgLWZvbnQgJHVpZm9udAogICAgLnRmLmxiYXIucmVsbSBjb25mIC1mb250ICR1aWZvbnQKICAgIHRyYWNlIGFkZCB2YXJpYWJsZSBoaWdobGlnaHRfcmVsYXRlZCB3cml0ZSB2cmVsX2NoYW5nZQogICAgcGFjayAudGYubGJhci5yZWxtIC1zaWRlIGxlZnQgLWZpbGwgeQoKICAgICMgRmluaXNoIHB1dHRpbmcgdGhlIHVwcGVyIGhhbGYgb2YgdGhlIHZpZXdlciB0b2dldGhlcgogICAgcGFjayAudGYubGJhciAtaW4gLnRmIC1zaWRlIGJvdHRvbSAtZmlsbCB4CiAgICBwYWNrIC50Zi5iYXIgLWluIC50ZiAtc2lkZSBib3R0b20gLWZpbGwgeAogICAgcGFjayAudGYuaGlzdGZyYW1lIC1maWxsIGJvdGggLXNpZGUgdG9wIC1leHBhbmQgMQogICAgLmN0b3AgYWRkIC50ZgogICAgLmN0b3AgcGFuZWNvbmZpZ3VyZSAudGYgLWhlaWdodCAkZ2VvbWV0cnkodG9waGVpZ2h0KQogICAgLmN0b3AgcGFuZWNvbmZpZ3VyZSAudGYgLXdpZHRoICRnZW9tZXRyeSh0b3B3aWR0aCkKCiAgICAjIG5vdyBidWlsZCB1cCB0aGUgYm90dG9tCiAgICBwYW5lZHdpbmRvdyAucHdib3R0b20gLW9yaWVudCBob3Jpem9udGFsCgogICAgIyBsb3dlciBsZWZ0LCBhIHRleHQgYm94IG92ZXIgc2VhcmNoIGJhciwgc2Nyb2xsIGJhciB0byB0aGUgcmlnaHQKICAgICMgaWYgd2Uga25vdyB3aW5kb3cgaGVpZ2h0LCB0aGVuIHRoYXQgd2lsbCBzZXQgdGhlIGxvd2VyIHRleHQgaGVpZ2h0LCBvdGhlcndpc2UKICAgICMgd2Ugc2V0IGxvd2VyIHRleHQgaGVpZ2h0IHdoaWNoIHdpbGwgZHJpdmUgd2luZG93IGhlaWdodAogICAgaWYge1tpbmZvIGV4aXN0cyBnZW9tZXRyeShtYWluKV19IHsKICAgICAgICBmcmFtZSAuYmxlZnQgLXdpZHRoICRnZW9tZXRyeShib3R3aWR0aCkKICAgIH0gZWxzZSB7CiAgICAgICAgZnJhbWUgLmJsZWZ0IC13aWR0aCAkZ2VvbWV0cnkoYm90d2lkdGgpIC1oZWlnaHQgJGdlb21ldHJ5KGJvdGhlaWdodCkKICAgIH0KICAgIGZyYW1lIC5ibGVmdC50b3AKICAgIGZyYW1lIC5ibGVmdC5taWQKCiAgICBidXR0b24gLmJsZWZ0LnRvcC5zZWFyY2ggLXRleHQgIlNlYXJjaCIgLWNvbW1hbmQgZG9zZWFyY2ggXAoJLWZvbnQgJHVpZm9udAogICAgcGFjayAuYmxlZnQudG9wLnNlYXJjaCAtc2lkZSBsZWZ0IC1wYWR4IDUKICAgIHNldCBzc3RyaW5nIC5ibGVmdC50b3Auc3N0cmluZwogICAgZW50cnkgJHNzdHJpbmcgLXdpZHRoIDIwIC1mb250ICR0ZXh0Zm9udCAtdGV4dHZhcmlhYmxlIHNlYXJjaHN0cmluZwogICAgbGFwcGVuZCBlbnRyaWVzICRzc3RyaW5nCiAgICB0cmFjZSBhZGQgdmFyaWFibGUgc2VhcmNoc3RyaW5nIHdyaXRlIGluY3JzZWFyY2gKICAgIHBhY2sgJHNzdHJpbmcgLXNpZGUgbGVmdCAtZXhwYW5kIDEgLWZpbGwgeAogICAgcmFkaW9idXR0b24gLmJsZWZ0Lm1pZC5kaWZmIC10ZXh0ICJEaWZmIiBcCgktY29tbWFuZCBjaGFuZ2VkaWZmZGlzcCAtdmFyaWFibGUgZGlmZmVsaWRlIC12YWx1ZSB7MCAwfQogICAgcmFkaW9idXR0b24gLmJsZWZ0Lm1pZC5vbGQgLXRleHQgIk9sZCB2ZXJzaW9uIiBcCgktY29tbWFuZCBjaGFuZ2VkaWZmZGlzcCAtdmFyaWFibGUgZGlmZmVsaWRlIC12YWx1ZSB7MCAxfQogICAgcmFkaW9idXR0b24gLmJsZWZ0Lm1pZC5uZXcgLXRleHQgIk5ldyB2ZXJzaW9uIiBcCgktY29tbWFuZCBjaGFuZ2VkaWZmZGlzcCAtdmFyaWFibGUgZGlmZmVsaWRlIC12YWx1ZSB7MSAwfQogICAgcGFjayAuYmxlZnQubWlkLmRpZmYgLmJsZWZ0Lm1pZC5vbGQgLmJsZWZ0Lm1pZC5uZXcgLXNpZGUgbGVmdAogICAgc2V0IGN0ZXh0IC5ibGVmdC5jdGV4dAogICAgdGV4dCAkY3RleHQgLWJhY2tncm91bmQgJGJnY29sb3IgLWZvcmVncm91bmQgJGZnY29sb3IgXAoJLXRhYnMgIltleHByIHskdGFic3RvcCAqICRjaGFyc3BjfV0iIFwKCS1zdGF0ZSBkaXNhYmxlZCAtZm9udCAkdGV4dGZvbnQgXAoJLXlzY3JvbGxjb21tYW5kIHNjcm9sbHRleHQgLXdyYXAgbm9uZQogICAgc2Nyb2xsYmFyIC5ibGVmdC5zYiAtY29tbWFuZCAiJGN0ZXh0IHl2aWV3IgogICAgcGFjayAuYmxlZnQudG9wIC1zaWRlIHRvcCAtZmlsbCB4CiAgICBwYWNrIC5ibGVmdC5taWQgLXNpZGUgdG9wIC1maWxsIHgKICAgIHBhY2sgLmJsZWZ0LnNiIC1zaWRlIHJpZ2h0IC1maWxsIHkKICAgIHBhY2sgJGN0ZXh0IC1zaWRlIGxlZnQgLWZpbGwgYm90aCAtZXhwYW5kIDEKICAgIGxhcHBlbmQgYmdsaXN0ICRjdGV4dAogICAgbGFwcGVuZCBmZ2xpc3QgJGN0ZXh0CgogICAgJGN0ZXh0IHRhZyBjb25mIGNvbW1lbnQgLXdyYXAgJHdyYXBjb21tZW50CiAgICAkY3RleHQgdGFnIGNvbmYgZmlsZXNlcCAtZm9udCBbY29uY2F0ICR0ZXh0Zm9udCBib2xkXSAtYmFjayAiI2FhYWFhYSIKICAgICRjdGV4dCB0YWcgY29uZiBodW5rc2VwIC1mb3JlIFtsaW5kZXggJGRpZmZjb2xvcnMgMl0KICAgICRjdGV4dCB0YWcgY29uZiBkMCAtZm9yZSBbbGluZGV4ICRkaWZmY29sb3JzIDBdCiAgICAkY3RleHQgdGFnIGNvbmYgZDEgLWZvcmUgW2xpbmRleCAkZGlmZmNvbG9ycyAxXQogICAgJGN0ZXh0IHRhZyBjb25mIG0wIC1mb3JlIHJlZAogICAgJGN0ZXh0IHRhZyBjb25mIG0xIC1mb3JlIGJsdWUKICAgICRjdGV4dCB0YWcgY29uZiBtMiAtZm9yZSBncmVlbgogICAgJGN0ZXh0IHRhZyBjb25mIG0zIC1mb3JlIHB1cnBsZQogICAgJGN0ZXh0IHRhZyBjb25mIG00IC1mb3JlIGJyb3duCiAgICAkY3RleHQgdGFnIGNvbmYgbTUgLWZvcmUgIiMwMDkwOTAiCiAgICAkY3RleHQgdGFnIGNvbmYgbTYgLWZvcmUgbWFnZW50YQogICAgJGN0ZXh0IHRhZyBjb25mIG03IC1mb3JlICIjODA4MDAwIgogICAgJGN0ZXh0IHRhZyBjb25mIG04IC1mb3JlICIjMDA5MDAwIgogICAgJGN0ZXh0IHRhZyBjb25mIG05IC1mb3JlICIjZmYwMDgwIgogICAgJGN0ZXh0IHRhZyBjb25mIG0xMCAtZm9yZSBjeWFuCiAgICAkY3RleHQgdGFnIGNvbmYgbTExIC1mb3JlICIjYjA3MDcwIgogICAgJGN0ZXh0IHRhZyBjb25mIG0xMiAtZm9yZSAiIzcwYjBmMCIKICAgICRjdGV4dCB0YWcgY29uZiBtMTMgLWZvcmUgIiM3MGYwYjAiCiAgICAkY3RleHQgdGFnIGNvbmYgbTE0IC1mb3JlICIjZjBiMDcwIgogICAgJGN0ZXh0IHRhZyBjb25mIG0xNSAtZm9yZSAiI2ZmNzBiMCIKICAgICRjdGV4dCB0YWcgY29uZiBtbWF4IC1mb3JlIGRhcmtncmV5CiAgICBzZXQgbWVyZ2VtYXggMTYKICAgICRjdGV4dCB0YWcgY29uZiBtcmVzdWx0IC1mb250IFtjb25jYXQgJHRleHRmb250IGJvbGRdCiAgICAkY3RleHQgdGFnIGNvbmYgbXNlcCAtZm9udCBbY29uY2F0ICR0ZXh0Zm9udCBib2xkXQogICAgJGN0ZXh0IHRhZyBjb25mIGZvdW5kIC1iYWNrIHllbGxvdwoKICAgIC5wd2JvdHRvbSBhZGQgLmJsZWZ0CiAgICAucHdib3R0b20gcGFuZWNvbmZpZ3VyZSAuYmxlZnQgLXdpZHRoICRnZW9tZXRyeShib3R3aWR0aCkKCiAgICAjIGxvd2VyIHJpZ2h0CiAgICBmcmFtZSAuYnJpZ2h0CiAgICBmcmFtZSAuYnJpZ2h0Lm1vZGUKICAgIHJhZGlvYnV0dG9uIC5icmlnaHQubW9kZS5wYXRjaCAtdGV4dCAiUGF0Y2giIFwKCS1jb21tYW5kIHJlc2VsZWN0bGluZSAtdmFyaWFibGUgY21pdG1vZGUgLXZhbHVlICJwYXRjaCIKICAgIC5icmlnaHQubW9kZS5wYXRjaCBjb25maWd1cmUgLWZvbnQgJHVpZm9udAogICAgcmFkaW9idXR0b24gLmJyaWdodC5tb2RlLnRyZWUgLXRleHQgIlRyZWUiIFwKCS1jb21tYW5kIHJlc2VsZWN0bGluZSAtdmFyaWFibGUgY21pdG1vZGUgLXZhbHVlICJ0cmVlIgogICAgLmJyaWdodC5tb2RlLnRyZWUgY29uZmlndXJlIC1mb250ICR1aWZvbnQKICAgIGdyaWQgLmJyaWdodC5tb2RlLnBhdGNoIC5icmlnaHQubW9kZS50cmVlIC1zdGlja3kgZXcKICAgIHBhY2sgLmJyaWdodC5tb2RlIC1zaWRlIHRvcCAtZmlsbCB4CiAgICBzZXQgY2ZsaXN0IC5icmlnaHQuY2ZpbGVzCiAgICBzZXQgaW5kZW50IFtmb250IG1lYXN1cmUgJG1haW5mb250ICJubiJdCiAgICB0ZXh0ICRjZmxpc3QgXAoJLXNlbGVjdGJhY2tncm91bmQgJHNlbGVjdGJnY29sb3IgXAoJLWJhY2tncm91bmQgJGJnY29sb3IgLWZvcmVncm91bmQgJGZnY29sb3IgXAoJLWZvbnQgJG1haW5mb250IFwKCS10YWJzIFtsaXN0ICRpbmRlbnQgW2V4cHIgezIgKiAkaW5kZW50fV1dIFwKCS15c2Nyb2xsY29tbWFuZCAiLmJyaWdodC5zYiBzZXQiIFwKCS1jdXJzb3IgWy4gY2dldCAtY3Vyc29yXSBcCgktc3BhY2luZzEgMSAtc3BhY2luZzMgMQogICAgbGFwcGVuZCBiZ2xpc3QgJGNmbGlzdAogICAgbGFwcGVuZCBmZ2xpc3QgJGNmbGlzdAogICAgc2Nyb2xsYmFyIC5icmlnaHQuc2IgLWNvbW1hbmQgIiRjZmxpc3QgeXZpZXciCiAgICBwYWNrIC5icmlnaHQuc2IgLXNpZGUgcmlnaHQgLWZpbGwgeQogICAgcGFjayAkY2ZsaXN0IC1zaWRlIGxlZnQgLWZpbGwgYm90aCAtZXhwYW5kIDEKICAgICRjZmxpc3QgdGFnIGNvbmZpZ3VyZSBoaWdobGlnaHQgXAoJLWJhY2tncm91bmQgWyRjZmxpc3QgY2dldCAtc2VsZWN0YmFja2dyb3VuZF0KICAgICRjZmxpc3QgdGFnIGNvbmZpZ3VyZSBib2xkIC1mb250IFtjb25jYXQgJG1haW5mb250IGJvbGRdCgogICAgLnB3Ym90dG9tIGFkZCAuYnJpZ2h0CiAgICAuY3RvcCBhZGQgLnB3Ym90dG9tCgogICAgIyByZXN0b3JlIHdpbmRvdyBwb3NpdGlvbiBpZiBrbm93bgogICAgaWYge1tpbmZvIGV4aXN0cyBnZW9tZXRyeShtYWluKV19IHsKICAgICAgICB3bSBnZW9tZXRyeSAuICIkZ2VvbWV0cnkobWFpbikiCiAgICB9CgogICAgaWYge1t0ayB3aW5kb3dpbmdzeXN0ZW1dIGVxIHthcXVhfX0gewogICAgICAgIHNldCBNMUIgTTEKICAgIH0gZWxzZSB7CiAgICAgICAgc2V0IE0xQiBDb250cm9sCiAgICB9CgogICAgYmluZCAucHdib3R0b20gPENvbmZpZ3VyZT4ge3Jlc2l6ZWNkZXRwYW5lcyAlVyAld30KICAgIHBhY2sgLmN0b3AgLWZpbGwgYm90aCAtZXhwYW5kIDEKICAgIGJpbmRhbGwgPDE+IHtzZWxjYW52bGluZSAlVyAleCAleX0KICAgICNiaW5kYWxsIDxCMS1Nb3Rpb24+IHtzZWxjYW52bGluZSAlVyAleCAleX0KICAgIGJpbmRhbGwgPEJ1dHRvblJlbGVhc2UtND4gImFsbGNhbnZzIHl2aWV3IHNjcm9sbCAtNSB1bml0cyIKICAgIGJpbmRhbGwgPEJ1dHRvblJlbGVhc2UtNT4gImFsbGNhbnZzIHl2aWV3IHNjcm9sbCA1IHVuaXRzIgogICAgYmluZGFsbCA8Mj4gImNhbnZzY2FuIG1hcmsgJVcgJXggJXkiCiAgICBiaW5kYWxsIDxCMi1Nb3Rpb24+ICJjYW52c2NhbiBkcmFndG8gJVcgJXggJXkiCiAgICBiaW5ka2V5IDxIb21lPiBzZWxmaXJzdGxpbmUKICAgIGJpbmRrZXkgPEVuZD4gc2VsbGFzdGxpbmUKICAgIGJpbmQgLiA8S2V5LVVwPiAic2VsbmV4dGxpbmUgLTEiCiAgICBiaW5kIC4gPEtleS1Eb3duPiAic2VsbmV4dGxpbmUgMSIKICAgIGJpbmQgLiA8U2hpZnQtS2V5LVVwPiAibmV4dF9oaWdobGlnaHQgLTEiCiAgICBiaW5kIC4gPFNoaWZ0LUtleS1Eb3duPiAibmV4dF9oaWdobGlnaHQgMSIKICAgIGJpbmRrZXkgPEtleS1SaWdodD4gImdvZm9ydyIKICAgIGJpbmRrZXkgPEtleS1MZWZ0PiAiZ29iYWNrIgogICAgYmluZCAuIDxLZXktUHJpb3I+ICJzZWxuZXh0cGFnZSAtMSIKICAgIGJpbmQgLiA8S2V5LU5leHQ+ICJzZWxuZXh0cGFnZSAxIgogICAgYmluZCAuIDwkTTFCLUhvbWU+ICJhbGxjYW52cyB5dmlldyBtb3ZldG8gMC4wIgogICAgYmluZCAuIDwkTTFCLUVuZD4gImFsbGNhbnZzIHl2aWV3IG1vdmV0byAxLjAiCiAgICBiaW5kIC4gPCRNMUItS2V5LVVwPiAiYWxsY2FudnMgeXZpZXcgc2Nyb2xsIC0xIHVuaXRzIgogICAgYmluZCAuIDwkTTFCLUtleS1Eb3duPiAiYWxsY2FudnMgeXZpZXcgc2Nyb2xsIDEgdW5pdHMiCiAgICBiaW5kIC4gPCRNMUItS2V5LVByaW9yPiAiYWxsY2FudnMgeXZpZXcgc2Nyb2xsIC0xIHBhZ2VzIgogICAgYmluZCAuIDwkTTFCLUtleS1OZXh0PiAiYWxsY2FudnMgeXZpZXcgc2Nyb2xsIDEgcGFnZXMiCiAgICBiaW5ka2V5IDxLZXktRGVsZXRlPiAiJGN0ZXh0IHl2aWV3IHNjcm9sbCAtMSBwYWdlcyIKICAgIGJpbmRrZXkgPEtleS1CYWNrU3BhY2U+ICIkY3RleHQgeXZpZXcgc2Nyb2xsIC0xIHBhZ2VzIgogICAgYmluZGtleSA8S2V5LXNwYWNlPiAiJGN0ZXh0IHl2aWV3IHNjcm9sbCAxIHBhZ2VzIgogICAgYmluZGtleSBwICJzZWxuZXh0bGluZSAtMSIKICAgIGJpbmRrZXkgbiAic2VsbmV4dGxpbmUgMSIKICAgIGJpbmRrZXkgeiAiZ29iYWNrIgogICAgYmluZGtleSB4ICJnb2ZvcnciCiAgICBiaW5ka2V5IGkgInNlbG5leHRsaW5lIC0xIgogICAgYmluZGtleSBrICJzZWxuZXh0bGluZSAxIgogICAgYmluZGtleSBqICJnb2JhY2siCiAgICBiaW5ka2V5IGwgImdvZm9ydyIKICAgIGJpbmRrZXkgYiAiJGN0ZXh0IHl2aWV3IHNjcm9sbCAtMSBwYWdlcyIKICAgIGJpbmRrZXkgZCAiJGN0ZXh0IHl2aWV3IHNjcm9sbCAxOCB1bml0cyIKICAgIGJpbmRrZXkgdSAiJGN0ZXh0IHl2aWV3IHNjcm9sbCAtMTggdW5pdHMiCiAgICBiaW5ka2V5IC8ge2ZpbmRuZXh0IDF9CiAgICBiaW5ka2V5IDxLZXktUmV0dXJuPiB7ZmluZG5leHQgMH0KICAgIGJpbmRrZXkgPyBmaW5kcHJldgogICAgYmluZGtleSBmIG5leHRmaWxlCiAgICBiaW5ka2V5IDxGNT4gdXBkYXRlY29tbWl0cwogICAgYmluZCAuIDwkTTFCLXE+IGRvcXVpdAogICAgYmluZCAuIDwkTTFCLWY+IGRvZmluZAogICAgYmluZCAuIDwkTTFCLWc+IHtmaW5kbmV4dCAwfQogICAgYmluZCAuIDwkTTFCLXI+IGRvc2VhcmNoYmFjawogICAgYmluZCAuIDwkTTFCLXM+IGRvc2VhcmNoCiAgICBiaW5kIC4gPCRNMUItZXF1YWw+IHtpbmNyZm9udCAxfQogICAgYmluZCAuIDwkTTFCLUtQX0FkZD4ge2luY3Jmb250IDF9CiAgICBiaW5kIC4gPCRNMUItbWludXM+IHtpbmNyZm9udCAtMX0KICAgIGJpbmQgLiA8JE0xQi1LUF9TdWJ0cmFjdD4ge2luY3Jmb250IC0xfQogICAgd20gcHJvdG9jb2wgLiBXTV9ERUxFVEVfV0lORE9XIGRvcXVpdAogICAgYmluZCAuIDxCdXR0b24tMT4gImNsaWNrICVXIgogICAgYmluZCAkZnN0cmluZyA8S2V5LVJldHVybj4gZG9maW5kCiAgICBiaW5kICRzaGExZW50cnkgPEtleS1SZXR1cm4+IGdvdG9jb21taXQKICAgIGJpbmQgJHNoYTFlbnRyeSA8PFBhc3RlU2VsZWN0aW9uPj4gY2xlYXJzaGExCiAgICBiaW5kICRjZmxpc3QgPDE+IHtzZWxfZmxpc3QgJVcgJXggJXk7IGJyZWFrfQogICAgYmluZCAkY2ZsaXN0IDxCMS1Nb3Rpb24+IHtzZWxfZmxpc3QgJVcgJXggJXk7IGJyZWFrfQogICAgYmluZCAkY2ZsaXN0IDxCdXR0b25SZWxlYXNlLTE+IHt0cmVlY2xpY2sgJVcgJXggJXl9CgogICAgc2V0IG1haW5jdXJzb3IgWy4gY2dldCAtY3Vyc29yXQogICAgc2V0IHRleHRjdXJzb3IgWyRjdGV4dCBjZ2V0IC1jdXJzb3JdCiAgICBzZXQgY3VydGV4dGN1cnNvciAkdGV4dGN1cnNvcgoKICAgIHNldCByb3djdHhtZW51IC5yb3djdHhtZW51CiAgICBtZW51ICRyb3djdHhtZW51IC10ZWFyb2ZmIDAKICAgICRyb3djdHhtZW51IGFkZCBjb21tYW5kIC1sYWJlbCAiRGlmZiB0aGlzIC0+IHNlbGVjdGVkIiBcCgktY29tbWFuZCB7ZGlmZnZzc2VsIDB9CiAgICAkcm93Y3R4bWVudSBhZGQgY29tbWFuZCAtbGFiZWwgIkRpZmYgc2VsZWN0ZWQgLT4gdGhpcyIgXAoJLWNvbW1hbmQge2RpZmZ2c3NlbCAxfQogICAgJHJvd2N0eG1lbnUgYWRkIGNvbW1hbmQgLWxhYmVsICJNYWtlIHBhdGNoIiAtY29tbWFuZCBta3BhdGNoCiAgICAkcm93Y3R4bWVudSBhZGQgY29tbWFuZCAtbGFiZWwgIkNyZWF0ZSB0YWciIC1jb21tYW5kIG1rdGFnCiAgICAkcm93Y3R4bWVudSBhZGQgY29tbWFuZCAtbGFiZWwgIldyaXRlIGNvbW1pdCB0byBmaWxlIiAtY29tbWFuZCB3cml0ZWNvbW1pdAogICAgJHJvd2N0eG1lbnUgYWRkIGNvbW1hbmQgLWxhYmVsICJDcmVhdGUgbmV3IGJyYW5jaCIgLWNvbW1hbmQgbWticmFuY2gKICAgICRyb3djdHhtZW51IGFkZCBjb21tYW5kIC1sYWJlbCAiQ2hlcnJ5LXBpY2sgdGhpcyBjb21taXQiIFwKCS1jb21tYW5kIGNoZXJyeXBpY2sKICAgICRyb3djdHhtZW51IGFkZCBjb21tYW5kIC1sYWJlbCAiUmVzZXQgSEVBRCBicmFuY2ggdG8gaGVyZSIgXAoJLWNvbW1hbmQgcmVzZXRoZWFkCgogICAgc2V0IGZha2Vyb3dtZW51IC5mYWtlcm93bWVudQogICAgbWVudSAkZmFrZXJvd21lbnUgLXRlYXJvZmYgMAogICAgJGZha2Vyb3dtZW51IGFkZCBjb21tYW5kIC1sYWJlbCAiRGlmZiB0aGlzIC0+IHNlbGVjdGVkIiBcCgktY29tbWFuZCB7ZGlmZnZzc2VsIDB9CiAgICAkZmFrZXJvd21lbnUgYWRkIGNvbW1hbmQgLWxhYmVsICJEaWZmIHNlbGVjdGVkIC0+IHRoaXMiIFwKCS1jb21tYW5kIHtkaWZmdnNzZWwgMX0KICAgICRmYWtlcm93bWVudSBhZGQgY29tbWFuZCAtbGFiZWwgIk1ha2UgcGF0Y2giIC1jb21tYW5kIG1rcGF0Y2gKIyAgICAkZmFrZXJvd21lbnUgYWRkIGNvbW1hbmQgLWxhYmVsICJDb21taXQiIC1jb21tYW5kIHtta2NvbW1pdCAwfQojICAgICRmYWtlcm93bWVudSBhZGQgY29tbWFuZCAtbGFiZWwgIkNvbW1pdCBhbGwiIC1jb21tYW5kIHtta2NvbW1pdCAxfQojICAgICRmYWtlcm93bWVudSBhZGQgY29tbWFuZCAtbGFiZWwgIlJldmVydCBsb2NhbCBjaGFuZ2VzIiAtY29tbWFuZCByZXZlcnRsb2NhbAoKICAgIHNldCBoZWFkY3R4bWVudSAuaGVhZGN0eG1lbnUKICAgIG1lbnUgJGhlYWRjdHhtZW51IC10ZWFyb2ZmIDAKICAgICRoZWFkY3R4bWVudSBhZGQgY29tbWFuZCAtbGFiZWwgIkNoZWNrIG91dCB0aGlzIGJyYW5jaCIgXAoJLWNvbW1hbmQgY29icmFuY2gKICAgICRoZWFkY3R4bWVudSBhZGQgY29tbWFuZCAtbGFiZWwgIlJlbW92ZSB0aGlzIGJyYW5jaCIgXAoJLWNvbW1hbmQgcm1icmFuY2gKfQoKIyBtb3VzZS0yIG1ha2VzIGFsbCB3aW5kb3dzIHNjYW4gdmVydGljYWxseSwgYnV0IG9ubHkgdGhlIG9uZQojIHRoZSBjdXJzb3IgaXMgaW4gc2NhbnMgaG9yaXpvbnRhbGx5CnByb2MgY2FudnNjYW4ge29wIHcgeCB5fSB7CiAgICBnbG9iYWwgY2FudiBjYW52MiBjYW52MwogICAgZm9yZWFjaCBjIFtsaXN0ICRjYW52ICRjYW52MiAkY2FudjNdIHsKCWlmIHskYyA9PSAkd30gewoJICAgICRjIHNjYW4gJG9wICR4ICR5Cgl9IGVsc2UgewoJICAgICRjIHNjYW4gJG9wIDAgJHkKCX0KICAgIH0KfQoKcHJvYyBzY3JvbGxjYW52IHtjc2Nyb2xsIGYwIGYxfSB7CiAgICAkY3Njcm9sbCBzZXQgJGYwICRmMQogICAgZHJhd2ZyYWMgJGYwICRmMQogICAgZmx1c2hoaWdobGlnaHRzCn0KCiMgd2hlbiB3ZSBtYWtlIGEga2V5IGJpbmRpbmcgZm9yIHRoZSB0b3BsZXZlbCwgbWFrZSBzdXJlCiMgaXQgZG9lc24ndCBnZXQgdHJpZ2dlcmVkIHdoZW4gdGhhdCBrZXkgaXMgcHJlc3NlZCBpbiB0aGUKIyBmaW5kIHN0cmluZyBlbnRyeSB3aWRnZXQuCnByb2MgYmluZGtleSB7ZXYgc2NyaXB0fSB7CiAgICBnbG9iYWwgZW50cmllcwogICAgYmluZCAuICRldiAkc2NyaXB0CiAgICBzZXQgZXNjcmlwdCBbYmluZCBFbnRyeSAkZXZdCiAgICBpZiB7JGVzY3JpcHQgPT0ge319IHsKCXNldCBlc2NyaXB0IFtiaW5kIEVudHJ5IDxLZXk+XQogICAgfQogICAgZm9yZWFjaCBlICRlbnRyaWVzIHsKCWJpbmQgJGUgJGV2ICIkZXNjcmlwdDsgYnJlYWsiCiAgICB9Cn0KCiMgc2V0IHRoZSBmb2N1cyBiYWNrIHRvIHRoZSB0b3BsZXZlbCBmb3IgYW55IGNsaWNrIG91dHNpZGUKIyB0aGUgZW50cnkgd2lkZ2V0cwpwcm9jIGNsaWNrIHt3fSB7CiAgICBnbG9iYWwgZW50cmllcwogICAgZm9yZWFjaCBlICRlbnRyaWVzIHsKCWlmIHskdyA9PSAkZX0gcmV0dXJuCiAgICB9CiAgICBmb2N1cyAuCn0KCnByb2Mgc2F2ZXN0dWZmIHt3fSB7CiAgICBnbG9iYWwgY2FudiBjYW52MiBjYW52MyBjdGV4dCBjZmxpc3QgbWFpbmZvbnQgdGV4dGZvbnQgdWlmb250IHRhYnN0b3AKICAgIGdsb2JhbCBzdHVmZnNhdmVkIGZpbmRtZXJnZWZpbGVzIG1heGdyYXBocGN0CiAgICBnbG9iYWwgbWF4d2lkdGggc2hvd25lYXJ0YWdzIHNob3dsb2NhbGNoYW5nZXMKICAgIGdsb2JhbCB2aWV3bmFtZSB2aWV3ZmlsZXMgdmlld2FyZ3Mgdmlld3Blcm0gbmV4dHZpZXdudW0KICAgIGdsb2JhbCBjbWl0bW9kZSB3cmFwY29tbWVudAogICAgZ2xvYmFsIGNvbG9ycyBiZ2NvbG9yIGZnY29sb3IgZGlmZmNvbG9ycyBzZWxlY3RiZ2NvbG9yCgogICAgaWYgeyRzdHVmZnNhdmVkfSByZXR1cm4KICAgIGlmIHshW3dpbmZvIHZpZXdhYmxlIC5dfSByZXR1cm4KICAgIGNhdGNoIHsKCXNldCBmIFtvcGVuICJ+Ly5naXRrLW5ldyIgd10KCXB1dHMgJGYgW2xpc3Qgc2V0IG1haW5mb250ICRtYWluZm9udF0KCXB1dHMgJGYgW2xpc3Qgc2V0IHRleHRmb250ICR0ZXh0Zm9udF0KCXB1dHMgJGYgW2xpc3Qgc2V0IHVpZm9udCAkdWlmb250XQoJcHV0cyAkZiBbbGlzdCBzZXQgdGFic3RvcCAkdGFic3RvcF0KCXB1dHMgJGYgW2xpc3Qgc2V0IGZpbmRtZXJnZWZpbGVzICRmaW5kbWVyZ2VmaWxlc10KCXB1dHMgJGYgW2xpc3Qgc2V0IG1heGdyYXBocGN0ICRtYXhncmFwaHBjdF0KCXB1dHMgJGYgW2xpc3Qgc2V0IG1heHdpZHRoICRtYXh3aWR0aF0KCXB1dHMgJGYgW2xpc3Qgc2V0IGNtaXRtb2RlICRjbWl0bW9kZV0KCXB1dHMgJGYgW2xpc3Qgc2V0IHdyYXBjb21tZW50ICR3cmFwY29tbWVudF0KCXB1dHMgJGYgW2xpc3Qgc2V0IHNob3duZWFydGFncyAkc2hvd25lYXJ0YWdzXQoJcHV0cyAkZiBbbGlzdCBzZXQgc2hvd2xvY2FsY2hhbmdlcyAkc2hvd2xvY2FsY2hhbmdlc10KCXB1dHMgJGYgW2xpc3Qgc2V0IGJnY29sb3IgJGJnY29sb3JdCglwdXRzICRmIFtsaXN0IHNldCBmZ2NvbG9yICRmZ2NvbG9yXQoJcHV0cyAkZiBbbGlzdCBzZXQgY29sb3JzICRjb2xvcnNdCglwdXRzICRmIFtsaXN0IHNldCBkaWZmY29sb3JzICRkaWZmY29sb3JzXQoJcHV0cyAkZiBbbGlzdCBzZXQgc2VsZWN0Ymdjb2xvciAkc2VsZWN0Ymdjb2xvcl0KCglwdXRzICRmICJzZXQgZ2VvbWV0cnkobWFpbikgW3dtIGdlb21ldHJ5IC5dIgoJcHV0cyAkZiAic2V0IGdlb21ldHJ5KHRvcHdpZHRoKSBbd2luZm8gd2lkdGggLnRmXSIKCXB1dHMgJGYgInNldCBnZW9tZXRyeSh0b3BoZWlnaHQpIFt3aW5mbyBoZWlnaHQgLnRmXSIKICAgICAgICBwdXRzICRmICJzZXQgZ2VvbWV0cnkocHdzYXNoMCkgXCJbLnRmLmhpc3RmcmFtZS5wd2NsaXN0IHNhc2ggY29vcmQgMF1cIiIKICAgICAgICBwdXRzICRmICJzZXQgZ2VvbWV0cnkocHdzYXNoMSkgXCJbLnRmLmhpc3RmcmFtZS5wd2NsaXN0IHNhc2ggY29vcmQgMV1cIiIKCXB1dHMgJGYgInNldCBnZW9tZXRyeShib3R3aWR0aCkgW3dpbmZvIHdpZHRoIC5ibGVmdF0iCglwdXRzICRmICJzZXQgZ2VvbWV0cnkoYm90aGVpZ2h0KSBbd2luZm8gaGVpZ2h0IC5ibGVmdF0iCgoJcHV0cyAtbm9uZXdsaW5lICRmICJzZXQgcGVybXZpZXdzIHsiCglmb3Ige3NldCB2IDB9IHskdiA8ICRuZXh0dmlld251bX0ge2luY3Igdn0gewoJICAgIGlmIHskdmlld3Blcm0oJHYpfSB7CgkJcHV0cyAkZiAie1tsaXN0ICR2aWV3bmFtZSgkdikgJHZpZXdmaWxlcygkdikgJHZpZXdhcmdzKCR2KV19IgoJICAgIH0KCX0KCXB1dHMgJGYgIn0iCgljbG9zZSAkZgoJZmlsZSByZW5hbWUgLWZvcmNlICJ+Ly5naXRrLW5ldyIgIn4vLmdpdGsiCiAgICB9CiAgICBzZXQgc3R1ZmZzYXZlZCAxCn0KCnByb2MgcmVzaXplY2xpc3RwYW5lcyB7d2luIHd9IHsKICAgIGdsb2JhbCBvbGR3aWR0aAogICAgaWYge1tpbmZvIGV4aXN0cyBvbGR3aWR0aCgkd2luKV19IHsKCXNldCBzMCBbJHdpbiBzYXNoIGNvb3JkIDBdCglzZXQgczEgWyR3aW4gc2FzaCBjb29yZCAxXQoJaWYgeyR3IDwgNjB9IHsKCSAgICBzZXQgc2FzaDAgW2V4cHIge2ludCgkdy8yIC0gMil9XQoJICAgIHNldCBzYXNoMSBbZXhwciB7aW50KCR3KjUvNiAtIDIpfV0KCX0gZWxzZSB7CgkgICAgc2V0IGZhY3RvciBbZXhwciB7MS4wICogJHcgLyAkb2xkd2lkdGgoJHdpbil9XQoJICAgIHNldCBzYXNoMCBbZXhwciB7aW50KCRmYWN0b3IgKiBbbGluZGV4ICRzMCAwXSl9XQoJICAgIHNldCBzYXNoMSBbZXhwciB7aW50KCRmYWN0b3IgKiBbbGluZGV4ICRzMSAwXSl9XQoJICAgIGlmIHskc2FzaDAgPCAzMH0gewoJCXNldCBzYXNoMCAzMAoJICAgIH0KCSAgICBpZiB7JHNhc2gxIDwgJHNhc2gwICsgMjB9IHsKCQlzZXQgc2FzaDEgW2V4cHIgeyRzYXNoMCArIDIwfV0KCSAgICB9CgkgICAgaWYgeyRzYXNoMSA+ICR3IC0gMTB9IHsKCQlzZXQgc2FzaDEgW2V4cHIgeyR3IC0gMTB9XQoJCWlmIHskc2FzaDAgPiAkc2FzaDEgLSAyMH0gewoJCSAgICBzZXQgc2FzaDAgW2V4cHIgeyRzYXNoMSAtIDIwfV0KCQl9CgkgICAgfQoJfQoJJHdpbiBzYXNoIHBsYWNlIDAgJHNhc2gwIFtsaW5kZXggJHMwIDFdCgkkd2luIHNhc2ggcGxhY2UgMSAkc2FzaDEgW2xpbmRleCAkczEgMV0KICAgIH0KICAgIHNldCBvbGR3aWR0aCgkd2luKSAkdwp9Cgpwcm9jIHJlc2l6ZWNkZXRwYW5lcyB7d2luIHd9IHsKICAgIGdsb2JhbCBvbGR3aWR0aAogICAgaWYge1tpbmZvIGV4aXN0cyBvbGR3aWR0aCgkd2luKV19IHsKCXNldCBzMCBbJHdpbiBzYXNoIGNvb3JkIDBdCglpZiB7JHcgPCA2MH0gewoJICAgIHNldCBzYXNoMCBbZXhwciB7aW50KCR3KjMvNCAtIDIpfV0KCX0gZWxzZSB7CgkgICAgc2V0IGZhY3RvciBbZXhwciB7MS4wICogJHcgLyAkb2xkd2lkdGgoJHdpbil9XQoJICAgIHNldCBzYXNoMCBbZXhwciB7aW50KCRmYWN0b3IgKiBbbGluZGV4ICRzMCAwXSl9XQoJICAgIGlmIHskc2FzaDAgPCA0NX0gewoJCXNldCBzYXNoMCA0NQoJICAgIH0KCSAgICBpZiB7JHNhc2gwID4gJHcgLSAxNX0gewoJCXNldCBzYXNoMCBbZXhwciB7JHcgLSAxNX1dCgkgICAgfQoJfQoJJHdpbiBzYXNoIHBsYWNlIDAgJHNhc2gwIFtsaW5kZXggJHMwIDFdCiAgICB9CiAgICBzZXQgb2xkd2lkdGgoJHdpbikgJHcKfQoKcHJvYyBhbGxjYW52cyBhcmdzIHsKICAgIGdsb2JhbCBjYW52IGNhbnYyIGNhbnYzCiAgICBldmFsICRjYW52ICRhcmdzCiAgICBldmFsICRjYW52MiAkYXJncwogICAgZXZhbCAkY2FudjMgJGFyZ3MKfQoKcHJvYyBiaW5kYWxsIHtldmVudCBhY3Rpb259IHsKICAgIGdsb2JhbCBjYW52IGNhbnYyIGNhbnYzCiAgICBiaW5kICRjYW52ICRldmVudCAkYWN0aW9uCiAgICBiaW5kICRjYW52MiAkZXZlbnQgJGFjdGlvbgogICAgYmluZCAkY2FudjMgJGV2ZW50ICRhY3Rpb24KfQoKcHJvYyBhYm91dCB7fSB7CiAgICBnbG9iYWwgdWlmb250CiAgICBzZXQgdyAuYWJvdXQKICAgIGlmIHtbd2luZm8gZXhpc3RzICR3XX0gewoJcmFpc2UgJHcKCXJldHVybgogICAgfQogICAgdG9wbGV2ZWwgJHcKICAgIHdtIHRpdGxlICR3ICJBYm91dCBnaXRrIgogICAgbWVzc2FnZSAkdy5tIC10ZXh0IHsKR2l0ayAtIGEgY29tbWl0IHZpZXdlciBmb3IgZ2l0CgpDb3B5cmlnaHQgqSAyMDA1LTIwMDYgUGF1bCBNYWNrZXJyYXMKClVzZSBhbmQgcmVkaXN0cmlidXRlIHVuZGVyIHRoZSB0ZXJtcyBvZiB0aGUgR05VIEdlbmVyYWwgUHVibGljIExpY2Vuc2V9IFwKCSAgICAtanVzdGlmeSBjZW50ZXIgLWFzcGVjdCA0MDAgLWJvcmRlciAyIC1iZyB3aGl0ZSAtcmVsaWVmIGdyb292ZQogICAgcGFjayAkdy5tIC1zaWRlIHRvcCAtZmlsbCB4IC1wYWR4IDIgLXBhZHkgMgogICAgJHcubSBjb25maWd1cmUgLWZvbnQgJHVpZm9udAogICAgYnV0dG9uICR3Lm9rIC10ZXh0IENsb3NlIC1jb21tYW5kICJkZXN0cm95ICR3IiAtZGVmYXVsdCBhY3RpdmUKICAgIHBhY2sgJHcub2sgLXNpZGUgYm90dG9tCiAgICAkdy5vayBjb25maWd1cmUgLWZvbnQgJHVpZm9udAogICAgYmluZCAkdyA8VmlzaWJpbGl0eT4gImZvY3VzICR3Lm9rIgogICAgYmluZCAkdyA8S2V5LUVzY2FwZT4gImRlc3Ryb3kgJHciCiAgICBiaW5kICR3IDxLZXktUmV0dXJuPiAiZGVzdHJveSAkdyIKfQoKcHJvYyBrZXlzIHt9IHsKICAgIGdsb2JhbCB1aWZvbnQKICAgIHNldCB3IC5rZXlzCiAgICBpZiB7W3dpbmZvIGV4aXN0cyAkd119IHsKCXJhaXNlICR3CglyZXR1cm4KICAgIH0KICAgIGlmIHtbdGsgd2luZG93aW5nc3lzdGVtXSBlcSB7YXF1YX19IHsKCXNldCBNMVQgQ21kCiAgICB9IGVsc2UgewoJc2V0IE0xVCBDdHJsCiAgICB9CiAgICB0b3BsZXZlbCAkdwogICAgd20gdGl0bGUgJHcgIkdpdGsga2V5IGJpbmRpbmdzIgogICAgbWVzc2FnZSAkdy5tIC10ZXh0ICIKR2l0ayBrZXkgYmluZGluZ3M6Cgo8JE0xVC1RPgkJUXVpdAo8SG9tZT4JCU1vdmUgdG8gZmlyc3QgY29tbWl0CjxFbmQ+CQlNb3ZlIHRvIGxhc3QgY29tbWl0CjxVcD4sIHAsIGkJTW92ZSB1cCBvbmUgY29tbWl0CjxEb3duPiwgbiwgawlNb3ZlIGRvd24gb25lIGNvbW1pdAo8TGVmdD4sIHosIGoJR28gYmFjayBpbiBoaXN0b3J5IGxpc3QKPFJpZ2h0PiwgeCwgbAlHbyBmb3J3YXJkIGluIGhpc3RvcnkgbGlzdAo8UGFnZVVwPglNb3ZlIHVwIG9uZSBwYWdlIGluIGNvbW1pdCBsaXN0CjxQYWdlRG93bj4JTW92ZSBkb3duIG9uZSBwYWdlIGluIGNvbW1pdCBsaXN0CjwkTTFULUhvbWU+CVNjcm9sbCB0byB0b3Agb2YgY29tbWl0IGxpc3QKPCRNMVQtRW5kPglTY3JvbGwgdG8gYm90dG9tIG9mIGNvbW1pdCBsaXN0CjwkTTFULVVwPglTY3JvbGwgY29tbWl0IGxpc3QgdXAgb25lIGxpbmUKPCRNMVQtRG93bj4JU2Nyb2xsIGNvbW1pdCBsaXN0IGRvd24gb25lIGxpbmUKPCRNMVQtUGFnZVVwPglTY3JvbGwgY29tbWl0IGxpc3QgdXAgb25lIHBhZ2UKPCRNMVQtUGFnZURvd24+CVNjcm9sbCBjb21taXQgbGlzdCBkb3duIG9uZSBwYWdlCjxTaGlmdC1VcD4JTW92ZSB0byBwcmV2aW91cyBoaWdobGlnaHRlZCBsaW5lCjxTaGlmdC1Eb3duPglNb3ZlIHRvIG5leHQgaGlnaGxpZ2h0ZWQgbGluZQo8RGVsZXRlPiwgYglTY3JvbGwgZGlmZiB2aWV3IHVwIG9uZSBwYWdlCjxCYWNrc3BhY2U+CVNjcm9sbCBkaWZmIHZpZXcgdXAgb25lIHBhZ2UKPFNwYWNlPgkJU2Nyb2xsIGRpZmYgdmlldyBkb3duIG9uZSBwYWdlCnUJCVNjcm9sbCBkaWZmIHZpZXcgdXAgMTggbGluZXMKZAkJU2Nyb2xsIGRpZmYgdmlldyBkb3duIDE4IGxpbmVzCjwkTTFULUY+CQlGaW5kCjwkTTFULUc+CQlNb3ZlIHRvIG5leHQgZmluZCBoaXQKPFJldHVybj4JTW92ZSB0byBuZXh0IGZpbmQgaGl0Ci8JCU1vdmUgdG8gbmV4dCBmaW5kIGhpdCwgb3IgcmVkbyBmaW5kCj8JCU1vdmUgdG8gcHJldmlvdXMgZmluZCBoaXQKZgkJU2Nyb2xsIGRpZmYgdmlldyB0byBuZXh0IGZpbGUKPCRNMVQtUz4JCVNlYXJjaCBmb3IgbmV4dCBoaXQgaW4gZGlmZiB2aWV3CjwkTTFULVI+CQlTZWFyY2ggZm9yIHByZXZpb3VzIGhpdCBpbiBkaWZmIHZpZXcKPCRNMVQtS1ArPglJbmNyZWFzZSBmb250IHNpemUKPCRNMVQtcGx1cz4JSW5jcmVhc2UgZm9udCBzaXplCjwkTTFULUtQLT4JRGVjcmVhc2UgZm9udCBzaXplCjwkTTFULW1pbnVzPglEZWNyZWFzZSBmb250IHNpemUKPEY1PgkJVXBkYXRlCiIgXAoJICAgIC1qdXN0aWZ5IGxlZnQgLWJnIHdoaXRlIC1ib3JkZXIgMiAtcmVsaWVmIGdyb292ZQogICAgcGFjayAkdy5tIC1zaWRlIHRvcCAtZmlsbCBib3RoIC1wYWR4IDIgLXBhZHkgMgogICAgJHcubSBjb25maWd1cmUgLWZvbnQgJHVpZm9udAogICAgYnV0dG9uICR3Lm9rIC10ZXh0IENsb3NlIC1jb21tYW5kICJkZXN0cm95ICR3IiAtZGVmYXVsdCBhY3RpdmUKICAgIHBhY2sgJHcub2sgLXNpZGUgYm90dG9tCiAgICAkdy5vayBjb25maWd1cmUgLWZvbnQgJHVpZm9udAogICAgYmluZCAkdyA8VmlzaWJpbGl0eT4gImZvY3VzICR3Lm9rIgogICAgYmluZCAkdyA8S2V5LUVzY2FwZT4gImRlc3Ryb3kgJHciCiAgICBiaW5kICR3IDxLZXktUmV0dXJuPiAiZGVzdHJveSAkdyIKfQoKIyBQcm9jZWR1cmVzIGZvciBtYW5pcHVsYXRpbmcgdGhlIGZpbGUgbGlzdCB3aW5kb3cgYXQgdGhlCiMgYm90dG9tIHJpZ2h0IG9mIHRoZSBvdmVyYWxsIHdpbmRvdy4KCnByb2MgdHJlZXZpZXcge3cgbCBvcGVubGV2c30gewogICAgZ2xvYmFsIHRyZWVjb250ZW50cyB0cmVlZGlyb3BlbiB0cmVlaGVpZ2h0IHRyZWVwYXJlbnQgdHJlZWluZGV4CgogICAgc2V0IGl4IDAKICAgIHNldCB0cmVlaW5kZXgoKSAwCiAgICBzZXQgbGV2IDAKICAgIHNldCBwcmVmaXgge30KICAgIHNldCBwcmVmaXhlbmQgLTEKICAgIHNldCBwcmVmZW5kc3RhY2sge30KICAgIHNldCBodHN0YWNrIHt9CiAgICBzZXQgaHQgMAogICAgc2V0IHRyZWVjb250ZW50cygpIHt9CiAgICAkdyBjb25mIC1zdGF0ZSBub3JtYWwKICAgIGZvcmVhY2ggZiAkbCB7Cgl3aGlsZSB7W3N0cmluZyByYW5nZSAkZiAwICRwcmVmaXhlbmRdIG5lICRwcmVmaXh9IHsKCSAgICBpZiB7JGxldiA8PSAkb3BlbmxldnN9IHsKCQkkdyBtYXJrIHNldCBlOiR0cmVlaW5kZXgoJHByZWZpeCkgImVuZCAtMWMiCgkJJHcgbWFyayBncmF2aXR5IGU6JHRyZWVpbmRleCgkcHJlZml4KSBsZWZ0CgkgICAgfQoJICAgIHNldCB0cmVlaGVpZ2h0KCRwcmVmaXgpICRodAoJICAgIGluY3IgaHQgW2xpbmRleCAkaHRzdGFjayBlbmRdCgkgICAgc2V0IGh0c3RhY2sgW2xyZXBsYWNlICRodHN0YWNrIGVuZCBlbmRdCgkgICAgc2V0IHByZWZpeGVuZCBbbGluZGV4ICRwcmVmZW5kc3RhY2sgZW5kXQoJICAgIHNldCBwcmVmZW5kc3RhY2sgW2xyZXBsYWNlICRwcmVmZW5kc3RhY2sgZW5kIGVuZF0KCSAgICBzZXQgcHJlZml4IFtzdHJpbmcgcmFuZ2UgJHByZWZpeCAwICRwcmVmaXhlbmRdCgkgICAgaW5jciBsZXYgLTEKCX0KCXNldCB0YWlsIFtzdHJpbmcgcmFuZ2UgJGYgW2V4cHIgeyRwcmVmaXhlbmQrMX1dIGVuZF0KCXdoaWxlIHtbc2V0IHNsYXNoIFtzdHJpbmcgZmlyc3QgIi8iICR0YWlsXV0gPj0gMH0gewoJICAgIGxhcHBlbmQgaHRzdGFjayAkaHQKCSAgICBzZXQgaHQgMAoJICAgIGxhcHBlbmQgcHJlZmVuZHN0YWNrICRwcmVmaXhlbmQKCSAgICBpbmNyIHByZWZpeGVuZCBbZXhwciB7JHNsYXNoICsgMX1dCgkgICAgc2V0IGQgW3N0cmluZyByYW5nZSAkdGFpbCAwICRzbGFzaF0KCSAgICBsYXBwZW5kIHRyZWVjb250ZW50cygkcHJlZml4KSAkZAoJICAgIHNldCBvbGRwcmVmaXggJHByZWZpeAoJICAgIGFwcGVuZCBwcmVmaXggJGQKCSAgICBzZXQgdHJlZWNvbnRlbnRzKCRwcmVmaXgpIHt9CgkgICAgc2V0IHRyZWVpbmRleCgkcHJlZml4KSBbaW5jciBpeF0KCSAgICBzZXQgdHJlZXBhcmVudCgkcHJlZml4KSAkb2xkcHJlZml4CgkgICAgc2V0IHRhaWwgW3N0cmluZyByYW5nZSAkdGFpbCBbZXhwciB7JHNsYXNoKzF9XSBlbmRdCgkgICAgaWYgeyRsZXYgPD0gJG9wZW5sZXZzfSB7CgkJc2V0IGh0IDEKCQlzZXQgdHJlZWRpcm9wZW4oJHByZWZpeCkgW2V4cHIgeyRsZXYgPCAkb3BlbmxldnN9XQoJCXNldCBibSBbZXhwciB7JGxldiA9PSAkb3BlbmxldnM/ICJ0cmktcnQiOiAidHJpLWRuIn1dCgkJJHcgbWFyayBzZXQgZDokaXggImVuZCAtMWMiCgkJJHcgbWFyayBncmF2aXR5IGQ6JGl4IGxlZnQKCQlzZXQgc3RyICJcbiIKCQlmb3Ige3NldCBpIDB9IHskaSA8ICRsZXZ9IHtpbmNyIGl9IHthcHBlbmQgc3RyICJcdCJ9CgkJJHcgaW5zZXJ0IGVuZCAkc3RyCgkJJHcgaW1hZ2UgY3JlYXRlIGVuZCAtYWxpZ24gY2VudGVyIC1pbWFnZSAkYm0gLXBhZHggMSBcCgkJICAgIC1uYW1lIGE6JGl4CgkJJHcgaW5zZXJ0IGVuZCAkZCBbaGlnaGxpZ2h0X3RhZyAkcHJlZml4XQoJCSR3IG1hcmsgc2V0IHM6JGl4ICJlbmQgLTFjIgoJCSR3IG1hcmsgZ3Jhdml0eSBzOiRpeCBsZWZ0CgkgICAgfQoJICAgIGluY3IgbGV2Cgl9CglpZiB7JHRhaWwgbmUge319IHsKCSAgICBpZiB7JGxldiA8PSAkb3BlbmxldnN9IHsKCQlpbmNyIGh0CgkJc2V0IHN0ciAiXG4iCgkJZm9yIHtzZXQgaSAwfSB7JGkgPCAkbGV2fSB7aW5jciBpfSB7YXBwZW5kIHN0ciAiXHQifQoJCSR3IGluc2VydCBlbmQgJHN0cgoJCSR3IGluc2VydCBlbmQgJHRhaWwgW2hpZ2hsaWdodF90YWcgJGZdCgkgICAgfQoJICAgIGxhcHBlbmQgdHJlZWNvbnRlbnRzKCRwcmVmaXgpICR0YWlsCgl9CiAgICB9CiAgICB3aGlsZSB7JGh0c3RhY2sgbmUge319IHsKCXNldCB0cmVlaGVpZ2h0KCRwcmVmaXgpICRodAoJaW5jciBodCBbbGluZGV4ICRodHN0YWNrIGVuZF0KCXNldCBodHN0YWNrIFtscmVwbGFjZSAkaHRzdGFjayBlbmQgZW5kXQoJc2V0IHByZWZpeGVuZCBbbGluZGV4ICRwcmVmZW5kc3RhY2sgZW5kXQoJc2V0IHByZWZlbmRzdGFjayBbbHJlcGxhY2UgJHByZWZlbmRzdGFjayBlbmQgZW5kXQoJc2V0IHByZWZpeCBbc3RyaW5nIHJhbmdlICRwcmVmaXggMCAkcHJlZml4ZW5kXQogICAgfQogICAgJHcgY29uZiAtc3RhdGUgZGlzYWJsZWQKfQoKcHJvYyBsaW5ldG9lbHQge2x9IHsKICAgIGdsb2JhbCB0cmVlaGVpZ2h0IHRyZWVjb250ZW50cwoKICAgIHNldCB5IDIKICAgIHNldCBwcmVmaXgge30KICAgIHdoaWxlIHsxfSB7Cglmb3JlYWNoIGUgJHRyZWVjb250ZW50cygkcHJlZml4KSB7CgkgICAgaWYgeyR5ID09ICRsfSB7CgkJcmV0dXJuICIkcHJlZml4JGUiCgkgICAgfQoJICAgIHNldCBuIDEKCSAgICBpZiB7W3N0cmluZyBpbmRleCAkZSBlbmRdIGVxICIvIn0gewoJCXNldCBuICR0cmVlaGVpZ2h0KCRwcmVmaXgkZSkKCQlpZiB7JHkgKyAkbiA+ICRsfSB7CgkJICAgIGFwcGVuZCBwcmVmaXggJGUKCQkgICAgaW5jciB5CgkJICAgIGJyZWFrCgkJfQoJICAgIH0KCSAgICBpbmNyIHkgJG4KCX0KICAgIH0KfQoKcHJvYyBoaWdobGlnaHRfdHJlZSB7eSBwcmVmaXh9IHsKICAgIGdsb2JhbCB0cmVlaGVpZ2h0IHRyZWVjb250ZW50cyBjZmxpc3QKCiAgICBmb3JlYWNoIGUgJHRyZWVjb250ZW50cygkcHJlZml4KSB7CglzZXQgcGF0aCAkcHJlZml4JGUKCWlmIHtbaGlnaGxpZ2h0X3RhZyAkcGF0aF0gbmUge319IHsKCSAgICAkY2ZsaXN0IHRhZyBhZGQgYm9sZCAkeS4wICIkeS4wIGxpbmVlbmQiCgl9CglpbmNyIHkKCWlmIHtbc3RyaW5nIGluZGV4ICRlIGVuZF0gZXEgIi8iICYmICR0cmVlaGVpZ2h0KCRwYXRoKSA+IDF9IHsKCSAgICBzZXQgeSBbaGlnaGxpZ2h0X3RyZWUgJHkgJHBhdGhdCgl9CiAgICB9CiAgICByZXR1cm4gJHkKfQoKcHJvYyB0cmVlY2xvc2VkaXIge3cgZGlyfSB7CiAgICBnbG9iYWwgdHJlZWRpcm9wZW4gdHJlZWhlaWdodCB0cmVlcGFyZW50IHRyZWVpbmRleAoKICAgIHNldCBpeCAkdHJlZWluZGV4KCRkaXIpCiAgICAkdyBjb25mIC1zdGF0ZSBub3JtYWwKICAgICR3IGRlbGV0ZSBzOiRpeCBlOiRpeAogICAgc2V0IHRyZWVkaXJvcGVuKCRkaXIpIDAKICAgICR3IGltYWdlIGNvbmZpZ3VyZSBhOiRpeCAtaW1hZ2UgdHJpLXJ0CiAgICAkdyBjb25mIC1zdGF0ZSBkaXNhYmxlZAogICAgc2V0IG4gW2V4cHIgezEgLSAkdHJlZWhlaWdodCgkZGlyKX1dCiAgICB3aGlsZSB7JGRpciBuZSB7fX0gewoJaW5jciB0cmVlaGVpZ2h0KCRkaXIpICRuCglzZXQgZGlyICR0cmVlcGFyZW50KCRkaXIpCiAgICB9Cn0KCnByb2MgdHJlZW9wZW5kaXIge3cgZGlyfSB7CiAgICBnbG9iYWwgdHJlZWRpcm9wZW4gdHJlZWhlaWdodCB0cmVlcGFyZW50IHRyZWVjb250ZW50cyB0cmVlaW5kZXgKCiAgICBzZXQgaXggJHRyZWVpbmRleCgkZGlyKQogICAgJHcgY29uZiAtc3RhdGUgbm9ybWFsCiAgICAkdyBpbWFnZSBjb25maWd1cmUgYTokaXggLWltYWdlIHRyaS1kbgogICAgJHcgbWFyayBzZXQgZTokaXggczokaXgKICAgICR3IG1hcmsgZ3Jhdml0eSBlOiRpeCByaWdodAogICAgc2V0IGxldiAwCiAgICBzZXQgc3RyICJcbiIKICAgIHNldCBuIFtsbGVuZ3RoICR0cmVlY29udGVudHMoJGRpcildCiAgICBmb3Ige3NldCB4ICRkaXJ9IHskeCBuZSB7fX0ge3NldCB4ICR0cmVlcGFyZW50KCR4KX0gewoJaW5jciBsZXYKCWFwcGVuZCBzdHIgIlx0IgoJaW5jciB0cmVlaGVpZ2h0KCR4KSAkbgogICAgfQogICAgZm9yZWFjaCBlICR0cmVlY29udGVudHMoJGRpcikgewoJc2V0IGRlICRkaXIkZQoJaWYge1tzdHJpbmcgaW5kZXggJGUgZW5kXSBlcSAiLyJ9IHsKCSAgICBzZXQgaXkgJHRyZWVpbmRleCgkZGUpCgkgICAgJHcgbWFyayBzZXQgZDokaXkgZTokaXgKCSAgICAkdyBtYXJrIGdyYXZpdHkgZDokaXkgbGVmdAoJICAgICR3IGluc2VydCBlOiRpeCAkc3RyCgkgICAgc2V0IHRyZWVkaXJvcGVuKCRkZSkgMAoJICAgICR3IGltYWdlIGNyZWF0ZSBlOiRpeCAtYWxpZ24gY2VudGVyIC1pbWFnZSB0cmktcnQgLXBhZHggMSBcCgkJLW5hbWUgYTokaXkKCSAgICAkdyBpbnNlcnQgZTokaXggJGUgW2hpZ2hsaWdodF90YWcgJGRlXQoJICAgICR3IG1hcmsgc2V0IHM6JGl5IGU6JGl4CgkgICAgJHcgbWFyayBncmF2aXR5IHM6JGl5IGxlZnQKCSAgICBzZXQgdHJlZWhlaWdodCgkZGUpIDEKCX0gZWxzZSB7CgkgICAgJHcgaW5zZXJ0IGU6JGl4ICRzdHIKCSAgICAkdyBpbnNlcnQgZTokaXggJGUgW2hpZ2hsaWdodF90YWcgJGRlXQoJfQogICAgfQogICAgJHcgbWFyayBncmF2aXR5IGU6JGl4IGxlZnQKICAgICR3IGNvbmYgLXN0YXRlIGRpc2FibGVkCiAgICBzZXQgdHJlZWRpcm9wZW4oJGRpcikgMQogICAgc2V0IHRvcCBbbGluZGV4IFtzcGxpdCBbJHcgaW5kZXggQDAsMF0gLl0gMF0KICAgIHNldCBodCBbJHcgY2dldCAtaGVpZ2h0XQogICAgc2V0IGwgW2xpbmRleCBbc3BsaXQgWyR3IGluZGV4IHM6JGl4XSAuXSAwXQogICAgaWYgeyRsIDwgJHRvcH0gewoJJHcgeXZpZXcgJGwuMAogICAgfSBlbHNlaWYgeyRsICsgJG4gKyAxID4gJHRvcCArICRodH0gewoJc2V0IHRvcCBbZXhwciB7JGwgKyAkbiArIDIgLSAkaHR9XQoJaWYgeyRsIDwgJHRvcH0gewoJICAgIHNldCB0b3AgJGwKCX0KCSR3IHl2aWV3ICR0b3AuMAogICAgfQp9Cgpwcm9jIHRyZWVjbGljayB7dyB4IHl9IHsKICAgIGdsb2JhbCB0cmVlZGlyb3BlbiBjbWl0bW9kZSBjdGV4dCBjZmxpc3QgY2ZsaXN0X3RvcAoKICAgIGlmIHskY21pdG1vZGUgbmUgInRyZWUifSByZXR1cm4KICAgIGlmIHshW2luZm8gZXhpc3RzIGNmbGlzdF90b3BdfSByZXR1cm4KICAgIHNldCBsIFtsaW5kZXggW3NwbGl0IFskdyBpbmRleCAiQCR4LCR5Il0gIi4iXSAwXQogICAgJGNmbGlzdCB0YWcgcmVtb3ZlIGhpZ2hsaWdodCAkY2ZsaXN0X3RvcC4wICIkY2ZsaXN0X3RvcC4wIGxpbmVlbmQiCiAgICAkY2ZsaXN0IHRhZyBhZGQgaGlnaGxpZ2h0ICRsLjAgIiRsLjAgbGluZWVuZCIKICAgIHNldCBjZmxpc3RfdG9wICRsCiAgICBpZiB7JGwgPT0gMX0gewoJJGN0ZXh0IHl2aWV3IDEuMAoJcmV0dXJuCiAgICB9CiAgICBzZXQgZSBbbGluZXRvZWx0ICRsXQogICAgaWYge1tzdHJpbmcgaW5kZXggJGUgZW5kXSBuZSAiLyJ9IHsKCXNob3dmaWxlICRlCiAgICB9IGVsc2VpZiB7JHRyZWVkaXJvcGVuKCRlKX0gewoJdHJlZWNsb3NlZGlyICR3ICRlCiAgICB9IGVsc2UgewoJdHJlZW9wZW5kaXIgJHcgJGUKICAgIH0KfQoKcHJvYyBzZXRmaWxlbGlzdCB7aWR9IHsKICAgIGdsb2JhbCB0cmVlZmlsZWxpc3QgY2ZsaXN0CgogICAgdHJlZXZpZXcgJGNmbGlzdCAkdHJlZWZpbGVsaXN0KCRpZCkgMAp9CgppbWFnZSBjcmVhdGUgYml0bWFwIHRyaS1ydCAtYmFja2dyb3VuZCBibGFjayAtZm9yZWdyb3VuZCBibHVlIC1kYXRhIHsKICAgICNkZWZpbmUgdHJpLXJ0X3dpZHRoIDEzCiAgICAjZGVmaW5lIHRyaS1ydF9oZWlnaHQgMTMKICAgIHN0YXRpYyB1bnNpZ25lZCBjaGFyIHRyaS1ydF9iaXRzW10gPSB7CiAgICAgICAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDEwLCAweDAwLCAweDMwLCAweDAwLCAweDcwLCAweDAwLCAweGYwLCAweDAwLAogICAgICAgMHhmMCwgMHgwMSwgMHhmMCwgMHgwMCwgMHg3MCwgMHgwMCwgMHgzMCwgMHgwMCwgMHgxMCwgMHgwMCwgMHgwMCwgMHgwMCwKICAgICAgIDB4MDAsIDB4MDB9Owp9IC1tYXNrZGF0YSB7CiAgICAjZGVmaW5lIHRyaS1ydC1tYXNrX3dpZHRoIDEzCiAgICAjZGVmaW5lIHRyaS1ydC1tYXNrX2hlaWdodCAxMwogICAgc3RhdGljIHVuc2lnbmVkIGNoYXIgdHJpLXJ0LW1hc2tfYml0c1tdID0gewogICAgICAgMHgwOCwgMHgwMCwgMHgxOCwgMHgwMCwgMHgzOCwgMHgwMCwgMHg3OCwgMHgwMCwgMHhmOCwgMHgwMCwgMHhmOCwgMHgwMSwKICAgICAgIDB4ZjgsIDB4MDMsIDB4ZjgsIDB4MDEsIDB4ZjgsIDB4MDAsIDB4NzgsIDB4MDAsIDB4MzgsIDB4MDAsIDB4MTgsIDB4MDAsCiAgICAgICAweDA4LCAweDAwfTsKfQppbWFnZSBjcmVhdGUgYml0bWFwIHRyaS1kbiAtYmFja2dyb3VuZCBibGFjayAtZm9yZWdyb3VuZCBibHVlIC1kYXRhIHsKICAgICNkZWZpbmUgdHJpLWRuX3dpZHRoIDEzCiAgICAjZGVmaW5lIHRyaS1kbl9oZWlnaHQgMTMKICAgIHN0YXRpYyB1bnNpZ25lZCBjaGFyIHRyaS1kbl9iaXRzW10gPSB7CiAgICAgICAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweDAwLCAweGZjLCAweDA3LCAweGY4LCAweDAzLAogICAgICAgMHhmMCwgMHgwMSwgMHhlMCwgMHgwMCwgMHg0MCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwKICAgICAgIDB4MDAsIDB4MDB9Owp9IC1tYXNrZGF0YSB7CiAgICAjZGVmaW5lIHRyaS1kbi1tYXNrX3dpZHRoIDEzCiAgICAjZGVmaW5lIHRyaS1kbi1tYXNrX2hlaWdodCAxMwogICAgc3RhdGljIHVuc2lnbmVkIGNoYXIgdHJpLWRuLW1hc2tfYml0c1tdID0gewogICAgICAgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHgwMCwgMHhmZiwgMHgxZiwgMHhmZSwgMHgwZiwgMHhmYywgMHgwNywKICAgICAgIDB4ZjgsIDB4MDMsIDB4ZjAsIDB4MDEsIDB4ZTAsIDB4MDAsIDB4NDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsIDB4MDAsCiAgICAgICAweDAwLCAweDAwfTsKfQoKcHJvYyBpbml0X2ZsaXN0IHtmaXJzdH0gewogICAgZ2xvYmFsIGNmbGlzdCBjZmxpc3RfdG9wIHNlbGVjdGVkbGluZSBkaWZmZmlsZXN0YXJ0CgogICAgJGNmbGlzdCBjb25mIC1zdGF0ZSBub3JtYWwKICAgICRjZmxpc3QgZGVsZXRlIDAuMCBlbmQKICAgIGlmIHskZmlyc3QgbmUge319IHsKCSRjZmxpc3QgaW5zZXJ0IGVuZCAkZmlyc3QKCXNldCBjZmxpc3RfdG9wIDEKCSRjZmxpc3QgdGFnIGFkZCBoaWdobGlnaHQgMS4wICIxLjAgbGluZWVuZCIKICAgIH0gZWxzZSB7CgljYXRjaCB7dW5zZXQgY2ZsaXN0X3RvcH0KICAgIH0KICAgICRjZmxpc3QgY29uZiAtc3RhdGUgZGlzYWJsZWQKICAgIHNldCBkaWZmZmlsZXN0YXJ0IHt9Cn0KCnByb2MgaGlnaGxpZ2h0X3RhZyB7Zn0gewogICAgZ2xvYmFsIGhpZ2hsaWdodF9wYXRocwoKICAgIGZvcmVhY2ggcCAkaGlnaGxpZ2h0X3BhdGhzIHsKCWlmIHtbc3RyaW5nIG1hdGNoICRwICRmXX0gewoJICAgIHJldHVybiAiYm9sZCIKCX0KICAgIH0KICAgIHJldHVybiB7fQp9Cgpwcm9jIGhpZ2hsaWdodF9maWxlbGlzdCB7fSB7CiAgICBnbG9iYWwgY21pdG1vZGUgY2ZsaXN0CgogICAgJGNmbGlzdCBjb25mIC1zdGF0ZSBub3JtYWwKICAgIGlmIHskY21pdG1vZGUgbmUgInRyZWUifSB7CglzZXQgZW5kIFtsaW5kZXggW3NwbGl0IFskY2ZsaXN0IGluZGV4IGVuZF0gLl0gMF0KCWZvciB7c2V0IGwgMn0geyRsIDwgJGVuZH0ge2luY3IgbH0gewoJICAgIHNldCBsaW5lIFskY2ZsaXN0IGdldCAkbC4wICIkbC4wIGxpbmVlbmQiXQoJICAgIGlmIHtbaGlnaGxpZ2h0X3RhZyAkbGluZV0gbmUge319IHsKCQkkY2ZsaXN0IHRhZyBhZGQgYm9sZCAkbC4wICIkbC4wIGxpbmVlbmQiCgkgICAgfQoJfQogICAgfSBlbHNlIHsKCWhpZ2hsaWdodF90cmVlIDIge30KICAgIH0KICAgICRjZmxpc3QgY29uZiAtc3RhdGUgZGlzYWJsZWQKfQoKcHJvYyB1bmhpZ2hsaWdodF9maWxlbGlzdCB7fSB7CiAgICBnbG9iYWwgY2ZsaXN0CgogICAgJGNmbGlzdCBjb25mIC1zdGF0ZSBub3JtYWwKICAgICRjZmxpc3QgdGFnIHJlbW92ZSBib2xkIDEuMCBlbmQKICAgICRjZmxpc3QgY29uZiAtc3RhdGUgZGlzYWJsZWQKfQoKcHJvYyBhZGRfZmxpc3Qge2ZsfSB7CiAgICBnbG9iYWwgY2ZsaXN0CgogICAgJGNmbGlzdCBjb25mIC1zdGF0ZSBub3JtYWwKICAgIGZvcmVhY2ggZiAkZmwgewoJJGNmbGlzdCBpbnNlcnQgZW5kICJcbiIKCSRjZmxpc3QgaW5zZXJ0IGVuZCAkZiBbaGlnaGxpZ2h0X3RhZyAkZl0KICAgIH0KICAgICRjZmxpc3QgY29uZiAtc3RhdGUgZGlzYWJsZWQKfQoKcHJvYyBzZWxfZmxpc3Qge3cgeCB5fSB7CiAgICBnbG9iYWwgY3RleHQgZGlmZmZpbGVzdGFydCBjZmxpc3QgY2ZsaXN0X3RvcCBjbWl0bW9kZQoKICAgIGlmIHskY21pdG1vZGUgZXEgInRyZWUifSByZXR1cm4KICAgIGlmIHshW2luZm8gZXhpc3RzIGNmbGlzdF90b3BdfSByZXR1cm4KICAgIHNldCBsIFtsaW5kZXggW3NwbGl0IFskdyBpbmRleCAiQCR4LCR5Il0gIi4iXSAwXQogICAgJGNmbGlzdCB0YWcgcmVtb3ZlIGhpZ2hsaWdodCAkY2ZsaXN0X3RvcC4wICIkY2ZsaXN0X3RvcC4wIGxpbmVlbmQiCiAgICAkY2ZsaXN0IHRhZyBhZGQgaGlnaGxpZ2h0ICRsLjAgIiRsLjAgbGluZWVuZCIKICAgIHNldCBjZmxpc3RfdG9wICRsCiAgICBpZiB7JGwgPT0gMX0gewoJJGN0ZXh0IHl2aWV3IDEuMAogICAgfSBlbHNlIHsKCWNhdGNoIHskY3RleHQgeXZpZXcgW2xpbmRleCAkZGlmZmZpbGVzdGFydCBbZXhwciB7JGwgLSAyfV1dfQogICAgfQp9CgojIEZ1bmN0aW9ucyBmb3IgYWRkaW5nIGFuZCByZW1vdmluZyBzaGVsbC10eXBlIHF1b3RpbmcKCnByb2Mgc2hlbGxxdW90ZSB7c3RyfSB7CiAgICBpZiB7IVtzdHJpbmcgbWF0Y2ggIipcWydcIlxcIFx0XSoiICRzdHJdfSB7CglyZXR1cm4gJHN0cgogICAgfQogICAgaWYgeyFbc3RyaW5nIG1hdGNoICIqXFsnXCJcXF0qIiAkc3RyXX0gewoJcmV0dXJuICJcIiRzdHJcIiIKICAgIH0KICAgIGlmIHshW3N0cmluZyBtYXRjaCAiKicqIiAkc3RyXX0gewoJcmV0dXJuICInJHN0ciciCiAgICB9CiAgICByZXR1cm4gIlwiW3N0cmluZyBtYXAge1wiIFxcXCIgXFwgXFxcXH0gJHN0cl1cIiIKfQoKcHJvYyBzaGVsbGFyZ2xpc3Qge2x9IHsKICAgIHNldCBzdHIge30KICAgIGZvcmVhY2ggYSAkbCB7CglpZiB7JHN0ciBuZSB7fX0gewoJICAgIGFwcGVuZCBzdHIgIiAiCgl9CglhcHBlbmQgc3RyIFtzaGVsbHF1b3RlICRhXQogICAgfQogICAgcmV0dXJuICRzdHIKfQoKcHJvYyBzaGVsbGRlcXVvdGUge3N0cn0gewogICAgc2V0IHJldCB7fQogICAgc2V0IHVzZWQgLTEKICAgIHdoaWxlIHsxfSB7CglpbmNyIHVzZWQKCWlmIHshW3JlZ2V4cCAtc3RhcnQgJHVzZWQgLWluZGljZXMgIlxbJ1wiXFxcXCBcdF0iICRzdHIgZmlyc3RdfSB7CgkgICAgYXBwZW5kIHJldCBbc3RyaW5nIHJhbmdlICRzdHIgJHVzZWQgZW5kXQoJICAgIHNldCB1c2VkIFtzdHJpbmcgbGVuZ3RoICRzdHJdCgkgICAgYnJlYWsKCX0KCXNldCBmaXJzdCBbbGluZGV4ICRmaXJzdCAwXQoJc2V0IGNoIFtzdHJpbmcgaW5kZXggJHN0ciAkZmlyc3RdCglpZiB7JGZpcnN0ID4gJHVzZWR9IHsKCSAgICBhcHBlbmQgcmV0IFtzdHJpbmcgcmFuZ2UgJHN0ciAkdXNlZCBbZXhwciB7JGZpcnN0IC0gMX1dXQoJICAgIHNldCB1c2VkICRmaXJzdAoJfQoJaWYgeyRjaCBlcSAiICIgfHwgJGNoIGVxICJcdCJ9IGJyZWFrCglpbmNyIHVzZWQKCWlmIHskY2ggZXEgIicifSB7CgkgICAgc2V0IGZpcnN0IFtzdHJpbmcgZmlyc3QgIiciICRzdHIgJHVzZWRdCgkgICAgaWYgeyRmaXJzdCA8IDB9IHsKCQllcnJvciAidW5tYXRjaGVkIHNpbmdsZS1xdW90ZSIKCSAgICB9CgkgICAgYXBwZW5kIHJldCBbc3RyaW5nIHJhbmdlICRzdHIgJHVzZWQgW2V4cHIgeyRmaXJzdCAtIDF9XV0KCSAgICBzZXQgdXNlZCAkZmlyc3QKCSAgICBjb250aW51ZQoJfQoJaWYgeyRjaCBlcSAiXFwifSB7CgkgICAgaWYgeyR1c2VkID49IFtzdHJpbmcgbGVuZ3RoICRzdHJdfSB7CgkJZXJyb3IgInRyYWlsaW5nIGJhY2tzbGFzaCIKCSAgICB9CgkgICAgYXBwZW5kIHJldCBbc3RyaW5nIGluZGV4ICRzdHIgJHVzZWRdCgkgICAgY29udGludWUKCX0KCSMgaGVyZSBjaCA9PSAiXCIiCgl3aGlsZSB7MX0gewoJICAgIGlmIHshW3JlZ2V4cCAtc3RhcnQgJHVzZWQgLWluZGljZXMgIlxbXCJcXFxcXSIgJHN0ciBmaXJzdF19IHsKCQllcnJvciAidW5tYXRjaGVkIGRvdWJsZS1xdW90ZSIKCSAgICB9CgkgICAgc2V0IGZpcnN0IFtsaW5kZXggJGZpcnN0IDBdCgkgICAgc2V0IGNoIFtzdHJpbmcgaW5kZXggJHN0ciAkZmlyc3RdCgkgICAgaWYgeyRmaXJzdCA+ICR1c2VkfSB7CgkJYXBwZW5kIHJldCBbc3RyaW5nIHJhbmdlICRzdHIgJHVzZWQgW2V4cHIgeyRmaXJzdCAtIDF9XV0KCQlzZXQgdXNlZCAkZmlyc3QKCSAgICB9CgkgICAgaWYgeyRjaCBlcSAiXCIifSBicmVhawoJICAgIGluY3IgdXNlZAoJICAgIGFwcGVuZCByZXQgW3N0cmluZyBpbmRleCAkc3RyICR1c2VkXQoJICAgIGluY3IgdXNlZAoJfQogICAgfQogICAgcmV0dXJuIFtsaXN0ICR1c2VkICRyZXRdCn0KCnByb2Mgc2hlbGxzcGxpdCB7c3RyfSB7CiAgICBzZXQgbCB7fQogICAgd2hpbGUgezF9IHsKCXNldCBzdHIgW3N0cmluZyB0cmltbGVmdCAkc3RyXQoJaWYgeyRzdHIgZXEge319IGJyZWFrCglzZXQgZHEgW3NoZWxsZGVxdW90ZSAkc3RyXQoJc2V0IG4gW2xpbmRleCAkZHEgMF0KCXNldCB3b3JkIFtsaW5kZXggJGRxIDFdCglzZXQgc3RyIFtzdHJpbmcgcmFuZ2UgJHN0ciAkbiBlbmRdCglsYXBwZW5kIGwgJHdvcmQKICAgIH0KICAgIHJldHVybiAkbAp9CgojIENvZGUgdG8gaW1wbGVtZW50IG11bHRpcGxlIHZpZXdzCgpwcm9jIG5ld3ZpZXcge2lzaGlnaGxpZ2h0fSB7CiAgICBnbG9iYWwgbmV4dHZpZXdudW0gbmV3dmlld25hbWUgbmV3dmlld3Blcm0gdWlmb250IG5ld2lzaGlnaGxpZ2h0CiAgICBnbG9iYWwgbmV3dmlld2FyZ3MgcmV2dHJlZWFyZ3MKCiAgICBzZXQgbmV3aXNoaWdobGlnaHQgJGlzaGlnaGxpZ2h0CiAgICBzZXQgdG9wIC5naXRrdmlldwogICAgaWYge1t3aW5mbyBleGlzdHMgJHRvcF19IHsKCXJhaXNlICR0b3AKCXJldHVybgogICAgfQogICAgc2V0IG5ld3ZpZXduYW1lKCRuZXh0dmlld251bSkgIlZpZXcgJG5leHR2aWV3bnVtIgogICAgc2V0IG5ld3ZpZXdwZXJtKCRuZXh0dmlld251bSkgMAogICAgc2V0IG5ld3ZpZXdhcmdzKCRuZXh0dmlld251bSkgW3NoZWxsYXJnbGlzdCAkcmV2dHJlZWFyZ3NdCiAgICB2aWV3ZWRpdG9yICR0b3AgJG5leHR2aWV3bnVtICJHaXRrIHZpZXcgZGVmaW5pdGlvbiIKfQoKcHJvYyBlZGl0dmlldyB7fSB7CiAgICBnbG9iYWwgY3VydmlldwogICAgZ2xvYmFsIHZpZXduYW1lIHZpZXdwZXJtIG5ld3ZpZXduYW1lIG5ld3ZpZXdwZXJtCiAgICBnbG9iYWwgdmlld2FyZ3MgbmV3dmlld2FyZ3MKCiAgICBzZXQgdG9wIC5naXRrdmVkaXQtJGN1cnZpZXcKICAgIGlmIHtbd2luZm8gZXhpc3RzICR0b3BdfSB7CglyYWlzZSAkdG9wCglyZXR1cm4KICAgIH0KICAgIHNldCBuZXd2aWV3bmFtZSgkY3VydmlldykgJHZpZXduYW1lKCRjdXJ2aWV3KQogICAgc2V0IG5ld3ZpZXdwZXJtKCRjdXJ2aWV3KSAkdmlld3Blcm0oJGN1cnZpZXcpCiAgICBzZXQgbmV3dmlld2FyZ3MoJGN1cnZpZXcpIFtzaGVsbGFyZ2xpc3QgJHZpZXdhcmdzKCRjdXJ2aWV3KV0KICAgIHZpZXdlZGl0b3IgJHRvcCAkY3VydmlldyAiR2l0azogZWRpdCB2aWV3ICR2aWV3bmFtZSgkY3VydmlldykiCn0KCnByb2Mgdmlld2VkaXRvciB7dG9wIG4gdGl0bGV9IHsKICAgIGdsb2JhbCBuZXd2aWV3bmFtZSBuZXd2aWV3cGVybSB2aWV3ZmlsZXMKICAgIGdsb2JhbCB1aWZvbnQKCiAgICB0b3BsZXZlbCAkdG9wCiAgICB3bSB0aXRsZSAkdG9wICR0aXRsZQogICAgbGFiZWwgJHRvcC5ubCAtdGV4dCAiTmFtZSIgLWZvbnQgJHVpZm9udAogICAgZW50cnkgJHRvcC5uYW1lIC13aWR0aCAyMCAtdGV4dHZhcmlhYmxlIG5ld3ZpZXduYW1lKCRuKSAtZm9udCAkdWlmb250CiAgICBncmlkICR0b3AubmwgJHRvcC5uYW1lIC1zdGlja3kgdyAtcGFkeSA1CiAgICBjaGVja2J1dHRvbiAkdG9wLnBlcm0gLXRleHQgIlJlbWVtYmVyIHRoaXMgdmlldyIgLXZhcmlhYmxlIG5ld3ZpZXdwZXJtKCRuKSBcCgktZm9udCAkdWlmb250CiAgICBncmlkICR0b3AucGVybSAtIC1wYWR5IDUgLXN0aWNreSB3CiAgICBtZXNzYWdlICR0b3AuYWwgLWFzcGVjdCAxMDAwIC1mb250ICR1aWZvbnQgXAoJLXRleHQgIkNvbW1pdHMgdG8gaW5jbHVkZSAoYXJndW1lbnRzIHRvIGdpdCByZXYtbGlzdCk6IgogICAgZ3JpZCAkdG9wLmFsIC0gLXN0aWNreSB3IC1wYWR5IDUKICAgIGVudHJ5ICR0b3AuYXJncyAtd2lkdGggNTAgLXRleHR2YXJpYWJsZSBuZXd2aWV3YXJncygkbikgXAoJLWJhY2tncm91bmQgd2hpdGUgLWZvbnQgJHVpZm9udAogICAgZ3JpZCAkdG9wLmFyZ3MgLSAtc3RpY2t5IGV3IC1wYWR4IDUKICAgIG1lc3NhZ2UgJHRvcC5sIC1hc3BlY3QgMTAwMCAtZm9udCAkdWlmb250IFwKCS10ZXh0ICJFbnRlciBmaWxlcyBhbmQgZGlyZWN0b3JpZXMgdG8gaW5jbHVkZSwgb25lIHBlciBsaW5lOiIKICAgIGdyaWQgJHRvcC5sIC0gLXN0aWNreSB3CiAgICB0ZXh0ICR0b3AudCAtd2lkdGggNDAgLWhlaWdodCAxMCAtYmFja2dyb3VuZCB3aGl0ZSAtZm9udCAkdWlmb250CiAgICBpZiB7W2luZm8gZXhpc3RzIHZpZXdmaWxlcygkbildfSB7Cglmb3JlYWNoIGYgJHZpZXdmaWxlcygkbikgewoJICAgICR0b3AudCBpbnNlcnQgZW5kICRmCgkgICAgJHRvcC50IGluc2VydCBlbmQgIlxuIgoJfQoJJHRvcC50IGRlbGV0ZSB7ZW5kIC0gMWN9IGVuZAoJJHRvcC50IG1hcmsgc2V0IGluc2VydCAwLjAKICAgIH0KICAgIGdyaWQgJHRvcC50IC0gLXN0aWNreSBldyAtcGFkeCA1CiAgICBmcmFtZSAkdG9wLmJ1dHMKICAgIGJ1dHRvbiAkdG9wLmJ1dHMub2sgLXRleHQgIk9LIiAtY29tbWFuZCBbbGlzdCBuZXd2aWV3b2sgJHRvcCAkbl0gXAoJLWZvbnQgJHVpZm9udAogICAgYnV0dG9uICR0b3AuYnV0cy5jYW4gLXRleHQgIkNhbmNlbCIgLWNvbW1hbmQgW2xpc3QgZGVzdHJveSAkdG9wXSBcCgktZm9udCAkdWlmb250CiAgICBncmlkICR0b3AuYnV0cy5vayAkdG9wLmJ1dHMuY2FuCiAgICBncmlkIGNvbHVtbmNvbmZpZ3VyZSAkdG9wLmJ1dHMgMCAtd2VpZ2h0IDEgLXVuaWZvcm0gYQogICAgZ3JpZCBjb2x1bW5jb25maWd1cmUgJHRvcC5idXRzIDEgLXdlaWdodCAxIC11bmlmb3JtIGEKICAgIGdyaWQgJHRvcC5idXRzIC0gLXBhZHkgMTAgLXN0aWNreSBldwogICAgZm9jdXMgJHRvcC50Cn0KCnByb2MgZG92aWV3bWVudSB7bSBmaXJzdCBjbWQgb3AgYXJndn0gewogICAgc2V0IG5tZW51IFskbSBpbmRleCBlbmRdCiAgICBmb3Ige3NldCBpICRmaXJzdH0geyRpIDw9ICRubWVudX0ge2luY3IgaX0gewoJaWYge1skbSBlbnRyeWNnZXQgJGkgLWNvbW1hbmRdIGVxICRjbWR9IHsKCSAgICBldmFsICRtICRvcCAkaSAkYXJndgoJICAgIGJyZWFrCgl9CiAgICB9Cn0KCnByb2MgYWxsdmlld21lbnVzIHtuIG9wIGFyZ3N9IHsKICAgIGdsb2JhbCB2aWV3aGxtZW51CgogICAgZG92aWV3bWVudSAuYmFyLnZpZXcgNSBbbGlzdCBzaG93dmlldyAkbl0gJG9wICRhcmdzCiAgICBkb3ZpZXdtZW51ICR2aWV3aGxtZW51IDEgW2xpc3QgYWRkdmhpZ2hsaWdodCAkbl0gJG9wICRhcmdzCn0KCnByb2MgbmV3dmlld29rIHt0b3Agbn0gewogICAgZ2xvYmFsIG5leHR2aWV3bnVtIG5ld3ZpZXdwZXJtIG5ld3ZpZXduYW1lIG5ld2lzaGlnaGxpZ2h0CiAgICBnbG9iYWwgdmlld25hbWUgdmlld2ZpbGVzIHZpZXdwZXJtIHNlbGVjdGVkdmlldyBjdXJ2aWV3CiAgICBnbG9iYWwgdmlld2FyZ3MgbmV3dmlld2FyZ3Mgdmlld2hsbWVudQoKICAgIGlmIHtbY2F0Y2ggewoJc2V0IG5ld2FyZ3MgW3NoZWxsc3BsaXQgJG5ld3ZpZXdhcmdzKCRuKV0KICAgIH0gZXJyXX0gewoJZXJyb3JfcG9wdXAgIkVycm9yIGluIGNvbW1pdCBzZWxlY3Rpb24gYXJndW1lbnRzOiAkZXJyIgoJd20gcmFpc2UgJHRvcAoJZm9jdXMgJHRvcAoJcmV0dXJuCiAgICB9CiAgICBzZXQgZmlsZXMge30KICAgIGZvcmVhY2ggZiBbc3BsaXQgWyR0b3AudCBnZXQgMC4wIGVuZF0gIlxuIl0gewoJc2V0IGZ0IFtzdHJpbmcgdHJpbSAkZl0KCWlmIHskZnQgbmUge319IHsKCSAgICBsYXBwZW5kIGZpbGVzICRmdAoJfQogICAgfQogICAgaWYgeyFbaW5mbyBleGlzdHMgdmlld2ZpbGVzKCRuKV19IHsKCSMgY3JlYXRpbmcgYSBuZXcgdmlldwoJaW5jciBuZXh0dmlld251bQoJc2V0IHZpZXduYW1lKCRuKSAkbmV3dmlld25hbWUoJG4pCglzZXQgdmlld3Blcm0oJG4pICRuZXd2aWV3cGVybSgkbikKCXNldCB2aWV3ZmlsZXMoJG4pICRmaWxlcwoJc2V0IHZpZXdhcmdzKCRuKSAkbmV3YXJncwoJYWRkdmlld21lbnUgJG4KCWlmIHshJG5ld2lzaGlnaGxpZ2h0fSB7CgkgICAgcnVuIHNob3d2aWV3ICRuCgl9IGVsc2UgewoJICAgIHJ1biBhZGR2aGlnaGxpZ2h0ICRuCgl9CiAgICB9IGVsc2UgewoJIyBlZGl0aW5nIGFuIGV4aXN0aW5nIHZpZXcKCXNldCB2aWV3cGVybSgkbikgJG5ld3ZpZXdwZXJtKCRuKQoJaWYgeyRuZXd2aWV3bmFtZSgkbikgbmUgJHZpZXduYW1lKCRuKX0gewoJICAgIHNldCB2aWV3bmFtZSgkbikgJG5ld3ZpZXduYW1lKCRuKQoJICAgIGRvdmlld21lbnUgLmJhci52aWV3IDUgW2xpc3Qgc2hvd3ZpZXcgJG5dIFwKCQllbnRyeWNvbmYgW2xpc3QgLWxhYmVsICR2aWV3bmFtZSgkbildCgkgICAgZG92aWV3bWVudSAkdmlld2hsbWVudSAxIFtsaXN0IGFkZHZoaWdobGlnaHQgJG5dIFwKCQllbnRyeWNvbmYgW2xpc3QgLWxhYmVsICR2aWV3bmFtZSgkbikgLXZhbHVlICR2aWV3bmFtZSgkbildCgl9CglpZiB7JGZpbGVzIG5lICR2aWV3ZmlsZXMoJG4pIHx8ICRuZXdhcmdzIG5lICR2aWV3YXJncygkbil9IHsKCSAgICBzZXQgdmlld2ZpbGVzKCRuKSAkZmlsZXMKCSAgICBzZXQgdmlld2FyZ3MoJG4pICRuZXdhcmdzCgkgICAgaWYgeyRjdXJ2aWV3ID09ICRufSB7CgkJcnVuIHVwZGF0ZWNvbW1pdHMKCSAgICB9Cgl9CiAgICB9CiAgICBjYXRjaCB7ZGVzdHJveSAkdG9wfQp9Cgpwcm9jIGRlbHZpZXcge30gewogICAgZ2xvYmFsIGN1cnZpZXcgdmlld2RhdGEgdmlld3Blcm0gaGx2aWV3IHNlbGVjdGVkaGx2aWV3CgogICAgaWYgeyRjdXJ2aWV3ID09IDB9IHJldHVybgogICAgaWYge1tpbmZvIGV4aXN0cyBobHZpZXddICYmICRobHZpZXcgPT0gJGN1cnZpZXd9IHsKCXNldCBzZWxlY3RlZGhsdmlldyBOb25lCgl1bnNldCBobHZpZXcKICAgIH0KICAgIGFsbHZpZXdtZW51cyAkY3VydmlldyBkZWxldGUKICAgIHNldCB2aWV3ZGF0YSgkY3Vydmlldykge30KICAgIHNldCB2aWV3cGVybSgkY3VydmlldykgMAogICAgc2hvd3ZpZXcgMAp9Cgpwcm9jIGFkZHZpZXdtZW51IHtufSB7CiAgICBnbG9iYWwgdmlld25hbWUgdmlld2hsbWVudQoKICAgIC5iYXIudmlldyBhZGQgcmFkaW9idXR0b24gLWxhYmVsICR2aWV3bmFtZSgkbikgXAoJLWNvbW1hbmQgW2xpc3Qgc2hvd3ZpZXcgJG5dIC12YXJpYWJsZSBzZWxlY3RlZHZpZXcgLXZhbHVlICRuCiAgICAkdmlld2hsbWVudSBhZGQgcmFkaW9idXR0b24gLWxhYmVsICR2aWV3bmFtZSgkbikgXAoJLWNvbW1hbmQgW2xpc3QgYWRkdmhpZ2hsaWdodCAkbl0gLXZhcmlhYmxlIHNlbGVjdGVkaGx2aWV3Cn0KCnByb2MgZmxhdHRlbiB7dmFyfSB7CiAgICBnbG9iYWwgJHZhcgoKICAgIHNldCByZXQge30KICAgIGZvcmVhY2ggaSBbYXJyYXkgbmFtZXMgJHZhcl0gewoJbGFwcGVuZCByZXQgJGkgW3NldCAkdmFyXCgkaVwpXQogICAgfQogICAgcmV0dXJuICRyZXQKfQoKcHJvYyB1bmZsYXR0ZW4ge3ZhciBsfSB7CiAgICBnbG9iYWwgJHZhcgoKICAgIGNhdGNoIHt1bnNldCAkdmFyfQogICAgZm9yZWFjaCB7aSB2fSAkbCB7CglzZXQgJHZhclwoJGlcKSAkdgogICAgfQp9Cgpwcm9jIHNob3d2aWV3IHtufSB7CiAgICBnbG9iYWwgY3VydmlldyB2aWV3ZGF0YSB2aWV3ZmlsZXMKICAgIGdsb2JhbCBkaXNwbGF5b3JkZXIgcGFyZW50bGlzdCByb3dpZGxpc3Qgcm93b2Zmc2V0cwogICAgZ2xvYmFsIGNvbG9ybWFwIHJvd3RleHR4IGNvbW1pdHJvdyBuZXh0Y29sb3IgY2FudnhtYXgKICAgIGdsb2JhbCBudW1jb21taXRzIHJvd3JhbmdlbGlzdCBjb21taXRsaXN0ZWQgaWRyb3dyYW5nZXMgcm93Y2hrCiAgICBnbG9iYWwgc2VsZWN0ZWRsaW5lIGN1cnJlbnRpZCBjYW52IGNhbnZ5MAogICAgZ2xvYmFsIHRyZWVkaWZmcwogICAgZ2xvYmFsIHBlbmRpbmdfc2VsZWN0IHBoYXNlCiAgICBnbG9iYWwgY29tbWl0aWR4IHJvd2xhaWRvdXQgcm93b3B0aW0KICAgIGdsb2JhbCBjb21tZmQKICAgIGdsb2JhbCBzZWxlY3RlZHZpZXcgc2VsZWN0Zmlyc3QKICAgIGdsb2JhbCB2cGFyZW50bGlzdCB2ZGlzcG9yZGVyIHZjbWl0bGlzdGVkCiAgICBnbG9iYWwgaGx2aWV3IHNlbGVjdGVkaGx2aWV3CgogICAgaWYgeyRuID09ICRjdXJ2aWV3fSByZXR1cm4KICAgIHNldCBzZWxpZCB7fQogICAgaWYge1tpbmZvIGV4aXN0cyBzZWxlY3RlZGxpbmVdfSB7CglzZXQgc2VsaWQgJGN1cnJlbnRpZAoJc2V0IHkgW3ljICRzZWxlY3RlZGxpbmVdCglzZXQgeW1heCBbbGluZGV4IFskY2FudiBjZ2V0IC1zY3JvbGxyZWdpb25dIDNdCglzZXQgc3BhbiBbJGNhbnYgeXZpZXddCglzZXQgeXRvcCBbZXhwciB7W2xpbmRleCAkc3BhbiAwXSAqICR5bWF4fV0KCXNldCB5Ym90IFtleHByIHtbbGluZGV4ICRzcGFuIDFdICogJHltYXh9XQoJaWYgeyR5dG9wIDwgJHkgJiYgJHkgPCAkeWJvdH0gewoJICAgIHNldCB5c2NyZWVuIFtleHByIHskeSAtICR5dG9wfV0KCX0gZWxzZSB7CgkgICAgc2V0IHlzY3JlZW4gW2V4cHIgeygkeWJvdCAtICR5dG9wKSAvIDJ9XQoJfQogICAgfSBlbHNlaWYge1tpbmZvIGV4aXN0cyBwZW5kaW5nX3NlbGVjdF19IHsKCXNldCBzZWxpZCAkcGVuZGluZ19zZWxlY3QKCXVuc2V0IHBlbmRpbmdfc2VsZWN0CiAgICB9CiAgICB1bnNlbGVjdGxpbmUKICAgIG5vcm1hbGxpbmUKICAgIGlmIHskY3VydmlldyA+PSAwfSB7CglzZXQgdnBhcmVudGxpc3QoJGN1cnZpZXcpICRwYXJlbnRsaXN0CglzZXQgdmRpc3BvcmRlcigkY3VydmlldykgJGRpc3BsYXlvcmRlcgoJc2V0IHZjbWl0bGlzdGVkKCRjdXJ2aWV3KSAkY29tbWl0bGlzdGVkCglpZiB7JHBoYXNlIG5lIHt9fSB7CgkgICAgc2V0IHZpZXdkYXRhKCRjdXJ2aWV3KSBcCgkJW2xpc3QgJHBoYXNlICRyb3dpZGxpc3QgJHJvd29mZnNldHMgJHJvd3JhbmdlbGlzdCBcCgkJICAgICBbZmxhdHRlbiBpZHJvd3Jhbmdlc10gW2ZsYXR0ZW4gaWRpbmxpc3RdIFwKCQkgICAgICRyb3dsYWlkb3V0ICRyb3dvcHRpbSAkbnVtY29tbWl0c10KCX0gZWxzZWlmIHshW2luZm8gZXhpc3RzIHZpZXdkYXRhKCRjdXJ2aWV3KV0KCQkgIHx8IFtsaW5kZXggJHZpZXdkYXRhKCRjdXJ2aWV3KSAwXSBuZSB7fX0gewoJICAgIHNldCB2aWV3ZGF0YSgkY3VydmlldykgXAoJCVtsaXN0IHt9ICRyb3dpZGxpc3QgJHJvd29mZnNldHMgJHJvd3JhbmdlbGlzdF0KCX0KICAgIH0KICAgIGNhdGNoIHt1bnNldCB0cmVlZGlmZnN9CiAgICBjbGVhcl9kaXNwbGF5CiAgICBpZiB7W2luZm8gZXhpc3RzIGhsdmlld10gJiYgJGhsdmlldyA9PSAkbn0gewoJdW5zZXQgaGx2aWV3CglzZXQgc2VsZWN0ZWRobHZpZXcgTm9uZQogICAgfQoKICAgIHNldCBjdXJ2aWV3ICRuCiAgICBzZXQgc2VsZWN0ZWR2aWV3ICRuCiAgICAuYmFyLnZpZXcgZW50cnljb25mIEVkaXQqIC1zdGF0ZSBbZXhwciB7JG4gPT0gMD8gImRpc2FibGVkIjogIm5vcm1hbCJ9XQogICAgLmJhci52aWV3IGVudHJ5Y29uZiBEZWxldGUqIC1zdGF0ZSBbZXhwciB7JG4gPT0gMD8gImRpc2FibGVkIjogIm5vcm1hbCJ9XQoKICAgIGlmIHshW2luZm8gZXhpc3RzIHZpZXdkYXRhKCRuKV19IHsKCWlmIHskc2VsaWQgbmUge319IHsKCSAgICBzZXQgcGVuZGluZ19zZWxlY3QgJHNlbGlkCgl9CglnZXRjb21taXRzCglyZXR1cm4KICAgIH0KCiAgICBzZXQgdiAkdmlld2RhdGEoJG4pCiAgICBzZXQgcGhhc2UgW2xpbmRleCAkdiAwXQogICAgc2V0IGRpc3BsYXlvcmRlciAkdmRpc3BvcmRlcigkbikKICAgIHNldCBwYXJlbnRsaXN0ICR2cGFyZW50bGlzdCgkbikKICAgIHNldCBjb21taXRsaXN0ZWQgJHZjbWl0bGlzdGVkKCRuKQogICAgc2V0IHJvd2lkbGlzdCBbbGluZGV4ICR2IDFdCiAgICBzZXQgcm93b2Zmc2V0cyBbbGluZGV4ICR2IDJdCiAgICBzZXQgcm93cmFuZ2VsaXN0IFtsaW5kZXggJHYgM10KICAgIGlmIHskcGhhc2UgZXEge319IHsKCXNldCBudW1jb21taXRzIFtsbGVuZ3RoICRkaXNwbGF5b3JkZXJdCgljYXRjaCB7dW5zZXQgaWRyb3dyYW5nZXN9CiAgICB9IGVsc2UgewoJdW5mbGF0dGVuIGlkcm93cmFuZ2VzIFtsaW5kZXggJHYgNF0KCXVuZmxhdHRlbiBpZGlubGlzdCBbbGluZGV4ICR2IDVdCglzZXQgcm93bGFpZG91dCBbbGluZGV4ICR2IDZdCglzZXQgcm93b3B0aW0gW2xpbmRleCAkdiA3XQoJc2V0IG51bWNvbW1pdHMgW2xpbmRleCAkdiA4XQoJY2F0Y2gge3Vuc2V0IHJvd2Noa30KICAgIH0KCiAgICBjYXRjaCB7dW5zZXQgY29sb3JtYXB9CiAgICBjYXRjaCB7dW5zZXQgcm93dGV4dHh9CiAgICBzZXQgbmV4dGNvbG9yIDAKICAgIHNldCBjYW52eG1heCBbJGNhbnYgY2dldCAtd2lkdGhdCiAgICBzZXQgY3VydmlldyAkbgogICAgc2V0IHJvdyAwCiAgICBzZXRjYW52c2Nyb2xsCiAgICBzZXQgeWYgMAogICAgc2V0IHJvdyB7fQogICAgc2V0IHNlbGVjdGZpcnN0IDAKICAgIGlmIHskc2VsaWQgbmUge30gJiYgW2luZm8gZXhpc3RzIGNvbW1pdHJvdygkbiwkc2VsaWQpXX0gewoJc2V0IHJvdyAkY29tbWl0cm93KCRuLCRzZWxpZCkKCSMgdHJ5IHRvIGdldCB0aGUgc2VsZWN0ZWQgcm93IGluIHRoZSBzYW1lIHBvc2l0aW9uIG9uIHRoZSBzY3JlZW4KCXNldCB5bWF4IFtsaW5kZXggWyRjYW52IGNnZXQgLXNjcm9sbHJlZ2lvbl0gM10KCXNldCB5dG9wIFtleHByIHtbeWMgJHJvd10gLSAkeXNjcmVlbn1dCglpZiB7JHl0b3AgPCAwfSB7CgkgICAgc2V0IHl0b3AgMAoJfQoJc2V0IHlmIFtleHByIHskeXRvcCAqIDEuMCAvICR5bWF4fV0KICAgIH0KICAgIGFsbGNhbnZzIHl2aWV3IG1vdmV0byAkeWYKICAgIGRyYXd2aXNpYmxlCiAgICBpZiB7JHJvdyBuZSB7fX0gewoJc2VsZWN0bGluZSAkcm93IDAKICAgIH0gZWxzZWlmIHskc2VsaWQgbmUge319IHsKCXNldCBwZW5kaW5nX3NlbGVjdCAkc2VsaWQKICAgIH0gZWxzZSB7CglzZXQgcm93IFtmaXJzdF9yZWFsX3Jvd10KCWlmIHskcm93IDwgJG51bWNvbW1pdHN9IHsKCSAgICBzZWxlY3RsaW5lICRyb3cgMAoJfSBlbHNlIHsKCSAgICBzZXQgc2VsZWN0Zmlyc3QgMQoJfQogICAgfQogICAgaWYgeyRwaGFzZSBuZSB7fX0gewoJaWYgeyRwaGFzZSBlcSAiZ2V0Y29tbWl0cyJ9IHsKCSAgICBzaG93X3N0YXR1cyAiUmVhZGluZyBjb21taXRzLi4uIgoJfQoJcnVuIGNoZXdjb21taXRzICRuCiAgICB9IGVsc2VpZiB7JG51bWNvbW1pdHMgPT0gMH0gewoJc2hvd19zdGF0dXMgIk5vIGNvbW1pdHMgc2VsZWN0ZWQiCiAgICB9Cn0KCiMgU3R1ZmYgcmVsYXRpbmcgdG8gdGhlIGhpZ2hsaWdodGluZyBmYWNpbGl0eQoKcHJvYyBpc2hpZ2hsaWdodGVkIHtyb3d9IHsKICAgIGdsb2JhbCB2aGlnaGxpZ2h0cyBmaGlnaGxpZ2h0cyBuaGlnaGxpZ2h0cyByaGlnaGxpZ2h0cwoKICAgIGlmIHtbaW5mbyBleGlzdHMgbmhpZ2hsaWdodHMoJHJvdyldICYmICRuaGlnaGxpZ2h0cygkcm93KSA+IDB9IHsKCXJldHVybiAkbmhpZ2hsaWdodHMoJHJvdykKICAgIH0KICAgIGlmIHtbaW5mbyBleGlzdHMgdmhpZ2hsaWdodHMoJHJvdyldICYmICR2aGlnaGxpZ2h0cygkcm93KSA+IDB9IHsKCXJldHVybiAkdmhpZ2hsaWdodHMoJHJvdykKICAgIH0KICAgIGlmIHtbaW5mbyBleGlzdHMgZmhpZ2hsaWdodHMoJHJvdyldICYmICRmaGlnaGxpZ2h0cygkcm93KSA+IDB9IHsKCXJldHVybiAkZmhpZ2hsaWdodHMoJHJvdykKICAgIH0KICAgIGlmIHtbaW5mbyBleGlzdHMgcmhpZ2hsaWdodHMoJHJvdyldICYmICRyaGlnaGxpZ2h0cygkcm93KSA+IDB9IHsKCXJldHVybiAkcmhpZ2hsaWdodHMoJHJvdykKICAgIH0KICAgIHJldHVybiAwCn0KCnByb2MgYm9sZGVuIHtyb3cgZm9udH0gewogICAgZ2xvYmFsIGNhbnYgbGluZWh0YWcgc2VsZWN0ZWRsaW5lIGJvbGRyb3dzCgogICAgbGFwcGVuZCBib2xkcm93cyAkcm93CiAgICAkY2FudiBpdGVtY29uZiAkbGluZWh0YWcoJHJvdykgLWZvbnQgJGZvbnQKICAgIGlmIHtbaW5mbyBleGlzdHMgc2VsZWN0ZWRsaW5lXSAmJiAkcm93ID09ICRzZWxlY3RlZGxpbmV9IHsKCSRjYW52IGRlbGV0ZSBzZWNzZWwKCXNldCB0IFtldmFsICRjYW52IGNyZWF0ZSByZWN0IFskY2FudiBiYm94ICRsaW5laHRhZygkcm93KV0gXAoJCSAgIC1vdXRsaW5lIHt7fX0gLXRhZ3Mgc2Vjc2VsIFwKCQkgICAtZmlsbCBbJGNhbnYgY2dldCAtc2VsZWN0YmFja2dyb3VuZF1dCgkkY2FudiBsb3dlciAkdAogICAgfQp9Cgpwcm9jIGJvbGRlbl9uYW1lIHtyb3cgZm9udH0gewogICAgZ2xvYmFsIGNhbnYyIGxpbmVudGFnIHNlbGVjdGVkbGluZSBib2xkbmFtZXJvd3MKCiAgICBsYXBwZW5kIGJvbGRuYW1lcm93cyAkcm93CiAgICAkY2FudjIgaXRlbWNvbmYgJGxpbmVudGFnKCRyb3cpIC1mb250ICRmb250CiAgICBpZiB7W2luZm8gZXhpc3RzIHNlbGVjdGVkbGluZV0gJiYgJHJvdyA9PSAkc2VsZWN0ZWRsaW5lfSB7CgkkY2FudjIgZGVsZXRlIHNlY3NlbAoJc2V0IHQgW2V2YWwgJGNhbnYyIGNyZWF0ZSByZWN0IFskY2FudjIgYmJveCAkbGluZW50YWcoJHJvdyldIFwKCQkgICAtb3V0bGluZSB7e319IC10YWdzIHNlY3NlbCBcCgkJICAgLWZpbGwgWyRjYW52MiBjZ2V0IC1zZWxlY3RiYWNrZ3JvdW5kXV0KCSRjYW52MiBsb3dlciAkdAogICAgfQp9Cgpwcm9jIHVuYm9sZGVuIHt9IHsKICAgIGdsb2JhbCBtYWluZm9udCBib2xkcm93cwoKICAgIHNldCBzdGlsbGJvbGQge30KICAgIGZvcmVhY2ggcm93ICRib2xkcm93cyB7CglpZiB7IVtpc2hpZ2hsaWdodGVkICRyb3ddfSB7CgkgICAgYm9sZGVuICRyb3cgJG1haW5mb250Cgl9IGVsc2UgewoJICAgIGxhcHBlbmQgc3RpbGxib2xkICRyb3cKCX0KICAgIH0KICAgIHNldCBib2xkcm93cyAkc3RpbGxib2xkCn0KCnByb2MgYWRkdmhpZ2hsaWdodCB7bn0gewogICAgZ2xvYmFsIGhsdmlldyBjdXJ2aWV3IHZpZXdkYXRhIHZobF9kb25lIHZoaWdobGlnaHRzIGNvbW1pdGlkeAoKICAgIGlmIHtbaW5mbyBleGlzdHMgaGx2aWV3XX0gewoJZGVsdmhpZ2hsaWdodAogICAgfQogICAgc2V0IGhsdmlldyAkbgogICAgaWYgeyRuICE9ICRjdXJ2aWV3ICYmICFbaW5mbyBleGlzdHMgdmlld2RhdGEoJG4pXX0gewoJc2V0IHZpZXdkYXRhKCRuKSBbbGlzdCBnZXRjb21taXRzIHt7fX0ge3t9fSB7fSB7fSB7fSAwIDAgMCB7fV0KCXNldCB2cGFyZW50bGlzdCgkbikge30KCXNldCB2ZGlzcG9yZGVyKCRuKSB7fQoJc2V0IHZjbWl0bGlzdGVkKCRuKSB7fQoJc3RhcnRfcmV2X2xpc3QgJG4KICAgIH0KICAgIHNldCB2aGxfZG9uZSAkY29tbWl0aWR4KCRobHZpZXcpCiAgICBpZiB7JHZobF9kb25lID4gMH0gewoJZHJhd3Zpc2libGUKICAgIH0KfQoKcHJvYyBkZWx2aGlnaGxpZ2h0IHt9IHsKICAgIGdsb2JhbCBobHZpZXcgdmhpZ2hsaWdodHMKCiAgICBpZiB7IVtpbmZvIGV4aXN0cyBobHZpZXddfSByZXR1cm4KICAgIHVuc2V0IGhsdmlldwogICAgY2F0Y2gge3Vuc2V0IHZoaWdobGlnaHRzfQogICAgdW5ib2xkZW4KfQoKcHJvYyB2aGlnaGxpZ2h0bW9yZSB7fSB7CiAgICBnbG9iYWwgaGx2aWV3IHZobF9kb25lIGNvbW1pdGlkeCB2aGlnaGxpZ2h0cwogICAgZ2xvYmFsIGRpc3BsYXlvcmRlciB2ZGlzcG9yZGVyIGN1cnZpZXcgbWFpbmZvbnQKCiAgICBzZXQgZm9udCBbY29uY2F0ICRtYWluZm9udCBib2xkXQogICAgc2V0IG1heCAkY29tbWl0aWR4KCRobHZpZXcpCiAgICBpZiB7JGhsdmlldyA9PSAkY3Vydmlld30gewoJc2V0IGRpc3AgJGRpc3BsYXlvcmRlcgogICAgfSBlbHNlIHsKCXNldCBkaXNwICR2ZGlzcG9yZGVyKCRobHZpZXcpCiAgICB9CiAgICBzZXQgdnIgW3Zpc2libGVyb3dzXQogICAgc2V0IHIwIFtsaW5kZXggJHZyIDBdCiAgICBzZXQgcjEgW2xpbmRleCAkdnIgMV0KICAgIGZvciB7c2V0IGkgJHZobF9kb25lfSB7JGkgPCAkbWF4fSB7aW5jciBpfSB7CglzZXQgaWQgW2xpbmRleCAkZGlzcCAkaV0KCWlmIHtbaW5mbyBleGlzdHMgY29tbWl0cm93KCRjdXJ2aWV3LCRpZCldfSB7CgkgICAgc2V0IHJvdyAkY29tbWl0cm93KCRjdXJ2aWV3LCRpZCkKCSAgICBpZiB7JHIwIDw9ICRyb3cgJiYgJHJvdyA8PSAkcjF9IHsKCQlpZiB7IVtoaWdobGlnaHRlZCAkcm93XX0gewoJCSAgICBib2xkZW4gJHJvdyAkZm9udAoJCX0KCQlzZXQgdmhpZ2hsaWdodHMoJHJvdykgMQoJICAgIH0KCX0KICAgIH0KICAgIHNldCB2aGxfZG9uZSAkbWF4Cn0KCnByb2MgYXNrdmhpZ2hsaWdodCB7cm93IGlkfSB7CiAgICBnbG9iYWwgaGx2aWV3IHZoaWdobGlnaHRzIGNvbW1pdHJvdyBpZGRyYXduIG1haW5mb250CgogICAgaWYge1tpbmZvIGV4aXN0cyBjb21taXRyb3coJGhsdmlldywkaWQpXX0gewoJaWYge1tpbmZvIGV4aXN0cyBpZGRyYXduKCRpZCldICYmICFbaXNoaWdobGlnaHRlZCAkcm93XX0gewoJICAgIGJvbGRlbiAkcm93IFtjb25jYXQgJG1haW5mb250IGJvbGRdCgl9CglzZXQgdmhpZ2hsaWdodHMoJHJvdykgMQogICAgfSBlbHNlIHsKCXNldCB2aGlnaGxpZ2h0cygkcm93KSAwCiAgICB9Cn0KCnByb2MgaGZpbGVzX2NoYW5nZSB7bmFtZSBpeCBvcH0gewogICAgZ2xvYmFsIGhpZ2hsaWdodF9maWxlcyBmaWxlaGlnaGxpZ2h0IGZoaWdobGlnaHRzIGZoX3NlcmlhbAogICAgZ2xvYmFsIG1haW5mb250IGhpZ2hsaWdodF9wYXRocwoKICAgIGlmIHtbaW5mbyBleGlzdHMgZmlsZWhpZ2hsaWdodF19IHsKCSMgZGVsZXRlIHByZXZpb3VzIGhpZ2hsaWdodHMKCWNhdGNoIHtjbG9zZSAkZmlsZWhpZ2hsaWdodH0KCXVuc2V0IGZpbGVoaWdobGlnaHQKCWNhdGNoIHt1bnNldCBmaGlnaGxpZ2h0c30KCXVuYm9sZGVuCgl1bmhpZ2hsaWdodF9maWxlbGlzdAogICAgfQogICAgc2V0IGhpZ2hsaWdodF9wYXRocyB7fQogICAgYWZ0ZXIgY2FuY2VsIGRvX2ZpbGVfaGwgJGZoX3NlcmlhbAogICAgaW5jciBmaF9zZXJpYWwKICAgIGlmIHskaGlnaGxpZ2h0X2ZpbGVzIG5lIHt9fSB7CglhZnRlciAzMDAgZG9fZmlsZV9obCAkZmhfc2VyaWFsCiAgICB9Cn0KCnByb2MgbWFrZXBhdHRlcm5zIHtsfSB7CiAgICBzZXQgcmV0IHt9CiAgICBmb3JlYWNoIGUgJGwgewoJc2V0IGVlIFtzdHJpbmcgbWFwIHsiKiIgIlxcKiIgIj8iICJcXD8iICJcWyIgIlxcXFsiICJcXCIgIlxcXFwifSAkZV0KCWlmIHtbc3RyaW5nIGluZGV4ICRlZSBlbmRdIGVxICIvIn0gewoJICAgIGxhcHBlbmQgcmV0ICIkZWUqIgoJfSBlbHNlIHsKCSAgICBsYXBwZW5kIHJldCAkZWUKCSAgICBsYXBwZW5kIHJldCAiJGVlLyoiCgl9CiAgICB9CiAgICByZXR1cm4gJHJldAp9Cgpwcm9jIGRvX2ZpbGVfaGwge3NlcmlhbH0gewogICAgZ2xvYmFsIGhpZ2hsaWdodF9maWxlcyBmaWxlaGlnaGxpZ2h0IGhpZ2hsaWdodF9wYXRocyBnZHR0eXBlIGZobF9saXN0CgogICAgaWYgeyRnZHR0eXBlIGVxICJ0b3VjaGluZyBwYXRoczoifSB7CglpZiB7W2NhdGNoIHtzZXQgcGF0aHMgW3NoZWxsc3BsaXQgJGhpZ2hsaWdodF9maWxlc119XX0gcmV0dXJuCglzZXQgaGlnaGxpZ2h0X3BhdGhzIFttYWtlcGF0dGVybnMgJHBhdGhzXQoJaGlnaGxpZ2h0X2ZpbGVsaXN0CglzZXQgZ2R0YXJncyBbY29uY2F0IC0tICRwYXRoc10KICAgIH0gZWxzZSB7CglzZXQgZ2R0YXJncyBbbGlzdCAiLVMkaGlnaGxpZ2h0X2ZpbGVzIl0KICAgIH0KICAgIHNldCBjbWQgW2NvbmNhdCB8IGdpdCBkaWZmLXRyZWUgLXIgLXMgLS1zdGRpbiAkZ2R0YXJnc10KICAgIHNldCBmaWxlaGlnaGxpZ2h0IFtvcGVuICRjbWQgcitdCiAgICBmY29uZmlndXJlICRmaWxlaGlnaGxpZ2h0IC1ibG9ja2luZyAwCiAgICBmaWxlcnVuICRmaWxlaGlnaGxpZ2h0IHJlYWRmaGlnaGxpZ2h0CiAgICBzZXQgZmhsX2xpc3Qge30KICAgIGRyYXd2aXNpYmxlCiAgICBmbHVzaGhpZ2hsaWdodHMKfQoKcHJvYyBmbHVzaGhpZ2hsaWdodHMge30gewogICAgZ2xvYmFsIGZpbGVoaWdobGlnaHQgZmhsX2xpc3QKCiAgICBpZiB7W2luZm8gZXhpc3RzIGZpbGVoaWdobGlnaHRdfSB7CglsYXBwZW5kIGZobF9saXN0IHt9CglwdXRzICRmaWxlaGlnaGxpZ2h0ICIiCglmbHVzaCAkZmlsZWhpZ2hsaWdodAogICAgfQp9Cgpwcm9jIGFza2ZpbGVoaWdobGlnaHQge3JvdyBpZH0gewogICAgZ2xvYmFsIGZpbGVoaWdobGlnaHQgZmhpZ2hsaWdodHMgZmhsX2xpc3QKCiAgICBsYXBwZW5kIGZobF9saXN0ICRpZAogICAgc2V0IGZoaWdobGlnaHRzKCRyb3cpIC0xCiAgICBwdXRzICRmaWxlaGlnaGxpZ2h0ICRpZAp9Cgpwcm9jIHJlYWRmaGlnaGxpZ2h0IHt9IHsKICAgIGdsb2JhbCBmaWxlaGlnaGxpZ2h0IGZoaWdobGlnaHRzIGNvbW1pdHJvdyBjdXJ2aWV3IG1haW5mb250IGlkZHJhd24KICAgIGdsb2JhbCBmaGxfbGlzdAoKICAgIGlmIHshW2luZm8gZXhpc3RzIGZpbGVoaWdobGlnaHRdfSB7CglyZXR1cm4gMAogICAgfQogICAgc2V0IG5yIDAKICAgIHdoaWxlIHtbaW5jciBucl0gPD0gMTAwICYmIFtnZXRzICRmaWxlaGlnaGxpZ2h0IGxpbmVdID49IDB9IHsKCXNldCBsaW5lIFtzdHJpbmcgdHJpbSAkbGluZV0KCXNldCBpIFtsc2VhcmNoIC1leGFjdCAkZmhsX2xpc3QgJGxpbmVdCglpZiB7JGkgPCAwfSBjb250aW51ZQoJZm9yIHtzZXQgaiAwfSB7JGogPCAkaX0ge2luY3Igan0gewoJICAgIHNldCBpZCBbbGluZGV4ICRmaGxfbGlzdCAkal0KCSAgICBpZiB7W2luZm8gZXhpc3RzIGNvbW1pdHJvdygkY3VydmlldywkaWQpXX0gewoJCXNldCBmaGlnaGxpZ2h0cygkY29tbWl0cm93KCRjdXJ2aWV3LCRpZCkpIDAKCSAgICB9Cgl9CglzZXQgZmhsX2xpc3QgW2xyYW5nZSAkZmhsX2xpc3QgW2V4cHIgeyRpKzF9XSBlbmRdCglpZiB7JGxpbmUgZXEge319IGNvbnRpbnVlCglpZiB7IVtpbmZvIGV4aXN0cyBjb21taXRyb3coJGN1cnZpZXcsJGxpbmUpXX0gY29udGludWUKCXNldCByb3cgJGNvbW1pdHJvdygkY3VydmlldywkbGluZSkKCWlmIHtbaW5mbyBleGlzdHMgaWRkcmF3bigkbGluZSldICYmICFbaXNoaWdobGlnaHRlZCAkcm93XX0gewoJICAgIGJvbGRlbiAkcm93IFtjb25jYXQgJG1haW5mb250IGJvbGRdCgl9CglzZXQgZmhpZ2hsaWdodHMoJHJvdykgMQogICAgfQogICAgaWYge1tlb2YgJGZpbGVoaWdobGlnaHRdfSB7CgkjIHN0cmFuZ2UuLi4KCXB1dHMgIm9vcHMsIGdpdCBkaWZmLXRyZWUgZGllZCIKCWNhdGNoIHtjbG9zZSAkZmlsZWhpZ2hsaWdodH0KCXVuc2V0IGZpbGVoaWdobGlnaHQKCXJldHVybiAwCiAgICB9CiAgICBuZXh0X2hsY29udAogICAgcmV0dXJuIDEKfQoKcHJvYyBmaW5kX2NoYW5nZSB7bmFtZSBpeCBvcH0gewogICAgZ2xvYmFsIG5oaWdobGlnaHRzIG1haW5mb250IGJvbGRuYW1lcm93cwogICAgZ2xvYmFsIGZpbmRzdHJpbmcgZmluZHBhdHRlcm4gZmluZHR5cGUKCiAgICAjIGRlbGV0ZSBwcmV2aW91cyBoaWdobGlnaHRzLCBpZiBhbnkKICAgIGZvcmVhY2ggcm93ICRib2xkbmFtZXJvd3MgewoJYm9sZGVuX25hbWUgJHJvdyAkbWFpbmZvbnQKICAgIH0KICAgIHNldCBib2xkbmFtZXJvd3Mge30KICAgIGNhdGNoIHt1bnNldCBuaGlnaGxpZ2h0c30KICAgIHVuYm9sZGVuCiAgICB1bm1hcmttYXRjaGVzCiAgICBpZiB7JGZpbmR0eXBlIG5lICJSZWdleHAifSB7CglzZXQgZSBbc3RyaW5nIG1hcCB7IioiICJcXCoiICI/IiAiXFw/IiAiXFsiICJcXFxbIiAiXFwiICJcXFxcIn0gXAoJCSAgICRmaW5kc3RyaW5nXQoJc2V0IGZpbmRwYXR0ZXJuICIqJGUqIgogICAgfQogICAgZHJhd3Zpc2libGUKfQoKcHJvYyBkb2VzbWF0Y2gge2Z9IHsKICAgIGdsb2JhbCBmaW5kdHlwZSBmaW5kc3RyaW5nIGZpbmRwYXR0ZXJuCgogICAgaWYgeyRmaW5kdHlwZSBlcSAiUmVnZXhwIn0gewoJcmV0dXJuIFtyZWdleHAgJGZpbmRzdHJpbmcgJGZdCiAgICB9IGVsc2VpZiB7JGZpbmR0eXBlIGVxICJJZ25DYXNlIn0gewoJcmV0dXJuIFtzdHJpbmcgbWF0Y2ggLW5vY2FzZSAkZmluZHBhdHRlcm4gJGZdCiAgICB9IGVsc2UgewoJcmV0dXJuIFtzdHJpbmcgbWF0Y2ggJGZpbmRwYXR0ZXJuICRmXQogICAgfQp9Cgpwcm9jIGFza2ZpbmRoaWdobGlnaHQge3JvdyBpZH0gewogICAgZ2xvYmFsIG5oaWdobGlnaHRzIGNvbW1pdGluZm8gaWRkcmF3biBtYWluZm9udAogICAgZ2xvYmFsIGZpbmRsb2MKICAgIGdsb2JhbCBtYXJraW5nbWF0Y2hlcwoKICAgIGlmIHshW2luZm8gZXhpc3RzIGNvbW1pdGluZm8oJGlkKV19IHsKCWdldGNvbW1pdCAkaWQKICAgIH0KICAgIHNldCBpbmZvICRjb21taXRpbmZvKCRpZCkKICAgIHNldCBpc2JvbGQgMAogICAgc2V0IGZsZHR5cGVzIHtIZWFkbGluZSBBdXRob3IgRGF0ZSBDb21taXR0ZXIgQ0RhdGUgQ29tbWVudHN9CiAgICBmb3JlYWNoIGYgJGluZm8gdHkgJGZsZHR5cGVzIHsKCWlmIHsoJGZpbmRsb2MgZXEgIkFsbCBmaWVsZHMiIHx8ICRmaW5kbG9jIGVxICR0eSkgJiYKCSAgICBbZG9lc21hdGNoICRmXX0gewoJICAgIGlmIHskdHkgZXEgIkF1dGhvciJ9IHsKCQlzZXQgaXNib2xkIDIKCQlicmVhawoJICAgIH0KCSAgICBzZXQgaXNib2xkIDEKCX0KICAgIH0KICAgIGlmIHskaXNib2xkICYmIFtpbmZvIGV4aXN0cyBpZGRyYXduKCRpZCldfSB7CglzZXQgZiBbY29uY2F0ICRtYWluZm9udCBib2xkXQoJaWYgeyFbaXNoaWdobGlnaHRlZCAkcm93XX0gewoJICAgIGJvbGRlbiAkcm93ICRmCgkgICAgaWYgeyRpc2JvbGQgPiAxfSB7CgkJYm9sZGVuX25hbWUgJHJvdyAkZgoJICAgIH0KCX0KCWlmIHskbWFya2luZ21hdGNoZXN9IHsKCSAgICBtYXJrcm93bWF0Y2hlcyAkcm93ICRpZAoJfQogICAgfQogICAgc2V0IG5oaWdobGlnaHRzKCRyb3cpICRpc2JvbGQKfQoKcHJvYyBtYXJrcm93bWF0Y2hlcyB7cm93IGlkfSB7CiAgICBnbG9iYWwgY2FudiBjYW52MiBsaW5laHRhZyBsaW5lbnRhZyBjb21taXRpbmZvIGZpbmRsb2MKCiAgICBzZXQgaGVhZGxpbmUgW2xpbmRleCAkY29tbWl0aW5mbygkaWQpIDBdCiAgICBzZXQgYXV0aG9yIFtsaW5kZXggJGNvbW1pdGluZm8oJGlkKSAxXQogICAgJGNhbnYgZGVsZXRlIG1hdGNoJHJvdwogICAgJGNhbnYyIGRlbGV0ZSBtYXRjaCRyb3cKICAgIGlmIHskZmluZGxvYyBlcSAiQWxsIGZpZWxkcyIgfHwgJGZpbmRsb2MgZXEgIkhlYWRsaW5lIn0gewoJc2V0IG0gW2ZpbmRtYXRjaGVzICRoZWFkbGluZV0KCWlmIHskbSBuZSB7fX0gewoJICAgIG1hcmttYXRjaGVzICRjYW52ICRyb3cgJGhlYWRsaW5lICRsaW5laHRhZygkcm93KSAkbSBcCgkJWyRjYW52IGl0ZW1jZ2V0ICRsaW5laHRhZygkcm93KSAtZm9udF0gJHJvdwoJfQogICAgfQogICAgaWYgeyRmaW5kbG9jIGVxICJBbGwgZmllbGRzIiB8fCAkZmluZGxvYyBlcSAiQXV0aG9yIn0gewoJc2V0IG0gW2ZpbmRtYXRjaGVzICRhdXRob3JdCglpZiB7JG0gbmUge319IHsKCSAgICBtYXJrbWF0Y2hlcyAkY2FudjIgJHJvdyAkYXV0aG9yICRsaW5lbnRhZygkcm93KSAkbSBcCgkJWyRjYW52MiBpdGVtY2dldCAkbGluZW50YWcoJHJvdykgLWZvbnRdICRyb3cKCX0KICAgIH0KfQoKcHJvYyB2cmVsX2NoYW5nZSB7bmFtZSBpeCBvcH0gewogICAgZ2xvYmFsIGhpZ2hsaWdodF9yZWxhdGVkCgogICAgcmhpZ2hsaWdodF9ub25lCiAgICBpZiB7JGhpZ2hsaWdodF9yZWxhdGVkIG5lICJOb25lIn0gewoJcnVuIGRyYXd2aXNpYmxlCiAgICB9Cn0KCiMgcHJlcGFyZSBmb3IgdGVzdGluZyB3aGV0aGVyIGNvbW1pdHMgYXJlIGRlc2NlbmRlbnRzIG9yIGFuY2VzdG9ycyBvZiBhCnByb2MgcmhpZ2hsaWdodF9zZWwge2F9IHsKICAgIGdsb2JhbCBkZXNjZW5kZW50IGRlc2NfdG9kbyBhbmNlc3RvciBhbmNfdG9kbwogICAgZ2xvYmFsIGhpZ2hsaWdodF9yZWxhdGVkIHJoaWdobGlnaHRzCgogICAgY2F0Y2gge3Vuc2V0IGRlc2NlbmRlbnR9CiAgICBzZXQgZGVzY190b2RvIFtsaXN0ICRhXQogICAgY2F0Y2gge3Vuc2V0IGFuY2VzdG9yfQogICAgc2V0IGFuY190b2RvIFtsaXN0ICRhXQogICAgaWYgeyRoaWdobGlnaHRfcmVsYXRlZCBuZSAiTm9uZSJ9IHsKCXJoaWdobGlnaHRfbm9uZQoJcnVuIGRyYXd2aXNpYmxlCiAgICB9Cn0KCnByb2MgcmhpZ2hsaWdodF9ub25lIHt9IHsKICAgIGdsb2JhbCByaGlnaGxpZ2h0cwoKICAgIGNhdGNoIHt1bnNldCByaGlnaGxpZ2h0c30KICAgIHVuYm9sZGVuCn0KCnByb2MgaXNfZGVzY2VuZGVudCB7YX0gewogICAgZ2xvYmFsIGN1cnZpZXcgY2hpbGRyZW4gY29tbWl0cm93IGRlc2NlbmRlbnQgZGVzY190b2RvCgogICAgc2V0IHYgJGN1cnZpZXcKICAgIHNldCBsYSAkY29tbWl0cm93KCR2LCRhKQogICAgc2V0IHRvZG8gJGRlc2NfdG9kbwogICAgc2V0IGxlZnRvdmVyIHt9CiAgICBzZXQgZG9uZSAwCiAgICBmb3Ige3NldCBpIDB9IHskaSA8IFtsbGVuZ3RoICR0b2RvXX0ge2luY3IgaX0gewoJc2V0IGRvIFtsaW5kZXggJHRvZG8gJGldCglpZiB7JGNvbW1pdHJvdygkdiwkZG8pIDwgJGxhfSB7CgkgICAgbGFwcGVuZCBsZWZ0b3ZlciAkZG8KCSAgICBjb250aW51ZQoJfQoJZm9yZWFjaCBuayAkY2hpbGRyZW4oJHYsJGRvKSB7CgkgICAgaWYgeyFbaW5mbyBleGlzdHMgZGVzY2VuZGVudCgkbmspXX0gewoJCXNldCBkZXNjZW5kZW50KCRuaykgMQoJCWxhcHBlbmQgdG9kbyAkbmsKCQlpZiB7JG5rIGVxICRhfSB7CgkJICAgIHNldCBkb25lIDEKCQl9CgkgICAgfQoJfQoJaWYgeyRkb25lfSB7CgkgICAgc2V0IGRlc2NfdG9kbyBbY29uY2F0ICRsZWZ0b3ZlciBbbHJhbmdlICR0b2RvIFtleHByIHskaSsxfV0gZW5kXV0KCSAgICByZXR1cm4KCX0KICAgIH0KICAgIHNldCBkZXNjZW5kZW50KCRhKSAwCiAgICBzZXQgZGVzY190b2RvICRsZWZ0b3Zlcgp9Cgpwcm9jIGlzX2FuY2VzdG9yIHthfSB7CiAgICBnbG9iYWwgY3VydmlldyBwYXJlbnRsaXN0IGNvbW1pdHJvdyBhbmNlc3RvciBhbmNfdG9kbwoKICAgIHNldCB2ICRjdXJ2aWV3CiAgICBzZXQgbGEgJGNvbW1pdHJvdygkdiwkYSkKICAgIHNldCB0b2RvICRhbmNfdG9kbwogICAgc2V0IGxlZnRvdmVyIHt9CiAgICBzZXQgZG9uZSAwCiAgICBmb3Ige3NldCBpIDB9IHskaSA8IFtsbGVuZ3RoICR0b2RvXX0ge2luY3IgaX0gewoJc2V0IGRvIFtsaW5kZXggJHRvZG8gJGldCglpZiB7IVtpbmZvIGV4aXN0cyBjb21taXRyb3coJHYsJGRvKV0gfHwgJGNvbW1pdHJvdygkdiwkZG8pID4gJGxhfSB7CgkgICAgbGFwcGVuZCBsZWZ0b3ZlciAkZG8KCSAgICBjb250aW51ZQoJfQoJZm9yZWFjaCBucCBbbGluZGV4ICRwYXJlbnRsaXN0ICRjb21taXRyb3coJHYsJGRvKV0gewoJICAgIGlmIHshW2luZm8gZXhpc3RzIGFuY2VzdG9yKCRucCldfSB7CgkJc2V0IGFuY2VzdG9yKCRucCkgMQoJCWxhcHBlbmQgdG9kbyAkbnAKCQlpZiB7JG5wIGVxICRhfSB7CgkJICAgIHNldCBkb25lIDEKCQl9CgkgICAgfQoJfQoJaWYgeyRkb25lfSB7CgkgICAgc2V0IGFuY190b2RvIFtjb25jYXQgJGxlZnRvdmVyIFtscmFuZ2UgJHRvZG8gW2V4cHIgeyRpKzF9XSBlbmRdXQoJICAgIHJldHVybgoJfQogICAgfQogICAgc2V0IGFuY2VzdG9yKCRhKSAwCiAgICBzZXQgYW5jX3RvZG8gJGxlZnRvdmVyCn0KCnByb2MgYXNrcmVsaGlnaGxpZ2h0IHtyb3cgaWR9IHsKICAgIGdsb2JhbCBkZXNjZW5kZW50IGhpZ2hsaWdodF9yZWxhdGVkIGlkZHJhd24gbWFpbmZvbnQgcmhpZ2hsaWdodHMKICAgIGdsb2JhbCBzZWxlY3RlZGxpbmUgYW5jZXN0b3IKCiAgICBpZiB7IVtpbmZvIGV4aXN0cyBzZWxlY3RlZGxpbmVdfSByZXR1cm4KICAgIHNldCBpc2JvbGQgMAogICAgaWYgeyRoaWdobGlnaHRfcmVsYXRlZCBlcSAiRGVzY2VuZGVudCIgfHwKCSRoaWdobGlnaHRfcmVsYXRlZCBlcSAiTm90IGRlc2NlbmRlbnQifSB7CglpZiB7IVtpbmZvIGV4aXN0cyBkZXNjZW5kZW50KCRpZCldfSB7CgkgICAgaXNfZGVzY2VuZGVudCAkaWQKCX0KCWlmIHskZGVzY2VuZGVudCgkaWQpID09ICgkaGlnaGxpZ2h0X3JlbGF0ZWQgZXEgIkRlc2NlbmRlbnQiKX0gewoJICAgIHNldCBpc2JvbGQgMQoJfQogICAgfSBlbHNlaWYgeyRoaWdobGlnaHRfcmVsYXRlZCBlcSAiQW5jZXN0b3IiIHx8CgkgICAgICAkaGlnaGxpZ2h0X3JlbGF0ZWQgZXEgIk5vdCBhbmNlc3RvciJ9IHsKCWlmIHshW2luZm8gZXhpc3RzIGFuY2VzdG9yKCRpZCldfSB7CgkgICAgaXNfYW5jZXN0b3IgJGlkCgl9CglpZiB7JGFuY2VzdG9yKCRpZCkgPT0gKCRoaWdobGlnaHRfcmVsYXRlZCBlcSAiQW5jZXN0b3IiKX0gewoJICAgIHNldCBpc2JvbGQgMQoJfQogICAgfQogICAgaWYge1tpbmZvIGV4aXN0cyBpZGRyYXduKCRpZCldfSB7CglpZiB7JGlzYm9sZCAmJiAhW2lzaGlnaGxpZ2h0ZWQgJHJvd119IHsKCSAgICBib2xkZW4gJHJvdyBbY29uY2F0ICRtYWluZm9udCBib2xkXQoJfQogICAgfQogICAgc2V0IHJoaWdobGlnaHRzKCRyb3cpICRpc2JvbGQKfQoKcHJvYyBuZXh0X2hsY29udCB7fSB7CiAgICBnbG9iYWwgZmhsX3JvdyBmaGxfZGlybiBkaXNwbGF5b3JkZXIgbnVtY29tbWl0cwogICAgZ2xvYmFsIHZoaWdobGlnaHRzIGZoaWdobGlnaHRzIG5oaWdobGlnaHRzIHJoaWdobGlnaHRzCiAgICBnbG9iYWwgaGx2aWV3IGZpbGVoaWdobGlnaHQgZmluZHN0cmluZyBoaWdobGlnaHRfcmVsYXRlZAoKICAgIGlmIHshW2luZm8gZXhpc3RzIGZobF9kaXJuXSB8fCAkZmhsX2Rpcm4gPT0gMH0gcmV0dXJuCiAgICBzZXQgcm93ICRmaGxfcm93CiAgICB3aGlsZSB7MX0gewoJaWYgeyRyb3cgPCAwIHx8ICRyb3cgPj0gJG51bWNvbW1pdHN9IHsKCSAgICBiZWxsCgkgICAgc2V0IGZobF9kaXJuIDAKCSAgICByZXR1cm4KCX0KCXNldCBpZCBbbGluZGV4ICRkaXNwbGF5b3JkZXIgJHJvd10KCWlmIHtbaW5mbyBleGlzdHMgaGx2aWV3XX0gewoJICAgIGlmIHshW2luZm8gZXhpc3RzIHZoaWdobGlnaHRzKCRyb3cpXX0gewoJCWFza3ZoaWdobGlnaHQgJHJvdyAkaWQKCSAgICB9CgkgICAgaWYgeyR2aGlnaGxpZ2h0cygkcm93KSA+IDB9IGJyZWFrCgl9CglpZiB7JGZpbmRzdHJpbmcgbmUge319IHsKCSAgICBpZiB7IVtpbmZvIGV4aXN0cyBuaGlnaGxpZ2h0cygkcm93KV19IHsKCQlhc2tmaW5kaGlnaGxpZ2h0ICRyb3cgJGlkCgkgICAgfQoJICAgIGlmIHskbmhpZ2hsaWdodHMoJHJvdykgPiAwfSBicmVhawoJfQoJaWYgeyRoaWdobGlnaHRfcmVsYXRlZCBuZSAiTm9uZSJ9IHsKCSAgICBpZiB7IVtpbmZvIGV4aXN0cyByaGlnaGxpZ2h0cygkcm93KV19IHsKCQlhc2tyZWxoaWdobGlnaHQgJHJvdyAkaWQKCSAgICB9CgkgICAgaWYgeyRyaGlnaGxpZ2h0cygkcm93KSA+IDB9IGJyZWFrCgl9CglpZiB7W2luZm8gZXhpc3RzIGZpbGVoaWdobGlnaHRdfSB7CgkgICAgaWYgeyFbaW5mbyBleGlzdHMgZmhpZ2hsaWdodHMoJHJvdyldfSB7CgkJIyBhc2sgZm9yIGEgZmV3IG1vcmUgd2hpbGUgd2UncmUgYXQgaXQuLi4KCQlzZXQgciAkcm93CgkJZm9yIHtzZXQgbiAwfSB7JG4gPCAxMDB9IHtpbmNyIG59IHsKCQkgICAgaWYgeyFbaW5mbyBleGlzdHMgZmhpZ2hsaWdodHMoJHIpXX0gewoJCQlhc2tmaWxlaGlnaGxpZ2h0ICRyIFtsaW5kZXggJGRpc3BsYXlvcmRlciAkcl0KCQkgICAgfQoJCSAgICBpbmNyIHIgJGZobF9kaXJuCgkJICAgIGlmIHskciA8IDAgfHwgJHIgPj0gJG51bWNvbW1pdHN9IGJyZWFrCgkJfQoJCWZsdXNoaGlnaGxpZ2h0cwoJICAgIH0KCSAgICBpZiB7JGZoaWdobGlnaHRzKCRyb3cpIDwgMH0gewoJCXNldCBmaGxfcm93ICRyb3cKCQlyZXR1cm4KCSAgICB9CgkgICAgaWYgeyRmaGlnaGxpZ2h0cygkcm93KSA+IDB9IGJyZWFrCgl9CglpbmNyIHJvdyAkZmhsX2Rpcm4KICAgIH0KICAgIHNldCBmaGxfZGlybiAwCiAgICBzZWxlY3RsaW5lICRyb3cgMQp9Cgpwcm9jIG5leHRfaGlnaGxpZ2h0IHtkaXJufSB7CiAgICBnbG9iYWwgc2VsZWN0ZWRsaW5lIGZobF9yb3cgZmhsX2Rpcm4KICAgIGdsb2JhbCBobHZpZXcgZmlsZWhpZ2hsaWdodCBmaW5kc3RyaW5nIGhpZ2hsaWdodF9yZWxhdGVkCgogICAgaWYgeyFbaW5mbyBleGlzdHMgc2VsZWN0ZWRsaW5lXX0gcmV0dXJuCiAgICBpZiB7IShbaW5mbyBleGlzdHMgaGx2aWV3XSB8fCAkZmluZHN0cmluZyBuZSB7fSB8fAoJICAkaGlnaGxpZ2h0X3JlbGF0ZWQgbmUgIk5vbmUiIHx8IFtpbmZvIGV4aXN0cyBmaWxlaGlnaGxpZ2h0XSl9IHJldHVybgogICAgc2V0IGZobF9yb3cgW2V4cHIgeyRzZWxlY3RlZGxpbmUgKyAkZGlybn1dCiAgICBzZXQgZmhsX2Rpcm4gJGRpcm4KICAgIG5leHRfaGxjb250Cn0KCnByb2MgY2FuY2VsX25leHRfaGlnaGxpZ2h0IHt9IHsKICAgIGdsb2JhbCBmaGxfZGlybgoKICAgIHNldCBmaGxfZGlybiAwCn0KCiMgR3JhcGggbGF5b3V0IGZ1bmN0aW9ucwoKcHJvYyBzaG9ydGlkcyB7aWRzfSB7CiAgICBzZXQgcmVzIHt9CiAgICBmb3JlYWNoIGlkICRpZHMgewoJaWYge1tsbGVuZ3RoICRpZF0gPiAxfSB7CgkgICAgbGFwcGVuZCByZXMgW3Nob3J0aWRzICRpZF0KCX0gZWxzZWlmIHtbcmVnZXhwIHteWzAtOWEtZl17NDB9JH0gJGlkXX0gewoJICAgIGxhcHBlbmQgcmVzIFtzdHJpbmcgcmFuZ2UgJGlkIDAgN10KCX0gZWxzZSB7CgkgICAgbGFwcGVuZCByZXMgJGlkCgl9CiAgICB9CiAgICByZXR1cm4gJHJlcwp9Cgpwcm9jIGluY3JhbmdlIHtsIHggb30gewogICAgc2V0IG4gW2xsZW5ndGggJGxdCiAgICB3aGlsZSB7JHggPCAkbn0gewoJc2V0IGUgW2xpbmRleCAkbCAkeF0KCWlmIHskZSBuZSB7fX0gewoJICAgIGxzZXQgbCAkeCBbZXhwciB7JGUgKyAkb31dCgl9CglpbmNyIHgKICAgIH0KICAgIHJldHVybiAkbAp9Cgpwcm9jIG50aW1lcyB7biBvfSB7CiAgICBzZXQgcmV0IHt9CiAgICBmb3Ige30geyRuID4gMH0ge2luY3IgbiAtMX0gewoJbGFwcGVuZCByZXQgJG8KICAgIH0KICAgIHJldHVybiAkcmV0Cn0KCnByb2MgdXNlZGlucmFuZ2Uge2lkIGwxIGwyfSB7CiAgICBnbG9iYWwgY2hpbGRyZW4gY29tbWl0cm93IGN1cnZpZXcKCiAgICBpZiB7W2luZm8gZXhpc3RzIGNvbW1pdHJvdygkY3VydmlldywkaWQpXX0gewoJc2V0IHIgJGNvbW1pdHJvdygkY3VydmlldywkaWQpCglpZiB7JGwxIDw9ICRyICYmICRyIDw9ICRsMn0gewoJICAgIHJldHVybiBbZXhwciB7JHIgLSAkbDEgKyAxfV0KCX0KICAgIH0KICAgIHNldCBraWRzICRjaGlsZHJlbigkY3VydmlldywkaWQpCiAgICBmb3JlYWNoIGMgJGtpZHMgewoJc2V0IHIgJGNvbW1pdHJvdygkY3VydmlldywkYykKCWlmIHskbDEgPD0gJHIgJiYgJHIgPD0gJGwyfSB7CgkgICAgcmV0dXJuIFtleHByIHskciAtICRsMSArIDF9XQoJfQogICAgfQogICAgcmV0dXJuIDAKfQoKcHJvYyBzYW5pdHkge3JvdyB7ZnVsbCAwfX0gewogICAgZ2xvYmFsIHJvd2lkbGlzdCByb3dvZmZzZXRzCgogICAgc2V0IGNvbCAtMQogICAgc2V0IGlkcyBbbGluZGV4ICRyb3dpZGxpc3QgJHJvd10KICAgIGZvcmVhY2ggaWQgJGlkcyB7CglpbmNyIGNvbAoJaWYgeyRpZCBlcSB7fX0gY29udGludWUKCWlmIHskY29sIDwgW2xsZW5ndGggJGlkc10gLSAxICYmCgkgICAgW2xzZWFyY2ggLWV4YWN0IC1zdGFydCBbZXhwciB7JGNvbCsxfV0gJGlkcyAkaWRdID49IDB9IHsKCSAgICBwdXRzICJvb3BzOiBbc2hvcnRpZHMgJGlkXSByZXBlYXRlZCBpbiByb3cgJHJvdyBjb2wgJGNvbDoge1tzaG9ydGlkcyBbbGluZGV4ICRyb3dpZGxpc3QgJHJvd11dfSIKCX0KCXNldCBvIFtsaW5kZXggJHJvd29mZnNldHMgJHJvdyAkY29sXQoJc2V0IHkgJHJvdwoJc2V0IHggJGNvbAoJd2hpbGUgeyRvIG5lIHt9fSB7CgkgICAgaW5jciB5IC0xCgkgICAgaW5jciB4ICRvCgkgICAgaWYge1tsaW5kZXggJHJvd2lkbGlzdCAkeSAkeF0gIT0gJGlkfSB7CgkJcHV0cyAib29wczogcm93b2Zmc2V0cyB3cm9uZyBhdCByb3cgW2V4cHIgeyR5KzF9XSBjb2wgW2V4cHIgeyR4LSRvfV0iCgkJcHV0cyAiICBpZD1bc2hvcnRpZHMgJGlkXSBjaGVjayBzdGFydGVkIGF0IHJvdyAkcm93IgoJCWZvciB7c2V0IGkgJHJvd30geyRpID49ICR5fSB7aW5jciBpIC0xfSB7CgkJICAgIHB1dHMgIiAgcm93ICRpIGlkcz17W3Nob3J0aWRzIFtsaW5kZXggJHJvd2lkbGlzdCAkaV1dfSBvZmZzPXtbbGluZGV4ICRyb3dvZmZzZXRzICRpXX0iCgkJfQoJCWJyZWFrCgkgICAgfQoJICAgIGlmIHshJGZ1bGx9IGJyZWFrCgkgICAgc2V0IG8gW2xpbmRleCAkcm93b2Zmc2V0cyAkeSAkeF0KCX0KICAgIH0KfQoKcHJvYyBtYWtldXBhcnJvdyB7b2lkIHggeSB6fSB7CiAgICBnbG9iYWwgcm93aWRsaXN0IHJvd29mZnNldHMgdXBhcnJvd2xlbiBpZHJvd3JhbmdlcyBkaXNwbGF5b3JkZXIKCiAgICBmb3Ige3NldCBpIDF9IHskaSA8ICR1cGFycm93bGVuICYmICR5ID4gMX0ge2luY3IgaX0gewoJaW5jciB5IC0xCglpbmNyIHggJHoKCXNldCBvZmYwIFtsaW5kZXggJHJvd29mZnNldHMgJHldCglmb3Ige3NldCB4MCAkeH0gezF9IHtpbmNyIHgwfSB7CgkgICAgaWYgeyR4MCA+PSBbbGxlbmd0aCAkb2ZmMF19IHsKCQlzZXQgeDAgW2xsZW5ndGggW2xpbmRleCAkcm93b2Zmc2V0cyBbZXhwciB7JHktMX1dXV0KCQlicmVhawoJICAgIH0KCSAgICBzZXQgeiBbbGluZGV4ICRvZmYwICR4MF0KCSAgICBpZiB7JHogbmUge319IHsKCQlpbmNyIHgwICR6CgkJYnJlYWsKCSAgICB9Cgl9CglzZXQgeiBbZXhwciB7JHgwIC0gJHh9XQoJbHNldCByb3dpZGxpc3QgJHkgW2xpbnNlcnQgW2xpbmRleCAkcm93aWRsaXN0ICR5XSAkeCAkb2lkXQoJbHNldCByb3dvZmZzZXRzICR5IFtsaW5zZXJ0IFtsaW5kZXggJHJvd29mZnNldHMgJHldICR4ICR6XQogICAgfQogICAgc2V0IHRtcCBbbHJlcGxhY2UgW2xpbmRleCAkcm93b2Zmc2V0cyAkeV0gJHggJHgge31dCiAgICBsc2V0IHJvd29mZnNldHMgJHkgW2luY3JhbmdlICR0bXAgW2V4cHIgeyR4KzF9XSAtMV0KICAgIGxhcHBlbmQgaWRyb3dyYW5nZXMoJG9pZCkgW2xpbmRleCAkZGlzcGxheW9yZGVyICR5XQp9Cgpwcm9jIGluaXRsYXlvdXQge30gewogICAgZ2xvYmFsIHJvd2lkbGlzdCByb3dvZmZzZXRzIGRpc3BsYXlvcmRlciBjb21taXRsaXN0ZWQKICAgIGdsb2JhbCByb3dsYWlkb3V0IHJvd29wdGltCiAgICBnbG9iYWwgaWRpbmxpc3Qgcm93Y2hrIHJvd3JhbmdlbGlzdCBpZHJvd3JhbmdlcwogICAgZ2xvYmFsIG51bWNvbW1pdHMgY2FudnhtYXggY2FudgogICAgZ2xvYmFsIG5leHRjb2xvcgogICAgZ2xvYmFsIHBhcmVudGxpc3QKICAgIGdsb2JhbCBjb2xvcm1hcCByb3d0ZXh0eAogICAgZ2xvYmFsIHNlbGVjdGZpcnN0CgogICAgc2V0IG51bWNvbW1pdHMgMAogICAgc2V0IGRpc3BsYXlvcmRlciB7fQogICAgc2V0IGNvbW1pdGxpc3RlZCB7fQogICAgc2V0IHBhcmVudGxpc3Qge30KICAgIHNldCByb3dyYW5nZWxpc3Qge30KICAgIHNldCBuZXh0Y29sb3IgMAogICAgc2V0IHJvd2lkbGlzdCB7e319CiAgICBzZXQgcm93b2Zmc2V0cyB7e319CiAgICBjYXRjaCB7dW5zZXQgaWRpbmxpc3R9CiAgICBjYXRjaCB7dW5zZXQgcm93Y2hrfQogICAgc2V0IHJvd2xhaWRvdXQgMAogICAgc2V0IHJvd29wdGltIDAKICAgIHNldCBjYW52eG1heCBbJGNhbnYgY2dldCAtd2lkdGhdCiAgICBjYXRjaCB7dW5zZXQgY29sb3JtYXB9CiAgICBjYXRjaCB7dW5zZXQgcm93dGV4dHh9CiAgICBjYXRjaCB7dW5zZXQgaWRyb3dyYW5nZXN9CiAgICBzZXQgc2VsZWN0Zmlyc3QgMQp9Cgpwcm9jIHNldGNhbnZzY3JvbGwge30gewogICAgZ2xvYmFsIGNhbnYgY2FudjIgY2FudjMgbnVtY29tbWl0cyBsaW5lc3BjIGNhbnZ4bWF4IGNhbnZ5MAoKICAgIHNldCB5bWF4IFtleHByIHskY2FudnkwICsgKCRudW1jb21taXRzIC0gMC41KSAqICRsaW5lc3BjICsgMn1dCiAgICAkY2FudiBjb25mIC1zY3JvbGxyZWdpb24gW2xpc3QgMCAwICRjYW52eG1heCAkeW1heF0KICAgICRjYW52MiBjb25mIC1zY3JvbGxyZWdpb24gW2xpc3QgMCAwIDAgJHltYXhdCiAgICAkY2FudjMgY29uZiAtc2Nyb2xscmVnaW9uIFtsaXN0IDAgMCAwICR5bWF4XQp9Cgpwcm9jIHZpc2libGVyb3dzIHt9IHsKICAgIGdsb2JhbCBjYW52IG51bWNvbW1pdHMgbGluZXNwYwoKICAgIHNldCB5bWF4IFtsaW5kZXggWyRjYW52IGNnZXQgLXNjcm9sbHJlZ2lvbl0gM10KICAgIGlmIHskeW1heCBlcSB7fSB8fCAkeW1heCA9PSAwfSByZXR1cm4KICAgIHNldCBmIFskY2FudiB5dmlld10KICAgIHNldCB5MCBbZXhwciB7aW50KFtsaW5kZXggJGYgMF0gKiAkeW1heCl9XQogICAgc2V0IHIwIFtleHByIHtpbnQoKCR5MCAtIDMpIC8gJGxpbmVzcGMpIC0gMX1dCiAgICBpZiB7JHIwIDwgMH0gewoJc2V0IHIwIDAKICAgIH0KICAgIHNldCB5MSBbZXhwciB7aW50KFtsaW5kZXggJGYgMV0gKiAkeW1heCl9XQogICAgc2V0IHIxIFtleHByIHtpbnQoKCR5MSAtIDMpIC8gJGxpbmVzcGMpICsgMX1dCiAgICBpZiB7JHIxID49ICRudW1jb21taXRzfSB7CglzZXQgcjEgW2V4cHIgeyRudW1jb21taXRzIC0gMX1dCiAgICB9CiAgICByZXR1cm4gW2xpc3QgJHIwICRyMV0KfQoKcHJvYyBsYXlvdXRtb3JlIHt0bWF4IGFsbHJlYWR9IHsKICAgIGdsb2JhbCByb3dsYWlkb3V0IHJvd29wdGltIGNvbW1pdGlkeCBudW1jb21taXRzIG9wdGltX2RlbGF5CiAgICBnbG9iYWwgdXBhcnJvd2xlbiBjdXJ2aWV3IHJvd2lkbGlzdCBpZGlubGlzdAoKICAgIHNldCBzaG93bGFzdCAwCiAgICBzZXQgc2hvd2RlbGF5ICRvcHRpbV9kZWxheQogICAgc2V0IG9wdGRlbGF5IFtleHByIHskdXBhcnJvd2xlbiArIDF9XQogICAgd2hpbGUgezF9IHsKCWlmIHskcm93b3B0aW0gLSAkc2hvd2RlbGF5ID4gJG51bWNvbW1pdHN9IHsKCSAgICBzaG93c3R1ZmYgW2V4cHIgeyRyb3dvcHRpbSAtICRzaG93ZGVsYXl9XSAkc2hvd2xhc3QKCX0gZWxzZWlmIHskcm93bGFpZG91dCAtICRvcHRkZWxheSA+ICRyb3dvcHRpbX0gewoJICAgIHNldCBuciBbZXhwciB7JHJvd2xhaWRvdXQgLSAkb3B0ZGVsYXkgLSAkcm93b3B0aW19XQoJICAgIGlmIHskbnIgPiAxMDB9IHsKCQlzZXQgbnIgMTAwCgkgICAgfQoJICAgIG9wdGltaXplX3Jvd3MgJHJvd29wdGltIDAgW2V4cHIgeyRyb3dvcHRpbSArICRucn1dCgkgICAgaW5jciByb3dvcHRpbSAkbnIKCX0gZWxzZWlmIHskY29tbWl0aWR4KCRjdXJ2aWV3KSA+ICRyb3dsYWlkb3V0fSB7CgkgICAgc2V0IG5yIFtleHByIHskY29tbWl0aWR4KCRjdXJ2aWV3KSAtICRyb3dsYWlkb3V0fV0KCSAgICAjIG1heSBuZWVkIHRvIGluY3JlYXNlIHRoaXMgdGhyZXNob2xkIGlmIHVwYXJyb3dsZW4gb3IKCSAgICAjIG1pbmdhcGxlbiBhcmUgaW5jcmVhc2VkLi4uCgkgICAgaWYgeyRuciA+IDE1MH0gewoJCXNldCBuciAxNTAKCSAgICB9CgkgICAgc2V0IHJvdyAkcm93bGFpZG91dAoJICAgIHNldCByb3dsYWlkb3V0IFtsYXlvdXRyb3dzICRyb3cgW2V4cHIgeyRyb3cgKyAkbnJ9XSAkYWxscmVhZF0KCSAgICBpZiB7JHJvd2xhaWRvdXQgPT0gJHJvd30gewoJCXJldHVybiAwCgkgICAgfQoJfSBlbHNlaWYgeyRhbGxyZWFkfSB7CgkgICAgc2V0IG9wdGRlbGF5IDAKCSAgICBzZXQgbnJvd3MgJGNvbW1pdGlkeCgkY3VydmlldykKCSAgICBpZiB7W2xpbmRleCAkcm93aWRsaXN0ICRucm93c10gbmUge30gfHwKCQlbYXJyYXkgbmFtZXMgaWRpbmxpc3RdIG5lIHt9fSB7CgkJbGF5b3V0dGFpbAoJCXNldCByb3dsYWlkb3V0ICRjb21taXRpZHgoJGN1cnZpZXcpCgkgICAgfSBlbHNlaWYgeyRyb3dvcHRpbSA9PSAkbnJvd3N9IHsKCQlzZXQgc2hvd2RlbGF5IDAKCQlzZXQgc2hvd2xhc3QgMQoJCWlmIHskbnVtY29tbWl0cyA9PSAkbnJvd3N9IHsKCQkgICAgcmV0dXJuIDAKCQl9CgkgICAgfQoJfSBlbHNlIHsKCSAgICByZXR1cm4gMAoJfQoJaWYgeyR0bWF4IG5lIHt9ICYmIFtjbG9jayBjbGlja3MgLW1pbGxpc2Vjb25kc10gPj0gJHRtYXh9IHsKCSAgICByZXR1cm4gMQoJfQogICAgfQp9Cgpwcm9jIHNob3dzdHVmZiB7Y2Fuc2hvdyBsYXN0fSB7CiAgICBnbG9iYWwgbnVtY29tbWl0cyBjb21taXRyb3cgcGVuZGluZ19zZWxlY3Qgc2VsZWN0ZWRsaW5lIGN1cnZpZXcKICAgIGdsb2JhbCBsb29raW5nZm9yaGVhZCBtYWluaGVhZGlkIGRpc3BsYXlvcmRlciBzZWxlY3RmaXJzdAogICAgZ2xvYmFsIGxhc3RzY3JvbGxzZXQKCiAgICBpZiB7JG51bWNvbW1pdHMgPT0gMH0gewoJZ2xvYmFsIHBoYXNlCglzZXQgcGhhc2UgImluY3JkcmF3IgoJYWxsY2FudnMgZGVsZXRlIGFsbAogICAgfQogICAgc2V0IHIwICRudW1jb21taXRzCiAgICBzZXQgcHJldiAkbnVtY29tbWl0cwogICAgc2V0IG51bWNvbW1pdHMgJGNhbnNob3cKICAgIHNldCB0IFtjbG9jayBjbGlja3MgLW1pbGxpc2Vjb25kc10KICAgIGlmIHskcHJldiA8IDEwMCB8fCAkbGFzdCB8fCAkdCAtICRsYXN0c2Nyb2xsc2V0ID4gNTAwfSB7CglzZXQgbGFzdHNjcm9sbHNldCAkdAoJc2V0Y2FudnNjcm9sbAogICAgfQogICAgc2V0IHJvd3MgW3Zpc2libGVyb3dzXQogICAgc2V0IHIxIFtsaW5kZXggJHJvd3MgMV0KICAgIGlmIHskcjEgPj0gJGNhbnNob3d9IHsKCXNldCByMSBbZXhwciB7JGNhbnNob3cgLSAxfV0KICAgIH0KICAgIGlmIHskcjAgPD0gJHIxfSB7CglkcmF3Y29tbWl0cyAkcjAgJHIxCiAgICB9CiAgICBpZiB7W2luZm8gZXhpc3RzIHBlbmRpbmdfc2VsZWN0XSAmJgoJW2luZm8gZXhpc3RzIGNvbW1pdHJvdygkY3VydmlldywkcGVuZGluZ19zZWxlY3QpXSAmJgoJJGNvbW1pdHJvdygkY3VydmlldywkcGVuZGluZ19zZWxlY3QpIDwgJG51bWNvbW1pdHN9IHsKCXNlbGVjdGxpbmUgJGNvbW1pdHJvdygkY3VydmlldywkcGVuZGluZ19zZWxlY3QpIDEKICAgIH0KICAgIGlmIHskc2VsZWN0Zmlyc3R9IHsKCWlmIHtbaW5mbyBleGlzdHMgc2VsZWN0ZWRsaW5lXSB8fCBbaW5mbyBleGlzdHMgcGVuZGluZ19zZWxlY3RdfSB7CgkgICAgc2V0IHNlbGVjdGZpcnN0IDAKCX0gZWxzZSB7CgkgICAgc2V0IGwgW2ZpcnN0X3JlYWxfcm93XQoJICAgIHNlbGVjdGxpbmUgJGwgMQoJICAgIHNldCBzZWxlY3RmaXJzdCAwCgl9CiAgICB9CiAgICBpZiB7JGxvb2tpbmdmb3JoZWFkICYmIFtpbmZvIGV4aXN0cyBjb21taXRyb3coJGN1cnZpZXcsJG1haW5oZWFkaWQpXQoJJiYgKCRsYXN0IHx8ICRjb21taXRyb3coJGN1cnZpZXcsJG1haW5oZWFkaWQpIDwgJG51bWNvbW1pdHMgLSAxKX0gewoJc2V0IGxvb2tpbmdmb3JoZWFkIDAKCWRvZGlmZmluZGV4CiAgICB9Cn0KCnByb2MgZG9zaG93bG9jYWxjaGFuZ2VzIHt9IHsKICAgIGdsb2JhbCBsb29raW5nZm9yaGVhZCBjdXJ2aWV3IG1haW5oZWFkaWQgcGhhc2UgY29tbWl0cm93CgogICAgaWYge1tpbmZvIGV4aXN0cyBjb21taXRyb3coJGN1cnZpZXcsJG1haW5oZWFkaWQpXSAmJgoJKCRwaGFzZSBlcSB7fSB8fCAkY29tbWl0cm93KCRjdXJ2aWV3LCRtYWluaGVhZGlkKSA8ICRudW1jb21taXRzIC0gMSl9IHsKCWRvZGlmZmluZGV4CiAgICB9IGVsc2VpZiB7JHBoYXNlIG5lIHt9fSB7CglzZXQgbG9va2luZ2ZvcmhlYWQgMQogICAgfQp9Cgpwcm9jIGRvaGlkZWxvY2FsY2hhbmdlcyB7fSB7CiAgICBnbG9iYWwgbG9va2luZ2ZvcmhlYWQgbG9jYWxmcm93IGxvY2FsaXJvdyBsc2VyaWFsCgogICAgc2V0IGxvb2tpbmdmb3JoZWFkIDAKICAgIGlmIHskbG9jYWxmcm93ID49IDB9IHsKCXJlbW92ZXJvdyAkbG9jYWxmcm93CglzZXQgbG9jYWxmcm93IC0xCglpZiB7JGxvY2FsaXJvdyA+IDB9IHsKCSAgICBpbmNyIGxvY2FsaXJvdyAtMQoJfQogICAgfQogICAgaWYgeyRsb2NhbGlyb3cgPj0gMH0gewoJcmVtb3Zlcm93ICRsb2NhbGlyb3cKCXNldCBsb2NhbGlyb3cgLTEKICAgIH0KICAgIGluY3IgbHNlcmlhbAp9CgojIHNwYXduIG9mZiBhIHByb2Nlc3MgdG8gZG8gZ2l0IGRpZmYtaW5kZXggLS1jYWNoZWQgSEVBRApwcm9jIGRvZGlmZmluZGV4IHt9IHsKICAgIGdsb2JhbCBsb2NhbGlyb3cgbG9jYWxmcm93IGxzZXJpYWwKCiAgICBpbmNyIGxzZXJpYWwKICAgIHNldCBsb2NhbGZyb3cgLTEKICAgIHNldCBsb2NhbGlyb3cgLTEKICAgIHNldCBmZCBbb3BlbiAifGdpdCBkaWZmLWluZGV4IC0tY2FjaGVkIEhFQUQiIHJdCiAgICBmY29uZmlndXJlICRmZCAtYmxvY2tpbmcgMAogICAgZmlsZXJ1biAkZmQgW2xpc3QgcmVhZGRpZmZpbmRleCAkZmQgJGxzZXJpYWxdCn0KCnByb2MgcmVhZGRpZmZpbmRleCB7ZmQgc2VyaWFsfSB7CiAgICBnbG9iYWwgbG9jYWxpcm93IGNvbW1pdHJvdyBtYWluaGVhZGlkIG51bGxpZDIgY3VydmlldwogICAgZ2xvYmFsIGNvbW1pdGluZm8gY29tbWl0ZGF0YSBsc2VyaWFsCgogICAgc2V0IGlzZGlmZiAxCiAgICBpZiB7W2dldHMgJGZkIGxpbmVdIDwgMH0gewoJaWYgeyFbZW9mICRmZF19IHsKCSAgICByZXR1cm4gMQoJfQoJc2V0IGlzZGlmZiAwCiAgICB9CiAgICAjIHdlIG9ubHkgbmVlZCB0byBzZWUgb25lIGxpbmUgYW5kIHdlIGRvbid0IHJlYWxseSBjYXJlIHdoYXQgaXQgc2F5cy4uLgogICAgY2xvc2UgJGZkCgogICAgIyBub3cgc2VlIGlmIHRoZXJlIGFyZSBhbnkgbG9jYWwgY2hhbmdlcyBub3QgY2hlY2tlZCBpbiB0byB0aGUgaW5kZXgKICAgIGlmIHskc2VyaWFsID09ICRsc2VyaWFsfSB7CglzZXQgZmQgW29wZW4gInxnaXQgZGlmZi1maWxlcyIgcl0KCWZjb25maWd1cmUgJGZkIC1ibG9ja2luZyAwCglmaWxlcnVuICRmZCBbbGlzdCByZWFkZGlmZmZpbGVzICRmZCAkc2VyaWFsXQogICAgfQoKICAgIGlmIHskaXNkaWZmICYmICRzZXJpYWwgPT0gJGxzZXJpYWwgJiYgJGxvY2FsaXJvdyA9PSAtMX0gewoJIyBhZGQgdGhlIGxpbmUgZm9yIHRoZSBjaGFuZ2VzIGluIHRoZSBpbmRleCB0byB0aGUgZ3JhcGgKCXNldCBsb2NhbGlyb3cgJGNvbW1pdHJvdygkY3VydmlldywkbWFpbmhlYWRpZCkKCXNldCBobCAiTG9jYWwgY2hhbmdlcyBjaGVja2VkIGluIHRvIGluZGV4IGJ1dCBub3QgY29tbWl0dGVkIgoJc2V0IGNvbW1pdGluZm8oJG51bGxpZDIpIFtsaXN0ICAkaGwge30ge30ge30ge30gIiAgICAkaGxcbiJdCglzZXQgY29tbWl0ZGF0YSgkbnVsbGlkMikgIlxuICAgICRobFxuIgoJaW5zZXJ0cm93ICRsb2NhbGlyb3cgJG51bGxpZDIKICAgIH0KICAgIHJldHVybiAwCn0KCnByb2MgcmVhZGRpZmZmaWxlcyB7ZmQgc2VyaWFsfSB7CiAgICBnbG9iYWwgbG9jYWxpcm93IGxvY2FsZnJvdyBjb21taXRyb3cgbWFpbmhlYWRpZCBudWxsaWQgY3VydmlldwogICAgZ2xvYmFsIGNvbW1pdGluZm8gY29tbWl0ZGF0YSBsc2VyaWFsCgogICAgc2V0IGlzZGlmZiAxCiAgICBpZiB7W2dldHMgJGZkIGxpbmVdIDwgMH0gewoJaWYgeyFbZW9mICRmZF19IHsKCSAgICByZXR1cm4gMQoJfQoJc2V0IGlzZGlmZiAwCiAgICB9CiAgICAjIHdlIG9ubHkgbmVlZCB0byBzZWUgb25lIGxpbmUgYW5kIHdlIGRvbid0IHJlYWxseSBjYXJlIHdoYXQgaXQgc2F5cy4uLgogICAgY2xvc2UgJGZkCgogICAgaWYgeyRpc2RpZmYgJiYgJHNlcmlhbCA9PSAkbHNlcmlhbCAmJiAkbG9jYWxmcm93ID09IC0xfSB7CgkjIGFkZCB0aGUgbGluZSBmb3IgdGhlIGxvY2FsIGRpZmYgdG8gdGhlIGdyYXBoCglpZiB7JGxvY2FsaXJvdyA+PSAwfSB7CgkgICAgc2V0IGxvY2FsZnJvdyAkbG9jYWxpcm93CgkgICAgaW5jciBsb2NhbGlyb3cKCX0gZWxzZSB7CgkgICAgc2V0IGxvY2FsZnJvdyAkY29tbWl0cm93KCRjdXJ2aWV3LCRtYWluaGVhZGlkKQoJfQoJc2V0IGhsICJMb2NhbCB1bmNvbW1pdHRlZCBjaGFuZ2VzLCBub3QgY2hlY2tlZCBpbiB0byBpbmRleCIKCXNldCBjb21taXRpbmZvKCRudWxsaWQpIFtsaXN0ICAkaGwge30ge30ge30ge30gIiAgICAkaGxcbiJdCglzZXQgY29tbWl0ZGF0YSgkbnVsbGlkKSAiXG4gICAgJGhsXG4iCglpbnNlcnRyb3cgJGxvY2FsZnJvdyAkbnVsbGlkCiAgICB9CiAgICByZXR1cm4gMAp9Cgpwcm9jIGxheW91dHJvd3Mge3JvdyBlbmRyb3cgbGFzdH0gewogICAgZ2xvYmFsIHJvd2lkbGlzdCByb3dvZmZzZXRzIGRpc3BsYXlvcmRlcgogICAgZ2xvYmFsIHVwYXJyb3dsZW4gZG93bmFycm93bGVuIG1heHdpZHRoIG1pbmdhcGxlbgogICAgZ2xvYmFsIGNoaWxkcmVuIHBhcmVudGxpc3QKICAgIGdsb2JhbCBpZHJvd3JhbmdlcwogICAgZ2xvYmFsIGNvbW1pdGlkeCBjdXJ2aWV3CiAgICBnbG9iYWwgaWRpbmxpc3Qgcm93Y2hrIHJvd3JhbmdlbGlzdAoKICAgIHNldCBpZGxpc3QgW2xpbmRleCAkcm93aWRsaXN0ICRyb3ddCiAgICBzZXQgb2ZmcyBbbGluZGV4ICRyb3dvZmZzZXRzICRyb3ddCiAgICB3aGlsZSB7JHJvdyA8ICRlbmRyb3d9IHsKCXNldCBpZCBbbGluZGV4ICRkaXNwbGF5b3JkZXIgJHJvd10KCXNldCBvbGRvbGRzIHt9CglzZXQgbmV3b2xkcyB7fQoJZm9yZWFjaCBwIFtsaW5kZXggJHBhcmVudGxpc3QgJHJvd10gewoJICAgIGlmIHshW2luZm8gZXhpc3RzIGlkaW5saXN0KCRwKV19IHsKCQlsYXBwZW5kIG5ld29sZHMgJHAKCSAgICB9IGVsc2VpZiB7ISRpZGlubGlzdCgkcCl9IHsKCQlsYXBwZW5kIG9sZG9sZHMgJHAKCSAgICB9Cgl9CglzZXQgbmV2IFtleHByIHtbbGxlbmd0aCAkaWRsaXN0XSArIFtsbGVuZ3RoICRuZXdvbGRzXQoJCSAgICAgICArIFtsbGVuZ3RoICRvbGRvbGRzXSAtICRtYXh3aWR0aCArIDF9XQoJaWYgeyRuZXYgPiAwfSB7CgkgICAgaWYgeyEkbGFzdCAmJgoJCSRyb3cgKyAkdXBhcnJvd2xlbiArICRtaW5nYXBsZW4gPj0gJGNvbW1pdGlkeCgkY3Vydmlldyl9IGJyZWFrCgkgICAgZm9yIHtzZXQgeCBbbGxlbmd0aCAkaWRsaXN0XX0ge1tpbmNyIHggLTFdID49IDB9IHt9IHsKCQlzZXQgaSBbbGluZGV4ICRpZGxpc3QgJHhdCgkJaWYgeyFbaW5mbyBleGlzdHMgcm93Y2hrKCRpKV0gfHwgJHJvdyA+PSAkcm93Y2hrKCRpKX0gewoJCSAgICBzZXQgciBbdXNlZGlucmFuZ2UgJGkgW2V4cHIgeyRyb3cgLSAkZG93bmFycm93bGVufV0gXAoJCQkgICAgICAgW2V4cHIgeyRyb3cgKyAkdXBhcnJvd2xlbiArICRtaW5nYXBsZW59XV0KCQkgICAgaWYgeyRyID09IDB9IHsKCQkJc2V0IGlkbGlzdCBbbHJlcGxhY2UgJGlkbGlzdCAkeCAkeF0KCQkJc2V0IG9mZnMgW2xyZXBsYWNlICRvZmZzICR4ICR4XQoJCQlzZXQgb2ZmcyBbaW5jcmFuZ2UgJG9mZnMgJHggMV0KCQkJc2V0IGlkaW5saXN0KCRpKSAwCgkJCXNldCBybTEgW2V4cHIgeyRyb3cgLSAxfV0KCQkJbGFwcGVuZCBpZHJvd3JhbmdlcygkaSkgW2xpbmRleCAkZGlzcGxheW9yZGVyICRybTFdCgkJCWlmIHtbaW5jciBuZXYgLTFdIDw9IDB9IGJyZWFrCgkJCWNvbnRpbnVlCgkJICAgIH0KCQkgICAgc2V0IHJvd2NoaygkaWQpIFtleHByIHskcm93ICsgJHJ9XQoJCX0KCSAgICB9CgkgICAgbHNldCByb3dpZGxpc3QgJHJvdyAkaWRsaXN0CgkgICAgbHNldCByb3dvZmZzZXRzICRyb3cgJG9mZnMKCX0KCXNldCBjb2wgW2xzZWFyY2ggLWV4YWN0ICRpZGxpc3QgJGlkXQoJaWYgeyRjb2wgPCAwfSB7CgkgICAgc2V0IGNvbCBbbGxlbmd0aCAkaWRsaXN0XQoJICAgIGxhcHBlbmQgaWRsaXN0ICRpZAoJICAgIGxzZXQgcm93aWRsaXN0ICRyb3cgJGlkbGlzdAoJICAgIHNldCB6IHt9CgkgICAgaWYgeyRjaGlsZHJlbigkY3VydmlldywkaWQpIG5lIHt9fSB7CgkJc2V0IHogW2V4cHIge1tsbGVuZ3RoIFtsaW5kZXggJHJvd2lkbGlzdCBbZXhwciB7JHJvdy0xfV1dXSAtICRjb2x9XQoJCXVuc2V0IGlkaW5saXN0KCRpZCkKCSAgICB9CgkgICAgbGFwcGVuZCBvZmZzICR6CgkgICAgbHNldCByb3dvZmZzZXRzICRyb3cgJG9mZnMKCSAgICBpZiB7JHogbmUge319IHsKCQltYWtldXBhcnJvdyAkaWQgJGNvbCAkcm93ICR6CgkgICAgfQoJfSBlbHNlIHsKCSAgICB1bnNldCBpZGlubGlzdCgkaWQpCgl9CglzZXQgcmFuZ2VzIHt9CglpZiB7W2luZm8gZXhpc3RzIGlkcm93cmFuZ2VzKCRpZCldfSB7CgkgICAgc2V0IHJhbmdlcyAkaWRyb3dyYW5nZXMoJGlkKQoJICAgIGxhcHBlbmQgcmFuZ2VzICRpZAoJICAgIHVuc2V0IGlkcm93cmFuZ2VzKCRpZCkKCX0KCWxhcHBlbmQgcm93cmFuZ2VsaXN0ICRyYW5nZXMKCWluY3Igcm93CglzZXQgb2ZmcyBbbnRpbWVzIFtsbGVuZ3RoICRpZGxpc3RdIDBdCglzZXQgbCBbbGxlbmd0aCAkbmV3b2xkc10KCXNldCBpZGxpc3QgW2V2YWwgbHJlcGxhY2UgXCRpZGxpc3QgJGNvbCAkY29sICRuZXdvbGRzXQoJc2V0IG8gMAoJaWYgeyRsICE9IDF9IHsKCSAgICBzZXQgb2ZmcyBbbHJhbmdlICRvZmZzIDAgW2V4cHIgeyRjb2wgLSAxfV1dCgkgICAgZm9yZWFjaCB4ICRuZXdvbGRzIHsKCQlsYXBwZW5kIG9mZnMge30KCQlpbmNyIG8gLTEKCSAgICB9CgkgICAgaW5jciBvCgkgICAgc2V0IHRtcCBbZXhwciB7W2xsZW5ndGggJGlkbGlzdF0gLSBbbGxlbmd0aCAkb2Zmc119XQoJICAgIGlmIHskdG1wID4gMH0gewoJCXNldCBvZmZzIFtjb25jYXQgJG9mZnMgW250aW1lcyAkdG1wICRvXV0KCSAgICB9Cgl9IGVsc2UgewoJICAgIGxzZXQgb2ZmcyAkY29sIHt9Cgl9Cglmb3JlYWNoIGkgJG5ld29sZHMgewoJICAgIHNldCBpZGlubGlzdCgkaSkgMQoJICAgIHNldCBpZHJvd3JhbmdlcygkaSkgJGlkCgl9CglpbmNyIGNvbCAkbAoJZm9yZWFjaCBvaWQgJG9sZG9sZHMgewoJICAgIHNldCBpZGlubGlzdCgkb2lkKSAxCgkgICAgc2V0IGlkbGlzdCBbbGluc2VydCAkaWRsaXN0ICRjb2wgJG9pZF0KCSAgICBzZXQgb2ZmcyBbbGluc2VydCAkb2ZmcyAkY29sICRvXQoJICAgIG1ha2V1cGFycm93ICRvaWQgJGNvbCAkcm93ICRvCgkgICAgaW5jciBjb2wKCX0KCWxhcHBlbmQgcm93aWRsaXN0ICRpZGxpc3QKCWxhcHBlbmQgcm93b2Zmc2V0cyAkb2ZmcwogICAgfQogICAgcmV0dXJuICRyb3cKfQoKcHJvYyBhZGRleHRyYWlkIHtpZCByb3d9IHsKICAgIGdsb2JhbCBkaXNwbGF5b3JkZXIgY29tbWl0cm93IGNvbW1pdGluZm8KICAgIGdsb2JhbCBjb21taXRpZHggY29tbWl0bGlzdGVkCiAgICBnbG9iYWwgcGFyZW50bGlzdCBjaGlsZHJlbiBjdXJ2aWV3CgogICAgaW5jciBjb21taXRpZHgoJGN1cnZpZXcpCiAgICBsYXBwZW5kIGRpc3BsYXlvcmRlciAkaWQKICAgIGxhcHBlbmQgY29tbWl0bGlzdGVkIDAKICAgIGxhcHBlbmQgcGFyZW50bGlzdCB7fQogICAgc2V0IGNvbW1pdHJvdygkY3VydmlldywkaWQpICRyb3cKICAgIHJlYWRjb21taXQgJGlkCiAgICBpZiB7IVtpbmZvIGV4aXN0cyBjb21taXRpbmZvKCRpZCldfSB7CglzZXQgY29tbWl0aW5mbygkaWQpIHsiTm8gY29tbWl0IGluZm9ybWF0aW9uIGF2YWlsYWJsZSJ9CiAgICB9CiAgICBpZiB7IVtpbmZvIGV4aXN0cyBjaGlsZHJlbigkY3VydmlldywkaWQpXX0gewoJc2V0IGNoaWxkcmVuKCRjdXJ2aWV3LCRpZCkge30KICAgIH0KfQoKcHJvYyBsYXlvdXR0YWlsIHt9IHsKICAgIGdsb2JhbCByb3dpZGxpc3Qgcm93b2Zmc2V0cyBpZGlubGlzdCBjb21taXRpZHggY3VydmlldwogICAgZ2xvYmFsIGlkcm93cmFuZ2VzIHJvd3JhbmdlbGlzdAoKICAgIHNldCByb3cgJGNvbW1pdGlkeCgkY3VydmlldykKICAgIHNldCBpZGxpc3QgW2xpbmRleCAkcm93aWRsaXN0ICRyb3ddCiAgICB3aGlsZSB7JGlkbGlzdCBuZSB7fX0gewoJc2V0IGNvbCBbZXhwciB7W2xsZW5ndGggJGlkbGlzdF0gLSAxfV0KCXNldCBpZCBbbGluZGV4ICRpZGxpc3QgJGNvbF0KCWFkZGV4dHJhaWQgJGlkICRyb3cKCXVuc2V0IGlkaW5saXN0KCRpZCkKCWxhcHBlbmQgaWRyb3dyYW5nZXMoJGlkKSAkaWQKCWxhcHBlbmQgcm93cmFuZ2VsaXN0ICRpZHJvd3JhbmdlcygkaWQpCgl1bnNldCBpZHJvd3JhbmdlcygkaWQpCglpbmNyIHJvdwoJc2V0IG9mZnMgW250aW1lcyAkY29sIDBdCglzZXQgaWRsaXN0IFtscmVwbGFjZSAkaWRsaXN0ICRjb2wgJGNvbF0KCWxhcHBlbmQgcm93aWRsaXN0ICRpZGxpc3QKCWxhcHBlbmQgcm93b2Zmc2V0cyAkb2ZmcwogICAgfQoKICAgIGZvcmVhY2ggaWQgW2FycmF5IG5hbWVzIGlkaW5saXN0XSB7Cgl1bnNldCBpZGlubGlzdCgkaWQpCglhZGRleHRyYWlkICRpZCAkcm93Cglsc2V0IHJvd2lkbGlzdCAkcm93IFtsaXN0ICRpZF0KCWxzZXQgcm93b2Zmc2V0cyAkcm93IDAKCW1ha2V1cGFycm93ICRpZCAwICRyb3cgMAoJbGFwcGVuZCBpZHJvd3JhbmdlcygkaWQpICRpZAoJbGFwcGVuZCByb3dyYW5nZWxpc3QgJGlkcm93cmFuZ2VzKCRpZCkKCXVuc2V0IGlkcm93cmFuZ2VzKCRpZCkKCWluY3Igcm93CglsYXBwZW5kIHJvd2lkbGlzdCB7fQoJbGFwcGVuZCByb3dvZmZzZXRzIHt9CiAgICB9Cn0KCnByb2MgaW5zZXJ0X3BhZCB7cm93IGNvbCBucGFkfSB7CiAgICBnbG9iYWwgcm93aWRsaXN0IHJvd29mZnNldHMKCiAgICBzZXQgcGFkIFtudGltZXMgJG5wYWQge31dCiAgICBsc2V0IHJvd2lkbGlzdCAkcm93IFtldmFsIGxpbnNlcnQgW2xpc3QgW2xpbmRleCAkcm93aWRsaXN0ICRyb3ddXSAkY29sICRwYWRdCiAgICBzZXQgdG1wIFtldmFsIGxpbnNlcnQgW2xpc3QgW2xpbmRleCAkcm93b2Zmc2V0cyAkcm93XV0gJGNvbCAkcGFkXQogICAgbHNldCByb3dvZmZzZXRzICRyb3cgW2luY3JhbmdlICR0bXAgW2V4cHIgeyRjb2wgKyAkbnBhZH1dIFtleHByIHstJG5wYWR9XV0KfQoKcHJvYyBvcHRpbWl6ZV9yb3dzIHtyb3cgY29sIGVuZHJvd30gewogICAgZ2xvYmFsIHJvd2lkbGlzdCByb3dvZmZzZXRzIGRpc3BsYXlvcmRlcgoKICAgIGZvciB7fSB7JHJvdyA8ICRlbmRyb3d9IHtpbmNyIHJvd30gewoJc2V0IGlkbGlzdCBbbGluZGV4ICRyb3dpZGxpc3QgJHJvd10KCXNldCBvZmZzIFtsaW5kZXggJHJvd29mZnNldHMgJHJvd10KCXNldCBoYXNwYWQgMAoJZm9yIHt9IHskY29sIDwgW2xsZW5ndGggJG9mZnNdfSB7aW5jciBjb2x9IHsKCSAgICBpZiB7W2xpbmRleCAkaWRsaXN0ICRjb2xdIGVxIHt9fSB7CgkJc2V0IGhhc3BhZCAxCgkJY29udGludWUKCSAgICB9CgkgICAgc2V0IHogW2xpbmRleCAkb2ZmcyAkY29sXQoJICAgIGlmIHskeiBlcSB7fX0gY29udGludWUKCSAgICBzZXQgaXNhcnJvdyAwCgkgICAgc2V0IHgwIFtleHByIHskY29sICsgJHp9XQoJICAgIHNldCB5MCBbZXhwciB7JHJvdyAtIDF9XQoJICAgIHNldCB6MCBbbGluZGV4ICRyb3dvZmZzZXRzICR5MCAkeDBdCgkgICAgaWYgeyR6MCBlcSB7fX0gewoJCXNldCBpZCBbbGluZGV4ICRpZGxpc3QgJGNvbF0KCQlzZXQgcmFuZ2VzIFtyb3dyYW5nZXMgJGlkXQoJCWlmIHskcmFuZ2VzIG5lIHt9ICYmICR5MCA+IFtsaW5kZXggJHJhbmdlcyAwXX0gewoJCSAgICBzZXQgaXNhcnJvdyAxCgkJfQoJICAgIH0KCSAgICAjIExvb2tpbmcgYXQgbGluZXMgZnJvbSB0aGlzIHJvdyB0byB0aGUgcHJldmlvdXMgcm93LAoJICAgICMgbWFrZSB0aGVtIGdvIHN0cmFpZ2h0IHVwIGlmIHRoZXkgZW5kIGluIGFuIGFycm93IG9uCgkgICAgIyB0aGUgcHJldmlvdXMgcm93OyBvdGhlcndpc2UgbWFrZSB0aGVtIGdvIHN0cmFpZ2h0IHVwCgkgICAgIyBvciBhdCA0NSBkZWdyZWVzLgoJICAgIGlmIHskeiA8IC0xIHx8ICgkeiA8IDAgJiYgJGlzYXJyb3cpfSB7CgkJIyBMaW5lIGN1cnJlbnRseSBnb2VzIGxlZnQgdG9vIG11Y2g7CgkJIyBpbnNlcnQgcGFkcyBpbiB0aGUgcHJldmlvdXMgcm93LCB0aGVuIG9wdGltaXplIGl0CgkJc2V0IG5wYWQgW2V4cHIgey0xIC0gJHogKyAkaXNhcnJvd31dCgkJc2V0IG9mZnMgW2luY3JhbmdlICRvZmZzICRjb2wgJG5wYWRdCgkJaW5zZXJ0X3BhZCAkeTAgJHgwICRucGFkCgkJaWYgeyR5MCA+IDB9IHsKCQkgICAgb3B0aW1pemVfcm93cyAkeTAgJHgwICRyb3cKCQl9CgkJc2V0IHogW2xpbmRleCAkb2ZmcyAkY29sXQoJCXNldCB4MCBbZXhwciB7JGNvbCArICR6fV0KCQlzZXQgejAgW2xpbmRleCAkcm93b2Zmc2V0cyAkeTAgJHgwXQoJICAgIH0gZWxzZWlmIHskeiA+IDEgfHwgKCR6ID4gMCAmJiAkaXNhcnJvdyl9IHsKCQkjIExpbmUgY3VycmVudGx5IGdvZXMgcmlnaHQgdG9vIG11Y2g7CgkJIyBpbnNlcnQgcGFkcyBpbiB0aGlzIGxpbmUgYW5kIGFkanVzdCB0aGUgbmV4dCdzIHJvd29mZnNldHMKCQlzZXQgbnBhZCBbZXhwciB7JHogLSAxICsgJGlzYXJyb3d9XQoJCXNldCB5MSBbZXhwciB7JHJvdyArIDF9XQoJCXNldCBvZmZzMiBbbGluZGV4ICRyb3dvZmZzZXRzICR5MV0KCQlzZXQgeDEgLTEKCQlmb3JlYWNoIHogJG9mZnMyIHsKCQkgICAgaW5jciB4MQoJCSAgICBpZiB7JHogZXEge30gfHwgJHgxICsgJHogPCAkY29sfSBjb250aW51ZQoJCSAgICBpZiB7JHgxICsgJHogPiAkY29sfSB7CgkJCWluY3IgbnBhZAoJCSAgICB9CgkJICAgIGxzZXQgcm93b2Zmc2V0cyAkeTEgW2luY3JhbmdlICRvZmZzMiAkeDEgJG5wYWRdCgkJICAgIGJyZWFrCgkJfQoJCXNldCBwYWQgW250aW1lcyAkbnBhZCB7fV0KCQlzZXQgaWRsaXN0IFtldmFsIGxpbnNlcnQgXCRpZGxpc3QgJGNvbCAkcGFkXQoJCXNldCB0bXAgW2V2YWwgbGluc2VydCBcJG9mZnMgJGNvbCAkcGFkXQoJCWluY3IgY29sICRucGFkCgkJc2V0IG9mZnMgW2luY3JhbmdlICR0bXAgJGNvbCBbZXhwciB7LSRucGFkfV1dCgkJc2V0IHogW2xpbmRleCAkb2ZmcyAkY29sXQoJCXNldCBoYXNwYWQgMQoJICAgIH0KCSAgICBpZiB7JHowIGVxIHt9ICYmICEkaXNhcnJvd30gewoJCSMgdGhpcyBsaW5lIGxpbmtzIHRvIGl0cyBmaXJzdCBjaGlsZCBvbiByb3cgJHJvdy0yCgkJc2V0IHJtMiBbZXhwciB7JHJvdyAtIDJ9XQoJCXNldCBpZCBbbGluZGV4ICRkaXNwbGF5b3JkZXIgJHJtMl0KCQlzZXQgeGMgW2xzZWFyY2ggLWV4YWN0IFtsaW5kZXggJHJvd2lkbGlzdCAkcm0yXSAkaWRdCgkJaWYgeyR4YyA+PSAwfSB7CgkJICAgIHNldCB6MCBbZXhwciB7JHhjIC0gJHgwfV0KCQl9CgkgICAgfQoJICAgICMgYXZvaWQgbGluZXMgamlnZ2luZyBsZWZ0IHRoZW4gaW1tZWRpYXRlbHkgcmlnaHQKCSAgICBpZiB7JHowIG5lIHt9ICYmICR6IDwgMCAmJiAkejAgPiAwfSB7CgkJaW5zZXJ0X3BhZCAkeTAgJHgwIDEKCQlzZXQgb2ZmcyBbaW5jcmFuZ2UgJG9mZnMgJGNvbCAxXQoJCW9wdGltaXplX3Jvd3MgJHkwIFtleHByIHskeDAgKyAxfV0gJHJvdwoJICAgIH0KCX0KCWlmIHshJGhhc3BhZH0gewoJICAgIHNldCBvIHt9CgkgICAgIyBGaW5kIHRoZSBmaXJzdCBjb2x1bW4gdGhhdCBkb2Vzbid0IGhhdmUgYSBsaW5lIGdvaW5nIHJpZ2h0CgkgICAgZm9yIHtzZXQgY29sIFtsbGVuZ3RoICRpZGxpc3RdfSB7W2luY3IgY29sIC0xXSA+PSAwfSB7fSB7CgkJc2V0IG8gW2xpbmRleCAkb2ZmcyAkY29sXQoJCWlmIHskbyBlcSB7fX0gewoJCSAgICAjIGNoZWNrIGlmIHRoaXMgaXMgdGhlIGxpbmsgdG8gdGhlIGZpcnN0IGNoaWxkCgkJICAgIHNldCBpZCBbbGluZGV4ICRpZGxpc3QgJGNvbF0KCQkgICAgc2V0IHJhbmdlcyBbcm93cmFuZ2VzICRpZF0KCQkgICAgaWYgeyRyYW5nZXMgbmUge30gJiYgJHJvdyA9PSBbbGluZGV4ICRyYW5nZXMgMF19IHsKCQkJIyBpdCBpcywgd29yayBvdXQgb2Zmc2V0IHRvIGNoaWxkCgkJCXNldCB5MCBbZXhwciB7JHJvdyAtIDF9XQoJCQlzZXQgaWQgW2xpbmRleCAkZGlzcGxheW9yZGVyICR5MF0KCQkJc2V0IHgwIFtsc2VhcmNoIC1leGFjdCBbbGluZGV4ICRyb3dpZGxpc3QgJHkwXSAkaWRdCgkJCWlmIHskeDAgPj0gMH0gewoJCQkgICAgc2V0IG8gW2V4cHIgeyR4MCAtICRjb2x9XQoJCQl9CgkJICAgIH0KCQl9CgkJaWYgeyRvIGVxIHt9IHx8ICRvIDw9IDB9IGJyZWFrCgkgICAgfQoJICAgICMgSW5zZXJ0IGEgcGFkIGF0IHRoYXQgY29sdW1uIGFzIGxvbmcgYXMgaXQgaGFzIGEgbGluZSBhbmQKCSAgICAjIGlzbid0IHRoZSBsYXN0IGNvbHVtbiwgYW5kIGFkanVzdCB0aGUgbmV4dCByb3cnIG9mZnNldHMKCSAgICBpZiB7JG8gbmUge30gJiYgW2luY3IgY29sXSA8IFtsbGVuZ3RoICRpZGxpc3RdfSB7CgkJc2V0IHkxIFtleHByIHskcm93ICsgMX1dCgkJc2V0IG9mZnMyIFtsaW5kZXggJHJvd29mZnNldHMgJHkxXQoJCXNldCB4MSAtMQoJCWZvcmVhY2ggeiAkb2ZmczIgewoJCSAgICBpbmNyIHgxCgkJICAgIGlmIHskeiBlcSB7fSB8fCAkeDEgKyAkeiA8ICRjb2x9IGNvbnRpbnVlCgkJICAgIGxzZXQgcm93b2Zmc2V0cyAkeTEgW2luY3JhbmdlICRvZmZzMiAkeDEgMV0KCQkgICAgYnJlYWsKCQl9CgkJc2V0IGlkbGlzdCBbbGluc2VydCAkaWRsaXN0ICRjb2wge31dCgkJc2V0IHRtcCBbbGluc2VydCAkb2ZmcyAkY29sIHt9XQoJCWluY3IgY29sCgkJc2V0IG9mZnMgW2luY3JhbmdlICR0bXAgJGNvbCAtMV0KCSAgICB9Cgl9Cglsc2V0IHJvd2lkbGlzdCAkcm93ICRpZGxpc3QKCWxzZXQgcm93b2Zmc2V0cyAkcm93ICRvZmZzCglzZXQgY29sIDAKICAgIH0KfQoKcHJvYyB4YyB7cm93IGNvbH0gewogICAgZ2xvYmFsIGNhbnZ4MCBsaW5lc3BjCiAgICByZXR1cm4gW2V4cHIgeyRjYW52eDAgKyAkY29sICogJGxpbmVzcGN9XQp9Cgpwcm9jIHljIHtyb3d9IHsKICAgIGdsb2JhbCBjYW52eTAgbGluZXNwYwogICAgcmV0dXJuIFtleHByIHskY2FudnkwICsgJHJvdyAqICRsaW5lc3BjfV0KfQoKcHJvYyBsaW5ld2lkdGgge2lkfSB7CiAgICBnbG9iYWwgdGhpY2tlcmxpbmUgbHRoaWNrbmVzcwoKICAgIHNldCB3aWQgJGx0aGlja25lc3MKICAgIGlmIHtbaW5mbyBleGlzdHMgdGhpY2tlcmxpbmVdICYmICRpZCBlcSAkdGhpY2tlcmxpbmV9IHsKCXNldCB3aWQgW2V4cHIgezIgKiAkbHRoaWNrbmVzc31dCiAgICB9CiAgICByZXR1cm4gJHdpZAp9Cgpwcm9jIHJvd3JhbmdlcyB7aWR9IHsKICAgIGdsb2JhbCBwaGFzZSBpZHJvd3JhbmdlcyBjb21taXRyb3cgcm93bGFpZG91dCByb3dyYW5nZWxpc3QgY3VydmlldwoKICAgIHNldCByYW5nZXMge30KICAgIGlmIHskcGhhc2UgZXEge30gfHwKCShbaW5mbyBleGlzdHMgY29tbWl0cm93KCRjdXJ2aWV3LCRpZCldCgkgJiYgJGNvbW1pdHJvdygkY3VydmlldywkaWQpIDwgJHJvd2xhaWRvdXQpfSB7CglzZXQgcmFuZ2VzIFtsaW5kZXggJHJvd3JhbmdlbGlzdCAkY29tbWl0cm93KCRjdXJ2aWV3LCRpZCldCiAgICB9IGVsc2VpZiB7W2luZm8gZXhpc3RzIGlkcm93cmFuZ2VzKCRpZCldfSB7CglzZXQgcmFuZ2VzICRpZHJvd3JhbmdlcygkaWQpCiAgICB9CiAgICBzZXQgbGluZW5vcyB7fQogICAgZm9yZWFjaCByaWQgJHJhbmdlcyB7CglsYXBwZW5kIGxpbmVub3MgJGNvbW1pdHJvdygkY3VydmlldywkcmlkKQogICAgfQogICAgaWYgeyRsaW5lbm9zIG5lIHt9fSB7Cglsc2V0IGxpbmVub3MgMCBbZXhwciB7W2xpbmRleCAkbGluZW5vcyAwXSArIDF9XQogICAgfQogICAgcmV0dXJuICRsaW5lbm9zCn0KCiMgd29yayBhcm91bmQgdGs4LjQgcmVmdXNhbCB0byBkcmF3IGFycm93cyBvbiBkaWFnb25hbCBzZWdtZW50cwpwcm9jIGFkamFycm93aGlnaCB7Y29vcmRzfSB7CiAgICBnbG9iYWwgbGluZXNwYwoKICAgIHNldCB4MCBbbGluZGV4ICRjb29yZHMgMF0KICAgIHNldCB4MSBbbGluZGV4ICRjb29yZHMgMl0KICAgIGlmIHskeDAgIT0gJHgxfSB7CglzZXQgeTAgW2xpbmRleCAkY29vcmRzIDFdCglzZXQgeTEgW2xpbmRleCAkY29vcmRzIDNdCglpZiB7JHkwIC0gJHkxIDw9IDIgKiAkbGluZXNwYyAmJiAkeDEgPT0gW2xpbmRleCAkY29vcmRzIDRdfSB7CgkgICAgIyB3ZSBoYXZlIGEgbmVhcmJ5IHZlcnRpY2FsIHNlZ21lbnQsIGp1c3QgdHJpbSBvZmYgdGhlIGRpYWcgYml0CgkgICAgc2V0IGNvb3JkcyBbbHJhbmdlICRjb29yZHMgMiBlbmRdCgl9IGVsc2UgewoJICAgIHNldCBzbG9wZSBbZXhwciB7KCR4MCAtICR4MSkgLyAoJHkwIC0gJHkxKX1dCgkgICAgc2V0IHhpIFtleHByIHskeDAgLSAkc2xvcGUgKiAkbGluZXNwYyAvIDJ9XQoJICAgIHNldCB5aSBbZXhwciB7JHkwIC0gJGxpbmVzcGMgLyAyfV0KCSAgICBzZXQgY29vcmRzIFtscmVwbGFjZSAkY29vcmRzIDAgMSAkeGkgJHkwICR4aSAkeWldCgl9CiAgICB9CiAgICByZXR1cm4gJGNvb3Jkcwp9Cgpwcm9jIGRyYXdsaW5lc2VnIHtpZCByb3cgZW5kcm93IGFycm93bG93fSB7CiAgICBnbG9iYWwgcm93aWRsaXN0IGRpc3BsYXlvcmRlciBpZGRyYXduIGxpbmVzZWdzCiAgICBnbG9iYWwgY2FudiBjb2xvcm1hcCBsaW5lc3BjIGN1cnZpZXcgbWF4bGluZWxlbgoKICAgIHNldCBjb2xzIFtsaXN0IFtsc2VhcmNoIC1leGFjdCBbbGluZGV4ICRyb3dpZGxpc3QgJHJvd10gJGlkXV0KICAgIHNldCBsZSBbZXhwciB7JHJvdyArIDF9XQogICAgc2V0IGFycm93aGlnaCAxCiAgICB3aGlsZSB7MX0gewoJc2V0IGMgW2xzZWFyY2ggLWV4YWN0IFtsaW5kZXggJHJvd2lkbGlzdCAkbGVdICRpZF0KCWlmIHskYyA8IDB9IHsKCSAgICBpbmNyIGxlIC0xCgkgICAgYnJlYWsKCX0KCWxhcHBlbmQgY29scyAkYwoJc2V0IHggW2xpbmRleCAkZGlzcGxheW9yZGVyICRsZV0KCWlmIHskeCBlcSAkaWR9IHsKCSAgICBzZXQgYXJyb3doaWdoIDAKCSAgICBicmVhawoJfQoJaWYge1tpbmZvIGV4aXN0cyBpZGRyYXduKCR4KV0gfHwgJGxlID09ICRlbmRyb3d9IHsKCSAgICBzZXQgYyBbbHNlYXJjaCAtZXhhY3QgW2xpbmRleCAkcm93aWRsaXN0IFtleHByIHskbGUrMX1dXSAkaWRdCgkgICAgaWYgeyRjID49IDB9IHsKCQlsYXBwZW5kIGNvbHMgJGMKCQlzZXQgYXJyb3doaWdoIDAKCSAgICB9CgkgICAgYnJlYWsKCX0KCWluY3IgbGUKICAgIH0KICAgIGlmIHskbGUgPD0gJHJvd30gewoJcmV0dXJuICRyb3cKICAgIH0KCiAgICBzZXQgbGluZXMge30KICAgIHNldCBpIDAKICAgIHNldCBqb2luaGlnaCAwCiAgICBpZiB7W2luZm8gZXhpc3RzIGxpbmVzZWdzKCRpZCldfSB7CglzZXQgbGluZXMgJGxpbmVzZWdzKCRpZCkKCWZvcmVhY2ggbGkgJGxpbmVzIHsKCSAgICBzZXQgcjAgW2xpbmRleCAkbGkgMF0KCSAgICBpZiB7JHIwID4gJHJvd30gewoJCWlmIHskcjAgPT0gJGxlICYmIFtsaW5kZXggJGxpIDFdIC0gJHJvdyA8PSAkbWF4bGluZWxlbn0gewoJCSAgICBzZXQgam9pbmhpZ2ggMQoJCX0KCQlicmVhawoJICAgIH0KCSAgICBpbmNyIGkKCX0KICAgIH0KICAgIHNldCBqb2lubG93IDAKICAgIGlmIHskaSA+IDB9IHsKCXNldCBsaSBbbGluZGV4ICRsaW5lcyBbZXhwciB7JGktMX1dXQoJc2V0IHIxIFtsaW5kZXggJGxpIDFdCglpZiB7JHIxID09ICRyb3cgJiYgJGxlIC0gW2xpbmRleCAkbGkgMF0gPD0gJG1heGxpbmVsZW59IHsKCSAgICBzZXQgam9pbmxvdyAxCgl9CiAgICB9CgogICAgc2V0IHggW2xpbmRleCAkY29scyBbZXhwciB7JGxlIC0gJHJvd31dXQogICAgc2V0IHhwIFtsaW5kZXggJGNvbHMgW2V4cHIgeyRsZSAtIDEgLSAkcm93fV1dCiAgICBzZXQgZGlyIFtleHByIHskeHAgLSAkeH1dCiAgICBpZiB7JGpvaW5oaWdofSB7CglzZXQgaXRoIFtsaW5kZXggJGxpbmVzICRpIDJdCglzZXQgY29vcmRzIFskY2FudiBjb29yZHMgJGl0aF0KCXNldCBhaCBbJGNhbnYgaXRlbWNnZXQgJGl0aCAtYXJyb3ddCglzZXQgYXJyb3doaWdoIFtleHByIHskYWggZXEgImZpcnN0IiB8fCAkYWggZXEgImJvdGgifV0KCXNldCB4MiBbbGluZGV4ICRjb2xzIFtleHByIHskbGUgKyAxIC0gJHJvd31dXQoJaWYgeyR4MiBuZSB7fSAmJiAkeCAtICR4MiA9PSAkZGlyfSB7CgkgICAgc2V0IGNvb3JkcyBbbHJhbmdlICRjb29yZHMgMCBlbmQtMl0KCX0KICAgIH0gZWxzZSB7CglzZXQgY29vcmRzIFtsaXN0IFt4YyAkbGUgJHhdIFt5YyAkbGVdXQogICAgfQogICAgaWYgeyRqb2lubG93fSB7CglzZXQgaXRsIFtsaW5kZXggJGxpbmVzIFtleHByIHskaS0xfV0gMl0KCXNldCBhbCBbJGNhbnYgaXRlbWNnZXQgJGl0bCAtYXJyb3ddCglzZXQgYXJyb3dsb3cgW2V4cHIgeyRhbCBlcSAibGFzdCIgfHwgJGFsIGVxICJib3RoIn1dCiAgICB9IGVsc2VpZiB7JGFycm93bG93ICYmCgkgICAgICBbbHNlYXJjaCAtZXhhY3QgW2xpbmRleCAkcm93aWRsaXN0IFtleHByIHskcm93LTF9XV0gJGlkXSA+PSAwfSB7CglzZXQgYXJyb3dsb3cgMAogICAgfQogICAgc2V0IGFycm93IFtsaW5kZXgge25vbmUgZmlyc3QgbGFzdCBib3RofSBbZXhwciB7JGFycm93aGlnaCArIDIqJGFycm93bG93fV1dCiAgICBmb3Ige3NldCB5ICRsZX0ge1tpbmNyIHkgLTFdID4gJHJvd30ge30gewoJc2V0IHggJHhwCglzZXQgeHAgW2xpbmRleCAkY29scyBbZXhwciB7JHkgLSAxIC0gJHJvd31dXQoJc2V0IG5kaXIgW2V4cHIgeyR4cCAtICR4fV0KCWlmIHskZGlyICE9ICRuZGlyIHx8ICR4cCA8IDB9IHsKCSAgICBsYXBwZW5kIGNvb3JkcyBbeGMgJHkgJHhdIFt5YyAkeV0KCX0KCXNldCBkaXIgJG5kaXIKICAgIH0KICAgIGlmIHshJGpvaW5sb3d9IHsKCWlmIHskeHAgPCAwfSB7CgkgICAgIyBqb2luIHBhcmVudCBsaW5lIHRvIGZpcnN0IGNoaWxkCgkgICAgc2V0IGNoIFtsaW5kZXggJGRpc3BsYXlvcmRlciAkcm93XQoJICAgIHNldCB4YyBbbHNlYXJjaCAtZXhhY3QgW2xpbmRleCAkcm93aWRsaXN0ICRyb3ddICRjaF0KCSAgICBpZiB7JHhjIDwgMH0gewoJCXB1dHMgIm9vcHM6IGRyYXdsaW5lc2VnOiBjaGlsZCAkY2ggbm90IG9uIHJvdyAkcm93IgoJICAgIH0gZWxzZSB7CgkJaWYgeyR4YyA8ICR4IC0gMX0gewoJCSAgICBsYXBwZW5kIGNvb3JkcyBbeGMgJHJvdyBbZXhwciB7JHgtMX1dXSBbeWMgJHJvd10KCQl9IGVsc2VpZiB7JHhjID4gJHggKyAxfSB7CgkJICAgIGxhcHBlbmQgY29vcmRzIFt4YyAkcm93IFtleHByIHskeCsxfV1dIFt5YyAkcm93XQoJCX0KCQlzZXQgeCAkeGMKCSAgICB9CgkgICAgbGFwcGVuZCBjb29yZHMgW3hjICRyb3cgJHhdIFt5YyAkcm93XQoJfSBlbHNlIHsKCSAgICBzZXQgeG4gW3hjICRyb3cgJHhwXQoJICAgIHNldCB5biBbeWMgJHJvd10KCSAgICAjIHdvcmsgYXJvdW5kIHRrOC40IHJlZnVzYWwgdG8gZHJhdyBhcnJvd3Mgb24gZGlhZ29uYWwgc2VnbWVudHMKCSAgICBpZiB7JGFycm93bG93ICYmICR4biAhPSBbbGluZGV4ICRjb29yZHMgZW5kLTFdfSB7CgkJaWYge1tsbGVuZ3RoICRjb29yZHNdIDwgNCB8fAoJCSAgICBbbGluZGV4ICRjb29yZHMgZW5kLTNdICE9IFtsaW5kZXggJGNvb3JkcyBlbmQtMV0gfHwKCQkgICAgW2xpbmRleCAkY29vcmRzIGVuZF0gLSAkeW4gPiAyICogJGxpbmVzcGN9IHsKCQkgICAgc2V0IHhuIFt4YyAkcm93IFtleHByIHskeHAgLSAwLjUgKiAkZGlyfV1dCgkJICAgIHNldCB5byBbeWMgW2V4cHIgeyRyb3cgKyAwLjV9XV0KCQkgICAgbGFwcGVuZCBjb29yZHMgJHhuICR5byAkeG4gJHluCgkJfQoJICAgIH0gZWxzZSB7CgkJbGFwcGVuZCBjb29yZHMgJHhuICR5bgoJICAgIH0KCX0KCWlmIHshJGpvaW5oaWdofSB7CgkgICAgaWYgeyRhcnJvd2hpZ2h9IHsKCQlzZXQgY29vcmRzIFthZGphcnJvd2hpZ2ggJGNvb3Jkc10KCSAgICB9CgkgICAgYXNzaWduY29sb3IgJGlkCgkgICAgc2V0IHQgWyRjYW52IGNyZWF0ZSBsaW5lICRjb29yZHMgLXdpZHRoIFtsaW5ld2lkdGggJGlkXSBcCgkJICAgICAgIC1maWxsICRjb2xvcm1hcCgkaWQpIC10YWdzIGxpbmVzLiRpZCAtYXJyb3cgJGFycm93XQoJICAgICRjYW52IGxvd2VyICR0CgkgICAgYmluZGxpbmUgJHQgJGlkCgkgICAgc2V0IGxpbmVzIFtsaW5zZXJ0ICRsaW5lcyAkaSBbbGlzdCAkcm93ICRsZSAkdF1dCgl9IGVsc2UgewoJICAgICRjYW52IGNvb3JkcyAkaXRoICRjb29yZHMKCSAgICBpZiB7JGFycm93IG5lICRhaH0gewoJCSRjYW52IGl0ZW1jb25mICRpdGggLWFycm93ICRhcnJvdwoJICAgIH0KCSAgICBsc2V0IGxpbmVzICRpIDAgJHJvdwoJfQogICAgfSBlbHNlIHsKCXNldCB4byBbbHNlYXJjaCAtZXhhY3QgW2xpbmRleCAkcm93aWRsaXN0IFtleHByIHskcm93IC0gMX1dXSAkaWRdCglzZXQgbmRpciBbZXhwciB7JHhvIC0gJHhwfV0KCXNldCBjbG93IFskY2FudiBjb29yZHMgJGl0bF0KCWlmIHskZGlyID09ICRuZGlyfSB7CgkgICAgc2V0IGNsb3cgW2xyYW5nZSAkY2xvdyAyIGVuZF0KCX0KCXNldCBjb29yZHMgW2NvbmNhdCAkY29vcmRzICRjbG93XQoJaWYgeyEkam9pbmhpZ2h9IHsKCSAgICBsc2V0IGxpbmVzIFtleHByIHskaS0xfV0gMSAkbGUKCSAgICBpZiB7JGFycm93aGlnaH0gewoJCXNldCBjb29yZHMgW2FkamFycm93aGlnaCAkY29vcmRzXQoJICAgIH0KCX0gZWxzZSB7CgkgICAgIyBjb2FsZXNjZSB0d28gcGllY2VzCgkgICAgJGNhbnYgZGVsZXRlICRpdGgKCSAgICBzZXQgYiBbbGluZGV4ICRsaW5lcyBbZXhwciB7JGktMX1dIDBdCgkgICAgc2V0IGUgW2xpbmRleCAkbGluZXMgJGkgMV0KCSAgICBzZXQgbGluZXMgW2xyZXBsYWNlICRsaW5lcyBbZXhwciB7JGktMX1dICRpIFtsaXN0ICRiICRlICRpdGxdXQoJfQoJJGNhbnYgY29vcmRzICRpdGwgJGNvb3JkcwoJaWYgeyRhcnJvdyBuZSAkYWx9IHsKCSAgICAkY2FudiBpdGVtY29uZiAkaXRsIC1hcnJvdyAkYXJyb3cKCX0KICAgIH0KCiAgICBzZXQgbGluZXNlZ3MoJGlkKSAkbGluZXMKICAgIHJldHVybiAkbGUKfQoKcHJvYyBkcmF3cGFyZW50bGlua3Mge2lkIHJvd30gewogICAgZ2xvYmFsIHJvd2lkbGlzdCBjYW52IGNvbG9ybWFwIGN1cnZpZXcgcGFyZW50bGlzdAogICAgZ2xvYmFsIGlkcG9zCgogICAgc2V0IHJvd2lkcyBbbGluZGV4ICRyb3dpZGxpc3QgJHJvd10KICAgIHNldCBjb2wgW2xzZWFyY2ggLWV4YWN0ICRyb3dpZHMgJGlkXQogICAgaWYgeyRjb2wgPCAwfSByZXR1cm4KICAgIHNldCBvbGRzIFtsaW5kZXggJHBhcmVudGxpc3QgJHJvd10KICAgIHNldCByb3cyIFtleHByIHskcm93ICsgMX1dCiAgICBzZXQgeCBbeGMgJHJvdyAkY29sXQogICAgc2V0IHkgW3ljICRyb3ddCiAgICBzZXQgeTIgW3ljICRyb3cyXQogICAgc2V0IGlkcyBbbGluZGV4ICRyb3dpZGxpc3QgJHJvdzJdCiAgICAjIHJteCA9IHJpZ2h0LW1vc3QgWCBjb29yZCB1c2VkCiAgICBzZXQgcm14IDAKICAgIGZvcmVhY2ggcCAkb2xkcyB7CglzZXQgaSBbbHNlYXJjaCAtZXhhY3QgJGlkcyAkcF0KCWlmIHskaSA8IDB9IHsKCSAgICBwdXRzICJvb3BzLCBwYXJlbnQgJHAgb2YgJGlkIG5vdCBpbiBsaXN0IgoJICAgIGNvbnRpbnVlCgl9CglzZXQgeDIgW3hjICRyb3cyICRpXQoJaWYgeyR4MiA+ICRybXh9IHsKCSAgICBzZXQgcm14ICR4MgoJfQoJaWYge1tsc2VhcmNoIC1leGFjdCAkcm93aWRzICRwXSA8IDB9IHsKCSAgICAjIGRyYXdsaW5lc2VnIHdpbGwgZG8gdGhpcyBvbmUgZm9yIHVzCgkgICAgY29udGludWUKCX0KCWFzc2lnbmNvbG9yICRwCgkjIHNob3VsZCBoYW5kbGUgZHVwbGljYXRlZCBwYXJlbnRzIGhlcmUuLi4KCXNldCBjb29yZHMgW2xpc3QgJHggJHldCglpZiB7JGkgPCAkY29sIC0gMX0gewoJICAgIGxhcHBlbmQgY29vcmRzIFt4YyAkcm93IFtleHByIHskaSArIDF9XV0gJHkKCX0gZWxzZWlmIHskaSA+ICRjb2wgKyAxfSB7CgkgICAgbGFwcGVuZCBjb29yZHMgW3hjICRyb3cgW2V4cHIgeyRpIC0gMX1dXSAkeQoJfQoJbGFwcGVuZCBjb29yZHMgJHgyICR5MgoJc2V0IHQgWyRjYW52IGNyZWF0ZSBsaW5lICRjb29yZHMgLXdpZHRoIFtsaW5ld2lkdGggJHBdIFwKCQkgICAtZmlsbCAkY29sb3JtYXAoJHApIC10YWdzIGxpbmVzLiRwXQoJJGNhbnYgbG93ZXIgJHQKCWJpbmRsaW5lICR0ICRwCiAgICB9CiAgICBpZiB7JHJteCA+IFtsaW5kZXggJGlkcG9zKCRpZCkgMV19IHsKCWxzZXQgaWRwb3MoJGlkKSAxICRybXgKCXJlZHJhd3RhZ3MgJGlkCiAgICB9Cn0KCnByb2MgZHJhd2xpbmVzIHtpZH0gewogICAgZ2xvYmFsIGNhbnYKCiAgICAkY2FudiBpdGVtY29uZiBsaW5lcy4kaWQgLXdpZHRoIFtsaW5ld2lkdGggJGlkXQp9Cgpwcm9jIGRyYXdjbWl0dGV4dCB7aWQgcm93IGNvbH0gewogICAgZ2xvYmFsIGxpbmVzcGMgY2FudiBjYW52MiBjYW52MyBjYW52eTAgZmdjb2xvciBjdXJ2aWV3CiAgICBnbG9iYWwgY29tbWl0bGlzdGVkIGNvbW1pdGluZm8gcm93aWRsaXN0IHBhcmVudGxpc3QKICAgIGdsb2JhbCByb3d0ZXh0eCBpZHBvcyBpZHRhZ3MgaWRoZWFkcyBpZG90aGVycmVmcwogICAgZ2xvYmFsIGxpbmVodGFnIGxpbmVudGFnIGxpbmVkdGFnCiAgICBnbG9iYWwgbWFpbmZvbnQgY2FudnhtYXggYm9sZHJvd3MgYm9sZG5hbWVyb3dzIGZnY29sb3IgbnVsbGlkIG51bGxpZDIKCiAgICAjIGxpc3RlZCBpcyAwIGZvciBib3VuZGFyeSwgMSBmb3Igbm9ybWFsLCAyIGZvciBsZWZ0LCAzIGZvciByaWdodAogICAgc2V0IGxpc3RlZCBbbGluZGV4ICRjb21taXRsaXN0ZWQgJHJvd10KICAgIGlmIHskaWQgZXEgJG51bGxpZH0gewoJc2V0IG9maWxsIHJlZAogICAgfSBlbHNlaWYgeyRpZCBlcSAkbnVsbGlkMn0gewoJc2V0IG9maWxsIGdyZWVuCiAgICB9IGVsc2UgewoJc2V0IG9maWxsIFtleHByIHskbGlzdGVkICE9IDA/ICJibHVlIjogIndoaXRlIn1dCiAgICB9CiAgICBzZXQgeCBbeGMgJHJvdyAkY29sXQogICAgc2V0IHkgW3ljICRyb3ddCiAgICBzZXQgb3JhZCBbZXhwciB7JGxpbmVzcGMgLyAzfV0KICAgIGlmIHskbGlzdGVkIDw9IDF9IHsKCXNldCB0IFskY2FudiBjcmVhdGUgb3ZhbCBbZXhwciB7JHggLSAkb3JhZH1dIFtleHByIHskeSAtICRvcmFkfV0gXAoJCSAgIFtleHByIHskeCArICRvcmFkIC0gMX1dIFtleHByIHskeSArICRvcmFkIC0gMX1dIFwKCQkgICAtZmlsbCAkb2ZpbGwgLW91dGxpbmUgJGZnY29sb3IgLXdpZHRoIDEgLXRhZ3MgY2lyY2xlXQogICAgfSBlbHNlaWYgeyRsaXN0ZWQgPT0gMn0gewoJIyB0cmlhbmdsZSBwb2ludGluZyBsZWZ0IGZvciBsZWZ0LXNpZGUgY29tbWl0cwoJc2V0IHQgWyRjYW52IGNyZWF0ZSBwb2x5Z29uIFwKCQkgICBbZXhwciB7JHggLSAkb3JhZH1dICR5IFwKCQkgICBbZXhwciB7JHggKyAkb3JhZCAtIDF9XSBbZXhwciB7JHkgLSAkb3JhZH1dIFwKCQkgICBbZXhwciB7JHggKyAkb3JhZCAtIDF9XSBbZXhwciB7JHkgKyAkb3JhZCAtIDF9XSBcCgkJICAgLWZpbGwgJG9maWxsIC1vdXRsaW5lICRmZ2NvbG9yIC13aWR0aCAxIC10YWdzIGNpcmNsZV0KICAgIH0gZWxzZSB7CgkjIHRyaWFuZ2xlIHBvaW50aW5nIHJpZ2h0IGZvciByaWdodC1zaWRlIGNvbW1pdHMKCXNldCB0IFskY2FudiBjcmVhdGUgcG9seWdvbiBcCgkJICAgW2V4cHIgeyR4ICsgJG9yYWQgLSAxfV0gJHkgXAoJCSAgIFtleHByIHskeCAtICRvcmFkfV0gW2V4cHIgeyR5IC0gJG9yYWR9XSBcCgkJICAgW2V4cHIgeyR4IC0gJG9yYWR9XSBbZXhwciB7JHkgKyAkb3JhZCAtIDF9XSBcCgkJICAgLWZpbGwgJG9maWxsIC1vdXRsaW5lICRmZ2NvbG9yIC13aWR0aCAxIC10YWdzIGNpcmNsZV0KICAgIH0KICAgICRjYW52IHJhaXNlICR0CiAgICAkY2FudiBiaW5kICR0IDwxPiB7c2VsY2FudmxpbmUge30gJXggJXl9CiAgICBzZXQgcm14IFtsbGVuZ3RoIFtsaW5kZXggJHJvd2lkbGlzdCAkcm93XV0KICAgIHNldCBvbGRzIFtsaW5kZXggJHBhcmVudGxpc3QgJHJvd10KICAgIGlmIHskb2xkcyBuZSB7fX0gewoJc2V0IG5leHRpZHMgW2xpbmRleCAkcm93aWRsaXN0IFtleHByIHskcm93ICsgMX1dXQoJZm9yZWFjaCBwICRvbGRzIHsKCSAgICBzZXQgaSBbbHNlYXJjaCAtZXhhY3QgJG5leHRpZHMgJHBdCgkgICAgaWYgeyRpID4gJHJteH0gewoJCXNldCBybXggJGkKCSAgICB9Cgl9CiAgICB9CiAgICBzZXQgeHQgW3hjICRyb3cgJHJteF0KICAgIHNldCByb3d0ZXh0eCgkcm93KSAkeHQKICAgIHNldCBpZHBvcygkaWQpIFtsaXN0ICR4ICR4dCAkeV0KICAgIGlmIHtbaW5mbyBleGlzdHMgaWR0YWdzKCRpZCldIHx8IFtpbmZvIGV4aXN0cyBpZGhlYWRzKCRpZCldCgl8fCBbaW5mbyBleGlzdHMgaWRvdGhlcnJlZnMoJGlkKV19IHsKCXNldCB4dCBbZHJhd3RhZ3MgJGlkICR4ICR4dCAkeV0KICAgIH0KICAgIHNldCBoZWFkbGluZSBbbGluZGV4ICRjb21taXRpbmZvKCRpZCkgMF0KICAgIHNldCBuYW1lIFtsaW5kZXggJGNvbW1pdGluZm8oJGlkKSAxXQogICAgc2V0IGRhdGUgW2xpbmRleCAkY29tbWl0aW5mbygkaWQpIDJdCiAgICBzZXQgZGF0ZSBbZm9ybWF0ZGF0ZSAkZGF0ZV0KICAgIHNldCBmb250ICRtYWluZm9udAogICAgc2V0IG5mb250ICRtYWluZm9udAogICAgc2V0IGlzYm9sZCBbaXNoaWdobGlnaHRlZCAkcm93XQogICAgaWYgeyRpc2JvbGQgPiAwfSB7CglsYXBwZW5kIGJvbGRyb3dzICRyb3cKCWxhcHBlbmQgZm9udCBib2xkCglpZiB7JGlzYm9sZCA+IDF9IHsKCSAgICBsYXBwZW5kIGJvbGRuYW1lcm93cyAkcm93CgkgICAgbGFwcGVuZCBuZm9udCBib2xkCgl9CiAgICB9CiAgICBzZXQgbGluZWh0YWcoJHJvdykgWyRjYW52IGNyZWF0ZSB0ZXh0ICR4dCAkeSAtYW5jaG9yIHcgLWZpbGwgJGZnY29sb3IgXAoJCQkgICAgLXRleHQgJGhlYWRsaW5lIC1mb250ICRmb250IC10YWdzIHRleHRdCiAgICAkY2FudiBiaW5kICRsaW5laHRhZygkcm93KSA8QnV0dG9uLTM+ICJyb3dtZW51ICVYICVZICRpZCIKICAgIHNldCBsaW5lbnRhZygkcm93KSBbJGNhbnYyIGNyZWF0ZSB0ZXh0IDMgJHkgLWFuY2hvciB3IC1maWxsICRmZ2NvbG9yIFwKCQkJICAgIC10ZXh0ICRuYW1lIC1mb250ICRuZm9udCAtdGFncyB0ZXh0XQogICAgc2V0IGxpbmVkdGFnKCRyb3cpIFskY2FudjMgY3JlYXRlIHRleHQgMyAkeSAtYW5jaG9yIHcgLWZpbGwgJGZnY29sb3IgXAoJCQkgICAgLXRleHQgJGRhdGUgLWZvbnQgJG1haW5mb250IC10YWdzIHRleHRdCiAgICBzZXQgeHIgW2V4cHIgeyR4dCArIFtmb250IG1lYXN1cmUgJG1haW5mb250ICRoZWFkbGluZV19XQogICAgaWYgeyR4ciA+ICRjYW52eG1heH0gewoJc2V0IGNhbnZ4bWF4ICR4cgoJc2V0Y2FudnNjcm9sbAogICAgfQp9Cgpwcm9jIGRyYXdjbWl0cm93IHtyb3d9IHsKICAgIGdsb2JhbCBkaXNwbGF5b3JkZXIgcm93aWRsaXN0CiAgICBnbG9iYWwgaWRkcmF3biBtYXJraW5nbWF0Y2hlcwogICAgZ2xvYmFsIGNvbW1pdGluZm8gcGFyZW50bGlzdCBudW1jb21taXRzCiAgICBnbG9iYWwgZmlsZWhpZ2hsaWdodCBmaGlnaGxpZ2h0cyBmaW5kc3RyaW5nIG5oaWdobGlnaHRzCiAgICBnbG9iYWwgaGx2aWV3IHZoaWdobGlnaHRzCiAgICBnbG9iYWwgaGlnaGxpZ2h0X3JlbGF0ZWQgcmhpZ2hsaWdodHMKCiAgICBpZiB7JHJvdyA+PSAkbnVtY29tbWl0c30gcmV0dXJuCgogICAgc2V0IGlkIFtsaW5kZXggJGRpc3BsYXlvcmRlciAkcm93XQogICAgaWYge1tpbmZvIGV4aXN0cyBobHZpZXddICYmICFbaW5mbyBleGlzdHMgdmhpZ2hsaWdodHMoJHJvdyldfSB7Cglhc2t2aGlnaGxpZ2h0ICRyb3cgJGlkCiAgICB9CiAgICBpZiB7W2luZm8gZXhpc3RzIGZpbGVoaWdobGlnaHRdICYmICFbaW5mbyBleGlzdHMgZmhpZ2hsaWdodHMoJHJvdyldfSB7Cglhc2tmaWxlaGlnaGxpZ2h0ICRyb3cgJGlkCiAgICB9CiAgICBpZiB7JGZpbmRzdHJpbmcgbmUge30gJiYgIVtpbmZvIGV4aXN0cyBuaGlnaGxpZ2h0cygkcm93KV19IHsKCWFza2ZpbmRoaWdobGlnaHQgJHJvdyAkaWQKICAgIH0KICAgIGlmIHskaGlnaGxpZ2h0X3JlbGF0ZWQgbmUgIk5vbmUiICYmICFbaW5mbyBleGlzdHMgcmhpZ2hsaWdodHMoJHJvdyldfSB7Cglhc2tyZWxoaWdobGlnaHQgJHJvdyAkaWQKICAgIH0KICAgIGlmIHshW2luZm8gZXhpc3RzIGlkZHJhd24oJGlkKV19IHsKCXNldCBjb2wgW2xzZWFyY2ggLWV4YWN0IFtsaW5kZXggJHJvd2lkbGlzdCAkcm93XSAkaWRdCglpZiB7JGNvbCA8IDB9IHsKCSAgICBwdXRzICJvb3BzLCByb3cgJHJvdyBpZCAkaWQgbm90IGluIGxpc3QiCgkgICAgcmV0dXJuCgl9CglpZiB7IVtpbmZvIGV4aXN0cyBjb21taXRpbmZvKCRpZCldfSB7CgkgICAgZ2V0Y29tbWl0ICRpZAoJfQoJYXNzaWduY29sb3IgJGlkCglkcmF3Y21pdHRleHQgJGlkICRyb3cgJGNvbAoJc2V0IGlkZHJhd24oJGlkKSAxCiAgICB9CiAgICBpZiB7JG1hcmtpbmdtYXRjaGVzfSB7CgltYXJrcm93bWF0Y2hlcyAkcm93ICRpZAogICAgfQp9Cgpwcm9jIGRyYXdjb21taXRzIHtyb3cge2VuZHJvdyB7fX19IHsKICAgIGdsb2JhbCBudW1jb21taXRzIGlkZHJhd24gZGlzcGxheW9yZGVyIGN1cnZpZXcKICAgIGdsb2JhbCBwYXJlbnRsaXN0IHJvd2lkbGlzdAoKICAgIGlmIHskcm93IDwgMH0gewoJc2V0IHJvdyAwCiAgICB9CiAgICBpZiB7JGVuZHJvdyBlcSB7fX0gewoJc2V0IGVuZHJvdyAkcm93CiAgICB9CiAgICBpZiB7JGVuZHJvdyA+PSAkbnVtY29tbWl0c30gewoJc2V0IGVuZHJvdyBbZXhwciB7JG51bWNvbW1pdHMgLSAxfV0KICAgIH0KCiAgICAjIG1ha2UgdGhlIGxpbmVzIGpvaW4gdG8gYWxyZWFkeS1kcmF3biByb3dzIGVpdGhlciBzaWRlCiAgICBzZXQgciBbZXhwciB7JHJvdyAtIDF9XQogICAgaWYgeyRyIDwgMCB8fCAhW2luZm8gZXhpc3RzIGlkZHJhd24oW2xpbmRleCAkZGlzcGxheW9yZGVyICRyXSldfSB7CglzZXQgciAkcm93CiAgICB9CiAgICBzZXQgZXIgW2V4cHIgeyRlbmRyb3cgKyAxfV0KICAgIGlmIHskZXIgPj0gJG51bWNvbW1pdHMgfHwKCSFbaW5mbyBleGlzdHMgaWRkcmF3bihbbGluZGV4ICRkaXNwbGF5b3JkZXIgJGVyXSldfSB7CglzZXQgZXIgJGVuZHJvdwogICAgfQogICAgZm9yIHt9IHskciA8PSAkZXJ9IHtpbmNyIHJ9IHsKCXNldCBpZCBbbGluZGV4ICRkaXNwbGF5b3JkZXIgJHJdCglzZXQgd2FzZHJhd24gW2luZm8gZXhpc3RzIGlkZHJhd24oJGlkKV0KCWRyYXdjbWl0cm93ICRyCglpZiB7JHIgPT0gJGVyfSBicmVhawoJc2V0IG5leHRpZCBbbGluZGV4ICRkaXNwbGF5b3JkZXIgW2V4cHIgeyRyICsgMX1dXQoJaWYgeyR3YXNkcmF3biAmJiBbaW5mbyBleGlzdHMgaWRkcmF3bigkbmV4dGlkKV19IHsKCSAgICBjYXRjaCB7dW5zZXQgcHJldmxpbmVzfQoJICAgIGNvbnRpbnVlCgl9CglkcmF3cGFyZW50bGlua3MgJGlkICRyCgoJaWYge1tpbmZvIGV4aXN0cyBsaW5lZW5kcygkcildfSB7CgkgICAgZm9yZWFjaCBsaWQgJGxpbmVlbmRzKCRyKSB7CgkJdW5zZXQgcHJldmxpbmVzKCRsaWQpCgkgICAgfQoJfQoJc2V0IHJvd2lkcyBbbGluZGV4ICRyb3dpZGxpc3QgJHJdCglmb3JlYWNoIGxpZCAkcm93aWRzIHsKCSAgICBpZiB7JGxpZCBlcSB7fX0gY29udGludWUKCSAgICBpZiB7JGxpZCBlcSAkaWR9IHsKCQkjIHNlZSBpZiB0aGlzIGlzIHRoZSBmaXJzdCBjaGlsZCBvZiBhbnkgb2YgaXRzIHBhcmVudHMKCQlmb3JlYWNoIHAgW2xpbmRleCAkcGFyZW50bGlzdCAkcl0gewoJCSAgICBpZiB7W2xzZWFyY2ggLWV4YWN0ICRyb3dpZHMgJHBdIDwgMH0gewoJCQkjIG1ha2UgdGhpcyBsaW5lIGV4dGVuZCB1cCB0byB0aGUgY2hpbGQKCQkJc2V0IGxlIFtkcmF3bGluZXNlZyAkcCAkciAkZXIgMF0KCQkJbGFwcGVuZCBsaW5lZW5kcygkbGUpICRwCgkJCXNldCBwcmV2bGluZXMoJHApIDEKCQkgICAgfQoJCX0KCSAgICB9IGVsc2VpZiB7IVtpbmZvIGV4aXN0cyBwcmV2bGluZXMoJGxpZCldfSB7CgkJc2V0IGxlIFtkcmF3bGluZXNlZyAkbGlkICRyICRlciAxXQoJCWxhcHBlbmQgbGluZWVuZHMoJGxlKSAkbGlkCgkJc2V0IHByZXZsaW5lcygkbGlkKSAxCgkgICAgfQoJfQogICAgfQp9Cgpwcm9jIGRyYXdmcmFjIHtmMCBmMX0gewogICAgZ2xvYmFsIGNhbnYgbGluZXNwYwoKICAgIHNldCB5bWF4IFtsaW5kZXggWyRjYW52IGNnZXQgLXNjcm9sbHJlZ2lvbl0gM10KICAgIGlmIHskeW1heCBlcSB7fSB8fCAkeW1heCA9PSAwfSByZXR1cm4KICAgIHNldCB5MCBbZXhwciB7aW50KCRmMCAqICR5bWF4KX1dCiAgICBzZXQgcm93IFtleHByIHtpbnQoKCR5MCAtIDMpIC8gJGxpbmVzcGMpIC0gMX1dCiAgICBzZXQgeTEgW2V4cHIge2ludCgkZjEgKiAkeW1heCl9XQogICAgc2V0IGVuZHJvdyBbZXhwciB7aW50KCgkeTEgLSAzKSAvICRsaW5lc3BjKSArIDF9XQogICAgZHJhd2NvbW1pdHMgJHJvdyAkZW5kcm93Cn0KCnByb2MgZHJhd3Zpc2libGUge30gewogICAgZ2xvYmFsIGNhbnYKICAgIGV2YWwgZHJhd2ZyYWMgWyRjYW52IHl2aWV3XQp9Cgpwcm9jIGNsZWFyX2Rpc3BsYXkge30gewogICAgZ2xvYmFsIGlkZHJhd24gbGluZXNlZ3MKICAgIGdsb2JhbCB2aGlnaGxpZ2h0cyBmaGlnaGxpZ2h0cyBuaGlnaGxpZ2h0cyByaGlnaGxpZ2h0cwoKICAgIGFsbGNhbnZzIGRlbGV0ZSBhbGwKICAgIGNhdGNoIHt1bnNldCBpZGRyYXdufQogICAgY2F0Y2gge3Vuc2V0IGxpbmVzZWdzfQogICAgY2F0Y2gge3Vuc2V0IHZoaWdobGlnaHRzfQogICAgY2F0Y2gge3Vuc2V0IGZoaWdobGlnaHRzfQogICAgY2F0Y2gge3Vuc2V0IG5oaWdobGlnaHRzfQogICAgY2F0Y2gge3Vuc2V0IHJoaWdobGlnaHRzfQp9Cgpwcm9jIGZpbmRjcm9zc2luZ3Mge2lkfSB7CiAgICBnbG9iYWwgcm93aWRsaXN0IHBhcmVudGxpc3QgbnVtY29tbWl0cyByb3dvZmZzZXRzIGRpc3BsYXlvcmRlcgoKICAgIHNldCBjcm9zcyB7fQogICAgc2V0IGNjcm9zcyB7fQogICAgZm9yZWFjaCB7cyBlfSBbcm93cmFuZ2VzICRpZF0gewoJaWYgeyRlID49ICRudW1jb21taXRzfSB7CgkgICAgc2V0IGUgW2V4cHIgeyRudW1jb21taXRzIC0gMX1dCgl9CglpZiB7JGUgPD0gJHN9IGNvbnRpbnVlCglzZXQgeCBbbHNlYXJjaCAtZXhhY3QgW2xpbmRleCAkcm93aWRsaXN0ICRlXSAkaWRdCglpZiB7JHggPCAwfSB7CgkgICAgcHV0cyAiZmluZGNyb3NzaW5nczogb29wcywgbm8gW3Nob3J0aWRzICRpZF0gaW4gcm93ICRlIgoJICAgIGNvbnRpbnVlCgl9Cglmb3Ige3NldCByb3cgJGV9IHtbaW5jciByb3cgLTFdID49ICRzfSB7fSB7CgkgICAgc2V0IG9sZHMgW2xpbmRleCAkcGFyZW50bGlzdCAkcm93XQoJICAgIHNldCBraWQgW2xpbmRleCAkZGlzcGxheW9yZGVyICRyb3ddCgkgICAgc2V0IGtpZHggW2xzZWFyY2ggLWV4YWN0IFtsaW5kZXggJHJvd2lkbGlzdCAkcm93XSAka2lkXQoJICAgIGlmIHska2lkeCA8IDB9IGNvbnRpbnVlCgkgICAgc2V0IG5leHRyb3cgW2xpbmRleCAkcm93aWRsaXN0IFtleHByIHskcm93ICsgMX1dXQoJICAgIGZvcmVhY2ggcCAkb2xkcyB7CgkJc2V0IHB4IFtsc2VhcmNoIC1leGFjdCAkbmV4dHJvdyAkcF0KCQlpZiB7JHB4IDwgMH0gY29udGludWUKCQlpZiB7KCRraWR4IDwgJHggJiYgJHggPCAkcHgpIHx8ICgkcHggPCAkeCAmJiAkeCA8ICRraWR4KX0gewoJCSAgICBpZiB7W2xzZWFyY2ggLWV4YWN0ICRjY3Jvc3MgJHBdID49IDB9IGNvbnRpbnVlCgkJICAgIGlmIHskeCA9PSAkcHggKyAoJGtpZHggPCAkcHg/IC0xOiAxKX0gewoJCQlsYXBwZW5kIGNjcm9zcyAkcAoJCSAgICB9IGVsc2VpZiB7W2xzZWFyY2ggLWV4YWN0ICRjcm9zcyAkcF0gPCAwfSB7CgkJCWxhcHBlbmQgY3Jvc3MgJHAKCQkgICAgfQoJCX0KCSAgICB9CgkgICAgc2V0IGluYyBbbGluZGV4ICRyb3dvZmZzZXRzICRyb3cgJHhdCgkgICAgaWYgeyRpbmMgZXEge319IGJyZWFrCgkgICAgaW5jciB4ICRpbmMKCX0KICAgIH0KICAgIHJldHVybiBbY29uY2F0ICRjY3Jvc3Mge3t9fSAkY3Jvc3NdCn0KCnByb2MgYXNzaWduY29sb3Ige2lkfSB7CiAgICBnbG9iYWwgY29sb3JtYXAgY29sb3JzIG5leHRjb2xvcgogICAgZ2xvYmFsIGNvbW1pdHJvdyBwYXJlbnRsaXN0IGNoaWxkcmVuIGNoaWxkcmVuIGN1cnZpZXcKCiAgICBpZiB7W2luZm8gZXhpc3RzIGNvbG9ybWFwKCRpZCldfSByZXR1cm4KICAgIHNldCBuY29sb3JzIFtsbGVuZ3RoICRjb2xvcnNdCiAgICBpZiB7W2luZm8gZXhpc3RzIGNoaWxkcmVuKCRjdXJ2aWV3LCRpZCldfSB7CglzZXQga2lkcyAkY2hpbGRyZW4oJGN1cnZpZXcsJGlkKQogICAgfSBlbHNlIHsKCXNldCBraWRzIHt9CiAgICB9CiAgICBpZiB7W2xsZW5ndGggJGtpZHNdID09IDF9IHsKCXNldCBjaGlsZCBbbGluZGV4ICRraWRzIDBdCglpZiB7W2luZm8gZXhpc3RzIGNvbG9ybWFwKCRjaGlsZCldCgkgICAgJiYgW2xsZW5ndGggW2xpbmRleCAkcGFyZW50bGlzdCAkY29tbWl0cm93KCRjdXJ2aWV3LCRjaGlsZCldXSA9PSAxfSB7CgkgICAgc2V0IGNvbG9ybWFwKCRpZCkgJGNvbG9ybWFwKCRjaGlsZCkKCSAgICByZXR1cm4KCX0KICAgIH0KICAgIHNldCBiYWRjb2xvcnMge30KICAgIHNldCBvcmlnYmFkIHt9CiAgICBmb3JlYWNoIHggW2ZpbmRjcm9zc2luZ3MgJGlkXSB7CglpZiB7JHggZXEge319IHsKCSAgICAjIGRlbGltaXRlciBiZXR3ZWVuIGNvcm5lciBjcm9zc2luZ3MgYW5kIG90aGVyIGNyb3NzaW5ncwoJICAgIGlmIHtbbGxlbmd0aCAkYmFkY29sb3JzXSA+PSAkbmNvbG9ycyAtIDF9IGJyZWFrCgkgICAgc2V0IG9yaWdiYWQgJGJhZGNvbG9ycwoJfQoJaWYge1tpbmZvIGV4aXN0cyBjb2xvcm1hcCgkeCldCgkgICAgJiYgW2xzZWFyY2ggLWV4YWN0ICRiYWRjb2xvcnMgJGNvbG9ybWFwKCR4KV0gPCAwfSB7CgkgICAgbGFwcGVuZCBiYWRjb2xvcnMgJGNvbG9ybWFwKCR4KQoJfQogICAgfQogICAgaWYge1tsbGVuZ3RoICRiYWRjb2xvcnNdID49ICRuY29sb3JzfSB7CglzZXQgYmFkY29sb3JzICRvcmlnYmFkCiAgICB9CiAgICBzZXQgb3JpZ2JhZCAkYmFkY29sb3JzCiAgICBpZiB7W2xsZW5ndGggJGJhZGNvbG9yc10gPCAkbmNvbG9ycyAtIDF9IHsKCWZvcmVhY2ggY2hpbGQgJGtpZHMgewoJICAgIGlmIHtbaW5mbyBleGlzdHMgY29sb3JtYXAoJGNoaWxkKV0KCQkmJiBbbHNlYXJjaCAtZXhhY3QgJGJhZGNvbG9ycyAkY29sb3JtYXAoJGNoaWxkKV0gPCAwfSB7CgkJbGFwcGVuZCBiYWRjb2xvcnMgJGNvbG9ybWFwKCRjaGlsZCkKCSAgICB9CgkgICAgZm9yZWFjaCBwIFtsaW5kZXggJHBhcmVudGxpc3QgJGNvbW1pdHJvdygkY3VydmlldywkY2hpbGQpXSB7CgkJaWYge1tpbmZvIGV4aXN0cyBjb2xvcm1hcCgkcCldCgkJICAgICYmIFtsc2VhcmNoIC1leGFjdCAkYmFkY29sb3JzICRjb2xvcm1hcCgkcCldIDwgMH0gewoJCSAgICBsYXBwZW5kIGJhZGNvbG9ycyAkY29sb3JtYXAoJHApCgkJfQoJICAgIH0KCX0KCWlmIHtbbGxlbmd0aCAkYmFkY29sb3JzXSA+PSAkbmNvbG9yc30gewoJICAgIHNldCBiYWRjb2xvcnMgJG9yaWdiYWQKCX0KICAgIH0KICAgIGZvciB7c2V0IGkgMH0geyRpIDw9ICRuY29sb3JzfSB7aW5jciBpfSB7CglzZXQgYyBbbGluZGV4ICRjb2xvcnMgJG5leHRjb2xvcl0KCWlmIHtbaW5jciBuZXh0Y29sb3JdID49ICRuY29sb3JzfSB7CgkgICAgc2V0IG5leHRjb2xvciAwCgl9CglpZiB7W2xzZWFyY2ggLWV4YWN0ICRiYWRjb2xvcnMgJGNdfSBicmVhawogICAgfQogICAgc2V0IGNvbG9ybWFwKCRpZCkgJGMKfQoKcHJvYyBiaW5kbGluZSB7dCBpZH0gewogICAgZ2xvYmFsIGNhbnYKCiAgICAkY2FudiBiaW5kICR0IDxFbnRlcj4gImxpbmVlbnRlciAleCAleSAkaWQiCiAgICAkY2FudiBiaW5kICR0IDxNb3Rpb24+ICJsaW5lbW90aW9uICV4ICV5ICRpZCIKICAgICRjYW52IGJpbmQgJHQgPExlYXZlPiAibGluZWxlYXZlICRpZCIKICAgICRjYW52IGJpbmQgJHQgPEJ1dHRvbi0xPiAibGluZWNsaWNrICV4ICV5ICRpZCAxIgp9Cgpwcm9jIGRyYXd0YWdzIHtpZCB4IHh0IHkxfSB7CiAgICBnbG9iYWwgaWR0YWdzIGlkaGVhZHMgaWRvdGhlcnJlZnMgbWFpbmhlYWQKICAgIGdsb2JhbCBsaW5lc3BjIGx0aGlja25lc3MKICAgIGdsb2JhbCBjYW52IG1haW5mb250IGNvbW1pdHJvdyByb3d0ZXh0eCBjdXJ2aWV3IGZnY29sb3IgYmdjb2xvcgoKICAgIHNldCBtYXJrcyB7fQogICAgc2V0IG50YWdzIDAKICAgIHNldCBuaGVhZHMgMAogICAgaWYge1tpbmZvIGV4aXN0cyBpZHRhZ3MoJGlkKV19IHsKCXNldCBtYXJrcyAkaWR0YWdzKCRpZCkKCXNldCBudGFncyBbbGxlbmd0aCAkbWFya3NdCiAgICB9CiAgICBpZiB7W2luZm8gZXhpc3RzIGlkaGVhZHMoJGlkKV19IHsKCXNldCBtYXJrcyBbY29uY2F0ICRtYXJrcyAkaWRoZWFkcygkaWQpXQoJc2V0IG5oZWFkcyBbbGxlbmd0aCAkaWRoZWFkcygkaWQpXQogICAgfQogICAgaWYge1tpbmZvIGV4aXN0cyBpZG90aGVycmVmcygkaWQpXX0gewoJc2V0IG1hcmtzIFtjb25jYXQgJG1hcmtzICRpZG90aGVycmVmcygkaWQpXQogICAgfQogICAgaWYgeyRtYXJrcyBlcSB7fX0gewoJcmV0dXJuICR4dAogICAgfQoKICAgIHNldCBkZWx0YSBbZXhwciB7aW50KDAuNSAqICgkbGluZXNwYyAtICRsdGhpY2tuZXNzKSl9XQogICAgc2V0IHl0IFtleHByIHskeTEgLSAwLjUgKiAkbGluZXNwY31dCiAgICBzZXQgeWIgW2V4cHIgeyR5dCArICRsaW5lc3BjIC0gMX1dCiAgICBzZXQgeHZhbHMge30KICAgIHNldCB3dmFscyB7fQogICAgc2V0IGkgLTEKICAgIGZvcmVhY2ggdGFnICRtYXJrcyB7CglpbmNyIGkKCWlmIHskaSA+PSAkbnRhZ3MgJiYgJGkgPCAkbnRhZ3MgKyAkbmhlYWRzICYmICR0YWcgZXEgJG1haW5oZWFkfSB7CgkgICAgc2V0IHdpZCBbZm9udCBtZWFzdXJlIFtjb25jYXQgJG1haW5mb250IGJvbGRdICR0YWddCgl9IGVsc2UgewoJICAgIHNldCB3aWQgW2ZvbnQgbWVhc3VyZSAkbWFpbmZvbnQgJHRhZ10KCX0KCWxhcHBlbmQgeHZhbHMgJHh0CglsYXBwZW5kIHd2YWxzICR3aWQKCXNldCB4dCBbZXhwciB7JHh0ICsgJGRlbHRhICsgJHdpZCArICRsdGhpY2tuZXNzICsgJGxpbmVzcGN9XQogICAgfQogICAgc2V0IHQgWyRjYW52IGNyZWF0ZSBsaW5lICR4ICR5MSBbbGluZGV4ICR4dmFscyBlbmRdICR5MSBcCgkgICAgICAgLXdpZHRoICRsdGhpY2tuZXNzIC1maWxsIGJsYWNrIC10YWdzIHRhZy4kaWRdCiAgICAkY2FudiBsb3dlciAkdAogICAgZm9yZWFjaCB0YWcgJG1hcmtzIHggJHh2YWxzIHdpZCAkd3ZhbHMgewoJc2V0IHhsIFtleHByIHskeCArICRkZWx0YX1dCglzZXQgeHIgW2V4cHIgeyR4ICsgJGRlbHRhICsgJHdpZCArICRsdGhpY2tuZXNzfV0KCXNldCBmb250ICRtYWluZm9udAoJaWYge1tpbmNyIG50YWdzIC0xXSA+PSAwfSB7CgkgICAgIyBkcmF3IGEgdGFnCgkgICAgc2V0IHQgWyRjYW52IGNyZWF0ZSBwb2x5Z29uICR4IFtleHByIHskeXQgKyAkZGVsdGF9XSAkeGwgJHl0IFwKCQkgICAgICAgJHhyICR5dCAkeHIgJHliICR4bCAkeWIgJHggW2V4cHIgeyR5YiAtICRkZWx0YX1dIFwKCQkgICAgICAgLXdpZHRoIDEgLW91dGxpbmUgYmxhY2sgLWZpbGwgeWVsbG93IC10YWdzIHRhZy4kaWRdCgkgICAgJGNhbnYgYmluZCAkdCA8MT4gW2xpc3Qgc2hvd3RhZyAkdGFnIDFdCgkgICAgc2V0IHJvd3RleHR4KCRjb21taXRyb3coJGN1cnZpZXcsJGlkKSkgW2V4cHIgeyR4ciArICRsaW5lc3BjfV0KCX0gZWxzZSB7CgkgICAgIyBkcmF3IGEgaGVhZCBvciBvdGhlciByZWYKCSAgICBpZiB7W2luY3IgbmhlYWRzIC0xXSA+PSAwfSB7CgkJc2V0IGNvbCBncmVlbgoJCWlmIHskdGFnIGVxICRtYWluaGVhZH0gewoJCSAgICBsYXBwZW5kIGZvbnQgYm9sZAoJCX0KCSAgICB9IGVsc2UgewoJCXNldCBjb2wgIiNkZGRkZmYiCgkgICAgfQoJICAgIHNldCB4bCBbZXhwciB7JHhsIC0gJGRlbHRhLzJ9XQoJICAgICRjYW52IGNyZWF0ZSBwb2x5Z29uICR4ICR5dCAkeHIgJHl0ICR4ciAkeWIgJHggJHliIFwKCQktd2lkdGggMSAtb3V0bGluZSBibGFjayAtZmlsbCAkY29sIC10YWdzIHRhZy4kaWQKCSAgICBpZiB7W3JlZ2V4cCB7XihyZW1vdGVzLy4qL3xyZW1vdGVzLyl9ICR0YWcgbWF0Y2ggcmVtb3RlcHJlZml4XX0gewoJICAgICAgICBzZXQgcndpZCBbZm9udCBtZWFzdXJlICRtYWluZm9udCAkcmVtb3RlcHJlZml4XQoJCXNldCB4aSBbZXhwciB7JHggKyAxfV0KCQlzZXQgeXRpIFtleHByIHskeXQgKyAxfV0KCQlzZXQgeHJpIFtleHByIHskeCArICRyd2lkfV0KCQkkY2FudiBjcmVhdGUgcG9seWdvbiAkeGkgJHl0aSAkeHJpICR5dGkgJHhyaSAkeWIgJHhpICR5YiBcCgkJCS13aWR0aCAwIC1maWxsICIjZmZkZGFhIiAtdGFncyB0YWcuJGlkCgkgICAgfQoJfQoJc2V0IHQgWyRjYW52IGNyZWF0ZSB0ZXh0ICR4bCAkeTEgLWFuY2hvciB3IC10ZXh0ICR0YWcgLWZpbGwgJGZnY29sb3IgXAoJCSAgIC1mb250ICRmb250IC10YWdzIFtsaXN0IHRhZy4kaWQgdGV4dF1dCglpZiB7JG50YWdzID49IDB9IHsKCSAgICAkY2FudiBiaW5kICR0IDwxPiBbbGlzdCBzaG93dGFnICR0YWcgMV0KCX0gZWxzZWlmIHskbmhlYWRzID49IDB9IHsKCSAgICAkY2FudiBiaW5kICR0IDxCdXR0b24tMz4gW2xpc3QgaGVhZG1lbnUgJVggJVkgJGlkICR0YWddCgl9CiAgICB9CiAgICByZXR1cm4gJHh0Cn0KCnByb2MgeGNvb3JkIHtpIGxldmVsIGxufSB7CiAgICBnbG9iYWwgY2FudngwIHhzcGMxIHhzcGMyCgogICAgc2V0IHggW2V4cHIgeyRjYW52eDAgKyAkaSAqICR4c3BjMSgkbG4pfV0KICAgIGlmIHskaSA+IDAgJiYgJGkgPT0gJGxldmVsfSB7CglzZXQgeCBbZXhwciB7JHggKyAwLjUgKiAoJHhzcGMyIC0gJHhzcGMxKCRsbikpfV0KICAgIH0gZWxzZWlmIHskaSA+ICRsZXZlbH0gewoJc2V0IHggW2V4cHIgeyR4ICsgJHhzcGMyIC0gJHhzcGMxKCRsbil9XQogICAgfQogICAgcmV0dXJuICR4Cn0KCnByb2Mgc2hvd19zdGF0dXMge21zZ30gewogICAgZ2xvYmFsIGNhbnYgbWFpbmZvbnQgZmdjb2xvcgoKICAgIGNsZWFyX2Rpc3BsYXkKICAgICRjYW52IGNyZWF0ZSB0ZXh0IDMgMyAtYW5jaG9yIG53IC10ZXh0ICRtc2cgLWZvbnQgJG1haW5mb250IFwKCS10YWdzIHRleHQgLWZpbGwgJGZnY29sb3IKfQoKIyBJbnNlcnQgYSBuZXcgY29tbWl0IGFzIHRoZSBjaGlsZCBvZiB0aGUgY29tbWl0IG9uIHJvdyAkcm93LgojIFRoZSBuZXcgY29tbWl0IHdpbGwgYmUgZGlzcGxheWVkIG9uIHJvdyAkcm93IGFuZCB0aGUgY29tbWl0cwojIG9uIHRoYXQgcm93IGFuZCBiZWxvdyB3aWxsIG1vdmUgZG93biBvbmUgcm93Lgpwcm9jIGluc2VydHJvdyB7cm93IG5ld2NtaXR9IHsKICAgIGdsb2JhbCBkaXNwbGF5b3JkZXIgcGFyZW50bGlzdCBjb21taXRsaXN0ZWQgY2hpbGRyZW4KICAgIGdsb2JhbCBjb21taXRyb3cgY3VydmlldyByb3dpZGxpc3Qgcm93b2Zmc2V0cyBudW1jb21taXRzCiAgICBnbG9iYWwgcm93cmFuZ2VsaXN0IHJvd2xhaWRvdXQgcm93b3B0aW0gbnVtY29tbWl0cwogICAgZ2xvYmFsIHNlbGVjdGVkbGluZSByb3djaGsgY29tbWl0aWR4CgogICAgaWYgeyRyb3cgPj0gJG51bWNvbW1pdHN9IHsKCXB1dHMgIm9vcHMsIGluc2VydGluZyBuZXcgcm93ICRyb3cgYnV0IG9ubHkgaGF2ZSAkbnVtY29tbWl0cyByb3dzIgoJcmV0dXJuCiAgICB9CiAgICBzZXQgcCBbbGluZGV4ICRkaXNwbGF5b3JkZXIgJHJvd10KICAgIHNldCBkaXNwbGF5b3JkZXIgW2xpbnNlcnQgJGRpc3BsYXlvcmRlciAkcm93ICRuZXdjbWl0XQogICAgc2V0IHBhcmVudGxpc3QgW2xpbnNlcnQgJHBhcmVudGxpc3QgJHJvdyAkcF0KICAgIHNldCBraWRzICRjaGlsZHJlbigkY3VydmlldywkcCkKICAgIGxhcHBlbmQga2lkcyAkbmV3Y21pdAogICAgc2V0IGNoaWxkcmVuKCRjdXJ2aWV3LCRwKSAka2lkcwogICAgc2V0IGNoaWxkcmVuKCRjdXJ2aWV3LCRuZXdjbWl0KSB7fQogICAgc2V0IGNvbW1pdGxpc3RlZCBbbGluc2VydCAkY29tbWl0bGlzdGVkICRyb3cgMV0KICAgIHNldCBsIFtsbGVuZ3RoICRkaXNwbGF5b3JkZXJdCiAgICBmb3Ige3NldCByICRyb3d9IHskciA8ICRsfSB7aW5jciByfSB7CglzZXQgaWQgW2xpbmRleCAkZGlzcGxheW9yZGVyICRyXQoJc2V0IGNvbW1pdHJvdygkY3VydmlldywkaWQpICRyCiAgICB9CiAgICBpbmNyIGNvbW1pdGlkeCgkY3VydmlldykKCiAgICBzZXQgaWRsaXN0IFtsaW5kZXggJHJvd2lkbGlzdCAkcm93XQogICAgc2V0IG9mZnMgW2xpbmRleCAkcm93b2Zmc2V0cyAkcm93XQogICAgc2V0IG5ld29mZnMge30KICAgIGZvcmVhY2ggeCAkaWRsaXN0IHsKCWlmIHskeCBlcSB7fSB8fCAoJHggZXEgJHAgJiYgW2xsZW5ndGggJGtpZHNdID09IDEpfSB7CgkgICAgbGFwcGVuZCBuZXdvZmZzIHt9Cgl9IGVsc2UgewoJICAgIGxhcHBlbmQgbmV3b2ZmcyAwCgl9CiAgICB9CiAgICBpZiB7W2xsZW5ndGggJGtpZHNdID09IDF9IHsKCXNldCBjb2wgW2xzZWFyY2ggLWV4YWN0ICRpZGxpc3QgJHBdCglsc2V0IGlkbGlzdCAkY29sICRuZXdjbWl0CiAgICB9IGVsc2UgewoJc2V0IGNvbCBbbGxlbmd0aCAkaWRsaXN0XQoJbGFwcGVuZCBpZGxpc3QgJG5ld2NtaXQKCWxhcHBlbmQgb2ZmcyB7fQoJbHNldCByb3dvZmZzZXRzICRyb3cgJG9mZnMKICAgIH0KICAgIHNldCByb3dpZGxpc3QgW2xpbnNlcnQgJHJvd2lkbGlzdCAkcm93ICRpZGxpc3RdCiAgICBzZXQgcm93b2Zmc2V0cyBbbGluc2VydCAkcm93b2Zmc2V0cyBbZXhwciB7JHJvdysxfV0gJG5ld29mZnNdCgogICAgc2V0IHJvd3JhbmdlbGlzdCBbbGluc2VydCAkcm93cmFuZ2VsaXN0ICRyb3cge31dCiAgICBpZiB7W2xsZW5ndGggJGtpZHNdID4gMX0gewoJc2V0IHJwMSBbZXhwciB7JHJvdyArIDF9XQoJc2V0IHJhbmdlcyBbbGluZGV4ICRyb3dyYW5nZWxpc3QgJHJwMV0KCWlmIHskcmFuZ2VzIGVxIHt9fSB7CgkgICAgc2V0IHJhbmdlcyBbbGlzdCAkbmV3Y21pdCAkcF0KCX0gZWxzZWlmIHtbbGluZGV4ICRyYW5nZXMgZW5kLTFdIGVxICRwfSB7CgkgICAgbHNldCByYW5nZXMgZW5kLTEgJG5ld2NtaXQKCX0KCWxzZXQgcm93cmFuZ2VsaXN0ICRycDEgJHJhbmdlcwogICAgfQoKICAgIGNhdGNoIHt1bnNldCByb3djaGt9CgogICAgaW5jciByb3dsYWlkb3V0CiAgICBpbmNyIHJvd29wdGltCiAgICBpbmNyIG51bWNvbW1pdHMKCiAgICBpZiB7W2luZm8gZXhpc3RzIHNlbGVjdGVkbGluZV0gJiYgJHNlbGVjdGVkbGluZSA+PSAkcm93fSB7CglpbmNyIHNlbGVjdGVkbGluZQogICAgfQogICAgcmVkaXNwbGF5Cn0KCiMgUmVtb3ZlIGEgY29tbWl0IHRoYXQgd2FzIGluc2VydGVkIHdpdGggaW5zZXJ0cm93IG9uIHJvdyAkcm93Lgpwcm9jIHJlbW92ZXJvdyB7cm93fSB7CiAgICBnbG9iYWwgZGlzcGxheW9yZGVyIHBhcmVudGxpc3QgY29tbWl0bGlzdGVkIGNoaWxkcmVuCiAgICBnbG9iYWwgY29tbWl0cm93IGN1cnZpZXcgcm93aWRsaXN0IHJvd29mZnNldHMgbnVtY29tbWl0cwogICAgZ2xvYmFsIHJvd3JhbmdlbGlzdCBpZHJvd3JhbmdlcyByb3dsYWlkb3V0IHJvd29wdGltIG51bWNvbW1pdHMKICAgIGdsb2JhbCBsaW5lc2VnZW5kcyBzZWxlY3RlZGxpbmUgcm93Y2hrIGNvbW1pdGlkeAoKICAgIGlmIHskcm93ID49ICRudW1jb21taXRzfSB7CglwdXRzICJvb3BzLCByZW1vdmluZyByb3cgJHJvdyBidXQgb25seSBoYXZlICRudW1jb21taXRzIHJvd3MiCglyZXR1cm4KICAgIH0KICAgIHNldCBycDEgW2V4cHIgeyRyb3cgKyAxfV0KICAgIHNldCBpZCBbbGluZGV4ICRkaXNwbGF5b3JkZXIgJHJvd10KICAgIHNldCBwIFtsaW5kZXggJHBhcmVudGxpc3QgJHJvd10KICAgIHNldCBkaXNwbGF5b3JkZXIgW2xyZXBsYWNlICRkaXNwbGF5b3JkZXIgJHJvdyAkcm93XQogICAgc2V0IHBhcmVudGxpc3QgW2xyZXBsYWNlICRwYXJlbnRsaXN0ICRyb3cgJHJvd10KICAgIHNldCBjb21taXRsaXN0ZWQgW2xyZXBsYWNlICRjb21taXRsaXN0ZWQgJHJvdyAkcm93XQogICAgc2V0IGtpZHMgJGNoaWxkcmVuKCRjdXJ2aWV3LCRwKQogICAgc2V0IGkgW2xzZWFyY2ggLWV4YWN0ICRraWRzICRpZF0KICAgIGlmIHskaSA+PSAwfSB7CglzZXQga2lkcyBbbHJlcGxhY2UgJGtpZHMgJGkgJGldCglzZXQgY2hpbGRyZW4oJGN1cnZpZXcsJHApICRraWRzCiAgICB9CiAgICBzZXQgbCBbbGxlbmd0aCAkZGlzcGxheW9yZGVyXQogICAgZm9yIHtzZXQgciAkcm93fSB7JHIgPCAkbH0ge2luY3Igcn0gewoJc2V0IGlkIFtsaW5kZXggJGRpc3BsYXlvcmRlciAkcl0KCXNldCBjb21taXRyb3coJGN1cnZpZXcsJGlkKSAkcgogICAgfQogICAgaW5jciBjb21taXRpZHgoJGN1cnZpZXcpIC0xCgogICAgc2V0IHJvd2lkbGlzdCBbbHJlcGxhY2UgJHJvd2lkbGlzdCAkcm93ICRyb3ddCiAgICBzZXQgcm93b2Zmc2V0cyBbbHJlcGxhY2UgJHJvd29mZnNldHMgJHJwMSAkcnAxXQogICAgaWYgeyRraWRzIG5lIHt9fSB7CglzZXQgb2ZmcyBbbGluZGV4ICRyb3dvZmZzZXRzICRyb3ddCglzZXQgb2ZmcyBbbHJlcGxhY2UgJG9mZnMgZW5kIGVuZF0KCWxzZXQgcm93b2Zmc2V0cyAkcm93ICRvZmZzCiAgICB9CgogICAgc2V0IHJvd3JhbmdlbGlzdCBbbHJlcGxhY2UgJHJvd3JhbmdlbGlzdCAkcm93ICRyb3ddCiAgICBpZiB7W2xsZW5ndGggJGtpZHNdID4gMH0gewoJc2V0IHJhbmdlcyBbbGluZGV4ICRyb3dyYW5nZWxpc3QgJHJvd10KCWlmIHtbbGluZGV4ICRyYW5nZXMgZW5kLTFdIGVxICRpZH0gewoJICAgIHNldCByYW5nZXMgW2xyZXBsYWNlICRyYW5nZXMgZW5kLTEgZW5kXQoJICAgIGxzZXQgcm93cmFuZ2VsaXN0ICRyb3cgJHJhbmdlcwoJfQogICAgfQoKICAgIGNhdGNoIHt1bnNldCByb3djaGt9CgogICAgaW5jciByb3dsYWlkb3V0IC0xCiAgICBpbmNyIHJvd29wdGltIC0xCiAgICBpbmNyIG51bWNvbW1pdHMgLTEKCiAgICBpZiB7W2luZm8gZXhpc3RzIHNlbGVjdGVkbGluZV0gJiYgJHNlbGVjdGVkbGluZSA+ICRyb3d9IHsKCWluY3Igc2VsZWN0ZWRsaW5lIC0xCiAgICB9CiAgICByZWRpc3BsYXkKfQoKIyBEb24ndCBjaGFuZ2UgdGhlIHRleHQgcGFuZSBjdXJzb3IgaWYgaXQgaXMgY3VycmVudGx5IHRoZSBoYW5kIGN1cnNvciwKIyBzaG93aW5nIHRoYXQgd2UgYXJlIG92ZXIgYSBzaGExIElEIGxpbmsuCnByb2Mgc2V0dGV4dGN1cnNvciB7Y30gewogICAgZ2xvYmFsIGN0ZXh0IGN1cnRleHRjdXJzb3IKCiAgICBpZiB7WyRjdGV4dCBjZ2V0IC1jdXJzb3JdID09ICRjdXJ0ZXh0Y3Vyc29yfSB7CgkkY3RleHQgY29uZmlnIC1jdXJzb3IgJGMKICAgIH0KICAgIHNldCBjdXJ0ZXh0Y3Vyc29yICRjCn0KCnByb2Mgbm93YnVzeSB7d2hhdH0gewogICAgZ2xvYmFsIGlzYnVzeQoKICAgIGlmIHtbYXJyYXkgbmFtZXMgaXNidXN5XSBlcSB7fX0gewoJLiBjb25maWcgLWN1cnNvciB3YXRjaAoJc2V0dGV4dGN1cnNvciB3YXRjaAogICAgfQogICAgc2V0IGlzYnVzeSgkd2hhdCkgMQp9Cgpwcm9jIG5vdGJ1c3kge3doYXR9IHsKICAgIGdsb2JhbCBpc2J1c3kgbWFpbmN1cnNvciB0ZXh0Y3Vyc29yCgogICAgY2F0Y2gge3Vuc2V0IGlzYnVzeSgkd2hhdCl9CiAgICBpZiB7W2FycmF5IG5hbWVzIGlzYnVzeV0gZXEge319IHsKCS4gY29uZmlnIC1jdXJzb3IgJG1haW5jdXJzb3IKCXNldHRleHRjdXJzb3IgJHRleHRjdXJzb3IKICAgIH0KfQoKcHJvYyBmaW5kbWF0Y2hlcyB7Zn0gewogICAgZ2xvYmFsIGZpbmR0eXBlIGZpbmRzdHJpbmcKICAgIGlmIHskZmluZHR5cGUgPT0gIlJlZ2V4cCJ9IHsKCXNldCBtYXRjaGVzIFtyZWdleHAgLWluZGljZXMgLWFsbCAtaW5saW5lICRmaW5kc3RyaW5nICRmXQogICAgfSBlbHNlIHsKCXNldCBmcyAkZmluZHN0cmluZwoJaWYgeyRmaW5kdHlwZSA9PSAiSWduQ2FzZSJ9IHsKCSAgICBzZXQgZiBbc3RyaW5nIHRvbG93ZXIgJGZdCgkgICAgc2V0IGZzIFtzdHJpbmcgdG9sb3dlciAkZnNdCgl9CglzZXQgbWF0Y2hlcyB7fQoJc2V0IGkgMAoJc2V0IGwgW3N0cmluZyBsZW5ndGggJGZzXQoJd2hpbGUge1tzZXQgaiBbc3RyaW5nIGZpcnN0ICRmcyAkZiAkaV1dID49IDB9IHsKCSAgICBsYXBwZW5kIG1hdGNoZXMgW2xpc3QgJGogW2V4cHIgeyRqKyRsLTF9XV0KCSAgICBzZXQgaSBbZXhwciB7JGogKyAkbH1dCgl9CiAgICB9CiAgICByZXR1cm4gJG1hdGNoZXMKfQoKcHJvYyBkb2ZpbmQge3tyZXYgMH19IHsKICAgIGdsb2JhbCBmaW5kc3RyaW5nIGZpbmRzdGFydGxpbmUgZmluZGN1cmxpbmUgc2VsZWN0ZWRsaW5lIG51bWNvbW1pdHMKCiAgICB1bm1hcmttYXRjaGVzCiAgICBjYW5jZWxfbmV4dF9oaWdobGlnaHQKICAgIGZvY3VzIC4KICAgIGlmIHskZmluZHN0cmluZyBlcSB7fSB8fCAkbnVtY29tbWl0cyA9PSAwfSByZXR1cm4KICAgIGlmIHshW2luZm8gZXhpc3RzIHNlbGVjdGVkbGluZV19IHsKCXNldCBmaW5kc3RhcnRsaW5lIFtsaW5kZXggW3Zpc2libGVyb3dzXSAkcmV2XQogICAgfSBlbHNlIHsKCXNldCBmaW5kc3RhcnRsaW5lICRzZWxlY3RlZGxpbmUKICAgIH0KICAgIHNldCBmaW5kY3VybGluZSAkZmluZHN0YXJ0bGluZQogICAgbm93YnVzeSBmaW5kaW5nCiAgICBpZiB7ISRyZXZ9IHsKCXJ1biBmaW5kbW9yZQogICAgfSBlbHNlIHsKCWlmIHskZmluZGN1cmxpbmUgPT0gMH0gewoJICAgIHNldCBmaW5kY3VybGluZSAkbnVtY29tbWl0cwoJfQoJaW5jciBmaW5kY3VybGluZSAtMQoJcnVuIGZpbmRtb3JlcmV2CiAgICB9Cn0KCnByb2MgZmluZG5leHQge3Jlc3RhcnR9IHsKICAgIGdsb2JhbCBmaW5kY3VybGluZQogICAgaWYgeyFbaW5mbyBleGlzdHMgZmluZGN1cmxpbmVdfSB7CglpZiB7JHJlc3RhcnR9IHsKCSAgICBkb2ZpbmQKCX0gZWxzZSB7CgkgICAgYmVsbAoJfQogICAgfSBlbHNlIHsKCXJ1biBmaW5kbW9yZQoJbm93YnVzeSBmaW5kaW5nCiAgICB9Cn0KCnByb2MgZmluZHByZXYge30gewogICAgZ2xvYmFsIGZpbmRjdXJsaW5lCiAgICBpZiB7IVtpbmZvIGV4aXN0cyBmaW5kY3VybGluZV19IHsKCWRvZmluZCAxCiAgICB9IGVsc2UgewoJcnVuIGZpbmRtb3JlcmV2Cglub3didXN5IGZpbmRpbmcKICAgIH0KfQoKcHJvYyBmaW5kbW9yZSB7fSB7CiAgICBnbG9iYWwgY29tbWl0ZGF0YSBjb21taXRpbmZvIG51bWNvbW1pdHMgZmluZHN0cmluZyBmaW5kcGF0dGVybiBmaW5kbG9jCiAgICBnbG9iYWwgZmluZHN0YXJ0bGluZSBmaW5kY3VybGluZSBkaXNwbGF5b3JkZXIKCiAgICBzZXQgZmxkdHlwZXMge0hlYWRsaW5lIEF1dGhvciBEYXRlIENvbW1pdHRlciBDRGF0ZSBDb21tZW50c30KICAgIHNldCBsIFtleHByIHskZmluZGN1cmxpbmUgKyAxfV0KICAgIGlmIHskbCA+PSAkbnVtY29tbWl0c30gewoJc2V0IGwgMAogICAgfQogICAgaWYgeyRsIDw9ICRmaW5kc3RhcnRsaW5lfSB7CglzZXQgbGltIFtleHByIHskZmluZHN0YXJ0bGluZSArIDF9XQogICAgfSBlbHNlIHsKCXNldCBsaW0gJG51bWNvbW1pdHMKICAgIH0KICAgIGlmIHskbGltIC0gJGwgPiA1MDB9IHsKCXNldCBsaW0gW2V4cHIgeyRsICsgNTAwfV0KICAgIH0KICAgIHNldCBsYXN0IDAKICAgIGZvciB7fSB7JGwgPCAkbGltfSB7aW5jciBsfSB7CglzZXQgaWQgW2xpbmRleCAkZGlzcGxheW9yZGVyICRsXQoJIyBzaG91bGRuJ3QgaGFwcGVuIHVubGVzcyBnaXQgbG9nIGRvZXNuJ3QgZ2l2ZSBhbGwgdGhlIGNvbW1pdHMuLi4KCWlmIHshW2luZm8gZXhpc3RzIGNvbW1pdGRhdGEoJGlkKV19IGNvbnRpbnVlCglpZiB7IVtkb2VzbWF0Y2ggJGNvbW1pdGRhdGEoJGlkKV19IGNvbnRpbnVlCglpZiB7IVtpbmZvIGV4aXN0cyBjb21taXRpbmZvKCRpZCldfSB7CgkgICAgZ2V0Y29tbWl0ICRpZAoJfQoJc2V0IGluZm8gJGNvbW1pdGluZm8oJGlkKQoJZm9yZWFjaCBmICRpbmZvIHR5ICRmbGR0eXBlcyB7CgkgICAgaWYgeygkZmluZGxvYyBlcSAiQWxsIGZpZWxkcyIgfHwgJGZpbmRsb2MgZXEgJHR5KSAmJgoJCVtkb2VzbWF0Y2ggJGZdfSB7CgkJZmluZHNlbGVjdGxpbmUgJGwKCQlub3RidXN5IGZpbmRpbmcKCQlyZXR1cm4gMAoJICAgIH0KCX0KICAgIH0KICAgIGlmIHskbCA9PSAkZmluZHN0YXJ0bGluZSArIDF9IHsKCWJlbGwKCXVuc2V0IGZpbmRjdXJsaW5lCglub3RidXN5IGZpbmRpbmcKCXJldHVybiAwCiAgICB9CiAgICBzZXQgZmluZGN1cmxpbmUgW2V4cHIgeyRsIC0gMX1dCiAgICByZXR1cm4gMQp9Cgpwcm9jIGZpbmRtb3JlcmV2IHt9IHsKICAgIGdsb2JhbCBjb21taXRkYXRhIGNvbW1pdGluZm8gbnVtY29tbWl0cyBmaW5kc3RyaW5nIGZpbmRwYXR0ZXJuIGZpbmRsb2MKICAgIGdsb2JhbCBmaW5kc3RhcnRsaW5lIGZpbmRjdXJsaW5lIGRpc3BsYXlvcmRlcgoKICAgIHNldCBmbGR0eXBlcyB7SGVhZGxpbmUgQXV0aG9yIERhdGUgQ29tbWl0dGVyIENEYXRlIENvbW1lbnRzfQogICAgc2V0IGwgJGZpbmRjdXJsaW5lCiAgICBpZiB7JGwgPT0gMH0gewoJc2V0IGwgJG51bWNvbW1pdHMKICAgIH0KICAgIGluY3IgbCAtMQogICAgaWYgeyRsID49ICRmaW5kc3RhcnRsaW5lfSB7CglzZXQgbGltIFtleHByIHskZmluZHN0YXJ0bGluZSAtIDF9XQogICAgfSBlbHNlIHsKCXNldCBsaW0gLTEKICAgIH0KICAgIGlmIHskbCAtICRsaW0gPiA1MDB9IHsKCXNldCBsaW0gW2V4cHIgeyRsIC0gNTAwfV0KICAgIH0KICAgIHNldCBsYXN0IDAKICAgIGZvciB7fSB7JGwgPiAkbGltfSB7aW5jciBsIC0xfSB7CglzZXQgaWQgW2xpbmRleCAkZGlzcGxheW9yZGVyICRsXQoJaWYgeyFbZG9lc21hdGNoICRjb21taXRkYXRhKCRpZCldfSBjb250aW51ZQoJaWYgeyFbaW5mbyBleGlzdHMgY29tbWl0aW5mbygkaWQpXX0gewoJICAgIGdldGNvbW1pdCAkaWQKCX0KCXNldCBpbmZvICRjb21taXRpbmZvKCRpZCkKCWZvcmVhY2ggZiAkaW5mbyB0eSAkZmxkdHlwZXMgewoJICAgIGlmIHsoJGZpbmRsb2MgZXEgIkFsbCBmaWVsZHMiIHx8ICRmaW5kbG9jIGVxICR0eSkgJiYKCQlbZG9lc21hdGNoICRmXX0gewoJCWZpbmRzZWxlY3RsaW5lICRsCgkJbm90YnVzeSBmaW5kaW5nCgkJcmV0dXJuIDAKCSAgICB9Cgl9CiAgICB9CiAgICBpZiB7JGwgPT0gLTF9IHsKCWJlbGwKCXVuc2V0IGZpbmRjdXJsaW5lCglub3RidXN5IGZpbmRpbmcKCXJldHVybiAwCiAgICB9CiAgICBzZXQgZmluZGN1cmxpbmUgW2V4cHIgeyRsICsgMX1dCiAgICByZXR1cm4gMQp9Cgpwcm9jIGZpbmRzZWxlY3RsaW5lIHtsfSB7CiAgICBnbG9iYWwgZmluZGxvYyBjb21tZW50ZW5kIGN0ZXh0IGZpbmRjdXJsaW5lIG1hcmtpbmdtYXRjaGVzCgogICAgc2V0IG1hcmtpbmdtYXRjaGVzIDEKICAgIHNldCBmaW5kY3VybGluZSAkbAogICAgc2VsZWN0bGluZSAkbCAxCiAgICBpZiB7JGZpbmRsb2MgPT0gIkFsbCBmaWVsZHMiIHx8ICRmaW5kbG9jID09ICJDb21tZW50cyJ9IHsKCSMgaGlnaGxpZ2h0IHRoZSBtYXRjaGVzIGluIHRoZSBjb21tZW50cwoJc2V0IGYgWyRjdGV4dCBnZXQgMS4wICRjb21tZW50ZW5kXQoJc2V0IG1hdGNoZXMgW2ZpbmRtYXRjaGVzICRmXQoJZm9yZWFjaCBtYXRjaCAkbWF0Y2hlcyB7CgkgICAgc2V0IHN0YXJ0IFtsaW5kZXggJG1hdGNoIDBdCgkgICAgc2V0IGVuZCBbZXhwciB7W2xpbmRleCAkbWF0Y2ggMV0gKyAxfV0KCSAgICAkY3RleHQgdGFnIGFkZCBmb3VuZCAiMS4wICsgJHN0YXJ0IGMiICIxLjAgKyAkZW5kIGMiCgl9CiAgICB9CiAgICBkcmF3dmlzaWJsZQp9CgojIG1hcmsgdGhlIGJpdHMgb2YgYSBoZWFkbGluZSBvciBhdXRob3IgdGhhdCBtYXRjaCBhIGZpbmQgc3RyaW5nCnByb2MgbWFya21hdGNoZXMge2NhbnYgbCBzdHIgdGFnIG1hdGNoZXMgZm9udCByb3d9IHsKICAgIGdsb2JhbCBzZWxlY3RlZGxpbmUKCiAgICBzZXQgYmJveCBbJGNhbnYgYmJveCAkdGFnXQogICAgc2V0IHgwIFtsaW5kZXggJGJib3ggMF0KICAgIHNldCB5MCBbbGluZGV4ICRiYm94IDFdCiAgICBzZXQgeTEgW2xpbmRleCAkYmJveCAzXQogICAgZm9yZWFjaCBtYXRjaCAkbWF0Y2hlcyB7CglzZXQgc3RhcnQgW2xpbmRleCAkbWF0Y2ggMF0KCXNldCBlbmQgW2xpbmRleCAkbWF0Y2ggMV0KCWlmIHskc3RhcnQgPiAkZW5kfSBjb250aW51ZQoJc2V0IHhvZmYgW2ZvbnQgbWVhc3VyZSAkZm9udCBbc3RyaW5nIHJhbmdlICRzdHIgMCBbZXhwciB7JHN0YXJ0LTF9XV1dCglzZXQgeGxlbiBbZm9udCBtZWFzdXJlICRmb250IFtzdHJpbmcgcmFuZ2UgJHN0ciAwIFtleHByIHskZW5kfV1dXQoJc2V0IHQgWyRjYW52IGNyZWF0ZSByZWN0IFtleHByIHskeDArJHhvZmZ9XSAkeTAgXAoJCSAgIFtleHByIHskeDArJHhsZW4rMn1dICR5MSBcCgkJICAgLW91dGxpbmUge30gLXRhZ3MgW2xpc3QgbWF0Y2gkbCBtYXRjaGVzXSAtZmlsbCB5ZWxsb3ddCgkkY2FudiBsb3dlciAkdAoJaWYge1tpbmZvIGV4aXN0cyBzZWxlY3RlZGxpbmVdICYmICRyb3cgPT0gJHNlbGVjdGVkbGluZX0gewoJICAgICRjYW52IHJhaXNlICR0IHNlY3NlbAoJfQogICAgfQp9Cgpwcm9jIHVubWFya21hdGNoZXMge30gewogICAgZ2xvYmFsIGZpbmRpZHMgbWFya2luZ21hdGNoZXMgZmluZGN1cmxpbmUKCiAgICBhbGxjYW52cyBkZWxldGUgbWF0Y2hlcwogICAgY2F0Y2gge3Vuc2V0IGZpbmRpZHN9CiAgICBzZXQgbWFya2luZ21hdGNoZXMgMAogICAgY2F0Y2gge3Vuc2V0IGZpbmRjdXJsaW5lfQp9Cgpwcm9jIHNlbGNhbnZsaW5lIHt3IHggeX0gewogICAgZ2xvYmFsIGNhbnYgY2FudnkwIGN0ZXh0IGxpbmVzcGMKICAgIGdsb2JhbCByb3d0ZXh0eAogICAgc2V0IHltYXggW2xpbmRleCBbJGNhbnYgY2dldCAtc2Nyb2xscmVnaW9uXSAzXQogICAgaWYgeyR5bWF4ID09IHt9fSByZXR1cm4KICAgIHNldCB5ZnJhYyBbbGluZGV4IFskY2FudiB5dmlld10gMF0KICAgIHNldCB5IFtleHByIHskeSArICR5ZnJhYyAqICR5bWF4fV0KICAgIHNldCBsIFtleHByIHtpbnQoKCR5IC0gJGNhbnZ5MCkgLyAkbGluZXNwYyArIDAuNSl9XQogICAgaWYgeyRsIDwgMH0gewoJc2V0IGwgMAogICAgfQogICAgaWYgeyR3IGVxICRjYW52fSB7CglpZiB7IVtpbmZvIGV4aXN0cyByb3d0ZXh0eCgkbCldIHx8ICR4IDwgJHJvd3RleHR4KCRsKX0gcmV0dXJuCiAgICB9CiAgICB1bm1hcmttYXRjaGVzCiAgICBzZWxlY3RsaW5lICRsIDEKfQoKcHJvYyBjb21taXRfZGVzY3JpcHRvciB7cH0gewogICAgZ2xvYmFsIGNvbW1pdGluZm8KICAgIGlmIHshW2luZm8gZXhpc3RzIGNvbW1pdGluZm8oJHApXX0gewoJZ2V0Y29tbWl0ICRwCiAgICB9CiAgICBzZXQgbCAiLi4uIgogICAgaWYge1tsbGVuZ3RoICRjb21taXRpbmZvKCRwKV0gPiAxfSB7CglzZXQgbCBbbGluZGV4ICRjb21taXRpbmZvKCRwKSAwXQogICAgfQogICAgcmV0dXJuICIkcCAoJGwpXG4iCn0KCiMgYXBwZW5kIHNvbWUgdGV4dCB0byB0aGUgY3RleHQgd2lkZ2V0LCBhbmQgbWFrZSBhbnkgU0hBMSBJRAojIHRoYXQgd2Uga25vdyBhYm91dCBiZSBhIGNsaWNrYWJsZSBsaW5rLgpwcm9jIGFwcGVuZHdpdGhsaW5rcyB7dGV4dCB0YWdzfSB7CiAgICBnbG9iYWwgY3RleHQgY29tbWl0cm93IGxpbmtudW0gY3VydmlldwoKICAgIHNldCBzdGFydCBbJGN0ZXh0IGluZGV4ICJlbmQgLSAxYyJdCiAgICAkY3RleHQgaW5zZXJ0IGVuZCAkdGV4dCAkdGFncwogICAgc2V0IGxpbmtzIFtyZWdleHAgLWluZGljZXMgLWFsbCAtaW5saW5lIHtbMC05YS1mXXs0MH19ICR0ZXh0XQogICAgZm9yZWFjaCBsICRsaW5rcyB7CglzZXQgcyBbbGluZGV4ICRsIDBdCglzZXQgZSBbbGluZGV4ICRsIDFdCglzZXQgbGlua2lkIFtzdHJpbmcgcmFuZ2UgJHRleHQgJHMgJGVdCglpZiB7IVtpbmZvIGV4aXN0cyBjb21taXRyb3coJGN1cnZpZXcsJGxpbmtpZCldfSBjb250aW51ZQoJaW5jciBlCgkkY3RleHQgdGFnIGFkZCBsaW5rICIkc3RhcnQgKyAkcyBjIiAiJHN0YXJ0ICsgJGUgYyIKCSRjdGV4dCB0YWcgYWRkIGxpbmskbGlua251bSAiJHN0YXJ0ICsgJHMgYyIgIiRzdGFydCArICRlIGMiCgkkY3RleHQgdGFnIGJpbmQgbGluayRsaW5rbnVtIDwxPiBcCgkgICAgW2xpc3Qgc2VsZWN0bGluZSAkY29tbWl0cm93KCRjdXJ2aWV3LCRsaW5raWQpIDFdCglpbmNyIGxpbmtudW0KICAgIH0KICAgICRjdGV4dCB0YWcgY29uZiBsaW5rIC1mb3JlZ3JvdW5kIGJsdWUgLXVuZGVybGluZSAxCiAgICAkY3RleHQgdGFnIGJpbmQgbGluayA8RW50ZXI+IHsgJVcgY29uZmlndXJlIC1jdXJzb3IgaGFuZDIgfQogICAgJGN0ZXh0IHRhZyBiaW5kIGxpbmsgPExlYXZlPiB7ICVXIGNvbmZpZ3VyZSAtY3Vyc29yICRjdXJ0ZXh0Y3Vyc29yIH0KfQoKcHJvYyB2aWV3bmV4dGxpbmUge2Rpcn0gewogICAgZ2xvYmFsIGNhbnYgbGluZXNwYwoKICAgICRjYW52IGRlbGV0ZSBob3ZlcgogICAgc2V0IHltYXggW2xpbmRleCBbJGNhbnYgY2dldCAtc2Nyb2xscmVnaW9uXSAzXQogICAgc2V0IHdub3cgWyRjYW52IHl2aWV3XQogICAgc2V0IHd0b3AgW2V4cHIge1tsaW5kZXggJHdub3cgMF0gKiAkeW1heH1dCiAgICBzZXQgbmV3dG9wIFtleHByIHskd3RvcCArICRkaXIgKiAkbGluZXNwY31dCiAgICBpZiB7JG5ld3RvcCA8IDB9IHsKCXNldCBuZXd0b3AgMAogICAgfSBlbHNlaWYgeyRuZXd0b3AgPiAkeW1heH0gewoJc2V0IG5ld3RvcCAkeW1heAogICAgfQogICAgYWxsY2FudnMgeXZpZXcgbW92ZXRvIFtleHByIHskbmV3dG9wICogMS4wIC8gJHltYXh9XQp9CgojIGFkZCBhIGxpc3Qgb2YgdGFnIG9yIGJyYW5jaCBuYW1lcyBhdCBwb3NpdGlvbiBwb3MKIyByZXR1cm5zIHRoZSBudW1iZXIgb2YgbmFtZXMgaW5zZXJ0ZWQKcHJvYyBhcHBlbmRyZWZzIHtwb3MgaWRzIHZhcn0gewogICAgZ2xvYmFsIGN0ZXh0IGNvbW1pdHJvdyBsaW5rbnVtIGN1cnZpZXcgJHZhciBtYXhyZWZzCgogICAgaWYge1tjYXRjaCB7JGN0ZXh0IGluZGV4ICRwb3N9XX0gewoJcmV0dXJuIDAKICAgIH0KICAgICRjdGV4dCBjb25mIC1zdGF0ZSBub3JtYWwKICAgICRjdGV4dCBkZWxldGUgJHBvcyAiJHBvcyBsaW5lZW5kIgogICAgc2V0IHRhZ3Mge30KICAgIGZvcmVhY2ggaWQgJGlkcyB7Cglmb3JlYWNoIHRhZyBbc2V0ICR2YXJcKCRpZFwpXSB7CgkgICAgbGFwcGVuZCB0YWdzIFtsaXN0ICR0YWcgJGlkXQoJfQogICAgfQogICAgaWYge1tsbGVuZ3RoICR0YWdzXSA+ICRtYXhyZWZzfSB7CgkkY3RleHQgaW5zZXJ0ICRwb3MgIm1hbnkgKFtsbGVuZ3RoICR0YWdzXSkiCiAgICB9IGVsc2UgewoJc2V0IHRhZ3MgW2xzb3J0IC1pbmRleCAwIC1kZWNyZWFzaW5nICR0YWdzXQoJc2V0IHNlcCB7fQoJZm9yZWFjaCB0aSAkdGFncyB7CgkgICAgc2V0IGlkIFtsaW5kZXggJHRpIDFdCgkgICAgc2V0IGxrIGxpbmskbGlua251bQoJICAgIGluY3IgbGlua251bQoJICAgICRjdGV4dCB0YWcgZGVsZXRlICRsawoJICAgICRjdGV4dCBpbnNlcnQgJHBvcyAkc2VwCgkgICAgJGN0ZXh0IGluc2VydCAkcG9zIFtsaW5kZXggJHRpIDBdICRsawoJICAgIGlmIHtbaW5mbyBleGlzdHMgY29tbWl0cm93KCRjdXJ2aWV3LCRpZCldfSB7CgkJJGN0ZXh0IHRhZyBjb25mICRsayAtZm9yZWdyb3VuZCBibHVlCgkJJGN0ZXh0IHRhZyBiaW5kICRsayA8MT4gXAoJCSAgICBbbGlzdCBzZWxlY3RsaW5lICRjb21taXRyb3coJGN1cnZpZXcsJGlkKSAxXQoJCSRjdGV4dCB0YWcgY29uZiAkbGsgLXVuZGVybGluZSAxCgkJJGN0ZXh0IHRhZyBiaW5kICRsayA8RW50ZXI+IHsgJVcgY29uZmlndXJlIC1jdXJzb3IgaGFuZDIgfQoJCSRjdGV4dCB0YWcgYmluZCAkbGsgPExlYXZlPiBcCgkJICAgIHsgJVcgY29uZmlndXJlIC1jdXJzb3IgJGN1cnRleHRjdXJzb3IgfQoJICAgIH0KCSAgICBzZXQgc2VwICIsICIKCX0KICAgIH0KICAgICRjdGV4dCBjb25mIC1zdGF0ZSBkaXNhYmxlZAogICAgcmV0dXJuIFtsbGVuZ3RoICR0YWdzXQp9CgojIGNhbGxlZCB3aGVuIHdlIGhhdmUgZmluaXNoZWQgY29tcHV0aW5nIHRoZSBuZWFyYnkgdGFncwpwcm9jIGRpc3BuZWFydGFncyB7ZGVsYXl9IHsKICAgIGdsb2JhbCBzZWxlY3RlZGxpbmUgY3VycmVudGlkIHNob3duZWFydGFncyB0YWdwaGFzZQoKICAgIGlmIHshW2luZm8gZXhpc3RzIHNlbGVjdGVkbGluZV0gfHwgISRzaG93bmVhcnRhZ3N9IHJldHVybgogICAgYWZ0ZXIgY2FuY2VsIGRpc3BuZXh0dGFnCiAgICBpZiB7JGRlbGF5fSB7CglhZnRlciAyMDAgZGlzcG5leHR0YWcKCXNldCB0YWdwaGFzZSAtMQogICAgfSBlbHNlIHsKCWFmdGVyIGlkbGUgZGlzcG5leHR0YWcKCXNldCB0YWdwaGFzZSAwCiAgICB9Cn0KCnByb2MgZGlzcG5leHR0YWcge30gewogICAgZ2xvYmFsIHNlbGVjdGVkbGluZSBjdXJyZW50aWQgc2hvd25lYXJ0YWdzIHRhZ3BoYXNlIGN0ZXh0CgogICAgaWYgeyFbaW5mbyBleGlzdHMgc2VsZWN0ZWRsaW5lXSB8fCAhJHNob3duZWFydGFnc30gcmV0dXJuCiAgICBzd2l0Y2ggLS0gJHRhZ3BoYXNlIHsKCTAgewoJICAgIHNldCBkdGFncyBbZGVzY3RhZ3MgJGN1cnJlbnRpZF0KCSAgICBpZiB7JGR0YWdzIG5lIHt9fSB7CgkJYXBwZW5kcmVmcyBwcmVjZWRlcyAkZHRhZ3MgaWR0YWdzCgkgICAgfQoJfQoJMSB7CgkgICAgc2V0IGF0YWdzIFthbmN0YWdzICRjdXJyZW50aWRdCgkgICAgaWYgeyRhdGFncyBuZSB7fX0gewoJCWFwcGVuZHJlZnMgZm9sbG93cyAkYXRhZ3MgaWR0YWdzCgkgICAgfQoJfQoJMiB7CgkgICAgc2V0IGRoZWFkcyBbZGVzY2hlYWRzICRjdXJyZW50aWRdCgkgICAgaWYgeyRkaGVhZHMgbmUge319IHsKCQlpZiB7W2FwcGVuZHJlZnMgYnJhbmNoICRkaGVhZHMgaWRoZWFkc10gPiAxCgkJICAgICYmIFskY3RleHQgZ2V0ICJicmFuY2ggLTNjIl0gZXEgImgifSB7CgkJICAgICMgdHVybiAiQnJhbmNoIiBpbnRvICJCcmFuY2hlcyIKCQkgICAgJGN0ZXh0IGNvbmYgLXN0YXRlIG5vcm1hbAoJCSAgICAkY3RleHQgaW5zZXJ0ICJicmFuY2ggLTJjIiAiZXMiCgkJICAgICRjdGV4dCBjb25mIC1zdGF0ZSBkaXNhYmxlZAoJCX0KCSAgICB9Cgl9CiAgICB9CiAgICBpZiB7W2luY3IgdGFncGhhc2VdIDw9IDJ9IHsKCWFmdGVyIGlkbGUgZGlzcG5leHR0YWcKICAgIH0KfQoKcHJvYyBzZWxlY3RsaW5lIHtsIGlzbmV3fSB7CiAgICBnbG9iYWwgY2FudiBjYW52MiBjYW52MyBjdGV4dCBjb21taXRpbmZvIHNlbGVjdGVkbGluZQogICAgZ2xvYmFsIGRpc3BsYXlvcmRlciBsaW5laHRhZyBsaW5lbnRhZyBsaW5lZHRhZwogICAgZ2xvYmFsIGNhbnZ5MCBsaW5lc3BjIHBhcmVudGxpc3QgY2hpbGRyZW4gY3VydmlldwogICAgZ2xvYmFsIGN1cnJlbnRpZCBzaGExZW50cnkKICAgIGdsb2JhbCBjb21tZW50ZW5kIGlkdGFncyBsaW5rbnVtCiAgICBnbG9iYWwgbWVyZ2VtYXggbnVtY29tbWl0cyBwZW5kaW5nX3NlbGVjdAogICAgZ2xvYmFsIGNtaXRtb2RlIHNob3duZWFydGFncyBhbGxjb21taXRzCgogICAgY2F0Y2gge3Vuc2V0IHBlbmRpbmdfc2VsZWN0fQogICAgJGNhbnYgZGVsZXRlIGhvdmVyCiAgICBub3JtYWxsaW5lCiAgICBjYW5jZWxfbmV4dF9oaWdobGlnaHQKICAgIGlmIHskbCA8IDAgfHwgJGwgPj0gJG51bWNvbW1pdHN9IHJldHVybgogICAgc2V0IHkgW2V4cHIgeyRjYW52eTAgKyAkbCAqICRsaW5lc3BjfV0KICAgIHNldCB5bWF4IFtsaW5kZXggWyRjYW52IGNnZXQgLXNjcm9sbHJlZ2lvbl0gM10KICAgIHNldCB5dG9wIFtleHByIHskeSAtICRsaW5lc3BjIC0gMX1dCiAgICBzZXQgeWJvdCBbZXhwciB7JHkgKyAkbGluZXNwYyArIDF9XQogICAgc2V0IHdub3cgWyRjYW52IHl2aWV3XQogICAgc2V0IHd0b3AgW2V4cHIge1tsaW5kZXggJHdub3cgMF0gKiAkeW1heH1dCiAgICBzZXQgd2JvdCBbZXhwciB7W2xpbmRleCAkd25vdyAxXSAqICR5bWF4fV0KICAgIHNldCB3aCBbZXhwciB7JHdib3QgLSAkd3RvcH1dCiAgICBzZXQgbmV3dG9wICR3dG9wCiAgICBpZiB7JHl0b3AgPCAkd3RvcH0gewoJaWYgeyR5Ym90IDwgJHd0b3B9IHsKCSAgICBzZXQgbmV3dG9wIFtleHByIHskeSAtICR3aCAvIDIuMH1dCgl9IGVsc2UgewoJICAgIHNldCBuZXd0b3AgJHl0b3AKCSAgICBpZiB7JG5ld3RvcCA+ICR3dG9wIC0gJGxpbmVzcGN9IHsKCQlzZXQgbmV3dG9wIFtleHByIHskd3RvcCAtICRsaW5lc3BjfV0KCSAgICB9Cgl9CiAgICB9IGVsc2VpZiB7JHlib3QgPiAkd2JvdH0gewoJaWYgeyR5dG9wID4gJHdib3R9IHsKCSAgICBzZXQgbmV3dG9wIFtleHByIHskeSAtICR3aCAvIDIuMH1dCgl9IGVsc2UgewoJICAgIHNldCBuZXd0b3AgW2V4cHIgeyR5Ym90IC0gJHdofV0KCSAgICBpZiB7JG5ld3RvcCA8ICR3dG9wICsgJGxpbmVzcGN9IHsKCQlzZXQgbmV3dG9wIFtleHByIHskd3RvcCArICRsaW5lc3BjfV0KCSAgICB9Cgl9CiAgICB9CiAgICBpZiB7JG5ld3RvcCAhPSAkd3RvcH0gewoJaWYgeyRuZXd0b3AgPCAwfSB7CgkgICAgc2V0IG5ld3RvcCAwCgl9CglhbGxjYW52cyB5dmlldyBtb3ZldG8gW2V4cHIgeyRuZXd0b3AgKiAxLjAgLyAkeW1heH1dCglkcmF3dmlzaWJsZQogICAgfQoKICAgIGlmIHshW2luZm8gZXhpc3RzIGxpbmVodGFnKCRsKV19IHJldHVybgogICAgJGNhbnYgZGVsZXRlIHNlY3NlbAogICAgc2V0IHQgW2V2YWwgJGNhbnYgY3JlYXRlIHJlY3QgWyRjYW52IGJib3ggJGxpbmVodGFnKCRsKV0gLW91dGxpbmUge3t9fSBcCgkgICAgICAgLXRhZ3Mgc2Vjc2VsIC1maWxsIFskY2FudiBjZ2V0IC1zZWxlY3RiYWNrZ3JvdW5kXV0KICAgICRjYW52IGxvd2VyICR0CiAgICAkY2FudjIgZGVsZXRlIHNlY3NlbAogICAgc2V0IHQgW2V2YWwgJGNhbnYyIGNyZWF0ZSByZWN0IFskY2FudjIgYmJveCAkbGluZW50YWcoJGwpXSAtb3V0bGluZSB7e319IFwKCSAgICAgICAtdGFncyBzZWNzZWwgLWZpbGwgWyRjYW52MiBjZ2V0IC1zZWxlY3RiYWNrZ3JvdW5kXV0KICAgICRjYW52MiBsb3dlciAkdAogICAgJGNhbnYzIGRlbGV0ZSBzZWNzZWwKICAgIHNldCB0IFtldmFsICRjYW52MyBjcmVhdGUgcmVjdCBbJGNhbnYzIGJib3ggJGxpbmVkdGFnKCRsKV0gLW91dGxpbmUge3t9fSBcCgkgICAgICAgLXRhZ3Mgc2Vjc2VsIC1maWxsIFskY2FudjMgY2dldCAtc2VsZWN0YmFja2dyb3VuZF1dCiAgICAkY2FudjMgbG93ZXIgJHQKCiAgICBpZiB7JGlzbmV3fSB7CglhZGR0b2hpc3RvcnkgW2xpc3Qgc2VsZWN0bGluZSAkbCAwXQogICAgfQoKICAgIHNldCBzZWxlY3RlZGxpbmUgJGwKCiAgICBzZXQgaWQgW2xpbmRleCAkZGlzcGxheW9yZGVyICRsXQogICAgc2V0IGN1cnJlbnRpZCAkaWQKICAgICRzaGExZW50cnkgZGVsZXRlIDAgZW5kCiAgICAkc2hhMWVudHJ5IGluc2VydCAwICRpZAogICAgJHNoYTFlbnRyeSBzZWxlY3Rpb24gZnJvbSAwCiAgICAkc2hhMWVudHJ5IHNlbGVjdGlvbiB0byBlbmQKICAgIHJoaWdobGlnaHRfc2VsICRpZAoKICAgICRjdGV4dCBjb25mIC1zdGF0ZSBub3JtYWwKICAgIGNsZWFyX2N0ZXh0CiAgICBzZXQgbGlua251bSAwCiAgICBzZXQgaW5mbyAkY29tbWl0aW5mbygkaWQpCiAgICBzZXQgZGF0ZSBbZm9ybWF0ZGF0ZSBbbGluZGV4ICRpbmZvIDJdXQogICAgJGN0ZXh0IGluc2VydCBlbmQgIkF1dGhvcjogW2xpbmRleCAkaW5mbyAxXSAgJGRhdGVcbiIKICAgIHNldCBkYXRlIFtmb3JtYXRkYXRlIFtsaW5kZXggJGluZm8gNF1dCiAgICAkY3RleHQgaW5zZXJ0IGVuZCAiQ29tbWl0dGVyOiBbbGluZGV4ICRpbmZvIDNdICAkZGF0ZVxuIgogICAgaWYge1tpbmZvIGV4aXN0cyBpZHRhZ3MoJGlkKV19IHsKCSRjdGV4dCBpbnNlcnQgZW5kICJUYWdzOiIKCWZvcmVhY2ggdGFnICRpZHRhZ3MoJGlkKSB7CgkgICAgJGN0ZXh0IGluc2VydCBlbmQgIiAkdGFnIgoJfQoJJGN0ZXh0IGluc2VydCBlbmQgIlxuIgogICAgfQoKICAgIHNldCBoZWFkZXJzIHt9CiAgICBzZXQgb2xkcyBbbGluZGV4ICRwYXJlbnRsaXN0ICRsXQogICAgaWYge1tsbGVuZ3RoICRvbGRzXSA+IDF9IHsKCXNldCBucCAwCglmb3JlYWNoIHAgJG9sZHMgewoJICAgIGlmIHskbnAgPj0gJG1lcmdlbWF4fSB7CgkJc2V0IHRhZyBtbWF4CgkgICAgfSBlbHNlIHsKCQlzZXQgdGFnIG0kbnAKCSAgICB9CgkgICAgJGN0ZXh0IGluc2VydCBlbmQgIlBhcmVudDogIiAkdGFnCgkgICAgYXBwZW5kd2l0aGxpbmtzIFtjb21taXRfZGVzY3JpcHRvciAkcF0ge30KCSAgICBpbmNyIG5wCgl9CiAgICB9IGVsc2UgewoJZm9yZWFjaCBwICRvbGRzIHsKCSAgICBhcHBlbmQgaGVhZGVycyAiUGFyZW50OiBbY29tbWl0X2Rlc2NyaXB0b3IgJHBdIgoJfQogICAgfQoKICAgIGZvcmVhY2ggYyAkY2hpbGRyZW4oJGN1cnZpZXcsJGlkKSB7CglhcHBlbmQgaGVhZGVycyAiQ2hpbGQ6ICBbY29tbWl0X2Rlc2NyaXB0b3IgJGNdIgogICAgfQoKICAgICMgbWFrZSBhbnl0aGluZyB0aGF0IGxvb2tzIGxpa2UgYSBTSEExIElEIGJlIGEgY2xpY2thYmxlIGxpbmsKICAgIGFwcGVuZHdpdGhsaW5rcyAkaGVhZGVycyB7fQogICAgaWYgeyRzaG93bmVhcnRhZ3N9IHsKCWlmIHshW2luZm8gZXhpc3RzIGFsbGNvbW1pdHNdfSB7CgkgICAgZ2V0YWxsY29tbWl0cwoJfQoJJGN0ZXh0IGluc2VydCBlbmQgIkJyYW5jaDogIgoJJGN0ZXh0IG1hcmsgc2V0IGJyYW5jaCAiZW5kIC0xYyIKCSRjdGV4dCBtYXJrIGdyYXZpdHkgYnJhbmNoIGxlZnQKCSRjdGV4dCBpbnNlcnQgZW5kICJcbkZvbGxvd3M6ICIKCSRjdGV4dCBtYXJrIHNldCBmb2xsb3dzICJlbmQgLTFjIgoJJGN0ZXh0IG1hcmsgZ3Jhdml0eSBmb2xsb3dzIGxlZnQKCSRjdGV4dCBpbnNlcnQgZW5kICJcblByZWNlZGVzOiAiCgkkY3RleHQgbWFyayBzZXQgcHJlY2VkZXMgImVuZCAtMWMiCgkkY3RleHQgbWFyayBncmF2aXR5IHByZWNlZGVzIGxlZnQKCSRjdGV4dCBpbnNlcnQgZW5kICJcbiIKCWRpc3BuZWFydGFncyAxCiAgICB9CiAgICAkY3RleHQgaW5zZXJ0IGVuZCAiXG4iCiAgICBzZXQgY29tbWVudCBbbGluZGV4ICRpbmZvIDVdCiAgICBpZiB7W3N0cmluZyBmaXJzdCAiXHIiICRjb21tZW50XSA+PSAwfSB7CglzZXQgY29tbWVudCBbc3RyaW5nIG1hcCB7IlxyIiAiXG4gICAgIn0gJGNvbW1lbnRdCiAgICB9CiAgICBhcHBlbmR3aXRobGlua3MgJGNvbW1lbnQge2NvbW1lbnR9CgogICAgJGN0ZXh0IHRhZyByZW1vdmUgZm91bmQgMS4wIGVuZAogICAgJGN0ZXh0IGNvbmYgLXN0YXRlIGRpc2FibGVkCiAgICBzZXQgY29tbWVudGVuZCBbJGN0ZXh0IGluZGV4ICJlbmQgLSAxYyJdCgogICAgaW5pdF9mbGlzdCAiQ29tbWVudHMiCiAgICBpZiB7JGNtaXRtb2RlIGVxICJ0cmVlIn0gewoJZ2V0dHJlZSAkaWQKICAgIH0gZWxzZWlmIHtbbGxlbmd0aCAkb2xkc10gPD0gMX0gewoJc3RhcnRkaWZmICRpZAogICAgfSBlbHNlIHsKCW1lcmdlZGlmZiAkaWQgJGwKICAgIH0KfQoKcHJvYyBzZWxmaXJzdGxpbmUge30gewogICAgdW5tYXJrbWF0Y2hlcwogICAgc2VsZWN0bGluZSAwIDEKfQoKcHJvYyBzZWxsYXN0bGluZSB7fSB7CiAgICBnbG9iYWwgbnVtY29tbWl0cwogICAgdW5tYXJrbWF0Y2hlcwogICAgc2V0IGwgW2V4cHIgeyRudW1jb21taXRzIC0gMX1dCiAgICBzZWxlY3RsaW5lICRsIDEKfQoKcHJvYyBzZWxuZXh0bGluZSB7ZGlyfSB7CiAgICBnbG9iYWwgc2VsZWN0ZWRsaW5lCiAgICBpZiB7IVtpbmZvIGV4aXN0cyBzZWxlY3RlZGxpbmVdfSByZXR1cm4KICAgIHNldCBsIFtleHByIHskc2VsZWN0ZWRsaW5lICsgJGRpcn1dCiAgICB1bm1hcmttYXRjaGVzCiAgICBzZWxlY3RsaW5lICRsIDEKfQoKcHJvYyBzZWxuZXh0cGFnZSB7ZGlyfSB7CiAgICBnbG9iYWwgY2FudiBsaW5lc3BjIHNlbGVjdGVkbGluZSBudW1jb21taXRzCgogICAgc2V0IGxwcCBbZXhwciB7KFt3aW5mbyBoZWlnaHQgJGNhbnZdIC0gMikgLyAkbGluZXNwY31dCiAgICBpZiB7JGxwcCA8IDF9IHsKCXNldCBscHAgMQogICAgfQogICAgYWxsY2FudnMgeXZpZXcgc2Nyb2xsIFtleHByIHskZGlyICogJGxwcH1dIHVuaXRzCiAgICBkcmF3dmlzaWJsZQogICAgaWYgeyFbaW5mbyBleGlzdHMgc2VsZWN0ZWRsaW5lXX0gcmV0dXJuCiAgICBzZXQgbCBbZXhwciB7JHNlbGVjdGVkbGluZSArICRkaXIgKiAkbHBwfV0KICAgIGlmIHskbCA8IDB9IHsKCXNldCBsIDAKICAgIH0gZWxzZWlmIHskbCA+PSAkbnVtY29tbWl0c30gewogICAgICAgIHNldCBsIFtleHByICRudW1jb21taXRzIC0gMV0KICAgIH0KICAgIHVubWFya21hdGNoZXMKICAgIHNlbGVjdGxpbmUgJGwgMQp9Cgpwcm9jIHVuc2VsZWN0bGluZSB7fSB7CiAgICBnbG9iYWwgc2VsZWN0ZWRsaW5lIGN1cnJlbnRpZAoKICAgIGNhdGNoIHt1bnNldCBzZWxlY3RlZGxpbmV9CiAgICBjYXRjaCB7dW5zZXQgY3VycmVudGlkfQogICAgYWxsY2FudnMgZGVsZXRlIHNlY3NlbAogICAgcmhpZ2hsaWdodF9ub25lCiAgICBjYW5jZWxfbmV4dF9oaWdobGlnaHQKfQoKcHJvYyByZXNlbGVjdGxpbmUge30gewogICAgZ2xvYmFsIHNlbGVjdGVkbGluZQoKICAgIGlmIHtbaW5mbyBleGlzdHMgc2VsZWN0ZWRsaW5lXX0gewoJc2VsZWN0bGluZSAkc2VsZWN0ZWRsaW5lIDAKICAgIH0KfQoKcHJvYyBhZGR0b2hpc3Rvcnkge2NtZH0gewogICAgZ2xvYmFsIGhpc3RvcnkgaGlzdG9yeWluZGV4IGN1cnZpZXcKCiAgICBzZXQgZWx0IFtsaXN0ICRjdXJ2aWV3ICRjbWRdCiAgICBpZiB7JGhpc3RvcnlpbmRleCA+IDAKCSYmIFtsaW5kZXggJGhpc3RvcnkgW2V4cHIgeyRoaXN0b3J5aW5kZXggLSAxfV1dID09ICRlbHR9IHsKCXJldHVybgogICAgfQoKICAgIGlmIHskaGlzdG9yeWluZGV4IDwgW2xsZW5ndGggJGhpc3RvcnldfSB7CglzZXQgaGlzdG9yeSBbbHJlcGxhY2UgJGhpc3RvcnkgJGhpc3RvcnlpbmRleCBlbmQgJGVsdF0KICAgIH0gZWxzZSB7CglsYXBwZW5kIGhpc3RvcnkgJGVsdAogICAgfQogICAgaW5jciBoaXN0b3J5aW5kZXgKICAgIGlmIHskaGlzdG9yeWluZGV4ID4gMX0gewoJLnRmLmJhci5sZWZ0YnV0IGNvbmYgLXN0YXRlIG5vcm1hbAogICAgfSBlbHNlIHsKCS50Zi5iYXIubGVmdGJ1dCBjb25mIC1zdGF0ZSBkaXNhYmxlZAogICAgfQogICAgLnRmLmJhci5yaWdodGJ1dCBjb25mIC1zdGF0ZSBkaXNhYmxlZAp9Cgpwcm9jIGdvZG8ge2VsdH0gewogICAgZ2xvYmFsIGN1cnZpZXcKCiAgICBzZXQgdmlldyBbbGluZGV4ICRlbHQgMF0KICAgIHNldCBjbWQgW2xpbmRleCAkZWx0IDFdCiAgICBpZiB7JGN1cnZpZXcgIT0gJHZpZXd9IHsKCXNob3d2aWV3ICR2aWV3CiAgICB9CiAgICBldmFsICRjbWQKfQoKcHJvYyBnb2JhY2sge30gewogICAgZ2xvYmFsIGhpc3RvcnkgaGlzdG9yeWluZGV4CgogICAgaWYgeyRoaXN0b3J5aW5kZXggPiAxfSB7CglpbmNyIGhpc3RvcnlpbmRleCAtMQoJZ29kbyBbbGluZGV4ICRoaXN0b3J5IFtleHByIHskaGlzdG9yeWluZGV4IC0gMX1dXQoJLnRmLmJhci5yaWdodGJ1dCBjb25mIC1zdGF0ZSBub3JtYWwKICAgIH0KICAgIGlmIHskaGlzdG9yeWluZGV4IDw9IDF9IHsKCS50Zi5iYXIubGVmdGJ1dCBjb25mIC1zdGF0ZSBkaXNhYmxlZAogICAgfQp9Cgpwcm9jIGdvZm9ydyB7fSB7CiAgICBnbG9iYWwgaGlzdG9yeSBoaXN0b3J5aW5kZXgKCiAgICBpZiB7JGhpc3RvcnlpbmRleCA8IFtsbGVuZ3RoICRoaXN0b3J5XX0gewoJc2V0IGNtZCBbbGluZGV4ICRoaXN0b3J5ICRoaXN0b3J5aW5kZXhdCglpbmNyIGhpc3RvcnlpbmRleAoJZ29kbyAkY21kCgkudGYuYmFyLmxlZnRidXQgY29uZiAtc3RhdGUgbm9ybWFsCiAgICB9CiAgICBpZiB7JGhpc3RvcnlpbmRleCA+PSBbbGxlbmd0aCAkaGlzdG9yeV19IHsKCS50Zi5iYXIucmlnaHRidXQgY29uZiAtc3RhdGUgZGlzYWJsZWQKICAgIH0KfQoKcHJvYyBnZXR0cmVlIHtpZH0gewogICAgZ2xvYmFsIHRyZWVmaWxlbGlzdCB0cmVlaWRsaXN0IGRpZmZpZHMgZGlmZm1lcmdlaWQgdHJlZXBlbmRpbmcKICAgIGdsb2JhbCBudWxsaWQgbnVsbGlkMgoKICAgIHNldCBkaWZmaWRzICRpZAogICAgY2F0Y2gge3Vuc2V0IGRpZmZtZXJnZWlkfQogICAgaWYgeyFbaW5mbyBleGlzdHMgdHJlZWZpbGVsaXN0KCRpZCldfSB7CglpZiB7IVtpbmZvIGV4aXN0cyB0cmVlcGVuZGluZ119IHsKCSAgICBpZiB7JGlkIGVxICRudWxsaWR9IHsKCQlzZXQgY21kIFtsaXN0IHwgZ2l0IGxzLWZpbGVzXQoJICAgIH0gZWxzZWlmIHskaWQgZXEgJG51bGxpZDJ9IHsKCQlzZXQgY21kIFtsaXN0IHwgZ2l0IGxzLWZpbGVzIC0tc3RhZ2UgLXRdCgkgICAgfSBlbHNlIHsKCQlzZXQgY21kIFtsaXN0IHwgZ2l0IGxzLXRyZWUgLXIgJGlkXQoJICAgIH0KCSAgICBpZiB7W2NhdGNoIHtzZXQgZ3RmIFtvcGVuICRjbWQgcl19XX0gewoJCXJldHVybgoJICAgIH0KCSAgICBzZXQgdHJlZXBlbmRpbmcgJGlkCgkgICAgc2V0IHRyZWVmaWxlbGlzdCgkaWQpIHt9CgkgICAgc2V0IHRyZWVpZGxpc3QoJGlkKSB7fQoJICAgIGZjb25maWd1cmUgJGd0ZiAtYmxvY2tpbmcgMAoJICAgIGZpbGVydW4gJGd0ZiBbbGlzdCBnZXR0cmVlbGluZSAkZ3RmICRpZF0KCX0KICAgIH0gZWxzZSB7CglzZXRmaWxlbGlzdCAkaWQKICAgIH0KfQoKcHJvYyBnZXR0cmVlbGluZSB7Z3RmIGlkfSB7CiAgICBnbG9iYWwgdHJlZWZpbGVsaXN0IHRyZWVpZGxpc3QgdHJlZXBlbmRpbmcgY21pdG1vZGUgZGlmZmlkcyBudWxsaWQgbnVsbGlkMgoKICAgIHNldCBubCAwCiAgICB3aGlsZSB7W2luY3IgbmxdIDw9IDEwMDAgJiYgW2dldHMgJGd0ZiBsaW5lXSA+PSAwfSB7CglpZiB7JGRpZmZpZHMgZXEgJG51bGxpZH0gewoJICAgIHNldCBmbmFtZSAkbGluZQoJfSBlbHNlIHsKCSAgICBpZiB7JGRpZmZpZHMgbmUgJG51bGxpZDIgJiYgW2xpbmRleCAkbGluZSAxXSBuZSAiYmxvYiJ9IGNvbnRpbnVlCgkgICAgc2V0IGkgW3N0cmluZyBmaXJzdCAiXHQiICRsaW5lXQoJICAgIGlmIHskaSA8IDB9IGNvbnRpbnVlCgkgICAgc2V0IHNoYTEgW2xpbmRleCAkbGluZSAyXQoJICAgIHNldCBmbmFtZSBbc3RyaW5nIHJhbmdlICRsaW5lIFtleHByIHskaSsxfV0gZW5kXQoJICAgIGlmIHtbc3RyaW5nIGluZGV4ICRmbmFtZSAwXSBlcSAiXCIifSB7CgkJc2V0IGZuYW1lIFtsaW5kZXggJGZuYW1lIDBdCgkgICAgfQoJICAgIGxhcHBlbmQgdHJlZWlkbGlzdCgkaWQpICRzaGExCgl9CglsYXBwZW5kIHRyZWVmaWxlbGlzdCgkaWQpICRmbmFtZQogICAgfQogICAgaWYgeyFbZW9mICRndGZdfSB7CglyZXR1cm4gW2V4cHIgeyRubCA+PSAxMDAwPyAyOiAxfV0KICAgIH0KICAgIGNsb3NlICRndGYKICAgIHVuc2V0IHRyZWVwZW5kaW5nCiAgICBpZiB7JGNtaXRtb2RlIG5lICJ0cmVlIn0gewoJaWYgeyFbaW5mbyBleGlzdHMgZGlmZm1lcmdlaWRdfSB7CgkgICAgZ2V0dHJlZWRpZmZzICRkaWZmaWRzCgl9CiAgICB9IGVsc2VpZiB7JGlkIG5lICRkaWZmaWRzfSB7CglnZXR0cmVlICRkaWZmaWRzCiAgICB9IGVsc2UgewoJc2V0ZmlsZWxpc3QgJGlkCiAgICB9CiAgICByZXR1cm4gMAp9Cgpwcm9jIHNob3dmaWxlIHtmfSB7CiAgICBnbG9iYWwgdHJlZWZpbGVsaXN0IHRyZWVpZGxpc3QgZGlmZmlkcyBudWxsaWQgbnVsbGlkMgogICAgZ2xvYmFsIGN0ZXh0IGNvbW1lbnRlbmQKCiAgICBzZXQgaSBbbHNlYXJjaCAtZXhhY3QgJHRyZWVmaWxlbGlzdCgkZGlmZmlkcykgJGZdCiAgICBpZiB7JGkgPCAwfSB7CglwdXRzICJvb3BzLCAkZiBub3QgaW4gbGlzdCBmb3IgaWQgJGRpZmZpZHMiCglyZXR1cm4KICAgIH0KICAgIGlmIHskZGlmZmlkcyBlcSAkbnVsbGlkfSB7CglpZiB7W2NhdGNoIHtzZXQgYmYgW29wZW4gJGYgcl19IGVycl19IHsKCSAgICBwdXRzICJvb3BzLCBjYW4ndCByZWFkICRmOiAkZXJyIgoJICAgIHJldHVybgoJfQogICAgfSBlbHNlIHsKCXNldCBibG9iIFtsaW5kZXggJHRyZWVpZGxpc3QoJGRpZmZpZHMpICRpXQoJaWYge1tjYXRjaCB7c2V0IGJmIFtvcGVuIFtjb25jYXQgfCBnaXQgY2F0LWZpbGUgYmxvYiAkYmxvYl0gcl19IGVycl19IHsKCSAgICBwdXRzICJvb3BzLCBlcnJvciByZWFkaW5nIGJsb2IgJGJsb2I6ICRlcnIiCgkgICAgcmV0dXJuCgl9CiAgICB9CiAgICBmY29uZmlndXJlICRiZiAtYmxvY2tpbmcgMAogICAgZmlsZXJ1biAkYmYgW2xpc3QgZ2V0YmxvYmxpbmUgJGJmICRkaWZmaWRzXQogICAgJGN0ZXh0IGNvbmZpZyAtc3RhdGUgbm9ybWFsCiAgICBjbGVhcl9jdGV4dCAkY29tbWVudGVuZAogICAgJGN0ZXh0IGluc2VydCBlbmQgIlxuIgogICAgJGN0ZXh0IGluc2VydCBlbmQgIiRmXG4iIGZpbGVzZXAKICAgICRjdGV4dCBjb25maWcgLXN0YXRlIGRpc2FibGVkCiAgICAkY3RleHQgeXZpZXcgJGNvbW1lbnRlbmQKfQoKcHJvYyBnZXRibG9ibGluZSB7YmYgaWR9IHsKICAgIGdsb2JhbCBkaWZmaWRzIGNtaXRtb2RlIGN0ZXh0CgogICAgaWYgeyRpZCBuZSAkZGlmZmlkcyB8fCAkY21pdG1vZGUgbmUgInRyZWUifSB7CgljYXRjaCB7Y2xvc2UgJGJmfQoJcmV0dXJuIDAKICAgIH0KICAgICRjdGV4dCBjb25maWcgLXN0YXRlIG5vcm1hbAogICAgc2V0IG5sIDAKICAgIHdoaWxlIHtbaW5jciBubF0gPD0gMTAwMCAmJiBbZ2V0cyAkYmYgbGluZV0gPj0gMH0gewoJJGN0ZXh0IGluc2VydCBlbmQgIiRsaW5lXG4iCiAgICB9CiAgICBpZiB7W2VvZiAkYmZdfSB7CgkjIGRlbGV0ZSBsYXN0IG5ld2xpbmUKCSRjdGV4dCBkZWxldGUgImVuZCAtIDJjIiAiZW5kIC0gMWMiCgljbG9zZSAkYmYKCXJldHVybiAwCiAgICB9CiAgICAkY3RleHQgY29uZmlnIC1zdGF0ZSBkaXNhYmxlZAogICAgcmV0dXJuIFtleHByIHskbmwgPj0gMTAwMD8gMjogMX1dCn0KCnByb2MgbWVyZ2VkaWZmIHtpZCBsfSB7CiAgICBnbG9iYWwgZGlmZm1lcmdlaWQgZGlmZm9wdHMgbWRpZmZmZAogICAgZ2xvYmFsIGRpZmZpZHMKICAgIGdsb2JhbCBwYXJlbnRsaXN0CgogICAgc2V0IGRpZmZtZXJnZWlkICRpZAogICAgc2V0IGRpZmZpZHMgJGlkCiAgICAjIHRoaXMgZG9lc24ndCBzZWVtIHRvIGFjdHVhbGx5IGFmZmVjdCBhbnl0aGluZy4uLgogICAgc2V0IGVudihHSVRfRElGRl9PUFRTKSAkZGlmZm9wdHMKICAgIHNldCBjbWQgW2NvbmNhdCB8IGdpdCBkaWZmLXRyZWUgLS1uby1jb21taXQtaWQgLS1jYyAkaWRdCiAgICBpZiB7W2NhdGNoIHtzZXQgbWRmIFtvcGVuICRjbWQgcl19IGVycl19IHsKCWVycm9yX3BvcHVwICJFcnJvciBnZXR0aW5nIG1lcmdlIGRpZmZzOiAkZXJyIgoJcmV0dXJuCiAgICB9CiAgICBmY29uZmlndXJlICRtZGYgLWJsb2NraW5nIDAKICAgIHNldCBtZGlmZmZkKCRpZCkgJG1kZgogICAgc2V0IG5wIFtsbGVuZ3RoIFtsaW5kZXggJHBhcmVudGxpc3QgJGxdXQogICAgZmlsZXJ1biAkbWRmIFtsaXN0IGdldG1lcmdlZGlmZmxpbmUgJG1kZiAkaWQgJG5wXQp9Cgpwcm9jIGdldG1lcmdlZGlmZmxpbmUge21kZiBpZCBucH0gewogICAgZ2xvYmFsIGRpZmZtZXJnZWlkIGN0ZXh0IGNmbGlzdCBtZXJnZW1heAogICAgZ2xvYmFsIGRpZmZmaWxlc3RhcnQgbWRpZmZmZAoKICAgICRjdGV4dCBjb25mIC1zdGF0ZSBub3JtYWwKICAgIHNldCBuciAwCiAgICB3aGlsZSB7W2luY3IgbnJdIDw9IDEwMDAgJiYgW2dldHMgJG1kZiBsaW5lXSA+PSAwfSB7CglpZiB7IVtpbmZvIGV4aXN0cyBkaWZmbWVyZ2VpZF0gfHwgJGlkICE9ICRkaWZmbWVyZ2VpZAoJICAgIHx8ICRtZGYgIT0gJG1kaWZmZmQoJGlkKX0gewoJICAgIGNsb3NlICRtZGYKCSAgICByZXR1cm4gMAoJfQoJaWYge1tyZWdleHAge15kaWZmIC0tY2MgKC4qKX0gJGxpbmUgbWF0Y2ggZm5hbWVdfSB7CgkgICAgIyBzdGFydCBvZiBhIG5ldyBmaWxlCgkgICAgJGN0ZXh0IGluc2VydCBlbmQgIlxuIgoJICAgIHNldCBoZXJlIFskY3RleHQgaW5kZXggImVuZCAtIDFjIl0KCSAgICBsYXBwZW5kIGRpZmZmaWxlc3RhcnQgJGhlcmUKCSAgICBhZGRfZmxpc3QgW2xpc3QgJGZuYW1lXQoJICAgIHNldCBsIFtleHByIHsoNzggLSBbc3RyaW5nIGxlbmd0aCAkZm5hbWVdKSAvIDJ9XQoJICAgIHNldCBwYWQgW3N0cmluZyByYW5nZSAiLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSIgMSAkbF0KCSAgICAkY3RleHQgaW5zZXJ0IGVuZCAiJHBhZCAkZm5hbWUgJHBhZFxuIiBmaWxlc2VwCgl9IGVsc2VpZiB7W3JlZ2V4cCB7XkBAfSAkbGluZV19IHsKCSAgICAkY3RleHQgaW5zZXJ0IGVuZCAiJGxpbmVcbiIgaHVua3NlcAoJfSBlbHNlaWYge1tyZWdleHAge15bMC05YS1mXXs0MH0kfSAkbGluZV0gfHwgW3JlZ2V4cCB7XmluZGV4fSAkbGluZV19IHsKCSAgICAjIGRvIG5vdGhpbmcKCX0gZWxzZSB7CgkgICAgIyBwYXJzZSB0aGUgcHJlZml4IC0gb25lICcgJywgJy0nIG9yICcrJyBmb3IgZWFjaCBwYXJlbnQKCSAgICBzZXQgc3BhY2VzIHt9CgkgICAgc2V0IG1pbnVzZXMge30KCSAgICBzZXQgcGx1c2VzIHt9CgkgICAgc2V0IGlzYmFkIDAKCSAgICBmb3Ige3NldCBqIDB9IHskaiA8ICRucH0ge2luY3Igan0gewoJCXNldCBjIFtzdHJpbmcgcmFuZ2UgJGxpbmUgJGogJGpdCgkJaWYgeyRjID09ICIgIn0gewoJCSAgICBsYXBwZW5kIHNwYWNlcyAkagoJCX0gZWxzZWlmIHskYyA9PSAiLSJ9IHsKCQkgICAgbGFwcGVuZCBtaW51c2VzICRqCgkJfSBlbHNlaWYgeyRjID09ICIrIn0gewoJCSAgICBsYXBwZW5kIHBsdXNlcyAkagoJCX0gZWxzZSB7CgkJICAgIHNldCBpc2JhZCAxCgkJICAgIGJyZWFrCgkJfQoJICAgIH0KCSAgICBzZXQgdGFncyB7fQoJICAgIHNldCBudW0ge30KCSAgICBpZiB7ISRpc2JhZCAmJiAkbWludXNlcyBuZSB7fSAmJiAkcGx1c2VzIGVxIHt9fSB7CgkJIyBsaW5lIGRvZXNuJ3QgYXBwZWFyIGluIHJlc3VsdCwgcGFyZW50cyBpbiAkbWludXNlcyBoYXZlIHRoZSBsaW5lCgkJc2V0IG51bSBbbGluZGV4ICRtaW51c2VzIDBdCgkgICAgfSBlbHNlaWYgeyEkaXNiYWQgJiYgJHBsdXNlcyBuZSB7fSAmJiAkbWludXNlcyBlcSB7fX0gewoJCSMgbGluZSBhcHBlYXJzIGluIHJlc3VsdCwgcGFyZW50cyBpbiAkcGx1c2VzIGRvbid0IGhhdmUgdGhlIGxpbmUKCQlsYXBwZW5kIHRhZ3MgbXJlc3VsdAoJCXNldCBudW0gW2xpbmRleCAkc3BhY2VzIDBdCgkgICAgfQoJICAgIGlmIHskbnVtIG5lIHt9fSB7CgkJaWYgeyRudW0gPj0gJG1lcmdlbWF4fSB7CgkJICAgIHNldCBudW0gIm1heCIKCQl9CgkJbGFwcGVuZCB0YWdzIG0kbnVtCgkgICAgfQoJICAgICRjdGV4dCBpbnNlcnQgZW5kICIkbGluZVxuIiAkdGFncwoJfQogICAgfQogICAgJGN0ZXh0IGNvbmYgLXN0YXRlIGRpc2FibGVkCiAgICBpZiB7W2VvZiAkbWRmXX0gewoJY2xvc2UgJG1kZgoJcmV0dXJuIDAKICAgIH0KICAgIHJldHVybiBbZXhwciB7JG5yID49IDEwMDA/IDI6IDF9XQp9Cgpwcm9jIHN0YXJ0ZGlmZiB7aWRzfSB7CiAgICBnbG9iYWwgdHJlZWRpZmZzIGRpZmZpZHMgdHJlZXBlbmRpbmcgZGlmZm1lcmdlaWQgbnVsbGlkIG51bGxpZDIKCiAgICBzZXQgZGlmZmlkcyAkaWRzCiAgICBjYXRjaCB7dW5zZXQgZGlmZm1lcmdlaWR9CiAgICBpZiB7IVtpbmZvIGV4aXN0cyB0cmVlZGlmZnMoJGlkcyldIHx8CglbbHNlYXJjaCAtZXhhY3QgJGlkcyAkbnVsbGlkXSA+PSAwIHx8CglbbHNlYXJjaCAtZXhhY3QgJGlkcyAkbnVsbGlkMl0gPj0gMH0gewoJaWYgeyFbaW5mbyBleGlzdHMgdHJlZXBlbmRpbmddfSB7CgkgICAgZ2V0dHJlZWRpZmZzICRpZHMKCX0KICAgIH0gZWxzZSB7CglhZGR0b2NmbGlzdCAkaWRzCiAgICB9Cn0KCnByb2MgYWRkdG9jZmxpc3Qge2lkc30gewogICAgZ2xvYmFsIHRyZWVkaWZmcyBjZmxpc3QKICAgIGFkZF9mbGlzdCAkdHJlZWRpZmZzKCRpZHMpCiAgICBnZXRibG9iZGlmZnMgJGlkcwp9Cgpwcm9jIGRpZmZjbWQge2lkcyBmbGFnc30gewogICAgZ2xvYmFsIG51bGxpZCBudWxsaWQyCgogICAgc2V0IGkgW2xzZWFyY2ggLWV4YWN0ICRpZHMgJG51bGxpZF0KICAgIHNldCBqIFtsc2VhcmNoIC1leGFjdCAkaWRzICRudWxsaWQyXQogICAgaWYgeyRpID49IDB9IHsKCWlmIHtbbGxlbmd0aCAkaWRzXSA+IDEgJiYgJGogPCAwfSB7CgkgICAgIyBjb21wYXJpbmcgd29ya2luZyBkaXJlY3Rvcnkgd2l0aCBzb21lIHNwZWNpZmljIHJldmlzaW9uCgkgICAgc2V0IGNtZCBbY29uY2F0IHwgZ2l0IGRpZmYtaW5kZXggJGZsYWdzXQoJICAgIGlmIHskaSA9PSAwfSB7CgkJbGFwcGVuZCBjbWQgLVIgW2xpbmRleCAkaWRzIDFdCgkgICAgfSBlbHNlIHsKCQlsYXBwZW5kIGNtZCBbbGluZGV4ICRpZHMgMF0KCSAgICB9Cgl9IGVsc2UgewoJICAgICMgY29tcGFyaW5nIHdvcmtpbmcgZGlyZWN0b3J5IHdpdGggaW5kZXgKCSAgICBzZXQgY21kIFtjb25jYXQgfCBnaXQgZGlmZi1maWxlcyAkZmxhZ3NdCgkgICAgaWYgeyRqID09IDF9IHsKCQlsYXBwZW5kIGNtZCAtUgoJICAgIH0KCX0KICAgIH0gZWxzZWlmIHskaiA+PSAwfSB7CglzZXQgY21kIFtjb25jYXQgfCBnaXQgZGlmZi1pbmRleCAtLWNhY2hlZCAkZmxhZ3NdCglpZiB7W2xsZW5ndGggJGlkc10gPiAxfSB7CgkgICAgIyBjb21wYXJpbmcgaW5kZXggd2l0aCBzcGVjaWZpYyByZXZpc2lvbgoJICAgIGlmIHskaSA9PSAwfSB7CgkJbGFwcGVuZCBjbWQgLVIgW2xpbmRleCAkaWRzIDFdCgkgICAgfSBlbHNlIHsKCQlsYXBwZW5kIGNtZCBbbGluZGV4ICRpZHMgMF0KCSAgICB9Cgl9IGVsc2UgewoJICAgICMgY29tcGFyaW5nIGluZGV4IHdpdGggSEVBRAoJICAgIGxhcHBlbmQgY21kIEhFQUQKCX0KICAgIH0gZWxzZSB7CglzZXQgY21kIFtjb25jYXQgfCBnaXQgZGlmZi10cmVlIC1yICRmbGFncyAkaWRzXQogICAgfQogICAgcmV0dXJuICRjbWQKfQoKcHJvYyBnZXR0cmVlZGlmZnMge2lkc30gewogICAgZ2xvYmFsIHRyZWVkaWZmIHRyZWVwZW5kaW5nCgogICAgc2V0IHRyZWVwZW5kaW5nICRpZHMKICAgIHNldCB0cmVlZGlmZiB7fQogICAgaWYge1tjYXRjaCB7c2V0IGdkdGYgW29wZW4gW2RpZmZjbWQgJGlkcyB7LS1uby1jb21taXQtaWR9XSByXX1dfSByZXR1cm4KICAgIGZjb25maWd1cmUgJGdkdGYgLWJsb2NraW5nIDAKICAgIGZpbGVydW4gJGdkdGYgW2xpc3QgZ2V0dHJlZWRpZmZsaW5lICRnZHRmICRpZHNdCn0KCnByb2MgZ2V0dHJlZWRpZmZsaW5lIHtnZHRmIGlkc30gewogICAgZ2xvYmFsIHRyZWVkaWZmIHRyZWVkaWZmcyB0cmVlcGVuZGluZyBkaWZmaWRzIGRpZmZtZXJnZWlkCiAgICBnbG9iYWwgY21pdG1vZGUKCiAgICBzZXQgbnIgMAogICAgd2hpbGUge1tpbmNyIG5yXSA8PSAxMDAwICYmIFtnZXRzICRnZHRmIGxpbmVdID49IDB9IHsKCXNldCBpIFtzdHJpbmcgZmlyc3QgIlx0IiAkbGluZV0KCWlmIHskaSA+PSAwfSB7CgkgICAgc2V0IGZpbGUgW3N0cmluZyByYW5nZSAkbGluZSBbZXhwciB7JGkrMX1dIGVuZF0KCSAgICBpZiB7W3N0cmluZyBpbmRleCAkZmlsZSAwXSBlcSAiXCIifSB7CgkJc2V0IGZpbGUgW2xpbmRleCAkZmlsZSAwXQoJICAgIH0KCSAgICBsYXBwZW5kIHRyZWVkaWZmICRmaWxlCgl9CiAgICB9CiAgICBpZiB7IVtlb2YgJGdkdGZdfSB7CglyZXR1cm4gW2V4cHIgeyRuciA+PSAxMDAwPyAyOiAxfV0KICAgIH0KICAgIGNsb3NlICRnZHRmCiAgICBzZXQgdHJlZWRpZmZzKCRpZHMpICR0cmVlZGlmZgogICAgdW5zZXQgdHJlZXBlbmRpbmcKICAgIGlmIHskY21pdG1vZGUgZXEgInRyZWUifSB7CglnZXR0cmVlICRkaWZmaWRzCiAgICB9IGVsc2VpZiB7JGlkcyAhPSAkZGlmZmlkc30gewoJaWYgeyFbaW5mbyBleGlzdHMgZGlmZm1lcmdlaWRdfSB7CgkgICAgZ2V0dHJlZWRpZmZzICRkaWZmaWRzCgl9CiAgICB9IGVsc2UgewoJYWRkdG9jZmxpc3QgJGlkcwogICAgfQogICAgcmV0dXJuIDAKfQoKcHJvYyBnZXRibG9iZGlmZnMge2lkc30gewogICAgZ2xvYmFsIGRpZmZvcHRzIGJsb2JkaWZmZmQgZGlmZmlkcyBlbnYKICAgIGdsb2JhbCBkaWZmaW5oZHIgdHJlZWRpZmZzCgogICAgc2V0IGVudihHSVRfRElGRl9PUFRTKSAkZGlmZm9wdHMKICAgIGlmIHtbY2F0Y2gge3NldCBiZGYgW29wZW4gW2RpZmZjbWQgJGlkcyB7LXAgLUMgLS1uby1jb21taXQtaWR9XSByXX0gZXJyXX0gewoJcHV0cyAiZXJyb3IgZ2V0dGluZyBkaWZmczogJGVyciIKCXJldHVybgogICAgfQogICAgc2V0IGRpZmZpbmhkciAwCiAgICBmY29uZmlndXJlICRiZGYgLWJsb2NraW5nIDAKICAgIHNldCBibG9iZGlmZmZkKCRpZHMpICRiZGYKICAgIGZpbGVydW4gJGJkZiBbbGlzdCBnZXRibG9iZGlmZmxpbmUgJGJkZiAkZGlmZmlkc10KfQoKcHJvYyBzZXRpbmxpc3Qge3ZhciBpIHZhbH0gewogICAgZ2xvYmFsICR2YXIKCiAgICB3aGlsZSB7W2xsZW5ndGggW3NldCAkdmFyXV0gPCAkaX0gewoJbGFwcGVuZCAkdmFyIHt9CiAgICB9CiAgICBpZiB7W2xsZW5ndGggW3NldCAkdmFyXV0gPT0gJGl9IHsKCWxhcHBlbmQgJHZhciAkdmFsCiAgICB9IGVsc2UgewoJbHNldCAkdmFyICRpICR2YWwKICAgIH0KfQoKcHJvYyBtYWtlZGlmZmhkciB7Zm5hbWUgaWRzfSB7CiAgICBnbG9iYWwgY3RleHQgY3VyZGlmZnN0YXJ0IHRyZWVkaWZmcwoKICAgIHNldCBpIFtsc2VhcmNoIC1leGFjdCAkdHJlZWRpZmZzKCRpZHMpICRmbmFtZV0KICAgIGlmIHskaSA+PSAwfSB7CglzZXRpbmxpc3QgZGlmZmZpbGVzdGFydCAkaSAkY3VyZGlmZnN0YXJ0CiAgICB9CiAgICBzZXQgbCBbZXhwciB7KDc4IC0gW3N0cmluZyBsZW5ndGggJGZuYW1lXSkgLyAyfV0KICAgIHNldCBwYWQgW3N0cmluZyByYW5nZSAiLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSIgMSAkbF0KICAgICRjdGV4dCBpbnNlcnQgJGN1cmRpZmZzdGFydCAiJHBhZCAkZm5hbWUgJHBhZCIgZmlsZXNlcAp9Cgpwcm9jIGdldGJsb2JkaWZmbGluZSB7YmRmIGlkc30gewogICAgZ2xvYmFsIGRpZmZpZHMgYmxvYmRpZmZmZCBjdGV4dCBjdXJkaWZmc3RhcnQKICAgIGdsb2JhbCBkaWZmbmV4dGhlYWQgZGlmZm5leHRub3RlIGRpZmZmaWxlc3RhcnQKICAgIGdsb2JhbCBkaWZmaW5oZHIgdHJlZWRpZmZzCgogICAgc2V0IG5yIDAKICAgICRjdGV4dCBjb25mIC1zdGF0ZSBub3JtYWwKICAgIHdoaWxlIHtbaW5jciBucl0gPD0gMTAwMCAmJiBbZ2V0cyAkYmRmIGxpbmVdID49IDB9IHsKCWlmIHskaWRzICE9ICRkaWZmaWRzIHx8ICRiZGYgIT0gJGJsb2JkaWZmZmQoJGlkcyl9IHsKCSAgICBjbG9zZSAkYmRmCgkgICAgcmV0dXJuIDAKCX0KCWlmIHshW3N0cmluZyBjb21wYXJlIC1sZW5ndGggMTEgImRpZmYgLS1naXQgIiAkbGluZV19IHsKCSAgICAjIHRyaW0gb2ZmICJkaWZmIC0tZ2l0ICIKCSAgICBzZXQgbGluZSBbc3RyaW5nIHJhbmdlICRsaW5lIDExIGVuZF0KCSAgICBzZXQgZGlmZmluaGRyIDEKCSAgICAjIHN0YXJ0IG9mIGEgbmV3IGZpbGUKCSAgICAkY3RleHQgaW5zZXJ0IGVuZCAiXG4iCgkgICAgc2V0IGN1cmRpZmZzdGFydCBbJGN0ZXh0IGluZGV4ICJlbmQgLSAxYyJdCgkgICAgJGN0ZXh0IGluc2VydCBlbmQgIlxuIiBmaWxlc2VwCgkgICAgIyBJZiB0aGUgbmFtZSBoYXNuJ3QgY2hhbmdlZCB0aGUgbGVuZ3RoIHdpbGwgYmUgb2RkLAoJICAgICMgdGhlIG1pZGRsZSBjaGFyIHdpbGwgYmUgYSBzcGFjZSwgYW5kIHRoZSB0d28gYml0cyBlaXRoZXIKCSAgICAjIHNpZGUgd2lsbCBiZSBhL25hbWUgYW5kIGIvbmFtZSwgb3IgImEvbmFtZSIgYW5kICJiL25hbWUiLgoJICAgICMgSWYgdGhlIG5hbWUgaGFzIGNoYW5nZWQgd2UnbGwgZ2V0ICJyZW5hbWUgZnJvbSIgYW5kCgkgICAgIyAicmVuYW1lIHRvIiBsaW5lcyBmb2xsb3dpbmcgdGhpcywgYW5kIHdlJ2xsIHVzZSB0aGVtCgkgICAgIyB0byBnZXQgdGhlIGZpbGVuYW1lcy4KCSAgICAjIFRoaXMgY29tcGxleGl0eSBpcyBuZWNlc3NhcnkgYmVjYXVzZSBzcGFjZXMgaW4gdGhlIGZpbGVuYW1lKHMpCgkgICAgIyBkb24ndCBnZXQgZXNjYXBlZC4KCSAgICBzZXQgbCBbc3RyaW5nIGxlbmd0aCAkbGluZV0KCSAgICBzZXQgaSBbZXhwciB7JGwgLyAyfV0KCSAgICBpZiB7ISgoJGwgJiAxKSAmJiBbc3RyaW5nIGluZGV4ICRsaW5lICRpXSBlcSAiICIgJiYKCQkgIFtzdHJpbmcgcmFuZ2UgJGxpbmUgMiBbZXhwciB7JGkgLSAxfV1dIGVxIFwKCQkgICAgICBbc3RyaW5nIHJhbmdlICRsaW5lIFtleHByIHskaSArIDN9XSBlbmRdKX0gewoJCWNvbnRpbnVlCgkgICAgfQoJICAgICMgdW5lc2NhcGUgaWYgcXVvdGVkIGFuZCBjaG9wIG9mZiB0aGUgYS8gZnJvbSB0aGUgZnJvbnQKCSAgICBpZiB7W3N0cmluZyBpbmRleCAkbGluZSAwXSBlcSAiXCIifSB7CgkJc2V0IGZuYW1lIFtzdHJpbmcgcmFuZ2UgW2xpbmRleCAkbGluZSAwXSAyIGVuZF0KCSAgICB9IGVsc2UgewoJCXNldCBmbmFtZSBbc3RyaW5nIHJhbmdlICRsaW5lIDIgW2V4cHIgeyRpIC0gMX1dXQoJICAgIH0KCSAgICBtYWtlZGlmZmhkciAkZm5hbWUgJGlkcwoKCX0gZWxzZWlmIHtbcmVnZXhwIHteQEAgLShbMC05XSspKCxbMC05XSspPyBcKyhbMC05XSspKCxbMC05XSspPyBAQCguKil9IFwKCQkgICAgICAgJGxpbmUgbWF0Y2ggZjFsIGYxYyBmMmwgZjJjIHJlc3RdfSB7CgkgICAgJGN0ZXh0IGluc2VydCBlbmQgIiRsaW5lXG4iIGh1bmtzZXAKCSAgICBzZXQgZGlmZmluaGRyIDAKCgl9IGVsc2VpZiB7JGRpZmZpbmhkcn0gewoJICAgIGlmIHshW3N0cmluZyBjb21wYXJlIC1sZW5ndGggMTIgInJlbmFtZSBmcm9tICIgJGxpbmVdfSB7CgkJc2V0IGZuYW1lIFtzdHJpbmcgcmFuZ2UgJGxpbmUgMTIgZW5kXQoJCWlmIHtbc3RyaW5nIGluZGV4ICRmbmFtZSAwXSBlcSAiXCIifSB7CgkJICAgIHNldCBmbmFtZSBbbGluZGV4ICRmbmFtZSAwXQoJCX0KCQlzZXQgaSBbbHNlYXJjaCAtZXhhY3QgJHRyZWVkaWZmcygkaWRzKSAkZm5hbWVdCgkJaWYgeyRpID49IDB9IHsKCQkgICAgc2V0aW5saXN0IGRpZmZmaWxlc3RhcnQgJGkgJGN1cmRpZmZzdGFydAoJCX0KCSAgICB9IGVsc2VpZiB7IVtzdHJpbmcgY29tcGFyZSAtbGVuZ3RoIDEwICRsaW5lICJyZW5hbWUgdG8gIl19IHsKCQlzZXQgZm5hbWUgW3N0cmluZyByYW5nZSAkbGluZSAxMCBlbmRdCgkJaWYge1tzdHJpbmcgaW5kZXggJGZuYW1lIDBdIGVxICJcIiJ9IHsKCQkgICAgc2V0IGZuYW1lIFtsaW5kZXggJGZuYW1lIDBdCgkJfQoJCW1ha2VkaWZmaGRyICRmbmFtZSAkaWRzCgkgICAgfSBlbHNlaWYge1tzdHJpbmcgY29tcGFyZSAtbGVuZ3RoIDMgJGxpbmUgIi0tLSJdID09IDB9IHsKCQkjIGRvIG5vdGhpbmcKCQljb250aW51ZQoJICAgIH0gZWxzZWlmIHtbc3RyaW5nIGNvbXBhcmUgLWxlbmd0aCAzICRsaW5lICIrKysiXSA9PSAwfSB7CgkJc2V0IGRpZmZpbmhkciAwCgkJY29udGludWUKCSAgICB9CgkgICAgJGN0ZXh0IGluc2VydCBlbmQgIiRsaW5lXG4iIGZpbGVzZXAKCgl9IGVsc2UgewoJICAgIHNldCB4IFtzdHJpbmcgcmFuZ2UgJGxpbmUgMCAwXQoJICAgIGlmIHskeCA9PSAiLSIgfHwgJHggPT0gIisifSB7CgkJc2V0IHRhZyBbZXhwciB7JHggPT0gIisifV0KCQkkY3RleHQgaW5zZXJ0IGVuZCAiJGxpbmVcbiIgZCR0YWcKCSAgICB9IGVsc2VpZiB7JHggPT0gIiAifSB7CgkJJGN0ZXh0IGluc2VydCBlbmQgIiRsaW5lXG4iCgkgICAgfSBlbHNlIHsKCQkjICJcIE5vIG5ld2xpbmUgYXQgZW5kIG9mIGZpbGUiLAoJCSMgb3Igc29tZXRoaW5nIGVsc2Ugd2UgZG9uJ3QgcmVjb2duaXplCgkJJGN0ZXh0IGluc2VydCBlbmQgIiRsaW5lXG4iIGh1bmtzZXAKCSAgICB9Cgl9CiAgICB9CiAgICAkY3RleHQgY29uZiAtc3RhdGUgZGlzYWJsZWQKICAgIGlmIHtbZW9mICRiZGZdfSB7CgljbG9zZSAkYmRmCglyZXR1cm4gMAogICAgfQogICAgcmV0dXJuIFtleHByIHskbnIgPj0gMTAwMD8gMjogMX1dCn0KCnByb2MgY2hhbmdlZGlmZmRpc3Age30gewogICAgZ2xvYmFsIGN0ZXh0IGRpZmZlbGlkZQoKICAgICRjdGV4dCB0YWcgY29uZiBkMCAtZWxpZGUgW2xpbmRleCAkZGlmZmVsaWRlIDBdCiAgICAkY3RleHQgdGFnIGNvbmYgZDEgLWVsaWRlIFtsaW5kZXggJGRpZmZlbGlkZSAxXQp9Cgpwcm9jIHByZXZmaWxlIHt9IHsKICAgIGdsb2JhbCBkaWZmZmlsZXN0YXJ0IGN0ZXh0CiAgICBzZXQgcHJldiBbbGluZGV4ICRkaWZmZmlsZXN0YXJ0IDBdCiAgICBzZXQgaGVyZSBbJGN0ZXh0IGluZGV4IEAwLDBdCiAgICBmb3JlYWNoIGxvYyAkZGlmZmZpbGVzdGFydCB7CglpZiB7WyRjdGV4dCBjb21wYXJlICRsb2MgPj0gJGhlcmVdfSB7CgkgICAgJGN0ZXh0IHl2aWV3ICRwcmV2CgkgICAgcmV0dXJuCgl9CglzZXQgcHJldiAkbG9jCiAgICB9CiAgICAkY3RleHQgeXZpZXcgJHByZXYKfQoKcHJvYyBuZXh0ZmlsZSB7fSB7CiAgICBnbG9iYWwgZGlmZmZpbGVzdGFydCBjdGV4dAogICAgc2V0IGhlcmUgWyRjdGV4dCBpbmRleCBAMCwwXQogICAgZm9yZWFjaCBsb2MgJGRpZmZmaWxlc3RhcnQgewoJaWYge1skY3RleHQgY29tcGFyZSAkbG9jID4gJGhlcmVdfSB7CgkgICAgJGN0ZXh0IHl2aWV3ICRsb2MKCSAgICByZXR1cm4KCX0KICAgIH0KfQoKcHJvYyBjbGVhcl9jdGV4dCB7e2ZpcnN0IDEuMH19IHsKICAgIGdsb2JhbCBjdGV4dCBzbWFya3RvcCBzbWFya2JvdAoKICAgIHNldCBsIFtsaW5kZXggW3NwbGl0ICRmaXJzdCAuXSAwXQogICAgaWYgeyFbaW5mbyBleGlzdHMgc21hcmt0b3BdIHx8IFskY3RleHQgY29tcGFyZSAkZmlyc3QgPCAkc21hcmt0b3AuMF19IHsKCXNldCBzbWFya3RvcCAkbAogICAgfQogICAgaWYgeyFbaW5mbyBleGlzdHMgc21hcmtib3RdIHx8IFskY3RleHQgY29tcGFyZSAkZmlyc3QgPCAkc21hcmtib3QuMF19IHsKCXNldCBzbWFya2JvdCAkbAogICAgfQogICAgJGN0ZXh0IGRlbGV0ZSAkZmlyc3QgZW5kCn0KCnByb2MgaW5jcnNlYXJjaCB7bmFtZSBpeCBvcH0gewogICAgZ2xvYmFsIGN0ZXh0IHNlYXJjaHN0cmluZyBzZWFyY2hkaXJuCgogICAgJGN0ZXh0IHRhZyByZW1vdmUgZm91bmQgMS4wIGVuZAogICAgaWYge1tjYXRjaCB7JGN0ZXh0IGluZGV4IGFuY2hvcn1dfSB7CgkjIG5vIGFuY2hvciBzZXQsIHVzZSBzdGFydCBvZiBzZWxlY3Rpb24sIG9yIG9mIHZpc2libGUgYXJlYQoJc2V0IHNlbCBbJGN0ZXh0IHRhZyByYW5nZXMgc2VsXQoJaWYgeyRzZWwgbmUge319IHsKCSAgICAkY3RleHQgbWFyayBzZXQgYW5jaG9yIFtsaW5kZXggJHNlbCAwXQoJfSBlbHNlaWYgeyRzZWFyY2hkaXJuIGVxICItZm9yd2FyZHMifSB7CgkgICAgJGN0ZXh0IG1hcmsgc2V0IGFuY2hvciBAMCwwCgl9IGVsc2UgewoJICAgICRjdGV4dCBtYXJrIHNldCBhbmNob3IgQDAsW3dpbmZvIGhlaWdodCAkY3RleHRdCgl9CiAgICB9CiAgICBpZiB7JHNlYXJjaHN0cmluZyBuZSB7fX0gewoJc2V0IGhlcmUgWyRjdGV4dCBzZWFyY2ggJHNlYXJjaGRpcm4gLS0gJHNlYXJjaHN0cmluZyBhbmNob3JdCglpZiB7JGhlcmUgbmUge319IHsKCSAgICAkY3RleHQgc2VlICRoZXJlCgl9CglzZWFyY2htYXJrdmlzaWJsZSAxCiAgICB9Cn0KCnByb2MgZG9zZWFyY2gge30gewogICAgZ2xvYmFsIHNzdHJpbmcgY3RleHQgc2VhcmNoc3RyaW5nIHNlYXJjaGRpcm4KCiAgICBmb2N1cyAkc3N0cmluZwogICAgJHNzdHJpbmcgaWN1cnNvciBlbmQKICAgIHNldCBzZWFyY2hkaXJuIC1mb3J3YXJkcwogICAgaWYgeyRzZWFyY2hzdHJpbmcgbmUge319IHsKCXNldCBzZWwgWyRjdGV4dCB0YWcgcmFuZ2VzIHNlbF0KCWlmIHskc2VsIG5lIHt9fSB7CgkgICAgc2V0IHN0YXJ0ICJbbGluZGV4ICRzZWwgMF0gKyAxYyIKCX0gZWxzZWlmIHtbY2F0Y2gge3NldCBzdGFydCBbJGN0ZXh0IGluZGV4IGFuY2hvcl19XX0gewoJICAgIHNldCBzdGFydCAiQDAsMCIKCX0KCXNldCBtYXRjaCBbJGN0ZXh0IHNlYXJjaCAtY291bnQgbWxlbiAtLSAkc2VhcmNoc3RyaW5nICRzdGFydF0KCSRjdGV4dCB0YWcgcmVtb3ZlIHNlbCAxLjAgZW5kCglpZiB7JG1hdGNoIGVxIHt9fSB7CgkgICAgYmVsbAoJICAgIHJldHVybgoJfQoJJGN0ZXh0IHNlZSAkbWF0Y2gKCXNldCBtZW5kICIkbWF0Y2ggKyAkbWxlbiBjIgoJJGN0ZXh0IHRhZyBhZGQgc2VsICRtYXRjaCAkbWVuZAoJJGN0ZXh0IG1hcmsgdW5zZXQgYW5jaG9yCiAgICB9Cn0KCnByb2MgZG9zZWFyY2hiYWNrIHt9IHsKICAgIGdsb2JhbCBzc3RyaW5nIGN0ZXh0IHNlYXJjaHN0cmluZyBzZWFyY2hkaXJuCgogICAgZm9jdXMgJHNzdHJpbmcKICAgICRzc3RyaW5nIGljdXJzb3IgZW5kCiAgICBzZXQgc2VhcmNoZGlybiAtYmFja3dhcmRzCiAgICBpZiB7JHNlYXJjaHN0cmluZyBuZSB7fX0gewoJc2V0IHNlbCBbJGN0ZXh0IHRhZyByYW5nZXMgc2VsXQoJaWYgeyRzZWwgbmUge319IHsKCSAgICBzZXQgc3RhcnQgW2xpbmRleCAkc2VsIDBdCgl9IGVsc2VpZiB7W2NhdGNoIHtzZXQgc3RhcnQgWyRjdGV4dCBpbmRleCBhbmNob3JdfV19IHsKCSAgICBzZXQgc3RhcnQgQDAsW3dpbmZvIGhlaWdodCAkY3RleHRdCgl9CglzZXQgbWF0Y2ggWyRjdGV4dCBzZWFyY2ggLWJhY2t3YXJkcyAtY291bnQgbWwgLS0gJHNlYXJjaHN0cmluZyAkc3RhcnRdCgkkY3RleHQgdGFnIHJlbW92ZSBzZWwgMS4wIGVuZAoJaWYgeyRtYXRjaCBlcSB7fX0gewoJICAgIGJlbGwKCSAgICByZXR1cm4KCX0KCSRjdGV4dCBzZWUgJG1hdGNoCglzZXQgbWVuZCAiJG1hdGNoICsgJG1sIGMiCgkkY3RleHQgdGFnIGFkZCBzZWwgJG1hdGNoICRtZW5kCgkkY3RleHQgbWFyayB1bnNldCBhbmNob3IKICAgIH0KfQoKcHJvYyBzZWFyY2htYXJrIHtmaXJzdCBsYXN0fSB7CiAgICBnbG9iYWwgY3RleHQgc2VhcmNoc3RyaW5nCgogICAgc2V0IG1lbmQgJGZpcnN0LjAKICAgIHdoaWxlIHsxfSB7CglzZXQgbWF0Y2ggWyRjdGV4dCBzZWFyY2ggLWNvdW50IG1sZW4gLS0gJHNlYXJjaHN0cmluZyAkbWVuZCAkbGFzdC5lbmRdCglpZiB7JG1hdGNoIGVxIHt9fSBicmVhawoJc2V0IG1lbmQgIiRtYXRjaCArICRtbGVuIGMiCgkkY3RleHQgdGFnIGFkZCBmb3VuZCAkbWF0Y2ggJG1lbmQKICAgIH0KfQoKcHJvYyBzZWFyY2htYXJrdmlzaWJsZSB7ZG9hbGx9IHsKICAgIGdsb2JhbCBjdGV4dCBzbWFya3RvcCBzbWFya2JvdAoKICAgIHNldCB0b3BsaW5lIFtsaW5kZXggW3NwbGl0IFskY3RleHQgaW5kZXggQDAsMF0gLl0gMF0KICAgIHNldCBib3RsaW5lIFtsaW5kZXggW3NwbGl0IFskY3RleHQgaW5kZXggQDAsW3dpbmZvIGhlaWdodCAkY3RleHRdXSAuXSAwXQogICAgaWYgeyRkb2FsbCB8fCAkYm90bGluZSA8ICRzbWFya3RvcCB8fCAkdG9wbGluZSA+ICRzbWFya2JvdH0gewoJIyBubyBvdmVybGFwIHdpdGggcHJldmlvdXMKCXNlYXJjaG1hcmsgJHRvcGxpbmUgJGJvdGxpbmUKCXNldCBzbWFya3RvcCAkdG9wbGluZQoJc2V0IHNtYXJrYm90ICRib3RsaW5lCiAgICB9IGVsc2UgewoJaWYgeyR0b3BsaW5lIDwgJHNtYXJrdG9wfSB7CgkgICAgc2VhcmNobWFyayAkdG9wbGluZSBbZXhwciB7JHNtYXJrdG9wLTF9XQoJICAgIHNldCBzbWFya3RvcCAkdG9wbGluZQoJfQoJaWYgeyRib3RsaW5lID4gJHNtYXJrYm90fSB7CgkgICAgc2VhcmNobWFyayBbZXhwciB7JHNtYXJrYm90KzF9XSAkYm90bGluZQoJICAgIHNldCBzbWFya2JvdCAkYm90bGluZQoJfQogICAgfQp9Cgpwcm9jIHNjcm9sbHRleHQge2YwIGYxfSB7CiAgICBnbG9iYWwgc2VhcmNoc3RyaW5nCgogICAgLmJsZWZ0LnNiIHNldCAkZjAgJGYxCiAgICBpZiB7JHNlYXJjaHN0cmluZyBuZSB7fX0gewoJc2VhcmNobWFya3Zpc2libGUgMAogICAgfQp9Cgpwcm9jIHNldGNvb3JkcyB7fSB7CiAgICBnbG9iYWwgbGluZXNwYyBjaGFyc3BjIGNhbnZ4MCBjYW52eTAgbWFpbmZvbnQKICAgIGdsb2JhbCB4c3BjMSB4c3BjMiBsdGhpY2tuZXNzCgogICAgc2V0IGxpbmVzcGMgW2ZvbnQgbWV0cmljcyAkbWFpbmZvbnQgLWxpbmVzcGFjZV0KICAgIHNldCBjaGFyc3BjIFtmb250IG1lYXN1cmUgJG1haW5mb250ICJtIl0KICAgIHNldCBjYW52eTAgW2V4cHIge2ludCgzICsgMC41ICogJGxpbmVzcGMpfV0KICAgIHNldCBjYW52eDAgW2V4cHIge2ludCgzICsgMC41ICogJGxpbmVzcGMpfV0KICAgIHNldCBsdGhpY2tuZXNzIFtleHByIHtpbnQoJGxpbmVzcGMgLyA5KSArIDF9XQogICAgc2V0IHhzcGMxKDApICRsaW5lc3BjCiAgICBzZXQgeHNwYzIgJGxpbmVzcGMKfQoKcHJvYyByZWRpc3BsYXkge30gewogICAgZ2xvYmFsIGNhbnYKICAgIGdsb2JhbCBzZWxlY3RlZGxpbmUKCiAgICBzZXQgeW1heCBbbGluZGV4IFskY2FudiBjZ2V0IC1zY3JvbGxyZWdpb25dIDNdCiAgICBpZiB7JHltYXggZXEge30gfHwgJHltYXggPT0gMH0gcmV0dXJuCiAgICBzZXQgc3BhbiBbJGNhbnYgeXZpZXddCiAgICBjbGVhcl9kaXNwbGF5CiAgICBzZXRjYW52c2Nyb2xsCiAgICBhbGxjYW52cyB5dmlldyBtb3ZldG8gW2xpbmRleCAkc3BhbiAwXQogICAgZHJhd3Zpc2libGUKICAgIGlmIHtbaW5mbyBleGlzdHMgc2VsZWN0ZWRsaW5lXX0gewoJc2VsZWN0bGluZSAkc2VsZWN0ZWRsaW5lIDAKCWFsbGNhbnZzIHl2aWV3IG1vdmV0byBbbGluZGV4ICRzcGFuIDBdCiAgICB9Cn0KCnByb2MgaW5jcmZvbnQge2luY30gewogICAgZ2xvYmFsIG1haW5mb250IHRleHRmb250IGN0ZXh0IGNhbnYgcGhhc2UgY2ZsaXN0CiAgICBnbG9iYWwgY2hhcnNwYyB0YWJzdG9wCiAgICBnbG9iYWwgc3RvcHBlZCBlbnRyaWVzCiAgICB1bm1hcmttYXRjaGVzCiAgICBzZXQgbWFpbmZvbnQgW2xyZXBsYWNlICRtYWluZm9udCAxIDEgW2V4cHIge1tsaW5kZXggJG1haW5mb250IDFdICsgJGluY31dXQogICAgc2V0IHRleHRmb250IFtscmVwbGFjZSAkdGV4dGZvbnQgMSAxIFtleHByIHtbbGluZGV4ICR0ZXh0Zm9udCAxXSArICRpbmN9XV0KICAgIHNldGNvb3JkcwogICAgJGN0ZXh0IGNvbmYgLWZvbnQgJHRleHRmb250IC10YWJzICJbZXhwciB7JHRhYnN0b3AgKiAkY2hhcnNwY31dIgogICAgJGNmbGlzdCBjb25mIC1mb250ICR0ZXh0Zm9udAogICAgJGN0ZXh0IHRhZyBjb25mIGZpbGVzZXAgLWZvbnQgW2NvbmNhdCAkdGV4dGZvbnQgYm9sZF0KICAgIGZvcmVhY2ggZSAkZW50cmllcyB7CgkkZSBjb25mIC1mb250ICRtYWluZm9udAogICAgfQogICAgaWYgeyRwaGFzZSBlcSAiZ2V0Y29tbWl0cyJ9IHsKCSRjYW52IGl0ZW1jb25mIHRleHRpdGVtcyAtZm9udCAkbWFpbmZvbnQKICAgIH0KICAgIHJlZGlzcGxheQp9Cgpwcm9jIGNsZWFyc2hhMSB7fSB7CiAgICBnbG9iYWwgc2hhMWVudHJ5IHNoYTFzdHJpbmcKICAgIGlmIHtbc3RyaW5nIGxlbmd0aCAkc2hhMXN0cmluZ10gPT0gNDB9IHsKCSRzaGExZW50cnkgZGVsZXRlIDAgZW5kCiAgICB9Cn0KCnByb2Mgc2hhMWNoYW5nZSB7bjEgbjIgb3B9IHsKICAgIGdsb2JhbCBzaGExc3RyaW5nIGN1cnJlbnRpZCBzaGExYnV0CiAgICBpZiB7JHNoYTFzdHJpbmcgPT0ge30KCXx8IChbaW5mbyBleGlzdHMgY3VycmVudGlkXSAmJiAkc2hhMXN0cmluZyA9PSAkY3VycmVudGlkKX0gewoJc2V0IHN0YXRlIGRpc2FibGVkCiAgICB9IGVsc2UgewoJc2V0IHN0YXRlIG5vcm1hbAogICAgfQogICAgaWYge1skc2hhMWJ1dCBjZ2V0IC1zdGF0ZV0gPT0gJHN0YXRlfSByZXR1cm4KICAgIGlmIHskc3RhdGUgPT0gIm5vcm1hbCJ9IHsKCSRzaGExYnV0IGNvbmYgLXN0YXRlIG5vcm1hbCAtcmVsaWVmIHJhaXNlZCAtdGV4dCAiR290bzogIgogICAgfSBlbHNlIHsKCSRzaGExYnV0IGNvbmYgLXN0YXRlIGRpc2FibGVkIC1yZWxpZWYgZmxhdCAtdGV4dCAiU0hBMSBJRDogIgogICAgfQp9Cgpwcm9jIGdvdG9jb21taXQge30gewogICAgZ2xvYmFsIHNoYTFzdHJpbmcgY3VycmVudGlkIGNvbW1pdHJvdyB0YWdpZHMgaGVhZGlkcwogICAgZ2xvYmFsIGRpc3BsYXlvcmRlciBudW1jb21taXRzIGN1cnZpZXcKCiAgICBpZiB7JHNoYTFzdHJpbmcgPT0ge30KCXx8IChbaW5mbyBleGlzdHMgY3VycmVudGlkXSAmJiAkc2hhMXN0cmluZyA9PSAkY3VycmVudGlkKX0gcmV0dXJuCiAgICBpZiB7W2luZm8gZXhpc3RzIHRhZ2lkcygkc2hhMXN0cmluZyldfSB7CglzZXQgaWQgJHRhZ2lkcygkc2hhMXN0cmluZykKICAgIH0gZWxzZWlmIHtbaW5mbyBleGlzdHMgaGVhZGlkcygkc2hhMXN0cmluZyldfSB7CglzZXQgaWQgJGhlYWRpZHMoJHNoYTFzdHJpbmcpCiAgICB9IGVsc2UgewoJc2V0IGlkIFtzdHJpbmcgdG9sb3dlciAkc2hhMXN0cmluZ10KCWlmIHtbcmVnZXhwIHteWzAtOWEtZl17NCwzOX0kfSAkaWRdfSB7CgkgICAgc2V0IG1hdGNoZXMge30KCSAgICBmb3JlYWNoIGkgJGRpc3BsYXlvcmRlciB7CgkJaWYge1tzdHJpbmcgbWF0Y2ggJGlkKiAkaV19IHsKCQkgICAgbGFwcGVuZCBtYXRjaGVzICRpCgkJfQoJICAgIH0KCSAgICBpZiB7JG1hdGNoZXMgbmUge319IHsKCQlpZiB7W2xsZW5ndGggJG1hdGNoZXNdID4gMX0gewoJCSAgICBlcnJvcl9wb3B1cCAiU2hvcnQgU0hBMSBpZCAkaWQgaXMgYW1iaWd1b3VzIgoJCSAgICByZXR1cm4KCQl9CgkJc2V0IGlkIFtsaW5kZXggJG1hdGNoZXMgMF0KCSAgICB9Cgl9CiAgICB9CiAgICBpZiB7W2luZm8gZXhpc3RzIGNvbW1pdHJvdygkY3VydmlldywkaWQpXX0gewoJc2VsZWN0bGluZSAkY29tbWl0cm93KCRjdXJ2aWV3LCRpZCkgMQoJcmV0dXJuCiAgICB9CiAgICBpZiB7W3JlZ2V4cCB7XlswLTlhLWZBLUZdezQsfSR9ICRzaGExc3RyaW5nXX0gewoJc2V0IHR5cGUgIlNIQTEgaWQiCiAgICB9IGVsc2UgewoJc2V0IHR5cGUgIlRhZy9IZWFkIgogICAgfQogICAgZXJyb3JfcG9wdXAgIiR0eXBlICRzaGExc3RyaW5nIGlzIG5vdCBrbm93biIKfQoKcHJvYyBsaW5lZW50ZXIge3ggeSBpZH0gewogICAgZ2xvYmFsIGhvdmVyeCBob3ZlcnkgaG92ZXJpZCBob3ZlcnRpbWVyCiAgICBnbG9iYWwgY29tbWl0aW5mbyBjYW52CgogICAgaWYgeyFbaW5mbyBleGlzdHMgY29tbWl0aW5mbygkaWQpXSAmJiAhW2dldGNvbW1pdCAkaWRdfSByZXR1cm4KICAgIHNldCBob3ZlcnggJHgKICAgIHNldCBob3ZlcnkgJHkKICAgIHNldCBob3ZlcmlkICRpZAogICAgaWYge1tpbmZvIGV4aXN0cyBob3ZlcnRpbWVyXX0gewoJYWZ0ZXIgY2FuY2VsICRob3ZlcnRpbWVyCiAgICB9CiAgICBzZXQgaG92ZXJ0aW1lciBbYWZ0ZXIgNTAwIGxpbmVob3Zlcl0KICAgICRjYW52IGRlbGV0ZSBob3Zlcgp9Cgpwcm9jIGxpbmVtb3Rpb24ge3ggeSBpZH0gewogICAgZ2xvYmFsIGhvdmVyeCBob3ZlcnkgaG92ZXJpZCBob3ZlcnRpbWVyCgogICAgaWYge1tpbmZvIGV4aXN0cyBob3ZlcmlkXSAmJiAkaWQgPT0gJGhvdmVyaWR9IHsKCXNldCBob3ZlcnggJHgKCXNldCBob3ZlcnkgJHkKCWlmIHtbaW5mbyBleGlzdHMgaG92ZXJ0aW1lcl19IHsKCSAgICBhZnRlciBjYW5jZWwgJGhvdmVydGltZXIKCX0KCXNldCBob3ZlcnRpbWVyIFthZnRlciA1MDAgbGluZWhvdmVyXQogICAgfQp9Cgpwcm9jIGxpbmVsZWF2ZSB7aWR9IHsKICAgIGdsb2JhbCBob3ZlcmlkIGhvdmVydGltZXIgY2FudgoKICAgIGlmIHtbaW5mbyBleGlzdHMgaG92ZXJpZF0gJiYgJGlkID09ICRob3ZlcmlkfSB7CgkkY2FudiBkZWxldGUgaG92ZXIKCWlmIHtbaW5mbyBleGlzdHMgaG92ZXJ0aW1lcl19IHsKCSAgICBhZnRlciBjYW5jZWwgJGhvdmVydGltZXIKCSAgICB1bnNldCBob3ZlcnRpbWVyCgl9Cgl1bnNldCBob3ZlcmlkCiAgICB9Cn0KCnByb2MgbGluZWhvdmVyIHt9IHsKICAgIGdsb2JhbCBob3ZlcnggaG92ZXJ5IGhvdmVyaWQgaG92ZXJ0aW1lcgogICAgZ2xvYmFsIGNhbnYgbGluZXNwYyBsdGhpY2tuZXNzCiAgICBnbG9iYWwgY29tbWl0aW5mbyBtYWluZm9udAoKICAgIHNldCB0ZXh0IFtsaW5kZXggJGNvbW1pdGluZm8oJGhvdmVyaWQpIDBdCiAgICBzZXQgeW1heCBbbGluZGV4IFskY2FudiBjZ2V0IC1zY3JvbGxyZWdpb25dIDNdCiAgICBpZiB7JHltYXggPT0ge319IHJldHVybgogICAgc2V0IHlmcmFjIFtsaW5kZXggWyRjYW52IHl2aWV3XSAwXQogICAgc2V0IHggW2V4cHIgeyRob3ZlcnggKyAyICogJGxpbmVzcGN9XQogICAgc2V0IHkgW2V4cHIgeyRob3ZlcnkgKyAkeWZyYWMgKiAkeW1heCAtICRsaW5lc3BjIC8gMn1dCiAgICBzZXQgeDAgW2V4cHIgeyR4IC0gMiAqICRsdGhpY2tuZXNzfV0KICAgIHNldCB5MCBbZXhwciB7JHkgLSAyICogJGx0aGlja25lc3N9XQogICAgc2V0IHgxIFtleHByIHskeCArIFtmb250IG1lYXN1cmUgJG1haW5mb250ICR0ZXh0XSArIDIgKiAkbHRoaWNrbmVzc31dCiAgICBzZXQgeTEgW2V4cHIgeyR5ICsgJGxpbmVzcGMgKyAyICogJGx0aGlja25lc3N9XQogICAgc2V0IHQgWyRjYW52IGNyZWF0ZSByZWN0YW5nbGUgJHgwICR5MCAkeDEgJHkxIFwKCSAgICAgICAtZmlsbCBcI2ZmZmY4MCAtb3V0bGluZSBibGFjayAtd2lkdGggMSAtdGFncyBob3Zlcl0KICAgICRjYW52IHJhaXNlICR0CiAgICBzZXQgdCBbJGNhbnYgY3JlYXRlIHRleHQgJHggJHkgLWFuY2hvciBudyAtdGV4dCAkdGV4dCAtdGFncyBob3ZlciBcCgkgICAgICAgLWZvbnQgJG1haW5mb250XQogICAgJGNhbnYgcmFpc2UgJHQKfQoKcHJvYyBjbGlja2lzb25hcnJvdyB7aWQgeX0gewogICAgZ2xvYmFsIGx0aGlja25lc3MKCiAgICBzZXQgcmFuZ2VzIFtyb3dyYW5nZXMgJGlkXQogICAgc2V0IHRocmVzaCBbZXhwciB7MiAqICRsdGhpY2tuZXNzICsgNn1dCiAgICBzZXQgbiBbZXhwciB7W2xsZW5ndGggJHJhbmdlc10gLSAxfV0KICAgIGZvciB7c2V0IGkgMX0geyRpIDwgJG59IHtpbmNyIGl9IHsKCXNldCByb3cgW2xpbmRleCAkcmFuZ2VzICRpXQoJaWYge2FicyhbeWMgJHJvd10gLSAkeSkgPCAkdGhyZXNofSB7CgkgICAgcmV0dXJuICRpCgl9CiAgICB9CiAgICByZXR1cm4ge30KfQoKcHJvYyBhcnJvd2p1bXAge2lkIG4geX0gewogICAgZ2xvYmFsIGNhbnYKCiAgICAjIDEgPC0+IDIsIDMgPC0+IDQsIGV0Yy4uLgogICAgc2V0IG4gW2V4cHIgeygoJG4gLSAxKSBeIDEpICsgMX1dCiAgICBzZXQgcm93IFtsaW5kZXggW3Jvd3JhbmdlcyAkaWRdICRuXQogICAgc2V0IHl0IFt5YyAkcm93XQogICAgc2V0IHltYXggW2xpbmRleCBbJGNhbnYgY2dldCAtc2Nyb2xscmVnaW9uXSAzXQogICAgaWYgeyR5bWF4IGVxIHt9IHx8ICR5bWF4IDw9IDB9IHJldHVybgogICAgc2V0IHZpZXcgWyRjYW52IHl2aWV3XQogICAgc2V0IHlzcGFuIFtleHByIHtbbGluZGV4ICR2aWV3IDFdIC0gW2xpbmRleCAkdmlldyAwXX1dCiAgICBzZXQgeWZyYWMgW2V4cHIgeyR5dCAvICR5bWF4IC0gJHlzcGFuIC8gMn1dCiAgICBpZiB7JHlmcmFjIDwgMH0gewoJc2V0IHlmcmFjIDAKICAgIH0KICAgIGFsbGNhbnZzIHl2aWV3IG1vdmV0byAkeWZyYWMKfQoKcHJvYyBsaW5lY2xpY2sge3ggeSBpZCBpc25ld30gewogICAgZ2xvYmFsIGN0ZXh0IGNvbW1pdGluZm8gY2hpbGRyZW4gY2FudiB0aGlja2VybGluZSBjdXJ2aWV3CgogICAgaWYgeyFbaW5mbyBleGlzdHMgY29tbWl0aW5mbygkaWQpXSAmJiAhW2dldGNvbW1pdCAkaWRdfSByZXR1cm4KICAgIHVubWFya21hdGNoZXMKICAgIHVuc2VsZWN0bGluZQogICAgbm9ybWFsbGluZQogICAgJGNhbnYgZGVsZXRlIGhvdmVyCiAgICAjIGRyYXcgdGhpcyBsaW5lIHRoaWNrZXIgdGhhbiBub3JtYWwKICAgIHNldCB0aGlja2VybGluZSAkaWQKICAgIGRyYXdsaW5lcyAkaWQKICAgIGlmIHskaXNuZXd9IHsKCXNldCB5bWF4IFtsaW5kZXggWyRjYW52IGNnZXQgLXNjcm9sbHJlZ2lvbl0gM10KCWlmIHskeW1heCBlcSB7fX0gcmV0dXJuCglzZXQgeWZyYWMgW2xpbmRleCBbJGNhbnYgeXZpZXddIDBdCglzZXQgeSBbZXhwciB7JHkgKyAkeWZyYWMgKiAkeW1heH1dCiAgICB9CiAgICBzZXQgZGlybiBbY2xpY2tpc29uYXJyb3cgJGlkICR5XQogICAgaWYgeyRkaXJuIG5lIHt9fSB7CglhcnJvd2p1bXAgJGlkICRkaXJuICR5CglyZXR1cm4KICAgIH0KCiAgICBpZiB7JGlzbmV3fSB7CglhZGR0b2hpc3RvcnkgW2xpc3QgbGluZWNsaWNrICR4ICR5ICRpZCAwXQogICAgfQogICAgIyBmaWxsIHRoZSBkZXRhaWxzIHBhbmUgd2l0aCBpbmZvIGFib3V0IHRoaXMgbGluZQogICAgJGN0ZXh0IGNvbmYgLXN0YXRlIG5vcm1hbAogICAgY2xlYXJfY3RleHQKICAgICRjdGV4dCB0YWcgY29uZiBsaW5rIC1mb3JlZ3JvdW5kIGJsdWUgLXVuZGVybGluZSAxCiAgICAkY3RleHQgdGFnIGJpbmQgbGluayA8RW50ZXI+IHsgJVcgY29uZmlndXJlIC1jdXJzb3IgaGFuZDIgfQogICAgJGN0ZXh0IHRhZyBiaW5kIGxpbmsgPExlYXZlPiB7ICVXIGNvbmZpZ3VyZSAtY3Vyc29yICRjdXJ0ZXh0Y3Vyc29yIH0KICAgICRjdGV4dCBpbnNlcnQgZW5kICJQYXJlbnQ6XHQiCiAgICAkY3RleHQgaW5zZXJ0IGVuZCAkaWQgW2xpc3QgbGluayBsaW5rMF0KICAgICRjdGV4dCB0YWcgYmluZCBsaW5rMCA8MT4gW2xpc3Qgc2VsYnlpZCAkaWRdCiAgICBzZXQgaW5mbyAkY29tbWl0aW5mbygkaWQpCiAgICAkY3RleHQgaW5zZXJ0IGVuZCAiXG5cdFtsaW5kZXggJGluZm8gMF1cbiIKICAgICRjdGV4dCBpbnNlcnQgZW5kICJcdEF1dGhvcjpcdFtsaW5kZXggJGluZm8gMV1cbiIKICAgIHNldCBkYXRlIFtmb3JtYXRkYXRlIFtsaW5kZXggJGluZm8gMl1dCiAgICAkY3RleHQgaW5zZXJ0IGVuZCAiXHREYXRlOlx0JGRhdGVcbiIKICAgIHNldCBraWRzICRjaGlsZHJlbigkY3VydmlldywkaWQpCiAgICBpZiB7JGtpZHMgbmUge319IHsKCSRjdGV4dCBpbnNlcnQgZW5kICJcbkNoaWxkcmVuOiIKCXNldCBpIDAKCWZvcmVhY2ggY2hpbGQgJGtpZHMgewoJICAgIGluY3IgaQoJICAgIGlmIHshW2luZm8gZXhpc3RzIGNvbW1pdGluZm8oJGNoaWxkKV0gJiYgIVtnZXRjb21taXQgJGNoaWxkXX0gY29udGludWUKCSAgICBzZXQgaW5mbyAkY29tbWl0aW5mbygkY2hpbGQpCgkgICAgJGN0ZXh0IGluc2VydCBlbmQgIlxuXHQiCgkgICAgJGN0ZXh0IGluc2VydCBlbmQgJGNoaWxkIFtsaXN0IGxpbmsgbGluayRpXQoJICAgICRjdGV4dCB0YWcgYmluZCBsaW5rJGkgPDE+IFtsaXN0IHNlbGJ5aWQgJGNoaWxkXQoJICAgICRjdGV4dCBpbnNlcnQgZW5kICJcblx0W2xpbmRleCAkaW5mbyAwXSIKCSAgICAkY3RleHQgaW5zZXJ0IGVuZCAiXG5cdEF1dGhvcjpcdFtsaW5kZXggJGluZm8gMV0iCgkgICAgc2V0IGRhdGUgW2Zvcm1hdGRhdGUgW2xpbmRleCAkaW5mbyAyXV0KCSAgICAkY3RleHQgaW5zZXJ0IGVuZCAiXG5cdERhdGU6XHQkZGF0ZVxuIgoJfQogICAgfQogICAgJGN0ZXh0IGNvbmYgLXN0YXRlIGRpc2FibGVkCiAgICBpbml0X2ZsaXN0IHt9Cn0KCnByb2Mgbm9ybWFsbGluZSB7fSB7CiAgICBnbG9iYWwgdGhpY2tlcmxpbmUKICAgIGlmIHtbaW5mbyBleGlzdHMgdGhpY2tlcmxpbmVdfSB7CglzZXQgaWQgJHRoaWNrZXJsaW5lCgl1bnNldCB0aGlja2VybGluZQoJZHJhd2xpbmVzICRpZAogICAgfQp9Cgpwcm9jIHNlbGJ5aWQge2lkfSB7CiAgICBnbG9iYWwgY29tbWl0cm93IGN1cnZpZXcKICAgIGlmIHtbaW5mbyBleGlzdHMgY29tbWl0cm93KCRjdXJ2aWV3LCRpZCldfSB7CglzZWxlY3RsaW5lICRjb21taXRyb3coJGN1cnZpZXcsJGlkKSAxCiAgICB9Cn0KCnByb2MgbXN0aW1lIHt9IHsKICAgIGdsb2JhbCBzdGFydG1zdGltZQogICAgaWYgeyFbaW5mbyBleGlzdHMgc3RhcnRtc3RpbWVdfSB7CglzZXQgc3RhcnRtc3RpbWUgW2Nsb2NrIGNsaWNrcyAtbWlsbGlzZWNvbmRzXQogICAgfQogICAgcmV0dXJuIFtmb3JtYXQgIiUuM2YiIFtleHByIHsoW2Nsb2NrIGNsaWNrIC1taWxsaXNlY29uZHNdIC0gJHN0YXJ0bXN0aW1lKSAvIDEwMDAuMH1dXQp9Cgpwcm9jIHJvd21lbnUge3ggeSBpZH0gewogICAgZ2xvYmFsIHJvd2N0eG1lbnUgY29tbWl0cm93IHNlbGVjdGVkbGluZSByb3dtZW51aWQgY3VydmlldwogICAgZ2xvYmFsIG51bGxpZCBudWxsaWQyIGZha2Vyb3dtZW51IG1haW5oZWFkCgogICAgc2V0IHJvd21lbnVpZCAkaWQKICAgIGlmIHshW2luZm8gZXhpc3RzIHNlbGVjdGVkbGluZV0KCXx8ICRjb21taXRyb3coJGN1cnZpZXcsJGlkKSBlcSAkc2VsZWN0ZWRsaW5lfSB7CglzZXQgc3RhdGUgZGlzYWJsZWQKICAgIH0gZWxzZSB7CglzZXQgc3RhdGUgbm9ybWFsCiAgICB9CiAgICBpZiB7JGlkIG5lICRudWxsaWQgJiYgJGlkIG5lICRudWxsaWQyfSB7CglzZXQgbWVudSAkcm93Y3R4bWVudQoJJG1lbnUgZW50cnljb25maWd1cmUgNyAtbGFiZWwgIlJlc2V0ICRtYWluaGVhZCBicmFuY2ggdG8gaGVyZSIKICAgIH0gZWxzZSB7CglzZXQgbWVudSAkZmFrZXJvd21lbnUKICAgIH0KICAgICRtZW51IGVudHJ5Y29uZmlndXJlICJEaWZmIHRoaXMqIiAtc3RhdGUgJHN0YXRlCiAgICAkbWVudSBlbnRyeWNvbmZpZ3VyZSAiRGlmZiBzZWxlY3RlZCoiIC1zdGF0ZSAkc3RhdGUKICAgICRtZW51IGVudHJ5Y29uZmlndXJlICJNYWtlIHBhdGNoIiAtc3RhdGUgJHN0YXRlCiAgICB0a19wb3B1cCAkbWVudSAkeCAkeQp9Cgpwcm9jIGRpZmZ2c3NlbCB7ZGlybn0gewogICAgZ2xvYmFsIHJvd21lbnVpZCBzZWxlY3RlZGxpbmUgZGlzcGxheW9yZGVyCgogICAgaWYgeyFbaW5mbyBleGlzdHMgc2VsZWN0ZWRsaW5lXX0gcmV0dXJuCiAgICBpZiB7JGRpcm59IHsKCXNldCBvbGRpZCBbbGluZGV4ICRkaXNwbGF5b3JkZXIgJHNlbGVjdGVkbGluZV0KCXNldCBuZXdpZCAkcm93bWVudWlkCiAgICB9IGVsc2UgewoJc2V0IG9sZGlkICRyb3dtZW51aWQKCXNldCBuZXdpZCBbbGluZGV4ICRkaXNwbGF5b3JkZXIgJHNlbGVjdGVkbGluZV0KICAgIH0KICAgIGFkZHRvaGlzdG9yeSBbbGlzdCBkb3NlbGRpZmYgJG9sZGlkICRuZXdpZF0KICAgIGRvc2VsZGlmZiAkb2xkaWQgJG5ld2lkCn0KCnByb2MgZG9zZWxkaWZmIHtvbGRpZCBuZXdpZH0gewogICAgZ2xvYmFsIGN0ZXh0CiAgICBnbG9iYWwgY29tbWl0aW5mbwoKICAgICRjdGV4dCBjb25mIC1zdGF0ZSBub3JtYWwKICAgIGNsZWFyX2N0ZXh0CiAgICBpbml0X2ZsaXN0ICJUb3AiCiAgICAkY3RleHQgaW5zZXJ0IGVuZCAiRnJvbSAiCiAgICAkY3RleHQgdGFnIGNvbmYgbGluayAtZm9yZWdyb3VuZCBibHVlIC11bmRlcmxpbmUgMQogICAgJGN0ZXh0IHRhZyBiaW5kIGxpbmsgPEVudGVyPiB7ICVXIGNvbmZpZ3VyZSAtY3Vyc29yIGhhbmQyIH0KICAgICRjdGV4dCB0YWcgYmluZCBsaW5rIDxMZWF2ZT4geyAlVyBjb25maWd1cmUgLWN1cnNvciAkY3VydGV4dGN1cnNvciB9CiAgICAkY3RleHQgdGFnIGJpbmQgbGluazAgPDE+IFtsaXN0IHNlbGJ5aWQgJG9sZGlkXQogICAgJGN0ZXh0IGluc2VydCBlbmQgJG9sZGlkIFtsaXN0IGxpbmsgbGluazBdCiAgICAkY3RleHQgaW5zZXJ0IGVuZCAiXG4gICAgICIKICAgICRjdGV4dCBpbnNlcnQgZW5kIFtsaW5kZXggJGNvbW1pdGluZm8oJG9sZGlkKSAwXQogICAgJGN0ZXh0IGluc2VydCBlbmQgIlxuXG5UbyAgICIKICAgICRjdGV4dCB0YWcgYmluZCBsaW5rMSA8MT4gW2xpc3Qgc2VsYnlpZCAkbmV3aWRdCiAgICAkY3RleHQgaW5zZXJ0IGVuZCAkbmV3aWQgW2xpc3QgbGluayBsaW5rMV0KICAgICRjdGV4dCBpbnNlcnQgZW5kICJcbiAgICAgIgogICAgJGN0ZXh0IGluc2VydCBlbmQgW2xpbmRleCAkY29tbWl0aW5mbygkbmV3aWQpIDBdCiAgICAkY3RleHQgaW5zZXJ0IGVuZCAiXG4iCiAgICAkY3RleHQgY29uZiAtc3RhdGUgZGlzYWJsZWQKICAgICRjdGV4dCB0YWcgcmVtb3ZlIGZvdW5kIDEuMCBlbmQKICAgIHN0YXJ0ZGlmZiBbbGlzdCAkb2xkaWQgJG5ld2lkXQp9Cgpwcm9jIG1rcGF0Y2gge30gewogICAgZ2xvYmFsIHJvd21lbnVpZCBjdXJyZW50aWQgY29tbWl0aW5mbyBwYXRjaHRvcCBwYXRjaG51bQoKICAgIGlmIHshW2luZm8gZXhpc3RzIGN1cnJlbnRpZF19IHJldHVybgogICAgc2V0IG9sZGlkICRjdXJyZW50aWQKICAgIHNldCBvbGRoZWFkIFtsaW5kZXggJGNvbW1pdGluZm8oJG9sZGlkKSAwXQogICAgc2V0IG5ld2lkICRyb3dtZW51aWQKICAgIHNldCBuZXdoZWFkIFtsaW5kZXggJGNvbW1pdGluZm8oJG5ld2lkKSAwXQogICAgc2V0IHRvcCAucGF0Y2gKICAgIHNldCBwYXRjaHRvcCAkdG9wCiAgICBjYXRjaCB7ZGVzdHJveSAkdG9wfQogICAgdG9wbGV2ZWwgJHRvcAogICAgbGFiZWwgJHRvcC50aXRsZSAtdGV4dCAiR2VuZXJhdGUgcGF0Y2giCiAgICBncmlkICR0b3AudGl0bGUgLSAtcGFkeSAxMAogICAgbGFiZWwgJHRvcC5mcm9tIC10ZXh0ICJGcm9tOiIKICAgIGVudHJ5ICR0b3AuZnJvbXNoYTEgLXdpZHRoIDQwIC1yZWxpZWYgZmxhdAogICAgJHRvcC5mcm9tc2hhMSBpbnNlcnQgMCAkb2xkaWQKICAgICR0b3AuZnJvbXNoYTEgY29uZiAtc3RhdGUgcmVhZG9ubHkKICAgIGdyaWQgJHRvcC5mcm9tICR0b3AuZnJvbXNoYTEgLXN0aWNreSB3CiAgICBlbnRyeSAkdG9wLmZyb21oZWFkIC13aWR0aCA2MCAtcmVsaWVmIGZsYXQKICAgICR0b3AuZnJvbWhlYWQgaW5zZXJ0IDAgJG9sZGhlYWQKICAgICR0b3AuZnJvbWhlYWQgY29uZiAtc3RhdGUgcmVhZG9ubHkKICAgIGdyaWQgeCAkdG9wLmZyb21oZWFkIC1zdGlja3kgdwogICAgbGFiZWwgJHRvcC50byAtdGV4dCAiVG86IgogICAgZW50cnkgJHRvcC50b3NoYTEgLXdpZHRoIDQwIC1yZWxpZWYgZmxhdAogICAgJHRvcC50b3NoYTEgaW5zZXJ0IDAgJG5ld2lkCiAgICAkdG9wLnRvc2hhMSBjb25mIC1zdGF0ZSByZWFkb25seQogICAgZ3JpZCAkdG9wLnRvICR0b3AudG9zaGExIC1zdGlja3kgdwogICAgZW50cnkgJHRvcC50b2hlYWQgLXdpZHRoIDYwIC1yZWxpZWYgZmxhdAogICAgJHRvcC50b2hlYWQgaW5zZXJ0IDAgJG5ld2hlYWQKICAgICR0b3AudG9oZWFkIGNvbmYgLXN0YXRlIHJlYWRvbmx5CiAgICBncmlkIHggJHRvcC50b2hlYWQgLXN0aWNreSB3CiAgICBidXR0b24gJHRvcC5yZXYgLXRleHQgIlJldmVyc2UiIC1jb21tYW5kIG1rcGF0Y2hyZXYgLXBhZHggNQogICAgZ3JpZCAkdG9wLnJldiB4IC1wYWR5IDEwCiAgICBsYWJlbCAkdG9wLmZsYWIgLXRleHQgIk91dHB1dCBmaWxlOiIKICAgIGVudHJ5ICR0b3AuZm5hbWUgLXdpZHRoIDYwCiAgICAkdG9wLmZuYW1lIGluc2VydCAwIFtmaWxlIG5vcm1hbGl6ZSAicGF0Y2gkcGF0Y2hudW0ucGF0Y2giXQogICAgaW5jciBwYXRjaG51bQogICAgZ3JpZCAkdG9wLmZsYWIgJHRvcC5mbmFtZSAtc3RpY2t5IHcKICAgIGZyYW1lICR0b3AuYnV0cwogICAgYnV0dG9uICR0b3AuYnV0cy5nZW4gLXRleHQgIkdlbmVyYXRlIiAtY29tbWFuZCBta3BhdGNoZ28KICAgIGJ1dHRvbiAkdG9wLmJ1dHMuY2FuIC10ZXh0ICJDYW5jZWwiIC1jb21tYW5kIG1rcGF0Y2hjYW4KICAgIGdyaWQgJHRvcC5idXRzLmdlbiAkdG9wLmJ1dHMuY2FuCiAgICBncmlkIGNvbHVtbmNvbmZpZ3VyZSAkdG9wLmJ1dHMgMCAtd2VpZ2h0IDEgLXVuaWZvcm0gYQogICAgZ3JpZCBjb2x1bW5jb25maWd1cmUgJHRvcC5idXRzIDEgLXdlaWdodCAxIC11bmlmb3JtIGEKICAgIGdyaWQgJHRvcC5idXRzIC0gLXBhZHkgMTAgLXN0aWNreSBldwogICAgZm9jdXMgJHRvcC5mbmFtZQp9Cgpwcm9jIG1rcGF0Y2hyZXYge30gewogICAgZ2xvYmFsIHBhdGNodG9wCgogICAgc2V0IG9sZGlkIFskcGF0Y2h0b3AuZnJvbXNoYTEgZ2V0XQogICAgc2V0IG9sZGhlYWQgWyRwYXRjaHRvcC5mcm9taGVhZCBnZXRdCiAgICBzZXQgbmV3aWQgWyRwYXRjaHRvcC50b3NoYTEgZ2V0XQogICAgc2V0IG5ld2hlYWQgWyRwYXRjaHRvcC50b2hlYWQgZ2V0XQogICAgZm9yZWFjaCBlIFtsaXN0IGZyb21zaGExIGZyb21oZWFkIHRvc2hhMSB0b2hlYWRdIFwKCSAgICB2IFtsaXN0ICRuZXdpZCAkbmV3aGVhZCAkb2xkaWQgJG9sZGhlYWRdIHsKCSRwYXRjaHRvcC4kZSBjb25mIC1zdGF0ZSBub3JtYWwKCSRwYXRjaHRvcC4kZSBkZWxldGUgMCBlbmQKCSRwYXRjaHRvcC4kZSBpbnNlcnQgMCAkdgoJJHBhdGNodG9wLiRlIGNvbmYgLXN0YXRlIHJlYWRvbmx5CiAgICB9Cn0KCnByb2MgbWtwYXRjaGdvIHt9IHsKICAgIGdsb2JhbCBwYXRjaHRvcCBudWxsaWQgbnVsbGlkMgoKICAgIHNldCBvbGRpZCBbJHBhdGNodG9wLmZyb21zaGExIGdldF0KICAgIHNldCBuZXdpZCBbJHBhdGNodG9wLnRvc2hhMSBnZXRdCiAgICBzZXQgZm5hbWUgWyRwYXRjaHRvcC5mbmFtZSBnZXRdCiAgICBzZXQgY21kIFtkaWZmY21kIFtsaXN0ICRvbGRpZCAkbmV3aWRdIC1wXQogICAgbGFwcGVuZCBjbWQgPiRmbmFtZSAmCiAgICBpZiB7W2NhdGNoIHtldmFsIGV4ZWMgJGNtZH0gZXJyXX0gewoJZXJyb3JfcG9wdXAgIkVycm9yIGNyZWF0aW5nIHBhdGNoOiAkZXJyIgogICAgfQogICAgY2F0Y2gge2Rlc3Ryb3kgJHBhdGNodG9wfQogICAgdW5zZXQgcGF0Y2h0b3AKfQoKcHJvYyBta3BhdGNoY2FuIHt9IHsKICAgIGdsb2JhbCBwYXRjaHRvcAoKICAgIGNhdGNoIHtkZXN0cm95ICRwYXRjaHRvcH0KICAgIHVuc2V0IHBhdGNodG9wCn0KCnByb2MgbWt0YWcge30gewogICAgZ2xvYmFsIHJvd21lbnVpZCBta3RhZ3RvcCBjb21taXRpbmZvCgogICAgc2V0IHRvcCAubWFrZXRhZwogICAgc2V0IG1rdGFndG9wICR0b3AKICAgIGNhdGNoIHtkZXN0cm95ICR0b3B9CiAgICB0b3BsZXZlbCAkdG9wCiAgICBsYWJlbCAkdG9wLnRpdGxlIC10ZXh0ICJDcmVhdGUgdGFnIgogICAgZ3JpZCAkdG9wLnRpdGxlIC0gLXBhZHkgMTAKICAgIGxhYmVsICR0b3AuaWQgLXRleHQgIklEOiIKICAgIGVudHJ5ICR0b3Auc2hhMSAtd2lkdGggNDAgLXJlbGllZiBmbGF0CiAgICAkdG9wLnNoYTEgaW5zZXJ0IDAgJHJvd21lbnVpZAogICAgJHRvcC5zaGExIGNvbmYgLXN0YXRlIHJlYWRvbmx5CiAgICBncmlkICR0b3AuaWQgJHRvcC5zaGExIC1zdGlja3kgdwogICAgZW50cnkgJHRvcC5oZWFkIC13aWR0aCA2MCAtcmVsaWVmIGZsYXQKICAgICR0b3AuaGVhZCBpbnNlcnQgMCBbbGluZGV4ICRjb21taXRpbmZvKCRyb3dtZW51aWQpIDBdCiAgICAkdG9wLmhlYWQgY29uZiAtc3RhdGUgcmVhZG9ubHkKICAgIGdyaWQgeCAkdG9wLmhlYWQgLXN0aWNreSB3CiAgICBsYWJlbCAkdG9wLnRsYWIgLXRleHQgIlRhZyBuYW1lOiIKICAgIGVudHJ5ICR0b3AudGFnIC13aWR0aCA2MAogICAgZ3JpZCAkdG9wLnRsYWIgJHRvcC50YWcgLXN0aWNreSB3CiAgICBmcmFtZSAkdG9wLmJ1dHMKICAgIGJ1dHRvbiAkdG9wLmJ1dHMuZ2VuIC10ZXh0ICJDcmVhdGUiIC1jb21tYW5kIG1rdGFnZ28KICAgIGJ1dHRvbiAkdG9wLmJ1dHMuY2FuIC10ZXh0ICJDYW5jZWwiIC1jb21tYW5kIG1rdGFnY2FuCiAgICBncmlkICR0b3AuYnV0cy5nZW4gJHRvcC5idXRzLmNhbgogICAgZ3JpZCBjb2x1bW5jb25maWd1cmUgJHRvcC5idXRzIDAgLXdlaWdodCAxIC11bmlmb3JtIGEKICAgIGdyaWQgY29sdW1uY29uZmlndXJlICR0b3AuYnV0cyAxIC13ZWlnaHQgMSAtdW5pZm9ybSBhCiAgICBncmlkICR0b3AuYnV0cyAtIC1wYWR5IDEwIC1zdGlja3kgZXcKICAgIGZvY3VzICR0b3AudGFnCn0KCnByb2MgZG9ta3RhZyB7fSB7CiAgICBnbG9iYWwgbWt0YWd0b3AgZW52IHRhZ2lkcyBpZHRhZ3MKCiAgICBzZXQgaWQgWyRta3RhZ3RvcC5zaGExIGdldF0KICAgIHNldCB0YWcgWyRta3RhZ3RvcC50YWcgZ2V0XQogICAgaWYgeyR0YWcgPT0ge319IHsKCWVycm9yX3BvcHVwICJObyB0YWcgbmFtZSBzcGVjaWZpZWQiCglyZXR1cm4KICAgIH0KICAgIGlmIHtbaW5mbyBleGlzdHMgdGFnaWRzKCR0YWcpXX0gewoJZXJyb3JfcG9wdXAgIlRhZyBcIiR0YWdcIiBhbHJlYWR5IGV4aXN0cyIKCXJldHVybgogICAgfQogICAgaWYge1tjYXRjaCB7CglzZXQgZGlyIFtnaXRkaXJdCglzZXQgZm5hbWUgW2ZpbGUgam9pbiAkZGlyICJyZWZzL3RhZ3MiICR0YWddCglzZXQgZiBbb3BlbiAkZm5hbWUgd10KCXB1dHMgJGYgJGlkCgljbG9zZSAkZgogICAgfSBlcnJdfSB7CgllcnJvcl9wb3B1cCAiRXJyb3IgY3JlYXRpbmcgdGFnOiAkZXJyIgoJcmV0dXJuCiAgICB9CgogICAgc2V0IHRhZ2lkcygkdGFnKSAkaWQKICAgIGxhcHBlbmQgaWR0YWdzKCRpZCkgJHRhZwogICAgcmVkcmF3dGFncyAkaWQKICAgIGFkZGVkdGFnICRpZAp9Cgpwcm9jIHJlZHJhd3RhZ3Mge2lkfSB7CiAgICBnbG9iYWwgY2FudiBsaW5laHRhZyBjb21taXRyb3cgaWRwb3Mgc2VsZWN0ZWRsaW5lIGN1cnZpZXcKICAgIGdsb2JhbCBtYWluZm9udCBjYW52eG1heCBpZGRyYXduCgogICAgaWYgeyFbaW5mbyBleGlzdHMgY29tbWl0cm93KCRjdXJ2aWV3LCRpZCldfSByZXR1cm4KICAgIGlmIHshW2luZm8gZXhpc3RzIGlkZHJhd24oJGlkKV19IHJldHVybgogICAgZHJhd2NvbW1pdHMgJGNvbW1pdHJvdygkY3VydmlldywkaWQpCiAgICAkY2FudiBkZWxldGUgdGFnLiRpZAogICAgc2V0IHh0IFtldmFsIGRyYXd0YWdzICRpZCAkaWRwb3MoJGlkKV0KICAgICRjYW52IGNvb3JkcyAkbGluZWh0YWcoJGNvbW1pdHJvdygkY3VydmlldywkaWQpKSAkeHQgW2xpbmRleCAkaWRwb3MoJGlkKSAyXQogICAgc2V0IHRleHQgWyRjYW52IGl0ZW1jZ2V0ICRsaW5laHRhZygkY29tbWl0cm93KCRjdXJ2aWV3LCRpZCkpIC10ZXh0XQogICAgc2V0IHhyIFtleHByIHskeHQgKyBbZm9udCBtZWFzdXJlICRtYWluZm9udCAkdGV4dF19XQogICAgaWYgeyR4ciA+ICRjYW52eG1heH0gewoJc2V0IGNhbnZ4bWF4ICR4cgoJc2V0Y2FudnNjcm9sbAogICAgfQogICAgaWYge1tpbmZvIGV4aXN0cyBzZWxlY3RlZGxpbmVdCgkmJiAkc2VsZWN0ZWRsaW5lID09ICRjb21taXRyb3coJGN1cnZpZXcsJGlkKX0gewoJc2VsZWN0bGluZSAkc2VsZWN0ZWRsaW5lIDAKICAgIH0KfQoKcHJvYyBta3RhZ2NhbiB7fSB7CiAgICBnbG9iYWwgbWt0YWd0b3AKCiAgICBjYXRjaCB7ZGVzdHJveSAkbWt0YWd0b3B9CiAgICB1bnNldCBta3RhZ3RvcAp9Cgpwcm9jIG1rdGFnZ28ge30gewogICAgZG9ta3RhZwogICAgbWt0YWdjYW4KfQoKcHJvYyB3cml0ZWNvbW1pdCB7fSB7CiAgICBnbG9iYWwgcm93bWVudWlkIHdyY29tdG9wIGNvbW1pdGluZm8gd3Jjb21jbWQKCiAgICBzZXQgdG9wIC53cml0ZWNvbW1pdAogICAgc2V0IHdyY29tdG9wICR0b3AKICAgIGNhdGNoIHtkZXN0cm95ICR0b3B9CiAgICB0b3BsZXZlbCAkdG9wCiAgICBsYWJlbCAkdG9wLnRpdGxlIC10ZXh0ICJXcml0ZSBjb21taXQgdG8gZmlsZSIKICAgIGdyaWQgJHRvcC50aXRsZSAtIC1wYWR5IDEwCiAgICBsYWJlbCAkdG9wLmlkIC10ZXh0ICJJRDoiCiAgICBlbnRyeSAkdG9wLnNoYTEgLXdpZHRoIDQwIC1yZWxpZWYgZmxhdAogICAgJHRvcC5zaGExIGluc2VydCAwICRyb3dtZW51aWQKICAgICR0b3Auc2hhMSBjb25mIC1zdGF0ZSByZWFkb25seQogICAgZ3JpZCAkdG9wLmlkICR0b3Auc2hhMSAtc3RpY2t5IHcKICAgIGVudHJ5ICR0b3AuaGVhZCAtd2lkdGggNjAgLXJlbGllZiBmbGF0CiAgICAkdG9wLmhlYWQgaW5zZXJ0IDAgW2xpbmRleCAkY29tbWl0aW5mbygkcm93bWVudWlkKSAwXQogICAgJHRvcC5oZWFkIGNvbmYgLXN0YXRlIHJlYWRvbmx5CiAgICBncmlkIHggJHRvcC5oZWFkIC1zdGlja3kgdwogICAgbGFiZWwgJHRvcC5jbGFiIC10ZXh0ICJDb21tYW5kOiIKICAgIGVudHJ5ICR0b3AuY21kIC13aWR0aCA2MCAtdGV4dHZhcmlhYmxlIHdyY29tY21kCiAgICBncmlkICR0b3AuY2xhYiAkdG9wLmNtZCAtc3RpY2t5IHcgLXBhZHkgMTAKICAgIGxhYmVsICR0b3AuZmxhYiAtdGV4dCAiT3V0cHV0IGZpbGU6IgogICAgZW50cnkgJHRvcC5mbmFtZSAtd2lkdGggNjAKICAgICR0b3AuZm5hbWUgaW5zZXJ0IDAgW2ZpbGUgbm9ybWFsaXplICJjb21taXQtW3N0cmluZyByYW5nZSAkcm93bWVudWlkIDAgNl0iXQogICAgZ3JpZCAkdG9wLmZsYWIgJHRvcC5mbmFtZSAtc3RpY2t5IHcKICAgIGZyYW1lICR0b3AuYnV0cwogICAgYnV0dG9uICR0b3AuYnV0cy5nZW4gLXRleHQgIldyaXRlIiAtY29tbWFuZCB3cmNvbWdvCiAgICBidXR0b24gJHRvcC5idXRzLmNhbiAtdGV4dCAiQ2FuY2VsIiAtY29tbWFuZCB3cmNvbWNhbgogICAgZ3JpZCAkdG9wLmJ1dHMuZ2VuICR0b3AuYnV0cy5jYW4KICAgIGdyaWQgY29sdW1uY29uZmlndXJlICR0b3AuYnV0cyAwIC13ZWlnaHQgMSAtdW5pZm9ybSBhCiAgICBncmlkIGNvbHVtbmNvbmZpZ3VyZSAkdG9wLmJ1dHMgMSAtd2VpZ2h0IDEgLXVuaWZvcm0gYQogICAgZ3JpZCAkdG9wLmJ1dHMgLSAtcGFkeSAxMCAtc3RpY2t5IGV3CiAgICBmb2N1cyAkdG9wLmZuYW1lCn0KCnByb2Mgd3Jjb21nbyB7fSB7CiAgICBnbG9iYWwgd3Jjb210b3AKCiAgICBzZXQgaWQgWyR3cmNvbXRvcC5zaGExIGdldF0KICAgIHNldCBjbWQgImVjaG8gJGlkIHwgWyR3cmNvbXRvcC5jbWQgZ2V0XSIKICAgIHNldCBmbmFtZSBbJHdyY29tdG9wLmZuYW1lIGdldF0KICAgIGlmIHtbY2F0Y2gge2V4ZWMgc2ggLWMgJGNtZCA+JGZuYW1lICZ9IGVycl19IHsKCWVycm9yX3BvcHVwICJFcnJvciB3cml0aW5nIGNvbW1pdDogJGVyciIKICAgIH0KICAgIGNhdGNoIHtkZXN0cm95ICR3cmNvbXRvcH0KICAgIHVuc2V0IHdyY29tdG9wCn0KCnByb2Mgd3Jjb21jYW4ge30gewogICAgZ2xvYmFsIHdyY29tdG9wCgogICAgY2F0Y2gge2Rlc3Ryb3kgJHdyY29tdG9wfQogICAgdW5zZXQgd3Jjb210b3AKfQoKcHJvYyBta2JyYW5jaCB7fSB7CiAgICBnbG9iYWwgcm93bWVudWlkIG1rYnJ0b3AKCiAgICBzZXQgdG9wIC5tYWtlYnJhbmNoCiAgICBjYXRjaCB7ZGVzdHJveSAkdG9wfQogICAgdG9wbGV2ZWwgJHRvcAogICAgbGFiZWwgJHRvcC50aXRsZSAtdGV4dCAiQ3JlYXRlIG5ldyBicmFuY2giCiAgICBncmlkICR0b3AudGl0bGUgLSAtcGFkeSAxMAogICAgbGFiZWwgJHRvcC5pZCAtdGV4dCAiSUQ6IgogICAgZW50cnkgJHRvcC5zaGExIC13aWR0aCA0MCAtcmVsaWVmIGZsYXQKICAgICR0b3Auc2hhMSBpbnNlcnQgMCAkcm93bWVudWlkCiAgICAkdG9wLnNoYTEgY29uZiAtc3RhdGUgcmVhZG9ubHkKICAgIGdyaWQgJHRvcC5pZCAkdG9wLnNoYTEgLXN0aWNreSB3CiAgICBsYWJlbCAkdG9wLm5sYWIgLXRleHQgIk5hbWU6IgogICAgZW50cnkgJHRvcC5uYW1lIC13aWR0aCA0MAogICAgZ3JpZCAkdG9wLm5sYWIgJHRvcC5uYW1lIC1zdGlja3kgdwogICAgZnJhbWUgJHRvcC5idXRzCiAgICBidXR0b24gJHRvcC5idXRzLmdvIC10ZXh0ICJDcmVhdGUiIC1jb21tYW5kIFtsaXN0IG1rYnJnbyAkdG9wXQogICAgYnV0dG9uICR0b3AuYnV0cy5jYW4gLXRleHQgIkNhbmNlbCIgLWNvbW1hbmQgImNhdGNoIHtkZXN0cm95ICR0b3B9IgogICAgZ3JpZCAkdG9wLmJ1dHMuZ28gJHRvcC5idXRzLmNhbgogICAgZ3JpZCBjb2x1bW5jb25maWd1cmUgJHRvcC5idXRzIDAgLXdlaWdodCAxIC11bmlmb3JtIGEKICAgIGdyaWQgY29sdW1uY29uZmlndXJlICR0b3AuYnV0cyAxIC13ZWlnaHQgMSAtdW5pZm9ybSBhCiAgICBncmlkICR0b3AuYnV0cyAtIC1wYWR5IDEwIC1zdGlja3kgZXcKICAgIGZvY3VzICR0b3AubmFtZQp9Cgpwcm9jIG1rYnJnbyB7dG9wfSB7CiAgICBnbG9iYWwgaGVhZGlkcyBpZGhlYWRzCgogICAgc2V0IG5hbWUgWyR0b3AubmFtZSBnZXRdCiAgICBzZXQgaWQgWyR0b3Auc2hhMSBnZXRdCiAgICBpZiB7JG5hbWUgZXEge319IHsKCWVycm9yX3BvcHVwICJQbGVhc2Ugc3BlY2lmeSBhIG5hbWUgZm9yIHRoZSBuZXcgYnJhbmNoIgoJcmV0dXJuCiAgICB9CiAgICBjYXRjaCB7ZGVzdHJveSAkdG9wfQogICAgbm93YnVzeSBuZXdicmFuY2gKICAgIHVwZGF0ZQogICAgaWYge1tjYXRjaCB7CglleGVjIGdpdCBicmFuY2ggJG5hbWUgJGlkCiAgICB9IGVycl19IHsKCW5vdGJ1c3kgbmV3YnJhbmNoCgllcnJvcl9wb3B1cCAkZXJyCiAgICB9IGVsc2UgewoJc2V0IGhlYWRpZHMoJG5hbWUpICRpZAoJbGFwcGVuZCBpZGhlYWRzKCRpZCkgJG5hbWUKCWFkZGVkaGVhZCAkaWQgJG5hbWUKCW5vdGJ1c3kgbmV3YnJhbmNoCglyZWRyYXd0YWdzICRpZAoJZGlzcG5lYXJ0YWdzIDAKICAgIH0KfQoKcHJvYyBjaGVycnlwaWNrIHt9IHsKICAgIGdsb2JhbCByb3dtZW51aWQgY3VydmlldyBjb21taXRyb3cKICAgIGdsb2JhbCBtYWluaGVhZAoKICAgIHNldCBvbGRoZWFkIFtleGVjIGdpdCByZXYtcGFyc2UgSEVBRF0KICAgIHNldCBkaGVhZHMgW2Rlc2NoZWFkcyAkcm93bWVudWlkXQogICAgaWYgeyRkaGVhZHMgbmUge30gJiYgW2xzZWFyY2ggLWV4YWN0ICRkaGVhZHMgJG9sZGhlYWRdID49IDB9IHsKCXNldCBvayBbY29uZmlybV9wb3B1cCAiQ29tbWl0IFtzdHJpbmcgcmFuZ2UgJHJvd21lbnVpZCAwIDddIGlzIGFscmVhZHlcCgkJCWluY2x1ZGVkIGluIGJyYW5jaCAkbWFpbmhlYWQgLS0gcmVhbGx5IHJlLWFwcGx5IGl0PyJdCglpZiB7ISRva30gcmV0dXJuCiAgICB9CiAgICBub3didXN5IGNoZXJyeXBpY2sKICAgIHVwZGF0ZQogICAgIyBVbmZvcnR1bmF0ZWx5IGdpdC1jaGVycnktcGljayB3cml0ZXMgc3R1ZmYgdG8gc3RkZXJyIGV2ZW4gd2hlbgogICAgIyBubyBlcnJvciBvY2N1cnMsIGFuZCBleGVjIHRha2VzIHRoYXQgYXMgYW4gaW5kaWNhdGlvbiBvZiBlcnJvci4uLgogICAgaWYge1tjYXRjaCB7ZXhlYyBzaCAtYyAiZ2l0IGNoZXJyeS1waWNrIC1yICRyb3dtZW51aWQgMj4mMSJ9IGVycl19IHsKCW5vdGJ1c3kgY2hlcnJ5cGljawoJZXJyb3JfcG9wdXAgJGVycgoJcmV0dXJuCiAgICB9CiAgICBzZXQgbmV3aGVhZCBbZXhlYyBnaXQgcmV2LXBhcnNlIEhFQURdCiAgICBpZiB7JG5ld2hlYWQgZXEgJG9sZGhlYWR9IHsKCW5vdGJ1c3kgY2hlcnJ5cGljawoJZXJyb3JfcG9wdXAgIk5vIGNoYW5nZXMgY29tbWl0dGVkIgoJcmV0dXJuCiAgICB9CiAgICBhZGRuZXdjaGlsZCAkbmV3aGVhZCAkb2xkaGVhZAogICAgaWYge1tpbmZvIGV4aXN0cyBjb21taXRyb3coJGN1cnZpZXcsJG9sZGhlYWQpXX0gewoJaW5zZXJ0cm93ICRjb21taXRyb3coJGN1cnZpZXcsJG9sZGhlYWQpICRuZXdoZWFkCglpZiB7JG1haW5oZWFkIG5lIHt9fSB7CgkgICAgbW92ZWhlYWQgJG5ld2hlYWQgJG1haW5oZWFkCgkgICAgbW92ZWRoZWFkICRuZXdoZWFkICRtYWluaGVhZAoJfQoJcmVkcmF3dGFncyAkb2xkaGVhZAoJcmVkcmF3dGFncyAkbmV3aGVhZAogICAgfQogICAgbm90YnVzeSBjaGVycnlwaWNrCn0KCnByb2MgcmVzZXRoZWFkIHt9IHsKICAgIGdsb2JhbCBtYWluaGVhZGlkIG1haW5oZWFkIHJvd21lbnVpZCBjb25maXJtX29rIHJlc2V0dHlwZQogICAgZ2xvYmFsIHNob3dsb2NhbGNoYW5nZXMKCiAgICBzZXQgY29uZmlybV9vayAwCiAgICBzZXQgdyAiLmNvbmZpcm1yZXNldCIKICAgIHRvcGxldmVsICR3CiAgICB3bSB0cmFuc2llbnQgJHcgLgogICAgd20gdGl0bGUgJHcgIkNvbmZpcm0gcmVzZXQiCiAgICBtZXNzYWdlICR3Lm0gLXRleHQgXAoJIlJlc2V0IGJyYW5jaCAkbWFpbmhlYWQgdG8gW3N0cmluZyByYW5nZSAkcm93bWVudWlkIDAgN10/IiBcCgktanVzdGlmeSBjZW50ZXIgLWFzcGVjdCAxMDAwCiAgICBwYWNrICR3Lm0gLXNpZGUgdG9wIC1maWxsIHggLXBhZHggMjAgLXBhZHkgMjAKICAgIGZyYW1lICR3LmYgLXJlbGllZiBzdW5rZW4gLWJvcmRlciAyCiAgICBtZXNzYWdlICR3LmYucnQgLXRleHQgIlJlc2V0IHR5cGU6IiAtYXNwZWN0IDEwMDAKICAgIGdyaWQgJHcuZi5ydCAtc3RpY2t5IHcKICAgIHNldCByZXNldHR5cGUgbWl4ZWQKICAgIHJhZGlvYnV0dG9uICR3LmYuc29mdCAtdmFsdWUgc29mdCAtdmFyaWFibGUgcmVzZXR0eXBlIC1qdXN0aWZ5IGxlZnQgXAoJLXRleHQgIlNvZnQ6IExlYXZlIHdvcmtpbmcgdHJlZSBhbmQgaW5kZXggdW50b3VjaGVkIgogICAgZ3JpZCAkdy5mLnNvZnQgLXN0aWNreSB3CiAgICByYWRpb2J1dHRvbiAkdy5mLm1peGVkIC12YWx1ZSBtaXhlZCAtdmFyaWFibGUgcmVzZXR0eXBlIC1qdXN0aWZ5IGxlZnQgXAoJLXRleHQgIk1peGVkOiBMZWF2ZSB3b3JraW5nIHRyZWUgdW50b3VjaGVkLCByZXNldCBpbmRleCIKICAgIGdyaWQgJHcuZi5taXhlZCAtc3RpY2t5IHcKICAgIHJhZGlvYnV0dG9uICR3LmYuaGFyZCAtdmFsdWUgaGFyZCAtdmFyaWFibGUgcmVzZXR0eXBlIC1qdXN0aWZ5IGxlZnQgXAoJLXRleHQgIkhhcmQ6IFJlc2V0IHdvcmtpbmcgdHJlZSBhbmQgaW5kZXhcbihkaXNjYXJkIEFMTCBsb2NhbCBjaGFuZ2VzKSIKICAgIGdyaWQgJHcuZi5oYXJkIC1zdGlja3kgdwogICAgcGFjayAkdy5mIC1zaWRlIHRvcCAtZmlsbCB4CiAgICBidXR0b24gJHcub2sgLXRleHQgT0sgLWNvbW1hbmQgInNldCBjb25maXJtX29rIDE7IGRlc3Ryb3kgJHciCiAgICBwYWNrICR3Lm9rIC1zaWRlIGxlZnQgLWZpbGwgeCAtcGFkeCAyMCAtcGFkeSAyMAogICAgYnV0dG9uICR3LmNhbmNlbCAtdGV4dCBDYW5jZWwgLWNvbW1hbmQgImRlc3Ryb3kgJHciCiAgICBwYWNrICR3LmNhbmNlbCAtc2lkZSByaWdodCAtZmlsbCB4IC1wYWR4IDIwIC1wYWR5IDIwCiAgICBiaW5kICR3IDxWaXNpYmlsaXR5PiAiZ3JhYiAkdzsgZm9jdXMgJHciCiAgICB0a3dhaXQgd2luZG93ICR3CiAgICBpZiB7ISRjb25maXJtX29rfSByZXR1cm4KICAgIGlmIHtbY2F0Y2gge3NldCBmZCBbb3BlbiBcCgkgICAgW2xpc3QgfCBzaCAtYyAiZ2l0IHJlc2V0IC0tJHJlc2V0dHlwZSAkcm93bWVudWlkIDI+JjEiXSByXX0gZXJyXX0gewoJZXJyb3JfcG9wdXAgJGVycgogICAgfSBlbHNlIHsKCWRvaGlkZWxvY2FsY2hhbmdlcwoJc2V0IHcgIi5yZXNldHByb2dyZXNzIgoJZmlsZXJ1biAkZmQgW2xpc3QgcmVhZHJlc2V0c3RhdCAkZmQgJHddCgl0b3BsZXZlbCAkdwoJd20gdHJhbnNpZW50ICR3Cgl3bSB0aXRsZSAkdyAiUmVzZXQgcHJvZ3Jlc3MiCgltZXNzYWdlICR3Lm0gLXRleHQgIlJlc2V0IGluIHByb2dyZXNzLCBwbGVhc2Ugd2FpdC4uLiIgXAoJICAgIC1qdXN0aWZ5IGNlbnRlciAtYXNwZWN0IDEwMDAKCXBhY2sgJHcubSAtc2lkZSB0b3AgLWZpbGwgeCAtcGFkeCAyMCAtcGFkeSA1CgljYW52YXMgJHcuYyAtd2lkdGggMTUwIC1oZWlnaHQgMjAgLWJnIHdoaXRlCgkkdy5jIGNyZWF0ZSByZWN0IDAgMCAwIDIwIC1maWxsIGdyZWVuIC10YWdzIHJlY3QKCXBhY2sgJHcuYyAtc2lkZSB0b3AgLWZpbGwgeCAtcGFkeCAyMCAtcGFkeSA1IC1leHBhbmQgMQoJbm93YnVzeSByZXNldAogICAgfQp9Cgpwcm9jIHJlYWRyZXNldHN0YXQge2ZkIHd9IHsKICAgIGdsb2JhbCBtYWluaGVhZCBtYWluaGVhZGlkIHNob3dsb2NhbGNoYW5nZXMKCiAgICBpZiB7W2dldHMgJGZkIGxpbmVdID49IDB9IHsKCWlmIHtbcmVnZXhwIHsoWzAtOV0rKSUgXCgoWzAtOV0rKS8oWzAtOV0rKVwpfSAkbGluZSBtYXRjaCBwIG0gbl19IHsKCSAgICBzZXQgeCBbZXhwciB7KCRtICogMTUwKSAvICRufV0KCSAgICAkdy5jIGNvb3JkcyByZWN0IDAgMCAkeCAyMAoJfQoJcmV0dXJuIDEKICAgIH0KICAgIGRlc3Ryb3kgJHcKICAgIG5vdGJ1c3kgcmVzZXQKICAgIGlmIHtbY2F0Y2gge2Nsb3NlICRmZH0gZXJyXX0gewoJZXJyb3JfcG9wdXAgJGVycgogICAgfQogICAgc2V0IG9sZGhlYWQgJG1haW5oZWFkaWQKICAgIHNldCBuZXdoZWFkIFtleGVjIGdpdCByZXYtcGFyc2UgSEVBRF0KICAgIGlmIHskbmV3aGVhZCBuZSAkb2xkaGVhZH0gewoJbW92ZWhlYWQgJG5ld2hlYWQgJG1haW5oZWFkCgltb3ZlZGhlYWQgJG5ld2hlYWQgJG1haW5oZWFkCglzZXQgbWFpbmhlYWRpZCAkbmV3aGVhZAoJcmVkcmF3dGFncyAkb2xkaGVhZAoJcmVkcmF3dGFncyAkbmV3aGVhZAogICAgfQogICAgaWYgeyRzaG93bG9jYWxjaGFuZ2VzfSB7Cglkb3Nob3dsb2NhbGNoYW5nZXMKICAgIH0KICAgIHJldHVybiAwCn0KCiMgY29udGV4dCBtZW51IGZvciBhIGhlYWQKcHJvYyBoZWFkbWVudSB7eCB5IGlkIGhlYWR9IHsKICAgIGdsb2JhbCBoZWFkbWVudWlkIGhlYWRtZW51aGVhZCBoZWFkY3R4bWVudSBtYWluaGVhZAoKICAgIHNldCBoZWFkbWVudWlkICRpZAogICAgc2V0IGhlYWRtZW51aGVhZCAkaGVhZAogICAgc2V0IHN0YXRlIG5vcm1hbAogICAgaWYgeyRoZWFkIGVxICRtYWluaGVhZH0gewoJc2V0IHN0YXRlIGRpc2FibGVkCiAgICB9CiAgICAkaGVhZGN0eG1lbnUgZW50cnljb25maWd1cmUgMCAtc3RhdGUgJHN0YXRlCiAgICAkaGVhZGN0eG1lbnUgZW50cnljb25maWd1cmUgMSAtc3RhdGUgJHN0YXRlCiAgICB0a19wb3B1cCAkaGVhZGN0eG1lbnUgJHggJHkKfQoKcHJvYyBjb2JyYW5jaCB7fSB7CiAgICBnbG9iYWwgaGVhZG1lbnVpZCBoZWFkbWVudWhlYWQgbWFpbmhlYWQgaGVhZGlkcwogICAgZ2xvYmFsIHNob3dsb2NhbGNoYW5nZXMgbWFpbmhlYWRpZAoKICAgICMgY2hlY2sgdGhlIHRyZWUgaXMgY2xlYW4gZmlyc3Q/PwogICAgc2V0IG9sZG1haW5oZWFkICRtYWluaGVhZAogICAgbm93YnVzeSBjaGVja291dAogICAgdXBkYXRlCiAgICBkb2hpZGVsb2NhbGNoYW5nZXMKICAgIGlmIHtbY2F0Y2ggewoJZXhlYyBnaXQgY2hlY2tvdXQgLXEgJGhlYWRtZW51aGVhZAogICAgfSBlcnJdfSB7Cglub3RidXN5IGNoZWNrb3V0CgllcnJvcl9wb3B1cCAkZXJyCiAgICB9IGVsc2UgewoJbm90YnVzeSBjaGVja291dAoJc2V0IG1haW5oZWFkICRoZWFkbWVudWhlYWQKCXNldCBtYWluaGVhZGlkICRoZWFkbWVudWlkCglpZiB7W2luZm8gZXhpc3RzIGhlYWRpZHMoJG9sZG1haW5oZWFkKV19IHsKCSAgICByZWRyYXd0YWdzICRoZWFkaWRzKCRvbGRtYWluaGVhZCkKCX0KCXJlZHJhd3RhZ3MgJGhlYWRtZW51aWQKICAgIH0KICAgIGlmIHskc2hvd2xvY2FsY2hhbmdlc30gewoJZG9kaWZmaW5kZXgKICAgIH0KfQoKcHJvYyBybWJyYW5jaCB7fSB7CiAgICBnbG9iYWwgaGVhZG1lbnVpZCBoZWFkbWVudWhlYWQgbWFpbmhlYWQKICAgIGdsb2JhbCBoZWFkaWRzIGlkaGVhZHMKCiAgICBzZXQgaGVhZCAkaGVhZG1lbnVoZWFkCiAgICBzZXQgaWQgJGhlYWRtZW51aWQKICAgICMgdGhpcyBjaGVjayBzaG91bGRuJ3QgYmUgbmVlZGVkIGFueSBtb3JlLi4uCiAgICBpZiB7JGhlYWQgZXEgJG1haW5oZWFkfSB7CgllcnJvcl9wb3B1cCAiQ2Fubm90IGRlbGV0ZSB0aGUgY3VycmVudGx5IGNoZWNrZWQtb3V0IGJyYW5jaCIKCXJldHVybgogICAgfQogICAgc2V0IGRoZWFkcyBbZGVzY2hlYWRzICRpZF0KICAgIGlmIHskZGhlYWRzIGVxICRoZWFkaWRzKCRoZWFkKX0gewoJIyB0aGUgc3R1ZmYgb24gdGhpcyBicmFuY2ggaXNuJ3Qgb24gYW55IG90aGVyIGJyYW5jaAoJaWYgeyFbY29uZmlybV9wb3B1cCAiVGhlIGNvbW1pdHMgb24gYnJhbmNoICRoZWFkIGFyZW4ndCBvbiBhbnkgb3RoZXJcCgkJCWJyYW5jaC5cblJlYWxseSBkZWxldGUgYnJhbmNoICRoZWFkPyJdfSByZXR1cm4KICAgIH0KICAgIG5vd2J1c3kgcm1icmFuY2gKICAgIHVwZGF0ZQogICAgaWYge1tjYXRjaCB7ZXhlYyBnaXQgYnJhbmNoIC1EICRoZWFkfSBlcnJdfSB7Cglub3RidXN5IHJtYnJhbmNoCgllcnJvcl9wb3B1cCAkZXJyCglyZXR1cm4KICAgIH0KICAgIHJlbW92ZWhlYWQgJGlkICRoZWFkCiAgICByZW1vdmVkaGVhZCAkaWQgJGhlYWQKICAgIHJlZHJhd3RhZ3MgJGlkCiAgICBub3RidXN5IHJtYnJhbmNoCiAgICBkaXNwbmVhcnRhZ3MgMAp9CgojIFN0dWZmIGZvciBmaW5kaW5nIG5lYXJieSB0YWdzCnByb2MgZ2V0YWxsY29tbWl0cyB7fSB7CiAgICBnbG9iYWwgYWxsY29tbWl0cyBhbGxpZHMgbmJtcCBuZXh0YXJjIHNlZWRzCgogICAgc2V0IGFsbGlkcyB7fQogICAgc2V0IG5ibXAgMAogICAgc2V0IG5leHRhcmMgMAogICAgc2V0IGFsbGNvbW1pdHMgMAogICAgc2V0IHNlZWRzIHt9CiAgICByZWdldGFsbGNvbW1pdHMKfQoKIyBDYWxsZWQgd2hlbiB0aGUgZ3JhcGggbWlnaHQgaGF2ZSBjaGFuZ2VkCnByb2MgcmVnZXRhbGxjb21taXRzIHt9IHsKICAgIGdsb2JhbCBhbGxjb21taXRzIHNlZWRzCgogICAgc2V0IGNtZCBbY29uY2F0IHwgZ2l0IHJldi1saXN0IC0tYWxsIC0tcGFyZW50c10KICAgIGZvcmVhY2ggaWQgJHNlZWRzIHsKCWxhcHBlbmQgY21kICJeJGlkIgogICAgfQogICAgc2V0IGZkIFtvcGVuICRjbWQgcl0KICAgIGZjb25maWd1cmUgJGZkIC1ibG9ja2luZyAwCiAgICBpbmNyIGFsbGNvbW1pdHMKICAgIG5vd2J1c3kgYWxsY29tbWl0cwogICAgZmlsZXJ1biAkZmQgW2xpc3QgZ2V0YWxsY2xpbmVzICRmZF0KfQoKIyBTaW5jZSBtb3N0IGNvbW1pdHMgaGF2ZSAxIHBhcmVudCBhbmQgMSBjaGlsZCwgd2UgZ3JvdXAgc3RyaW5ncyBvZgojIHN1Y2ggY29tbWl0cyBpbnRvICJhcmNzIiBqb2luaW5nIGJyYW5jaC9tZXJnZSBwb2ludHMgKEJNUHMpLCB3aGljaAojIGFyZSBjb21taXRzIHRoYXQgZWl0aGVyIGRvbid0IGhhdmUgMSBwYXJlbnQgb3IgZG9uJ3QgaGF2ZSAxIGNoaWxkLgojCiMgYXJjbm9zKGlkKSAtIGluY29taW5nIGFyY3MgZm9yIEJNUCwgYXJjIHdlJ3JlIG9uIGZvciBvdGhlciBub2RlcwojIGFyY291dChpZCkgLSBvdXRnb2luZyBhcmNzIGZvciBCTVAKIyBhcmNpZHMoYSkgLSBsaXN0IG9mIElEcyBvbiBhcmMgaW5jbHVkaW5nIGVuZCBidXQgbm90IHN0YXJ0CiMgYXJjc3RhcnQoYSkgLSBCTVAgSUQgYXQgc3RhcnQgb2YgYXJjCiMgYXJjZW5kKGEpIC0gQk1QIElEIGF0IGVuZCBvZiBhcmMKIyBncm93aW5nKGEpIC0gYXJjIGEgaXMgc3RpbGwgZ3Jvd2luZwojIGFyY3RhZ3MoYSkgLSBJRHMgb3V0IG9mIGFyY2lkcyAoZXhjbHVkaW5nIGVuZCkgdGhhdCBoYXZlIHRhZ3MKIyBhcmNoZWFkcyhhKSAtIElEcyBvdXQgb2YgYXJjaWRzIChleGNsdWRpbmcgZW5kKSB0aGF0IGhhdmUgaGVhZHMKIyBUaGUgc3RhcnQgb2YgYW4gYXJjIGlzIGF0IHRoZSBkZXNjZW5kZW50IGVuZCwgc28gImluY29taW5nIiBtZWFucwojIGNvbWluZyBmcm9tIGRlc2NlbmRlbnRzLCBhbmQgIm91dGdvaW5nIiBtZWFucyBnb2luZyB0b3dhcmRzIGFuY2VzdG9ycy4KCnByb2MgZ2V0YWxsY2xpbmVzIHtmZH0gewogICAgZ2xvYmFsIGFsbGlkcyBhbGxwYXJlbnRzIGFsbGNoaWxkcmVuIGlkdGFncyBpZGhlYWRzIG5leHRhcmMgbmJtcAogICAgZ2xvYmFsIGFyY25vcyBhcmNpZHMgYXJjdGFncyBhcmNvdXQgYXJjZW5kIGFyY3N0YXJ0IGFyY2hlYWRzIGdyb3dpbmcKICAgIGdsb2JhbCBzZWVkcyBhbGxjb21taXRzCgogICAgc2V0IG5pZCAwCiAgICB3aGlsZSB7W2luY3IgbmlkXSA8PSAxMDAwICYmIFtnZXRzICRmZCBsaW5lXSA+PSAwfSB7CglzZXQgaWQgW2xpbmRleCAkbGluZSAwXQoJaWYge1tpbmZvIGV4aXN0cyBhbGxwYXJlbnRzKCRpZCldfSB7CgkgICAgIyBzZWVuIGl0IGFscmVhZHkKCSAgICBjb250aW51ZQoJfQoJbGFwcGVuZCBhbGxpZHMgJGlkCglzZXQgb2xkcyBbbHJhbmdlICRsaW5lIDEgZW5kXQoJc2V0IGFsbHBhcmVudHMoJGlkKSAkb2xkcwoJaWYgeyFbaW5mbyBleGlzdHMgYWxsY2hpbGRyZW4oJGlkKV19IHsKCSAgICBzZXQgYWxsY2hpbGRyZW4oJGlkKSB7fQoJICAgIHNldCBhcmNub3MoJGlkKSB7fQoJICAgIGxhcHBlbmQgc2VlZHMgJGlkCgl9IGVsc2UgewoJICAgIHNldCBhICRhcmNub3MoJGlkKQoJICAgIGlmIHtbbGxlbmd0aCAkb2xkc10gPT0gMSAmJiBbbGxlbmd0aCAkYV0gPT0gMX0gewoJCWxhcHBlbmQgYXJjaWRzKCRhKSAkaWQKCQlpZiB7W2luZm8gZXhpc3RzIGlkdGFncygkaWQpXX0gewoJCSAgICBsYXBwZW5kIGFyY3RhZ3MoJGEpICRpZAoJCX0KCQlpZiB7W2luZm8gZXhpc3RzIGlkaGVhZHMoJGlkKV19IHsKCQkgICAgbGFwcGVuZCBhcmNoZWFkcygkYSkgJGlkCgkJfQoJCWlmIHtbaW5mbyBleGlzdHMgYWxscGFyZW50cygkb2xkcyldfSB7CgkJICAgICMgc2VlbiBwYXJlbnQgYWxyZWFkeQoJCSAgICBpZiB7IVtpbmZvIGV4aXN0cyBhcmNvdXQoJG9sZHMpXX0gewoJCQlzcGxpdGFyYyAkb2xkcwoJCSAgICB9CgkJICAgIGxhcHBlbmQgYXJjaWRzKCRhKSAkb2xkcwoJCSAgICBzZXQgYXJjZW5kKCRhKSAkb2xkcwoJCSAgICB1bnNldCBncm93aW5nKCRhKQoJCX0KCQlsYXBwZW5kIGFsbGNoaWxkcmVuKCRvbGRzKSAkaWQKCQlsYXBwZW5kIGFyY25vcygkb2xkcykgJGEKCQljb250aW51ZQoJICAgIH0KCX0KCWluY3IgbmJtcAoJZm9yZWFjaCBhICRhcmNub3MoJGlkKSB7CgkgICAgbGFwcGVuZCBhcmNpZHMoJGEpICRpZAoJICAgIHNldCBhcmNlbmQoJGEpICRpZAoJICAgIHVuc2V0IGdyb3dpbmcoJGEpCgl9CgoJc2V0IGFvIHt9Cglmb3JlYWNoIHAgJG9sZHMgewoJICAgIGxhcHBlbmQgYWxsY2hpbGRyZW4oJHApICRpZAoJICAgIHNldCBhIFtpbmNyIG5leHRhcmNdCgkgICAgc2V0IGFyY3N0YXJ0KCRhKSAkaWQKCSAgICBzZXQgYXJjaGVhZHMoJGEpIHt9CgkgICAgc2V0IGFyY3RhZ3MoJGEpIHt9CgkgICAgc2V0IGFyY2hlYWRzKCRhKSB7fQoJICAgIHNldCBhcmNpZHMoJGEpIHt9CgkgICAgbGFwcGVuZCBhbyAkYQoJICAgIHNldCBncm93aW5nKCRhKSAxCgkgICAgaWYge1tpbmZvIGV4aXN0cyBhbGxwYXJlbnRzKCRwKV19IHsKCQkjIHNlZW4gaXQgYWxyZWFkeSwgbWF5IG5lZWQgdG8gbWFrZSBhIG5ldyBicmFuY2gKCQlpZiB7IVtpbmZvIGV4aXN0cyBhcmNvdXQoJHApXX0gewoJCSAgICBzcGxpdGFyYyAkcAoJCX0KCQlsYXBwZW5kIGFyY2lkcygkYSkgJHAKCQlzZXQgYXJjZW5kKCRhKSAkcAoJCXVuc2V0IGdyb3dpbmcoJGEpCgkgICAgfQoJICAgIGxhcHBlbmQgYXJjbm9zKCRwKSAkYQoJfQoJc2V0IGFyY291dCgkaWQpICRhbwogICAgfQogICAgaWYgeyRuaWQgPiAwfSB7CglnbG9iYWwgY2FjaGVkX2RoZWFkcyBjYWNoZWRfZHRhZ3MgY2FjaGVkX2F0YWdzCgljYXRjaCB7dW5zZXQgY2FjaGVkX2RoZWFkc30KCWNhdGNoIHt1bnNldCBjYWNoZWRfZHRhZ3N9CgljYXRjaCB7dW5zZXQgY2FjaGVkX2F0YWdzfQogICAgfQogICAgaWYgeyFbZW9mICRmZF19IHsKCXJldHVybiBbZXhwciB7JG5pZCA+PSAxMDAwPyAyOiAxfV0KICAgIH0KICAgIGNsb3NlICRmZAogICAgaWYge1tpbmNyIGFsbGNvbW1pdHMgLTFdID09IDB9IHsKCW5vdGJ1c3kgYWxsY29tbWl0cwogICAgfQogICAgZGlzcG5lYXJ0YWdzIDAKICAgIHJldHVybiAwCn0KCnByb2MgcmVjYWxjYXJjIHthfSB7CiAgICBnbG9iYWwgYXJjdGFncyBhcmNoZWFkcyBhcmNpZHMgaWR0YWdzIGlkaGVhZHMKCiAgICBzZXQgYXQge30KICAgIHNldCBhaCB7fQogICAgZm9yZWFjaCBpZCBbbHJhbmdlICRhcmNpZHMoJGEpIDAgZW5kLTFdIHsKCWlmIHtbaW5mbyBleGlzdHMgaWR0YWdzKCRpZCldfSB7CgkgICAgbGFwcGVuZCBhdCAkaWQKCX0KCWlmIHtbaW5mbyBleGlzdHMgaWRoZWFkcygkaWQpXX0gewoJICAgIGxhcHBlbmQgYWggJGlkCgl9CiAgICB9CiAgICBzZXQgYXJjdGFncygkYSkgJGF0CiAgICBzZXQgYXJjaGVhZHMoJGEpICRhaAp9Cgpwcm9jIHNwbGl0YXJjIHtwfSB7CiAgICBnbG9iYWwgYXJjbm9zIGFyY2lkcyBuZXh0YXJjIG5ibXAgYXJjdGFncyBhcmNoZWFkcyBpZHRhZ3MgaWRoZWFkcwogICAgZ2xvYmFsIGFyY3N0YXJ0IGFyY2VuZCBhcmNvdXQgYWxscGFyZW50cyBncm93aW5nCgogICAgc2V0IGEgJGFyY25vcygkcCkKICAgIGlmIHtbbGxlbmd0aCAkYV0gIT0gMX0gewoJcHV0cyAib29wcyBzcGxpdGFyYyBjYWxsZWQgYnV0IFtsbGVuZ3RoICRhXSBhcmNzIGFscmVhZHkiCglyZXR1cm4KICAgIH0KICAgIHNldCBhIFtsaW5kZXggJGEgMF0KICAgIHNldCBpIFtsc2VhcmNoIC1leGFjdCAkYXJjaWRzKCRhKSAkcF0KICAgIGlmIHskaSA8IDB9IHsKCXB1dHMgIm9vcHMgc3BsaXRhcmMgJHAgbm90IGluIGFyYyAkYSIKCXJldHVybgogICAgfQogICAgc2V0IG5hIFtpbmNyIG5leHRhcmNdCiAgICBpZiB7W2luZm8gZXhpc3RzIGFyY2VuZCgkYSldfSB7CglzZXQgYXJjZW5kKCRuYSkgJGFyY2VuZCgkYSkKICAgIH0gZWxzZSB7CglzZXQgbCBbbGluZGV4ICRhbGxwYXJlbnRzKFtsaW5kZXggJGFyY2lkcygkYSkgZW5kXSkgMF0KCXNldCBqIFtsc2VhcmNoIC1leGFjdCAkYXJjbm9zKCRsKSAkYV0KCXNldCBhcmNub3MoJGwpIFtscmVwbGFjZSAkYXJjbm9zKCRsKSAkaiAkaiAkbmFdCiAgICB9CiAgICBzZXQgdGFpbCBbbHJhbmdlICRhcmNpZHMoJGEpIFtleHByIHskaSsxfV0gZW5kXQogICAgc2V0IGFyY2lkcygkYSkgW2xyYW5nZSAkYXJjaWRzKCRhKSAwICRpXQogICAgc2V0IGFyY2VuZCgkYSkgJHAKICAgIHNldCBhcmNzdGFydCgkbmEpICRwCiAgICBzZXQgYXJjb3V0KCRwKSAkbmEKICAgIHNldCBhcmNpZHMoJG5hKSAkdGFpbAogICAgaWYge1tpbmZvIGV4aXN0cyBncm93aW5nKCRhKV19IHsKCXNldCBncm93aW5nKCRuYSkgMQoJdW5zZXQgZ3Jvd2luZygkYSkKICAgIH0KICAgIGluY3IgbmJtcAoKICAgIGZvcmVhY2ggaWQgJHRhaWwgewoJaWYge1tsbGVuZ3RoICRhcmNub3MoJGlkKV0gPT0gMX0gewoJICAgIHNldCBhcmNub3MoJGlkKSAkbmEKCX0gZWxzZSB7CgkgICAgc2V0IGogW2xzZWFyY2ggLWV4YWN0ICRhcmNub3MoJGlkKSAkYV0KCSAgICBzZXQgYXJjbm9zKCRpZCkgW2xyZXBsYWNlICRhcmNub3MoJGlkKSAkaiAkaiAkbmFdCgl9CiAgICB9CgogICAgIyByZWNvbnN0cnVjdCB0YWdzIGFuZCBoZWFkcyBsaXN0cwogICAgaWYgeyRhcmN0YWdzKCRhKSBuZSB7fSB8fCAkYXJjaGVhZHMoJGEpIG5lIHt9fSB7CglyZWNhbGNhcmMgJGEKCXJlY2FsY2FyYyAkbmEKICAgIH0gZWxzZSB7CglzZXQgYXJjdGFncygkbmEpIHt9CglzZXQgYXJjaGVhZHMoJG5hKSB7fQogICAgfQp9CgojIFVwZGF0ZSB0aGluZ3MgZm9yIGEgbmV3IGNvbW1pdCBhZGRlZCB0aGF0IGlzIGEgY2hpbGQgb2Ygb25lCiMgZXhpc3RpbmcgY29tbWl0LiAgVXNlZCB3aGVuIGNoZXJyeS1waWNraW5nLgpwcm9jIGFkZG5ld2NoaWxkIHtpZCBwfSB7CiAgICBnbG9iYWwgYWxsaWRzIGFsbHBhcmVudHMgYWxsY2hpbGRyZW4gaWR0YWdzIG5leHRhcmMgbmJtcAogICAgZ2xvYmFsIGFyY25vcyBhcmNpZHMgYXJjdGFncyBhcmNvdXQgYXJjZW5kIGFyY3N0YXJ0IGFyY2hlYWRzIGdyb3dpbmcKICAgIGdsb2JhbCBzZWVkcwoKICAgIGxhcHBlbmQgYWxsaWRzICRpZAogICAgc2V0IGFsbHBhcmVudHMoJGlkKSBbbGlzdCAkcF0KICAgIHNldCBhbGxjaGlsZHJlbigkaWQpIHt9CiAgICBzZXQgYXJjbm9zKCRpZCkge30KICAgIGxhcHBlbmQgc2VlZHMgJGlkCiAgICBpbmNyIG5ibXAKICAgIGxhcHBlbmQgYWxsY2hpbGRyZW4oJHApICRpZAogICAgc2V0IGEgW2luY3IgbmV4dGFyY10KICAgIHNldCBhcmNzdGFydCgkYSkgJGlkCiAgICBzZXQgYXJjaGVhZHMoJGEpIHt9CiAgICBzZXQgYXJjdGFncygkYSkge30KICAgIHNldCBhcmNpZHMoJGEpIFtsaXN0ICRwXQogICAgc2V0IGFyY2VuZCgkYSkgJHAKICAgIGlmIHshW2luZm8gZXhpc3RzIGFyY291dCgkcCldfSB7CglzcGxpdGFyYyAkcAogICAgfQogICAgbGFwcGVuZCBhcmNub3MoJHApICRhCiAgICBzZXQgYXJjb3V0KCRpZCkgW2xpc3QgJGFdCn0KCiMgUmV0dXJucyAxIGlmIGEgaXMgYW4gYW5jZXN0b3Igb2YgYiwgLTEgaWYgYiBpcyBhbiBhbmNlc3RvciBvZiBhLAojIG9yIDAgaWYgbmVpdGhlciBpcyB0cnVlLgpwcm9jIGFuY19vcl9kZXNjIHthIGJ9IHsKICAgIGdsb2JhbCBhcmNvdXQgYXJjc3RhcnQgYXJjZW5kIGFyY25vcyBjYWNoZWRfaXNhbmMKCiAgICBpZiB7JGFyY25vcygkYSkgZXEgJGFyY25vcygkYil9IHsKCSMgQm90aCBhcmUgb24gdGhlIHNhbWUgYXJjKHMpOyBlaXRoZXIgYm90aCBhcmUgdGhlIHNhbWUgQk1QLAoJIyBvciBpZiBvbmUgaXMgbm90IGEgQk1QLCB0aGUgb3RoZXIgaXMgYWxzbyBub3QgYSBCTVAgb3IgaXMKCSMgdGhlIEJNUCBhdCBlbmQgb2YgdGhlIGFyYyAoYW5kIGl0IG9ubHkgaGFzIDEgaW5jb21pbmcgYXJjKS4KCSMgT3IgYm90aCBjYW4gYmUgQk1QcyB3aXRoIG5vIGluY29taW5nIGFyY3MuCglpZiB7JGEgZXEgJGIgfHwgJGFyY25vcygkYSkgZXEge319IHsKCSAgICByZXR1cm4gMAoJfQoJIyBhc3NlcnQge1tsbGVuZ3RoICRhcmNub3MoJGEpXSA9PSAxfQoJc2V0IGFyYyBbbGluZGV4ICRhcmNub3MoJGEpIDBdCglzZXQgaSBbbHNlYXJjaCAtZXhhY3QgJGFyY2lkcygkYXJjKSAkYV0KCXNldCBqIFtsc2VhcmNoIC1leGFjdCAkYXJjaWRzKCRhcmMpICRiXQoJaWYgeyRpIDwgMCB8fCAkaSA+ICRqfSB7CgkgICAgcmV0dXJuIDEKCX0gZWxzZSB7CgkgICAgcmV0dXJuIC0xCgl9CiAgICB9CgogICAgaWYgeyFbaW5mbyBleGlzdHMgYXJjb3V0KCRhKV19IHsKCXNldCBhcmMgW2xpbmRleCAkYXJjbm9zKCRhKSAwXQoJaWYge1tpbmZvIGV4aXN0cyBhcmNlbmQoJGFyYyldfSB7CgkgICAgc2V0IGFlbmQgJGFyY2VuZCgkYXJjKQoJfSBlbHNlIHsKCSAgICBzZXQgYWVuZCB7fQoJfQoJc2V0IGEgJGFyY3N0YXJ0KCRhcmMpCiAgICB9IGVsc2UgewoJc2V0IGFlbmQgJGEKICAgIH0KICAgIGlmIHshW2luZm8gZXhpc3RzIGFyY291dCgkYildfSB7CglzZXQgYXJjIFtsaW5kZXggJGFyY25vcygkYikgMF0KCWlmIHtbaW5mbyBleGlzdHMgYXJjZW5kKCRhcmMpXX0gewoJICAgIHNldCBiZW5kICRhcmNlbmQoJGFyYykKCX0gZWxzZSB7CgkgICAgc2V0IGJlbmQge30KCX0KCXNldCBiICRhcmNzdGFydCgkYXJjKQogICAgfSBlbHNlIHsKCXNldCBiZW5kICRiCiAgICB9CiAgICBpZiB7JGEgZXEgJGJlbmR9IHsKCXJldHVybiAxCiAgICB9CiAgICBpZiB7JGIgZXEgJGFlbmR9IHsKCXJldHVybiAtMQogICAgfQogICAgaWYge1tpbmZvIGV4aXN0cyBjYWNoZWRfaXNhbmMoJGEsJGJlbmQpXX0gewoJaWYgeyRjYWNoZWRfaXNhbmMoJGEsJGJlbmQpfSB7CgkgICAgcmV0dXJuIDEKCX0KICAgIH0KICAgIGlmIHtbaW5mbyBleGlzdHMgY2FjaGVkX2lzYW5jKCRiLCRhZW5kKV19IHsKCWlmIHskY2FjaGVkX2lzYW5jKCRiLCRhZW5kKX0gewoJICAgIHJldHVybiAtMQoJfQoJaWYge1tpbmZvIGV4aXN0cyBjYWNoZWRfaXNhbmMoJGEsJGJlbmQpXX0gewoJICAgIHJldHVybiAwCgl9CiAgICB9CgogICAgc2V0IHRvZG8gW2xpc3QgJGEgJGJdCiAgICBzZXQgYW5jKCRhKSBhCiAgICBzZXQgYW5jKCRiKSBiCiAgICBmb3Ige3NldCBpIDB9IHskaSA8IFtsbGVuZ3RoICR0b2RvXX0ge2luY3IgaX0gewoJc2V0IHggW2xpbmRleCAkdG9kbyAkaV0KCWlmIHskYW5jKCR4KSBlcSB7fX0gewoJICAgIGNvbnRpbnVlCgl9Cglmb3JlYWNoIGFyYyAkYXJjbm9zKCR4KSB7CgkgICAgc2V0IHhkICRhcmNzdGFydCgkYXJjKQoJICAgIGlmIHskeGQgZXEgJGJlbmR9IHsKCQlzZXQgY2FjaGVkX2lzYW5jKCRhLCRiZW5kKSAxCgkJc2V0IGNhY2hlZF9pc2FuYygkYiwkYWVuZCkgMAoJCXJldHVybiAxCgkgICAgfSBlbHNlaWYgeyR4ZCBlcSAkYWVuZH0gewoJCXNldCBjYWNoZWRfaXNhbmMoJGIsJGFlbmQpIDEKCQlzZXQgY2FjaGVkX2lzYW5jKCRhLCRiZW5kKSAwCgkJcmV0dXJuIC0xCgkgICAgfQoJICAgIGlmIHshW2luZm8gZXhpc3RzIGFuYygkeGQpXX0gewoJCXNldCBhbmMoJHhkKSAkYW5jKCR4KQoJCWxhcHBlbmQgdG9kbyAkeGQKCSAgICB9IGVsc2VpZiB7JGFuYygkeGQpIG5lICRhbmMoJHgpfSB7CgkJc2V0IGFuYygkeGQpIHt9CgkgICAgfQoJfQogICAgfQogICAgc2V0IGNhY2hlZF9pc2FuYygkYSwkYmVuZCkgMAogICAgc2V0IGNhY2hlZF9pc2FuYygkYiwkYWVuZCkgMAogICAgcmV0dXJuIDAKfQoKIyBUaGlzIGlkZW50aWZpZXMgd2hldGhlciAkZGVzYyBoYXMgYW4gYW5jZXN0b3IgdGhhdCBpcwojIGEgZ3Jvd2luZyB0aXAgb2YgdGhlIGdyYXBoIGFuZCB3aGljaCBpcyBub3QgYW4gYW5jZXN0b3Igb2YgJGFuYwojIGFuZCByZXR1cm5zIDAgaWYgc28gYW5kIDEgaWYgbm90LgojIElmIHdlIHN1YnNlcXVlbnRseSBkaXNjb3ZlciBhIHRhZyBvbiBzdWNoIGEgZ3Jvd2luZyB0aXAsIGFuZCB0aGF0CiMgdHVybnMgb3V0IHRvIGJlIGEgZGVzY2VuZGVudCBvZiAkYW5jICh3aGljaCBpdCBjb3VsZCwgc2luY2Ugd2UKIyBkb24ndCBuZWNlc3NhcmlseSBzZWUgY2hpbGRyZW4gYmVmb3JlIHBhcmVudHMpLCB0aGVuICRkZXNjCiMgaXNuJ3QgYSBnb29kIGNob2ljZSB0byBkaXNwbGF5IGFzIGEgZGVzY2VuZGVudCB0YWcgb2YKIyAkYW5jIChzaW5jZSBpdCBpcyB0aGUgZGVzY2VuZGVudCBvZiBhbm90aGVyIHRhZyB3aGljaCBpcwojIGEgZGVzY2VuZGVudCBvZiAkYW5jKS4gIFNpbWlsYXJseSwgJGFuYyBpc24ndCBhIGdvb2QgY2hvaWNlIHRvCiMgZGlzcGxheSBhcyBhIGFuY2VzdG9yIHRhZyBvZiAkZGVzYy4KIwpwcm9jIGlzX2NlcnRhaW4ge2Rlc2MgYW5jfSB7CiAgICBnbG9iYWwgYXJjbm9zIGFyY291dCBhcmNzdGFydCBhcmNlbmQgZ3Jvd2luZyBwcm9ibGVtcwoKICAgIHNldCBjZXJ0YWluIHt9CiAgICBpZiB7W2xsZW5ndGggJGFyY25vcygkYW5jKV0gPT0gMX0gewoJIyB0YWdzIG9uIHRoZSBzYW1lIGFyYyBhcmUgY2VydGFpbgoJaWYgeyRhcmNub3MoJGRlc2MpIGVxICRhcmNub3MoJGFuYyl9IHsKCSAgICByZXR1cm4gMQoJfQoJaWYgeyFbaW5mbyBleGlzdHMgYXJjb3V0KCRhbmMpXX0gewoJICAgICMgaWYgJGFuYyBpcyBwYXJ0d2F5IGFsb25nIGFuIGFyYywgdXNlIHRoZSBzdGFydCBvZiB0aGUgYXJjIGluc3RlYWQKCSAgICBzZXQgYSBbbGluZGV4ICRhcmNub3MoJGFuYykgMF0KCSAgICBzZXQgYW5jICRhcmNzdGFydCgkYSkKCX0KICAgIH0KICAgIGlmIHtbbGxlbmd0aCAkYXJjbm9zKCRkZXNjKV0gPiAxIHx8IFtpbmZvIGV4aXN0cyBhcmNvdXQoJGRlc2MpXX0gewoJc2V0IHggJGRlc2MKICAgIH0gZWxzZSB7CglzZXQgYSBbbGluZGV4ICRhcmNub3MoJGRlc2MpIDBdCglzZXQgeCAkYXJjZW5kKCRhKQogICAgfQogICAgaWYgeyR4ID09ICRhbmN9IHsKCXJldHVybiAxCiAgICB9CiAgICBzZXQgYW5jbGlzdCBbbGlzdCAkeF0KICAgIHNldCBkbCgkeCkgMQogICAgc2V0IG5uaCAxCiAgICBzZXQgbmdyb3dhbmMgMAogICAgZm9yIHtzZXQgaSAwfSB7JGkgPCBbbGxlbmd0aCAkYW5jbGlzdF0gJiYgKCRubmggPiAwIHx8ICRuZ3Jvd2FuYyA+IDApfSB7aW5jciBpfSB7CglzZXQgeCBbbGluZGV4ICRhbmNsaXN0ICRpXQoJaWYgeyRkbCgkeCl9IHsKCSAgICBpbmNyIG5uaCAtMQoJfQoJc2V0IGRvbmUoJHgpIDEKCWZvcmVhY2ggYSAkYXJjb3V0KCR4KSB7CgkgICAgaWYge1tpbmZvIGV4aXN0cyBncm93aW5nKCRhKV19IHsKCQlpZiB7IVtpbmZvIGV4aXN0cyBncm93YW5jKCR4KV0gJiYgJGRsKCR4KX0gewoJCSAgICBzZXQgZ3Jvd2FuYygkeCkgMQoJCSAgICBpbmNyIG5ncm93YW5jCgkJfQoJICAgIH0gZWxzZSB7CgkJc2V0IHkgJGFyY2VuZCgkYSkKCQlpZiB7W2luZm8gZXhpc3RzIGRsKCR5KV19IHsKCQkgICAgaWYgeyRkbCgkeSl9IHsKCQkJaWYgeyEkZGwoJHgpfSB7CgkJCSAgICBzZXQgZGwoJHkpIDAKCQkJICAgIGlmIHshW2luZm8gZXhpc3RzIGRvbmUoJHkpXX0gewoJCQkJaW5jciBubmggLTEKCQkJICAgIH0KCQkJICAgIGlmIHtbaW5mbyBleGlzdHMgZ3Jvd2FuYygkeCldfSB7CgkJCQlpbmNyIG5ncm93YW5jIC0xCgkJCSAgICB9CgkJCSAgICBzZXQgeGwgW2xpc3QgJHldCgkJCSAgICBmb3Ige3NldCBrIDB9IHskayA8IFtsbGVuZ3RoICR4bF19IHtpbmNyIGt9IHsKCQkJCXNldCB6IFtsaW5kZXggJHhsICRrXQoJCQkJZm9yZWFjaCBjICRhcmNvdXQoJHopIHsKCQkJCSAgICBpZiB7W2luZm8gZXhpc3RzIGFyY2VuZCgkYyldfSB7CgkJCQkJc2V0IHYgJGFyY2VuZCgkYykKCQkJCQlpZiB7W2luZm8gZXhpc3RzIGRsKCR2KV0gJiYgJGRsKCR2KX0gewoJCQkJCSAgICBzZXQgZGwoJHYpIDAKCQkJCQkgICAgaWYgeyFbaW5mbyBleGlzdHMgZG9uZSgkdildfSB7CgkJCQkJCWluY3Igbm5oIC0xCgkJCQkJICAgIH0KCQkJCQkgICAgaWYge1tpbmZvIGV4aXN0cyBncm93YW5jKCR2KV19IHsKCQkJCQkJaW5jciBuZ3Jvd2FuYyAtMQoJCQkJCSAgICB9CgkJCQkJICAgIGxhcHBlbmQgeGwgJHYKCQkJCQl9CgkJCQkgICAgfQoJCQkJfQoJCQkgICAgfQoJCQl9CgkJICAgIH0KCQl9IGVsc2VpZiB7JHkgZXEgJGFuYyB8fCAhJGRsKCR4KX0gewoJCSAgICBzZXQgZGwoJHkpIDAKCQkgICAgbGFwcGVuZCBhbmNsaXN0ICR5CgkJfSBlbHNlIHsKCQkgICAgc2V0IGRsKCR5KSAxCgkJICAgIGxhcHBlbmQgYW5jbGlzdCAkeQoJCSAgICBpbmNyIG5uaAoJCX0KCSAgICB9Cgl9CiAgICB9CiAgICBmb3JlYWNoIHggW2FycmF5IG5hbWVzIGdyb3dhbmNdIHsKCWlmIHskZGwoJHgpfSB7CgkgICAgcmV0dXJuIDAKCX0KCXJldHVybiAwCiAgICB9CiAgICByZXR1cm4gMQp9Cgpwcm9jIHZhbGlkYXRlX2FyY3RhZ3Mge2F9IHsKICAgIGdsb2JhbCBhcmN0YWdzIGlkdGFncwoKICAgIHNldCBpIC0xCiAgICBzZXQgbmEgJGFyY3RhZ3MoJGEpCiAgICBmb3JlYWNoIGlkICRhcmN0YWdzKCRhKSB7CglpbmNyIGkKCWlmIHshW2luZm8gZXhpc3RzIGlkdGFncygkaWQpXX0gewoJICAgIHNldCBuYSBbbHJlcGxhY2UgJG5hICRpICRpXQoJICAgIGluY3IgaSAtMQoJfQogICAgfQogICAgc2V0IGFyY3RhZ3MoJGEpICRuYQp9Cgpwcm9jIHZhbGlkYXRlX2FyY2hlYWRzIHthfSB7CiAgICBnbG9iYWwgYXJjaGVhZHMgaWRoZWFkcwoKICAgIHNldCBpIC0xCiAgICBzZXQgbmEgJGFyY2hlYWRzKCRhKQogICAgZm9yZWFjaCBpZCAkYXJjaGVhZHMoJGEpIHsKCWluY3IgaQoJaWYgeyFbaW5mbyBleGlzdHMgaWRoZWFkcygkaWQpXX0gewoJICAgIHNldCBuYSBbbHJlcGxhY2UgJG5hICRpICRpXQoJICAgIGluY3IgaSAtMQoJfQogICAgfQogICAgc2V0IGFyY2hlYWRzKCRhKSAkbmEKfQoKIyBSZXR1cm4gdGhlIGxpc3Qgb2YgSURzIHRoYXQgaGF2ZSB0YWdzIHRoYXQgYXJlIGRlc2NlbmRlbnRzIG9mIGlkLAojIGlnbm9yaW5nIElEcyB0aGF0IGFyZSBkZXNjZW5kZW50cyBvZiBJRHMgYWxyZWFkeSByZXBvcnRlZC4KcHJvYyBkZXNjdGFncyB7aWR9IHsKICAgIGdsb2JhbCBhcmNub3MgYXJjc3RhcnQgYXJjaWRzIGFyY3RhZ3MgaWR0YWdzIGFsbHBhcmVudHMKICAgIGdsb2JhbCBncm93aW5nIGNhY2hlZF9kdGFncwoKICAgIGlmIHshW2luZm8gZXhpc3RzIGFsbHBhcmVudHMoJGlkKV19IHsKCXJldHVybiB7fQogICAgfQogICAgc2V0IHQxIFtjbG9jayBjbGlja3MgLW1pbGxpc2Vjb25kc10KICAgIHNldCBhcmdpZCAkaWQKICAgIGlmIHtbbGxlbmd0aCAkYXJjbm9zKCRpZCldID09IDEgJiYgW2xsZW5ndGggJGFsbHBhcmVudHMoJGlkKV0gPT0gMX0gewoJIyBwYXJ0LXdheSBhbG9uZyBhbiBhcmM7IGNoZWNrIHRoYXQgYXJjIGZpcnN0CglzZXQgYSBbbGluZGV4ICRhcmNub3MoJGlkKSAwXQoJaWYgeyRhcmN0YWdzKCRhKSBuZSB7fX0gewoJICAgIHZhbGlkYXRlX2FyY3RhZ3MgJGEKCSAgICBzZXQgaSBbbHNlYXJjaCAtZXhhY3QgJGFyY2lkcygkYSkgJGlkXQoJICAgIHNldCB0aWQge30KCSAgICBmb3JlYWNoIHQgJGFyY3RhZ3MoJGEpIHsKCQlzZXQgaiBbbHNlYXJjaCAtZXhhY3QgJGFyY2lkcygkYSkgJHRdCgkJaWYgeyRqID49ICRpfSBicmVhawoJCXNldCB0aWQgJHQKCSAgICB9CgkgICAgaWYgeyR0aWQgbmUge319IHsKCQlyZXR1cm4gJHRpZAoJICAgIH0KCX0KCXNldCBpZCAkYXJjc3RhcnQoJGEpCglpZiB7W2luZm8gZXhpc3RzIGlkdGFncygkaWQpXX0gewoJICAgIHJldHVybiAkaWQKCX0KICAgIH0KICAgIGlmIHtbaW5mbyBleGlzdHMgY2FjaGVkX2R0YWdzKCRpZCldfSB7CglyZXR1cm4gJGNhY2hlZF9kdGFncygkaWQpCiAgICB9CgogICAgc2V0IG9yaWdpZCAkaWQKICAgIHNldCB0b2RvIFtsaXN0ICRpZF0KICAgIHNldCBxdWV1ZWQoJGlkKSAxCiAgICBzZXQgbmMgMQogICAgZm9yIHtzZXQgaSAwfSB7JGkgPCBbbGxlbmd0aCAkdG9kb10gJiYgJG5jID4gMH0ge2luY3IgaX0gewoJc2V0IGlkIFtsaW5kZXggJHRvZG8gJGldCglzZXQgZG9uZSgkaWQpIDEKCXNldCB0YSBbaW5mbyBleGlzdHMgaGFzdGFnZ2VkYW5jZXN0b3IoJGlkKV0KCWlmIHshJHRhfSB7CgkgICAgaW5jciBuYyAtMQoJfQoJIyBpZ25vcmUgdGFncyBvbiBzdGFydGluZyBub2RlCglpZiB7ISR0YSAmJiAkaSA+IDB9IHsKCSAgICBpZiB7W2luZm8gZXhpc3RzIGlkdGFncygkaWQpXX0gewoJCXNldCB0YWdsb2MoJGlkKSAkaWQKCQlzZXQgdGEgMQoJICAgIH0gZWxzZWlmIHtbaW5mbyBleGlzdHMgY2FjaGVkX2R0YWdzKCRpZCldfSB7CgkJc2V0IHRhZ2xvYygkaWQpICRjYWNoZWRfZHRhZ3MoJGlkKQoJCXNldCB0YSAxCgkgICAgfQoJfQoJZm9yZWFjaCBhICRhcmNub3MoJGlkKSB7CgkgICAgc2V0IGQgJGFyY3N0YXJ0KCRhKQoJICAgIGlmIHshJHRhICYmICRhcmN0YWdzKCRhKSBuZSB7fX0gewoJCXZhbGlkYXRlX2FyY3RhZ3MgJGEKCQlpZiB7JGFyY3RhZ3MoJGEpIG5lIHt9fSB7CgkJICAgIGxhcHBlbmQgdGFnbG9jKCRpZCkgW2xpbmRleCAkYXJjdGFncygkYSkgZW5kXQoJCX0KCSAgICB9CgkgICAgaWYgeyR0YSB8fCAkYXJjdGFncygkYSkgbmUge319IHsKCQlzZXQgdG9tYXJrIFtsaXN0ICRkXQoJCWZvciB7c2V0IGogMH0geyRqIDwgW2xsZW5ndGggJHRvbWFya119IHtpbmNyIGp9IHsKCQkgICAgc2V0IGRkIFtsaW5kZXggJHRvbWFyayAkal0KCQkgICAgaWYgeyFbaW5mbyBleGlzdHMgaGFzdGFnZ2VkYW5jZXN0b3IoJGRkKV19IHsKCQkJaWYge1tpbmZvIGV4aXN0cyBkb25lKCRkZCldfSB7CgkJCSAgICBmb3JlYWNoIGIgJGFyY25vcygkZGQpIHsKCQkJCWxhcHBlbmQgdG9tYXJrICRhcmNzdGFydCgkYikKCQkJICAgIH0KCQkJICAgIGlmIHtbaW5mbyBleGlzdHMgdGFnbG9jKCRkZCldfSB7CgkJCQl1bnNldCB0YWdsb2MoJGRkKQoJCQkgICAgfQoJCQl9IGVsc2VpZiB7W2luZm8gZXhpc3RzIHF1ZXVlZCgkZGQpXX0gewoJCQkgICAgaW5jciBuYyAtMQoJCQl9CgkJCXNldCBoYXN0YWdnZWRhbmNlc3RvcigkZGQpIDEKCQkgICAgfQoJCX0KCSAgICB9CgkgICAgaWYgeyFbaW5mbyBleGlzdHMgcXVldWVkKCRkKV19IHsKCQlsYXBwZW5kIHRvZG8gJGQKCQlzZXQgcXVldWVkKCRkKSAxCgkJaWYgeyFbaW5mbyBleGlzdHMgaGFzdGFnZ2VkYW5jZXN0b3IoJGQpXX0gewoJCSAgICBpbmNyIG5jCgkJfQoJICAgIH0KCX0KICAgIH0KICAgIHNldCB0YWdzIHt9CiAgICBmb3JlYWNoIGlkIFthcnJheSBuYW1lcyB0YWdsb2NdIHsKCWlmIHshW2luZm8gZXhpc3RzIGhhc3RhZ2dlZGFuY2VzdG9yKCRpZCldfSB7CgkgICAgZm9yZWFjaCB0ICR0YWdsb2MoJGlkKSB7CgkJaWYge1tsc2VhcmNoIC1leGFjdCAkdGFncyAkdF0gPCAwfSB7CgkJICAgIGxhcHBlbmQgdGFncyAkdAoJCX0KCSAgICB9Cgl9CiAgICB9CiAgICBzZXQgdDIgW2Nsb2NrIGNsaWNrcyAtbWlsbGlzZWNvbmRzXQogICAgc2V0IGxvb3BpeCAkaQoKICAgICMgcmVtb3ZlIHRhZ3MgdGhhdCBhcmUgZGVzY2VuZGVudHMgb2Ygb3RoZXIgdGFncwogICAgZm9yIHtzZXQgaSAwfSB7JGkgPCBbbGxlbmd0aCAkdGFnc119IHtpbmNyIGl9IHsKCXNldCBhIFtsaW5kZXggJHRhZ3MgJGldCglmb3Ige3NldCBqIDB9IHskaiA8ICRpfSB7aW5jciBqfSB7CgkgICAgc2V0IGIgW2xpbmRleCAkdGFncyAkal0KCSAgICBzZXQgciBbYW5jX29yX2Rlc2MgJGEgJGJdCgkgICAgaWYgeyRyID09IDF9IHsKCQlzZXQgdGFncyBbbHJlcGxhY2UgJHRhZ3MgJGogJGpdCgkJaW5jciBqIC0xCgkJaW5jciBpIC0xCgkgICAgfSBlbHNlaWYgeyRyID09IC0xfSB7CgkJc2V0IHRhZ3MgW2xyZXBsYWNlICR0YWdzICRpICRpXQoJCWluY3IgaSAtMQoJCWJyZWFrCgkgICAgfQoJfQogICAgfQoKICAgIGlmIHtbYXJyYXkgbmFtZXMgZ3Jvd2luZ10gbmUge319IHsKCSMgZ3JhcGggaXNuJ3QgZmluaXNoZWQsIG5lZWQgdG8gY2hlY2sgaWYgYW55IHRhZyBjb3VsZCBnZXQKCSMgZWNsaXBzZWQgYnkgYW5vdGhlciB0YWcgY29taW5nIGxhdGVyLiAgU2ltcGx5IGlnbm9yZSBhbnkKCSMgdGFncyB0aGF0IGNvdWxkIGxhdGVyIGdldCBlY2xpcHNlZC4KCXNldCBjdGFncyB7fQoJZm9yZWFjaCB0ICR0YWdzIHsKCSAgICBpZiB7W2lzX2NlcnRhaW4gJHQgJG9yaWdpZF19IHsKCQlsYXBwZW5kIGN0YWdzICR0CgkgICAgfQoJfQoJaWYgeyR0YWdzIGVxICRjdGFnc30gewoJICAgIHNldCBjYWNoZWRfZHRhZ3MoJG9yaWdpZCkgJHRhZ3MKCX0gZWxzZSB7CgkgICAgc2V0IHRhZ3MgJGN0YWdzCgl9CiAgICB9IGVsc2UgewoJc2V0IGNhY2hlZF9kdGFncygkb3JpZ2lkKSAkdGFncwogICAgfQogICAgc2V0IHQzIFtjbG9jayBjbGlja3MgLW1pbGxpc2Vjb25kc10KICAgIGlmIHswICYmICR0MyAtICR0MSA+PSAxMDB9IHsKCXB1dHMgIml0ZXJhdGluZyBkZXNjZW5kZW50cyAoJGxvb3BpeC9bbGxlbmd0aCAkdG9kb10gbm9kZXMpIHRvb2tcCiAgICAJICAgIFtleHByIHskdDItJHQxfV0rW2V4cHIgeyR0My0kdDJ9XW1zLCAkbmMgY2FuZGlkYXRlcyBsZWZ0IgogICAgfQogICAgcmV0dXJuICR0YWdzCn0KCnByb2MgYW5jdGFncyB7aWR9IHsKICAgIGdsb2JhbCBhcmNub3MgYXJjaWRzIGFyY291dCBhcmNlbmQgYXJjdGFncyBpZHRhZ3MgYWxscGFyZW50cwogICAgZ2xvYmFsIGdyb3dpbmcgY2FjaGVkX2F0YWdzCgogICAgaWYgeyFbaW5mbyBleGlzdHMgYWxscGFyZW50cygkaWQpXX0gewoJcmV0dXJuIHt9CiAgICB9CiAgICBzZXQgdDEgW2Nsb2NrIGNsaWNrcyAtbWlsbGlzZWNvbmRzXQogICAgc2V0IGFyZ2lkICRpZAogICAgaWYge1tsbGVuZ3RoICRhcmNub3MoJGlkKV0gPT0gMSAmJiBbbGxlbmd0aCAkYWxscGFyZW50cygkaWQpXSA9PSAxfSB7CgkjIHBhcnQtd2F5IGFsb25nIGFuIGFyYzsgY2hlY2sgdGhhdCBhcmMgZmlyc3QKCXNldCBhIFtsaW5kZXggJGFyY25vcygkaWQpIDBdCglpZiB7JGFyY3RhZ3MoJGEpIG5lIHt9fSB7CgkgICAgdmFsaWRhdGVfYXJjdGFncyAkYQoJICAgIHNldCBpIFtsc2VhcmNoIC1leGFjdCAkYXJjaWRzKCRhKSAkaWRdCgkgICAgZm9yZWFjaCB0ICRhcmN0YWdzKCRhKSB7CgkJc2V0IGogW2xzZWFyY2ggLWV4YWN0ICRhcmNpZHMoJGEpICR0XQoJCWlmIHskaiA+ICRpfSB7CgkJICAgIHJldHVybiAkdAoJCX0KCSAgICB9Cgl9CglpZiB7IVtpbmZvIGV4aXN0cyBhcmNlbmQoJGEpXX0gewoJICAgIHJldHVybiB7fQoJfQoJc2V0IGlkICRhcmNlbmQoJGEpCglpZiB7W2luZm8gZXhpc3RzIGlkdGFncygkaWQpXX0gewoJICAgIHJldHVybiAkaWQKCX0KICAgIH0KICAgIGlmIHtbaW5mbyBleGlzdHMgY2FjaGVkX2F0YWdzKCRpZCldfSB7CglyZXR1cm4gJGNhY2hlZF9hdGFncygkaWQpCiAgICB9CgogICAgc2V0IG9yaWdpZCAkaWQKICAgIHNldCB0b2RvIFtsaXN0ICRpZF0KICAgIHNldCBxdWV1ZWQoJGlkKSAxCiAgICBzZXQgdGFnbGlzdCB7fQogICAgc2V0IG5jIDEKICAgIGZvciB7c2V0IGkgMH0geyRpIDwgW2xsZW5ndGggJHRvZG9dICYmICRuYyA+IDB9IHtpbmNyIGl9IHsKCXNldCBpZCBbbGluZGV4ICR0b2RvICRpXQoJc2V0IGRvbmUoJGlkKSAxCglzZXQgdGQgW2luZm8gZXhpc3RzIGhhc3RhZ2dlZGRlc2NlbmRlbnQoJGlkKV0KCWlmIHshJHRkfSB7CgkgICAgaW5jciBuYyAtMQoJfQoJIyBpZ25vcmUgdGFncyBvbiBzdGFydGluZyBub2RlCglpZiB7ISR0ZCAmJiAkaSA+IDB9IHsKCSAgICBpZiB7W2luZm8gZXhpc3RzIGlkdGFncygkaWQpXX0gewoJCXNldCB0YWdsb2MoJGlkKSAkaWQKCQlzZXQgdGQgMQoJICAgIH0gZWxzZWlmIHtbaW5mbyBleGlzdHMgY2FjaGVkX2F0YWdzKCRpZCldfSB7CgkJc2V0IHRhZ2xvYygkaWQpICRjYWNoZWRfYXRhZ3MoJGlkKQoJCXNldCB0ZCAxCgkgICAgfQoJfQoJZm9yZWFjaCBhICRhcmNvdXQoJGlkKSB7CgkgICAgaWYgeyEkdGQgJiYgJGFyY3RhZ3MoJGEpIG5lIHt9fSB7CgkJdmFsaWRhdGVfYXJjdGFncyAkYQoJCWlmIHskYXJjdGFncygkYSkgbmUge319IHsKCQkgICAgbGFwcGVuZCB0YWdsb2MoJGlkKSBbbGluZGV4ICRhcmN0YWdzKCRhKSAwXQoJCX0KCSAgICB9CgkgICAgaWYgeyFbaW5mbyBleGlzdHMgYXJjZW5kKCRhKV19IGNvbnRpbnVlCgkgICAgc2V0IGQgJGFyY2VuZCgkYSkKCSAgICBpZiB7JHRkIHx8ICRhcmN0YWdzKCRhKSBuZSB7fX0gewoJCXNldCB0b21hcmsgW2xpc3QgJGRdCgkJZm9yIHtzZXQgaiAwfSB7JGogPCBbbGxlbmd0aCAkdG9tYXJrXX0ge2luY3Igan0gewoJCSAgICBzZXQgZGQgW2xpbmRleCAkdG9tYXJrICRqXQoJCSAgICBpZiB7IVtpbmZvIGV4aXN0cyBoYXN0YWdnZWRkZXNjZW5kZW50KCRkZCldfSB7CgkJCWlmIHtbaW5mbyBleGlzdHMgZG9uZSgkZGQpXX0gewoJCQkgICAgZm9yZWFjaCBiICRhcmNvdXQoJGRkKSB7CgkJCQlpZiB7W2luZm8gZXhpc3RzIGFyY2VuZCgkYildfSB7CgkJCQkgICAgbGFwcGVuZCB0b21hcmsgJGFyY2VuZCgkYikKCQkJCX0KCQkJICAgIH0KCQkJICAgIGlmIHtbaW5mbyBleGlzdHMgdGFnbG9jKCRkZCldfSB7CgkJCQl1bnNldCB0YWdsb2MoJGRkKQoJCQkgICAgfQoJCQl9IGVsc2VpZiB7W2luZm8gZXhpc3RzIHF1ZXVlZCgkZGQpXX0gewoJCQkgICAgaW5jciBuYyAtMQoJCQl9CgkJCXNldCBoYXN0YWdnZWRkZXNjZW5kZW50KCRkZCkgMQoJCSAgICB9CgkJfQoJICAgIH0KCSAgICBpZiB7IVtpbmZvIGV4aXN0cyBxdWV1ZWQoJGQpXX0gewoJCWxhcHBlbmQgdG9kbyAkZAoJCXNldCBxdWV1ZWQoJGQpIDEKCQlpZiB7IVtpbmZvIGV4aXN0cyBoYXN0YWdnZWRkZXNjZW5kZW50KCRkKV19IHsKCQkgICAgaW5jciBuYwoJCX0KCSAgICB9Cgl9CiAgICB9CiAgICBzZXQgdDIgW2Nsb2NrIGNsaWNrcyAtbWlsbGlzZWNvbmRzXQogICAgc2V0IGxvb3BpeCAkaQogICAgc2V0IHRhZ3Mge30KICAgIGZvcmVhY2ggaWQgW2FycmF5IG5hbWVzIHRhZ2xvY10gewoJaWYgeyFbaW5mbyBleGlzdHMgaGFzdGFnZ2VkZGVzY2VuZGVudCgkaWQpXX0gewoJICAgIGZvcmVhY2ggdCAkdGFnbG9jKCRpZCkgewoJCWlmIHtbbHNlYXJjaCAtZXhhY3QgJHRhZ3MgJHRdIDwgMH0gewoJCSAgICBsYXBwZW5kIHRhZ3MgJHQKCQl9CgkgICAgfQoJfQogICAgfQoKICAgICMgcmVtb3ZlIHRhZ3MgdGhhdCBhcmUgYW5jZXN0b3JzIG9mIG90aGVyIHRhZ3MKICAgIGZvciB7c2V0IGkgMH0geyRpIDwgW2xsZW5ndGggJHRhZ3NdfSB7aW5jciBpfSB7CglzZXQgYSBbbGluZGV4ICR0YWdzICRpXQoJZm9yIHtzZXQgaiAwfSB7JGogPCAkaX0ge2luY3Igan0gewoJICAgIHNldCBiIFtsaW5kZXggJHRhZ3MgJGpdCgkgICAgc2V0IHIgW2FuY19vcl9kZXNjICRhICRiXQoJICAgIGlmIHskciA9PSAtMX0gewoJCXNldCB0YWdzIFtscmVwbGFjZSAkdGFncyAkaiAkal0KCQlpbmNyIGogLTEKCQlpbmNyIGkgLTEKCSAgICB9IGVsc2VpZiB7JHIgPT0gMX0gewoJCXNldCB0YWdzIFtscmVwbGFjZSAkdGFncyAkaSAkaV0KCQlpbmNyIGkgLTEKCQlicmVhawoJICAgIH0KCX0KICAgIH0KCiAgICBpZiB7W2FycmF5IG5hbWVzIGdyb3dpbmddIG5lIHt9fSB7CgkjIGdyYXBoIGlzbid0IGZpbmlzaGVkLCBuZWVkIHRvIGNoZWNrIGlmIGFueSB0YWcgY291bGQgZ2V0CgkjIGVjbGlwc2VkIGJ5IGFub3RoZXIgdGFnIGNvbWluZyBsYXRlci4gIFNpbXBseSBpZ25vcmUgYW55CgkjIHRhZ3MgdGhhdCBjb3VsZCBsYXRlciBnZXQgZWNsaXBzZWQuCglzZXQgY3RhZ3Mge30KCWZvcmVhY2ggdCAkdGFncyB7CgkgICAgaWYge1tpc19jZXJ0YWluICRvcmlnaWQgJHRdfSB7CgkJbGFwcGVuZCBjdGFncyAkdAoJICAgIH0KCX0KCWlmIHskdGFncyBlcSAkY3RhZ3N9IHsKCSAgICBzZXQgY2FjaGVkX2F0YWdzKCRvcmlnaWQpICR0YWdzCgl9IGVsc2UgewoJICAgIHNldCB0YWdzICRjdGFncwoJfQogICAgfSBlbHNlIHsKCXNldCBjYWNoZWRfYXRhZ3MoJG9yaWdpZCkgJHRhZ3MKICAgIH0KICAgIHNldCB0MyBbY2xvY2sgY2xpY2tzIC1taWxsaXNlY29uZHNdCiAgICBpZiB7MCAmJiAkdDMgLSAkdDEgPj0gMTAwfSB7CglwdXRzICJpdGVyYXRpbmcgYW5jZXN0b3JzICgkbG9vcGl4L1tsbGVuZ3RoICR0b2RvXSBub2RlcykgdG9va1wKICAgIAkgICAgW2V4cHIgeyR0Mi0kdDF9XStbZXhwciB7JHQzLSR0Mn1dbXMsICRuYyBjYW5kaWRhdGVzIGxlZnQiCiAgICB9CiAgICByZXR1cm4gJHRhZ3MKfQoKIyBSZXR1cm4gdGhlIGxpc3Qgb2YgSURzIHRoYXQgaGF2ZSBoZWFkcyB0aGF0IGFyZSBkZXNjZW5kZW50cyBvZiBpZCwKIyBpbmNsdWRpbmcgaWQgaXRzZWxmIGlmIGl0IGhhcyBhIGhlYWQuCnByb2MgZGVzY2hlYWRzIHtpZH0gewogICAgZ2xvYmFsIGFyY25vcyBhcmNzdGFydCBhcmNpZHMgYXJjaGVhZHMgaWRoZWFkcyBjYWNoZWRfZGhlYWRzCiAgICBnbG9iYWwgYWxscGFyZW50cwoKICAgIGlmIHshW2luZm8gZXhpc3RzIGFsbHBhcmVudHMoJGlkKV19IHsKCXJldHVybiB7fQogICAgfQogICAgc2V0IGFyZXQge30KICAgIGlmIHtbbGxlbmd0aCAkYXJjbm9zKCRpZCldID09IDEgJiYgW2xsZW5ndGggJGFsbHBhcmVudHMoJGlkKV0gPT0gMX0gewoJIyBwYXJ0LXdheSBhbG9uZyBhbiBhcmM7IGNoZWNrIGl0IGZpcnN0CglzZXQgYSBbbGluZGV4ICRhcmNub3MoJGlkKSAwXQoJaWYgeyRhcmNoZWFkcygkYSkgbmUge319IHsKCSAgICB2YWxpZGF0ZV9hcmNoZWFkcyAkYQoJICAgIHNldCBpIFtsc2VhcmNoIC1leGFjdCAkYXJjaWRzKCRhKSAkaWRdCgkgICAgZm9yZWFjaCB0ICRhcmNoZWFkcygkYSkgewoJCXNldCBqIFtsc2VhcmNoIC1leGFjdCAkYXJjaWRzKCRhKSAkdF0KCQlpZiB7JGogPiAkaX0gYnJlYWsKCQlsYXBwZW5kIGFyZXQgJHQKCSAgICB9Cgl9CglzZXQgaWQgJGFyY3N0YXJ0KCRhKQogICAgfQogICAgc2V0IG9yaWdpZCAkaWQKICAgIHNldCB0b2RvIFtsaXN0ICRpZF0KICAgIHNldCBzZWVuKCRpZCkgMQogICAgc2V0IHJldCB7fQogICAgZm9yIHtzZXQgaSAwfSB7JGkgPCBbbGxlbmd0aCAkdG9kb119IHtpbmNyIGl9IHsKCXNldCBpZCBbbGluZGV4ICR0b2RvICRpXQoJaWYge1tpbmZvIGV4aXN0cyBjYWNoZWRfZGhlYWRzKCRpZCldfSB7CgkgICAgc2V0IHJldCBbY29uY2F0ICRyZXQgJGNhY2hlZF9kaGVhZHMoJGlkKV0KCX0gZWxzZSB7CgkgICAgaWYge1tpbmZvIGV4aXN0cyBpZGhlYWRzKCRpZCldfSB7CgkJbGFwcGVuZCByZXQgJGlkCgkgICAgfQoJICAgIGZvcmVhY2ggYSAkYXJjbm9zKCRpZCkgewoJCWlmIHskYXJjaGVhZHMoJGEpIG5lIHt9fSB7CgkJICAgIHZhbGlkYXRlX2FyY2hlYWRzICRhCgkJICAgIGlmIHskYXJjaGVhZHMoJGEpIG5lIHt9fSB7CgkJCXNldCByZXQgW2NvbmNhdCAkcmV0ICRhcmNoZWFkcygkYSldCgkJICAgIH0KCQl9CgkJc2V0IGQgJGFyY3N0YXJ0KCRhKQoJCWlmIHshW2luZm8gZXhpc3RzIHNlZW4oJGQpXX0gewoJCSAgICBsYXBwZW5kIHRvZG8gJGQKCQkgICAgc2V0IHNlZW4oJGQpIDEKCQl9CgkgICAgfQoJfQogICAgfQogICAgc2V0IHJldCBbbHNvcnQgLXVuaXF1ZSAkcmV0XQogICAgc2V0IGNhY2hlZF9kaGVhZHMoJG9yaWdpZCkgJHJldAogICAgcmV0dXJuIFtjb25jYXQgJHJldCAkYXJldF0KfQoKcHJvYyBhZGRlZHRhZyB7aWR9IHsKICAgIGdsb2JhbCBhcmNub3MgYXJjb3V0IGNhY2hlZF9kdGFncyBjYWNoZWRfYXRhZ3MKCiAgICBpZiB7IVtpbmZvIGV4aXN0cyBhcmNub3MoJGlkKV19IHJldHVybgogICAgaWYgeyFbaW5mbyBleGlzdHMgYXJjb3V0KCRpZCldfSB7CglyZWNhbGNhcmMgW2xpbmRleCAkYXJjbm9zKCRpZCkgMF0KICAgIH0KICAgIGNhdGNoIHt1bnNldCBjYWNoZWRfZHRhZ3N9CiAgICBjYXRjaCB7dW5zZXQgY2FjaGVkX2F0YWdzfQp9Cgpwcm9jIGFkZGVkaGVhZCB7aGlkIGhlYWR9IHsKICAgIGdsb2JhbCBhcmNub3MgYXJjb3V0IGNhY2hlZF9kaGVhZHMKCiAgICBpZiB7IVtpbmZvIGV4aXN0cyBhcmNub3MoJGhpZCldfSByZXR1cm4KICAgIGlmIHshW2luZm8gZXhpc3RzIGFyY291dCgkaGlkKV19IHsKCXJlY2FsY2FyYyBbbGluZGV4ICRhcmNub3MoJGhpZCkgMF0KICAgIH0KICAgIGNhdGNoIHt1bnNldCBjYWNoZWRfZGhlYWRzfQp9Cgpwcm9jIHJlbW92ZWRoZWFkIHtoaWQgaGVhZH0gewogICAgZ2xvYmFsIGNhY2hlZF9kaGVhZHMKCiAgICBjYXRjaCB7dW5zZXQgY2FjaGVkX2RoZWFkc30KfQoKcHJvYyBtb3ZlZGhlYWQge2hpZCBoZWFkfSB7CiAgICBnbG9iYWwgYXJjbm9zIGFyY291dCBjYWNoZWRfZGhlYWRzCgogICAgaWYgeyFbaW5mbyBleGlzdHMgYXJjbm9zKCRoaWQpXX0gcmV0dXJuCiAgICBpZiB7IVtpbmZvIGV4aXN0cyBhcmNvdXQoJGhpZCldfSB7CglyZWNhbGNhcmMgW2xpbmRleCAkYXJjbm9zKCRoaWQpIDBdCiAgICB9CiAgICBjYXRjaCB7dW5zZXQgY2FjaGVkX2RoZWFkc30KfQoKcHJvYyBjaGFuZ2VkcmVmcyB7fSB7CiAgICBnbG9iYWwgY2FjaGVkX2RoZWFkcyBjYWNoZWRfZHRhZ3MgY2FjaGVkX2F0YWdzCiAgICBnbG9iYWwgYXJjdGFncyBhcmNoZWFkcyBhcmNub3MgYXJjb3V0IGlkaGVhZHMgaWR0YWdzCgogICAgZm9yZWFjaCBpZCBbY29uY2F0IFthcnJheSBuYW1lcyBpZGhlYWRzXSBbYXJyYXkgbmFtZXMgaWR0YWdzXV0gewoJaWYge1tpbmZvIGV4aXN0cyBhcmNub3MoJGlkKV0gJiYgIVtpbmZvIGV4aXN0cyBhcmNvdXQoJGlkKV19IHsKCSAgICBzZXQgYSBbbGluZGV4ICRhcmNub3MoJGlkKSAwXQoJICAgIGlmIHshW2luZm8gZXhpc3RzIGRvbmVhcmMoJGEpXX0gewoJCXJlY2FsY2FyYyAkYQoJCXNldCBkb25lYXJjKCRhKSAxCgkgICAgfQoJfQogICAgfQogICAgY2F0Y2gge3Vuc2V0IGNhY2hlZF9kdGFnc30KICAgIGNhdGNoIHt1bnNldCBjYWNoZWRfYXRhZ3N9CiAgICBjYXRjaCB7dW5zZXQgY2FjaGVkX2RoZWFkc30KfQoKcHJvYyByZXJlYWRyZWZzIHt9IHsKICAgIGdsb2JhbCBpZHRhZ3MgaWRoZWFkcyBpZG90aGVycmVmcyBtYWluaGVhZAoKICAgIHNldCByZWZpZHMgW2NvbmNhdCBbYXJyYXkgbmFtZXMgaWR0YWdzXSBcCgkJICAgIFthcnJheSBuYW1lcyBpZGhlYWRzXSBbYXJyYXkgbmFtZXMgaWRvdGhlcnJlZnNdXQogICAgZm9yZWFjaCBpZCAkcmVmaWRzIHsKCWlmIHshW2luZm8gZXhpc3RzIHJlZigkaWQpXX0gewoJICAgIHNldCByZWYoJGlkKSBbbGlzdHJlZnMgJGlkXQoJfQogICAgfQogICAgc2V0IG9sZG1haW5oZWFkICRtYWluaGVhZAogICAgcmVhZHJlZnMKICAgIGNoYW5nZWRyZWZzCiAgICBzZXQgcmVmaWRzIFtsc29ydCAtdW5pcXVlIFtjb25jYXQgJHJlZmlkcyBbYXJyYXkgbmFtZXMgaWR0YWdzXSBcCgkJCVthcnJheSBuYW1lcyBpZGhlYWRzXSBbYXJyYXkgbmFtZXMgaWRvdGhlcnJlZnNdXV0KICAgIGZvcmVhY2ggaWQgJHJlZmlkcyB7CglzZXQgdiBbbGlzdHJlZnMgJGlkXQoJaWYgeyFbaW5mbyBleGlzdHMgcmVmKCRpZCldIHx8ICRyZWYoJGlkKSAhPSAkdiB8fAoJICAgICgkaWQgZXEgJG9sZG1haW5oZWFkICYmICRpZCBuZSAkbWFpbmhlYWQpIHx8CgkgICAgKCRpZCBlcSAkbWFpbmhlYWQgJiYgJGlkIG5lICRvbGRtYWluaGVhZCl9IHsKCSAgICByZWRyYXd0YWdzICRpZAoJfQogICAgfQp9Cgpwcm9jIGxpc3RyZWZzIHtpZH0gewogICAgZ2xvYmFsIGlkdGFncyBpZGhlYWRzIGlkb3RoZXJyZWZzCgogICAgc2V0IHgge30KICAgIGlmIHtbaW5mbyBleGlzdHMgaWR0YWdzKCRpZCldfSB7CglzZXQgeCAkaWR0YWdzKCRpZCkKICAgIH0KICAgIHNldCB5IHt9CiAgICBpZiB7W2luZm8gZXhpc3RzIGlkaGVhZHMoJGlkKV19IHsKCXNldCB5ICRpZGhlYWRzKCRpZCkKICAgIH0KICAgIHNldCB6IHt9CiAgICBpZiB7W2luZm8gZXhpc3RzIGlkb3RoZXJyZWZzKCRpZCldfSB7CglzZXQgeiAkaWRvdGhlcnJlZnMoJGlkKQogICAgfQogICAgcmV0dXJuIFtsaXN0ICR4ICR5ICR6XQp9Cgpwcm9jIHNob3d0YWcge3RhZyBpc25ld30gewogICAgZ2xvYmFsIGN0ZXh0IHRhZ2NvbnRlbnRzIHRhZ2lkcyBsaW5rbnVtIHRhZ29iamlkCgogICAgaWYgeyRpc25ld30gewoJYWRkdG9oaXN0b3J5IFtsaXN0IHNob3d0YWcgJHRhZyAwXQogICAgfQogICAgJGN0ZXh0IGNvbmYgLXN0YXRlIG5vcm1hbAogICAgY2xlYXJfY3RleHQKICAgIHNldCBsaW5rbnVtIDAKICAgIGlmIHshW2luZm8gZXhpc3RzIHRhZ2NvbnRlbnRzKCR0YWcpXX0gewoJY2F0Y2ggewoJICAgIHNldCB0YWdjb250ZW50cygkdGFnKSBbZXhlYyBnaXQgY2F0LWZpbGUgdGFnICR0YWdvYmppZCgkdGFnKV0KCX0KICAgIH0KICAgIGlmIHtbaW5mbyBleGlzdHMgdGFnY29udGVudHMoJHRhZyldfSB7CglzZXQgdGV4dCAkdGFnY29udGVudHMoJHRhZykKICAgIH0gZWxzZSB7CglzZXQgdGV4dCAiVGFnOiAkdGFnXG5JZDogICR0YWdpZHMoJHRhZykiCiAgICB9CiAgICBhcHBlbmR3aXRobGlua3MgJHRleHQge30KICAgICRjdGV4dCBjb25mIC1zdGF0ZSBkaXNhYmxlZAogICAgaW5pdF9mbGlzdCB7fQp9Cgpwcm9jIGRvcXVpdCB7fSB7CiAgICBnbG9iYWwgc3RvcHBlZAogICAgc2V0IHN0b3BwZWQgMTAwCiAgICBzYXZlc3R1ZmYgLgogICAgZGVzdHJveSAuCn0KCnByb2MgZG9wcmVmcyB7fSB7CiAgICBnbG9iYWwgbWF4d2lkdGggbWF4Z3JhcGhwY3QgZGlmZm9wdHMKICAgIGdsb2JhbCBvbGRwcmVmcyBwcmVmc3RvcCBzaG93bmVhcnRhZ3Mgc2hvd2xvY2FsY2hhbmdlcwogICAgZ2xvYmFsIGJnY29sb3IgZmdjb2xvciBjdGV4dCBkaWZmY29sb3JzIHNlbGVjdGJnY29sb3IKICAgIGdsb2JhbCB1aWZvbnQgdGFic3RvcAoKICAgIHNldCB0b3AgLmdpdGtwcmVmcwogICAgc2V0IHByZWZzdG9wICR0b3AKICAgIGlmIHtbd2luZm8gZXhpc3RzICR0b3BdfSB7CglyYWlzZSAkdG9wCglyZXR1cm4KICAgIH0KICAgIGZvcmVhY2ggdiB7bWF4d2lkdGggbWF4Z3JhcGhwY3QgZGlmZm9wdHMgc2hvd25lYXJ0YWdzIHNob3dsb2NhbGNoYW5nZXN9IHsKCXNldCBvbGRwcmVmcygkdikgW3NldCAkdl0KICAgIH0KICAgIHRvcGxldmVsICR0b3AKICAgIHdtIHRpdGxlICR0b3AgIkdpdGsgcHJlZmVyZW5jZXMiCiAgICBsYWJlbCAkdG9wLmxkaXNwIC10ZXh0ICJDb21taXQgbGlzdCBkaXNwbGF5IG9wdGlvbnMiCiAgICAkdG9wLmxkaXNwIGNvbmZpZ3VyZSAtZm9udCAkdWlmb250CiAgICBncmlkICR0b3AubGRpc3AgLSAtc3RpY2t5IHcgLXBhZHkgMTAKICAgIGxhYmVsICR0b3Auc3BhY2VyIC10ZXh0ICIgIgogICAgbGFiZWwgJHRvcC5tYXh3aWR0aGwgLXRleHQgIk1heGltdW0gZ3JhcGggd2lkdGggKGxpbmVzKSIgXAoJLWZvbnQgb3B0aW9uZm9udAogICAgc3BpbmJveCAkdG9wLm1heHdpZHRoIC1mcm9tIDAgLXRvIDEwMCAtd2lkdGggNCAtdGV4dHZhcmlhYmxlIG1heHdpZHRoCiAgICBncmlkICR0b3Auc3BhY2VyICR0b3AubWF4d2lkdGhsICR0b3AubWF4d2lkdGggLXN0aWNreSB3CiAgICBsYWJlbCAkdG9wLm1heHBjdGwgLXRleHQgIk1heGltdW0gZ3JhcGggd2lkdGggKCUgb2YgcGFuZSkiIFwKCS1mb250IG9wdGlvbmZvbnQKICAgIHNwaW5ib3ggJHRvcC5tYXhwY3QgLWZyb20gMSAtdG8gMTAwIC13aWR0aCA0IC10ZXh0dmFyaWFibGUgbWF4Z3JhcGhwY3QKICAgIGdyaWQgeCAkdG9wLm1heHBjdGwgJHRvcC5tYXhwY3QgLXN0aWNreSB3CiAgICBmcmFtZSAkdG9wLnNob3dsb2NhbAogICAgbGFiZWwgJHRvcC5zaG93bG9jYWwubCAtdGV4dCAiU2hvdyBsb2NhbCBjaGFuZ2VzIiAtZm9udCBvcHRpb25mb250CiAgICBjaGVja2J1dHRvbiAkdG9wLnNob3dsb2NhbC5iIC12YXJpYWJsZSBzaG93bG9jYWxjaGFuZ2VzCiAgICBwYWNrICR0b3Auc2hvd2xvY2FsLmIgJHRvcC5zaG93bG9jYWwubCAtc2lkZSBsZWZ0CiAgICBncmlkIHggJHRvcC5zaG93bG9jYWwgLXN0aWNreSB3CgogICAgbGFiZWwgJHRvcC5kZGlzcCAtdGV4dCAiRGlmZiBkaXNwbGF5IG9wdGlvbnMiCiAgICAkdG9wLmRkaXNwIGNvbmZpZ3VyZSAtZm9udCAkdWlmb250CiAgICBncmlkICR0b3AuZGRpc3AgLSAtc3RpY2t5IHcgLXBhZHkgMTAKICAgIGxhYmVsICR0b3AuZGlmZm9wdGwgLXRleHQgIk9wdGlvbnMgZm9yIGRpZmYgcHJvZ3JhbSIgXAoJLWZvbnQgb3B0aW9uZm9udAogICAgZW50cnkgJHRvcC5kaWZmb3B0IC13aWR0aCAyMCAtdGV4dHZhcmlhYmxlIGRpZmZvcHRzCiAgICBncmlkIHggJHRvcC5kaWZmb3B0bCAkdG9wLmRpZmZvcHQgLXN0aWNreSB3CiAgICBmcmFtZSAkdG9wLm50YWcKICAgIGxhYmVsICR0b3AubnRhZy5sIC10ZXh0ICJEaXNwbGF5IG5lYXJieSB0YWdzIiAtZm9udCBvcHRpb25mb250CiAgICBjaGVja2J1dHRvbiAkdG9wLm50YWcuYiAtdmFyaWFibGUgc2hvd25lYXJ0YWdzCiAgICBwYWNrICR0b3AubnRhZy5iICR0b3AubnRhZy5sIC1zaWRlIGxlZnQKICAgIGdyaWQgeCAkdG9wLm50YWcgLXN0aWNreSB3CiAgICBsYWJlbCAkdG9wLnRhYnN0b3BsIC10ZXh0ICJ0YWJzdG9wIiAtZm9udCBvcHRpb25mb250CiAgICBzcGluYm94ICR0b3AudGFic3RvcCAtZnJvbSAxIC10byAyMCAtd2lkdGggNCAtdGV4dHZhcmlhYmxlIHRhYnN0b3AKICAgIGdyaWQgeCAkdG9wLnRhYnN0b3BsICR0b3AudGFic3RvcCAtc3RpY2t5IHcKCiAgICBsYWJlbCAkdG9wLmNkaXNwIC10ZXh0ICJDb2xvcnM6IHByZXNzIHRvIGNob29zZSIKICAgICR0b3AuY2Rpc3AgY29uZmlndXJlIC1mb250ICR1aWZvbnQKICAgIGdyaWQgJHRvcC5jZGlzcCAtIC1zdGlja3kgdyAtcGFkeSAxMAogICAgbGFiZWwgJHRvcC5iZyAtcGFkeCA0MCAtcmVsaWVmIHN1bmsgLWJhY2tncm91bmQgJGJnY29sb3IKICAgIGJ1dHRvbiAkdG9wLmJnYnV0IC10ZXh0ICJCYWNrZ3JvdW5kIiAtZm9udCBvcHRpb25mb250IFwKCS1jb21tYW5kIFtsaXN0IGNob29zZWNvbG9yIGJnY29sb3IgMCAkdG9wLmJnIGJhY2tncm91bmQgc2V0YmddCiAgICBncmlkIHggJHRvcC5iZ2J1dCAkdG9wLmJnIC1zdGlja3kgdwogICAgbGFiZWwgJHRvcC5mZyAtcGFkeCA0MCAtcmVsaWVmIHN1bmsgLWJhY2tncm91bmQgJGZnY29sb3IKICAgIGJ1dHRvbiAkdG9wLmZnYnV0IC10ZXh0ICJGb3JlZ3JvdW5kIiAtZm9udCBvcHRpb25mb250IFwKCS1jb21tYW5kIFtsaXN0IGNob29zZWNvbG9yIGZnY29sb3IgMCAkdG9wLmZnIGZvcmVncm91bmQgc2V0ZmddCiAgICBncmlkIHggJHRvcC5mZ2J1dCAkdG9wLmZnIC1zdGlja3kgdwogICAgbGFiZWwgJHRvcC5kaWZmb2xkIC1wYWR4IDQwIC1yZWxpZWYgc3VuayAtYmFja2dyb3VuZCBbbGluZGV4ICRkaWZmY29sb3JzIDBdCiAgICBidXR0b24gJHRvcC5kaWZmb2xkYnV0IC10ZXh0ICJEaWZmOiBvbGQgbGluZXMiIC1mb250IG9wdGlvbmZvbnQgXAoJLWNvbW1hbmQgW2xpc3QgY2hvb3NlY29sb3IgZGlmZmNvbG9ycyAwICR0b3AuZGlmZm9sZCAiZGlmZiBvbGQgbGluZXMiIFwKCQkgICAgICBbbGlzdCAkY3RleHQgdGFnIGNvbmYgZDAgLWZvcmVncm91bmRdXQogICAgZ3JpZCB4ICR0b3AuZGlmZm9sZGJ1dCAkdG9wLmRpZmZvbGQgLXN0aWNreSB3CiAgICBsYWJlbCAkdG9wLmRpZmZuZXcgLXBhZHggNDAgLXJlbGllZiBzdW5rIC1iYWNrZ3JvdW5kIFtsaW5kZXggJGRpZmZjb2xvcnMgMV0KICAgIGJ1dHRvbiAkdG9wLmRpZmZuZXdidXQgLXRleHQgIkRpZmY6IG5ldyBsaW5lcyIgLWZvbnQgb3B0aW9uZm9udCBcCgktY29tbWFuZCBbbGlzdCBjaG9vc2Vjb2xvciBkaWZmY29sb3JzIDEgJHRvcC5kaWZmbmV3ICJkaWZmIG5ldyBsaW5lcyIgXAoJCSAgICAgIFtsaXN0ICRjdGV4dCB0YWcgY29uZiBkMSAtZm9yZWdyb3VuZF1dCiAgICBncmlkIHggJHRvcC5kaWZmbmV3YnV0ICR0b3AuZGlmZm5ldyAtc3RpY2t5IHcKICAgIGxhYmVsICR0b3AuaHVua3NlcCAtcGFkeCA0MCAtcmVsaWVmIHN1bmsgLWJhY2tncm91bmQgW2xpbmRleCAkZGlmZmNvbG9ycyAyXQogICAgYnV0dG9uICR0b3AuaHVua3NlcGJ1dCAtdGV4dCAiRGlmZjogaHVuayBoZWFkZXIiIC1mb250IG9wdGlvbmZvbnQgXAoJLWNvbW1hbmQgW2xpc3QgY2hvb3NlY29sb3IgZGlmZmNvbG9ycyAyICR0b3AuaHVua3NlcCBcCgkJICAgICAgImRpZmYgaHVuayBoZWFkZXIiIFwKCQkgICAgICBbbGlzdCAkY3RleHQgdGFnIGNvbmYgaHVua3NlcCAtZm9yZWdyb3VuZF1dCiAgICBncmlkIHggJHRvcC5odW5rc2VwYnV0ICR0b3AuaHVua3NlcCAtc3RpY2t5IHcKICAgIGxhYmVsICR0b3Auc2VsYmdzZXAgLXBhZHggNDAgLXJlbGllZiBzdW5rIC1iYWNrZ3JvdW5kICRzZWxlY3RiZ2NvbG9yCiAgICBidXR0b24gJHRvcC5zZWxiZ2J1dCAtdGV4dCAiU2VsZWN0IGJnIiAtZm9udCBvcHRpb25mb250IFwKCS1jb21tYW5kIFtsaXN0IGNob29zZWNvbG9yIHNlbGVjdGJnY29sb3IgMCAkdG9wLnNlbGJnc2VwIGJhY2tncm91bmQgc2V0c2VsYmddCiAgICBncmlkIHggJHRvcC5zZWxiZ2J1dCAkdG9wLnNlbGJnc2VwIC1zdGlja3kgdwoKICAgIGZyYW1lICR0b3AuYnV0cwogICAgYnV0dG9uICR0b3AuYnV0cy5vayAtdGV4dCAiT0siIC1jb21tYW5kIHByZWZzb2sgLWRlZmF1bHQgYWN0aXZlCiAgICAkdG9wLmJ1dHMub2sgY29uZmlndXJlIC1mb250ICR1aWZvbnQKICAgIGJ1dHRvbiAkdG9wLmJ1dHMuY2FuIC10ZXh0ICJDYW5jZWwiIC1jb21tYW5kIHByZWZzY2FuIC1kZWZhdWx0IG5vcm1hbAogICAgJHRvcC5idXRzLmNhbiBjb25maWd1cmUgLWZvbnQgJHVpZm9udAogICAgZ3JpZCAkdG9wLmJ1dHMub2sgJHRvcC5idXRzLmNhbgogICAgZ3JpZCBjb2x1bW5jb25maWd1cmUgJHRvcC5idXRzIDAgLXdlaWdodCAxIC11bmlmb3JtIGEKICAgIGdyaWQgY29sdW1uY29uZmlndXJlICR0b3AuYnV0cyAxIC13ZWlnaHQgMSAtdW5pZm9ybSBhCiAgICBncmlkICR0b3AuYnV0cyAtIC0gLXBhZHkgMTAgLXN0aWNreSBldwogICAgYmluZCAkdG9wIDxWaXNpYmlsaXR5PiAiZm9jdXMgJHRvcC5idXRzLm9rIgp9Cgpwcm9jIGNob29zZWNvbG9yIHt2IHZpIHcgeCBjbWR9IHsKICAgIGdsb2JhbCAkdgoKICAgIHNldCBjIFt0a19jaG9vc2VDb2xvciAtaW5pdGlhbGNvbG9yIFtsaW5kZXggW3NldCAkdl0gJHZpXSBcCgkgICAgICAgLXRpdGxlICJHaXRrOiBjaG9vc2UgY29sb3IgZm9yICR4Il0KICAgIGlmIHskYyBlcSB7fX0gcmV0dXJuCiAgICAkdyBjb25mIC1iYWNrZ3JvdW5kICRjCiAgICBsc2V0ICR2ICR2aSAkYwogICAgZXZhbCAkY21kICRjCn0KCnByb2Mgc2V0c2VsYmcge2N9IHsKICAgIGdsb2JhbCBiZ2xpc3QgY2ZsaXN0CiAgICBmb3JlYWNoIHcgJGJnbGlzdCB7CgkkdyBjb25maWd1cmUgLXNlbGVjdGJhY2tncm91bmQgJGMKICAgIH0KICAgICRjZmxpc3QgdGFnIGNvbmZpZ3VyZSBoaWdobGlnaHQgXAoJLWJhY2tncm91bmQgWyRjZmxpc3QgY2dldCAtc2VsZWN0YmFja2dyb3VuZF0KICAgIGFsbGNhbnZzIGl0ZW1jb25mIHNlY3NlbCAtZmlsbCAkYwp9Cgpwcm9jIHNldGJnIHtjfSB7CiAgICBnbG9iYWwgYmdsaXN0CgogICAgZm9yZWFjaCB3ICRiZ2xpc3QgewoJJHcgY29uZiAtYmFja2dyb3VuZCAkYwogICAgfQp9Cgpwcm9jIHNldGZnIHtjfSB7CiAgICBnbG9iYWwgZmdsaXN0IGNhbnYKCiAgICBmb3JlYWNoIHcgJGZnbGlzdCB7CgkkdyBjb25mIC1mb3JlZ3JvdW5kICRjCiAgICB9CiAgICBhbGxjYW52cyBpdGVtY29uZiB0ZXh0IC1maWxsICRjCiAgICAkY2FudiBpdGVtY29uZiBjaXJjbGUgLW91dGxpbmUgJGMKfQoKcHJvYyBwcmVmc2NhbiB7fSB7CiAgICBnbG9iYWwgbWF4d2lkdGggbWF4Z3JhcGhwY3QgZGlmZm9wdHMKICAgIGdsb2JhbCBvbGRwcmVmcyBwcmVmc3RvcCBzaG93bmVhcnRhZ3Mgc2hvd2xvY2FsY2hhbmdlcwoKICAgIGZvcmVhY2ggdiB7bWF4d2lkdGggbWF4Z3JhcGhwY3QgZGlmZm9wdHMgc2hvd25lYXJ0YWdzIHNob3dsb2NhbGNoYW5nZXN9IHsKCXNldCAkdiAkb2xkcHJlZnMoJHYpCiAgICB9CiAgICBjYXRjaCB7ZGVzdHJveSAkcHJlZnN0b3B9CiAgICB1bnNldCBwcmVmc3RvcAp9Cgpwcm9jIHByZWZzb2sge30gewogICAgZ2xvYmFsIG1heHdpZHRoIG1heGdyYXBocGN0CiAgICBnbG9iYWwgb2xkcHJlZnMgcHJlZnN0b3Agc2hvd25lYXJ0YWdzIHNob3dsb2NhbGNoYW5nZXMKICAgIGdsb2JhbCBjaGFyc3BjIGN0ZXh0IHRhYnN0b3AKCiAgICBjYXRjaCB7ZGVzdHJveSAkcHJlZnN0b3B9CiAgICB1bnNldCBwcmVmc3RvcAogICAgJGN0ZXh0IGNvbmZpZ3VyZSAtdGFicyAiW2V4cHIgeyR0YWJzdG9wICogJGNoYXJzcGN9XSIKICAgIGlmIHskc2hvd2xvY2FsY2hhbmdlcyAhPSAkb2xkcHJlZnMoc2hvd2xvY2FsY2hhbmdlcyl9IHsKCWlmIHskc2hvd2xvY2FsY2hhbmdlc30gewoJICAgIGRvc2hvd2xvY2FsY2hhbmdlcwoJfSBlbHNlIHsKCSAgICBkb2hpZGVsb2NhbGNoYW5nZXMKCX0KICAgIH0KICAgIGlmIHskbWF4d2lkdGggIT0gJG9sZHByZWZzKG1heHdpZHRoKQoJfHwgJG1heGdyYXBocGN0ICE9ICRvbGRwcmVmcyhtYXhncmFwaHBjdCl9IHsKCXJlZGlzcGxheQogICAgfSBlbHNlaWYgeyRzaG93bmVhcnRhZ3MgIT0gJG9sZHByZWZzKHNob3duZWFydGFncyl9IHsKCXJlc2VsZWN0bGluZQogICAgfQp9Cgpwcm9jIGZvcm1hdGRhdGUge2R9IHsKICAgIGlmIHskZCBuZSB7fX0gewoJc2V0IGQgW2Nsb2NrIGZvcm1hdCAkZCAtZm9ybWF0ICIlWS0lbS0lZCAlSDolTTolUyJdCiAgICB9CiAgICByZXR1cm4gJGQKfQoKIyBUaGlzIGxpc3Qgb2YgZW5jb2RpbmcgbmFtZXMgYW5kIGFsaWFzZXMgaXMgZGlzdGlsbGVkIGZyb20KIyBodHRwOi8vd3d3LmlhbmEub3JnL2Fzc2lnbm1lbnRzL2NoYXJhY3Rlci1zZXRzLgojIE5vdCBhbGwgb2YgdGhlbSBhcmUgc3VwcG9ydGVkIGJ5IFRjbC4Kc2V0IGVuY29kaW5nX2FsaWFzZXMgewogICAgeyBBTlNJX1gzLjQtMTk2OCBpc28taXItNiBBTlNJX1gzLjQtMTk4NiBJU09fNjQ2LmlydjoxOTkxIEFTQ0lJCiAgICAgIElTTzY0Ni1VUyBVUy1BU0NJSSB1cyBJQk0zNjcgY3AzNjcgY3NBU0NJSSB9CiAgICB7IElTTy0xMDY0Ni1VVEYtMSBjc0lTTzEwNjQ2VVRGMSB9CiAgICB7IElTT182NDYuYmFzaWM6MTk4MyByZWYgY3NJU082NDZiYXNpYzE5ODMgfQogICAgeyBJTlZBUklBTlQgY3NJTlZBUklBTlQgfQogICAgeyBJU09fNjQ2LmlydjoxOTgzIGlzby1pci0yIGlydiBjc0lTTzJJbnRsUmVmVmVyc2lvbiB9CiAgICB7IEJTXzQ3MzAgaXNvLWlyLTQgSVNPNjQ2LUdCIGdiIHVrIGNzSVNPNFVuaXRlZEtpbmdkb20gfQogICAgeyBOQVRTLVNFRkkgaXNvLWlyLTgtMSBjc05BVFNTRUZJIH0KICAgIHsgTkFUUy1TRUZJLUFERCBpc28taXItOC0yIGNzTkFUU1NFRklBREQgfQogICAgeyBOQVRTLURBTk8gaXNvLWlyLTktMSBjc05BVFNEQU5PIH0KICAgIHsgTkFUUy1EQU5PLUFERCBpc28taXItOS0yIGNzTkFUU0RBTk9BREQgfQogICAgeyBTRU5fODUwMjAwX0IgaXNvLWlyLTEwIEZJIElTTzY0Ni1GSSBJU082NDYtU0Ugc2UgY3NJU08xMFN3ZWRpc2ggfQogICAgeyBTRU5fODUwMjAwX0MgaXNvLWlyLTExIElTTzY0Ni1TRTIgc2UyIGNzSVNPMTFTd2VkaXNoRm9yTmFtZXMgfQogICAgeyBLU19DXzU2MDEtMTk4NyBpc28taXItMTQ5IEtTX0NfNTYwMS0xOTg5IEtTQ181NjAxIGtvcmVhbiBjc0tTQzU2MDExOTg3IH0KICAgIHsgSVNPLTIwMjItS1IgY3NJU08yMDIyS1IgfQogICAgeyBFVUMtS1IgY3NFVUNLUiB9CiAgICB7IElTTy0yMDIyLUpQIGNzSVNPMjAyMkpQIH0KICAgIHsgSVNPLTIwMjItSlAtMiBjc0lTTzIwMjJKUDIgfQogICAgeyBKSVNfQzYyMjAtMTk2OS1qcCBKSVNfQzYyMjAtMTk2OSBpc28taXItMTMga2F0YWthbmEgeDAyMDEtNwogICAgICBjc0lTTzEzSklTQzYyMjBqcCB9CiAgICB7IEpJU19DNjIyMC0xOTY5LXJvIGlzby1pci0xNCBqcCBJU082NDYtSlAgY3NJU08xNEpJU0M2MjIwcm8gfQogICAgeyBJVCBpc28taXItMTUgSVNPNjQ2LUlUIGNzSVNPMTVJdGFsaWFuIH0KICAgIHsgUFQgaXNvLWlyLTE2IElTTzY0Ni1QVCBjc0lTTzE2UG9ydHVndWVzZSB9CiAgICB7IEVTIGlzby1pci0xNyBJU082NDYtRVMgY3NJU08xN1NwYW5pc2ggfQogICAgeyBncmVlazctb2xkIGlzby1pci0xOCBjc0lTTzE4R3JlZWs3T2xkIH0KICAgIHsgbGF0aW4tZ3JlZWsgaXNvLWlyLTE5IGNzSVNPMTlMYXRpbkdyZWVrIH0KICAgIHsgRElOXzY2MDAzIGlzby1pci0yMSBkZSBJU082NDYtREUgY3NJU08yMUdlcm1hbiB9CiAgICB7IE5GX1pfNjItMDEwXygxOTczKSBpc28taXItMjUgSVNPNjQ2LUZSMSBjc0lTTzI1RnJlbmNoIH0KICAgIHsgTGF0aW4tZ3JlZWstMSBpc28taXItMjcgY3NJU08yN0xhdGluR3JlZWsxIH0KICAgIHsgSVNPXzU0MjcgaXNvLWlyLTM3IGNzSVNPNTQyN0N5cmlsbGljIH0KICAgIHsgSklTX0M2MjI2LTE5NzggaXNvLWlyLTQyIGNzSVNPNDJKSVNDNjIyNjE5NzggfQogICAgeyBCU192aWV3ZGF0YSBpc28taXItNDcgY3NJU080N0JTVmlld2RhdGEgfQogICAgeyBJTklTIGlzby1pci00OSBjc0lTTzQ5SU5JUyB9CiAgICB7IElOSVMtOCBpc28taXItNTAgY3NJU081MElOSVM4IH0KICAgIHsgSU5JUy1jeXJpbGxpYyBpc28taXItNTEgY3NJU081MUlOSVNDeXJpbGxpYyB9CiAgICB7IElTT181NDI3OjE5ODEgaXNvLWlyLTU0IElTTzU0MjdDeXJpbGxpYzE5ODEgfQogICAgeyBJU09fNTQyODoxOTgwIGlzby1pci01NSBjc0lTTzU0MjhHcmVlayB9CiAgICB7IEdCXzE5ODgtODAgaXNvLWlyLTU3IGNuIElTTzY0Ni1DTiBjc0lTTzU3R0IxOTg4IH0KICAgIHsgR0JfMjMxMi04MCBpc28taXItNTggY2hpbmVzZSBjc0lTTzU4R0IyMzEyODAgfQogICAgeyBOU180NTUxLTEgaXNvLWlyLTYwIElTTzY0Ni1OTyBubyBjc0lTTzYwRGFuaXNoTm9yd2VnaWFuCiAgICAgIGNzSVNPNjBOb3J3ZWdpYW4xIH0KICAgIHsgTlNfNDU1MS0yIElTTzY0Ni1OTzIgaXNvLWlyLTYxIG5vMiBjc0lTTzYxTm9yd2VnaWFuMiB9CiAgICB7IE5GX1pfNjItMDEwIGlzby1pci02OSBJU082NDYtRlIgZnIgY3NJU082OUZyZW5jaCB9CiAgICB7IHZpZGVvdGV4LXN1cHBsIGlzby1pci03MCBjc0lTTzcwVmlkZW90ZXhTdXBwMSB9CiAgICB7IFBUMiBpc28taXItODQgSVNPNjQ2LVBUMiBjc0lTTzg0UG9ydHVndWVzZTIgfQogICAgeyBFUzIgaXNvLWlyLTg1IElTTzY0Ni1FUzIgY3NJU084NVNwYW5pc2gyIH0KICAgIHsgTVNaXzc3OTUuMyBpc28taXItODYgSVNPNjQ2LUhVIGh1IGNzSVNPODZIdW5nYXJpYW4gfQogICAgeyBKSVNfQzYyMjYtMTk4MyBpc28taXItODcgeDAyMDggSklTX1gwMjA4LTE5ODMgY3NJU084N0pJU1gwMjA4IH0KICAgIHsgZ3JlZWs3IGlzby1pci04OCBjc0lTTzg4R3JlZWs3IH0KICAgIHsgQVNNT180NDkgSVNPXzkwMzYgYXJhYmljNyBpc28taXItODkgY3NJU084OUFTTU80NDkgfQogICAgeyBpc28taXItOTAgY3NJU085MCB9CiAgICB7IEpJU19DNjIyOS0xOTg0LWEgaXNvLWlyLTkxIGpwLW9jci1hIGNzSVNPOTFKSVNDNjIyOTE5ODRhIH0KICAgIHsgSklTX0M2MjI5LTE5ODQtYiBpc28taXItOTIgSVNPNjQ2LUpQLU9DUi1CIGpwLW9jci1iCiAgICAgIGNzSVNPOTJKSVNDNjI5OTE5ODRiIH0KICAgIHsgSklTX0M2MjI5LTE5ODQtYi1hZGQgaXNvLWlyLTkzIGpwLW9jci1iLWFkZCBjc0lTTzkzSklTNjIyOTE5ODRiYWRkIH0KICAgIHsgSklTX0M2MjI5LTE5ODQtaGFuZCBpc28taXItOTQganAtb2NyLWhhbmQgY3NJU085NEpJUzYyMjkxOTg0aGFuZCB9CiAgICB7IEpJU19DNjIyOS0xOTg0LWhhbmQtYWRkIGlzby1pci05NSBqcC1vY3ItaGFuZC1hZGQKICAgICAgY3NJU085NUpJUzYyMjkxOTg0aGFuZGFkZCB9CiAgICB7IEpJU19DNjIyOS0xOTg0LWthbmEgaXNvLWlyLTk2IGNzSVNPOTZKSVNDNjIyOTE5ODRrYW5hIH0KICAgIHsgSVNPXzIwMzMtMTk4MyBpc28taXItOTggZTEzYiBjc0lTTzIwMzMgfQogICAgeyBBTlNJX1gzLjExMC0xOTgzIGlzby1pci05OSBDU0FfVDUwMC0xOTgzIE5BUExQUyBjc0lTTzk5TkFQTFBTIH0KICAgIHsgSVNPXzg4NTktMToxOTg3IGlzby1pci0xMDAgSVNPXzg4NTktMSBJU08tODg1OS0xIGxhdGluMSBsMSBJQk04MTkKICAgICAgQ1A4MTkgY3NJU09MYXRpbjEgfQogICAgeyBJU09fODg1OS0yOjE5ODcgaXNvLWlyLTEwMSBJU09fODg1OS0yIElTTy04ODU5LTIgbGF0aW4yIGwyIGNzSVNPTGF0aW4yIH0KICAgIHsgVC42MS03Yml0IGlzby1pci0xMDIgY3NJU08xMDJUNjE3Yml0IH0KICAgIHsgVC42MS04Yml0IFQuNjEgaXNvLWlyLTEwMyBjc0lTTzEwM1Q2MThiaXQgfQogICAgeyBJU09fODg1OS0zOjE5ODggaXNvLWlyLTEwOSBJU09fODg1OS0zIElTTy04ODU5LTMgbGF0aW4zIGwzIGNzSVNPTGF0aW4zIH0KICAgIHsgSVNPXzg4NTktNDoxOTg4IGlzby1pci0xMTAgSVNPXzg4NTktNCBJU08tODg1OS00IGxhdGluNCBsNCBjc0lTT0xhdGluNCB9CiAgICB7IEVDTUEtY3lyaWxsaWMgaXNvLWlyLTExMSBLT0k4LUUgY3NJU08xMTFFQ01BQ3lyaWxsaWMgfQogICAgeyBDU0FfWjI0My40LTE5ODUtMSBpc28taXItMTIxIElTTzY0Ni1DQSBjc2E3LTEgY2EgY3NJU08xMjFDYW5hZGlhbjEgfQogICAgeyBDU0FfWjI0My40LTE5ODUtMiBpc28taXItMTIyIElTTzY0Ni1DQTIgY3NhNy0yIGNzSVNPMTIyQ2FuYWRpYW4yIH0KICAgIHsgQ1NBX1oyNDMuNC0xOTg1LWdyIGlzby1pci0xMjMgY3NJU08xMjNDU0FaMjQzNDE5ODVnciB9CiAgICB7IElTT184ODU5LTY6MTk4NyBpc28taXItMTI3IElTT184ODU5LTYgSVNPLTg4NTktNiBFQ01BLTExNCBBU01PLTcwOAogICAgICBhcmFiaWMgY3NJU09MYXRpbkFyYWJpYyB9CiAgICB7IElTT184ODU5LTYtRSBjc0lTTzg4NTk2RSBJU08tODg1OS02LUUgfQogICAgeyBJU09fODg1OS02LUkgY3NJU084ODU5NkkgSVNPLTg4NTktNi1JIH0KICAgIHsgSVNPXzg4NTktNzoxOTg3IGlzby1pci0xMjYgSVNPXzg4NTktNyBJU08tODg1OS03IEVMT1RfOTI4IEVDTUEtMTE4CiAgICAgIGdyZWVrIGdyZWVrOCBjc0lTT0xhdGluR3JlZWsgfQogICAgeyBULjEwMS1HMiBpc28taXItMTI4IGNzSVNPMTI4VDEwMUcyIH0KICAgIHsgSVNPXzg4NTktODoxOTg4IGlzby1pci0xMzggSVNPXzg4NTktOCBJU08tODg1OS04IGhlYnJldwogICAgICBjc0lTT0xhdGluSGVicmV3IH0KICAgIHsgSVNPXzg4NTktOC1FIGNzSVNPODg1OThFIElTTy04ODU5LTgtRSB9CiAgICB7IElTT184ODU5LTgtSSBjc0lTTzg4NTk4SSBJU08tODg1OS04LUkgfQogICAgeyBDU05fMzY5MTAzIGlzby1pci0xMzkgY3NJU08xMzlDU04zNjkxMDMgfQogICAgeyBKVVNfSS5CMS4wMDIgaXNvLWlyLTE0MSBJU082NDYtWVUganMgeXUgY3NJU08xNDFKVVNJQjEwMDIgfQogICAgeyBJU09fNjkzNy0yLWFkZCBpc28taXItMTQyIGNzSVNPVGV4dENvbW0gfQogICAgeyBJRUNfUDI3LTEgaXNvLWlyLTE0MyBjc0lTTzE0M0lFQ1AyNzEgfQogICAgeyBJU09fODg1OS01OjE5ODggaXNvLWlyLTE0NCBJU09fODg1OS01IElTTy04ODU5LTUgY3lyaWxsaWMKICAgICAgY3NJU09MYXRpbkN5cmlsbGljIH0KICAgIHsgSlVTX0kuQjEuMDAzLXNlcmIgaXNvLWlyLTE0NiBzZXJiaWFuIGNzSVNPMTQ2U2VyYmlhbiB9CiAgICB7IEpVU19JLkIxLjAwMy1tYWMgbWFjZWRvbmlhbiBpc28taXItMTQ3IGNzSVNPMTQ3TWFjZWRvbmlhbiB9CiAgICB7IElTT184ODU5LTk6MTk4OSBpc28taXItMTQ4IElTT184ODU5LTkgSVNPLTg4NTktOSBsYXRpbjUgbDUgY3NJU09MYXRpbjUgfQogICAgeyBncmVlay1jY2l0dCBpc28taXItMTUwIGNzSVNPMTUwIGNzSVNPMTUwR3JlZWtDQ0lUVCB9CiAgICB7IE5DX05DMDAtMTA6ODEgY3ViYSBpc28taXItMTUxIElTTzY0Ni1DVSBjc0lTTzE1MUN1YmEgfQogICAgeyBJU09fNjkzNy0yLTI1IGlzby1pci0xNTIgY3NJU082OTM3QWRkIH0KICAgIHsgR09TVF8xOTc2OC03NCBTVF9TRVZfMzU4LTg4IGlzby1pci0xNTMgY3NJU08xNTNHT1NUMTk3Njg3NCB9CiAgICB7IElTT184ODU5LXN1cHAgaXNvLWlyLTE1NCBsYXRpbjEtMi01IGNzSVNPODg1OVN1cHAgfQogICAgeyBJU09fMTAzNjctYm94IGlzby1pci0xNTUgY3NJU08xMDM2N0JveCB9CiAgICB7IElTTy04ODU5LTEwIGlzby1pci0xNTcgbDYgSVNPXzg4NTktMTA6MTk5MiBjc0lTT0xhdGluNiBsYXRpbjYgfQogICAgeyBsYXRpbi1sYXAgbGFwIGlzby1pci0xNTggY3NJU08xNThMYXAgfQogICAgeyBKSVNfWDAyMTItMTk5MCB4MDIxMiBpc28taXItMTU5IGNzSVNPMTU5SklTWDAyMTIxOTkwIH0KICAgIHsgRFNfMjA4OSBEUzIwODkgSVNPNjQ2LURLIGRrIGNzSVNPNjQ2RGFuaXNoIH0KICAgIHsgdXMtZGsgY3NVU0RLIH0KICAgIHsgZGstdXMgY3NES1VTIH0KICAgIHsgSklTX1gwMjAxIFgwMjAxIGNzSGFsZldpZHRoS2F0YWthbmEgfQogICAgeyBLU0M1NjM2IElTTzY0Ni1LUiBjc0tTQzU2MzYgfQogICAgeyBJU08tMTA2NDYtVUNTLTIgY3NVbmljb2RlIH0KICAgIHsgSVNPLTEwNjQ2LVVDUy00IGNzVUNTNCB9CiAgICB7IERFQy1NQ1MgZGVjIGNzREVDTUNTIH0KICAgIHsgaHAtcm9tYW44IHJvbWFuOCByOCBjc0hQUm9tYW44IH0KICAgIHsgbWFjaW50b3NoIG1hYyBjc01hY2ludG9zaCB9CiAgICB7IElCTTAzNyBjcDAzNyBlYmNkaWMtY3AtdXMgZWJjZGljLWNwLWNhIGViY2RpYy1jcC13dCBlYmNkaWMtY3AtbmwKICAgICAgY3NJQk0wMzcgfQogICAgeyBJQk0wMzggRUJDRElDLUlOVCBjcDAzOCBjc0lCTTAzOCB9CiAgICB7IElCTTI3MyBDUDI3MyBjc0lCTTI3MyB9CiAgICB7IElCTTI3NCBFQkNESUMtQkUgQ1AyNzQgY3NJQk0yNzQgfQogICAgeyBJQk0yNzUgRUJDRElDLUJSIGNwMjc1IGNzSUJNMjc1IH0KICAgIHsgSUJNMjc3IEVCQ0RJQy1DUC1ESyBFQkNESUMtQ1AtTk8gY3NJQk0yNzcgfQogICAgeyBJQk0yNzggQ1AyNzggZWJjZGljLWNwLWZpIGViY2RpYy1jcC1zZSBjc0lCTTI3OCB9CiAgICB7IElCTTI4MCBDUDI4MCBlYmNkaWMtY3AtaXQgY3NJQk0yODAgfQogICAgeyBJQk0yODEgRUJDRElDLUpQLUUgY3AyODEgY3NJQk0yODEgfQogICAgeyBJQk0yODQgQ1AyODQgZWJjZGljLWNwLWVzIGNzSUJNMjg0IH0KICAgIHsgSUJNMjg1IENQMjg1IGViY2RpYy1jcC1nYiBjc0lCTTI4NSB9CiAgICB7IElCTTI5MCBjcDI5MCBFQkNESUMtSlAta2FuYSBjc0lCTTI5MCB9CiAgICB7IElCTTI5NyBjcDI5NyBlYmNkaWMtY3AtZnIgY3NJQk0yOTcgfQogICAgeyBJQk00MjAgY3A0MjAgZWJjZGljLWNwLWFyMSBjc0lCTTQyMCB9CiAgICB7IElCTTQyMyBjcDQyMyBlYmNkaWMtY3AtZ3IgY3NJQk00MjMgfQogICAgeyBJQk00MjQgY3A0MjQgZWJjZGljLWNwLWhlIGNzSUJNNDI0IH0KICAgIHsgSUJNNDM3IGNwNDM3IDQzNyBjc1BDOENvZGVQYWdlNDM3IH0KICAgIHsgSUJNNTAwIENQNTAwIGViY2RpYy1jcC1iZSBlYmNkaWMtY3AtY2ggY3NJQk01MDAgfQogICAgeyBJQk03NzUgY3A3NzUgY3NQQzc3NUJhbHRpYyB9CiAgICB7IElCTTg1MCBjcDg1MCA4NTAgY3NQQzg1ME11bHRpbGluZ3VhbCB9CiAgICB7IElCTTg1MSBjcDg1MSA4NTEgY3NJQk04NTEgfQogICAgeyBJQk04NTIgY3A4NTIgODUyIGNzUENwODUyIH0KICAgIHsgSUJNODU1IGNwODU1IDg1NSBjc0lCTTg1NSB9CiAgICB7IElCTTg1NyBjcDg1NyA4NTcgY3NJQk04NTcgfQogICAgeyBJQk04NjAgY3A4NjAgODYwIGNzSUJNODYwIH0KICAgIHsgSUJNODYxIGNwODYxIDg2MSBjcC1pcyBjc0lCTTg2MSB9CiAgICB7IElCTTg2MiBjcDg2MiA4NjIgY3NQQzg2MkxhdGluSGVicmV3IH0KICAgIHsgSUJNODYzIGNwODYzIDg2MyBjc0lCTTg2MyB9CiAgICB7IElCTTg2NCBjcDg2NCBjc0lCTTg2NCB9CiAgICB7IElCTTg2NSBjcDg2NSA4NjUgY3NJQk04NjUgfQogICAgeyBJQk04NjYgY3A4NjYgODY2IGNzSUJNODY2IH0KICAgIHsgSUJNODY4IENQODY4IGNwLWFyIGNzSUJNODY4IH0KICAgIHsgSUJNODY5IGNwODY5IDg2OSBjcC1nciBjc0lCTTg2OSB9CiAgICB7IElCTTg3MCBDUDg3MCBlYmNkaWMtY3Atcm9lY2UgZWJjZGljLWNwLXl1IGNzSUJNODcwIH0KICAgIHsgSUJNODcxIENQODcxIGViY2RpYy1jcC1pcyBjc0lCTTg3MSB9CiAgICB7IElCTTg4MCBjcDg4MCBFQkNESUMtQ3lyaWxsaWMgY3NJQk04ODAgfQogICAgeyBJQk04OTEgY3A4OTEgY3NJQk04OTEgfQogICAgeyBJQk05MDMgY3A5MDMgY3NJQk05MDMgfQogICAgeyBJQk05MDQgY3A5MDQgOTA0IGNzSUJCTTkwNCB9CiAgICB7IElCTTkwNSBDUDkwNSBlYmNkaWMtY3AtdHIgY3NJQk05MDUgfQogICAgeyBJQk05MTggQ1A5MTggZWJjZGljLWNwLWFyMiBjc0lCTTkxOCB9CiAgICB7IElCTTEwMjYgQ1AxMDI2IGNzSUJNMTAyNiB9CiAgICB7IEVCQ0RJQy1BVC1ERSBjc0lCTUVCQ0RJQ0FUREUgfQogICAgeyBFQkNESUMtQVQtREUtQSBjc0VCQ0RJQ0FUREVBIH0KICAgIHsgRUJDRElDLUNBLUZSIGNzRUJDRElDQ0FGUiB9CiAgICB7IEVCQ0RJQy1ESy1OTyBjc0VCQ0RJQ0RLTk8gfQogICAgeyBFQkNESUMtREstTk8tQSBjc0VCQ0RJQ0RLTk9BIH0KICAgIHsgRUJDRElDLUZJLVNFIGNzRUJDRElDRklTRSB9CiAgICB7IEVCQ0RJQy1GSS1TRS1BIGNzRUJDRElDRklTRUEgfQogICAgeyBFQkNESUMtRlIgY3NFQkNESUNGUiB9CiAgICB7IEVCQ0RJQy1JVCBjc0VCQ0RJQ0lUIH0KICAgIHsgRUJDRElDLVBUIGNzRUJDRElDUFQgfQogICAgeyBFQkNESUMtRVMgY3NFQkNESUNFUyB9CiAgICB7IEVCQ0RJQy1FUy1BIGNzRUJDRElDRVNBIH0KICAgIHsgRUJDRElDLUVTLVMgY3NFQkNESUNFU1MgfQogICAgeyBFQkNESUMtVUsgY3NFQkNESUNVSyB9CiAgICB7IEVCQ0RJQy1VUyBjc0VCQ0RJQ1VTIH0KICAgIHsgVU5LTk9XTi04QklUIGNzVW5rbm93bjhCaVQgfQogICAgeyBNTkVNT05JQyBjc01uZW1vbmljIH0KICAgIHsgTU5FTSBjc01uZW0gfQogICAgeyBWSVNDSUkgY3NWSVNDSUkgfQogICAgeyBWSVFSIGNzVklRUiB9CiAgICB7IEtPSTgtUiBjc0tPSThSIH0KICAgIHsgSUJNMDA4NTggQ0NTSUQwMDg1OCBDUDAwODU4IFBDLU11bHRpbGluZ3VhbC04NTArZXVybyB9CiAgICB7IElCTTAwOTI0IENDU0lEMDA5MjQgQ1AwMDkyNCBlYmNkaWMtTGF0aW45LS1ldXJvIH0KICAgIHsgSUJNMDExNDAgQ0NTSUQwMTE0MCBDUDAxMTQwIGViY2RpYy11cy0zNytldXJvIH0KICAgIHsgSUJNMDExNDEgQ0NTSUQwMTE0MSBDUDAxMTQxIGViY2RpYy1kZS0yNzMrZXVybyB9CiAgICB7IElCTTAxMTQyIENDU0lEMDExNDIgQ1AwMTE0MiBlYmNkaWMtZGstMjc3K2V1cm8gZWJjZGljLW5vLTI3NytldXJvIH0KICAgIHsgSUJNMDExNDMgQ0NTSUQwMTE0MyBDUDAxMTQzIGViY2RpYy1maS0yNzgrZXVybyBlYmNkaWMtc2UtMjc4K2V1cm8gfQogICAgeyBJQk0wMTE0NCBDQ1NJRDAxMTQ0IENQMDExNDQgZWJjZGljLWl0LTI4MCtldXJvIH0KICAgIHsgSUJNMDExNDUgQ0NTSUQwMTE0NSBDUDAxMTQ1IGViY2RpYy1lcy0yODQrZXVybyB9CiAgICB7IElCTTAxMTQ2IENDU0lEMDExNDYgQ1AwMTE0NiBlYmNkaWMtZ2ItMjg1K2V1cm8gfQogICAgeyBJQk0wMTE0NyBDQ1NJRDAxMTQ3IENQMDExNDcgZWJjZGljLWZyLTI5NytldXJvIH0KICAgIHsgSUJNMDExNDggQ0NTSUQwMTE0OCBDUDAxMTQ4IGViY2RpYy1pbnRlcm5hdGlvbmFsLTUwMCtldXJvIH0KICAgIHsgSUJNMDExNDkgQ0NTSUQwMTE0OSBDUDAxMTQ5IGViY2RpYy1pcy04NzErZXVybyB9CiAgICB7IElCTTEwNDcgSUJNLTEwNDcgfQogICAgeyBQVENQMTU0IGNzUFRDUDE1NCBQVDE1NCBDUDE1NCBDeXJpbGxpYy1Bc2lhbiB9CiAgICB7IEFtaWdhLTEyNTEgQW1pMTI1MSBBbWlnYTEyNTEgQW1pLTEyNTEgfQogICAgeyBVTklDT0RFLTEtMSBjc1VuaWNvZGUxMSB9CiAgICB7IENFU1UtOCBjc0NFU1UtOCB9CiAgICB7IEJPQ1UtMSBjc0JPQ1UtMSB9CiAgICB7IFVOSUNPREUtMS0xLVVURi03IGNzVW5pY29kZTExVVRGNyB9CiAgICB7IElTTy04ODU5LTE0IGlzby1pci0xOTkgSVNPXzg4NTktMTQ6MTk5OCBJU09fODg1OS0xNCBsYXRpbjggaXNvLWNlbHRpYwogICAgICBsOCB9CiAgICB7IElTTy04ODU5LTE1IElTT184ODU5LTE1IExhdGluLTkgfQogICAgeyBJU08tODg1OS0xNiBpc28taXItMjI2IElTT184ODU5LTE2OjIwMDEgSVNPXzg4NTktMTYgbGF0aW4xMCBsMTAgfQogICAgeyBHQksgQ1A5MzYgTVM5MzYgd2luZG93cy05MzYgfQogICAgeyBKSVNfRW5jb2RpbmcgY3NKSVNFbmNvZGluZyB9CiAgICB7IFNoaWZ0X0pJUyBNU19LYW5qaSBjc1NoaWZ0SklTIH0KICAgIHsgRXh0ZW5kZWRfVU5JWF9Db2RlX1BhY2tlZF9Gb3JtYXRfZm9yX0phcGFuZXNlIGNzRVVDUGtkRm10SmFwYW5lc2UKICAgICAgRVVDLUpQIH0KICAgIHsgRXh0ZW5kZWRfVU5JWF9Db2RlX0ZpeGVkX1dpZHRoX2Zvcl9KYXBhbmVzZSBjc0VVQ0ZpeFdpZEphcGFuZXNlIH0KICAgIHsgSVNPLTEwNjQ2LVVDUy1CYXNpYyBjc1VuaWNvZGVBU0NJSSB9CiAgICB7IElTTy0xMDY0Ni1Vbmljb2RlLUxhdGluMSBjc1VuaWNvZGVMYXRpbjEgSVNPLTEwNjQ2IH0KICAgIHsgSVNPLVVuaWNvZGUtSUJNLTEyNjEgY3NVbmljb2RlSUJNMTI2MSB9CiAgICB7IElTTy1Vbmljb2RlLUlCTS0xMjY4IGNzVW5pY29kZUlCTTEyNjggfQogICAgeyBJU08tVW5pY29kZS1JQk0tMTI3NiBjc1VuaWNvZGVJQk0xMjc2IH0KICAgIHsgSVNPLVVuaWNvZGUtSUJNLTEyNjQgY3NVbmljb2RlSUJNMTI2NCB9CiAgICB7IElTTy1Vbmljb2RlLUlCTS0xMjY1IGNzVW5pY29kZUlCTTEyNjUgfQogICAgeyBJU08tODg1OS0xLVdpbmRvd3MtMy4wLUxhdGluLTEgY3NXaW5kb3dzMzBMYXRpbjEgfQogICAgeyBJU08tODg1OS0xLVdpbmRvd3MtMy4xLUxhdGluLTEgY3NXaW5kb3dzMzFMYXRpbjEgfQogICAgeyBJU08tODg1OS0yLVdpbmRvd3MtTGF0aW4tMiBjc1dpbmRvd3MzMUxhdGluMiB9CiAgICB7IElTTy04ODU5LTktV2luZG93cy1MYXRpbi01IGNzV2luZG93czMxTGF0aW41IH0KICAgIHsgQWRvYmUtU3RhbmRhcmQtRW5jb2RpbmcgY3NBZG9iZVN0YW5kYXJkRW5jb2RpbmcgfQogICAgeyBWZW50dXJhLVVTIGNzVmVudHVyYVVTIH0KICAgIHsgVmVudHVyYS1JbnRlcm5hdGlvbmFsIGNzVmVudHVyYUludGVybmF0aW9uYWwgfQogICAgeyBQQzgtRGFuaXNoLU5vcndlZ2lhbiBjc1BDOERhbmlzaE5vcndlZ2lhbiB9CiAgICB7IFBDOC1UdXJraXNoIGNzUEM4VHVya2lzaCB9CiAgICB7IElCTS1TeW1ib2xzIGNzSUJNU3ltYm9scyB9CiAgICB7IElCTS1UaGFpIGNzSUJNVGhhaSB9CiAgICB7IEhQLUxlZ2FsIGNzSFBMZWdhbCB9CiAgICB7IEhQLVBpLWZvbnQgY3NIUFBpRm9udCB9CiAgICB7IEhQLU1hdGg4IGNzSFBNYXRoOCB9CiAgICB7IEFkb2JlLVN5bWJvbC1FbmNvZGluZyBjc0hQUFNNYXRoIH0KICAgIHsgSFAtRGVza1RvcCBjc0hQRGVza3RvcCB9CiAgICB7IFZlbnR1cmEtTWF0aCBjc1ZlbnR1cmFNYXRoIH0KICAgIHsgTWljcm9zb2Z0LVB1Ymxpc2hpbmcgY3NNaWNyb3NvZnRQdWJsaXNoaW5nIH0KICAgIHsgV2luZG93cy0zMUogY3NXaW5kb3dzMzFKIH0KICAgIHsgR0IyMzEyIGNzR0IyMzEyIH0KICAgIHsgQmlnNSBjc0JpZzUgfQp9Cgpwcm9jIHRjbF9lbmNvZGluZyB7ZW5jfSB7CiAgICBnbG9iYWwgZW5jb2RpbmdfYWxpYXNlcwogICAgc2V0IG5hbWVzIFtlbmNvZGluZyBuYW1lc10KICAgIHNldCBsY25hbWVzIFtzdHJpbmcgdG9sb3dlciAkbmFtZXNdCiAgICBzZXQgZW5jIFtzdHJpbmcgdG9sb3dlciAkZW5jXQogICAgc2V0IGkgW2xzZWFyY2ggLWV4YWN0ICRsY25hbWVzICRlbmNdCiAgICBpZiB7JGkgPCAwfSB7CgkjIGxvb2sgZm9yICJpc29ubm4iIGluc3RlYWQgb2YgImlzby1ubm4iIG9yICJpc29fbm5uIgoJaWYge1tyZWdzdWIge15pc29bLV9dfSAkZW5jIGlzbyBlbmN4XX0gewoJICAgIHNldCBpIFtsc2VhcmNoIC1leGFjdCAkbGNuYW1lcyAkZW5jeF0KCX0KICAgIH0KICAgIGlmIHskaSA8IDB9IHsKCWZvcmVhY2ggbCAkZW5jb2RpbmdfYWxpYXNlcyB7CgkgICAgc2V0IGxsIFtzdHJpbmcgdG9sb3dlciAkbF0KCSAgICBpZiB7W2xzZWFyY2ggLWV4YWN0ICRsbCAkZW5jXSA8IDB9IGNvbnRpbnVlCgkgICAgIyBsb29rIHRocm91Z2ggdGhlIGFsaWFzZXMgZm9yIG9uZSB0aGF0IHRjbCBrbm93cyBhYm91dAoJICAgIGZvcmVhY2ggZSAkbGwgewoJCXNldCBpIFtsc2VhcmNoIC1leGFjdCAkbGNuYW1lcyAkZV0KCQlpZiB7JGkgPCAwfSB7CgkJICAgIGlmIHtbcmVnc3ViIHteaXNvWy1fXX0gJGUgaXNvIGV4XX0gewoJCQlzZXQgaSBbbHNlYXJjaCAtZXhhY3QgJGxjbmFtZXMgJGV4XQoJCSAgICB9CgkJfQoJCWlmIHskaSA+PSAwfSBicmVhawoJICAgIH0KCSAgICBicmVhawoJfQogICAgfQogICAgaWYgeyRpID49IDB9IHsKCXJldHVybiBbbGluZGV4ICRuYW1lcyAkaV0KICAgIH0KICAgIHJldHVybiB7fQp9CgojIGRlZmF1bHRzLi4uCnNldCBkYXRlbW9kZSAwCnNldCBkaWZmb3B0cyAiLVUgNSAtcCIKc2V0IHdyY29tY21kICJnaXQgZGlmZi10cmVlIC0tc3RkaW4gLXAgLS1wcmV0dHkiCgpzZXQgZ2l0ZW5jb2Rpbmcge30KY2F0Y2ggewogICAgc2V0IGdpdGVuY29kaW5nIFtleGVjIGdpdCBjb25maWcgLS1nZXQgaTE4bi5jb21taXRlbmNvZGluZ10KfQppZiB7JGdpdGVuY29kaW5nID09ICIifSB7CiAgICBzZXQgZ2l0ZW5jb2RpbmcgInV0Zi04Igp9CnNldCB0Y2xlbmNvZGluZyBbdGNsX2VuY29kaW5nICRnaXRlbmNvZGluZ10KaWYgeyR0Y2xlbmNvZGluZyA9PSB7fX0gewogICAgcHV0cyBzdGRlcnIgIldhcm5pbmc6IGVuY29kaW5nICRnaXRlbmNvZGluZyBpcyBub3Qgc3VwcG9ydGVkIGJ5IFRjbC9UayIKfQoKc2V0IG1haW5mb250IHtIZWx2ZXRpY2EgOX0Kc2V0IHRleHRmb250IHtDb3VyaWVyIDl9CnNldCB1aWZvbnQge0hlbHZldGljYSA5IGJvbGR9CnNldCB0YWJzdG9wIDgKc2V0IGZpbmRtZXJnZWZpbGVzIDAKc2V0IG1heGdyYXBocGN0IDUwCnNldCBtYXh3aWR0aCAxNgpzZXQgcmV2bGlzdG9yZGVyIDAKc2V0IGZhc3RkYXRlIDAKc2V0IHVwYXJyb3dsZW4gNwpzZXQgZG93bmFycm93bGVuIDcKc2V0IG1pbmdhcGxlbiAzMApzZXQgY21pdG1vZGUgInBhdGNoIgpzZXQgd3JhcGNvbW1lbnQgIm5vbmUiCnNldCBzaG93bmVhcnRhZ3MgMQpzZXQgbWF4cmVmcyAyMApzZXQgbWF4bGluZWxlbiAyMDAKc2V0IHNob3dsb2NhbGNoYW5nZXMgMQoKc2V0IGNvbG9ycyB7Z3JlZW4gcmVkIGJsdWUgbWFnZW50YSBkYXJrZ3JleSBicm93biBvcmFuZ2V9CnNldCBiZ2NvbG9yIHdoaXRlCnNldCBmZ2NvbG9yIGJsYWNrCnNldCBkaWZmY29sb3JzIHtyZWQgIiMwMGEwMDAiIGJsdWV9CnNldCBzZWxlY3RiZ2NvbG9yIGdyYXk4NQoKY2F0Y2gge3NvdXJjZSB+Ly5naXRrfQoKZm9udCBjcmVhdGUgb3B0aW9uZm9udCAtZmFtaWx5IHNhbnMtc2VyaWYgLXNpemUgLTEyCgojIGNoZWNrIHRoYXQgd2UgY2FuIGZpbmQgYSAuZ2l0IGRpcmVjdG9yeSBzb21ld2hlcmUuLi4Kc2V0IGdpdGRpciBbZ2l0ZGlyXQppZiB7IVtmaWxlIGlzZGlyZWN0b3J5ICRnaXRkaXJdfSB7CiAgICBzaG93X2Vycm9yIHt9IC4gIkNhbm5vdCBmaW5kIHRoZSBnaXQgZGlyZWN0b3J5IFwiJGdpdGRpclwiLiIKICAgIGV4aXQgMQp9CgpzZXQgcmV2dHJlZWFyZ3Mge30Kc2V0IGNtZGxpbmVfZmlsZXMge30Kc2V0IGkgMApmb3JlYWNoIGFyZyAkYXJndiB7CiAgICBzd2l0Y2ggLS0gJGFyZyB7CgkiIiB7IH0KCSItZCIgeyBzZXQgZGF0ZW1vZGUgMSB9CgkiLS0iIHsKCSAgICBzZXQgY21kbGluZV9maWxlcyBbbHJhbmdlICRhcmd2IFtleHByIHskaSArIDF9XSBlbmRdCgkgICAgYnJlYWsKCX0KCWRlZmF1bHQgewoJICAgIGxhcHBlbmQgcmV2dHJlZWFyZ3MgJGFyZwoJfQogICAgfQogICAgaW5jciBpCn0KCmlmIHskaSA+PSBbbGxlbmd0aCAkYXJndl0gJiYgJHJldnRyZWVhcmdzIG5lIHt9fSB7CiAgICAjIG5vIC0tIG9uIGNvbW1hbmQgbGluZSwgYnV0IHNvbWUgYXJndW1lbnRzIChvdGhlciB0aGFuIC1kKQogICAgaWYge1tjYXRjaCB7CglzZXQgZiBbZXZhbCBleGVjIGdpdCByZXYtcGFyc2UgLS1uby1yZXZzIC0tbm8tZmxhZ3MgJHJldnRyZWVhcmdzXQoJc2V0IGNtZGxpbmVfZmlsZXMgW3NwbGl0ICRmICJcbiJdCglzZXQgbiBbbGxlbmd0aCAkY21kbGluZV9maWxlc10KCXNldCByZXZ0cmVlYXJncyBbbHJhbmdlICRyZXZ0cmVlYXJncyAwIGVuZC0kbl0KCSMgVW5mb3J0dW5hdGVseSBnaXQgcmV2LXBhcnNlIGRvZXNuJ3QgcHJvZHVjZSBhbiBlcnJvciB3aGVuCgkjIHNvbWV0aGluZyBpcyBib3RoIGEgcmV2aXNpb24gYW5kIGEgZmlsZW5hbWUuICBUbyBiZSBjb25zaXN0ZW50CgkjIHdpdGggZ2l0IGxvZyBhbmQgZ2l0IHJldi1saXN0LCBjaGVjayByZXZ0cmVlYXJncyBmb3IgZmlsZW5hbWVzLgoJZm9yZWFjaCBhcmcgJHJldnRyZWVhcmdzIHsKCSAgICBpZiB7W2ZpbGUgZXhpc3RzICRhcmddfSB7CgkJc2hvd19lcnJvciB7fSAuICJBbWJpZ3VvdXMgYXJndW1lbnQgJyRhcmcnOiBib3RoIHJldmlzaW9uXAoJCQkJIGFuZCBmaWxlbmFtZSIKCQlleGl0IDEKCSAgICB9Cgl9CiAgICB9IGVycl19IHsKCSMgdW5mb3J0dW5hdGVseSB3ZSBnZXQgYm90aCBzdGRvdXQgYW5kIHN0ZGVyciBpbiAkZXJyLAoJIyBzbyBsb29rIGZvciAiZmF0YWw6Ii4KCXNldCBpIFtzdHJpbmcgZmlyc3QgImZhdGFsOiIgJGVycl0KCWlmIHskaSA+IDB9IHsKCSAgICBzZXQgZXJyIFtzdHJpbmcgcmFuZ2UgJGVyciBbZXhwciB7JGkgKyA2fV0gZW5kXQoJfQoJc2hvd19lcnJvciB7fSAuICJCYWQgYXJndW1lbnRzIHRvIGdpdGs6XG4kZXJyIgoJZXhpdCAxCiAgICB9Cn0KCnNldCBudWxsaWQgIjAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAiCnNldCBudWxsaWQyICIwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAxIgoKCnNldCBydW5xIHt9CnNldCBoaXN0b3J5IHt9CnNldCBoaXN0b3J5aW5kZXggMApzZXQgZmhfc2VyaWFsIDAKc2V0IG5obF9uYW1lcyB7fQpzZXQgaGlnaGxpZ2h0X3BhdGhzIHt9CnNldCBzZWFyY2hkaXJuIC1mb3J3YXJkcwpzZXQgYm9sZHJvd3Mge30Kc2V0IGJvbGRuYW1lcm93cyB7fQpzZXQgZGlmZmVsaWRlIHswIDB9CnNldCBtYXJraW5nbWF0Y2hlcyAwCgpzZXQgb3B0aW1fZGVsYXkgMTYKCnNldCBuZXh0dmlld251bSAxCnNldCBjdXJ2aWV3IDAKc2V0IHNlbGVjdGVkdmlldyAwCnNldCBzZWxlY3RlZGhsdmlldyBOb25lCnNldCB2aWV3ZmlsZXMoMCkge30Kc2V0IHZpZXdwZXJtKDApIDAKc2V0IHZpZXdhcmdzKDApIHt9CgpzZXQgY21kbGluZW9rIDAKc2V0IHN0b3BwZWQgMApzZXQgc3R1ZmZzYXZlZCAwCnNldCBwYXRjaG51bSAwCnNldCBsb29raW5nZm9yaGVhZCAwCnNldCBsb2NhbGlyb3cgLTEKc2V0IGxvY2FsZnJvdyAtMQpzZXQgbHNlcmlhbCAwCnNldGNvb3JkcwptYWtld2luZG93CiMgd2FpdCBmb3IgdGhlIHdpbmRvdyB0byBiZWNvbWUgdmlzaWJsZQp0a3dhaXQgdmlzaWJpbGl0eSAuCndtIHRpdGxlIC4gIltmaWxlIHRhaWwgJGFyZ3YwXTogW2ZpbGUgdGFpbCBbcHdkXV0iCnJlYWRyZWZzCgppZiB7JGNtZGxpbmVfZmlsZXMgbmUge30gfHwgJHJldnRyZWVhcmdzIG5lIHt9fSB7CiAgICAjIGNyZWF0ZSBhIHZpZXcgZm9yIHRoZSBmaWxlcy9kaXJzIHNwZWNpZmllZCBvbiB0aGUgY29tbWFuZCBsaW5lCiAgICBzZXQgY3VydmlldyAxCiAgICBzZXQgc2VsZWN0ZWR2aWV3IDEKICAgIHNldCBuZXh0dmlld251bSAyCiAgICBzZXQgdmlld25hbWUoMSkgIkNvbW1hbmQgbGluZSIKICAgIHNldCB2aWV3ZmlsZXMoMSkgJGNtZGxpbmVfZmlsZXMKICAgIHNldCB2aWV3YXJncygxKSAkcmV2dHJlZWFyZ3MKICAgIHNldCB2aWV3cGVybSgxKSAwCiAgICBhZGR2aWV3bWVudSAxCiAgICAuYmFyLnZpZXcgZW50cnljb25mIEVkaXQqIC1zdGF0ZSBub3JtYWwKICAgIC5iYXIudmlldyBlbnRyeWNvbmYgRGVsZXRlKiAtc3RhdGUgbm9ybWFsCn0KCmlmIHtbaW5mbyBleGlzdHMgcGVybXZpZXdzXX0gewogICAgZm9yZWFjaCB2ICRwZXJtdmlld3MgewoJc2V0IG4gJG5leHR2aWV3bnVtCglpbmNyIG5leHR2aWV3bnVtCglzZXQgdmlld25hbWUoJG4pIFtsaW5kZXggJHYgMF0KCXNldCB2aWV3ZmlsZXMoJG4pIFtsaW5kZXggJHYgMV0KCXNldCB2aWV3YXJncygkbikgW2xpbmRleCAkdiAyXQoJc2V0IHZpZXdwZXJtKCRuKSAxCglhZGR2aWV3bWVudSAkbgogICAgfQp9CmdldGNvbW1pdHMK