112081 2013-03-11 16:56:20 -0700 Printing to PDF should produce internal links when HTML has internal links 2016-11-05 13:05:56 -0700 1 1 1 Unclassified WebKit Printing 528+ (Nightly build) All All RESOLVED FIXED InRadar P2 Enhancement --- 1 dml+webkit thorton ap cdumez cmarcelo commit-queue darin dbates ddkilzer dglazkov dml+webkit eric esprehn+autocc glenn junov kangil.han kondapallykalyan ojan.autocc peter+ews scotty.hyndman senorblanco simon.fraser thorton webkit.review.bot oldest_to_newest 852886 0 dml+webkit 2013-03-11 16:56:20 -0700 Currently when outputting to PDF with Skia, WebKit treats links to elsewhere in the same HTML document the same as links to elsewhere on the Web. For example, a HTML page with a table of contents that links to headings later in the page will result in a PDF with links back to the original HTML page. A nicer user experience would be for these links to be put out as internal PDF links, so if the user clicks one, they are taken to the relevant page within the PDF. Proposed solution: 1) When any element with an ID is encountered, output a named destination to the PDF. For example <h1 id="summary">Summary</h1> would result in a destination named "summary" in the PDF. Even if there are no links within the document to this ID, having this named destination allows links elsewhere on the Web to point to this part of the document (e.g. http://example.com/document.pdf#nameddest=summary). 2) When a link is encountered that points to the current document, the URL fragment (part after the "#") is taken and a link is produced that points to the corresponding named destination. Note, I already have code to do this. APIs to support this have already been added to Skia in change: https://code.google.com/p/skia/source/detail?r=8034 852914 1 192604 dml+webkit 2013-03-11 17:26:48 -0700 Created attachment 192604 Patch 852958 2 192604 webkit.review.bot 2013-03-11 18:30:24 -0700 Comment on attachment 192604 Patch Attachment 192604 did not pass cr-linux-debug-ews (chromium-xvfb): Output: http://webkit-commit-queue.appspot.com/results/17169360 852972 3 192604 peter+ews 2013-03-11 18:44:01 -0700 Comment on attachment 192604 Patch Attachment 192604 did not pass cr-android-ews (chromium-android): Output: http://webkit-commit-queue.appspot.com/results/17121466 852994 4 192604 webkit.review.bot 2013-03-11 19:06:20 -0700 Comment on attachment 192604 Patch Attachment 192604 did not pass chromium-ews (chromium-xvfb): Output: http://webkit-commit-queue.appspot.com/results/17013944 853009 5 dml+webkit 2013-03-11 19:30:18 -0700 Compilation failures looks like my Skia change (landed three days ago) is not present. Is updating to the latest version of Skia a manual process? 853055 6 192604 ap 2013-03-11 22:10:03 -0700 Comment on attachment 192604 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=192604&action=review Looks fine in general. > Source/WebCore/ChangeLog:8 > + This change doesn't have any tests because PDF generation doesn't have any existing tests. How did you test manually? > Source/WebCore/platform/graphics/GraphicsContext.h:271 > + void setShouldOutputInternalLinks(bool); This function is never called in this patch. > Source/WebCore/platform/graphics/GraphicsContext.h:431 > void setURLForRect(const KURL&, const IntRect&); > > + void setLinkToDestination(const char*, const IntRect&); This first parameter needs a name, it's not easily deducible from type. The parameter should be a String, it's the job of GraphicsContext to convert it to a type suitable for a specific platform. It would be better to have these functions follow a common style. I'd name the new one "setDestinationForRect". > Source/WebCore/platform/graphics/GraphicsContext.h:432 > + void addDestination(const String&, IntPoint); addDestinationAtPoint? Also, we normally pass IntPoint as const reference, too. > Source/WebCore/rendering/RenderObject.cpp:1118 > + KURL url = n->document()->completeURL(href); > + CString urlString = url.string().utf8(); The URL may be invalid, which needs to be accounted for. > Source/WebCore/rendering/RenderObject.cpp:1120 > + context->setLinkToDestination(strchr(urlString.data(), '#') + 1, pixelSnappedIntRect(rect)); A better way to determine what the identifier is is would be via KURL::fragmentIdentifier(). > Source/WebCore/rendering/RenderObject.cpp:1127 > + Node* n = this->node(); The reason to say "this->node()" is to avoid conflicts with a local variable of the same name, which you don't have here. But using abbreviations is discouraged in WebKit code, so you should. > Source/WebCore/rendering/RenderObject.cpp:1139 > + this->addDestination(graphicsContext); No reason for "this->" here. > Source/WebCore/rendering/RenderObject.cpp:1142 > + while (child) { > + child->addDestinationsRecursive(graphicsContext); Wow, adding a destination for every element with an id is quite some work. You explained the reason in the bug, but I'm not convinced. If there is already an HTML document on the Web, other pages should link to it, not to a PDF. And if it's not on the Web, a real authoring tool should be used to produce the file to publish, not a browser's "Save As" command. Also, anchors link to names, not to ids. > Source/WebCore/rendering/RenderObject.h:983 > + void addDestination(GraphicsContext*); This function is never called from outside, and should be private. 853466 7 senorblanco 2013-03-12 08:02:38 -0700 (In reply to comment #5) > Compilation failures looks like my Skia change (landed three days ago) is not present. Is updating to the latest version of Skia a manual process? Skia is rolled manually, usually once a day, into Chrome. You can check which version Chrome is using by examining the src/DEPS file in a Chrome checkout. Skia is also rolled manually into WebKit, via the Source/WebKit/chromium/DEPS file. This happens more infrequently, and you may have to ask someone to do it for you, or add it to your change. This is the version used by the EWS bots, so that will have to happen before you can satisfy the EWS bots on this patch. 853468 8 senorblanco 2013-03-12 08:04:18 -0700 (In reply to comment #7) > Skia is also rolled manually into WebKit, via the Source/WebKit/chromium/DEPS file. This happens more infrequently, and you may have to ask someone to do it for you, or add it to your change. This is the version used by the EWS bots, so that will have to happen before you can satisfy the EWS bots on this patch. Let me amend that: *chrome* is rolled into WebKit via Source/WebKit/chromium/DEPS, which pulls with it the current version of Skia that Chrome is using (in its src/DEPS file). 854037 9 192865 dml+webkit 2013-03-12 21:08:30 -0700 Created attachment 192865 Patch 854039 10 192604 dml+webkit 2013-03-12 21:13:38 -0700 Comment on attachment 192604 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=192604&action=review >> Source/WebCore/ChangeLog:8 >> + This change doesn't have any tests because PDF generation doesn't have any existing tests. > > How did you test manually? I wrote a test HTML file with various different elements (<h1>, <p>, <a>, <div>, <td>). These had IDs. One of the <a> elements had a name instead. I then had links to each of these. I also had an element with an ID but no link to it and a link to something that didn't exist. I generated PDFs from this HTML using both a headless version of WebKit and file->print->save as PDF in Chromium. I then opened these PDFs in a text editor to make sure the links and the destinations looked right (and to make sure there was no destination defined for the element with no link to it). I then opened the PDFs in Evince, Acroread and the PDF viewer on Mac OS and confirmed that clicking the links scrolled to the appropriate page (or in the case of Evince to the actual element itself). >> Source/WebCore/platform/graphics/GraphicsContext.h:271 >> + void setShouldOutputInternalLinks(bool); > > This function is never called in this patch. Was thinking of providing a way to disable it in case some users of WebKit didn't want it. Probably less needed now that I'm only outputting named destinations that are used. Removed this. >> Source/WebCore/platform/graphics/GraphicsContext.h:431 >> + void setLinkToDestination(const char*, const IntRect&); > > This first parameter needs a name, it's not easily deducible from type. The parameter should be a String, it's the job of GraphicsContext to convert it to a type suitable for a specific platform. > > It would be better to have these functions follow a common style. I'd name the new one "setDestinationForRect". Done >> Source/WebCore/platform/graphics/GraphicsContext.h:432 >> + void addDestination(const String&, IntPoint); > > addDestinationAtPoint? Also, we normally pass IntPoint as const reference, too. Done >> Source/WebCore/rendering/RenderObject.cpp:1118 >> + CString urlString = url.string().utf8(); > > The URL may be invalid, which needs to be accounted for. Done >> Source/WebCore/rendering/RenderObject.cpp:1120 >> + context->setLinkToDestination(strchr(urlString.data(), '#') + 1, pixelSnappedIntRect(rect)); > > A better way to determine what the identifier is is would be via KURL::fragmentIdentifier(). Done >> Source/WebCore/rendering/RenderObject.cpp:1127 >> + Node* n = this->node(); > > The reason to say "this->node()" is to avoid conflicts with a local variable of the same name, which you don't have here. > > But using abbreviations is discouraged in WebKit code, so you should. This code has now been removed. >> Source/WebCore/rendering/RenderObject.cpp:1139 >> + this->addDestination(graphicsContext); > > No reason for "this->" here. Code removed. >> Source/WebCore/rendering/RenderObject.cpp:1142 >> + child->addDestinationsRecursive(graphicsContext); > > Wow, adding a destination for every element with an id is quite some work. You explained the reason in the bug, but I'm not convinced. If there is already an HTML document on the Web, other pages should link to it, not to a PDF. And if it's not on the Web, a real authoring tool should be used to produce the file to publish, not a browser's "Save As" command. > > Also, anchors link to names, not to ids. IDs are checked first. Names are checked second and only for <a> elements. http://www.w3.org/html/wg/drafts/html/master/browsers.html#scroll-to-fragid Fortunately I was able to take advantage of Document::findAnchor, so this patch no longer has to worry about those details. I've changed the patch to: 1) only output links to named destinations where such a named destination exists. 2) only output named destinations if something links to it. >> Source/WebCore/rendering/RenderObject.h:983 >> + void addDestination(GraphicsContext*); > > This function is never called from outside, and should be private. Removed method. 854042 11 dml+webkit 2013-03-12 21:17:06 -0700 Thanks for the quick review. I think I've addressed all your comments, although it was a substantial change so I expect there will likely be additional comments on the new code. I had a look at the version of Skia being pulled by Chromium and the version of Chromium being pulled by WebKit and it looks like it'll probably be OK to me - someone else updated it a few hours ago. So fingers crossed that it passes this time. 854063 12 192865 ap 2013-03-12 22:31:51 -0700 Comment on attachment 192865 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=192865&action=review Thank you, this looks much better. r- for leaving a dangling pointer. > Source/WebCore/ChangeLog:9 > + This change doesn't have any tests because PDF generation doesn't > + have any existing tests. Manual testing was performed in Chromium That said, adding a way to test PDF generation would be a valuable project. > Source/WebCore/ChangeLog:17 > + (WebCore): It's just a bug of prepare-ChangeLog that this cruft is added. The purpose of generating file and name links is to simplify adding per-function comments to ChangeLogs, and unhelpful garbage should be removed (yes, a lot of people don't do that, sadly). > Source/WebCore/dom/Document.h:1200 > + HashMap<String, Element*>& usedAnchors() { return m_usedAnchors; } Looks like this could be const (on both sides). But see other comments. > Source/WebCore/dom/Document.h:1465 > + HashMap<String, Element*> m_usedAnchors; This is very surprising to have as a permanent member of Document. This causes a serious bug: if one generates PDF twice, and an element is removed in between the calls, a dangling pointer is left in the HashMap, and then dereferenced. The HashMap should at least be cleared when no longer needed, but I think that I have a better suggestion below. > Source/WebCore/page/FrameView.cpp:3434 > + p->addDestinationAtPoint(i->key, IntPoint(0, y)); Why no horizontal offset? The user can have the document zoomed in, and then scrolling to (0, y) may not reveal the element. Can the result of absoluteBoundingBoxRect() have negative coordinates? Perhaps we should clamp to 0. Ditto for being out of page bounds on the other side. > Source/WebCore/rendering/RenderObject.cpp:1124 > + document()->addUsedAnchor(name, element); Would it work if we just called addDestinationAtPoint here? The same destination could be added several times, but I don't see any reason why that would be a problem. We are just using an intermediate map instead of one in PDF context. > Source/WebCore/rendering/RenderObject.cpp:1129 > + return; > + } > + } > + context->setURLForRect(url, pixelSnappedIntRect(rect)); Unsure if it's meaningful to add a same-document URL if anchor couldn't be found. Perhaps the early return should be outside "if (element)"? 854081 13 192865 dml+webkit 2013-03-12 23:30:09 -0700 Comment on attachment 192865 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=192865&action=review >> Source/WebCore/rendering/RenderObject.cpp:1124 >> + document()->addUsedAnchor(name, element); > > Would it work if we just called addDestinationAtPoint here? The same destination could be added several times, but I don't see any reason why that would be a problem. We are just using an intermediate map instead of one in PDF context. Unfortunately not. GraphicsContext::addDestinationAtPoint needs to be called on the GraphicsContext for the page containing the destination. If we called it here, the link would only work if the destination was on the same page as the link. It's currently being called for all pages and then dropped when the point falls outside the bounds of the page (i.e. all but the correct page). I'll have a look and see if I can find another way of structuring it without storing stuff on Document. If you have any ideas, let me know. >> Source/WebCore/rendering/RenderObject.cpp:1129 >> + context->setURLForRect(url, pixelSnappedIntRect(rect)); > > Unsure if it's meaningful to add a same-document URL if anchor couldn't be found. Perhaps the early return should be outside "if (element)"? The patch as it currently stands puts out a regular link - i.e. falls back to the old behavior. I'll move the return, which will mean same-document URLs that are broken will become non-links. 854319 14 ap 2013-03-13 08:35:47 -0700 > GraphicsContext::addDestinationAtPoint needs to be called on the GraphicsContext for the page containing the destination. I'm confused. Do we have multiple GraphicsContexts when printing to a PDF? But even then, aren't all internal links in-document? 855695 15 193232 dml+webkit 2013-03-14 22:17:40 -0700 Created attachment 193232 Patch 855696 16 192865 dml+webkit 2013-03-14 22:21:19 -0700 Comment on attachment 192865 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=192865&action=review >> Source/WebCore/ChangeLog:9 >> + have any existing tests. Manual testing was performed in Chromium > > That said, adding a way to test PDF generation would be a valuable project. Agreed. Not sure I have sufficient familiarity with WebKit to know where and how to write such a test. Ideally it'd run WebKit headlessly on an input HTML file, render to PDF then make assertions about the contents of the PDF. I've got no idea how straightforward it would be to run WebKit in this manner. As an interim measure, is there somewhere I can put my test file, in case the code is changed later and someone wants to manually test that it still works? Or should I just attach it to this bug? >> Source/WebCore/ChangeLog:17 >> + (WebCore): > > It's just a bug of prepare-ChangeLog that this cruft is added. The purpose of generating file and name links is to simplify adding per-function comments to ChangeLogs, and unhelpful garbage should be removed (yes, a lot of people don't do that, sadly). Makes sense. Removed. >> Source/WebCore/dom/Document.h:1200 >> + HashMap<String, Element*>& usedAnchors() { return m_usedAnchors; } > > Looks like this could be const (on both sides). But see other comments. Code removed. >> Source/WebCore/dom/Document.h:1465 >> + HashMap<String, Element*> m_usedAnchors; > > This is very surprising to have as a permanent member of Document. This causes a serious bug: if one generates PDF twice, and an element is removed in between the calls, a dangling pointer is left in the HashMap, and then dereferenced. > > The HashMap should at least be cleared when no longer needed, but I think that I have a better suggestion below. I've removed all code from Document. >> Source/WebCore/page/FrameView.cpp:3434 >> + p->addDestinationAtPoint(i->key, IntPoint(0, y)); > > Why no horizontal offset? The user can have the document zoomed in, and then scrolling to (0, y) may not reveal the element. > > Can the result of absoluteBoundingBoxRect() have negative coordinates? Perhaps we should clamp to 0. Ditto for being out of page bounds on the other side. I now check that the point is inside the page's rectangle and ignore it if it isn't. I think Skia does this as well, but it doesn't hurt to do it in WebKit as well. >>> Source/WebCore/rendering/RenderObject.cpp:1124 >>> + document()->addUsedAnchor(name, element); >> >> Would it work if we just called addDestinationAtPoint here? The same destination could be added several times, but I don't see any reason why that would be a problem. We are just using an intermediate map instead of one in PDF context. > > Unfortunately not. GraphicsContext::addDestinationAtPoint needs to be called on the GraphicsContext for the page containing the destination. If we called it here, the link would only work if the destination was on the same page as the link. It's currently being called for all pages and then dropped when the point falls outside the bounds of the page (i.e. all but the correct page). I'll have a look and see if I can find another way of structuring it without storing stuff on Document. If you have any ideas, let me know. You asked if a new GraphicsContext is created for each page... I'd assumed that one was - the headless code I'm using does that, but I see that PrintContext::spoolAllPagesWithBoundaries doesn't do that - it instead reuses the same GraphicsContext. In any case, at the Skia level, we definitely have a different SkPDFDevice/SkCanvas for each page and the destinations need to get written to the correct SkPDFDevice for the page that the destination appears on. So unless there is some way to get access to a random page's SkCanvas, the destinations need to be put out while the page containing those destinations is being rendered. Instead, I've added code to FrameView that finds links, gets the elements they point to and outputs them as destinations if they're on the current page. 855723 17 ap 2013-03-14 23:13:21 -0700 > Agreed. Not sure I have sufficient familiarity with WebKit to know where and how to write such a test. Ideally it'd run WebKit headlessly on an input HTML file, render to PDF then make assertions about the contents of the PDF. I've got no idea how straightforward it would be to run WebKit in this manner. The hardest part here is to make assertions about contents of produced PDFs, and to a lesser degree, adding plumbing to produce a PDFD. Headless operation is what regression tests do normally, and we have 30000 of them. Tests in LayoutTests/webarchive directory are somewhat similar, although their way to assert correctness is by comparing produced binary file to expected one, which would not work so great for PDFs. > As an interim measure, is there somewhere I can put my test file, in case the code is changed later and someone wants to manually test that it still works? Or should I just attach it to this bug? There is a ManualTests directory at the root of WebKit checkout, but I would discourage using it. No one ever runs these tests, and adding something that requires multiple manual steps just makes existing tests slightly less useful. > In any case, at the Skia level, we definitely have a different SkPDFDevice/SkCanvas for each page and the destinations need to get written to the correct SkPDFDevice for the page that the destination appears on. So unless there is some way to get access to a random page's SkCanvas, the destinations need to be put out while the page containing those destinations is being rendered. Are you talking about pages in a produced PDF, or about subframes? There is something here that feels wrong, but I can't put my finger on it. 855750 18 dml+webkit 2013-03-15 00:05:01 -0700 (In reply to comment #17) > > Agreed. Not sure I have sufficient familiarity with WebKit to know where and how to write such a test. Ideally it'd run WebKit headlessly on an input HTML file, render to PDF then make assertions about the contents of the PDF. I've got no idea how straightforward it would be to run WebKit in this manner. > > The hardest part here is to make assertions about contents of produced PDFs, and to a lesser degree, adding plumbing to produce a PDFD. Headless operation is what regression tests do normally, and we have 30000 of them. The assertions I think I can manage, since both the links and the destinations end up in the PDF in plain text. It's the plumbing parts that I'm unsure of. > > In any case, at the Skia level, we definitely have a different SkPDFDevice/SkCanvas for each page and the destinations need to get written to the correct SkPDFDevice for the page that the destination appears on. So unless there is some way to get access to a random page's SkCanvas, the destinations need to be put out while the page containing those destinations is being rendered. > > Are you talking about pages in a produced PDF, or about subframes? There is something here that feels wrong, but I can't put my finger on it. AFAIK there should be one SkPDFDevice and on SkCanvas per page in the produced PDF. I've got some ideas that I'll investigate on Monday (Sydney time) that may mean it would work to add the destinations from RenderObject (like you originally suggested). 856780 19 dml+webkit 2013-03-17 17:19:27 -0700 (In reply to comment #17) > > In any case, at the Skia level, we definitely have a different SkPDFDevice/SkCanvas for each page and the destinations need to get written to the correct SkPDFDevice for the page that the destination appears on. So unless there is some way to get access to a random page's SkCanvas, the destinations need to be put out while the page containing those destinations is being rendered. > > Are you talking about pages in a produced PDF, or about subframes? There is something here that feels wrong, but I can't put my finger on it. I thought it might be possible to call addDestinationAtPoint from RenderObject::addPDFURLRect. I've now tried it and it doesn't work. Destinations only get written if they are on the same page as something that links to them. I thought that addPDFURLRect was getting called for each page and for each URL, but, probably fortunately for performance, it isn't. I did some investigation as to where the GraphicsContext is getting created. It seems there is a new GraphicsContext for each page, created (at least for Chromium) in WebFrameImpl::printPage. Given the above, I don't see any obvious options other than what I'm doing in my latest patch. Is it a problem that I'm traversing the render tree for each page? The paint code already does that. One alternative to that would be to traverse it only for the first page, then store a HashMap on FrameView from names to elements that have been linked to. This could then be reused for subsequent pages. 857929 20 ap 2013-03-18 22:09:12 -0700 > Is it a problem that I'm traversing the render tree for each page? Well, this effectively adds an O(n^2) algorithm. Can you measure how long it takes to generate a PDF for single page HTML5 spec with and without this patch? IIRC Safari prints the whole document at once, not page by page (except when generating preview). So, ideally I'm interested in the above measurement for Safari. 859983 21 194177 dml+webkit 2013-03-20 20:37:03 -0700 Created attachment 194177 Patch 859990 22 dml+webkit 2013-03-20 20:54:20 -0700 Does Safari use Skia for generating PDFs? When I build WebKit and run Safari (using Tools/Scripts/run-safari) then print to PDF, the resulting PDF appears as though my change was not present. It seems like the code in RenderObject is being run but not the code in GraphicsContextSkia. In any case, I've updated my change so that it only traverses the DOM once and caches the linked elements for use on subsequent pages. 859991 23 thorton 2013-03-20 20:56:17 -0700 (In reply to comment #22) > Does Safari use Skia for generating PDFs? When I build WebKit and run Safari (using Tools/Scripts/run-safari) then print to PDF, the resulting PDF appears as though my change was not present. It seems like the code in RenderObject is being run but not the code in GraphicsContextSkia. No, Safari does not use Skia, it uses CG. Skia is a Chromium-port thing. 860506 24 194177 thorton 2013-03-21 11:30:28 -0700 Comment on attachment 194177 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=194177&action=review > Source/WebCore/page/FrameView.cpp:3490 > + if (!m_linkedDestinationsValid) { > + collectLinkedDestinations(node); > + m_linkedDestinationsValid = true; > + } What if you print, the page is mutated via JavaScript, and then you print again? m_linkedDestinations will be stale, right? And contain stale pointers to Elements? Which you will then dereference below? > Source/WebCore/page/FrameView.cpp:3495 > + IntRect bb = it->value->renderer()->absoluteBoundingBoxRect(); > + IntPoint point(bb.x(), bb.y()); Please expand "bb". > Source/WebCore/page/FrameView.cpp:3496 > + if (pageRect.contains(point)) What if the bounds are shoved off the page but the bounding box intersects the page? You probably want "intersection of pageRect and 'bb' is not empty", no? > Source/WebCore/platform/graphics/skia/GraphicsContextSkia.cpp:1113 > + return true; Shouldn't this only return true if the graphics context is backed by e.g. a PDF? Certainly you don't want to do all this work for a bitmap Skia context... 860948 25 194404 dml+webkit 2013-03-21 17:54:11 -0700 Created attachment 194404 Patch 860951 26 194177 dml+webkit 2013-03-21 17:57:50 -0700 Comment on attachment 194177 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=194177&action=review >> Source/WebCore/page/FrameView.cpp:3490 >> + } > > What if you print, the page is mutated via JavaScript, and then you print again? m_linkedDestinations will be stale, right? And contain stale pointers to Elements? Which you will then dereference below? I'd wrongly thought that FrameView only lived for the duration of the print. I've moved this code to PrintContext which should fix this. >> Source/WebCore/page/FrameView.cpp:3495 >> + IntPoint point(bb.x(), bb.y()); > > Please expand "bb". Done. >> Source/WebCore/page/FrameView.cpp:3496 >> + if (pageRect.contains(point)) > > What if the bounds are shoved off the page but the bounding box intersects the page? You probably want "intersection of pageRect and 'bb' is not empty", no? Good point. Done. >> Source/WebCore/platform/graphics/skia/GraphicsContextSkia.cpp:1113 >> + return true; > > Shouldn't this only return true if the graphics context is backed by e.g. a PDF? Certainly you don't want to do all this work for a bitmap Skia context... I now check if it's printing. 863997 27 194404 ap 2013-03-26 14:23:04 -0700 Comment on attachment 194404 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=194404&action=review > In any case, at the Skia level, we definitely have a different SkPDFDevice/SkCanvas for each page and the destinations need to get written to the correct SkPDFDevice for the page that the destination appears on. I don't understand how this can work. If every page is separate, how do cross-page links work at all? Surely there is an object in Skia that represents the whole multi-page document? For example in CG, it's a CGPDFContext, and one calls CGPDFContextBeginPage when moving to the next page. > Source/WebCore/platform/graphics/skia/GraphicsContextSkia.cpp:1113 > + return platformContext()->printing(); I'm not sure if this is a good place to make such checks. A GraphicsContext may not have any idea about whether it's printing or not, it's the responsibility of both higher level and lower level code. 864001 28 195162 ap 2013-03-26 14:27:18 -0700 Created attachment 195162 with non-functional CG support I tried making a patch that works with CG too, but for some reason, a resulting document has no clickable links at all. Perhaps rects are represented in a way that's different from how it's done elsewhere? 867489 29 dml+webkit 2013-04-01 19:33:28 -0700 Sorry about the slow reply - we had a 4 day weekend here in Australia. (In reply to comment #27) > (From update of attachment 194404 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=194404&action=review > > > In any case, at the Skia level, we definitely have a different SkPDFDevice/SkCanvas for each page and the destinations need to get written to the correct SkPDFDevice for the page that the destination appears on. > > I don't understand how this can work. If every page is separate, how do cross-page links work at all? Surely there is an object in Skia that represents the whole multi-page document? For example in CG, it's a CGPDFContext, and one calls CGPDFContextBeginPage when moving to the next page. There's SkPDFDocument. It represents the whole PDF document. The destinations still need to be written to the correct SkPDFDevice for the page they're on though. > > Source/WebCore/platform/graphics/skia/GraphicsContextSkia.cpp:1113 > > + return platformContext()->printing(); > > I'm not sure if this is a good place to make such checks. A GraphicsContext may not have any idea about whether it's printing or not, it's the responsibility of both higher level and lower level code. So I should just revert this to return true here? Now that adding the destinations is being done in PrintContext, it will already only be getting run if we're printing. That only leaves linking to destinations which doesn't really do any significant amount of work, so is probably OK to do even if the underlying Skia device doesn't support it. (In reply to comment #28) > Created an attachment (id=195162) [details] > with non-funcitonal CG support > > I tried making a patch that works with CG too, but for some reason, a resulting document has no clickable links at all. Perhaps rects are represented in a way that's different from how it's done elsewhere? Presumably it would need to apply transforms in a similar way to what the CG implementation of GraphicsContext::setURLForRect does. That said, I tried doing that and it still didn't work. Looking at the generated PDF in a text editor, neither the destinations nor the links to the destinations are being put out. I've got no idea why not. 871331 30 darin 2013-04-08 18:07:52 -0700 We used to do this in Safari and Core Graphics. Did the code to do this get removed at some point? 871333 31 darin 2013-04-08 18:08:13 -0700 Oh, I see “internal links!” Got it. 871341 32 dml+webkit 2013-04-08 18:14:08 -0700 I'm going to continue with trying to get this change into Blink. https://code.google.com/p/chromium/issues/detail?id=157266 If anyone is interested in seeing this feature in WebKit with CG, feel free to pick this up. Thanks Alexey for the helpful comments. 871365 33 194404 ap 2013-04-08 19:04:09 -0700 Comment on attachment 194404 Patch r- to get this out of review queue, as we don't support Skia in WebKit any more. We should certainly finish this. 887425 34 ap 2013-05-10 10:47:08 -0700 <rdar://problem/8239740> 1118064 35 259132 thorton 2015-08-16 17:24:29 -0700 Created attachment 259132 patch, still doesn't work Rebaselined the patch, and added the requisite transforms to the CG code. It still doesn't work though, even though everything we're handing to CG seems totally sane. Not sure what's up. 1238784 36 thorton 2016-10-11 01:06:28 -0700 I believe the problem is WKPrintingView _drawPDFDocument:page:atPoint:'s implementation of annotation copying. 1238786 37 thorton 2016-10-11 01:14:09 -0700 Yup! This should be pretty easy now, knowing that. 1247242 38 293645 thorton 2016-11-02 00:20:30 -0700 Created attachment 293645 Significant progress; actually works now 1247243 39 293645 thorton 2016-11-02 00:21:16 -0700 Comment on attachment 293645 Significant progress; actually works now Not ready for review, though. 1247612 40 293729 thorton 2016-11-02 18:24:13 -0700 Created attachment 293729 Patch 1247614 41 293730 thorton 2016-11-02 18:26:07 -0700 Created attachment 293730 Patch 1247619 42 293732 thorton 2016-11-02 18:41:16 -0700 Created attachment 293732 Patch 1247624 43 293732 simon.fraser 2016-11-02 19:14:31 -0700 Comment on attachment 293732 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=293732&action=review > Source/WebCore/page/PrintContext.cpp:252 > +void PrintContext::collectLinkedDestinations(Node* node) Node& > Source/WebCore/page/PrintContext.cpp:255 > + for (Node* child = node->firstChild(); child; child = child->nextSibling()) > + collectLinkedDestinations(child); Hmm, can we use tree traversal iterator thingies? > Source/WebCore/platform/graphics/GraphicsContext.h:474 > + void setDestinationForRect(const String& name, const IntRect&); > + void addDestinationAtPoint(const String& name, const IntPoint&); The rest of this API is FloatPoint/FloatRect, other than the URL one above. > Source/WebCore/platform/graphics/GraphicsContext.h:582 > + bool supportsInternalLinks(); const ? > Source/WebCore/rendering/RenderObject.cpp:621 > + if (paintInfo.context().supportsInternalLinks() && url.hasFragmentIdentifier() && equalIgnoringFragmentIdentifier(url, document.baseURL())) { > + String name = url.fragmentIdentifier(); > + if (document.findAnchor(name)) > + paintInfo.context().setDestinationForRect(name, snappedIntRect(urlRect)); > + return; > + } This looks a lot like the code in PrintContext::collectLinkedDestinations(). Share it? 1247812 44 293791 thorton 2016-11-03 13:05:09 -0700 Created attachment 293791 Patch 1247819 45 293791 simon.fraser 2016-11-03 13:19:11 -0700 Comment on attachment 293791 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=293791&action=review > Source/WebCore/page/PrintContext.h:110 > + Optional<HashMap<String, Element*>> m_linkedDestinations; It makes me slightly nervous that this has raw Element*. Can script run while this thing is live? Also, not sure that Optional<> gains you much over unique_ptr<> 1247821 46 thorton 2016-11-03 13:29:59 -0700 (In reply to comment #45) > Comment on attachment 293791 [details] > Patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=293791&action=review > > > Source/WebCore/page/PrintContext.h:110 > > + Optional<HashMap<String, Element*>> m_linkedDestinations; > > It makes me slightly nervous that this has raw Element*. Can script run > while this thing is live? It shouldn't be able to; it lives just during PrintContext between begin/end, which looks like only encompasses painting, but I could be wrong. It seems entirely reasonable to ref these, anyway. > Also, not sure that Optional<> gains you much over unique_ptr<> Sure, but is there any reason to prefer unique_ptr? 1247853 47 thorton 2016-11-03 14:11:31 -0700 https://trac.webkit.org/changeset/208347 1248145 48 293645 darin 2016-11-04 09:53:34 -0700 Comment on attachment 293645 Significant progress; actually works now View in context: https://bugs.webkit.org/attachment.cgi?id=293645&action=review Sorry, I missed the final work on this and maybe things changed a lot in the patch that you landed, but here were my comments on an earlier draft. > Source/WebCore/page/PrintContext.cpp:39 > + , m_linkedDestinationsValid(false) In new code we should do these in the class definitions. > Source/WebCore/page/PrintContext.cpp:196 > + if (ctx.supportsInternalLinks()) > + outputLinkedDestinations(ctx, m_frame->document(), pageRect); Might be clearer to have the outputLinkedDestinations functions check the boolean instead. > Source/WebCore/page/PrintContext.cpp:208 > + if (ctx.supportsInternalLinks()) > + outputLinkedDestinations(ctx, m_frame->document(), rect); Ditto. > Source/WebCore/page/PrintContext.cpp:257 > +void PrintContext::collectLinkedDestinations(Node* node) Since this function dereferences the node pointer, it should take a reference, not a pointer. I suggest Document& and using a non-recursive algorithm. > Source/WebCore/page/PrintContext.cpp:259 > + // FIXME: We have better ways to iterate now? We do. In particular, we should do non-recursive iteration. Since we are only interested in elements we can use the elements iterator. > Source/WebCore/page/PrintContext.cpp:266 > + const AtomicString& href = static_cast<Element*>(node)->getAttribute(HTMLNames::hrefAttr); downcast is preferred over static_cast for casts from node to element. auto& would be nice here. attributeWithoutSynchronization is better here. > Source/WebCore/page/PrintContext.cpp:270 > + Document& document = node->document(); auto& would be nice here. > Source/WebCore/page/PrintContext.cpp:278 > + m_linkedDestinations.set(name, element); Probably want to use add instead of set. Depends really on what we want to do if the same name occurs more than once. > Source/WebCore/page/PrintContext.cpp:282 > +void PrintContext::outputLinkedDestinations(GraphicsContext& graphicsContext, Node* node, const IntRect& pageRect) I suggest taking a Document& instead of a Node*. > Source/WebCore/page/PrintContext.cpp:287 > + if (!m_linkedDestinationsValid) { > + collectLinkedDestinations(node); > + m_linkedDestinationsValid = true; > + } Seems peculiar that if m_linkedDestinationsValid is true that we ignore the node; somehow we know it’s the same as last time? Why a pointer for the node? Can it be null? > Source/WebCore/page/PrintContext.cpp:290 > + HashMap<String, Element*>::const_iterator end = m_linkedDestinations.end(); > + for (HashMap<String, Element*>::const_iterator it = m_linkedDestinations.begin(); it != end; ++it) { Modern for loop would work well here and eliminate those long type names for the iterator. > Source/WebCore/page/PrintContext.cpp:292 > + IntRect boundingBox = it->value->renderer()->absoluteBoundingBoxRect(); > + if (pageRect.intersects(boundingBox)) { Not sure we need a local variable here; might read more nicely without it. Also, what guarantees the renderers are all non-null? 1248203 49 thorton 2016-11-04 12:27:49 -0700 (In reply to comment #48) > Comment on attachment 293645 [details] > Significant progress; actually works now > > View in context: > https://bugs.webkit.org/attachment.cgi?id=293645&action=review > > Sorry, I missed the final work on this and maybe things changed a lot in the > patch that you landed, but here were my comments on an earlier draft. OK! Let me see what I fixed; it looks like this one was before I really started ripping it up, so hopefully most are fixed. > > Source/WebCore/page/PrintContext.cpp:39 > > + , m_linkedDestinationsValid(false) > > In new code we should do these in the class definitions. This is gone. > > Source/WebCore/page/PrintContext.cpp:196 > > + if (ctx.supportsInternalLinks()) > > + outputLinkedDestinations(ctx, m_frame->document(), pageRect); > > Might be clearer to have the outputLinkedDestinations functions check the > boolean instead. I did this. > > Source/WebCore/page/PrintContext.cpp:208 > > + if (ctx.supportsInternalLinks()) > > + outputLinkedDestinations(ctx, m_frame->document(), rect); > > Ditto. I did this. > > Source/WebCore/page/PrintContext.cpp:257 > > +void PrintContext::collectLinkedDestinations(Node* node) > > Since this function dereferences the node pointer, it should take a > reference, not a pointer. I suggest Document& and using a non-recursive > algorithm. I did this (both the reference and non-recursiveness, though not taking Document, which is a good idea). > > Source/WebCore/page/PrintContext.cpp:259 > > + // FIXME: We have better ways to iterate now? > > We do. In particular, we should do non-recursive iteration. Since we are > only interested in elements we can use the elements iterator. Ooh, I switched to a different and non-recursive node iterator, but didn't know about the element iterator. Will look into that. > > Source/WebCore/page/PrintContext.cpp:266 > > + const AtomicString& href = static_cast<Element*>(node)->getAttribute(HTMLNames::hrefAttr); > > downcast is preferred over static_cast for casts from node to element. Did this. > auto& would be nice here. Did not do this. > attributeWithoutSynchronization is better here. Did not do this. I never know how to know when to do it! > > Source/WebCore/page/PrintContext.cpp:270 > > + Document& document = node->document(); > > auto& would be nice here. OK. > > Source/WebCore/page/PrintContext.cpp:278 > > + m_linkedDestinations.set(name, element); > > Probably want to use add instead of set. Depends really on what we want to > do if the same name occurs more than once. Interesting. > > Source/WebCore/page/PrintContext.cpp:282 > > +void PrintContext::outputLinkedDestinations(GraphicsContext& graphicsContext, Node* node, const IntRect& pageRect) > > I suggest taking a Document& instead of a Node*. Sure! > > Source/WebCore/page/PrintContext.cpp:287 > > + if (!m_linkedDestinationsValid) { > > + collectLinkedDestinations(node); > > + m_linkedDestinationsValid = true; > > + } > > Seems peculiar that if m_linkedDestinationsValid is true that we ignore the > node; somehow we know it’s the same as last time? Why a pointer for the > node? Can it be null? This thing only lasts one print operation, so there's theretically no opportunity for it to become invalid > > Source/WebCore/page/PrintContext.cpp:290 > > + HashMap<String, Element*>::const_iterator end = m_linkedDestinations.end(); > > + for (HashMap<String, Element*>::const_iterator it = m_linkedDestinations.begin(); it != end; ++it) { > > Modern for loop would work well here and eliminate those long type names for > the iterator. Yep, did this. > > Source/WebCore/page/PrintContext.cpp:292 > > + IntRect boundingBox = it->value->renderer()->absoluteBoundingBoxRect(); > > + if (pageRect.intersects(boundingBox)) { > > Not sure we need a local variable here; might read more nicely without it. I think this is resolved. > Also, what guarantees the renderers are all non-null? Hmm, that's a good point. Will fix. 1248266 50 thorton 2016-11-04 14:08:07 -0700 Follow up in https://trac.webkit.org/changeset/208398 1248531 51 darin 2016-11-05 13:05:56 -0700 (In reply to comment #49) > > attributeWithoutSynchronization is better here. > > Did not do this. I never know how to know when to do it! If you forget the rule, you can re-derive it by reading the Element::synchronizeAttribute function. The rule is this: If the attribute we are getting is, or might be either 1) the style attribute (HTMLNames::styleAttr) or 2) an animated attribute of an SVG element then we have to use the getAttribute family of functions, which has a couple more branches and is slower. Otherwise, we can and should use the attributeWithoutSynchronization family. So typically if we are writing a general purpose function that can work with any attribute we will need to use the getAttribute family. But if we are writing a function that works with one particular attribute, it's likely we can use the attributeWithoutSynchronization. In this case, the attribute was href, which is not style, and SVG does not have an animated attribute named href. So that means we can use attributeWithoutSynchronization. 192604 2013-03-11 17:26:48 -0700 2013-03-12 21:13:38 -0700 Patch bug-112081-20130312112247.patch text/plain 9594 dml+webkit U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ1NDI0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOWZjNjY3MmVkM2VjOTZm YmJmZDc0YTk5YTk1NTUyZTBlODhhMmI2NS4uZjFlNTFlYjdlMzViYmQ0YTA4YWYwMjdkZWJiYmFi Yzg4MWYyMmQzZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM4IEBACisyMDEzLTAzLTExICBEYXZp ZCBMYXR0aW1vcmUgIDxkbWwrd2Via2l0QGdvb2dsZS5jb20+CisKKyAgICAgICAgUHJpbnRpbmcg dG8gUERGIHNob3VsZCBwcm9kdWNlIGludGVybmFsIGxpbmtzIHdoZW4gSFRNTCBoYXMgaW50ZXJu YWwgbGlua3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTExMjA4MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFRoaXMgY2hhbmdlIGRvZXNuJ3QgaGF2ZSBhbnkgdGVzdHMgYmVjYXVzZSBQREYgZ2VuZXJhdGlv biBkb2Vzbid0IGhhdmUgYW55IGV4aXN0aW5nIHRlc3RzLgorCisgICAgICAgICogcGFnZS9GcmFt ZVZpZXcuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJhbWVWaWV3OjpwYWludENvbnRlbnRzKToK KyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0OjpzZXRTaG91bGRPdXRwdXRJbnRlcm5hbExpbmtz KToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0 OjpzaG91bGRPdXRwdXRJbnRlcm5hbExpbmtzKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNz Q29udGV4dDo6c3VwcG9ydHNJbnRlcm5hbExpbmtzKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBo aWNzQ29udGV4dDo6c2V0TGlua1RvRGVzdGluYXRpb24pOgorICAgICAgICAoV2ViQ29yZTo6R3Jh cGhpY3NDb250ZXh0OjphZGREZXN0aW5hdGlvbik6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhp Y3MvR3JhcGhpY3NDb250ZXh0Lmg6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHRT dGF0ZTo6R3JhcGhpY3NDb250ZXh0U3RhdGUpOgorICAgICAgICAoR3JhcGhpY3NDb250ZXh0U3Rh dGUpOgorICAgICAgICAoR3JhcGhpY3NDb250ZXh0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFw aGljcy9za2lhL0dyYXBoaWNzQ29udGV4dFNraWEuY3BwOgorICAgICAgICAoV2ViQ29yZTo6R3Jh cGhpY3NDb250ZXh0OjpzdXBwb3J0c0ludGVybmFsTGlua3MpOgorICAgICAgICAoV2ViQ29yZSk6 CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6OnNldExpbmtUb0Rlc3RpbmF0aW9u KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6YWRkRGVzdGluYXRpb24pOgor ICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwOgorICAgICAgICAoV2ViQ29yZTo6 UmVuZGVyT2JqZWN0OjphZGRQREZVUkxSZWN0KToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAg ICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjphZGREZXN0aW5hdGlvbik6CisgICAgICAgIChXZWJD b3JlOjpSZW5kZXJPYmplY3Q6OmFkZERlc3RpbmF0aW9uc1JlY3Vyc2l2ZSk6CisgICAgICAgICog cmVuZGVyaW5nL1JlbmRlck9iamVjdC5oOgorICAgICAgICAoUmVuZGVyT2JqZWN0KToKKwogMjAx My0wMy0wNSAgT2phbiBWYWZhaSAgPG9qYW5AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIEludHJp bnNpYyB3aWR0aCBrZXl3b3JkIHZhbHVlcyBkb24ndCB3b3JrIGZvciB0YWJsZXMKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvRnJhbWVWaWV3LmNwcAppbmRleCAxZjU3ZTBjMjc0YzdmM2I5MDNhN2M2YzY0MTk4MDFmYWU1 NTc2OTNiLi4xNWViODM3MWFkOTQ4Y2Y3ZjE0NzE2ZWU4ZDhjOTA0MWI5ODQ4NGQ5IDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvcGFnZS9GcmFtZVZpZXcuY3BwCkBAIC0zNDI3LDYgKzM0MjcsOSBAQCB2b2lkIEZyYW1lVmll dzo6cGFpbnRDb250ZW50cyhHcmFwaGljc0NvbnRleHQqIHAsIGNvbnN0IEludFJlY3QmIHJlY3Qp CiAKICAgICByb290TGF5ZXItPnBhaW50KHAsIHJlY3QsIG1fcGFpbnRCZWhhdmlvciwgZWx0UmVu ZGVyZXIpOwogCisgICAgaWYgKHAtPnNob3VsZE91dHB1dEludGVybmFsTGlua3MoKSkKKyAgICAg ICAgbV9mcmFtZS0+Y29udGVudFJlbmRlcmVyKCktPmFkZERlc3RpbmF0aW9uc1JlY3Vyc2l2ZShw KTsKKwogICAgIGlmIChyb290TGF5ZXItPmNvbnRhaW5zRGlydHlPdmVybGF5U2Nyb2xsYmFycygp KQogICAgICAgICByb290TGF5ZXItPnBhaW50T3ZlcmxheVNjcm9sbGJhcnMocCwgcmVjdCwgbV9w YWludEJlaGF2aW9yLCBlbHRSZW5kZXJlcik7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuY3BwCmluZGV4IDUwN2I0ZGUwMjQ4NjVi YjYzMmQ3ZjI4MWMzMjJjNGM5NzhmMTIzNjIuLmRkNzUzMDM2MzdiZmQ0M2M3ZDBmNTM2ZTg5M2M1 NTgxMWVmYzE4YmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L0dyYXBoaWNzQ29udGV4dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvR3JhcGhpY3NDb250ZXh0LmNwcApAQCAtMzMsNiArMzMsNyBAQAogI2luY2x1ZGUgIkludFJl Y3QuaCIKICNpbmNsdWRlICJSb3VuZGVkUmVjdC5oIgogI2luY2x1ZGUgIlRleHRSdW4uaCIKKyNp bmNsdWRlIDx3dGYvVW51c2VkUGFyYW0uaD4KIAogI2luY2x1ZGUgInN0ZGlvLmgiCiAKQEAgLTI2 NSw2ICsyNjYsMzYgQEAgYm9vbCBHcmFwaGljc0NvbnRleHQ6OnNob3VsZFN1YnBpeGVsUXVhbnRp emVGb250cygpIGNvbnN0CiAgICAgcmV0dXJuIG1fc3RhdGUuc2hvdWxkU3VicGl4ZWxRdWFudGl6 ZUZvbnRzOwogfQogCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0U2hvdWxkT3V0cHV0SW50ZXJu YWxMaW5rcyhib29sIGIpCit7CisgICAgbV9zdGF0ZS5zaG91bGRPdXRwdXRJbnRlcm5hbExpbmtz ID0gYjsKK30KKworYm9vbCBHcmFwaGljc0NvbnRleHQ6OnNob3VsZE91dHB1dEludGVybmFsTGlu a3MoKSBjb25zdAoreworICAgIHJldHVybiBzdXBwb3J0c0ludGVybmFsTGlua3MoKSAmJiBtX3N0 YXRlLnNob3VsZE91dHB1dEludGVybmFsTGlua3M7Cit9CisKKyNpZiAhVVNFKFNLSUEpCitib29s IEdyYXBoaWNzQ29udGV4dDo6c3VwcG9ydHNJbnRlcm5hbExpbmtzKCkKK3sKKyAgICByZXR1cm4g ZmFsc2U7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzZXRMaW5rVG9EZXN0aW5hdGlvbihj b25zdCBjaGFyKiBkZXN0TmFtZSwgY29uc3QgSW50UmVjdCYgcmVjdCkKK3sKKyAgICBVTlVTRURf UEFSQU0oZGVzdE5hbWUpOworICAgIFVOVVNFRF9QQVJBTShyZWN0KTsKK30KKwordm9pZCBHcmFw aGljc0NvbnRleHQ6OmFkZERlc3RpbmF0aW9uKGNvbnN0IFN0cmluZyYgbmFtZSwgSW50UG9pbnQg cG9zKQoreworICAgIFVOVVNFRF9QQVJBTShuYW1lKTsKKyAgICBVTlVTRURfUEFSQU0ocG9zKTsK K30KKworI2VuZGlmCisKIGNvbnN0IEdyYXBoaWNzQ29udGV4dFN0YXRlJiBHcmFwaGljc0NvbnRl eHQ6OnN0YXRlKCkgY29uc3QKIHsKICAgICByZXR1cm4gbV9zdGF0ZTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5oIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmgKaW5kZXggNWJjODg4 MWI0MTc4OTUzMWY2MzVkMzgyZTZkMDNlYjY3NGYxNzZhOC4uZDA3YjM2OWI0MmJiZjM3NjE1MjUw ZWFiMGNlNzhiOGM4NWIzMDhlNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmgKQEAgLTE3Niw2ICsxNzYsNyBAQCBuYW1lc3BhY2Ug V2ViQ29yZSB7CiAgICAgICAgICAgICAvLyBidXQgd2UgbmVlZCB0byBwcmVzZXJ2ZSB0aGlzIGJ1 Z2d5IGJlaGF2aW9yIGZvciBjYW52YXMgYW5kIC13ZWJraXQtYm94LXNoYWRvdy4KICAgICAgICAg ICAgICwgc2hhZG93c1VzZUxlZ2FjeVJhZGl1cyhmYWxzZSkKICNlbmRpZgorICAgICAgICAgICAg LCBzaG91bGRPdXRwdXRJbnRlcm5hbExpbmtzKHRydWUpCiAgICAgICAgIHsKICAgICAgICAgfQog CkBAIC0yMTQsNiArMjE1LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogI2lmIFVTRShDRykKICAg ICAgICAgYm9vbCBzaGFkb3dzVXNlTGVnYWN5UmFkaXVzIDogMTsKICNlbmRpZgorICAgICAgICBi b29sIHNob3VsZE91dHB1dEludGVybmFsTGlua3MgOiAxOwogICAgIH07CiAKICAgICBjbGFzcyBH cmFwaGljc0NvbnRleHQgewpAQCAtMjY2LDYgKzI2OCw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK ICAgICAgICAgdm9pZCBzZXRTaG91bGRTdWJwaXhlbFF1YW50aXplRm9udHMoYm9vbCk7CiAgICAg ICAgIGJvb2wgc2hvdWxkU3VicGl4ZWxRdWFudGl6ZUZvbnRzKCkgY29uc3Q7CiAKKyAgICAgICAg dm9pZCBzZXRTaG91bGRPdXRwdXRJbnRlcm5hbExpbmtzKGJvb2wpOworICAgICAgICBib29sIHNo b3VsZE91dHB1dEludGVybmFsTGlua3MoKSBjb25zdDsKKwogICAgICAgICBjb25zdCBHcmFwaGlj c0NvbnRleHRTdGF0ZSYgc3RhdGUoKSBjb25zdDsKIAogI2lmIFVTRShDRykKQEAgLTQyMyw2ICs0 MjgsOSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgdm9pZCBzZXRVUkxGb3JSZWN0 KGNvbnN0IEtVUkwmLCBjb25zdCBJbnRSZWN0Jik7CiAKKyAgICAgICAgdm9pZCBzZXRMaW5rVG9E ZXN0aW5hdGlvbihjb25zdCBjaGFyKiwgY29uc3QgSW50UmVjdCYpOworICAgICAgICB2b2lkIGFk ZERlc3RpbmF0aW9uKGNvbnN0IFN0cmluZyYsIEludFBvaW50KTsKKwogICAgICAgICB2b2lkIGNv bmNhdENUTShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mKTsKICAgICAgICAgdm9pZCBzZXRDVE0oY29u c3QgQWZmaW5lVHJhbnNmb3JtJik7CiAKQEAgLTU2NCw2ICs1NzIsNyBAQCBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAgICAgICAgIHZvaWQgYmVnaW5QbGF0Zm9ybVRyYW5zcGFyZW5jeUxheWVyKGZsb2F0 IG9wYWNpdHkpOwogICAgICAgICB2b2lkIGVuZFBsYXRmb3JtVHJhbnNwYXJlbmN5TGF5ZXIoKTsK ICAgICAgICAgc3RhdGljIGJvb2wgc3VwcG9ydHNUcmFuc3BhcmVuY3lMYXllcnMoKTsKKyAgICAg ICAgc3RhdGljIGJvb2wgc3VwcG9ydHNJbnRlcm5hbExpbmtzKCk7CiAKICAgICAgICAgdm9pZCBm aWxsRWxsaXBzZUFzUGF0aChjb25zdCBGbG9hdFJlY3QmKTsKICAgICAgICAgdm9pZCBzdHJva2VF bGxpcHNlQXNQYXRoKGNvbnN0IEZsb2F0UmVjdCYpOwpAQCAtNjIwLDQgKzYyOSwzIEBAIG5hbWVz cGFjZSBXZWJDb3JlIHsKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIEdyYXBo aWNzQ29udGV4dF9oCi0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL3NraWEvR3JhcGhpY3NDb250ZXh0U2tpYS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9za2lhL0dyYXBoaWNzQ29udGV4dFNraWEuY3BwCmluZGV4IDZhNTZjY2I1ZTIz MDM3Mzc5NzEwYzc2YjYwZjU4OGExZGRjYzJhNjYuLjZiZTRjY2JjMDk3YWQ1YzRmNDJjNDIxNDRk MjA2N2NmYjllNzU5ZjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL3NraWEvR3JhcGhpY3NDb250ZXh0U2tpYS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3Mvc2tpYS9HcmFwaGljc0NvbnRleHRTa2lhLmNwcApAQCAtMTEwOCw2ICsx MTA4LDMwIEBAIHZvaWQgR3JhcGhpY3NDb250ZXh0OjpzZXRVUkxGb3JSZWN0KGNvbnN0IEtVUkwm IGxpbmssIGNvbnN0IEludFJlY3QmIGRlc3RSZWN0KQogICAgIFNrQW5ub3RhdGVSZWN0V2l0aFVS TChwbGF0Zm9ybUNvbnRleHQoKS0+Y2FudmFzKCksIGRlc3RSZWN0LCB1cmwuZ2V0KCkpOwogfQog Citib29sIEdyYXBoaWNzQ29udGV4dDo6c3VwcG9ydHNJbnRlcm5hbExpbmtzKCkKK3sKKyAgICBy ZXR1cm4gdHJ1ZTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldExpbmtUb0Rlc3RpbmF0 aW9uKGNvbnN0IGNoYXIqIGRlc3ROYW1lLCBjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAgIGlm IChwYWludGluZ0Rpc2FibGVkKCkpCisgICAgICAgIHJldHVybjsKKworICAgIFNrQXV0b0RhdGFV bnJlZiBza0Rlc3ROYW1lKFNrRGF0YTo6TmV3V2l0aENTdHJpbmcoZGVzdE5hbWUpKTsKKyAgICBT a0Fubm90YXRlTGlua1RvRGVzdGluYXRpb24ocGxhdGZvcm1Db250ZXh0KCktPmNhbnZhcygpLCBy ZWN0LCBza0Rlc3ROYW1lLmdldCgpKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmFkZERl c3RpbmF0aW9uKGNvbnN0IFN0cmluZyYgbmFtZSwgSW50UG9pbnQgcG9zKQoreworICAgIGlmIChw YWludGluZ0Rpc2FibGVkKCkpCisgICAgICAgIHJldHVybjsKKworICAgIFNrQXV0b0RhdGFVbnJl ZiBuYW1lRGF0YShTa0RhdGE6Ok5ld1dpdGhDU3RyaW5nKG5hbWUudXRmOCgpLmRhdGEoKSkpOwor ICAgIFNrQW5ub3RhdGVOYW1lZERlc3RpbmF0aW9uKHBsYXRmb3JtQ29udGV4dCgpLT5jYW52YXMo KSwKKyAgICAgICAgU2tQb2ludDo6TWFrZShwb3MueCgpLCBwb3MueSgpKSwgbmFtZURhdGEpOwor fQorCiB2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0UGxhdGZvcm1TaG91bGRBbnRpYWxpYXMoYm9v bCBlbmFibGUpCiB7CiAgICAgaWYgKHBhaW50aW5nRGlzYWJsZWQoKSkKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwIGIvU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKaW5kZXggYzc2YjAwYTFlNTk0NTNhZjA3ODgxY2M4 ZTg2OWQ0ZmY0YTM4N2U2ZC4uYjY1ZDViY2ViN2Q5NGU4MTlkZWZmYzFmYzZkM2EyNzk5NjQ1Yzcx YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKQEAgLTExMTQs NyArMTExNCwzNCBAQCB2b2lkIFJlbmRlck9iamVjdDo6YWRkUERGVVJMUmVjdChHcmFwaGljc0Nv bnRleHQqIGNvbnRleHQsIGNvbnN0IExheW91dFJlY3QmIHJlYwogICAgIGNvbnN0IEF0b21pY1N0 cmluZyYgaHJlZiA9IHN0YXRpY19jYXN0PEVsZW1lbnQqPihuKS0+Z2V0QXR0cmlidXRlKGhyZWZB dHRyKTsKICAgICBpZiAoaHJlZi5pc051bGwoKSkKICAgICAgICAgcmV0dXJuOwotICAgIGNvbnRl eHQtPnNldFVSTEZvclJlY3Qobi0+ZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwoaHJlZiksIHBpeGVs U25hcHBlZEludFJlY3QocmVjdCkpOworICAgIEtVUkwgdXJsID0gbi0+ZG9jdW1lbnQoKS0+Y29t cGxldGVVUkwoaHJlZik7CisgICAgQ1N0cmluZyB1cmxTdHJpbmcgPSB1cmwuc3RyaW5nKCkudXRm OCgpOworICAgIGlmIChjb250ZXh0LT5zaG91bGRPdXRwdXRJbnRlcm5hbExpbmtzKCkgJiYgdXJs Lmhhc0ZyYWdtZW50SWRlbnRpZmllcigpICYmIGVxdWFsSWdub3JpbmdGcmFnbWVudElkZW50aWZp ZXIodXJsLCBuLT5kb2N1bWVudCgpLT5iYXNlVVJMKCkpKQorICAgICAgICBjb250ZXh0LT5zZXRM aW5rVG9EZXN0aW5hdGlvbihzdHJjaHIodXJsU3RyaW5nLmRhdGEoKSwgJyMnKSArIDEsIHBpeGVs U25hcHBlZEludFJlY3QocmVjdCkpOworICAgIGVsc2UKKyAgICAgICAgY29udGV4dC0+c2V0VVJM Rm9yUmVjdCh1cmwsIHBpeGVsU25hcHBlZEludFJlY3QocmVjdCkpOworfQorCit2b2lkIFJlbmRl ck9iamVjdDo6YWRkRGVzdGluYXRpb24oR3JhcGhpY3NDb250ZXh0KiBncmFwaGljc0NvbnRleHQp Cit7CisgICAgTm9kZSogbiA9IHRoaXMtPm5vZGUoKTsKKyAgICBpZiAoIW4gfHwgIW4tPmlzRWxl bWVudE5vZGUoKSkKKyAgICAgICAgcmV0dXJuOworICAgIGNvbnN0IEF0b21pY1N0cmluZyYgaWQg PSBzdGF0aWNfY2FzdDxFbGVtZW50Kj4obiktPmdldElkQXR0cmlidXRlKCk7CisgICAgaWYgKGlk LmlzTnVsbCgpKQorICAgICAgICByZXR1cm47CisgICAgaW50IHkgPSB0aGlzLT5hYnNvbHV0ZUJv dW5kaW5nQm94UmVjdCgpLnkoKTsKKyAgICBncmFwaGljc0NvbnRleHQtPmFkZERlc3RpbmF0aW9u KGlkLnN0cmluZygpLCBJbnRQb2ludCgwLCB5KSk7Cit9CisKK3ZvaWQgUmVuZGVyT2JqZWN0Ojph ZGREZXN0aW5hdGlvbnNSZWN1cnNpdmUoR3JhcGhpY3NDb250ZXh0KiBncmFwaGljc0NvbnRleHQp Cit7CisgICAgdGhpcy0+YWRkRGVzdGluYXRpb24oZ3JhcGhpY3NDb250ZXh0KTsKKyAgICBSZW5k ZXJPYmplY3QqIGNoaWxkID0gdGhpcy0+Zmlyc3RDaGlsZCgpOworICAgIHdoaWxlIChjaGlsZCkg eworICAgICAgICBjaGlsZC0+YWRkRGVzdGluYXRpb25zUmVjdXJzaXZlKGdyYXBoaWNzQ29udGV4 dCk7CisgICAgICAgIGNoaWxkID0gY2hpbGQtPm5leHRTaWJsaW5nKCk7CisgICAgfQogfQogCiB2 b2lkIFJlbmRlck9iamVjdDo6cGFpbnRPdXRsaW5lKFBhaW50SW5mbyYgcGFpbnRJbmZvLCBjb25z dCBMYXlvdXRSZWN0JiBwYWludFJlY3QpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5k ZXJpbmcvUmVuZGVyT2JqZWN0LmggYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2Jq ZWN0LmgKaW5kZXggMjMzNWM1ZTAwODc2OWFlZDQyODg5ZDZkYWI3MjY3ODk0ZDk3OTgyNC4uZDdj N2UyMTlmNThmNGE3NjNlYmE0N2M5ZDUzOGNmMDYxNDllYzM3ZCAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Jl bmRlcmluZy9SZW5kZXJPYmplY3QuaApAQCAtOTgwLDYgKzk4MCw4IEBAIHB1YmxpYzoKICAgICBi b29sIGNyZWF0ZXNHcm91cCgpIGNvbnN0IHsgcmV0dXJuIGlzVHJhbnNwYXJlbnQoKSB8fCBoYXNN YXNrKCkgfHwgaGFzRmlsdGVyKCkgfHwgaGFzQmxlbmRNb2RlKCk7IH0gCiAgICAgCiAgICAgdmly dHVhbCB2b2lkIGFkZEZvY3VzUmluZ1JlY3RzKFZlY3RvcjxJbnRSZWN0PiYsIGNvbnN0IExheW91 dFBvaW50JiAvKiBhZGRpdGlvbmFsT2Zmc2V0ICovLCBjb25zdCBSZW5kZXJMYXllck1vZGVsT2Jq ZWN0KiAvKiBwYWludENvbnRhaW5lciAqLyA9IDApIHsgfTsKKyAgICB2b2lkIGFkZERlc3RpbmF0 aW9uKEdyYXBoaWNzQ29udGV4dCopOworICAgIHZvaWQgYWRkRGVzdGluYXRpb25zUmVjdXJzaXZl KEdyYXBoaWNzQ29udGV4dCopOwogCiAgICAgTGF5b3V0UmVjdCBhYnNvbHV0ZU91dGxpbmVCb3Vu ZHMoKSBjb25zdAogICAgIHsK 192865 2013-03-12 21:08:30 -0700 2013-03-14 22:21:19 -0700 Patch bug-112081-20130313150428.patch text/plain 9257 dml+webkit U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ1NDI0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOWZjNjY3MmVkM2VjOTZm YmJmZDc0YTk5YTk1NTUyZTBlODhhMmI2NS4uNmJiYTU2YmM4Njk0MDQ0YWU1ZTc2OGVhYTExYzg0 OWQ0OTU3Zjk5MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDQxIEBACisyMDEzLTAzLTExICBEYXZp ZCBMYXR0aW1vcmUgIDxkbWwrd2Via2l0QGdvb2dsZS5jb20+CisKKyAgICAgICAgUHJpbnRpbmcg dG8gUERGIHNob3VsZCBwcm9kdWNlIGludGVybmFsIGxpbmtzIHdoZW4gSFRNTCBoYXMgaW50ZXJu YWwgbGlua3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTExMjA4MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFRoaXMgY2hhbmdlIGRvZXNuJ3QgaGF2ZSBhbnkgdGVzdHMgYmVjYXVzZSBQREYgZ2VuZXJhdGlv biBkb2Vzbid0CisgICAgICAgIGhhdmUgYW55IGV4aXN0aW5nIHRlc3RzLiBNYW51YWwgdGVzdGlu ZyB3YXMgcGVyZm9ybWVkIGluIENocm9taXVtCisgICAgICAgIGFuZCBhIGhlYWRsZXNzIHZlcnNp b24gb2YgV2ViS2l0IHdpdGggYSB2YXJpZXR5IG9mIGxpbmtzIGFuZAorICAgICAgICBhbmNob3Jz LgorCisgICAgICAgICogcGFnZS9GcmFtZVZpZXcuY3BwOgorICAgICAgICAoV2ViQ29yZTo6RnJh bWVWaWV3OjpwYWludENvbnRlbnRzKToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9HcmFw aGljc0NvbnRleHQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0OjpzZXRT aG91bGRPdXRwdXRJbnRlcm5hbExpbmtzKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAo V2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0OjpzaG91bGRPdXRwdXRJbnRlcm5hbExpbmtzKToKKyAg ICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6c3VwcG9ydHNJbnRlcm5hbExpbmtzKToK KyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6c2V0TGlua1RvRGVzdGluYXRpb24p OgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0OjphZGREZXN0aW5hdGlvbik6Cisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0Lmg6CisgICAgICAgIChX ZWJDb3JlOjpHcmFwaGljc0NvbnRleHRTdGF0ZTo6R3JhcGhpY3NDb250ZXh0U3RhdGUpOgorICAg ICAgICAoR3JhcGhpY3NDb250ZXh0U3RhdGUpOgorICAgICAgICAoR3JhcGhpY3NDb250ZXh0KToK KyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9za2lhL0dyYXBoaWNzQ29udGV4dFNraWEuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0OjpzdXBwb3J0c0ludGVybmFsTGlu a3MpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRl eHQ6OnNldExpbmtUb0Rlc3RpbmF0aW9uKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29u dGV4dDo6YWRkRGVzdGluYXRpb24pOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3Qu Y3BwOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjphZGRQREZVUkxSZWN0KToKKyAg ICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjphZGREZXN0 aW5hdGlvbik6CisgICAgICAgIChXZWJDb3JlOjpSZW5kZXJPYmplY3Q6OmFkZERlc3RpbmF0aW9u c1JlY3Vyc2l2ZSk6CisgICAgICAgICogcmVuZGVyaW5nL1JlbmRlck9iamVjdC5oOgorICAgICAg ICAoUmVuZGVyT2JqZWN0KToKKwogMjAxMy0wMy0wNSAgT2phbiBWYWZhaSAgPG9qYW5AY2hyb21p dW0ub3JnPgogCiAgICAgICAgIEludHJpbnNpYyB3aWR0aCBrZXl3b3JkIHZhbHVlcyBkb24ndCB3 b3JrIGZvciB0YWJsZXMKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuY3BwCmluZGV4IGM1ODQ3YWZkODIwYTIx N2Q0ODExNDA5OTkwNDBhYmU5N2IwZjdlZTYuLmExODAzNmI4OTk5NDJhMjc0ODQ0MWQwZjE3MTA4 ZjlmZGIxM2RjZjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvZG9tL0RvY3VtZW50LmNwcApAQCAtMTY5OCw2ICsxNjk4LDEx IEBAIFBhc3NSZWZQdHI8VHJlZVdhbGtlcj4gRG9jdW1lbnQ6OmNyZWF0ZVRyZWVXYWxrZXIoTm9k ZSogcm9vdCwgdW5zaWduZWQgd2hhdFRvU2hvCiAgICAgcmV0dXJuIFRyZWVXYWxrZXI6OmNyZWF0 ZShyb290LCB3aGF0VG9TaG93LCBmaWx0ZXIsIGV4cGFuZEVudGl0eVJlZmVyZW5jZXMpOwogfQog Cit2b2lkIERvY3VtZW50OjphZGRVc2VkQW5jaG9yKGNvbnN0IFN0cmluZyYgYW5jaG9yTmFtZSwg RWxlbWVudCogZWxlbWVudCkKK3sKKyAgICBtX3VzZWRBbmNob3JzLmFkZChhbmNob3JOYW1lLCBl bGVtZW50KTsKK30KKwogdm9pZCBEb2N1bWVudDo6c2NoZWR1bGVGb3JjZWRTdHlsZVJlY2FsYygp CiB7CiAgICAgbV9wZW5kaW5nU3R5bGVSZWNhbGNTaG91bGRGb3JjZSA9IHRydWU7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9kb20vRG9jdW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2RvbS9E b2N1bWVudC5oCmluZGV4IGE0MWEwNWRlMTM0ODEyYTg1M2RjZjUwYWEyMDlhZjNhZWRhMDdmZWIu LjNhYjJiYzVjNDEwY2I4ZjUyMjVmOTcxMWY0ZDBhMTkxNDE2OGIxYTcgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL2RvbS9Eb2N1bWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2RvbS9Eb2N1 bWVudC5oCkBAIC0xMTk2LDYgKzExOTYsOSBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIGNvbnN0 IFNlY3VyaXR5T3JpZ2luKiB0b3BPcmlnaW4oKSBjb25zdCBPVkVSUklERTsKIAorICAgIHZvaWQg YWRkVXNlZEFuY2hvcihjb25zdCBTdHJpbmcmIGFuY2hvck5hbWUsIEVsZW1lbnQqKTsKKyAgICBI YXNoTWFwPFN0cmluZywgRWxlbWVudCo+JiB1c2VkQW5jaG9ycygpIHsgcmV0dXJuIG1fdXNlZEFu Y2hvcnM7IH0KKwogcHJvdGVjdGVkOgogICAgIERvY3VtZW50KEZyYW1lKiwgY29uc3QgS1VSTCYs IGJvb2wgaXNYSFRNTCwgYm9vbCBpc0hUTUwpOwogCkBAIC0xNDU5LDYgKzE0NjIsOCBAQCBwcml2 YXRlOgogICAgIEhhc2hNYXA8U3RyaW5nSW1wbCosIEVsZW1lbnQqLCBDYXNlRm9sZGluZ0hhc2g+ IG1fZWxlbWVudHNCeUFjY2Vzc0tleTsgICAgCiAgICAgYm9vbCBtX2FjY2Vzc0tleU1hcFZhbGlk OwogCisgICAgSGFzaE1hcDxTdHJpbmcsIEVsZW1lbnQqPiBtX3VzZWRBbmNob3JzOworCiAgICAg T3duUHRyPFNlbGVjdG9yUXVlcnlDYWNoZT4gbV9zZWxlY3RvclF1ZXJ5Q2FjaGU7CiAKICAgICBi b29sIG1fdXNlU2VjdXJlS2V5Ym9hcmRFbnRyeVdoZW5BY3RpdmU7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1l Vmlldy5jcHAKaW5kZXggMWY1N2UwYzI3NGM3ZjNiOTAzYTdjNmM2NDE5ODAxZmFlNTU3NjkzYi4u ZjBlODM0YmI3MjcyY2JjOTM5NmI2Y2M1NWNjNmNmMjEyMDBlNjVhNiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv RnJhbWVWaWV3LmNwcApAQCAtMzQyNyw2ICszNDI3LDE0IEBAIHZvaWQgRnJhbWVWaWV3OjpwYWlu dENvbnRlbnRzKEdyYXBoaWNzQ29udGV4dCogcCwgY29uc3QgSW50UmVjdCYgcmVjdCkKIAogICAg IHJvb3RMYXllci0+cGFpbnQocCwgcmVjdCwgbV9wYWludEJlaGF2aW9yLCBlbHRSZW5kZXJlcik7 CiAKKyAgICBpZiAocC0+c3VwcG9ydHNJbnRlcm5hbExpbmtzKCkpIHsKKyAgICAgICAgSGFzaE1h cDxTdHJpbmcsIEVsZW1lbnQqPiYgdXNlZEFuY2hvcnMgPSBkb2N1bWVudC0+dXNlZEFuY2hvcnMo KTsKKyAgICAgICAgZm9yIChIYXNoTWFwPFN0cmluZywgRWxlbWVudCo+OjppdGVyYXRvciBpID0g dXNlZEFuY2hvcnMuYmVnaW4oKTsgaSAhPSB1c2VkQW5jaG9ycy5lbmQoKTsgKytpKSB7CisgICAg ICAgICAgICBpbnQgeSA9IGktPnZhbHVlLT5yZW5kZXJlcigpLT5hYnNvbHV0ZUJvdW5kaW5nQm94 UmVjdCgpLnkoKTsKKyAgICAgICAgICAgIHAtPmFkZERlc3RpbmF0aW9uQXRQb2ludChpLT5rZXks IEludFBvaW50KDAsIHkpKTsKKyAgICAgICAgfQorICAgIH0KKwogICAgIGlmIChyb290TGF5ZXIt PmNvbnRhaW5zRGlydHlPdmVybGF5U2Nyb2xsYmFycygpKQogICAgICAgICByb290TGF5ZXItPnBh aW50T3ZlcmxheVNjcm9sbGJhcnMocCwgcmVjdCwgbV9wYWludEJlaGF2aW9yLCBlbHRSZW5kZXJl cik7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBo aWNzQ29udGV4dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGlj c0NvbnRleHQuY3BwCmluZGV4IDUwN2I0ZGUwMjQ4NjViYjYzMmQ3ZjI4MWMzMjJjNGM5NzhmMTIz NjIuLmNmZmI1NmFlNjNlMjY1YTZiNmEwZDNiOTZiOGY0YmU1YTQzYTgyMjIgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmNwcApA QCAtMzMsNiArMzMsNyBAQAogI2luY2x1ZGUgIkludFJlY3QuaCIKICNpbmNsdWRlICJSb3VuZGVk UmVjdC5oIgogI2luY2x1ZGUgIlRleHRSdW4uaCIKKyNpbmNsdWRlIDx3dGYvVW51c2VkUGFyYW0u aD4KIAogI2luY2x1ZGUgInN0ZGlvLmgiCiAKQEAgLTI2NSw2ICsyNjYsMjYgQEAgYm9vbCBHcmFw aGljc0NvbnRleHQ6OnNob3VsZFN1YnBpeGVsUXVhbnRpemVGb250cygpIGNvbnN0CiAgICAgcmV0 dXJuIG1fc3RhdGUuc2hvdWxkU3VicGl4ZWxRdWFudGl6ZUZvbnRzOwogfQogCisjaWYgIVVTRShT S0lBKQorYm9vbCBHcmFwaGljc0NvbnRleHQ6OnN1cHBvcnRzSW50ZXJuYWxMaW5rcygpCit7Cisg ICAgcmV0dXJuIGZhbHNlOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0RGVzdGluYXRp b25Gb3JSZWN0KGNvbnN0IFN0cmluZyYgZGVzdE5hbWUsIGNvbnN0IEludFJlY3QmIHJlY3QpCit7 CisgICAgVU5VU0VEX1BBUkFNKGRlc3ROYW1lKTsKKyAgICBVTlVTRURfUEFSQU0ocmVjdCk7Cit9 CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjphZGREZXN0aW5hdGlvbkF0UG9pbnQoY29uc3QgU3Ry aW5nJiBuYW1lLCBjb25zdCBJbnRQb2ludCYgcG9zKQoreworICAgIFVOVVNFRF9QQVJBTShuYW1l KTsKKyAgICBVTlVTRURfUEFSQU0ocG9zKTsKK30KKworI2VuZGlmCisKIGNvbnN0IEdyYXBoaWNz Q29udGV4dFN0YXRlJiBHcmFwaGljc0NvbnRleHQ6OnN0YXRlKCkgY29uc3QKIHsKICAgICByZXR1 cm4gbV9zdGF0ZTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L0dyYXBoaWNzQ29udGV4dC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3Jh cGhpY3NDb250ZXh0LmgKaW5kZXggNWJjODg4MWI0MTc4OTUzMWY2MzVkMzgyZTZkMDNlYjY3NGYx NzZhOC4uMzE0MjNlZTc0ZTEyYjdmZTIzMjE1ZTZiNGRlOTVmNTQ0NGZlNDM0ZCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmgKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmgKQEAg LTQyMyw2ICs0MjMsOSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgdm9pZCBzZXRV UkxGb3JSZWN0KGNvbnN0IEtVUkwmLCBjb25zdCBJbnRSZWN0Jik7CiAKKyAgICAgICAgdm9pZCBz ZXREZXN0aW5hdGlvbkZvclJlY3QoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJbnRSZWN0Jik7 CisgICAgICAgIHZvaWQgYWRkRGVzdGluYXRpb25BdFBvaW50KGNvbnN0IFN0cmluZyYgbmFtZSwg Y29uc3QgSW50UG9pbnQmKTsKKwogICAgICAgICB2b2lkIGNvbmNhdENUTShjb25zdCBBZmZpbmVU cmFuc2Zvcm0mKTsKICAgICAgICAgdm9pZCBzZXRDVE0oY29uc3QgQWZmaW5lVHJhbnNmb3JtJik7 CiAKQEAgLTUzMiw2ICs1MzUsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAjZW5kaWYKIAogICAg ICAgICBzdGF0aWMgdm9pZCBhZGp1c3RMaW5lVG9QaXhlbEJvdW5kYXJpZXMoRmxvYXRQb2ludCYg cDEsIEZsb2F0UG9pbnQmIHAyLCBmbG9hdCBzdHJva2VXaWR0aCwgU3Ryb2tlU3R5bGUpOworICAg ICAgICBzdGF0aWMgYm9vbCBzdXBwb3J0c0ludGVybmFsTGlua3MoKTsKIAogICAgIHByaXZhdGU6 CiAgICAgICAgIHZvaWQgcGxhdGZvcm1Jbml0KFBsYXRmb3JtR3JhcGhpY3NDb250ZXh0Kik7CkBA IC02MjAsNCArNjI0LDMgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogfSAvLyBuYW1lc3BhY2UgV2Vi Q29yZQogCiAjZW5kaWYgLy8gR3JhcGhpY3NDb250ZXh0X2gKLQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvc2tpYS9HcmFwaGljc0NvbnRleHRTa2lhLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3NraWEvR3JhcGhpY3NDb250ZXh0U2tp YS5jcHAKaW5kZXggNmE1NmNjYjVlMjMwMzczNzk3MTBjNzZiNjBmNTg4YTFkZGNjMmE2Ni4uYzhl ZTk5MjJkMDBjNjM5ODhlNmJhZGQ0MDRhYTM3OGIwM2QzNjQxMSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvc2tpYS9HcmFwaGljc0NvbnRleHRTa2lhLmNwcAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9za2lhL0dyYXBoaWNzQ29udGV4 dFNraWEuY3BwCkBAIC0xMTA4LDYgKzExMDgsMzAgQEAgdm9pZCBHcmFwaGljc0NvbnRleHQ6OnNl dFVSTEZvclJlY3QoY29uc3QgS1VSTCYgbGluaywgY29uc3QgSW50UmVjdCYgZGVzdFJlY3QpCiAg ICAgU2tBbm5vdGF0ZVJlY3RXaXRoVVJMKHBsYXRmb3JtQ29udGV4dCgpLT5jYW52YXMoKSwgZGVz dFJlY3QsIHVybC5nZXQoKSk7CiB9CiAKK2Jvb2wgR3JhcGhpY3NDb250ZXh0OjpzdXBwb3J0c0lu dGVybmFsTGlua3MoKQoreworICAgIHJldHVybiB0cnVlOworfQorCit2b2lkIEdyYXBoaWNzQ29u dGV4dDo6c2V0RGVzdGluYXRpb25Gb3JSZWN0KGNvbnN0IFN0cmluZyYgZGVzdE5hbWUsIGNvbnN0 IEludFJlY3QmIHJlY3QpCit7CisgICAgaWYgKHBhaW50aW5nRGlzYWJsZWQoKSkKKyAgICAgICAg cmV0dXJuOworCisgICAgU2tBdXRvRGF0YVVucmVmIHNrRGVzdE5hbWUoU2tEYXRhOjpOZXdXaXRo Q1N0cmluZyhkZXN0TmFtZS51dGY4KCkuZGF0YSgpKSk7CisgICAgU2tBbm5vdGF0ZUxpbmtUb0Rl c3RpbmF0aW9uKHBsYXRmb3JtQ29udGV4dCgpLT5jYW52YXMoKSwgcmVjdCwgc2tEZXN0TmFtZS5n ZXQoKSk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjphZGREZXN0aW5hdGlvbkF0UG9pbnQo Y29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJbnRQb2ludCYgcG9zKQoreworICAgIGlmIChwYWlu dGluZ0Rpc2FibGVkKCkpCisgICAgICAgIHJldHVybjsKKworICAgIFNrQXV0b0RhdGFVbnJlZiBu YW1lRGF0YShTa0RhdGE6Ok5ld1dpdGhDU3RyaW5nKG5hbWUudXRmOCgpLmRhdGEoKSkpOworICAg IFNrQW5ub3RhdGVOYW1lZERlc3RpbmF0aW9uKHBsYXRmb3JtQ29udGV4dCgpLT5jYW52YXMoKSwK KyAgICAgICAgU2tQb2ludDo6TWFrZShwb3MueCgpLCBwb3MueSgpKSwgbmFtZURhdGEpOworfQor CiB2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0UGxhdGZvcm1TaG91bGRBbnRpYWxpYXMoYm9vbCBl bmFibGUpCiB7CiAgICAgaWYgKHBhaW50aW5nRGlzYWJsZWQoKSkKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKaW5kZXggYzc2YjAwYTFlNTk0NTNhZjA3ODgxY2M4ZTg2 OWQ0ZmY0YTM4N2U2ZC4uNDE1ODRlNWRhMjQ4YWZmNTgyNGY1MjNkNGU2ZjE3OGNiNTQyZmM2MCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKKysr IGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKQEAgLTExMTQsNyAr MTExNCwxOSBAQCB2b2lkIFJlbmRlck9iamVjdDo6YWRkUERGVVJMUmVjdChHcmFwaGljc0NvbnRl eHQqIGNvbnRleHQsIGNvbnN0IExheW91dFJlY3QmIHJlYwogICAgIGNvbnN0IEF0b21pY1N0cmlu ZyYgaHJlZiA9IHN0YXRpY19jYXN0PEVsZW1lbnQqPihuKS0+Z2V0QXR0cmlidXRlKGhyZWZBdHRy KTsKICAgICBpZiAoaHJlZi5pc051bGwoKSkKICAgICAgICAgcmV0dXJuOwotICAgIGNvbnRleHQt PnNldFVSTEZvclJlY3Qobi0+ZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwoaHJlZiksIHBpeGVsU25h cHBlZEludFJlY3QocmVjdCkpOworICAgIEtVUkwgdXJsID0gbi0+ZG9jdW1lbnQoKS0+Y29tcGxl dGVVUkwoaHJlZik7CisgICAgaWYgKCF1cmwuaXNWYWxpZCgpKQorICAgICAgICByZXR1cm47Cisg ICAgaWYgKGNvbnRleHQtPnN1cHBvcnRzSW50ZXJuYWxMaW5rcygpICYmIHVybC5oYXNGcmFnbWVu dElkZW50aWZpZXIoKSAmJiBlcXVhbElnbm9yaW5nRnJhZ21lbnRJZGVudGlmaWVyKHVybCwgbi0+ ZG9jdW1lbnQoKS0+YmFzZVVSTCgpKSkgeworICAgICAgICBTdHJpbmcgbmFtZSA9IHVybC5mcmFn bWVudElkZW50aWZpZXIoKTsKKyAgICAgICAgRWxlbWVudCogZWxlbWVudCA9IGRvY3VtZW50KCkt PmZpbmRBbmNob3IobmFtZSk7CisgICAgICAgIGlmIChlbGVtZW50KSB7CisgICAgICAgICAgICBk b2N1bWVudCgpLT5hZGRVc2VkQW5jaG9yKG5hbWUsIGVsZW1lbnQpOworICAgICAgICAgICAgY29u dGV4dC0+c2V0RGVzdGluYXRpb25Gb3JSZWN0KG5hbWUsIHBpeGVsU25hcHBlZEludFJlY3QocmVj dCkpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9CisgICAgfQorICAgIGNvbnRleHQt PnNldFVSTEZvclJlY3QodXJsLCBwaXhlbFNuYXBwZWRJbnRSZWN0KHJlY3QpKTsKIH0KIAogdm9p ZCBSZW5kZXJPYmplY3Q6OnBhaW50T3V0bGluZShQYWludEluZm8mIHBhaW50SW5mbywgY29uc3Qg TGF5b3V0UmVjdCYgcGFpbnRSZWN0KQo= 193232 2013-03-14 22:17:40 -0700 2013-03-20 20:36:55 -0700 Patch bug-112081-20130315161335.patch text/plain 8067 dml+webkit U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ1ODAyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWRiOWE2MmM4MmMwOTUx NGQ4MDJiYjBjZWIzZTA1MGIyZDM3YTI0OC4uOTNiMzQ3MTM5MGE3Yzg2MWZlMDA5NzQwNWM2MTlh ZDgzNzEwNGQyZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEzLTAzLTExICBEYXZp ZCBMYXR0aW1vcmUgIDxkbWwrd2Via2l0QGdvb2dsZS5jb20+CisKKyAgICAgICAgUHJpbnRpbmcg dG8gUERGIHNob3VsZCBwcm9kdWNlIGludGVybmFsIGxpbmtzIHdoZW4gSFRNTCBoYXMgaW50ZXJu YWwgbGlua3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTExMjA4MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFRoaXMgY2hhbmdlIGRvZXNuJ3QgaGF2ZSBhbnkgdGVzdHMgYmVjYXVzZSBQREYgZ2VuZXJhdGlv biBkb2Vzbid0CisgICAgICAgIGhhdmUgYW55IGV4aXN0aW5nIHRlc3RzLiBNYW51YWwgdGVzdGlu ZyB3YXMgcGVyZm9ybWVkIGluIENocm9taXVtCisgICAgICAgIGFuZCBhIGhlYWRsZXNzIHZlcnNp b24gb2YgV2ViS2l0IHdpdGggYSB2YXJpZXR5IG9mIGxpbmtzIGFuZAorICAgICAgICBhbmNob3Jz LgorCiAyMDEzLTAzLTE0ICBNYXJqYSBIw7ZsdHTDpCAgPG1hcmphQGNocm9taXVtLm9yZz4KIAog ICAgICAgICBbVjhdIFN0b3JlIG1haW4gd29ybGQgYW5kIG5vbi1tYWluIHdvcmxkIHRlbXBsYXRl cyBzZXBhcmF0ZWx5LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcu Y3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCmluZGV4IDY2NGJlMDdkOGRl NWQ1NGNiNTFiY2UxMmVjZWUzNmMzY2Q2NDJjN2IuLjU5NzNlZmQ2NTg3MmU4NGYxNzAxMGQ5NTc1 ZTY0ODhkZjZlZjhhMGEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKQEAgLTM0MzIsNiAr MzQzMiw5IEBAIHZvaWQgRnJhbWVWaWV3OjpwYWludENvbnRlbnRzKEdyYXBoaWNzQ29udGV4dCog cCwgY29uc3QgSW50UmVjdCYgcmVjdCkKIAogICAgIHJvb3RMYXllci0+cGFpbnQocCwgcmVjdCwg bV9wYWludEJlaGF2aW9yLCBlbHRSZW5kZXJlcik7CiAKKyAgICBpZiAocC0+c3VwcG9ydHNJbnRl cm5hbExpbmtzKCkpCisgICAgICAgIG91dHB1dExpbmtlZERlc3RpbmF0aW9ucyhwLCBkb2N1bWVu dCwgcmVjdCk7CisKICAgICBpZiAocm9vdExheWVyLT5jb250YWluc0RpcnR5T3ZlcmxheVNjcm9s bGJhcnMoKSkKICAgICAgICAgcm9vdExheWVyLT5wYWludE92ZXJsYXlTY3JvbGxiYXJzKHAsIHJl Y3QsIG1fcGFpbnRCZWhhdmlvciwgZWx0UmVuZGVyZXIpOwogCkBAIC0zNDU1LDYgKzM0NTgsMzEg QEAgdm9pZCBGcmFtZVZpZXc6OnBhaW50Q29udGVudHMoR3JhcGhpY3NDb250ZXh0KiBwLCBjb25z dCBJbnRSZWN0JiByZWN0KQogICAgIEluc3BlY3Rvckluc3RydW1lbnRhdGlvbjo6ZGlkUGFpbnQo Y29va2llLCBwLCByZWN0KTsKIH0KIAordm9pZCBGcmFtZVZpZXc6Om91dHB1dExpbmtlZERlc3Rp bmF0aW9ucyhHcmFwaGljc0NvbnRleHQqIGdyYXBoaWNzQ29udGV4dCwgTm9kZSogbm9kZSwgY29u c3QgSW50UmVjdCYgcGFnZVJlY3QpCit7CisgICAgZm9yIChOb2RlKiBpID0gbm9kZS0+Zmlyc3RD aGlsZCgpOyBpOyBpID0gaS0+bmV4dFNpYmxpbmcoKSkKKyAgICAgICAgb3V0cHV0TGlua2VkRGVz dGluYXRpb25zKGdyYXBoaWNzQ29udGV4dCwgaSwgcGFnZVJlY3QpOworCisgICAgaWYgKCFub2Rl LT5pc0xpbmsoKSB8fCAhbm9kZS0+aXNFbGVtZW50Tm9kZSgpKQorICAgICAgICByZXR1cm47Cisg ICAgY29uc3QgQXRvbWljU3RyaW5nJiBocmVmID0gc3RhdGljX2Nhc3Q8RWxlbWVudCo+KG5vZGUp LT5nZXRBdHRyaWJ1dGUoaHJlZkF0dHIpOworICAgIGlmIChocmVmLmlzTnVsbCgpKQorICAgICAg ICByZXR1cm47CisgICAgS1VSTCB1cmwgPSBub2RlLT5kb2N1bWVudCgpLT5jb21wbGV0ZVVSTCho cmVmKTsKKyAgICBpZiAoIXVybC5pc1ZhbGlkKCkpCisgICAgICAgIHJldHVybjsKKyAgICBpZiAo dXJsLmhhc0ZyYWdtZW50SWRlbnRpZmllcigpICYmIGVxdWFsSWdub3JpbmdGcmFnbWVudElkZW50 aWZpZXIodXJsLCBub2RlLT5kb2N1bWVudCgpLT5iYXNlVVJMKCkpKSB7CisgICAgICAgIFN0cmlu ZyBuYW1lID0gdXJsLmZyYWdtZW50SWRlbnRpZmllcigpOworICAgICAgICBFbGVtZW50KiBlbGVt ZW50ID0gbm9kZS0+ZG9jdW1lbnQoKS0+ZmluZEFuY2hvcihuYW1lKTsKKyAgICAgICAgaWYgKGVs ZW1lbnQpIHsKKyAgICAgICAgICAgIEludFJlY3QgYmIgPSBlbGVtZW50LT5yZW5kZXJlcigpLT5h YnNvbHV0ZUJvdW5kaW5nQm94UmVjdCgpOworICAgICAgICAgICAgSW50UG9pbnQgcG9pbnQoYmIu eCgpLCBiYi55KCkpOworICAgICAgICAgICAgaWYgKHBhZ2VSZWN0LmNvbnRhaW5zKHBvaW50KSkK KyAgICAgICAgICAgICAgICBncmFwaGljc0NvbnRleHQtPmFkZERlc3RpbmF0aW9uQXRQb2ludChu YW1lLCBwb2ludCk7CisgICAgICAgIH0KKyAgICB9Cit9CisKIHZvaWQgRnJhbWVWaWV3OjpzZXRQ YWludEJlaGF2aW9yKFBhaW50QmVoYXZpb3IgYmVoYXZpb3IpCiB7CiAgICAgbV9wYWludEJlaGF2 aW9yID0gYmVoYXZpb3I7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmll dy5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuaAppbmRleCAxNDhkYzYxYjJmYjcy ZGRmN2I3N2Q4ZTUzNjYyOWRhM2ExMmYzNzlkLi44NGNlOGE0OWRkOTNhNTVkYmRkZDM1YzkxMzRk NTc4NjE4MmE2YjBmIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5o CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3LmgKQEAgLTQ5Myw2ICs0OTMsOCBA QCBwcml2YXRlOgogCiAgICAgYm9vbCBkb0xheW91dFdpdGhGcmFtZUZsYXR0ZW5pbmcoYm9vbCBh bGxvd1N1YnRyZWUpOwogCisgICAgdm9pZCBvdXRwdXRMaW5rZWREZXN0aW5hdGlvbnMoR3JhcGhp Y3NDb250ZXh0KiwgTm9kZSosIGNvbnN0IEludFJlY3QmIHBhZ2VSZWN0KTsKKwogICAgIHZpcnR1 YWwgQVhPYmplY3RDYWNoZSogYXhPYmplY3RDYWNoZSgpIGNvbnN0OwogICAgIHZvaWQgbm90aWZ5 V2lkZ2V0c0luQWxsRnJhbWVzKFdpZGdldE5vdGlmaWNhdGlvbik7CiAgICAgdm9pZCByZW1vdmVG cm9tQVhPYmplY3RDYWNoZSgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL0dyYXBoaWNzQ29udGV4dC5jcHAKaW5kZXggNTA3YjRkZTAyNDg2NWJiNjMyZDdmMjgx YzMyMmM0Yzk3OGYxMjM2Mi4uY2ZmYjU2YWU2M2UyNjVhNmI2YTBkM2I5NmI4ZjRiZTVhNDNhODIy MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3ND b250ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGlj c0NvbnRleHQuY3BwCkBAIC0zMyw2ICszMyw3IEBACiAjaW5jbHVkZSAiSW50UmVjdC5oIgogI2lu Y2x1ZGUgIlJvdW5kZWRSZWN0LmgiCiAjaW5jbHVkZSAiVGV4dFJ1bi5oIgorI2luY2x1ZGUgPHd0 Zi9VbnVzZWRQYXJhbS5oPgogCiAjaW5jbHVkZSAic3RkaW8uaCIKIApAQCAtMjY1LDYgKzI2Niwy NiBAQCBib29sIEdyYXBoaWNzQ29udGV4dDo6c2hvdWxkU3VicGl4ZWxRdWFudGl6ZUZvbnRzKCkg Y29uc3QKICAgICByZXR1cm4gbV9zdGF0ZS5zaG91bGRTdWJwaXhlbFF1YW50aXplRm9udHM7CiB9 CiAKKyNpZiAhVVNFKFNLSUEpCitib29sIEdyYXBoaWNzQ29udGV4dDo6c3VwcG9ydHNJbnRlcm5h bExpbmtzKCkKK3sKKyAgICByZXR1cm4gZmFsc2U7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0 OjpzZXREZXN0aW5hdGlvbkZvclJlY3QoY29uc3QgU3RyaW5nJiBkZXN0TmFtZSwgY29uc3QgSW50 UmVjdCYgcmVjdCkKK3sKKyAgICBVTlVTRURfUEFSQU0oZGVzdE5hbWUpOworICAgIFVOVVNFRF9Q QVJBTShyZWN0KTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmFkZERlc3RpbmF0aW9uQXRQ b2ludChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IEludFBvaW50JiBwb3MpCit7CisgICAgVU5V U0VEX1BBUkFNKG5hbWUpOworICAgIFVOVVNFRF9QQVJBTShwb3MpOworfQorCisjZW5kaWYKKwog Y29uc3QgR3JhcGhpY3NDb250ZXh0U3RhdGUmIEdyYXBoaWNzQ29udGV4dDo6c3RhdGUoKSBjb25z dAogewogICAgIHJldHVybiBtX3N0YXRlOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuaAppbmRleCA1YmM4ODgxYjQxNzg5NTMxZjYzNWQz ODJlNmQwM2ViNjc0ZjE3NmE4Li4zMTQyM2VlNzRlMTJiN2ZlMjMyMTVlNmI0ZGU5NWY1NDQ0ZmU0 MzRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGlj c0NvbnRleHQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGlj c0NvbnRleHQuaApAQCAtNDIzLDYgKzQyMyw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAg ICAgICB2b2lkIHNldFVSTEZvclJlY3QoY29uc3QgS1VSTCYsIGNvbnN0IEludFJlY3QmKTsKIAor ICAgICAgICB2b2lkIHNldERlc3RpbmF0aW9uRm9yUmVjdChjb25zdCBTdHJpbmcmIG5hbWUsIGNv bnN0IEludFJlY3QmKTsKKyAgICAgICAgdm9pZCBhZGREZXN0aW5hdGlvbkF0UG9pbnQoY29uc3Qg U3RyaW5nJiBuYW1lLCBjb25zdCBJbnRQb2ludCYpOworCiAgICAgICAgIHZvaWQgY29uY2F0Q1RN KGNvbnN0IEFmZmluZVRyYW5zZm9ybSYpOwogICAgICAgICB2b2lkIHNldENUTShjb25zdCBBZmZp bmVUcmFuc2Zvcm0mKTsKIApAQCAtNTMyLDYgKzUzNSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK ICNlbmRpZgogCiAgICAgICAgIHN0YXRpYyB2b2lkIGFkanVzdExpbmVUb1BpeGVsQm91bmRhcmll cyhGbG9hdFBvaW50JiBwMSwgRmxvYXRQb2ludCYgcDIsIGZsb2F0IHN0cm9rZVdpZHRoLCBTdHJv a2VTdHlsZSk7CisgICAgICAgIHN0YXRpYyBib29sIHN1cHBvcnRzSW50ZXJuYWxMaW5rcygpOwog CiAgICAgcHJpdmF0ZToKICAgICAgICAgdm9pZCBwbGF0Zm9ybUluaXQoUGxhdGZvcm1HcmFwaGlj c0NvbnRleHQqKTsKQEAgLTYyMCw0ICs2MjQsMyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiB9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBHcmFwaGljc0NvbnRleHRfaAotCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9za2lhL0dyYXBoaWNzQ29u dGV4dFNraWEuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvc2tpYS9HcmFw aGljc0NvbnRleHRTa2lhLmNwcAppbmRleCA2YTU2Y2NiNWUyMzAzNzM3OTcxMGM3NmI2MGY1ODhh MWRkY2MyYTY2Li5jOGVlOTkyMmQwMGM2Mzk4OGU2YmFkZDQwNGFhMzc4YjAzZDM2NDExIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9za2lhL0dyYXBoaWNzQ29u dGV4dFNraWEuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3NraWEv R3JhcGhpY3NDb250ZXh0U2tpYS5jcHAKQEAgLTExMDgsNiArMTEwOCwzMCBAQCB2b2lkIEdyYXBo aWNzQ29udGV4dDo6c2V0VVJMRm9yUmVjdChjb25zdCBLVVJMJiBsaW5rLCBjb25zdCBJbnRSZWN0 JiBkZXN0UmVjdCkKICAgICBTa0Fubm90YXRlUmVjdFdpdGhVUkwocGxhdGZvcm1Db250ZXh0KCkt PmNhbnZhcygpLCBkZXN0UmVjdCwgdXJsLmdldCgpKTsKIH0KIAorYm9vbCBHcmFwaGljc0NvbnRl eHQ6OnN1cHBvcnRzSW50ZXJuYWxMaW5rcygpCit7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3Zv aWQgR3JhcGhpY3NDb250ZXh0OjpzZXREZXN0aW5hdGlvbkZvclJlY3QoY29uc3QgU3RyaW5nJiBk ZXN0TmFtZSwgY29uc3QgSW50UmVjdCYgcmVjdCkKK3sKKyAgICBpZiAocGFpbnRpbmdEaXNhYmxl ZCgpKQorICAgICAgICByZXR1cm47CisKKyAgICBTa0F1dG9EYXRhVW5yZWYgc2tEZXN0TmFtZShT a0RhdGE6Ok5ld1dpdGhDU3RyaW5nKGRlc3ROYW1lLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBTa0Fu bm90YXRlTGlua1RvRGVzdGluYXRpb24ocGxhdGZvcm1Db250ZXh0KCktPmNhbnZhcygpLCByZWN0 LCBza0Rlc3ROYW1lLmdldCgpKTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmFkZERlc3Rp bmF0aW9uQXRQb2ludChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IEludFBvaW50JiBwb3MpCit7 CisgICAgaWYgKHBhaW50aW5nRGlzYWJsZWQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgU2tB dXRvRGF0YVVucmVmIG5hbWVEYXRhKFNrRGF0YTo6TmV3V2l0aENTdHJpbmcobmFtZS51dGY4KCku ZGF0YSgpKSk7CisgICAgU2tBbm5vdGF0ZU5hbWVkRGVzdGluYXRpb24ocGxhdGZvcm1Db250ZXh0 KCktPmNhbnZhcygpLAorICAgICAgICBTa1BvaW50OjpNYWtlKHBvcy54KCksIHBvcy55KCkpLCBu YW1lRGF0YSk7Cit9CisKIHZvaWQgR3JhcGhpY3NDb250ZXh0OjpzZXRQbGF0Zm9ybVNob3VsZEFu dGlhbGlhcyhib29sIGVuYWJsZSkKIHsKICAgICBpZiAocGFpbnRpbmdEaXNhYmxlZCgpKQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAppbmRleCBiMTQ4YTU4YjVjMmI4 YjM1ZTE2MTYzNzkxNmY3MGE5Y2Q3M2FmOTZlLi5jNjc4MTllNmY1Zjc4YmFhNDA2YTkxMzNmOTUw NDUwYzkwZmY3YTQzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy T2JqZWN0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNw cApAQCAtMTExNCw3ICsxMTE0LDE2IEBAIHZvaWQgUmVuZGVyT2JqZWN0OjphZGRQREZVUkxSZWN0 KEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwgY29uc3QgTGF5b3V0UmVjdCYgcmVjCiAgICAgY29u c3QgQXRvbWljU3RyaW5nJiBocmVmID0gdG9FbGVtZW50KG4pLT5nZXRBdHRyaWJ1dGUoaHJlZkF0 dHIpOwogICAgIGlmIChocmVmLmlzTnVsbCgpKQogICAgICAgICByZXR1cm47Ci0gICAgY29udGV4 dC0+c2V0VVJMRm9yUmVjdChuLT5kb2N1bWVudCgpLT5jb21wbGV0ZVVSTChocmVmKSwgcGl4ZWxT bmFwcGVkSW50UmVjdChyZWN0KSk7CisgICAgS1VSTCB1cmwgPSBuLT5kb2N1bWVudCgpLT5jb21w bGV0ZVVSTChocmVmKTsKKyAgICBpZiAoIXVybC5pc1ZhbGlkKCkpCisgICAgICAgIHJldHVybjsK KyAgICBpZiAoY29udGV4dC0+c3VwcG9ydHNJbnRlcm5hbExpbmtzKCkgJiYgdXJsLmhhc0ZyYWdt ZW50SWRlbnRpZmllcigpICYmIGVxdWFsSWdub3JpbmdGcmFnbWVudElkZW50aWZpZXIodXJsLCBu LT5kb2N1bWVudCgpLT5iYXNlVVJMKCkpKSB7CisgICAgICAgIFN0cmluZyBuYW1lID0gdXJsLmZy YWdtZW50SWRlbnRpZmllcigpOworICAgICAgICBpZiAoZG9jdW1lbnQoKS0+ZmluZEFuY2hvcihu YW1lKSkKKyAgICAgICAgICAgIGNvbnRleHQtPnNldERlc3RpbmF0aW9uRm9yUmVjdChuYW1lLCBw aXhlbFNuYXBwZWRJbnRSZWN0KHJlY3QpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBj b250ZXh0LT5zZXRVUkxGb3JSZWN0KHVybCwgcGl4ZWxTbmFwcGVkSW50UmVjdChyZWN0KSk7CiB9 CiAKIHZvaWQgUmVuZGVyT2JqZWN0OjpwYWludE91dGxpbmUoUGFpbnRJbmZvJiBwYWludEluZm8s IGNvbnN0IExheW91dFJlY3QmIHBhaW50UmVjdCkK 194177 2013-03-20 20:37:03 -0700 2013-03-21 17:57:50 -0700 Patch bug-112081-20130321143252.patch text/plain 9408 dml+webkit U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ1ODAyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWRiOWE2MmM4MmMwOTUx NGQ4MDJiYjBjZWIzZTA1MGIyZDM3YTI0OC4uOTNiMzQ3MTM5MGE3Yzg2MWZlMDA5NzQwNWM2MTlh ZDgzNzEwNGQyZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEzLTAzLTExICBEYXZp ZCBMYXR0aW1vcmUgIDxkbWwrd2Via2l0QGdvb2dsZS5jb20+CisKKyAgICAgICAgUHJpbnRpbmcg dG8gUERGIHNob3VsZCBwcm9kdWNlIGludGVybmFsIGxpbmtzIHdoZW4gSFRNTCBoYXMgaW50ZXJu YWwgbGlua3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTExMjA4MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFRoaXMgY2hhbmdlIGRvZXNuJ3QgaGF2ZSBhbnkgdGVzdHMgYmVjYXVzZSBQREYgZ2VuZXJhdGlv biBkb2Vzbid0CisgICAgICAgIGhhdmUgYW55IGV4aXN0aW5nIHRlc3RzLiBNYW51YWwgdGVzdGlu ZyB3YXMgcGVyZm9ybWVkIGluIENocm9taXVtCisgICAgICAgIGFuZCBhIGhlYWRsZXNzIHZlcnNp b24gb2YgV2ViS2l0IHdpdGggYSB2YXJpZXR5IG9mIGxpbmtzIGFuZAorICAgICAgICBhbmNob3Jz LgorCiAyMDEzLTAzLTE0ICBNYXJqYSBIw7ZsdHTDpCAgPG1hcmphQGNocm9taXVtLm9yZz4KIAog ICAgICAgICBbVjhdIFN0b3JlIG1haW4gd29ybGQgYW5kIG5vbi1tYWluIHdvcmxkIHRlbXBsYXRl cyBzZXBhcmF0ZWx5LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcu Y3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuY3BwCmluZGV4IDY2NGJlMDdkOGRl NWQ1NGNiNTFiY2UxMmVjZWUzNmMzY2Q2NDJjN2IuLjA3NWQzODkwMjhiZTM2ZDZjYmJiNWQ5Y2Jm MDUxODUyNDE3M2JkZmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvRnJhbWVWaWV3 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5jcHAKQEAgLTE5MSw2ICsx OTEsNyBAQCBGcmFtZVZpZXc6OkZyYW1lVmlldyhGcmFtZSogZnJhbWUpCiAgICAgLCBtX3Nob3Vs ZFVwZGF0ZVdoaWxlT2Zmc2NyZWVuKHRydWUpCiAgICAgLCBtX2RlZmVyU2V0TmVlZHNMYXlvdXRz KDApCiAgICAgLCBtX3NldE5lZWRzTGF5b3V0V2FzRGVmZXJyZWQoZmFsc2UpCisgICAgLCBtX2xp bmtlZERlc3RpbmF0aW9uc1ZhbGlkKGZhbHNlKQogICAgICwgbV9zY3JvbGxDb3JuZXIoMCkKICAg ICAsIG1fc2hvdWxkQXV0b1NpemUoZmFsc2UpCiAgICAgLCBtX2luQXV0b1NpemUoZmFsc2UpCkBA IC0yOTgsNiArMjk5LDggQEAgdm9pZCBGcmFtZVZpZXc6OnJlc2V0KCkKICAgICBtX2ZpcnN0Vmlz dWFsbHlOb25FbXB0eUxheW91dENhbGxiYWNrUGVuZGluZyA9IHRydWU7CiAgICAgbV9tYWludGFp blNjcm9sbFBvc2l0aW9uQW5jaG9yID0gMDsKICAgICBtX2Rpc2FibGVSZXBhaW50cyA9IDA7Cisg ICAgbV9saW5rZWREZXN0aW5hdGlvbnNWYWxpZCA9IGZhbHNlOworICAgIG1fbGlua2VkRGVzdGlu YXRpb25zLmNsZWFyKCk7CiB9CiAKIHZvaWQgRnJhbWVWaWV3OjpyZW1vdmVGcm9tQVhPYmplY3RD YWNoZSgpCkBAIC0zNDMyLDYgKzM0MzUsOSBAQCB2b2lkIEZyYW1lVmlldzo6cGFpbnRDb250ZW50 cyhHcmFwaGljc0NvbnRleHQqIHAsIGNvbnN0IEludFJlY3QmIHJlY3QpCiAKICAgICByb290TGF5 ZXItPnBhaW50KHAsIHJlY3QsIG1fcGFpbnRCZWhhdmlvciwgZWx0UmVuZGVyZXIpOwogCisgICAg aWYgKHAtPnN1cHBvcnRzSW50ZXJuYWxMaW5rcygpKQorICAgICAgICBvdXRwdXRMaW5rZWREZXN0 aW5hdGlvbnMocCwgZG9jdW1lbnQsIHJlY3QpOworCiAgICAgaWYgKHJvb3RMYXllci0+Y29udGFp bnNEaXJ0eU92ZXJsYXlTY3JvbGxiYXJzKCkpCiAgICAgICAgIHJvb3RMYXllci0+cGFpbnRPdmVy bGF5U2Nyb2xsYmFycyhwLCByZWN0LCBtX3BhaW50QmVoYXZpb3IsIGVsdFJlbmRlcmVyKTsKIApA QCAtMzQ1NSw2ICszNDYxLDQzIEBAIHZvaWQgRnJhbWVWaWV3OjpwYWludENvbnRlbnRzKEdyYXBo aWNzQ29udGV4dCogcCwgY29uc3QgSW50UmVjdCYgcmVjdCkKICAgICBJbnNwZWN0b3JJbnN0cnVt ZW50YXRpb246OmRpZFBhaW50KGNvb2tpZSwgcCwgcmVjdCk7CiB9CiAKK3ZvaWQgRnJhbWVWaWV3 Ojpjb2xsZWN0TGlua2VkRGVzdGluYXRpb25zKE5vZGUqIG5vZGUpCit7CisgICAgZm9yIChOb2Rl KiBpID0gbm9kZS0+Zmlyc3RDaGlsZCgpOyBpOyBpID0gaS0+bmV4dFNpYmxpbmcoKSkKKyAgICAg ICAgY29sbGVjdExpbmtlZERlc3RpbmF0aW9ucyhpKTsKKworICAgIGlmICghbm9kZS0+aXNMaW5r KCkgfHwgIW5vZGUtPmlzRWxlbWVudE5vZGUoKSkKKyAgICAgICAgcmV0dXJuOworICAgIGNvbnN0 IEF0b21pY1N0cmluZyYgaHJlZiA9IHN0YXRpY19jYXN0PEVsZW1lbnQqPihub2RlKS0+Z2V0QXR0 cmlidXRlKGhyZWZBdHRyKTsKKyAgICBpZiAoaHJlZi5pc051bGwoKSkKKyAgICAgICAgcmV0dXJu OworICAgIEtVUkwgdXJsID0gbm9kZS0+ZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwoaHJlZik7Cisg ICAgaWYgKCF1cmwuaXNWYWxpZCgpKQorICAgICAgICByZXR1cm47CisgICAgaWYgKHVybC5oYXNG cmFnbWVudElkZW50aWZpZXIoKSAmJiBlcXVhbElnbm9yaW5nRnJhZ21lbnRJZGVudGlmaWVyKHVy bCwgbm9kZS0+ZG9jdW1lbnQoKS0+YmFzZVVSTCgpKSkgeworICAgICAgICBTdHJpbmcgbmFtZSA9 IHVybC5mcmFnbWVudElkZW50aWZpZXIoKTsKKyAgICAgICAgRWxlbWVudCogZWxlbWVudCA9IG5v ZGUtPmRvY3VtZW50KCktPmZpbmRBbmNob3IobmFtZSk7CisgICAgICAgIGlmIChlbGVtZW50KQor ICAgICAgICAgICAgbV9saW5rZWREZXN0aW5hdGlvbnMuc2V0KG5hbWUsIGVsZW1lbnQpOworICAg IH0KK30KKwordm9pZCBGcmFtZVZpZXc6Om91dHB1dExpbmtlZERlc3RpbmF0aW9ucyhHcmFwaGlj c0NvbnRleHQqIGdyYXBoaWNzQ29udGV4dCwgTm9kZSogbm9kZSwgY29uc3QgSW50UmVjdCYgcGFn ZVJlY3QpCit7CisgICAgaWYgKCFtX2xpbmtlZERlc3RpbmF0aW9uc1ZhbGlkKSB7CisgICAgICAg IGNvbGxlY3RMaW5rZWREZXN0aW5hdGlvbnMobm9kZSk7CisgICAgICAgIG1fbGlua2VkRGVzdGlu YXRpb25zVmFsaWQgPSB0cnVlOworICAgIH0KKworICAgIEhhc2hNYXA8U3RyaW5nLCBFbGVtZW50 Kj46OmNvbnN0X2l0ZXJhdG9yIGVuZCA9IG1fbGlua2VkRGVzdGluYXRpb25zLmVuZCgpOworICAg IGZvciAoSGFzaE1hcDxTdHJpbmcsIEVsZW1lbnQqPjo6Y29uc3RfaXRlcmF0b3IgaXQgPSBtX2xp bmtlZERlc3RpbmF0aW9ucy5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAgSW50 UmVjdCBiYiA9IGl0LT52YWx1ZS0+cmVuZGVyZXIoKS0+YWJzb2x1dGVCb3VuZGluZ0JveFJlY3Qo KTsKKyAgICAgICAgSW50UG9pbnQgcG9pbnQoYmIueCgpLCBiYi55KCkpOworICAgICAgICBpZiAo cGFnZVJlY3QuY29udGFpbnMocG9pbnQpKQorICAgICAgICAgICAgZ3JhcGhpY3NDb250ZXh0LT5h ZGREZXN0aW5hdGlvbkF0UG9pbnQoaXQtPmtleSwgcG9pbnQpOworICAgIH0KK30KKwogdm9pZCBG cmFtZVZpZXc6OnNldFBhaW50QmVoYXZpb3IoUGFpbnRCZWhhdmlvciBiZWhhdmlvcikKIHsKICAg ICBtX3BhaW50QmVoYXZpb3IgPSBiZWhhdmlvcjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvRnJhbWVWaWV3LmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL0ZyYW1lVmlldy5oCmluZGV4 IDE0OGRjNjFiMmZiNzJkZGY3Yjc3ZDhlNTM2NjI5ZGEzYTEyZjM3OWQuLmMxNGQ1N2EyYmQyMGYw MDlkNzI3MDE4NDU3OWQyMTU1MjAyMzYxZGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvRnJhbWVWaWV3LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9GcmFtZVZpZXcuaApAQCAt NDkzLDYgKzQ5Myw5IEBAIHByaXZhdGU6CiAKICAgICBib29sIGRvTGF5b3V0V2l0aEZyYW1lRmxh dHRlbmluZyhib29sIGFsbG93U3VidHJlZSk7CiAKKyAgICB2b2lkIGNvbGxlY3RMaW5rZWREZXN0 aW5hdGlvbnMoTm9kZSopOworICAgIHZvaWQgb3V0cHV0TGlua2VkRGVzdGluYXRpb25zKEdyYXBo aWNzQ29udGV4dCosIE5vZGUqLCBjb25zdCBJbnRSZWN0JiBwYWdlUmVjdCk7CisKICAgICB2aXJ0 dWFsIEFYT2JqZWN0Q2FjaGUqIGF4T2JqZWN0Q2FjaGUoKSBjb25zdDsKICAgICB2b2lkIG5vdGlm eVdpZGdldHNJbkFsbEZyYW1lcyhXaWRnZXROb3RpZmljYXRpb24pOwogICAgIHZvaWQgcmVtb3Zl RnJvbUFYT2JqZWN0Q2FjaGUoKTsKQEAgLTU3Nyw2ICs1ODAsOSBAQCBwcml2YXRlOgogICAgIGJv b2wgbV9pc1Zpc3VhbGx5Tm9uRW1wdHk7CiAgICAgYm9vbCBtX2ZpcnN0VmlzdWFsbHlOb25FbXB0 eUxheW91dENhbGxiYWNrUGVuZGluZzsKIAorICAgIEhhc2hNYXA8U3RyaW5nLCBFbGVtZW50Kj4g bV9saW5rZWREZXN0aW5hdGlvbnM7CisgICAgYm9vbCBtX2xpbmtlZERlc3RpbmF0aW9uc1ZhbGlk OworCiAgICAgUmVmUHRyPE5vZGU+IG1fbWFpbnRhaW5TY3JvbGxQb3NpdGlvbkFuY2hvcjsKIAog ICAgIC8vIFJlbmRlcmVyIHRvIGhvbGQgb3VyIGN1c3RvbSBzY3JvbGwgY29ybmVyLgpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmNw cCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5jcHAK aW5kZXggNTA3YjRkZTAyNDg2NWJiNjMyZDdmMjgxYzMyMmM0Yzk3OGYxMjM2Mi4uY2ZmYjU2YWU2 M2UyNjVhNmI2YTBkM2I5NmI4ZjRiZTVhNDNhODIyMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuY3BwCkBAIC0zMyw2ICszMyw3 IEBACiAjaW5jbHVkZSAiSW50UmVjdC5oIgogI2luY2x1ZGUgIlJvdW5kZWRSZWN0LmgiCiAjaW5j bHVkZSAiVGV4dFJ1bi5oIgorI2luY2x1ZGUgPHd0Zi9VbnVzZWRQYXJhbS5oPgogCiAjaW5jbHVk ZSAic3RkaW8uaCIKIApAQCAtMjY1LDYgKzI2NiwyNiBAQCBib29sIEdyYXBoaWNzQ29udGV4dDo6 c2hvdWxkU3VicGl4ZWxRdWFudGl6ZUZvbnRzKCkgY29uc3QKICAgICByZXR1cm4gbV9zdGF0ZS5z aG91bGRTdWJwaXhlbFF1YW50aXplRm9udHM7CiB9CiAKKyNpZiAhVVNFKFNLSUEpCitib29sIEdy YXBoaWNzQ29udGV4dDo6c3VwcG9ydHNJbnRlcm5hbExpbmtzKCkKK3sKKyAgICByZXR1cm4gZmFs c2U7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzZXREZXN0aW5hdGlvbkZvclJlY3QoY29u c3QgU3RyaW5nJiBkZXN0TmFtZSwgY29uc3QgSW50UmVjdCYgcmVjdCkKK3sKKyAgICBVTlVTRURf UEFSQU0oZGVzdE5hbWUpOworICAgIFVOVVNFRF9QQVJBTShyZWN0KTsKK30KKwordm9pZCBHcmFw aGljc0NvbnRleHQ6OmFkZERlc3RpbmF0aW9uQXRQb2ludChjb25zdCBTdHJpbmcmIG5hbWUsIGNv bnN0IEludFBvaW50JiBwb3MpCit7CisgICAgVU5VU0VEX1BBUkFNKG5hbWUpOworICAgIFVOVVNF RF9QQVJBTShwb3MpOworfQorCisjZW5kaWYKKwogY29uc3QgR3JhcGhpY3NDb250ZXh0U3RhdGUm IEdyYXBoaWNzQ29udGV4dDo6c3RhdGUoKSBjb25zdAogewogICAgIHJldHVybiBtX3N0YXRlOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250 ZXh0LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQu aAppbmRleCA1YmM4ODgxYjQxNzg5NTMxZjYzNWQzODJlNmQwM2ViNjc0ZjE3NmE4Li4zMTQyM2Vl NzRlMTJiN2ZlMjMyMTVlNmI0ZGU5NWY1NDQ0ZmU0MzRkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuaAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuaApAQCAtNDIzLDYgKzQyMyw5 IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgICAgICB2b2lkIHNldFVSTEZvclJlY3QoY29u c3QgS1VSTCYsIGNvbnN0IEludFJlY3QmKTsKIAorICAgICAgICB2b2lkIHNldERlc3RpbmF0aW9u Rm9yUmVjdChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IEludFJlY3QmKTsKKyAgICAgICAgdm9p ZCBhZGREZXN0aW5hdGlvbkF0UG9pbnQoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJbnRQb2lu dCYpOworCiAgICAgICAgIHZvaWQgY29uY2F0Q1RNKGNvbnN0IEFmZmluZVRyYW5zZm9ybSYpOwog ICAgICAgICB2b2lkIHNldENUTShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mKTsKIApAQCAtNTMyLDYg KzUzNSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNlbmRpZgogCiAgICAgICAgIHN0YXRpYyB2 b2lkIGFkanVzdExpbmVUb1BpeGVsQm91bmRhcmllcyhGbG9hdFBvaW50JiBwMSwgRmxvYXRQb2lu dCYgcDIsIGZsb2F0IHN0cm9rZVdpZHRoLCBTdHJva2VTdHlsZSk7CisgICAgICAgIHN0YXRpYyBi b29sIHN1cHBvcnRzSW50ZXJuYWxMaW5rcygpOwogCiAgICAgcHJpdmF0ZToKICAgICAgICAgdm9p ZCBwbGF0Zm9ybUluaXQoUGxhdGZvcm1HcmFwaGljc0NvbnRleHQqKTsKQEAgLTYyMCw0ICs2MjQs MyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRp ZiAvLyBHcmFwaGljc0NvbnRleHRfaAotCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9za2lhL0dyYXBoaWNzQ29udGV4dFNraWEuY3BwIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3Mvc2tpYS9HcmFwaGljc0NvbnRleHRTa2lhLmNwcAppbmRleCA2 YTU2Y2NiNWUyMzAzNzM3OTcxMGM3NmI2MGY1ODhhMWRkY2MyYTY2Li5jOGVlOTkyMmQwMGM2Mzk4 OGU2YmFkZDQwNGFhMzc4YjAzZDM2NDExIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9za2lhL0dyYXBoaWNzQ29udGV4dFNraWEuY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3NraWEvR3JhcGhpY3NDb250ZXh0U2tpYS5jcHAKQEAg LTExMDgsNiArMTEwOCwzMCBAQCB2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0VVJMRm9yUmVjdChj b25zdCBLVVJMJiBsaW5rLCBjb25zdCBJbnRSZWN0JiBkZXN0UmVjdCkKICAgICBTa0Fubm90YXRl UmVjdFdpdGhVUkwocGxhdGZvcm1Db250ZXh0KCktPmNhbnZhcygpLCBkZXN0UmVjdCwgdXJsLmdl dCgpKTsKIH0KIAorYm9vbCBHcmFwaGljc0NvbnRleHQ6OnN1cHBvcnRzSW50ZXJuYWxMaW5rcygp Cit7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzZXREZXN0 aW5hdGlvbkZvclJlY3QoY29uc3QgU3RyaW5nJiBkZXN0TmFtZSwgY29uc3QgSW50UmVjdCYgcmVj dCkKK3sKKyAgICBpZiAocGFpbnRpbmdEaXNhYmxlZCgpKQorICAgICAgICByZXR1cm47CisKKyAg ICBTa0F1dG9EYXRhVW5yZWYgc2tEZXN0TmFtZShTa0RhdGE6Ok5ld1dpdGhDU3RyaW5nKGRlc3RO YW1lLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBTa0Fubm90YXRlTGlua1RvRGVzdGluYXRpb24ocGxh dGZvcm1Db250ZXh0KCktPmNhbnZhcygpLCByZWN0LCBza0Rlc3ROYW1lLmdldCgpKTsKK30KKwor dm9pZCBHcmFwaGljc0NvbnRleHQ6OmFkZERlc3RpbmF0aW9uQXRQb2ludChjb25zdCBTdHJpbmcm IG5hbWUsIGNvbnN0IEludFBvaW50JiBwb3MpCit7CisgICAgaWYgKHBhaW50aW5nRGlzYWJsZWQo KSkKKyAgICAgICAgcmV0dXJuOworCisgICAgU2tBdXRvRGF0YVVucmVmIG5hbWVEYXRhKFNrRGF0 YTo6TmV3V2l0aENTdHJpbmcobmFtZS51dGY4KCkuZGF0YSgpKSk7CisgICAgU2tBbm5vdGF0ZU5h bWVkRGVzdGluYXRpb24ocGxhdGZvcm1Db250ZXh0KCktPmNhbnZhcygpLAorICAgICAgICBTa1Bv aW50OjpNYWtlKHBvcy54KCksIHBvcy55KCkpLCBuYW1lRGF0YSk7Cit9CisKIHZvaWQgR3JhcGhp Y3NDb250ZXh0OjpzZXRQbGF0Zm9ybVNob3VsZEFudGlhbGlhcyhib29sIGVuYWJsZSkKIHsKICAg ICBpZiAocGFpbnRpbmdEaXNhYmxlZCgpKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlck9iamVjdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy T2JqZWN0LmNwcAppbmRleCBiMTQ4YTU4YjVjMmI4YjM1ZTE2MTYzNzkxNmY3MGE5Y2Q3M2FmOTZl Li5jNjc4MTllNmY1Zjc4YmFhNDA2YTkxMzNmOTUwNDUwYzkwZmY3YTQzIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcApAQCAtMTExNCw3ICsxMTE0LDE2IEBAIHZv aWQgUmVuZGVyT2JqZWN0OjphZGRQREZVUkxSZWN0KEdyYXBoaWNzQ29udGV4dCogY29udGV4dCwg Y29uc3QgTGF5b3V0UmVjdCYgcmVjCiAgICAgY29uc3QgQXRvbWljU3RyaW5nJiBocmVmID0gdG9F bGVtZW50KG4pLT5nZXRBdHRyaWJ1dGUoaHJlZkF0dHIpOwogICAgIGlmIChocmVmLmlzTnVsbCgp KQogICAgICAgICByZXR1cm47Ci0gICAgY29udGV4dC0+c2V0VVJMRm9yUmVjdChuLT5kb2N1bWVu dCgpLT5jb21wbGV0ZVVSTChocmVmKSwgcGl4ZWxTbmFwcGVkSW50UmVjdChyZWN0KSk7CisgICAg S1VSTCB1cmwgPSBuLT5kb2N1bWVudCgpLT5jb21wbGV0ZVVSTChocmVmKTsKKyAgICBpZiAoIXVy bC5pc1ZhbGlkKCkpCisgICAgICAgIHJldHVybjsKKyAgICBpZiAoY29udGV4dC0+c3VwcG9ydHNJ bnRlcm5hbExpbmtzKCkgJiYgdXJsLmhhc0ZyYWdtZW50SWRlbnRpZmllcigpICYmIGVxdWFsSWdu b3JpbmdGcmFnbWVudElkZW50aWZpZXIodXJsLCBuLT5kb2N1bWVudCgpLT5iYXNlVVJMKCkpKSB7 CisgICAgICAgIFN0cmluZyBuYW1lID0gdXJsLmZyYWdtZW50SWRlbnRpZmllcigpOworICAgICAg ICBpZiAoZG9jdW1lbnQoKS0+ZmluZEFuY2hvcihuYW1lKSkKKyAgICAgICAgICAgIGNvbnRleHQt PnNldERlc3RpbmF0aW9uRm9yUmVjdChuYW1lLCBwaXhlbFNuYXBwZWRJbnRSZWN0KHJlY3QpKTsK KyAgICAgICAgcmV0dXJuOworICAgIH0KKyAgICBjb250ZXh0LT5zZXRVUkxGb3JSZWN0KHVybCwg cGl4ZWxTbmFwcGVkSW50UmVjdChyZWN0KSk7CiB9CiAKIHZvaWQgUmVuZGVyT2JqZWN0OjpwYWlu dE91dGxpbmUoUGFpbnRJbmZvJiBwYWludEluZm8sIGNvbnN0IExheW91dFJlY3QmIHBhaW50UmVj dCkK 194404 2013-03-21 17:54:11 -0700 2015-08-16 17:24:29 -0700 Patch bug-112081-20130322114959.patch text/plain 10606 dml+webkit U3VidmVyc2lvbiBSZXZpc2lvbjogMTQ1ODAyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWRiOWE2MmM4MmMwOTUx NGQ4MDJiYjBjZWIzZTA1MGIyZDM3YTI0OC4uOTNiMzQ3MTM5MGE3Yzg2MWZlMDA5NzQwNWM2MTlh ZDgzNzEwNGQyZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEzLTAzLTExICBEYXZp ZCBMYXR0aW1vcmUgIDxkbWwrd2Via2l0QGdvb2dsZS5jb20+CisKKyAgICAgICAgUHJpbnRpbmcg dG8gUERGIHNob3VsZCBwcm9kdWNlIGludGVybmFsIGxpbmtzIHdoZW4gSFRNTCBoYXMgaW50ZXJu YWwgbGlua3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTExMjA4MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAg IFRoaXMgY2hhbmdlIGRvZXNuJ3QgaGF2ZSBhbnkgdGVzdHMgYmVjYXVzZSBQREYgZ2VuZXJhdGlv biBkb2Vzbid0CisgICAgICAgIGhhdmUgYW55IGV4aXN0aW5nIHRlc3RzLiBNYW51YWwgdGVzdGlu ZyB3YXMgcGVyZm9ybWVkIGluIENocm9taXVtCisgICAgICAgIGFuZCBhIGhlYWRsZXNzIHZlcnNp b24gb2YgV2ViS2l0IHdpdGggYSB2YXJpZXR5IG9mIGxpbmtzIGFuZAorICAgICAgICBhbmNob3Jz LgorCiAyMDEzLTAzLTE0ICBNYXJqYSBIw7ZsdHTDpCAgPG1hcmphQGNocm9taXVtLm9yZz4KIAog ICAgICAgICBbVjhdIFN0b3JlIG1haW4gd29ybGQgYW5kIG5vbi1tYWluIHdvcmxkIHRlbXBsYXRl cyBzZXBhcmF0ZWx5LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9QcmludENvbnRl eHQuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QcmludENvbnRleHQuY3BwCmluZGV4IGVkNjBi NDhlYmNiYTY2YzMwYzgzMWY2ODg1M2ZjZTk0NGE2OTVkMTkuLmExNjRjMDliY2Q1MTgxYmVhOGM0 ZmQ3MmIzZTY4YjE0ZGNjMjZhN2IgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUHJp bnRDb250ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1ByaW50Q29udGV4dC5jcHAK QEAgLTI0LDYgKzI0LDcgQEAKICNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIKICNpbmNsdWRl ICJGcmFtZS5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgorI2luY2x1ZGUgIkhUTUxOYW1lcy5o IgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKICNpbmNsdWRlICJTdHlsZUluaGVyaXRlZERhdGEu aCIKICNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KQEAgLTQ2LDYgKzQ3LDcgQEAgY29u c3QgZmxvYXQgcHJpbnRpbmdNYXhpbXVtU2hyaW5rRmFjdG9yID0gMjsKIFByaW50Q29udGV4dDo6 UHJpbnRDb250ZXh0KEZyYW1lKiBmcmFtZSkKICAgICA6IG1fZnJhbWUoZnJhbWUpCiAgICAgLCBt X2lzUHJpbnRpbmcoZmFsc2UpCisgICAgLCBtX2xpbmtlZERlc3RpbmF0aW9uc1ZhbGlkKGZhbHNl KQogewogfQogCkBAIC0yMDEsNiArMjAzLDggQEAgdm9pZCBQcmludENvbnRleHQ6OnNwb29sUGFn ZShHcmFwaGljc0NvbnRleHQmIGN0eCwgaW50IHBhZ2VOdW1iZXIsIGZsb2F0IHdpZHRoKQogICAg IGN0eC50cmFuc2xhdGUoLXBhZ2VSZWN0LngoKSwgLXBhZ2VSZWN0LnkoKSk7CiAgICAgY3R4LmNs aXAocGFnZVJlY3QpOwogICAgIG1fZnJhbWUtPnZpZXcoKS0+cGFpbnRDb250ZW50cygmY3R4LCBw YWdlUmVjdCk7CisgICAgaWYgKGN0eC5zdXBwb3J0c0ludGVybmFsTGlua3MoKSkKKyAgICAgICAg b3V0cHV0TGlua2VkRGVzdGluYXRpb25zKGN0eCwgbV9mcmFtZS0+ZG9jdW1lbnQoKSwgcGFnZVJl Y3QpOwogICAgIGN0eC5yZXN0b3JlKCk7CiB9CiAKQEAgLTIxOSw2ICsyMjMsOCBAQCB2b2lkIFBy aW50Q29udGV4dDo6ZW5kKCkKICAgICBBU1NFUlQobV9pc1ByaW50aW5nKTsKICAgICBtX2lzUHJp bnRpbmcgPSBmYWxzZTsKICAgICBtX2ZyYW1lLT5zZXRQcmludGluZyhmYWxzZSwgRmxvYXRTaXpl KCksIEZsb2F0U2l6ZSgpLCAwLCBBZGp1c3RWaWV3U2l6ZSk7CisgICAgbV9saW5rZWREZXN0aW5h dGlvbnMuY2xlYXIoKTsKKyAgICBtX2xpbmtlZERlc3RpbmF0aW9uc1ZhbGlkID0gZmFsc2U7CiB9 CiAKIHN0YXRpYyBSZW5kZXJCb3hNb2RlbE9iamVjdCogZW5jbG9zaW5nQm94TW9kZWxPYmplY3Qo UmVuZGVyT2JqZWN0KiBvYmplY3QpCkBAIC0yNjAsNiArMjY2LDQ1IEBAIGludCBQcmludENvbnRl eHQ6OnBhZ2VOdW1iZXJGb3JFbGVtZW50KEVsZW1lbnQqIGVsZW1lbnQsIGNvbnN0IEZsb2F0U2l6 ZSYgcGFnZVNpCiAgICAgcmV0dXJuIC0xOwogfQogCit2b2lkIFByaW50Q29udGV4dDo6Y29sbGVj dExpbmtlZERlc3RpbmF0aW9ucyhOb2RlKiBub2RlKQoreworICAgIGZvciAoTm9kZSogaSA9IG5v ZGUtPmZpcnN0Q2hpbGQoKTsgaTsgaSA9IGktPm5leHRTaWJsaW5nKCkpCisgICAgICAgIGNvbGxl Y3RMaW5rZWREZXN0aW5hdGlvbnMoaSk7CisKKyAgICBpZiAoIW5vZGUtPmlzTGluaygpIHx8ICFu b2RlLT5pc0VsZW1lbnROb2RlKCkpCisgICAgICAgIHJldHVybjsKKyAgICBjb25zdCBBdG9taWNT dHJpbmcmIGhyZWYgPSBzdGF0aWNfY2FzdDxFbGVtZW50Kj4obm9kZSktPmdldEF0dHJpYnV0ZShI VE1MTmFtZXM6OmhyZWZBdHRyKTsKKyAgICBpZiAoaHJlZi5pc051bGwoKSkKKyAgICAgICAgcmV0 dXJuOworICAgIEtVUkwgdXJsID0gbm9kZS0+ZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwoaHJlZik7 CisgICAgaWYgKCF1cmwuaXNWYWxpZCgpKQorICAgICAgICByZXR1cm47CisgICAgaWYgKHVybC5o YXNGcmFnbWVudElkZW50aWZpZXIoKSAmJiBlcXVhbElnbm9yaW5nRnJhZ21lbnRJZGVudGlmaWVy KHVybCwgbm9kZS0+ZG9jdW1lbnQoKS0+YmFzZVVSTCgpKSkgeworICAgICAgICBTdHJpbmcgbmFt ZSA9IHVybC5mcmFnbWVudElkZW50aWZpZXIoKTsKKyAgICAgICAgRWxlbWVudCogZWxlbWVudCA9 IG5vZGUtPmRvY3VtZW50KCktPmZpbmRBbmNob3IobmFtZSk7CisgICAgICAgIGlmIChlbGVtZW50 KQorICAgICAgICAgICAgbV9saW5rZWREZXN0aW5hdGlvbnMuc2V0KG5hbWUsIGVsZW1lbnQpOwor ICAgIH0KK30KKwordm9pZCBQcmludENvbnRleHQ6Om91dHB1dExpbmtlZERlc3RpbmF0aW9ucyhH cmFwaGljc0NvbnRleHQmIGdyYXBoaWNzQ29udGV4dCwgTm9kZSogbm9kZSwgY29uc3QgSW50UmVj dCYgcGFnZVJlY3QpCit7CisgICAgaWYgKCFtX2xpbmtlZERlc3RpbmF0aW9uc1ZhbGlkKSB7Cisg ICAgICAgIGNvbGxlY3RMaW5rZWREZXN0aW5hdGlvbnMobm9kZSk7CisgICAgICAgIG1fbGlua2Vk RGVzdGluYXRpb25zVmFsaWQgPSB0cnVlOworICAgIH0KKworICAgIEhhc2hNYXA8U3RyaW5nLCBF bGVtZW50Kj46OmNvbnN0X2l0ZXJhdG9yIGVuZCA9IG1fbGlua2VkRGVzdGluYXRpb25zLmVuZCgp OworICAgIGZvciAoSGFzaE1hcDxTdHJpbmcsIEVsZW1lbnQqPjo6Y29uc3RfaXRlcmF0b3IgaXQg PSBtX2xpbmtlZERlc3RpbmF0aW9ucy5iZWdpbigpOyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAg ICAgSW50UmVjdCBib3VuZGluZ0JveCA9IGl0LT52YWx1ZS0+cmVuZGVyZXIoKS0+YWJzb2x1dGVC b3VuZGluZ0JveFJlY3QoKTsKKyAgICAgICAgaWYgKHBhZ2VSZWN0LmludGVyc2VjdHMoYm91bmRp bmdCb3gpKSB7CisgICAgICAgICAgICBJbnRQb2ludCBwb2ludCA9IGJvdW5kaW5nQm94Lm1pblhN aW5ZQ29ybmVyKCk7CisgICAgICAgICAgICBwb2ludC5jbGFtcE5lZ2F0aXZlVG9aZXJvKCk7Cisg ICAgICAgICAgICBncmFwaGljc0NvbnRleHQuYWRkRGVzdGluYXRpb25BdFBvaW50KGl0LT5rZXks IHBvaW50KTsKKyAgICAgICAgfQorICAgIH0KK30KKwogU3RyaW5nIFByaW50Q29udGV4dDo6cGFn ZVByb3BlcnR5KEZyYW1lKiBmcmFtZSwgY29uc3QgY2hhciogcHJvcGVydHlOYW1lLCBpbnQgcGFn ZU51bWJlcikKIHsKICAgICBEb2N1bWVudCogZG9jdW1lbnQgPSBmcmFtZS0+ZG9jdW1lbnQoKTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUHJpbnRDb250ZXh0LmggYi9Tb3VyY2Uv V2ViQ29yZS9wYWdlL1ByaW50Q29udGV4dC5oCmluZGV4IDJlZmQwNWQzZmRjZmY2NTIyODA2NDZh Y2FkZGI2MmRlZDAyYTJlNDkuLjhjOTUzZTViNGY3NDFjMThiODcwNDJlN2Q5YzJiYTVlNGViZjI4 N2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUHJpbnRDb250ZXh0LmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGFnZS9QcmludENvbnRleHQuaApAQCAtMjIsNyArMjIsOSBAQAogI2Rl ZmluZSBQcmludENvbnRleHRfaAogCiAjaW5jbHVkZSA8d3RmL0ZvcndhcmQuaD4KKyNpbmNsdWRl IDx3dGYvSGFzaE1hcC5oPgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KKyNpbmNsdWRlIDx3dGYv dGV4dC9XVEZTdHJpbmcuaD4KIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCkBAIC0zMiw2ICszNCw3 IEBAIGNsYXNzIEZsb2F0UmVjdDsKIGNsYXNzIEZsb2F0U2l6ZTsKIGNsYXNzIEdyYXBoaWNzQ29u dGV4dDsKIGNsYXNzIEludFJlY3Q7CitjbGFzcyBOb2RlOwogCiBjbGFzcyBQcmludENvbnRleHQg ewogcHVibGljOgpAQCAtODAsMTQgKzgzLDIwIEBAIHB1YmxpYzoKICAgICBzdGF0aWMgdm9pZCBz cG9vbEFsbFBhZ2VzV2l0aEJvdW5kYXJpZXMoRnJhbWUqLCBHcmFwaGljc0NvbnRleHQmLCBjb25z dCBGbG9hdFNpemUmIHBhZ2VTaXplSW5QaXhlbHMpOwogCiBwcm90ZWN0ZWQ6CisgICAgdm9pZCBv dXRwdXRMaW5rZWREZXN0aW5hdGlvbnMoR3JhcGhpY3NDb250ZXh0JiwgTm9kZSosIGNvbnN0IElu dFJlY3QmIHBhZ2VSZWN0KTsKKwogICAgIEZyYW1lKiBtX2ZyYW1lOwogICAgIFZlY3RvcjxJbnRS ZWN0PiBtX3BhZ2VSZWN0czsKIAogcHJpdmF0ZToKICAgICB2b2lkIGNvbXB1dGVQYWdlUmVjdHNX aXRoUGFnZVNpemVJbnRlcm5hbChjb25zdCBGbG9hdFNpemUmIHBhZ2VTaXplSW5QaXhlbHMsIGJv b2wgYWxsb3dIb3Jpem9udGFsVGlsaW5nKTsKKyAgICB2b2lkIGNvbGxlY3RMaW5rZWREZXN0aW5h dGlvbnMoTm9kZSopOwogCiAgICAgLy8gVXNlZCB0byBwcmV2ZW50IG1pc3VzZXMgb2YgYmVnaW4o KSBhbmQgZW5kKCkgKGUuZy4sIGNhbGwgZW5kIHdpdGhvdXQgYmVnaW4pLgogICAgIGJvb2wgbV9p c1ByaW50aW5nOworCisgICAgSGFzaE1hcDxTdHJpbmcsIEVsZW1lbnQqPiBtX2xpbmtlZERlc3Rp bmF0aW9uczsKKyAgICBib29sIG1fbGlua2VkRGVzdGluYXRpb25zVmFsaWQ7CiB9OwogCiB9CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRl eHQuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0 LmNwcAppbmRleCA1MDdiNGRlMDI0ODY1YmI2MzJkN2YyODFjMzIyYzRjOTc4ZjEyMzYyLi5jZmZi NTZhZTYzZTI2NWE2YjZhMGQzYjk2YjhmNGJlNWE0M2E4MjIyIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuY3BwCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5jcHAKQEAgLTMzLDYg KzMzLDcgQEAKICNpbmNsdWRlICJJbnRSZWN0LmgiCiAjaW5jbHVkZSAiUm91bmRlZFJlY3QuaCIK ICNpbmNsdWRlICJUZXh0UnVuLmgiCisjaW5jbHVkZSA8d3RmL1VudXNlZFBhcmFtLmg+CiAKICNp bmNsdWRlICJzdGRpby5oIgogCkBAIC0yNjUsNiArMjY2LDI2IEBAIGJvb2wgR3JhcGhpY3NDb250 ZXh0OjpzaG91bGRTdWJwaXhlbFF1YW50aXplRm9udHMoKSBjb25zdAogICAgIHJldHVybiBtX3N0 YXRlLnNob3VsZFN1YnBpeGVsUXVhbnRpemVGb250czsKIH0KIAorI2lmICFVU0UoU0tJQSkKK2Jv b2wgR3JhcGhpY3NDb250ZXh0OjpzdXBwb3J0c0ludGVybmFsTGlua3MoKQoreworICAgIHJldHVy biBmYWxzZTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldERlc3RpbmF0aW9uRm9yUmVj dChjb25zdCBTdHJpbmcmIGRlc3ROYW1lLCBjb25zdCBJbnRSZWN0JiByZWN0KQoreworICAgIFVO VVNFRF9QQVJBTShkZXN0TmFtZSk7CisgICAgVU5VU0VEX1BBUkFNKHJlY3QpOworfQorCit2b2lk IEdyYXBoaWNzQ29udGV4dDo6YWRkRGVzdGluYXRpb25BdFBvaW50KGNvbnN0IFN0cmluZyYgbmFt ZSwgY29uc3QgSW50UG9pbnQmIHBvcykKK3sKKyAgICBVTlVTRURfUEFSQU0obmFtZSk7CisgICAg VU5VU0VEX1BBUkFNKHBvcyk7Cit9CisKKyNlbmRpZgorCiBjb25zdCBHcmFwaGljc0NvbnRleHRT dGF0ZSYgR3JhcGhpY3NDb250ZXh0OjpzdGF0ZSgpIGNvbnN0CiB7CiAgICAgcmV0dXJuIG1fc3Rh dGU7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGlj c0NvbnRleHQuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29u dGV4dC5oCmluZGV4IDViYzg4ODFiNDE3ODk1MzFmNjM1ZDM4MmU2ZDAzZWI2NzRmMTc2YTguLjQ1 NmZlYTlkNjU0MjhiYmZlYjdlMThhY2Y5YmRkN2QyMTgwNzMwNzIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5oCkBAIC00MjMsNiAr NDIzLDkgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiAgICAgICAgIHZvaWQgc2V0VVJMRm9yUmVj dChjb25zdCBLVVJMJiwgY29uc3QgSW50UmVjdCYpOwogCisgICAgICAgIHZvaWQgc2V0RGVzdGlu YXRpb25Gb3JSZWN0KGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgSW50UmVjdCYpOworICAgICAg ICB2b2lkIGFkZERlc3RpbmF0aW9uQXRQb2ludChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IElu dFBvaW50Jik7CisKICAgICAgICAgdm9pZCBjb25jYXRDVE0oY29uc3QgQWZmaW5lVHJhbnNmb3Jt Jik7CiAgICAgICAgIHZvaWQgc2V0Q1RNKGNvbnN0IEFmZmluZVRyYW5zZm9ybSYpOwogCkBAIC01 MzIsNiArNTM1LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogI2VuZGlmCiAKICAgICAgICAgc3Rh dGljIHZvaWQgYWRqdXN0TGluZVRvUGl4ZWxCb3VuZGFyaWVzKEZsb2F0UG9pbnQmIHAxLCBGbG9h dFBvaW50JiBwMiwgZmxvYXQgc3Ryb2tlV2lkdGgsIFN0cm9rZVN0eWxlKTsKKyAgICAgICAgYm9v bCBzdXBwb3J0c0ludGVybmFsTGlua3MoKTsKIAogICAgIHByaXZhdGU6CiAgICAgICAgIHZvaWQg cGxhdGZvcm1Jbml0KFBsYXRmb3JtR3JhcGhpY3NDb250ZXh0Kik7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9za2lhL0dyYXBoaWNzQ29udGV4dFNraWEuY3Bw IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvc2tpYS9HcmFwaGljc0NvbnRleHRT a2lhLmNwcAppbmRleCA2YTU2Y2NiNWUyMzAzNzM3OTcxMGM3NmI2MGY1ODhhMWRkY2MyYTY2Li5h MTJmYjM1YzVkNWZjNTUxOTY0NjBjNjQwODY3ZmU1YTJhNGIyYmZiIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9za2lhL0dyYXBoaWNzQ29udGV4dFNraWEuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL3NraWEvR3JhcGhpY3NDb250 ZXh0U2tpYS5jcHAKQEAgLTExMDgsNiArMTEwOCwzMCBAQCB2b2lkIEdyYXBoaWNzQ29udGV4dDo6 c2V0VVJMRm9yUmVjdChjb25zdCBLVVJMJiBsaW5rLCBjb25zdCBJbnRSZWN0JiBkZXN0UmVjdCkK ICAgICBTa0Fubm90YXRlUmVjdFdpdGhVUkwocGxhdGZvcm1Db250ZXh0KCktPmNhbnZhcygpLCBk ZXN0UmVjdCwgdXJsLmdldCgpKTsKIH0KIAorYm9vbCBHcmFwaGljc0NvbnRleHQ6OnN1cHBvcnRz SW50ZXJuYWxMaW5rcygpCit7CisgICAgcmV0dXJuIHBsYXRmb3JtQ29udGV4dCgpLT5wcmludGlu ZygpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0RGVzdGluYXRpb25Gb3JSZWN0KGNv bnN0IFN0cmluZyYgZGVzdE5hbWUsIGNvbnN0IEludFJlY3QmIHJlY3QpCit7CisgICAgaWYgKHBh aW50aW5nRGlzYWJsZWQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgU2tBdXRvRGF0YVVucmVm IHNrRGVzdE5hbWUoU2tEYXRhOjpOZXdXaXRoQ1N0cmluZyhkZXN0TmFtZS51dGY4KCkuZGF0YSgp KSk7CisgICAgU2tBbm5vdGF0ZUxpbmtUb0Rlc3RpbmF0aW9uKHBsYXRmb3JtQ29udGV4dCgpLT5j YW52YXMoKSwgcmVjdCwgc2tEZXN0TmFtZS5nZXQoKSk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250 ZXh0OjphZGREZXN0aW5hdGlvbkF0UG9pbnQoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJbnRQ b2ludCYgcG9zKQoreworICAgIGlmIChwYWludGluZ0Rpc2FibGVkKCkpCisgICAgICAgIHJldHVy bjsKKworICAgIFNrQXV0b0RhdGFVbnJlZiBuYW1lRGF0YShTa0RhdGE6Ok5ld1dpdGhDU3RyaW5n KG5hbWUudXRmOCgpLmRhdGEoKSkpOworICAgIFNrQW5ub3RhdGVOYW1lZERlc3RpbmF0aW9uKHBs YXRmb3JtQ29udGV4dCgpLT5jYW52YXMoKSwKKyAgICAgICAgU2tQb2ludDo6TWFrZShwb3MueCgp LCBwb3MueSgpKSwgbmFtZURhdGEpOworfQorCiB2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0UGxh dGZvcm1TaG91bGRBbnRpYWxpYXMoYm9vbCBlbmFibGUpCiB7CiAgICAgaWYgKHBhaW50aW5nRGlz YWJsZWQoKSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmpl Y3QuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKaW5kZXgg YjE0OGE1OGI1YzJiOGIzNWUxNjE2Mzc5MTZmNzBhOWNkNzNhZjk2ZS4uYzY3ODE5ZTZmNWY3OGJh YTQwNmE5MTMzZjk1MDQ1MGM5MGZmN2E0MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcmVu ZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1Jl bmRlck9iamVjdC5jcHAKQEAgLTExMTQsNyArMTExNCwxNiBAQCB2b2lkIFJlbmRlck9iamVjdDo6 YWRkUERGVVJMUmVjdChHcmFwaGljc0NvbnRleHQqIGNvbnRleHQsIGNvbnN0IExheW91dFJlY3Qm IHJlYwogICAgIGNvbnN0IEF0b21pY1N0cmluZyYgaHJlZiA9IHRvRWxlbWVudChuKS0+Z2V0QXR0 cmlidXRlKGhyZWZBdHRyKTsKICAgICBpZiAoaHJlZi5pc051bGwoKSkKICAgICAgICAgcmV0dXJu OwotICAgIGNvbnRleHQtPnNldFVSTEZvclJlY3Qobi0+ZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwo aHJlZiksIHBpeGVsU25hcHBlZEludFJlY3QocmVjdCkpOworICAgIEtVUkwgdXJsID0gbi0+ZG9j dW1lbnQoKS0+Y29tcGxldGVVUkwoaHJlZik7CisgICAgaWYgKCF1cmwuaXNWYWxpZCgpKQorICAg ICAgICByZXR1cm47CisgICAgaWYgKGNvbnRleHQtPnN1cHBvcnRzSW50ZXJuYWxMaW5rcygpICYm IHVybC5oYXNGcmFnbWVudElkZW50aWZpZXIoKSAmJiBlcXVhbElnbm9yaW5nRnJhZ21lbnRJZGVu dGlmaWVyKHVybCwgbi0+ZG9jdW1lbnQoKS0+YmFzZVVSTCgpKSkgeworICAgICAgICBTdHJpbmcg bmFtZSA9IHVybC5mcmFnbWVudElkZW50aWZpZXIoKTsKKyAgICAgICAgaWYgKGRvY3VtZW50KCkt PmZpbmRBbmNob3IobmFtZSkpCisgICAgICAgICAgICBjb250ZXh0LT5zZXREZXN0aW5hdGlvbkZv clJlY3QobmFtZSwgcGl4ZWxTbmFwcGVkSW50UmVjdChyZWN0KSk7CisgICAgICAgIHJldHVybjsK KyAgICB9CisgICAgY29udGV4dC0+c2V0VVJMRm9yUmVjdCh1cmwsIHBpeGVsU25hcHBlZEludFJl Y3QocmVjdCkpOwogfQogCiB2b2lkIFJlbmRlck9iamVjdDo6cGFpbnRPdXRsaW5lKFBhaW50SW5m byYgcGFpbnRJbmZvLCBjb25zdCBMYXlvdXRSZWN0JiBwYWludFJlY3QpCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJGcmFtZUltcGwuY3BwIGIvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViRnJhbWVJbXBsLmNwcAppbmRleCBmZTI4NmI5MmEyNThkZTQ2YTI2 ZGE3YzQ5ODJkZWJjN2EwZDc4Y2RjLi5kZGIxYWVmNGQ1N2Q5ODM1Zjg3NjBlMjMyMjA2NWE1MzFk ZWI0MDAyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJGcmFtZUlt cGwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkZyYW1lSW1wbC5jcHAK QEAgLTM1Niw2ICszNTYsOCBAQCBwdWJsaWM6CiAgICAgICAgIGNvbnRleHQudHJhbnNsYXRlKHN0 YXRpY19jYXN0PGZsb2F0PigtcGFnZVJlY3QueCgpKSwgc3RhdGljX2Nhc3Q8ZmxvYXQ+KC1wYWdl UmVjdC55KCkpKTsKICAgICAgICAgY29udGV4dC5jbGlwKHBhZ2VSZWN0KTsKICAgICAgICAgZnJh bWUoKS0+dmlldygpLT5wYWludENvbnRlbnRzKCZjb250ZXh0LCBwYWdlUmVjdCk7CisgICAgICAg IGlmIChjb250ZXh0LnN1cHBvcnRzSW50ZXJuYWxMaW5rcygpKQorICAgICAgICAgICAgb3V0cHV0 TGlua2VkRGVzdGluYXRpb25zKGNvbnRleHQsIGZyYW1lKCktPmRvY3VtZW50KCksIHBhZ2VSZWN0 KTsKICAgICAgICAgY29udGV4dC5yZXN0b3JlKCk7CiAgICAgICAgIHJldHVybiBzY2FsZTsKICAg ICB9Cg== 195162 2013-03-26 14:27:18 -0700 2015-08-16 17:24:29 -0700 with non-functional CG support PDFInternalLinks.txt text/plain 10891 ap SW5kZXg6IFNvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2Vi Q29yZS9DaGFuZ2VMb2cJKHJldmlzaW9uIDE0NjkyMykKKysrIFNvdXJjZS9XZWJDb3JlL0NoYW5n ZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE1IEBACisyMDEzLTAzLTI2ICBEYXZpZCBM YXR0aW1vcmUgIDxkbWwrd2Via2l0QGdvb2dsZS5jb20+CisKKyAgICAgICAgUHJpbnRpbmcgdG8g UERGIHNob3VsZCBwcm9kdWNlIGludGVybmFsIGxpbmtzIHdoZW4gSFRNTCBoYXMgaW50ZXJuYWwg bGlua3MKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEx MjA4MQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRo aXMgY2hhbmdlIGRvZXNuJ3QgaGF2ZSBhbnkgdGVzdHMgYmVjYXVzZSBQREYgZ2VuZXJhdGlvbiBk b2Vzbid0CisgICAgICAgIGhhdmUgYW55IGV4aXN0aW5nIHRlc3RzLiBNYW51YWwgdGVzdGluZyB3 YXMgcGVyZm9ybWVkIGluIENocm9taXVtCisgICAgICAgIGFuZCBhIGhlYWRsZXNzIHZlcnNpb24g b2YgV2ViS2l0IHdpdGggYSB2YXJpZXR5IG9mIGxpbmtzIGFuZAorICAgICAgICBhbmNob3JzLgor CiAyMDEzLTAzLTI2ICBKb2UgTWFzb24gIDxqbWFzb25AYmxhY2tiZXJyeS5jb20+CiAKICAgICAg ICAgW0JsYWNrQmVycnldIEluIFJTU0ZpbHRlclN0cmVhbSwgZG9uJ3Qgc3dhbGxvdyBoZWFkZXJz IHdoZW4gdGhlcmUncyBubyBib2R5CkluZGV4OiBTb3VyY2UvV2ViQ29yZS9wYWdlL1ByaW50Q29u dGV4dC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUvcGFnZS9QcmludENvbnRleHQu Y3BwCShyZXZpc2lvbiAxNDY5MjMpCisrKyBTb3VyY2UvV2ViQ29yZS9wYWdlL1ByaW50Q29udGV4 dC5jcHAJKHdvcmtpbmcgY29weSkKQEAgLTI0LDYgKzI0LDcgQEAKICNpbmNsdWRlICJHcmFwaGlj c0NvbnRleHQuaCIKICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgor I2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKICNpbmNsdWRl ICJTdHlsZUluaGVyaXRlZERhdGEuaCIKICNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4K QEAgLTQ2LDYgKzQ3LDcgQEAgY29uc3QgZmxvYXQgcHJpbnRpbmdNYXhpbXVtU2hyaW5rRmFjdG9y IAogUHJpbnRDb250ZXh0OjpQcmludENvbnRleHQoRnJhbWUqIGZyYW1lKQogICAgIDogbV9mcmFt ZShmcmFtZSkKICAgICAsIG1faXNQcmludGluZyhmYWxzZSkKKyAgICAsIG1fbGlua2VkRGVzdGlu YXRpb25zVmFsaWQoZmFsc2UpCiB7CiB9CiAKQEAgLTIwMSw2ICsyMDMsOCBAQCB2b2lkIFByaW50 Q29udGV4dDo6c3Bvb2xQYWdlKEdyYXBoaWNzQ29uCiAgICAgY3R4LnRyYW5zbGF0ZSgtcGFnZVJl Y3QueCgpLCAtcGFnZVJlY3QueSgpKTsKICAgICBjdHguY2xpcChwYWdlUmVjdCk7CiAgICAgbV9m cmFtZS0+dmlldygpLT5wYWludENvbnRlbnRzKCZjdHgsIHBhZ2VSZWN0KTsKKyAgICBpZiAoY3R4 LnN1cHBvcnRzSW50ZXJuYWxMaW5rcygpKQorICAgICAgICBvdXRwdXRMaW5rZWREZXN0aW5hdGlv bnMoY3R4LCBtX2ZyYW1lLT5kb2N1bWVudCgpLCBwYWdlUmVjdCk7CiAgICAgY3R4LnJlc3RvcmUo KTsKIH0KIApAQCAtMjE5LDYgKzIyMyw4IEBAIHZvaWQgUHJpbnRDb250ZXh0OjplbmQoKQogICAg IEFTU0VSVChtX2lzUHJpbnRpbmcpOwogICAgIG1faXNQcmludGluZyA9IGZhbHNlOwogICAgIG1f ZnJhbWUtPnNldFByaW50aW5nKGZhbHNlLCBGbG9hdFNpemUoKSwgRmxvYXRTaXplKCksIDAsIEFk anVzdFZpZXdTaXplKTsKKyAgICBtX2xpbmtlZERlc3RpbmF0aW9ucy5jbGVhcigpOworICAgIG1f bGlua2VkRGVzdGluYXRpb25zVmFsaWQgPSBmYWxzZTsKIH0KIAogc3RhdGljIFJlbmRlckJveE1v ZGVsT2JqZWN0KiBlbmNsb3NpbmdCb3hNb2RlbE9iamVjdChSZW5kZXJPYmplY3QqIG9iamVjdCkK QEAgLTI2MCw2ICsyNjYsNDUgQEAgaW50IFByaW50Q29udGV4dDo6cGFnZU51bWJlckZvckVsZW1l bnQoRQogICAgIHJldHVybiAtMTsKIH0KIAordm9pZCBQcmludENvbnRleHQ6OmNvbGxlY3RMaW5r ZWREZXN0aW5hdGlvbnMoTm9kZSogbm9kZSkKK3sKKyAgICBmb3IgKE5vZGUqIGkgPSBub2RlLT5m aXJzdENoaWxkKCk7IGk7IGkgPSBpLT5uZXh0U2libGluZygpKQorICAgICAgICBjb2xsZWN0TGlu a2VkRGVzdGluYXRpb25zKGkpOworCisgICAgaWYgKCFub2RlLT5pc0xpbmsoKSB8fCAhbm9kZS0+ aXNFbGVtZW50Tm9kZSgpKQorICAgICAgICByZXR1cm47CisgICAgY29uc3QgQXRvbWljU3RyaW5n JiBocmVmID0gc3RhdGljX2Nhc3Q8RWxlbWVudCo+KG5vZGUpLT5nZXRBdHRyaWJ1dGUoSFRNTE5h bWVzOjpocmVmQXR0cik7CisgICAgaWYgKGhyZWYuaXNOdWxsKCkpCisgICAgICAgIHJldHVybjsK KyAgICBLVVJMIHVybCA9IG5vZGUtPmRvY3VtZW50KCktPmNvbXBsZXRlVVJMKGhyZWYpOworICAg IGlmICghdXJsLmlzVmFsaWQoKSkKKyAgICAgICAgcmV0dXJuOworICAgIGlmICh1cmwuaGFzRnJh Z21lbnRJZGVudGlmaWVyKCkgJiYgZXF1YWxJZ25vcmluZ0ZyYWdtZW50SWRlbnRpZmllcih1cmws IG5vZGUtPmRvY3VtZW50KCktPmJhc2VVUkwoKSkpIHsKKyAgICAgICAgU3RyaW5nIG5hbWUgPSB1 cmwuZnJhZ21lbnRJZGVudGlmaWVyKCk7CisgICAgICAgIEVsZW1lbnQqIGVsZW1lbnQgPSBub2Rl LT5kb2N1bWVudCgpLT5maW5kQW5jaG9yKG5hbWUpOworICAgICAgICBpZiAoZWxlbWVudCkKKyAg ICAgICAgICAgIG1fbGlua2VkRGVzdGluYXRpb25zLnNldChuYW1lLCBlbGVtZW50KTsKKyAgICB9 Cit9CisKK3ZvaWQgUHJpbnRDb250ZXh0OjpvdXRwdXRMaW5rZWREZXN0aW5hdGlvbnMoR3JhcGhp Y3NDb250ZXh0JiBncmFwaGljc0NvbnRleHQsIE5vZGUqIG5vZGUsIGNvbnN0IEludFJlY3QmIHBh Z2VSZWN0KQoreworICAgIGlmICghbV9saW5rZWREZXN0aW5hdGlvbnNWYWxpZCkgeworICAgICAg ICBjb2xsZWN0TGlua2VkRGVzdGluYXRpb25zKG5vZGUpOworICAgICAgICBtX2xpbmtlZERlc3Rp bmF0aW9uc1ZhbGlkID0gdHJ1ZTsKKyAgICB9CisKKyAgICBIYXNoTWFwPFN0cmluZywgRWxlbWVu dCo+Ojpjb25zdF9pdGVyYXRvciBlbmQgPSBtX2xpbmtlZERlc3RpbmF0aW9ucy5lbmQoKTsKKyAg ICBmb3IgKEhhc2hNYXA8U3RyaW5nLCBFbGVtZW50Kj46OmNvbnN0X2l0ZXJhdG9yIGl0ID0gbV9s aW5rZWREZXN0aW5hdGlvbnMuYmVnaW4oKTsgaXQgIT0gZW5kOyArK2l0KSB7CisgICAgICAgIElu dFJlY3QgYm91bmRpbmdCb3ggPSBpdC0+dmFsdWUtPnJlbmRlcmVyKCktPmFic29sdXRlQm91bmRp bmdCb3hSZWN0KCk7CisgICAgICAgIGlmIChwYWdlUmVjdC5pbnRlcnNlY3RzKGJvdW5kaW5nQm94 KSkgeworICAgICAgICAgICAgSW50UG9pbnQgcG9pbnQgPSBib3VuZGluZ0JveC5taW5YTWluWUNv cm5lcigpOworICAgICAgICAgICAgcG9pbnQuY2xhbXBOZWdhdGl2ZVRvWmVybygpOworICAgICAg ICAgICAgZ3JhcGhpY3NDb250ZXh0LmFkZERlc3RpbmF0aW9uQXRQb2ludChpdC0+a2V5LCBwb2lu dCk7CisgICAgICAgIH0KKyAgICB9Cit9CisKIFN0cmluZyBQcmludENvbnRleHQ6OnBhZ2VQcm9w ZXJ0eShGcmFtZSogZnJhbWUsIGNvbnN0IGNoYXIqIHByb3BlcnR5TmFtZSwgaW50IHBhZ2VOdW1i ZXIpCiB7CiAgICAgRG9jdW1lbnQqIGRvY3VtZW50ID0gZnJhbWUtPmRvY3VtZW50KCk7CkluZGV4 OiBTb3VyY2UvV2ViQ29yZS9wYWdlL1ByaW50Q29udGV4dC5oCj09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJj ZS9XZWJDb3JlL3BhZ2UvUHJpbnRDb250ZXh0LmgJKHJldmlzaW9uIDE0NjkyMykKKysrIFNvdXJj ZS9XZWJDb3JlL3BhZ2UvUHJpbnRDb250ZXh0LmgJKHdvcmtpbmcgY29weSkKQEAgLTIyLDcgKzIy LDkgQEAKICNkZWZpbmUgUHJpbnRDb250ZXh0X2gKIAogI2luY2x1ZGUgPHd0Zi9Gb3J3YXJkLmg+ CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KICNpbmNsdWRlIDx3dGYvVmVjdG9yLmg+CisjaW5j bHVkZSA8d3RmL3RleHQvV1RGU3RyaW5nLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIApAQCAt MzIsNiArMzQsNyBAQCBjbGFzcyBGbG9hdFJlY3Q7CiBjbGFzcyBGbG9hdFNpemU7CiBjbGFzcyBH cmFwaGljc0NvbnRleHQ7CiBjbGFzcyBJbnRSZWN0OworY2xhc3MgTm9kZTsKIAogY2xhc3MgUHJp bnRDb250ZXh0IHsKIHB1YmxpYzoKQEAgLTgwLDE0ICs4MywyMCBAQCBwdWJsaWM6CiAgICAgc3Rh dGljIHZvaWQgc3Bvb2xBbGxQYWdlc1dpdGhCb3VuZGFyaWVzKEZyYW1lKiwgR3JhcGhpY3NDb250 ZXh0JiwgY29uc3QgRmxvYXRTaXplJiBwYWdlU2l6ZUluUGl4ZWxzKTsKIAogcHJvdGVjdGVkOgor ICAgIHZvaWQgb3V0cHV0TGlua2VkRGVzdGluYXRpb25zKEdyYXBoaWNzQ29udGV4dCYsIE5vZGUq LCBjb25zdCBJbnRSZWN0JiBwYWdlUmVjdCk7CisKICAgICBGcmFtZSogbV9mcmFtZTsKICAgICBW ZWN0b3I8SW50UmVjdD4gbV9wYWdlUmVjdHM7CiAKIHByaXZhdGU6CiAgICAgdm9pZCBjb21wdXRl UGFnZVJlY3RzV2l0aFBhZ2VTaXplSW50ZXJuYWwoY29uc3QgRmxvYXRTaXplJiBwYWdlU2l6ZUlu UGl4ZWxzLCBib29sIGFsbG93SG9yaXpvbnRhbFRpbGluZyk7CisgICAgdm9pZCBjb2xsZWN0TGlu a2VkRGVzdGluYXRpb25zKE5vZGUqKTsKIAogICAgIC8vIFVzZWQgdG8gcHJldmVudCBtaXN1c2Vz IG9mIGJlZ2luKCkgYW5kIGVuZCgpIChlLmcuLCBjYWxsIGVuZCB3aXRob3V0IGJlZ2luKS4KICAg ICBib29sIG1faXNQcmludGluZzsKKworICAgIEhhc2hNYXA8U3RyaW5nLCBFbGVtZW50Kj4gbV9s aW5rZWREZXN0aW5hdGlvbnM7CisgICAgYm9vbCBtX2xpbmtlZERlc3RpbmF0aW9uc1ZhbGlkOwog fTsKIAogfQpJbmRleDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3ND b250ZXh0LmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9HcmFwaGljc0NvbnRleHQuY3BwCShyZXZpc2lvbiAxNDY5MjMpCisrKyBTb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuY3BwCSh3b3JraW5nIGNvcHkpCkBA IC0zMyw2ICszMyw3IEBACiAjaW5jbHVkZSAiSW50UmVjdC5oIgogI2luY2x1ZGUgIlJvdW5kZWRS ZWN0LmgiCiAjaW5jbHVkZSAiVGV4dFJ1bi5oIgorI2luY2x1ZGUgPHd0Zi9VbnVzZWRQYXJhbS5o PgogCiAjaW5jbHVkZSAic3RkaW8uaCIKIApAQCAtMjY1LDYgKzI2NiwyNiBAQCBib29sIEdyYXBo aWNzQ29udGV4dDo6c2hvdWxkU3VicGl4ZWxRdWFuCiAgICAgcmV0dXJuIG1fc3RhdGUuc2hvdWxk U3VicGl4ZWxRdWFudGl6ZUZvbnRzOwogfQogCisjaWYgIVVTRShTS0lBKSAmJiAhVVNFKENHKQor Ym9vbCBHcmFwaGljc0NvbnRleHQ6OnN1cHBvcnRzSW50ZXJuYWxMaW5rcygpCit7CisgICAgcmV0 dXJuIGZhbHNlOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0RGVzdGluYXRpb25Gb3JS ZWN0KGNvbnN0IFN0cmluZyYgZGVzdE5hbWUsIGNvbnN0IEludFJlY3QmIHJlY3QpCit7CisgICAg VU5VU0VEX1BBUkFNKGRlc3ROYW1lKTsKKyAgICBVTlVTRURfUEFSQU0ocmVjdCk7Cit9CisKK3Zv aWQgR3JhcGhpY3NDb250ZXh0OjphZGREZXN0aW5hdGlvbkF0UG9pbnQoY29uc3QgU3RyaW5nJiBu YW1lLCBjb25zdCBJbnRQb2ludCYgcG9zKQoreworICAgIFVOVVNFRF9QQVJBTShuYW1lKTsKKyAg ICBVTlVTRURfUEFSQU0ocG9zKTsKK30KKworI2VuZGlmCisKIGNvbnN0IEdyYXBoaWNzQ29udGV4 dFN0YXRlJiBHcmFwaGljc0NvbnRleHQ6OnN0YXRlKCkgY29uc3QKIHsKICAgICByZXR1cm4gbV9z dGF0ZTsKSW5kZXg6IFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29u dGV4dC5oCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dy YXBoaWNzQ29udGV4dC5oCShyZXZpc2lvbiAxNDY5MjMpCisrKyBTb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuaAkod29ya2luZyBjb3B5KQpAQCAtNDIzLDYg KzQyMyw5IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogICAgICAgICB2b2lkIHNldFVSTEZvclJl Y3QoY29uc3QgS1VSTCYsIGNvbnN0IEludFJlY3QmKTsKIAorICAgICAgICB2b2lkIHNldERlc3Rp bmF0aW9uRm9yUmVjdChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IEludFJlY3QmKTsKKyAgICAg ICAgdm9pZCBhZGREZXN0aW5hdGlvbkF0UG9pbnQoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJ bnRQb2ludCYpOworCiAgICAgICAgIHZvaWQgY29uY2F0Q1RNKGNvbnN0IEFmZmluZVRyYW5zZm9y bSYpOwogICAgICAgICB2b2lkIHNldENUTShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mKTsKIApAQCAt NTMyLDYgKzUzNSw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNlbmRpZgogCiAgICAgICAgIHN0 YXRpYyB2b2lkIGFkanVzdExpbmVUb1BpeGVsQm91bmRhcmllcyhGbG9hdFBvaW50JiBwMSwgRmxv YXRQb2ludCYgcDIsIGZsb2F0IHN0cm9rZVdpZHRoLCBTdHJva2VTdHlsZSk7CisgICAgICAgIGJv b2wgc3VwcG9ydHNJbnRlcm5hbExpbmtzKCk7CiAKICAgICBwcml2YXRlOgogICAgICAgICB2b2lk IHBsYXRmb3JtSW5pdChQbGF0Zm9ybUdyYXBoaWNzQ29udGV4dCopOwpJbmRleDogU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvR3JhcGhpY3NDb250ZXh0Q0cuY3BwCj09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT0KLS0tIFNvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL0dyYXBoaWNzQ29udGV4 dENHLmNwcAkocmV2aXNpb24gMTQ2OTIzKQorKysgU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2cvR3JhcGhpY3NDb250ZXh0Q0cuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xODI2LDQg KzE4MjYsMTkgQEAgdm9pZCBHcmFwaGljc0NvbnRleHQ6OnBsYXRmb3JtU3Ryb2tlRWxsaQogICAg IENHQ29udGV4dFN0cm9rZUVsbGlwc2VJblJlY3QoY29udGV4dCwgZWxsaXBzZSk7CiB9CiAKK2Jv b2wgR3JhcGhpY3NDb250ZXh0OjpzdXBwb3J0c0ludGVybmFsTGlua3MoKQoreworICAgIHJldHVy biB0cnVlOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0RGVzdGluYXRpb25Gb3JSZWN0 KGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgSW50UmVjdCYgcmVjdCkKK3sKKyAgICBDR1BERkNv bnRleHRTZXREZXN0aW5hdGlvbkZvclJlY3QocGxhdGZvcm1Db250ZXh0KCksIG5hbWUuY3JlYXRl Q0ZTdHJpbmcoKS5nZXQoKSwgcmVjdCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjphZGRE ZXN0aW5hdGlvbkF0UG9pbnQoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJbnRQb2ludCYgcG9z aXRpb24pCit7CisgICAgQ0dQREZDb250ZXh0QWRkRGVzdGluYXRpb25BdFBvaW50KHBsYXRmb3Jt Q29udGV4dCgpLCBuYW1lLmNyZWF0ZUNGU3RyaW5nKCkuZ2V0KCksIHBvc2l0aW9uKTsKK30KKwog fQpJbmRleDogU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mvc2tpYS9HcmFwaGljc0Nv bnRleHRTa2lhLmNwcAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBTb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9za2lhL0dyYXBoaWNzQ29udGV4dFNraWEuY3BwCShyZXZpc2lvbiAxNDY5MjMpCisrKyBT b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9za2lhL0dyYXBoaWNzQ29udGV4dFNraWEu Y3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMTA4LDYgKzExMDgsMzAgQEAgdm9pZCBHcmFwaGljc0Nv bnRleHQ6OnNldFVSTEZvclJlY3QoY29ucwogICAgIFNrQW5ub3RhdGVSZWN0V2l0aFVSTChwbGF0 Zm9ybUNvbnRleHQoKS0+Y2FudmFzKCksIGRlc3RSZWN0LCB1cmwuZ2V0KCkpOwogfQogCitib29s IEdyYXBoaWNzQ29udGV4dDo6c3VwcG9ydHNJbnRlcm5hbExpbmtzKCkKK3sKKyAgICByZXR1cm4g cGxhdGZvcm1Db250ZXh0KCktPnByaW50aW5nKCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0 OjpzZXREZXN0aW5hdGlvbkZvclJlY3QoY29uc3QgU3RyaW5nJiBkZXN0TmFtZSwgY29uc3QgSW50 UmVjdCYgcmVjdCkKK3sKKyAgICBpZiAocGFpbnRpbmdEaXNhYmxlZCgpKQorICAgICAgICByZXR1 cm47CisKKyAgICBTa0F1dG9EYXRhVW5yZWYgc2tEZXN0TmFtZShTa0RhdGE6Ok5ld1dpdGhDU3Ry aW5nKGRlc3ROYW1lLnV0ZjgoKS5kYXRhKCkpKTsKKyAgICBTa0Fubm90YXRlTGlua1RvRGVzdGlu YXRpb24ocGxhdGZvcm1Db250ZXh0KCktPmNhbnZhcygpLCByZWN0LCBza0Rlc3ROYW1lLmdldCgp KTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmFkZERlc3RpbmF0aW9uQXRQb2ludChjb25z dCBTdHJpbmcmIG5hbWUsIGNvbnN0IEludFBvaW50JiBwb3MpCit7CisgICAgaWYgKHBhaW50aW5n RGlzYWJsZWQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgU2tBdXRvRGF0YVVucmVmIG5hbWVE YXRhKFNrRGF0YTo6TmV3V2l0aENTdHJpbmcobmFtZS51dGY4KCkuZGF0YSgpKSk7CisgICAgU2tB bm5vdGF0ZU5hbWVkRGVzdGluYXRpb24ocGxhdGZvcm1Db250ZXh0KCktPmNhbnZhcygpLAorICAg ICAgICBTa1BvaW50OjpNYWtlKHBvcy54KCksIHBvcy55KCkpLCBuYW1lRGF0YSk7Cit9CisKIHZv aWQgR3JhcGhpY3NDb250ZXh0OjpzZXRQbGF0Zm9ybVNob3VsZEFudGlhbGlhcyhib29sIGVuYWJs ZSkKIHsKICAgICBpZiAocGFpbnRpbmdEaXNhYmxlZCgpKQpJbmRleDogU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gU291cmNlL1dlYkNvcmUv cmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAJKHJldmlzaW9uIDE0NjkyMykKKysrIFNvdXJjZS9X ZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0xMTE0 LDcgKzExMTQsMTYgQEAgdm9pZCBSZW5kZXJPYmplY3Q6OmFkZFBERlVSTFJlY3QoR3JhcGhpYwog ICAgIGNvbnN0IEF0b21pY1N0cmluZyYgaHJlZiA9IHRvRWxlbWVudChuKS0+Z2V0QXR0cmlidXRl KGhyZWZBdHRyKTsKICAgICBpZiAoaHJlZi5pc051bGwoKSkKICAgICAgICAgcmV0dXJuOwotICAg IGNvbnRleHQtPnNldFVSTEZvclJlY3Qobi0+ZG9jdW1lbnQoKS0+Y29tcGxldGVVUkwoaHJlZiks IHBpeGVsU25hcHBlZEludFJlY3QocmVjdCkpOworICAgIEtVUkwgdXJsID0gbi0+ZG9jdW1lbnQo KS0+Y29tcGxldGVVUkwoaHJlZik7CisgICAgaWYgKCF1cmwuaXNWYWxpZCgpKQorICAgICAgICBy ZXR1cm47CisgICAgaWYgKGNvbnRleHQtPnN1cHBvcnRzSW50ZXJuYWxMaW5rcygpICYmIHVybC5o YXNGcmFnbWVudElkZW50aWZpZXIoKSAmJiBlcXVhbElnbm9yaW5nRnJhZ21lbnRJZGVudGlmaWVy KHVybCwgbi0+ZG9jdW1lbnQoKS0+YmFzZVVSTCgpKSkgeworICAgICAgICBTdHJpbmcgbmFtZSA9 IHVybC5mcmFnbWVudElkZW50aWZpZXIoKTsKKyAgICAgICAgaWYgKGRvY3VtZW50KCktPmZpbmRB bmNob3IobmFtZSkpCisgICAgICAgICAgICBjb250ZXh0LT5zZXREZXN0aW5hdGlvbkZvclJlY3Qo bmFtZSwgcGl4ZWxTbmFwcGVkSW50UmVjdChyZWN0KSk7CisgICAgICAgIHJldHVybjsKKyAgICB9 CisgICAgY29udGV4dC0+c2V0VVJMRm9yUmVjdCh1cmwsIHBpeGVsU25hcHBlZEludFJlY3QocmVj dCkpOwogfQogCiB2b2lkIFJlbmRlck9iamVjdDo6cGFpbnRPdXRsaW5lKFBhaW50SW5mbyYgcGFp bnRJbmZvLCBjb25zdCBMYXlvdXRSZWN0JiBwYWludFJlY3QpCkluZGV4OiBTb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3NyYy9XZWJGcmFtZUltcGwuY3BwCj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFNvdXJjZS9XZWJL aXQvY2hyb21pdW0vc3JjL1dlYkZyYW1lSW1wbC5jcHAJKHJldmlzaW9uIDE0NjkyMykKKysrIFNv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYkZyYW1lSW1wbC5jcHAJKHdvcmtpbmcgY29weSkK QEAgLTM1Nyw2ICszNTcsOCBAQCBwdWJsaWM6CiAgICAgICAgIGNvbnRleHQudHJhbnNsYXRlKHN0 YXRpY19jYXN0PGZsb2F0PigtcGFnZVJlY3QueCgpKSwgc3RhdGljX2Nhc3Q8ZmxvYXQ+KC1wYWdl UmVjdC55KCkpKTsKICAgICAgICAgY29udGV4dC5jbGlwKHBhZ2VSZWN0KTsKICAgICAgICAgZnJh bWUoKS0+dmlldygpLT5wYWludENvbnRlbnRzKCZjb250ZXh0LCBwYWdlUmVjdCk7CisgICAgICAg IGlmIChjb250ZXh0LnN1cHBvcnRzSW50ZXJuYWxMaW5rcygpKQorICAgICAgICAgICAgb3V0cHV0 TGlua2VkRGVzdGluYXRpb25zKGNvbnRleHQsIGZyYW1lKCktPmRvY3VtZW50KCksIHBhZ2VSZWN0 KTsKICAgICAgICAgY29udGV4dC5yZXN0b3JlKCk7CiAgICAgICAgIHJldHVybiBzY2FsZTsKICAg ICB9Cg== 259132 2015-08-16 17:24:29 -0700 2016-11-02 00:20:20 -0700 patch, still doesn't work pdf.diff text/plain 9242 thorton ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJDb3JlL0No YW5nZUxvZwppbmRleCBhZGE2YzBlLi44MWNjYTYxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTEg QEAKKzIwMTUtMDgtMTYgIFRpbW90aHkgSG9ydG9uICA8dGltb3RoeV9ob3J0b25AYXBwbGUuY29t PgorCisgICAgICAgIFByaW50aW5nIHRvIFBERiBzaG91bGQgcHJvZHVjZSBpbnRlcm5hbCBsaW5r cyB3aGVuIEhUTUwgaGFzIGludGVybmFsIGxpbmtzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMTIwODEKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKyAgICAgICAgUGF0Y2ggb3JpZ2luYWxseSBieSBEYXZpZCBMYXR0aW1vcmUu CisKIDIwMTUtMDgtMTUgIENocmlzIER1bWV6ICA8Y2R1bWV6QGFwcGxlLmNvbT4KIAogICAgICAg ICBSZWZhY3RvciBIVE1MQ29sbGVjdGlvbiB0byBiZSBhcyBmYXN0IGFzIENhY2hlZExpdmVOb2Rl TGlzdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9QcmludENvbnRleHQuY3BwIGIv U291cmNlL1dlYkNvcmUvcGFnZS9QcmludENvbnRleHQuY3BwCmluZGV4IGY0ODI4NWUuLmZkMDZi OGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUHJpbnRDb250ZXh0LmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1ByaW50Q29udGV4dC5jcHAKQEAgLTI0LDYgKzI0LDcgQEAK ICNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIKICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1 ZGUgIkZyYW1lVmlldy5oIgorI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgogI2luY2x1ZGUgIlJlbmRl clZpZXcuaCIKICNpbmNsdWRlICJTdHlsZUluaGVyaXRlZERhdGEuaCIKICNpbmNsdWRlICJTdHls ZVJlc29sdmVyLmgiCkBAIC00Nyw2ICs0OCw3IEBAIGNvbnN0IGZsb2F0IHByaW50aW5nTWF4aW11 bVNocmlua0ZhY3RvciA9IDI7CiBQcmludENvbnRleHQ6OlByaW50Q29udGV4dChGcmFtZSogZnJh bWUpCiAgICAgOiBtX2ZyYW1lKGZyYW1lKQogICAgICwgbV9pc1ByaW50aW5nKGZhbHNlKQorICAg ICwgbV9saW5rZWREZXN0aW5hdGlvbnNWYWxpZChmYWxzZSkKIHsKIH0KIApAQCAtMjAyLDYgKzIw NCw4IEBAIHZvaWQgUHJpbnRDb250ZXh0OjpzcG9vbFBhZ2UoR3JhcGhpY3NDb250ZXh0JiBjdHgs IGludCBwYWdlTnVtYmVyLCBmbG9hdCB3aWR0aCkKICAgICBjdHgudHJhbnNsYXRlKC1wYWdlUmVj dC54KCksIC1wYWdlUmVjdC55KCkpOwogICAgIGN0eC5jbGlwKHBhZ2VSZWN0KTsKICAgICBtX2Zy YW1lLT52aWV3KCktPnBhaW50Q29udGVudHMoJmN0eCwgcGFnZVJlY3QpOworICAgIGlmIChjdHgu c3VwcG9ydHNJbnRlcm5hbExpbmtzKCkpCisgICAgICAgIG91dHB1dExpbmtlZERlc3RpbmF0aW9u cyhjdHgsIG1fZnJhbWUtPmRvY3VtZW50KCksIHBhZ2VSZWN0KTsKICAgICBjdHgucmVzdG9yZSgp OwogfQogCkBAIC0yMjAsNiArMjI0LDggQEAgdm9pZCBQcmludENvbnRleHQ6OmVuZCgpCiAgICAg QVNTRVJUKG1faXNQcmludGluZyk7CiAgICAgbV9pc1ByaW50aW5nID0gZmFsc2U7CiAgICAgbV9m cmFtZS0+c2V0UHJpbnRpbmcoZmFsc2UsIEZsb2F0U2l6ZSgpLCBGbG9hdFNpemUoKSwgMCwgQWRq dXN0Vmlld1NpemUpOworICAgIG1fbGlua2VkRGVzdGluYXRpb25zLmNsZWFyKCk7CisgICAgbV9s aW5rZWREZXN0aW5hdGlvbnNWYWxpZCA9IGZhbHNlOwogfQogCiBzdGF0aWMgUmVuZGVyQm94TW9k ZWxPYmplY3QqIGVuY2xvc2luZ0JveE1vZGVsT2JqZWN0KFJlbmRlck9iamVjdCogb2JqZWN0KQpA QCAtMjYxLDYgKzI2Nyw0OSBAQCBpbnQgUHJpbnRDb250ZXh0OjpwYWdlTnVtYmVyRm9yRWxlbWVu dChFbGVtZW50KiBlbGVtZW50LCBjb25zdCBGbG9hdFNpemUmIHBhZ2VTaQogICAgIHJldHVybiAt MTsKIH0KIAordm9pZCBQcmludENvbnRleHQ6OmNvbGxlY3RMaW5rZWREZXN0aW5hdGlvbnMoTm9k ZSogbm9kZSkKK3sKKyAgICAvLyBGSVhNRTogV2UgaGF2ZSBiZXR0ZXIgd2F5cyB0byBpdGVyYXRl IG5vdz8KKyAgICBmb3IgKE5vZGUqIGkgPSBub2RlLT5maXJzdENoaWxkKCk7IGk7IGkgPSBpLT5u ZXh0U2libGluZygpKQorICAgICAgICBjb2xsZWN0TGlua2VkRGVzdGluYXRpb25zKGkpOworCisg ICAgaWYgKCFub2RlLT5pc0xpbmsoKSB8fCAhbm9kZS0+aXNFbGVtZW50Tm9kZSgpKQorICAgICAg ICByZXR1cm47CisKKyAgICBjb25zdCBBdG9taWNTdHJpbmcmIGhyZWYgPSBzdGF0aWNfY2FzdDxF bGVtZW50Kj4obm9kZSktPmdldEF0dHJpYnV0ZShIVE1MTmFtZXM6OmhyZWZBdHRyKTsKKyAgICBp ZiAoaHJlZi5pc051bGwoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgRG9jdW1lbnQmIGRvY3Vt ZW50ID0gbm9kZS0+ZG9jdW1lbnQoKTsKKyAgICBVUkwgdXJsID0gZG9jdW1lbnQuY29tcGxldGVV UkwoaHJlZik7CisgICAgaWYgKCF1cmwuaXNWYWxpZCgpKQorICAgICAgICByZXR1cm47CisKKyAg ICBpZiAodXJsLmhhc0ZyYWdtZW50SWRlbnRpZmllcigpICYmIGVxdWFsSWdub3JpbmdGcmFnbWVu dElkZW50aWZpZXIodXJsLCBkb2N1bWVudC5iYXNlVVJMKCkpKSB7CisgICAgICAgIFN0cmluZyBu YW1lID0gdXJsLmZyYWdtZW50SWRlbnRpZmllcigpOworICAgICAgICBpZiAoRWxlbWVudCogZWxl bWVudCA9IGRvY3VtZW50LmZpbmRBbmNob3IobmFtZSkpCisgICAgICAgICAgICBtX2xpbmtlZERl c3RpbmF0aW9ucy5zZXQobmFtZSwgZWxlbWVudCk7CisgICAgfQorfQorCit2b2lkIFByaW50Q29u dGV4dDo6b3V0cHV0TGlua2VkRGVzdGluYXRpb25zKEdyYXBoaWNzQ29udGV4dCYgZ3JhcGhpY3ND b250ZXh0LCBOb2RlKiBub2RlLCBjb25zdCBJbnRSZWN0JiBwYWdlUmVjdCkKK3sKKyAgICBpZiAo IW1fbGlua2VkRGVzdGluYXRpb25zVmFsaWQpIHsKKyAgICAgICAgY29sbGVjdExpbmtlZERlc3Rp bmF0aW9ucyhub2RlKTsKKyAgICAgICAgbV9saW5rZWREZXN0aW5hdGlvbnNWYWxpZCA9IHRydWU7 CisgICAgfQorCisgICAgSGFzaE1hcDxTdHJpbmcsIEVsZW1lbnQqPjo6Y29uc3RfaXRlcmF0b3Ig ZW5kID0gbV9saW5rZWREZXN0aW5hdGlvbnMuZW5kKCk7CisgICAgZm9yIChIYXNoTWFwPFN0cmlu ZywgRWxlbWVudCo+Ojpjb25zdF9pdGVyYXRvciBpdCA9IG1fbGlua2VkRGVzdGluYXRpb25zLmJl Z2luKCk7IGl0ICE9IGVuZDsgKytpdCkgeworICAgICAgICBJbnRSZWN0IGJvdW5kaW5nQm94ID0g aXQtPnZhbHVlLT5yZW5kZXJlcigpLT5hYnNvbHV0ZUJvdW5kaW5nQm94UmVjdCgpOworICAgICAg ICBpZiAocGFnZVJlY3QuaW50ZXJzZWN0cyhib3VuZGluZ0JveCkpIHsKKyAgICAgICAgICAgIElu dFBvaW50IHBvaW50ID0gYm91bmRpbmdCb3gubWluWE1pbllDb3JuZXIoKTsKKyAgICAgICAgICAg IHBvaW50LmNsYW1wTmVnYXRpdmVUb1plcm8oKTsKKyAgICAgICAgICAgIGdyYXBoaWNzQ29udGV4 dC5hZGREZXN0aW5hdGlvbkF0UG9pbnQoaXQtPmtleSwgcG9pbnQpOworICAgICAgICB9CisgICAg fQorfQorCiBTdHJpbmcgUHJpbnRDb250ZXh0OjpwYWdlUHJvcGVydHkoRnJhbWUqIGZyYW1lLCBj b25zdCBjaGFyKiBwcm9wZXJ0eU5hbWUsIGludCBwYWdlTnVtYmVyKQogewogICAgIERvY3VtZW50 KiBkb2N1bWVudCA9IGZyYW1lLT5kb2N1bWVudCgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGFnZS9QcmludENvbnRleHQuaCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUHJpbnRDb250ZXh0 LmgKaW5kZXggN2M1MWNhNC4uMDJjOGFlMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFn ZS9QcmludENvbnRleHQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1ByaW50Q29udGV4dC5o CkBAIC0yMiw3ICsyMiw5IEBACiAjZGVmaW5lIFByaW50Q29udGV4dF9oCiAKICNpbmNsdWRlIDx3 dGYvRm9yd2FyZC5oPgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL1Zl Y3Rvci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgogCiBuYW1lc3BhY2UgV2Vi Q29yZSB7CiAKQEAgLTMyLDYgKzM0LDcgQEAgY2xhc3MgRmxvYXRSZWN0OwogY2xhc3MgRmxvYXRT aXplOwogY2xhc3MgR3JhcGhpY3NDb250ZXh0OwogY2xhc3MgSW50UmVjdDsKK2NsYXNzIE5vZGU7 CiAKIGNsYXNzIFByaW50Q29udGV4dCB7CiBwdWJsaWM6CkBAIC04MCwxNCArODMsMjAgQEAgcHVi bGljOgogICAgIFdFQkNPUkVfRVhQT1JUIHN0YXRpYyB2b2lkIHNwb29sQWxsUGFnZXNXaXRoQm91 bmRhcmllcyhGcmFtZSosIEdyYXBoaWNzQ29udGV4dCYsIGNvbnN0IEZsb2F0U2l6ZSYgcGFnZVNp emVJblBpeGVscyk7CiAKIHByb3RlY3RlZDoKKyAgICB2b2lkIG91dHB1dExpbmtlZERlc3RpbmF0 aW9ucyhHcmFwaGljc0NvbnRleHQmLCBOb2RlKiwgY29uc3QgSW50UmVjdCYgcGFnZVJlY3QpOwor CiAgICAgRnJhbWUqIG1fZnJhbWU7CiAgICAgVmVjdG9yPEludFJlY3Q+IG1fcGFnZVJlY3RzOwog CiBwcml2YXRlOgogICAgIHZvaWQgY29tcHV0ZVBhZ2VSZWN0c1dpdGhQYWdlU2l6ZUludGVybmFs KGNvbnN0IEZsb2F0U2l6ZSYgcGFnZVNpemVJblBpeGVscywgYm9vbCBhbGxvd0hvcml6b250YWxU aWxpbmcpOworICAgIHZvaWQgY29sbGVjdExpbmtlZERlc3RpbmF0aW9ucyhOb2RlKik7CiAKICAg ICAvLyBVc2VkIHRvIHByZXZlbnQgbWlzdXNlcyBvZiBiZWdpbigpIGFuZCBlbmQoKSAoZS5nLiwg Y2FsbCBlbmQgd2l0aG91dCBiZWdpbikuCiAgICAgYm9vbCBtX2lzUHJpbnRpbmc7CisKKyAgICBI YXNoTWFwPFN0cmluZywgRWxlbWVudCo+IG1fbGlua2VkRGVzdGluYXRpb25zOworICAgIGJvb2wg bV9saW5rZWREZXN0aW5hdGlvbnNWYWxpZDsKIH07CiAKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuY3BwCmluZGV4IGU2YjM3ZmQu LjFmYzAwNGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dy YXBoaWNzQ29udGV4dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv R3JhcGhpY3NDb250ZXh0LmNwcApAQCAtNzQzLDQgKzc0MywyNCBAQCBGbG9hdFJlY3QgR3JhcGhp Y3NDb250ZXh0Ojpjb21wdXRlTGluZUJvdW5kc0FuZEFudGlhbGlhc2luZ01vZGVGb3JUZXh0KGNv bnN0IEZsbwogICAgIHJldHVybiBGbG9hdFJlY3Qob3JpZ2luLngoKSwgb3JpZ2luLnkoKSwgd2lk dGgsIHRoaWNrbmVzcyk7CiB9CiAKKyNpZiAhVVNFKENHKQorYm9vbCBHcmFwaGljc0NvbnRleHQ6 OnN1cHBvcnRzSW50ZXJuYWxMaW5rcygpCit7CisgICAgcmV0dXJuIGZhbHNlOworfQorCit2b2lk IEdyYXBoaWNzQ29udGV4dDo6c2V0RGVzdGluYXRpb25Gb3JSZWN0KGNvbnN0IFN0cmluZyYgZGVz dE5hbWUsIGNvbnN0IEludFJlY3QmIHJlY3QpCit7CisgICAgVU5VU0VEX1BBUkFNKGRlc3ROYW1l KTsKKyAgICBVTlVTRURfUEFSQU0ocmVjdCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0Ojph ZGREZXN0aW5hdGlvbkF0UG9pbnQoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJbnRQb2ludCYg cG9zKQoreworICAgIFVOVVNFRF9QQVJBTShuYW1lKTsKKyAgICBVTlVTRURfUEFSQU0ocG9zKTsK K30KKworI2VuZGlmCisKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL0dyYXBoaWNzQ29udGV4dC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvR3JhcGhpY3NDb250ZXh0LmgKaW5kZXggZDhkZWZmMC4uYjdkOTU1OSAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmgKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmgKQEAgLTQy NSw2ICs0MjUsOSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKICAgICAgICAgdm9pZCBzZXRVUkxG b3JSZWN0KGNvbnN0IFVSTCYsIGNvbnN0IEludFJlY3QmKTsKIAorICAgICAgICB2b2lkIHNldERl c3RpbmF0aW9uRm9yUmVjdChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IEludFJlY3QmKTsKKyAg ICAgICAgdm9pZCBhZGREZXN0aW5hdGlvbkF0UG9pbnQoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25z dCBJbnRQb2ludCYpOworCiAgICAgICAgIHZvaWQgY29uY2F0Q1RNKGNvbnN0IEFmZmluZVRyYW5z Zm9ybSYpOwogICAgICAgICB2b2lkIHNldENUTShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mKTsKIApA QCAtNTEzLDYgKzUxNiw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKICNlbmRpZgogCiAgICAgICAg IHN0YXRpYyB2b2lkIGFkanVzdExpbmVUb1BpeGVsQm91bmRhcmllcyhGbG9hdFBvaW50JiBwMSwg RmxvYXRQb2ludCYgcDIsIGZsb2F0IHN0cm9rZVdpZHRoLCBTdHJva2VTdHlsZSk7CisgICAgICAg IGJvb2wgc3VwcG9ydHNJbnRlcm5hbExpbmtzKCk7CiAKICAgICBwcml2YXRlOgogICAgICAgICB2 b2lkIHBsYXRmb3JtSW5pdChQbGF0Zm9ybUdyYXBoaWNzQ29udGV4dCopOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvR3JhcGhpY3NDb250ZXh0Q0cuY3Bw IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvR3JhcGhpY3NDb250ZXh0Q0cu Y3BwCmluZGV4IDA4MGY3MmYuLjVlZmY1Y2EgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2NnL0dyYXBoaWNzQ29udGV4dENHLmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9HcmFwaGljc0NvbnRleHRDRy5jcHAKQEAgLTE2MzQs NCArMTYzNCwzNCBAQCB2b2lkIEdyYXBoaWNzQ29udGV4dDo6cGxhdGZvcm1TdHJva2VFbGxpcHNl KGNvbnN0IEZsb2F0UmVjdCYgZWxsaXBzZSkKICAgICBDR0NvbnRleHRTdHJva2VFbGxpcHNlSW5S ZWN0KGNvbnRleHQsIGVsbGlwc2UpOwogfQogCitib29sIEdyYXBoaWNzQ29udGV4dDo6c3VwcG9y dHNJbnRlcm5hbExpbmtzKCkKK3sKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwordm9pZCBHcmFwaGlj c0NvbnRleHQ6OnNldERlc3RpbmF0aW9uRm9yUmVjdChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0 IEludFJlY3QmIGRlc3RSZWN0KQoreworICAgIGlmIChwYWludGluZ0Rpc2FibGVkKCkpCisgICAg ICAgIHJldHVybjsKKworICAgIENHQ29udGV4dFJlZiBjb250ZXh0ID0gcGxhdGZvcm1Db250ZXh0 KCk7CisKKyAgICBJbnRSZWN0IHJlY3QgPSBkZXN0UmVjdDsKKyAgICByZWN0LmludGVyc2VjdChl bmNsb3NpbmdJbnRSZWN0KENHQ29udGV4dEdldENsaXBCb3VuZGluZ0JveChjb250ZXh0KSkpOwor CisgICAgQ0dSZWN0IHRyYW5zZm9ybWVkUmVjdCA9IENHUmVjdEFwcGx5QWZmaW5lVHJhbnNmb3Jt KHJlY3QsIENHQ29udGV4dEdldENUTShjb250ZXh0KSk7CisgICAgQ0dQREZDb250ZXh0U2V0RGVz dGluYXRpb25Gb3JSZWN0KGNvbnRleHQsIG5hbWUuY3JlYXRlQ0ZTdHJpbmcoKS5nZXQoKSwgdHJh bnNmb3JtZWRSZWN0KTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmFkZERlc3RpbmF0aW9u QXRQb2ludChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IEludFBvaW50JiBwb3NpdGlvbikKK3sK KyAgICBpZiAocGFpbnRpbmdEaXNhYmxlZCgpKQorICAgICAgICByZXR1cm47CisKKyAgICBDR0Nv bnRleHRSZWYgY29udGV4dCA9IHBsYXRmb3JtQ29udGV4dCgpOworCisgICAgQ0dQb2ludCB0cmFu c2Zvcm1lZFBvaW50ID0gQ0dQb2ludEFwcGx5QWZmaW5lVHJhbnNmb3JtKHBvc2l0aW9uLCBDR0Nv bnRleHRHZXRDVE0oY29udGV4dCkpOworICAgIENHUERGQ29udGV4dEFkZERlc3RpbmF0aW9uQXRQ b2ludChjb250ZXh0LCBuYW1lLmNyZWF0ZUNGU3RyaW5nKCkuZ2V0KCksIHRyYW5zZm9ybWVkUG9p bnQpOworfQorCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy T2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCmlu ZGV4IDM1YjMxNjIuLjExZDY1M2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJPYmplY3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJP YmplY3QuY3BwCkBAIC03MTgsMTAgKzcxOCwyNSBAQCB2b2lkIFJlbmRlck9iamVjdDo6YWRkUERG VVJMUmVjdChQYWludEluZm8mIHBhaW50SW5mbywgY29uc3QgTGF5b3V0UG9pbnQmIHBhaW50Twog ICAgIE5vZGUqIG5vZGUgPSB0aGlzLT5ub2RlKCk7CiAgICAgaWYgKCFpczxFbGVtZW50Pihub2Rl KSB8fCAhbm9kZS0+aXNMaW5rKCkpCiAgICAgICAgIHJldHVybjsKKwogICAgIGNvbnN0IEF0b21p Y1N0cmluZyYgaHJlZiA9IGRvd25jYXN0PEVsZW1lbnQ+KCpub2RlKS5nZXRBdHRyaWJ1dGUoaHJl ZkF0dHIpOwogICAgIGlmIChocmVmLmlzTnVsbCgpKQogICAgICAgICByZXR1cm47Ci0gICAgcGFp bnRJbmZvLmNvbnRleHQtPnNldFVSTEZvclJlY3Qobm9kZS0+ZG9jdW1lbnQoKS5jb21wbGV0ZVVS TChocmVmKSwgc25hcHBlZEludFJlY3QodXJsUmVjdCkpOworCisgICAgRG9jdW1lbnQmIGRvY3Vt ZW50ID0gbm9kZS0+ZG9jdW1lbnQoKTsKKworICAgIFVSTCB1cmwgPSBkb2N1bWVudC5jb21wbGV0 ZVVSTChocmVmKTsKKyAgICBpZiAoIXVybC5pc1ZhbGlkKCkpCisgICAgICAgIHJldHVybjsKKwor ICAgIGlmIChwYWludEluZm8uY29udGV4dC0+c3VwcG9ydHNJbnRlcm5hbExpbmtzKCkgJiYgdXJs Lmhhc0ZyYWdtZW50SWRlbnRpZmllcigpICYmIGVxdWFsSWdub3JpbmdGcmFnbWVudElkZW50aWZp ZXIodXJsLCBkb2N1bWVudC5iYXNlVVJMKCkpKSB7CisgICAgICAgIFN0cmluZyBuYW1lID0gdXJs LmZyYWdtZW50SWRlbnRpZmllcigpOworICAgICAgICBpZiAoZG9jdW1lbnQuZmluZEFuY2hvcihu YW1lKSkKKyAgICAgICAgICAgIHBhaW50SW5mby5jb250ZXh0LT5zZXREZXN0aW5hdGlvbkZvclJl Y3QobmFtZSwgdXJsUmVjdCk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBwYWludElu Zm8uY29udGV4dC0+c2V0VVJMRm9yUmVjdCh1cmwsIHVybFJlY3QpOwogfQogCiAjaWYgUExBVEZP Uk0oSU9TKQo= 293645 2016-11-02 00:20:30 -0700 2016-11-04 09:53:34 -0700 Significant progress; actually works now bug-112081-20161102001631.patch text/plain 14860 thorton U3VidmVyc2lvbiBSZXZpc2lvbjogMjA4MjcwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggOWFlZGU3NjM2MWNkNDU1 YjAxNzBkMjIxOTVjNDkyNWNiZGU1NDNiMC4uZGI4YTQ5ZGEwNDA1NWRhMTg4OTdiYTM2MzE3OTJh NGZhNzFkZDZmMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDExIEBACisyMDE2LTEwLTEwICBUaW1v dGh5IEhvcnRvbiAgPHRpbW90aHlfaG9ydG9uQGFwcGxlLmNvbT4KKworICAgICAgICBQcmludGlu ZyB0byBQREYgc2hvdWxkIHByb2R1Y2UgaW50ZXJuYWwgbGlua3Mgd2hlbiBIVE1MIGhhcyBpbnRl cm5hbCBsaW5rcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTEyMDgxCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisgICAgICAg IFBhdGNoIG9yaWdpbmFsbHkgYnkgRGF2aWQgTGF0dGltb3JlLgorCiAyMDE2LTExLTAxICBEYXZl IEh5YXR0ICA8aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAgIFtDU1MgUGFyc2VyXSBTdXBwb3J0 IHRoZSBzaGFkb3cgRE9NCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1ByaW50Q29u dGV4dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1ByaW50Q29udGV4dC5jcHAKaW5kZXggNTRk ZWEzNmY5MmFlYTBmZDNkYzUxNWFlOTlkMDJlZDJlYWUzZjQyOS4uYTdmY2E3NTUzN2I4MTQwMWIw ODJmMTcyYmNhNTdiZjMxMjBlN2UwNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGFnZS9Q cmludENvbnRleHQuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUHJpbnRDb250ZXh0LmNw cApAQCAtMjQsNiArMjQsNyBAQAogI2luY2x1ZGUgIkdyYXBoaWNzQ29udGV4dC5oIgogI2luY2x1 ZGUgIkZyYW1lLmgiCiAjaW5jbHVkZSAiRnJhbWVWaWV3LmgiCisjaW5jbHVkZSAiSFRNTE5hbWVz LmgiCiAjaW5jbHVkZSAiUmVuZGVyVmlldy5oIgogI2luY2x1ZGUgIlN0eWxlSW5oZXJpdGVkRGF0 YS5oIgogI2luY2x1ZGUgIlN0eWxlUmVzb2x2ZXIuaCIKQEAgLTM1LDYgKzM2LDcgQEAgbmFtZXNw YWNlIFdlYkNvcmUgewogUHJpbnRDb250ZXh0OjpQcmludENvbnRleHQoRnJhbWUqIGZyYW1lKQog ICAgIDogbV9mcmFtZShmcmFtZSkKICAgICAsIG1faXNQcmludGluZyhmYWxzZSkKKyAgICAsIG1f bGlua2VkRGVzdGluYXRpb25zVmFsaWQoZmFsc2UpCiB7CiB9CiAKQEAgLTE5MCw2ICsxOTIsOCBA QCB2b2lkIFByaW50Q29udGV4dDo6c3Bvb2xQYWdlKEdyYXBoaWNzQ29udGV4dCYgY3R4LCBpbnQg cGFnZU51bWJlciwgZmxvYXQgd2lkdGgpCiAgICAgY3R4LnRyYW5zbGF0ZSgtcGFnZVJlY3QueCgp LCAtcGFnZVJlY3QueSgpKTsKICAgICBjdHguY2xpcChwYWdlUmVjdCk7CiAgICAgbV9mcmFtZS0+ dmlldygpLT5wYWludENvbnRlbnRzKGN0eCwgcGFnZVJlY3QpOworICAgIGlmIChjdHguc3VwcG9y dHNJbnRlcm5hbExpbmtzKCkpCisgICAgICAgIG91dHB1dExpbmtlZERlc3RpbmF0aW9ucyhjdHgs IG1fZnJhbWUtPmRvY3VtZW50KCksIHBhZ2VSZWN0KTsKICAgICBjdHgucmVzdG9yZSgpOwogfQog CkBAIC0yMDAsNiArMjA0LDggQEAgdm9pZCBQcmludENvbnRleHQ6OnNwb29sUmVjdChHcmFwaGlj c0NvbnRleHQmIGN0eCwgY29uc3QgSW50UmVjdCYgcmVjdCkKICAgICBjdHgudHJhbnNsYXRlKC1y ZWN0LngoKSwgLXJlY3QueSgpKTsKICAgICBjdHguY2xpcChyZWN0KTsKICAgICBtX2ZyYW1lLT52 aWV3KCktPnBhaW50Q29udGVudHMoY3R4LCByZWN0KTsKKyAgICBpZiAoY3R4LnN1cHBvcnRzSW50 ZXJuYWxMaW5rcygpKQorICAgICAgICBvdXRwdXRMaW5rZWREZXN0aW5hdGlvbnMoY3R4LCBtX2Zy YW1lLT5kb2N1bWVudCgpLCByZWN0KTsKICAgICBjdHgucmVzdG9yZSgpOwogfQogCkBAIC0yMDgs NiArMjE0LDggQEAgdm9pZCBQcmludENvbnRleHQ6OmVuZCgpCiAgICAgQVNTRVJUKG1faXNQcmlu dGluZyk7CiAgICAgbV9pc1ByaW50aW5nID0gZmFsc2U7CiAgICAgbV9mcmFtZS0+c2V0UHJpbnRp bmcoZmFsc2UsIEZsb2F0U2l6ZSgpLCBGbG9hdFNpemUoKSwgMCwgQWRqdXN0Vmlld1NpemUpOwor ICAgIG1fbGlua2VkRGVzdGluYXRpb25zLmNsZWFyKCk7CisgICAgbV9saW5rZWREZXN0aW5hdGlv bnNWYWxpZCA9IGZhbHNlOwogfQogCiBzdGF0aWMgaW5saW5lIFJlbmRlckJveE1vZGVsT2JqZWN0 KiBlbmNsb3NpbmdCb3hNb2RlbE9iamVjdChSZW5kZXJFbGVtZW50KiByZW5kZXJlcikKQEAgLTI0 Niw2ICsyNTQsNDkgQEAgaW50IFByaW50Q29udGV4dDo6cGFnZU51bWJlckZvckVsZW1lbnQoRWxl bWVudCogZWxlbWVudCwgY29uc3QgRmxvYXRTaXplJiBwYWdlU2kKICAgICByZXR1cm4gLTE7CiB9 CiAKK3ZvaWQgUHJpbnRDb250ZXh0Ojpjb2xsZWN0TGlua2VkRGVzdGluYXRpb25zKE5vZGUqIG5v ZGUpCit7CisgICAgLy8gRklYTUU6IFdlIGhhdmUgYmV0dGVyIHdheXMgdG8gaXRlcmF0ZSBub3c/ CisgICAgZm9yIChOb2RlKiBpID0gbm9kZS0+Zmlyc3RDaGlsZCgpOyBpOyBpID0gaS0+bmV4dFNp YmxpbmcoKSkKKyAgICAgICAgY29sbGVjdExpbmtlZERlc3RpbmF0aW9ucyhpKTsKKworICAgIGlm ICghbm9kZS0+aXNMaW5rKCkgfHwgIW5vZGUtPmlzRWxlbWVudE5vZGUoKSkKKyAgICAgICAgcmV0 dXJuOworCisgICAgY29uc3QgQXRvbWljU3RyaW5nJiBocmVmID0gc3RhdGljX2Nhc3Q8RWxlbWVu dCo+KG5vZGUpLT5nZXRBdHRyaWJ1dGUoSFRNTE5hbWVzOjpocmVmQXR0cik7CisgICAgaWYgKGhy ZWYuaXNOdWxsKCkpCisgICAgICAgIHJldHVybjsKKworICAgIERvY3VtZW50JiBkb2N1bWVudCA9 IG5vZGUtPmRvY3VtZW50KCk7CisgICAgVVJMIHVybCA9IGRvY3VtZW50LmNvbXBsZXRlVVJMKGhy ZWYpOworICAgIGlmICghdXJsLmlzVmFsaWQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYg KHVybC5oYXNGcmFnbWVudElkZW50aWZpZXIoKSAmJiBlcXVhbElnbm9yaW5nRnJhZ21lbnRJZGVu dGlmaWVyKHVybCwgZG9jdW1lbnQuYmFzZVVSTCgpKSkgeworICAgICAgICBTdHJpbmcgbmFtZSA9 IHVybC5mcmFnbWVudElkZW50aWZpZXIoKTsKKyAgICAgICAgaWYgKEVsZW1lbnQqIGVsZW1lbnQg PSBkb2N1bWVudC5maW5kQW5jaG9yKG5hbWUpKQorICAgICAgICAgICAgbV9saW5rZWREZXN0aW5h dGlvbnMuc2V0KG5hbWUsIGVsZW1lbnQpOworICAgIH0KK30KKwordm9pZCBQcmludENvbnRleHQ6 Om91dHB1dExpbmtlZERlc3RpbmF0aW9ucyhHcmFwaGljc0NvbnRleHQmIGdyYXBoaWNzQ29udGV4 dCwgTm9kZSogbm9kZSwgY29uc3QgSW50UmVjdCYgcGFnZVJlY3QpCit7CisgICAgaWYgKCFtX2xp bmtlZERlc3RpbmF0aW9uc1ZhbGlkKSB7CisgICAgICAgIGNvbGxlY3RMaW5rZWREZXN0aW5hdGlv bnMobm9kZSk7CisgICAgICAgIG1fbGlua2VkRGVzdGluYXRpb25zVmFsaWQgPSB0cnVlOworICAg IH0KKworICAgIEhhc2hNYXA8U3RyaW5nLCBFbGVtZW50Kj46OmNvbnN0X2l0ZXJhdG9yIGVuZCA9 IG1fbGlua2VkRGVzdGluYXRpb25zLmVuZCgpOworICAgIGZvciAoSGFzaE1hcDxTdHJpbmcsIEVs ZW1lbnQqPjo6Y29uc3RfaXRlcmF0b3IgaXQgPSBtX2xpbmtlZERlc3RpbmF0aW9ucy5iZWdpbigp OyBpdCAhPSBlbmQ7ICsraXQpIHsKKyAgICAgICAgSW50UmVjdCBib3VuZGluZ0JveCA9IGl0LT52 YWx1ZS0+cmVuZGVyZXIoKS0+YWJzb2x1dGVCb3VuZGluZ0JveFJlY3QoKTsKKyAgICAgICAgaWYg KHBhZ2VSZWN0LmludGVyc2VjdHMoYm91bmRpbmdCb3gpKSB7CisgICAgICAgICAgICBJbnRQb2lu dCBwb2ludCA9IGJvdW5kaW5nQm94Lm1pblhNaW5ZQ29ybmVyKCk7CisgICAgICAgICAgICBwb2lu dC5jbGFtcE5lZ2F0aXZlVG9aZXJvKCk7CisgICAgICAgICAgICBncmFwaGljc0NvbnRleHQuYWRk RGVzdGluYXRpb25BdFBvaW50KGl0LT5rZXksIHBvaW50KTsKKyAgICAgICAgfQorICAgIH0KK30K KwogU3RyaW5nIFByaW50Q29udGV4dDo6cGFnZVByb3BlcnR5KEZyYW1lKiBmcmFtZSwgY29uc3Qg Y2hhciogcHJvcGVydHlOYW1lLCBpbnQgcGFnZU51bWJlcikKIHsKICAgICBEb2N1bWVudCogZG9j dW1lbnQgPSBmcmFtZS0+ZG9jdW1lbnQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bh Z2UvUHJpbnRDb250ZXh0LmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1ByaW50Q29udGV4dC5oCmlu ZGV4IDlmYzY2ZDNkYTkxMGUwNTA4OWY1NTdhZTM2ZjkxMjMwOTU3NGJkMGEuLmQ5MWI2ZGJkNzQ1 ZTQwOTE0NjkxMmIwNmQwYWI5N2Q1NzVmMDBiMWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvUHJpbnRDb250ZXh0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QcmludENvbnRl eHQuaApAQCAtMjEsNyArMjEsOSBAQAogI3ByYWdtYSBvbmNlCiAKICNpbmNsdWRlIDx3dGYvRm9y d2FyZC5oPgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5o PgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7 CiAKQEAgLTMxLDYgKzMzLDcgQEAgY2xhc3MgRmxvYXRSZWN0OwogY2xhc3MgRmxvYXRTaXplOwog Y2xhc3MgR3JhcGhpY3NDb250ZXh0OwogY2xhc3MgSW50UmVjdDsKK2NsYXNzIE5vZGU7CiAKIGNs YXNzIFByaW50Q29udGV4dCB7CiBwdWJsaWM6CkBAIC05MiwxNSArOTUsMjEgQEAgcHVibGljOgog ICAgIHN0YXRpYyBjb25zdGV4cHIgZmxvYXQgbWF4aW11bVNocmlua0ZhY3RvcigpIHsgcmV0dXJu IDI7IH0KIAogcHJvdGVjdGVkOgorICAgIHZvaWQgb3V0cHV0TGlua2VkRGVzdGluYXRpb25zKEdy YXBoaWNzQ29udGV4dCYsIE5vZGUqLCBjb25zdCBJbnRSZWN0JiBwYWdlUmVjdCk7CisKICAgICBG cmFtZSogbV9mcmFtZTsKICAgICBWZWN0b3I8SW50UmVjdD4gbV9wYWdlUmVjdHM7CiAKIHByaXZh dGU6CiAgICAgdm9pZCBjb21wdXRlUGFnZVJlY3RzV2l0aFBhZ2VTaXplSW50ZXJuYWwoY29uc3Qg RmxvYXRTaXplJiBwYWdlU2l6ZUluUGl4ZWxzLCBib29sIGFsbG93SG9yaXpvbnRhbFRpbGluZyk7 CiAgICAgYm9vbCBiZWdpbkFuZENvbXB1dGVQYWdlUmVjdHNXaXRoUGFnZVNpemUoRnJhbWUmLCBj b25zdCBGbG9hdFNpemUmIHBhZ2VTaXplSW5QaXhlbHMpOworICAgIHZvaWQgY29sbGVjdExpbmtl ZERlc3RpbmF0aW9ucyhOb2RlKik7CiAKICAgICAvLyBVc2VkIHRvIHByZXZlbnQgbWlzdXNlcyBv ZiBiZWdpbigpIGFuZCBlbmQoKSAoZS5nLiwgY2FsbCBlbmQgd2l0aG91dCBiZWdpbikuCiAgICAg Ym9vbCBtX2lzUHJpbnRpbmc7CisKKyAgICBIYXNoTWFwPFN0cmluZywgRWxlbWVudCo+IG1fbGlu a2VkRGVzdGluYXRpb25zOworICAgIGJvb2wgbV9saW5rZWREZXN0aW5hdGlvbnNWYWxpZDsKIH07 CiAKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuY3BwCmluZGV4IDg4YjdmNWI5MTVlNDdjNTgx YTcyOGQ2NWVkMzMwYjE3ZmU1ODFkMzkuLjdjZGM1YzVmMTNiYzVjOGQyMDkwNWQ5NTkwODRmYzYz NDMxMzQzNWQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dy YXBoaWNzQ29udGV4dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv R3JhcGhpY3NDb250ZXh0LmNwcApAQCAtMTE3Nyw0ICsxMTc3LDI0IEBAIFZlY3RvcjxGbG9hdFBv aW50PiBHcmFwaGljc0NvbnRleHQ6OmNlbnRlckxpbmVBbmRDdXRPZmZDb3JuZXJzKGJvb2wgaXNW ZXJ0aWNhbExpCiAgICAgcmV0dXJuIHsgcG9pbnQxLCBwb2ludDIgfTsKIH0KIAorI2lmICFVU0Uo Q0cpCitib29sIEdyYXBoaWNzQ29udGV4dDo6c3VwcG9ydHNJbnRlcm5hbExpbmtzKCkKK3sKKyAg ICByZXR1cm4gZmFsc2U7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzZXREZXN0aW5hdGlv bkZvclJlY3QoY29uc3QgU3RyaW5nJiBkZXN0TmFtZSwgY29uc3QgSW50UmVjdCYgcmVjdCkKK3sK KyAgICBVTlVTRURfUEFSQU0oZGVzdE5hbWUpOworICAgIFVOVVNFRF9QQVJBTShyZWN0KTsKK30K Kwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmFkZERlc3RpbmF0aW9uQXRQb2ludChjb25zdCBTdHJp bmcmIG5hbWUsIGNvbnN0IEludFBvaW50JiBwb3MpCit7CisgICAgVU5VU0VEX1BBUkFNKG5hbWUp OworICAgIFVOVVNFRF9QQVJBTShwb3MpOworfQorCisjZW5kaWYKKwogfQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmggYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuaAppbmRleCA1Njk3 YzA5Zjc2ZWQ2M2EwYzlmODk3ZTkwMTU1MTlkNTA3ODJjNDQxLi40NTJhN2U5Njc5YjRkYTU4YTU2 OWU2MmE2MWRlOTI3OTQ2ZjkyOGEyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuaApAQCAtNDcwLDYgKzQ3MCw5IEBAIHB1YmxpYzoK IAogICAgIHZvaWQgc2V0VVJMRm9yUmVjdChjb25zdCBVUkwmLCBjb25zdCBJbnRSZWN0Jik7CiAK KyAgICB2b2lkIHNldERlc3RpbmF0aW9uRm9yUmVjdChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0 IEludFJlY3QmKTsKKyAgICB2b2lkIGFkZERlc3RpbmF0aW9uQXRQb2ludChjb25zdCBTdHJpbmcm IG5hbWUsIGNvbnN0IEludFBvaW50Jik7CisKICAgICB2b2lkIGNvbmNhdENUTShjb25zdCBBZmZp bmVUcmFuc2Zvcm0mKTsKICAgICB2b2lkIHNldENUTShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mKTsK IApAQCAtNTc2LDYgKzU3OSw4IEBAIHB1YmxpYzoKIAogICAgIHN0YXRpYyB2b2lkIGFkanVzdExp bmVUb1BpeGVsQm91bmRhcmllcyhGbG9hdFBvaW50JiBwMSwgRmxvYXRQb2ludCYgcDIsIGZsb2F0 IHN0cm9rZVdpZHRoLCBTdHJva2VTdHlsZSk7CiAKKyAgICBib29sIHN1cHBvcnRzSW50ZXJuYWxM aW5rcygpOworCiBwcml2YXRlOgogICAgIHZvaWQgcGxhdGZvcm1Jbml0KFBsYXRmb3JtR3JhcGhp Y3NDb250ZXh0Kik7CiAgICAgdm9pZCBwbGF0Zm9ybURlc3Ryb3koKTsKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL0dyYXBoaWNzQ29udGV4dENHLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL0dyYXBoaWNzQ29udGV4dENHLmNw cAppbmRleCBlMDZmNDVkNDkyYzU4OGFiYzJlYjlmNWFmY2QyNDBkMzhlZWM1NTI4Li5hMjgxYTEw OGI4MThjMzRhZDFkYmFiMjdjZmIxNjRjOTIwZTZiZjE4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9HcmFwaGljc0NvbnRleHRDRy5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvR3JhcGhpY3NDb250ZXh0Q0cuY3BwCkBA IC0xNTcyLDggKzE1NzIsNyBAQCB2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0VVJMRm9yUmVjdChj b25zdCBVUkwmIGxpbmssIGNvbnN0IEludFJlY3QmIGRlc3RSZWN0KQogICAgIEludFJlY3QgcmVj dCA9IGRlc3RSZWN0OwogICAgIHJlY3QuaW50ZXJzZWN0KGludEJveCk7CiAKLSAgICBDR1BERkNv bnRleHRTZXRVUkxGb3JSZWN0KGNvbnRleHQsIHVybFJlZi5nZXQoKSwKLSAgICAgICAgQ0dSZWN0 QXBwbHlBZmZpbmVUcmFuc2Zvcm0ocmVjdCwgQ0dDb250ZXh0R2V0Q1RNKGNvbnRleHQpKSk7Cisg ICAgQ0dQREZDb250ZXh0U2V0VVJMRm9yUmVjdChjb250ZXh0LCB1cmxSZWYuZ2V0KCksIENHUmVj dEFwcGx5QWZmaW5lVHJhbnNmb3JtKHJlY3QsIENHQ29udGV4dEdldENUTShjb250ZXh0KSkpOwog I2Vsc2UKICAgICBVTlVTRURfUEFSQU0obGluayk7CiAgICAgVU5VU0VEX1BBUkFNKGRlc3RSZWN0 KTsKQEAgLTE5MDIsNiArMTkwMSwzNiBAQCB2b2lkIEdyYXBoaWNzQ29udGV4dDo6cGxhdGZvcm1T dHJva2VFbGxpcHNlKGNvbnN0IEZsb2F0UmVjdCYgZWxsaXBzZSkKICAgICBDR0NvbnRleHRTdHJv a2VFbGxpcHNlSW5SZWN0KGNvbnRleHQsIGVsbGlwc2UpOwogfQogCitib29sIEdyYXBoaWNzQ29u dGV4dDo6c3VwcG9ydHNJbnRlcm5hbExpbmtzKCkKK3sKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwor dm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldERlc3RpbmF0aW9uRm9yUmVjdChjb25zdCBTdHJpbmcm IG5hbWUsIGNvbnN0IEludFJlY3QmIGRlc3RSZWN0KQoreworICAgIGlmIChwYWludGluZ0Rpc2Fi bGVkKCkpCisgICAgICAgIHJldHVybjsKKworICAgIENHQ29udGV4dFJlZiBjb250ZXh0ID0gcGxh dGZvcm1Db250ZXh0KCk7CisKKyAgICBJbnRSZWN0IHJlY3QgPSBkZXN0UmVjdDsKKyAgICByZWN0 LmludGVyc2VjdChlbmNsb3NpbmdJbnRSZWN0KENHQ29udGV4dEdldENsaXBCb3VuZGluZ0JveChj b250ZXh0KSkpOworCisgICAgQ0dSZWN0IHRyYW5zZm9ybWVkUmVjdCA9IENHUmVjdEFwcGx5QWZm aW5lVHJhbnNmb3JtKHJlY3QsIENHQ29udGV4dEdldENUTShjb250ZXh0KSk7CisgICAgQ0dQREZD b250ZXh0U2V0RGVzdGluYXRpb25Gb3JSZWN0KGNvbnRleHQsIG5hbWUuY3JlYXRlQ0ZTdHJpbmco KS5nZXQoKSwgdHJhbnNmb3JtZWRSZWN0KTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OmFk ZERlc3RpbmF0aW9uQXRQb2ludChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IEludFBvaW50JiBw b3NpdGlvbikKK3sKKyAgICBpZiAocGFpbnRpbmdEaXNhYmxlZCgpKQorICAgICAgICByZXR1cm47 CisKKyAgICBDR0NvbnRleHRSZWYgY29udGV4dCA9IHBsYXRmb3JtQ29udGV4dCgpOworCisgICAg Q0dQb2ludCB0cmFuc2Zvcm1lZFBvaW50ID0gQ0dQb2ludEFwcGx5QWZmaW5lVHJhbnNmb3JtKHBv c2l0aW9uLCBDR0NvbnRleHRHZXRDVE0oY29udGV4dCkpOworICAgIENHUERGQ29udGV4dEFkZERl c3RpbmF0aW9uQXRQb2ludChjb250ZXh0LCBuYW1lLmNyZWF0ZUNGU3RyaW5nKCkuZ2V0KCksIHRy YW5zZm9ybWVkUG9pbnQpOworfQorCiB9CiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJp bmcvUmVuZGVyT2JqZWN0LmNwcAppbmRleCAxNzc4NDFlNjY2ZmQzZWZlMmU5MTBhMGNlODNiYWQz MWFlYzk3MDRiLi43M2YxZWRlYjY2MmFhYzk0NzkwNGE0MDhjZWMzNjZiODc3MDQ5Yjk1IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcApAQCAtNjA3LDcgKzYwNywx OCBAQCB2b2lkIFJlbmRlck9iamVjdDo6YWRkUERGVVJMUmVjdChQYWludEluZm8mIHBhaW50SW5m bywgY29uc3QgTGF5b3V0UG9pbnQmIHBhaW50TwogICAgIGNvbnN0IEF0b21pY1N0cmluZyYgaHJl ZiA9IGRvd25jYXN0PEVsZW1lbnQ+KCpub2RlKS5nZXRBdHRyaWJ1dGUoaHJlZkF0dHIpOwogICAg IGlmIChocmVmLmlzTnVsbCgpKQogICAgICAgICByZXR1cm47Ci0gICAgcGFpbnRJbmZvLmNvbnRl eHQoKS5zZXRVUkxGb3JSZWN0KG5vZGUtPmRvY3VtZW50KCkuY29tcGxldGVVUkwoaHJlZiksIHNu YXBwZWRJbnRSZWN0KHVybFJlY3QpKTsKKyAgICAKKyAgICBEb2N1bWVudCYgZG9jdW1lbnQgPSBu b2RlLT5kb2N1bWVudCgpOworICAgIFVSTCB1cmwgPSBkb2N1bWVudC5jb21wbGV0ZVVSTChocmVm KTsKKyAgICBpZiAoIXVybC5pc1ZhbGlkKCkpCisgICAgICAgIHJldHVybjsKKyAgICBpZiAocGFp bnRJbmZvLmNvbnRleHQoKS5zdXBwb3J0c0ludGVybmFsTGlua3MoKSAmJiB1cmwuaGFzRnJhZ21l bnRJZGVudGlmaWVyKCkgJiYgZXF1YWxJZ25vcmluZ0ZyYWdtZW50SWRlbnRpZmllcih1cmwsIGRv Y3VtZW50LmJhc2VVUkwoKSkpIHsKKyAgICAgICAgU3RyaW5nIG5hbWUgPSB1cmwuZnJhZ21lbnRJ ZGVudGlmaWVyKCk7CisgICAgICAgIGlmIChkb2N1bWVudC5maW5kQW5jaG9yKG5hbWUpKQorICAg ICAgICAgICAgcGFpbnRJbmZvLmNvbnRleHQoKS5zZXREZXN0aW5hdGlvbkZvclJlY3QobmFtZSwg c25hcHBlZEludFJlY3QodXJsUmVjdCkpOworICAgICAgICByZXR1cm47CisgICAgfQorICAgIHBh aW50SW5mby5jb250ZXh0KCkuc2V0VVJMRm9yUmVjdCh1cmwsIHNuYXBwZWRJbnRSZWN0KHVybFJl Y3QpKTsKIH0KIAogI2lmIFBMQVRGT1JNKElPUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQy L1VJUHJvY2Vzcy9tYWMvV0tQcmludGluZ1ZpZXcuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vz cy9tYWMvV0tQcmludGluZ1ZpZXcuaAppbmRleCAzYjhiOGQyODk1ZDU0NGI3OWRlMzdmZGE4ZjM3 YTI0ZDlkY2I5MTk4Li5kYWNmNmE1NmRlNzliNjcyZDg4MzUzZjZkYjZiZWNkOTU5NzhkZTg2IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbWFjL1dLUHJpbnRpbmdWaWV3LmgK KysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL21hYy9XS1ByaW50aW5nVmlldy5oCkBAIC0z Myw2ICszMyw3IEBACiAjaW1wb3J0IDx3dGYvVmVjdG9yLmg+CiAKIEBjbGFzcyBXS1ByaW50aW5n Vmlld0RhdGE7CitAY2xhc3MgUERGRGVzdGluYXRpb247CiBAY2xhc3MgUERGRG9jdW1lbnQ7CiAK IG5hbWVzcGFjZSBXZWJLaXQgewpAQCAtNTIsNiArNTMsNyBAQCBjbGFzcyBXZWJGcmFtZVByb3h5 OwogCiAgICAgVmVjdG9yPHVpbnQ4X3Q+IF9wcmludGVkUGFnZXNEYXRhOwogICAgIFJldGFpblB0 cjxQREZEb2N1bWVudD4gX3ByaW50ZWRQYWdlc1BERkRvY3VtZW50OworICAgIFZlY3RvcjxWZWN0 b3I8UmV0YWluUHRyPFBERkRlc3RpbmF0aW9uPj4+IF9saW5rRGVzdGluYXRpb25zOwogCiAgICAg dWludDY0X3QgX2V4cGVjdGVkQ29tcHV0ZWRQYWdlc0NhbGxiYWNrOwogICAgIEhhc2hNYXA8dWlu dDY0X3QsIFdlYkNvcmU6OkludFJlY3Q+IF9leHBlY3RlZFByZXZpZXdDYWxsYmFja3M7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbWFjL1dLUHJpbnRpbmdWaWV3Lm1tIGIv U291cmNlL1dlYktpdDIvVUlQcm9jZXNzL21hYy9XS1ByaW50aW5nVmlldy5tbQppbmRleCAzYjEw Y2U3NWYxNWVjNmIzOWYxMWU2MGE0NjFiODZjZjc4NWFlNDRmLi40MWQ2M2ZjODJmYjMzZjVlMWNm Nzk3MWQzZGU0OGYxNTdiYzQ3MDAzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nl c3MvbWFjL1dLUHJpbnRpbmdWaWV3Lm1tCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9t YWMvV0tQcmludGluZ1ZpZXcubW0KQEAgLTQ1Niw2ICs0NTYsMTIgQEAgc3RhdGljIHZvaWQgcHJl cGFyZURhdGFGb3JQcmludGluZ09uU2Vjb25kYXJ5VGhyZWFkKFdLUHJpbnRpbmdWaWV3ICp2aWV3 KQogCiAgICAgQ0dBZmZpbmVUcmFuc2Zvcm0gdHJhbnNmb3JtID0gQ0dDb250ZXh0R2V0Q1RNKGNv bnRleHQpOwogCisgICAgZm9yIChjb25zdCBhdXRvJiBkZXN0aW5hdGlvbiA6IF9saW5rRGVzdGlu YXRpb25zW3BhZ2VdKSB7CisgICAgICAgIE5TU3RyaW5nICpkZXN0aW5hdGlvbk5hbWUgPSBbTlNT dHJpbmcgc3RyaW5nV2l0aEZvcm1hdDpAIiVsdS0lZi0lZiIsICh1bnNpZ25lZCBsb25nKVtwZGZE b2N1bWVudCBpbmRleEZvclBhZ2U6W2Rlc3RpbmF0aW9uIHBhZ2VdXSwgW2Rlc3RpbmF0aW9uIHBv aW50XS54LCBbZGVzdGluYXRpb24gcG9pbnRdLnldOworICAgICAgICBDR1BvaW50IGRlc3RpbmF0 aW9uUG9pbnQgPSBDR1BvaW50QXBwbHlBZmZpbmVUcmFuc2Zvcm0oTlNQb2ludFRvQ0dQb2ludChb ZGVzdGluYXRpb24gcG9pbnRdKSwgdHJhbnNmb3JtKTsKKyAgICAgICAgQ0dQREZDb250ZXh0QWRk RGVzdGluYXRpb25BdFBvaW50KGNvbnRleHQsIChDRlN0cmluZ1JlZilkZXN0aW5hdGlvbk5hbWUs IGRlc3RpbmF0aW9uUG9pbnQpOworICAgIH0KKwogICAgIGZvciAoUERGQW5ub3RhdGlvbiAqYW5u b3RhdGlvbiBpbiBbcGRmUGFnZSBhbm5vdGF0aW9uc10pIHsKICAgICAgICAgaWYgKCFbYW5ub3Rh dGlvbiBpc0tpbmRPZkNsYXNzOnBkZkFubm90YXRpb25MaW5rQ2xhc3MoKV0pCiAgICAgICAgICAg ICBjb250aW51ZTsKQEAgLTQ2NSw4ICs0NzEsMjAgQEAgc3RhdGljIHZvaWQgcHJlcGFyZURhdGFG b3JQcmludGluZ09uU2Vjb25kYXJ5VGhyZWFkKFdLUHJpbnRpbmdWaWV3ICp2aWV3KQogICAgICAg ICBQREZBbm5vdGF0aW9uTGluayAqbGlua0Fubm90YXRpb24gPSAoUERGQW5ub3RhdGlvbkxpbmsg Kilhbm5vdGF0aW9uOwogI3ByYWdtYSBjbGFuZyBkaWFnbm9zdGljIHBvcAogICAgICAgICBOU1VS TCAqdXJsID0gW2xpbmtBbm5vdGF0aW9uIFVSTF07Ci0gICAgICAgIGlmICghdXJsKQorCisgICAg ICAgIGlmICghdXJsKSB7CisgICAgICAgICAgICBQREZEZXN0aW5hdGlvbiAqZGVzdGluYXRpb24g PSBbbGlua0Fubm90YXRpb24gZGVzdGluYXRpb25dOworICAgICAgICAgICAgaWYgKCFkZXN0aW5h dGlvbikKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKworICAgICAgICAgICAgQ0dSZWN0IHVy bFJlY3QgPSBOU1JlY3RUb0NHUmVjdChbbGlua0Fubm90YXRpb24gYm91bmRzXSk7CisgICAgICAg ICAgICBDR1JlY3QgdHJhbnNmb3JtZWRSZWN0ID0gQ0dSZWN0QXBwbHlBZmZpbmVUcmFuc2Zvcm0o dXJsUmVjdCwgdHJhbnNmb3JtKTsKKworICAgICAgICAgICAgTlNTdHJpbmcgKmRlc3RpbmF0aW9u TmFtZSA9IFtOU1N0cmluZyBzdHJpbmdXaXRoRm9ybWF0OkAiJWx1LSVmLSVmIiwgKHVuc2lnbmVk IGxvbmcpW3BkZkRvY3VtZW50IGluZGV4Rm9yUGFnZTpkZXN0aW5hdGlvbi5wYWdlXSwgZGVzdGlu YXRpb24ucG9pbnQueCwgZGVzdGluYXRpb24ucG9pbnQueV07CisgICAgICAgICAgICBDR1BERkNv bnRleHRTZXREZXN0aW5hdGlvbkZvclJlY3QoY29udGV4dCwgKENGU3RyaW5nUmVmKWRlc3RpbmF0 aW9uTmFtZSwgdHJhbnNmb3JtZWRSZWN0KTsKKwogICAgICAgICAgICAgY29udGludWU7CisgICAg ICAgIH0KIAogICAgICAgICBDR1JlY3QgdXJsUmVjdCA9IE5TUmVjdFRvQ0dSZWN0KFtsaW5rQW5u b3RhdGlvbiBib3VuZHNdKTsKICAgICAgICAgQ0dSZWN0IHRyYW5zZm9ybWVkUmVjdCA9IENHUmVj dEFwcGx5QWZmaW5lVHJhbnNmb3JtKHVybFJlY3QsIHRyYW5zZm9ybSk7CkBAIC01NDksNiArNTY3 LDMxIEBAIHN0YXRpYyB2b2lkIHByZXBhcmVEYXRhRm9yUHJpbnRpbmdPblNlY29uZGFyeVRocmVh ZChXS1ByaW50aW5nVmlldyAqdmlldykKICAgICBpZiAoIV9wcmludGVkUGFnZXNQREZEb2N1bWVu dCkgewogICAgICAgICBSZXRhaW5QdHI8TlNEYXRhPiBwZGZEYXRhID0gYWRvcHROUyhbW05TRGF0 YSBhbGxvY10gaW5pdFdpdGhCeXRlczpfcHJpbnRlZFBhZ2VzRGF0YS5kYXRhKCkgbGVuZ3RoOl9w cmludGVkUGFnZXNEYXRhLnNpemUoKV0pOwogICAgICAgICBfcHJpbnRlZFBhZ2VzUERGRG9jdW1l bnQgPSBhZG9wdE5TKFtbcGRmRG9jdW1lbnRDbGFzcygpIGFsbG9jXSBpbml0V2l0aERhdGE6cGRm RGF0YS5nZXQoKV0pOworCisgICAgICAgIHVuc2lnbmVkIHBhZ2VDb3VudCA9IFtfcHJpbnRlZFBh Z2VzUERGRG9jdW1lbnQgcGFnZUNvdW50XTsKKyAgICAgICAgVmVjdG9yPFZlY3RvcjxSZXRhaW5Q dHI8UERGRGVzdGluYXRpb24+Pj4gbGlua0Rlc3RpbmF0aW9ucyhwYWdlQ291bnQpOworICAgICAg ICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgcGFnZUNvdW50OyBpKyspIHsKKyAgICAgICAgICAg IFBERlBhZ2UgKnBhZ2UgPSBbX3ByaW50ZWRQYWdlc1BERkRvY3VtZW50IHBhZ2VBdEluZGV4Omld OworICAgICAgICAgICAgZm9yIChQREZBbm5vdGF0aW9uICphbm5vdGF0aW9uIGluIHBhZ2UuYW5u b3RhdGlvbnMpIHsKKyAgICAgICAgICAgICAgICBpZiAoIVthbm5vdGF0aW9uIGlzS2luZE9mQ2xh c3M6cGRmQW5ub3RhdGlvbkxpbmtDbGFzcygpXSkKKyAgICAgICAgICAgICAgICAgICAgY29udGlu dWU7CisKKyNwcmFnbWEgY2xhbmcgZGlhZ25vc3RpYyBwdXNoCisjcHJhZ21hIGNsYW5nIGRpYWdu b3N0aWMgaWdub3JlZCAiLVdkZXByZWNhdGVkLWRlY2xhcmF0aW9ucyIKKyAgICAgICAgICAgICAg ICBQREZBbm5vdGF0aW9uTGluayAqbGlua0Fubm90YXRpb24gPSAoUERGQW5ub3RhdGlvbkxpbmsg Kilhbm5vdGF0aW9uOworI3ByYWdtYSBjbGFuZyBkaWFnbm9zdGljIHBvcAorICAgICAgICAgICAg ICAgIGlmIChsaW5rQW5ub3RhdGlvbi5VUkwpCisgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVl OworCisgICAgICAgICAgICAgICAgUERGRGVzdGluYXRpb24gKmRlc3RpbmF0aW9uID0gbGlua0Fu bm90YXRpb24uZGVzdGluYXRpb247CisgICAgICAgICAgICAgICAgaWYgKCFkZXN0aW5hdGlvbikK KyAgICAgICAgICAgICAgICAgICAgY29udGludWU7CisKKyAgICAgICAgICAgICAgICBsaW5rRGVz dGluYXRpb25zW1tfcHJpbnRlZFBhZ2VzUERGRG9jdW1lbnQgaW5kZXhGb3JQYWdlOmRlc3RpbmF0 aW9uLnBhZ2VdXS5hcHBlbmQoZGVzdGluYXRpb24pOworICAgICAgICAgICAgfQorICAgICAgICB9 CisKKyAgICAgICAgX2xpbmtEZXN0aW5hdGlvbnMgPSBsaW5rRGVzdGluYXRpb25zOwogICAgIH0K IAogICAgIHVuc2lnbmVkIHByaW50ZWRQYWdlTnVtYmVyID0gW3NlbGYgX3BhZ2VGb3JSZWN0Om5z UmVjdF0gLSBbc2VsZiBfZmlyc3RQcmludGVkUGFnZU51bWJlcl07Cg== 293729 2016-11-02 18:24:13 -0700 2016-11-02 18:26:01 -0700 Patch bug-112081-20161102182013.patch text/plain 16864 thorton U3VidmVyc2lvbiBSZXZpc2lvbjogMjA4Mjk0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjE3YTU0OWFjMjVlZWI3 OGJhMzhkNmY5YzBhNTk3ZDVhN2JkMTQ1Ni4uYzk1YjAyNzU5YTI5YWExNWQxOWVlZjM4NDk0NDU3 NTZmZGMxZTM4NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM5IEBACisyMDE2LTExLTAyICBUaW0g SG9ydG9uICA8dGltb3RoeV9ob3J0b25AYXBwbGUuY29tPgorCisgICAgICAgIFByaW50aW5nIHRv IFBERiBzaG91bGQgcHJvZHVjZSBpbnRlcm5hbCBsaW5rcyB3aGVuIEhUTUwgaGFzIGludGVybmFs IGxpbmtzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x MTIwODEKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzgyMzk3NDA+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisgICAgICAgIFBhdGNoIG9yaWdpbmFsbHkgYnkgRGF2aWQg TGF0dGltb3JlLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cywgYXMgaXQncyB1bmNsZWFyIGhvdyB0 byB0ZXN0IFBERiBvdXRwdXQuCisKKyAgICAgICAgKiBwYWdlL1ByaW50Q29udGV4dC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpQcmludENvbnRleHQ6OlByaW50Q29udGV4dCk6CisgICAgICAgIChX ZWJDb3JlOjpQcmludENvbnRleHQ6OnNwb29sUGFnZSk6CisgICAgICAgIChXZWJDb3JlOjpQcmlu dENvbnRleHQ6OnNwb29sUmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpQcmludENvbnRleHQ6OmVu ZCk6CisgICAgICAgIChXZWJDb3JlOjpQcmludENvbnRleHQ6OmNvbGxlY3RMaW5rZWREZXN0aW5h dGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6UHJpbnRDb250ZXh0OjpvdXRwdXRMaW5rZWREZXN0 aW5hdGlvbnMpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjphZGRQREZVUkxSZWN0KToKKyAgICAgICAgUGx1bWIg aW50ZXJuYWwgbGlua3MgKGZyYWdtZW50IGxpbmtzKSB0aHJvdWdoIHRvIEdyYXBoaWNzQ29udGV4 dCwgdXNpbmcKKyAgICAgICAgdGhlIGZyYWdtZW50IG5hbWUgZnJvbSB0aGUgcGFnZS4KKworICAg ICAgICAqIHBhZ2UvUHJpbnRDb250ZXh0Lmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mv R3JhcGhpY3NDb250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6 c3VwcG9ydHNJbnRlcm5hbExpbmtzKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4 dDo6c2V0RGVzdGluYXRpb25Gb3JSZWN0KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29u dGV4dDo6YWRkRGVzdGluYXRpb25BdFBvaW50KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGlj cy9HcmFwaGljc0NvbnRleHQuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jZy9HcmFw aGljc0NvbnRleHRDRy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6OnN1 cHBvcnRzSW50ZXJuYWxMaW5rcyk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6 OnNldERlc3RpbmF0aW9uRm9yUmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRl eHQ6OmFkZERlc3RpbmF0aW9uQXRQb2ludCk6CisgICAgICAgIFBsdW1iIGludGVybmFsIGxpbmtz IHRocm91Z2ggdG8gdGhlIENHQ29udGV4dC4gQXBwbHkgdGhlIENUTSwgYmVjYXVzZQorICAgICAg ICB0aGVzZSBmdW5jdGlvbnMgZXhwZWN0IHBvc2l0aW9ucyBpbiBnbG9iYWwgY29vcmRpbmF0ZXMu CisKIDIwMTYtMTEtMDEgIERlYW4gSmFja3NvbiAgPGRpbm9AYXBwbGUuY29tPgogCiAgICAgICAg IEZpbHRlciBmdW5jdGlvbnMgZ3JheXNjYWxlL2ludmVydC9vcGFjaXR5L3NlcGlhIHNob3VsZCBj bGFtcCB2YWx1ZXMgb3ZlciAxMDAlLCBub3QgZmFpbApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dDIvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IDA3ZTc2Y2I5ZjRl OTU5ZjZlMWFhNTAxNTJlODBmOWM3NDAxM2Y5NmQuLjkxZGFiYjgxYjY4YjI0OWRlYmEzM2Q4Nzk3 MmEyOGExNGUzMGU1MTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAxNi0xMS0wMiAg VGltIEhvcnRvbiAgPHRpbW90aHlfaG9ydG9uQGFwcGxlLmNvbT4KKworICAgICAgICBQcmludGlu ZyB0byBQREYgc2hvdWxkIHByb2R1Y2UgaW50ZXJuYWwgbGlua3Mgd2hlbiBIVE1MIGhhcyBpbnRl cm5hbCBsaW5rcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTEyMDgxCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS84MjM5NzQwPgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogVUlQcm9jZXNzL21hYy9XS1By aW50aW5nVmlldy5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9tYWMvV0tQcmludGluZ1ZpZXcubW06 CisgICAgICAgIChsaW5rRGVzdGluYXRpb25OYW1lKToKKyAgICAgICAgKC1bV0tQcmludGluZ1Zp ZXcgX2RyYXdQREZEb2N1bWVudDpwYWdlOmF0UG9pbnQ6XSk6CisgICAgICAgIFByb3BhZ2F0ZSBs aW5rLXRvLWRlc3RpbmF0aW9uIGFubm90YXRpb25zIChhbmQgZWFjaCBwYWdlJ3MgZGVzdGluYXRp b25zKQorICAgICAgICBpbnRvIHRoZSBwcmludGVkIFBERi4KKyAgICAgICAgR2VuZXJhdGUgYSB1 bmlxdWUgZGVzdGluYXRpb24gbmFtZSBiYXNlZCBvbiB0aGUgcGFnZSBhbmQgcG9zaXRpb24sIGJl Y2F1c2UKKyAgICAgICAgd2UgaGF2ZSBsb3N0IHRoZSBmcmFnbWVudCBuYW1lIGluZm9ybWF0aW9u LgorCisgICAgICAgICgtW1dLUHJpbnRpbmdWaWV3IGRyYXdSZWN0Ol0pOgorICAgICAgICBDb21w dXRlIGFsbCBvZiB0aGUgZGVzdGluYXRpb25zIGZvciBldmVyeSBwYWdlLCBzbyB0aGF0IHdlIGNh biBhZGQgdGhlbQorICAgICAgICB0byB0aGUgY29udGV4dCBhcyB3ZSBwYWludCB0aGUgcGFnZXMg KHdlIG5lZWQgdGhlIHBhZ2UgQ1RNIGluIG9yZGVyIHRvIGFkZCB0aGVtKS4KKwogMjAxNi0xMS0w MiAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CiAKICAgICAgICAg TmV0d29ya1Nlc3Npb246IE5ldHdvcmsgcHJvY2VzcyBjcmFzaCB3aGVuIGNvbnZlcnRpbmcgbWFp biByZXNvdXJjZSB0byBkb3dubG9hZApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9Q cmludENvbnRleHQuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QcmludENvbnRleHQuY3BwCmlu ZGV4IDU0ZGVhMzZmOTJhZWEwZmQzZGM1MTVhZTk5ZDAyZWQyZWFlM2Y0MjkuLmNkZDE0ZDE1NjFm MmQxYzExMjdlYTk0NjEzMmEzNmQ3OTIzMTc5Y2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvUHJpbnRDb250ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1ByaW50Q29u dGV4dC5jcHAKQEAgLTI0LDYgKzI0LDggQEAKICNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIK ICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgorI2luY2x1ZGUgIkhU TUxOYW1lcy5oIgorI2luY2x1ZGUgIk5vZGVUcmF2ZXJzYWwuaCIKICNpbmNsdWRlICJSZW5kZXJW aWV3LmgiCiAjaW5jbHVkZSAiU3R5bGVJbmhlcml0ZWREYXRhLmgiCiAjaW5jbHVkZSAiU3R5bGVS ZXNvbHZlci5oIgpAQCAtMzQsNyArMzYsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIFByaW50 Q29udGV4dDo6UHJpbnRDb250ZXh0KEZyYW1lKiBmcmFtZSkKICAgICA6IG1fZnJhbWUoZnJhbWUp Ci0gICAgLCBtX2lzUHJpbnRpbmcoZmFsc2UpCiB7CiB9CiAKQEAgLTE5MCw2ICsxOTEsNyBAQCB2 b2lkIFByaW50Q29udGV4dDo6c3Bvb2xQYWdlKEdyYXBoaWNzQ29udGV4dCYgY3R4LCBpbnQgcGFn ZU51bWJlciwgZmxvYXQgd2lkdGgpCiAgICAgY3R4LnRyYW5zbGF0ZSgtcGFnZVJlY3QueCgpLCAt cGFnZVJlY3QueSgpKTsKICAgICBjdHguY2xpcChwYWdlUmVjdCk7CiAgICAgbV9mcmFtZS0+dmll dygpLT5wYWludENvbnRlbnRzKGN0eCwgcGFnZVJlY3QpOworICAgIG91dHB1dExpbmtlZERlc3Rp bmF0aW9ucyhjdHgsIG1fZnJhbWUtPmRvY3VtZW50KCksIHBhZ2VSZWN0KTsKICAgICBjdHgucmVz dG9yZSgpOwogfQogCkBAIC0yMDAsNiArMjAyLDcgQEAgdm9pZCBQcmludENvbnRleHQ6OnNwb29s UmVjdChHcmFwaGljc0NvbnRleHQmIGN0eCwgY29uc3QgSW50UmVjdCYgcmVjdCkKICAgICBjdHgu dHJhbnNsYXRlKC1yZWN0LngoKSwgLXJlY3QueSgpKTsKICAgICBjdHguY2xpcChyZWN0KTsKICAg ICBtX2ZyYW1lLT52aWV3KCktPnBhaW50Q29udGVudHMoY3R4LCByZWN0KTsKKyAgICBvdXRwdXRM aW5rZWREZXN0aW5hdGlvbnMoY3R4LCBtX2ZyYW1lLT5kb2N1bWVudCgpLCByZWN0KTsKICAgICBj dHgucmVzdG9yZSgpOwogfQogCkBAIC0yMDgsNiArMjExLDcgQEAgdm9pZCBQcmludENvbnRleHQ6 OmVuZCgpCiAgICAgQVNTRVJUKG1faXNQcmludGluZyk7CiAgICAgbV9pc1ByaW50aW5nID0gZmFs c2U7CiAgICAgbV9mcmFtZS0+c2V0UHJpbnRpbmcoZmFsc2UsIEZsb2F0U2l6ZSgpLCBGbG9hdFNp emUoKSwgMCwgQWRqdXN0Vmlld1NpemUpOworICAgIG1fbGlua2VkRGVzdGluYXRpb25zID0gTnVs bG9wdDsKIH0KIAogc3RhdGljIGlubGluZSBSZW5kZXJCb3hNb2RlbE9iamVjdCogZW5jbG9zaW5n Qm94TW9kZWxPYmplY3QoUmVuZGVyRWxlbWVudCogcmVuZGVyZXIpCkBAIC0yNDYsNiArMjUwLDU0 IEBAIGludCBQcmludENvbnRleHQ6OnBhZ2VOdW1iZXJGb3JFbGVtZW50KEVsZW1lbnQqIGVsZW1l bnQsIGNvbnN0IEZsb2F0U2l6ZSYgcGFnZVNpCiAgICAgcmV0dXJuIC0xOwogfQogCit2b2lkIFBy aW50Q29udGV4dDo6Y29sbGVjdExpbmtlZERlc3RpbmF0aW9ucyhOb2RlKiBub2RlKQoreworICAg IG1fbGlua2VkRGVzdGluYXRpb25zID0geyB9OworCisgICAgZm9yIChOb2RlKiBjaGlsZCA9IG5v ZGUtPmZpcnN0Q2hpbGQoKTsgY2hpbGQ7IGNoaWxkID0gTm9kZVRyYXZlcnNhbDo6bmV4dCgqY2hp bGQpKQorICAgICAgICBjb2xsZWN0TGlua2VkRGVzdGluYXRpb25zKGNoaWxkKTsKKworICAgIGlm ICghbm9kZS0+aXNMaW5rKCkpCisgICAgICAgIHJldHVybjsKKworICAgIGlmICghaXM8RWxlbWVu dD4obm9kZSkpCisgICAgICAgIHJldHVybjsKKworICAgIGNvbnN0IEF0b21pY1N0cmluZyYgaHJl ZiA9IGRvd25jYXN0PEVsZW1lbnQ+KG5vZGUpLT5nZXRBdHRyaWJ1dGUoSFRNTE5hbWVzOjpocmVm QXR0cik7CisgICAgaWYgKGhyZWYuaXNOdWxsKCkpCisgICAgICAgIHJldHVybjsKKworICAgIERv Y3VtZW50JiBkb2N1bWVudCA9IG5vZGUtPmRvY3VtZW50KCk7CisgICAgVVJMIHVybCA9IGRvY3Vt ZW50LmNvbXBsZXRlVVJMKGhyZWYpOworICAgIGlmICghdXJsLmlzVmFsaWQoKSkKKyAgICAgICAg cmV0dXJuOworCisgICAgaWYgKHVybC5oYXNGcmFnbWVudElkZW50aWZpZXIoKSAmJiBlcXVhbEln bm9yaW5nRnJhZ21lbnRJZGVudGlmaWVyKHVybCwgZG9jdW1lbnQuYmFzZVVSTCgpKSkgeworICAg ICAgICBTdHJpbmcgbmFtZSA9IHVybC5mcmFnbWVudElkZW50aWZpZXIoKTsKKyAgICAgICAgaWYg KEVsZW1lbnQqIGVsZW1lbnQgPSBkb2N1bWVudC5maW5kQW5jaG9yKG5hbWUpKQorICAgICAgICAg ICAgbV9saW5rZWREZXN0aW5hdGlvbnMtPnNldChuYW1lLCBlbGVtZW50KTsKKyAgICB9Cit9CisK K3ZvaWQgUHJpbnRDb250ZXh0OjpvdXRwdXRMaW5rZWREZXN0aW5hdGlvbnMoR3JhcGhpY3NDb250 ZXh0JiBncmFwaGljc0NvbnRleHQsIE5vZGUqIG5vZGUsIGNvbnN0IEludFJlY3QmIHBhZ2VSZWN0 KQoreworICAgIGlmICghZ3JhcGhpY3NDb250ZXh0LnN1cHBvcnRzSW50ZXJuYWxMaW5rcygpKQor ICAgICAgICByZXR1cm47CisKKyAgICBpZiAoIW1fbGlua2VkRGVzdGluYXRpb25zKQorICAgICAg ICBjb2xsZWN0TGlua2VkRGVzdGluYXRpb25zKG5vZGUpOworCisgICAgZm9yIChjb25zdCBhdXRv JiBpdCA6ICptX2xpbmtlZERlc3RpbmF0aW9ucykgeworICAgICAgICBJbnRSZWN0IGJvdW5kaW5n Qm94ID0gaXQudmFsdWUtPnJlbmRlcmVyKCktPmFic29sdXRlQm91bmRpbmdCb3hSZWN0KCk7Cisg ICAgICAgIGlmICghcGFnZVJlY3QuaW50ZXJzZWN0cyhib3VuZGluZ0JveCkpCisgICAgICAgICAg ICBjb250aW51ZTsKKworICAgICAgICBJbnRQb2ludCBwb2ludCA9IGJvdW5kaW5nQm94Lm1pblhN aW5ZQ29ybmVyKCk7CisgICAgICAgIHBvaW50LmNsYW1wTmVnYXRpdmVUb1plcm8oKTsKKyAgICAg ICAgZ3JhcGhpY3NDb250ZXh0LmFkZERlc3RpbmF0aW9uQXRQb2ludChpdC5rZXksIHBvaW50KTsK KyAgICB9Cit9CisKIFN0cmluZyBQcmludENvbnRleHQ6OnBhZ2VQcm9wZXJ0eShGcmFtZSogZnJh bWUsIGNvbnN0IGNoYXIqIHByb3BlcnR5TmFtZSwgaW50IHBhZ2VOdW1iZXIpCiB7CiAgICAgRG9j dW1lbnQqIGRvY3VtZW50ID0gZnJhbWUtPmRvY3VtZW50KCk7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL1ByaW50Q29udGV4dC5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QcmludENv bnRleHQuaAppbmRleCA5ZmM2NmQzZGE5MTBlMDUwODlmNTU3YWUzNmY5MTIzMDk1NzRiZDBhLi5h YzBkMzdiNzQ5ZDNmNDY3Njg4NWJhOTM4ODIyODQ1YTdhOWI4MDdhIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL1ByaW50Q29udGV4dC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv UHJpbnRDb250ZXh0LmgKQEAgLTIxLDcgKzIxLDkgQEAKICNwcmFnbWEgb25jZQogCiAjaW5jbHVk ZSA8d3RmL0ZvcndhcmQuaD4KKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogI2luY2x1ZGUgPHd0 Zi9WZWN0b3IuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KIAogbmFtZXNwYWNl IFdlYkNvcmUgewogCkBAIC0zMSw2ICszMyw3IEBAIGNsYXNzIEZsb2F0UmVjdDsKIGNsYXNzIEZs b2F0U2l6ZTsKIGNsYXNzIEdyYXBoaWNzQ29udGV4dDsKIGNsYXNzIEludFJlY3Q7CitjbGFzcyBO b2RlOwogCiBjbGFzcyBQcmludENvbnRleHQgewogcHVibGljOgpAQCAtOTgsOSArMTAxLDEzIEBA IHByb3RlY3RlZDoKIHByaXZhdGU6CiAgICAgdm9pZCBjb21wdXRlUGFnZVJlY3RzV2l0aFBhZ2VT aXplSW50ZXJuYWwoY29uc3QgRmxvYXRTaXplJiBwYWdlU2l6ZUluUGl4ZWxzLCBib29sIGFsbG93 SG9yaXpvbnRhbFRpbGluZyk7CiAgICAgYm9vbCBiZWdpbkFuZENvbXB1dGVQYWdlUmVjdHNXaXRo UGFnZVNpemUoRnJhbWUmLCBjb25zdCBGbG9hdFNpemUmIHBhZ2VTaXplSW5QaXhlbHMpOworICAg IHZvaWQgY29sbGVjdExpbmtlZERlc3RpbmF0aW9ucyhOb2RlKik7CisgICAgdm9pZCBvdXRwdXRM aW5rZWREZXN0aW5hdGlvbnMoR3JhcGhpY3NDb250ZXh0JiwgTm9kZSosIGNvbnN0IEludFJlY3Qm IHBhZ2VSZWN0KTsKIAogICAgIC8vIFVzZWQgdG8gcHJldmVudCBtaXN1c2VzIG9mIGJlZ2luKCkg YW5kIGVuZCgpIChlLmcuLCBjYWxsIGVuZCB3aXRob3V0IGJlZ2luKS4KLSAgICBib29sIG1faXNQ cmludGluZzsKKyAgICBib29sIG1faXNQcmludGluZyB7IGZhbHNlIH07CisKKyAgICBPcHRpb25h bDxIYXNoTWFwPFN0cmluZywgRWxlbWVudCo+PiBtX2xpbmtlZERlc3RpbmF0aW9uczsKIH07CiAK IH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuY3BwCmluZGV4IDg4YjdmNWI5MTVlNDdjNTgxYTcy OGQ2NWVkMzMwYjE3ZmU1ODFkMzkuLmJjNWQyOWQwYzQwZDJkMGEyN2UxOWFmMjBmMmVmNTU2MjFl YTA5NWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBo aWNzQ29udGV4dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3Jh cGhpY3NDb250ZXh0LmNwcApAQCAtMTE3Nyw0ICsxMTc3LDE5IEBAIFZlY3RvcjxGbG9hdFBvaW50 PiBHcmFwaGljc0NvbnRleHQ6OmNlbnRlckxpbmVBbmRDdXRPZmZDb3JuZXJzKGJvb2wgaXNWZXJ0 aWNhbExpCiAgICAgcmV0dXJuIHsgcG9pbnQxLCBwb2ludDIgfTsKIH0KIAorI2lmICFVU0UoQ0cp Citib29sIEdyYXBoaWNzQ29udGV4dDo6c3VwcG9ydHNJbnRlcm5hbExpbmtzKCkKK3sKKyAgICBy ZXR1cm4gZmFsc2U7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzZXREZXN0aW5hdGlvbkZv clJlY3QoY29uc3QgU3RyaW5nJiwgY29uc3QgSW50UmVjdCYpCit7Cit9CisKK3ZvaWQgR3JhcGhp Y3NDb250ZXh0OjphZGREZXN0aW5hdGlvbkF0UG9pbnQoY29uc3QgU3RyaW5nJiwgY29uc3QgSW50 UG9pbnQmKQoreworfQorI2VuZGlmCisKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmgKaW5kZXggNTY5N2MwOWY3NmVkNjNhMGM5Zjg5 N2U5MDE1NTE5ZDUwNzgyYzQ0MS4uNDUyYTdlOTY3OWI0ZGE1OGE1NjllNjJhNjFkZTkyNzk0NmY5 MjhhMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhp Y3NDb250ZXh0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhp Y3NDb250ZXh0LmgKQEAgLTQ3MCw2ICs0NzAsOSBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHNldFVS TEZvclJlY3QoY29uc3QgVVJMJiwgY29uc3QgSW50UmVjdCYpOwogCisgICAgdm9pZCBzZXREZXN0 aW5hdGlvbkZvclJlY3QoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJbnRSZWN0Jik7CisgICAg dm9pZCBhZGREZXN0aW5hdGlvbkF0UG9pbnQoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJbnRQ b2ludCYpOworCiAgICAgdm9pZCBjb25jYXRDVE0oY29uc3QgQWZmaW5lVHJhbnNmb3JtJik7CiAg ICAgdm9pZCBzZXRDVE0oY29uc3QgQWZmaW5lVHJhbnNmb3JtJik7CiAKQEAgLTU3Niw2ICs1Nzks OCBAQCBwdWJsaWM6CiAKICAgICBzdGF0aWMgdm9pZCBhZGp1c3RMaW5lVG9QaXhlbEJvdW5kYXJp ZXMoRmxvYXRQb2ludCYgcDEsIEZsb2F0UG9pbnQmIHAyLCBmbG9hdCBzdHJva2VXaWR0aCwgU3Ry b2tlU3R5bGUpOwogCisgICAgYm9vbCBzdXBwb3J0c0ludGVybmFsTGlua3MoKTsKKwogcHJpdmF0 ZToKICAgICB2b2lkIHBsYXRmb3JtSW5pdChQbGF0Zm9ybUdyYXBoaWNzQ29udGV4dCopOwogICAg IHZvaWQgcGxhdGZvcm1EZXN0cm95KCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jZy9HcmFwaGljc0NvbnRleHRDRy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jZy9HcmFwaGljc0NvbnRleHRDRy5jcHAKaW5kZXggZTA2ZjQ1ZDQ5 MmM1ODhhYmMyZWI5ZjVhZmNkMjQwZDM4ZWVjNTUyOC4uM2Q1NzU5YmU1OThkMWI0OWYzMmJjNWM2 OTQ0MzBjMjdkNDE2YzhkOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2cvR3JhcGhpY3NDb250ZXh0Q0cuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2NnL0dyYXBoaWNzQ29udGV4dENHLmNwcApAQCAtMTkwMiw2ICsxOTAyLDM2 IEBAIHZvaWQgR3JhcGhpY3NDb250ZXh0OjpwbGF0Zm9ybVN0cm9rZUVsbGlwc2UoY29uc3QgRmxv YXRSZWN0JiBlbGxpcHNlKQogICAgIENHQ29udGV4dFN0cm9rZUVsbGlwc2VJblJlY3QoY29udGV4 dCwgZWxsaXBzZSk7CiB9CiAKK2Jvb2wgR3JhcGhpY3NDb250ZXh0OjpzdXBwb3J0c0ludGVybmFs TGlua3MoKQoreworICAgIHJldHVybiB0cnVlOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6 c2V0RGVzdGluYXRpb25Gb3JSZWN0KGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgSW50UmVjdCYg ZGVzdFJlY3QpCit7CisgICAgaWYgKHBhaW50aW5nRGlzYWJsZWQoKSkKKyAgICAgICAgcmV0dXJu OworCisgICAgQ0dDb250ZXh0UmVmIGNvbnRleHQgPSBwbGF0Zm9ybUNvbnRleHQoKTsKKworICAg IEludFJlY3QgcmVjdCA9IGRlc3RSZWN0OworICAgIHJlY3QuaW50ZXJzZWN0KGVuY2xvc2luZ0lu dFJlY3QoQ0dDb250ZXh0R2V0Q2xpcEJvdW5kaW5nQm94KGNvbnRleHQpKSk7CisKKyAgICBDR1Jl Y3QgdHJhbnNmb3JtZWRSZWN0ID0gQ0dSZWN0QXBwbHlBZmZpbmVUcmFuc2Zvcm0ocmVjdCwgQ0dD b250ZXh0R2V0Q1RNKGNvbnRleHQpKTsKKyAgICBDR1BERkNvbnRleHRTZXREZXN0aW5hdGlvbkZv clJlY3QoY29udGV4dCwgbmFtZS5jcmVhdGVDRlN0cmluZygpLmdldCgpLCB0cmFuc2Zvcm1lZFJl Y3QpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6YWRkRGVzdGluYXRpb25BdFBvaW50KGNv bnN0IFN0cmluZyYgbmFtZSwgY29uc3QgSW50UG9pbnQmIHBvc2l0aW9uKQoreworICAgIGlmIChw YWludGluZ0Rpc2FibGVkKCkpCisgICAgICAgIHJldHVybjsKKworICAgIENHQ29udGV4dFJlZiBj b250ZXh0ID0gcGxhdGZvcm1Db250ZXh0KCk7CisKKyAgICBDR1BvaW50IHRyYW5zZm9ybWVkUG9p bnQgPSBDR1BvaW50QXBwbHlBZmZpbmVUcmFuc2Zvcm0ocG9zaXRpb24sIENHQ29udGV4dEdldENU TShjb250ZXh0KSk7CisgICAgQ0dQREZDb250ZXh0QWRkRGVzdGluYXRpb25BdFBvaW50KGNvbnRl eHQsIG5hbWUuY3JlYXRlQ0ZTdHJpbmcoKS5nZXQoKSwgdHJhbnNmb3JtZWRQb2ludCk7Cit9CisK IH0KIAogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy T2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCmlu ZGV4IDE3Nzg0MWU2NjZmZDNlZmUyZTkxMGEwY2U4M2JhZDMxYWVjOTcwNGIuLjU4NmQyMzM2Zjk4 ZTUyMjBmMjhkMzc3MGMyMDAyMjFjYmFlZDEyMTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJPYmplY3QuY3BwCkBAIC02MDcsNyArNjA3LDIwIEBAIHZvaWQgUmVuZGVyT2JqZWN0 OjphZGRQREZVUkxSZWN0KFBhaW50SW5mbyYgcGFpbnRJbmZvLCBjb25zdCBMYXlvdXRQb2ludCYg cGFpbnRPCiAgICAgY29uc3QgQXRvbWljU3RyaW5nJiBocmVmID0gZG93bmNhc3Q8RWxlbWVudD4o Km5vZGUpLmdldEF0dHJpYnV0ZShocmVmQXR0cik7CiAgICAgaWYgKGhyZWYuaXNOdWxsKCkpCiAg ICAgICAgIHJldHVybjsKLSAgICBwYWludEluZm8uY29udGV4dCgpLnNldFVSTEZvclJlY3Qobm9k ZS0+ZG9jdW1lbnQoKS5jb21wbGV0ZVVSTChocmVmKSwgc25hcHBlZEludFJlY3QodXJsUmVjdCkp OworICAgIAorICAgIERvY3VtZW50JiBkb2N1bWVudCA9IG5vZGUtPmRvY3VtZW50KCk7CisgICAg VVJMIHVybCA9IGRvY3VtZW50LmNvbXBsZXRlVVJMKGhyZWYpOworICAgIGlmICghdXJsLmlzVmFs aWQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKHBhaW50SW5mby5jb250ZXh0KCkuc3Vw cG9ydHNJbnRlcm5hbExpbmtzKCkgJiYgdXJsLmhhc0ZyYWdtZW50SWRlbnRpZmllcigpICYmIGVx dWFsSWdub3JpbmdGcmFnbWVudElkZW50aWZpZXIodXJsLCBkb2N1bWVudC5iYXNlVVJMKCkpKSB7 CisgICAgICAgIFN0cmluZyBuYW1lID0gdXJsLmZyYWdtZW50SWRlbnRpZmllcigpOworICAgICAg ICBpZiAoZG9jdW1lbnQuZmluZEFuY2hvcihuYW1lKSkKKyAgICAgICAgICAgIHBhaW50SW5mby5j b250ZXh0KCkuc2V0RGVzdGluYXRpb25Gb3JSZWN0KG5hbWUsIHNuYXBwZWRJbnRSZWN0KHVybFJl Y3QpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIHBhaW50SW5mby5jb250ZXh0KCku c2V0VVJMRm9yUmVjdCh1cmwsIHNuYXBwZWRJbnRSZWN0KHVybFJlY3QpKTsKIH0KIAogI2lmIFBM QVRGT1JNKElPUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9tYWMvV0tQ cmludGluZ1ZpZXcuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9tYWMvV0tQcmludGluZ1Zp ZXcuaAppbmRleCAzYjhiOGQyODk1ZDU0NGI3OWRlMzdmZGE4ZjM3YTI0ZDlkY2I5MTk4Li4zZjJm ZTkzOTE3NWNhM2ZlZTA3MDgxOTk2YzI1NmQ0NTdlZGQyOWFlIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvbWFjL1dLUHJpbnRpbmdWaWV3LmgKKysrIGIvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL21hYy9XS1ByaW50aW5nVmlldy5oCkBAIC0zMyw2ICszMyw3IEBACiAjaW1w b3J0IDx3dGYvVmVjdG9yLmg+CiAKIEBjbGFzcyBXS1ByaW50aW5nVmlld0RhdGE7CitAY2xhc3Mg UERGRGVzdGluYXRpb247CiBAY2xhc3MgUERGRG9jdW1lbnQ7CiAKIG5hbWVzcGFjZSBXZWJLaXQg ewpAQCAtNTIsNiArNTMsNyBAQCBjbGFzcyBXZWJGcmFtZVByb3h5OwogCiAgICAgVmVjdG9yPHVp bnQ4X3Q+IF9wcmludGVkUGFnZXNEYXRhOwogICAgIFJldGFpblB0cjxQREZEb2N1bWVudD4gX3By aW50ZWRQYWdlc1BERkRvY3VtZW50OworICAgIFZlY3RvcjxWZWN0b3I8UmV0YWluUHRyPFBERkRl c3RpbmF0aW9uPj4+IF9saW5rRGVzdGluYXRpb25zUGVyUGFnZTsKIAogICAgIHVpbnQ2NF90IF9l eHBlY3RlZENvbXB1dGVkUGFnZXNDYWxsYmFjazsKICAgICBIYXNoTWFwPHVpbnQ2NF90LCBXZWJD b3JlOjpJbnRSZWN0PiBfZXhwZWN0ZWRQcmV2aWV3Q2FsbGJhY2tzOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL21hYy9XS1ByaW50aW5nVmlldy5tbSBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9tYWMvV0tQcmludGluZ1ZpZXcubW0KaW5kZXggM2IxMGNlNzVmMTVlYzZi MzlmMTFlNjBhNDYxYjg2Y2Y3ODVhZTQ0Zi4uMGE5NTA2OGYwMDZhMmFjOTY2M2MyNmU3MzRlODVk YjBhY2Y5ZTdkYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL21hYy9XS1By aW50aW5nVmlldy5tbQorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbWFjL1dLUHJpbnRp bmdWaWV3Lm1tCkBAIC00MjcsNiArNDI3LDExIEBAIHN0YXRpYyB2b2lkIHByZXBhcmVEYXRhRm9y UHJpbnRpbmdPblNlY29uZGFyeVRocmVhZChXS1ByaW50aW5nVmlldyAqdmlldykKICAgICByZXR1 cm4gMDsgLy8gSW52YWxpZCBwYWdlIG51bWJlci4KIH0KIAorc3RhdGljIENGU3RyaW5nUmVmIGxp bmtEZXN0aW5hdGlvbk5hbWUoUERGRG9jdW1lbnQgKmRvY3VtZW50LCBQREZEZXN0aW5hdGlvbiAq ZGVzdGluYXRpb24pCit7CisgICAgcmV0dXJuIChDRlN0cmluZ1JlZilbTlNTdHJpbmcgc3RyaW5n V2l0aEZvcm1hdDpAIiVsdS0lZi0lZiIsICh1bnNpZ25lZCBsb25nKVtkb2N1bWVudCBpbmRleEZv clBhZ2U6ZGVzdGluYXRpb24ucGFnZV0sIGRlc3RpbmF0aW9uLnBvaW50LngsIGRlc3RpbmF0aW9u LnBvaW50LnldOworfQorCiAtICh2b2lkKV9kcmF3UERGRG9jdW1lbnQ6KFBERkRvY3VtZW50ICop cGRmRG9jdW1lbnQgcGFnZToodW5zaWduZWQpcGFnZSBhdFBvaW50OihOU1BvaW50KXBvaW50CiB7 CiAgICAgaWYgKCFwZGZEb2N1bWVudCkgewpAQCAtNDU2LDYgKzQ2MSwxMSBAQCBzdGF0aWMgdm9p ZCBwcmVwYXJlRGF0YUZvclByaW50aW5nT25TZWNvbmRhcnlUaHJlYWQoV0tQcmludGluZ1ZpZXcg KnZpZXcpCiAKICAgICBDR0FmZmluZVRyYW5zZm9ybSB0cmFuc2Zvcm0gPSBDR0NvbnRleHRHZXRD VE0oY29udGV4dCk7CiAKKyAgICBmb3IgKGNvbnN0IGF1dG8mIGRlc3RpbmF0aW9uIDogX2xpbmtE ZXN0aW5hdGlvbnNQZXJQYWdlW3BhZ2VdKSB7CisgICAgICAgIENHUG9pbnQgZGVzdGluYXRpb25Q b2ludCA9IENHUG9pbnRBcHBseUFmZmluZVRyYW5zZm9ybShOU1BvaW50VG9DR1BvaW50KFtkZXN0 aW5hdGlvbiBwb2ludF0pLCB0cmFuc2Zvcm0pOworICAgICAgICBDR1BERkNvbnRleHRBZGREZXN0 aW5hdGlvbkF0UG9pbnQoY29udGV4dCwgbGlua0Rlc3RpbmF0aW9uTmFtZShwZGZEb2N1bWVudCwg ZGVzdGluYXRpb24uZ2V0KCkpLCBkZXN0aW5hdGlvblBvaW50KTsKKyAgICB9CisKICAgICBmb3Ig KFBERkFubm90YXRpb24gKmFubm90YXRpb24gaW4gW3BkZlBhZ2UgYW5ub3RhdGlvbnNdKSB7CiAg ICAgICAgIGlmICghW2Fubm90YXRpb24gaXNLaW5kT2ZDbGFzczpwZGZBbm5vdGF0aW9uTGlua0Ns YXNzKCldKQogICAgICAgICAgICAgY29udGludWU7CkBAIC00NjUsOCArNDc1LDE4IEBAIHN0YXRp YyB2b2lkIHByZXBhcmVEYXRhRm9yUHJpbnRpbmdPblNlY29uZGFyeVRocmVhZChXS1ByaW50aW5n VmlldyAqdmlldykKICAgICAgICAgUERGQW5ub3RhdGlvbkxpbmsgKmxpbmtBbm5vdGF0aW9uID0g KFBERkFubm90YXRpb25MaW5rICopYW5ub3RhdGlvbjsKICNwcmFnbWEgY2xhbmcgZGlhZ25vc3Rp YyBwb3AKICAgICAgICAgTlNVUkwgKnVybCA9IFtsaW5rQW5ub3RhdGlvbiBVUkxdOwotICAgICAg ICBpZiAoIXVybCkKKworICAgICAgICBpZiAoIXVybCkgeworICAgICAgICAgICAgUERGRGVzdGlu YXRpb24gKmRlc3RpbmF0aW9uID0gW2xpbmtBbm5vdGF0aW9uIGRlc3RpbmF0aW9uXTsKKyAgICAg ICAgICAgIGlmICghZGVzdGluYXRpb24pCisgICAgICAgICAgICAgICAgY29udGludWU7CisKKyAg ICAgICAgICAgIENHUmVjdCB1cmxSZWN0ID0gTlNSZWN0VG9DR1JlY3QoW2xpbmtBbm5vdGF0aW9u IGJvdW5kc10pOworICAgICAgICAgICAgQ0dSZWN0IHRyYW5zZm9ybWVkUmVjdCA9IENHUmVjdEFw cGx5QWZmaW5lVHJhbnNmb3JtKHVybFJlY3QsIHRyYW5zZm9ybSk7CisgICAgICAgICAgICBDR1BE RkNvbnRleHRTZXREZXN0aW5hdGlvbkZvclJlY3QoY29udGV4dCwgbGlua0Rlc3RpbmF0aW9uTmFt ZShwZGZEb2N1bWVudCwgZGVzdGluYXRpb24pLCB0cmFuc2Zvcm1lZFJlY3QpOworCiAgICAgICAg ICAgICBjb250aW51ZTsKKyAgICAgICAgfQogCiAgICAgICAgIENHUmVjdCB1cmxSZWN0ID0gTlNS ZWN0VG9DR1JlY3QoW2xpbmtBbm5vdGF0aW9uIGJvdW5kc10pOwogICAgICAgICBDR1JlY3QgdHJh bnNmb3JtZWRSZWN0ID0gQ0dSZWN0QXBwbHlBZmZpbmVUcmFuc2Zvcm0odXJsUmVjdCwgdHJhbnNm b3JtKTsKQEAgLTU0OSw2ICs1NjksMzEgQEAgc3RhdGljIHZvaWQgcHJlcGFyZURhdGFGb3JQcmlu dGluZ09uU2Vjb25kYXJ5VGhyZWFkKFdLUHJpbnRpbmdWaWV3ICp2aWV3KQogICAgIGlmICghX3By aW50ZWRQYWdlc1BERkRvY3VtZW50KSB7CiAgICAgICAgIFJldGFpblB0cjxOU0RhdGE+IHBkZkRh dGEgPSBhZG9wdE5TKFtbTlNEYXRhIGFsbG9jXSBpbml0V2l0aEJ5dGVzOl9wcmludGVkUGFnZXNE YXRhLmRhdGEoKSBsZW5ndGg6X3ByaW50ZWRQYWdlc0RhdGEuc2l6ZSgpXSk7CiAgICAgICAgIF9w cmludGVkUGFnZXNQREZEb2N1bWVudCA9IGFkb3B0TlMoW1twZGZEb2N1bWVudENsYXNzKCkgYWxs b2NdIGluaXRXaXRoRGF0YTpwZGZEYXRhLmdldCgpXSk7CisKKyAgICAgICAgdW5zaWduZWQgcGFn ZUNvdW50ID0gW19wcmludGVkUGFnZXNQREZEb2N1bWVudCBwYWdlQ291bnRdOworICAgICAgICBf bGlua0Rlc3RpbmF0aW9uc1BlclBhZ2UuY2xlYXIoKTsKKyAgICAgICAgX2xpbmtEZXN0aW5hdGlv bnNQZXJQYWdlLnJlc2l6ZShwYWdlQ291bnQpOworICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAw OyBpIDwgcGFnZUNvdW50OyBpKyspIHsKKyAgICAgICAgICAgIFBERlBhZ2UgKnBhZ2UgPSBbX3By aW50ZWRQYWdlc1BERkRvY3VtZW50IHBhZ2VBdEluZGV4OmldOworICAgICAgICAgICAgZm9yIChQ REZBbm5vdGF0aW9uICphbm5vdGF0aW9uIGluIHBhZ2UuYW5ub3RhdGlvbnMpIHsKKyAgICAgICAg ICAgICAgICBpZiAoIVthbm5vdGF0aW9uIGlzS2luZE9mQ2xhc3M6cGRmQW5ub3RhdGlvbkxpbmtD bGFzcygpXSkKKyAgICAgICAgICAgICAgICAgICAgY29udGludWU7CisKKyNwcmFnbWEgY2xhbmcg ZGlhZ25vc3RpYyBwdXNoCisjcHJhZ21hIGNsYW5nIGRpYWdub3N0aWMgaWdub3JlZCAiLVdkZXBy ZWNhdGVkLWRlY2xhcmF0aW9ucyIKKyAgICAgICAgICAgICAgICBQREZBbm5vdGF0aW9uTGluayAq bGlua0Fubm90YXRpb24gPSAoUERGQW5ub3RhdGlvbkxpbmsgKilhbm5vdGF0aW9uOworI3ByYWdt YSBjbGFuZyBkaWFnbm9zdGljIHBvcAorICAgICAgICAgICAgICAgIGlmIChsaW5rQW5ub3RhdGlv bi5VUkwpCisgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAgICAgICAgICAg UERGRGVzdGluYXRpb24gKmRlc3RpbmF0aW9uID0gbGlua0Fubm90YXRpb24uZGVzdGluYXRpb247 CisgICAgICAgICAgICAgICAgaWYgKCFkZXN0aW5hdGlvbikKKyAgICAgICAgICAgICAgICAgICAg Y29udGludWU7CisKKyAgICAgICAgICAgICAgICB1bnNpZ25lZCBkZXN0aW5hdGlvblBhZ2VJbmRl eCA9IFtfcHJpbnRlZFBhZ2VzUERGRG9jdW1lbnQgaW5kZXhGb3JQYWdlOmRlc3RpbmF0aW9uLnBh Z2VdOworICAgICAgICAgICAgICAgIF9saW5rRGVzdGluYXRpb25zUGVyUGFnZVtkZXN0aW5hdGlv blBhZ2VJbmRleF0uYXBwZW5kKGRlc3RpbmF0aW9uKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAg fQogICAgIH0KIAogICAgIHVuc2lnbmVkIHByaW50ZWRQYWdlTnVtYmVyID0gW3NlbGYgX3BhZ2VG b3JSZWN0Om5zUmVjdF0gLSBbc2VsZiBfZmlyc3RQcmludGVkUGFnZU51bWJlcl07Cg== 293730 2016-11-02 18:26:07 -0700 2016-11-02 18:41:11 -0700 Patch bug-112081-20161102182207.patch text/plain 16864 thorton U3VidmVyc2lvbiBSZXZpc2lvbjogMjA4Mjk0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjE3YTU0OWFjMjVlZWI3 OGJhMzhkNmY5YzBhNTk3ZDVhN2JkMTQ1Ni4uMWRkNjkxMjIwYWNjM2UxNmI0ZTllMmI0ODI5ZTQ2 ZTg1OTEzYjE1YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM5IEBACisyMDE2LTExLTAyICBUaW0g SG9ydG9uICA8dGltb3RoeV9ob3J0b25AYXBwbGUuY29tPgorCisgICAgICAgIFByaW50aW5nIHRv IFBERiBzaG91bGQgcHJvZHVjZSBpbnRlcm5hbCBsaW5rcyB3aGVuIEhUTUwgaGFzIGludGVybmFs IGxpbmtzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x MTIwODEKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzU5NTU3MDU+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisgICAgICAgIFBhdGNoIG9yaWdpbmFsbHkgYnkgRGF2aWQg TGF0dGltb3JlLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cywgYXMgaXQncyB1bmNsZWFyIGhvdyB0 byB0ZXN0IFBERiBvdXRwdXQuCisKKyAgICAgICAgKiBwYWdlL1ByaW50Q29udGV4dC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpQcmludENvbnRleHQ6OlByaW50Q29udGV4dCk6CisgICAgICAgIChX ZWJDb3JlOjpQcmludENvbnRleHQ6OnNwb29sUGFnZSk6CisgICAgICAgIChXZWJDb3JlOjpQcmlu dENvbnRleHQ6OnNwb29sUmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpQcmludENvbnRleHQ6OmVu ZCk6CisgICAgICAgIChXZWJDb3JlOjpQcmludENvbnRleHQ6OmNvbGxlY3RMaW5rZWREZXN0aW5h dGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6UHJpbnRDb250ZXh0OjpvdXRwdXRMaW5rZWREZXN0 aW5hdGlvbnMpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjphZGRQREZVUkxSZWN0KToKKyAgICAgICAgUGx1bWIg aW50ZXJuYWwgbGlua3MgKGZyYWdtZW50IGxpbmtzKSB0aHJvdWdoIHRvIEdyYXBoaWNzQ29udGV4 dCwgdXNpbmcKKyAgICAgICAgdGhlIGZyYWdtZW50IG5hbWUgZnJvbSB0aGUgcGFnZS4KKworICAg ICAgICAqIHBhZ2UvUHJpbnRDb250ZXh0Lmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mv R3JhcGhpY3NDb250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6 c3VwcG9ydHNJbnRlcm5hbExpbmtzKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4 dDo6c2V0RGVzdGluYXRpb25Gb3JSZWN0KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29u dGV4dDo6YWRkRGVzdGluYXRpb25BdFBvaW50KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGlj cy9HcmFwaGljc0NvbnRleHQuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jZy9HcmFw aGljc0NvbnRleHRDRy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6OnN1 cHBvcnRzSW50ZXJuYWxMaW5rcyk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6 OnNldERlc3RpbmF0aW9uRm9yUmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRl eHQ6OmFkZERlc3RpbmF0aW9uQXRQb2ludCk6CisgICAgICAgIFBsdW1iIGludGVybmFsIGxpbmtz IHRocm91Z2ggdG8gdGhlIENHQ29udGV4dC4gQXBwbHkgdGhlIENUTSwgYmVjYXVzZQorICAgICAg ICB0aGVzZSBmdW5jdGlvbnMgZXhwZWN0IHBvc2l0aW9ucyBpbiBnbG9iYWwgY29vcmRpbmF0ZXMu CisKIDIwMTYtMTEtMDEgIERlYW4gSmFja3NvbiAgPGRpbm9AYXBwbGUuY29tPgogCiAgICAgICAg IEZpbHRlciBmdW5jdGlvbnMgZ3JheXNjYWxlL2ludmVydC9vcGFjaXR5L3NlcGlhIHNob3VsZCBj bGFtcCB2YWx1ZXMgb3ZlciAxMDAlLCBub3QgZmFpbApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dDIvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IDA3ZTc2Y2I5ZjRl OTU5ZjZlMWFhNTAxNTJlODBmOWM3NDAxM2Y5NmQuLjkyYTE2ODY0ZTY2MTI2MjIyNzY0YjA3ODNl OTI3YzZiNjM4NGFjNDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAxNi0xMS0wMiAg VGltIEhvcnRvbiAgPHRpbW90aHlfaG9ydG9uQGFwcGxlLmNvbT4KKworICAgICAgICBQcmludGlu ZyB0byBQREYgc2hvdWxkIHByb2R1Y2UgaW50ZXJuYWwgbGlua3Mgd2hlbiBIVE1MIGhhcyBpbnRl cm5hbCBsaW5rcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTEyMDgxCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS81OTU1NzA1PgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogVUlQcm9jZXNzL21hYy9XS1By aW50aW5nVmlldy5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9tYWMvV0tQcmludGluZ1ZpZXcubW06 CisgICAgICAgIChsaW5rRGVzdGluYXRpb25OYW1lKToKKyAgICAgICAgKC1bV0tQcmludGluZ1Zp ZXcgX2RyYXdQREZEb2N1bWVudDpwYWdlOmF0UG9pbnQ6XSk6CisgICAgICAgIFByb3BhZ2F0ZSBs aW5rLXRvLWRlc3RpbmF0aW9uIGFubm90YXRpb25zIChhbmQgZWFjaCBwYWdlJ3MgZGVzdGluYXRp b25zKQorICAgICAgICBpbnRvIHRoZSBwcmludGVkIFBERi4KKyAgICAgICAgR2VuZXJhdGUgYSB1 bmlxdWUgZGVzdGluYXRpb24gbmFtZSBiYXNlZCBvbiB0aGUgcGFnZSBhbmQgcG9zaXRpb24sIGJl Y2F1c2UKKyAgICAgICAgd2UgaGF2ZSBsb3N0IHRoZSBmcmFnbWVudCBuYW1lIGluZm9ybWF0aW9u LgorCisgICAgICAgICgtW1dLUHJpbnRpbmdWaWV3IGRyYXdSZWN0Ol0pOgorICAgICAgICBDb21w dXRlIGFsbCBvZiB0aGUgZGVzdGluYXRpb25zIGZvciBldmVyeSBwYWdlLCBzbyB0aGF0IHdlIGNh biBhZGQgdGhlbQorICAgICAgICB0byB0aGUgY29udGV4dCBhcyB3ZSBwYWludCB0aGUgcGFnZXMg KHdlIG5lZWQgdGhlIHBhZ2UgQ1RNIGluIG9yZGVyIHRvIGFkZCB0aGVtKS4KKwogMjAxNi0xMS0w MiAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CiAKICAgICAgICAg TmV0d29ya1Nlc3Npb246IE5ldHdvcmsgcHJvY2VzcyBjcmFzaCB3aGVuIGNvbnZlcnRpbmcgbWFp biByZXNvdXJjZSB0byBkb3dubG9hZApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9Q cmludENvbnRleHQuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QcmludENvbnRleHQuY3BwCmlu ZGV4IDU0ZGVhMzZmOTJhZWEwZmQzZGM1MTVhZTk5ZDAyZWQyZWFlM2Y0MjkuLmNkZDE0ZDE1NjFm MmQxYzExMjdlYTk0NjEzMmEzNmQ3OTIzMTc5Y2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvUHJpbnRDb250ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1ByaW50Q29u dGV4dC5jcHAKQEAgLTI0LDYgKzI0LDggQEAKICNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIK ICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgorI2luY2x1ZGUgIkhU TUxOYW1lcy5oIgorI2luY2x1ZGUgIk5vZGVUcmF2ZXJzYWwuaCIKICNpbmNsdWRlICJSZW5kZXJW aWV3LmgiCiAjaW5jbHVkZSAiU3R5bGVJbmhlcml0ZWREYXRhLmgiCiAjaW5jbHVkZSAiU3R5bGVS ZXNvbHZlci5oIgpAQCAtMzQsNyArMzYsNiBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIFByaW50 Q29udGV4dDo6UHJpbnRDb250ZXh0KEZyYW1lKiBmcmFtZSkKICAgICA6IG1fZnJhbWUoZnJhbWUp Ci0gICAgLCBtX2lzUHJpbnRpbmcoZmFsc2UpCiB7CiB9CiAKQEAgLTE5MCw2ICsxOTEsNyBAQCB2 b2lkIFByaW50Q29udGV4dDo6c3Bvb2xQYWdlKEdyYXBoaWNzQ29udGV4dCYgY3R4LCBpbnQgcGFn ZU51bWJlciwgZmxvYXQgd2lkdGgpCiAgICAgY3R4LnRyYW5zbGF0ZSgtcGFnZVJlY3QueCgpLCAt cGFnZVJlY3QueSgpKTsKICAgICBjdHguY2xpcChwYWdlUmVjdCk7CiAgICAgbV9mcmFtZS0+dmll dygpLT5wYWludENvbnRlbnRzKGN0eCwgcGFnZVJlY3QpOworICAgIG91dHB1dExpbmtlZERlc3Rp bmF0aW9ucyhjdHgsIG1fZnJhbWUtPmRvY3VtZW50KCksIHBhZ2VSZWN0KTsKICAgICBjdHgucmVz dG9yZSgpOwogfQogCkBAIC0yMDAsNiArMjAyLDcgQEAgdm9pZCBQcmludENvbnRleHQ6OnNwb29s UmVjdChHcmFwaGljc0NvbnRleHQmIGN0eCwgY29uc3QgSW50UmVjdCYgcmVjdCkKICAgICBjdHgu dHJhbnNsYXRlKC1yZWN0LngoKSwgLXJlY3QueSgpKTsKICAgICBjdHguY2xpcChyZWN0KTsKICAg ICBtX2ZyYW1lLT52aWV3KCktPnBhaW50Q29udGVudHMoY3R4LCByZWN0KTsKKyAgICBvdXRwdXRM aW5rZWREZXN0aW5hdGlvbnMoY3R4LCBtX2ZyYW1lLT5kb2N1bWVudCgpLCByZWN0KTsKICAgICBj dHgucmVzdG9yZSgpOwogfQogCkBAIC0yMDgsNiArMjExLDcgQEAgdm9pZCBQcmludENvbnRleHQ6 OmVuZCgpCiAgICAgQVNTRVJUKG1faXNQcmludGluZyk7CiAgICAgbV9pc1ByaW50aW5nID0gZmFs c2U7CiAgICAgbV9mcmFtZS0+c2V0UHJpbnRpbmcoZmFsc2UsIEZsb2F0U2l6ZSgpLCBGbG9hdFNp emUoKSwgMCwgQWRqdXN0Vmlld1NpemUpOworICAgIG1fbGlua2VkRGVzdGluYXRpb25zID0gTnVs bG9wdDsKIH0KIAogc3RhdGljIGlubGluZSBSZW5kZXJCb3hNb2RlbE9iamVjdCogZW5jbG9zaW5n Qm94TW9kZWxPYmplY3QoUmVuZGVyRWxlbWVudCogcmVuZGVyZXIpCkBAIC0yNDYsNiArMjUwLDU0 IEBAIGludCBQcmludENvbnRleHQ6OnBhZ2VOdW1iZXJGb3JFbGVtZW50KEVsZW1lbnQqIGVsZW1l bnQsIGNvbnN0IEZsb2F0U2l6ZSYgcGFnZVNpCiAgICAgcmV0dXJuIC0xOwogfQogCit2b2lkIFBy aW50Q29udGV4dDo6Y29sbGVjdExpbmtlZERlc3RpbmF0aW9ucyhOb2RlKiBub2RlKQoreworICAg IG1fbGlua2VkRGVzdGluYXRpb25zID0geyB9OworCisgICAgZm9yIChOb2RlKiBjaGlsZCA9IG5v ZGUtPmZpcnN0Q2hpbGQoKTsgY2hpbGQ7IGNoaWxkID0gTm9kZVRyYXZlcnNhbDo6bmV4dCgqY2hp bGQpKQorICAgICAgICBjb2xsZWN0TGlua2VkRGVzdGluYXRpb25zKGNoaWxkKTsKKworICAgIGlm ICghbm9kZS0+aXNMaW5rKCkpCisgICAgICAgIHJldHVybjsKKworICAgIGlmICghaXM8RWxlbWVu dD4obm9kZSkpCisgICAgICAgIHJldHVybjsKKworICAgIGNvbnN0IEF0b21pY1N0cmluZyYgaHJl ZiA9IGRvd25jYXN0PEVsZW1lbnQ+KG5vZGUpLT5nZXRBdHRyaWJ1dGUoSFRNTE5hbWVzOjpocmVm QXR0cik7CisgICAgaWYgKGhyZWYuaXNOdWxsKCkpCisgICAgICAgIHJldHVybjsKKworICAgIERv Y3VtZW50JiBkb2N1bWVudCA9IG5vZGUtPmRvY3VtZW50KCk7CisgICAgVVJMIHVybCA9IGRvY3Vt ZW50LmNvbXBsZXRlVVJMKGhyZWYpOworICAgIGlmICghdXJsLmlzVmFsaWQoKSkKKyAgICAgICAg cmV0dXJuOworCisgICAgaWYgKHVybC5oYXNGcmFnbWVudElkZW50aWZpZXIoKSAmJiBlcXVhbEln bm9yaW5nRnJhZ21lbnRJZGVudGlmaWVyKHVybCwgZG9jdW1lbnQuYmFzZVVSTCgpKSkgeworICAg ICAgICBTdHJpbmcgbmFtZSA9IHVybC5mcmFnbWVudElkZW50aWZpZXIoKTsKKyAgICAgICAgaWYg KEVsZW1lbnQqIGVsZW1lbnQgPSBkb2N1bWVudC5maW5kQW5jaG9yKG5hbWUpKQorICAgICAgICAg ICAgbV9saW5rZWREZXN0aW5hdGlvbnMtPnNldChuYW1lLCBlbGVtZW50KTsKKyAgICB9Cit9CisK K3ZvaWQgUHJpbnRDb250ZXh0OjpvdXRwdXRMaW5rZWREZXN0aW5hdGlvbnMoR3JhcGhpY3NDb250 ZXh0JiBncmFwaGljc0NvbnRleHQsIE5vZGUqIG5vZGUsIGNvbnN0IEludFJlY3QmIHBhZ2VSZWN0 KQoreworICAgIGlmICghZ3JhcGhpY3NDb250ZXh0LnN1cHBvcnRzSW50ZXJuYWxMaW5rcygpKQor ICAgICAgICByZXR1cm47CisKKyAgICBpZiAoIW1fbGlua2VkRGVzdGluYXRpb25zKQorICAgICAg ICBjb2xsZWN0TGlua2VkRGVzdGluYXRpb25zKG5vZGUpOworCisgICAgZm9yIChjb25zdCBhdXRv JiBpdCA6ICptX2xpbmtlZERlc3RpbmF0aW9ucykgeworICAgICAgICBJbnRSZWN0IGJvdW5kaW5n Qm94ID0gaXQudmFsdWUtPnJlbmRlcmVyKCktPmFic29sdXRlQm91bmRpbmdCb3hSZWN0KCk7Cisg ICAgICAgIGlmICghcGFnZVJlY3QuaW50ZXJzZWN0cyhib3VuZGluZ0JveCkpCisgICAgICAgICAg ICBjb250aW51ZTsKKworICAgICAgICBJbnRQb2ludCBwb2ludCA9IGJvdW5kaW5nQm94Lm1pblhN aW5ZQ29ybmVyKCk7CisgICAgICAgIHBvaW50LmNsYW1wTmVnYXRpdmVUb1plcm8oKTsKKyAgICAg ICAgZ3JhcGhpY3NDb250ZXh0LmFkZERlc3RpbmF0aW9uQXRQb2ludChpdC5rZXksIHBvaW50KTsK KyAgICB9Cit9CisKIFN0cmluZyBQcmludENvbnRleHQ6OnBhZ2VQcm9wZXJ0eShGcmFtZSogZnJh bWUsIGNvbnN0IGNoYXIqIHByb3BlcnR5TmFtZSwgaW50IHBhZ2VOdW1iZXIpCiB7CiAgICAgRG9j dW1lbnQqIGRvY3VtZW50ID0gZnJhbWUtPmRvY3VtZW50KCk7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wYWdlL1ByaW50Q29udGV4dC5oIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QcmludENv bnRleHQuaAppbmRleCA5ZmM2NmQzZGE5MTBlMDUwODlmNTU3YWUzNmY5MTIzMDk1NzRiZDBhLi5h YzBkMzdiNzQ5ZDNmNDY3Njg4NWJhOTM4ODIyODQ1YTdhOWI4MDdhIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wYWdlL1ByaW50Q29udGV4dC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BhZ2Uv UHJpbnRDb250ZXh0LmgKQEAgLTIxLDcgKzIxLDkgQEAKICNwcmFnbWEgb25jZQogCiAjaW5jbHVk ZSA8d3RmL0ZvcndhcmQuaD4KKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgogI2luY2x1ZGUgPHd0 Zi9WZWN0b3IuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KIAogbmFtZXNwYWNl IFdlYkNvcmUgewogCkBAIC0zMSw2ICszMyw3IEBAIGNsYXNzIEZsb2F0UmVjdDsKIGNsYXNzIEZs b2F0U2l6ZTsKIGNsYXNzIEdyYXBoaWNzQ29udGV4dDsKIGNsYXNzIEludFJlY3Q7CitjbGFzcyBO b2RlOwogCiBjbGFzcyBQcmludENvbnRleHQgewogcHVibGljOgpAQCAtOTgsOSArMTAxLDEzIEBA IHByb3RlY3RlZDoKIHByaXZhdGU6CiAgICAgdm9pZCBjb21wdXRlUGFnZVJlY3RzV2l0aFBhZ2VT aXplSW50ZXJuYWwoY29uc3QgRmxvYXRTaXplJiBwYWdlU2l6ZUluUGl4ZWxzLCBib29sIGFsbG93 SG9yaXpvbnRhbFRpbGluZyk7CiAgICAgYm9vbCBiZWdpbkFuZENvbXB1dGVQYWdlUmVjdHNXaXRo UGFnZVNpemUoRnJhbWUmLCBjb25zdCBGbG9hdFNpemUmIHBhZ2VTaXplSW5QaXhlbHMpOworICAg IHZvaWQgY29sbGVjdExpbmtlZERlc3RpbmF0aW9ucyhOb2RlKik7CisgICAgdm9pZCBvdXRwdXRM aW5rZWREZXN0aW5hdGlvbnMoR3JhcGhpY3NDb250ZXh0JiwgTm9kZSosIGNvbnN0IEludFJlY3Qm IHBhZ2VSZWN0KTsKIAogICAgIC8vIFVzZWQgdG8gcHJldmVudCBtaXN1c2VzIG9mIGJlZ2luKCkg YW5kIGVuZCgpIChlLmcuLCBjYWxsIGVuZCB3aXRob3V0IGJlZ2luKS4KLSAgICBib29sIG1faXNQ cmludGluZzsKKyAgICBib29sIG1faXNQcmludGluZyB7IGZhbHNlIH07CisKKyAgICBPcHRpb25h bDxIYXNoTWFwPFN0cmluZywgRWxlbWVudCo+PiBtX2xpbmtlZERlc3RpbmF0aW9uczsKIH07CiAK IH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuY3BwCmluZGV4IDg4YjdmNWI5MTVlNDdjNTgxYTcy OGQ2NWVkMzMwYjE3ZmU1ODFkMzkuLmJjNWQyOWQwYzQwZDJkMGEyN2UxOWFmMjBmMmVmNTU2MjFl YTA5NWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBo aWNzQ29udGV4dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3Jh cGhpY3NDb250ZXh0LmNwcApAQCAtMTE3Nyw0ICsxMTc3LDE5IEBAIFZlY3RvcjxGbG9hdFBvaW50 PiBHcmFwaGljc0NvbnRleHQ6OmNlbnRlckxpbmVBbmRDdXRPZmZDb3JuZXJzKGJvb2wgaXNWZXJ0 aWNhbExpCiAgICAgcmV0dXJuIHsgcG9pbnQxLCBwb2ludDIgfTsKIH0KIAorI2lmICFVU0UoQ0cp Citib29sIEdyYXBoaWNzQ29udGV4dDo6c3VwcG9ydHNJbnRlcm5hbExpbmtzKCkKK3sKKyAgICBy ZXR1cm4gZmFsc2U7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjpzZXREZXN0aW5hdGlvbkZv clJlY3QoY29uc3QgU3RyaW5nJiwgY29uc3QgSW50UmVjdCYpCit7Cit9CisKK3ZvaWQgR3JhcGhp Y3NDb250ZXh0OjphZGREZXN0aW5hdGlvbkF0UG9pbnQoY29uc3QgU3RyaW5nJiwgY29uc3QgSW50 UG9pbnQmKQoreworfQorI2VuZGlmCisKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmgKaW5kZXggNTY5N2MwOWY3NmVkNjNhMGM5Zjg5 N2U5MDE1NTE5ZDUwNzgyYzQ0MS4uNDUyYTdlOTY3OWI0ZGE1OGE1NjllNjJhNjFkZTkyNzk0NmY5 MjhhMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhp Y3NDb250ZXh0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhp Y3NDb250ZXh0LmgKQEAgLTQ3MCw2ICs0NzAsOSBAQCBwdWJsaWM6CiAKICAgICB2b2lkIHNldFVS TEZvclJlY3QoY29uc3QgVVJMJiwgY29uc3QgSW50UmVjdCYpOwogCisgICAgdm9pZCBzZXREZXN0 aW5hdGlvbkZvclJlY3QoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJbnRSZWN0Jik7CisgICAg dm9pZCBhZGREZXN0aW5hdGlvbkF0UG9pbnQoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJbnRQ b2ludCYpOworCiAgICAgdm9pZCBjb25jYXRDVE0oY29uc3QgQWZmaW5lVHJhbnNmb3JtJik7CiAg ICAgdm9pZCBzZXRDVE0oY29uc3QgQWZmaW5lVHJhbnNmb3JtJik7CiAKQEAgLTU3Niw2ICs1Nzks OCBAQCBwdWJsaWM6CiAKICAgICBzdGF0aWMgdm9pZCBhZGp1c3RMaW5lVG9QaXhlbEJvdW5kYXJp ZXMoRmxvYXRQb2ludCYgcDEsIEZsb2F0UG9pbnQmIHAyLCBmbG9hdCBzdHJva2VXaWR0aCwgU3Ry b2tlU3R5bGUpOwogCisgICAgYm9vbCBzdXBwb3J0c0ludGVybmFsTGlua3MoKTsKKwogcHJpdmF0 ZToKICAgICB2b2lkIHBsYXRmb3JtSW5pdChQbGF0Zm9ybUdyYXBoaWNzQ29udGV4dCopOwogICAg IHZvaWQgcGxhdGZvcm1EZXN0cm95KCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jZy9HcmFwaGljc0NvbnRleHRDRy5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jZy9HcmFwaGljc0NvbnRleHRDRy5jcHAKaW5kZXggZTA2ZjQ1ZDQ5 MmM1ODhhYmMyZWI5ZjVhZmNkMjQwZDM4ZWVjNTUyOC4uM2Q1NzU5YmU1OThkMWI0OWYzMmJjNWM2 OTQ0MzBjMjdkNDE2YzhkOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2cvR3JhcGhpY3NDb250ZXh0Q0cuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2NnL0dyYXBoaWNzQ29udGV4dENHLmNwcApAQCAtMTkwMiw2ICsxOTAyLDM2 IEBAIHZvaWQgR3JhcGhpY3NDb250ZXh0OjpwbGF0Zm9ybVN0cm9rZUVsbGlwc2UoY29uc3QgRmxv YXRSZWN0JiBlbGxpcHNlKQogICAgIENHQ29udGV4dFN0cm9rZUVsbGlwc2VJblJlY3QoY29udGV4 dCwgZWxsaXBzZSk7CiB9CiAKK2Jvb2wgR3JhcGhpY3NDb250ZXh0OjpzdXBwb3J0c0ludGVybmFs TGlua3MoKQoreworICAgIHJldHVybiB0cnVlOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6 c2V0RGVzdGluYXRpb25Gb3JSZWN0KGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgSW50UmVjdCYg ZGVzdFJlY3QpCit7CisgICAgaWYgKHBhaW50aW5nRGlzYWJsZWQoKSkKKyAgICAgICAgcmV0dXJu OworCisgICAgQ0dDb250ZXh0UmVmIGNvbnRleHQgPSBwbGF0Zm9ybUNvbnRleHQoKTsKKworICAg IEludFJlY3QgcmVjdCA9IGRlc3RSZWN0OworICAgIHJlY3QuaW50ZXJzZWN0KGVuY2xvc2luZ0lu dFJlY3QoQ0dDb250ZXh0R2V0Q2xpcEJvdW5kaW5nQm94KGNvbnRleHQpKSk7CisKKyAgICBDR1Jl Y3QgdHJhbnNmb3JtZWRSZWN0ID0gQ0dSZWN0QXBwbHlBZmZpbmVUcmFuc2Zvcm0ocmVjdCwgQ0dD b250ZXh0R2V0Q1RNKGNvbnRleHQpKTsKKyAgICBDR1BERkNvbnRleHRTZXREZXN0aW5hdGlvbkZv clJlY3QoY29udGV4dCwgbmFtZS5jcmVhdGVDRlN0cmluZygpLmdldCgpLCB0cmFuc2Zvcm1lZFJl Y3QpOworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6YWRkRGVzdGluYXRpb25BdFBvaW50KGNv bnN0IFN0cmluZyYgbmFtZSwgY29uc3QgSW50UG9pbnQmIHBvc2l0aW9uKQoreworICAgIGlmIChw YWludGluZ0Rpc2FibGVkKCkpCisgICAgICAgIHJldHVybjsKKworICAgIENHQ29udGV4dFJlZiBj b250ZXh0ID0gcGxhdGZvcm1Db250ZXh0KCk7CisKKyAgICBDR1BvaW50IHRyYW5zZm9ybWVkUG9p bnQgPSBDR1BvaW50QXBwbHlBZmZpbmVUcmFuc2Zvcm0ocG9zaXRpb24sIENHQ29udGV4dEdldENU TShjb250ZXh0KSk7CisgICAgQ0dQREZDb250ZXh0QWRkRGVzdGluYXRpb25BdFBvaW50KGNvbnRl eHQsIG5hbWUuY3JlYXRlQ0ZTdHJpbmcoKS5nZXQoKSwgdHJhbnNmb3JtZWRQb2ludCk7Cit9CisK IH0KIAogI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVy T2JqZWN0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCmlu ZGV4IDE3Nzg0MWU2NjZmZDNlZmUyZTkxMGEwY2U4M2JhZDMxYWVjOTcwNGIuLjU4NmQyMzM2Zjk4 ZTUyMjBmMjhkMzc3MGMyMDAyMjFjYmFlZDEyMTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3JlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmlu Zy9SZW5kZXJPYmplY3QuY3BwCkBAIC02MDcsNyArNjA3LDIwIEBAIHZvaWQgUmVuZGVyT2JqZWN0 OjphZGRQREZVUkxSZWN0KFBhaW50SW5mbyYgcGFpbnRJbmZvLCBjb25zdCBMYXlvdXRQb2ludCYg cGFpbnRPCiAgICAgY29uc3QgQXRvbWljU3RyaW5nJiBocmVmID0gZG93bmNhc3Q8RWxlbWVudD4o Km5vZGUpLmdldEF0dHJpYnV0ZShocmVmQXR0cik7CiAgICAgaWYgKGhyZWYuaXNOdWxsKCkpCiAg ICAgICAgIHJldHVybjsKLSAgICBwYWludEluZm8uY29udGV4dCgpLnNldFVSTEZvclJlY3Qobm9k ZS0+ZG9jdW1lbnQoKS5jb21wbGV0ZVVSTChocmVmKSwgc25hcHBlZEludFJlY3QodXJsUmVjdCkp OworICAgIAorICAgIERvY3VtZW50JiBkb2N1bWVudCA9IG5vZGUtPmRvY3VtZW50KCk7CisgICAg VVJMIHVybCA9IGRvY3VtZW50LmNvbXBsZXRlVVJMKGhyZWYpOworICAgIGlmICghdXJsLmlzVmFs aWQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKHBhaW50SW5mby5jb250ZXh0KCkuc3Vw cG9ydHNJbnRlcm5hbExpbmtzKCkgJiYgdXJsLmhhc0ZyYWdtZW50SWRlbnRpZmllcigpICYmIGVx dWFsSWdub3JpbmdGcmFnbWVudElkZW50aWZpZXIodXJsLCBkb2N1bWVudC5iYXNlVVJMKCkpKSB7 CisgICAgICAgIFN0cmluZyBuYW1lID0gdXJsLmZyYWdtZW50SWRlbnRpZmllcigpOworICAgICAg ICBpZiAoZG9jdW1lbnQuZmluZEFuY2hvcihuYW1lKSkKKyAgICAgICAgICAgIHBhaW50SW5mby5j b250ZXh0KCkuc2V0RGVzdGluYXRpb25Gb3JSZWN0KG5hbWUsIHNuYXBwZWRJbnRSZWN0KHVybFJl Y3QpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIHBhaW50SW5mby5jb250ZXh0KCku c2V0VVJMRm9yUmVjdCh1cmwsIHNuYXBwZWRJbnRSZWN0KHVybFJlY3QpKTsKIH0KIAogI2lmIFBM QVRGT1JNKElPUykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9tYWMvV0tQ cmludGluZ1ZpZXcuaCBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9tYWMvV0tQcmludGluZ1Zp ZXcuaAppbmRleCAzYjhiOGQyODk1ZDU0NGI3OWRlMzdmZGE4ZjM3YTI0ZDlkY2I5MTk4Li4zZjJm ZTkzOTE3NWNhM2ZlZTA3MDgxOTk2YzI1NmQ0NTdlZGQyOWFlIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0Mi9VSVByb2Nlc3MvbWFjL1dLUHJpbnRpbmdWaWV3LmgKKysrIGIvU291cmNlL1dlYktp dDIvVUlQcm9jZXNzL21hYy9XS1ByaW50aW5nVmlldy5oCkBAIC0zMyw2ICszMyw3IEBACiAjaW1w b3J0IDx3dGYvVmVjdG9yLmg+CiAKIEBjbGFzcyBXS1ByaW50aW5nVmlld0RhdGE7CitAY2xhc3Mg UERGRGVzdGluYXRpb247CiBAY2xhc3MgUERGRG9jdW1lbnQ7CiAKIG5hbWVzcGFjZSBXZWJLaXQg ewpAQCAtNTIsNiArNTMsNyBAQCBjbGFzcyBXZWJGcmFtZVByb3h5OwogCiAgICAgVmVjdG9yPHVp bnQ4X3Q+IF9wcmludGVkUGFnZXNEYXRhOwogICAgIFJldGFpblB0cjxQREZEb2N1bWVudD4gX3By aW50ZWRQYWdlc1BERkRvY3VtZW50OworICAgIFZlY3RvcjxWZWN0b3I8UmV0YWluUHRyPFBERkRl c3RpbmF0aW9uPj4+IF9saW5rRGVzdGluYXRpb25zUGVyUGFnZTsKIAogICAgIHVpbnQ2NF90IF9l eHBlY3RlZENvbXB1dGVkUGFnZXNDYWxsYmFjazsKICAgICBIYXNoTWFwPHVpbnQ2NF90LCBXZWJD b3JlOjpJbnRSZWN0PiBfZXhwZWN0ZWRQcmV2aWV3Q2FsbGJhY2tzOwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYktpdDIvVUlQcm9jZXNzL21hYy9XS1ByaW50aW5nVmlldy5tbSBiL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9tYWMvV0tQcmludGluZ1ZpZXcubW0KaW5kZXggM2IxMGNlNzVmMTVlYzZi MzlmMTFlNjBhNDYxYjg2Y2Y3ODVhZTQ0Zi4uMGE5NTA2OGYwMDZhMmFjOTY2M2MyNmU3MzRlODVk YjBhY2Y5ZTdkYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL21hYy9XS1By aW50aW5nVmlldy5tbQorKysgYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbWFjL1dLUHJpbnRp bmdWaWV3Lm1tCkBAIC00MjcsNiArNDI3LDExIEBAIHN0YXRpYyB2b2lkIHByZXBhcmVEYXRhRm9y UHJpbnRpbmdPblNlY29uZGFyeVRocmVhZChXS1ByaW50aW5nVmlldyAqdmlldykKICAgICByZXR1 cm4gMDsgLy8gSW52YWxpZCBwYWdlIG51bWJlci4KIH0KIAorc3RhdGljIENGU3RyaW5nUmVmIGxp bmtEZXN0aW5hdGlvbk5hbWUoUERGRG9jdW1lbnQgKmRvY3VtZW50LCBQREZEZXN0aW5hdGlvbiAq ZGVzdGluYXRpb24pCit7CisgICAgcmV0dXJuIChDRlN0cmluZ1JlZilbTlNTdHJpbmcgc3RyaW5n V2l0aEZvcm1hdDpAIiVsdS0lZi0lZiIsICh1bnNpZ25lZCBsb25nKVtkb2N1bWVudCBpbmRleEZv clBhZ2U6ZGVzdGluYXRpb24ucGFnZV0sIGRlc3RpbmF0aW9uLnBvaW50LngsIGRlc3RpbmF0aW9u LnBvaW50LnldOworfQorCiAtICh2b2lkKV9kcmF3UERGRG9jdW1lbnQ6KFBERkRvY3VtZW50ICop cGRmRG9jdW1lbnQgcGFnZToodW5zaWduZWQpcGFnZSBhdFBvaW50OihOU1BvaW50KXBvaW50CiB7 CiAgICAgaWYgKCFwZGZEb2N1bWVudCkgewpAQCAtNDU2LDYgKzQ2MSwxMSBAQCBzdGF0aWMgdm9p ZCBwcmVwYXJlRGF0YUZvclByaW50aW5nT25TZWNvbmRhcnlUaHJlYWQoV0tQcmludGluZ1ZpZXcg KnZpZXcpCiAKICAgICBDR0FmZmluZVRyYW5zZm9ybSB0cmFuc2Zvcm0gPSBDR0NvbnRleHRHZXRD VE0oY29udGV4dCk7CiAKKyAgICBmb3IgKGNvbnN0IGF1dG8mIGRlc3RpbmF0aW9uIDogX2xpbmtE ZXN0aW5hdGlvbnNQZXJQYWdlW3BhZ2VdKSB7CisgICAgICAgIENHUG9pbnQgZGVzdGluYXRpb25Q b2ludCA9IENHUG9pbnRBcHBseUFmZmluZVRyYW5zZm9ybShOU1BvaW50VG9DR1BvaW50KFtkZXN0 aW5hdGlvbiBwb2ludF0pLCB0cmFuc2Zvcm0pOworICAgICAgICBDR1BERkNvbnRleHRBZGREZXN0 aW5hdGlvbkF0UG9pbnQoY29udGV4dCwgbGlua0Rlc3RpbmF0aW9uTmFtZShwZGZEb2N1bWVudCwg ZGVzdGluYXRpb24uZ2V0KCkpLCBkZXN0aW5hdGlvblBvaW50KTsKKyAgICB9CisKICAgICBmb3Ig KFBERkFubm90YXRpb24gKmFubm90YXRpb24gaW4gW3BkZlBhZ2UgYW5ub3RhdGlvbnNdKSB7CiAg ICAgICAgIGlmICghW2Fubm90YXRpb24gaXNLaW5kT2ZDbGFzczpwZGZBbm5vdGF0aW9uTGlua0Ns YXNzKCldKQogICAgICAgICAgICAgY29udGludWU7CkBAIC00NjUsOCArNDc1LDE4IEBAIHN0YXRp YyB2b2lkIHByZXBhcmVEYXRhRm9yUHJpbnRpbmdPblNlY29uZGFyeVRocmVhZChXS1ByaW50aW5n VmlldyAqdmlldykKICAgICAgICAgUERGQW5ub3RhdGlvbkxpbmsgKmxpbmtBbm5vdGF0aW9uID0g KFBERkFubm90YXRpb25MaW5rICopYW5ub3RhdGlvbjsKICNwcmFnbWEgY2xhbmcgZGlhZ25vc3Rp YyBwb3AKICAgICAgICAgTlNVUkwgKnVybCA9IFtsaW5rQW5ub3RhdGlvbiBVUkxdOwotICAgICAg ICBpZiAoIXVybCkKKworICAgICAgICBpZiAoIXVybCkgeworICAgICAgICAgICAgUERGRGVzdGlu YXRpb24gKmRlc3RpbmF0aW9uID0gW2xpbmtBbm5vdGF0aW9uIGRlc3RpbmF0aW9uXTsKKyAgICAg ICAgICAgIGlmICghZGVzdGluYXRpb24pCisgICAgICAgICAgICAgICAgY29udGludWU7CisKKyAg ICAgICAgICAgIENHUmVjdCB1cmxSZWN0ID0gTlNSZWN0VG9DR1JlY3QoW2xpbmtBbm5vdGF0aW9u IGJvdW5kc10pOworICAgICAgICAgICAgQ0dSZWN0IHRyYW5zZm9ybWVkUmVjdCA9IENHUmVjdEFw cGx5QWZmaW5lVHJhbnNmb3JtKHVybFJlY3QsIHRyYW5zZm9ybSk7CisgICAgICAgICAgICBDR1BE RkNvbnRleHRTZXREZXN0aW5hdGlvbkZvclJlY3QoY29udGV4dCwgbGlua0Rlc3RpbmF0aW9uTmFt ZShwZGZEb2N1bWVudCwgZGVzdGluYXRpb24pLCB0cmFuc2Zvcm1lZFJlY3QpOworCiAgICAgICAg ICAgICBjb250aW51ZTsKKyAgICAgICAgfQogCiAgICAgICAgIENHUmVjdCB1cmxSZWN0ID0gTlNS ZWN0VG9DR1JlY3QoW2xpbmtBbm5vdGF0aW9uIGJvdW5kc10pOwogICAgICAgICBDR1JlY3QgdHJh bnNmb3JtZWRSZWN0ID0gQ0dSZWN0QXBwbHlBZmZpbmVUcmFuc2Zvcm0odXJsUmVjdCwgdHJhbnNm b3JtKTsKQEAgLTU0OSw2ICs1NjksMzEgQEAgc3RhdGljIHZvaWQgcHJlcGFyZURhdGFGb3JQcmlu dGluZ09uU2Vjb25kYXJ5VGhyZWFkKFdLUHJpbnRpbmdWaWV3ICp2aWV3KQogICAgIGlmICghX3By aW50ZWRQYWdlc1BERkRvY3VtZW50KSB7CiAgICAgICAgIFJldGFpblB0cjxOU0RhdGE+IHBkZkRh dGEgPSBhZG9wdE5TKFtbTlNEYXRhIGFsbG9jXSBpbml0V2l0aEJ5dGVzOl9wcmludGVkUGFnZXNE YXRhLmRhdGEoKSBsZW5ndGg6X3ByaW50ZWRQYWdlc0RhdGEuc2l6ZSgpXSk7CiAgICAgICAgIF9w cmludGVkUGFnZXNQREZEb2N1bWVudCA9IGFkb3B0TlMoW1twZGZEb2N1bWVudENsYXNzKCkgYWxs b2NdIGluaXRXaXRoRGF0YTpwZGZEYXRhLmdldCgpXSk7CisKKyAgICAgICAgdW5zaWduZWQgcGFn ZUNvdW50ID0gW19wcmludGVkUGFnZXNQREZEb2N1bWVudCBwYWdlQ291bnRdOworICAgICAgICBf bGlua0Rlc3RpbmF0aW9uc1BlclBhZ2UuY2xlYXIoKTsKKyAgICAgICAgX2xpbmtEZXN0aW5hdGlv bnNQZXJQYWdlLnJlc2l6ZShwYWdlQ291bnQpOworICAgICAgICBmb3IgKHVuc2lnbmVkIGkgPSAw OyBpIDwgcGFnZUNvdW50OyBpKyspIHsKKyAgICAgICAgICAgIFBERlBhZ2UgKnBhZ2UgPSBbX3By aW50ZWRQYWdlc1BERkRvY3VtZW50IHBhZ2VBdEluZGV4OmldOworICAgICAgICAgICAgZm9yIChQ REZBbm5vdGF0aW9uICphbm5vdGF0aW9uIGluIHBhZ2UuYW5ub3RhdGlvbnMpIHsKKyAgICAgICAg ICAgICAgICBpZiAoIVthbm5vdGF0aW9uIGlzS2luZE9mQ2xhc3M6cGRmQW5ub3RhdGlvbkxpbmtD bGFzcygpXSkKKyAgICAgICAgICAgICAgICAgICAgY29udGludWU7CisKKyNwcmFnbWEgY2xhbmcg ZGlhZ25vc3RpYyBwdXNoCisjcHJhZ21hIGNsYW5nIGRpYWdub3N0aWMgaWdub3JlZCAiLVdkZXBy ZWNhdGVkLWRlY2xhcmF0aW9ucyIKKyAgICAgICAgICAgICAgICBQREZBbm5vdGF0aW9uTGluayAq bGlua0Fubm90YXRpb24gPSAoUERGQW5ub3RhdGlvbkxpbmsgKilhbm5vdGF0aW9uOworI3ByYWdt YSBjbGFuZyBkaWFnbm9zdGljIHBvcAorICAgICAgICAgICAgICAgIGlmIChsaW5rQW5ub3RhdGlv bi5VUkwpCisgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAgICAgICAgICAg UERGRGVzdGluYXRpb24gKmRlc3RpbmF0aW9uID0gbGlua0Fubm90YXRpb24uZGVzdGluYXRpb247 CisgICAgICAgICAgICAgICAgaWYgKCFkZXN0aW5hdGlvbikKKyAgICAgICAgICAgICAgICAgICAg Y29udGludWU7CisKKyAgICAgICAgICAgICAgICB1bnNpZ25lZCBkZXN0aW5hdGlvblBhZ2VJbmRl eCA9IFtfcHJpbnRlZFBhZ2VzUERGRG9jdW1lbnQgaW5kZXhGb3JQYWdlOmRlc3RpbmF0aW9uLnBh Z2VdOworICAgICAgICAgICAgICAgIF9saW5rRGVzdGluYXRpb25zUGVyUGFnZVtkZXN0aW5hdGlv blBhZ2VJbmRleF0uYXBwZW5kKGRlc3RpbmF0aW9uKTsKKyAgICAgICAgICAgIH0KKyAgICAgICAg fQogICAgIH0KIAogICAgIHVuc2lnbmVkIHByaW50ZWRQYWdlTnVtYmVyID0gW3NlbGYgX3BhZ2VG b3JSZWN0Om5zUmVjdF0gLSBbc2VsZiBfZmlyc3RQcmludGVkUGFnZU51bWJlcl07Cg== 293732 2016-11-02 18:41:16 -0700 2016-11-03 13:05:03 -0700 Patch bug-112081-20161102183716.patch text/plain 16866 thorton U3VidmVyc2lvbiBSZXZpc2lvbjogMjA4Mjk0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjE3YTU0OWFjMjVlZWI3 OGJhMzhkNmY5YzBhNTk3ZDVhN2JkMTQ1Ni4uMWRkNjkxMjIwYWNjM2UxNmI0ZTllMmI0ODI5ZTQ2 ZTg1OTEzYjE1YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM5IEBACisyMDE2LTExLTAyICBUaW0g SG9ydG9uICA8dGltb3RoeV9ob3J0b25AYXBwbGUuY29tPgorCisgICAgICAgIFByaW50aW5nIHRv IFBERiBzaG91bGQgcHJvZHVjZSBpbnRlcm5hbCBsaW5rcyB3aGVuIEhUTUwgaGFzIGludGVybmFs IGxpbmtzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x MTIwODEKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzU5NTU3MDU+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisgICAgICAgIFBhdGNoIG9yaWdpbmFsbHkgYnkgRGF2aWQg TGF0dGltb3JlLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cywgYXMgaXQncyB1bmNsZWFyIGhvdyB0 byB0ZXN0IFBERiBvdXRwdXQuCisKKyAgICAgICAgKiBwYWdlL1ByaW50Q29udGV4dC5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpQcmludENvbnRleHQ6OlByaW50Q29udGV4dCk6CisgICAgICAgIChX ZWJDb3JlOjpQcmludENvbnRleHQ6OnNwb29sUGFnZSk6CisgICAgICAgIChXZWJDb3JlOjpQcmlu dENvbnRleHQ6OnNwb29sUmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpQcmludENvbnRleHQ6OmVu ZCk6CisgICAgICAgIChXZWJDb3JlOjpQcmludENvbnRleHQ6OmNvbGxlY3RMaW5rZWREZXN0aW5h dGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6UHJpbnRDb250ZXh0OjpvdXRwdXRMaW5rZWREZXN0 aW5hdGlvbnMpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3BwOgorICAgICAg ICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjphZGRQREZVUkxSZWN0KToKKyAgICAgICAgUGx1bWIg aW50ZXJuYWwgbGlua3MgKGZyYWdtZW50IGxpbmtzKSB0aHJvdWdoIHRvIEdyYXBoaWNzQ29udGV4 dCwgdXNpbmcKKyAgICAgICAgdGhlIGZyYWdtZW50IG5hbWUgZnJvbSB0aGUgcGFnZS4KKworICAg ICAgICAqIHBhZ2UvUHJpbnRDb250ZXh0Lmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3Mv R3JhcGhpY3NDb250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDo6 c3VwcG9ydHNJbnRlcm5hbExpbmtzKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4 dDo6c2V0RGVzdGluYXRpb25Gb3JSZWN0KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29u dGV4dDo6YWRkRGVzdGluYXRpb25BdFBvaW50KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGlj cy9HcmFwaGljc0NvbnRleHQuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jZy9HcmFw aGljc0NvbnRleHRDRy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6OnN1 cHBvcnRzSW50ZXJuYWxMaW5rcyk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6 OnNldERlc3RpbmF0aW9uRm9yUmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRl eHQ6OmFkZERlc3RpbmF0aW9uQXRQb2ludCk6CisgICAgICAgIFBsdW1iIGludGVybmFsIGxpbmtz IHRocm91Z2ggdG8gdGhlIENHQ29udGV4dC4gQXBwbHkgdGhlIENUTSwgYmVjYXVzZQorICAgICAg ICB0aGVzZSBmdW5jdGlvbnMgZXhwZWN0IHBvc2l0aW9ucyBpbiBnbG9iYWwgY29vcmRpbmF0ZXMu CisKIDIwMTYtMTEtMDEgIERlYW4gSmFja3NvbiAgPGRpbm9AYXBwbGUuY29tPgogCiAgICAgICAg IEZpbHRlciBmdW5jdGlvbnMgZ3JheXNjYWxlL2ludmVydC9vcGFjaXR5L3NlcGlhIHNob3VsZCBj bGFtcCB2YWx1ZXMgb3ZlciAxMDAlLCBub3QgZmFpbApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dDIvQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IDA3ZTc2Y2I5ZjRl OTU5ZjZlMWFhNTAxNTJlODBmOWM3NDAxM2Y5NmQuLjkyYTE2ODY0ZTY2MTI2MjIyNzY0YjA3ODNl OTI3YzZiNjM4NGFjNDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysg Yi9Tb3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAxNi0xMS0wMiAg VGltIEhvcnRvbiAgPHRpbW90aHlfaG9ydG9uQGFwcGxlLmNvbT4KKworICAgICAgICBQcmludGlu ZyB0byBQREYgc2hvdWxkIHByb2R1Y2UgaW50ZXJuYWwgbGlua3Mgd2hlbiBIVE1MIGhhcyBpbnRl cm5hbCBsaW5rcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MTEyMDgxCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS81OTU1NzA1PgorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogVUlQcm9jZXNzL21hYy9XS1By aW50aW5nVmlldy5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9tYWMvV0tQcmludGluZ1ZpZXcubW06 CisgICAgICAgIChsaW5rRGVzdGluYXRpb25OYW1lKToKKyAgICAgICAgKC1bV0tQcmludGluZ1Zp ZXcgX2RyYXdQREZEb2N1bWVudDpwYWdlOmF0UG9pbnQ6XSk6CisgICAgICAgIFByb3BhZ2F0ZSBs aW5rLXRvLWRlc3RpbmF0aW9uIGFubm90YXRpb25zIChhbmQgZWFjaCBwYWdlJ3MgZGVzdGluYXRp b25zKQorICAgICAgICBpbnRvIHRoZSBwcmludGVkIFBERi4KKyAgICAgICAgR2VuZXJhdGUgYSB1 bmlxdWUgZGVzdGluYXRpb24gbmFtZSBiYXNlZCBvbiB0aGUgcGFnZSBhbmQgcG9zaXRpb24sIGJl Y2F1c2UKKyAgICAgICAgd2UgaGF2ZSBsb3N0IHRoZSBmcmFnbWVudCBuYW1lIGluZm9ybWF0aW9u LgorCisgICAgICAgICgtW1dLUHJpbnRpbmdWaWV3IGRyYXdSZWN0Ol0pOgorICAgICAgICBDb21w dXRlIGFsbCBvZiB0aGUgZGVzdGluYXRpb25zIGZvciBldmVyeSBwYWdlLCBzbyB0aGF0IHdlIGNh biBhZGQgdGhlbQorICAgICAgICB0byB0aGUgY29udGV4dCBhcyB3ZSBwYWludCB0aGUgcGFnZXMg KHdlIG5lZWQgdGhlIHBhZ2UgQ1RNIGluIG9yZGVyIHRvIGFkZCB0aGVtKS4KKwogMjAxNi0xMS0w MiAgQ2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CiAKICAgICAgICAg TmV0d29ya1Nlc3Npb246IE5ldHdvcmsgcHJvY2VzcyBjcmFzaCB3aGVuIGNvbnZlcnRpbmcgbWFp biByZXNvdXJjZSB0byBkb3dubG9hZApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGFnZS9Q cmludENvbnRleHQuY3BwIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QcmludENvbnRleHQuY3BwCmlu ZGV4IDU0ZGVhMzZmOTJhZWEwZmQzZGM1MTVhZTk5ZDAyZWQyZWFlM2Y0MjkuLjUwNTljNWM0YjE3 YWI0MmQ1M2JmMjQ3Mzg3ZjU3ODEyZWJlZmU2NGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BhZ2UvUHJpbnRDb250ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1ByaW50Q29u dGV4dC5jcHAKQEAgLTI0LDYgKzI0LDcgQEAKICNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQuaCIK ICNpbmNsdWRlICJGcmFtZS5oIgogI2luY2x1ZGUgIkZyYW1lVmlldy5oIgorI2luY2x1ZGUgIkhU TUxOYW1lcy5oIgogI2luY2x1ZGUgIlJlbmRlclZpZXcuaCIKICNpbmNsdWRlICJTdHlsZUluaGVy aXRlZERhdGEuaCIKICNpbmNsdWRlICJTdHlsZVJlc29sdmVyLmgiCkBAIC0zNCw3ICszNSw2IEBA IG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogUHJpbnRDb250ZXh0OjpQcmludENvbnRleHQoRnJhbWUq IGZyYW1lKQogICAgIDogbV9mcmFtZShmcmFtZSkKLSAgICAsIG1faXNQcmludGluZyhmYWxzZSkK IHsKIH0KIApAQCAtMTkwLDYgKzE5MCw3IEBAIHZvaWQgUHJpbnRDb250ZXh0OjpzcG9vbFBhZ2Uo R3JhcGhpY3NDb250ZXh0JiBjdHgsIGludCBwYWdlTnVtYmVyLCBmbG9hdCB3aWR0aCkKICAgICBj dHgudHJhbnNsYXRlKC1wYWdlUmVjdC54KCksIC1wYWdlUmVjdC55KCkpOwogICAgIGN0eC5jbGlw KHBhZ2VSZWN0KTsKICAgICBtX2ZyYW1lLT52aWV3KCktPnBhaW50Q29udGVudHMoY3R4LCBwYWdl UmVjdCk7CisgICAgb3V0cHV0TGlua2VkRGVzdGluYXRpb25zKGN0eCwgbV9mcmFtZS0+ZG9jdW1l bnQoKSwgcGFnZVJlY3QpOwogICAgIGN0eC5yZXN0b3JlKCk7CiB9CiAKQEAgLTIwMCw2ICsyMDEs NyBAQCB2b2lkIFByaW50Q29udGV4dDo6c3Bvb2xSZWN0KEdyYXBoaWNzQ29udGV4dCYgY3R4LCBj b25zdCBJbnRSZWN0JiByZWN0KQogICAgIGN0eC50cmFuc2xhdGUoLXJlY3QueCgpLCAtcmVjdC55 KCkpOwogICAgIGN0eC5jbGlwKHJlY3QpOwogICAgIG1fZnJhbWUtPnZpZXcoKS0+cGFpbnRDb250 ZW50cyhjdHgsIHJlY3QpOworICAgIG91dHB1dExpbmtlZERlc3RpbmF0aW9ucyhjdHgsIG1fZnJh bWUtPmRvY3VtZW50KCksIHJlY3QpOwogICAgIGN0eC5yZXN0b3JlKCk7CiB9CiAKQEAgLTIwOCw2 ICsyMTAsNyBAQCB2b2lkIFByaW50Q29udGV4dDo6ZW5kKCkKICAgICBBU1NFUlQobV9pc1ByaW50 aW5nKTsKICAgICBtX2lzUHJpbnRpbmcgPSBmYWxzZTsKICAgICBtX2ZyYW1lLT5zZXRQcmludGlu ZyhmYWxzZSwgRmxvYXRTaXplKCksIEZsb2F0U2l6ZSgpLCAwLCBBZGp1c3RWaWV3U2l6ZSk7Cisg ICAgbV9saW5rZWREZXN0aW5hdGlvbnMgPSBOdWxsb3B0OwogfQogCiBzdGF0aWMgaW5saW5lIFJl bmRlckJveE1vZGVsT2JqZWN0KiBlbmNsb3NpbmdCb3hNb2RlbE9iamVjdChSZW5kZXJFbGVtZW50 KiByZW5kZXJlcikKQEAgLTI0Niw2ICsyNDksNTQgQEAgaW50IFByaW50Q29udGV4dDo6cGFnZU51 bWJlckZvckVsZW1lbnQoRWxlbWVudCogZWxlbWVudCwgY29uc3QgRmxvYXRTaXplJiBwYWdlU2kK ICAgICByZXR1cm4gLTE7CiB9CiAKK3ZvaWQgUHJpbnRDb250ZXh0Ojpjb2xsZWN0TGlua2VkRGVz dGluYXRpb25zKE5vZGUqIG5vZGUpCit7CisgICAgZm9yIChOb2RlKiBjaGlsZCA9IG5vZGUtPmZp cnN0Q2hpbGQoKTsgY2hpbGQ7IGNoaWxkID0gY2hpbGQtPm5leHRTaWJsaW5nKCkpCisgICAgICAg IGNvbGxlY3RMaW5rZWREZXN0aW5hdGlvbnMoY2hpbGQpOworCisgICAgaWYgKCFub2RlLT5pc0xp bmsoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKCFpczxFbGVtZW50Pihub2RlKSkKKyAg ICAgICAgcmV0dXJuOworCisgICAgY29uc3QgQXRvbWljU3RyaW5nJiBocmVmID0gZG93bmNhc3Q8 RWxlbWVudD4obm9kZSktPmdldEF0dHJpYnV0ZShIVE1MTmFtZXM6OmhyZWZBdHRyKTsKKyAgICBp ZiAoaHJlZi5pc051bGwoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgRG9jdW1lbnQmIGRvY3Vt ZW50ID0gbm9kZS0+ZG9jdW1lbnQoKTsKKyAgICBVUkwgdXJsID0gZG9jdW1lbnQuY29tcGxldGVV UkwoaHJlZik7CisgICAgaWYgKCF1cmwuaXNWYWxpZCgpKQorICAgICAgICByZXR1cm47CisKKyAg ICBpZiAodXJsLmhhc0ZyYWdtZW50SWRlbnRpZmllcigpICYmIGVxdWFsSWdub3JpbmdGcmFnbWVu dElkZW50aWZpZXIodXJsLCBkb2N1bWVudC5iYXNlVVJMKCkpKSB7CisgICAgICAgIFN0cmluZyBu YW1lID0gdXJsLmZyYWdtZW50SWRlbnRpZmllcigpOworICAgICAgICBpZiAoRWxlbWVudCogZWxl bWVudCA9IGRvY3VtZW50LmZpbmRBbmNob3IobmFtZSkpCisgICAgICAgICAgICBtX2xpbmtlZERl c3RpbmF0aW9ucy0+c2V0KG5hbWUsIGVsZW1lbnQpOworICAgIH0KK30KKwordm9pZCBQcmludENv bnRleHQ6Om91dHB1dExpbmtlZERlc3RpbmF0aW9ucyhHcmFwaGljc0NvbnRleHQmIGdyYXBoaWNz Q29udGV4dCwgTm9kZSogbm9kZSwgY29uc3QgSW50UmVjdCYgcGFnZVJlY3QpCit7CisgICAgaWYg KCFncmFwaGljc0NvbnRleHQuc3VwcG9ydHNJbnRlcm5hbExpbmtzKCkpCisgICAgICAgIHJldHVy bjsKKworICAgIGlmICghbV9saW5rZWREZXN0aW5hdGlvbnMpIHsKKyAgICAgICAgbV9saW5rZWRE ZXN0aW5hdGlvbnMgPSBIYXNoTWFwPFN0cmluZywgRWxlbWVudCo+IHsgfTsKKyAgICAgICAgY29s bGVjdExpbmtlZERlc3RpbmF0aW9ucyhub2RlKTsKKyAgICB9CisKKyAgICBmb3IgKGNvbnN0IGF1 dG8mIGl0IDogKm1fbGlua2VkRGVzdGluYXRpb25zKSB7CisgICAgICAgIEludFJlY3QgYm91bmRp bmdCb3ggPSBpdC52YWx1ZS0+cmVuZGVyZXIoKS0+YWJzb2x1dGVCb3VuZGluZ0JveFJlY3QoKTsK KyAgICAgICAgaWYgKCFwYWdlUmVjdC5pbnRlcnNlY3RzKGJvdW5kaW5nQm94KSkKKyAgICAgICAg ICAgIGNvbnRpbnVlOworCisgICAgICAgIEludFBvaW50IHBvaW50ID0gYm91bmRpbmdCb3gubWlu WE1pbllDb3JuZXIoKTsKKyAgICAgICAgcG9pbnQuY2xhbXBOZWdhdGl2ZVRvWmVybygpOworICAg ICAgICBncmFwaGljc0NvbnRleHQuYWRkRGVzdGluYXRpb25BdFBvaW50KGl0LmtleSwgcG9pbnQp OworICAgIH0KK30KKwogU3RyaW5nIFByaW50Q29udGV4dDo6cGFnZVByb3BlcnR5KEZyYW1lKiBm cmFtZSwgY29uc3QgY2hhciogcHJvcGVydHlOYW1lLCBpbnQgcGFnZU51bWJlcikKIHsKICAgICBE b2N1bWVudCogZG9jdW1lbnQgPSBmcmFtZS0+ZG9jdW1lbnQoKTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJDb3JlL3BhZ2UvUHJpbnRDb250ZXh0LmggYi9Tb3VyY2UvV2ViQ29yZS9wYWdlL1ByaW50 Q29udGV4dC5oCmluZGV4IDlmYzY2ZDNkYTkxMGUwNTA4OWY1NTdhZTM2ZjkxMjMwOTU3NGJkMGEu LmFjMGQzN2I3NDlkM2Y0Njc2ODg1YmE5Mzg4MjI4NDVhN2E5YjgwN2EgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BhZ2UvUHJpbnRDb250ZXh0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGFn ZS9QcmludENvbnRleHQuaApAQCAtMjEsNyArMjEsOSBAQAogI3ByYWdtYSBvbmNlCiAKICNpbmNs dWRlIDx3dGYvRm9yd2FyZC5oPgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CiAjaW5jbHVkZSA8 d3RmL1ZlY3Rvci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgogCiBuYW1lc3Bh Y2UgV2ViQ29yZSB7CiAKQEAgLTMxLDYgKzMzLDcgQEAgY2xhc3MgRmxvYXRSZWN0OwogY2xhc3Mg RmxvYXRTaXplOwogY2xhc3MgR3JhcGhpY3NDb250ZXh0OwogY2xhc3MgSW50UmVjdDsKK2NsYXNz IE5vZGU7CiAKIGNsYXNzIFByaW50Q29udGV4dCB7CiBwdWJsaWM6CkBAIC05OCw5ICsxMDEsMTMg QEAgcHJvdGVjdGVkOgogcHJpdmF0ZToKICAgICB2b2lkIGNvbXB1dGVQYWdlUmVjdHNXaXRoUGFn ZVNpemVJbnRlcm5hbChjb25zdCBGbG9hdFNpemUmIHBhZ2VTaXplSW5QaXhlbHMsIGJvb2wgYWxs b3dIb3Jpem9udGFsVGlsaW5nKTsKICAgICBib29sIGJlZ2luQW5kQ29tcHV0ZVBhZ2VSZWN0c1dp dGhQYWdlU2l6ZShGcmFtZSYsIGNvbnN0IEZsb2F0U2l6ZSYgcGFnZVNpemVJblBpeGVscyk7Cisg ICAgdm9pZCBjb2xsZWN0TGlua2VkRGVzdGluYXRpb25zKE5vZGUqKTsKKyAgICB2b2lkIG91dHB1 dExpbmtlZERlc3RpbmF0aW9ucyhHcmFwaGljc0NvbnRleHQmLCBOb2RlKiwgY29uc3QgSW50UmVj dCYgcGFnZVJlY3QpOwogCiAgICAgLy8gVXNlZCB0byBwcmV2ZW50IG1pc3VzZXMgb2YgYmVnaW4o KSBhbmQgZW5kKCkgKGUuZy4sIGNhbGwgZW5kIHdpdGhvdXQgYmVnaW4pLgotICAgIGJvb2wgbV9p c1ByaW50aW5nOworICAgIGJvb2wgbV9pc1ByaW50aW5nIHsgZmFsc2UgfTsKKworICAgIE9wdGlv bmFsPEhhc2hNYXA8U3RyaW5nLCBFbGVtZW50Kj4+IG1fbGlua2VkRGVzdGluYXRpb25zOwogfTsK IAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5jcHAKaW5kZXggODhiN2Y1YjkxNWU0N2M1ODFh NzI4ZDY1ZWQzMzBiMTdmZTU4MWQzOS4uYmM1ZDI5ZDBjNDBkMmQwYTI3ZTE5YWYyMGYyZWY1NTYy MWVhMDk1YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3Jh cGhpY3NDb250ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9H cmFwaGljc0NvbnRleHQuY3BwCkBAIC0xMTc3LDQgKzExNzcsMTkgQEAgVmVjdG9yPEZsb2F0UG9p bnQ+IEdyYXBoaWNzQ29udGV4dDo6Y2VudGVyTGluZUFuZEN1dE9mZkNvcm5lcnMoYm9vbCBpc1Zl cnRpY2FsTGkKICAgICByZXR1cm4geyBwb2ludDEsIHBvaW50MiB9OwogfQogCisjaWYgIVVTRShD RykKK2Jvb2wgR3JhcGhpY3NDb250ZXh0OjpzdXBwb3J0c0ludGVybmFsTGlua3MoKQoreworICAg IHJldHVybiBmYWxzZTsKK30KKwordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldERlc3RpbmF0aW9u Rm9yUmVjdChjb25zdCBTdHJpbmcmLCBjb25zdCBJbnRSZWN0JikKK3sKK30KKwordm9pZCBHcmFw aGljc0NvbnRleHQ6OmFkZERlc3RpbmF0aW9uQXRQb2ludChjb25zdCBTdHJpbmcmLCBjb25zdCBJ bnRQb2ludCYpCit7Cit9CisjZW5kaWYKKwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuaAppbmRleCA1Njk3YzA5Zjc2ZWQ2M2EwYzlm ODk3ZTkwMTU1MTlkNTA3ODJjNDQxLi40NTJhN2U5Njc5YjRkYTU4YTU2OWU2MmE2MWRlOTI3OTQ2 ZjkyOGEyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFw aGljc0NvbnRleHQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9HcmFw aGljc0NvbnRleHQuaApAQCAtNDcwLDYgKzQ3MCw5IEBAIHB1YmxpYzoKIAogICAgIHZvaWQgc2V0 VVJMRm9yUmVjdChjb25zdCBVUkwmLCBjb25zdCBJbnRSZWN0Jik7CiAKKyAgICB2b2lkIHNldERl c3RpbmF0aW9uRm9yUmVjdChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IEludFJlY3QmKTsKKyAg ICB2b2lkIGFkZERlc3RpbmF0aW9uQXRQb2ludChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IElu dFBvaW50Jik7CisKICAgICB2b2lkIGNvbmNhdENUTShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mKTsK ICAgICB2b2lkIHNldENUTShjb25zdCBBZmZpbmVUcmFuc2Zvcm0mKTsKIApAQCAtNTc2LDYgKzU3 OSw4IEBAIHB1YmxpYzoKIAogICAgIHN0YXRpYyB2b2lkIGFkanVzdExpbmVUb1BpeGVsQm91bmRh cmllcyhGbG9hdFBvaW50JiBwMSwgRmxvYXRQb2ludCYgcDIsIGZsb2F0IHN0cm9rZVdpZHRoLCBT dHJva2VTdHlsZSk7CiAKKyAgICBib29sIHN1cHBvcnRzSW50ZXJuYWxMaW5rcygpOworCiBwcml2 YXRlOgogICAgIHZvaWQgcGxhdGZvcm1Jbml0KFBsYXRmb3JtR3JhcGhpY3NDb250ZXh0Kik7CiAg ICAgdm9pZCBwbGF0Zm9ybURlc3Ryb3koKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2NnL0dyYXBoaWNzQ29udGV4dENHLmNwcCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2NnL0dyYXBoaWNzQ29udGV4dENHLmNwcAppbmRleCBlMDZmNDVk NDkyYzU4OGFiYzJlYjlmNWFmY2QyNDBkMzhlZWM1NTI4Li4zZDU3NTliZTU5OGQxYjQ5ZjMyYmM1 YzY5NDQzMGMyN2Q0MTZjOGQ4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jZy9HcmFwaGljc0NvbnRleHRDRy5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2cvR3JhcGhpY3NDb250ZXh0Q0cuY3BwCkBAIC0xOTAyLDYgKzE5MDIs MzYgQEAgdm9pZCBHcmFwaGljc0NvbnRleHQ6OnBsYXRmb3JtU3Ryb2tlRWxsaXBzZShjb25zdCBG bG9hdFJlY3QmIGVsbGlwc2UpCiAgICAgQ0dDb250ZXh0U3Ryb2tlRWxsaXBzZUluUmVjdChjb250 ZXh0LCBlbGxpcHNlKTsKIH0KIAorYm9vbCBHcmFwaGljc0NvbnRleHQ6OnN1cHBvcnRzSW50ZXJu YWxMaW5rcygpCit7CisgICAgcmV0dXJuIHRydWU7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0 OjpzZXREZXN0aW5hdGlvbkZvclJlY3QoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJbnRSZWN0 JiBkZXN0UmVjdCkKK3sKKyAgICBpZiAocGFpbnRpbmdEaXNhYmxlZCgpKQorICAgICAgICByZXR1 cm47CisKKyAgICBDR0NvbnRleHRSZWYgY29udGV4dCA9IHBsYXRmb3JtQ29udGV4dCgpOworCisg ICAgSW50UmVjdCByZWN0ID0gZGVzdFJlY3Q7CisgICAgcmVjdC5pbnRlcnNlY3QoZW5jbG9zaW5n SW50UmVjdChDR0NvbnRleHRHZXRDbGlwQm91bmRpbmdCb3goY29udGV4dCkpKTsKKworICAgIENH UmVjdCB0cmFuc2Zvcm1lZFJlY3QgPSBDR1JlY3RBcHBseUFmZmluZVRyYW5zZm9ybShyZWN0LCBD R0NvbnRleHRHZXRDVE0oY29udGV4dCkpOworICAgIENHUERGQ29udGV4dFNldERlc3RpbmF0aW9u Rm9yUmVjdChjb250ZXh0LCBuYW1lLmNyZWF0ZUNGU3RyaW5nKCkuZ2V0KCksIHRyYW5zZm9ybWVk UmVjdCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjphZGREZXN0aW5hdGlvbkF0UG9pbnQo Y29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBJbnRQb2ludCYgcG9zaXRpb24pCit7CisgICAgaWYg KHBhaW50aW5nRGlzYWJsZWQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQ0dDb250ZXh0UmVm IGNvbnRleHQgPSBwbGF0Zm9ybUNvbnRleHQoKTsKKworICAgIENHUG9pbnQgdHJhbnNmb3JtZWRQ b2ludCA9IENHUG9pbnRBcHBseUFmZmluZVRyYW5zZm9ybShwb3NpdGlvbiwgQ0dDb250ZXh0R2V0 Q1RNKGNvbnRleHQpKTsKKyAgICBDR1BERkNvbnRleHRBZGREZXN0aW5hdGlvbkF0UG9pbnQoY29u dGV4dCwgbmFtZS5jcmVhdGVDRlN0cmluZygpLmdldCgpLCB0cmFuc2Zvcm1lZFBvaW50KTsKK30K KwogfQogCiAjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3JlbmRlcmluZy9SZW5k ZXJPYmplY3QuY3BwIGIvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAK aW5kZXggMTc3ODQxZTY2NmZkM2VmZTJlOTEwYTBjZTgzYmFkMzFhZWM5NzA0Yi4uNTg2ZDIzMzZm OThlNTIyMGYyOGQzNzcwYzIwMDIyMWNiYWVkMTIxOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcmVuZGVy aW5nL1JlbmRlck9iamVjdC5jcHAKQEAgLTYwNyw3ICs2MDcsMjAgQEAgdm9pZCBSZW5kZXJPYmpl Y3Q6OmFkZFBERlVSTFJlY3QoUGFpbnRJbmZvJiBwYWludEluZm8sIGNvbnN0IExheW91dFBvaW50 JiBwYWludE8KICAgICBjb25zdCBBdG9taWNTdHJpbmcmIGhyZWYgPSBkb3duY2FzdDxFbGVtZW50 Pigqbm9kZSkuZ2V0QXR0cmlidXRlKGhyZWZBdHRyKTsKICAgICBpZiAoaHJlZi5pc051bGwoKSkK ICAgICAgICAgcmV0dXJuOwotICAgIHBhaW50SW5mby5jb250ZXh0KCkuc2V0VVJMRm9yUmVjdChu b2RlLT5kb2N1bWVudCgpLmNvbXBsZXRlVVJMKGhyZWYpLCBzbmFwcGVkSW50UmVjdCh1cmxSZWN0 KSk7CisgICAgCisgICAgRG9jdW1lbnQmIGRvY3VtZW50ID0gbm9kZS0+ZG9jdW1lbnQoKTsKKyAg ICBVUkwgdXJsID0gZG9jdW1lbnQuY29tcGxldGVVUkwoaHJlZik7CisgICAgaWYgKCF1cmwuaXNW YWxpZCgpKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAocGFpbnRJbmZvLmNvbnRleHQoKS5z dXBwb3J0c0ludGVybmFsTGlua3MoKSAmJiB1cmwuaGFzRnJhZ21lbnRJZGVudGlmaWVyKCkgJiYg ZXF1YWxJZ25vcmluZ0ZyYWdtZW50SWRlbnRpZmllcih1cmwsIGRvY3VtZW50LmJhc2VVUkwoKSkp IHsKKyAgICAgICAgU3RyaW5nIG5hbWUgPSB1cmwuZnJhZ21lbnRJZGVudGlmaWVyKCk7CisgICAg ICAgIGlmIChkb2N1bWVudC5maW5kQW5jaG9yKG5hbWUpKQorICAgICAgICAgICAgcGFpbnRJbmZv LmNvbnRleHQoKS5zZXREZXN0aW5hdGlvbkZvclJlY3QobmFtZSwgc25hcHBlZEludFJlY3QodXJs UmVjdCkpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgcGFpbnRJbmZvLmNvbnRleHQo KS5zZXRVUkxGb3JSZWN0KHVybCwgc25hcHBlZEludFJlY3QodXJsUmVjdCkpOwogfQogCiAjaWYg UExBVEZPUk0oSU9TKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL21hYy9X S1ByaW50aW5nVmlldy5oIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL21hYy9XS1ByaW50aW5n Vmlldy5oCmluZGV4IDNiOGI4ZDI4OTVkNTQ0Yjc5ZGUzN2ZkYThmMzdhMjRkOWRjYjkxOTguLjNm MmZlOTM5MTc1Y2EzZmVlMDcwODE5OTZjMjU2ZDQ1N2VkZDI5YWUgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQyL1VJUHJvY2Vzcy9tYWMvV0tQcmludGluZ1ZpZXcuaAorKysgYi9Tb3VyY2UvV2Vi S2l0Mi9VSVByb2Nlc3MvbWFjL1dLUHJpbnRpbmdWaWV3LmgKQEAgLTMzLDYgKzMzLDcgQEAKICNp bXBvcnQgPHd0Zi9WZWN0b3IuaD4KIAogQGNsYXNzIFdLUHJpbnRpbmdWaWV3RGF0YTsKK0BjbGFz cyBQREZEZXN0aW5hdGlvbjsKIEBjbGFzcyBQREZEb2N1bWVudDsKIAogbmFtZXNwYWNlIFdlYktp dCB7CkBAIC01Miw2ICs1Myw3IEBAIGNsYXNzIFdlYkZyYW1lUHJveHk7CiAKICAgICBWZWN0b3I8 dWludDhfdD4gX3ByaW50ZWRQYWdlc0RhdGE7CiAgICAgUmV0YWluUHRyPFBERkRvY3VtZW50PiBf cHJpbnRlZFBhZ2VzUERGRG9jdW1lbnQ7CisgICAgVmVjdG9yPFZlY3RvcjxSZXRhaW5QdHI8UERG RGVzdGluYXRpb24+Pj4gX2xpbmtEZXN0aW5hdGlvbnNQZXJQYWdlOwogCiAgICAgdWludDY0X3Qg X2V4cGVjdGVkQ29tcHV0ZWRQYWdlc0NhbGxiYWNrOwogICAgIEhhc2hNYXA8dWludDY0X3QsIFdl YkNvcmU6OkludFJlY3Q+IF9leHBlY3RlZFByZXZpZXdDYWxsYmFja3M7CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbWFjL1dLUHJpbnRpbmdWaWV3Lm1tIGIvU291cmNlL1dl YktpdDIvVUlQcm9jZXNzL21hYy9XS1ByaW50aW5nVmlldy5tbQppbmRleCAzYjEwY2U3NWYxNWVj NmIzOWYxMWU2MGE0NjFiODZjZjc4NWFlNDRmLi4wYTk1MDY4ZjAwNmEyYWM5NjYzYzI2ZTczNGU4 NWRiMGFjZjllN2RjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbWFjL1dL UHJpbnRpbmdWaWV3Lm1tCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9tYWMvV0tQcmlu dGluZ1ZpZXcubW0KQEAgLTQyNyw2ICs0MjcsMTEgQEAgc3RhdGljIHZvaWQgcHJlcGFyZURhdGFG b3JQcmludGluZ09uU2Vjb25kYXJ5VGhyZWFkKFdLUHJpbnRpbmdWaWV3ICp2aWV3KQogICAgIHJl dHVybiAwOyAvLyBJbnZhbGlkIHBhZ2UgbnVtYmVyLgogfQogCitzdGF0aWMgQ0ZTdHJpbmdSZWYg bGlua0Rlc3RpbmF0aW9uTmFtZShQREZEb2N1bWVudCAqZG9jdW1lbnQsIFBERkRlc3RpbmF0aW9u ICpkZXN0aW5hdGlvbikKK3sKKyAgICByZXR1cm4gKENGU3RyaW5nUmVmKVtOU1N0cmluZyBzdHJp bmdXaXRoRm9ybWF0OkAiJWx1LSVmLSVmIiwgKHVuc2lnbmVkIGxvbmcpW2RvY3VtZW50IGluZGV4 Rm9yUGFnZTpkZXN0aW5hdGlvbi5wYWdlXSwgZGVzdGluYXRpb24ucG9pbnQueCwgZGVzdGluYXRp b24ucG9pbnQueV07Cit9CisKIC0gKHZvaWQpX2RyYXdQREZEb2N1bWVudDooUERGRG9jdW1lbnQg KilwZGZEb2N1bWVudCBwYWdlOih1bnNpZ25lZClwYWdlIGF0UG9pbnQ6KE5TUG9pbnQpcG9pbnQK IHsKICAgICBpZiAoIXBkZkRvY3VtZW50KSB7CkBAIC00NTYsNiArNDYxLDExIEBAIHN0YXRpYyB2 b2lkIHByZXBhcmVEYXRhRm9yUHJpbnRpbmdPblNlY29uZGFyeVRocmVhZChXS1ByaW50aW5nVmll dyAqdmlldykKIAogICAgIENHQWZmaW5lVHJhbnNmb3JtIHRyYW5zZm9ybSA9IENHQ29udGV4dEdl dENUTShjb250ZXh0KTsKIAorICAgIGZvciAoY29uc3QgYXV0byYgZGVzdGluYXRpb24gOiBfbGlu a0Rlc3RpbmF0aW9uc1BlclBhZ2VbcGFnZV0pIHsKKyAgICAgICAgQ0dQb2ludCBkZXN0aW5hdGlv blBvaW50ID0gQ0dQb2ludEFwcGx5QWZmaW5lVHJhbnNmb3JtKE5TUG9pbnRUb0NHUG9pbnQoW2Rl c3RpbmF0aW9uIHBvaW50XSksIHRyYW5zZm9ybSk7CisgICAgICAgIENHUERGQ29udGV4dEFkZERl c3RpbmF0aW9uQXRQb2ludChjb250ZXh0LCBsaW5rRGVzdGluYXRpb25OYW1lKHBkZkRvY3VtZW50 LCBkZXN0aW5hdGlvbi5nZXQoKSksIGRlc3RpbmF0aW9uUG9pbnQpOworICAgIH0KKwogICAgIGZv ciAoUERGQW5ub3RhdGlvbiAqYW5ub3RhdGlvbiBpbiBbcGRmUGFnZSBhbm5vdGF0aW9uc10pIHsK ICAgICAgICAgaWYgKCFbYW5ub3RhdGlvbiBpc0tpbmRPZkNsYXNzOnBkZkFubm90YXRpb25MaW5r Q2xhc3MoKV0pCiAgICAgICAgICAgICBjb250aW51ZTsKQEAgLTQ2NSw4ICs0NzUsMTggQEAgc3Rh dGljIHZvaWQgcHJlcGFyZURhdGFGb3JQcmludGluZ09uU2Vjb25kYXJ5VGhyZWFkKFdLUHJpbnRp bmdWaWV3ICp2aWV3KQogICAgICAgICBQREZBbm5vdGF0aW9uTGluayAqbGlua0Fubm90YXRpb24g PSAoUERGQW5ub3RhdGlvbkxpbmsgKilhbm5vdGF0aW9uOwogI3ByYWdtYSBjbGFuZyBkaWFnbm9z dGljIHBvcAogICAgICAgICBOU1VSTCAqdXJsID0gW2xpbmtBbm5vdGF0aW9uIFVSTF07Ci0gICAg ICAgIGlmICghdXJsKQorCisgICAgICAgIGlmICghdXJsKSB7CisgICAgICAgICAgICBQREZEZXN0 aW5hdGlvbiAqZGVzdGluYXRpb24gPSBbbGlua0Fubm90YXRpb24gZGVzdGluYXRpb25dOworICAg ICAgICAgICAgaWYgKCFkZXN0aW5hdGlvbikKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKwor ICAgICAgICAgICAgQ0dSZWN0IHVybFJlY3QgPSBOU1JlY3RUb0NHUmVjdChbbGlua0Fubm90YXRp b24gYm91bmRzXSk7CisgICAgICAgICAgICBDR1JlY3QgdHJhbnNmb3JtZWRSZWN0ID0gQ0dSZWN0 QXBwbHlBZmZpbmVUcmFuc2Zvcm0odXJsUmVjdCwgdHJhbnNmb3JtKTsKKyAgICAgICAgICAgIENH UERGQ29udGV4dFNldERlc3RpbmF0aW9uRm9yUmVjdChjb250ZXh0LCBsaW5rRGVzdGluYXRpb25O YW1lKHBkZkRvY3VtZW50LCBkZXN0aW5hdGlvbiksIHRyYW5zZm9ybWVkUmVjdCk7CisKICAgICAg ICAgICAgIGNvbnRpbnVlOworICAgICAgICB9CiAKICAgICAgICAgQ0dSZWN0IHVybFJlY3QgPSBO U1JlY3RUb0NHUmVjdChbbGlua0Fubm90YXRpb24gYm91bmRzXSk7CiAgICAgICAgIENHUmVjdCB0 cmFuc2Zvcm1lZFJlY3QgPSBDR1JlY3RBcHBseUFmZmluZVRyYW5zZm9ybSh1cmxSZWN0LCB0cmFu c2Zvcm0pOwpAQCAtNTQ5LDYgKzU2OSwzMSBAQCBzdGF0aWMgdm9pZCBwcmVwYXJlRGF0YUZvclBy aW50aW5nT25TZWNvbmRhcnlUaHJlYWQoV0tQcmludGluZ1ZpZXcgKnZpZXcpCiAgICAgaWYgKCFf cHJpbnRlZFBhZ2VzUERGRG9jdW1lbnQpIHsKICAgICAgICAgUmV0YWluUHRyPE5TRGF0YT4gcGRm RGF0YSA9IGFkb3B0TlMoW1tOU0RhdGEgYWxsb2NdIGluaXRXaXRoQnl0ZXM6X3ByaW50ZWRQYWdl c0RhdGEuZGF0YSgpIGxlbmd0aDpfcHJpbnRlZFBhZ2VzRGF0YS5zaXplKCldKTsKICAgICAgICAg X3ByaW50ZWRQYWdlc1BERkRvY3VtZW50ID0gYWRvcHROUyhbW3BkZkRvY3VtZW50Q2xhc3MoKSBh bGxvY10gaW5pdFdpdGhEYXRhOnBkZkRhdGEuZ2V0KCldKTsKKworICAgICAgICB1bnNpZ25lZCBw YWdlQ291bnQgPSBbX3ByaW50ZWRQYWdlc1BERkRvY3VtZW50IHBhZ2VDb3VudF07CisgICAgICAg IF9saW5rRGVzdGluYXRpb25zUGVyUGFnZS5jbGVhcigpOworICAgICAgICBfbGlua0Rlc3RpbmF0 aW9uc1BlclBhZ2UucmVzaXplKHBhZ2VDb3VudCk7CisgICAgICAgIGZvciAodW5zaWduZWQgaSA9 IDA7IGkgPCBwYWdlQ291bnQ7IGkrKykgeworICAgICAgICAgICAgUERGUGFnZSAqcGFnZSA9IFtf cHJpbnRlZFBhZ2VzUERGRG9jdW1lbnQgcGFnZUF0SW5kZXg6aV07CisgICAgICAgICAgICBmb3Ig KFBERkFubm90YXRpb24gKmFubm90YXRpb24gaW4gcGFnZS5hbm5vdGF0aW9ucykgeworICAgICAg ICAgICAgICAgIGlmICghW2Fubm90YXRpb24gaXNLaW5kT2ZDbGFzczpwZGZBbm5vdGF0aW9uTGlu a0NsYXNzKCldKQorICAgICAgICAgICAgICAgICAgICBjb250aW51ZTsKKworI3ByYWdtYSBjbGFu ZyBkaWFnbm9zdGljIHB1c2gKKyNwcmFnbWEgY2xhbmcgZGlhZ25vc3RpYyBpZ25vcmVkICItV2Rl cHJlY2F0ZWQtZGVjbGFyYXRpb25zIgorICAgICAgICAgICAgICAgIFBERkFubm90YXRpb25MaW5r ICpsaW5rQW5ub3RhdGlvbiA9IChQREZBbm5vdGF0aW9uTGluayAqKWFubm90YXRpb247CisjcHJh Z21hIGNsYW5nIGRpYWdub3N0aWMgcG9wCisgICAgICAgICAgICAgICAgaWYgKGxpbmtBbm5vdGF0 aW9uLlVSTCkKKyAgICAgICAgICAgICAgICAgICAgY29udGludWU7CisKKyAgICAgICAgICAgICAg ICBQREZEZXN0aW5hdGlvbiAqZGVzdGluYXRpb24gPSBsaW5rQW5ub3RhdGlvbi5kZXN0aW5hdGlv bjsKKyAgICAgICAgICAgICAgICBpZiAoIWRlc3RpbmF0aW9uKQorICAgICAgICAgICAgICAgICAg ICBjb250aW51ZTsKKworICAgICAgICAgICAgICAgIHVuc2lnbmVkIGRlc3RpbmF0aW9uUGFnZUlu ZGV4ID0gW19wcmludGVkUGFnZXNQREZEb2N1bWVudCBpbmRleEZvclBhZ2U6ZGVzdGluYXRpb24u cGFnZV07CisgICAgICAgICAgICAgICAgX2xpbmtEZXN0aW5hdGlvbnNQZXJQYWdlW2Rlc3RpbmF0 aW9uUGFnZUluZGV4XS5hcHBlbmQoZGVzdGluYXRpb24pOworICAgICAgICAgICAgfQorICAgICAg ICB9CiAgICAgfQogCiAgICAgdW5zaWduZWQgcHJpbnRlZFBhZ2VOdW1iZXIgPSBbc2VsZiBfcGFn ZUZvclJlY3Q6bnNSZWN0XSAtIFtzZWxmIF9maXJzdFByaW50ZWRQYWdlTnVtYmVyXTsK 293791 2016-11-03 13:05:09 -0700 2016-11-03 13:19:11 -0700 Patch bug-112081-20161103130108.patch text/plain 21359 thorton U3VidmVyc2lvbiBSZXZpc2lvbjogMjA4Mjk0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjE3YTU0OWFjMjVlZWI3 OGJhMzhkNmY5YzBhNTk3ZDVhN2JkMTQ1Ni4uMjFhNTkzYTcwMTc5ZWI2MzM5OTgxMjkyOGNiYWE1 NTg4NmMwZjFjZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDUyIEBACisyMDE2LTExLTAyICBUaW0g SG9ydG9uICA8dGltb3RoeV9ob3J0b25AYXBwbGUuY29tPgorCisgICAgICAgIFByaW50aW5nIHRv IFBERiBzaG91bGQgcHJvZHVjZSBpbnRlcm5hbCBsaW5rcyB3aGVuIEhUTUwgaGFzIGludGVybmFs IGxpbmtzCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0x MTIwODEKKyAgICAgICAgPHJkYXI6Ly9wcm9ibGVtLzU5NTU3MDU+CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisgICAgICAgIFBhdGNoIG9yaWdpbmFsbHkgYnkgRGF2aWQg TGF0dGltb3JlLgorCisgICAgICAgIE5vIG5ldyB0ZXN0cywgYXMgaXQncyB1bmNsZWFyIGhvdyB0 byB0ZXN0IFBERiBvdXRwdXQuCisKKyAgICAgICAgKiBkb20vRWxlbWVudC5jcHA6CisgICAgICAg IChXZWJDb3JlOjpFbGVtZW50OjpmaW5kQW5jaG9yRWxlbWVudEZvckxpbmspOgorICAgICAgICAq IGRvbS9FbGVtZW50Lmg6CisgICAgICAgIEFkZCBmaW5kQW5jaG9yRWxlbWVudEZvckxpbmssIHdo aWNoIGxvb2tzIHVwIHRoZSBhbmNob3IgZWxlbWVudCBjb3JyZXNwb25kaW5nCisgICAgICAgIHRv IHRoZSBjdXJyZW50IGVsZW1lbnQncyBocmVmLCBhbmQgYWxzbyByZXR1cm5zIHRoZSBmcmFnbWVu dCBuYW1lIGFzIGFuIG91dCBwYXJhbWV0ZXIuCisKKyAgICAgICAgKiBwYWdlL1ByaW50Q29udGV4 dC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpQcmludENvbnRleHQ6OlByaW50Q29udGV4dCk6Cisg ICAgICAgIChXZWJDb3JlOjpQcmludENvbnRleHQ6OnNwb29sUGFnZSk6CisgICAgICAgIChXZWJD b3JlOjpQcmludENvbnRleHQ6OnNwb29sUmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpQcmludENv bnRleHQ6OmVuZCk6CisgICAgICAgIChXZWJDb3JlOjpQcmludENvbnRleHQ6OmNvbGxlY3RMaW5r ZWREZXN0aW5hdGlvbnMpOgorICAgICAgICAoV2ViQ29yZTo6UHJpbnRDb250ZXh0OjpvdXRwdXRM aW5rZWREZXN0aW5hdGlvbnMpOgorICAgICAgICAqIHJlbmRlcmluZy9SZW5kZXJPYmplY3QuY3Bw OgorICAgICAgICAoV2ViQ29yZTo6UmVuZGVyT2JqZWN0OjphZGRQREZVUkxSZWN0KToKKyAgICAg ICAgUGx1bWIgaW50ZXJuYWwgbGlua3MgKGZyYWdtZW50IGxpbmtzKSB0aHJvdWdoIHRvIEdyYXBo aWNzQ29udGV4dCwgdXNpbmcKKyAgICAgICAgdGhlIGZyYWdtZW50IG5hbWUgZnJvbSB0aGUgcGFn ZS4KKworICAgICAgICAqIHBhZ2UvUHJpbnRDb250ZXh0Lmg6CisgICAgICAgICogcGxhdGZvcm0v Z3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNz Q29udGV4dDo6c3VwcG9ydHNJbnRlcm5hbExpbmtzKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBo aWNzQ29udGV4dDo6c2V0RGVzdGluYXRpb25Gb3JSZWN0KToKKyAgICAgICAgKFdlYkNvcmU6Okdy YXBoaWNzQ29udGV4dDo6YWRkRGVzdGluYXRpb25BdFBvaW50KToKKyAgICAgICAgKiBwbGF0Zm9y bS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuaDoKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGlj cy9jZy9HcmFwaGljc0NvbnRleHRDRy5jcHA6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0Nv bnRleHQ6OnN1cHBvcnRzSW50ZXJuYWxMaW5rcyk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGlj c0NvbnRleHQ6OnNldERlc3RpbmF0aW9uRm9yUmVjdCk6CisgICAgICAgIChXZWJDb3JlOjpHcmFw aGljc0NvbnRleHQ6OmFkZERlc3RpbmF0aW9uQXRQb2ludCk6CisgICAgICAgIFBsdW1iIGludGVy bmFsIGxpbmtzIHRocm91Z2ggdG8gdGhlIENHQ29udGV4dC4gQXBwbHkgdGhlIENUTSwgYmVjYXVz ZQorICAgICAgICB0aGVzZSBmdW5jdGlvbnMgZXhwZWN0IHBvc2l0aW9ucyBpbiBnbG9iYWwgY29v cmRpbmF0ZXMuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy93aW4vR3JhcGhpY3NDb250 ZXh0RGlyZWN0MkQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0OjpzZXRV UkxGb3JSZWN0KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9HcmFwaGljc0Nv bnRleHRDYWlyby5jcHA6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQ6OnNldFVS TEZvclJlY3QpOgorICAgICAgICBBZGp1c3Qgc2V0VVJMRm9yUmVjdCB0byB0YWtlIGEgRmxvYXRS ZWN0LCBsaWtlIGV2ZXJ5dGhpbmcgZWxzZSwgYW5kCisgICAgICAgIHN0b3Agcm91bmRpbmcuCisK IDIwMTYtMTEtMDEgIERlYW4gSmFja3NvbiAgPGRpbm9AYXBwbGUuY29tPgogCiAgICAgICAgIEZp bHRlciBmdW5jdGlvbnMgZ3JheXNjYWxlL2ludmVydC9vcGFjaXR5L3NlcGlhIHNob3VsZCBjbGFt cCB2YWx1ZXMgb3ZlciAxMDAlLCBub3QgZmFpbApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdDIv Q2hhbmdlTG9nIGIvU291cmNlL1dlYktpdDIvQ2hhbmdlTG9nCmluZGV4IDA3ZTc2Y2I5ZjRlOTU5 ZjZlMWFhNTAxNTJlODBmOWM3NDAxM2Y5NmQuLjkyYTE2ODY0ZTY2MTI2MjIyNzY0YjA3ODNlOTI3 YzZiNjM4NGFjNDkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL0NoYW5nZUxvZworKysgYi9T b3VyY2UvV2ViS2l0Mi9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyNCBAQAorMjAxNi0xMS0wMiAgVGlt IEhvcnRvbiAgPHRpbW90aHlfaG9ydG9uQGFwcGxlLmNvbT4KKworICAgICAgICBQcmludGluZyB0 byBQREYgc2hvdWxkIHByb2R1Y2UgaW50ZXJuYWwgbGlua3Mgd2hlbiBIVE1MIGhhcyBpbnRlcm5h bCBsaW5rcworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MTEyMDgxCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS81OTU1NzA1PgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogVUlQcm9jZXNzL21hYy9XS1ByaW50 aW5nVmlldy5oOgorICAgICAgICAqIFVJUHJvY2Vzcy9tYWMvV0tQcmludGluZ1ZpZXcubW06Cisg ICAgICAgIChsaW5rRGVzdGluYXRpb25OYW1lKToKKyAgICAgICAgKC1bV0tQcmludGluZ1ZpZXcg X2RyYXdQREZEb2N1bWVudDpwYWdlOmF0UG9pbnQ6XSk6CisgICAgICAgIFByb3BhZ2F0ZSBsaW5r LXRvLWRlc3RpbmF0aW9uIGFubm90YXRpb25zIChhbmQgZWFjaCBwYWdlJ3MgZGVzdGluYXRpb25z KQorICAgICAgICBpbnRvIHRoZSBwcmludGVkIFBERi4KKyAgICAgICAgR2VuZXJhdGUgYSB1bmlx dWUgZGVzdGluYXRpb24gbmFtZSBiYXNlZCBvbiB0aGUgcGFnZSBhbmQgcG9zaXRpb24sIGJlY2F1 c2UKKyAgICAgICAgd2UgaGF2ZSBsb3N0IHRoZSBmcmFnbWVudCBuYW1lIGluZm9ybWF0aW9uLgor CisgICAgICAgICgtW1dLUHJpbnRpbmdWaWV3IGRyYXdSZWN0Ol0pOgorICAgICAgICBDb21wdXRl IGFsbCBvZiB0aGUgZGVzdGluYXRpb25zIGZvciBldmVyeSBwYWdlLCBzbyB0aGF0IHdlIGNhbiBh ZGQgdGhlbQorICAgICAgICB0byB0aGUgY29udGV4dCBhcyB3ZSBwYWludCB0aGUgcGFnZXMgKHdl IG5lZWQgdGhlIHBhZ2UgQ1RNIGluIG9yZGVyIHRvIGFkZCB0aGVtKS4KKwogMjAxNi0xMS0wMiAg Q2FybG9zIEdhcmNpYSBDYW1wb3MgIDxjZ2FyY2lhQGlnYWxpYS5jb20+CiAKICAgICAgICAgTmV0 d29ya1Nlc3Npb246IE5ldHdvcmsgcHJvY2VzcyBjcmFzaCB3aGVuIGNvbnZlcnRpbmcgbWFpbiBy ZXNvdXJjZSB0byBkb3dubG9hZApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvZG9tL0VsZW1l bnQuY3BwIGIvU291cmNlL1dlYkNvcmUvZG9tL0VsZW1lbnQuY3BwCmluZGV4IGFkNzdjYzVhNWIx NTNhZTY3ODExZmVmZjdiYmYwMzg3NzRjMDIwN2EuLjQyNDE5ZWRjZmY5MzRkMDBiNDE2Y2JiYTkw MjRiMDJmMmUxYzFhMGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmNw cAorKysgYi9Tb3VyY2UvV2ViQ29yZS9kb20vRWxlbWVudC5jcHAKQEAgLTM3NDYsNCArMzc0Niwy NiBAQCBFeGNlcHRpb25Pcjx2b2lkPiBFbGVtZW50OjppbnNlcnRBZGphY2VudFRleHQoY29uc3Qg U3RyaW5nJiB3aGVyZSwgY29uc3QgU3RyaW5nJgogICAgIHJldHVybiB7IH07CiB9CiAKK0VsZW1l bnQqIEVsZW1lbnQ6OmZpbmRBbmNob3JFbGVtZW50Rm9yTGluayhTdHJpbmcmIG91dEFuY2hvck5h bWUpCit7CisgICAgaWYgKCFpc0xpbmsoKSkKKyAgICAgICAgcmV0dXJuIG51bGxwdHI7CisKKyAg ICBjb25zdCBBdG9taWNTdHJpbmcmIGhyZWYgPSBnZXRBdHRyaWJ1dGUoSFRNTE5hbWVzOjpocmVm QXR0cik7CisgICAgaWYgKGhyZWYuaXNOdWxsKCkpCisgICAgICAgIHJldHVybiBudWxscHRyOwor CisgICAgRG9jdW1lbnQmIGRvY3VtZW50ID0gdGhpcy0+ZG9jdW1lbnQoKTsKKyAgICBVUkwgdXJs ID0gZG9jdW1lbnQuY29tcGxldGVVUkwoaHJlZik7CisgICAgaWYgKCF1cmwuaXNWYWxpZCgpKQor ICAgICAgICByZXR1cm4gbnVsbHB0cjsKKworICAgIGlmICh1cmwuaGFzRnJhZ21lbnRJZGVudGlm aWVyKCkgJiYgZXF1YWxJZ25vcmluZ0ZyYWdtZW50SWRlbnRpZmllcih1cmwsIGRvY3VtZW50LmJh c2VVUkwoKSkpIHsKKyAgICAgICAgb3V0QW5jaG9yTmFtZSA9IHVybC5mcmFnbWVudElkZW50aWZp ZXIoKTsKKyAgICAgICAgcmV0dXJuIGRvY3VtZW50LmZpbmRBbmNob3Iob3V0QW5jaG9yTmFtZSk7 CisgICAgfQorCisgICAgcmV0dXJuIG51bGxwdHI7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNv cmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmggYi9Tb3VyY2UvV2Vi Q29yZS9kb20vRWxlbWVudC5oCmluZGV4IDAxODIyOTFjOTk4MjZkZDU0YTU5YTc0NjI1YTA2NzE5 NmFkODBkOTguLjYxYTYzNzRkNWY4NmI1YmM0ODI4ZmFhNDY3ZjQzM2FhY2Y0YmIwYmUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2RvbS9FbGVtZW50LmgKKysrIGIvU291cmNlL1dlYkNvcmUv ZG9tL0VsZW1lbnQuaApAQCAtNTc2LDYgKzU3Niw4IEBAIHB1YmxpYzoKICAgICBWZWN0b3I8V2Vi QW5pbWF0aW9uKj4gZ2V0QW5pbWF0aW9ucygpOwogI2VuZGlmCiAKKyAgICBFbGVtZW50KiBmaW5k QW5jaG9yRWxlbWVudEZvckxpbmsoU3RyaW5nJiBvdXRBbmNob3JOYW1lKTsKKwogcHJvdGVjdGVk OgogICAgIEVsZW1lbnQoY29uc3QgUXVhbGlmaWVkTmFtZSYsIERvY3VtZW50JiwgQ29uc3RydWN0 aW9uVHlwZSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUHJpbnRDb250ZXh0 LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUHJpbnRDb250ZXh0LmNwcAppbmRleCA1NGRlYTM2 ZjkyYWVhMGZkM2RjNTE1YWU5OWQwMmVkMmVhZTNmNDI5Li4yN2ExYjM2ZmM3OThhNTg3M2EzYWQ3 N2Q1NWVjYTljYjk1ODA4NzczIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wYWdlL1ByaW50 Q29udGV4dC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGFnZS9QcmludENvbnRleHQuY3BwCkBA IC0yNCw2ICsyNCw4IEBACiAjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0LmgiCiAjaW5jbHVkZSAi RnJhbWUuaCIKICNpbmNsdWRlICJGcmFtZVZpZXcuaCIKKyNpbmNsdWRlICJIVE1MTmFtZXMuaCIK KyNpbmNsdWRlICJOb2RlVHJhdmVyc2FsLmgiCiAjaW5jbHVkZSAiUmVuZGVyVmlldy5oIgogI2lu Y2x1ZGUgIlN0eWxlSW5oZXJpdGVkRGF0YS5oIgogI2luY2x1ZGUgIlN0eWxlUmVzb2x2ZXIuaCIK QEAgLTM0LDcgKzM2LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogCiBQcmludENvbnRleHQ6OlBy aW50Q29udGV4dChGcmFtZSogZnJhbWUpCiAgICAgOiBtX2ZyYW1lKGZyYW1lKQotICAgICwgbV9p c1ByaW50aW5nKGZhbHNlKQogewogfQogCkBAIC0xOTAsNiArMTkxLDcgQEAgdm9pZCBQcmludENv bnRleHQ6OnNwb29sUGFnZShHcmFwaGljc0NvbnRleHQmIGN0eCwgaW50IHBhZ2VOdW1iZXIsIGZs b2F0IHdpZHRoKQogICAgIGN0eC50cmFuc2xhdGUoLXBhZ2VSZWN0LngoKSwgLXBhZ2VSZWN0Lnko KSk7CiAgICAgY3R4LmNsaXAocGFnZVJlY3QpOwogICAgIG1fZnJhbWUtPnZpZXcoKS0+cGFpbnRD b250ZW50cyhjdHgsIHBhZ2VSZWN0KTsKKyAgICBvdXRwdXRMaW5rZWREZXN0aW5hdGlvbnMoY3R4 LCBtX2ZyYW1lLT5kb2N1bWVudCgpLCBwYWdlUmVjdCk7CiAgICAgY3R4LnJlc3RvcmUoKTsKIH0K IApAQCAtMjAwLDYgKzIwMiw3IEBAIHZvaWQgUHJpbnRDb250ZXh0OjpzcG9vbFJlY3QoR3JhcGhp Y3NDb250ZXh0JiBjdHgsIGNvbnN0IEludFJlY3QmIHJlY3QpCiAgICAgY3R4LnRyYW5zbGF0ZSgt cmVjdC54KCksIC1yZWN0LnkoKSk7CiAgICAgY3R4LmNsaXAocmVjdCk7CiAgICAgbV9mcmFtZS0+ dmlldygpLT5wYWludENvbnRlbnRzKGN0eCwgcmVjdCk7CisgICAgb3V0cHV0TGlua2VkRGVzdGlu YXRpb25zKGN0eCwgbV9mcmFtZS0+ZG9jdW1lbnQoKSwgcmVjdCk7CiAgICAgY3R4LnJlc3RvcmUo KTsKIH0KIApAQCAtMjA4LDYgKzIxMSw3IEBAIHZvaWQgUHJpbnRDb250ZXh0OjplbmQoKQogICAg IEFTU0VSVChtX2lzUHJpbnRpbmcpOwogICAgIG1faXNQcmludGluZyA9IGZhbHNlOwogICAgIG1f ZnJhbWUtPnNldFByaW50aW5nKGZhbHNlLCBGbG9hdFNpemUoKSwgRmxvYXRTaXplKCksIDAsIEFk anVzdFZpZXdTaXplKTsKKyAgICBtX2xpbmtlZERlc3RpbmF0aW9ucyA9IE51bGxvcHQ7CiB9CiAK IHN0YXRpYyBpbmxpbmUgUmVuZGVyQm94TW9kZWxPYmplY3QqIGVuY2xvc2luZ0JveE1vZGVsT2Jq ZWN0KFJlbmRlckVsZW1lbnQqIHJlbmRlcmVyKQpAQCAtMjQ2LDYgKzI1MCwzOSBAQCBpbnQgUHJp bnRDb250ZXh0OjpwYWdlTnVtYmVyRm9yRWxlbWVudChFbGVtZW50KiBlbGVtZW50LCBjb25zdCBG bG9hdFNpemUmIHBhZ2VTaQogICAgIHJldHVybiAtMTsKIH0KIAordm9pZCBQcmludENvbnRleHQ6 OmNvbGxlY3RMaW5rZWREZXN0aW5hdGlvbnMoTm9kZSYgbm9kZSkKK3sKKyAgICBmb3IgKE5vZGUq IGNoaWxkID0gJm5vZGU7IGNoaWxkOyBjaGlsZCA9IE5vZGVUcmF2ZXJzYWw6Om5leHQoKmNoaWxk KSkgeworICAgICAgICBpZiAoIWlzPEVsZW1lbnQ+KGNoaWxkKSkKKyAgICAgICAgICAgIGNvbnRp bnVlOworCisgICAgICAgIFN0cmluZyBvdXRBbmNob3JOYW1lOworICAgICAgICBpZiAoRWxlbWVu dCogZWxlbWVudCA9IGRvd25jYXN0PEVsZW1lbnQ+KGNoaWxkKS0+ZmluZEFuY2hvckVsZW1lbnRG b3JMaW5rKG91dEFuY2hvck5hbWUpKQorICAgICAgICAgICAgbV9saW5rZWREZXN0aW5hdGlvbnMt PnNldChvdXRBbmNob3JOYW1lLCBlbGVtZW50KTsKKyAgICB9Cit9CisKK3ZvaWQgUHJpbnRDb250 ZXh0OjpvdXRwdXRMaW5rZWREZXN0aW5hdGlvbnMoR3JhcGhpY3NDb250ZXh0JiBncmFwaGljc0Nv bnRleHQsIE5vZGUqIG5vZGUsIGNvbnN0IEludFJlY3QmIHBhZ2VSZWN0KQoreworICAgIGlmICgh Z3JhcGhpY3NDb250ZXh0LnN1cHBvcnRzSW50ZXJuYWxMaW5rcygpKQorICAgICAgICByZXR1cm47 CisKKyAgICBpZiAoIW1fbGlua2VkRGVzdGluYXRpb25zKSB7CisgICAgICAgIG1fbGlua2VkRGVz dGluYXRpb25zID0gSGFzaE1hcDxTdHJpbmcsIEVsZW1lbnQqPiB7IH07CisgICAgICAgIGNvbGxl Y3RMaW5rZWREZXN0aW5hdGlvbnMoKm5vZGUpOworICAgIH0KKworICAgIGZvciAoY29uc3QgYXV0 byYgaXQgOiAqbV9saW5rZWREZXN0aW5hdGlvbnMpIHsKKyAgICAgICAgRmxvYXRQb2ludCBwb2lu dCA9IGl0LnZhbHVlLT5yZW5kZXJlcigpLT5hbmNob3JSZWN0KCkubWluWE1pbllDb3JuZXIoKTsK KyAgICAgICAgcG9pbnQuZXhwYW5kZWRUbyhGbG9hdFBvaW50KCkpOworCisgICAgICAgIGlmICgh cGFnZVJlY3QuY29udGFpbnMocm91bmRlZEludFBvaW50KHBvaW50KSkpCisgICAgICAgICAgICBj b250aW51ZTsKKworICAgICAgICBncmFwaGljc0NvbnRleHQuYWRkRGVzdGluYXRpb25BdFBvaW50 KGl0LmtleSwgcG9pbnQpOworICAgIH0KK30KKwogU3RyaW5nIFByaW50Q29udGV4dDo6cGFnZVBy b3BlcnR5KEZyYW1lKiBmcmFtZSwgY29uc3QgY2hhciogcHJvcGVydHlOYW1lLCBpbnQgcGFnZU51 bWJlcikKIHsKICAgICBEb2N1bWVudCogZG9jdW1lbnQgPSBmcmFtZS0+ZG9jdW1lbnQoKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUHJpbnRDb250ZXh0LmggYi9Tb3VyY2UvV2Vi Q29yZS9wYWdlL1ByaW50Q29udGV4dC5oCmluZGV4IDlmYzY2ZDNkYTkxMGUwNTA4OWY1NTdhZTM2 ZjkxMjMwOTU3NGJkMGEuLjZhZDkyOTVkNDhmYTg2MjQ0ZTI3MDA3NmE4YjZhNDk5ZjZhZmM1YjEg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BhZ2UvUHJpbnRDb250ZXh0LmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGFnZS9QcmludENvbnRleHQuaApAQCAtMjEsNyArMjEsOSBAQAogI3ByYWdt YSBvbmNlCiAKICNpbmNsdWRlIDx3dGYvRm9yd2FyZC5oPgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFw Lmg+CiAjaW5jbHVkZSA8d3RmL1ZlY3Rvci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmlu Zy5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKQEAgLTMxLDYgKzMzLDcgQEAgY2xhc3MgRmxv YXRSZWN0OwogY2xhc3MgRmxvYXRTaXplOwogY2xhc3MgR3JhcGhpY3NDb250ZXh0OwogY2xhc3Mg SW50UmVjdDsKK2NsYXNzIE5vZGU7CiAKIGNsYXNzIFByaW50Q29udGV4dCB7CiBwdWJsaWM6CkBA IC05OCw5ICsxMDEsMTMgQEAgcHJvdGVjdGVkOgogcHJpdmF0ZToKICAgICB2b2lkIGNvbXB1dGVQ YWdlUmVjdHNXaXRoUGFnZVNpemVJbnRlcm5hbChjb25zdCBGbG9hdFNpemUmIHBhZ2VTaXplSW5Q aXhlbHMsIGJvb2wgYWxsb3dIb3Jpem9udGFsVGlsaW5nKTsKICAgICBib29sIGJlZ2luQW5kQ29t cHV0ZVBhZ2VSZWN0c1dpdGhQYWdlU2l6ZShGcmFtZSYsIGNvbnN0IEZsb2F0U2l6ZSYgcGFnZVNp emVJblBpeGVscyk7CisgICAgdm9pZCBjb2xsZWN0TGlua2VkRGVzdGluYXRpb25zKE5vZGUmKTsK KyAgICB2b2lkIG91dHB1dExpbmtlZERlc3RpbmF0aW9ucyhHcmFwaGljc0NvbnRleHQmLCBOb2Rl KiwgY29uc3QgSW50UmVjdCYgcGFnZVJlY3QpOwogCiAgICAgLy8gVXNlZCB0byBwcmV2ZW50IG1p c3VzZXMgb2YgYmVnaW4oKSBhbmQgZW5kKCkgKGUuZy4sIGNhbGwgZW5kIHdpdGhvdXQgYmVnaW4p LgotICAgIGJvb2wgbV9pc1ByaW50aW5nOworICAgIGJvb2wgbV9pc1ByaW50aW5nIHsgZmFsc2Ug fTsKKworICAgIE9wdGlvbmFsPEhhc2hNYXA8U3RyaW5nLCBFbGVtZW50Kj4+IG1fbGlua2VkRGVz dGluYXRpb25zOwogfTsKIAogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmNwcCBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4dC5jcHAKaW5kZXggODhi N2Y1YjkxNWU0N2M1ODFhNzI4ZDY1ZWQzMzBiMTdmZTU4MWQzOS4uMmRkYjRkZmYxZGVjZTZjZDI5 MTM5NzNkMjI0ZGQ5YzIxNTk3ZmE2YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9HcmFwaGljc0NvbnRleHQuY3BwCkBAIC0xMTc3LDQgKzExNzcsMTkgQEAg VmVjdG9yPEZsb2F0UG9pbnQ+IEdyYXBoaWNzQ29udGV4dDo6Y2VudGVyTGluZUFuZEN1dE9mZkNv cm5lcnMoYm9vbCBpc1ZlcnRpY2FsTGkKICAgICByZXR1cm4geyBwb2ludDEsIHBvaW50MiB9Owog fQogCisjaWYgIVVTRShDRykKK2Jvb2wgR3JhcGhpY3NDb250ZXh0OjpzdXBwb3J0c0ludGVybmFs TGlua3MoKSBjb25zdAoreworICAgIHJldHVybiBmYWxzZTsKK30KKwordm9pZCBHcmFwaGljc0Nv bnRleHQ6OnNldERlc3RpbmF0aW9uRm9yUmVjdChjb25zdCBTdHJpbmcmLCBjb25zdCBGbG9hdFJl Y3QmKQoreworfQorCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6YWRkRGVzdGluYXRpb25BdFBvaW50 KGNvbnN0IFN0cmluZyYsIGNvbnN0IEZsb2F0UG9pbnQmKQoreworfQorI2VuZGlmCisKIH0KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL0dyYXBoaWNzQ29udGV4 dC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmgK aW5kZXggNTY5N2MwOWY3NmVkNjNhMGM5Zjg5N2U5MDE1NTE5ZDUwNzgyYzQ0MS4uZDBkZWIyMDJl ZGEwZWJlOWJkNGEzMTY0OWQxMTcwYmZhNjBhMTczOCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmgKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvR3JhcGhpY3NDb250ZXh0LmgKQEAgLTQ2OCw3ICs0NjgsMTAg QEAgcHVibGljOgogICAgIHZvaWQgdHJhbnNsYXRlKGNvbnN0IEZsb2F0U2l6ZSYgc2l6ZSkgeyB0 cmFuc2xhdGUoc2l6ZS53aWR0aCgpLCBzaXplLmhlaWdodCgpKTsgfQogICAgIFdFQkNPUkVfRVhQ T1JUIHZvaWQgdHJhbnNsYXRlKGZsb2F0IHgsIGZsb2F0IHkpOwogCi0gICAgdm9pZCBzZXRVUkxG b3JSZWN0KGNvbnN0IFVSTCYsIGNvbnN0IEludFJlY3QmKTsKKyAgICB2b2lkIHNldFVSTEZvclJl Y3QoY29uc3QgVVJMJiwgY29uc3QgRmxvYXRSZWN0Jik7CisKKyAgICB2b2lkIHNldERlc3RpbmF0 aW9uRm9yUmVjdChjb25zdCBTdHJpbmcmIG5hbWUsIGNvbnN0IEZsb2F0UmVjdCYpOworICAgIHZv aWQgYWRkRGVzdGluYXRpb25BdFBvaW50KGNvbnN0IFN0cmluZyYgbmFtZSwgY29uc3QgRmxvYXRQ b2ludCYpOwogCiAgICAgdm9pZCBjb25jYXRDVE0oY29uc3QgQWZmaW5lVHJhbnNmb3JtJik7CiAg ICAgdm9pZCBzZXRDVE0oY29uc3QgQWZmaW5lVHJhbnNmb3JtJik7CkBAIC01NzYsNiArNTc5LDgg QEAgcHVibGljOgogCiAgICAgc3RhdGljIHZvaWQgYWRqdXN0TGluZVRvUGl4ZWxCb3VuZGFyaWVz KEZsb2F0UG9pbnQmIHAxLCBGbG9hdFBvaW50JiBwMiwgZmxvYXQgc3Ryb2tlV2lkdGgsIFN0cm9r ZVN0eWxlKTsKIAorICAgIGJvb2wgc3VwcG9ydHNJbnRlcm5hbExpbmtzKCkgY29uc3Q7CisKIHBy aXZhdGU6CiAgICAgdm9pZCBwbGF0Zm9ybUluaXQoUGxhdGZvcm1HcmFwaGljc0NvbnRleHQqKTsK ICAgICB2b2lkIHBsYXRmb3JtRGVzdHJveSgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2Fpcm8vR3JhcGhpY3NDb250ZXh0Q2Fpcm8uY3BwIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2Fpcm8vR3JhcGhpY3NDb250ZXh0Q2Fpcm8uY3Bw CmluZGV4IGVhM2U5ZjYwNDhiOGY0NGE0OGQ1YjNmNWVmOGJkM2RhNWE1YTMyZDcuLmEyMGJmMjFl NmQxNzcxYWI1MDRiMTQ4MTU0NWMwMDUzMTU3MGY5MTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NhaXJvL0dyYXBoaWNzQ29udGV4dENhaXJvLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jYWlyby9HcmFwaGljc0NvbnRleHRD YWlyby5jcHAKQEAgLTgwNSw3ICs4MDUsNyBAQCB2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0UGxh dGZvcm1TdHJva2VTdHlsZShTdHJva2VTdHlsZSBzdHJva2VTdHlsZSkKICAgICB9CiB9CiAKLXZv aWQgR3JhcGhpY3NDb250ZXh0OjpzZXRVUkxGb3JSZWN0KGNvbnN0IFVSTCYsIGNvbnN0IEludFJl Y3QmKQordm9pZCBHcmFwaGljc0NvbnRleHQ6OnNldFVSTEZvclJlY3QoY29uc3QgVVJMJiwgY29u c3QgRmxvYXRSZWN0JikKIHsKICAgICBub3RJbXBsZW1lbnRlZCgpOwogfQpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvR3JhcGhpY3NDb250ZXh0Q0cuY3Bw IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2cvR3JhcGhpY3NDb250ZXh0Q0cu Y3BwCmluZGV4IGUwNmY0NWQ0OTJjNTg4YWJjMmViOWY1YWZjZDI0MGQzOGVlYzU1MjguLjNmMjZl ZWQ0MzkzMjE4MWUxM2JmMWZkNDhkYjJjZjBlMWE4Y2Q0MTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2NnL0dyYXBoaWNzQ29udGV4dENHLmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jZy9HcmFwaGljc0NvbnRleHRDRy5jcHAK QEAgLTE1NDgsNyArMTU0OCw3IEBAIHZvaWQgR3JhcGhpY3NDb250ZXh0OjpkcmF3TGluZXNGb3JU ZXh0KGNvbnN0IEZsb2F0UG9pbnQmIHBvaW50LCBjb25zdCBEYXNoQXJyYXkmCiAgICAgICAgIHNl dENHRmlsbENvbG9yKHBsYXRmb3JtQ29udGV4dCgpLCBmaWxsQ29sb3IoKSk7CiB9CiAKLXZvaWQg R3JhcGhpY3NDb250ZXh0OjpzZXRVUkxGb3JSZWN0KGNvbnN0IFVSTCYgbGluaywgY29uc3QgSW50 UmVjdCYgZGVzdFJlY3QpCit2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0VVJMRm9yUmVjdChjb25z dCBVUkwmIGxpbmssIGNvbnN0IEZsb2F0UmVjdCYgZGVzdFJlY3QpCiB7CiAjaWYgIVBMQVRGT1JN KElPUykKICAgICBpZiAocGFpbnRpbmdEaXNhYmxlZCgpKQpAQCAtMTU2NSwxNSArMTU2NSwxMSBA QCB2b2lkIEdyYXBoaWNzQ29udGV4dDo6c2V0VVJMRm9yUmVjdChjb25zdCBVUkwmIGxpbmssIGNv bnN0IEludFJlY3QmIGRlc3RSZWN0KQogCiAgICAgQ0dDb250ZXh0UmVmIGNvbnRleHQgPSBwbGF0 Zm9ybUNvbnRleHQoKTsKIAorICAgIEZsb2F0UmVjdCByZWN0ID0gZGVzdFJlY3Q7CiAgICAgLy8g R2V0IHRoZSBib3VuZGluZyBib3ggdG8gaGFuZGxlIGNsaXBwaW5nLgotICAgIENHUmVjdCBib3gg PSBDR0NvbnRleHRHZXRDbGlwQm91bmRpbmdCb3goY29udGV4dCk7CisgICAgcmVjdC5pbnRlcnNl Y3QoQ0dDb250ZXh0R2V0Q2xpcEJvdW5kaW5nQm94KGNvbnRleHQpKTsKIAotICAgIEludFJlY3Qg aW50Qm94KChpbnQpYm94Lm9yaWdpbi54LCAoaW50KWJveC5vcmlnaW4ueSwgKGludClib3guc2l6 ZS53aWR0aCwgKGludClib3guc2l6ZS5oZWlnaHQpOwotICAgIEludFJlY3QgcmVjdCA9IGRlc3RS ZWN0OwotICAgIHJlY3QuaW50ZXJzZWN0KGludEJveCk7Ci0KLSAgICBDR1BERkNvbnRleHRTZXRV UkxGb3JSZWN0KGNvbnRleHQsIHVybFJlZi5nZXQoKSwKLSAgICAgICAgQ0dSZWN0QXBwbHlBZmZp bmVUcmFuc2Zvcm0ocmVjdCwgQ0dDb250ZXh0R2V0Q1RNKGNvbnRleHQpKSk7CisgICAgQ0dQREZD b250ZXh0U2V0VVJMRm9yUmVjdChjb250ZXh0LCB1cmxSZWYuZ2V0KCksIENHUmVjdEFwcGx5QWZm aW5lVHJhbnNmb3JtKHJlY3QsIENHQ29udGV4dEdldENUTShjb250ZXh0KSkpOwogI2Vsc2UKICAg ICBVTlVTRURfUEFSQU0obGluayk7CiAgICAgVU5VU0VEX1BBUkFNKGRlc3RSZWN0KTsKQEAgLTE5 MDIsNiArMTg5OCwzNiBAQCB2b2lkIEdyYXBoaWNzQ29udGV4dDo6cGxhdGZvcm1TdHJva2VFbGxp cHNlKGNvbnN0IEZsb2F0UmVjdCYgZWxsaXBzZSkKICAgICBDR0NvbnRleHRTdHJva2VFbGxpcHNl SW5SZWN0KGNvbnRleHQsIGVsbGlwc2UpOwogfQogCitib29sIEdyYXBoaWNzQ29udGV4dDo6c3Vw cG9ydHNJbnRlcm5hbExpbmtzKCkgY29uc3QKK3sKKyAgICByZXR1cm4gdHJ1ZTsKK30KKwordm9p ZCBHcmFwaGljc0NvbnRleHQ6OnNldERlc3RpbmF0aW9uRm9yUmVjdChjb25zdCBTdHJpbmcmIG5h bWUsIGNvbnN0IEZsb2F0UmVjdCYgZGVzdFJlY3QpCit7CisgICAgaWYgKHBhaW50aW5nRGlzYWJs ZWQoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgQ0dDb250ZXh0UmVmIGNvbnRleHQgPSBwbGF0 Zm9ybUNvbnRleHQoKTsKKworICAgIEZsb2F0UmVjdCByZWN0ID0gZGVzdFJlY3Q7CisgICAgcmVj dC5pbnRlcnNlY3QoQ0dDb250ZXh0R2V0Q2xpcEJvdW5kaW5nQm94KGNvbnRleHQpKTsKKworICAg IENHUmVjdCB0cmFuc2Zvcm1lZFJlY3QgPSBDR1JlY3RBcHBseUFmZmluZVRyYW5zZm9ybShyZWN0 LCBDR0NvbnRleHRHZXRDVE0oY29udGV4dCkpOworICAgIENHUERGQ29udGV4dFNldERlc3RpbmF0 aW9uRm9yUmVjdChjb250ZXh0LCBuYW1lLmNyZWF0ZUNGU3RyaW5nKCkuZ2V0KCksIHRyYW5zZm9y bWVkUmVjdCk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0OjphZGREZXN0aW5hdGlvbkF0UG9p bnQoY29uc3QgU3RyaW5nJiBuYW1lLCBjb25zdCBGbG9hdFBvaW50JiBwb3NpdGlvbikKK3sKKyAg ICBpZiAocGFpbnRpbmdEaXNhYmxlZCgpKQorICAgICAgICByZXR1cm47CisKKyAgICBDR0NvbnRl eHRSZWYgY29udGV4dCA9IHBsYXRmb3JtQ29udGV4dCgpOworCisgICAgQ0dQb2ludCB0cmFuc2Zv cm1lZFBvaW50ID0gQ0dQb2ludEFwcGx5QWZmaW5lVHJhbnNmb3JtKHBvc2l0aW9uLCBDR0NvbnRl eHRHZXRDVE0oY29udGV4dCkpOworICAgIENHUERGQ29udGV4dEFkZERlc3RpbmF0aW9uQXRQb2lu dChjb250ZXh0LCBuYW1lLmNyZWF0ZUNGU3RyaW5nKCkuZ2V0KCksIHRyYW5zZm9ybWVkUG9pbnQp OworfQorCiB9CiAKICNlbmRpZgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3Mvd2luL0dyYXBoaWNzQ29udGV4dERpcmVjdDJELmNwcCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL3dpbi9HcmFwaGljc0NvbnRleHREaXJlY3QyRC5jcHAKaW5kZXgg NDMzMDAzYWEwNmViYWYxNmM3MjU2YzU1ZTNlZTMzNWEwOGQxM2NkNi4uZTQxODc1ZGUwNmM4Y2U2 NjRhYTJlM2QxYjZiNWFmMWY0ODdiYTE2YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3Mvd2luL0dyYXBoaWNzQ29udGV4dERpcmVjdDJELmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy93aW4vR3JhcGhpY3NDb250ZXh0RGlyZWN0MkQu Y3BwCkBAIC0xNjI4LDcgKzE2MjgsNyBAQCB2b2lkIEdyYXBoaWNzQ29udGV4dDo6ZHJhd0xpbmVz Rm9yVGV4dChjb25zdCBGbG9hdFBvaW50JiBwb2ludCwgY29uc3QgRGFzaEFycmF5JgogICAgIG5v dEltcGxlbWVudGVkKCk7CiB9CiAKLXZvaWQgR3JhcGhpY3NDb250ZXh0OjpzZXRVUkxGb3JSZWN0 KGNvbnN0IFVSTCYgbGluaywgY29uc3QgSW50UmVjdCYgZGVzdFJlY3QpCit2b2lkIEdyYXBoaWNz Q29udGV4dDo6c2V0VVJMRm9yUmVjdChjb25zdCBVUkwmIGxpbmssIGNvbnN0IEZsb2F0UmVjdCYg ZGVzdFJlY3QpCiB7CiAgICAgaWYgKHBhaW50aW5nRGlzYWJsZWQoKSkKICAgICAgICAgcmV0dXJu OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcmVuZGVyaW5nL1JlbmRlck9iamVjdC5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2JqZWN0LmNwcAppbmRleCAxNzc4NDFl NjY2ZmQzZWZlMmU5MTBhMGNlODNiYWQzMWFlYzk3MDRiLi41ZmQwMWY1YWNlODY0NmFiZWU2YWFk ODY4NDNiMDA2YTFkZDA1ODA2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcv UmVuZGVyT2JqZWN0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9yZW5kZXJpbmcvUmVuZGVyT2Jq ZWN0LmNwcApAQCAtNjA0LDEwICs2MDQsMjIgQEAgdm9pZCBSZW5kZXJPYmplY3Q6OmFkZFBERlVS TFJlY3QoUGFpbnRJbmZvJiBwYWludEluZm8sIGNvbnN0IExheW91dFBvaW50JiBwYWludE8KICAg ICBOb2RlKiBub2RlID0gdGhpcy0+bm9kZSgpOwogICAgIGlmICghaXM8RWxlbWVudD4obm9kZSkg fHwgIW5vZGUtPmlzTGluaygpKQogICAgICAgICByZXR1cm47Ci0gICAgY29uc3QgQXRvbWljU3Ry aW5nJiBocmVmID0gZG93bmNhc3Q8RWxlbWVudD4oKm5vZGUpLmdldEF0dHJpYnV0ZShocmVmQXR0 cik7CisgICAgRWxlbWVudCYgZWxlbWVudCA9IGRvd25jYXN0PEVsZW1lbnQ+KCpub2RlKTsKKyAg ICBjb25zdCBBdG9taWNTdHJpbmcmIGhyZWYgPSBlbGVtZW50LmdldEF0dHJpYnV0ZShocmVmQXR0 cik7CiAgICAgaWYgKGhyZWYuaXNOdWxsKCkpCiAgICAgICAgIHJldHVybjsKLSAgICBwYWludElu Zm8uY29udGV4dCgpLnNldFVSTEZvclJlY3Qobm9kZS0+ZG9jdW1lbnQoKS5jb21wbGV0ZVVSTCho cmVmKSwgc25hcHBlZEludFJlY3QodXJsUmVjdCkpOworCisgICAgaWYgKHBhaW50SW5mby5jb250 ZXh0KCkuc3VwcG9ydHNJbnRlcm5hbExpbmtzKCkpIHsKKyAgICAgICAgU3RyaW5nIG91dEFuY2hv ck5hbWU7CisgICAgICAgIEVsZW1lbnQqIGxpbmtUYXJnZXQgPSBlbGVtZW50LmZpbmRBbmNob3JF bGVtZW50Rm9yTGluayhvdXRBbmNob3JOYW1lKTsKKyAgICAgICAgaWYgKGxpbmtUYXJnZXQpIHsK KyAgICAgICAgICAgIHBhaW50SW5mby5jb250ZXh0KCkuc2V0RGVzdGluYXRpb25Gb3JSZWN0KG91 dEFuY2hvck5hbWUsIHVybFJlY3QpOworICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB9Cisg ICAgfQorCisgICAgcGFpbnRJbmZvLmNvbnRleHQoKS5zZXRVUkxGb3JSZWN0KG5vZGUtPmRvY3Vt ZW50KCkuY29tcGxldGVVUkwoaHJlZiksIHVybFJlY3QpOworCiB9CiAKICNpZiBQTEFURk9STShJ T1MpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbWFjL1dLUHJpbnRpbmdW aWV3LmggYi9Tb3VyY2UvV2ViS2l0Mi9VSVByb2Nlc3MvbWFjL1dLUHJpbnRpbmdWaWV3LmgKaW5k ZXggM2I4YjhkMjg5NWQ1NDRiNzlkZTM3ZmRhOGYzN2EyNGQ5ZGNiOTE5OC4uM2YyZmU5MzkxNzVj YTNmZWUwNzA4MTk5NmMyNTZkNDU3ZWRkMjlhZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdDIv VUlQcm9jZXNzL21hYy9XS1ByaW50aW5nVmlldy5oCisrKyBiL1NvdXJjZS9XZWJLaXQyL1VJUHJv Y2Vzcy9tYWMvV0tQcmludGluZ1ZpZXcuaApAQCAtMzMsNiArMzMsNyBAQAogI2ltcG9ydCA8d3Rm L1ZlY3Rvci5oPgogCiBAY2xhc3MgV0tQcmludGluZ1ZpZXdEYXRhOworQGNsYXNzIFBERkRlc3Rp bmF0aW9uOwogQGNsYXNzIFBERkRvY3VtZW50OwogCiBuYW1lc3BhY2UgV2ViS2l0IHsKQEAgLTUy LDYgKzUzLDcgQEAgY2xhc3MgV2ViRnJhbWVQcm94eTsKIAogICAgIFZlY3Rvcjx1aW50OF90PiBf cHJpbnRlZFBhZ2VzRGF0YTsKICAgICBSZXRhaW5QdHI8UERGRG9jdW1lbnQ+IF9wcmludGVkUGFn ZXNQREZEb2N1bWVudDsKKyAgICBWZWN0b3I8VmVjdG9yPFJldGFpblB0cjxQREZEZXN0aW5hdGlv bj4+PiBfbGlua0Rlc3RpbmF0aW9uc1BlclBhZ2U7CiAKICAgICB1aW50NjRfdCBfZXhwZWN0ZWRD b21wdXRlZFBhZ2VzQ2FsbGJhY2s7CiAgICAgSGFzaE1hcDx1aW50NjRfdCwgV2ViQ29yZTo6SW50 UmVjdD4gX2V4cGVjdGVkUHJldmlld0NhbGxiYWNrczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQyL1VJUHJvY2Vzcy9tYWMvV0tQcmludGluZ1ZpZXcubW0gYi9Tb3VyY2UvV2ViS2l0Mi9VSVBy b2Nlc3MvbWFjL1dLUHJpbnRpbmdWaWV3Lm1tCmluZGV4IDNiMTBjZTc1ZjE1ZWM2YjM5ZjExZTYw YTQ2MWI4NmNmNzg1YWU0NGYuLjBhOTUwNjhmMDA2YTJhYzk2NjNjMjZlNzM0ZTg1ZGIwYWNmOWU3 ZGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQyL1VJUHJvY2Vzcy9tYWMvV0tQcmludGluZ1Zp ZXcubW0KKysrIGIvU291cmNlL1dlYktpdDIvVUlQcm9jZXNzL21hYy9XS1ByaW50aW5nVmlldy5t bQpAQCAtNDI3LDYgKzQyNywxMSBAQCBzdGF0aWMgdm9pZCBwcmVwYXJlRGF0YUZvclByaW50aW5n T25TZWNvbmRhcnlUaHJlYWQoV0tQcmludGluZ1ZpZXcgKnZpZXcpCiAgICAgcmV0dXJuIDA7IC8v IEludmFsaWQgcGFnZSBudW1iZXIuCiB9CiAKK3N0YXRpYyBDRlN0cmluZ1JlZiBsaW5rRGVzdGlu YXRpb25OYW1lKFBERkRvY3VtZW50ICpkb2N1bWVudCwgUERGRGVzdGluYXRpb24gKmRlc3RpbmF0 aW9uKQoreworICAgIHJldHVybiAoQ0ZTdHJpbmdSZWYpW05TU3RyaW5nIHN0cmluZ1dpdGhGb3Jt YXQ6QCIlbHUtJWYtJWYiLCAodW5zaWduZWQgbG9uZylbZG9jdW1lbnQgaW5kZXhGb3JQYWdlOmRl c3RpbmF0aW9uLnBhZ2VdLCBkZXN0aW5hdGlvbi5wb2ludC54LCBkZXN0aW5hdGlvbi5wb2ludC55 XTsKK30KKwogLSAodm9pZClfZHJhd1BERkRvY3VtZW50OihQREZEb2N1bWVudCAqKXBkZkRvY3Vt ZW50IHBhZ2U6KHVuc2lnbmVkKXBhZ2UgYXRQb2ludDooTlNQb2ludClwb2ludAogewogICAgIGlm ICghcGRmRG9jdW1lbnQpIHsKQEAgLTQ1Niw2ICs0NjEsMTEgQEAgc3RhdGljIHZvaWQgcHJlcGFy ZURhdGFGb3JQcmludGluZ09uU2Vjb25kYXJ5VGhyZWFkKFdLUHJpbnRpbmdWaWV3ICp2aWV3KQog CiAgICAgQ0dBZmZpbmVUcmFuc2Zvcm0gdHJhbnNmb3JtID0gQ0dDb250ZXh0R2V0Q1RNKGNvbnRl eHQpOwogCisgICAgZm9yIChjb25zdCBhdXRvJiBkZXN0aW5hdGlvbiA6IF9saW5rRGVzdGluYXRp b25zUGVyUGFnZVtwYWdlXSkgeworICAgICAgICBDR1BvaW50IGRlc3RpbmF0aW9uUG9pbnQgPSBD R1BvaW50QXBwbHlBZmZpbmVUcmFuc2Zvcm0oTlNQb2ludFRvQ0dQb2ludChbZGVzdGluYXRpb24g cG9pbnRdKSwgdHJhbnNmb3JtKTsKKyAgICAgICAgQ0dQREZDb250ZXh0QWRkRGVzdGluYXRpb25B dFBvaW50KGNvbnRleHQsIGxpbmtEZXN0aW5hdGlvbk5hbWUocGRmRG9jdW1lbnQsIGRlc3RpbmF0 aW9uLmdldCgpKSwgZGVzdGluYXRpb25Qb2ludCk7CisgICAgfQorCiAgICAgZm9yIChQREZBbm5v dGF0aW9uICphbm5vdGF0aW9uIGluIFtwZGZQYWdlIGFubm90YXRpb25zXSkgewogICAgICAgICBp ZiAoIVthbm5vdGF0aW9uIGlzS2luZE9mQ2xhc3M6cGRmQW5ub3RhdGlvbkxpbmtDbGFzcygpXSkK ICAgICAgICAgICAgIGNvbnRpbnVlOwpAQCAtNDY1LDggKzQ3NSwxOCBAQCBzdGF0aWMgdm9pZCBw cmVwYXJlRGF0YUZvclByaW50aW5nT25TZWNvbmRhcnlUaHJlYWQoV0tQcmludGluZ1ZpZXcgKnZp ZXcpCiAgICAgICAgIFBERkFubm90YXRpb25MaW5rICpsaW5rQW5ub3RhdGlvbiA9IChQREZBbm5v dGF0aW9uTGluayAqKWFubm90YXRpb247CiAjcHJhZ21hIGNsYW5nIGRpYWdub3N0aWMgcG9wCiAg ICAgICAgIE5TVVJMICp1cmwgPSBbbGlua0Fubm90YXRpb24gVVJMXTsKLSAgICAgICAgaWYgKCF1 cmwpCisKKyAgICAgICAgaWYgKCF1cmwpIHsKKyAgICAgICAgICAgIFBERkRlc3RpbmF0aW9uICpk ZXN0aW5hdGlvbiA9IFtsaW5rQW5ub3RhdGlvbiBkZXN0aW5hdGlvbl07CisgICAgICAgICAgICBp ZiAoIWRlc3RpbmF0aW9uKQorICAgICAgICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAgICAg ICBDR1JlY3QgdXJsUmVjdCA9IE5TUmVjdFRvQ0dSZWN0KFtsaW5rQW5ub3RhdGlvbiBib3VuZHNd KTsKKyAgICAgICAgICAgIENHUmVjdCB0cmFuc2Zvcm1lZFJlY3QgPSBDR1JlY3RBcHBseUFmZmlu ZVRyYW5zZm9ybSh1cmxSZWN0LCB0cmFuc2Zvcm0pOworICAgICAgICAgICAgQ0dQREZDb250ZXh0 U2V0RGVzdGluYXRpb25Gb3JSZWN0KGNvbnRleHQsIGxpbmtEZXN0aW5hdGlvbk5hbWUocGRmRG9j dW1lbnQsIGRlc3RpbmF0aW9uKSwgdHJhbnNmb3JtZWRSZWN0KTsKKwogICAgICAgICAgICAgY29u dGludWU7CisgICAgICAgIH0KIAogICAgICAgICBDR1JlY3QgdXJsUmVjdCA9IE5TUmVjdFRvQ0dS ZWN0KFtsaW5rQW5ub3RhdGlvbiBib3VuZHNdKTsKICAgICAgICAgQ0dSZWN0IHRyYW5zZm9ybWVk UmVjdCA9IENHUmVjdEFwcGx5QWZmaW5lVHJhbnNmb3JtKHVybFJlY3QsIHRyYW5zZm9ybSk7CkBA IC01NDksNiArNTY5LDMxIEBAIHN0YXRpYyB2b2lkIHByZXBhcmVEYXRhRm9yUHJpbnRpbmdPblNl Y29uZGFyeVRocmVhZChXS1ByaW50aW5nVmlldyAqdmlldykKICAgICBpZiAoIV9wcmludGVkUGFn ZXNQREZEb2N1bWVudCkgewogICAgICAgICBSZXRhaW5QdHI8TlNEYXRhPiBwZGZEYXRhID0gYWRv cHROUyhbW05TRGF0YSBhbGxvY10gaW5pdFdpdGhCeXRlczpfcHJpbnRlZFBhZ2VzRGF0YS5kYXRh KCkgbGVuZ3RoOl9wcmludGVkUGFnZXNEYXRhLnNpemUoKV0pOwogICAgICAgICBfcHJpbnRlZFBh Z2VzUERGRG9jdW1lbnQgPSBhZG9wdE5TKFtbcGRmRG9jdW1lbnRDbGFzcygpIGFsbG9jXSBpbml0 V2l0aERhdGE6cGRmRGF0YS5nZXQoKV0pOworCisgICAgICAgIHVuc2lnbmVkIHBhZ2VDb3VudCA9 IFtfcHJpbnRlZFBhZ2VzUERGRG9jdW1lbnQgcGFnZUNvdW50XTsKKyAgICAgICAgX2xpbmtEZXN0 aW5hdGlvbnNQZXJQYWdlLmNsZWFyKCk7CisgICAgICAgIF9saW5rRGVzdGluYXRpb25zUGVyUGFn ZS5yZXNpemUocGFnZUNvdW50KTsKKyAgICAgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IHBh Z2VDb3VudDsgaSsrKSB7CisgICAgICAgICAgICBQREZQYWdlICpwYWdlID0gW19wcmludGVkUGFn ZXNQREZEb2N1bWVudCBwYWdlQXRJbmRleDppXTsKKyAgICAgICAgICAgIGZvciAoUERGQW5ub3Rh dGlvbiAqYW5ub3RhdGlvbiBpbiBwYWdlLmFubm90YXRpb25zKSB7CisgICAgICAgICAgICAgICAg aWYgKCFbYW5ub3RhdGlvbiBpc0tpbmRPZkNsYXNzOnBkZkFubm90YXRpb25MaW5rQ2xhc3MoKV0p CisgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVlOworCisjcHJhZ21hIGNsYW5nIGRpYWdub3N0 aWMgcHVzaAorI3ByYWdtYSBjbGFuZyBkaWFnbm9zdGljIGlnbm9yZWQgIi1XZGVwcmVjYXRlZC1k ZWNsYXJhdGlvbnMiCisgICAgICAgICAgICAgICAgUERGQW5ub3RhdGlvbkxpbmsgKmxpbmtBbm5v dGF0aW9uID0gKFBERkFubm90YXRpb25MaW5rICopYW5ub3RhdGlvbjsKKyNwcmFnbWEgY2xhbmcg ZGlhZ25vc3RpYyBwb3AKKyAgICAgICAgICAgICAgICBpZiAobGlua0Fubm90YXRpb24uVVJMKQor ICAgICAgICAgICAgICAgICAgICBjb250aW51ZTsKKworICAgICAgICAgICAgICAgIFBERkRlc3Rp bmF0aW9uICpkZXN0aW5hdGlvbiA9IGxpbmtBbm5vdGF0aW9uLmRlc3RpbmF0aW9uOworICAgICAg ICAgICAgICAgIGlmICghZGVzdGluYXRpb24pCisgICAgICAgICAgICAgICAgICAgIGNvbnRpbnVl OworCisgICAgICAgICAgICAgICAgdW5zaWduZWQgZGVzdGluYXRpb25QYWdlSW5kZXggPSBbX3By aW50ZWRQYWdlc1BERkRvY3VtZW50IGluZGV4Rm9yUGFnZTpkZXN0aW5hdGlvbi5wYWdlXTsKKyAg ICAgICAgICAgICAgICBfbGlua0Rlc3RpbmF0aW9uc1BlclBhZ2VbZGVzdGluYXRpb25QYWdlSW5k ZXhdLmFwcGVuZChkZXN0aW5hdGlvbik7CisgICAgICAgICAgICB9CisgICAgICAgIH0KICAgICB9 CiAKICAgICB1bnNpZ25lZCBwcmludGVkUGFnZU51bWJlciA9IFtzZWxmIF9wYWdlRm9yUmVjdDpu c1JlY3RdIC0gW3NlbGYgX2ZpcnN0UHJpbnRlZFBhZ2VOdW1iZXJdOwo=