72672 2011-11-17 15:34:03 -0800 [chromium] Incremental texture updates are not atomic 2012-01-21 19:31:03 -0800 1 1 1 Unclassified WebKit WebCore Misc. 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 76792 74113 76740 1 nduca reveman abarth aelias cc-bugs enne jamesr reveman webkit.review.bot oldest_to_newest 505290 0 nduca 2011-11-17 15:34:03 -0800 https://bugs.webkit.org/show_bug.cgi?id=72669 disables incremental updates because they cause update artefacts. However, this negatively affects fling performance. We need artefact free flings, and thus we need a way to update tiles without affecting the tiles we have already on the screen. 510465 1 116882 reveman 2011-11-28 21:22:48 -0800 Created attachment 116882 Patch 513377 2 116882 enne 2011-12-01 18:39:11 -0800 Comment on attachment 116882 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=116882&action=review So, just to sanity check, let me talk out loud what I'm seeing this patch do. Forgive me being long-winded, but hopefully this description will be helpful for others: The general idea is that uploads to resources onscreen need to be done into separate textures so that we don't get visible discrepancies. At the end of commit, all the layers/tiles that are visible get put in a list to the side. New managed textures are allocated for all of these resources so they get new texture ids. The commit completes and all contents textures are unprotected. On the next frame, the paint then happens on the main thread. When the next commit starts, we reduce memory to the texture limit, possibly evicting and deleting some of these previously visible textures in that list on the side. Incremental upload occurs. Tree sync happens. At the end of commit, we clear the off-to-the-side texture list, which puts them on the eviction list (if they haven't been deleted), providing a potential cache of evicted textures to use when requesting textures for the next upload. There's additional logic to reuse these potentially evicted textures to prevent texture churn. Then, we start the process over again with moving all currently visible tile/layer textures into that list and replacing them, etc. I have a couple of questions: We currently keep around all the visible in-use tiles, but I'm not totally convinced this is sufficient for offscreen tiles. For example, what if you have tiles A and B that are both offscreen on frame n, but become visible in frame n+1 due to scrolling from either thread. Because they weren't visible on frame n, that means that their textures haven't been replaced. Therefore, they will upload into the same texture ids on frame n+1, possibly causing a visual discrepancy if A uploads and a frame is drawn before B uploads. I'm not sure we want to put *all* textures onto a list every frame, but maybe there's some other more elegant solution. How would this interact with prepainting? Would we consider those textures "in use"? I would suspect you'd need to, otherwise you could scroll on the impl thread onto prepainted but now visible tiles that were being incrementally uploaded as you watched. I almost wonder if it would be more straightforwward to just ask for new textures ahead of time when you know you're going to modify them, rather than trying to preserve and replace them afterwards. Did you consider that sort of approach? I wonder if that might solve the previous problem as well. What prevents a texture in the m_usedTextureList from getting evicted due to memory pressure, getting recycled during requestTexture, and then uploaded on the very next frame. Wouldn't that cause an onscreen texture to get modified while in use? (Or worse, what would prevent a currently onscreen texture from getting deleted during deleteEvictedTextures in beginCommitOnImplThread? I suppose this could happen right now before this patch.) Do we need to reserve all of these textures in m_usedTextureList after we unreserve all the contents textures? I'd feel much better with a test case that bumped up against memory limits and exercised these edge cases. Am I reading it right that all the visible textures go into the used list, even the ones that aren't being modified that frame? If we do end up needing to reserve all the textures in the used list, maybe we should only put the ones that are modified there, so that we don't end up with 2x the average contents texture memory usage. > Source/WebCore/platform/graphics/chromium/ManagedTexture.cpp:69 > + m_textureId = m_textureManager->textureId(m_token); Can you add a comment that the texture id might not be valid here? > Source/WebCore/platform/graphics/chromium/ManagedTexture.h:43 > - static PassOwnPtr<ManagedTexture> create(TextureManager* manager) > + static PassRefPtr<ManagedTexture> create(TextureManager* manager) I'm probably just missing something obvious, but why does this need to become a RefPtr instead of an OwnPtr? It looks like in all cases you transfer ownership from the layer/updater into the m_usedTextureList, which then gets cleared on the next frame. I continue to be skeptical of RefPtr usage (largely because it makes it hard to reason about when and where destruction occurs), and would prefer the clearer semantics of OwnPtr when possible. 514898 3 117840 reveman 2011-12-04 21:48:18 -0800 Created attachment 117840 Patch 515109 4 reveman 2011-12-05 08:55:37 -0800 Thanks for having a look at this. (In reply to comment #2) > (From update of attachment 116882 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=116882&action=review > > So, just to sanity check, let me talk out loud what I'm seeing this patch do. Forgive me being long-winded, but hopefully this description will be helpful for others: > > The general idea is that uploads to resources onscreen need to be done into separate textures so that we don't get visible discrepancies. At the end of commit, all the layers/tiles that are visible get put in a list to the side. New managed textures are allocated for all of these resources so they get new texture ids. The commit completes and all contents textures are unprotected. On the next frame, the paint then happens on the main thread. When the next commit starts, we reduce memory to the texture limit, possibly evicting and deleting some of these previously visible textures in that list on the side. Incremental upload occurs. Tree sync happens. At the end of commit, we clear the off-to-the-side texture list, which puts them on the eviction list (if they haven't been deleted), providing a potential cache of evicted textures to use when requesting textures for the next upload. There's additional logic to reuse these potentially evicted textures to prevent texture churn. Then, we start the process over again with moving all currently visible tile/layer textures into that list and replacing them, etc. I think you got it just right. The new patch will only put the textures being updated in the used texture list instead of all textures. Things are the same other than that. > > I have a couple of questions: > > We currently keep around all the visible in-use tiles, but I'm not totally convinced this is sufficient for offscreen tiles. For example, what if you have tiles A and B that are both offscreen on frame n, but become visible in frame n+1 due to scrolling from either thread. Because they weren't visible on frame n, that means that their textures haven't been replaced. Therefore, they will upload into the same texture ids on frame n+1, possibly causing a visual discrepancy if A uploads and a frame is drawn before B uploads. I'm not sure we want to put *all* textures onto a list every frame, but maybe there's some other more elegant solution. Yes, this has been fixed in latest patch. > > How would this interact with prepainting? Would we consider those textures "in use"? I would suspect you'd need to, otherwise you could scroll on the impl thread onto prepainted but now visible tiles that were being incrementally uploaded as you watched. I almost wonder if it would be more straightforwward to just ask for new textures ahead of time when you know you're going to modify them, rather than trying to preserve and replace them afterwards. Did you consider that sort of approach? I wonder if that might solve the previous problem as well. I think initially we should just consider prepainted tiles as normal tiles in relation to this patch. I don't understand what you mean by "ask for new textures ahead of time when you know you're going to modify them, rather than trying to preserve and replace them afterwards.". Can you elaborate some more? > > What prevents a texture in the m_usedTextureList from getting evicted due to memory pressure, getting recycled during requestTexture, and then uploaded on the very next frame. Wouldn't that cause an onscreen texture to get modified while in use? (Or worse, what would prevent a currently onscreen texture from getting deleted during deleteEvictedTextures in beginCommitOnImplThread? I suppose this could happen right now before this patch.) Do we need to reserve all of these textures in m_usedTextureList after we unreserve all the contents textures? I'd feel much better with a test case that bumped up against memory limits and exercised these edge cases. A list of textures currently used by the impl thread would be helpful here. I guess we just need to make sure that textures currently used by the impl thread are never evicted. I'll work on putting together some unit tests for this. > > Am I reading it right that all the visible textures go into the used list, even the ones that aren't being modified that frame? If we do end up needing to reserve all the textures in the used list, maybe we should only put the ones that are modified there, so that we don't end up with 2x the average contents texture memory usage. I changed this in the latest patch. Only texture that are updated are put in the list now. > > > Source/WebCore/platform/graphics/chromium/ManagedTexture.cpp:69 > > + m_textureId = m_textureManager->textureId(m_token); > > Can you add a comment that the texture id might not be valid here? Done. > > > Source/WebCore/platform/graphics/chromium/ManagedTexture.h:43 > > - static PassOwnPtr<ManagedTexture> create(TextureManager* manager) > > + static PassRefPtr<ManagedTexture> create(TextureManager* manager) > > I'm probably just missing something obvious, but why does this need to become a RefPtr instead of an OwnPtr? It looks like in all cases you transfer ownership from the layer/updater into the m_usedTextureList, which then gets cleared on the next frame. I continue to be skeptical of RefPtr usage (largely because it makes it hard to reason about when and where destruction occurs), and would prefer the clearer semantics of OwnPtr when possible. Yeah, some initial work I did on this patch required RefPtr but the current version doesn't. I changed it to OwnPtr in latest patch. 515132 5 enne 2011-12-05 09:17:33 -0800 (In reply to comment #4) > Thanks for having a look at this. > > (In reply to comment #2) > > How would this interact with prepainting? Would we consider those textures "in use"? I would suspect you'd need to, otherwise you could scroll on the impl thread onto prepainted but now visible tiles that were being incrementally uploaded as you watched. I almost wonder if it would be more straightforwward to just ask for new textures ahead of time when you know you're going to modify them, rather than trying to preserve and replace them afterwards. Did you consider that sort of approach? I wonder if that might solve the previous problem as well. > > I don't understand what you mean by "ask for new textures ahead of time when you know you're going to modify them, rather than trying to preserve and replace them afterwards.". Can you elaborate some more? So, right now, at the end of commit, you're replacing textures that are in use. My suggestion was to allocate new tokens/textures directly at the point you know you're going to change their contents. If you're uploading into a tile texture, for instance, you could call some special "reserveNew" function that put the old texture token on some eviction list (one that couldn't get reused this frame) and generated a new token for that managed texture. If the tile contents are still valid, you could just use the old reserve function and not allocate a new texture for it. > > What prevents a texture in the m_usedTextureList from getting evicted due to memory pressure, getting recycled during requestTexture, and then uploaded on the very next frame. Wouldn't that cause an onscreen texture to get modified while in use? (Or worse, what would prevent a currently onscreen texture from getting deleted during deleteEvictedTextures in beginCommitOnImplThread? I suppose this could happen right now before this patch.) Do we need to reserve all of these textures in m_usedTextureList after we unreserve all the contents textures? I'd feel much better with a test case that bumped up against memory limits and exercised these edge cases. > > A list of textures currently used by the impl thread would be helpful here. I guess we just need to make sure that textures currently used by the impl thread are never evicted. I think all the textures that the impl thread knows about are potentially usable. I think reserving textures is the mechanism that already exists to prevent these textures that are being used from being evicted. > I'll work on putting together some unit tests for this. Excellent. 516180 6 reveman 2011-12-06 13:01:50 -0800 (In reply to comment #5) > (In reply to comment #4) > > Thanks for having a look at this. > > > > (In reply to comment #2) > > > > How would this interact with prepainting? Would we consider those textures "in use"? I would suspect you'd need to, otherwise you could scroll on the impl thread onto prepainted but now visible tiles that were being incrementally uploaded as you watched. I almost wonder if it would be more straightforwward to just ask for new textures ahead of time when you know you're going to modify them, rather than trying to preserve and replace them afterwards. Did you consider that sort of approach? I wonder if that might solve the previous problem as well. > > > > I don't understand what you mean by "ask for new textures ahead of time when you know you're going to modify them, rather than trying to preserve and replace them afterwards.". Can you elaborate some more? > > So, right now, at the end of commit, you're replacing textures that are in use. My suggestion was to allocate new tokens/textures directly at the point you know you're going to change their contents. If you're uploading into a tile texture, for instance, you could call some special "reserveNew" function that put the old texture token on some eviction list (one that couldn't get reused this frame) and generated a new token for that managed texture. If the tile contents are still valid, you could just use the old reserve function and not allocate a new texture for it. This is pretty much how the new version of patch works. Though I still use the replaceTexture mechanism. I like the idea of having this controlled from outside the texture manager as there will be situations where we don't need new textures for commits (CCSingleThreadProxy) and when we can release the textures used by the impl thread will be different when we land the upcoming async commit patch. > > > > What prevents a texture in the m_usedTextureList from getting evicted due to memory pressure, getting recycled during requestTexture, and then uploaded on the very next frame. Wouldn't that cause an onscreen texture to get modified while in use? (Or worse, what would prevent a currently onscreen texture from getting deleted during deleteEvictedTextures in beginCommitOnImplThread? I suppose this could happen right now before this patch.) Do we need to reserve all of these textures in m_usedTextureList after we unreserve all the contents textures? I'd feel much better with a test case that bumped up against memory limits and exercised these edge cases. > > > > A list of textures currently used by the impl thread would be helpful here. I guess we just need to make sure that textures currently used by the impl thread are never evicted. > > I think all the textures that the impl thread knows about are potentially usable. I think reserving textures is the mechanism that already exists to prevent these textures that are being used from being evicted. Yea, the problem is that textures currently used by the impl thread are not reserved, right? 517523 7 118415 reveman 2011-12-08 10:24:49 -0800 Created attachment 118415 Patch Protect visible textures properly. 517918 8 118415 enne 2011-12-08 16:50:30 -0800 Comment on attachment 118415 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=118415&action=review (What patch is this supposed to apply against?) > Source/WebCore/platform/graphics/chromium/ManagedTexture.cpp:70 > + // This will return 0 if texture has not yet been allocated. > + m_textureId = m_textureManager->textureId(m_token); This is unnecessary, given line 65 above. > Source/WebCore/platform/graphics/chromium/TextureManager.cpp:316 > + info.textureId = m_evictedTextures[i].textureId; You should also set the textureId reference here to return this to the caller. > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:381 > + if (tile->m_firstUpdate) { > tile->m_dirtyLayerRect = m_tiler->tileLayerRect(tile); Don't we set the dirty layer rect in createTile? Why do we need this flag? > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:-387 > - if (!tile->managedTexture()->reserve(m_tiler->tileSize(), m_textureFormat)) { > - m_skipsDraw = true; > - cleanupResources(); > - return; Where does this logic move to? > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:389 > + if (tile->m_dirtyLayerRect.isEmpty()) > + continue; > + > + if (!tile->managedTexture()->isValid(m_tiler->tileSize(), m_textureFormat)) > + tile->m_dirtyLayerRect = m_tiler->tileLayerRect(tile); I think these checks are in the wrong order? Or, the early out for an empty dirty rect shouldn't be there? If a tile texture isn't valid but that tile hasn't been invalidated, doesn't it still need to be painted and considered dirty? > Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp:401 > + // Unprotect all textures prior to calling protectTextures(). > + // protectTextures() will reserve all visible textures and leave > + // the rest unprotected. > + m_layerTreeHost->contentsTextureManager()->unprotectAllTextures(); Am I right in understanding that you unprotect/protect here so that visible textures from the previous frame and the current frame are still reserved and won't get evicted and deleted at the beginning of the frame? What about textures visible in frame n-2 but not visible now? I guess I'm just not sure that "visible" is the right set to be protecting here. Any texture that the impl tree knows about shouldn't be evicted and deleted, right? 518933 9 reveman 2011-12-11 16:01:19 -0800 Sorry for delayed response. (In reply to comment #8) > (From update of attachment 118415 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=118415&action=review > > (What patch is this supposed to apply against?) I just split 72752 into two patches so this patch now depends on both 72752 and 72192. > > > Source/WebCore/platform/graphics/chromium/ManagedTexture.cpp:70 > > + // This will return 0 if texture has not yet been allocated. > > + m_textureId = m_textureManager->textureId(m_token); > > This is unnecessary, given line 65 above. Oh, I didn't notice a textureId reference being passed to requestTexture. That's exactly what we need here. > > > Source/WebCore/platform/graphics/chromium/TextureManager.cpp:316 > > + info.textureId = m_evictedTextures[i].textureId; > > You should also set the textureId reference here to return this to the caller. > > > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:381 > > + if (tile->m_firstUpdate) { > > tile->m_dirtyLayerRect = m_tiler->tileLayerRect(tile); > > Don't we set the dirty layer rect in createTile? Why do we need this flag? Fixed. > > > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:-387 > > - if (!tile->managedTexture()->reserve(m_tiler->tileSize(), m_textureFormat)) { > > - m_skipsDraw = true; > > - cleanupResources(); > > - return; > > Where does this logic move to? Should have moved to protectTileTextures. Fixed in new patch. > > > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:389 > > + if (tile->m_dirtyLayerRect.isEmpty()) > > + continue; > > + > > + if (!tile->managedTexture()->isValid(m_tiler->tileSize(), m_textureFormat)) > > + tile->m_dirtyLayerRect = m_tiler->tileLayerRect(tile); > > I think these checks are in the wrong order? Or, the early out for an empty dirty rect shouldn't be there? If a tile texture isn't valid but that tile hasn't been invalidated, doesn't it still need to be painted and considered dirty? I was trying to use the valid state of textures to determine whether they can be partially updated or not. I realized that this doesn't work as textures can then be invalid for two reasons: 1. Been reused because they are not visible. 2. Requires non-partial update. The new patch that I'm about to upload does this differently. First a quick explanation of what this patch needs to accomplish; if partial texture uploads are allowed or not should be controlled by the CCProxy. The CCProxy also needs to be able to control what textures are protected as they need to be protected until they are no longer used by the impl thread. The tricky part is that the layer area that needs to be updated depend on if partial updates can be used or not. So this information must be available to prepareToUpdateIfDirty(). My new patch does the following: In CCThreadProxy::beginFrameAndCommit(): 1. Call unprotectAllTextures() 2. Call prepareToUpdate(). prepareToUpdateIfDirty() can tell if partial updates are necessary based on if they are protected or not. In this case none of them are protected. [1] 3. Steal all textures that have been determined to need update as these textures, if valid, are currently used by the impl thread. 4. Protect all impl side textures that are about to be updated. 5. Call protectTextures(). This will reserve and protect all visible textures including the ones that we're about to update. 6. prepareFrameResourcesOnImplThread. This is the step that runs synchronously on the impl side and allows the texture updater to allocate compositor resources. 7. Call updateContents() to paint and start uploading of new textures. 8. Commit. 9. Release textures previously used by the impl thread. Here's the simpler CCSingleThreadProxy method: 1. Call prepareToUpdate(). All currently used textures are protected so prepareToUpdateIfDirty() knows that partial updates can be used. 2. Call unprotectAllTextures(). 3. Call protectTextures(). Reserve and protect currently visible textures. 7. prepareFrameResourcesOnImplThread. 7. Call updateContents() to paint and start uploading of new textures. 8. Commit. Let me know if there's any part of this that doesn't seem correct. [1] We might want to use a different property than isProtected to tell if partial update is possible. 518934 10 118715 reveman 2011-12-11 16:01:40 -0800 Created attachment 118715 Patch 519754 11 enne 2011-12-12 18:23:32 -0800 (In reply to comment #9) I'm replying to your strategy here and not the patch itself. > My new patch does the following: > > In CCThreadProxy::beginFrameAndCommit(): > > 1. Call unprotectAllTextures() This might be minor, but if possible can we can we do this at the end of commit? I think the logic is easier to understand if we don't carry texture reservation between frames. > 2. Call prepareToUpdate(). prepareToUpdateIfDirty() can tell if partial updates are necessary based on if they are protected or not. In this case none of them are protected. [1] > 3. Steal all textures that have been determined to need update as these textures, if valid, are currently used by the impl thread. > 4. Protect all impl side textures that are about to be updated. Just for clarification, do you mean protect the old textures that were replaced or the new replacement textures? > 5. Call protectTextures(). This will reserve and protect all visible textures including the ones that we're about to update. > 6. prepareFrameResourcesOnImplThread. This is the step that runs synchronously on the impl side and allows the texture updater to allocate compositor resources. > 7. Call updateContents() to paint and start uploading of new textures. > 8. Commit. > 9. Release textures previously used by the impl thread. By release, do you mean evict? Or delete? Or both? In general, where does texture deletion happen in this strategy? > Here's the simpler CCSingleThreadProxy method: > > 1. Call prepareToUpdate(). All currently used textures are protected so prepareToUpdateIfDirty() knows that partial updates can be used. > 2. Call unprotectAllTextures(). > 3. Call protectTextures(). Reserve and protect currently visible textures. > 7. prepareFrameResourcesOnImplThread. > 7. Call updateContents() to paint and start uploading of new textures. > 8. Commit. > > > [1] We might want to use a different property than isProtected to tell if partial update is possible. Yes, please. Maybe pass an explicit setting to the layer or something? I think I'd just prefer the two proxies to behave as similarly as is reasonably possible with respect to commit behavior, just for sanity's sake. > Let me know if there's any part of this that doesn't seem correct. Two things: klobag added a texture recycling patch not so long ago (see TextureManager::replaceTexture) that, when allocating textures over the reclamation limit pulls non-protected (and non-evicted) textures off the LRU list and reuses them. It seems like with the above scheme we could replace an in-use texture on the impl thread that wasn't visible and protected. I'm not sure that patch is compatible at all with non-atomic updates. Do you have any thoughts on how to make these work together? What about LRU and texture reservation? It seems like we want to definitely evict the old version of any modified textures at the end of the frame, but if we reserved them (in step #4) then they'd move to the front of the LRU queue and other (still valid) textures might get evicted first. How is this handled? 520100 12 nduca 2011-12-13 08:49:35 -0800 (In reply to comment #11) > (In reply to comment #9) > > I'm replying to your strategy here and not the patch itself. Should we have a phone call to hammer our strategy out here? High level, we're going on 2 weeks on this bug... 520112 13 reveman 2011-12-13 09:02:21 -0800 (In reply to comment #11) > (In reply to comment #9) > > I'm replying to your strategy here and not the patch itself. > > > My new patch does the following: > > > > In CCThreadProxy::beginFrameAndCommit(): > > > > 1. Call unprotectAllTextures() > > This might be minor, but if possible can we can we do this at the end of commit? I think the logic is easier to understand if we don't carry texture reservation between frames. The reason I did it here is that I want to make sure that textures used by the impl thread are protected between frames. I guess it would be safe to move this to the end of commit if I can make the assumption that no texture reservation is done except for when LayerChromium::protectTextures() is called. Btw, with the async commit support I'm working on, end of commit becomes a bit more fuzzy.. > > > 2. Call prepareToUpdate(). prepareToUpdateIfDirty() can tell if partial updates are necessary based on if they are protected or not. In this case none of them are protected. [1] > > 3. Steal all textures that have been determined to need update as these textures, if valid, are currently used by the impl thread. > > 4. Protect all impl side textures that are about to be updated. > > Just for clarification, do you mean protect the old textures that were replaced or the new replacement textures? New replacement textures and old textures that are visible but don't need update. > > > 5. Call protectTextures(). This will reserve and protect all visible textures including the ones that we're about to update. > > 6. prepareFrameResourcesOnImplThread. This is the step that runs synchronously on the impl side and allows the texture updater to allocate compositor resources. > > 7. Call updateContents() to paint and start uploading of new textures. > > 8. Commit. > > 9. Release textures previously used by the impl thread. > > By release, do you mean evict? Or delete? Or both? In general, where does texture deletion happen in this strategy? By release, I mean that the texture manager tokens are release as a result of deleting ManagedTexture instances. Texture manager puts textures in the evicted textures list when tokens are released. Texture deletion is happening in the same place as before: CCLayerTreeHost::beginCommitOnImplThread. > > > Here's the simpler CCSingleThreadProxy method: > > > > 1. Call prepareToUpdate(). All currently used textures are protected so prepareToUpdateIfDirty() knows that partial updates can be used. > > 2. Call unprotectAllTextures(). > > 3. Call protectTextures(). Reserve and protect currently visible textures. > > 7. prepareFrameResourcesOnImplThread. > > 7. Call updateContents() to paint and start uploading of new textures. > > 8. Commit. > > > > > > [1] We might want to use a different property than isProtected to tell if partial update is possible. > > Yes, please. Maybe pass an explicit setting to the layer or something? I think I'd just prefer the two proxies to behave as similarly as is reasonably possible with respect to commit behavior, just for sanity's sake. I think it makes more sense to have this be a ManagedTexture or TextureManager setting rather than part of the layer. Asynchronous commit support will require the commit and texture protection process to be a bit different between the two proxies. So one of goals of this patch is to allow some of that difference. No more than necessary though. > > > Let me know if there's any part of this that doesn't seem correct. > > Two things: > > klobag added a texture recycling patch not so long ago (see TextureManager::replaceTexture) that, when allocating textures over the reclamation limit pulls non-protected (and non-evicted) textures off the LRU list and reuses them. It seems like with the above scheme we could replace an in-use texture on the impl thread that wasn't visible and protected. I'm not sure that patch is compatible at all with non-atomic updates. Do you have any thoughts on how to make these work together? Yes, we can't allow that to happen. My current approach of keeping all visible textures protected between frames should make sure this isn't a problem. The texture recycling can still make use of non-visible textures as they wont be protected. > > What about LRU and texture reservation? It seems like we want to definitely evict the old version of any modified textures at the end of the frame, but if we reserved them (in step #4) then they'd move to the front of the LRU queue and other (still valid) textures might get evicted first. How is this handled? The old version of the modified textures are always evicted as soon as is safe to do so. They should be last in the LRU list as they are protected before all other textures but it shouldn't matter as the ManagedTexture instances are deleted which forces them to be evicted independent of their LRU position. 520114 14 reveman 2011-12-13 09:03:29 -0800 (In reply to comment #12) > (In reply to comment #11) > > (In reply to comment #9) > > > > I'm replying to your strategy here and not the patch itself. > > Should we have a phone call to hammer our strategy out here? High level, we're going on 2 weeks on this bug... Sounds good. I'll schedule something asap. 520184 15 enne 2011-12-13 10:50:16 -0800 (In reply to comment #13) > (In reply to comment #11) Re: phonecall. I think this is on the right path, and I hope it doesn't seem like I'm trying to block this patch. It's more that I got this wrong originally, and I want to make sure that there's not some corner case where we're going to be displaying inconsistent textures to the user. I suspect it'll be extremely difficult to repro such an interaction between commit and texture eviction, so I'd like to make sure we get this right. > > klobag added a texture recycling patch not so long ago (see TextureManager::replaceTexture) that, when allocating textures over the reclamation limit pulls non-protected (and non-evicted) textures off the LRU list and reuses them. It seems like with the above scheme we could replace an in-use texture on the impl thread that wasn't visible and protected. I'm not sure that patch is compatible at all with non-atomic updates. Do you have any thoughts on how to make these work together? > > Yes, we can't allow that to happen. My current approach of keeping all visible textures protected between frames should make sure this isn't a problem. The texture recycling can still make use of non-visible textures as they wont be protected. ...but the non-visible/non-protected textures could become visible on the impl thread, via impl-only scrolling, and get reused for some entirely different texture while it's visible to the user. That's my worry. Am I missing something? 520207 16 reveman 2011-12-13 11:16:04 -0800 (In reply to comment #15) > (In reply to comment #13) > > (In reply to comment #11) > > Re: phonecall. I think this is on the right path, and I hope it doesn't seem like I'm trying to block this patch. It's more that I got this wrong originally, and I want to make sure that there's not some corner case where we're going to be displaying inconsistent textures to the user. I suspect it'll be extremely difficult to repro such an interaction between commit and texture eviction, so I'd like to make sure we get this right. I think I have something that works well now but wouldn't be comfortable landing this unless all of us understand exactly how it works and agree that it's accurate. A phone call seems like a good way to get there. > > > > klobag added a texture recycling patch not so long ago (see TextureManager::replaceTexture) that, when allocating textures over the reclamation limit pulls non-protected (and non-evicted) textures off the LRU list and reuses them. It seems like with the above scheme we could replace an in-use texture on the impl thread that wasn't visible and protected. I'm not sure that patch is compatible at all with non-atomic updates. Do you have any thoughts on how to make these work together? > > > > Yes, we can't allow that to happen. My current approach of keeping all visible textures protected between frames should make sure this isn't a problem. The texture recycling can still make use of non-visible textures as they wont be protected. > > ...but the non-visible/non-protected textures could become visible on the impl thread, via impl-only scrolling, and get reused for some entirely different texture while it's visible to the user. > > That's my worry. Am I missing something? OK, I wasn't sure about this. We just need to protect all textures then. This is a minor change. hm, this makes the texture manager (except the reuse of evicted textures part) sort of useless though. 520337 17 jamesr 2011-12-13 13:28:28 -0800 The dependencies listed on this bug still bother me. This needs to be independent of https://bugs.webkit.org/show_bug.cgi?id=72192 and of https://bugs.webkit.org/show_bug.cgi?id=72752, if for no other reason than we need atomicity on some platforms where we don't want to initialize before painting or upload in parallel with painting. Is there an actual code dependency on the features those patches implement? 520348 18 reveman 2011-12-13 13:43:52 -0800 (In reply to comment #17) > The dependencies listed on this bug still bother me. This needs to be independent of https://bugs.webkit.org/show_bug.cgi?id=72192 and of https://bugs.webkit.org/show_bug.cgi?id=72752, if for no other reason than we need atomicity on some platforms where we don't want to initialize before painting or upload in parallel with painting. Is there an actual code dependency on the features those patches implement? Yes, this depends on features provided by those patches. I'm working on a way around that but it's probably going to take significantly longer to get that ready than landing those patches. 520349 19 jamesr 2011-12-13 13:45:12 -0800 (In reply to comment #18) > (In reply to comment #17) > > The dependencies listed on this bug still bother me. This needs to be independent of https://bugs.webkit.org/show_bug.cgi?id=72192 and of https://bugs.webkit.org/show_bug.cgi?id=72752, if for no other reason than we need atomicity on some platforms where we don't want to initialize before painting or upload in parallel with painting. Is there an actual code dependency on the features those patches implement? > > Yes, this depends on features provided by those patches. I'm working on a way around that but it's probably going to take significantly longer to get that ready than landing those patches. We aren't going to enable the _features_ in those patches (like parallel uploading) on all platforms, but we still need atomicity. So what's the plan? 520352 20 jamesr 2011-12-13 13:47:39 -0800 (In reply to comment #18) > (In reply to comment #17) > > The dependencies listed on this bug still bother me. This needs to be independent of https://bugs.webkit.org/show_bug.cgi?id=72192 and of https://bugs.webkit.org/show_bug.cgi?id=72752, if for no other reason than we need atomicity on some platforms where we don't want to initialize before painting or upload in parallel with painting. Is there an actual code dependency on the features those patches implement? > > Yes, this depends on features provided by those patches. I'm working on a way around that but it's probably going to take significantly longer to get that ready than landing those patches. Or perhaps by features do you mean code constructs (like the iterators), but not actual features in terms of new behaviors? If so then please hoist those into this patch and make it the root of the dependency tree. We need atomicity in order to enable the already-checked-in-but-disabled incremental upload logic. As far as I know we do not need any other features in order to have incremental uploads. 522771 21 119619 reveman 2011-12-16 09:13:55 -0800 Created attachment 119619 Patch 522772 22 reveman 2011-12-16 09:15:22 -0800 New version without dependencies. 524317 23 119619 jamesr 2011-12-19 17:15:25 -0800 Comment on attachment 119619 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=119619&action=review The basic idea seems good but there's some logic here that is either incomplete or that I don't understand. > Source/WebCore/platform/graphics/chromium/ManagedTexture.cpp:110 > + ManagedTexture* texture = new ManagedTexture(m_textureManager, m_token, m_size, m_format, m_textureId); in any constructor function like this you should adoptPtr() and store into a local OwnPtr<> immediately. > Source/WebCore/platform/graphics/chromium/ManagedTexture.h:65 > + PassOwnPtr<ManagedTexture> steal(); What does 'steal()' mean? This needs some docs > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:386 > + if (tile->isDirty() && layerTreeHost() && !layerTreeHost()->settings().partialUpdates) > + layerTreeHost()->appendUsedTextureOnImplThread(tile->managedTexture()->steal()); so if I understand correctly, if we hit this logic we 'steal' the texture to make sure that the isValid() check on the next line fails. this seems a bit indirect - could we instead swap out the tiler's ManagedTexture for a new one in a less magical fashion? > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp:97 > + // Update m_settings based on partial update capability. > + m_settings.partialUpdates = m_proxy->partialUpdateCapability(); if it's a capability, why is it on CCLayerTreeHost::settings() instead of CCLayerTreeHost::capabilities() ? > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp:512 > +void CCLayerTreeHost::appendUsedTextureOnImplThread(PassOwnPtr<ManagedTexture> texture) > +{ > + m_usedTexturesOnImplThread.append(texture); if you have a function like this that is expected to be called on a particular thread, please check that with an ASSERT(CCProxy::isImplThread()). > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h:243 > + TextureList m_usedTexturesOnImplThread; what's this used for? I see a call to append entries to this, and I see a call to clear it, but I don't see any logic that uses this vector. > Source/WebCore/platform/graphics/chromium/cc/CCProxy.h:83 > + virtual bool partialUpdateCapability() const = 0; > + I'm not sure what this means and the name isn't helping me. What does it mean to have a 'partial update capability'? Naively I would expect this to mean that the proxy is capable of doing partial updates, but the implementations return true for CCSingleThreadProxy and false for CCThreadProxy which is the exact opposite of what I would expect. > Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp:47 > +static const size_t updatesPerFrame = 5; the only place that (usefully) uses this value is in scheduleActionUpdateMoreResources(), so I think it'd be clearer to leave this value a function static const in there > Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp:578 > + return updatesPerFrame == numeric_limits<size_t>::max(); this doesn't make any sense - both constants you are comparing here are defined inside this .cpp and clearly aren't equal. Why isn't this just 'return false'? > Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp:181 > + std::vector<WebGLId> m_textures; > + std::set<WebGLId> m_usedTextures; using namespace std; please 524318 24 119619 jamesr 2011-12-19 17:16:09 -0800 Comment on attachment 119619 Patch Setting r- for now until feedback is addressed. 524651 25 reveman 2011-12-20 09:29:52 -0800 (In reply to comment #23) > (From update of attachment 119619 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=119619&action=review > > The basic idea seems good but there's some logic here that is either incomplete or that I don't understand. > > > Source/WebCore/platform/graphics/chromium/ManagedTexture.cpp:110 > > + ManagedTexture* texture = new ManagedTexture(m_textureManager, m_token, m_size, m_format, m_textureId); > > in any constructor function like this you should adoptPtr() and store into a local OwnPtr<> immediately. Sure, I'll fix that if we want to keep this constructor. > > > Source/WebCore/platform/graphics/chromium/ManagedTexture.h:65 > > + PassOwnPtr<ManagedTexture> steal(); > > What does 'steal()' mean? This needs some docs > > > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:386 > > + if (tile->isDirty() && layerTreeHost() && !layerTreeHost()->settings().partialUpdates) > > + layerTreeHost()->appendUsedTextureOnImplThread(tile->managedTexture()->steal()); > > so if I understand correctly, if we hit this logic we 'steal' the texture to make sure that the isValid() check on the next line fails. this seems a bit indirect - could we instead swap out the tiler's ManagedTexture for a new one in a less magical fashion? You can find an alternative to the "steal()" approach in the first attachment of this bug. That patch instead adds a LayerTextureUpdater::Texture::replaceTexture function. Do you prefer that? I'm not a huge fan of either approach so let me know if you have any other ideas. > > > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp:97 > > + // Update m_settings based on partial update capability. > > + m_settings.partialUpdates = m_proxy->partialUpdateCapability(); > > if it's a capability, why is it on CCLayerTreeHost::settings() instead of CCLayerTreeHost::capabilities() ? It's not a renderer capability so I don't think it should be part of CCLayerTreeHost::layerRendererCapabilities(). Are you suggesting that we add a CCLayerTreeHost::capabilities()? Sure, I can do that if you prefer that over putting it in CCLayerTreeHost::settings(). > > > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.cpp:512 > > +void CCLayerTreeHost::appendUsedTextureOnImplThread(PassOwnPtr<ManagedTexture> texture) > > +{ > > + m_usedTexturesOnImplThread.append(texture); > > if you have a function like this that is expected to be called on a particular thread, please check that with an ASSERT(CCProxy::isImplThread()). hm, need a better name for that function. It's not actually supposed to be called on the impl thread. It's called on the main thread and adds a texture to the list of textures used on the impl thread. So the "OnImplThread" prefix is accurate but confusing as already used to indicate that the function should be called on the impl thread. > > > Source/WebCore/platform/graphics/chromium/cc/CCLayerTreeHost.h:243 > > + TextureList m_usedTexturesOnImplThread; > > what's this used for? I see a call to append entries to this, and I see a call to clear it, but I don't see any logic that uses this vector. It's just a list of textures that can't be released because they might be used by the impl thread for intermediate drawing between texture uploads. Textures are added to this list during "prepareToUpdate" and then released after commit completion when we know that they are not used by impl thread anymore. > > > Source/WebCore/platform/graphics/chromium/cc/CCProxy.h:83 > > + virtual bool partialUpdateCapability() const = 0; > > + > > I'm not sure what this means and the name isn't helping me. What does it mean to have a 'partial update capability'? Naively I would expect this to mean that the proxy is capable of doing partial updates, but the implementations return true for CCSingleThreadProxy and false for CCThreadProxy which is the exact opposite of what I would expect. It means that the proxy supports partial texture updates. If this is not supported by the proxy, full texture updates are required. Maybe partialTextureUpdateCapability() is a better name? > > > Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp:47 > > +static const size_t updatesPerFrame = 5; > > the only place that (usefully) uses this value is in scheduleActionUpdateMoreResources(), so I think it'd be clearer to leave this value a function static const in there Well, we need it to determine if partial texture updates are possible. See below. > > > Source/WebCore/platform/graphics/chromium/cc/CCThreadProxy.cpp:578 > > + return updatesPerFrame == numeric_limits<size_t>::max(); > > this doesn't make any sense - both constants you are comparing here are defined inside this .cpp and clearly aren't equal. Why isn't this just 'return false'? The code was slightly adjusted to allow updatesPerFrame to be configurable. A value of std::numeric_limits<size_t>::max() would be equal to disabling interleaved texture updates. Being able to experiment with different updatesPerFrame values by just changing the updatesPerFrame constant and not having to remember to adjust the value returned by CCThreadProxy::partialUpdateCapability() is what I prefer. I'll change this to "return false" and make "updatesPerFrame" a function static const if you prefer that. > > > Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp:181 > > + std::vector<WebGLId> m_textures; > > + std::set<WebGLId> m_usedTextures; > > using namespace std; please Sure. FYI, std:: is currently used instead of "using namespace std" everywhere in chromium/tests except for ScrollAnimatorNoneTest.cpp. 528650 26 jamesr 2012-01-02 20:15:08 -0800 I see, and the ManagedTextures are held alive artificially so that their texture IDs aren't reused by the TextureManager? This needs some comments at least. Is there no better way to deal with texture reuse? 531178 27 121449 reveman 2012-01-06 11:10:16 -0800 Created attachment 121449 Patch 531185 28 reveman 2012-01-06 11:14:58 -0800 (In reply to comment #26) > I see, and the ManagedTextures are held alive artificially so that their texture IDs aren't reused by the TextureManager? This needs some comments at least. Is there no better way to deal with texture reuse? It's not really a reuse issue. It's just that the textures used on the impl thread can't be deleted until the commit completes. Updated patch includes these changes: - Have ManagedTexture::steal() store in local OwnPtr<> immediately. - CCLayerTreeHost::appendUsedTextureOnImplThread renamed to CCLayerTreeHost::deleteTextureAfterCommit. - Rename partialUpdateCapability() to partialTextureUpdateCapability(). - Rename CCThreadProxy.cpp: updatesPerFrame to textureUpdatesPerFrame. - Add "using namespace std" to CCLayerTreeHostTest.cpp. - Add comments to explain ManagedTexture::steal() and its use. 531329 29 121449 jamesr 2012-01-06 13:18:13 -0800 Comment on attachment 121449 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=121449&action=review > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:380 > + if (tile->isDirty() && layerTreeHost() && !layerTreeHost()->settings().partialTextureUpdates) > + layerTreeHost()->deleteTextureAfterCommit(tile->managedTexture()->steal()); one concern i have with this is that it'll force us to do full tile paints + uploads even when on the last upload, for instance if we damage less than 5 tiles total. Example: open this page data:text/html;charset=utf-8,%3C!DOCTYPE%20html%3E%3Cinput%3E and put focus in the input area so the cursor blinks. without this patch, the paints+uploads are 3x16 pixels. with this patch, they are 256x256 and if you get really unlucky with tile boundaries they grow to 1024x1024. that's a pretty serious regression, and I think invalidations that are under the incremental upload limit are the common case. can we somehow make the growth only apply to uploads before the final batch? 531558 30 121449 jamesr 2012-01-06 18:07:31 -0800 Comment on attachment 121449 Patch R-, the performance impact here is too heavy. 532251 31 reveman 2012-01-09 09:54:04 -0800 (In reply to comment #29) > (From update of attachment 121449 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=121449&action=review > > > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:380 > > + if (tile->isDirty() && layerTreeHost() && !layerTreeHost()->settings().partialTextureUpdates) > > + layerTreeHost()->deleteTextureAfterCommit(tile->managedTexture()->steal()); > > one concern i have with this is that it'll force us to do full tile paints + uploads even when on the last upload, for instance if we damage less than 5 tiles total. > > Example: open this page data:text/html;charset=utf-8,%3C!DOCTYPE%20html%3E%3Cinput%3E and put focus in the input area so the cursor blinks. without this patch, the paints+uploads are 3x16 pixels. with this patch, they are 256x256 and if you get really unlucky with tile boundaries they grow to 1024x1024. that's a pretty serious regression, and I think invalidations that are under the incremental upload limit are the common case. > > can we somehow make the growth only apply to uploads before the final batch? Sure, that would be a nice improvement to this patch. How about I update this patch so the functionality can be tested without turning on incremental updates and implement the "final batch" improvement in a follow up patch? 532252 32 121676 reveman 2012-01-09 09:59:09 -0800 Created attachment 121676 Patch 539030 33 jamesr 2012-01-19 14:19:35 -0800 (In reply to comment #31) > (In reply to comment #29) > > (From update of attachment 121449 [details] [details]) > > View in context: https://bugs.webkit.org/attachment.cgi?id=121449&action=review > > > > > Source/WebCore/platform/graphics/chromium/TiledLayerChromium.cpp:380 > > > + if (tile->isDirty() && layerTreeHost() && !layerTreeHost()->settings().partialTextureUpdates) > > > + layerTreeHost()->deleteTextureAfterCommit(tile->managedTexture()->steal()); > > > > one concern i have with this is that it'll force us to do full tile paints + uploads even when on the last upload, for instance if we damage less than 5 tiles total. > > > > Example: open this page data:text/html;charset=utf-8,%3C!DOCTYPE%20html%3E%3Cinput%3E and put focus in the input area so the cursor blinks. without this patch, the paints+uploads are 3x16 pixels. with this patch, they are 256x256 and if you get really unlucky with tile boundaries they grow to 1024x1024. that's a pretty serious regression, and I think invalidations that are under the incremental upload limit are the common case. > > > > can we somehow make the growth only apply to uploads before the final batch? > > Sure, that would be a nice improvement to this patch. How about I update this patch so the functionality can be tested without turning on incremental updates and implement the "final batch" improvement in a follow up patch? I think that's a great approach to take. Can you file a bug about that? 539031 34 121676 jamesr 2012-01-19 14:20:22 -0800 Comment on attachment 121676 Patch R=me 539787 35 123378 reveman 2012-01-20 14:19:19 -0800 Created attachment 123378 Patch 539795 36 reveman 2012-01-20 14:32:45 -0800 Rebased patch and created: https://bugs.webkit.org/show_bug.cgi?id=76740 539804 37 123378 jamesr 2012-01-20 14:44:22 -0800 Comment on attachment 123378 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=123378&action=review Very close, but tests need a bit of love still. > Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp:136 > +class CompositorFakeWebGraphicsContext3D : public FakeWebGraphicsContext3D { how is this different from the one in CompositorFakeWebGraphicsContext3D.h? can you use that one instead, or base this fake off of that fake to add the additional functionality you need (like texture tracking)? > Source/WebKit/chromium/tests/CCLayerTreeHostTest.cpp:186 > + vector<WebGLId> m_textures; > + set<WebGLId> m_usedTextures; we don't use STL containers in WebKit, even in unit tests. Use the WTF types 539839 38 123393 reveman 2012-01-20 15:22:17 -0800 Created attachment 123393 Patch 539879 39 123393 jamesr 2012-01-20 16:04:49 -0800 Comment on attachment 123393 Patch R=me, thanks 540004 40 123393 webkit.review.bot 2012-01-20 18:49:23 -0800 Comment on attachment 123393 Patch Clearing flags on attachment: 123393 Committed r105564: <http://trac.webkit.org/changeset/105564> 540005 41 webkit.review.bot 2012-01-20 18:49:30 -0800 All reviewed patches have been landed. Closing bug. 540180 42 abarth 2012-01-21 15:49:42 -0800 This appears not to compile: ____Ld ../../../../../xcodebuild/Debug/webkit_unit_tests [...] Undefined symbols: "__ZN7WebCore19CCLayerTreeHostImpl23startPageScaleAnimationERKNS_7IntSizeEbfdd", referenced from: __ZTVN12_GLOBAL__N_121MockLayerTreeHostImplE in CCLayerTreeHostTest.o ld: symbol(s) not found clang:error: linker command failed with exit code 1 (use -v to see invocation) 540181 43 abarth 2012-01-21 15:50:01 -0800 (On Chromium Mac) 540196 44 reveman 2012-01-21 17:27:04 -0800 (In reply to comment #42) > This appears not to compile: > > > ____Ld ../../../../../xcodebuild/Debug/webkit_unit_tests > [...] > Undefined symbols: > "__ZN7WebCore19CCLayerTreeHostImpl23startPageScaleAnimationERKNS_7IntSizeEbfdd", referenced from: > __ZTVN12_GLOBAL__N_121MockLayerTreeHostImplE in CCLayerTreeHostTest.o > ld: symbol(s) not found > clang:error: linker command failed with exit code 1 (use -v to see invocation) You sure this patch is causing this? Looks like r105566 is causing it: https://bugs.webkit.org/show_bug.cgi?id=71529 540199 45 reveman 2012-01-21 18:00:28 -0800 Reopening to attach new patch. 540200 46 123465 reveman 2012-01-21 18:00:31 -0800 Created attachment 123465 Patch 540203 47 reveman 2012-01-21 18:03:38 -0800 Latest patch avoids use of std::numeric_limits to fix this build issue: ../platform/graphics/chromium/cc/CCThreadProxy.cpp:47:21: error: declaration requires a global constructor [-Werror,-Wglobal-constructors] static const size_t textureUpdatesPerFrame = numeric_limits<size_t>::max(); ^ ~~~~~~~~~~~~~~~~~~~~~~~~~~~~~ 540214 48 123465 webkit.review.bot 2012-01-21 19:30:55 -0800 Comment on attachment 123465 Patch Clearing flags on attachment: 123465 Committed r105583: <http://trac.webkit.org/changeset/105583> 540215 49 webkit.review.bot 2012-01-21 19:31:03 -0800 All reviewed patches have been landed. Closing bug. 116882 2011-11-28 21:22:48 -0800 2011-12-04 21:48:18 -0800 Patch atomic-texture-updates.diff text/plain 37512 reveman Y29tbWl0IGU0OWRhNTEzMjQ3NDBhMGNlOTMxOTNjZDMzMjhkZDY5MzllOWM2OTUKQXV0aG9yOiBE YXZpZCBSZXZlbWFuIDxyZXZlbWFuQGNocm9taXVtLm9yZz4KRGF0ZTogICBXZWQgTm92IDIzIDAx OjEzOjQxIDIwMTEgLTA1MDAKCiAgICBbQ2hyb21pdW1dIEluY3JlbWVudGFsIHRleHR1cmUgdXBk YXRlcyBhcmUgbm90IGF0b21pYy4KICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD03MjY3MgogICAgCiAgICBTb3VyY2UvV2ViQ29yZToKICAgIAogICAgVXNlIGEgbmV3 IHNldCBvZiB0ZXh0dXJlcyBmb3IgZWFjaCBjb21taXQgd2hlbiBpbmNyZW1lbnRhbAogICAgdGV4 dHVyZSB1cGRhdGVzIGFyZSBlbmFibGVkLiBBdm9pZCB0ZXh0dXJlIHRyYXNoaW5nIGJ5CiAgICBo YXZpbmcgdGV4dHVyZSBtYW5hZ2VyIHJldXNlIGV2aWN0ZWQgdGV4dHVyZXMgd2hlbiBhdmFpbGFi bGUuCiAgICAKICAgIFRoaXMgcGF0Y2ggaXMgdGVzdGVkIGJ5IHRoZSBmb2xsb3dpbmcgdW5pdCB0 ZXN0OgogICAgLSBDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0LnJ1bk11bHRpVGhyZWFk CiAgICAKICAgIFNvdXJjZS9XZWJLaXQvY2hyb21pdW06CiAgICAKICAgIEFkZCBDQ0xheWVyVHJl ZUhvc3RUZXN0QXRvbWljQ29tbWl0IHRlc3QgdGhhdCB2ZXJpZmllcyBhdG9taWNpdHkKICAgIG9m IGNvbW1pdHMgYW5kIHJldXNlIG9mIHRleHR1cmVzLgoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0JpdG1hcENhbnZhc0xheWVyVGV4dHVyZVVw ZGF0ZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQml0 bWFwQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlci5jcHAKaW5kZXggMDc5MDVjMS4uM2NkMzVmZCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQml0 bWFwQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQml0bWFwQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlci5j cHAKQEAgLTM1LDcgKzM1LDcgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1CaXRtYXBDYW52 YXNMYXllclRleHR1cmVVcGRhdGVyOjpUZXh0dXJlOjpUZXh0dXJlKEJpdG1hcENhbnZhc0xheWVy VGV4dHVyZVVwZGF0ZXIqIHRleHR1cmVVcGRhdGVyLCBQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJl PiB0ZXh0dXJlKQorQml0bWFwQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZTo6VGV4 dHVyZShCaXRtYXBDYW52YXNMYXllclRleHR1cmVVcGRhdGVyKiB0ZXh0dXJlVXBkYXRlciwgUGFz c1JlZlB0cjxNYW5hZ2VkVGV4dHVyZT4gdGV4dHVyZSkKICAgICA6IENhbnZhc0xheWVyVGV4dHVy ZVVwZGF0ZXI6OlRleHR1cmUodGV4dHVyZSkKICAgICAsIG1fdGV4dHVyZVVwZGF0ZXIodGV4dHVy ZVVwZGF0ZXIpCiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9CaXRtYXBDYW52YXNMYXllclRleHR1cmVVcGRhdGVyLmggYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9CaXRtYXBDYW52YXNMYXllclRleHR1cmVV cGRhdGVyLmgKaW5kZXggMmU5MWRiYS4uZjQ5ZDk4YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQml0bWFwQ2FudmFzTGF5ZXJUZXh0dXJlVXBk YXRlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0Jp dG1hcENhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXIuaApAQCAtNDIsNyArNDIsNyBAQCBjbGFzcyBC aXRtYXBDYW52YXNMYXllclRleHR1cmVVcGRhdGVyIDogcHVibGljIENhbnZhc0xheWVyVGV4dHVy ZVVwZGF0ZXIgewogcHVibGljOgogICAgIGNsYXNzIFRleHR1cmUgOiBwdWJsaWMgQ2FudmFzTGF5 ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZSB7CiAgICAgcHVibGljOgotICAgICAgICBUZXh0dXJl KEJpdG1hcENhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXIqLCBQYXNzT3duUHRyPE1hbmFnZWRUZXh0 dXJlPik7CisgICAgICAgIFRleHR1cmUoQml0bWFwQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlcios IFBhc3NSZWZQdHI8TWFuYWdlZFRleHR1cmU+KTsKICAgICAgICAgdmlydHVhbCB+VGV4dHVyZSgp OwogCiAgICAgICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVSZWN0KEdyYXBoaWNzQ29udGV4dDNEKiwg Y29uc3QgSW50UmVjdCYgc291cmNlUmVjdCwgY29uc3QgSW50UmVjdCYgZGVzdFJlY3QpOwpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQml0bWFw U2tQaWN0dXJlQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9CaXRtYXBTa1BpY3R1cmVDYW52YXNMYXllclRleHR1 cmVVcGRhdGVyLmNwcAppbmRleCBlMjdiYTk5Li41NTZkNTU1IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9CaXRtYXBTa1BpY3R1cmVDYW52YXNM YXllclRleHR1cmVVcGRhdGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9CaXRtYXBTa1BpY3R1cmVDYW52YXNMYXllclRleHR1cmVVcGRhdGVyLmNw cApAQCAtMzgsNyArMzgsNyBAQAogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKLUJpdG1hcFNrUGlj dHVyZUNhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXI6OlRleHR1cmU6OlRleHR1cmUoQml0bWFwU2tQ aWN0dXJlQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlciogdGV4dHVyZVVwZGF0ZXIsIFBhc3NPd25Q dHI8TWFuYWdlZFRleHR1cmU+IHRleHR1cmUpCitCaXRtYXBTa1BpY3R1cmVDYW52YXNMYXllclRl eHR1cmVVcGRhdGVyOjpUZXh0dXJlOjpUZXh0dXJlKEJpdG1hcFNrUGljdHVyZUNhbnZhc0xheWVy VGV4dHVyZVVwZGF0ZXIqIHRleHR1cmVVcGRhdGVyLCBQYXNzUmVmUHRyPE1hbmFnZWRUZXh0dXJl PiB0ZXh0dXJlKQogICAgIDogQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZSh0ZXh0 dXJlKQogICAgICwgbV90ZXh0dXJlVXBkYXRlcih0ZXh0dXJlVXBkYXRlcikKICAgICAsIG1fbWFw cGVkQnVmZmVyKDApCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9CaXRtYXBTa1BpY3R1cmVDYW52YXNMYXllclRleHR1cmVVcGRhdGVyLmggYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9CaXRtYXBTa1BpY3R1cmVD YW52YXNMYXllclRleHR1cmVVcGRhdGVyLmgKaW5kZXggOTRhODU4Zi4uNGNkOGRmMiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQml0bWFwU2tQ aWN0dXJlQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0JpdG1hcFNrUGljdHVyZUNhbnZhc0xheWVyVGV4dHVy ZVVwZGF0ZXIuaApAQCAtNDAsNyArNDAsNyBAQCBjbGFzcyBCaXRtYXBTa1BpY3R1cmVDYW52YXNM YXllclRleHR1cmVVcGRhdGVyIDogcHVibGljIFNrUGljdHVyZUNhbnZhc0xheWVyVGV4dAogcHVi bGljOgogICAgIGNsYXNzIFRleHR1cmUgOiBwdWJsaWMgQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRl cjo6VGV4dHVyZSB7CiAgICAgcHVibGljOgotICAgICAgICBUZXh0dXJlKEJpdG1hcFNrUGljdHVy ZUNhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXIqLCBQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJlPik7 CisgICAgICAgIFRleHR1cmUoQml0bWFwU2tQaWN0dXJlQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRl ciosIFBhc3NSZWZQdHI8TWFuYWdlZFRleHR1cmU+KTsKIAogICAgICAgICB2aXJ0dWFsIGJvb2wg bmVlZFByZXBhcmVSZWN0KCk7CiAgICAgICAgIHZpcnR1YWwgdm9pZCBwcmVwYXJlUmVjdChHcmFw aGljc0NvbnRleHQzRCosIFRleHR1cmVBbGxvY2F0b3IqLCBjb25zdCBJbnRSZWN0JiBzb3VyY2VS ZWN0LCBjb25zdCBJbnRSZWN0JiBkZXN0UmVjdCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hyb21pdW0uY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNo cm9taXVtLmNwcAppbmRleCBlMDRmMThkLi43ZGE1NTU2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hyb21pdW0uY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0NhbnZhczJE TGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTEwMiw3ICsxMDIsOCBAQCB2b2lkIENhbnZhczJETGF5ZXJD aHJvbWl1bTo6dXBkYXRlQ29tcG9zaXRvclJlc291cmNlcygpCiAKIHZvaWQgQ2FudmFzMkRMYXll ckNocm9taXVtOjpmb3JFYWNoQ29tcG9zaXRvclJlc291cmNlKExheWVyVGV4dHVyZVVwZGF0ZXI6 OkhhbmRsZXImIGhhbmRsZXIpCiB7Ci0gICAgaGFuZGxlci5oYW5kbGUobV91cGRhdGVyVGV4dHVy ZS5nZXQoKSwgSW50UmVjdCgpLCBJbnRSZWN0KCkpOworICAgIEludFJlY3Qgbm9uRW1wdHlSZWN0 KDAsIDAsIDEsIDEpOworICAgIGhhbmRsZXIuaGFuZGxlKG1fdXBkYXRlclRleHR1cmUuZ2V0KCks IG5vbkVtcHR5UmVjdCwgbm9uRW1wdHlSZWN0KTsKIH0KIAogdm9pZCBDYW52YXMyRExheWVyQ2hy b21pdW06OmNvbnRlbnRDaGFuZ2VkKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL0NhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXIuY3BwIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzTGF5ZXJUZXh0dXJl VXBkYXRlci5jcHAKaW5kZXggYzYxZWMzMy4uNTM0ZTc5YiAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRl ci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2Fu dmFzTGF5ZXJUZXh0dXJlVXBkYXRlci5jcHAKQEAgLTM2LDcgKzM2LDcgQEAKIAogbmFtZXNwYWNl IFdlYkNvcmUgewogCi1DYW52YXNMYXllclRleHR1cmVVcGRhdGVyOjpUZXh0dXJlOjpUZXh0dXJl KFBhc3NPd25QdHI8TWFuYWdlZFRleHR1cmU+IHRleHR1cmUpIDogbV90ZXh0dXJlKHRleHR1cmUp CitDYW52YXNMYXllclRleHR1cmVVcGRhdGVyOjpUZXh0dXJlOjpUZXh0dXJlKFBhc3NSZWZQdHI8 TWFuYWdlZFRleHR1cmU+IHRleHR1cmUpIDogbV90ZXh0dXJlKHRleHR1cmUpCiB7CiB9CiAKQEAg LTQ0LDYgKzQ0LDEzIEBAIENhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXI6OlRleHR1cmU6On5UZXh0 dXJlKCkKIHsKIH0KIAorUGFzc1JlZlB0cjxNYW5hZ2VkVGV4dHVyZT4gQ2FudmFzTGF5ZXJUZXh0 dXJlVXBkYXRlcjo6VGV4dHVyZTo6cmVwbGFjZVRleHR1cmUoVGV4dHVyZU1hbmFnZXIqIG1hbmFn ZXIpCit7CisgICAgUmVmUHRyPE1hbmFnZWRUZXh0dXJlPiBvbGQgPSBtX3RleHR1cmU7CisgICAg bV90ZXh0dXJlID0gTWFuYWdlZFRleHR1cmU6OmNyZWF0ZShtYW5hZ2VyKTsKKyAgICByZXR1cm4g b2xkLnJlbGVhc2UoKTsKK30KKwogYm9vbCBDYW52YXNMYXllclRleHR1cmVVcGRhdGVyOjpUZXh0 dXJlOjpuZWVkUHJlcGFyZVJlY3QoKQogewogICAgIHJldHVybiAhbV90ZXh0dXJlLT50ZXh0dXJl SWQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL0NhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0NhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXIuaAppbmRleCA4ODZk MTAxLi45YzUxNWZiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9DYW52YXNMYXllclRleHR1cmVVcGRhdGVyLmgKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlci5o CkBAIC00NSwxNSArNDUsMTYgQEAgcHVibGljOgogICAgICAgICB2aXJ0dWFsIH5UZXh0dXJlKCk7 CiAKICAgICAgICAgdmlydHVhbCBNYW5hZ2VkVGV4dHVyZSogdGV4dHVyZSgpIHsgcmV0dXJuIG1f dGV4dHVyZS5nZXQoKTsgfQorICAgICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8TWFuYWdlZFRleHR1 cmU+IHJlcGxhY2VUZXh0dXJlKFRleHR1cmVNYW5hZ2VyKik7CiAKICAgICAgICAgdmlydHVhbCBi b29sIG5lZWRQcmVwYXJlUmVjdCgpOwogICAgICAgICB2aXJ0dWFsIHZvaWQgcHJlcGFyZVJlY3Qo R3JhcGhpY3NDb250ZXh0M0QqLCBUZXh0dXJlQWxsb2NhdG9yKiwgY29uc3QgSW50UmVjdCYgLyog c291cmNlUmVjdCAqLywgY29uc3QgSW50UmVjdCYgLyogZGVzdFJlY3QgKi8pOwogCiAgICAgcHJv dGVjdGVkOgotICAgICAgICBleHBsaWNpdCBUZXh0dXJlKFBhc3NPd25QdHI8TWFuYWdlZFRleHR1 cmU+KTsKKyAgICAgICAgZXhwbGljaXQgVGV4dHVyZShQYXNzUmVmUHRyPE1hbmFnZWRUZXh0dXJl Pik7CiAKICAgICBwcml2YXRlOgotICAgICAgICBPd25QdHI8TWFuYWdlZFRleHR1cmU+IG1fdGV4 dHVyZTsKKyAgICAgICAgUmVmUHRyPE1hbmFnZWRUZXh0dXJlPiBtX3RleHR1cmU7CiAgICAgfTsK IAogICAgIHZpcnR1YWwgfkNhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXIoKTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0ZyYW1lQnVmZmVyU2tQ aWN0dXJlQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9GcmFtZUJ1ZmZlclNrUGljdHVyZUNhbnZhc0xheWVyVGV4 dHVyZVVwZGF0ZXIuY3BwCmluZGV4IDllZWZiNDYuLjQ3YmQ2NmYgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0ZyYW1lQnVmZmVyU2tQaWN0dXJl Q2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vRnJhbWVCdWZmZXJTa1BpY3R1cmVDYW52YXNMYXllclRleHR1 cmVVcGRhdGVyLmNwcApAQCAtNDQsNyArNDQsNyBAQCBwdWJsaWM6CiAgICAgRnJhbWVCdWZmZXIo KTsKICAgICB+RnJhbWVCdWZmZXIoKTsKIAotICAgIFNrQ2FudmFzKiBpbml0aWFsaXplKEdyYXBo aWNzQ29udGV4dDNEKiwgTWFuYWdlZFRleHR1cmUqKTsKKyAgICBTa0NhbnZhcyogaW5pdGlhbGl6 ZShHcmFwaGljc0NvbnRleHQzRCosIFBhc3NSZWZQdHI8TWFuYWdlZFRleHR1cmU+KTsKIAogcHJp dmF0ZToKICAgICBHcmFwaGljc0NvbnRleHQzRCogbV9jb250ZXh0OwpAQCAtNjYsNyArNjYsNyBA QCBGcmFtZUJ1ZmZlcjo6fkZyYW1lQnVmZmVyKCkKICAgICAgICAgbV9jb250ZXh0LT5kZWxldGVG cmFtZWJ1ZmZlcihtX2Zibyk7CiB9CiAKLVNrQ2FudmFzKiBGcmFtZUJ1ZmZlcjo6aW5pdGlhbGl6 ZShHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgTWFuYWdlZFRleHR1cmUqIHRleHR1cmUpCitT a0NhbnZhcyogRnJhbWVCdWZmZXI6OmluaXRpYWxpemUoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRl eHQsIFBhc3NSZWZQdHI8TWFuYWdlZFRleHR1cmU+IHRleHR1cmUpCiB7CiAgICAgbV9jb250ZXh0 ID0gY29udGV4dDsKICAgICBtX2ZibyA9IG1fY29udGV4dC0+Y3JlYXRlRnJhbWVidWZmZXIoKTsK QEAgLTk1LDcgKzk1LDcgQEAgU2tDYW52YXMqIEZyYW1lQnVmZmVyOjppbml0aWFsaXplKEdyYXBo aWNzQ29udGV4dDNEKiBjb250ZXh0LCBNYW5hZ2VkVGV4dHVyZSogdGUKIAogfSAvLyBuYW1lc3Bh Y2UKIAotRnJhbWVCdWZmZXJTa1BpY3R1cmVDYW52YXNMYXllclRleHR1cmVVcGRhdGVyOjpUZXh0 dXJlOjpUZXh0dXJlKEZyYW1lQnVmZmVyU2tQaWN0dXJlQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRl ciogdGV4dHVyZVVwZGF0ZXIsIFBhc3NPd25QdHI8TWFuYWdlZFRleHR1cmU+IHRleHR1cmUpCitG cmFtZUJ1ZmZlclNrUGljdHVyZUNhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXI6OlRleHR1cmU6OlRl eHR1cmUoRnJhbWVCdWZmZXJTa1BpY3R1cmVDYW52YXNMYXllclRleHR1cmVVcGRhdGVyKiB0ZXh0 dXJlVXBkYXRlciwgUGFzc1JlZlB0cjxNYW5hZ2VkVGV4dHVyZT4gdGV4dHVyZSkKICAgICA6IENh bnZhc0xheWVyVGV4dHVyZVVwZGF0ZXI6OlRleHR1cmUodGV4dHVyZSkKICAgICAsIG1fdGV4dHVy ZVVwZGF0ZXIodGV4dHVyZVVwZGF0ZXIpCiB7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9GcmFtZUJ1ZmZlclNrUGljdHVyZUNhbnZhc0xheWVy VGV4dHVyZVVwZGF0ZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL0ZyYW1lQnVmZmVyU2tQaWN0dXJlQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlci5oCmluZGV4 IGE4ZmY4NWYuLjZjYTg0ZDUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0ZyYW1lQnVmZmVyU2tQaWN0dXJlQ2FudmFzTGF5ZXJUZXh0dXJlVXBk YXRlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0Zy YW1lQnVmZmVyU2tQaWN0dXJlQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlci5oCkBAIC00MCw3ICs0 MCw3IEBAIGNsYXNzIEZyYW1lQnVmZmVyU2tQaWN0dXJlQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRl ciA6IHB1YmxpYyBTa1BpY3R1cmVDYW52YXNMYXllCiBwdWJsaWM6CiAgICAgY2xhc3MgVGV4dHVy ZSA6IHB1YmxpYyBDYW52YXNMYXllclRleHR1cmVVcGRhdGVyOjpUZXh0dXJlIHsKICAgICBwdWJs aWM6Ci0gICAgICAgIFRleHR1cmUoRnJhbWVCdWZmZXJTa1BpY3R1cmVDYW52YXNMYXllclRleHR1 cmVVcGRhdGVyKiwgUGFzc093blB0cjxNYW5hZ2VkVGV4dHVyZT4pOworICAgICAgICBUZXh0dXJl KEZyYW1lQnVmZmVyU2tQaWN0dXJlQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlciosIFBhc3NSZWZQ dHI8TWFuYWdlZFRleHR1cmU+KTsKICAgICAgICAgdmlydHVhbCB+VGV4dHVyZSgpOwogCiAgICAg ICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVSZWN0KEdyYXBoaWNzQ29udGV4dDNEKiwgY29uc3QgSW50 UmVjdCYgc291cmNlUmVjdCwgY29uc3QgSW50UmVjdCYgZGVzdFJlY3QpOwpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vSW1hZ2VMYXllckNocm9t aXVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0ltYWdl TGF5ZXJDaHJvbWl1bS5jcHAKaW5kZXggZjlkODY3NC4uNzQ1YzhhNSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vSW1hZ2VMYXllckNocm9taXVt LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9JbWFn ZUxheWVyQ2hyb21pdW0uY3BwCkBAIC00OCwxMyArNDgsMTkgQEAgY2xhc3MgSW1hZ2VMYXllclRl eHR1cmVVcGRhdGVyIDogcHVibGljIExheWVyVGV4dHVyZVVwZGF0ZXIgewogcHVibGljOgogICAg IGNsYXNzIFRleHR1cmUgOiBwdWJsaWMgTGF5ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZSB7CiAg ICAgcHVibGljOgotICAgICAgICBUZXh0dXJlKEltYWdlTGF5ZXJUZXh0dXJlVXBkYXRlciogdGV4 dHVyZVVwZGF0ZXIsIFBhc3NPd25QdHI8TWFuYWdlZFRleHR1cmU+IHRleHR1cmUpCisgICAgICAg IFRleHR1cmUoSW1hZ2VMYXllclRleHR1cmVVcGRhdGVyKiB0ZXh0dXJlVXBkYXRlciwgUGFzc1Jl ZlB0cjxNYW5hZ2VkVGV4dHVyZT4gdGV4dHVyZSkKICAgICAgICAgICAgIDogbV90ZXh0dXJlKHRl eHR1cmUpCiAgICAgICAgICAgICAsIG1fdGV4dHVyZVVwZGF0ZXIodGV4dHVyZVVwZGF0ZXIpCiAg ICAgICAgIHsKICAgICAgICAgfQogCiAgICAgICAgIHZpcnR1YWwgTWFuYWdlZFRleHR1cmUqIHRl eHR1cmUoKSB7IHJldHVybiBtX3RleHR1cmUuZ2V0KCk7IH0KKyAgICAgICAgUGFzc1JlZlB0cjxN YW5hZ2VkVGV4dHVyZT4gcmVwbGFjZVRleHR1cmUoVGV4dHVyZU1hbmFnZXIqIG1hbmFnZXIpCisg ICAgICAgIHsKKyAgICAgICAgICAgIFJlZlB0cjxNYW5hZ2VkVGV4dHVyZT4gb2xkID0gbV90ZXh0 dXJlOworICAgICAgICAgICAgbV90ZXh0dXJlID0gTWFuYWdlZFRleHR1cmU6OmNyZWF0ZShtYW5h Z2VyKTsKKyAgICAgICAgICAgIHJldHVybiBvbGQucmVsZWFzZSgpOworICAgICAgICB9CiAKICAg ICAgICAgdmlydHVhbCBib29sIG5lZWRQcmVwYXJlUmVjdCgpCiAgICAgICAgIHsKQEAgLTc2LDcg KzgyLDcgQEAgcHVibGljOgogICAgIHByaXZhdGU6CiAgICAgICAgIEltYWdlTGF5ZXJUZXh0dXJl VXBkYXRlciogdGV4dHVyZVVwZGF0ZXIoKSB7IHJldHVybiBtX3RleHR1cmVVcGRhdGVyOyB9CiAK LSAgICAgICAgT3duUHRyPE1hbmFnZWRUZXh0dXJlPiBtX3RleHR1cmU7CisgICAgICAgIFJlZlB0 cjxNYW5hZ2VkVGV4dHVyZT4gbV90ZXh0dXJlOwogICAgICAgICBJbWFnZUxheWVyVGV4dHVyZVVw ZGF0ZXIqIG1fdGV4dHVyZVVwZGF0ZXI7CiAgICAgfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJUZXh0dXJlVXBkYXRlci5oIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJUZXh0dXJlVXBk YXRlci5oCmluZGV4IDkxOTlhYWIuLmU4N2Q1OTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyVGV4dHVyZVVwZGF0ZXIuaAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclRleHR1cmVVcGRh dGVyLmgKQEAgLTMwLDYgKzMwLDcgQEAKICNpZiBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcp CiAKICNpbmNsdWRlICJHcmFwaGljc1R5cGVzM0QuaCIKKyNpbmNsdWRlICJNYW5hZ2VkVGV4dHVy ZS5oIgogI2luY2x1ZGUgPHd0Zi9SZWZDb3VudGVkLmg+CiAKIG5hbWVzcGFjZSBXZWJDb3JlIHsK QEAgLTM3LDkgKzM4LDYgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogY2xhc3MgR3JhcGhpY3NDb250 ZXh0M0Q7CiBjbGFzcyBJbnRSZWN0OwogY2xhc3MgSW50U2l6ZTsKLWNsYXNzIE1hbmFnZWRUZXh0 dXJlOwotY2xhc3MgVGV4dHVyZUFsbG9jYXRvcjsKLWNsYXNzIFRleHR1cmVNYW5hZ2VyOwogCiBj bGFzcyBMYXllclRleHR1cmVVcGRhdGVyIDogcHVibGljIFJlZkNvdW50ZWQ8TGF5ZXJUZXh0dXJl VXBkYXRlcj4gewogcHVibGljOgpAQCAtNDksNiArNDcsNyBAQCBwdWJsaWM6CiAgICAgICAgIHZp cnR1YWwgflRleHR1cmUoKSB7IH0KIAogICAgICAgICB2aXJ0dWFsIE1hbmFnZWRUZXh0dXJlKiB0 ZXh0dXJlKCkgeyByZXR1cm4gMDsgfQorICAgICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8TWFuYWdl ZFRleHR1cmU+IHJlcGxhY2VUZXh0dXJlKFRleHR1cmVNYW5hZ2VyKikgeyByZXR1cm4gUmVmUHRy PE1hbmFnZWRUZXh0dXJlPigpOyB9CiAgICAgICAgIHZpcnR1YWwgYm9vbCBuZWVkUHJlcGFyZVJl Y3QoKSB7IHJldHVybiBmYWxzZTsgfQogICAgICAgICB2aXJ0dWFsIHZvaWQgcHJlcGFyZVJlY3Qo R3JhcGhpY3NDb250ZXh0M0QqLCBUZXh0dXJlQWxsb2NhdG9yKiwgY29uc3QgSW50UmVjdCYgLyog c291cmNlUmVjdCAqLywgY29uc3QgSW50UmVjdCYgLyogZGVzdFJlY3QgKi8pIHsgfQogICAgICAg ICB2aXJ0dWFsIHZvaWQgcGFpbnRDb250ZW50c1JlY3QoY29uc3QgSW50UmVjdCYgLyogc291cmNl UmVjdCAqLykgeyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5jcHAKaW5kZXggYzc0Yzk3Yy4uZTAyMjc2 ZTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L01hbmFnZWRUZXh0dXJlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5jcHAKQEAgLTY2LDYgKzY2LDcgQEAgYm9vbCBNYW5h Z2VkVGV4dHVyZTo6cmVzZXJ2ZShjb25zdCBJbnRTaXplJiBzaXplLCB1bnNpZ25lZCBmb3JtYXQp CiAgICAgICAgIGlmIChyZXNlcnZlZCkgewogICAgICAgICAgICAgbV9zaXplID0gc2l6ZTsKICAg ICAgICAgICAgIG1fZm9ybWF0ID0gZm9ybWF0OworICAgICAgICAgICAgbV90ZXh0dXJlSWQgPSBt X3RleHR1cmVNYW5hZ2VyLT50ZXh0dXJlSWQobV90b2tlbik7CiAgICAgICAgIH0KICAgICB9CiAK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01h bmFnZWRUZXh0dXJlLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9NYW5hZ2VkVGV4dHVyZS5oCmluZGV4IGQ3M2M4NzQuLjZkMDZjMTggMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRUZXh0dXJlLmgK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFuYWdlZFRl eHR1cmUuaApAQCAtMzEsMTggKzMxLDE4IEBACiAjaW5jbHVkZSA8d3RmL0Zhc3RBbGxvY0Jhc2Uu aD4KICNpbmNsdWRlIDx3dGYvTm9uY29weWFibGUuaD4KICNpbmNsdWRlIDx3dGYvUGFzc093blB0 ci5oPgotI2luY2x1ZGUgPHd0Zi9SZWZQdHIuaD4KKyNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5o PgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIGNsYXNzIEdyYXBoaWNzQ29udGV4dDNEOwogCi1j bGFzcyBNYW5hZ2VkVGV4dHVyZSB7CitjbGFzcyBNYW5hZ2VkVGV4dHVyZSA6IHB1YmxpYyBSZWZD b3VudGVkPE1hbmFnZWRUZXh0dXJlPiB7CiAgICAgV1RGX01BS0VfTk9OQ09QWUFCTEUoTWFuYWdl ZFRleHR1cmUpOwogcHVibGljOgotICAgIHN0YXRpYyBQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJl PiBjcmVhdGUoVGV4dHVyZU1hbmFnZXIqIG1hbmFnZXIpCisgICAgc3RhdGljIFBhc3NSZWZQdHI8 TWFuYWdlZFRleHR1cmU+IGNyZWF0ZShUZXh0dXJlTWFuYWdlciogbWFuYWdlcikKICAgICB7Ci0g ICAgICAgIHJldHVybiBhZG9wdFB0cihuZXcgTWFuYWdlZFRleHR1cmUobWFuYWdlcikpOworICAg ICAgICByZXR1cm4gYWRvcHRSZWYobmV3IE1hbmFnZWRUZXh0dXJlKG1hbmFnZXIpKTsKICAgICB9 CiAgICAgfk1hbmFnZWRUZXh0dXJlKCk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RleHR1cmVNYW5hZ2VyLmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RleHR1cmVNYW5hZ2VyLmNwcAppbmRleCBj NjAwZDllLi4yZmQ0YzU2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9UZXh0dXJlTWFuYWdlci5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGV4dHVyZU1hbmFnZXIuY3BwCkBAIC0yMzUsMTAgKzIz NSwzNCBAQCBib29sIFRleHR1cmVNYW5hZ2VyOjpyZXF1ZXN0VGV4dHVyZShUZXh0dXJlVG9rZW4g dG9rZW4sIEludFNpemUgc2l6ZSwgdW5zaWduZWQgZgogI2lmbmRlZiBOREVCVUcKICAgICBpbmZv LmFsbG9jYXRvciA9IDA7CiAjZW5kaWYKKworICAgIC8vIFJldXNlIGV2aWN0ZWQgdGV4dHVyZSBp ZiBhdmFpbGFibGUuCisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCBtX2V2aWN0ZWRUZXh0dXJl cy5zaXplKCk7ICsraSkgeworICAgICAgICBpZiAoIW1fZXZpY3RlZFRleHR1cmVzW2ldLnRleHR1 cmVJZCkKKyAgICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAgIGlmIChtX2V2aWN0ZWRUZXh0 dXJlc1tpXS5zaXplID09IHNpemUgJiYgbV9ldmljdGVkVGV4dHVyZXNbaV0uZm9ybWF0ID09IGZv cm1hdCkgeworICAgICAgICAgICAgaW5mby50ZXh0dXJlSWQgPSBtX2V2aWN0ZWRUZXh0dXJlc1tp XS50ZXh0dXJlSWQ7CisgICAgICAgICAgICBtX2V2aWN0ZWRUZXh0dXJlc1tpXS50ZXh0dXJlSWQg PSAwOworI2lmbmRlZiBOREVCVUcKKyAgICAgICAgICAgIGluZm8uYWxsb2NhdG9yID0gbV9ldmlj dGVkVGV4dHVyZXNbaV0uYWxsb2NhdG9yOworI2VuZGlmCisgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgfQorICAgIH0KKwogICAgIGFkZFRleHR1cmUodG9rZW4sIGluZm8pOwogICAgIHJldHVy biB0cnVlOwogfQogCit1bnNpZ25lZCBUZXh0dXJlTWFuYWdlcjo6dGV4dHVyZUlkKFRleHR1cmVU b2tlbiB0b2tlbikKK3sKKyAgICBUZXh0dXJlTWFwOjppdGVyYXRvciBpdCA9IG1fdGV4dHVyZXMu ZmluZCh0b2tlbik7CisgICAgQVNTRVJUKGl0ICE9IG1fdGV4dHVyZXMuZW5kKCkpOworICAgIFRl eHR1cmVJbmZvKiBpbmZvID0gJml0LmdldCgpLT5zZWNvbmQ7CisgICAgcmV0dXJuIGluZm8tPnRl eHR1cmVJZDsKK30KKwogfQogCiAjZW5kaWYgLy8gVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5H KQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v VGV4dHVyZU1hbmFnZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL1RleHR1cmVNYW5hZ2VyLmgKaW5kZXggZjMyN2I0Yy4uZWY5ODY3ZCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGV4dHVyZU1hbmFnZXIu aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UZXh0dXJl TWFuYWdlci5oCkBAIC03NSw2ICs3NSw3IEBAIHB1YmxpYzoKICAgICB2b2lkIHVucHJvdGVjdFRl eHR1cmUoVGV4dHVyZVRva2VuKTsKICAgICB2b2lkIHVucHJvdGVjdEFsbFRleHR1cmVzKCk7CiAg ICAgYm9vbCBpc1Byb3RlY3RlZChUZXh0dXJlVG9rZW4pOworICAgIHVuc2lnbmVkIHRleHR1cmVJ ZChUZXh0dXJlVG9rZW4pOwogCiAgICAgdW5zaWduZWQgYWxsb2NhdGVUZXh0dXJlKFRleHR1cmVB bGxvY2F0b3IqLCBUZXh0dXJlVG9rZW4pOwogICAgIHZvaWQgZGVsZXRlRXZpY3RlZFRleHR1cmVz KFRleHR1cmVBbGxvY2F0b3IqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCmluZGV4 IGYyMTA4ZGEuLjQyYmQ0NGEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcApAQCAt MTc0LDMxICsxNzQsMjcgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OmNyZWF0ZVRpbGVyKEND TGF5ZXJUaWxpbmdEYXRhOjpCb3JkZXJUZXhlbE9wdGlvbiBib3JkZXIKIAogdm9pZCBUaWxlZExh eWVyQ2hyb21pdW06OmZvckVhY2hDb21wb3NpdG9yUmVzb3VyY2UoTGF5ZXJUZXh0dXJlVXBkYXRl cjo6SGFuZGxlciYgaGFuZGxlcikKIHsKLSAgICAvLyBQYWludGluZyBjb3VsZCBjYXVzZSBjb21w b3NpdGluZyB0byBnZXQgdHVybmVkIG9mZiwgd2hpY2ggbWF5IGNhdXNlIHRoZSB0aWxlciB0byBi ZWNvbWUgaW52YWxpZGF0ZWQgbWlkLXVwZGF0ZS4KLSAgICBpZiAobV9za2lwc0RyYXcgfHwgbV9y ZXF1ZXN0ZWRVcGRhdGVSZWN0LmlzRW1wdHkoKSB8fCAhbV90aWxlci0+bnVtVGlsZXMoKSB8fCBt X3BhaW50UmVjdC5pc0VtcHR5KCkpCisgICAgaWYgKCFtX3RpbGVyKQogICAgICAgICByZXR1cm47 CiAKLSAgICBpbnQgbGVmdCwgdG9wLCByaWdodCwgYm90dG9tOwotICAgIG1fdGlsZXItPmNvbnRl bnRSZWN0VG9UaWxlSW5kaWNlcyhtX3JlcXVlc3RlZFVwZGF0ZVJlY3QsIGxlZnQsIHRvcCwgcmln aHQsIGJvdHRvbSk7Ci0gICAgZm9yIChpbnQgaiA9IHRvcDsgaiA8PSBib3R0b207ICsraikgewot ICAgICAgICBmb3IgKGludCBpID0gbGVmdDsgaSA8PSByaWdodDsgKytpKSB7Ci0gICAgICAgICAg ICBVcGRhdGFibGVUaWxlKiB0aWxlID0gdGlsZUF0KGksIGopOworICAgIGZvciAoQ0NMYXllclRp bGluZ0RhdGE6OlRpbGVNYXA6OmNvbnN0X2l0ZXJhdG9yIGl0ZXIgPSBtX3RpbGVyLT50aWxlcygp LmJlZ2luKCk7IGl0ZXIgIT0gbV90aWxlci0+dGlsZXMoKS5lbmQoKTsgKytpdGVyKSB7CisgICAg ICAgIFVwZGF0YWJsZVRpbGUqIHRpbGUgPSBzdGF0aWNfY2FzdDxVcGRhdGFibGVUaWxlKj4oaXRl ci0+c2Vjb25kLmdldCgpKTsKKyAgICAgICAgaWYgKCF0aWxlLT5tYW5hZ2VkVGV4dHVyZSgpLT5p c1ZhbGlkKG1fdGlsZXItPnRpbGVTaXplKCksIG1fdGV4dHVyZUZvcm1hdCkpCisgICAgICAgICAg ICBjb250aW51ZTsKIAotICAgICAgICAgICAgLy8gUmVxdWlyZWQgdGlsZXMgYXJlIGNyZWF0ZWQg aW4gcHJlcGFyZVRvVXBkYXRlKCkuIEEgdGlsZSBzaG91bGQKLSAgICAgICAgICAgIC8vIG5ldmVy IGJlIHJlbW92ZWQgYmV0d2VlbiB0aGUgY2FsbCB0byBwcmVwYXJlVG9VcGRhdGUoKSBhbmQgdGhl Ci0gICAgICAgICAgICAvLyBjYWxsIHRvIHVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMoKS4KLSAg ICAgICAgICAgIGlmICghdGlsZSkKLSAgICAgICAgICAgICAgICBDUkFTSCgpOworICAgICAgICBJ bnRSZWN0IHNvdXJjZVJlY3Q7CisgICAgICAgIEludFJlY3QgZGVzdFJlY3Q7CiAKLSAgICAgICAg ICAgIEludFJlY3Qgc291cmNlUmVjdCA9IHRpbGUtPm1fdXBkYXRlUmVjdDsKLSAgICAgICAgICAg IGlmICh0aWxlLT5tX3VwZGF0ZVJlY3QuaXNFbXB0eSgpKQotICAgICAgICAgICAgICAgIGNvbnRp bnVlOworICAgICAgICAvLyBQYWludGluZyBjb3VsZCBjYXVzZSBjb21wb3NpdGluZyB0byBnZXQg dHVybmVkIG9mZiwgd2hpY2ggbWF5IGNhdXNlIHRoZSB0aWxlciB0byBiZWNvbWUgaW52YWxpZGF0 ZWQgbWlkLXVwZGF0ZS4KKyAgICAgICAgaWYgKCFtX3NraXBzRHJhdyAmJiAhbV9yZXF1ZXN0ZWRV cGRhdGVSZWN0LmlzRW1wdHkoKSAmJiAhbV9wYWludFJlY3QuaXNFbXB0eSgpKQorICAgICAgICAg ICAgc291cmNlUmVjdCA9IHRpbGUtPm1fdXBkYXRlUmVjdDsKIAorICAgICAgICBpZiAoIXNvdXJj ZVJlY3QuaXNFbXB0eSgpKSB7CiAgICAgICAgICAgICBBU1NFUlQodGlsZS0+bWFuYWdlZFRleHR1 cmUoKS0+aXNSZXNlcnZlZCgpKTsKICAgICAgICAgICAgIGNvbnN0IEludFBvaW50IGFuY2hvciA9 IG1fdGlsZXItPnRpbGVDb250ZW50UmVjdCh0aWxlKS5sb2NhdGlvbigpOwogCiAgICAgICAgICAg ICAvLyBDYWxjdWxhdGUgdGlsZS1zcGFjZSByZWN0YW5nbGUgdG8gdXBsb2FkIGludG8uCi0gICAg ICAgICAgICBJbnRSZWN0IGRlc3RSZWN0KEludFBvaW50KHNvdXJjZVJlY3QueCgpIC0gYW5jaG9y LngoKSwgc291cmNlUmVjdC55KCkgLSBhbmNob3IueSgpKSwgc291cmNlUmVjdC5zaXplKCkpOwor ICAgICAgICAgICAgZGVzdFJlY3QgPSBJbnRSZWN0KEludFBvaW50KHNvdXJjZVJlY3QueCgpIC0g YW5jaG9yLngoKSwgc291cmNlUmVjdC55KCkgLSBhbmNob3IueSgpKSwgc291cmNlUmVjdC5zaXpl KCkpOwogICAgICAgICAgICAgaWYgKGRlc3RSZWN0LngoKSA8IDApCiAgICAgICAgICAgICAgICAg Q1JBU0goKTsKICAgICAgICAgICAgIGlmIChkZXN0UmVjdC55KCkgPCAwKQpAQCAtMjE0LDkgKzIx MCw5IEBAIHZvaWQgVGlsZWRMYXllckNocm9taXVtOjpmb3JFYWNoQ29tcG9zaXRvclJlc291cmNl KExheWVyVGV4dHVyZVVwZGF0ZXI6OkhhbmRsZXImCiAgICAgICAgICAgICAgICAgQ1JBU0goKTsK ICAgICAgICAgICAgIGlmIChwYWludE9mZnNldC55KCkgKyBkZXN0UmVjdC5oZWlnaHQoKSA+IG1f cGFpbnRSZWN0LmhlaWdodCgpKQogICAgICAgICAgICAgICAgIENSQVNIKCk7Ci0KLSAgICAgICAg ICAgIGhhbmRsZXIuaGFuZGxlKHRpbGUtPnRleHR1cmUoKSwgc291cmNlUmVjdCwgZGVzdFJlY3Qp OwogICAgICAgICB9CisKKyAgICAgICAgaGFuZGxlci5oYW5kbGUodGlsZS0+dGV4dHVyZSgpLCBz b3VyY2VSZWN0LCBkZXN0UmVjdCk7CiAgICAgfQogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXllckNocm9t aXVtLmNwcAppbmRleCA3YmVjN2MwLi5iZTYwZTY1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJv bWl1bS5jcHAKQEAgLTQ0LDcgKzQ0LDcgQEAKIAogbmFtZXNwYWNlIFdlYkNvcmUgewogCi1WaWRl b0xheWVyQ2hyb21pdW06OlVwZGF0ZXJUZXh0dXJlOjpVcGRhdGVyVGV4dHVyZShQYXNzT3duUHRy PE1hbmFnZWRUZXh0dXJlPiB0ZXh0dXJlKQorVmlkZW9MYXllckNocm9taXVtOjpVcGRhdGVyVGV4 dHVyZTo6VXBkYXRlclRleHR1cmUoUGFzc1JlZlB0cjxNYW5hZ2VkVGV4dHVyZT4gdGV4dHVyZSkK ICAgICA6IG1fdGV4dHVyZSh0ZXh0dXJlKQogICAgICwgbV9tYXBwZWRCdWZmZXIoMCkKIHsKQEAg LTU1LDYgKzU1LDEzIEBAIFZpZGVvTGF5ZXJDaHJvbWl1bTo6VXBkYXRlclRleHR1cmU6On5VcGRh dGVyVGV4dHVyZSgpCiAgICAgQVNTRVJUKCFtX21hcHBlZEJ1ZmZlcik7CiB9CiAKK1Bhc3NSZWZQ dHI8TWFuYWdlZFRleHR1cmU+IFZpZGVvTGF5ZXJDaHJvbWl1bTo6VXBkYXRlclRleHR1cmU6OnJl cGxhY2VUZXh0dXJlKFRleHR1cmVNYW5hZ2VyKiBtYW5hZ2VyKQoreworICAgIFJlZlB0cjxNYW5h Z2VkVGV4dHVyZT4gb2xkID0gbV90ZXh0dXJlOworICAgIG1fdGV4dHVyZSA9IE1hbmFnZWRUZXh0 dXJlOjpjcmVhdGUobWFuYWdlcik7CisgICAgcmV0dXJuIG9sZC5yZWxlYXNlKCk7Cit9CisKIHZv aWQgVmlkZW9MYXllckNocm9taXVtOjpVcGRhdGVyVGV4dHVyZTo6cHJlcGFyZVJlY3QoR3JhcGhp Y3NDb250ZXh0M0QqIGNvbnRleHQsIFRleHR1cmVBbGxvY2F0b3IqIGFsbG9jYXRvciwgY29uc3Qg SW50UmVjdCYgLyogc291cmNlUmVjdCAqLywgY29uc3QgSW50UmVjdCYgLyogZGVzdFJlY3QgKi8p CiB7CiAgICAgSW50U2l6ZSBkaW1lbnNpb25zID0gbV90ZXh0dXJlLT5zaXplKCk7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVy Q2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1Zp ZGVvTGF5ZXJDaHJvbWl1bS5oCmluZGV4IDdlZWYwZWYuLjYwZmZmZTIgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1 bS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVv TGF5ZXJDaHJvbWl1bS5oCkBAIC00NSw3ICs0NSw3IEBAIGNsYXNzIFZpZGVvTGF5ZXJDaHJvbWl1 bSA6IHB1YmxpYyBMYXllckNocm9taXVtIHsKIHB1YmxpYzoKICAgICBjbGFzcyBVcGRhdGVyVGV4 dHVyZSA6IHB1YmxpYyBMYXllclRleHR1cmVVcGRhdGVyOjpUZXh0dXJlIHsKICAgICBwdWJsaWM6 Ci0gICAgICAgIHN0YXRpYyBQYXNzT3duUHRyPFVwZGF0ZXJUZXh0dXJlPiBjcmVhdGUoUGFzc093 blB0cjxNYW5hZ2VkVGV4dHVyZT4gdGV4dHVyZSkKKyAgICAgICAgc3RhdGljIFBhc3NPd25QdHI8 VXBkYXRlclRleHR1cmU+IGNyZWF0ZShQYXNzUmVmUHRyPE1hbmFnZWRUZXh0dXJlPiB0ZXh0dXJl KQogICAgICAgICB7CiAgICAgICAgICAgICByZXR1cm4gYWRvcHRQdHIobmV3IFVwZGF0ZXJUZXh0 dXJlKHRleHR1cmUpKTsKICAgICAgICAgfQpAQCAtNTMsNiArNTMsNyBAQCBwdWJsaWM6CiAgICAg ICAgIHZpcnR1YWwgflVwZGF0ZXJUZXh0dXJlKCk7CiAKICAgICAgICAgdmlydHVhbCBNYW5hZ2Vk VGV4dHVyZSogdGV4dHVyZSgpIHsgcmV0dXJuIG1fdGV4dHVyZS5nZXQoKTsgfQorICAgICAgICB2 aXJ0dWFsIFBhc3NSZWZQdHI8TWFuYWdlZFRleHR1cmU+IHJlcGxhY2VUZXh0dXJlKFRleHR1cmVN YW5hZ2VyKik7CiAKICAgICAgICAgdmlydHVhbCBib29sIG5lZWRQcmVwYXJlUmVjdCgpIHsgcmV0 dXJuIHRydWU7IH0KICAgICAgICAgdmlydHVhbCB2b2lkIHByZXBhcmVSZWN0KEdyYXBoaWNzQ29u dGV4dDNEKiwgVGV4dHVyZUFsbG9jYXRvciosIGNvbnN0IEludFJlY3QmIHNvdXJjZVJlY3QsIGNv bnN0IEludFJlY3QmIGRlc3RSZWN0KTsKQEAgLTYzLDkgKzY0LDkgQEAgcHVibGljOgogICAgICAg ICBJbnRTaXplJiB2aXNpYmxlU2l6ZSgpIHsgcmV0dXJuIG1fdmlzaWJsZVNpemU7IH0KIAogICAg IHByaXZhdGU6Ci0gICAgICAgIGV4cGxpY2l0IFVwZGF0ZXJUZXh0dXJlKFBhc3NPd25QdHI8TWFu YWdlZFRleHR1cmU+IHRleHR1cmUpOworICAgICAgICBleHBsaWNpdCBVcGRhdGVyVGV4dHVyZShQ YXNzUmVmUHRyPE1hbmFnZWRUZXh0dXJlPiB0ZXh0dXJlKTsKIAotICAgICAgICBPd25QdHI8TWFu YWdlZFRleHR1cmU+IG1fdGV4dHVyZTsKKyAgICAgICAgUmVmUHRyPE1hbmFnZWRUZXh0dXJlPiBt X3RleHR1cmU7CiAgICAgICAgIEludFNpemUgbV92aXNpYmxlU2l6ZTsKICAgICAgICAgdWludDhf dCogbV9tYXBwZWRCdWZmZXI7CiAgICAgICAgIE93bkFycmF5UHRyPHVpbnQ4X3Q+IG1fYnVmZmVy OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v V2ViR0xMYXllckNocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL1dlYkdMTGF5ZXJDaHJvbWl1bS5jcHAKaW5kZXggNTE4YTU5OC4uM2RmOTdmNyAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vV2Vi R0xMYXllckNocm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9XZWJHTExheWVyQ2hyb21pdW0uY3BwCkBAIC0xMTMsNyArMTEzLDggQEAgdm9p ZCBXZWJHTExheWVyQ2hyb21pdW06OnVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMoR3JhcGhpY3ND b250ZXh0M0QqIHJlbmRlcmVyQ28KIAogdm9pZCBXZWJHTExheWVyQ2hyb21pdW06OmZvckVhY2hD b21wb3NpdG9yUmVzb3VyY2UoTGF5ZXJUZXh0dXJlVXBkYXRlcjo6SGFuZGxlciYgaGFuZGxlcikK IHsKLSAgICBoYW5kbGVyLmhhbmRsZShtX3VwZGF0ZXJUZXh0dXJlLmdldCgpLCBJbnRSZWN0KCks IEludFJlY3QoKSk7CisgICAgSW50UmVjdCBub25FbXB0eVJlY3QoMCwgMCwgMSwgMSk7CisgICAg aGFuZGxlci5oYW5kbGUobV91cGRhdGVyVGV4dHVyZS5nZXQoKSwgbm9uRW1wdHlSZWN0LCBub25F bXB0eVJlY3QpOwogfQogCiBib29sIFdlYkdMTGF5ZXJDaHJvbWl1bTo6cGFpbnRSZW5kZXJlZFJl c3VsdHNUb0NhbnZhcyhJbWFnZUJ1ZmZlciogaW1hZ2VCdWZmZXIpCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRzVXBEaXNwbGF5 LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0hlYWRz VXBEaXNwbGF5LmgKaW5kZXggMDVjYjIwZC4uYjZkYjQ5NCAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NIZWFkc1VwRGlzcGxheS5oCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDSGVhZHNV cERpc3BsYXkuaApAQCAtNzEsNyArNzEsNyBAQCBwcml2YXRlOgogCiAgICAgZG91YmxlIG1fZmls dGVyZWRGcmFtZVRpbWU7CiAKLSAgICBPd25QdHI8TWFuYWdlZFRleHR1cmU+IG1faHVkVGV4dHVy ZTsKKyAgICBSZWZQdHI8TWFuYWdlZFRleHR1cmU+IG1faHVkVGV4dHVyZTsKIAogICAgIExheWVy UmVuZGVyZXJDaHJvbWl1bSogbV9sYXllclJlbmRlcmVyOwogCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3Bw IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRy ZWVIb3N0LmNwcAppbmRleCBmMGJiOTVkLi5jYmU0NWQwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwCisr KyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJU cmVlSG9zdC5jcHAKQEAgLTQ5LDggKzQ5LDExIEBAIENDTGF5ZXJUcmVlSG9zdDo6TmVlZFJlc291 cmNlSGFuZGxlcjo6fk5lZWRSZXNvdXJjZUhhbmRsZXIoKQogewogfQogCi12b2lkIENDTGF5ZXJU cmVlSG9zdDo6TmVlZFJlc291cmNlSGFuZGxlcjo6aGFuZGxlKExheWVyVGV4dHVyZVVwZGF0ZXI6 OlRleHR1cmUqIHRleHR1cmUsIGNvbnN0IEludFJlY3QmIC8qIHNvdXJjZVJlY3QgKi8sIGNvbnN0 IEludFJlY3QmIC8qIGRlc3RSZWN0ICovKQordm9pZCBDQ0xheWVyVHJlZUhvc3Q6Ok5lZWRSZXNv dXJjZUhhbmRsZXI6OmhhbmRsZShMYXllclRleHR1cmVVcGRhdGVyOjpUZXh0dXJlKiB0ZXh0dXJl LCBjb25zdCBJbnRSZWN0JiAvKiBzb3VyY2VSZWN0ICovLCBjb25zdCBJbnRSZWN0JiBkZXN0UmVj dCkKIHsKKyAgICBpZiAoZGVzdFJlY3QuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisKICAg ICBpZiAodGV4dHVyZS0+bmVlZFByZXBhcmVSZWN0KCkpCiAgICAgICAgIG1fcmVzb3VyY2VzKys7 CiB9CkBAIC02Nyw2ICs3MCw5IEBAIENDTGF5ZXJUcmVlSG9zdDo6UHJlcGFyZVJlc291cmNlSGFu ZGxlcjo6flByZXBhcmVSZXNvdXJjZUhhbmRsZXIoKQogCiB2b2lkIENDTGF5ZXJUcmVlSG9zdDo6 UHJlcGFyZVJlc291cmNlSGFuZGxlcjo6aGFuZGxlKExheWVyVGV4dHVyZVVwZGF0ZXI6OlRleHR1 cmUqIHRleHR1cmUsIGNvbnN0IEludFJlY3QmIHNvdXJjZVJlY3QsIGNvbnN0IEludFJlY3QmIGRl c3RSZWN0KQogeworICAgIGlmIChkZXN0UmVjdC5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybjsK KwogICAgIGlmICh0ZXh0dXJlLT5uZWVkUHJlcGFyZVJlY3QoKSkKICAgICAgICAgdGV4dHVyZS0+ cHJlcGFyZVJlY3QobV9jb250ZXh0LCBtX2FsbG9jYXRvciwgc291cmNlUmVjdCwgZGVzdFJlY3Qp OwogfQpAQCAtODIsMTAgKzg4LDMxIEBAIENDTGF5ZXJUcmVlSG9zdDo6UGFpbnRIYW5kbGVyOjp+ UGFpbnRIYW5kbGVyKCkKIAogdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OlBhaW50SGFuZGxlcjo6aGFu ZGxlKExheWVyVGV4dHVyZVVwZGF0ZXI6OlRleHR1cmUqIHRleHR1cmUsIGNvbnN0IEludFJlY3Qm IHNvdXJjZVJlY3QsIGNvbnN0IEludFJlY3QmIGRlc3RSZWN0KQogeworICAgIGlmIChkZXN0UmVj dC5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybjsKKwogICAgIHRleHR1cmUtPnBhaW50Q29udGVu dHNSZWN0KHNvdXJjZVJlY3QpOwogICAgIG1fcHJveHktPnVwZGF0ZSh0ZXh0dXJlLCBzb3VyY2VS ZWN0LCBkZXN0UmVjdCk7CiB9CiAKK0NDTGF5ZXJUcmVlSG9zdDo6UmVwbGFjZVRleHR1cmVIYW5k bGVyOjpSZXBsYWNlVGV4dHVyZUhhbmRsZXIoVGV4dHVyZU1hbmFnZXIqIG1hbmFnZXIsIFRleHR1 cmVMaXN0KiBsaXN0KQorICAgIDogbV90ZXh0dXJlTWFuYWdlcihtYW5hZ2VyKQorICAgICwgbV9s aXN0KGxpc3QpCit7Cit9CisKK0NDTGF5ZXJUcmVlSG9zdDo6UmVwbGFjZVRleHR1cmVIYW5kbGVy Ojp+UmVwbGFjZVRleHR1cmVIYW5kbGVyKCkKK3sKK30KKwordm9pZCBDQ0xheWVyVHJlZUhvc3Q6 OlJlcGxhY2VUZXh0dXJlSGFuZGxlcjo6aGFuZGxlKExheWVyVGV4dHVyZVVwZGF0ZXI6OlRleHR1 cmUqIHRleHR1cmUsIGNvbnN0IEludFJlY3QmIC8qIHNvdXJjZVJlY3QgKi8sIGNvbnN0IEludFJl Y3QmIC8qIGRlc3RSZWN0ICovKQoreworICAgIGlmICh0ZXh0dXJlLT50ZXh0dXJlKCkpIHsKKyAg ICAgICAgbV9saXN0LT5hcHBlbmQodGV4dHVyZS0+cmVwbGFjZVRleHR1cmUobV90ZXh0dXJlTWFu YWdlcikpOworICAgICAgICBBU1NFUlQobV9saXN0LT5sYXN0KCkuZ2V0KCkpOworICAgIH0KK30K KwogUGFzc1JlZlB0cjxDQ0xheWVyVHJlZUhvc3Q+IENDTGF5ZXJUcmVlSG9zdDo6Y3JlYXRlKEND TGF5ZXJUcmVlSG9zdENsaWVudCogY2xpZW50LCBjb25zdCBDQ1NldHRpbmdzJiBzZXR0aW5ncykK IHsKICAgICBSZWZQdHI8Q0NMYXllclRyZWVIb3N0PiBsYXllclRyZWVIb3N0ID0gYWRvcHRSZWYo bmV3IENDTGF5ZXJUcmVlSG9zdChjbGllbnQsIHNldHRpbmdzKSk7CkBAIC00MjgsNiArNDU1LDEy IEBAIHZvaWQgQ0NMYXllclRyZWVIb3N0OjpwYWludENvbnRlbnRzKExheWVyQ2hyb21pdW0qIHJv b3RMYXllcikKICAgICB9CiB9CiAKK3ZvaWQgQ0NMYXllclRyZWVIb3N0OjpyZXBsYWNlVGV4dHVy ZXMoVGV4dHVyZUxpc3QmIGxpc3QpCit7CisgICAgUmVwbGFjZVRleHR1cmVIYW5kbGVyIGhhbmRs ZXIoY29udGVudHNUZXh0dXJlTWFuYWdlcigpLCAmbGlzdCk7CisgICAgZm9yRWFjaENvbXBvc2l0 b3JSZXNvdXJjZShoYW5kbGVyKTsKK30KKwogdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OmFwcGVuZFZp c2libGVMYXllcihMYXllckNocm9taXVtKiBsYXllciwgTGF5ZXJMaXN0JiB1cGRhdGVMaXN0KQog ewogICAgIC8vIEZvciBub3JtYWwgbGF5ZXJzLCB0aGVzZSBjb25kaXRpb25zIHNob3VsZCBoYXZl IGFscmVhZHkgYmVlbiBjaGVja2VkIHdoaWxlIGNyZWF0aW5nIHRoZSByZW5kZXIgc3VyZmFjZSBs YXllciBsaXN0cy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmgKaW5kZXggYTJjMjAyYS4uMWFm YTQwNiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vY2MvQ0NMYXllclRyZWVIb3N0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmgKQEAgLTE4OSw2ICsxODksOSBAQCBw dWJsaWM6CiAgICAgdm9pZCBwcmVwYXJlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRl eHQzRCosIFRleHR1cmVBbGxvY2F0b3IqKTsKICAgICB2b2lkIHBhaW50Q29udGVudHMoKTsKIAor ICAgIHR5cGVkZWYgVmVjdG9yPFJlZlB0cjxNYW5hZ2VkVGV4dHVyZT4gPiBUZXh0dXJlTGlzdDsK KyAgICB2b2lkIHJlcGxhY2VUZXh0dXJlcyhUZXh0dXJlTGlzdCYpOworCiAgICAgdm9pZCBmb3JF YWNoQ29tcG9zaXRvclJlc291cmNlKExheWVyVGV4dHVyZVVwZGF0ZXI6OkhhbmRsZXImKTsKICAg ICB2b2lkIGFwcGx5U2Nyb2xsQW5kU2NhbGUoY29uc3QgQ0NTY3JvbGxBbmRTY2FsZVNldCYpOwog ICAgIHZvaWQgc3RhcnRSYXRlTGltaXRlcihHcmFwaGljc0NvbnRleHQzRCopOwpAQCAtMjM1LDYg KzIzOCwxOCBAQCBwcml2YXRlOgogICAgICAgICBDQ1Byb3h5KiBtX3Byb3h5OwogICAgIH07CiAK KyAgICBjbGFzcyBSZXBsYWNlVGV4dHVyZUhhbmRsZXIgOiBwdWJsaWMgTGF5ZXJUZXh0dXJlVXBk YXRlcjo6SGFuZGxlciB7CisgICAgcHVibGljOgorICAgICAgICBSZXBsYWNlVGV4dHVyZUhhbmRs ZXIoVGV4dHVyZU1hbmFnZXIqLCBUZXh0dXJlTGlzdCopOworICAgICAgICB2aXJ0dWFsIH5SZXBs YWNlVGV4dHVyZUhhbmRsZXIoKTsKKworICAgICAgICB2aXJ0dWFsIHZvaWQgaGFuZGxlKExheWVy VGV4dHVyZVVwZGF0ZXI6OlRleHR1cmUqLCBjb25zdCBJbnRSZWN0JiBzb3VyY2VSZWN0LCBjb25z dCBJbnRSZWN0JiBkZXN0UmVjdCk7CisKKyAgICBwcml2YXRlOgorICAgICAgICBUZXh0dXJlTWFu YWdlciogbV90ZXh0dXJlTWFuYWdlcjsKKyAgICAgICAgVGV4dHVyZUxpc3QqIG1fbGlzdDsKKyAg ICB9OworCiAgICAgdHlwZWRlZiBWZWN0b3I8UmVmUHRyPExheWVyQ2hyb21pdW0+ID4gTGF5ZXJM aXN0OwogCiAgICAgdm9pZCBhcHBlbmRWaXNpYmxlTGF5ZXIoTGF5ZXJDaHJvbWl1bSosIExheWVy TGlzdCYpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vY2MvQ0NSZW5kZXJTdXJmYWNlLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9jYy9DQ1JlbmRlclN1cmZhY2UuaAppbmRleCA0YmQ0YWY4Li43NGY2NzMw IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9j Yy9DQ1JlbmRlclN1cmZhY2UuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9jYy9DQ1JlbmRlclN1cmZhY2UuaApAQCAtMTEzLDcgKzExMyw3IEBAIHByaXZh dGU6CiAgICAgYm9vbCBtX3NraXBzRHJhdzsKICAgICBib29sIG1fc3VyZmFjZVByb3BlcnR5Q2hh bmdlZDsKIAotICAgIE93blB0cjxNYW5hZ2VkVGV4dHVyZT4gbV9jb250ZW50c1RleHR1cmU7Cisg ICAgUmVmUHRyPE1hbmFnZWRUZXh0dXJlPiBtX2NvbnRlbnRzVGV4dHVyZTsKICAgICBmbG9hdCBt X2RyYXdPcGFjaXR5OwogICAgIFRyYW5zZm9ybWF0aW9uTWF0cml4IG1fZHJhd1RyYW5zZm9ybTsK ICAgICBUcmFuc2Zvcm1hdGlvbk1hdHJpeCBtX3JlcGxpY2FEcmF3VHJhbnNmb3JtOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJl YWRQcm94eS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9j Yy9DQ1RocmVhZFByb3h5LmNwcAppbmRleCBhYjgwYWM4Li41ZDk5NGQ4IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5 LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9D Q1RocmVhZFByb3h5LmNwcApAQCAtMjgwLDYgKzI4MCw4IEBAIHZvaWQgQ0NUaHJlYWRQcm94eTo6 c3RvcCgpCiAKICAgICBtX21haW5UaHJlYWRQcm94eS0+c2h1dGRvd24oKTsgLy8gU3RvcCBydW5u aW5nIHRhc2tzIHBvc3RlZCB0byB1cy4KIAorICAgIG1fdXNlZFRleHR1cmVMaXN0LmNsZWFyKCk7 IC8vIFJlbGVhc2UgdGV4dHVyZXMgbm8gbG9uZ2VyIHVzZWQgYnkgaW1wbC4KKwogICAgIEFTU0VS VCghbV9sYXllclRyZWVIb3N0SW1wbCk7IC8vIHZlcmlmeSB0aGF0IHRoZSBpbXBsIGRlbGV0ZWQu CiAgICAgbV9sYXllclRyZWVIb3N0ID0gMDsKICAgICBtX3N0YXJ0ZWQgPSBmYWxzZTsKQEAgLTQx Niw2ICs0MTgsMTMgQEAgdm9pZCBDQ1RocmVhZFByb3h5OjpiZWdpbkZyYW1lQW5kQ29tbWl0KGlu dCBzZXF1ZW5jZU51bWJlciwgZG91YmxlIGZyYW1lQmVnaW5UaW0KICAgICAgICAgY29tcGxldGlv bi53YWl0KCk7CiAgICAgfQogCisgICAgLy8gUmVsZWFzZSB0ZXh0dXJlcyBubyBsb25nZXIgdXNl ZCBieSBpbXBsIHRocmVhZC4KKyAgICBtX3VzZWRUZXh0dXJlTGlzdC5jbGVhcigpOworCisgICAg Ly8gTW92ZSB0ZXh0dXJlcyB1c2VkIGJ5IGltcGwgdGhyZWFkIHRvIHVzZWRUZXh0dXJlTGlzdCBh bmQgY3JlYXRlIG5ldworICAgIC8vIHRleHR1cmVzIGZvciBuZXh0IHVwZGF0ZS4KKyAgICBtX2xh eWVyVHJlZUhvc3QtPnJlcGxhY2VUZXh0dXJlcyhtX3VzZWRUZXh0dXJlTGlzdCk7CisKICAgICBt X2xheWVyVHJlZUhvc3QtPmNvbW1pdENvbXBsZXRlKCk7CiAKICAgICBBU1NFUlQobV9sYXN0RXhl Y3V0ZWRCZWdpbkZyYW1lQW5kQ29tbWl0U2VxdWVuY2VOdW1iZXIgPT0gc2VxdWVuY2VOdW1iZXIp OwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Y2MvQ0NUaHJlYWRQcm94eS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vY2MvQ0NUaHJlYWRQcm94eS5oCmluZGV4IGFiYTM0NGIuLmMzY2ZhMTMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFk UHJveHkuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9j Yy9DQ1RocmVhZFByb3h5LmgKQEAgLTg2LDYgKzg2LDggQEAgcHJpdmF0ZToKICAgICAgICAgSW50 UmVjdCBtX2Rlc3RSZWN0OwogICAgIH07CiAKKyAgICB0eXBlZGVmIFZlY3RvcjxSZWZQdHI8TWFu YWdlZFRleHR1cmU+ID4gVGV4dHVyZUxpc3Q7CisKICAgICAvLyBDYWxsZWQgb24gbWFpbiB0aHJl YWQKICAgICB2b2lkIGJlZ2luRnJhbWVBbmRDb21taXQoaW50IHNlcXVlbmNlTnVtYmVyLCBkb3Vi bGUgZnJhbWVCZWdpblRpbWUsIFBhc3NPd25QdHI8Q0NTY3JvbGxBbmRTY2FsZVNldD4pOwogICAg IHZvaWQgZGlkQ29tbWl0QW5kRHJhd0ZyYW1lKCk7CkBAIC0xMTgsNiArMTIwLDcgQEAgcHJpdmF0 ZToKICAgICBMYXllclJlbmRlcmVyQ2FwYWJpbGl0aWVzIG1fbGF5ZXJSZW5kZXJlckNhcGFiaWxp dGllc01haW5UaHJlYWRDb3B5OwogICAgIGJvb2wgbV9zdGFydGVkOwogICAgIGludCBtX2xhc3RF eGVjdXRlZEJlZ2luRnJhbWVBbmRDb21taXRTZXF1ZW5jZU51bWJlcjsKKyAgICBUZXh0dXJlTGlz dCBtX3VzZWRUZXh0dXJlTGlzdDsKIAogICAgIC8vIFVzZWQgb24gdGhlIENDVGhyZWFkIG9ubHku CiAgICAgT3duUHRyPENDTGF5ZXJUcmVlSG9zdEltcGw+IG1fbGF5ZXJUcmVlSG9zdEltcGw7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0NDTGF5ZXJUcmVlSG9zdFRl c3QuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9DQ0xheWVyVHJlZUhvc3RUZXN0 LmNwcAppbmRleCA5MzA1Yjc3Li4xZWNjZTA0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3Rlc3RzL0NDTGF5ZXJUcmVlSG9zdFRlc3QuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vdGVzdHMvQ0NMYXllclRyZWVIb3N0VGVzdC5jcHAKQEAgLTQ3LDYgKzQ3LDcgQEAK ICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9WZWN0b3IuaD4KIAor dXNpbmcgbmFtZXNwYWNlIHN0ZDsKIHVzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwogdXNpbmcgbmFt ZXNwYWNlIFdlYktpdDsKIHVzaW5nIG5hbWVzcGFjZSBXVEY7CkBAIC0xMzgsOSArMTM5LDQxIEBA IHB1YmxpYzoKICAgICB2aXJ0dWFsIFdlYkdMSWQgY3JlYXRlU2hhZGVyKFdHQzNEZW51bSkgeyBy ZXR1cm4gMTsgfQogICAgIHZpcnR1YWwgdm9pZCBnZXRTaGFkZXJpdihXZWJHTElkLCBXR0MzRGVu dW0sIFdHQzNEaW50KiB2YWx1ZSkgeyAqdmFsdWUgPSAxOyB9CiAgICAgdmlydHVhbCB2b2lkIGdl dFByb2dyYW1pdihXZWJHTElkLCBXR0MzRGVudW0sIFdHQzNEaW50KiB2YWx1ZSkgeyAqdmFsdWUg PSAxOyB9CisgICAgdmlydHVhbCBXZWJHTElkIGNyZWF0ZVRleHR1cmUoKQorICAgIHsKKyAgICAg ICAgV2ViR0xJZCB0ZXh0dXJlID0gbV90ZXh0dXJlcy5zaXplKCkgKyAxOworICAgICAgICBtX3Rl eHR1cmVzLnB1c2hfYmFjayh0ZXh0dXJlKTsKKyAgICAgICAgcmV0dXJuIHRleHR1cmU7CisgICAg fQorCisgICAgdmlydHVhbCB2b2lkIGRlbGV0ZVRleHR1cmUoV2ViR0xJZCB0ZXh0dXJlKQorICAg IHsKKyAgICAgICAgZm9yICh2ZWN0b3I8V2ViR0xJZD46Oml0ZXJhdG9yIGl0ID0gbV90ZXh0dXJl cy5iZWdpbigpOyBpdCAhPSBtX3RleHR1cmVzLmVuZCgpOyBpdCsrKSB7CisgICAgICAgICAgICBp ZiAoKml0ID09IHRleHR1cmUpIHsKKyAgICAgICAgICAgICAgICBtX3RleHR1cmVzLmVyYXNlKGl0 KTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAg IH0KKworICAgIHZpcnR1YWwgdm9pZCBiaW5kVGV4dHVyZShXR0MzRGVudW0gLyogdGFyZ2V0ICov LCBXZWJHTElkIHRleHR1cmUpCisgICAgeworICAgICAgICBtX3VzZWRUZXh0dXJlcy5pbnNlcnQo dGV4dHVyZSk7CisgICAgfQorCisgICAgaW50IG51bVRleHR1cmVzKCkgY29uc3QgeyByZXR1cm4g c3RhdGljX2Nhc3Q8aW50PihtX3RleHR1cmVzLnNpemUoKSk7IH0KKyAgICBpbnQgdGV4dHVyZShp bnQgaSkgY29uc3QgeyByZXR1cm4gbV90ZXh0dXJlc1tpXTsgfQorICAgIHZvaWQgcmVzZXRUZXh0 dXJlcygpIHsgbV90ZXh0dXJlcy5jbGVhcigpOyB9CisKKyAgICBpbnQgbnVtVXNlZFRleHR1cmVz KCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8aW50PihtX3VzZWRUZXh0dXJlcy5zaXplKCkp OyB9CisgICAgYm9vbCB1c2VkVGV4dHVyZShpbnQgdGV4dHVyZSkgY29uc3QgeyByZXR1cm4gbV91 c2VkVGV4dHVyZXMuZmluZCh0ZXh0dXJlKSAhPSBtX3VzZWRUZXh0dXJlcy5lbmQoKTsgfQorICAg IHZvaWQgcmVzZXRVc2VkVGV4dHVyZXMoKSB7IG1fdXNlZFRleHR1cmVzLmNsZWFyKCk7IH0KIAog cHJpdmF0ZToKICAgICBDb21wb3NpdG9yTW9ja1dlYkdyYXBoaWNzQ29udGV4dDNEKCkgeyB9CisK KyAgICB2ZWN0b3I8V2ViR0xJZD4gbV90ZXh0dXJlczsKKyAgICBzZXQ8V2ViR0xJZD4gbV91c2Vk VGV4dHVyZXM7CiB9OwogCiAvLyBJbXBsZW1lbnRhdGlvbiBvZiBDQ0xheWVyVHJlZUhvc3QgY2Fs bGJhY2sgaW50ZXJmYWNlLgpAQCAtOTQwLDcgKzk3Myw3IEBAIHB1YmxpYzoKICAgICBwdWJsaWM6 CiAgICAgICAgIGNsYXNzIFRleHR1cmUgOiBwdWJsaWMgTGF5ZXJUZXh0dXJlVXBkYXRlcjo6VGV4 dHVyZSB7CiAgICAgICAgIHB1YmxpYzoKLSAgICAgICAgICAgIFRleHR1cmUoQ29udGVudExheWVy VGV4dHVyZVVwZGF0ZXIqIHRleHR1cmVVcGRhdGVyLCBQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJl PiB0ZXh0dXJlKQorICAgICAgICAgICAgVGV4dHVyZShDb250ZW50TGF5ZXJUZXh0dXJlVXBkYXRl ciogdGV4dHVyZVVwZGF0ZXIsIFBhc3NSZWZQdHI8TWFuYWdlZFRleHR1cmU+IHRleHR1cmUpCiAg ICAgICAgICAgICAgICAgOiBtX3RleHR1cmUodGV4dHVyZSkKICAgICAgICAgICAgICAgICAsIG1f dGV4dHVyZVVwZGF0ZXIodGV4dHVyZVVwZGF0ZXIpCiAgICAgICAgICAgICB7CkBAIC05NDgsMTQg Kzk4MSwyMyBAQCBwdWJsaWM6CiAKICAgICAgICAgICAgIHZpcnR1YWwgTWFuYWdlZFRleHR1cmUq IHRleHR1cmUoKSB7IHJldHVybiBtX3RleHR1cmUuZ2V0KCk7IH0KIAorICAgICAgICAgICAgdmly dHVhbCBQYXNzUmVmUHRyPE1hbmFnZWRUZXh0dXJlPiByZXBsYWNlVGV4dHVyZShUZXh0dXJlTWFu YWdlciogbWFuYWdlcikKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICBSZWZQdHI8TWFu YWdlZFRleHR1cmU+IG9sZCA9IG1fdGV4dHVyZTsKKyAgICAgICAgICAgICAgICBtX3RleHR1cmUg PSBNYW5hZ2VkVGV4dHVyZTo6Y3JlYXRlKG1hbmFnZXIpOworICAgICAgICAgICAgICAgIHJldHVy biBvbGQucmVsZWFzZSgpOworICAgICAgICAgICAgfQorCiAgICAgICAgICAgICB2aXJ0dWFsIGJv b2wgbmVlZFByZXBhcmVSZWN0KCkKICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICByZXR1 cm4gbV90ZXh0dXJlVXBkYXRlci0+bGF5ZXIoKS0+bmVlZFByZXBhcmVSZWN0KCk7CiAgICAgICAg ICAgICB9CiAKLSAgICAgICAgICAgIHZpcnR1YWwgdm9pZCBwcmVwYXJlUmVjdChHcmFwaGljc0Nv bnRleHQzRCosIFRleHR1cmVBbGxvY2F0b3IqLCBjb25zdCBJbnRSZWN0JiAvKiBzb3VyY2VSZWN0 ICovLCBjb25zdCBJbnRSZWN0JiAvKiBkZXN0UmVjdCAqLykKKyAgICAgICAgICAgIHZpcnR1YWwg dm9pZCBwcmVwYXJlUmVjdChHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgVGV4dHVyZUFsbG9j YXRvciogYWxsb2NhdG9yLCBjb25zdCBJbnRSZWN0JiAvKiBzb3VyY2VSZWN0ICovLCBjb25zdCBJ bnRSZWN0JiAvKiBkZXN0UmVjdCAqLykKICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICBt X3RleHR1cmVVcGRhdGVyLT5sYXllcigpLT5wcmVwYXJlUmVjdCgpOworICAgICAgICAgICAgICAg IGlmICghbV90ZXh0dXJlLT50ZXh0dXJlSWQoKSkKKyAgICAgICAgICAgICAgICAgICAgbV90ZXh0 dXJlLT5hbGxvY2F0ZVRleHR1cmUoY29udGV4dCwgYWxsb2NhdG9yKTsKICAgICAgICAgICAgIH0K IAogICAgICAgICAgICAgdmlydHVhbCB2b2lkIHBhaW50Q29udGVudHNSZWN0KGNvbnN0IEludFJl Y3QmIC8qIHNvdXJjZVJlY3QgKi8pCkBAIC05NjMsMTMgKzEwMDUsMTUgQEAgcHVibGljOgogICAg ICAgICAgICAgICAgIG1fdGV4dHVyZVVwZGF0ZXItPmxheWVyKCktPnBhaW50Q29udGVudHNSZWN0 KCk7CiAgICAgICAgICAgICB9CiAKLSAgICAgICAgICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVSZWN0 KEdyYXBoaWNzQ29udGV4dDNEKiwgY29uc3QgSW50UmVjdCYgLyogc291cmNlUmVjdCAqLywgY29u c3QgSW50UmVjdCYgLyogZGVzdFJlY3QgKi8pCisgICAgICAgICAgICB2aXJ0dWFsIHZvaWQgdXBk YXRlUmVjdChHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgY29uc3QgSW50UmVjdCYgLyogc291 cmNlUmVjdCAqLywgY29uc3QgSW50UmVjdCYgLyogZGVzdFJlY3QgKi8pCiAgICAgICAgICAgICB7 CiAgICAgICAgICAgICAgICAgbV90ZXh0dXJlVXBkYXRlci0+bGF5ZXIoKS0+dXBkYXRlUmVjdCgp OworICAgICAgICAgICAgICAgIGlmIChtX3RleHR1cmUtPnRleHR1cmVJZCgpKQorICAgICAgICAg ICAgICAgICAgICBjb250ZXh0LT5iaW5kVGV4dHVyZShHcmFwaGljc0NvbnRleHQzRDo6VEVYVFVS RV8yRCwgbV90ZXh0dXJlLT50ZXh0dXJlSWQoKSk7CiAgICAgICAgICAgICB9CiAKICAgICAgICAg cHJpdmF0ZToKLSAgICAgICAgICAgIE93blB0cjxNYW5hZ2VkVGV4dHVyZT4gbV90ZXh0dXJlOwor ICAgICAgICAgICAgUmVmUHRyPE1hbmFnZWRUZXh0dXJlPiBtX3RleHR1cmU7CiAgICAgICAgICAg ICBDb250ZW50TGF5ZXJUZXh0dXJlVXBkYXRlciogbV90ZXh0dXJlVXBkYXRlcjsKICAgICAgICAg fTsKIApAQCAtMTE0MSw0ICsxMTg1LDgyIEBAIFRFU1RfRihDQ0xheWVyVHJlZUhvc3RUZXN0Tm9Q cmVwYXJlUmVjdCwgcnVuTXVsdGlUaHJlYWQpCiAgICAgcnVuVGVzdCh0cnVlKTsKIH0KIAorLy8g VmVyaWZ5IGF0b21pY2l0eSBvZiBjb21taXRzIGFuZCByZXVzZSBvZiB0ZXh0dXJlcy4KK2NsYXNz IENDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQgOiBwdWJsaWMgQ0NMYXllclRyZWVIb3N0 VGVzdCB7CitwdWJsaWM6CisgICAgQ0NMYXllclRyZWVIb3N0VGVzdEF0b21pY0NvbW1pdCgpCisg ICAgICAgIDogbV91cGRhdGVDaGVja0xheWVyKENvbnRlbnRMYXllckNocm9taXVtV2l0aFVwZGF0 ZVRyYWNraW5nOjpjcmVhdGUoJm1fZGVsZWdhdGUsIHRydWUpKQorICAgICAgICAsIG1fbnVtQ29t bWl0cygwKQorICAgIHsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgYmVnaW5UZXN0KCkKKyAg ICB7CisgICAgICAgIG1fbGF5ZXJUcmVlSG9zdC0+c2V0Um9vdExheWVyKG1fdXBkYXRlQ2hlY2tM YXllcik7CisgICAgICAgIG1fbGF5ZXJUcmVlSG9zdC0+c2V0Vmlld3BvcnQoSW50U2l6ZSgxMCwg MTApKTsKKworICAgICAgICBwb3N0U2V0TmVlZHNDb21taXRUb01haW5UaHJlYWQoKTsKKyAgICB9 CisKKyAgICB2aXJ0dWFsIHZvaWQgY29tbWl0Q29tcGxldGVPbkNDVGhyZWFkKENDTGF5ZXJUcmVl SG9zdEltcGwqIGltcGwpCisgICAgeworICAgICAgICBDb21wb3NpdG9yTW9ja1dlYkdyYXBoaWNz Q29udGV4dDNEKiBjb250ZXh0ID0gc3RhdGljX2Nhc3Q8Q29tcG9zaXRvck1vY2tXZWJHcmFwaGlj c0NvbnRleHQzRCo+KEdyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZTo6ZXh0cmFjdFdlYkdyYXBoaWNz Q29udGV4dDNEKGltcGwtPmNvbnRleHQoKSkpOworCisgICAgICAgIHN3aXRjaCAoKyttX251bUNv bW1pdHMpIHsKKyAgICAgICAgICAgIGNhc2UgMToKKyAgICAgICAgICAgICAgICAvLyBOdW1iZXIg b2YgdGV4dHVyZXMgc2hvdWxkIGJlIG9uZS4KKyAgICAgICAgICAgICAgICBFWFBFQ1RfRVEoMSwg Y29udGV4dC0+bnVtVGV4dHVyZXMoKSk7CisgICAgICAgICAgICAgICAgLy8gTnVtYmVyIG9mIHRl eHR1cmVzIHVzZWQgZm9yIGNvbW1pdCBzaG91bGQgYmUgb25lLgorICAgICAgICAgICAgICAgIEVY UEVDVF9FUSgxLCBjb250ZXh0LT5udW1Vc2VkVGV4dHVyZXMoKSk7CisgICAgICAgICAgICAgICAg Ly8gVmVyaWZ5IHVzZWQgdGV4dHVyZSBpcyBjb3JyZWN0LgorICAgICAgICAgICAgICAgIEVYUEVD VF9UUlVFKGNvbnRleHQtPnVzZWRUZXh0dXJlKGNvbnRleHQtPnRleHR1cmUoMCkpKTsKKworICAg ICAgICAgICAgICAgIGNvbnRleHQtPnJlc2V0VXNlZFRleHR1cmVzKCk7CisgICAgICAgICAgICAg ICAgcG9zdFNldE5lZWRzQ29tbWl0VG9NYWluVGhyZWFkKCk7CisgICAgICAgICAgICAgICAgYnJl YWs7CisgICAgICAgICAgICBjYXNlIDI6CisgICAgICAgICAgICAgICAgLy8gTnVtYmVyIG9mIHRl eHR1cmVzIHNob3VsZCBiZSB0d28gYXMgdGhlIGZpcnN0IHRleHR1cmUKKyAgICAgICAgICAgICAg ICAvLyBpcyB1c2VkIGJ5IGltcGwgdGhyZWFkIGFuZCBjYW5ub3QgYnkgdXNlZCBmb3IgdXBkYXRl LgorICAgICAgICAgICAgICAgIEVYUEVDVF9FUSgyLCBjb250ZXh0LT5udW1UZXh0dXJlcygpKTsK KyAgICAgICAgICAgICAgICAvLyBOdW1iZXIgb2YgdGV4dHVyZXMgdXNlZCBmb3IgY29tbWl0IHNo b3VsZCBzdGlsbCBiZSBvbmUuCisgICAgICAgICAgICAgICAgRVhQRUNUX0VRKDEsIGNvbnRleHQt Pm51bVVzZWRUZXh0dXJlcygpKTsKKyAgICAgICAgICAgICAgICAvLyBGaXJzdCB0ZXh0dXJlIHNo b3VsZCBub3QgaGF2ZSBiZWVuIHVzZWQuCisgICAgICAgICAgICAgICAgRVhQRUNUX0ZBTFNFKGNv bnRleHQtPnVzZWRUZXh0dXJlKGNvbnRleHQtPnRleHR1cmUoMCkpKTsKKyAgICAgICAgICAgICAg ICAvLyBOZXcgdGV4dHVyZSBzaG91bGQgaGF2ZSBiZWVuIHVzZWQuCisgICAgICAgICAgICAgICAg RVhQRUNUX1RSVUUoY29udGV4dC0+dXNlZFRleHR1cmUoY29udGV4dC0+dGV4dHVyZSgxKSkpOwor CisgICAgICAgICAgICAgICAgY29udGV4dC0+cmVzZXRVc2VkVGV4dHVyZXMoKTsKKyAgICAgICAg ICAgICAgICBwb3N0U2V0TmVlZHNDb21taXRUb01haW5UaHJlYWQoKTsKKyAgICAgICAgICAgICAg ICBicmVhazsKKyAgICAgICAgICAgIGRlZmF1bHQ6CisgICAgICAgICAgICAgICAgLy8gTnVtYmVy IG9mIHRleHR1cmVzIHNob3VsZCBub3QgaGF2ZSBpbmNyZWFzZWQuIE9sZCB0ZXh0dXJlCisgICAg ICAgICAgICAgICAgLy8gc2hvdWxkIGhhdmUgYmVlbiByZXVzZWQuCisgICAgICAgICAgICAgICAg RVhQRUNUX0VRKDIsIGNvbnRleHQtPm51bVRleHR1cmVzKCkpOworICAgICAgICAgICAgICAgIC8v IE51bWJlciBvZiB0ZXh0dXJlcyB1c2VkIGZvciBjb21taXQgc2hvdWxkIHN0aWxsIGJlIG9uZS4K KyAgICAgICAgICAgICAgICBFWFBFQ1RfRVEoMSwgY29udGV4dC0+bnVtVXNlZFRleHR1cmVzKCkp OworICAgICAgICAgICAgICAgIC8vIEZpcnN0IHRleHR1cmUgc2hvdWxkIGhhdmUgYmVlbiB1c2Vk IGZvciBjb21taXQuCisgICAgICAgICAgICAgICAgRVhQRUNUX1RSVUUoY29udGV4dC0+dXNlZFRl eHR1cmUoY29udGV4dC0+dGV4dHVyZSgwKSkpOworICAgICAgICAgICAgICAgIC8vIFNlY29uZCB0 ZXh0dXJlIHNob3VsZCBub3QgaGF2ZSBiZWVuIHVzZWQgZm9yIGNvbW1pdC4KKyAgICAgICAgICAg ICAgICBFWFBFQ1RfRkFMU0UoY29udGV4dC0+dXNlZFRleHR1cmUoY29udGV4dC0+dGV4dHVyZSgx KSkpOworCisgICAgICAgICAgICAgICAgZW5kVGVzdCgpOworICAgICAgICB9CisgICAgfQorCisg ICAgdmlydHVhbCB2b2lkIGFmdGVyVGVzdCgpCisgICAgeworICAgIH0KKworcHJpdmF0ZToKKyAg ICBNb2NrTGF5ZXJEZWxlZ2F0ZSBtX2RlbGVnYXRlOworICAgIFJlZlB0cjxDb250ZW50TGF5ZXJD aHJvbWl1bVdpdGhVcGRhdGVUcmFja2luZz4gbV91cGRhdGVDaGVja0xheWVyOworICAgIGludCBt X251bUNvbW1pdHM7Cit9OworCitURVNUX0YoQ0NMYXllclRyZWVIb3N0VGVzdEF0b21pY0NvbW1p dCwgcnVuTXVsdGlUaHJlYWQpCit7CisgICAgcnVuVGVzdCh0cnVlKTsKK30KKworCiB9IC8vIG5h bWVzcGFjZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9UaWxlZExh eWVyQ2hyb21pdW1UZXN0LmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvVGlsZWRM YXllckNocm9taXVtVGVzdC5jcHAKaW5kZXggMThmMDNlMC4uYjJiMDg3MCAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9UaWxlZExheWVyQ2hyb21pdW1UZXN0LmNwcAor KysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL1RpbGVkTGF5ZXJDaHJvbWl1bVRlc3Qu Y3BwCkBAIC00NywxNCArNDcsMTQgQEAgY2xhc3MgRmFrZUxheWVyVGV4dHVyZVVwZGF0ZXIgOiBw dWJsaWMgTGF5ZXJUZXh0dXJlVXBkYXRlciB7CiBwdWJsaWM6CiAgICAgY2xhc3MgVGV4dHVyZSA6 IHB1YmxpYyBMYXllclRleHR1cmVVcGRhdGVyOjpUZXh0dXJlIHsKICAgICBwdWJsaWM6Ci0gICAg ICAgIFRleHR1cmUoUGFzc093blB0cjxNYW5hZ2VkVGV4dHVyZT4gdGV4dHVyZSkgOiBtX3RleHR1 cmUodGV4dHVyZSkgeyB9CisgICAgICAgIFRleHR1cmUoUGFzc1JlZlB0cjxNYW5hZ2VkVGV4dHVy ZT4gdGV4dHVyZSkgOiBtX3RleHR1cmUodGV4dHVyZSkgeyB9CiAKICAgICAgICAgdmlydHVhbCBN YW5hZ2VkVGV4dHVyZSogdGV4dHVyZSgpIHsgcmV0dXJuIG1fdGV4dHVyZS5nZXQoKTsgfQogCiAg ICAgICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVSZWN0KEdyYXBoaWNzQ29udGV4dDNEKiwgY29uc3Qg SW50UmVjdCYsIGNvbnN0IEludFJlY3QmKSB7IH0KIAogICAgIHByaXZhdGU6Ci0gICAgICAgIE93 blB0cjxNYW5hZ2VkVGV4dHVyZT4gbV90ZXh0dXJlOworICAgICAgICBSZWZQdHI8TWFuYWdlZFRl eHR1cmU+IG1fdGV4dHVyZTsKICAgICB9OwogCiAgICAgRmFrZUxheWVyVGV4dHVyZVVwZGF0ZXIo KSB7IH0K 117840 2011-12-04 21:48:18 -0800 2011-12-08 10:24:49 -0800 Patch atomic-texture-updates.diff text/plain 34716 reveman ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0Nh bnZhczJETGF5ZXJDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hyb21pdW0uY3BwCmluZGV4IGUwNGYxOGQuLjdkYTU1 NTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0NhbnZhczJETGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNocm9taXVtLmNwcApAQCAtMTAyLDcgKzEw Miw4IEBAIHZvaWQgQ2FudmFzMkRMYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3Vy Y2VzKCkKIAogdm9pZCBDYW52YXMyRExheWVyQ2hyb21pdW06OmZvckVhY2hDb21wb3NpdG9yUmVz b3VyY2UoTGF5ZXJUZXh0dXJlVXBkYXRlcjo6SGFuZGxlciYgaGFuZGxlcikKIHsKLSAgICBoYW5k bGVyLmhhbmRsZShtX3VwZGF0ZXJUZXh0dXJlLmdldCgpLCBJbnRSZWN0KCksIEludFJlY3QoKSk7 CisgICAgSW50UmVjdCBub25FbXB0eVJlY3QoMCwgMCwgMSwgMSk7CisgICAgaGFuZGxlci5oYW5k bGUobV91cGRhdGVyVGV4dHVyZS5nZXQoKSwgbm9uRW1wdHlSZWN0LCBub25FbXB0eVJlY3QpOwog fQogCiB2b2lkIENhbnZhczJETGF5ZXJDaHJvbWl1bTo6Y29udGVudENoYW5nZWQoKQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzTGF5 ZXJUZXh0dXJlVXBkYXRlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9DYW52YXNMYXllclRleHR1cmVVcGRhdGVyLmNwcAppbmRleCBjNjFlYzMzLi4yODMx NjY5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9DYW52YXNMYXllclRleHR1cmVVcGRhdGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXNMYXllclRleHR1cmVVcGRhdGVyLmNwcApAQCAt NDQsNiArNDQsMTMgQEAgQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZTo6flRleHR1 cmUoKQogewogfQogCitQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJlPiBDYW52YXNMYXllclRleHR1 cmVVcGRhdGVyOjpUZXh0dXJlOjpyZXBsYWNlVGV4dHVyZShUZXh0dXJlTWFuYWdlciogbWFuYWdl cikKK3sKKyAgICBPd25QdHI8TWFuYWdlZFRleHR1cmU+IG9sZCA9IG1fdGV4dHVyZS5yZWxlYXNl KCk7CisgICAgbV90ZXh0dXJlID0gTWFuYWdlZFRleHR1cmU6OmNyZWF0ZShtYW5hZ2VyKTsKKyAg ICByZXR1cm4gb2xkLnJlbGVhc2UoKTsKK30KKwogYm9vbCBDYW52YXNMYXllclRleHR1cmVVcGRh dGVyOjpUZXh0dXJlOjpuZWVkUHJlcGFyZVJlY3QoKQogewogICAgIHJldHVybiAhbV90ZXh0dXJl LT50ZXh0dXJlSWQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL0NhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXIuaCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0NhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXIuaApp bmRleCA4ODZkMTAxLi44ZTYwZjA3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXNMYXllclRleHR1cmVVcGRhdGVyLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzTGF5ZXJUZXh0dXJl VXBkYXRlci5oCkBAIC00NSw2ICs0NSw3IEBAIHB1YmxpYzoKICAgICAgICAgdmlydHVhbCB+VGV4 dHVyZSgpOwogCiAgICAgICAgIHZpcnR1YWwgTWFuYWdlZFRleHR1cmUqIHRleHR1cmUoKSB7IHJl dHVybiBtX3RleHR1cmUuZ2V0KCk7IH0KKyAgICAgICAgdmlydHVhbCBQYXNzT3duUHRyPE1hbmFn ZWRUZXh0dXJlPiByZXBsYWNlVGV4dHVyZShUZXh0dXJlTWFuYWdlciopOwogCiAgICAgICAgIHZp cnR1YWwgYm9vbCBuZWVkUHJlcGFyZVJlY3QoKTsKICAgICAgICAgdmlydHVhbCB2b2lkIHByZXBh cmVSZWN0KEdyYXBoaWNzQ29udGV4dDNEKiwgVGV4dHVyZUFsbG9jYXRvciosIGNvbnN0IEludFJl Y3QmIC8qIHNvdXJjZVJlY3QgKi8sIGNvbnN0IEludFJlY3QmIC8qIGRlc3RSZWN0ICovKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0ltYWdl TGF5ZXJDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9JbWFnZUxheWVyQ2hyb21pdW0uY3BwCmluZGV4IGY5ZDg2NzQuLmEzNDBiMTQgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0ltYWdlTGF5 ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vSW1hZ2VMYXllckNocm9taXVtLmNwcApAQCAtNTUsNiArNTUsMTIgQEAgcHVibGljOgog ICAgICAgICB9CiAKICAgICAgICAgdmlydHVhbCBNYW5hZ2VkVGV4dHVyZSogdGV4dHVyZSgpIHsg cmV0dXJuIG1fdGV4dHVyZS5nZXQoKTsgfQorICAgICAgICBQYXNzT3duUHRyPE1hbmFnZWRUZXh0 dXJlPiByZXBsYWNlVGV4dHVyZShUZXh0dXJlTWFuYWdlciogbWFuYWdlcikKKyAgICAgICAgewor ICAgICAgICAgICAgT3duUHRyPE1hbmFnZWRUZXh0dXJlPiBvbGQgPSBtX3RleHR1cmUucmVsZWFz ZSgpOworICAgICAgICAgICAgbV90ZXh0dXJlID0gTWFuYWdlZFRleHR1cmU6OmNyZWF0ZShtYW5h Z2VyKTsKKyAgICAgICAgICAgIHJldHVybiBvbGQucmVsZWFzZSgpOworICAgICAgICB9CiAKICAg ICAgICAgdmlydHVhbCBib29sIG5lZWRQcmVwYXJlUmVjdCgpCiAgICAgICAgIHsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hyb21p dW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyQ2hy b21pdW0uaAppbmRleCBkNmMxZTQzLi4xYTU1YjVkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmgKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5oCkBAIC0x NjIsNiArMTYyLDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgYm9vbCBkcmF3c0NvbnRlbnQoKSBj b25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgIHZpcnR1YWwgdm9pZCBwcmVwYXJlVG9VcGRhdGVJ ZkRpcnR5KCkgeyB9CiAgICAgdmlydHVhbCB2b2lkIHBhaW50Q29udGVudHNJZkRpcnR5KCkgeyB9 CisgICAgdmlydHVhbCB2b2lkIGZpbmlzaFVwZGF0ZSgpIHsgfQogICAgIHZpcnR1YWwgdm9pZCBm b3JFYWNoQ29tcG9zaXRvclJlc291cmNlKExheWVyVGV4dHVyZVVwZGF0ZXI6OkhhbmRsZXImKSB7 IH0KICAgICB2aXJ0dWFsIHZvaWQgc2V0SXNNYXNrKGJvb2wpIHsgfQogICAgIHZpcnR1YWwgdm9p ZCB1bnJlc2VydmVDb250ZW50c1RleHR1cmUoKSB7IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyVGV4dHVyZVVwZGF0ZXIuaCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xheWVyVGV4dHVyZVVwZGF0 ZXIuaAppbmRleCAyMjZiYzIxLi5iYzBhZmZiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllclRleHR1cmVVcGRhdGVyLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJUZXh0dXJlVXBkYXRl ci5oCkBAIC0zMCw2ICszMCw3IEBACiAjaWYgVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQog CiAjaW5jbHVkZSAiR3JhcGhpY3NUeXBlczNELmgiCisjaW5jbHVkZSAiTWFuYWdlZFRleHR1cmUu aCIKICNpbmNsdWRlIDx3dGYvUmVmQ291bnRlZC5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBA IC0zNyw5ICszOCw2IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIGNsYXNzIEdyYXBoaWNzQ29udGV4 dDNEOwogY2xhc3MgSW50UmVjdDsKIGNsYXNzIEludFNpemU7Ci1jbGFzcyBNYW5hZ2VkVGV4dHVy ZTsKLWNsYXNzIFRleHR1cmVBbGxvY2F0b3I7Ci1jbGFzcyBUZXh0dXJlTWFuYWdlcjsKIAogY2xh c3MgTGF5ZXJUZXh0dXJlVXBkYXRlciA6IHB1YmxpYyBSZWZDb3VudGVkPExheWVyVGV4dHVyZVVw ZGF0ZXI+IHsKIHB1YmxpYzoKQEAgLTQ5LDYgKzQ3LDcgQEAgcHVibGljOgogICAgICAgICB2aXJ0 dWFsIH5UZXh0dXJlKCkgeyB9CiAKICAgICAgICAgdmlydHVhbCBNYW5hZ2VkVGV4dHVyZSogdGV4 dHVyZSgpIHsgcmV0dXJuIDA7IH0KKyAgICAgICAgdmlydHVhbCBQYXNzT3duUHRyPE1hbmFnZWRU ZXh0dXJlPiByZXBsYWNlVGV4dHVyZShUZXh0dXJlTWFuYWdlciopIHsgcmV0dXJuIFBhc3NPd25Q dHI8TWFuYWdlZFRleHR1cmU+KCk7IH0KIAogICAgICAgICAvLyBwcmVwYXJlUmVjdCgpIHdpbGwg b25seSBiZSBjYWxsZWQgaWYgdGhpcyByZXR1cm5zIHRydWUuCiAgICAgICAgIHZpcnR1YWwgYm9v bCBuZWVkUHJlcGFyZVJlY3QoKSB7IHJldHVybiBmYWxzZTsgfQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFuYWdlZFRleHR1cmUuY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFuYWdlZFRleHR1cmUu Y3BwCmluZGV4IGM3NGM5N2MuLjcwNWUwZWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRUZXh0dXJlLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5jcHAKQEAg LTY2LDYgKzY2LDggQEAgYm9vbCBNYW5hZ2VkVGV4dHVyZTo6cmVzZXJ2ZShjb25zdCBJbnRTaXpl JiBzaXplLCB1bnNpZ25lZCBmb3JtYXQpCiAgICAgICAgIGlmIChyZXNlcnZlZCkgewogICAgICAg ICAgICAgbV9zaXplID0gc2l6ZTsKICAgICAgICAgICAgIG1fZm9ybWF0ID0gZm9ybWF0OworICAg ICAgICAgICAgLy8gVGhpcyB3aWxsIHJldHVybiAwIGlmIHRleHR1cmUgaGFzIG5vdCB5ZXQgYmVl biBhbGxvY2F0ZWQuCisgICAgICAgICAgICBtX3RleHR1cmVJZCA9IG1fdGV4dHVyZU1hbmFnZXIt PnRleHR1cmVJZChtX3Rva2VuKTsKICAgICAgICAgfQogICAgIH0KIApkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGV4dHVyZU1hbmFnZXIuY3Bw IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGV4dHVyZU1hbmFn ZXIuY3BwCmluZGV4IGFlYjY4NjYuLjllODhlNGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RleHR1cmVNYW5hZ2VyLmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UZXh0dXJlTWFuYWdlci5jcHAK QEAgLTIzMiwxMCArMjMyLDM0IEBAIGJvb2wgVGV4dHVyZU1hbmFnZXI6OnJlcXVlc3RUZXh0dXJl KFRleHR1cmVUb2tlbiB0b2tlbiwgSW50U2l6ZSBzaXplLCB1bnNpZ25lZCBmCiAjaWZuZGVmIE5E RUJVRwogICAgIGluZm8uYWxsb2NhdG9yID0gMDsKICNlbmRpZgorCisgICAgLy8gUmV1c2UgZXZp Y3RlZCB0ZXh0dXJlIGlmIGF2YWlsYWJsZS4KKyAgICBmb3IgKHNpemVfdCBpID0gMDsgaSA8IG1f ZXZpY3RlZFRleHR1cmVzLnNpemUoKTsgKytpKSB7CisgICAgICAgIGlmICghbV9ldmljdGVkVGV4 dHVyZXNbaV0udGV4dHVyZUlkKQorICAgICAgICAgICAgY29udGludWU7CisKKyAgICAgICAgaWYg KG1fZXZpY3RlZFRleHR1cmVzW2ldLnNpemUgPT0gc2l6ZSAmJiBtX2V2aWN0ZWRUZXh0dXJlc1tp XS5mb3JtYXQgPT0gZm9ybWF0KSB7CisgICAgICAgICAgICBpbmZvLnRleHR1cmVJZCA9IG1fZXZp Y3RlZFRleHR1cmVzW2ldLnRleHR1cmVJZDsKKyAgICAgICAgICAgIG1fZXZpY3RlZFRleHR1cmVz W2ldLnRleHR1cmVJZCA9IDA7CisjaWZuZGVmIE5ERUJVRworICAgICAgICAgICAgaW5mby5hbGxv Y2F0b3IgPSBtX2V2aWN0ZWRUZXh0dXJlc1tpXS5hbGxvY2F0b3I7CisjZW5kaWYKKyAgICAgICAg ICAgIGJyZWFrOworICAgICAgICB9CisgICAgfQorCiAgICAgYWRkVGV4dHVyZSh0b2tlbiwgaW5m byk7CiAgICAgcmV0dXJuIHRydWU7CiB9CiAKK3Vuc2lnbmVkIFRleHR1cmVNYW5hZ2VyOjp0ZXh0 dXJlSWQoVGV4dHVyZVRva2VuIHRva2VuKQoreworICAgIFRleHR1cmVNYXA6Oml0ZXJhdG9yIGl0 ID0gbV90ZXh0dXJlcy5maW5kKHRva2VuKTsKKyAgICBBU1NFUlQoaXQgIT0gbV90ZXh0dXJlcy5l bmQoKSk7CisgICAgVGV4dHVyZUluZm8qIGluZm8gPSAmaXQuZ2V0KCktPnNlY29uZDsKKyAgICBy ZXR1cm4gaW5mby0+dGV4dHVyZUlkOworfQorCiB9CiAKICNlbmRpZiAvLyBVU0UoQUNDRUxFUkFU RURfQ09NUE9TSVRJTkcpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9UZXh0dXJlTWFuYWdlci5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vVGV4dHVyZU1hbmFnZXIuaAppbmRleCBmMzI3YjRjLi5lZjk4Njdk IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9U ZXh0dXJlTWFuYWdlci5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL1RleHR1cmVNYW5hZ2VyLmgKQEAgLTc1LDYgKzc1LDcgQEAgcHVibGljOgogICAgIHZv aWQgdW5wcm90ZWN0VGV4dHVyZShUZXh0dXJlVG9rZW4pOwogICAgIHZvaWQgdW5wcm90ZWN0QWxs VGV4dHVyZXMoKTsKICAgICBib29sIGlzUHJvdGVjdGVkKFRleHR1cmVUb2tlbik7CisgICAgdW5z aWduZWQgdGV4dHVyZUlkKFRleHR1cmVUb2tlbik7CiAKICAgICB1bnNpZ25lZCBhbGxvY2F0ZVRl eHR1cmUoVGV4dHVyZUFsbG9jYXRvciosIFRleHR1cmVUb2tlbik7CiAgICAgdm9pZCBkZWxldGVF dmljdGVkVGV4dHVyZXMoVGV4dHVyZUFsbG9jYXRvciopOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJv bWl1bS5jcHAKaW5kZXggNTJkMTc4Mi4uN2YyNDg0NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hy b21pdW0uY3BwCkBAIC01Miw3ICs1MiwxMSBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7CiBjbGFzcyBV cGRhdGFibGVUaWxlIDogcHVibGljIENDTGF5ZXJUaWxpbmdEYXRhOjpUaWxlIHsKICAgICBXVEZf TUFLRV9OT05DT1BZQUJMRShVcGRhdGFibGVUaWxlKTsKIHB1YmxpYzoKLSAgICBleHBsaWNpdCBV cGRhdGFibGVUaWxlKFBhc3NPd25QdHI8TGF5ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZT4gdGV4 dHVyZSkgOiBtX3RleHR1cmUodGV4dHVyZSkgeyB9CisgICAgZXhwbGljaXQgVXBkYXRhYmxlVGls ZShQYXNzT3duUHRyPExheWVyVGV4dHVyZVVwZGF0ZXI6OlRleHR1cmU+IHRleHR1cmUpCisgICAg ICAgIDogbV9maXJzdFVwZGF0ZSh0cnVlKQorICAgICAgICAsIG1fdGV4dHVyZSh0ZXh0dXJlKQor ICAgIHsKKyAgICB9CiAKICAgICBMYXllclRleHR1cmVVcGRhdGVyOjpUZXh0dXJlKiB0ZXh0dXJl KCkgeyByZXR1cm4gbV90ZXh0dXJlLmdldCgpOyB9CiAgICAgTWFuYWdlZFRleHR1cmUqIG1hbmFn ZWRUZXh0dXJlKCkgeyByZXR1cm4gbV90ZXh0dXJlLT50ZXh0dXJlKCk7IH0KQEAgLTY0LDYgKzY4 LDggQEAgcHVibGljOgogICAgIEludFJlY3QgbV9kaXJ0eUxheWVyUmVjdDsKICAgICAvLyBDb250 ZW50LXNwYWNlIHJlY3RhbmdsZSB0aGF0IG5lZWRzIHRvIGJlIHVwZGF0ZWQuCiAgICAgSW50UmVj dCBtX3VwZGF0ZVJlY3Q7CisgICAgLy8gVHJ1ZSB1bnRpbCBmaXJzdCB1cGRhdGUgaGFzIGhhcHBl bmRlZC4KKyAgICBib29sIG1fZmlyc3RVcGRhdGU7CiBwcml2YXRlOgogICAgIE93blB0cjxMYXll clRleHR1cmVVcGRhdGVyOjpUZXh0dXJlPiBtX3RleHR1cmU7CiB9OwpAQCAtMTc0LDMxICsxODAs MjQgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OmNyZWF0ZVRpbGVyKENDTGF5ZXJUaWxpbmdE YXRhOjpCb3JkZXJUZXhlbE9wdGlvbiBib3JkZXIKIAogdm9pZCBUaWxlZExheWVyQ2hyb21pdW06 OmZvckVhY2hDb21wb3NpdG9yUmVzb3VyY2UoTGF5ZXJUZXh0dXJlVXBkYXRlcjo6SGFuZGxlciYg aGFuZGxlcikKIHsKLSAgICAvLyBQYWludGluZyBjb3VsZCBjYXVzZSBjb21wb3NpdGluZyB0byBn ZXQgdHVybmVkIG9mZiwgd2hpY2ggbWF5IGNhdXNlIHRoZSB0aWxlciB0byBiZWNvbWUgaW52YWxp ZGF0ZWQgbWlkLXVwZGF0ZS4KLSAgICBpZiAobV9za2lwc0RyYXcgfHwgbV9yZXF1ZXN0ZWRVcGRh dGVSZWN0LmlzRW1wdHkoKSB8fCAhbV90aWxlci0+bnVtVGlsZXMoKSB8fCBtX3BhaW50UmVjdC5p c0VtcHR5KCkpCisgICAgaWYgKCFtX3RpbGVyKQogICAgICAgICByZXR1cm47CiAKLSAgICBpbnQg bGVmdCwgdG9wLCByaWdodCwgYm90dG9tOwotICAgIG1fdGlsZXItPmNvbnRlbnRSZWN0VG9UaWxl SW5kaWNlcyhtX3JlcXVlc3RlZFVwZGF0ZVJlY3QsIGxlZnQsIHRvcCwgcmlnaHQsIGJvdHRvbSk7 Ci0gICAgZm9yIChpbnQgaiA9IHRvcDsgaiA8PSBib3R0b207ICsraikgewotICAgICAgICBmb3Ig KGludCBpID0gbGVmdDsgaSA8PSByaWdodDsgKytpKSB7Ci0gICAgICAgICAgICBVcGRhdGFibGVU aWxlKiB0aWxlID0gdGlsZUF0KGksIGopOworICAgIGZvciAoQ0NMYXllclRpbGluZ0RhdGE6OlRp bGVNYXA6OmNvbnN0X2l0ZXJhdG9yIGl0ZXIgPSBtX3RpbGVyLT50aWxlcygpLmJlZ2luKCk7IGl0 ZXIgIT0gbV90aWxlci0+dGlsZXMoKS5lbmQoKTsgKytpdGVyKSB7CisgICAgICAgIFVwZGF0YWJs ZVRpbGUqIHRpbGUgPSBzdGF0aWNfY2FzdDxVcGRhdGFibGVUaWxlKj4oaXRlci0+c2Vjb25kLmdl dCgpKTsKIAotICAgICAgICAgICAgLy8gUmVxdWlyZWQgdGlsZXMgYXJlIGNyZWF0ZWQgaW4gcHJl cGFyZVRvVXBkYXRlKCkuIEEgdGlsZSBzaG91bGQKLSAgICAgICAgICAgIC8vIG5ldmVyIGJlIHJl bW92ZWQgYmV0d2VlbiB0aGUgY2FsbCB0byBwcmVwYXJlVG9VcGRhdGUoKSBhbmQgdGhlCi0gICAg ICAgICAgICAvLyBjYWxsIHRvIHVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMoKS4KLSAgICAgICAg ICAgIGlmICghdGlsZSkKLSAgICAgICAgICAgICAgICBDUkFTSCgpOworICAgICAgICBJbnRSZWN0 IHNvdXJjZVJlY3Q7CisgICAgICAgIEludFJlY3QgZGVzdFJlY3Q7CiAKLSAgICAgICAgICAgIElu dFJlY3Qgc291cmNlUmVjdCA9IHRpbGUtPm1fdXBkYXRlUmVjdDsKLSAgICAgICAgICAgIGlmICh0 aWxlLT5tX3VwZGF0ZVJlY3QuaXNFbXB0eSgpKQotICAgICAgICAgICAgICAgIGNvbnRpbnVlOwor ICAgICAgICAvLyBQYWludGluZyBjb3VsZCBjYXVzZSBjb21wb3NpdGluZyB0byBnZXQgdHVybmVk IG9mZiwgd2hpY2ggbWF5IGNhdXNlIHRoZSB0aWxlciB0byBiZWNvbWUgaW52YWxpZGF0ZWQgbWlk LXVwZGF0ZS4KKyAgICAgICAgaWYgKCFtX3NraXBzRHJhdyAmJiAhbV9yZXF1ZXN0ZWRVcGRhdGVS ZWN0LmlzRW1wdHkoKSAmJiAhbV9wYWludFJlY3QuaXNFbXB0eSgpKQorICAgICAgICAgICAgc291 cmNlUmVjdCA9IHRpbGUtPm1fdXBkYXRlUmVjdDsKIAotICAgICAgICAgICAgQVNTRVJUKHRpbGUt Pm1hbmFnZWRUZXh0dXJlKCktPmlzUmVzZXJ2ZWQoKSk7CisgICAgICAgIGlmICghc291cmNlUmVj dC5pc0VtcHR5KCkpIHsKICAgICAgICAgICAgIGNvbnN0IEludFBvaW50IGFuY2hvciA9IG1fdGls ZXItPnRpbGVDb250ZW50UmVjdCh0aWxlKS5sb2NhdGlvbigpOwogCiAgICAgICAgICAgICAvLyBD YWxjdWxhdGUgdGlsZS1zcGFjZSByZWN0YW5nbGUgdG8gdXBsb2FkIGludG8uCi0gICAgICAgICAg ICBJbnRSZWN0IGRlc3RSZWN0KEludFBvaW50KHNvdXJjZVJlY3QueCgpIC0gYW5jaG9yLngoKSwg c291cmNlUmVjdC55KCkgLSBhbmNob3IueSgpKSwgc291cmNlUmVjdC5zaXplKCkpOworICAgICAg ICAgICAgZGVzdFJlY3QgPSBJbnRSZWN0KEludFBvaW50KHNvdXJjZVJlY3QueCgpIC0gYW5jaG9y LngoKSwgc291cmNlUmVjdC55KCkgLSBhbmNob3IueSgpKSwgc291cmNlUmVjdC5zaXplKCkpOwog ICAgICAgICAgICAgaWYgKGRlc3RSZWN0LngoKSA8IDApCiAgICAgICAgICAgICAgICAgQ1JBU0go KTsKICAgICAgICAgICAgIGlmIChkZXN0UmVjdC55KCkgPCAwKQpAQCAtMjE0LDkgKzIxMyw5IEBA IHZvaWQgVGlsZWRMYXllckNocm9taXVtOjpmb3JFYWNoQ29tcG9zaXRvclJlc291cmNlKExheWVy VGV4dHVyZVVwZGF0ZXI6OkhhbmRsZXImCiAgICAgICAgICAgICAgICAgQ1JBU0goKTsKICAgICAg ICAgICAgIGlmIChwYWludE9mZnNldC55KCkgKyBkZXN0UmVjdC5oZWlnaHQoKSA+IG1fcGFpbnRS ZWN0LmhlaWdodCgpKQogICAgICAgICAgICAgICAgIENSQVNIKCk7Ci0KLSAgICAgICAgICAgIGhh bmRsZXIuaGFuZGxlKHRpbGUtPnRleHR1cmUoKSwgc291cmNlUmVjdCwgZGVzdFJlY3QpOwogICAg ICAgICB9CisKKyAgICAgICAgaGFuZGxlci5oYW5kbGUodGlsZS0+dGV4dHVyZSgpLCBzb3VyY2VS ZWN0LCBkZXN0UmVjdCk7CiAgICAgfQogfQogCkBAIC0zNzQsMTUgKzM3MywxNyBAQCB2b2lkIFRp bGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRvVXBkYXRlKGNvbnN0IEludFJlY3QmIGNvbnRlbnRS ZWN0KQogICAgICAgICAgICAgaWYgKCF0aWxlKQogICAgICAgICAgICAgICAgIHRpbGUgPSBjcmVh dGVUaWxlKGksIGopOwogCi0gICAgICAgICAgICBpZiAoIXRpbGUtPm1hbmFnZWRUZXh0dXJlKCkt PmlzVmFsaWQobV90aWxlci0+dGlsZVNpemUoKSwgbV90ZXh0dXJlRm9ybWF0KSkKKyAgICAgICAg ICAgIGlmICh0aWxlLT5tX2ZpcnN0VXBkYXRlKSB7CiAgICAgICAgICAgICAgICAgdGlsZS0+bV9k aXJ0eUxheWVyUmVjdCA9IG1fdGlsZXItPnRpbGVMYXllclJlY3QodGlsZSk7Ci0KLSAgICAgICAg ICAgIGlmICghdGlsZS0+bWFuYWdlZFRleHR1cmUoKS0+cmVzZXJ2ZShtX3RpbGVyLT50aWxlU2l6 ZSgpLCBtX3RleHR1cmVGb3JtYXQpKSB7Ci0gICAgICAgICAgICAgICAgbV9za2lwc0RyYXcgPSB0 cnVlOwotICAgICAgICAgICAgICAgIGNsZWFudXBSZXNvdXJjZXMoKTsKLSAgICAgICAgICAgICAg ICByZXR1cm47CisgICAgICAgICAgICAgICAgdGlsZS0+bV9maXJzdFVwZGF0ZSA9IGZhbHNlOwog ICAgICAgICAgICAgfQogCisgICAgICAgICAgICBpZiAodGlsZS0+bV9kaXJ0eUxheWVyUmVjdC5p c0VtcHR5KCkpCisgICAgICAgICAgICAgICAgY29udGludWU7CisKKyAgICAgICAgICAgIGlmICgh dGlsZS0+bWFuYWdlZFRleHR1cmUoKS0+aXNWYWxpZChtX3RpbGVyLT50aWxlU2l6ZSgpLCBtX3Rl eHR1cmVGb3JtYXQpKQorICAgICAgICAgICAgICAgIHRpbGUtPm1fZGlydHlMYXllclJlY3QgPSBt X3RpbGVyLT50aWxlTGF5ZXJSZWN0KHRpbGUpOworCiAgICAgICAgICAgICBkaXJ0eUxheWVyUmVj dC51bml0ZSh0aWxlLT5tX2RpcnR5TGF5ZXJSZWN0KTsKICAgICAgICAgfQogICAgIH0KQEAgLTQy OSw2ICs0MzAsMTcgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnBhaW50Q29udGVudHMoY29u c3QgSW50UmVjdCYgY29udGVudFJlY3QpCiAgICAgaWYgKG1fc2tpcHNEcmF3IHx8IG1fcmVxdWVz dGVkVXBkYXRlUmVjdC5pc0VtcHR5KCkgfHwgIW1fdGlsZXItPm51bVRpbGVzKCkgfHwgbV9wYWlu dFJlY3QuaXNFbXB0eSgpKQogICAgICAgICByZXR1cm47CiAKKyAgICAvLyBSZXNlcnZlIHRpbGVz IGFzIG5lZWRlZC4KKyAgICBmb3IgKENDTGF5ZXJUaWxpbmdEYXRhOjpUaWxlTWFwOjpjb25zdF9p dGVyYXRvciBpdGVyID0gbV90aWxlci0+dGlsZXMoKS5iZWdpbigpOyBpdGVyICE9IG1fdGlsZXIt PnRpbGVzKCkuZW5kKCk7ICsraXRlcikgeworICAgICAgICBVcGRhdGFibGVUaWxlKiB0aWxlID0g c3RhdGljX2Nhc3Q8VXBkYXRhYmxlVGlsZSo+KGl0ZXItPnNlY29uZC5nZXQoKSk7CisKKyAgICAg ICAgaWYgKHRpbGUtPm1fdXBkYXRlUmVjdC5pc0VtcHR5KCkpCisgICAgICAgICAgICBjb250aW51 ZTsKKworICAgICAgICBpZiAoIXRpbGUtPm1hbmFnZWRUZXh0dXJlKCktPnJlc2VydmUobV90aWxl ci0+dGlsZVNpemUoKSwgbV90ZXh0dXJlRm9ybWF0KSkKKyAgICAgICAgICAgIHRpbGUtPm1fdXBk YXRlUmVjdCA9IEludFJlY3QoKTsKKyAgICB9CisKICAgICAvLyBDYWxsaW5nIHBhaW50Q29udGVu dHMoKSBjYWxscyBpbnRvIFdlYktpdCB0byBwYWludCwgd2hpY2ggbWF5IGhhdmUgdGhlIHNpZGUK ICAgICAvLyBlZmZlY3Qgb2YgZGlzYWJsaW5nIGNvbXBvc2l0aW5nLCB3aGljaCBjYXVzZXMgb3Vy IHJlZmVyZW5jZSB0byB0aGUgdGV4dHVyZSB1cGRhdGVyIHRvIGJlIGRlbGV0ZWQuCiAgICAgLy8g SG93ZXZlciwgd2UgY2FuJ3QgZnJlZSB0aGUgbWVtb3J5IGJhY2tpbmcgdGhlIEdyYXBoaWNzQ29u dGV4dCB1bnRpbCB0aGUgcGFpbnQgZmluaXNoZXMsCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXllckNocm9taXVt LmNwcAppbmRleCA3YmVjN2MwLi40YjRjNDY5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1 bS5jcHAKQEAgLTQ3LDYgKzQ3LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogVmlkZW9MYXllckNo cm9taXVtOjpVcGRhdGVyVGV4dHVyZTo6VXBkYXRlclRleHR1cmUoUGFzc093blB0cjxNYW5hZ2Vk VGV4dHVyZT4gdGV4dHVyZSkKICAgICA6IG1fdGV4dHVyZSh0ZXh0dXJlKQogICAgICwgbV9tYXBw ZWRCdWZmZXIoMCkKKyAgICAsIG1fZGF0YSgwKQogewogfQogCkBAIC01NSw2ICs1NiwxMyBAQCBW aWRlb0xheWVyQ2hyb21pdW06OlVwZGF0ZXJUZXh0dXJlOjp+VXBkYXRlclRleHR1cmUoKQogICAg IEFTU0VSVCghbV9tYXBwZWRCdWZmZXIpOwogfQogCitQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJl PiBWaWRlb0xheWVyQ2hyb21pdW06OlVwZGF0ZXJUZXh0dXJlOjpyZXBsYWNlVGV4dHVyZShUZXh0 dXJlTWFuYWdlciogbWFuYWdlcikKK3sKKyAgICBPd25QdHI8TWFuYWdlZFRleHR1cmU+IG9sZCA9 IG1fdGV4dHVyZS5yZWxlYXNlKCk7CisgICAgbV90ZXh0dXJlID0gTWFuYWdlZFRleHR1cmU6OmNy ZWF0ZShtYW5hZ2VyKTsKKyAgICByZXR1cm4gb2xkLnJlbGVhc2UoKTsKK30KKwogdm9pZCBWaWRl b0xheWVyQ2hyb21pdW06OlVwZGF0ZXJUZXh0dXJlOjpwcmVwYXJlUmVjdChHcmFwaGljc0NvbnRl eHQzRCogY29udGV4dCwgVGV4dHVyZUFsbG9jYXRvciogYWxsb2NhdG9yLCBjb25zdCBJbnRSZWN0 JiAvKiBzb3VyY2VSZWN0ICovLCBjb25zdCBJbnRSZWN0JiAvKiBkZXN0UmVjdCAqLykKIHsKICAg ICBJbnRTaXplIGRpbWVuc2lvbnMgPSBtX3RleHR1cmUtPnNpemUoKTsKQEAgLTcwLDE0ICs3OCwx NSBAQCB2b2lkIFZpZGVvTGF5ZXJDaHJvbWl1bTo6VXBkYXRlclRleHR1cmU6OnByZXBhcmVSZWN0 KEdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0LAogICAgIG1fdGV4dHVyZS0+YWxsb2NhdGVUZXh0 dXJlKGNvbnRleHQsIGFsbG9jYXRvcik7CiB9CiAKLXZvaWQgVmlkZW9MYXllckNocm9taXVtOjpV cGRhdGVyVGV4dHVyZTo6ZGF0YVJlY3QoY29uc3Qgdm9pZCogZGF0YSkKK3ZvaWQgVmlkZW9MYXll ckNocm9taXVtOjpVcGRhdGVyVGV4dHVyZTo6cGFpbnRDb250ZW50c1JlY3QoY29uc3QgSW50UmVj dCYgLyogc291cmNlUmVjdCAqLykKIHsKICAgICBzaXplX3QgYnVmZmVyU2l6ZSA9IFRleHR1cmVN YW5hZ2VyOjptZW1vcnlVc2VCeXRlcyhtX3RleHR1cmUtPnNpemUoKSwgbV90ZXh0dXJlLT5mb3Jt YXQoKSk7CiAKKyAgICBBU1NFUlQobV9kYXRhKTsKICAgICBpZiAobV9tYXBwZWRCdWZmZXIpCi0g ICAgICAgIG1lbWNweShtX21hcHBlZEJ1ZmZlciwgZGF0YSwgYnVmZmVyU2l6ZSk7CisgICAgICAg IG1lbWNweShtX21hcHBlZEJ1ZmZlciwgbV9kYXRhLCBidWZmZXJTaXplKTsKICAgICBlbHNlCi0g ICAgICAgIG1lbWNweShtX2J1ZmZlci5nZXQoKSwgZGF0YSwgYnVmZmVyU2l6ZSk7CisgICAgICAg IG1lbWNweShtX2J1ZmZlci5nZXQoKSwgbV9kYXRhLCBidWZmZXJTaXplKTsKIH0KIAogdm9pZCBW aWRlb0xheWVyQ2hyb21pdW06OlVwZGF0ZXJUZXh0dXJlOjp1cGRhdGVSZWN0KEdyYXBoaWNzQ29u dGV4dDNEKiBjb250ZXh0LCBjb25zdCBJbnRSZWN0JiAvKiBzb3VyY2VSZWN0ICovLCBjb25zdCBJ bnRSZWN0JiAvKiBkZXN0UmVjdCAqLykKQEAgLTEzMSw3ICsxNDAsNyBAQCB2b2lkIFZpZGVvTGF5 ZXJDaHJvbWl1bTo6Y2xlYW51cFJlc291cmNlcygpCiAKIHZvaWQgVmlkZW9MYXllckNocm9taXVt OjpwcmVwYXJlVG9VcGRhdGVJZkRpcnR5KCkKIHsKLSAgICBtX2ZyYW1lID0gMDsKKyAgICBBU1NF UlQoIW1fZnJhbWUpOwogCiAgICAgaWYgKCFtX2RlbGVnYXRlIHx8ICFtX3Byb3ZpZGVyIHx8ICFk cmF3c0NvbnRlbnQoKSkKICAgICAgICAgcmV0dXJuOwpAQCAtMTg3LDYgKzE5Niw5IEBAIHZvaWQg VmlkZW9MYXllckNocm9taXVtOjpwcmVwYXJlVG9VcGRhdGVJZkRpcnR5KCkKICAgICAgICAgcmV0 dXJuOwogICAgIH0KIAorICAgIGZvciAodW5zaWduZWQgcGxhbmUgPSAwOyBwbGFuZSA8IGZyYW1l LT5wbGFuZXMoKTsgcGxhbmUrKykKKyAgICAgICAgbV90ZXh0dXJlc1twbGFuZV0tPnNldERhdGEo ZnJhbWUtPmRhdGEocGxhbmUpKTsKKwogICAgIG1fZnJhbWUgPSBmcmFtZTsKICAgICBtX3BsYW5l cyA9IGZyYW1lLT5wbGFuZXMoKTsKIApAQCAtMTk0LDE2ICsyMDYsMTUgQEAgdm9pZCBWaWRlb0xh eWVyQ2hyb21pdW06OnByZXBhcmVUb1VwZGF0ZUlmRGlydHkoKQogICAgIG1fbmVlZHNEaXNwbGF5 ID0gZmFsc2U7CiB9CiAKLXZvaWQgVmlkZW9MYXllckNocm9taXVtOjpwYWludENvbnRlbnRzSWZE aXJ0eSgpCit2b2lkIFZpZGVvTGF5ZXJDaHJvbWl1bTo6ZmluaXNoVXBkYXRlKCkKIHsKLSAgICBp ZiAoIW1fZnJhbWUpCi0gICAgICAgIHJldHVybjsKKyAgICBpZiAobV9mcmFtZSkgeworICAgICAg ICBmb3IgKHVuc2lnbmVkIHBsYW5lID0gMDsgcGxhbmUgPCBtX3BsYW5lczsgcGxhbmUrKykKKyAg ICAgICAgICAgIG1fdGV4dHVyZXNbcGxhbmVdLT5yZXNldERhdGEoKTsKIAotICAgIC8vIENvcHkg cGxhbmVzIHRvIG1hcHBlZCBidWZmZXJzLgotICAgIGZvciAodW5zaWduZWQgcGxhbmUgPSAwOyBw bGFuZSA8IG1fZnJhbWUtPnBsYW5lcygpOyBwbGFuZSsrKQotICAgICAgICBtX3RleHR1cmVzW3Bs YW5lXS0+ZGF0YVJlY3QobV9mcmFtZS0+ZGF0YShwbGFuZSkpOwotCi0gICAgbV9wcm92aWRlci0+ cHV0Q3VycmVudEZyYW1lKG1fZnJhbWUpOworICAgICAgICBtX3Byb3ZpZGVyLT5wdXRDdXJyZW50 RnJhbWUobV9mcmFtZSk7CisgICAgICAgIG1fZnJhbWUgPSAwOworICAgIH0KIH0KIAogdm9pZCBW aWRlb0xheWVyQ2hyb21pdW06OmZvckVhY2hDb21wb3NpdG9yUmVzb3VyY2UoTGF5ZXJUZXh0dXJl VXBkYXRlcjo6SGFuZGxlciYgaGFuZGxlcikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1bS5oIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXllckNocm9taXVtLmgKaW5k ZXggMzUxZjhmOC4uODA4MDQ5ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXllckNocm9taXVtLmgKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXllckNocm9taXVtLmgKQEAgLTUz LDE1ICs1MywxOSBAQCBwdWJsaWM6CiAgICAgICAgIHZpcnR1YWwgflVwZGF0ZXJUZXh0dXJlKCk7 CiAKICAgICAgICAgdmlydHVhbCBNYW5hZ2VkVGV4dHVyZSogdGV4dHVyZSgpIHsgcmV0dXJuIG1f dGV4dHVyZS5nZXQoKTsgfQorICAgICAgICB2aXJ0dWFsIFBhc3NPd25QdHI8TWFuYWdlZFRleHR1 cmU+IHJlcGxhY2VUZXh0dXJlKFRleHR1cmVNYW5hZ2VyKik7CiAKICAgICAgICAgdmlydHVhbCBi b29sIG5lZWRQcmVwYXJlUmVjdCgpIHsgcmV0dXJuIHRydWU7IH0KICAgICAgICAgdmlydHVhbCB2 b2lkIHByZXBhcmVSZWN0KEdyYXBoaWNzQ29udGV4dDNEKiwgVGV4dHVyZUFsbG9jYXRvciosIGNv bnN0IEludFJlY3QmIHNvdXJjZVJlY3QsIGNvbnN0IEludFJlY3QmIGRlc3RSZWN0KTsKLSAgICAg ICAgdm9pZCBkYXRhUmVjdChjb25zdCB2b2lkKik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBwYWlu dENvbnRlbnRzUmVjdChjb25zdCBJbnRSZWN0JiBzb3VyY2VSZWN0KTsKICAgICAgICAgdmlydHVh bCB2b2lkIHVwZGF0ZVJlY3QoR3JhcGhpY3NDb250ZXh0M0QqLCBjb25zdCBJbnRSZWN0JiBzb3Vy Y2VSZWN0LCBjb25zdCBJbnRSZWN0JiBkZXN0UmVjdCk7CiAKICAgICAgICAgdm9pZCBzZXRWaXNp YmxlU2l6ZShJbnRTaXplJiBzaXplKSB7IG1fdmlzaWJsZVNpemUgPSBzaXplOyB9CiAgICAgICAg IEludFNpemUmIHZpc2libGVTaXplKCkgeyByZXR1cm4gbV92aXNpYmxlU2l6ZTsgfQogCisgICAg ICAgIHZvaWQgc2V0RGF0YShjb25zdCB2b2lkKiBkYXRhKSB7IG1fZGF0YSA9IGRhdGE7IH0KKyAg ICAgICAgdm9pZCByZXNldERhdGEoKSB7IG1fZGF0YSA9IDA7IH0KKwogICAgIHByaXZhdGU6CiAg ICAgICAgIGV4cGxpY2l0IFVwZGF0ZXJUZXh0dXJlKFBhc3NPd25QdHI8TWFuYWdlZFRleHR1cmU+ KTsKIApAQCAtNjksNiArNzMsNyBAQCBwdWJsaWM6CiAgICAgICAgIEludFNpemUgbV92aXNpYmxl U2l6ZTsKICAgICAgICAgdWludDhfdCogbV9tYXBwZWRCdWZmZXI7CiAgICAgICAgIE93bkFycmF5 UHRyPHVpbnQ4X3Q+IG1fYnVmZmVyOworICAgICAgICBjb25zdCB2b2lkKiBtX2RhdGE7CiAgICAg fTsKIAogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFZpZGVvTGF5ZXJDaHJvbWl1bT4gY3JlYXRlKEND TGF5ZXJEZWxlZ2F0ZSogPSAwLApAQCAtNzgsNyArODMsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVh bCBQYXNzUmVmUHRyPENDTGF5ZXJJbXBsPiBjcmVhdGVDQ0xheWVySW1wbCgpOwogCiAgICAgdmly dHVhbCB2b2lkIHByZXBhcmVUb1VwZGF0ZUlmRGlydHkoKTsKLSAgICB2aXJ0dWFsIHZvaWQgcGFp bnRDb250ZW50c0lmRGlydHkoKTsKKyAgICB2aXJ0dWFsIHZvaWQgZmluaXNoVXBkYXRlKCk7CiAg ICAgdmlydHVhbCB2b2lkIGZvckVhY2hDb21wb3NpdG9yUmVzb3VyY2UoTGF5ZXJUZXh0dXJlVXBk YXRlcjo6SGFuZGxlciYpOwogICAgIHZpcnR1YWwgYm9vbCBkcmF3c0NvbnRlbnQoKSBjb25zdCB7 IHJldHVybiB0cnVlOyB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL1dlYkdMTGF5ZXJDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9XZWJHTExheWVyQ2hyb21pdW0uY3BwCmluZGV4IDNm NGIwNWIuLmYzOWQzZGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1dlYkdMTGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vV2ViR0xMYXllckNocm9taXVtLmNwcApAQCAtMTEz LDcgKzExMyw4IEBAIHZvaWQgV2ViR0xMYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVz b3VyY2VzKEdyYXBoaWNzQ29udGV4dDNEKiByZW5kZXJlckNvCiAKIHZvaWQgV2ViR0xMYXllckNo cm9taXVtOjpmb3JFYWNoQ29tcG9zaXRvclJlc291cmNlKExheWVyVGV4dHVyZVVwZGF0ZXI6Okhh bmRsZXImIGhhbmRsZXIpCiB7Ci0gICAgaGFuZGxlci5oYW5kbGUobV91cGRhdGVyVGV4dHVyZS5n ZXQoKSwgSW50UmVjdCgpLCBJbnRSZWN0KCkpOworICAgIEludFJlY3Qgbm9uRW1wdHlSZWN0KDAs IDAsIDEsIDEpOworICAgIGhhbmRsZXIuaGFuZGxlKG1fdXBkYXRlclRleHR1cmUuZ2V0KCksIG5v bkVtcHR5UmVjdCwgbm9uRW1wdHlSZWN0KTsKIH0KIAogYm9vbCBXZWJHTExheWVyQ2hyb21pdW06 OnBhaW50UmVuZGVyZWRSZXN1bHRzVG9DYW52YXMoSW1hZ2VCdWZmZXIqIGltYWdlQnVmZmVyKQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NMYXllclRyZWVIb3N0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAKaW5kZXggY2M0ZGE5NS4uYjcyMzVmZSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NM YXllclRyZWVIb3N0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwCkBAIC01OCw4ICs1OCwxMSBAQCBDQ0xheWVy VHJlZUhvc3Q6Ok5lZWRSZXNvdXJjZUhhbmRsZXI6On5OZWVkUmVzb3VyY2VIYW5kbGVyKCkKIHsK IH0KIAotdm9pZCBDQ0xheWVyVHJlZUhvc3Q6Ok5lZWRSZXNvdXJjZUhhbmRsZXI6OmhhbmRsZShM YXllclRleHR1cmVVcGRhdGVyOjpUZXh0dXJlKiB0ZXh0dXJlLCBjb25zdCBJbnRSZWN0JiAvKiBz b3VyY2VSZWN0ICovLCBjb25zdCBJbnRSZWN0JiAvKiBkZXN0UmVjdCAqLykKK3ZvaWQgQ0NMYXll clRyZWVIb3N0OjpOZWVkUmVzb3VyY2VIYW5kbGVyOjpoYW5kbGUoTGF5ZXJUZXh0dXJlVXBkYXRl cjo6VGV4dHVyZSogdGV4dHVyZSwgY29uc3QgSW50UmVjdCYgLyogc291cmNlUmVjdCAqLywgY29u c3QgSW50UmVjdCYgZGVzdFJlY3QpCiB7CisgICAgaWYgKGRlc3RSZWN0LmlzRW1wdHkoKSkKKyAg ICAgICAgcmV0dXJuOworCiAgICAgaWYgKHRleHR1cmUtPm5lZWRQcmVwYXJlUmVjdCgpKQogICAg ICAgICBtX3Jlc291cmNlcysrOwogfQpAQCAtNzYsNiArNzksOSBAQCBDQ0xheWVyVHJlZUhvc3Q6 OlByZXBhcmVSZXNvdXJjZUhhbmRsZXI6On5QcmVwYXJlUmVzb3VyY2VIYW5kbGVyKCkKIAogdm9p ZCBDQ0xheWVyVHJlZUhvc3Q6OlByZXBhcmVSZXNvdXJjZUhhbmRsZXI6OmhhbmRsZShMYXllclRl eHR1cmVVcGRhdGVyOjpUZXh0dXJlKiB0ZXh0dXJlLCBjb25zdCBJbnRSZWN0JiBzb3VyY2VSZWN0 LCBjb25zdCBJbnRSZWN0JiBkZXN0UmVjdCkKIHsKKyAgICBpZiAoZGVzdFJlY3QuaXNFbXB0eSgp KQorICAgICAgICByZXR1cm47CisKICAgICBpZiAodGV4dHVyZS0+bmVlZFByZXBhcmVSZWN0KCkp CiAgICAgICAgIHRleHR1cmUtPnByZXBhcmVSZWN0KG1fY29udGV4dCwgbV9hbGxvY2F0b3IsIHNv dXJjZVJlY3QsIGRlc3RSZWN0KTsKIH0KQEAgLTkxLDEwICs5NywzNCBAQCBDQ0xheWVyVHJlZUhv c3Q6OlBhaW50SGFuZGxlcjo6flBhaW50SGFuZGxlcigpCiAKIHZvaWQgQ0NMYXllclRyZWVIb3N0 OjpQYWludEhhbmRsZXI6OmhhbmRsZShMYXllclRleHR1cmVVcGRhdGVyOjpUZXh0dXJlKiB0ZXh0 dXJlLCBjb25zdCBJbnRSZWN0JiBzb3VyY2VSZWN0LCBjb25zdCBJbnRSZWN0JiBkZXN0UmVjdCkK IHsKKyAgICBpZiAoZGVzdFJlY3QuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisKICAgICB0 ZXh0dXJlLT5wYWludENvbnRlbnRzUmVjdChzb3VyY2VSZWN0KTsKICAgICBtX3Byb3h5LT51cGRh dGUodGV4dHVyZSwgc291cmNlUmVjdCwgZGVzdFJlY3QpOwogfQogCitDQ0xheWVyVHJlZUhvc3Q6 OlJlcGxhY2VUZXh0dXJlSGFuZGxlcjo6UmVwbGFjZVRleHR1cmVIYW5kbGVyKFRleHR1cmVNYW5h Z2VyKiBtYW5hZ2VyLCBUZXh0dXJlTGlzdCogbGlzdCkKKyAgICA6IG1fdGV4dHVyZU1hbmFnZXIo bWFuYWdlcikKKyAgICAsIG1fbGlzdChsaXN0KQoreworfQorCitDQ0xheWVyVHJlZUhvc3Q6OlJl cGxhY2VUZXh0dXJlSGFuZGxlcjo6flJlcGxhY2VUZXh0dXJlSGFuZGxlcigpCit7Cit9CisKK3Zv aWQgQ0NMYXllclRyZWVIb3N0OjpSZXBsYWNlVGV4dHVyZUhhbmRsZXI6OmhhbmRsZShMYXllclRl eHR1cmVVcGRhdGVyOjpUZXh0dXJlKiB0ZXh0dXJlLCBjb25zdCBJbnRSZWN0JiAvKiBzb3VyY2VS ZWN0ICovLCBjb25zdCBJbnRSZWN0JiBkZXN0UmVjdCkKK3sKKyAgICBpZiAoZGVzdFJlY3QuaXNF bXB0eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAodGV4dHVyZS0+dGV4dHVyZSgpKSB7 CisgICAgICAgIG1fbGlzdC0+YXBwZW5kKHRleHR1cmUtPnJlcGxhY2VUZXh0dXJlKG1fdGV4dHVy ZU1hbmFnZXIpKTsKKyAgICAgICAgQVNTRVJUKG1fbGlzdC0+bGFzdCgpLmdldCgpKTsKKyAgICB9 Cit9CisKIFBhc3NSZWZQdHI8Q0NMYXllclRyZWVIb3N0PiBDQ0xheWVyVHJlZUhvc3Q6OmNyZWF0 ZShDQ0xheWVyVHJlZUhvc3RDbGllbnQqIGNsaWVudCwgY29uc3QgQ0NTZXR0aW5ncyYgc2V0dGlu Z3MpCiB7CiAgICAgUmVmUHRyPENDTGF5ZXJUcmVlSG9zdD4gbGF5ZXJUcmVlSG9zdCA9IGFkb3B0 UmVmKG5ldyBDQ0xheWVyVHJlZUhvc3QoY2xpZW50LCBzZXR0aW5ncykpOwpAQCAtNDMzLDEyICs0 NjMsMzggQEAgdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnBhaW50Q29udGVudHMoTGF5ZXJDaHJvbWl1 bSogcm9vdExheWVyKQogICAgIGZvciAoaW50IGxheWVySW5kZXggPSBtX2xheWVyVXBkYXRlTGlz dC5zaXplKCkgLSAxOyBsYXllckluZGV4ID49IDAgOyAtLWxheWVySW5kZXgpIHsKICAgICAgICAg TGF5ZXJDaHJvbWl1bSogbGF5ZXIgPSBtX2xheWVyVXBkYXRlTGlzdFtsYXllckluZGV4XS5nZXQo KTsKICAgICAgICAgbGF5ZXItPnBhaW50Q29udGVudHNJZkRpcnR5KCk7CisgICAgfQorfQorCit2 b2lkIENDTGF5ZXJUcmVlSG9zdDo6dXBkYXRlQ29udGVudHMoKQoreworICAgIGlmICghcm9vdExh eWVyKCkpCisgICAgICAgIHJldHVybjsKKworICAgIGlmICh2aWV3cG9ydFNpemUoKS5pc0VtcHR5 KCkpCisgICAgICAgIHJldHVybjsKKworICAgIHVwZGF0ZUNvbnRlbnRzKHJvb3RMYXllcigpKTsK K30KKwordm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnVwZGF0ZUNvbnRlbnRzKExheWVyQ2hyb21pdW0q IHJvb3RMYXllcikKK3sKKyAgICBUUkFDRV9FVkVOVCgiQ0NMYXllclRyZWVIb3N0Ojp1cGRhdGVD b250ZW50cyIsIHRoaXMsIDApOwogCisgICAgZm9yIChpbnQgbGF5ZXJJbmRleCA9IG1fbGF5ZXJV cGRhdGVMaXN0LnNpemUoKSAtIDE7IGxheWVySW5kZXggPj0gMCA7IC0tbGF5ZXJJbmRleCkgewog ICAgICAgICBQYWludEhhbmRsZXIgaGFuZGxlcihtX3Byb3h5LmdldCgpKTsKKyAgICAgICAgTGF5 ZXJDaHJvbWl1bSogbGF5ZXIgPSBtX2xheWVyVXBkYXRlTGlzdFtsYXllckluZGV4XS5nZXQoKTsK ICAgICAgICAgbGF5ZXItPmZvckVhY2hDb21wb3NpdG9yUmVzb3VyY2UoaGFuZGxlcik7CisgICAg ICAgIGxheWVyLT5maW5pc2hVcGRhdGUoKTsKICAgICB9CiB9CiAKK3ZvaWQgQ0NMYXllclRyZWVI b3N0OjpyZXBsYWNlVGV4dHVyZXMoVGV4dHVyZUxpc3QmIGxpc3QpCit7CisgICAgUmVwbGFjZVRl eHR1cmVIYW5kbGVyIGhhbmRsZXIoY29udGVudHNUZXh0dXJlTWFuYWdlcigpLCAmbGlzdCk7Cisg ICAgZm9yRWFjaENvbXBvc2l0b3JSZXNvdXJjZShoYW5kbGVyKTsKK30KKwogdm9pZCBDQ0xheWVy VHJlZUhvc3Q6OmFwcGVuZFZpc2libGVMYXllcihMYXllckNocm9taXVtKiBsYXllciwgTGF5ZXJM aXN0JiB1cGRhdGVMaXN0KQogewogICAgIC8vIEZvciBub3JtYWwgbGF5ZXJzLCB0aGVzZSBjb25k aXRpb25zIHNob3VsZCBoYXZlIGFscmVhZHkgYmVlbiBjaGVja2VkIHdoaWxlIGNyZWF0aW5nIHRo ZSByZW5kZXIgc3VyZmFjZSBsYXllciBsaXN0cy4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmgK aW5kZXggMTRiYjgxMi4uZWE4MDY0NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmgKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmgKQEAg LTE4OCw5ICsxODgsMTMgQEAgcHVibGljOgogICAgIHZvaWQgc2V0SGF2ZVdoZWVsRXZlbnRIYW5k bGVycyhib29sKTsKIAogICAgIHZvaWQgcHJlcGFyZVRvVXBkYXRlKCk7CisgICAgdm9pZCBwYWlu dENvbnRlbnRzKCk7CiAgICAgYm9vbCBuZWVkc0NvbXBvc2l0b3JSZXNvdXJjZXMoKTsKICAgICB2 b2lkIHByZXBhcmVDb21wb3NpdG9yUmVzb3VyY2VzKEdyYXBoaWNzQ29udGV4dDNEKiwgVGV4dHVy ZUFsbG9jYXRvciopOwotICAgIHZvaWQgcGFpbnRDb250ZW50cygpOworICAgIHZvaWQgdXBkYXRl Q29udGVudHMoKTsKKworICAgIHR5cGVkZWYgVmVjdG9yPE93blB0cjxNYW5hZ2VkVGV4dHVyZT4g PiBUZXh0dXJlTGlzdDsKKyAgICB2b2lkIHJlcGxhY2VUZXh0dXJlcyhUZXh0dXJlTGlzdCYpOwog CiAgICAgdm9pZCBmb3JFYWNoQ29tcG9zaXRvclJlc291cmNlKExheWVyVGV4dHVyZVVwZGF0ZXI6 OkhhbmRsZXImKTsKICAgICB2b2lkIGFwcGx5U2Nyb2xsQW5kU2NhbGUoY29uc3QgQ0NTY3JvbGxB bmRTY2FsZVNldCYpOwpAQCAtMjM4LDYgKzI0MiwxOCBAQCBwcml2YXRlOgogICAgICAgICBDQ1By b3h5KiBtX3Byb3h5OwogICAgIH07CiAKKyAgICBjbGFzcyBSZXBsYWNlVGV4dHVyZUhhbmRsZXIg OiBwdWJsaWMgTGF5ZXJUZXh0dXJlVXBkYXRlcjo6SGFuZGxlciB7CisgICAgcHVibGljOgorICAg ICAgICBSZXBsYWNlVGV4dHVyZUhhbmRsZXIoVGV4dHVyZU1hbmFnZXIqLCBUZXh0dXJlTGlzdCop OworICAgICAgICB2aXJ0dWFsIH5SZXBsYWNlVGV4dHVyZUhhbmRsZXIoKTsKKworICAgICAgICB2 aXJ0dWFsIHZvaWQgaGFuZGxlKExheWVyVGV4dHVyZVVwZGF0ZXI6OlRleHR1cmUqLCBjb25zdCBJ bnRSZWN0JiBzb3VyY2VSZWN0LCBjb25zdCBJbnRSZWN0JiBkZXN0UmVjdCk7CisKKyAgICBwcml2 YXRlOgorICAgICAgICBUZXh0dXJlTWFuYWdlciogbV90ZXh0dXJlTWFuYWdlcjsKKyAgICAgICAg VGV4dHVyZUxpc3QqIG1fbGlzdDsKKyAgICB9OworCiAgICAgdHlwZWRlZiBWZWN0b3I8UmVmUHRy PExheWVyQ2hyb21pdW0+ID4gTGF5ZXJMaXN0OwogCiAgICAgdm9pZCBhcHBlbmRWaXNpYmxlTGF5 ZXIoTGF5ZXJDaHJvbWl1bSosIExheWVyTGlzdCYpOwpAQCAtMjQ2LDYgKzI2Miw3IEBAIHByaXZh dGU6CiAKICAgICB2b2lkIHByZXBhcmVUb1VwZGF0ZShMYXllckNocm9taXVtKik7CiAgICAgdm9p ZCBwYWludENvbnRlbnRzKExheWVyQ2hyb21pdW0qKTsKKyAgICB2b2lkIHVwZGF0ZUNvbnRlbnRz KExheWVyQ2hyb21pdW0qKTsKICAgICB2b2lkIGNsZWFyUGVuZGluZ1VwZGF0ZSgpOwogCiAgICAg aW50IG1fY29tcG9zaXRvcklkZW50aWZpZXI7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1NpbmdsZVRocmVhZFByb3h5LmNwcCBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDU2luZ2xlVGhyZWFk UHJveHkuY3BwCmluZGV4IDkyNzMzNzAuLjVmNzk2OTEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDU2luZ2xlVGhyZWFkUHJveHkuY3Bw CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDU2lu Z2xlVGhyZWFkUHJveHkuY3BwCkBAIC0xNDgsMTEgKzE0OCwxMyBAQCB2b2lkIENDU2luZ2xlVGhy ZWFkUHJveHk6OmRvQ29tbWl0KCkKIHsKICAgICBBU1NFUlQoQ0NQcm94eTo6aXNNYWluVGhyZWFk KCkpOwogCisgICAgbV9sYXllclRyZWVIb3N0LT5wYWludENvbnRlbnRzKCk7CisKICAgICAvLyBQ cmVwYXJlIGNvbXBvc2l0b3IgcmVzb3VyY2VzCiAgICAgaWYgKG1fbGF5ZXJUcmVlSG9zdC0+bmVl ZHNDb21wb3NpdG9yUmVzb3VyY2VzKCkpCiAgICAgICAgIG1fbGF5ZXJUcmVlSG9zdC0+cHJlcGFy ZUNvbXBvc2l0b3JSZXNvdXJjZXMobV9sYXllclRyZWVIb3N0SW1wbC0+Y29udGV4dCgpLCBtX2xh eWVyVHJlZUhvc3RJbXBsLT5jb250ZW50c1RleHR1cmVBbGxvY2F0b3IoKSk7CiAKLSAgICBtX2xh eWVyVHJlZUhvc3QtPnBhaW50Q29udGVudHMoKTsKKyAgICBtX2xheWVyVHJlZUhvc3QtPnVwZGF0 ZUNvbnRlbnRzKCk7CiAKICAgICAvLyBDb21taXQgaW1tZWRpYXRlbHkKICAgICB7CmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVh ZFByb3h5LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2Nj L0NDVGhyZWFkUHJveHkuY3BwCmluZGV4IGVhNzI5MDcuLjZkMzcyMTYgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHku Y3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND VGhyZWFkUHJveHkuY3BwCkBAIC0yODAsNiArMjgwLDggQEAgdm9pZCBDQ1RocmVhZFByb3h5Ojpz dG9wKCkKIAogICAgIG1fbWFpblRocmVhZFByb3h5LT5zaHV0ZG93bigpOyAvLyBTdG9wIHJ1bm5p bmcgdGFza3MgcG9zdGVkIHRvIHVzLgogCisgICAgbV91c2VkVGV4dHVyZUxpc3QuY2xlYXIoKTsg Ly8gUmVsZWFzZSB0ZXh0dXJlcyBubyBsb25nZXIgdXNlZCBieSBpbXBsLgorCiAgICAgQVNTRVJU KCFtX2xheWVyVHJlZUhvc3RJbXBsKTsgLy8gdmVyaWZ5IHRoYXQgdGhlIGltcGwgZGVsZXRlZC4K ICAgICBtX2xheWVyVHJlZUhvc3QgPSAwOwogICAgIG1fc3RhcnRlZCA9IGZhbHNlOwpAQCAtMzg5 LDYgKzM5MSwxNCBAQCB2b2lkIENDVGhyZWFkUHJveHk6OmJlZ2luRnJhbWVBbmRDb21taXQoaW50 IHNlcXVlbmNlTnVtYmVyLCBkb3VibGUgZnJhbWVCZWdpblRpbQogCiAgICAgbV9sYXllclRyZWVI b3N0LT5wcmVwYXJlVG9VcGRhdGUoKTsKIAorICAgIC8vIFJlbGVhc2UgdGV4dHVyZXMgbm8gbG9u Z2VyIHVzZWQgYnkgaW1wbCB0aHJlYWQuCisgICAgbV91c2VkVGV4dHVyZUxpc3QuY2xlYXIoKTsK KyAgICAvLyBNb3ZlIHRleHR1cmVzIHVzZWQgYnkgaW1wbCB0aHJlYWQgdG8gbV91c2VkVGV4dHVy ZUxpc3QgYW5kIGNyZWF0ZSBuZXcKKyAgICAvLyB0ZXh0dXJlcyBmb3IgdXBkYXRlLgorICAgIG1f bGF5ZXJUcmVlSG9zdC0+cmVwbGFjZVRleHR1cmVzKG1fdXNlZFRleHR1cmVMaXN0KTsKKworICAg IG1fbGF5ZXJUcmVlSG9zdC0+cGFpbnRDb250ZW50cygpOworCiAgICAgaWYgKG1fbGF5ZXJUcmVl SG9zdC0+bmVlZHNDb21wb3NpdG9yUmVzb3VyY2VzKCkpIHsKICAgICAgICAgLy8gSW5pdGlhbGl6 ZSBjb21wb3NpdG9yIHJlc291cmNlcyByZXF1aXJlIGZvciBmcmFtZS4KICAgICAgICAgVFJBQ0Vf RVZFTlQoImFsbG9jYXRlIiwgdGhpcywgMCk7CkBAIC0zOTcsNyArNDA3LDcgQEAgdm9pZCBDQ1Ro cmVhZFByb3h5OjpiZWdpbkZyYW1lQW5kQ29tbWl0KGludCBzZXF1ZW5jZU51bWJlciwgZG91Ymxl IGZyYW1lQmVnaW5UaW0KICAgICAgICAgY29tcGxldGlvbi53YWl0KCk7CiAgICAgfQogCi0gICAg bV9sYXllclRyZWVIb3N0LT5wYWludENvbnRlbnRzKCk7CisgICAgbV9sYXllclRyZWVIb3N0LT51 cGRhdGVDb250ZW50cygpOwogCiAgICAgLy8gQmVmb3JlIGFwcGx5aW5nIHNjcm9sbHMgYW5kIGNh bGxpbmcgYW5pbWF0ZSwgd2Ugc2V0IG1fYW5pbWF0ZVJlcXVlc3RlZCB0byBmYWxzZS4KICAgICAv LyBJZiBpdCBpcyB0cnVlIG5vdywgaXQgbWVhbnMgc2V0TmVlZEFuaW1hdGUgd2FzIGNhbGxlZCBh Z2Fpbi4gQ2FsbCBzZXROZWVkc0NvbW1pdApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5oIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5oCmluZGV4IGYx MjQ0YzIuLmJjNjRjODYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmgKQEAgLTg2LDYgKzg2LDgg QEAgcHJpdmF0ZToKICAgICAgICAgSW50UmVjdCBtX2Rlc3RSZWN0OwogICAgIH07CiAKKyAgICB0 eXBlZGVmIFZlY3RvcjxPd25QdHI8TWFuYWdlZFRleHR1cmU+ID4gVGV4dHVyZUxpc3Q7CisKICAg ICAvLyBDYWxsZWQgb24gbWFpbiB0aHJlYWQKICAgICB2b2lkIGJlZ2luRnJhbWVBbmRDb21taXQo aW50IHNlcXVlbmNlTnVtYmVyLCBkb3VibGUgZnJhbWVCZWdpblRpbWUsIFBhc3NPd25QdHI8Q0NT Y3JvbGxBbmRTY2FsZVNldD4pOwogICAgIHZvaWQgZGlkQ29tbWl0QW5kRHJhd0ZyYW1lKCk7CkBA IC0xMTgsNiArMTIwLDcgQEAgcHJpdmF0ZToKICAgICBMYXllclJlbmRlcmVyQ2FwYWJpbGl0aWVz IG1fbGF5ZXJSZW5kZXJlckNhcGFiaWxpdGllc01haW5UaHJlYWRDb3B5OwogICAgIGJvb2wgbV9z dGFydGVkOwogICAgIGludCBtX2xhc3RFeGVjdXRlZEJlZ2luRnJhbWVBbmRDb21taXRTZXF1ZW5j ZU51bWJlcjsKKyAgICBUZXh0dXJlTGlzdCBtX3VzZWRUZXh0dXJlTGlzdDsKIAogICAgIC8vIFVz ZWQgb24gdGhlIENDVGhyZWFkIG9ubHkuCiAgICAgT3duUHRyPENDTGF5ZXJUcmVlSG9zdEltcGw+ IG1fbGF5ZXJUcmVlSG9zdEltcGw7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3Rlc3RzL0NDTGF5ZXJUcmVlSG9zdFRlc3QuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90 ZXN0cy9DQ0xheWVyVHJlZUhvc3RUZXN0LmNwcAppbmRleCA4YTZlZjcxLi41MTVkMTQ1IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0NDTGF5ZXJUcmVlSG9zdFRlc3Qu Y3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvQ0NMYXllclRyZWVIb3N0VGVz dC5jcHAKQEAgLTEzOCw5ICsxMzgsNDEgQEAgcHVibGljOgogICAgIHZpcnR1YWwgV2ViR0xJZCBj cmVhdGVTaGFkZXIoV0dDM0RlbnVtKSB7IHJldHVybiAxOyB9CiAgICAgdmlydHVhbCB2b2lkIGdl dFNoYWRlcml2KFdlYkdMSWQsIFdHQzNEZW51bSwgV0dDM0RpbnQqIHZhbHVlKSB7ICp2YWx1ZSA9 IDE7IH0KICAgICB2aXJ0dWFsIHZvaWQgZ2V0UHJvZ3JhbWl2KFdlYkdMSWQsIFdHQzNEZW51bSwg V0dDM0RpbnQqIHZhbHVlKSB7ICp2YWx1ZSA9IDE7IH0KKyAgICB2aXJ0dWFsIFdlYkdMSWQgY3Jl YXRlVGV4dHVyZSgpCisgICAgeworICAgICAgICBXZWJHTElkIHRleHR1cmUgPSBtX3RleHR1cmVz LnNpemUoKSArIDE7CisgICAgICAgIG1fdGV4dHVyZXMucHVzaF9iYWNrKHRleHR1cmUpOworICAg ICAgICByZXR1cm4gdGV4dHVyZTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZGVsZXRlVGV4 dHVyZShXZWJHTElkIHRleHR1cmUpCisgICAgeworICAgICAgICBmb3IgKHN0ZDo6dmVjdG9yPFdl YkdMSWQ+OjppdGVyYXRvciBpdCA9IG1fdGV4dHVyZXMuYmVnaW4oKTsgaXQgIT0gbV90ZXh0dXJl cy5lbmQoKTsgaXQrKykgeworICAgICAgICAgICAgaWYgKCppdCA9PSB0ZXh0dXJlKSB7CisgICAg ICAgICAgICAgICAgbV90ZXh0dXJlcy5lcmFzZShpdCk7CisgICAgICAgICAgICAgICAgYnJlYWs7 CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgYmlu ZFRleHR1cmUoV0dDM0RlbnVtIC8qIHRhcmdldCAqLywgV2ViR0xJZCB0ZXh0dXJlKQorICAgIHsK KyAgICAgICAgbV91c2VkVGV4dHVyZXMuaW5zZXJ0KHRleHR1cmUpOworICAgIH0KKworICAgIGlu dCBudW1UZXh0dXJlcygpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PGludD4obV90ZXh0dXJl cy5zaXplKCkpOyB9CisgICAgaW50IHRleHR1cmUoaW50IGkpIGNvbnN0IHsgcmV0dXJuIG1fdGV4 dHVyZXNbaV07IH0KKyAgICB2b2lkIHJlc2V0VGV4dHVyZXMoKSB7IG1fdGV4dHVyZXMuY2xlYXIo KTsgfQorCisgICAgaW50IG51bVVzZWRUZXh0dXJlcygpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19j YXN0PGludD4obV91c2VkVGV4dHVyZXMuc2l6ZSgpKTsgfQorICAgIGJvb2wgdXNlZFRleHR1cmUo aW50IHRleHR1cmUpIGNvbnN0IHsgcmV0dXJuIG1fdXNlZFRleHR1cmVzLmZpbmQodGV4dHVyZSkg IT0gbV91c2VkVGV4dHVyZXMuZW5kKCk7IH0KKyAgICB2b2lkIHJlc2V0VXNlZFRleHR1cmVzKCkg eyBtX3VzZWRUZXh0dXJlcy5jbGVhcigpOyB9CiAKIHByaXZhdGU6CiAgICAgQ29tcG9zaXRvck1v Y2tXZWJHcmFwaGljc0NvbnRleHQzRCgpIHsgfQorCisgICAgc3RkOjp2ZWN0b3I8V2ViR0xJZD4g bV90ZXh0dXJlczsKKyAgICBzdGQ6OnNldDxXZWJHTElkPiBtX3VzZWRUZXh0dXJlczsKIH07CiAK IC8vIEltcGxlbWVudGF0aW9uIG9mIENDTGF5ZXJUcmVlSG9zdCBjYWxsYmFjayBpbnRlcmZhY2Uu CkBAIC05NjYsMTQgKzk5OCwyMyBAQCBwdWJsaWM6CiAKICAgICAgICAgICAgIHZpcnR1YWwgTWFu YWdlZFRleHR1cmUqIHRleHR1cmUoKSB7IHJldHVybiBtX3RleHR1cmUuZ2V0KCk7IH0KIAorICAg ICAgICAgICAgdmlydHVhbCBQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJlPiByZXBsYWNlVGV4dHVy ZShUZXh0dXJlTWFuYWdlciogbWFuYWdlcikKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAg ICBPd25QdHI8TWFuYWdlZFRleHR1cmU+IG9sZCA9IG1fdGV4dHVyZS5yZWxlYXNlKCk7CisgICAg ICAgICAgICAgICAgbV90ZXh0dXJlID0gTWFuYWdlZFRleHR1cmU6OmNyZWF0ZShtYW5hZ2VyKTsK KyAgICAgICAgICAgICAgICByZXR1cm4gb2xkLnJlbGVhc2UoKTsKKyAgICAgICAgICAgIH0KKwog ICAgICAgICAgICAgdmlydHVhbCBib29sIG5lZWRQcmVwYXJlUmVjdCgpCiAgICAgICAgICAgICB7 CiAgICAgICAgICAgICAgICAgcmV0dXJuIG1fdGV4dHVyZVVwZGF0ZXItPmxheWVyKCktPm5lZWRQ cmVwYXJlUmVjdCgpOwogICAgICAgICAgICAgfQogCi0gICAgICAgICAgICB2aXJ0dWFsIHZvaWQg cHJlcGFyZVJlY3QoR3JhcGhpY3NDb250ZXh0M0QqLCBUZXh0dXJlQWxsb2NhdG9yKiwgY29uc3Qg SW50UmVjdCYgLyogc291cmNlUmVjdCAqLywgY29uc3QgSW50UmVjdCYgLyogZGVzdFJlY3QgKi8p CisgICAgICAgICAgICB2aXJ0dWFsIHZvaWQgcHJlcGFyZVJlY3QoR3JhcGhpY3NDb250ZXh0M0Qq IGNvbnRleHQsIFRleHR1cmVBbGxvY2F0b3IqIGFsbG9jYXRvciwgY29uc3QgSW50UmVjdCYgLyog c291cmNlUmVjdCAqLywgY29uc3QgSW50UmVjdCYgLyogZGVzdFJlY3QgKi8pCiAgICAgICAgICAg ICB7CiAgICAgICAgICAgICAgICAgbV90ZXh0dXJlVXBkYXRlci0+bGF5ZXIoKS0+cHJlcGFyZVJl Y3QoKTsKKyAgICAgICAgICAgICAgICBpZiAoIW1fdGV4dHVyZS0+dGV4dHVyZUlkKCkpCisgICAg ICAgICAgICAgICAgICAgIG1fdGV4dHVyZS0+YWxsb2NhdGVUZXh0dXJlKGNvbnRleHQsIGFsbG9j YXRvcik7CiAgICAgICAgICAgICB9CiAKICAgICAgICAgICAgIHZpcnR1YWwgdm9pZCBwYWludENv bnRlbnRzUmVjdChjb25zdCBJbnRSZWN0JiAvKiBzb3VyY2VSZWN0ICovKQpAQCAtOTgxLDkgKzEw MjIsMTEgQEAgcHVibGljOgogICAgICAgICAgICAgICAgIG1fdGV4dHVyZVVwZGF0ZXItPmxheWVy KCktPnBhaW50Q29udGVudHNSZWN0KCk7CiAgICAgICAgICAgICB9CiAKLSAgICAgICAgICAgIHZp cnR1YWwgdm9pZCB1cGRhdGVSZWN0KEdyYXBoaWNzQ29udGV4dDNEKiwgY29uc3QgSW50UmVjdCYg Lyogc291cmNlUmVjdCAqLywgY29uc3QgSW50UmVjdCYgLyogZGVzdFJlY3QgKi8pCisgICAgICAg ICAgICB2aXJ0dWFsIHZvaWQgdXBkYXRlUmVjdChHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwg Y29uc3QgSW50UmVjdCYgLyogc291cmNlUmVjdCAqLywgY29uc3QgSW50UmVjdCYgLyogZGVzdFJl Y3QgKi8pCiAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgbV90ZXh0dXJlVXBkYXRlci0+ bGF5ZXIoKS0+dXBkYXRlUmVjdCgpOworICAgICAgICAgICAgICAgIGlmIChtX3RleHR1cmUtPnRl eHR1cmVJZCgpKQorICAgICAgICAgICAgICAgICAgICBjb250ZXh0LT5iaW5kVGV4dHVyZShHcmFw aGljc0NvbnRleHQzRDo6VEVYVFVSRV8yRCwgbV90ZXh0dXJlLT50ZXh0dXJlSWQoKSk7CiAgICAg ICAgICAgICB9CiAKICAgICAgICAgcHJpdmF0ZToKQEAgLTExNjIsNCArMTIwNSwxMDQgQEAgVEVT VF9GKENDTGF5ZXJUcmVlSG9zdFRlc3ROb1ByZXBhcmVSZWN0LCBydW5NdWx0aVRocmVhZCkKICAg ICBydW5UZXN0KHRydWUpOwogfQogCisvLyBWZXJpZnkgYXRvbWljaXR5IG9mIGNvbW1pdHMgYW5k IHJldXNlIG9mIHRleHR1cmVzLgorY2xhc3MgQ0NMYXllclRyZWVIb3N0VGVzdEF0b21pY0NvbW1p dCA6IHB1YmxpYyBDQ0xheWVyVHJlZUhvc3RUZXN0IHsKK3B1YmxpYzoKKyAgICBDQ0xheWVyVHJl ZUhvc3RUZXN0QXRvbWljQ29tbWl0KCkKKyAgICAgICAgOiBtX3VwZGF0ZUNoZWNrTGF5ZXIoQ29u dGVudExheWVyQ2hyb21pdW1XaXRoVXBkYXRlVHJhY2tpbmc6OmNyZWF0ZSgmbV9kZWxlZ2F0ZSwg dHJ1ZSkpCisgICAgICAgICwgbV9udW1Db21taXRzKDApCisgICAgeworICAgIH0KKworICAgIHZp cnR1YWwgdm9pZCBiZWdpblRlc3QoKQorICAgIHsKKyAgICAgICAgbV9sYXllclRyZWVIb3N0LT5z ZXRSb290TGF5ZXIobV91cGRhdGVDaGVja0xheWVyKTsKKyAgICAgICAgbV9sYXllclRyZWVIb3N0 LT5zZXRWaWV3cG9ydChJbnRTaXplKDEwLCAxMCkpOworCisgICAgICAgIHBvc3RTZXROZWVkc0Nv bW1pdFRvTWFpblRocmVhZCgpOworICAgICAgICBwb3N0U2V0TmVlZHNSZWRyYXdUb01haW5UaHJl YWQoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgY29tbWl0Q29tcGxldGVPbkNDVGhyZWFk KENDTGF5ZXJUcmVlSG9zdEltcGwqIGltcGwpCisgICAgeworICAgICAgICBDb21wb3NpdG9yTW9j a1dlYkdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0ID0gc3RhdGljX2Nhc3Q8Q29tcG9zaXRvck1v Y2tXZWJHcmFwaGljc0NvbnRleHQzRCo+KEdyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZTo6ZXh0cmFj dFdlYkdyYXBoaWNzQ29udGV4dDNEKGltcGwtPmNvbnRleHQoKSkpOworCisgICAgICAgIHN3aXRj aCAoaW1wbC0+ZnJhbWVOdW1iZXIoKSkgeworICAgICAgICAgICAgY2FzZSAwOgorICAgICAgICAg ICAgICAgIC8vIE51bWJlciBvZiB0ZXh0dXJlcyBzaG91bGQgYmUgb25lLgorICAgICAgICAgICAg ICAgIEVYUEVDVF9FUSgxLCBjb250ZXh0LT5udW1UZXh0dXJlcygpKTsKKyAgICAgICAgICAgICAg ICAvLyBOdW1iZXIgb2YgdGV4dHVyZXMgdXNlZCBmb3IgY29tbWl0IHNob3VsZCBiZSBvbmUuCisg ICAgICAgICAgICAgICAgRVhQRUNUX0VRKDEsIGNvbnRleHQtPm51bVVzZWRUZXh0dXJlcygpKTsK KyAgICAgICAgICAgICAgICAvLyBWZXJpZnkgdXNlZCB0ZXh0dXJlIGlzIGNvcnJlY3QuCisgICAg ICAgICAgICAgICAgRVhQRUNUX1RSVUUoY29udGV4dC0+dXNlZFRleHR1cmUoY29udGV4dC0+dGV4 dHVyZSgwKSkpOworCisgICAgICAgICAgICAgICAgY29udGV4dC0+cmVzZXRVc2VkVGV4dHVyZXMo KTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIGNhc2UgMToKKyAgICAgICAg ICAgICAgICAvLyBOdW1iZXIgb2YgdGV4dHVyZXMgc2hvdWxkIGJlIHR3byBhcyB0aGUgZmlyc3Qg dGV4dHVyZQorICAgICAgICAgICAgICAgIC8vIGlzIHVzZWQgYnkgaW1wbCB0aHJlYWQgYW5kIGNh bm5vdCBieSB1c2VkIGZvciB1cGRhdGUuCisgICAgICAgICAgICAgICAgRVhQRUNUX0VRKDIsIGNv bnRleHQtPm51bVRleHR1cmVzKCkpOworICAgICAgICAgICAgICAgIC8vIE51bWJlciBvZiB0ZXh0 dXJlcyB1c2VkIGZvciBjb21taXQgc2hvdWxkIHN0aWxsIGJlIG9uZS4KKyAgICAgICAgICAgICAg ICBFWFBFQ1RfRVEoMSwgY29udGV4dC0+bnVtVXNlZFRleHR1cmVzKCkpOworICAgICAgICAgICAg ICAgIC8vIEZpcnN0IHRleHR1cmUgc2hvdWxkIG5vdCBoYXZlIGJlZW4gdXNlZC4KKyAgICAgICAg ICAgICAgICBFWFBFQ1RfRkFMU0UoY29udGV4dC0+dXNlZFRleHR1cmUoY29udGV4dC0+dGV4dHVy ZSgwKSkpOworICAgICAgICAgICAgICAgIC8vIE5ldyB0ZXh0dXJlIHNob3VsZCBoYXZlIGJlZW4g dXNlZC4KKyAgICAgICAgICAgICAgICBFWFBFQ1RfVFJVRShjb250ZXh0LT51c2VkVGV4dHVyZShj b250ZXh0LT50ZXh0dXJlKDEpKSk7CisKKyAgICAgICAgICAgICAgICBjb250ZXh0LT5yZXNldFVz ZWRUZXh0dXJlcygpOworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgY2FzZSAy OgorICAgICAgICAgICAgICAgIC8vIE51bWJlciBvZiB0ZXh0dXJlcyBzaG91bGQgbm90IGhhdmUg aW5jcmVhc2VkLiBPbGQgdGV4dHVyZQorICAgICAgICAgICAgICAgIC8vIHNob3VsZCBoYXZlIGJl ZW4gcmV1c2VkLgorICAgICAgICAgICAgICAgIEVYUEVDVF9FUSgyLCBjb250ZXh0LT5udW1UZXh0 dXJlcygpKTsKKyAgICAgICAgICAgICAgICAvLyBOdW1iZXIgb2YgdGV4dHVyZXMgdXNlZCBmb3Ig Y29tbWl0IHNob3VsZCBzdGlsbCBiZSBvbmUuCisgICAgICAgICAgICAgICAgRVhQRUNUX0VRKDEs IGNvbnRleHQtPm51bVVzZWRUZXh0dXJlcygpKTsKKyAgICAgICAgICAgICAgICAvLyBGaXJzdCB0 ZXh0dXJlIHNob3VsZCBoYXZlIGJlZW4gdXNlZCBmb3IgY29tbWl0LgorICAgICAgICAgICAgICAg IEVYUEVDVF9UUlVFKGNvbnRleHQtPnVzZWRUZXh0dXJlKGNvbnRleHQtPnRleHR1cmUoMCkpKTsK KyAgICAgICAgICAgICAgICAvLyBTZWNvbmQgdGV4dHVyZSBzaG91bGQgbm90IGhhdmUgYmVlbiB1 c2VkIGZvciBjb21taXQuCisgICAgICAgICAgICAgICAgRVhQRUNUX0ZBTFNFKGNvbnRleHQtPnVz ZWRUZXh0dXJlKGNvbnRleHQtPnRleHR1cmUoMSkpKTsKKyAgICAgICAgICAgICAgICBicmVhazsK KyAgICAgICAgICAgIGRlZmF1bHQ6CisgICAgICAgICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVE KCk7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9CisKKyAgICB2aXJ0 dWFsIHZvaWQgZHJhd0xheWVyc09uQ0NUaHJlYWQoQ0NMYXllclRyZWVIb3N0SW1wbCogaW1wbCkK KyAgICB7CisgICAgICAgIENvbXBvc2l0b3JNb2NrV2ViR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRl eHQgPSBzdGF0aWNfY2FzdDxDb21wb3NpdG9yTW9ja1dlYkdyYXBoaWNzQ29udGV4dDNEKj4oR3Jh cGhpY3NDb250ZXh0M0RQcml2YXRlOjpleHRyYWN0V2ViR3JhcGhpY3NDb250ZXh0M0QoaW1wbC0+ Y29udGV4dCgpKSk7CisKKyAgICAgICAgLy8gTnVtYmVyIG9mIHRleHR1cmVzIHVzZWQgZm9yIGRy YXcgc2hvdWxkIGFsd2F5cyBiZSBvbmUuCisgICAgICAgIEVYUEVDVF9FUSgxLCBjb250ZXh0LT5u dW1Vc2VkVGV4dHVyZXMoKSk7CisKKyAgICAgICAgaWYgKGltcGwtPmZyYW1lTnVtYmVyKCkgPCAz KSB7CisgICAgICAgICAgICBjb250ZXh0LT5yZXNldFVzZWRUZXh0dXJlcygpOworICAgICAgICAg ICAgcG9zdFNldE5lZWRzQW5pbWF0ZUFuZENvbW1pdFRvTWFpblRocmVhZCgpOworICAgICAgICAg ICAgcG9zdFNldE5lZWRzUmVkcmF3VG9NYWluVGhyZWFkKCk7CisgICAgICAgIH0gZWxzZSB7Cisg ICAgICAgICAgICBlbmRUZXN0KCk7CisgICAgICAgIH0KKyAgICB9CisKKyAgICB2aXJ0dWFsIHZv aWQgYW5pbWF0ZUFuZExheW91dChkb3VibGUgZnJhbWVCZWdpblRpbWUpCisgICAgeworICAgICAg ICBtX3VwZGF0ZUNoZWNrTGF5ZXItPnNldE5lZWRzRGlzcGxheSgpOworICAgIH0KKworICAgIHZp cnR1YWwgdm9pZCBhZnRlclRlc3QoKQorICAgIHsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgTW9j a0xheWVyRGVsZWdhdGUgbV9kZWxlZ2F0ZTsKKyAgICBSZWZQdHI8Q29udGVudExheWVyQ2hyb21p dW1XaXRoVXBkYXRlVHJhY2tpbmc+IG1fdXBkYXRlQ2hlY2tMYXllcjsKKyAgICBpbnQgbV9udW1D b21taXRzOworfTsKKworVEVTVF9GKENDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQsIHJ1 bk11bHRpVGhyZWFkKQoreworICAgIHJ1blRlc3QodHJ1ZSk7Cit9CisKKwogfSAvLyBuYW1lc3Bh Y2UK 118415 2011-12-08 10:24:49 -0800 2011-12-11 16:01:40 -0800 Patch atomic-commit.diff text/plain 51857 reveman ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0Nh bnZhczJETGF5ZXJDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hyb21pdW0uY3BwCmluZGV4IGUwNGYxOGQuLjdkYTU1 NTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0NhbnZhczJETGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNocm9taXVtLmNwcApAQCAtMTAyLDcgKzEw Miw4IEBAIHZvaWQgQ2FudmFzMkRMYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3Vy Y2VzKCkKIAogdm9pZCBDYW52YXMyRExheWVyQ2hyb21pdW06OmZvckVhY2hDb21wb3NpdG9yUmVz b3VyY2UoTGF5ZXJUZXh0dXJlVXBkYXRlcjo6SGFuZGxlciYgaGFuZGxlcikKIHsKLSAgICBoYW5k bGVyLmhhbmRsZShtX3VwZGF0ZXJUZXh0dXJlLmdldCgpLCBJbnRSZWN0KCksIEludFJlY3QoKSk7 CisgICAgSW50UmVjdCBub25FbXB0eVJlY3QoMCwgMCwgMSwgMSk7CisgICAgaGFuZGxlci5oYW5k bGUobV91cGRhdGVyVGV4dHVyZS5nZXQoKSwgbm9uRW1wdHlSZWN0LCBub25FbXB0eVJlY3QpOwog fQogCiB2b2lkIENhbnZhczJETGF5ZXJDaHJvbWl1bTo6Y29udGVudENoYW5nZWQoKQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzTGF5 ZXJUZXh0dXJlVXBkYXRlci5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9DYW52YXNMYXllclRleHR1cmVVcGRhdGVyLmNwcAppbmRleCBjNjFlYzMzLi4yODMx NjY5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9DYW52YXNMYXllclRleHR1cmVVcGRhdGVyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXNMYXllclRleHR1cmVVcGRhdGVyLmNwcApAQCAt NDQsNiArNDQsMTMgQEAgQ2FudmFzTGF5ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZTo6flRleHR1 cmUoKQogewogfQogCitQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJlPiBDYW52YXNMYXllclRleHR1 cmVVcGRhdGVyOjpUZXh0dXJlOjpyZXBsYWNlVGV4dHVyZShUZXh0dXJlTWFuYWdlciogbWFuYWdl cikKK3sKKyAgICBPd25QdHI8TWFuYWdlZFRleHR1cmU+IG9sZCA9IG1fdGV4dHVyZS5yZWxlYXNl KCk7CisgICAgbV90ZXh0dXJlID0gTWFuYWdlZFRleHR1cmU6OmNyZWF0ZShtYW5hZ2VyKTsKKyAg ICByZXR1cm4gb2xkLnJlbGVhc2UoKTsKK30KKwogYm9vbCBDYW52YXNMYXllclRleHR1cmVVcGRh dGVyOjpUZXh0dXJlOjpuZWVkUHJlcGFyZVJlY3QoKQogewogICAgIHJldHVybiAhbV90ZXh0dXJl LT50ZXh0dXJlSWQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL0NhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXIuaCBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0NhbnZhc0xheWVyVGV4dHVyZVVwZGF0ZXIuaApp bmRleCA4ODZkMTAxLi44ZTYwZjA3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9DYW52YXNMYXllclRleHR1cmVVcGRhdGVyLmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzTGF5ZXJUZXh0dXJl VXBkYXRlci5oCkBAIC00NSw2ICs0NSw3IEBAIHB1YmxpYzoKICAgICAgICAgdmlydHVhbCB+VGV4 dHVyZSgpOwogCiAgICAgICAgIHZpcnR1YWwgTWFuYWdlZFRleHR1cmUqIHRleHR1cmUoKSB7IHJl dHVybiBtX3RleHR1cmUuZ2V0KCk7IH0KKyAgICAgICAgdmlydHVhbCBQYXNzT3duUHRyPE1hbmFn ZWRUZXh0dXJlPiByZXBsYWNlVGV4dHVyZShUZXh0dXJlTWFuYWdlciopOwogCiAgICAgICAgIHZp cnR1YWwgYm9vbCBuZWVkUHJlcGFyZVJlY3QoKTsKICAgICAgICAgdmlydHVhbCB2b2lkIHByZXBh cmVSZWN0KEdyYXBoaWNzQ29udGV4dDNEKiwgVGV4dHVyZUFsbG9jYXRvciosIGNvbnN0IEludFJl Y3QmIC8qIHNvdXJjZVJlY3QgKi8sIGNvbnN0IEludFJlY3QmIC8qIGRlc3RSZWN0ICovKTsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0NvbnRl bnRMYXllckNocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0NvbnRlbnRMYXllckNocm9taXVtLmNwcAppbmRleCBkZDc0OTY3Li41ZmY2MmI4IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9Db250 ZW50TGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vQ29udGVudExheWVyQ2hyb21pdW0uY3BwCkBAIC0xMjMsNiArMTIzLDE5IEBA IHZvaWQgQ29udGVudExheWVyQ2hyb21pdW06OnBhaW50Q29udGVudHNJZkRpcnR5KCkKICAgICBw YWludENvbnRlbnRzKGxheWVyUmVjdCk7CiB9CiAKK3ZvaWQgQ29udGVudExheWVyQ2hyb21pdW06 OnByb3RlY3RUZXh0dXJlcygpCit7CisgICAgY29uc3QgSW50UmVjdCYgbGF5ZXJSZWN0ID0gdmlz aWJsZUxheWVyUmVjdCgpOworICAgIGlmIChsYXllclJlY3QuaXNFbXB0eSgpKQorICAgICAgICBy ZXR1cm47CisKKyAgICBpZiAoIWRyYXdzQ29udGVudCgpKQorICAgICAgICByZXR1cm47CisKKyAg ICBwcm90ZWN0VGlsZVRleHR1cmVzKGxheWVyUmVjdCk7Cit9CisKKwogYm9vbCBDb250ZW50TGF5 ZXJDaHJvbWl1bTo6ZHJhd3NDb250ZW50KCkgY29uc3QKIHsKICAgICByZXR1cm4gbV9kZWxlZ2F0 ZSAmJiBtX2RlbGVnYXRlLT5kcmF3c0NvbnRlbnQoKSAmJiBUaWxlZExheWVyQ2hyb21pdW06OmRy YXdzQ29udGVudCgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vQ29udGVudExheWVyQ2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL0NvbnRlbnRMYXllckNocm9taXVtLmgKaW5kZXggYzVlOWZj Yy4uZTEwNjc4MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vQ29udGVudExheWVyQ2hyb21pdW0uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9Db250ZW50TGF5ZXJDaHJvbWl1bS5oCkBAIC01MCw2ICs1 MCw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIH5Db250ZW50TGF5ZXJDaHJvbWl1bSgpOwogCiAg ICAgdmlydHVhbCB2b2lkIHByZXBhcmVUb1VwZGF0ZUlmRGlydHkoKTsKKyAgICB2aXJ0dWFsIHZv aWQgcHJvdGVjdFRleHR1cmVzKCk7CiAgICAgdmlydHVhbCB2b2lkIHBhaW50Q29udGVudHNJZkRp cnR5KCk7CiAKIHByb3RlY3RlZDoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0ltYWdlTGF5ZXJDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9JbWFnZUxheWVyQ2hyb21pdW0uY3BwCmluZGV4 IDFlMzNjNmQuLjJjZDI4ZGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0ltYWdlTGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vSW1hZ2VMYXllckNocm9taXVtLmNwcApAQCAt NTUsNiArNTUsMTIgQEAgcHVibGljOgogICAgICAgICB9CiAKICAgICAgICAgdmlydHVhbCBNYW5h Z2VkVGV4dHVyZSogdGV4dHVyZSgpIHsgcmV0dXJuIG1fdGV4dHVyZS5nZXQoKTsgfQorICAgICAg ICBQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJlPiByZXBsYWNlVGV4dHVyZShUZXh0dXJlTWFuYWdl ciogbWFuYWdlcikKKyAgICAgICAgeworICAgICAgICAgICAgT3duUHRyPE1hbmFnZWRUZXh0dXJl PiBvbGQgPSBtX3RleHR1cmUucmVsZWFzZSgpOworICAgICAgICAgICAgbV90ZXh0dXJlID0gTWFu YWdlZFRleHR1cmU6OmNyZWF0ZShtYW5hZ2VyKTsKKyAgICAgICAgICAgIHJldHVybiBvbGQucmVs ZWFzZSgpOworICAgICAgICB9CiAKICAgICAgICAgdmlydHVhbCBib29sIG5lZWRQcmVwYXJlUmVj dCgpCiAgICAgICAgIHsKQEAgLTE5NCw2ICsyMDAsMTEgQEAgdm9pZCBJbWFnZUxheWVyQ2hyb21p dW06OnByZXBhcmVUb1VwZGF0ZUlmRGlydHkoKQogICAgIHByZXBhcmVUb1VwZGF0ZSh2aXNpYmxl TGF5ZXJSZWN0KCkpOwogfQogCit2b2lkIEltYWdlTGF5ZXJDaHJvbWl1bTo6cHJvdGVjdFRleHR1 cmVzKCkKK3sKKyAgICBwcm90ZWN0VGlsZVRleHR1cmVzKHZpc2libGVMYXllclJlY3QoKSk7Cit9 CisKIExheWVyVGV4dHVyZVVwZGF0ZXIqIEltYWdlTGF5ZXJDaHJvbWl1bTo6dGV4dHVyZVVwZGF0 ZXIoKSBjb25zdAogewogICAgIHJldHVybiBtX3RleHR1cmVVcGRhdGVyLmdldCgpOwpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vSW1hZ2VMYXll ckNocm9taXVtLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9J bWFnZUxheWVyQ2hyb21pdW0uaAppbmRleCBmNmViYzhhLi5hMDJhNDU0IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9JbWFnZUxheWVyQ2hyb21p dW0uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9JbWFn ZUxheWVyQ2hyb21pdW0uaApAQCAtNTQsNiArNTQsNyBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFs IGJvb2wgZHJhd3NDb250ZW50KCkgY29uc3Q7CiAgICAgdmlydHVhbCB2b2lkIHByZXBhcmVUb1Vw ZGF0ZUlmRGlydHkoKTsKKyAgICB2aXJ0dWFsIHZvaWQgcHJvdGVjdFRleHR1cmVzKCk7CiAgICAg dmlydHVhbCBib29sIG5lZWRzQ29udGVudHNTY2FsZSgpIGNvbnN0OwogCiAgICAgdm9pZCBzZXRD b250ZW50cyhJbWFnZSogaW1hZ2UpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1bS5oCmluZGV4IGZkMDQzZjAuLjY5 NzQ5OTkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL0xheWVyQ2hyb21pdW0uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9MYXllckNocm9taXVtLmgKQEAgLTE2MSw3ICsxNjEsOSBAQCBwdWJsaWM6CiAg ICAgLy8gVGhlc2UgbWV0aG9kcyB0eXBpY2FsbHkgbmVlZCB0byBiZSBvdmVyd3JpdHRlbiBieSBk ZXJpdmVkIGNsYXNzZXMuCiAgICAgdmlydHVhbCBib29sIGRyYXdzQ29udGVudCgpIGNvbnN0IHsg cmV0dXJuIGZhbHNlOyB9CiAgICAgdmlydHVhbCB2b2lkIHByZXBhcmVUb1VwZGF0ZUlmRGlydHko KSB7IH0KKyAgICB2aXJ0dWFsIHZvaWQgcHJvdGVjdFRleHR1cmVzKCkgeyB9CiAgICAgdmlydHVh bCB2b2lkIHBhaW50Q29udGVudHNJZkRpcnR5KCkgeyB9CisgICAgdmlydHVhbCB2b2lkIGZpbmlz aFVwZGF0ZSgpIHsgfQogICAgIHZpcnR1YWwgdm9pZCBmb3JFYWNoQ29tcG9zaXRvclJlc291cmNl KExheWVyVGV4dHVyZVVwZGF0ZXI6OkhhbmRsZXImKSB7IH0KICAgICB2aXJ0dWFsIHZvaWQgc2V0 SXNNYXNrKGJvb2wpIHsgfQogICAgIHZpcnR1YWwgdm9pZCB1bnJlc2VydmVDb250ZW50c1RleHR1 cmUoKSB7IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL0xheWVyVGV4dHVyZVVwZGF0ZXIuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0xheWVyVGV4dHVyZVVwZGF0ZXIuaAppbmRleCAyMjZiYzIxLi5iYzBh ZmZiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9MYXllclRleHR1cmVVcGRhdGVyLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vTGF5ZXJUZXh0dXJlVXBkYXRlci5oCkBAIC0zMCw2ICszMCw3IEBACiAj aWYgVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQogCiAjaW5jbHVkZSAiR3JhcGhpY3NUeXBl czNELmgiCisjaW5jbHVkZSAiTWFuYWdlZFRleHR1cmUuaCIKICNpbmNsdWRlIDx3dGYvUmVmQ291 bnRlZC5oPgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CkBAIC0zNyw5ICszOCw2IEBAIG5hbWVzcGFj ZSBXZWJDb3JlIHsKIGNsYXNzIEdyYXBoaWNzQ29udGV4dDNEOwogY2xhc3MgSW50UmVjdDsKIGNs YXNzIEludFNpemU7Ci1jbGFzcyBNYW5hZ2VkVGV4dHVyZTsKLWNsYXNzIFRleHR1cmVBbGxvY2F0 b3I7Ci1jbGFzcyBUZXh0dXJlTWFuYWdlcjsKIAogY2xhc3MgTGF5ZXJUZXh0dXJlVXBkYXRlciA6 IHB1YmxpYyBSZWZDb3VudGVkPExheWVyVGV4dHVyZVVwZGF0ZXI+IHsKIHB1YmxpYzoKQEAgLTQ5 LDYgKzQ3LDcgQEAgcHVibGljOgogICAgICAgICB2aXJ0dWFsIH5UZXh0dXJlKCkgeyB9CiAKICAg ICAgICAgdmlydHVhbCBNYW5hZ2VkVGV4dHVyZSogdGV4dHVyZSgpIHsgcmV0dXJuIDA7IH0KKyAg ICAgICAgdmlydHVhbCBQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJlPiByZXBsYWNlVGV4dHVyZShU ZXh0dXJlTWFuYWdlciopIHsgcmV0dXJuIFBhc3NPd25QdHI8TWFuYWdlZFRleHR1cmU+KCk7IH0K IAogICAgICAgICAvLyBwcmVwYXJlUmVjdCgpIHdpbGwgb25seSBiZSBjYWxsZWQgaWYgdGhpcyBy ZXR1cm5zIHRydWUuCiAgICAgICAgIHZpcnR1YWwgYm9vbCBuZWVkUHJlcGFyZVJlY3QoKSB7IHJl dHVybiBmYWxzZTsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vTWFuYWdlZFRleHR1cmUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vTWFuYWdlZFRleHR1cmUuY3BwCmluZGV4IGVlMTgwMjUuLjk3Yjg2 NTAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L01hbmFnZWRUZXh0dXJlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5jcHAKQEAgLTY2LDYgKzY2LDggQEAgYm9vbCBNYW5h Z2VkVGV4dHVyZTo6cmVzZXJ2ZShjb25zdCBJbnRTaXplJiBzaXplLCB1bnNpZ25lZCBmb3JtYXQp CiAgICAgICAgIGlmIChyZXNlcnZlZCkgewogICAgICAgICAgICAgbV9zaXplID0gc2l6ZTsKICAg ICAgICAgICAgIG1fZm9ybWF0ID0gZm9ybWF0OworICAgICAgICAgICAgLy8gVGhpcyB3aWxsIHJl dHVybiAwIGlmIHRleHR1cmUgaGFzIG5vdCB5ZXQgYmVlbiBhbGxvY2F0ZWQuCisgICAgICAgICAg ICBtX3RleHR1cmVJZCA9IG1fdGV4dHVyZU1hbmFnZXItPnRleHR1cmVJZChtX3Rva2VuKTsKICAg ICAgICAgfQogICAgIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vVGV4dHVyZU1hbmFnZXIuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vVGV4dHVyZU1hbmFnZXIuY3BwCmluZGV4IGQ2NmIwNmEuLmMx NmYwYjEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL1RleHR1cmVNYW5hZ2VyLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9UZXh0dXJlTWFuYWdlci5jcHAKQEAgLTMwNiwxMCArMzA2LDQ3IEBAIGJv b2wgVGV4dHVyZU1hbmFnZXI6OnJlcXVlc3RUZXh0dXJlKFRleHR1cmVUb2tlbiB0b2tlbiwgSW50 U2l6ZSBzaXplLCB1bnNpZ25lZCBmCiAgICAgICAgIGlmICh0ZXh0dXJlSWQpCiAgICAgICAgICAg ICByZXR1cm4gdHJ1ZTsKICAgICB9CisKKyAgICAvLyBSZXVzZSBldmljdGVkIHRleHR1cmUgaWYg YXZhaWxhYmxlLgorICAgIGZvciAoc2l6ZV90IGkgPSAwOyBpIDwgbV9ldmljdGVkVGV4dHVyZXMu c2l6ZSgpOyArK2kpIHsKKyAgICAgICAgaWYgKCFtX2V2aWN0ZWRUZXh0dXJlc1tpXS50ZXh0dXJl SWQpCisgICAgICAgICAgICBjb250aW51ZTsKKworICAgICAgICBpZiAobV9ldmljdGVkVGV4dHVy ZXNbaV0uc2l6ZSA9PSBzaXplICYmIG1fZXZpY3RlZFRleHR1cmVzW2ldLmZvcm1hdCA9PSBmb3Jt YXQpIHsKKyAgICAgICAgICAgIGluZm8udGV4dHVyZUlkID0gbV9ldmljdGVkVGV4dHVyZXNbaV0u dGV4dHVyZUlkOworICAgICAgICAgICAgbV9ldmljdGVkVGV4dHVyZXNbaV0udGV4dHVyZUlkID0g MDsKKyNpZm5kZWYgTkRFQlVHCisgICAgICAgICAgICBpbmZvLmFsbG9jYXRvciA9IG1fZXZpY3Rl ZFRleHR1cmVzW2ldLmFsbG9jYXRvcjsKKyNlbmRpZgorICAgICAgICAgICAgYnJlYWs7CisgICAg ICAgIH0KKyAgICB9CisKICAgICBhZGRUZXh0dXJlKHRva2VuLCBpbmZvKTsKICAgICByZXR1cm4g dHJ1ZTsKIH0KIAordW5zaWduZWQgVGV4dHVyZU1hbmFnZXI6OnRleHR1cmVJZChUZXh0dXJlVG9r ZW4gdG9rZW4pCit7CisgICAgVGV4dHVyZU1hcDo6aXRlcmF0b3IgaXQgPSBtX3RleHR1cmVzLmZp bmQodG9rZW4pOworICAgIEFTU0VSVChpdCAhPSBtX3RleHR1cmVzLmVuZCgpKTsKKyAgICBUZXh0 dXJlSW5mbyogaW5mbyA9ICZpdC5nZXQoKS0+c2Vjb25kOworICAgIHJldHVybiBpbmZvLT50ZXh0 dXJlSWQ7Cit9CisKK1RleHR1cmVUb2tlbiBUZXh0dXJlTWFuYWdlcjo6dG9rZW5Gb3JUZXh0dXJl SWQodW5zaWduZWQgdGV4dHVyZUlkKQoreworICAgIFRleHR1cmVNYXA6Oml0ZXJhdG9yIGl0ID0g bV90ZXh0dXJlcy5iZWdpbigpOworICAgIHdoaWxlIChpdCAhPSBtX3RleHR1cmVzLmVuZCgpKSB7 CisgICAgICAgIGlmIChpdC0+c2Vjb25kLnRleHR1cmVJZCA9PSB0ZXh0dXJlSWQpCisgICAgICAg ICAgICByZXR1cm4gaXQtPmZpcnN0OworCisgICAgICAgICsraXQ7CisgICAgfQorCisgICAgcmV0 dXJuIDA7Cit9CisKIH0KIAogI2VuZGlmIC8vIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1Rl eHR1cmVNYW5hZ2VyLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9UZXh0dXJlTWFuYWdlci5oCmluZGV4IGM2YzIxYWQuLmVlNWY3MjEgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RleHR1cmVNYW5hZ2VyLmgK KysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGV4dHVyZU1h bmFnZXIuaApAQCAtNzYsNiArNzYsOCBAQCBwdWJsaWM6CiAgICAgdm9pZCB1bnByb3RlY3RUZXh0 dXJlKFRleHR1cmVUb2tlbik7CiAgICAgdm9pZCB1bnByb3RlY3RBbGxUZXh0dXJlcygpOwogICAg IGJvb2wgaXNQcm90ZWN0ZWQoVGV4dHVyZVRva2VuKTsKKyAgICB1bnNpZ25lZCB0ZXh0dXJlSWQo VGV4dHVyZVRva2VuKTsKKyAgICBUZXh0dXJlVG9rZW4gdG9rZW5Gb3JUZXh0dXJlSWQodW5zaWdu ZWQgdGV4dHVyZUlkKTsKIAogICAgIHVuc2lnbmVkIGFsbG9jYXRlVGV4dHVyZShUZXh0dXJlQWxs b2NhdG9yKiwgVGV4dHVyZVRva2VuKTsKICAgICB2b2lkIGRlbGV0ZUV2aWN0ZWRUZXh0dXJlcyhU ZXh0dXJlQWxsb2NhdG9yKik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcAppbmRleCAy YTY4MTU4Li4yODhkYmNlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTUy LDcgKzUyLDExIEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIGNsYXNzIFVwZGF0YWJsZVRpbGUgOiBw dWJsaWMgQ0NMYXllclRpbGluZ0RhdGE6OlRpbGUgewogICAgIFdURl9NQUtFX05PTkNPUFlBQkxF KFVwZGF0YWJsZVRpbGUpOwogcHVibGljOgotICAgIGV4cGxpY2l0IFVwZGF0YWJsZVRpbGUoUGFz c093blB0cjxMYXllclRleHR1cmVVcGRhdGVyOjpUZXh0dXJlPiB0ZXh0dXJlKSA6IG1fdGV4dHVy ZSh0ZXh0dXJlKSB7IH0KKyAgICBleHBsaWNpdCBVcGRhdGFibGVUaWxlKFBhc3NPd25QdHI8TGF5 ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZT4gdGV4dHVyZSkKKyAgICAgICAgOiBtX2ZpcnN0VXBk YXRlKHRydWUpCisgICAgICAgICwgbV90ZXh0dXJlKHRleHR1cmUpCisgICAgeworICAgIH0KIAog ICAgIExheWVyVGV4dHVyZVVwZGF0ZXI6OlRleHR1cmUqIHRleHR1cmUoKSB7IHJldHVybiBtX3Rl eHR1cmUuZ2V0KCk7IH0KICAgICBNYW5hZ2VkVGV4dHVyZSogbWFuYWdlZFRleHR1cmUoKSB7IHJl dHVybiBtX3RleHR1cmUtPnRleHR1cmUoKTsgfQpAQCAtNjQsNiArNjgsOCBAQCBwdWJsaWM6CiAg ICAgSW50UmVjdCBtX2RpcnR5TGF5ZXJSZWN0OwogICAgIC8vIENvbnRlbnQtc3BhY2UgcmVjdGFu Z2xlIHRoYXQgbmVlZHMgdG8gYmUgdXBkYXRlZC4KICAgICBJbnRSZWN0IG1fdXBkYXRlUmVjdDsK KyAgICAvLyBUcnVlIHVudGlsIGZpcnN0IHVwZGF0ZSBoYXMgaGFwcGVuZGVkLgorICAgIGJvb2wg bV9maXJzdFVwZGF0ZTsKIHByaXZhdGU6CiAgICAgT3duUHRyPExheWVyVGV4dHVyZVVwZGF0ZXI6 OlRleHR1cmU+IG1fdGV4dHVyZTsKIH07CkBAIC0xNzQsMzUgKzE4MCwyNCBAQCB2b2lkIFRpbGVk TGF5ZXJDaHJvbWl1bTo6Y3JlYXRlVGlsZXIoQ0NMYXllclRpbGluZ0RhdGE6OkJvcmRlclRleGVs T3B0aW9uIGJvcmRlcgogCiB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6Zm9yRWFjaENvbXBvc2l0 b3JSZXNvdXJjZShMYXllclRleHR1cmVVcGRhdGVyOjpIYW5kbGVyJiBoYW5kbGVyKQogewotICAg IC8vIElmIHRoaXMgYXNzZXJ0IGlzIGhpdCwgaXQgbWVhbnMgdGhhdCBwYWludENvbnRlbnRzSWZE aXJ0eSBoYXNuJ3QgYmVlbgotICAgIC8vIGNhbGxlZCBvbiB0aGlzIGxheWVyLiBBbnkgbGF5ZXIg dGhhdCBpcyB1cGRhdGVkIHNob3VsZCBiZSBwYWludGVkIGZpcnN0LgotICAgIEFTU0VSVChtX3Rp bGVyKTsKLQotICAgIC8vIFBhaW50aW5nIGNvdWxkIGNhdXNlIGNvbXBvc2l0aW5nIHRvIGdldCB0 dXJuZWQgb2ZmLCB3aGljaCBtYXkgY2F1c2UgdGhlIHRpbGVyIHRvIGJlY29tZSBpbnZhbGlkYXRl ZCBtaWQtdXBkYXRlLgotICAgIGlmIChtX3NraXBzRHJhdyB8fCBtX3JlcXVlc3RlZFVwZGF0ZVJl Y3QuaXNFbXB0eSgpIHx8ICFtX3RpbGVyIHx8ICFtX3RpbGVyLT5udW1UaWxlcygpIHx8IG1fcGFp bnRSZWN0LmlzRW1wdHkoKSkKKyAgICBpZiAoIW1fdGlsZXIpCiAgICAgICAgIHJldHVybjsKIAot ICAgIGludCBsZWZ0LCB0b3AsIHJpZ2h0LCBib3R0b207Ci0gICAgbV90aWxlci0+Y29udGVudFJl Y3RUb1RpbGVJbmRpY2VzKG1fcmVxdWVzdGVkVXBkYXRlUmVjdCwgbGVmdCwgdG9wLCByaWdodCwg Ym90dG9tKTsKLSAgICBmb3IgKGludCBqID0gdG9wOyBqIDw9IGJvdHRvbTsgKytqKSB7Ci0gICAg ICAgIGZvciAoaW50IGkgPSBsZWZ0OyBpIDw9IHJpZ2h0OyArK2kpIHsKLSAgICAgICAgICAgIFVw ZGF0YWJsZVRpbGUqIHRpbGUgPSB0aWxlQXQoaSwgaik7CisgICAgZm9yIChDQ0xheWVyVGlsaW5n RGF0YTo6VGlsZU1hcDo6Y29uc3RfaXRlcmF0b3IgaXRlciA9IG1fdGlsZXItPnRpbGVzKCkuYmVn aW4oKTsgaXRlciAhPSBtX3RpbGVyLT50aWxlcygpLmVuZCgpOyArK2l0ZXIpIHsKKyAgICAgICAg VXBkYXRhYmxlVGlsZSogdGlsZSA9IHN0YXRpY19jYXN0PFVwZGF0YWJsZVRpbGUqPihpdGVyLT5z ZWNvbmQuZ2V0KCkpOwogCi0gICAgICAgICAgICAvLyBSZXF1aXJlZCB0aWxlcyBhcmUgY3JlYXRl ZCBpbiBwcmVwYXJlVG9VcGRhdGUoKS4gQSB0aWxlIHNob3VsZAotICAgICAgICAgICAgLy8gbmV2 ZXIgYmUgcmVtb3ZlZCBiZXR3ZWVuIHRoZSBjYWxsIHRvIHByZXBhcmVUb1VwZGF0ZSgpIGFuZCB0 aGUKLSAgICAgICAgICAgIC8vIGNhbGwgdG8gdXBkYXRlQ29tcG9zaXRvclJlc291cmNlcygpLgot ICAgICAgICAgICAgaWYgKCF0aWxlKQotICAgICAgICAgICAgICAgIENSQVNIKCk7CisgICAgICAg IEludFJlY3Qgc291cmNlUmVjdDsKKyAgICAgICAgSW50UmVjdCBkZXN0UmVjdDsKIAotICAgICAg ICAgICAgSW50UmVjdCBzb3VyY2VSZWN0ID0gdGlsZS0+bV91cGRhdGVSZWN0OwotICAgICAgICAg ICAgaWYgKHRpbGUtPm1fdXBkYXRlUmVjdC5pc0VtcHR5KCkpCi0gICAgICAgICAgICAgICAgY29u dGludWU7CisgICAgICAgIC8vIFBhaW50aW5nIGNvdWxkIGNhdXNlIGNvbXBvc2l0aW5nIHRvIGdl dCB0dXJuZWQgb2ZmLCB3aGljaCBtYXkgY2F1c2UgdGhlIHRpbGVyIHRvIGJlY29tZSBpbnZhbGlk YXRlZCBtaWQtdXBkYXRlLgorICAgICAgICBpZiAoIW1fc2tpcHNEcmF3ICYmICFtX3JlcXVlc3Rl ZFVwZGF0ZVJlY3QuaXNFbXB0eSgpICYmICFtX3BhaW50UmVjdC5pc0VtcHR5KCkpCisgICAgICAg ICAgICBzb3VyY2VSZWN0ID0gdGlsZS0+bV91cGRhdGVSZWN0OwogCi0gICAgICAgICAgICBBU1NF UlQodGlsZS0+bWFuYWdlZFRleHR1cmUoKS0+aXNSZXNlcnZlZCgpKTsKKyAgICAgICAgaWYgKCFz b3VyY2VSZWN0LmlzRW1wdHkoKSkgewogICAgICAgICAgICAgY29uc3QgSW50UG9pbnQgYW5jaG9y ID0gbV90aWxlci0+dGlsZUNvbnRlbnRSZWN0KHRpbGUpLmxvY2F0aW9uKCk7CiAKICAgICAgICAg ICAgIC8vIENhbGN1bGF0ZSB0aWxlLXNwYWNlIHJlY3RhbmdsZSB0byB1cGxvYWQgaW50by4KLSAg ICAgICAgICAgIEludFJlY3QgZGVzdFJlY3QoSW50UG9pbnQoc291cmNlUmVjdC54KCkgLSBhbmNo b3IueCgpLCBzb3VyY2VSZWN0LnkoKSAtIGFuY2hvci55KCkpLCBzb3VyY2VSZWN0LnNpemUoKSk7 CisgICAgICAgICAgICBkZXN0UmVjdCA9IEludFJlY3QoSW50UG9pbnQoc291cmNlUmVjdC54KCkg LSBhbmNob3IueCgpLCBzb3VyY2VSZWN0LnkoKSAtIGFuY2hvci55KCkpLCBzb3VyY2VSZWN0LnNp emUoKSk7CiAgICAgICAgICAgICBpZiAoZGVzdFJlY3QueCgpIDwgMCkKICAgICAgICAgICAgICAg ICBDUkFTSCgpOwogICAgICAgICAgICAgaWYgKGRlc3RSZWN0LnkoKSA8IDApCkBAIC0yMTgsOSAr MjEzLDkgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OmZvckVhY2hDb21wb3NpdG9yUmVzb3Vy Y2UoTGF5ZXJUZXh0dXJlVXBkYXRlcjo6SGFuZGxlciYKICAgICAgICAgICAgICAgICBDUkFTSCgp OwogICAgICAgICAgICAgaWYgKHBhaW50T2Zmc2V0LnkoKSArIGRlc3RSZWN0LmhlaWdodCgpID4g bV9wYWludFJlY3QuaGVpZ2h0KCkpCiAgICAgICAgICAgICAgICAgQ1JBU0goKTsKLQotICAgICAg ICAgICAgaGFuZGxlci5oYW5kbGUodGlsZS0+dGV4dHVyZSgpLCBzb3VyY2VSZWN0LCBkZXN0UmVj dCk7CiAgICAgICAgIH0KKworICAgICAgICBoYW5kbGVyLmhhbmRsZSh0aWxlLT50ZXh0dXJlKCks IHNvdXJjZVJlY3QsIGRlc3RSZWN0KTsKICAgICB9CiB9CiAKQEAgLTMzMiwxMCArMzI3LDE0IEBA IHZvaWQgVGlsZWRMYXllckNocm9taXVtOjpwcm90ZWN0VGlsZVRleHR1cmVzKGNvbnN0IEludFJl Y3QmIGNvbnRlbnRSZWN0KQogICAgIGZvciAoaW50IGogPSB0b3A7IGogPD0gYm90dG9tOyArK2op IHsKICAgICAgICAgZm9yIChpbnQgaSA9IGxlZnQ7IGkgPD0gcmlnaHQ7ICsraSkgewogICAgICAg ICAgICAgVXBkYXRhYmxlVGlsZSogdGlsZSA9IHRpbGVBdChpLCBqKTsKLSAgICAgICAgICAgIGlm ICghdGlsZSB8fCAhdGlsZS0+bWFuYWdlZFRleHR1cmUoKS0+aXNWYWxpZChtX3RpbGVyLT50aWxl U2l6ZSgpLCBtX3RleHR1cmVGb3JtYXQpKQorICAgICAgICAgICAgaWYgKCF0aWxlKQorICAgICAg ICAgICAgICAgIGNvbnRpbnVlOworCisgICAgICAgICAgICBpZiAodGlsZS0+bV91cGRhdGVSZWN0 LmlzRW1wdHkoKSAmJiAhdGlsZS0+bWFuYWdlZFRleHR1cmUoKS0+aXNWYWxpZChtX3RpbGVyLT50 aWxlU2l6ZSgpLCBtX3RleHR1cmVGb3JtYXQpKQogICAgICAgICAgICAgICAgIGNvbnRpbnVlOwog Ci0gICAgICAgICAgICB0aWxlLT5tYW5hZ2VkVGV4dHVyZSgpLT5yZXNlcnZlKG1fdGlsZXItPnRp bGVTaXplKCksIG1fdGV4dHVyZUZvcm1hdCk7CisgICAgICAgICAgICBpZiAoIXRpbGUtPm1hbmFn ZWRUZXh0dXJlKCktPnJlc2VydmUobV90aWxlci0+dGlsZVNpemUoKSwgbV90ZXh0dXJlRm9ybWF0 KSkKKyAgICAgICAgICAgICAgICB0aWxlLT5tX3VwZGF0ZVJlY3QgPSBJbnRSZWN0KCk7CiAgICAg ICAgIH0KICAgICB9CiB9CkBAIC0zNzgsMTUgKzM3NywxNyBAQCB2b2lkIFRpbGVkTGF5ZXJDaHJv bWl1bTo6cHJlcGFyZVRvVXBkYXRlKGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0KQogICAgICAg ICAgICAgaWYgKCF0aWxlKQogICAgICAgICAgICAgICAgIHRpbGUgPSBjcmVhdGVUaWxlKGksIGop OwogCi0gICAgICAgICAgICBpZiAoIXRpbGUtPm1hbmFnZWRUZXh0dXJlKCktPmlzVmFsaWQobV90 aWxlci0+dGlsZVNpemUoKSwgbV90ZXh0dXJlRm9ybWF0KSkKKyAgICAgICAgICAgIGlmICh0aWxl LT5tX2ZpcnN0VXBkYXRlKSB7CiAgICAgICAgICAgICAgICAgdGlsZS0+bV9kaXJ0eUxheWVyUmVj dCA9IG1fdGlsZXItPnRpbGVMYXllclJlY3QodGlsZSk7Ci0KLSAgICAgICAgICAgIGlmICghdGls ZS0+bWFuYWdlZFRleHR1cmUoKS0+cmVzZXJ2ZShtX3RpbGVyLT50aWxlU2l6ZSgpLCBtX3RleHR1 cmVGb3JtYXQpKSB7Ci0gICAgICAgICAgICAgICAgbV9za2lwc0RyYXcgPSB0cnVlOwotICAgICAg ICAgICAgICAgIGNsZWFudXBSZXNvdXJjZXMoKTsKLSAgICAgICAgICAgICAgICByZXR1cm47Cisg ICAgICAgICAgICAgICAgdGlsZS0+bV9maXJzdFVwZGF0ZSA9IGZhbHNlOwogICAgICAgICAgICAg fQogCisgICAgICAgICAgICBpZiAodGlsZS0+bV9kaXJ0eUxheWVyUmVjdC5pc0VtcHR5KCkpCisg ICAgICAgICAgICAgICAgY29udGludWU7CisKKyAgICAgICAgICAgIGlmICghdGlsZS0+bWFuYWdl ZFRleHR1cmUoKS0+aXNWYWxpZChtX3RpbGVyLT50aWxlU2l6ZSgpLCBtX3RleHR1cmVGb3JtYXQp KQorICAgICAgICAgICAgICAgIHRpbGUtPm1fZGlydHlMYXllclJlY3QgPSBtX3RpbGVyLT50aWxl TGF5ZXJSZWN0KHRpbGUpOworCiAgICAgICAgICAgICBkaXJ0eUxheWVyUmVjdC51bml0ZSh0aWxl LT5tX2RpcnR5TGF5ZXJSZWN0KTsKICAgICAgICAgfQogICAgIH0KQEAgLTQzMCw3ICs0MzEsMTEg QEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnByZXBhcmVUb1VwZGF0ZShjb25zdCBJbnRSZWN0 JiBjb250ZW50UmVjdCkKIAogdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnBhaW50Q29udGVudHMo Y29uc3QgSW50UmVjdCYgY29udGVudFJlY3QpCiB7Ci0gICAgaWYgKG1fc2tpcHNEcmF3IHx8IG1f cmVxdWVzdGVkVXBkYXRlUmVjdC5pc0VtcHR5KCkgfHwgIW1fdGlsZXItPm51bVRpbGVzKCkgfHwg bV9wYWludFJlY3QuaXNFbXB0eSgpKQorICAgIC8vIElmIHRoaXMgYXNzZXJ0IGlzIGhpdCwgaXQg bWVhbnMgdGhhdCBwcmVwYXJlVG9VcGRhdGVJZkRpcnR5IGhhc24ndCBiZWVuCisgICAgLy8gY2Fs bGVkIG9uIHRoaXMgbGF5ZXIuIEFueSBsYXllciB0aGF0IGlzIHVwZGF0ZWQgc2hvdWxkIGJlIHBy ZXBhcmVkIGZpcnN0LgorICAgIEFTU0VSVChtX3RpbGVyKTsKKworICAgIGlmIChtX3NraXBzRHJh dyB8fCBtX3JlcXVlc3RlZFVwZGF0ZVJlY3QuaXNFbXB0eSgpIHx8ICFtX3RpbGVyIHx8ICFtX3Rp bGVyLT5udW1UaWxlcygpIHx8IG1fcGFpbnRSZWN0LmlzRW1wdHkoKSkKICAgICAgICAgcmV0dXJu OwogCiAgICAgLy8gQ2FsbGluZyBwYWludENvbnRlbnRzKCkgY2FsbHMgaW50byBXZWJLaXQgdG8g cGFpbnQsIHdoaWNoIG1heSBoYXZlIHRoZSBzaWRlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXllckNocm9taXVt LmNwcAppbmRleCA3YmVjN2MwLi40NTgwYTgxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1 bS5jcHAKQEAgLTQ3LDYgKzQ3LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUgewogVmlkZW9MYXllckNo cm9taXVtOjpVcGRhdGVyVGV4dHVyZTo6VXBkYXRlclRleHR1cmUoUGFzc093blB0cjxNYW5hZ2Vk VGV4dHVyZT4gdGV4dHVyZSkKICAgICA6IG1fdGV4dHVyZSh0ZXh0dXJlKQogICAgICwgbV9tYXBw ZWRCdWZmZXIoMCkKKyAgICAsIG1fZGF0YSgwKQogewogfQogCkBAIC01NSw2ICs1NiwxMyBAQCBW aWRlb0xheWVyQ2hyb21pdW06OlVwZGF0ZXJUZXh0dXJlOjp+VXBkYXRlclRleHR1cmUoKQogICAg IEFTU0VSVCghbV9tYXBwZWRCdWZmZXIpOwogfQogCitQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJl PiBWaWRlb0xheWVyQ2hyb21pdW06OlVwZGF0ZXJUZXh0dXJlOjpyZXBsYWNlVGV4dHVyZShUZXh0 dXJlTWFuYWdlciogbWFuYWdlcikKK3sKKyAgICBPd25QdHI8TWFuYWdlZFRleHR1cmU+IG9sZCA9 IG1fdGV4dHVyZS5yZWxlYXNlKCk7CisgICAgbV90ZXh0dXJlID0gTWFuYWdlZFRleHR1cmU6OmNy ZWF0ZShtYW5hZ2VyKTsKKyAgICByZXR1cm4gb2xkLnJlbGVhc2UoKTsKK30KKwogdm9pZCBWaWRl b0xheWVyQ2hyb21pdW06OlVwZGF0ZXJUZXh0dXJlOjpwcmVwYXJlUmVjdChHcmFwaGljc0NvbnRl eHQzRCogY29udGV4dCwgVGV4dHVyZUFsbG9jYXRvciogYWxsb2NhdG9yLCBjb25zdCBJbnRSZWN0 JiAvKiBzb3VyY2VSZWN0ICovLCBjb25zdCBJbnRSZWN0JiAvKiBkZXN0UmVjdCAqLykKIHsKICAg ICBJbnRTaXplIGRpbWVuc2lvbnMgPSBtX3RleHR1cmUtPnNpemUoKTsKQEAgLTcwLDE0ICs3OCwx NSBAQCB2b2lkIFZpZGVvTGF5ZXJDaHJvbWl1bTo6VXBkYXRlclRleHR1cmU6OnByZXBhcmVSZWN0 KEdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0LAogICAgIG1fdGV4dHVyZS0+YWxsb2NhdGVUZXh0 dXJlKGNvbnRleHQsIGFsbG9jYXRvcik7CiB9CiAKLXZvaWQgVmlkZW9MYXllckNocm9taXVtOjpV cGRhdGVyVGV4dHVyZTo6ZGF0YVJlY3QoY29uc3Qgdm9pZCogZGF0YSkKK3ZvaWQgVmlkZW9MYXll ckNocm9taXVtOjpVcGRhdGVyVGV4dHVyZTo6cGFpbnRDb250ZW50c1JlY3QoY29uc3QgSW50UmVj dCYgLyogc291cmNlUmVjdCAqLykKIHsKICAgICBzaXplX3QgYnVmZmVyU2l6ZSA9IFRleHR1cmVN YW5hZ2VyOjptZW1vcnlVc2VCeXRlcyhtX3RleHR1cmUtPnNpemUoKSwgbV90ZXh0dXJlLT5mb3Jt YXQoKSk7CiAKKyAgICBBU1NFUlQobV9kYXRhKTsKICAgICBpZiAobV9tYXBwZWRCdWZmZXIpCi0g ICAgICAgIG1lbWNweShtX21hcHBlZEJ1ZmZlciwgZGF0YSwgYnVmZmVyU2l6ZSk7CisgICAgICAg IG1lbWNweShtX21hcHBlZEJ1ZmZlciwgbV9kYXRhLCBidWZmZXJTaXplKTsKICAgICBlbHNlCi0g ICAgICAgIG1lbWNweShtX2J1ZmZlci5nZXQoKSwgZGF0YSwgYnVmZmVyU2l6ZSk7CisgICAgICAg IG1lbWNweShtX2J1ZmZlci5nZXQoKSwgbV9kYXRhLCBidWZmZXJTaXplKTsKIH0KIAogdm9pZCBW aWRlb0xheWVyQ2hyb21pdW06OlVwZGF0ZXJUZXh0dXJlOjp1cGRhdGVSZWN0KEdyYXBoaWNzQ29u dGV4dDNEKiBjb250ZXh0LCBjb25zdCBJbnRSZWN0JiAvKiBzb3VyY2VSZWN0ICovLCBjb25zdCBJ bnRSZWN0JiAvKiBkZXN0UmVjdCAqLykKQEAgLTEzMSwyMSArMTQwLDEzIEBAIHZvaWQgVmlkZW9M YXllckNocm9taXVtOjpjbGVhbnVwUmVzb3VyY2VzKCkKIAogdm9pZCBWaWRlb0xheWVyQ2hyb21p dW06OnByZXBhcmVUb1VwZGF0ZUlmRGlydHkoKQogewotICAgIG1fZnJhbWUgPSAwOworICAgIEFT U0VSVCghbV9mcmFtZSk7CiAKICAgICBpZiAoIW1fZGVsZWdhdGUgfHwgIW1fcHJvdmlkZXIgfHwg IWRyYXdzQ29udGVudCgpKQogICAgICAgICByZXR1cm47CiAKLSAgICBpZiAoIW1fbmVlZHNEaXNw bGF5ICYmIHRleHR1cmVzVmFsaWQoKSkgewotICAgICAgICBmb3IgKHVuc2lnbmVkIHBsYW5lID0g MDsgcGxhbmUgPCBtX3BsYW5lczsgcGxhbmUrKykgewotICAgICAgICAgICAgTWFuYWdlZFRleHR1 cmUqIHRleCA9IG1fdGV4dHVyZXNbcGxhbmVdLT50ZXh0dXJlKCk7Ci0gICAgICAgICAgICBpZiAo IXRleC0+cmVzZXJ2ZSh0ZXgtPnNpemUoKSwgdGV4LT5mb3JtYXQoKSkpIHsKLSAgICAgICAgICAg ICAgICBtX3NraXBzRHJhdyA9IHRydWU7Ci0gICAgICAgICAgICAgICAgYnJlYWs7Ci0gICAgICAg ICAgICB9Ci0gICAgICAgIH0KKyAgICBpZiAoIW1fbmVlZHNEaXNwbGF5KQogICAgICAgICByZXR1 cm47Ci0gICAgfQogCiAgICAgbV9wbGFuZXMgPSAwOwogICAgIG1fc2tpcHNEcmF3ID0gZmFsc2U7 CkBAIC0xNTgsNyArMTU5LDcgQEAgdm9pZCBWaWRlb0xheWVyQ2hyb21pdW06OnByZXBhcmVUb1Vw ZGF0ZUlmRGlydHkoKQogICAgIH0KIAogICAgIG1fZnJhbWVGb3JtYXQgPSBmcmFtZS0+Zm9ybWF0 KCk7Ci0gICAgR0MzRGVudW0gdGV4dHVyZUZvcm1hdCA9IGRldGVybWluZVRleHR1cmVGb3JtYXQo ZnJhbWUpOworICAgIEdDM0RlbnVtIHRleHR1cmVGb3JtYXQgPSBkZXRlcm1pbmVUZXh0dXJlRm9y bWF0KG1fZnJhbWVGb3JtYXQpOwogICAgIGlmICh0ZXh0dXJlRm9ybWF0ID09IEdyYXBoaWNzQ29u dGV4dDNEOjpJTlZBTElEX1ZBTFVFKSB7CiAgICAgICAgIC8vIEZJWE1FOiBJbXBsZW1lbnQgb3Ro ZXIgcGF0aHMuCiAgICAgICAgIG5vdEltcGxlbWVudGVkKCk7CkBAIC0xNzksMTIgKzE4MCwyNiBA QCB2b2lkIFZpZGVvTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRvVXBkYXRlSWZEaXJ0eSgpCiAgICAg aWYgKGZyYW1lLT5wbGFuZXMoKSA+IE1heFBsYW5lcykKICAgICAgICAgQ1JBU0goKTsKIAotICAg IC8vIFJlc2VydmUgdGV4dHVyZXMgZm9yIHBsYW5lcyBpZiB0aGV5IGFyZSBub3QgcmVzZXJ2ZWQg YWxyZWFkeS4KLSAgICBib29sIHRleHR1cmVzUmVzZXJ2ZWQgPSByZXNlcnZlVGV4dHVyZXMoZnJh bWUsIHRleHR1cmVGb3JtYXQpOwotICAgIGlmICghdGV4dHVyZXNSZXNlcnZlZCkgewotICAgICAg ICBtX3NraXBzRHJhdyA9IHRydWU7Ci0gICAgICAgIG1fcHJvdmlkZXItPnB1dEN1cnJlbnRGcmFt ZShmcmFtZSk7Ci0gICAgICAgIHJldHVybjsKKyAgICBpbnQgbWF4VGV4dHVyZVNpemUgPSBsYXll clRyZWVIb3N0KCktPmxheWVyUmVuZGVyZXJDYXBhYmlsaXRpZXMoKS5tYXhUZXh0dXJlU2l6ZTsK KworICAgIGZvciAodW5zaWduZWQgcGxhbmUgPSAwOyBwbGFuZSA8IGZyYW1lLT5wbGFuZXMoKTsg cGxhbmUrKykgeworICAgICAgICBJbnRTaXplIHJlcXVpcmVkVGV4dHVyZVNpemUgPSBmcmFtZS0+ cmVxdWlyZWRUZXh0dXJlU2l6ZShwbGFuZSk7CisKKyAgICAgICAgLy8gSWYgdGhlIHJlbmRlcmVy IGNhbm5vdCBoYW5kbGUgdGhpcyBsYXJnZSBvZiBhIHRleHR1cmUsIHNraXAgZHJhdy4KKyAgICAg ICAgLy8gRklYTUU6IFJlbW92ZSB0aGlzIHRlc3Qgd2hlbiB0aWxlZCBsYXllcnMgYXJlIGltcGxl bWVudGVkLgorICAgICAgICBpZiAocmVxdWlyZWRUZXh0dXJlU2l6ZS5pc1plcm8oKSB8fCByZXF1 aXJlZFRleHR1cmVTaXplLndpZHRoKCkgPiBtYXhUZXh0dXJlU2l6ZSB8fCByZXF1aXJlZFRleHR1 cmVTaXplLmhlaWdodCgpID4gbWF4VGV4dHVyZVNpemUpIHsKKyAgICAgICAgICAgIG1fc2tpcHNE cmF3ID0gdHJ1ZTsKKyAgICAgICAgICAgIG1fcHJvdmlkZXItPnB1dEN1cnJlbnRGcmFtZShmcmFt ZSk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKworICAgICAgICBpZiAobV90ZXh0 dXJlc1twbGFuZV0tPnRleHR1cmUoKS0+c2l6ZSgpICE9IHJlcXVpcmVkVGV4dHVyZVNpemUpIHsK KyAgICAgICAgICAgIEludFNpemUgdmlzaWJsZVNpemUgPSBjb21wdXRlVmlzaWJsZVNpemUoZnJh bWUsIHBsYW5lKTsKKyAgICAgICAgICAgIG1fdGV4dHVyZXNbcGxhbmVdLT5zZXRWaXNpYmxlU2l6 ZSh2aXNpYmxlU2l6ZSk7CisgICAgICAgIH0KKworICAgICAgICBtX3RleHR1cmVzW3BsYW5lXS0+ c2V0UmVxdWlyZWRUZXh0dXJlU2l6ZShyZXF1aXJlZFRleHR1cmVTaXplKTsKKyAgICAgICAgbV90 ZXh0dXJlc1twbGFuZV0tPnNldERhdGEoZnJhbWUtPmRhdGEocGxhbmUpKTsKICAgICB9CiAKICAg ICBtX2ZyYW1lID0gZnJhbWU7CkBAIC0xOTQsMTYgKzIwOSw0MCBAQCB2b2lkIFZpZGVvTGF5ZXJD aHJvbWl1bTo6cHJlcGFyZVRvVXBkYXRlSWZEaXJ0eSgpCiAgICAgbV9uZWVkc0Rpc3BsYXkgPSBm YWxzZTsKIH0KIAotdm9pZCBWaWRlb0xheWVyQ2hyb21pdW06OnBhaW50Q29udGVudHNJZkRpcnR5 KCkKK3ZvaWQgVmlkZW9MYXllckNocm9taXVtOjpwcm90ZWN0VGV4dHVyZXMoKQogewotICAgIGlm ICghbV9mcmFtZSkKKyAgICBHQzNEZW51bSB0ZXh0dXJlRm9ybWF0ID0gZGV0ZXJtaW5lVGV4dHVy ZUZvcm1hdChtX2ZyYW1lRm9ybWF0KTsKKworICAgIGlmICh0ZXh0dXJlRm9ybWF0ID09IEdyYXBo aWNzQ29udGV4dDNEOjpURVhUVVJFXzJEIHx8IHRleHR1cmVGb3JtYXQgPT0gR3JhcGhpY3NDb250 ZXh0M0Q6OklOVkFMSURfVkFMVUUpCiAgICAgICAgIHJldHVybjsKIAotICAgIC8vIENvcHkgcGxh bmVzIHRvIG1hcHBlZCBidWZmZXJzLgotICAgIGZvciAodW5zaWduZWQgcGxhbmUgPSAwOyBwbGFu ZSA8IG1fZnJhbWUtPnBsYW5lcygpOyBwbGFuZSsrKQotICAgICAgICBtX3RleHR1cmVzW3BsYW5l XS0+ZGF0YVJlY3QobV9mcmFtZS0+ZGF0YShwbGFuZSkpOworICAgIGlmIChtX3NraXBzRHJhdykK KyAgICAgICAgcmV0dXJuOworCisgICAgbV9za2lwc0RyYXcgPSB0cnVlOworCisgICAgZm9yICh1 bnNpZ25lZCBwbGFuZSA9IDA7IHBsYW5lIDwgbV9wbGFuZXM7IHBsYW5lKyspIHsKKyAgICAgICAg TWFuYWdlZFRleHR1cmUgKnRleHR1cmUgPSBtX3RleHR1cmVzW3BsYW5lXS0+dGV4dHVyZSgpOwor ICAgICAgICBJbnRTaXplIHNpemUgPSBtX3RleHR1cmVzW3BsYW5lXS0+cmVxdWlyZWRUZXh0dXJl U2l6ZSgpOworICAgICAgICBpZiAoIW1fZnJhbWUgJiYgIXRleHR1cmUtPmlzVmFsaWQoc2l6ZSwg dGV4dHVyZUZvcm1hdCkpCisgICAgICAgICAgICByZXR1cm47CiAKLSAgICBtX3Byb3ZpZGVyLT5w dXRDdXJyZW50RnJhbWUobV9mcmFtZSk7CisgICAgICAgIGlmICghdGV4dHVyZS0+cmVzZXJ2ZShz aXplLCB0ZXh0dXJlRm9ybWF0KSkKKyAgICAgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICBt X3NraXBzRHJhdyA9IGZhbHNlOworfQorCit2b2lkIFZpZGVvTGF5ZXJDaHJvbWl1bTo6ZmluaXNo VXBkYXRlKCkKK3sKKyAgICBpZiAobV9mcmFtZSkgeworICAgICAgICBmb3IgKHVuc2lnbmVkIHBs YW5lID0gMDsgcGxhbmUgPCBtX3BsYW5lczsgcGxhbmUrKykKKyAgICAgICAgICAgIG1fdGV4dHVy ZXNbcGxhbmVdLT5yZXNldERhdGEoKTsKKworICAgICAgICBtX3Byb3ZpZGVyLT5wdXRDdXJyZW50 RnJhbWUobV9mcmFtZSk7CisgICAgICAgIG1fZnJhbWUgPSAwOworICAgIH0KIH0KIAogdm9pZCBW aWRlb0xheWVyQ2hyb21pdW06OmZvckVhY2hDb21wb3NpdG9yUmVzb3VyY2UoTGF5ZXJUZXh0dXJl VXBkYXRlcjo6SGFuZGxlciYgaGFuZGxlcikKQEAgLTI0Nyw5ICsyODYsOSBAQCB2b2lkIFZpZGVv TGF5ZXJDaHJvbWl1bTo6c2V0TGF5ZXJUcmVlSG9zdChDQ0xheWVyVHJlZUhvc3QqIGhvc3QpCiAg ICAgTGF5ZXJDaHJvbWl1bTo6c2V0TGF5ZXJUcmVlSG9zdChob3N0KTsKIH0KIAotR0MzRGVudW0g VmlkZW9MYXllckNocm9taXVtOjpkZXRlcm1pbmVUZXh0dXJlRm9ybWF0KGNvbnN0IFZpZGVvRnJh bWVDaHJvbWl1bSogZnJhbWUpCitHQzNEZW51bSBWaWRlb0xheWVyQ2hyb21pdW06OmRldGVybWlu ZVRleHR1cmVGb3JtYXQoVmlkZW9GcmFtZUNocm9taXVtOjpGb3JtYXQgZnJhbWVGb3JtYXQpCiB7 Ci0gICAgc3dpdGNoIChmcmFtZS0+Zm9ybWF0KCkpIHsKKyAgICBzd2l0Y2ggKGZyYW1lRm9ybWF0 KSB7CiAgICAgY2FzZSBWaWRlb0ZyYW1lQ2hyb21pdW06OllWMTI6CiAgICAgY2FzZSBWaWRlb0Zy YW1lQ2hyb21pdW06OllWMTY6CiAgICAgICAgIHJldHVybiBHcmFwaGljc0NvbnRleHQzRDo6TFVN SU5BTkNFOwpAQCAtMjYzLDQ3ICszMDIsNiBAQCBHQzNEZW51bSBWaWRlb0xheWVyQ2hyb21pdW06 OmRldGVybWluZVRleHR1cmVGb3JtYXQoY29uc3QgVmlkZW9GcmFtZUNocm9taXVtKiBmcgogICAg IHJldHVybiBHcmFwaGljc0NvbnRleHQzRDo6SU5WQUxJRF9WQUxVRTsKIH0KIAotYm9vbCBWaWRl b0xheWVyQ2hyb21pdW06OnRleHR1cmVzVmFsaWQoKQotewotICAgIEFTU0VSVChsYXllclRyZWVI b3N0KCkpOwotCi0gICAgZm9yICh1bnNpZ25lZCBwbGFuZSA9IDA7IHBsYW5lIDwgbV9wbGFuZXM7 IHBsYW5lKyspIHsKLSAgICAgICAgTWFuYWdlZFRleHR1cmUqIHRleCA9IG1fdGV4dHVyZXNbcGxh bmVdLT50ZXh0dXJlKCk7Ci0gICAgICAgIGlmICghdGV4LT5pc1ZhbGlkKHRleC0+c2l6ZSgpLCB0 ZXgtPmZvcm1hdCgpKSkKLSAgICAgICAgICAgIHJldHVybiBmYWxzZTsKLSAgICB9Ci0gICAgcmV0 dXJuIHRydWU7Ci19Ci0KLWJvb2wgVmlkZW9MYXllckNocm9taXVtOjpyZXNlcnZlVGV4dHVyZXMo Y29uc3QgVmlkZW9GcmFtZUNocm9taXVtKiBmcmFtZSwgR0MzRGVudW0gdGV4dHVyZUZvcm1hdCkK LXsKLSAgICBBU1NFUlQobGF5ZXJUcmVlSG9zdCgpKTsKLSAgICBBU1NFUlQoZnJhbWUpOwotICAg IEFTU0VSVCh0ZXh0dXJlRm9ybWF0ICE9IEdyYXBoaWNzQ29udGV4dDNEOjpJTlZBTElEX1ZBTFVF KTsKLQotICAgIGludCBtYXhUZXh0dXJlU2l6ZSA9IGxheWVyVHJlZUhvc3QoKS0+bGF5ZXJSZW5k ZXJlckNhcGFiaWxpdGllcygpLm1heFRleHR1cmVTaXplOwotCi0gICAgZm9yICh1bnNpZ25lZCBw bGFuZSA9IDA7IHBsYW5lIDwgZnJhbWUtPnBsYW5lcygpOyBwbGFuZSsrKSB7Ci0gICAgICAgIElu dFNpemUgcmVxdWlyZWRUZXh0dXJlU2l6ZSA9IGZyYW1lLT5yZXF1aXJlZFRleHR1cmVTaXplKHBs YW5lKTsKLSAgICAgICAgQVNTRVJUKG1fdGV4dHVyZXNbcGxhbmVdKTsKLSAgICAgICAgQVNTRVJU KG1fdGV4dHVyZXNbcGxhbmVdLT50ZXh0dXJlKCkpOwotCi0gICAgICAgIC8vIElmIHRoZSByZW5k ZXJlciBjYW5ub3QgaGFuZGxlIHRoaXMgbGFyZ2Ugb2YgYSB0ZXh0dXJlLCByZXR1cm4gZmFsc2Uu Ci0gICAgICAgIC8vIEZJWE1FOiBSZW1vdmUgdGhpcyB0ZXN0IHdoZW4gdGlsZWQgbGF5ZXJzIGFy ZSBpbXBsZW1lbnRlZC4KLSAgICAgICAgaWYgKHJlcXVpcmVkVGV4dHVyZVNpemUuaXNaZXJvKCkg fHwgcmVxdWlyZWRUZXh0dXJlU2l6ZS53aWR0aCgpID4gbWF4VGV4dHVyZVNpemUgfHwgcmVxdWly ZWRUZXh0dXJlU2l6ZS5oZWlnaHQoKSA+IG1heFRleHR1cmVTaXplKQotICAgICAgICAgICAgcmV0 dXJuIGZhbHNlOwotCi0gICAgICAgIGlmIChtX3RleHR1cmVzW3BsYW5lXS0+dGV4dHVyZSgpLT5z aXplKCkgIT0gcmVxdWlyZWRUZXh0dXJlU2l6ZSkgewotICAgICAgICAgICAgSW50U2l6ZSB2aXNp YmxlU2l6ZSA9IGNvbXB1dGVWaXNpYmxlU2l6ZShmcmFtZSwgcGxhbmUpOwotICAgICAgICAgICAg bV90ZXh0dXJlc1twbGFuZV0tPnNldFZpc2libGVTaXplKHZpc2libGVTaXplKTsKLSAgICAgICAg fQotCi0gICAgICAgIG1fdGV4dHVyZXNbcGxhbmVdLT50ZXh0dXJlKCktPnJlc2VydmUocmVxdWly ZWRUZXh0dXJlU2l6ZSwgdGV4dHVyZUZvcm1hdCk7Ci0gICAgfQotCi0gICAgcmV0dXJuIHRydWU7 Ci19Ci0KIEludFNpemUgVmlkZW9MYXllckNocm9taXVtOjpjb21wdXRlVmlzaWJsZVNpemUoY29u c3QgVmlkZW9GcmFtZUNocm9taXVtKiBmcmFtZSwgdW5zaWduZWQgcGxhbmUpCiB7CiAgICAgaW50 IHZpc2libGVXaWR0aCA9IGZyYW1lLT53aWR0aChwbGFuZSk7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9WaWRlb0xheWVyQ2hyb21pdW0uaCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJv bWl1bS5oCmluZGV4IDM1MWY4ZjguLmEyMDBjOTQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1bS5oCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1 bS5oCkBAIC01MywyMiArNTMsMzEgQEAgcHVibGljOgogICAgICAgICB2aXJ0dWFsIH5VcGRhdGVy VGV4dHVyZSgpOwogCiAgICAgICAgIHZpcnR1YWwgTWFuYWdlZFRleHR1cmUqIHRleHR1cmUoKSB7 IHJldHVybiBtX3RleHR1cmUuZ2V0KCk7IH0KKyAgICAgICAgdmlydHVhbCBQYXNzT3duUHRyPE1h bmFnZWRUZXh0dXJlPiByZXBsYWNlVGV4dHVyZShUZXh0dXJlTWFuYWdlciopOwogCiAgICAgICAg IHZpcnR1YWwgYm9vbCBuZWVkUHJlcGFyZVJlY3QoKSB7IHJldHVybiB0cnVlOyB9CiAgICAgICAg IHZpcnR1YWwgdm9pZCBwcmVwYXJlUmVjdChHcmFwaGljc0NvbnRleHQzRCosIFRleHR1cmVBbGxv Y2F0b3IqLCBjb25zdCBJbnRSZWN0JiBzb3VyY2VSZWN0LCBjb25zdCBJbnRSZWN0JiBkZXN0UmVj dCk7Ci0gICAgICAgIHZvaWQgZGF0YVJlY3QoY29uc3Qgdm9pZCopOworICAgICAgICB2aXJ0dWFs IHZvaWQgcGFpbnRDb250ZW50c1JlY3QoY29uc3QgSW50UmVjdCYgc291cmNlUmVjdCk7CiAgICAg ICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVSZWN0KEdyYXBoaWNzQ29udGV4dDNEKiwgY29uc3QgSW50 UmVjdCYgc291cmNlUmVjdCwgY29uc3QgSW50UmVjdCYgZGVzdFJlY3QpOwogCiAgICAgICAgIHZv aWQgc2V0VmlzaWJsZVNpemUoSW50U2l6ZSYgc2l6ZSkgeyBtX3Zpc2libGVTaXplID0gc2l6ZTsg fQogICAgICAgICBJbnRTaXplJiB2aXNpYmxlU2l6ZSgpIHsgcmV0dXJuIG1fdmlzaWJsZVNpemU7 IH0KIAorICAgICAgICB2b2lkIHNldFJlcXVpcmVkVGV4dHVyZVNpemUoSW50U2l6ZSYgc2l6ZSkg eyBtX3JlcXVpcmVkVGV4dHVyZVNpemUgPSBzaXplOyB9CisgICAgICAgIEludFNpemUmIHJlcXVp cmVkVGV4dHVyZVNpemUoKSB7IHJldHVybiBtX3JlcXVpcmVkVGV4dHVyZVNpemU7IH0KKworICAg ICAgICB2b2lkIHNldERhdGEoY29uc3Qgdm9pZCogZGF0YSkgeyBtX2RhdGEgPSBkYXRhOyB9Cisg ICAgICAgIHZvaWQgcmVzZXREYXRhKCkgeyBtX2RhdGEgPSAwOyB9CisKICAgICBwcml2YXRlOgog ICAgICAgICBleHBsaWNpdCBVcGRhdGVyVGV4dHVyZShQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJl Pik7CiAKICAgICAgICAgT3duUHRyPE1hbmFnZWRUZXh0dXJlPiBtX3RleHR1cmU7CisgICAgICAg IEludFNpemUgbV9yZXF1aXJlZFRleHR1cmVTaXplOwogICAgICAgICBJbnRTaXplIG1fdmlzaWJs ZVNpemU7CiAgICAgICAgIHVpbnQ4X3QqIG1fbWFwcGVkQnVmZmVyOwogICAgICAgICBPd25BcnJh eVB0cjx1aW50OF90PiBtX2J1ZmZlcjsKKyAgICAgICAgY29uc3Qgdm9pZCogbV9kYXRhOwogICAg IH07CiAKICAgICBzdGF0aWMgUGFzc1JlZlB0cjxWaWRlb0xheWVyQ2hyb21pdW0+IGNyZWF0ZShD Q0xheWVyRGVsZWdhdGUqID0gMCwKQEAgLTc4LDcgKzg3LDggQEAgcHVibGljOgogICAgIHZpcnR1 YWwgUGFzc1JlZlB0cjxDQ0xheWVySW1wbD4gY3JlYXRlQ0NMYXllckltcGwoKTsKIAogICAgIHZp cnR1YWwgdm9pZCBwcmVwYXJlVG9VcGRhdGVJZkRpcnR5KCk7Ci0gICAgdmlydHVhbCB2b2lkIHBh aW50Q29udGVudHNJZkRpcnR5KCk7CisgICAgdmlydHVhbCB2b2lkIHByb3RlY3RUZXh0dXJlcygp OworICAgIHZpcnR1YWwgdm9pZCBmaW5pc2hVcGRhdGUoKTsKICAgICB2aXJ0dWFsIHZvaWQgZm9y RWFjaENvbXBvc2l0b3JSZXNvdXJjZShMYXllclRleHR1cmVVcGRhdGVyOjpIYW5kbGVyJik7CiAg ICAgdmlydHVhbCBib29sIGRyYXdzQ29udGVudCgpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KIApA QCAtOTQsMTIgKzEwNCw4IEBAIHByb3RlY3RlZDoKIHByaXZhdGU6CiAgICAgVmlkZW9MYXllckNo cm9taXVtKENDTGF5ZXJEZWxlZ2F0ZSosIFZpZGVvRnJhbWVQcm92aWRlciopOwogCi0gICAgc3Rh dGljIEdDM0RlbnVtIGRldGVybWluZVRleHR1cmVGb3JtYXQoY29uc3QgVmlkZW9GcmFtZUNocm9t aXVtKik7CisgICAgc3RhdGljIEdDM0RlbnVtIGRldGVybWluZVRleHR1cmVGb3JtYXQoVmlkZW9G cmFtZUNocm9taXVtOjpGb3JtYXQpOwogICAgIHN0YXRpYyBJbnRTaXplIGNvbXB1dGVWaXNpYmxl U2l6ZShjb25zdCBWaWRlb0ZyYW1lQ2hyb21pdW0qLCB1bnNpZ25lZCBwbGFuZSk7Ci0gICAgYm9v bCB0ZXh0dXJlc1ZhbGlkKCk7Ci0gICAgYm9vbCByZXNlcnZlVGV4dHVyZXMoY29uc3QgVmlkZW9G cmFtZUNocm9taXVtKiwgR0MzRGVudW0gdGV4dHVyZUZvcm1hdCk7Ci0KLSAgICB2b2lkIHJlc2V0 RnJhbWVQYXJhbWV0ZXJzKCk7CiAKICAgICBib29sIG1fc2tpcHNEcmF3OwogICAgIFZpZGVvRnJh bWVDaHJvbWl1bTo6Rm9ybWF0IG1fZnJhbWVGb3JtYXQ7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9XZWJHTExheWVyQ2hyb21pdW0uY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vV2ViR0xMYXllckNocm9t aXVtLmNwcAppbmRleCAzZjRiMDViLi5mMzlkM2RjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9XZWJHTExheWVyQ2hyb21pdW0uY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1dlYkdMTGF5ZXJDaHJv bWl1bS5jcHAKQEAgLTExMyw3ICsxMTMsOCBAQCB2b2lkIFdlYkdMTGF5ZXJDaHJvbWl1bTo6dXBk YXRlQ29tcG9zaXRvclJlc291cmNlcyhHcmFwaGljc0NvbnRleHQzRCogcmVuZGVyZXJDbwogCiB2 b2lkIFdlYkdMTGF5ZXJDaHJvbWl1bTo6Zm9yRWFjaENvbXBvc2l0b3JSZXNvdXJjZShMYXllclRl eHR1cmVVcGRhdGVyOjpIYW5kbGVyJiBoYW5kbGVyKQogewotICAgIGhhbmRsZXIuaGFuZGxlKG1f dXBkYXRlclRleHR1cmUuZ2V0KCksIEludFJlY3QoKSwgSW50UmVjdCgpKTsKKyAgICBJbnRSZWN0 IG5vbkVtcHR5UmVjdCgwLCAwLCAxLCAxKTsKKyAgICBoYW5kbGVyLmhhbmRsZShtX3VwZGF0ZXJU ZXh0dXJlLmdldCgpLCBub25FbXB0eVJlY3QsIG5vbkVtcHR5UmVjdCk7CiB9CiAKIGJvb2wgV2Vi R0xMYXllckNocm9taXVtOjpwYWludFJlbmRlcmVkUmVzdWx0c1RvQ2FudmFzKEltYWdlQnVmZmVy KiBpbWFnZUJ1ZmZlcikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwCmluZGV4IGM2NTg0 NTIuLjU5NWQwMmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcApAQCAtNTgsOCAr NTgsMTEgQEAgQ0NMYXllclRyZWVIb3N0OjpOZWVkUmVzb3VyY2VIYW5kbGVyOjp+TmVlZFJlc291 cmNlSGFuZGxlcigpCiB7CiB9CiAKLXZvaWQgQ0NMYXllclRyZWVIb3N0OjpOZWVkUmVzb3VyY2VI YW5kbGVyOjpoYW5kbGUoTGF5ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZSogdGV4dHVyZSwgY29u c3QgSW50UmVjdCYgLyogc291cmNlUmVjdCAqLywgY29uc3QgSW50UmVjdCYgLyogZGVzdFJlY3Qg Ki8pCit2b2lkIENDTGF5ZXJUcmVlSG9zdDo6TmVlZFJlc291cmNlSGFuZGxlcjo6aGFuZGxlKExh eWVyVGV4dHVyZVVwZGF0ZXI6OlRleHR1cmUqIHRleHR1cmUsIGNvbnN0IEludFJlY3QmIC8qIHNv dXJjZVJlY3QgKi8sIGNvbnN0IEludFJlY3QmIGRlc3RSZWN0KQogeworICAgIGlmIChkZXN0UmVj dC5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybjsKKwogICAgIGlmICh0ZXh0dXJlLT5uZWVkUHJl cGFyZVJlY3QoKSkKICAgICAgICAgbV9yZXNvdXJjZXMrKzsKIH0KQEAgLTc2LDYgKzc5LDkgQEAg Q0NMYXllclRyZWVIb3N0OjpQcmVwYXJlUmVzb3VyY2VIYW5kbGVyOjp+UHJlcGFyZVJlc291cmNl SGFuZGxlcigpCiAKIHZvaWQgQ0NMYXllclRyZWVIb3N0OjpQcmVwYXJlUmVzb3VyY2VIYW5kbGVy OjpoYW5kbGUoTGF5ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZSogdGV4dHVyZSwgY29uc3QgSW50 UmVjdCYgc291cmNlUmVjdCwgY29uc3QgSW50UmVjdCYgZGVzdFJlY3QpCiB7CisgICAgaWYgKGRl c3RSZWN0LmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCiAgICAgaWYgKHRleHR1cmUtPm5l ZWRQcmVwYXJlUmVjdCgpKQogICAgICAgICB0ZXh0dXJlLT5wcmVwYXJlUmVjdChtX2NvbnRleHQs IG1fYWxsb2NhdG9yLCBzb3VyY2VSZWN0LCBkZXN0UmVjdCk7CiB9CkBAIC05MSwxMCArOTcsMzQg QEAgQ0NMYXllclRyZWVIb3N0OjpQYWludEhhbmRsZXI6On5QYWludEhhbmRsZXIoKQogCiB2b2lk IENDTGF5ZXJUcmVlSG9zdDo6UGFpbnRIYW5kbGVyOjpoYW5kbGUoTGF5ZXJUZXh0dXJlVXBkYXRl cjo6VGV4dHVyZSogdGV4dHVyZSwgY29uc3QgSW50UmVjdCYgc291cmNlUmVjdCwgY29uc3QgSW50 UmVjdCYgZGVzdFJlY3QpCiB7CisgICAgaWYgKGRlc3RSZWN0LmlzRW1wdHkoKSkKKyAgICAgICAg cmV0dXJuOworCiAgICAgdGV4dHVyZS0+cGFpbnRDb250ZW50c1JlY3Qoc291cmNlUmVjdCk7CiAg ICAgbV9wcm94eS0+dXBkYXRlKHRleHR1cmUsIHNvdXJjZVJlY3QsIGRlc3RSZWN0KTsKIH0KIAor Q0NMYXllclRyZWVIb3N0OjpSZXBsYWNlVGV4dHVyZUhhbmRsZXI6OlJlcGxhY2VUZXh0dXJlSGFu ZGxlcihUZXh0dXJlTWFuYWdlciogbWFuYWdlciwgVGV4dHVyZUxpc3QqIGxpc3QpCisgICAgOiBt X3RleHR1cmVNYW5hZ2VyKG1hbmFnZXIpCisgICAgLCBtX2xpc3QobGlzdCkKK3sKK30KKworQ0NM YXllclRyZWVIb3N0OjpSZXBsYWNlVGV4dHVyZUhhbmRsZXI6On5SZXBsYWNlVGV4dHVyZUhhbmRs ZXIoKQoreworfQorCit2b2lkIENDTGF5ZXJUcmVlSG9zdDo6UmVwbGFjZVRleHR1cmVIYW5kbGVy OjpoYW5kbGUoTGF5ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZSogdGV4dHVyZSwgY29uc3QgSW50 UmVjdCYgLyogc291cmNlUmVjdCAqLywgY29uc3QgSW50UmVjdCYgZGVzdFJlY3QpCit7CisgICAg aWYgKGRlc3RSZWN0LmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKHRleHR1 cmUtPnRleHR1cmUoKSkgeworICAgICAgICBtX2xpc3QtPmFwcGVuZCh0ZXh0dXJlLT5yZXBsYWNl VGV4dHVyZShtX3RleHR1cmVNYW5hZ2VyKSk7CisgICAgICAgIEFTU0VSVChtX2xpc3QtPmxhc3Qo KS5nZXQoKSk7CisgICAgfQorfQorCiBQYXNzUmVmUHRyPENDTGF5ZXJUcmVlSG9zdD4gQ0NMYXll clRyZWVIb3N0OjpjcmVhdGUoQ0NMYXllclRyZWVIb3N0Q2xpZW50KiBjbGllbnQsIGNvbnN0IEND U2V0dGluZ3MmIHNldHRpbmdzKQogewogICAgIFJlZlB0cjxDQ0xheWVyVHJlZUhvc3Q+IGxheWVy VHJlZUhvc3QgPSBhZG9wdFJlZihuZXcgQ0NMYXllclRyZWVIb3N0KGNsaWVudCwgc2V0dGluZ3Mp KTsKQEAgLTIwNiw3ICsyMzYsNiBAQCB2b2lkIENDTGF5ZXJUcmVlSG9zdDo6ZmluaXNoQ29tbWl0 T25JbXBsVGhyZWFkKENDTGF5ZXJUcmVlSG9zdEltcGwqIGhvc3RJbXBsKQogdm9pZCBDQ0xheWVy VHJlZUhvc3Q6OmNvbW1pdENvbXBsZXRlKCkKIHsKICAgICBjbGVhclBlbmRpbmdVcGRhdGUoKTsK LSAgICBtX2NvbnRlbnRzVGV4dHVyZU1hbmFnZXItPnVucHJvdGVjdEFsbFRleHR1cmVzKCk7CiB9 CiAKIFBhc3NSZWZQdHI8R3JhcGhpY3NDb250ZXh0M0Q+IENDTGF5ZXJUcmVlSG9zdDo6Y3JlYXRl TGF5ZXJUcmVlSG9zdENvbnRleHQzRCgpCkBAIC00MDUsNiArNDM0LDI3IEBAIHZvaWQgQ0NMYXll clRyZWVIb3N0OjpwcmVwYXJlVG9VcGRhdGUoTGF5ZXJDaHJvbWl1bSogcm9vdExheWVyKQogICAg IH0KIH0KIAordm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnByb3RlY3RUZXh0dXJlcygpCit7CisgICAg aWYgKCFyb290TGF5ZXIoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgaWYgKHZpZXdwb3J0U2l6 ZSgpLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCisgICAgcHJvdGVjdFRleHR1cmVzKHJv b3RMYXllcigpKTsKK30KKwordm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnByb3RlY3RUZXh0dXJlcyhM YXllckNocm9taXVtKiByb290TGF5ZXIpCit7CisgICAgVFJBQ0VfRVZFTlQoIkNDTGF5ZXJUcmVl SG9zdDo6cHJvdGVjdFRleHR1cmVzIiwgdGhpcywgMCk7CisKKyAgICBmb3IgKGludCBsYXllcklu ZGV4ID0gbV9sYXllclVwZGF0ZUxpc3Quc2l6ZSgpIC0gMTsgbGF5ZXJJbmRleCA+PSAwIDsgLS1s YXllckluZGV4KSB7CisgICAgICAgIExheWVyQ2hyb21pdW0qIGxheWVyID0gbV9sYXllclVwZGF0 ZUxpc3RbbGF5ZXJJbmRleF0uZ2V0KCk7CisgICAgICAgIGxheWVyLT5wcm90ZWN0VGV4dHVyZXMo KTsKKyAgICB9Cit9CisKIGJvb2wgQ0NMYXllclRyZWVIb3N0OjpuZWVkc0NvbXBvc2l0b3JSZXNv dXJjZXMoKQogewogICAgIE5lZWRSZXNvdXJjZUhhbmRsZXIgaGFuZGxlcjsKQEAgLTQxOSw3ICs0 NjksNyBAQCB2b2lkIENDTGF5ZXJUcmVlSG9zdDo6cHJlcGFyZUNvbXBvc2l0b3JSZXNvdXJjZXMo R3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIFRleAogICAgIGZvckVhY2hDb21wb3NpdG9yUmVz b3VyY2UoaGFuZGxlcik7CiB9CiAKLXZvaWQgQ0NMYXllclRyZWVIb3N0OjpwYWludENvbnRlbnRz KCkKK3ZvaWQgQ0NMYXllclRyZWVIb3N0Ojp1cGRhdGVDb250ZW50cygpCiB7CiAgICAgaWYgKCFy b290TGF5ZXIoKSkKICAgICAgICAgcmV0dXJuOwpAQCAtNDI3LDIyICs0NzcsMjggQEAgdm9pZCBD Q0xheWVyVHJlZUhvc3Q6OnBhaW50Q29udGVudHMoKQogICAgIGlmICh2aWV3cG9ydFNpemUoKS5p c0VtcHR5KCkpCiAgICAgICAgIHJldHVybjsKIAotICAgIHBhaW50Q29udGVudHMocm9vdExheWVy KCkpOworICAgIHVwZGF0ZUNvbnRlbnRzKHJvb3RMYXllcigpKTsKIH0KIAotdm9pZCBDQ0xheWVy VHJlZUhvc3Q6OnBhaW50Q29udGVudHMoTGF5ZXJDaHJvbWl1bSogcm9vdExheWVyKQordm9pZCBD Q0xheWVyVHJlZUhvc3Q6OnVwZGF0ZUNvbnRlbnRzKExheWVyQ2hyb21pdW0qIHJvb3RMYXllcikK IHsKLSAgICBUUkFDRV9FVkVOVCgiQ0NMYXllclRyZWVIb3N0OjpwYWludENvbnRlbnRzIiwgdGhp cywgMCk7CisgICAgVFJBQ0VfRVZFTlQoIkNDTGF5ZXJUcmVlSG9zdDo6dXBkYXRlQ29udGVudHMi LCB0aGlzLCAwKTsKIAogICAgIGZvciAoaW50IGxheWVySW5kZXggPSBtX2xheWVyVXBkYXRlTGlz dC5zaXplKCkgLSAxOyBsYXllckluZGV4ID49IDAgOyAtLWxheWVySW5kZXgpIHsKKyAgICAgICAg UGFpbnRIYW5kbGVyIGhhbmRsZXIobV9wcm94eS5nZXQoKSk7CiAgICAgICAgIExheWVyQ2hyb21p dW0qIGxheWVyID0gbV9sYXllclVwZGF0ZUxpc3RbbGF5ZXJJbmRleF0uZ2V0KCk7CiAgICAgICAg IGxheWVyLT5wYWludENvbnRlbnRzSWZEaXJ0eSgpOwotCi0gICAgICAgIFBhaW50SGFuZGxlciBo YW5kbGVyKG1fcHJveHkuZ2V0KCkpOwogICAgICAgICBsYXllci0+Zm9yRWFjaENvbXBvc2l0b3JS ZXNvdXJjZShoYW5kbGVyKTsKKyAgICAgICAgbGF5ZXItPmZpbmlzaFVwZGF0ZSgpOwogICAgIH0K IH0KIAordm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnJlcGxhY2VUZXh0dXJlcyhUZXh0dXJlTGlzdCYg bGlzdCkKK3sKKyAgICBSZXBsYWNlVGV4dHVyZUhhbmRsZXIgaGFuZGxlcihjb250ZW50c1RleHR1 cmVNYW5hZ2VyKCksICZsaXN0KTsKKyAgICBmb3JFYWNoQ29tcG9zaXRvclJlc291cmNlKGhhbmRs ZXIpOworfQorCiB2b2lkIENDTGF5ZXJUcmVlSG9zdDo6YXBwZW5kVmlzaWJsZUxheWVyKExheWVy Q2hyb21pdW0qIGxheWVyLCBMYXllckxpc3QmIHVwZGF0ZUxpc3QpCiB7CiAgICAgLy8gRm9yIG5v cm1hbCBsYXllcnMsIHRoZXNlIGNvbmRpdGlvbnMgc2hvdWxkIGhhdmUgYWxyZWFkeSBiZWVuIGNo ZWNrZWQgd2hpbGUgY3JlYXRpbmcgdGhlIHJlbmRlciBzdXJmYWNlIGxheWVyIGxpc3RzLgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NM YXllclRyZWVIb3N0LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9jYy9DQ0xheWVyVHJlZUhvc3QuaAppbmRleCBjMzJlMjEwLi4yMTJkYTBhIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJl ZUhvc3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9j Yy9DQ0xheWVyVHJlZUhvc3QuaApAQCAtMTg4LDkgKzE4OCwxMyBAQCBwdWJsaWM6CiAgICAgdm9p ZCBzZXRIYXZlV2hlZWxFdmVudEhhbmRsZXJzKGJvb2wpOwogCiAgICAgdm9pZCBwcmVwYXJlVG9V cGRhdGUoKTsKKyAgICB2b2lkIHByb3RlY3RUZXh0dXJlcygpOwogICAgIGJvb2wgbmVlZHNDb21w b3NpdG9yUmVzb3VyY2VzKCk7CiAgICAgdm9pZCBwcmVwYXJlQ29tcG9zaXRvclJlc291cmNlcyhH cmFwaGljc0NvbnRleHQzRCosIFRleHR1cmVBbGxvY2F0b3IqKTsKLSAgICB2b2lkIHBhaW50Q29u dGVudHMoKTsKKyAgICB2b2lkIHVwZGF0ZUNvbnRlbnRzKCk7CisKKyAgICB0eXBlZGVmIFZlY3Rv cjxPd25QdHI8TWFuYWdlZFRleHR1cmU+ID4gVGV4dHVyZUxpc3Q7CisgICAgdm9pZCByZXBsYWNl VGV4dHVyZXMoVGV4dHVyZUxpc3QmKTsKIAogICAgIHZvaWQgZm9yRWFjaENvbXBvc2l0b3JSZXNv dXJjZShMYXllclRleHR1cmVVcGRhdGVyOjpIYW5kbGVyJik7CiAgICAgdm9pZCBhcHBseVNjcm9s bEFuZFNjYWxlKGNvbnN0IENDU2Nyb2xsQW5kU2NhbGVTZXQmKTsKQEAgLTIzOCw2ICsyNDIsMTgg QEAgcHJpdmF0ZToKICAgICAgICAgQ0NQcm94eSogbV9wcm94eTsKICAgICB9OwogCisgICAgY2xh c3MgUmVwbGFjZVRleHR1cmVIYW5kbGVyIDogcHVibGljIExheWVyVGV4dHVyZVVwZGF0ZXI6Okhh bmRsZXIgeworICAgIHB1YmxpYzoKKyAgICAgICAgUmVwbGFjZVRleHR1cmVIYW5kbGVyKFRleHR1 cmVNYW5hZ2VyKiwgVGV4dHVyZUxpc3QqKTsKKyAgICAgICAgdmlydHVhbCB+UmVwbGFjZVRleHR1 cmVIYW5kbGVyKCk7CisKKyAgICAgICAgdmlydHVhbCB2b2lkIGhhbmRsZShMYXllclRleHR1cmVV cGRhdGVyOjpUZXh0dXJlKiwgY29uc3QgSW50UmVjdCYgc291cmNlUmVjdCwgY29uc3QgSW50UmVj dCYgZGVzdFJlY3QpOworCisgICAgcHJpdmF0ZToKKyAgICAgICAgVGV4dHVyZU1hbmFnZXIqIG1f dGV4dHVyZU1hbmFnZXI7CisgICAgICAgIFRleHR1cmVMaXN0KiBtX2xpc3Q7CisgICAgfTsKKwog ICAgIHR5cGVkZWYgVmVjdG9yPFJlZlB0cjxMYXllckNocm9taXVtPiA+IExheWVyTGlzdDsKIAog ICAgIHZvaWQgYXBwZW5kVmlzaWJsZUxheWVyKExheWVyQ2hyb21pdW0qLCBMYXllckxpc3QmKTsK QEAgLTI0NSw3ICsyNjEsOCBAQCBwcml2YXRlOgogICAgIHZvaWQgYXBwZW5kVmlzaWJsZUxheWVy cyhjb25zdCBMYXllckxpc3QmIHJlbmRlclN1cmZhY2VVcGRhdGVMaXN0LCBMYXllckxpc3QmIHVw ZGF0ZUxpc3QpOwogCiAgICAgdm9pZCBwcmVwYXJlVG9VcGRhdGUoTGF5ZXJDaHJvbWl1bSopOwot ICAgIHZvaWQgcGFpbnRDb250ZW50cyhMYXllckNocm9taXVtKik7CisgICAgdm9pZCBwcm90ZWN0 VGV4dHVyZXMoTGF5ZXJDaHJvbWl1bSopOworICAgIHZvaWQgdXBkYXRlQ29udGVudHMoTGF5ZXJD aHJvbWl1bSopOwogICAgIHZvaWQgY2xlYXJQZW5kaW5nVXBkYXRlKCk7CiAKICAgICBpbnQgbV9j b21wb3NpdG9ySWRlbnRpZmllcjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDU2luZ2xlVGhyZWFkUHJveHkuY3BwIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NTaW5nbGVUaHJlYWRQcm94eS5j cHAKaW5kZXggOTI3MzM3MC4uYTRjYzdiYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NTaW5nbGVUaHJlYWRQcm94eS5jcHAKKysrIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NTaW5nbGVUaHJl YWRQcm94eS5jcHAKQEAgLTE1Miw3ICsxNTIsNyBAQCB2b2lkIENDU2luZ2xlVGhyZWFkUHJveHk6 OmRvQ29tbWl0KCkKICAgICBpZiAobV9sYXllclRyZWVIb3N0LT5uZWVkc0NvbXBvc2l0b3JSZXNv dXJjZXMoKSkKICAgICAgICAgbV9sYXllclRyZWVIb3N0LT5wcmVwYXJlQ29tcG9zaXRvclJlc291 cmNlcyhtX2xheWVyVHJlZUhvc3RJbXBsLT5jb250ZXh0KCksIG1fbGF5ZXJUcmVlSG9zdEltcGwt PmNvbnRlbnRzVGV4dHVyZUFsbG9jYXRvcigpKTsKIAotICAgIG1fbGF5ZXJUcmVlSG9zdC0+cGFp bnRDb250ZW50cygpOworICAgIG1fbGF5ZXJUcmVlSG9zdC0+dXBkYXRlQ29udGVudHMoKTsKIAog ICAgIC8vIENvbW1pdCBpbW1lZGlhdGVseQogICAgIHsKQEAgLTI4Niw2ICsyODYsMTAgQEAgdm9p ZCBDQ1NpbmdsZVRocmVhZFByb3h5Ojpjb21taXRJZk5lZWRlZCgpCiAKICAgICBtX2xheWVyVHJl ZUhvc3QtPnByZXBhcmVUb1VwZGF0ZSgpOwogCisgICAgLy8gUHJvdGVjdCBhbGwgdmlzaWJsZSB0 ZXh0dXJlcy4KKyAgICBtX2xheWVyVHJlZUhvc3QtPmNvbnRlbnRzVGV4dHVyZU1hbmFnZXIoKS0+ dW5wcm90ZWN0QWxsVGV4dHVyZXMoKTsKKyAgICBtX2xheWVyVHJlZUhvc3QtPnByb3RlY3RUZXh0 dXJlcygpOworCiAgICAgZG9Db21taXQoKTsKIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmNw cAppbmRleCBkODliZmZmLi5lNmVmYjNhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmNwcApA QCAtMzg3LDggKzM4NywyOSBAQCB2b2lkIENDVGhyZWFkUHJveHk6OmJlZ2luRnJhbWVBbmRDb21t aXQoaW50IHNlcXVlbmNlTnVtYmVyLCBkb3VibGUgZnJhbWVCZWdpblRpbQogICAgIC8vIHVwZGF0 ZUxheWVycy4KICAgICBtX2NvbW1pdFJlcXVlc3RlZCA9IGZhbHNlOwogCisgICAgLy8gVGhpcyB3 aWxsIGRldGVybWluZSB3aGF0IG5lZWRzIHRvIGJlIHVwZGF0ZWQuCiAgICAgbV9sYXllclRyZWVI b3N0LT5wcmVwYXJlVG9VcGRhdGUoKTsKIAorICAgIC8vIE1vdmUgdGV4dHVyZXMgdXNlZCBieSBp bXBsIHRocmVhZCB0byB1c2VkVGV4dHVyZUxpc3QgYW5kIGNyZWF0ZSBuZXcKKyAgICAvLyB0ZXh0 dXJlcyBmb3IgdXBkYXRlLgorICAgIFRleHR1cmVMaXN0IHVzZWRUZXh0dXJlTGlzdDsKKyAgICBt X2xheWVyVHJlZUhvc3QtPnJlcGxhY2VUZXh0dXJlcyh1c2VkVGV4dHVyZUxpc3QpOworCisgICAg Ly8gVW5wcm90ZWN0IGFsbCB0ZXh0dXJlcyBwcmlvciB0byBjYWxsaW5nIHByb3RlY3RUZXh0dXJl cygpLgorICAgIC8vIHByb3RlY3RUZXh0dXJlcygpIHdpbGwgcmVzZXJ2ZSBhbGwgdmlzaWJsZSB0 ZXh0dXJlcyBhbmQgbGVhdmUKKyAgICAvLyB0aGUgcmVzdCB1bnByb3RlY3RlZC4KKyAgICBtX2xh eWVyVHJlZUhvc3QtPmNvbnRlbnRzVGV4dHVyZU1hbmFnZXIoKS0+dW5wcm90ZWN0QWxsVGV4dHVy ZXMoKTsKKworICAgIC8vIFByb3RlY3QgdmFsaWQgdGV4dHVyZXMgaW4gdXNlZFRleHR1cmVMaXN0 LgorICAgIGZvciAoaW50IGluZGV4ID0gdXNlZFRleHR1cmVMaXN0LnNpemUoKSAtIDE7IGluZGV4 ID49IDAgOyAtLWluZGV4KSB7CisgICAgICAgIE1hbmFnZWRUZXh0dXJlKiB0ZXh0dXJlID0gdXNl ZFRleHR1cmVMaXN0W2luZGV4XS5nZXQoKTsKKyAgICAgICAgaWYgKHRleHR1cmUtPmlzVmFsaWQo dGV4dHVyZS0+c2l6ZSgpLCB0ZXh0dXJlLT5mb3JtYXQoKSkpCisgICAgICAgICAgICB0ZXh0dXJl LT5yZXNlcnZlKHRleHR1cmUtPnNpemUoKSwgdGV4dHVyZS0+Zm9ybWF0KCkpOworICAgIH0KKwor ICAgIC8vIFByb3RlY3QgYWxsIHZpc2libGUgdGV4dHVyZXMgaW5jbHVkaW5nIHRoZSBvbmVzIHVz ZWQgZm9yIHVwZGF0ZS4KKyAgICBtX2xheWVyVHJlZUhvc3QtPnByb3RlY3RUZXh0dXJlcygpOwor CiAgICAgaWYgKG1fbGF5ZXJUcmVlSG9zdC0+bmVlZHNDb21wb3NpdG9yUmVzb3VyY2VzKCkpIHsK ICAgICAgICAgLy8gSW5pdGlhbGl6ZSBjb21wb3NpdG9yIHJlc291cmNlcyByZXF1aXJlIGZvciBm cmFtZS4KICAgICAgICAgVFJBQ0VfRVZFTlQoImFsbG9jYXRlIiwgdGhpcywgMCk7CkBAIC0zOTcs NyArNDE4LDcgQEAgdm9pZCBDQ1RocmVhZFByb3h5OjpiZWdpbkZyYW1lQW5kQ29tbWl0KGludCBz ZXF1ZW5jZU51bWJlciwgZG91YmxlIGZyYW1lQmVnaW5UaW0KICAgICAgICAgY29tcGxldGlvbi53 YWl0KCk7CiAgICAgfQogCi0gICAgbV9sYXllclRyZWVIb3N0LT5wYWludENvbnRlbnRzKCk7Cisg ICAgbV9sYXllclRyZWVIb3N0LT51cGRhdGVDb250ZW50cygpOwogCiAgICAgLy8gQmVmb3JlIGFw cGx5aW5nIHNjcm9sbHMgYW5kIGNhbGxpbmcgYW5pbWF0ZSwgd2Ugc2V0IG1fYW5pbWF0ZVJlcXVl c3RlZCB0byBmYWxzZS4KICAgICAvLyBJZiBpdCBpcyB0cnVlIG5vdywgaXQgbWVhbnMgc2V0TmVl ZEFuaW1hdGUgd2FzIGNhbGxlZCBhZ2Fpbi4gQ2FsbCBzZXROZWVkc0NvbW1pdApAQCAtNDE2LDYg KzQzNyw5IEBAIHZvaWQgQ0NUaHJlYWRQcm94eTo6YmVnaW5GcmFtZUFuZENvbW1pdChpbnQgc2Vx dWVuY2VOdW1iZXIsIGRvdWJsZSBmcmFtZUJlZ2luVGltCiAgICAgICAgIGNvbXBsZXRpb24ud2Fp dCgpOwogICAgIH0KIAorICAgIC8vIEV4cGxpY2l0bHkgcmVsZWFzZSB0ZXh0dXJlcyBubyBsb25n ZXIgdXNlZCBieSBpbXBsIHRocmVhZC4KKyAgICB1c2VkVGV4dHVyZUxpc3QuY2xlYXIoKTsKKwog ICAgIG1fbGF5ZXJUcmVlSG9zdC0+Y29tbWl0Q29tcGxldGUoKTsKIAogICAgIEFTU0VSVChtX2xh c3RFeGVjdXRlZEJlZ2luRnJhbWVBbmRDb21taXRTZXF1ZW5jZU51bWJlciA9PSBzZXF1ZW5jZU51 bWJlcik7CkBAIC00NDQsNiArNDY4LDkgQEAgdm9pZCBDQ1RocmVhZFByb3h5Ojp1cGRhdGVUZXh0 dXJlT25JbXBsVGhyZWFkKFBhc3NPd25QdHI8VXBkYXRlRW50cnk+IGVudHJ5KQogICAgICAgICBy ZXR1cm47CiAKICAgICBtX3RleHR1cmVVcGRhdGVyT25JbXBsVGhyZWFkLmFwcGVuZChlbnRyeS0+ bV90ZXh0dXJlLCBlbnRyeS0+bV9zb3VyY2VSZWN0LCBlbnRyeS0+bV9kZXN0UmVjdCk7CisKKyAg ICBpZiAoIW1fbGF5ZXJUcmVlSG9zdEltcGwtPnNldHRpbmdzKCkuZGVsYXlUZXh0dXJlVXBkYXRl cykKKyAgICAgICAgbV9zY2hlZHVsZXJPbkltcGxUaHJlYWQtPnNldFJlc291cmNlVXBkYXRlc1Bl bmRpbmcoKTsKIH0KIAogdm9pZCBDQ1RocmVhZFByb3h5OjpiZWdpbkZyYW1lQ29tcGxldGVPbklt cGxUaHJlYWQoQ0NDb21wbGV0aW9uRXZlbnQqIGNvbXBsZXRpb24pCkBAIC00NTksNyArNDg2LDgg QEAgdm9pZCBDQ1RocmVhZFByb3h5OjpiZWdpbkZyYW1lQ29tcGxldGVPbkltcGxUaHJlYWQoQ0ND b21wbGV0aW9uRXZlbnQqIGNvbXBsZXRpb24KIAogICAgIG1fY29tbWl0Q29tcGxldGlvbkV2ZW50 T25JbXBsVGhyZWFkID0gY29tcGxldGlvbjsKIAotICAgIGlmIChoYXNNb3JlUmVzb3VyY2VVcGRh dGVzKCkpCisgICAgaWYgKG1fbGF5ZXJUcmVlSG9zdEltcGwtPnNldHRpbmdzKCkuZGVsYXlUZXh0 dXJlVXBkYXRlcworICAgICAgICAmJiBoYXNNb3JlUmVzb3VyY2VVcGRhdGVzKCkpCiAgICAgICAg IG1fc2NoZWR1bGVyT25JbXBsVGhyZWFkLT5zZXRSZXNvdXJjZVVwZGF0ZXNQZW5kaW5nKCk7CiAK ICAgICBtX3NjaGVkdWxlck9uSW1wbFRocmVhZC0+YmVnaW5GcmFtZUNvbXBsZXRlKCk7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1Ro cmVhZFByb3h5LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9j Yy9DQ1RocmVhZFByb3h5LmgKaW5kZXggZjEyNDRjMi4uMTM1ZDI3ZiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5o CisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhy ZWFkUHJveHkuaApAQCAtODYsNiArODYsOCBAQCBwcml2YXRlOgogICAgICAgICBJbnRSZWN0IG1f ZGVzdFJlY3Q7CiAgICAgfTsKIAorICAgIHR5cGVkZWYgVmVjdG9yPE93blB0cjxNYW5hZ2VkVGV4 dHVyZT4gPiBUZXh0dXJlTGlzdDsKKwogICAgIC8vIENhbGxlZCBvbiBtYWluIHRocmVhZAogICAg IHZvaWQgYmVnaW5GcmFtZUFuZENvbW1pdChpbnQgc2VxdWVuY2VOdW1iZXIsIGRvdWJsZSBmcmFt ZUJlZ2luVGltZSwgUGFzc093blB0cjxDQ1Njcm9sbEFuZFNjYWxlU2V0Pik7CiAgICAgdm9pZCBk aWRDb21taXRBbmREcmF3RnJhbWUoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vdGVzdHMvQ0NMYXllclRyZWVIb3N0VGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3Rlc3RzL0NDTGF5ZXJUcmVlSG9zdFRlc3QuY3BwCmluZGV4IDQzMTNmYTUuLjc4ODAyNzIgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvQ0NMYXllclRyZWVIb3N0VGVz dC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9DQ0xheWVyVHJlZUhvc3RU ZXN0LmNwcApAQCAtNjEsNiArNjEsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIGRyYXdM YXllcnNPbkNDVGhyZWFkKENDTGF5ZXJUcmVlSG9zdEltcGwqKSB7IH0KICAgICB2aXJ0dWFsIHZv aWQgYXBwbHlTY3JvbGxBbmRTY2FsZShjb25zdCBJbnRTaXplJiwgZmxvYXQpIHsgfQogICAgIHZp cnR1YWwgdm9pZCBhbmltYXRlQW5kTGF5b3V0KGRvdWJsZSBmcmFtZUJlZ2luVGltZSkgeyB9Cisg ICAgdmlydHVhbCB2b2lkIGRpZENvbW1pdEFuZERyYXdGcmFtZSgpIHsgfQogfTsKIAogLy8gQWRh cHRzIENDTGF5ZXJUcmVlSG9zdEltcGwgZm9yIHRlc3QuIFJ1bnMgcmVhbCBjb2RlLCB0aGVuIGlu dm9rZXMgdGVzdCBob29rcy4KQEAgLTEzOCw5ICsxMzksNDEgQEAgcHVibGljOgogICAgIHZpcnR1 YWwgV2ViR0xJZCBjcmVhdGVTaGFkZXIoV0dDM0RlbnVtKSB7IHJldHVybiAxOyB9CiAgICAgdmly dHVhbCB2b2lkIGdldFNoYWRlcml2KFdlYkdMSWQsIFdHQzNEZW51bSwgV0dDM0RpbnQqIHZhbHVl KSB7ICp2YWx1ZSA9IDE7IH0KICAgICB2aXJ0dWFsIHZvaWQgZ2V0UHJvZ3JhbWl2KFdlYkdMSWQs IFdHQzNEZW51bSwgV0dDM0RpbnQqIHZhbHVlKSB7ICp2YWx1ZSA9IDE7IH0KKyAgICB2aXJ0dWFs IFdlYkdMSWQgY3JlYXRlVGV4dHVyZSgpCisgICAgeworICAgICAgICBXZWJHTElkIHRleHR1cmUg PSBtX3RleHR1cmVzLnNpemUoKSArIDE7CisgICAgICAgIG1fdGV4dHVyZXMucHVzaF9iYWNrKHRl eHR1cmUpOworICAgICAgICByZXR1cm4gdGV4dHVyZTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZv aWQgZGVsZXRlVGV4dHVyZShXZWJHTElkIHRleHR1cmUpCisgICAgeworICAgICAgICBmb3IgKHN0 ZDo6dmVjdG9yPFdlYkdMSWQ+OjppdGVyYXRvciBpdCA9IG1fdGV4dHVyZXMuYmVnaW4oKTsgaXQg IT0gbV90ZXh0dXJlcy5lbmQoKTsgaXQrKykgeworICAgICAgICAgICAgaWYgKCppdCA9PSB0ZXh0 dXJlKSB7CisgICAgICAgICAgICAgICAgbV90ZXh0dXJlcy5lcmFzZShpdCk7CisgICAgICAgICAg ICAgICAgYnJlYWs7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAgICB9CisKKyAgICB2aXJ0 dWFsIHZvaWQgYmluZFRleHR1cmUoV0dDM0RlbnVtIC8qIHRhcmdldCAqLywgV2ViR0xJZCB0ZXh0 dXJlKQorICAgIHsKKyAgICAgICAgbV91c2VkVGV4dHVyZXMuaW5zZXJ0KHRleHR1cmUpOworICAg IH0KKworICAgIGludCBudW1UZXh0dXJlcygpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PGlu dD4obV90ZXh0dXJlcy5zaXplKCkpOyB9CisgICAgaW50IHRleHR1cmUoaW50IGkpIGNvbnN0IHsg cmV0dXJuIG1fdGV4dHVyZXNbaV07IH0KKyAgICB2b2lkIHJlc2V0VGV4dHVyZXMoKSB7IG1fdGV4 dHVyZXMuY2xlYXIoKTsgfQorCisgICAgaW50IG51bVVzZWRUZXh0dXJlcygpIGNvbnN0IHsgcmV0 dXJuIHN0YXRpY19jYXN0PGludD4obV91c2VkVGV4dHVyZXMuc2l6ZSgpKTsgfQorICAgIGJvb2wg dXNlZFRleHR1cmUoaW50IHRleHR1cmUpIGNvbnN0IHsgcmV0dXJuIG1fdXNlZFRleHR1cmVzLmZp bmQodGV4dHVyZSkgIT0gbV91c2VkVGV4dHVyZXMuZW5kKCk7IH0KKyAgICB2b2lkIHJlc2V0VXNl ZFRleHR1cmVzKCkgeyBtX3VzZWRUZXh0dXJlcy5jbGVhcigpOyB9CiAKIHByaXZhdGU6CiAgICAg Q29tcG9zaXRvck1vY2tXZWJHcmFwaGljc0NvbnRleHQzRCgpIHsgfQorCisgICAgc3RkOjp2ZWN0 b3I8V2ViR0xJZD4gbV90ZXh0dXJlczsKKyAgICBzdGQ6OnNldDxXZWJHTElkPiBtX3VzZWRUZXh0 dXJlczsKIH07CiAKIC8vIEltcGxlbWVudGF0aW9uIG9mIENDTGF5ZXJUcmVlSG9zdCBjYWxsYmFj ayBpbnRlcmZhY2UuCkBAIC0xNzEsNiArMjA0LDcgQEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2 b2lkIGRpZENvbW1pdEFuZERyYXdGcmFtZSgpCiAgICAgeworICAgICAgICBtX3Rlc3RIb29rcy0+ ZGlkQ29tbWl0QW5kRHJhd0ZyYW1lKCk7CiAgICAgfQogCiAgICAgdmlydHVhbCB2b2lkIGRpZENv bXBsZXRlU3dhcEJ1ZmZlcnMoKQpAQCAtOTY2LDE0ICsxMDAwLDIzIEBAIHB1YmxpYzoKIAogICAg ICAgICAgICAgdmlydHVhbCBNYW5hZ2VkVGV4dHVyZSogdGV4dHVyZSgpIHsgcmV0dXJuIG1fdGV4 dHVyZS5nZXQoKTsgfQogCisgICAgICAgICAgICB2aXJ0dWFsIFBhc3NPd25QdHI8TWFuYWdlZFRl eHR1cmU+IHJlcGxhY2VUZXh0dXJlKFRleHR1cmVNYW5hZ2VyKiBtYW5hZ2VyKQorICAgICAgICAg ICAgeworICAgICAgICAgICAgICAgIE93blB0cjxNYW5hZ2VkVGV4dHVyZT4gb2xkID0gbV90ZXh0 dXJlLnJlbGVhc2UoKTsKKyAgICAgICAgICAgICAgICBtX3RleHR1cmUgPSBNYW5hZ2VkVGV4dHVy ZTo6Y3JlYXRlKG1hbmFnZXIpOworICAgICAgICAgICAgICAgIHJldHVybiBvbGQucmVsZWFzZSgp OworICAgICAgICAgICAgfQorCiAgICAgICAgICAgICB2aXJ0dWFsIGJvb2wgbmVlZFByZXBhcmVS ZWN0KCkKICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICByZXR1cm4gbV90ZXh0dXJlVXBk YXRlci0+bGF5ZXIoKS0+bmVlZFByZXBhcmVSZWN0KCk7CiAgICAgICAgICAgICB9CiAKLSAgICAg ICAgICAgIHZpcnR1YWwgdm9pZCBwcmVwYXJlUmVjdChHcmFwaGljc0NvbnRleHQzRCosIFRleHR1 cmVBbGxvY2F0b3IqLCBjb25zdCBJbnRSZWN0JiAvKiBzb3VyY2VSZWN0ICovLCBjb25zdCBJbnRS ZWN0JiAvKiBkZXN0UmVjdCAqLykKKyAgICAgICAgICAgIHZpcnR1YWwgdm9pZCBwcmVwYXJlUmVj dChHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgVGV4dHVyZUFsbG9jYXRvciogYWxsb2NhdG9y LCBjb25zdCBJbnRSZWN0JiAvKiBzb3VyY2VSZWN0ICovLCBjb25zdCBJbnRSZWN0JiAvKiBkZXN0 UmVjdCAqLykKICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAgICBtX3RleHR1cmVVcGRhdGVy LT5sYXllcigpLT5wcmVwYXJlUmVjdCgpOworICAgICAgICAgICAgICAgIGlmICghbV90ZXh0dXJl LT50ZXh0dXJlSWQoKSkKKyAgICAgICAgICAgICAgICAgICAgbV90ZXh0dXJlLT5hbGxvY2F0ZVRl eHR1cmUoY29udGV4dCwgYWxsb2NhdG9yKTsKICAgICAgICAgICAgIH0KIAogICAgICAgICAgICAg dmlydHVhbCB2b2lkIHBhaW50Q29udGVudHNSZWN0KGNvbnN0IEludFJlY3QmIC8qIHNvdXJjZVJl Y3QgKi8pCkBAIC05ODEsOSArMTAyNCwxMSBAQCBwdWJsaWM6CiAgICAgICAgICAgICAgICAgbV90 ZXh0dXJlVXBkYXRlci0+bGF5ZXIoKS0+cGFpbnRDb250ZW50c1JlY3QoKTsKICAgICAgICAgICAg IH0KIAotICAgICAgICAgICAgdmlydHVhbCB2b2lkIHVwZGF0ZVJlY3QoR3JhcGhpY3NDb250ZXh0 M0QqLCBjb25zdCBJbnRSZWN0JiAvKiBzb3VyY2VSZWN0ICovLCBjb25zdCBJbnRSZWN0JiAvKiBk ZXN0UmVjdCAqLykKKyAgICAgICAgICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVSZWN0KEdyYXBoaWNz Q29udGV4dDNEKiBjb250ZXh0LCBjb25zdCBJbnRSZWN0JiAvKiBzb3VyY2VSZWN0ICovLCBjb25z dCBJbnRSZWN0JiAvKiBkZXN0UmVjdCAqLykKICAgICAgICAgICAgIHsKICAgICAgICAgICAgICAg ICBtX3RleHR1cmVVcGRhdGVyLT5sYXllcigpLT51cGRhdGVSZWN0KCk7CisgICAgICAgICAgICAg ICAgaWYgKG1fdGV4dHVyZS0+dGV4dHVyZUlkKCkpCisgICAgICAgICAgICAgICAgICAgIGNvbnRl eHQtPmJpbmRUZXh0dXJlKEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCBtX3RleHR1cmUt PnRleHR1cmVJZCgpKTsKICAgICAgICAgICAgIH0KIAogICAgICAgICBwcml2YXRlOgpAQCAtMTE2 Miw0ICsxMjA3LDIyMCBAQCBURVNUX0YoQ0NMYXllclRyZWVIb3N0VGVzdE5vUHJlcGFyZVJlY3Qs IHJ1bk11bHRpVGhyZWFkKQogICAgIHJ1blRlc3QodHJ1ZSk7CiB9CiAKKy8vIFZlcmlmeSBhdG9t aWNpdHkgb2YgY29tbWl0cyBhbmQgcmV1c2Ugb2YgdGV4dHVyZXMuCitjbGFzcyBDQ0xheWVyVHJl ZUhvc3RUZXN0QXRvbWljQ29tbWl0IDogcHVibGljIENDTGF5ZXJUcmVlSG9zdFRlc3QgeworcHVi bGljOgorICAgIENDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQoKQorICAgICAgICA6IG1f dXBkYXRlQ2hlY2tMYXllcihDb250ZW50TGF5ZXJDaHJvbWl1bVdpdGhVcGRhdGVUcmFja2luZzo6 Y3JlYXRlKCZtX2RlbGVnYXRlLCB0cnVlKSkKKyAgICAgICAgLCBtX251bUNvbW1pdHMoMCkKKyAg ICB7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGJlZ2luVGVzdCgpCisgICAgeworICAgICAg ICBtX2xheWVyVHJlZUhvc3QtPnNldFJvb3RMYXllcihtX3VwZGF0ZUNoZWNrTGF5ZXIpOworICAg ICAgICBtX2xheWVyVHJlZUhvc3QtPnNldFZpZXdwb3J0KEludFNpemUoMTAsIDEwKSk7CisKKyAg ICAgICAgcG9zdFNldE5lZWRzQ29tbWl0VG9NYWluVGhyZWFkKCk7CisgICAgICAgIHBvc3RTZXRO ZWVkc1JlZHJhd1RvTWFpblRocmVhZCgpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBjb21t aXRDb21wbGV0ZU9uQ0NUaHJlYWQoQ0NMYXllclRyZWVIb3N0SW1wbCogaW1wbCkKKyAgICB7Cisg ICAgICAgIENvbXBvc2l0b3JNb2NrV2ViR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQgPSBzdGF0 aWNfY2FzdDxDb21wb3NpdG9yTW9ja1dlYkdyYXBoaWNzQ29udGV4dDNEKj4oR3JhcGhpY3NDb250 ZXh0M0RQcml2YXRlOjpleHRyYWN0V2ViR3JhcGhpY3NDb250ZXh0M0QoaW1wbC0+Y29udGV4dCgp KSk7CisKKyAgICAgICAgc3dpdGNoIChpbXBsLT5mcmFtZU51bWJlcigpKSB7CisgICAgICAgICAg ICBjYXNlIDA6CisgICAgICAgICAgICAgICAgLy8gTnVtYmVyIG9mIHRleHR1cmVzIHNob3VsZCBi ZSBvbmUuCisgICAgICAgICAgICAgICAgRVhQRUNUX0VRKDEsIGNvbnRleHQtPm51bVRleHR1cmVz KCkpOworICAgICAgICAgICAgICAgIC8vIE51bWJlciBvZiB0ZXh0dXJlcyB1c2VkIGZvciBjb21t aXQgc2hvdWxkIGJlIG9uZS4KKyAgICAgICAgICAgICAgICBFWFBFQ1RfRVEoMSwgY29udGV4dC0+ bnVtVXNlZFRleHR1cmVzKCkpOworICAgICAgICAgICAgICAgIC8vIFZlcmlmeSB1c2VkIHRleHR1 cmUgaXMgY29ycmVjdC4KKyAgICAgICAgICAgICAgICBFWFBFQ1RfVFJVRShjb250ZXh0LT51c2Vk VGV4dHVyZShjb250ZXh0LT50ZXh0dXJlKDApKSk7CisKKyAgICAgICAgICAgICAgICBjb250ZXh0 LT5yZXNldFVzZWRUZXh0dXJlcygpOworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAg ICAgY2FzZSAxOgorICAgICAgICAgICAgICAgIC8vIE51bWJlciBvZiB0ZXh0dXJlcyBzaG91bGQg YmUgdHdvIGFzIHRoZSBmaXJzdCB0ZXh0dXJlCisgICAgICAgICAgICAgICAgLy8gaXMgdXNlZCBi eSBpbXBsIHRocmVhZCBhbmQgY2Fubm90IGJ5IHVzZWQgZm9yIHVwZGF0ZS4KKyAgICAgICAgICAg ICAgICBFWFBFQ1RfRVEoMiwgY29udGV4dC0+bnVtVGV4dHVyZXMoKSk7CisgICAgICAgICAgICAg ICAgLy8gTnVtYmVyIG9mIHRleHR1cmVzIHVzZWQgZm9yIGNvbW1pdCBzaG91bGQgc3RpbGwgYmUg b25lLgorICAgICAgICAgICAgICAgIEVYUEVDVF9FUSgxLCBjb250ZXh0LT5udW1Vc2VkVGV4dHVy ZXMoKSk7CisgICAgICAgICAgICAgICAgLy8gRmlyc3QgdGV4dHVyZSBzaG91bGQgbm90IGhhdmUg YmVlbiB1c2VkLgorICAgICAgICAgICAgICAgIEVYUEVDVF9GQUxTRShjb250ZXh0LT51c2VkVGV4 dHVyZShjb250ZXh0LT50ZXh0dXJlKDApKSk7CisgICAgICAgICAgICAgICAgLy8gTmV3IHRleHR1 cmUgc2hvdWxkIGhhdmUgYmVlbiB1c2VkLgorICAgICAgICAgICAgICAgIEVYUEVDVF9UUlVFKGNv bnRleHQtPnVzZWRUZXh0dXJlKGNvbnRleHQtPnRleHR1cmUoMSkpKTsKKworICAgICAgICAgICAg ICAgIGNvbnRleHQtPnJlc2V0VXNlZFRleHR1cmVzKCk7CisgICAgICAgICAgICAgICAgYnJlYWs7 CisgICAgICAgICAgICBjYXNlIDI6CisgICAgICAgICAgICAgICAgLy8gTnVtYmVyIG9mIHRleHR1 cmVzIHNob3VsZCBub3QgaGF2ZSBpbmNyZWFzZWQuIE9sZCB0ZXh0dXJlCisgICAgICAgICAgICAg ICAgLy8gc2hvdWxkIGhhdmUgYmVlbiByZXVzZWQuCisgICAgICAgICAgICAgICAgRVhQRUNUX0VR KDIsIGNvbnRleHQtPm51bVRleHR1cmVzKCkpOworICAgICAgICAgICAgICAgIC8vIE51bWJlciBv ZiB0ZXh0dXJlcyB1c2VkIGZvciBjb21taXQgc2hvdWxkIHN0aWxsIGJlIG9uZS4KKyAgICAgICAg ICAgICAgICBFWFBFQ1RfRVEoMSwgY29udGV4dC0+bnVtVXNlZFRleHR1cmVzKCkpOworICAgICAg ICAgICAgICAgIC8vIEZpcnN0IHRleHR1cmUgc2hvdWxkIGhhdmUgYmVlbiB1c2VkIGZvciBjb21t aXQuCisgICAgICAgICAgICAgICAgRVhQRUNUX1RSVUUoY29udGV4dC0+dXNlZFRleHR1cmUoY29u dGV4dC0+dGV4dHVyZSgwKSkpOworICAgICAgICAgICAgICAgIC8vIFNlY29uZCB0ZXh0dXJlIHNo b3VsZCBub3QgaGF2ZSBiZWVuIHVzZWQgZm9yIGNvbW1pdC4KKyAgICAgICAgICAgICAgICBFWFBF Q1RfRkFMU0UoY29udGV4dC0+dXNlZFRleHR1cmUoY29udGV4dC0+dGV4dHVyZSgxKSkpOworICAg ICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgZGVmYXVsdDoKKyAgICAgICAgICAgICAg ICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAg fQorICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBkcmF3TGF5ZXJzT25DQ1RocmVhZChDQ0xheWVy VHJlZUhvc3RJbXBsKiBpbXBsKQorICAgIHsKKyAgICAgICAgQ29tcG9zaXRvck1vY2tXZWJHcmFw aGljc0NvbnRleHQzRCogY29udGV4dCA9IHN0YXRpY19jYXN0PENvbXBvc2l0b3JNb2NrV2ViR3Jh cGhpY3NDb250ZXh0M0QqPihHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6OmV4dHJhY3RXZWJHcmFw aGljc0NvbnRleHQzRChpbXBsLT5jb250ZXh0KCkpKTsKKworICAgICAgICAvLyBOdW1iZXIgb2Yg dGV4dHVyZXMgdXNlZCBmb3IgZHJhdyBzaG91bGQgYWx3YXlzIGJlIG9uZS4KKyAgICAgICAgRVhQ RUNUX0VRKDEsIGNvbnRleHQtPm51bVVzZWRUZXh0dXJlcygpKTsKKworICAgICAgICBpZiAoaW1w bC0+ZnJhbWVOdW1iZXIoKSA8IDMpIHsKKyAgICAgICAgICAgIGNvbnRleHQtPnJlc2V0VXNlZFRl eHR1cmVzKCk7CisgICAgICAgICAgICBwb3N0U2V0TmVlZHNBbmltYXRlQW5kQ29tbWl0VG9NYWlu VGhyZWFkKCk7CisgICAgICAgICAgICBwb3N0U2V0TmVlZHNSZWRyYXdUb01haW5UaHJlYWQoKTsK KyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgIGVuZFRlc3QoKTsKKyAgICAgICAgfQorICAg IH0KKworICAgIHZpcnR1YWwgdm9pZCBhbmltYXRlQW5kTGF5b3V0KGRvdWJsZSBmcmFtZUJlZ2lu VGltZSkKKyAgICB7CisgICAgICAgIG1fdXBkYXRlQ2hlY2tMYXllci0+c2V0TmVlZHNEaXNwbGF5 KCk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGFmdGVyVGVzdCgpCisgICAgeworICAgIH0K KworcHJpdmF0ZToKKyAgICBNb2NrTGF5ZXJEZWxlZ2F0ZSBtX2RlbGVnYXRlOworICAgIFJlZlB0 cjxDb250ZW50TGF5ZXJDaHJvbWl1bVdpdGhVcGRhdGVUcmFja2luZz4gbV91cGRhdGVDaGVja0xh eWVyOworICAgIGludCBtX251bUNvbW1pdHM7Cit9OworCitURVNUX0YoQ0NMYXllclRyZWVIb3N0 VGVzdEF0b21pY0NvbW1pdCwgcnVuTXVsdGlUaHJlYWQpCit7CisgICAgcnVuVGVzdCh0cnVlKTsK K30KKworCisvLyBWZXJpZnkgdGhhdCBvbmx5IHByb3RlY3RlZCB0ZXh0dXJlcyBhcmUgdXNlZC4K K2NsYXNzIENDTGF5ZXJUcmVlSG9zdFRlc3RUZXh0dXJlVXNhZ2UgOiBwdWJsaWMgQ0NMYXllclRy ZWVIb3N0VGVzdCB7CitwdWJsaWM6CisgICAgdmlydHVhbCB2b2lkIGRyYXdMYXllcnNPbkNDVGhy ZWFkKENDTGF5ZXJUcmVlSG9zdEltcGwqIGltcGwpCisgICAgeworICAgICAgICBDb21wb3NpdG9y TW9ja1dlYkdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0ID0gc3RhdGljX2Nhc3Q8Q29tcG9zaXRv ck1vY2tXZWJHcmFwaGljc0NvbnRleHQzRCo+KEdyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZTo6ZXh0 cmFjdFdlYkdyYXBoaWNzQ29udGV4dDNEKGltcGwtPmNvbnRleHQoKSkpOworCisgICAgICAgIGZv ciAoaW50IGkgPSAwOyBpIDwgY29udGV4dC0+bnVtVGV4dHVyZXMoKTsgaSsrKQorICAgICAgICAg ICAgaWYgKGNvbnRleHQtPnVzZWRUZXh0dXJlKGNvbnRleHQtPnRleHR1cmUoaSkpKQorICAgICAg ICAgICAgICAgIG1fdGV4dHVyZXMucHVzaF9iYWNrKGNvbnRleHQtPnRleHR1cmUoaSkpOworCisg ICAgICAgIGNvbnRleHQtPnJlc2V0VXNlZFRleHR1cmVzKCk7CisgICAgfQorCisgICAgdmlydHVh bCB2b2lkIGRpZENvbW1pdEFuZERyYXdGcmFtZSgpCisgICAgeworICAgICAgICBmb3IgKHN0ZDo6 dmVjdG9yPFdlYkdMSWQ+OjppdGVyYXRvciBpdCA9IG1fdGV4dHVyZXMuYmVnaW4oKTsgaXQgIT0g bV90ZXh0dXJlcy5lbmQoKTsgKytpdCkgeworICAgICAgICAgICAgVGV4dHVyZVRva2VuIHRva2Vu ID0gbV9sYXllclRyZWVIb3N0LT5jb250ZW50c1RleHR1cmVNYW5hZ2VyKCktPnRva2VuRm9yVGV4 dHVyZUlkKCppdCk7CisgICAgICAgICAgICBBU1NFUlQodG9rZW4pOworICAgICAgICAgICAgRVhQ RUNUX1RSVUUobV9sYXllclRyZWVIb3N0LT5jb250ZW50c1RleHR1cmVNYW5hZ2VyKCktPmhhc1Rl eHR1cmUodG9rZW4pKTsKKyAgICAgICAgICAgIEVYUEVDVF9UUlVFKG1fbGF5ZXJUcmVlSG9zdC0+ Y29udGVudHNUZXh0dXJlTWFuYWdlcigpLT5pc1Byb3RlY3RlZCh0b2tlbikpOworICAgICAgICB9 CisgICAgICAgIG1fdGV4dHVyZXMuY2xlYXIoKTsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgc3Rk Ojp2ZWN0b3I8V2ViR0xJZD4gbV90ZXh0dXJlczsKK307CisKK2NsYXNzIENDTGF5ZXJUcmVlSG9z dFRlc3RUZXh0dXJlVXNhZ2VTaW1wbGUgOiBwdWJsaWMgQ0NMYXllclRyZWVIb3N0VGVzdFRleHR1 cmVVc2FnZSB7CitwdWJsaWM6CisgICAgQ0NMYXllclRyZWVIb3N0VGVzdFRleHR1cmVVc2FnZVNp bXBsZSgpCisgICAgICAgIDogbV91cGRhdGVDaGVja0xheWVyKENvbnRlbnRMYXllckNocm9taXVt V2l0aFVwZGF0ZVRyYWNraW5nOjpjcmVhdGUoJm1fZGVsZWdhdGUsIHRydWUpKQorICAgIHsKKyAg ICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgYmVnaW5UZXN0KCkKKyAgICB7CisgICAgICAgIG1fbGF5 ZXJUcmVlSG9zdC0+c2V0Um9vdExheWVyKG1fdXBkYXRlQ2hlY2tMYXllcik7CisgICAgICAgIG1f bGF5ZXJUcmVlSG9zdC0+c2V0Vmlld3BvcnQoSW50U2l6ZSgxMCwgMTApKTsKKworICAgICAgICBw b3N0U2V0TmVlZHNDb21taXRUb01haW5UaHJlYWQoKTsKKyAgICAgICAgcG9zdFNldE5lZWRzUmVk cmF3VG9NYWluVGhyZWFkKCk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRpZENvbW1pdEFu ZERyYXdGcmFtZSgpCisgICAgeworICAgICAgICBDQ0xheWVyVHJlZUhvc3RUZXN0VGV4dHVyZVVz YWdlOjpkaWRDb21taXRBbmREcmF3RnJhbWUoKTsKKyAgICAgICAgZW5kVGVzdCgpOworICAgIH0K KworICAgIHZpcnR1YWwgdm9pZCBhZnRlclRlc3QoKQorICAgIHsKKyAgICB9CisKK3ByaXZhdGU6 CisgICAgTW9ja0xheWVyRGVsZWdhdGUgbV9kZWxlZ2F0ZTsKKyAgICBSZWZQdHI8Q29udGVudExh eWVyQ2hyb21pdW1XaXRoVXBkYXRlVHJhY2tpbmc+IG1fdXBkYXRlQ2hlY2tMYXllcjsKK307CisK K1RFU1RfRihDQ0xheWVyVHJlZUhvc3RUZXN0VGV4dHVyZVVzYWdlU2ltcGxlLCBydW5NdWx0aVRo cmVhZCkKK3sKKyAgICBydW5UZXN0KHRydWUpOworfQorCitjbGFzcyBDQ0xheWVyVHJlZUhvc3RU ZXN0VGV4dHVyZVVzYWdlTXVsdGlGcmFtZSA6IHB1YmxpYyBDQ0xheWVyVHJlZUhvc3RUZXN0VGV4 dHVyZVVzYWdlIHsKK3B1YmxpYzoKKyAgICBDQ0xheWVyVHJlZUhvc3RUZXN0VGV4dHVyZVVzYWdl TXVsdGlGcmFtZSgpCisgICAgICAgIDogbV91cGRhdGVDaGVja0xheWVyKENvbnRlbnRMYXllckNo cm9taXVtV2l0aFVwZGF0ZVRyYWNraW5nOjpjcmVhdGUoJm1fZGVsZWdhdGUsIHRydWUpKQorICAg ICAgICAsIG1fbnVtQ29tbWl0KDApCisgICAgeworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBi ZWdpblRlc3QoKQorICAgIHsKKyAgICAgICAgbV9sYXllclRyZWVIb3N0LT5zZXRSb290TGF5ZXIo bV91cGRhdGVDaGVja0xheWVyKTsKKyAgICAgICAgbV9sYXllclRyZWVIb3N0LT5zZXRWaWV3cG9y dChJbnRTaXplKDEwLCAxMCkpOworCisgICAgICAgIHBvc3RTZXROZWVkc0NvbW1pdFRvTWFpblRo cmVhZCgpOworICAgICAgICBwb3N0U2V0TmVlZHNSZWRyYXdUb01haW5UaHJlYWQoKTsKKyAgICB9 CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkQ29tbWl0QW5kRHJhd0ZyYW1lKCkKKyAgICB7CisgICAg ICAgIENDTGF5ZXJUcmVlSG9zdFRlc3RUZXh0dXJlVXNhZ2U6OmRpZENvbW1pdEFuZERyYXdGcmFt ZSgpOworICAgICAgICBpZiAobV9udW1Db21taXQgPCAzKSB7CisgICAgICAgICAgICBwb3N0U2V0 TmVlZHNBbmltYXRlQW5kQ29tbWl0VG9NYWluVGhyZWFkKCk7CisgICAgICAgICAgICBwb3N0U2V0 TmVlZHNSZWRyYXdUb01haW5UaHJlYWQoKTsKKyAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAg IGVuZFRlc3QoKTsKKyAgICAgICAgfQorCisgICAgICAgIG1fbnVtQ29tbWl0Kys7CisgICAgfQor CisgICAgdmlydHVhbCB2b2lkIGFuaW1hdGVBbmRMYXlvdXQoZG91YmxlIGZyYW1lQmVnaW5UaW1l KQorICAgIHsKKyAgICAgICAgbV91cGRhdGVDaGVja0xheWVyLT5zZXROZWVkc0Rpc3BsYXkoKTsK KyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgYWZ0ZXJUZXN0KCkKKyAgICB7CisgICAgfQorCitw cml2YXRlOgorICAgIE1vY2tMYXllckRlbGVnYXRlIG1fZGVsZWdhdGU7CisgICAgUmVmUHRyPENv bnRlbnRMYXllckNocm9taXVtV2l0aFVwZGF0ZVRyYWNraW5nPiBtX3VwZGF0ZUNoZWNrTGF5ZXI7 CisgICAgaW50IG1fbnVtQ29tbWl0OworfTsKKworVEVTVF9GKENDTGF5ZXJUcmVlSG9zdFRlc3RU ZXh0dXJlVXNhZ2VNdWx0aUZyYW1lLCBydW5NdWx0aVRocmVhZCkKK3sKKyAgICBydW5UZXN0KHRy dWUpOworfQorCisKIH0gLy8gbmFtZXNwYWNlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3Rlc3RzL1RpbGVkTGF5ZXJDaHJvbWl1bVRlc3QuY3BwIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS90ZXN0cy9UaWxlZExheWVyQ2hyb21pdW1UZXN0LmNwcAppbmRleCA5M2NmYjU3Li5j NjFkNDYyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL1RpbGVkTGF5 ZXJDaHJvbWl1bVRlc3QuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvVGls ZWRMYXllckNocm9taXVtVGVzdC5jcHAKQEAgLTEzMiw2ICsxMzIsNyBAQCBURVNUKFRpbGVkTGF5 ZXJDaHJvbWl1bVRlc3QsIHB1c2hEaXJ0eVRpbGVzKQogICAgIC8vIFRoZSB0aWxlIHNpemUgaXMg MTAweDEwMCwgc28gdGhpcyBpbnZhbGlkYXRlcyBhbmQgdGhlbiBwYWludHMgdHdvIHRpbGVzLgog ICAgIGxheWVyLT5pbnZhbGlkYXRlUmVjdChJbnRSZWN0KDAsIDAsIDEwMCwgMjAwKSk7CiAgICAg bGF5ZXItPnByZXBhcmVUb1VwZGF0ZShJbnRSZWN0KDAsIDAsIDEwMCwgMjAwKSk7CisgICAgbGF5 ZXItPnByb3RlY3RUaWxlVGV4dHVyZXMoSW50UmVjdCgwLCAwLCAxMDAsIDIwMCkpOwogICAgIGxh eWVyLT5wYWludENvbnRlbnRzKEludFJlY3QoMCwgMCwgMTAwLCAyMDApKTsKICAgICBsYXllci0+ Zm9yRWFjaENvbXBvc2l0b3JSZXNvdXJjZShoYW5kbGVyKTsKICAgICBsYXllci0+cHVzaFByb3Bl cnRpZXNUbyhsYXllckltcGwuZ2V0KCkpOwpAQCAtMTQwLDEyICsxNDEsMTIgQEAgVEVTVChUaWxl ZExheWVyQ2hyb21pdW1UZXN0LCBwdXNoRGlydHlUaWxlcykKICAgICBFWFBFQ1RfVFJVRShsYXll ckltcGwtPmhhc1RpbGVBdCgwLCAwKSk7CiAgICAgRVhQRUNUX1RSVUUobGF5ZXJJbXBsLT5oYXNU aWxlQXQoMCwgMSkpOwogCi0gICAgdGV4dHVyZU1hbmFnZXItPnVucHJvdGVjdEFsbFRleHR1cmVz KCk7Ci0KICAgICAvLyBJbnZhbGlkYXRlcyBib3RoIHRpbGVzLi4uCiAgICAgbGF5ZXItPmludmFs aWRhdGVSZWN0KEludFJlY3QoMCwgMCwgMTAwLCAyMDApKTsKICAgICAvLyAuLi4uYnV0IHRoZW4g b25seSB1cGRhdGUgb25lIG9mIHRoZW0uCiAgICAgbGF5ZXItPnByZXBhcmVUb1VwZGF0ZShJbnRS ZWN0KDAsIDAsIDEwMCwgMTAwKSk7CisgICAgdGV4dHVyZU1hbmFnZXItPnVucHJvdGVjdEFsbFRl eHR1cmVzKCk7CisgICAgbGF5ZXItPnByb3RlY3RUaWxlVGV4dHVyZXMoSW50UmVjdCgwLCAwLCAx MDAsIDEwMCkpOwogICAgIGxheWVyLT5wYWludENvbnRlbnRzKEludFJlY3QoMCwgMCwgMTAwLCAx MDApKTsKICAgICBsYXllci0+Zm9yRWFjaENvbXBvc2l0b3JSZXNvdXJjZShoYW5kbGVyKTsKICAg ICBsYXllci0+cHVzaFByb3BlcnRpZXNUbyhsYXllckltcGwuZ2V0KCkpOwo= 118715 2011-12-11 16:01:40 -0800 2011-12-16 09:13:51 -0800 Patch atomic-texture-updates.diff text/plain 48252 reveman ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0Nh bnZhczJETGF5ZXJDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9DYW52YXMyRExheWVyQ2hyb21pdW0uY3BwCmluZGV4IGUwNGYxOGQuLjdkYTU1 NTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0NhbnZhczJETGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vQ2FudmFzMkRMYXllckNocm9taXVtLmNwcApAQCAtMTAyLDcgKzEw Miw4IEBAIHZvaWQgQ2FudmFzMkRMYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3Vy Y2VzKCkKIAogdm9pZCBDYW52YXMyRExheWVyQ2hyb21pdW06OmZvckVhY2hDb21wb3NpdG9yUmVz b3VyY2UoTGF5ZXJUZXh0dXJlVXBkYXRlcjo6SGFuZGxlciYgaGFuZGxlcikKIHsKLSAgICBoYW5k bGVyLmhhbmRsZShtX3VwZGF0ZXJUZXh0dXJlLmdldCgpLCBJbnRSZWN0KCksIEludFJlY3QoKSk7 CisgICAgSW50UmVjdCBub25FbXB0eVJlY3QoMCwgMCwgMSwgMSk7CisgICAgaGFuZGxlci5oYW5k bGUobV91cGRhdGVyVGV4dHVyZS5nZXQoKSwgbm9uRW1wdHlSZWN0LCBub25FbXB0eVJlY3QpOwog fQogCiB2b2lkIENhbnZhczJETGF5ZXJDaHJvbWl1bTo6Y29udGVudENoYW5nZWQoKQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vQ29udGVudExh eWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vQ29udGVudExheWVyQ2hyb21pdW0uY3BwCmluZGV4IGRkNzQ5NjcuLjVmZjYyYjggMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0NvbnRlbnRM YXllckNocm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9Db250ZW50TGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTEyMyw2ICsxMjMsMTkgQEAgdm9p ZCBDb250ZW50TGF5ZXJDaHJvbWl1bTo6cGFpbnRDb250ZW50c0lmRGlydHkoKQogICAgIHBhaW50 Q29udGVudHMobGF5ZXJSZWN0KTsKIH0KIAordm9pZCBDb250ZW50TGF5ZXJDaHJvbWl1bTo6cHJv dGVjdFRleHR1cmVzKCkKK3sKKyAgICBjb25zdCBJbnRSZWN0JiBsYXllclJlY3QgPSB2aXNpYmxl TGF5ZXJSZWN0KCk7CisgICAgaWYgKGxheWVyUmVjdC5pc0VtcHR5KCkpCisgICAgICAgIHJldHVy bjsKKworICAgIGlmICghZHJhd3NDb250ZW50KCkpCisgICAgICAgIHJldHVybjsKKworICAgIHBy b3RlY3RUaWxlVGV4dHVyZXMobGF5ZXJSZWN0KTsKK30KKworCiBib29sIENvbnRlbnRMYXllckNo cm9taXVtOjpkcmF3c0NvbnRlbnQoKSBjb25zdAogewogICAgIHJldHVybiBtX2RlbGVnYXRlICYm IG1fZGVsZWdhdGUtPmRyYXdzQ29udGVudCgpICYmIFRpbGVkTGF5ZXJDaHJvbWl1bTo6ZHJhd3ND b250ZW50KCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9Db250ZW50TGF5ZXJDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vQ29udGVudExheWVyQ2hyb21pdW0uaAppbmRleCBjNWU5ZmNjLi5l MTA2NzgyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9Db250ZW50TGF5ZXJDaHJvbWl1bS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL0NvbnRlbnRMYXllckNocm9taXVtLmgKQEAgLTUwLDYgKzUwLDcg QEAgcHVibGljOgogICAgIHZpcnR1YWwgfkNvbnRlbnRMYXllckNocm9taXVtKCk7CiAKICAgICB2 aXJ0dWFsIHZvaWQgcHJlcGFyZVRvVXBkYXRlSWZEaXJ0eSgpOworICAgIHZpcnR1YWwgdm9pZCBw cm90ZWN0VGV4dHVyZXMoKTsKICAgICB2aXJ0dWFsIHZvaWQgcGFpbnRDb250ZW50c0lmRGlydHko KTsKIAogcHJvdGVjdGVkOgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vSW1hZ2VMYXllckNocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0ltYWdlTGF5ZXJDaHJvbWl1bS5jcHAKaW5kZXggZjky YTEzYS4uMjZhYmE3MiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vSW1hZ2VMYXllckNocm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9JbWFnZUxheWVyQ2hyb21pdW0uY3BwCkBAIC0xODEs NiArMTgxLDExIEBAIHZvaWQgSW1hZ2VMYXllckNocm9taXVtOjpwcmVwYXJlVG9VcGRhdGVJZkRp cnR5KCkKICAgICBwcmVwYXJlVG9VcGRhdGUodmlzaWJsZUxheWVyUmVjdCgpKTsKIH0KIAordm9p ZCBJbWFnZUxheWVyQ2hyb21pdW06OnByb3RlY3RUZXh0dXJlcygpCit7CisgICAgcHJvdGVjdFRp bGVUZXh0dXJlcyh2aXNpYmxlTGF5ZXJSZWN0KCkpOworfQorCiBMYXllclRleHR1cmVVcGRhdGVy KiBJbWFnZUxheWVyQ2hyb21pdW06OnRleHR1cmVVcGRhdGVyKCkgY29uc3QKIHsKICAgICByZXR1 cm4gbV90ZXh0dXJlVXBkYXRlci5nZXQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0ltYWdlTGF5ZXJDaHJvbWl1bS5oIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vSW1hZ2VMYXllckNocm9taXVtLmgKaW5k ZXggZjZlYmM4YS4uYTAyYTQ1NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vSW1hZ2VMYXllckNocm9taXVtLmgKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vSW1hZ2VMYXllckNocm9taXVtLmgKQEAgLTU0 LDYgKzU0LDcgQEAgcHVibGljOgogCiAgICAgdmlydHVhbCBib29sIGRyYXdzQ29udGVudCgpIGNv bnN0OwogICAgIHZpcnR1YWwgdm9pZCBwcmVwYXJlVG9VcGRhdGVJZkRpcnR5KCk7CisgICAgdmly dHVhbCB2b2lkIHByb3RlY3RUZXh0dXJlcygpOwogICAgIHZpcnR1YWwgYm9vbCBuZWVkc0NvbnRl bnRzU2NhbGUoKSBjb25zdDsKIAogICAgIHZvaWQgc2V0Q29udGVudHMoSW1hZ2UqIGltYWdlKTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0xh eWVyQ2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L0xheWVyQ2hyb21pdW0uaAppbmRleCBjN2ZjYjRjLi5kMWZiZTZiIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9MYXllckNocm9taXVtLmgKKysr IGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTGF5ZXJDaHJvbWl1 bS5oCkBAIC0xNjEsNyArMTYxLDkgQEAgcHVibGljOgogICAgIC8vIFRoZXNlIG1ldGhvZHMgdHlw aWNhbGx5IG5lZWQgdG8gYmUgb3ZlcndyaXR0ZW4gYnkgZGVyaXZlZCBjbGFzc2VzLgogICAgIHZp cnR1YWwgYm9vbCBkcmF3c0NvbnRlbnQoKSBjb25zdCB7IHJldHVybiBmYWxzZTsgfQogICAgIHZp cnR1YWwgdm9pZCBwcmVwYXJlVG9VcGRhdGVJZkRpcnR5KCkgeyB9CisgICAgdmlydHVhbCB2b2lk IHByb3RlY3RUZXh0dXJlcygpIHsgfQogICAgIHZpcnR1YWwgdm9pZCBwYWludENvbnRlbnRzSWZE aXJ0eSgpIHsgfQorICAgIHZpcnR1YWwgdm9pZCBmaW5pc2hVcGRhdGUoKSB7IH0KICAgICB2aXJ0 dWFsIHZvaWQgZm9yRWFjaENvbXBvc2l0b3JSZXNvdXJjZShMYXllclRleHR1cmVVcGRhdGVyOjpI YW5kbGVyJikgeyB9CiAgICAgdmlydHVhbCB2b2lkIHNldElzTWFzayhib29sKSB7IH0KICAgICB2 aXJ0dWFsIHZvaWQgdW5yZXNlcnZlQ29udGVudHNUZXh0dXJlKCkgeyB9CmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5j cHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5hZ2VkVGV4 dHVyZS5jcHAKaW5kZXggZWUxODAyNS4uYTFiZTk0NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFuYWdlZFRleHR1cmUuY3BwCisrKyBiL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRUZXh0dXJlLmNw cApAQCAtNDEsNiArNDEsMTUgQEAgTWFuYWdlZFRleHR1cmU6Ok1hbmFnZWRUZXh0dXJlKFRleHR1 cmVNYW5hZ2VyKiBtYW5hZ2VyKQogewogfQogCitNYW5hZ2VkVGV4dHVyZTo6TWFuYWdlZFRleHR1 cmUoVGV4dHVyZU1hbmFnZXIqIG1hbmFnZXIsIFRleHR1cmVUb2tlbiB0b2tlbiwgSW50U2l6ZSBz aXplLCB1bnNpZ25lZCBmb3JtYXQsIHVuc2lnbmVkIHRleHR1cmVJZCkKKyAgICA6IG1fdGV4dHVy ZU1hbmFnZXIobWFuYWdlcikKKyAgICAsIG1fdG9rZW4odG9rZW4pCisgICAgLCBtX3NpemUoc2l6 ZSkKKyAgICAsIG1fZm9ybWF0KGZvcm1hdCkKKyAgICAsIG1fdGV4dHVyZUlkKHRleHR1cmVJZCkK K3sKK30KKwogTWFuYWdlZFRleHR1cmU6On5NYW5hZ2VkVGV4dHVyZSgpCiB7CiAgICAgaWYgKG1f dG9rZW4pCkBAIC0xMDEsNiArMTEwLDE3IEBAIHZvaWQgTWFuYWdlZFRleHR1cmU6OmZyYW1lYnVm ZmVyVGV4dHVyZTJEKEdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0LCBUZXh0dXJlQWxsCiAgICAg Y29udGV4dC0+ZnJhbWVidWZmZXJUZXh0dXJlMkQoR3JhcGhpY3NDb250ZXh0M0Q6OkZSQU1FQlVG RkVSLCBHcmFwaGljc0NvbnRleHQzRDo6Q09MT1JfQVRUQUNITUVOVDAsIEdyYXBoaWNzQ29udGV4 dDNEOjpURVhUVVJFXzJELCBtX3RleHR1cmVJZCwgMCk7CiB9CiAKK1Bhc3NPd25QdHI8TWFuYWdl ZFRleHR1cmU+IE1hbmFnZWRUZXh0dXJlOjpzdGVhbCgpCit7CisgICAgTWFuYWdlZFRleHR1cmUq IHRleHR1cmUgPSBuZXcgTWFuYWdlZFRleHR1cmUobV90ZXh0dXJlTWFuYWdlciwgbV90b2tlbiwg bV9zaXplLCBtX2Zvcm1hdCwgbV90ZXh0dXJlSWQpOworICAgIG1fdG9rZW4gPSAwOworICAgIG1f c2l6ZSA9IEludFNpemUoKTsKKyAgICBtX2Zvcm1hdCA9IDA7CisgICAgbV90ZXh0dXJlSWQgPSAw OworICAgIHJldHVybiBhZG9wdFB0cih0ZXh0dXJlKTsKK30KKworCiB9CiAKICNlbmRpZiAvLyBV U0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5oIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFuYWdlZFRleHR1cmUuaAppbmRleCBkNzNj ODc0Li43N2UwZjU2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRUZXh0dXJlLmgKQEAgLTYzLDggKzYzLDExIEBAIHB1 YmxpYzoKICAgICB1bnNpZ25lZCBmb3JtYXQoKSBjb25zdCB7IHJldHVybiBtX2Zvcm1hdDsgfQog ICAgIHVuc2lnbmVkIHRleHR1cmVJZCgpIGNvbnN0IHsgcmV0dXJuIG1fdGV4dHVyZUlkOyB9CiAK KyAgICBQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJlPiBzdGVhbCgpOworCiBwcml2YXRlOgogICAg IGV4cGxpY2l0IE1hbmFnZWRUZXh0dXJlKFRleHR1cmVNYW5hZ2VyKik7CisgICAgTWFuYWdlZFRl eHR1cmUoVGV4dHVyZU1hbmFnZXIqLCBUZXh0dXJlVG9rZW4sIEludFNpemUsIHVuc2lnbmVkIGZv cm1hdCwgdW5zaWduZWQgdGV4dHVyZUlkKTsKIAogICAgIFRleHR1cmVNYW5hZ2VyKiBtX3RleHR1 cmVNYW5hZ2VyOwogICAgIFRleHR1cmVUb2tlbiBtX3Rva2VuOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGV4dHVyZU1hbmFnZXIuY3BwIGIv U291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGV4dHVyZU1hbmFnZXIu Y3BwCmluZGV4IDExODc1MzcuLjNiYjE2ZTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RleHR1cmVNYW5hZ2VyLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UZXh0dXJlTWFuYWdlci5jcHAKQEAg LTMwNiwxMCArMzA2LDM5IEBAIGJvb2wgVGV4dHVyZU1hbmFnZXI6OnJlcXVlc3RUZXh0dXJlKFRl eHR1cmVUb2tlbiB0b2tlbiwgSW50U2l6ZSBzaXplLCB1bnNpZ25lZCBmCiAgICAgICAgIGlmICh0 ZXh0dXJlSWQpCiAgICAgICAgICAgICByZXR1cm4gdHJ1ZTsKICAgICB9CisKKyAgICAvLyBSZXVz ZSBldmljdGVkIHRleHR1cmUgaWYgYXZhaWxhYmxlLgorICAgIGZvciAoc2l6ZV90IGkgPSAwOyBp IDwgbV9ldmljdGVkVGV4dHVyZXMuc2l6ZSgpOyArK2kpIHsKKyAgICAgICAgaWYgKCFtX2V2aWN0 ZWRUZXh0dXJlc1tpXS50ZXh0dXJlSWQpCisgICAgICAgICAgICBjb250aW51ZTsKKworICAgICAg ICBpZiAobV9ldmljdGVkVGV4dHVyZXNbaV0uc2l6ZSA9PSBzaXplICYmIG1fZXZpY3RlZFRleHR1 cmVzW2ldLmZvcm1hdCA9PSBmb3JtYXQpIHsKKyAgICAgICAgICAgIGluZm8udGV4dHVyZUlkID0g dGV4dHVyZUlkID0gbV9ldmljdGVkVGV4dHVyZXNbaV0udGV4dHVyZUlkOworICAgICAgICAgICAg bV9ldmljdGVkVGV4dHVyZXNbaV0udGV4dHVyZUlkID0gMDsKKyNpZm5kZWYgTkRFQlVHCisgICAg ICAgICAgICBpbmZvLmFsbG9jYXRvciA9IG1fZXZpY3RlZFRleHR1cmVzW2ldLmFsbG9jYXRvcjsK KyNlbmRpZgorICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9CisKICAgICBhZGRU ZXh0dXJlKHRva2VuLCBpbmZvKTsKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAorVGV4dHVyZVRva2Vu IFRleHR1cmVNYW5hZ2VyOjp0b2tlbkZvclRleHR1cmVJZCh1bnNpZ25lZCB0ZXh0dXJlSWQpCit7 CisgICAgVGV4dHVyZU1hcDo6aXRlcmF0b3IgaXQgPSBtX3RleHR1cmVzLmJlZ2luKCk7CisgICAg d2hpbGUgKGl0ICE9IG1fdGV4dHVyZXMuZW5kKCkpIHsKKyAgICAgICAgaWYgKGl0LT5zZWNvbmQu dGV4dHVyZUlkID09IHRleHR1cmVJZCkKKyAgICAgICAgICAgIHJldHVybiBpdC0+Zmlyc3Q7CisK KyAgICAgICAgKytpdDsKKyAgICB9CisKKyAgICByZXR1cm4gMDsKK30KKwogfQogCiAjZW5kaWYg Ly8gVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGV4dHVyZU1hbmFnZXIuaCBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RleHR1cmVNYW5hZ2VyLmgKaW5kZXgg YzZjMjFhZC4uYTEwMzFiZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vVGV4dHVyZU1hbmFnZXIuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UZXh0dXJlTWFuYWdlci5oCkBAIC03Niw2ICs3Niw3IEBA IHB1YmxpYzoKICAgICB2b2lkIHVucHJvdGVjdFRleHR1cmUoVGV4dHVyZVRva2VuKTsKICAgICB2 b2lkIHVucHJvdGVjdEFsbFRleHR1cmVzKCk7CiAgICAgYm9vbCBpc1Byb3RlY3RlZChUZXh0dXJl VG9rZW4pOworICAgIFRleHR1cmVUb2tlbiB0b2tlbkZvclRleHR1cmVJZCh1bnNpZ25lZCB0ZXh0 dXJlSWQpOwogCiAgICAgdW5zaWduZWQgYWxsb2NhdGVUZXh0dXJlKFRleHR1cmVBbGxvY2F0b3Iq LCBUZXh0dXJlVG9rZW4pOwogICAgIHZvaWQgZGVsZXRlRXZpY3RlZFRleHR1cmVzKFRleHR1cmVB bGxvY2F0b3IqKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCmluZGV4IGZhMWU5MGQu LjBkNGYyYjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcApAQCAtMTc0LDM1ICsx NzQsMjQgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OmNyZWF0ZVRpbGVyKENDTGF5ZXJUaWxp bmdEYXRhOjpCb3JkZXJUZXhlbE9wdGlvbiBib3JkZXIKIAogdm9pZCBUaWxlZExheWVyQ2hyb21p dW06OmZvckVhY2hDb21wb3NpdG9yUmVzb3VyY2UoTGF5ZXJUZXh0dXJlVXBkYXRlcjo6SGFuZGxl ciYgaGFuZGxlcikKIHsKLSAgICAvLyBJZiB0aGlzIGFzc2VydCBpcyBoaXQsIGl0IG1lYW5zIHRo YXQgcGFpbnRDb250ZW50c0lmRGlydHkgaGFzbid0IGJlZW4KLSAgICAvLyBjYWxsZWQgb24gdGhp cyBsYXllci4gQW55IGxheWVyIHRoYXQgaXMgdXBkYXRlZCBzaG91bGQgYmUgcGFpbnRlZCBmaXJz dC4KLSAgICBBU1NFUlQobV9za2lwc0RyYXcgfHwgbV90aWxlcik7Ci0KLSAgICAvLyBQYWludGlu ZyBjb3VsZCBjYXVzZSBjb21wb3NpdGluZyB0byBnZXQgdHVybmVkIG9mZiwgd2hpY2ggbWF5IGNh dXNlIHRoZSB0aWxlciB0byBiZWNvbWUgaW52YWxpZGF0ZWQgbWlkLXVwZGF0ZS4KLSAgICBpZiAo bV9za2lwc0RyYXcgfHwgbV9yZXF1ZXN0ZWRVcGRhdGVSZWN0LmlzRW1wdHkoKSB8fCAhbV90aWxl ciB8fCAhbV90aWxlci0+bnVtVGlsZXMoKSB8fCBtX3BhaW50UmVjdC5pc0VtcHR5KCkpCisgICAg aWYgKCFtX3RpbGVyKQogICAgICAgICByZXR1cm47CiAKLSAgICBpbnQgbGVmdCwgdG9wLCByaWdo dCwgYm90dG9tOwotICAgIG1fdGlsZXItPmNvbnRlbnRSZWN0VG9UaWxlSW5kaWNlcyhtX3JlcXVl c3RlZFVwZGF0ZVJlY3QsIGxlZnQsIHRvcCwgcmlnaHQsIGJvdHRvbSk7Ci0gICAgZm9yIChpbnQg aiA9IHRvcDsgaiA8PSBib3R0b207ICsraikgewotICAgICAgICBmb3IgKGludCBpID0gbGVmdDsg aSA8PSByaWdodDsgKytpKSB7Ci0gICAgICAgICAgICBVcGRhdGFibGVUaWxlKiB0aWxlID0gdGls ZUF0KGksIGopOworICAgIGZvciAoQ0NMYXllclRpbGluZ0RhdGE6OlRpbGVNYXA6OmNvbnN0X2l0 ZXJhdG9yIGl0ZXIgPSBtX3RpbGVyLT50aWxlcygpLmJlZ2luKCk7IGl0ZXIgIT0gbV90aWxlci0+ dGlsZXMoKS5lbmQoKTsgKytpdGVyKSB7CisgICAgICAgIFVwZGF0YWJsZVRpbGUqIHRpbGUgPSBz dGF0aWNfY2FzdDxVcGRhdGFibGVUaWxlKj4oaXRlci0+c2Vjb25kLmdldCgpKTsKIAotICAgICAg ICAgICAgLy8gUmVxdWlyZWQgdGlsZXMgYXJlIGNyZWF0ZWQgaW4gcHJlcGFyZVRvVXBkYXRlKCku IEEgdGlsZSBzaG91bGQKLSAgICAgICAgICAgIC8vIG5ldmVyIGJlIHJlbW92ZWQgYmV0d2VlbiB0 aGUgY2FsbCB0byBwcmVwYXJlVG9VcGRhdGUoKSBhbmQgdGhlCi0gICAgICAgICAgICAvLyBjYWxs IHRvIHVwZGF0ZUNvbXBvc2l0b3JSZXNvdXJjZXMoKS4KLSAgICAgICAgICAgIGlmICghdGlsZSkK LSAgICAgICAgICAgICAgICBDUkFTSCgpOworICAgICAgICBJbnRSZWN0IHNvdXJjZVJlY3Q7Cisg ICAgICAgIEludFJlY3QgZGVzdFJlY3Q7CiAKLSAgICAgICAgICAgIEludFJlY3Qgc291cmNlUmVj dCA9IHRpbGUtPm1fdXBkYXRlUmVjdDsKLSAgICAgICAgICAgIGlmICh0aWxlLT5tX3VwZGF0ZVJl Y3QuaXNFbXB0eSgpKQotICAgICAgICAgICAgICAgIGNvbnRpbnVlOworICAgICAgICAvLyBQYWlu dGluZyBjb3VsZCBjYXVzZSBjb21wb3NpdGluZyB0byBnZXQgdHVybmVkIG9mZiwgd2hpY2ggbWF5 IGNhdXNlIHRoZSB0aWxlciB0byBiZWNvbWUgaW52YWxpZGF0ZWQgbWlkLXVwZGF0ZS4KKyAgICAg ICAgaWYgKCFtX3NraXBzRHJhdyAmJiAhbV9yZXF1ZXN0ZWRVcGRhdGVSZWN0LmlzRW1wdHkoKSAm JiAhbV9wYWludFJlY3QuaXNFbXB0eSgpKQorICAgICAgICAgICAgc291cmNlUmVjdCA9IHRpbGUt Pm1fdXBkYXRlUmVjdDsKIAotICAgICAgICAgICAgQVNTRVJUKHRpbGUtPm1hbmFnZWRUZXh0dXJl KCktPmlzUmVzZXJ2ZWQoKSk7CisgICAgICAgIGlmICghc291cmNlUmVjdC5pc0VtcHR5KCkpIHsK ICAgICAgICAgICAgIGNvbnN0IEludFBvaW50IGFuY2hvciA9IG1fdGlsZXItPnRpbGVDb250ZW50 UmVjdCh0aWxlKS5sb2NhdGlvbigpOwogCiAgICAgICAgICAgICAvLyBDYWxjdWxhdGUgdGlsZS1z cGFjZSByZWN0YW5nbGUgdG8gdXBsb2FkIGludG8uCi0gICAgICAgICAgICBJbnRSZWN0IGRlc3RS ZWN0KEludFBvaW50KHNvdXJjZVJlY3QueCgpIC0gYW5jaG9yLngoKSwgc291cmNlUmVjdC55KCkg LSBhbmNob3IueSgpKSwgc291cmNlUmVjdC5zaXplKCkpOworICAgICAgICAgICAgZGVzdFJlY3Qg PSBJbnRSZWN0KEludFBvaW50KHNvdXJjZVJlY3QueCgpIC0gYW5jaG9yLngoKSwgc291cmNlUmVj dC55KCkgLSBhbmNob3IueSgpKSwgc291cmNlUmVjdC5zaXplKCkpOwogICAgICAgICAgICAgaWYg KGRlc3RSZWN0LngoKSA8IDApCiAgICAgICAgICAgICAgICAgQ1JBU0goKTsKICAgICAgICAgICAg IGlmIChkZXN0UmVjdC55KCkgPCAwKQpAQCAtMjE4LDkgKzIwNyw5IEBAIHZvaWQgVGlsZWRMYXll ckNocm9taXVtOjpmb3JFYWNoQ29tcG9zaXRvclJlc291cmNlKExheWVyVGV4dHVyZVVwZGF0ZXI6 OkhhbmRsZXImCiAgICAgICAgICAgICAgICAgQ1JBU0goKTsKICAgICAgICAgICAgIGlmIChwYWlu dE9mZnNldC55KCkgKyBkZXN0UmVjdC5oZWlnaHQoKSA+IG1fcGFpbnRSZWN0LmhlaWdodCgpKQog ICAgICAgICAgICAgICAgIENSQVNIKCk7Ci0KLSAgICAgICAgICAgIGhhbmRsZXIuaGFuZGxlKHRp bGUtPnRleHR1cmUoKSwgc291cmNlUmVjdCwgZGVzdFJlY3QpOwogICAgICAgICB9CisKKyAgICAg ICAgaGFuZGxlci5oYW5kbGUodGlsZS0+dGV4dHVyZSgpLCBzb3VyY2VSZWN0LCBkZXN0UmVjdCk7 CiAgICAgfQogfQogCkBAIC0zMzIsMTAgKzMyMSwxOCBAQCB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1 bTo6cHJvdGVjdFRpbGVUZXh0dXJlcyhjb25zdCBJbnRSZWN0JiBjb250ZW50UmVjdCkKICAgICBm b3IgKGludCBqID0gdG9wOyBqIDw9IGJvdHRvbTsgKytqKSB7CiAgICAgICAgIGZvciAoaW50IGkg PSBsZWZ0OyBpIDw9IHJpZ2h0OyArK2kpIHsKICAgICAgICAgICAgIFVwZGF0YWJsZVRpbGUqIHRp bGUgPSB0aWxlQXQoaSwgaik7Ci0gICAgICAgICAgICBpZiAoIXRpbGUgfHwgIXRpbGUtPm1hbmFn ZWRUZXh0dXJlKCktPmlzVmFsaWQobV90aWxlci0+dGlsZVNpemUoKSwgbV90ZXh0dXJlRm9ybWF0 KSkKKyAgICAgICAgICAgIGlmICghdGlsZSkKICAgICAgICAgICAgICAgICBjb250aW51ZTsKIAot ICAgICAgICAgICAgdGlsZS0+bWFuYWdlZFRleHR1cmUoKS0+cmVzZXJ2ZShtX3RpbGVyLT50aWxl U2l6ZSgpLCBtX3RleHR1cmVGb3JtYXQpOworICAgICAgICAgICAgaWYgKHRpbGUtPm1hbmFnZWRU ZXh0dXJlKCktPmlzUmVzZXJ2ZWQoKSkKKyAgICAgICAgICAgICAgICBjb250aW51ZTsKKworICAg ICAgICAgICAgaWYgKCF0aWxlLT5tYW5hZ2VkVGV4dHVyZSgpLT5yZXNlcnZlKG1fdGlsZXItPnRp bGVTaXplKCksIG1fdGV4dHVyZUZvcm1hdCkpIHsKKyAgICAgICAgICAgICAgICB0aWxlLT5tX3Vw ZGF0ZVJlY3QgPSBJbnRSZWN0KCk7CisgICAgICAgICAgICAgICAgbV9za2lwc0RyYXcgPSB0cnVl OworICAgICAgICAgICAgICAgIGNsZWFudXBSZXNvdXJjZXMoKTsKKyAgICAgICAgICAgICAgICBy ZXR1cm47CisgICAgICAgICAgICB9CiAgICAgICAgIH0KICAgICB9CiB9CkBAIC0zNzgsMTMgKzM3 NSwxMyBAQCB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRvVXBkYXRlKGNvbnN0IElu dFJlY3QmIGNvbnRlbnRSZWN0KQogICAgICAgICAgICAgaWYgKCF0aWxlKQogICAgICAgICAgICAg ICAgIHRpbGUgPSBjcmVhdGVUaWxlKGksIGopOwogCi0gICAgICAgICAgICBpZiAoIXRpbGUtPm1h bmFnZWRUZXh0dXJlKCktPmlzVmFsaWQobV90aWxlci0+dGlsZVNpemUoKSwgbV90ZXh0dXJlRm9y bWF0KSkKLSAgICAgICAgICAgICAgICB0aWxlLT5tX2RpcnR5TGF5ZXJSZWN0ID0gbV90aWxlci0+ dGlsZUxheWVyUmVjdCh0aWxlKTsKKyAgICAgICAgICAgIGlmICh0aWxlLT5tYW5hZ2VkVGV4dHVy ZSgpLT5pc1ZhbGlkKG1fdGlsZXItPnRpbGVTaXplKCksIG1fdGV4dHVyZUZvcm1hdCkpIHsKKyAg ICAgICAgICAgICAgICAvLyBVbnJlc2VydmVkIHRleHR1cmUgbmVlZCBmdWxsIHVwZGF0ZS4KKyAg ICAgICAgICAgICAgICBpZiAodGlsZS0+aXNEaXJ0eSgpICYmICF0aWxlLT5tYW5hZ2VkVGV4dHVy ZSgpLT5pc1Jlc2VydmVkKCkpCisgICAgICAgICAgICAgICAgICAgIHRpbGUtPm1fZGlydHlMYXll clJlY3QgPSBtX3RpbGVyLT50aWxlTGF5ZXJSZWN0KHRpbGUpOwogCi0gICAgICAgICAgICBpZiAo IXRpbGUtPm1hbmFnZWRUZXh0dXJlKCktPnJlc2VydmUobV90aWxlci0+dGlsZVNpemUoKSwgbV90 ZXh0dXJlRm9ybWF0KSkgewotICAgICAgICAgICAgICAgIG1fc2tpcHNEcmF3ID0gdHJ1ZTsKLSAg ICAgICAgICAgICAgICBjbGVhbnVwUmVzb3VyY2VzKCk7Ci0gICAgICAgICAgICAgICAgcmV0dXJu OworICAgICAgICAgICAgfSBlbHNlIHsKKyAgICAgICAgICAgICAgICB0aWxlLT5tX2RpcnR5TGF5 ZXJSZWN0ID0gbV90aWxlci0+dGlsZUxheWVyUmVjdCh0aWxlKTsKICAgICAgICAgICAgIH0KIAog ICAgICAgICAgICAgZGlydHlMYXllclJlY3QudW5pdGUodGlsZS0+bV9kaXJ0eUxheWVyUmVjdCk7 CkBAIC00MzAsNyArNDI3LDExIEBAIHZvaWQgVGlsZWRMYXllckNocm9taXVtOjpwcmVwYXJlVG9V cGRhdGUoY29uc3QgSW50UmVjdCYgY29udGVudFJlY3QpCiAKIHZvaWQgVGlsZWRMYXllckNocm9t aXVtOjpwYWludENvbnRlbnRzKGNvbnN0IEludFJlY3QmIGNvbnRlbnRSZWN0KQogewotICAgIGlm IChtX3NraXBzRHJhdyB8fCBtX3JlcXVlc3RlZFVwZGF0ZVJlY3QuaXNFbXB0eSgpIHx8ICFtX3Rp bGVyLT5udW1UaWxlcygpIHx8IG1fcGFpbnRSZWN0LmlzRW1wdHkoKSkKKyAgICAvLyBJZiB0aGlz IGFzc2VydCBpcyBoaXQsIGl0IG1lYW5zIHRoYXQgcHJlcGFyZVRvVXBkYXRlSWZEaXJ0eSBoYXNu J3QgYmVlbgorICAgIC8vIGNhbGxlZCBvbiB0aGlzIGxheWVyLiBBbnkgbGF5ZXIgdGhhdCBpcyB1 cGRhdGVkIHNob3VsZCBiZSBwcmVwYXJlZCBmaXJzdC4KKyAgICBBU1NFUlQobV90aWxlcik7CisK KyAgICBpZiAobV9za2lwc0RyYXcgfHwgbV9yZXF1ZXN0ZWRVcGRhdGVSZWN0LmlzRW1wdHkoKSB8 fCAhbV90aWxlciB8fCAhbV90aWxlci0+bnVtVGlsZXMoKSB8fCBtX3BhaW50UmVjdC5pc0VtcHR5 KCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIC8vIENhbGxpbmcgcGFpbnRDb250ZW50cygpIGNh bGxzIGludG8gV2ViS2l0IHRvIHBhaW50LCB3aGljaCBtYXkgaGF2ZSB0aGUgc2lkZQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXll ckNocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L1ZpZGVvTGF5ZXJDaHJvbWl1bS5jcHAKaW5kZXggN2JlYzdjMC4uYTFhNDcwMyAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXllckNo cm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9WaWRlb0xheWVyQ2hyb21pdW0uY3BwCkBAIC00Nyw2ICs0Nyw3IEBAIG5hbWVzcGFjZSBXZWJD b3JlIHsKIFZpZGVvTGF5ZXJDaHJvbWl1bTo6VXBkYXRlclRleHR1cmU6OlVwZGF0ZXJUZXh0dXJl KFBhc3NPd25QdHI8TWFuYWdlZFRleHR1cmU+IHRleHR1cmUpCiAgICAgOiBtX3RleHR1cmUodGV4 dHVyZSkKICAgICAsIG1fbWFwcGVkQnVmZmVyKDApCisgICAgLCBtX2RhdGEoMCkKIHsKIH0KIApA QCAtNzAsMTQgKzcxLDE1IEBAIHZvaWQgVmlkZW9MYXllckNocm9taXVtOjpVcGRhdGVyVGV4dHVy ZTo6cHJlcGFyZVJlY3QoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsCiAgICAgbV90ZXh0dXJl LT5hbGxvY2F0ZVRleHR1cmUoY29udGV4dCwgYWxsb2NhdG9yKTsKIH0KIAotdm9pZCBWaWRlb0xh eWVyQ2hyb21pdW06OlVwZGF0ZXJUZXh0dXJlOjpkYXRhUmVjdChjb25zdCB2b2lkKiBkYXRhKQor dm9pZCBWaWRlb0xheWVyQ2hyb21pdW06OlVwZGF0ZXJUZXh0dXJlOjpwYWludENvbnRlbnRzUmVj dChjb25zdCBJbnRSZWN0JiAvKiBzb3VyY2VSZWN0ICovKQogewogICAgIHNpemVfdCBidWZmZXJT aXplID0gVGV4dHVyZU1hbmFnZXI6Om1lbW9yeVVzZUJ5dGVzKG1fdGV4dHVyZS0+c2l6ZSgpLCBt X3RleHR1cmUtPmZvcm1hdCgpKTsKIAorICAgIEFTU0VSVChtX2RhdGEpOwogICAgIGlmIChtX21h cHBlZEJ1ZmZlcikKLSAgICAgICAgbWVtY3B5KG1fbWFwcGVkQnVmZmVyLCBkYXRhLCBidWZmZXJT aXplKTsKKyAgICAgICAgbWVtY3B5KG1fbWFwcGVkQnVmZmVyLCBtX2RhdGEsIGJ1ZmZlclNpemUp OwogICAgIGVsc2UKLSAgICAgICAgbWVtY3B5KG1fYnVmZmVyLmdldCgpLCBkYXRhLCBidWZmZXJT aXplKTsKKyAgICAgICAgbWVtY3B5KG1fYnVmZmVyLmdldCgpLCBtX2RhdGEsIGJ1ZmZlclNpemUp OwogfQogCiB2b2lkIFZpZGVvTGF5ZXJDaHJvbWl1bTo6VXBkYXRlclRleHR1cmU6OnVwZGF0ZVJl Y3QoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIGNvbnN0IEludFJlY3QmIC8qIHNvdXJjZVJl Y3QgKi8sIGNvbnN0IEludFJlY3QmIC8qIGRlc3RSZWN0ICovKQpAQCAtMTMxLDIxICsxMzMsMTMg QEAgdm9pZCBWaWRlb0xheWVyQ2hyb21pdW06OmNsZWFudXBSZXNvdXJjZXMoKQogCiB2b2lkIFZp ZGVvTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRvVXBkYXRlSWZEaXJ0eSgpCiB7Ci0gICAgbV9mcmFt ZSA9IDA7CisgICAgQVNTRVJUKCFtX2ZyYW1lKTsKIAogICAgIGlmICghbV9kZWxlZ2F0ZSB8fCAh bV9wcm92aWRlciB8fCAhZHJhd3NDb250ZW50KCkpCiAgICAgICAgIHJldHVybjsKIAotICAgIGlm ICghbV9uZWVkc0Rpc3BsYXkgJiYgdGV4dHVyZXNWYWxpZCgpKSB7Ci0gICAgICAgIGZvciAodW5z aWduZWQgcGxhbmUgPSAwOyBwbGFuZSA8IG1fcGxhbmVzOyBwbGFuZSsrKSB7Ci0gICAgICAgICAg ICBNYW5hZ2VkVGV4dHVyZSogdGV4ID0gbV90ZXh0dXJlc1twbGFuZV0tPnRleHR1cmUoKTsKLSAg ICAgICAgICAgIGlmICghdGV4LT5yZXNlcnZlKHRleC0+c2l6ZSgpLCB0ZXgtPmZvcm1hdCgpKSkg ewotICAgICAgICAgICAgICAgIG1fc2tpcHNEcmF3ID0gdHJ1ZTsKLSAgICAgICAgICAgICAgICBi cmVhazsKLSAgICAgICAgICAgIH0KLSAgICAgICAgfQorICAgIGlmICghbV9uZWVkc0Rpc3BsYXkp CiAgICAgICAgIHJldHVybjsKLSAgICB9CiAKICAgICBtX3BsYW5lcyA9IDA7CiAgICAgbV9za2lw c0RyYXcgPSBmYWxzZTsKQEAgLTE1OCw3ICsxNTIsNyBAQCB2b2lkIFZpZGVvTGF5ZXJDaHJvbWl1 bTo6cHJlcGFyZVRvVXBkYXRlSWZEaXJ0eSgpCiAgICAgfQogCiAgICAgbV9mcmFtZUZvcm1hdCA9 IGZyYW1lLT5mb3JtYXQoKTsKLSAgICBHQzNEZW51bSB0ZXh0dXJlRm9ybWF0ID0gZGV0ZXJtaW5l VGV4dHVyZUZvcm1hdChmcmFtZSk7CisgICAgR0MzRGVudW0gdGV4dHVyZUZvcm1hdCA9IGRldGVy bWluZVRleHR1cmVGb3JtYXQobV9mcmFtZUZvcm1hdCk7CiAgICAgaWYgKHRleHR1cmVGb3JtYXQg PT0gR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfVkFMVUUpIHsKICAgICAgICAgLy8gRklYTUU6 IEltcGxlbWVudCBvdGhlciBwYXRocy4KICAgICAgICAgbm90SW1wbGVtZW50ZWQoKTsKQEAgLTE3 OSwxMiArMTczLDI2IEBAIHZvaWQgVmlkZW9MYXllckNocm9taXVtOjpwcmVwYXJlVG9VcGRhdGVJ ZkRpcnR5KCkKICAgICBpZiAoZnJhbWUtPnBsYW5lcygpID4gTWF4UGxhbmVzKQogICAgICAgICBD UkFTSCgpOwogCi0gICAgLy8gUmVzZXJ2ZSB0ZXh0dXJlcyBmb3IgcGxhbmVzIGlmIHRoZXkgYXJl IG5vdCByZXNlcnZlZCBhbHJlYWR5LgotICAgIGJvb2wgdGV4dHVyZXNSZXNlcnZlZCA9IHJlc2Vy dmVUZXh0dXJlcyhmcmFtZSwgdGV4dHVyZUZvcm1hdCk7Ci0gICAgaWYgKCF0ZXh0dXJlc1Jlc2Vy dmVkKSB7Ci0gICAgICAgIG1fc2tpcHNEcmF3ID0gdHJ1ZTsKLSAgICAgICAgbV9wcm92aWRlci0+ cHV0Q3VycmVudEZyYW1lKGZyYW1lKTsKLSAgICAgICAgcmV0dXJuOworICAgIGludCBtYXhUZXh0 dXJlU2l6ZSA9IGxheWVyVHJlZUhvc3QoKS0+bGF5ZXJSZW5kZXJlckNhcGFiaWxpdGllcygpLm1h eFRleHR1cmVTaXplOworCisgICAgZm9yICh1bnNpZ25lZCBwbGFuZSA9IDA7IHBsYW5lIDwgZnJh bWUtPnBsYW5lcygpOyBwbGFuZSsrKSB7CisgICAgICAgIEludFNpemUgcmVxdWlyZWRUZXh0dXJl U2l6ZSA9IGZyYW1lLT5yZXF1aXJlZFRleHR1cmVTaXplKHBsYW5lKTsKKworICAgICAgICAvLyBJ ZiB0aGUgcmVuZGVyZXIgY2Fubm90IGhhbmRsZSB0aGlzIGxhcmdlIG9mIGEgdGV4dHVyZSwgc2tp cCBkcmF3LgorICAgICAgICAvLyBGSVhNRTogUmVtb3ZlIHRoaXMgdGVzdCB3aGVuIHRpbGVkIGxh eWVycyBhcmUgaW1wbGVtZW50ZWQuCisgICAgICAgIGlmIChyZXF1aXJlZFRleHR1cmVTaXplLmlz WmVybygpIHx8IHJlcXVpcmVkVGV4dHVyZVNpemUud2lkdGgoKSA+IG1heFRleHR1cmVTaXplIHx8 IHJlcXVpcmVkVGV4dHVyZVNpemUuaGVpZ2h0KCkgPiBtYXhUZXh0dXJlU2l6ZSkgeworICAgICAg ICAgICAgbV9za2lwc0RyYXcgPSB0cnVlOworICAgICAgICAgICAgbV9wcm92aWRlci0+cHV0Q3Vy cmVudEZyYW1lKGZyYW1lKTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorCisgICAg ICAgIGlmIChtX3RleHR1cmVzW3BsYW5lXS0+dGV4dHVyZSgpLT5zaXplKCkgIT0gcmVxdWlyZWRU ZXh0dXJlU2l6ZSkgeworICAgICAgICAgICAgSW50U2l6ZSB2aXNpYmxlU2l6ZSA9IGNvbXB1dGVW aXNpYmxlU2l6ZShmcmFtZSwgcGxhbmUpOworICAgICAgICAgICAgbV90ZXh0dXJlc1twbGFuZV0t PnNldFZpc2libGVTaXplKHZpc2libGVTaXplKTsKKyAgICAgICAgfQorCisgICAgICAgIG1fdGV4 dHVyZXNbcGxhbmVdLT5zZXRSZXF1aXJlZFRleHR1cmVTaXplKHJlcXVpcmVkVGV4dHVyZVNpemUp OworICAgICAgICBtX3RleHR1cmVzW3BsYW5lXS0+c2V0RGF0YShmcmFtZS0+ZGF0YShwbGFuZSkp OwogICAgIH0KIAogICAgIG1fZnJhbWUgPSBmcmFtZTsKQEAgLTE5NCwyNSArMjAyLDQ5IEBAIHZv aWQgVmlkZW9MYXllckNocm9taXVtOjpwcmVwYXJlVG9VcGRhdGVJZkRpcnR5KCkKICAgICBtX25l ZWRzRGlzcGxheSA9IGZhbHNlOwogfQogCi12b2lkIFZpZGVvTGF5ZXJDaHJvbWl1bTo6cGFpbnRD b250ZW50c0lmRGlydHkoKQordm9pZCBWaWRlb0xheWVyQ2hyb21pdW06OnByb3RlY3RUZXh0dXJl cygpCiB7Ci0gICAgaWYgKCFtX2ZyYW1lKQorICAgIEdDM0RlbnVtIHRleHR1cmVGb3JtYXQgPSBk ZXRlcm1pbmVUZXh0dXJlRm9ybWF0KG1fZnJhbWVGb3JtYXQpOworCisgICAgaWYgKHRleHR1cmVG b3JtYXQgPT0gR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQgfHwgdGV4dHVyZUZvcm1hdCA9 PSBHcmFwaGljc0NvbnRleHQzRDo6SU5WQUxJRF9WQUxVRSkKICAgICAgICAgcmV0dXJuOwogCi0g ICAgLy8gQ29weSBwbGFuZXMgdG8gbWFwcGVkIGJ1ZmZlcnMuCi0gICAgZm9yICh1bnNpZ25lZCBw bGFuZSA9IDA7IHBsYW5lIDwgbV9mcmFtZS0+cGxhbmVzKCk7IHBsYW5lKyspCi0gICAgICAgIG1f dGV4dHVyZXNbcGxhbmVdLT5kYXRhUmVjdChtX2ZyYW1lLT5kYXRhKHBsYW5lKSk7CisgICAgaWYg KG1fc2tpcHNEcmF3KQorICAgICAgICByZXR1cm47CisKKyAgICBmb3IgKHVuc2lnbmVkIHBsYW5l ID0gMDsgcGxhbmUgPCBtX3BsYW5lczsgcGxhbmUrKykgeworICAgICAgICBNYW5hZ2VkVGV4dHVy ZSAqdGV4dHVyZSA9IG1fdGV4dHVyZXNbcGxhbmVdLT50ZXh0dXJlKCk7CisgICAgICAgIEludFNp emUgc2l6ZSA9IG1fdGV4dHVyZXNbcGxhbmVdLT5yZXF1aXJlZFRleHR1cmVTaXplKCk7CisKKyAg ICAgICAgaWYgKHRleHR1cmUtPmlzUmVzZXJ2ZWQoKSkKKyAgICAgICAgICAgIGNvbnRpbnVlOwog Ci0gICAgbV9wcm92aWRlci0+cHV0Q3VycmVudEZyYW1lKG1fZnJhbWUpOworICAgICAgICBpZiAo IXRleHR1cmUtPnJlc2VydmUoc2l6ZSwgdGV4dHVyZUZvcm1hdCkpIHsKKyAgICAgICAgICAgIG1f c2tpcHNEcmF3ID0gdHJ1ZTsKKyAgICAgICAgICAgIHJldHVybjsKKyAgICAgICAgfQorICAgIH0K IH0KIAotdm9pZCBWaWRlb0xheWVyQ2hyb21pdW06OmZvckVhY2hDb21wb3NpdG9yUmVzb3VyY2Uo TGF5ZXJUZXh0dXJlVXBkYXRlcjo6SGFuZGxlciYgaGFuZGxlcikKK3ZvaWQgVmlkZW9MYXllckNo cm9taXVtOjpmaW5pc2hVcGRhdGUoKQogewotICAgIGlmICghbV9mcmFtZSkKLSAgICAgICAgcmV0 dXJuOworICAgIGlmIChtX2ZyYW1lKSB7CisgICAgICAgIGZvciAodW5zaWduZWQgcGxhbmUgPSAw OyBwbGFuZSA8IG1fcGxhbmVzOyBwbGFuZSsrKQorICAgICAgICAgICAgbV90ZXh0dXJlc1twbGFu ZV0tPnJlc2V0RGF0YSgpOworCisgICAgICAgIG1fcHJvdmlkZXItPnB1dEN1cnJlbnRGcmFtZSht X2ZyYW1lKTsKKyAgICAgICAgbV9mcmFtZSA9IDA7CisgICAgfQorfQogCit2b2lkIFZpZGVvTGF5 ZXJDaHJvbWl1bTo6Zm9yRWFjaENvbXBvc2l0b3JSZXNvdXJjZShMYXllclRleHR1cmVVcGRhdGVy OjpIYW5kbGVyJiBoYW5kbGVyKQorewogICAgIGZvciAodW5zaWduZWQgcGxhbmUgPSAwOyBwbGFu ZSA8IG1fcGxhbmVzOyBwbGFuZSsrKSB7Ci0gICAgICAgIEludFJlY3QgcmVjdChJbnRQb2ludCgp LCBtX3RleHR1cmVzW3BsYW5lXS0+dmlzaWJsZVNpemUoKSk7CisgICAgICAgIEludFJlY3QgcmVj dDsKKworICAgICAgICBpZiAobV9mcmFtZSkKKyAgICAgICAgICAgIHJlY3QgPSBJbnRSZWN0KElu dFBvaW50KCksIG1fdGV4dHVyZXNbcGxhbmVdLT52aXNpYmxlU2l6ZSgpKTsKKwogICAgICAgICBo YW5kbGVyLmhhbmRsZShtX3RleHR1cmVzW3BsYW5lXS5nZXQoKSwgcmVjdCwgcmVjdCk7CiAgICAg fQogfQpAQCAtMjQ3LDkgKzI3OSw5IEBAIHZvaWQgVmlkZW9MYXllckNocm9taXVtOjpzZXRMYXll clRyZWVIb3N0KENDTGF5ZXJUcmVlSG9zdCogaG9zdCkKICAgICBMYXllckNocm9taXVtOjpzZXRM YXllclRyZWVIb3N0KGhvc3QpOwogfQogCi1HQzNEZW51bSBWaWRlb0xheWVyQ2hyb21pdW06OmRl dGVybWluZVRleHR1cmVGb3JtYXQoY29uc3QgVmlkZW9GcmFtZUNocm9taXVtKiBmcmFtZSkKK0dD M0RlbnVtIFZpZGVvTGF5ZXJDaHJvbWl1bTo6ZGV0ZXJtaW5lVGV4dHVyZUZvcm1hdChWaWRlb0Zy YW1lQ2hyb21pdW06OkZvcm1hdCBmcmFtZUZvcm1hdCkKIHsKLSAgICBzd2l0Y2ggKGZyYW1lLT5m b3JtYXQoKSkgeworICAgIHN3aXRjaCAoZnJhbWVGb3JtYXQpIHsKICAgICBjYXNlIFZpZGVvRnJh bWVDaHJvbWl1bTo6WVYxMjoKICAgICBjYXNlIFZpZGVvRnJhbWVDaHJvbWl1bTo6WVYxNjoKICAg ICAgICAgcmV0dXJuIEdyYXBoaWNzQ29udGV4dDNEOjpMVU1JTkFOQ0U7CkBAIC0yNjMsNDcgKzI5 NSw2IEBAIEdDM0RlbnVtIFZpZGVvTGF5ZXJDaHJvbWl1bTo6ZGV0ZXJtaW5lVGV4dHVyZUZvcm1h dChjb25zdCBWaWRlb0ZyYW1lQ2hyb21pdW0qIGZyCiAgICAgcmV0dXJuIEdyYXBoaWNzQ29udGV4 dDNEOjpJTlZBTElEX1ZBTFVFOwogfQogCi1ib29sIFZpZGVvTGF5ZXJDaHJvbWl1bTo6dGV4dHVy ZXNWYWxpZCgpCi17Ci0gICAgQVNTRVJUKGxheWVyVHJlZUhvc3QoKSk7Ci0KLSAgICBmb3IgKHVu c2lnbmVkIHBsYW5lID0gMDsgcGxhbmUgPCBtX3BsYW5lczsgcGxhbmUrKykgewotICAgICAgICBN YW5hZ2VkVGV4dHVyZSogdGV4ID0gbV90ZXh0dXJlc1twbGFuZV0tPnRleHR1cmUoKTsKLSAgICAg ICAgaWYgKCF0ZXgtPmlzVmFsaWQodGV4LT5zaXplKCksIHRleC0+Zm9ybWF0KCkpKQotICAgICAg ICAgICAgcmV0dXJuIGZhbHNlOwotICAgIH0KLSAgICByZXR1cm4gdHJ1ZTsKLX0KLQotYm9vbCBW aWRlb0xheWVyQ2hyb21pdW06OnJlc2VydmVUZXh0dXJlcyhjb25zdCBWaWRlb0ZyYW1lQ2hyb21p dW0qIGZyYW1lLCBHQzNEZW51bSB0ZXh0dXJlRm9ybWF0KQotewotICAgIEFTU0VSVChsYXllclRy ZWVIb3N0KCkpOwotICAgIEFTU0VSVChmcmFtZSk7Ci0gICAgQVNTRVJUKHRleHR1cmVGb3JtYXQg IT0gR3JhcGhpY3NDb250ZXh0M0Q6OklOVkFMSURfVkFMVUUpOwotCi0gICAgaW50IG1heFRleHR1 cmVTaXplID0gbGF5ZXJUcmVlSG9zdCgpLT5sYXllclJlbmRlcmVyQ2FwYWJpbGl0aWVzKCkubWF4 VGV4dHVyZVNpemU7Ci0KLSAgICBmb3IgKHVuc2lnbmVkIHBsYW5lID0gMDsgcGxhbmUgPCBmcmFt ZS0+cGxhbmVzKCk7IHBsYW5lKyspIHsKLSAgICAgICAgSW50U2l6ZSByZXF1aXJlZFRleHR1cmVT aXplID0gZnJhbWUtPnJlcXVpcmVkVGV4dHVyZVNpemUocGxhbmUpOwotICAgICAgICBBU1NFUlQo bV90ZXh0dXJlc1twbGFuZV0pOwotICAgICAgICBBU1NFUlQobV90ZXh0dXJlc1twbGFuZV0tPnRl eHR1cmUoKSk7Ci0KLSAgICAgICAgLy8gSWYgdGhlIHJlbmRlcmVyIGNhbm5vdCBoYW5kbGUgdGhp cyBsYXJnZSBvZiBhIHRleHR1cmUsIHJldHVybiBmYWxzZS4KLSAgICAgICAgLy8gRklYTUU6IFJl bW92ZSB0aGlzIHRlc3Qgd2hlbiB0aWxlZCBsYXllcnMgYXJlIGltcGxlbWVudGVkLgotICAgICAg ICBpZiAocmVxdWlyZWRUZXh0dXJlU2l6ZS5pc1plcm8oKSB8fCByZXF1aXJlZFRleHR1cmVTaXpl LndpZHRoKCkgPiBtYXhUZXh0dXJlU2l6ZSB8fCByZXF1aXJlZFRleHR1cmVTaXplLmhlaWdodCgp ID4gbWF4VGV4dHVyZVNpemUpCi0gICAgICAgICAgICByZXR1cm4gZmFsc2U7Ci0KLSAgICAgICAg aWYgKG1fdGV4dHVyZXNbcGxhbmVdLT50ZXh0dXJlKCktPnNpemUoKSAhPSByZXF1aXJlZFRleHR1 cmVTaXplKSB7Ci0gICAgICAgICAgICBJbnRTaXplIHZpc2libGVTaXplID0gY29tcHV0ZVZpc2li bGVTaXplKGZyYW1lLCBwbGFuZSk7Ci0gICAgICAgICAgICBtX3RleHR1cmVzW3BsYW5lXS0+c2V0 VmlzaWJsZVNpemUodmlzaWJsZVNpemUpOwotICAgICAgICB9Ci0KLSAgICAgICAgbV90ZXh0dXJl c1twbGFuZV0tPnRleHR1cmUoKS0+cmVzZXJ2ZShyZXF1aXJlZFRleHR1cmVTaXplLCB0ZXh0dXJl Rm9ybWF0KTsKLSAgICB9Ci0KLSAgICByZXR1cm4gdHJ1ZTsKLX0KLQogSW50U2l6ZSBWaWRlb0xh eWVyQ2hyb21pdW06OmNvbXB1dGVWaXNpYmxlU2l6ZShjb25zdCBWaWRlb0ZyYW1lQ2hyb21pdW0q IGZyYW1lLCB1bnNpZ25lZCBwbGFuZSkKIHsKICAgICBpbnQgdmlzaWJsZVdpZHRoID0gZnJhbWUt PndpZHRoKHBsYW5lKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1ZpZGVvTGF5ZXJDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXllckNocm9taXVtLmgKaW5kZXggMzUxZjhmOC4u MDgyYjk0NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vVmlkZW9MYXllckNocm9taXVtLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vVmlkZW9MYXllckNocm9taXVtLmgKQEAgLTU2LDE5ICs1NiwyNyBA QCBwdWJsaWM6CiAKICAgICAgICAgdmlydHVhbCBib29sIG5lZWRQcmVwYXJlUmVjdCgpIHsgcmV0 dXJuIHRydWU7IH0KICAgICAgICAgdmlydHVhbCB2b2lkIHByZXBhcmVSZWN0KEdyYXBoaWNzQ29u dGV4dDNEKiwgVGV4dHVyZUFsbG9jYXRvciosIGNvbnN0IEludFJlY3QmIHNvdXJjZVJlY3QsIGNv bnN0IEludFJlY3QmIGRlc3RSZWN0KTsKLSAgICAgICAgdm9pZCBkYXRhUmVjdChjb25zdCB2b2lk Kik7CisgICAgICAgIHZpcnR1YWwgdm9pZCBwYWludENvbnRlbnRzUmVjdChjb25zdCBJbnRSZWN0 JiBzb3VyY2VSZWN0KTsKICAgICAgICAgdmlydHVhbCB2b2lkIHVwZGF0ZVJlY3QoR3JhcGhpY3ND b250ZXh0M0QqLCBjb25zdCBJbnRSZWN0JiBzb3VyY2VSZWN0LCBjb25zdCBJbnRSZWN0JiBkZXN0 UmVjdCk7CiAKICAgICAgICAgdm9pZCBzZXRWaXNpYmxlU2l6ZShJbnRTaXplJiBzaXplKSB7IG1f dmlzaWJsZVNpemUgPSBzaXplOyB9CiAgICAgICAgIEludFNpemUmIHZpc2libGVTaXplKCkgeyBy ZXR1cm4gbV92aXNpYmxlU2l6ZTsgfQogCisgICAgICAgIHZvaWQgc2V0UmVxdWlyZWRUZXh0dXJl U2l6ZShJbnRTaXplJiBzaXplKSB7IG1fcmVxdWlyZWRUZXh0dXJlU2l6ZSA9IHNpemU7IH0KKyAg ICAgICAgSW50U2l6ZSYgcmVxdWlyZWRUZXh0dXJlU2l6ZSgpIHsgcmV0dXJuIG1fcmVxdWlyZWRU ZXh0dXJlU2l6ZTsgfQorCisgICAgICAgIHZvaWQgc2V0RGF0YShjb25zdCB2b2lkKiBkYXRhKSB7 IG1fZGF0YSA9IGRhdGE7IH0KKyAgICAgICAgdm9pZCByZXNldERhdGEoKSB7IG1fZGF0YSA9IDA7 IH0KKwogICAgIHByaXZhdGU6CiAgICAgICAgIGV4cGxpY2l0IFVwZGF0ZXJUZXh0dXJlKFBhc3NP d25QdHI8TWFuYWdlZFRleHR1cmU+KTsKIAogICAgICAgICBPd25QdHI8TWFuYWdlZFRleHR1cmU+ IG1fdGV4dHVyZTsKKyAgICAgICAgSW50U2l6ZSBtX3JlcXVpcmVkVGV4dHVyZVNpemU7CiAgICAg ICAgIEludFNpemUgbV92aXNpYmxlU2l6ZTsKICAgICAgICAgdWludDhfdCogbV9tYXBwZWRCdWZm ZXI7CiAgICAgICAgIE93bkFycmF5UHRyPHVpbnQ4X3Q+IG1fYnVmZmVyOworICAgICAgICBjb25z dCB2b2lkKiBtX2RhdGE7CiAgICAgfTsKIAogICAgIHN0YXRpYyBQYXNzUmVmUHRyPFZpZGVvTGF5 ZXJDaHJvbWl1bT4gY3JlYXRlKENDTGF5ZXJEZWxlZ2F0ZSogPSAwLApAQCAtNzgsNyArODYsOCBA QCBwdWJsaWM6CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPENDTGF5ZXJJbXBsPiBjcmVhdGVDQ0xh eWVySW1wbCgpOwogCiAgICAgdmlydHVhbCB2b2lkIHByZXBhcmVUb1VwZGF0ZUlmRGlydHkoKTsK LSAgICB2aXJ0dWFsIHZvaWQgcGFpbnRDb250ZW50c0lmRGlydHkoKTsKKyAgICB2aXJ0dWFsIHZv aWQgcHJvdGVjdFRleHR1cmVzKCk7CisgICAgdmlydHVhbCB2b2lkIGZpbmlzaFVwZGF0ZSgpOwog ICAgIHZpcnR1YWwgdm9pZCBmb3JFYWNoQ29tcG9zaXRvclJlc291cmNlKExheWVyVGV4dHVyZVVw ZGF0ZXI6OkhhbmRsZXImKTsKICAgICB2aXJ0dWFsIGJvb2wgZHJhd3NDb250ZW50KCkgY29uc3Qg eyByZXR1cm4gdHJ1ZTsgfQogCkBAIC05NCwxMiArMTAzLDggQEAgcHJvdGVjdGVkOgogcHJpdmF0 ZToKICAgICBWaWRlb0xheWVyQ2hyb21pdW0oQ0NMYXllckRlbGVnYXRlKiwgVmlkZW9GcmFtZVBy b3ZpZGVyKik7CiAKLSAgICBzdGF0aWMgR0MzRGVudW0gZGV0ZXJtaW5lVGV4dHVyZUZvcm1hdChj b25zdCBWaWRlb0ZyYW1lQ2hyb21pdW0qKTsKKyAgICBzdGF0aWMgR0MzRGVudW0gZGV0ZXJtaW5l VGV4dHVyZUZvcm1hdChWaWRlb0ZyYW1lQ2hyb21pdW06OkZvcm1hdCk7CiAgICAgc3RhdGljIElu dFNpemUgY29tcHV0ZVZpc2libGVTaXplKGNvbnN0IFZpZGVvRnJhbWVDaHJvbWl1bSosIHVuc2ln bmVkIHBsYW5lKTsKLSAgICBib29sIHRleHR1cmVzVmFsaWQoKTsKLSAgICBib29sIHJlc2VydmVU ZXh0dXJlcyhjb25zdCBWaWRlb0ZyYW1lQ2hyb21pdW0qLCBHQzNEZW51bSB0ZXh0dXJlRm9ybWF0 KTsKLQotICAgIHZvaWQgcmVzZXRGcmFtZVBhcmFtZXRlcnMoKTsKIAogICAgIGJvb2wgbV9za2lw c0RyYXc7CiAgICAgVmlkZW9GcmFtZUNocm9taXVtOjpGb3JtYXQgbV9mcmFtZUZvcm1hdDsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1dlYkdM TGF5ZXJDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9XZWJHTExheWVyQ2hyb21pdW0uY3BwCmluZGV4IDNmNGIwNWIuLmYzOWQzZGMgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1dlYkdMTGF5 ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vV2ViR0xMYXllckNocm9taXVtLmNwcApAQCAtMTEzLDcgKzExMyw4IEBAIHZvaWQgV2Vi R0xMYXllckNocm9taXVtOjp1cGRhdGVDb21wb3NpdG9yUmVzb3VyY2VzKEdyYXBoaWNzQ29udGV4 dDNEKiByZW5kZXJlckNvCiAKIHZvaWQgV2ViR0xMYXllckNocm9taXVtOjpmb3JFYWNoQ29tcG9z aXRvclJlc291cmNlKExheWVyVGV4dHVyZVVwZGF0ZXI6OkhhbmRsZXImIGhhbmRsZXIpCiB7Ci0g ICAgaGFuZGxlci5oYW5kbGUobV91cGRhdGVyVGV4dHVyZS5nZXQoKSwgSW50UmVjdCgpLCBJbnRS ZWN0KCkpOworICAgIEludFJlY3Qgbm9uRW1wdHlSZWN0KDAsIDAsIDEsIDEpOworICAgIGhhbmRs ZXIuaGFuZGxlKG1fdXBkYXRlclRleHR1cmUuZ2V0KCksIG5vbkVtcHR5UmVjdCwgbm9uRW1wdHlS ZWN0KTsKIH0KIAogYm9vbCBXZWJHTExheWVyQ2hyb21pdW06OnBhaW50UmVuZGVyZWRSZXN1bHRz VG9DYW52YXMoSW1hZ2VCdWZmZXIqIGltYWdlQnVmZmVyKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcCBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVl SG9zdC5jcHAKaW5kZXggYzY1ODQ1Mi4uM2QzMDdiYyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJl ZUhvc3QuY3BwCkBAIC01OCw4ICs1OCwxMSBAQCBDQ0xheWVyVHJlZUhvc3Q6Ok5lZWRSZXNvdXJj ZUhhbmRsZXI6On5OZWVkUmVzb3VyY2VIYW5kbGVyKCkKIHsKIH0KIAotdm9pZCBDQ0xheWVyVHJl ZUhvc3Q6Ok5lZWRSZXNvdXJjZUhhbmRsZXI6OmhhbmRsZShMYXllclRleHR1cmVVcGRhdGVyOjpU ZXh0dXJlKiB0ZXh0dXJlLCBjb25zdCBJbnRSZWN0JiAvKiBzb3VyY2VSZWN0ICovLCBjb25zdCBJ bnRSZWN0JiAvKiBkZXN0UmVjdCAqLykKK3ZvaWQgQ0NMYXllclRyZWVIb3N0OjpOZWVkUmVzb3Vy Y2VIYW5kbGVyOjpoYW5kbGUoTGF5ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZSogdGV4dHVyZSwg Y29uc3QgSW50UmVjdCYgLyogc291cmNlUmVjdCAqLywgY29uc3QgSW50UmVjdCYgZGVzdFJlY3Qp CiB7CisgICAgaWYgKGRlc3RSZWN0LmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuOworCiAgICAg aWYgKHRleHR1cmUtPm5lZWRQcmVwYXJlUmVjdCgpKQogICAgICAgICBtX3Jlc291cmNlcysrOwog fQpAQCAtNzYsNiArNzksOSBAQCBDQ0xheWVyVHJlZUhvc3Q6OlByZXBhcmVSZXNvdXJjZUhhbmRs ZXI6On5QcmVwYXJlUmVzb3VyY2VIYW5kbGVyKCkKIAogdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OlBy ZXBhcmVSZXNvdXJjZUhhbmRsZXI6OmhhbmRsZShMYXllclRleHR1cmVVcGRhdGVyOjpUZXh0dXJl KiB0ZXh0dXJlLCBjb25zdCBJbnRSZWN0JiBzb3VyY2VSZWN0LCBjb25zdCBJbnRSZWN0JiBkZXN0 UmVjdCkKIHsKKyAgICBpZiAoZGVzdFJlY3QuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisK ICAgICBpZiAodGV4dHVyZS0+bmVlZFByZXBhcmVSZWN0KCkpCiAgICAgICAgIHRleHR1cmUtPnBy ZXBhcmVSZWN0KG1fY29udGV4dCwgbV9hbGxvY2F0b3IsIHNvdXJjZVJlY3QsIGRlc3RSZWN0KTsK IH0KQEAgLTkxLDEwICs5NywzMiBAQCBDQ0xheWVyVHJlZUhvc3Q6OlBhaW50SGFuZGxlcjo6flBh aW50SGFuZGxlcigpCiAKIHZvaWQgQ0NMYXllclRyZWVIb3N0OjpQYWludEhhbmRsZXI6OmhhbmRs ZShMYXllclRleHR1cmVVcGRhdGVyOjpUZXh0dXJlKiB0ZXh0dXJlLCBjb25zdCBJbnRSZWN0JiBz b3VyY2VSZWN0LCBjb25zdCBJbnRSZWN0JiBkZXN0UmVjdCkKIHsKKyAgICBpZiAoZGVzdFJlY3Qu aXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisKICAgICB0ZXh0dXJlLT5wYWludENvbnRlbnRz UmVjdChzb3VyY2VSZWN0KTsKICAgICBtX3Byb3h5LT51cGRhdGUodGV4dHVyZSwgc291cmNlUmVj dCwgZGVzdFJlY3QpOwogfQogCitDQ0xheWVyVHJlZUhvc3Q6OlN0ZWFsVGV4dHVyZUhhbmRsZXI6 OlN0ZWFsVGV4dHVyZUhhbmRsZXIoVGV4dHVyZU1hbmFnZXIqIG1hbmFnZXIsIFRleHR1cmVMaXN0 KiBsaXN0KQorICAgIDogbV90ZXh0dXJlTWFuYWdlcihtYW5hZ2VyKQorICAgICwgbV9saXN0KGxp c3QpCit7Cit9CisKK0NDTGF5ZXJUcmVlSG9zdDo6U3RlYWxUZXh0dXJlSGFuZGxlcjo6flN0ZWFs VGV4dHVyZUhhbmRsZXIoKQoreworfQorCit2b2lkIENDTGF5ZXJUcmVlSG9zdDo6U3RlYWxUZXh0 dXJlSGFuZGxlcjo6aGFuZGxlKExheWVyVGV4dHVyZVVwZGF0ZXI6OlRleHR1cmUqIHRleHR1cmUs IGNvbnN0IEludFJlY3QmIC8qIHNvdXJjZVJlY3QgKi8sIGNvbnN0IEludFJlY3QmIGRlc3RSZWN0 KQoreworICAgIGlmIChkZXN0UmVjdC5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybjsKKworICAg IGlmICh0ZXh0dXJlLT50ZXh0dXJlKCkpCisgICAgICAgIG1fbGlzdC0+YXBwZW5kKHRleHR1cmUt PnRleHR1cmUoKS0+c3RlYWwoKSk7Cit9CisKIFBhc3NSZWZQdHI8Q0NMYXllclRyZWVIb3N0PiBD Q0xheWVyVHJlZUhvc3Q6OmNyZWF0ZShDQ0xheWVyVHJlZUhvc3RDbGllbnQqIGNsaWVudCwgY29u c3QgQ0NTZXR0aW5ncyYgc2V0dGluZ3MpCiB7CiAgICAgUmVmUHRyPENDTGF5ZXJUcmVlSG9zdD4g bGF5ZXJUcmVlSG9zdCA9IGFkb3B0UmVmKG5ldyBDQ0xheWVyVHJlZUhvc3QoY2xpZW50LCBzZXR0 aW5ncykpOwpAQCAtMjA2LDcgKzIzNCw2IEBAIHZvaWQgQ0NMYXllclRyZWVIb3N0OjpmaW5pc2hD b21taXRPbkltcGxUaHJlYWQoQ0NMYXllclRyZWVIb3N0SW1wbCogaG9zdEltcGwpCiB2b2lkIEND TGF5ZXJUcmVlSG9zdDo6Y29tbWl0Q29tcGxldGUoKQogewogICAgIGNsZWFyUGVuZGluZ1VwZGF0 ZSgpOwotICAgIG1fY29udGVudHNUZXh0dXJlTWFuYWdlci0+dW5wcm90ZWN0QWxsVGV4dHVyZXMo KTsKIH0KIAogUGFzc1JlZlB0cjxHcmFwaGljc0NvbnRleHQzRD4gQ0NMYXllclRyZWVIb3N0Ojpj cmVhdGVMYXllclRyZWVIb3N0Q29udGV4dDNEKCkKQEAgLTQwNSw2ICs0MzIsMjcgQEAgdm9pZCBD Q0xheWVyVHJlZUhvc3Q6OnByZXBhcmVUb1VwZGF0ZShMYXllckNocm9taXVtKiByb290TGF5ZXIp CiAgICAgfQogfQogCit2b2lkIENDTGF5ZXJUcmVlSG9zdDo6cHJvdGVjdFRleHR1cmVzKCkKK3sK KyAgICBpZiAoIXJvb3RMYXllcigpKQorICAgICAgICByZXR1cm47CisKKyAgICBpZiAodmlld3Bv cnRTaXplKCkuaXNFbXB0eSgpKQorICAgICAgICByZXR1cm47CisKKyAgICBwcm90ZWN0VGV4dHVy ZXMocm9vdExheWVyKCkpOworfQorCit2b2lkIENDTGF5ZXJUcmVlSG9zdDo6cHJvdGVjdFRleHR1 cmVzKExheWVyQ2hyb21pdW0qIHJvb3RMYXllcikKK3sKKyAgICBUUkFDRV9FVkVOVCgiQ0NMYXll clRyZWVIb3N0Ojpwcm90ZWN0VGV4dHVyZXMiLCB0aGlzLCAwKTsKKworICAgIGZvciAoaW50IGxh eWVySW5kZXggPSBtX2xheWVyVXBkYXRlTGlzdC5zaXplKCkgLSAxOyBsYXllckluZGV4ID49IDAg OyAtLWxheWVySW5kZXgpIHsKKyAgICAgICAgTGF5ZXJDaHJvbWl1bSogbGF5ZXIgPSBtX2xheWVy VXBkYXRlTGlzdFtsYXllckluZGV4XS5nZXQoKTsKKyAgICAgICAgbGF5ZXItPnByb3RlY3RUZXh0 dXJlcygpOworICAgIH0KK30KKwogYm9vbCBDQ0xheWVyVHJlZUhvc3Q6Om5lZWRzQ29tcG9zaXRv clJlc291cmNlcygpCiB7CiAgICAgTmVlZFJlc291cmNlSGFuZGxlciBoYW5kbGVyOwpAQCAtNDE5 LDcgKzQ2Nyw3IEBAIHZvaWQgQ0NMYXllclRyZWVIb3N0OjpwcmVwYXJlQ29tcG9zaXRvclJlc291 cmNlcyhHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgVGV4CiAgICAgZm9yRWFjaENvbXBvc2l0 b3JSZXNvdXJjZShoYW5kbGVyKTsKIH0KIAotdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnBhaW50Q29u dGVudHMoKQordm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnVwZGF0ZUNvbnRlbnRzKCkKIHsKICAgICBp ZiAoIXJvb3RMYXllcigpKQogICAgICAgICByZXR1cm47CkBAIC00MjcsMjIgKzQ3NSwyOCBAQCB2 b2lkIENDTGF5ZXJUcmVlSG9zdDo6cGFpbnRDb250ZW50cygpCiAgICAgaWYgKHZpZXdwb3J0U2l6 ZSgpLmlzRW1wdHkoKSkKICAgICAgICAgcmV0dXJuOwogCi0gICAgcGFpbnRDb250ZW50cyhyb290 TGF5ZXIoKSk7CisgICAgdXBkYXRlQ29udGVudHMocm9vdExheWVyKCkpOwogfQogCi12b2lkIEND TGF5ZXJUcmVlSG9zdDo6cGFpbnRDb250ZW50cyhMYXllckNocm9taXVtKiByb290TGF5ZXIpCit2 b2lkIENDTGF5ZXJUcmVlSG9zdDo6dXBkYXRlQ29udGVudHMoTGF5ZXJDaHJvbWl1bSogcm9vdExh eWVyKQogewotICAgIFRSQUNFX0VWRU5UKCJDQ0xheWVyVHJlZUhvc3Q6OnBhaW50Q29udGVudHMi LCB0aGlzLCAwKTsKKyAgICBUUkFDRV9FVkVOVCgiQ0NMYXllclRyZWVIb3N0Ojp1cGRhdGVDb250 ZW50cyIsIHRoaXMsIDApOwogCiAgICAgZm9yIChpbnQgbGF5ZXJJbmRleCA9IG1fbGF5ZXJVcGRh dGVMaXN0LnNpemUoKSAtIDE7IGxheWVySW5kZXggPj0gMCA7IC0tbGF5ZXJJbmRleCkgeworICAg ICAgICBQYWludEhhbmRsZXIgaGFuZGxlcihtX3Byb3h5LmdldCgpKTsKICAgICAgICAgTGF5ZXJD aHJvbWl1bSogbGF5ZXIgPSBtX2xheWVyVXBkYXRlTGlzdFtsYXllckluZGV4XS5nZXQoKTsKICAg ICAgICAgbGF5ZXItPnBhaW50Q29udGVudHNJZkRpcnR5KCk7Ci0KLSAgICAgICAgUGFpbnRIYW5k bGVyIGhhbmRsZXIobV9wcm94eS5nZXQoKSk7CiAgICAgICAgIGxheWVyLT5mb3JFYWNoQ29tcG9z aXRvclJlc291cmNlKGhhbmRsZXIpOworICAgICAgICBsYXllci0+ZmluaXNoVXBkYXRlKCk7CiAg ICAgfQogfQogCit2b2lkIENDTGF5ZXJUcmVlSG9zdDo6c3RlYWxUZXh0dXJlcyhUZXh0dXJlTGlz dCYgbGlzdCkKK3sKKyAgICBTdGVhbFRleHR1cmVIYW5kbGVyIGhhbmRsZXIoY29udGVudHNUZXh0 dXJlTWFuYWdlcigpLCAmbGlzdCk7CisgICAgZm9yRWFjaENvbXBvc2l0b3JSZXNvdXJjZShoYW5k bGVyKTsKK30KKwogdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OmFwcGVuZFZpc2libGVMYXllcihMYXll ckNocm9taXVtKiBsYXllciwgTGF5ZXJMaXN0JiB1cGRhdGVMaXN0KQogewogICAgIC8vIEZvciBu b3JtYWwgbGF5ZXJzLCB0aGVzZSBjb25kaXRpb25zIHNob3VsZCBoYXZlIGFscmVhZHkgYmVlbiBj aGVja2VkIHdoaWxlIGNyZWF0aW5nIHRoZSByZW5kZXIgc3VyZmFjZSBsYXllciBsaXN0cy4KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND TGF5ZXJUcmVlSG9zdC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vY2MvQ0NMYXllclRyZWVIb3N0LmgKaW5kZXggYzMyZTIxMC4uYWZkMzgyNCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRy ZWVIb3N0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Y2MvQ0NMYXllclRyZWVIb3N0LmgKQEAgLTE4OCw5ICsxODgsMTMgQEAgcHVibGljOgogICAgIHZv aWQgc2V0SGF2ZVdoZWVsRXZlbnRIYW5kbGVycyhib29sKTsKIAogICAgIHZvaWQgcHJlcGFyZVRv VXBkYXRlKCk7CisgICAgdm9pZCBwcm90ZWN0VGV4dHVyZXMoKTsKICAgICBib29sIG5lZWRzQ29t cG9zaXRvclJlc291cmNlcygpOwogICAgIHZvaWQgcHJlcGFyZUNvbXBvc2l0b3JSZXNvdXJjZXMo R3JhcGhpY3NDb250ZXh0M0QqLCBUZXh0dXJlQWxsb2NhdG9yKik7Ci0gICAgdm9pZCBwYWludENv bnRlbnRzKCk7CisgICAgdm9pZCB1cGRhdGVDb250ZW50cygpOworCisgICAgdHlwZWRlZiBWZWN0 b3I8T3duUHRyPE1hbmFnZWRUZXh0dXJlPiA+IFRleHR1cmVMaXN0OworICAgIHZvaWQgc3RlYWxU ZXh0dXJlcyhUZXh0dXJlTGlzdCYpOwogCiAgICAgdm9pZCBmb3JFYWNoQ29tcG9zaXRvclJlc291 cmNlKExheWVyVGV4dHVyZVVwZGF0ZXI6OkhhbmRsZXImKTsKICAgICB2b2lkIGFwcGx5U2Nyb2xs QW5kU2NhbGUoY29uc3QgQ0NTY3JvbGxBbmRTY2FsZVNldCYpOwpAQCAtMjM4LDYgKzI0MiwxOCBA QCBwcml2YXRlOgogICAgICAgICBDQ1Byb3h5KiBtX3Byb3h5OwogICAgIH07CiAKKyAgICBjbGFz cyBTdGVhbFRleHR1cmVIYW5kbGVyIDogcHVibGljIExheWVyVGV4dHVyZVVwZGF0ZXI6OkhhbmRs ZXIgeworICAgIHB1YmxpYzoKKyAgICAgICAgU3RlYWxUZXh0dXJlSGFuZGxlcihUZXh0dXJlTWFu YWdlciosIFRleHR1cmVMaXN0Kik7CisgICAgICAgIHZpcnR1YWwgflN0ZWFsVGV4dHVyZUhhbmRs ZXIoKTsKKworICAgICAgICB2aXJ0dWFsIHZvaWQgaGFuZGxlKExheWVyVGV4dHVyZVVwZGF0ZXI6 OlRleHR1cmUqLCBjb25zdCBJbnRSZWN0JiBzb3VyY2VSZWN0LCBjb25zdCBJbnRSZWN0JiBkZXN0 UmVjdCk7CisKKyAgICBwcml2YXRlOgorICAgICAgICBUZXh0dXJlTWFuYWdlciogbV90ZXh0dXJl TWFuYWdlcjsKKyAgICAgICAgVGV4dHVyZUxpc3QqIG1fbGlzdDsKKyAgICB9OworCiAgICAgdHlw ZWRlZiBWZWN0b3I8UmVmUHRyPExheWVyQ2hyb21pdW0+ID4gTGF5ZXJMaXN0OwogCiAgICAgdm9p ZCBhcHBlbmRWaXNpYmxlTGF5ZXIoTGF5ZXJDaHJvbWl1bSosIExheWVyTGlzdCYpOwpAQCAtMjQ1 LDcgKzI2MSw4IEBAIHByaXZhdGU6CiAgICAgdm9pZCBhcHBlbmRWaXNpYmxlTGF5ZXJzKGNvbnN0 IExheWVyTGlzdCYgcmVuZGVyU3VyZmFjZVVwZGF0ZUxpc3QsIExheWVyTGlzdCYgdXBkYXRlTGlz dCk7CiAKICAgICB2b2lkIHByZXBhcmVUb1VwZGF0ZShMYXllckNocm9taXVtKik7Ci0gICAgdm9p ZCBwYWludENvbnRlbnRzKExheWVyQ2hyb21pdW0qKTsKKyAgICB2b2lkIHByb3RlY3RUZXh0dXJl cyhMYXllckNocm9taXVtKik7CisgICAgdm9pZCB1cGRhdGVDb250ZW50cyhMYXllckNocm9taXVt Kik7CiAgICAgdm9pZCBjbGVhclBlbmRpbmdVcGRhdGUoKTsKIAogICAgIGludCBtX2NvbXBvc2l0 b3JJZGVudGlmaWVyOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vY2MvQ0NTaW5nbGVUaHJlYWRQcm94eS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1NpbmdsZVRocmVhZFByb3h5LmNwcAppbmRl eCA5MjczMzcwLi5hNGNjN2JhIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9jYy9DQ1NpbmdsZVRocmVhZFByb3h5LmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1NpbmdsZVRocmVhZFByb3h5 LmNwcApAQCAtMTUyLDcgKzE1Miw3IEBAIHZvaWQgQ0NTaW5nbGVUaHJlYWRQcm94eTo6ZG9Db21t aXQoKQogICAgIGlmIChtX2xheWVyVHJlZUhvc3QtPm5lZWRzQ29tcG9zaXRvclJlc291cmNlcygp KQogICAgICAgICBtX2xheWVyVHJlZUhvc3QtPnByZXBhcmVDb21wb3NpdG9yUmVzb3VyY2VzKG1f bGF5ZXJUcmVlSG9zdEltcGwtPmNvbnRleHQoKSwgbV9sYXllclRyZWVIb3N0SW1wbC0+Y29udGVu dHNUZXh0dXJlQWxsb2NhdG9yKCkpOwogCi0gICAgbV9sYXllclRyZWVIb3N0LT5wYWludENvbnRl bnRzKCk7CisgICAgbV9sYXllclRyZWVIb3N0LT51cGRhdGVDb250ZW50cygpOwogCiAgICAgLy8g Q29tbWl0IGltbWVkaWF0ZWx5CiAgICAgewpAQCAtMjg2LDYgKzI4NiwxMCBAQCB2b2lkIENDU2lu Z2xlVGhyZWFkUHJveHk6OmNvbW1pdElmTmVlZGVkKCkKIAogICAgIG1fbGF5ZXJUcmVlSG9zdC0+ cHJlcGFyZVRvVXBkYXRlKCk7CiAKKyAgICAvLyBQcm90ZWN0IGFsbCB2aXNpYmxlIHRleHR1cmVz LgorICAgIG1fbGF5ZXJUcmVlSG9zdC0+Y29udGVudHNUZXh0dXJlTWFuYWdlcigpLT51bnByb3Rl Y3RBbGxUZXh0dXJlcygpOworICAgIG1fbGF5ZXJUcmVlSG9zdC0+cHJvdGVjdFRleHR1cmVzKCk7 CisKICAgICBkb0NvbW1pdCgpOwogfQogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmNwcCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuY3BwCmluZGV4 IGVmYWFiMmUuLmFlNDRjMGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuY3BwCkBAIC0zODcs OCArMzg3LDI3IEBAIHZvaWQgQ0NUaHJlYWRQcm94eTo6YmVnaW5GcmFtZUFuZENvbW1pdChpbnQg c2VxdWVuY2VOdW1iZXIsIGRvdWJsZSBmcmFtZUJlZ2luVGltCiAgICAgLy8gdXBkYXRlTGF5ZXJz LgogICAgIG1fY29tbWl0UmVxdWVzdGVkID0gZmFsc2U7CiAKKyAgICAvLyBQYXJ0aWFsIHVwZGF0 ZXMgYXJlIG5vdCBhbGxvd2VkIHRvIHVucHJvdGVjdGVkIHRleHR1cmVzIHNvCisgICAgLy8gdW5w cm90ZWN0IGFsbCB0ZXh0dXJlcyBwcmlvciB0byBjYWxsaW5nIHByZXBhcmVUb1VwZGF0ZSgpLgor ICAgIG1fbGF5ZXJUcmVlSG9zdC0+Y29udGVudHNUZXh0dXJlTWFuYWdlcigpLT51bnByb3RlY3RB bGxUZXh0dXJlcygpOworCisgICAgLy8gVGhpcyB3aWxsIGRldGVybWluZSB3aGF0IG5lZWRzIHRv IGJlIHVwZGF0ZWQuCiAgICAgbV9sYXllclRyZWVIb3N0LT5wcmVwYXJlVG9VcGRhdGUoKTsKIAor ICAgIC8vIE1vdmUgdGV4dHVyZXMgdXNlZCBieSBpbXBsIHRocmVhZCB0byB1c2VkVGV4dHVyZUxp c3QuCisgICAgVGV4dHVyZUxpc3QgdXNlZFRleHR1cmVMaXN0OworICAgIG1fbGF5ZXJUcmVlSG9z dC0+c3RlYWxUZXh0dXJlcyh1c2VkVGV4dHVyZUxpc3QpOworCisgICAgLy8gUHJvdGVjdCB0ZXh0 dXJlcyBpbiB1c2VkVGV4dHVyZUxpc3QuCisgICAgZm9yIChzaXplX3QgaSA9IDA7IGkgPCB1c2Vk VGV4dHVyZUxpc3Quc2l6ZSgpOyArK2kpIHsKKyAgICAgICAgTWFuYWdlZFRleHR1cmUqIHRleHR1 cmUgPSB1c2VkVGV4dHVyZUxpc3RbaV0uZ2V0KCk7CisgICAgICAgIGlmICh0ZXh0dXJlLT5pc1Zh bGlkKHRleHR1cmUtPnNpemUoKSwgdGV4dHVyZS0+Zm9ybWF0KCkpKQorICAgICAgICAgICAgdGV4 dHVyZS0+cmVzZXJ2ZSh0ZXh0dXJlLT5zaXplKCksIHRleHR1cmUtPmZvcm1hdCgpKTsKKyAgICB9 CisKKyAgICAvLyBQcm90ZWN0IGFsbCB2aXNpYmxlIHRleHR1cmVzIGluY2x1ZGluZyB0aGUgb25l cyB1c2VkIGZvciB1cGRhdGUuCisgICAgbV9sYXllclRyZWVIb3N0LT5wcm90ZWN0VGV4dHVyZXMo KTsKKwogICAgIGlmIChtX2xheWVyVHJlZUhvc3QtPm5lZWRzQ29tcG9zaXRvclJlc291cmNlcygp KSB7CiAgICAgICAgIC8vIEluaXRpYWxpemUgY29tcG9zaXRvciByZXNvdXJjZXMgcmVxdWlyZSBm b3IgZnJhbWUuCiAgICAgICAgIFRSQUNFX0VWRU5UKCJhbGxvY2F0ZSIsIHRoaXMsIDApOwpAQCAt Mzk3LDcgKzQxNiw3IEBAIHZvaWQgQ0NUaHJlYWRQcm94eTo6YmVnaW5GcmFtZUFuZENvbW1pdChp bnQgc2VxdWVuY2VOdW1iZXIsIGRvdWJsZSBmcmFtZUJlZ2luVGltCiAgICAgICAgIGNvbXBsZXRp b24ud2FpdCgpOwogICAgIH0KIAotICAgIG1fbGF5ZXJUcmVlSG9zdC0+cGFpbnRDb250ZW50cygp OworICAgIG1fbGF5ZXJUcmVlSG9zdC0+dXBkYXRlQ29udGVudHMoKTsKIAogICAgIC8vIEJlZm9y ZSBhcHBseWluZyBzY3JvbGxzIGFuZCBjYWxsaW5nIGFuaW1hdGUsIHdlIHNldCBtX2FuaW1hdGVS ZXF1ZXN0ZWQgdG8gZmFsc2UuCiAgICAgLy8gSWYgaXQgaXMgdHJ1ZSBub3csIGl0IG1lYW5zIHNl dE5lZWRBbmltYXRlIHdhcyBjYWxsZWQgYWdhaW4uIENhbGwgc2V0TmVlZHNDb21taXQKQEAgLTQx Niw2ICs0MzUsOSBAQCB2b2lkIENDVGhyZWFkUHJveHk6OmJlZ2luRnJhbWVBbmRDb21taXQoaW50 IHNlcXVlbmNlTnVtYmVyLCBkb3VibGUgZnJhbWVCZWdpblRpbQogICAgICAgICBjb21wbGV0aW9u LndhaXQoKTsKICAgICB9CiAKKyAgICAvLyBFeHBsaWNpdGx5IHJlbGVhc2UgdGV4dHVyZXMgbm8g bG9uZ2VyIHVzZWQgYnkgaW1wbCB0aHJlYWQuCisgICAgdXNlZFRleHR1cmVMaXN0LmNsZWFyKCk7 CisKICAgICBtX2xheWVyVHJlZUhvc3QtPmNvbW1pdENvbXBsZXRlKCk7CiAKICAgICBBU1NFUlQo bV9sYXN0RXhlY3V0ZWRCZWdpbkZyYW1lQW5kQ29tbWl0U2VxdWVuY2VOdW1iZXIgPT0gc2VxdWVu Y2VOdW1iZXIpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5oCmluZGV4IGYxMjQ0YzIuLjEzNWQyN2Yg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2Nj L0NDVGhyZWFkUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmgKQEAgLTg2LDYgKzg2LDggQEAgcHJpdmF0ZToKICAg ICAgICAgSW50UmVjdCBtX2Rlc3RSZWN0OwogICAgIH07CiAKKyAgICB0eXBlZGVmIFZlY3RvcjxP d25QdHI8TWFuYWdlZFRleHR1cmU+ID4gVGV4dHVyZUxpc3Q7CisKICAgICAvLyBDYWxsZWQgb24g bWFpbiB0aHJlYWQKICAgICB2b2lkIGJlZ2luRnJhbWVBbmRDb21taXQoaW50IHNlcXVlbmNlTnVt YmVyLCBkb3VibGUgZnJhbWVCZWdpblRpbWUsIFBhc3NPd25QdHI8Q0NTY3JvbGxBbmRTY2FsZVNl dD4pOwogICAgIHZvaWQgZGlkQ29tbWl0QW5kRHJhd0ZyYW1lKCk7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0NDTGF5ZXJUcmVlSG9zdFRlc3QuY3BwIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS90ZXN0cy9DQ0xheWVyVHJlZUhvc3RUZXN0LmNwcAppbmRleCA0MzEz ZmE1Li41MmM3MDQzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0ND TGF5ZXJUcmVlSG9zdFRlc3QuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMv Q0NMYXllclRyZWVIb3N0VGVzdC5jcHAKQEAgLTYxLDYgKzYxLDcgQEAgcHVibGljOgogICAgIHZp cnR1YWwgdm9pZCBkcmF3TGF5ZXJzT25DQ1RocmVhZChDQ0xheWVyVHJlZUhvc3RJbXBsKikgeyB9 CiAgICAgdmlydHVhbCB2b2lkIGFwcGx5U2Nyb2xsQW5kU2NhbGUoY29uc3QgSW50U2l6ZSYsIGZs b2F0KSB7IH0KICAgICB2aXJ0dWFsIHZvaWQgYW5pbWF0ZUFuZExheW91dChkb3VibGUgZnJhbWVC ZWdpblRpbWUpIHsgfQorICAgIHZpcnR1YWwgdm9pZCBkaWRDb21taXRBbmREcmF3RnJhbWUoKSB7 IH0KIH07CiAKIC8vIEFkYXB0cyBDQ0xheWVyVHJlZUhvc3RJbXBsIGZvciB0ZXN0LiBSdW5zIHJl YWwgY29kZSwgdGhlbiBpbnZva2VzIHRlc3QgaG9va3MuCkBAIC0xMzgsOSArMTM5LDQxIEBAIHB1 YmxpYzoKICAgICB2aXJ0dWFsIFdlYkdMSWQgY3JlYXRlU2hhZGVyKFdHQzNEZW51bSkgeyByZXR1 cm4gMTsgfQogICAgIHZpcnR1YWwgdm9pZCBnZXRTaGFkZXJpdihXZWJHTElkLCBXR0MzRGVudW0s IFdHQzNEaW50KiB2YWx1ZSkgeyAqdmFsdWUgPSAxOyB9CiAgICAgdmlydHVhbCB2b2lkIGdldFBy b2dyYW1pdihXZWJHTElkLCBXR0MzRGVudW0sIFdHQzNEaW50KiB2YWx1ZSkgeyAqdmFsdWUgPSAx OyB9CisgICAgdmlydHVhbCBXZWJHTElkIGNyZWF0ZVRleHR1cmUoKQorICAgIHsKKyAgICAgICAg V2ViR0xJZCB0ZXh0dXJlID0gbV90ZXh0dXJlcy5zaXplKCkgKyAxOworICAgICAgICBtX3RleHR1 cmVzLnB1c2hfYmFjayh0ZXh0dXJlKTsKKyAgICAgICAgcmV0dXJuIHRleHR1cmU7CisgICAgfQor CisgICAgdmlydHVhbCB2b2lkIGRlbGV0ZVRleHR1cmUoV2ViR0xJZCB0ZXh0dXJlKQorICAgIHsK KyAgICAgICAgZm9yIChzdGQ6OnZlY3RvcjxXZWJHTElkPjo6aXRlcmF0b3IgaXQgPSBtX3RleHR1 cmVzLmJlZ2luKCk7IGl0ICE9IG1fdGV4dHVyZXMuZW5kKCk7IGl0KyspIHsKKyAgICAgICAgICAg IGlmICgqaXQgPT0gdGV4dHVyZSkgeworICAgICAgICAgICAgICAgIG1fdGV4dHVyZXMuZXJhc2Uo aXQpOworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAgICAgICB9Cisg ICAgfQorCisgICAgdmlydHVhbCB2b2lkIGJpbmRUZXh0dXJlKFdHQzNEZW51bSAvKiB0YXJnZXQg Ki8sIFdlYkdMSWQgdGV4dHVyZSkKKyAgICB7CisgICAgICAgIG1fdXNlZFRleHR1cmVzLmluc2Vy dCh0ZXh0dXJlKTsKKyAgICB9CisKKyAgICBpbnQgbnVtVGV4dHVyZXMoKSBjb25zdCB7IHJldHVy biBzdGF0aWNfY2FzdDxpbnQ+KG1fdGV4dHVyZXMuc2l6ZSgpKTsgfQorICAgIGludCB0ZXh0dXJl KGludCBpKSBjb25zdCB7IHJldHVybiBtX3RleHR1cmVzW2ldOyB9CisgICAgdm9pZCByZXNldFRl eHR1cmVzKCkgeyBtX3RleHR1cmVzLmNsZWFyKCk7IH0KKworICAgIGludCBudW1Vc2VkVGV4dHVy ZXMoKSBjb25zdCB7IHJldHVybiBzdGF0aWNfY2FzdDxpbnQ+KG1fdXNlZFRleHR1cmVzLnNpemUo KSk7IH0KKyAgICBib29sIHVzZWRUZXh0dXJlKGludCB0ZXh0dXJlKSBjb25zdCB7IHJldHVybiBt X3VzZWRUZXh0dXJlcy5maW5kKHRleHR1cmUpICE9IG1fdXNlZFRleHR1cmVzLmVuZCgpOyB9Cisg ICAgdm9pZCByZXNldFVzZWRUZXh0dXJlcygpIHsgbV91c2VkVGV4dHVyZXMuY2xlYXIoKTsgfQog CiBwcml2YXRlOgogICAgIENvbXBvc2l0b3JNb2NrV2ViR3JhcGhpY3NDb250ZXh0M0QoKSB7IH0K KworICAgIHN0ZDo6dmVjdG9yPFdlYkdMSWQ+IG1fdGV4dHVyZXM7CisgICAgc3RkOjpzZXQ8V2Vi R0xJZD4gbV91c2VkVGV4dHVyZXM7CiB9OwogCiAvLyBJbXBsZW1lbnRhdGlvbiBvZiBDQ0xheWVy VHJlZUhvc3QgY2FsbGJhY2sgaW50ZXJmYWNlLgpAQCAtMTcxLDYgKzIwNCw3IEBAIHB1YmxpYzoK IAogICAgIHZpcnR1YWwgdm9pZCBkaWRDb21taXRBbmREcmF3RnJhbWUoKQogICAgIHsKKyAgICAg ICAgbV90ZXN0SG9va3MtPmRpZENvbW1pdEFuZERyYXdGcmFtZSgpOwogICAgIH0KIAogICAgIHZp cnR1YWwgdm9pZCBkaWRDb21wbGV0ZVN3YXBCdWZmZXJzKCkKQEAgLTk2NiwxNCArMTAwMCwyMyBA QCBwdWJsaWM6CiAKICAgICAgICAgICAgIHZpcnR1YWwgTWFuYWdlZFRleHR1cmUqIHRleHR1cmUo KSB7IHJldHVybiBtX3RleHR1cmUuZ2V0KCk7IH0KIAorICAgICAgICAgICAgdmlydHVhbCBQYXNz T3duUHRyPE1hbmFnZWRUZXh0dXJlPiByZXBsYWNlVGV4dHVyZShUZXh0dXJlTWFuYWdlciogbWFu YWdlcikKKyAgICAgICAgICAgIHsKKyAgICAgICAgICAgICAgICBPd25QdHI8TWFuYWdlZFRleHR1 cmU+IG9sZCA9IG1fdGV4dHVyZS5yZWxlYXNlKCk7CisgICAgICAgICAgICAgICAgbV90ZXh0dXJl ID0gTWFuYWdlZFRleHR1cmU6OmNyZWF0ZShtYW5hZ2VyKTsKKyAgICAgICAgICAgICAgICByZXR1 cm4gb2xkLnJlbGVhc2UoKTsKKyAgICAgICAgICAgIH0KKwogICAgICAgICAgICAgdmlydHVhbCBi b29sIG5lZWRQcmVwYXJlUmVjdCgpCiAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAgcmV0 dXJuIG1fdGV4dHVyZVVwZGF0ZXItPmxheWVyKCktPm5lZWRQcmVwYXJlUmVjdCgpOwogICAgICAg ICAgICAgfQogCi0gICAgICAgICAgICB2aXJ0dWFsIHZvaWQgcHJlcGFyZVJlY3QoR3JhcGhpY3ND b250ZXh0M0QqLCBUZXh0dXJlQWxsb2NhdG9yKiwgY29uc3QgSW50UmVjdCYgLyogc291cmNlUmVj dCAqLywgY29uc3QgSW50UmVjdCYgLyogZGVzdFJlY3QgKi8pCisgICAgICAgICAgICB2aXJ0dWFs IHZvaWQgcHJlcGFyZVJlY3QoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIFRleHR1cmVBbGxv Y2F0b3IqIGFsbG9jYXRvciwgY29uc3QgSW50UmVjdCYgLyogc291cmNlUmVjdCAqLywgY29uc3Qg SW50UmVjdCYgLyogZGVzdFJlY3QgKi8pCiAgICAgICAgICAgICB7CiAgICAgICAgICAgICAgICAg bV90ZXh0dXJlVXBkYXRlci0+bGF5ZXIoKS0+cHJlcGFyZVJlY3QoKTsKKyAgICAgICAgICAgICAg ICBpZiAoIW1fdGV4dHVyZS0+dGV4dHVyZUlkKCkpCisgICAgICAgICAgICAgICAgICAgIG1fdGV4 dHVyZS0+YWxsb2NhdGVUZXh0dXJlKGNvbnRleHQsIGFsbG9jYXRvcik7CiAgICAgICAgICAgICB9 CiAKICAgICAgICAgICAgIHZpcnR1YWwgdm9pZCBwYWludENvbnRlbnRzUmVjdChjb25zdCBJbnRS ZWN0JiAvKiBzb3VyY2VSZWN0ICovKQpAQCAtOTgxLDkgKzEwMjQsMTEgQEAgcHVibGljOgogICAg ICAgICAgICAgICAgIG1fdGV4dHVyZVVwZGF0ZXItPmxheWVyKCktPnBhaW50Q29udGVudHNSZWN0 KCk7CiAgICAgICAgICAgICB9CiAKLSAgICAgICAgICAgIHZpcnR1YWwgdm9pZCB1cGRhdGVSZWN0 KEdyYXBoaWNzQ29udGV4dDNEKiwgY29uc3QgSW50UmVjdCYgLyogc291cmNlUmVjdCAqLywgY29u c3QgSW50UmVjdCYgLyogZGVzdFJlY3QgKi8pCisgICAgICAgICAgICB2aXJ0dWFsIHZvaWQgdXBk YXRlUmVjdChHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgY29uc3QgSW50UmVjdCYgLyogc291 cmNlUmVjdCAqLywgY29uc3QgSW50UmVjdCYgLyogZGVzdFJlY3QgKi8pCiAgICAgICAgICAgICB7 CiAgICAgICAgICAgICAgICAgbV90ZXh0dXJlVXBkYXRlci0+bGF5ZXIoKS0+dXBkYXRlUmVjdCgp OworICAgICAgICAgICAgICAgIGlmIChtX3RleHR1cmUtPnRleHR1cmVJZCgpKQorICAgICAgICAg ICAgICAgICAgICBjb250ZXh0LT5iaW5kVGV4dHVyZShHcmFwaGljc0NvbnRleHQzRDo6VEVYVFVS RV8yRCwgbV90ZXh0dXJlLT50ZXh0dXJlSWQoKSk7CiAgICAgICAgICAgICB9CiAKICAgICAgICAg cHJpdmF0ZToKQEAgLTExNjIsNCArMTIwNywyMTkgQEAgVEVTVF9GKENDTGF5ZXJUcmVlSG9zdFRl c3ROb1ByZXBhcmVSZWN0LCBydW5NdWx0aVRocmVhZCkKICAgICBydW5UZXN0KHRydWUpOwogfQog CisvLyBWZXJpZnkgYXRvbWljaXR5IG9mIGNvbW1pdHMgYW5kIHJldXNlIG9mIHRleHR1cmVzLgor Y2xhc3MgQ0NMYXllclRyZWVIb3N0VGVzdEF0b21pY0NvbW1pdCA6IHB1YmxpYyBDQ0xheWVyVHJl ZUhvc3RUZXN0IHsKK3B1YmxpYzoKKyAgICBDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0 KCkKKyAgICAgICAgOiBtX3VwZGF0ZUNoZWNrTGF5ZXIoQ29udGVudExheWVyQ2hyb21pdW1XaXRo VXBkYXRlVHJhY2tpbmc6OmNyZWF0ZSgmbV9kZWxlZ2F0ZSwgdHJ1ZSkpCisgICAgICAgICwgbV9u dW1Db21taXRzKDApCisgICAgeworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBiZWdpblRlc3Qo KQorICAgIHsKKyAgICAgICAgbV9sYXllclRyZWVIb3N0LT5zZXRSb290TGF5ZXIobV91cGRhdGVD aGVja0xheWVyKTsKKyAgICAgICAgbV9sYXllclRyZWVIb3N0LT5zZXRWaWV3cG9ydChJbnRTaXpl KDEwLCAxMCkpOworCisgICAgICAgIHBvc3RTZXROZWVkc0NvbW1pdFRvTWFpblRocmVhZCgpOwor ICAgICAgICBwb3N0U2V0TmVlZHNSZWRyYXdUb01haW5UaHJlYWQoKTsKKyAgICB9CisKKyAgICB2 aXJ0dWFsIHZvaWQgY29tbWl0Q29tcGxldGVPbkNDVGhyZWFkKENDTGF5ZXJUcmVlSG9zdEltcGwq IGltcGwpCisgICAgeworICAgICAgICBDb21wb3NpdG9yTW9ja1dlYkdyYXBoaWNzQ29udGV4dDNE KiBjb250ZXh0ID0gc3RhdGljX2Nhc3Q8Q29tcG9zaXRvck1vY2tXZWJHcmFwaGljc0NvbnRleHQz RCo+KEdyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZTo6ZXh0cmFjdFdlYkdyYXBoaWNzQ29udGV4dDNE KGltcGwtPmNvbnRleHQoKSkpOworCisgICAgICAgIHN3aXRjaCAoaW1wbC0+ZnJhbWVOdW1iZXIo KSkgeworICAgICAgICAgICAgY2FzZSAwOgorICAgICAgICAgICAgICAgIC8vIE51bWJlciBvZiB0 ZXh0dXJlcyBzaG91bGQgYmUgb25lLgorICAgICAgICAgICAgICAgIEVYUEVDVF9FUSgxLCBjb250 ZXh0LT5udW1UZXh0dXJlcygpKTsKKyAgICAgICAgICAgICAgICAvLyBOdW1iZXIgb2YgdGV4dHVy ZXMgdXNlZCBmb3IgY29tbWl0IHNob3VsZCBiZSBvbmUuCisgICAgICAgICAgICAgICAgRVhQRUNU X0VRKDEsIGNvbnRleHQtPm51bVVzZWRUZXh0dXJlcygpKTsKKyAgICAgICAgICAgICAgICAvLyBW ZXJpZnkgdXNlZCB0ZXh0dXJlIGlzIGNvcnJlY3QuCisgICAgICAgICAgICAgICAgRVhQRUNUX1RS VUUoY29udGV4dC0+dXNlZFRleHR1cmUoY29udGV4dC0+dGV4dHVyZSgwKSkpOworCisgICAgICAg ICAgICAgICAgY29udGV4dC0+cmVzZXRVc2VkVGV4dHVyZXMoKTsKKyAgICAgICAgICAgICAgICBi cmVhazsKKyAgICAgICAgICAgIGNhc2UgMToKKyAgICAgICAgICAgICAgICAvLyBOdW1iZXIgb2Yg dGV4dHVyZXMgc2hvdWxkIGJlIHR3byBhcyB0aGUgZmlyc3QgdGV4dHVyZQorICAgICAgICAgICAg ICAgIC8vIGlzIHVzZWQgYnkgaW1wbCB0aHJlYWQgYW5kIGNhbm5vdCBieSB1c2VkIGZvciB1cGRh dGUuCisgICAgICAgICAgICAgICAgRVhQRUNUX0VRKDIsIGNvbnRleHQtPm51bVRleHR1cmVzKCkp OworICAgICAgICAgICAgICAgIC8vIE51bWJlciBvZiB0ZXh0dXJlcyB1c2VkIGZvciBjb21taXQg c2hvdWxkIHN0aWxsIGJlIG9uZS4KKyAgICAgICAgICAgICAgICBFWFBFQ1RfRVEoMSwgY29udGV4 dC0+bnVtVXNlZFRleHR1cmVzKCkpOworICAgICAgICAgICAgICAgIC8vIEZpcnN0IHRleHR1cmUg c2hvdWxkIG5vdCBoYXZlIGJlZW4gdXNlZC4KKyAgICAgICAgICAgICAgICBFWFBFQ1RfRkFMU0Uo Y29udGV4dC0+dXNlZFRleHR1cmUoY29udGV4dC0+dGV4dHVyZSgwKSkpOworICAgICAgICAgICAg ICAgIC8vIE5ldyB0ZXh0dXJlIHNob3VsZCBoYXZlIGJlZW4gdXNlZC4KKyAgICAgICAgICAgICAg ICBFWFBFQ1RfVFJVRShjb250ZXh0LT51c2VkVGV4dHVyZShjb250ZXh0LT50ZXh0dXJlKDEpKSk7 CisKKyAgICAgICAgICAgICAgICBjb250ZXh0LT5yZXNldFVzZWRUZXh0dXJlcygpOworICAgICAg ICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgY2FzZSAyOgorICAgICAgICAgICAgICAgIC8v IE51bWJlciBvZiB0ZXh0dXJlcyBzaG91bGQgbm90IGhhdmUgaW5jcmVhc2VkLiBPbGQgdGV4dHVy ZQorICAgICAgICAgICAgICAgIC8vIHNob3VsZCBoYXZlIGJlZW4gcmV1c2VkLgorICAgICAgICAg ICAgICAgIEVYUEVDVF9FUSgyLCBjb250ZXh0LT5udW1UZXh0dXJlcygpKTsKKyAgICAgICAgICAg ICAgICAvLyBOdW1iZXIgb2YgdGV4dHVyZXMgdXNlZCBmb3IgY29tbWl0IHNob3VsZCBzdGlsbCBi ZSBvbmUuCisgICAgICAgICAgICAgICAgRVhQRUNUX0VRKDEsIGNvbnRleHQtPm51bVVzZWRUZXh0 dXJlcygpKTsKKyAgICAgICAgICAgICAgICAvLyBGaXJzdCB0ZXh0dXJlIHNob3VsZCBoYXZlIGJl ZW4gdXNlZCBmb3IgY29tbWl0LgorICAgICAgICAgICAgICAgIEVYUEVDVF9UUlVFKGNvbnRleHQt PnVzZWRUZXh0dXJlKGNvbnRleHQtPnRleHR1cmUoMCkpKTsKKyAgICAgICAgICAgICAgICAvLyBT ZWNvbmQgdGV4dHVyZSBzaG91bGQgbm90IGhhdmUgYmVlbiB1c2VkIGZvciBjb21taXQuCisgICAg ICAgICAgICAgICAgRVhQRUNUX0ZBTFNFKGNvbnRleHQtPnVzZWRUZXh0dXJlKGNvbnRleHQtPnRl eHR1cmUoMSkpKTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIGRlZmF1bHQ6 CisgICAgICAgICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgICAgICAgICAg YnJlYWs7CisgICAgICAgIH0KKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZHJhd0xheWVyc09u Q0NUaHJlYWQoQ0NMYXllclRyZWVIb3N0SW1wbCogaW1wbCkKKyAgICB7CisgICAgICAgIENvbXBv c2l0b3JNb2NrV2ViR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQgPSBzdGF0aWNfY2FzdDxDb21w b3NpdG9yTW9ja1dlYkdyYXBoaWNzQ29udGV4dDNEKj4oR3JhcGhpY3NDb250ZXh0M0RQcml2YXRl OjpleHRyYWN0V2ViR3JhcGhpY3NDb250ZXh0M0QoaW1wbC0+Y29udGV4dCgpKSk7CisKKyAgICAg ICAgLy8gTnVtYmVyIG9mIHRleHR1cmVzIHVzZWQgZm9yIGRyYXcgc2hvdWxkIGFsd2F5cyBiZSBv bmUuCisgICAgICAgIEVYUEVDVF9FUSgxLCBjb250ZXh0LT5udW1Vc2VkVGV4dHVyZXMoKSk7CisK KyAgICAgICAgaWYgKGltcGwtPmZyYW1lTnVtYmVyKCkgPCAzKSB7CisgICAgICAgICAgICBjb250 ZXh0LT5yZXNldFVzZWRUZXh0dXJlcygpOworICAgICAgICAgICAgcG9zdFNldE5lZWRzQW5pbWF0 ZUFuZENvbW1pdFRvTWFpblRocmVhZCgpOworICAgICAgICAgICAgcG9zdFNldE5lZWRzUmVkcmF3 VG9NYWluVGhyZWFkKCk7CisgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICBlbmRUZXN0KCk7 CisgICAgICAgIH0KKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgYW5pbWF0ZUFuZExheW91dChk b3VibGUgZnJhbWVCZWdpblRpbWUpCisgICAgeworICAgICAgICBtX3VwZGF0ZUNoZWNrTGF5ZXIt PnNldE5lZWRzRGlzcGxheSgpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBhZnRlclRlc3Qo KQorICAgIHsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgTW9ja0xheWVyRGVsZWdhdGUgbV9kZWxl Z2F0ZTsKKyAgICBSZWZQdHI8Q29udGVudExheWVyQ2hyb21pdW1XaXRoVXBkYXRlVHJhY2tpbmc+ IG1fdXBkYXRlQ2hlY2tMYXllcjsKKyAgICBpbnQgbV9udW1Db21taXRzOworfTsKKworVEVTVF9G KENDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQsIHJ1bk11bHRpVGhyZWFkKQoreworICAg IHJ1blRlc3QodHJ1ZSk7Cit9CisKKy8vIFZlcmlmeSB0aGF0IG9ubHkgcHJvdGVjdGVkIHRleHR1 cmVzIGFyZSB1c2VkLgorY2xhc3MgQ0NMYXllclRyZWVIb3N0VGVzdFRleHR1cmVVc2FnZSA6IHB1 YmxpYyBDQ0xheWVyVHJlZUhvc3RUZXN0IHsKK3B1YmxpYzoKKyAgICB2aXJ0dWFsIHZvaWQgZHJh d0xheWVyc09uQ0NUaHJlYWQoQ0NMYXllclRyZWVIb3N0SW1wbCogaW1wbCkKKyAgICB7CisgICAg ICAgIENvbXBvc2l0b3JNb2NrV2ViR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQgPSBzdGF0aWNf Y2FzdDxDb21wb3NpdG9yTW9ja1dlYkdyYXBoaWNzQ29udGV4dDNEKj4oR3JhcGhpY3NDb250ZXh0 M0RQcml2YXRlOjpleHRyYWN0V2ViR3JhcGhpY3NDb250ZXh0M0QoaW1wbC0+Y29udGV4dCgpKSk7 CisKKyAgICAgICAgZm9yIChpbnQgaSA9IDA7IGkgPCBjb250ZXh0LT5udW1UZXh0dXJlcygpOyBp KyspCisgICAgICAgICAgICBpZiAoY29udGV4dC0+dXNlZFRleHR1cmUoY29udGV4dC0+dGV4dHVy ZShpKSkpCisgICAgICAgICAgICAgICAgbV90ZXh0dXJlcy5wdXNoX2JhY2soY29udGV4dC0+dGV4 dHVyZShpKSk7CisKKyAgICAgICAgY29udGV4dC0+cmVzZXRVc2VkVGV4dHVyZXMoKTsKKyAgICB9 CisKKyAgICB2aXJ0dWFsIHZvaWQgZGlkQ29tbWl0QW5kRHJhd0ZyYW1lKCkKKyAgICB7CisgICAg ICAgIGZvciAoc3RkOjp2ZWN0b3I8V2ViR0xJZD46Oml0ZXJhdG9yIGl0ID0gbV90ZXh0dXJlcy5i ZWdpbigpOyBpdCAhPSBtX3RleHR1cmVzLmVuZCgpOyArK2l0KSB7CisgICAgICAgICAgICBUZXh0 dXJlVG9rZW4gdG9rZW4gPSBtX2xheWVyVHJlZUhvc3QtPmNvbnRlbnRzVGV4dHVyZU1hbmFnZXIo KS0+dG9rZW5Gb3JUZXh0dXJlSWQoKml0KTsKKyAgICAgICAgICAgIEFTU0VSVCh0b2tlbik7Cisg ICAgICAgICAgICBFWFBFQ1RfVFJVRShtX2xheWVyVHJlZUhvc3QtPmNvbnRlbnRzVGV4dHVyZU1h bmFnZXIoKS0+aGFzVGV4dHVyZSh0b2tlbikpOworICAgICAgICAgICAgRVhQRUNUX1RSVUUobV9s YXllclRyZWVIb3N0LT5jb250ZW50c1RleHR1cmVNYW5hZ2VyKCktPmlzUHJvdGVjdGVkKHRva2Vu KSk7CisgICAgICAgIH0KKyAgICAgICAgbV90ZXh0dXJlcy5jbGVhcigpOworICAgIH0KKworcHJp dmF0ZToKKyAgICBzdGQ6OnZlY3RvcjxXZWJHTElkPiBtX3RleHR1cmVzOworfTsKKworY2xhc3Mg Q0NMYXllclRyZWVIb3N0VGVzdFRleHR1cmVVc2FnZVNpbXBsZSA6IHB1YmxpYyBDQ0xheWVyVHJl ZUhvc3RUZXN0VGV4dHVyZVVzYWdlIHsKK3B1YmxpYzoKKyAgICBDQ0xheWVyVHJlZUhvc3RUZXN0 VGV4dHVyZVVzYWdlU2ltcGxlKCkKKyAgICAgICAgOiBtX3VwZGF0ZUNoZWNrTGF5ZXIoQ29udGVu dExheWVyQ2hyb21pdW1XaXRoVXBkYXRlVHJhY2tpbmc6OmNyZWF0ZSgmbV9kZWxlZ2F0ZSwgdHJ1 ZSkpCisgICAgeworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBiZWdpblRlc3QoKQorICAgIHsK KyAgICAgICAgbV9sYXllclRyZWVIb3N0LT5zZXRSb290TGF5ZXIobV91cGRhdGVDaGVja0xheWVy KTsKKyAgICAgICAgbV9sYXllclRyZWVIb3N0LT5zZXRWaWV3cG9ydChJbnRTaXplKDEwLCAxMCkp OworCisgICAgICAgIHBvc3RTZXROZWVkc0NvbW1pdFRvTWFpblRocmVhZCgpOworICAgICAgICBw b3N0U2V0TmVlZHNSZWRyYXdUb01haW5UaHJlYWQoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZv aWQgZGlkQ29tbWl0QW5kRHJhd0ZyYW1lKCkKKyAgICB7CisgICAgICAgIENDTGF5ZXJUcmVlSG9z dFRlc3RUZXh0dXJlVXNhZ2U6OmRpZENvbW1pdEFuZERyYXdGcmFtZSgpOworICAgICAgICBlbmRU ZXN0KCk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGFmdGVyVGVzdCgpCisgICAgeworICAg IH0KKworcHJpdmF0ZToKKyAgICBNb2NrTGF5ZXJEZWxlZ2F0ZSBtX2RlbGVnYXRlOworICAgIFJl ZlB0cjxDb250ZW50TGF5ZXJDaHJvbWl1bVdpdGhVcGRhdGVUcmFja2luZz4gbV91cGRhdGVDaGVj a0xheWVyOworfTsKKworVEVTVF9GKENDTGF5ZXJUcmVlSG9zdFRlc3RUZXh0dXJlVXNhZ2VTaW1w bGUsIHJ1bk11bHRpVGhyZWFkKQoreworICAgIHJ1blRlc3QodHJ1ZSk7Cit9CisKK2NsYXNzIEND TGF5ZXJUcmVlSG9zdFRlc3RUZXh0dXJlVXNhZ2VNdWx0aUZyYW1lIDogcHVibGljIENDTGF5ZXJU cmVlSG9zdFRlc3RUZXh0dXJlVXNhZ2UgeworcHVibGljOgorICAgIENDTGF5ZXJUcmVlSG9zdFRl c3RUZXh0dXJlVXNhZ2VNdWx0aUZyYW1lKCkKKyAgICAgICAgOiBtX3VwZGF0ZUNoZWNrTGF5ZXIo Q29udGVudExheWVyQ2hyb21pdW1XaXRoVXBkYXRlVHJhY2tpbmc6OmNyZWF0ZSgmbV9kZWxlZ2F0 ZSwgdHJ1ZSkpCisgICAgICAgICwgbV9udW1Db21taXQoMCkKKyAgICB7CisgICAgfQorCisgICAg dmlydHVhbCB2b2lkIGJlZ2luVGVzdCgpCisgICAgeworICAgICAgICBtX2xheWVyVHJlZUhvc3Qt PnNldFJvb3RMYXllcihtX3VwZGF0ZUNoZWNrTGF5ZXIpOworICAgICAgICBtX2xheWVyVHJlZUhv c3QtPnNldFZpZXdwb3J0KEludFNpemUoMTAsIDEwKSk7CisKKyAgICAgICAgcG9zdFNldE5lZWRz Q29tbWl0VG9NYWluVGhyZWFkKCk7CisgICAgICAgIHBvc3RTZXROZWVkc1JlZHJhd1RvTWFpblRo cmVhZCgpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBkaWRDb21taXRBbmREcmF3RnJhbWUo KQorICAgIHsKKyAgICAgICAgQ0NMYXllclRyZWVIb3N0VGVzdFRleHR1cmVVc2FnZTo6ZGlkQ29t bWl0QW5kRHJhd0ZyYW1lKCk7CisgICAgICAgIGlmIChtX251bUNvbW1pdCA8IDMpIHsKKyAgICAg ICAgICAgIHBvc3RTZXROZWVkc0FuaW1hdGVBbmRDb21taXRUb01haW5UaHJlYWQoKTsKKyAgICAg ICAgICAgIHBvc3RTZXROZWVkc1JlZHJhd1RvTWFpblRocmVhZCgpOworICAgICAgICB9IGVsc2Ug eworICAgICAgICAgICAgZW5kVGVzdCgpOworICAgICAgICB9CisKKyAgICAgICAgbV9udW1Db21t aXQrKzsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgYW5pbWF0ZUFuZExheW91dChkb3VibGUg ZnJhbWVCZWdpblRpbWUpCisgICAgeworICAgICAgICBtX3VwZGF0ZUNoZWNrTGF5ZXItPnNldE5l ZWRzRGlzcGxheSgpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBhZnRlclRlc3QoKQorICAg IHsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgTW9ja0xheWVyRGVsZWdhdGUgbV9kZWxlZ2F0ZTsK KyAgICBSZWZQdHI8Q29udGVudExheWVyQ2hyb21pdW1XaXRoVXBkYXRlVHJhY2tpbmc+IG1fdXBk YXRlQ2hlY2tMYXllcjsKKyAgICBpbnQgbV9udW1Db21taXQ7Cit9OworCitURVNUX0YoQ0NMYXll clRyZWVIb3N0VGVzdFRleHR1cmVVc2FnZU11bHRpRnJhbWUsIHJ1bk11bHRpVGhyZWFkKQorewor ICAgIHJ1blRlc3QodHJ1ZSk7Cit9CisKKwogfSAvLyBuYW1lc3BhY2UKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvVGlsZWRMYXllckNocm9taXVtVGVzdC5jcHAgYi9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL1RpbGVkTGF5ZXJDaHJvbWl1bVRlc3QuY3BwCmlu ZGV4IDkzY2ZiNTcuLjVmZThlODAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v dGVzdHMvVGlsZWRMYXllckNocm9taXVtVGVzdC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS90ZXN0cy9UaWxlZExheWVyQ2hyb21pdW1UZXN0LmNwcApAQCAtNDAsNyArNDAsNyBAQCBu YW1lc3BhY2UgewogCiBjbGFzcyBGYWtlSGFuZGxlciA6IHB1YmxpYyBMYXllclRleHR1cmVVcGRh dGVyOjpIYW5kbGVyIHsKIHB1YmxpYzoKLSAgICB2aXJ0dWFsIHZvaWQgaGFuZGxlKExheWVyVGV4 dHVyZVVwZGF0ZXI6OlRleHR1cmUqLCBjb25zdCBJbnRSZWN0JiwgY29uc3QgSW50UmVjdCYpIHsg fQorICAgIHZpcnR1YWwgdm9pZCBoYW5kbGUoTGF5ZXJUZXh0dXJlVXBkYXRlcjo6VGV4dHVyZSog dGV4dHVyZSwgY29uc3QgSW50UmVjdCYgc291cmNlUmVjdCwgY29uc3QgSW50UmVjdCYpIHsgfQog fTsKIAogY2xhc3MgRmFrZUxheWVyVGV4dHVyZVVwZGF0ZXIgOiBwdWJsaWMgTGF5ZXJUZXh0dXJl VXBkYXRlciB7CkBAIC0xMzIsNiArMTMyLDcgQEAgVEVTVChUaWxlZExheWVyQ2hyb21pdW1UZXN0 LCBwdXNoRGlydHlUaWxlcykKICAgICAvLyBUaGUgdGlsZSBzaXplIGlzIDEwMHgxMDAsIHNvIHRo aXMgaW52YWxpZGF0ZXMgYW5kIHRoZW4gcGFpbnRzIHR3byB0aWxlcy4KICAgICBsYXllci0+aW52 YWxpZGF0ZVJlY3QoSW50UmVjdCgwLCAwLCAxMDAsIDIwMCkpOwogICAgIGxheWVyLT5wcmVwYXJl VG9VcGRhdGUoSW50UmVjdCgwLCAwLCAxMDAsIDIwMCkpOworICAgIGxheWVyLT5wcm90ZWN0VGls ZVRleHR1cmVzKEludFJlY3QoMCwgMCwgMTAwLCAyMDApKTsKICAgICBsYXllci0+cGFpbnRDb250 ZW50cyhJbnRSZWN0KDAsIDAsIDEwMCwgMjAwKSk7CiAgICAgbGF5ZXItPmZvckVhY2hDb21wb3Np dG9yUmVzb3VyY2UoaGFuZGxlcik7CiAgICAgbGF5ZXItPnB1c2hQcm9wZXJ0aWVzVG8obGF5ZXJJ bXBsLmdldCgpKTsKQEAgLTE0MCwxMiArMTQxLDEyIEBAIFRFU1QoVGlsZWRMYXllckNocm9taXVt VGVzdCwgcHVzaERpcnR5VGlsZXMpCiAgICAgRVhQRUNUX1RSVUUobGF5ZXJJbXBsLT5oYXNUaWxl QXQoMCwgMCkpOwogICAgIEVYUEVDVF9UUlVFKGxheWVySW1wbC0+aGFzVGlsZUF0KDAsIDEpKTsK IAotICAgIHRleHR1cmVNYW5hZ2VyLT51bnByb3RlY3RBbGxUZXh0dXJlcygpOwotCiAgICAgLy8g SW52YWxpZGF0ZXMgYm90aCB0aWxlcy4uLgogICAgIGxheWVyLT5pbnZhbGlkYXRlUmVjdChJbnRS ZWN0KDAsIDAsIDEwMCwgMjAwKSk7CiAgICAgLy8gLi4uLmJ1dCB0aGVuIG9ubHkgdXBkYXRlIG9u ZSBvZiB0aGVtLgogICAgIGxheWVyLT5wcmVwYXJlVG9VcGRhdGUoSW50UmVjdCgwLCAwLCAxMDAs IDEwMCkpOworICAgIHRleHR1cmVNYW5hZ2VyLT51bnByb3RlY3RBbGxUZXh0dXJlcygpOworICAg IGxheWVyLT5wcm90ZWN0VGlsZVRleHR1cmVzKEludFJlY3QoMCwgMCwgMTAwLCAxMDApKTsKICAg ICBsYXllci0+cGFpbnRDb250ZW50cyhJbnRSZWN0KDAsIDAsIDEwMCwgMTAwKSk7CiAgICAgbGF5 ZXItPmZvckVhY2hDb21wb3NpdG9yUmVzb3VyY2UoaGFuZGxlcik7CiAgICAgbGF5ZXItPnB1c2hQ cm9wZXJ0aWVzVG8obGF5ZXJJbXBsLmdldCgpKTsK 119619 2011-12-16 09:13:55 -0800 2012-01-06 11:10:12 -0800 Patch bug-72672-20111216121353.patch text/plain 19706 reveman U3VidmVyc2lvbiBSZXZpc2lvbjogMTAzMDcwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYzhiMGQ1OTg1OTIzMjFi OTdmNWYyZjg2MTQ5NWI4MGRjNmYwYTU1Ni4uNzMxZTRiYjg2YTZmNjc3Y2MwNzljNWFlMzliMTAy OTIwYTMyMjA2ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDExLTEyLTE2ICBEYXZp ZCBSZXZlbWFuICA8cmV2ZW1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBJ bmNyZW1lbnRhbCB0ZXh0dXJlIHVwZGF0ZXMgYXJlIG5vdCBhdG9taWMuCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MjY3MgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEVuYWJsZSBpbmNyZW1lbnRhbCBjb21t aXRzIGFuZCB1c2UgYSBuZXcgc2V0IG9mIHRleHR1cmVzIGZvciBlYWNoCisgICAgICAgIGNvbW1p dCB3aGVuIGluY3JlbWVudGFsIHRleHR1cmUgdXBkYXRlcyBhcmUgZW5hYmxlZC4KKworICAgICAg ICBUaGlzIHBhdGNoIGlzIHRlc3RlZCBieSB0aGUgZm9sbG93aW5nIHVuaXQgdGVzdDoKKyAgICAg ICAgLSBDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0LnJ1bk11bHRpVGhyZWFkCisKKyAg ICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5jcHA6Cisg ICAgICAgIChXZWJDb3JlOjpNYW5hZ2VkVGV4dHVyZTo6TWFuYWdlZFRleHR1cmUpOgorICAgICAg ICAoV2ViQ29yZTo6TWFuYWdlZFRleHR1cmU6OnN0ZWFsKToKKyAgICAgICAgKiBwbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5oOgorICAgICAgICAqIHBsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3Jl OjpUaWxlZExheWVyQ2hyb21pdW06OnByZXBhcmVUb1VwZGF0ZSk6CisgICAgICAgICogcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcDoKKyAgICAgICAgKFdl YkNvcmU6OkNDTGF5ZXJUcmVlSG9zdDo6aW5pdGlhbGl6ZSk6CisgICAgICAgIChXZWJDb3JlOjpD Q0xheWVyVHJlZUhvc3Q6OmNvbW1pdENvbXBsZXRlKToKKyAgICAgICAgKFdlYkNvcmU6OkNDTGF5 ZXJUcmVlSG9zdDo6YXBwZW5kVXNlZFRleHR1cmVPbkltcGxUaHJlYWQpOgorICAgICAgICAqIHBs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oOgorICAgICAgICAo V2ViQ29yZTo6Q0NTZXR0aW5nczo6Q0NTZXR0aW5ncyk6CisgICAgICAgICogcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vY2MvQ0NQcm94eS5oOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL2NjL0NDU2luZ2xlVGhyZWFkUHJveHkuaDoKKyAgICAgICAgKFdlYkNvcmU6OkND U2luZ2xlVGhyZWFkUHJveHk6OnBhcnRpYWxVcGRhdGVDYXBhYmlsaXR5KToKKyAgICAgICAgKiBw bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmNwcDoKKyAgICAgICAg KFdlYkNvcmU6OkNDVGhyZWFkUHJveHk6OnNjaGVkdWxlZEFjdGlvblVwZGF0ZU1vcmVSZXNvdXJj ZXMpOgorICAgICAgICAoV2ViQ29yZTo6Q0NUaHJlYWRQcm94eTo6cGFydGlhbFVwZGF0ZUNhcGFi aWxpdHkpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFk UHJveHkuaDoKKwogMjAxMS0xMi0xNCAgTmF0IER1Y2EgIDxuZHVjYUBjaHJvbWl1bS5vcmc+CiAK ICAgICAgICAgW2Nocm9taXVtXSBEZWxheUJhc2VkVGltZVNvdXJjZSBzaG91bGQgbm90IGNoYW5n ZSBpdHMgdGltZWJhc2Ugb24gbGF0ZSB0aWNrcwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9DaGFuZ2VMb2cgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRl eCAwNzRjZGY4OGE0OGQwMGVkY2JmYjg1ZDlhNTdmMjg0ZGZkNGJjMGI1Li4yODQyODdlMDNmMTFi ODBlOTljZjUxODE0N2NjYTViZTQ3NDFjMGMwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpA QCAtMSwzICsxLDM2IEBACisyMDExLTEyLTE2ICBEYXZpZCBSZXZlbWFuICA8cmV2ZW1hbkBjaHJv bWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBJbmNyZW1lbnRhbCB0ZXh0dXJlIHVwZGF0 ZXMgYXJlIG5vdCBhdG9taWMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD03MjY3MgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgor CisgICAgICAgIEFkZCBDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0IHRlc3QgdGhhdCB2 ZXJpZmllcyBhdG9taWNpdHkKKyAgICAgICAgb2YgY29tbWl0cy4KKworICAgICAgICAqIHRlc3Rz L0NDTGF5ZXJUcmVlSG9zdFRlc3QuY3BwOgorICAgICAgICAoV1RGOjpUZXN0SG9va3M6OmRpZENv bW1pdEFuZERyYXdGcmFtZSk6CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JNb2NrV2ViR3JhcGhp Y3NDb250ZXh0M0Q6OmNyZWF0ZVRleHR1cmUpOgorICAgICAgICAoV1RGOjpDb21wb3NpdG9yTW9j a1dlYkdyYXBoaWNzQ29udGV4dDNEOjpkZWxldGVUZXh0dXJlKToKKyAgICAgICAgKFdURjo6Q29t cG9zaXRvck1vY2tXZWJHcmFwaGljc0NvbnRleHQzRDo6YmluZFRleHR1cmUpOgorICAgICAgICAo V1RGOjpDb21wb3NpdG9yTW9ja1dlYkdyYXBoaWNzQ29udGV4dDNEOjpudW1UZXh0dXJlcyk6Cisg ICAgICAgIChXVEY6OkNvbXBvc2l0b3JNb2NrV2ViR3JhcGhpY3NDb250ZXh0M0Q6OnRleHR1cmUp OgorICAgICAgICAoV1RGOjpDb21wb3NpdG9yTW9ja1dlYkdyYXBoaWNzQ29udGV4dDNEOjpyZXNl dFRleHR1cmVzKToKKyAgICAgICAgKFdURjo6Q29tcG9zaXRvck1vY2tXZWJHcmFwaGljc0NvbnRl eHQzRDo6bnVtVXNlZFRleHR1cmVzKToKKyAgICAgICAgKFdURjo6Q29tcG9zaXRvck1vY2tXZWJH cmFwaGljc0NvbnRleHQzRDo6dXNlZFRleHR1cmUpOgorICAgICAgICAoV1RGOjpDb21wb3NpdG9y TW9ja1dlYkdyYXBoaWNzQ29udGV4dDNEOjpyZXNldFVzZWRUZXh0dXJlcyk6CisgICAgICAgIChX VEY6Ok1vY2tMYXllclRyZWVIb3N0Q2xpZW50OjpkaWRDb21taXRBbmREcmF3RnJhbWUpOgorICAg ICAgICAoV1RGOjpNb2NrTGF5ZXJEZWxlZ2F0ZTo6ZHJhd3NDb250ZW50KToKKyAgICAgICAgKFdU Rjo6TW9ja0xheWVyRGVsZWdhdGU6OnBhaW50Q29udGVudHMpOgorICAgICAgICAoV1RGOjpNb2Nr TGF5ZXJEZWxlZ2F0ZTo6bm90aWZ5U3luY1JlcXVpcmVkKToKKyAgICAgICAgKFdURjo6Q0NMYXll clRyZWVIb3N0VGVzdEF0b21pY0NvbW1pdDo6Q0NMYXllclRyZWVIb3N0VGVzdEF0b21pY0NvbW1p dCk6CisgICAgICAgIChXVEY6OkNDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQ6OmJlZ2lu VGVzdCk6CisgICAgICAgIChXVEY6OkNDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQ6OmNv bW1pdENvbXBsZXRlT25DQ1RocmVhZCk6CisgICAgICAgIChXVEY6OkNDTGF5ZXJUcmVlSG9zdFRl c3RBdG9taWNDb21taXQ6OmRyYXdMYXllcnNPbkNDVGhyZWFkKToKKyAgICAgICAgKFdURjo6Q0NM YXllclRyZWVIb3N0VGVzdEF0b21pY0NvbW1pdDo6YW5pbWF0ZUFuZExheW91dCk6CisgICAgICAg IChXVEY6OkNDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQ6OmFmdGVyVGVzdCk6CisgICAg ICAgIChXVEY6OlRFU1RfRik6CisKIDIwMTEtMTItMTUgIFN0ZXBoZW4gV2hpdGUgIDxzZW5vcmJs YW5jb0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgRW5hYmxlIENTU19GSUxURVJTIGluIENocm9t aXVtLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vTWFuYWdlZFRleHR1cmUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vTWFuYWdlZFRleHR1cmUuY3BwCmluZGV4IGNiZGZlMDNjMmM1NDQzYmNlYWY0M2Nh NmFmMDJhNzNjNTcxZDAzMzMuLjc4YTI0Zjk4OGZmNWNiNjIxNGRjOGQ2MzZiNjI0MmUxYWE1MjEx YzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L01hbmFnZWRUZXh0dXJlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5jcHAKQEAgLTQxLDYgKzQxLDE1IEBAIE1hbmFnZWRU ZXh0dXJlOjpNYW5hZ2VkVGV4dHVyZShUZXh0dXJlTWFuYWdlciogbWFuYWdlcikKIHsKIH0KIAor TWFuYWdlZFRleHR1cmU6Ok1hbmFnZWRUZXh0dXJlKFRleHR1cmVNYW5hZ2VyKiBtYW5hZ2VyLCBU ZXh0dXJlVG9rZW4gdG9rZW4sIEludFNpemUgc2l6ZSwgdW5zaWduZWQgZm9ybWF0LCB1bnNpZ25l ZCB0ZXh0dXJlSWQpCisgICAgOiBtX3RleHR1cmVNYW5hZ2VyKG1hbmFnZXIpCisgICAgLCBtX3Rv a2VuKHRva2VuKQorICAgICwgbV9zaXplKHNpemUpCisgICAgLCBtX2Zvcm1hdChmb3JtYXQpCisg ICAgLCBtX3RleHR1cmVJZCh0ZXh0dXJlSWQpCit7Cit9CisKIE1hbmFnZWRUZXh0dXJlOjp+TWFu YWdlZFRleHR1cmUoKQogewogICAgIGlmIChtX3Rva2VuKQpAQCAtOTYsNiArMTA1LDE3IEBAIHZv aWQgTWFuYWdlZFRleHR1cmU6OmZyYW1lYnVmZmVyVGV4dHVyZTJEKEdyYXBoaWNzQ29udGV4dDNE KiBjb250ZXh0LCBUZXh0dXJlQWxsCiAgICAgY29udGV4dC0+ZnJhbWVidWZmZXJUZXh0dXJlMkQo R3JhcGhpY3NDb250ZXh0M0Q6OkZSQU1FQlVGRkVSLCBHcmFwaGljc0NvbnRleHQzRDo6Q09MT1Jf QVRUQUNITUVOVDAsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCBtX3RleHR1cmVJZCwg MCk7CiB9CiAKK1Bhc3NPd25QdHI8TWFuYWdlZFRleHR1cmU+IE1hbmFnZWRUZXh0dXJlOjpzdGVh bCgpCit7CisgICAgTWFuYWdlZFRleHR1cmUqIHRleHR1cmUgPSBuZXcgTWFuYWdlZFRleHR1cmUo bV90ZXh0dXJlTWFuYWdlciwgbV90b2tlbiwgbV9zaXplLCBtX2Zvcm1hdCwgbV90ZXh0dXJlSWQp OworICAgIG1fdG9rZW4gPSAwOworICAgIG1fc2l6ZSA9IEludFNpemUoKTsKKyAgICBtX2Zvcm1h dCA9IDA7CisgICAgbV90ZXh0dXJlSWQgPSAwOworICAgIHJldHVybiBhZG9wdFB0cih0ZXh0dXJl KTsKK30KKworCiB9CiAKICNlbmRpZiAvLyBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcpCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5h Z2VkVGV4dHVyZS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v TWFuYWdlZFRleHR1cmUuaAppbmRleCA0ZDQzODA5NTk1MzQwZjVkNzMzZDU2NzkyOTFhOTIwNjRj N2IxYWU1Li4zMzA3ODVmNWI2OGIyMDRkODM1NDgzMTBlMWIyMWZkZmViNzhhM2NlIDEwMDY0NAot LS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5hZ2VkVGV4 dHVyZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01h bmFnZWRUZXh0dXJlLmgKQEAgLTYyLDggKzYyLDExIEBAIHB1YmxpYzoKICAgICB1bnNpZ25lZCBm b3JtYXQoKSBjb25zdCB7IHJldHVybiBtX2Zvcm1hdDsgfQogICAgIHVuc2lnbmVkIHRleHR1cmVJ ZCgpIGNvbnN0IHsgcmV0dXJuIG1fdGV4dHVyZUlkOyB9CiAKKyAgICBQYXNzT3duUHRyPE1hbmFn ZWRUZXh0dXJlPiBzdGVhbCgpOworCiBwcml2YXRlOgogICAgIGV4cGxpY2l0IE1hbmFnZWRUZXh0 dXJlKFRleHR1cmVNYW5hZ2VyKik7CisgICAgTWFuYWdlZFRleHR1cmUoVGV4dHVyZU1hbmFnZXIq LCBUZXh0dXJlVG9rZW4sIEludFNpemUsIHVuc2lnbmVkIGZvcm1hdCwgdW5zaWduZWQgdGV4dHVy ZUlkKTsKIAogICAgIFRleHR1cmVNYW5hZ2VyKiBtX3RleHR1cmVNYW5hZ2VyOwogICAgIFRleHR1 cmVUb2tlbiBtX3Rva2VuOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAKaW5kZXggODdj YmE4ODgxMTY3NzE1NTdjODVkNjJlNzFlNTZlMjFjM2U0ODQxOS4uNjBmMGMzZDgzNzliODY2Zjg4 NDI0NTI3ODU2Mzk4MDY3Mjg1NTQ2ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3Bw CkBAIC0zODIsNiArMzgyLDkgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnByZXBhcmVUb1Vw ZGF0ZShjb25zdCBJbnRSZWN0JiBjb250ZW50UmVjdCkKICAgICAgICAgICAgIGlmICghdGlsZSkK ICAgICAgICAgICAgICAgICB0aWxlID0gY3JlYXRlVGlsZShpLCBqKTsKIAorICAgICAgICAgICAg aWYgKHRpbGUtPmlzRGlydHkoKSAmJiBsYXllclRyZWVIb3N0KCkgJiYgIWxheWVyVHJlZUhvc3Qo KS0+c2V0dGluZ3MoKS5wYXJ0aWFsVXBkYXRlcykKKyAgICAgICAgICAgICAgICBsYXllclRyZWVI b3N0KCktPmFwcGVuZFVzZWRUZXh0dXJlT25JbXBsVGhyZWFkKHRpbGUtPm1hbmFnZWRUZXh0dXJl KCktPnN0ZWFsKCkpOworCiAgICAgICAgICAgICBpZiAoIXRpbGUtPm1hbmFnZWRUZXh0dXJlKCkt PmlzVmFsaWQobV90aWxlci0+dGlsZVNpemUoKSwgbV90ZXh0dXJlRm9ybWF0KSkKICAgICAgICAg ICAgICAgICB0aWxlLT5tX2RpcnR5TGF5ZXJSZWN0ID0gbV90aWxlci0+dGlsZUxheWVyUmVjdCh0 aWxlKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAKaW5kZXggNzkwNjQ0MDhlZTBi YWMxMzRlY2VhZWYzMTcyZjZlY2NiMjI5NWEwNC4uMzBiYThhZGEzMDg1NTk3MjM1ZDA0YjQzM2Y2 NDllN2MyYmE3NWY5NyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwCkBAIC05Myw2 ICs5Myw5IEBAIGJvb2wgQ0NMYXllclRyZWVIb3N0Ojppbml0aWFsaXplKCkKICAgICAvLyBVcGRh dGUgbV9zZXR0aW5ncyBiYXNlZCBvbiBjYXBhYmlsaXRpZXMgdGhhdCB3ZSBnb3QgYmFjayBmcm9t IHRoZSByZW5kZXJlci4KICAgICBtX3NldHRpbmdzLmFjY2VsZXJhdGVQYWludGluZyA9IG1fcHJv eHktPmxheWVyUmVuZGVyZXJDYXBhYmlsaXRpZXMoKS51c2luZ0FjY2VsZXJhdGVkUGFpbnRpbmc7 CiAKKyAgICAvLyBVcGRhdGUgbV9zZXR0aW5ncyBiYXNlZCBvbiBwYXJ0aWFsIHVwZGF0ZSBjYXBh YmlsaXR5LgorICAgIG1fc2V0dGluZ3MucGFydGlhbFVwZGF0ZXMgPSBtX3Byb3h5LT5wYXJ0aWFs VXBkYXRlQ2FwYWJpbGl0eSgpOworCiAgICAgbV9jb250ZW50c1RleHR1cmVNYW5hZ2VyID0gVGV4 dHVyZU1hbmFnZXI6OmNyZWF0ZShUZXh0dXJlTWFuYWdlcjo6aGlnaExpbWl0Qnl0ZXModmlld3Bv cnRTaXplKCkpLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgVGV4dHVyZU1hbmFnZXI6OnJlY2xhaW1MaW1pdEJ5dGVzKHZpZXdwb3J0U2l6ZSgp KSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg IG1fcHJveHktPmxheWVyUmVuZGVyZXJDYXBhYmlsaXRpZXMoKS5tYXhUZXh0dXJlU2l6ZSk7CkBA IC0xNTgsNiArMTYxLDcgQEAgdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OmZpbmlzaENvbW1pdE9uSW1w bFRocmVhZChDQ0xheWVyVHJlZUhvc3RJbXBsKiBob3N0SW1wbCkKIAogdm9pZCBDQ0xheWVyVHJl ZUhvc3Q6OmNvbW1pdENvbXBsZXRlKCkKIHsKKyAgICBtX3VzZWRUZXh0dXJlc09uSW1wbFRocmVh ZC5jbGVhcigpOwogICAgIGNsZWFyUGVuZGluZ1VwZGF0ZSgpOwogICAgIG1fY29udGVudHNUZXh0 dXJlTWFuYWdlci0+dW5wcm90ZWN0QWxsVGV4dHVyZXMoKTsKIH0KQEAgLTUwMyw0ICs1MDcsOSBA QCB2b2lkIENDTGF5ZXJUcmVlSG9zdDo6c3RvcFJhdGVMaW1pdGVyKEdyYXBoaWNzQ29udGV4dDNE KiBjb250ZXh0KQogICAgIH0KIH0KIAordm9pZCBDQ0xheWVyVHJlZUhvc3Q6OmFwcGVuZFVzZWRU ZXh0dXJlT25JbXBsVGhyZWFkKFBhc3NPd25QdHI8TWFuYWdlZFRleHR1cmU+IHRleHR1cmUpCit7 CisgICAgbV91c2VkVGV4dHVyZXNPbkltcGxUaHJlYWQuYXBwZW5kKHRleHR1cmUpOworfQorCiB9 CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9j Yy9DQ0xheWVyVHJlZUhvc3QuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oCmluZGV4IDJhZjQyNjYwNzcwMzQ3ZTUxYThjNjA2 MGQzOWQ2ZWNiYjZhMTYzZDQuLjA2ODVmZjIxYWJlYTc5NWQ4MGU0NWRlNmEwZmI1NWU0YWExODkz MGUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L2NjL0NDTGF5ZXJUcmVlSG9zdC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oCkBAIC03NSw3ICs3NSw4IEBAIHN0cnVj dCBDQ1NldHRpbmdzIHsKICAgICAgICAgICAgICwgc2hvd1BsYXRmb3JtTGF5ZXJUcmVlKGZhbHNl KQogICAgICAgICAgICAgLCByZWZyZXNoUmF0ZSgwKQogICAgICAgICAgICAgLCBwZXJUaWxlUGFp bnRpbmcoZmFsc2UpCi0gICAgICAgICAgICAsIHBhcnRpYWxTd2FwRW5hYmxlZChmYWxzZSkgeyB9 CisgICAgICAgICAgICAsIHBhcnRpYWxTd2FwRW5hYmxlZChmYWxzZSkKKyAgICAgICAgICAgICwg cGFydGlhbFVwZGF0ZXMoZmFsc2UpIHsgfQogCiAgICAgYm9vbCBhY2NlbGVyYXRlUGFpbnRpbmc7 CiAgICAgYm9vbCBjb21wb3NpdGVPZmZzY3JlZW47CkBAIC04NCw2ICs4NSw3IEBAIHN0cnVjdCBD Q1NldHRpbmdzIHsKICAgICBkb3VibGUgcmVmcmVzaFJhdGU7CiAgICAgYm9vbCBwZXJUaWxlUGFp bnRpbmc7CiAgICAgYm9vbCBwYXJ0aWFsU3dhcEVuYWJsZWQ7CisgICAgYm9vbCBwYXJ0aWFsVXBk YXRlczsKIH07CiAKIC8vIFByb3ZpZGVzIGluZm9ybWF0aW9uIG9uIGFuIEltcGwncyByZW5kZXJp bmcgY2FwYWJpbGl0aWVzIGJhY2sgdG8gdGhlIENDTGF5ZXJUcmVlSG9zdApAQCAtMTk1LDEyICsx OTcsMTUgQEAgcHVibGljOgogICAgIHZvaWQgc3RhcnRSYXRlTGltaXRlcihHcmFwaGljc0NvbnRl eHQzRCopOwogICAgIHZvaWQgc3RvcFJhdGVMaW1pdGVyKEdyYXBoaWNzQ29udGV4dDNEKik7CiAK KyAgICB2b2lkIGFwcGVuZFVzZWRUZXh0dXJlT25JbXBsVGhyZWFkKFBhc3NPd25QdHI8TWFuYWdl ZFRleHR1cmU+KTsKKwogcHJvdGVjdGVkOgogICAgIENDTGF5ZXJUcmVlSG9zdChDQ0xheWVyVHJl ZUhvc3RDbGllbnQqLCBjb25zdCBDQ1NldHRpbmdzJik7CiAgICAgYm9vbCBpbml0aWFsaXplKCk7 CiAKIHByaXZhdGU6CiAgICAgdHlwZWRlZiBWZWN0b3I8UmVmUHRyPExheWVyQ2hyb21pdW0+ID4g TGF5ZXJMaXN0OworICAgIHR5cGVkZWYgVmVjdG9yPE93blB0cjxNYW5hZ2VkVGV4dHVyZT4gPiBU ZXh0dXJlTGlzdDsKIAogICAgIHZvaWQgcGFpbnRMYXllckNvbnRlbnRzKGNvbnN0IExheWVyTGlz dCYpOwogICAgIHZvaWQgcGFpbnRNYXNrQW5kUmVwbGljYUZvclJlbmRlclN1cmZhY2UoTGF5ZXJD aHJvbWl1bSopOwpAQCAtMjM0LDYgKzIzOSw4IEBAIHByaXZhdGU6CiAKICAgICBmbG9hdCBtX3Bh Z2VTY2FsZTsKICAgICBmbG9hdCBtX21pblBhZ2VTY2FsZSwgbV9tYXhQYWdlU2NhbGU7CisKKyAg ICBUZXh0dXJlTGlzdCBtX3VzZWRUZXh0dXJlc09uSW1wbFRocmVhZDsKIH07CiAKIH0KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDUHJv eHkuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDUHJv eHkuaAppbmRleCBiYjM3ODAxNDdiMTZjMjZiNzVhN2NjZDIyYWE4YjhmZTg0ZTc2YmJkLi5hNTVl NTEyZGUyMmRkYmU5MTVmMzIxNzY4YWJiZTdjMGIxOGJkNDE2IDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1Byb3h5LmgKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NQcm94eS5oCkBAIC03 OSw2ICs3OSw4IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc3RhcnQoKSA9IDA7IC8vIE11 c3QgYmUgY2FsbGVkIGJlZm9yZSB1c2luZyB0aGUgcHJveHkuCiAgICAgdmlydHVhbCB2b2lkIHN0 b3AoKSA9IDA7IC8vIE11c3QgYmUgY2FsbGVkIGJlZm9yZSBkZWxldGluZyB0aGUgcHJveHkuCiAK KyAgICB2aXJ0dWFsIGJvb2wgcGFydGlhbFVwZGF0ZUNhcGFiaWxpdHkoKSBjb25zdCA9IDA7CisK ICAgICAvLyBEZWJ1ZyBob29rcwogI2lmbmRlZiBOREVCVUcKICAgICBzdGF0aWMgYm9vbCBpc01h aW5UaHJlYWQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL2NjL0NDU2luZ2xlVGhyZWFkUHJveHkuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDU2luZ2xlVGhyZWFkUHJveHkuaAppbmRleCAwZDVh NGEyZDhhNTE2YjFkN2JjZjk5MWE5OWUxYzc4Nzg5OTQzZWM1Li5lYTRmM2YwN2U2ZGI0ZWRjZDg0 MjZkMDBhMTU0OTI2N2I4NWIzMjIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1NpbmdsZVRocmVhZFByb3h5LmgKKysrIGIvU291cmNl L1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NTaW5nbGVUaHJlYWRQcm94 eS5oCkBAIC01NCw2ICs1NCw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc2V0VmlzaWJs ZShib29sKTsKICAgICB2aXJ0dWFsIHZvaWQgc3RhcnQoKTsKICAgICB2aXJ0dWFsIHZvaWQgc3Rv cCgpOworICAgIHZpcnR1YWwgYm9vbCBwYXJ0aWFsVXBkYXRlQ2FwYWJpbGl0eSgpIGNvbnN0IHsg cmV0dXJuIHRydWU7IH0KIAogICAgIC8vIENDTGF5ZXJUcmVlSG9zdEltcGxDbGllbnQgaW1wbGVt ZW50YXRpb24KICAgICB2aXJ0dWFsIHZvaWQgb25Td2FwQnVmZmVyc0NvbXBsZXRlT25JbXBsVGhy ZWFkKCkgeyBBU1NFUlRfTk9UX1JFQUNIRUQoKTsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmNw cAppbmRleCBjMDBkZDY2ZTUzNGFhMzQ0NGY2YmU4YWQ0YWFmMWQ4NTljZDE0ZmQ2Li5lMjhkYmVi YjA1ODc4NDM1MjEwMTc2NGY0MTY1MTQyYzFiMjQ0ZWEzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmNwcAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFBy b3h5LmNwcApAQCAtMzksOCArMzksMTUgQEAKICNpbmNsdWRlIDx3dGYvQ3VycmVudFRpbWUuaD4K ICNpbmNsdWRlIDx3dGYvTWFpblRocmVhZC5oPgogCit1c2luZyBuYW1lc3BhY2Ugc3RkOwogdXNp bmcgbmFtZXNwYWNlIFdURjsKIAorbmFtZXNwYWNlIHsKKworc3RhdGljIGNvbnN0IHNpemVfdCB1 cGRhdGVzUGVyRnJhbWUgPSA1OworCit9IC8vIGFub255bW91cyBuYW1lc3BhY2UKKwogbmFtZXNw YWNlIFdlYkNvcmUgewogCiBQYXNzT3duUHRyPENDUHJveHk+IENDVGhyZWFkUHJveHk6OmNyZWF0 ZShDQ0xheWVyVHJlZUhvc3QqIGxheWVyVHJlZUhvc3QpCkBAIC00NDAsOCArNDQ3LDcgQEAgdm9p ZCBDQ1RocmVhZFByb3h5OjpzY2hlZHVsZWRBY3Rpb25VcGRhdGVNb3JlUmVzb3VyY2VzKCkKIHsK ICAgICBUUkFDRV9FVkVOVCgiQ0NUaHJlYWRQcm94eTo6c2NoZWR1bGVkQWN0aW9uVXBkYXRlTW9y ZVJlc291cmNlcyIsIHRoaXMsIDApOwogICAgIEFTU0VSVChtX2N1cnJlbnRUZXh0dXJlVXBkYXRl ck9uSW1wbFRocmVhZCk7Ci0gICAgc3RhdGljIGNvbnN0IGludCBVcGRhdGVzUGVyRnJhbWUgPSA5 OTk5OTsKLSAgICBtX2N1cnJlbnRUZXh0dXJlVXBkYXRlck9uSW1wbFRocmVhZC0+dXBkYXRlKG1f bGF5ZXJUcmVlSG9zdEltcGwtPmNvbnRleHQoKSwgVXBkYXRlc1BlckZyYW1lKTsKKyAgICBtX2N1 cnJlbnRUZXh0dXJlVXBkYXRlck9uSW1wbFRocmVhZC0+dXBkYXRlKG1fbGF5ZXJUcmVlSG9zdElt cGwtPmNvbnRleHQoKSwgdXBkYXRlc1BlckZyYW1lKTsKIH0KIAogdm9pZCBDQ1RocmVhZFByb3h5 OjpzY2hlZHVsZWRBY3Rpb25Db21taXQoKQpAQCAtNTY3LDQgKzU3Myw5IEBAIHZvaWQgQ0NUaHJl YWRQcm94eTo6bGF5ZXJUcmVlSG9zdENsb3NlZE9uSW1wbFRocmVhZChDQ0NvbXBsZXRpb25FdmVu dCogY29tcGxldGlvCiAgICAgY29tcGxldGlvbi0+c2lnbmFsKCk7CiB9CiAKK2Jvb2wgQ0NUaHJl YWRQcm94eTo6cGFydGlhbFVwZGF0ZUNhcGFiaWxpdHkoKSBjb25zdAoreworICAgIHJldHVybiB1 cGRhdGVzUGVyRnJhbWUgPT0gbnVtZXJpY19saW1pdHM8c2l6ZV90Pjo6bWF4KCk7Cit9CisKIH0g Ly8gbmFtZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuaCBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuaAppbmRleCBhNDFjMGQ1 NjRiNjM4MTNiYTYzYTZjZWQ1OGUwNGQ2OWMzOGYyZGVhLi5hOWVlYmYzYzdmM2VjYmE0NGJkYjM5 MjA2NzhiZjg3ZTI0NjZlMWZlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmgKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5oCkBAIC02Miw2ICs2 Miw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc2V0VmlzaWJsZShib29sKTsKICAgICB2 aXJ0dWFsIHZvaWQgc3RhcnQoKTsKICAgICB2aXJ0dWFsIHZvaWQgc3RvcCgpOworICAgIHZpcnR1 YWwgYm9vbCBwYXJ0aWFsVXBkYXRlQ2FwYWJpbGl0eSgpIGNvbnN0OwogCiAgICAgLy8gQ0NMYXll clRyZWVIb3N0SW1wbENsaWVudCBpbXBsZW1lbnRhdGlvbgogICAgIHZpcnR1YWwgdm9pZCBvblN3 YXBCdWZmZXJzQ29tcGxldGVPbkltcGxUaHJlYWQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vdGVzdHMvQ0NMYXllclRyZWVIb3N0VGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3Rlc3RzL0NDTGF5ZXJUcmVlSG9zdFRlc3QuY3BwCmluZGV4IDliYjdlZGZhNDUy MTUwODFlNjQ5NmQxY2ExZTBjMzU5MjBiNmQ5MjQuLmJiNjQ2Y2Y5ZDkwOWMxNGQxZjI5NTczYTZm MGQ1OGMyODk2NzNjYTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMv Q0NMYXllclRyZWVIb3N0VGVzdC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0 cy9DQ0xheWVyVHJlZUhvc3RUZXN0LmNwcApAQCAtNDAsNiArNDAsNyBAQAogI2luY2x1ZGUgImNj L0NDVGhyZWFkVGFzay5oIgogI2luY2x1ZGUgInBsYXRmb3JtL1dlYktpdFBsYXRmb3JtU3VwcG9y dC5oIgogI2luY2x1ZGUgInBsYXRmb3JtL1dlYlRocmVhZC5oIgorI2luY2x1ZGUgPGdtb2NrL2dt b2NrLmg+CiAjaW5jbHVkZSA8Z3Rlc3QvZ3Rlc3QuaD4KICNpbmNsdWRlIDx3ZWJraXQvc3VwcG9y dC93ZWJraXRfc3VwcG9ydC5oPgogI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CkBAIC02MCw2 ICs2MSw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgZHJhd0xheWVyc09uQ0NUaHJlYWQo Q0NMYXllclRyZWVIb3N0SW1wbCopIHsgfQogICAgIHZpcnR1YWwgdm9pZCBhcHBseVNjcm9sbEFu ZFNjYWxlKGNvbnN0IEludFNpemUmLCBmbG9hdCkgeyB9CiAgICAgdmlydHVhbCB2b2lkIGFuaW1h dGVBbmRMYXlvdXQoZG91YmxlIGZyYW1lQmVnaW5UaW1lKSB7IH0KKyAgICB2aXJ0dWFsIHZvaWQg ZGlkQ29tbWl0QW5kRHJhd0ZyYW1lKCkgeyB9CiB9OwogCiAvLyBBZGFwdHMgQ0NMYXllclRyZWVI b3N0SW1wbCBmb3IgdGVzdC4gUnVucyByZWFsIGNvZGUsIHRoZW4gaW52b2tlcyB0ZXN0IGhvb2tz LgpAQCAtMTQyLDkgKzE0NCw0MSBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCBXZWJHTElkIGNyZWF0 ZVNoYWRlcihXR0MzRGVudW0pIHsgcmV0dXJuIDE7IH0KICAgICB2aXJ0dWFsIHZvaWQgZ2V0U2hh ZGVyaXYoV2ViR0xJZCwgV0dDM0RlbnVtLCBXR0MzRGludCogdmFsdWUpIHsgKnZhbHVlID0gMTsg fQogICAgIHZpcnR1YWwgdm9pZCBnZXRQcm9ncmFtaXYoV2ViR0xJZCwgV0dDM0RlbnVtLCBXR0Mz RGludCogdmFsdWUpIHsgKnZhbHVlID0gMTsgfQorICAgIHZpcnR1YWwgV2ViR0xJZCBjcmVhdGVU ZXh0dXJlKCkKKyAgICB7CisgICAgICAgIFdlYkdMSWQgdGV4dHVyZSA9IG1fdGV4dHVyZXMuc2l6 ZSgpICsgMTsKKyAgICAgICAgbV90ZXh0dXJlcy5wdXNoX2JhY2sodGV4dHVyZSk7CisgICAgICAg IHJldHVybiB0ZXh0dXJlOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBkZWxldGVUZXh0dXJl KFdlYkdMSWQgdGV4dHVyZSkKKyAgICB7CisgICAgICAgIGZvciAoc3RkOjp2ZWN0b3I8V2ViR0xJ ZD46Oml0ZXJhdG9yIGl0ID0gbV90ZXh0dXJlcy5iZWdpbigpOyBpdCAhPSBtX3RleHR1cmVzLmVu ZCgpOyBpdCsrKSB7CisgICAgICAgICAgICBpZiAoKml0ID09IHRleHR1cmUpIHsKKyAgICAgICAg ICAgICAgICBtX3RleHR1cmVzLmVyYXNlKGl0KTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAg ICAgICAgICAgIH0KKyAgICAgICAgfQorICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBiaW5kVGV4 dHVyZShXR0MzRGVudW0gLyogdGFyZ2V0ICovLCBXZWJHTElkIHRleHR1cmUpCisgICAgeworICAg ICAgICBtX3VzZWRUZXh0dXJlcy5pbnNlcnQodGV4dHVyZSk7CisgICAgfQorCisgICAgaW50IG51 bVRleHR1cmVzKCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8aW50PihtX3RleHR1cmVzLnNp emUoKSk7IH0KKyAgICBpbnQgdGV4dHVyZShpbnQgaSkgY29uc3QgeyByZXR1cm4gbV90ZXh0dXJl c1tpXTsgfQorICAgIHZvaWQgcmVzZXRUZXh0dXJlcygpIHsgbV90ZXh0dXJlcy5jbGVhcigpOyB9 CisKKyAgICBpbnQgbnVtVXNlZFRleHR1cmVzKCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8 aW50PihtX3VzZWRUZXh0dXJlcy5zaXplKCkpOyB9CisgICAgYm9vbCB1c2VkVGV4dHVyZShpbnQg dGV4dHVyZSkgY29uc3QgeyByZXR1cm4gbV91c2VkVGV4dHVyZXMuZmluZCh0ZXh0dXJlKSAhPSBt X3VzZWRUZXh0dXJlcy5lbmQoKTsgfQorICAgIHZvaWQgcmVzZXRVc2VkVGV4dHVyZXMoKSB7IG1f dXNlZFRleHR1cmVzLmNsZWFyKCk7IH0KIAogcHJpdmF0ZToKICAgICBDb21wb3NpdG9yTW9ja1dl YkdyYXBoaWNzQ29udGV4dDNEKCkgeyB9CisKKyAgICBzdGQ6OnZlY3RvcjxXZWJHTElkPiBtX3Rl eHR1cmVzOworICAgIHN0ZDo6c2V0PFdlYkdMSWQ+IG1fdXNlZFRleHR1cmVzOwogfTsKIAogLy8g SW1wbGVtZW50YXRpb24gb2YgQ0NMYXllclRyZWVIb3N0IGNhbGxiYWNrIGludGVyZmFjZS4KQEAg LTE3NSw2ICsyMDksNyBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ29tbWl0QW5k RHJhd0ZyYW1lKCkKICAgICB7CisgICAgICAgIG1fdGVzdEhvb2tzLT5kaWRDb21taXRBbmREcmF3 RnJhbWUoKTsKICAgICB9CiAKICAgICB2aXJ0dWFsIHZvaWQgZGlkQ29tcGxldGVTd2FwQnVmZmVy cygpCkBAIC0xMDI5LDQgKzEwNjQsOTkgQEAgVEVTVF9GKENDTGF5ZXJUcmVlSG9zdFRlc3RPcGFj aXR5Q2hhbmdlLCBydW5NdWx0aVRocmVhZCkKICAgICBydW5UZXN0KHRydWUpOwogfQogCitjbGFz cyBNb2NrTGF5ZXJEZWxlZ2F0ZSA6IHB1YmxpYyBDQ0xheWVyRGVsZWdhdGUgeworcHVibGljOgor ICAgIGJvb2wgZHJhd3NDb250ZW50KCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfQorICAgIE1PQ0tf Q09OU1RfTUVUSE9EMChwcmVzZXJ2ZXMzRCwgYm9vbCgpKTsKKyAgICB2b2lkIHBhaW50Q29udGVu dHMoR3JhcGhpY3NDb250ZXh0JiwgY29uc3QgSW50UmVjdCYpIHsgfQorICAgIHZvaWQgbm90aWZ5 U3luY1JlcXVpcmVkKCkgeyB9Cit9OworCisvLyBWZXJpZnkgYXRvbWljaXR5IG9mIGNvbW1pdHMg YW5kIHJldXNlIG9mIHRleHR1cmVzLgorY2xhc3MgQ0NMYXllclRyZWVIb3N0VGVzdEF0b21pY0Nv bW1pdCA6IHB1YmxpYyBDQ0xheWVyVHJlZUhvc3RUZXN0IHsKK3B1YmxpYzoKKyAgICBDQ0xheWVy VHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0KCkKKyAgICAgICAgOiBtX3VwZGF0ZUNoZWNrTGF5ZXIo Q29udGVudExheWVyQ2hyb21pdW1XaXRoVXBkYXRlVHJhY2tpbmc6OmNyZWF0ZSgmbV9kZWxlZ2F0 ZSkpCisgICAgICAgICwgbV9udW1Db21taXRzKDApCisgICAgeworICAgIH0KKworICAgIHZpcnR1 YWwgdm9pZCBiZWdpblRlc3QoKQorICAgIHsKKyAgICAgICAgbV9sYXllclRyZWVIb3N0LT5zZXRS b290TGF5ZXIobV91cGRhdGVDaGVja0xheWVyKTsKKyAgICAgICAgbV9sYXllclRyZWVIb3N0LT5z ZXRWaWV3cG9ydChJbnRTaXplKDEwLCAxMCkpOworCisgICAgICAgIHBvc3RTZXROZWVkc0NvbW1p dFRvTWFpblRocmVhZCgpOworICAgICAgICBwb3N0U2V0TmVlZHNSZWRyYXdUb01haW5UaHJlYWQo KTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgY29tbWl0Q29tcGxldGVPbkNDVGhyZWFkKEND TGF5ZXJUcmVlSG9zdEltcGwqIGltcGwpCisgICAgeworICAgICAgICBDb21wb3NpdG9yTW9ja1dl YkdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0ID0gc3RhdGljX2Nhc3Q8Q29tcG9zaXRvck1vY2tX ZWJHcmFwaGljc0NvbnRleHQzRCo+KEdyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZTo6ZXh0cmFjdFdl YkdyYXBoaWNzQ29udGV4dDNEKGltcGwtPmNvbnRleHQoKSkpOworCisgICAgICAgIHN3aXRjaCAo aW1wbC0+ZnJhbWVOdW1iZXIoKSkgeworICAgICAgICBjYXNlIDA6CisgICAgICAgICAgICAvLyBO dW1iZXIgb2YgdGV4dHVyZXMgc2hvdWxkIGJlIG9uZS4KKyAgICAgICAgICAgIEVYUEVDVF9FUSgx LCBjb250ZXh0LT5udW1UZXh0dXJlcygpKTsKKyAgICAgICAgICAgIC8vIE51bWJlciBvZiB0ZXh0 dXJlcyB1c2VkIGZvciBjb21taXQgc2hvdWxkIGJlIG9uZS4KKyAgICAgICAgICAgIEVYUEVDVF9F USgxLCBjb250ZXh0LT5udW1Vc2VkVGV4dHVyZXMoKSk7CisgICAgICAgICAgICAvLyBWZXJpZnkg dXNlZCB0ZXh0dXJlIGlzIGNvcnJlY3QuCisgICAgICAgICAgICBFWFBFQ1RfVFJVRShjb250ZXh0 LT51c2VkVGV4dHVyZShjb250ZXh0LT50ZXh0dXJlKDApKSk7CisKKyAgICAgICAgICAgIGNvbnRl eHQtPnJlc2V0VXNlZFRleHR1cmVzKCk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgY2Fz ZSAxOgorICAgICAgICAgICAgLy8gTnVtYmVyIG9mIHRleHR1cmVzIHNob3VsZCBiZSB0d28gYXMg dGhlIGZpcnN0IHRleHR1cmUKKyAgICAgICAgICAgIC8vIGlzIHVzZWQgYnkgaW1wbCB0aHJlYWQg YW5kIGNhbm5vdCBieSB1c2VkIGZvciB1cGRhdGUuCisgICAgICAgICAgICBFWFBFQ1RfRVEoMiwg Y29udGV4dC0+bnVtVGV4dHVyZXMoKSk7CisgICAgICAgICAgICAvLyBOdW1iZXIgb2YgdGV4dHVy ZXMgdXNlZCBmb3IgY29tbWl0IHNob3VsZCBzdGlsbCBiZSBvbmUuCisgICAgICAgICAgICBFWFBF Q1RfRVEoMSwgY29udGV4dC0+bnVtVXNlZFRleHR1cmVzKCkpOworICAgICAgICAgICAgLy8gRmly c3QgdGV4dHVyZSBzaG91bGQgbm90IGhhdmUgYmVlbiB1c2VkLgorICAgICAgICAgICAgRVhQRUNU X0ZBTFNFKGNvbnRleHQtPnVzZWRUZXh0dXJlKGNvbnRleHQtPnRleHR1cmUoMCkpKTsKKyAgICAg ICAgICAgIC8vIE5ldyB0ZXh0dXJlIHNob3VsZCBoYXZlIGJlZW4gdXNlZC4KKyAgICAgICAgICAg IEVYUEVDVF9UUlVFKGNvbnRleHQtPnVzZWRUZXh0dXJlKGNvbnRleHQtPnRleHR1cmUoMSkpKTsK KworICAgICAgICAgICAgY29udGV4dC0+cmVzZXRVc2VkVGV4dHVyZXMoKTsKKyAgICAgICAgICAg IGJyZWFrOworICAgICAgICBkZWZhdWx0OgorICAgICAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVE KCk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgfQorICAgIH0KKworICAgIHZpcnR1YWwg dm9pZCBkcmF3TGF5ZXJzT25DQ1RocmVhZChDQ0xheWVyVHJlZUhvc3RJbXBsKiBpbXBsKQorICAg IHsKKyAgICAgICAgQ29tcG9zaXRvck1vY2tXZWJHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCA9 IHN0YXRpY19jYXN0PENvbXBvc2l0b3JNb2NrV2ViR3JhcGhpY3NDb250ZXh0M0QqPihHcmFwaGlj c0NvbnRleHQzRFByaXZhdGU6OmV4dHJhY3RXZWJHcmFwaGljc0NvbnRleHQzRChpbXBsLT5jb250 ZXh0KCkpKTsKKworICAgICAgICAvLyBOdW1iZXIgb2YgdGV4dHVyZXMgdXNlZCBmb3IgZHJhdyBz aG91bGQgYWx3YXlzIGJlIG9uZS4KKyAgICAgICAgRVhQRUNUX0VRKDEsIGNvbnRleHQtPm51bVVz ZWRUZXh0dXJlcygpKTsKKworICAgICAgICBpZiAoaW1wbC0+ZnJhbWVOdW1iZXIoKSA8IDIpIHsK KyAgICAgICAgICAgIGNvbnRleHQtPnJlc2V0VXNlZFRleHR1cmVzKCk7CisgICAgICAgICAgICBw b3N0U2V0TmVlZHNBbmltYXRlQW5kQ29tbWl0VG9NYWluVGhyZWFkKCk7CisgICAgICAgICAgICBw b3N0U2V0TmVlZHNSZWRyYXdUb01haW5UaHJlYWQoKTsKKyAgICAgICAgfSBlbHNlCisgICAgICAg ICAgICBlbmRUZXN0KCk7CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGFuaW1hdGVBbmRMYXlv dXQoZG91YmxlIGZyYW1lQmVnaW5UaW1lKQorICAgIHsKKyAgICAgICAgbV91cGRhdGVDaGVja0xh eWVyLT5zZXROZWVkc0Rpc3BsYXkoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgYWZ0ZXJU ZXN0KCkKKyAgICB7CisgICAgfQorCitwcml2YXRlOgorICAgIE1vY2tMYXllckRlbGVnYXRlIG1f ZGVsZWdhdGU7CisgICAgUmVmUHRyPENvbnRlbnRMYXllckNocm9taXVtV2l0aFVwZGF0ZVRyYWNr aW5nPiBtX3VwZGF0ZUNoZWNrTGF5ZXI7CisgICAgaW50IG1fbnVtQ29tbWl0czsKK307CisKK1RF U1RfRihDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0LCBydW5NdWx0aVRocmVhZCkKK3sK KyAgICBydW5UZXN0KHRydWUpOworfQorCiB9IC8vIG5hbWVzcGFjZQo= 121449 2012-01-06 11:10:16 -0800 2012-01-09 09:59:07 -0800 Patch bug-72672-20120106141015.patch text/plain 21932 reveman U3VidmVyc2lvbiBSZXZpc2lvbjogMTA0MjkzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNWI1ZTRiYzQ3MGFkZTNl NWY5ZDk4ZDYzZWY0MzI1NjczMjg2YjYwNy4uNGIwMDYxYzM4NzQyMDI0ZDJlNjY0MTdiMTU4NTg5 N2VjZWQ4OTYyYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDEyLTAxLTA2ICBEYXZp ZCBSZXZlbWFuICA8cmV2ZW1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBJ bmNyZW1lbnRhbCB0ZXh0dXJlIHVwZGF0ZXMgYXJlIG5vdCBhdG9taWMuCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MjY3MgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFVzZSBhIG5ldyBzZXQgb2YgdGV4dHVy ZXMgZm9yIGVhY2ggY29tbWl0IHdoZW4gaW5jcmVtZW50YWwKKyAgICAgICAgdGV4dHVyZSB1cGRh dGVzIGFyZSBlbmFibGVkLgorCisgICAgICAgIFRoaXMgcGF0Y2ggaXMgdGVzdGVkIGJ5IHRoZSBm b2xsb3dpbmcgdW5pdCB0ZXN0OgorICAgICAgICAtIENDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWND b21taXQucnVuTXVsdGlUaHJlYWQKKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL01hbmFnZWRUZXh0dXJlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1hbmFnZWRUZXh0dXJl OjpNYW5hZ2VkVGV4dHVyZSk6CisgICAgICAgIChXZWJDb3JlOjpNYW5hZ2VkVGV4dHVyZTo6c3Rl YWwpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRUZXh0dXJl Lmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9t aXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRv VXBkYXRlVGlsZXMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND TGF5ZXJUcmVlSG9zdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6Omlu aXRpYWxpemUpOgorICAgICAgICAoV2ViQ29yZTo6Q0NMYXllclRyZWVIb3N0Ojpjb21taXRDb21w bGV0ZSk6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6OmRlbGV0ZVRleHR1cmVB ZnRlckNvbW1pdCk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NM YXllclRyZWVIb3N0Lmg6CisgICAgICAgIChXZWJDb3JlOjpDQ1NldHRpbmdzOjpDQ1NldHRpbmdz KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1Byb3h5Lmg6Cisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NTaW5nbGVUaHJlYWRQcm94 eS5oOgorICAgICAgICAoV2ViQ29yZTo6Q0NTaW5nbGVUaHJlYWRQcm94eTo6cGFydGlhbFRleHR1 cmVVcGRhdGVDYXBhYmlsaXR5KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9jYy9DQ1RocmVhZFByb3h5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNDVGhyZWFkUHJveHk6 OnNjaGVkdWxlZEFjdGlvblVwZGF0ZU1vcmVSZXNvdXJjZXMpOgorICAgICAgICAoV2ViQ29yZTo6 Q0NUaHJlYWRQcm94eTo6cGFydGlhbFRleHR1cmVVcGRhdGVDYXBhYmlsaXR5KToKKyAgICAgICAg KiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5Lmg6CisKIDIwMTIt MDEtMDUgIEFudHRpIEtvaXZpc3RvICA8YW50dGlAYXBwbGUuY29tPgogCiAgICAgICAgIFJFR1JF U1NJT04gKHIxMDQwNjApOiBmYXN0L2Zvcm1zL3RleHRhcmVhLW1ldHJpY3MuaHRtbCBpcyBmYWls aW5nCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IDM1OGFhMGM3ZDViMmJlMDNlYmVhNmY3 OWMxNGU5NDUzYjczMDdiNTEuLmJlZTNjNzY5NzcxM2UzOWEzZWYwZTk0YWIxYjcyOGJlZDIwNjM2 MmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNDIgQEAKKzIwMTItMDEt MDYgIERhdmlkIFJldmVtYW4gIDxyZXZlbWFuQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hy b21pdW1dIEluY3JlbWVudGFsIHRleHR1cmUgdXBkYXRlcyBhcmUgbm90IGF0b21pYy4KKyAgICAg ICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTcyNjcyCisKKyAgICAg ICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIENDTGF5ZXJUcmVl SG9zdFRlc3RBdG9taWNDb21taXQgdGVzdCB0aGF0IHZlcmlmaWVzIGF0b21pY2l0eQorICAgICAg ICBvZiBjb21taXRzLgorCisgICAgICAgICogdGVzdHMvQ0NMYXllclRyZWVIb3N0VGVzdC5jcHA6 CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6OmNyZWF0 ZSk6CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6Om1h a2VDb250ZXh0Q3VycmVudCk6CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhp Y3NDb250ZXh0M0Q6OmNyZWF0ZVByb2dyYW0pOgorICAgICAgICAoV1RGOjpDb21wb3NpdG9yRmFr ZVdlYkdyYXBoaWNzQ29udGV4dDNEOjpjcmVhdGVTaGFkZXIpOgorICAgICAgICAoV1RGOjpDb21w b3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEOjpnZXRTaGFkZXJpdik6CisgICAgICAgIChX VEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6OmdldFByb2dyYW1pdik6Cisg ICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6OmNyZWF0ZVRl eHR1cmUpOgorICAgICAgICAoV1RGOjpDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNE OjpkZWxldGVUZXh0dXJlKToKKyAgICAgICAgKFdURjo6Q29tcG9zaXRvckZha2VXZWJHcmFwaGlj c0NvbnRleHQzRDo6YmluZFRleHR1cmUpOgorICAgICAgICAoV1RGOjpDb21wb3NpdG9yRmFrZVdl YkdyYXBoaWNzQ29udGV4dDNEOjpudW1UZXh0dXJlcyk6CisgICAgICAgIChXVEY6OkNvbXBvc2l0 b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6OnRleHR1cmUpOgorICAgICAgICAoV1RGOjpDb21w b3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEOjpyZXNldFRleHR1cmVzKToKKyAgICAgICAg KFdURjo6Q29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRDo6bnVtVXNlZFRleHR1cmVz KToKKyAgICAgICAgKFdURjo6Q29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRDo6dXNl ZFRleHR1cmUpOgorICAgICAgICAoV1RGOjpDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4 dDNEOjpyZXNldFVzZWRUZXh0dXJlcyk6CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2Vi R3JhcGhpY3NDb250ZXh0M0Q6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QpOgor ICAgICAgICAoV1RGOjpNb2NrTGF5ZXJUcmVlSG9zdENsaWVudDo6Y3JlYXRlTGF5ZXJUcmVlSG9z dENvbnRleHQzRCk6CisgICAgICAgIChXVEY6Ok1vY2tMYXllckRlbGVnYXRlOjpkcmF3c0NvbnRl bnQpOgorICAgICAgICAoV1RGOjpNb2NrTGF5ZXJEZWxlZ2F0ZTo6cGFpbnRDb250ZW50cyk6Cisg ICAgICAgIChXVEY6Ok1vY2tMYXllckRlbGVnYXRlOjpub3RpZnlTeW5jUmVxdWlyZWQpOgorICAg ICAgICAoV1RGOjpDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0OjpDQ0xheWVyVHJlZUhv c3RUZXN0QXRvbWljQ29tbWl0KToKKyAgICAgICAgKFdURjo6Q0NMYXllclRyZWVIb3N0VGVzdEF0 b21pY0NvbW1pdDo6YmVnaW5UZXN0KToKKyAgICAgICAgKFdURjo6Q0NMYXllclRyZWVIb3N0VGVz dEF0b21pY0NvbW1pdDo6Y29tbWl0Q29tcGxldGVPbkNDVGhyZWFkKToKKyAgICAgICAgKFdURjo6 Q0NMYXllclRyZWVIb3N0VGVzdEF0b21pY0NvbW1pdDo6ZHJhd0xheWVyc09uQ0NUaHJlYWQpOgor ICAgICAgICAoV1RGOjpDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0OjpsYXlvdXQpOgor ICAgICAgICAoV1RGOjpDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0OjphZnRlclRlc3Qp OgorICAgICAgICAoV1RGOjpURVNUX0YpOgorCiAyMDEyLTAxLTA1ICBKb2NoZW4gRWlzaW5nZXIg IDxqb2NoZW5AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIENoZWNrIHdoZXRoZXIgYSBXZWJWaWV3 IGV4aXN0cyBiZWZvcmUgYWNjZXNzaW5nIGl0IGluIFN0b3JhZ2VBcmVhUHJveHkuIFRoaXMgaXMg bm90IG5lY2Vzc2FyaWx5IHRoZSBjYXNlLCBlLmcuIGZvciBkZXRhY2hlZCBpZnJhbWVzLgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFuYWdl ZFRleHR1cmUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v TWFuYWdlZFRleHR1cmUuY3BwCmluZGV4IDBjMWU0YjcwZDI3MTRhMzg2Zjk3ZWFhMzQ4ZDdlM2U4 YzY2ZWNlMTEuLjViYjE5ZmE4N2RlYWQyN2NlN2UxYzc5M2E4ZmMzNTgyYzBkM2ZiZDEgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRU ZXh0dXJlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9NYW5hZ2VkVGV4dHVyZS5jcHAKQEAgLTQxLDYgKzQxLDE1IEBAIE1hbmFnZWRUZXh0dXJlOjpN YW5hZ2VkVGV4dHVyZShUZXh0dXJlTWFuYWdlciogbWFuYWdlcikKIHsKIH0KIAorTWFuYWdlZFRl eHR1cmU6Ok1hbmFnZWRUZXh0dXJlKFRleHR1cmVNYW5hZ2VyKiBtYW5hZ2VyLCBUZXh0dXJlVG9r ZW4gdG9rZW4sIEludFNpemUgc2l6ZSwgdW5zaWduZWQgZm9ybWF0LCB1bnNpZ25lZCB0ZXh0dXJl SWQpCisgICAgOiBtX3RleHR1cmVNYW5hZ2VyKG1hbmFnZXIpCisgICAgLCBtX3Rva2VuKHRva2Vu KQorICAgICwgbV9zaXplKHNpemUpCisgICAgLCBtX2Zvcm1hdChmb3JtYXQpCisgICAgLCBtX3Rl eHR1cmVJZCh0ZXh0dXJlSWQpCit7Cit9CisKIE1hbmFnZWRUZXh0dXJlOjp+TWFuYWdlZFRleHR1 cmUoKQogewogICAgIGlmIChtX3Rva2VuKQpAQCAtOTksNiArMTA4LDE3IEBAIHZvaWQgTWFuYWdl ZFRleHR1cmU6OmZyYW1lYnVmZmVyVGV4dHVyZTJEKEdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0 LCBUZXh0dXJlQWxsCiAgICAgY29udGV4dC0+ZnJhbWVidWZmZXJUZXh0dXJlMkQoR3JhcGhpY3ND b250ZXh0M0Q6OkZSQU1FQlVGRkVSLCBHcmFwaGljc0NvbnRleHQzRDo6Q09MT1JfQVRUQUNITUVO VDAsIEdyYXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCBtX3RleHR1cmVJZCwgMCk7CiB9CiAK K1Bhc3NPd25QdHI8TWFuYWdlZFRleHR1cmU+IE1hbmFnZWRUZXh0dXJlOjpzdGVhbCgpCit7Cisg ICAgT3duUHRyPE1hbmFnZWRUZXh0dXJlPiB0ZXh0dXJlID0gYWRvcHRQdHIobmV3IE1hbmFnZWRU ZXh0dXJlKG1fdGV4dHVyZU1hbmFnZXIsIG1fdG9rZW4sIG1fc2l6ZSwgbV9mb3JtYXQsIG1fdGV4 dHVyZUlkKSk7CisgICAgbV90b2tlbiA9IDA7CisgICAgbV9zaXplID0gSW50U2l6ZSgpOworICAg IG1fZm9ybWF0ID0gMDsKKyAgICBtX3RleHR1cmVJZCA9IDA7CisgICAgcmV0dXJuIHRleHR1cmUu cmVsZWFzZSgpOworfQorCisKIH0KIAogI2VuZGlmIC8vIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJ VElORykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL01hbmFnZWRUZXh0dXJlLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5oCmluZGV4IDFjYzhiZmE5YWIzMWNjOTIzMWI0N2E4M2Nj NTY1MmEyMmFhZTgxYTguLjc2ZDYyYThiYjg5YWQ2ZDQxZjYzMGZiNjRiNmU2OGM5YjgzZmI3YWUg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01h bmFnZWRUZXh0dXJlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vTWFuYWdlZFRleHR1cmUuaApAQCAtNjMsOCArNjMsMTMgQEAgcHVibGljOgogICAgIHVu c2lnbmVkIGZvcm1hdCgpIGNvbnN0IHsgcmV0dXJuIG1fZm9ybWF0OyB9CiAgICAgdW5zaWduZWQg dGV4dHVyZUlkKCkgY29uc3QgeyByZXR1cm4gbV90ZXh0dXJlSWQ7IH0KIAorICAgIC8vIFN0ZWFs IHRva2VuIGFuZCB0ZXh0dXJlSWQgYnkgaW5zdGFudGlhdGVzIGEgbmV3IHRleHR1cmUgdXNpbmcg ZXhpc3RpbmcKKyAgICAvLyBtZW1iZXIgdmFyaWFibGVzLgorICAgIFBhc3NPd25QdHI8TWFuYWdl ZFRleHR1cmU+IHN0ZWFsKCk7CisKIHByaXZhdGU6CiAgICAgZXhwbGljaXQgTWFuYWdlZFRleHR1 cmUoVGV4dHVyZU1hbmFnZXIqKTsKKyAgICBNYW5hZ2VkVGV4dHVyZShUZXh0dXJlTWFuYWdlcios IFRleHR1cmVUb2tlbiwgSW50U2l6ZSwgdW5zaWduZWQgZm9ybWF0LCB1bnNpZ25lZCB0ZXh0dXJl SWQpOwogCiAgICAgVGV4dHVyZU1hbmFnZXIqIG1fdGV4dHVyZU1hbmFnZXI7CiAgICAgVGV4dHVy ZVRva2VuIG1fdG9rZW47CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcAppbmRleCBhZDJj YjEzZmM3MzA5MzZhOWM5NGQ0YTg4NDUxMzgzYzNjZDJmMTM4Li5hOTFkYjIxZWY2MGRkZTk3ZWZl NTZhOGQ3MDQ3MGE3MTUzYjNmMmMzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAK QEAgLTM3NCw2ICszNzQsMTEgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnByZXBhcmVUb1Vw ZGF0ZVRpbGVzKGJvb2wgaWRsZSwgaW50IGxlZnQsIGludCB0b3AsIGludAogICAgICAgICAgICAg aWYgKCF0aWxlKQogICAgICAgICAgICAgICAgIHRpbGUgPSBjcmVhdGVUaWxlKGksIGopOwogCisg ICAgICAgICAgICAvLyBEbyBwb3N0IGNvbW1pdCBkZWxldGlvbiBvZiBjdXJyZW50IHRleHR1cmUg d2hlbiBwYXJ0aWFsIHRleHR1cmUKKyAgICAgICAgICAgIC8vIHVwZGF0ZXMgYXJlIG5vdCB1c2Vk LgorICAgICAgICAgICAgaWYgKHRpbGUtPmlzRGlydHkoKSAmJiBsYXllclRyZWVIb3N0KCkgJiYg IWxheWVyVHJlZUhvc3QoKS0+c2V0dGluZ3MoKS5wYXJ0aWFsVGV4dHVyZVVwZGF0ZXMpCisgICAg ICAgICAgICAgICAgbGF5ZXJUcmVlSG9zdCgpLT5kZWxldGVUZXh0dXJlQWZ0ZXJDb21taXQodGls ZS0+bWFuYWdlZFRleHR1cmUoKS0+c3RlYWwoKSk7CisKICAgICAgICAgICAgIGlmICghdGlsZS0+ bWFuYWdlZFRleHR1cmUoKS0+aXNWYWxpZChtX3RpbGVyLT50aWxlU2l6ZSgpLCBtX3RleHR1cmVG b3JtYXQpKQogICAgICAgICAgICAgICAgIHRpbGUtPm1fZGlydHlSZWN0ID0gbV90aWxlci0+dGls ZVJlY3QodGlsZSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwCmluZGV4IDM3OWQx NjA4Mzc1OTg0ZTU5NGIyNThiMDI4MDdiZGQ1MGM2NTU0YTkuLmFkOTU4ZmRjZGVkZDI4OGE4OGZi OWY1YzUwYjNjMDQ1ZTFiN2M5Y2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcApA QCAtOTQsNiArOTQsOSBAQCBib29sIENDTGF5ZXJUcmVlSG9zdDo6aW5pdGlhbGl6ZSgpCiAgICAg Ly8gVXBkYXRlIG1fc2V0dGluZ3MgYmFzZWQgb24gY2FwYWJpbGl0aWVzIHRoYXQgd2UgZ290IGJh Y2sgZnJvbSB0aGUgcmVuZGVyZXIuCiAgICAgbV9zZXR0aW5ncy5hY2NlbGVyYXRlUGFpbnRpbmcg PSBtX3Byb3h5LT5sYXllclJlbmRlcmVyQ2FwYWJpbGl0aWVzKCkudXNpbmdBY2NlbGVyYXRlZFBh aW50aW5nOwogCisgICAgLy8gVXBkYXRlIG1fc2V0dGluZ3MgYmFzZWQgb24gcGFydGlhbCB1cGRh dGUgY2FwYWJpbGl0eS4KKyAgICBtX3NldHRpbmdzLnBhcnRpYWxUZXh0dXJlVXBkYXRlcyA9IG1f cHJveHktPnBhcnRpYWxUZXh0dXJlVXBkYXRlQ2FwYWJpbGl0eSgpOworCiAgICAgbV9jb250ZW50 c1RleHR1cmVNYW5hZ2VyID0gVGV4dHVyZU1hbmFnZXI6OmNyZWF0ZShUZXh0dXJlTWFuYWdlcjo6 aGlnaExpbWl0Qnl0ZXModmlld3BvcnRTaXplKCkpLAogICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgVGV4dHVyZU1hbmFnZXI6OnJlY2xhaW1MaW1p dEJ5dGVzKHZpZXdwb3J0U2l6ZSgpKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgIG1fcHJveHktPmxheWVyUmVuZGVyZXJDYXBhYmlsaXRpZXMo KS5tYXhUZXh0dXJlU2l6ZSk7CkBAIC0xNjQsNiArMTY3LDcgQEAgdm9pZCBDQ0xheWVyVHJlZUhv c3Q6OmZpbmlzaENvbW1pdE9uSW1wbFRocmVhZChDQ0xheWVyVHJlZUhvc3RJbXBsKiBob3N0SW1w bCkKIAogdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OmNvbW1pdENvbXBsZXRlKCkKIHsKKyAgICBtX2Rl bGV0ZVRleHR1cmVBZnRlckNvbW1pdExpc3QuY2xlYXIoKTsKICAgICBjbGVhclBlbmRpbmdVcGRh dGUoKTsKICAgICBtX2NvbnRlbnRzVGV4dHVyZU1hbmFnZXItPnVucHJvdGVjdEFsbFRleHR1cmVz KCk7CiB9CkBAIC01MjcsNCArNTMxLDkgQEAgdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnN0b3BSYXRl TGltaXRlcihHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCkKICAgICB9CiB9CiAKK3ZvaWQgQ0NM YXllclRyZWVIb3N0OjpkZWxldGVUZXh0dXJlQWZ0ZXJDb21taXQoUGFzc093blB0cjxNYW5hZ2Vk VGV4dHVyZT4gdGV4dHVyZSkKK3sKKyAgICBtX2RlbGV0ZVRleHR1cmVBZnRlckNvbW1pdExpc3Qu YXBwZW5kKHRleHR1cmUpOworfQorCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuaCBiL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oCmluZGV4 IDRmMjkzZWNhNWEyMTIzZDc2NWE2NDBlNGU3NDI4NGZkNTY3NjMwYWUuLjE1OGIxM2RmM2QxYjRh NzBlMzE5YTkwOTlkYTU0Y2Y3NGQzYzA0YjAgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5o CkBAIC03Niw3ICs3Niw4IEBAIHN0cnVjdCBDQ1NldHRpbmdzIHsKICAgICAgICAgICAgICwgc2hv d1BsYXRmb3JtTGF5ZXJUcmVlKGZhbHNlKQogICAgICAgICAgICAgLCByZWZyZXNoUmF0ZSgwKQog ICAgICAgICAgICAgLCBwZXJUaWxlUGFpbnRpbmcoZmFsc2UpCi0gICAgICAgICAgICAsIHBhcnRp YWxTd2FwRW5hYmxlZChmYWxzZSkgeyB9CisgICAgICAgICAgICAsIHBhcnRpYWxTd2FwRW5hYmxl ZChmYWxzZSkKKyAgICAgICAgICAgICwgcGFydGlhbFRleHR1cmVVcGRhdGVzKGZhbHNlKSB7IH0K IAogICAgIGJvb2wgYWNjZWxlcmF0ZVBhaW50aW5nOwogICAgIGJvb2wgY29tcG9zaXRlT2Zmc2Ny ZWVuOwpAQCAtODUsNiArODYsNyBAQCBzdHJ1Y3QgQ0NTZXR0aW5ncyB7CiAgICAgZG91YmxlIHJl ZnJlc2hSYXRlOwogICAgIGJvb2wgcGVyVGlsZVBhaW50aW5nOwogICAgIGJvb2wgcGFydGlhbFN3 YXBFbmFibGVkOworICAgIGJvb2wgcGFydGlhbFRleHR1cmVVcGRhdGVzOwogfTsKIAogLy8gUHJv dmlkZXMgaW5mb3JtYXRpb24gb24gYW4gSW1wbCdzIHJlbmRlcmluZyBjYXBhYmlsaXRpZXMgYmFj ayB0byB0aGUgQ0NMYXllclRyZWVIb3N0CkBAIC0xOTIsMTIgKzE5NCwxNSBAQCBwdWJsaWM6CiAg ICAgdm9pZCBzdGFydFJhdGVMaW1pdGVyKEdyYXBoaWNzQ29udGV4dDNEKik7CiAgICAgdm9pZCBz dG9wUmF0ZUxpbWl0ZXIoR3JhcGhpY3NDb250ZXh0M0QqKTsKIAorICAgIHZvaWQgZGVsZXRlVGV4 dHVyZUFmdGVyQ29tbWl0KFBhc3NPd25QdHI8TWFuYWdlZFRleHR1cmU+KTsKKwogcHJvdGVjdGVk OgogICAgIENDTGF5ZXJUcmVlSG9zdChDQ0xheWVyVHJlZUhvc3RDbGllbnQqLCBjb25zdCBDQ1Nl dHRpbmdzJik7CiAgICAgYm9vbCBpbml0aWFsaXplKCk7CiAKIHByaXZhdGU6CiAgICAgdHlwZWRl ZiBWZWN0b3I8UmVmUHRyPExheWVyQ2hyb21pdW0+ID4gTGF5ZXJMaXN0OworICAgIHR5cGVkZWYg VmVjdG9yPE93blB0cjxNYW5hZ2VkVGV4dHVyZT4gPiBUZXh0dXJlTGlzdDsKIAogICAgIGVudW0g UGFpbnRUeXBlIHsgUGFpbnRWaXNpYmxlLCBQYWludElkbGUgfTsKICAgICBzdGF0aWMgdm9pZCBw YWludENvbnRlbnRzSWZEaXJ0eShMYXllckNocm9taXVtKiwgUGFpbnRUeXBlKTsKQEAgLTIzMyw2 ICsyMzgsOCBAQCBwcml2YXRlOgogICAgIGZsb2F0IG1fcGFnZVNjYWxlOwogICAgIGZsb2F0IG1f bWluUGFnZVNjYWxlLCBtX21heFBhZ2VTY2FsZTsKICAgICBib29sIG1fdHJpZ2dlcklkbGVQYWlu dHM7CisKKyAgICBUZXh0dXJlTGlzdCBtX2RlbGV0ZVRleHR1cmVBZnRlckNvbW1pdExpc3Q7CiB9 OwogCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9jYy9DQ1Byb3h5LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9jYy9DQ1Byb3h5LmgKaW5kZXggYmIzNzgwMTQ3YjE2YzI2Yjc1YTdjY2QyMmFhOGI4ZmU4 NGU3NmJiZC4uOTM3YzE1NGZmNjliYTg1M2JiZmM5MzQ1NmQ3NzY2NzEwYzcwYTIyNCAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NQcm94 eS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND UHJveHkuaApAQCAtNzksNiArNzksMTAgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBzdGFy dCgpID0gMDsgLy8gTXVzdCBiZSBjYWxsZWQgYmVmb3JlIHVzaW5nIHRoZSBwcm94eS4KICAgICB2 aXJ0dWFsIHZvaWQgc3RvcCgpID0gMDsgLy8gTXVzdCBiZSBjYWxsZWQgYmVmb3JlIGRlbGV0aW5n IHRoZSBwcm94eS4KIAorICAgIC8vIFdoZXRoZXIgc3ViLXJlZ2lvbnMgb2YgdGV4dHVyZXMgY2Fu IGJlIHVwZGF0ZWQgb3IgaWYgY29tcGxldGUgdGV4dHVyZQorICAgIC8vIHVwZGF0ZXMgYXJlIHJl cXVpcmVkLgorICAgIHZpcnR1YWwgYm9vbCBwYXJ0aWFsVGV4dHVyZVVwZGF0ZUNhcGFiaWxpdHko KSBjb25zdCA9IDA7CisKICAgICAvLyBEZWJ1ZyBob29rcwogI2lmbmRlZiBOREVCVUcKICAgICBz dGF0aWMgYm9vbCBpc01haW5UaHJlYWQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDU2luZ2xlVGhyZWFkUHJveHkuaCBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDU2luZ2xlVGhyZWFkUHJv eHkuaAppbmRleCAwZDVhNGEyZDhhNTE2YjFkN2JjZjk5MWE5OWUxYzc4Nzg5OTQzZWM1Li40ZmFh MjI5OTkxMmFlYzljNGU2YWI0YmE3MDI3ZDgxYzgwNmQ0NWVlIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1NpbmdsZVRocmVhZFByb3h5 LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NT aW5nbGVUaHJlYWRQcm94eS5oCkBAIC01NCw2ICs1NCw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFs IHZvaWQgc2V0VmlzaWJsZShib29sKTsKICAgICB2aXJ0dWFsIHZvaWQgc3RhcnQoKTsKICAgICB2 aXJ0dWFsIHZvaWQgc3RvcCgpOworICAgIHZpcnR1YWwgYm9vbCBwYXJ0aWFsVGV4dHVyZVVwZGF0 ZUNhcGFiaWxpdHkoKSBjb25zdCB7IHJldHVybiB0cnVlOyB9CiAKICAgICAvLyBDQ0xheWVyVHJl ZUhvc3RJbXBsQ2xpZW50IGltcGxlbWVudGF0aW9uCiAgICAgdmlydHVhbCB2b2lkIG9uU3dhcEJ1 ZmZlcnNDb21wbGV0ZU9uSW1wbFRocmVhZCgpIHsgQVNTRVJUX05PVF9SRUFDSEVEKCk7IH0KZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND VGhyZWFkUHJveHkuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vY2MvQ0NUaHJlYWRQcm94eS5jcHAKaW5kZXggOTAzMzEzNTEzYTlkMDk4MjM0MTJlNWU3N2Q2 OTk4NTQ1N2Y5M2E2MS4uZjg4NGQwYzFlODg2MDRiYjNiODQ3MTdjYTAyZDlmODI4Y2NiN2Y3MCAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NUaHJlYWRQcm94eS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5jcHAKQEAgLTM5LDggKzM5LDE1IEBACiAjaW5jbHVk ZSA8d3RmL0N1cnJlbnRUaW1lLmg+CiAjaW5jbHVkZSA8d3RmL01haW5UaHJlYWQuaD4KIAordXNp bmcgbmFtZXNwYWNlIHN0ZDsKIHVzaW5nIG5hbWVzcGFjZSBXVEY7CiAKK25hbWVzcGFjZSB7CisK K3N0YXRpYyBjb25zdCBzaXplX3QgdGV4dHVyZVVwZGF0ZXNQZXJGcmFtZSA9IDU7CisKK30gLy8g YW5vbnltb3VzIG5hbWVzcGFjZQorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIFBhc3NPd25QdHI8 Q0NQcm94eT4gQ0NUaHJlYWRQcm94eTo6Y3JlYXRlKENDTGF5ZXJUcmVlSG9zdCogbGF5ZXJUcmVl SG9zdCkKQEAgLTQzOCw4ICs0NDUsNyBAQCB2b2lkIENDVGhyZWFkUHJveHk6OnNjaGVkdWxlZEFj dGlvblVwZGF0ZU1vcmVSZXNvdXJjZXMoKQogewogICAgIFRSQUNFX0VWRU5UKCJDQ1RocmVhZFBy b3h5OjpzY2hlZHVsZWRBY3Rpb25VcGRhdGVNb3JlUmVzb3VyY2VzIiwgdGhpcywgMCk7CiAgICAg QVNTRVJUKG1fY3VycmVudFRleHR1cmVVcGRhdGVyT25JbXBsVGhyZWFkKTsKLSAgICBzdGF0aWMg Y29uc3QgaW50IFVwZGF0ZXNQZXJGcmFtZSA9IDk5OTk5OwotICAgIG1fY3VycmVudFRleHR1cmVV cGRhdGVyT25JbXBsVGhyZWFkLT51cGRhdGUobV9sYXllclRyZWVIb3N0SW1wbC0+Y29udGV4dCgp LCBVcGRhdGVzUGVyRnJhbWUpOworICAgIG1fY3VycmVudFRleHR1cmVVcGRhdGVyT25JbXBsVGhy ZWFkLT51cGRhdGUobV9sYXllclRyZWVIb3N0SW1wbC0+Y29udGV4dCgpLCB0ZXh0dXJlVXBkYXRl c1BlckZyYW1lKTsKIH0KIAogdm9pZCBDQ1RocmVhZFByb3h5OjpzY2hlZHVsZWRBY3Rpb25Db21t aXQoKQpAQCAtNTY1LDQgKzU3MSw5IEBAIHZvaWQgQ0NUaHJlYWRQcm94eTo6bGF5ZXJUcmVlSG9z dENsb3NlZE9uSW1wbFRocmVhZChDQ0NvbXBsZXRpb25FdmVudCogY29tcGxldGlvCiAgICAgY29t cGxldGlvbi0+c2lnbmFsKCk7CiB9CiAKK2Jvb2wgQ0NUaHJlYWRQcm94eTo6cGFydGlhbFRleHR1 cmVVcGRhdGVDYXBhYmlsaXR5KCkgY29uc3QKK3sKKyAgICByZXR1cm4gdGV4dHVyZVVwZGF0ZXNQ ZXJGcmFtZSA9PSBudW1lcmljX2xpbWl0czxzaXplX3Q+OjptYXgoKTsKK30KKwogfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5oCmluZGV4IGE0MWMwZDU2NGI2Mzgx M2JhNjNhNmNlZDU4ZTA0ZDY5YzM4ZjJkZWEuLmExMWI1Mjc4NTk5MzFjZmI5OGY4NzI0YTUxMjQz YTA5YjRlY2MzYjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmgKQEAgLTYyLDYgKzYyLDcgQEAg cHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBzZXRWaXNpYmxlKGJvb2wpOwogICAgIHZpcnR1YWwg dm9pZCBzdGFydCgpOwogICAgIHZpcnR1YWwgdm9pZCBzdG9wKCk7CisgICAgdmlydHVhbCBib29s IHBhcnRpYWxUZXh0dXJlVXBkYXRlQ2FwYWJpbGl0eSgpIGNvbnN0OwogCiAgICAgLy8gQ0NMYXll clRyZWVIb3N0SW1wbENsaWVudCBpbXBsZW1lbnRhdGlvbgogICAgIHZpcnR1YWwgdm9pZCBvblN3 YXBCdWZmZXJzQ29tcGxldGVPbkltcGxUaHJlYWQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vdGVzdHMvQ0NMYXllclRyZWVIb3N0VGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3Rlc3RzL0NDTGF5ZXJUcmVlSG9zdFRlc3QuY3BwCmluZGV4IGU2Y2U4YjA2NjNl Y2E5ZWZlN2UzNGFmZDIyYzhlMWZlY2U5MTBkZjYuLjkzMWJkM2YwZGViNjM3ODdiYmQ4MGMxNDQ3 OTljMDA1Mzk3NTUzMDMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMv Q0NMYXllclRyZWVIb3N0VGVzdC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0 cy9DQ0xheWVyVHJlZUhvc3RUZXN0LmNwcApAQCAtMjYsOSArMjYsOSBAQAogCiAjaW5jbHVkZSAi Y2MvQ0NMYXllclRyZWVIb3N0LmgiCiAKLSNpbmNsdWRlICJDb21wb3NpdG9yRmFrZUdyYXBoaWNz Q29udGV4dDNELmgiCiAjaW5jbHVkZSAiQ29udGVudExheWVyQ2hyb21pdW0uaCIKICNpbmNsdWRl ICJGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QuaCIKKyNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQz RFByaXZhdGUuaCIKICNpbmNsdWRlICJMYXllckNocm9taXVtLmgiCiAjaW5jbHVkZSAiVGV4dHVy ZU1hbmFnZXIuaCIKICNpbmNsdWRlICJXZWJDb21wb3NpdG9yLmgiCkBAIC00MCwxMiArNDAsMTQg QEAKICNpbmNsdWRlICJjYy9DQ1RocmVhZFRhc2suaCIKICNpbmNsdWRlICJwbGF0Zm9ybS9XZWJL aXRQbGF0Zm9ybVN1cHBvcnQuaCIKICNpbmNsdWRlICJwbGF0Zm9ybS9XZWJUaHJlYWQuaCIKKyNp bmNsdWRlIDxnbW9jay9nbW9jay5oPgogI2luY2x1ZGUgPGd0ZXN0L2d0ZXN0Lmg+CiAjaW5jbHVk ZSA8d2Via2l0L3N1cHBvcnQvd2Via2l0X3N1cHBvcnQuaD4KICNpbmNsdWRlIDx3dGYvTWFpblRo cmVhZC5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1ZlY3Rv ci5oPgogCit1c2luZyBuYW1lc3BhY2Ugc3RkOwogdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiB1 c2luZyBuYW1lc3BhY2UgV2ViS2l0OwogdXNpbmcgbmFtZXNwYWNlIFdURjsKQEAgLTEzMCw2ICsx MzIsNjAgQEAgcHJpdmF0ZToKICAgICBUZXN0SG9va3MqIG1fdGVzdEhvb2tzOwogfTsKIAorLy8g VGVzdCBzdHViIGZvciBXZWJHcmFwaGljc0NvbnRleHQzRC4gUmV0dXJucyBjYW5uZWQgdmFsdWVz IG5lZWRlZCBmb3IgY29tcG9zaXRvciBpbml0aWFsaXphdGlvbi4KK2NsYXNzIENvbXBvc2l0b3JG YWtlV2ViR3JhcGhpY3NDb250ZXh0M0QgOiBwdWJsaWMgRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNE IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxDb21wb3NpdG9yRmFrZVdlYkdyYXBo aWNzQ29udGV4dDNEPiBjcmVhdGUoQXR0cmlidXRlcyBhdHRycykKKyAgICB7CisgICAgICAgIHJl dHVybiBhZG9wdFB0cihuZXcgQ29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRChhdHRy cykpOworICAgIH0KKworICAgIHZpcnR1YWwgYm9vbCBtYWtlQ29udGV4dEN1cnJlbnQoKSB7IHJl dHVybiB0cnVlOyB9CisgICAgdmlydHVhbCBXZWJHTElkIGNyZWF0ZVByb2dyYW0oKSB7IHJldHVy biAxOyB9CisgICAgdmlydHVhbCBXZWJHTElkIGNyZWF0ZVNoYWRlcihXR0MzRGVudW0pIHsgcmV0 dXJuIDE7IH0KKyAgICB2aXJ0dWFsIHZvaWQgZ2V0U2hhZGVyaXYoV2ViR0xJZCwgV0dDM0RlbnVt LCBXR0MzRGludCogdmFsdWUpIHsgKnZhbHVlID0gMTsgfQorICAgIHZpcnR1YWwgdm9pZCBnZXRQ cm9ncmFtaXYoV2ViR0xJZCwgV0dDM0RlbnVtLCBXR0MzRGludCogdmFsdWUpIHsgKnZhbHVlID0g MTsgfQorCisgICAgdmlydHVhbCBXZWJHTElkIGNyZWF0ZVRleHR1cmUoKQorICAgIHsKKyAgICAg ICAgV2ViR0xJZCB0ZXh0dXJlID0gbV90ZXh0dXJlcy5zaXplKCkgKyAxOworICAgICAgICBtX3Rl eHR1cmVzLnB1c2hfYmFjayh0ZXh0dXJlKTsKKyAgICAgICAgcmV0dXJuIHRleHR1cmU7CisgICAg fQorCisgICAgdmlydHVhbCB2b2lkIGRlbGV0ZVRleHR1cmUoV2ViR0xJZCB0ZXh0dXJlKQorICAg IHsKKyAgICAgICAgZm9yICh2ZWN0b3I8V2ViR0xJZD46Oml0ZXJhdG9yIGl0ID0gbV90ZXh0dXJl cy5iZWdpbigpOyBpdCAhPSBtX3RleHR1cmVzLmVuZCgpOyBpdCsrKSB7CisgICAgICAgICAgICBp ZiAoKml0ID09IHRleHR1cmUpIHsKKyAgICAgICAgICAgICAgICBtX3RleHR1cmVzLmVyYXNlKGl0 KTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAg IH0KKworICAgIHZpcnR1YWwgdm9pZCBiaW5kVGV4dHVyZShXR0MzRGVudW0gLyogdGFyZ2V0ICov LCBXZWJHTElkIHRleHR1cmUpCisgICAgeworICAgICAgICBtX3VzZWRUZXh0dXJlcy5pbnNlcnQo dGV4dHVyZSk7CisgICAgfQorCisgICAgaW50IG51bVRleHR1cmVzKCkgY29uc3QgeyByZXR1cm4g c3RhdGljX2Nhc3Q8aW50PihtX3RleHR1cmVzLnNpemUoKSk7IH0KKyAgICBpbnQgdGV4dHVyZShp bnQgaSkgY29uc3QgeyByZXR1cm4gbV90ZXh0dXJlc1tpXTsgfQorICAgIHZvaWQgcmVzZXRUZXh0 dXJlcygpIHsgbV90ZXh0dXJlcy5jbGVhcigpOyB9CisKKyAgICBpbnQgbnVtVXNlZFRleHR1cmVz KCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8aW50PihtX3VzZWRUZXh0dXJlcy5zaXplKCkp OyB9CisgICAgYm9vbCB1c2VkVGV4dHVyZShpbnQgdGV4dHVyZSkgY29uc3QgeyByZXR1cm4gbV91 c2VkVGV4dHVyZXMuZmluZCh0ZXh0dXJlKSAhPSBtX3VzZWRUZXh0dXJlcy5lbmQoKTsgfQorICAg IHZvaWQgcmVzZXRVc2VkVGV4dHVyZXMoKSB7IG1fdXNlZFRleHR1cmVzLmNsZWFyKCk7IH0KKwor cHJpdmF0ZToKKyAgICBleHBsaWNpdCBDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNE KEF0dHJpYnV0ZXMgYXR0cnMpCisgICAgeworICAgICAgICBtX2F0dHJzID0gYXR0cnM7CisgICAg fQorCisgICAgdmVjdG9yPFdlYkdMSWQ+IG1fdGV4dHVyZXM7CisgICAgc2V0PFdlYkdMSWQ+IG1f dXNlZFRleHR1cmVzOworfTsKKwogLy8gSW1wbGVtZW50YXRpb24gb2YgQ0NMYXllclRyZWVIb3N0 IGNhbGxiYWNrIGludGVyZmFjZS4KIGNsYXNzIE1vY2tMYXllclRyZWVIb3N0Q2xpZW50IDogcHVi bGljIENDTGF5ZXJUcmVlSG9zdENsaWVudCB7CiBwdWJsaWM6CkBAIC0xNTUsNyArMjExLDE1IEBA IHB1YmxpYzoKIAogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxHcmFwaGljc0NvbnRleHQzRD4gY3Jl YXRlTGF5ZXJUcmVlSG9zdENvbnRleHQzRCgpCiAgICAgewotICAgICAgICByZXR1cm4gY3JlYXRl Q29tcG9zaXRvck1vY2tHcmFwaGljc0NvbnRleHQzRChHcmFwaGljc0NvbnRleHQzRDo6QXR0cmli dXRlcygpKTsKKyAgICAgICAgR3JhcGhpY3NDb250ZXh0M0Q6OkF0dHJpYnV0ZXMgYXR0cnM7Cisg ICAgICAgIFdlYkdyYXBoaWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzIHdlYkF0dHJzOworICAgICAg ICB3ZWJBdHRycy5hbHBoYSA9IGF0dHJzLmFscGhhOworCisgICAgICAgIE93blB0cjxXZWJHcmFw aGljc0NvbnRleHQzRD4gd2ViQ29udGV4dCA9IENvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250 ZXh0M0Q6OmNyZWF0ZSh3ZWJBdHRycyk7CisgICAgICAgIHJldHVybiBHcmFwaGljc0NvbnRleHQz RFByaXZhdGU6OmNyZWF0ZUdyYXBoaWNzQ29udGV4dEZyb21XZWJDb250ZXh0KAorICAgICAgICAg ICAgd2ViQ29udGV4dC5yZWxlYXNlKCksIGF0dHJzLCAwLAorICAgICAgICAgICAgR3JhcGhpY3ND b250ZXh0M0Q6OlJlbmRlckRpcmVjdGx5VG9Ib3N0V2luZG93LAorICAgICAgICAgICAgR3JhcGhp Y3NDb250ZXh0M0RQcml2YXRlOjpGb3JVc2VPbkFub3RoZXJUaHJlYWQpOwogICAgIH0KIAogICAg IHZpcnR1YWwgdm9pZCBkaWRDb21taXRBbmREcmF3RnJhbWUoKQpAQCAtMTAyNSw0ICsxMDg5LDk5 IEBAIFRFU1RfRihDQ0xheWVyVHJlZUhvc3RUZXN0T3BhY2l0eUNoYW5nZSwgcnVuTXVsdGlUaHJl YWQpCiAgICAgcnVuVGVzdCh0cnVlKTsKIH0KIAorY2xhc3MgTW9ja0xheWVyRGVsZWdhdGUgOiBw dWJsaWMgQ0NMYXllckRlbGVnYXRlIHsKK3B1YmxpYzoKKyAgICBib29sIGRyYXdzQ29udGVudCgp IGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KKyAgICBNT0NLX0NPTlNUX01FVEhPRDAocHJlc2VydmVz M0QsIGJvb2woKSk7CisgICAgdm9pZCBwYWludENvbnRlbnRzKEdyYXBoaWNzQ29udGV4dCYsIGNv bnN0IEludFJlY3QmKSB7IH0KKyAgICB2b2lkIG5vdGlmeVN5bmNSZXF1aXJlZCgpIHsgfQorfTsK KworLy8gVmVyaWZ5IGF0b21pY2l0eSBvZiBjb21taXRzIGFuZCByZXVzZSBvZiB0ZXh0dXJlcy4K K2NsYXNzIENDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQgOiBwdWJsaWMgQ0NMYXllclRy ZWVIb3N0VGVzdCB7CitwdWJsaWM6CisgICAgQ0NMYXllclRyZWVIb3N0VGVzdEF0b21pY0NvbW1p dCgpCisgICAgICAgIDogbV91cGRhdGVDaGVja0xheWVyKENvbnRlbnRMYXllckNocm9taXVtV2l0 aFVwZGF0ZVRyYWNraW5nOjpjcmVhdGUoJm1fZGVsZWdhdGUpKQorICAgICAgICAsIG1fbnVtQ29t bWl0cygwKQorICAgIHsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgYmVnaW5UZXN0KCkKKyAg ICB7CisgICAgICAgIG1fbGF5ZXJUcmVlSG9zdC0+c2V0Um9vdExheWVyKG1fdXBkYXRlQ2hlY2tM YXllcik7CisgICAgICAgIG1fbGF5ZXJUcmVlSG9zdC0+c2V0Vmlld3BvcnQoSW50U2l6ZSgxMCwg MTApKTsKKworICAgICAgICBwb3N0U2V0TmVlZHNDb21taXRUb01haW5UaHJlYWQoKTsKKyAgICAg ICAgcG9zdFNldE5lZWRzUmVkcmF3VG9NYWluVGhyZWFkKCk7CisgICAgfQorCisgICAgdmlydHVh bCB2b2lkIGNvbW1pdENvbXBsZXRlT25DQ1RocmVhZChDQ0xheWVyVHJlZUhvc3RJbXBsKiBpbXBs KQorICAgIHsKKyAgICAgICAgQ29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRCogY29u dGV4dCA9IHN0YXRpY19jYXN0PENvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QqPihH cmFwaGljc0NvbnRleHQzRFByaXZhdGU6OmV4dHJhY3RXZWJHcmFwaGljc0NvbnRleHQzRChpbXBs LT5jb250ZXh0KCkpKTsKKworICAgICAgICBzd2l0Y2ggKGltcGwtPmZyYW1lTnVtYmVyKCkpIHsK KyAgICAgICAgY2FzZSAwOgorICAgICAgICAgICAgLy8gTnVtYmVyIG9mIHRleHR1cmVzIHNob3Vs ZCBiZSBvbmUuCisgICAgICAgICAgICBFWFBFQ1RfRVEoMSwgY29udGV4dC0+bnVtVGV4dHVyZXMo KSk7CisgICAgICAgICAgICAvLyBOdW1iZXIgb2YgdGV4dHVyZXMgdXNlZCBmb3IgY29tbWl0IHNo b3VsZCBiZSBvbmUuCisgICAgICAgICAgICBFWFBFQ1RfRVEoMSwgY29udGV4dC0+bnVtVXNlZFRl eHR1cmVzKCkpOworICAgICAgICAgICAgLy8gVmVyaWZ5IHVzZWQgdGV4dHVyZSBpcyBjb3JyZWN0 LgorICAgICAgICAgICAgRVhQRUNUX1RSVUUoY29udGV4dC0+dXNlZFRleHR1cmUoY29udGV4dC0+ dGV4dHVyZSgwKSkpOworCisgICAgICAgICAgICBjb250ZXh0LT5yZXNldFVzZWRUZXh0dXJlcygp OworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgMToKKyAgICAgICAgICAgIC8vIE51 bWJlciBvZiB0ZXh0dXJlcyBzaG91bGQgYmUgdHdvIGFzIHRoZSBmaXJzdCB0ZXh0dXJlCisgICAg ICAgICAgICAvLyBpcyB1c2VkIGJ5IGltcGwgdGhyZWFkIGFuZCBjYW5ub3QgYnkgdXNlZCBmb3Ig dXBkYXRlLgorICAgICAgICAgICAgRVhQRUNUX0VRKDIsIGNvbnRleHQtPm51bVRleHR1cmVzKCkp OworICAgICAgICAgICAgLy8gTnVtYmVyIG9mIHRleHR1cmVzIHVzZWQgZm9yIGNvbW1pdCBzaG91 bGQgc3RpbGwgYmUgb25lLgorICAgICAgICAgICAgRVhQRUNUX0VRKDEsIGNvbnRleHQtPm51bVVz ZWRUZXh0dXJlcygpKTsKKyAgICAgICAgICAgIC8vIEZpcnN0IHRleHR1cmUgc2hvdWxkIG5vdCBo YXZlIGJlZW4gdXNlZC4KKyAgICAgICAgICAgIEVYUEVDVF9GQUxTRShjb250ZXh0LT51c2VkVGV4 dHVyZShjb250ZXh0LT50ZXh0dXJlKDApKSk7CisgICAgICAgICAgICAvLyBOZXcgdGV4dHVyZSBz aG91bGQgaGF2ZSBiZWVuIHVzZWQuCisgICAgICAgICAgICBFWFBFQ1RfVFJVRShjb250ZXh0LT51 c2VkVGV4dHVyZShjb250ZXh0LT50ZXh0dXJlKDEpKSk7CisKKyAgICAgICAgICAgIGNvbnRleHQt PnJlc2V0VXNlZFRleHR1cmVzKCk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgZGVmYXVs dDoKKyAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgICAgICAgICAgYnJlYWs7 CisgICAgICAgIH0KKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZHJhd0xheWVyc09uQ0NUaHJl YWQoQ0NMYXllclRyZWVIb3N0SW1wbCogaW1wbCkKKyAgICB7CisgICAgICAgIENvbXBvc2l0b3JG YWtlV2ViR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQgPSBzdGF0aWNfY2FzdDxDb21wb3NpdG9y RmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEKj4oR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlOjpleHRy YWN0V2ViR3JhcGhpY3NDb250ZXh0M0QoaW1wbC0+Y29udGV4dCgpKSk7CisKKyAgICAgICAgLy8g TnVtYmVyIG9mIHRleHR1cmVzIHVzZWQgZm9yIGRyYXcgc2hvdWxkIGFsd2F5cyBiZSBvbmUuCisg ICAgICAgIEVYUEVDVF9FUSgxLCBjb250ZXh0LT5udW1Vc2VkVGV4dHVyZXMoKSk7CisKKyAgICAg ICAgaWYgKGltcGwtPmZyYW1lTnVtYmVyKCkgPCAyKSB7CisgICAgICAgICAgICBjb250ZXh0LT5y ZXNldFVzZWRUZXh0dXJlcygpOworICAgICAgICAgICAgcG9zdFNldE5lZWRzQW5pbWF0ZUFuZENv bW1pdFRvTWFpblRocmVhZCgpOworICAgICAgICAgICAgcG9zdFNldE5lZWRzUmVkcmF3VG9NYWlu VGhyZWFkKCk7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgZW5kVGVzdCgpOworICAgIH0K KworICAgIHZpcnR1YWwgdm9pZCBsYXlvdXQoKQorICAgIHsKKyAgICAgICAgbV91cGRhdGVDaGVj a0xheWVyLT5zZXROZWVkc0Rpc3BsYXkoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgYWZ0 ZXJUZXN0KCkKKyAgICB7CisgICAgfQorCitwcml2YXRlOgorICAgIE1vY2tMYXllckRlbGVnYXRl IG1fZGVsZWdhdGU7CisgICAgUmVmUHRyPENvbnRlbnRMYXllckNocm9taXVtV2l0aFVwZGF0ZVRy YWNraW5nPiBtX3VwZGF0ZUNoZWNrTGF5ZXI7CisgICAgaW50IG1fbnVtQ29tbWl0czsKK307CisK K1RFU1RfRihDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0LCBydW5NdWx0aVRocmVhZCkK K3sKKyAgICBydW5UZXN0KHRydWUpOworfQorCiB9IC8vIG5hbWVzcGFjZQo= 121676 2012-01-09 09:59:09 -0800 2012-01-20 14:19:10 -0800 Patch bug-72672-20120109095908.patch text/plain 21989 reveman U3VidmVyc2lvbiBSZXZpc2lvbjogMTA0NDYyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTk3NTQ4NGYwY2M1ZTk1 MjZmNTEwYmFkOWEyMDhhZjg2M2ZmZjliZC4uYjQyMzM1MzgwNzMxZmM0MTVlZmNkYjUzZDdlY2Q4 MjExYzQ3MTQ0YyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDEyLTAxLTA5ICBEYXZp ZCBSZXZlbWFuICA8cmV2ZW1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW2Nocm9taXVtXSBJ bmNyZW1lbnRhbCB0ZXh0dXJlIHVwZGF0ZXMgYXJlIG5vdCBhdG9taWMuCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MjY3MgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFVzZSBhIG5ldyBzZXQgb2YgdGV4dHVy ZXMgZm9yIGVhY2ggY29tbWl0IHdoZW4gaW5jcmVtZW50YWwKKyAgICAgICAgdGV4dHVyZSB1cGRh dGVzIGFyZSBlbmFibGVkLgorCisgICAgICAgIFRoaXMgcGF0Y2ggaXMgdGVzdGVkIGJ5IHRoZSBm b2xsb3dpbmcgdW5pdCB0ZXN0OgorICAgICAgICAtIENDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWND b21taXQucnVuTXVsdGlUaHJlYWQKKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL01hbmFnZWRUZXh0dXJlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1hbmFnZWRUZXh0dXJl OjpNYW5hZ2VkVGV4dHVyZSk6CisgICAgICAgIChXZWJDb3JlOjpNYW5hZ2VkVGV4dHVyZTo6c3Rl YWwpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRUZXh0dXJl Lmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9t aXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRv VXBkYXRlVGlsZXMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND TGF5ZXJUcmVlSG9zdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6Omlu aXRpYWxpemUpOgorICAgICAgICAoV2ViQ29yZTo6Q0NMYXllclRyZWVIb3N0Ojpjb21taXRDb21w bGV0ZSk6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6OmRlbGV0ZVRleHR1cmVB ZnRlckNvbW1pdCk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NM YXllclRyZWVIb3N0Lmg6CisgICAgICAgIChXZWJDb3JlOjpDQ1NldHRpbmdzOjpDQ1NldHRpbmdz KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1Byb3h5Lmg6Cisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NTaW5nbGVUaHJlYWRQcm94 eS5oOgorICAgICAgICAoV2ViQ29yZTo6Q0NTaW5nbGVUaHJlYWRQcm94eTo6cGFydGlhbFRleHR1 cmVVcGRhdGVDYXBhYmlsaXR5KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9jYy9DQ1RocmVhZFByb3h5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNDVGhyZWFkUHJveHk6 OnNjaGVkdWxlZEFjdGlvblVwZGF0ZU1vcmVSZXNvdXJjZXMpOgorICAgICAgICAoV2ViQ29yZTo6 Q0NUaHJlYWRQcm94eTo6cGFydGlhbFRleHR1cmVVcGRhdGVDYXBhYmlsaXR5KToKKyAgICAgICAg KiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5Lmg6CisKIDIwMTIt MDEtMDkgIFNoZXJpZmYgQm90ICA8d2Via2l0LnJldmlldy5ib3RAZ21haWwuY29tPgogCiAgICAg ICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHIxMDQ0MTguCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdl TG9nCmluZGV4IGVlZmMyZjkxM2MyYTNhNWNjYjRiZmZiZDg4YmY3OThjZTEzZmI0YTUuLjM0MTY0 MzJlZmEyZGVhMWUzZWQ2ZGMyNjgwOTNlMGZiMjY0ZDIxMGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hh bmdlTG9nCkBAIC0xLDMgKzEsNDIgQEAKKzIwMTItMDEtMDkgIERhdmlkIFJldmVtYW4gIDxyZXZl bWFuQGNocm9taXVtLm9yZz4KKworICAgICAgICBbY2hyb21pdW1dIEluY3JlbWVudGFsIHRleHR1 cmUgdXBkYXRlcyBhcmUgbm90IGF0b21pYy4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTcyNjcyCisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgQWRkIENDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQgdGVz dCB0aGF0IHZlcmlmaWVzIGF0b21pY2l0eQorICAgICAgICBvZiBjb21taXRzLgorCisgICAgICAg ICogdGVzdHMvQ0NMYXllclRyZWVIb3N0VGVzdC5jcHA6CisgICAgICAgIChXVEY6OkNvbXBvc2l0 b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6OmNyZWF0ZSk6CisgICAgICAgIChXVEY6OkNvbXBv c2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6Om1ha2VDb250ZXh0Q3VycmVudCk6CisgICAg ICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6OmNyZWF0ZVByb2dy YW0pOgorICAgICAgICAoV1RGOjpDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEOjpj cmVhdGVTaGFkZXIpOgorICAgICAgICAoV1RGOjpDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29u dGV4dDNEOjpnZXRTaGFkZXJpdik6CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3Jh cGhpY3NDb250ZXh0M0Q6OmdldFByb2dyYW1pdik6CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JG YWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6OmNyZWF0ZVRleHR1cmUpOgorICAgICAgICAoV1RGOjpD b21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEOjpkZWxldGVUZXh0dXJlKToKKyAgICAg ICAgKFdURjo6Q29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRDo6YmluZFRleHR1cmUp OgorICAgICAgICAoV1RGOjpDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEOjpudW1U ZXh0dXJlcyk6CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0 M0Q6OnRleHR1cmUpOgorICAgICAgICAoV1RGOjpDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29u dGV4dDNEOjpyZXNldFRleHR1cmVzKToKKyAgICAgICAgKFdURjo6Q29tcG9zaXRvckZha2VXZWJH cmFwaGljc0NvbnRleHQzRDo6bnVtVXNlZFRleHR1cmVzKToKKyAgICAgICAgKFdURjo6Q29tcG9z aXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRDo6dXNlZFRleHR1cmUpOgorICAgICAgICAoV1RG OjpDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEOjpyZXNldFVzZWRUZXh0dXJlcyk6 CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6OkNvbXBv c2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QpOgorICAgICAgICAoV1RGOjpNb2NrTGF5ZXJU cmVlSG9zdENsaWVudDo6Y3JlYXRlTGF5ZXJUcmVlSG9zdENvbnRleHQzRCk6CisgICAgICAgIChX VEY6Ok1vY2tMYXllckRlbGVnYXRlOjpkcmF3c0NvbnRlbnQpOgorICAgICAgICAoV1RGOjpNb2Nr TGF5ZXJEZWxlZ2F0ZTo6cGFpbnRDb250ZW50cyk6CisgICAgICAgIChXVEY6Ok1vY2tMYXllckRl bGVnYXRlOjpub3RpZnlTeW5jUmVxdWlyZWQpOgorICAgICAgICAoV1RGOjpDQ0xheWVyVHJlZUhv c3RUZXN0QXRvbWljQ29tbWl0OjpDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0KToKKyAg ICAgICAgKFdURjo6Q0NMYXllclRyZWVIb3N0VGVzdEF0b21pY0NvbW1pdDo6YmVnaW5UZXN0KToK KyAgICAgICAgKFdURjo6Q0NMYXllclRyZWVIb3N0VGVzdEF0b21pY0NvbW1pdDo6Y29tbWl0Q29t cGxldGVPbkNDVGhyZWFkKToKKyAgICAgICAgKFdURjo6Q0NMYXllclRyZWVIb3N0VGVzdEF0b21p Y0NvbW1pdDo6ZHJhd0xheWVyc09uQ0NUaHJlYWQpOgorICAgICAgICAoV1RGOjpDQ0xheWVyVHJl ZUhvc3RUZXN0QXRvbWljQ29tbWl0OjpsYXlvdXQpOgorICAgICAgICAoV1RGOjpDQ0xheWVyVHJl ZUhvc3RUZXN0QXRvbWljQ29tbWl0OjphZnRlclRlc3QpOgorICAgICAgICAoV1RGOjpURVNUX0Yp OgorCiAyMDEyLTAxLTA5ICBTaGVyaWZmIEJvdCAgPHdlYmtpdC5yZXZpZXcuYm90QGdtYWlsLmNv bT4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91dCByMTA0NDE4LgpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFuYWdlZFRleHR1 cmUuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFuYWdl ZFRleHR1cmUuY3BwCmluZGV4IDBjMWU0YjcwZDI3MTRhMzg2Zjk3ZWFhMzQ4ZDdlM2U4YzY2ZWNl MTEuLjViYjE5ZmE4N2RlYWQyN2NlN2UxYzc5M2E4ZmMzNTgyYzBkM2ZiZDEgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRUZXh0dXJl LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5h Z2VkVGV4dHVyZS5jcHAKQEAgLTQxLDYgKzQxLDE1IEBAIE1hbmFnZWRUZXh0dXJlOjpNYW5hZ2Vk VGV4dHVyZShUZXh0dXJlTWFuYWdlciogbWFuYWdlcikKIHsKIH0KIAorTWFuYWdlZFRleHR1cmU6 Ok1hbmFnZWRUZXh0dXJlKFRleHR1cmVNYW5hZ2VyKiBtYW5hZ2VyLCBUZXh0dXJlVG9rZW4gdG9r ZW4sIEludFNpemUgc2l6ZSwgdW5zaWduZWQgZm9ybWF0LCB1bnNpZ25lZCB0ZXh0dXJlSWQpCisg ICAgOiBtX3RleHR1cmVNYW5hZ2VyKG1hbmFnZXIpCisgICAgLCBtX3Rva2VuKHRva2VuKQorICAg ICwgbV9zaXplKHNpemUpCisgICAgLCBtX2Zvcm1hdChmb3JtYXQpCisgICAgLCBtX3RleHR1cmVJ ZCh0ZXh0dXJlSWQpCit7Cit9CisKIE1hbmFnZWRUZXh0dXJlOjp+TWFuYWdlZFRleHR1cmUoKQog ewogICAgIGlmIChtX3Rva2VuKQpAQCAtOTksNiArMTA4LDE3IEBAIHZvaWQgTWFuYWdlZFRleHR1 cmU6OmZyYW1lYnVmZmVyVGV4dHVyZTJEKEdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0LCBUZXh0 dXJlQWxsCiAgICAgY29udGV4dC0+ZnJhbWVidWZmZXJUZXh0dXJlMkQoR3JhcGhpY3NDb250ZXh0 M0Q6OkZSQU1FQlVGRkVSLCBHcmFwaGljc0NvbnRleHQzRDo6Q09MT1JfQVRUQUNITUVOVDAsIEdy YXBoaWNzQ29udGV4dDNEOjpURVhUVVJFXzJELCBtX3RleHR1cmVJZCwgMCk7CiB9CiAKK1Bhc3NP d25QdHI8TWFuYWdlZFRleHR1cmU+IE1hbmFnZWRUZXh0dXJlOjpzdGVhbCgpCit7CisgICAgT3du UHRyPE1hbmFnZWRUZXh0dXJlPiB0ZXh0dXJlID0gYWRvcHRQdHIobmV3IE1hbmFnZWRUZXh0dXJl KG1fdGV4dHVyZU1hbmFnZXIsIG1fdG9rZW4sIG1fc2l6ZSwgbV9mb3JtYXQsIG1fdGV4dHVyZUlk KSk7CisgICAgbV90b2tlbiA9IDA7CisgICAgbV9zaXplID0gSW50U2l6ZSgpOworICAgIG1fZm9y bWF0ID0gMDsKKyAgICBtX3RleHR1cmVJZCA9IDA7CisgICAgcmV0dXJuIHRleHR1cmUucmVsZWFz ZSgpOworfQorCisKIH0KIAogI2VuZGlmIC8vIFVTRShBQ0NFTEVSQVRFRF9DT01QT1NJVElORykK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01h bmFnZWRUZXh0dXJlLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9NYW5hZ2VkVGV4dHVyZS5oCmluZGV4IDFjYzhiZmE5YWIzMWNjOTIzMWI0N2E4M2NjNTY1MmEy MmFhZTgxYTguLjc2ZDYyYThiYjg5YWQ2ZDQxZjYzMGZiNjRiNmU2OGM5YjgzZmI3YWUgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRU ZXh0dXJlLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v TWFuYWdlZFRleHR1cmUuaApAQCAtNjMsOCArNjMsMTMgQEAgcHVibGljOgogICAgIHVuc2lnbmVk IGZvcm1hdCgpIGNvbnN0IHsgcmV0dXJuIG1fZm9ybWF0OyB9CiAgICAgdW5zaWduZWQgdGV4dHVy ZUlkKCkgY29uc3QgeyByZXR1cm4gbV90ZXh0dXJlSWQ7IH0KIAorICAgIC8vIFN0ZWFsIHRva2Vu IGFuZCB0ZXh0dXJlSWQgYnkgaW5zdGFudGlhdGVzIGEgbmV3IHRleHR1cmUgdXNpbmcgZXhpc3Rp bmcKKyAgICAvLyBtZW1iZXIgdmFyaWFibGVzLgorICAgIFBhc3NPd25QdHI8TWFuYWdlZFRleHR1 cmU+IHN0ZWFsKCk7CisKIHByaXZhdGU6CiAgICAgZXhwbGljaXQgTWFuYWdlZFRleHR1cmUoVGV4 dHVyZU1hbmFnZXIqKTsKKyAgICBNYW5hZ2VkVGV4dHVyZShUZXh0dXJlTWFuYWdlciosIFRleHR1 cmVUb2tlbiwgSW50U2l6ZSwgdW5zaWduZWQgZm9ybWF0LCB1bnNpZ25lZCB0ZXh0dXJlSWQpOwog CiAgICAgVGV4dHVyZU1hbmFnZXIqIG1fdGV4dHVyZU1hbmFnZXI7CiAgICAgVGV4dHVyZVRva2Vu IG1fdG9rZW47CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcAppbmRleCBhZDJjYjEzZmM3 MzA5MzZhOWM5NGQ0YTg4NDUxMzgzYzNjZDJmMTM4Li5hOTFkYjIxZWY2MGRkZTk3ZWZlNTZhOGQ3 MDQ3MGE3MTUzYjNmMmMzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAKQEAgLTM3 NCw2ICszNzQsMTEgQEAgdm9pZCBUaWxlZExheWVyQ2hyb21pdW06OnByZXBhcmVUb1VwZGF0ZVRp bGVzKGJvb2wgaWRsZSwgaW50IGxlZnQsIGludCB0b3AsIGludAogICAgICAgICAgICAgaWYgKCF0 aWxlKQogICAgICAgICAgICAgICAgIHRpbGUgPSBjcmVhdGVUaWxlKGksIGopOwogCisgICAgICAg ICAgICAvLyBEbyBwb3N0IGNvbW1pdCBkZWxldGlvbiBvZiBjdXJyZW50IHRleHR1cmUgd2hlbiBw YXJ0aWFsIHRleHR1cmUKKyAgICAgICAgICAgIC8vIHVwZGF0ZXMgYXJlIG5vdCB1c2VkLgorICAg ICAgICAgICAgaWYgKHRpbGUtPmlzRGlydHkoKSAmJiBsYXllclRyZWVIb3N0KCkgJiYgIWxheWVy VHJlZUhvc3QoKS0+c2V0dGluZ3MoKS5wYXJ0aWFsVGV4dHVyZVVwZGF0ZXMpCisgICAgICAgICAg ICAgICAgbGF5ZXJUcmVlSG9zdCgpLT5kZWxldGVUZXh0dXJlQWZ0ZXJDb21taXQodGlsZS0+bWFu YWdlZFRleHR1cmUoKS0+c3RlYWwoKSk7CisKICAgICAgICAgICAgIGlmICghdGlsZS0+bWFuYWdl ZFRleHR1cmUoKS0+aXNWYWxpZChtX3RpbGVyLT50aWxlU2l6ZSgpLCBtX3RleHR1cmVGb3JtYXQp KQogICAgICAgICAgICAgICAgIHRpbGUtPm1fZGlydHlSZWN0ID0gbV90aWxlci0+dGlsZVJlY3Qo dGlsZSk7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwCmluZGV4IDM3OWQxNjA4Mzc1 OTg0ZTU5NGIyNThiMDI4MDdiZGQ1MGM2NTU0YTkuLjgxZTg4NjA1N2FmZDkwNzQwODg3NjFiZjEz NmI1ZGFlN2ZlZmNiMWIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcApAQCAtOTQs NiArOTQsOSBAQCBib29sIENDTGF5ZXJUcmVlSG9zdDo6aW5pdGlhbGl6ZSgpCiAgICAgLy8gVXBk YXRlIG1fc2V0dGluZ3MgYmFzZWQgb24gY2FwYWJpbGl0aWVzIHRoYXQgd2UgZ290IGJhY2sgZnJv bSB0aGUgcmVuZGVyZXIuCiAgICAgbV9zZXR0aW5ncy5hY2NlbGVyYXRlUGFpbnRpbmcgPSBtX3By b3h5LT5sYXllclJlbmRlcmVyQ2FwYWJpbGl0aWVzKCkudXNpbmdBY2NlbGVyYXRlZFBhaW50aW5n OwogCisgICAgLy8gVXBkYXRlIG1fc2V0dGluZ3MgYmFzZWQgb24gcGFydGlhbCB1cGRhdGUgY2Fw YWJpbGl0eS4KKyAgICBtX3NldHRpbmdzLnBhcnRpYWxUZXh0dXJlVXBkYXRlcyA9IG1fc2V0dGlu Z3MucGFydGlhbFRleHR1cmVVcGRhdGVzICYmIG1fcHJveHktPnBhcnRpYWxUZXh0dXJlVXBkYXRl Q2FwYWJpbGl0eSgpOworCiAgICAgbV9jb250ZW50c1RleHR1cmVNYW5hZ2VyID0gVGV4dHVyZU1h bmFnZXI6OmNyZWF0ZShUZXh0dXJlTWFuYWdlcjo6aGlnaExpbWl0Qnl0ZXModmlld3BvcnRTaXpl KCkpLAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgVGV4dHVyZU1hbmFnZXI6OnJlY2xhaW1MaW1pdEJ5dGVzKHZpZXdwb3J0U2l6ZSgpKSwKICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIG1fcHJv eHktPmxheWVyUmVuZGVyZXJDYXBhYmlsaXRpZXMoKS5tYXhUZXh0dXJlU2l6ZSk7CkBAIC0xNjQs NiArMTY3LDcgQEAgdm9pZCBDQ0xheWVyVHJlZUhvc3Q6OmZpbmlzaENvbW1pdE9uSW1wbFRocmVh ZChDQ0xheWVyVHJlZUhvc3RJbXBsKiBob3N0SW1wbCkKIAogdm9pZCBDQ0xheWVyVHJlZUhvc3Q6 OmNvbW1pdENvbXBsZXRlKCkKIHsKKyAgICBtX2RlbGV0ZVRleHR1cmVBZnRlckNvbW1pdExpc3Qu Y2xlYXIoKTsKICAgICBjbGVhclBlbmRpbmdVcGRhdGUoKTsKICAgICBtX2NvbnRlbnRzVGV4dHVy ZU1hbmFnZXItPnVucHJvdGVjdEFsbFRleHR1cmVzKCk7CiB9CkBAIC01MjcsNCArNTMxLDkgQEAg dm9pZCBDQ0xheWVyVHJlZUhvc3Q6OnN0b3BSYXRlTGltaXRlcihHcmFwaGljc0NvbnRleHQzRCog Y29udGV4dCkKICAgICB9CiB9CiAKK3ZvaWQgQ0NMYXllclRyZWVIb3N0OjpkZWxldGVUZXh0dXJl QWZ0ZXJDb21taXQoUGFzc093blB0cjxNYW5hZ2VkVGV4dHVyZT4gdGV4dHVyZSkKK3sKKyAgICBt X2RlbGV0ZVRleHR1cmVBZnRlckNvbW1pdExpc3QuYXBwZW5kKHRleHR1cmUpOworfQorCiB9CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9D Q0xheWVyVHJlZUhvc3QuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oCmluZGV4IDRmMjkzZWNhNWEyMTIzZDc2NWE2NDBlNGU3 NDI4NGZkNTY3NjMwYWUuLmFjYzQzZmUyN2VhN2QzNDE3NzBiMjIyODU0YTU2ZWFiZWRhM2VkMTkg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2Nj L0NDTGF5ZXJUcmVlSG9zdC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5oCkBAIC03Niw3ICs3Niw4IEBAIHN0cnVjdCBD Q1NldHRpbmdzIHsKICAgICAgICAgICAgICwgc2hvd1BsYXRmb3JtTGF5ZXJUcmVlKGZhbHNlKQog ICAgICAgICAgICAgLCByZWZyZXNoUmF0ZSgwKQogICAgICAgICAgICAgLCBwZXJUaWxlUGFpbnRp bmcoZmFsc2UpCi0gICAgICAgICAgICAsIHBhcnRpYWxTd2FwRW5hYmxlZChmYWxzZSkgeyB9Cisg ICAgICAgICAgICAsIHBhcnRpYWxTd2FwRW5hYmxlZChmYWxzZSkKKyAgICAgICAgICAgICwgcGFy dGlhbFRleHR1cmVVcGRhdGVzKHRydWUpIHsgfQogCiAgICAgYm9vbCBhY2NlbGVyYXRlUGFpbnRp bmc7CiAgICAgYm9vbCBjb21wb3NpdGVPZmZzY3JlZW47CkBAIC04NSw2ICs4Niw3IEBAIHN0cnVj dCBDQ1NldHRpbmdzIHsKICAgICBkb3VibGUgcmVmcmVzaFJhdGU7CiAgICAgYm9vbCBwZXJUaWxl UGFpbnRpbmc7CiAgICAgYm9vbCBwYXJ0aWFsU3dhcEVuYWJsZWQ7CisgICAgYm9vbCBwYXJ0aWFs VGV4dHVyZVVwZGF0ZXM7CiB9OwogCiAvLyBQcm92aWRlcyBpbmZvcm1hdGlvbiBvbiBhbiBJbXBs J3MgcmVuZGVyaW5nIGNhcGFiaWxpdGllcyBiYWNrIHRvIHRoZSBDQ0xheWVyVHJlZUhvc3QKQEAg LTE5MiwxMiArMTk0LDE1IEBAIHB1YmxpYzoKICAgICB2b2lkIHN0YXJ0UmF0ZUxpbWl0ZXIoR3Jh cGhpY3NDb250ZXh0M0QqKTsKICAgICB2b2lkIHN0b3BSYXRlTGltaXRlcihHcmFwaGljc0NvbnRl eHQzRCopOwogCisgICAgdm9pZCBkZWxldGVUZXh0dXJlQWZ0ZXJDb21taXQoUGFzc093blB0cjxN YW5hZ2VkVGV4dHVyZT4pOworCiBwcm90ZWN0ZWQ6CiAgICAgQ0NMYXllclRyZWVIb3N0KENDTGF5 ZXJUcmVlSG9zdENsaWVudCosIGNvbnN0IENDU2V0dGluZ3MmKTsKICAgICBib29sIGluaXRpYWxp emUoKTsKIAogcHJpdmF0ZToKICAgICB0eXBlZGVmIFZlY3RvcjxSZWZQdHI8TGF5ZXJDaHJvbWl1 bT4gPiBMYXllckxpc3Q7CisgICAgdHlwZWRlZiBWZWN0b3I8T3duUHRyPE1hbmFnZWRUZXh0dXJl PiA+IFRleHR1cmVMaXN0OwogCiAgICAgZW51bSBQYWludFR5cGUgeyBQYWludFZpc2libGUsIFBh aW50SWRsZSB9OwogICAgIHN0YXRpYyB2b2lkIHBhaW50Q29udGVudHNJZkRpcnR5KExheWVyQ2hy b21pdW0qLCBQYWludFR5cGUpOwpAQCAtMjMzLDYgKzIzOCw4IEBAIHByaXZhdGU6CiAgICAgZmxv YXQgbV9wYWdlU2NhbGU7CiAgICAgZmxvYXQgbV9taW5QYWdlU2NhbGUsIG1fbWF4UGFnZVNjYWxl OwogICAgIGJvb2wgbV90cmlnZ2VySWRsZVBhaW50czsKKworICAgIFRleHR1cmVMaXN0IG1fZGVs ZXRlVGV4dHVyZUFmdGVyQ29tbWl0TGlzdDsKIH07CiAKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDUHJveHkuaCBiL1NvdXJjZS9X ZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDUHJveHkuaAppbmRleCBiYjM3 ODAxNDdiMTZjMjZiNzVhN2NjZDIyYWE4YjhmZTg0ZTc2YmJkLi45MzdjMTU0ZmY2OWJhODUzYmJm YzkzNDU2ZDc3NjY3MTBjNzBhMjI0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1Byb3h5LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NQcm94eS5oCkBAIC03OSw2ICs3OSwxMCBAQCBw dWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHN0YXJ0KCkgPSAwOyAvLyBNdXN0IGJlIGNhbGxlZCBi ZWZvcmUgdXNpbmcgdGhlIHByb3h5LgogICAgIHZpcnR1YWwgdm9pZCBzdG9wKCkgPSAwOyAvLyBN dXN0IGJlIGNhbGxlZCBiZWZvcmUgZGVsZXRpbmcgdGhlIHByb3h5LgogCisgICAgLy8gV2hldGhl ciBzdWItcmVnaW9ucyBvZiB0ZXh0dXJlcyBjYW4gYmUgdXBkYXRlZCBvciBpZiBjb21wbGV0ZSB0 ZXh0dXJlCisgICAgLy8gdXBkYXRlcyBhcmUgcmVxdWlyZWQuCisgICAgdmlydHVhbCBib29sIHBh cnRpYWxUZXh0dXJlVXBkYXRlQ2FwYWJpbGl0eSgpIGNvbnN0ID0gMDsKKwogICAgIC8vIERlYnVn IGhvb2tzCiAjaWZuZGVmIE5ERUJVRwogICAgIHN0YXRpYyBib29sIGlzTWFpblRocmVhZCgpOwpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NTaW5nbGVUaHJlYWRQcm94eS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vY2MvQ0NTaW5nbGVUaHJlYWRQcm94eS5oCmluZGV4IDBkNWE0YTJkOGE1MTZiMWQ3 YmNmOTkxYTk5ZTFjNzg3ODk5NDNlYzUuLjRmYWEyMjk5OTEyYWVjOWM0ZTZhYjRiYTcwMjdkODFj ODA2ZDQ1ZWUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL2NjL0NDU2luZ2xlVGhyZWFkUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1NpbmdsZVRocmVhZFByb3h5LmgKQEAgLTU0LDYg KzU0LDcgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBzZXRWaXNpYmxlKGJvb2wpOwogICAg IHZpcnR1YWwgdm9pZCBzdGFydCgpOwogICAgIHZpcnR1YWwgdm9pZCBzdG9wKCk7CisgICAgdmly dHVhbCBib29sIHBhcnRpYWxUZXh0dXJlVXBkYXRlQ2FwYWJpbGl0eSgpIGNvbnN0IHsgcmV0dXJu IHRydWU7IH0KIAogICAgIC8vIENDTGF5ZXJUcmVlSG9zdEltcGxDbGllbnQgaW1wbGVtZW50YXRp b24KICAgICB2aXJ0dWFsIHZvaWQgb25Td2FwQnVmZmVyc0NvbXBsZXRlT25JbXBsVGhyZWFkKCkg eyBBU1NFUlRfTk9UX1JFQUNIRUQoKTsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5jcHAgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmNwcAppbmRl eCA5MDMzMTM1MTNhOWQwOTgyMzQxMmU1ZTc3ZDY5OTg1NDU3ZjkzYTYxLi4zMmE4NjMwY2UzMTAy NTAxNzc4OWQyNTA0NDZiZjlmZjY5MDQwZDBkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmNwcAorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmNw cApAQCAtMzksOCArMzksMTUgQEAKICNpbmNsdWRlIDx3dGYvQ3VycmVudFRpbWUuaD4KICNpbmNs dWRlIDx3dGYvTWFpblRocmVhZC5oPgogCit1c2luZyBuYW1lc3BhY2Ugc3RkOwogdXNpbmcgbmFt ZXNwYWNlIFdURjsKIAorbmFtZXNwYWNlIHsKKworc3RhdGljIGNvbnN0IHNpemVfdCB0ZXh0dXJl VXBkYXRlc1BlckZyYW1lID0gbnVtZXJpY19saW1pdHM8c2l6ZV90Pjo6bWF4KCk7CisKK30gLy8g YW5vbnltb3VzIG5hbWVzcGFjZQorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAKIFBhc3NPd25QdHI8 Q0NQcm94eT4gQ0NUaHJlYWRQcm94eTo6Y3JlYXRlKENDTGF5ZXJUcmVlSG9zdCogbGF5ZXJUcmVl SG9zdCkKQEAgLTQzOCw4ICs0NDUsNyBAQCB2b2lkIENDVGhyZWFkUHJveHk6OnNjaGVkdWxlZEFj dGlvblVwZGF0ZU1vcmVSZXNvdXJjZXMoKQogewogICAgIFRSQUNFX0VWRU5UKCJDQ1RocmVhZFBy b3h5OjpzY2hlZHVsZWRBY3Rpb25VcGRhdGVNb3JlUmVzb3VyY2VzIiwgdGhpcywgMCk7CiAgICAg QVNTRVJUKG1fY3VycmVudFRleHR1cmVVcGRhdGVyT25JbXBsVGhyZWFkKTsKLSAgICBzdGF0aWMg Y29uc3QgaW50IFVwZGF0ZXNQZXJGcmFtZSA9IDk5OTk5OwotICAgIG1fY3VycmVudFRleHR1cmVV cGRhdGVyT25JbXBsVGhyZWFkLT51cGRhdGUobV9sYXllclRyZWVIb3N0SW1wbC0+Y29udGV4dCgp LCBVcGRhdGVzUGVyRnJhbWUpOworICAgIG1fY3VycmVudFRleHR1cmVVcGRhdGVyT25JbXBsVGhy ZWFkLT51cGRhdGUobV9sYXllclRyZWVIb3N0SW1wbC0+Y29udGV4dCgpLCB0ZXh0dXJlVXBkYXRl c1BlckZyYW1lKTsKIH0KIAogdm9pZCBDQ1RocmVhZFByb3h5OjpzY2hlZHVsZWRBY3Rpb25Db21t aXQoKQpAQCAtNTY1LDQgKzU3MSw5IEBAIHZvaWQgQ0NUaHJlYWRQcm94eTo6bGF5ZXJUcmVlSG9z dENsb3NlZE9uSW1wbFRocmVhZChDQ0NvbXBsZXRpb25FdmVudCogY29tcGxldGlvCiAgICAgY29t cGxldGlvbi0+c2lnbmFsKCk7CiB9CiAKK2Jvb2wgQ0NUaHJlYWRQcm94eTo6cGFydGlhbFRleHR1 cmVVcGRhdGVDYXBhYmlsaXR5KCkgY29uc3QKK3sKKyAgICByZXR1cm4gdGV4dHVyZVVwZGF0ZXNQ ZXJGcmFtZSA9PSBudW1lcmljX2xpbWl0czxzaXplX3Q+OjptYXgoKTsKK30KKwogfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5oCmluZGV4IGE0MWMwZDU2NGI2Mzgx M2JhNjNhNmNlZDU4ZTA0ZDY5YzM4ZjJkZWEuLmExMWI1Mjc4NTk5MzFjZmI5OGY4NzI0YTUxMjQz YTA5YjRlY2MzYjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmgKQEAgLTYyLDYgKzYyLDcgQEAg cHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBzZXRWaXNpYmxlKGJvb2wpOwogICAgIHZpcnR1YWwg dm9pZCBzdGFydCgpOwogICAgIHZpcnR1YWwgdm9pZCBzdG9wKCk7CisgICAgdmlydHVhbCBib29s IHBhcnRpYWxUZXh0dXJlVXBkYXRlQ2FwYWJpbGl0eSgpIGNvbnN0OwogCiAgICAgLy8gQ0NMYXll clRyZWVIb3N0SW1wbENsaWVudCBpbXBsZW1lbnRhdGlvbgogICAgIHZpcnR1YWwgdm9pZCBvblN3 YXBCdWZmZXJzQ29tcGxldGVPbkltcGxUaHJlYWQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vdGVzdHMvQ0NMYXllclRyZWVIb3N0VGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3Rlc3RzL0NDTGF5ZXJUcmVlSG9zdFRlc3QuY3BwCmluZGV4IGU2Y2U4YjA2NjNl Y2E5ZWZlN2UzNGFmZDIyYzhlMWZlY2U5MTBkZjYuLjJiZmFjYjY2MDU4YzNiY2YxNmE5OTU0MTE0 ZTIxYjVjOGFkZjRmZWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMv Q0NMYXllclRyZWVIb3N0VGVzdC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0 cy9DQ0xheWVyVHJlZUhvc3RUZXN0LmNwcApAQCAtMjYsOSArMjYsOSBAQAogCiAjaW5jbHVkZSAi Y2MvQ0NMYXllclRyZWVIb3N0LmgiCiAKLSNpbmNsdWRlICJDb21wb3NpdG9yRmFrZUdyYXBoaWNz Q29udGV4dDNELmgiCiAjaW5jbHVkZSAiQ29udGVudExheWVyQ2hyb21pdW0uaCIKICNpbmNsdWRl ICJGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QuaCIKKyNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQz RFByaXZhdGUuaCIKICNpbmNsdWRlICJMYXllckNocm9taXVtLmgiCiAjaW5jbHVkZSAiVGV4dHVy ZU1hbmFnZXIuaCIKICNpbmNsdWRlICJXZWJDb21wb3NpdG9yLmgiCkBAIC00MCwxMiArNDAsMTQg QEAKICNpbmNsdWRlICJjYy9DQ1RocmVhZFRhc2suaCIKICNpbmNsdWRlICJwbGF0Zm9ybS9XZWJL aXRQbGF0Zm9ybVN1cHBvcnQuaCIKICNpbmNsdWRlICJwbGF0Zm9ybS9XZWJUaHJlYWQuaCIKKyNp bmNsdWRlIDxnbW9jay9nbW9jay5oPgogI2luY2x1ZGUgPGd0ZXN0L2d0ZXN0Lmg+CiAjaW5jbHVk ZSA8d2Via2l0L3N1cHBvcnQvd2Via2l0X3N1cHBvcnQuaD4KICNpbmNsdWRlIDx3dGYvTWFpblRo cmVhZC5oPgogI2luY2x1ZGUgPHd0Zi9QYXNzUmVmUHRyLmg+CiAjaW5jbHVkZSA8d3RmL1ZlY3Rv ci5oPgogCit1c2luZyBuYW1lc3BhY2Ugc3RkOwogdXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CiB1 c2luZyBuYW1lc3BhY2UgV2ViS2l0OwogdXNpbmcgbmFtZXNwYWNlIFdURjsKQEAgLTEzMCw2ICsx MzIsNjAgQEAgcHJpdmF0ZToKICAgICBUZXN0SG9va3MqIG1fdGVzdEhvb2tzOwogfTsKIAorLy8g VGVzdCBzdHViIGZvciBXZWJHcmFwaGljc0NvbnRleHQzRC4gUmV0dXJucyBjYW5uZWQgdmFsdWVz IG5lZWRlZCBmb3IgY29tcG9zaXRvciBpbml0aWFsaXphdGlvbi4KK2NsYXNzIENvbXBvc2l0b3JG YWtlV2ViR3JhcGhpY3NDb250ZXh0M0QgOiBwdWJsaWMgRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNE IHsKK3B1YmxpYzoKKyAgICBzdGF0aWMgUGFzc093blB0cjxDb21wb3NpdG9yRmFrZVdlYkdyYXBo aWNzQ29udGV4dDNEPiBjcmVhdGUoQXR0cmlidXRlcyBhdHRycykKKyAgICB7CisgICAgICAgIHJl dHVybiBhZG9wdFB0cihuZXcgQ29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRChhdHRy cykpOworICAgIH0KKworICAgIHZpcnR1YWwgYm9vbCBtYWtlQ29udGV4dEN1cnJlbnQoKSB7IHJl dHVybiB0cnVlOyB9CisgICAgdmlydHVhbCBXZWJHTElkIGNyZWF0ZVByb2dyYW0oKSB7IHJldHVy biAxOyB9CisgICAgdmlydHVhbCBXZWJHTElkIGNyZWF0ZVNoYWRlcihXR0MzRGVudW0pIHsgcmV0 dXJuIDE7IH0KKyAgICB2aXJ0dWFsIHZvaWQgZ2V0U2hhZGVyaXYoV2ViR0xJZCwgV0dDM0RlbnVt LCBXR0MzRGludCogdmFsdWUpIHsgKnZhbHVlID0gMTsgfQorICAgIHZpcnR1YWwgdm9pZCBnZXRQ cm9ncmFtaXYoV2ViR0xJZCwgV0dDM0RlbnVtLCBXR0MzRGludCogdmFsdWUpIHsgKnZhbHVlID0g MTsgfQorCisgICAgdmlydHVhbCBXZWJHTElkIGNyZWF0ZVRleHR1cmUoKQorICAgIHsKKyAgICAg ICAgV2ViR0xJZCB0ZXh0dXJlID0gbV90ZXh0dXJlcy5zaXplKCkgKyAxOworICAgICAgICBtX3Rl eHR1cmVzLnB1c2hfYmFjayh0ZXh0dXJlKTsKKyAgICAgICAgcmV0dXJuIHRleHR1cmU7CisgICAg fQorCisgICAgdmlydHVhbCB2b2lkIGRlbGV0ZVRleHR1cmUoV2ViR0xJZCB0ZXh0dXJlKQorICAg IHsKKyAgICAgICAgZm9yICh2ZWN0b3I8V2ViR0xJZD46Oml0ZXJhdG9yIGl0ID0gbV90ZXh0dXJl cy5iZWdpbigpOyBpdCAhPSBtX3RleHR1cmVzLmVuZCgpOyBpdCsrKSB7CisgICAgICAgICAgICBp ZiAoKml0ID09IHRleHR1cmUpIHsKKyAgICAgICAgICAgICAgICBtX3RleHR1cmVzLmVyYXNlKGl0 KTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKyAgICAgICAgfQorICAg IH0KKworICAgIHZpcnR1YWwgdm9pZCBiaW5kVGV4dHVyZShXR0MzRGVudW0gLyogdGFyZ2V0ICov LCBXZWJHTElkIHRleHR1cmUpCisgICAgeworICAgICAgICBtX3VzZWRUZXh0dXJlcy5pbnNlcnQo dGV4dHVyZSk7CisgICAgfQorCisgICAgaW50IG51bVRleHR1cmVzKCkgY29uc3QgeyByZXR1cm4g c3RhdGljX2Nhc3Q8aW50PihtX3RleHR1cmVzLnNpemUoKSk7IH0KKyAgICBpbnQgdGV4dHVyZShp bnQgaSkgY29uc3QgeyByZXR1cm4gbV90ZXh0dXJlc1tpXTsgfQorICAgIHZvaWQgcmVzZXRUZXh0 dXJlcygpIHsgbV90ZXh0dXJlcy5jbGVhcigpOyB9CisKKyAgICBpbnQgbnVtVXNlZFRleHR1cmVz KCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8aW50PihtX3VzZWRUZXh0dXJlcy5zaXplKCkp OyB9CisgICAgYm9vbCB1c2VkVGV4dHVyZShpbnQgdGV4dHVyZSkgY29uc3QgeyByZXR1cm4gbV91 c2VkVGV4dHVyZXMuZmluZCh0ZXh0dXJlKSAhPSBtX3VzZWRUZXh0dXJlcy5lbmQoKTsgfQorICAg IHZvaWQgcmVzZXRVc2VkVGV4dHVyZXMoKSB7IG1fdXNlZFRleHR1cmVzLmNsZWFyKCk7IH0KKwor cHJpdmF0ZToKKyAgICBleHBsaWNpdCBDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNE KEF0dHJpYnV0ZXMgYXR0cnMpCisgICAgeworICAgICAgICBtX2F0dHJzID0gYXR0cnM7CisgICAg fQorCisgICAgdmVjdG9yPFdlYkdMSWQ+IG1fdGV4dHVyZXM7CisgICAgc2V0PFdlYkdMSWQ+IG1f dXNlZFRleHR1cmVzOworfTsKKwogLy8gSW1wbGVtZW50YXRpb24gb2YgQ0NMYXllclRyZWVIb3N0 IGNhbGxiYWNrIGludGVyZmFjZS4KIGNsYXNzIE1vY2tMYXllclRyZWVIb3N0Q2xpZW50IDogcHVi bGljIENDTGF5ZXJUcmVlSG9zdENsaWVudCB7CiBwdWJsaWM6CkBAIC0xNTUsNyArMjExLDE1IEBA IHB1YmxpYzoKIAogICAgIHZpcnR1YWwgUGFzc1JlZlB0cjxHcmFwaGljc0NvbnRleHQzRD4gY3Jl YXRlTGF5ZXJUcmVlSG9zdENvbnRleHQzRCgpCiAgICAgewotICAgICAgICByZXR1cm4gY3JlYXRl Q29tcG9zaXRvck1vY2tHcmFwaGljc0NvbnRleHQzRChHcmFwaGljc0NvbnRleHQzRDo6QXR0cmli dXRlcygpKTsKKyAgICAgICAgR3JhcGhpY3NDb250ZXh0M0Q6OkF0dHJpYnV0ZXMgYXR0cnM7Cisg ICAgICAgIFdlYkdyYXBoaWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzIHdlYkF0dHJzOworICAgICAg ICB3ZWJBdHRycy5hbHBoYSA9IGF0dHJzLmFscGhhOworCisgICAgICAgIE93blB0cjxXZWJHcmFw aGljc0NvbnRleHQzRD4gd2ViQ29udGV4dCA9IENvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250 ZXh0M0Q6OmNyZWF0ZSh3ZWJBdHRycyk7CisgICAgICAgIHJldHVybiBHcmFwaGljc0NvbnRleHQz RFByaXZhdGU6OmNyZWF0ZUdyYXBoaWNzQ29udGV4dEZyb21XZWJDb250ZXh0KAorICAgICAgICAg ICAgd2ViQ29udGV4dC5yZWxlYXNlKCksIGF0dHJzLCAwLAorICAgICAgICAgICAgR3JhcGhpY3ND b250ZXh0M0Q6OlJlbmRlckRpcmVjdGx5VG9Ib3N0V2luZG93LAorICAgICAgICAgICAgR3JhcGhp Y3NDb250ZXh0M0RQcml2YXRlOjpGb3JVc2VPbkFub3RoZXJUaHJlYWQpOwogICAgIH0KIAogICAg IHZpcnR1YWwgdm9pZCBkaWRDb21taXRBbmREcmF3RnJhbWUoKQpAQCAtMTAyNSw0ICsxMDg5LDEw MSBAQCBURVNUX0YoQ0NMYXllclRyZWVIb3N0VGVzdE9wYWNpdHlDaGFuZ2UsIHJ1bk11bHRpVGhy ZWFkKQogICAgIHJ1blRlc3QodHJ1ZSk7CiB9CiAKK2NsYXNzIE1vY2tMYXllckRlbGVnYXRlIDog cHVibGljIENDTGF5ZXJEZWxlZ2F0ZSB7CitwdWJsaWM6CisgICAgYm9vbCBkcmF3c0NvbnRlbnQo KSBjb25zdCB7IHJldHVybiB0cnVlOyB9CisgICAgTU9DS19DT05TVF9NRVRIT0QwKHByZXNlcnZl czNELCBib29sKCkpOworICAgIHZvaWQgcGFpbnRDb250ZW50cyhHcmFwaGljc0NvbnRleHQmLCBj b25zdCBJbnRSZWN0JikgeyB9CisgICAgdm9pZCBub3RpZnlTeW5jUmVxdWlyZWQoKSB7IH0KK307 CisKKy8vIFZlcmlmeSBhdG9taWNpdHkgb2YgY29tbWl0cyBhbmQgcmV1c2Ugb2YgdGV4dHVyZXMu CitjbGFzcyBDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0IDogcHVibGljIENDTGF5ZXJU cmVlSG9zdFRlc3QgeworcHVibGljOgorICAgIENDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21t aXQoKQorICAgICAgICA6IG1fdXBkYXRlQ2hlY2tMYXllcihDb250ZW50TGF5ZXJDaHJvbWl1bVdp dGhVcGRhdGVUcmFja2luZzo6Y3JlYXRlKCZtX2RlbGVnYXRlKSkKKyAgICAgICAgLCBtX251bUNv bW1pdHMoMCkKKyAgICB7CisgICAgICAgIC8vIE1ha2Ugc3VyZSBwYXJ0aWFsIHRleHR1cmUgdXBk YXRlcyBhcmUgdHVybmVkIG9mZi4KKyAgICAgICAgbV9zZXR0aW5ncy5wYXJ0aWFsVGV4dHVyZVVw ZGF0ZXMgPSBmYWxzZTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgYmVnaW5UZXN0KCkKKyAg ICB7CisgICAgICAgIG1fbGF5ZXJUcmVlSG9zdC0+c2V0Um9vdExheWVyKG1fdXBkYXRlQ2hlY2tM YXllcik7CisgICAgICAgIG1fbGF5ZXJUcmVlSG9zdC0+c2V0Vmlld3BvcnQoSW50U2l6ZSgxMCwg MTApKTsKKworICAgICAgICBwb3N0U2V0TmVlZHNDb21taXRUb01haW5UaHJlYWQoKTsKKyAgICAg ICAgcG9zdFNldE5lZWRzUmVkcmF3VG9NYWluVGhyZWFkKCk7CisgICAgfQorCisgICAgdmlydHVh bCB2b2lkIGNvbW1pdENvbXBsZXRlT25DQ1RocmVhZChDQ0xheWVyVHJlZUhvc3RJbXBsKiBpbXBs KQorICAgIHsKKyAgICAgICAgQ29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRCogY29u dGV4dCA9IHN0YXRpY19jYXN0PENvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QqPihH cmFwaGljc0NvbnRleHQzRFByaXZhdGU6OmV4dHJhY3RXZWJHcmFwaGljc0NvbnRleHQzRChpbXBs LT5jb250ZXh0KCkpKTsKKworICAgICAgICBzd2l0Y2ggKGltcGwtPmZyYW1lTnVtYmVyKCkpIHsK KyAgICAgICAgY2FzZSAwOgorICAgICAgICAgICAgLy8gTnVtYmVyIG9mIHRleHR1cmVzIHNob3Vs ZCBiZSBvbmUuCisgICAgICAgICAgICBFWFBFQ1RfRVEoMSwgY29udGV4dC0+bnVtVGV4dHVyZXMo KSk7CisgICAgICAgICAgICAvLyBOdW1iZXIgb2YgdGV4dHVyZXMgdXNlZCBmb3IgY29tbWl0IHNo b3VsZCBiZSBvbmUuCisgICAgICAgICAgICBFWFBFQ1RfRVEoMSwgY29udGV4dC0+bnVtVXNlZFRl eHR1cmVzKCkpOworICAgICAgICAgICAgLy8gVmVyaWZ5IHVzZWQgdGV4dHVyZSBpcyBjb3JyZWN0 LgorICAgICAgICAgICAgRVhQRUNUX1RSVUUoY29udGV4dC0+dXNlZFRleHR1cmUoY29udGV4dC0+ dGV4dHVyZSgwKSkpOworCisgICAgICAgICAgICBjb250ZXh0LT5yZXNldFVzZWRUZXh0dXJlcygp OworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgMToKKyAgICAgICAgICAgIC8vIE51 bWJlciBvZiB0ZXh0dXJlcyBzaG91bGQgYmUgdHdvIGFzIHRoZSBmaXJzdCB0ZXh0dXJlCisgICAg ICAgICAgICAvLyBpcyB1c2VkIGJ5IGltcGwgdGhyZWFkIGFuZCBjYW5ub3QgYnkgdXNlZCBmb3Ig dXBkYXRlLgorICAgICAgICAgICAgRVhQRUNUX0VRKDIsIGNvbnRleHQtPm51bVRleHR1cmVzKCkp OworICAgICAgICAgICAgLy8gTnVtYmVyIG9mIHRleHR1cmVzIHVzZWQgZm9yIGNvbW1pdCBzaG91 bGQgc3RpbGwgYmUgb25lLgorICAgICAgICAgICAgRVhQRUNUX0VRKDEsIGNvbnRleHQtPm51bVVz ZWRUZXh0dXJlcygpKTsKKyAgICAgICAgICAgIC8vIEZpcnN0IHRleHR1cmUgc2hvdWxkIG5vdCBo YXZlIGJlZW4gdXNlZC4KKyAgICAgICAgICAgIEVYUEVDVF9GQUxTRShjb250ZXh0LT51c2VkVGV4 dHVyZShjb250ZXh0LT50ZXh0dXJlKDApKSk7CisgICAgICAgICAgICAvLyBOZXcgdGV4dHVyZSBz aG91bGQgaGF2ZSBiZWVuIHVzZWQuCisgICAgICAgICAgICBFWFBFQ1RfVFJVRShjb250ZXh0LT51 c2VkVGV4dHVyZShjb250ZXh0LT50ZXh0dXJlKDEpKSk7CisKKyAgICAgICAgICAgIGNvbnRleHQt PnJlc2V0VXNlZFRleHR1cmVzKCk7CisgICAgICAgICAgICBicmVhazsKKyAgICAgICAgZGVmYXVs dDoKKyAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgICAgICAgICAgYnJlYWs7 CisgICAgICAgIH0KKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZHJhd0xheWVyc09uQ0NUaHJl YWQoQ0NMYXllclRyZWVIb3N0SW1wbCogaW1wbCkKKyAgICB7CisgICAgICAgIENvbXBvc2l0b3JG YWtlV2ViR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQgPSBzdGF0aWNfY2FzdDxDb21wb3NpdG9y RmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEKj4oR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlOjpleHRy YWN0V2ViR3JhcGhpY3NDb250ZXh0M0QoaW1wbC0+Y29udGV4dCgpKSk7CisKKyAgICAgICAgLy8g TnVtYmVyIG9mIHRleHR1cmVzIHVzZWQgZm9yIGRyYXcgc2hvdWxkIGFsd2F5cyBiZSBvbmUuCisg ICAgICAgIEVYUEVDVF9FUSgxLCBjb250ZXh0LT5udW1Vc2VkVGV4dHVyZXMoKSk7CisKKyAgICAg ICAgaWYgKGltcGwtPmZyYW1lTnVtYmVyKCkgPCAyKSB7CisgICAgICAgICAgICBjb250ZXh0LT5y ZXNldFVzZWRUZXh0dXJlcygpOworICAgICAgICAgICAgcG9zdFNldE5lZWRzQW5pbWF0ZUFuZENv bW1pdFRvTWFpblRocmVhZCgpOworICAgICAgICAgICAgcG9zdFNldE5lZWRzUmVkcmF3VG9NYWlu VGhyZWFkKCk7CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgZW5kVGVzdCgpOworICAgIH0K KworICAgIHZpcnR1YWwgdm9pZCBsYXlvdXQoKQorICAgIHsKKyAgICAgICAgbV91cGRhdGVDaGVj a0xheWVyLT5zZXROZWVkc0Rpc3BsYXkoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgYWZ0 ZXJUZXN0KCkKKyAgICB7CisgICAgfQorCitwcml2YXRlOgorICAgIE1vY2tMYXllckRlbGVnYXRl IG1fZGVsZWdhdGU7CisgICAgUmVmUHRyPENvbnRlbnRMYXllckNocm9taXVtV2l0aFVwZGF0ZVRy YWNraW5nPiBtX3VwZGF0ZUNoZWNrTGF5ZXI7CisgICAgaW50IG1fbnVtQ29tbWl0czsKK307CisK K1RFU1RfRihDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0LCBydW5NdWx0aVRocmVhZCkK K3sKKyAgICBydW5UZXN0KHRydWUpOworfQorCiB9IC8vIG5hbWVzcGFjZQo= 123378 2012-01-20 14:19:19 -0800 2012-01-20 15:22:10 -0800 Patch bug-72672-20120120171917.patch text/plain 22131 reveman U3VidmVyc2lvbiBSZXZpc2lvbjogMTA1NTQwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMGNkZWUyZWY0MjA1NDky Mjc5MDdhZDE2MzgyNDcyN2UzNmExOWMzYy4uOThlMWVlZjUxYTdhODZmNzQxMTIyYWI0YTgwNDI2 YzJkZTkyZjA5MSAxMDA3NTUKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDEyLTAxLTIwICBEYXZp ZCBSZXZlbWFuICA8cmV2ZW1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW0Nocm9taXVtXSBJ bmNyZW1lbnRhbCB0ZXh0dXJlIHVwZGF0ZXMgYXJlIG5vdCBhdG9taWMuCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MjY3MgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFVzZSBhIG5ldyBzZXQgb2YgdGV4dHVy ZXMgZm9yIGVhY2ggY29tbWl0IHdoZW4gaW5jcmVtZW50YWwKKyAgICAgICAgdGV4dHVyZSB1cGRh dGVzIGFyZSBlbmFibGVkLgorCisgICAgICAgIFRoaXMgcGF0Y2ggaXMgdGVzdGVkIGJ5IHRoZSBm b2xsb3dpbmcgdW5pdCB0ZXN0OgorICAgICAgICAtIENDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWND b21taXQucnVuTXVsdGlUaHJlYWQKKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL01hbmFnZWRUZXh0dXJlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1hbmFnZWRUZXh0dXJl OjpNYW5hZ2VkVGV4dHVyZSk6CisgICAgICAgIChXZWJDb3JlOjpNYW5hZ2VkVGV4dHVyZTo6c3Rl YWwpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRUZXh0dXJl Lmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9t aXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRv VXBkYXRlVGlsZXMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND TGF5ZXJUcmVlSG9zdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6Omlu aXRpYWxpemUpOgorICAgICAgICAoV2ViQ29yZTo6Q0NMYXllclRyZWVIb3N0Ojpjb21taXRDb21w bGV0ZSk6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6OmRlbGV0ZVRleHR1cmVB ZnRlckNvbW1pdCk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NM YXllclRyZWVIb3N0Lmg6CisgICAgICAgIChXZWJDb3JlOjpDQ1NldHRpbmdzOjpDQ1NldHRpbmdz KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1Byb3h5Lmg6Cisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NTaW5nbGVUaHJlYWRQcm94 eS5oOgorICAgICAgICAoV2ViQ29yZTo6Q0NTaW5nbGVUaHJlYWRQcm94eTo6cGFydGlhbFRleHR1 cmVVcGRhdGVDYXBhYmlsaXR5KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9jYy9DQ1RocmVhZFByb3h5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNDVGhyZWFkUHJveHk6 OnNjaGVkdWxlZEFjdGlvblVwZGF0ZU1vcmVSZXNvdXJjZXMpOgorICAgICAgICAoV2ViQ29yZTo6 Q0NUaHJlYWRQcm94eTo6cGFydGlhbFRleHR1cmVVcGRhdGVDYXBhYmlsaXR5KToKKyAgICAgICAg KiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5Lmg6CisKIDIwMTIt MDEtMjAgIE1hcmMtQW5kcmUgRGVjb3N0ZSAgPG1hZEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg QWRkIHByb3BlciBvZmZzZXQgdG8gcG9zaXRpb24gcmlnaHQgY2xpY2sgdG8gc2ltdWxhdGUgYSBj b250ZXh0IG1lbnUgaW52b2NhdGlvbi4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggMDZl NzA5NDE2M2M2ZmNjNTE1ZGYzNmM3ZmFhNDgyNmQ4ZmE0ZWI2OS4uMjFiYjM2NzlkMTdiODg3ODdh YTZmZWRhMWNiMWU3ZTE3NmRhNjEzZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEs MyArMSw0MiBAQAorMjAxMi0wMS0yMCAgRGF2aWQgUmV2ZW1hbiAgPHJldmVtYW5AY2hyb21pdW0u b3JnPgorCisgICAgICAgIFtDaHJvbWl1bV0gSW5jcmVtZW50YWwgdGV4dHVyZSB1cGRhdGVzIGFy ZSBub3QgYXRvbWljLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9NzI2NzIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBBZGQgQ0NMYXllclRyZWVIb3N0VGVzdEF0b21pY0NvbW1pdCB0ZXN0IHRoYXQgdmVyaWZp ZXMgYXRvbWljaXR5CisgICAgICAgIG9mIGNvbW1pdHMuCisKKyAgICAgICAgKiB0ZXN0cy9DQ0xh eWVyVHJlZUhvc3RUZXN0LmNwcDoKKyAgICAgICAgKFdURjo6Q29tcG9zaXRvckZha2VXZWJHcmFw aGljc0NvbnRleHQzRDo6Y3JlYXRlKToKKyAgICAgICAgKFdURjo6Q29tcG9zaXRvckZha2VXZWJH cmFwaGljc0NvbnRleHQzRDo6bWFrZUNvbnRleHRDdXJyZW50KToKKyAgICAgICAgKFdURjo6Q29t cG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRDo6Y3JlYXRlUHJvZ3JhbSk6CisgICAgICAg IChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6OmNyZWF0ZVNoYWRlcik6 CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6OmdldFNo YWRlcml2KToKKyAgICAgICAgKFdURjo6Q29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQz RDo6Z2V0UHJvZ3JhbWl2KToKKyAgICAgICAgKFdURjo6Q29tcG9zaXRvckZha2VXZWJHcmFwaGlj c0NvbnRleHQzRDo6Y3JlYXRlVGV4dHVyZSk6CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtl V2ViR3JhcGhpY3NDb250ZXh0M0Q6OmRlbGV0ZVRleHR1cmUpOgorICAgICAgICAoV1RGOjpDb21w b3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEOjpiaW5kVGV4dHVyZSk6CisgICAgICAgIChX VEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6Om51bVRleHR1cmVzKToKKyAg ICAgICAgKFdURjo6Q29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRDo6dGV4dHVyZSk6 CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6OnJlc2V0 VGV4dHVyZXMpOgorICAgICAgICAoV1RGOjpDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4 dDNEOjpudW1Vc2VkVGV4dHVyZXMpOgorICAgICAgICAoV1RGOjpDb21wb3NpdG9yRmFrZVdlYkdy YXBoaWNzQ29udGV4dDNEOjp1c2VkVGV4dHVyZSk6CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JG YWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6OnJlc2V0VXNlZFRleHR1cmVzKToKKyAgICAgICAgKFdU Rjo6Q29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRDo6Q29tcG9zaXRvckZha2VXZWJH cmFwaGljc0NvbnRleHQzRCk6CisgICAgICAgIChXVEY6Ok1vY2tMYXllclRyZWVIb3N0Q2xpZW50 OjpjcmVhdGVMYXllclRyZWVIb3N0Q29udGV4dDNEKToKKyAgICAgICAgKFdURjo6TW9ja0NvbnRl bnRMYXllckRlbGVnYXRlOjpkcmF3c0NvbnRlbnQpOgorICAgICAgICAoV1RGOjpNb2NrQ29udGVu dExheWVyRGVsZWdhdGU6OnBhaW50Q29udGVudHMpOgorICAgICAgICAoV1RGOjpNb2NrQ29udGVu dExheWVyRGVsZWdhdGU6Om5vdGlmeVN5bmNSZXF1aXJlZCk6CisgICAgICAgIChXVEY6OkNDTGF5 ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQ6OkNDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21t aXQpOgorICAgICAgICAoV1RGOjpDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0OjpiZWdp blRlc3QpOgorICAgICAgICAoV1RGOjpDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0Ojpj b21taXRDb21wbGV0ZU9uQ0NUaHJlYWQpOgorICAgICAgICAoV1RGOjpDQ0xheWVyVHJlZUhvc3RU ZXN0QXRvbWljQ29tbWl0OjpkcmF3TGF5ZXJzT25DQ1RocmVhZCk6CisgICAgICAgIChXVEY6OkND TGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQ6OmxheW91dCk6CisgICAgICAgIChXVEY6OkND TGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQ6OmFmdGVyVGVzdCk6CisgICAgICAgIChXVEY6 OlRFU1RfRik6CisKIDIwMTItMDEtMjAgIFNhZHJ1bCBIYWJpYiBDaG93ZGh1cnkgIDxzYWRydWxA Y2hyb21pdW0ub3JnPgogCiAgICAgICAgIFtjaHJvbWl1bV0gUmV2ZXJ0IGEgY291cGxlIG9mIGNo YW5nZXMgaW4gZmlsZWFwaS8gdGhhdCBicmVhayB0ZXN0cyBpbiBjaHJvbWVvcy4KZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRUZXh0 dXJlLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFn ZWRUZXh0dXJlLmNwcAppbmRleCAwYzFlNGI3MGQyNzE0YTM4NmY5N2VhYTM0OGQ3ZTNlOGM2NmVj ZTExLi41YmIxOWZhODdkZWFkMjdjZTdlMWM3OTNhOGZjMzU4MmMwZDNmYmQxIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVy ZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFu YWdlZFRleHR1cmUuY3BwCkBAIC00MSw2ICs0MSwxNSBAQCBNYW5hZ2VkVGV4dHVyZTo6TWFuYWdl ZFRleHR1cmUoVGV4dHVyZU1hbmFnZXIqIG1hbmFnZXIpCiB7CiB9CiAKK01hbmFnZWRUZXh0dXJl OjpNYW5hZ2VkVGV4dHVyZShUZXh0dXJlTWFuYWdlciogbWFuYWdlciwgVGV4dHVyZVRva2VuIHRv a2VuLCBJbnRTaXplIHNpemUsIHVuc2lnbmVkIGZvcm1hdCwgdW5zaWduZWQgdGV4dHVyZUlkKQor ICAgIDogbV90ZXh0dXJlTWFuYWdlcihtYW5hZ2VyKQorICAgICwgbV90b2tlbih0b2tlbikKKyAg ICAsIG1fc2l6ZShzaXplKQorICAgICwgbV9mb3JtYXQoZm9ybWF0KQorICAgICwgbV90ZXh0dXJl SWQodGV4dHVyZUlkKQoreworfQorCiBNYW5hZ2VkVGV4dHVyZTo6fk1hbmFnZWRUZXh0dXJlKCkK IHsKICAgICBpZiAobV90b2tlbikKQEAgLTk5LDYgKzEwOCwxNyBAQCB2b2lkIE1hbmFnZWRUZXh0 dXJlOjpmcmFtZWJ1ZmZlclRleHR1cmUyRChHcmFwaGljc0NvbnRleHQzRCogY29udGV4dCwgVGV4 dHVyZUFsbAogICAgIGNvbnRleHQtPmZyYW1lYnVmZmVyVGV4dHVyZTJEKEdyYXBoaWNzQ29udGV4 dDNEOjpGUkFNRUJVRkZFUiwgR3JhcGhpY3NDb250ZXh0M0Q6OkNPTE9SX0FUVEFDSE1FTlQwLCBH cmFwaGljc0NvbnRleHQzRDo6VEVYVFVSRV8yRCwgbV90ZXh0dXJlSWQsIDApOwogfQogCitQYXNz T3duUHRyPE1hbmFnZWRUZXh0dXJlPiBNYW5hZ2VkVGV4dHVyZTo6c3RlYWwoKQoreworICAgIE93 blB0cjxNYW5hZ2VkVGV4dHVyZT4gdGV4dHVyZSA9IGFkb3B0UHRyKG5ldyBNYW5hZ2VkVGV4dHVy ZShtX3RleHR1cmVNYW5hZ2VyLCBtX3Rva2VuLCBtX3NpemUsIG1fZm9ybWF0LCBtX3RleHR1cmVJ ZCkpOworICAgIG1fdG9rZW4gPSAwOworICAgIG1fc2l6ZSA9IEludFNpemUoKTsKKyAgICBtX2Zv cm1hdCA9IDA7CisgICAgbV90ZXh0dXJlSWQgPSAwOworICAgIHJldHVybiB0ZXh0dXJlLnJlbGVh c2UoKTsKK30KKworCiB9CiAKICNlbmRpZiAvLyBVU0UoQUNDRUxFUkFURURfQ09NUE9TSVRJTkcp CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9N YW5hZ2VkVGV4dHVyZS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vTWFuYWdlZFRleHR1cmUuaAppbmRleCAxY2M4YmZhOWFiMzFjYzkyMzFiNDdhODNjYzU2NTJh MjJhYWU4MWE4Li43NmQ2MmE4YmI4OWFkNmQ0MWY2MzBmYjY0YjZlNjhjOWI4M2ZiN2FlIDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5hZ2Vk VGV4dHVyZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L01hbmFnZWRUZXh0dXJlLmgKQEAgLTYzLDggKzYzLDEzIEBAIHB1YmxpYzoKICAgICB1bnNpZ25l ZCBmb3JtYXQoKSBjb25zdCB7IHJldHVybiBtX2Zvcm1hdDsgfQogICAgIHVuc2lnbmVkIHRleHR1 cmVJZCgpIGNvbnN0IHsgcmV0dXJuIG1fdGV4dHVyZUlkOyB9CiAKKyAgICAvLyBTdGVhbCB0b2tl biBhbmQgdGV4dHVyZUlkIGJ5IGluc3RhbnRpYXRlcyBhIG5ldyB0ZXh0dXJlIHVzaW5nIGV4aXN0 aW5nCisgICAgLy8gbWVtYmVyIHZhcmlhYmxlcy4KKyAgICBQYXNzT3duUHRyPE1hbmFnZWRUZXh0 dXJlPiBzdGVhbCgpOworCiBwcml2YXRlOgogICAgIGV4cGxpY2l0IE1hbmFnZWRUZXh0dXJlKFRl eHR1cmVNYW5hZ2VyKik7CisgICAgTWFuYWdlZFRleHR1cmUoVGV4dHVyZU1hbmFnZXIqLCBUZXh0 dXJlVG9rZW4sIEludFNpemUsIHVuc2lnbmVkIGZvcm1hdCwgdW5zaWduZWQgdGV4dHVyZUlkKTsK IAogICAgIFRleHR1cmVNYW5hZ2VyKiBtX3RleHR1cmVNYW5hZ2VyOwogICAgIFRleHR1cmVUb2tl biBtX3Rva2VuOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAKaW5kZXggMTQzMGE2MTY3 ODkzMjgzOWY0MGM1YjNkMWI5YmI3NGY3N2E5YTU1NS4uOTJkMTAyZTMyMmEyMTgzNTVlMTU2ODFl NTAwNWFkMzJhMmUyYjZlNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCkBAIC0z ODAsNiArMzgwLDExIEBAIHZvaWQgVGlsZWRMYXllckNocm9taXVtOjpwcmVwYXJlVG9VcGRhdGVU aWxlcyhib29sIGlkbGUsIGludCBsZWZ0LCBpbnQgdG9wLCBpbnQKICAgICAgICAgICAgIGlmICgh dGlsZSkKICAgICAgICAgICAgICAgICB0aWxlID0gY3JlYXRlVGlsZShpLCBqKTsKIAorICAgICAg ICAgICAgLy8gRG8gcG9zdCBjb21taXQgZGVsZXRpb24gb2YgY3VycmVudCB0ZXh0dXJlIHdoZW4g cGFydGlhbCB0ZXh0dXJlCisgICAgICAgICAgICAvLyB1cGRhdGVzIGFyZSBub3QgdXNlZC4KKyAg ICAgICAgICAgIGlmICh0aWxlLT5pc0RpcnR5KCkgJiYgbGF5ZXJUcmVlSG9zdCgpICYmICFsYXll clRyZWVIb3N0KCktPnNldHRpbmdzKCkucGFydGlhbFRleHR1cmVVcGRhdGVzKQorICAgICAgICAg ICAgICAgIGxheWVyVHJlZUhvc3QoKS0+ZGVsZXRlVGV4dHVyZUFmdGVyQ29tbWl0KHRpbGUtPm1h bmFnZWRUZXh0dXJlKCktPnN0ZWFsKCkpOworCiAgICAgICAgICAgICBpZiAoIXRpbGUtPm1hbmFn ZWRUZXh0dXJlKCktPmlzVmFsaWQobV90aWxlci0+dGlsZVNpemUoKSwgbV90ZXh0dXJlRm9ybWF0 KSkKICAgICAgICAgICAgICAgICB0aWxlLT5tX2RpcnR5UmVjdCA9IG1fdGlsZXItPnRpbGVSZWN0 KHRpbGUpOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcAppbmRleCA4NjYzZWMwYWMy Y2RmMzZiMjQ3MjI4MWNmZmFlYTE5NDAyMjVhMjNjLi5hMmZiODIyYzU2YmRiMzVmY2NkM2I5OWE0 ZDE0ZGVlYThkOTEzMjhiIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAKQEAgLTk1 LDYgKzk1LDkgQEAgYm9vbCBDQ0xheWVyVHJlZUhvc3Q6OmluaXRpYWxpemUoKQogICAgIC8vIFVw ZGF0ZSBtX3NldHRpbmdzIGJhc2VkIG9uIGNhcGFiaWxpdGllcyB0aGF0IHdlIGdvdCBiYWNrIGZy b20gdGhlIHJlbmRlcmVyLgogICAgIG1fc2V0dGluZ3MuYWNjZWxlcmF0ZVBhaW50aW5nID0gbV9w cm94eS0+bGF5ZXJSZW5kZXJlckNhcGFiaWxpdGllcygpLnVzaW5nQWNjZWxlcmF0ZWRQYWludGlu ZzsKIAorICAgIC8vIFVwZGF0ZSBtX3NldHRpbmdzIGJhc2VkIG9uIHBhcnRpYWwgdXBkYXRlIGNh cGFiaWxpdHkuCisgICAgbV9zZXR0aW5ncy5wYXJ0aWFsVGV4dHVyZVVwZGF0ZXMgPSBtX3NldHRp bmdzLnBhcnRpYWxUZXh0dXJlVXBkYXRlcyAmJiBtX3Byb3h5LT5wYXJ0aWFsVGV4dHVyZVVwZGF0 ZUNhcGFiaWxpdHkoKTsKKwogICAgIG1fY29udGVudHNUZXh0dXJlTWFuYWdlciA9IFRleHR1cmVN YW5hZ2VyOjpjcmVhdGUoVGV4dHVyZU1hbmFnZXI6OmhpZ2hMaW1pdEJ5dGVzKHZpZXdwb3J0U2l6 ZSgpKSwKICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIFRleHR1cmVNYW5hZ2VyOjpyZWNsYWltTGltaXRCeXRlcyh2aWV3cG9ydFNpemUoKSksCiAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBtX3By b3h5LT5sYXllclJlbmRlcmVyQ2FwYWJpbGl0aWVzKCkubWF4VGV4dHVyZVNpemUpOwpAQCAtMTY1 LDYgKzE2OCw3IEBAIHZvaWQgQ0NMYXllclRyZWVIb3N0OjpmaW5pc2hDb21taXRPbkltcGxUaHJl YWQoQ0NMYXllclRyZWVIb3N0SW1wbCogaG9zdEltcGwpCiAKIHZvaWQgQ0NMYXllclRyZWVIb3N0 Ojpjb21taXRDb21wbGV0ZSgpCiB7CisgICAgbV9kZWxldGVUZXh0dXJlQWZ0ZXJDb21taXRMaXN0 LmNsZWFyKCk7CiAgICAgY2xlYXJQZW5kaW5nVXBkYXRlKCk7CiAgICAgbV9jb250ZW50c1RleHR1 cmVNYW5hZ2VyLT51bnByb3RlY3RBbGxUZXh0dXJlcygpOwogfQpAQCAtNTE0LDQgKzUxOCw5IEBA IHZvaWQgQ0NMYXllclRyZWVIb3N0OjpzdG9wUmF0ZUxpbWl0ZXIoR3JhcGhpY3NDb250ZXh0M0Qq IGNvbnRleHQpCiAgICAgfQogfQogCit2b2lkIENDTGF5ZXJUcmVlSG9zdDo6ZGVsZXRlVGV4dHVy ZUFmdGVyQ29tbWl0KFBhc3NPd25QdHI8TWFuYWdlZFRleHR1cmU+IHRleHR1cmUpCit7CisgICAg bV9kZWxldGVUZXh0dXJlQWZ0ZXJDb21taXRMaXN0LmFwcGVuZCh0ZXh0dXJlKTsKK30KKwogfQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NMYXllclRyZWVIb3N0LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuaAppbmRleCAyZjk4OWJjZjZhMTkxYzEwZmM3NDFjOWFm MWRlN2NhOTFjMzA2MDVlLi5kOTJhZGMxNjZhZTY3ZTNhZjA1NDI5NTEwYzk3ZDNmZTM2ODM1MDlm IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9j Yy9DQ0xheWVyVHJlZUhvc3QuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuaApAQCAtNzYsNyArNzYsOCBAQCBzdHJ1Y3Qg Q0NTZXR0aW5ncyB7CiAgICAgICAgICAgICAsIHNob3dQbGF0Zm9ybUxheWVyVHJlZShmYWxzZSkK ICAgICAgICAgICAgICwgcmVmcmVzaFJhdGUoMCkKICAgICAgICAgICAgICwgcGVyVGlsZVBhaW50 aW5nKGZhbHNlKQotICAgICAgICAgICAgLCBwYXJ0aWFsU3dhcEVuYWJsZWQoZmFsc2UpIHsgfQor ICAgICAgICAgICAgLCBwYXJ0aWFsU3dhcEVuYWJsZWQoZmFsc2UpCisgICAgICAgICAgICAsIHBh cnRpYWxUZXh0dXJlVXBkYXRlcyh0cnVlKSB7IH0KIAogICAgIGJvb2wgYWNjZWxlcmF0ZVBhaW50 aW5nOwogICAgIGJvb2wgY29tcG9zaXRlT2Zmc2NyZWVuOwpAQCAtODUsNiArODYsNyBAQCBzdHJ1 Y3QgQ0NTZXR0aW5ncyB7CiAgICAgZG91YmxlIHJlZnJlc2hSYXRlOwogICAgIGJvb2wgcGVyVGls ZVBhaW50aW5nOwogICAgIGJvb2wgcGFydGlhbFN3YXBFbmFibGVkOworICAgIGJvb2wgcGFydGlh bFRleHR1cmVVcGRhdGVzOwogfTsKIAogLy8gUHJvdmlkZXMgaW5mb3JtYXRpb24gb24gYW4gSW1w bCdzIHJlbmRlcmluZyBjYXBhYmlsaXRpZXMgYmFjayB0byB0aGUgQ0NMYXllclRyZWVIb3N0CkBA IC0xOTIsMTIgKzE5NCwxNSBAQCBwdWJsaWM6CiAgICAgdm9pZCBzdGFydFJhdGVMaW1pdGVyKEdy YXBoaWNzQ29udGV4dDNEKik7CiAgICAgdm9pZCBzdG9wUmF0ZUxpbWl0ZXIoR3JhcGhpY3NDb250 ZXh0M0QqKTsKIAorICAgIHZvaWQgZGVsZXRlVGV4dHVyZUFmdGVyQ29tbWl0KFBhc3NPd25QdHI8 TWFuYWdlZFRleHR1cmU+KTsKKwogcHJvdGVjdGVkOgogICAgIENDTGF5ZXJUcmVlSG9zdChDQ0xh eWVyVHJlZUhvc3RDbGllbnQqLCBjb25zdCBDQ1NldHRpbmdzJik7CiAgICAgYm9vbCBpbml0aWFs aXplKCk7CiAKIHByaXZhdGU6CiAgICAgdHlwZWRlZiBWZWN0b3I8UmVmUHRyPExheWVyQ2hyb21p dW0+ID4gTGF5ZXJMaXN0OworICAgIHR5cGVkZWYgVmVjdG9yPE93blB0cjxNYW5hZ2VkVGV4dHVy ZT4gPiBUZXh0dXJlTGlzdDsKIAogICAgIGVudW0gUGFpbnRUeXBlIHsgUGFpbnRWaXNpYmxlLCBQ YWludElkbGUgfTsKICAgICBzdGF0aWMgdm9pZCBwYWludENvbnRlbnRzSWZEaXJ0eShMYXllckNo cm9taXVtKiwgUGFpbnRUeXBlKTsKQEAgLTIzMyw2ICsyMzgsOCBAQCBwcml2YXRlOgogICAgIGZs b2F0IG1fcGFnZVNjYWxlOwogICAgIGZsb2F0IG1fbWluUGFnZVNjYWxlLCBtX21heFBhZ2VTY2Fs ZTsKICAgICBib29sIG1fdHJpZ2dlcklkbGVQYWludHM7CisKKyAgICBUZXh0dXJlTGlzdCBtX2Rl bGV0ZVRleHR1cmVBZnRlckNvbW1pdExpc3Q7CiB9OwogCiB9CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1Byb3h5LmggYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1Byb3h5LmgKaW5kZXggYmIz NzgwMTQ3YjE2YzI2Yjc1YTdjY2QyMmFhOGI4ZmU4NGU3NmJiZC4uOTM3YzE1NGZmNjliYTg1M2Ji ZmM5MzQ1NmQ3NzY2NzEwYzcwYTIyNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDUHJveHkuaApAQCAtNzksNiArNzksMTAgQEAg cHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBzdGFydCgpID0gMDsgLy8gTXVzdCBiZSBjYWxsZWQg YmVmb3JlIHVzaW5nIHRoZSBwcm94eS4KICAgICB2aXJ0dWFsIHZvaWQgc3RvcCgpID0gMDsgLy8g TXVzdCBiZSBjYWxsZWQgYmVmb3JlIGRlbGV0aW5nIHRoZSBwcm94eS4KIAorICAgIC8vIFdoZXRo ZXIgc3ViLXJlZ2lvbnMgb2YgdGV4dHVyZXMgY2FuIGJlIHVwZGF0ZWQgb3IgaWYgY29tcGxldGUg dGV4dHVyZQorICAgIC8vIHVwZGF0ZXMgYXJlIHJlcXVpcmVkLgorICAgIHZpcnR1YWwgYm9vbCBw YXJ0aWFsVGV4dHVyZVVwZGF0ZUNhcGFiaWxpdHkoKSBjb25zdCA9IDA7CisKICAgICAvLyBEZWJ1 ZyBob29rcwogI2lmbmRlZiBOREVCVUcKICAgICBzdGF0aWMgYm9vbCBpc01haW5UaHJlYWQoKTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2Nj L0NDU2luZ2xlVGhyZWFkUHJveHkuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL2NjL0NDU2luZ2xlVGhyZWFkUHJveHkuaAppbmRleCAwZDVhNGEyZDhhNTE2YjFk N2JjZjk5MWE5OWUxYzc4Nzg5OTQzZWM1Li40ZmFhMjI5OTkxMmFlYzljNGU2YWI0YmE3MDI3ZDgx YzgwNmQ0NWVlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9jYy9DQ1NpbmdsZVRocmVhZFByb3h5LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NTaW5nbGVUaHJlYWRQcm94eS5oCkBAIC01NCw2 ICs1NCw3IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc2V0VmlzaWJsZShib29sKTsKICAg ICB2aXJ0dWFsIHZvaWQgc3RhcnQoKTsKICAgICB2aXJ0dWFsIHZvaWQgc3RvcCgpOworICAgIHZp cnR1YWwgYm9vbCBwYXJ0aWFsVGV4dHVyZVVwZGF0ZUNhcGFiaWxpdHkoKSBjb25zdCB7IHJldHVy biB0cnVlOyB9CiAKICAgICAvLyBDQ0xheWVyVHJlZUhvc3RJbXBsQ2xpZW50IGltcGxlbWVudGF0 aW9uCiAgICAgdmlydHVhbCB2b2lkIG9uU3dhcEJ1ZmZlcnNDb21wbGV0ZU9uSW1wbFRocmVhZCgp IHsgQVNTRVJUX05PVF9SRUFDSEVEKCk7IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuY3BwIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5jcHAKaW5k ZXggOTAzMzEzNTEzYTlkMDk4MjM0MTJlNWU3N2Q2OTk4NTQ1N2Y5M2E2MS4uMzJhODYzMGNlMzEw MjUwMTc3ODlkMjUwNDQ2YmY5ZmY2OTA0MGQwZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5jcHAKKysrIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5j cHAKQEAgLTM5LDggKzM5LDE1IEBACiAjaW5jbHVkZSA8d3RmL0N1cnJlbnRUaW1lLmg+CiAjaW5j bHVkZSA8d3RmL01haW5UaHJlYWQuaD4KIAordXNpbmcgbmFtZXNwYWNlIHN0ZDsKIHVzaW5nIG5h bWVzcGFjZSBXVEY7CiAKK25hbWVzcGFjZSB7CisKK3N0YXRpYyBjb25zdCBzaXplX3QgdGV4dHVy ZVVwZGF0ZXNQZXJGcmFtZSA9IG51bWVyaWNfbGltaXRzPHNpemVfdD46Om1heCgpOworCit9IC8v IGFub255bW91cyBuYW1lc3BhY2UKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBQYXNzT3duUHRy PENDUHJveHk+IENDVGhyZWFkUHJveHk6OmNyZWF0ZShDQ0xheWVyVHJlZUhvc3QqIGxheWVyVHJl ZUhvc3QpCkBAIC00MzgsOCArNDQ1LDcgQEAgdm9pZCBDQ1RocmVhZFByb3h5OjpzY2hlZHVsZWRB Y3Rpb25VcGRhdGVNb3JlUmVzb3VyY2VzKCkKIHsKICAgICBUUkFDRV9FVkVOVCgiQ0NUaHJlYWRQ cm94eTo6c2NoZWR1bGVkQWN0aW9uVXBkYXRlTW9yZVJlc291cmNlcyIsIHRoaXMsIDApOwogICAg IEFTU0VSVChtX2N1cnJlbnRUZXh0dXJlVXBkYXRlck9uSW1wbFRocmVhZCk7Ci0gICAgc3RhdGlj IGNvbnN0IGludCBVcGRhdGVzUGVyRnJhbWUgPSA5OTk5OTsKLSAgICBtX2N1cnJlbnRUZXh0dXJl VXBkYXRlck9uSW1wbFRocmVhZC0+dXBkYXRlKG1fbGF5ZXJUcmVlSG9zdEltcGwtPmNvbnRleHQo KSwgVXBkYXRlc1BlckZyYW1lKTsKKyAgICBtX2N1cnJlbnRUZXh0dXJlVXBkYXRlck9uSW1wbFRo cmVhZC0+dXBkYXRlKG1fbGF5ZXJUcmVlSG9zdEltcGwtPmNvbnRleHQoKSwgdGV4dHVyZVVwZGF0 ZXNQZXJGcmFtZSk7CiB9CiAKIHZvaWQgQ0NUaHJlYWRQcm94eTo6c2NoZWR1bGVkQWN0aW9uQ29t bWl0KCkKQEAgLTU2NSw0ICs1NzEsOSBAQCB2b2lkIENDVGhyZWFkUHJveHk6OmxheWVyVHJlZUhv c3RDbG9zZWRPbkltcGxUaHJlYWQoQ0NDb21wbGV0aW9uRXZlbnQqIGNvbXBsZXRpbwogICAgIGNv bXBsZXRpb24tPnNpZ25hbCgpOwogfQogCitib29sIENDVGhyZWFkUHJveHk6OnBhcnRpYWxUZXh0 dXJlVXBkYXRlQ2FwYWJpbGl0eSgpIGNvbnN0Cit7CisgICAgcmV0dXJuIHRleHR1cmVVcGRhdGVz UGVyRnJhbWUgPT0gbnVtZXJpY19saW1pdHM8c2l6ZV90Pjo6bWF4KCk7Cit9CisKIH0gLy8gbmFt ZXNwYWNlIFdlYkNvcmUKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuaAppbmRleCBhNDFjMGQ1NjRiNjM4 MTNiYTYzYTZjZWQ1OGUwNGQ2OWMzOGYyZGVhLi5hMTFiNTI3ODU5OTMxY2ZiOThmODcyNGE1MTI0 M2EwOWI0ZWNjM2I5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGlj cy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5oCkBAIC02Miw2ICs2Miw3IEBA IHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc2V0VmlzaWJsZShib29sKTsKICAgICB2aXJ0dWFs IHZvaWQgc3RhcnQoKTsKICAgICB2aXJ0dWFsIHZvaWQgc3RvcCgpOworICAgIHZpcnR1YWwgYm9v bCBwYXJ0aWFsVGV4dHVyZVVwZGF0ZUNhcGFiaWxpdHkoKSBjb25zdDsKIAogICAgIC8vIENDTGF5 ZXJUcmVlSG9zdEltcGxDbGllbnQgaW1wbGVtZW50YXRpb24KICAgICB2aXJ0dWFsIHZvaWQgb25T d2FwQnVmZmVyc0NvbXBsZXRlT25JbXBsVGhyZWFkKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3Rlc3RzL0NDTGF5ZXJUcmVlSG9zdFRlc3QuY3BwIGIvU291cmNlL1dlYktp dC9jaHJvbWl1bS90ZXN0cy9DQ0xheWVyVHJlZUhvc3RUZXN0LmNwcAppbmRleCA5NTE4NTk2NTA2 MjY5NDhkMGI2ZDVmNjZlOTNiMjdhOTA4Y2IxMDc5Li42NGU0NDg3Mjc1YjU4NjFkZTU3YmJiMDFm ZTc4MzFhNzEyMmJjYTY4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3Rz L0NDTGF5ZXJUcmVlSG9zdFRlc3QuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVz dHMvQ0NMYXllclRyZWVIb3N0VGVzdC5jcHAKQEAgLTI2LDkgKzI2LDkgQEAKIAogI2luY2x1ZGUg ImNjL0NDTGF5ZXJUcmVlSG9zdC5oIgogCi0jaW5jbHVkZSAiQ29tcG9zaXRvckZha2VHcmFwaGlj c0NvbnRleHQzRC5oIgogI2luY2x1ZGUgIkNvbnRlbnRMYXllckNocm9taXVtLmgiCiAjaW5jbHVk ZSAiRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNELmgiCisjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0 M0RQcml2YXRlLmgiCiAjaW5jbHVkZSAiTGF5ZXJDaHJvbWl1bS5oIgogI2luY2x1ZGUgIlRleHR1 cmVNYW5hZ2VyLmgiCiAjaW5jbHVkZSAiV2ViQ29tcG9zaXRvci5oIgpAQCAtNDAsMTIgKzQwLDE0 IEBACiAjaW5jbHVkZSAiY2MvQ0NUaHJlYWRUYXNrLmgiCiAjaW5jbHVkZSAicGxhdGZvcm0vV2Vi S2l0UGxhdGZvcm1TdXBwb3J0LmgiCiAjaW5jbHVkZSAicGxhdGZvcm0vV2ViVGhyZWFkLmgiCisj aW5jbHVkZSA8Z21vY2svZ21vY2suaD4KICNpbmNsdWRlIDxndGVzdC9ndGVzdC5oPgogI2luY2x1 ZGUgPHdlYmtpdC9zdXBwb3J0L3dlYmtpdF9zdXBwb3J0Lmg+CiAjaW5jbHVkZSA8d3RmL01haW5U aHJlYWQuaD4KICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0ci5oPgogI2luY2x1ZGUgPHd0Zi9WZWN0 b3IuaD4KIAordXNpbmcgbmFtZXNwYWNlIHN0ZDsKIHVzaW5nIG5hbWVzcGFjZSBXZWJDb3JlOwog dXNpbmcgbmFtZXNwYWNlIFdlYktpdDsKIHVzaW5nIG5hbWVzcGFjZSBXVEY7CkBAIC0xMzAsNiAr MTMyLDYwIEBAIHByaXZhdGU6CiAgICAgVGVzdEhvb2tzKiBtX3Rlc3RIb29rczsKIH07CiAKKy8v IFRlc3Qgc3R1YiBmb3IgV2ViR3JhcGhpY3NDb250ZXh0M0QuIFJldHVybnMgY2FubmVkIHZhbHVl cyBuZWVkZWQgZm9yIGNvbXBvc2l0b3IgaW5pdGlhbGl6YXRpb24uCitjbGFzcyBDb21wb3NpdG9y RmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEIDogcHVibGljIEZha2VXZWJHcmFwaGljc0NvbnRleHQz RCB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8Q29tcG9zaXRvckZha2VXZWJHcmFw aGljc0NvbnRleHQzRD4gY3JlYXRlKEF0dHJpYnV0ZXMgYXR0cnMpCisgICAgeworICAgICAgICBy ZXR1cm4gYWRvcHRQdHIobmV3IENvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QoYXR0 cnMpKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIGJvb2wgbWFrZUNvbnRleHRDdXJyZW50KCkgeyBy ZXR1cm4gdHJ1ZTsgfQorICAgIHZpcnR1YWwgV2ViR0xJZCBjcmVhdGVQcm9ncmFtKCkgeyByZXR1 cm4gMTsgfQorICAgIHZpcnR1YWwgV2ViR0xJZCBjcmVhdGVTaGFkZXIoV0dDM0RlbnVtKSB7IHJl dHVybiAxOyB9CisgICAgdmlydHVhbCB2b2lkIGdldFNoYWRlcml2KFdlYkdMSWQsIFdHQzNEZW51 bSwgV0dDM0RpbnQqIHZhbHVlKSB7ICp2YWx1ZSA9IDE7IH0KKyAgICB2aXJ0dWFsIHZvaWQgZ2V0 UHJvZ3JhbWl2KFdlYkdMSWQsIFdHQzNEZW51bSwgV0dDM0RpbnQqIHZhbHVlKSB7ICp2YWx1ZSA9 IDE7IH0KKworICAgIHZpcnR1YWwgV2ViR0xJZCBjcmVhdGVUZXh0dXJlKCkKKyAgICB7CisgICAg ICAgIFdlYkdMSWQgdGV4dHVyZSA9IG1fdGV4dHVyZXMuc2l6ZSgpICsgMTsKKyAgICAgICAgbV90 ZXh0dXJlcy5wdXNoX2JhY2sodGV4dHVyZSk7CisgICAgICAgIHJldHVybiB0ZXh0dXJlOworICAg IH0KKworICAgIHZpcnR1YWwgdm9pZCBkZWxldGVUZXh0dXJlKFdlYkdMSWQgdGV4dHVyZSkKKyAg ICB7CisgICAgICAgIGZvciAodmVjdG9yPFdlYkdMSWQ+OjppdGVyYXRvciBpdCA9IG1fdGV4dHVy ZXMuYmVnaW4oKTsgaXQgIT0gbV90ZXh0dXJlcy5lbmQoKTsgaXQrKykgeworICAgICAgICAgICAg aWYgKCppdCA9PSB0ZXh0dXJlKSB7CisgICAgICAgICAgICAgICAgbV90ZXh0dXJlcy5lcmFzZShp dCk7CisgICAgICAgICAgICAgICAgYnJlYWs7CisgICAgICAgICAgICB9CisgICAgICAgIH0KKyAg ICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgYmluZFRleHR1cmUoV0dDM0RlbnVtIC8qIHRhcmdldCAq LywgV2ViR0xJZCB0ZXh0dXJlKQorICAgIHsKKyAgICAgICAgbV91c2VkVGV4dHVyZXMuaW5zZXJ0 KHRleHR1cmUpOworICAgIH0KKworICAgIGludCBudW1UZXh0dXJlcygpIGNvbnN0IHsgcmV0dXJu IHN0YXRpY19jYXN0PGludD4obV90ZXh0dXJlcy5zaXplKCkpOyB9CisgICAgaW50IHRleHR1cmUo aW50IGkpIGNvbnN0IHsgcmV0dXJuIG1fdGV4dHVyZXNbaV07IH0KKyAgICB2b2lkIHJlc2V0VGV4 dHVyZXMoKSB7IG1fdGV4dHVyZXMuY2xlYXIoKTsgfQorCisgICAgaW50IG51bVVzZWRUZXh0dXJl cygpIGNvbnN0IHsgcmV0dXJuIHN0YXRpY19jYXN0PGludD4obV91c2VkVGV4dHVyZXMuc2l6ZSgp KTsgfQorICAgIGJvb2wgdXNlZFRleHR1cmUoaW50IHRleHR1cmUpIGNvbnN0IHsgcmV0dXJuIG1f dXNlZFRleHR1cmVzLmZpbmQodGV4dHVyZSkgIT0gbV91c2VkVGV4dHVyZXMuZW5kKCk7IH0KKyAg ICB2b2lkIHJlc2V0VXNlZFRleHR1cmVzKCkgeyBtX3VzZWRUZXh0dXJlcy5jbGVhcigpOyB9CisK K3ByaXZhdGU6CisgICAgZXhwbGljaXQgQ29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQz RChBdHRyaWJ1dGVzIGF0dHJzKQorICAgIHsKKyAgICAgICAgbV9hdHRycyA9IGF0dHJzOworICAg IH0KKworICAgIHZlY3RvcjxXZWJHTElkPiBtX3RleHR1cmVzOworICAgIHNldDxXZWJHTElkPiBt X3VzZWRUZXh0dXJlczsKK307CisKIC8vIEltcGxlbWVudGF0aW9uIG9mIENDTGF5ZXJUcmVlSG9z dCBjYWxsYmFjayBpbnRlcmZhY2UuCiBjbGFzcyBNb2NrTGF5ZXJUcmVlSG9zdENsaWVudCA6IHB1 YmxpYyBDQ0xheWVyVHJlZUhvc3RDbGllbnQgewogcHVibGljOgpAQCAtMTU1LDcgKzIxMSwxNSBA QCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8R3JhcGhpY3NDb250ZXh0M0Q+IGNy ZWF0ZUxheWVyVHJlZUhvc3RDb250ZXh0M0QoKQogICAgIHsKLSAgICAgICAgcmV0dXJuIGNyZWF0 ZUNvbXBvc2l0b3JNb2NrR3JhcGhpY3NDb250ZXh0M0QoR3JhcGhpY3NDb250ZXh0M0Q6OkF0dHJp YnV0ZXMoKSk7CisgICAgICAgIEdyYXBoaWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzIGF0dHJzOwor ICAgICAgICBXZWJHcmFwaGljc0NvbnRleHQzRDo6QXR0cmlidXRlcyB3ZWJBdHRyczsKKyAgICAg ICAgd2ViQXR0cnMuYWxwaGEgPSBhdHRycy5hbHBoYTsKKworICAgICAgICBPd25QdHI8V2ViR3Jh cGhpY3NDb250ZXh0M0Q+IHdlYkNvbnRleHQgPSBDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29u dGV4dDNEOjpjcmVhdGUod2ViQXR0cnMpOworICAgICAgICByZXR1cm4gR3JhcGhpY3NDb250ZXh0 M0RQcml2YXRlOjpjcmVhdGVHcmFwaGljc0NvbnRleHRGcm9tV2ViQ29udGV4dCgKKyAgICAgICAg ICAgIHdlYkNvbnRleHQucmVsZWFzZSgpLCBhdHRycywgMCwKKyAgICAgICAgICAgIEdyYXBoaWNz Q29udGV4dDNEOjpSZW5kZXJEaXJlY3RseVRvSG9zdFdpbmRvdywKKyAgICAgICAgICAgIEdyYXBo aWNzQ29udGV4dDNEUHJpdmF0ZTo6Rm9yVXNlT25Bbm90aGVyVGhyZWFkKTsKICAgICB9CiAKICAg ICB2aXJ0dWFsIHZvaWQgZGlkQ29tbWl0QW5kRHJhd0ZyYW1lKCkKQEAgLTEwNjgsNCArMTEzMiwx MDEgQEAgVEVTVF9GKENDTGF5ZXJUcmVlSG9zdFRlc3RTZXRWaWV3cG9ydFNpemUsIHJ1blNpbmds ZVRocmVhZCkKICAgICBydW5UZXN0KGZhbHNlKTsKIH0KIAorY2xhc3MgTW9ja0NvbnRlbnRMYXll ckRlbGVnYXRlIDogcHVibGljIENvbnRlbnRMYXllckRlbGVnYXRlIHsKK3B1YmxpYzoKKyAgICBi b29sIGRyYXdzQ29udGVudCgpIGNvbnN0IHsgcmV0dXJuIHRydWU7IH0KKyAgICBNT0NLX0NPTlNU X01FVEhPRDAocHJlc2VydmVzM0QsIGJvb2woKSk7CisgICAgdm9pZCBwYWludENvbnRlbnRzKEdy YXBoaWNzQ29udGV4dCYsIGNvbnN0IEludFJlY3QmKSB7IH0KKyAgICB2b2lkIG5vdGlmeVN5bmNS ZXF1aXJlZCgpIHsgfQorfTsKKworLy8gVmVyaWZ5IGF0b21pY2l0eSBvZiBjb21taXRzIGFuZCBy ZXVzZSBvZiB0ZXh0dXJlcy4KK2NsYXNzIENDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQg OiBwdWJsaWMgQ0NMYXllclRyZWVIb3N0VGVzdCB7CitwdWJsaWM6CisgICAgQ0NMYXllclRyZWVI b3N0VGVzdEF0b21pY0NvbW1pdCgpCisgICAgICAgIDogbV91cGRhdGVDaGVja0xheWVyKENvbnRl bnRMYXllckNocm9taXVtV2l0aFVwZGF0ZVRyYWNraW5nOjpjcmVhdGUoJm1fZGVsZWdhdGUpKQor ICAgICAgICAsIG1fbnVtQ29tbWl0cygwKQorICAgIHsKKyAgICAgICAgLy8gTWFrZSBzdXJlIHBh cnRpYWwgdGV4dHVyZSB1cGRhdGVzIGFyZSB0dXJuZWQgb2ZmLgorICAgICAgICBtX3NldHRpbmdz LnBhcnRpYWxUZXh0dXJlVXBkYXRlcyA9IGZhbHNlOworICAgIH0KKworICAgIHZpcnR1YWwgdm9p ZCBiZWdpblRlc3QoKQorICAgIHsKKyAgICAgICAgbV9sYXllclRyZWVIb3N0LT5zZXRSb290TGF5 ZXIobV91cGRhdGVDaGVja0xheWVyKTsKKyAgICAgICAgbV9sYXllclRyZWVIb3N0LT5zZXRWaWV3 cG9ydFNpemUoSW50U2l6ZSgxMCwgMTApKTsKKworICAgICAgICBwb3N0U2V0TmVlZHNDb21taXRU b01haW5UaHJlYWQoKTsKKyAgICAgICAgcG9zdFNldE5lZWRzUmVkcmF3VG9NYWluVGhyZWFkKCk7 CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGNvbW1pdENvbXBsZXRlT25DQ1RocmVhZChDQ0xh eWVyVHJlZUhvc3RJbXBsKiBpbXBsKQorICAgIHsKKyAgICAgICAgQ29tcG9zaXRvckZha2VXZWJH cmFwaGljc0NvbnRleHQzRCogY29udGV4dCA9IHN0YXRpY19jYXN0PENvbXBvc2l0b3JGYWtlV2Vi R3JhcGhpY3NDb250ZXh0M0QqPihHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6OmV4dHJhY3RXZWJH cmFwaGljc0NvbnRleHQzRChpbXBsLT5jb250ZXh0KCkpKTsKKworICAgICAgICBzd2l0Y2ggKGlt cGwtPmZyYW1lTnVtYmVyKCkpIHsKKyAgICAgICAgY2FzZSAwOgorICAgICAgICAgICAgLy8gTnVt YmVyIG9mIHRleHR1cmVzIHNob3VsZCBiZSBvbmUuCisgICAgICAgICAgICBFWFBFQ1RfRVEoMSwg Y29udGV4dC0+bnVtVGV4dHVyZXMoKSk7CisgICAgICAgICAgICAvLyBOdW1iZXIgb2YgdGV4dHVy ZXMgdXNlZCBmb3IgY29tbWl0IHNob3VsZCBiZSBvbmUuCisgICAgICAgICAgICBFWFBFQ1RfRVEo MSwgY29udGV4dC0+bnVtVXNlZFRleHR1cmVzKCkpOworICAgICAgICAgICAgLy8gVmVyaWZ5IHVz ZWQgdGV4dHVyZSBpcyBjb3JyZWN0LgorICAgICAgICAgICAgRVhQRUNUX1RSVUUoY29udGV4dC0+ dXNlZFRleHR1cmUoY29udGV4dC0+dGV4dHVyZSgwKSkpOworCisgICAgICAgICAgICBjb250ZXh0 LT5yZXNldFVzZWRUZXh0dXJlcygpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2Ug MToKKyAgICAgICAgICAgIC8vIE51bWJlciBvZiB0ZXh0dXJlcyBzaG91bGQgYmUgdHdvIGFzIHRo ZSBmaXJzdCB0ZXh0dXJlCisgICAgICAgICAgICAvLyBpcyB1c2VkIGJ5IGltcGwgdGhyZWFkIGFu ZCBjYW5ub3QgYnkgdXNlZCBmb3IgdXBkYXRlLgorICAgICAgICAgICAgRVhQRUNUX0VRKDIsIGNv bnRleHQtPm51bVRleHR1cmVzKCkpOworICAgICAgICAgICAgLy8gTnVtYmVyIG9mIHRleHR1cmVz IHVzZWQgZm9yIGNvbW1pdCBzaG91bGQgc3RpbGwgYmUgb25lLgorICAgICAgICAgICAgRVhQRUNU X0VRKDEsIGNvbnRleHQtPm51bVVzZWRUZXh0dXJlcygpKTsKKyAgICAgICAgICAgIC8vIEZpcnN0 IHRleHR1cmUgc2hvdWxkIG5vdCBoYXZlIGJlZW4gdXNlZC4KKyAgICAgICAgICAgIEVYUEVDVF9G QUxTRShjb250ZXh0LT51c2VkVGV4dHVyZShjb250ZXh0LT50ZXh0dXJlKDApKSk7CisgICAgICAg ICAgICAvLyBOZXcgdGV4dHVyZSBzaG91bGQgaGF2ZSBiZWVuIHVzZWQuCisgICAgICAgICAgICBF WFBFQ1RfVFJVRShjb250ZXh0LT51c2VkVGV4dHVyZShjb250ZXh0LT50ZXh0dXJlKDEpKSk7CisK KyAgICAgICAgICAgIGNvbnRleHQtPnJlc2V0VXNlZFRleHR1cmVzKCk7CisgICAgICAgICAgICBi cmVhazsKKyAgICAgICAgZGVmYXVsdDoKKyAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgp OworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9CisKKyAgICB2aXJ0dWFsIHZv aWQgZHJhd0xheWVyc09uQ0NUaHJlYWQoQ0NMYXllclRyZWVIb3N0SW1wbCogaW1wbCkKKyAgICB7 CisgICAgICAgIENvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQgPSBz dGF0aWNfY2FzdDxDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEKj4oR3JhcGhpY3ND b250ZXh0M0RQcml2YXRlOjpleHRyYWN0V2ViR3JhcGhpY3NDb250ZXh0M0QoaW1wbC0+Y29udGV4 dCgpKSk7CisKKyAgICAgICAgLy8gTnVtYmVyIG9mIHRleHR1cmVzIHVzZWQgZm9yIGRyYXcgc2hv dWxkIGFsd2F5cyBiZSBvbmUuCisgICAgICAgIEVYUEVDVF9FUSgxLCBjb250ZXh0LT5udW1Vc2Vk VGV4dHVyZXMoKSk7CisKKyAgICAgICAgaWYgKGltcGwtPmZyYW1lTnVtYmVyKCkgPCAyKSB7Cisg ICAgICAgICAgICBjb250ZXh0LT5yZXNldFVzZWRUZXh0dXJlcygpOworICAgICAgICAgICAgcG9z dFNldE5lZWRzQW5pbWF0ZUFuZENvbW1pdFRvTWFpblRocmVhZCgpOworICAgICAgICAgICAgcG9z dFNldE5lZWRzUmVkcmF3VG9NYWluVGhyZWFkKCk7CisgICAgICAgIH0gZWxzZQorICAgICAgICAg ICAgZW5kVGVzdCgpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBsYXlvdXQoKQorICAgIHsK KyAgICAgICAgbV91cGRhdGVDaGVja0xheWVyLT5zZXROZWVkc0Rpc3BsYXkoKTsKKyAgICB9CisK KyAgICB2aXJ0dWFsIHZvaWQgYWZ0ZXJUZXN0KCkKKyAgICB7CisgICAgfQorCitwcml2YXRlOgor ICAgIE1vY2tDb250ZW50TGF5ZXJEZWxlZ2F0ZSBtX2RlbGVnYXRlOworICAgIFJlZlB0cjxDb250 ZW50TGF5ZXJDaHJvbWl1bVdpdGhVcGRhdGVUcmFja2luZz4gbV91cGRhdGVDaGVja0xheWVyOwor ICAgIGludCBtX251bUNvbW1pdHM7Cit9OworCitURVNUX0YoQ0NMYXllclRyZWVIb3N0VGVzdEF0 b21pY0NvbW1pdCwgcnVuTXVsdGlUaHJlYWQpCit7CisgICAgcnVuVGVzdCh0cnVlKTsKK30KKwog fSAvLyBuYW1lc3BhY2UK 123393 2012-01-20 15:22:17 -0800 2012-01-21 18:00:22 -0800 Patch bug-72672-20120120182216.patch text/plain 22411 reveman U3VidmVyc2lvbiBSZXZpc2lvbjogMTA1NTQwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMGNkZWUyZWY0MjA1NDky Mjc5MDdhZDE2MzgyNDcyN2UzNmExOWMzYy4uOThlMWVlZjUxYTdhODZmNzQxMTIyYWI0YTgwNDI2 YzJkZTkyZjA5MSAxMDA3NTUKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDEyLTAxLTIwICBEYXZp ZCBSZXZlbWFuICA8cmV2ZW1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW0Nocm9taXVtXSBJ bmNyZW1lbnRhbCB0ZXh0dXJlIHVwZGF0ZXMgYXJlIG5vdCBhdG9taWMuCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MjY3MgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFVzZSBhIG5ldyBzZXQgb2YgdGV4dHVy ZXMgZm9yIGVhY2ggY29tbWl0IHdoZW4gaW5jcmVtZW50YWwKKyAgICAgICAgdGV4dHVyZSB1cGRh dGVzIGFyZSBlbmFibGVkLgorCisgICAgICAgIFRoaXMgcGF0Y2ggaXMgdGVzdGVkIGJ5IHRoZSBm b2xsb3dpbmcgdW5pdCB0ZXN0OgorICAgICAgICAtIENDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWND b21taXQucnVuTXVsdGlUaHJlYWQKKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL01hbmFnZWRUZXh0dXJlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1hbmFnZWRUZXh0dXJl OjpNYW5hZ2VkVGV4dHVyZSk6CisgICAgICAgIChXZWJDb3JlOjpNYW5hZ2VkVGV4dHVyZTo6c3Rl YWwpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRUZXh0dXJl Lmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9t aXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRv VXBkYXRlVGlsZXMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND TGF5ZXJUcmVlSG9zdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6Omlu aXRpYWxpemUpOgorICAgICAgICAoV2ViQ29yZTo6Q0NMYXllclRyZWVIb3N0Ojpjb21taXRDb21w bGV0ZSk6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6OmRlbGV0ZVRleHR1cmVB ZnRlckNvbW1pdCk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NM YXllclRyZWVIb3N0Lmg6CisgICAgICAgIChXZWJDb3JlOjpDQ1NldHRpbmdzOjpDQ1NldHRpbmdz KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1Byb3h5Lmg6Cisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NTaW5nbGVUaHJlYWRQcm94 eS5oOgorICAgICAgICAoV2ViQ29yZTo6Q0NTaW5nbGVUaHJlYWRQcm94eTo6cGFydGlhbFRleHR1 cmVVcGRhdGVDYXBhYmlsaXR5KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9jYy9DQ1RocmVhZFByb3h5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNDVGhyZWFkUHJveHk6 OnNjaGVkdWxlZEFjdGlvblVwZGF0ZU1vcmVSZXNvdXJjZXMpOgorICAgICAgICAoV2ViQ29yZTo6 Q0NUaHJlYWRQcm94eTo6cGFydGlhbFRleHR1cmVVcGRhdGVDYXBhYmlsaXR5KToKKyAgICAgICAg KiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5Lmg6CisKIDIwMTIt MDEtMjAgIE1hcmMtQW5kcmUgRGVjb3N0ZSAgPG1hZEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAg QWRkIHByb3BlciBvZmZzZXQgdG8gcG9zaXRpb24gcmlnaHQgY2xpY2sgdG8gc2ltdWxhdGUgYSBj b250ZXh0IG1lbnUgaW52b2NhdGlvbi4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggMDZl NzA5NDE2M2M2ZmNjNTE1ZGYzNmM3ZmFhNDgyNmQ4ZmE0ZWI2OS4uNDdjYmMzNzg0ZTlhMzM4NjM4 ODNlYWY4NTU1MGY5MGIzNmM4MTNhZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwzOCBAQAorMjAxMi0wMS0yMCAgRGF2aWQgUmV2ZW1hbiAgPHJldmVtYW5AY2hyb21pdW0u b3JnPgorCisgICAgICAgIFtDaHJvbWl1bV0gSW5jcmVtZW50YWwgdGV4dHVyZSB1cGRhdGVzIGFy ZSBub3QgYXRvbWljLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9NzI2NzIKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAg ICAgICBBZGQgQ0NMYXllclRyZWVIb3N0VGVzdEF0b21pY0NvbW1pdCB0ZXN0IHRoYXQgdmVyaWZp ZXMgYXRvbWljaXR5CisgICAgICAgIG9mIGNvbW1pdHMuCisKKyAgICAgICAgKiB0ZXN0cy9DQ0xh eWVyVHJlZUhvc3RUZXN0LmNwcDoKKyAgICAgICAgKFdURjo6Q29tcG9zaXRvckZha2VXZWJHcmFw aGljc0NvbnRleHQzRFdpdGhUZXh0dXJlVHJhY2tpbmc6OmNyZWF0ZSk6CisgICAgICAgIChXVEY6 OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0RXaXRoVGV4dHVyZVRyYWNraW5nOjpj cmVhdGVUZXh0dXJlKToKKyAgICAgICAgKFdURjo6Q29tcG9zaXRvckZha2VXZWJHcmFwaGljc0Nv bnRleHQzRFdpdGhUZXh0dXJlVHJhY2tpbmc6OmRlbGV0ZVRleHR1cmUpOgorICAgICAgICAoV1RG OjpDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEV2l0aFRleHR1cmVUcmFja2luZzo6 YmluZFRleHR1cmUpOgorICAgICAgICAoV1RGOjpDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29u dGV4dDNEV2l0aFRleHR1cmVUcmFja2luZzo6bnVtVGV4dHVyZXMpOgorICAgICAgICAoV1RGOjpD b21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEV2l0aFRleHR1cmVUcmFja2luZzo6dGV4 dHVyZSk6CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0RX aXRoVGV4dHVyZVRyYWNraW5nOjpyZXNldFRleHR1cmVzKToKKyAgICAgICAgKFdURjo6Q29tcG9z aXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRFdpdGhUZXh0dXJlVHJhY2tpbmc6Om51bVVzZWRU ZXh0dXJlcyk6CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0 M0RXaXRoVGV4dHVyZVRyYWNraW5nOjp1c2VkVGV4dHVyZSk6CisgICAgICAgIChXVEY6OkNvbXBv c2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0RXaXRoVGV4dHVyZVRyYWNraW5nOjpyZXNldFVz ZWRUZXh0dXJlcyk6CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250 ZXh0M0RXaXRoVGV4dHVyZVRyYWNraW5nOjpDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4 dDNEV2l0aFRleHR1cmVUcmFja2luZyk6CisgICAgICAgIChXVEY6Ok1vY2tMYXllclRyZWVIb3N0 Q2xpZW50OjpjcmVhdGVMYXllclRyZWVIb3N0Q29udGV4dDNEKToKKyAgICAgICAgKFdURjo6TW9j a0NvbnRlbnRMYXllckRlbGVnYXRlOjpkcmF3c0NvbnRlbnQpOgorICAgICAgICAoV1RGOjpNb2Nr Q29udGVudExheWVyRGVsZWdhdGU6OnBhaW50Q29udGVudHMpOgorICAgICAgICAoV1RGOjpNb2Nr Q29udGVudExheWVyRGVsZWdhdGU6Om5vdGlmeVN5bmNSZXF1aXJlZCk6CisgICAgICAgIChXVEY6 OkNDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQ6OkNDTGF5ZXJUcmVlSG9zdFRlc3RBdG9t aWNDb21taXQpOgorICAgICAgICAoV1RGOjpDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0 OjpiZWdpblRlc3QpOgorICAgICAgICAoV1RGOjpDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29t bWl0Ojpjb21taXRDb21wbGV0ZU9uQ0NUaHJlYWQpOgorICAgICAgICAoV1RGOjpDQ0xheWVyVHJl ZUhvc3RUZXN0QXRvbWljQ29tbWl0OjpkcmF3TGF5ZXJzT25DQ1RocmVhZCk6CisgICAgICAgIChX VEY6OkNDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQ6OmxheW91dCk6CisgICAgICAgIChX VEY6OkNDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQ6OmFmdGVyVGVzdCk6CisgICAgICAg IChXVEY6OlRFU1RfRik6CisgICAgICAgICogdGVzdHMvQ29tcG9zaXRvckZha2VXZWJHcmFwaGlj c0NvbnRleHQzRC5oOgorCiAyMDEyLTAxLTIwICBTYWRydWwgSGFiaWIgQ2hvd2RodXJ5ICA8c2Fk cnVsQGNocm9taXVtLm9yZz4KIAogICAgICAgICBbY2hyb21pdW1dIFJldmVydCBhIGNvdXBsZSBv ZiBjaGFuZ2VzIGluIGZpbGVhcGkvIHRoYXQgYnJlYWsgdGVzdHMgaW4gY2hyb21lb3MuCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5hZ2Vk VGV4dHVyZS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9N YW5hZ2VkVGV4dHVyZS5jcHAKaW5kZXggMGMxZTRiNzBkMjcxNGEzODZmOTdlYWEzNDhkN2UzZThj NjZlY2UxMS4uNWJiMTlmYTg3ZGVhZDI3Y2U3ZTFjNzkzYThmYzM1ODJjMGQzZmJkMSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFuYWdlZFRl eHR1cmUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L01hbmFnZWRUZXh0dXJlLmNwcApAQCAtNDEsNiArNDEsMTUgQEAgTWFuYWdlZFRleHR1cmU6Ok1h bmFnZWRUZXh0dXJlKFRleHR1cmVNYW5hZ2VyKiBtYW5hZ2VyKQogewogfQogCitNYW5hZ2VkVGV4 dHVyZTo6TWFuYWdlZFRleHR1cmUoVGV4dHVyZU1hbmFnZXIqIG1hbmFnZXIsIFRleHR1cmVUb2tl biB0b2tlbiwgSW50U2l6ZSBzaXplLCB1bnNpZ25lZCBmb3JtYXQsIHVuc2lnbmVkIHRleHR1cmVJ ZCkKKyAgICA6IG1fdGV4dHVyZU1hbmFnZXIobWFuYWdlcikKKyAgICAsIG1fdG9rZW4odG9rZW4p CisgICAgLCBtX3NpemUoc2l6ZSkKKyAgICAsIG1fZm9ybWF0KGZvcm1hdCkKKyAgICAsIG1fdGV4 dHVyZUlkKHRleHR1cmVJZCkKK3sKK30KKwogTWFuYWdlZFRleHR1cmU6On5NYW5hZ2VkVGV4dHVy ZSgpCiB7CiAgICAgaWYgKG1fdG9rZW4pCkBAIC05OSw2ICsxMDgsMTcgQEAgdm9pZCBNYW5hZ2Vk VGV4dHVyZTo6ZnJhbWVidWZmZXJUZXh0dXJlMkQoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQs IFRleHR1cmVBbGwKICAgICBjb250ZXh0LT5mcmFtZWJ1ZmZlclRleHR1cmUyRChHcmFwaGljc0Nv bnRleHQzRDo6RlJBTUVCVUZGRVIsIEdyYXBoaWNzQ29udGV4dDNEOjpDT0xPUl9BVFRBQ0hNRU5U MCwgR3JhcGhpY3NDb250ZXh0M0Q6OlRFWFRVUkVfMkQsIG1fdGV4dHVyZUlkLCAwKTsKIH0KIAor UGFzc093blB0cjxNYW5hZ2VkVGV4dHVyZT4gTWFuYWdlZFRleHR1cmU6OnN0ZWFsKCkKK3sKKyAg ICBPd25QdHI8TWFuYWdlZFRleHR1cmU+IHRleHR1cmUgPSBhZG9wdFB0cihuZXcgTWFuYWdlZFRl eHR1cmUobV90ZXh0dXJlTWFuYWdlciwgbV90b2tlbiwgbV9zaXplLCBtX2Zvcm1hdCwgbV90ZXh0 dXJlSWQpKTsKKyAgICBtX3Rva2VuID0gMDsKKyAgICBtX3NpemUgPSBJbnRTaXplKCk7CisgICAg bV9mb3JtYXQgPSAwOworICAgIG1fdGV4dHVyZUlkID0gMDsKKyAgICByZXR1cm4gdGV4dHVyZS5y ZWxlYXNlKCk7Cit9CisKKwogfQogCiAjZW5kaWYgLy8gVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lU SU5HKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vTWFuYWdlZFRleHR1cmUuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL01hbmFnZWRUZXh0dXJlLmgKaW5kZXggMWNjOGJmYTlhYjMxY2M5MjMxYjQ3YTgzY2M1 NjUyYTIyYWFlODFhOC4uNzZkNjJhOGJiODlhZDZkNDFmNjMwZmI2NGI2ZTY4YzliODNmYjdhZSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFu YWdlZFRleHR1cmUuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJv bWl1bS9NYW5hZ2VkVGV4dHVyZS5oCkBAIC02Myw4ICs2MywxMyBAQCBwdWJsaWM6CiAgICAgdW5z aWduZWQgZm9ybWF0KCkgY29uc3QgeyByZXR1cm4gbV9mb3JtYXQ7IH0KICAgICB1bnNpZ25lZCB0 ZXh0dXJlSWQoKSBjb25zdCB7IHJldHVybiBtX3RleHR1cmVJZDsgfQogCisgICAgLy8gU3RlYWwg dG9rZW4gYW5kIHRleHR1cmVJZCBieSBpbnN0YW50aWF0ZXMgYSBuZXcgdGV4dHVyZSB1c2luZyBl eGlzdGluZworICAgIC8vIG1lbWJlciB2YXJpYWJsZXMuCisgICAgUGFzc093blB0cjxNYW5hZ2Vk VGV4dHVyZT4gc3RlYWwoKTsKKwogcHJpdmF0ZToKICAgICBleHBsaWNpdCBNYW5hZ2VkVGV4dHVy ZShUZXh0dXJlTWFuYWdlciopOworICAgIE1hbmFnZWRUZXh0dXJlKFRleHR1cmVNYW5hZ2VyKiwg VGV4dHVyZVRva2VuLCBJbnRTaXplLCB1bnNpZ25lZCBmb3JtYXQsIHVuc2lnbmVkIHRleHR1cmVJ ZCk7CiAKICAgICBUZXh0dXJlTWFuYWdlciogbV90ZXh0dXJlTWFuYWdlcjsKICAgICBUZXh0dXJl VG9rZW4gbV90b2tlbjsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCmluZGV4IDE0MzBh NjE2Nzg5MzI4MzlmNDBjNWIzZDFiOWJiNzRmNzdhOWE1NTUuLjkyZDEwMmUzMjJhMjE4MzU1ZTE1 NjgxZTUwMDVhZDMyYTJlMmI2ZTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3Jt L2dyYXBoaWNzL2Nocm9taXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcApA QCAtMzgwLDYgKzM4MCwxMSBAQCB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRvVXBk YXRlVGlsZXMoYm9vbCBpZGxlLCBpbnQgbGVmdCwgaW50IHRvcCwgaW50CiAgICAgICAgICAgICBp ZiAoIXRpbGUpCiAgICAgICAgICAgICAgICAgdGlsZSA9IGNyZWF0ZVRpbGUoaSwgaik7CiAKKyAg ICAgICAgICAgIC8vIERvIHBvc3QgY29tbWl0IGRlbGV0aW9uIG9mIGN1cnJlbnQgdGV4dHVyZSB3 aGVuIHBhcnRpYWwgdGV4dHVyZQorICAgICAgICAgICAgLy8gdXBkYXRlcyBhcmUgbm90IHVzZWQu CisgICAgICAgICAgICBpZiAodGlsZS0+aXNEaXJ0eSgpICYmIGxheWVyVHJlZUhvc3QoKSAmJiAh bGF5ZXJUcmVlSG9zdCgpLT5zZXR0aW5ncygpLnBhcnRpYWxUZXh0dXJlVXBkYXRlcykKKyAgICAg ICAgICAgICAgICBsYXllclRyZWVIb3N0KCktPmRlbGV0ZVRleHR1cmVBZnRlckNvbW1pdCh0aWxl LT5tYW5hZ2VkVGV4dHVyZSgpLT5zdGVhbCgpKTsKKwogICAgICAgICAgICAgaWYgKCF0aWxlLT5t YW5hZ2VkVGV4dHVyZSgpLT5pc1ZhbGlkKG1fdGlsZXItPnRpbGVTaXplKCksIG1fdGV4dHVyZUZv cm1hdCkpCiAgICAgICAgICAgICAgICAgdGlsZS0+bV9kaXJ0eVJlY3QgPSBtX3RpbGVyLT50aWxl UmVjdCh0aWxlKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAKaW5kZXggODY2M2Vj MGFjMmNkZjM2YjI0NzIyODFjZmZhZWExOTQwMjI1YTIzYy4uYTJmYjgyMmM1NmJkYjM1ZmNjZDNi OTlhNGQxNGRlZWE4ZDkxMzI4YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcAorKysgYi9Tb3VyY2UvV2Vi Q29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwCkBA IC05NSw2ICs5NSw5IEBAIGJvb2wgQ0NMYXllclRyZWVIb3N0Ojppbml0aWFsaXplKCkKICAgICAv LyBVcGRhdGUgbV9zZXR0aW5ncyBiYXNlZCBvbiBjYXBhYmlsaXRpZXMgdGhhdCB3ZSBnb3QgYmFj ayBmcm9tIHRoZSByZW5kZXJlci4KICAgICBtX3NldHRpbmdzLmFjY2VsZXJhdGVQYWludGluZyA9 IG1fcHJveHktPmxheWVyUmVuZGVyZXJDYXBhYmlsaXRpZXMoKS51c2luZ0FjY2VsZXJhdGVkUGFp bnRpbmc7CiAKKyAgICAvLyBVcGRhdGUgbV9zZXR0aW5ncyBiYXNlZCBvbiBwYXJ0aWFsIHVwZGF0 ZSBjYXBhYmlsaXR5LgorICAgIG1fc2V0dGluZ3MucGFydGlhbFRleHR1cmVVcGRhdGVzID0gbV9z ZXR0aW5ncy5wYXJ0aWFsVGV4dHVyZVVwZGF0ZXMgJiYgbV9wcm94eS0+cGFydGlhbFRleHR1cmVV cGRhdGVDYXBhYmlsaXR5KCk7CisKICAgICBtX2NvbnRlbnRzVGV4dHVyZU1hbmFnZXIgPSBUZXh0 dXJlTWFuYWdlcjo6Y3JlYXRlKFRleHR1cmVNYW5hZ2VyOjpoaWdoTGltaXRCeXRlcyh2aWV3cG9y dFNpemUoKSksCiAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICBUZXh0dXJlTWFuYWdlcjo6cmVjbGFpbUxpbWl0Qnl0ZXModmlld3BvcnRTaXplKCkp LAogICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg bV9wcm94eS0+bGF5ZXJSZW5kZXJlckNhcGFiaWxpdGllcygpLm1heFRleHR1cmVTaXplKTsKQEAg LTE2NSw2ICsxNjgsNyBAQCB2b2lkIENDTGF5ZXJUcmVlSG9zdDo6ZmluaXNoQ29tbWl0T25JbXBs VGhyZWFkKENDTGF5ZXJUcmVlSG9zdEltcGwqIGhvc3RJbXBsKQogCiB2b2lkIENDTGF5ZXJUcmVl SG9zdDo6Y29tbWl0Q29tcGxldGUoKQogeworICAgIG1fZGVsZXRlVGV4dHVyZUFmdGVyQ29tbWl0 TGlzdC5jbGVhcigpOwogICAgIGNsZWFyUGVuZGluZ1VwZGF0ZSgpOwogICAgIG1fY29udGVudHNU ZXh0dXJlTWFuYWdlci0+dW5wcm90ZWN0QWxsVGV4dHVyZXMoKTsKIH0KQEAgLTUxNCw0ICs1MTgs OSBAQCB2b2lkIENDTGF5ZXJUcmVlSG9zdDo6c3RvcFJhdGVMaW1pdGVyKEdyYXBoaWNzQ29udGV4 dDNEKiBjb250ZXh0KQogICAgIH0KIH0KIAordm9pZCBDQ0xheWVyVHJlZUhvc3Q6OmRlbGV0ZVRl eHR1cmVBZnRlckNvbW1pdChQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJlPiB0ZXh0dXJlKQorewor ICAgIG1fZGVsZXRlVGV4dHVyZUFmdGVyQ29tbWl0TGlzdC5hcHBlbmQodGV4dHVyZSk7Cit9CisK IH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVt L2NjL0NDTGF5ZXJUcmVlSG9zdC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3Mv Y2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmgKaW5kZXggMmY5ODliY2Y2YTE5MWMxMGZjNzQx YzlhZjFkZTdjYTkxYzMwNjA1ZS4uZDkyYWRjMTY2YWU2N2UzYWYwNTQyOTUxMGM5N2QzZmUzNjgz NTA5ZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vY2MvQ0NMYXllclRyZWVIb3N0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRyZWVIb3N0LmgKQEAgLTc2LDcgKzc2LDggQEAgc3Ry dWN0IENDU2V0dGluZ3MgewogICAgICAgICAgICAgLCBzaG93UGxhdGZvcm1MYXllclRyZWUoZmFs c2UpCiAgICAgICAgICAgICAsIHJlZnJlc2hSYXRlKDApCiAgICAgICAgICAgICAsIHBlclRpbGVQ YWludGluZyhmYWxzZSkKLSAgICAgICAgICAgICwgcGFydGlhbFN3YXBFbmFibGVkKGZhbHNlKSB7 IH0KKyAgICAgICAgICAgICwgcGFydGlhbFN3YXBFbmFibGVkKGZhbHNlKQorICAgICAgICAgICAg LCBwYXJ0aWFsVGV4dHVyZVVwZGF0ZXModHJ1ZSkgeyB9CiAKICAgICBib29sIGFjY2VsZXJhdGVQ YWludGluZzsKICAgICBib29sIGNvbXBvc2l0ZU9mZnNjcmVlbjsKQEAgLTg1LDYgKzg2LDcgQEAg c3RydWN0IENDU2V0dGluZ3MgewogICAgIGRvdWJsZSByZWZyZXNoUmF0ZTsKICAgICBib29sIHBl clRpbGVQYWludGluZzsKICAgICBib29sIHBhcnRpYWxTd2FwRW5hYmxlZDsKKyAgICBib29sIHBh cnRpYWxUZXh0dXJlVXBkYXRlczsKIH07CiAKIC8vIFByb3ZpZGVzIGluZm9ybWF0aW9uIG9uIGFu IEltcGwncyByZW5kZXJpbmcgY2FwYWJpbGl0aWVzIGJhY2sgdG8gdGhlIENDTGF5ZXJUcmVlSG9z dApAQCAtMTkyLDEyICsxOTQsMTUgQEAgcHVibGljOgogICAgIHZvaWQgc3RhcnRSYXRlTGltaXRl cihHcmFwaGljc0NvbnRleHQzRCopOwogICAgIHZvaWQgc3RvcFJhdGVMaW1pdGVyKEdyYXBoaWNz Q29udGV4dDNEKik7CiAKKyAgICB2b2lkIGRlbGV0ZVRleHR1cmVBZnRlckNvbW1pdChQYXNzT3du UHRyPE1hbmFnZWRUZXh0dXJlPik7CisKIHByb3RlY3RlZDoKICAgICBDQ0xheWVyVHJlZUhvc3Qo Q0NMYXllclRyZWVIb3N0Q2xpZW50KiwgY29uc3QgQ0NTZXR0aW5ncyYpOwogICAgIGJvb2wgaW5p dGlhbGl6ZSgpOwogCiBwcml2YXRlOgogICAgIHR5cGVkZWYgVmVjdG9yPFJlZlB0cjxMYXllckNo cm9taXVtPiA+IExheWVyTGlzdDsKKyAgICB0eXBlZGVmIFZlY3RvcjxPd25QdHI8TWFuYWdlZFRl eHR1cmU+ID4gVGV4dHVyZUxpc3Q7CiAKICAgICBlbnVtIFBhaW50VHlwZSB7IFBhaW50VmlzaWJs ZSwgUGFpbnRJZGxlIH07CiAgICAgc3RhdGljIHZvaWQgcGFpbnRDb250ZW50c0lmRGlydHkoTGF5 ZXJDaHJvbWl1bSosIFBhaW50VHlwZSk7CkBAIC0yMzMsNiArMjM4LDggQEAgcHJpdmF0ZToKICAg ICBmbG9hdCBtX3BhZ2VTY2FsZTsKICAgICBmbG9hdCBtX21pblBhZ2VTY2FsZSwgbV9tYXhQYWdl U2NhbGU7CiAgICAgYm9vbCBtX3RyaWdnZXJJZGxlUGFpbnRzOworCisgICAgVGV4dHVyZUxpc3Qg bV9kZWxldGVUZXh0dXJlQWZ0ZXJDb21taXRMaXN0OwogfTsKIAogfQpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NQcm94eS5oIGIvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NQcm94eS5oCmluZGV4 IGJiMzc4MDE0N2IxNmMyNmI3NWE3Y2NkMjJhYThiOGZlODRlNzZiYmQuLjkzN2MxNTRmZjY5YmE4 NTNiYmZjOTM0NTZkNzc2NjcxMGM3MGEyMjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1Byb3h5LmgKQEAgLTc5LDYgKzc5LDEw IEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgc3RhcnQoKSA9IDA7IC8vIE11c3QgYmUgY2Fs bGVkIGJlZm9yZSB1c2luZyB0aGUgcHJveHkuCiAgICAgdmlydHVhbCB2b2lkIHN0b3AoKSA9IDA7 IC8vIE11c3QgYmUgY2FsbGVkIGJlZm9yZSBkZWxldGluZyB0aGUgcHJveHkuCiAKKyAgICAvLyBX aGV0aGVyIHN1Yi1yZWdpb25zIG9mIHRleHR1cmVzIGNhbiBiZSB1cGRhdGVkIG9yIGlmIGNvbXBs ZXRlIHRleHR1cmUKKyAgICAvLyB1cGRhdGVzIGFyZSByZXF1aXJlZC4KKyAgICB2aXJ0dWFsIGJv b2wgcGFydGlhbFRleHR1cmVVcGRhdGVDYXBhYmlsaXR5KCkgY29uc3QgPSAwOworCiAgICAgLy8g RGVidWcgaG9va3MKICNpZm5kZWYgTkRFQlVHCiAgICAgc3RhdGljIGJvb2wgaXNNYWluVGhyZWFk KCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9jYy9DQ1NpbmdsZVRocmVhZFByb3h5LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9jYy9DQ1NpbmdsZVRocmVhZFByb3h5LmgKaW5kZXggMGQ1YTRhMmQ4YTUx NmIxZDdiY2Y5OTFhOTllMWM3ODc4OTk0M2VjNS4uNGZhYTIyOTk5MTJhZWM5YzRlNmFiNGJhNzAy N2Q4MWM4MDZkNDVlZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vY2MvQ0NTaW5nbGVUaHJlYWRQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDU2luZ2xlVGhyZWFkUHJveHkuaApAQCAt NTQsNiArNTQsNyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHNldFZpc2libGUoYm9vbCk7 CiAgICAgdmlydHVhbCB2b2lkIHN0YXJ0KCk7CiAgICAgdmlydHVhbCB2b2lkIHN0b3AoKTsKKyAg ICB2aXJ0dWFsIGJvb2wgcGFydGlhbFRleHR1cmVVcGRhdGVDYXBhYmlsaXR5KCkgY29uc3QgeyBy ZXR1cm4gdHJ1ZTsgfQogCiAgICAgLy8gQ0NMYXllclRyZWVIb3N0SW1wbENsaWVudCBpbXBsZW1l bnRhdGlvbgogICAgIHZpcnR1YWwgdm9pZCBvblN3YXBCdWZmZXJzQ29tcGxldGVPbkltcGxUaHJl YWQoKSB7IEFTU0VSVF9OT1RfUkVBQ0hFRCgpOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmNwcCBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuY3Bw CmluZGV4IDkwMzMxMzUxM2E5ZDA5ODIzNDEyZTVlNzdkNjk5ODU0NTdmOTNhNjEuLjMyYTg2MzBj ZTMxMDI1MDE3Nzg5ZDI1MDQ0NmJmOWZmNjkwNDBkMGQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJv eHkuY3BwCkBAIC0zOSw4ICszOSwxNSBAQAogI2luY2x1ZGUgPHd0Zi9DdXJyZW50VGltZS5oPgog I2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CiAKK3VzaW5nIG5hbWVzcGFjZSBzdGQ7CiB1c2lu ZyBuYW1lc3BhY2UgV1RGOwogCituYW1lc3BhY2UgeworCitzdGF0aWMgY29uc3Qgc2l6ZV90IHRl eHR1cmVVcGRhdGVzUGVyRnJhbWUgPSBudW1lcmljX2xpbWl0czxzaXplX3Q+OjptYXgoKTsKKwor fSAvLyBhbm9ueW1vdXMgbmFtZXNwYWNlCisKIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogUGFzc093 blB0cjxDQ1Byb3h5PiBDQ1RocmVhZFByb3h5OjpjcmVhdGUoQ0NMYXllclRyZWVIb3N0KiBsYXll clRyZWVIb3N0KQpAQCAtNDM4LDggKzQ0NSw3IEBAIHZvaWQgQ0NUaHJlYWRQcm94eTo6c2NoZWR1 bGVkQWN0aW9uVXBkYXRlTW9yZVJlc291cmNlcygpCiB7CiAgICAgVFJBQ0VfRVZFTlQoIkNDVGhy ZWFkUHJveHk6OnNjaGVkdWxlZEFjdGlvblVwZGF0ZU1vcmVSZXNvdXJjZXMiLCB0aGlzLCAwKTsK ICAgICBBU1NFUlQobV9jdXJyZW50VGV4dHVyZVVwZGF0ZXJPbkltcGxUaHJlYWQpOwotICAgIHN0 YXRpYyBjb25zdCBpbnQgVXBkYXRlc1BlckZyYW1lID0gOTk5OTk7Ci0gICAgbV9jdXJyZW50VGV4 dHVyZVVwZGF0ZXJPbkltcGxUaHJlYWQtPnVwZGF0ZShtX2xheWVyVHJlZUhvc3RJbXBsLT5jb250 ZXh0KCksIFVwZGF0ZXNQZXJGcmFtZSk7CisgICAgbV9jdXJyZW50VGV4dHVyZVVwZGF0ZXJPbklt cGxUaHJlYWQtPnVwZGF0ZShtX2xheWVyVHJlZUhvc3RJbXBsLT5jb250ZXh0KCksIHRleHR1cmVV cGRhdGVzUGVyRnJhbWUpOwogfQogCiB2b2lkIENDVGhyZWFkUHJveHk6OnNjaGVkdWxlZEFjdGlv bkNvbW1pdCgpCkBAIC01NjUsNCArNTcxLDkgQEAgdm9pZCBDQ1RocmVhZFByb3h5OjpsYXllclRy ZWVIb3N0Q2xvc2VkT25JbXBsVGhyZWFkKENDQ29tcGxldGlvbkV2ZW50KiBjb21wbGV0aW8KICAg ICBjb21wbGV0aW9uLT5zaWduYWwoKTsKIH0KIAorYm9vbCBDQ1RocmVhZFByb3h5OjpwYXJ0aWFs VGV4dHVyZVVwZGF0ZUNhcGFiaWxpdHkoKSBjb25zdAoreworICAgIHJldHVybiB0ZXh0dXJlVXBk YXRlc1BlckZyYW1lID09IG51bWVyaWNfbGltaXRzPHNpemVfdD46Om1heCgpOworfQorCiB9IC8v IG5hbWVzcGFjZSBXZWJDb3JlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmgKaW5kZXggYTQxYzBkNTY0 YjYzODEzYmE2M2E2Y2VkNThlMDRkNjljMzhmMmRlYS4uYTExYjUyNzg1OTkzMWNmYjk4Zjg3MjRh NTEyNDNhMDliNGVjYzNiOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuaApAQCAtNjIsNiArNjIs NyBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHNldFZpc2libGUoYm9vbCk7CiAgICAgdmly dHVhbCB2b2lkIHN0YXJ0KCk7CiAgICAgdmlydHVhbCB2b2lkIHN0b3AoKTsKKyAgICB2aXJ0dWFs IGJvb2wgcGFydGlhbFRleHR1cmVVcGRhdGVDYXBhYmlsaXR5KCkgY29uc3Q7CiAKICAgICAvLyBD Q0xheWVyVHJlZUhvc3RJbXBsQ2xpZW50IGltcGxlbWVudGF0aW9uCiAgICAgdmlydHVhbCB2b2lk IG9uU3dhcEJ1ZmZlcnNDb21wbGV0ZU9uSW1wbFRocmVhZCgpOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9jaHJvbWl1bS90ZXN0cy9DQ0xheWVyVHJlZUhvc3RUZXN0LmNwcCBiL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vdGVzdHMvQ0NMYXllclRyZWVIb3N0VGVzdC5jcHAKaW5kZXggOTUxODU5 NjUwNjI2OTQ4ZDBiNmQ1ZjY2ZTkzYjI3YTkwOGNiMTA3OS4uNThkZTc1OWJiMzM5M2I1ZGU3ZDk4 NjIwNmI3Y2VmOTNmN2FhMmQ3MSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90 ZXN0cy9DQ0xheWVyVHJlZUhvc3RUZXN0LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3Rlc3RzL0NDTGF5ZXJUcmVlSG9zdFRlc3QuY3BwCkBAIC0yNiw5ICsyNiw5IEBACiAKICNpbmNs dWRlICJjYy9DQ0xheWVyVHJlZUhvc3QuaCIKIAotI2luY2x1ZGUgIkNvbXBvc2l0b3JGYWtlR3Jh cGhpY3NDb250ZXh0M0QuaCIKKyNpbmNsdWRlICJDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29u dGV4dDNELmgiCiAjaW5jbHVkZSAiQ29udGVudExheWVyQ2hyb21pdW0uaCIKLSNpbmNsdWRlICJG YWtlV2ViR3JhcGhpY3NDb250ZXh0M0QuaCIKKyNpbmNsdWRlICJHcmFwaGljc0NvbnRleHQzRFBy aXZhdGUuaCIKICNpbmNsdWRlICJMYXllckNocm9taXVtLmgiCiAjaW5jbHVkZSAiVGV4dHVyZU1h bmFnZXIuaCIKICNpbmNsdWRlICJXZWJDb21wb3NpdG9yLmgiCkBAIC00MCw2ICs0MCw3IEBACiAj aW5jbHVkZSAiY2MvQ0NUaHJlYWRUYXNrLmgiCiAjaW5jbHVkZSAicGxhdGZvcm0vV2ViS2l0UGxh dGZvcm1TdXBwb3J0LmgiCiAjaW5jbHVkZSAicGxhdGZvcm0vV2ViVGhyZWFkLmgiCisjaW5jbHVk ZSA8Z21vY2svZ21vY2suaD4KICNpbmNsdWRlIDxndGVzdC9ndGVzdC5oPgogI2luY2x1ZGUgPHdl YmtpdC9zdXBwb3J0L3dlYmtpdF9zdXBwb3J0Lmg+CiAjaW5jbHVkZSA8d3RmL01haW5UaHJlYWQu aD4KQEAgLTEzMCw2ICsxMzEsNTIgQEAgcHJpdmF0ZToKICAgICBUZXN0SG9va3MqIG1fdGVzdEhv b2tzOwogfTsKIAorY2xhc3MgQ29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRFdpdGhU ZXh0dXJlVHJhY2tpbmcgOiBwdWJsaWMgQ29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQz RCB7CitwdWJsaWM6CisgICAgc3RhdGljIFBhc3NPd25QdHI8Q29tcG9zaXRvckZha2VXZWJHcmFw aGljc0NvbnRleHQzRFdpdGhUZXh0dXJlVHJhY2tpbmc+IGNyZWF0ZShBdHRyaWJ1dGVzIGF0dHJz KQorICAgIHsKKyAgICAgICAgcmV0dXJuIGFkb3B0UHRyKG5ldyBDb21wb3NpdG9yRmFrZVdlYkdy YXBoaWNzQ29udGV4dDNEV2l0aFRleHR1cmVUcmFja2luZyhhdHRycykpOworICAgIH0KKworICAg IHZpcnR1YWwgV2ViR0xJZCBjcmVhdGVUZXh0dXJlKCkKKyAgICB7CisgICAgICAgIFdlYkdMSWQg dGV4dHVyZSA9IG1fdGV4dHVyZXMuc2l6ZSgpICsgMTsKKyAgICAgICAgbV90ZXh0dXJlcy5hcHBl bmQodGV4dHVyZSk7CisgICAgICAgIHJldHVybiB0ZXh0dXJlOworICAgIH0KKworICAgIHZpcnR1 YWwgdm9pZCBkZWxldGVUZXh0dXJlKFdlYkdMSWQgdGV4dHVyZSkKKyAgICB7CisgICAgICAgIGZv ciAoc2l6ZV90IGkgPSAwOyBpIDwgbV90ZXh0dXJlcy5zaXplKCk7IGkrKykgeworICAgICAgICAg ICAgaWYgKG1fdGV4dHVyZXNbaV0gPT0gdGV4dHVyZSkgeworICAgICAgICAgICAgICAgIG1fdGV4 dHVyZXMucmVtb3ZlKGkpOworICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQor ICAgICAgICB9CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGJpbmRUZXh0dXJlKFdHQzNEZW51 bSAvKiB0YXJnZXQgKi8sIFdlYkdMSWQgdGV4dHVyZSkKKyAgICB7CisgICAgICAgIG1fdXNlZFRl eHR1cmVzLmFkZCh0ZXh0dXJlKTsKKyAgICB9CisKKyAgICBpbnQgbnVtVGV4dHVyZXMoKSBjb25z dCB7IHJldHVybiBzdGF0aWNfY2FzdDxpbnQ+KG1fdGV4dHVyZXMuc2l6ZSgpKTsgfQorICAgIGlu dCB0ZXh0dXJlKGludCBpKSBjb25zdCB7IHJldHVybiBtX3RleHR1cmVzW2ldOyB9CisgICAgdm9p ZCByZXNldFRleHR1cmVzKCkgeyBtX3RleHR1cmVzLmNsZWFyKCk7IH0KKworICAgIGludCBudW1V c2VkVGV4dHVyZXMoKSBjb25zdCB7IHJldHVybiBzdGF0aWNfY2FzdDxpbnQ+KG1fdXNlZFRleHR1 cmVzLnNpemUoKSk7IH0KKyAgICBib29sIHVzZWRUZXh0dXJlKGludCB0ZXh0dXJlKSBjb25zdCB7 IHJldHVybiBtX3VzZWRUZXh0dXJlcy5maW5kKHRleHR1cmUpICE9IG1fdXNlZFRleHR1cmVzLmVu ZCgpOyB9CisgICAgdm9pZCByZXNldFVzZWRUZXh0dXJlcygpIHsgbV91c2VkVGV4dHVyZXMuY2xl YXIoKTsgfQorCitwcml2YXRlOgorICAgIGV4cGxpY2l0IENvbXBvc2l0b3JGYWtlV2ViR3JhcGhp Y3NDb250ZXh0M0RXaXRoVGV4dHVyZVRyYWNraW5nKEF0dHJpYnV0ZXMgYXR0cnMpIDogQ29tcG9z aXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRChhdHRycykKKyAgICB7CisgICAgfQorCisgICAg VmVjdG9yPFdlYkdMSWQ+IG1fdGV4dHVyZXM7CisgICAgSGFzaFNldDxXZWJHTElkPiBtX3VzZWRU ZXh0dXJlczsKK307CisKIC8vIEltcGxlbWVudGF0aW9uIG9mIENDTGF5ZXJUcmVlSG9zdCBjYWxs YmFjayBpbnRlcmZhY2UuCiBjbGFzcyBNb2NrTGF5ZXJUcmVlSG9zdENsaWVudCA6IHB1YmxpYyBD Q0xheWVyVHJlZUhvc3RDbGllbnQgewogcHVibGljOgpAQCAtMTU1LDcgKzIwMiwxNSBAQCBwdWJs aWM6CiAKICAgICB2aXJ0dWFsIFBhc3NSZWZQdHI8R3JhcGhpY3NDb250ZXh0M0Q+IGNyZWF0ZUxh eWVyVHJlZUhvc3RDb250ZXh0M0QoKQogICAgIHsKLSAgICAgICAgcmV0dXJuIGNyZWF0ZUNvbXBv c2l0b3JNb2NrR3JhcGhpY3NDb250ZXh0M0QoR3JhcGhpY3NDb250ZXh0M0Q6OkF0dHJpYnV0ZXMo KSk7CisgICAgICAgIEdyYXBoaWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzIGF0dHJzOworICAgICAg ICBXZWJHcmFwaGljc0NvbnRleHQzRDo6QXR0cmlidXRlcyB3ZWJBdHRyczsKKyAgICAgICAgd2Vi QXR0cnMuYWxwaGEgPSBhdHRycy5hbHBoYTsKKworICAgICAgICBPd25QdHI8V2ViR3JhcGhpY3ND b250ZXh0M0Q+IHdlYkNvbnRleHQgPSBDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNE V2l0aFRleHR1cmVUcmFja2luZzo6Y3JlYXRlKHdlYkF0dHJzKTsKKyAgICAgICAgcmV0dXJuIEdy YXBoaWNzQ29udGV4dDNEUHJpdmF0ZTo6Y3JlYXRlR3JhcGhpY3NDb250ZXh0RnJvbVdlYkNvbnRl eHQoCisgICAgICAgICAgICB3ZWJDb250ZXh0LnJlbGVhc2UoKSwgYXR0cnMsIDAsCisgICAgICAg ICAgICBHcmFwaGljc0NvbnRleHQzRDo6UmVuZGVyRGlyZWN0bHlUb0hvc3RXaW5kb3csCisgICAg ICAgICAgICBHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6OkZvclVzZU9uQW5vdGhlclRocmVhZCk7 CiAgICAgfQogCiAgICAgdmlydHVhbCB2b2lkIGRpZENvbW1pdEFuZERyYXdGcmFtZSgpCkBAIC0x MDY4LDQgKzExMjMsMTAxIEBAIFRFU1RfRihDQ0xheWVyVHJlZUhvc3RUZXN0U2V0Vmlld3BvcnRT aXplLCBydW5TaW5nbGVUaHJlYWQpCiAgICAgcnVuVGVzdChmYWxzZSk7CiB9CiAKK2NsYXNzIE1v Y2tDb250ZW50TGF5ZXJEZWxlZ2F0ZSA6IHB1YmxpYyBDb250ZW50TGF5ZXJEZWxlZ2F0ZSB7Citw dWJsaWM6CisgICAgYm9vbCBkcmF3c0NvbnRlbnQoKSBjb25zdCB7IHJldHVybiB0cnVlOyB9Cisg ICAgTU9DS19DT05TVF9NRVRIT0QwKHByZXNlcnZlczNELCBib29sKCkpOworICAgIHZvaWQgcGFp bnRDb250ZW50cyhHcmFwaGljc0NvbnRleHQmLCBjb25zdCBJbnRSZWN0JikgeyB9CisgICAgdm9p ZCBub3RpZnlTeW5jUmVxdWlyZWQoKSB7IH0KK307CisKKy8vIFZlcmlmeSBhdG9taWNpdHkgb2Yg Y29tbWl0cyBhbmQgcmV1c2Ugb2YgdGV4dHVyZXMuCitjbGFzcyBDQ0xheWVyVHJlZUhvc3RUZXN0 QXRvbWljQ29tbWl0IDogcHVibGljIENDTGF5ZXJUcmVlSG9zdFRlc3QgeworcHVibGljOgorICAg IENDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQoKQorICAgICAgICA6IG1fdXBkYXRlQ2hl Y2tMYXllcihDb250ZW50TGF5ZXJDaHJvbWl1bVdpdGhVcGRhdGVUcmFja2luZzo6Y3JlYXRlKCZt X2RlbGVnYXRlKSkKKyAgICAgICAgLCBtX251bUNvbW1pdHMoMCkKKyAgICB7CisgICAgICAgIC8v IE1ha2Ugc3VyZSBwYXJ0aWFsIHRleHR1cmUgdXBkYXRlcyBhcmUgdHVybmVkIG9mZi4KKyAgICAg ICAgbV9zZXR0aW5ncy5wYXJ0aWFsVGV4dHVyZVVwZGF0ZXMgPSBmYWxzZTsKKyAgICB9CisKKyAg ICB2aXJ0dWFsIHZvaWQgYmVnaW5UZXN0KCkKKyAgICB7CisgICAgICAgIG1fbGF5ZXJUcmVlSG9z dC0+c2V0Um9vdExheWVyKG1fdXBkYXRlQ2hlY2tMYXllcik7CisgICAgICAgIG1fbGF5ZXJUcmVl SG9zdC0+c2V0Vmlld3BvcnRTaXplKEludFNpemUoMTAsIDEwKSk7CisKKyAgICAgICAgcG9zdFNl dE5lZWRzQ29tbWl0VG9NYWluVGhyZWFkKCk7CisgICAgICAgIHBvc3RTZXROZWVkc1JlZHJhd1Rv TWFpblRocmVhZCgpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBjb21taXRDb21wbGV0ZU9u Q0NUaHJlYWQoQ0NMYXllclRyZWVIb3N0SW1wbCogaW1wbCkKKyAgICB7CisgICAgICAgIENvbXBv c2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0RXaXRoVGV4dHVyZVRyYWNraW5nKiBjb250ZXh0 ID0gc3RhdGljX2Nhc3Q8Q29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRFdpdGhUZXh0 dXJlVHJhY2tpbmcqPihHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6OmV4dHJhY3RXZWJHcmFwaGlj c0NvbnRleHQzRChpbXBsLT5jb250ZXh0KCkpKTsKKworICAgICAgICBzd2l0Y2ggKGltcGwtPmZy YW1lTnVtYmVyKCkpIHsKKyAgICAgICAgY2FzZSAwOgorICAgICAgICAgICAgLy8gTnVtYmVyIG9m IHRleHR1cmVzIHNob3VsZCBiZSBvbmUuCisgICAgICAgICAgICBFWFBFQ1RfRVEoMSwgY29udGV4 dC0+bnVtVGV4dHVyZXMoKSk7CisgICAgICAgICAgICAvLyBOdW1iZXIgb2YgdGV4dHVyZXMgdXNl ZCBmb3IgY29tbWl0IHNob3VsZCBiZSBvbmUuCisgICAgICAgICAgICBFWFBFQ1RfRVEoMSwgY29u dGV4dC0+bnVtVXNlZFRleHR1cmVzKCkpOworICAgICAgICAgICAgLy8gVmVyaWZ5IHVzZWQgdGV4 dHVyZSBpcyBjb3JyZWN0LgorICAgICAgICAgICAgRVhQRUNUX1RSVUUoY29udGV4dC0+dXNlZFRl eHR1cmUoY29udGV4dC0+dGV4dHVyZSgwKSkpOworCisgICAgICAgICAgICBjb250ZXh0LT5yZXNl dFVzZWRUZXh0dXJlcygpOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIGNhc2UgMToKKyAg ICAgICAgICAgIC8vIE51bWJlciBvZiB0ZXh0dXJlcyBzaG91bGQgYmUgdHdvIGFzIHRoZSBmaXJz dCB0ZXh0dXJlCisgICAgICAgICAgICAvLyBpcyB1c2VkIGJ5IGltcGwgdGhyZWFkIGFuZCBjYW5u b3QgYnkgdXNlZCBmb3IgdXBkYXRlLgorICAgICAgICAgICAgRVhQRUNUX0VRKDIsIGNvbnRleHQt Pm51bVRleHR1cmVzKCkpOworICAgICAgICAgICAgLy8gTnVtYmVyIG9mIHRleHR1cmVzIHVzZWQg Zm9yIGNvbW1pdCBzaG91bGQgc3RpbGwgYmUgb25lLgorICAgICAgICAgICAgRVhQRUNUX0VRKDEs IGNvbnRleHQtPm51bVVzZWRUZXh0dXJlcygpKTsKKyAgICAgICAgICAgIC8vIEZpcnN0IHRleHR1 cmUgc2hvdWxkIG5vdCBoYXZlIGJlZW4gdXNlZC4KKyAgICAgICAgICAgIEVYUEVDVF9GQUxTRShj b250ZXh0LT51c2VkVGV4dHVyZShjb250ZXh0LT50ZXh0dXJlKDApKSk7CisgICAgICAgICAgICAv LyBOZXcgdGV4dHVyZSBzaG91bGQgaGF2ZSBiZWVuIHVzZWQuCisgICAgICAgICAgICBFWFBFQ1Rf VFJVRShjb250ZXh0LT51c2VkVGV4dHVyZShjb250ZXh0LT50ZXh0dXJlKDEpKSk7CisKKyAgICAg ICAgICAgIGNvbnRleHQtPnJlc2V0VXNlZFRleHR1cmVzKCk7CisgICAgICAgICAgICBicmVhazsK KyAgICAgICAgZGVmYXVsdDoKKyAgICAgICAgICAgIEFTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAg ICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgZHJh d0xheWVyc09uQ0NUaHJlYWQoQ0NMYXllclRyZWVIb3N0SW1wbCogaW1wbCkKKyAgICB7CisgICAg ICAgIENvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0RXaXRoVGV4dHVyZVRyYWNraW5n KiBjb250ZXh0ID0gc3RhdGljX2Nhc3Q8Q29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQz RFdpdGhUZXh0dXJlVHJhY2tpbmcqPihHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6OmV4dHJhY3RX ZWJHcmFwaGljc0NvbnRleHQzRChpbXBsLT5jb250ZXh0KCkpKTsKKworICAgICAgICAvLyBOdW1i ZXIgb2YgdGV4dHVyZXMgdXNlZCBmb3IgZHJhdyBzaG91bGQgYWx3YXlzIGJlIG9uZS4KKyAgICAg ICAgRVhQRUNUX0VRKDEsIGNvbnRleHQtPm51bVVzZWRUZXh0dXJlcygpKTsKKworICAgICAgICBp ZiAoaW1wbC0+ZnJhbWVOdW1iZXIoKSA8IDIpIHsKKyAgICAgICAgICAgIGNvbnRleHQtPnJlc2V0 VXNlZFRleHR1cmVzKCk7CisgICAgICAgICAgICBwb3N0U2V0TmVlZHNBbmltYXRlQW5kQ29tbWl0 VG9NYWluVGhyZWFkKCk7CisgICAgICAgICAgICBwb3N0U2V0TmVlZHNSZWRyYXdUb01haW5UaHJl YWQoKTsKKyAgICAgICAgfSBlbHNlCisgICAgICAgICAgICBlbmRUZXN0KCk7CisgICAgfQorCisg ICAgdmlydHVhbCB2b2lkIGxheW91dCgpCisgICAgeworICAgICAgICBtX3VwZGF0ZUNoZWNrTGF5 ZXItPnNldE5lZWRzRGlzcGxheSgpOworICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBhZnRlclRl c3QoKQorICAgIHsKKyAgICB9CisKK3ByaXZhdGU6CisgICAgTW9ja0NvbnRlbnRMYXllckRlbGVn YXRlIG1fZGVsZWdhdGU7CisgICAgUmVmUHRyPENvbnRlbnRMYXllckNocm9taXVtV2l0aFVwZGF0 ZVRyYWNraW5nPiBtX3VwZGF0ZUNoZWNrTGF5ZXI7CisgICAgaW50IG1fbnVtQ29tbWl0czsKK307 CisKK1RFU1RfRihDQ0xheWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0LCBydW5NdWx0aVRocmVh ZCkKK3sKKyAgICBydW5UZXN0KHRydWUpOworfQorCiB9IC8vIG5hbWVzcGFjZQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9Db21wb3NpdG9yRmFrZVdlYkdyYXBoaWNz Q29udGV4dDNELmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0NvbXBvc2l0b3JGYWtl V2ViR3JhcGhpY3NDb250ZXh0M0QuaAppbmRleCBkZTE0MDliZDQyNGI2NDc0M2I4Zjk5OTNiM2Mx NzJiOGY2MGFiNTExLi4wNzkwNjM5ZDU3MzAxOWI1NTRkMTQxYjc0MWM4ZGQ2ODg2NDFkYzZmIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0NvbXBvc2l0b3JGYWtlV2Vi R3JhcGhpY3NDb250ZXh0M0QuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0Nv bXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QuaApAQCAtNDMsNyArNDMsNyBAQCBwdWJs aWM6CiAgICAgdmlydHVhbCB2b2lkIGdldFNoYWRlcml2KFdlYkdMSWQsIFdHQzNEZW51bSwgV0dD M0RpbnQqIHZhbHVlKSB7ICp2YWx1ZSA9IDE7IH0KICAgICB2aXJ0dWFsIHZvaWQgZ2V0UHJvZ3Jh bWl2KFdlYkdMSWQsIFdHQzNEZW51bSwgV0dDM0RpbnQqIHZhbHVlKSB7ICp2YWx1ZSA9IDE7IH0K IAotcHJpdmF0ZToKK3Byb3RlY3RlZDoKICAgICBleHBsaWNpdCBDb21wb3NpdG9yRmFrZVdlYkdy YXBoaWNzQ29udGV4dDNEKEF0dHJpYnV0ZXMgYXR0cnMpCiAgICAgewogICAgICAgICBtX2F0dHJz ID0gYXR0cnM7Cg== 123465 2012-01-21 18:00:31 -0800 2012-01-21 19:30:55 -0800 Patch bug-72672-20120121210030.patch text/plain 22292 reveman U3VidmVyc2lvbiBSZXZpc2lvbjogMTA1NTgyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODk5MDRlYzI4YTFlMTY0 MGRhMjJkZmUzNTViMTI0MWJmNTljMjFkNy4uZjIxNzEyNGQ0NDdkYTU5MjJlYTY4NTE5NGIwODcw OGQ0YjEyZmQyMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDEyLTAxLTIxICBEYXZp ZCBSZXZlbWFuICA8cmV2ZW1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW0Nocm9taXVtXSBJ bmNyZW1lbnRhbCB0ZXh0dXJlIHVwZGF0ZXMgYXJlIG5vdCBhdG9taWMuCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MjY3MgorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFVzZSBhIG5ldyBzZXQgb2YgdGV4dHVy ZXMgZm9yIGVhY2ggY29tbWl0IHdoZW4gaW5jcmVtZW50YWwKKyAgICAgICAgdGV4dHVyZSB1cGRh dGVzIGFyZSBlbmFibGVkLgorCisgICAgICAgIFRoaXMgcGF0Y2ggaXMgdGVzdGVkIGJ5IHRoZSBm b2xsb3dpbmcgdW5pdCB0ZXN0OgorICAgICAgICAtIENDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWND b21taXQucnVuTXVsdGlUaHJlYWQKKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL01hbmFnZWRUZXh0dXJlLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6Ok1hbmFnZWRUZXh0dXJl OjpNYW5hZ2VkVGV4dHVyZSk6CisgICAgICAgIChXZWJDb3JlOjpNYW5hZ2VkVGV4dHVyZTo6c3Rl YWwpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRUZXh0dXJl Lmg6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9t aXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OlRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRv VXBkYXRlVGlsZXMpOgorICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0ND TGF5ZXJUcmVlSG9zdC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6Omlu aXRpYWxpemUpOgorICAgICAgICAoV2ViQ29yZTo6Q0NMYXllclRyZWVIb3N0Ojpjb21taXRDb21w bGV0ZSk6CisgICAgICAgIChXZWJDb3JlOjpDQ0xheWVyVHJlZUhvc3Q6OmRlbGV0ZVRleHR1cmVB ZnRlckNvbW1pdCk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NM YXllclRyZWVIb3N0Lmg6CisgICAgICAgIChXZWJDb3JlOjpDQ1NldHRpbmdzOjpDQ1NldHRpbmdz KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1Byb3h5Lmg6Cisg ICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NTaW5nbGVUaHJlYWRQcm94 eS5oOgorICAgICAgICAoV2ViQ29yZTo6Q0NTaW5nbGVUaHJlYWRQcm94eTo6cGFydGlhbFRleHR1 cmVVcGRhdGVDYXBhYmlsaXR5KToKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9jYy9DQ1RocmVhZFByb3h5LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkNDVGhyZWFkUHJveHk6 OnNjaGVkdWxlZEFjdGlvblVwZGF0ZU1vcmVSZXNvdXJjZXMpOgorICAgICAgICAoV2ViQ29yZTo6 Q0NUaHJlYWRQcm94eTo6cGFydGlhbFRleHR1cmVVcGRhdGVDYXBhYmlsaXR5KToKKyAgICAgICAg KiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5Lmg6CisKIDIwMTIt MDEtMjEgIFBhYmxvIEZsb3VyZXQgIDxwYWJsb2ZAbW90b3JvbGEuY29tPgogCiAgICAgICAgIEFk ZCAudXJsIGF0dHJpYnV0ZSBhbG9uZ3NpZGUgLlVSTCBpbiBFdmVudFNvdXJjZSBhbmQgV2ViU29j a2V0IHRvIGNvbXBseSB3aXRoIHRoZSBzcGVjcyBidXQgbm90IGJyZWFrIGV4aXN0aW5nIHVzYWdl LgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cgYi9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCAyNWMyNThlNTI1MzBiM2RiMTRmZWNlNzk2 YjgzMDMxOGUwZjQ4MGI2Li4yNGJkZmVkMDk2OGQ5MWQ2ZTQyMzQ1YzEzOWFjODQ3NzUwOWI1MTA4 IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZworKysgYi9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM4IEBACisyMDEyLTAxLTIx ICBEYXZpZCBSZXZlbWFuICA8cmV2ZW1hbkBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgW0Nocm9t aXVtXSBJbmNyZW1lbnRhbCB0ZXh0dXJlIHVwZGF0ZXMgYXJlIG5vdCBhdG9taWMuCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03MjY3MgorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIEFkZCBDQ0xheWVyVHJlZUhv c3RUZXN0QXRvbWljQ29tbWl0IHRlc3QgdGhhdCB2ZXJpZmllcyBhdG9taWNpdHkKKyAgICAgICAg b2YgY29tbWl0cy4KKworICAgICAgICAqIHRlc3RzL0NDTGF5ZXJUcmVlSG9zdFRlc3QuY3BwOgor ICAgICAgICAoV1RGOjpDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEV2l0aFRleHR1 cmVUcmFja2luZzo6Y3JlYXRlKToKKyAgICAgICAgKFdURjo6Q29tcG9zaXRvckZha2VXZWJHcmFw aGljc0NvbnRleHQzRFdpdGhUZXh0dXJlVHJhY2tpbmc6OmNyZWF0ZVRleHR1cmUpOgorICAgICAg ICAoV1RGOjpDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEV2l0aFRleHR1cmVUcmFj a2luZzo6ZGVsZXRlVGV4dHVyZSk6CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3Jh cGhpY3NDb250ZXh0M0RXaXRoVGV4dHVyZVRyYWNraW5nOjpiaW5kVGV4dHVyZSk6CisgICAgICAg IChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0RXaXRoVGV4dHVyZVRyYWNr aW5nOjpudW1UZXh0dXJlcyk6CisgICAgICAgIChXVEY6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhp Y3NDb250ZXh0M0RXaXRoVGV4dHVyZVRyYWNraW5nOjp0ZXh0dXJlKToKKyAgICAgICAgKFdURjo6 Q29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRFdpdGhUZXh0dXJlVHJhY2tpbmc6OnJl c2V0VGV4dHVyZXMpOgorICAgICAgICAoV1RGOjpDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29u dGV4dDNEV2l0aFRleHR1cmVUcmFja2luZzo6bnVtVXNlZFRleHR1cmVzKToKKyAgICAgICAgKFdU Rjo6Q29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRFdpdGhUZXh0dXJlVHJhY2tpbmc6 OnVzZWRUZXh0dXJlKToKKyAgICAgICAgKFdURjo6Q29tcG9zaXRvckZha2VXZWJHcmFwaGljc0Nv bnRleHQzRFdpdGhUZXh0dXJlVHJhY2tpbmc6OnJlc2V0VXNlZFRleHR1cmVzKToKKyAgICAgICAg KFdURjo6Q29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRFdpdGhUZXh0dXJlVHJhY2tp bmc6OkNvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0RXaXRoVGV4dHVyZVRyYWNraW5n KToKKyAgICAgICAgKFdURjo6TW9ja0xheWVyVHJlZUhvc3RDbGllbnQ6OmNyZWF0ZUxheWVyVHJl ZUhvc3RDb250ZXh0M0QpOgorICAgICAgICAoV1RGOjpNb2NrQ29udGVudExheWVyRGVsZWdhdGU6 OmRyYXdzQ29udGVudCk6CisgICAgICAgIChXVEY6Ok1vY2tDb250ZW50TGF5ZXJEZWxlZ2F0ZTo6 cGFpbnRDb250ZW50cyk6CisgICAgICAgIChXVEY6Ok1vY2tDb250ZW50TGF5ZXJEZWxlZ2F0ZTo6 bm90aWZ5U3luY1JlcXVpcmVkKToKKyAgICAgICAgKFdURjo6Q0NMYXllclRyZWVIb3N0VGVzdEF0 b21pY0NvbW1pdDo6Q0NMYXllclRyZWVIb3N0VGVzdEF0b21pY0NvbW1pdCk6CisgICAgICAgIChX VEY6OkNDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQ6OmJlZ2luVGVzdCk6CisgICAgICAg IChXVEY6OkNDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQ6OmNvbW1pdENvbXBsZXRlT25D Q1RocmVhZCk6CisgICAgICAgIChXVEY6OkNDTGF5ZXJUcmVlSG9zdFRlc3RBdG9taWNDb21taXQ6 OmRyYXdMYXllcnNPbkNDVGhyZWFkKToKKyAgICAgICAgKFdURjo6Q0NMYXllclRyZWVIb3N0VGVz dEF0b21pY0NvbW1pdDo6bGF5b3V0KToKKyAgICAgICAgKFdURjo6Q0NMYXllclRyZWVIb3N0VGVz dEF0b21pY0NvbW1pdDo6YWZ0ZXJUZXN0KToKKyAgICAgICAgKFdURjo6VEVTVF9GKToKKyAgICAg ICAgKiB0ZXN0cy9Db21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNELmg6CisKIDIwMTIt MDEtMjEgIFNoZXJpZmYgQm90ICA8d2Via2l0LnJldmlldy5ib3RAZ21haWwuY29tPgogCiAgICAg ICAgIFVucmV2aWV3ZWQsIHJvbGxpbmcgb3V0IHIxMDU1NjQuCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5jcHAgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5hZ2VkVGV4dHVyZS5j cHAKaW5kZXggMGMxZTRiNzBkMjcxNGEzODZmOTdlYWEzNDhkN2UzZThjNjZlY2UxMS4uNWJiMTlm YTg3ZGVhZDI3Y2U3ZTFjNzkzYThmYzM1ODJjMGQzZmJkMSAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFuYWdlZFRleHR1cmUuY3BwCisrKyBi L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRUZXh0dXJl LmNwcApAQCAtNDEsNiArNDEsMTUgQEAgTWFuYWdlZFRleHR1cmU6Ok1hbmFnZWRUZXh0dXJlKFRl eHR1cmVNYW5hZ2VyKiBtYW5hZ2VyKQogewogfQogCitNYW5hZ2VkVGV4dHVyZTo6TWFuYWdlZFRl eHR1cmUoVGV4dHVyZU1hbmFnZXIqIG1hbmFnZXIsIFRleHR1cmVUb2tlbiB0b2tlbiwgSW50U2l6 ZSBzaXplLCB1bnNpZ25lZCBmb3JtYXQsIHVuc2lnbmVkIHRleHR1cmVJZCkKKyAgICA6IG1fdGV4 dHVyZU1hbmFnZXIobWFuYWdlcikKKyAgICAsIG1fdG9rZW4odG9rZW4pCisgICAgLCBtX3NpemUo c2l6ZSkKKyAgICAsIG1fZm9ybWF0KGZvcm1hdCkKKyAgICAsIG1fdGV4dHVyZUlkKHRleHR1cmVJ ZCkKK3sKK30KKwogTWFuYWdlZFRleHR1cmU6On5NYW5hZ2VkVGV4dHVyZSgpCiB7CiAgICAgaWYg KG1fdG9rZW4pCkBAIC05OSw2ICsxMDgsMTcgQEAgdm9pZCBNYW5hZ2VkVGV4dHVyZTo6ZnJhbWVi dWZmZXJUZXh0dXJlMkQoR3JhcGhpY3NDb250ZXh0M0QqIGNvbnRleHQsIFRleHR1cmVBbGwKICAg ICBjb250ZXh0LT5mcmFtZWJ1ZmZlclRleHR1cmUyRChHcmFwaGljc0NvbnRleHQzRDo6RlJBTUVC VUZGRVIsIEdyYXBoaWNzQ29udGV4dDNEOjpDT0xPUl9BVFRBQ0hNRU5UMCwgR3JhcGhpY3NDb250 ZXh0M0Q6OlRFWFRVUkVfMkQsIG1fdGV4dHVyZUlkLCAwKTsKIH0KIAorUGFzc093blB0cjxNYW5h Z2VkVGV4dHVyZT4gTWFuYWdlZFRleHR1cmU6OnN0ZWFsKCkKK3sKKyAgICBPd25QdHI8TWFuYWdl ZFRleHR1cmU+IHRleHR1cmUgPSBhZG9wdFB0cihuZXcgTWFuYWdlZFRleHR1cmUobV90ZXh0dXJl TWFuYWdlciwgbV90b2tlbiwgbV9zaXplLCBtX2Zvcm1hdCwgbV90ZXh0dXJlSWQpKTsKKyAgICBt X3Rva2VuID0gMDsKKyAgICBtX3NpemUgPSBJbnRTaXplKCk7CisgICAgbV9mb3JtYXQgPSAwOwor ICAgIG1fdGV4dHVyZUlkID0gMDsKKyAgICByZXR1cm4gdGV4dHVyZS5yZWxlYXNlKCk7Cit9CisK KwogfQogCiAjZW5kaWYgLy8gVVNFKEFDQ0VMRVJBVEVEX0NPTVBPU0lUSU5HKQpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFuYWdlZFRleHR1 cmUuaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL01hbmFnZWRU ZXh0dXJlLmgKaW5kZXggMWNjOGJmYTlhYjMxY2M5MjMxYjQ3YTgzY2M1NjUyYTIyYWFlODFhOC4u NzZkNjJhOGJiODlhZDZkNDFmNjMwZmI2NGI2ZTY4YzliODNmYjdhZSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vTWFuYWdlZFRleHR1cmUuaAor KysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9NYW5hZ2VkVGV4 dHVyZS5oCkBAIC02Myw4ICs2MywxMyBAQCBwdWJsaWM6CiAgICAgdW5zaWduZWQgZm9ybWF0KCkg Y29uc3QgeyByZXR1cm4gbV9mb3JtYXQ7IH0KICAgICB1bnNpZ25lZCB0ZXh0dXJlSWQoKSBjb25z dCB7IHJldHVybiBtX3RleHR1cmVJZDsgfQogCisgICAgLy8gU3RlYWwgdG9rZW4gYW5kIHRleHR1 cmVJZCBieSBpbnN0YW50aWF0ZXMgYSBuZXcgdGV4dHVyZSB1c2luZyBleGlzdGluZworICAgIC8v IG1lbWJlciB2YXJpYWJsZXMuCisgICAgUGFzc093blB0cjxNYW5hZ2VkVGV4dHVyZT4gc3RlYWwo KTsKKwogcHJpdmF0ZToKICAgICBleHBsaWNpdCBNYW5hZ2VkVGV4dHVyZShUZXh0dXJlTWFuYWdl ciopOworICAgIE1hbmFnZWRUZXh0dXJlKFRleHR1cmVNYW5hZ2VyKiwgVGV4dHVyZVRva2VuLCBJ bnRTaXplLCB1bnNpZ25lZCBmb3JtYXQsIHVuc2lnbmVkIHRleHR1cmVJZCk7CiAKICAgICBUZXh0 dXJlTWFuYWdlciogbV90ZXh0dXJlTWFuYWdlcjsKICAgICBUZXh0dXJlVG9rZW4gbV90b2tlbjsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL1Rp bGVkTGF5ZXJDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9UaWxlZExheWVyQ2hyb21pdW0uY3BwCmluZGV4IDE0MzBhNjE2Nzg5MzI4MzlmNDBj NWIzZDFiOWJiNzRmNzdhOWE1NTUuLjkyZDEwMmUzMjJhMjE4MzU1ZTE1NjgxZTUwMDVhZDMyYTJl MmI2ZTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9t aXVtL1RpbGVkTGF5ZXJDaHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vVGlsZWRMYXllckNocm9taXVtLmNwcApAQCAtMzgwLDYgKzM4MCwx MSBAQCB2b2lkIFRpbGVkTGF5ZXJDaHJvbWl1bTo6cHJlcGFyZVRvVXBkYXRlVGlsZXMoYm9vbCBp ZGxlLCBpbnQgbGVmdCwgaW50IHRvcCwgaW50CiAgICAgICAgICAgICBpZiAoIXRpbGUpCiAgICAg ICAgICAgICAgICAgdGlsZSA9IGNyZWF0ZVRpbGUoaSwgaik7CiAKKyAgICAgICAgICAgIC8vIERv IHBvc3QgY29tbWl0IGRlbGV0aW9uIG9mIGN1cnJlbnQgdGV4dHVyZSB3aGVuIHBhcnRpYWwgdGV4 dHVyZQorICAgICAgICAgICAgLy8gdXBkYXRlcyBhcmUgbm90IHVzZWQuCisgICAgICAgICAgICBp ZiAodGlsZS0+aXNEaXJ0eSgpICYmIGxheWVyVHJlZUhvc3QoKSAmJiAhbGF5ZXJUcmVlSG9zdCgp LT5zZXR0aW5ncygpLnBhcnRpYWxUZXh0dXJlVXBkYXRlcykKKyAgICAgICAgICAgICAgICBsYXll clRyZWVIb3N0KCktPmRlbGV0ZVRleHR1cmVBZnRlckNvbW1pdCh0aWxlLT5tYW5hZ2VkVGV4dHVy ZSgpLT5zdGVhbCgpKTsKKwogICAgICAgICAgICAgaWYgKCF0aWxlLT5tYW5hZ2VkVGV4dHVyZSgp LT5pc1ZhbGlkKG1fdGlsZXItPnRpbGVTaXplKCksIG1fdGV4dHVyZUZvcm1hdCkpCiAgICAgICAg ICAgICAgICAgdGlsZS0+bV9kaXJ0eVJlY3QgPSBtX3RpbGVyLT50aWxlUmVjdCh0aWxlKTsKIApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NMYXllclRyZWVIb3N0LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2No cm9taXVtL2NjL0NDTGF5ZXJUcmVlSG9zdC5jcHAKaW5kZXggODY2M2VjMGFjMmNkZjM2YjI0NzIy ODFjZmZhZWExOTQwMjI1YTIzYy4uYTJmYjgyMmM1NmJkYjM1ZmNjZDNiOTlhNGQxNGRlZWE4ZDkx MzI4YiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vY2MvQ0NMYXllclRyZWVIb3N0LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9jYy9DQ0xheWVyVHJlZUhvc3QuY3BwCkBAIC05NSw2ICs5NSw5IEBA IGJvb2wgQ0NMYXllclRyZWVIb3N0Ojppbml0aWFsaXplKCkKICAgICAvLyBVcGRhdGUgbV9zZXR0 aW5ncyBiYXNlZCBvbiBjYXBhYmlsaXRpZXMgdGhhdCB3ZSBnb3QgYmFjayBmcm9tIHRoZSByZW5k ZXJlci4KICAgICBtX3NldHRpbmdzLmFjY2VsZXJhdGVQYWludGluZyA9IG1fcHJveHktPmxheWVy UmVuZGVyZXJDYXBhYmlsaXRpZXMoKS51c2luZ0FjY2VsZXJhdGVkUGFpbnRpbmc7CiAKKyAgICAv LyBVcGRhdGUgbV9zZXR0aW5ncyBiYXNlZCBvbiBwYXJ0aWFsIHVwZGF0ZSBjYXBhYmlsaXR5Lgor ICAgIG1fc2V0dGluZ3MucGFydGlhbFRleHR1cmVVcGRhdGVzID0gbV9zZXR0aW5ncy5wYXJ0aWFs VGV4dHVyZVVwZGF0ZXMgJiYgbV9wcm94eS0+cGFydGlhbFRleHR1cmVVcGRhdGVDYXBhYmlsaXR5 KCk7CisKICAgICBtX2NvbnRlbnRzVGV4dHVyZU1hbmFnZXIgPSBUZXh0dXJlTWFuYWdlcjo6Y3Jl YXRlKFRleHR1cmVNYW5hZ2VyOjpoaWdoTGltaXRCeXRlcyh2aWV3cG9ydFNpemUoKSksCiAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBUZXh0dXJl TWFuYWdlcjo6cmVjbGFpbUxpbWl0Qnl0ZXModmlld3BvcnRTaXplKCkpLAogICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgbV9wcm94eS0+bGF5ZXJS ZW5kZXJlckNhcGFiaWxpdGllcygpLm1heFRleHR1cmVTaXplKTsKQEAgLTE2NSw2ICsxNjgsNyBA QCB2b2lkIENDTGF5ZXJUcmVlSG9zdDo6ZmluaXNoQ29tbWl0T25JbXBsVGhyZWFkKENDTGF5ZXJU cmVlSG9zdEltcGwqIGhvc3RJbXBsKQogCiB2b2lkIENDTGF5ZXJUcmVlSG9zdDo6Y29tbWl0Q29t cGxldGUoKQogeworICAgIG1fZGVsZXRlVGV4dHVyZUFmdGVyQ29tbWl0TGlzdC5jbGVhcigpOwog ICAgIGNsZWFyUGVuZGluZ1VwZGF0ZSgpOwogICAgIG1fY29udGVudHNUZXh0dXJlTWFuYWdlci0+ dW5wcm90ZWN0QWxsVGV4dHVyZXMoKTsKIH0KQEAgLTUxNCw0ICs1MTgsOSBAQCB2b2lkIENDTGF5 ZXJUcmVlSG9zdDo6c3RvcFJhdGVMaW1pdGVyKEdyYXBoaWNzQ29udGV4dDNEKiBjb250ZXh0KQog ICAgIH0KIH0KIAordm9pZCBDQ0xheWVyVHJlZUhvc3Q6OmRlbGV0ZVRleHR1cmVBZnRlckNvbW1p dChQYXNzT3duUHRyPE1hbmFnZWRUZXh0dXJlPiB0ZXh0dXJlKQoreworICAgIG1fZGVsZXRlVGV4 dHVyZUFmdGVyQ29tbWl0TGlzdC5hcHBlbmQodGV4dHVyZSk7Cit9CisKIH0KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDTGF5ZXJUcmVl SG9zdC5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NM YXllclRyZWVIb3N0LmgKaW5kZXggMmY5ODliY2Y2YTE5MWMxMGZjNzQxYzlhZjFkZTdjYTkxYzMw NjA1ZS4uZDkyYWRjMTY2YWU2N2UzYWYwNTQyOTUxMGM5N2QzZmUzNjgzNTA5ZiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NMYXllclRy ZWVIb3N0LmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v Y2MvQ0NMYXllclRyZWVIb3N0LmgKQEAgLTc2LDcgKzc2LDggQEAgc3RydWN0IENDU2V0dGluZ3Mg ewogICAgICAgICAgICAgLCBzaG93UGxhdGZvcm1MYXllclRyZWUoZmFsc2UpCiAgICAgICAgICAg ICAsIHJlZnJlc2hSYXRlKDApCiAgICAgICAgICAgICAsIHBlclRpbGVQYWludGluZyhmYWxzZSkK LSAgICAgICAgICAgICwgcGFydGlhbFN3YXBFbmFibGVkKGZhbHNlKSB7IH0KKyAgICAgICAgICAg ICwgcGFydGlhbFN3YXBFbmFibGVkKGZhbHNlKQorICAgICAgICAgICAgLCBwYXJ0aWFsVGV4dHVy ZVVwZGF0ZXModHJ1ZSkgeyB9CiAKICAgICBib29sIGFjY2VsZXJhdGVQYWludGluZzsKICAgICBi b29sIGNvbXBvc2l0ZU9mZnNjcmVlbjsKQEAgLTg1LDYgKzg2LDcgQEAgc3RydWN0IENDU2V0dGlu Z3MgewogICAgIGRvdWJsZSByZWZyZXNoUmF0ZTsKICAgICBib29sIHBlclRpbGVQYWludGluZzsK ICAgICBib29sIHBhcnRpYWxTd2FwRW5hYmxlZDsKKyAgICBib29sIHBhcnRpYWxUZXh0dXJlVXBk YXRlczsKIH07CiAKIC8vIFByb3ZpZGVzIGluZm9ybWF0aW9uIG9uIGFuIEltcGwncyByZW5kZXJp bmcgY2FwYWJpbGl0aWVzIGJhY2sgdG8gdGhlIENDTGF5ZXJUcmVlSG9zdApAQCAtMTkyLDEyICsx OTQsMTUgQEAgcHVibGljOgogICAgIHZvaWQgc3RhcnRSYXRlTGltaXRlcihHcmFwaGljc0NvbnRl eHQzRCopOwogICAgIHZvaWQgc3RvcFJhdGVMaW1pdGVyKEdyYXBoaWNzQ29udGV4dDNEKik7CiAK KyAgICB2b2lkIGRlbGV0ZVRleHR1cmVBZnRlckNvbW1pdChQYXNzT3duUHRyPE1hbmFnZWRUZXh0 dXJlPik7CisKIHByb3RlY3RlZDoKICAgICBDQ0xheWVyVHJlZUhvc3QoQ0NMYXllclRyZWVIb3N0 Q2xpZW50KiwgY29uc3QgQ0NTZXR0aW5ncyYpOwogICAgIGJvb2wgaW5pdGlhbGl6ZSgpOwogCiBw cml2YXRlOgogICAgIHR5cGVkZWYgVmVjdG9yPFJlZlB0cjxMYXllckNocm9taXVtPiA+IExheWVy TGlzdDsKKyAgICB0eXBlZGVmIFZlY3RvcjxPd25QdHI8TWFuYWdlZFRleHR1cmU+ID4gVGV4dHVy ZUxpc3Q7CiAKICAgICBlbnVtIFBhaW50VHlwZSB7IFBhaW50VmlzaWJsZSwgUGFpbnRJZGxlIH07 CiAgICAgc3RhdGljIHZvaWQgcGFpbnRDb250ZW50c0lmRGlydHkoTGF5ZXJDaHJvbWl1bSosIFBh aW50VHlwZSk7CkBAIC0yMzMsNiArMjM4LDggQEAgcHJpdmF0ZToKICAgICBmbG9hdCBtX3BhZ2VT Y2FsZTsKICAgICBmbG9hdCBtX21pblBhZ2VTY2FsZSwgbV9tYXhQYWdlU2NhbGU7CiAgICAgYm9v bCBtX3RyaWdnZXJJZGxlUGFpbnRzOworCisgICAgVGV4dHVyZUxpc3QgbV9kZWxldGVUZXh0dXJl QWZ0ZXJDb21taXRMaXN0OwogfTsKIAogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NQcm94eS5oIGIvU291cmNlL1dlYkNvcmUvcGxh dGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NQcm94eS5oCmluZGV4IGJiMzc4MDE0N2IxNmMy NmI3NWE3Y2NkMjJhYThiOGZlODRlNzZiYmQuLjkzN2MxNTRmZjY5YmE4NTNiYmZjOTM0NTZkNzc2 NjcxMGM3MGEyMjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL2NjL0NDUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9jYy9DQ1Byb3h5LmgKQEAgLTc5LDYgKzc5LDEwIEBAIHB1YmxpYzoKICAg ICB2aXJ0dWFsIHZvaWQgc3RhcnQoKSA9IDA7IC8vIE11c3QgYmUgY2FsbGVkIGJlZm9yZSB1c2lu ZyB0aGUgcHJveHkuCiAgICAgdmlydHVhbCB2b2lkIHN0b3AoKSA9IDA7IC8vIE11c3QgYmUgY2Fs bGVkIGJlZm9yZSBkZWxldGluZyB0aGUgcHJveHkuCiAKKyAgICAvLyBXaGV0aGVyIHN1Yi1yZWdp b25zIG9mIHRleHR1cmVzIGNhbiBiZSB1cGRhdGVkIG9yIGlmIGNvbXBsZXRlIHRleHR1cmUKKyAg ICAvLyB1cGRhdGVzIGFyZSByZXF1aXJlZC4KKyAgICB2aXJ0dWFsIGJvb2wgcGFydGlhbFRleHR1 cmVVcGRhdGVDYXBhYmlsaXR5KCkgY29uc3QgPSAwOworCiAgICAgLy8gRGVidWcgaG9va3MKICNp Zm5kZWYgTkRFQlVHCiAgICAgc3RhdGljIGJvb2wgaXNNYWluVGhyZWFkKCk7CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1NpbmdsZVRo cmVhZFByb3h5LmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9j Yy9DQ1NpbmdsZVRocmVhZFByb3h5LmgKaW5kZXggMGQ1YTRhMmQ4YTUxNmIxZDdiY2Y5OTFhOTll MWM3ODc4OTk0M2VjNS4uNGZhYTIyOTk5MTJhZWM5YzRlNmFiNGJhNzAyN2Q4MWM4MDZkNDVlZSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2Mv Q0NTaW5nbGVUaHJlYWRQcm94eS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBo aWNzL2Nocm9taXVtL2NjL0NDU2luZ2xlVGhyZWFkUHJveHkuaApAQCAtNTQsNiArNTQsNyBAQCBw dWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHNldFZpc2libGUoYm9vbCk7CiAgICAgdmlydHVhbCB2 b2lkIHN0YXJ0KCk7CiAgICAgdmlydHVhbCB2b2lkIHN0b3AoKTsKKyAgICB2aXJ0dWFsIGJvb2wg cGFydGlhbFRleHR1cmVVcGRhdGVDYXBhYmlsaXR5KCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfQog CiAgICAgLy8gQ0NMYXllclRyZWVIb3N0SW1wbENsaWVudCBpbXBsZW1lbnRhdGlvbgogICAgIHZp cnR1YWwgdm9pZCBvblN3YXBCdWZmZXJzQ29tcGxldGVPbkltcGxUaHJlYWQoKSB7IEFTU0VSVF9O T1RfUkVBQ0hFRCgpOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFw aGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmNwcCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRm b3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuY3BwCmluZGV4IDkwMzMxMzUx M2E5ZDA5ODIzNDEyZTVlNzdkNjk5ODU0NTdmOTNhNjEuLjIwYWM1MzE4MGU5YWNjMTQ2ZDE3NjU3 MWMyZjZiNDdkMGQ1OWRmM2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuY3BwCkBAIC00MSw2 ICs0MSwxMiBAQAogCiB1c2luZyBuYW1lc3BhY2UgV1RGOwogCituYW1lc3BhY2UgeworCitzdGF0 aWMgY29uc3Qgc2l6ZV90IHRleHR1cmVVcGRhdGVzUGVyRnJhbWUgPSAwOworCit9IC8vIGFub255 bW91cyBuYW1lc3BhY2UKKwogbmFtZXNwYWNlIFdlYkNvcmUgewogCiBQYXNzT3duUHRyPENDUHJv eHk+IENDVGhyZWFkUHJveHk6OmNyZWF0ZShDQ0xheWVyVHJlZUhvc3QqIGxheWVyVHJlZUhvc3Qp CkBAIC00MzgsOCArNDQ0LDcgQEAgdm9pZCBDQ1RocmVhZFByb3h5OjpzY2hlZHVsZWRBY3Rpb25V cGRhdGVNb3JlUmVzb3VyY2VzKCkKIHsKICAgICBUUkFDRV9FVkVOVCgiQ0NUaHJlYWRQcm94eTo6 c2NoZWR1bGVkQWN0aW9uVXBkYXRlTW9yZVJlc291cmNlcyIsIHRoaXMsIDApOwogICAgIEFTU0VS VChtX2N1cnJlbnRUZXh0dXJlVXBkYXRlck9uSW1wbFRocmVhZCk7Ci0gICAgc3RhdGljIGNvbnN0 IGludCBVcGRhdGVzUGVyRnJhbWUgPSA5OTk5OTsKLSAgICBtX2N1cnJlbnRUZXh0dXJlVXBkYXRl ck9uSW1wbFRocmVhZC0+dXBkYXRlKG1fbGF5ZXJUcmVlSG9zdEltcGwtPmNvbnRleHQoKSwgVXBk YXRlc1BlckZyYW1lKTsKKyAgICBtX2N1cnJlbnRUZXh0dXJlVXBkYXRlck9uSW1wbFRocmVhZC0+ dXBkYXRlKG1fbGF5ZXJUcmVlSG9zdEltcGwtPmNvbnRleHQoKSwgdGV4dHVyZVVwZGF0ZXNQZXJG cmFtZSA+IDAgPyB0ZXh0dXJlVXBkYXRlc1BlckZyYW1lIDogOTk5OTkpOwogfQogCiB2b2lkIEND VGhyZWFkUHJveHk6OnNjaGVkdWxlZEFjdGlvbkNvbW1pdCgpCkBAIC01NjUsNCArNTcwLDkgQEAg dm9pZCBDQ1RocmVhZFByb3h5OjpsYXllclRyZWVIb3N0Q2xvc2VkT25JbXBsVGhyZWFkKENDQ29t cGxldGlvbkV2ZW50KiBjb21wbGV0aW8KICAgICBjb21wbGV0aW9uLT5zaWduYWwoKTsKIH0KIAor Ym9vbCBDQ1RocmVhZFByb3h5OjpwYXJ0aWFsVGV4dHVyZVVwZGF0ZUNhcGFiaWxpdHkoKSBjb25z dAoreworICAgIHJldHVybiAhdGV4dHVyZVVwZGF0ZXNQZXJGcmFtZTsKK30KKwogfSAvLyBuYW1l c3BhY2UgV2ViQ29yZQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0v Z3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5oCmluZGV4IGE0MWMwZDU2NGI2Mzgx M2JhNjNhNmNlZDU4ZTA0ZDY5YzM4ZjJkZWEuLmExMWI1Mjc4NTk5MzFjZmI5OGY4NzI0YTUxMjQz YTA5YjRlY2MzYjkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL2NjL0NDVGhyZWFkUHJveHkuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmgKQEAgLTYyLDYgKzYyLDcgQEAg cHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBzZXRWaXNpYmxlKGJvb2wpOwogICAgIHZpcnR1YWwg dm9pZCBzdGFydCgpOwogICAgIHZpcnR1YWwgdm9pZCBzdG9wKCk7CisgICAgdmlydHVhbCBib29s IHBhcnRpYWxUZXh0dXJlVXBkYXRlQ2FwYWJpbGl0eSgpIGNvbnN0OwogCiAgICAgLy8gQ0NMYXll clRyZWVIb3N0SW1wbENsaWVudCBpbXBsZW1lbnRhdGlvbgogICAgIHZpcnR1YWwgdm9pZCBvblN3 YXBCdWZmZXJzQ29tcGxldGVPbkltcGxUaHJlYWQoKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vdGVzdHMvQ0NMYXllclRyZWVIb3N0VGVzdC5jcHAgYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3Rlc3RzL0NDTGF5ZXJUcmVlSG9zdFRlc3QuY3BwCmluZGV4IDk1MTg1OTY1MDYy Njk0OGQwYjZkNWY2NmU5M2IyN2E5MDhjYjEwNzkuLjU4ZGU3NTliYjMzOTNiNWRlN2Q5ODYyMDZi N2NlZjkzZjdhYTJkNzEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMv Q0NMYXllclRyZWVIb3N0VGVzdC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0 cy9DQ0xheWVyVHJlZUhvc3RUZXN0LmNwcApAQCAtMjYsOSArMjYsOSBAQAogCiAjaW5jbHVkZSAi Y2MvQ0NMYXllclRyZWVIb3N0LmgiCiAKLSNpbmNsdWRlICJDb21wb3NpdG9yRmFrZUdyYXBoaWNz Q29udGV4dDNELmgiCisjaW5jbHVkZSAiQ29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQz RC5oIgogI2luY2x1ZGUgIkNvbnRlbnRMYXllckNocm9taXVtLmgiCi0jaW5jbHVkZSAiRmFrZVdl YkdyYXBoaWNzQ29udGV4dDNELmgiCisjaW5jbHVkZSAiR3JhcGhpY3NDb250ZXh0M0RQcml2YXRl LmgiCiAjaW5jbHVkZSAiTGF5ZXJDaHJvbWl1bS5oIgogI2luY2x1ZGUgIlRleHR1cmVNYW5hZ2Vy LmgiCiAjaW5jbHVkZSAiV2ViQ29tcG9zaXRvci5oIgpAQCAtNDAsNiArNDAsNyBAQAogI2luY2x1 ZGUgImNjL0NDVGhyZWFkVGFzay5oIgogI2luY2x1ZGUgInBsYXRmb3JtL1dlYktpdFBsYXRmb3Jt U3VwcG9ydC5oIgogI2luY2x1ZGUgInBsYXRmb3JtL1dlYlRocmVhZC5oIgorI2luY2x1ZGUgPGdt b2NrL2dtb2NrLmg+CiAjaW5jbHVkZSA8Z3Rlc3QvZ3Rlc3QuaD4KICNpbmNsdWRlIDx3ZWJraXQv c3VwcG9ydC93ZWJraXRfc3VwcG9ydC5oPgogI2luY2x1ZGUgPHd0Zi9NYWluVGhyZWFkLmg+CkBA IC0xMzAsNiArMTMxLDUyIEBAIHByaXZhdGU6CiAgICAgVGVzdEhvb2tzKiBtX3Rlc3RIb29rczsK IH07CiAKK2NsYXNzIENvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0RXaXRoVGV4dHVy ZVRyYWNraW5nIDogcHVibGljIENvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Qgewor cHVibGljOgorICAgIHN0YXRpYyBQYXNzT3duUHRyPENvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3ND b250ZXh0M0RXaXRoVGV4dHVyZVRyYWNraW5nPiBjcmVhdGUoQXR0cmlidXRlcyBhdHRycykKKyAg ICB7CisgICAgICAgIHJldHVybiBhZG9wdFB0cihuZXcgQ29tcG9zaXRvckZha2VXZWJHcmFwaGlj c0NvbnRleHQzRFdpdGhUZXh0dXJlVHJhY2tpbmcoYXR0cnMpKTsKKyAgICB9CisKKyAgICB2aXJ0 dWFsIFdlYkdMSWQgY3JlYXRlVGV4dHVyZSgpCisgICAgeworICAgICAgICBXZWJHTElkIHRleHR1 cmUgPSBtX3RleHR1cmVzLnNpemUoKSArIDE7CisgICAgICAgIG1fdGV4dHVyZXMuYXBwZW5kKHRl eHR1cmUpOworICAgICAgICByZXR1cm4gdGV4dHVyZTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZv aWQgZGVsZXRlVGV4dHVyZShXZWJHTElkIHRleHR1cmUpCisgICAgeworICAgICAgICBmb3IgKHNp emVfdCBpID0gMDsgaSA8IG1fdGV4dHVyZXMuc2l6ZSgpOyBpKyspIHsKKyAgICAgICAgICAgIGlm IChtX3RleHR1cmVzW2ldID09IHRleHR1cmUpIHsKKyAgICAgICAgICAgICAgICBtX3RleHR1cmVz LnJlbW92ZShpKTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0KKyAgICAg ICAgfQorICAgIH0KKworICAgIHZpcnR1YWwgdm9pZCBiaW5kVGV4dHVyZShXR0MzRGVudW0gLyog dGFyZ2V0ICovLCBXZWJHTElkIHRleHR1cmUpCisgICAgeworICAgICAgICBtX3VzZWRUZXh0dXJl cy5hZGQodGV4dHVyZSk7CisgICAgfQorCisgICAgaW50IG51bVRleHR1cmVzKCkgY29uc3QgeyBy ZXR1cm4gc3RhdGljX2Nhc3Q8aW50PihtX3RleHR1cmVzLnNpemUoKSk7IH0KKyAgICBpbnQgdGV4 dHVyZShpbnQgaSkgY29uc3QgeyByZXR1cm4gbV90ZXh0dXJlc1tpXTsgfQorICAgIHZvaWQgcmVz ZXRUZXh0dXJlcygpIHsgbV90ZXh0dXJlcy5jbGVhcigpOyB9CisKKyAgICBpbnQgbnVtVXNlZFRl eHR1cmVzKCkgY29uc3QgeyByZXR1cm4gc3RhdGljX2Nhc3Q8aW50PihtX3VzZWRUZXh0dXJlcy5z aXplKCkpOyB9CisgICAgYm9vbCB1c2VkVGV4dHVyZShpbnQgdGV4dHVyZSkgY29uc3QgeyByZXR1 cm4gbV91c2VkVGV4dHVyZXMuZmluZCh0ZXh0dXJlKSAhPSBtX3VzZWRUZXh0dXJlcy5lbmQoKTsg fQorICAgIHZvaWQgcmVzZXRVc2VkVGV4dHVyZXMoKSB7IG1fdXNlZFRleHR1cmVzLmNsZWFyKCk7 IH0KKworcHJpdmF0ZToKKyAgICBleHBsaWNpdCBDb21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29u dGV4dDNEV2l0aFRleHR1cmVUcmFja2luZyhBdHRyaWJ1dGVzIGF0dHJzKSA6IENvbXBvc2l0b3JG YWtlV2ViR3JhcGhpY3NDb250ZXh0M0QoYXR0cnMpCisgICAgeworICAgIH0KKworICAgIFZlY3Rv cjxXZWJHTElkPiBtX3RleHR1cmVzOworICAgIEhhc2hTZXQ8V2ViR0xJZD4gbV91c2VkVGV4dHVy ZXM7Cit9OworCiAvLyBJbXBsZW1lbnRhdGlvbiBvZiBDQ0xheWVyVHJlZUhvc3QgY2FsbGJhY2sg aW50ZXJmYWNlLgogY2xhc3MgTW9ja0xheWVyVHJlZUhvc3RDbGllbnQgOiBwdWJsaWMgQ0NMYXll clRyZWVIb3N0Q2xpZW50IHsKIHB1YmxpYzoKQEAgLTE1NSw3ICsyMDIsMTUgQEAgcHVibGljOgog CiAgICAgdmlydHVhbCBQYXNzUmVmUHRyPEdyYXBoaWNzQ29udGV4dDNEPiBjcmVhdGVMYXllclRy ZWVIb3N0Q29udGV4dDNEKCkKICAgICB7Ci0gICAgICAgIHJldHVybiBjcmVhdGVDb21wb3NpdG9y TW9ja0dyYXBoaWNzQ29udGV4dDNEKEdyYXBoaWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzKCkpOwor ICAgICAgICBHcmFwaGljc0NvbnRleHQzRDo6QXR0cmlidXRlcyBhdHRyczsKKyAgICAgICAgV2Vi R3JhcGhpY3NDb250ZXh0M0Q6OkF0dHJpYnV0ZXMgd2ViQXR0cnM7CisgICAgICAgIHdlYkF0dHJz LmFscGhhID0gYXR0cnMuYWxwaGE7CisKKyAgICAgICAgT3duUHRyPFdlYkdyYXBoaWNzQ29udGV4 dDNEPiB3ZWJDb250ZXh0ID0gQ29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRleHQzRFdpdGhU ZXh0dXJlVHJhY2tpbmc6OmNyZWF0ZSh3ZWJBdHRycyk7CisgICAgICAgIHJldHVybiBHcmFwaGlj c0NvbnRleHQzRFByaXZhdGU6OmNyZWF0ZUdyYXBoaWNzQ29udGV4dEZyb21XZWJDb250ZXh0KAor ICAgICAgICAgICAgd2ViQ29udGV4dC5yZWxlYXNlKCksIGF0dHJzLCAwLAorICAgICAgICAgICAg R3JhcGhpY3NDb250ZXh0M0Q6OlJlbmRlckRpcmVjdGx5VG9Ib3N0V2luZG93LAorICAgICAgICAg ICAgR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlOjpGb3JVc2VPbkFub3RoZXJUaHJlYWQpOwogICAg IH0KIAogICAgIHZpcnR1YWwgdm9pZCBkaWRDb21taXRBbmREcmF3RnJhbWUoKQpAQCAtMTA2OCw0 ICsxMTIzLDEwMSBAQCBURVNUX0YoQ0NMYXllclRyZWVIb3N0VGVzdFNldFZpZXdwb3J0U2l6ZSwg cnVuU2luZ2xlVGhyZWFkKQogICAgIHJ1blRlc3QoZmFsc2UpOwogfQogCitjbGFzcyBNb2NrQ29u dGVudExheWVyRGVsZWdhdGUgOiBwdWJsaWMgQ29udGVudExheWVyRGVsZWdhdGUgeworcHVibGlj OgorICAgIGJvb2wgZHJhd3NDb250ZW50KCkgY29uc3QgeyByZXR1cm4gdHJ1ZTsgfQorICAgIE1P Q0tfQ09OU1RfTUVUSE9EMChwcmVzZXJ2ZXMzRCwgYm9vbCgpKTsKKyAgICB2b2lkIHBhaW50Q29u dGVudHMoR3JhcGhpY3NDb250ZXh0JiwgY29uc3QgSW50UmVjdCYpIHsgfQorICAgIHZvaWQgbm90 aWZ5U3luY1JlcXVpcmVkKCkgeyB9Cit9OworCisvLyBWZXJpZnkgYXRvbWljaXR5IG9mIGNvbW1p dHMgYW5kIHJldXNlIG9mIHRleHR1cmVzLgorY2xhc3MgQ0NMYXllclRyZWVIb3N0VGVzdEF0b21p Y0NvbW1pdCA6IHB1YmxpYyBDQ0xheWVyVHJlZUhvc3RUZXN0IHsKK3B1YmxpYzoKKyAgICBDQ0xh eWVyVHJlZUhvc3RUZXN0QXRvbWljQ29tbWl0KCkKKyAgICAgICAgOiBtX3VwZGF0ZUNoZWNrTGF5 ZXIoQ29udGVudExheWVyQ2hyb21pdW1XaXRoVXBkYXRlVHJhY2tpbmc6OmNyZWF0ZSgmbV9kZWxl Z2F0ZSkpCisgICAgICAgICwgbV9udW1Db21taXRzKDApCisgICAgeworICAgICAgICAvLyBNYWtl IHN1cmUgcGFydGlhbCB0ZXh0dXJlIHVwZGF0ZXMgYXJlIHR1cm5lZCBvZmYuCisgICAgICAgIG1f c2V0dGluZ3MucGFydGlhbFRleHR1cmVVcGRhdGVzID0gZmFsc2U7CisgICAgfQorCisgICAgdmly dHVhbCB2b2lkIGJlZ2luVGVzdCgpCisgICAgeworICAgICAgICBtX2xheWVyVHJlZUhvc3QtPnNl dFJvb3RMYXllcihtX3VwZGF0ZUNoZWNrTGF5ZXIpOworICAgICAgICBtX2xheWVyVHJlZUhvc3Qt PnNldFZpZXdwb3J0U2l6ZShJbnRTaXplKDEwLCAxMCkpOworCisgICAgICAgIHBvc3RTZXROZWVk c0NvbW1pdFRvTWFpblRocmVhZCgpOworICAgICAgICBwb3N0U2V0TmVlZHNSZWRyYXdUb01haW5U aHJlYWQoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgY29tbWl0Q29tcGxldGVPbkNDVGhy ZWFkKENDTGF5ZXJUcmVlSG9zdEltcGwqIGltcGwpCisgICAgeworICAgICAgICBDb21wb3NpdG9y RmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEV2l0aFRleHR1cmVUcmFja2luZyogY29udGV4dCA9IHN0 YXRpY19jYXN0PENvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0RXaXRoVGV4dHVyZVRy YWNraW5nKj4oR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlOjpleHRyYWN0V2ViR3JhcGhpY3NDb250 ZXh0M0QoaW1wbC0+Y29udGV4dCgpKSk7CisKKyAgICAgICAgc3dpdGNoIChpbXBsLT5mcmFtZU51 bWJlcigpKSB7CisgICAgICAgIGNhc2UgMDoKKyAgICAgICAgICAgIC8vIE51bWJlciBvZiB0ZXh0 dXJlcyBzaG91bGQgYmUgb25lLgorICAgICAgICAgICAgRVhQRUNUX0VRKDEsIGNvbnRleHQtPm51 bVRleHR1cmVzKCkpOworICAgICAgICAgICAgLy8gTnVtYmVyIG9mIHRleHR1cmVzIHVzZWQgZm9y IGNvbW1pdCBzaG91bGQgYmUgb25lLgorICAgICAgICAgICAgRVhQRUNUX0VRKDEsIGNvbnRleHQt Pm51bVVzZWRUZXh0dXJlcygpKTsKKyAgICAgICAgICAgIC8vIFZlcmlmeSB1c2VkIHRleHR1cmUg aXMgY29ycmVjdC4KKyAgICAgICAgICAgIEVYUEVDVF9UUlVFKGNvbnRleHQtPnVzZWRUZXh0dXJl KGNvbnRleHQtPnRleHR1cmUoMCkpKTsKKworICAgICAgICAgICAgY29udGV4dC0+cmVzZXRVc2Vk VGV4dHVyZXMoKTsKKyAgICAgICAgICAgIGJyZWFrOworICAgICAgICBjYXNlIDE6CisgICAgICAg ICAgICAvLyBOdW1iZXIgb2YgdGV4dHVyZXMgc2hvdWxkIGJlIHR3byBhcyB0aGUgZmlyc3QgdGV4 dHVyZQorICAgICAgICAgICAgLy8gaXMgdXNlZCBieSBpbXBsIHRocmVhZCBhbmQgY2Fubm90IGJ5 IHVzZWQgZm9yIHVwZGF0ZS4KKyAgICAgICAgICAgIEVYUEVDVF9FUSgyLCBjb250ZXh0LT5udW1U ZXh0dXJlcygpKTsKKyAgICAgICAgICAgIC8vIE51bWJlciBvZiB0ZXh0dXJlcyB1c2VkIGZvciBj b21taXQgc2hvdWxkIHN0aWxsIGJlIG9uZS4KKyAgICAgICAgICAgIEVYUEVDVF9FUSgxLCBjb250 ZXh0LT5udW1Vc2VkVGV4dHVyZXMoKSk7CisgICAgICAgICAgICAvLyBGaXJzdCB0ZXh0dXJlIHNo b3VsZCBub3QgaGF2ZSBiZWVuIHVzZWQuCisgICAgICAgICAgICBFWFBFQ1RfRkFMU0UoY29udGV4 dC0+dXNlZFRleHR1cmUoY29udGV4dC0+dGV4dHVyZSgwKSkpOworICAgICAgICAgICAgLy8gTmV3 IHRleHR1cmUgc2hvdWxkIGhhdmUgYmVlbiB1c2VkLgorICAgICAgICAgICAgRVhQRUNUX1RSVUUo Y29udGV4dC0+dXNlZFRleHR1cmUoY29udGV4dC0+dGV4dHVyZSgxKSkpOworCisgICAgICAgICAg ICBjb250ZXh0LT5yZXNldFVzZWRUZXh0dXJlcygpOworICAgICAgICAgICAgYnJlYWs7CisgICAg ICAgIGRlZmF1bHQ6CisgICAgICAgICAgICBBU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAgICAg ICAgIGJyZWFrOworICAgICAgICB9CisgICAgfQorCisgICAgdmlydHVhbCB2b2lkIGRyYXdMYXll cnNPbkNDVGhyZWFkKENDTGF5ZXJUcmVlSG9zdEltcGwqIGltcGwpCisgICAgeworICAgICAgICBD b21wb3NpdG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEV2l0aFRleHR1cmVUcmFja2luZyogY29u dGV4dCA9IHN0YXRpY19jYXN0PENvbXBvc2l0b3JGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0RXaXRo VGV4dHVyZVRyYWNraW5nKj4oR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlOjpleHRyYWN0V2ViR3Jh cGhpY3NDb250ZXh0M0QoaW1wbC0+Y29udGV4dCgpKSk7CisKKyAgICAgICAgLy8gTnVtYmVyIG9m IHRleHR1cmVzIHVzZWQgZm9yIGRyYXcgc2hvdWxkIGFsd2F5cyBiZSBvbmUuCisgICAgICAgIEVY UEVDVF9FUSgxLCBjb250ZXh0LT5udW1Vc2VkVGV4dHVyZXMoKSk7CisKKyAgICAgICAgaWYgKGlt cGwtPmZyYW1lTnVtYmVyKCkgPCAyKSB7CisgICAgICAgICAgICBjb250ZXh0LT5yZXNldFVzZWRU ZXh0dXJlcygpOworICAgICAgICAgICAgcG9zdFNldE5lZWRzQW5pbWF0ZUFuZENvbW1pdFRvTWFp blRocmVhZCgpOworICAgICAgICAgICAgcG9zdFNldE5lZWRzUmVkcmF3VG9NYWluVGhyZWFkKCk7 CisgICAgICAgIH0gZWxzZQorICAgICAgICAgICAgZW5kVGVzdCgpOworICAgIH0KKworICAgIHZp cnR1YWwgdm9pZCBsYXlvdXQoKQorICAgIHsKKyAgICAgICAgbV91cGRhdGVDaGVja0xheWVyLT5z ZXROZWVkc0Rpc3BsYXkoKTsKKyAgICB9CisKKyAgICB2aXJ0dWFsIHZvaWQgYWZ0ZXJUZXN0KCkK KyAgICB7CisgICAgfQorCitwcml2YXRlOgorICAgIE1vY2tDb250ZW50TGF5ZXJEZWxlZ2F0ZSBt X2RlbGVnYXRlOworICAgIFJlZlB0cjxDb250ZW50TGF5ZXJDaHJvbWl1bVdpdGhVcGRhdGVUcmFj a2luZz4gbV91cGRhdGVDaGVja0xheWVyOworICAgIGludCBtX251bUNvbW1pdHM7Cit9OworCitU RVNUX0YoQ0NMYXllclRyZWVIb3N0VGVzdEF0b21pY0NvbW1pdCwgcnVuTXVsdGlUaHJlYWQpCit7 CisgICAgcnVuVGVzdCh0cnVlKTsKK30KKwogfSAvLyBuYW1lc3BhY2UKZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvQ29tcG9zaXRvckZha2VXZWJHcmFwaGljc0NvbnRl eHQzRC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9Db21wb3NpdG9yRmFrZVdlYkdy YXBoaWNzQ29udGV4dDNELmgKaW5kZXggZGUxNDA5YmQ0MjRiNjQ3NDNiOGY5OTkzYjNjMTcyYjhm NjBhYjUxMS4uMDc5MDYzOWQ1NzMwMTliNTU0ZDE0MWI3NDFjOGRkNjg4NjQxZGM2ZiAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9Db21wb3NpdG9yRmFrZVdlYkdyYXBo aWNzQ29udGV4dDNELmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9Db21wb3Np dG9yRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNELmgKQEAgLTQzLDcgKzQzLDcgQEAgcHVibGljOgog ICAgIHZpcnR1YWwgdm9pZCBnZXRTaGFkZXJpdihXZWJHTElkLCBXR0MzRGVudW0sIFdHQzNEaW50 KiB2YWx1ZSkgeyAqdmFsdWUgPSAxOyB9CiAgICAgdmlydHVhbCB2b2lkIGdldFByb2dyYW1pdihX ZWJHTElkLCBXR0MzRGVudW0sIFdHQzNEaW50KiB2YWx1ZSkgeyAqdmFsdWUgPSAxOyB9CiAKLXBy aXZhdGU6Citwcm90ZWN0ZWQ6CiAgICAgZXhwbGljaXQgQ29tcG9zaXRvckZha2VXZWJHcmFwaGlj c0NvbnRleHQzRChBdHRyaWJ1dGVzIGF0dHJzKQogICAgIHsKICAgICAgICAgbV9hdHRycyA9IGF0 dHJzOwo=