LyoNCiAgICBGcmVlUlRPUyBWOC4wLjA6cmMxIC0gQ29weXJpZ2h0IChDKSAyMDE0IFJlYWwgVGltZSBFbmdpbmVlcnMgTHRkLg0KICAgIEFsbCByaWdodHMgcmVzZXJ2ZWQNCg0KICAgIFZJU0lUIGh0dHA6Ly93d3cuRnJlZVJUT1Mub3JnIFRPIEVOU1VSRSBZT1UgQVJFIFVTSU5HIFRIRSBMQVRFU1QgVkVSU0lPTi4NCg0KICAgICoqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKg0KICAgICAqICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqDQogICAgICogICAgRnJlZVJUT1MgcHJvdmlkZXMgY29tcGxldGVseSBmcmVlIHlldCBwcm9mZXNzaW9uYWxseSBkZXZlbG9wZWQsICAgICoNCiAgICAgKiAgICByb2J1c3QsIHN0cmljdGx5IHF1YWxpdHkgY29udHJvbGxlZCwgc3VwcG9ydGVkLCBhbmQgY3Jvc3MgICAgICAgICAgKg0KICAgICAqICAgIHBsYXRmb3JtIHNvZnR3YXJlIHRoYXQgaGFzIGJlY29tZSBhIGRlIGZhY3RvIHN0YW5kYXJkLiAgICAgICAgICAgICAqDQogICAgICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICoNCiAgICAgKiAgICBIZWxwIHlvdXJzZWxmIGdldCBzdGFydGVkIHF1aWNrbHkgYW5kIHN1cHBvcnQgdGhlIEZyZWVSVE9TICAgICAgICAgKg0KICAgICAqICAgIHByb2plY3QgYnkgcHVyY2hhc2luZyBhIEZyZWVSVE9TIHR1dG9yaWFsIGJvb2ssIHJlZmVyZW5jZSAgICAgICAgICAqDQogICAgICogICAgbWFudWFsLCBvciBib3RoIGZyb206IGh0dHA6Ly93d3cuRnJlZVJUT1Mub3JnL0RvY3VtZW50YXRpb24gICAgICAgICoNCiAgICAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKg0KICAgICAqICAgIFRoYW5rIHlvdSEgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqDQogICAgICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICoNCiAgICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCg0KICAgIFRoaXMgZmlsZSBpcyBwYXJ0IG9mIHRoZSBGcmVlUlRPUyBkaXN0cmlidXRpb24uDQoNCiAgICBGcmVlUlRPUyBpcyBmcmVlIHNvZnR3YXJlOyB5b3UgY2FuIHJlZGlzdHJpYnV0ZSBpdCBhbmQvb3IgbW9kaWZ5IGl0IHVuZGVyDQogICAgdGhlIHRlcm1zIG9mIHRoZSBHTlUgR2VuZXJhbCBQdWJsaWMgTGljZW5zZSAodmVyc2lvbiAyKSBhcyBwdWJsaXNoZWQgYnkgdGhlDQogICAgRnJlZSBTb2Z0d2FyZSBGb3VuZGF0aW9uID4+IUFORCBNT0RJRklFRCBCWSE8PCB0aGUgRnJlZVJUT1MgZXhjZXB0aW9uLg0KDQogICAgPj4hIE5PVEU6IFRoZSBtb2RpZmljYXRpb24gdG8gdGhlIEdQTCBpcyBpbmNsdWRlZCB0byBhbGxvdyB5b3UgdG8gZGlzdHJpYnV0ZQ0KICAgID4+ISBhIGNvbWJpbmVkIHdvcmsgdGhhdCBpbmNsdWRlcyBGcmVlUlRPUyB3aXRob3V0IGJlaW5nIG9ibGlnZWQgdG8gcHJvdmlkZQ0KICAgID4+ISB0aGUgc291cmNlIGNvZGUgZm9yIHByb3ByaWV0YXJ5IGNvbXBvbmVudHMgb3V0c2lkZSBvZiB0aGUgRnJlZVJUT1MNCiAgICA+PiEga2VybmVsLg0KDQogICAgRnJlZVJUT1MgaXMgZGlzdHJpYnV0ZWQgaW4gdGhlIGhvcGUgdGhhdCBpdCB3aWxsIGJlIHVzZWZ1bCwgYnV0IFdJVEhPVVQgQU5ZDQogICAgV0FSUkFOVFk7IHdpdGhvdXQgZXZlbiB0aGUgaW1wbGllZCB3YXJyYW50eSBvZiBNRVJDSEFOVEFCSUxJVFkgb3IgRklUTkVTUw0KICAgIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRS4gIEZ1bGwgbGljZW5zZSB0ZXh0IGlzIGF2YWlsYWJsZSBmcm9tIHRoZSBmb2xsb3dpbmcNCiAgICBsaW5rOiBodHRwOi8vd3d3LmZyZWVydG9zLm9yZy9hMDAxMTQuaHRtbA0KDQogICAgMSB0YWIgPT0gNCBzcGFjZXMhDQoNCiAgICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCiAgICAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKg0KICAgICAqICAgIEhhdmluZyBhIHByb2JsZW0/ICBTdGFydCBieSByZWFkaW5nIHRoZSBGQVEgIk15IGFwcGxpY2F0aW9uIGRvZXMgICAqDQogICAgICogICAgbm90IHJ1biwgd2hhdCBjb3VsZCBiZSB3cm9uZz8iICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICoNCiAgICAgKiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgKg0KICAgICAqICAgIGh0dHA6Ly93d3cuRnJlZVJUT1Mub3JnL0ZBUUhlbHAuaHRtbCAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAqDQogICAgICogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICoNCiAgICAqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioqKioNCg0KICAgIGh0dHA6Ly93d3cuRnJlZVJUT1Mub3JnIC0gRG9jdW1lbnRhdGlvbiwgYm9va3MsIHRyYWluaW5nLCBsYXRlc3QgdmVyc2lvbnMsDQogICAgbGljZW5zZSBhbmQgUmVhbCBUaW1lIEVuZ2luZWVycyBMdGQuIGNvbnRhY3QgZGV0YWlscy4NCg0KICAgIGh0dHA6Ly93d3cuRnJlZVJUT1Mub3JnL3BsdXMgLSBBIHNlbGVjdGlvbiBvZiBGcmVlUlRPUyBlY29zeXN0ZW0gcHJvZHVjdHMsDQogICAgaW5jbHVkaW5nIEZyZWVSVE9TK1RyYWNlIC0gYW4gaW5kaXNwZW5zYWJsZSBwcm9kdWN0aXZpdHkgdG9vbCwgYSBET1MNCiAgICBjb21wYXRpYmxlIEZBVCBmaWxlIHN5c3RlbSwgYW5kIG91ciB0aW55IHRocmVhZCBhd2FyZSBVRFAvSVAgc3RhY2suDQoNCiAgICBodHRwOi8vd3d3Lk9wZW5SVE9TLmNvbSAtIFJlYWwgVGltZSBFbmdpbmVlcnMgbHRkIGxpY2Vuc2UgRnJlZVJUT1MgdG8gSGlnaA0KICAgIEludGVncml0eSBTeXN0ZW1zIHRvIHNlbGwgdW5kZXIgdGhlIE9wZW5SVE9TIGJyYW5kLiAgTG93IGNvc3QgT3BlblJUT1MNCiAgICBsaWNlbnNlcyBvZmZlciB0aWNrZXRlZCBzdXBwb3J0LCBpbmRlbW5pZmljYXRpb24gYW5kIG1pZGRsZXdhcmUuDQoNCiAgICBodHRwOi8vd3d3LlNhZmVSVE9TLmNvbSAtIEhpZ2ggSW50ZWdyaXR5IFN5c3RlbXMgYWxzbyBwcm92aWRlIGEgc2FmZXR5DQogICAgZW5naW5lZXJlZCBhbmQgaW5kZXBlbmRlbnRseSBTSUwzIGNlcnRpZmllZCB2ZXJzaW9uIGZvciB1c2UgaW4gc2FmZXR5IGFuZA0KICAgIG1pc3Npb24gY3JpdGljYWwgYXBwbGljYXRpb25zIHRoYXQgcmVxdWlyZSBwcm92YWJsZSBkZXBlbmRhYmlsaXR5Lg0KDQogICAgMSB0YWIgPT0gNCBzcGFjZXMhDQoqLw0KDQoNCi8qDQogKiBDcmVhdGVzIGFsbCB0aGUgZGVtbyBhcHBsaWNhdGlvbiB0YXNrcywgdGhlbiBzdGFydHMgdGhlIHNjaGVkdWxlci4gIFRoZSBXRUINCiAqIGRvY3VtZW50YXRpb24gcHJvdmlkZXMgbW9yZSBkZXRhaWxzIG9mIHRoZSBzdGFuZGFyZCBkZW1vIGFwcGxpY2F0aW9uIHRhc2tzDQogKiAod2hpY2gganVzdCBleGlzdCB0byB0ZXN0IHRoZSBrZXJuZWwgcG9ydCBhbmQgcHJvdmlkZSBhbiBleGFtcGxlIG9mIGhvdyB0byB1c2UNCiAqIGVhY2ggRnJlZVJUT1MgQVBJIGZ1bmN0aW9uKS4NCiAqDQogKiBJbiBhZGRpdGlvbiB0byB0aGUgc3RhbmRhcmQgZGVtbyB0YXNrcywgdGhlIGZvbGxvd2luZyB0YXNrcyBhbmQgdGVzdHMgYXJlDQogKiBkZWZpbmVkIGFuZC9vciBjcmVhdGVkIHdpdGhpbiB0aGlzIGZpbGU6DQogKg0KICogIkNoZWNrIiB0YXNrIC0gVGhpcyBvbmx5IGV4ZWN1dGVzIGV2ZXJ5IGZpdmUgc2Vjb25kcyBidXQgaGFzIHRoZSBoaWdoZXN0DQogKiBwcmlvcml0eSBzbyBpcyBndWFyYW50ZWVkIHRvIGdldCBwcm9jZXNzb3IgdGltZS4gIEl0cyBtYWluIGZ1bmN0aW9uIGlzIHRvDQogKiBjaGVjayB0aGF0IGFsbCB0aGUgc3RhbmRhcmQgZGVtbyB0YXNrcyBhcmUgc3RpbGwgb3BlcmF0aW9uYWwuIFRoZSBjaGVjayB0YXNrDQogKiB3aWxsIHRvZ2dsZSBMRUQgMyAoUEIxMSkgZXZlcnkgZml2ZSBzZWNvbmRzIHNvIGxvbmcgYXMgbm8gZXJyb3JzIGhhdmUgYmVlbg0KICogZGV0ZWN0ZWQuICBUaGUgdG9nZ2xlIHJhdGUgd2lsbCBpbmNyZWFzZSB0byBoYWxmIGEgc2Vjb25kIGlmIGFuIGVycm9yIGhhcw0KICogYmVlbiBmb3VuZCBpbiBhbnkgdGFzay4NCiAqDQogKiAiRWNobyIgdGFzayAtIFRoaXMgaXMgYSB2ZXJ5IGJhc2ljIHRhc2sgdGhhdCBzaW1wbHkgZWNob2VzIGFueSBjaGFyYWN0ZXJzDQogKiByZWNlaXZlZCBvbiBDT00wIChVU0FSVDEpLiAgVGhpcyBjYW4gYmUgdGVzdGVkIGJ5IHRyYW5zbWl0dGluZyBhIHRleHQgZmlsZQ0KICogZnJvbSBhIGR1bWIgdGVybWluYWwgdG8gdGhlIFNUTTMyIFVTQVJUIHRoZW4gb2JzZXJ2aW5nIG9yIGNhcHR1cmluZyB0aGUgdGV4dA0KICogdGhhdCBpcyBlY2hvZWQgYmFjay4gIE1pc3NpbmcgY2hhcmFjdGVycyB3aWxsIGJlIGFsbCB0aGUgbW9yZSBvYnZpb3VzIGlmIHRoZQ0KICogZmlsZSBjb250YWlucyBhIHNpbXBsZSByZXBlYXRpbmcgc3RyaW5nIG9mIGZpeGVkIHdpZHRoLg0KICoNCiAqIEN1cnJlbnRseSB0aGlzIGRlbW8gZG9lcyBub3QgaW5jbHVkZSBpbnRlcnJ1cHQgbmVzdGluZyBleGFtcGxlcy4gIEhpZ2gNCiAqIGZyZXF1ZW5jeSB0aW1lciBhbmQgc2ltcGxlciBuZXN0aW5nIGV4YW1wbGVzIGNhbiBiZSBmb3VuZCBpbiBtb3N0IENvcnRleC1NMw0KICogZGVtbyBhcHBsaWNhdGlvbnMuDQogKg0KICogVGhlIGZ1bmN0aW9ucyB1c2VkIHRvIGluaXRpYWxpc2UsIHNldCBhbmQgY2xlYXIgTEVEIG91dHB1dHMgYXJlIG5vcm1hbGx5DQogKiBkZWZpbmVkIGluIHBhcnRlc3QuYy4gIFRoaXMgZGVtbyBpbmNsdWRlcyB0d28gcGFydGVzdCBmaWxlcywgb25lIHRoYXQgaXMNCiAqIGNvbmZpZ3VyZWQgZm9yIHVzZSB3aXRoIHRoZSBLZWlsIE1DQlNUTTMyIGV2YWx1YXRpb24gYm9hcmQgKGNhbGxlZA0KICogUGFyVGVzdF9NQ0JTVE0zMi5jKSBhbmQgb25lIHRoYXQgaXMgY29uZmlndXJlZCBmb3IgdXNlIHdpdGggdGhlIG9mZmljaWFsDQogKiBTVCBFdmFsIGJvYXJkIChjYWxsZWQgUGFyVGVzdF9TVF9FdmFsLmMpLiAgT25lIG9uZSBvZiB0aGVzZSBmaWxlcyBzaG91bGQgYmUNCiAqIGluY2x1ZGVkIGluIHRoZSBidWlsZCBhdCBhbnkgb25lIHRpbWUsIGFzIGFwcHJvcHJpYXRlIGZvciB0aGUgaGFyZHdhcmUNCiAqIGFjdHVhbGx5IGJlaW5nIHVzZWQuDQogKi8NCg0KLyogU3RhbmRhcmQgaW5jbHVkZXMuICovDQojaW5jbHVkZSA8c3RyaW5nLmg+DQoNCi8qIFNjaGVkdWxlciBpbmNsdWRlcy4gKi8NCiNpbmNsdWRlICJGcmVlUlRPUy5oIg0KI2luY2x1ZGUgInRhc2suaCINCiNpbmNsdWRlICJxdWV1ZS5oIg0KDQovKiBMaWJyYXJ5IGluY2x1ZGVzLiAqLw0KI2luY2x1ZGUgInN0bTMyZjEweF9pdC5oIg0KDQovKiBEZW1vIGFwcCBpbmNsdWRlcy4gKi8NCiNpbmNsdWRlICJCbG9ja1EuaCINCiNpbmNsdWRlICJpbnRlZ2VyLmgiDQojaW5jbHVkZSAiZmxhc2guaCINCiNpbmNsdWRlICJwYXJ0ZXN0LmgiDQojaW5jbHVkZSAic2VtdGVzdC5oIg0KI2luY2x1ZGUgIkdlblFUZXN0LmgiDQojaW5jbHVkZSAiUVBlZWsuaCINCiNpbmNsdWRlICJyZWNtdXRleC5oIg0KDQovKiBEcml2ZXIgaW5jbHVkZXMuICovDQojaW5jbHVkZSAiU1RNMzJfVVNBUlQuaCINCg0KDQovKiBUaGUgdGltZSBiZXR3ZWVuIGN5Y2xlcyBvZiB0aGUgJ2NoZWNrJyB0YXNrIC0gd2hpY2ggZGVwZW5kcyBvbiB3aGV0aGVyIHRoZQ0KY2hlY2sgdGFzayBoYXMgZGV0ZWN0ZWQgYW4gZXJyb3Igb3Igbm90LiAqLw0KI2RlZmluZSBtYWluQ0hFQ0tfREVMQVlfTk9fRVJST1IJCQkoICggcG9ydFRpY2tUeXBlICkgNTAwMCAvIHBvcnRUSUNLX1JBVEVfTVMgKQ0KI2RlZmluZSBtYWluQ0hFQ0tfREVMQVlfRVJST1IJCQkJKCAoIHBvcnRUaWNrVHlwZSApIDUwMCAvIHBvcnRUSUNLX1JBVEVfTVMgKQ0KDQovKiBUaGUgTEVEIGNvbnRyb2xsZWQgYnkgdGhlICdjaGVjaycgdGFzay4gKi8NCiNkZWZpbmUgbWFpbkNIRUNLX0xFRAkJCQkJCSggMyApDQoNCi8qIFRhc2sgcHJpb3JpdGllcy4gKi8NCiNkZWZpbmUgbWFpblNFTV9URVNUX1BSSU9SSVRZCQkJCSggdHNrSURMRV9QUklPUklUWSArIDEgKQ0KI2RlZmluZSBtYWluQkxPQ0tfUV9QUklPUklUWQkJCQkoIHRza0lETEVfUFJJT1JJVFkgKyAyICkNCiNkZWZpbmUgbWFpbkNIRUNLX1RBU0tfUFJJT1JJVFkJCQkJKCB0c2tJRExFX1BSSU9SSVRZICsgMyApDQojZGVmaW5lIG1haW5GTEFTSF9UQVNLX1BSSU9SSVRZCQkJCSggdHNrSURMRV9QUklPUklUWSArIDIgKQ0KI2RlZmluZSBtYWluRUNIT19UQVNLX1BSSU9SSVRZCQkJCSggdHNrSURMRV9QUklPUklUWSArIDEgKQ0KI2RlZmluZSBtYWluSU5URUdFUl9UQVNLX1BSSU9SSVRZICAgICAgICAgICAoIHRza0lETEVfUFJJT1JJVFkgKQ0KI2RlZmluZSBtYWluR0VOX1FVRVVFX1RBU0tfUFJJT1JJVFkJCQkoIHRza0lETEVfUFJJT1JJVFkgKQ0KDQovKiBDT00gcG9ydCBhbmQgYmF1ZCByYXRlIHVzZWQgYnkgdGhlIGVjaG8gdGFzay4gKi8NCiNkZWZpbmUgbWFpbkNPTTAJCQkJCQkJKCAwICkNCiNkZWZpbmUgbWFpbkJBVURfUkFURQkJCQkJCSggMTE1MjAwICkNCg0KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovDQoNCi8qDQogKiBDb25maWd1cmUgdGhlIGhhcmR3YXJlIGZvciB0aGUgZGVtby4NCiAqLw0Kc3RhdGljIHZvaWQgcHJ2U2V0dXBIYXJkd2FyZSggdm9pZCApOw0KDQovKiBUaGUgJ2NoZWNrJyB0YXNrIGFzIGRlc2NyaWJlZCBhdCB0aGUgdG9wIG9mIHRoaXMgZmlsZS4gKi8NCnN0YXRpYyB2b2lkIHBydkNoZWNrVGFzayggdm9pZCAqcHZQYXJhbWV0ZXJzICk7DQoNCi8qIEEgc2ltcGxlIHRhc2sgdGhhdCBlY2hvZXMgYWxsIHRoZSBjaGFyYWN0ZXJzIHRoYXQgYXJlIHJlY2VpdmVkIG9uIENPTTANCihVU0FSVDEpLiAqLw0Kc3RhdGljIHZvaWQgcHJ2VVNBUlRFY2hvVGFzayggdm9pZCAqcHZQYXJhbWV0ZXJzICk7DQoNCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLw0KDQppbnQgbWFpbiggdm9pZCApDQp7DQojaWZkZWYgREVCVUcNCiAgZGVidWcoKTsNCiNlbmRpZg0KDQoJLyogU2V0IHVwIHRoZSBjbG9ja3MgYW5kIG1lbW9yeSBpbnRlcmZhY2UuICovDQoJcHJ2U2V0dXBIYXJkd2FyZSgpOw0KDQoJLyogU3RhcnQgdGhlIHN0YW5kYXJkIGRlbW8gdGFza3MuICBUaGVzZSBhcmUganVzdCBoZXJlIHRvIGV4ZXJjaXNlIHRoZQ0KCWtlcm5lbCBwb3J0IGFuZCBwcm92aWRlIGV4YW1wbGVzIG9mIGhvdyB0aGUgRnJlZVJUT1MgQVBJIGNhbiBiZSB1c2VkLiAqLw0KCXZTdGFydEJsb2NraW5nUXVldWVUYXNrcyggbWFpbkJMT0NLX1FfUFJJT1JJVFkgKTsNCiAgICB2U3RhcnRTZW1hcGhvcmVUYXNrcyggbWFpblNFTV9URVNUX1BSSU9SSVRZICk7DQogICAgdlN0YXJ0SW50ZWdlck1hdGhUYXNrcyggbWFpbklOVEVHRVJfVEFTS19QUklPUklUWSApOw0KICAgIHZTdGFydEdlbmVyaWNRdWV1ZVRhc2tzKCBtYWluR0VOX1FVRVVFX1RBU0tfUFJJT1JJVFkgKTsNCgl2U3RhcnRMRURGbGFzaFRhc2tzKCBtYWluRkxBU0hfVEFTS19QUklPUklUWSApOw0KICAgIHZTdGFydFF1ZXVlUGVla1Rhc2tzKCk7DQogICAgdlN0YXJ0UmVjdXJzaXZlTXV0ZXhUYXNrcygpOw0KDQoJLyogQ3JlYXRlIHRoZSAnZWNobycgdGFzaywgd2hpY2ggaXMgYWxzbyBkZWZpbmVkIHdpdGhpbiB0aGlzIGZpbGUuICovDQoJeFRhc2tDcmVhdGUoIHBydlVTQVJURWNob1Rhc2ssICJFY2hvIiwgY29uZmlnTUlOSU1BTF9TVEFDS19TSVpFLCBOVUxMLCBtYWluRUNIT19UQVNLX1BSSU9SSVRZLCBOVUxMICk7DQoNCgkvKiBDcmVhdGUgdGhlICdjaGVjaycgdGFzaywgd2hpY2ggaXMgYWxzbyBkZWZpbmVkIHdpdGhpbiB0aGlzIGZpbGUuICovDQoJeFRhc2tDcmVhdGUoIHBydkNoZWNrVGFzaywgIkNoZWNrIiwgY29uZmlnTUlOSU1BTF9TVEFDS19TSVpFLCBOVUxMLCBtYWluQ0hFQ0tfVEFTS19QUklPUklUWSwgTlVMTCApOw0KDQogICAgLyogU3RhcnQgdGhlIHNjaGVkdWxlci4gKi8NCgl2VGFza1N0YXJ0U2NoZWR1bGVyKCk7DQoNCiAgICAvKiBXaWxsIG9ubHkgZ2V0IGhlcmUgaWYgdGhlcmUgd2FzIGluc3VmZmljaWVudCBtZW1vcnkgdG8gY3JlYXRlIHRoZSBpZGxlDQogICAgdGFzay4gIFRoZSBpZGxlIHRhc2sgaXMgY3JlYXRlZCB3aXRoaW4gdlRhc2tTdGFydFNjaGVkdWxlcigpLiAqLw0KCWZvciggOzsgKTsNCn0NCi8qLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0qLw0KDQovKiBEZXNjcmliZWQgYXQgdGhlIHRvcCBvZiB0aGlzIGZpbGUuICovDQpzdGF0aWMgdm9pZCBwcnZDaGVja1Rhc2soIHZvaWQgKnB2UGFyYW1ldGVycyApDQp7DQpwb3J0VGlja1R5cGUgeExhc3RFeGVjdXRpb25UaW1lOw0KdW5zaWduZWQgbG9uZyB1bFRpY2tzVG9XYWl0ID0gbWFpbkNIRUNLX0RFTEFZX05PX0VSUk9SOw0KDQoJLyogSnVzdCB0byByZW1vdmUgdGhlIGNvbXBpbGVyIHdhcm5pbmcgYWJvdXQgdGhlIHVudXNlZCBwYXJhbWV0ZXIuICovDQoJKCB2b2lkICkgcHZQYXJhbWV0ZXJzOw0KDQoJLyogSW5pdGlhbGlzZSB0aGUgdmFyaWFibGUgdXNlZCB0byBjb250cm9sIG91ciBpdGVyYXRpb24gcmF0ZSBwcmlvciB0bw0KCWl0cyBmaXJzdCB1c2UuICovDQoJeExhc3RFeGVjdXRpb25UaW1lID0geFRhc2tHZXRUaWNrQ291bnQoKTsNCg0KCWZvciggOzsgKQ0KCXsNCgkJLyogV2FpdCB1bnRpbCBpdCBpcyB0aW1lIHRvIHJ1biB0aGUgdGVzdHMgYWdhaW4uICovDQoJCXZUYXNrRGVsYXlVbnRpbCggJnhMYXN0RXhlY3V0aW9uVGltZSwgdWxUaWNrc1RvV2FpdCApOw0KDQoJCS8qIEhhcyBhbiBlcnJvciBiZWVuIGZvdW5kIGluIGFueSB0YXNrPyAqLw0KCQlpZiggeEFyZUdlbmVyaWNRdWV1ZVRhc2tzU3RpbGxSdW5uaW5nKCkgIT0gcGRUUlVFICkNCgkJew0KCQkJLyogUmVkdWNlIHRoZSB0aW1lIGJldHdlZW4gY3ljbGVzIG9mIHRoaXMgdGFzayAtIHdoaWNoIGhhcyB0aGUNCgkJCWVmZmVjdCBvZiBpbmNyZWFzaW5nIHRoZSByYXRlIGF0IHdoaWNoIHRoZSAnY2hlY2snIExFRCB0b2dnbGVzIHRvDQoJCQlpbmRpY2F0ZSB0aGUgZXhpc3RlbmNlIG9mIGFuIGVycm9yIHRvIGFuIG9ic2VydmVyLiAqLw0KCQkJdWxUaWNrc1RvV2FpdCA9IG1haW5DSEVDS19ERUxBWV9FUlJPUjsNCgkJfQ0KCQllbHNlIGlmKCB4QXJlUXVldWVQZWVrVGFza3NTdGlsbFJ1bm5pbmcoKSAhPSBwZFRSVUUgKQ0KCQl7DQoJCQl1bFRpY2tzVG9XYWl0ID0gbWFpbkNIRUNLX0RFTEFZX0VSUk9SOw0KCQl9DQoJCWVsc2UgaWYoIHhBcmVCbG9ja2luZ1F1ZXVlc1N0aWxsUnVubmluZygpICE9IHBkVFJVRSApDQoJCXsNCgkJCXVsVGlja3NUb1dhaXQgPSBtYWluQ0hFQ0tfREVMQVlfRVJST1I7DQoJCX0NCgkgICAgZWxzZSBpZiggeEFyZVNlbWFwaG9yZVRhc2tzU3RpbGxSdW5uaW5nKCkgIT0gcGRUUlVFICkNCgkgICAgew0KCSAgICAgICAgdWxUaWNrc1RvV2FpdCA9IG1haW5DSEVDS19ERUxBWV9FUlJPUjsNCgkgICAgfQ0KCSAgICBlbHNlIGlmKCB4QXJlSW50ZWdlck1hdGhzVGFza1N0aWxsUnVubmluZygpICE9IHBkVFJVRSApDQoJICAgIHsNCgkgICAgICAgIHVsVGlja3NUb1dhaXQgPSBtYWluQ0hFQ0tfREVMQVlfRVJST1I7DQoJICAgIH0NCgkgICAgZWxzZSBpZiggeEFyZVJlY3Vyc2l2ZU11dGV4VGFza3NTdGlsbFJ1bm5pbmcoKSAhPSBwZFRSVUUgKQ0KCSAgICB7DQoJICAgIAl1bFRpY2tzVG9XYWl0ID0gbWFpbkNIRUNLX0RFTEFZX0VSUk9SOw0KCSAgICB9DQoNCgkJdlBhclRlc3RUb2dnbGVMRUQoIG1haW5DSEVDS19MRUQgKTsNCgl9DQp9DQovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8NCg0KLyogRGVzY3JpYmVkIGF0IHRoZSB0b3Agb2YgdGhpcyBmaWxlLiAqLw0Kc3RhdGljIHZvaWQgcHJ2VVNBUlRFY2hvVGFzayggdm9pZCAqcHZQYXJhbWV0ZXJzICkNCnsNCnNpZ25lZCBjaGFyIGNDaGFyOw0KDQovKiBTdHJpbmcgZGVjbGFyZWQgc3RhdGljIHRvIGVuc3VyZSBpdCBkb2VzIG5vdCBlbmQgdXAgb24gdGhlIHN0YWNrLCBubyBtYXR0ZXINCndoYXQgdGhlIG9wdGltaXNhdGlvbiBsZXZlbC4gKi8NCnN0YXRpYyBjb25zdCBjaGFyICpwY0xvbmdpc2hTdHJpbmcgPQ0KIkFCQkEgd2FzIGEgU3dlZGlzaCBwb3AgbXVzaWMgZ3JvdXAgZm9ybWVkIGluIFN0b2NraG9sbSBpbiAxOTcyLCBjb25zaXN0aW5nIG9mIEFubmktRnJpZCBGcmlkYSBMeW5nc3RhZCwgIg0KIkJq9nJuIFVsdmFldXMsIEJlbm55IEFuZGVyc3NvbiBhbmQgQWduZXRoYSBG5Gx0c2tvZy4gVGhyb3VnaG91dCB0aGUgYmFuZCdzIGV4aXN0ZW5jZSwgRuRsdHNrb2cgYW5kIFVsdmFldXMgIg0KIndlcmUgYSBtYXJyaWVkIGNvdXBsZSwgYXMgd2VyZSBMeW5nc3RhZCBhbmQgQW5kZXJzc29uIC0gYWx0aG91Z2ggYm90aCBjb3VwbGVzIGxhdGVyIGRpdm9yY2VkLiBUaGV5IGJlY2FtZSBvbmUgIg0KIm9mIHRoZSBtb3N0IGNvbW1lcmNpYWxseSBzdWNjZXNzZnVsIGFjdHMgaW4gdGhlIGhpc3Rvcnkgb2YgcG9wdWxhciBtdXNpYywgYW5kIHRoZXkgdG9wcGVkIHRoZSBjaGFydHMgd29ybGR3aWRlICINCiJmcm9tIDE5NzIgdG8gMTk4My4gIEFCQkEgZ2FpbmVkIGludGVybmF0aW9uYWwgcG9wdWxhcml0eSBlbXBsb3lpbmcgY2F0Y2h5IHNvbmcgaG9va3MsIHNpbXBsZSBseXJpY3MsIHNvdW5kICINCiJlZmZlY3RzIChyZXZlcmIsIHBoYXNpbmcpIGFuZCBhIFdhbGwgb2YgU291bmQgYWNoaWV2ZWQgYnkgb3ZlcmR1YmJpbmcgdGhlIGZlbWFsZSBzaW5nZXJzJyB2b2ljZXMgaW4gbXVsdGlwbGUgIg0KImhhcm1vbmllcy4gQXMgdGhlaXIgcG9wdWxhcml0eSBncmV3LCB0aGV5IHdlcmUgc291Z2h0IGFmdGVyIHRvIHRvdXIgRXVyb3BlLCBBdXN0cmFsaWEsIGFuZCBOb3J0aCBBbWVyaWNhLCBkcmF3aW5nICINCiJjcm93ZHMgb2YgYXJkZW50IGZhbnMsIG5vdGFibHkgaW4gQXVzdHJhbGlhLiBUb3VyaW5nIGJlY2FtZSBhIGNvbnRlbnRpb3VzIGlzc3VlLCBiZWluZyBwYXJ0aWN1bGFybHkgY3VtYmVyc29tZSBmb3IgIg0KIkbkbHRza29nLCBidXQgdGhleSBjb250aW51ZWQgdG8gcmVsZWFzZSBzdHVkaW8gYWxidW1zIHRvIHdpZGVzcHJlYWQgY29tbWVyY2lhbCBzdWNjZXNzLiBBdCB0aGUgaGVpZ2h0IG9mIHRoZWlyICINCiJwb3B1bGFyaXR5LCBob3dldmVyLCBib3RoIHJlbGF0aW9uc2hpcHMgYmVnYW4gc3VmZmVyaW5nIHN0cmFpbiB0aGF0IGxlZCB1bHRpbWF0ZWx5IHRvIHRoZSBjb2xsYXBzZSBvZiBmaXJzdCB0aGUgIg0KIlVsdmFldXMtRuRsdHNrb2cgbWFycmlhZ2UgKGluIDE5NzkpIGFuZCB0aGVuIG9mIHRoZSBBbmRlcnNzb24tTHluZ3N0YWQgbWFycmlhZ2UgaW4gMTk4MS4gSW4gdGhlIGxhdGUgMTk3MHMgYW5kIGVhcmx5ICINCiIxOTgwcyB0aGVzZSByZWxhdGlvbnNoaXAgY2hhbmdlcyBiZWdhbiBtYW5pZmVzdGluZyBpbiB0aGUgZ3JvdXAncyBtdXNpYywgYXMgdGhleSBwcm9kdWNlZCBtb3JlIHRob3VnaHRmdWwsICINCiJpbnRyb3NwZWN0aXZlIGx5cmljcyB3aXRoIGRpZmZlcmVudCBjb21wb3NpdGlvbnMuIjsNCg0KCS8qIEp1c3QgdG8gYXZvaWQgY29tcGlsZXIgd2FybmluZ3MuICovDQoJKCB2b2lkICkgcHZQYXJhbWV0ZXJzOw0KDQoJLyogSW5pdGlhbGlzZSBDT00wLCB3aGljaCBpcyBVU0FSVDEgYWNjb3JkaW5nIHRvIHRoZSBTVE0zMiBsaWJyYXJpZXMuICovDQoJbENPTVBvcnRJbml0KCBtYWluQ09NMCwgbWFpbkJBVURfUkFURSApOw0KDQoJLyogVHJ5IHNlbmRpbmcgb3V0IGEgc3RyaW5nIGFsbCBpbiBvbmUgZ28sIGFzIGEgdmVyeSBiYXNpYyB0ZXN0IG9mIHRoZQ0KICAgIGxTZXJpYWxQdXRTdHJpbmcoKSBmdW5jdGlvbi4gKi8NCiAgICBsU2VyaWFsUHV0U3RyaW5nKCBtYWluQ09NMCwgcGNMb25naXNoU3RyaW5nLCBzdHJsZW4oIHBjTG9uZ2lzaFN0cmluZyApICk7DQoNCglmb3IoIDs7ICkNCgl7DQoJCS8qIEJsb2NrIHRvIHdhaXQgZm9yIGEgY2hhcmFjdGVyIHRvIGJlIHJlY2VpdmVkIG9uIENPTTAuICovDQoJCXhTZXJpYWxHZXRDaGFyKCBtYWluQ09NMCwgJmNDaGFyLCBwb3J0TUFYX0RFTEFZICk7DQoNCgkJLyogV3JpdGUgdGhlIHJlY2VpdmVkIGNoYXJhY3RlciBiYWNrIHRvIENPTTAuICovDQoJCXhTZXJpYWxQdXRDaGFyKCBtYWluQ09NMCwgY0NoYXIsIDAgKTsNCgl9DQp9DQovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8NCg0Kc3RhdGljIHZvaWQgcHJ2U2V0dXBIYXJkd2FyZSggdm9pZCApDQp7DQoJLyogUkNDIHN5c3RlbSByZXNldChmb3IgZGVidWcgcHVycG9zZSkuICovDQoJUkNDX0RlSW5pdCAoKTsNCg0KICAgIC8qIEVuYWJsZSBIU0UuICovDQoJUkNDX0hTRUNvbmZpZyggUkNDX0hTRV9PTiApOw0KDQoJLyogV2FpdCB0aWxsIEhTRSBpcyByZWFkeS4gKi8NCgl3aGlsZSAoUkNDX0dldEZsYWdTdGF0dXMoUkNDX0ZMQUdfSFNFUkRZKSA9PSBSRVNFVCk7DQoNCiAgICAvKiBIQ0xLID0gU1lTQ0xLLiAqLw0KCVJDQ19IQ0xLQ29uZmlnKCBSQ0NfU1lTQ0xLX0RpdjEgKTsNCg0KICAgIC8qIFBDTEsyICA9IEhDTEsuICovDQoJUkNDX1BDTEsyQ29uZmlnKCBSQ0NfSENMS19EaXYxICk7DQoNCiAgICAvKiBQQ0xLMSAgPSBIQ0xLLzIuICovDQoJUkNDX1BDTEsxQ29uZmlnKCBSQ0NfSENMS19EaXYyICk7DQoNCgkvKiBBRENDTEsgPSBQQ0xLMi80LiAqLw0KCVJDQ19BRENDTEtDb25maWcoIFJDQ19QQ0xLMl9EaXY0ICk7DQoNCiAgICAvKiBGbGFzaCAyIHdhaXQgc3RhdGUuICovDQoJKiggdm9sYXRpbGUgdW5zaWduZWQgbG9uZyAgKiApMHg0MDAyMjAwMCA9IDB4MDE7DQoNCgkvKiBQTExDTEsgPSA4TUh6ICogOSA9IDcyIE1IeiAqLw0KCVJDQ19QTExDb25maWcoIFJDQ19QTExTb3VyY2VfSFNFX0RpdjEsIFJDQ19QTExNdWxfOSApOw0KDQogICAgLyogRW5hYmxlIFBMTC4gKi8NCglSQ0NfUExMQ21kKCBFTkFCTEUgKTsNCg0KCS8qIFdhaXQgdGlsbCBQTEwgaXMgcmVhZHkuICovDQoJd2hpbGUgKFJDQ19HZXRGbGFnU3RhdHVzKFJDQ19GTEFHX1BMTFJEWSkgPT0gUkVTRVQpOw0KDQoJLyogU2VsZWN0IFBMTCBhcyBzeXN0ZW0gY2xvY2sgc291cmNlLiAqLw0KCVJDQ19TWVNDTEtDb25maWcgKFJDQ19TWVNDTEtTb3VyY2VfUExMQ0xLKTsNCg0KCS8qIFdhaXQgdGlsbCBQTEwgaXMgdXNlZCBhcyBzeXN0ZW0gY2xvY2sgc291cmNlLiAqLw0KCXdoaWxlIChSQ0NfR2V0U1lTQ0xLU291cmNlKCkgIT0gMHgwOCk7DQoNCgkvKiBFbmFibGUgR1BJT0EsIEdQSU9CLCBHUElPQywgR1BJT0QsIEdQSU9FIGFuZCBBRklPIGNsb2NrcyAqLw0KCVJDQ19BUEIyUGVyaXBoQ2xvY2tDbWQoCVJDQ19BUEIyUGVyaXBoX0dQSU9BIHwgUkNDX0FQQjJQZXJpcGhfR1BJT0IgfFJDQ19BUEIyUGVyaXBoX0dQSU9DDQoJCQkJCQkJfCBSQ0NfQVBCMlBlcmlwaF9HUElPRCB8IFJDQ19BUEIyUGVyaXBoX0dQSU9FIHwgUkNDX0FQQjJQZXJpcGhfQUZJTywgRU5BQkxFICk7DQoNCgkvKiBTZXQgdGhlIFZlY3RvciBUYWJsZSBiYXNlIGFkZHJlc3MgYXQgMHgwODAwMDAwMC4gKi8NCglOVklDX1NldFZlY3RvclRhYmxlKCBOVklDX1ZlY3RUYWJfRkxBU0gsIDB4MCApOw0KDQoJTlZJQ19Qcmlvcml0eUdyb3VwQ29uZmlnKCBOVklDX1ByaW9yaXR5R3JvdXBfNCApOw0KDQoJLyogQ29uZmlndXJlIEhDTEsgY2xvY2sgYXMgU3lzVGljayBjbG9jayBzb3VyY2UuICovDQoJU3lzVGlja19DTEtTb3VyY2VDb25maWcoIFN5c1RpY2tfQ0xLU291cmNlX0hDTEsgKTsNCg0KCS8qIEluaXRpYWxpc2UgdGhlIElPIHVzZWQgZm9yIHRoZSBMRUQgb3V0cHV0cy4gKi8NCgl2UGFyVGVzdEluaXRpYWxpc2UoKTsNCg0KCS8qIFNQSTIgUGVyaXBoIGNsb2NrIGVuYWJsZSAqLw0KCVJDQ19BUEIxUGVyaXBoQ2xvY2tDbWQoIFJDQ19BUEIxUGVyaXBoX1NQSTIsIEVOQUJMRSApOw0KfQ0KLyotLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLSovDQoNCnZvaWQgdkFwcGxpY2F0aW9uU3RhY2tPdmVyZmxvd0hvb2soIHhUYXNrSGFuZGxlIHB4VGFzaywgY2hhciAqcGNUYXNrTmFtZSApDQp7DQoJLyogVGhpcyBmdW5jdGlvbiB3aWxsIGdldCBjYWxsZWQgaWYgYSB0YXNrIG92ZXJmbG93cyBpdHMgc3RhY2suICAgSWYgdGhlDQoJcGFyYW1ldGVycyBhcmUgY29ycnVwdCB0aGVuIGluc3BlY3QgcHhDdXJyZW50VENCIHRvIGZpbmQgd2hpY2ggd2FzIHRoZQ0KCW9mZmVuZGluZyB0YXNrLiAqLw0KDQoJKCB2b2lkICkgcHhUYXNrOw0KCSggdm9pZCApIHBjVGFza05hbWU7DQoNCglmb3IoIDs7ICk7DQp9DQovKi0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tKi8NCg0Kdm9pZCBhc3NlcnRfZmFpbGVkKCB1bnNpZ25lZCBjaGFyICpwdWNGaWxlLCB1bnNpZ25lZCBsb25nIHVsTGluZSApDQp7DQoJKCB2b2lkICkgcHVjRmlsZTsNCgkoIHZvaWQgKSB1bExpbmU7DQoNCglmb3IoIDs7ICk7DQp9DQoNCg==