145370 2015-05-25 10:35:30 -0700 Vector's move assignment operator should move the passed-in vector into a temporary object 2016-09-09 07:26:31 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified NEW P2 Normal --- 1 zan zan andersca ap benjamin cdumez cmarcelo commit-queue darin dbates mcatanzaro svillar oldest_to_newest 1097249 0 zan 2015-05-25 10:35:30 -0700 Vector's move assignment operator should move the passed-in vector into a temporary object 1097253 1 253688 zan 2015-05-25 11:07:57 -0700 Created attachment 253688 Patch 1097322 2 253688 darin 2015-05-26 09:34:18 -0700 Comment on attachment 253688 Patch Anders should review this. 1097324 3 253688 andersca 2015-05-26 09:46:52 -0700 Comment on attachment 253688 Patch Patch looks good but need tests. 1097592 4 253688 ap 2015-05-26 22:25:34 -0700 Comment on attachment 253688 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=253688&action=review > Source/WTF/ChangeLog:11 > + into a temporary object. This ensures that the passed-in Vector is returned into > + the initial state (as if that object was default-constructed) by swapping its data > + with the data of the temporary object. Which part of this doesn't happen without this patch? 1097638 5 253688 darin 2015-05-27 09:12:09 -0700 Comment on attachment 253688 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=253688&action=review >> Source/WTF/ChangeLog:11 >> + with the data of the temporary object. > > Which part of this doesn't happen without this patch? Without the patch, if a and b are vectors, then this: a = WTF::move(b); Swaps a and b, and after the swap b will have whatever happened to be in a, not necessarily an empty vector. Anders explained to me that this is OK from a C++ perspective because move just has to leave the “moved from” object in some state that is safe to destroy, not any particular state. With the patch, b is guaranteed to be an empty vector. This can be more pleasant to program with in many cases and I generally prefer it for our WebKit classes. 1097645 6 ap 2015-05-27 09:53:06 -0700 Makes sense. Sorry, I misread the patch. That said, it's not clear to me whether moving is good for performance when made safe like this. We are adding a lot of default Vector constructors everywhere. 1097661 7 darin 2015-05-27 10:47:25 -0700 (In reply to comment #6) > That said, it's not clear to me whether moving is good for performance when > made safe like this. We are adding a lot of default Vector constructors > everywhere. I think that’s likely a misunderstanding. The constructor zeros out a pointer and two 32-bit integers and is quite low cost with no branches. The cost worry might actually be the Vector destructor. One downside of this implementation is that we end up compiling in one additional call to the destructor in the common case, and I supposed there is some risk that it won’t all be optimized away even though the compiler can easily prove the pointer is null. 1098677 8 mcatanzaro 2015-06-01 18:08:30 -0700 (In reply to comment #5) > With the patch, b is guaranteed to be an empty vector. This can be more > pleasant to program with in many cases and I generally prefer it for our > WebKit classes. If a programmer were to use the vector b after calling WTF::move(b), e.g. to test whether b is empty, I would assume it to be a bug. I don't think any of our code should rely on that behavior, and I'm unsure why Zan wants to introduce it. (Zan is usually right though; let's see what he has to say.) 1098678 9 darin 2015-06-01 18:17:52 -0700 (In reply to comment #8) > If a programmer were to use the vector b after calling WTF::move(b), e.g. to > test whether b is empty, I would assume it to be a bug. I have often written code where I have a collection in a data member, and I want to move it into a local variable for processing and leave an empty collection in its place, to “consume” and process the collection. In that case I like that the data members is empty after moving out of it. However, in such cases, I am always moving into a newly created object anyway, so it is typically the constructor rather than operator= that is involved. 1098766 10 svillar 2015-06-02 04:09:30 -0700 (In reply to comment #5) > Comment on attachment 253688 [details] > Without the patch, if a and b are vectors, then this: > > a = WTF::move(b); > > Swaps a and b, and after the swap b will have whatever happened to be in a, > not necessarily an empty vector. Anders explained to me that this is OK from > a C++ perspective because move just has to leave the “moved from” object in > some state that is safe to destroy, not any particular state. Indeed. Also using b after a move is "undefined behavior" according to the spec if I am not wrong, so I guess that the actual implementation should focus on the performance of the move operation instead of caring about the actual contents of the "moved from" object after it. 1098770 11 zan 2015-06-02 05:38:04 -0700 (In reply to comment #10) > (In reply to comment #5) > > Comment on attachment 253688 [details] > > Without the patch, if a and b are vectors, then this: > > > > a = WTF::move(b); > > > > Swaps a and b, and after the swap b will have whatever happened to be in a, > > not necessarily an empty vector. Anders explained to me that this is OK from > > a C++ perspective because move just has to leave the “moved from” object in > > some state that is safe to destroy, not any particular state. > > Indeed. Also using b after a move is "undefined behavior" according to the > spec if I am not wrong, so I guess that the actual implementation should > focus on the performance of the move operation instead of caring about the > actual contents of the "moved from" object after it. Per specification, in most cases in the standard library, the moved-from object is in a valid but unspecified state, meaning that the moved-from object is still usable but is 'empty' directly after the move -- containers have no elements but can be queried for size and have new elements added, and std::unique_ptr<> has its pointer nulled out but can be reset with a pointer to a different object. Accessing some specific element of an empty container or dereferencing a null std::unique_ptr<> would lead to undefined behavior. A case in point is a generic std::swap() implementation: template<typename T> void swap(T& a, T& b) { T temp = std::move(a); a = std::move(b); b = std::move(temp); } Here both objects are reused after they've been moved-from. (This reminded me that we could specialize std::swap() for WebKit containers to call T::swap() directly instead of moving objects around.) 1098777 12 zan 2015-06-02 07:08:11 -0700 Inspecting the generated code on x86_64, produced with Clang 3.6 and -O2, the compiler does a formidable optimizing job. This is the code that's current generated for operator=(Vector&&) for a Vector with no internal capacity, just swapping the resources of the two objects: 00000000002b42a0 <WTF::Vector<JSC::DFG::Node*, 0ul, WTF::CrashOnOverflow, 16ul>::operator=(WTF::Vector<JSC::DFG::Node*, 0ul, WTF::CrashOnOverflow, 16ul>&&)>: 2b42a0: 48 8b 07 mov (%rdi),%rax 2b42a3: 48 8b 0e mov (%rsi),%rcx 2b42a6: 48 89 0f mov %rcx,(%rdi) 2b42a9: 48 89 06 mov %rax,(%rsi) 2b42ac: 8b 47 08 mov 0x8(%rdi),%eax 2b42af: 8b 4e 08 mov 0x8(%rsi),%ecx 2b42b2: 89 4f 08 mov %ecx,0x8(%rdi) 2b42b5: 89 46 08 mov %eax,0x8(%rsi) 2b42b8: 8b 47 0c mov 0xc(%rdi),%eax 2b42bb: 8b 4e 0c mov 0xc(%rsi),%ecx 2b42be: 89 4f 0c mov %ecx,0xc(%rdi) 2b42c1: 89 46 0c mov %eax,0xc(%rsi) 2b42c4: 48 89 f8 mov %rdi,%rax 2b42c7: c3 retq 2b42c8: 0f 1f 84 00 00 00 00 nopl 0x0(%rax,%rax,1) 2b42cf: 00 This is the code generated with the proposed patch, avoiding any temporary object construction, directly nullifying the moved-from object and simply moving the resources into the moved-to object, freeing the previous data: 00000000002bde10 <WTF::Vector<JSC::DFG::Node*, 0ul, WTF::CrashOnOverflow, 16ul>::operator=(WTF::Vector<JSC::DFG::Node*, 0ul, WTF::CrashOnOverflow, 16ul>&&)>: 2bde10: 53 push %rbx 2bde11: 48 89 fb mov %rdi,%rbx 2bde14: 48 8b 06 mov (%rsi),%rax 2bde17: 48 c7 06 00 00 00 00 movq $0x0,(%rsi) 2bde1e: 8b 4e 08 mov 0x8(%rsi),%ecx 2bde21: c7 46 08 00 00 00 00 movl $0x0,0x8(%rsi) 2bde28: 8b 56 0c mov 0xc(%rsi),%edx 2bde2b: c7 46 0c 00 00 00 00 movl $0x0,0xc(%rsi) 2bde32: 48 8b 3b mov (%rbx),%rdi 2bde35: 48 89 03 mov %rax,(%rbx) 2bde38: 89 4b 08 mov %ecx,0x8(%rbx) 2bde3b: 89 53 0c mov %edx,0xc(%rbx) 2bde3e: 48 85 ff test %rdi,%rdi 2bde41: 74 05 je 2bde48 <WTF::Vector<JSC::DFG::Node*, 0ul, WTF::CrashOnOverflow, 16ul>::operator=(WTF::Vector<JSC::DFG::Node*, 0ul, WTF::CrashOnOverflow, 16ul>&&)+0x38> 2bde43: e8 38 43 f1 ff callq 1d2180 <WTF::fastFree(void*)@plt> 2bde48: 48 89 d8 mov %rbx,%rax 2bde4b: 5b pop %rbx 2bde4c: c3 retq 2bde4d: 0f 1f 00 nopl (%rax) 1100196 13 254442 zan 2015-06-07 10:38:55 -0700 Created attachment 254442 Patch Now with a simple test case. 1100268 14 darin 2015-06-07 17:46:42 -0700 (In reply to comment #12) > Inspecting the generated code on x86_64, produced with Clang 3.6 and -O2, > the compiler does a formidable optimizing job. So if the move assignment operator was used alone, this means that the change would make the code bigger. It’s worth investigating further to see that when we include the variable being assigned from going out of scope if the total code size is bigger or not. Maybe not critical before landing this change, but something I am wondering about. 1100273 15 254442 darin 2015-06-07 17:52:04 -0700 Comment on attachment 254442 Patch I like this change, but I think Anders should make the call. Anders, could you review+? 1123914 16 zan 2015-09-05 01:21:58 -0700 (In reply to comment #14) > (In reply to comment #12) > > Inspecting the generated code on x86_64, produced with Clang 3.6 and -O2, > > the compiler does a formidable optimizing job. > > So if the move assignment operator was used alone, this means that the > change would make the code bigger. It’s worth investigating further to see > that when we include the variable being assigned from going out of scope if > the total code size is bigger or not. Maybe not critical before landing this > change, but something I am wondering about. If the Vector that's being assigned from is a temporary local object, then the compiler will likely optimize the move assignment down to just moving the resources of the temporary object into the target object, and destroying the resources previously held by the target object. The process in this case is pretty similar to just swapping the resources between the two objects (which is what the move assignment operator is doing until this patch lands). This is a very simple example that shows a local object being moved into a static object: static Vector<uint8_t*> s_vec; static void vectorTest() { Vector<uint8_t*> vec(4, nullptr); s_vec = WTF::move(vec); } Clang generates this -- the code allocates the necessary memory and moves all the information into the static object, deallocating previous data, if any: 0000000000536c60 <JSC::vectorTest()>: 536c60: 50 push %rax 536c61: bf 20 00 00 00 mov $0x20,%edi 536c66: e8 c5 39 cc ff callq 1fa630 <WTF::fastMalloc(unsigned long)@plt> 536c6b: 48 85 c0 test %rax,%rax 536c6e: 74 0a je 536c7a <JSC::vectorTest()+0x1a> 536c70: 0f 57 c0 xorps %xmm0,%xmm0 536c73: 0f 11 40 10 movups %xmm0,0x10(%rax) 536c77: 0f 11 00 movups %xmm0,(%rax) 536c7a: 48 8b 3d b7 61 38 00 mov 0x3861b7(%rip),%rdi # 8bce38 <JSC::s_vec> 536c81: 48 89 05 b0 61 38 00 mov %rax,0x3861b0(%rip) # 8bce38 <JSC::s_vec> 536c88: c7 05 ae 61 38 00 04 movl $0x4,0x3861ae(%rip) # 8bce40 <JSC::s_vec+0x8> 536c8f: 00 00 00 536c92: c7 05 a8 61 38 00 04 movl $0x4,0x3861a8(%rip) # 8bce44 <JSC::s_vec+0xc> 536c99: 00 00 00 536c9c: 48 85 ff test %rdi,%rdi 536c9f: 74 06 je 536ca7 <JSC::vectorTest()+0x47> 536ca1: 58 pop %rax 536ca2: e9 59 3a cc ff jmpq 1fa700 <WTF::fastFree(void*)@plt> 536ca7: 58 pop %rax 536ca8: c3 retq 536ca9: 0f 1f 80 00 00 00 00 nopl 0x0(%rax) Again, this example is probably not tough to optimize for any compiler, but it shows the behavior we're hoping for in this specific case. Overall the move assignment operators will now generate larger code because of the extra destructor, but that's The Right Thing(TM) to do. 1214454 17 284563 zan 2016-07-25 22:09:20 -0700 Created attachment 284563 WIP patch 1224265 18 287301 zan 2016-08-29 11:57:59 -0700 Created attachment 287301 Patch 1228022 19 287301 mcatanzaro 2016-09-08 20:33:16 -0700 Comment on attachment 287301 Patch (Please give Anders some time to object before landing.) 1228107 20 andersca 2016-09-09 07:26:31 -0700 If this is done on a vector with inline capacity, won't it add an extra copy? 253688 2015-05-25 11:07:57 -0700 2015-06-07 10:38:46 -0700 Patch bug-145370-20150525200746.patch text/plain 2139 zan U3VidmVyc2lvbiBSZXZpc2lvbjogMTg0ODUxCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDA1YWM5MmM3YTEwOGZkNDkzNDFiODcx YTQ2ODY1YWM1OGJjNDJjYzcuLjFkMDcyZTAzNzg5Yzk5MWU4MTVmM2U4NGJmNzQ5ZWFhMjk4M2E0 Y2IgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjYgQEAKKzIwMTUtMDUtMjUgIFphbiBEb2JlcnNlayAgPHpkb2Jl cnNla0BpZ2FsaWEuY29tPgorCisgICAgICAgIFZlY3RvcidzIG1vdmUgYXNzaWdubWVudCBvcGVy YXRvciBzaG91bGQgbW92ZSB0aGUgcGFzc2VkLWluIHZlY3RvciBpbnRvIGEgdGVtcG9yYXJ5IG9i amVjdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ1 MzcwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSGF2 ZSB0aGUgVmVjdG9yJ3MgbW92ZSBhc3NpZ25tZW50IG9wZXJhdG9yIGZpcnN0IG1vdmUgdGhlIHBh c3NlZC1pbiBWZWN0b3Igb2JqZWN0CisgICAgICAgIGludG8gYSB0ZW1wb3Jhcnkgb2JqZWN0LiBU aGlzIGVuc3VyZXMgdGhhdCB0aGUgcGFzc2VkLWluIFZlY3RvciBpcyByZXR1cm5lZCBpbnRvCisg ICAgICAgIHRoZSBpbml0aWFsIHN0YXRlIChhcyBpZiB0aGF0IG9iamVjdCB3YXMgZGVmYXVsdC1j b25zdHJ1Y3RlZCkgYnkgc3dhcHBpbmcgaXRzIGRhdGEKKyAgICAgICAgd2l0aCB0aGUgZGF0YSBv ZiB0aGUgdGVtcG9yYXJ5IG9iamVjdC4KKworICAgICAgICBPbmx5IHRoZW4gaXMgVmVjdG9yOjpz d2FwKCkgY2FsbGVkLCBmaW5hbGx5IHBsYWNpbmcgdGhlIGRhdGEgb2YgdGhlIHBhc3NlZC1pbiBW ZWN0b3IKKyAgICAgICAgaW50byB0aGUgdGFyZ2V0IG9iamVjdCwgYW5kIHBsYWNpbmcgdGhlIGRh dGEgb2YgdGhlIHRhcmdldCBvYmplY3QgaW50byB0aGUgdGVtcG9yYXJ5CisgICAgICAgIG9iamVj dCwgd2hpY2ggaXMgZGVzdHJveWVkIGFmdGVyd2FyZHMuCisKKyAgICAgICAgVGhpcyBmb2xsb3dz IHRoZSBtb3ZlIGFzc2lnbm1lbnQgb3BlcmF0b3IgaW1wbGVtZW50YXRpb24gb2YgSGFzaFRhYmxl IGFuZCBsZWF2ZXMgdGhlCisgICAgICAgIHBhc3NlZC1pbiBWZWN0b3IgaW4gdGhlIGluaXRpYWwg c3RhdGUsIGluc3RlYWQgb2YganVzdCBzd2FwcGluZyB0aGUgZGF0YSB3aXRoIHRoZQorICAgICAg ICB0YXJnZXQgb2JqZWN0LgorCisgICAgICAgICogd3RmL1ZlY3Rvci5oOgorICAgICAgICAoV1RG Ojo9KToKKwogMjAxNS0wNS0yMyAgRGFuIEJlcm5zdGVpbiAgPG1pdHpAYXBwbGUuY29tPgogCiAg ICAgICAgIFJlbW92ZSB1bnVzZWQgZGVmaW5pdGlvbnMgb2YgV0VCS0lUX1ZFUlNJT05fTUlOX1JF UVVJUkVECmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9WZWN0b3IuaCBiL1NvdXJjZS9XVEYv d3RmL1ZlY3Rvci5oCmluZGV4IDQyNTdkOGMyYjBkNzM5ZmQ1Nzk0OGJkN2NiODRiYjIxN2ViODQ0 YjUuLjdmYzZiMmQzZWQ3ZmQyNTY2ZDZmYzQzZjk1NDViNGExY2NhZWNmMTggMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XVEYvd3RmL1ZlY3Rvci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1ZlY3Rvci5oCkBA IC04ODUsNyArODg1LDggQEAgaW5saW5lIFZlY3RvcjxULCBpbmxpbmVDYXBhY2l0eSwgT3ZlcmZs b3dIYW5kbGVyLCBtaW5DYXBhY2l0eT46OlZlY3RvcihWZWN0b3I8VCwKIHRlbXBsYXRlPHR5cGVu YW1lIFQsIHNpemVfdCBpbmxpbmVDYXBhY2l0eSwgdHlwZW5hbWUgT3ZlcmZsb3dIYW5kbGVyLCBz aXplX3QgbWluQ2FwYWNpdHk+CiBpbmxpbmUgVmVjdG9yPFQsIGlubGluZUNhcGFjaXR5LCBPdmVy Zmxvd0hhbmRsZXIsIG1pbkNhcGFjaXR5PiYgVmVjdG9yPFQsIGlubGluZUNhcGFjaXR5LCBPdmVy Zmxvd0hhbmRsZXIsIG1pbkNhcGFjaXR5Pjo6b3BlcmF0b3I9KFZlY3RvcjxULCBpbmxpbmVDYXBh Y2l0eSwgT3ZlcmZsb3dIYW5kbGVyLCBtaW5DYXBhY2l0eT4mJiBvdGhlcikKIHsKLSAgICBzd2Fw KG90aGVyKTsKKyAgICBWZWN0b3IgdGVtcCA9IFdURjo6bW92ZShvdGhlcik7CisgICAgc3dhcCh0 ZW1wKTsKICAgICByZXR1cm4gKnRoaXM7CiB9CiAK 254442 2015-06-07 10:38:55 -0700 2016-07-25 22:09:14 -0700 Patch bug-145370-20150607193829.patch text/plain 3835 zan U3VidmVyc2lvbiBSZXZpc2lvbjogMTg1Mjg4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDQ1Mzg0MzNhNGNkZmFkNjM3NmI5OTc5 NjIzMWQ2ZmYxN2NhNGI3ZTMuLmI2YTZkZGQ5MjgxMzRmZWViYmYwMTU3YTA0NzNkM2RkMTFlYzY4 ODIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjggQEAKKzIwMTUtMDYtMDYgIFphbiBEb2JlcnNlayAgPHpkb2Jl cnNla0BpZ2FsaWEuY29tPgorCisgICAgICAgIFZlY3RvcidzIG1vdmUgYXNzaWdubWVudCBvcGVy YXRvciBzaG91bGQgbW92ZSB0aGUgcGFzc2VkLWluIHZlY3RvciBpbnRvIGEgdGVtcG9yYXJ5IG9i amVjdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ1 MzcwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSGF2 ZSB0aGUgVmVjdG9yJ3MgbW92ZSBhc3NpZ25tZW50IG9wZXJhdG9yIGZpcnN0IG1vdmUgdGhlIHBh c3NlZC1pbiBWZWN0b3Igb2JqZWN0CisgICAgICAgIGludG8gYSB0ZW1wb3Jhcnkgb2JqZWN0LiBU aGlzIGVuc3VyZXMgdGhhdCB0aGUgcGFzc2VkLWluIFZlY3RvciBpcyByZXR1cm5lZCBpbnRvCisg ICAgICAgIGEgdmFsaWQgYnV0IHVuc3BlY2lmaWVkIHN0YXRlIChlc3NlbnRpYWxseSB0aGUgc2Ft ZSBhcyBpZiB0aGF0IG9iamVjdCB3YXMKKyAgICAgICAgZGVmYXVsdC1jb25zdHJ1Y3RlZCkgYnkg c3dhcHBpbmcgaXRzIGRhdGEgd2l0aCB0aGUgZGF0YSBvZiB0aGUgdGVtcG9yYXJ5IG9iamVjdC4K KworICAgICAgICBPbmx5IHRoZW4gaXMgVmVjdG9yPD46OnN3YXAoKSBjYWxsZWQsIGZpbmFsbHkg cGxhY2luZyB0aGUgZGF0YSBvZiB0aGUgcGFzc2VkLWluIFZlY3RvcgorICAgICAgICBpbnRvIHRo ZSB0YXJnZXQgb2JqZWN0LCBhbmQgcGxhY2luZyB0aGUgZGF0YSBvZiB0aGUgdGFyZ2V0IG9iamVj dCBpbnRvIHRoZSB0ZW1wb3JhcnkKKyAgICAgICAgb2JqZWN0LCB3aGljaCBpcyBkZXN0cm95ZWQg YWZ0ZXJ3YXJkcy4KKworICAgICAgICBUaGlzIGZvbGxvd3MgdGhlIG1vdmUgYXNzaWdubWVudCBv cGVyYXRvciBpbXBsZW1lbnRhdGlvbiBvZiBIYXNoVGFibGUgYW5kIGxlYXZlcyB0aGUKKyAgICAg ICAgcGFzc2VkLWluIFZlY3RvciBpbiB0aGUgaW5pdGlhbCBzdGF0ZSwgaW5zdGVhZCBvZiBqdXN0 IHN3YXBwaW5nIHRoZSBkYXRhIHdpdGggdGhlCisgICAgICAgIHRhcmdldCBvYmplY3QuIFRoZSBj b21waWxlciBjYW4gb3B0aW1pemUgdGhpcyB3ZWxsIGVub3VnaCB0byBhdm9pZCBjb25zdHJ1Y3Rp bmcKKyAgICAgICAgdGhlIHRlbXBvcmFyeSBvYmplY3QgZW50aXJlbHksIG1vdmluZyB0aGUgbmV3 IHJlc291cmNlcyBkaXJlY3RseSBpbnRvIHRoZSB0YXJnZXQKKyAgICAgICAgb2JqZWN0IGFuZCBm cmVlaW5nIGFueSBwcmV2aW91cyBkYXRhLgorCisgICAgICAgICogd3RmL1ZlY3Rvci5oOgorICAg ICAgICAoV1RGOjo9KToKKwogMjAxNS0wNi0wNSAgQ2hyaXMgRHVtZXogIDxjZHVtZXpAYXBwbGUu Y29tPgogCiAgICAgICAgIFtXSzJdW2lPU10gTGltaXQgdGhlIG51bWJlciBvZiB2bm9kZXMgdXNl ZCBieSB0aGUgV2ViQ29udGVudCBwcm9jZXNzZXMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3Rm L1ZlY3Rvci5oIGIvU291cmNlL1dURi93dGYvVmVjdG9yLmgKaW5kZXggZDYxYzVmZmMzNmEwY2I4 ZWExZTllN2M0ZmY2NTU5ZTk5ZWE2NmQwNy4uZTgwZTVkZmM0ZWY2YTJlYzRkODcyZTg4YzkxMTUx YTVlNjdmNDRlZiAxMDA2NDQKLS0tIGEvU291cmNlL1dURi93dGYvVmVjdG9yLmgKKysrIGIvU291 cmNlL1dURi93dGYvVmVjdG9yLmgKQEAgLTg4Niw3ICs4ODYsOCBAQCBpbmxpbmUgVmVjdG9yPFQs IGlubGluZUNhcGFjaXR5LCBPdmVyZmxvd0hhbmRsZXIsIG1pbkNhcGFjaXR5Pjo6VmVjdG9yKFZl Y3RvcjxULAogdGVtcGxhdGU8dHlwZW5hbWUgVCwgc2l6ZV90IGlubGluZUNhcGFjaXR5LCB0eXBl bmFtZSBPdmVyZmxvd0hhbmRsZXIsIHNpemVfdCBtaW5DYXBhY2l0eT4KIGlubGluZSBWZWN0b3I8 VCwgaW5saW5lQ2FwYWNpdHksIE92ZXJmbG93SGFuZGxlciwgbWluQ2FwYWNpdHk+JiBWZWN0b3I8 VCwgaW5saW5lQ2FwYWNpdHksIE92ZXJmbG93SGFuZGxlciwgbWluQ2FwYWNpdHk+OjpvcGVyYXRv cj0oVmVjdG9yPFQsIGlubGluZUNhcGFjaXR5LCBPdmVyZmxvd0hhbmRsZXIsIG1pbkNhcGFjaXR5 PiYmIG90aGVyKQogewotICAgIHN3YXAob3RoZXIpOworICAgIFZlY3RvciB0ZW1wID0gV1RGOjpt b3ZlKG90aGVyKTsKKyAgICBzd2FwKHRlbXApOwogICAgIHJldHVybiAqdGhpczsKIH0KIApkaWZm IC0tZ2l0IGEvVG9vbHMvQ2hhbmdlTG9nIGIvVG9vbHMvQ2hhbmdlTG9nCmluZGV4IDZjNjk2ZTFl ZGM2N2YwN2NmMWMzZWU4OTQ2YjhmOWRmNDgzZDhlNmUuLjE1MDJlMzc4ZjdhMDA5YTFkZDFmY2E5 YTc1YmEyNWQ3YWE2ZWU1NWUgMTAwNjQ0Ci0tLSBhL1Rvb2xzL0NoYW5nZUxvZworKysgYi9Ub29s cy9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxNCBAQAorMjAxNS0wNi0wNyAgWmFuIERvYmVyc2VrICA8 emRvYmVyc2VrQGlnYWxpYS5jb20+CisKKyAgICAgICAgVmVjdG9yJ3MgbW92ZSBhc3NpZ25tZW50 IG9wZXJhdG9yIHNob3VsZCBtb3ZlIHRoZSBwYXNzZWQtaW4gdmVjdG9yIGludG8gYSB0ZW1wb3Jh cnkgb2JqZWN0CisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0xNDUzNzAKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5jcHA6CisgICAgICAgIChUZXN0V2Vi S2l0QVBJOjpURVNUKTogQWRkIHRoZSBXVEZfVmVjdG9yLk1vdmVBc3NpZ25tZW50T3BlcmF0b3Ig dGVzdCB0aGF0IGVuc3VyZXMKKyAgICAgICAgdGhlIG1vdmUgYXNzaWdubWVudCBvcGVyYXRvciBm b3IgdGhlIFZlY3RvciBjbGFzcyBiZWhhdmVzIGNvcnJlY3RseS4KKwogMjAxNS0wNi0wNSAgWmFs YW4gQnVqdGFzICA8emFsYW5AYXBwbGUuY29tPgogCiAgICAgICAgIEZyb20gcjE4NTI3MyBvbiBX VEY6OlJlZkNvdW50ZXIgZXhwb3NlcyB0aGUgYWN0dWFsIHJlZmNvdW50IGluc3RlYWQgb2YgYSBi b29sZWFuIHZhbHVlLgpkaWZmIC0tZ2l0IGEvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYv VmVjdG9yLmNwcCBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5jcHAKaW5k ZXggMjYyMmQwOWUyMjViZTJhOTdjZDY0MWZhMjgyODQ0ZTU4ZWIxYmQ0MS4uNTljYjE2YWEwOGIz YjI0ODE3ZGM0NzI0OTdhMzJmMmQxNWFmODdlOCAxMDA2NDQKLS0tIGEvVG9vbHMvVGVzdFdlYktp dEFQSS9UZXN0cy9XVEYvVmVjdG9yLmNwcAorKysgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3Rz L1dURi9WZWN0b3IuY3BwCkBAIC01MTcsNCArNTE3LDE1IEBAIFRFU1QoV1RGX1ZlY3RvciwgUmVt b3ZlQWxsTWF0Y2hpbmcpCiAgICAgRVhQRUNUX1RSVUUodi5pc0VtcHR5KCkpOwogfQogCitURVNU KFdURl9WZWN0b3IsIE1vdmVBc3NpZ25tZW50T3BlcmF0b3IpCit7CisgICAgVmVjdG9yPGludD4g djEgPSB7IDEgfTsKKyAgICBWZWN0b3I8aW50PiB2MiA9IHsgMiwgMyB9OworCisgICAgdjEgPSBX VEY6Om1vdmUodjIpOworCisgICAgRVhQRUNUX1RSVUUodjEgPT0gVmVjdG9yPGludD4oeyAyLCAz IH0pKTsKKyAgICBFWFBFQ1RfVFJVRSh2Mi5pc0VtcHR5KCkpOworfQorCiB9IC8vIG5hbWVzcGFj ZSBUZXN0V2ViS2l0QVBJCg== 284563 2016-07-25 22:09:20 -0700 2016-08-29 11:57:48 -0700 WIP patch bug-145370-20160725220811.patch text/plain 2677 zan U3VidmVyc2lvbiBSZXZpc2lvbjogMjAzNjYwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGQ4MmMzNzUwNjZjYzhmYTg2YmQ3MTAy Njc1ZGIwN2FlMDU4N2Q0NTEuLmE0MjI4OWQ4OWNkNzE2MDVkNTE0MGJmYTVjYjk0YjczMDkwMWZl YWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTYtMDctMjUgIFphbiBEb2JlcnNlayAgPHpkb2Jl cnNla0BpZ2FsaWEuY29tPgorCisgICAgICAgIFZlY3RvcidzIG1vdmUgYXNzaWdubWVudCBvcGVy YXRvciBzaG91bGQgbW92ZSB0aGUgcGFzc2VkLWluIHZlY3RvciBpbnRvIGEgdGVtcG9yYXJ5IG9i amVjdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ1 MzcwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiB3 dGYvVmVjdG9yLmg6CisgICAgICAgIChXVEY6Oj0pOgorCiAyMDE2LTA3LTIxICBNeWxlcyBDLiBN YXhmaWVsZCAgPG1tYXhmaWVsZEBhcHBsZS5jb20+CiAKICAgICAgICAgW21hY09TXSBDYXJldCBw bGFjZW1lbnQgb2NjdXJzIGluIHRoZSBtaWRkbGUgb2YgbmV3IGVtb2ppIGdyb3VwIGNhbmRpZGF0 ZXMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvd3RmL1ZlY3Rvci5oIGIvU291cmNlL1dURi93dGYv VmVjdG9yLmgKaW5kZXggMGVlZTU0MjcwZmJkZGI1MTJlOWM5NjFiYTU5OWFkZTY2ZDk2NjMyNC4u MTc3OWJjNmZjZDE4NDMyYWVhZmE3ZTI5Y2MxYWFlYmJjM2JhZDczMiAxMDA2NDQKLS0tIGEvU291 cmNlL1dURi93dGYvVmVjdG9yLmgKKysrIGIvU291cmNlL1dURi93dGYvVmVjdG9yLmgKQEAgLTg4 Nyw3ICs4ODcsOCBAQCBpbmxpbmUgVmVjdG9yPFQsIGlubGluZUNhcGFjaXR5LCBPdmVyZmxvd0hh bmRsZXIsIG1pbkNhcGFjaXR5Pjo6VmVjdG9yKFZlY3RvcjxULAogdGVtcGxhdGU8dHlwZW5hbWUg VCwgc2l6ZV90IGlubGluZUNhcGFjaXR5LCB0eXBlbmFtZSBPdmVyZmxvd0hhbmRsZXIsIHNpemVf dCBtaW5DYXBhY2l0eT4KIGlubGluZSBWZWN0b3I8VCwgaW5saW5lQ2FwYWNpdHksIE92ZXJmbG93 SGFuZGxlciwgbWluQ2FwYWNpdHk+JiBWZWN0b3I8VCwgaW5saW5lQ2FwYWNpdHksIE92ZXJmbG93 SGFuZGxlciwgbWluQ2FwYWNpdHk+OjpvcGVyYXRvcj0oVmVjdG9yPFQsIGlubGluZUNhcGFjaXR5 LCBPdmVyZmxvd0hhbmRsZXIsIG1pbkNhcGFjaXR5PiYmIG90aGVyKQogewotICAgIHN3YXAob3Ro ZXIpOworICAgIFZlY3RvciB0ZW1wID0gV1RGTW92ZShvdGhlcik7CisgICAgc3dhcCh0ZW1wKTsK ICAgICByZXR1cm4gKnRoaXM7CiB9CiAKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rv b2xzL0NoYW5nZUxvZwppbmRleCBhODhkMGMxOWMzOWI1ZTU3N2Q3NWFlNmZiMTkzZWU3ZjVhNDJi ZDhkLi4zODJjYjc1MDM1ZjFhNWU3NTlmYWY2NTQ2OWQzMTJkYjk5MmEwYmM1IDEwMDY0NAotLS0g YS9Ub29scy9DaGFuZ2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAK KzIwMTYtMDctMjUgIFphbiBEb2JlcnNlayAgPHpkb2JlcnNla0BpZ2FsaWEuY29tPgorCisgICAg ICAgIFZlY3RvcidzIG1vdmUgYXNzaWdubWVudCBvcGVyYXRvciBzaG91bGQgbW92ZSB0aGUgcGFz c2VkLWluIHZlY3RvciBpbnRvIGEgdGVtcG9yYXJ5IG9iamVjdAorICAgICAgICBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ1MzcwCisKKyAgICAgICAgUmV2aWV3ZWQg YnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBUZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9W ZWN0b3IuY3BwOgorICAgICAgICAoVGVzdFdlYktpdEFQSTo6VEVTVCk6CisKIDIwMTYtMDctMjMg IFlvdWVubiBGYWJsZXQgIDx5b3Vlbm5AYXBwbGUuY29tPgogCiAgICAgICAgIFdQVCBzdGFzaCBz ZXJ2ZXIgc2hvdWxkIGJlIGtlcHQgcnVubmluZyB3aGVuIGxhdW5jaGluZyB3cHQgc2VydmVyCmRp ZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9WZWN0b3IuY3BwIGIvVG9v bHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvVmVjdG9yLmNwcAppbmRleCA2NTY3YWM1NTliY2U2 MWE1NzY1NTNjMDIyZTBhOWYzZTQ2YTMzOGU3Li4wZjI3ZWI4NjVjNzgzZDJmOGJlMDZmMmI4NzBj ODNmNjk3ZmQwMzZjIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9W ZWN0b3IuY3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5jcHAK QEAgLTYxNCw0ICs2MTQsMTUgQEAgVEVTVChXVEZfVmVjdG9yLCBSZW1vdmVBbGxNYXRjaGluZykK ICAgICBFWFBFQ1RfVFJVRSh2LmlzRW1wdHkoKSk7CiB9CiAKK1RFU1QoV1RGX1ZlY3RvciwgTW92 ZUFzc2lnbm1lbnRPcGVyYXRvcikKK3sKKyAgICBWZWN0b3I8aW50PiB2MSA9IHsgMSB9OworICAg IFZlY3RvcjxpbnQ+IHYyID0geyAyLCAzIH07CisKKyAgICB2MSA9IFdURk1vdmUodjIpOworCisg ICAgRVhQRUNUX1RSVUUodjEgPT0gVmVjdG9yPGludD4oeyAyLCAzIH0pKTsKKyAgICBFWFBFQ1Rf VFJVRSh2Mi5pc0VtcHR5KCkpOworfQorCiB9IC8vIG5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJCg== 287301 2016-08-29 11:57:59 -0700 2016-09-08 20:33:16 -0700 Patch bug-145370-20160829115549.patch text/plain 3766 zan U3VidmVyc2lvbiBSZXZpc2lvbjogMjA1MTE5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IDA0Nzg2YmU3Njc2OTBjYzg1ODdlZGEw ZDZlYTBiMzUwNTVlYWY5OGMuLjU3NDc3ZGQ1OTk5OTAzMzA1ZDViMzc4NDcyNDQxODNmMjFjMmM1 ZGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMjggQEAKKzIwMTYtMDgtMjkgIFphbiBEb2JlcnNlayAgPHpkb2Jl cnNla0BpZ2FsaWEuY29tPgorCisgICAgICAgIFZlY3RvcidzIG1vdmUgYXNzaWdubWVudCBvcGVy YXRvciBzaG91bGQgbW92ZSB0aGUgcGFzc2VkLWluIHZlY3RvciBpbnRvIGEgdGVtcG9yYXJ5IG9i amVjdAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MTQ1 MzcwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgSGF2 ZSB0aGUgVmVjdG9yJ3MgbW92ZSBhc3NpZ25tZW50IG9wZXJhdG9yIGZpcnN0IG1vdmUgdGhlIHBh c3NlZC1pbiBWZWN0b3Igb2JqZWN0CisgICAgICAgIGludG8gYSB0ZW1wb3Jhcnkgb2JqZWN0LiBU aGlzIGVuc3VyZXMgdGhhdCB0aGUgcGFzc2VkLWluIFZlY3RvciBpcyByZXR1cm5lZCBpbnRvCisg ICAgICAgIGEgdmFsaWQgYnV0IHVuc3BlY2lmaWVkIHN0YXRlIChlc3NlbnRpYWxseSB0aGUgc2Ft ZSBhcyBpZiB0aGF0IG9iamVjdCB3YXMKKyAgICAgICAgZGVmYXVsdC1jb25zdHJ1Y3RlZCkgYnkg c3dhcHBpbmcgaXRzIGRhdGEgd2l0aCB0aGUgZGF0YSBvZiB0aGUgdGVtcG9yYXJ5IG9iamVjdC4K KworICAgICAgICBPbmx5IHRoZW4gaXMgVmVjdG9yPD46OnN3YXAoKSBjYWxsZWQsIGZpbmFsbHkg cGxhY2luZyB0aGUgZGF0YSBvZiB0aGUgcGFzc2VkLWluIFZlY3RvcgorICAgICAgICBpbnRvIHRo ZSB0YXJnZXQgb2JqZWN0LCBhbmQgcGxhY2luZyB0aGUgZGF0YSBvZiB0aGUgdGFyZ2V0IG9iamVj dCBpbnRvIHRoZSB0ZW1wb3JhcnkKKyAgICAgICAgb2JqZWN0LCB3aGljaCBpcyBkZXN0cm95ZWQg YWZ0ZXJ3YXJkcy4KKworICAgICAgICBUaGlzIGZvbGxvd3MgdGhlIHN0YW5kYXJkIG1vdmUgYXNz aWdubWVudCBvcGVyYXRvciBpbXBsZW1lbnRhdGlvbiBhbmQgbGVhdmVzIHRoZQorICAgICAgICBw YXNzZWQtaW4gVmVjdG9yIGluIHRoZSBpbml0aWFsIHN0YXRlLCBpbnN0ZWFkIG9mIGp1c3Qgc3dh cHBpbmcgdGhlIGRhdGEgd2l0aCB0aGUKKyAgICAgICAgdGFyZ2V0IG9iamVjdC4gVGhlIGNvbXBp bGVyIGNhbiBvcHRpbWl6ZSB0aGlzIHdlbGwgZW5vdWdoIHRvIGF2b2lkIGNvbnN0cnVjdGluZwor ICAgICAgICB0aGUgdGVtcG9yYXJ5IG9iamVjdCBlbnRpcmVseSwgbW92aW5nIHRoZSBuZXcgcmVz b3VyY2VzIGRpcmVjdGx5IGludG8gdGhlIHRhcmdldAorICAgICAgICBvYmplY3QgYW5kIGZyZWVp bmcgYW55IHByZXZpb3VzIGRhdGEuCisKKyAgICAgICAgKiB3dGYvVmVjdG9yLmg6CisgICAgICAg IChXVEY6Oj0pOgorCiAyMDE2LTA4LTI3ICBBbGV4IENocmlzdGVuc2VuICA8YWNocmlzdGVuc2Vu QHdlYmtpdC5vcmc+CiAKICAgICAgICAgVVJMUGFyc2VyIHNob3VsZCBwYXJzZSByZWxhdGl2ZSBV UkxzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL3d0Zi9WZWN0b3IuaCBiL1NvdXJjZS9XVEYvd3Rm L1ZlY3Rvci5oCmluZGV4IDBlZWU1NDI3MGZiZGRiNTEyZTljOTYxYmE1OTlhZGU2NmQ5NjYzMjQu LjE3NzliYzZmY2QxODQzMmFlYWZhN2UyOWNjMWFhZWJiYzNiYWQ3MzIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XVEYvd3RmL1ZlY3Rvci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1ZlY3Rvci5oCkBAIC04 ODcsNyArODg3LDggQEAgaW5saW5lIFZlY3RvcjxULCBpbmxpbmVDYXBhY2l0eSwgT3ZlcmZsb3dI YW5kbGVyLCBtaW5DYXBhY2l0eT46OlZlY3RvcihWZWN0b3I8VCwKIHRlbXBsYXRlPHR5cGVuYW1l IFQsIHNpemVfdCBpbmxpbmVDYXBhY2l0eSwgdHlwZW5hbWUgT3ZlcmZsb3dIYW5kbGVyLCBzaXpl X3QgbWluQ2FwYWNpdHk+CiBpbmxpbmUgVmVjdG9yPFQsIGlubGluZUNhcGFjaXR5LCBPdmVyZmxv d0hhbmRsZXIsIG1pbkNhcGFjaXR5PiYgVmVjdG9yPFQsIGlubGluZUNhcGFjaXR5LCBPdmVyZmxv d0hhbmRsZXIsIG1pbkNhcGFjaXR5Pjo6b3BlcmF0b3I9KFZlY3RvcjxULCBpbmxpbmVDYXBhY2l0 eSwgT3ZlcmZsb3dIYW5kbGVyLCBtaW5DYXBhY2l0eT4mJiBvdGhlcikKIHsKLSAgICBzd2FwKG90 aGVyKTsKKyAgICBWZWN0b3IgdGVtcCA9IFdURk1vdmUob3RoZXIpOworICAgIHN3YXAodGVtcCk7 CiAgICAgcmV0dXJuICp0aGlzOwogfQogCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9U b29scy9DaGFuZ2VMb2cKaW5kZXggNDVhMzYyOTRhNzFjZmQ3MDVhYTliNjZhNDIwNTdkNzVlOWUw YjY0Mi4uM2Q5ZjU5NGM4ZGEwMmEyYzNlMzY0NTAxNWQ4MjYxOTA0NWZjZDk3NCAxMDA2NDQKLS0t IGEvVG9vbHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBA CisyMDE2LTA4LTI5ICBaYW4gRG9iZXJzZWsgIDx6ZG9iZXJzZWtAaWdhbGlhLmNvbT4KKworICAg ICAgICBWZWN0b3IncyBtb3ZlIGFzc2lnbm1lbnQgb3BlcmF0b3Igc2hvdWxkIG1vdmUgdGhlIHBh c3NlZC1pbiB2ZWN0b3IgaW50byBhIHRlbXBvcmFyeSBvYmplY3QKKyAgICAgICAgaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE0NTM3MAorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYv VmVjdG9yLmNwcDoKKyAgICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOiBBZGQgdGhlIFdURl9W ZWN0b3IuTW92ZUFzc2lnbm1lbnRPcGVyYXRvciB0ZXN0IHRoYXQgZW5zdXJlcworICAgICAgICB0 aGUgbW92ZSBhc3NpZ25tZW50IG9wZXJhdG9yIGZvciB0aGUgVmVjdG9yIGNsYXNzIGJlaGF2ZXMg Y29ycmVjdGx5LgorCiAyMDE2LTA4LTI5ICBQZXIgQXJuZSBWb2xsYW4gIDxwdm9sbGFuQGFwcGxl LmNvbT4KIAogICAgICAgICBBdHRlbXB0IHRvIGZpeCBXaW5kb3dzIGJ1aWxkIGFmdGVyIHIyMDUw OTAuCmRpZmYgLS1naXQgYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9WZWN0b3IuY3Bw IGIvVG9vbHMvVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvVmVjdG9yLmNwcAppbmRleCA0ODIzNWIx ZmNmMmI1ZGMyZDc5NWU4MGMwOTMzNTQ5YWEwNzVkMzljLi41MmRlZWYxM2UxZWRmZWRhZGYxZGZk MTJkMmZlMTY5MmRkODBhZmYyIDEwMDY0NAotLS0gYS9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3Rz L1dURi9WZWN0b3IuY3BwCisrKyBiL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1ZlY3Rv ci5jcHAKQEAgLTYxNCw0ICs2MTQsMTUgQEAgVEVTVChXVEZfVmVjdG9yLCBSZW1vdmVBbGxNYXRj aGluZykKICAgICBFWFBFQ1RfVFJVRSh2LmlzRW1wdHkoKSk7CiB9CiAKK1RFU1QoV1RGX1ZlY3Rv ciwgTW92ZUFzc2lnbm1lbnRPcGVyYXRvcikKK3sKKyAgICBWZWN0b3I8aW50PiB2MSA9IHsgMSB9 OworICAgIFZlY3RvcjxpbnQ+IHYyID0geyAyLCAzIH07CisKKyAgICB2MSA9IFdURk1vdmUodjIp OworCisgICAgRVhQRUNUX1RSVUUodjEgPT0gVmVjdG9yPGludD4oeyAyLCAzIH0pKTsKKyAgICBF WFBFQ1RfVFJVRSh2Mi5pc0VtcHR5KCkpOworfQorCiB9IC8vIG5hbWVzcGFjZSBUZXN0V2ViS2l0 QVBJCg==