109880 2013-02-14 18:31:09 -0800 Stack allocated the grid data in RenderGrid 2013-02-15 12:27:22 -0800 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED WONTFIX P2 Normal --- 109881 1 ojan ojan eric jchaffraix ojan.autocc tony webkit.review.bot oldest_to_newest 833611 0 ojan 2013-02-14 18:31:09 -0800 Stack allocated the grid data in RenderGrid 833612 1 188463 ojan 2013-02-14 18:33:29 -0800 Created attachment 188463 Patch 834006 2 188463 jchaffraix 2013-02-15 07:29:44 -0800 Comment on attachment 188463 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=188463&action=review As a whole, I don't think this is an improvement (though I do understand the goal). If we want to cache the grid representation between layouts, we will have to revert this change. Also computing the grid falls into logical const-ness IMO. Enforcing logical constness would only require to add a mutable statement to m_grid or (probably better) a const_cast to call placeItemsOnGrid vs patching a lot of RenderGrid's methods to enforce physical const-ness. Because of the above, I would rather see us the former instead of the latter (unless I missed something). > Source/WebCore/rendering/RenderGrid.cpp:471 > + ASSERT(grid.isEmpty()); This ASSERT becomes pretty useless. It was to catch people not calling clear() on the grid at the end of layout / computePreferredLogicalWidths. > Source/WebCore/rendering/RenderGrid.h:53 > + typedef Vector<Vector<Vector<RenderBox*, 1> > > GridData; I am not super fan of the naming. GridData is a pretty generic and already overloaded term (e.g StyleGridData). I would just stick with Grid as this is really what it is. If you want something less generic, GridRepresentation could work (btw, this is the typedef you said was not super useful, guess it was :)) 834121 3 ojan 2013-02-15 09:58:16 -0800 (In reply to comment #2) > (From update of attachment 188463 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=188463&action=review > > As a whole, I don't think this is an improvement (though I do understand the goal). > > If we want to cache the grid representation between layouts, we will have to revert this change. Also computing the grid falls into logical const-ness IMO. Enforcing logical constness would only require to add a mutable statement to m_grid or (probably better) a const_cast to call placeItemsOnGrid vs patching a lot of RenderGrid's methods to enforce physical const-ness. Because of the above, I would rather see us the former instead of the latter (unless I missed something). Assuming a world where we know that we never want to cache the grid representation, do you still think this is a step in the wrong direction? I don't think we should write the code around a performance optimization that may or may not apply in the future. Also, undoing this change is a tiny amount of work. The reason I like stack allocating it is because for someone new to the code it's much easier to trace what's going on. Also, as it is, in the current the member variable is just a way to avoid passing an argument around, which is a bad reason to make something a member IMO. Also, it means we need to be careful to always call m_grid.clear(). What if we add an early return in the middle of layoutGridItems? > > Source/WebCore/rendering/RenderGrid.cpp:471 > > + ASSERT(grid.isEmpty()); > > This ASSERT becomes pretty useless. It was to catch people not calling clear() on the grid at the end of layout / computePreferredLogicalWidths. Yeah. I thought about it and decided it could be valuable to assert that someone isn't calling placeItemsOnGrid multiple times on the same grid. That's obviously not gonna happen in the current code, but I could imagine it in the future. > > Source/WebCore/rendering/RenderGrid.h:53 > > + typedef Vector<Vector<Vector<RenderBox*, 1> > > GridData; > > I am not super fan of the naming. GridData is a pretty generic and already overloaded term (e.g StyleGridData). > > I would just stick with Grid as this is really what it is. If you want something less generic, GridRepresentation could work (btw, this is the typedef you said was not super useful, guess it was :)) I can change it to Grid. Now that we're passing it around everywhere, it's clearly more readable to have a typedef IMO. 834161 4 188463 jchaffraix 2013-02-15 10:37:44 -0800 Comment on attachment 188463 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=188463&action=review > Assuming a world where we know that we never want to cache the grid representation, do you still think this is a step in the wrong direction? I don't think we should write the code around a performance optimization that may or may not apply in the future. Also, undoing this change is a tiny amount of work. That's assuming my objection was only based on performance: adding an extra argument to 5 functions is a cognitive load and I have been complaining about having lots of arguments already. Also if you wanted it on the stack, you should have requested it when reviewing the patch for the representation yesterday. It feels weird to undo that the next day. So yes, even if you take performance refactorings out of the equation, I still think it's not the right direction. But we can agree to disagree on this. > The reason I like stack allocating it is because for someone new to the code it's much easier to trace what's going on. Also, as it is, in the current the member variable is just a way to avoid passing an argument around, which is a bad reason to make something a member IMO. Also, it means we need to be careful to always call m_grid.clear(). What if we add an early return in the middle of layoutGridItems? That's a far-fetched argument. We rarely early return in layout and I don't see why this would happen in grid. >>> Source/WebCore/rendering/RenderGrid.cpp:471 >>> + ASSERT(grid.isEmpty()); >> >> This ASSERT becomes pretty useless. It was to catch people not calling clear() on the grid at the end of layout / computePreferredLogicalWidths. > > Yeah. I thought about it and decided it could be valuable to assert that someone isn't calling placeItemsOnGrid multiple times on the same grid. That's obviously not gonna happen in the current code, but I could imagine it in the future. As I tell people, I can't read your mind, neither your ChangeLog nor a comment explains why this was kept so how am I to know? This ASSERT would need a comment as you are changing the meaning of it: it used to be a functional ASSERT (if you haven't cleared the grid, there are grid items left in it so we will be wrong), now it's more a performance one (you would end up with duplicates in the grid but that shouldn't impact our layout algorithm). 834205 5 ojan 2013-02-15 11:25:33 -0800 (In reply to comment #4) > (From update of attachment 188463 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=188463&action=review > > > Assuming a world where we know that we never want to cache the grid representation, do you still think this is a step in the wrong direction? I don't think we should write the code around a performance optimization that may or may not apply in the future. Also, undoing this change is a tiny amount of work. > > That's assuming my objection was only based on performance: adding an extra argument to 5 functions is a cognitive load and I have been complaining about having lots of arguments already. By this logic we could use a static instead of a member variable, no? > Also if you wanted it on the stack, you should have requested it when reviewing the patch for the representation yesterday. It feels weird to undo that the next day. This problem only occurred to me when I went to implement computeIntrinsicLogicalWidths and couldn't because of the const issue. > >>> Source/WebCore/rendering/RenderGrid.cpp:471 > >>> + ASSERT(grid.isEmpty()); > >> > >> This ASSERT becomes pretty useless. It was to catch people not calling clear() on the grid at the end of layout / computePreferredLogicalWidths. > > > > Yeah. I thought about it and decided it could be valuable to assert that someone isn't calling placeItemsOnGrid multiple times on the same grid. That's obviously not gonna happen in the current code, but I could imagine it in the future. > > As I tell people, I can't read your mind, neither your ChangeLog nor a comment explains why this was kept so how am I to know? > > This ASSERT would need a comment as you are changing the meaning of it: it used to be a functional ASSERT (if you haven't cleared the grid, there are grid items left in it so we will be wrong), now it's more a performance one (you would end up with duplicates in the grid but that shouldn't impact our layout algorithm). I'm fine removing the assert. 834269 6 ojan 2013-02-15 12:27:22 -0800 Hmm...a static doesn't work if you have a nested grid. I'll just make it mutable. 188463 2013-02-14 18:33:29 -0800 2013-02-15 10:37:44 -0800 Patch bug-109880-20130214182957.patch text/plain 16243 ojan U3VidmVyc2lvbiBSZXZpc2lvbjogMTQyOTE4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNzM5NmE3NGU3NGI3NTkx ZmUwNTVjN2RlMzM2ZmI2ODA2YzVkMGFlMy4uYzEyMjkyYTQwYjFkNTJiYTdhODQ5ZGQ1Zjc0ZGM3 MmZlYjEyODU3NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDMwIEBACisyMDEzLTAyLTE0ICBPamFu IFZhZmFpICA8b2phbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgU3RhY2sgYWxsb2NhdGVkIHRo ZSBncmlkIGRhdGEgaW4gUmVuZGVyR3JpZAorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTA5ODgwCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgVGhpcyBpcyBpbiBwcmVwYXJhdGlvbiBmb3IgbW92aW5nIHRoZSBi b2R5IG9mIGNvbXB1dGVQcmVmZXJyZWRMb2dpY2FsV2lkdGhzCisgICAgICAgIGludG8gY29tcHV0 ZUludHJpbnNpY0xvZ2ljYWxXaWR0aHMsIHdoaWNoIGlzIGNvbnN0IGFuZCB0aHVzIGNhbid0IGJl IG1vZGlmeWluZworICAgICAgICBhIG1lbWJlciB2YXJpYWJsZS4KKworICAgICAgICBUaGlzIG1l YW5zIHRoYXQgd2UgbmVlZCB0byBwYXNzIHRoZSBncmlkIGFzIGFuIGFyZ3VtZW50IGFueXdoZXJl IHdlIG5lZWQgdG8gdXNlIGl0LgorICAgICAgICBBcyBzdWNoLCBhZGRpbmcgYSBHcmlkRGF0YSB0 eXBlZGVmIHNlZW1lZCB3b3J0aCB0aGUgYWRkZWQgcmVhZGFiaWxpdHkgbm93LgorCisgICAgICAg ICogcmVuZGVyaW5nL1JlbmRlckdyaWQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyR3Jp ZDo6R3JpZEl0ZXJhdG9yOjpHcmlkSXRlcmF0b3IpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVy R3JpZDo6Y29tcHV0ZVByZWZlcnJlZExvZ2ljYWxXaWR0aHMpOgorICAgICAgICAoV2ViQ29yZTo6 UmVuZGVyR3JpZDo6Y29tcHV0ZVByZWZlcnJlZFRyYWNrV2lkdGgpOgorICAgICAgICAoV2ViQ29y ZTo6UmVuZGVyR3JpZDo6Y29tcHV0ZWRVc2VkQnJlYWR0aE9mR3JpZFRyYWNrcyk6CisgICAgICAg IChXZWJDb3JlOjpSZW5kZXJHcmlkOjpyZXNvbHZlQ29udGVudEJhc2VkVHJhY2tTaXppbmdGdW5j dGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyR3JpZDo6cmVzb2x2ZUNvbnRlbnRCYXNl ZFRyYWNrU2l6aW5nRnVuY3Rpb25zRm9ySXRlbXMpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVy R3JpZDo6cGxhY2VJdGVtc09uR3JpZCk6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJHcmlkOjps YXlvdXRHcmlkSXRlbXMpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJHcmlkLmg6CisgICAg ICAgIChXZWJDb3JlOjpSZW5kZXJHcmlkOjpjb2x1bW5Db3VudCk6CisgICAgICAgIChXZWJDb3Jl OjpSZW5kZXJHcmlkOjpyb3dDb3VudCk6CisKIDIwMTMtMDItMTQgIEplciBOb2JsZSAgPGplci5u b2JsZUBhcHBsZS5jb20+CiAKICAgICAgICAgRU1FOiByZXBsYWNlIE1lZGlhS2V5U2Vzc2lvbi5h ZGRLZXkoKSAtPiB1cGRhdGUoKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5n L1JlbmRlckdyaWQuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckdyaWQuY3Bw CmluZGV4IDEzZWZhZDk5OWYyNGU0NzJmMTI1MzYwY2Y2YzljYzI4NzIyYzE5ZTMuLjk5YjdlZjBk NWY3MGI4NjllZWU3NzZlMjk1MjI4ZWJiNWY1ZGI4N2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3JlbmRlcmluZy9SZW5kZXJHcmlkLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyR3JpZC5jcHAKQEAgLTcxLDcgKzcxLDcgQEAgY2xhc3MgUmVuZGVyR3JpZDo6R3Jp ZEl0ZXJhdG9yIHsKIHB1YmxpYzoKICAgICAvLyB8ZGlyZWN0aW9ufCBpcyB0aGUgZGlyZWN0aW9u IHRoYXQgaXMgZml4ZWQgdG8gfGZpeGVkVHJhY2tJbmRleHwgc28gZS5nCiAgICAgLy8gR3JpZEl0 ZXJhdG9yKG1fZ3JpZCwgRm9yQ29sdW1ucywgMSkgd2lsbCB3YWxrIG92ZXIgdGhlIHJvd3Mgb2Yg dGhlIDJuZCBjb2x1bW4uCi0gICAgR3JpZEl0ZXJhdG9yKGNvbnN0IFZlY3RvcjxWZWN0b3I8VmVj dG9yPFJlbmRlckJveCosIDE+ID4gPiYgZ3JpZCwgVHJhY2tTaXppbmdEaXJlY3Rpb24gZGlyZWN0 aW9uLCBzaXplX3QgZml4ZWRUcmFja0luZGV4KQorICAgIEdyaWRJdGVyYXRvcihjb25zdCBHcmlk RGF0YSYgZ3JpZCwgVHJhY2tTaXppbmdEaXJlY3Rpb24gZGlyZWN0aW9uLCBzaXplX3QgZml4ZWRU cmFja0luZGV4KQogICAgICAgICA6IG1fZ3JpZChncmlkKQogICAgICAgICAsIG1fZGlyZWN0aW9u KGRpcmVjdGlvbikKICAgICAgICAgLCBtX3Jvd0luZGV4KChkaXJlY3Rpb24gPT0gRm9yQ29sdW1u cykgPyAwIDogZml4ZWRUcmFja0luZGV4KQpAQCAtOTcsNyArOTcsNyBAQCBwdWJsaWM6CiAgICAg ICAgIHJldHVybiAwOwogICAgIH0KIHByaXZhdGU6Ci0gICAgY29uc3QgVmVjdG9yPFZlY3RvcjxW ZWN0b3I8UmVuZGVyQm94KiwgMT4gPiA+JiBtX2dyaWQ7CisgICAgY29uc3QgR3JpZERhdGEmIG1f Z3JpZDsKICAgICBUcmFja1NpemluZ0RpcmVjdGlvbiBtX2RpcmVjdGlvbjsKICAgICBzaXplX3Qg bV9yb3dJbmRleDsKICAgICBzaXplX3QgbV9jb2x1bW5JbmRleDsKQEAgLTE3Miw3ICsxNzIsOCBA QCB2b2lkIFJlbmRlckdyaWQ6OmNvbXB1dGVQcmVmZXJyZWRMb2dpY2FsV2lkdGhzKCkKIHsKICAg ICBBU1NFUlQocHJlZmVycmVkTG9naWNhbFdpZHRoc0RpcnR5KCkpOwogCi0gICAgcGxhY2VJdGVt c09uR3JpZCgpOworICAgIEdyaWREYXRhIGdyaWQ7CisgICAgcGxhY2VJdGVtc09uR3JpZChncmlk KTsKIAogICAgIG1fbWluUHJlZmVycmVkTG9naWNhbFdpZHRoID0gMDsKICAgICBtX21heFByZWZl cnJlZExvZ2ljYWxXaWR0aCA9IDA7CkBAIC0xODIsOCArMTgzLDggQEAgdm9pZCBSZW5kZXJHcmlk Ojpjb21wdXRlUHJlZmVycmVkTG9naWNhbFdpZHRocygpCiAgICAgY29uc3QgVmVjdG9yPEdyaWRU cmFja1NpemU+JiB0cmFja1N0eWxlcyA9IHN0eWxlKCktPmdyaWRDb2x1bW5zKCk7CiAKICAgICBm b3IgKHNpemVfdCBpID0gMDsgaSA8IHRyYWNrU3R5bGVzLnNpemUoKTsgKytpKSB7Ci0gICAgICAg IExheW91dFVuaXQgbWluVHJhY2tCcmVhZHRoID0gY29tcHV0ZVByZWZlcnJlZFRyYWNrV2lkdGgo dHJhY2tTdHlsZXNbaV0ubWluVHJhY2tCcmVhZHRoKCksIGkpOwotICAgICAgICBMYXlvdXRVbml0 IG1heFRyYWNrQnJlYWR0aCA9IGNvbXB1dGVQcmVmZXJyZWRUcmFja1dpZHRoKHRyYWNrU3R5bGVz W2ldLm1heFRyYWNrQnJlYWR0aCgpLCBpKTsKKyAgICAgICAgTGF5b3V0VW5pdCBtaW5UcmFja0Jy ZWFkdGggPSBjb21wdXRlUHJlZmVycmVkVHJhY2tXaWR0aChncmlkLCB0cmFja1N0eWxlc1tpXS5t aW5UcmFja0JyZWFkdGgoKSwgaSk7CisgICAgICAgIExheW91dFVuaXQgbWF4VHJhY2tCcmVhZHRo ID0gY29tcHV0ZVByZWZlcnJlZFRyYWNrV2lkdGgoZ3JpZCwgdHJhY2tTdHlsZXNbaV0ubWF4VHJh Y2tCcmVhZHRoKCksIGkpOwogICAgICAgICBtYXhUcmFja0JyZWFkdGggPSBzdGQ6Om1heChtYXhU cmFja0JyZWFkdGgsIG1pblRyYWNrQnJlYWR0aCk7CiAKICAgICAgICAgbV9taW5QcmVmZXJyZWRM b2dpY2FsV2lkdGggKz0gbWluVHJhY2tCcmVhZHRoOwpAQCAtMTk5LDEwICsyMDAsOSBAQCB2b2lk IFJlbmRlckdyaWQ6OmNvbXB1dGVQcmVmZXJyZWRMb2dpY2FsV2lkdGhzKCkKICAgICBtX21heFBy ZWZlcnJlZExvZ2ljYWxXaWR0aCArPSBib3JkZXJBbmRQYWRkaW5nSW5JbmxpbmVEaXJlY3Rpb247 CiAKICAgICBzZXRQcmVmZXJyZWRMb2dpY2FsV2lkdGhzRGlydHkoZmFsc2UpOwotICAgIG1fZ3Jp ZC5jbGVhcigpOwogfQogCi1MYXlvdXRVbml0IFJlbmRlckdyaWQ6OmNvbXB1dGVQcmVmZXJyZWRU cmFja1dpZHRoKGNvbnN0IExlbmd0aCYgbGVuZ3RoLCBzaXplX3QgdHJhY2tJbmRleCkgY29uc3QK K0xheW91dFVuaXQgUmVuZGVyR3JpZDo6Y29tcHV0ZVByZWZlcnJlZFRyYWNrV2lkdGgoY29uc3Qg R3JpZERhdGEmIGdyaWQsIGNvbnN0IExlbmd0aCYgbGVuZ3RoLCBzaXplX3QgdHJhY2tJbmRleCkg Y29uc3QKIHsKICAgICBpZiAobGVuZ3RoLmlzRml4ZWQoKSkgewogICAgICAgICAvLyBHcmlkIGFy ZWFzIGRvbid0IGhhdmUgYm9yZGVycywgbWFyZ2lucyBvciBwYWRkaW5ncyBzbyB3ZSBkb24ndCBu ZWVkIHRvIGFjY291bnQgZm9yIHRoZW0uCkBAIC0yMTEsNyArMjExLDcgQEAgTGF5b3V0VW5pdCBS ZW5kZXJHcmlkOjpjb21wdXRlUHJlZmVycmVkVHJhY2tXaWR0aChjb25zdCBMZW5ndGgmIGxlbmd0 aCwgc2l6ZV90IHQKIAogICAgIGlmIChsZW5ndGguaXNNaW5Db250ZW50KCkpIHsKICAgICAgICAg TGF5b3V0VW5pdCBtaW5Db250ZW50U2l6ZSA9IDA7Ci0gICAgICAgIEdyaWRJdGVyYXRvciBpdGVy YXRvcihtX2dyaWQsIEZvckNvbHVtbnMsIHRyYWNrSW5kZXgpOworICAgICAgICBHcmlkSXRlcmF0 b3IgaXRlcmF0b3IoZ3JpZCwgRm9yQ29sdW1ucywgdHJhY2tJbmRleCk7CiAgICAgICAgIHdoaWxl IChSZW5kZXJCb3gqIGdyaWRJdGVtID0gaXRlcmF0b3IubmV4dEdyaWRJdGVtKCkpIHsKICAgICAg ICAgICAgIC8vIEZJWE1FOiBXZSBzaG91bGQgaW5jbHVkZSB0aGUgY2hpbGQncyBmaXhlZCBtYXJn aW5zIGxpa2UgUmVuZGVyRmxleGlibGVCb3guCiAgICAgICAgICAgICBtaW5Db250ZW50U2l6ZSA9 IHN0ZDo6bWF4KG1pbkNvbnRlbnRTaXplLCBncmlkSXRlbS0+bWluUHJlZmVycmVkTG9naWNhbFdp ZHRoKCkpOwpAQCAtMjIxLDcgKzIyMSw3IEBAIExheW91dFVuaXQgUmVuZGVyR3JpZDo6Y29tcHV0 ZVByZWZlcnJlZFRyYWNrV2lkdGgoY29uc3QgTGVuZ3RoJiBsZW5ndGgsIHNpemVfdCB0CiAKICAg ICBpZiAobGVuZ3RoLmlzTWF4Q29udGVudCgpKSB7CiAgICAgICAgIExheW91dFVuaXQgbWF4Q29u dGVudFNpemUgPSAwOwotICAgICAgICBHcmlkSXRlcmF0b3IgaXRlcmF0b3IobV9ncmlkLCBGb3JD b2x1bW5zLCB0cmFja0luZGV4KTsKKyAgICAgICAgR3JpZEl0ZXJhdG9yIGl0ZXJhdG9yKGdyaWQs IEZvckNvbHVtbnMsIHRyYWNrSW5kZXgpOwogICAgICAgICB3aGlsZSAoUmVuZGVyQm94KiBncmlk SXRlbSA9IGl0ZXJhdG9yLm5leHRHcmlkSXRlbSgpKSB7CiAgICAgICAgICAgICAvLyBGSVhNRTog V2Ugc2hvdWxkIGluY2x1ZGUgdGhlIGNoaWxkJ3MgZml4ZWQgbWFyZ2lucyBsaWtlIFJlbmRlckZs ZXhpYmxlQm94LgogICAgICAgICAgICAgbWF4Q29udGVudFNpemUgPSBzdGQ6Om1heChtYXhDb250 ZW50U2l6ZSwgZ3JpZEl0ZW0tPm1heFByZWZlcnJlZExvZ2ljYWxXaWR0aCgpKTsKQEAgLTIzNCw3 ICsyMzQsNyBAQCBMYXlvdXRVbml0IFJlbmRlckdyaWQ6OmNvbXB1dGVQcmVmZXJyZWRUcmFja1dp ZHRoKGNvbnN0IExlbmd0aCYgbGVuZ3RoLCBzaXplX3QgdAogICAgIHJldHVybiAwOwogfQogCi12 b2lkIFJlbmRlckdyaWQ6OmNvbXB1dGVkVXNlZEJyZWFkdGhPZkdyaWRUcmFja3MoVHJhY2tTaXpp bmdEaXJlY3Rpb24gZGlyZWN0aW9uLCBWZWN0b3I8R3JpZFRyYWNrPiYgY29sdW1uVHJhY2tzLCBW ZWN0b3I8R3JpZFRyYWNrPiYgcm93VHJhY2tzKQordm9pZCBSZW5kZXJHcmlkOjpjb21wdXRlZFVz ZWRCcmVhZHRoT2ZHcmlkVHJhY2tzKGNvbnN0IEdyaWREYXRhJiBncmlkLCBUcmFja1NpemluZ0Rp cmVjdGlvbiBkaXJlY3Rpb24sIFZlY3RvcjxHcmlkVHJhY2s+JiBjb2x1bW5UcmFja3MsIFZlY3Rv cjxHcmlkVHJhY2s+JiByb3dUcmFja3MpCiB7CiAgICAgY29uc3QgVmVjdG9yPEdyaWRUcmFja1Np emU+JiB0cmFja1N0eWxlcyA9IChkaXJlY3Rpb24gPT0gRm9yQ29sdW1ucykgPyBzdHlsZSgpLT5n cmlkQ29sdW1ucygpIDogc3R5bGUoKS0+Z3JpZFJvd3MoKTsKICAgICBMYXlvdXRVbml0IGF2YWls YWJsZUxvZ2ljYWxTcGFjZSA9IChkaXJlY3Rpb24gPT0gRm9yQ29sdW1ucykgPyBhdmFpbGFibGVM b2dpY2FsV2lkdGgoKSA6IGF2YWlsYWJsZUxvZ2ljYWxIZWlnaHQoSW5jbHVkZU1hcmdpbkJvcmRl clBhZGRpbmcpOwpAQCAtMjUzLDcgKzI1Myw3IEBAIHZvaWQgUmVuZGVyR3JpZDo6Y29tcHV0ZWRV c2VkQnJlYWR0aE9mR3JpZFRyYWNrcyhUcmFja1NpemluZ0RpcmVjdGlvbiBkaXJlY3Rpb24sCiAg ICAgfQogCiAgICAgLy8gRklYTUU6IFdlIHNob3VsZG4ndCBjYWxsIHJlc29sdmVDb250ZW50QmFz ZWRUcmFja1NpemluZ0Z1bmN0aW9ucyBpZiB3ZSBoYXZlIG5vIG1pbi1jb250ZW50IC8gbWF4LWNv bnRlbnQgdHJhY2tzLgotICAgIHJlc29sdmVDb250ZW50QmFzZWRUcmFja1NpemluZ0Z1bmN0aW9u cyhkaXJlY3Rpb24sIGNvbHVtblRyYWNrcywgcm93VHJhY2tzLCBhdmFpbGFibGVMb2dpY2FsU3Bh Y2UpOworICAgIHJlc29sdmVDb250ZW50QmFzZWRUcmFja1NpemluZ0Z1bmN0aW9ucyhncmlkLCBk aXJlY3Rpb24sIGNvbHVtblRyYWNrcywgcm93VHJhY2tzLCBhdmFpbGFibGVMb2dpY2FsU3BhY2Up OwogCiAgICAgaWYgKGF2YWlsYWJsZUxvZ2ljYWxTcGFjZSA8PSAwKQogICAgICAgICByZXR1cm47 CkBAIC0zNjgsNyArMzY4LDcgQEAgTGF5b3V0VW5pdCBSZW5kZXJHcmlkOjptYXhDb250ZW50Rm9y Q2hpbGQoUmVuZGVyQm94KiBjaGlsZCwgVHJhY2tTaXppbmdEaXJlY3Rpb24KICAgICByZXR1cm4g bG9naWNhbENvbnRlbnRIZWlnaHRGb3JDaGlsZChjaGlsZCwgY29sdW1uVHJhY2tzKTsKIH0KIAot dm9pZCBSZW5kZXJHcmlkOjpyZXNvbHZlQ29udGVudEJhc2VkVHJhY2tTaXppbmdGdW5jdGlvbnMo VHJhY2tTaXppbmdEaXJlY3Rpb24gZGlyZWN0aW9uLCBWZWN0b3I8R3JpZFRyYWNrPiYgY29sdW1u VHJhY2tzLCBWZWN0b3I8R3JpZFRyYWNrPiYgcm93VHJhY2tzLCBMYXlvdXRVbml0JiBhdmFpbGFi bGVMb2dpY2FsU3BhY2UpCit2b2lkIFJlbmRlckdyaWQ6OnJlc29sdmVDb250ZW50QmFzZWRUcmFj a1NpemluZ0Z1bmN0aW9ucyhjb25zdCBHcmlkRGF0YSYgZ3JpZCwgVHJhY2tTaXppbmdEaXJlY3Rp b24gZGlyZWN0aW9uLCBWZWN0b3I8R3JpZFRyYWNrPiYgY29sdW1uVHJhY2tzLCBWZWN0b3I8R3Jp ZFRyYWNrPiYgcm93VHJhY2tzLCBMYXlvdXRVbml0JiBhdmFpbGFibGVMb2dpY2FsU3BhY2UpCiB7 CiAgICAgLy8gRklYTUU6IFNwbGl0IHRoZSBncmlkIHRyYWNrcyBvbmNlIHdlIHN1cHBvcnQgc3Bh bm5pbmcgb3IgZnJhY3Rpb25zIChzdGVwIDEgYW5kIDIgb2YgdGhlIGFsZ29yaXRobSkuCiAKQEAg LTM4MCwzMiArMzgwLDMyIEBAIHZvaWQgUmVuZGVyR3JpZDo6cmVzb2x2ZUNvbnRlbnRCYXNlZFRy YWNrU2l6aW5nRnVuY3Rpb25zKFRyYWNrU2l6aW5nRGlyZWN0aW9uIGRpCiAgICAgICAgIGNvbnN0 IExlbmd0aCYgbWluVHJhY2tCcmVhZHRoID0gdHJhY2tTaXplLm1pblRyYWNrQnJlYWR0aCgpOwog ICAgICAgICBpZiAobWluVHJhY2tCcmVhZHRoLmlzTWluQ29udGVudCgpIHx8IG1pblRyYWNrQnJl YWR0aC5pc01heENvbnRlbnQoKSkgewogICAgICAgICAgICAgTGF5b3V0VW5pdCBvbGRVc2VkQnJl YWR0aCA9IHRyYWNrLm1fdXNlZEJyZWFkdGg7Ci0gICAgICAgICAgICByZXNvbHZlQ29udGVudEJh c2VkVHJhY2tTaXppbmdGdW5jdGlvbnNGb3JJdGVtcyhkaXJlY3Rpb24sIGNvbHVtblRyYWNrcywg cm93VHJhY2tzLCBpLCAmUmVuZGVyR3JpZDo6bWluQ29udGVudEZvckNoaWxkLCAmR3JpZFRyYWNr Ojp1c2VkQnJlYWR0aCwgJkdyaWRUcmFjazo6Z3Jvd1VzZWRCcmVhZHRoKTsKKyAgICAgICAgICAg IHJlc29sdmVDb250ZW50QmFzZWRUcmFja1NpemluZ0Z1bmN0aW9uc0Zvckl0ZW1zKGdyaWQsIGRp cmVjdGlvbiwgY29sdW1uVHJhY2tzLCByb3dUcmFja3MsIGksICZSZW5kZXJHcmlkOjptaW5Db250 ZW50Rm9yQ2hpbGQsICZHcmlkVHJhY2s6OnVzZWRCcmVhZHRoLCAmR3JpZFRyYWNrOjpncm93VXNl ZEJyZWFkdGgpOwogICAgICAgICAgICAgYXZhaWxhYmxlTG9naWNhbFNwYWNlIC09ICh0cmFjay5t X3VzZWRCcmVhZHRoIC0gb2xkVXNlZEJyZWFkdGgpOwogICAgICAgICB9CiAKICAgICAgICAgaWYg KG1pblRyYWNrQnJlYWR0aC5pc01heENvbnRlbnQoKSkgewogICAgICAgICAgICAgTGF5b3V0VW5p dCBvbGRVc2VkQnJlYWR0aCA9IHRyYWNrLm1fdXNlZEJyZWFkdGg7Ci0gICAgICAgICAgICByZXNv bHZlQ29udGVudEJhc2VkVHJhY2tTaXppbmdGdW5jdGlvbnNGb3JJdGVtcyhkaXJlY3Rpb24sIGNv bHVtblRyYWNrcywgcm93VHJhY2tzLCBpLCAmUmVuZGVyR3JpZDo6bWF4Q29udGVudEZvckNoaWxk LCAmR3JpZFRyYWNrOjp1c2VkQnJlYWR0aCwgJkdyaWRUcmFjazo6Z3Jvd1VzZWRCcmVhZHRoKTsK KyAgICAgICAgICAgIHJlc29sdmVDb250ZW50QmFzZWRUcmFja1NpemluZ0Z1bmN0aW9uc0Zvckl0 ZW1zKGdyaWQsIGRpcmVjdGlvbiwgY29sdW1uVHJhY2tzLCByb3dUcmFja3MsIGksICZSZW5kZXJH cmlkOjptYXhDb250ZW50Rm9yQ2hpbGQsICZHcmlkVHJhY2s6OnVzZWRCcmVhZHRoLCAmR3JpZFRy YWNrOjpncm93VXNlZEJyZWFkdGgpOwogICAgICAgICAgICAgYXZhaWxhYmxlTG9naWNhbFNwYWNl IC09ICh0cmFjay5tX3VzZWRCcmVhZHRoIC0gb2xkVXNlZEJyZWFkdGgpOwogICAgICAgICB9CiAK ICAgICAgICAgY29uc3QgTGVuZ3RoJiBtYXhUcmFja0JyZWFkdGggPSB0cmFja1NpemUubWF4VHJh Y2tCcmVhZHRoKCk7CiAgICAgICAgIGlmIChtYXhUcmFja0JyZWFkdGguaXNNaW5Db250ZW50KCkg fHwgbWF4VHJhY2tCcmVhZHRoLmlzTWF4Q29udGVudCgpKQotICAgICAgICAgICAgcmVzb2x2ZUNv bnRlbnRCYXNlZFRyYWNrU2l6aW5nRnVuY3Rpb25zRm9ySXRlbXMoZGlyZWN0aW9uLCBjb2x1bW5U cmFja3MsIHJvd1RyYWNrcywgaSwgJlJlbmRlckdyaWQ6Om1pbkNvbnRlbnRGb3JDaGlsZCwgJkdy aWRUcmFjazo6bWF4QnJlYWR0aElmTm90SW5maW5pdGUsICZHcmlkVHJhY2s6Omdyb3dNYXhCcmVh ZHRoKTsKKyAgICAgICAgICAgIHJlc29sdmVDb250ZW50QmFzZWRUcmFja1NpemluZ0Z1bmN0aW9u c0Zvckl0ZW1zKGdyaWQsIGRpcmVjdGlvbiwgY29sdW1uVHJhY2tzLCByb3dUcmFja3MsIGksICZS ZW5kZXJHcmlkOjptaW5Db250ZW50Rm9yQ2hpbGQsICZHcmlkVHJhY2s6Om1heEJyZWFkdGhJZk5v dEluZmluaXRlLCAmR3JpZFRyYWNrOjpncm93TWF4QnJlYWR0aCk7CiAKICAgICAgICAgaWYgKG1h eFRyYWNrQnJlYWR0aC5pc01heENvbnRlbnQoKSkKLSAgICAgICAgICAgIHJlc29sdmVDb250ZW50 QmFzZWRUcmFja1NpemluZ0Z1bmN0aW9uc0Zvckl0ZW1zKGRpcmVjdGlvbiwgY29sdW1uVHJhY2tz LCByb3dUcmFja3MsIGksICZSZW5kZXJHcmlkOjptYXhDb250ZW50Rm9yQ2hpbGQsICZHcmlkVHJh Y2s6Om1heEJyZWFkdGhJZk5vdEluZmluaXRlLCAmR3JpZFRyYWNrOjpncm93TWF4QnJlYWR0aCk7 CisgICAgICAgICAgICByZXNvbHZlQ29udGVudEJhc2VkVHJhY2tTaXppbmdGdW5jdGlvbnNGb3JJ dGVtcyhncmlkLCBkaXJlY3Rpb24sIGNvbHVtblRyYWNrcywgcm93VHJhY2tzLCBpLCAmUmVuZGVy R3JpZDo6bWF4Q29udGVudEZvckNoaWxkLCAmR3JpZFRyYWNrOjptYXhCcmVhZHRoSWZOb3RJbmZp bml0ZSwgJkdyaWRUcmFjazo6Z3Jvd01heEJyZWFkdGgpOwogCiAgICAgICAgIGlmICh0cmFjay5t X21heEJyZWFkdGggPT0gaW5maW5pdHkpCiAgICAgICAgICAgICB0cmFjay5tX21heEJyZWFkdGgg PSB0cmFjay5tX3VzZWRCcmVhZHRoOwogICAgIH0KIH0KIAotdm9pZCBSZW5kZXJHcmlkOjpyZXNv bHZlQ29udGVudEJhc2VkVHJhY2tTaXppbmdGdW5jdGlvbnNGb3JJdGVtcyhUcmFja1NpemluZ0Rp cmVjdGlvbiBkaXJlY3Rpb24sIFZlY3RvcjxHcmlkVHJhY2s+JiBjb2x1bW5UcmFja3MsIFZlY3Rv cjxHcmlkVHJhY2s+JiByb3dUcmFja3MsIHNpemVfdCB0cmFja0luZGV4LCBTaXppbmdGdW5jdGlv biBzaXppbmdGdW5jdGlvbiwgQWNjdW11bGF0b3JHZXR0ZXIgdHJhY2tHZXR0ZXIsIEFjY3VtdWxh dG9yR3Jvd0Z1bmN0aW9uIHRyYWNrR3Jvd3RoRnVuY3Rpb24pCit2b2lkIFJlbmRlckdyaWQ6OnJl c29sdmVDb250ZW50QmFzZWRUcmFja1NpemluZ0Z1bmN0aW9uc0Zvckl0ZW1zKGNvbnN0IEdyaWRE YXRhJiBncmlkLCBUcmFja1NpemluZ0RpcmVjdGlvbiBkaXJlY3Rpb24sIFZlY3RvcjxHcmlkVHJh Y2s+JiBjb2x1bW5UcmFja3MsIFZlY3RvcjxHcmlkVHJhY2s+JiByb3dUcmFja3MsIHNpemVfdCB0 cmFja0luZGV4LCBTaXppbmdGdW5jdGlvbiBzaXppbmdGdW5jdGlvbiwgQWNjdW11bGF0b3JHZXR0 ZXIgdHJhY2tHZXR0ZXIsIEFjY3VtdWxhdG9yR3Jvd0Z1bmN0aW9uIHRyYWNrR3Jvd3RoRnVuY3Rp b24pCiB7CiAgICAgR3JpZFRyYWNrJiB0cmFjayA9IChkaXJlY3Rpb24gPT0gRm9yQ29sdW1ucykg PyBjb2x1bW5UcmFja3NbdHJhY2tJbmRleF0gOiByb3dUcmFja3NbdHJhY2tJbmRleF07Ci0gICAg R3JpZEl0ZXJhdG9yIGl0ZXJhdG9yKG1fZ3JpZCwgZGlyZWN0aW9uLCB0cmFja0luZGV4KTsKKyAg ICBHcmlkSXRlcmF0b3IgaXRlcmF0b3IoZ3JpZCwgZGlyZWN0aW9uLCB0cmFja0luZGV4KTsKICAg ICB3aGlsZSAoUmVuZGVyQm94KiBncmlkSXRlbSA9IGl0ZXJhdG9yLm5leHRHcmlkSXRlbSgpKSB7 CiAgICAgICAgIExheW91dFVuaXQgY29udGVudFNpemUgPSAodGhpcy0+KnNpemluZ0Z1bmN0aW9u KShncmlkSXRlbSwgZGlyZWN0aW9uLCBjb2x1bW5UcmFja3MpOwogICAgICAgICBMYXlvdXRVbml0 IGFkZGl0aW9uYWxCcmVhZHRoU3BhY2UgPSBjb250ZW50U2l6ZSAtICh0cmFjay4qdHJhY2tHZXR0 ZXIpKCk7CkBAIC00NjYsMzEgKzQ2NiwzMiBAQCBib29sIFJlbmRlckdyaWQ6OnRyYWNrc0FyZVdp ZGVyVGhhbk1pblRyYWNrQnJlYWR0aChUcmFja1NpemluZ0RpcmVjdGlvbiBkaXJlY3RpbwogfQog I2VuZGlmCiAKLXZvaWQgUmVuZGVyR3JpZDo6cGxhY2VJdGVtc09uR3JpZCgpCit2b2lkIFJlbmRl ckdyaWQ6OnBsYWNlSXRlbXNPbkdyaWQoR3JpZERhdGEmIGdyaWQpCiB7Ci0gICAgQVNTRVJUKG1f Z3JpZC5pc0VtcHR5KCkpOwotICAgIG1fZ3JpZC5ncm93KG1heGltdW1JbmRleEluRGlyZWN0aW9u KEZvclJvd3MpKTsKKyAgICBBU1NFUlQoZ3JpZC5pc0VtcHR5KCkpOworICAgIGdyaWQuZ3Jvdyht YXhpbXVtSW5kZXhJbkRpcmVjdGlvbihGb3JSb3dzKSk7CiAgICAgc2l6ZV90IG1heGltdW1Db2x1 bW5JbmRleCA9IG1heGltdW1JbmRleEluRGlyZWN0aW9uKEZvckNvbHVtbnMpOwotICAgIGZvciAo c2l6ZV90IGkgPSAwOyBpIDwgZ3JpZFJvd0NvdW50KCk7ICsraSkKLSAgICAgICAgbV9ncmlkW2ld Lmdyb3cobWF4aW11bUNvbHVtbkluZGV4KTsKKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IHJv d0NvdW50KGdyaWQpOyArK2kpCisgICAgICAgIGdyaWRbaV0uZ3JvdyhtYXhpbXVtQ29sdW1uSW5k ZXgpOwogCiAgICAgZm9yIChSZW5kZXJCb3gqIGNoaWxkID0gZmlyc3RDaGlsZEJveCgpOyBjaGls ZDsgY2hpbGQgPSBjaGlsZC0+bmV4dFNpYmxpbmdCb3goKSkgewogICAgICAgICBzaXplX3QgY29s dW1uVHJhY2sgPSByZXNvbHZlR3JpZFBvc2l0aW9uKGNoaWxkLT5zdHlsZSgpLT5ncmlkSXRlbUNv bHVtbigpKTsKICAgICAgICAgc2l6ZV90IHJvd1RyYWNrID0gcmVzb2x2ZUdyaWRQb3NpdGlvbihj aGlsZC0+c3R5bGUoKS0+Z3JpZEl0ZW1Sb3coKSk7CiAKLSAgICAgICAgbV9ncmlkW3Jvd1RyYWNr XVtjb2x1bW5UcmFja10uYXBwZW5kKGNoaWxkKTsKKyAgICAgICAgZ3JpZFtyb3dUcmFja11bY29s dW1uVHJhY2tdLmFwcGVuZChjaGlsZCk7CiAgICAgfQogfQogCiB2b2lkIFJlbmRlckdyaWQ6Omxh eW91dEdyaWRJdGVtcygpCiB7Ci0gICAgcGxhY2VJdGVtc09uR3JpZCgpOworICAgIEdyaWREYXRh IGdyaWQ7CisgICAgcGxhY2VJdGVtc09uR3JpZChncmlkKTsKIAotICAgIFZlY3RvcjxHcmlkVHJh Y2s+IGNvbHVtblRyYWNrcyhncmlkQ29sdW1uQ291bnQoKSk7Ci0gICAgVmVjdG9yPEdyaWRUcmFj az4gcm93VHJhY2tzKGdyaWRSb3dDb3VudCgpKTsKLSAgICBjb21wdXRlZFVzZWRCcmVhZHRoT2ZH cmlkVHJhY2tzKEZvckNvbHVtbnMsIGNvbHVtblRyYWNrcywgcm93VHJhY2tzKTsKKyAgICBWZWN0 b3I8R3JpZFRyYWNrPiBjb2x1bW5UcmFja3MoY29sdW1uQ291bnQoZ3JpZCkpOworICAgIFZlY3Rv cjxHcmlkVHJhY2s+IHJvd1RyYWNrcyhyb3dDb3VudChncmlkKSk7CisgICAgY29tcHV0ZWRVc2Vk QnJlYWR0aE9mR3JpZFRyYWNrcyhncmlkLCBGb3JDb2x1bW5zLCBjb2x1bW5UcmFja3MsIHJvd1Ry YWNrcyk7CiAgICAgQVNTRVJUKHRyYWNrc0FyZVdpZGVyVGhhbk1pblRyYWNrQnJlYWR0aChGb3JD b2x1bW5zLCBjb2x1bW5UcmFja3MpKTsKLSAgICBjb21wdXRlZFVzZWRCcmVhZHRoT2ZHcmlkVHJh Y2tzKEZvclJvd3MsIGNvbHVtblRyYWNrcywgcm93VHJhY2tzKTsKKyAgICBjb21wdXRlZFVzZWRC cmVhZHRoT2ZHcmlkVHJhY2tzKGdyaWQsIEZvclJvd3MsIGNvbHVtblRyYWNrcywgcm93VHJhY2tz KTsKICAgICBBU1NFUlQodHJhY2tzQXJlV2lkZXJUaGFuTWluVHJhY2tCcmVhZHRoKEZvclJvd3Ms IHJvd1RyYWNrcykpOwogCiAgICAgZm9yIChSZW5kZXJCb3gqIGNoaWxkID0gZmlyc3RDaGlsZEJv eCgpOyBjaGlsZDsgY2hpbGQgPSBjaGlsZC0+bmV4dFNpYmxpbmdCb3goKSkgewpAQCAtNTI3LDcg KzUyOCw2IEBAIHZvaWQgUmVuZGVyR3JpZDo6bGF5b3V0R3JpZEl0ZW1zKCkKICAgICAvLyBGSVhN RTogV2Ugc2hvdWxkIGhhbmRsZSBtaW4gLyBtYXggbG9naWNhbCBoZWlnaHQuCiAKICAgICBzZXRM b2dpY2FsSGVpZ2h0KGxvZ2ljYWxIZWlnaHQoKSArIGJvcmRlckFuZFBhZGRpbmdMb2dpY2FsSGVp Z2h0KCkpOwotICAgIG1fZ3JpZC5jbGVhcigpOwogfQogCiBzaXplX3QgUmVuZGVyR3JpZDo6cmVz b2x2ZUdyaWRQb3NpdGlvbihUcmFja1NpemluZ0RpcmVjdGlvbiBkaXJlY3Rpb24sIGNvbnN0IFJl bmRlck9iamVjdCogZ3JpZEl0ZW0pIGNvbnN0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9y ZW5kZXJpbmcvUmVuZGVyR3JpZC5oIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlckdy aWQuaAppbmRleCBkM2M2YmIxOTBhY2VmZGI4MzUwZDUyMDUyODkxY2JjN2NiNzI2YTg3Li40NDg2 MWU0M2RkYTA4ZWQ1MmY3MzJiNmUzMmFkZmQyNjdlOGMzN2EwIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyR3JpZC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRl cmluZy9SZW5kZXJHcmlkLmgKQEAgLTQ4LDIyICs0OCwyMyBAQCBwcml2YXRlOgogICAgIHZpcnR1 YWwgYm9vbCBpc1JlbmRlckdyaWQoKSBjb25zdCBPVkVSUklERSB7IHJldHVybiB0cnVlOyB9CiAg ICAgdmlydHVhbCB2b2lkIGNvbXB1dGVQcmVmZXJyZWRMb2dpY2FsV2lkdGhzKCkgT1ZFUlJJREU7 CiAKLSAgICBMYXlvdXRVbml0IGNvbXB1dGVQcmVmZXJyZWRUcmFja1dpZHRoKGNvbnN0IExlbmd0 aCYsIHNpemVfdCkgY29uc3Q7Ci0KICAgICBjbGFzcyBHcmlkSXRlcmF0b3I7CiAgICAgZW51bSBU cmFja1NpemluZ0RpcmVjdGlvbiB7IEZvckNvbHVtbnMsIEZvclJvd3MgfTsKLSAgICB2b2lkIGNv bXB1dGVkVXNlZEJyZWFkdGhPZkdyaWRUcmFja3MoVHJhY2tTaXppbmdEaXJlY3Rpb24sIFZlY3Rv cjxHcmlkVHJhY2s+JiBjb2x1bW5UcmFja3MsIFZlY3RvcjxHcmlkVHJhY2s+JiByb3dUcmFja3Mp OworICAgIHR5cGVkZWYgVmVjdG9yPFZlY3RvcjxWZWN0b3I8UmVuZGVyQm94KiwgMT4gPiA+IEdy aWREYXRhOworCisgICAgTGF5b3V0VW5pdCBjb21wdXRlUHJlZmVycmVkVHJhY2tXaWR0aChjb25z dCBHcmlkRGF0YSYsIGNvbnN0IExlbmd0aCYsIHNpemVfdCkgY29uc3Q7CisgICAgdm9pZCBjb21w dXRlZFVzZWRCcmVhZHRoT2ZHcmlkVHJhY2tzKGNvbnN0IEdyaWREYXRhJiwgVHJhY2tTaXppbmdE aXJlY3Rpb24sIFZlY3RvcjxHcmlkVHJhY2s+JiBjb2x1bW5UcmFja3MsIFZlY3RvcjxHcmlkVHJh Y2s+JiByb3dUcmFja3MpOwogICAgIExheW91dFVuaXQgY29tcHV0ZVVzZWRCcmVhZHRoT2ZNaW5M ZW5ndGgoVHJhY2tTaXppbmdEaXJlY3Rpb24sIGNvbnN0IExlbmd0aCYpIGNvbnN0OwogICAgIExh eW91dFVuaXQgY29tcHV0ZVVzZWRCcmVhZHRoT2ZNYXhMZW5ndGgoVHJhY2tTaXppbmdEaXJlY3Rp b24sIGNvbnN0IExlbmd0aCYpIGNvbnN0OwogICAgIExheW91dFVuaXQgY29tcHV0ZVVzZWRCcmVh ZHRoT2ZTcGVjaWZpZWRMZW5ndGgoVHJhY2tTaXppbmdEaXJlY3Rpb24sIGNvbnN0IExlbmd0aCYp IGNvbnN0OwotICAgIHZvaWQgcmVzb2x2ZUNvbnRlbnRCYXNlZFRyYWNrU2l6aW5nRnVuY3Rpb25z KFRyYWNrU2l6aW5nRGlyZWN0aW9uLCBWZWN0b3I8R3JpZFRyYWNrPiYgY29sdW1uVHJhY2tzLCBW ZWN0b3I8R3JpZFRyYWNrPiYgcm93VHJhY2tzLCBMYXlvdXRVbml0JiBhdmFpbGFibGVMb2dpY2Fs U3BhY2UpOwotICAgIHZvaWQgcGxhY2VJdGVtc09uR3JpZCgpOworICAgIHZvaWQgcmVzb2x2ZUNv bnRlbnRCYXNlZFRyYWNrU2l6aW5nRnVuY3Rpb25zKGNvbnN0IEdyaWREYXRhJiwgVHJhY2tTaXpp bmdEaXJlY3Rpb24sIFZlY3RvcjxHcmlkVHJhY2s+JiBjb2x1bW5UcmFja3MsIFZlY3RvcjxHcmlk VHJhY2s+JiByb3dUcmFja3MsIExheW91dFVuaXQmIGF2YWlsYWJsZUxvZ2ljYWxTcGFjZSk7Cisg ICAgdm9pZCBwbGFjZUl0ZW1zT25HcmlkKEdyaWREYXRhJik7CiAgICAgdm9pZCBsYXlvdXRHcmlk SXRlbXMoKTsKIAogICAgIHR5cGVkZWYgTGF5b3V0VW5pdCAoUmVuZGVyR3JpZDo6KiBTaXppbmdG dW5jdGlvbikoUmVuZGVyQm94KiwgVHJhY2tTaXppbmdEaXJlY3Rpb24sIFZlY3RvcjxHcmlkVHJh Y2s+Jik7CiAgICAgdHlwZWRlZiBMYXlvdXRVbml0IChHcmlkVHJhY2s6OiogQWNjdW11bGF0b3JH ZXR0ZXIpKCkgY29uc3Q7CiAgICAgdHlwZWRlZiB2b2lkIChHcmlkVHJhY2s6OiogQWNjdW11bGF0 b3JHcm93RnVuY3Rpb24pKExheW91dFVuaXQpOwotICAgIHZvaWQgcmVzb2x2ZUNvbnRlbnRCYXNl ZFRyYWNrU2l6aW5nRnVuY3Rpb25zRm9ySXRlbXMoVHJhY2tTaXppbmdEaXJlY3Rpb24sIFZlY3Rv cjxHcmlkVHJhY2s+JiBjb2x1bW5UcmFja3MsIFZlY3RvcjxHcmlkVHJhY2s+JiByb3dUcmFja3Ms IHNpemVfdCwgU2l6aW5nRnVuY3Rpb24sIEFjY3VtdWxhdG9yR2V0dGVyLCBBY2N1bXVsYXRvckdy b3dGdW5jdGlvbik7CisgICAgdm9pZCByZXNvbHZlQ29udGVudEJhc2VkVHJhY2tTaXppbmdGdW5j dGlvbnNGb3JJdGVtcyhjb25zdCBHcmlkRGF0YSYsIFRyYWNrU2l6aW5nRGlyZWN0aW9uLCBWZWN0 b3I8R3JpZFRyYWNrPiYgY29sdW1uVHJhY2tzLCBWZWN0b3I8R3JpZFRyYWNrPiYgcm93VHJhY2tz LCBzaXplX3QsIFNpemluZ0Z1bmN0aW9uLCBBY2N1bXVsYXRvckdldHRlciwgQWNjdW11bGF0b3JH cm93RnVuY3Rpb24pOwogICAgIHZvaWQgZGlzdHJpYnV0ZVNwYWNlVG9UcmFja3MoVmVjdG9yPEdy aWRUcmFjayo+JiwgVmVjdG9yPEdyaWRUcmFjayo+KiB0cmFja3NGb3JHcm93dGhBYm92ZU1heEJy ZWFkdGgsIEFjY3VtdWxhdG9yR2V0dGVyLCBBY2N1bXVsYXRvckdyb3dGdW5jdGlvbiwgTGF5b3V0 VW5pdCYgYXZhaWxhYmxlTG9naWNhbFNwYWNlKTsKIAogICAgIGNvbnN0IEdyaWRUcmFja1NpemUm IGdyaWRUcmFja1NpemUoVHJhY2tTaXppbmdEaXJlY3Rpb24sIHNpemVfdCk7CkBAIC04MCwxMCAr ODEsOCBAQCBwcml2YXRlOgogICAgIGJvb2wgdHJhY2tzQXJlV2lkZXJUaGFuTWluVHJhY2tCcmVh ZHRoKFRyYWNrU2l6aW5nRGlyZWN0aW9uLCBjb25zdCBWZWN0b3I8R3JpZFRyYWNrPiYpOwogI2Vu ZGlmCiAKLSAgICBzaXplX3QgZ3JpZENvbHVtbkNvdW50KCkgY29uc3QgeyByZXR1cm4gbV9ncmlk LmlzRW1wdHkoKSA/IDAgOiBtX2dyaWRbMF0uc2l6ZSgpOyB9Ci0gICAgc2l6ZV90IGdyaWRSb3dD b3VudCgpIGNvbnN0IHsgcmV0dXJuIG1fZ3JpZC5zaXplKCk7IH0KLQotICAgIFZlY3RvcjxWZWN0 b3I8VmVjdG9yPFJlbmRlckJveCosIDE+ID4gPiBtX2dyaWQ7CisgICAgc2l6ZV90IGNvbHVtbkNv dW50KEdyaWREYXRhIGdyaWQpIGNvbnN0IHsgcmV0dXJuIGdyaWQuaXNFbXB0eSgpID8gMCA6IGdy aWRbMF0uc2l6ZSgpOyB9CisgICAgc2l6ZV90IHJvd0NvdW50KEdyaWREYXRhIGdyaWQpIGNvbnN0 IHsgcmV0dXJuIGdyaWQuc2l6ZSgpOyB9CiB9OwogCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCg==