133990 2014-06-17 12:12:17 -0700 Refactor to remove unnecessary code from the string hashing functions 2014-06-24 09:49:28 -0700 1 1 1 Unclassified WebKit Web Template Framework 528+ (Nightly build) Unspecified Unspecified ASSIGNED BlinkMergeCandidate P2 Normal --- 1 manyoso manyoso andersca benjamin cmarcelo commit-queue darin dbates msaboff sam oldest_to_newest 1016198 0 manyoso 2014-06-17 12:12:17 -0700 StringHasher has methods to calculate the hash of a null terminated character array which internally calculate the length by searching for the null value at the end. These methods are only used by CStringTranslator in AtomicString to calculate the hash of a new AtomicString made by a string literal. These methods are both unnecessary and a bit costly because CStringTranslator, which is used by Hash* classes in WTF, searches for the end of the character array more than once and then once again when creating the StringImpl that backs the AtomicString. 1016203 1 233248 manyoso 2014-06-17 12:22:50 -0700 Created attachment 233248 Patch 1016287 2 dbates 2014-06-17 16:02:30 -0700 Blink review: <https://codereview.chromium.org/328453003> Blink commit: <https://src.chromium.org/viewvc/blink?revision=175826&view=revision> 1016667 3 manyoso 2014-06-19 07:33:09 -0700 (In reply to comment #2) > Blink review: <https://codereview.chromium.org/328453003> > Blink commit: <https://src.chromium.org/viewvc/blink?revision=175826&view=revision> Can you have a look please or suggest someone else to review? 1016947 4 233248 dbates 2014-06-20 10:13:42 -0700 Comment on attachment 233248 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=233248&action=review > Source/WTF/ChangeLog:6 > + Refactor to remove unnecessary code from the string hashing functions > + https://bugs.webkit.org/show_bug.cgi?id=133990 > + > + Previously, StringHasher contained methods for calculating the hash of a pure C We have an convention of referring to the original Blink commit when merging a Blink patch into WebKit by adding a remark to the ChangeLog entry/commit message of the form: Merged from Blink: https://src.chromium.org/viewvc/blink?revision=175826&view=revision You can see an example of ChangeLog entry/commit messages that reference this at <http://trac.webkit.org/changeset/166668>. > Source/WTF/ChangeLog:17 > + Reviewed by NOBODY (OOPS!). Please move the Reviewed by line to be on its own line under the WebKit bug URL. > Source/WTF/wtf/text/AtomicString.cpp:94 > - return addToStringTable<const LChar*, CStringTranslator>(c); > + return add(c, strlen(reinterpret_cast<const char*>(c))); This seems like a weird and indirect approach because AtomicString::add(const LChar*, unsigned) duplicates the precondition checks done in this function and otherwise calls through to AtomicString::addToStringTable<LCharBuffer, LCharBufferTranslator>(). We should take a similar approach as AtomicString::add(const UChar*) and stack allocate an LCharBuffer with the specified string and computed length and directly call AtomicString::addToStringTable<LCharBuffer, LCharBufferTranslator>(...), which may be inlined. > Tools/ChangeLog:6 > + Refactor to remove unnecessary code from the string hashing functions > + https://bugs.webkit.org/show_bug.cgi?id=133990 > + > + Previously, StringHasher contained methods for calculating the hash of a pure C Please also update this ChangeLog entry. 1017321 5 233248 darin 2014-06-21 12:46:40 -0700 Comment on attachment 233248 Patch As far as I can tell, this patch removes a “don’t iterate the string twice” optimization. 1017334 6 benjamin 2014-06-21 13:42:45 -0700 (In reply to comment #5) > (From update of attachment 233248 [details]) > As far as I can tell, this patch removes a “don’t iterate the string twice” optimization. I was thinking the same :) Any performance numbers Adam? How did you measure the improvement? 1017548 7 manyoso 2014-06-23 07:28:55 -0700 (In reply to comment #5) > (From update of attachment 233248 [details]) > As far as I can tell, this patch removes a “don’t iterate the string twice” optimization. Just the opposite unless I'm very mistaken. This patch removes additional iterations of the string in favor of one iteration up front. 1017549 8 manyoso 2014-06-23 07:30:19 -0700 (In reply to comment #6) > (In reply to comment #5) > > (From update of attachment 233248 [details] [details]) > > As far as I can tell, this patch removes a “don’t iterate the string twice” optimization. > > I was thinking the same :) > > Any performance numbers Adam? How did you measure the improvement? I did not measure any improvement. The reason for the patch is mostly a refactor to remove unnecessary code. I do believe it removes additional iterations of the string, but I haven't tried to measure it. 1017572 9 233248 dbates 2014-06-23 09:11:42 -0700 Comment on attachment 233248 Patch Looking over the patch again, I agree with Darin Adler's and Benjamin Poulain's remarks in comment #5 and comment #6, respectively, that this patch removes an optimization to avoid an iteration over the specified LChar string to be added to the table. Specifically this patch increases the algorithmic complexity of add() by a factor of N (the length of the LChar string to add to the table) when the string already exists in the table. Without the proposed patch the cost to add a string S with length N that already exists in the table is O(2N) = "cost to hash S" (O(N)) + "cost to perform an equality operation to ensure that a match with the same hash is identical to S" (O(N)). With the proposed patch the cost becomes O(3N) = "cost to compute strlen(S)" (O(N)) + "cost to hash S" (O(N)) + "cost to perform an equality operation to ensure that a match with the same hash is identical to S" (O(N)). 1017617 10 manyoso 2014-06-23 11:46:33 -0700 (In reply to comment #9) > (From update of attachment 233248 [details]) > Looking over the patch again, I agree with Darin Adler's and Benjamin Poulain's remarks in comment #5 and comment #6, respectively, that this patch removes an optimization to avoid an iteration over the specified LChar string to be added to the table. Specifically this patch increases the algorithmic complexity of add() by a factor of N (the length of the LChar string to add to the table) when the string already exists in the table. > > Without the proposed patch the cost to add a string S with length N that already exists in the table is O(2N) = "cost to hash S" (O(N)) + "cost to perform an equality operation to ensure that a match with the same hash is identical to S" (O(N)). With the proposed patch the cost becomes O(3N) = "cost to compute strlen(S)" (O(N)) + "cost to hash S" (O(N)) + "cost to perform an equality operation to ensure that a match with the same hash is identical to S" (O(N)). It also reduces by a factor of N when the string is not in the table, but hash clashes with another string of different length, right? 1017658 11 dbates 2014-06-23 13:14:01 -0700 (In reply to comment #10) > (In reply to comment #9) > > (From update of attachment 233248 [details] [details]) > > Looking over the patch again, I agree with Darin Adler's and Benjamin Poulain's remarks in comment #5 and comment #6, respectively, that this patch removes an optimization to avoid an iteration over the specified LChar string to be added to the table. Specifically this patch increases the algorithmic complexity of add() by a factor of N (the length of the LChar string to add to the table) when the string already exists in the table. > > > > Without the proposed patch the cost to add a string S with length N that already exists in the table is O(2N) = "cost to hash S" (O(N)) + "cost to perform an equality operation to ensure that a match with the same hash is identical to S" (O(N)). With the proposed patch the cost becomes O(3N) = "cost to compute strlen(S)" (O(N)) + "cost to hash S" (O(N)) + "cost to perform an equality operation to ensure that a match with the same hash is identical to S" (O(N)). > > It also reduces by a factor of N when the string is not in the table, but hash clashes with another string of different length, right? Can you elaborate? As far as I can tell, the proposed patch doesn't reduce the cost by a factor of N for such a situation. 1017697 12 manyoso 2014-06-23 14:38:45 -0700 (In reply to comment #11) > (In reply to comment #10) > > (In reply to comment #9) > > > (From update of attachment 233248 [details] [details] [details]) > > > Looking over the patch again, I agree with Darin Adler's and Benjamin Poulain's remarks in comment #5 and comment #6, respectively, that this patch removes an optimization to avoid an iteration over the specified LChar string to be added to the table. Specifically this patch increases the algorithmic complexity of add() by a factor of N (the length of the LChar string to add to the table) when the string already exists in the table. > > > > > > Without the proposed patch the cost to add a string S with length N that already exists in the table is O(2N) = "cost to hash S" (O(N)) + "cost to perform an equality operation to ensure that a match with the same hash is identical to S" (O(N)). With the proposed patch the cost becomes O(3N) = "cost to compute strlen(S)" (O(N)) + "cost to hash S" (O(N)) + "cost to perform an equality operation to ensure that a match with the same hash is identical to S" (O(N)). > > > > It also reduces by a factor of N when the string is not in the table, but hash clashes with another string of different length, right? > > Can you elaborate? > > As far as I can tell, the proposed patch doesn't reduce the cost by a factor of N for such a situation. In such a situation, the proposed patch will consist of: "cost to compute strlen(S)" (O(N) + "cost to hash S" (O(N)) + "cost to determine the two strings don't match which is early return 'S.length != S1.length" whereas without the patch it would be: "cost to hash S" (O(N)) + "cost to perform an equality operation to ensure that a match with the same hash is identical to S" (O(N)) + cost to create new StringImpl by calling strlen at the end correct? 1017976 13 dbates 2014-06-24 09:45:18 -0700 (In reply to comment #12) > > > [...] > > > It also reduces by a factor of N when the string is not in the table, but hash clashes with another string of different length, right? > > > > Can you elaborate? > > > > As far as I can tell, the proposed patch doesn't reduce the cost by a factor of N for such a situation. > > In such a situation, the proposed patch will consist of: > > "cost to compute strlen(S)" (O(N) + "cost to hash S" (O(N)) + "cost to determine the two strings don't match which is early return 'S.length != S1.length" > > whereas without the patch it would be: > > "cost to hash S" (O(N)) + "cost to perform an equality operation to ensure that a match with the same hash is identical to S" (O(N)) + cost to create new StringImpl by calling strlen at the end > > correct? You're right for this case! As aforementioned, the proposed patch increases the algorithmic complexity of add() by a factor of N when the string already exists in the table. I'm unclear which case is more likely to happen in practice. Are you able to measure it? 1017977 14 dbates 2014-06-24 09:49:28 -0700 Let S and S' be strings. We stay S == S' if the contents of the strings are identical. The following are different cases and their worst-case algorithmic complexities with and without the proposed patch: Case 1: Suppose S != S', strlen(S) == strlen(S'), hash(S) == hash(S') and S' is in the atomic string table. AtomicString::add(S): Without patch: O(4N) = "cost of hash(S)" (O(N)) + "cost to compare S and S'" (O(N)) + "cost to compute strlen(S)" (O(N)) + "cost to copy the buffer in StringImpl::createInternal()" (O(N)) With patch: O(4N) = "cost to compute strlen(S)" (O(N)) + "cost of hash(S)" (O(N)) + "cost to compare S and S'" (O(N)) + "cost to copy the buffer in StringImpl::createInternal()" (O(N)) Case 2: Suppose S != S', strlen(S) != strlen(S'), hash(S) == hash(S') and S' is in the atomic string table. AtomicString::add(S): Without patch: O(4N) = "cost of hash(S)" (O(N)) + "cost to compare S and S'" (O(N)) + "cost to compute strlen(S)" (O(N)) + "cost to copy the buffer in StringImpl::createInternal()" (O(N)) With patch: O(3N) = "cost to compute strlen(S)" (O(N)) + "cost of hash(S)" (O(N)) + "cost to compare S and S'" (O(1)) + "cost to copy the buffer in StringImpl::createInternal()" (O(N)) Case 3: Suppose S == S', strlen(S) == strlen(S'), hash(S) == hash(S') and S' is in the atomic string table. AtomicString::add(S): Without patch: O(2N) = "cost of hash(S)" (O(N)) + "cost to compare S and S'" (O(N)) With patch: O(3N) = "cost to compute strlen(S)" (O(N)) + "cost of hash(S)" (O(N)) + "cost to compare S and S'" (O(N)) Case 4: Suppose hash(S) != hash(S_i) for every string S_i in the atomic string table. AtomicString::add(S): Without patch: O(3N) = "cost of hash(S)" (O(N)) + "cost to compute strlen(S)" (O(N)) + "cost to copy the buffer in StringImpl::createInternal()" (O(N)) With patch: O(3N) = "cost to compute strlen(S)" (O(N)) + "cost of hash(S)" (O(N)) + "cost to copy the buffer in StringImpl::createInternal()" (O(N)) 233248 2014-06-17 12:22:50 -0700 2014-06-23 09:11:41 -0700 Patch bug-133990-20140617152226.patch text/plain 16241 manyoso U3VidmVyc2lvbiBSZXZpc2lvbjogMTcwMDE1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDIxNTQyMmFiN2ExNzcxY2ZiZmEwZjg4 OTBkYjI1Y2I3YzliYTUzMTEuLjI3NjY0NDdlODUyNTc0YzM3YTcyMGI0NmM2OWU0MDUzNWVhZGQ5 NTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTQtMDYtMTcgIEFkYW0gVHJlYXQgIDxhZGFtLnRy ZWF0QHNhbXN1bmcuY29tPgorCisgICAgICAgIFJlZmFjdG9yIHRvIHJlbW92ZSB1bm5lY2Vzc2Fy eSBjb2RlIGZyb20gdGhlIHN0cmluZyBoYXNoaW5nIGZ1bmN0aW9ucworICAgICAgICBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTMzOTkwCisKKyAgICAgICAgUHJldmlv dXNseSwgU3RyaW5nSGFzaGVyIGNvbnRhaW5lZCBtZXRob2RzIGZvciBjYWxjdWxhdGluZyB0aGUg aGFzaCBvZiBhIHB1cmUgQworICAgICAgICBjaGFyYWN0ZXIgYXJyYXkgd2l0aG91dCBoYXZpbmcg dG8gcGFzcyBpbiB0aGUgbGVuZ3RoIG9mIHRoZSBhcnJheS4gVGhpcyB3YXMgb25seQorICAgICAg ICB1c2VkIGZvciBBdG9taWNTdHJpbmdzIGNvbnN0cnVjdGVkIHZpYSBhIHN0cmluZyBsaXRlcmFs LiBUaGUgaW1wbCBvZiB0aGUgc3BlY2lmaWMKKyAgICAgICAgaGFzaGluZyBmdW5jdGlvbiBjdXJy ZW50bHkgdXNlZCBpbiBXVEYgYWxyZWFkeSBjaGVja3MgZm9yIG51bGwgdGVybWluYXRlZCBjaGFy YWN0ZXIKKyAgICAgICAgYXJyYXkgYW5kIHdoZW4gdGhlIGZpbmFsIFN0cmluZ0ltcGwqIGZvciB0 aGUgQXRvbWljU3RyaW5nIGlzIGNvbnN0cnVjdGVkIHdlCisgICAgICAgIGRvIHNvIGFnYWluLgor CisgICAgICAgIFRoaXMgcGF0Y2gganVzdCBjb21wdXRlcyB0aGUgbGVuZ3RoIHVwIGZyb250IGFu ZCBwYXNzZXMgdGhhdCBpbmZvcm1hdGlvbiBhbG9uZworICAgICAgICB0byB0aGUgaGFzaGluZyBm dW5jdGlvbi4gIEV2ZW50dWFsbHkgdGhpcyBsZW5ndGggaXMgdXNlZCB0byBjb25zdHJ1Y3QgdGhl CisgICAgICAgIFN0cmluZ0ltcGwgd2l0aG91dCBjb21wdXRpbmcgYWdhaW4uCisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiB3dGYvU3RyaW5nSGFzaGVy Lmg6CisgICAgICAgIChXVEY6OlN0cmluZ0hhc2hlcjo6YWRkQ2hhcmFjdGVyc0Fzc3VtaW5nQWxp Z25lZCk6IERlbGV0ZWQuCisgICAgICAgIChXVEY6OlN0cmluZ0hhc2hlcjo6YWRkQ2hhcmFjdGVy cyk6IERlbGV0ZWQuCisgICAgICAgIChXVEY6OlN0cmluZ0hhc2hlcjo6Y29tcHV0ZUhhc2hBbmRN YXNrVG9wOEJpdHMpOiBEZWxldGVkLgorICAgICAgICAoV1RGOjpTdHJpbmdIYXNoZXI6OmNvbXB1 dGVIYXNoKTogRGVsZXRlZC4KKyAgICAgICAgKiB3dGYvdGV4dC9BdG9taWNTdHJpbmcuY3BwOgor ICAgICAgICAoV1RGOjpBdG9taWNTdHJpbmc6OmFkZCk6CisgICAgICAgIChXVEY6OkNTdHJpbmdU cmFuc2xhdG9yOjpoYXNoKTogRGVsZXRlZC4KKyAgICAgICAgKFdURjo6Q1N0cmluZ1RyYW5zbGF0 b3I6OmVxdWFsKTogRGVsZXRlZC4KKyAgICAgICAgKFdURjo6Q1N0cmluZ1RyYW5zbGF0b3I6OnRy YW5zbGF0ZSk6IERlbGV0ZWQuCisKIDIwMTQtMDYtMTUgIERhbiBCZXJuc3RlaW4gIDxtaXR6QGFw cGxlLmNvbT4KIAogICAgICAgICBpT1MgYnVpbGQgZml4IGFmdGVyIHIxNjk5OTUuCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV1RGL3d0Zi9TdHJpbmdIYXNoZXIuaCBiL1NvdXJjZS9XVEYvd3RmL1N0cmlu Z0hhc2hlci5oCmluZGV4IDBmZGRiYmRiYWZhNDQxOGQyZTJkYzE1MDFjODk1ZTk4ZDlmYjMzODgu LmFlMDBhMTY0ZWIzOThhY2EzYmMxNzhkMmUyMjA0YWJlZTQ4YzEzZWMgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XVEYvd3RmL1N0cmluZ0hhc2hlci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1N0cmluZ0hh c2hlci5oCkBAIC0xMTAsMjUgKzExMCw2IEBAIHB1YmxpYzoKICAgICAgICAgYWRkQ2hhcmFjdGVy c0Fzc3VtaW5nQWxpZ25lZDxULCBkZWZhdWx0Q29udmVydGVyPihkYXRhLCBsZW5ndGgpOwogICAg IH0KIAotICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQsIFVDaGFyIENvbnZlcnRlcihUKT4gdm9pZCBh ZGRDaGFyYWN0ZXJzQXNzdW1pbmdBbGlnbmVkKGNvbnN0IFQqIGRhdGEpCi0gICAgewotICAgICAg ICBBU1NFUlQoIW1faGFzUGVuZGluZ0NoYXJhY3Rlcik7Ci0KLSAgICAgICAgd2hpbGUgKFQgYSA9 ICpkYXRhKyspIHsKLSAgICAgICAgICAgIFQgYiA9ICpkYXRhKys7Ci0gICAgICAgICAgICBpZiAo IWIpIHsKLSAgICAgICAgICAgICAgICBhZGRDaGFyYWN0ZXIoQ29udmVydGVyKGEpKTsKLSAgICAg ICAgICAgICAgICBicmVhazsKLSAgICAgICAgICAgIH0KLSAgICAgICAgICAgIGFkZENoYXJhY3Rl cnNBc3N1bWluZ0FsaWduZWQoQ29udmVydGVyKGEpLCBDb252ZXJ0ZXIoYikpOwotICAgICAgICB9 Ci0gICAgfQotCi0gICAgdGVtcGxhdGU8dHlwZW5hbWUgVD4gdm9pZCBhZGRDaGFyYWN0ZXJzQXNz dW1pbmdBbGlnbmVkKGNvbnN0IFQqIGRhdGEpCi0gICAgewotICAgICAgICBhZGRDaGFyYWN0ZXJz QXNzdW1pbmdBbGlnbmVkPFQsIGRlZmF1bHRDb252ZXJ0ZXI+KGRhdGEpOwotICAgIH0KLQogICAg IHRlbXBsYXRlPHR5cGVuYW1lIFQsIFVDaGFyIENvbnZlcnRlcihUKT4gdm9pZCBhZGRDaGFyYWN0 ZXJzKGNvbnN0IFQqIGRhdGEsIHVuc2lnbmVkIGxlbmd0aCkKICAgICB7CiAgICAgICAgIGlmICht X2hhc1BlbmRpbmdDaGFyYWN0ZXIgJiYgbGVuZ3RoKSB7CkBAIC0xNDQsMjAgKzEyNSw2IEBAIHB1 YmxpYzoKICAgICAgICAgYWRkQ2hhcmFjdGVyczxULCBkZWZhdWx0Q29udmVydGVyPihkYXRhLCBs ZW5ndGgpOwogICAgIH0KIAotICAgIHRlbXBsYXRlPHR5cGVuYW1lIFQsIFVDaGFyIENvbnZlcnRl cihUKT4gdm9pZCBhZGRDaGFyYWN0ZXJzKGNvbnN0IFQqIGRhdGEpCi0gICAgewotICAgICAgICBp ZiAobV9oYXNQZW5kaW5nQ2hhcmFjdGVyICYmICpkYXRhKSB7Ci0gICAgICAgICAgICBtX2hhc1Bl bmRpbmdDaGFyYWN0ZXIgPSBmYWxzZTsKLSAgICAgICAgICAgIGFkZENoYXJhY3RlcnNBc3N1bWlu Z0FsaWduZWQobV9wZW5kaW5nQ2hhcmFjdGVyLCBDb252ZXJ0ZXIoKmRhdGErKykpOwotICAgICAg ICB9Ci0gICAgICAgIGFkZENoYXJhY3RlcnNBc3N1bWluZ0FsaWduZWQ8VCwgQ29udmVydGVyPihk YXRhKTsKLSAgICB9Ci0KLSAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiB2b2lkIGFkZENoYXJhY3Rl cnMoY29uc3QgVCogZGF0YSkKLSAgICB7Ci0gICAgICAgIGFkZENoYXJhY3RlcnM8VCwgZGVmYXVs dENvbnZlcnRlcj4oZGF0YSk7Ci0gICAgfQotCiAgICAgdW5zaWduZWQgaGFzaFdpdGhUb3A4Qml0 c01hc2tlZCgpIGNvbnN0CiAgICAgewogICAgICAgICB1bnNpZ25lZCByZXN1bHQgPSBhdmFsYW5j aGVCaXRzKCk7CkBAIC0xOTcsMjMgKzE2NCwxMSBAQCBwdWJsaWM6CiAgICAgICAgIHJldHVybiBo YXNoZXIuaGFzaFdpdGhUb3A4Qml0c01hc2tlZCgpOwogICAgIH0KIAotICAgIHRlbXBsYXRlPHR5 cGVuYW1lIFQsIFVDaGFyIENvbnZlcnRlcihUKT4gc3RhdGljIHVuc2lnbmVkIGNvbXB1dGVIYXNo QW5kTWFza1RvcDhCaXRzKGNvbnN0IFQqIGRhdGEpCi0gICAgewotICAgICAgICBTdHJpbmdIYXNo ZXIgaGFzaGVyOwotICAgICAgICBoYXNoZXIuYWRkQ2hhcmFjdGVyc0Fzc3VtaW5nQWxpZ25lZDxU LCBDb252ZXJ0ZXI+KGRhdGEpOwotICAgICAgICByZXR1cm4gaGFzaGVyLmhhc2hXaXRoVG9wOEJp dHNNYXNrZWQoKTsKLSAgICB9Ci0KICAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBzdGF0aWMgdW5z aWduZWQgY29tcHV0ZUhhc2hBbmRNYXNrVG9wOEJpdHMoY29uc3QgVCogZGF0YSwgdW5zaWduZWQg bGVuZ3RoKQogICAgIHsKICAgICAgICAgcmV0dXJuIGNvbXB1dGVIYXNoQW5kTWFza1RvcDhCaXRz PFQsIGRlZmF1bHRDb252ZXJ0ZXI+KGRhdGEsIGxlbmd0aCk7CiAgICAgfQogCi0gICAgdGVtcGxh dGU8dHlwZW5hbWUgVD4gc3RhdGljIHVuc2lnbmVkIGNvbXB1dGVIYXNoQW5kTWFza1RvcDhCaXRz KGNvbnN0IFQqIGRhdGEpCi0gICAgewotICAgICAgICByZXR1cm4gY29tcHV0ZUhhc2hBbmRNYXNr VG9wOEJpdHM8VCwgZGVmYXVsdENvbnZlcnRlcj4oZGF0YSk7Ci0gICAgfQotCiAgICAgdGVtcGxh dGU8dHlwZW5hbWUgVCwgVUNoYXIgQ29udmVydGVyKFQpPiBzdGF0aWMgdW5zaWduZWQgY29tcHV0 ZUhhc2goY29uc3QgVCogZGF0YSwgdW5zaWduZWQgbGVuZ3RoKQogICAgIHsKICAgICAgICAgU3Ry aW5nSGFzaGVyIGhhc2hlcjsKQEAgLTIyMSwyMyArMTc2LDExIEBAIHB1YmxpYzoKICAgICAgICAg cmV0dXJuIGhhc2hlci5oYXNoKCk7CiAgICAgfQogCi0gICAgdGVtcGxhdGU8dHlwZW5hbWUgVCwg VUNoYXIgQ29udmVydGVyKFQpPiBzdGF0aWMgdW5zaWduZWQgY29tcHV0ZUhhc2goY29uc3QgVCog ZGF0YSkKLSAgICB7Ci0gICAgICAgIFN0cmluZ0hhc2hlciBoYXNoZXI7Ci0gICAgICAgIGhhc2hl ci5hZGRDaGFyYWN0ZXJzQXNzdW1pbmdBbGlnbmVkPFQsIENvbnZlcnRlcj4oZGF0YSk7Ci0gICAg ICAgIHJldHVybiBoYXNoZXIuaGFzaCgpOwotICAgIH0KLQogICAgIHRlbXBsYXRlPHR5cGVuYW1l IFQ+IHN0YXRpYyB1bnNpZ25lZCBjb21wdXRlSGFzaChjb25zdCBUKiBkYXRhLCB1bnNpZ25lZCBs ZW5ndGgpCiAgICAgewogICAgICAgICByZXR1cm4gY29tcHV0ZUhhc2g8VCwgZGVmYXVsdENvbnZl cnRlcj4oZGF0YSwgbGVuZ3RoKTsKICAgICB9CiAKLSAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBUPiBz dGF0aWMgdW5zaWduZWQgY29tcHV0ZUhhc2goY29uc3QgVCogZGF0YSkKLSAgICB7Ci0gICAgICAg IHJldHVybiBjb21wdXRlSGFzaDxULCBkZWZhdWx0Q29udmVydGVyPihkYXRhKTsKLSAgICB9Ci0K ICAgICBzdGF0aWMgdW5zaWduZWQgaGFzaE1lbW9yeShjb25zdCB2b2lkKiBkYXRhLCB1bnNpZ25l ZCBsZW5ndGgpCiAgICAgewogICAgICAgICAvLyBGSVhNRTogV2h5IGRvZXMgdGhpcyBmdW5jdGlv biB1c2UgdGhlIHZlcnNpb24gb2YgdGhlIGhhc2ggdGhhdCBkcm9wcyB0aGUgdG9wIDggYml0cz8K ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL3RleHQvQXRvbWljU3RyaW5nLmNwcCBiL1NvdXJj ZS9XVEYvd3RmL3RleHQvQXRvbWljU3RyaW5nLmNwcAppbmRleCBmMDQ4MDFjMWZiOTgzOGMwM2Y5 YjMzMzlmNmM1ODI4YWZkMzI2MTQ5Li5hMmE3Y2Q1MzA2NjRiNmZjMzEwZjIxNDQ0YWVkNjU2OTEx ZDAwOTlmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi90ZXh0L0F0b21pY1N0cmluZy5jcHAK KysrIGIvU291cmNlL1dURi93dGYvdGV4dC9BdG9taWNTdHJpbmcuY3BwCkBAIC04NCwyNSArODQs NiBAQCBzdGF0aWMgaW5saW5lIFBhc3NSZWZQdHI8U3RyaW5nSW1wbD4gYWRkVG9TdHJpbmdUYWJs ZShjb25zdCBUJiB2YWx1ZSkKICAgICByZXR1cm4gYWRkUmVzdWx0LmlzTmV3RW50cnkgPyBhZG9w dFJlZigqYWRkUmVzdWx0Lml0ZXJhdG9yKSA6ICphZGRSZXN1bHQuaXRlcmF0b3I7CiB9CiAKLXN0 cnVjdCBDU3RyaW5nVHJhbnNsYXRvciB7Ci0gICAgc3RhdGljIHVuc2lnbmVkIGhhc2goY29uc3Qg TENoYXIqIGMpCi0gICAgewotICAgICAgICByZXR1cm4gU3RyaW5nSGFzaGVyOjpjb21wdXRlSGFz aEFuZE1hc2tUb3A4Qml0cyhjKTsKLSAgICB9Ci0KLSAgICBzdGF0aWMgaW5saW5lIGJvb2wgZXF1 YWwoU3RyaW5nSW1wbCogciwgY29uc3QgTENoYXIqIHMpCi0gICAgewotICAgICAgICByZXR1cm4g V1RGOjplcXVhbChyLCBzKTsKLSAgICB9Ci0KLSAgICBzdGF0aWMgdm9pZCB0cmFuc2xhdGUoU3Ry aW5nSW1wbComIGxvY2F0aW9uLCBjb25zdCBMQ2hhciogY29uc3QmIGMsIHVuc2lnbmVkIGhhc2gp Ci0gICAgewotICAgICAgICBsb2NhdGlvbiA9ICZTdHJpbmdJbXBsOjpjcmVhdGUoYykubGVha1Jl ZigpOwotICAgICAgICBsb2NhdGlvbi0+c2V0SGFzaChoYXNoKTsKLSAgICAgICAgbG9jYXRpb24t PnNldElzQXRvbWljKHRydWUpOwotICAgIH0KLX07Ci0KIFBhc3NSZWZQdHI8U3RyaW5nSW1wbD4g QXRvbWljU3RyaW5nOjphZGQoY29uc3QgTENoYXIqIGMpCiB7CiAgICAgaWYgKCFjKQpAQCAtMTEw LDcgKzkxLDcgQEAgUGFzc1JlZlB0cjxTdHJpbmdJbXBsPiBBdG9taWNTdHJpbmc6OmFkZChjb25z dCBMQ2hhciogYykKICAgICBpZiAoISpjKQogICAgICAgICByZXR1cm4gU3RyaW5nSW1wbDo6ZW1w dHkoKTsKIAotICAgIHJldHVybiBhZGRUb1N0cmluZ1RhYmxlPGNvbnN0IExDaGFyKiwgQ1N0cmlu Z1RyYW5zbGF0b3I+KGMpOworICAgIHJldHVybiBhZGQoYywgc3RybGVuKHJlaW50ZXJwcmV0X2Nh c3Q8Y29uc3QgY2hhcio+KGMpKSk7CiB9CiAKIHRlbXBsYXRlPHR5cGVuYW1lIENoYXJhY3RlclR5 cGU+CmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9DaGFuZ2VMb2cKaW5kZXgg YTBmZGQ1ZDgwNDc3MTE1OGJlZGU1YjRjYzMzMGU0NDQxZWUxY2FiZC4uNTcyNDM4ZDdmMTYyM2Mw MDgxNjZkMjg0ZDZkMjE1MGVhNmFhNjc5NSAxMDA2NDQKLS0tIGEvVG9vbHMvQ2hhbmdlTG9nCisr KyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDI0IEBACisyMDE0LTA2LTE3ICBBZGFtIFRy ZWF0ICA8YWRhbS50cmVhdEBzYW1zdW5nLmNvbT4KKworICAgICAgICBSZWZhY3RvciB0byByZW1v dmUgdW5uZWNlc3NhcnkgY29kZSBmcm9tIHRoZSBzdHJpbmcgaGFzaGluZyBmdW5jdGlvbnMKKyAg ICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEzMzk5MAorCisg ICAgICAgIFByZXZpb3VzbHksIFN0cmluZ0hhc2hlciBjb250YWluZWQgbWV0aG9kcyBmb3IgY2Fs Y3VsYXRpbmcgdGhlIGhhc2ggb2YgYSBwdXJlIEMKKyAgICAgICAgY2hhcmFjdGVyIGFycmF5IHdp dGhvdXQgaGF2aW5nIHRvIHBhc3MgaW4gdGhlIGxlbmd0aCBvZiB0aGUgYXJyYXkuIFRoaXMgd2Fz IG9ubHkKKyAgICAgICAgdXNlZCBmb3IgQXRvbWljU3RyaW5ncyBjb25zdHJ1Y3RlZCB2aWEgYSBz dHJpbmcgbGl0ZXJhbC4gVGhlIGltcGwgb2YgdGhlIHNwZWNpZmljCisgICAgICAgIGhhc2hpbmcg ZnVuY3Rpb24gY3VycmVudGx5IHVzZWQgaW4gV1RGIGFscmVhZHkgY2hlY2tzIGZvciBudWxsIHRl cm1pbmF0ZWQgY2hhcmFjdGVyCisgICAgICAgIGFycmF5IGFuZCB3aGVuIHRoZSBmaW5hbCBTdHJp bmdJbXBsKiBmb3IgdGhlIEF0b21pY1N0cmluZyBpcyBjb25zdHJ1Y3RlZCB3ZQorICAgICAgICBk byBzbyBhZ2Fpbi4KKworICAgICAgICBUaGlzIHBhdGNoIGp1c3QgY29tcHV0ZXMgdGhlIGxlbmd0 aCB1cCBmcm9udCBhbmQgcGFzc2VzIHRoYXQgaW5mb3JtYXRpb24gYWxvbmcKKyAgICAgICAgdG8g dGhlIGhhc2hpbmcgZnVuY3Rpb24uICBFdmVudHVhbGx5IHRoaXMgbGVuZ3RoIGlzIHVzZWQgdG8g Y29uc3RydWN0IHRoZQorICAgICAgICBTdHJpbmdJbXBsIHdpdGhvdXQgY29tcHV0aW5nIGFnYWlu LgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogVGVz dFdlYktpdEFQSS9UZXN0cy9XVEYvU3RyaW5nSGFzaGVyLmNwcDoKKyAgICAgICAgKFRlc3RXZWJL aXRBUEk6OlRFU1QpOgorCiAyMDE0LTA2LTE2ICBNYXJpbyBTYW5jaGV6IFByYWRhICA8bWFyaW8u cHJhZGFAc2Ftc3VuZy5jb20+CiAKICAgICAgICAgW0FUS10gTWlzc2luZyAnc2VsZWN0aW9uLWNo YW5nZWQnIHNpZ25hbCB3aGVuIG5hdmlnYXRpbmcgYSBjb21ibyBib3ggd2l0aCBrZXlib2FyZApk aWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvU3RyaW5nSGFzaGVyLmNw cCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1N0cmluZ0hhc2hlci5jcHAKaW5kZXgg YTRkMjIzYzk5OGU5YjQ1ZDNkNmJjOTI0YjVhZjJjYTI2ZTFiYTNmMi4uODAzNzk5Y2UyM2NmNWEw OTc3NWQxYzZjOWJiMjlkZTI0ZjEwNmQ2MCAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktpdEFQ SS9UZXN0cy9XVEYvU3RyaW5nSGFzaGVyLmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rl c3RzL1dURi9TdHJpbmdIYXNoZXIuY3BwCkBAIC0xMjEsMTAgKzEyMSw2IEBAIFRFU1QoV1RGLCBT dHJpbmdIYXNoZXJfYWRkQ2hhcmFjdGVycykKICAgICBBU1NFUlRfRVEoZW1wdHlTdHJpbmdIYXNo LCBoYXNoZXIuaGFzaCgpKTsKICAgICBBU1NFUlRfRVEoZW1wdHlTdHJpbmdIYXNoICYgMHhGRkZG RkYsIGhhc2hlci5oYXNoV2l0aFRvcDhCaXRzTWFza2VkKCkpOwogICAgIGhhc2hlciA9IFN0cmlu Z0hhc2hlcigpOwotICAgIGhhc2hlci5hZGRDaGFyYWN0ZXJzKG51bGxMQ2hhcnMpOwotICAgIEFT U0VSVF9FUShlbXB0eVN0cmluZ0hhc2gsIGhhc2hlci5oYXNoKCkpOwotICAgIEFTU0VSVF9FUShl bXB0eVN0cmluZ0hhc2ggJiAweEZGRkZGRiwgaGFzaGVyLmhhc2hXaXRoVG9wOEJpdHNNYXNrZWQo KSk7Ci0gICAgaGFzaGVyID0gU3RyaW5nSGFzaGVyKCk7CiAgICAgaGFzaGVyLmFkZENoYXJhY3Rl cnMoc3RhdGljX2Nhc3Q8VUNoYXIqPigwKSwgMCk7CiAgICAgQVNTRVJUX0VRKGVtcHR5U3RyaW5n SGFzaCwgaGFzaGVyLmhhc2goKSk7CiAgICAgQVNTRVJUX0VRKGVtcHR5U3RyaW5nSGFzaCAmIDB4 RkZGRkZGLCBoYXNoZXIuaGFzaFdpdGhUb3A4Qml0c01hc2tlZCgpKTsKQEAgLTEzMiwxMCArMTI4 LDYgQEAgVEVTVChXVEYsIFN0cmluZ0hhc2hlcl9hZGRDaGFyYWN0ZXJzKQogICAgIGhhc2hlci5h ZGRDaGFyYWN0ZXJzKG51bGxVQ2hhcnMsIDApOwogICAgIEFTU0VSVF9FUShlbXB0eVN0cmluZ0hh c2gsIGhhc2hlci5oYXNoKCkpOwogICAgIEFTU0VSVF9FUShlbXB0eVN0cmluZ0hhc2ggJiAweEZG RkZGRiwgaGFzaGVyLmhhc2hXaXRoVG9wOEJpdHNNYXNrZWQoKSk7Ci0gICAgaGFzaGVyID0gU3Ry aW5nSGFzaGVyKCk7Ci0gICAgaGFzaGVyLmFkZENoYXJhY3RlcnMobnVsbFVDaGFycyk7Ci0gICAg QVNTRVJUX0VRKGVtcHR5U3RyaW5nSGFzaCwgaGFzaGVyLmhhc2goKSk7Ci0gICAgQVNTRVJUX0VR KGVtcHR5U3RyaW5nSGFzaCAmIDB4RkZGRkZGLCBoYXNoZXIuaGFzaFdpdGhUb3A4Qml0c01hc2tl ZCgpKTsKIAogICAgIC8vIEhhc2hpbmcgb25lIGNoYXJhY3Rlci4KICAgICBoYXNoZXIgPSBTdHJp bmdIYXNoZXIoKTsKQEAgLTE1MywyNSArMTQ1LDEzIEBAIFRFU1QoV1RGLCBTdHJpbmdIYXNoZXJf YWRkQ2hhcmFjdGVycykKICAgICBBU1NFUlRfRVEodGVzdEFIYXNoNSwgaGFzaGVyLmhhc2goKSk7 CiAgICAgQVNTRVJUX0VRKHRlc3RBSGFzaDUgJiAweEZGRkZGRiwgaGFzaGVyLmhhc2hXaXRoVG9w OEJpdHNNYXNrZWQoKSk7CiAgICAgaGFzaGVyID0gU3RyaW5nSGFzaGVyKCk7Ci0gICAgaGFzaGVy LmFkZENoYXJhY3RlcnModGVzdEFMQ2hhcnMpOwotICAgIEFTU0VSVF9FUSh0ZXN0QUhhc2g1LCBo YXNoZXIuaGFzaCgpKTsKLSAgICBBU1NFUlRfRVEodGVzdEFIYXNoNSAmIDB4RkZGRkZGLCBoYXNo ZXIuaGFzaFdpdGhUb3A4Qml0c01hc2tlZCgpKTsKLSAgICBoYXNoZXIgPSBTdHJpbmdIYXNoZXIo KTsKICAgICBoYXNoZXIuYWRkQ2hhcmFjdGVycyh0ZXN0QVVDaGFycywgNSk7CiAgICAgQVNTRVJU X0VRKHRlc3RBSGFzaDUsIGhhc2hlci5oYXNoKCkpOwogICAgIEFTU0VSVF9FUSh0ZXN0QUhhc2g1 ICYgMHhGRkZGRkYsIGhhc2hlci5oYXNoV2l0aFRvcDhCaXRzTWFza2VkKCkpOwogICAgIGhhc2hl ciA9IFN0cmluZ0hhc2hlcigpOwotICAgIGhhc2hlci5hZGRDaGFyYWN0ZXJzKHRlc3RBVUNoYXJz KTsKLSAgICBBU1NFUlRfRVEodGVzdEFIYXNoNSwgaGFzaGVyLmhhc2goKSk7Ci0gICAgQVNTRVJU X0VRKHRlc3RBSGFzaDUgJiAweEZGRkZGRiwgaGFzaGVyLmhhc2hXaXRoVG9wOEJpdHNNYXNrZWQo KSk7Ci0gICAgaGFzaGVyID0gU3RyaW5nSGFzaGVyKCk7CiAgICAgaGFzaGVyLmFkZENoYXJhY3Rl cnModGVzdEJVQ2hhcnMsIDUpOwogICAgIEFTU0VSVF9FUSh0ZXN0Qkhhc2g1LCBoYXNoZXIuaGFz aCgpKTsKICAgICBBU1NFUlRfRVEodGVzdEJIYXNoNSAmIDB4RkZGRkZGLCBoYXNoZXIuaGFzaFdp dGhUb3A4Qml0c01hc2tlZCgpKTsKLSAgICBoYXNoZXIgPSBTdHJpbmdIYXNoZXIoKTsKLSAgICBo YXNoZXIuYWRkQ2hhcmFjdGVycyh0ZXN0QlVDaGFycyk7Ci0gICAgQVNTRVJUX0VRKHRlc3RCSGFz aDUsIGhhc2hlci5oYXNoKCkpOwotICAgIEFTU0VSVF9FUSh0ZXN0Qkhhc2g1ICYgMHhGRkZGRkYs IGhhc2hlci5oYXNoV2l0aFRvcDhCaXRzTWFza2VkKCkpOwogCiAgICAgLy8gSGFzaGluZyBmaXZl IGNoYXJhY3RlcnMsIGluIGdyb3VwcyBvZiB0d28sIHRoZW4gdGhlIGxhc3Qgb25lLgogICAgIGhh c2hlciA9IFN0cmluZ0hhc2hlcigpOwpAQCAtMTg3LDcgKzE2Nyw3IEBAIFRFU1QoV1RGLCBTdHJp bmdIYXNoZXJfYWRkQ2hhcmFjdGVycykKICAgICBoYXNoZXIgPSBTdHJpbmdIYXNoZXIoKTsKICAg ICBoYXNoZXIuYWRkQ2hhcmFjdGVycyh0ZXN0QUxDaGFycywgMik7CiAgICAgaGFzaGVyLmFkZENo YXJhY3RlcnModGVzdEFMQ2hhcnMgKyAyLCAyKTsKLSAgICBoYXNoZXIuYWRkQ2hhcmFjdGVycyh0 ZXN0QUxDaGFycyArIDQpOworICAgIGhhc2hlci5hZGRDaGFyYWN0ZXJzKHRlc3RBTENoYXJzICsg NCwgMSk7CiAgICAgQVNTRVJUX0VRKHRlc3RBSGFzaDUsIGhhc2hlci5oYXNoKCkpOwogICAgIEFT U0VSVF9FUSh0ZXN0QUhhc2g1ICYgMHhGRkZGRkYsIGhhc2hlci5oYXNoV2l0aFRvcDhCaXRzTWFz a2VkKCkpOwogICAgIGhhc2hlciA9IFN0cmluZ0hhc2hlcigpOwpAQCAtMjAzLDcgKzE4Myw3IEBA IFRFU1QoV1RGLCBTdHJpbmdIYXNoZXJfYWRkQ2hhcmFjdGVycykKICAgICBoYXNoZXIgPSBTdHJp bmdIYXNoZXIoKTsKICAgICBoYXNoZXIuYWRkQ2hhcmFjdGVycyh0ZXN0QVVDaGFycywgMik7CiAg ICAgaGFzaGVyLmFkZENoYXJhY3RlcnModGVzdEFVQ2hhcnMgKyAyLCAyKTsKLSAgICBoYXNoZXIu YWRkQ2hhcmFjdGVycyh0ZXN0QVVDaGFycyArIDQpOworICAgIGhhc2hlci5hZGRDaGFyYWN0ZXJz KHRlc3RBVUNoYXJzICsgNCwgMSk7CiAgICAgQVNTRVJUX0VRKHRlc3RBSGFzaDUsIGhhc2hlci5o YXNoKCkpOwogICAgIEFTU0VSVF9FUSh0ZXN0QUhhc2g1ICYgMHhGRkZGRkYsIGhhc2hlci5oYXNo V2l0aFRvcDhCaXRzTWFza2VkKCkpOwogICAgIGhhc2hlciA9IFN0cmluZ0hhc2hlcigpOwpAQCAt MjE5LDcgKzE5OSw3IEBAIFRFU1QoV1RGLCBTdHJpbmdIYXNoZXJfYWRkQ2hhcmFjdGVycykKICAg ICBoYXNoZXIgPSBTdHJpbmdIYXNoZXIoKTsKICAgICBoYXNoZXIuYWRkQ2hhcmFjdGVycyh0ZXN0 QlVDaGFycywgMik7CiAgICAgaGFzaGVyLmFkZENoYXJhY3RlcnModGVzdEJVQ2hhcnMgKyAyLCAy KTsKLSAgICBoYXNoZXIuYWRkQ2hhcmFjdGVycyh0ZXN0QlVDaGFycyArIDQpOworICAgIGhhc2hl ci5hZGRDaGFyYWN0ZXJzKHRlc3RCVUNoYXJzICsgNCwgMSk7CiAgICAgQVNTRVJUX0VRKHRlc3RC SGFzaDUsIGhhc2hlci5oYXNoKCkpOwogICAgIEFTU0VSVF9FUSh0ZXN0Qkhhc2g1ICYgMHhGRkZG RkYsIGhhc2hlci5oYXNoV2l0aFRvcDhCaXRzTWFza2VkKCkpOwogCkBAIC0yMzUsNyArMjE1LDcg QEAgVEVTVChXVEYsIFN0cmluZ0hhc2hlcl9hZGRDaGFyYWN0ZXJzKQogICAgIGhhc2hlci5hZGRD aGFyYWN0ZXJzKHRlc3RBTENoYXJzLCAzKTsKICAgICBBU1NFUlRfRVEodGVzdEFIYXNoMywgaGFz aGVyLmhhc2goKSk7CiAgICAgQVNTRVJUX0VRKHRlc3RBSGFzaDMgJiAweEZGRkZGRiwgaGFzaGVy Lmhhc2hXaXRoVG9wOEJpdHNNYXNrZWQoKSk7Ci0gICAgaGFzaGVyLmFkZENoYXJhY3RlcnModGVz dEFMQ2hhcnMgKyAzKTsKKyAgICBoYXNoZXIuYWRkQ2hhcmFjdGVycyh0ZXN0QUxDaGFycyArIDMs IDIpOwogICAgIEFTU0VSVF9FUSh0ZXN0QUhhc2g1LCBoYXNoZXIuaGFzaCgpKTsKICAgICBBU1NF UlRfRVEodGVzdEFIYXNoNSAmIDB4RkZGRkZGLCBoYXNoZXIuaGFzaFdpdGhUb3A4Qml0c01hc2tl ZCgpKTsKICAgICBoYXNoZXIgPSBTdHJpbmdIYXNoZXIoKTsKQEAgLTI2MSw3ICsyNDEsNyBAQCBU RVNUKFdURiwgU3RyaW5nSGFzaGVyX2FkZENoYXJhY3RlcnMpCiAgICAgQVNTRVJUX0VRKHRlc3RC SGFzaDUgJiAweEZGRkZGRiwgaGFzaGVyLmhhc2hXaXRoVG9wOEJpdHNNYXNrZWQoKSk7CiAgICAg aGFzaGVyID0gU3RyaW5nSGFzaGVyKCk7CiAgICAgaGFzaGVyLmFkZENoYXJhY3RlcnModGVzdEJV Q2hhcnMsIDMpOwotICAgIGhhc2hlci5hZGRDaGFyYWN0ZXJzKHRlc3RCVUNoYXJzICsgMyk7Cisg ICAgaGFzaGVyLmFkZENoYXJhY3RlcnModGVzdEJVQ2hhcnMgKyAzLCAyKTsKICAgICBBU1NFUlRf RVEodGVzdEJIYXNoNSwgaGFzaGVyLmhhc2goKSk7CiAgICAgQVNTRVJUX0VRKHRlc3RCSGFzaDUg JiAweEZGRkZGRiwgaGFzaGVyLmhhc2hXaXRoVG9wOEJpdHNNYXNrZWQoKSk7CiB9CkBAIC0yODcs MTAgKzI2Nyw2IEBAIFRFU1QoV1RGLCBTdHJpbmdIYXNoZXJfYWRkQ2hhcmFjdGVyc0Fzc3VtaW5n QWxpZ25lZCkKICAgICBoYXNoZXIuYWRkQ2hhcmFjdGVyc0Fzc3VtaW5nQWxpZ25lZChudWxsVUNo YXJzLCAwKTsKICAgICBBU1NFUlRfRVEoZW1wdHlTdHJpbmdIYXNoLCBoYXNoZXIuaGFzaCgpKTsK ICAgICBBU1NFUlRfRVEoZW1wdHlTdHJpbmdIYXNoICYgMHhGRkZGRkYsIGhhc2hlci5oYXNoV2l0 aFRvcDhCaXRzTWFza2VkKCkpOwotICAgIGhhc2hlciA9IFN0cmluZ0hhc2hlcigpOwotICAgIGhh c2hlci5hZGRDaGFyYWN0ZXJzQXNzdW1pbmdBbGlnbmVkKG51bGxVQ2hhcnMpOwotICAgIEFTU0VS VF9FUShlbXB0eVN0cmluZ0hhc2gsIGhhc2hlci5oYXNoKCkpOwotICAgIEFTU0VSVF9FUShlbXB0 eVN0cmluZ0hhc2ggJiAweEZGRkZGRiwgaGFzaGVyLmhhc2hXaXRoVG9wOEJpdHNNYXNrZWQoKSk7 CiAKICAgICAvLyBIYXNoaW5nIG9uZSBjaGFyYWN0ZXIuCiAgICAgaGFzaGVyID0gU3RyaW5nSGFz aGVyKCk7CkBAIC0zMDgsMjUgKzI4NCwxMyBAQCBURVNUKFdURiwgU3RyaW5nSGFzaGVyX2FkZENo YXJhY3RlcnNBc3N1bWluZ0FsaWduZWQpCiAgICAgQVNTRVJUX0VRKHRlc3RBSGFzaDUsIGhhc2hl ci5oYXNoKCkpOwogICAgIEFTU0VSVF9FUSh0ZXN0QUhhc2g1ICYgMHhGRkZGRkYsIGhhc2hlci5o YXNoV2l0aFRvcDhCaXRzTWFza2VkKCkpOwogICAgIGhhc2hlciA9IFN0cmluZ0hhc2hlcigpOwot ICAgIGhhc2hlci5hZGRDaGFyYWN0ZXJzQXNzdW1pbmdBbGlnbmVkKHRlc3RBTENoYXJzKTsKLSAg ICBBU1NFUlRfRVEodGVzdEFIYXNoNSwgaGFzaGVyLmhhc2goKSk7Ci0gICAgQVNTRVJUX0VRKHRl c3RBSGFzaDUgJiAweEZGRkZGRiwgaGFzaGVyLmhhc2hXaXRoVG9wOEJpdHNNYXNrZWQoKSk7Ci0g ICAgaGFzaGVyID0gU3RyaW5nSGFzaGVyKCk7CiAgICAgaGFzaGVyLmFkZENoYXJhY3RlcnNBc3N1 bWluZ0FsaWduZWQodGVzdEFVQ2hhcnMsIDUpOwogICAgIEFTU0VSVF9FUSh0ZXN0QUhhc2g1LCBo YXNoZXIuaGFzaCgpKTsKICAgICBBU1NFUlRfRVEodGVzdEFIYXNoNSAmIDB4RkZGRkZGLCBoYXNo ZXIuaGFzaFdpdGhUb3A4Qml0c01hc2tlZCgpKTsKICAgICBoYXNoZXIgPSBTdHJpbmdIYXNoZXIo KTsKLSAgICBoYXNoZXIuYWRkQ2hhcmFjdGVyc0Fzc3VtaW5nQWxpZ25lZCh0ZXN0QVVDaGFycyk7 Ci0gICAgQVNTRVJUX0VRKHRlc3RBSGFzaDUsIGhhc2hlci5oYXNoKCkpOwotICAgIEFTU0VSVF9F USh0ZXN0QUhhc2g1ICYgMHhGRkZGRkYsIGhhc2hlci5oYXNoV2l0aFRvcDhCaXRzTWFza2VkKCkp OwotICAgIGhhc2hlciA9IFN0cmluZ0hhc2hlcigpOwogICAgIGhhc2hlci5hZGRDaGFyYWN0ZXJz QXNzdW1pbmdBbGlnbmVkKHRlc3RCVUNoYXJzLCA1KTsKICAgICBBU1NFUlRfRVEodGVzdEJIYXNo NSwgaGFzaGVyLmhhc2goKSk7CiAgICAgQVNTRVJUX0VRKHRlc3RCSGFzaDUgJiAweEZGRkZGRiwg aGFzaGVyLmhhc2hXaXRoVG9wOEJpdHNNYXNrZWQoKSk7Ci0gICAgaGFzaGVyID0gU3RyaW5nSGFz aGVyKCk7Ci0gICAgaGFzaGVyLmFkZENoYXJhY3RlcnNBc3N1bWluZ0FsaWduZWQodGVzdEJVQ2hh cnMpOwotICAgIEFTU0VSVF9FUSh0ZXN0Qkhhc2g1LCBoYXNoZXIuaGFzaCgpKTsKLSAgICBBU1NF UlRfRVEodGVzdEJIYXNoNSAmIDB4RkZGRkZGLCBoYXNoZXIuaGFzaFdpdGhUb3A4Qml0c01hc2tl ZCgpKTsKIAogICAgIC8vIEhhc2hpbmcgZml2ZSBjaGFyYWN0ZXJzLCBpbiBncm91cHMgb2YgdHdv LCB0aGVuIHRoZSBsYXN0IG9uZS4KICAgICBoYXNoZXIgPSBTdHJpbmdIYXNoZXIoKTsKQEAgLTM0 Miw3ICszMDYsNyBAQCBURVNUKFdURiwgU3RyaW5nSGFzaGVyX2FkZENoYXJhY3RlcnNBc3N1bWlu Z0FsaWduZWQpCiAgICAgaGFzaGVyID0gU3RyaW5nSGFzaGVyKCk7CiAgICAgaGFzaGVyLmFkZENo YXJhY3RlcnNBc3N1bWluZ0FsaWduZWQodGVzdEFMQ2hhcnMsIDIpOwogICAgIGhhc2hlci5hZGRD aGFyYWN0ZXJzQXNzdW1pbmdBbGlnbmVkKHRlc3RBTENoYXJzICsgMiwgMik7Ci0gICAgaGFzaGVy LmFkZENoYXJhY3RlcnNBc3N1bWluZ0FsaWduZWQodGVzdEFMQ2hhcnMgKyA0KTsKKyAgICBoYXNo ZXIuYWRkQ2hhcmFjdGVyc0Fzc3VtaW5nQWxpZ25lZCh0ZXN0QUxDaGFycyArIDQsIDEpOwogICAg IEFTU0VSVF9FUSh0ZXN0QUhhc2g1LCBoYXNoZXIuaGFzaCgpKTsKICAgICBBU1NFUlRfRVEodGVz dEFIYXNoNSAmIDB4RkZGRkZGLCBoYXNoZXIuaGFzaFdpdGhUb3A4Qml0c01hc2tlZCgpKTsKICAg ICBoYXNoZXIgPSBTdHJpbmdIYXNoZXIoKTsKQEAgLTM1OCw3ICszMjIsNyBAQCBURVNUKFdURiwg U3RyaW5nSGFzaGVyX2FkZENoYXJhY3RlcnNBc3N1bWluZ0FsaWduZWQpCiAgICAgaGFzaGVyID0g U3RyaW5nSGFzaGVyKCk7CiAgICAgaGFzaGVyLmFkZENoYXJhY3RlcnNBc3N1bWluZ0FsaWduZWQo dGVzdEFVQ2hhcnMsIDIpOwogICAgIGhhc2hlci5hZGRDaGFyYWN0ZXJzQXNzdW1pbmdBbGlnbmVk KHRlc3RBVUNoYXJzICsgMiwgMik7Ci0gICAgaGFzaGVyLmFkZENoYXJhY3RlcnNBc3N1bWluZ0Fs aWduZWQodGVzdEFVQ2hhcnMgKyA0KTsKKyAgICBoYXNoZXIuYWRkQ2hhcmFjdGVyc0Fzc3VtaW5n QWxpZ25lZCh0ZXN0QVVDaGFycyArIDQsIDEpOwogICAgIEFTU0VSVF9FUSh0ZXN0QUhhc2g1LCBo YXNoZXIuaGFzaCgpKTsKICAgICBBU1NFUlRfRVEodGVzdEFIYXNoNSAmIDB4RkZGRkZGLCBoYXNo ZXIuaGFzaFdpdGhUb3A4Qml0c01hc2tlZCgpKTsKICAgICBoYXNoZXIgPSBTdHJpbmdIYXNoZXIo KTsKQEAgLTM3NCw3ICszMzgsNyBAQCBURVNUKFdURiwgU3RyaW5nSGFzaGVyX2FkZENoYXJhY3Rl cnNBc3N1bWluZ0FsaWduZWQpCiAgICAgaGFzaGVyID0gU3RyaW5nSGFzaGVyKCk7CiAgICAgaGFz aGVyLmFkZENoYXJhY3RlcnNBc3N1bWluZ0FsaWduZWQodGVzdEJVQ2hhcnMsIDIpOwogICAgIGhh c2hlci5hZGRDaGFyYWN0ZXJzQXNzdW1pbmdBbGlnbmVkKHRlc3RCVUNoYXJzICsgMiwgMik7Ci0g ICAgaGFzaGVyLmFkZENoYXJhY3RlcnNBc3N1bWluZ0FsaWduZWQodGVzdEJVQ2hhcnMgKyA0KTsK KyAgICBoYXNoZXIuYWRkQ2hhcmFjdGVyc0Fzc3VtaW5nQWxpZ25lZCh0ZXN0QlVDaGFycyArIDQs IDEpOwogICAgIEFTU0VSVF9FUSh0ZXN0Qkhhc2g1LCBoYXNoZXIuaGFzaCgpKTsKICAgICBBU1NF UlRfRVEodGVzdEJIYXNoNSAmIDB4RkZGRkZGLCBoYXNoZXIuaGFzaFdpdGhUb3A4Qml0c01hc2tl ZCgpKTsKIApAQCAtMzkwLDcgKzM1NCw3IEBAIFRFU1QoV1RGLCBTdHJpbmdIYXNoZXJfYWRkQ2hh cmFjdGVyc0Fzc3VtaW5nQWxpZ25lZCkKICAgICBoYXNoZXIuYWRkQ2hhcmFjdGVyc0Fzc3VtaW5n QWxpZ25lZCh0ZXN0QlVDaGFyc1syXSwgdGVzdEJVQ2hhcnNbM10pOwogICAgIEFTU0VSVF9FUSh0 ZXN0Qkhhc2g0LCBoYXNoZXIuaGFzaCgpKTsKICAgICBBU1NFUlRfRVEodGVzdEJIYXNoNCAmIDB4 RkZGRkZGLCBoYXNoZXIuaGFzaFdpdGhUb3A4Qml0c01hc2tlZCgpKTsKLSAgICBoYXNoZXIuYWRk Q2hhcmFjdGVyc0Fzc3VtaW5nQWxpZ25lZCh0ZXN0QlVDaGFycyArIDQpOworICAgIGhhc2hlci5h ZGRDaGFyYWN0ZXJzQXNzdW1pbmdBbGlnbmVkKHRlc3RCVUNoYXJzICsgNCwgMSk7CiAgICAgQVNT RVJUX0VRKHRlc3RCSGFzaDUsIGhhc2hlci5oYXNoKCkpOwogICAgIEFTU0VSVF9FUSh0ZXN0Qkhh c2g1ICYgMHhGRkZGRkYsIGhhc2hlci5oYXNoV2l0aFRvcDhCaXRzTWFza2VkKCkpOwogfQo=