77155 2012-01-26 15:25:22 -0800 [chromium] GL_CHROMIUM_gpu_memory_manager extension 2012-02-17 13:41:10 -0800 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 77573 78265 1 mmocny mmocny cc-bugs dglazkov fishd jamesr loislo nduca webkit.review.bot oldest_to_newest 543555 0 mmocny 2012-01-26 15:25:22 -0800 [chromium] Adding gl extensions for addAffectedRenderWidgetById and setMemoryAllocationChangedCallback 543559 1 124191 mmocny 2012-01-26 15:26:26 -0800 Created attachment 124191 Patch 543565 2 mmocny 2012-01-26 15:28:46 -0800 Will need to wait for http://codereview.chromium.org/9289052/ work to land before this can go through. 543913 3 124191 nduca 2012-01-27 02:16:12 -0800 Comment on attachment 124191 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=124191&action=review You didn't do the Extensions3DChromium plumbing. Please do that as well in this patch. > Source/WebKit/chromium/ChangeLog:2 > + Your commit message should just be Add support for GL_xxx_CHROMIUM What is our extension? I think its one extension, GL_gpu_memory_manager_CHROMIUM > Source/WebKit/chromium/ChangeLog:21 > + (WebKit::WebGraphicsContext3D::addAffectedRenderWidgetByIdCHROMIUM): See my comments on the chrome side bug about: 1) clarifying the behavior of WGC3D::Initialize() and whether that always implies the passed-in WebView is affected if its non-null? 2) using WebViews instead of renderwidget (both in naming and argument) 3) I feel like I had a comment #3 but I forgot :/ 547395 4 125023 mmocny 2012-02-01 14:58:46 -0800 Created attachment 125023 Patch 547397 5 mmocny 2012-02-01 15:01:06 -0800 This is not finished (I am going to change the raw pointer usage to Owning/Passing pointers, etc). However, I wanted feedback specifically if it was okay to predeclare the two WebKit classes in Extensions3DChromium.h which is in WebCore. 547399 6 webkit.review.bot 2012-02-01 15:01:47 -0800 Please wait for approval from fishd@chromium.org before submitting because this patch contains changes to the Chromium public API. 547447 7 125023 webkit.review.bot 2012-02-01 15:44:18 -0800 Comment on attachment 125023 Patch Attachment 125023 did not pass chromium-ews (chromium-xvfb): Output: http://queues.webkit.org/results/11396607 547589 8 125023 jamesr 2012-02-01 19:54:42 -0800 Comment on attachment 125023 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=125023&action=review Can you put a description somewhere of what this does? > Source/WebCore/platform/graphics/chromium/Extensions3DChromium.h:97 > + virtual void addAffectedWebViewCHROMIUM(WebKit::WebView* webview); > + virtual void removeAffectedWebViewCHROMIUM(WebKit::WebView* webview); you can't talk about namespace WebKit concepts in WebCore, it's a layering violation. > Source/WebKit/chromium/public/platform/WebGpuMemoryAllocation.h:2 > + * Copyright (C) 2009 Google Inc. All rights reserved. 2012 > Source/WebKit/chromium/public/platform/WebGpuMemoryAllocation.h:8 > + * * Redistributions of source code must retain the above copyright we use 2-clause license header for new files > Source/WebKit/chromium/public/platform/WebGpuMemoryAllocation.h:37 > +#include <content/common/gpu/gpu_memory_allocation.h> this is also a layering violation. WebKit should not depend on content 548146 9 125184 mmocny 2012-02-02 13:55:11 -0800 Created attachment 125184 Patch 548151 10 nduca 2012-02-02 14:00:08 -0800 View in context: https://bugs.webkit.org/attachment.cgi?id=125023&action=review Looks close! >> Source/WebCore/platform/graphics/chromium/Extensions3DChromium.h:97 >> + virtual void removeAffectedWebViewCHROMIUM(WebKit::WebView* webview); > > you can't talk about namespace WebKit concepts in WebCore, it's a layering violation. I dont think we need these two methods exposed. The WebViewImpl is the only one that needs that, and it can do it by reaching inside the SharedGraphicsContext and calling directly into the underlyign WGC3D. > Source/WebCore/platform/graphics/chromium/Extensions3DChromium.h:100 > + virtual void onMemoryAllocationChanged(const WebKit::WebGpuMemoryAllocation&) = 0; The extensions3dchromium should define an inner struct that is the allocation. GraphicsContext3DCHromium should convert from the Web allocation to the extensions versoin. > Source/WebCore/platform/graphics/chromium/Extensions3DChromium.h:103 > + virtual void setMemoryAllocationChangedCallbackCHROMIUM(GraphicsMemoryAllocationChangedCallbackCHROMIUM*); copy the style of swapcomplete for pointer ownership >> Source/WebKit/chromium/public/platform/WebGpuMemoryAllocation.h:37 >> +#include <content/common/gpu/gpu_memory_allocation.h> > > this is also a layering violation. WebKit should not depend on content This is copying the style of WebRect.h, which does this. Thoughts, james? Barring this, or if you simply desire to make progress fast (which I think makes sense) make this structure oblivious of GpuMemoryAllocation and then in WebGraphicsContext3DCommandBufferImpl convert to its version of the struct by hand. > Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h:162 > + virtual void addAffectedWebViewCHROMIUM(WebView* webview) { } style bot is going to complain at giving this a name, just say (WebView* ) 548154 11 125184 danakj 2012-02-02 14:02:43 -0800 Comment on attachment 125184 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=125184&action=review > Source/WebKit/chromium/public/platform/WebGpuMemoryAllocation.h:2 > + * Copyright (C) 2009 Google Inc. All rights reserved. 2012 548227 12 125184 jamesr 2012-02-02 16:16:57 -0800 Comment on attachment 125184 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=125184&action=review > Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h:163 > + virtual void addAffectedWebViewCHROMIUM(WebView* webview) { } > + virtual void removeAffectedWebViewCHROMIUM(WebView* webview) { } still NACK on layering - stuff in the platform API (WK/chromium/public/platform) is not allowed to be aware of types in the client API (WK/chromium/public). This is so the implementation of the platform API, which the rest of WebKit depends on, can be built without having knowledge of the higher-level client API. Otherwise we'd have a cycle. 548231 13 jamesr 2012-02-02 16:24:18 -0800 (In reply to comment #10) > >> Source/WebKit/chromium/public/platform/WebGpuMemoryAllocation.h:37 > >> +#include <content/common/gpu/gpu_memory_allocation.h> > > > > this is also a layering violation. WebKit should not depend on content > > This is copying the style of WebRect.h, which does this. Thoughts, james? > WebRect is different, it's depending on a ui/gfx type which is very near to the lowest level of our dependency tree. That's OK, but content is right out. 30 second guide to layers we try to maintain in chromium / WebKit from top to bottom: "chrome" namespace chrome: src/chrome/** in chromium checkout, implementation of chromium browser features (like new tab page, extensions, sync) "content" namespace content: src/content/** in chromium checkout, implementation of multi-process view handling. aware of multiple processes, IPC, and how to embed WebKit but no knowledge of chromium browser features "WebKit client API" namespace WebKit: Source/WebKit/chromium/public/* in WebKit checkout, WebKit client embedding API. single-process embedding API for WebKit. isolates all chromium code from WebKit internal types. not aware of IPC "WebCore" namespace WebCore: Source/WebCore/** in WebKit checkout. implementation of all sorts of web stuff "WebKit platform API" namespace WebKit (confusing i know): Source/WebKit/chromium/public/platform/* in WebKit checkout, WebKit platform API. This is the API for all platform constructs that WebKit depends on - things like network stack, graphics stack, etc. implementations of this platform API should not depend on WebKit (and thus not depend on anything in the WebKit client API) From any layer you can depend on nearly anything below you - for example code in chrome/ or content/ can use the WebKit client API or the WebKit platform APIs directly - but you can never depend or use types from layers above you. 548344 14 mmocny 2012-02-02 18:58:09 -0800 Thanks James. I was aware of the layers down to the WebKit platform but did not understand that distinction (I thought WebCore was the lowest..). (In reply to comment #13) > (In reply to comment #10) > > >> Source/WebKit/chromium/public/platform/WebGpuMemoryAllocation.h:37 > > >> +#include <content/common/gpu/gpu_memory_allocation.h> > > > > > > this is also a layering violation. WebKit should not depend on content > > > > This is copying the style of WebRect.h, which does this. Thoughts, james? > > > > WebRect is different, it's depending on a ui/gfx type which is very near to the lowest level of our dependency tree. That's OK, but content is right out. > > 30 second guide to layers we try to maintain in chromium / WebKit from top to bottom: > > "chrome" namespace chrome: src/chrome/** in chromium checkout, implementation of chromium browser features (like new tab page, extensions, sync) > > "content" namespace content: src/content/** in chromium checkout, implementation of multi-process view handling. aware of multiple processes, IPC, and how to embed WebKit but no knowledge of chromium browser features > > "WebKit client API" namespace WebKit: Source/WebKit/chromium/public/* in WebKit checkout, WebKit client embedding API. single-process embedding API for WebKit. isolates all chromium code from WebKit internal types. not aware of IPC > > "WebCore" namespace WebCore: Source/WebCore/** in WebKit checkout. implementation of all sorts of web stuff > > "WebKit platform API" namespace WebKit (confusing i know): Source/WebKit/chromium/public/platform/* in WebKit checkout, WebKit platform API. This is the API for all platform constructs that WebKit depends on - things like network stack, graphics stack, etc. implementations of this platform API should not depend on WebKit (and thus not depend on anything in the WebKit client API) > > > > > From any layer you can depend on nearly anything below you - for example code in chrome/ or content/ can use the WebKit client API or the WebKit platform APIs directly - but you can never depend or use types from layers above you. 548741 15 125336 mmocny 2012-02-03 08:28:54 -0800 Created attachment 125336 Patch 548826 16 nduca 2012-02-03 10:29:52 -0800 James, your layering argument above neglects to acknowledge that the platform API is WiP. Right now, WebGraphicsContext3D still uses the WebView* as a method to create view contexts. It is the only way to identify views back to the embedder, at this point. We need to eventually evolve that to use some other ID, perhaps surface ids, but that plumbing isn't ready in Chrome land either. When I finish my inversion, it should be, but its not there yet. In the interm, I think that use of WebView* on WebGraphicsContext3D is an acceptable near-term violation. 548845 17 nduca 2012-02-03 10:44:27 -0800 Specifically, the way to fix this probably is to use int32 surface_id everywhere The new WebWidgetSurface class would have a surface_id accessor. WebGraphcisContext3D would be constructable with surface ids. The methods Michal is adding here would use surface ids. Doing this right now, just strikes me as a little painful. We're trying to keep this stuff cherry-pickable. 550603 18 jamesr 2012-02-06 21:30:14 -0800 I'd like to understand a bit better what this patch is trying to accomplish in order to figure out the best way to do it. We already have an association between WebGraphicsContext3D instances and WebViews for compositor contexts, via the initialization path. Is this API supposed to be used for non-compositor contexts? If so, what is the meaning of this association? I think such an association will be difficult to make in general since a single canvas 2d or webgl context can contribute to many different views, possibly at the same time. It can also contribute to views that aren't composited (consider an offscreen webgl context used for some computation). 553393 19 126345 mmocny 2012-02-09 12:03:31 -0800 Created attachment 126345 Patch 553659 20 jamesr 2012-02-09 17:55:13 -0800 I'd like to see more motivation behind the need to associated contexts with surfaces and how different sorts of contexts are intended to use this, either here or in a design doc. I don't feel as if comment #18 has been addressed sufficiently to move forward this this patch as is. 553826 21 nduca 2012-02-09 22:07:53 -0800 (In reply to comment #20) > I'd like to see more motivation behind the need to associated contexts with surfaces and how different sorts of contexts are intended to use this, either here or in a design doc. I don't feel as if comment #18 has been addressed sufficiently to move forward this this patch as is. I think your confusion is about the affected context being the same as the webview. That is definitely not the case. The issue here is the shared graphics context. That context contains resources that affect some webviews, but not others. Our goal is to free up Ganesh resources when all of the WebView's that use Ganesh are invisible [in the near term] and in the medium term, to dynamically adjust the allocation given to ganesh based on whether there is a canvas in the most immediate foreground tab versus in a background tab. To do this, we need to have a list for the shared graphics context what WebView's it affects. @twiz has a patch to do this by scanning during commit for a canvas2d layer backed by Ganesh. When such a layer exists, a post-commit hook uses this information to tell the *shared graphics context* that it affects the *compositor's context*. Hopefully this clears up why the WebViewImpl<->GraphicsContext3D association isn't valid here. Now, the reason that this patch uses surface IDs instead of pointers is about thread safety. The place where we will add/remove affected surfaces is on the main thread. Right now, it is being done in a post-commit step (see @twiz's patch). While in the very very near term, we migth make an assumpiton that the pointers are thread-safe, in the not-very-long term, I think that's an unsafe assumption. Thus, we need a way to refer from the sharedgraphicscontext to the webview's onscreen context. One layerdown the chrome-side of the graphics stack, all this webviewimpl<->renderwidgetost mappings turn into surface ids, which are plain old int32s. This thus seems like a natural way to identify things --- the WebViewImpls stores their surface_id's and then twiz's patch can hand that surface id to the shared graphics contexts whenever a webviewimpl starts having an accelerated canvas. I hope this helps. I really do think that this is the right way forward. 553832 22 126345 nduca 2012-02-09 22:16:50 -0800 Comment on attachment 126345 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=126345&action=review Unofficially this LGTM. Though, I admit that this is because I've been working on this with Michael, Twiz and so on for a while now. :) James, I hope my previous notes address your concerns sufficiently that we can get this landed. If not, I'm happy to work with you more to see what the disconnect is. piman, I hope that it is clear from my previous comments why using surface_id instead of a WebGraphicsConext3D* on the add/remove functions was done. To reiterate, my concern here is that pointer access makes the assumption that the impl-thread-side context is safely accessible. Personally, I'd prefer to avoid that assumption --- the weak-nature of the surface_id's allows that to happen. Does this make sense to you? > Source/WebCore/platform/graphics/chromium/Extensions3DChromium.h:100 > + void addAffectedSurfaceCHROMIUM(int); Surface->SurfaceID > Source/WebKit/chromium/public/WebViewClient.h:347 > + // Memory Management --------------------------------------------------- How about making an accessor on WebGraphicsContext3D for surfaceId()? > Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h:163 > + virtual void removeAffectedSurfaceCHROMIUM(int) { } Any reason for making these {} instead of pure =0? Is the intent to land this before the other side? I was leaning toward landing the chrome patches then these... 553846 23 jamesr 2012-02-09 22:25:03 -0800 (In reply to comment #21) > (In reply to comment #20) > > I'd like to see more motivation behind the need to associated contexts with surfaces and how different sorts of contexts are intended to use this, either here or in a design doc. I don't feel as if comment #18 has been addressed sufficiently to move forward this this patch as is. > > I think your confusion is about the affected context being the same as the webview. That is definitely not the case. > > The issue here is the shared graphics context. That context contains resources that affect some webviews, but not others. Our goal is to free up Ganesh resources when all of the WebView's that use Ganesh are invisible [in the near term] and in the medium term, to dynamically adjust the allocation given to ganesh based on whether there is a canvas in the most immediate foreground tab versus in a background tab. I don't think that the issue is the shared graphics context - the issue is that *every* graphics context is shared in the sense that it might contribute to many views. A single WebGL context might drive 5 tabs, for example, via drawImage(). How is that relationship represented here? What if some of the tabs are driven by a context even if that context doesn't directly contribute to the compositor in that tab (see more below)? > > To do this, we need to have a list for the shared graphics context what WebView's it affects. @twiz has a patch to do this by scanning during commit for a canvas2d layer backed by Ganesh. When such a layer exists, a post-commit hook uses this information to tell the *shared graphics context* that it affects the *compositor's context*. I don't think that is sufficient - canvas might be used in a certain web view even if it doesn't generate a layer (and in fact I think this is pretty common). For example, a WebGL game may generate some set of resources using offscreen canvases and then upload them to textures. A page might do significant work in a WebGL or canvas context that's completely offscreen, reading data back through readback mechanisms. We won't be able to detect either of these cases by examining only the compositing tree, but I think they're common enough to worry about (maps definitely does the first). To look at this from another angle, today we strongly associated compositor contexts with views (via creation). For all other contexts we express the relationship between them via share groups (ignoring pepper for the moment where we have a different sharing mechanism). Looked at from that angle, we can define a set of WebViews a context may contribute to by looking at all contexts in its share group and identifying the compositor / onscreen contexts. Then a context is fully "backgrounded" when all of the WebViews it is associated with are hidden. Today, that would have the practical effect that we treat everything in the same process as linked with everything else (because they are in the share group). I think that's a realistic view of what knowledge we have about how the contexts may be interacting with each other - if they are in the same render process, their might be JS links between them that allow for direct manipulation of each other's resources. If we can get a tighter view of exactly which WebGL contexts may have JS links with others then we can use that information to make smaller GL share groups which would also tighten up the set of contexts that are related to each view. This also has the benefit of not needing any new API since we already have API for share groups. Hope this makes sense. 554063 24 nduca 2012-02-10 07:01:51 -0800 I disagree with your point of view. Using sharegroups, a foreground plain-old-webpage in one tab would have reduced memory allocation simply because a page in the background happened to have briefly created a canvas context. That seems very wrong. I understand that you are taking a conservative route ("all contexts affect all share groups"). But, I don't understand your resistance to another API --- APIs aren't themselves costly. In this case, they give us a future avenue to be more precise in our allocations. We can in some cases attribute a canvas or webgl instance to specific context. We can't always be 100% right, but the entire memory managment scheme is suggestive, not mandatory. Mistakes are fine because the entire allocation system is based on "suggestion" not enforcement -- you can go over your allocation without penalty. I'll say it one more time: we want to give truly visible tabs the most memory they can get, *and* we want to provide an *avenue* to minimize the memory allocations given to invisible tabs. I would last-ditch propose that we go ahead with the surfacE_id approach. If in the future we decide that share groups are sufficient, we can *simplify*. Right now, I think a reductionist approach seems like the wrong way to go. 554784 25 126345 jamesr 2012-02-11 21:42:05 -0800 Comment on attachment 126345 Patch I think we'll just have to disagree for now. I appreciate the energy and passion with which you've been tackling this problem and do value your input, but in this instance I strongly feel that attempting to derive context relationships from the compositing tree is not the way to go. I suggest that we move forward with the rest of the API and see where that gets us. I think there's an orchard of low-hanging fruit to keep us busy for some time. If in the course of that we uncover new data or gain new insights we should use that to inform our direction. 555465 26 126345 mmocny 2012-02-13 12:34:00 -0800 Comment on attachment 126345 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=126345&action=review I've made changes to remove the add/removeAffectedX extension. >> Source/WebCore/platform/graphics/chromium/Extensions3DChromium.h:100 >> + void addAffectedSurfaceCHROMIUM(int); > > Surface->SurfaceID removed. >> Source/WebKit/chromium/public/WebViewClient.h:347 >> + // Memory Management --------------------------------------------------- > > How about making an accessor on WebGraphicsContext3D for surfaceId()? removed. >> Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h:163 >> + virtual void removeAffectedSurfaceCHROMIUM(int) { } > > Any reason for making these {} instead of pure =0? Is the intent to land this before the other side? I was leaning toward landing the chrome patches then these... These have been removed, however, the below set...Callback is { } and not pure because derived classes cannot predeclare WebGraphicsMemoryAllocationChangedCallbackCHROMIUM and so cannot provide an implementation without at least one WebKit patch. 555468 27 126807 mmocny 2012-02-13 12:37:46 -0800 Created attachment 126807 Patch 555575 28 126807 jamesr 2012-02-13 14:04:23 -0800 Comment on attachment 126807 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=126807&action=review > Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h:137 > + virtual ~WebGraphicsMemoryAllocationChangedCallbackCHROMIUM() { } do we expect callers to need to destroy callbacks via a WebGraphicsMemoryAllocationChangedCallbackCHROMIUM* ? for client type interfaces we often make the d'tor protected if ownership is supposed to be maintained by something with knowledge of the concrete implementation. (i see the other callbacks here follow this pattern, but i'm curious as to why) > Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h:161 > + // GL_CHROMIUM_gpu_memory_manager - sets callback for memory allocation changes. can we document what the semantics of this are? i'm not sure from this description if this is called when the amount of memory we are using changes or when the amount of memory we are supposed to use changes. > Source/WebKit/chromium/public/platform/WebGraphicsMemoryAllocation.h:34 > + unsigned int gpuResourceSizeInBytes; do we really need a struct here if it's just a single number? can we start with a number and expand as we need to? i'm guessing that we expect the set of things passed to change, but any change to this struct will require changes to both webkit and chromium since this is exposed to both so we aren't hiding too much. if this is representing a number of bytes, i think it should be a size_t. it's not hard to imagine a WebGL game using more than 4gb of gpu resources on a 64 bit machine 555577 29 jamesr 2012-02-13 14:05:14 -0800 Overall looks pretty good. I left some comments about API aesthetics. 556512 30 126807 mmocny 2012-02-14 12:53:32 -0800 Comment on attachment 126807 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=126807&action=review >> Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h:137 >> + virtual ~WebGraphicsMemoryAllocationChangedCallbackCHROMIUM() { } > > do we expect callers to need to destroy callbacks via a WebGraphicsMemoryAllocationChangedCallbackCHROMIUM* ? for client type interfaces we often make the d'tor protected if ownership is supposed to be maintained by something with knowledge of the concrete implementation. (i see the other callbacks here follow this pattern, but i'm curious as to why) We do expect clients with concrete knowledge of the implementation to maintain the ownership, so I've changed to protected, thanks for the pointer. >> Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h:161 >> + // GL_CHROMIUM_gpu_memory_manager - sets callback for memory allocation changes. > > can we document what the semantics of this are? i'm not sure from this description if this is called when the amount of memory we are using changes or when the amount of memory we are supposed to use changes. done. >> Source/WebKit/chromium/public/platform/WebGraphicsMemoryAllocation.h:34 >> + unsigned int gpuResourceSizeInBytes; > > do we really need a struct here if it's just a single number? can we start with a number and expand as we need to? i'm guessing that we expect the set of things passed to change, but any change to this struct will require changes to both webkit and chromium since this is exposed to both so we aren't hiding too much. > > if this is representing a number of bytes, i think it should be a size_t. it's not hard to imagine a WebGL game using more than 4gb of gpu resources on a 64 bit machine done. There was actually a leak here, where client was not managing ownership as it should have, which I have fixed. 556513 31 127021 mmocny 2012-02-14 12:54:23 -0800 Created attachment 127021 Patch 556535 32 127021 jamesr 2012-02-14 13:10:52 -0800 Comment on attachment 127021 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=127021&action=review R=me > Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h:135 > + virtual void onMemoryAllocationChanged(size_t gpuResourceSizeInBytes) = 0; FYI in other places in the WebKit API (but not in this file) we prefer using either willXXX() or doXXX() to make it clearer whether the callback is invoked before or after the event in question. In this case I think this should be "didMemory..." since it's an async notification. i think it's probably better to be locally consistent here and leave the name you have, but could you file a bug on these callbacks collectively not following the normal naming conventions? > Source/WebKit/chromium/public/platform/WebGraphicsContext3D.h:136 > + protected: nit: newline before 'protected', please 556551 33 127028 mmocny 2012-02-14 13:21:03 -0800 Created attachment 127028 Patch 556590 34 127028 webkit.review.bot 2012-02-14 14:11:12 -0800 Comment on attachment 127028 Patch Rejecting attachment 127028 from commit-queue. Failed to run "['/mnt/git/webkit-commit-queue/Tools/Scripts/webkit-patch', '--status-host=queues.webkit.org', '-..." exit_code: 1 ERROR: /mnt/git/webkit-commit-queue/Source/WebCore/ChangeLog neither lists a valid reviewer nor contains the string "Unreviewed" or "Rubber stamp" (case insensitive). Full output: http://queues.webkit.org/results/11521396 556636 35 127028 webkit.review.bot 2012-02-14 14:50:55 -0800 Comment on attachment 127028 Patch Rejecting attachment 127028 from commit-queue. Failed to run "['/mnt/git/webkit-commit-queue/Tools/Scripts/webkit-patch', '--status-host=queues.webkit.org', '-..." exit_code: 2 Last 500 characters of output: /ChangeLog CONFLICT (content): Merge conflict in Source/WebCore/ChangeLog Failed to merge in the changes. Patch failed at 0001 IndexedDB: Invalid dates should not be valid keys When you have resolved this problem run "git rebase --continue". If you would prefer to skip this patch, instead run "git rebase --skip". To restore the original branch and stop rebasing run "git rebase --abort". rebase refs/remotes/origin/master: command returned error: 1 Died at Tools/Scripts/update-webkit line 164. Full output: http://queues.webkit.org/results/11522410 558898 36 nduca 2012-02-16 21:43:42 -0800 @michal, are we landing this? Looks like its ready to go. 559156 37 127580 mmocny 2012-02-17 06:29:07 -0800 Created attachment 127580 Patch 559188 38 127580 webkit.review.bot 2012-02-17 07:42:11 -0800 Comment on attachment 127580 Patch Clearing flags on attachment: 127580 Committed r108071: <http://trac.webkit.org/changeset/108071> 559189 39 webkit.review.bot 2012-02-17 07:42:17 -0800 All reviewed patches have been landed. Closing bug. 559201 40 loislo 2012-02-17 08:06:32 -0800 Reverted r108071 for reason: chromium-mac compilation failed Committed r108074: <http://trac.webkit.org/changeset/108074> 559233 41 mmocny 2012-02-17 09:01:00 -0800 Fixed the compile issue (virtual keyword used where a non-virtual function was meant). Chromium-mac compiler (clang, I take it) caught the warning-as-error. 559234 42 127599 mmocny 2012-02-17 09:03:08 -0800 Created attachment 127599 Patch 559240 43 127601 mmocny 2012-02-17 09:08:26 -0800 Created attachment 127601 Patch 559490 44 127601 webkit.review.bot 2012-02-17 13:41:02 -0800 Comment on attachment 127601 Patch Clearing flags on attachment: 127601 Committed r108116: <http://trac.webkit.org/changeset/108116> 559491 45 webkit.review.bot 2012-02-17 13:41:10 -0800 All reviewed patches have been landed. Closing bug. 124191 2012-01-26 15:26:26 -0800 2012-02-01 14:58:41 -0800 Patch bug-77155-20120126182625.patch text/plain 8113 mmocny U3VidmVyc2lvbiBSZXZpc2lvbjogMTA2MDA4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IGRhOTIwZDVkMGI4YmMxZDUyNDBjZmE1ODFmYWIzN2ZhYjVjN2Q0YmIuLjQ5ZmIwYjJiNGYyNjBj ZTk3Zjk5MzI5NTZkZWI3NjZmNDAxZDc0NWEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsMzIgQEAKKzIwMTItMDEtMjYgIE1pY2hhbCBNb2NueSAgPG1tb2NueUBnb29nbGUu Y29tPgorCisgICAgICAgIFtjaHJvbWl1bV0gQWRkaW5nIGdsIGV4dGVuc2lvbnMgZm9yIGFkZEFm ZmVjdGVkUmVuZGVyV2lkZ2V0QnlJZCBhbmQgc2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxs YmFjaworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9Nzcx NTUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHB1 YmxpYy9wbGF0Zm9ybS9XZWJHcHVNZW1vcnlBbGxvY2F0aW9uLmg6IEFkZGVkLgorICAgICAgICAo V2ViS2l0KToKKyAgICAgICAgKFdlYkdwdU1lbW9yeUFsbG9jYXRpb24pOgorICAgICAgICAoV2Vi S2l0OjpXZWJHcHVNZW1vcnlBbGxvY2F0aW9uOjpXZWJHcHVNZW1vcnlBbGxvY2F0aW9uKToKKyAg ICAgICAgKFdlYktpdDo6V2ViR3B1TWVtb3J5QWxsb2NhdGlvbjo6b3BlcmF0b3I9KToKKyAgICAg ICAgKFdlYktpdDo6V2ViR3B1TWVtb3J5QWxsb2NhdGlvbjo6b3BlcmF0b3IgR3B1TWVtb3J5QWxs b2NhdGlvbik6CisgICAgICAgIChXZWJLaXQ6Om9wZXJhdG9yPT0pOgorICAgICAgICAoV2ViS2l0 OjpvcGVyYXRvciE9KToKKyAgICAgICAgKiBwdWJsaWMvcGxhdGZvcm0vV2ViR3JhcGhpY3NDb250 ZXh0M0QuaDoKKyAgICAgICAgKFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxs YmFja0NIUk9NSVVNKToKKyAgICAgICAgKFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0Q6Oldl YkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNOjp+V2ViR3Jh cGhpY3NNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAo V2ViR3JhcGhpY3NDb250ZXh0M0QpOgorICAgICAgICAoKToKKyAgICAgICAgKFdlYktpdDo6V2Vi R3JhcGhpY3NDb250ZXh0M0Q6OmFkZEFmZmVjdGVkUmVuZGVyV2lkZ2V0QnlJZENIUk9NSVVNKToK KyAgICAgICAgKFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0Q6OnJlbW92ZUFmZmVjdGVkUmVu ZGVyV2lkZ2V0QnlJZENIUk9NSVVNKToKKyAgICAgICAgKFdlYktpdDo6V2ViR3JhcGhpY3NDb250 ZXh0M0Q6OnNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6CisgICAg ICAgICogdGVzdHMvRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNELmg6CisgICAgICAgIChXZWJLaXQ6 OkZha2VXZWJHcmFwaGljc0NvbnRleHQzRDo6YWRkQWZmZWN0ZWRSZW5kZXJXaWRnZXRCeUlkQ0hS T01JVU0pOgorICAgICAgICAoV2ViS2l0OjpGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6OnJlbW92 ZUFmZmVjdGVkUmVuZGVyV2lkZ2V0QnlJZENIUk9NSVVNKToKKyAgICAgICAgKEZha2VXZWJHcmFw aGljc0NvbnRleHQzRCk6CisgICAgICAgIChXZWJLaXQ6OkZha2VXZWJHcmFwaGljc0NvbnRleHQz RDo6c2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKToKKwogMjAxMi0w MS0yNSAgR3JlZyBCaWxsb2NrICA8Z2JpbGxvY2tAZ29vZ2xlLmNvbT4KIAogICAgICAgICBBZGQg SW50ZW50UmVxdWVzdCBpbmNsdWRlIGZvciBGcmFtZUxvYWRlckNsaWVudEltcGwuCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9XZWJHcHVNZW1vcnlB bGxvY2F0aW9uLmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9XZWJH cHVNZW1vcnlBbGxvY2F0aW9uLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uZmQ1NTc3YWJjODlhZDJkNmZmYTljM2Vj NDVlOGUxMTBlYTMxN2JiMwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vcHVibGljL3BsYXRmb3JtL1dlYkdwdU1lbW9yeUFsbG9jYXRpb24uaApAQCAtMCwwICsxLDk3 IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDA5IEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVz ZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFy eSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQg cHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMgYXJlCisgKiBtZXQ6CisgKgor ICogICAgICogUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5h cnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUKKyAqIGNvcHlyaWdodCBub3RpY2UsIHRo aXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIKKyAqIGlu IHRoZSBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUKKyAqIGRpc3RyaWJ1dGlvbi4KKyAqICAgICAqIE5laXRoZXIgdGhlIG5hbWUgb2YgR29vZ2xl IEluYy4gbm9yIHRoZSBuYW1lcyBvZiBpdHMKKyAqIGNvbnRyaWJ1dG9ycyBtYXkgYmUgdXNlZCB0 byBlbmRvcnNlIG9yIHByb21vdGUgcHJvZHVjdHMgZGVyaXZlZCBmcm9tCisgKiB0aGlzIHNvZnR3 YXJlIHdpdGhvdXQgc3BlY2lmaWMgcHJpb3Igd3JpdHRlbiBwZXJtaXNzaW9uLgorICoKKyAqIFRI SVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgVEhFIENPUFlSSUdIVCBIT0xERVJTIEFORCBDT05U UklCVVRPUlMKKyAqICJBUyBJUyIgQU5EIEFOWSBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElF UywgSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRCBXQVJSQU5U SUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IKKyAqIEEgUEFSVElDVUxBUiBQ VVJQT1NFIEFSRSBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBUSEUgQ09QWVJJR0hUCisg KiBPV05FUiBPUiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVD VCwgSU5DSURFTlRBTCwKKyAqIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBE QU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9G IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLAorICogREFUQSwgT1Ig UFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04g QU5ZCisgKiBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8K KworI2lmbmRlZiBXZWJHcHVNZW1vcnlBbGxvY2F0aW9uX2gKKyNkZWZpbmUgV2ViR3B1TWVtb3J5 QWxsb2NhdGlvbl9oCisKKyNpbmNsdWRlICJXZWJDb21tb24uaCIKKworI2lmICFXRUJLSVRfSU1Q TEVNRU5UQVRJT04KKyNpbmNsdWRlIDxjb250ZW50L2NvbW1vbi9ncHUvZ3B1X21lbW9yeV9hbGxv Y2F0aW9uLmg+CisjZW5kaWYKKworbmFtZXNwYWNlIFdlYktpdCB7CisKK3N0cnVjdCBXZWJHcHVN ZW1vcnlBbGxvY2F0aW9uIHsKKyAgICBpbnQgZ3B1UmVzb3VyY2VTaXplSW5CeXRlczsKKyAgICBi b29sIGhhc0Zyb250YnVmZmVyOworICAgIGJvb2wgaGFzQmFja2J1ZmZlcjsKKworICAgIFdlYkdw dU1lbW9yeUFsbG9jYXRpb24oKQorICAgICAgICA6IGdwdVJlc291cmNlU2l6ZUluQnl0ZXMoMCkK KyAgICAgICAgLCBoYXNGcm9udGJ1ZmZlcihmYWxzZSkKKyAgICAgICAgLCBoYXNCYWNrYnVmZmVy KGZhbHNlKQorICAgIHsKKyAgICB9CisKKyAgICBXZWJHcHVNZW1vcnlBbGxvY2F0aW9uKGludCBn cHVSZXNvdXJjZVNpemVJbkJ5dGVzLCBib29sIGhhc0Zyb250YnVmZmVyLCBib29sIGhhc0JhY2ti dWZmZXIpCisgICAgICAgIDogZ3B1UmVzb3VyY2VTaXplSW5CeXRlcyhncHVSZXNvdXJjZVNpemVJ bkJ5dGVzKQorICAgICAgICAsIGhhc0Zyb250YnVmZmVyKGhhc0Zyb250YnVmZmVyKQorICAgICAg ICAsIGhhc0JhY2tidWZmZXIoaGFzQmFja2J1ZmZlcikKKyAgICB7CisgICAgfQorCisjaWYgIVdF QktJVF9JTVBMRU1FTlRBVElPTgorICAgIFdlYkdwdU1lbW9yeUFsbG9jYXRpb24oY29uc3QgR3B1 TWVtb3J5QWxsb2NhdGlvbiYgYWxsb2NhdGlvbikKKyAgICAgICAgOiBncHVSZXNvdXJjZVNpemVJ bkJ5dGVzKGFsbG9jYXRpb24uZ3B1UmVzb3VyY2VTaXplSW5CeXRlcykKKyAgICAgICAgLCBoYXNG cm9udGJ1ZmZlcihhbGxvY2F0aW9uLmhhc0Zyb250YnVmZmVyKQorICAgICAgICAsIGhhc0JhY2ti dWZmZXIoYWxsb2NhdGlvbi5oYXNCYWNrYnVmZmVyKQorICAgIHsKKyAgICB9CisKKyAgICBXZWJH cHVNZW1vcnlBbGxvY2F0aW9uJiBvcGVyYXRvcj0oY29uc3QgR3B1TWVtb3J5QWxsb2NhdGlvbiYg YWxsb2NhdGlvbikKKyAgICB7CisgICAgICAgIGdwdVJlc291cmNlU2l6ZUluQnl0ZXMgPSBhbGxv Y2F0aW9uLmdwdVJlc291cmNlU2l6ZUluQnl0ZXM7CisgICAgICAgIGhhc0Zyb250YnVmZmVyID0g YWxsb2NhdGlvbi5oYXNGcm9udGJ1ZmZlcjsKKyAgICAgICAgaGFzQmFja2J1ZmZlciA9IGFsbG9j YXRpb24uaGFzQmFja2J1ZmZlcjsKKyAgICAgICAgcmV0dXJuICp0aGlzOworICAgIH0KKworICAg IG9wZXJhdG9yIEdwdU1lbW9yeUFsbG9jYXRpb24oKSBjb25zdAorICAgIHsKKyAgICAgICAgcmV0 dXJuIEdwdU1lbW9yeUFsbG9jYXRpb24oZ3B1UmVzb3VyY2VTaXplSW5CeXRlcywgaGFzRnJvbnRi dWZmZXIsIGhhc0JhY2tidWZmZXIpOworICAgIH0KKyNlbmRpZgorfTsKKworaW5saW5lIGJvb2wg b3BlcmF0b3I9PShjb25zdCBXZWJHcHVNZW1vcnlBbGxvY2F0aW9uJiBhLCBjb25zdCBXZWJHcHVN ZW1vcnlBbGxvY2F0aW9uJiBiKQoreworICAgIHJldHVybiBhLmdwdVJlc291cmNlU2l6ZUluQnl0 ZXMgPT0gYi5ncHVSZXNvdXJjZVNpemVJbkJ5dGVzICYmIGEuaGFzRnJvbnRidWZmZXIgPT0gYi5o YXNGcm9udGJ1ZmZlciAmJiBhLmhhc0JhY2tidWZmZXIgPT0gYi5oYXNCYWNrYnVmZmVyOworfQor CitpbmxpbmUgYm9vbCBvcGVyYXRvciE9KGNvbnN0IFdlYkdwdU1lbW9yeUFsbG9jYXRpb24mIGEs IGNvbnN0IFdlYkdwdU1lbW9yeUFsbG9jYXRpb24mIGIpCit7CisgICAgcmV0dXJuICEoYSA9PSBi KTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2ViS2l0CisKKyNlbmRpZgorCmRpZmYgLS1naXQgYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRleHQz RC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViR3JhcGhpY3ND b250ZXh0M0QuaAppbmRleCBhMzFkOGI3MWExODJjYWZlYmFlMzY1ZjkyYzU5YTUyMjljNjkwNDM1 Li45OGI0MTM1ZTg5MmVkZjY1MzVjMDM2ZDRkZjRmODkxNDU0MzA4ZGNkIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRleHQz RC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdyYXBo aWNzQ29udGV4dDNELmgKQEAgLTMyLDYgKzMyLDcgQEAKICNkZWZpbmUgV2ViR3JhcGhpY3NDb250 ZXh0M0RfaAogCiAjaW5jbHVkZSAiV2ViQ29tbW9uLmgiCisjaW5jbHVkZSAiV2ViR3B1TWVtb3J5 QWxsb2NhdGlvbi5oIgogI2luY2x1ZGUgIldlYk5vbkNvcHlhYmxlLmgiCiAjaW5jbHVkZSAiV2Vi U3RyaW5nLmgiCiAKQEAgLTEyNCw2ICsxMjUsMTIgQEAgcHVibGljOgogICAgICAgICB2aXJ0dWFs IH5XZWJHcmFwaGljc1N3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVNKCkgeyB9CiAg ICAgfTsKIAorICAgIGNsYXNzIFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxs YmFja0NIUk9NSVVNIHsKKyAgICBwdWJsaWM6CisgICAgICAgIHZpcnR1YWwgdm9pZCBvbk1lbW9y eUFsbG9jYXRpb25DaGFuZ2VkKGNvbnN0IFdlYkdwdU1lbW9yeUFsbG9jYXRpb24mKSA9IDA7Cisg ICAgICAgIHZpcnR1YWwgfldlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0NIUk9NSVVNKCkgeyB9CisgICAgfTsKKwogICAgIC8vIEdyYXBoaWNzIFJlc291cmNlIFVzYWdl CiAgICAgZW51bSBSZXNvdXJjZVVzYWdlIHsKICAgICAgICAgUkVTT1VSQ0VfVVNBR0VfRlVMTCwK QEAgLTE1NSw2ICsxNjIsMTEgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBzZXRWaXNpYmls aXR5Q0hST01JVU0oYm9vbCB2aXNpYmxlKSB7IH0KICAgICB2aXJ0dWFsIHZvaWQgc2V0UmVzb3Vy Y2VVc2FnZUNIUk9NSVVNKFJlc291cmNlVXNhZ2UpIHsgfQogCisgICAgdmlydHVhbCB2b2lkIGFk ZEFmZmVjdGVkUmVuZGVyV2lkZ2V0QnlJZENIUk9NSVVNKGludCBpZCkgeyB9CisgICAgdmlydHVh bCB2b2lkIHJlbW92ZUFmZmVjdGVkUmVuZGVyV2lkZ2V0QnlJZENIUk9NSVVNKGludCBpZCkgeyB9 CisKKyAgICB2aXJ0dWFsIHZvaWQgc2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NI Uk9NSVVNKFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVN KiBjYWxsYmFjaykgeyB9CisKICAgICAvLyBRdWVyeSB3aGV0aGVyIGl0IGlzIGJ1aWx0IG9uIHRv cCBvZiBjb21wbGlhbnQgR0xFUzIgaW1wbGVtZW50YXRpb24uCiAgICAgdmlydHVhbCBib29sIGlz R0xFUzJDb21wbGlhbnQoKSA9IDA7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vdGVzdHMvRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNELmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3Rlc3RzL0Zha2VXZWJHcmFwaGljc0NvbnRleHQzRC5oCmluZGV4IDEzOGY2YjQ1M2I1ZjMy NmRkODVkNTk1MGIyMDNjOTE0MDg5ZDI0NzkuLjgzY2QyN2NmNmQyZmFiM2IzMmIyNjU4OGE4Zjc1 MzVmMWUxMjM3MTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvRmFr ZVdlYkdyYXBoaWNzQ29udGV4dDNELmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0 cy9GYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QuaApAQCAtNjUsNiArNjUsMTEgQEAgcHVibGljOgog CiAgICAgdmlydHVhbCB2b2lkIHNldFJlc291cmNlVXNhZ2VDSFJPTUlVTShSZXNvdXJjZVVzYWdl KSB7IH0KIAorICAgIHZpcnR1YWwgdm9pZCBhZGRBZmZlY3RlZFJlbmRlcldpZGdldEJ5SWRDSFJP TUlVTShpbnQgaWQpIHsgfQorICAgIHZpcnR1YWwgdm9pZCByZW1vdmVBZmZlY3RlZFJlbmRlcldp ZGdldEJ5SWRDSFJPTUlVTShpbnQgaWQpIHsgfQorCisgICAgdmlydHVhbCB2b2lkIHNldE1lbW9y eUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShXZWJHcmFwaGljc01lbW9yeUFsbG9j YXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSogY2FsbGJhY2spIHsgfQorCiAgICAgdmlydHVh bCBXZWJTdHJpbmcgZ2V0UmVxdWVzdGFibGVFeHRlbnNpb25zQ0hST01JVU0oKSB7IHJldHVybiBX ZWJTdHJpbmcoKTsgfQogICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0RXh0ZW5zaW9uQ0hST01JVU0o Y29uc3QgY2hhciopIHsgfQogCg== 125023 2012-02-01 14:58:46 -0800 2012-02-02 13:55:07 -0800 Patch bug-77155-20120201175845.patch text/plain 15998 mmocny U3VidmVyc2lvbiBSZXZpc2lvbjogMTA2NDk0CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNzhiNGNhNDljNjgwNThi OWVhNzQ0ZmUyN2ZiNDc4MzE0YzRmYjY4Yi4uYTQxNGJmMjE1NTZmOGU5NDc0NTU4MzUwNWRhMGQ4 ZmZlYzc4ZjFiZiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDEyLTAyLTAxICBNaWNo YWwgTW9jbnkgIDxtbW9jbnlAZ29vZ2xlLmNvbT4KKworICAgICAgICBbY2hyb21pdW1dIEdMX0NI Uk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9NzcxNTUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0V4dGVuc2lvbnMz RENocm9taXVtLmg6CisgICAgICAgIChXZWJLaXQpOgorICAgICAgICAoR3JhcGhpY3NNZW1vcnlB bGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAoV2ViQ29yZTo6RXh0 ZW5zaW9uczNEQ2hyb21pdW06OkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0NIUk9NSVVNOjp+R3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01J VU0pOgorICAgICAgICAoRXh0ZW5zaW9uczNEQ2hyb21pdW0pOgorCiAyMDEyLTAyLTAxICBSeW9z dWtlIE5pd2EgIDxybml3YUB3ZWJraXQub3JnPgogCiAgICAgICAgIEdjYyBidWlsZCBmaXggYWZ0 ZXIgcjEwNjQ4Mi4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9n IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggMDc0YjJkMTc4NzU2YThj MzQ3NjM0M2JjY2JlY2Q4NzYxZDZlNjE3OC4uOGRmYjQxOGUzZDk1MzNiNjA4YzMwNTM1YjU2NzE2 MTQzZjRjOWEwZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cK KysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSw0NCBAQAor MjAxMi0wMi0wMSAgTWljaGFsIE1vY255ICA8bW1vY255QGdvb2dsZS5jb20+CisKKyAgICAgICAg W2Nocm9taXVtXSBHTF9DSFJPTUlVTV9ncHVfbWVtb3J5X21hbmFnZXIKKyAgICAgICAgaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3MTU1CisKKyAgICAgICAgUmV2aWV3 ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBwdWJsaWMvcGxhdGZvcm0vV2ViR3B1 TWVtb3J5QWxsb2NhdGlvbi5oOiBBZGRlZC4KKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChX ZWJHcHVNZW1vcnlBbGxvY2F0aW9uKToKKyAgICAgICAgKFdlYktpdDo6V2ViR3B1TWVtb3J5QWxs b2NhdGlvbjo6V2ViR3B1TWVtb3J5QWxsb2NhdGlvbik6CisgICAgICAgIChXZWJLaXQ6OldlYkdw dU1lbW9yeUFsbG9jYXRpb246Om9wZXJhdG9yPSk6CisgICAgICAgIChXZWJLaXQ6OldlYkdwdU1l bW9yeUFsbG9jYXRpb246Om9wZXJhdG9yIEdwdU1lbW9yeUFsbG9jYXRpb24pOgorICAgICAgICAo V2ViS2l0OjpvcGVyYXRvcj09KToKKyAgICAgICAgKFdlYktpdDo6b3BlcmF0b3IhPSk6CisgICAg ICAgICogcHVibGljL3BsYXRmb3JtL1dlYkdyYXBoaWNzQ29udGV4dDNELmg6CisgICAgICAgIChX ZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6CisgICAg ICAgIChXZWJLaXQ6OldlYkdyYXBoaWNzQ29udGV4dDNEOjpXZWJHcmFwaGljc01lbW9yeUFsbG9j YXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTTo6fldlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlv bkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKFdlYkdyYXBoaWNzQ29udGV4dDNE KToKKyAgICAgICAgKFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0Q6OmFkZEFmZmVjdGVkV2Vi Vmlld0NIUk9NSVVNKToKKyAgICAgICAgKFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0Q6OnJl bW92ZUFmZmVjdGVkV2ViVmlld0NIUk9NSVVNKToKKyAgICAgICAgKFdlYktpdDo6V2ViR3JhcGhp Y3NDb250ZXh0M0Q6OnNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6 CisgICAgICAgICogc3JjL0V4dGVuc2lvbnMzRENocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNv cmU6OkV4dGVuc2lvbnMzRENocm9taXVtOjphZGRBZmZlY3RlZFdlYlZpZXdDSFJPTUlVTSk6Cisg ICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OkV4dGVuc2lvbnMzRENocm9taXVt OjpyZW1vdmVBZmZlY3RlZFdlYlZpZXdDSFJPTUlVTSk6CisgICAgICAgIChXZWJDb3JlOjpFeHRl bnNpb25zM0RDaHJvbWl1bTo6c2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9N SVVNKToKKyAgICAgICAgKiBzcmMvR3JhcGhpY3NDb250ZXh0M0RDaHJvbWl1bS5jcHA6CisgICAg ICAgIChXZWJDb3JlKToKKyAgICAgICAgKEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlv bkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250 ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcjo6R3JhcGhpY3NDb250 ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcik6CisgICAgICAgIChX ZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tB ZGFwdGVyOjp+R3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNr QWRhcHRlcik6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9j YXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyOjpvbk1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkKToK KyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZTo6c2V0TWVtb3J5QWxs b2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKiBzcmMvR3JhcGhpY3ND b250ZXh0M0RQcml2YXRlLmg6CisgICAgICAgICogdGVzdHMvRmFrZVdlYkdyYXBoaWNzQ29udGV4 dDNELmg6CisgICAgICAgIChXZWJLaXQ6OkZha2VXZWJHcmFwaGljc0NvbnRleHQzRDo6YWRkQWZm ZWN0ZWRXZWJWaWV3Q0hST01JVU0pOgorICAgICAgICAoV2ViS2l0OjpGYWtlV2ViR3JhcGhpY3ND b250ZXh0M0Q6OnJlbW92ZUFmZmVjdGVkV2ViVmlld0NIUk9NSVVNKToKKyAgICAgICAgKEZha2VX ZWJHcmFwaGljc0NvbnRleHQzRCk6CisgICAgICAgIChXZWJLaXQ6OkZha2VXZWJHcmFwaGljc0Nv bnRleHQzRDo6c2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKToKKwog MjAxMi0wMi0wMSAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAK ICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjEwNjM4Mi4KZGlmZiAtLWdpdCBhL1Nv dXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0V4dGVuc2lvbnMzRENocm9t aXVtLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9FeHRlbnNp b25zM0RDaHJvbWl1bS5oCmluZGV4IGUxNjQ2MDlhZTk0N2IxNmZlMTA2MmE0ZmRkNDk2ZDJhNmU0 ZTdmYTMuLjM4YTgzMzc4ZTU2YjgxMWM0ZDA3YTlkNjY2OGNlZWZkYmE5N2U2MTMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0V4dGVuc2lvbnMz RENocm9taXVtLmgKKysrIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21p dW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaApAQCAtMjgsNiArMjgsMTEgQEAKIAogI2luY2x1ZGUg IkV4dGVuc2lvbnMzRC5oIgogCituYW1lc3BhY2UgV2ViS2l0IHsKK2NsYXNzIFdlYlZpZXc7Citj bGFzcyBXZWJHcHVNZW1vcnlBbGxvY2F0aW9uOworfQorCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK IGNsYXNzIEdyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZTsKQEAgLTg3LDYgKzkyLDE2IEBAIHB1Ymxp YzoKICAgICAvLyBHTF9DSFJPTUlVTV9zZXRfdmlzaWJpbGl0eQogICAgIHZvaWQgc2V0VmlzaWJp bGl0eUNIUk9NSVVNKGJvb2wpOwogCisgICAgLy8gR0xfQ0hST01JVU1fZ3B1X21lbW9yeV9tYW5h Z2VyCisgICAgdmlydHVhbCB2b2lkIGFkZEFmZmVjdGVkV2ViVmlld0NIUk9NSVVNKFdlYktpdDo6 V2ViVmlldyogd2Vidmlldyk7CisgICAgdmlydHVhbCB2b2lkIHJlbW92ZUFmZmVjdGVkV2ViVmll d0NIUk9NSVVNKFdlYktpdDo6V2ViVmlldyogd2Vidmlldyk7CisgICAgY2xhc3MgR3JhcGhpY3NN ZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0geworICAgIHB1YmxpYzoKKyAg ICAgICAgdmlydHVhbCB2b2lkIG9uTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQoY29uc3QgV2ViS2l0 OjpXZWJHcHVNZW1vcnlBbGxvY2F0aW9uJikgPSAwOworICAgICAgICB2aXJ0dWFsIH5HcmFwaGlj c01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSgpIHsgfQorICAgIH07Cisg ICAgdmlydHVhbCB2b2lkIHNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlV TShHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSopOworCiAg ICAgLy8gR0xfQ0hST01JVU1fc3dhcGJ1ZmZlcnNfY29tcGxldGVfY2FsbGJhY2sKICAgICBjbGFz cyBTd2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJhY2tDSFJPTUlVTSB7CiAgICAgcHVibGljOgpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViR3B1TWVt b3J5QWxsb2NhdGlvbi5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0v V2ViR3B1TWVtb3J5QWxsb2NhdGlvbi5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmQwZTdiZTI3MzcwMDM0MmRiOTVl Nzc4ZjkzYjMxYWEzZTQ3MDA2MDAKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9XZWJHcHVNZW1vcnlBbGxvY2F0aW9uLmgKQEAgLTAsMCAr MSw5NyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAwOSBHb29nbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0Ogor ICoKKyAqICAgICAqIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisg KiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlCisgKiBkaXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdv b2dsZSBJbmMuIG5vciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVz ZWQgdG8gZW5kb3JzZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBz b2Z0d2FyZSB3aXRob3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQg Q09OVFJJQlVUT1JTCisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJB TlRJRVMsIElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FS UkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VM QVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdI VAorICogT1dORVIgT1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEs IE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWQorICogVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpZm5kZWYgV2ViR3B1TWVtb3J5QWxsb2NhdGlvbl9oCisjZGVmaW5lIFdlYkdwdU1l bW9yeUFsbG9jYXRpb25faAorCisjaW5jbHVkZSAiV2ViQ29tbW9uLmgiCisKKyNpZiAhV0VCS0lU X0lNUExFTUVOVEFUSU9OCisjaW5jbHVkZSA8Y29udGVudC9jb21tb24vZ3B1L2dwdV9tZW1vcnlf YWxsb2NhdGlvbi5oPgorI2VuZGlmCisKK25hbWVzcGFjZSBXZWJLaXQgeworCitzdHJ1Y3QgV2Vi R3B1TWVtb3J5QWxsb2NhdGlvbiB7CisgICAgdWludDMyX3QgZ3B1UmVzb3VyY2VTaXplSW5CeXRl czsKKyAgICBib29sIGhhc0Zyb250YnVmZmVyOworICAgIGJvb2wgaGFzQmFja2J1ZmZlcjsKKwor ICAgIFdlYkdwdU1lbW9yeUFsbG9jYXRpb24oKQorICAgICAgICA6IGdwdVJlc291cmNlU2l6ZUlu Qnl0ZXMoMCkKKyAgICAgICAgLCBoYXNGcm9udGJ1ZmZlcihmYWxzZSkKKyAgICAgICAgLCBoYXNC YWNrYnVmZmVyKGZhbHNlKQorICAgIHsKKyAgICB9CisKKyAgICBXZWJHcHVNZW1vcnlBbGxvY2F0 aW9uKHVpbnQzMl90IGdwdVJlc291cmNlU2l6ZUluQnl0ZXMsIGJvb2wgaGFzRnJvbnRidWZmZXIs IGJvb2wgaGFzQmFja2J1ZmZlcikKKyAgICAgICAgOiBncHVSZXNvdXJjZVNpemVJbkJ5dGVzKGdw dVJlc291cmNlU2l6ZUluQnl0ZXMpCisgICAgICAgICwgaGFzRnJvbnRidWZmZXIoaGFzRnJvbnRi dWZmZXIpCisgICAgICAgICwgaGFzQmFja2J1ZmZlcihoYXNCYWNrYnVmZmVyKQorICAgIHsKKyAg ICB9CisKKyNpZiAhV0VCS0lUX0lNUExFTUVOVEFUSU9OCisgICAgV2ViR3B1TWVtb3J5QWxsb2Nh dGlvbihjb25zdCBHcHVNZW1vcnlBbGxvY2F0aW9uJiBhbGxvY2F0aW9uKQorICAgICAgICA6IGdw dVJlc291cmNlU2l6ZUluQnl0ZXMoYWxsb2NhdGlvbi5ncHVSZXNvdXJjZVNpemVJbkJ5dGVzKQor ICAgICAgICAsIGhhc0Zyb250YnVmZmVyKGFsbG9jYXRpb24uaGFzRnJvbnRidWZmZXIpCisgICAg ICAgICwgaGFzQmFja2J1ZmZlcihhbGxvY2F0aW9uLmhhc0JhY2tidWZmZXIpCisgICAgeworICAg IH0KKworICAgIFdlYkdwdU1lbW9yeUFsbG9jYXRpb24mIG9wZXJhdG9yPShjb25zdCBHcHVNZW1v cnlBbGxvY2F0aW9uJiBhbGxvY2F0aW9uKQorICAgIHsKKyAgICAgICAgZ3B1UmVzb3VyY2VTaXpl SW5CeXRlcyA9IGFsbG9jYXRpb24uZ3B1UmVzb3VyY2VTaXplSW5CeXRlczsKKyAgICAgICAgaGFz RnJvbnRidWZmZXIgPSBhbGxvY2F0aW9uLmhhc0Zyb250YnVmZmVyOworICAgICAgICBoYXNCYWNr YnVmZmVyID0gYWxsb2NhdGlvbi5oYXNCYWNrYnVmZmVyOworICAgICAgICByZXR1cm4gKnRoaXM7 CisgICAgfQorCisgICAgb3BlcmF0b3IgR3B1TWVtb3J5QWxsb2NhdGlvbigpIGNvbnN0CisgICAg eworICAgICAgICByZXR1cm4gR3B1TWVtb3J5QWxsb2NhdGlvbihncHVSZXNvdXJjZVNpemVJbkJ5 dGVzLCBoYXNGcm9udGJ1ZmZlciwgaGFzQmFja2J1ZmZlcik7CisgICAgfQorI2VuZGlmCit9Owor CitpbmxpbmUgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFdlYkdwdU1lbW9yeUFsbG9jYXRpb24mIGEs IGNvbnN0IFdlYkdwdU1lbW9yeUFsbG9jYXRpb24mIGIpCit7CisgICAgcmV0dXJuIGEuZ3B1UmVz b3VyY2VTaXplSW5CeXRlcyA9PSBiLmdwdVJlc291cmNlU2l6ZUluQnl0ZXMgJiYgYS5oYXNGcm9u dGJ1ZmZlciA9PSBiLmhhc0Zyb250YnVmZmVyICYmIGEuaGFzQmFja2J1ZmZlciA9PSBiLmhhc0Jh Y2tidWZmZXI7Cit9CisKK2lubGluZSBib29sIG9wZXJhdG9yIT0oY29uc3QgV2ViR3B1TWVtb3J5 QWxsb2NhdGlvbiYgYSwgY29uc3QgV2ViR3B1TWVtb3J5QWxsb2NhdGlvbiYgYikKK3sKKyAgICBy ZXR1cm4gIShhID09IGIpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlmCisK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdy YXBoaWNzQ29udGV4dDNELmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9y bS9XZWJHcmFwaGljc0NvbnRleHQzRC5oCmluZGV4IDU3ZjlkNzk4NTNhNjU1NDllNGVhMDdjZDA5 MGVhZDg3YTQwNmQxOTIuLmQ3YzdhYjY2ZGVkOGE2MDMxNDZiOTYwZTFkYmVjMjBlNWI4YjdjMGIg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdy YXBoaWNzQ29udGV4dDNELmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxh dGZvcm0vV2ViR3JhcGhpY3NDb250ZXh0M0QuaApAQCAtMzIsNiArMzIsNyBAQAogI2RlZmluZSBX ZWJHcmFwaGljc0NvbnRleHQzRF9oCiAKICNpbmNsdWRlICJXZWJDb21tb24uaCIKKyNpbmNsdWRl ICJXZWJHcHVNZW1vcnlBbGxvY2F0aW9uLmgiCiAjaW5jbHVkZSAiV2ViTm9uQ29weWFibGUuaCIK ICNpbmNsdWRlICJXZWJTdHJpbmcuaCIKIApAQCAtMTMwLDYgKzEzMSwxMiBAQCBwdWJsaWM6CiAg ICAgICAgIHZpcnR1YWwgfldlYkdyYXBoaWNzU3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQ0hS T01JVU0oKSB7IH0KICAgICB9OwogCisgICAgY2xhc3MgV2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0 aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0geworICAgIHB1YmxpYzoKKyAgICAgICAgdmlydHVh bCB2b2lkIG9uTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQoY29uc3QgV2ViR3B1TWVtb3J5QWxsb2Nh dGlvbiYpID0gMDsKKyAgICAgICAgdmlydHVhbCB+V2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9u Q2hhbmdlZENhbGxiYWNrQ0hST01JVU0oKSB7IH0KKyAgICB9OworCiAgICAgLy8gVGhpcyBkZXN0 cnVjdG9yIG5lZWRzIHRvIGJlIHB1YmxpYyBzbyB0aGF0IHVzaW5nIGNsYXNzZXMgY2FuIGRlc3Ry b3kgaW5zdGFuY2VzIGlmIGluaXRpYWxpemF0aW9uIGZhaWxzLgogICAgIHZpcnR1YWwgfldlYkdy YXBoaWNzQ29udGV4dDNEKCkge30KIApAQCAtMTUxLDYgKzE1OCwxMyBAQCBwdWJsaWM6CiAgICAg Ly8gR0xfQ0hST01JVU1fc2V0VmlzaWJpbGl0eSAtIENoYW5nZXMgdGhlIHZpc2liaWxpdHkgb2Yg dGhlIGJhY2tidWZmZXIKICAgICB2aXJ0dWFsIHZvaWQgc2V0VmlzaWJpbGl0eUNIUk9NSVVNKGJv b2wgdmlzaWJsZSkgPSAwOwogCisgICAgLy8gR0xfQ0hST01JVU1fZ3B1X21lbW9yeV9tYW5hZ2Vy IC0gYWRkL3JlbW92ZSBXZWJWaWV3cyB1c2luZyB0aGlzIGNvbnRleHQKKyAgICB2aXJ0dWFsIHZv aWQgYWRkQWZmZWN0ZWRXZWJWaWV3Q0hST01JVU0oV2ViVmlldyogd2VidmlldykgeyB9CisgICAg dmlydHVhbCB2b2lkIHJlbW92ZUFmZmVjdGVkV2ViVmlld0NIUk9NSVVNKFdlYlZpZXcqIHdlYnZp ZXcpIHsgfQorCisgICAgLy8gR0xfQ0hST01JVU1fZ3B1X21lbW9yeV9tYW5hZ2VyIC0gc2V0IGNh bGxiYWNrIGZvciBtZW1vcnkgYWxsb2NhdGlvbiBjaGFuZ2VzCisgICAgdmlydHVhbCB2b2lkIHNl dE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShXZWJHcmFwaGljc01lbW9y eUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSogY2FsbGJhY2spIHsgfQorCiAgICAg Ly8gUXVlcnkgd2hldGhlciBpdCBpcyBidWlsdCBvbiB0b3Agb2YgY29tcGxpYW50IEdMRVMyIGlt cGxlbWVudGF0aW9uLgogICAgIHZpcnR1YWwgYm9vbCBpc0dMRVMyQ29tcGxpYW50KCkgPSAwOwog CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9FeHRlbnNpb25zM0RDaHJv bWl1bS5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9FeHRlbnNpb25zM0RDaHJvbWl1 bS5jcHAKaW5kZXggZWNlMDQwNWFlYzRmMTIwMzk1ZmVkZDFiMWMyOGViMmY0ODgxNjBjZi4uOTE2 MWUyMjI2NTVlMTM2MTRiZDFiOGNkNTE2MmM1YzE3ODliNmJiOSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdC9jaHJvbWl1bS9zcmMvRXh0ZW5zaW9uczNEQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vc3JjL0V4dGVuc2lvbnMzRENocm9taXVtLmNwcApAQCAtMTA3LDYg KzEwNywyMSBAQCB2b2lkIEV4dGVuc2lvbnMzRENocm9taXVtOjpzZXRWaXNpYmlsaXR5Q0hST01J VU0oYm9vbCB2aXNpYmlsaXR5KQogICAgIG1fcHJpdmF0ZS0+c2V0VmlzaWJpbGl0eUNIUk9NSVVN KHZpc2liaWxpdHkpOwogfQogCit2b2lkIEV4dGVuc2lvbnMzRENocm9taXVtOjphZGRBZmZlY3Rl ZFdlYlZpZXdDSFJPTUlVTShXZWJLaXQ6OldlYlZpZXcqIHdlYnZpZXcpCit7CisgICAgbV9wcml2 YXRlLT5hZGRBZmZlY3RlZFdlYlZpZXdDSFJPTUlVTSh3ZWJ2aWV3KTsKK30KKwordm9pZCBFeHRl bnNpb25zM0RDaHJvbWl1bTo6cmVtb3ZlQWZmZWN0ZWRXZWJWaWV3Q0hST01JVU0oV2ViS2l0OjpX ZWJWaWV3KiB3ZWJ2aWV3KQoreworICAgIG1fcHJpdmF0ZS0+cmVtb3ZlQWZmZWN0ZWRXZWJWaWV3 Q0hST01JVU0od2Vidmlldyk7Cit9CisKK3ZvaWQgRXh0ZW5zaW9uczNEQ2hyb21pdW06OnNldE1l bW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShHcmFwaGljc01lbW9yeUFsbG9j YXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSogY2FsbGJhY2spCit7CisgICAgbV9wcml2YXRl LT5zZXRNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oY2FsbGJhY2spOwor fQorCiBQbGF0Zm9ybTNET2JqZWN0IEV4dGVuc2lvbnMzRENocm9taXVtOjpjcmVhdGVWZXJ0ZXhB cnJheU9FUygpCiB7CiAgICAgcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRENocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0uY3BwCmluZGV4IDk0OTU4Yzk0 ZTMwZDUxNzE1NGRjODk2ZGJmNTE5ZWM1NDhkNWUzZmQuLjQyOThkMDQxZjk0OTE4YTEyNTI1MGQ3 MTRmYmUzZDM5ZWUwOGZiMzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0uY3BwCkBAIC00OCw2ICs0OCw3IEBACiAj aW5jbHVkZSAiV2ViS2l0LmgiCiAjaW5jbHVkZSAiV2ViVmlld0NsaWVudC5oIgogI2luY2x1ZGUg IldlYlZpZXdJbXBsLmgiCisjaW5jbHVkZSAicGxhdGZvcm0vV2ViR3B1TWVtb3J5QWxsb2NhdGlv bi5oIgogI2luY2x1ZGUgInBsYXRmb3JtL1dlYkdyYXBoaWNzQ29udGV4dDNELmgiCiAjaW5jbHVk ZSAicGxhdGZvcm0vV2ViS2l0UGxhdGZvcm1TdXBwb3J0LmgiCiAKQEAgLTkwNCw2ICs5MDUsOSBA QCBERUxFR0FURV9UT19JTVBMXzEodW5tYXBUZXhTdWJJbWFnZTJEQ0hST01JVU0sIGNvbnN0IHZv aWQqKQogCiBERUxFR0FURV9UT19JTVBMXzEoc2V0VmlzaWJpbGl0eUNIUk9NSVVNLCBib29sKTsK IAorREVMRUdBVEVfVE9fSU1QTF8xKGFkZEFmZmVjdGVkV2ViVmlld0NIUk9NSVVNLCBXZWJLaXQ6 OldlYlZpZXcqKTsKK0RFTEVHQVRFX1RPX0lNUExfMShyZW1vdmVBZmZlY3RlZFdlYlZpZXdDSFJP TUlVTSwgV2ViS2l0OjpXZWJWaWV3Kik7CisKIERFTEVHQVRFX1RPX0lNUExfMTAoYmxpdEZyYW1l YnVmZmVyQ0hST01JVU0sIEdDM0RpbnQsIEdDM0RpbnQsIEdDM0RpbnQsIEdDM0RpbnQsIEdDM0Rp bnQsIEdDM0RpbnQsIEdDM0RpbnQsIEdDM0RpbnQsIEdDM0RiaXRmaWVsZCwgR0MzRGVudW0pCiBE RUxFR0FURV9UT19JTVBMXzUocmVuZGVyYnVmZmVyU3RvcmFnZU11bHRpc2FtcGxlQ0hST01JVU0s IEdDM0RlbnVtLCBHQzNEc2l6ZWksIEdDM0RlbnVtLCBHQzNEc2l6ZWksIEdDM0RzaXplaSkKIApA QCAtMTM2Miw2ICsxMzY2LDI5IEBAIHZvaWQgR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlOjpzZXRT d2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJhY2tDSFJPTUlVTShQYXNzT3duUHRyCiAgICAgbV9pbXBs LT5zZXRTd2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJhY2tDSFJPTUlVTShtX3N3YXBCdWZmZXJzQ29t cGxldGVDYWxsYmFja0FkYXB0ZXIuZ2V0KCkpOwogfQogCitjbGFzcyBHcmFwaGljc0NvbnRleHQz RE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyIDogcHVibGljIFdlYktpdDo6 V2ViR3JhcGhpY3NDb250ZXh0M0Q6OldlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRD YWxsYmFja0NIUk9NSVVNIHsKK3B1YmxpYzoKKyAgICBHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFs bG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyKEV4dGVuc2lvbnMzRENocm9taXVtOjpHcmFw aGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSogY2IpCisgICAgICAg IDogbV9tZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrKGNiKQorICAgIHsKKyAgICB9CisK KyAgICB2aXJ0dWFsIH5HcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2Fs bGJhY2tBZGFwdGVyKCkgeyB9CisKKyAgICB2aXJ0dWFsIHZvaWQgb25NZW1vcnlBbGxvY2F0aW9u Q2hhbmdlZChjb25zdCBXZWJLaXQ6OldlYkdwdU1lbW9yeUFsbG9jYXRpb24mIGFsbG9jYXRpb24p CisgICAgeworICAgICAgICBpZiAobV9tZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrKQor ICAgICAgICAgICAgbV9tZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrLT5vbk1lbW9yeUFs bG9jYXRpb25DaGFuZ2VkKGFsbG9jYXRpb24pOworICAgIH0KK3ByaXZhdGU6CisgICAgRXh0ZW5z aW9uczNEQ2hyb21pdW06OkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NI Uk9NSVVNKiBtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2s7Cit9OworCit2b2lkIEdy YXBoaWNzQ29udGV4dDNEUHJpdmF0ZTo6c2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0NIUk9NSVVNKEV4dGVuc2lvbnMzRENocm9taXVtOjpHcmFwaGljc01lbW9yeUFsbG9jYXRpb25D aGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSogY2IpCit7CisgICAgbV9pbXBsLT5zZXRNZW1vcnlBbGxv Y2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0obmV3IEdyYXBoaWNzQ29udGV4dDNETWVtb3J5 QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIoY2IpKTsKK30KKwogfSAvLyBuYW1lc3Bh Y2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gRU5BQkxFKFdFQkdMKQpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlLmggYi9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRFByaXZhdGUuaAppbmRleCBmMmQ0 OWExMzJjNjQ1Yzg4YjBhMjc5MWFkMzEyM2Y1NjViOWIxMjk1Li44Y2RhOWU1NjRhZjliODgzOTJk ZjVjMDVlMmI1NTdmYzc1OWE5ZTc4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9HcmFwaGljc0NvbnRleHQzRFByaXZhdGUuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRFByaXZhdGUuaApAQCAtMjk1LDYgKzI5NSwxMSBAQCBw dWJsaWM6CiAgICAgLy8gR0xfQ0hST01JVU1fc2V0X3Zpc2liaWxpdHkKICAgICB2b2lkIHNldFZp c2liaWxpdHlDSFJPTUlVTShib29sKTsKIAorICAgIC8vIEdMX0NIUk9NSVVNX2dwdV9tZW1vcnlf bWFuYWdlcgorICAgIHZpcnR1YWwgdm9pZCBhZGRBZmZlY3RlZFdlYlZpZXdDSFJPTUlVTShXZWJL aXQ6OldlYlZpZXcqIHdlYnZpZXcpOworICAgIHZpcnR1YWwgdm9pZCByZW1vdmVBZmZlY3RlZFdl YlZpZXdDSFJPTUlVTShXZWJLaXQ6OldlYlZpZXcqIHdlYnZpZXcpOworICAgIHZpcnR1YWwgdm9p ZCBzZXRNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oRXh0ZW5zaW9uczNE Q2hyb21pdW06OkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVN Kik7CisKICAgICAvLyBHTF9DSFJPTUlVTV9mcmFtZWJ1ZmZlcl9tdWx0aXNhbXBsZQogICAgIHZv aWQgYmxpdEZyYW1lYnVmZmVyQ0hST01JVU0oR0MzRGludCBzcmNYMCwgR0MzRGludCBzcmNZMCwg R0MzRGludCBzcmNYMSwgR0MzRGludCBzcmNZMSwgR0MzRGludCBkc3RYMCwgR0MzRGludCBkc3RZ MCwgR0MzRGludCBkc3RYMSwgR0MzRGludCBkc3RZMSwgR0MzRGJpdGZpZWxkIG1hc2ssIEdDM0Rl bnVtIGZpbHRlcik7CiAgICAgdm9pZCByZW5kZXJidWZmZXJTdG9yYWdlTXVsdGlzYW1wbGVDSFJP TUlVTShHQzNEZW51bSB0YXJnZXQsIEdDM0RzaXplaSBzYW1wbGVzLCBHQzNEZW51bSBpbnRlcm5h bGZvcm1hdCwgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0KTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNELmgg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0Zha2VXZWJHcmFwaGljc0NvbnRleHQzRC5o CmluZGV4IGNmMDY1MWI3NzAzMmJkODBlNTgzYzY2ODI3NzQ2Mjg4NjA1NWRkYjguLjc4NTA3ZTlh MmU0ZTE5ZmFiYWI0MWQ3MDhkZjE2ZDU1ZDRmODQwNWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vdGVzdHMvRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNELmgKKysrIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS90ZXN0cy9GYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QuaApAQCAtNjUs NiArNjUsMTEgQEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2b2lkIHNldFZpc2liaWxpdHlDSFJP TUlVTShib29sIHZpc2libGUpIHsgfQogCisgICAgdmlydHVhbCB2b2lkIGFkZEFmZmVjdGVkV2Vi Vmlld0NIUk9NSVVNKFdlYlZpZXcqIHdlYnZpZXcpIHsgfQorICAgIHZpcnR1YWwgdm9pZCByZW1v dmVBZmZlY3RlZFdlYlZpZXdDSFJPTUlVTShXZWJWaWV3KiB3ZWJ2aWV3KSB7IH0KKworICAgIHZp cnR1YWwgdm9pZCBzZXRNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oV2Vi R3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0qIGNhbGxiYWNr KSB7IH0KKwogICAgIHZpcnR1YWwgV2ViU3RyaW5nIGdldFJlcXVlc3RhYmxlRXh0ZW5zaW9uc0NI Uk9NSVVNKCkgeyByZXR1cm4gV2ViU3RyaW5nKCk7IH0KICAgICB2aXJ0dWFsIHZvaWQgcmVxdWVz dEV4dGVuc2lvbkNIUk9NSVVNKGNvbnN0IGNoYXIqKSB7IH0KIAo= 125184 2012-02-02 13:55:11 -0800 2012-02-03 08:28:51 -0800 Patch bug-77155-20120202165510.patch text/plain 14159 mmocny U3VidmVyc2lvbiBSZXZpc2lvbjogMTA2NTU2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTU5Njc5NTIzZjcyNjNl YjY0ZGIwZTVjMWU2NThkZDc5NzgyNmE5OS4uMWMzNDU2M2FlZjBiNmIwODg5YWViZjgyOWVhYjk5 ODdiOWRjYzViYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDEyLTAyLTAyICBNaWNo YWwgTW9jbnkgIDxtbW9jbnlAZ29vZ2xlLmNvbT4KKworICAgICAgICBbY2hyb21pdW1dIEdMX0NI Uk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlcgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9NzcxNTUKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9P UFMhKS4KKworICAgICAgICAqIHBsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0V4dGVuc2lvbnMz RENocm9taXVtLmg6CisgICAgICAgIChHcHVNZW1vcnlBbGxvY2F0aW9uQ0hST01JVU0pOgorICAg ICAgICAoR3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgor ICAgICAgICAoV2ViQ29yZTo6RXh0ZW5zaW9uczNEQ2hyb21pdW06OkdyYXBoaWNzTWVtb3J5QWxs b2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNOjp+R3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9u Q2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAoRXh0ZW5zaW9uczNEQ2hyb21pdW0p OgorCiAyMDEyLTAyLTAyICBBbGxhbiBTYW5kZmVsZCBKZW5zZW4gIDxhbGxhbi5qZW5zZW5Abm9r aWEuY29tPgogCiAgICAgICAgIFVwZGF0ZSBhY3RpdmUgYW5kIGhvdmVyIHN0YXRlIG9uIHRvdWNo IHJlbGVhc2UuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBi L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IGM0N2Q2YWVkNzY1MTQ2ZWQ4 N2IwZGU5NzFiNjI3OTJmNjUwMjViMWQuLmYyOGIxOWZlMTFiZTI1MWY3MjNjODUyZDNjYmMwYTAy Y2FlNzRiZjQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisr KyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsNDAgQEAKKzIw MTItMDItMDIgIE1pY2hhbCBNb2NueSAgPG1tb2NueUBnb29nbGUuY29tPgorCisgICAgICAgIFtj aHJvbWl1bV0gR0xfQ0hST01JVU1fZ3B1X21lbW9yeV9tYW5hZ2VyCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NzE1NQorCisgICAgICAgIFJldmlld2Vk IGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogcHVibGljL3BsYXRmb3JtL1dlYkdwdU1l bW9yeUFsbG9jYXRpb24uaDogQWRkZWQuCisgICAgICAgIChXZWJLaXQpOgorICAgICAgICAoV2Vi R3B1TWVtb3J5QWxsb2NhdGlvbik6CisgICAgICAgIChXZWJLaXQ6OldlYkdwdU1lbW9yeUFsbG9j YXRpb246OldlYkdwdU1lbW9yeUFsbG9jYXRpb24pOgorICAgICAgICAoV2ViS2l0OjpvcGVyYXRv cj09KToKKyAgICAgICAgKFdlYktpdDo6b3BlcmF0b3IhPSk6CisgICAgICAgICogcHVibGljL3Bs YXRmb3JtL1dlYkdyYXBoaWNzQ29udGV4dDNELmg6CisgICAgICAgIChXZWJHcmFwaGljc01lbW9y eUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6CisgICAgICAgIChXZWJLaXQ6Oldl YkdyYXBoaWNzQ29udGV4dDNEOjpXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2Fs bGJhY2tDSFJPTUlVTTo6fldlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0NIUk9NSVVNKToKKyAgICAgICAgKFdlYkdyYXBoaWNzQ29udGV4dDNEKToKKyAgICAgICAgKFdl YktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0Q6OmFkZEFmZmVjdGVkV2ViVmlld0NIUk9NSVVNKToK KyAgICAgICAgKFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0Q6OnJlbW92ZUFmZmVjdGVkV2Vi Vmlld0NIUk9NSVVNKToKKyAgICAgICAgKFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0Q6OnNl dE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6CisgICAgICAgICogc3Jj L0V4dGVuc2lvbnMzRENocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV4dGVuc2lvbnMz RENocm9taXVtOjpzZXRNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgor ICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgICogc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21p dW0uY3BwOgorICAgICAgICAoR3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdl ZENhbGxiYWNrQWRhcHRlcik6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRE1l bW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyOjpHcmFwaGljc0NvbnRleHQzRE1l bW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyKToKKyAgICAgICAgKFdlYkNvcmU6 OkdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXI6 On5HcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVy KToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNo YW5nZWRDYWxsYmFja0FkYXB0ZXI6Om9uTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQpOgorICAgICAg ICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6 OnNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6CisgICAgICAgICog c3JjL0dyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZS5oOgorICAgICAgICAqIHRlc3RzL0Zha2VXZWJH cmFwaGljc0NvbnRleHQzRC5oOgorICAgICAgICAoV2ViS2l0OjpGYWtlV2ViR3JhcGhpY3NDb250 ZXh0M0Q6OmFkZEFmZmVjdGVkV2ViVmlld0NIUk9NSVVNKToKKyAgICAgICAgKFdlYktpdDo6RmFr ZVdlYkdyYXBoaWNzQ29udGV4dDNEOjpyZW1vdmVBZmZlY3RlZFdlYlZpZXdDSFJPTUlVTSk6Cisg ICAgICAgIChGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QpOgorICAgICAgICAoV2ViS2l0OjpGYWtl V2ViR3JhcGhpY3NDb250ZXh0M0Q6OnNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tD SFJPTUlVTSk6CisKIDIwMTItMDItMDIgIEFsbGFuIFNhbmRmZWxkIEplbnNlbiAgPGFsbGFuLmpl bnNlbkBub2tpYS5jb20+CiAKICAgICAgICAgVXBkYXRlIGVudW0gbmFtZSBmb3IgSGl0VGVzdFJl cXVlc3Q6OlJlcXVlc3RUeXBlCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9n cmFwaGljcy9jaHJvbWl1bS9FeHRlbnNpb25zM0RDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaAppbmRleCBl MTY0NjA5YWU5NDdiMTZmZTEwNjJhNGZkZDQ5NmQyYTZlNGU3ZmEzLi4xN2FmM2VmNDVmMjk0Nzdj ZDQ3MmZhZDllZDNmMTYyY2NkZjZmOWU2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0 Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9FeHRlbnNpb25zM0RDaHJvbWl1bS5oCisrKyBiL1NvdXJj ZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0V4dGVuc2lvbnMzRENocm9taXVt LmgKQEAgLTg3LDYgKzg3LDE5IEBAIHB1YmxpYzoKICAgICAvLyBHTF9DSFJPTUlVTV9zZXRfdmlz aWJpbGl0eQogICAgIHZvaWQgc2V0VmlzaWJpbGl0eUNIUk9NSVVNKGJvb2wpOwogCisgICAgLy8g R0xfQ0hST01JVU1fZ3B1X21lbW9yeV9tYW5hZ2VyCisgICAgc3RydWN0IEdwdU1lbW9yeUFsbG9j YXRpb25DSFJPTUlVTSB7CisgICAgICAgIHVpbnQzMl90IGdwdVJlc291cmNlU2l6ZUluQnl0ZXM7 CisgICAgICAgIGJvb2wgaGFzRnJvbnRidWZmZXI7CisgICAgICAgIGJvb2wgaGFzQmFja2J1ZmZl cjsKKyAgICB9OworICAgIGNsYXNzIEdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxs YmFja0NIUk9NSVVNIHsKKyAgICBwdWJsaWM6CisgICAgICAgIHZpcnR1YWwgdm9pZCBvbk1lbW9y eUFsbG9jYXRpb25DaGFuZ2VkKGNvbnN0IEdwdU1lbW9yeUFsbG9jYXRpb25DSFJPTUlVTSYpID0g MDsKKyAgICAgICAgdmlydHVhbCB+R3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxi YWNrQ0hST01JVU0oKSB7IH0KKyAgICB9OworICAgIHZpcnR1YWwgdm9pZCBzZXRNZW1vcnlBbGxv Y2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oR3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uQ2hh bmdlZENhbGxiYWNrQ0hST01JVU0qKTsKKwogICAgIC8vIEdMX0NIUk9NSVVNX3N3YXBidWZmZXJz X2NvbXBsZXRlX2NhbGxiYWNrCiAgICAgY2xhc3MgU3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNr Q0hST01JVU0gewogICAgIHB1YmxpYzoKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vcHVibGljL3BsYXRmb3JtL1dlYkdwdU1lbW9yeUFsbG9jYXRpb24uaCBiL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdwdU1lbW9yeUFsbG9jYXRpb24uaApuZXcg ZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwLi5hYjZhZDVlYzQ2MDA2ODI3OWUyODQ4ZDlmMzE2ZGViN2YwYzBmM2RkCi0tLSAvZGV2 L251bGwKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViR3B1 TWVtb3J5QWxsb2NhdGlvbi5oCkBAIC0wLDAgKzEsNzEgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMp IDIwMDkgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1 dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQK KyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dp bmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMg b2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICog ICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0 cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9k dWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlv ciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBC WSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQg QU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAq IExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFO RCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElO IE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lB TCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFdlYkdwdU1lbW9yeUFs bG9jYXRpb25faAorI2RlZmluZSBXZWJHcHVNZW1vcnlBbGxvY2F0aW9uX2gKKworI2luY2x1ZGUg IldlYkNvbW1vbi5oIgorCituYW1lc3BhY2UgV2ViS2l0IHsKKworc3RydWN0IFdlYkdwdU1lbW9y eUFsbG9jYXRpb24geworICAgIHVuc2lnbmVkIGludCBncHVSZXNvdXJjZVNpemVJbkJ5dGVzOwor ICAgIGJvb2wgaGFzRnJvbnRidWZmZXI7CisgICAgYm9vbCBoYXNCYWNrYnVmZmVyOworCisgICAg V2ViR3B1TWVtb3J5QWxsb2NhdGlvbigpCisgICAgICAgIDogZ3B1UmVzb3VyY2VTaXplSW5CeXRl cygwKQorICAgICAgICAsIGhhc0Zyb250YnVmZmVyKGZhbHNlKQorICAgICAgICAsIGhhc0JhY2ti dWZmZXIoZmFsc2UpCisgICAgeworICAgIH0KKworICAgIFdlYkdwdU1lbW9yeUFsbG9jYXRpb24o dW5zaWduZWQgaW50IGdwdVJlc291cmNlU2l6ZUluQnl0ZXMsIGJvb2wgaGFzRnJvbnRidWZmZXIs IGJvb2wgaGFzQmFja2J1ZmZlcikKKyAgICAgICAgOiBncHVSZXNvdXJjZVNpemVJbkJ5dGVzKGdw dVJlc291cmNlU2l6ZUluQnl0ZXMpCisgICAgICAgICwgaGFzRnJvbnRidWZmZXIoaGFzRnJvbnRi dWZmZXIpCisgICAgICAgICwgaGFzQmFja2J1ZmZlcihoYXNCYWNrYnVmZmVyKQorICAgIHsKKyAg ICB9Cit9OworCitpbmxpbmUgYm9vbCBvcGVyYXRvcj09KGNvbnN0IFdlYkdwdU1lbW9yeUFsbG9j YXRpb24mIGEsIGNvbnN0IFdlYkdwdU1lbW9yeUFsbG9jYXRpb24mIGIpCit7CisgICAgcmV0dXJu IGEuZ3B1UmVzb3VyY2VTaXplSW5CeXRlcyA9PSBiLmdwdVJlc291cmNlU2l6ZUluQnl0ZXMgJiYg YS5oYXNGcm9udGJ1ZmZlciA9PSBiLmhhc0Zyb250YnVmZmVyICYmIGEuaGFzQmFja2J1ZmZlciA9 PSBiLmhhc0JhY2tidWZmZXI7Cit9CisKK2lubGluZSBib29sIG9wZXJhdG9yIT0oY29uc3QgV2Vi R3B1TWVtb3J5QWxsb2NhdGlvbiYgYSwgY29uc3QgV2ViR3B1TWVtb3J5QWxsb2NhdGlvbiYgYikK K3sKKyAgICByZXR1cm4gIShhID09IGIpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJLaXQKKwor I2VuZGlmCisKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRm b3JtL1dlYkdyYXBoaWNzQ29udGV4dDNELmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1Ymxp Yy9wbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRleHQzRC5oCmluZGV4IDU3ZjlkNzk4NTNhNjU1NDll NGVhMDdjZDA5MGVhZDg3YTQwNmQxOTIuLmQ3YzdhYjY2ZGVkOGE2MDMxNDZiOTYwZTFkYmVjMjBl NWI4YjdjMGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRm b3JtL1dlYkdyYXBoaWNzQ29udGV4dDNELmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9w dWJsaWMvcGxhdGZvcm0vV2ViR3JhcGhpY3NDb250ZXh0M0QuaApAQCAtMzIsNiArMzIsNyBAQAog I2RlZmluZSBXZWJHcmFwaGljc0NvbnRleHQzRF9oCiAKICNpbmNsdWRlICJXZWJDb21tb24uaCIK KyNpbmNsdWRlICJXZWJHcHVNZW1vcnlBbGxvY2F0aW9uLmgiCiAjaW5jbHVkZSAiV2ViTm9uQ29w eWFibGUuaCIKICNpbmNsdWRlICJXZWJTdHJpbmcuaCIKIApAQCAtMTMwLDYgKzEzMSwxMiBAQCBw dWJsaWM6CiAgICAgICAgIHZpcnR1YWwgfldlYkdyYXBoaWNzU3dhcEJ1ZmZlcnNDb21wbGV0ZUNh bGxiYWNrQ0hST01JVU0oKSB7IH0KICAgICB9OwogCisgICAgY2xhc3MgV2ViR3JhcGhpY3NNZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0geworICAgIHB1YmxpYzoKKyAgICAg ICAgdmlydHVhbCB2b2lkIG9uTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQoY29uc3QgV2ViR3B1TWVt b3J5QWxsb2NhdGlvbiYpID0gMDsKKyAgICAgICAgdmlydHVhbCB+V2ViR3JhcGhpY3NNZW1vcnlB bGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oKSB7IH0KKyAgICB9OworCiAgICAgLy8g VGhpcyBkZXN0cnVjdG9yIG5lZWRzIHRvIGJlIHB1YmxpYyBzbyB0aGF0IHVzaW5nIGNsYXNzZXMg Y2FuIGRlc3Ryb3kgaW5zdGFuY2VzIGlmIGluaXRpYWxpemF0aW9uIGZhaWxzLgogICAgIHZpcnR1 YWwgfldlYkdyYXBoaWNzQ29udGV4dDNEKCkge30KIApAQCAtMTUxLDYgKzE1OCwxMyBAQCBwdWJs aWM6CiAgICAgLy8gR0xfQ0hST01JVU1fc2V0VmlzaWJpbGl0eSAtIENoYW5nZXMgdGhlIHZpc2li aWxpdHkgb2YgdGhlIGJhY2tidWZmZXIKICAgICB2aXJ0dWFsIHZvaWQgc2V0VmlzaWJpbGl0eUNI Uk9NSVVNKGJvb2wgdmlzaWJsZSkgPSAwOwogCisgICAgLy8gR0xfQ0hST01JVU1fZ3B1X21lbW9y eV9tYW5hZ2VyIC0gYWRkL3JlbW92ZSBXZWJWaWV3cyB1c2luZyB0aGlzIGNvbnRleHQKKyAgICB2 aXJ0dWFsIHZvaWQgYWRkQWZmZWN0ZWRXZWJWaWV3Q0hST01JVU0oV2ViVmlldyogd2Vidmlldykg eyB9CisgICAgdmlydHVhbCB2b2lkIHJlbW92ZUFmZmVjdGVkV2ViVmlld0NIUk9NSVVNKFdlYlZp ZXcqIHdlYnZpZXcpIHsgfQorCisgICAgLy8gR0xfQ0hST01JVU1fZ3B1X21lbW9yeV9tYW5hZ2Vy IC0gc2V0IGNhbGxiYWNrIGZvciBtZW1vcnkgYWxsb2NhdGlvbiBjaGFuZ2VzCisgICAgdmlydHVh bCB2b2lkIHNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShXZWJHcmFw aGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSogY2FsbGJhY2spIHsg fQorCiAgICAgLy8gUXVlcnkgd2hldGhlciBpdCBpcyBidWlsdCBvbiB0b3Agb2YgY29tcGxpYW50 IEdMRVMyIGltcGxlbWVudGF0aW9uLgogICAgIHZpcnR1YWwgYm9vbCBpc0dMRVMyQ29tcGxpYW50 KCkgPSAwOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9FeHRlbnNp b25zM0RDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9FeHRlbnNpb25z M0RDaHJvbWl1bS5jcHAKaW5kZXggZWNlMDQwNWFlYzRmMTIwMzk1ZmVkZDFiMWMyOGViMmY0ODgx NjBjZi4uYTc3YzEzMDVmNTNhOWJkN2NhY2U3NmM3ZGZjZGI5MGIzMjE0YTNjOCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRXh0ZW5zaW9uczNEQ2hyb21pdW0uY3BwCisr KyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0V4dGVuc2lvbnMzRENocm9taXVtLmNwcApA QCAtMTA3LDYgKzEwNywxMSBAQCB2b2lkIEV4dGVuc2lvbnMzRENocm9taXVtOjpzZXRWaXNpYmls aXR5Q0hST01JVU0oYm9vbCB2aXNpYmlsaXR5KQogICAgIG1fcHJpdmF0ZS0+c2V0VmlzaWJpbGl0 eUNIUk9NSVVNKHZpc2liaWxpdHkpOwogfQogCit2b2lkIEV4dGVuc2lvbnMzRENocm9taXVtOjpz ZXRNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oR3JhcGhpY3NNZW1vcnlB bGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0qIGNhbGxiYWNrKQoreworICAgIG1fcHJp dmF0ZS0+c2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKGNhbGxiYWNr KTsKK30KKwogUGxhdGZvcm0zRE9iamVjdCBFeHRlbnNpb25zM0RDaHJvbWl1bTo6Y3JlYXRlVmVy dGV4QXJyYXlPRVMoKQogewogICAgIHJldHVybiAwOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRENocm9taXVtLmNwcAppbmRleCA5NDk1 OGM5NGUzMGQ1MTcxNTRkYzg5NmRiZjUxOWVjNTQ4ZDVlM2ZkLi43MzI4MjNiYTFkZGQyYTMxMmJi ZTMyOWQxYmVjNWI0YTY4N2RlMzEyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9HcmFwaGljc0NvbnRleHQzRENocm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRENocm9taXVtLmNwcApAQCAtNDgsNiArNDgsNyBA QAogI2luY2x1ZGUgIldlYktpdC5oIgogI2luY2x1ZGUgIldlYlZpZXdDbGllbnQuaCIKICNpbmNs dWRlICJXZWJWaWV3SW1wbC5oIgorI2luY2x1ZGUgInBsYXRmb3JtL1dlYkdwdU1lbW9yeUFsbG9j YXRpb24uaCIKICNpbmNsdWRlICJwbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRleHQzRC5oIgogI2lu Y2x1ZGUgInBsYXRmb3JtL1dlYktpdFBsYXRmb3JtU3VwcG9ydC5oIgogCkBAIC0xMzYyLDYgKzEz NjMsMzMgQEAgdm9pZCBHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6OnNldFN3YXBCdWZmZXJzQ29t cGxldGVDYWxsYmFja0NIUk9NSVVNKFBhc3NPd25QdHIKICAgICBtX2ltcGwtPnNldFN3YXBCdWZm ZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVNKG1fc3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNr QWRhcHRlci5nZXQoKSk7CiB9CiAKK2NsYXNzIEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2Nh dGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIgOiBwdWJsaWMgV2ViS2l0OjpXZWJHcmFwaGljc0Nv bnRleHQzRDo6V2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01J VU0geworcHVibGljOgorICAgIEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0FkYXB0ZXIoRXh0ZW5zaW9uczNEQ2hyb21pdW06OkdyYXBoaWNzTWVtb3J5QWxs b2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKiBjYikKKyAgICAgICAgOiBtX21lbW9yeUFs bG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2soY2IpCisgICAgeworICAgIH0KKworICAgIHZpcnR1YWwg fkdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIo KSB7IH0KKworICAgIHZpcnR1YWwgdm9pZCBvbk1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkKGNvbnN0 IFdlYktpdDo6V2ViR3B1TWVtb3J5QWxsb2NhdGlvbiYgYWxsb2NhdGlvbikKKyAgICB7CisgICAg ICAgIEV4dGVuc2lvbnMzRENocm9taXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ0hST01JVU0gYWxs b2NhdGlvbkNocm9taXVtOworICAgICAgICBhbGxvY2F0aW9uQ2hyb21pdW0uZ3B1UmVzb3VyY2VT aXplSW5CeXRlcyA9IGFsbG9jYXRpb24uZ3B1UmVzb3VyY2VTaXplSW5CeXRlczsKKyAgICAgICAg YWxsb2NhdGlvbkNocm9taXVtLmhhc0Zyb250YnVmZmVyID0gYWxsb2NhdGlvbi5oYXNGcm9udGJ1 ZmZlcjsKKyAgICAgICAgYWxsb2NhdGlvbkNocm9taXVtLmhhc0JhY2tidWZmZXIgPSBhbGxvY2F0 aW9uLmhhc0JhY2tidWZmZXI7CisgICAgICAgIGlmIChtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2Vk Q2FsbGJhY2spCisgICAgICAgICAgICBtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2st Pm9uTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQoYWxsb2NhdGlvbkNocm9taXVtKTsKKyAgICB9Citw cml2YXRlOgorICAgIEV4dGVuc2lvbnMzRENocm9taXVtOjpHcmFwaGljc01lbW9yeUFsbG9jYXRp b25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSogbV9tZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxi YWNrOworfTsKKwordm9pZCBHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6OnNldE1lbW9yeUFsbG9j YXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShFeHRlbnNpb25zM0RDaHJvbWl1bTo6R3JhcGhp Y3NNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0qIGNiKQoreworICAgIG1f aW1wbC0+c2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKG5ldyBHcmFw aGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyKGNiKSk7 Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIEVOQUJMRShXRUJHTCkK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNE UHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RQ cml2YXRlLmgKaW5kZXggZjJkNDlhMTMyYzY0NWM4OGIwYTI3OTFhZDMxMjNmNTY1YjliMTI5NS4u ODc2YWYxNjJhZDAwYTlmZTgzY2U3ZTFjNThhMDZiZWFmYTI5MDIxOCAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlLmgKKysrIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlLmgKQEAg LTI5NSw2ICsyOTUsOSBAQCBwdWJsaWM6CiAgICAgLy8gR0xfQ0hST01JVU1fc2V0X3Zpc2liaWxp dHkKICAgICB2b2lkIHNldFZpc2liaWxpdHlDSFJPTUlVTShib29sKTsKIAorICAgIC8vIEdMX0NI Uk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlcgorICAgIHZpcnR1YWwgdm9pZCBzZXRNZW1vcnlBbGxv Y2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oRXh0ZW5zaW9uczNEQ2hyb21pdW06OkdyYXBo aWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKik7CisKICAgICAvLyBH TF9DSFJPTUlVTV9mcmFtZWJ1ZmZlcl9tdWx0aXNhbXBsZQogICAgIHZvaWQgYmxpdEZyYW1lYnVm ZmVyQ0hST01JVU0oR0MzRGludCBzcmNYMCwgR0MzRGludCBzcmNZMCwgR0MzRGludCBzcmNYMSwg R0MzRGludCBzcmNZMSwgR0MzRGludCBkc3RYMCwgR0MzRGludCBkc3RZMCwgR0MzRGludCBkc3RY MSwgR0MzRGludCBkc3RZMSwgR0MzRGJpdGZpZWxkIG1hc2ssIEdDM0RlbnVtIGZpbHRlcik7CiAg ICAgdm9pZCByZW5kZXJidWZmZXJTdG9yYWdlTXVsdGlzYW1wbGVDSFJPTUlVTShHQzNEZW51bSB0 YXJnZXQsIEdDM0RzaXplaSBzYW1wbGVzLCBHQzNEZW51bSBpbnRlcm5hbGZvcm1hdCwgR0MzRHNp emVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vdGVzdHMvRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNELmggYi9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3Rlc3RzL0Zha2VXZWJHcmFwaGljc0NvbnRleHQzRC5oCmluZGV4IGNmMDY1MWI3 NzAzMmJkODBlNTgzYzY2ODI3NzQ2Mjg4NjA1NWRkYjguLjc4NTA3ZTlhMmU0ZTE5ZmFiYWI0MWQ3 MDhkZjE2ZDU1ZDRmODQwNWMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVz dHMvRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNELmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1 bS90ZXN0cy9GYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QuaApAQCAtNjUsNiArNjUsMTEgQEAgcHVi bGljOgogCiAgICAgdmlydHVhbCB2b2lkIHNldFZpc2liaWxpdHlDSFJPTUlVTShib29sIHZpc2li bGUpIHsgfQogCisgICAgdmlydHVhbCB2b2lkIGFkZEFmZmVjdGVkV2ViVmlld0NIUk9NSVVNKFdl YlZpZXcqIHdlYnZpZXcpIHsgfQorICAgIHZpcnR1YWwgdm9pZCByZW1vdmVBZmZlY3RlZFdlYlZp ZXdDSFJPTUlVTShXZWJWaWV3KiB3ZWJ2aWV3KSB7IH0KKworICAgIHZpcnR1YWwgdm9pZCBzZXRN ZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oV2ViR3JhcGhpY3NNZW1vcnlB bGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0qIGNhbGxiYWNrKSB7IH0KKwogICAgIHZp cnR1YWwgV2ViU3RyaW5nIGdldFJlcXVlc3RhYmxlRXh0ZW5zaW9uc0NIUk9NSVVNKCkgeyByZXR1 cm4gV2ViU3RyaW5nKCk7IH0KICAgICB2aXJ0dWFsIHZvaWQgcmVxdWVzdEV4dGVuc2lvbkNIUk9N SVVNKGNvbnN0IGNoYXIqKSB7IH0KIAo= 125336 2012-02-03 08:28:54 -0800 2012-02-09 12:03:27 -0800 Patch bug-77155-20120203112853.patch text/plain 10984 mmocny U3VidmVyc2lvbiBSZXZpc2lvbjogMTA2NjU5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYzJkNjVhODAxMDNmMjll MDgzOWExNjFmYjA0ODNkNzc3MjJjZDlkOS4uMDQ0OWZkYjc2ZTQxNzlmOTM5NmRkMGE3NzRhNjg5 ZGJjYWY0MGMyOSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDEyLTAyLTAzICBNaWNo YWwgTW9jbnkgIDxtbW9jbnlAZ29vZ2xlLmNvbT4KKworICAgICAgICBbY2hyb21pdW1dIEdMX0NI Uk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlciBleHRlbnNpb24KKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3MTU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgTm8gbmV3IHRlc3RzLiAoT09QUyEpCisKKyAgICAg ICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9FeHRlbnNpb25zM0RDaHJvbWl1bS5oOgor ICAgICAgICAoR3B1TWVtb3J5QWxsb2NhdGlvbkNIUk9NSVVNKToKKyAgICAgICAgKEdwdU1lbW9y eUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6CisgICAgICAgIChXZWJDb3JlOjpF eHRlbnNpb25zM0RDaHJvbWl1bTo6R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NI Uk9NSVVNOjp+R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKToKKyAg ICAgICAgKEV4dGVuc2lvbnMzRENocm9taXVtKToKKwogMjAxMi0wMi0wMyAgTm8nYW0gUm9zZW50 aGFsICA8bm9hbS5yb3NlbnRoYWxAbm9raWEuY29tPgogCiAgICAgICAgIFtRdF1bVGV4bWFwXSBS ZWZhY3RvciBUZXh0dXJlTWFwcGVyIEFQSSB0byB1c2UgSW1hZ2VCdWZmZXJzIHdoZW4gcG9zc2li bGUuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IGJmZjNhZGY0OWI1YzMyZjI2N2U1MTlm MzI5ZjFjNzA2ZjNjOTM2YjEuLjIyODZmZDFhYmEwNWVkMDJlODJhOTlmYjllODJjYTUyMDM3ZDUz N2YgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzQgQEAKKzIwMTItMDIt MDMgIE1pY2hhbCBNb2NueSAgPG1tb2NueUBnb29nbGUuY29tPgorCisgICAgICAgIFtjaHJvbWl1 bV0gR0xfQ0hST01JVU1fZ3B1X21lbW9yeV9tYW5hZ2VyIGV4dGVuc2lvbgorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzcxNTUKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHB1YmxpYy9wbGF0Zm9ybS9XZWJH cmFwaGljc0NvbnRleHQzRC5oOgorICAgICAgICAoV2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9u Q2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAoV2ViS2l0OjpXZWJHcmFwaGljc0Nv bnRleHQzRDo6V2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01J VU06On5XZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6 CisgICAgICAgIChXZWJHcmFwaGljc0NvbnRleHQzRCk6CisgICAgICAgIChXZWJLaXQ6OldlYkdy YXBoaWNzQ29udGV4dDNEOjphZGRBZmZlY3RlZFdlYlZpZXdDSFJPTUlVTSk6CisgICAgICAgIChX ZWJLaXQ6OldlYkdyYXBoaWNzQ29udGV4dDNEOjpyZW1vdmVBZmZlY3RlZFdlYlZpZXdDSFJPTUlV TSk6CisgICAgICAgIChXZWJLaXQ6OldlYkdyYXBoaWNzQ29udGV4dDNEOjpzZXRNZW1vcnlBbGxv Y2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAqIHNyYy9FeHRlbnNpb25z M0RDaHJvbWl1bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpFeHRlbnNpb25zM0RDaHJvbWl1bTo6 c2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAg KFdlYkNvcmUpOgorICAgICAgICAqIHNyYy9HcmFwaGljc0NvbnRleHQzRENocm9taXVtLmNwcDoK KyAgICAgICAgKEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0FkYXB0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxv Y2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcjo6R3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxv Y2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcik6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGlj c0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyOjp+R3JhcGhp Y3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcik6CisgICAg ICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2Fs bGJhY2tBZGFwdGVyOjpvbk1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkKToKKyAgICAgICAgKFdlYkNv cmUpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0RQcml2YXRlOjpzZXRHcHVN ZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAqIHNyYy9H cmFwaGljc0NvbnRleHQzRFByaXZhdGUuaDoKKyAgICAgICAgKiB0ZXN0cy9GYWtlV2ViR3JhcGhp Y3NDb250ZXh0M0QuaDoKKyAgICAgICAgKFdlYktpdDo6RmFrZVdlYkdyYXBoaWNzQ29udGV4dDNE OjphZGRBZmZlY3RlZFdlYlZpZXdDSFJPTUlVTSk6CisgICAgICAgIChXZWJLaXQ6OkZha2VXZWJH cmFwaGljc0NvbnRleHQzRDo6cmVtb3ZlQWZmZWN0ZWRXZWJWaWV3Q0hST01JVU0pOgorICAgICAg ICAoRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEKToKKyAgICAgICAgKFdlYktpdDo6RmFrZVdlYkdy YXBoaWNzQ29udGV4dDNEOjpzZXRNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01J VU0pOgorCiAyMDEyLTAyLTAzICBZdXJ5IFNlbWlraGF0c2t5ICA8eXVyeXNAY2hyb21pdW0ub3Jn PgogCiAgICAgICAgIFVucmV2aWV3ZWQuIFVwZGF0ZSBDaHJvbWl1bSBkZXBzLgpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vRXh0ZW5zaW9uczNE Q2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0V4 dGVuc2lvbnMzRENocm9taXVtLmgKaW5kZXggZTE2NDYwOWFlOTQ3YjE2ZmUxMDYyYTRmZGQ0OTZk MmE2ZTRlN2ZhMy4uZGNhZWQ5MzhiM2Y2YTIwOGFhNjYzMjI2ZTdkYjFlNDBhYmQyMjcwMSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vRXh0ZW5z aW9uczNEQ2hyb21pdW0uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9j aHJvbWl1bS9FeHRlbnNpb25zM0RDaHJvbWl1bS5oCkBAIC04Nyw2ICs4NywxOSBAQCBwdWJsaWM6 CiAgICAgLy8gR0xfQ0hST01JVU1fc2V0X3Zpc2liaWxpdHkKICAgICB2b2lkIHNldFZpc2liaWxp dHlDSFJPTUlVTShib29sKTsKIAorICAgIC8vIEdMX0NIUk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdl cgorICAgIHN0cnVjdCBHcHVNZW1vcnlBbGxvY2F0aW9uQ0hST01JVU0geworICAgICAgICB1aW50 MzJfdCBncHVSZXNvdXJjZVNpemVJbkJ5dGVzOworICAgICAgICBib29sIGhhc0Zyb250YnVmZmVy OworICAgICAgICBib29sIGhhc0JhY2tidWZmZXI7CisgICAgfTsKKyAgICBjbGFzcyBHcHVNZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0geworICAgIHB1YmxpYzoKKyAgICAg ICAgdmlydHVhbCB2b2lkIG9uR3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQoY29uc3QgR3B1TWVt b3J5QWxsb2NhdGlvbkNIUk9NSVVNJikgPSAwOworICAgICAgICB2aXJ0dWFsIH5HcHVNZW1vcnlB bGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oKSB7IH0KKyAgICB9OworICAgIHZpcnR1 YWwgdm9pZCBzZXRHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oUGFz c093blB0cjxHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0+KTsKKwog ICAgIC8vIEdMX0NIUk9NSVVNX3N3YXBidWZmZXJzX2NvbXBsZXRlX2NhbGxiYWNrCiAgICAgY2xh c3MgU3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQ0hST01JVU0gewogICAgIHB1YmxpYzoKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdyYXBo aWNzQ29udGV4dDNELmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9X ZWJHcmFwaGljc0NvbnRleHQzRC5oCmluZGV4IDU3ZjlkNzk4NTNhNjU1NDllNGVhMDdjZDA5MGVh ZDg3YTQwNmQxOTIuLmJhOWUyNDdhNzQ4NTUwZGI5ZGFhZDI0YWRiYjExYzYyMzM2ZWIzNTAgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdyYXBo aWNzQ29udGV4dDNELmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZv cm0vV2ViR3JhcGhpY3NDb250ZXh0M0QuaApAQCAtMzIsNiArMzIsNyBAQAogI2RlZmluZSBXZWJH cmFwaGljc0NvbnRleHQzRF9oCiAKICNpbmNsdWRlICJXZWJDb21tb24uaCIKKyNpbmNsdWRlICJX ZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb24uaCIKICNpbmNsdWRlICJXZWJOb25Db3B5YWJsZS5o IgogI2luY2x1ZGUgIldlYlN0cmluZy5oIgogCkBAIC0xMzAsNiArMTMxLDEyIEBAIHB1YmxpYzoK ICAgICAgICAgdmlydHVhbCB+V2ViR3JhcGhpY3NTd2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJhY2tD SFJPTUlVTSgpIHsgfQogICAgIH07CiAKKyAgICBjbGFzcyBXZWJHcmFwaGljc01lbW9yeUFsbG9j YXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSB7CisgICAgcHVibGljOgorICAgICAgICB2aXJ0 dWFsIHZvaWQgb25NZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZChjb25zdCBXZWJHcmFwaGljc01lbW9y eUFsbG9jYXRpb24mKSA9IDA7CisgICAgICAgIHZpcnR1YWwgfldlYkdyYXBoaWNzTWVtb3J5QWxs b2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKCkgeyB9CisgICAgfTsKKwogICAgIC8vIFRo aXMgZGVzdHJ1Y3RvciBuZWVkcyB0byBiZSBwdWJsaWMgc28gdGhhdCB1c2luZyBjbGFzc2VzIGNh biBkZXN0cm95IGluc3RhbmNlcyBpZiBpbml0aWFsaXphdGlvbiBmYWlscy4KICAgICB2aXJ0dWFs IH5XZWJHcmFwaGljc0NvbnRleHQzRCgpIHt9CiAKQEAgLTE1MSw2ICsxNTgsMTMgQEAgcHVibGlj OgogICAgIC8vIEdMX0NIUk9NSVVNX3NldFZpc2liaWxpdHkgLSBDaGFuZ2VzIHRoZSB2aXNpYmls aXR5IG9mIHRoZSBiYWNrYnVmZmVyCiAgICAgdmlydHVhbCB2b2lkIHNldFZpc2liaWxpdHlDSFJP TUlVTShib29sIHZpc2libGUpID0gMDsKIAorICAgIC8vIEdMX0NIUk9NSVVNX2dwdV9tZW1vcnlf bWFuYWdlciAtIGFkZC9yZW1vdmUgV2ViVmlld3MgdXNpbmcgdGhpcyBjb250ZXh0CisgICAgdmly dHVhbCB2b2lkIGFkZEFmZmVjdGVkV2ViVmlld0NIUk9NSVVNKFdlYlZpZXcqKSB7IH0KKyAgICB2 aXJ0dWFsIHZvaWQgcmVtb3ZlQWZmZWN0ZWRXZWJWaWV3Q0hST01JVU0oV2ViVmlldyopIHsgfQor CisgICAgLy8gR0xfQ0hST01JVU1fZ3B1X21lbW9yeV9tYW5hZ2VyIC0gc2V0IGNhbGxiYWNrIGZv ciBtZW1vcnkgYWxsb2NhdGlvbiBjaGFuZ2VzCisgICAgdmlydHVhbCB2b2lkIHNldE1lbW9yeUFs bG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRp b25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSogY2FsbGJhY2spIHsgfQorCiAgICAgLy8gUXVlcnkg d2hldGhlciBpdCBpcyBidWlsdCBvbiB0b3Agb2YgY29tcGxpYW50IEdMRVMyIGltcGxlbWVudGF0 aW9uLgogICAgIHZpcnR1YWwgYm9vbCBpc0dMRVMyQ29tcGxpYW50KCkgPSAwOwogCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9FeHRlbnNpb25zM0RDaHJvbWl1bS5jcHAg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9FeHRlbnNpb25zM0RDaHJvbWl1bS5jcHAKaW5k ZXggZWNlMDQwNWFlYzRmMTIwMzk1ZmVkZDFiMWMyOGViMmY0ODgxNjBjZi4uNzMzOTdiZDJiMTZh N2NjY2ZhMTgyYmExMjc2OGRhMGM3YTU4NzZkYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvRXh0ZW5zaW9uczNEQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL0V4dGVuc2lvbnMzRENocm9taXVtLmNwcApAQCAtMTA3LDYgKzEwNywxMSBA QCB2b2lkIEV4dGVuc2lvbnMzRENocm9taXVtOjpzZXRWaXNpYmlsaXR5Q0hST01JVU0oYm9vbCB2 aXNpYmlsaXR5KQogICAgIG1fcHJpdmF0ZS0+c2V0VmlzaWJpbGl0eUNIUk9NSVVNKHZpc2liaWxp dHkpOwogfQogCit2b2lkIEV4dGVuc2lvbnMzRENocm9taXVtOjpzZXRHcHVNZW1vcnlBbGxvY2F0 aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oUGFzc093blB0cjxHcHVNZW1vcnlBbGxvY2F0aW9u Q2hhbmdlZENhbGxiYWNrQ0hST01JVU0+IGNhbGxiYWNrKQoreworICAgIG1fcHJpdmF0ZS0+c2V0 R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKGNhbGxiYWNrKTsKK30K KwogUGxhdGZvcm0zRE9iamVjdCBFeHRlbnNpb25zM0RDaHJvbWl1bTo6Y3JlYXRlVmVydGV4QXJy YXlPRVMoKQogewogICAgIHJldHVybiAwOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRENocm9taXVtLmNwcAppbmRleCA5NDk1OGM5NGUz MGQ1MTcxNTRkYzg5NmRiZjUxOWVjNTQ4ZDVlM2ZkLi42ZWFiOTY2ZGIwZDIwOTEwNjU2OGI5YzNi NWU0MTFjZWYyZGZkODM3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9H cmFwaGljc0NvbnRleHQzRENocm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9HcmFwaGljc0NvbnRleHQzRENocm9taXVtLmNwcApAQCAtNDgsNiArNDgsNyBAQAogI2lu Y2x1ZGUgIldlYktpdC5oIgogI2luY2x1ZGUgIldlYlZpZXdDbGllbnQuaCIKICNpbmNsdWRlICJX ZWJWaWV3SW1wbC5oIgorI2luY2x1ZGUgInBsYXRmb3JtL1dlYkdyYXBoaWNzTWVtb3J5QWxsb2Nh dGlvbi5oIgogI2luY2x1ZGUgInBsYXRmb3JtL1dlYkdyYXBoaWNzQ29udGV4dDNELmgiCiAjaW5j bHVkZSAicGxhdGZvcm0vV2ViS2l0UGxhdGZvcm1TdXBwb3J0LmgiCiAKQEAgLTEzNjIsNiArMTM2 MywzMyBAQCB2b2lkIEdyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZTo6c2V0U3dhcEJ1ZmZlcnNDb21w bGV0ZUNhbGxiYWNrQ0hST01JVU0oUGFzc093blB0cgogICAgIG1faW1wbC0+c2V0U3dhcEJ1ZmZl cnNDb21wbGV0ZUNhbGxiYWNrQ0hST01JVU0obV9zd2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJhY2tB ZGFwdGVyLmdldCgpKTsKIH0KIAorY2xhc3MgR3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0 aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlciA6IHB1YmxpYyBXZWJLaXQ6OldlYkdyYXBoaWNzQ29u dGV4dDNEOjpXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlV TSB7CitwdWJsaWM6CisgICAgR3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdl ZENhbGxiYWNrQWRhcHRlcihQYXNzT3duUHRyPEV4dGVuc2lvbnMzRENocm9taXVtOjpHcHVNZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0+IGNiKQorICAgICAgICA6IG1fbWVt b3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFjayhjYikKKyAgICB7CisgICAgfQorCisgICAgdmly dHVhbCB+R3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRh cHRlcigpIHsgfQorCisgICAgdmlydHVhbCB2b2lkIG9uTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQo Y29uc3QgV2ViS2l0OjpXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb24mIGFsbG9jYXRpb24pCisg ICAgeworICAgICAgICBFeHRlbnNpb25zM0RDaHJvbWl1bTo6R3B1TWVtb3J5QWxsb2NhdGlvbkNI Uk9NSVVNIGFsbG9jYXRpb25DaHJvbWl1bTsKKyAgICAgICAgYWxsb2NhdGlvbkNocm9taXVtLmdw dVJlc291cmNlU2l6ZUluQnl0ZXMgPSBhbGxvY2F0aW9uLmdwdVJlc291cmNlU2l6ZUluQnl0ZXM7 CisgICAgICAgIGFsbG9jYXRpb25DaHJvbWl1bS5oYXNGcm9udGJ1ZmZlciA9IGFsbG9jYXRpb24u aGFzRnJvbnRidWZmZXI7CisgICAgICAgIGFsbG9jYXRpb25DaHJvbWl1bS5oYXNCYWNrYnVmZmVy ID0gYWxsb2NhdGlvbi5oYXNCYWNrYnVmZmVyOworICAgICAgICBpZiAobV9tZW1vcnlBbGxvY2F0 aW9uQ2hhbmdlZENhbGxiYWNrKQorICAgICAgICAgICAgbV9tZW1vcnlBbGxvY2F0aW9uQ2hhbmdl ZENhbGxiYWNrLT5vbkdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkKGFsbG9jYXRpb25DaHJvbWl1 bSk7CisgICAgfQorcHJpdmF0ZToKKyAgICBPd25QdHI8RXh0ZW5zaW9uczNEQ2hyb21pdW06Okdw dU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTT4gbV9tZW1vcnlBbGxvY2F0 aW9uQ2hhbmdlZENhbGxiYWNrOworfTsKKwordm9pZCBHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6 OnNldEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShQYXNzT3duUHRy PEV4dGVuc2lvbnMzRENocm9taXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNr Q0hST01JVU0+IGNiKQoreworICAgIG1faW1wbC0+c2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRD YWxsYmFja0NIUk9NSVVNKG5ldyBHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFu Z2VkQ2FsbGJhY2tBZGFwdGVyKGNiKSk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAog I2VuZGlmIC8vIEVOQUJMRShXRUJHTCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlLmgKaW5kZXggZjJkNDlhMTMyYzY0NWM4OGIw YTI3OTFhZDMxMjNmNTY1YjliMTI5NS4uYzczZmNkZDJjOTdiM2JjMjk0ZGNiYjBiMGQzMTQ1N2M0 NzMyNWI3NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3ND b250ZXh0M0RQcml2YXRlLmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhp Y3NDb250ZXh0M0RQcml2YXRlLmgKQEAgLTI5NSw2ICsyOTUsOSBAQCBwdWJsaWM6CiAgICAgLy8g R0xfQ0hST01JVU1fc2V0X3Zpc2liaWxpdHkKICAgICB2b2lkIHNldFZpc2liaWxpdHlDSFJPTUlV TShib29sKTsKIAorICAgIC8vIEdMX0NIUk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlcgorICAgIHZp cnR1YWwgdm9pZCBzZXRHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0o UGFzc093blB0cjxFeHRlbnNpb25zM0RDaHJvbWl1bTo6R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0NIUk9NSVVNPik7CisKICAgICAvLyBHTF9DSFJPTUlVTV9mcmFtZWJ1ZmZlcl9t dWx0aXNhbXBsZQogICAgIHZvaWQgYmxpdEZyYW1lYnVmZmVyQ0hST01JVU0oR0MzRGludCBzcmNY MCwgR0MzRGludCBzcmNZMCwgR0MzRGludCBzcmNYMSwgR0MzRGludCBzcmNZMSwgR0MzRGludCBk c3RYMCwgR0MzRGludCBkc3RZMCwgR0MzRGludCBkc3RYMSwgR0MzRGludCBkc3RZMSwgR0MzRGJp dGZpZWxkIG1hc2ssIEdDM0RlbnVtIGZpbHRlcik7CiAgICAgdm9pZCByZW5kZXJidWZmZXJTdG9y YWdlTXVsdGlzYW1wbGVDSFJPTUlVTShHQzNEZW51bSB0YXJnZXQsIEdDM0RzaXplaSBzYW1wbGVz LCBHQzNEZW51bSBpbnRlcm5hbGZvcm1hdCwgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVp Z2h0KTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvRmFrZVdlYkdy YXBoaWNzQ29udGV4dDNELmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0Zha2VXZWJH cmFwaGljc0NvbnRleHQzRC5oCmluZGV4IGNmMDY1MWI3NzAzMmJkODBlNTgzYzY2ODI3NzQ2Mjg4 NjA1NWRkYjguLjQ2NWJlMTAwOTZhODZkMGM3MzYxMTM2MTc4ZDMzZjUzZWIxZjc2MDMgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvRmFrZVdlYkdyYXBoaWNzQ29udGV4 dDNELmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9GYWtlV2ViR3JhcGhpY3ND b250ZXh0M0QuaApAQCAtNjUsNiArNjUsMTEgQEAgcHVibGljOgogCiAgICAgdmlydHVhbCB2b2lk IHNldFZpc2liaWxpdHlDSFJPTUlVTShib29sIHZpc2libGUpIHsgfQogCisgICAgdmlydHVhbCB2 b2lkIGFkZEFmZmVjdGVkV2ViVmlld0NIUk9NSVVNKFdlYlZpZXcqKSB7IH0KKyAgICB2aXJ0dWFs IHZvaWQgcmVtb3ZlQWZmZWN0ZWRXZWJWaWV3Q0hST01JVU0oV2ViVmlldyopIHsgfQorCisgICAg dmlydHVhbCB2b2lkIHNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShX ZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSogY2FsbGJh Y2spIHsgfQorCiAgICAgdmlydHVhbCBXZWJTdHJpbmcgZ2V0UmVxdWVzdGFibGVFeHRlbnNpb25z Q0hST01JVU0oKSB7IHJldHVybiBXZWJTdHJpbmcoKTsgfQogICAgIHZpcnR1YWwgdm9pZCByZXF1 ZXN0RXh0ZW5zaW9uQ0hST01JVU0oY29uc3QgY2hhciopIHsgfQogCg== 126345 2012-02-09 12:03:31 -0800 2012-02-13 12:37:42 -0800 Patch bug-77155-20120209150329.patch text/plain 16765 mmocny U3VidmVyc2lvbiBSZXZpc2lvbjogMTA3MjMwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMzBjOThhMTYyMWIwMDNh OTk5NmI0ODE4ZWVlZjVlMmJkZDMzYTNiYy4uN2Y4ZjExMWVhOGYwYmEyZWIwMjExNTlmNzA2NDEw YzQ3NjYxNWE2ZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDEyLTAyLTA5ICBNaWNo YWwgTW9jbnkgIDxtbW9jbnlAZ29vZ2xlLmNvbT4KKworICAgICAgICBbY2hyb21pdW1dW25vdCBm b3IgcmV2aWV3XSBHTF9DSFJPTUlVTV9ncHVfbWVtb3J5X21hbmFnZXIgZXh0ZW5zaW9uCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NzE1NQorCisgICAg ICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaDoKKyAgICAgICAgKEdwdU1lbW9y eUFsbG9jYXRpb25DSFJPTUlVTSk6CisgICAgICAgIChHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdl ZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAoV2ViQ29yZTo6RXh0ZW5zaW9uczNEQ2hyb21p dW06OkdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTTo6fkdwdU1lbW9y eUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6CisgICAgICAgIChFeHRlbnNpb25z M0RDaHJvbWl1bSk6CisgICAgICAgICogcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NU aHJlYWRQcm94eS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpDQ1RocmVhZFByb3h5Ojpjb21wb3Np dGVBbmRSZWFkYmFjayk6CisKIDIwMTItMDItMDkgIEFsZXhlaSBGaWxpcHBvdiAgPGFsZXhlaWZA Y2hyb21pdW0ub3JnPgogCiAgICAgICAgIFdlYiBJbnNwZWN0b3I6IFNob3cgcGVyY2VudGFnZSBi eSBkZWZhdWx0IGluIGhlYXAgcHJvZmlsZXIuCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL0NoYW5nZUxvZyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4 IGMzODM3ZDFjZmZjNGY1Yjg1MDQ0MDFjY2IwNDJiZDE5NWNiMzM0OWUuLjg1ZGYyMGQ5NTgzYTE1 NDRjZmM3MTQxMTliNzc3MGNhZGYxODIwN2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vQ2hhbmdlTG9nCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBA IC0xLDMgKzEsNDggQEAKKzIwMTItMDItMDkgIE1pY2hhbCBNb2NueSAgPG1tb2NueUBnb29nbGUu Y29tPgorCisgICAgICAgIFtjaHJvbWl1bV1bbm90IGZvciByZXZpZXddIEdMX0NIUk9NSVVNX2dw dV9tZW1vcnlfbWFuYWdlciBleHRlbnNpb24KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTc3MTU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChP T1BTISkuCisKKyAgICAgICAgKiBwdWJsaWMvV2ViVmlld0NsaWVudC5oOgorICAgICAgICAoV2Vi Vmlld0NsaWVudCk6CisgICAgICAgIChXZWJLaXQ6OldlYlZpZXdDbGllbnQ6OnN1cmZhY2VJZCk6 CisgICAgICAgICogcHVibGljL3BsYXRmb3JtL1dlYkdyYXBoaWNzQ29udGV4dDNELmg6CisgICAg ICAgIChXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6 CisgICAgICAgIChXZWJLaXQ6OldlYkdyYXBoaWNzQ29udGV4dDNEOjpXZWJHcmFwaGljc01lbW9y eUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTTo6fldlYkdyYXBoaWNzTWVtb3J5QWxs b2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKFdlYkdyYXBoaWNzQ29u dGV4dDNEKToKKyAgICAgICAgKFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0Q6OmFkZEFmZmVj dGVkU3VyZmFjZUNIUk9NSVVNKToKKyAgICAgICAgKFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0 M0Q6OnJlbW92ZUFmZmVjdGVkU3VyZmFjZUNIUk9NSVVNKToKKyAgICAgICAgKFdlYktpdDo6V2Vi R3JhcGhpY3NDb250ZXh0M0Q6OnNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJP TUlVTSk6CisgICAgICAgICogcHVibGljL3BsYXRmb3JtL1dlYkdyYXBoaWNzTWVtb3J5QWxsb2Nh dGlvbi5oOiBBZGRlZC4KKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJHcmFwaGljc01l bW9yeUFsbG9jYXRpb24pOgorICAgICAgICAoV2ViS2l0OjpXZWJHcmFwaGljc01lbW9yeUFsbG9j YXRpb246OldlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbik6CisgICAgICAgIChXZWJLaXQ6Om9w ZXJhdG9yPT0pOgorICAgICAgICAoV2ViS2l0OjpvcGVyYXRvciE9KToKKyAgICAgICAgKiBzcmMv RXh0ZW5zaW9uczNEQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6RXh0ZW5zaW9uczNE Q2hyb21pdW06OnNldEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6 CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OkV4dGVuc2lvbnMzRENocm9t aXVtOjphZGRBZmZlY3RlZFN1cmZhY2VDSFJPTUlVTSk6CisgICAgICAgIChXZWJDb3JlOjpFeHRl bnNpb25zM0RDaHJvbWl1bTo6cmVtb3ZlQWZmZWN0ZWRTdXJmYWNlQ0hST01JVU0pOgorICAgICAg ICAqIHNyYy9HcmFwaGljc0NvbnRleHQzRENocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6 OkdyYXBoaWNzQ29udGV4dDNEOjp+R3JhcGhpY3NDb250ZXh0M0QpOgorICAgICAgICAoR3JhcGhp Y3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcik6CisgICAg ICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2Fs bGJhY2tBZGFwdGVyOjpHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2Fs bGJhY2tBZGFwdGVyKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNETWVtb3J5 QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXI6On5HcmFwaGljc0NvbnRleHQzRE1lbW9y eUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyKToKKyAgICAgICAgKFdlYkNvcmU6Okdy YXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXI6Om9u TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChX ZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6OnNldEdwdU1lbW9yeUFsbG9jYXRpb25D aGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRl eHQzRFByaXZhdGU6OmFkZEFmZmVjdGVkU3VyZmFjZUNIUk9NSVVNKToKKyAgICAgICAgKFdlYkNv cmU6OkdyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZTo6cmVtb3ZlQWZmZWN0ZWRTdXJmYWNlQ0hST01J VU0pOgorICAgICAgICAqIHNyYy9HcmFwaGljc0NvbnRleHQzRFByaXZhdGUuaDoKKyAgICAgICAg KiB0ZXN0cy9GYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QuaDoKKyAgICAgICAgKFdlYktpdDo6RmFr ZVdlYkdyYXBoaWNzQ29udGV4dDNEOjphZGRBZmZlY3RlZFN1cmZhY2VDSFJPTUlVTSk6CisgICAg ICAgIChXZWJLaXQ6OkZha2VXZWJHcmFwaGljc0NvbnRleHQzRDo6cmVtb3ZlQWZmZWN0ZWRTdXJm YWNlQ0hST01JVU0pOgorICAgICAgICAoV2ViS2l0OjpGYWtlV2ViR3JhcGhpY3NDb250ZXh0M0Q6 OnNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6CisgICAgICAgIChG YWtlV2ViR3JhcGhpY3NDb250ZXh0M0QpOgorCiAyMDEyLTAyLTA4ICBSYXltb25kIExpdSAgPHJh eW1vbmQubGl1QGludGVsLmNvbT4KIAogICAgICAgICBGaXggYSB0eXBvIGZvciByMTA3MTI1CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9FeHRl bnNpb25zM0RDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaAppbmRleCBlMTY0NjA5YWU5NDdiMTZmZTEwNjJh NGZkZDQ5NmQyYTZlNGU3ZmEzLi45MmI0ZjQ1ODY3MTNkOTY3OWNlMTIyMjk4YWYzZDgzMDYyZmE4 ZjU5IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1 bS9FeHRlbnNpb25zM0RDaHJvbWl1bS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0V4dGVuc2lvbnMzRENocm9taXVtLmgKQEAgLTg3LDYgKzg3LDIwIEBA IHB1YmxpYzoKICAgICAvLyBHTF9DSFJPTUlVTV9zZXRfdmlzaWJpbGl0eQogICAgIHZvaWQgc2V0 VmlzaWJpbGl0eUNIUk9NSVVNKGJvb2wpOwogCisgICAgLy8gR0xfQ0hST01JVU1fZ3B1X21lbW9y eV9tYW5hZ2VyCisgICAgc3RydWN0IEdwdU1lbW9yeUFsbG9jYXRpb25DSFJPTUlVTSB7CisgICAg ICAgIHVpbnQzMl90IGdwdVJlc291cmNlU2l6ZUluQnl0ZXM7CisgICAgfTsKKyAgICBjbGFzcyBH cHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0geworICAgIHB1YmxpYzoK KyAgICAgICAgdmlydHVhbCB2b2lkIG9uR3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQoY29uc3Qg R3B1TWVtb3J5QWxsb2NhdGlvbkNIUk9NSVVNJikgPSAwOworICAgICAgICB2aXJ0dWFsIH5HcHVN ZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oKSB7IH0KKyAgICB9OworICAg IHZvaWQgc2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKFBhc3NP d25QdHI8R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNPik7CisgICAg dm9pZCBhZGRBZmZlY3RlZFN1cmZhY2VDSFJPTUlVTShpbnQpOworICAgIHZvaWQgcmVtb3ZlQWZm ZWN0ZWRTdXJmYWNlQ0hST01JVU0oaW50KTsKKworCiAgICAgLy8gR0xfQ0hST01JVU1fc3dhcGJ1 ZmZlcnNfY29tcGxldGVfY2FsbGJhY2sKICAgICBjbGFzcyBTd2FwQnVmZmVyc0NvbXBsZXRlQ2Fs bGJhY2tDSFJPTUlVTSB7CiAgICAgcHVibGljOgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv cGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vY2MvQ0NUaHJlYWRQcm94eS5jcHAgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmNwcApp bmRleCA4Y2E4NTJkZGE2Yzg2ZmNhNzAxZTQ3YzNkNGExZTA1NmJjZGMwM2Y2Li40ZTQxNjIwNDFm ODY2ZWIyOGI2MGM4YTU4NjJjNjUyNjVkMjY3YWE2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29y ZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5LmNwcAorKysgYi9T b3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9jYy9DQ1RocmVhZFByb3h5 LmNwcApAQCAtMTE3LDYgKzExNyw3IEBAIGJvb2wgQ0NUaHJlYWRQcm94eTo6Y29tcG9zaXRlQW5k UmVhZGJhY2sodm9pZCAqcGl4ZWxzLCBjb25zdCBJbnRSZWN0JiByZWN0KQogICAgIHJlcXVlc3Qu cGl4ZWxzID0gcGl4ZWxzOwogICAgIENDUHJveHk6OmltcGxUaHJlYWQoKS0+cG9zdFRhc2soY3Jl YXRlQ0NUaHJlYWRUYXNrKHRoaXMsICZDQ1RocmVhZFByb3h5OjpyZXF1ZXN0UmVhZGJhY2tPbklt cGxUaHJlYWQsIEFsbG93Q3Jvc3NUaHJlYWRBY2Nlc3MoJnJlcXVlc3QpKSk7CiAgICAgcmVxdWVz dC5jb21wbGV0aW9uLndhaXQoKTsKKwogICAgIHJldHVybiByZXF1ZXN0LnN1Y2Nlc3M7CiB9CiAK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlZpZXdDbGllbnQu aCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlZpZXdDbGllbnQuaAppbmRleCAx YjQyYTQ4YThmYTlhYTA5MWY3YzkwNzY4ZTQwMTU0OTdiNDk0M2VmLi5iMzY0NGFhM2NhOTk2MTZj MDhiNjVlYjNhNTRmYjg5MGQ0NzQ5NWZlIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3B1YmxpYy9XZWJWaWV3Q2xpZW50LmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9w dWJsaWMvV2ViVmlld0NsaWVudC5oCkBAIC0zNDQsNiArMzQ0LDExIEBAIHB1YmxpYzoKICAgICAg ICAgcmV0dXJuIFdlYlBhZ2VWaXNpYmlsaXR5U3RhdGVWaXNpYmxlOwogICAgIH0KIAorICAgIC8v IE1lbW9yeSBNYW5hZ2VtZW50IC0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLQorCisgICAgLy8gUmV0dXJucyB0aGUgY3VycmVudCBjb21wb3NpdG9yIHN1 cmZhY2UgaWQgb2YgdGhlIFdlYlZpZXcuCisgICAgdmlydHVhbCBpbnQgc3VyZmFjZUlkKCkgY29u c3QgeyByZXR1cm4gMDsgfQorCiAgICAgLy8gTWVkaWEgU3RyZWFtcyAtLS0tLS0tLS0tLS0tLS0t LS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tLS0tCiAKICAgICB2aXJ0dWFsIFdl YlVzZXJNZWRpYUNsaWVudCogdXNlck1lZGlhQ2xpZW50KCkgeyByZXR1cm4gMDsgfQpkaWZmIC0t Z2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViR3JhcGhpY3ND b250ZXh0M0QuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdy YXBoaWNzQ29udGV4dDNELmgKaW5kZXggNTdmOWQ3OTg1M2E2NTU0OWU0ZWEwN2NkMDkwZWFkODdh NDA2ZDE5Mi4uMWM4OGZlMzg2OTExNDRkMmE3MWNkYWY3YTM3YzBmMGQwYzRhOGM1NyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViR3JhcGhpY3ND b250ZXh0M0QuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9X ZWJHcmFwaGljc0NvbnRleHQzRC5oCkBAIC0zMiw2ICszMiw3IEBACiAjZGVmaW5lIFdlYkdyYXBo aWNzQ29udGV4dDNEX2gKIAogI2luY2x1ZGUgIldlYkNvbW1vbi5oIgorI2luY2x1ZGUgIldlYkdy YXBoaWNzTWVtb3J5QWxsb2NhdGlvbi5oIgogI2luY2x1ZGUgIldlYk5vbkNvcHlhYmxlLmgiCiAj aW5jbHVkZSAiV2ViU3RyaW5nLmgiCiAKQEAgLTEzMCw2ICsxMzEsMTIgQEAgcHVibGljOgogICAg ICAgICB2aXJ0dWFsIH5XZWJHcmFwaGljc1N3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9N SVVNKCkgeyB9CiAgICAgfTsKIAorICAgIGNsYXNzIFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlv bkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNIHsKKyAgICBwdWJsaWM6CisgICAgICAgIHZpcnR1YWwg dm9pZCBvbk1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkKGNvbnN0IFdlYkdyYXBoaWNzTWVtb3J5QWxs b2NhdGlvbiYpID0gMDsKKyAgICAgICAgdmlydHVhbCB+V2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0 aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oKSB7IH0KKyAgICB9OworCiAgICAgLy8gVGhpcyBk ZXN0cnVjdG9yIG5lZWRzIHRvIGJlIHB1YmxpYyBzbyB0aGF0IHVzaW5nIGNsYXNzZXMgY2FuIGRl c3Ryb3kgaW5zdGFuY2VzIGlmIGluaXRpYWxpemF0aW9uIGZhaWxzLgogICAgIHZpcnR1YWwgfldl YkdyYXBoaWNzQ29udGV4dDNEKCkge30KIApAQCAtMTUxLDYgKzE1OCwxMyBAQCBwdWJsaWM6CiAg ICAgLy8gR0xfQ0hST01JVU1fc2V0VmlzaWJpbGl0eSAtIENoYW5nZXMgdGhlIHZpc2liaWxpdHkg b2YgdGhlIGJhY2tidWZmZXIKICAgICB2aXJ0dWFsIHZvaWQgc2V0VmlzaWJpbGl0eUNIUk9NSVVN KGJvb2wgdmlzaWJsZSkgPSAwOwogCisgICAgLy8gR0xfQ0hST01JVU1fZ3B1X21lbW9yeV9tYW5h Z2VyIC0gYWRkL3JlbW92ZSBzdXJmYWNlcyBhZmZlY3RlZCBieSB0aGlzIGNvbnRleHQuCisgICAg dmlydHVhbCB2b2lkIGFkZEFmZmVjdGVkU3VyZmFjZUNIUk9NSVVNKGludCkgeyB9CisgICAgdmly dHVhbCB2b2lkIHJlbW92ZUFmZmVjdGVkU3VyZmFjZUNIUk9NSVVNKGludCkgeyB9CisKKyAgICAv LyBHTF9DSFJPTUlVTV9ncHVfbWVtb3J5X21hbmFnZXIgLSBzZXQgY2FsbGJhY2sgdXNlZCBhZnRl ciBhIG1lbW9yeSBhbGxvY2F0aW9uIGNoYW5nZS4KKyAgICB2aXJ0dWFsIHZvaWQgc2V0TWVtb3J5 QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKFdlYkdyYXBoaWNzTWVtb3J5QWxsb2Nh dGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKiBjYWxsYmFjaykgeyB9CisKICAgICAvLyBRdWVy eSB3aGV0aGVyIGl0IGlzIGJ1aWx0IG9uIHRvcCBvZiBjb21wbGlhbnQgR0xFUzIgaW1wbGVtZW50 YXRpb24uCiAgICAgdmlydHVhbCBib29sIGlzR0xFUzJDb21wbGlhbnQoKSA9IDA7CiAKZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdyYXBoaWNz TWVtb3J5QWxsb2NhdGlvbi5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZv cm0vV2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNTA1Y2ZhOGE3ZThm NGI2MzJhNDJmNmY1YzUyMGU1MjAxMzQzOWJlNgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlv bi5oCkBAIC0wLDAgKzEsNjAgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwor ICogYXJlIG1ldDoKKyAqCisgKiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11 c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBv ZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIg bWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNP RlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIEFORCBJVFMgQ09OVFJJQlVUT1JTICJBUyBJUyIg QU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFC SUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xB SU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFC TEUgRk9SIEFOWQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhF TVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsK KyAqIExPU1MgT0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJ T04pIEhPV0VWRVIgQ0FVU0VEIEFORAorICogT04gQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdI RVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRSBPRgorICogVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFdlYkdyYXBoaWNzTWVtb3J5QWxs b2NhdGlvbl9oCisjZGVmaW5lIFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbl9oCisKKyNpbmNs dWRlICJXZWJDb21tb24uaCIKKworbmFtZXNwYWNlIFdlYktpdCB7CisKK3N0cnVjdCBXZWJHcmFw aGljc01lbW9yeUFsbG9jYXRpb24geworICAgIHVuc2lnbmVkIGludCBncHVSZXNvdXJjZVNpemVJ bkJ5dGVzOworCisgICAgV2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uKCkKKyAgICAgICAgOiBn cHVSZXNvdXJjZVNpemVJbkJ5dGVzKDApCisgICAgeworICAgIH0KKworICAgIFdlYkdyYXBoaWNz TWVtb3J5QWxsb2NhdGlvbih1bnNpZ25lZCBpbnQgZ3B1UmVzb3VyY2VTaXplSW5CeXRlcykKKyAg ICAgICAgOiBncHVSZXNvdXJjZVNpemVJbkJ5dGVzKGdwdVJlc291cmNlU2l6ZUluQnl0ZXMpCisg ICAgeworICAgIH0KK307CisKK2lubGluZSBib29sIG9wZXJhdG9yPT0oY29uc3QgV2ViR3JhcGhp Y3NNZW1vcnlBbGxvY2F0aW9uJiBhLCBjb25zdCBXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb24m IGIpCit7CisgICAgcmV0dXJuIGEuZ3B1UmVzb3VyY2VTaXplSW5CeXRlcyA9PSBiLmdwdVJlc291 cmNlU2l6ZUluQnl0ZXM7Cit9CisKK2lubGluZSBib29sIG9wZXJhdG9yIT0oY29uc3QgV2ViR3Jh cGhpY3NNZW1vcnlBbGxvY2F0aW9uJiBhLCBjb25zdCBXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRp b24mIGIpCit7CisgICAgcmV0dXJuICEoYSA9PSBiKTsKK30KKworfSAvLyBuYW1lc3BhY2UgV2Vi S2l0CisKKyNlbmRpZgorCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9F eHRlbnNpb25zM0RDaHJvbWl1bS5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9FeHRl bnNpb25zM0RDaHJvbWl1bS5jcHAKaW5kZXggZWNlMDQwNWFlYzRmMTIwMzk1ZmVkZDFiMWMyOGVi MmY0ODgxNjBjZi4uYWMzZTkyMjlmYmU3NGFlMjU3ZGNiNWIzYTcyYzMyNGM0NzYyYjNmYiAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRXh0ZW5zaW9uczNEQ2hyb21pdW0u Y3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0V4dGVuc2lvbnMzRENocm9taXVt LmNwcApAQCAtMTA3LDYgKzEwNywyMSBAQCB2b2lkIEV4dGVuc2lvbnMzRENocm9taXVtOjpzZXRW aXNpYmlsaXR5Q0hST01JVU0oYm9vbCB2aXNpYmlsaXR5KQogICAgIG1fcHJpdmF0ZS0+c2V0Vmlz aWJpbGl0eUNIUk9NSVVNKHZpc2liaWxpdHkpOwogfQogCit2b2lkIEV4dGVuc2lvbnMzRENocm9t aXVtOjpzZXRHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oUGFzc093 blB0cjxHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0+IGNhbGxiYWNr KQoreworICAgIG1fcHJpdmF0ZS0+c2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0NIUk9NSVVNKGNhbGxiYWNrKTsKK30KKwordm9pZCBFeHRlbnNpb25zM0RDaHJvbWl1bTo6YWRk QWZmZWN0ZWRTdXJmYWNlQ0hST01JVU0oaW50IHN1cmZhY2VJZCkKK3sKKyAgICBtX3ByaXZhdGUt PmFkZEFmZmVjdGVkU3VyZmFjZUNIUk9NSVVNKHN1cmZhY2VJZCk7Cit9CisKK3ZvaWQgRXh0ZW5z aW9uczNEQ2hyb21pdW06OnJlbW92ZUFmZmVjdGVkU3VyZmFjZUNIUk9NSVVNKGludCBzdXJmYWNl SWQpCit7CisgICAgbV9wcml2YXRlLT5yZW1vdmVBZmZlY3RlZFN1cmZhY2VDSFJPTUlVTShzdXJm YWNlSWQpOworfQorCiBQbGF0Zm9ybTNET2JqZWN0IEV4dGVuc2lvbnMzRENocm9taXVtOjpjcmVh dGVWZXJ0ZXhBcnJheU9FUygpCiB7CiAgICAgcmV0dXJuIDA7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRENocm9taXVtLmNwcCBiL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0uY3BwCmluZGV4 IGNiYmY1YzU4MWFkZmMzYmViNTkwOTYzMDJhMzBlMGExYjdlY2NhNGEuLmVmMGZmMzY4MTczMDVl ZTA1NWQ2YzllMDBmYzJlYWQwZmU2YzY3YTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0uY3BwCisrKyBiL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0uY3BwCkBAIC00OCw2ICs0 OCw3IEBACiAjaW5jbHVkZSAiV2ViS2l0LmgiCiAjaW5jbHVkZSAiV2ViVmlld0NsaWVudC5oIgog I2luY2x1ZGUgIldlYlZpZXdJbXBsLmgiCisjaW5jbHVkZSAicGxhdGZvcm0vV2ViR3JhcGhpY3NN ZW1vcnlBbGxvY2F0aW9uLmgiCiAjaW5jbHVkZSAicGxhdGZvcm0vV2ViR3JhcGhpY3NDb250ZXh0 M0QuaCIKICNpbmNsdWRlICJwbGF0Zm9ybS9XZWJLaXRQbGF0Zm9ybVN1cHBvcnQuaCIKIApAQCAt MTAzNSw2ICsxMDM2LDcgQEAgR3JhcGhpY3NDb250ZXh0M0Q6On5HcmFwaGljc0NvbnRleHQzRCgp CiAgICAgbV9wcml2YXRlLT5zZXRDb250ZXh0TG9zdENhbGxiYWNrKG51bGxwdHIpOwogICAgIG1f cHJpdmF0ZS0+c2V0RXJyb3JNZXNzYWdlQ2FsbGJhY2sobnVsbHB0cik7CiAgICAgbV9wcml2YXRl LT5zZXRTd2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJhY2tDSFJPTUlVTShudWxscHRyKTsKKyAgICBt X3ByaXZhdGUtPnNldEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShu dWxscHRyKTsKIH0KIAogUGFzc1JlZlB0cjxHcmFwaGljc0NvbnRleHQzRD4gR3JhcGhpY3NDb250 ZXh0M0Q6OmNyZWF0ZShHcmFwaGljc0NvbnRleHQzRDo6QXR0cmlidXRlcyBhdHRycywgSG9zdFdp bmRvdyogaG9zdFdpbmRvdywgR3JhcGhpY3NDb250ZXh0M0Q6OlJlbmRlclN0eWxlIHJlbmRlclN0 eWxlKQpAQCAtMTM1OSw2ICsxMzYxLDQyIEBAIHZvaWQgR3JhcGhpY3NDb250ZXh0M0RQcml2YXRl OjpzZXRTd2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJhY2tDSFJPTUlVTShQYXNzT3duUHRyCiAgICAg bV9pbXBsLT5zZXRTd2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJhY2tDSFJPTUlVTShtX3N3YXBCdWZm ZXJzQ29tcGxldGVDYWxsYmFja0FkYXB0ZXIuZ2V0KCkpOwogfQogCitjbGFzcyBHcmFwaGljc0Nv bnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyIDogcHVibGljIFdl YktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0Q6OldlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNo YW5nZWRDYWxsYmFja0NIUk9NSVVNIHsKK3B1YmxpYzoKKyAgICBHcmFwaGljc0NvbnRleHQzRE1l bW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyKFBhc3NPd25QdHI8RXh0ZW5zaW9u czNEQ2hyb21pdW06OkdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTT4g Y2IpCisgICAgICAgIDogbV9tZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrKGNiKQorICAg IHsKKyAgICB9CisKKyAgICB2aXJ0dWFsIH5HcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRp b25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyKCkgeyB9CisKKyAgICB2aXJ0dWFsIHZvaWQgb25NZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZChjb25zdCBXZWJLaXQ6OldlYkdyYXBoaWNzTWVtb3J5QWxsb2Nh dGlvbiYgYWxsb2NhdGlvbikKKyAgICB7CisgICAgICAgIEV4dGVuc2lvbnMzRENocm9taXVtOjpH cHVNZW1vcnlBbGxvY2F0aW9uQ0hST01JVU0gYWxsb2NhdGlvbkNocm9taXVtOworICAgICAgICBh bGxvY2F0aW9uQ2hyb21pdW0uZ3B1UmVzb3VyY2VTaXplSW5CeXRlcyA9IGFsbG9jYXRpb24uZ3B1 UmVzb3VyY2VTaXplSW5CeXRlczsKKyAgICAgICAgaWYgKG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFjaykKKyAgICAgICAgICAgIG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj ay0+b25HcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZChhbGxvY2F0aW9uQ2hyb21pdW0pOworICAg IH0KKworcHJpdmF0ZToKKyAgICBPd25QdHI8RXh0ZW5zaW9uczNEQ2hyb21pdW06OkdwdU1lbW9y eUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTT4gbV9tZW1vcnlBbGxvY2F0aW9uQ2hh bmdlZENhbGxiYWNrOworfTsKKwordm9pZCBHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6OnNldEdw dU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShQYXNzT3duUHRyPEV4dGVu c2lvbnMzRENocm9taXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01J VU0+IGNiKQoreworICAgIG1faW1wbC0+c2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0NIUk9NSVVNKG5ldyBHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2Fs bGJhY2tBZGFwdGVyKGNiKSk7Cit9CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlOjph ZGRBZmZlY3RlZFN1cmZhY2VDSFJPTUlVTShpbnQgc3VyZmFjZUlkKQoreworICAgIG1faW1wbC0+ YWRkQWZmZWN0ZWRTdXJmYWNlQ0hST01JVU0oc3VyZmFjZUlkKTsKK30KKwordm9pZCBHcmFwaGlj c0NvbnRleHQzRFByaXZhdGU6OnJlbW92ZUFmZmVjdGVkU3VyZmFjZUNIUk9NSVVNKGludCBzdXJm YWNlSWQpCit7CisgICAgbV9pbXBsLT5yZW1vdmVBZmZlY3RlZFN1cmZhY2VDSFJPTUlVTShzdXJm YWNlSWQpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBFTkFCTEUo V0VCR0wpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0Nv bnRleHQzRFByaXZhdGUuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29u dGV4dDNEUHJpdmF0ZS5oCmluZGV4IGYyZDQ5YTEzMmM2NDVjODhiMGEyNzkxYWQzMTIzZjU2NWI5 YjEyOTUuLmE4NTQxYzhiNDRhNmE2NTM1ZGQ0NGEzODhkZDY1ZTIxMmVhZjRiMWMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZS5o CisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEUHJpdmF0 ZS5oCkBAIC0yOTUsNiArMjk1LDExIEBAIHB1YmxpYzoKICAgICAvLyBHTF9DSFJPTUlVTV9zZXRf dmlzaWJpbGl0eQogICAgIHZvaWQgc2V0VmlzaWJpbGl0eUNIUk9NSVVNKGJvb2wpOwogCisgICAg Ly8gR0xfQ0hST01JVU1fZ3B1X21lbW9yeV9tYW5hZ2VyCisgICAgdmlydHVhbCB2b2lkIHNldEdw dU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShQYXNzT3duUHRyPEV4dGVu c2lvbnMzRENocm9taXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01J VU0+KTsKKyAgICB2b2lkIGFkZEFmZmVjdGVkU3VyZmFjZUNIUk9NSVVNKGludCk7CisgICAgdm9p ZCByZW1vdmVBZmZlY3RlZFN1cmZhY2VDSFJPTUlVTShpbnQpOworCiAgICAgLy8gR0xfQ0hST01J VU1fZnJhbWVidWZmZXJfbXVsdGlzYW1wbGUKICAgICB2b2lkIGJsaXRGcmFtZWJ1ZmZlckNIUk9N SVVNKEdDM0RpbnQgc3JjWDAsIEdDM0RpbnQgc3JjWTAsIEdDM0RpbnQgc3JjWDEsIEdDM0RpbnQg c3JjWTEsIEdDM0RpbnQgZHN0WDAsIEdDM0RpbnQgZHN0WTAsIEdDM0RpbnQgZHN0WDEsIEdDM0Rp bnQgZHN0WTEsIEdDM0RiaXRmaWVsZCBtYXNrLCBHQzNEZW51bSBmaWx0ZXIpOwogICAgIHZvaWQg cmVuZGVyYnVmZmVyU3RvcmFnZU11bHRpc2FtcGxlQ0hST01JVU0oR0MzRGVudW0gdGFyZ2V0LCBH QzNEc2l6ZWkgc2FtcGxlcywgR0MzRGVudW0gaW50ZXJuYWxmb3JtYXQsIEdDM0RzaXplaSB3aWR0 aCwgR0MzRHNpemVpIGhlaWdodCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3Rlc3RzL0Zha2VXZWJHcmFwaGljc0NvbnRleHQzRC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1 bS90ZXN0cy9GYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QuaAppbmRleCBjZjA2NTFiNzcwMzJiZDgw ZTU4M2M2NjgyNzc0NjI4ODYwNTVkZGI4Li5lNjU0MjJkYTY4MzFmZmFkMDhiZmM0OGNmZTZiMTQ0 Mjk4OGI5N2ZjIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0Zha2VX ZWJHcmFwaGljc0NvbnRleHQzRC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMv RmFrZVdlYkdyYXBoaWNzQ29udGV4dDNELmgKQEAgLTY1LDYgKzY1LDEwIEBAIHB1YmxpYzoKIAog ICAgIHZpcnR1YWwgdm9pZCBzZXRWaXNpYmlsaXR5Q0hST01JVU0oYm9vbCB2aXNpYmxlKSB7IH0K IAorICAgIHZpcnR1YWwgdm9pZCBhZGRBZmZlY3RlZFN1cmZhY2VDSFJPTUlVTShpbnQgc3VyZmFj ZUlkKSB7IH0KKyAgICB2aXJ0dWFsIHZvaWQgcmVtb3ZlQWZmZWN0ZWRTdXJmYWNlQ0hST01JVU0o aW50IHN1cmZhY2VJZCkgeyB9CisgICAgdmlydHVhbCB2b2lkIHNldE1lbW9yeUFsbG9jYXRpb25D aGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2Vk Q2FsbGJhY2tDSFJPTUlVTSogY2FsbGJhY2spIHsgfQorCiAgICAgdmlydHVhbCBXZWJTdHJpbmcg Z2V0UmVxdWVzdGFibGVFeHRlbnNpb25zQ0hST01JVU0oKSB7IHJldHVybiBXZWJTdHJpbmcoKTsg fQogICAgIHZpcnR1YWwgdm9pZCByZXF1ZXN0RXh0ZW5zaW9uQ0hST01JVU0oY29uc3QgY2hhciop IHsgfQogCg== 126807 2012-02-13 12:37:46 -0800 2012-02-14 12:54:20 -0800 Patch bug-77155-20120213153745.patch text/plain 13464 mmocny U3VidmVyc2lvbiBSZXZpc2lvbjogMTA3NTYzCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNGNjN2U2MjQxY2JlZTQw NWU5NjkxZDZiOTI4MTllY2Y3OWFkZDBlNy4uNDUzZDNkODIwYWM3M2FkMTdhNzk3ZjhmYjEyMDJm ZDdiMGJjY2Q3MyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE2IEBACisyMDEyLTAyLTEzICBNaWNo YWwgTW9jbnkgIDxtbW9jbnlAZ29vZ2xlLmNvbT4KKworICAgICAgICBbY2hyb21pdW1dIEdMX0NI Uk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlciBleHRlbnNpb24KKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3MTU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9F eHRlbnNpb25zM0RDaHJvbWl1bS5oOgorICAgICAgICAoR3B1TWVtb3J5QWxsb2NhdGlvbkNIUk9N SVVNKToKKyAgICAgICAgKEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlV TSk6CisgICAgICAgIChXZWJDb3JlOjpFeHRlbnNpb25zM0RDaHJvbWl1bTo6R3B1TWVtb3J5QWxs b2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNOjp+R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKEV4dGVuc2lvbnMzRENocm9taXVtKToKKwog MjAxMi0wMi0wNiAgUmFwaGFlbCBLdWJvIGRhIENvc3RhICA8a3Vib0Bwcm9mdXNpb24ubW9iaT4K IAogICAgICAgICBbRUZMXSBEcm9wIHN1cHBvcnQgZm9yIHRoZSBDdXJsIG5ldHdvcmsgYmFja2Vu ZC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggMjhlMjFjYmQwNDgwNDJjZjkzNTRiYmFm MmRmYTkwNjA4NmUwMDk3OC4uMjE2NTY4ODMzYTRmYzYyMWVhMjBhZTc1YzRkZjQ5NDllZTMwZWU4 YSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNyBAQAorMjAxMi0wMi0x MyAgTWljaGFsIE1vY255ICA8bW1vY255QGdvb2dsZS5jb20+CisKKyAgICAgICAgW2Nocm9taXVt XSBHTF9DSFJPTUlVTV9ncHVfbWVtb3J5X21hbmFnZXIgZXh0ZW5zaW9uCisgICAgICAgIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NzE1NQorCisgICAgICAgIFJldmll d2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogcHVibGljL3BsYXRmb3JtL1dlYkdy YXBoaWNzQ29udGV4dDNELmg6CisgICAgICAgIChXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25D aGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6CisgICAgICAgIChXZWJLaXQ6OldlYkdyYXBoaWNzQ29u dGV4dDNEOjpXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlV TTo6fldlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKToK KyAgICAgICAgKFdlYkdyYXBoaWNzQ29udGV4dDNEKToKKyAgICAgICAgKFdlYktpdDo6V2ViR3Jh cGhpY3NDb250ZXh0M0Q6OnNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlV TSk6CisgICAgICAgICogcHVibGljL3BsYXRmb3JtL1dlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlv bi5oOiBBZGRlZC4KKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJHcmFwaGljc01lbW9y eUFsbG9jYXRpb24pOgorICAgICAgICAoV2ViS2l0OjpXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRp b246OldlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbik6CisgICAgICAgIChXZWJLaXQ6Om9wZXJh dG9yPT0pOgorICAgICAgICAoV2ViS2l0OjpvcGVyYXRvciE9KToKKyAgICAgICAgKiBzcmMvRXh0 ZW5zaW9uczNEQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6RXh0ZW5zaW9uczNEQ2hy b21pdW06OnNldEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6Cisg ICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKiBzcmMvR3JhcGhpY3NDb250ZXh0M0RDaHJvbWl1 bS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRDo6fkdyYXBoaWNzQ29u dGV4dDNEKToKKyAgICAgICAgKEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0FkYXB0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0RN ZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcjo6R3JhcGhpY3NDb250ZXh0M0RN ZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcik6CisgICAgICAgIChXZWJDb3Jl OjpHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVy Ojp+R3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRl cik6CisgICAgICAgIChXZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25D aGFuZ2VkQ2FsbGJhY2tBZGFwdGVyOjpvbk1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkKToKKyAgICAg ICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0RQcml2YXRl OjpzZXRHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAg ICAqIHNyYy9HcmFwaGljc0NvbnRleHQzRFByaXZhdGUuaDoKKyAgICAgICAgKiB0ZXN0cy9GYWtl V2ViR3JhcGhpY3NDb250ZXh0M0QuaDoKKyAgICAgICAgKFdlYktpdDo6RmFrZVdlYkdyYXBoaWNz Q29udGV4dDNEOjpzZXRNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgor ICAgICAgICAoRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEKToKKwogMjAxMi0wMi0xMyAgWW9zaWZ1 bWkgSW5vdWUgIDx5b3NpbkBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgW0Zvcm1zXSBVc2UgZW51 bSBpbnN0ZWFkIG9mIGJvb2wgZm9yIEhUTUxJbnB1dEVsZW1lbnQ6OnNldFZhbHVlCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9FeHRlbnNpb25z M0RDaHJvbWl1bS5oIGIvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0v RXh0ZW5zaW9uczNEQ2hyb21pdW0uaAppbmRleCBlMTY0NjA5YWU5NDdiMTZmZTEwNjJhNGZkZDQ5 NmQyYTZlNGU3ZmEzLi4zN2IyNDA3M2Q5YjRmN2NmYjE1NjkyMWI1N2NhYWFjNmFjYTk4YjY2IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9FeHRl bnNpb25zM0RDaHJvbWl1bS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL0V4dGVuc2lvbnMzRENocm9taXVtLmgKQEAgLTg3LDYgKzg3LDE3IEBAIHB1Ymxp YzoKICAgICAvLyBHTF9DSFJPTUlVTV9zZXRfdmlzaWJpbGl0eQogICAgIHZvaWQgc2V0VmlzaWJp bGl0eUNIUk9NSVVNKGJvb2wpOwogCisgICAgLy8gR0xfQ0hST01JVU1fZ3B1X21lbW9yeV9tYW5h Z2VyCisgICAgc3RydWN0IEdwdU1lbW9yeUFsbG9jYXRpb25DSFJPTUlVTSB7CisgICAgICAgIHVp bnQzMl90IGdwdVJlc291cmNlU2l6ZUluQnl0ZXM7CisgICAgfTsKKyAgICBjbGFzcyBHcHVNZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0geworICAgIHB1YmxpYzoKKyAgICAg ICAgdmlydHVhbCB2b2lkIG9uR3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQoY29uc3QgR3B1TWVt b3J5QWxsb2NhdGlvbkNIUk9NSVVNJikgPSAwOworICAgICAgICB2aXJ0dWFsIH5HcHVNZW1vcnlB bGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oKSB7IH0KKyAgICB9OworICAgIHZvaWQg c2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKFBhc3NPd25QdHI8 R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNPik7CisKICAgICAvLyBH TF9DSFJPTUlVTV9zd2FwYnVmZmVyc19jb21wbGV0ZV9jYWxsYmFjawogICAgIGNsYXNzIFN3YXBC dWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVNIHsKICAgICBwdWJsaWM6CmRpZmYgLS1naXQg YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRl eHQzRC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViR3JhcGhp Y3NDb250ZXh0M0QuaAppbmRleCA1N2Y5ZDc5ODUzYTY1NTQ5ZTRlYTA3Y2QwOTBlYWQ4N2E0MDZk MTkyLi5iNmMzMTAyZTNjNDA2N2JjYWQ4Yjg0MGQwOTQ5Y2Y3ZTEwOWI0ZWE5IDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRl eHQzRC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdy YXBoaWNzQ29udGV4dDNELmgKQEAgLTMyLDYgKzMyLDcgQEAKICNkZWZpbmUgV2ViR3JhcGhpY3ND b250ZXh0M0RfaAogCiAjaW5jbHVkZSAiV2ViQ29tbW9uLmgiCisjaW5jbHVkZSAiV2ViR3JhcGhp Y3NNZW1vcnlBbGxvY2F0aW9uLmgiCiAjaW5jbHVkZSAiV2ViTm9uQ29weWFibGUuaCIKICNpbmNs dWRlICJXZWJTdHJpbmcuaCIKIApAQCAtMTMwLDYgKzEzMSwxMiBAQCBwdWJsaWM6CiAgICAgICAg IHZpcnR1YWwgfldlYkdyYXBoaWNzU3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQ0hST01JVU0o KSB7IH0KICAgICB9OwogCisgICAgY2xhc3MgV2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uQ2hh bmdlZENhbGxiYWNrQ0hST01JVU0geworICAgIHB1YmxpYzoKKyAgICAgICAgdmlydHVhbCB2b2lk IG9uTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQoY29uc3QgV2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0 aW9uJikgPSAwOworICAgICAgICB2aXJ0dWFsIH5XZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25D aGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSgpIHsgfQorICAgIH07CisKICAgICAvLyBUaGlzIGRlc3Ry dWN0b3IgbmVlZHMgdG8gYmUgcHVibGljIHNvIHRoYXQgdXNpbmcgY2xhc3NlcyBjYW4gZGVzdHJv eSBpbnN0YW5jZXMgaWYgaW5pdGlhbGl6YXRpb24gZmFpbHMuCiAgICAgdmlydHVhbCB+V2ViR3Jh cGhpY3NDb250ZXh0M0QoKSB7fQogCkBAIC0xNTEsNiArMTU4LDkgQEAgcHVibGljOgogICAgIC8v IEdMX0NIUk9NSVVNX3NldFZpc2liaWxpdHkgLSBDaGFuZ2VzIHRoZSB2aXNpYmlsaXR5IG9mIHRo ZSBiYWNrYnVmZmVyCiAgICAgdmlydHVhbCB2b2lkIHNldFZpc2liaWxpdHlDSFJPTUlVTShib29s IHZpc2libGUpID0gMDsKIAorICAgIC8vIEdMX0NIUk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlciAt IHNldHMgY2FsbGJhY2sgZm9yIG1lbW9yeSBhbGxvY2F0aW9uIGNoYW5nZXMuCisgICAgdmlydHVh bCB2b2lkIHNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShXZWJHcmFw aGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSogY2FsbGJhY2spIHsg fQorCiAgICAgLy8gUXVlcnkgd2hldGhlciBpdCBpcyBidWlsdCBvbiB0b3Agb2YgY29tcGxpYW50 IEdMRVMyIGltcGxlbWVudGF0aW9uLgogICAgIHZpcnR1YWwgYm9vbCBpc0dMRVMyQ29tcGxpYW50 KCkgPSAwOwogCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9wbGF0 Zm9ybS9XZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb24uaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vcHVibGljL3BsYXRmb3JtL1dlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbi5oCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAuLjUwNWNmYThhN2U4ZjRiNjMyYTQyZjZmNWM1MjBlNTIwMTM0MzliZTYKLS0tIC9kZXYvbnVs bAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9XZWJHcmFwaGlj c01lbW9yeUFsbG9jYXRpb24uaApAQCAtMCwwICsxLDYwIEBACisvKgorICogQ29weXJpZ2h0IChD KSAyMDEyIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKgorICogMS4gIFJlZGlzdHJpYnV0aW9ucyBv ZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24u CisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBBTkQgSVRTIENPTlRS SUJVVE9SUyAiQVMgSVMiIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVT LCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFIElNUExJRUQKKyAqIFdBUlJBTlRJ RVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9T RSBBUkUKKyAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIE9SIElUUyBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5U QUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAoSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7CisgKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQKKyAqIE9OIEFOWSBUSEVPUlkg T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YKKyAqIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lmbmRlZiBXZWJH cmFwaGljc01lbW9yeUFsbG9jYXRpb25faAorI2RlZmluZSBXZWJHcmFwaGljc01lbW9yeUFsbG9j YXRpb25faAorCisjaW5jbHVkZSAiV2ViQ29tbW9uLmgiCisKK25hbWVzcGFjZSBXZWJLaXQgewor CitzdHJ1Y3QgV2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uIHsKKyAgICB1bnNpZ25lZCBpbnQg Z3B1UmVzb3VyY2VTaXplSW5CeXRlczsKKworICAgIFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlv bigpCisgICAgICAgIDogZ3B1UmVzb3VyY2VTaXplSW5CeXRlcygwKQorICAgIHsKKyAgICB9CisK KyAgICBXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb24odW5zaWduZWQgaW50IGdwdVJlc291cmNl U2l6ZUluQnl0ZXMpCisgICAgICAgIDogZ3B1UmVzb3VyY2VTaXplSW5CeXRlcyhncHVSZXNvdXJj ZVNpemVJbkJ5dGVzKQorICAgIHsKKyAgICB9Cit9OworCitpbmxpbmUgYm9vbCBvcGVyYXRvcj09 KGNvbnN0IFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbiYgYSwgY29uc3QgV2ViR3JhcGhpY3NN ZW1vcnlBbGxvY2F0aW9uJiBiKQoreworICAgIHJldHVybiBhLmdwdVJlc291cmNlU2l6ZUluQnl0 ZXMgPT0gYi5ncHVSZXNvdXJjZVNpemVJbkJ5dGVzOworfQorCitpbmxpbmUgYm9vbCBvcGVyYXRv ciE9KGNvbnN0IFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbiYgYSwgY29uc3QgV2ViR3JhcGhp Y3NNZW1vcnlBbGxvY2F0aW9uJiBiKQoreworICAgIHJldHVybiAhKGEgPT0gYik7Cit9CisKK30g Ly8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYKKwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvRXh0ZW5zaW9uczNEQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvRXh0ZW5zaW9uczNEQ2hyb21pdW0uY3BwCmluZGV4IGVjZTA0MDVhZWM0ZjEy MDM5NWZlZGQxYjFjMjhlYjJmNDg4MTYwY2YuLjczMzk3YmQyYjE2YTdjY2NmYTE4MmJhMTI3Njhk YTBjN2E1ODc2ZGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0V4dGVu c2lvbnMzRENocm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9FeHRl bnNpb25zM0RDaHJvbWl1bS5jcHAKQEAgLTEwNyw2ICsxMDcsMTEgQEAgdm9pZCBFeHRlbnNpb25z M0RDaHJvbWl1bTo6c2V0VmlzaWJpbGl0eUNIUk9NSVVNKGJvb2wgdmlzaWJpbGl0eSkKICAgICBt X3ByaXZhdGUtPnNldFZpc2liaWxpdHlDSFJPTUlVTSh2aXNpYmlsaXR5KTsKIH0KIAordm9pZCBF eHRlbnNpb25zM0RDaHJvbWl1bTo6c2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0NIUk9NSVVNKFBhc3NPd25QdHI8R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NI Uk9NSVVNPiBjYWxsYmFjaykKK3sKKyAgICBtX3ByaXZhdGUtPnNldEdwdU1lbW9yeUFsbG9jYXRp b25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShjYWxsYmFjayk7Cit9CisKIFBsYXRmb3JtM0RPYmpl Y3QgRXh0ZW5zaW9uczNEQ2hyb21pdW06OmNyZWF0ZVZlcnRleEFycmF5T0VTKCkKIHsKICAgICBy ZXR1cm4gMDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNz Q29udGV4dDNEQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhp Y3NDb250ZXh0M0RDaHJvbWl1bS5jcHAKaW5kZXggY2JiZjVjNTgxYWRmYzNiZWI1OTA5NjMwMmEz MGUwYTFiN2VjY2E0YS4uNmQyMmRjMTgyYThlZjI5YzAyMDNlMmU2ZWUxOWEzYjc0YjNkZGRlNiAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RD aHJvbWl1bS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250 ZXh0M0RDaHJvbWl1bS5jcHAKQEAgLTQ4LDYgKzQ4LDcgQEAKICNpbmNsdWRlICJXZWJLaXQuaCIK ICNpbmNsdWRlICJXZWJWaWV3Q2xpZW50LmgiCiAjaW5jbHVkZSAiV2ViVmlld0ltcGwuaCIKKyNp bmNsdWRlICJwbGF0Zm9ybS9XZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb24uaCIKICNpbmNsdWRl ICJwbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRleHQzRC5oIgogI2luY2x1ZGUgInBsYXRmb3JtL1dl YktpdFBsYXRmb3JtU3VwcG9ydC5oIgogCkBAIC0xMDM1LDYgKzEwMzYsNyBAQCBHcmFwaGljc0Nv bnRleHQzRDo6fkdyYXBoaWNzQ29udGV4dDNEKCkKICAgICBtX3ByaXZhdGUtPnNldENvbnRleHRM b3N0Q2FsbGJhY2sobnVsbHB0cik7CiAgICAgbV9wcml2YXRlLT5zZXRFcnJvck1lc3NhZ2VDYWxs YmFjayhudWxscHRyKTsKICAgICBtX3ByaXZhdGUtPnNldFN3YXBCdWZmZXJzQ29tcGxldGVDYWxs YmFja0NIUk9NSVVNKG51bGxwdHIpOworICAgIG1fcHJpdmF0ZS0+c2V0R3B1TWVtb3J5QWxsb2Nh dGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKG51bGxwdHIpOwogfQogCiBQYXNzUmVmUHRyPEdy YXBoaWNzQ29udGV4dDNEPiBHcmFwaGljc0NvbnRleHQzRDo6Y3JlYXRlKEdyYXBoaWNzQ29udGV4 dDNEOjpBdHRyaWJ1dGVzIGF0dHJzLCBIb3N0V2luZG93KiBob3N0V2luZG93LCBHcmFwaGljc0Nv bnRleHQzRDo6UmVuZGVyU3R5bGUgcmVuZGVyU3R5bGUpCkBAIC0xMzU5LDYgKzEzNjEsMzMgQEAg dm9pZCBHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6OnNldFN3YXBCdWZmZXJzQ29tcGxldGVDYWxs YmFja0NIUk9NSVVNKFBhc3NPd25QdHIKICAgICBtX2ltcGwtPnNldFN3YXBCdWZmZXJzQ29tcGxl dGVDYWxsYmFja0NIUk9NSVVNKG1fc3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQWRhcHRlci5n ZXQoKSk7CiB9CiAKK2NsYXNzIEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0FkYXB0ZXIgOiBwdWJsaWMgV2ViS2l0OjpXZWJHcmFwaGljc0NvbnRleHQzRDo6 V2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0geworcHVi bGljOgorICAgIEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0FkYXB0ZXIoUGFzc093blB0cjxFeHRlbnNpb25zM0RDaHJvbWl1bTo6R3B1TWVtb3J5QWxsb2Nh dGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNPiBjYikKKyAgICAgICAgOiBtX21lbW9yeUFsbG9j YXRpb25DaGFuZ2VkQ2FsbGJhY2soY2IpCisgICAgeworICAgIH0KKworICAgIHZpcnR1YWwgfkdy YXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIoKSB7 IH0KKworICAgIHZpcnR1YWwgdm9pZCBvbk1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkKGNvbnN0IFdl YktpdDo6V2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uJiBhbGxvY2F0aW9uKQorICAgIHsKKyAg ICAgICAgaWYgKCFtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2spCisgICAgICAgICAg cmV0dXJuOworICAgICAgICBFeHRlbnNpb25zM0RDaHJvbWl1bTo6R3B1TWVtb3J5QWxsb2NhdGlv bkNIUk9NSVVNIGFsbG9jYXRpb25DaHJvbWl1bTsKKyAgICAgICAgYWxsb2NhdGlvbkNocm9taXVt LmdwdVJlc291cmNlU2l6ZUluQnl0ZXMgPSBhbGxvY2F0aW9uLmdwdVJlc291cmNlU2l6ZUluQnl0 ZXM7CisgICAgICAgIG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFjay0+b25HcHVNZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZChhbGxvY2F0aW9uQ2hyb21pdW0pOworICAgIH0KKworcHJpdmF0 ZToKKyAgICBPd25QdHI8RXh0ZW5zaW9uczNEQ2hyb21pdW06OkdwdU1lbW9yeUFsbG9jYXRpb25D aGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTT4gbV9tZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNr OworfTsKKwordm9pZCBHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6OnNldEdwdU1lbW9yeUFsbG9j YXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShQYXNzT3duUHRyPEV4dGVuc2lvbnMzRENocm9t aXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0+IGNiKQorewor ICAgIG1faW1wbC0+c2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKG5l dyBHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVy KGNiKSk7Cit9CisKIH0gLy8gbmFtZXNwYWNlIFdlYkNvcmUKIAogI2VuZGlmIC8vIEVOQUJMRShX RUJHTCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29u dGV4dDNEUHJpdmF0ZS5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250 ZXh0M0RQcml2YXRlLmgKaW5kZXggZjJkNDlhMTMyYzY0NWM4OGIwYTI3OTFhZDMxMjNmNTY1Yjli MTI5NS4uYzczZmNkZDJjOTdiM2JjMjk0ZGNiYjBiMGQzMTQ1N2M0NzMyNWI3NCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlLmgK KysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RQcml2YXRl LmgKQEAgLTI5NSw2ICsyOTUsOSBAQCBwdWJsaWM6CiAgICAgLy8gR0xfQ0hST01JVU1fc2V0X3Zp c2liaWxpdHkKICAgICB2b2lkIHNldFZpc2liaWxpdHlDSFJPTUlVTShib29sKTsKIAorICAgIC8v IEdMX0NIUk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlcgorICAgIHZpcnR1YWwgdm9pZCBzZXRHcHVN ZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oUGFzc093blB0cjxFeHRlbnNp b25zM0RDaHJvbWl1bTo6R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVN Pik7CisKICAgICAvLyBHTF9DSFJPTUlVTV9mcmFtZWJ1ZmZlcl9tdWx0aXNhbXBsZQogICAgIHZv aWQgYmxpdEZyYW1lYnVmZmVyQ0hST01JVU0oR0MzRGludCBzcmNYMCwgR0MzRGludCBzcmNZMCwg R0MzRGludCBzcmNYMSwgR0MzRGludCBzcmNZMSwgR0MzRGludCBkc3RYMCwgR0MzRGludCBkc3RZ MCwgR0MzRGludCBkc3RYMSwgR0MzRGludCBkc3RZMSwgR0MzRGJpdGZpZWxkIG1hc2ssIEdDM0Rl bnVtIGZpbHRlcik7CiAgICAgdm9pZCByZW5kZXJidWZmZXJTdG9yYWdlTXVsdGlzYW1wbGVDSFJP TUlVTShHQzNEZW51bSB0YXJnZXQsIEdDM0RzaXplaSBzYW1wbGVzLCBHQzNEZW51bSBpbnRlcm5h bGZvcm1hdCwgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0KTsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNELmgg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0Zha2VXZWJHcmFwaGljc0NvbnRleHQzRC5o CmluZGV4IGNmMDY1MWI3NzAzMmJkODBlNTgzYzY2ODI3NzQ2Mjg4NjA1NWRkYjguLmFlMjdkYTcz MDJjN2ZjNTE5NGY2MmRlNDliOTU3ZTIzMGRlMjcyYzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vdGVzdHMvRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNELmgKKysrIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS90ZXN0cy9GYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QuaApAQCAtNjUs NiArNjUsOCBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIHZvaWQgc2V0VmlzaWJpbGl0eUNIUk9N SVVNKGJvb2wgdmlzaWJsZSkgeyB9CiAKKyAgICB2aXJ0dWFsIHZvaWQgc2V0TWVtb3J5QWxsb2Nh dGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNo YW5nZWRDYWxsYmFja0NIUk9NSVVNKiBjYWxsYmFjaykgeyB9CisKICAgICB2aXJ0dWFsIFdlYlN0 cmluZyBnZXRSZXF1ZXN0YWJsZUV4dGVuc2lvbnNDSFJPTUlVTSgpIHsgcmV0dXJuIFdlYlN0cmlu ZygpOyB9CiAgICAgdmlydHVhbCB2b2lkIHJlcXVlc3RFeHRlbnNpb25DSFJPTUlVTShjb25zdCBj aGFyKikgeyB9CiAK 127021 2012-02-14 12:54:23 -0800 2012-02-14 13:20:54 -0800 Patch bug-77155-20120214155422.patch text/plain 10873 mmocny U3VidmVyc2lvbiBSZXZpc2lvbjogMTA3NzEwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjNlZjcxYTQyZmMxNmRm ZjJiNTNjZjAzNDFkNTNlZjExZTk1MjA5ZS4uNDYwMDg5ODU4ZGY1YTlhZGQ3MDFiMGQ3ZjcwMWQ4 MGVjNDY2MWNlYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEyLTAyLTE0ICBNaWNo YWwgTW9jbnkgIDxtbW9jbnlAZ29vZ2xlLmNvbT4KKworICAgICAgICBbY2hyb21pdW1dIEdMX0NI Uk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlciBleHRlbnNpb24KKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3MTU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9F eHRlbnNpb25zM0RDaHJvbWl1bS5oOgorICAgICAgICAoR3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKFdlYkNvcmU6OkV4dGVuc2lvbnMzRENocm9t aXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU06On5HcHVNZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAoRXh0ZW5zaW9u czNEQ2hyb21pdW0pOgorCiAyMDEyLTAyLTE0ICBDc2FiYSBPc3p0cm9nb27DoWMgIDxvc3N5QHdl YmtpdC5vcmc+CiAKICAgICAgICAgVHlwbyBmaXggYWZ0ZXIgcjEwNzcwNy4KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9DaGFuZ2VMb2cKaW5kZXggYzZlZTgxMGNmZjkxZjhkNThlNWFhODQ0ZTAzM2QwZWZkY2I2NDQz ZC4uNDY5ZTY0MDgwNjU1YThkMjMzNTZjMzM1ZmFkNTNlMGViOWU1NmMyNiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMiBAQAorMjAxMi0wMi0xNCAgTWljaGFsIE1vY255 ICA8bW1vY255QGdvb2dsZS5jb20+CisKKyAgICAgICAgW2Nocm9taXVtXSBHTF9DSFJPTUlVTV9n cHVfbWVtb3J5X21hbmFnZXIgZXh0ZW5zaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD03NzE1NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgICogcHVibGljL3BsYXRmb3JtL1dlYkdyYXBoaWNzQ29udGV4dDNE Lmg6CisgICAgICAgIChXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tD SFJPTUlVTSk6CisgICAgICAgIChXZWJLaXQ6OldlYkdyYXBoaWNzQ29udGV4dDNEOjpXZWJHcmFw aGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTTo6fldlYkdyYXBoaWNz TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKFdlYkdy YXBoaWNzQ29udGV4dDNEKToKKyAgICAgICAgKFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0Q6 OnNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6CisgICAgICAgICog c3JjL0V4dGVuc2lvbnMzRENocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV4dGVuc2lv bnMzRENocm9taXVtOjpzZXRHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01J VU0pOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgICogc3JjL0dyYXBoaWNzQ29udGV4dDNE Q2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0Q6On5HcmFw aGljc0NvbnRleHQzRCk6CisgICAgICAgIChHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRp b25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29u dGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXI6OkdyYXBoaWNzQ29u dGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIpOgorICAgICAgICAo V2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNr QWRhcHRlcjo6fkdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0FkYXB0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxv Y2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcjo6b25NZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZCk6 CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNE UHJpdmF0ZTo6c2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKToK KyAgICAgICAgKiBzcmMvR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlLmg6CisgICAgICAgIChXZWJD b3JlKToKKyAgICAgICAgKiB0ZXN0cy9GYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QuaDoKKyAgICAg ICAgKFdlYktpdDo6RmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEOjpzZXRNZW1vcnlBbGxvY2F0aW9u Q2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAoRmFrZVdlYkdyYXBoaWNzQ29udGV4 dDNEKToKKwogMjAxMi0wMi0xNCAgVnNldm9sb2QgVmxhc292ICA8dnNldmlrQGNocm9taXVtLm9y Zz4KIAogICAgICAgICBXZWIgSW5zcGVjdG9yOiBNYWtlIFNjcmlwdHNOYXZpZ2F0b3IgZGVmYXVs dCBmaWxlIHNlbGVjdG9yLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0V4dGVuc2lvbnMzRENocm9taXVtLmgKaW5kZXggZTE2 NDYwOWFlOTQ3YjE2ZmUxMDYyYTRmZGQ0OTZkMmE2ZTRlN2ZhMy4uNTA5ZGIzM2U4NTNhMDM4MWMy ZWZlNWI0Nzc3Mzg0MDBhMTJlY2NlNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9FeHRlbnNpb25zM0RDaHJvbWl1bS5o CkBAIC04Nyw2ICs4NywxNCBAQCBwdWJsaWM6CiAgICAgLy8gR0xfQ0hST01JVU1fc2V0X3Zpc2li aWxpdHkKICAgICB2b2lkIHNldFZpc2liaWxpdHlDSFJPTUlVTShib29sKTsKIAorICAgIC8vIEdM X0NIUk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlcgorICAgIGNsYXNzIEdwdU1lbW9yeUFsbG9jYXRp b25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSB7CisgICAgcHVibGljOgorICAgICAgICB2aXJ0dWFs IHZvaWQgb25HcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZChzaXplX3QgZ3B1UmVzb3VyY2VTaXpl SW5CeXRlcykgPSAwOworICAgICAgICB2aXJ0dWFsIH5HcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdl ZENhbGxiYWNrQ0hST01JVU0oKSB7IH0KKyAgICB9OworICAgIHZvaWQgc2V0R3B1TWVtb3J5QWxs b2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKFBhc3NPd25QdHI8R3B1TWVtb3J5QWxsb2Nh dGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNPik7CisKICAgICAvLyBHTF9DSFJPTUlVTV9zd2Fw YnVmZmVyc19jb21wbGV0ZV9jYWxsYmFjawogICAgIGNsYXNzIFN3YXBCdWZmZXJzQ29tcGxldGVD YWxsYmFja0NIUk9NSVVNIHsKICAgICBwdWJsaWM6CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRleHQzRC5oIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViR3JhcGhpY3NDb250ZXh0M0QuaApp bmRleCA1N2Y5ZDc5ODUzYTY1NTQ5ZTRlYTA3Y2QwOTBlYWQ4N2E0MDZkMTkyLi4zZWUzNTExNDZi NTUxMzUxYmRhY2RiMDZlMGMzZmViZDVmNmJiNjY3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRleHQzRC5oCisrKyBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdyYXBoaWNzQ29udGV4dDNE LmgKQEAgLTEzMCw2ICsxMzAsMTMgQEAgcHVibGljOgogICAgICAgICB2aXJ0dWFsIH5XZWJHcmFw aGljc1N3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVNKCkgeyB9CiAgICAgfTsKIAor ICAgIGNsYXNzIFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9N SVVNIHsKKyAgICBwdWJsaWM6CisgICAgICAgIHZpcnR1YWwgdm9pZCBvbk1lbW9yeUFsbG9jYXRp b25DaGFuZ2VkKHNpemVfdCBncHVSZXNvdXJjZVNpemVJbkJ5dGVzKSA9IDA7CisgICAgcHJvdGVj dGVkOgorICAgICAgICB2aXJ0dWFsIH5XZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2Vk Q2FsbGJhY2tDSFJPTUlVTSgpIHsgfQorICAgIH07CisKICAgICAvLyBUaGlzIGRlc3RydWN0b3Ig bmVlZHMgdG8gYmUgcHVibGljIHNvIHRoYXQgdXNpbmcgY2xhc3NlcyBjYW4gZGVzdHJveSBpbnN0 YW5jZXMgaWYgaW5pdGlhbGl6YXRpb24gZmFpbHMuCiAgICAgdmlydHVhbCB+V2ViR3JhcGhpY3ND b250ZXh0M0QoKSB7fQogCkBAIC0xNTEsNiArMTU4LDkgQEAgcHVibGljOgogICAgIC8vIEdMX0NI Uk9NSVVNX3NldFZpc2liaWxpdHkgLSBDaGFuZ2VzIHRoZSB2aXNpYmlsaXR5IG9mIHRoZSBiYWNr YnVmZmVyCiAgICAgdmlydHVhbCB2b2lkIHNldFZpc2liaWxpdHlDSFJPTUlVTShib29sIHZpc2li bGUpID0gMDsKIAorICAgIC8vIEdMX0NIUk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlciAtIHNldHMg Y2FsbGJhY2sgdG8gb2JzZXJ2ZSBjaGFuZ2VzIHRvIG1lbW9yeSBhbGxvY2F0aW9uIGxpbWl0cy4K KyAgICB2aXJ0dWFsIHZvaWQgc2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9N SVVNKFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKiBj YWxsYmFjaykgeyB9CisKICAgICAvLyBRdWVyeSB3aGV0aGVyIGl0IGlzIGJ1aWx0IG9uIHRvcCBv ZiBjb21wbGlhbnQgR0xFUzIgaW1wbGVtZW50YXRpb24uCiAgICAgdmlydHVhbCBib29sIGlzR0xF UzJDb21wbGlhbnQoKSA9IDA7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL0V4dGVuc2lvbnMzRENocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L0V4dGVuc2lvbnMzRENocm9taXVtLmNwcAppbmRleCBlY2UwNDA1YWVjNGYxMjAzOTVmZWRkMWIx YzI4ZWIyZjQ4ODE2MGNmLi43MzM5N2JkMmIxNmE3Y2NjZmExODJiYTEyNzY4ZGEwYzdhNTg3NmRi IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9FeHRlbnNpb25zM0RDaHJv bWl1bS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRXh0ZW5zaW9uczNEQ2hy b21pdW0uY3BwCkBAIC0xMDcsNiArMTA3LDExIEBAIHZvaWQgRXh0ZW5zaW9uczNEQ2hyb21pdW06 OnNldFZpc2liaWxpdHlDSFJPTUlVTShib29sIHZpc2liaWxpdHkpCiAgICAgbV9wcml2YXRlLT5z ZXRWaXNpYmlsaXR5Q0hST01JVU0odmlzaWJpbGl0eSk7CiB9CiAKK3ZvaWQgRXh0ZW5zaW9uczNE Q2hyb21pdW06OnNldEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShQ YXNzT3duUHRyPEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTT4gY2Fs bGJhY2spCit7CisgICAgbV9wcml2YXRlLT5zZXRHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENh bGxiYWNrQ0hST01JVU0oY2FsbGJhY2spOworfQorCiBQbGF0Zm9ybTNET2JqZWN0IEV4dGVuc2lv bnMzRENocm9taXVtOjpjcmVhdGVWZXJ0ZXhBcnJheU9FUygpCiB7CiAgICAgcmV0dXJuIDA7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRENo cm9taXVtLmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNE Q2hyb21pdW0uY3BwCmluZGV4IGNiYmY1YzU4MWFkZmMzYmViNTkwOTYzMDJhMzBlMGExYjdlY2Nh NGEuLmExZGViMjNmMmU5Y2FkYzJmOWNlZjcxZGNiZjU4ZmQxMTFkNTgwN2EgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0uY3Bw CisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21p dW0uY3BwCkBAIC0xMDM1LDYgKzEwMzUsNyBAQCBHcmFwaGljc0NvbnRleHQzRDo6fkdyYXBoaWNz Q29udGV4dDNEKCkKICAgICBtX3ByaXZhdGUtPnNldENvbnRleHRMb3N0Q2FsbGJhY2sobnVsbHB0 cik7CiAgICAgbV9wcml2YXRlLT5zZXRFcnJvck1lc3NhZ2VDYWxsYmFjayhudWxscHRyKTsKICAg ICBtX3ByaXZhdGUtPnNldFN3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVNKG51bGxw dHIpOworICAgIG1fcHJpdmF0ZS0+c2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0NIUk9NSVVNKG51bGxwdHIpOwogfQogCiBQYXNzUmVmUHRyPEdyYXBoaWNzQ29udGV4dDNEPiBH cmFwaGljc0NvbnRleHQzRDo6Y3JlYXRlKEdyYXBoaWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzIGF0 dHJzLCBIb3N0V2luZG93KiBob3N0V2luZG93LCBHcmFwaGljc0NvbnRleHQzRDo6UmVuZGVyU3R5 bGUgcmVuZGVyU3R5bGUpCkBAIC0xMzU5LDYgKzEzNjAsMzEgQEAgdm9pZCBHcmFwaGljc0NvbnRl eHQzRFByaXZhdGU6OnNldFN3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVNKFBhc3NP d25QdHIKICAgICBtX2ltcGwtPnNldFN3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVN KG1fc3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQWRhcHRlci5nZXQoKSk7CiB9CiAKK2NsYXNz IEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIg OiBwdWJsaWMgV2ViS2l0OjpXZWJHcmFwaGljc0NvbnRleHQzRDo6V2ViR3JhcGhpY3NNZW1vcnlB bGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0geworcHVibGljOgorICAgIEdyYXBoaWNz Q29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIoUGFzc093blB0 cjxFeHRlbnNpb25zM0RDaHJvbWl1bTo6R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0NIUk9NSVVNPiBjYikKKyAgICAgICAgOiBtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJh Y2soY2IpCisgICAgeworICAgIH0KKworICAgIHZpcnR1YWwgfkdyYXBoaWNzQ29udGV4dDNETWVt b3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIoKSB7IH0KKworICAgIHZpcnR1YWwg dm9pZCBvbk1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkKHNpemVfdCBncHVSZXNvdXJjZVNpemVJbkJ5 dGVzKQorICAgIHsKKyAgICAgICAgaWYgKG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj aykKKyAgICAgICAgICAgIG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFjay0+b25HcHVN ZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZChncHVSZXNvdXJjZVNpemVJbkJ5dGVzKTsKKyAgICB9CisK K3ByaXZhdGU6CisgICAgT3duUHRyPEV4dGVuc2lvbnMzRENocm9taXVtOjpHcHVNZW1vcnlBbGxv Y2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0+IG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRD YWxsYmFjazsKK307CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlOjpzZXRHcHVNZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oUGFzc093blB0cjxFeHRlbnNpb25z M0RDaHJvbWl1bTo6R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNPiBj YikKK3sKKyAgICBtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyID0gYWRv cHRQdHIobmV3IEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0FkYXB0ZXIoY2IpKTsKKyAgICBtX2ltcGwtPnNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2Fs bGJhY2tDSFJPTUlVTShtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyLmdl dCgpKTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gRU5BQkxFKFdF QkdMKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250 ZXh0M0RQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRl eHQzRFByaXZhdGUuaAppbmRleCBmMmQ0OWExMzJjNjQ1Yzg4YjBhMjc5MWFkMzEyM2Y1NjViOWIx Mjk1Li43NDMzY2VlOTFhNzZiNGIwOWI3NTM4NmU5MWE2YTZmNTY5MzExYmIyIDEwMDY0NAotLS0g YS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRFByaXZhdGUuaAor KysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRFByaXZhdGUu aApAQCAtNTEsNiArNTEsNyBAQCBjbGFzcyBFeHRlbnNpb25zM0RDaHJvbWl1bTsKIGNsYXNzIEdy YXBoaWNzQ29udGV4dExvc3RDYWxsYmFja0FkYXB0ZXI7CiBjbGFzcyBHcmFwaGljc0NvbnRleHQz RFN3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0FkYXB0ZXI7CiBjbGFzcyBHcmFwaGljc0Vycm9y TWVzc2FnZUNhbGxiYWNrQWRhcHRlcjsKK2NsYXNzIEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxs b2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXI7CiAKIGNsYXNzIEdyYXBoaWNzQ29udGV4dDNE UHJpdmF0ZSB7CiBwdWJsaWM6CkBAIC0yOTUsNiArMjk2LDkgQEAgcHVibGljOgogICAgIC8vIEdM X0NIUk9NSVVNX3NldF92aXNpYmlsaXR5CiAgICAgdm9pZCBzZXRWaXNpYmlsaXR5Q0hST01JVU0o Ym9vbCk7CiAKKyAgICAvLyBHTF9DSFJPTUlVTV9ncHVfbWVtb3J5X21hbmFnZXIKKyAgICB2aXJ0 dWFsIHZvaWQgc2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKFBh c3NPd25QdHI8RXh0ZW5zaW9uczNEQ2hyb21pdW06OkdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2Vk Q2FsbGJhY2tDSFJPTUlVTT4pOworCiAgICAgLy8gR0xfQ0hST01JVU1fZnJhbWVidWZmZXJfbXVs dGlzYW1wbGUKICAgICB2b2lkIGJsaXRGcmFtZWJ1ZmZlckNIUk9NSVVNKEdDM0RpbnQgc3JjWDAs IEdDM0RpbnQgc3JjWTAsIEdDM0RpbnQgc3JjWDEsIEdDM0RpbnQgc3JjWTEsIEdDM0RpbnQgZHN0 WDAsIEdDM0RpbnQgZHN0WTAsIEdDM0RpbnQgZHN0WDEsIEdDM0RpbnQgZHN0WTEsIEdDM0RiaXRm aWVsZCBtYXNrLCBHQzNEZW51bSBmaWx0ZXIpOwogICAgIHZvaWQgcmVuZGVyYnVmZmVyU3RvcmFn ZU11bHRpc2FtcGxlQ0hST01JVU0oR0MzRGVudW0gdGFyZ2V0LCBHQzNEc2l6ZWkgc2FtcGxlcywg R0MzRGVudW0gaW50ZXJuYWxmb3JtYXQsIEdDM0RzaXplaSB3aWR0aCwgR0MzRHNpemVpIGhlaWdo dCk7CkBAIC0zMjUsNiArMzI5LDcgQEAgcHJpdmF0ZToKICAgICBPd25QdHI8R3JhcGhpY3NDb250 ZXh0TG9zdENhbGxiYWNrQWRhcHRlcj4gbV9jb250ZXh0TG9zdENhbGxiYWNrQWRhcHRlcjsKICAg ICBPd25QdHI8R3JhcGhpY3NFcnJvck1lc3NhZ2VDYWxsYmFja0FkYXB0ZXI+IG1fZXJyb3JNZXNz YWdlQ2FsbGJhY2tBZGFwdGVyOwogICAgIE93blB0cjxHcmFwaGljc0NvbnRleHQzRFN3YXBCdWZm ZXJzQ29tcGxldGVDYWxsYmFja0FkYXB0ZXI+IG1fc3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNr QWRhcHRlcjsKKyAgICBPd25QdHI8R3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hh bmdlZENhbGxiYWNrQWRhcHRlcj4gbV9tZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRh cHRlcjsKICAgICBXZWJLaXQ6OldlYlZpZXdJbXBsKiBtX3dlYlZpZXdJbXBsOwogICAgIGJvb2wg bV9pbml0aWFsaXplZEF2YWlsYWJsZUV4dGVuc2lvbnM7CiAgICAgSGFzaFNldDxTdHJpbmc+IG1f ZW5hYmxlZEV4dGVuc2lvbnM7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rl c3RzL0Zha2VXZWJHcmFwaGljc0NvbnRleHQzRC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90 ZXN0cy9GYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QuaAppbmRleCBjZjA2NTFiNzcwMzJiZDgwZTU4 M2M2NjgyNzc0NjI4ODYwNTVkZGI4Li5hZTI3ZGE3MzAyYzdmYzUxOTRmNjJkZTQ5Yjk1N2UyMzBk ZTI3MmMzIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0Zha2VXZWJH cmFwaGljc0NvbnRleHQzRC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvRmFr ZVdlYkdyYXBoaWNzQ29udGV4dDNELmgKQEAgLTY1LDYgKzY1LDggQEAgcHVibGljOgogCiAgICAg dmlydHVhbCB2b2lkIHNldFZpc2liaWxpdHlDSFJPTUlVTShib29sIHZpc2libGUpIHsgfQogCisg ICAgdmlydHVhbCB2b2lkIHNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlV TShXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSogY2Fs bGJhY2spIHsgfQorCiAgICAgdmlydHVhbCBXZWJTdHJpbmcgZ2V0UmVxdWVzdGFibGVFeHRlbnNp b25zQ0hST01JVU0oKSB7IHJldHVybiBXZWJTdHJpbmcoKTsgfQogICAgIHZpcnR1YWwgdm9pZCBy ZXF1ZXN0RXh0ZW5zaW9uQ0hST01JVU0oY29uc3QgY2hhciopIHsgfQogCg== 127028 2012-02-14 13:21:03 -0800 2012-02-17 06:29:04 -0800 Patch bug-77155-20120214162102.patch text/plain 10875 mmocny U3VidmVyc2lvbiBSZXZpc2lvbjogMTA3NzEwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZjNlZjcxYTQyZmMxNmRm ZjJiNTNjZjAzNDFkNTNlZjExZTk1MjA5ZS4uNDYwMDg5ODU4ZGY1YTlhZGQ3MDFiMGQ3ZjcwMWQ4 MGVjNDY2MWNlYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEyLTAyLTE0ICBNaWNo YWwgTW9jbnkgIDxtbW9jbnlAZ29vZ2xlLmNvbT4KKworICAgICAgICBbY2hyb21pdW1dIEdMX0NI Uk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlciBleHRlbnNpb24KKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3MTU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9F eHRlbnNpb25zM0RDaHJvbWl1bS5oOgorICAgICAgICAoR3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKFdlYkNvcmU6OkV4dGVuc2lvbnMzRENocm9t aXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU06On5HcHVNZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAoRXh0ZW5zaW9u czNEQ2hyb21pdW0pOgorCiAyMDEyLTAyLTE0ICBDc2FiYSBPc3p0cm9nb27DoWMgIDxvc3N5QHdl YmtpdC5vcmc+CiAKICAgICAgICAgVHlwbyBmaXggYWZ0ZXIgcjEwNzcwNy4KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9DaGFuZ2VMb2cKaW5kZXggYzZlZTgxMGNmZjkxZjhkNThlNWFhODQ0ZTAzM2QwZWZkY2I2NDQz ZC4uNDY5ZTY0MDgwNjU1YThkMjMzNTZjMzM1ZmFkNTNlMGViOWU1NmMyNiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMiBAQAorMjAxMi0wMi0xNCAgTWljaGFsIE1vY255 ICA8bW1vY255QGdvb2dsZS5jb20+CisKKyAgICAgICAgW2Nocm9taXVtXSBHTF9DSFJPTUlVTV9n cHVfbWVtb3J5X21hbmFnZXIgZXh0ZW5zaW9uCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD03NzE1NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgICogcHVibGljL3BsYXRmb3JtL1dlYkdyYXBoaWNzQ29udGV4dDNE Lmg6CisgICAgICAgIChXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tD SFJPTUlVTSk6CisgICAgICAgIChXZWJLaXQ6OldlYkdyYXBoaWNzQ29udGV4dDNEOjpXZWJHcmFw aGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTTo6fldlYkdyYXBoaWNz TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKFdlYkdy YXBoaWNzQ29udGV4dDNEKToKKyAgICAgICAgKFdlYktpdDo6V2ViR3JhcGhpY3NDb250ZXh0M0Q6 OnNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6CisgICAgICAgICog c3JjL0V4dGVuc2lvbnMzRENocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkV4dGVuc2lv bnMzRENocm9taXVtOjpzZXRHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01J VU0pOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgICogc3JjL0dyYXBoaWNzQ29udGV4dDNE Q2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0Q6On5HcmFw aGljc0NvbnRleHQzRCk6CisgICAgICAgIChHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRp b25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29u dGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXI6OkdyYXBoaWNzQ29u dGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIpOgorICAgICAgICAo V2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNr QWRhcHRlcjo6fkdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0FkYXB0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxv Y2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcjo6b25NZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZCk6 CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNE UHJpdmF0ZTo6c2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKToK KyAgICAgICAgKiBzcmMvR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlLmg6CisgICAgICAgIChXZWJD b3JlKToKKyAgICAgICAgKiB0ZXN0cy9GYWtlV2ViR3JhcGhpY3NDb250ZXh0M0QuaDoKKyAgICAg ICAgKFdlYktpdDo6RmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEOjpzZXRNZW1vcnlBbGxvY2F0aW9u Q2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAoRmFrZVdlYkdyYXBoaWNzQ29udGV4 dDNEKToKKwogMjAxMi0wMi0xNCAgVnNldm9sb2QgVmxhc292ICA8dnNldmlrQGNocm9taXVtLm9y Zz4KIAogICAgICAgICBXZWIgSW5zcGVjdG9yOiBNYWtlIFNjcmlwdHNOYXZpZ2F0b3IgZGVmYXVs dCBmaWxlIHNlbGVjdG9yLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3Jh cGhpY3MvY2hyb21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3JlL3Bs YXRmb3JtL2dyYXBoaWNzL2Nocm9taXVtL0V4dGVuc2lvbnMzRENocm9taXVtLmgKaW5kZXggZTE2 NDYwOWFlOTQ3YjE2ZmUxMDYyYTRmZGQ0OTZkMmE2ZTRlN2ZhMy4uNTA5ZGIzM2U4NTNhMDM4MWMy ZWZlNWI0Nzc3Mzg0MDBhMTJlY2NlNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZv cm0vZ3JhcGhpY3MvY2hyb21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9wbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9FeHRlbnNpb25zM0RDaHJvbWl1bS5o CkBAIC04Nyw2ICs4NywxNCBAQCBwdWJsaWM6CiAgICAgLy8gR0xfQ0hST01JVU1fc2V0X3Zpc2li aWxpdHkKICAgICB2b2lkIHNldFZpc2liaWxpdHlDSFJPTUlVTShib29sKTsKIAorICAgIC8vIEdM X0NIUk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlcgorICAgIGNsYXNzIEdwdU1lbW9yeUFsbG9jYXRp b25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSB7CisgICAgcHVibGljOgorICAgICAgICB2aXJ0dWFs IHZvaWQgb25HcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZChzaXplX3QgZ3B1UmVzb3VyY2VTaXpl SW5CeXRlcykgPSAwOworICAgICAgICB2aXJ0dWFsIH5HcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdl ZENhbGxiYWNrQ0hST01JVU0oKSB7IH0KKyAgICB9OworICAgIHZvaWQgc2V0R3B1TWVtb3J5QWxs b2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKFBhc3NPd25QdHI8R3B1TWVtb3J5QWxsb2Nh dGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNPik7CisKICAgICAvLyBHTF9DSFJPTUlVTV9zd2Fw YnVmZmVyc19jb21wbGV0ZV9jYWxsYmFjawogICAgIGNsYXNzIFN3YXBCdWZmZXJzQ29tcGxldGVD YWxsYmFja0NIUk9NSVVNIHsKICAgICBwdWJsaWM6CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRleHQzRC5oIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViR3JhcGhpY3NDb250ZXh0M0QuaApp bmRleCA1N2Y5ZDc5ODUzYTY1NTQ5ZTRlYTA3Y2QwOTBlYWQ4N2E0MDZkMTkyLi5mMTNmN2M0NGQ5 YzJiMGU3YWVlMTJiMTg5NWUxMWRjMWIyYTA4OTAyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0 L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRleHQzRC5oCisrKyBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdyYXBoaWNzQ29udGV4dDNE LmgKQEAgLTEzMCw2ICsxMzAsMTQgQEAgcHVibGljOgogICAgICAgICB2aXJ0dWFsIH5XZWJHcmFw aGljc1N3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVNKCkgeyB9CiAgICAgfTsKIAor ICAgIGNsYXNzIFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9N SVVNIHsKKyAgICBwdWJsaWM6CisgICAgICAgIHZpcnR1YWwgdm9pZCBvbk1lbW9yeUFsbG9jYXRp b25DaGFuZ2VkKHNpemVfdCBncHVSZXNvdXJjZVNpemVJbkJ5dGVzKSA9IDA7CisKKyAgICBwcm90 ZWN0ZWQ6CisgICAgICAgIHZpcnR1YWwgfldlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0NIUk9NSVVNKCkgeyB9CisgICAgfTsKKwogICAgIC8vIFRoaXMgZGVzdHJ1Y3Rv ciBuZWVkcyB0byBiZSBwdWJsaWMgc28gdGhhdCB1c2luZyBjbGFzc2VzIGNhbiBkZXN0cm95IGlu c3RhbmNlcyBpZiBpbml0aWFsaXphdGlvbiBmYWlscy4KICAgICB2aXJ0dWFsIH5XZWJHcmFwaGlj c0NvbnRleHQzRCgpIHt9CiAKQEAgLTE1MSw2ICsxNTksOSBAQCBwdWJsaWM6CiAgICAgLy8gR0xf Q0hST01JVU1fc2V0VmlzaWJpbGl0eSAtIENoYW5nZXMgdGhlIHZpc2liaWxpdHkgb2YgdGhlIGJh Y2tidWZmZXIKICAgICB2aXJ0dWFsIHZvaWQgc2V0VmlzaWJpbGl0eUNIUk9NSVVNKGJvb2wgdmlz aWJsZSkgPSAwOwogCisgICAgLy8gR0xfQ0hST01JVU1fZ3B1X21lbW9yeV9tYW5hZ2VyIC0gc2V0 cyBjYWxsYmFjayB0byBvYnNlcnZlIGNoYW5nZXMgdG8gbWVtb3J5IGFsbG9jYXRpb24gbGltaXRz LgorICAgIHZpcnR1YWwgdm9pZCBzZXRNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hS T01JVU0oV2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0q IGNhbGxiYWNrKSB7IH0KKwogICAgIC8vIFF1ZXJ5IHdoZXRoZXIgaXQgaXMgYnVpbHQgb24gdG9w IG9mIGNvbXBsaWFudCBHTEVTMiBpbXBsZW1lbnRhdGlvbi4KICAgICB2aXJ0dWFsIGJvb2wgaXNH TEVTMkNvbXBsaWFudCgpID0gMDsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvRXh0ZW5zaW9uczNEQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9z cmMvRXh0ZW5zaW9uczNEQ2hyb21pdW0uY3BwCmluZGV4IGVjZTA0MDVhZWM0ZjEyMDM5NWZlZGQx YjFjMjhlYjJmNDg4MTYwY2YuLjczMzk3YmQyYjE2YTdjY2NmYTE4MmJhMTI3NjhkYTBjN2E1ODc2 ZGIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0V4dGVuc2lvbnMzRENo cm9taXVtLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9FeHRlbnNpb25zM0RD aHJvbWl1bS5jcHAKQEAgLTEwNyw2ICsxMDcsMTEgQEAgdm9pZCBFeHRlbnNpb25zM0RDaHJvbWl1 bTo6c2V0VmlzaWJpbGl0eUNIUk9NSVVNKGJvb2wgdmlzaWJpbGl0eSkKICAgICBtX3ByaXZhdGUt PnNldFZpc2liaWxpdHlDSFJPTUlVTSh2aXNpYmlsaXR5KTsKIH0KIAordm9pZCBFeHRlbnNpb25z M0RDaHJvbWl1bTo6c2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVN KFBhc3NPd25QdHI8R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNPiBj YWxsYmFjaykKK3sKKyAgICBtX3ByaXZhdGUtPnNldEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2Vk Q2FsbGJhY2tDSFJPTUlVTShjYWxsYmFjayk7Cit9CisKIFBsYXRmb3JtM0RPYmplY3QgRXh0ZW5z aW9uczNEQ2hyb21pdW06OmNyZWF0ZVZlcnRleEFycmF5T0VTKCkKIHsKICAgICByZXR1cm4gMDsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNE Q2hyb21pdW0uY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0 M0RDaHJvbWl1bS5jcHAKaW5kZXggY2JiZjVjNTgxYWRmYzNiZWI1OTA5NjMwMmEzMGUwYTFiN2Vj Y2E0YS4uYTFkZWIyM2YyZTljYWRjMmY5Y2VmNzFkY2JmNThmZDExMWQ1ODA3YSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RDaHJvbWl1bS5j cHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RDaHJv bWl1bS5jcHAKQEAgLTEwMzUsNiArMTAzNSw3IEBAIEdyYXBoaWNzQ29udGV4dDNEOjp+R3JhcGhp Y3NDb250ZXh0M0QoKQogICAgIG1fcHJpdmF0ZS0+c2V0Q29udGV4dExvc3RDYWxsYmFjayhudWxs cHRyKTsKICAgICBtX3ByaXZhdGUtPnNldEVycm9yTWVzc2FnZUNhbGxiYWNrKG51bGxwdHIpOwog ICAgIG1fcHJpdmF0ZS0+c2V0U3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQ0hST01JVU0obnVs bHB0cik7CisgICAgbV9wcml2YXRlLT5zZXRHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxi YWNrQ0hST01JVU0obnVsbHB0cik7CiB9CiAKIFBhc3NSZWZQdHI8R3JhcGhpY3NDb250ZXh0M0Q+ IEdyYXBoaWNzQ29udGV4dDNEOjpjcmVhdGUoR3JhcGhpY3NDb250ZXh0M0Q6OkF0dHJpYnV0ZXMg YXR0cnMsIEhvc3RXaW5kb3cqIGhvc3RXaW5kb3csIEdyYXBoaWNzQ29udGV4dDNEOjpSZW5kZXJT dHlsZSByZW5kZXJTdHlsZSkKQEAgLTEzNTksNiArMTM2MCwzMSBAQCB2b2lkIEdyYXBoaWNzQ29u dGV4dDNEUHJpdmF0ZTo6c2V0U3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQ0hST01JVU0oUGFz c093blB0cgogICAgIG1faW1wbC0+c2V0U3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQ0hST01J VU0obV9zd2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJhY2tBZGFwdGVyLmdldCgpKTsKIH0KIAorY2xh c3MgR3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRl ciA6IHB1YmxpYyBXZWJLaXQ6OldlYkdyYXBoaWNzQ29udGV4dDNEOjpXZWJHcmFwaGljc01lbW9y eUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSB7CitwdWJsaWM6CisgICAgR3JhcGhp Y3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcihQYXNzT3du UHRyPEV4dGVuc2lvbnMzRENocm9taXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxi YWNrQ0hST01JVU0+IGNiKQorICAgICAgICA6IG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxs YmFjayhjYikKKyAgICB7CisgICAgfQorCisgICAgdmlydHVhbCB+R3JhcGhpY3NDb250ZXh0M0RN ZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcigpIHsgfQorCisgICAgdmlydHVh bCB2b2lkIG9uTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQoc2l6ZV90IGdwdVJlc291cmNlU2l6ZUlu Qnl0ZXMpCisgICAgeworICAgICAgICBpZiAobV9tZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxi YWNrKQorICAgICAgICAgICAgbV9tZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrLT5vbkdw dU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkKGdwdVJlc291cmNlU2l6ZUluQnl0ZXMpOworICAgIH0K KworcHJpdmF0ZToKKyAgICBPd25QdHI8RXh0ZW5zaW9uczNEQ2hyb21pdW06OkdwdU1lbW9yeUFs bG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTT4gbV9tZW1vcnlBbGxvY2F0aW9uQ2hhbmdl ZENhbGxiYWNrOworfTsKKwordm9pZCBHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6OnNldEdwdU1l bW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShQYXNzT3duUHRyPEV4dGVuc2lv bnMzRENocm9taXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0+ IGNiKQoreworICAgIG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIgPSBh ZG9wdFB0cihuZXcgR3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxi YWNrQWRhcHRlcihjYikpOworICAgIG1faW1wbC0+c2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRD YWxsYmFja0NIUk9NSVVNKG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIu Z2V0KCkpOworfQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBFTkFCTEUo V0VCR0wpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0Nv bnRleHQzRFByaXZhdGUuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29u dGV4dDNEUHJpdmF0ZS5oCmluZGV4IGYyZDQ5YTEzMmM2NDVjODhiMGEyNzkxYWQzMTIzZjU2NWI5 YjEyOTUuLjc0MzNjZWU5MWE3NmI0YjA5Yjc1Mzg2ZTkxYTZhNmY1NjkzMTFiYjIgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZS5o CisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEUHJpdmF0 ZS5oCkBAIC01MSw2ICs1MSw3IEBAIGNsYXNzIEV4dGVuc2lvbnMzRENocm9taXVtOwogY2xhc3Mg R3JhcGhpY3NDb250ZXh0TG9zdENhbGxiYWNrQWRhcHRlcjsKIGNsYXNzIEdyYXBoaWNzQ29udGV4 dDNEU3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQWRhcHRlcjsKIGNsYXNzIEdyYXBoaWNzRXJy b3JNZXNzYWdlQ2FsbGJhY2tBZGFwdGVyOworY2xhc3MgR3JhcGhpY3NDb250ZXh0M0RNZW1vcnlB bGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcjsKIAogY2xhc3MgR3JhcGhpY3NDb250ZXh0 M0RQcml2YXRlIHsKIHB1YmxpYzoKQEAgLTI5NSw2ICsyOTYsOSBAQCBwdWJsaWM6CiAgICAgLy8g R0xfQ0hST01JVU1fc2V0X3Zpc2liaWxpdHkKICAgICB2b2lkIHNldFZpc2liaWxpdHlDSFJPTUlV TShib29sKTsKIAorICAgIC8vIEdMX0NIUk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlcgorICAgIHZp cnR1YWwgdm9pZCBzZXRHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0o UGFzc093blB0cjxFeHRlbnNpb25zM0RDaHJvbWl1bTo6R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0NIUk9NSVVNPik7CisKICAgICAvLyBHTF9DSFJPTUlVTV9mcmFtZWJ1ZmZlcl9t dWx0aXNhbXBsZQogICAgIHZvaWQgYmxpdEZyYW1lYnVmZmVyQ0hST01JVU0oR0MzRGludCBzcmNY MCwgR0MzRGludCBzcmNZMCwgR0MzRGludCBzcmNYMSwgR0MzRGludCBzcmNZMSwgR0MzRGludCBk c3RYMCwgR0MzRGludCBkc3RZMCwgR0MzRGludCBkc3RYMSwgR0MzRGludCBkc3RZMSwgR0MzRGJp dGZpZWxkIG1hc2ssIEdDM0RlbnVtIGZpbHRlcik7CiAgICAgdm9pZCByZW5kZXJidWZmZXJTdG9y YWdlTXVsdGlzYW1wbGVDSFJPTUlVTShHQzNEZW51bSB0YXJnZXQsIEdDM0RzaXplaSBzYW1wbGVz LCBHQzNEZW51bSBpbnRlcm5hbGZvcm1hdCwgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVp Z2h0KTsKQEAgLTMyNSw2ICszMjksNyBAQCBwcml2YXRlOgogICAgIE93blB0cjxHcmFwaGljc0Nv bnRleHRMb3N0Q2FsbGJhY2tBZGFwdGVyPiBtX2NvbnRleHRMb3N0Q2FsbGJhY2tBZGFwdGVyOwog ICAgIE93blB0cjxHcmFwaGljc0Vycm9yTWVzc2FnZUNhbGxiYWNrQWRhcHRlcj4gbV9lcnJvck1l c3NhZ2VDYWxsYmFja0FkYXB0ZXI7CiAgICAgT3duUHRyPEdyYXBoaWNzQ29udGV4dDNEU3dhcEJ1 ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQWRhcHRlcj4gbV9zd2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJh Y2tBZGFwdGVyOworICAgIE93blB0cjxHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25D aGFuZ2VkQ2FsbGJhY2tBZGFwdGVyPiBtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tB ZGFwdGVyOwogICAgIFdlYktpdDo6V2ViVmlld0ltcGwqIG1fd2ViVmlld0ltcGw7CiAgICAgYm9v bCBtX2luaXRpYWxpemVkQXZhaWxhYmxlRXh0ZW5zaW9uczsKICAgICBIYXNoU2V0PFN0cmluZz4g bV9lbmFibGVkRXh0ZW5zaW9uczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v dGVzdHMvRmFrZVdlYkdyYXBoaWNzQ29udGV4dDNELmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3Rlc3RzL0Zha2VXZWJHcmFwaGljc0NvbnRleHQzRC5oCmluZGV4IGNmMDY1MWI3NzAzMmJkODBl NTgzYzY2ODI3NzQ2Mjg4NjA1NWRkYjguLmFlMjdkYTczMDJjN2ZjNTE5NGY2MmRlNDliOTU3ZTIz MGRlMjcyYzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvRmFrZVdl YkdyYXBoaWNzQ29udGV4dDNELmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9G YWtlV2ViR3JhcGhpY3NDb250ZXh0M0QuaApAQCAtNjUsNiArNjUsOCBAQCBwdWJsaWM6CiAKICAg ICB2aXJ0dWFsIHZvaWQgc2V0VmlzaWJpbGl0eUNIUk9NSVVNKGJvb2wgdmlzaWJsZSkgeyB9CiAK KyAgICB2aXJ0dWFsIHZvaWQgc2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9N SVVNKFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKiBj YWxsYmFjaykgeyB9CisKICAgICB2aXJ0dWFsIFdlYlN0cmluZyBnZXRSZXF1ZXN0YWJsZUV4dGVu c2lvbnNDSFJPTUlVTSgpIHsgcmV0dXJuIFdlYlN0cmluZygpOyB9CiAgICAgdmlydHVhbCB2b2lk IHJlcXVlc3RFeHRlbnNpb25DSFJPTUlVTShjb25zdCBjaGFyKikgeyB9CiAK 127580 2012-02-17 06:29:07 -0800 2012-02-17 09:03:03 -0800 Patch bug-77155-20120217092906.patch text/plain 10866 mmocny U3VidmVyc2lvbiBSZXZpc2lvbjogMTA4MDY2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMTdiYTFkZWQzNmRkYjRh OWM1MjY0YjE0NGE4OGUxOWIyYjBhMzI2MC4uNmJlNWYzMzc2YmQyNWVkZWQxNWFlNWFlZGQ2YmMy ZmM4YzRkNTQwZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEyLTAyLTE3ICBNaWNo YWwgTW9jbnkgIDxtbW9jbnlAZ29vZ2xlLmNvbT4KKworICAgICAgICBbY2hyb21pdW1dIEdMX0NI Uk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlciBleHRlbnNpb24KKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3MTU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg SmFtZXMgUm9iaW5zb24uCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9F eHRlbnNpb25zM0RDaHJvbWl1bS5oOgorICAgICAgICAoR3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKFdlYkNvcmU6OkV4dGVuc2lvbnMzRENocm9t aXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU06On5HcHVNZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAoRXh0ZW5zaW9u czNEQ2hyb21pdW0pOgorCiAyMDEyLTAyLTE3ICBQYXZlbCBGZWxkbWFuICA8cGZlbGRtYW5AZ29v Z2xlLmNvbT4KIAogICAgICAgICBXZWIgSW5zcGVjdG9yOiBhIGJpdCBvZiBjb2xvciBwaWNrZXIg cG9saXNoCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZyBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCmluZGV4IDNhYmU1YjA3MDdlOTI5MzA2NTg3 N2ZhYTQwNWNhMTg0MjBmZGE4N2MuLjUwZTYxOTc3NTY5MWZlOWZhODI5ZDM0MmNkMjI3ZTM2M2Y5 YTUxMjcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCisrKyBi L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzIgQEAKKzIwMTIt MDItMTcgIE1pY2hhbCBNb2NueSAgPG1tb2NueUBnb29nbGUuY29tPgorCisgICAgICAgIFtjaHJv bWl1bV0gR0xfQ0hST01JVU1fZ3B1X21lbW9yeV9tYW5hZ2VyIGV4dGVuc2lvbgorICAgICAgICBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9NzcxNTUKKworICAgICAgICBS ZXZpZXdlZCBieSBKYW1lcyBSb2JpbnNvbi4KKworICAgICAgICAqIHB1YmxpYy9wbGF0Zm9ybS9X ZWJHcmFwaGljc0NvbnRleHQzRC5oOgorICAgICAgICAoV2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0 aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAoV2ViS2l0OjpXZWJHcmFwaGlj c0NvbnRleHQzRDo6V2ViR3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hS T01JVU06On5XZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlV TSk6CisgICAgICAgIChXZWJHcmFwaGljc0NvbnRleHQzRCk6CisgICAgICAgIChXZWJLaXQ6Oldl YkdyYXBoaWNzQ29udGV4dDNEOjpzZXRNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hS T01JVU0pOgorICAgICAgICAqIHNyYy9FeHRlbnNpb25zM0RDaHJvbWl1bS5jcHA6CisgICAgICAg IChXZWJDb3JlOjpFeHRlbnNpb25zM0RDaHJvbWl1bTo6c2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNo YW5nZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAqIHNy Yy9HcmFwaGljc0NvbnRleHQzRENocm9taXVtLmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBo aWNzQ29udGV4dDNEOjp+R3JhcGhpY3NDb250ZXh0M0QpOgorICAgICAgICAoR3JhcGhpY3NDb250 ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcik6CisgICAgICAgIChX ZWJDb3JlOjpHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tB ZGFwdGVyOjpHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tB ZGFwdGVyKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2Nh dGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXI6On5HcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9j YXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyKToKKyAgICAgICAgKFdlYkNvcmU6OkdyYXBoaWNz Q29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXI6Om9uTWVtb3J5 QWxsb2NhdGlvbkNoYW5nZWQpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3Jl OjpHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6OnNldEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2Vk Q2FsbGJhY2tDSFJPTUlVTSk6CisgICAgICAgICogc3JjL0dyYXBoaWNzQ29udGV4dDNEUHJpdmF0 ZS5oOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgICogdGVzdHMvRmFrZVdlYkdyYXBoaWNz Q29udGV4dDNELmg6CisgICAgICAgIChXZWJLaXQ6OkZha2VXZWJHcmFwaGljc0NvbnRleHQzRDo6 c2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKEZh a2VXZWJHcmFwaGljc0NvbnRleHQzRCk6CisKIDIwMTItMDItMTcgIElseWEgVGlraG9ub3Zza3kg IDxsb2lzbG9AY2hyb21pdW0ub3JnPgogCiAgICAgICAgIFVucmV2aWV3ZWQuIENocm9taXVtIERF UFMgcm9sbApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hy b21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaCBiL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0V4dGVuc2lvbnMzRENocm9taXVtLmgKaW5kZXggZTE2NDYwOWFlOTQ3 YjE2ZmUxMDYyYTRmZGQ0OTZkMmE2ZTRlN2ZhMy4uNTA5ZGIzM2U4NTNhMDM4MWMyZWZlNWI0Nzc3 Mzg0MDBhMTJlY2NlNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvcGxhdGZvcm0vZ3JhcGhp Y3MvY2hyb21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9w bGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9FeHRlbnNpb25zM0RDaHJvbWl1bS5oCkBAIC04Nyw2 ICs4NywxNCBAQCBwdWJsaWM6CiAgICAgLy8gR0xfQ0hST01JVU1fc2V0X3Zpc2liaWxpdHkKICAg ICB2b2lkIHNldFZpc2liaWxpdHlDSFJPTUlVTShib29sKTsKIAorICAgIC8vIEdMX0NIUk9NSVVN X2dwdV9tZW1vcnlfbWFuYWdlcgorICAgIGNsYXNzIEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2Vk Q2FsbGJhY2tDSFJPTUlVTSB7CisgICAgcHVibGljOgorICAgICAgICB2aXJ0dWFsIHZvaWQgb25H cHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZChzaXplX3QgZ3B1UmVzb3VyY2VTaXplSW5CeXRlcykg PSAwOworICAgICAgICB2aXJ0dWFsIH5HcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNr Q0hST01JVU0oKSB7IH0KKyAgICB9OworICAgIHZvaWQgc2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNo YW5nZWRDYWxsYmFja0NIUk9NSVVNKFBhc3NPd25QdHI8R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0NIUk9NSVVNPik7CisKICAgICAvLyBHTF9DSFJPTUlVTV9zd2FwYnVmZmVyc19j b21wbGV0ZV9jYWxsYmFjawogICAgIGNsYXNzIFN3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0NI Uk9NSVVNIHsKICAgICBwdWJsaWM6CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3B1YmxpYy9wbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRleHQzRC5oIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViR3JhcGhpY3NDb250ZXh0M0QuaAppbmRleCA1N2Y5 ZDc5ODUzYTY1NTQ5ZTRlYTA3Y2QwOTBlYWQ4N2E0MDZkMTkyLi5mMTNmN2M0NGQ5YzJiMGU3YWVl MTJiMTg5NWUxMWRjMWIyYTA4OTAyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3B1YmxpYy9wbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRleHQzRC5oCisrKyBiL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdyYXBoaWNzQ29udGV4dDNELmgKQEAgLTEz MCw2ICsxMzAsMTQgQEAgcHVibGljOgogICAgICAgICB2aXJ0dWFsIH5XZWJHcmFwaGljc1N3YXBC dWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVNKCkgeyB9CiAgICAgfTsKIAorICAgIGNsYXNz IFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNIHsKKyAg ICBwdWJsaWM6CisgICAgICAgIHZpcnR1YWwgdm9pZCBvbk1lbW9yeUFsbG9jYXRpb25DaGFuZ2Vk KHNpemVfdCBncHVSZXNvdXJjZVNpemVJbkJ5dGVzKSA9IDA7CisKKyAgICBwcm90ZWN0ZWQ6Cisg ICAgICAgIHZpcnR1YWwgfldlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0NIUk9NSVVNKCkgeyB9CisgICAgfTsKKwogICAgIC8vIFRoaXMgZGVzdHJ1Y3RvciBuZWVkcyB0 byBiZSBwdWJsaWMgc28gdGhhdCB1c2luZyBjbGFzc2VzIGNhbiBkZXN0cm95IGluc3RhbmNlcyBp ZiBpbml0aWFsaXphdGlvbiBmYWlscy4KICAgICB2aXJ0dWFsIH5XZWJHcmFwaGljc0NvbnRleHQz RCgpIHt9CiAKQEAgLTE1MSw2ICsxNTksOSBAQCBwdWJsaWM6CiAgICAgLy8gR0xfQ0hST01JVU1f c2V0VmlzaWJpbGl0eSAtIENoYW5nZXMgdGhlIHZpc2liaWxpdHkgb2YgdGhlIGJhY2tidWZmZXIK ICAgICB2aXJ0dWFsIHZvaWQgc2V0VmlzaWJpbGl0eUNIUk9NSVVNKGJvb2wgdmlzaWJsZSkgPSAw OwogCisgICAgLy8gR0xfQ0hST01JVU1fZ3B1X21lbW9yeV9tYW5hZ2VyIC0gc2V0cyBjYWxsYmFj ayB0byBvYnNlcnZlIGNoYW5nZXMgdG8gbWVtb3J5IGFsbG9jYXRpb24gbGltaXRzLgorICAgIHZp cnR1YWwgdm9pZCBzZXRNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oV2Vi R3JhcGhpY3NNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0qIGNhbGxiYWNr KSB7IH0KKwogICAgIC8vIFF1ZXJ5IHdoZXRoZXIgaXQgaXMgYnVpbHQgb24gdG9wIG9mIGNvbXBs aWFudCBHTEVTMiBpbXBsZW1lbnRhdGlvbi4KICAgICB2aXJ0dWFsIGJvb2wgaXNHTEVTMkNvbXBs aWFudCgpID0gMDsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRXh0 ZW5zaW9uczNEQ2hyb21pdW0uY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRXh0ZW5z aW9uczNEQ2hyb21pdW0uY3BwCmluZGV4IGVjZTA0MDVhZWM0ZjEyMDM5NWZlZGQxYjFjMjhlYjJm NDg4MTYwY2YuLjczMzk3YmQyYjE2YTdjY2NmYTE4MmJhMTI3NjhkYTBjN2E1ODc2ZGIgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0V4dGVuc2lvbnMzRENocm9taXVtLmNw cAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9FeHRlbnNpb25zM0RDaHJvbWl1bS5j cHAKQEAgLTEwNyw2ICsxMDcsMTEgQEAgdm9pZCBFeHRlbnNpb25zM0RDaHJvbWl1bTo6c2V0Vmlz aWJpbGl0eUNIUk9NSVVNKGJvb2wgdmlzaWJpbGl0eSkKICAgICBtX3ByaXZhdGUtPnNldFZpc2li aWxpdHlDSFJPTUlVTSh2aXNpYmlsaXR5KTsKIH0KIAordm9pZCBFeHRlbnNpb25zM0RDaHJvbWl1 bTo6c2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKFBhc3NPd25Q dHI8R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNPiBjYWxsYmFjaykK K3sKKyAgICBtX3ByaXZhdGUtPnNldEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tD SFJPTUlVTShjYWxsYmFjayk7Cit9CisKIFBsYXRmb3JtM0RPYmplY3QgRXh0ZW5zaW9uczNEQ2hy b21pdW06OmNyZWF0ZVZlcnRleEFycmF5T0VTKCkKIHsKICAgICByZXR1cm4gMDsKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0u Y3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RDaHJvbWl1 bS5jcHAKaW5kZXggY2JiZjVjNTgxYWRmYzNiZWI1OTA5NjMwMmEzMGUwYTFiN2VjY2E0YS4uYTFk ZWIyM2YyZTljYWRjMmY5Y2VmNzFkY2JmNThmZDExMWQ1ODA3YSAxMDA2NDQKLS0tIGEvU291cmNl L1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RDaHJvbWl1bS5jcHAKKysrIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0M0RDaHJvbWl1bS5jcHAK QEAgLTEwMzUsNiArMTAzNSw3IEBAIEdyYXBoaWNzQ29udGV4dDNEOjp+R3JhcGhpY3NDb250ZXh0 M0QoKQogICAgIG1fcHJpdmF0ZS0+c2V0Q29udGV4dExvc3RDYWxsYmFjayhudWxscHRyKTsKICAg ICBtX3ByaXZhdGUtPnNldEVycm9yTWVzc2FnZUNhbGxiYWNrKG51bGxwdHIpOwogICAgIG1fcHJp dmF0ZS0+c2V0U3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQ0hST01JVU0obnVsbHB0cik7Cisg ICAgbV9wcml2YXRlLT5zZXRHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01J VU0obnVsbHB0cik7CiB9CiAKIFBhc3NSZWZQdHI8R3JhcGhpY3NDb250ZXh0M0Q+IEdyYXBoaWNz Q29udGV4dDNEOjpjcmVhdGUoR3JhcGhpY3NDb250ZXh0M0Q6OkF0dHJpYnV0ZXMgYXR0cnMsIEhv c3RXaW5kb3cqIGhvc3RXaW5kb3csIEdyYXBoaWNzQ29udGV4dDNEOjpSZW5kZXJTdHlsZSByZW5k ZXJTdHlsZSkKQEAgLTEzNTksNiArMTM2MCwzMSBAQCB2b2lkIEdyYXBoaWNzQ29udGV4dDNEUHJp dmF0ZTo6c2V0U3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQ0hST01JVU0oUGFzc093blB0cgog ICAgIG1faW1wbC0+c2V0U3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQ0hST01JVU0obV9zd2Fw QnVmZmVyc0NvbXBsZXRlQ2FsbGJhY2tBZGFwdGVyLmdldCgpKTsKIH0KIAorY2xhc3MgR3JhcGhp Y3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlciA6IHB1Ymxp YyBXZWJLaXQ6OldlYkdyYXBoaWNzQ29udGV4dDNEOjpXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRp b25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSB7CitwdWJsaWM6CisgICAgR3JhcGhpY3NDb250ZXh0 M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcihQYXNzT3duUHRyPEV4dGVu c2lvbnMzRENocm9taXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01J VU0+IGNiKQorICAgICAgICA6IG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFjayhjYikK KyAgICB7CisgICAgfQorCisgICAgdmlydHVhbCB+R3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxv Y2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcigpIHsgfQorCisgICAgdmlydHVhbCB2b2lkIG9u TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQoc2l6ZV90IGdwdVJlc291cmNlU2l6ZUluQnl0ZXMpCisg ICAgeworICAgICAgICBpZiAobV9tZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrKQorICAg ICAgICAgICAgbV9tZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrLT5vbkdwdU1lbW9yeUFs bG9jYXRpb25DaGFuZ2VkKGdwdVJlc291cmNlU2l6ZUluQnl0ZXMpOworICAgIH0KKworcHJpdmF0 ZToKKyAgICBPd25QdHI8RXh0ZW5zaW9uczNEQ2hyb21pdW06OkdwdU1lbW9yeUFsbG9jYXRpb25D aGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTT4gbV9tZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNr OworfTsKKwordm9pZCBHcmFwaGljc0NvbnRleHQzRFByaXZhdGU6OnNldEdwdU1lbW9yeUFsbG9j YXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShQYXNzT3duUHRyPEV4dGVuc2lvbnMzRENocm9t aXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0+IGNiKQorewor ICAgIG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIgPSBhZG9wdFB0cihu ZXcgR3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRl cihjYikpOworICAgIG1faW1wbC0+c2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NI Uk9NSVVNKG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIuZ2V0KCkpOwor fQorCiB9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCiAKICNlbmRpZiAvLyBFTkFCTEUoV0VCR0wpCmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRFBy aXZhdGUuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEUHJp dmF0ZS5oCmluZGV4IGYyZDQ5YTEzMmM2NDVjODhiMGEyNzkxYWQzMTIzZjU2NWI5YjEyOTUuLjc0 MzNjZWU5MWE3NmI0YjA5Yjc1Mzg2ZTkxYTZhNmY1NjkzMTFiYjIgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZS5oCisrKyBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZS5oCkBAIC01 MSw2ICs1MSw3IEBAIGNsYXNzIEV4dGVuc2lvbnMzRENocm9taXVtOwogY2xhc3MgR3JhcGhpY3ND b250ZXh0TG9zdENhbGxiYWNrQWRhcHRlcjsKIGNsYXNzIEdyYXBoaWNzQ29udGV4dDNEU3dhcEJ1 ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQWRhcHRlcjsKIGNsYXNzIEdyYXBoaWNzRXJyb3JNZXNzYWdl Q2FsbGJhY2tBZGFwdGVyOworY2xhc3MgR3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9u Q2hhbmdlZENhbGxiYWNrQWRhcHRlcjsKIAogY2xhc3MgR3JhcGhpY3NDb250ZXh0M0RQcml2YXRl IHsKIHB1YmxpYzoKQEAgLTI5NSw2ICsyOTYsOSBAQCBwdWJsaWM6CiAgICAgLy8gR0xfQ0hST01J VU1fc2V0X3Zpc2liaWxpdHkKICAgICB2b2lkIHNldFZpc2liaWxpdHlDSFJPTUlVTShib29sKTsK IAorICAgIC8vIEdMX0NIUk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlcgorICAgIHZpcnR1YWwgdm9p ZCBzZXRHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oUGFzc093blB0 cjxFeHRlbnNpb25zM0RDaHJvbWl1bTo6R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0NIUk9NSVVNPik7CisKICAgICAvLyBHTF9DSFJPTUlVTV9mcmFtZWJ1ZmZlcl9tdWx0aXNhbXBs ZQogICAgIHZvaWQgYmxpdEZyYW1lYnVmZmVyQ0hST01JVU0oR0MzRGludCBzcmNYMCwgR0MzRGlu dCBzcmNZMCwgR0MzRGludCBzcmNYMSwgR0MzRGludCBzcmNZMSwgR0MzRGludCBkc3RYMCwgR0Mz RGludCBkc3RZMCwgR0MzRGludCBkc3RYMSwgR0MzRGludCBkc3RZMSwgR0MzRGJpdGZpZWxkIG1h c2ssIEdDM0RlbnVtIGZpbHRlcik7CiAgICAgdm9pZCByZW5kZXJidWZmZXJTdG9yYWdlTXVsdGlz YW1wbGVDSFJPTUlVTShHQzNEZW51bSB0YXJnZXQsIEdDM0RzaXplaSBzYW1wbGVzLCBHQzNEZW51 bSBpbnRlcm5hbGZvcm1hdCwgR0MzRHNpemVpIHdpZHRoLCBHQzNEc2l6ZWkgaGVpZ2h0KTsKQEAg LTMyNSw2ICszMjksNyBAQCBwcml2YXRlOgogICAgIE93blB0cjxHcmFwaGljc0NvbnRleHRMb3N0 Q2FsbGJhY2tBZGFwdGVyPiBtX2NvbnRleHRMb3N0Q2FsbGJhY2tBZGFwdGVyOwogICAgIE93blB0 cjxHcmFwaGljc0Vycm9yTWVzc2FnZUNhbGxiYWNrQWRhcHRlcj4gbV9lcnJvck1lc3NhZ2VDYWxs YmFja0FkYXB0ZXI7CiAgICAgT3duUHRyPEdyYXBoaWNzQ29udGV4dDNEU3dhcEJ1ZmZlcnNDb21w bGV0ZUNhbGxiYWNrQWRhcHRlcj4gbV9zd2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJhY2tBZGFwdGVy OworICAgIE93blB0cjxHcmFwaGljc0NvbnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2Fs bGJhY2tBZGFwdGVyPiBtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyOwog ICAgIFdlYktpdDo6V2ViVmlld0ltcGwqIG1fd2ViVmlld0ltcGw7CiAgICAgYm9vbCBtX2luaXRp YWxpemVkQXZhaWxhYmxlRXh0ZW5zaW9uczsKICAgICBIYXNoU2V0PFN0cmluZz4gbV9lbmFibGVk RXh0ZW5zaW9uczsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvRmFr ZVdlYkdyYXBoaWNzQ29udGV4dDNELmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0Zh a2VXZWJHcmFwaGljc0NvbnRleHQzRC5oCmluZGV4IGNmMDY1MWI3NzAzMmJkODBlNTgzYzY2ODI3 NzQ2Mjg4NjA1NWRkYjguLmFlMjdkYTczMDJjN2ZjNTE5NGY2MmRlNDliOTU3ZTIzMGRlMjcyYzMg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvRmFrZVdlYkdyYXBoaWNz Q29udGV4dDNELmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9GYWtlV2ViR3Jh cGhpY3NDb250ZXh0M0QuaApAQCAtNjUsNiArNjUsOCBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFs IHZvaWQgc2V0VmlzaWJpbGl0eUNIUk9NSVVNKGJvb2wgdmlzaWJsZSkgeyB9CiAKKyAgICB2aXJ0 dWFsIHZvaWQgc2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKFdlYkdy YXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKiBjYWxsYmFjaykg eyB9CisKICAgICB2aXJ0dWFsIFdlYlN0cmluZyBnZXRSZXF1ZXN0YWJsZUV4dGVuc2lvbnNDSFJP TUlVTSgpIHsgcmV0dXJuIFdlYlN0cmluZygpOyB9CiAgICAgdmlydHVhbCB2b2lkIHJlcXVlc3RF eHRlbnNpb25DSFJPTUlVTShjb25zdCBjaGFyKikgeyB9CiAK 127599 2012-02-17 09:03:08 -0800 2012-02-17 09:08:21 -0800 Patch bug-77155-20120217120307.patch text/plain 10919 mmocny U3VidmVyc2lvbiBSZXZpc2lvbjogMTA4MDgyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDRkMjFmNDI2OTE3NGU2 ZDkwMWViMmM1YjFhOGZjMDg4YzU0ZjE5Zi4uYzdlYTU1ZTM4YWJkZDNjYTEzYzA3MjViZGRiYjYw Y2Y1ZTc1OTQ2OSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEyLTAyLTE3ICBNaWNo YWwgTW9jbnkgIDxtbW9jbnlAZ29vZ2xlLmNvbT4KKworICAgICAgICBbY2hyb21pdW1dIEdMX0NI Uk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlciBleHRlbnNpb24KKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3MTU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg Tk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9F eHRlbnNpb25zM0RDaHJvbWl1bS5oOgorICAgICAgICAoR3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKFdlYkNvcmU6OkV4dGVuc2lvbnMzRENocm9t aXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU06On5HcHVNZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAoRXh0ZW5zaW9u czNEQ2hyb21pdW0pOgorCiAyMDEyLTAyLTE3ICBGbG9yaW4gTWFsaXRhICA8Zm1hbGl0YUBnb29n bGUuY29tPgogCiAgICAgICAgIGNocm9tZS5kbGwhV2ViQ29yZTo6U1ZHVFJlZkVsZW1lbnQ6OnVw ZGF0ZVJlZmVyZW5jZWRUZXh0IFJlYWRBVkBOVUxMIChlODVjYjhlMTQwMDcxZmE3NzkwY2FkMjE1 YjAxMDlkYykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggZDg3M2VhN2QwYjc0MDEwMGE2 NGZhYjM3ODYyMzU2ZjBhMDFlMzgwOC4uYTUwMzUwMTRiYWYwYzYzOTJhYjU5ZmIzMGVhNDhjM2Fk NDU5MGMzZCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysr IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMiBAQAorMjAx Mi0wMi0xNyAgTWljaGFsIE1vY255ICA8bW1vY255QGdvb2dsZS5jb20+CisKKyAgICAgICAgW2No cm9taXVtXSBHTF9DSFJPTUlVTV9ncHVfbWVtb3J5X21hbmFnZXIgZXh0ZW5zaW9uCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NzE1NQorCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogcHVibGljL3BsYXRmb3Jt L1dlYkdyYXBoaWNzQ29udGV4dDNELmg6CisgICAgICAgIChXZWJHcmFwaGljc01lbW9yeUFsbG9j YXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6CisgICAgICAgIChXZWJLaXQ6OldlYkdyYXBo aWNzQ29udGV4dDNEOjpXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tD SFJPTUlVTTo6fldlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9N SVVNKToKKyAgICAgICAgKFdlYkdyYXBoaWNzQ29udGV4dDNEKToKKyAgICAgICAgKFdlYktpdDo6 V2ViR3JhcGhpY3NDb250ZXh0M0Q6OnNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tD SFJPTUlVTSk6CisgICAgICAgICogc3JjL0V4dGVuc2lvbnMzRENocm9taXVtLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkV4dGVuc2lvbnMzRENocm9taXVtOjpzZXRHcHVNZW1vcnlBbGxvY2F0aW9u Q2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgICog c3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6R3Jh cGhpY3NDb250ZXh0M0Q6On5HcmFwaGljc0NvbnRleHQzRCk6CisgICAgICAgIChHcmFwaGljc0Nv bnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyKToKKyAgICAgICAg KFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0FkYXB0ZXI6OkdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0FkYXB0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxv Y2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcjo6fkdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxs b2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhp Y3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcjo6b25NZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZCk6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNv cmU6OkdyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZTo6c2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKiBzcmMvR3JhcGhpY3NDb250ZXh0M0RQcml2 YXRlLmg6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKiB0ZXN0cy9GYWtlV2ViR3JhcGhp Y3NDb250ZXh0M0QuaDoKKyAgICAgICAgKFdlYktpdDo6RmFrZVdlYkdyYXBoaWNzQ29udGV4dDNE OjpzZXRNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAo RmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEKToKKwogMjAxMi0wMi0xNyAgSWx5YSBUaWtob25vdnNr eSAgPGxvaXNsb0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBv dXQgcjEwODA3MS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL0V4dGVuc2lvbnMzRENocm9taXVtLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9FeHRlbnNpb25zM0RDaHJvbWl1bS5oCmluZGV4IGUxNjQ2MDlh ZTk0N2IxNmZlMTA2MmE0ZmRkNDk2ZDJhNmU0ZTdmYTMuLjUwOWRiMzNlODUzYTAzODFjMmVmZTVi NDc3NzM4NDAwYTEyZWNjZTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0V4dGVuc2lvbnMzRENocm9taXVtLmgKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaApAQCAt ODcsNiArODcsMTQgQEAgcHVibGljOgogICAgIC8vIEdMX0NIUk9NSVVNX3NldF92aXNpYmlsaXR5 CiAgICAgdm9pZCBzZXRWaXNpYmlsaXR5Q0hST01JVU0oYm9vbCk7CiAKKyAgICAvLyBHTF9DSFJP TUlVTV9ncHVfbWVtb3J5X21hbmFnZXIKKyAgICBjbGFzcyBHcHVNZW1vcnlBbGxvY2F0aW9uQ2hh bmdlZENhbGxiYWNrQ0hST01JVU0geworICAgIHB1YmxpYzoKKyAgICAgICAgdmlydHVhbCB2b2lk IG9uR3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQoc2l6ZV90IGdwdVJlc291cmNlU2l6ZUluQnl0 ZXMpID0gMDsKKyAgICAgICAgdmlydHVhbCB+R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxs YmFja0NIUk9NSVVNKCkgeyB9CisgICAgfTsKKyAgICB2b2lkIHNldEdwdU1lbW9yeUFsbG9jYXRp b25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShQYXNzT3duUHRyPEdwdU1lbW9yeUFsbG9jYXRpb25D aGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTT4pOworCiAgICAgLy8gR0xfQ0hST01JVU1fc3dhcGJ1ZmZl cnNfY29tcGxldGVfY2FsbGJhY2sKICAgICBjbGFzcyBTd2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJh Y2tDSFJPTUlVTSB7CiAgICAgcHVibGljOgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViR3JhcGhpY3NDb250ZXh0M0QuaCBiL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdyYXBoaWNzQ29udGV4dDNELmgKaW5kZXgg NTdmOWQ3OTg1M2E2NTU0OWU0ZWEwN2NkMDkwZWFkODdhNDA2ZDE5Mi4uZjEzZjdjNDRkOWMyYjBl N2FlZTEyYjE4OTVlMTFkYzFiMmEwODkwMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViR3JhcGhpY3NDb250ZXh0M0QuaAorKysgYi9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRleHQzRC5oCkBA IC0xMzAsNiArMTMwLDE0IEBAIHB1YmxpYzoKICAgICAgICAgdmlydHVhbCB+V2ViR3JhcGhpY3NT d2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJhY2tDSFJPTUlVTSgpIHsgfQogICAgIH07CiAKKyAgICBj bGFzcyBXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSB7 CisgICAgcHVibGljOgorICAgICAgICB2aXJ0dWFsIHZvaWQgb25NZW1vcnlBbGxvY2F0aW9uQ2hh bmdlZChzaXplX3QgZ3B1UmVzb3VyY2VTaXplSW5CeXRlcykgPSAwOworCisgICAgcHJvdGVjdGVk OgorICAgICAgICB2aXJ0dWFsIH5XZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2Fs bGJhY2tDSFJPTUlVTSgpIHsgfQorICAgIH07CisKICAgICAvLyBUaGlzIGRlc3RydWN0b3IgbmVl ZHMgdG8gYmUgcHVibGljIHNvIHRoYXQgdXNpbmcgY2xhc3NlcyBjYW4gZGVzdHJveSBpbnN0YW5j ZXMgaWYgaW5pdGlhbGl6YXRpb24gZmFpbHMuCiAgICAgdmlydHVhbCB+V2ViR3JhcGhpY3NDb250 ZXh0M0QoKSB7fQogCkBAIC0xNTEsNiArMTU5LDkgQEAgcHVibGljOgogICAgIC8vIEdMX0NIUk9N SVVNX3NldFZpc2liaWxpdHkgLSBDaGFuZ2VzIHRoZSB2aXNpYmlsaXR5IG9mIHRoZSBiYWNrYnVm ZmVyCiAgICAgdmlydHVhbCB2b2lkIHNldFZpc2liaWxpdHlDSFJPTUlVTShib29sIHZpc2libGUp ID0gMDsKIAorICAgIC8vIEdMX0NIUk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlciAtIHNldHMgY2Fs bGJhY2sgdG8gb2JzZXJ2ZSBjaGFuZ2VzIHRvIG1lbW9yeSBhbGxvY2F0aW9uIGxpbWl0cy4KKyAg ICB2aXJ0dWFsIHZvaWQgc2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVN KFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKiBjYWxs YmFjaykgeyB9CisKICAgICAvLyBRdWVyeSB3aGV0aGVyIGl0IGlzIGJ1aWx0IG9uIHRvcCBvZiBj b21wbGlhbnQgR0xFUzIgaW1wbGVtZW50YXRpb24uCiAgICAgdmlydHVhbCBib29sIGlzR0xFUzJD b21wbGlhbnQoKSA9IDA7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L0V4dGVuc2lvbnMzRENocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0V4 dGVuc2lvbnMzRENocm9taXVtLmNwcAppbmRleCBlY2UwNDA1YWVjNGYxMjAzOTVmZWRkMWIxYzI4 ZWIyZjQ4ODE2MGNmLi43MzM5N2JkMmIxNmE3Y2NjZmExODJiYTEyNzY4ZGEwYzdhNTg3NmRiIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9FeHRlbnNpb25zM0RDaHJvbWl1 bS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRXh0ZW5zaW9uczNEQ2hyb21p dW0uY3BwCkBAIC0xMDcsNiArMTA3LDExIEBAIHZvaWQgRXh0ZW5zaW9uczNEQ2hyb21pdW06OnNl dFZpc2liaWxpdHlDSFJPTUlVTShib29sIHZpc2liaWxpdHkpCiAgICAgbV9wcml2YXRlLT5zZXRW aXNpYmlsaXR5Q0hST01JVU0odmlzaWJpbGl0eSk7CiB9CiAKK3ZvaWQgRXh0ZW5zaW9uczNEQ2hy b21pdW06OnNldEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShQYXNz T3duUHRyPEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTT4gY2FsbGJh Y2spCit7CisgICAgbV9wcml2YXRlLT5zZXRHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxi YWNrQ0hST01JVU0oY2FsbGJhY2spOworfQorCiBQbGF0Zm9ybTNET2JqZWN0IEV4dGVuc2lvbnMz RENocm9taXVtOjpjcmVhdGVWZXJ0ZXhBcnJheU9FUygpCiB7CiAgICAgcmV0dXJuIDA7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRENocm9t aXVtLmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hy b21pdW0uY3BwCmluZGV4IGNiYmY1YzU4MWFkZmMzYmViNTkwOTYzMDJhMzBlMGExYjdlY2NhNGEu LmExZGViMjNmMmU5Y2FkYzJmOWNlZjcxZGNiZjU4ZmQxMTFkNTgwN2EgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0uY3BwCisr KyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0u Y3BwCkBAIC0xMDM1LDYgKzEwMzUsNyBAQCBHcmFwaGljc0NvbnRleHQzRDo6fkdyYXBoaWNzQ29u dGV4dDNEKCkKICAgICBtX3ByaXZhdGUtPnNldENvbnRleHRMb3N0Q2FsbGJhY2sobnVsbHB0cik7 CiAgICAgbV9wcml2YXRlLT5zZXRFcnJvck1lc3NhZ2VDYWxsYmFjayhudWxscHRyKTsKICAgICBt X3ByaXZhdGUtPnNldFN3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVNKG51bGxwdHIp OworICAgIG1fcHJpdmF0ZS0+c2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NI Uk9NSVVNKG51bGxwdHIpOwogfQogCiBQYXNzUmVmUHRyPEdyYXBoaWNzQ29udGV4dDNEPiBHcmFw aGljc0NvbnRleHQzRDo6Y3JlYXRlKEdyYXBoaWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzIGF0dHJz LCBIb3N0V2luZG93KiBob3N0V2luZG93LCBHcmFwaGljc0NvbnRleHQzRDo6UmVuZGVyU3R5bGUg cmVuZGVyU3R5bGUpCkBAIC0xMzU5LDYgKzEzNjAsMzEgQEAgdm9pZCBHcmFwaGljc0NvbnRleHQz RFByaXZhdGU6OnNldFN3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVNKFBhc3NPd25Q dHIKICAgICBtX2ltcGwtPnNldFN3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVNKG1f c3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQWRhcHRlci5nZXQoKSk7CiB9CiAKK2NsYXNzIEdy YXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIgOiBw dWJsaWMgV2ViS2l0OjpXZWJHcmFwaGljc0NvbnRleHQzRDo6V2ViR3JhcGhpY3NNZW1vcnlBbGxv Y2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0geworcHVibGljOgorICAgIEdyYXBoaWNzQ29u dGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIoUGFzc093blB0cjxF eHRlbnNpb25zM0RDaHJvbWl1bTo6R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NI Uk9NSVVNPiBjYikKKyAgICAgICAgOiBtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2so Y2IpCisgICAgeworICAgIH0KKworICAgIHZpcnR1YWwgfkdyYXBoaWNzQ29udGV4dDNETWVtb3J5 QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIoKSB7IH0KKworICAgIHZpcnR1YWwgdm9p ZCBvbk1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkKHNpemVfdCBncHVSZXNvdXJjZVNpemVJbkJ5dGVz KQorICAgIHsKKyAgICAgICAgaWYgKG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFjaykK KyAgICAgICAgICAgIG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFjay0+b25HcHVNZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZChncHVSZXNvdXJjZVNpemVJbkJ5dGVzKTsKKyAgICB9CisKK3By aXZhdGU6CisgICAgT3duUHRyPEV4dGVuc2lvbnMzRENocm9taXVtOjpHcHVNZW1vcnlBbGxvY2F0 aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0+IG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxs YmFjazsKK307CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlOjpzZXRHcHVNZW1vcnlB bGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oUGFzc093blB0cjxFeHRlbnNpb25zM0RD aHJvbWl1bTo6R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNPiBjYikK K3sKKyAgICBtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyID0gYWRvcHRQ dHIobmV3IEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0Fk YXB0ZXIoY2IpKTsKKyAgICBtX2ltcGwtPnNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJh Y2tDSFJPTUlVTShtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyLmdldCgp KTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gRU5BQkxFKFdFQkdM KQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0 M0RQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQz RFByaXZhdGUuaAppbmRleCBmMmQ0OWExMzJjNjQ1Yzg4YjBhMjc5MWFkMzEyM2Y1NjViOWIxMjk1 Li5jNmM3ZDdmMTNhYzY0MWVhMTQ3MmMxYTI2YTU0NjljOTY4ZmQxYjQ4IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRFByaXZhdGUuaAorKysg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRFByaXZhdGUuaApA QCAtNTEsNiArNTEsNyBAQCBjbGFzcyBFeHRlbnNpb25zM0RDaHJvbWl1bTsKIGNsYXNzIEdyYXBo aWNzQ29udGV4dExvc3RDYWxsYmFja0FkYXB0ZXI7CiBjbGFzcyBHcmFwaGljc0NvbnRleHQzRFN3 YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0FkYXB0ZXI7CiBjbGFzcyBHcmFwaGljc0Vycm9yTWVz c2FnZUNhbGxiYWNrQWRhcHRlcjsKK2NsYXNzIEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2Nh dGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXI7CiAKIGNsYXNzIEdyYXBoaWNzQ29udGV4dDNEUHJp dmF0ZSB7CiBwdWJsaWM6CkBAIC0yOTUsNiArMjk2LDkgQEAgcHVibGljOgogICAgIC8vIEdMX0NI Uk9NSVVNX3NldF92aXNpYmlsaXR5CiAgICAgdm9pZCBzZXRWaXNpYmlsaXR5Q0hST01JVU0oYm9v bCk7CiAKKyAgICAvLyBHTF9DSFJPTUlVTV9ncHVfbWVtb3J5X21hbmFnZXIKKyAgICB2b2lkIHNl dEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShQYXNzT3duUHRyPEV4 dGVuc2lvbnMzRENocm9taXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hS T01JVU0+KTsKKwogICAgIC8vIEdMX0NIUk9NSVVNX2ZyYW1lYnVmZmVyX211bHRpc2FtcGxlCiAg ICAgdm9pZCBibGl0RnJhbWVidWZmZXJDSFJPTUlVTShHQzNEaW50IHNyY1gwLCBHQzNEaW50IHNy Y1kwLCBHQzNEaW50IHNyY1gxLCBHQzNEaW50IHNyY1kxLCBHQzNEaW50IGRzdFgwLCBHQzNEaW50 IGRzdFkwLCBHQzNEaW50IGRzdFgxLCBHQzNEaW50IGRzdFkxLCBHQzNEYml0ZmllbGQgbWFzaywg R0MzRGVudW0gZmlsdGVyKTsKICAgICB2b2lkIHJlbmRlcmJ1ZmZlclN0b3JhZ2VNdWx0aXNhbXBs ZUNIUk9NSVVNKEdDM0RlbnVtIHRhcmdldCwgR0MzRHNpemVpIHNhbXBsZXMsIEdDM0RlbnVtIGlu dGVybmFsZm9ybWF0LCBHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBoZWlnaHQpOwpAQCAtMzI1 LDYgKzMyOSw3IEBAIHByaXZhdGU6CiAgICAgT3duUHRyPEdyYXBoaWNzQ29udGV4dExvc3RDYWxs YmFja0FkYXB0ZXI+IG1fY29udGV4dExvc3RDYWxsYmFja0FkYXB0ZXI7CiAgICAgT3duUHRyPEdy YXBoaWNzRXJyb3JNZXNzYWdlQ2FsbGJhY2tBZGFwdGVyPiBtX2Vycm9yTWVzc2FnZUNhbGxiYWNr QWRhcHRlcjsKICAgICBPd25QdHI8R3JhcGhpY3NDb250ZXh0M0RTd2FwQnVmZmVyc0NvbXBsZXRl Q2FsbGJhY2tBZGFwdGVyPiBtX3N3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0FkYXB0ZXI7Cisg ICAgT3duUHRyPEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0FkYXB0ZXI+IG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXI7CiAgICAg V2ViS2l0OjpXZWJWaWV3SW1wbCogbV93ZWJWaWV3SW1wbDsKICAgICBib29sIG1faW5pdGlhbGl6 ZWRBdmFpbGFibGVFeHRlbnNpb25zOwogICAgIEhhc2hTZXQ8U3RyaW5nPiBtX2VuYWJsZWRFeHRl bnNpb25zOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9GYWtlV2Vi R3JhcGhpY3NDb250ZXh0M0QuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvRmFrZVdl YkdyYXBoaWNzQ29udGV4dDNELmgKaW5kZXggY2YwNjUxYjc3MDMyYmQ4MGU1ODNjNjY4Mjc3NDYy ODg2MDU1ZGRiOC4uYWUyN2RhNzMwMmM3ZmM1MTk0ZjYyZGU0OWI5NTdlMjMwZGUyNzJjMyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9GYWtlV2ViR3JhcGhpY3NDb250 ZXh0M0QuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0Zha2VXZWJHcmFwaGlj c0NvbnRleHQzRC5oCkBAIC02NSw2ICs2NSw4IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9p ZCBzZXRWaXNpYmlsaXR5Q0hST01JVU0oYm9vbCB2aXNpYmxlKSB7IH0KIAorICAgIHZpcnR1YWwg dm9pZCBzZXRNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oV2ViR3JhcGhp Y3NNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0qIGNhbGxiYWNrKSB7IH0K KwogICAgIHZpcnR1YWwgV2ViU3RyaW5nIGdldFJlcXVlc3RhYmxlRXh0ZW5zaW9uc0NIUk9NSVVN KCkgeyByZXR1cm4gV2ViU3RyaW5nKCk7IH0KICAgICB2aXJ0dWFsIHZvaWQgcmVxdWVzdEV4dGVu c2lvbkNIUk9NSVVNKGNvbnN0IGNoYXIqKSB7IH0KIAo= 127601 2012-02-17 09:08:26 -0800 2012-02-17 13:41:02 -0800 Patch bug-77155-20120217120825.patch text/plain 10919 mmocny U3VidmVyc2lvbiBSZXZpc2lvbjogMTA4MDgyCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNDRkMjFmNDI2OTE3NGU2 ZDkwMWViMmM1YjFhOGZjMDg4YzU0ZjE5Zi4uMDU2YjU4OGZjNTVlYzY1YjhmMDY3NDI3MDExZGM0 OTYxZmFmZTMxMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEyLTAyLTE3ICBNaWNo YWwgTW9jbnkgIDxtbW9jbnlAZ29vZ2xlLmNvbT4KKworICAgICAgICBbY2hyb21pdW1dIEdMX0NI Uk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlciBleHRlbnNpb24KKyAgICAgICAgaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTc3MTU1CisKKyAgICAgICAgUmV2aWV3ZWQgYnkg SmFtZXMgUm9iaW5zb24uCisKKyAgICAgICAgKiBwbGF0Zm9ybS9ncmFwaGljcy9jaHJvbWl1bS9F eHRlbnNpb25zM0RDaHJvbWl1bS5oOgorICAgICAgICAoR3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKFdlYkNvcmU6OkV4dGVuc2lvbnMzRENocm9t aXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU06On5HcHVNZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAoRXh0ZW5zaW9u czNEQ2hyb21pdW0pOgorCiAyMDEyLTAyLTE3ICBGbG9yaW4gTWFsaXRhICA8Zm1hbGl0YUBnb29n bGUuY29tPgogCiAgICAgICAgIGNocm9tZS5kbGwhV2ViQ29yZTo6U1ZHVFJlZkVsZW1lbnQ6OnVw ZGF0ZVJlZmVyZW5jZWRUZXh0IFJlYWRBVkBOVUxMIChlODVjYjhlMTQwMDcxZmE3NzkwY2FkMjE1 YjAxMDlkYykKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggZDg3M2VhN2QwYjc0MDEwMGE2 NGZhYjM3ODYyMzU2ZjBhMDFlMzgwOC4uZjk0N2QyOTgzYTA5OGE3ODRmMzM3YmQ2ZDk3ZTY3ZmY2 MWNlZWVlNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysr IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMiBAQAorMjAx Mi0wMi0xNyAgTWljaGFsIE1vY255ICA8bW1vY255QGdvb2dsZS5jb20+CisKKyAgICAgICAgW2No cm9taXVtXSBHTF9DSFJPTUlVTV9ncHVfbWVtb3J5X21hbmFnZXIgZXh0ZW5zaW9uCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD03NzE1NQorCisgICAgICAg IFJldmlld2VkIGJ5IEphbWVzIFJvYmluc29uLgorCisgICAgICAgICogcHVibGljL3BsYXRmb3Jt L1dlYkdyYXBoaWNzQ29udGV4dDNELmg6CisgICAgICAgIChXZWJHcmFwaGljc01lbW9yeUFsbG9j YXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSk6CisgICAgICAgIChXZWJLaXQ6OldlYkdyYXBo aWNzQ29udGV4dDNEOjpXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tD SFJPTUlVTTo6fldlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9N SVVNKToKKyAgICAgICAgKFdlYkdyYXBoaWNzQ29udGV4dDNEKToKKyAgICAgICAgKFdlYktpdDo6 V2ViR3JhcGhpY3NDb250ZXh0M0Q6OnNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tD SFJPTUlVTSk6CisgICAgICAgICogc3JjL0V4dGVuc2lvbnMzRENocm9taXVtLmNwcDoKKyAgICAg ICAgKFdlYkNvcmU6OkV4dGVuc2lvbnMzRENocm9taXVtOjpzZXRHcHVNZW1vcnlBbGxvY2F0aW9u Q2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgICog c3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0uY3BwOgorICAgICAgICAoV2ViQ29yZTo6R3Jh cGhpY3NDb250ZXh0M0Q6On5HcmFwaGljc0NvbnRleHQzRCk6CisgICAgICAgIChHcmFwaGljc0Nv bnRleHQzRE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyKToKKyAgICAgICAg KFdlYkNvcmU6OkdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0FkYXB0ZXI6OkdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0FkYXB0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhpY3NDb250ZXh0M0RNZW1vcnlBbGxv Y2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcjo6fkdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxs b2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIpOgorICAgICAgICAoV2ViQ29yZTo6R3JhcGhp Y3NDb250ZXh0M0RNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQWRhcHRlcjo6b25NZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZCk6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKFdlYkNv cmU6OkdyYXBoaWNzQ29udGV4dDNEUHJpdmF0ZTo6c2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5n ZWRDYWxsYmFja0NIUk9NSVVNKToKKyAgICAgICAgKiBzcmMvR3JhcGhpY3NDb250ZXh0M0RQcml2 YXRlLmg6CisgICAgICAgIChXZWJDb3JlKToKKyAgICAgICAgKiB0ZXN0cy9GYWtlV2ViR3JhcGhp Y3NDb250ZXh0M0QuaDoKKyAgICAgICAgKFdlYktpdDo6RmFrZVdlYkdyYXBoaWNzQ29udGV4dDNE OjpzZXRNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0pOgorICAgICAgICAo RmFrZVdlYkdyYXBoaWNzQ29udGV4dDNEKToKKwogMjAxMi0wMi0xNyAgSWx5YSBUaWtob25vdnNr eSAgPGxvaXNsb0BjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBv dXQgcjEwODA3MS4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dyYXBoaWNz L2Nocm9taXVtL0V4dGVuc2lvbnMzRENocm9taXVtLmggYi9Tb3VyY2UvV2ViQ29yZS9wbGF0Zm9y bS9ncmFwaGljcy9jaHJvbWl1bS9FeHRlbnNpb25zM0RDaHJvbWl1bS5oCmluZGV4IGUxNjQ2MDlh ZTk0N2IxNmZlMTA2MmE0ZmRkNDk2ZDJhNmU0ZTdmYTMuLjUwOWRiMzNlODUzYTAzODFjMmVmZTVi NDc3NzM4NDAwYTEyZWNjZTUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL3BsYXRmb3JtL2dy YXBoaWNzL2Nocm9taXVtL0V4dGVuc2lvbnMzRENocm9taXVtLmgKKysrIGIvU291cmNlL1dlYkNv cmUvcGxhdGZvcm0vZ3JhcGhpY3MvY2hyb21pdW0vRXh0ZW5zaW9uczNEQ2hyb21pdW0uaApAQCAt ODcsNiArODcsMTQgQEAgcHVibGljOgogICAgIC8vIEdMX0NIUk9NSVVNX3NldF92aXNpYmlsaXR5 CiAgICAgdm9pZCBzZXRWaXNpYmlsaXR5Q0hST01JVU0oYm9vbCk7CiAKKyAgICAvLyBHTF9DSFJP TUlVTV9ncHVfbWVtb3J5X21hbmFnZXIKKyAgICBjbGFzcyBHcHVNZW1vcnlBbGxvY2F0aW9uQ2hh bmdlZENhbGxiYWNrQ0hST01JVU0geworICAgIHB1YmxpYzoKKyAgICAgICAgdmlydHVhbCB2b2lk IG9uR3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWQoc2l6ZV90IGdwdVJlc291cmNlU2l6ZUluQnl0 ZXMpID0gMDsKKyAgICAgICAgdmlydHVhbCB+R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxs YmFja0NIUk9NSVVNKCkgeyB9CisgICAgfTsKKyAgICB2b2lkIHNldEdwdU1lbW9yeUFsbG9jYXRp b25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShQYXNzT3duUHRyPEdwdU1lbW9yeUFsbG9jYXRpb25D aGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTT4pOworCiAgICAgLy8gR0xfQ0hST01JVU1fc3dhcGJ1ZmZl cnNfY29tcGxldGVfY2FsbGJhY2sKICAgICBjbGFzcyBTd2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJh Y2tDSFJPTUlVTSB7CiAgICAgcHVibGljOgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViR3JhcGhpY3NDb250ZXh0M0QuaCBiL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vcHVibGljL3BsYXRmb3JtL1dlYkdyYXBoaWNzQ29udGV4dDNELmgKaW5kZXgg NTdmOWQ3OTg1M2E2NTU0OWU0ZWEwN2NkMDkwZWFkODdhNDA2ZDE5Mi4uZjEzZjdjNDRkOWMyYjBl N2FlZTEyYjE4OTVlMTFkYzFiMmEwODkwMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJv bWl1bS9wdWJsaWMvcGxhdGZvcm0vV2ViR3JhcGhpY3NDb250ZXh0M0QuaAorKysgYi9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3B1YmxpYy9wbGF0Zm9ybS9XZWJHcmFwaGljc0NvbnRleHQzRC5oCkBA IC0xMzAsNiArMTMwLDE0IEBAIHB1YmxpYzoKICAgICAgICAgdmlydHVhbCB+V2ViR3JhcGhpY3NT d2FwQnVmZmVyc0NvbXBsZXRlQ2FsbGJhY2tDSFJPTUlVTSgpIHsgfQogICAgIH07CiAKKyAgICBj bGFzcyBXZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTSB7 CisgICAgcHVibGljOgorICAgICAgICB2aXJ0dWFsIHZvaWQgb25NZW1vcnlBbGxvY2F0aW9uQ2hh bmdlZChzaXplX3QgZ3B1UmVzb3VyY2VTaXplSW5CeXRlcykgPSAwOworCisgICAgcHJvdGVjdGVk OgorICAgICAgICB2aXJ0dWFsIH5XZWJHcmFwaGljc01lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2Fs bGJhY2tDSFJPTUlVTSgpIHsgfQorICAgIH07CisKICAgICAvLyBUaGlzIGRlc3RydWN0b3IgbmVl ZHMgdG8gYmUgcHVibGljIHNvIHRoYXQgdXNpbmcgY2xhc3NlcyBjYW4gZGVzdHJveSBpbnN0YW5j ZXMgaWYgaW5pdGlhbGl6YXRpb24gZmFpbHMuCiAgICAgdmlydHVhbCB+V2ViR3JhcGhpY3NDb250 ZXh0M0QoKSB7fQogCkBAIC0xNTEsNiArMTU5LDkgQEAgcHVibGljOgogICAgIC8vIEdMX0NIUk9N SVVNX3NldFZpc2liaWxpdHkgLSBDaGFuZ2VzIHRoZSB2aXNpYmlsaXR5IG9mIHRoZSBiYWNrYnVm ZmVyCiAgICAgdmlydHVhbCB2b2lkIHNldFZpc2liaWxpdHlDSFJPTUlVTShib29sIHZpc2libGUp ID0gMDsKIAorICAgIC8vIEdMX0NIUk9NSVVNX2dwdV9tZW1vcnlfbWFuYWdlciAtIHNldHMgY2Fs bGJhY2sgdG8gb2JzZXJ2ZSBjaGFuZ2VzIHRvIG1lbW9yeSBhbGxvY2F0aW9uIGxpbWl0cy4KKyAg ICB2aXJ0dWFsIHZvaWQgc2V0TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVN KFdlYkdyYXBoaWNzTWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNKiBjYWxs YmFjaykgeyB9CisKICAgICAvLyBRdWVyeSB3aGV0aGVyIGl0IGlzIGJ1aWx0IG9uIHRvcCBvZiBj b21wbGlhbnQgR0xFUzIgaW1wbGVtZW50YXRpb24uCiAgICAgdmlydHVhbCBib29sIGlzR0xFUzJD b21wbGlhbnQoKSA9IDA7CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L0V4dGVuc2lvbnMzRENocm9taXVtLmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0V4 dGVuc2lvbnMzRENocm9taXVtLmNwcAppbmRleCBlY2UwNDA1YWVjNGYxMjAzOTVmZWRkMWIxYzI4 ZWIyZjQ4ODE2MGNmLi43MzM5N2JkMmIxNmE3Y2NjZmExODJiYTEyNzY4ZGEwYzdhNTg3NmRiIDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9FeHRlbnNpb25zM0RDaHJvbWl1 bS5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvRXh0ZW5zaW9uczNEQ2hyb21p dW0uY3BwCkBAIC0xMDcsNiArMTA3LDExIEBAIHZvaWQgRXh0ZW5zaW9uczNEQ2hyb21pdW06OnNl dFZpc2liaWxpdHlDSFJPTUlVTShib29sIHZpc2liaWxpdHkpCiAgICAgbV9wcml2YXRlLT5zZXRW aXNpYmlsaXR5Q0hST01JVU0odmlzaWJpbGl0eSk7CiB9CiAKK3ZvaWQgRXh0ZW5zaW9uczNEQ2hy b21pdW06OnNldEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShQYXNz T3duUHRyPEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTT4gY2FsbGJh Y2spCit7CisgICAgbV9wcml2YXRlLT5zZXRHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxi YWNrQ0hST01JVU0oY2FsbGJhY2spOworfQorCiBQbGF0Zm9ybTNET2JqZWN0IEV4dGVuc2lvbnMz RENocm9taXVtOjpjcmVhdGVWZXJ0ZXhBcnJheU9FUygpCiB7CiAgICAgcmV0dXJuIDA7CmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRENocm9t aXVtLmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hy b21pdW0uY3BwCmluZGV4IGNiYmY1YzU4MWFkZmMzYmViNTkwOTYzMDJhMzBlMGExYjdlY2NhNGEu LmExZGViMjNmMmU5Y2FkYzJmOWNlZjcxZGNiZjU4ZmQxMTFkNTgwN2EgMTAwNjQ0Ci0tLSBhL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0uY3BwCisr KyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0dyYXBoaWNzQ29udGV4dDNEQ2hyb21pdW0u Y3BwCkBAIC0xMDM1LDYgKzEwMzUsNyBAQCBHcmFwaGljc0NvbnRleHQzRDo6fkdyYXBoaWNzQ29u dGV4dDNEKCkKICAgICBtX3ByaXZhdGUtPnNldENvbnRleHRMb3N0Q2FsbGJhY2sobnVsbHB0cik7 CiAgICAgbV9wcml2YXRlLT5zZXRFcnJvck1lc3NhZ2VDYWxsYmFjayhudWxscHRyKTsKICAgICBt X3ByaXZhdGUtPnNldFN3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVNKG51bGxwdHIp OworICAgIG1fcHJpdmF0ZS0+c2V0R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NI Uk9NSVVNKG51bGxwdHIpOwogfQogCiBQYXNzUmVmUHRyPEdyYXBoaWNzQ29udGV4dDNEPiBHcmFw aGljc0NvbnRleHQzRDo6Y3JlYXRlKEdyYXBoaWNzQ29udGV4dDNEOjpBdHRyaWJ1dGVzIGF0dHJz LCBIb3N0V2luZG93KiBob3N0V2luZG93LCBHcmFwaGljc0NvbnRleHQzRDo6UmVuZGVyU3R5bGUg cmVuZGVyU3R5bGUpCkBAIC0xMzU5LDYgKzEzNjAsMzEgQEAgdm9pZCBHcmFwaGljc0NvbnRleHQz RFByaXZhdGU6OnNldFN3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVNKFBhc3NPd25Q dHIKICAgICBtX2ltcGwtPnNldFN3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0NIUk9NSVVNKG1f c3dhcEJ1ZmZlcnNDb21wbGV0ZUNhbGxiYWNrQWRhcHRlci5nZXQoKSk7CiB9CiAKK2NsYXNzIEdy YXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIgOiBw dWJsaWMgV2ViS2l0OjpXZWJHcmFwaGljc0NvbnRleHQzRDo6V2ViR3JhcGhpY3NNZW1vcnlBbGxv Y2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0geworcHVibGljOgorICAgIEdyYXBoaWNzQ29u dGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIoUGFzc093blB0cjxF eHRlbnNpb25zM0RDaHJvbWl1bTo6R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NI Uk9NSVVNPiBjYikKKyAgICAgICAgOiBtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2so Y2IpCisgICAgeworICAgIH0KKworICAgIHZpcnR1YWwgfkdyYXBoaWNzQ29udGV4dDNETWVtb3J5 QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXIoKSB7IH0KKworICAgIHZpcnR1YWwgdm9p ZCBvbk1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkKHNpemVfdCBncHVSZXNvdXJjZVNpemVJbkJ5dGVz KQorICAgIHsKKyAgICAgICAgaWYgKG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFjaykK KyAgICAgICAgICAgIG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFjay0+b25HcHVNZW1v cnlBbGxvY2F0aW9uQ2hhbmdlZChncHVSZXNvdXJjZVNpemVJbkJ5dGVzKTsKKyAgICB9CisKK3By aXZhdGU6CisgICAgT3duUHRyPEV4dGVuc2lvbnMzRENocm9taXVtOjpHcHVNZW1vcnlBbGxvY2F0 aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0+IG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxs YmFjazsKK307CisKK3ZvaWQgR3JhcGhpY3NDb250ZXh0M0RQcml2YXRlOjpzZXRHcHVNZW1vcnlB bGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oUGFzc093blB0cjxFeHRlbnNpb25zM0RD aHJvbWl1bTo6R3B1TWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0NIUk9NSVVNPiBjYikK K3sKKyAgICBtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyID0gYWRvcHRQ dHIobmV3IEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0Fk YXB0ZXIoY2IpKTsKKyAgICBtX2ltcGwtPnNldE1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJh Y2tDSFJPTUlVTShtX21lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tBZGFwdGVyLmdldCgp KTsKK30KKwogfSAvLyBuYW1lc3BhY2UgV2ViQ29yZQogCiAjZW5kaWYgLy8gRU5BQkxFKFdFQkdM KQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvR3JhcGhpY3NDb250ZXh0 M0RQcml2YXRlLmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQz RFByaXZhdGUuaAppbmRleCBmMmQ0OWExMzJjNjQ1Yzg4YjBhMjc5MWFkMzEyM2Y1NjViOWIxMjk1 Li5jNmM3ZDdmMTNhYzY0MWVhMTQ3MmMxYTI2YTU0NjljOTY4ZmQxYjQ4IDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRFByaXZhdGUuaAorKysg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9HcmFwaGljc0NvbnRleHQzRFByaXZhdGUuaApA QCAtNTEsNiArNTEsNyBAQCBjbGFzcyBFeHRlbnNpb25zM0RDaHJvbWl1bTsKIGNsYXNzIEdyYXBo aWNzQ29udGV4dExvc3RDYWxsYmFja0FkYXB0ZXI7CiBjbGFzcyBHcmFwaGljc0NvbnRleHQzRFN3 YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0FkYXB0ZXI7CiBjbGFzcyBHcmFwaGljc0Vycm9yTWVz c2FnZUNhbGxiYWNrQWRhcHRlcjsKK2NsYXNzIEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2Nh dGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXI7CiAKIGNsYXNzIEdyYXBoaWNzQ29udGV4dDNEUHJp dmF0ZSB7CiBwdWJsaWM6CkBAIC0yOTUsNiArMjk2LDkgQEAgcHVibGljOgogICAgIC8vIEdMX0NI Uk9NSVVNX3NldF92aXNpYmlsaXR5CiAgICAgdm9pZCBzZXRWaXNpYmlsaXR5Q0hST01JVU0oYm9v bCk7CiAKKyAgICAvLyBHTF9DSFJPTUlVTV9ncHVfbWVtb3J5X21hbmFnZXIKKyAgICB2b2lkIHNl dEdwdU1lbW9yeUFsbG9jYXRpb25DaGFuZ2VkQ2FsbGJhY2tDSFJPTUlVTShQYXNzT3duUHRyPEV4 dGVuc2lvbnMzRENocm9taXVtOjpHcHVNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hS T01JVU0+KTsKKwogICAgIC8vIEdMX0NIUk9NSVVNX2ZyYW1lYnVmZmVyX211bHRpc2FtcGxlCiAg ICAgdm9pZCBibGl0RnJhbWVidWZmZXJDSFJPTUlVTShHQzNEaW50IHNyY1gwLCBHQzNEaW50IHNy Y1kwLCBHQzNEaW50IHNyY1gxLCBHQzNEaW50IHNyY1kxLCBHQzNEaW50IGRzdFgwLCBHQzNEaW50 IGRzdFkwLCBHQzNEaW50IGRzdFgxLCBHQzNEaW50IGRzdFkxLCBHQzNEYml0ZmllbGQgbWFzaywg R0MzRGVudW0gZmlsdGVyKTsKICAgICB2b2lkIHJlbmRlcmJ1ZmZlclN0b3JhZ2VNdWx0aXNhbXBs ZUNIUk9NSVVNKEdDM0RlbnVtIHRhcmdldCwgR0MzRHNpemVpIHNhbXBsZXMsIEdDM0RlbnVtIGlu dGVybmFsZm9ybWF0LCBHQzNEc2l6ZWkgd2lkdGgsIEdDM0RzaXplaSBoZWlnaHQpOwpAQCAtMzI1 LDYgKzMyOSw3IEBAIHByaXZhdGU6CiAgICAgT3duUHRyPEdyYXBoaWNzQ29udGV4dExvc3RDYWxs YmFja0FkYXB0ZXI+IG1fY29udGV4dExvc3RDYWxsYmFja0FkYXB0ZXI7CiAgICAgT3duUHRyPEdy YXBoaWNzRXJyb3JNZXNzYWdlQ2FsbGJhY2tBZGFwdGVyPiBtX2Vycm9yTWVzc2FnZUNhbGxiYWNr QWRhcHRlcjsKICAgICBPd25QdHI8R3JhcGhpY3NDb250ZXh0M0RTd2FwQnVmZmVyc0NvbXBsZXRl Q2FsbGJhY2tBZGFwdGVyPiBtX3N3YXBCdWZmZXJzQ29tcGxldGVDYWxsYmFja0FkYXB0ZXI7Cisg ICAgT3duUHRyPEdyYXBoaWNzQ29udGV4dDNETWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFj a0FkYXB0ZXI+IG1fbWVtb3J5QWxsb2NhdGlvbkNoYW5nZWRDYWxsYmFja0FkYXB0ZXI7CiAgICAg V2ViS2l0OjpXZWJWaWV3SW1wbCogbV93ZWJWaWV3SW1wbDsKICAgICBib29sIG1faW5pdGlhbGl6 ZWRBdmFpbGFibGVFeHRlbnNpb25zOwogICAgIEhhc2hTZXQ8U3RyaW5nPiBtX2VuYWJsZWRFeHRl bnNpb25zOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9GYWtlV2Vi R3JhcGhpY3NDb250ZXh0M0QuaCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vdGVzdHMvRmFrZVdl YkdyYXBoaWNzQ29udGV4dDNELmgKaW5kZXggY2YwNjUxYjc3MDMyYmQ4MGU1ODNjNjY4Mjc3NDYy ODg2MDU1ZGRiOC4uYWUyN2RhNzMwMmM3ZmM1MTk0ZjYyZGU0OWI5NTdlMjMwZGUyNzJjMyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS90ZXN0cy9GYWtlV2ViR3JhcGhpY3NDb250 ZXh0M0QuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Rlc3RzL0Zha2VXZWJHcmFwaGlj c0NvbnRleHQzRC5oCkBAIC02NSw2ICs2NSw4IEBAIHB1YmxpYzoKIAogICAgIHZpcnR1YWwgdm9p ZCBzZXRWaXNpYmlsaXR5Q0hST01JVU0oYm9vbCB2aXNpYmxlKSB7IH0KIAorICAgIHZpcnR1YWwg dm9pZCBzZXRNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0oV2ViR3JhcGhp Y3NNZW1vcnlBbGxvY2F0aW9uQ2hhbmdlZENhbGxiYWNrQ0hST01JVU0qIGNhbGxiYWNrKSB7IH0K KwogICAgIHZpcnR1YWwgV2ViU3RyaW5nIGdldFJlcXVlc3RhYmxlRXh0ZW5zaW9uc0NIUk9NSVVN KCkgeyByZXR1cm4gV2ViU3RyaW5nKCk7IH0KICAgICB2aXJ0dWFsIHZvaWQgcmVxdWVzdEV4dGVu c2lvbkNIUk9NSVVNKGNvbnN0IGNoYXIqKSB7IH0KIAo=