LyoKICogcGFzMl9wY20uYyBBdWRpbyByb3V0aW5lcyBmb3IgUEFTMTYKICoKICoKICogQ29weXJpZ2h0IChDKSBieSBIYW5udSBTYXZvbGFpbmVuIDE5OTMtMTk5NwogKgogKiBPU1MvRnJlZSBmb3IgTGludXggaXMgZGlzdHJpYnV0ZWQgdW5kZXIgdGhlIEdOVSBHRU5FUkFMIFBVQkxJQyBMSUNFTlNFIChHUEwpCiAqIFZlcnNpb24gMiAoSnVuZSAxOTkxKS4gU2VlIHRoZSAiQ09QWUlORyIgZmlsZSBkaXN0cmlidXRlZCB3aXRoIHRoaXMgc29mdHdhcmUKICogZm9yIG1vcmUgaW5mby4KICoKICoKICogVGhvbWFzIFNhaWxlciAgIDogaW9jdGwgY29kZSByZXdvcmtlZCAodm1hbGxvYy92ZnJlZSByZW1vdmVkKQogKiBBbGFuIENveAkgICA6IFN3YXR0ZWQgYSBkb3VibGUgYWxsb2NhdGlvbiBvZiBkZXZpY2UgYnVnLiBNYWRlIGEgZmV3CiAqCQkgICAgIG1vcmUgdGhpbmdzIG1vZHVsZSBvcHRpb25zLgogKiBCYXJ0bG9taWVqIFpvbG5pZXJraWV3aWN6IDogQWRkZWQgX19pbml0IHRvIHBhc19wY21faW5pdCgpCiAqLwoKI2luY2x1ZGUgPGxpbnV4L2luaXQuaD4KI2luY2x1ZGUgPGxpbnV4L3NwaW5sb2NrLmg+CiNpbmNsdWRlIDxhc20vdGltZXguaD4KI2luY2x1ZGUgInNvdW5kX2NvbmZpZy5oIgoKI2luY2x1ZGUgInBhczIuaCIKCiNpZm5kZWYgREVCCiNkZWZpbmUgREVCKFdIQVQpCiNlbmRpZgoKI2RlZmluZSBQQVNfUENNX0lOVFJCSVRTICgweDA4KQovKgogKiBTYW1wbGUgYnVmZmVyIHRpbWVyIGludGVycnVwdCBlbmFibGUKICovCgojZGVmaW5lIFBDTV9OT04JMAojZGVmaW5lIFBDTV9EQUMJMQojZGVmaW5lIFBDTV9BREMJMgoKc3RhdGljIHVuc2lnbmVkIGxvbmcgcGNtX3NwZWVkOyAJLyogc2FtcGxpbmcgcmF0ZSAqLwpzdGF0aWMgdW5zaWduZWQgY2hhciBwY21fY2hhbm5lbHMgPSAxOwkvKiBjaGFubmVscyAoMSBvciAyKSAqLwpzdGF0aWMgdW5zaWduZWQgY2hhciBwY21fYml0cyA9IDg7CS8qIGJpdHMvc2FtcGxlICg4IG9yIDE2KSAqLwpzdGF0aWMgdW5zaWduZWQgY2hhciBwY21fZmlsdGVyOwkvKiBmaWx0ZXIgRkxBRyAqLwpzdGF0aWMgdW5zaWduZWQgY2hhciBwY21fbW9kZSA9IFBDTV9OT047CnN0YXRpYyB1bnNpZ25lZCBsb25nIHBjbV9jb3VudDsKc3RhdGljIHVuc2lnbmVkIHNob3J0IHBjbV9iaXRzb2sgPSA4OwkvKiBtYXNrIG9mIE9LIGJpdHMgKi8Kc3RhdGljIGludCAgICAgIHBjbV9idXN5OwppbnQgICAgICAgICAgICAgcGFzX2F1ZGlvZGV2ID0gLTE7CnN0YXRpYyBpbnQgICAgICBvcGVuX21vZGU7CgpleHRlcm4gc3BpbmxvY2tfdCBwYXNfbG9jazsKCnN0YXRpYyBpbnQgcGNtX3NldF9zcGVlZChpbnQgYXJnKQp7CglpbnQgZm9vLCB0bXA7Cgl1bnNpZ25lZCBsb25nIGZsYWdzOwoKCWlmIChhcmcgPT0gMCkKCQlyZXR1cm4gcGNtX3NwZWVkOwoKCWlmIChhcmcgPiA0NDEwMCkKCQlhcmcgPSA0NDEwMDsKCWlmIChhcmcgPCA1MDAwKQoJCWFyZyA9IDUwMDA7CgoJaWYgKHBjbV9jaGFubmVscyAmIDIpCgl7CgkJZm9vID0gKChDTE9DS19USUNLX1JBVEUgLyAyKSArIChhcmcgLyAyKSkgLyBhcmc7CgkJYXJnID0gKChDTE9DS19USUNLX1JBVEUgLyAyKSArIChmb28gLyAyKSkgLyBmb287Cgl9CgllbHNlCgl7CgkJZm9vID0gKENMT0NLX1RJQ0tfUkFURSArIChhcmcgLyAyKSkgLyBhcmc7CgkJYXJnID0gKENMT0NLX1RJQ0tfUkFURSArIChmb28gLyAyKSkgLyBmb287Cgl9CgoJcGNtX3NwZWVkID0gYXJnOwoKCXRtcCA9IHBhc19yZWFkKDB4MEI4QSk7CgoJLyoKCSAqIFNldCBhbnRpLWFsaWFzaW5nIGZpbHRlcnMgYWNjb3JkaW5nIHRvIHNhbXBsZSByYXRlLiBZb3UgcmVhbGx5ICpORUVEKgoJICogdG8gZW5hYmxlIHRoaXMgZmVhdHVyZSBmb3IgYWxsIG5vcm1hbCByZWNvcmRpbmcgdW5sZXNzIHlvdSB3YW50IHRvCgkgKiBleHBlcmltZW50IHdpdGggYWxpYXNpbmcgZWZmZWN0cy4KCSAqIFRoZXNlIGZpbHRlcnMgYXBwbHkgdG8gdGhlIHNlbGVjdGVkICJyZWNvcmRpbmciIHNvdXJjZS4KCSAqIEkgKHBmdykgZG9uJ3Qga25vdyB0aGUgZW5jb2Rpbmcgb2YgdGhlc2UgNSBiaXRzLiBUaGUgdmFsdWVzIHNob3duCgkgKiBjb21lIGZyb20gdGhlIFNESyBmb3VuZCBvbiBmdHAudXdwLmVkdTovcHViL21zZG9zL3Byb2F1ZGlvLy4KCSAqCgkgKiBJIGNsZWFyZWQgYml0IDUgb2YgdGhlc2UgdmFsdWVzLCBzaW5jZSB0aGF0IGJpdCBjb250cm9scyB0aGUgbWFzdGVyCgkgKiBtdXRlIGZsYWcuIChPbGF2IFf2bGZlbHNjaG5laWRlcikKCSAqCgkgKi8KI2lmICFkZWZpbmVkIE5PX0FVVE9fRklMVEVSX1NFVAoJdG1wICY9IDB4ZTA7CglpZiAocGNtX3NwZWVkID49IDIgKiAxNzg5NykKCQl0bXAgfD0gMHgwMTsKCWVsc2UgaWYgKHBjbV9zcGVlZCA+PSAyICogMTU5MDkpCgkJdG1wIHw9IDB4MDI7CgllbHNlIGlmIChwY21fc3BlZWQgPj0gMiAqIDExOTMxKQoJCXRtcCB8PSAweDA5OwoJZWxzZSBpZiAocGNtX3NwZWVkID49IDIgKiA4OTQ4KQoJCXRtcCB8PSAweDExOwoJZWxzZSBpZiAocGNtX3NwZWVkID49IDIgKiA1OTY1KQoJCXRtcCB8PSAweDE5OwoJZWxzZSBpZiAocGNtX3NwZWVkID49IDIgKiAyOTgyKQoJCXRtcCB8PSAweDA0OwoJcGNtX2ZpbHRlciA9IHRtcDsKI2VuZGlmCgoJc3Bpbl9sb2NrX2lycXNhdmUoJnBhc19sb2NrLCBmbGFncyk7CgoJcGFzX3dyaXRlKHRtcCAmIH4oMHg0MCB8IDB4ODApLCAweDBCOEEpOwoJcGFzX3dyaXRlKDB4MDAgfCAweDMwIHwgMHgwNCwgMHgxMzhCKTsKCXBhc193cml0ZShmb28gJiAweGZmLCAweDEzODgpOwoJcGFzX3dyaXRlKChmb28gPj4gOCkgJiAweGZmLCAweDEzODgpOwoJcGFzX3dyaXRlKHRtcCwgMHgwQjhBKTsKCglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwYXNfbG9jaywgZmxhZ3MpOwoKCXJldHVybiBwY21fc3BlZWQ7Cn0KCnN0YXRpYyBpbnQgcGNtX3NldF9jaGFubmVscyhpbnQgYXJnKQp7CgoJaWYgKChhcmcgIT0gMSkgJiYgKGFyZyAhPSAyKSkKCQlyZXR1cm4gcGNtX2NoYW5uZWxzOwoKCWlmIChhcmcgIT0gcGNtX2NoYW5uZWxzKQoJewoJCXBhc193cml0ZShwYXNfcmVhZCgweEY4QSkgXiAweDIwLCAweEY4QSk7CgoJCXBjbV9jaGFubmVscyA9IGFyZzsKCQlwY21fc2V0X3NwZWVkKHBjbV9zcGVlZCk7CS8qIFRoZSBzcGVlZCBtdXN0IGJlIHJlaW5pdGlhbGl6ZWQgKi8KCX0KCXJldHVybiBwY21fY2hhbm5lbHM7Cn0KCnN0YXRpYyBpbnQgcGNtX3NldF9iaXRzKGludCBhcmcpCnsKCWlmIChhcmcgPT0gMCkKCQlyZXR1cm4gcGNtX2JpdHM7CgoJaWYgKChhcmcgJiBwY21fYml0c29rKSAhPSBhcmcpCgkJcmV0dXJuIHBjbV9iaXRzOwoKCWlmIChhcmcgIT0gcGNtX2JpdHMpCgl7CgkJcGFzX3dyaXRlKHBhc19yZWFkKDB4ODM4OSkgXiAweDA0LCAweDgzODkpOwoKCQlwY21fYml0cyA9IGFyZzsKCX0KCXJldHVybiBwY21fYml0czsKfQoKc3RhdGljIGludCBwYXNfYXVkaW9faW9jdGwoaW50IGRldiwgdW5zaWduZWQgaW50IGNtZCwgdm9pZCBfX3VzZXIgKmFyZykKewoJaW50IHZhbCwgcmV0OwoJaW50IF9fdXNlciAqcCA9IGFyZzsKCglERUIocHJpbnRrKCJwYXMyX3BjbS5jOiBzdGF0aWMgaW50IHBhc19hdWRpb19pb2N0bCh1bnNpZ25lZCBpbnQgY21kID0gJVgsIHVuc2lnbmVkIGludCBhcmcgPSAlWClcbiIsIGNtZCwgYXJnKSk7CgoJc3dpdGNoIChjbWQpIAoJewoJY2FzZSBTT1VORF9QQ01fV1JJVEVfUkFURToKCQlpZiAoZ2V0X3VzZXIodmFsLCBwKSkgCgkJCXJldHVybiAtRUZBVUxUOwoJCXJldCA9IHBjbV9zZXRfc3BlZWQodmFsKTsKCQlicmVhazsKCgljYXNlIFNPVU5EX1BDTV9SRUFEX1JBVEU6CgkJcmV0ID0gcGNtX3NwZWVkOwoJCWJyZWFrOwoJCQoJY2FzZSBTTkRDVExfRFNQX1NURVJFTzoKCQlpZiAoZ2V0X3VzZXIodmFsLCBwKSkgCgkJCXJldHVybiAtRUZBVUxUOwoJCXJldCA9IHBjbV9zZXRfY2hhbm5lbHModmFsICsgMSkgLSAxOwoJCWJyZWFrOwoKCWNhc2UgU09VTkRfUENNX1dSSVRFX0NIQU5ORUxTOgoJCWlmIChnZXRfdXNlcih2YWwsIHApKSAKCQkJcmV0dXJuIC1FRkFVTFQ7CgkJcmV0ID0gcGNtX3NldF9jaGFubmVscyh2YWwpOwoJCWJyZWFrOwoKCWNhc2UgU09VTkRfUENNX1JFQURfQ0hBTk5FTFM6CgkJcmV0ID0gcGNtX2NoYW5uZWxzOwoJCWJyZWFrOwoKCWNhc2UgU05EQ1RMX0RTUF9TRVRGTVQ6CgkJaWYgKGdldF91c2VyKHZhbCwgcCkpCgkJCXJldHVybiAtRUZBVUxUOwoJCXJldCA9IHBjbV9zZXRfYml0cyh2YWwpOwoJCWJyZWFrOwoJCQoJY2FzZSBTT1VORF9QQ01fUkVBRF9CSVRTOgoJCXJldCA9IHBjbV9iaXRzOwoJCWJyZWFrOwogIAoJZGVmYXVsdDoKCQlyZXR1cm4gLUVJTlZBTDsKCX0KCXJldHVybiBwdXRfdXNlcihyZXQsIHApOwp9CgpzdGF0aWMgdm9pZCBwYXNfYXVkaW9fcmVzZXQoaW50IGRldikKewoJREVCKHByaW50aygicGFzMl9wY20uYzogc3RhdGljIHZvaWQgcGFzX2F1ZGlvX3Jlc2V0KHZvaWQpXG4iKSk7CgoJcGFzX3dyaXRlKHBhc19yZWFkKDB4RjhBKSAmIH4weDQwLCAweEY4QSk7CS8qIERpc2FibGUgUENNICovCn0KCnN0YXRpYyBpbnQgcGFzX2F1ZGlvX29wZW4oaW50IGRldiwgaW50IG1vZGUpCnsKCWludCAgICAgICAgICAgICBlcnI7Cgl1bnNpZ25lZCBsb25nICAgZmxhZ3M7CgoJREVCKHByaW50aygicGFzMl9wY20uYzogc3RhdGljIGludCBwYXNfYXVkaW9fb3BlbihpbnQgbW9kZSA9ICVYKVxuIiwgbW9kZSkpOwoKCXNwaW5fbG9ja19pcnFzYXZlKCZwYXNfbG9jaywgZmxhZ3MpOwoJaWYgKHBjbV9idXN5KQoJewoJCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBhc19sb2NrLCBmbGFncyk7CgkJcmV0dXJuIC1FQlVTWTsKCX0KCXBjbV9idXN5ID0gMTsKCXNwaW5fdW5sb2NrX2lycXJlc3RvcmUoJnBhc19sb2NrLCBmbGFncyk7CgoJaWYgKChlcnIgPSBwYXNfc2V0X2ludHIoUEFTX1BDTV9JTlRSQklUUykpIDwgMCkKCQlyZXR1cm4gZXJyOwoKCglwY21fY291bnQgPSAwOwoJb3Blbl9tb2RlID0gbW9kZTsKCglyZXR1cm4gMDsKfQoKc3RhdGljIHZvaWQgcGFzX2F1ZGlvX2Nsb3NlKGludCBkZXYpCnsKCXVuc2lnbmVkIGxvbmcgICBmbGFnczsKCglERUIocHJpbnRrKCJwYXMyX3BjbS5jOiBzdGF0aWMgdm9pZCBwYXNfYXVkaW9fY2xvc2Uodm9pZClcbiIpKTsKCglzcGluX2xvY2tfaXJxc2F2ZSgmcGFzX2xvY2ssIGZsYWdzKTsKCglwYXNfYXVkaW9fcmVzZXQoZGV2KTsKCXBhc19yZW1vdmVfaW50cihQQVNfUENNX0lOVFJCSVRTKTsKCXBjbV9tb2RlID0gUENNX05PTjsKCglwY21fYnVzeSA9IDA7CglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwYXNfbG9jaywgZmxhZ3MpOwp9CgpzdGF0aWMgdm9pZCBwYXNfYXVkaW9fb3V0cHV0X2Jsb2NrKGludCBkZXYsIHVuc2lnbmVkIGxvbmcgYnVmLCBpbnQgY291bnQsCgkJICAgICAgIGludCBpbnRyZmxhZykKewoJdW5zaWduZWQgbG9uZyAgIGZsYWdzLCBjbnQ7CgoJREVCKHByaW50aygicGFzMl9wY20uYzogc3RhdGljIHZvaWQgcGFzX2F1ZGlvX291dHB1dF9ibG9jayhjaGFyICpidWYgPSAlUCwgaW50IGNvdW50ID0gJVgpXG4iLCBidWYsIGNvdW50KSk7CgoJY250ID0gY291bnQ7CglpZiAoYXVkaW9fZGV2c1tkZXZdLT5kbWFwX291dC0+ZG1hID4gMykKCQljbnQgPj49IDE7CgoJaWYgKGF1ZGlvX2RldnNbZGV2XS0+ZmxhZ3MgJiBETUFfQVVUT01PREUgJiYKCSAgICBpbnRyZmxhZyAmJgoJICAgIGNudCA9PSBwY21fY291bnQpCgkJcmV0dXJuOwoKCXNwaW5fbG9ja19pcnFzYXZlKCZwYXNfbG9jaywgZmxhZ3MpOwoKCXBhc193cml0ZShwYXNfcmVhZCgweEY4QSkgJiB+MHg0MCwKCQkgIDB4RjhBKTsKCgkvKiBETUFidWZfc3RhcnRfZG1hIChkZXYsIGJ1ZiwgY291bnQsIERNQV9NT0RFX1dSSVRFKTsgKi8KCglpZiAoYXVkaW9fZGV2c1tkZXZdLT5kbWFwX291dC0+ZG1hID4gMykKCQljb3VudCA+Pj0gMTsKCglpZiAoY291bnQgIT0gcGNtX2NvdW50KQoJewoJCXBhc193cml0ZShwYXNfcmVhZCgweDBCOEEpICYgfjB4ODAsIDB4MEI4QSk7CgkJcGFzX3dyaXRlKDB4NDAgfCAweDMwIHwgMHgwNCwgMHgxMzhCKTsKCQlwYXNfd3JpdGUoY291bnQgJiAweGZmLCAweDEzODkpOwoJCXBhc193cml0ZSgoY291bnQgPj4gOCkgJiAweGZmLCAweDEzODkpOwoJCXBhc193cml0ZShwYXNfcmVhZCgweDBCOEEpIHwgMHg4MCwgMHgwQjhBKTsKCgkJcGNtX2NvdW50ID0gY291bnQ7Cgl9CglwYXNfd3JpdGUocGFzX3JlYWQoMHgwQjhBKSB8IDB4ODAgfCAweDQwLCAweDBCOEEpOwojaWZkZWYgTk9fVFJJR0dFUgoJcGFzX3dyaXRlKHBhc19yZWFkKDB4RjhBKSB8IDB4NDAgfCAweDEwLCAweEY4QSk7CiNlbmRpZgoKCXBjbV9tb2RlID0gUENNX0RBQzsKCglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwYXNfbG9jaywgZmxhZ3MpOwp9CgpzdGF0aWMgdm9pZCBwYXNfYXVkaW9fc3RhcnRfaW5wdXQoaW50IGRldiwgdW5zaWduZWQgbG9uZyBidWYsIGludCBjb3VudCwKCQkgICAgICBpbnQgaW50cmZsYWcpCnsKCXVuc2lnbmVkIGxvbmcgICBmbGFnczsKCWludCAgICAgICAgICAgICBjbnQ7CgoJREVCKHByaW50aygicGFzMl9wY20uYzogc3RhdGljIHZvaWQgcGFzX2F1ZGlvX3N0YXJ0X2lucHV0KGNoYXIgKmJ1ZiA9ICVQLCBpbnQgY291bnQgPSAlWClcbiIsIGJ1ZiwgY291bnQpKTsKCgljbnQgPSBjb3VudDsKCWlmIChhdWRpb19kZXZzW2Rldl0tPmRtYXBfb3V0LT5kbWEgPiAzKQoJCWNudCA+Pj0gMTsKCglpZiAoYXVkaW9fZGV2c1twYXNfYXVkaW9kZXZdLT5mbGFncyAmIERNQV9BVVRPTU9ERSAmJgoJICAgIGludHJmbGFnICYmCgkgICAgY250ID09IHBjbV9jb3VudCkKCQlyZXR1cm47CgoJc3Bpbl9sb2NrX2lycXNhdmUoJnBhc19sb2NrLCBmbGFncyk7CgoJLyogRE1BYnVmX3N0YXJ0X2RtYSAoZGV2LCBidWYsIGNvdW50LCBETUFfTU9ERV9SRUFEKTsgKi8KCglpZiAoYXVkaW9fZGV2c1tkZXZdLT5kbWFwX291dC0+ZG1hID4gMykKCQljb3VudCA+Pj0gMTsKCglpZiAoY291bnQgIT0gcGNtX2NvdW50KQoJewoJCXBhc193cml0ZShwYXNfcmVhZCgweDBCOEEpICYgfjB4ODAsIDB4MEI4QSk7CgkJcGFzX3dyaXRlKDB4NDAgfCAweDMwIHwgMHgwNCwgMHgxMzhCKTsKCQlwYXNfd3JpdGUoY291bnQgJiAweGZmLCAweDEzODkpOwoJCXBhc193cml0ZSgoY291bnQgPj4gOCkgJiAweGZmLCAweDEzODkpOwoJCXBhc193cml0ZShwYXNfcmVhZCgweDBCOEEpIHwgMHg4MCwgMHgwQjhBKTsKCgkJcGNtX2NvdW50ID0gY291bnQ7Cgl9CglwYXNfd3JpdGUocGFzX3JlYWQoMHgwQjhBKSB8IDB4ODAgfCAweDQwLCAweDBCOEEpOwojaWZkZWYgTk9fVFJJR0dFUgoJcGFzX3dyaXRlKChwYXNfcmVhZCgweEY4QSkgfCAweDQwKSAmIH4weDEwLCAweEY4QSk7CiNlbmRpZgoKCXBjbV9tb2RlID0gUENNX0FEQzsKCglzcGluX3VubG9ja19pcnFyZXN0b3JlKCZwYXNfbG9jaywgZmxhZ3MpOwp9CgojaWZuZGVmIE5PX1RSSUdHRVIKc3RhdGljIHZvaWQgcGFzX2F1ZGlvX3RyaWdnZXIoaW50IGRldiwgaW50IHN0YXRlKQp7Cgl1bnNpZ25lZCBsb25nICAgZmxhZ3M7CgoJc3Bpbl9sb2NrX2lycXNhdmUoJnBhc19sb2NrLCBmbGFncyk7CglzdGF0ZSAmPSBvcGVuX21vZGU7CgoJaWYgKHN0YXRlICYgUENNX0VOQUJMRV9PVVRQVVQpCgkJcGFzX3dyaXRlKHBhc19yZWFkKDB4RjhBKSB8IDB4NDAgfCAweDEwLCAweEY4QSk7CgllbHNlIGlmIChzdGF0ZSAmIFBDTV9FTkFCTEVfSU5QVVQpCgkJcGFzX3dyaXRlKChwYXNfcmVhZCgweEY4QSkgfCAweDQwKSAmIH4weDEwLCAweEY4QSk7CgllbHNlCgkJcGFzX3dyaXRlKHBhc19yZWFkKDB4RjhBKSAmIH4weDQwLCAweEY4QSk7CgoJc3Bpbl91bmxvY2tfaXJxcmVzdG9yZSgmcGFzX2xvY2ssIGZsYWdzKTsKfQojZW5kaWYKCnN0YXRpYyBpbnQgcGFzX2F1ZGlvX3ByZXBhcmVfZm9yX2lucHV0KGludCBkZXYsIGludCBic2l6ZSwgaW50IGJjb3VudCkKewoJcGFzX2F1ZGlvX3Jlc2V0KGRldik7CglyZXR1cm4gMDsKfQoKc3RhdGljIGludCBwYXNfYXVkaW9fcHJlcGFyZV9mb3Jfb3V0cHV0KGludCBkZXYsIGludCBic2l6ZSwgaW50IGJjb3VudCkKewoJcGFzX2F1ZGlvX3Jlc2V0KGRldik7CglyZXR1cm4gMDsKfQoKc3RhdGljIHN0cnVjdCBhdWRpb19kcml2ZXIgcGFzX2F1ZGlvX2RyaXZlciA9CnsKCS5vd25lcgkJCT0gVEhJU19NT0RVTEUsCgkub3BlbgkJCT0gcGFzX2F1ZGlvX29wZW4sCgkuY2xvc2UJCQk9IHBhc19hdWRpb19jbG9zZSwKCS5vdXRwdXRfYmxvY2sJCT0gcGFzX2F1ZGlvX291dHB1dF9ibG9jaywKCS5zdGFydF9pbnB1dAkJPSBwYXNfYXVkaW9fc3RhcnRfaW5wdXQsCgkuaW9jdGwJCQk9IHBhc19hdWRpb19pb2N0bCwKCS5wcmVwYXJlX2Zvcl9pbnB1dAk9IHBhc19hdWRpb19wcmVwYXJlX2Zvcl9pbnB1dCwKCS5wcmVwYXJlX2Zvcl9vdXRwdXQJPSBwYXNfYXVkaW9fcHJlcGFyZV9mb3Jfb3V0cHV0LAoJLmhhbHRfaW8JCT0gcGFzX2F1ZGlvX3Jlc2V0LAoJLnRyaWdnZXIJCT0gcGFzX2F1ZGlvX3RyaWdnZXIKfTsKCnZvaWQgX19pbml0IHBhc19wY21faW5pdChzdHJ1Y3QgYWRkcmVzc19pbmZvICpod19jb25maWcpCnsKCURFQihwcmludGsoInBhczJfcGNtLmM6IGxvbmcgcGFzX3BjbV9pbml0KClcbiIpKTsKCglwY21fYml0c29rID0gODsKCWlmIChwYXNfcmVhZCgweEVGOEIpICYgMHgwOCkKCQlwY21fYml0c29rIHw9IDE2OwoKCXBjbV9zZXRfc3BlZWQoRFNQX0RFRkFVTFRfU1BFRUQpOwoKCWlmICgocGFzX2F1ZGlvZGV2ID0gc291bmRfaW5zdGFsbF9hdWRpb2RydihBVURJT19EUklWRVJfVkVSU0lPTiwKCQkJCQkiUHJvIEF1ZGlvIFNwZWN0cnVtIiwKCQkJCQkmcGFzX2F1ZGlvX2RyaXZlciwKCQkJCQlzaXplb2Yoc3RydWN0IGF1ZGlvX2RyaXZlciksCgkJCQkJRE1BX0FVVE9NT0RFLAoJCQkJCUFGTVRfVTggfCBBRk1UX1MxNl9MRSwKCQkJCQlOVUxMLAoJCQkJCWh3X2NvbmZpZy0+ZG1hLAoJCQkJCWh3X2NvbmZpZy0+ZG1hKSkgPCAwKQoJCXByaW50ayhLRVJOX1dBUk5JTkcgIlBBUzE2OiBUb28gbWFueSBQQ00gZGV2aWNlcyBhdmFpbGFibGVcbiIpOwp9Cgp2b2lkIHBhc19wY21faW50ZXJydXB0KHVuc2lnbmVkIGNoYXIgc3RhdHVzLCBpbnQgY2F1c2UpCnsKCWlmIChjYXVzZSA9PSAxKQoJewoJCS8qCgkJICogSGFsdCB0aGUgUENNIGZpcnN0LiBPdGhlcndpc2Ugd2UgZG9uJ3QgaGF2ZSB0aW1lIHRvIHN0YXJ0IGEgbmV3CgkJICogYmxvY2sgYmVmb3JlIHRoZSBQQ00gY2hpcCBwcm9jZWVkcyB0byB0aGUgbmV4dCBzYW1wbGUKCQkgKi8KCgkJaWYgKCEoYXVkaW9fZGV2c1twYXNfYXVkaW9kZXZdLT5mbGFncyAmIERNQV9BVVRPTU9ERSkpCgkJCXBhc193cml0ZShwYXNfcmVhZCgweEY4QSkgJiB+MHg0MCwgMHhGOEEpOwoKCQlzd2l0Y2ggKHBjbV9tb2RlKQoJCXsKCQkJY2FzZSBQQ01fREFDOgoJCQkJRE1BYnVmX291dHB1dGludHIocGFzX2F1ZGlvZGV2LCAxKTsKCQkJCWJyZWFrOwoKCQkJY2FzZSBQQ01fQURDOgoJCQkJRE1BYnVmX2lucHV0aW50cihwYXNfYXVkaW9kZXYpOwoJCQkJYnJlYWs7CgoJCQlkZWZhdWx0OgoJCQkJcHJpbnRrKEtFUk5fV0FSTklORyAiUEFTOiBVbmV4cGVjdGVkIFBDTSBpbnRlcnJ1cHRcbiIpOwoJCX0KCX0KfQo=