86557 2012-05-15 19:06:29 -0700 Allow WebTextFieldDecoratorClient to see applied decorations. 2012-05-25 19:21:03 -0700 1 1 1 Unclassified WebKit New Bugs 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 0 gcasto webkit-unassigned abarth dglazkov fishd jamesr tkent tkent+wkapi webkit.review.bot oldest_to_newest 624857 0 gcasto 2012-05-15 19:06:29 -0700 Allow WebTextFieldDecoratorClient to see applied decorations. 624863 1 142128 gcasto 2012-05-15 19:15:05 -0700 Created attachment 142128 Patch 624865 2 webkit.review.bot 2012-05-15 19:17:42 -0700 Please wait for approval from abarth@webkit.org, dglazkov@chromium.org, fishd@chromium.org, jamesr@chromium.org or tkent@chromium.org before submitting, as this patch contains changes to the Chromium public API. See also https://trac.webkit.org/wiki/ChromiumWebKitAPI. 624866 3 webkit.review.bot 2012-05-15 19:18:03 -0700 Attachment 142128 did not pass style-queue: Failed to run "['Tools/Scripts/check-webkit-style', '--diff-files', u'Source/WebCore/ChangeLog', u'Source/WebCor..." exit_code: 1 Source/WebKit/chromium/public/WebStyledElement.h:42: Code inside a namespace should not be indented. [whitespace/indent] [4] Total errors found: 1 in 11 files If any of these errors are false positives, please file a bug against check-webkit-style. 625616 4 142294 gcasto 2012-05-16 10:37:02 -0700 Created attachment 142294 Patch 625648 5 gcasto 2012-05-16 11:08:34 -0700 Fixed the style issue. 625657 6 142294 dglazkov 2012-05-16 11:16:33 -0700 Comment on attachment 142294 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=142294&action=review > Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:143 > + if (inlineStyle()->getPropertyValue(CSSPropertyVisibility) == "hidden" > + || inputStyle->visibility() == HIDDEN) > + style->setVisibility(HIDDEN); If you need this code, something has gone horribly wrong. > Source/WebKit/chromium/public/WebStyledElement.h:32 > +#define WebStyledElement_h As I mentioned before, it's not the right approach. Exposing StyledElement in WebKit API is an overkill for this solution. Perhaps instead we could morph the API to be a list of decorators in a document? Then, we can listen to normal document events and react to them by iterating through the decorators and operating on them. In other words, instead of exposing WebStyledElement, expose the WebTextFieldDecorator? WDYT? 625689 7 gcasto 2012-05-16 11:37:12 -0700 (In reply to comment #6) > (From update of attachment 142294 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=142294&action=review > > > Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:143 > > + if (inlineStyle()->getPropertyValue(CSSPropertyVisibility) == "hidden" > > + || inputStyle->visibility() == HIDDEN) > > + style->setVisibility(HIDDEN); > > If you need this code, something has gone horribly wrong. > So I don't understand the distinction between styles set by SetInlineStyleProperty and those set via RenderStyle, but just setting the inline style (either visibility:hidden or display:none) will not cause the element to disappear. As far as I can tell it has to be set here, and propagating from the inline style just seemed like the easiest way to accomplish this. Like I said, I don't understand why because I don't understand the distinction between them, but it's how it works at the moment. The second line is because currently if the HTMLInputElement is hidden, the decorator still shows up. This doesn't seem like it should happen either. > > Source/WebKit/chromium/public/WebStyledElement.h:32 > > +#define WebStyledElement_h > > As I mentioned before, it's not the right approach. Exposing StyledElement in WebKit API is an overkill for this solution. > > Perhaps instead we could morph the API to be a list of decorators in a document? > > Then, we can listen to normal document events and react to them by iterating through the decorators and operating on them. In other words, instead of exposing WebStyledElement, expose the WebTextFieldDecorator? WDYT? I'm not sure I understand what you are suggesting. Exposing WebTextFieldDecorator instead of WebStyledElement seems fine to me, though we can do that by just changing the function definition of decorationAdded(). It seems like you are suggesting something larger. How exactly are you proposing to change WebTextFieldDecoratorClient? 625774 8 142294 dglazkov 2012-05-16 13:06:53 -0700 Comment on attachment 142294 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=142294&action=review >>> Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:143 >>> + style->setVisibility(HIDDEN); >> >> If you need this code, something has gone horribly wrong. > > So I don't understand the distinction between styles set by SetInlineStyleProperty and those set via RenderStyle, but just setting the inline style (either visibility:hidden or display:none) will not cause the element to disappear. As far as I can tell it has to be set here, and propagating from the inline style just seemed like the easiest way to accomplish this. Like I said, I don't understand why because I don't understand the distinction between them, but it's how it works at the moment. > > The second line is because currently if the HTMLInputElement is hidden, the decorator still shows up. This doesn't seem like it should happen either. When you set inline style on an element, the style recalculation will be triggered and the correct style should be created for TextFieldDecorationElement. Unfortunately, the customStyleForRenderer method short-circuits this process and forces you to do gnarly hacks like this. The problem with not fixing this is that _every_ time you need to modify a style on the TextFieldDecorationElement, you will have to add a little condition just like this to customStyleForRenderer. That's just bad design. Not your design, but still unacceptable. Kent-san, can we please change this to something that is not so rigid? >>> Source/WebKit/chromium/public/WebStyledElement.h:32 >>> +#define WebStyledElement_h >> >> As I mentioned before, it's not the right approach. Exposing StyledElement in WebKit API is an overkill for this solution. >> >> Perhaps instead we could morph the API to be a list of decorators in a document? >> >> Then, we can listen to normal document events and react to them by iterating through the decorators and operating on them. In other words, instead of exposing WebStyledElement, expose the WebTextFieldDecorator? WDYT? > > I'm not sure I understand what you are suggesting. Exposing WebTextFieldDecorator instead of WebStyledElement seems fine to me, though we can do that by just changing the function definition of decorationAdded(). It seems like you are suggesting something larger. How exactly are you proposing to change WebTextFieldDecoratorClient? The design that I am proposing is: * Adding textfield decorators should be limited to simply initializing the shadow DOM subtrees with hidden elements. There are no decisions made about visibility during this, since it's too early to know the context (for your particular case). * We register a "load" or "DOMContentLoad" event listener * When the event fires, we iterate over all decorators and then make our decisions on whether the decorator should be visibile * WebTextFieldDecorator has a setVisible(bool) method, which we set when we make our decision If we need to do something more complex, like reacting when an input element is added or removed from the document tree, you need an accurate signal of when that happens. You can't rely on Chrome::addTextFieldDecorationsTo, since this will be called way too many times (and for most of them, not when you need it). Perhaps a MutationObserver would be useful here. 625917 9 gcasto 2012-05-16 15:17:58 -0700 (In reply to comment #8) > (From update of attachment 142294 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=142294&action=review > > >>> Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:143 > >>> + style->setVisibility(HIDDEN); > >> > >> If you need this code, something has gone horribly wrong. > > > > So I don't understand the distinction between styles set by SetInlineStyleProperty and those set via RenderStyle, but just setting the inline style (either visibility:hidden or display:none) will not cause the element to disappear. As far as I can tell it has to be set here, and propagating from the inline style just seemed like the easiest way to accomplish this. Like I said, I don't understand why because I don't understand the distinction between them, but it's how it works at the moment. > > > > The second line is because currently if the HTMLInputElement is hidden, the decorator still shows up. This doesn't seem like it should happen either. > > When you set inline style on an element, the style recalculation will be triggered and the correct style should be created for TextFieldDecorationElement. Unfortunately, the customStyleForRenderer method short-circuits this process and forces you to do gnarly hacks like this. The problem with not fixing this is that _every_ time you need to modify a style on the TextFieldDecorationElement, you will have to add a little condition just like this to customStyleForRenderer. That's just bad design. Not your design, but still unacceptable. Kent-san, can we please change this to something that is not so rigid? > > >>> Source/WebKit/chromium/public/WebStyledElement.h:32 > >>> +#define WebStyledElement_h > >> > >> As I mentioned before, it's not the right approach. Exposing StyledElement in WebKit API is an overkill for this solution. > >> > >> Perhaps instead we could morph the API to be a list of decorators in a document? > >> > >> Then, we can listen to normal document events and react to them by iterating through the decorators and operating on them. In other words, instead of exposing WebStyledElement, expose the WebTextFieldDecorator? WDYT? > > > > I'm not sure I understand what you are suggesting. Exposing WebTextFieldDecorator instead of WebStyledElement seems fine to me, though we can do that by just changing the function definition of decorationAdded(). It seems like you are suggesting something larger. How exactly are you proposing to change WebTextFieldDecoratorClient? > > The design that I am proposing is: > > * Adding textfield decorators should be limited to simply initializing the shadow DOM subtrees with hidden elements. There are no decisions made about visibility during this, since it's too early to know the context (for your particular case). > * We register a "load" or "DOMContentLoad" event listener > * When the event fires, we iterate over all decorators and then make our decisions on whether the decorator should be visibile > * WebTextFieldDecorator has a setVisible(bool) method, which we set when we make our decision > So the second and third point here suggest to me something where ChromeClientImpl asks Chromium if a particular element should be made visible (when the event handler fires). The last point implies that Chromium can change the visibility of the decorator whenever. I'm not sure what I'm missing, but I do think that the Chromium code needs to be able to change the visibility of a decorator at arbitrary times, since in my case the client is not going to know if a decorator should be visible until it gets some information back from the browser process. Assuming we change WebStyledElement -> WebTextFieldDecorator and fix the style propagation issue, the current WebTextFieldDecoratorClient works fine for me. Do you not approve of the interface change to WebTextFieldDecoratorClient, or was there something else you were hoping to get out of this new design? > If we need to do something more complex, like reacting when an input element is added or removed from the document tree, you need an accurate signal of when that happens. You can't rely on Chrome::addTextFieldDecorationsTo, since this will be called way too many times (and for most of them, not when you need it). Perhaps a MutationObserver would be useful here. I do not think that I need anything more complex. It's possible that eventually I would want this to be able to deal with dynamically generated forms, but first the password manager will need to deal with them. 625967 10 dglazkov 2012-05-16 16:04:15 -0700 (In reply to comment #9) > > So the second and third point here suggest to me something where ChromeClientImpl asks Chromium if a particular element should be made visible (when the event handler fires). The last point implies that Chromium can change the visibility of the decorator whenever. I'm not sure what I'm missing, but I do think that the Chromium code needs to be able to change the visibility of a decorator at arbitrary times, since in my case the client is not going to know if a decorator should be visible until it gets some information back from the browser process. Assuming we change WebStyledElement -> WebTextFieldDecorator and fix the style propagation issue, the current WebTextFieldDecoratorClient works fine for me. Do you not approve of the interface change to WebTextFieldDecoratorClient, or was there something else you were hoping to get out of this new design? > Ah, I see. I've forgotten about the IPC thing. So you need to hold on to WebTextFieldDecorator until you get the data back from the browser process? When would you request this data? addTextFieldDecorationsTo is too early, right? > > If we need to do something more complex, like reacting when an input element is added or removed from the document tree, you need an accurate signal of when that happens. You can't rely on Chrome::addTextFieldDecorationsTo, since this will be called way too many times (and for most of them, not when you need it). Perhaps a MutationObserver would be useful here. > > I do not think that I need anything more complex. It's possible that eventually I would want this to be able to deal with dynamically generated forms, but first the password manager will need to deal with them. Great! :) 626424 11 142294 tkent 2012-05-17 03:48:06 -0700 Comment on attachment 142294 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=142294&action=review >>>>> Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:143 >>>>> + style->setVisibility(HIDDEN); I don't remember why I used customStyleForRenderer() exactly. Probably we needed to call updateImage() when <input>'s disabled/readonly state is changed. If we moved updateImage() to another place, we would be able to use normal style resolution. - The width and height should work by specifying "width:1em; height:1em;" in UA stylesheet. - HTMLElement::hidden should work well if we use normal style resolution. 626726 12 gcasto 2012-05-17 11:06:59 -0700 (In reply to comment #10) > (In reply to comment #9) > > > > So the second and third point here suggest to me something where ChromeClientImpl asks Chromium if a particular element should be made visible (when the event handler fires). The last point implies that Chromium can change the visibility of the decorator whenever. I'm not sure what I'm missing, but I do think that the Chromium code needs to be able to change the visibility of a decorator at arbitrary times, since in my case the client is not going to know if a decorator should be visible until it gets some information back from the browser process. Assuming we change WebStyledElement -> WebTextFieldDecorator and fix the style propagation issue, the current WebTextFieldDecoratorClient works fine for me. Do you not approve of the interface change to WebTextFieldDecoratorClient, or was there something else you were hoping to get out of this new design? > > > > Ah, I see. I've forgotten about the IPC thing. So you need to hold on to WebTextFieldDecorator until you get the data back from the browser process? When would you request this data? addTextFieldDecorationsTo is too early, right? > The request is actually already being made for autofill purposes. It happens in didFinishDocumentLoad, and I don't think that this would need to move. As you mentioned, addTextFieldDecorationsTo is too early for this as we don't have the complete form data. > > > If we need to do something more complex, like reacting when an input element is added or removed from the document tree, you need an accurate signal of when that happens. You can't rely on Chrome::addTextFieldDecorationsTo, since this will be called way too many times (and for most of them, not when you need it). Perhaps a MutationObserver would be useful here. > > > > I do not think that I need anything more complex. It's possible that eventually I would want this to be able to deal with dynamically generated forms, but first the password manager will need to deal with them. > > Great! :) 626834 13 dglazkov 2012-05-17 12:16:42 -0700 (In reply to comment #12) > (In reply to comment #10) > > (In reply to comment #9) > > > > > > So the second and third point here suggest to me something where ChromeClientImpl asks Chromium if a particular element should be made visible (when the event handler fires). The last point implies that Chromium can change the visibility of the decorator whenever. I'm not sure what I'm missing, but I do think that the Chromium code needs to be able to change the visibility of a decorator at arbitrary times, since in my case the client is not going to know if a decorator should be visible until it gets some information back from the browser process. Assuming we change WebStyledElement -> WebTextFieldDecorator and fix the style propagation issue, the current WebTextFieldDecoratorClient works fine for me. Do you not approve of the interface change to WebTextFieldDecoratorClient, or was there something else you were hoping to get out of this new design? > > > > > > > Ah, I see. I've forgotten about the IPC thing. So you need to hold on to WebTextFieldDecorator until you get the data back from the browser process? When would you request this data? addTextFieldDecorationsTo is too early, right? > > > > The request is actually already being made for autofill purposes. It happens in didFinishDocumentLoad, and I don't think that this would need to move. As you mentioned, addTextFieldDecorationsTo is too early for this as we don't have the complete form data. Great, so this makes the API we need fairly simple: 1) a way to iterate through all elements per decorator in a document and; 2) a way to make some of them visible. > > > > > If we need to do something more complex, like reacting when an input element is added or removed from the document tree, you need an accurate signal of when that happens. You can't rely on Chrome::addTextFieldDecorationsTo, since this will be called way too many times (and for most of them, not when you need it). Perhaps a MutationObserver would be useful here. > > > > > > I do not think that I need anything more complex. It's possible that eventually I would want this to be able to deal with dynamically generated forms, but first the password manager will need to deal with them. > > > > Great! :) 626949 14 gcasto 2012-05-17 14:05:22 -0700 (In reply to comment #13) > (In reply to comment #12) > > (In reply to comment #10) > > > (In reply to comment #9) > > > > > > > > So the second and third point here suggest to me something where ChromeClientImpl asks Chromium if a particular element should be made visible (when the event handler fires). The last point implies that Chromium can change the visibility of the decorator whenever. I'm not sure what I'm missing, but I do think that the Chromium code needs to be able to change the visibility of a decorator at arbitrary times, since in my case the client is not going to know if a decorator should be visible until it gets some information back from the browser process. Assuming we change WebStyledElement -> WebTextFieldDecorator and fix the style propagation issue, the current WebTextFieldDecoratorClient works fine for me. Do you not approve of the interface change to WebTextFieldDecoratorClient, or was there something else you were hoping to get out of this new design? > > > > > > > > > > Ah, I see. I've forgotten about the IPC thing. So you need to hold on to WebTextFieldDecorator until you get the data back from the browser process? When would you request this data? addTextFieldDecorationsTo is too early, right? > > > > > > > The request is actually already being made for autofill purposes. It happens in didFinishDocumentLoad, and I don't think that this would need to move. As you mentioned, addTextFieldDecorationsTo is too early for this as we don't have the complete form data. > > Great, so this makes the API we need fairly simple: > 1) a way to iterate through all elements per decorator in a document and; > 2) a way to make some of them visible. > I mentioned this before, but I think that the API that I've currently proposed (modulo WebStyledElement -> WebTextFieldDecorator and the style propagation problems) allows this, though the user does have to worry about the lifetimes of the Elements. Is the lifetime issue what you are worried about, or just general cleanliness of the API, or what? Are you proposing adding function to WebView to iterate through these elements? Assuming that you don't want the client to worry about lifetimes, there are two other issues. The first is that having a way to do lookups as well as iteration through these elements would be useful. I'm thinking in particular of when we get the IPC from the browser iterating through all of the decorated elements looking for the one that we want to show seems slightly silly. Relatedly, I'm actually not sure if we need iteration, as I currently accomplish this by just iterating through all the forms on a page and I'm not sure how much faster just iterating through all the decorated elements would be. Secondly, we would need to change handleClick() to include a WebTextFieldDecorator, since I need that to determine how to center the popup. Not a big change though. I would also like to say that I would prefer that we get _something_ checked in reasonably soon that works. I'm willing to cleanup the API, I would just like to be able to have a testable UI in Chromium sooner rather than later. > > > > > > > If we need to do something more complex, like reacting when an input element is added or removed from the document tree, you need an accurate signal of when that happens. You can't rely on Chrome::addTextFieldDecorationsTo, since this will be called way too many times (and for most of them, not when you need it). Perhaps a MutationObserver would be useful here. > > > > > > > > I do not think that I need anything more complex. It's possible that eventually I would want this to be able to deal with dynamically generated forms, but first the password manager will need to deal with them. > > > > > > Great! :) 627303 15 dglazkov 2012-05-17 21:11:55 -0700 (In reply to comment #14) > (In reply to comment #13) > > (In reply to comment #12) > > > (In reply to comment #10) > > > > (In reply to comment #9) > > > > > > > > > > So the second and third point here suggest to me something where ChromeClientImpl asks Chromium if a particular element should be made visible (when the event handler fires). The last point implies that Chromium can change the visibility of the decorator whenever. I'm not sure what I'm missing, but I do think that the Chromium code needs to be able to change the visibility of a decorator at arbitrary times, since in my case the client is not going to know if a decorator should be visible until it gets some information back from the browser process. Assuming we change WebStyledElement -> WebTextFieldDecorator and fix the style propagation issue, the current WebTextFieldDecoratorClient works fine for me. Do you not approve of the interface change to WebTextFieldDecoratorClient, or was there something else you were hoping to get out of this new design? > > > > > > > > > > > > > Ah, I see. I've forgotten about the IPC thing. So you need to hold on to WebTextFieldDecorator until you get the data back from the browser process? When would you request this data? addTextFieldDecorationsTo is too early, right? > > > > > > > > > > The request is actually already being made for autofill purposes. It happens in didFinishDocumentLoad, and I don't think that this would need to move. As you mentioned, addTextFieldDecorationsTo is too early for this as we don't have the complete form data. > > > > Great, so this makes the API we need fairly simple: > > 1) a way to iterate through all elements per decorator in a document and; > > 2) a way to make some of them visible. > > > > I mentioned this before, but I think that the API that I've currently proposed (modulo WebStyledElement -> WebTextFieldDecorator and the style propagation problems) allows this, though the user does have to worry about the lifetimes of the Elements. Is the lifetime issue what you are worried about, or just general cleanliness of the API, or what? Are you proposing adding function to WebView to iterate through these elements? Yes. Holding on to references like this is madness. Consider this: at any point, a script on the page could change a text field into a checkbox (or any other element), and then you're stuck holding something you don't really want. > > Assuming that you don't want the client to worry about lifetimes, there are two other issues. The first is that having a way to do lookups as well as iteration through these elements would be useful. I'm thinking in particular of when we get the IPC from the browser iterating through all of the decorated elements looking for the one that we want to show seems slightly silly. Relatedly, I'm actually not sure if we need iteration, as I currently accomplish this by just iterating through all the forms on a page and I'm not sure how much faster just iterating through all the decorated elements would be. Secondly, we would need to change handleClick() to include a WebTextFieldDecorator, since I need that to determine how to center the popup. Not a big change though. > > I would also like to say that I would prefer that we get _something_ checked in reasonably soon that works. I'm willing to cleanup the API, I would just like to be able to have a testable UI in Chromium sooner rather than later. I understand. How about this -- when you look at any WebInputElement, you can ask for its decorator. This should allow you twiddle the visibility bits when iterating through forms? 628017 16 gcasto 2012-05-18 13:40:46 -0700 (In reply to comment #15) > (In reply to comment #14) > > (In reply to comment #13) > > > (In reply to comment #12) > > > > (In reply to comment #10) > > > > > (In reply to comment #9) > > > > > > > > > > > > So the second and third point here suggest to me something where ChromeClientImpl asks Chromium if a particular element should be made visible (when the event handler fires). The last point implies that Chromium can change the visibility of the decorator whenever. I'm not sure what I'm missing, but I do think that the Chromium code needs to be able to change the visibility of a decorator at arbitrary times, since in my case the client is not going to know if a decorator should be visible until it gets some information back from the browser process. Assuming we change WebStyledElement -> WebTextFieldDecorator and fix the style propagation issue, the current WebTextFieldDecoratorClient works fine for me. Do you not approve of the interface change to WebTextFieldDecoratorClient, or was there something else you were hoping to get out of this new design? > > > > > > > > > > > > > > > > Ah, I see. I've forgotten about the IPC thing. So you need to hold on to WebTextFieldDecorator until you get the data back from the browser process? When would you request this data? addTextFieldDecorationsTo is too early, right? > > > > > > > > > > > > > The request is actually already being made for autofill purposes. It happens in didFinishDocumentLoad, and I don't think that this would need to move. As you mentioned, addTextFieldDecorationsTo is too early for this as we don't have the complete form data. > > > > > > Great, so this makes the API we need fairly simple: > > > 1) a way to iterate through all elements per decorator in a document and; > > > 2) a way to make some of them visible. > > > > > > > I mentioned this before, but I think that the API that I've currently proposed (modulo WebStyledElement -> WebTextFieldDecorator and the style propagation problems) allows this, though the user does have to worry about the lifetimes of the Elements. Is the lifetime issue what you are worried about, or just general cleanliness of the API, or what? Are you proposing adding function to WebView to iterate through these elements? > > Yes. Holding on to references like this is madness. Consider this: at any point, a script on the page could change a text field into a checkbox (or any other element), and then you're stuck holding something you don't really want. > Just to be sure, are you worried about holding a reference to a WebInputElement or to a WebTextFieldDecorator? I'm wondering because I think that you need to hold onto a WebInputElement between the time we determine that we want to show the decorator and the time that we get the IPC from the browser saying that we can show it (assuming that we can get the WebTextFieldDecorator from the WebInputElement) > > > > Assuming that you don't want the client to worry about lifetimes, there are two other issues. The first is that having a way to do lookups as well as iteration through these elements would be useful. I'm thinking in particular of when we get the IPC from the browser iterating through all of the decorated elements looking for the one that we want to show seems slightly silly. Relatedly, I'm actually not sure if we need iteration, as I currently accomplish this by just iterating through all the forms on a page and I'm not sure how much faster just iterating through all the decorated elements would be. Secondly, we would need to change handleClick() to include a WebTextFieldDecorator, since I need that to determine how to center the popup. Not a big change though. > > > > I would also like to say that I would prefer that we get _something_ checked in reasonably soon that works. I'm willing to cleanup the API, I would just like to be able to have a testable UI in Chromium sooner rather than later. > > I understand. How about this -- when you look at any WebInputElement, you can ask for its decorator. This should allow you twiddle the visibility bits when iterating through forms? Seems reasonable to me. 628027 17 dglazkov 2012-05-18 13:50:57 -0700 (In reply to comment #16) > > Just to be sure, are you worried about holding a reference to a WebInputElement or to a WebTextFieldDecorator? I'm wondering because I think that you need to hold onto a WebInputElement between the time we determine that we want to show the decorator and the time that we get the IPC from the browser saying that we can show it (assuming that we can get the WebTextFieldDecorator from the WebInputElement) Yes, it's still not optimal, but I think we've done our best here. I believe there's code in AutoFill that deals with these types of problems. The engineers who wrote this spent a looooong time sifting through odd crashes around that. You don't want to be stuck in the same long tail :) > Seems reasonable to me. Yay! Progress. 629749 18 143145 gcasto 2012-05-21 17:21:13 -0700 Created attachment 143145 Patch 629752 19 gcasto 2012-05-21 17:26:06 -0700 This change reworks the API as we discussed, but doesn't solve the styling issue (so changing the visibility of a WebTextFieldDecorationElement currently doesn't do anything useful). I did change it so that the DIV element is always hidden, since it didn't seem to hurt and it prevents a problem where the decorator is hidden, but mousing over the element will give you a pointer instead of a text bar. However, I'm not sure why the DIV is there in the first place so I'm not entirely sure what the side effects of this are going to be. 629782 20 gcasto 2012-05-21 17:49:12 -0700 One other thing that I just thought about. For my use case, I would prefer that the decoration defaulted to hidden, but I'm not if other users of this API would agree. Given the current setup it seems difficult to override the default for every element. The best thing that I can come up with is to iterate over the entire document once it's finished loading and set everything to invisible that I don't want to be shown. So, do we think that the API should allow for some easier way to specify the default styling of the decorator? 630461 21 143145 dglazkov 2012-05-22 09:48:26 -0700 Comment on attachment 143145 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=143145&action=review I think this is good. I would really like for Kent-san to look over the next iteration of the patch, since you and I came up with this idea together. Another pair of eyes wouldn't hurt :) > Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:69 > +TextFieldDecorationElement* TextFieldDecorationElement::fromShadowRoot(ShadowRoot* shadowRoot) Can you file a bug about making TextFieldDecorationElement _the_ ShadowRoot and add a FIXME comment referencing it? // FIXME: After fixing http://bugs.webkit.org/...., this should be a simple cast. > Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:108 > + box->setInlineStyleProperty(CSSPropertyVisibility, CSSValueHidden); I don't mind if you expose a flag in TextFieldDecorator that allows controlling whether the element is hidden or visible by default. > Source/WebKit/chromium/public/WebTextFieldDecorationElement.h:54 > + // Make visible iff true. Don't need this comment here. > Source/WebKit/chromium/src/TextFieldDecoratorImpl.h:46 > + WebTextFieldDecoratorClient* decoratorClient(); Instead of exposing a client here, can we instead let it do the comparison inside: WebTextfieldDecoratorClient::isClientFor(WebCore::TextFieldDecorator*); This way, the casting to TextFieldDecoratorImpl becomes an implementation detail, not an assumption in WebInputElement. > Source/WebKit/chromium/src/WebInputElement.cpp:221 > + ShadowRoot* shadowRoot = unwrap<HTMLInputElement>()->shadow()->youngestShadowRoot(); I think the code just landed that lets you use Node::youngestShadowRoot() > Source/WebKit/chromium/src/WebInputElement.cpp:228 > + shadowRoot->olderShadowRoot(); shadowRoot = shadowRoot->olderShadowRoot(); !!! > Source/WebKit/chromium/src/WebTextFieldDecorationElement.cpp:50 > + if (visible) > + unwrap<TextFieldDecorationElement>()->setInlineStyleProperty(CSSPropertyVisibility, > + CSSValueVisible); > + else > + unwrap<TextFieldDecorationElement>()->setInlineStyleProperty(CSSPropertyVisibility, > + CSSValueHidden); I think we can just use WebElement::setAttribute("style", "display:none|block") instead. This way, the patch will be smaller and we're not exposing any new WebCore functionality. WDYT? 630645 22 gcasto 2012-05-22 12:11:58 -0700 (In reply to comment #21) > (From update of attachment 143145 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=143145&action=review > > I think this is good. I would really like for Kent-san to look over the next iteration of the patch, since you and I came up with this idea together. Another pair of eyes wouldn't hurt :) > > > Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:69 > > +TextFieldDecorationElement* TextFieldDecorationElement::fromShadowRoot(ShadowRoot* shadowRoot) > > Can you file a bug about making TextFieldDecorationElement _the_ ShadowRoot and add a FIXME comment referencing it? > > // FIXME: After fixing http://bugs.webkit.org/...., this should be a simple cast. > > > Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:108 > > + box->setInlineStyleProperty(CSSPropertyVisibility, CSSValueHidden); > > I don't mind if you expose a flag in TextFieldDecorator that allows controlling whether the element is hidden or visible by default. > How should this be exposed to chromium? Something like bool WebTextFieldDecoratorClient::isDefaultVisible()? > > Source/WebKit/chromium/public/WebTextFieldDecorationElement.h:54 > > + // Make visible iff true. > > Don't need this comment here. > > > Source/WebKit/chromium/src/TextFieldDecoratorImpl.h:46 > > + WebTextFieldDecoratorClient* decoratorClient(); > > Instead of exposing a client here, can we instead let it do the comparison inside: > > WebTextfieldDecoratorClient::isClientFor(WebCore::TextFieldDecorator*); > > This way, the casting to TextFieldDecoratorImpl becomes an implementation detail, not an assumption in WebInputElement. > > > Source/WebKit/chromium/src/WebInputElement.cpp:221 > > + ShadowRoot* shadowRoot = unwrap<HTMLInputElement>()->shadow()->youngestShadowRoot(); > > I think the code just landed that lets you use Node::youngestShadowRoot() > > > Source/WebKit/chromium/src/WebInputElement.cpp:228 > > + shadowRoot->olderShadowRoot(); > > shadowRoot = shadowRoot->olderShadowRoot(); !!! > > > Source/WebKit/chromium/src/WebTextFieldDecorationElement.cpp:50 > > + if (visible) > > + unwrap<TextFieldDecorationElement>()->setInlineStyleProperty(CSSPropertyVisibility, > > + CSSValueVisible); > > + else > > + unwrap<TextFieldDecorationElement>()->setInlineStyleProperty(CSSPropertyVisibility, > > + CSSValueHidden); > > I think we can just use WebElement::setAttribute("style", "display:none|block") instead. This way, the patch will be smaller and we're not exposing any new WebCore functionality. WDYT? 630648 23 dglazkov 2012-05-22 12:14:26 -0700 (In reply to comment #22) > How should this be exposed to chromium? Something like > > bool WebTextFieldDecoratorClient::isDefaultVisible()? visibleByDefault sounds WebKitty. 631112 24 143145 tkent 2012-05-22 20:13:26 -0700 Comment on attachment 143145 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=143145&action=review >>> Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:69 >>> +TextFieldDecorationElement* TextFieldDecorationElement::fromShadowRoot(ShadowRoot* shadowRoot) >> >> Can you file a bug about making TextFieldDecorationElement _the_ ShadowRoot and add a FIXME comment referencing it? >> >> // FIXME: After fixing http://bugs.webkit.org/...., this should be a simple cast. > > How should this be exposed to chromium? Something like > > bool WebTextFieldDecoratorClient::isDefaultVisible()? I'm not sure we can make TextFieldDecorationElement a ShadowRoot. If we'd like to avoid such digging, we can add id attribute to a TextFieldDecorationElement, and can use ShadowRoot::getElementById(). 631121 25 dglazkov 2012-05-22 20:27:29 -0700 (In reply to comment #24) > (From update of attachment 143145 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=143145&action=review > > >>> Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:69 > >>> +TextFieldDecorationElement* TextFieldDecorationElement::fromShadowRoot(ShadowRoot* shadowRoot) > >> > >> Can you file a bug about making TextFieldDecorationElement _the_ ShadowRoot and add a FIXME comment referencing it? > >> > >> // FIXME: After fixing http://bugs.webkit.org/...., this should be a simple cast. > > > > How should this be exposed to chromium? Something like > > > > bool WebTextFieldDecoratorClient::isDefaultVisible()? > > I'm not sure we can make TextFieldDecorationElement a ShadowRoot. > If we'd like to avoid such digging, we can add id attribute to a TextFieldDecorationElement, and can use ShadowRoot::getElementById(). Well, you're right -- not a Shadow Root. However, it surely does not need to be an element three levels down from the Shadow Root. 632995 26 143861 gcasto 2012-05-24 11:34:44 -0700 Created attachment 143861 Patch 632998 27 gcasto 2012-05-24 11:35:41 -0700 (In reply to comment #21) > (From update of attachment 143145 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=143145&action=review > > I think this is good. I would really like for Kent-san to look over the next iteration of the patch, since you and I came up with this idea together. Another pair of eyes wouldn't hurt :) > > > Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:69 > > +TextFieldDecorationElement* TextFieldDecorationElement::fromShadowRoot(ShadowRoot* shadowRoot) > > Can you file a bug about making TextFieldDecorationElement _the_ ShadowRoot and add a FIXME comment referencing it? > > // FIXME: After fixing http://bugs.webkit.org/...., this should be a simple cast. > I've filled a bug, but I removed this comment for the moment as it seems like we can't actually make this a ShadowRoot. I can put this, or something similar back in if you want. > > Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:108 > > + box->setInlineStyleProperty(CSSPropertyVisibility, CSSValueHidden); > > I don't mind if you expose a flag in TextFieldDecorator that allows controlling whether the element is hidden or visible by default. > > > Source/WebKit/chromium/public/WebTextFieldDecorationElement.h:54 > > + // Make visible iff true. > > Don't need this comment here. > > > Source/WebKit/chromium/src/TextFieldDecoratorImpl.h:46 > > + WebTextFieldDecoratorClient* decoratorClient(); > > Instead of exposing a client here, can we instead let it do the comparison inside: > > WebTextfieldDecoratorClient::isClientFor(WebCore::TextFieldDecorator*); > > This way, the casting to TextFieldDecoratorImpl becomes an implementation detail, not an assumption in WebInputElement. > So I moved the cast and comparison into WebTextFieldDecoratorClient, but I believe that you still need this function (or something similar like isFromDecoratorClient(WebTextFieldDecoratorClient*)) > > Source/WebKit/chromium/src/WebInputElement.cpp:221 > > + ShadowRoot* shadowRoot = unwrap<HTMLInputElement>()->shadow()->youngestShadowRoot(); > > I think the code just landed that lets you use Node::youngestShadowRoot() > > > Source/WebKit/chromium/src/WebInputElement.cpp:228 > > + shadowRoot->olderShadowRoot(); > > shadowRoot = shadowRoot->olderShadowRoot(); !!! > Yikes. > > Source/WebKit/chromium/src/WebTextFieldDecorationElement.cpp:50 > > + if (visible) > > + unwrap<TextFieldDecorationElement>()->setInlineStyleProperty(CSSPropertyVisibility, > > + CSSValueVisible); > > + else > > + unwrap<TextFieldDecorationElement>()->setInlineStyleProperty(CSSPropertyVisibility, > > + CSSValueHidden); > > I think we can just use WebElement::setAttribute("style", "display:none|block") instead. This way, the patch will be smaller and we're not exposing any new WebCore functionality. WDYT? I've made this change, though this does override the style set in TextFieldDecorationElement::decorate() yes? The only property that is currently getting set is -webkit-box-flex, but I'm not sure how important that is. It looks fine without it in testing anyway. Changing to display:none instead of visibility:hidden removed the mouse over issue that I was experiencing before, so that's good. 633456 28 143861 tkent 2012-05-24 18:48:57 -0700 Comment on attachment 143861 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=143861&action=review Looks almost ok. r- because of some nits. > Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:118 > setInlineStyleProperty(CSSPropertyWebkitBoxFlex, 0.0, CSSPrimitiveValue::CSS_NUMBER); > box->appendChild(this); > + > + if (visible) > + setInlineStyleProperty(CSSPropertyDisplay, CSSValueBlock); > + else > + setInlineStyleProperty(CSSPropertyDisplay, CSSValueNone); This should be put before box->appendChild(this) to avoid style-recalc after renderer attachment. Also, we can write this as setInlineStyleProperty(CSSPropertyDisplay, visible ? CSSValueBlock : CSSValueNone); > Source/WebKit/chromium/src/TextFieldDecoratorImpl.cpp:64 > + > + nit: should be one blank line. > Source/WebKit/chromium/src/WebInputElement.cpp:236 > + if (decoration > + && decoratorClient->isClientFor(decoration->textFieldDecorator())) { nit: You don't need to wrap these line. You don't need { }. > Source/WebKit/chromium/src/WebTextFieldDecorationElement.cpp:49 > + if (visible) > + unwrap<TextFieldDecorationElement>()->setAttribute(HTMLNames::styleAttr, > + "display:block"); > + else > + unwrap<TextFieldDecorationElement>()->setAttribute(HTMLNames::styleAttr, > + "display:none"); You should use setInlineStyleProperty() like you did in TextFieldDecorationElement::decorate(). Setting style attribute is expensive. 634005 29 gcasto 2012-05-25 10:05:24 -0700 (In reply to comment #28) > (From update of attachment 143861 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=143861&action=review > > Looks almost ok. r- because of some nits. > > > Source/WebCore/html/shadow/TextFieldDecorationElement.cpp:118 > > setInlineStyleProperty(CSSPropertyWebkitBoxFlex, 0.0, CSSPrimitiveValue::CSS_NUMBER); > > box->appendChild(this); > > + > > + if (visible) > > + setInlineStyleProperty(CSSPropertyDisplay, CSSValueBlock); > > + else > > + setInlineStyleProperty(CSSPropertyDisplay, CSSValueNone); > > This should be put before box->appendChild(this) to avoid style-recalc after renderer attachment. > Also, we can write this as setInlineStyleProperty(CSSPropertyDisplay, visible ? CSSValueBlock : CSSValueNone); > > > Source/WebKit/chromium/src/TextFieldDecoratorImpl.cpp:64 > > + > > + > > nit: should be one blank line. > > > Source/WebKit/chromium/src/WebInputElement.cpp:236 > > + if (decoration > > + && decoratorClient->isClientFor(decoration->textFieldDecorator())) { > > nit: You don't need to wrap these line. > You don't need { }. > > > Source/WebKit/chromium/src/WebTextFieldDecorationElement.cpp:49 > > + if (visible) > > + unwrap<TextFieldDecorationElement>()->setAttribute(HTMLNames::styleAttr, > > + "display:block"); > > + else > > + unwrap<TextFieldDecorationElement>()->setAttribute(HTMLNames::styleAttr, > > + "display:none"); > > You should use setInlineStyleProperty() like you did in TextFieldDecorationElement::decorate(). > Setting style attribute is expensive. I was originally using setInlineStyleProperty, but Dimitri recommended this instead. I'm fine with whichever. Dimitri, do you still think that this should use setAttribute? 634010 30 dglazkov 2012-05-25 10:08:56 -0700 (In reply to comment #29) > > You should use setInlineStyleProperty() like you did in TextFieldDecorationElement::decorate(). > > Setting style attribute is expensive. > > I was originally using setInlineStyleProperty, but Dimitri recommended this instead. I'm fine with whichever. Dimitri, do you still think that this should use setAttribute? I did, and I still think it's ok, since Web developers do this all the time -- but only if as means of removing the need for that whole extra file WebTextDecorationElement. Adding new WebKit API leads to pain of maintenance. If there are strong feelings, I would much rather expose setting inline style on WebElement. 634059 31 gcasto 2012-05-25 10:46:18 -0700 (In reply to comment #30) > (In reply to comment #29) > > > You should use setInlineStyleProperty() like you did in TextFieldDecorationElement::decorate(). > > > Setting style attribute is expensive. > > > > I was originally using setInlineStyleProperty, but Dimitri recommended this instead. I'm fine with whichever. Dimitri, do you still think that this should use setAttribute? > > I did, and I still think it's ok, since Web developers do this all the time -- but only if as means of removing the need for that whole extra file WebTextDecorationElement. Adding new WebKit API leads to pain of maintenance. If there are strong feelings, I would much rather expose setting inline style on WebElement. Ahh, I totally misunderstood that comment then. I didn't realize that you wanted to get rid of WebTextFieldDecorationElement. I'm fine with that. For the moment I'll just use a WebElement and not expose setInlineStyleProperty. I can add that later if we so desire. 634126 32 144111 gcasto 2012-05-25 11:48:39 -0700 Created attachment 144111 Patch 634513 33 144111 tkent 2012-05-25 18:37:01 -0700 Comment on attachment 144111 Patch ok 634532 34 144111 webkit.review.bot 2012-05-25 19:20:56 -0700 Comment on attachment 144111 Patch Clearing flags on attachment: 144111 Committed r118601: <http://trac.webkit.org/changeset/118601> 634533 35 webkit.review.bot 2012-05-25 19:21:03 -0700 All reviewed patches have been landed. Closing bug. 142128 2012-05-15 19:15:05 -0700 2012-05-16 10:36:58 -0700 Patch bug-86557-20120515191504.patch text/plain 14949 gcasto U3VidmVyc2lvbiBSZXZpc2lvbjogMTE2ODE2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYzc3ZjFhNTI1Y2Q0ODBj ZTdmNjliZWE4ODFmYTRiODZiNWEyYjNjNS4uNWM4ZDVjZWMxOTVjMWQ4ZDgwMmNkYWFiNGMxN2Vm MjgyNjQ4NDRmNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDEyLTA1LTE1ICBHYXJy ZXR0IENhc3RvICA8Z2Nhc3RvQGNocm9taXVtLm9yZz4KKworICAgICAgICBBbGxvdyBXZWJUZXh0 RmllbGREZWNvcmF0b3JDbGllbnQgdG8gc2VlIGFwcGxpZWQgZGVjb3JhdGlvbnMuCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NjU1NworCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogaHRtbC9zaGFkb3cvVGV4 dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuY3BwOgorICAgICAgICBVcGRhdGUgc28gdGhhdCBjaGFu Z2luZyB0aGUgQ1NTIHZpc2liaWx0eSBvbiB0aGUgZWxlbWVudCB3aWxsIGJlCisgICAgICAgIHBy b3Blcmx5IHJlZmxlY3RlZCBpbiByZW5kZXJpbmcuCisgICAgICAgIChXZWJDb3JlOjpUZXh0Rmll bGREZWNvcmF0aW9uRWxlbWVudDo6Y3VzdG9tU3R5bGVGb3JSZW5kZXJlcik6CisgICAgICAgICog aHRtbC9zaGFkb3cvVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuaDoKKyAgICAgICAgKFdlYkNv cmUpOgorICAgICAgICAoVGV4dEZpZWxkRGVjb3JhdG9yKToKKwogMjAxMi0wNS0xMSAgU2hlcmlm ZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdl ZCwgcm9sbGluZyBvdXQgcjExNjgwMi4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggMWFm ZTA2MzY1NzI0NDRkOGE4MDQ4NjQ3NThiZGVjYzQ4MjdjYzU0NS4uZWZhYTNmMTY3ODNhNzFiZTc0 ODVmMDU5YzRiYmFjYmFkOTlkMDhkYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwzNiBAQAorMjAxMi0wNS0xNSAgR2FycmV0dCBDYXN0byAgPGdjYXN0b0BjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgQWxsb3cgV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50IHRvIHNlZSBh cHBsaWVkIGRlY29yYXRpb25zLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9ODY1NTcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAqIFdlYktpdC5neXA6IEFkZGVkIG5ldyBmaWxlcy4KKyAgICAgICAgKiBwdWJs aWMvV2ViU3R5bGVkRWxlbWVudC5oOiBCcmlkZ2UgdG8gU3R5bGVkRWxlbWVudC4gQ3VycmVudGx5 IG9ubHkKKyAgICAgICAgYWxsb3dzIGZvciBjaGFuZ2luZyB0aGUgQ1NTIHZpc2liaWxpdHkgb2Yg YW4gZWxlbWVudC4KKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJTdHlsZWRFbGVtZW50 KToKKyAgICAgICAgKFdlYktpdDo6V2ViU3R5bGVkRWxlbWVudDo6V2ViU3R5bGVkRWxlbWVudCk6 CisgICAgICAgIChXZWJLaXQ6OldlYlN0eWxlZEVsZW1lbnQ6Om9wZXJhdG9yPSk6CisgICAgICAg IChXZWJLaXQ6OldlYlN0eWxlZEVsZW1lbnQ6OmFzc2lnbik6CisgICAgICAgICogcHVibGljL1dl YlRleHRGaWVsZERlY29yYXRvckNsaWVudC5oOgorICAgICAgICBBZGRlZCBkZWNvcmF0aW9uQWRk ZWQoKSB0byBsZXQgY2xpZW50cyBzZWUgdGhlIGRlY29yYXRpb24gb2JqZWN0IHRoYXQKKyAgICAg ICAgaXMgYWRkZWQuCisgICAgICAgIChXZWJUZXh0RmllbGREZWNvcmF0b3JDbGllbnQpOgorICAg ICAgICAqIHNyYy9DaHJvbWVDbGllbnRJbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6Q2hyb21l Q2xpZW50SW1wbDo6YWRkVGV4dEZpZWxkRGVjb3JhdGlvbnNUbyk6CisgICAgICAgICogc3JjL1Rl eHRGaWVsZERlY29yYXRvckltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpUZXh0RmllbGREZWNv cmF0b3JJbXBsOjpkZWNvcmF0aW9uQWRkZWQpOgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAg KiBzcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5oOgorICAgICAgICAoVGV4dEZpZWxkRGVjb3Jh dG9ySW1wbCk6CisgICAgICAgICogc3JjL1dlYlN0eWxlZEVsZW1lbnQuY3BwOgorICAgICAgICAo V2ViS2l0KToKKyAgICAgICAgKFdlYktpdDo6V2ViU3R5bGVkRWxlbWVudDo6c2V0VmlzaWJsZSk6 CisgICAgICAgIChXZWJLaXQ6OldlYlN0eWxlZEVsZW1lbnQ6OldlYlN0eWxlZEVsZW1lbnQpOgor ICAgICAgICAoV2ViS2l0OjpXZWJTdHlsZWRFbGVtZW50OjpvcGVyYXRvcj0pOgorICAgICAgICAo V2ViS2l0OjpXZWJTdHlsZWRFbGVtZW50OjpvcGVyYXRvciBQYXNzUmVmUHRyPFN0eWxlZEVsZW1l bnQ+KToKKwogMjAxMi0wNS0xMSAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFp bC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjExNjgwMi4KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1RleHRGaWVsZERlY29yYXRpb25FbGVt ZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1RleHRGaWVsZERlY29yYXRpb25F bGVtZW50LmNwcAppbmRleCA1ODBlYmFkY2JkZmE0ZjdjYWZjZTY2NDAxMzAyNjAwM2FkYWY2M2Q0 Li5jNTRkODM3MWVmNzkxODM0MmVhNmU4YWE2MTc0Y2IzOTdlNThiYTJkIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9UZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1l bnQuY3BwCkBAIC0xMzgsNiArMTM4LDkgQEAgUGFzc1JlZlB0cjxSZW5kZXJTdHlsZT4gVGV4dEZp ZWxkRGVjb3JhdGlvbkVsZW1lbnQ6OmN1c3RvbVN0eWxlRm9yUmVuZGVyZXIoKQogICAgIEFTU0VS VChpbnB1dFN0eWxlKTsKICAgICBzdHlsZS0+c2V0V2lkdGgoTGVuZ3RoKGlucHV0U3R5bGUtPmZv bnRTaXplKCksIEZpeGVkKSk7CiAgICAgc3R5bGUtPnNldEhlaWdodChMZW5ndGgoaW5wdXRTdHls ZS0+Zm9udFNpemUoKSwgRml4ZWQpKTsKKyAgICBpZiAoaW5saW5lU3R5bGUoKS0+Z2V0UHJvcGVy dHlWYWx1ZShDU1NQcm9wZXJ0eVZpc2liaWxpdHkpID09ICJoaWRkZW4iCisgICAgICAgIHx8IGlu cHV0U3R5bGUtPnZpc2liaWxpdHkoKSA9PSBISURERU4pCisgICAgICAgIHN0eWxlLT5zZXRWaXNp YmlsaXR5KEhJRERFTik7CiAgICAgdXBkYXRlSW1hZ2UoKTsKICAgICByZXR1cm4gc3R5bGUucmVs ZWFzZSgpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dEZp ZWxkRGVjb3JhdGlvbkVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1RleHRG aWVsZERlY29yYXRpb25FbGVtZW50LmgKaW5kZXggYjM0ZTdiNWFhOTZmMzRjNzcwNzcyOTk1Njk3 MWEyMjZlYWQ3MDBjNy4uYTY3MDNkNjU0YzA0OGI0MDg3YWU2NTY1YTg3NWY0ODVjNjc3NGM0MSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dEZpZWxkRGVjb3JhdGlv bkVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9UZXh0RmllbGREZWNv cmF0aW9uRWxlbWVudC5oCkBAIC0zOCw2ICszOCw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIGNs YXNzIENhY2hlZEltYWdlOwogY2xhc3MgSFRNTElucHV0RWxlbWVudDsKIAorY2xhc3MgVGV4dEZp ZWxkRGVjb3JhdGlvbkVsZW1lbnQ7CisKIC8vIEEgVGV4dEZpZWxkRGVjb3JhdG9yIG9iamVjdCBt dXN0IGxpdmUgdW50aWwgYWxsIG9mIHRleHQgZmllbGRzIHdoaWNoIHdlcmUKIC8vIGRlY29yYXRl ZCBieSBpdCBkaWUuCiBjbGFzcyBUZXh0RmllbGREZWNvcmF0b3IgewpAQCAtNDUsNiArNDcsOCBA QCBwdWJsaWM6CiAgICAgLy8gUmV0dXJucyB0cnVlIGlmIHRoaXMgVGV4dEZpZWxkRGVjb3JhdG9y IHdhbnRzIHRvIGFkZCBhCiAgICAgLy8gZGVjb3JhdGlvbiB0byB0aGUgc3BlY2lmaWVkIHRleHQg ZmllbGQuCiAgICAgdmlydHVhbCBib29sIHdpbGxBZGREZWNvcmF0aW9uVG8oSFRNTElucHV0RWxl bWVudCopID0gMDsKKyAgICAvLyBDYWxsZWQgb25jZSB0aGUgZ2l2ZW4gZGVjb3JhdGlvbiBpcyBh ZGRlZCB0byB0aGUgaW5wdXQgZWxlbWVudC4KKyAgICB2aXJ0dWFsIHZvaWQgZGVjb3JhdGlvbkFk ZGVkKEhUTUxJbnB1dEVsZW1lbnQqLCBUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudCopID0gMDsK IAogICAgIC8vIEEgVGV4dEZpZWxkRGVjb3JhdG9yIG9iamVjdCBzaG91bGQgb3duIHRoZSBDYWNo ZWRJbWFnZSBvYmplY3RzLgogICAgIHZpcnR1YWwgQ2FjaGVkSW1hZ2UqIGltYWdlRm9yTm9ybWFs U3RhdGUoKSA9IDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5n eXAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAKaW5kZXggZmRkZDY4ZDQ5MGE5 NGUxN2Q5ZGFhNGMzZjhkOTBiYmExZDI1MjljZS4uZmRlMjQ2NzZlMmY0ZTcwN2M1ZDY0OTUyYjIz MzE0ODhlMmJkNmRmMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQu Z3lwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cApAQCAtMjYzLDYgKzI2 Myw3IEBACiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJTdG9yYWdlUXVvdGFUeXBlLmgnLAog ICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViU3Vycm91bmRpbmdUZXh0LmgnLAogICAgICAgICAg ICAgICAgICdwdWJsaWMvV2ViU3RyZWFtVGV4dHVyZUNsaWVudC5oJywKKyAgICAgICAgICAgICAg ICAncHVibGljL1dlYlN0eWxlZEVsZW1lbnQuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9X ZWJUZXh0QWZmaW5pdHkuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJUZXh0Q2FzZVNl bnNpdGl2aXR5LmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViVGV4dENoZWNraW5nQ29t cGxldGlvbi5oJywKQEAgLTY0Nyw2ICs2NDgsNyBAQAogICAgICAgICAgICAgICAgICdzcmMvV2Vi U3RvcmFnZUV2ZW50RGlzcGF0Y2hlckltcGwuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dl YlN0b3JhZ2VRdW90YUNhbGxiYWNrc0ltcGwuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dl YlN0b3JhZ2VRdW90YUNhbGxiYWNrc0ltcGwuaCcsCisgICAgICAgICAgICAgICAgJ3NyYy9XZWJT dHlsZWRFbGVtZW50LmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJTdXJyb3VuZGluZ1Rl eHQuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYlRleHRSdW4uY3BwJywKICAgICAgICAg ICAgICAgICAnc3JjL1dlYlVSTExvYWRUaW1pbmcuY3BwJywKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlN0eWxlZEVsZW1lbnQuaCBiL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vcHVibGljL1dlYlN0eWxlZEVsZW1lbnQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5hNzk2ZDZlMzU1 ZDQ3YWYyMDgwZmU2ZGRhNGEzMjE3ZGRmYmFhNTNjCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViU3R5bGVkRWxlbWVudC5oCkBAIC0wLDAgKzEsNjYg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisg KiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4g dGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUg SW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRv IGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdh cmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRS SUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVT LCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJ RVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBV UlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAq IE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERB TUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLwor CisjaWZuZGVmIFdlYlN0eWxlZEVsZW1lbnRfaAorI2RlZmluZSBXZWJTdHlsZWRFbGVtZW50X2gK KworI2luY2x1ZGUgIldlYkVsZW1lbnQuaCIKKworI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgor bmFtZXNwYWNlIFdlYkNvcmUgeyBjbGFzcyBTdHlsZWRFbGVtZW50OyB9CisjZW5kaWYKKworbmFt ZXNwYWNlIFdlYktpdCB7CisKKyAgICBjbGFzcyBXZWJTdHlsZWRFbGVtZW50IDogcHVibGljIFdl YkVsZW1lbnQgeworICAgICAgcHVibGljOgorICAgICAgICBXZWJTdHlsZWRFbGVtZW50KCkgOiBX ZWJFbGVtZW50KCkgeyB9CisgICAgICAgIFdlYlN0eWxlZEVsZW1lbnQoY29uc3QgV2ViU3R5bGVk RWxlbWVudCYgc2UpIDogV2ViRWxlbWVudChzZSkgeyB9CisKKyAgICAgICAgV2ViU3R5bGVkRWxl bWVudCYgb3BlcmF0b3I9KGNvbnN0IFdlYlN0eWxlZEVsZW1lbnQmIHNlKQorICAgICAgICB7Cisg ICAgICAgICAgICBXZWJFbGVtZW50Ojphc3NpZ24oc2UpOworICAgICAgICAgICAgcmV0dXJuICp0 aGlzOworICAgICAgICB9CisgICAgICAgIHZvaWQgYXNzaWduKGNvbnN0IFdlYlN0eWxlZEVsZW1l bnQmIHNlKSB7IFdlYkVsZW1lbnQ6OmFzc2lnbihzZSk7IH0KKworICAgICAgICAvLyBTZXQgdmlz aWJpbGl0eSBzdHlsZSB0byB2aXNpYmxlIGlmIHRydWUsIGhpZGRlbiBpZiBmYWxzZS4KKyAgICAg ICAgV0VCS0lUX0VYUE9SVCB2b2lkIHNldFZpc2libGUoYm9vbCk7CisKKyNpZiBXRUJLSVRfSU1Q TEVNRU5UQVRJT04KKyAgICAgICAgV2ViU3R5bGVkRWxlbWVudChjb25zdCBXVEY6OlBhc3NSZWZQ dHI8V2ViQ29yZTo6U3R5bGVkRWxlbWVudD4mKTsKKyAgICAgICAgV2ViU3R5bGVkRWxlbWVudCYg b3BlcmF0b3I9KGNvbnN0IFdURjo6UGFzc1JlZlB0cjxXZWJDb3JlOjpTdHlsZWRFbGVtZW50PiYp OworICAgICAgICBvcGVyYXRvciBXVEY6OlBhc3NSZWZQdHI8V2ViQ29yZTo6U3R5bGVkRWxlbWVu dD4oKSBjb25zdDsKKyNlbmRpZgorICAgIH07CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisj ZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlRleHRG aWVsZERlY29yYXRvckNsaWVudC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2Vi VGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50LmgKaW5kZXggYThkMjlmOTNlYjg2YTQ2N2UyYTVlYjhj YTk0ZGRlODY2YTUyZDczMC4uZmE5MzVjNTZiOWM1MDEzOGU1YzJlYzYxMzQzZjczMTAzZTVlNjVh NSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViVGV4dEZpZWxk RGVjb3JhdG9yQ2xpZW50LmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2Vi VGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50LmgKQEAgLTQzLDYgKzQzLDEwIEBAIHB1YmxpYzoKICAg ICAvLyBoYXZlIGEgZGVjb3JhdGlvbiBpY29uLiBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCB3aGVu ZXZlciBhIHRleHQgZmllbGQgaXMKICAgICAvLyBjcmVhdGVkLCBhbmQgc2hvdWxkIG5vdCB0YWtl IG11Y2ggdGltZS4KICAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkQWRkRGVjb3JhdGlvblRvKGNvbnN0 IFdlYklucHV0RWxlbWVudCYpID0gMDsKKyAgICAvLyBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCB3 aGVuZXZlciBhIGRlY29yYXRpb24gaXMgYWRkZWQgdG8gdGhlIGdpdmVuCisgICAgLy8gV2ViSW5w dXRFbGVtZW50LgorICAgIHZpcnR1YWwgdm9pZCBkZWNvcmF0aW9uQWRkZWQoY29uc3QgV2ViSW5w dXRFbGVtZW50JiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IFdlYlN0 eWxlZEVsZW1lbnQmKSA9IDA7CiAKICAgICAvLyBJbWFnZSByZXNvdXJjZSBuYW1lIGZvciB0aGUg bm9ybWFsIHN0YXRlLiBUaGUgaW1hZ2UgaXMgc3RyZXRjaGVkIHRvCiAgICAgLy8gZm9udC1zaXpl IHggZm9udC1zaXplIHNxdWFyZS4gVGhlIGZ1bmN0aW9uIG11c3QgcmV0dXJuIGFuIGV4aXN0aW5n CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9DaHJvbWVDbGllbnRJbXBs LmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0Nocm9tZUNsaWVudEltcGwuY3BwCmlu ZGV4IDg4MDhlNWQ2YWZjZGMzNWFiYjRjNzcwYjcxZmYxN2FlMDkwZWY3NDAuLmJkMGNmZTJmNjY5 MzY0Yzk1NDhiMTBiM2M2NDQyNzJiNTNlOGQ4YzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL0Nocm9tZUNsaWVudEltcGwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL0Nocm9tZUNsaWVudEltcGwuY3BwCkBAIC0xMDQ2LDYgKzEwNDYsNyBAQCB2b2lk IENocm9tZUNsaWVudEltcGw6OmFkZFRleHRGaWVsZERlY29yYXRpb25zVG8oSFRNTElucHV0RWxl bWVudCogaW5wdXQpCiAgICAgICAgICAgICBjb250aW51ZTsKICAgICAgICAgUmVmUHRyPFRleHRG aWVsZERlY29yYXRpb25FbGVtZW50PiBkZWNvcmF0aW9uID0gVGV4dEZpZWxkRGVjb3JhdGlvbkVs ZW1lbnQ6OmNyZWF0ZShpbnB1dC0+ZG9jdW1lbnQoKSwgZGVjb3JhdG9yc1tpXS5nZXQoKSk7CiAg ICAgICAgIGRlY29yYXRpb24tPmRlY29yYXRlKGlucHV0KTsKKyAgICAgICAgZGVjb3JhdG9yc1tp XS0+ZGVjb3JhdGlvbkFkZGVkKGlucHV0LCBkZWNvcmF0aW9uLmdldCgpKTsKICAgICB9CiB9CiAK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1RleHRGaWVsZERlY29yYXRv ckltcGwuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVGV4dEZpZWxkRGVjb3JhdG9y SW1wbC5jcHAKaW5kZXggZTU4YzAyMmVlYjQ2NjdhMmNkNjcxY2FlYzk3ZjU3NzI5ZmJiMjVjNi4u OGJhNjdjMGIxN2RlZTViZjZjMjVhZmIxZjg0ZmZlNzk5MzEwMjkzYiAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5jcHAKKysrIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5jcHAKQEAg LTM1LDYgKzM1LDcgQEAKICNpbmNsdWRlICJIVE1MSW5wdXRFbGVtZW50LmgiCiAjaW5jbHVkZSAi SW1hZ2UuaCIKICNpbmNsdWRlICJXZWJJbnB1dEVsZW1lbnQuaCIKKyNpbmNsdWRlICJXZWJTdHls ZWRFbGVtZW50LmgiCiAjaW5jbHVkZSAiV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50LmgiCiAK IG5hbWVzcGFjZSBXZWJLaXQgewpAQCAtNjIsNiArNjMsMTQgQEAgYm9vbCBUZXh0RmllbGREZWNv cmF0b3JJbXBsOjp3aWxsQWRkRGVjb3JhdGlvblRvKEhUTUxJbnB1dEVsZW1lbnQqIGlucHV0KQog ICAgIHJldHVybiBtX2NsaWVudC0+c2hvdWxkQWRkRGVjb3JhdGlvblRvKFdlYklucHV0RWxlbWVu dChpbnB1dCkpOwogfQogCit2b2lkIFRleHRGaWVsZERlY29yYXRvckltcGw6OmRlY29yYXRpb25B ZGRlZChIVE1MSW5wdXRFbGVtZW50KiBpbnB1dCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgIFRleHRGaWVsZERlY29yYXRpb25FbGVtZW50KiBkZWNvcmF0aW9u KSB7CisgICAgQVNTRVJUKGlucHV0KTsKKyAgICBBU1NFUlQoZGVjb3JhdGlvbik7CisgICAgbV9j bGllbnQtPmRlY29yYXRpb25BZGRlZChXZWJJbnB1dEVsZW1lbnQoaW5wdXQpLAorICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgV2ViU3R5bGVkRWxlbWVudChkZWNvcmF0aW9uKSk7Cit9CisK IENhY2hlZEltYWdlKiBUZXh0RmllbGREZWNvcmF0b3JJbXBsOjppbWFnZUZvck5vcm1hbFN0YXRl KCkKIHsKICAgICBpZiAoIW1fY2FjaGVkSW1hZ2VGb3JOb3JtYWxTdGF0ZSkgewpkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5oIGIv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5oCmluZGV4 IDY2NzQ3NTI4MmY1YmUzOTVhZDExMmFiNTg4NTEwM2EwYTcxZTc5OWIuLjdhOGJmYjQwNjU2ZjQ3 NmY4ZDAyYzM1MjZjMTYyZDUxNzE0NTEyYzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL1RleHRGaWVsZERlY29yYXRvckltcGwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3NyYy9UZXh0RmllbGREZWNvcmF0b3JJbXBsLmgKQEAgLTQ1LDYgKzQ1LDcgQEAgcHVi bGljOgogCiBwcml2YXRlOgogICAgIHZpcnR1YWwgYm9vbCB3aWxsQWRkRGVjb3JhdGlvblRvKFdl YkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQqKSBPVkVSUklERTsKKyAgICB2aXJ0dWFsIHZvaWQgZGVj b3JhdGlvbkFkZGVkKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQqLCBXZWJDb3JlOjpUZXh0Rmll bGREZWNvcmF0aW9uRWxlbWVudCopIE9WRVJSSURFOwogICAgIHZpcnR1YWwgV2ViQ29yZTo6Q2Fj aGVkSW1hZ2UqIGltYWdlRm9yTm9ybWFsU3RhdGUoKSBPVkVSUklERTsKICAgICB2aXJ0dWFsIFdl YkNvcmU6OkNhY2hlZEltYWdlKiBpbWFnZUZvckRpc2FibGVkU3RhdGUoKSBPVkVSUklERTsKICAg ICB2aXJ0dWFsIFdlYkNvcmU6OkNhY2hlZEltYWdlKiBpbWFnZUZvclJlYWRvbmx5U3RhdGUoKSBP VkVSUklERTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlN0eWxl ZEVsZW1lbnQuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViU3R5bGVkRWxlbWVu dC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uZGUyOGRmNjQ4OWFmMmE0M2I1NGMxNWNhYmYwMzljZDVlOWQzMTc4 MwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlN0eWxl ZEVsZW1lbnQuY3BwCkBAIC0wLDAgKzEsNjkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIg R29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAg ICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBm b2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICog TmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICog Y29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBk ZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0 dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUg Q09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVY UFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlU RUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRO RVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVW RU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFC TEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhF TVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICog TElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsg TE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJ T04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdI RVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJ TkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhF IFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJ TElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVk ZSAiV2ViU3R5bGVkRWxlbWVudC5oIgorCisjaW5jbHVkZSAiQ1NTUHJvcGVydHlOYW1lcy5oIgor I2luY2x1ZGUgIkNTU1ZhbHVlS2V5d29yZHMuaCIKKyNpbmNsdWRlICJTdHlsZWRFbGVtZW50Lmgi CisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7 CisKK25hbWVzcGFjZSBXZWJLaXQgeworCit2b2lkIFdlYlN0eWxlZEVsZW1lbnQ6OnNldFZpc2li bGUoYm9vbCB2aXNpYmxlKQoreworICAgIGlmICh2aXNpYmxlKQorICAgICAgICB1bndyYXA8U3R5 bGVkRWxlbWVudD4oKS0+c2V0SW5saW5lU3R5bGVQcm9wZXJ0eShDU1NQcm9wZXJ0eVZpc2liaWxp dHksCisgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIENTU1ZhbHVlVmlzaWJsZSk7CisgICAgZWxzZQorICAgICAgICB1bndyYXA8U3R5bGVkRWxl bWVudD4oKS0+c2V0SW5saW5lU3R5bGVQcm9wZXJ0eShDU1NQcm9wZXJ0eVZpc2liaWxpdHksCisg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENT U1ZhbHVlSGlkZGVuKTsKK30KKworV2ViU3R5bGVkRWxlbWVudDo6V2ViU3R5bGVkRWxlbWVudChj b25zdCBQYXNzUmVmUHRyPFN0eWxlZEVsZW1lbnQ+JiBlbGVtKQorICAgIDogV2ViRWxlbWVudChl bGVtKQoreworfQorCitXZWJTdHlsZWRFbGVtZW50JiBXZWJTdHlsZWRFbGVtZW50OjpvcGVyYXRv cj0oY29uc3QgUGFzc1JlZlB0cjxTdHlsZWRFbGVtZW50PiYgZWxlbSkKK3sKKyAgICBtX3ByaXZh dGUgPSBlbGVtOworICAgIHJldHVybiAqdGhpczsKK30KKworV2ViU3R5bGVkRWxlbWVudDo6b3Bl cmF0b3IgUGFzc1JlZlB0cjxTdHlsZWRFbGVtZW50PigpIGNvbnN0Cit7CisgICAgcmV0dXJuIHN0 YXRpY19jYXN0PFN0eWxlZEVsZW1lbnQqPihtX3ByaXZhdGUuZ2V0KCkpOworfQorCit9IC8vIG5h bWVzcGFjZSBXZWJLaXQK 142294 2012-05-16 10:37:02 -0700 2012-05-21 17:21:00 -0700 Patch bug-86557-20120516103701.patch text/plain 14883 gcasto U3VidmVyc2lvbiBSZXZpc2lvbjogMTE2ODE2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYzc3ZjFhNTI1Y2Q0ODBj ZTdmNjliZWE4ODFmYTRiODZiNWEyYjNjNS4uNWM4ZDVjZWMxOTVjMWQ4ZDgwMmNkYWFiNGMxN2Vm MjgyNjQ4NDRmNCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDEyLTA1LTE1ICBHYXJy ZXR0IENhc3RvICA8Z2Nhc3RvQGNocm9taXVtLm9yZz4KKworICAgICAgICBBbGxvdyBXZWJUZXh0 RmllbGREZWNvcmF0b3JDbGllbnQgdG8gc2VlIGFwcGxpZWQgZGVjb3JhdGlvbnMuCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NjU1NworCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogaHRtbC9zaGFkb3cvVGV4 dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuY3BwOgorICAgICAgICBVcGRhdGUgc28gdGhhdCBjaGFu Z2luZyB0aGUgQ1NTIHZpc2liaWx0eSBvbiB0aGUgZWxlbWVudCB3aWxsIGJlCisgICAgICAgIHBy b3Blcmx5IHJlZmxlY3RlZCBpbiByZW5kZXJpbmcuCisgICAgICAgIChXZWJDb3JlOjpUZXh0Rmll bGREZWNvcmF0aW9uRWxlbWVudDo6Y3VzdG9tU3R5bGVGb3JSZW5kZXJlcik6CisgICAgICAgICog aHRtbC9zaGFkb3cvVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuaDoKKyAgICAgICAgKFdlYkNv cmUpOgorICAgICAgICAoVGV4dEZpZWxkRGVjb3JhdG9yKToKKwogMjAxMi0wNS0xMSAgU2hlcmlm ZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFpbC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdl ZCwgcm9sbGluZyBvdXQgcjExNjgwMi4KZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKaW5kZXggMWFm ZTA2MzY1NzI0NDRkOGE4MDQ4NjQ3NThiZGVjYzQ4MjdjYzU0NS4uZWZhYTNmMTY3ODNhNzFiZTc0 ODVmMDU5YzRiYmFjYmFkOTlkMDhkYSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwzNiBAQAorMjAxMi0wNS0xNSAgR2FycmV0dCBDYXN0byAgPGdjYXN0b0BjaHJvbWl1bS5v cmc+CisKKyAgICAgICAgQWxsb3cgV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50IHRvIHNlZSBh cHBsaWVkIGRlY29yYXRpb25zLgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9ODY1NTcKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4K KworICAgICAgICAqIFdlYktpdC5neXA6IEFkZGVkIG5ldyBmaWxlcy4KKyAgICAgICAgKiBwdWJs aWMvV2ViU3R5bGVkRWxlbWVudC5oOiBCcmlkZ2UgdG8gU3R5bGVkRWxlbWVudC4gQ3VycmVudGx5 IG9ubHkKKyAgICAgICAgYWxsb3dzIGZvciBjaGFuZ2luZyB0aGUgQ1NTIHZpc2liaWxpdHkgb2Yg YW4gZWxlbWVudC4KKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJTdHlsZWRFbGVtZW50 KToKKyAgICAgICAgKFdlYktpdDo6V2ViU3R5bGVkRWxlbWVudDo6V2ViU3R5bGVkRWxlbWVudCk6 CisgICAgICAgIChXZWJLaXQ6OldlYlN0eWxlZEVsZW1lbnQ6Om9wZXJhdG9yPSk6CisgICAgICAg IChXZWJLaXQ6OldlYlN0eWxlZEVsZW1lbnQ6OmFzc2lnbik6CisgICAgICAgICogcHVibGljL1dl YlRleHRGaWVsZERlY29yYXRvckNsaWVudC5oOgorICAgICAgICBBZGRlZCBkZWNvcmF0aW9uQWRk ZWQoKSB0byBsZXQgY2xpZW50cyBzZWUgdGhlIGRlY29yYXRpb24gb2JqZWN0IHRoYXQKKyAgICAg ICAgaXMgYWRkZWQuCisgICAgICAgIChXZWJUZXh0RmllbGREZWNvcmF0b3JDbGllbnQpOgorICAg ICAgICAqIHNyYy9DaHJvbWVDbGllbnRJbXBsLmNwcDoKKyAgICAgICAgKFdlYktpdDo6Q2hyb21l Q2xpZW50SW1wbDo6YWRkVGV4dEZpZWxkRGVjb3JhdGlvbnNUbyk6CisgICAgICAgICogc3JjL1Rl eHRGaWVsZERlY29yYXRvckltcGwuY3BwOgorICAgICAgICAoV2ViS2l0OjpUZXh0RmllbGREZWNv cmF0b3JJbXBsOjpkZWNvcmF0aW9uQWRkZWQpOgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAg KiBzcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5oOgorICAgICAgICAoVGV4dEZpZWxkRGVjb3Jh dG9ySW1wbCk6CisgICAgICAgICogc3JjL1dlYlN0eWxlZEVsZW1lbnQuY3BwOgorICAgICAgICAo V2ViS2l0KToKKyAgICAgICAgKFdlYktpdDo6V2ViU3R5bGVkRWxlbWVudDo6c2V0VmlzaWJsZSk6 CisgICAgICAgIChXZWJLaXQ6OldlYlN0eWxlZEVsZW1lbnQ6OldlYlN0eWxlZEVsZW1lbnQpOgor ICAgICAgICAoV2ViS2l0OjpXZWJTdHlsZWRFbGVtZW50OjpvcGVyYXRvcj0pOgorICAgICAgICAo V2ViS2l0OjpXZWJTdHlsZWRFbGVtZW50OjpvcGVyYXRvciBQYXNzUmVmUHRyPFN0eWxlZEVsZW1l bnQ+KToKKwogMjAxMi0wNS0xMSAgU2hlcmlmZiBCb3QgIDx3ZWJraXQucmV2aWV3LmJvdEBnbWFp bC5jb20+CiAKICAgICAgICAgVW5yZXZpZXdlZCwgcm9sbGluZyBvdXQgcjExNjgwMi4KZGlmZiAt LWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1RleHRGaWVsZERlY29yYXRpb25FbGVt ZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1RleHRGaWVsZERlY29yYXRpb25F bGVtZW50LmNwcAppbmRleCA1ODBlYmFkY2JkZmE0ZjdjYWZjZTY2NDAxMzAyNjAwM2FkYWY2M2Q0 Li5jNTRkODM3MWVmNzkxODM0MmVhNmU4YWE2MTc0Y2IzOTdlNThiYTJkIDEwMDY0NAotLS0gYS9T b3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9UZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudC5jcHAK KysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1l bnQuY3BwCkBAIC0xMzgsNiArMTM4LDkgQEAgUGFzc1JlZlB0cjxSZW5kZXJTdHlsZT4gVGV4dEZp ZWxkRGVjb3JhdGlvbkVsZW1lbnQ6OmN1c3RvbVN0eWxlRm9yUmVuZGVyZXIoKQogICAgIEFTU0VS VChpbnB1dFN0eWxlKTsKICAgICBzdHlsZS0+c2V0V2lkdGgoTGVuZ3RoKGlucHV0U3R5bGUtPmZv bnRTaXplKCksIEZpeGVkKSk7CiAgICAgc3R5bGUtPnNldEhlaWdodChMZW5ndGgoaW5wdXRTdHls ZS0+Zm9udFNpemUoKSwgRml4ZWQpKTsKKyAgICBpZiAoaW5saW5lU3R5bGUoKS0+Z2V0UHJvcGVy dHlWYWx1ZShDU1NQcm9wZXJ0eVZpc2liaWxpdHkpID09ICJoaWRkZW4iCisgICAgICAgIHx8IGlu cHV0U3R5bGUtPnZpc2liaWxpdHkoKSA9PSBISURERU4pCisgICAgICAgIHN0eWxlLT5zZXRWaXNp YmlsaXR5KEhJRERFTik7CiAgICAgdXBkYXRlSW1hZ2UoKTsKICAgICByZXR1cm4gc3R5bGUucmVs ZWFzZSgpOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dEZp ZWxkRGVjb3JhdGlvbkVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1RleHRG aWVsZERlY29yYXRpb25FbGVtZW50LmgKaW5kZXggYjM0ZTdiNWFhOTZmMzRjNzcwNzcyOTk1Njk3 MWEyMjZlYWQ3MDBjNy4uYTY3MDNkNjU0YzA0OGI0MDg3YWU2NTY1YTg3NWY0ODVjNjc3NGM0MSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dEZpZWxkRGVjb3JhdGlv bkVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9UZXh0RmllbGREZWNv cmF0aW9uRWxlbWVudC5oCkBAIC0zOCw2ICszOCw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIGNs YXNzIENhY2hlZEltYWdlOwogY2xhc3MgSFRNTElucHV0RWxlbWVudDsKIAorY2xhc3MgVGV4dEZp ZWxkRGVjb3JhdGlvbkVsZW1lbnQ7CisKIC8vIEEgVGV4dEZpZWxkRGVjb3JhdG9yIG9iamVjdCBt dXN0IGxpdmUgdW50aWwgYWxsIG9mIHRleHQgZmllbGRzIHdoaWNoIHdlcmUKIC8vIGRlY29yYXRl ZCBieSBpdCBkaWUuCiBjbGFzcyBUZXh0RmllbGREZWNvcmF0b3IgewpAQCAtNDUsNiArNDcsOCBA QCBwdWJsaWM6CiAgICAgLy8gUmV0dXJucyB0cnVlIGlmIHRoaXMgVGV4dEZpZWxkRGVjb3JhdG9y IHdhbnRzIHRvIGFkZCBhCiAgICAgLy8gZGVjb3JhdGlvbiB0byB0aGUgc3BlY2lmaWVkIHRleHQg ZmllbGQuCiAgICAgdmlydHVhbCBib29sIHdpbGxBZGREZWNvcmF0aW9uVG8oSFRNTElucHV0RWxl bWVudCopID0gMDsKKyAgICAvLyBDYWxsZWQgb25jZSB0aGUgZ2l2ZW4gZGVjb3JhdGlvbiBpcyBh ZGRlZCB0byB0aGUgaW5wdXQgZWxlbWVudC4KKyAgICB2aXJ0dWFsIHZvaWQgZGVjb3JhdGlvbkFk ZGVkKEhUTUxJbnB1dEVsZW1lbnQqLCBUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudCopID0gMDsK IAogICAgIC8vIEEgVGV4dEZpZWxkRGVjb3JhdG9yIG9iamVjdCBzaG91bGQgb3duIHRoZSBDYWNo ZWRJbWFnZSBvYmplY3RzLgogICAgIHZpcnR1YWwgQ2FjaGVkSW1hZ2UqIGltYWdlRm9yTm9ybWFs U3RhdGUoKSA9IDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5n eXAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAKaW5kZXggZmRkZDY4ZDQ5MGE5 NGUxN2Q5ZGFhNGMzZjhkOTBiYmExZDI1MjljZS4uZmRlMjQ2NzZlMmY0ZTcwN2M1ZDY0OTUyYjIz MzE0ODhlMmJkNmRmMyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQu Z3lwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cApAQCAtMjYzLDYgKzI2 Myw3IEBACiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJTdG9yYWdlUXVvdGFUeXBlLmgnLAog ICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViU3Vycm91bmRpbmdUZXh0LmgnLAogICAgICAgICAg ICAgICAgICdwdWJsaWMvV2ViU3RyZWFtVGV4dHVyZUNsaWVudC5oJywKKyAgICAgICAgICAgICAg ICAncHVibGljL1dlYlN0eWxlZEVsZW1lbnQuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9X ZWJUZXh0QWZmaW5pdHkuaCcsCiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJUZXh0Q2FzZVNl bnNpdGl2aXR5LmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2ViVGV4dENoZWNraW5nQ29t cGxldGlvbi5oJywKQEAgLTY0Nyw2ICs2NDgsNyBAQAogICAgICAgICAgICAgICAgICdzcmMvV2Vi U3RvcmFnZUV2ZW50RGlzcGF0Y2hlckltcGwuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dl YlN0b3JhZ2VRdW90YUNhbGxiYWNrc0ltcGwuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dl YlN0b3JhZ2VRdW90YUNhbGxiYWNrc0ltcGwuaCcsCisgICAgICAgICAgICAgICAgJ3NyYy9XZWJT dHlsZWRFbGVtZW50LmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJTdXJyb3VuZGluZ1Rl eHQuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYlRleHRSdW4uY3BwJywKICAgICAgICAg ICAgICAgICAnc3JjL1dlYlVSTExvYWRUaW1pbmcuY3BwJywKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlN0eWxlZEVsZW1lbnQuaCBiL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vcHVibGljL1dlYlN0eWxlZEVsZW1lbnQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi5lMWNmNzEzNWU0 YmY5MWM3NTJkY2IwYWYxYWE5ZGEwYjUyYmZlMmVkCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNl L1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViU3R5bGVkRWxlbWVudC5oCkBAIC0wLDAgKzEsNjYg QEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisg KiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFi b3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhl IGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhp cyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4g dGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRo ZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUg SW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRv IGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdh cmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJ UyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRS SUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVT LCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJ RVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBV UlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAq IE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNU LCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERB TUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0Yg U1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQ Uk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBB TlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBM SUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0Up IEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwg RVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLwor CisjaWZuZGVmIFdlYlN0eWxlZEVsZW1lbnRfaAorI2RlZmluZSBXZWJTdHlsZWRFbGVtZW50X2gK KworI2luY2x1ZGUgIldlYkVsZW1lbnQuaCIKKworI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgor bmFtZXNwYWNlIFdlYkNvcmUgeyBjbGFzcyBTdHlsZWRFbGVtZW50OyB9CisjZW5kaWYKKworbmFt ZXNwYWNlIFdlYktpdCB7CisKK2NsYXNzIFdlYlN0eWxlZEVsZW1lbnQgOiBwdWJsaWMgV2ViRWxl bWVudCB7CitwdWJsaWM6CisgICAgV2ViU3R5bGVkRWxlbWVudCgpIDogV2ViRWxlbWVudCgpIHsg fQorICAgIFdlYlN0eWxlZEVsZW1lbnQoY29uc3QgV2ViU3R5bGVkRWxlbWVudCYgc2UpIDogV2Vi RWxlbWVudChzZSkgeyB9CisKKyAgICBXZWJTdHlsZWRFbGVtZW50JiBvcGVyYXRvcj0oY29uc3Qg V2ViU3R5bGVkRWxlbWVudCYgc2UpCisgICAgeworICAgICAgICBXZWJFbGVtZW50Ojphc3NpZ24o c2UpOworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorICAgIHZvaWQgYXNzaWduKGNvbnN0 IFdlYlN0eWxlZEVsZW1lbnQmIHNlKSB7IFdlYkVsZW1lbnQ6OmFzc2lnbihzZSk7IH0KKworICAg IC8vIFNldCB2aXNpYmlsaXR5IHN0eWxlIHRvIHZpc2libGUgaWYgdHJ1ZSwgaGlkZGVuIGlmIGZh bHNlLgorICAgIFdFQktJVF9FWFBPUlQgdm9pZCBzZXRWaXNpYmxlKGJvb2wpOworCisjaWYgV0VC S0lUX0lNUExFTUVOVEFUSU9OCisgICAgV2ViU3R5bGVkRWxlbWVudChjb25zdCBXVEY6OlBhc3NS ZWZQdHI8V2ViQ29yZTo6U3R5bGVkRWxlbWVudD4mKTsKKyAgICBXZWJTdHlsZWRFbGVtZW50JiBv cGVyYXRvcj0oY29uc3QgV1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6OlN0eWxlZEVsZW1lbnQ+Jik7 CisgICAgb3BlcmF0b3IgV1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6OlN0eWxlZEVsZW1lbnQ+KCkg Y29uc3Q7CisjZW5kaWYKK307CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAorCisjZW5kaWYKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlRleHRGaWVsZERlY29y YXRvckNsaWVudC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViVGV4dEZpZWxk RGVjb3JhdG9yQ2xpZW50LmgKaW5kZXggYThkMjlmOTNlYjg2YTQ2N2UyYTVlYjhjYTk0ZGRlODY2 YTUyZDczMC4uZmE5MzVjNTZiOWM1MDEzOGU1YzJlYzYxMzQzZjczMTAzZTVlNjVhNSAxMDA2NDQK LS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViVGV4dEZpZWxkRGVjb3JhdG9y Q2xpZW50LmgKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViVGV4dEZpZWxk RGVjb3JhdG9yQ2xpZW50LmgKQEAgLTQzLDYgKzQzLDEwIEBAIHB1YmxpYzoKICAgICAvLyBoYXZl IGEgZGVjb3JhdGlvbiBpY29uLiBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCB3aGVuZXZlciBhIHRl eHQgZmllbGQgaXMKICAgICAvLyBjcmVhdGVkLCBhbmQgc2hvdWxkIG5vdCB0YWtlIG11Y2ggdGlt ZS4KICAgICB2aXJ0dWFsIGJvb2wgc2hvdWxkQWRkRGVjb3JhdGlvblRvKGNvbnN0IFdlYklucHV0 RWxlbWVudCYpID0gMDsKKyAgICAvLyBUaGlzIGZ1bmN0aW9uIGlzIGNhbGxlZCB3aGVuZXZlciBh IGRlY29yYXRpb24gaXMgYWRkZWQgdG8gdGhlIGdpdmVuCisgICAgLy8gV2ViSW5wdXRFbGVtZW50 LgorICAgIHZpcnR1YWwgdm9pZCBkZWNvcmF0aW9uQWRkZWQoY29uc3QgV2ViSW5wdXRFbGVtZW50 JiwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIGNvbnN0IFdlYlN0eWxlZEVsZW1l bnQmKSA9IDA7CiAKICAgICAvLyBJbWFnZSByZXNvdXJjZSBuYW1lIGZvciB0aGUgbm9ybWFsIHN0 YXRlLiBUaGUgaW1hZ2UgaXMgc3RyZXRjaGVkIHRvCiAgICAgLy8gZm9udC1zaXplIHggZm9udC1z aXplIHNxdWFyZS4gVGhlIGZ1bmN0aW9uIG11c3QgcmV0dXJuIGFuIGV4aXN0aW5nCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9DaHJvbWVDbGllbnRJbXBsLmNwcCBiL1Nv dXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL0Nocm9tZUNsaWVudEltcGwuY3BwCmluZGV4IDg4MDhl NWQ2YWZjZGMzNWFiYjRjNzcwYjcxZmYxN2FlMDkwZWY3NDAuLmJkMGNmZTJmNjY5MzY0Yzk1NDhi MTBiM2M2NDQyNzJiNTNlOGQ4YzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL0Nocm9tZUNsaWVudEltcGwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L0Nocm9tZUNsaWVudEltcGwuY3BwCkBAIC0xMDQ2LDYgKzEwNDYsNyBAQCB2b2lkIENocm9tZUNs aWVudEltcGw6OmFkZFRleHRGaWVsZERlY29yYXRpb25zVG8oSFRNTElucHV0RWxlbWVudCogaW5w dXQpCiAgICAgICAgICAgICBjb250aW51ZTsKICAgICAgICAgUmVmUHRyPFRleHRGaWVsZERlY29y YXRpb25FbGVtZW50PiBkZWNvcmF0aW9uID0gVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ6OmNy ZWF0ZShpbnB1dC0+ZG9jdW1lbnQoKSwgZGVjb3JhdG9yc1tpXS5nZXQoKSk7CiAgICAgICAgIGRl Y29yYXRpb24tPmRlY29yYXRlKGlucHV0KTsKKyAgICAgICAgZGVjb3JhdG9yc1tpXS0+ZGVjb3Jh dGlvbkFkZGVkKGlucHV0LCBkZWNvcmF0aW9uLmdldCgpKTsKICAgICB9CiB9CiAKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1RleHRGaWVsZERlY29yYXRvckltcGwuY3Bw IGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5jcHAK aW5kZXggZTU4YzAyMmVlYjQ2NjdhMmNkNjcxY2FlYzk3ZjU3NzI5ZmJiMjVjNi4uOGJhNjdjMGIx N2RlZTViZjZjMjVhZmIxZjg0ZmZlNzk5MzEwMjkzYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5jcHAKKysrIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5jcHAKQEAgLTM1LDYgKzM1 LDcgQEAKICNpbmNsdWRlICJIVE1MSW5wdXRFbGVtZW50LmgiCiAjaW5jbHVkZSAiSW1hZ2UuaCIK ICNpbmNsdWRlICJXZWJJbnB1dEVsZW1lbnQuaCIKKyNpbmNsdWRlICJXZWJTdHlsZWRFbGVtZW50 LmgiCiAjaW5jbHVkZSAiV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50LmgiCiAKIG5hbWVzcGFj ZSBXZWJLaXQgewpAQCAtNjIsNiArNjMsMTQgQEAgYm9vbCBUZXh0RmllbGREZWNvcmF0b3JJbXBs Ojp3aWxsQWRkRGVjb3JhdGlvblRvKEhUTUxJbnB1dEVsZW1lbnQqIGlucHV0KQogICAgIHJldHVy biBtX2NsaWVudC0+c2hvdWxkQWRkRGVjb3JhdGlvblRvKFdlYklucHV0RWxlbWVudChpbnB1dCkp OwogfQogCit2b2lkIFRleHRGaWVsZERlY29yYXRvckltcGw6OmRlY29yYXRpb25BZGRlZChIVE1M SW5wdXRFbGVtZW50KiBpbnB1dCwKKyAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgIFRleHRGaWVsZERlY29yYXRpb25FbGVtZW50KiBkZWNvcmF0aW9uKSB7CisgICAg QVNTRVJUKGlucHV0KTsKKyAgICBBU1NFUlQoZGVjb3JhdGlvbik7CisgICAgbV9jbGllbnQtPmRl Y29yYXRpb25BZGRlZChXZWJJbnB1dEVsZW1lbnQoaW5wdXQpLAorICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgV2ViU3R5bGVkRWxlbWVudChkZWNvcmF0aW9uKSk7Cit9CisKIENhY2hlZElt YWdlKiBUZXh0RmllbGREZWNvcmF0b3JJbXBsOjppbWFnZUZvck5vcm1hbFN0YXRlKCkKIHsKICAg ICBpZiAoIW1fY2FjaGVkSW1hZ2VGb3JOb3JtYWxTdGF0ZSkgewpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYktpdC9jaHJvbWl1bS9zcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5oIGIvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5oCmluZGV4IDY2NzQ3NTI4 MmY1YmUzOTVhZDExMmFiNTg4NTEwM2EwYTcxZTc5OWIuLjdhOGJmYjQwNjU2ZjQ3NmY4ZDAyYzM1 MjZjMTYyZDUxNzE0NTEyYzkgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3Jj L1RleHRGaWVsZERlY29yYXRvckltcGwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Ny Yy9UZXh0RmllbGREZWNvcmF0b3JJbXBsLmgKQEAgLTQ1LDYgKzQ1LDcgQEAgcHVibGljOgogCiBw cml2YXRlOgogICAgIHZpcnR1YWwgYm9vbCB3aWxsQWRkRGVjb3JhdGlvblRvKFdlYkNvcmU6OkhU TUxJbnB1dEVsZW1lbnQqKSBPVkVSUklERTsKKyAgICB2aXJ0dWFsIHZvaWQgZGVjb3JhdGlvbkFk ZGVkKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQqLCBXZWJDb3JlOjpUZXh0RmllbGREZWNvcmF0 aW9uRWxlbWVudCopIE9WRVJSSURFOwogICAgIHZpcnR1YWwgV2ViQ29yZTo6Q2FjaGVkSW1hZ2Uq IGltYWdlRm9yTm9ybWFsU3RhdGUoKSBPVkVSUklERTsKICAgICB2aXJ0dWFsIFdlYkNvcmU6OkNh Y2hlZEltYWdlKiBpbWFnZUZvckRpc2FibGVkU3RhdGUoKSBPVkVSUklERTsKICAgICB2aXJ0dWFs IFdlYkNvcmU6OkNhY2hlZEltYWdlKiBpbWFnZUZvclJlYWRvbmx5U3RhdGUoKSBPVkVSUklERTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlN0eWxlZEVsZW1lbnQu Y3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViU3R5bGVkRWxlbWVudC5jcHAKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMC4uZGUyOGRmNjQ4OWFmMmE0M2I1NGMxNWNhYmYwMzljZDVlOWQzMTc4MwotLS0gL2Rl di9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlN0eWxlZEVsZW1lbnQu Y3BwCkBAIC0wLDAgKzEsNjkgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBh cmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29w eXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFs cyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0 aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0 b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZy b20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1p c3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hU IEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1Ig SU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRI RSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgor ICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxM IFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFO WSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBP UiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBU TywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBV U0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VW RVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4g Q09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElH RU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICog T0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBT VUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiV2ViU3R5 bGVkRWxlbWVudC5oIgorCisjaW5jbHVkZSAiQ1NTUHJvcGVydHlOYW1lcy5oIgorI2luY2x1ZGUg IkNTU1ZhbHVlS2V5d29yZHMuaCIKKyNpbmNsdWRlICJTdHlsZWRFbGVtZW50LmgiCisjaW5jbHVk ZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKwordXNpbmcgbmFtZXNwYWNlIFdlYkNvcmU7CisKK25hbWVz cGFjZSBXZWJLaXQgeworCit2b2lkIFdlYlN0eWxlZEVsZW1lbnQ6OnNldFZpc2libGUoYm9vbCB2 aXNpYmxlKQoreworICAgIGlmICh2aXNpYmxlKQorICAgICAgICB1bndyYXA8U3R5bGVkRWxlbWVu dD4oKS0+c2V0SW5saW5lU3R5bGVQcm9wZXJ0eShDU1NQcm9wZXJ0eVZpc2liaWxpdHksCisgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENTU1Zh bHVlVmlzaWJsZSk7CisgICAgZWxzZQorICAgICAgICB1bndyYXA8U3R5bGVkRWxlbWVudD4oKS0+ c2V0SW5saW5lU3R5bGVQcm9wZXJ0eShDU1NQcm9wZXJ0eVZpc2liaWxpdHksCisgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIENTU1ZhbHVlSGlk ZGVuKTsKK30KKworV2ViU3R5bGVkRWxlbWVudDo6V2ViU3R5bGVkRWxlbWVudChjb25zdCBQYXNz UmVmUHRyPFN0eWxlZEVsZW1lbnQ+JiBlbGVtKQorICAgIDogV2ViRWxlbWVudChlbGVtKQorewor fQorCitXZWJTdHlsZWRFbGVtZW50JiBXZWJTdHlsZWRFbGVtZW50OjpvcGVyYXRvcj0oY29uc3Qg UGFzc1JlZlB0cjxTdHlsZWRFbGVtZW50PiYgZWxlbSkKK3sKKyAgICBtX3ByaXZhdGUgPSBlbGVt OworICAgIHJldHVybiAqdGhpczsKK30KKworV2ViU3R5bGVkRWxlbWVudDo6b3BlcmF0b3IgUGFz c1JlZlB0cjxTdHlsZWRFbGVtZW50PigpIGNvbnN0Cit7CisgICAgcmV0dXJuIHN0YXRpY19jYXN0 PFN0eWxlZEVsZW1lbnQqPihtX3ByaXZhdGUuZ2V0KCkpOworfQorCit9IC8vIG5hbWVzcGFjZSBX ZWJLaXQK 143145 2012-05-21 17:21:13 -0700 2012-05-24 11:34:37 -0700 Patch bug-86557-20120521172112.patch text/plain 16942 gcasto U3VidmVyc2lvbiBSZXZpc2lvbjogMTE2ODE2CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYzc3ZjFhNTI1Y2Q0ODBj ZTdmNjliZWE4ODFmYTRiODZiNWEyYjNjNS4uNDdlNjJlM2UzNTcxNzQyYjI3ZjIxMTY4NTQ5ZTUx MjkyZGQ1MjMzMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDEyLTA1LTE1ICBHYXJy ZXR0IENhc3RvICA8Z2Nhc3RvQGNocm9taXVtLm9yZz4KKworICAgICAgICBBbGxvdyBXZWJUZXh0 RmllbGREZWNvcmF0b3JDbGllbnQgdG8gc2VlIGFwcGxpZWQgZGVjb3JhdGlvbnMuCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NjU1NworCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogaHRtbC9zaGFkb3cvVGV4 dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEZpZWxk RGVjb3JhdGlvbkVsZW1lbnQ6OmZyb21TaGFkb3dSb290KTogQSBmdW5jdGlvbgorICAgICAgICB0 aGF0IHdpbGwgZXh0cmFjdCBhIFRleHRGaWVsRGVjb3JhdGlvbkVsZW1lbnQgZnJvbSBhIFNoYWRv d1Jvb3QsIGlmCisgICAgICAgIHRoZXJlIGlzIG9uZS4KKyAgICAgICAgKiBodG1sL3NoYWRvdy9U ZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAg IChUZXh0RmllbGREZWNvcmF0b3IpOgorCiAyMDEyLTA1LTExICBTaGVyaWZmIEJvdCAgPHdlYmtp dC5yZXZpZXcuYm90QGdtYWlsLmNvbT4KIAogICAgICAgICBVbnJldmlld2VkLCByb2xsaW5nIG91 dCByMTE2ODAyLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwppbmRleCAxYWZlMDYzNjU3MjQ0NGQ4 YTgwNDg2NDc1OGJkZWNjNDgyN2NjNTQ1Li5kZjViMzZlMDgzMGQ1NWI2NWJkMjM5YmI0MDE1MmY5 ZDRjZTg5MWNkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwor KysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisy MDEyLTA1LTE1ICBHYXJyZXR0IENhc3RvICA8Z2Nhc3RvQGNocm9taXVtLm9yZz4KKworICAgICAg ICBBbGxvdyBXZWJUZXh0RmllbGREZWNvcmF0b3JDbGllbnQgdG8gc2VlIGFwcGxpZWQgZGVjb3Jh dGlvbnMuCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04 NjU1NworCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICog V2ViS2l0Lmd5cDogQWRkZWQgbmV3IGZpbGVzLgorICAgICAgICAqIHB1YmxpYy9XZWJUZXh0Rmll bGREZWNvcmF0aW9uRWxlbWVudC5oOiBCcmlkZ2UgdG8KKyAgICAgICAgVGV4dEZpZWxkRGVjb3Jh dGlvbkVsZW1lbnQuIEN1cnJlbnRseSBhbGxvd3MgY2hhbmdpbmcgdGhlIENTUworICAgICAgICB2 aXNpYmlsaXR5IG9mIGEgZGVjb3JhdGlvbiBlbGVtZW50LgorICAgICAgICAoV2ViS2l0KToKKyAg ICAgICAgKFdlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50KToKKyAgICAgICAgKFdlYktpdDo6 V2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ6OldlYlRleHRGaWVsZERlY29yYXRpb25FbGVt ZW50KToKKyAgICAgICAgKFdlYktpdDo6V2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ6Om9w ZXJhdG9yPSk6CisgICAgICAgIChXZWJLaXQ6OldlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50 Ojphc3NpZ24pOgorICAgICAgICAqIHB1YmxpYy9XZWJJbnB1dEVsZW1lbnQuaDoKKyAgICAgICAg KFdlYktpdDo6V2ViSW5wdXRFbGVtZW50OjpkZWNvcmF0aW9uRWxlbWVudEZvcik6IFJldHVybnMg dGhlCisgICAgICAgIFdlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50IGF0dGFjaGVkIHRvIHRo ZSBXZWJJbnB1dEVsZW1lbnQgYnkgdGhlCisgICAgICAgIGdpdmVuIFdlYlRleHRGaWVsZERlY29y YXRvckNsaWVudCwgaWYgb25lIGV4aXN0cy4KKyAgICAgICAgKiBzcmMvVGV4dEZpZWxkRGVjb3Jh dG9ySW1wbC5jcHA6CisgICAgICAgIChXZWJLaXQpOgorICAgICAgICAqIHNyYy9UZXh0RmllbGRE ZWNvcmF0b3JJbXBsLmg6CisgICAgICAgIChUZXh0RmllbGREZWNvcmF0b3JJbXBsOjpkZWNvcmF0 b3JDbGllbnQpOiBHZXQgdGhlCisgICAgICAgIFdlYlRleHRGaWVsZERlY29yYXRvckNsaWVudCBv d25lZCBieSB0aGlzIG9iamVjdC4KKyAgICAgICAgKiBzcmMvV2ViVGV4dEZpZWxkRGVjb3JhdGlv bkVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViS2l0KToKKyAgICAgICAgKFdlYktpdDo6V2ViVGV4 dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ6OnNldFZpc2libGUpOgorICAgICAgICAoV2ViS2l0OjpX ZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudDo6V2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1l bnQpOgorICAgICAgICAoV2ViS2l0OjpXZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudDo6b3Bl cmF0b3I9KToKKyAgICAgICAgKFdlYktpdDo6V2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ6 Om9wZXJhdG9yIFBhc3NSZWZQdHI8U3R5bGVkRWxlbWVudD4pOgorCiAyMDEyLTA1LTExICBTaGVy aWZmIEJvdCAgPHdlYmtpdC5yZXZpZXcuYm90QGdtYWlsLmNvbT4KIAogICAgICAgICBVbnJldmll d2VkLCByb2xsaW5nIG91dCByMTE2ODAyLgpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRt bC9zaGFkb3cvVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuY3BwIGIvU291cmNlL1dlYkNvcmUv aHRtbC9zaGFkb3cvVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuY3BwCmluZGV4IDU4MGViYWRj YmRmYTRmN2NhZmNlNjY0MDEzMDI2MDAzYWRhZjYzZDQuLjNmOWM0YzZiZDgwYWMxMjI2ZTE1Yjhk YjQ4MDBhN2UyZTZiN2JiYzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93 L1RleHRGaWVsZERlY29yYXRpb25FbGVtZW50LmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1s L3NoYWRvdy9UZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudC5jcHAKQEAgLTY2LDYgKzY2LDE2IEBA IFBhc3NSZWZQdHI8VGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ+IFRleHRGaWVsZERlY29yYXRp b25FbGVtZW50OjpjcmVhdGUoRG9jdW1lCiAgICAgcmV0dXJuIGFkb3B0UmVmKG5ldyBUZXh0Rmll bGREZWNvcmF0aW9uRWxlbWVudChkb2N1bWVudCwgZGVjb3JhdG9yKSk7CiB9CiAKK1RleHRGaWVs ZERlY29yYXRpb25FbGVtZW50KiBUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudDo6ZnJvbVNoYWRv d1Jvb3QoU2hhZG93Um9vdCogc2hhZG93Um9vdCkKK3sKKyAgICBpZiAoIXNoYWRvd1Jvb3QtPmZp cnN0Q2hpbGQoKQorICAgICAgICB8fCAhc2hhZG93Um9vdC0+Zmlyc3RDaGlsZCgpLT5sYXN0Q2hp bGQoKQorICAgICAgICB8fCAhc2hhZG93Um9vdC0+Zmlyc3RDaGlsZCgpLT5sYXN0Q2hpbGQoKS0+ aXNFbGVtZW50Tm9kZSgpCisgICAgICAgIHx8ICF0b0VsZW1lbnQoc2hhZG93Um9vdC0+Zmlyc3RD aGlsZCgpLT5sYXN0Q2hpbGQoKSktPmlzVGV4dEZpZWxkRGVjb3JhdGlvbigpKQorICAgICAgICBy ZXR1cm4gMDsKKyAgICByZXR1cm4gdG9UZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudChzaGFkb3dS b290LT5maXJzdENoaWxkKCktPmxhc3RDaGlsZCgpKTsKK30KKwogc3RhdGljIGlubGluZSB2b2lk IGdldERlY29yYXRpb25Sb290QW5kRGVjb3JhdGVkUm9vdChIVE1MSW5wdXRFbGVtZW50KiBpbnB1 dCwgU2hhZG93Um9vdComIGRlY29yYXRpb25Sb290LCBTaGFkb3dSb290KiYgZGVjb3JhdGVkUm9v dCkKIHsKICAgICBTaGFkb3dSb290KiBleGlzdGluZ1Jvb3QgPSBpbnB1dC0+c2hhZG93KCktPnlv dW5nZXN0U2hhZG93Um9vdCgpOwpAQCAtOTUsNiArMTA1LDcgQEAgdm9pZCBUZXh0RmllbGREZWNv cmF0aW9uRWxlbWVudDo6ZGVjb3JhdGUoSFRNTElucHV0RWxlbWVudCogaW5wdXQpCiAgICAgZGVj b3JhdGlvblJvb3QtPmFwcGVuZENoaWxkKGJveCk7CiAgICAgYm94LT5zZXRJbmxpbmVTdHlsZVBy b3BlcnR5KENTU1Byb3BlcnR5RGlzcGxheSwgQ1NTVmFsdWVXZWJraXRCb3gpOwogICAgIGJveC0+ c2V0SW5saW5lU3R5bGVQcm9wZXJ0eShDU1NQcm9wZXJ0eVdlYmtpdEJveEFsaWduLCBDU1NWYWx1 ZUNlbnRlcik7CisgICAgYm94LT5zZXRJbmxpbmVTdHlsZVByb3BlcnR5KENTU1Byb3BlcnR5Vmlz aWJpbGl0eSwgQ1NTVmFsdWVIaWRkZW4pOwogICAgIEFTU0VSVChleGlzdGluZ1Jvb3QtPmNoaWxk Tm9kZUNvdW50KCkgPT0gMSk7CiAgICAgdG9IVE1MRWxlbWVudChleGlzdGluZ1Jvb3QtPmZpcnN0 Q2hpbGQoKSktPnNldElubGluZVN0eWxlUHJvcGVydHkoQ1NTUHJvcGVydHlXZWJraXRCb3hGbGV4 LCAxLjAsIENTU1ByaW1pdGl2ZVZhbHVlOjpDU1NfTlVNQkVSKTsKICAgICBib3gtPmFwcGVuZENo aWxkKEhUTUxTaGFkb3dFbGVtZW50OjpjcmVhdGUoSFRNTE5hbWVzOjpzaGFkb3dUYWcsIGlucHV0 LT5kb2N1bWVudCgpKSk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9U ZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudC5oIGIvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cv VGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuaAppbmRleCBiMzRlN2I1YWE5NmYzNGM3NzA3NzI5 OTU2OTcxYTIyNmVhZDcwMGM3Li44OTg2NzllNGViNDg1ZDQ1MWQyMTAwZTc4MWRhNzEwNzE5YTFm MTA3IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9UZXh0RmllbGREZWNv cmF0aW9uRWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1RleHRGaWVs ZERlY29yYXRpb25FbGVtZW50LmgKQEAgLTM3LDYgKzM3LDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogCiBjbGFzcyBDYWNoZWRJbWFnZTsKIGNsYXNzIEhUTUxJbnB1dEVsZW1lbnQ7CitjbGFzcyBT aGFkb3dSb290OwogCiAvLyBBIFRleHRGaWVsZERlY29yYXRvciBvYmplY3QgbXVzdCBsaXZlIHVu dGlsIGFsbCBvZiB0ZXh0IGZpZWxkcyB3aGljaCB3ZXJlCiAvLyBkZWNvcmF0ZWQgYnkgaXQgZGll LgpAQCAtNjUsNiArNjYsNyBAQCBwdWJsaWM6CiBjbGFzcyBUZXh0RmllbGREZWNvcmF0aW9uRWxl bWVudCA6IHB1YmxpYyBIVE1MRGl2RWxlbWVudCB7CiBwdWJsaWM6CiAgICAgc3RhdGljIFBhc3NS ZWZQdHI8VGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ+IGNyZWF0ZShEb2N1bWVudCosIFRleHRG aWVsZERlY29yYXRvciopOworICAgIHN0YXRpYyBUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudCog ZnJvbVNoYWRvd1Jvb3QoU2hhZG93Um9vdCopOwogICAgIFRleHRGaWVsZERlY29yYXRvciogdGV4 dEZpZWxkRGVjb3JhdG9yKCkgeyByZXR1cm4gbV90ZXh0RmllbGREZWNvcmF0b3I7IH0KICAgICB2 b2lkIGRlY29yYXRlKEhUTUxJbnB1dEVsZW1lbnQqKTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQu Z3lwCmluZGV4IGZkZGQ2OGQ0OTBhOTRlMTdkOWRhYTRjM2Y4ZDkwYmJhMWQyNTI5Y2UuLjNlYWMw MmQwM2I2YWQ4MGFjMGVlYTAyNDAwNjUyOGM3MjdmY2ZjNmYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dl YktpdC5neXAKQEAgLTI2OCw2ICsyNjgsNyBAQAogICAgICAgICAgICAgICAgICdwdWJsaWMvV2Vi VGV4dENoZWNraW5nQ29tcGxldGlvbi5oJywKICAgICAgICAgICAgICAgICAncHVibGljL1dlYlRl eHRDaGVja2luZ1Jlc3VsdC5oJywKICAgICAgICAgICAgICAgICAncHVibGljL1dlYlRleHREaXJl Y3Rpb24uaCcsCisgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJUZXh0RmllbGREZWNvcmF0aW9u RWxlbWVudC5oJywKICAgICAgICAgICAgICAgICAncHVibGljL1dlYlRleHRGaWVsZERlY29yYXRv ckNsaWVudC5oJywKICAgICAgICAgICAgICAgICAncHVibGljL1dlYlRleHRJbnB1dFR5cGUuaCcs CiAgICAgICAgICAgICAgICAgJ3B1YmxpYy9XZWJUZXh0UnVuLmgnLApAQCAtNjUxLDYgKzY1Miw3 IEBACiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJUZXh0UnVuLmNwcCcsCiAgICAgICAgICAgICAg ICAgJ3NyYy9XZWJVUkxMb2FkVGltaW5nLmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJT Y29wZWRVc2VyR2VzdHVyZS5jcHAnLAorICAgICAgICAgICAgICAgICdzcmMvV2ViVGV4dEZpZWxk RGVjb3JhdGlvbkVsZW1lbnQuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYlVzZXJNZWRp YVJlcXVlc3QuY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYlZpZGVvTGF5ZXIuY3BwJywK ICAgICAgICAgICAgICAgICAnc3JjL1dlYlZpZXdJbXBsLmNwcCcsCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJbnB1dEVsZW1lbnQuaCBiL1NvdXJjZS9XZWJL aXQvY2hyb21pdW0vcHVibGljL1dlYklucHV0RWxlbWVudC5oCmluZGV4IGIxYzQwN2M1OTQ5MGYw NzY4OTM3ZmM5MDBkNDJhNDc2ZWY0NjU0OTQuLjUxOGEyMDVhYzg1MzBlMDA2NDNjODYzMmE1NWY1 NDkzYjkwNzdhNTMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dl YklucHV0RWxlbWVudC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYklu cHV0RWxlbWVudC5oCkBAIC00MCw2ICs0MCw4IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsgY2xhc3Mg SFRNTElucHV0RWxlbWVudDsgfQogbmFtZXNwYWNlIFdlYktpdCB7CiAKICAgICBjbGFzcyBXZWJO b2RlQ29sbGVjdGlvbjsKKyAgICBjbGFzcyBXZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudDsK KyAgICBjbGFzcyBXZWJUZXh0RmllbGREZWNvcmF0b3JDbGllbnQ7CiAKICAgICAvLyBQcm92aWRl cyByZWFkb25seSBhY2Nlc3MgdG8gc29tZSBwcm9wZXJ0aWVzIG9mIGEgRE9NIGlucHV0IGVsZW1l bnQgbm9kZS4KICAgICBjbGFzcyBXZWJJbnB1dEVsZW1lbnQgOiBwdWJsaWMgV2ViRm9ybUNvbnRy b2xFbGVtZW50IHsKQEAgLTk3LDYgKzk5LDkgQEAgbmFtZXNwYWNlIFdlYktpdCB7CiAgICAgICAg IC8vIEV4cG9zZXMgdGhlIGRlZmF1bHQgdmFsdWUgb2YgdGhlIG1heExlbmd0aCBhdHRyaWJ1dGUu CiAgICAgICAgIFdFQktJVF9FWFBPUlQgc3RhdGljIGludCBkZWZhdWx0TWF4TGVuZ3RoKCk7CiAK KyAgICAgICAgLy8gUmV0dXJuIHRoZSBkZWNvcmF0aW9uIGFkZGVkIGJ5IHRoZSBzcGVjaWZpZWQg ZGVjb3JhdG9yIGlmIG9uZSBleGlzdHMuCisgICAgICAgIFdFQktJVF9FWFBPUlQgV2ViVGV4dEZp ZWxkRGVjb3JhdGlvbkVsZW1lbnQgZGVjb3JhdGlvbkVsZW1lbnRGb3IoV2ViVGV4dEZpZWxkRGVj b3JhdG9yQ2xpZW50Kik7CisKICNpZiBXRUJLSVRfSU1QTEVNRU5UQVRJT04KICAgICAgICAgV2Vi SW5wdXRFbGVtZW50KGNvbnN0IFdURjo6UGFzc1JlZlB0cjxXZWJDb3JlOjpIVE1MSW5wdXRFbGVt ZW50PiYpOwogICAgICAgICBXZWJJbnB1dEVsZW1lbnQmIG9wZXJhdG9yPShjb25zdCBXVEY6OlBh c3NSZWZQdHI8V2ViQ29yZTo6SFRNTElucHV0RWxlbWVudD4mKTsKZGlmZiAtLWdpdCBhL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50Lmgg Yi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJUZXh0RmllbGREZWNvcmF0aW9uRWxl bWVudC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAuLmViYWJlYmRkYzRiYjE0Yjg1MWZjOGE1MWM5N2FmMTEyNWU0YWNl NjcKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJU ZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudC5oCkBAIC0wLDAgKzEsNjYgQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRp dGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0 aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5h bWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJv bW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVj aWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICogIkFT IElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLAor ICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaWZuZGVmIFdlYlRl eHRGaWVsZERlY29yYXRpb25FbGVtZW50X2gKKyNkZWZpbmUgV2ViVGV4dEZpZWxkRGVjb3JhdGlv bkVsZW1lbnRfaAorCisjaW5jbHVkZSAiV2ViRWxlbWVudC5oIgorCisjaWYgV0VCS0lUX0lNUExF TUVOVEFUSU9OCituYW1lc3BhY2UgV2ViQ29yZSB7IGNsYXNzIFRleHRGaWVsZERlY29yYXRpb25F bGVtZW50OyB9CisjZW5kaWYKKworbmFtZXNwYWNlIFdlYktpdCB7CisKK2NsYXNzIFdlYlRleHRG aWVsZERlY29yYXRpb25FbGVtZW50IDogcHVibGljIFdlYkVsZW1lbnQgeworcHVibGljOgorICAg IFdlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50KCkgOiBXZWJFbGVtZW50KCkgeyB9CisgICAg V2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQoY29uc3QgV2ViVGV4dEZpZWxkRGVjb3JhdGlv bkVsZW1lbnQmIHNlKSA6IFdlYkVsZW1lbnQoc2UpIHsgfQorCisgICAgV2ViVGV4dEZpZWxkRGVj b3JhdGlvbkVsZW1lbnQmIG9wZXJhdG9yPShjb25zdCBXZWJUZXh0RmllbGREZWNvcmF0aW9uRWxl bWVudCYgc2UpCisgICAgeworICAgICAgICBXZWJFbGVtZW50Ojphc3NpZ24oc2UpOworICAgICAg ICByZXR1cm4gKnRoaXM7CisgICAgfQorICAgIHZvaWQgYXNzaWduKGNvbnN0IFdlYlRleHRGaWVs ZERlY29yYXRpb25FbGVtZW50JiBzZSkgeyBXZWJFbGVtZW50Ojphc3NpZ24oc2UpOyB9CisKKyAg ICAvLyBNYWtlIHZpc2libGUgaWZmIHRydWUuCisgICAgV0VCS0lUX0VYUE9SVCB2b2lkIHNldFZp c2libGUoYm9vbCk7CisKKyNpZiBXRUJLSVRfSU1QTEVNRU5UQVRJT04KKyAgICBXZWJUZXh0Rmll bGREZWNvcmF0aW9uRWxlbWVudChjb25zdCBXVEY6OlBhc3NSZWZQdHI8V2ViQ29yZTo6VGV4dEZp ZWxkRGVjb3JhdGlvbkVsZW1lbnQ+Jik7CisgICAgV2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1l bnQmIG9wZXJhdG9yPShjb25zdCBXVEY6OlBhc3NSZWZQdHI8V2ViQ29yZTo6VGV4dEZpZWxkRGVj b3JhdGlvbkVsZW1lbnQ+Jik7CisgICAgb3BlcmF0b3IgV1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6 OlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50PigpIGNvbnN0OworI2VuZGlmCit9OworCit9IC8v IG5hbWVzcGFjZSBXZWJLaXQKKworI2VuZGlmCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2No cm9taXVtL3NyYy9UZXh0RmllbGREZWNvcmF0b3JJbXBsLmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL1RleHRGaWVsZERlY29yYXRvckltcGwuY3BwCmluZGV4IGU1OGMwMjJlZWI0NjY3 YTJjZDY3MWNhZWM5N2Y1NzcyOWZiYjI1YzYuLjkzYTJhODliMWE2NTU0NjE0NjkwZDA2MTg1MzQx Nzc5MWQ1MGJjNmMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1RleHRG aWVsZERlY29yYXRvckltcGwuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1Rl eHRGaWVsZERlY29yYXRvckltcGwuY3BwCkBAIC01Niw2ICs1NiwxMiBAQCBUZXh0RmllbGREZWNv cmF0b3JJbXBsOjp+VGV4dEZpZWxkRGVjb3JhdG9ySW1wbCgpCiB7CiB9CiAKK1dlYlRleHRGaWVs ZERlY29yYXRvckNsaWVudCogVGV4dEZpZWxkRGVjb3JhdG9ySW1wbDo6ZGVjb3JhdG9yQ2xpZW50 KCkKK3sKKyAgICByZXR1cm4gbV9jbGllbnQ7Cit9CisKKwogYm9vbCBUZXh0RmllbGREZWNvcmF0 b3JJbXBsOjp3aWxsQWRkRGVjb3JhdGlvblRvKEhUTUxJbnB1dEVsZW1lbnQqIGlucHV0KQogewog ICAgIEFTU0VSVChpbnB1dCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Ny Yy9UZXh0RmllbGREZWNvcmF0b3JJbXBsLmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9U ZXh0RmllbGREZWNvcmF0b3JJbXBsLmgKaW5kZXggNjY3NDc1MjgyZjViZTM5NWFkMTEyYWI1ODg1 MTAzYTBhNzFlNzk5Yi4uMzE1YzJmMjIyYWVjZjczZGNmYzgyOTg4NjVmZTRjZTYzMmNjNjA5NyAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVGV4dEZpZWxkRGVjb3JhdG9y SW1wbC5oCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1RleHRGaWVsZERlY29yYXRv ckltcGwuaApAQCAtNDMsNiArNDMsOCBAQCBwdWJsaWM6CiAgICAgc3RhdGljIFBhc3NPd25QdHI8 VGV4dEZpZWxkRGVjb3JhdG9ySW1wbD4gY3JlYXRlKFdlYlRleHRGaWVsZERlY29yYXRvckNsaWVu dCopOwogICAgIHZpcnR1YWwgflRleHRGaWVsZERlY29yYXRvckltcGwoKTsKIAorICAgIFdlYlRl eHRGaWVsZERlY29yYXRvckNsaWVudCogZGVjb3JhdG9yQ2xpZW50KCk7CisKIHByaXZhdGU6CiAg ICAgdmlydHVhbCBib29sIHdpbGxBZGREZWNvcmF0aW9uVG8oV2ViQ29yZTo6SFRNTElucHV0RWxl bWVudCopIE9WRVJSSURFOwogICAgIHZpcnR1YWwgV2ViQ29yZTo6Q2FjaGVkSW1hZ2UqIGltYWdl Rm9yTm9ybWFsU3RhdGUoKSBPVkVSUklERTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hy b21pdW0vc3JjL1dlYklucHV0RWxlbWVudC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Ny Yy9XZWJJbnB1dEVsZW1lbnQuY3BwCmluZGV4IGMwMDM3YTBlZjBiMjBlZWEzMDU3YzQwZDExMmE3 NTIzOWJmN2RmODguLmEzYmM1MGU2MjBkZmQyZjZkZTkxMGMxMmNlM2M1M2JlMjE4YjVjYzUgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklucHV0RWxlbWVudC5jcHAK KysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViSW5wdXRFbGVtZW50LmNwcApAQCAt MzEsMTEgKzMxLDE2IEBACiAjaW5jbHVkZSAiY29uZmlnLmgiCiAjaW5jbHVkZSAiV2ViSW5wdXRF bGVtZW50LmgiCiAKKyNpbmNsdWRlICJFbGVtZW50U2hhZG93LmgiCiAjaW5jbHVkZSAiSFRNTERh dGFMaXN0RWxlbWVudC5oIgogI2luY2x1ZGUgIkhUTUxJbnB1dEVsZW1lbnQuaCIKICNpbmNsdWRl ICJIVE1MTmFtZXMuaCIKKyNpbmNsdWRlICJTaGFkb3dSb290LmgiCiAjaW5jbHVkZSAiVGV4dENv bnRyb2xJbm5lckVsZW1lbnRzLmgiCisjaW5jbHVkZSAiVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1l bnQuaCIKKyNpbmNsdWRlICJUZXh0RmllbGREZWNvcmF0b3JJbXBsLmgiCiAjaW5jbHVkZSAiV2Vi Tm9kZUNvbGxlY3Rpb24uaCIKKyNpbmNsdWRlICJXZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVu dC5oIgogI2luY2x1ZGUgInBsYXRmb3JtL1dlYlN0cmluZy5oIgogI2luY2x1ZGUgPHd0Zi9QYXNz UmVmUHRyLmg+CiAKQEAgLTIxMSw2ICsyMTYsMjAgQEAgaW50IFdlYklucHV0RWxlbWVudDo6ZGVm YXVsdE1heExlbmd0aCgpCiAgICAgcmV0dXJuIEhUTUxJbnB1dEVsZW1lbnQ6Om1heGltdW1MZW5n dGg7CiB9CiAKK1dlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50IFdlYklucHV0RWxlbWVudDo6 ZGVjb3JhdGlvbkVsZW1lbnRGb3IoV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50KiBkZWNvcmF0 b3JDbGllbnQpCit7CisgICAgU2hhZG93Um9vdCogc2hhZG93Um9vdCA9IHVud3JhcDxIVE1MSW5w dXRFbGVtZW50PigpLT5zaGFkb3coKS0+eW91bmdlc3RTaGFkb3dSb290KCk7CisgICAgd2hpbGUg KHNoYWRvd1Jvb3QpIHsKKyAgICAgICAgVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQqIGRlY29y YXRpb24gPSBUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudDo6ZnJvbVNoYWRvd1Jvb3Qoc2hhZG93 Um9vdCk7CisgICAgICAgIGlmIChkZWNvcmF0aW9uCisgICAgICAgICAgICAmJiBzdGF0aWNfY2Fz dDxUZXh0RmllbGREZWNvcmF0b3JJbXBsKj4oZGVjb3JhdGlvbi0+dGV4dEZpZWxkRGVjb3JhdG9y KCkpLT5kZWNvcmF0b3JDbGllbnQoKSA9PSBkZWNvcmF0b3JDbGllbnQpIHsKKyAgICAgICAgICAg IHJldHVybiBXZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudChkZWNvcmF0aW9uKTsKKyAgICAg ICAgfQorICAgICAgICBzaGFkb3dSb290LT5vbGRlclNoYWRvd1Jvb3QoKTsKKyAgICB9CisgICAg cmV0dXJuIFdlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50KCk7Cit9CisKIFdlYklucHV0RWxl bWVudDo6V2ViSW5wdXRFbGVtZW50KGNvbnN0IFBhc3NSZWZQdHI8SFRNTElucHV0RWxlbWVudD4m IGVsZW0pCiAgICAgOiBXZWJGb3JtQ29udHJvbEVsZW1lbnQoZWxlbSkKIHsKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50 LmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlRleHRGaWVsZERlY29yYXRpb25F bGVtZW50LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwLi45NDhlY2I4NzQ1ZTg0ZjQwZjY4NzAwYjI4MTkxNDYwNmFl ZmE1ZWRjCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2Vi VGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuY3BwCkBAIC0wLDAgKzEsNjkgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAgICAgKiBSZWRp c3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdo dAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3Qg cmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhlIGRvY3VtZW50 YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQorICogZGlzdHJp YnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5jLiBub3IgdGhl IG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3Ig cHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUgd2l0aG91dCBz cGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJVVE9SUworICog IkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcs IEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hB TlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJ U0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9XTkVSIE9SIENP TlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFM LAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xV RElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBH T09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBC VVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkKKyAqIFRIRU9S WSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9S IFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4g QU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJ U0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAi Y29uZmlnLmgiCisjaW5jbHVkZSAiV2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuaCIKKwor I2luY2x1ZGUgIkNTU1Byb3BlcnR5TmFtZXMuaCIKKyNpbmNsdWRlICJDU1NWYWx1ZUtleXdvcmRz LmgiCisjaW5jbHVkZSAiVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuaCIKKyNpbmNsdWRlIDx3 dGYvUGFzc1JlZlB0ci5oPgorCit1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKKworbmFtZXNwYWNl IFdlYktpdCB7CisKK3ZvaWQgV2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ6OnNldFZpc2li bGUoYm9vbCB2aXNpYmxlKQoreworICAgIGlmICh2aXNpYmxlKQorICAgICAgICB1bndyYXA8VGV4 dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ+KCktPnNldElubGluZVN0eWxlUHJvcGVydHkoQ1NTUHJv cGVydHlWaXNpYmlsaXR5LAorICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgQ1NTVmFsdWVWaXNpYmxlKTsKKyAgICBlbHNl CisgICAgICAgIHVud3JhcDxUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudD4oKS0+c2V0SW5saW5l U3R5bGVQcm9wZXJ0eShDU1NQcm9wZXJ0eVZpc2liaWxpdHksCisgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICBDU1NWYWx1 ZUhpZGRlbik7Cit9CisKK1dlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50OjpXZWJUZXh0Rmll bGREZWNvcmF0aW9uRWxlbWVudChjb25zdCBQYXNzUmVmUHRyPFRleHRGaWVsZERlY29yYXRpb25F bGVtZW50PiYgZWxlbSkKKyAgICA6IFdlYkVsZW1lbnQoZWxlbSkKK3sKK30KKworV2ViVGV4dEZp ZWxkRGVjb3JhdGlvbkVsZW1lbnQmIFdlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50OjpvcGVy YXRvcj0oY29uc3QgUGFzc1JlZlB0cjxUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudD4mIGVsZW0p Cit7CisgICAgbV9wcml2YXRlID0gZWxlbTsKKyAgICByZXR1cm4gKnRoaXM7Cit9CisKK1dlYlRl eHRGaWVsZERlY29yYXRpb25FbGVtZW50OjpvcGVyYXRvciBQYXNzUmVmUHRyPFRleHRGaWVsZERl Y29yYXRpb25FbGVtZW50PigpIGNvbnN0Cit7CisgICAgcmV0dXJuIHN0YXRpY19jYXN0PFRleHRG aWVsZERlY29yYXRpb25FbGVtZW50Kj4obV9wcml2YXRlLmdldCgpKTsKK30KKworfSAvLyBuYW1l c3BhY2UgV2ViS2l0Cg== 143861 2012-05-24 11:34:44 -0700 2012-05-25 11:48:32 -0700 Patch bug-86557-20120524113443.patch text/plain 22445 gcasto U3VidmVyc2lvbiBSZXZpc2lvbjogMTE3ODA4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNWZhNGY1NGNiMTc0MjQ4 ZTA4NWViNGViZjFlMDExYWI0ZjJiMWZiMS4uZGI2M2Q3ZDgxZTRlMTBlNzgzNDkxMDFkYzJmY2Nk MWZhZWY2NDkxYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDEyLTA1LTE1ICBHYXJy ZXR0IENhc3RvICA8Z2Nhc3RvQGNocm9taXVtLm9yZz4KKworICAgICAgICBBbGxvdyBXZWJUZXh0 RmllbGREZWNvcmF0b3JDbGllbnQgdG8gc2VlIGFwcGxpZWQgZGVjb3JhdGlvbnMuCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NjU1NworCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogaHRtbC9zaGFkb3cvVGV4 dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEZpZWxk RGVjb3JhdGlvbkVsZW1lbnQ6OmZyb21TaGFkb3dSb290KTogQSBmdW5jdGlvbgorICAgICAgICB0 aGF0IHdpbGwgZXh0cmFjdCBhIFRleHRGaWVsRGVjb3JhdGlvbkVsZW1lbnQgZnJvbSBhIFNoYWRv d1Jvb3QsIGlmCisgICAgICAgIHRoZXJlIGlzIG9uZS4KKyAgICAgICAgKiBodG1sL3NoYWRvdy9U ZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAg IChUZXh0RmllbGREZWNvcmF0b3IpOgorCiAyMDEyLTA1LTIxICBKb3NodWEgQmVsbCAgPGpzYmVs bEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgSW5kZXhlZERCOiBJbmRleCBrZXkgcGF0aHMgdGhh dCB5aWVsZCBpbnZhbGlkIGtleXMgc2hvdWxkIG5vdCBmYWlsIGFuIGFkZC9wdXQKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cKaW5kZXggOTQ5YjRlNWU0YzczZTlkNzczYWYwMmY4ZDY1M2Y2YjkxNWRh YTAxMy4uMzNiNTkzNDIxMDI1MmU1YTJiZDQwNmU4NThkYjVkYTQzODQxZWU3ZCAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzNSBAQAorMjAxMi0wNS0xNSAgR2FycmV0dCBD YXN0byAgPGdjYXN0b0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWxsb3cgV2ViVGV4dEZpZWxk RGVjb3JhdG9yQ2xpZW50IHRvIHNlZSBhcHBsaWVkIGRlY29yYXRpb25zLgorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODY1NTcKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFdlYktpdC5neXA6IEFkZGVkIG5l dyBmaWxlcy4KKyAgICAgICAgKiBwdWJsaWMvV2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQu aDogQnJpZGdlIHRvCisgICAgICAgIFRleHRGaWVsZERlY29yYXRpb25FbGVtZW50LiBDdXJyZW50 bHkgYWxsb3dzIGNoYW5naW5nIHRoZSBDU1MKKyAgICAgICAgdmlzaWJpbGl0eSBvZiBhIGRlY29y YXRpb24gZWxlbWVudC4KKyAgICAgICAgKFdlYktpdCk6CisgICAgICAgIChXZWJUZXh0RmllbGRE ZWNvcmF0aW9uRWxlbWVudCk6CisgICAgICAgIChXZWJLaXQ6OldlYlRleHRGaWVsZERlY29yYXRp b25FbGVtZW50OjpXZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudCk6CisgICAgICAgIChXZWJL aXQ6OldlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50OjpvcGVyYXRvcj0pOgorICAgICAgICAo V2ViS2l0OjpXZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudDo6YXNzaWduKToKKyAgICAgICAg KiBwdWJsaWMvV2ViSW5wdXRFbGVtZW50Lmg6CisgICAgICAgIChXZWJLaXQ6OldlYklucHV0RWxl bWVudDo6ZGVjb3JhdGlvbkVsZW1lbnRGb3IpOiBSZXR1cm5zIHRoZQorICAgICAgICBXZWJUZXh0 RmllbGREZWNvcmF0aW9uRWxlbWVudCBhdHRhY2hlZCB0byB0aGUgV2ViSW5wdXRFbGVtZW50IGJ5 IHRoZQorICAgICAgICBnaXZlbiBXZWJUZXh0RmllbGREZWNvcmF0b3JDbGllbnQsIGlmIG9uZSBl eGlzdHMuCisgICAgICAgICogc3JjL1RleHRGaWVsZERlY29yYXRvckltcGwuY3BwOgorICAgICAg ICAoV2ViS2l0KToKKyAgICAgICAgKiBzcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5oOgorICAg ICAgICAoVGV4dEZpZWxkRGVjb3JhdG9ySW1wbDo6ZGVjb3JhdG9yQ2xpZW50KTogR2V0IHRoZQor ICAgICAgICBXZWJUZXh0RmllbGREZWNvcmF0b3JDbGllbnQgb3duZWQgYnkgdGhpcyBvYmplY3Qu CisgICAgICAgICogc3JjL1dlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50LmNwcDoKKyAgICAg ICAgKFdlYktpdCk6CisgICAgICAgIChXZWJLaXQ6OldlYlRleHRGaWVsZERlY29yYXRpb25FbGVt ZW50OjpzZXRWaXNpYmxlKToKKyAgICAgICAgKFdlYktpdDo6V2ViVGV4dEZpZWxkRGVjb3JhdGlv bkVsZW1lbnQ6OldlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50KToKKyAgICAgICAgKFdlYktp dDo6V2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ6Om9wZXJhdG9yPSk6CisgICAgICAgIChX ZWJLaXQ6OldlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50OjpvcGVyYXRvciBQYXNzUmVmUHRy PFN0eWxlZEVsZW1lbnQ+KToKKwogMjAxMi0wNS0xOCAgTWljaGFlbCBOb3JkbWFuICA8bWljaGFl bG5AZ29vZ2xlLmNvbT4KIAogICAgICAgICBbY2hyb21pdW1dIERvbVN0b3JhZ2UgZXZlbnRzIGhh bmRsaW5nIG5lZWRzIFRMQyAoMikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hh ZG93L1RleHRGaWVsZERlY29yYXRpb25FbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwv c2hhZG93L1RleHRGaWVsZERlY29yYXRpb25FbGVtZW50LmNwcAppbmRleCAwZjdhZjM4ODBkODkx ZDMyODRkMjk4ZDI4NGIyODNlYmM0ZGRkMzIzLi4zZjVkZmZjZGVhYWE5ZTM4ZjdiMWU3YzMzYWQx OWEwMDhmNGZiYjQ0IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9UZXh0 RmllbGREZWNvcmF0aW9uRWxlbWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFk b3cvVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuY3BwCkBAIC02Niw2ICs2NiwxNiBAQCBQYXNz UmVmUHRyPFRleHRGaWVsZERlY29yYXRpb25FbGVtZW50PiBUZXh0RmllbGREZWNvcmF0aW9uRWxl bWVudDo6Y3JlYXRlKERvY3VtZQogICAgIHJldHVybiBhZG9wdFJlZihuZXcgVGV4dEZpZWxkRGVj b3JhdGlvbkVsZW1lbnQoZG9jdW1lbnQsIGRlY29yYXRvcikpOwogfQogCitUZXh0RmllbGREZWNv cmF0aW9uRWxlbWVudCogVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ6OmZyb21TaGFkb3dSb290 KFNoYWRvd1Jvb3QqIHNoYWRvd1Jvb3QpCit7CisgICAgaWYgKCFzaGFkb3dSb290LT5maXJzdENo aWxkKCkKKyAgICAgICAgfHwgIXNoYWRvd1Jvb3QtPmZpcnN0Q2hpbGQoKS0+bGFzdENoaWxkKCkK KyAgICAgICAgfHwgIXNoYWRvd1Jvb3QtPmZpcnN0Q2hpbGQoKS0+bGFzdENoaWxkKCktPmlzRWxl bWVudE5vZGUoKQorICAgICAgICB8fCAhdG9FbGVtZW50KHNoYWRvd1Jvb3QtPmZpcnN0Q2hpbGQo KS0+bGFzdENoaWxkKCkpLT5pc1RleHRGaWVsZERlY29yYXRpb24oKSkKKyAgICAgICAgcmV0dXJu IDA7CisgICAgcmV0dXJuIHRvVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQoc2hhZG93Um9vdC0+ Zmlyc3RDaGlsZCgpLT5sYXN0Q2hpbGQoKSk7Cit9CisKIHN0YXRpYyBpbmxpbmUgdm9pZCBnZXRE ZWNvcmF0aW9uUm9vdEFuZERlY29yYXRlZFJvb3QoSFRNTElucHV0RWxlbWVudCogaW5wdXQsIFNo YWRvd1Jvb3QqJiBkZWNvcmF0aW9uUm9vdCwgU2hhZG93Um9vdComIGRlY29yYXRlZFJvb3QpCiB7 CiAgICAgU2hhZG93Um9vdCogZXhpc3RpbmdSb290ID0gaW5wdXQtPnlvdW5nZXN0U2hhZG93Um9v dCgpOwpAQCAtODMsNyArOTMsNyBAQCBzdGF0aWMgaW5saW5lIHZvaWQgZ2V0RGVjb3JhdGlvblJv b3RBbmREZWNvcmF0ZWRSb290KEhUTUxJbnB1dEVsZW1lbnQqIGlucHV0LCBTaAogICAgIGRlY29y YXRlZFJvb3QgPSBleGlzdGluZ1Jvb3Q7CiB9CiAKLXZvaWQgVGV4dEZpZWxkRGVjb3JhdGlvbkVs ZW1lbnQ6OmRlY29yYXRlKEhUTUxJbnB1dEVsZW1lbnQqIGlucHV0KQordm9pZCBUZXh0RmllbGRE ZWNvcmF0aW9uRWxlbWVudDo6ZGVjb3JhdGUoSFRNTElucHV0RWxlbWVudCogaW5wdXQsIGJvb2wg dmlzaWJsZSkKIHsKICAgICBBU1NFUlQoaW5wdXQpOwogICAgIFNoYWRvd1Jvb3QqIGV4aXN0aW5n Um9vdDsKQEAgLTEwMSw2ICsxMTEsMTEgQEAgdm9pZCBUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVu dDo6ZGVjb3JhdGUoSFRNTElucHV0RWxlbWVudCogaW5wdXQpCiAKICAgICBzZXRJbmxpbmVTdHls ZVByb3BlcnR5KENTU1Byb3BlcnR5V2Via2l0Qm94RmxleCwgMC4wLCBDU1NQcmltaXRpdmVWYWx1 ZTo6Q1NTX05VTUJFUik7CiAgICAgYm94LT5hcHBlbmRDaGlsZCh0aGlzKTsKKworICAgIGlmICh2 aXNpYmxlKQorICAgICAgICBzZXRJbmxpbmVTdHlsZVByb3BlcnR5KENTU1Byb3BlcnR5RGlzcGxh eSwgQ1NTVmFsdWVCbG9jayk7CisgICAgZWxzZQorICAgICAgICBzZXRJbmxpbmVTdHlsZVByb3Bl cnR5KENTU1Byb3BlcnR5RGlzcGxheSwgQ1NTVmFsdWVOb25lKTsKIH0KIAogaW5saW5lIEhUTUxJ bnB1dEVsZW1lbnQqIFRleHRGaWVsZERlY29yYXRpb25FbGVtZW50Ojpob3N0SW5wdXQoKQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dEZpZWxkRGVjb3JhdGlvbkVs ZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1RleHRGaWVsZERlY29yYXRpb25F bGVtZW50LmgKaW5kZXggYjM0ZTdiNWFhOTZmMzRjNzcwNzcyOTk1Njk3MWEyMjZlYWQ3MDBjNy4u ZjJjODI3YTQ1MDFmMzRmOWIwYWRjMjdiMzFkZWZmODBiNzdmMjYyNSAxMDA2NDQKLS0tIGEvU291 cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuaAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9UZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudC5o CkBAIC0zNyw2ICszNyw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQ2FjaGVkSW1h Z2U7CiBjbGFzcyBIVE1MSW5wdXRFbGVtZW50OworY2xhc3MgU2hhZG93Um9vdDsKIAogLy8gQSBU ZXh0RmllbGREZWNvcmF0b3Igb2JqZWN0IG11c3QgbGl2ZSB1bnRpbCBhbGwgb2YgdGV4dCBmaWVs ZHMgd2hpY2ggd2VyZQogLy8gZGVjb3JhdGVkIGJ5IGl0IGRpZS4KQEAgLTQ1LDYgKzQ2LDcgQEAg cHVibGljOgogICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0aGlzIFRleHRGaWVsZERlY29yYXRvciB3 YW50cyB0byBhZGQgYQogICAgIC8vIGRlY29yYXRpb24gdG8gdGhlIHNwZWNpZmllZCB0ZXh0IGZp ZWxkLgogICAgIHZpcnR1YWwgYm9vbCB3aWxsQWRkRGVjb3JhdGlvblRvKEhUTUxJbnB1dEVsZW1l bnQqKSA9IDA7CisgICAgdmlydHVhbCBib29sIHZpc2libGVCeURlZmF1bHQoKSA9IDA7CiAKICAg ICAvLyBBIFRleHRGaWVsZERlY29yYXRvciBvYmplY3Qgc2hvdWxkIG93biB0aGUgQ2FjaGVkSW1h Z2Ugb2JqZWN0cy4KICAgICB2aXJ0dWFsIENhY2hlZEltYWdlKiBpbWFnZUZvck5vcm1hbFN0YXRl KCkgPSAwOwpAQCAtNjUsOCArNjcsOSBAQCBwdWJsaWM6CiBjbGFzcyBUZXh0RmllbGREZWNvcmF0 aW9uRWxlbWVudCA6IHB1YmxpYyBIVE1MRGl2RWxlbWVudCB7CiBwdWJsaWM6CiAgICAgc3RhdGlj IFBhc3NSZWZQdHI8VGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ+IGNyZWF0ZShEb2N1bWVudCos IFRleHRGaWVsZERlY29yYXRvciopOworICAgIHN0YXRpYyBUZXh0RmllbGREZWNvcmF0aW9uRWxl bWVudCogZnJvbVNoYWRvd1Jvb3QoU2hhZG93Um9vdCopOwogICAgIFRleHRGaWVsZERlY29yYXRv ciogdGV4dEZpZWxkRGVjb3JhdG9yKCkgeyByZXR1cm4gbV90ZXh0RmllbGREZWNvcmF0b3I7IH0K LSAgICB2b2lkIGRlY29yYXRlKEhUTUxJbnB1dEVsZW1lbnQqKTsKKyAgICB2b2lkIGRlY29yYXRl KEhUTUxJbnB1dEVsZW1lbnQqLCBib29sIHZpc2libGUpOwogCiBwcml2YXRlOgogICAgIFRleHRG aWVsZERlY29yYXRpb25FbGVtZW50KERvY3VtZW50KiwgVGV4dEZpZWxkRGVjb3JhdG9yKik7CmRp ZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAgYi9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL1dlYktpdC5neXAKaW5kZXggOWVhMDQ0ODZjNTJlZjQ1MmJkNGJhMGU1ZTFh YmE1ODlmNmRlZWRhMy4uNTZmMWIxNGYxMzkwZWIzOTkzZDNjMzJlYjI5ZjBjM2JkMjA2YzVlZSAx MDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCisrKyBiL1NvdXJj ZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cApAQCAtMjcxLDYgKzI3MSw3IEBACiAgICAgICAg ICAgICAgICAgJ3B1YmxpYy9XZWJUZXh0Q2hlY2tpbmdDb21wbGV0aW9uLmgnLAogICAgICAgICAg ICAgICAgICdwdWJsaWMvV2ViVGV4dENoZWNraW5nUmVzdWx0LmgnLAogICAgICAgICAgICAgICAg ICdwdWJsaWMvV2ViVGV4dERpcmVjdGlvbi5oJywKKyAgICAgICAgICAgICAgICAncHVibGljL1dl YlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50LmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMv V2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50LmgnLAogICAgICAgICAgICAgICAgICdwdWJsaWMv V2ViVGV4dElucHV0SW5mby5oJywKICAgICAgICAgICAgICAgICAncHVibGljL1dlYlRleHRJbnB1 dFR5cGUuaCcsCkBAIC02NjAsNiArNjYxLDggQEAKICAgICAgICAgICAgICAgICAnc3JjL1dlYlRl eHRSdW4uY3BwJywKICAgICAgICAgICAgICAgICAnc3JjL1dlYlVSTExvYWRUaW1pbmcuY3BwJywK ICAgICAgICAgICAgICAgICAnc3JjL1dlYlNjb3BlZFVzZXJHZXN0dXJlLmNwcCcsCisgICAgICAg ICAgICAgICAgJ3NyYy9XZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudC5jcHAnLAorICAgICAg ICAgICAgICAgICdzcmMvV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50LmNwcCcsCiAgICAgICAg ICAgICAgICAgJ3NyYy9XZWJVc2VyTWVkaWFSZXF1ZXN0LmNwcCcsCiAgICAgICAgICAgICAgICAg J3NyYy9XZWJWaWRlb0xheWVyLmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJWaWV3SW1w bC5jcHAnLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9wdWJsaWMvV2ViSW5w dXRFbGVtZW50LmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJbnB1dEVsZW1l bnQuaAppbmRleCAyM2U4NWFhNzMxMTEwOTk3M2ExMzkwYmY4MDdmY2I1YThhYzE5YmJiLi5kNWI4 MzJjYmM5ZjFlZWZmM2ZlN2MyNDI2YjJiYzAwOTdmMjY1OGVmIDEwMDY0NAotLS0gYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJbnB1dEVsZW1lbnQuaAorKysgYi9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJbnB1dEVsZW1lbnQuaApAQCAtNDAsNiArNDAsOCBAQCBu YW1lc3BhY2UgV2ViQ29yZSB7IGNsYXNzIEhUTUxJbnB1dEVsZW1lbnQ7IH0KIG5hbWVzcGFjZSBX ZWJLaXQgewogCiAgICAgY2xhc3MgV2ViTm9kZUNvbGxlY3Rpb247CisgICAgY2xhc3MgV2ViVGV4 dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ7CisgICAgY2xhc3MgV2ViVGV4dEZpZWxkRGVjb3JhdG9y Q2xpZW50OwogCiAgICAgLy8gUHJvdmlkZXMgcmVhZG9ubHkgYWNjZXNzIHRvIHNvbWUgcHJvcGVy dGllcyBvZiBhIERPTSBpbnB1dCBlbGVtZW50IG5vZGUuCiAgICAgY2xhc3MgV2ViSW5wdXRFbGVt ZW50IDogcHVibGljIFdlYkZvcm1Db250cm9sRWxlbWVudCB7CkBAIC0xMDMsNiArMTA1LDkgQEAg bmFtZXNwYWNlIFdlYktpdCB7CiAgICAgICAgIC8vIEV4cG9zZXMgdGhlIGRlZmF1bHQgdmFsdWUg b2YgdGhlIG1heExlbmd0aCBhdHRyaWJ1dGUuCiAgICAgICAgIFdFQktJVF9FWFBPUlQgc3RhdGlj IGludCBkZWZhdWx0TWF4TGVuZ3RoKCk7CiAKKyAgICAgICAgLy8gUmV0dXJuIHRoZSBkZWNvcmF0 aW9uIGFkZGVkIGJ5IHRoZSBzcGVjaWZpZWQgZGVjb3JhdG9yIGlmIG9uZSBleGlzdHMuCisgICAg ICAgIFdFQktJVF9FWFBPUlQgV2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQgZGVjb3JhdGlv bkVsZW1lbnRGb3IoV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50Kik7CisKICNpZiBXRUJLSVRf SU1QTEVNRU5UQVRJT04KICAgICAgICAgV2ViSW5wdXRFbGVtZW50KGNvbnN0IFdURjo6UGFzc1Jl ZlB0cjxXZWJDb3JlOjpIVE1MSW5wdXRFbGVtZW50PiYpOwogICAgICAgICBXZWJJbnB1dEVsZW1l bnQmIG9wZXJhdG9yPShjb25zdCBXVEY6OlBhc3NSZWZQdHI8V2ViQ29yZTo6SFRNTElucHV0RWxl bWVudD4mKTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vcHVibGljL1dlYlRl eHRGaWVsZERlY29yYXRpb25FbGVtZW50LmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1Ymxp Yy9XZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjI4ZmQwZGUyMTk3 NTE1MGU5M2JlMmIxNWY0N2RjZThjZDVjZjNiNGYKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudC5oCkBA IC0wLDAgKzEsNjUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAq IG1ldDoKKyAqCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRp b25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0 IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lcgorICogaW4gdGhlIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92 aWRlZCB3aXRoIHRoZQorICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFt ZSBvZiBHb29nbGUgSW5jLiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1h eSBiZSB1c2VkIHRvIGVuZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAq IHRoaXMgc29mdHdhcmUgd2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24u CisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERF UlMgQU5EIENPTlRSSUJVVE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElF RCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBM SUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQ QVJUSUNVTEFSIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBD T1BZUklHSFQKKyAqIE9XTkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJF Q1QsIElORElSRUNULCBJTkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05T RVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJP Q1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisg KiBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FV U0VEIEFORCBPTiBBTlkKKyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJB Q1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBP UiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJ UyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB TUFHRS4KKyAqLworCisjaWZuZGVmIFdlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50X2gKKyNk ZWZpbmUgV2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnRfaAorCisjaW5jbHVkZSAiV2ViRWxl bWVudC5oIgorCisjaWYgV0VCS0lUX0lNUExFTUVOVEFUSU9OCituYW1lc3BhY2UgV2ViQ29yZSB7 IGNsYXNzIFRleHRGaWVsZERlY29yYXRpb25FbGVtZW50OyB9CisjZW5kaWYKKworbmFtZXNwYWNl IFdlYktpdCB7CisKK2NsYXNzIFdlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50IDogcHVibGlj IFdlYkVsZW1lbnQgeworcHVibGljOgorICAgIFdlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50 KCkgOiBXZWJFbGVtZW50KCkgeyB9CisgICAgV2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQo Y29uc3QgV2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQmIHNlKSA6IFdlYkVsZW1lbnQoc2Up IHsgfQorCisgICAgV2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQmIG9wZXJhdG9yPShjb25z dCBXZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudCYgc2UpCisgICAgeworICAgICAgICBXZWJF bGVtZW50Ojphc3NpZ24oc2UpOworICAgICAgICByZXR1cm4gKnRoaXM7CisgICAgfQorICAgIHZv aWQgYXNzaWduKGNvbnN0IFdlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50JiBzZSkgeyBXZWJF bGVtZW50Ojphc3NpZ24oc2UpOyB9CisKKyAgICBXRUJLSVRfRVhQT1JUIHZvaWQgc2V0VmlzaWJs ZShib29sKTsKKworI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorICAgIFdlYlRleHRGaWVsZERl Y29yYXRpb25FbGVtZW50KGNvbnN0IFdURjo6UGFzc1JlZlB0cjxXZWJDb3JlOjpUZXh0RmllbGRE ZWNvcmF0aW9uRWxlbWVudD4mKTsKKyAgICBXZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudCYg b3BlcmF0b3I9KGNvbnN0IFdURjo6UGFzc1JlZlB0cjxXZWJDb3JlOjpUZXh0RmllbGREZWNvcmF0 aW9uRWxlbWVudD4mKTsKKyAgICBvcGVyYXRvciBXVEY6OlBhc3NSZWZQdHI8V2ViQ29yZTo6VGV4 dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ+KCkgY29uc3Q7CisjZW5kaWYKK307CisKK30gLy8gbmFt ZXNwYWNlIFdlYktpdAorCisjZW5kaWYKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vcHVibGljL1dlYlRleHRGaWVsZERlY29yYXRvckNsaWVudC5oIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9wdWJsaWMvV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50LmgKaW5kZXggYThkMjlm OTNlYjg2YTQ2N2UyYTVlYjhjYTk0ZGRlODY2YTUyZDczMC4uNzcyZTEyMTZiYzFhNDcyNjhlNmIx MDIzNWNmNjkwNGUyNzJjMjFjNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9w dWJsaWMvV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50LmgKKysrIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9wdWJsaWMvV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50LmgKQEAgLTMzLDYgKzMz LDEwIEBACiAKICNpbmNsdWRlICJwbGF0Zm9ybS9XZWJDU3RyaW5nLmgiCiAKKyNpZiBXRUJLSVRf SU1QTEVNRU5UQVRJT04KK25hbWVzcGFjZSBXZWJDb3JlIHsgY2xhc3MgVGV4dEZpZWxkRGVjb3Jh dG9yOyB9CisjZW5kaWYKKwogbmFtZXNwYWNlIFdlYktpdCB7CiAKIGNsYXNzIFdlYklucHV0RWxl bWVudDsKQEAgLTQzLDYgKzQ3LDggQEAgcHVibGljOgogICAgIC8vIGhhdmUgYSBkZWNvcmF0aW9u IGljb24uIFRoaXMgZnVuY3Rpb24gaXMgY2FsbGVkIHdoZW5ldmVyIGEgdGV4dCBmaWVsZCBpcwog ICAgIC8vIGNyZWF0ZWQsIGFuZCBzaG91bGQgbm90IHRha2UgbXVjaCB0aW1lLgogICAgIHZpcnR1 YWwgYm9vbCBzaG91bGRBZGREZWNvcmF0aW9uVG8oY29uc3QgV2ViSW5wdXRFbGVtZW50JikgPSAw OworICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0aGUgZGVjb3JhdGlvbiBzaG91bGQgYmUgdmlzaWJs ZSB3aGVuIGl0J3MgY3JlYXRlZC4KKyAgICB2aXJ0dWFsIGJvb2wgdmlzaWJsZUJ5RGVmYXVsdCgp ID0gMDsKIAogICAgIC8vIEltYWdlIHJlc291cmNlIG5hbWUgZm9yIHRoZSBub3JtYWwgc3RhdGUu IFRoZSBpbWFnZSBpcyBzdHJldGNoZWQgdG8KICAgICAvLyBmb250LXNpemUgeCBmb250LXNpemUg c3F1YXJlLiBUaGUgZnVuY3Rpb24gbXVzdCByZXR1cm4gYW4gZXhpc3RpbmcKQEAgLTYzLDYgKzY5 LDEwIEBAIHB1YmxpYzoKICAgICAvLyBzdGF0ZSBvZiBXZWJLaXQgb2JqZWN0cy4KICAgICB2aXJ0 dWFsIHZvaWQgd2lsbERldGFjaChjb25zdCBXZWJJbnB1dEVsZW1lbnQmKSA9IDA7CiAKKyNpZiBX RUJLSVRfSU1QTEVNRU5UQVRJT04KKyAgICBib29sIGlzQ2xpZW50Rm9yKFdlYkNvcmU6OlRleHRG aWVsZERlY29yYXRvciopOworI2VuZGlmCisKICAgICB2aXJ0dWFsIH5XZWJUZXh0RmllbGREZWNv cmF0b3JDbGllbnQoKSB7IH0KIH07CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21p dW0vc3JjL0Nocm9tZUNsaWVudEltcGwuY3BwIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMv Q2hyb21lQ2xpZW50SW1wbC5jcHAKaW5kZXggNzBkNTY1YzJlZWRiOGNhOThlYmMwYzU1MjQ1YmI3 MjZjNzhlZTQyYy4uZmFlZDNlZDg2ZWY0OTIwOTUyNTY0NzVhYmFjNWFiMDI3NTdkMDMwYSAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvQ2hyb21lQ2xpZW50SW1wbC5jcHAK KysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvQ2hyb21lQ2xpZW50SW1wbC5jcHAKQEAg LTEwMzYsNyArMTAzNiw3IEBAIHZvaWQgQ2hyb21lQ2xpZW50SW1wbDo6YWRkVGV4dEZpZWxkRGVj b3JhdGlvbnNUbyhIVE1MSW5wdXRFbGVtZW50KiBpbnB1dCkKICAgICAgICAgaWYgKCFkZWNvcmF0 b3JzW2ldLT53aWxsQWRkRGVjb3JhdGlvblRvKGlucHV0KSkKICAgICAgICAgICAgIGNvbnRpbnVl OwogICAgICAgICBSZWZQdHI8VGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ+IGRlY29yYXRpb24g PSBUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudDo6Y3JlYXRlKGlucHV0LT5kb2N1bWVudCgpLCBk ZWNvcmF0b3JzW2ldLmdldCgpKTsKLSAgICAgICAgZGVjb3JhdGlvbi0+ZGVjb3JhdGUoaW5wdXQp OworICAgICAgICBkZWNvcmF0aW9uLT5kZWNvcmF0ZShpbnB1dCwgZGVjb3JhdG9yc1tpXS0+dmlz aWJsZUJ5RGVmYXVsdCgpKTsKICAgICB9CiB9CiAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQv Y2hyb21pdW0vc3JjL1RleHRGaWVsZERlY29yYXRvckltcGwuY3BwIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5jcHAKaW5kZXggZTU4YzAyMmVlYjQ2 NjdhMmNkNjcxY2FlYzk3ZjU3NzI5ZmJiMjVjNi4uNTYyOTgwNmQ0ZmQxNzdkMjJiYzIzZjY0M2M4 NTZmOGVhOTliYjA0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVGV4 dEZpZWxkRGVjb3JhdG9ySW1wbC5jcHAKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMv VGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5jcHAKQEAgLTU2LDEyICs1NiwyMyBAQCBUZXh0RmllbGRE ZWNvcmF0b3JJbXBsOjp+VGV4dEZpZWxkRGVjb3JhdG9ySW1wbCgpCiB7CiB9CiAKK1dlYlRleHRG aWVsZERlY29yYXRvckNsaWVudCogVGV4dEZpZWxkRGVjb3JhdG9ySW1wbDo6ZGVjb3JhdG9yQ2xp ZW50KCkKK3sKKyAgICByZXR1cm4gbV9jbGllbnQ7Cit9CisKKwogYm9vbCBUZXh0RmllbGREZWNv cmF0b3JJbXBsOjp3aWxsQWRkRGVjb3JhdGlvblRvKEhUTUxJbnB1dEVsZW1lbnQqIGlucHV0KQog ewogICAgIEFTU0VSVChpbnB1dCk7CiAgICAgcmV0dXJuIG1fY2xpZW50LT5zaG91bGRBZGREZWNv cmF0aW9uVG8oV2ViSW5wdXRFbGVtZW50KGlucHV0KSk7CiB9CiAKK2Jvb2wgVGV4dEZpZWxkRGVj b3JhdG9ySW1wbDo6dmlzaWJsZUJ5RGVmYXVsdCgpCit7CisgICAgcmV0dXJuIG1fY2xpZW50LT52 aXNpYmxlQnlEZWZhdWx0KCk7Cit9CisKIENhY2hlZEltYWdlKiBUZXh0RmllbGREZWNvcmF0b3JJ bXBsOjppbWFnZUZvck5vcm1hbFN0YXRlKCkKIHsKICAgICBpZiAoIW1fY2FjaGVkSW1hZ2VGb3JO b3JtYWxTdGF0ZSkgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVGV4 dEZpZWxkRGVjb3JhdG9ySW1wbC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVGV4dEZp ZWxkRGVjb3JhdG9ySW1wbC5oCmluZGV4IDY2NzQ3NTI4MmY1YmUzOTVhZDExMmFiNTg4NTEwM2Ew YTcxZTc5OWIuLjhmNTIwNjliYWY2ZjZhZjQ3NGQ2NzQwNjE0NWQwYWY3M2VhMjA4NzkgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1RleHRGaWVsZERlY29yYXRvckltcGwu aAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9UZXh0RmllbGREZWNvcmF0b3JJbXBs LmgKQEAgLTQzLDggKzQzLDExIEBAIHB1YmxpYzoKICAgICBzdGF0aWMgUGFzc093blB0cjxUZXh0 RmllbGREZWNvcmF0b3JJbXBsPiBjcmVhdGUoV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50Kik7 CiAgICAgdmlydHVhbCB+VGV4dEZpZWxkRGVjb3JhdG9ySW1wbCgpOwogCisgICAgV2ViVGV4dEZp ZWxkRGVjb3JhdG9yQ2xpZW50KiBkZWNvcmF0b3JDbGllbnQoKTsKKwogcHJpdmF0ZToKICAgICB2 aXJ0dWFsIGJvb2wgd2lsbEFkZERlY29yYXRpb25UbyhXZWJDb3JlOjpIVE1MSW5wdXRFbGVtZW50 KikgT1ZFUlJJREU7CisgICAgdmlydHVhbCBib29sIHZpc2libGVCeURlZmF1bHQoKSBPVkVSUklE RTsKICAgICB2aXJ0dWFsIFdlYkNvcmU6OkNhY2hlZEltYWdlKiBpbWFnZUZvck5vcm1hbFN0YXRl KCkgT1ZFUlJJREU7CiAgICAgdmlydHVhbCBXZWJDb3JlOjpDYWNoZWRJbWFnZSogaW1hZ2VGb3JE aXNhYmxlZFN0YXRlKCkgT1ZFUlJJREU7CiAgICAgdmlydHVhbCBXZWJDb3JlOjpDYWNoZWRJbWFn ZSogaW1hZ2VGb3JSZWFkb25seVN0YXRlKCkgT1ZFUlJJREU7CmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJbnB1dEVsZW1lbnQuY3BwIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvV2ViSW5wdXRFbGVtZW50LmNwcAppbmRleCBhZGFlOWRhYzgyZDE3OGZlMWJl ZGMwZjlhOTVjYzcwNDM2NzcyZjU3Li45N2NlMjNlMTFlZGVmY2I4NWI0MmYzYTAyZWZlNGY3MzEw NDRhODk2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJbnB1dEVs ZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklucHV0RWxlbWVu dC5jcHAKQEAgLTMxLDExICszMSwxNyBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1ZGUg IldlYklucHV0RWxlbWVudC5oIgogCisjaW5jbHVkZSAiRWxlbWVudFNoYWRvdy5oIgogI2luY2x1 ZGUgIkhUTUxEYXRhTGlzdEVsZW1lbnQuaCIKICNpbmNsdWRlICJIVE1MSW5wdXRFbGVtZW50Lmgi CiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCisjaW5jbHVkZSAiU2hhZG93Um9vdC5oIgogI2luY2x1 ZGUgIlRleHRDb250cm9sSW5uZXJFbGVtZW50cy5oIgorI2luY2x1ZGUgIlRleHRGaWVsZERlY29y YXRpb25FbGVtZW50LmgiCisjaW5jbHVkZSAiVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5oIgogI2lu Y2x1ZGUgIldlYk5vZGVDb2xsZWN0aW9uLmgiCisjaW5jbHVkZSAiV2ViVGV4dEZpZWxkRGVjb3Jh dGlvbkVsZW1lbnQuaCIKKyNpbmNsdWRlICJXZWJUZXh0RmllbGREZWNvcmF0b3JDbGllbnQuaCIK ICNpbmNsdWRlICJwbGF0Zm9ybS9XZWJTdHJpbmcuaCIKICNpbmNsdWRlIDx3dGYvUGFzc1JlZlB0 ci5oPgogCkBAIC0yMjEsNiArMjI3LDIwIEBAIGludCBXZWJJbnB1dEVsZW1lbnQ6OmRlZmF1bHRN YXhMZW5ndGgoKQogICAgIHJldHVybiBIVE1MSW5wdXRFbGVtZW50OjptYXhpbXVtTGVuZ3RoOwog fQogCitXZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudCBXZWJJbnB1dEVsZW1lbnQ6OmRlY29y YXRpb25FbGVtZW50Rm9yKFdlYlRleHRGaWVsZERlY29yYXRvckNsaWVudCogZGVjb3JhdG9yQ2xp ZW50KQoreworICAgIFNoYWRvd1Jvb3QqIHNoYWRvd1Jvb3QgPSB1bndyYXA8SFRNTElucHV0RWxl bWVudD4oKS0+eW91bmdlc3RTaGFkb3dSb290KCk7CisgICAgd2hpbGUgKHNoYWRvd1Jvb3QpIHsK KyAgICAgICAgVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQqIGRlY29yYXRpb24gPSBUZXh0Rmll bGREZWNvcmF0aW9uRWxlbWVudDo6ZnJvbVNoYWRvd1Jvb3Qoc2hhZG93Um9vdCk7CisgICAgICAg IGlmIChkZWNvcmF0aW9uCisgICAgICAgICAgICAmJiBkZWNvcmF0b3JDbGllbnQtPmlzQ2xpZW50 Rm9yKGRlY29yYXRpb24tPnRleHRGaWVsZERlY29yYXRvcigpKSkgeworICAgICAgICAgICAgcmV0 dXJuIFdlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50KGRlY29yYXRpb24pOworICAgICAgICB9 CisgICAgICAgIHNoYWRvd1Jvb3QgPSBzaGFkb3dSb290LT5vbGRlclNoYWRvd1Jvb3QoKTsKKyAg ICB9CisgICAgcmV0dXJuIFdlYlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50KCk7Cit9CisKIFdl YklucHV0RWxlbWVudDo6V2ViSW5wdXRFbGVtZW50KGNvbnN0IFBhc3NSZWZQdHI8SFRNTElucHV0 RWxlbWVudD4mIGVsZW0pCiAgICAgOiBXZWJGb3JtQ29udHJvbEVsZW1lbnQoZWxlbSkKIHsKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlRleHRGaWVsZERlY29yYXRp b25FbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlRleHRGaWVsZERl Y29yYXRpb25FbGVtZW50LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi4yZDUyZGVjMjg3ZGMxZDcwOTc4YTU4NTUw ZDBjNmE3Y2MyYzBiMjhiCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYktpdC9jaHJvbWl1 bS9zcmMvV2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuY3BwCkBAIC0wLDAgKzEsNjggQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucyBhcmUKKyAqIG1ldDoKKyAqCisgKiAg ICAgKiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3Zl IGNvcHlyaWdodAorICogbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogICAgICogUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBm b3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZQorICogY29weXJpZ2h0IG5vdGljZSwgdGhpcyBs aXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lcgorICogaW4gdGhl IGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZQor ICogZGlzdHJpYnV0aW9uLgorICogICAgICogTmVpdGhlciB0aGUgbmFtZSBvZiBHb29nbGUgSW5j LiBub3IgdGhlIG5hbWVzIG9mIGl0cworICogY29udHJpYnV0b3JzIG1heSBiZSB1c2VkIHRvIGVu ZG9yc2Ugb3IgcHJvbW90ZSBwcm9kdWN0cyBkZXJpdmVkIGZyb20KKyAqIHRoaXMgc29mdHdhcmUg d2l0aG91dCBzcGVjaWZpYyBwcmlvciB3cml0dGVuIHBlcm1pc3Npb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBUSEUgQ09QWVJJR0hUIEhPTERFUlMgQU5EIENPTlRSSUJV VE9SUworICogIkFTIElTIiBBTkQgQU5ZIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QKKyAqIExJTUlURUQgVE8sIFRIRSBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUgorICogQSBQQVJUSUNVTEFSIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNIQUxMIFRIRSBDT1BZUklHSFQKKyAqIE9X TkVSIE9SIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJ TkNJREVOVEFMLAorICogU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFH RVMgKElOQ0xVRElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgUFJPQ1VSRU1FTlQgT0YgU1VC U1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsCisgKiBEQVRBLCBPUiBQUk9G SVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkK KyAqIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFC SUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFS SVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZF TiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisj aW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiV2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1l bnQuaCIKKworI2luY2x1ZGUgIkhUTUxOYW1lcy5oIgorI2luY2x1ZGUgIlRleHRGaWVsZERlY29y YXRpb25FbGVtZW50LmgiCisjaW5jbHVkZSA8d3RmL1Bhc3NSZWZQdHIuaD4KKwordXNpbmcgbmFt ZXNwYWNlIFdlYkNvcmU7CisKK25hbWVzcGFjZSBXZWJLaXQgeworCit2b2lkIFdlYlRleHRGaWVs ZERlY29yYXRpb25FbGVtZW50OjpzZXRWaXNpYmxlKGJvb2wgdmlzaWJsZSkKK3sKKyAgICBpZiAo dmlzaWJsZSkKKyAgICAgICAgdW53cmFwPFRleHRGaWVsZERlY29yYXRpb25FbGVtZW50PigpLT5z ZXRBdHRyaWJ1dGUoSFRNTE5hbWVzOjpzdHlsZUF0dHIsCisgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICJkaXNwbGF5OmJsb2NrIik7Cisg ICAgZWxzZQorICAgICAgICB1bndyYXA8VGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ+KCktPnNl dEF0dHJpYnV0ZShIVE1MTmFtZXM6OnN0eWxlQXR0ciwKKyAgICAgICAgICAgICAgICAgICAgICAg ICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgImRpc3BsYXk6bm9uZSIpOworfQor CitXZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudDo6V2ViVGV4dEZpZWxkRGVjb3JhdGlvbkVs ZW1lbnQoY29uc3QgUGFzc1JlZlB0cjxUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudD4mIGVsZW0p CisgICAgOiBXZWJFbGVtZW50KGVsZW0pCit7Cit9CisKK1dlYlRleHRGaWVsZERlY29yYXRpb25F bGVtZW50JiBXZWJUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudDo6b3BlcmF0b3I9KGNvbnN0IFBh c3NSZWZQdHI8VGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ+JiBlbGVtKQoreworICAgIG1fcHJp dmF0ZSA9IGVsZW07CisgICAgcmV0dXJuICp0aGlzOworfQorCitXZWJUZXh0RmllbGREZWNvcmF0 aW9uRWxlbWVudDo6b3BlcmF0b3IgUGFzc1JlZlB0cjxUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVu dD4oKSBjb25zdAoreworICAgIHJldHVybiBzdGF0aWNfY2FzdDxUZXh0RmllbGREZWNvcmF0aW9u RWxlbWVudCo+KG1fcHJpdmF0ZS5nZXQoKSk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdApk aWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVGV4dEZpZWxkRGVjb3Jh dG9yQ2xpZW50LmNwcCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlRleHRGaWVsZERl Y29yYXRvckNsaWVudC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uNGQ1YjE2MTc0ZDM0NGMzMDlmN2MzMjRkOTE4 YzU1M2M5ODQ4MzY4YwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0v c3JjL1dlYlRleHRGaWVsZERlY29yYXRvckNsaWVudC5jcHAKQEAgLTAsMCArMSw0NiBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAxMiBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor ICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAq IFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29w eXJpZ2h0CisgKiBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0g bXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBk aXN0cmlidXRpb24uCisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5v ciB0aGUgbmFtZXMgb2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3Jz ZSBvciBwcm9tb3RlIHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRo b3V0IHNwZWNpZmljIHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRX QVJFIElTIFBST1ZJREVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JT CisgKiAiQVMgSVMiIEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIg T1IgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lE RU5UQUwsCisgKiBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAo SU5DTFVESU5HLCBCVVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElU VVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7 IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICog VEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElU WSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lO RyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElG IEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNs dWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJXZWJUZXh0RmllbGREZWNvcmF0b3JDbGllbnQuaCIK KworI2luY2x1ZGUgIlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50LmgiCisjaW5jbHVkZSAiVGV4 dEZpZWxkRGVjb3JhdG9ySW1wbC5oIgorCit1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKKworbmFt ZXNwYWNlIFdlYktpdCB7CisKK2Jvb2wgV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50Ojppc0Ns aWVudEZvcihUZXh0RmllbGREZWNvcmF0b3IqIGRlY29yYXRvcikKK3sKKyAgICByZXR1cm4gc3Rh dGljX2Nhc3Q8VGV4dEZpZWxkRGVjb3JhdG9ySW1wbCo+KGRlY29yYXRvciktPmRlY29yYXRvckNs aWVudCgpID09IHRoaXM7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAo= 144111 2012-05-25 11:48:39 -0700 2012-05-25 19:20:56 -0700 Patch bug-86557-20120525114838.patch text/plain 14966 gcasto U3VidmVyc2lvbiBSZXZpc2lvbjogMTE3ODA4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggNWZhNGY1NGNiMTc0MjQ4 ZTA4NWViNGViZjFlMDExYWI0ZjJiMWZiMS4uZGI2M2Q3ZDgxZTRlMTBlNzgzNDkxMDFkYzJmY2Nk MWZhZWY2NDkxYiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE4IEBACisyMDEyLTA1LTE1ICBHYXJy ZXR0IENhc3RvICA8Z2Nhc3RvQGNocm9taXVtLm9yZz4KKworICAgICAgICBBbGxvdyBXZWJUZXh0 RmllbGREZWNvcmF0b3JDbGllbnQgdG8gc2VlIGFwcGxpZWQgZGVjb3JhdGlvbnMuCisgICAgICAg IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD04NjU1NworCisgICAgICAg IFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogaHRtbC9zaGFkb3cvVGV4 dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6VGV4dEZpZWxk RGVjb3JhdGlvbkVsZW1lbnQ6OmZyb21TaGFkb3dSb290KTogQSBmdW5jdGlvbgorICAgICAgICB0 aGF0IHdpbGwgZXh0cmFjdCBhIFRleHRGaWVsRGVjb3JhdGlvbkVsZW1lbnQgZnJvbSBhIFNoYWRv d1Jvb3QsIGlmCisgICAgICAgIHRoZXJlIGlzIG9uZS4KKyAgICAgICAgKiBodG1sL3NoYWRvdy9U ZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudC5oOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAg IChUZXh0RmllbGREZWNvcmF0b3IpOgorCiAyMDEyLTA1LTIxICBKb3NodWEgQmVsbCAgPGpzYmVs bEBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgSW5kZXhlZERCOiBJbmRleCBrZXkgcGF0aHMgdGhh dCB5aWVsZCBpbnZhbGlkIGtleXMgc2hvdWxkIG5vdCBmYWlsIGFuIGFkZC9wdXQKZGlmZiAtLWdp dCBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vQ2hhbmdlTG9nIGIvU291cmNlL1dlYktpdC9jaHJv bWl1bS9DaGFuZ2VMb2cKaW5kZXggOTQ5YjRlNWU0YzczZTlkNzczYWYwMmY4ZDY1M2Y2YjkxNWRh YTAxMy4uNjI3NDI4MTkyYWEwNWI0ZDA0ZDU0YmIxNzAxNmQzZDI3ZGZjOWRhMiAxMDA2NDQKLS0t IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9DaGFuZ2VMb2cKKysrIGIvU291cmNlL1dlYktpdC9j aHJvbWl1bS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwyMSBAQAorMjAxMi0wNS0xNSAgR2FycmV0dCBD YXN0byAgPGdjYXN0b0BjaHJvbWl1bS5vcmc+CisKKyAgICAgICAgQWxsb3cgV2ViVGV4dEZpZWxk RGVjb3JhdG9yQ2xpZW50IHRvIHNlZSBhcHBsaWVkIGRlY29yYXRpb25zLgorICAgICAgICBodHRw czovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9ODY1NTcKKworICAgICAgICBSZXZp ZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIFdlYktpdC5neXA6IEFkZGVkIG5l dyBmaWxlcy4KKyAgICAgICAgKiBwdWJsaWMvV2ViSW5wdXRFbGVtZW50Lmg6CisgICAgICAgIChX ZWJLaXQ6OldlYklucHV0RWxlbWVudDo6ZGVjb3JhdGlvbkVsZW1lbnRGb3IpOiBSZXR1cm5zIHRo ZQorICAgICAgICBXZWJFbGVtZW50IGF0dGFjaGVkIHRvIHRoZSBXZWJJbnB1dEVsZW1lbnQgYnkg dGhlIGdpdmVuCisgICAgICAgIFdlYlRleHRGaWVsZERlY29yYXRvckNsaWVudCwgaWYgb25lIGV4 aXN0cy4KKyAgICAgICAgKiBzcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5jcHA6CisgICAgICAg IChXZWJLaXQpOgorICAgICAgICAqIHNyYy9UZXh0RmllbGREZWNvcmF0b3JJbXBsLmg6CisgICAg ICAgIChUZXh0RmllbGREZWNvcmF0b3JJbXBsOjpkZWNvcmF0b3JDbGllbnQpOiBHZXQgdGhlCisg ICAgICAgIFdlYlRleHRGaWVsZERlY29yYXRvckNsaWVudCBvd25lZCBieSB0aGlzIG9iamVjdC4K KwogMjAxMi0wNS0xOCAgTWljaGFlbCBOb3JkbWFuICA8bWljaGFlbG5AZ29vZ2xlLmNvbT4KIAog ICAgICAgICBbY2hyb21pdW1dIERvbVN0b3JhZ2UgZXZlbnRzIGhhbmRsaW5nIG5lZWRzIFRMQyAo MikKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1RleHRGaWVsZERlY29y YXRpb25FbGVtZW50LmNwcCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1RleHRGaWVsZERl Y29yYXRpb25FbGVtZW50LmNwcAppbmRleCAwZjdhZjM4ODBkODkxZDMyODRkMjk4ZDI4NGIyODNl YmM0ZGRkMzIzLi43NzYzZTIzZGFkZGNlMDNmYWY3YWFlMTJhZjJmNjFmMGE5NDk5ZTc2IDEwMDY0 NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9UZXh0RmllbGREZWNvcmF0aW9uRWxl bWVudC5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dEZpZWxkRGVjb3Jh dGlvbkVsZW1lbnQuY3BwCkBAIC02Niw2ICs2NiwxNiBAQCBQYXNzUmVmUHRyPFRleHRGaWVsZERl Y29yYXRpb25FbGVtZW50PiBUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudDo6Y3JlYXRlKERvY3Vt ZQogICAgIHJldHVybiBhZG9wdFJlZihuZXcgVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQoZG9j dW1lbnQsIGRlY29yYXRvcikpOwogfQogCitUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudCogVGV4 dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ6OmZyb21TaGFkb3dSb290KFNoYWRvd1Jvb3QqIHNoYWRv d1Jvb3QpCit7CisgICAgaWYgKCFzaGFkb3dSb290LT5maXJzdENoaWxkKCkKKyAgICAgICAgfHwg IXNoYWRvd1Jvb3QtPmZpcnN0Q2hpbGQoKS0+bGFzdENoaWxkKCkKKyAgICAgICAgfHwgIXNoYWRv d1Jvb3QtPmZpcnN0Q2hpbGQoKS0+bGFzdENoaWxkKCktPmlzRWxlbWVudE5vZGUoKQorICAgICAg ICB8fCAhdG9FbGVtZW50KHNoYWRvd1Jvb3QtPmZpcnN0Q2hpbGQoKS0+bGFzdENoaWxkKCkpLT5p c1RleHRGaWVsZERlY29yYXRpb24oKSkKKyAgICAgICAgcmV0dXJuIDA7CisgICAgcmV0dXJuIHRv VGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQoc2hhZG93Um9vdC0+Zmlyc3RDaGlsZCgpLT5sYXN0 Q2hpbGQoKSk7Cit9CisKIHN0YXRpYyBpbmxpbmUgdm9pZCBnZXREZWNvcmF0aW9uUm9vdEFuZERl Y29yYXRlZFJvb3QoSFRNTElucHV0RWxlbWVudCogaW5wdXQsIFNoYWRvd1Jvb3QqJiBkZWNvcmF0 aW9uUm9vdCwgU2hhZG93Um9vdComIGRlY29yYXRlZFJvb3QpCiB7CiAgICAgU2hhZG93Um9vdCog ZXhpc3RpbmdSb290ID0gaW5wdXQtPnlvdW5nZXN0U2hhZG93Um9vdCgpOwpAQCAtODMsNyArOTMs NyBAQCBzdGF0aWMgaW5saW5lIHZvaWQgZ2V0RGVjb3JhdGlvblJvb3RBbmREZWNvcmF0ZWRSb290 KEhUTUxJbnB1dEVsZW1lbnQqIGlucHV0LCBTaAogICAgIGRlY29yYXRlZFJvb3QgPSBleGlzdGlu Z1Jvb3Q7CiB9CiAKLXZvaWQgVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ6OmRlY29yYXRlKEhU TUxJbnB1dEVsZW1lbnQqIGlucHV0KQordm9pZCBUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudDo6 ZGVjb3JhdGUoSFRNTElucHV0RWxlbWVudCogaW5wdXQsIGJvb2wgdmlzaWJsZSkKIHsKICAgICBB U1NFUlQoaW5wdXQpOwogICAgIFNoYWRvd1Jvb3QqIGV4aXN0aW5nUm9vdDsKQEAgLTk5LDcgKzEw OSw3IEBAIHZvaWQgVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ6OmRlY29yYXRlKEhUTUxJbnB1 dEVsZW1lbnQqIGlucHV0KQogICAgIHRvSFRNTEVsZW1lbnQoZXhpc3RpbmdSb290LT5maXJzdENo aWxkKCkpLT5zZXRJbmxpbmVTdHlsZVByb3BlcnR5KENTU1Byb3BlcnR5V2Via2l0Qm94RmxleCwg MS4wLCBDU1NQcmltaXRpdmVWYWx1ZTo6Q1NTX05VTUJFUik7CiAgICAgYm94LT5hcHBlbmRDaGls ZChIVE1MU2hhZG93RWxlbWVudDo6Y3JlYXRlKEhUTUxOYW1lczo6c2hhZG93VGFnLCBpbnB1dC0+ ZG9jdW1lbnQoKSkpOwogCi0gICAgc2V0SW5saW5lU3R5bGVQcm9wZXJ0eShDU1NQcm9wZXJ0eVdl YmtpdEJveEZsZXgsIDAuMCwgQ1NTUHJpbWl0aXZlVmFsdWU6OkNTU19OVU1CRVIpOworICAgIHNl dElubGluZVN0eWxlUHJvcGVydHkoQ1NTUHJvcGVydHlEaXNwbGF5LCB2aXNpYmxlID8gQ1NTVmFs dWVCbG9jayA6IENTU1ZhbHVlTm9uZSk7CiAgICAgYm94LT5hcHBlbmRDaGlsZCh0aGlzKTsKIH0K IApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dEZpZWxkRGVjb3Jh dGlvbkVsZW1lbnQuaCBiL1NvdXJjZS9XZWJDb3JlL2h0bWwvc2hhZG93L1RleHRGaWVsZERlY29y YXRpb25FbGVtZW50LmgKaW5kZXggYjM0ZTdiNWFhOTZmMzRjNzcwNzcyOTk1Njk3MWEyMjZlYWQ3 MDBjNy4uZjJjODI3YTQ1MDFmMzRmOWIwYWRjMjdiMzFkZWZmODBiNzdmMjYyNSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvaHRtbC9zaGFkb3cvVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQu aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9odG1sL3NoYWRvdy9UZXh0RmllbGREZWNvcmF0aW9uRWxl bWVudC5oCkBAIC0zNyw2ICszNyw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsKIAogY2xhc3MgQ2Fj aGVkSW1hZ2U7CiBjbGFzcyBIVE1MSW5wdXRFbGVtZW50OworY2xhc3MgU2hhZG93Um9vdDsKIAog Ly8gQSBUZXh0RmllbGREZWNvcmF0b3Igb2JqZWN0IG11c3QgbGl2ZSB1bnRpbCBhbGwgb2YgdGV4 dCBmaWVsZHMgd2hpY2ggd2VyZQogLy8gZGVjb3JhdGVkIGJ5IGl0IGRpZS4KQEAgLTQ1LDYgKzQ2 LDcgQEAgcHVibGljOgogICAgIC8vIFJldHVybnMgdHJ1ZSBpZiB0aGlzIFRleHRGaWVsZERlY29y YXRvciB3YW50cyB0byBhZGQgYQogICAgIC8vIGRlY29yYXRpb24gdG8gdGhlIHNwZWNpZmllZCB0 ZXh0IGZpZWxkLgogICAgIHZpcnR1YWwgYm9vbCB3aWxsQWRkRGVjb3JhdGlvblRvKEhUTUxJbnB1 dEVsZW1lbnQqKSA9IDA7CisgICAgdmlydHVhbCBib29sIHZpc2libGVCeURlZmF1bHQoKSA9IDA7 CiAKICAgICAvLyBBIFRleHRGaWVsZERlY29yYXRvciBvYmplY3Qgc2hvdWxkIG93biB0aGUgQ2Fj aGVkSW1hZ2Ugb2JqZWN0cy4KICAgICB2aXJ0dWFsIENhY2hlZEltYWdlKiBpbWFnZUZvck5vcm1h bFN0YXRlKCkgPSAwOwpAQCAtNjUsOCArNjcsOSBAQCBwdWJsaWM6CiBjbGFzcyBUZXh0RmllbGRE ZWNvcmF0aW9uRWxlbWVudCA6IHB1YmxpYyBIVE1MRGl2RWxlbWVudCB7CiBwdWJsaWM6CiAgICAg c3RhdGljIFBhc3NSZWZQdHI8VGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQ+IGNyZWF0ZShEb2N1 bWVudCosIFRleHRGaWVsZERlY29yYXRvciopOworICAgIHN0YXRpYyBUZXh0RmllbGREZWNvcmF0 aW9uRWxlbWVudCogZnJvbVNoYWRvd1Jvb3QoU2hhZG93Um9vdCopOwogICAgIFRleHRGaWVsZERl Y29yYXRvciogdGV4dEZpZWxkRGVjb3JhdG9yKCkgeyByZXR1cm4gbV90ZXh0RmllbGREZWNvcmF0 b3I7IH0KLSAgICB2b2lkIGRlY29yYXRlKEhUTUxJbnB1dEVsZW1lbnQqKTsKKyAgICB2b2lkIGRl Y29yYXRlKEhUTUxJbnB1dEVsZW1lbnQqLCBib29sIHZpc2libGUpOwogCiBwcml2YXRlOgogICAg IFRleHRGaWVsZERlY29yYXRpb25FbGVtZW50KERvY3VtZW50KiwgVGV4dEZpZWxkRGVjb3JhdG9y Kik7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAgYi9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL1dlYktpdC5neXAKaW5kZXggOWVhMDQ0ODZjNTJlZjQ1MmJkNGJh MGU1ZTFhYmE1ODlmNmRlZWRhMy4uMTM2Y2I0Y2E4Y2IxYzgzZjgzZWY0NjkxYzY4ZjgxZGU2ODc3 NDUyMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9XZWJLaXQuZ3lwCisrKyBi L1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vV2ViS2l0Lmd5cApAQCAtNjYwLDYgKzY2MCw3IEBACiAg ICAgICAgICAgICAgICAgJ3NyYy9XZWJUZXh0UnVuLmNwcCcsCiAgICAgICAgICAgICAgICAgJ3Ny Yy9XZWJVUkxMb2FkVGltaW5nLmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJTY29wZWRV c2VyR2VzdHVyZS5jcHAnLAorICAgICAgICAgICAgICAgICdzcmMvV2ViVGV4dEZpZWxkRGVjb3Jh dG9yQ2xpZW50LmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJVc2VyTWVkaWFSZXF1ZXN0 LmNwcCcsCiAgICAgICAgICAgICAgICAgJ3NyYy9XZWJWaWRlb0xheWVyLmNwcCcsCiAgICAgICAg ICAgICAgICAgJ3NyYy9XZWJWaWV3SW1wbC5jcHAnLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktp dC9jaHJvbWl1bS9wdWJsaWMvV2ViSW5wdXRFbGVtZW50LmggYi9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3B1YmxpYy9XZWJJbnB1dEVsZW1lbnQuaAppbmRleCAyM2U4NWFhNzMxMTEwOTk3M2ExMzkw YmY4MDdmY2I1YThhYzE5YmJiLi45MTM3NDBkNjZhMTk1NmNkMWQzMTVlZTA1ZjZlZTc3MmUyNDdk MjY4IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJbnB1dEVs ZW1lbnQuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3B1YmxpYy9XZWJJbnB1dEVsZW1l bnQuaApAQCAtNDAsNiArNDAsNyBAQCBuYW1lc3BhY2UgV2ViQ29yZSB7IGNsYXNzIEhUTUxJbnB1 dEVsZW1lbnQ7IH0KIG5hbWVzcGFjZSBXZWJLaXQgewogCiAgICAgY2xhc3MgV2ViTm9kZUNvbGxl Y3Rpb247CisgICAgY2xhc3MgV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50OwogCiAgICAgLy8g UHJvdmlkZXMgcmVhZG9ubHkgYWNjZXNzIHRvIHNvbWUgcHJvcGVydGllcyBvZiBhIERPTSBpbnB1 dCBlbGVtZW50IG5vZGUuCiAgICAgY2xhc3MgV2ViSW5wdXRFbGVtZW50IDogcHVibGljIFdlYkZv cm1Db250cm9sRWxlbWVudCB7CkBAIC0xMDMsNiArMTA0LDkgQEAgbmFtZXNwYWNlIFdlYktpdCB7 CiAgICAgICAgIC8vIEV4cG9zZXMgdGhlIGRlZmF1bHQgdmFsdWUgb2YgdGhlIG1heExlbmd0aCBh dHRyaWJ1dGUuCiAgICAgICAgIFdFQktJVF9FWFBPUlQgc3RhdGljIGludCBkZWZhdWx0TWF4TGVu Z3RoKCk7CiAKKyAgICAgICAgLy8gUmV0dXJuIHRoZSBkZWNvcmF0aW9uIGFkZGVkIGJ5IHRoZSBz cGVjaWZpZWQgZGVjb3JhdG9yIGlmIG9uZSBleGlzdHMuCisgICAgICAgIFdFQktJVF9FWFBPUlQg V2ViRWxlbWVudCBkZWNvcmF0aW9uRWxlbWVudEZvcihXZWJUZXh0RmllbGREZWNvcmF0b3JDbGll bnQqKTsKKwogI2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgogICAgICAgICBXZWJJbnB1dEVsZW1l bnQoY29uc3QgV1RGOjpQYXNzUmVmUHRyPFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ+Jik7CiAg ICAgICAgIFdlYklucHV0RWxlbWVudCYgb3BlcmF0b3I9KGNvbnN0IFdURjo6UGFzc1JlZlB0cjxX ZWJDb3JlOjpIVE1MSW5wdXRFbGVtZW50PiYpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9wdWJsaWMvV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50LmggYi9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3B1YmxpYy9XZWJUZXh0RmllbGREZWNvcmF0b3JDbGllbnQuaAppbmRleCBh OGQyOWY5M2ViODZhNDY3ZTJhNWViOGNhOTRkZGU4NjZhNTJkNzMwLi43NzJlMTIxNmJjMWE0NzI2 OGU2YjEwMjM1Y2Y2OTA0ZTI3MmMyMWM1IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9t aXVtL3B1YmxpYy9XZWJUZXh0RmllbGREZWNvcmF0b3JDbGllbnQuaAorKysgYi9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3B1YmxpYy9XZWJUZXh0RmllbGREZWNvcmF0b3JDbGllbnQuaApAQCAtMzMs NiArMzMsMTAgQEAKIAogI2luY2x1ZGUgInBsYXRmb3JtL1dlYkNTdHJpbmcuaCIKIAorI2lmIFdF QktJVF9JTVBMRU1FTlRBVElPTgorbmFtZXNwYWNlIFdlYkNvcmUgeyBjbGFzcyBUZXh0RmllbGRE ZWNvcmF0b3I7IH0KKyNlbmRpZgorCiBuYW1lc3BhY2UgV2ViS2l0IHsKIAogY2xhc3MgV2ViSW5w dXRFbGVtZW50OwpAQCAtNDMsNiArNDcsOCBAQCBwdWJsaWM6CiAgICAgLy8gaGF2ZSBhIGRlY29y YXRpb24gaWNvbi4gVGhpcyBmdW5jdGlvbiBpcyBjYWxsZWQgd2hlbmV2ZXIgYSB0ZXh0IGZpZWxk IGlzCiAgICAgLy8gY3JlYXRlZCwgYW5kIHNob3VsZCBub3QgdGFrZSBtdWNoIHRpbWUuCiAgICAg dmlydHVhbCBib29sIHNob3VsZEFkZERlY29yYXRpb25Ubyhjb25zdCBXZWJJbnB1dEVsZW1lbnQm KSA9IDA7CisgICAgLy8gUmV0dXJucyB0cnVlIGlmIHRoZSBkZWNvcmF0aW9uIHNob3VsZCBiZSB2 aXNpYmxlIHdoZW4gaXQncyBjcmVhdGVkLgorICAgIHZpcnR1YWwgYm9vbCB2aXNpYmxlQnlEZWZh dWx0KCkgPSAwOwogCiAgICAgLy8gSW1hZ2UgcmVzb3VyY2UgbmFtZSBmb3IgdGhlIG5vcm1hbCBz dGF0ZS4gVGhlIGltYWdlIGlzIHN0cmV0Y2hlZCB0bwogICAgIC8vIGZvbnQtc2l6ZSB4IGZvbnQt c2l6ZSBzcXVhcmUuIFRoZSBmdW5jdGlvbiBtdXN0IHJldHVybiBhbiBleGlzdGluZwpAQCAtNjMs NiArNjksMTAgQEAgcHVibGljOgogICAgIC8vIHN0YXRlIG9mIFdlYktpdCBvYmplY3RzLgogICAg IHZpcnR1YWwgdm9pZCB3aWxsRGV0YWNoKGNvbnN0IFdlYklucHV0RWxlbWVudCYpID0gMDsKIAor I2lmIFdFQktJVF9JTVBMRU1FTlRBVElPTgorICAgIGJvb2wgaXNDbGllbnRGb3IoV2ViQ29yZTo6 VGV4dEZpZWxkRGVjb3JhdG9yKik7CisjZW5kaWYKKwogICAgIHZpcnR1YWwgfldlYlRleHRGaWVs ZERlY29yYXRvckNsaWVudCgpIHsgfQogfTsKIApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9j aHJvbWl1bS9zcmMvQ2hyb21lQ2xpZW50SW1wbC5jcHAgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9DaHJvbWVDbGllbnRJbXBsLmNwcAppbmRleCA3MGQ1NjVjMmVlZGI4Y2E5OGViYzBjNTUy NDViYjcyNmM3OGVlNDJjLi5mYWVkM2VkODZlZjQ5MjA5NTI1NjQ3NWFiYWM1YWIwMjc1N2QwMzBh IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9DaHJvbWVDbGllbnRJbXBs LmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9DaHJvbWVDbGllbnRJbXBsLmNw cApAQCAtMTAzNiw3ICsxMDM2LDcgQEAgdm9pZCBDaHJvbWVDbGllbnRJbXBsOjphZGRUZXh0Rmll bGREZWNvcmF0aW9uc1RvKEhUTUxJbnB1dEVsZW1lbnQqIGlucHV0KQogICAgICAgICBpZiAoIWRl Y29yYXRvcnNbaV0tPndpbGxBZGREZWNvcmF0aW9uVG8oaW5wdXQpKQogICAgICAgICAgICAgY29u dGludWU7CiAgICAgICAgIFJlZlB0cjxUZXh0RmllbGREZWNvcmF0aW9uRWxlbWVudD4gZGVjb3Jh dGlvbiA9IFRleHRGaWVsZERlY29yYXRpb25FbGVtZW50OjpjcmVhdGUoaW5wdXQtPmRvY3VtZW50 KCksIGRlY29yYXRvcnNbaV0uZ2V0KCkpOwotICAgICAgICBkZWNvcmF0aW9uLT5kZWNvcmF0ZShp bnB1dCk7CisgICAgICAgIGRlY29yYXRpb24tPmRlY29yYXRlKGlucHV0LCBkZWNvcmF0b3JzW2ld LT52aXNpYmxlQnlEZWZhdWx0KCkpOwogICAgIH0KIH0KIApkaWZmIC0tZ2l0IGEvU291cmNlL1dl YktpdC9jaHJvbWl1bS9zcmMvVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5jcHAgYi9Tb3VyY2UvV2Vi S2l0L2Nocm9taXVtL3NyYy9UZXh0RmllbGREZWNvcmF0b3JJbXBsLmNwcAppbmRleCBlNThjMDIy ZWViNDY2N2EyY2Q2NzFjYWVjOTdmNTc3MjlmYmIyNWM2Li5hNzRhYTgyNWFhZWRlYmU3Y2U4NDJj MmY5YzMwMjFhYmZlM2RmMGU2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3Ny Yy9UZXh0RmllbGREZWNvcmF0b3JJbXBsLmNwcAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVt L3NyYy9UZXh0RmllbGREZWNvcmF0b3JJbXBsLmNwcApAQCAtNTYsMTIgKzU2LDIyIEBAIFRleHRG aWVsZERlY29yYXRvckltcGw6On5UZXh0RmllbGREZWNvcmF0b3JJbXBsKCkKIHsKIH0KIAorV2Vi VGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50KiBUZXh0RmllbGREZWNvcmF0b3JJbXBsOjpkZWNvcmF0 b3JDbGllbnQoKQoreworICAgIHJldHVybiBtX2NsaWVudDsKK30KKwogYm9vbCBUZXh0RmllbGRE ZWNvcmF0b3JJbXBsOjp3aWxsQWRkRGVjb3JhdGlvblRvKEhUTUxJbnB1dEVsZW1lbnQqIGlucHV0 KQogewogICAgIEFTU0VSVChpbnB1dCk7CiAgICAgcmV0dXJuIG1fY2xpZW50LT5zaG91bGRBZGRE ZWNvcmF0aW9uVG8oV2ViSW5wdXRFbGVtZW50KGlucHV0KSk7CiB9CiAKK2Jvb2wgVGV4dEZpZWxk RGVjb3JhdG9ySW1wbDo6dmlzaWJsZUJ5RGVmYXVsdCgpCit7CisgICAgcmV0dXJuIG1fY2xpZW50 LT52aXNpYmxlQnlEZWZhdWx0KCk7Cit9CisKIENhY2hlZEltYWdlKiBUZXh0RmllbGREZWNvcmF0 b3JJbXBsOjppbWFnZUZvck5vcm1hbFN0YXRlKCkKIHsKICAgICBpZiAoIW1fY2FjaGVkSW1hZ2VG b3JOb3JtYWxTdGF0ZSkgewpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMv VGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5oIGIvU291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvVGV4 dEZpZWxkRGVjb3JhdG9ySW1wbC5oCmluZGV4IDY2NzQ3NTI4MmY1YmUzOTVhZDExMmFiNTg4NTEw M2EwYTcxZTc5OWIuLjhmNTIwNjliYWY2ZjZhZjQ3NGQ2NzQwNjE0NWQwYWY3M2VhMjA4NzkgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1RleHRGaWVsZERlY29yYXRvcklt cGwuaAorKysgYi9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9UZXh0RmllbGREZWNvcmF0b3JJ bXBsLmgKQEAgLTQzLDggKzQzLDExIEBAIHB1YmxpYzoKICAgICBzdGF0aWMgUGFzc093blB0cjxU ZXh0RmllbGREZWNvcmF0b3JJbXBsPiBjcmVhdGUoV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50 Kik7CiAgICAgdmlydHVhbCB+VGV4dEZpZWxkRGVjb3JhdG9ySW1wbCgpOwogCisgICAgV2ViVGV4 dEZpZWxkRGVjb3JhdG9yQ2xpZW50KiBkZWNvcmF0b3JDbGllbnQoKTsKKwogcHJpdmF0ZToKICAg ICB2aXJ0dWFsIGJvb2wgd2lsbEFkZERlY29yYXRpb25UbyhXZWJDb3JlOjpIVE1MSW5wdXRFbGVt ZW50KikgT1ZFUlJJREU7CisgICAgdmlydHVhbCBib29sIHZpc2libGVCeURlZmF1bHQoKSBPVkVS UklERTsKICAgICB2aXJ0dWFsIFdlYkNvcmU6OkNhY2hlZEltYWdlKiBpbWFnZUZvck5vcm1hbFN0 YXRlKCkgT1ZFUlJJREU7CiAgICAgdmlydHVhbCBXZWJDb3JlOjpDYWNoZWRJbWFnZSogaW1hZ2VG b3JEaXNhYmxlZFN0YXRlKCkgT1ZFUlJJREU7CiAgICAgdmlydHVhbCBXZWJDb3JlOjpDYWNoZWRJ bWFnZSogaW1hZ2VGb3JSZWFkb25seVN0YXRlKCkgT1ZFUlJJREU7CmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJbnB1dEVsZW1lbnQuY3BwIGIvU291cmNlL1dlYktp dC9jaHJvbWl1bS9zcmMvV2ViSW5wdXRFbGVtZW50LmNwcAppbmRleCBhZGFlOWRhYzgyZDE3OGZl MWJlZGMwZjlhOTVjYzcwNDM2NzcyZjU3Li5jNThlOTA3MDQ2MzBiZGExN2Q4NGYzZThjZWQ1ODZh MmMwYmUyNjUyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViS2l0L2Nocm9taXVtL3NyYy9XZWJJbnB1 dEVsZW1lbnQuY3BwCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYklucHV0RWxl bWVudC5jcHAKQEAgLTMxLDExICszMSwxNiBAQAogI2luY2x1ZGUgImNvbmZpZy5oIgogI2luY2x1 ZGUgIldlYklucHV0RWxlbWVudC5oIgogCisjaW5jbHVkZSAiRWxlbWVudFNoYWRvdy5oIgogI2lu Y2x1ZGUgIkhUTUxEYXRhTGlzdEVsZW1lbnQuaCIKICNpbmNsdWRlICJIVE1MSW5wdXRFbGVtZW50 LmgiCiAjaW5jbHVkZSAiSFRNTE5hbWVzLmgiCisjaW5jbHVkZSAiU2hhZG93Um9vdC5oIgogI2lu Y2x1ZGUgIlRleHRDb250cm9sSW5uZXJFbGVtZW50cy5oIgorI2luY2x1ZGUgIlRleHRGaWVsZERl Y29yYXRpb25FbGVtZW50LmgiCisjaW5jbHVkZSAiVGV4dEZpZWxkRGVjb3JhdG9ySW1wbC5oIgog I2luY2x1ZGUgIldlYk5vZGVDb2xsZWN0aW9uLmgiCisjaW5jbHVkZSAiV2ViVGV4dEZpZWxkRGVj b3JhdG9yQ2xpZW50LmgiCiAjaW5jbHVkZSAicGxhdGZvcm0vV2ViU3RyaW5nLmgiCiAjaW5jbHVk ZSA8d3RmL1Bhc3NSZWZQdHIuaD4KIApAQCAtMjIxLDYgKzIyNiwxOCBAQCBpbnQgV2ViSW5wdXRF bGVtZW50OjpkZWZhdWx0TWF4TGVuZ3RoKCkKICAgICByZXR1cm4gSFRNTElucHV0RWxlbWVudDo6 bWF4aW11bUxlbmd0aDsKIH0KIAorV2ViRWxlbWVudCBXZWJJbnB1dEVsZW1lbnQ6OmRlY29yYXRp b25FbGVtZW50Rm9yKFdlYlRleHRGaWVsZERlY29yYXRvckNsaWVudCogZGVjb3JhdG9yQ2xpZW50 KQoreworICAgIFNoYWRvd1Jvb3QqIHNoYWRvd1Jvb3QgPSB1bndyYXA8SFRNTElucHV0RWxlbWVu dD4oKS0+eW91bmdlc3RTaGFkb3dSb290KCk7CisgICAgd2hpbGUgKHNoYWRvd1Jvb3QpIHsKKyAg ICAgICAgVGV4dEZpZWxkRGVjb3JhdGlvbkVsZW1lbnQqIGRlY29yYXRpb24gPSBUZXh0RmllbGRE ZWNvcmF0aW9uRWxlbWVudDo6ZnJvbVNoYWRvd1Jvb3Qoc2hhZG93Um9vdCk7CisgICAgICAgIGlm IChkZWNvcmF0aW9uICYmIGRlY29yYXRvckNsaWVudC0+aXNDbGllbnRGb3IoZGVjb3JhdGlvbi0+ dGV4dEZpZWxkRGVjb3JhdG9yKCkpKQorICAgICAgICAgICAgcmV0dXJuIFdlYkVsZW1lbnQoZGVj b3JhdGlvbik7CisgICAgICAgIHNoYWRvd1Jvb3QgPSBzaGFkb3dSb290LT5vbGRlclNoYWRvd1Jv b3QoKTsKKyAgICB9CisgICAgcmV0dXJuIFdlYkVsZW1lbnQoKTsKK30KKwogV2ViSW5wdXRFbGVt ZW50OjpXZWJJbnB1dEVsZW1lbnQoY29uc3QgUGFzc1JlZlB0cjxIVE1MSW5wdXRFbGVtZW50PiYg ZWxlbSkKICAgICA6IFdlYkZvcm1Db250cm9sRWxlbWVudChlbGVtKQogewpkaWZmIC0tZ2l0IGEv U291cmNlL1dlYktpdC9jaHJvbWl1bS9zcmMvV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50LmNw cCBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlRleHRGaWVsZERlY29yYXRvckNsaWVu dC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uNGQ1YjE2MTc0ZDM0NGMzMDlmN2MzMjRkOTE4YzU1M2M5ODQ4MzY4 YwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJLaXQvY2hyb21pdW0vc3JjL1dlYlRleHRG aWVsZERlY29yYXRvckNsaWVudC5jcHAKQEAgLTAsMCArMSw0NiBAQAorLyoKKyAqIENvcHlyaWdo dCAoQykgMjAxMiBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlz dHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0 aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZv bGxvd2luZyBjb25kaXRpb25zIGFyZQorICogbWV0OgorICoKKyAqICAgICAqIFJlZGlzdHJpYnV0 aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAgICAgKiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1 Y2UgdGhlIGFib3ZlCisgKiBjb3B5cmlnaHQgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyCisgKiBpbiB0aGUgZG9jdW1lbnRhdGlvbiBh bmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlCisgKiBkaXN0cmlidXRpb24u CisgKiAgICAgKiBOZWl0aGVyIHRoZSBuYW1lIG9mIEdvb2dsZSBJbmMuIG5vciB0aGUgbmFtZXMg b2YgaXRzCisgKiBjb250cmlidXRvcnMgbWF5IGJlIHVzZWQgdG8gZW5kb3JzZSBvciBwcm9tb3Rl IHByb2R1Y3RzIGRlcml2ZWQgZnJvbQorICogdGhpcyBzb2Z0d2FyZSB3aXRob3V0IHNwZWNpZmlj IHByaW9yIHdyaXR0ZW4gcGVybWlzc2lvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJ REVEIEJZIFRIRSBDT1BZUklHSFQgSE9MREVSUyBBTkQgQ09OVFJJQlVUT1JTCisgKiAiQVMgSVMi IEFORCBBTlkgRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5P VAorICogTElNSVRFRCBUTywgVEhFIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJ VFkgQU5EIEZJVE5FU1MgRk9SCisgKiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUgRElTQ0xBSU1F RC4gSU4gTk8gRVZFTlQgU0hBTEwgVEhFIENPUFlSSUdIVAorICogT1dORVIgT1IgQ09OVFJJQlVU T1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsCisgKiBT UEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBC VVQgTk9UCisgKiBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9S IFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwKKyAqIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNT IElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWQorICogVEhFT1JZIE9GIExJ QUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAor ICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZ IE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0Yg VEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcu aCIKKyNpbmNsdWRlICJXZWJUZXh0RmllbGREZWNvcmF0b3JDbGllbnQuaCIKKworI2luY2x1ZGUg IlRleHRGaWVsZERlY29yYXRpb25FbGVtZW50LmgiCisjaW5jbHVkZSAiVGV4dEZpZWxkRGVjb3Jh dG9ySW1wbC5oIgorCit1c2luZyBuYW1lc3BhY2UgV2ViQ29yZTsKKworbmFtZXNwYWNlIFdlYktp dCB7CisKK2Jvb2wgV2ViVGV4dEZpZWxkRGVjb3JhdG9yQ2xpZW50Ojppc0NsaWVudEZvcihUZXh0 RmllbGREZWNvcmF0b3IqIGRlY29yYXRvcikKK3sKKyAgICByZXR1cm4gc3RhdGljX2Nhc3Q8VGV4 dEZpZWxkRGVjb3JhdG9ySW1wbCo+KGRlY29yYXRvciktPmRlY29yYXRvckNsaWVudCgpID09IHRo aXM7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYktpdAo=