Lyogdmk6IHNldCBzdz00IHRzPTQ6ICovCi8qCiAqIE1pbmkga2JkX21vZGUgaW1wbGVtZW50YXRpb24gZm9yIGJ1c3lib3gKICoKICogQ29weXJpZ2h0IChDKSAyMDA3IExv72MgR3JlbmnpIDxsb2ljLmdyZW5pZUBnbWFpbC5jb20+CiAqICAgd3JpdHRlbiB1c2luZyBBbmRyaWVzIEJyb3V3ZXIgPGFlYkBjd2kubmw+J3Mga2JkX21vZGUgZnJvbQogKiAgIGNvbnNvbGUtdXRpbHMgdjAuMi4zLCBsaWNlbnNlZCB1bmRlciBHTlUgR1BMdjIKICoKICogTGljZW5zZWQgdW5kZXIgR1BMdjIgb3IgbGF0ZXIsIHNlZSBmaWxlIExJQ0VOU0UgaW4gdGhpcyB0YXJiYWxsIGZvciBkZXRhaWxzLgogKgogKi8KCiNpbmNsdWRlICJsaWJiYi5oIgojaW5jbHVkZSA8bGludXgva2QuaD4KCmludCBrYmRfbW9kZV9tYWluKGludCBhcmdjLCBjaGFyICoqYXJndikgTUFJTl9FWFRFUk5BTExZX1ZJU0lCTEU7CmludCBrYmRfbW9kZV9tYWluKGludCBhcmdjIFVOVVNFRF9QQVJBTSwgY2hhciAqKmFyZ3YpCnsKCWludCBmZDsKCXVuc2lnbmVkIG9wdDsKCWVudW0gewoJCVNDQU5DT0RFICA9ICgxIDw8IDApLAoJCUFTQ0lJCSAgPSAoMSA8PCAxKSwKCQlNRURJVU1SQVcgPSAoMSA8PCAyKSwKCQlVTklDT0RFCSAgPSAoMSA8PCAzKQoJfTsKCXN0YXRpYyBjb25zdCBjaGFyIEtEX3h4eFtdIEFMSUdOMSA9ICJzYWt1IjsKCW9wdCA9IGdldG9wdDMyKGFyZ3YsIEtEX3h4eCk7CglmZCA9IGdldF9jb25zb2xlX2ZkX29yX2RpZSgpOwoKCWlmICghb3B0KSB7IC8qIHByaW50IGN1cnJlbnQgc2V0dGluZyAqLwoJCWNvbnN0IGNoYXIgKm1vZGUgPSAidW5rbm93biI7CgkJaW50IG07CgoJCWlvY3RsKGZkLCBLREdLQk1PREUsICZtKTsKCQlpZiAobSA9PSBLX1JBVykKCQkJbW9kZSA9ICJyYXcgKHNjYW5jb2RlKSI7CgkJZWxzZSBpZiAobSA9PSBLX1hMQVRFKQoJCQltb2RlID0gImRlZmF1bHQgKEFTQ0lJKSI7CgkJZWxzZSBpZiAobSA9PSBLX01FRElVTVJBVykKCQkJbW9kZSA9ICJtZWRpdW1yYXcgKGtleWNvZGUpIjsKCQllbHNlIGlmIChtID09IEtfVU5JQ09ERSkKCQkJbW9kZSA9ICJVbmljb2RlIChVVEYtOCkiOwoJCXByaW50ZigiVGhlIGtleWJvYXJkIGlzIGluICVzIG1vZGVcbiIsIG1vZGUpOwoJfSBlbHNlIHsKCQlvcHQgPSBvcHQgJiBVTklDT0RFID8gMyA6IG9wdCA+PiAxOwoJCS8qIGRvdWJsZSBjYXN0IHByZXZlbnRzIHdhcm5pbmdzIGFib3V0IHdpZGVuaW5nIGNvbnZlcnNpb24gKi8KCQl4aW9jdGwoZmQsIEtEU0tCTU9ERSwgKHZvaWQqKShwdHJkaWZmX3Qpb3B0KTsKCX0KCglpZiAoRU5BQkxFX0ZFQVRVUkVfQ0xFQU5fVVApCgkJY2xvc2UoZmQpOwoJcmV0dXJuIEVYSVRfU1VDQ0VTUzsKfQo=