266608 2023-12-18 15:52:48 -0800 AX: Move objectsForIds off of the main thread 2023-12-19 21:09:19 -0800 1 1 1 Unclassified WebKit Accessibility WebKit Nightly Build All All RESOLVED FIXED InRadar P2 Normal --- 1 jhoffman23 jhoffman23 aboxhall andresg_22 apinheiro cfleizach dmazzoni ews-watchlist jcraig samuel_white tyler_w webkit-bug-importer oldest_to_newest 2000567 0 jhoffman23 2023-12-18 15:52:48 -0800 We have to go to the main thread for AXIsolatedTree::objectsForIds when an object (typically a target/origin of a relation) is ignored. These objects should be cached to be served on the main thread. 2000568 1 webkit-bug-importer 2023-12-18 15:52:57 -0800 <rdar://problem/119837270> 2000569 2 jhoffman23 2023-12-18 15:53:08 -0800 rdar://116133586 2000591 3 469121 jhoffman23 2023-12-18 18:12:34 -0800 Created attachment 469121 Patch 2000598 4 469121 tyler_w 2023-12-18 18:29:07 -0800 Comment on attachment 469121 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=469121&action=review > Source/WebCore/accessibility/AXObjectCache.cpp:4622 > + auto* relationOrigin = getOrCreate(origin, IsPartOfRelation::Yes); > + auto* relationTarget = getOrCreate(target, IsPartOfRelation::Yes); These should be RefPtrs. getOrCreate calls accessibilityIsIgnored(), which can cause objects to be destroyed as a side effect. We also directly call accessibilityIsIgnored() below. > Source/WebCore/accessibility/AXObjectCache.cpp:4632 > +#if ENABLE(ACCESSIBILITY_ISOLATED_TREE) > + if (auto tree = AXIsolatedTree::treeForPageID(m_pageID)) { > + if (relationOrigin && relationOrigin->accessibilityIsIgnored()) > + tree->addUnconnectedNode(*relationOrigin); > + if (relationTarget && relationTarget->accessibilityIsIgnored()) > + tree->addUnconnectedNode(*relationTarget); > + } > +#endif Something I just realized about addUnconnectedNode: it doesn't check that the object exists before creating a brand new isolated object. That's not great, especially with the addition of this code, as it means we'll create a ton of duplicate copies of the same object over and over. You can imagine an ARIA component that aria-owns 100 children. I think we'd create the same object 100 times? > Source/WebCore/accessibility/AXObjectCache.cpp:4739 > +#if ENABLE(ACCESSIBILITY_ISOLATED_TREE) > + // If this element has no more relations, and it is ignored, remove it from > + // the isolated tree. > + fprintf(stderr, "REmoving relation for %s\n", object->dbg().utf8().data()); > + auto* relationTarget = objectForID(targetID); > + if (!relationTarget || !relationTarget->accessibilityIsIgnored()) > + continue; > + > + if (!hasNoRelations(targetID)) > + continue; > + > + if (auto tree = AXIsolatedTree::treeForPageID(m_pageID)) > + tree->removeNode(*relationTarget); > +#endif // ENABLE(ACCESSIBILITY_ISOLATED_TREE) I understand that you've added this to cleanup objects that only exist in the isolated tree because they were added for relations reasons. But I wonder if it's necessary? Unconnected nodes will be cleaned up like normal when they're removed from the DOM / render tree, so not sure it's worth it to do all this work to try to clean them up for an uncommon scenario (an object is ignored, and used to have relations, but then lost them for some reason other than being deleted from the DOM). What do you think? > Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.cpp:171 > + for (auto& relatedObjectID : axObjectCache.relations().keys()) { > + auto* axObject = axObjectCache.objectForID(relatedObjectID); > + if (axObject && axObject->accessibilityIsIgnored()) { > + if (!tree->objectForID(relatedObjectID)) > + tree->addUnconnectedNode(*axObject); > + } > + } Is this necessary when we proactively add unconnected nodes if necessary in AXObjectCache::addRelations? Seems like we would need one or the other? 2000605 5 jhoffman23 2023-12-18 19:12:04 -0800 (In reply to Tyler Wilcock from comment #4) > Comment on attachment 469121 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=469121&action=review > > > Source/WebCore/accessibility/AXObjectCache.cpp:4622 > > + auto* relationOrigin = getOrCreate(origin, IsPartOfRelation::Yes); > > + auto* relationTarget = getOrCreate(target, IsPartOfRelation::Yes); > > These should be RefPtrs. getOrCreate calls accessibilityIsIgnored(), which > can cause objects to be destroyed as a side effect. We also directly call > accessibilityIsIgnored() below. Good point—will update these. > > Source/WebCore/accessibility/AXObjectCache.cpp:4632 > > +#if ENABLE(ACCESSIBILITY_ISOLATED_TREE) > > + if (auto tree = AXIsolatedTree::treeForPageID(m_pageID)) { > > + if (relationOrigin && relationOrigin->accessibilityIsIgnored()) > > + tree->addUnconnectedNode(*relationOrigin); > > + if (relationTarget && relationTarget->accessibilityIsIgnored()) > > + tree->addUnconnectedNode(*relationTarget); > > + } > > +#endif > > Something I just realized about addUnconnectedNode: it doesn't check that > the object exists before creating a brand new isolated object. That's not > great, especially with the addition of this code, as it means we'll create a > ton of duplicate copies of the same object over and over. You can imagine an > ARIA component that aria-owns 100 children. I think we'd create the same > object 100 times? Ah yeah, that is true! I'm curious if we don't check that now for a reason? I can easily add a m_readerThreadNodeMap.contains(id) inside addUnconnectedNode. > > Source/WebCore/accessibility/AXObjectCache.cpp:4739 > > +#if ENABLE(ACCESSIBILITY_ISOLATED_TREE) > > + // If this element has no more relations, and it is ignored, remove it from > > + // the isolated tree. > > + fprintf(stderr, "REmoving relation for %s\n", object->dbg().utf8().data()); > > + auto* relationTarget = objectForID(targetID); > > + if (!relationTarget || !relationTarget->accessibilityIsIgnored()) > > + continue; > > + > > + if (!hasNoRelations(targetID)) > > + continue; > > + > > + if (auto tree = AXIsolatedTree::treeForPageID(m_pageID)) > > + tree->removeNode(*relationTarget); > > +#endif // ENABLE(ACCESSIBILITY_ISOLATED_TREE) > > I understand that you've added this to cleanup objects that only exist in > the isolated tree because they were added for relations reasons. But I > wonder if it's necessary? Unconnected nodes will be cleaned up like normal > when they're removed from the DOM / render tree, so not sure it's worth it > to do all this work to try to clean them up for an uncommon scenario (an > object is ignored, and used to have relations, but then lost them for some > reason other than being deleted from the DOM). > > What do you think? My original thought was that if you have an object that is related to many other (ignored) objects, we should clean them up for space efficiency. But that case does seem extremely rare, so I totally get your point. Your comment also makes me think that not removing the unconnected nodes helps prevent more work in case those relations are re-established. I think the space trade off would be worth it. > > Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.cpp:171 > > + for (auto& relatedObjectID : axObjectCache.relations().keys()) { > > + auto* axObject = axObjectCache.objectForID(relatedObjectID); > > + if (axObject && axObject->accessibilityIsIgnored()) { > > + if (!tree->objectForID(relatedObjectID)) > > + tree->addUnconnectedNode(*axObject); > > + } > > + } > > Is this necessary when we proactively add unconnected nodes if necessary in > AXObjectCache::addRelations? Seems like we would need one or the other? In AXObjectCache::addRelation, we have to get the tree using treeForPageID. The code above is executing before the tree is added to the tree cache in AXIsolatedTree::create, so addRelation isn't adding any unconnected nodes since the tree is null. We need this here so that we can add the nodes at initialization, and then for relations that change, AXObjectCache::addRelation will take care of those. 2000608 6 tyler_w 2023-12-18 19:44:05 -0800 > > > Source/WebCore/accessibility/AXObjectCache.cpp:4632 > > > +#if ENABLE(ACCESSIBILITY_ISOLATED_TREE) > > > + if (auto tree = AXIsolatedTree::treeForPageID(m_pageID)) { > > > + if (relationOrigin && relationOrigin->accessibilityIsIgnored()) > > > + tree->addUnconnectedNode(*relationOrigin); > > > + if (relationTarget && relationTarget->accessibilityIsIgnored()) > > > + tree->addUnconnectedNode(*relationTarget); > > > + } > > > +#endif > > > > Something I just realized about addUnconnectedNode: it doesn't check that > > the object exists before creating a brand new isolated object. That's not > > great, especially with the addition of this code, as it means we'll create a > > ton of duplicate copies of the same object over and over. You can imagine an > > ARIA component that aria-owns 100 children. I think we'd create the same > > object 100 times? > > Ah yeah, that is true! I'm curious if we don't check that now for a reason? > I can easily add a m_readerThreadNodeMap.contains(id) inside > addUnconnectedNode. m_readerThreadNodeMap can only be read / written from the secondary thread (see the comment above its definition) because it's a non-thread safe hashmap. Checking AXIsolatedTree::m_nodeMap should do the trick though. m_nodeMap is intended to provide a representation of the isolated tree on the main-thread (for purposes such as these). > > > Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.cpp:171 > > > + for (auto& relatedObjectID : axObjectCache.relations().keys()) { > > > + auto* axObject = axObjectCache.objectForID(relatedObjectID); > > > + if (axObject && axObject->accessibilityIsIgnored()) { > > > + if (!tree->objectForID(relatedObjectID)) > > > + tree->addUnconnectedNode(*axObject); > > > + } > > > + } > > > > Is this necessary when we proactively add unconnected nodes if necessary in > > AXObjectCache::addRelations? Seems like we would need one or the other? > > In AXObjectCache::addRelation, we have to get the tree using treeForPageID. > The code above is executing before the tree is added to the tree cache in > AXIsolatedTree::create, so addRelation isn't adding any unconnected nodes > since the tree is null. We need this here so that we can add the nodes at > initialization, and then for relations that change, > AXObjectCache::addRelation will take care of those. Ah right, should've noticed this is in AXIsolatedTree::create! 2000609 7 jhoffman23 2023-12-18 19:53:49 -0800 (In reply to Tyler Wilcock from comment #6) > > > > Source/WebCore/accessibility/AXObjectCache.cpp:4632 > > > > +#if ENABLE(ACCESSIBILITY_ISOLATED_TREE) > > > > + if (auto tree = AXIsolatedTree::treeForPageID(m_pageID)) { > > > > + if (relationOrigin && relationOrigin->accessibilityIsIgnored()) > > > > + tree->addUnconnectedNode(*relationOrigin); > > > > + if (relationTarget && relationTarget->accessibilityIsIgnored()) > > > > + tree->addUnconnectedNode(*relationTarget); > > > > + } > > > > +#endif > > > > > > Something I just realized about addUnconnectedNode: it doesn't check that > > > the object exists before creating a brand new isolated object. That's not > > > great, especially with the addition of this code, as it means we'll create a > > > ton of duplicate copies of the same object over and over. You can imagine an > > > ARIA component that aria-owns 100 children. I think we'd create the same > > > object 100 times? > > > > Ah yeah, that is true! I'm curious if we don't check that now for a reason? > > I can easily add a m_readerThreadNodeMap.contains(id) inside > > addUnconnectedNode. > m_readerThreadNodeMap can only be read / written from the secondary thread > (see the comment above its definition) because it's a non-thread safe > hashmap. Checking AXIsolatedTree::m_nodeMap should do the trick though. > m_nodeMap is intended to provide a representation of the isolated tree on > the main-thread (for purposes such as these). Ah yes! I was under the impression, however, that unconnected nodes don't get added to the m_nodeMap (based on this comment in addUnconnectedNode): // Because we are queuing a change for an object not intended to be connected to the rest of the tree, // we don't need to update m_nodeMap or m_pendingChildrenUpdates for this object or its parent as is // done in AXIsolatedTree::nodeChangeForObject and AXIsolatedTree::queueChange. 2000610 8 tyler_w 2023-12-18 20:17:06 -0800 (In reply to Joshua Hoffman from comment #7) > (In reply to Tyler Wilcock from comment #6) > > > > > Source/WebCore/accessibility/AXObjectCache.cpp:4632 > > > > > +#if ENABLE(ACCESSIBILITY_ISOLATED_TREE) > > > > > + if (auto tree = AXIsolatedTree::treeForPageID(m_pageID)) { > > > > > + if (relationOrigin && relationOrigin->accessibilityIsIgnored()) > > > > > + tree->addUnconnectedNode(*relationOrigin); > > > > > + if (relationTarget && relationTarget->accessibilityIsIgnored()) > > > > > + tree->addUnconnectedNode(*relationTarget); > > > > > + } > > > > > +#endif > > > > > > > > Something I just realized about addUnconnectedNode: it doesn't check that > > > > the object exists before creating a brand new isolated object. That's not > > > > great, especially with the addition of this code, as it means we'll create a > > > > ton of duplicate copies of the same object over and over. You can imagine an > > > > ARIA component that aria-owns 100 children. I think we'd create the same > > > > object 100 times? > > > > > > Ah yeah, that is true! I'm curious if we don't check that now for a reason? > > > I can easily add a m_readerThreadNodeMap.contains(id) inside > > > addUnconnectedNode. > > m_readerThreadNodeMap can only be read / written from the secondary thread > > (see the comment above its definition) because it's a non-thread safe > > hashmap. Checking AXIsolatedTree::m_nodeMap should do the trick though. > > m_nodeMap is intended to provide a representation of the isolated tree on > > the main-thread (for purposes such as these). > > Ah yes! I was under the impression, however, that unconnected nodes don't > get added to the m_nodeMap (based on this comment in addUnconnectedNode): > // Because we are queuing a change for an object not intended to be > connected to the rest of the tree, > // we don't need to update m_nodeMap or m_pendingChildrenUpdates for this > object or its parent as is > // done in AXIsolatedTree::nodeChangeForObject and > AXIsolatedTree::queueChange. Ah yup, that's true. We should investigate if there's any reason why adding these to the node map would cause incorrect behavior, or if the reason it wasn't done was purely for efficiency's sake. If the latter, it's probably more efficient overall to update the node map once, than to not update the node map and create boundless copies of the same object. 2000613 9 469123 jhoffman23 2023-12-18 21:56:41 -0800 Created attachment 469123 Patch 2000616 10 jhoffman23 2023-12-18 22:12:13 -0800 (In reply to Tyler Wilcock from comment #8) > (In reply to Joshua Hoffman from comment #7) > > (In reply to Tyler Wilcock from comment #6)> > > > Ah yes! I was under the impression, however, that unconnected nodes don't > > get added to the m_nodeMap (based on this comment in addUnconnectedNode): > > // Because we are queuing a change for an object not intended to be > > connected to the rest of the tree, > > // we don't need to update m_nodeMap or m_pendingChildrenUpdates for this > > object or its parent as is > > // done in AXIsolatedTree::nodeChangeForObject and > > AXIsolatedTree::queueChange. > Ah yup, that's true. We should investigate if there's any reason why adding > these to the node map would cause incorrect behavior, or if the reason it > wasn't done was purely for efficiency's sake. If the latter, it's probably > more efficient overall to update the node map once, than to not update the > node map and create boundless copies of the same object. Investigated this and this shouldn't cause any issues, and all tests still pass. Adding it in in the latest patch. 2000724 11 469129 jhoffman23 2023-12-19 08:34:41 -0800 Created attachment 469129 Patch 2000787 12 tyler_w 2023-12-19 11:12:41 -0800 > > Ah yup, that's true. We should investigate if there's any reason why adding > > these to the node map would cause incorrect behavior, or if the reason it > > wasn't done was purely for efficiency's sake. If the latter, it's probably > > more efficient overall to update the node map once, than to not update the > > node map and create boundless copies of the same object. > > Investigated this and this shouldn't cause any issues, and all tests still > pass. Adding it in in the latest patch. OK I looked into it too, and I'm a bit worried that using the node map here will affect tree updates in an adverse way, as AXIsolatedTree::updateChildren does this: auto* axAncestor = Accessibility::findAncestor(axObject, true, [this] (auto& ancestor) { return m_nodeMap.find(ancestor.objectID()) != m_nodeMap.end(); }); The intention is to find the nearest in-live-tree (a.k.a not ignored) ancestor that's also in the node map, and we will be breaking that invariant, which would result in missing content in some cases. We could add an accessibilityIsIgnored check, but this is a hot path and that function is expensive. 2000795 13 jhoffman23 2023-12-19 11:31:29 -0800 (In reply to Tyler Wilcock from comment #12) > > > Ah yup, that's true. We should investigate if there's any reason why adding > > > these to the node map would cause incorrect behavior, or if the reason it > > > wasn't done was purely for efficiency's sake. If the latter, it's probably > > > more efficient overall to update the node map once, than to not update the > > > node map and create boundless copies of the same object. > > > > Investigated this and this shouldn't cause any issues, and all tests still > > pass. Adding it in in the latest patch. > OK I looked into it too, and I'm a bit worried that using the node map here > will affect tree updates in an adverse way, as > AXIsolatedTree::updateChildren does this: > > auto* axAncestor = Accessibility::findAncestor(axObject, true, [this] > (auto& ancestor) { > return m_nodeMap.find(ancestor.objectID()) != m_nodeMap.end(); > }); > > The intention is to find the nearest in-live-tree (a.k.a not ignored) > ancestor that's also in the node map, and we will be breaking that > invariant, which would result in missing content in some cases. We could add > an accessibilityIsIgnored check, but this is a hot path and that function is > expensive. Gotcha, in that case we can just add a m_unconnectedNodes HashSet store/remove IDs from there. 2000806 14 469132 jhoffman23 2023-12-19 12:10:06 -0800 Created attachment 469132 Patch 2000827 15 469132 tyler_w 2023-12-19 13:37:40 -0800 Comment on attachment 469132 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=469132&action=review > Source/WebCore/accessibility/AXObjectCache.cpp:4628 > + tree->addUnconnectedNode(*relationOrigin); Since we don't use the RefPtr anymore after this line, we can save ref-count churn by using relationOrigin.releaseNonNull(). Same for relationTarget. > Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.cpp:166 > + auto* axObject = axObjectCache.objectForID(relatedObjectID); Sorry for missing this before, but this should probably be a RefPtr too. > Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.cpp:168 > + if (!tree->objectForID(relatedObjectID)) We shouldn't call AXIsolatedTree::objectForID on the main-thread (it's basically a thin wrapper over m_readerThreadNodeMap). Can we remove this check entirely now that we have m_unconnectedNodes? > Source/WebCore/accessibility/isolatedtree/AXIsolatedTree.cpp:1065 > + if (m_unconnectedNodes.contains(objectID)) { > + m_unconnectedNodes.remove(objectID); You can save one hash operation by using HashMap::remove, which returns a bool indicating whether the value was removed. 2000832 16 469133 jhoffman23 2023-12-19 13:52:02 -0800 Created attachment 469133 Patch 2000833 17 jhoffman23 2023-12-19 13:52:25 -0800 (In reply to Tyler Wilcock from comment #15) > Comment on attachment 469132 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=469132&action=review Addressed all of your comments in the latest patch 2000944 18 ews-feeder 2023-12-19 21:09:17 -0800 Committed 272323@main (e4ad61660d18): <https://commits.webkit.org/272323@main> All reviewed patches have been landed. Closing bug and clearing flags on attachment 469133. 469121 2023-12-18 18:12:34 -0800 2023-12-18 21:49:08 -0800 Patch bug-266608-20231218201003.patch text/plain 8802 jhoffman23 RnJvbSA3MzM4ZjRiNzllZDE0MTdiNzVhNmJjMTc2MTI1ZDg5NjU0ZmIxNzJkIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb3NodWEgSG9mZm1hbiA8amhvZmZtYW4yM0BhcHBsZS5jb20+ CkRhdGU6IE1vbiwgMTggRGVjIDIwMjMgMTk6NDY6MzIgLTA2MDAKU3ViamVjdDogW1BBVENIXSBB WDogTW92ZSBvYmplY3RzRm9ySWRzIG9mZiBvZiB0aGUgbWFpbiB0aHJlYWQKIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjY2MDggcmRhcjovLzExNjEzMzU4NgoKUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgpUaGlzIHBhdGNoIG1vdmVzIG9iamVjdHNGb3JJRHMg Y29tcGxldGVseSBvZmYgb2YgdGhlIG1haW4gdGhyZWFkIGJ5IGVhZ2VybHkKY2FjaGluZyBpZ25v cmVkIG9iamVjdHMgdGhhdCBhcmUgb3JpZ2lucy90YXJnZXRzIG9mIHJlbGF0aW9uc2hpcHMuIFRo aXMgYWxsb3dzCmFsbCBwb3RlbnRpYWxseSByZXF1ZXN0ZWQgQVggb2JqZWN0cyB0byBiZSBzZXJ2 ZWQgZnJvbSB0aGUgQVggdGhyZWFkLgoKVGhlc2Ugb2JqZWN0cyBhcmUgYmVpbmcgYWRkZWQgYXMg dW5jb25uZWN0ZWQgaW4gdHdvIHNwb3RzOiAoMSkgd2hlbiB0aGUgaXNvbGF0ZWQKVHJlZSBpcyBp bml0aWFsaXplZCBhbmQgKDIpIHdoZW4gYSBuZXcgcmVsYXRpb24gaXMgYmVpbmcgYWRkZWQuIFdl IHJlbW92ZSB0aGVzZQp1bmNvbm5lY3RlZCBub2RlcyB3aGVuIHRoZSByZWxhdGlvbiBpcyByZW1v dmVkIEFORCB0aGF0IG9iamVjdCBoYXMgbm8gb3RoZXIKcmVsYXRpb25zLgoKKiBMYXlvdXRUZXN0 cy9hY2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS1leHBlY3RlZC50eHQ6CiogTGF5 b3V0VGVzdHMvYWNjZXNzaWJpbGl0eS9tYWMvYXJpYS1lcnJvcm1lc3NhZ2UuaHRtbDoKKiBTb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwOgooV2ViQ29yZTo6QVhP YmplY3RDYWNoZTo6YWRkUmVsYXRpb24pOgooV2ViQ29yZTo6QVhPYmplY3RDYWNoZTo6cmVtb3Zl UmVsYXRpb25zKToKKFdlYkNvcmU6OkFYT2JqZWN0Q2FjaGU6Omhhc05vUmVsYXRpb25zKToKKiBT b3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuaDoKKiBTb3VyY2UvV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5jcHA6CihXZWJD b3JlOjpBWElzb2xhdGVkVHJlZTo6Y3JlYXRlKToKKFdlYkNvcmU6OkFYSXNvbGF0ZWRUcmVlOjpv YmplY3RzRm9ySURzKToKLS0tCiAuLi4vV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2Fj aGUuY3BwICAgfCA0NyArKysrKysrKysrKysrKysrKystCiBTb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYT2JqZWN0Q2FjaGUuaCAgfCAgMSArCiAuLi4vaXNvbGF0ZWR0cmVlL0FYSXNvbGF0 ZWRUcmVlLmNwcCAgICAgICAgICAgfCAyNCArKysrLS0tLS0tCiAuLi4vbWFjL2FyaWEtZXJyb3Jt ZXNzYWdlLWV4cGVjdGVkLnR4dCAgICAgICAgfCAgNSArKwogLi4uL2FjY2Vzc2liaWxpdHkvbWFj L2FyaWEtZXJyb3JtZXNzYWdlLmh0bWwgIHwgIDcgKysrCiA1IGZpbGVzIGNoYW5nZWQsIDY2IGlu c2VydGlvbnMoKyksIDE4IGRlbGV0aW9ucygtKQoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3Np YmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwCmluZGV4IDU1MTcxNTFmNTllYS4uNzcxNzQzZWE1YmU1 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUu Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAK QEAgLTQ2MTgsNyArNDYxOCwxOCBAQCB2b2lkIEFYT2JqZWN0Q2FjaGU6OmFkZFJlbGF0aW9uKEVs ZW1lbnQqIG9yaWdpbiwgRWxlbWVudCogdGFyZ2V0LCBBWFJlbGF0aW9uVHlwZQogICAgICAgICBB U1NFUlRfTk9UX1JFQUNIRUQoKTsKICAgICAgICAgcmV0dXJuOwogICAgIH0KLSAgICBhZGRSZWxh dGlvbihnZXRPckNyZWF0ZShvcmlnaW4sIElzUGFydE9mUmVsYXRpb246OlllcyksIGdldE9yQ3Jl YXRlKHRhcmdldCwgSXNQYXJ0T2ZSZWxhdGlvbjo6WWVzKSwgcmVsYXRpb25UeXBlKTsKKyAgICBh dXRvKiByZWxhdGlvbk9yaWdpbiA9IGdldE9yQ3JlYXRlKG9yaWdpbiwgSXNQYXJ0T2ZSZWxhdGlv bjo6WWVzKTsKKyAgICBhdXRvKiByZWxhdGlvblRhcmdldCA9IGdldE9yQ3JlYXRlKHRhcmdldCwg SXNQYXJ0T2ZSZWxhdGlvbjo6WWVzKTsKKyAgICBhZGRSZWxhdGlvbihyZWxhdGlvbk9yaWdpbiwg cmVsYXRpb25UYXJnZXQsIHJlbGF0aW9uVHlwZSk7CisKKyNpZiBFTkFCTEUoQUNDRVNTSUJJTElU WV9JU09MQVRFRF9UUkVFKQorICAgIGlmIChhdXRvIHRyZWUgPSBBWElzb2xhdGVkVHJlZTo6dHJl ZUZvclBhZ2VJRChtX3BhZ2VJRCkpIHsKKyAgICAgICAgaWYgKHJlbGF0aW9uT3JpZ2luICYmIHJl bGF0aW9uT3JpZ2luLT5hY2Nlc3NpYmlsaXR5SXNJZ25vcmVkKCkpCisgICAgICAgICAgICB0cmVl LT5hZGRVbmNvbm5lY3RlZE5vZGUoKnJlbGF0aW9uT3JpZ2luKTsKKyAgICAgICAgaWYgKHJlbGF0 aW9uVGFyZ2V0ICYmIHJlbGF0aW9uVGFyZ2V0LT5hY2Nlc3NpYmlsaXR5SXNJZ25vcmVkKCkpCisg ICAgICAgICAgICB0cmVlLT5hZGRVbmNvbm5lY3RlZE5vZGUoKnJlbGF0aW9uVGFyZ2V0KTsKKyAg ICB9CisjZW5kaWYKIH0KIAogc3RhdGljIGJvb2wgY2FuSGF2ZVJlbGF0aW9ucyhFbGVtZW50JiBl bGVtZW50KQpAQCAtNDcwOSw5ICs0NzIwLDI1IEBAIHZvaWQgQVhPYmplY3RDYWNoZTo6cmVtb3Zl UmVsYXRpb25zKEVsZW1lbnQmIG9yaWdpbiwgQVhSZWxhdGlvblR5cGUgcmVsYXRpb25UeXBlCiAg ICAgaWYgKHN5bW1ldHJpYyA9PSBBWFJlbGF0aW9uVHlwZTo6Tm9uZSkKICAgICAgICAgcmV0dXJu OwogCi0gICAgZm9yIChBWElEIHRhcmdldElEIDogdGFyZ2V0SURzKQorICAgIGZvciAoQVhJRCB0 YXJnZXRJRCA6IHRhcmdldElEcykgewogICAgICAgICByZW1vdmVSZWxhdGlvbkJ5SUQodGFyZ2V0 SUQsIG9iamVjdC0+b2JqZWN0SUQoKSwgc3ltbWV0cmljKTsKIAorI2lmIEVOQUJMRShBQ0NFU1NJ QklMSVRZX0lTT0xBVEVEX1RSRUUpCisgICAgICAgIC8vIElmIHRoaXMgZWxlbWVudCBoYXMgbm8g bW9yZSByZWxhdGlvbnMsIGFuZCBpdCBpcyBpZ25vcmVkLCByZW1vdmUgaXQgZnJvbQorICAgICAg ICAvLyB0aGUgaXNvbGF0ZWQgdHJlZS4KKyAgICAgICAgZnByaW50ZihzdGRlcnIsICJSRW1vdmlu ZyByZWxhdGlvbiBmb3IgJXNcbiIsIG9iamVjdC0+ZGJnKCkudXRmOCgpLmRhdGEoKSk7CisgICAg ICAgIGF1dG8qIHJlbGF0aW9uVGFyZ2V0ID0gb2JqZWN0Rm9ySUQodGFyZ2V0SUQpOworICAgICAg ICBpZiAoIXJlbGF0aW9uVGFyZ2V0IHx8ICFyZWxhdGlvblRhcmdldC0+YWNjZXNzaWJpbGl0eUlz SWdub3JlZCgpKQorICAgICAgICAgICAgY29udGludWU7CisKKyAgICAgICAgaWYgKCFoYXNOb1Jl bGF0aW9ucyh0YXJnZXRJRCkpCisgICAgICAgICAgICBjb250aW51ZTsKKworICAgICAgICBpZiAo YXV0byB0cmVlID0gQVhJc29sYXRlZFRyZWU6OnRyZWVGb3JQYWdlSUQobV9wYWdlSUQpKQorICAg ICAgICAgICAgdHJlZS0+cmVtb3ZlTm9kZSgqcmVsYXRpb25UYXJnZXQpOworI2VuZGlmIC8vIEVO QUJMRShBQ0NFU1NJQklMSVRZX0lTT0xBVEVEX1RSRUUpCisgICAgfQorCiAgICAgaWYgKCF0YXJn ZXRJRHMuaXNFbXB0eSgpICYmIHJlbGF0aW9uVHlwZSA9PSBBWFJlbGF0aW9uVHlwZTo6T3duZXJG b3IpCiAgICAgICAgIGNoaWxkcmVuQ2hhbmdlZChvYmplY3QpOwogfQpAQCAtNDcyOCw2ICs0NzU1 LDIyIEBAIHZvaWQgQVhPYmplY3RDYWNoZTo6cmVtb3ZlUmVsYXRpb25CeUlEKEFYSUQgb3JpZ2lu SUQsIEFYSUQgdGFyZ2V0SUQsIEFYUmVsYXRpb25UCiAgICAgdGFyZ2V0c0l0ZXJhdG9yLT52YWx1 ZS5yZW1vdmUodGFyZ2V0SUQpOwogfQogCitib29sIEFYT2JqZWN0Q2FjaGU6Omhhc05vUmVsYXRp b25zKEFYSUQgb2JqZWN0SUQpCit7CisgICAgaWYgKCFtX3JlbGF0aW9ucy5jb250YWlucyhvYmpl Y3RJRCkpCisgICAgICAgIHJldHVybiB0cnVlOworCisgICAgYXV0byByZWxhdGlvbnMgPSBtX3Jl bGF0aW9ucy5nZXQob2JqZWN0SUQpOworICAgIGlmICghcmVsYXRpb25zLnNpemUoKSkKKyAgICAg ICAgcmV0dXJuIHRydWU7CisKKyAgICBmb3IgKGF1dG8mIHJlbGF0aW9uVHlwZSA6IHJlbGF0aW9u cykgeworICAgICAgICBpZiAocmVsYXRpb25UeXBlLnZhbHVlLnNpemUoKSkKKyAgICAgICAgICAg IHJldHVybiBmYWxzZTsKKyAgICB9CisgICAgcmV0dXJuIHRydWU7Cit9CisKIHZvaWQgQVhPYmpl Y3RDYWNoZTo6dXBkYXRlUmVsYXRpb25zSWZOZWVkZWQoKQogewogICAgIGlmICghbV9yZWxhdGlv bnNOZWVkVXBkYXRlKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B WE9iamVjdENhY2hlLmggYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2Fj aGUuaAppbmRleCA5MWU3ZmY0ZmJhMDEuLmZiNWQzY2ZmNDk2YiAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgKKysrIGIvU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgKQEAgLTY1MCw2ICs2NTAsNyBAQCBwcml2 YXRlOgogICAgIEhhc2hNYXA8QVhJRCwgQVhSZWxhdGlvbnM+IHJlbGF0aW9ucygpOwogICAgIGNv bnN0IEhhc2hTZXQ8QVhJRD4mIHJlbGF0aW9uVGFyZ2V0SURzKCk7CiAgICAgYm9vbCBpc0Rlc2Nl bmRhbnRPZlJlbGF0ZWROb2RlKE5vZGUmKTsKKyAgICBib29sIGhhc05vUmVsYXRpb25zKEFYSUQp OwogCiAgICAgLy8gT2JqZWN0IGNyZWF0aW9uLgogICAgIFJlZjxBY2Nlc3NpYmlsaXR5T2JqZWN0 PiBjcmVhdGVPYmplY3RGcm9tUmVuZGVyZXIoUmVuZGVyT2JqZWN0Kik7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVk VHJlZS5jcHAKaW5kZXggYjY3ZTEwYjAzNDFmLi4yYzIyMjNiN2QwNDIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xh dGVkVHJlZS5jcHAKQEAgLTE2Miw2ICsxNjIsMTQgQEAgUmVmPEFYSXNvbGF0ZWRUcmVlPiBBWElz b2xhdGVkVHJlZTo6Y3JlYXRlKEFYT2JqZWN0Q2FjaGUmIGF4T2JqZWN0Q2FjaGUpCiAKICAgICB0 cmVlLT51cGRhdGVSZWxhdGlvbnMoYXhPYmplY3RDYWNoZS5yZWxhdGlvbnMoKSk7CiAKKyAgICBm b3IgKGF1dG8mIHJlbGF0ZWRPYmplY3RJRCA6IGF4T2JqZWN0Q2FjaGUucmVsYXRpb25zKCkua2V5 cygpKSB7CisgICAgICAgIGF1dG8qIGF4T2JqZWN0ID0gYXhPYmplY3RDYWNoZS5vYmplY3RGb3JJ RChyZWxhdGVkT2JqZWN0SUQpOworICAgICAgICBpZiAoYXhPYmplY3QgJiYgYXhPYmplY3QtPmFj Y2Vzc2liaWxpdHlJc0lnbm9yZWQoKSkgeworICAgICAgICAgICAgaWYgKCF0cmVlLT5vYmplY3RG b3JJRChyZWxhdGVkT2JqZWN0SUQpKQorICAgICAgICAgICAgICAgIHRyZWUtPmFkZFVuY29ubmVj dGVkTm9kZSgqYXhPYmplY3QpOworICAgICAgICB9CisgICAgfQorCiAgICAgLy8gTm93IHRoYXQg dGhlIHRyZWUgaXMgcmVhZHkgdG8gdGFrZSBjbGllbnQgcmVxdWVzdHMsIGFkZCBpdCB0byB0aGUg dHJlZSBtYXBzIHNvIHRoYXQgaXQgY2FuIGJlIGZvdW5kLgogICAgIHN0b3JlVHJlZShheE9iamVj dENhY2hlLCB0cmVlKTsKICAgICByZXR1cm4gdHJlZTsKQEAgLTIzOSwyMiArMjQ3LDYgQEAgVmVj dG9yPFJlZlB0cjxBWENvcmVPYmplY3Q+PiBBWElzb2xhdGVkVHJlZTo6b2JqZWN0c0ZvcklEcyhj b25zdCBVJiBheElEcykKICAgICAgICAgICAgIGNvbnRpbnVlOwogICAgICAgICB9CiAKLSAgICAg ICAgLy8gVGhlcmUgaXMgbm8gaXNvbGF0ZWQgb2JqZWN0IGZvciB0aGlzIEFYSUQuIFRoaXMgY2Fu IGhhcHBlbiBpZiB0aGUgY29ycmVzcG9uZGluZyBsaXZlIG9iamVjdCBpcyBpZ25vcmVkLgotICAg ICAgICAvLyBJZiB0aGVyZSBpcyBhIGxpdmUgb2JqZWN0IGZvciB0aGlzIElEIGFuZCBpdCBpcyBh biBpZ25vcmVkIHRhcmdldCBvZiBhIHJlbGF0aW9uc2hpcCwgY3JlYXRlIGFuIGlzb2xhdGVkIG9i amVjdCBmb3IgaXQuCi0gICAgICAgIG9iamVjdCA9IEFjY2Vzc2liaWxpdHk6OnJldHJpZXZlVmFs dWVGcm9tTWFpblRocmVhZDxSZWZQdHI8QVhJc29sYXRlZE9iamVjdD4+KFsmYXhJRCwgdGhpc10g KCkgLT4gUmVmUHRyPEFYSXNvbGF0ZWRPYmplY3Q+IHsKLSAgICAgICAgICAgIGF1dG8qIGNhY2hl ID0gYXhPYmplY3RDYWNoZSgpOwotICAgICAgICAgICAgaWYgKCFjYWNoZSB8fCAhY2FjaGUtPnJl bGF0aW9uVGFyZ2V0SURzKCkuY29udGFpbnMoYXhJRCkpCi0gICAgICAgICAgICAgICAgcmV0dXJu IG51bGxwdHI7Ci0KLSAgICAgICAgICAgIFJlZlB0ciBheE9iamVjdCA9IGNhY2hlLT5vYmplY3RG b3JJRChheElEKTsKLSAgICAgICAgICAgIGlmICghYXhPYmplY3QgfHwgIWF4T2JqZWN0LT5hY2Nl c3NpYmlsaXR5SXNJZ25vcmVkKCkpCi0gICAgICAgICAgICAgICAgcmV0dXJuIG51bGxwdHI7Ci0K LSAgICAgICAgICAgIGF1dG8gb2JqZWN0ID0gQVhJc29sYXRlZE9iamVjdDo6Y3JlYXRlKCpheE9i amVjdCwgY29uc3RfY2FzdDxBWElzb2xhdGVkVHJlZSo+KHRoaXMpKTsKLSAgICAgICAgICAgIEFT U0VSVChheE9iamVjdC0+d3JhcHBlcigpKTsKLSAgICAgICAgICAgIG9iamVjdC0+YXR0YWNoUGxh dGZvcm1XcmFwcGVyKGF4T2JqZWN0LT53cmFwcGVyKCkpOwotICAgICAgICAgICAgcmV0dXJuIG9i amVjdDsKLSAgICAgICAgfSk7CiAgICAgICAgIGlmIChvYmplY3QpIHsKICAgICAgICAgICAgIG1f cmVhZGVyVGhyZWFkTm9kZU1hcC5hZGQoYXhJRCwgKm9iamVjdCk7CiAgICAgICAgICAgICByZXN1 bHQuYXBwZW5kKG9iamVjdCk7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5 L21hYy9hcmlhLWVycm9ybWVzc2FnZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9hY2Nlc3Np YmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS1leHBlY3RlZC50eHQKaW5kZXggYjU1MWFkYmFm MTU0Li41ZDg2MTAxNjM5NmMgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkv bWFjL2FyaWEtZXJyb3JtZXNzYWdlLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9hY2Nl c3NpYmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS1leHBlY3RlZC50eHQKQEAgLTcsNiArNywx MSBAQCBQQVNTOiBlcnJvck1lc3NhZ2VzWzFdLmRvbUlkZW50aWZpZXIgPT09ICdlcnJvck1lc3Nh Z2UyJwogQ2hhbmdpbmcgI3N0YXJ0VGltZSBhcmlhLWludmFsaWQgdG8gYmUgZmFsc2UuCiBQQVNT OiBheFN0YXJ0VGltZS5lcnJvck1lc3NhZ2VFbGVtZW50cygpID09PSB1bmRlZmluZWQKIAorQ2hh bmdpbmcgI3N0YXJ0VGltZSBhcmlhLWludmFsaWQgYmFjayB0byBiZSB0cnVlLgorUEFTUzogZXJy b3JNZXNzYWdlcy5sZW5ndGggPT09IDIKK1BBU1M6IGVycm9yTWVzc2FnZXNbMF0uZG9tSWRlbnRp ZmllciA9PT0gJ2Vycm9yTWVzc2FnZTEnCitQQVNTOiBlcnJvck1lc3NhZ2VzWzFdLmRvbUlkZW50 aWZpZXIgPT09ICdlcnJvck1lc3NhZ2UyJworCiBQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0 cnVlCiAKIFRFU1QgQ09NUExFVEUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2FjY2Vzc2liaWxp dHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLmh0bWwgYi9MYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5 L21hYy9hcmlhLWVycm9ybWVzc2FnZS5odG1sCmluZGV4IDcxZjg1MzM0MDE3MC4uZjFhMDU5Yjk4 NmZjIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9y bWVzc2FnZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJy b3JtZXNzYWdlLmh0bWwKQEAgLTI5LDYgKzI5LDEzIEBAIGlmICh3aW5kb3cuYWNjZXNzaWJpbGl0 eUNvbnRyb2xsZXIpIHsKICAgICBzZXRUaW1lb3V0KGFzeW5jIGZ1bmN0aW9uKCkgewogICAgICAg ICBvdXRwdXQgKz0gYXdhaXQgZXhwZWN0QXN5bmMoImF4U3RhcnRUaW1lLmVycm9yTWVzc2FnZUVs ZW1lbnRzKCkiLCAidW5kZWZpbmVkIik7CiAKKyAgICAgICAgb3V0cHV0ICs9ICJcbkNoYW5naW5n ICNzdGFydFRpbWUgYXJpYS1pbnZhbGlkIGJhY2sgdG8gYmUgdHJ1ZS5cbiI7CisgICAgICAgIGRv Y3VtZW50LmdldEVsZW1lbnRCeUlkKCJzdGFydFRpbWUiKS5zZXRBdHRyaWJ1dGUoImFyaWEtaW52 YWxpZCIsICJmYWxzZSIpOworCisgICAgICAgIG91dHB1dCArPSBhd2FpdCBleHBlY3RBc3luYygi ZXJyb3JNZXNzYWdlcy5sZW5ndGgiLCAiMiIpOworICAgICAgICBvdXRwdXQgKz0gZXhwZWN0KCJl cnJvck1lc3NhZ2VzWzBdLmRvbUlkZW50aWZpZXIiLCAiJ2Vycm9yTWVzc2FnZTEnIik7CisgICAg ICAgIG91dHB1dCArPSBleHBlY3QoImVycm9yTWVzc2FnZXNbMV0uZG9tSWRlbnRpZmllciIsICIn ZXJyb3JNZXNzYWdlMiciKTsKKwogICAgICAgICBkZWJ1ZyhvdXRwdXQpOwogICAgICAgICBmaW5p c2hKU1Rlc3QoKTsKICAgICB9LCAwKTsK 469123 2023-12-18 21:56:41 -0800 2023-12-19 08:11:57 -0800 Patch bug-266608-20231218235410.patch text/plain 8141 jhoffman23 RnJvbSA1N2Q1NTI3ZWY2MzU1ZDc3ZDcwZjc1ZTViZjAwNzhmNDhmYWMyYzRhIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb3NodWEgSG9mZm1hbiA8amhvZmZtYW4yM0BhcHBsZS5jb20+ CkRhdGU6IE1vbiwgMTggRGVjIDIwMjMgMTk6NDY6MzIgLTA2MDAKU3ViamVjdDogW1BBVENIXSBB WDogTW92ZSBvYmplY3RzRm9ySWRzIG9mZiBvZiB0aGUgbWFpbiB0aHJlYWQKIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjY2MDggcmRhcjovLzExNjEzMzU4NgoKUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgpUaGlzIHBhdGNoIG1vdmVzIG9iamVjdHNGb3JJRHMg Y29tcGxldGVseSBvZmYgb2YgdGhlIG1haW4gdGhyZWFkIGJ5IGVhZ2VybHkKY2FjaGluZyBpZ25v cmVkIG9iamVjdHMgdGhhdCBhcmUgb3JpZ2lucy90YXJnZXRzIG9mIHJlbGF0aW9uc2hpcHMuIFRo aXMgYWxsb3dzCmFsbCBwb3RlbnRpYWxseSByZXF1ZXN0ZWQgQVggb2JqZWN0cyB0byBiZSBzZXJ2 ZWQgZnJvbSB0aGUgQVggdGhyZWFkLgoKVGhlc2Ugb2JqZWN0cyBhcmUgYmVpbmcgYWRkZWQgYXMg dW5jb25uZWN0ZWQgaW4gdHdvIHNwb3RzOiAoMSkgd2hlbiB0aGUgaXNvbGF0ZWQKdHJlZSBpcyBp bml0aWFsaXplZCBhbmQgKDIpIHdoZW4gYSBuZXcgcmVsYXRpb24gaXMgYmVpbmcgYWRkZWQuCgoq IExheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLWV4cGVjdGVk LnR4dDoKKiBMYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS5o dG1sOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHA6CihX ZWJDb3JlOjpBWE9iamVjdENhY2hlOjphZGRSZWxhdGlvbik6CiogU291cmNlL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmg6CiogU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuY3BwOgooV2ViQ29yZTo6QVhJc29sYXRlZFRy ZWU6OmNyZWF0ZSk6CihXZWJDb3JlOjpBWElzb2xhdGVkVHJlZTo6b2JqZWN0c0ZvcklEcyk6CihX ZWJDb3JlOjpBWElzb2xhdGVkVHJlZTo6YWRkVW5jb25uZWN0ZWROb2RlKToKLS0tCiAuLi4vV2Vi Q29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwICAgfCAxMyArKysrKysrLQogU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmggIHwgIDEgKwogLi4uL2lz b2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5jcHAgICAgICAgICAgIHwgMzAgKysrKysrKysrLS0t LS0tLS0tLQogLi4uL21hYy9hcmlhLWVycm9ybWVzc2FnZS1leHBlY3RlZC50eHQgICAgICAgIHwg IDUgKysrKwogLi4uL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLmh0bWwgIHwg IDcgKysrKysKIDUgZmlsZXMgY2hhbmdlZCwgMzkgaW5zZXJ0aW9ucygrKSwgMTcgZGVsZXRpb25z KC0pCgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENh Y2hlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAK aW5kZXggNTUxNzE1MWY1OWVhLi44MWM3ZjE1MGNlMmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv YWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcApAQCAtNDYxOCw3ICs0NjE4LDE4IEBAIHZv aWQgQVhPYmplY3RDYWNoZTo6YWRkUmVsYXRpb24oRWxlbWVudCogb3JpZ2luLCBFbGVtZW50KiB0 YXJnZXQsIEFYUmVsYXRpb25UeXBlCiAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOwogICAg ICAgICByZXR1cm47CiAgICAgfQotICAgIGFkZFJlbGF0aW9uKGdldE9yQ3JlYXRlKG9yaWdpbiwg SXNQYXJ0T2ZSZWxhdGlvbjo6WWVzKSwgZ2V0T3JDcmVhdGUodGFyZ2V0LCBJc1BhcnRPZlJlbGF0 aW9uOjpZZXMpLCByZWxhdGlvblR5cGUpOworICAgIFJlZlB0ciByZWxhdGlvbk9yaWdpbiA9IGdl dE9yQ3JlYXRlKG9yaWdpbiwgSXNQYXJ0T2ZSZWxhdGlvbjo6WWVzKTsKKyAgICBSZWZQdHIgcmVs YXRpb25UYXJnZXQgPSBnZXRPckNyZWF0ZSh0YXJnZXQsIElzUGFydE9mUmVsYXRpb246Olllcyk7 CisgICAgYWRkUmVsYXRpb24ocmVsYXRpb25PcmlnaW4uZ2V0KCksIHJlbGF0aW9uVGFyZ2V0Lmdl dCgpLCByZWxhdGlvblR5cGUpOworCisjaWYgRU5BQkxFKEFDQ0VTU0lCSUxJVFlfSVNPTEFURURf VFJFRSkKKyAgICBpZiAoYXV0byB0cmVlID0gQVhJc29sYXRlZFRyZWU6OnRyZWVGb3JQYWdlSUQo bV9wYWdlSUQpKSB7CisgICAgICAgIGlmIChyZWxhdGlvbk9yaWdpbiAmJiByZWxhdGlvbk9yaWdp bi0+YWNjZXNzaWJpbGl0eUlzSWdub3JlZCgpKQorICAgICAgICAgICAgdHJlZS0+YWRkVW5jb25u ZWN0ZWROb2RlKCpyZWxhdGlvbk9yaWdpbik7CisgICAgICAgIGlmIChyZWxhdGlvblRhcmdldCAm JiByZWxhdGlvblRhcmdldC0+YWNjZXNzaWJpbGl0eUlzSWdub3JlZCgpKQorICAgICAgICAgICAg dHJlZS0+YWRkVW5jb25uZWN0ZWROb2RlKCpyZWxhdGlvblRhcmdldCk7CisgICAgfQorI2VuZGlm CiB9CiAKIHN0YXRpYyBib29sIGNhbkhhdmVSZWxhdGlvbnMoRWxlbWVudCYgZWxlbWVudCkKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5oIGIv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmgKaW5kZXggOTFlN2Zm NGZiYTAxLi5mYjVkM2NmZjQ5NmIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2li aWxpdHkvQVhPYmplY3RDYWNoZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv QVhPYmplY3RDYWNoZS5oCkBAIC02NTAsNiArNjUwLDcgQEAgcHJpdmF0ZToKICAgICBIYXNoTWFw PEFYSUQsIEFYUmVsYXRpb25zPiByZWxhdGlvbnMoKTsKICAgICBjb25zdCBIYXNoU2V0PEFYSUQ+ JiByZWxhdGlvblRhcmdldElEcygpOwogICAgIGJvb2wgaXNEZXNjZW5kYW50T2ZSZWxhdGVkTm9k ZShOb2RlJik7CisgICAgYm9vbCBoYXNOb1JlbGF0aW9ucyhBWElEKTsKIAogICAgIC8vIE9iamVj dCBjcmVhdGlvbi4KICAgICBSZWY8QWNjZXNzaWJpbGl0eU9iamVjdD4gY3JlYXRlT2JqZWN0RnJv bVJlbmRlcmVyKFJlbmRlck9iamVjdCopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuY3BwIGIvU291cmNlL1dlYkNv cmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuY3BwCmluZGV4IGI2 N2UxMGIwMzQxZi4uOWJkNDVlNzRiMTk2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9hY2Nl c3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuY3BwCkBAIC0x NjIsNiArMTYyLDE0IEBAIFJlZjxBWElzb2xhdGVkVHJlZT4gQVhJc29sYXRlZFRyZWU6OmNyZWF0 ZShBWE9iamVjdENhY2hlJiBheE9iamVjdENhY2hlKQogCiAgICAgdHJlZS0+dXBkYXRlUmVsYXRp b25zKGF4T2JqZWN0Q2FjaGUucmVsYXRpb25zKCkpOwogCisgICAgZm9yIChhdXRvJiByZWxhdGVk T2JqZWN0SUQgOiBheE9iamVjdENhY2hlLnJlbGF0aW9ucygpLmtleXMoKSkgeworICAgICAgICBh dXRvKiBheE9iamVjdCA9IGF4T2JqZWN0Q2FjaGUub2JqZWN0Rm9ySUQocmVsYXRlZE9iamVjdElE KTsKKyAgICAgICAgaWYgKGF4T2JqZWN0ICYmIGF4T2JqZWN0LT5hY2Nlc3NpYmlsaXR5SXNJZ25v cmVkKCkpIHsKKyAgICAgICAgICAgIGlmICghdHJlZS0+b2JqZWN0Rm9ySUQocmVsYXRlZE9iamVj dElEKSkKKyAgICAgICAgICAgICAgICB0cmVlLT5hZGRVbmNvbm5lY3RlZE5vZGUoKmF4T2JqZWN0 KTsKKyAgICAgICAgfQorICAgIH0KKwogICAgIC8vIE5vdyB0aGF0IHRoZSB0cmVlIGlzIHJlYWR5 IHRvIHRha2UgY2xpZW50IHJlcXVlc3RzLCBhZGQgaXQgdG8gdGhlIHRyZWUgbWFwcyBzbyB0aGF0 IGl0IGNhbiBiZSBmb3VuZC4KICAgICBzdG9yZVRyZWUoYXhPYmplY3RDYWNoZSwgdHJlZSk7CiAg ICAgcmV0dXJuIHRyZWU7CkBAIC0yMzksMjIgKzI0Nyw2IEBAIFZlY3RvcjxSZWZQdHI8QVhDb3Jl T2JqZWN0Pj4gQVhJc29sYXRlZFRyZWU6Om9iamVjdHNGb3JJRHMoY29uc3QgVSYgYXhJRHMpCiAg ICAgICAgICAgICBjb250aW51ZTsKICAgICAgICAgfQogCi0gICAgICAgIC8vIFRoZXJlIGlzIG5v IGlzb2xhdGVkIG9iamVjdCBmb3IgdGhpcyBBWElELiBUaGlzIGNhbiBoYXBwZW4gaWYgdGhlIGNv cnJlc3BvbmRpbmcgbGl2ZSBvYmplY3QgaXMgaWdub3JlZC4KLSAgICAgICAgLy8gSWYgdGhlcmUg aXMgYSBsaXZlIG9iamVjdCBmb3IgdGhpcyBJRCBhbmQgaXQgaXMgYW4gaWdub3JlZCB0YXJnZXQg b2YgYSByZWxhdGlvbnNoaXAsIGNyZWF0ZSBhbiBpc29sYXRlZCBvYmplY3QgZm9yIGl0LgotICAg ICAgICBvYmplY3QgPSBBY2Nlc3NpYmlsaXR5OjpyZXRyaWV2ZVZhbHVlRnJvbU1haW5UaHJlYWQ8 UmVmUHRyPEFYSXNvbGF0ZWRPYmplY3Q+PihbJmF4SUQsIHRoaXNdICgpIC0+IFJlZlB0cjxBWElz b2xhdGVkT2JqZWN0PiB7Ci0gICAgICAgICAgICBhdXRvKiBjYWNoZSA9IGF4T2JqZWN0Q2FjaGUo KTsKLSAgICAgICAgICAgIGlmICghY2FjaGUgfHwgIWNhY2hlLT5yZWxhdGlvblRhcmdldElEcygp LmNvbnRhaW5zKGF4SUQpKQotICAgICAgICAgICAgICAgIHJldHVybiBudWxscHRyOwotCi0gICAg ICAgICAgICBSZWZQdHIgYXhPYmplY3QgPSBjYWNoZS0+b2JqZWN0Rm9ySUQoYXhJRCk7Ci0gICAg ICAgICAgICBpZiAoIWF4T2JqZWN0IHx8ICFheE9iamVjdC0+YWNjZXNzaWJpbGl0eUlzSWdub3Jl ZCgpKQotICAgICAgICAgICAgICAgIHJldHVybiBudWxscHRyOwotCi0gICAgICAgICAgICBhdXRv IG9iamVjdCA9IEFYSXNvbGF0ZWRPYmplY3Q6OmNyZWF0ZSgqYXhPYmplY3QsIGNvbnN0X2Nhc3Q8 QVhJc29sYXRlZFRyZWUqPih0aGlzKSk7Ci0gICAgICAgICAgICBBU1NFUlQoYXhPYmplY3QtPndy YXBwZXIoKSk7Ci0gICAgICAgICAgICBvYmplY3QtPmF0dGFjaFBsYXRmb3JtV3JhcHBlcihheE9i amVjdC0+d3JhcHBlcigpKTsKLSAgICAgICAgICAgIHJldHVybiBvYmplY3Q7Ci0gICAgICAgIH0p OwogICAgICAgICBpZiAob2JqZWN0KSB7CiAgICAgICAgICAgICBtX3JlYWRlclRocmVhZE5vZGVN YXAuYWRkKGF4SUQsICpvYmplY3QpOwogICAgICAgICAgICAgcmVzdWx0LmFwcGVuZChvYmplY3Qp OwpAQCAtMzMxLDYgKzMyMywxMSBAQCB2b2lkIEFYSXNvbGF0ZWRUcmVlOjphZGRVbmNvbm5lY3Rl ZE5vZGUoUmVmPEFjY2Vzc2liaWxpdHlPYmplY3Q+IGF4T2JqZWN0KQogICAgIEFYVFJBQ0UoIkFY SXNvbGF0ZWRUcmVlOjphZGRVbmNvbm5lY3RlZE5vZGUiX3MpOwogICAgIEFTU0VSVChpc01haW5U aHJlYWQoKSk7CiAKKyAgICBpZiAobV9ub2RlTWFwLmNvbnRhaW5zKGF4T2JqZWN0LT5vYmplY3RJ RCgpKSkgeworICAgICAgICBBWExPRyhtYWtlU3RyaW5nKCJBWElzb2xhdGVkVHJlZTo6YWRkVW5j b25uZWN0ZWROb2RlIGV4aXRpbmcgYmVjYXVzZSBhbiBpc29sYXRlZCBvYmplY3QgZm9yICIsIGF4 T2JqZWN0LT5vYmplY3RJRCgpLmxvZ2dpbmdTdHJpbmcoKSwgIiBhbHJlYWR5IGV4aXN0cy4iKSk7 CisgICAgICAgIHJldHVybjsKKyAgICB9CisKICAgICBpZiAoYXhPYmplY3QtPmlzRGV0YWNoZWQo KSB8fCAhYXhPYmplY3QtPndyYXBwZXIoKSkgewogICAgICAgICBBWExPRyhtYWtlU3RyaW5nKCJB WElzb2xhdGVkVHJlZTo6YWRkVW5jb25uZWN0ZWROb2RlIGJhaWxpbmcgYmVjYXVzZSBhc3NvY2lh dGVkIGxpdmUgb2JqZWN0IElEICIsIGF4T2JqZWN0LT5vYmplY3RJRCgpLmxvZ2dpbmdTdHJpbmco KSwgIiBoYWQgbm8gd3JhcHBlciBvciBpcyBkZXRhY2hlZC4gT2JqZWN0IGlzOiIpKTsKICAgICAg ICAgQVhMT0coYXhPYmplY3QucHRyKCkpOwpAQCAtMzQ3LDYgKzM0NCw3IEBAIHZvaWQgQVhJc29s YXRlZFRyZWU6OmFkZFVuY29ubmVjdGVkTm9kZShSZWY8QWNjZXNzaWJpbGl0eU9iamVjdD4gYXhP YmplY3QpCiAgICAgLy8gb3RoZXIgZW50aXR5IGlzIHJlbW92ZWQgZnJvbSB0aGUgcGFnZS4KICAg ICBhdXRvIG9iamVjdCA9IEFYSXNvbGF0ZWRPYmplY3Q6OmNyZWF0ZShheE9iamVjdCwgdGhpcyk7 CiAgICAgb2JqZWN0LT5hdHRhY2hQbGF0Zm9ybVdyYXBwZXIoYXhPYmplY3QtPndyYXBwZXIoKSk7 CisgICAgbV9ub2RlTWFwLnNldChheE9iamVjdC0+b2JqZWN0SUQoKSwgUGFyZW50Q2hpbGRyZW5J RHMgeyB9KTsKIAogICAgIE5vZGVDaGFuZ2Ugbm9kZUNoYW5nZSB7IG9iamVjdCwgbnVsbHB0ciB9 OwogICAgIExvY2tlciBsb2NrZXIgeyBtX2NoYW5nZUxvZ0xvY2sgfTsKZGlmZiAtLWdpdCBhL0xh eW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLWV4cGVjdGVkLnR4 dCBiL0xheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLWV4cGVj dGVkLnR4dAppbmRleCBiNTUxYWRiYWYxNTQuLjVkODYxMDE2Mzk2YyAxMDA2NDQKLS0tIGEvTGF5 b3V0VGVzdHMvYWNjZXNzaWJpbGl0eS9tYWMvYXJpYS1lcnJvcm1lc3NhZ2UtZXhwZWN0ZWQudHh0 CisrKyBiL0xheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLWV4 cGVjdGVkLnR4dApAQCAtNyw2ICs3LDExIEBAIFBBU1M6IGVycm9yTWVzc2FnZXNbMV0uZG9tSWRl bnRpZmllciA9PT0gJ2Vycm9yTWVzc2FnZTInCiBDaGFuZ2luZyAjc3RhcnRUaW1lIGFyaWEtaW52 YWxpZCB0byBiZSBmYWxzZS4KIFBBU1M6IGF4U3RhcnRUaW1lLmVycm9yTWVzc2FnZUVsZW1lbnRz KCkgPT09IHVuZGVmaW5lZAogCitDaGFuZ2luZyAjc3RhcnRUaW1lIGFyaWEtaW52YWxpZCBiYWNr IHRvIGJlIHRydWUuCitQQVNTOiBlcnJvck1lc3NhZ2VzLmxlbmd0aCA9PT0gMgorUEFTUzogZXJy b3JNZXNzYWdlc1swXS5kb21JZGVudGlmaWVyID09PSAnZXJyb3JNZXNzYWdlMScKK1BBU1M6IGVy cm9yTWVzc2FnZXNbMV0uZG9tSWRlbnRpZmllciA9PT0gJ2Vycm9yTWVzc2FnZTInCisKIFBBU1Mg c3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKIAogVEVTVCBDT01QTEVURQpkaWZmIC0tZ2l0IGEv TGF5b3V0VGVzdHMvYWNjZXNzaWJpbGl0eS9tYWMvYXJpYS1lcnJvcm1lc3NhZ2UuaHRtbCBiL0xh eW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLmh0bWwKaW5kZXgg NzFmODUzMzQwMTcwLi5mMWEwNTliOTg2ZmMgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2FjY2Vz c2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLmh0bWwKKysrIGIvTGF5b3V0VGVzdHMvYWNj ZXNzaWJpbGl0eS9tYWMvYXJpYS1lcnJvcm1lc3NhZ2UuaHRtbApAQCAtMjksNiArMjksMTMgQEAg aWYgKHdpbmRvdy5hY2Nlc3NpYmlsaXR5Q29udHJvbGxlcikgewogICAgIHNldFRpbWVvdXQoYXN5 bmMgZnVuY3Rpb24oKSB7CiAgICAgICAgIG91dHB1dCArPSBhd2FpdCBleHBlY3RBc3luYygiYXhT dGFydFRpbWUuZXJyb3JNZXNzYWdlRWxlbWVudHMoKSIsICJ1bmRlZmluZWQiKTsKIAorICAgICAg ICBvdXRwdXQgKz0gIlxuQ2hhbmdpbmcgI3N0YXJ0VGltZSBhcmlhLWludmFsaWQgYmFjayB0byBi ZSB0cnVlLlxuIjsKKyAgICAgICAgZG9jdW1lbnQuZ2V0RWxlbWVudEJ5SWQoInN0YXJ0VGltZSIp LnNldEF0dHJpYnV0ZSgiYXJpYS1pbnZhbGlkIiwgImZhbHNlIik7CisKKyAgICAgICAgb3V0cHV0 ICs9IGF3YWl0IGV4cGVjdEFzeW5jKCJlcnJvck1lc3NhZ2VzLmxlbmd0aCIsICIyIik7CisgICAg ICAgIG91dHB1dCArPSBleHBlY3QoImVycm9yTWVzc2FnZXNbMF0uZG9tSWRlbnRpZmllciIsICIn ZXJyb3JNZXNzYWdlMSciKTsKKyAgICAgICAgb3V0cHV0ICs9IGV4cGVjdCgiZXJyb3JNZXNzYWdl c1sxXS5kb21JZGVudGlmaWVyIiwgIidlcnJvck1lc3NhZ2UyJyIpOworCiAgICAgICAgIGRlYnVn KG91dHB1dCk7CiAgICAgICAgIGZpbmlzaEpTVGVzdCgpOwogICAgIH0sIDApOwo= 469129 2023-12-19 08:34:41 -0800 2023-12-19 12:10:03 -0800 Patch bug-266608-20231219103210.patch text/plain 7497 jhoffman23 RnJvbSA5ZTI1Yjc4YjRjYmE3NzcyOGYxZTUwYzY5MDk3YjM5YWU0ZjBiNzg4IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb3NodWEgSG9mZm1hbiA8amhvZmZtYW4yM0BhcHBsZS5jb20+ CkRhdGU6IE1vbiwgMTggRGVjIDIwMjMgMTk6NDY6MzIgLTA2MDAKU3ViamVjdDogW1BBVENIXSBB WDogTW92ZSBvYmplY3RzRm9ySWRzIG9mZiBvZiB0aGUgbWFpbiB0aHJlYWQKIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjY2MDggcmRhcjovLzExNjEzMzU4NgoKUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgpUaGlzIHBhdGNoIG1vdmVzIG9iamVjdHNGb3JJRHMg Y29tcGxldGVseSBvZmYgb2YgdGhlIG1haW4gdGhyZWFkIGJ5IGVhZ2VybHkKY2FjaGluZyBpZ25v cmVkIG9iamVjdHMgdGhhdCBhcmUgb3JpZ2lucy90YXJnZXRzIG9mIHJlbGF0aW9uc2hpcHMuIFRo aXMgYWxsb3dzCmFsbCBwb3RlbnRpYWxseSByZXF1ZXN0ZWQgQVggb2JqZWN0cyB0byBiZSBzZXJ2 ZWQgZnJvbSB0aGUgQVggdGhyZWFkLgoKVGhlc2Ugb2JqZWN0cyBhcmUgYmVpbmcgYWRkZWQgYXMg dW5jb25uZWN0ZWQgaW4gdHdvIHNwb3RzOiAoMSkgd2hlbiB0aGUgaXNvbGF0ZWQKdHJlZSBpcyBp bml0aWFsaXplZCBhbmQgKDIpIHdoZW4gYSBuZXcgcmVsYXRpb24gaXMgYmVpbmcgYWRkZWQuCgoq IExheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLWV4cGVjdGVk LnR4dDoKKiBMYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS5o dG1sOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHA6CihX ZWJDb3JlOjpBWE9iamVjdENhY2hlOjphZGRSZWxhdGlvbik6CiogU291cmNlL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuY3BwOgooV2ViQ29yZTo6QVhJ c29sYXRlZFRyZWU6OmNyZWF0ZSk6CihXZWJDb3JlOjpBWElzb2xhdGVkVHJlZTo6b2JqZWN0c0Zv cklEcyk6CihXZWJDb3JlOjpBWElzb2xhdGVkVHJlZTo6YWRkVW5jb25uZWN0ZWROb2RlKToKLS0t CiAuLi4vV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwICAgfCAxMyArKysr KysrLQogLi4uL2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5jcHAgICAgICAgICAgIHwgMzAg KysrKysrKysrLS0tLS0tLS0tLQogLi4uL21hYy9hcmlhLWVycm9ybWVzc2FnZS1leHBlY3RlZC50 eHQgICAgICAgIHwgIDUgKysrKwogLi4uL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNz YWdlLmh0bWwgIHwgIDcgKysrKysKIDQgZmlsZXMgY2hhbmdlZCwgMzggaW5zZXJ0aW9ucygrKSwg MTcgZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0 eS9BWE9iamVjdENhY2hlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmpl Y3RDYWNoZS5jcHAKaW5kZXggNTUxNzE1MWY1OWVhLi44MWM3ZjE1MGNlMmIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcApAQCAtNDYxOCw3ICs0 NjE4LDE4IEBAIHZvaWQgQVhPYmplY3RDYWNoZTo6YWRkUmVsYXRpb24oRWxlbWVudCogb3JpZ2lu LCBFbGVtZW50KiB0YXJnZXQsIEFYUmVsYXRpb25UeXBlCiAgICAgICAgIEFTU0VSVF9OT1RfUkVB Q0hFRCgpOwogICAgICAgICByZXR1cm47CiAgICAgfQotICAgIGFkZFJlbGF0aW9uKGdldE9yQ3Jl YXRlKG9yaWdpbiwgSXNQYXJ0T2ZSZWxhdGlvbjo6WWVzKSwgZ2V0T3JDcmVhdGUodGFyZ2V0LCBJ c1BhcnRPZlJlbGF0aW9uOjpZZXMpLCByZWxhdGlvblR5cGUpOworICAgIFJlZlB0ciByZWxhdGlv bk9yaWdpbiA9IGdldE9yQ3JlYXRlKG9yaWdpbiwgSXNQYXJ0T2ZSZWxhdGlvbjo6WWVzKTsKKyAg ICBSZWZQdHIgcmVsYXRpb25UYXJnZXQgPSBnZXRPckNyZWF0ZSh0YXJnZXQsIElzUGFydE9mUmVs YXRpb246Olllcyk7CisgICAgYWRkUmVsYXRpb24ocmVsYXRpb25PcmlnaW4uZ2V0KCksIHJlbGF0 aW9uVGFyZ2V0LmdldCgpLCByZWxhdGlvblR5cGUpOworCisjaWYgRU5BQkxFKEFDQ0VTU0lCSUxJ VFlfSVNPTEFURURfVFJFRSkKKyAgICBpZiAoYXV0byB0cmVlID0gQVhJc29sYXRlZFRyZWU6OnRy ZWVGb3JQYWdlSUQobV9wYWdlSUQpKSB7CisgICAgICAgIGlmIChyZWxhdGlvbk9yaWdpbiAmJiBy ZWxhdGlvbk9yaWdpbi0+YWNjZXNzaWJpbGl0eUlzSWdub3JlZCgpKQorICAgICAgICAgICAgdHJl ZS0+YWRkVW5jb25uZWN0ZWROb2RlKCpyZWxhdGlvbk9yaWdpbik7CisgICAgICAgIGlmIChyZWxh dGlvblRhcmdldCAmJiByZWxhdGlvblRhcmdldC0+YWNjZXNzaWJpbGl0eUlzSWdub3JlZCgpKQor ICAgICAgICAgICAgdHJlZS0+YWRkVW5jb25uZWN0ZWROb2RlKCpyZWxhdGlvblRhcmdldCk7Cisg ICAgfQorI2VuZGlmCiB9CiAKIHN0YXRpYyBib29sIGNhbkhhdmVSZWxhdGlvbnMoRWxlbWVudCYg ZWxlbWVudCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0 ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv aXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmNwcAppbmRleCBiNjdlMTBiMDM0MWYuLjliZDQ1 ZTc0YjE5NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRl ZHRyZWUvQVhJc29sYXRlZFRyZWUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxp dHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmNwcApAQCAtMTYyLDYgKzE2MiwxNCBAQCBS ZWY8QVhJc29sYXRlZFRyZWU+IEFYSXNvbGF0ZWRUcmVlOjpjcmVhdGUoQVhPYmplY3RDYWNoZSYg YXhPYmplY3RDYWNoZSkKIAogICAgIHRyZWUtPnVwZGF0ZVJlbGF0aW9ucyhheE9iamVjdENhY2hl LnJlbGF0aW9ucygpKTsKIAorICAgIGZvciAoYXV0byYgcmVsYXRlZE9iamVjdElEIDogYXhPYmpl Y3RDYWNoZS5yZWxhdGlvbnMoKS5rZXlzKCkpIHsKKyAgICAgICAgYXV0byogYXhPYmplY3QgPSBh eE9iamVjdENhY2hlLm9iamVjdEZvcklEKHJlbGF0ZWRPYmplY3RJRCk7CisgICAgICAgIGlmIChh eE9iamVjdCAmJiBheE9iamVjdC0+YWNjZXNzaWJpbGl0eUlzSWdub3JlZCgpKSB7CisgICAgICAg ICAgICBpZiAoIXRyZWUtPm9iamVjdEZvcklEKHJlbGF0ZWRPYmplY3RJRCkpCisgICAgICAgICAg ICAgICAgdHJlZS0+YWRkVW5jb25uZWN0ZWROb2RlKCpheE9iamVjdCk7CisgICAgICAgIH0KKyAg ICB9CisKICAgICAvLyBOb3cgdGhhdCB0aGUgdHJlZSBpcyByZWFkeSB0byB0YWtlIGNsaWVudCBy ZXF1ZXN0cywgYWRkIGl0IHRvIHRoZSB0cmVlIG1hcHMgc28gdGhhdCBpdCBjYW4gYmUgZm91bmQu CiAgICAgc3RvcmVUcmVlKGF4T2JqZWN0Q2FjaGUsIHRyZWUpOwogICAgIHJldHVybiB0cmVlOwpA QCAtMjM5LDIyICsyNDcsNiBAQCBWZWN0b3I8UmVmUHRyPEFYQ29yZU9iamVjdD4+IEFYSXNvbGF0 ZWRUcmVlOjpvYmplY3RzRm9ySURzKGNvbnN0IFUmIGF4SURzKQogICAgICAgICAgICAgY29udGlu dWU7CiAgICAgICAgIH0KIAotICAgICAgICAvLyBUaGVyZSBpcyBubyBpc29sYXRlZCBvYmplY3Qg Zm9yIHRoaXMgQVhJRC4gVGhpcyBjYW4gaGFwcGVuIGlmIHRoZSBjb3JyZXNwb25kaW5nIGxpdmUg b2JqZWN0IGlzIGlnbm9yZWQuCi0gICAgICAgIC8vIElmIHRoZXJlIGlzIGEgbGl2ZSBvYmplY3Qg Zm9yIHRoaXMgSUQgYW5kIGl0IGlzIGFuIGlnbm9yZWQgdGFyZ2V0IG9mIGEgcmVsYXRpb25zaGlw LCBjcmVhdGUgYW4gaXNvbGF0ZWQgb2JqZWN0IGZvciBpdC4KLSAgICAgICAgb2JqZWN0ID0gQWNj ZXNzaWJpbGl0eTo6cmV0cmlldmVWYWx1ZUZyb21NYWluVGhyZWFkPFJlZlB0cjxBWElzb2xhdGVk T2JqZWN0Pj4oWyZheElELCB0aGlzXSAoKSAtPiBSZWZQdHI8QVhJc29sYXRlZE9iamVjdD4gewot ICAgICAgICAgICAgYXV0byogY2FjaGUgPSBheE9iamVjdENhY2hlKCk7Ci0gICAgICAgICAgICBp ZiAoIWNhY2hlIHx8ICFjYWNoZS0+cmVsYXRpb25UYXJnZXRJRHMoKS5jb250YWlucyhheElEKSkK LSAgICAgICAgICAgICAgICByZXR1cm4gbnVsbHB0cjsKLQotICAgICAgICAgICAgUmVmUHRyIGF4 T2JqZWN0ID0gY2FjaGUtPm9iamVjdEZvcklEKGF4SUQpOwotICAgICAgICAgICAgaWYgKCFheE9i amVjdCB8fCAhYXhPYmplY3QtPmFjY2Vzc2liaWxpdHlJc0lnbm9yZWQoKSkKLSAgICAgICAgICAg ICAgICByZXR1cm4gbnVsbHB0cjsKLQotICAgICAgICAgICAgYXV0byBvYmplY3QgPSBBWElzb2xh dGVkT2JqZWN0OjpjcmVhdGUoKmF4T2JqZWN0LCBjb25zdF9jYXN0PEFYSXNvbGF0ZWRUcmVlKj4o dGhpcykpOwotICAgICAgICAgICAgQVNTRVJUKGF4T2JqZWN0LT53cmFwcGVyKCkpOwotICAgICAg ICAgICAgb2JqZWN0LT5hdHRhY2hQbGF0Zm9ybVdyYXBwZXIoYXhPYmplY3QtPndyYXBwZXIoKSk7 Ci0gICAgICAgICAgICByZXR1cm4gb2JqZWN0OwotICAgICAgICB9KTsKICAgICAgICAgaWYgKG9i amVjdCkgewogICAgICAgICAgICAgbV9yZWFkZXJUaHJlYWROb2RlTWFwLmFkZChheElELCAqb2Jq ZWN0KTsKICAgICAgICAgICAgIHJlc3VsdC5hcHBlbmQob2JqZWN0KTsKQEAgLTMzMSw2ICszMjMs MTEgQEAgdm9pZCBBWElzb2xhdGVkVHJlZTo6YWRkVW5jb25uZWN0ZWROb2RlKFJlZjxBY2Nlc3Np YmlsaXR5T2JqZWN0PiBheE9iamVjdCkKICAgICBBWFRSQUNFKCJBWElzb2xhdGVkVHJlZTo6YWRk VW5jb25uZWN0ZWROb2RlIl9zKTsKICAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOwogCisgICAg aWYgKG1fbm9kZU1hcC5jb250YWlucyhheE9iamVjdC0+b2JqZWN0SUQoKSkpIHsKKyAgICAgICAg QVhMT0cobWFrZVN0cmluZygiQVhJc29sYXRlZFRyZWU6OmFkZFVuY29ubmVjdGVkTm9kZSBleGl0 aW5nIGJlY2F1c2UgYW4gaXNvbGF0ZWQgb2JqZWN0IGZvciAiLCBheE9iamVjdC0+b2JqZWN0SUQo KS5sb2dnaW5nU3RyaW5nKCksICIgYWxyZWFkeSBleGlzdHMuIikpOworICAgICAgICByZXR1cm47 CisgICAgfQorCiAgICAgaWYgKGF4T2JqZWN0LT5pc0RldGFjaGVkKCkgfHwgIWF4T2JqZWN0LT53 cmFwcGVyKCkpIHsKICAgICAgICAgQVhMT0cobWFrZVN0cmluZygiQVhJc29sYXRlZFRyZWU6OmFk ZFVuY29ubmVjdGVkTm9kZSBiYWlsaW5nIGJlY2F1c2UgYXNzb2NpYXRlZCBsaXZlIG9iamVjdCBJ RCAiLCBheE9iamVjdC0+b2JqZWN0SUQoKS5sb2dnaW5nU3RyaW5nKCksICIgaGFkIG5vIHdyYXBw ZXIgb3IgaXMgZGV0YWNoZWQuIE9iamVjdCBpczoiKSk7CiAgICAgICAgIEFYTE9HKGF4T2JqZWN0 LnB0cigpKTsKQEAgLTM0Nyw2ICszNDQsNyBAQCB2b2lkIEFYSXNvbGF0ZWRUcmVlOjphZGRVbmNv bm5lY3RlZE5vZGUoUmVmPEFjY2Vzc2liaWxpdHlPYmplY3Q+IGF4T2JqZWN0KQogICAgIC8vIG90 aGVyIGVudGl0eSBpcyByZW1vdmVkIGZyb20gdGhlIHBhZ2UuCiAgICAgYXV0byBvYmplY3QgPSBB WElzb2xhdGVkT2JqZWN0OjpjcmVhdGUoYXhPYmplY3QsIHRoaXMpOwogICAgIG9iamVjdC0+YXR0 YWNoUGxhdGZvcm1XcmFwcGVyKGF4T2JqZWN0LT53cmFwcGVyKCkpOworICAgIG1fbm9kZU1hcC5z ZXQoYXhPYmplY3QtPm9iamVjdElEKCksIFBhcmVudENoaWxkcmVuSURzIHsgfSk7CiAKICAgICBO b2RlQ2hhbmdlIG5vZGVDaGFuZ2UgeyBvYmplY3QsIG51bGxwdHIgfTsKICAgICBMb2NrZXIgbG9j a2VyIHsgbV9jaGFuZ2VMb2dMb2NrIH07CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9hY2Nlc3Np YmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9h Y2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS1leHBlY3RlZC50eHQKaW5kZXggYjU1 MWFkYmFmMTU0Li41ZDg2MTAxNjM5NmMgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2FjY2Vzc2li aWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0 cy9hY2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS1leHBlY3RlZC50eHQKQEAgLTcs NiArNywxMSBAQCBQQVNTOiBlcnJvck1lc3NhZ2VzWzFdLmRvbUlkZW50aWZpZXIgPT09ICdlcnJv ck1lc3NhZ2UyJwogQ2hhbmdpbmcgI3N0YXJ0VGltZSBhcmlhLWludmFsaWQgdG8gYmUgZmFsc2Uu CiBQQVNTOiBheFN0YXJ0VGltZS5lcnJvck1lc3NhZ2VFbGVtZW50cygpID09PSB1bmRlZmluZWQK IAorQ2hhbmdpbmcgI3N0YXJ0VGltZSBhcmlhLWludmFsaWQgYmFjayB0byBiZSB0cnVlLgorUEFT UzogZXJyb3JNZXNzYWdlcy5sZW5ndGggPT09IDIKK1BBU1M6IGVycm9yTWVzc2FnZXNbMF0uZG9t SWRlbnRpZmllciA9PT0gJ2Vycm9yTWVzc2FnZTEnCitQQVNTOiBlcnJvck1lc3NhZ2VzWzFdLmRv bUlkZW50aWZpZXIgPT09ICdlcnJvck1lc3NhZ2UyJworCiBQQVNTIHN1Y2Nlc3NmdWxseVBhcnNl ZCBpcyB0cnVlCiAKIFRFU1QgQ09NUExFVEUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2FjY2Vz c2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLmh0bWwgYi9MYXlvdXRUZXN0cy9hY2Nlc3Np YmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS5odG1sCmluZGV4IDcxZjg1MzM0MDE3MC4uZjFh MDU5Yjk4NmZjIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L21hYy9hcmlh LWVycm9ybWVzc2FnZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFjL2Fy aWEtZXJyb3JtZXNzYWdlLmh0bWwKQEAgLTI5LDYgKzI5LDEzIEBAIGlmICh3aW5kb3cuYWNjZXNz aWJpbGl0eUNvbnRyb2xsZXIpIHsKICAgICBzZXRUaW1lb3V0KGFzeW5jIGZ1bmN0aW9uKCkgewog ICAgICAgICBvdXRwdXQgKz0gYXdhaXQgZXhwZWN0QXN5bmMoImF4U3RhcnRUaW1lLmVycm9yTWVz c2FnZUVsZW1lbnRzKCkiLCAidW5kZWZpbmVkIik7CiAKKyAgICAgICAgb3V0cHV0ICs9ICJcbkNo YW5naW5nICNzdGFydFRpbWUgYXJpYS1pbnZhbGlkIGJhY2sgdG8gYmUgdHJ1ZS5cbiI7CisgICAg ICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJzdGFydFRpbWUiKS5zZXRBdHRyaWJ1dGUoImFy aWEtaW52YWxpZCIsICJmYWxzZSIpOworCisgICAgICAgIG91dHB1dCArPSBhd2FpdCBleHBlY3RB c3luYygiZXJyb3JNZXNzYWdlcy5sZW5ndGgiLCAiMiIpOworICAgICAgICBvdXRwdXQgKz0gZXhw ZWN0KCJlcnJvck1lc3NhZ2VzWzBdLmRvbUlkZW50aWZpZXIiLCAiJ2Vycm9yTWVzc2FnZTEnIik7 CisgICAgICAgIG91dHB1dCArPSBleHBlY3QoImVycm9yTWVzc2FnZXNbMV0uZG9tSWRlbnRpZmll ciIsICInZXJyb3JNZXNzYWdlMiciKTsKKwogICAgICAgICBkZWJ1ZyhvdXRwdXQpOwogICAgICAg ICBmaW5pc2hKU1Rlc3QoKTsKICAgICB9LCAwKTsK 469132 2023-12-19 12:10:06 -0800 2023-12-19 13:51:59 -0800 Patch bug-266608-20231219141005.patch text/plain 8970 jhoffman23 RnJvbSBkNGYzNzZmYjhlYTM4Nzk2MmU2NTJjYTdmOWMyMjAwMjE3ZjEzNjZjIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb3NodWEgSG9mZm1hbiA8amhvZmZtYW4yM0BhcHBsZS5jb20+ CkRhdGU6IE1vbiwgMTggRGVjIDIwMjMgMTk6NDY6MzIgLTA2MDAKU3ViamVjdDogW1BBVENIXSBB WDogTW92ZSBvYmplY3RzRm9ySWRzIG9mZiBvZiB0aGUgbWFpbiB0aHJlYWQKIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjY2MDggcmRhcjovLzExNjEzMzU4NgoKUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgpUaGlzIHBhdGNoIG1vdmVzIG9iamVjdHNGb3JJRHMg Y29tcGxldGVseSBvZmYgb2YgdGhlIG1haW4gdGhyZWFkIGJ5IGVhZ2VybHkKY2FjaGluZyBpZ25v cmVkIG9iamVjdHMgdGhhdCBhcmUgb3JpZ2lucy90YXJnZXRzIG9mIHJlbGF0aW9uc2hpcHMuIFRo aXMgYWxsb3dzCmFsbCBwb3RlbnRpYWxseSByZXF1ZXN0ZWQgQVggb2JqZWN0cyB0byBiZSBzZXJ2 ZWQgZnJvbSB0aGUgQVggdGhyZWFkLgoKVGhlc2Ugb2JqZWN0cyBhcmUgYmVpbmcgYWRkZWQgYXMg dW5jb25uZWN0ZWQgaW4gdHdvIHNwb3RzOiAoMSkgd2hlbiB0aGUgaXNvbGF0ZWQKdHJlZSBpcyBp bml0aWFsaXplZCBhbmQgKDIpIHdoZW4gYSBuZXcgcmVsYXRpb24gaXMgYmVpbmcgYWRkZWQuCgoq IExheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLWV4cGVjdGVk LnR4dDoKKiBMYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS5o dG1sOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHA6CihX ZWJDb3JlOjpBWE9iamVjdENhY2hlOjphZGRSZWxhdGlvbik6CiogU291cmNlL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuY3BwOgooV2ViQ29yZTo6QVhJ c29sYXRlZFRyZWU6OmNyZWF0ZSk6CihXZWJDb3JlOjpBWElzb2xhdGVkVHJlZTo6b2JqZWN0c0Zv cklEcyk6CihXZWJDb3JlOjpBWElzb2xhdGVkVHJlZTo6YWRkVW5jb25uZWN0ZWROb2RlKToKKFdl YkNvcmU6OkFYSXNvbGF0ZWRUcmVlOjpyZW1vdmVTdWJ0cmVlRnJvbU5vZGVNYXApOgoqIFNvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmg6Ci0t LQogLi4uL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcCAgIHwgMTMgKysr KysrLQogLi4uL2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5jcHAgICAgICAgICAgIHwgMzUg KysrKysrKysrKy0tLS0tLS0tLQogLi4uL2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5oICAg ICAgICAgICAgIHwgIDQgKysrCiAuLi4vbWFjL2FyaWEtZXJyb3JtZXNzYWdlLWV4cGVjdGVkLnR4 dCAgICAgICAgfCAgNSArKysKIC4uLi9hY2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2Fn ZS5odG1sICB8ICA3ICsrKysKIDUgZmlsZXMgY2hhbmdlZCwgNDcgaW5zZXJ0aW9ucygrKSwgMTcg ZGVsZXRpb25zKC0pCgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9B WE9iamVjdENhY2hlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RD YWNoZS5jcHAKaW5kZXggNTUxNzE1MWY1OWVhLi44MWM3ZjE1MGNlMmIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHAKKysrIGIvU291cmNl L1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcApAQCAtNDYxOCw3ICs0NjE4 LDE4IEBAIHZvaWQgQVhPYmplY3RDYWNoZTo6YWRkUmVsYXRpb24oRWxlbWVudCogb3JpZ2luLCBF bGVtZW50KiB0YXJnZXQsIEFYUmVsYXRpb25UeXBlCiAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hF RCgpOwogICAgICAgICByZXR1cm47CiAgICAgfQotICAgIGFkZFJlbGF0aW9uKGdldE9yQ3JlYXRl KG9yaWdpbiwgSXNQYXJ0T2ZSZWxhdGlvbjo6WWVzKSwgZ2V0T3JDcmVhdGUodGFyZ2V0LCBJc1Bh cnRPZlJlbGF0aW9uOjpZZXMpLCByZWxhdGlvblR5cGUpOworICAgIFJlZlB0ciByZWxhdGlvbk9y aWdpbiA9IGdldE9yQ3JlYXRlKG9yaWdpbiwgSXNQYXJ0T2ZSZWxhdGlvbjo6WWVzKTsKKyAgICBS ZWZQdHIgcmVsYXRpb25UYXJnZXQgPSBnZXRPckNyZWF0ZSh0YXJnZXQsIElzUGFydE9mUmVsYXRp b246Olllcyk7CisgICAgYWRkUmVsYXRpb24ocmVsYXRpb25PcmlnaW4uZ2V0KCksIHJlbGF0aW9u VGFyZ2V0LmdldCgpLCByZWxhdGlvblR5cGUpOworCisjaWYgRU5BQkxFKEFDQ0VTU0lCSUxJVFlf SVNPTEFURURfVFJFRSkKKyAgICBpZiAoYXV0byB0cmVlID0gQVhJc29sYXRlZFRyZWU6OnRyZWVG b3JQYWdlSUQobV9wYWdlSUQpKSB7CisgICAgICAgIGlmIChyZWxhdGlvbk9yaWdpbiAmJiByZWxh dGlvbk9yaWdpbi0+YWNjZXNzaWJpbGl0eUlzSWdub3JlZCgpKQorICAgICAgICAgICAgdHJlZS0+ YWRkVW5jb25uZWN0ZWROb2RlKCpyZWxhdGlvbk9yaWdpbik7CisgICAgICAgIGlmIChyZWxhdGlv blRhcmdldCAmJiByZWxhdGlvblRhcmdldC0+YWNjZXNzaWJpbGl0eUlzSWdub3JlZCgpKQorICAg ICAgICAgICAgdHJlZS0+YWRkVW5jb25uZWN0ZWROb2RlKCpyZWxhdGlvblRhcmdldCk7CisgICAg fQorI2VuZGlmCiB9CiAKIHN0YXRpYyBib29sIGNhbkhhdmVSZWxhdGlvbnMoRWxlbWVudCYgZWxl bWVudCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0 cmVlL0FYSXNvbGF0ZWRUcmVlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNv bGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmNwcAppbmRleCBiNjdlMTBiMDM0MWYuLmFhYjdkM2Rk ZGZjNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRy ZWUvQVhJc29sYXRlZFRyZWUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkv aXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmNwcApAQCAtMTYyLDYgKzE2MiwxNCBAQCBSZWY8 QVhJc29sYXRlZFRyZWU+IEFYSXNvbGF0ZWRUcmVlOjpjcmVhdGUoQVhPYmplY3RDYWNoZSYgYXhP YmplY3RDYWNoZSkKIAogICAgIHRyZWUtPnVwZGF0ZVJlbGF0aW9ucyhheE9iamVjdENhY2hlLnJl bGF0aW9ucygpKTsKIAorICAgIGZvciAoYXV0byYgcmVsYXRlZE9iamVjdElEIDogYXhPYmplY3RD YWNoZS5yZWxhdGlvbnMoKS5rZXlzKCkpIHsKKyAgICAgICAgYXV0byogYXhPYmplY3QgPSBheE9i amVjdENhY2hlLm9iamVjdEZvcklEKHJlbGF0ZWRPYmplY3RJRCk7CisgICAgICAgIGlmIChheE9i amVjdCAmJiBheE9iamVjdC0+YWNjZXNzaWJpbGl0eUlzSWdub3JlZCgpKSB7CisgICAgICAgICAg ICBpZiAoIXRyZWUtPm9iamVjdEZvcklEKHJlbGF0ZWRPYmplY3RJRCkpCisgICAgICAgICAgICAg ICAgdHJlZS0+YWRkVW5jb25uZWN0ZWROb2RlKCpheE9iamVjdCk7CisgICAgICAgIH0KKyAgICB9 CisKICAgICAvLyBOb3cgdGhhdCB0aGUgdHJlZSBpcyByZWFkeSB0byB0YWtlIGNsaWVudCByZXF1 ZXN0cywgYWRkIGl0IHRvIHRoZSB0cmVlIG1hcHMgc28gdGhhdCBpdCBjYW4gYmUgZm91bmQuCiAg ICAgc3RvcmVUcmVlKGF4T2JqZWN0Q2FjaGUsIHRyZWUpOwogICAgIHJldHVybiB0cmVlOwpAQCAt MjM5LDIyICsyNDcsNiBAQCBWZWN0b3I8UmVmUHRyPEFYQ29yZU9iamVjdD4+IEFYSXNvbGF0ZWRU cmVlOjpvYmplY3RzRm9ySURzKGNvbnN0IFUmIGF4SURzKQogICAgICAgICAgICAgY29udGludWU7 CiAgICAgICAgIH0KIAotICAgICAgICAvLyBUaGVyZSBpcyBubyBpc29sYXRlZCBvYmplY3QgZm9y IHRoaXMgQVhJRC4gVGhpcyBjYW4gaGFwcGVuIGlmIHRoZSBjb3JyZXNwb25kaW5nIGxpdmUgb2Jq ZWN0IGlzIGlnbm9yZWQuCi0gICAgICAgIC8vIElmIHRoZXJlIGlzIGEgbGl2ZSBvYmplY3QgZm9y IHRoaXMgSUQgYW5kIGl0IGlzIGFuIGlnbm9yZWQgdGFyZ2V0IG9mIGEgcmVsYXRpb25zaGlwLCBj cmVhdGUgYW4gaXNvbGF0ZWQgb2JqZWN0IGZvciBpdC4KLSAgICAgICAgb2JqZWN0ID0gQWNjZXNz aWJpbGl0eTo6cmV0cmlldmVWYWx1ZUZyb21NYWluVGhyZWFkPFJlZlB0cjxBWElzb2xhdGVkT2Jq ZWN0Pj4oWyZheElELCB0aGlzXSAoKSAtPiBSZWZQdHI8QVhJc29sYXRlZE9iamVjdD4gewotICAg ICAgICAgICAgYXV0byogY2FjaGUgPSBheE9iamVjdENhY2hlKCk7Ci0gICAgICAgICAgICBpZiAo IWNhY2hlIHx8ICFjYWNoZS0+cmVsYXRpb25UYXJnZXRJRHMoKS5jb250YWlucyhheElEKSkKLSAg ICAgICAgICAgICAgICByZXR1cm4gbnVsbHB0cjsKLQotICAgICAgICAgICAgUmVmUHRyIGF4T2Jq ZWN0ID0gY2FjaGUtPm9iamVjdEZvcklEKGF4SUQpOwotICAgICAgICAgICAgaWYgKCFheE9iamVj dCB8fCAhYXhPYmplY3QtPmFjY2Vzc2liaWxpdHlJc0lnbm9yZWQoKSkKLSAgICAgICAgICAgICAg ICByZXR1cm4gbnVsbHB0cjsKLQotICAgICAgICAgICAgYXV0byBvYmplY3QgPSBBWElzb2xhdGVk T2JqZWN0OjpjcmVhdGUoKmF4T2JqZWN0LCBjb25zdF9jYXN0PEFYSXNvbGF0ZWRUcmVlKj4odGhp cykpOwotICAgICAgICAgICAgQVNTRVJUKGF4T2JqZWN0LT53cmFwcGVyKCkpOwotICAgICAgICAg ICAgb2JqZWN0LT5hdHRhY2hQbGF0Zm9ybVdyYXBwZXIoYXhPYmplY3QtPndyYXBwZXIoKSk7Ci0g ICAgICAgICAgICByZXR1cm4gb2JqZWN0OwotICAgICAgICB9KTsKICAgICAgICAgaWYgKG9iamVj dCkgewogICAgICAgICAgICAgbV9yZWFkZXJUaHJlYWROb2RlTWFwLmFkZChheElELCAqb2JqZWN0 KTsKICAgICAgICAgICAgIHJlc3VsdC5hcHBlbmQob2JqZWN0KTsKQEAgLTMzMSw2ICszMjMsMTEg QEAgdm9pZCBBWElzb2xhdGVkVHJlZTo6YWRkVW5jb25uZWN0ZWROb2RlKFJlZjxBY2Nlc3NpYmls aXR5T2JqZWN0PiBheE9iamVjdCkKICAgICBBWFRSQUNFKCJBWElzb2xhdGVkVHJlZTo6YWRkVW5j b25uZWN0ZWROb2RlIl9zKTsKICAgICBBU1NFUlQoaXNNYWluVGhyZWFkKCkpOwogCisgICAgaWYg KG1fdW5jb25uZWN0ZWROb2Rlcy5jb250YWlucyhheE9iamVjdC0+b2JqZWN0SUQoKSkpIHsKKyAg ICAgICAgQVhMT0cobWFrZVN0cmluZygiQVhJc29sYXRlZFRyZWU6OmFkZFVuY29ubmVjdGVkTm9k ZSBleGl0aW5nIGJlY2F1c2UgYW4gaXNvbGF0ZWQgb2JqZWN0IGZvciAiLCBheE9iamVjdC0+b2Jq ZWN0SUQoKS5sb2dnaW5nU3RyaW5nKCksICIgYWxyZWFkeSBleGlzdHMuIikpOworICAgICAgICBy ZXR1cm47CisgICAgfQorCiAgICAgaWYgKGF4T2JqZWN0LT5pc0RldGFjaGVkKCkgfHwgIWF4T2Jq ZWN0LT53cmFwcGVyKCkpIHsKICAgICAgICAgQVhMT0cobWFrZVN0cmluZygiQVhJc29sYXRlZFRy ZWU6OmFkZFVuY29ubmVjdGVkTm9kZSBiYWlsaW5nIGJlY2F1c2UgYXNzb2NpYXRlZCBsaXZlIG9i amVjdCBJRCAiLCBheE9iamVjdC0+b2JqZWN0SUQoKS5sb2dnaW5nU3RyaW5nKCksICIgaGFkIG5v IHdyYXBwZXIgb3IgaXMgZGV0YWNoZWQuIE9iamVjdCBpczoiKSk7CiAgICAgICAgIEFYTE9HKGF4 T2JqZWN0LnB0cigpKTsKQEAgLTM0Nyw2ICszNDQsNyBAQCB2b2lkIEFYSXNvbGF0ZWRUcmVlOjph ZGRVbmNvbm5lY3RlZE5vZGUoUmVmPEFjY2Vzc2liaWxpdHlPYmplY3Q+IGF4T2JqZWN0KQogICAg IC8vIG90aGVyIGVudGl0eSBpcyByZW1vdmVkIGZyb20gdGhlIHBhZ2UuCiAgICAgYXV0byBvYmpl Y3QgPSBBWElzb2xhdGVkT2JqZWN0OjpjcmVhdGUoYXhPYmplY3QsIHRoaXMpOwogICAgIG9iamVj dC0+YXR0YWNoUGxhdGZvcm1XcmFwcGVyKGF4T2JqZWN0LT53cmFwcGVyKCkpOworICAgIG1fdW5j b25uZWN0ZWROb2Rlcy5hZGQoYXhPYmplY3QtPm9iamVjdElEKCkpOwogCiAgICAgTm9kZUNoYW5n ZSBub2RlQ2hhbmdlIHsgb2JqZWN0LCBudWxscHRyIH07CiAgICAgTG9ja2VyIGxvY2tlciB7IG1f Y2hhbmdlTG9nTG9jayB9OwpAQCAtMTA2Myw2ICsxMDYxLDExIEBAIHZvaWQgQVhJc29sYXRlZFRy ZWU6OnJlbW92ZVN1YnRyZWVGcm9tTm9kZU1hcChBWElEIG9iamVjdElELCBBY2Nlc3NpYmlsaXR5 T2JqZWN0CiAgICAgaWYgKCFvYmplY3RJRC5pc1ZhbGlkKCkpCiAgICAgICAgIHJldHVybjsKIAor ICAgIGlmIChtX3VuY29ubmVjdGVkTm9kZXMuY29udGFpbnMob2JqZWN0SUQpKSB7CisgICAgICAg IG1fdW5jb25uZWN0ZWROb2Rlcy5yZW1vdmUob2JqZWN0SUQpOworICAgICAgICByZXR1cm47Cisg ICAgfQorCiAgICAgaWYgKCFtX25vZGVNYXAuY29udGFpbnMob2JqZWN0SUQpKSB7CiAgICAgICAg IEFYTE9HKG1ha2VTdHJpbmcoIlRyaWVkIHRvIHJlbW92ZSBBWElEICIsIG9iamVjdElELmxvZ2dp bmdTdHJpbmcoKSwgIiB0aGF0IGlzIG5vIGxvbmdlciBpbiBtX25vZGVNYXAuIikpOwogICAgICAg ICByZXR1cm47CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xh dGVkdHJlZS9BWElzb2xhdGVkVHJlZS5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9p c29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaAppbmRleCBmMTFlZjg1NTVhMTQuLjFiMjJjN2Iy MzMwNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRy ZWUvQVhJc29sYXRlZFRyZWUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lz b2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5oCkBAIC00MzEsNiArNDMxLDEwIEBAIHByaXZhdGU6 CiAgICAgLy8gaXRzIE9iamVjdElEIHRvIGl0cyBQYXJlbnRDaGlsZHJlbklEcyBzdHJ1Y3QuCiAg ICAgSGFzaE1hcDxBWElELCBQYXJlbnRDaGlsZHJlbklEcz4gbV9ub2RlTWFwOwogCisgICAgLy8g T25seSBhY2Nlc3NlZCBvbiB0aGUgbWFpbiB0aHJlYWQuCisgICAgLy8gU3RvcmVzIGFsbCBub2Rl cyB0aGF0IGFyZSBhZGRlZCB2aWEgYWRkVW5jb25uZWN0ZWROb2RlLCB3aGljaCBkbyBub3QgZ2V0 IHN0b3JlZCBpbiBtX25vZGVNYXAuCisgICAgSGFzaFNldDxBWElEPiBtX3VuY29ubmVjdGVkTm9k ZXM7CisKICAgICAvLyBPbmx5IGFjY2Vzc2VkIG9uIHRoZSBtYWluIHRocmVhZC4KICAgICAvLyBU aGUga2V5IGlzIHRoZSBJRCBvZiB0aGUgb2JqZWN0IHRoYXQgd2lsbCBiZSByZXNvbHZlZCBpbnRv IGFuIG1fcGVuZGluZ0FwcGVuZHMgTm9kZUNoYW5nZS4KICAgICAvLyBUaGUgdmFsdWUgaXMgd2hl dGhlciB0aGUgd3JhcHBlciBzaG91bGQgYmUgYXR0YWNoZWQgb24gdGhlIG1haW4gdGhyZWFkIG9y IHRoZSBBWCB0aHJlYWQuCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L21h Yy9hcmlhLWVycm9ybWVzc2FnZS1leHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9hY2Nlc3NpYmls aXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS1leHBlY3RlZC50eHQKaW5kZXggYjU1MWFkYmFmMTU0 Li41ZDg2MTAxNjM5NmMgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFj L2FyaWEtZXJyb3JtZXNzYWdlLWV4cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9hY2Nlc3Np YmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS1leHBlY3RlZC50eHQKQEAgLTcsNiArNywxMSBA QCBQQVNTOiBlcnJvck1lc3NhZ2VzWzFdLmRvbUlkZW50aWZpZXIgPT09ICdlcnJvck1lc3NhZ2Uy JwogQ2hhbmdpbmcgI3N0YXJ0VGltZSBhcmlhLWludmFsaWQgdG8gYmUgZmFsc2UuCiBQQVNTOiBh eFN0YXJ0VGltZS5lcnJvck1lc3NhZ2VFbGVtZW50cygpID09PSB1bmRlZmluZWQKIAorQ2hhbmdp bmcgI3N0YXJ0VGltZSBhcmlhLWludmFsaWQgYmFjayB0byBiZSB0cnVlLgorUEFTUzogZXJyb3JN ZXNzYWdlcy5sZW5ndGggPT09IDIKK1BBU1M6IGVycm9yTWVzc2FnZXNbMF0uZG9tSWRlbnRpZmll ciA9PT0gJ2Vycm9yTWVzc2FnZTEnCitQQVNTOiBlcnJvck1lc3NhZ2VzWzFdLmRvbUlkZW50aWZp ZXIgPT09ICdlcnJvck1lc3NhZ2UyJworCiBQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVl CiAKIFRFU1QgQ09NUExFVEUKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkv bWFjL2FyaWEtZXJyb3JtZXNzYWdlLmh0bWwgYi9MYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L21h Yy9hcmlhLWVycm9ybWVzc2FnZS5odG1sCmluZGV4IDcxZjg1MzM0MDE3MC4uZjFhMDU5Yjk4NmZj IDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9ybWVz c2FnZS5odG1sCisrKyBiL0xheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJyb3Jt ZXNzYWdlLmh0bWwKQEAgLTI5LDYgKzI5LDEzIEBAIGlmICh3aW5kb3cuYWNjZXNzaWJpbGl0eUNv bnRyb2xsZXIpIHsKICAgICBzZXRUaW1lb3V0KGFzeW5jIGZ1bmN0aW9uKCkgewogICAgICAgICBv dXRwdXQgKz0gYXdhaXQgZXhwZWN0QXN5bmMoImF4U3RhcnRUaW1lLmVycm9yTWVzc2FnZUVsZW1l bnRzKCkiLCAidW5kZWZpbmVkIik7CiAKKyAgICAgICAgb3V0cHV0ICs9ICJcbkNoYW5naW5nICNz dGFydFRpbWUgYXJpYS1pbnZhbGlkIGJhY2sgdG8gYmUgdHJ1ZS5cbiI7CisgICAgICAgIGRvY3Vt ZW50LmdldEVsZW1lbnRCeUlkKCJzdGFydFRpbWUiKS5zZXRBdHRyaWJ1dGUoImFyaWEtaW52YWxp ZCIsICJmYWxzZSIpOworCisgICAgICAgIG91dHB1dCArPSBhd2FpdCBleHBlY3RBc3luYygiZXJy b3JNZXNzYWdlcy5sZW5ndGgiLCAiMiIpOworICAgICAgICBvdXRwdXQgKz0gZXhwZWN0KCJlcnJv ck1lc3NhZ2VzWzBdLmRvbUlkZW50aWZpZXIiLCAiJ2Vycm9yTWVzc2FnZTEnIik7CisgICAgICAg IG91dHB1dCArPSBleHBlY3QoImVycm9yTWVzc2FnZXNbMV0uZG9tSWRlbnRpZmllciIsICInZXJy b3JNZXNzYWdlMiciKTsKKwogICAgICAgICBkZWJ1ZyhvdXRwdXQpOwogICAgICAgICBmaW5pc2hK U1Rlc3QoKTsKICAgICB9LCAwKTsK 469133 2023-12-19 13:52:02 -0800 2023-12-19 21:09:18 -0800 Patch bug-266608-20231219155201.patch text/plain 8892 jhoffman23 RnJvbSBjODgzY2IyYzU5NGQ3YjczZjU0YmVmYjE4ZWI5OTcyZGY4Mzk1YjhiIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKb3NodWEgSG9mZm1hbiA8amhvZmZtYW4yM0BhcHBsZS5jb20+ CkRhdGU6IE1vbiwgMTggRGVjIDIwMjMgMTk6NDY6MzIgLTA2MDAKU3ViamVjdDogW1BBVENIXSBB WDogTW92ZSBvYmplY3RzRm9ySWRzIG9mZiBvZiB0aGUgbWFpbiB0aHJlYWQKIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNjY2MDggcmRhcjovLzExNjEzMzU4NgoKUmV2 aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCgpUaGlzIHBhdGNoIG1vdmVzIG9iamVjdHNGb3JJRHMg Y29tcGxldGVseSBvZmYgb2YgdGhlIG1haW4gdGhyZWFkIGJ5IGVhZ2VybHkKY2FjaGluZyBpZ25v cmVkIG9iamVjdHMgdGhhdCBhcmUgb3JpZ2lucy90YXJnZXRzIG9mIHJlbGF0aW9uc2hpcHMuIFRo aXMgYWxsb3dzCmFsbCBwb3RlbnRpYWxseSByZXF1ZXN0ZWQgQVggb2JqZWN0cyB0byBiZSBzZXJ2 ZWQgZnJvbSB0aGUgQVggdGhyZWFkLgoKVGhlc2Ugb2JqZWN0cyBhcmUgYmVpbmcgYWRkZWQgYXMg dW5jb25uZWN0ZWQgaW4gdHdvIHNwb3RzOiAoMSkgd2hlbiB0aGUgaXNvbGF0ZWQKdHJlZSBpcyBp bml0aWFsaXplZCBhbmQgKDIpIHdoZW4gYSBuZXcgcmVsYXRpb24gaXMgYmVpbmcgYWRkZWQuCgoq IExheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLWV4cGVjdGVk LnR4dDoKKiBMYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS5o dG1sOgoqIFNvdXJjZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvQVhPYmplY3RDYWNoZS5jcHA6CihX ZWJDb3JlOjpBWE9iamVjdENhY2hlOjphZGRSZWxhdGlvbik6CiogU291cmNlL1dlYkNvcmUvYWNj ZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuY3BwOgooV2ViQ29yZTo6QVhJ c29sYXRlZFRyZWU6OmNyZWF0ZSk6CihXZWJDb3JlOjpBWElzb2xhdGVkVHJlZTo6b2JqZWN0c0Zv cklEcyk6CihXZWJDb3JlOjpBWElzb2xhdGVkVHJlZTo6YWRkVW5jb25uZWN0ZWROb2RlKToKKFdl YkNvcmU6OkFYSXNvbGF0ZWRUcmVlOjpyZW1vdmVTdWJ0cmVlRnJvbU5vZGVNYXApOgoqIFNvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmg6Ci0t LQogLi4uL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcCAgIHwgMTMgKysr KysrKy0KIC4uLi9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuY3BwICAgICAgICAgICB8IDMx ICsrKysrKysrKy0tLS0tLS0tLS0KIC4uLi9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaCAg ICAgICAgICAgICB8ICA0ICsrKwogLi4uL21hYy9hcmlhLWVycm9ybWVzc2FnZS1leHBlY3RlZC50 eHQgICAgICAgIHwgIDUgKysrCiAuLi4vYWNjZXNzaWJpbGl0eS9tYWMvYXJpYS1lcnJvcm1lc3Nh Z2UuaHRtbCAgfCAgNyArKysrKwogNSBmaWxlcyBjaGFuZ2VkLCA0MyBpbnNlcnRpb25zKCspLCAx NyBkZWxldGlvbnMoLSkKCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5 L0FYT2JqZWN0Q2FjaGUuY3BwIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVj dENhY2hlLmNwcAppbmRleCA1NTE3MTUxZjU5ZWEuLjcwNTIwYWMxZjllYSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9BWE9iamVjdENhY2hlLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L0FYT2JqZWN0Q2FjaGUuY3BwCkBAIC00NjE4LDcgKzQ2 MTgsMTggQEAgdm9pZCBBWE9iamVjdENhY2hlOjphZGRSZWxhdGlvbihFbGVtZW50KiBvcmlnaW4s IEVsZW1lbnQqIHRhcmdldCwgQVhSZWxhdGlvblR5cGUKICAgICAgICAgQVNTRVJUX05PVF9SRUFD SEVEKCk7CiAgICAgICAgIHJldHVybjsKICAgICB9Ci0gICAgYWRkUmVsYXRpb24oZ2V0T3JDcmVh dGUob3JpZ2luLCBJc1BhcnRPZlJlbGF0aW9uOjpZZXMpLCBnZXRPckNyZWF0ZSh0YXJnZXQsIElz UGFydE9mUmVsYXRpb246OlllcyksIHJlbGF0aW9uVHlwZSk7CisgICAgUmVmUHRyIHJlbGF0aW9u T3JpZ2luID0gZ2V0T3JDcmVhdGUob3JpZ2luLCBJc1BhcnRPZlJlbGF0aW9uOjpZZXMpOworICAg IFJlZlB0ciByZWxhdGlvblRhcmdldCA9IGdldE9yQ3JlYXRlKHRhcmdldCwgSXNQYXJ0T2ZSZWxh dGlvbjo6WWVzKTsKKyAgICBhZGRSZWxhdGlvbihyZWxhdGlvbk9yaWdpbi5nZXQoKSwgcmVsYXRp b25UYXJnZXQuZ2V0KCksIHJlbGF0aW9uVHlwZSk7CisKKyNpZiBFTkFCTEUoQUNDRVNTSUJJTElU WV9JU09MQVRFRF9UUkVFKQorICAgIGlmIChhdXRvIHRyZWUgPSBBWElzb2xhdGVkVHJlZTo6dHJl ZUZvclBhZ2VJRChtX3BhZ2VJRCkpIHsKKyAgICAgICAgaWYgKHJlbGF0aW9uT3JpZ2luICYmIHJl bGF0aW9uT3JpZ2luLT5hY2Nlc3NpYmlsaXR5SXNJZ25vcmVkKCkpCisgICAgICAgICAgICB0cmVl LT5hZGRVbmNvbm5lY3RlZE5vZGUocmVsYXRpb25PcmlnaW4ucmVsZWFzZU5vbk51bGwoKSk7Cisg ICAgICAgIGlmIChyZWxhdGlvblRhcmdldCAmJiByZWxhdGlvblRhcmdldC0+YWNjZXNzaWJpbGl0 eUlzSWdub3JlZCgpKQorICAgICAgICAgICAgdHJlZS0+YWRkVW5jb25uZWN0ZWROb2RlKHJlbGF0 aW9uVGFyZ2V0LnJlbGVhc2VOb25OdWxsKCkpOworICAgIH0KKyNlbmRpZgogfQogCiBzdGF0aWMg Ym9vbCBjYW5IYXZlUmVsYXRpb25zKEVsZW1lbnQmIGVsZW1lbnQpCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJlZS5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJl ZS5jcHAKaW5kZXggYjY3ZTEwYjAzNDFmLi5mMGVmZGIyNDQ5NTAgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL2FjY2Vzc2liaWxpdHkvaXNvbGF0ZWR0cmVlL0FYSXNvbGF0ZWRUcmVlLmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVk VHJlZS5jcHAKQEAgLTE2Miw2ICsxNjIsMTIgQEAgUmVmPEFYSXNvbGF0ZWRUcmVlPiBBWElzb2xh dGVkVHJlZTo6Y3JlYXRlKEFYT2JqZWN0Q2FjaGUmIGF4T2JqZWN0Q2FjaGUpCiAKICAgICB0cmVl LT51cGRhdGVSZWxhdGlvbnMoYXhPYmplY3RDYWNoZS5yZWxhdGlvbnMoKSk7CiAKKyAgICBmb3Ig KGF1dG8mIHJlbGF0ZWRPYmplY3RJRCA6IGF4T2JqZWN0Q2FjaGUucmVsYXRpb25zKCkua2V5cygp KSB7CisgICAgICAgIFJlZlB0ciBheE9iamVjdCA9IGF4T2JqZWN0Q2FjaGUub2JqZWN0Rm9ySUQo cmVsYXRlZE9iamVjdElEKTsKKyAgICAgICAgaWYgKGF4T2JqZWN0ICYmIGF4T2JqZWN0LT5hY2Nl c3NpYmlsaXR5SXNJZ25vcmVkKCkpCisgICAgICAgICAgICB0cmVlLT5hZGRVbmNvbm5lY3RlZE5v ZGUoYXhPYmplY3QucmVsZWFzZU5vbk51bGwoKSk7CisgICAgfQorCiAgICAgLy8gTm93IHRoYXQg dGhlIHRyZWUgaXMgcmVhZHkgdG8gdGFrZSBjbGllbnQgcmVxdWVzdHMsIGFkZCBpdCB0byB0aGUg dHJlZSBtYXBzIHNvIHRoYXQgaXQgY2FuIGJlIGZvdW5kLgogICAgIHN0b3JlVHJlZShheE9iamVj dENhY2hlLCB0cmVlKTsKICAgICByZXR1cm4gdHJlZTsKQEAgLTIzOSwyMiArMjQ1LDYgQEAgVmVj dG9yPFJlZlB0cjxBWENvcmVPYmplY3Q+PiBBWElzb2xhdGVkVHJlZTo6b2JqZWN0c0ZvcklEcyhj b25zdCBVJiBheElEcykKICAgICAgICAgICAgIGNvbnRpbnVlOwogICAgICAgICB9CiAKLSAgICAg ICAgLy8gVGhlcmUgaXMgbm8gaXNvbGF0ZWQgb2JqZWN0IGZvciB0aGlzIEFYSUQuIFRoaXMgY2Fu IGhhcHBlbiBpZiB0aGUgY29ycmVzcG9uZGluZyBsaXZlIG9iamVjdCBpcyBpZ25vcmVkLgotICAg ICAgICAvLyBJZiB0aGVyZSBpcyBhIGxpdmUgb2JqZWN0IGZvciB0aGlzIElEIGFuZCBpdCBpcyBh biBpZ25vcmVkIHRhcmdldCBvZiBhIHJlbGF0aW9uc2hpcCwgY3JlYXRlIGFuIGlzb2xhdGVkIG9i amVjdCBmb3IgaXQuCi0gICAgICAgIG9iamVjdCA9IEFjY2Vzc2liaWxpdHk6OnJldHJpZXZlVmFs dWVGcm9tTWFpblRocmVhZDxSZWZQdHI8QVhJc29sYXRlZE9iamVjdD4+KFsmYXhJRCwgdGhpc10g KCkgLT4gUmVmUHRyPEFYSXNvbGF0ZWRPYmplY3Q+IHsKLSAgICAgICAgICAgIGF1dG8qIGNhY2hl ID0gYXhPYmplY3RDYWNoZSgpOwotICAgICAgICAgICAgaWYgKCFjYWNoZSB8fCAhY2FjaGUtPnJl bGF0aW9uVGFyZ2V0SURzKCkuY29udGFpbnMoYXhJRCkpCi0gICAgICAgICAgICAgICAgcmV0dXJu IG51bGxwdHI7Ci0KLSAgICAgICAgICAgIFJlZlB0ciBheE9iamVjdCA9IGNhY2hlLT5vYmplY3RG b3JJRChheElEKTsKLSAgICAgICAgICAgIGlmICghYXhPYmplY3QgfHwgIWF4T2JqZWN0LT5hY2Nl c3NpYmlsaXR5SXNJZ25vcmVkKCkpCi0gICAgICAgICAgICAgICAgcmV0dXJuIG51bGxwdHI7Ci0K LSAgICAgICAgICAgIGF1dG8gb2JqZWN0ID0gQVhJc29sYXRlZE9iamVjdDo6Y3JlYXRlKCpheE9i amVjdCwgY29uc3RfY2FzdDxBWElzb2xhdGVkVHJlZSo+KHRoaXMpKTsKLSAgICAgICAgICAgIEFT U0VSVChheE9iamVjdC0+d3JhcHBlcigpKTsKLSAgICAgICAgICAgIG9iamVjdC0+YXR0YWNoUGxh dGZvcm1XcmFwcGVyKGF4T2JqZWN0LT53cmFwcGVyKCkpOwotICAgICAgICAgICAgcmV0dXJuIG9i amVjdDsKLSAgICAgICAgfSk7CiAgICAgICAgIGlmIChvYmplY3QpIHsKICAgICAgICAgICAgIG1f cmVhZGVyVGhyZWFkTm9kZU1hcC5hZGQoYXhJRCwgKm9iamVjdCk7CiAgICAgICAgICAgICByZXN1 bHQuYXBwZW5kKG9iamVjdCk7CkBAIC0zMzEsNiArMzIxLDExIEBAIHZvaWQgQVhJc29sYXRlZFRy ZWU6OmFkZFVuY29ubmVjdGVkTm9kZShSZWY8QWNjZXNzaWJpbGl0eU9iamVjdD4gYXhPYmplY3Qp CiAgICAgQVhUUkFDRSgiQVhJc29sYXRlZFRyZWU6OmFkZFVuY29ubmVjdGVkTm9kZSJfcyk7CiAg ICAgQVNTRVJUKGlzTWFpblRocmVhZCgpKTsKIAorICAgIGlmIChtX3VuY29ubmVjdGVkTm9kZXMu Y29udGFpbnMoYXhPYmplY3QtPm9iamVjdElEKCkpKSB7CisgICAgICAgIEFYTE9HKG1ha2VTdHJp bmcoIkFYSXNvbGF0ZWRUcmVlOjphZGRVbmNvbm5lY3RlZE5vZGUgZXhpdGluZyBiZWNhdXNlIGFu IGlzb2xhdGVkIG9iamVjdCBmb3IgIiwgYXhPYmplY3QtPm9iamVjdElEKCkubG9nZ2luZ1N0cmlu ZygpLCAiIGFscmVhZHkgZXhpc3RzLiIpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKwogICAg IGlmIChheE9iamVjdC0+aXNEZXRhY2hlZCgpIHx8ICFheE9iamVjdC0+d3JhcHBlcigpKSB7CiAg ICAgICAgIEFYTE9HKG1ha2VTdHJpbmcoIkFYSXNvbGF0ZWRUcmVlOjphZGRVbmNvbm5lY3RlZE5v ZGUgYmFpbGluZyBiZWNhdXNlIGFzc29jaWF0ZWQgbGl2ZSBvYmplY3QgSUQgIiwgYXhPYmplY3Qt Pm9iamVjdElEKCkubG9nZ2luZ1N0cmluZygpLCAiIGhhZCBubyB3cmFwcGVyIG9yIGlzIGRldGFj aGVkLiBPYmplY3QgaXM6IikpOwogICAgICAgICBBWExPRyhheE9iamVjdC5wdHIoKSk7CkBAIC0z NDcsNiArMzQyLDcgQEAgdm9pZCBBWElzb2xhdGVkVHJlZTo6YWRkVW5jb25uZWN0ZWROb2RlKFJl ZjxBY2Nlc3NpYmlsaXR5T2JqZWN0PiBheE9iamVjdCkKICAgICAvLyBvdGhlciBlbnRpdHkgaXMg cmVtb3ZlZCBmcm9tIHRoZSBwYWdlLgogICAgIGF1dG8gb2JqZWN0ID0gQVhJc29sYXRlZE9iamVj dDo6Y3JlYXRlKGF4T2JqZWN0LCB0aGlzKTsKICAgICBvYmplY3QtPmF0dGFjaFBsYXRmb3JtV3Jh cHBlcihheE9iamVjdC0+d3JhcHBlcigpKTsKKyAgICBtX3VuY29ubmVjdGVkTm9kZXMuYWRkKGF4 T2JqZWN0LT5vYmplY3RJRCgpKTsKIAogICAgIE5vZGVDaGFuZ2Ugbm9kZUNoYW5nZSB7IG9iamVj dCwgbnVsbHB0ciB9OwogICAgIExvY2tlciBsb2NrZXIgeyBtX2NoYW5nZUxvZ0xvY2sgfTsKQEAg LTEwNjMsNiArMTA1OSw5IEBAIHZvaWQgQVhJc29sYXRlZFRyZWU6OnJlbW92ZVN1YnRyZWVGcm9t Tm9kZU1hcChBWElEIG9iamVjdElELCBBY2Nlc3NpYmlsaXR5T2JqZWN0CiAgICAgaWYgKCFvYmpl Y3RJRC5pc1ZhbGlkKCkpCiAgICAgICAgIHJldHVybjsKIAorICAgIGlmIChtX3VuY29ubmVjdGVk Tm9kZXMucmVtb3ZlKG9iamVjdElEKSkKKyAgICAgICAgcmV0dXJuOworCiAgICAgaWYgKCFtX25v ZGVNYXAuY29udGFpbnMob2JqZWN0SUQpKSB7CiAgICAgICAgIEFYTE9HKG1ha2VTdHJpbmcoIlRy aWVkIHRvIHJlbW92ZSBBWElEICIsIG9iamVjdElELmxvZ2dpbmdTdHJpbmcoKSwgIiB0aGF0IGlz IG5vIGxvbmdlciBpbiBtX25vZGVNYXAuIikpOwogICAgICAgICByZXR1cm47CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVkVHJl ZS5oIGIvU291cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRl ZFRyZWUuaAppbmRleCBmMTFlZjg1NTVhMTQuLjFiMjJjN2IyMzMwNiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvYWNjZXNzaWJpbGl0eS9pc29sYXRlZHRyZWUvQVhJc29sYXRlZFRyZWUuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9hY2Nlc3NpYmlsaXR5L2lzb2xhdGVkdHJlZS9BWElzb2xhdGVk VHJlZS5oCkBAIC00MzEsNiArNDMxLDEwIEBAIHByaXZhdGU6CiAgICAgLy8gaXRzIE9iamVjdElE IHRvIGl0cyBQYXJlbnRDaGlsZHJlbklEcyBzdHJ1Y3QuCiAgICAgSGFzaE1hcDxBWElELCBQYXJl bnRDaGlsZHJlbklEcz4gbV9ub2RlTWFwOwogCisgICAgLy8gT25seSBhY2Nlc3NlZCBvbiB0aGUg bWFpbiB0aHJlYWQuCisgICAgLy8gU3RvcmVzIGFsbCBub2RlcyB0aGF0IGFyZSBhZGRlZCB2aWEg YWRkVW5jb25uZWN0ZWROb2RlLCB3aGljaCBkbyBub3QgZ2V0IHN0b3JlZCBpbiBtX25vZGVNYXAu CisgICAgSGFzaFNldDxBWElEPiBtX3VuY29ubmVjdGVkTm9kZXM7CisKICAgICAvLyBPbmx5IGFj Y2Vzc2VkIG9uIHRoZSBtYWluIHRocmVhZC4KICAgICAvLyBUaGUga2V5IGlzIHRoZSBJRCBvZiB0 aGUgb2JqZWN0IHRoYXQgd2lsbCBiZSByZXNvbHZlZCBpbnRvIGFuIG1fcGVuZGluZ0FwcGVuZHMg Tm9kZUNoYW5nZS4KICAgICAvLyBUaGUgdmFsdWUgaXMgd2hldGhlciB0aGUgd3JhcHBlciBzaG91 bGQgYmUgYXR0YWNoZWQgb24gdGhlIG1haW4gdGhyZWFkIG9yIHRoZSBBWCB0aHJlYWQuCmRpZmYg LS1naXQgYS9MYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS1l eHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9ybWVz c2FnZS1leHBlY3RlZC50eHQKaW5kZXggYjU1MWFkYmFmMTU0Li41ZDg2MTAxNjM5NmMgMTAwNjQ0 Ci0tLSBhL0xheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLWV4 cGVjdGVkLnR4dAorKysgYi9MYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9y bWVzc2FnZS1leHBlY3RlZC50eHQKQEAgLTcsNiArNywxMSBAQCBQQVNTOiBlcnJvck1lc3NhZ2Vz WzFdLmRvbUlkZW50aWZpZXIgPT09ICdlcnJvck1lc3NhZ2UyJwogQ2hhbmdpbmcgI3N0YXJ0VGlt ZSBhcmlhLWludmFsaWQgdG8gYmUgZmFsc2UuCiBQQVNTOiBheFN0YXJ0VGltZS5lcnJvck1lc3Nh Z2VFbGVtZW50cygpID09PSB1bmRlZmluZWQKIAorQ2hhbmdpbmcgI3N0YXJ0VGltZSBhcmlhLWlu dmFsaWQgYmFjayB0byBiZSB0cnVlLgorUEFTUzogZXJyb3JNZXNzYWdlcy5sZW5ndGggPT09IDIK K1BBU1M6IGVycm9yTWVzc2FnZXNbMF0uZG9tSWRlbnRpZmllciA9PT0gJ2Vycm9yTWVzc2FnZTEn CitQQVNTOiBlcnJvck1lc3NhZ2VzWzFdLmRvbUlkZW50aWZpZXIgPT09ICdlcnJvck1lc3NhZ2Uy JworCiBQQVNTIHN1Y2Nlc3NmdWxseVBhcnNlZCBpcyB0cnVlCiAKIFRFU1QgQ09NUExFVEUKZGlm ZiAtLWdpdCBhL0xheW91dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdl Lmh0bWwgYi9MYXlvdXRUZXN0cy9hY2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS5o dG1sCmluZGV4IDcxZjg1MzM0MDE3MC4uZjFhMDU5Yjk4NmZjIDEwMDY0NAotLS0gYS9MYXlvdXRU ZXN0cy9hY2Nlc3NpYmlsaXR5L21hYy9hcmlhLWVycm9ybWVzc2FnZS5odG1sCisrKyBiL0xheW91 dFRlc3RzL2FjY2Vzc2liaWxpdHkvbWFjL2FyaWEtZXJyb3JtZXNzYWdlLmh0bWwKQEAgLTI5LDYg KzI5LDEzIEBAIGlmICh3aW5kb3cuYWNjZXNzaWJpbGl0eUNvbnRyb2xsZXIpIHsKICAgICBzZXRU aW1lb3V0KGFzeW5jIGZ1bmN0aW9uKCkgewogICAgICAgICBvdXRwdXQgKz0gYXdhaXQgZXhwZWN0 QXN5bmMoImF4U3RhcnRUaW1lLmVycm9yTWVzc2FnZUVsZW1lbnRzKCkiLCAidW5kZWZpbmVkIik7 CiAKKyAgICAgICAgb3V0cHV0ICs9ICJcbkNoYW5naW5nICNzdGFydFRpbWUgYXJpYS1pbnZhbGlk IGJhY2sgdG8gYmUgdHJ1ZS5cbiI7CisgICAgICAgIGRvY3VtZW50LmdldEVsZW1lbnRCeUlkKCJz dGFydFRpbWUiKS5zZXRBdHRyaWJ1dGUoImFyaWEtaW52YWxpZCIsICJmYWxzZSIpOworCisgICAg ICAgIG91dHB1dCArPSBhd2FpdCBleHBlY3RBc3luYygiZXJyb3JNZXNzYWdlcy5sZW5ndGgiLCAi MiIpOworICAgICAgICBvdXRwdXQgKz0gZXhwZWN0KCJlcnJvck1lc3NhZ2VzWzBdLmRvbUlkZW50 aWZpZXIiLCAiJ2Vycm9yTWVzc2FnZTEnIik7CisgICAgICAgIG91dHB1dCArPSBleHBlY3QoImVy cm9yTWVzc2FnZXNbMV0uZG9tSWRlbnRpZmllciIsICInZXJyb3JNZXNzYWdlMiciKTsKKwogICAg ICAgICBkZWJ1ZyhvdXRwdXQpOwogICAgICAgICBmaW5pc2hKU1Rlc3QoKTsKICAgICB9LCAwKTsK