176487 2017-09-06 17:22:52 -0700 Add a lambda-based map for Vectors 2017-09-27 12:37:13 -0700 1 1 1 Unclassified WebKit WebCore Misc. WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 youennf youennf benjamin buildbot cdumez cgarcia cmarcelo commit-queue darin dbates jer.noble kling saam sam webkit-bug-importer oldest_to_newest 1346170 0 youennf 2017-09-06 17:22:52 -0700 Add a lambda-based map for Vectors 1346171 1 320081 youennf 2017-09-06 17:24:27 -0700 Created attachment 320081 Patch 1346388 2 320128 youennf 2017-09-07 10:29:15 -0700 Created attachment 320128 Patch 1346594 3 320128 saam 2017-09-07 15:34:45 -0700 Comment on attachment 320128 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=320128&action=review > Source/WTF/wtf/Vector.h:1595 > +template<typename Transformer, typename VectorType> > +Vector<typename Mapper<Transformer, VectorType>::DestinationItemType> map(VectorType&& source, const Transformer& transformer) > +{ > + return Mapper<Transformer, VectorType>::map(std::forward<VectorType>(source), transformer); > +} I'm slightly hesitant to assume here we're only going to map over Vector types. Can we come up with a way to do this so we can easily map over HashSet, HashMap, etc. If other folks are interested in mapping over HashSet, HashMap, etc, one interesting question is, what's the return type? I'd assume map by default returns its input type, so map over HashSet returns a Vector. But I could sometimes see mapping a HashSet into a Vector. Maybe we can come up with a nice default, with the ability to override via templates? 1346645 4 youennf 2017-09-07 16:55:11 -0700 Discussing with Jer, there is already a Vector::map method taking a lambda. It might be good to move it to a free function like done in this patch and maybe move it to some other place and try making it work for more than Vector. Also, this patch is implementing map for both const Vector& and Vector&&. In the latter case, the items are passed as && to the transformer. Apparently, map is supposed to be const so maybe it is best to split these two patterns, or just not add the Vector&& as a pattern at all. 1346646 5 youennf 2017-09-07 16:55:15 -0700 Discussing with Jer, there is already a Vector::map method taking a lambda. It might be good to move it to a free function like done in this patch and maybe move it to some other place and try making it work for more than Vector. Also, this patch is implementing map for both const Vector& and Vector&&. In the latter case, the items are passed as && to the transformer. Apparently, map is supposed to be const so maybe it is best to split these two patterns, or just not add the Vector&& as a pattern at all. 1347270 6 320128 darin 2017-09-10 13:18:26 -0700 Comment on attachment 320128 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=320128&action=review > Source/WTF/wtf/Vector.h:1571 > + for (const auto& item : source) No need for the "const" here. >> Source/WTF/wtf/Vector.h:1595 >> +} > > I'm slightly hesitant to assume here we're only going to map over Vector types. Can we come up with a way to do this so we can easily map over HashSet, HashMap, etc. > > If other folks are interested in mapping over HashSet, HashMap, etc, one interesting question is, what's the return type? I'd assume map by default returns its input type, so map over HashSet returns a Vector. But I could sometimes see mapping a HashSet into a Vector. Maybe we can come up with a nice default, with the ability to override via templates? I think the first sentence here is attacking a straw man. This code doesn’t mean that we are mapping only over Vector types. In C++ we can use overloading to implement a function for more than one type. But perhaps the question is "how compatible would this be with other overloads". I don’t think we should force Youenn to make a more general purpose map function right now, but if there is some choice he is making here that will make it hard to implement the others in future, that might be nice. My design suggestion would be that the WTF::map function produces the same type it is passed, but then there is map<T> which produces the type T for various cases where that is easy to support and unambiguous. I think we should approve this patch without undue worry about that more general map function for the future; I expect we can implement it later relatively easily or change all callers if we really have to. > Source/WebKit/NetworkProcess/cache/CacheStorageEngineCaches.cpp:243 > + callback(WTF::map(WTFMove(result.value()), [this](String&& name) { I believe our coding style asks to put a space between [this] and (String&& name). > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:656 > + Vector<int> vector { 1, 1, 1}; I’m not sure we tested all the cases we should. We tested how it behaves when we pass a Vector, and when we pass a Vector&&, using WTFMove. But we don’t explicitly test passing a Vector& (which I think should allow the lambda to modify the values during the mapping process, right, including allowing them to be explicitly moved, right, or maybe as a matter of policy we would choose to not allow that?) and passing an actual const Vector&. Some of these could really be relevant to how we implemented Mapper. Also, should probably initialize the vector with different values rather than all with the same value. > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:659 > + auto mapped = WTF::map(vector, [&](const auto& item) { Ditto. > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:679 > + auto mapped = WTF::map(WTFMove(vector), [&](MoveOnly&& item) { Ditto. 1348060 7 youennf 2017-09-12 15:21:04 -0700 Thanks for the review. > > I'm slightly hesitant to assume here we're only going to map over Vector types. Can we come up with a way to do this so we can easily map over HashSet, HashMap, etc. > > > > If other folks are interested in mapping over HashSet, HashMap, etc, one interesting question is, what's the return type? I'd assume map by default returns its input type, so map over HashSet returns a Vector. But I could sometimes see mapping a HashSet into a Vector. Maybe we can come up with a nice default, with the ability to override via templates? > > I think the first sentence here is attacking a straw man. This code doesn’t > mean that we are mapping only over Vector types. In C++ we can use > overloading to implement a function for more than one type. But perhaps the > question is "how compatible would this be with other overloads". I don’t > think we should force Youenn to make a more general purpose map function > right now, but if there is some choice he is making here that will make it > hard to implement the others in future, that might be nice. > > My design suggestion would be that the WTF::map function produces the same > type it is passed, but then there is map<T> which produces the type T for > various cases where that is easy to support and unambiguous. I think we > should approve this patch without undue worry about that more general map > function for the future; I expect we can implement it later relatively > easily or change all callers if we really have to. Going from Map values or Map keys to a vector is a pattern that would be useful. I guess this could be handled with a way to get iterator + size. > > Source/WebKit/NetworkProcess/cache/CacheStorageEngineCaches.cpp:243 > > + callback(WTF::map(WTFMove(result.value()), [this](String&& name) { > > I believe our coding style asks to put a space between [this] and (String&& > name). OK. I am not sure we have consistency in the code base here. > > Tools/TestWebKitAPI/Tests/WTF/Vector.cpp:656 > > + Vector<int> vector { 1, 1, 1}; > > I’m not sure we tested all the cases we should. > > We tested how it behaves when we pass a Vector, and when we pass a Vector&&, > using WTFMove. But we don’t explicitly test passing a Vector& (which I think > should allow the lambda to modify the values during the mapping process, > right, including allowing them to be explicitly moved, right, or maybe as a > matter of policy we would choose to not allow that?) and passing an actual > const Vector&. Some of these could really be relevant to how we implemented > Mapper. The target is to expose mapping for const Vector& and Vector&&. A Vector& should be mapped as a const Vector&. I haven't seen use case yet on wanting to move items from a Vector& inside the lambda and I am not sure this is a very comprehensible pattern. > Also, should probably initialize the vector with different values rather > than all with the same value. OK 1348299 8 320642 youennf 2017-09-13 08:55:24 -0700 Created attachment 320642 Patch for landing 1348358 9 320642 commit-queue 2017-09-13 10:50:51 -0700 Comment on attachment 320642 Patch for landing Clearing flags on attachment: 320642 Committed r221977: <http://trac.webkit.org/changeset/221977> 1348359 10 commit-queue 2017-09-13 10:50:53 -0700 All reviewed patches have been landed. Closing bug. 1353533 11 webkit-bug-importer 2017-09-27 12:37:13 -0700 <rdar://problem/34693618> 320081 2017-09-06 17:24:27 -0700 2017-09-07 10:29:14 -0700 Patch bug-176487-20170906172426.patch text/plain 3990 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMjIxNzA1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGE1M2M0MmJkNWM1NWM2NmVlMTU2ZWI3 MjZiOTkzMmVhZTQ2NWYxNmMuLjgzODVmMzFmNWU5ZWZiM2UzNWFjODAxMWQ5NmE1YWZjMzUxMDQ2 YTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTYgQEAKKzIwMTctMDktMDYgIFlvdWVubiBGYWJsZXQgIDx5b3Vl bm5AYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBhIGxhbWJkYS1iYXNlZCBtYXAgZm9yIFZlY3Rv cnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3NjQ4 NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMg aGVscGVyIHJvdXRpbmUgYWxsb3dzIHJlZmFjdG9yaW5nIHRoZSByZXNlcnZlSW5pdGlhbENhcGFj aXR5L3VuY2hlY2tlZEFwcGVuZCBwYXR0ZXJuLCB0aGUgbWFwcGVyIGJldHdlZW4gc291cmNlIGFu ZCBkZXN0aW5hdGlvbiBpdGVtIGJlaW5nIGEgbGFtYmRhLgorCisgICAgICAgICogd3RmL1ZlY3Rv ci5oOgorICAgICAgICAoV1RGOjpNYXBwZXI6Om1hcCk6CisgICAgICAgIChXVEY6Om1hcCk6CisK IDIwMTctMDktMDYgIFBlciBBcm5lIFZvbGxhbiAgPHB2b2xsYW5AYXBwbGUuY29tPgogCiAgICAg ICAgIFtXaW5dIFdlYkNvcmUgZmFpbGVkIHRvIGJ1aWxkLCBJbmJhbmRUZXh0VHJhY2tQcml2YXRl QVZGOiBiYXNlIGNsYXNzIHVuZGVmaW5lZC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvQ2hh bmdlTG9nIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKaW5kZXggMGFmMTIxNDZiY2VhNWMzMTUz MjQ5MWU1M2VmN2QyOTcxN2JlZTdkZC4uMTUyNGRjYzk0YmRkOGIxOGVhOWE4MjMyODc1NGQ2OGVm OWJkOWMwZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKKysrIGIvU291cmNl L1dlYktpdC9DaGFuZ2VMb2cKQEAgLTEsNSArMSwxNSBAQAogMjAxNy0wOS0wNiAgWW91ZW5uIEZh YmxldCAgPHlvdWVubkBhcHBsZS5jb20+CiAKKyAgICAgICAgQWRkIGEgbGFtYmRhLWJhc2VkIG1h cCBmb3IgVmVjdG9ycworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MTc2NDg3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAg ICAgICAgKiBOZXR3b3JrUHJvY2Vzcy9jYWNoZS9DYWNoZVN0b3JhZ2VFbmdpbmVDYWNoZXMuY3Bw OgorICAgICAgICAoV2ViS2l0OjpDYWNoZVN0b3JhZ2U6OkNhY2hlczo6cmVhZENhY2hlc0Zyb21E aXNrKToKKworMjAxNy0wOS0wNiAgWW91ZW5uIEZhYmxldCAgPHlvdWVubkBhcHBsZS5jb20+CisK ICAgICAgICAgTmV0d29ya1Byb2Nlc3MgQ2FjaGUgYW5kIENhY2hlcyBzaG91bGQgYmUgY2xlYXJl ZCB3aGVuIHRoZSBsYXN0IHJlbGF0ZWQgV2ViUHJvY2VzcyBDYWNoZSBvciBDYWNoZVN0b3JhZ2Ug aXMgZGVzdHJveWVkCiAgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0xNzYyNDkKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYvVmVjdG9yLmggYi9Tb3Vy Y2UvV1RGL3d0Zi9WZWN0b3IuaAppbmRleCBjZjljN2ZiYWY4ODI2NTM3OTM1NmI5ZGU3N2U4N2Q1 Y2Q2ZDU1ODE0Li40ZThhZjhhNTEyNDc0NGQ5NDU4NmIwYzZkYmI4NmU1MDI5N2JhOWY3IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9WZWN0b3IuaAorKysgYi9Tb3VyY2UvV1RGL3d0Zi9WZWN0 b3IuaApAQCAtMTU2MCw2ICsxNTYwLDI1IEBAIHNpemVfdCByZW1vdmVSZXBlYXRlZEVsZW1lbnRz KFZlY3RvcjxULCBpbmxpbmVDYXBhY2l0eSwgT3ZlcmZsb3dIYW5kbGVyLCBtaW5DYXBhCiAgICAg cmV0dXJuIHJlbW92ZVJlcGVhdGVkRWxlbWVudHModmVjdG9yLCBbXSAoVCYgYSwgVCYgYikgeyBy ZXR1cm4gYSA9PSBiOyB9KTsKIH0KIAordGVtcGxhdGU8dHlwZW5hbWUgVHJhbnNmb3JtZXIsIHR5 cGVuYW1lIFNvdXJjZVR5cGU+IHN0cnVjdCBNYXBwZXIgeworICAgIHVzaW5nIERlc3RpbmF0aW9u VHlwZSA9IHR5cGVuYW1lIHN0ZDo6cmVzdWx0X29mPFRyYW5zZm9ybWVyKFNvdXJjZVR5cGUmJik+ Ojp0eXBlOworCisgICAgc3RhdGljIFZlY3RvcjxEZXN0aW5hdGlvblR5cGU+IG1hcChWZWN0b3I8 U291cmNlVHlwZT4mJiBzb3VyY2UsIGNvbnN0IFRyYW5zZm9ybWVyJiB0cmFuc2Zvcm1lcikKKyAg ICB7CisgICAgICAgIFZlY3RvcjxEZXN0aW5hdGlvblR5cGU+IHJlc3VsdDsKKyAgICAgICAgcmVz dWx0LnJlc2VydmVJbml0aWFsQ2FwYWNpdHkoc291cmNlLnNpemUoKSk7CisgICAgICAgIGZvciAo YXV0byYgaXRlbSA6IHNvdXJjZSkKKyAgICAgICAgICAgIHJlc3VsdC51bmNoZWNrZWRBcHBlbmQo dHJhbnNmb3JtZXIoc3RkOjpmb3J3YXJkPFNvdXJjZVR5cGU+KGl0ZW0pKSk7CisgICAgICAgIHJl dHVybiByZXN1bHQ7CisgICAgfQorfTsKKwordGVtcGxhdGU8dHlwZW5hbWUgVHJhbnNmb3JtZXIs IHR5cGVuYW1lIFZlY3RvclR5cGU+CitWZWN0b3I8dHlwZW5hbWUgTWFwcGVyPFRyYW5zZm9ybWVy LCB0eXBlbmFtZSBWZWN0b3JUeXBlOjpWYWx1ZVR5cGU+OjpEZXN0aW5hdGlvblR5cGU+IG1hcChW ZWN0b3JUeXBlJiYgc291cmNlLCBjb25zdCBUcmFuc2Zvcm1lciYgdHJhbnNmb3JtZXIpCit7Cisg ICAgcmV0dXJuIE1hcHBlcjxUcmFuc2Zvcm1lciwgdHlwZW5hbWUgVmVjdG9yVHlwZTo6VmFsdWVU eXBlPjo6bWFwKHN0ZDo6Zm9yd2FyZDxWZWN0b3JUeXBlPihzb3VyY2UpLCB0cmFuc2Zvcm1lcik7 Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdURgogCiB1c2luZyBXVEY6OlZlY3RvcjsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nlc3MvY2FjaGUvQ2FjaGVTdG9yYWdlRW5naW5l Q2FjaGVzLmNwcCBiL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nlc3MvY2FjaGUvQ2FjaGVTdG9y YWdlRW5naW5lQ2FjaGVzLmNwcAppbmRleCAyYzFiZmE1ZTViOWVhODNhMjkxOTkxZDJmNGIyYTg5 MGNiMWM1MTk2Li45ZGMyN2Y0ZDQwMzhmODA0YTYzMjc3YzRiMWQxYTBkMjUwNmRkMGZiIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL2NhY2hlL0NhY2hlU3RvcmFnZUVu Z2luZUNhY2hlcy5jcHAKKysrIGIvU291cmNlL1dlYktpdC9OZXR3b3JrUHJvY2Vzcy9jYWNoZS9D YWNoZVN0b3JhZ2VFbmdpbmVDYWNoZXMuY3BwCkBAIC0yNDAsMTIgKzI0MCw5IEBAIHZvaWQgQ2Fj aGVzOjpyZWFkQ2FjaGVzRnJvbURpc2soV1RGOjpGdW5jdGlvbjx2b2lkKEV4cGVjdGVkPFZlY3Rv cjxDYWNoZT4sIEVycm9yCiAgICAgICAgICAgICBjYWxsYmFjayhtYWtlVW5leHBlY3RlZChyZXN1 bHQuZXJyb3IoKSkpOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9Ci0gICAgICAgIFZl Y3RvcjxDYWNoZT4gY2FjaGVzOwotICAgICAgICBjYWNoZXMucmVzZXJ2ZUluaXRpYWxDYXBhY2l0 eShyZXN1bHQudmFsdWUoKS5zaXplKCkpOwotICAgICAgICBmb3IgKGF1dG8mIG5hbWUgOiByZXN1 bHQudmFsdWUoKSkKLSAgICAgICAgICAgIGNhY2hlcy51bmNoZWNrZWRBcHBlbmQoQ2FjaGUgeyAq dGhpcywgbV9lbmdpbmUtPm5leHRDYWNoZUlkZW50aWZpZXIoKSwgQ2FjaGU6OlN0YXRlOjpVbmlu aXRpYWxpemVkLCBXVEZNb3ZlKG5hbWUpIH0pOwotCi0gICAgICAgIGNhbGxiYWNrKFdURk1vdmUo Y2FjaGVzKSk7CisgICAgICAgIGNhbGxiYWNrKFdURjo6bWFwKFdURk1vdmUocmVzdWx0LnZhbHVl KCkpLCBbdGhpc10oU3RyaW5nJiYgbmFtZSkgeworICAgICAgICAgICAgcmV0dXJuIENhY2hlIHsg KnRoaXMsIG1fZW5naW5lLT5uZXh0Q2FjaGVJZGVudGlmaWVyKCksIENhY2hlOjpTdGF0ZTo6VW5p bml0aWFsaXplZCwgV1RGTW92ZShuYW1lKSB9OworICAgICAgICB9KSk7CiAgICAgfSk7CiB9CiAK 320128 2017-09-07 10:29:15 -0700 2017-09-13 08:55:23 -0700 Patch bug-176487-20170907102914.patch text/plain 6646 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMjIxNzA1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGE1M2M0MmJkNWM1NWM2NmVlMTU2ZWI3 MjZiOTkzMmVhZTQ2NWYxNmMuLjFjMmRkZWY0YmRjM2ZlN2RmZDBmODEyMjM3ZTc3NDhjMTRjZjQ3 NzcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTctMDktMDYgIFlvdWVubiBGYWJsZXQgIDx5b3Vl bm5AYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBhIGxhbWJkYS1iYXNlZCBtYXAgZm9yIFZlY3Rv cnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3NjQ4 NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMg aGVscGVyIHJvdXRpbmUgYWxsb3dzIHJlZmFjdG9yaW5nIHRoZSByZXNlcnZlSW5pdGlhbENhcGFj aXR5L3VuY2hlY2tlZEFwcGVuZCBwYXR0ZXJuLCB0aGUgbWFwcGVyIGJldHdlZW4gc291cmNlIGFu ZCBkZXN0aW5hdGlvbiBpdGVtIGJlaW5nIGEgbGFtYmRhLgorCisgICAgICAgICogd3RmL1ZlY3Rv ci5oOgorICAgICAgICAoV1RGOjpNYXBwZXI6OnRyYW5zZm9ybSk6CisgICAgICAgIChXVEY6Ok1h cHBlcjo6bWFwKToKKyAgICAgICAgKFdURjo6bWFwKToKKwogMjAxNy0wOS0wNiAgUGVyIEFybmUg Vm9sbGFuICA8cHZvbGxhbkBhcHBsZS5jb20+CiAKICAgICAgICAgW1dpbl0gV2ViQ29yZSBmYWls ZWQgdG8gYnVpbGQsIEluYmFuZFRleHRUcmFja1ByaXZhdGVBVkY6IGJhc2UgY2xhc3MgdW5kZWZp bmVkLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0 L0NoYW5nZUxvZwppbmRleCAwYWYxMjE0NmJjZWE1YzMxNTMyNDkxZTUzZWY3ZDI5NzE3YmVlN2Rk Li4xNTI0ZGNjOTRiZGQ4YjE4ZWE5YTgyMzI4NzU0ZDY4ZWY5YmQ5YzBlIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L0NoYW5nZUxvZwpAQCAt MSw1ICsxLDE1IEBACiAyMDE3LTA5LTA2ICBZb3Vlbm4gRmFibGV0ICA8eW91ZW5uQGFwcGxlLmNv bT4KIAorICAgICAgICBBZGQgYSBsYW1iZGEtYmFzZWQgbWFwIGZvciBWZWN0b3JzCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNzY0ODcKKworICAgICAg ICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIE5ldHdvcmtQcm9jZXNz L2NhY2hlL0NhY2hlU3RvcmFnZUVuZ2luZUNhY2hlcy5jcHA6CisgICAgICAgIChXZWJLaXQ6OkNh Y2hlU3RvcmFnZTo6Q2FjaGVzOjpyZWFkQ2FjaGVzRnJvbURpc2spOgorCisyMDE3LTA5LTA2ICBZ b3Vlbm4gRmFibGV0ICA8eW91ZW5uQGFwcGxlLmNvbT4KKwogICAgICAgICBOZXR3b3JrUHJvY2Vz cyBDYWNoZSBhbmQgQ2FjaGVzIHNob3VsZCBiZSBjbGVhcmVkIHdoZW4gdGhlIGxhc3QgcmVsYXRl ZCBXZWJQcm9jZXNzIENhY2hlIG9yIENhY2hlU3RvcmFnZSBpcyBkZXN0cm95ZWQKICAgICAgICAg aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3NjI0OQogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV1RGL3d0Zi9WZWN0b3IuaCBiL1NvdXJjZS9XVEYvd3RmL1ZlY3Rvci5oCmlu ZGV4IGNmOWM3ZmJhZjg4MjY1Mzc5MzU2YjlkZTc3ZTg3ZDVjZDZkNTU4MTQuLjdhODgwOWIwNWIy M2NkZGU3YzViNzc2YzQwYTUxYWRjMDA2YzgyMjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvd3Rm L1ZlY3Rvci5oCisrKyBiL1NvdXJjZS9XVEYvd3RmL1ZlY3Rvci5oCkBAIC0xNTYwLDYgKzE1NjAs NDAgQEAgc2l6ZV90IHJlbW92ZVJlcGVhdGVkRWxlbWVudHMoVmVjdG9yPFQsIGlubGluZUNhcGFj aXR5LCBPdmVyZmxvd0hhbmRsZXIsIG1pbkNhcGEKICAgICByZXR1cm4gcmVtb3ZlUmVwZWF0ZWRF bGVtZW50cyh2ZWN0b3IsIFtdIChUJiBhLCBUJiBiKSB7IHJldHVybiBhID09IGI7IH0pOwogfQog Cit0ZW1wbGF0ZTx0eXBlbmFtZSBUcmFuc2Zvcm1lciwgdHlwZW5hbWUgU291cmNlVHlwZT4gc3Ry dWN0IE1hcHBlciB7CisgICAgdXNpbmcgUmVhbFNvdXJjZVR5cGUgPSB0eXBlbmFtZSBzdGQ6OnJl bW92ZV9yZWZlcmVuY2U8U291cmNlVHlwZT46OnR5cGU7CisgICAgdXNpbmcgU291cmNlSXRlbVR5 cGUgPSB0eXBlbmFtZSBSZWFsU291cmNlVHlwZTo6VmFsdWVUeXBlOworICAgIHVzaW5nIERlc3Rp bmF0aW9uSXRlbVR5cGUgPSB0eXBlbmFtZSBzdGQ6OnJlc3VsdF9vZjxUcmFuc2Zvcm1lcihTb3Vy Y2VJdGVtVHlwZSYmKT46OnR5cGU7CisKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBVLCBzdGQ6OmVu YWJsZV9pZl90PHN0ZDo6aXNfY29uc3Q8dHlwZW5hbWUgc3RkOjpyZW1vdmVfcmVmZXJlbmNlPFU+ Ojp0eXBlPjo6dmFsdWU+KiA9IG51bGxwdHI+CisgICAgc3RhdGljIHZvaWQgdHJhbnNmb3JtKFZl Y3RvcjxEZXN0aW5hdGlvbkl0ZW1UeXBlPiYgcmVzdWx0LCBVJiYgc291cmNlLCBjb25zdCBUcmFu c2Zvcm1lciYgdHJhbnNmb3JtZXIpCisgICAgeworICAgICAgICBmb3IgKGNvbnN0IGF1dG8mIGl0 ZW0gOiBzb3VyY2UpCisgICAgICAgICAgICByZXN1bHQudW5jaGVja2VkQXBwZW5kKHRyYW5zZm9y bWVyKGl0ZW0pKTsKKyAgICB9CisKKyAgICB0ZW1wbGF0ZTx0eXBlbmFtZSBVLCBzdGQ6OmVuYWJs ZV9pZl90PCFzdGQ6OmlzX2NvbnN0PHR5cGVuYW1lIHN0ZDo6cmVtb3ZlX3JlZmVyZW5jZTxVPjo6 dHlwZT46OnZhbHVlPiogPSBudWxscHRyPgorICAgIHN0YXRpYyB2b2lkIHRyYW5zZm9ybShWZWN0 b3I8RGVzdGluYXRpb25JdGVtVHlwZT4mIHJlc3VsdCwgVSYmIHNvdXJjZSwgY29uc3QgVHJhbnNm b3JtZXImIHRyYW5zZm9ybWVyKQorICAgIHsKKyAgICAgICAgZm9yIChhdXRvJiBpdGVtIDogc291 cmNlKQorICAgICAgICAgICAgcmVzdWx0LnVuY2hlY2tlZEFwcGVuZCh0cmFuc2Zvcm1lcihzdGQ6 OmZvcndhcmQ8U291cmNlSXRlbVR5cGU+KGl0ZW0pKSk7CisgICAgfQorCisgICAgc3RhdGljIFZl Y3RvcjxEZXN0aW5hdGlvbkl0ZW1UeXBlPiBtYXAoU291cmNlVHlwZSYmIHNvdXJjZSwgY29uc3Qg VHJhbnNmb3JtZXImIHRyYW5zZm9ybWVyKQorICAgIHsKKyAgICAgICAgVmVjdG9yPERlc3RpbmF0 aW9uSXRlbVR5cGU+IHJlc3VsdDsKKyAgICAgICAgcmVzdWx0LnJlc2VydmVJbml0aWFsQ2FwYWNp dHkoc291cmNlLnNpemUoKSk7CisgICAgICAgIHRyYW5zZm9ybShyZXN1bHQsIHN0ZDo6Zm9yd2Fy ZDxTb3VyY2VUeXBlPihzb3VyY2UpLCB0cmFuc2Zvcm1lcik7CisgICAgICAgIHJldHVybiByZXN1 bHQ7CisgICAgfQorfTsKKwordGVtcGxhdGU8dHlwZW5hbWUgVHJhbnNmb3JtZXIsIHR5cGVuYW1l IFZlY3RvclR5cGU+CitWZWN0b3I8dHlwZW5hbWUgTWFwcGVyPFRyYW5zZm9ybWVyLCBWZWN0b3JU eXBlPjo6RGVzdGluYXRpb25JdGVtVHlwZT4gbWFwKFZlY3RvclR5cGUmJiBzb3VyY2UsIGNvbnN0 IFRyYW5zZm9ybWVyJiB0cmFuc2Zvcm1lcikKK3sKKyAgICByZXR1cm4gTWFwcGVyPFRyYW5zZm9y bWVyLCBWZWN0b3JUeXBlPjo6bWFwKHN0ZDo6Zm9yd2FyZDxWZWN0b3JUeXBlPihzb3VyY2UpLCB0 cmFuc2Zvcm1lcik7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdURgogCiB1c2luZyBXVEY6OlZlY3Rv cjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nlc3MvY2FjaGUvQ2FjaGVT dG9yYWdlRW5naW5lQ2FjaGVzLmNwcCBiL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nlc3MvY2Fj aGUvQ2FjaGVTdG9yYWdlRW5naW5lQ2FjaGVzLmNwcAppbmRleCAyYzFiZmE1ZTViOWVhODNhMjkx OTkxZDJmNGIyYTg5MGNiMWM1MTk2Li45ZGMyN2Y0ZDQwMzhmODA0YTYzMjc3YzRiMWQxYTBkMjUw NmRkMGZiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL2NhY2hlL0Nh Y2hlU3RvcmFnZUVuZ2luZUNhY2hlcy5jcHAKKysrIGIvU291cmNlL1dlYktpdC9OZXR3b3JrUHJv Y2Vzcy9jYWNoZS9DYWNoZVN0b3JhZ2VFbmdpbmVDYWNoZXMuY3BwCkBAIC0yNDAsMTIgKzI0MCw5 IEBAIHZvaWQgQ2FjaGVzOjpyZWFkQ2FjaGVzRnJvbURpc2soV1RGOjpGdW5jdGlvbjx2b2lkKEV4 cGVjdGVkPFZlY3RvcjxDYWNoZT4sIEVycm9yCiAgICAgICAgICAgICBjYWxsYmFjayhtYWtlVW5l eHBlY3RlZChyZXN1bHQuZXJyb3IoKSkpOwogICAgICAgICAgICAgcmV0dXJuOwogICAgICAgICB9 Ci0gICAgICAgIFZlY3RvcjxDYWNoZT4gY2FjaGVzOwotICAgICAgICBjYWNoZXMucmVzZXJ2ZUlu aXRpYWxDYXBhY2l0eShyZXN1bHQudmFsdWUoKS5zaXplKCkpOwotICAgICAgICBmb3IgKGF1dG8m IG5hbWUgOiByZXN1bHQudmFsdWUoKSkKLSAgICAgICAgICAgIGNhY2hlcy51bmNoZWNrZWRBcHBl bmQoQ2FjaGUgeyAqdGhpcywgbV9lbmdpbmUtPm5leHRDYWNoZUlkZW50aWZpZXIoKSwgQ2FjaGU6 OlN0YXRlOjpVbmluaXRpYWxpemVkLCBXVEZNb3ZlKG5hbWUpIH0pOwotCi0gICAgICAgIGNhbGxi YWNrKFdURk1vdmUoY2FjaGVzKSk7CisgICAgICAgIGNhbGxiYWNrKFdURjo6bWFwKFdURk1vdmUo cmVzdWx0LnZhbHVlKCkpLCBbdGhpc10oU3RyaW5nJiYgbmFtZSkgeworICAgICAgICAgICAgcmV0 dXJuIENhY2hlIHsgKnRoaXMsIG1fZW5naW5lLT5uZXh0Q2FjaGVJZGVudGlmaWVyKCksIENhY2hl OjpTdGF0ZTo6VW5pbml0aWFsaXplZCwgV1RGTW92ZShuYW1lKSB9OworICAgICAgICB9KSk7CiAg ICAgfSk7CiB9CiAKZGlmZiAtLWdpdCBhL1Rvb2xzL0NoYW5nZUxvZyBiL1Rvb2xzL0NoYW5nZUxv ZwppbmRleCBmMzBmOTlhN2EzZWQ4ZGY3YWZmZmQyNDg3YWRmOTc0YzE5MzhiOTBlLi41ODQ4Y2Iy NjQzZjE0YzQ0YjdkNTQ3MGVkYTE1ZmVhODBiNmI2NGY1IDEwMDY0NAotLS0gYS9Ub29scy9DaGFu Z2VMb2cKKysrIGIvVG9vbHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTMgQEAKKzIwMTctMDktMDcg IFlvdWVubiBGYWJsZXQgIDx5b3Vlbm5AYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBhIGxhbWJk YS1iYXNlZCBtYXAgZm9yIFZlY3RvcnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTE3NjQ4NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09Q UyEpLgorCisgICAgICAgICogVGVzdFdlYktpdEFQSS9UZXN0cy9XVEYvVmVjdG9yLmNwcDoKKyAg ICAgICAgKFRlc3RXZWJLaXRBUEk6OlRFU1QpOgorCiAyMDE3LTA5LTA2ICBBbGV4IENocmlzdGVu c2VuICA8YWNocmlzdGVuc2VuQHdlYmtpdC5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9s bGluZyBvdXQgcjIyMTY5NC4KZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMv V1RGL1ZlY3Rvci5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dURi9WZWN0b3IuY3Bw CmluZGV4IDRkYWJhMzAwNzZjODc2OTcwMjYxMTgyOGE2MzU1YzNkMTIyN2NkYzMuLjY1NzlmNTMy YWM5ZTcxNTQwNDFmNjgxNjA0ZTBjMDIzNjY3ZTAzNTAgMTAwNjQ0Ci0tLSBhL1Rvb2xzL1Rlc3RX ZWJLaXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5jcHAKKysrIGIvVG9vbHMvVGVzdFdlYktpdEFQSS9U ZXN0cy9XVEYvVmVjdG9yLmNwcApAQCAtNjUxLDQgKzY1MSw0MCBAQCBURVNUKFdURl9WZWN0b3Is IFJlbW92ZUFsbE1hdGNoaW5nKQogICAgIEVYUEVDVF9FUSgwVSwgdi5zaXplKCkpOwogfQogCitU RVNUKFdURl9WZWN0b3IsIE1hcExhbWJkYSkKK3sKKyAgICBWZWN0b3I8aW50PiB2ZWN0b3IgeyAx LCAxLCAxfTsKKworICAgIGludCBjb3VudGVyID0gMDsKKyAgICBhdXRvIG1hcHBlZCA9IFdURjo6 bWFwKHZlY3RvciwgWyZdKGNvbnN0IGF1dG8mIGl0ZW0pIHsKKyAgICAgICAgcmV0dXJuICsrY291 bnRlciA8PSBpdGVtOworICAgIH0pOworCisgICAgRVhQRUNUX0VRKDNVLCBtYXBwZWQuc2l6ZSgp KTsKKyAgICBFWFBFQ1RfVFJVRShtYXBwZWRbMF0pOworICAgIEVYUEVDVF9GQUxTRShtYXBwZWRb MV0pOworICAgIEVYUEVDVF9GQUxTRShtYXBwZWRbMl0pOworfQorCitURVNUKFdURl9WZWN0b3Is IE1hcExhbWJkYU1vdmUpCit7CisgICAgVmVjdG9yPE1vdmVPbmx5PiB2ZWN0b3I7CisKKyAgICB2 ZWN0b3IucmVzZXJ2ZUluaXRpYWxDYXBhY2l0eSgzKTsKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAw OyBpIDwgMzsgKytpKQorICAgICAgICB2ZWN0b3IudW5jaGVja2VkQXBwZW5kKE1vdmVPbmx5IHsg aSB9KTsKKworCisgICAgdW5zaWduZWQgY291bnRlciA9IDA7CisgICAgYXV0byBtYXBwZWQgPSBX VEY6Om1hcChXVEZNb3ZlKHZlY3RvciksIFsmXShNb3ZlT25seSYmIGl0ZW0pIHsKKyAgICAgICAg aXRlbSA9IGl0ZW0udmFsdWUoKSArICsrY291bnRlcjsKKyAgICAgICAgcmV0dXJuIFdURk1vdmUo aXRlbSk7CisgICAgfSk7CisKKyAgICBFWFBFQ1RfRVEoM1UsIG1hcHBlZC5zaXplKCkpOworICAg IEVYUEVDVF9FUSgxVSwgbWFwcGVkWzBdLnZhbHVlKCkpOworICAgIEVYUEVDVF9FUSgzVSwgbWFw cGVkWzFdLnZhbHVlKCkpOworICAgIEVYUEVDVF9FUSg1VSwgbWFwcGVkWzJdLnZhbHVlKCkpOwor fQorCiB9IC8vIG5hbWVzcGFjZSBUZXN0V2ViS2l0QVBJCg== 320642 2017-09-13 08:55:24 -0700 2017-09-13 10:50:51 -0700 Patch for landing bug-176487-20170913085524.patch text/plain 6217 youennf U3VidmVyc2lvbiBSZXZpc2lvbjogMjIxOTE1CmRpZmYgLS1naXQgYS9Tb3VyY2UvV1RGL0NoYW5n ZUxvZyBiL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCmluZGV4IGZkNmFmNThkMzY0OWM5YWJhNWMwZjA4 MGEyYzk5NWMyMmU3ZmUxM2YuLjQ1OTFlMzkwNWYxNjE5YTJmNjIwOGQ0YjM4Y2E2Y2Q4MDEzNDMy MDQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XVEYvQ2hh bmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMTctMDktMTIgIFlvdWVubiBGYWJsZXQgIDx5b3Vl bm5AYXBwbGUuY29tPgorCisgICAgICAgIEFkZCBhIGxhbWJkYS1iYXNlZCBtYXAgZm9yIFZlY3Rv cnMKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTE3NjQ4 NworCisgICAgICAgIFJldmlld2VkIGJ5IERhcmluIEFkbGVyLgorCisgICAgICAgIFRoaXMgaGVs cGVyIHJvdXRpbmUgYWxsb3dzIHJlZmFjdG9yaW5nIHRoZSByZXNlcnZlSW5pdGlhbENhcGFjaXR5 L3VuY2hlY2tlZEFwcGVuZCBwYXR0ZXJuLCB0aGUgbWFwcGVyIGJldHdlZW4gc291cmNlIGFuZCBk ZXN0aW5hdGlvbiBpdGVtIGJlaW5nIGEgbGFtYmRhLgorCisgICAgICAgICogd3RmL1ZlY3Rvci5o OgorICAgICAgICAoV1RGOjpNYXBwZXI6OnRyYW5zZm9ybSk6CisgICAgICAgIChXVEY6Ok1hcHBl cjo6bWFwKToKKyAgICAgICAgKFdURjo6bWFwKToKKwogMjAxNy0wOS0xMiAgU2FtIFdlaW5pZyAg PHNhbUB3ZWJraXQub3JnPgogCiAgICAgICAgIFtDbGVhbnVwXSBGb2xsb3cgdXAgY2xlYW51cCBm b3IgRE9NRm9ybURhdGEgaW1wbGVtZW50YXRpb24KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv Q2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKaW5kZXggNzYxMDU4MDE4MjdkNmFh ZjZkMDkwYmU0NTY2YTEwZGJiYTQ4MGI3NC4uOWRmNWNmMTRkZjJiYTE1NDI2MGE5NmUyMmY2MGMx NWEyNWI4ZmZiNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYktpdC9DaGFuZ2VMb2cKQEAgLTEsMyArMSwxMyBAQAorMjAxNy0wOS0xMiAgWW91ZW5u IEZhYmxldCAgPHlvdWVubkBhcHBsZS5jb20+CisKKyAgICAgICAgQWRkIGEgbGFtYmRhLWJhc2Vk IG1hcCBmb3IgVmVjdG9ycworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MTc2NDg3CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgRGFyaW4gQWRsZXIuCisKKyAg ICAgICAgKiBOZXR3b3JrUHJvY2Vzcy9jYWNoZS9DYWNoZVN0b3JhZ2VFbmdpbmVDYWNoZXMuY3Bw OgorICAgICAgICAoV2ViS2l0OjpDYWNoZVN0b3JhZ2U6OkNhY2hlczo6cmVhZENhY2hlc0Zyb21E aXNrKToKKwogMjAxNy0wOS0xMSAgV2Vuc29uIEhzaWVoICA8d2Vuc29uX2hzaWVoQGFwcGxlLmNv bT4KIAogICAgICAgICBbaU9TIERuRF0gU3VwcG9ydCBEYXRhVHJhbnNmZXIuc2V0RHJhZ0ltYWdl IHdoZW4gc3RhcnRpbmcgYSBkcmFnIG9uIGlPUwpkaWZmIC0tZ2l0IGEvU291cmNlL1dURi93dGYv VmVjdG9yLmggYi9Tb3VyY2UvV1RGL3d0Zi9WZWN0b3IuaAppbmRleCBjZjljN2ZiYWY4ODI2NTM3 OTM1NmI5ZGU3N2U4N2Q1Y2Q2ZDU1ODE0Li45YWQ4OTY4YWI5ZjcyMjZjNDY3Nzg1ZjVlNmEzODVm MjQ5MDViNjc3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL3d0Zi9WZWN0b3IuaAorKysgYi9Tb3Vy Y2UvV1RGL3d0Zi9WZWN0b3IuaApAQCAtMTU2MCw2ICsxNTYwLDM2IEBAIHNpemVfdCByZW1vdmVS ZXBlYXRlZEVsZW1lbnRzKFZlY3RvcjxULCBpbmxpbmVDYXBhY2l0eSwgT3ZlcmZsb3dIYW5kbGVy LCBtaW5DYXBhCiAgICAgcmV0dXJuIHJlbW92ZVJlcGVhdGVkRWxlbWVudHModmVjdG9yLCBbXSAo VCYgYSwgVCYgYikgeyByZXR1cm4gYSA9PSBiOyB9KTsKIH0KIAordGVtcGxhdGU8dHlwZW5hbWUg VHJhbnNmb3JtZXIsIHR5cGVuYW1lIFNvdXJjZVR5cGU+IHN0cnVjdCBNYXBwZXIgeworICAgIHVz aW5nIFJlYWxTb3VyY2VUeXBlID0gdHlwZW5hbWUgc3RkOjpyZW1vdmVfcmVmZXJlbmNlPFNvdXJj ZVR5cGU+Ojp0eXBlOworICAgIHVzaW5nIFNvdXJjZUl0ZW1UeXBlID0gdHlwZW5hbWUgUmVhbFNv dXJjZVR5cGU6OlZhbHVlVHlwZTsKKyAgICB1c2luZyBEZXN0aW5hdGlvbkl0ZW1UeXBlID0gdHlw ZW5hbWUgc3RkOjpyZXN1bHRfb2Y8VHJhbnNmb3JtZXIoU291cmNlSXRlbVR5cGUmJik+Ojp0eXBl OworCisgICAgc3RhdGljIFZlY3RvcjxEZXN0aW5hdGlvbkl0ZW1UeXBlPiBtYXAoY29uc3QgUmVh bFNvdXJjZVR5cGUmIHNvdXJjZSwgY29uc3QgVHJhbnNmb3JtZXImIHRyYW5zZm9ybWVyKQorICAg IHsKKyAgICAgICAgVmVjdG9yPERlc3RpbmF0aW9uSXRlbVR5cGU+IHJlc3VsdDsKKyAgICAgICAg cmVzdWx0LnJlc2VydmVJbml0aWFsQ2FwYWNpdHkoc291cmNlLnNpemUoKSk7CisgICAgICAgIGZv ciAoYXV0byYgaXRlbSA6IHNvdXJjZSkKKyAgICAgICAgICAgIHJlc3VsdC51bmNoZWNrZWRBcHBl bmQodHJhbnNmb3JtZXIoaXRlbSkpOworICAgICAgICByZXR1cm4gcmVzdWx0OworICAgIH0KKwor ICAgIHN0YXRpYyBWZWN0b3I8RGVzdGluYXRpb25JdGVtVHlwZT4gbWFwKFJlYWxTb3VyY2VUeXBl JiYgc291cmNlLCBjb25zdCBUcmFuc2Zvcm1lciYgdHJhbnNmb3JtZXIpCisgICAgeworICAgICAg ICBWZWN0b3I8RGVzdGluYXRpb25JdGVtVHlwZT4gcmVzdWx0OworICAgICAgICByZXN1bHQucmVz ZXJ2ZUluaXRpYWxDYXBhY2l0eShzb3VyY2Uuc2l6ZSgpKTsKKyAgICAgICAgZm9yIChhdXRvJiBp dGVtIDogc291cmNlKQorICAgICAgICAgICAgcmVzdWx0LnVuY2hlY2tlZEFwcGVuZCh0cmFuc2Zv cm1lcihzdGQ6OmZvcndhcmQ8U291cmNlSXRlbVR5cGU+KGl0ZW0pKSk7CisgICAgICAgIHJldHVy biByZXN1bHQ7CisgICAgfQorfTsKKwordGVtcGxhdGU8dHlwZW5hbWUgVHJhbnNmb3JtZXIsIHR5 cGVuYW1lIFZlY3RvclR5cGU+CitWZWN0b3I8dHlwZW5hbWUgTWFwcGVyPFRyYW5zZm9ybWVyLCBW ZWN0b3JUeXBlPjo6RGVzdGluYXRpb25JdGVtVHlwZT4gbWFwKFZlY3RvclR5cGUmJiBzb3VyY2Us IGNvbnN0IFRyYW5zZm9ybWVyJiB0cmFuc2Zvcm1lcikKK3sKKyAgICByZXR1cm4gTWFwcGVyPFRy YW5zZm9ybWVyLCBWZWN0b3JUeXBlPjo6bWFwKHN0ZDo6Zm9yd2FyZDxWZWN0b3JUeXBlPihzb3Vy Y2UpLCB0cmFuc2Zvcm1lcik7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdURgogCiB1c2luZyBXVEY6 OlZlY3RvcjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nlc3MvY2FjaGUv Q2FjaGVTdG9yYWdlRW5naW5lQ2FjaGVzLmNwcCBiL1NvdXJjZS9XZWJLaXQvTmV0d29ya1Byb2Nl c3MvY2FjaGUvQ2FjaGVTdG9yYWdlRW5naW5lQ2FjaGVzLmNwcAppbmRleCAyYzFiZmE1ZTViOWVh ODNhMjkxOTkxZDJmNGIyYTg5MGNiMWM1MTk2Li5iMzFlMjg5NzdkZWQxYzQ3MGM2OTY5NWIwMzhj YmI0NWM0YTNmNWM3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L05ldHdvcmtQcm9jZXNzL2Nh Y2hlL0NhY2hlU3RvcmFnZUVuZ2luZUNhY2hlcy5jcHAKKysrIGIvU291cmNlL1dlYktpdC9OZXR3 b3JrUHJvY2Vzcy9jYWNoZS9DYWNoZVN0b3JhZ2VFbmdpbmVDYWNoZXMuY3BwCkBAIC0yNDAsMTIg KzI0MCw5IEBAIHZvaWQgQ2FjaGVzOjpyZWFkQ2FjaGVzRnJvbURpc2soV1RGOjpGdW5jdGlvbjx2 b2lkKEV4cGVjdGVkPFZlY3RvcjxDYWNoZT4sIEVycm9yCiAgICAgICAgICAgICBjYWxsYmFjayht YWtlVW5leHBlY3RlZChyZXN1bHQuZXJyb3IoKSkpOwogICAgICAgICAgICAgcmV0dXJuOwogICAg ICAgICB9Ci0gICAgICAgIFZlY3RvcjxDYWNoZT4gY2FjaGVzOwotICAgICAgICBjYWNoZXMucmVz ZXJ2ZUluaXRpYWxDYXBhY2l0eShyZXN1bHQudmFsdWUoKS5zaXplKCkpOwotICAgICAgICBmb3Ig KGF1dG8mIG5hbWUgOiByZXN1bHQudmFsdWUoKSkKLSAgICAgICAgICAgIGNhY2hlcy51bmNoZWNr ZWRBcHBlbmQoQ2FjaGUgeyAqdGhpcywgbV9lbmdpbmUtPm5leHRDYWNoZUlkZW50aWZpZXIoKSwg Q2FjaGU6OlN0YXRlOjpVbmluaXRpYWxpemVkLCBXVEZNb3ZlKG5hbWUpIH0pOwotCi0gICAgICAg IGNhbGxiYWNrKFdURk1vdmUoY2FjaGVzKSk7CisgICAgICAgIGNhbGxiYWNrKFdURjo6bWFwKFdU Rk1vdmUocmVzdWx0LnZhbHVlKCkpLCBbdGhpc10gKFN0cmluZyYmIG5hbWUpIHsKKyAgICAgICAg ICAgIHJldHVybiBDYWNoZSB7ICp0aGlzLCBtX2VuZ2luZS0+bmV4dENhY2hlSWRlbnRpZmllcigp LCBDYWNoZTo6U3RhdGU6OlVuaW5pdGlhbGl6ZWQsIFdURk1vdmUobmFtZSkgfTsKKyAgICAgICAg fSkpOwogICAgIH0pOwogfQogCmRpZmYgLS1naXQgYS9Ub29scy9DaGFuZ2VMb2cgYi9Ub29scy9D aGFuZ2VMb2cKaW5kZXggYTYxNjZkZWQ1Yzc1Yzc2NGIxNGMzMWVlODdiMjRhYzQ5Mjk2NDE0ZS4u YjE3ZWJjNzNmNWQ4ZTYzNGY4OWY5NzZkMGZkOGIzYWQ3YzVjNTgzZCAxMDA2NDQKLS0tIGEvVG9v bHMvQ2hhbmdlTG9nCisrKyBiL1Rvb2xzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDEzIEBACisyMDE3 LTA5LTEyICBZb3Vlbm4gRmFibGV0ICA8eW91ZW5uQGFwcGxlLmNvbT4KKworICAgICAgICBBZGQg YSBsYW1iZGEtYmFzZWQgbWFwIGZvciBWZWN0b3JzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xNzY0ODcKKworICAgICAgICBSZXZpZXdlZCBieSBEYXJp biBBZGxlci4KKworICAgICAgICAqIFRlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5jcHA6 CisgICAgICAgIChUZXN0V2ViS2l0QVBJOjpURVNUKToKKwogMjAxNy0wOS0xMiAgQ2FybG9zIEdh cmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CiAKICAgICAgICAgW0ZyZWV0eXBlXSBE b2Vzbid0IHN1cHBvcnQgY29sb3VyZWQgZm9udHMKZGlmZiAtLWdpdCBhL1Rvb2xzL1Rlc3RXZWJL aXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5jcHAgYi9Ub29scy9UZXN0V2ViS2l0QVBJL1Rlc3RzL1dU Ri9WZWN0b3IuY3BwCmluZGV4IDRkYWJhMzAwNzZjODc2OTcwMjYxMTgyOGE2MzU1YzNkMTIyN2Nk YzMuLjkxZjdjZTBlYmJlZTUzZDk4YTJkNDUyNzRkYjllNjhmZWZkMTdhMTMgMTAwNjQ0Ci0tLSBh L1Rvb2xzL1Rlc3RXZWJLaXRBUEkvVGVzdHMvV1RGL1ZlY3Rvci5jcHAKKysrIGIvVG9vbHMvVGVz dFdlYktpdEFQSS9UZXN0cy9XVEYvVmVjdG9yLmNwcApAQCAtNjUxLDQgKzY1MSw0MSBAQCBURVNU KFdURl9WZWN0b3IsIFJlbW92ZUFsbE1hdGNoaW5nKQogICAgIEVYUEVDVF9FUSgwVSwgdi5zaXpl KCkpOwogfQogCitURVNUKFdURl9WZWN0b3IsIE1hcExhbWJkYSkKK3sKKyAgICBWZWN0b3I8aW50 PiB2ZWN0b3IgeyAyLCAzLCA0fTsKKworICAgIGludCBjb3VudGVyID0gMDsKKyAgICBhdXRvIG1h cHBlZCA9IFdURjo6bWFwKHZlY3RvciwgWyZdIChpbnQgaXRlbSkgeworICAgICAgICBjb3VudGVy ICs9IDI7CisgICAgICAgIHJldHVybiBjb3VudGVyIDw9IGl0ZW07CisgICAgfSk7CisKKyAgICBF WFBFQ1RfRVEoM1UsIG1hcHBlZC5zaXplKCkpOworICAgIEVYUEVDVF9UUlVFKG1hcHBlZFswXSk7 CisgICAgRVhQRUNUX0ZBTFNFKG1hcHBlZFsxXSk7CisgICAgRVhQRUNUX0ZBTFNFKG1hcHBlZFsy XSk7Cit9CisKK1RFU1QoV1RGX1ZlY3RvciwgTWFwTGFtYmRhTW92ZSkKK3sKKyAgICBWZWN0b3I8 TW92ZU9ubHk+IHZlY3RvcjsKKworICAgIHZlY3Rvci5yZXNlcnZlSW5pdGlhbENhcGFjaXR5KDMp OworICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCAzOyArK2kpCisgICAgICAgIHZlY3Rvci51 bmNoZWNrZWRBcHBlbmQoTW92ZU9ubHkgeyBpIH0pOworCisKKyAgICB1bnNpZ25lZCBjb3VudGVy ID0gMDsKKyAgICBhdXRvIG1hcHBlZCA9IFdURjo6bWFwKFdURk1vdmUodmVjdG9yKSwgWyZdIChN b3ZlT25seSYmIGl0ZW0pIHsKKyAgICAgICAgaXRlbSA9IGl0ZW0udmFsdWUoKSArICsrY291bnRl cjsKKyAgICAgICAgcmV0dXJuIFdURk1vdmUoaXRlbSk7CisgICAgfSk7CisKKyAgICBFWFBFQ1Rf RVEoM1UsIG1hcHBlZC5zaXplKCkpOworICAgIEVYUEVDVF9FUSgxVSwgbWFwcGVkWzBdLnZhbHVl KCkpOworICAgIEVYUEVDVF9FUSgzVSwgbWFwcGVkWzFdLnZhbHVlKCkpOworICAgIEVYUEVDVF9F USg1VSwgbWFwcGVkWzJdLnZhbHVlKCkpOworfQorCiB9IC8vIG5hbWVzcGFjZSBUZXN0V2ViS2l0 QVBJCg==