27454 2009-07-20 12:03:32 -0700 Hook maxlength attribute to ValidityState tooLong() method 2009-09-30 22:49:52 -0700 1 1 1 Unclassified WebKit Forms 528+ (Nightly build) All All RESOLVED FIXED http://www.whatwg.org/specs/web-apps/current-work/multipage/forms.html#maximum-allowed-value-length P2 Enhancement --- 21271 28001 29292 29796 19264 1 pkasting tkent adele commit-queue darin eric ian tkent oldest_to_newest 133189 0 pkasting 2009-07-20 12:03:32 -0700 Apparently maxlength can already be parsed, so it simply needs to be hooked to the tooLong() method of the validityState object. (We should also check that it's honored/ignored on the elements HTML5 specifies at the same time.) 135414 1 michelangelo 2009-07-28 16:50:46 -0700 From 4.10.14.5 I read: "Constraint validation: If an element has a maximum allowed value length, and its dirty value flag is false, and the code-point length of the element's value is greater than the element's maximum allowed value length, then the element is suffering from being too long." This means that if the attribute is specified and its value is a non-negative number AND if value's length ("code-point length") is greater than that attribute's value AND the dirty flag is "FALSE"... it suffers from being too long. Specs clarify how the dirty value flag shall be dealt with, from http://www.whatwg.org/specs/web-apps/current-work/multipage/forms.html#concept-input-value-dirty-flag I read: "Each input element has a boolean dirty value flag. When it is true, the element is said to have a dirty value. The dirty value flag must be initially set to false when the element is created, and must be set to true whenever the user interacts with the control in a way that changes the value." So, the tooLong flag would be set ONLY if element's value has never been modified by users (and if it is greater than maxlength). Is that right? Another issue for me is to understand the way it should react when maxlength=0: could text form controls (such as some input types and textareas) be forced to be left blank? 135415 2 pkasting 2009-07-28 16:53:00 -0700 (In reply to comment #1) > So, the tooLong flag would be set ONLY if element's value has never been > modified by users (and if it is greater than maxlength). Is that right? I think you stuck in an extra "never". It can only be tooLong if it _has_ been modified. > Another issue for me is to understand the way it should react when maxlength=0: > could text form controls (such as some input types and textareas) be forced to > be left blank? Yes. 135422 3 michelangelo 2009-07-28 17:03:58 -0700 (In reply to comment #1) > From 4.10.14.5 I read: > > "Constraint validation: If an element has a maximum allowed value length, and > its dirty value flag is false, and the code-point length of the element's value > is greater than the element's maximum allowed value length, then the element is > suffering from being too long." Ian confirmed that it's a typo.:) Thank you both. Constraint validation: If an element has a maximum allowed value length, and its dirty value flag is *TRUE*, and the code-point length of the element's value is greater than the element's maximum allowed value length, then the element is suffering from being too long. 136162 4 michelangelo 2009-07-31 08:01:03 -0700 As commented WebCore already support a "maxlength" attribute but it seems to have a slight different behavior. Its interface is the following: attribute long maxLength; HTML5 specs state the following interface instead: attribute unsigned long maxLength; Moreover, at this time WebCore supports this attribute only in HTMLInputElement along with its data structure (InputElementData); this should be supported in HTMLTextAreaElement too. These are the changes I believe are necessary: 1) modify HTMLInputElement's idl to match the one declared in specs (unsigned long, instead of long); 2) modify "int maxlength()" getter to "unsigned maxlength()", same for its setter; both will be pulled up into HTMLFormControlElement. 3) InputElement::parseMaxLengthAttribute shall be refactored and pulled up into an higher level class (HTMLFormControlElement??) 136237 5 darin 2009-07-31 13:47:25 -0700 (In reply to comment #4) > 1) modify HTMLInputElement's idl to match the one declared in specs (unsigned > long, instead of long); This is only needed if there's some way to detect the difference from a test case. Is there any difference? > 2) modify "int maxlength()" getter to "unsigned maxlength()", same for its > setter; both will be pulled up into HTMLFormControlElement. That seems wrong. We don't want to have a maxlength for other kinds of form control elements and moving this into the base class doesn't sound like a good idea to me. > 3) InputElement::parseMaxLengthAttribute shall be refactored and pulled up into an higher level class (HTMLFormControlElement??) These two maxlength attributes can be separate and you shouldn't try to factor them and move the functions into a base class unless there's some obvious clear benefit to doing so. 136242 6 michelangelo 2009-07-31 13:56:21 -0700 (In reply to comment #5) > > 2) modify "int maxlength()" getter to "unsigned maxlength()", same for its > > setter; both will be pulled up into HTMLFormControlElement. > That seems wrong. We don't want to have a maxlength for other kinds of form > control elements and moving this into the base class doesn't sound like a good > idea to me. maxlength applies to TextArea as well. http://www.whatwg.org/specs/web-apps/current-work/multipage/forms.html#dom-textarea-maxlength > > 3) InputElement::parseMaxLengthAttribute shall be refactored and pulled up into an higher level class (HTMLFormControlElement??) > These two maxlength attributes can be separate and you shouldn't try to factor > them and move the functions into a base class unless there's some obvious clear > benefit to doing so. Ditto. WebCore's "maxlength" attribute seems to have a slight different behavior than HTML5's, how do you usually solve such situation? 136280 7 pkasting 2009-07-31 15:50:31 -0700 Since Adele originally implemented maxLength on bug 6987 her insight is probably welcome here. I am confused like Michelangelo is by comment 5. Darin, are you proposing implementing an "HTML5 maxLength" that would live in parallel with the existing maxLength and behave differently? It seems at a glance like hoisting maxLength and modifying it to comply with the HTML5 spec would be the right course of action... 136282 8 ian 2009-07-31 15:52:00 -0700 The intent in HTML5 is to define what WebKit should do, including for the existing maxlength support. It isn't supposed to be different. If there are differences that you are concerned will result in compatibility issues, please let me know. 136285 9 darin 2009-07-31 15:58:27 -0700 (In reply to comment #6) > (In reply to comment #5) > > > > 2) modify "int maxlength()" getter to "unsigned maxlength()", same for its > > > setter; both will be pulled up into HTMLFormControlElement. > > That seems wrong. We don't want to have a maxlength for other kinds of form > > control elements and moving this into the base class doesn't sound like a good > > idea to me. > > maxlength applies to TextArea as well. > http://www.whatwg.org/specs/web-apps/current-work/multipage/forms.html#dom-textarea-maxlength Sure, but that doesn't mean they have to share the same base class. I'm just talking about the factoring. > > > 3) InputElement::parseMaxLengthAttribute shall be refactored and pulled up into an higher level class (HTMLFormControlElement??) > > These two maxlength attributes can be separate and you shouldn't try to factor > > them and move the functions into a base class unless there's some obvious clear > > benefit to doing so. > > Ditto. WebCore's "maxlength" attribute seems to have a slight different > behavior than HTML5's, how do you usually solve such situation? We can fix the bugs. Make test cases and show what's wrong. I am arguing with some specifics about your proposal of where to put the code, not with the concept of fixing bugs. 136292 10 pkasting 2009-07-31 16:15:00 -0700 (In reply to comment #9) > (In reply to comment #6) > > maxlength applies to TextArea as well. > > http://www.whatwg.org/specs/web-apps/current-work/multipage/forms.html#dom-textarea-maxlength > > Sure, but that doesn't mean they have to share the same base class. I'm just > talking about the factoring. OK. I haven't looked at the existing WebCore maxLength implementation. Perhaps it's so simple it should be copy-and-pasted between the classes that need it, or there is an obvious third place for a shared implementation to go. I've asked Michelangelo to first write a patch that converts the existing maxLength algorithm to match the HTML5 spec, along with a testcase for each change made (so there should be a test for the long-versus-unsigned-long change, for example). After we get that agreed-on and landed, a patch that implements maxLength on all elements where HTML5 specs it should be simpler and easier to review. Sound OK? 136300 11 darin 2009-07-31 16:38:25 -0700 > I've asked Michelangelo to first write a patch that converts the existing > maxLength algorithm to match the HTML5 spec, along with a testcase for each > change made (so there should be a test for the long-versus-unsigned-long > change, for example). After we get that agreed-on and landed, a patch that > implements maxLength on all elements where HTML5 specs it should be simpler and > easier to review. Sound OK? Sounds good. You could even do the tests first, landing failing and then patching the test results as we fix various things. 136746 12 michelangelo 2009-08-03 12:41:34 -0700 Actually, HTMLInputElement(s) never suffers of being "tooLong": each value longer than its "maxlength" attribute is trimmed so "validity.tooLong" is always false. About this specs state: "User agents may prevent the user from causing the element's value to be set to a value whose code-point length is greater than the element's maximum allowed value length." which seems very reasonable to me. If no objection is raised I'm gonna get a patch to make HTMLTextArea match the same behaviour, even if this means tooLong will always be false. Now, what would be an acceptable "default maxlength" for TextAreas? 136789 13 pkasting 2009-08-03 14:48:28 -0700 (In reply to comment #12) > Actually, HTMLInputElement(s) never suffers of being "tooLong": each value > longer than its "maxlength" attribute is trimmed so "validity.tooLong" is > always false. I am concerned about apparent spec self-inconsistency here. Section 4.10.4.2.7 reads: "If the input element has a maximum allowed value length, then the code-point length of the value of the element's value attribute must be equal to or less than the element's maximum allowed value length." Section 4.10.14.5 reads: "If an element has a maximum allowed value length, and its dirty value flag is true, and the code-point length of the element's value is greater than the element's maximum allowed value length, then the element is suffering from being too long. "User agents may prevent the user from causing the element's value to be set to a value whose code-point length is greater than the element's maximum allowed value length." The issue here is that the second reference above makes clamping the value length to the maxLength optional, but the first makes it required. Or am I misreading somehow? In the abstract, it'd be easier to implement just flagging long values as "tooLong" and not actually clamping the values. If we do want to clamp, it seems like all applicable elements should clamp, and should disallow more typing when the value hits the limit. But perhaps there's some legacy expectations around the behavior here... 136799 14 michelangelo 2009-08-03 15:11:36 -0700 (In reply to comment #13) > I am concerned about apparent spec self-inconsistency here. I share you concerns; at this time, perhaps, even if a bit harder, I believe that making TextArea behave like Inputs do is better: having two separate behaviours for the same attribute would be most confusing and quite a pain. It's just an opinion of mine, for what it's worth. > In the abstract, it'd be easier to implement just flagging long values as > "tooLong" and not actually clamping the values. If we do want to clamp, it > seems like all applicable elements should clamp, and should disallow more > typing when the value hits the limit. But perhaps there's some legacy > expectations around the behavior here... Yes: much of the "clamp" logic is in InputElement::constrainValue. 137098 15 ian 2009-08-04 13:01:46 -0700 This: "If the input element has a maximum allowed value length, then the code-point length of the value of the element's value attribute must be equal to or less than the element's maximum allowed value length." ...is a requirement on authors, not implementors. 137106 16 pkasting 2009-08-04 13:27:28 -0700 (In reply to comment #15) > This: > "If the input element has a maximum allowed value length, then the code-point > length of the value of the element's value attribute must be equal to or less > than the element's maximum allowed value length." > ...is a requirement on authors, not implementors. So we can ignore that entirely? I'm not sure what that requires authors to do... not set an initial value that's too long? If the UA doesn't trim the value to the maxLength, what does this even mean? 137114 17 ian 2009-08-04 13:52:45 -0700 Yes, you can ignore it entirely (unless you write an editor). It requires authors not to set an initial value that's longer than maxlength. I don't understand your last question. It has nothing to do with UA behaviour. 137161 18 pkasting 2009-08-04 15:49:31 -0700 OK, here's the definitive summary from my conversation with Hixie on #webkit: The spec requires the following: * If a field's initial value is longer than maxLength, but the field has not had any value set via the DOM, and the user hasn't modified the field, tooLong is false. * If a field's value is longer than maxLength and either the value has been set via the DOM (even to the same value as the initial value!), or the user has modified the field, tooLong is true. Consistency with other UAs' behavior requires the following additional pieces: * If a field's initial value is longer than maxLength, the whole value should be displayed, but the user cannot modify or add to it except to delete it (until it becomes short enough). I have filed bug 28001 about this and written more complete details there. * If the user attempts to make a value longer than maxLength, e.g. by typing or pasting, the value is clamped to maxLength characters. * The value may be set to something longer than maxLength programmatically via the DOM, in which case all of it is displayed (like the first bullet). If you combine all these constraints, what you find is that tooLong can only ever be true in the following two cases: * The initial value is longer than maxLength, and the user deletes something from the value but doesn't delete enough of it to bring the result down to maxLength. * The value is set to something longer than maxLength via the DOM, and not subsequently pared back by the user (or script). Again, note that having the initial value be "foo" and then setting the element's value to "foo" by the DOM _is_ considered to set the dirty value flag and thus make the element potentially tooLong. The upshot is that tooLong will rarely be true. 147759 19 tkent 2009-09-17 00:58:11 -0700 I already have the code. I'll ask to review it after Bug#29292 is landed. 149434 20 eric 2009-09-23 10:29:43 -0700 You might want to go ahead an post the code anyway, even if it's not up for review. I do that often so that patches I've worked on are never lost, even if my computer dies or I stop working in that area. 150455 21 40214 tkent 2009-09-27 21:11:47 -0700 Created attachment 40214 Proposed patch 150538 22 40214 darin 2009-09-28 09:40:10 -0700 Comment on attachment 40214 Proposed patch > + switch (inputType()) { > + case EMAIL: > + case PASSWORD: > + case SEARCH: > + case TELEPHONE: > + case TEXT: > + case URL: { > + bool userEditted = !m_data.value().isNull(); // tooLong must be false for the default value. > + if (userEditted && hasAttribute(maxlengthAttr)) { > + // It's safe to cast maxLength() to unsigned because maxLength() can never be negative. > + return value().length() > static_cast<unsigned>(maxLength()); > + } > + break; It's spelled "edited", not "editted". I think the comment is hard to read. You say "tooLong must be false for the default value" but what I think a better comment would be: // Return false for the default value even if it is longer than maxLength. Also, better to have the comment on the line before. It's harder to read it on the end of the line. Should do return false here instead of break, so we can ASSERT_NOT_REACHED outside the switch. We normally prefer early-return style, so the return should be for the case where there is no length check. > + } > + case BUTTON: > + case CHECKBOX: > + case COLOR: > + case FILE: > + case HIDDEN: > + case IMAGE: > + case ISINDEX: > + case NUMBER: > + case RADIO: > + case RANGE: > + case RESET: > + case SUBMIT: > + break; Should do return false here instead of break, so we can ASSERT_NOT_REACHED outside the switch. > + return false; Should ASSERT_NOT_REACHED here. > + const_cast<HTMLTextAreaElement*>(this)->updateValue(); As a rule, we should not use const_cast. Instead we should use mutable. > +bool HTMLTextAreaElement::tooLong() const > +{ > + if (m_isDirty) { > + bool ok; > + unsigned maxLength = getAttribute(maxlengthAttr).string().toUInt(&ok); > + if (ok) > + return value().length() > maxLength; > + } > + return false; > +} Our normal approach is early return. So we'd do: if (!m_isDirty) return false; if (!ok) return false; Instead of the way the logic is structured above. r=me as is, but pleaseconsider my comments. 150577 23 40214 eric 2009-09-28 11:36:01 -0700 Comment on attachment 40214 Proposed patch Given that Darin asked for comments above, I don't think this is ready for automated commit. cq-. You're welcome to make similar fixes as you land this by hand, or to post a new patch with corrections that can be cq+'d. Your call. 150808 24 tkent 2009-09-28 23:25:23 -0700 Thank you for the comments. I'll update the patch after Bug#29796 is landed. 151045 25 40214 eric 2009-09-29 14:10:58 -0700 Comment on attachment 40214 Proposed patch Removing Darin Adler's r+ from this obsolete patch (so that it doesn't show up in our list of patches to commit). 151157 26 tkent 2009-09-29 19:31:48 -0700 (In reply to comment #22) > > + const_cast<HTMLTextAreaElement*>(this)->updateValue(); > > As a rule, we should not use const_cast. Instead we should use mutable. I can revert updateValue() to const by adding "mutable" to m_isDirty, but the current updateValue() has const_cast for setFormControlValueMatchesRenderer(). Do you think the const_cast in the current code is reasonable? Should we make setFormControlValueMatchesRender() const, or make value() non-const? 151165 27 40343 tkent 2009-09-29 22:23:04 -0700 Created attachment 40343 Proposed patch (rev.2) - Follow Darin's comments - Rename parameter names of setMaxLength() An existing const_cast in updateValue() remains. 151286 28 darin 2009-09-30 10:13:50 -0700 (In reply to comment #26) > the > current updateValue() has const_cast for setFormControlValueMatchesRenderer(). > Do you think the const_cast in the current code is reasonable? Should we make > setFormControlValueMatchesRender() const, or make value() non-const? The right way to do this is to: 1) Decide which functions are "conceptually const" at a high level; which ones run without changing the state of the object. 2) Mark those functions as const. 3) Find cases where these const functions need to call non-const ones, and figure out why. Resolve this either by changing the caller to be non-const, or the called function to be const. 4) Make data members mutable as needed. But there's no need to resolve this for existing code just to write new code. For your specific question, I think that we should probably make setFormControlValueMatchesRender() const. 151288 29 40343 darin 2009-09-30 10:16:12 -0700 Comment on attachment 40343 Proposed patch (rev.2) I think later we might find an even better name than m_isDirty since that's a bit vague -- dirty with respect to what? But I think it's already a pretty good. r=me 151421 30 tkent 2009-09-30 18:17:54 -0700 (In reply to comment #29) > (From update of attachment 40343 [details]) > I think later we might find an even better name than m_isDirty since that's a > bit vague -- dirty with respect to what? But I think it's already a pretty > good. m_isDirty" was taken from "dirty value flag" in the HTML5 spec. http://www.whatwg.org/specs/web-apps/current-work/multipage/the-button-element.html#concept-textarea-dirty I think it is very clear for the spec readers, and m_edited or m_userEdited might be better for others. 151459 31 40343 commit-queue 2009-09-30 22:49:46 -0700 Comment on attachment 40343 Proposed patch (rev.2) Clearing flags on attachment: 40343 Committed r48959: <http://trac.webkit.org/changeset/48959> 151460 32 commit-queue 2009-09-30 22:49:52 -0700 All reviewed patches have been landed. Closing bug. 40214 2009-09-27 21:11:47 -0700 2009-09-29 14:10:58 -0700 Proposed patch 0001-toolong-1.patch text/plain 15989 tkent RnJvbSAwYWE3OGQ2MzFmODYwNDRjMjJjNzY3ZDhkYzc3NjU5MGQ3ZTU4MWZlIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBLZW50IFRhbXVyYSA8dGtlbnRAY2hyb21pdW0ub3JnPgpEYXRl OiBNb24sIDI4IFNlcCAyMDA5IDEzOjEwOjA5ICswOTAwClN1YmplY3Q6IFtQQVRDSF0gdG9vbG9u Zy0xCgotLS0KIExheW91dFRlc3RzL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHwgICAxNiArKysrKysrCiAuLi4vZm9ybXMvVmFsaWRpdHlTdGF0ZS10b29Mb25nLWlucHV0 LWV4cGVjdGVkLnR4dCB8ICAgMjAgKysrKysrKysrCiAuLi4vZmFzdC9mb3Jtcy9WYWxpZGl0eVN0 YXRlLXRvb0xvbmctaW5wdXQuaHRtbCAgICB8ICAgMTMgKysrKysrCiAuLi4vVmFsaWRpdHlTdGF0 ZS10b29Mb25nLXRleHRhcmVhLWV4cGVjdGVkLnR4dCAgICB8ICAgMTggKysrKysrKysKIC4uLi9m YXN0L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy10ZXh0YXJlYS5odG1sIHwgICAxMyArKysr KysKIC4uLi9zY3JpcHQtdGVzdHMvVmFsaWRpdHlTdGF0ZS10b29Mb25nLWlucHV0LmpzICAgIHwg ICA0NCArKysrKysrKysrKysrKysrKysrKwogLi4uL3NjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRl LXRvb0xvbmctdGV4dGFyZWEuanMgfCAgIDM3ICsrKysrKysrKysrKysrKysKIFdlYkNvcmUvQ2hh bmdlTG9nICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgIHwgICAyOCArKysrKysrKysr KysKIFdlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmggICAgICAgICAgICAgIHwg ICAgMSArCiBXZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAgICAgICAgICAgICAgICAg ICB8ICAgMzMgKysrKysrKysrKysrKysrCiBXZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5o ICAgICAgICAgICAgICAgICAgICB8ICAgIDEgKwogV2ViQ29yZS9odG1sL0hUTUxUZXh0QXJlYUVs ZW1lbnQuY3BwICAgICAgICAgICAgICAgfCAgIDIwICsrKysrKysrLQogV2ViQ29yZS9odG1sL0hU TUxUZXh0QXJlYUVsZW1lbnQuaCAgICAgICAgICAgICAgICAgfCAgICA2ICsrLQogV2ViQ29yZS9o dG1sL1ZhbGlkaXR5U3RhdGUuaCAgICAgICAgICAgICAgICAgICAgICAgfCAgICAyICstCiAxNCBm aWxlcyBjaGFuZ2VkLCAyNDYgaW5zZXJ0aW9ucygrKSwgNiBkZWxldGlvbnMoLSkKIGNyZWF0ZSBt b2RlIDEwMDY0NCBMYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy1p bnB1dC1leHBlY3RlZC50eHQKIGNyZWF0ZSBtb2RlIDEwMDY0NCBMYXlvdXRUZXN0cy9mYXN0L2Zv cm1zL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy1pbnB1dC5odG1sCiBjcmVhdGUgbW9kZSAxMDA2NDQg TGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFyZWEtZXhw ZWN0ZWQudHh0CiBjcmVhdGUgbW9kZSAxMDA2NDQgTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9WYWxp ZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFyZWEuaHRtbAogY3JlYXRlIG1vZGUgMTAwNjQ0IExheW91 dFRlc3RzL2Zhc3QvZm9ybXMvc2NyaXB0LXRlc3RzL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy1pbnB1 dC5qcwogY3JlYXRlIG1vZGUgMTAwNjQ0IExheW91dFRlc3RzL2Zhc3QvZm9ybXMvc2NyaXB0LXRl c3RzL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy10ZXh0YXJlYS5qcwoKZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA2MzU2ZWUwLi42 N2EwYTEwIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5b3V0VGVz dHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTkgQEAKKzIwMDktMDktMjcgIEtlbnQgVGFtdXJhICA8 dGtlbnRAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEp LgorCisgICAgICAgIEFkZCBWYWxpZGl0eVN0YXRlLnRvb0xvbmcgc3VwcG9ydCBmb3IgPGlucHV0 PiBhbmQgPHRleHRhcmVhPi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTI3NDU0CisKKyAgICAgICAgTmVlZCBhIHNob3J0IGRlc2NyaXB0aW9uIGFuZCBi dWcgVVJMIChPT1BTISkKKworICAgICAgICAqIGZhc3QvZm9ybXMvVmFsaWRpdHlTdGF0ZS10b29M b25nLWlucHV0LWV4cGVjdGVkLnR4dDogQWRkZWQuCisgICAgICAgICogZmFzdC9mb3Jtcy9WYWxp ZGl0eVN0YXRlLXRvb0xvbmctaW5wdXQuaHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9mb3Jt cy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFyZWEtZXhwZWN0ZWQudHh0OiBBZGRlZC4KKyAg ICAgICAgKiBmYXN0L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy10ZXh0YXJlYS5odG1sOiBB ZGRlZC4KKyAgICAgICAgKiBmYXN0L2Zvcm1zL3NjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRlLXRv b0xvbmctaW5wdXQuanM6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZm9ybXMvc2NyaXB0LXRlc3Rz L1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy10ZXh0YXJlYS5qczogQWRkZWQuCisKIDIwMDktMDktMjcg IFNhbSBXZWluaWcgIDxzYW1Ad2Via2l0Lm9yZz4KIAogICAgICAgICBSZXZpZXdlZCBieSBEYW4g QmVybnN0ZWluLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9WYWxpZGl0eVN0 YXRlLXRvb0xvbmctaW5wdXQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9W YWxpZGl0eVN0YXRlLXRvb0xvbmctaW5wdXQtZXhwZWN0ZWQudHh0Cm5ldyBmaWxlIG1vZGUgMTAw NjQ0CmluZGV4IDAwMDAwMDAuLjk0NWI5YjMKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0 cy9mYXN0L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy1pbnB1dC1leHBlY3RlZC50eHQKQEAg LTAsMCArMSwyMCBAQAorVGVzdHMgZm9yIHRvb0xvbmcgZmxhZyB3aXRoIDxpbnB1dD4gZWxlbWVu dHMuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAiUEFTUyIgbWVzc2Fn ZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCitQQVNTIGlucHV0LnZhbGlkaXR5 LnRvb0xvbmcgaXMgZmFsc2UKK1BBU1MgaW5wdXQudmFsdWUubGVuZ3RoIGlzIDUKK1BBU1MgaW5w dXQudmFsaWRpdHkudG9vTG9uZyBpcyBmYWxzZQorUEFTUyBpbnB1dC52YWx1ZS5sZW5ndGggaXMg NgorUEFTUyBpbnB1dC52YWxpZGl0eS50b29Mb25nIGlzIGZhbHNlCitQQVNTIGlucHV0LnZhbHVl Lmxlbmd0aCBpcyA0CitQQVNTIGlucHV0LnZhbGlkaXR5LnRvb0xvbmcgaXMgdHJ1ZQorUEFTUyBp bnB1dC52YWxpZGl0eS50b29Mb25nIGlzIGZhbHNlCitQQVNTIGlucHV0LnZhbGlkaXR5LnRvb0xv bmcgaXMgdHJ1ZQorUEFTUyBpbnB1dC52YWxpZGl0eS50b29Mb25nIGlzIHRydWUKK1BBU1MgaW5w dXQudmFsaWRpdHkudG9vTG9uZyBpcyBmYWxzZQorUEFTUyBzdWNjZXNzZnVsbHlQYXJzZWQgaXMg dHJ1ZQorCitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3QvZm9y bXMvVmFsaWRpdHlTdGF0ZS10b29Mb25nLWlucHV0Lmh0bWwgYi9MYXlvdXRUZXN0cy9mYXN0L2Zv cm1zL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy1pbnB1dC5odG1sCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjgyNmY4YjIKLS0tIC9kZXYvbnVsbAorKysgYi9MYXlvdXRUZXN0cy9m YXN0L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy1pbnB1dC5odG1sCkBAIC0wLDAgKzEsMTMg QEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vSUVURi8vRFREIEhUTUwvL0VOIj4KKzxodG1s PgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4uL2Zhc3QvanMvcmVz b3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8uLi9mYXN0L2pzL3Jl c291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8Ym9keT4KKzxwIGlk PSJkZXNjcmlwdGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+Cis8c2NyaXB0IHNy Yz0ic2NyaXB0LXRlc3RzL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy1pbnB1dC5qcyI+PC9zY3JpcHQ+ Cis8c2NyaXB0IHNyYz0iLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVzdC1wb3N0LmpzIj48 L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL2Zhc3Qv Zm9ybXMvVmFsaWRpdHlTdGF0ZS10b29Mb25nLXRleHRhcmVhLWV4cGVjdGVkLnR4dCBiL0xheW91 dFRlc3RzL2Zhc3QvZm9ybXMvVmFsaWRpdHlTdGF0ZS10b29Mb25nLXRleHRhcmVhLWV4cGVjdGVk LnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kOWU1YmI1Ci0tLSAvZGV2 L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9WYWxpZGl0eVN0YXRlLXRvb0xvbmct dGV4dGFyZWEtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTggQEAKK1Rlc3RzIGZvciB0b29Mb25n IGZsYWcgd2l0aCA8dGV4dGFyZWE+IGVsZW1lbnRzLgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBz ZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVU RSIuCisKKworUEFTUyB0ZXh0YXJlYS52YWxpZGl0eS50b29Mb25nIGlzIGZhbHNlCitQQVNTIHRl eHRhcmVhLnZhbHVlLmxlbmd0aCBpcyA1CitQQVNTIHRleHRhcmVhLnZhbGlkaXR5LnRvb0xvbmcg aXMgZmFsc2UKK1BBU1MgdGV4dGFyZWEudmFsdWUubGVuZ3RoIGlzIDYKK1BBU1MgdGV4dGFyZWEu dmFsaWRpdHkudG9vTG9uZyBpcyBmYWxzZQorUEFTUyB0ZXh0YXJlYS52YWx1ZS5sZW5ndGggaXMg NAorUEFTUyB0ZXh0YXJlYS52YWxpZGl0eS50b29Mb25nIGlzIHRydWUKK1BBU1MgdGV4dGFyZWEu dmFsaWRpdHkudG9vTG9uZyBpcyBmYWxzZQorUEFTUyB0ZXh0YXJlYS52YWxpZGl0eS50b29Mb25n IGlzIHRydWUKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVU RQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdG9v TG9uZy10ZXh0YXJlYS5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9WYWxpZGl0eVN0YXRl LXRvb0xvbmctdGV4dGFyZWEuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAw Li5iMWQ4MDMwCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9WYWxp ZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFyZWEuaHRtbApAQCAtMCwwICsxLDEzIEBACis8IURPQ1RZ UEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgor PGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10 ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMt dGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cCBpZD0iZGVzY3JpcHRp b24iPjwvcD4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBzcmM9InNjcmlwdC10 ZXN0cy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFyZWEuanMiPjwvc2NyaXB0PgorPHNjcmlw dCBzcmM9Ii4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5qcyI+PC9zY3JpcHQ+ Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3Nj cmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctaW5wdXQuanMgYi9MYXlvdXRUZXN0cy9m YXN0L2Zvcm1zL3NjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctaW5wdXQuanMKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZGM2MTA5ZQotLS0gL2Rldi9udWxsCisr KyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvc2NyaXB0LXRlc3RzL1ZhbGlkaXR5U3RhdGUtdG9v TG9uZy1pbnB1dC5qcwpAQCAtMCwwICsxLDQ0IEBACitkZXNjcmlwdGlvbignVGVzdHMgZm9yIHRv b0xvbmcgZmxhZyB3aXRoICZsdDtpbnB1dD4gZWxlbWVudHMuJyk7CisKK3ZhciBpbnB1dCA9IGRv Y3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2lucHV0Jyk7Citkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxk KGlucHV0KTsKKworLy8gTm8gbWF4bGVuZ3RoIGFuZCBubyB2YWx1ZQorc2hvdWxkQmVGYWxzZSgn aW5wdXQudmFsaWRpdHkudG9vTG9uZycpOworCisvLyBOb24tZGlydHkgdmFsdWUuCitpbnB1dC5z ZXRBdHRyaWJ1dGUoJ3ZhbHVlJywgJ2FiY2RlJyk7CitpbnB1dC5tYXhMZW5ndGggPSAzOworc2hv dWxkQmUoJ2lucHV0LnZhbHVlLmxlbmd0aCcsICc1Jyk7CitzaG91bGRCZUZhbHNlKCdpbnB1dC52 YWxpZGl0eS50b29Mb25nJyk7CisKK2lucHV0LnNldEF0dHJpYnV0ZSgndmFsdWUnLCAnYWJjZGVm Jyk7CitzaG91bGRCZSgnaW5wdXQudmFsdWUubGVuZ3RoJywgJzYnKTsKK3Nob3VsZEJlRmFsc2Uo J2lucHV0LnZhbGlkaXR5LnRvb0xvbmcnKTsKKworLy8gRGlydHkgdmFsdWUgYW5kIGxvbmdlciB0 aGFuIG1heExlbmd0aC4KK2lucHV0ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVudCgnaW5wdXQnKTsK K2RvY3VtZW50LmJvZHkuYXBwZW5kQ2hpbGQoaW5wdXQpOworaW5wdXQuc2V0QXR0cmlidXRlKCd2 YWx1ZScsICdhYmNkZScpOworaW5wdXQubWF4TGVuZ3RoID0gMzsKK2lucHV0LmZvY3VzKCk7Citp bnB1dC5zZXRTZWxlY3Rpb25SYW5nZSg1LCA1KTsgIC8vIE1vdmUgdGhlIGN1cnNvciBhdCB0aGUg ZW5kLgorZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ2RlbGV0ZScpOworc2hvdWxkQmUoJ2lucHV0LnZh bHVlLmxlbmd0aCcsICc0Jyk7CitzaG91bGRCZVRydWUoJ2lucHV0LnZhbGlkaXR5LnRvb0xvbmcn KTsKKy8vIE1ha2UgdGhlIHZhbHVlIDw9bWF4TGVuZ3RoLgorZG9jdW1lbnQuZXhlY0NvbW1hbmQo J2RlbGV0ZScpOworc2hvdWxkQmVGYWxzZSgnaW5wdXQudmFsaWRpdHkudG9vTG9uZycpOworCisv LyBTZXRzIGEgdmFsdWUgdmlhIERPTSBwcm9wZXJ0eS4KK2lucHV0LnZhbHVlID0gJ2FiY2RlJzsK K3Nob3VsZEJlVHJ1ZSgnaW5wdXQudmFsaWRpdHkudG9vTG9uZycpOworCisvLyBDaGFuZ2UgdGhl IHR5cGUgd2l0aCBhIHRvbyBsb25nIHZhbHVlLgoraW5wdXQudHlwZSA9ICdzZWFyY2gnOworc2hv dWxkQmVUcnVlKCdpbnB1dC52YWxpZGl0eS50b29Mb25nJyk7CisKK2lucHV0LnR5cGUgPSAnbnVt YmVyJzsKK3Nob3VsZEJlRmFsc2UoJ2lucHV0LnZhbGlkaXR5LnRvb0xvbmcnKTsKKwordmFyIHN1 Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zv cm1zL3NjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFyZWEuanMgYi9MYXlv dXRUZXN0cy9mYXN0L2Zvcm1zL3NjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctdGV4 dGFyZWEuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uNGExZmUxNwotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvc2NyaXB0LXRlc3RzL1ZhbGlk aXR5U3RhdGUtdG9vTG9uZy10ZXh0YXJlYS5qcwpAQCAtMCwwICsxLDM3IEBACitkZXNjcmlwdGlv bignVGVzdHMgZm9yIHRvb0xvbmcgZmxhZyB3aXRoICZsdDt0ZXh0YXJlYT4gZWxlbWVudHMuJyk7 CisKK3ZhciB0ZXh0YXJlYSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ3RleHRhcmVhJyk7Citk b2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHRleHRhcmVhKTsKKworLy8gTm8gbWF4bGVuZ3RoIGFu ZCBubyB2YWx1ZQorc2hvdWxkQmVGYWxzZSgndGV4dGFyZWEudmFsaWRpdHkudG9vTG9uZycpOwor CisvLyBOb24tZGlydHkgdmFsdWUuCit0ZXh0YXJlYS5kZWZhdWx0VmFsdWUgPSAnYWJjZGUnOwor dGV4dGFyZWEubWF4TGVuZ3RoID0gMzsKK3Nob3VsZEJlKCd0ZXh0YXJlYS52YWx1ZS5sZW5ndGgn LCAnNScpOworc2hvdWxkQmVGYWxzZSgndGV4dGFyZWEudmFsaWRpdHkudG9vTG9uZycpOworCit0 ZXh0YXJlYS5kZWZhdWx0VmFsdWUgPSAnYWJjZGVmJzsKK3Nob3VsZEJlKCd0ZXh0YXJlYS52YWx1 ZS5sZW5ndGgnLCAnNicpOworc2hvdWxkQmVGYWxzZSgndGV4dGFyZWEudmFsaWRpdHkudG9vTG9u ZycpOworCisvLyBEaXJ0eSB2YWx1ZSBhbmQgbG9uZ2VyIHRoYW4gbWF4TGVuZ3RoLgordGV4dGFy ZWEgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCd0ZXh0YXJlYScpOworZG9jdW1lbnQuYm9keS5h cHBlbmRDaGlsZCh0ZXh0YXJlYSk7Cit0ZXh0YXJlYS5kZWZhdWx0VmFsdWUgPSAnYWJjZGUnOwor dGV4dGFyZWEubWF4TGVuZ3RoID0gMzsKK3RleHRhcmVhLmZvY3VzKCk7Cit0ZXh0YXJlYS5zZXRT ZWxlY3Rpb25SYW5nZSg1LCA1KTsgIC8vIE1vdmUgdGhlIGN1cnNvciBhdCB0aGUgZW5kLgorZG9j dW1lbnQuZXhlY0NvbW1hbmQoJ2RlbGV0ZScpOworc2hvdWxkQmUoJ3RleHRhcmVhLnZhbHVlLmxl bmd0aCcsICc0Jyk7CitzaG91bGRCZVRydWUoJ3RleHRhcmVhLnZhbGlkaXR5LnRvb0xvbmcnKTsK Ky8vIE1ha2UgdGhlIHZhbHVlIDw9bWF4TGVuZ3RoLgorZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ2Rl bGV0ZScpOworc2hvdWxkQmVGYWxzZSgndGV4dGFyZWEudmFsaWRpdHkudG9vTG9uZycpOworCisv LyBTZXRzIGEgdmFsdWUgdmlhIERPTSBwcm9wZXJ0eS4KK3RleHRhcmVhLnZhbHVlID0gJ2FiY2Rl JzsKK3Nob3VsZEJlVHJ1ZSgndGV4dGFyZWEudmFsaWRpdHkudG9vTG9uZycpOworCit2YXIgc3Vj Y2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvQ2hhbmdlTG9nIGIv V2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMDM2ZmI1ZS4uOWMzYjUwZSAxMDA2NDQKLS0tIGEvV2Vi Q29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEsMyArMSwzMSBAQAor MjAwOS0wOS0yNyAgS2VudCBUYW11cmEgIDx0a2VudEBjaHJvbWl1bS5vcmc+CisKKyAgICAgICAg UmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkIFZhbGlkaXR5U3RhdGUu dG9vTG9uZyBzdXBwb3J0IGZvciA8aW5wdXQ+IGFuZCA8dGV4dGFyZWE+LgorICAgICAgICB0b29M b25nIHNob3VsZCB3b3JrIG9ubHkgZm9yIGBkaXJ0eScgdmFsdWVzLiAgVGhpcyBjaGFuZ2UgaW50 cm9kdWNlcworICAgICAgICBtX2RpcnR5IGZsYWcgZm9yIEhUTUxUZXh0QXJlYUVsZW1lbnQsIGFu ZCAhbV9kYXRhLnZhbHVlKCkuaXNOdWxsKCkKKyAgICAgICAgd29ya3MgYXMgYSBkaXJ0eSBmbGFn IGZvciBIVE1MSW5wdXRFbGVtZW50LgorICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9Mjc0NTQKKworICAgICAgICBUZXN0czogZmFzdC9mb3Jtcy9WYWxpZGl0 eVN0YXRlLXRvb0xvbmctaW5wdXQuaHRtbAorICAgICAgICAgICAgICAgZmFzdC9mb3Jtcy9WYWxp ZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFyZWEuaHRtbAorCisgICAgICAgICogaHRtbC9IVE1MRm9y bUNvbnRyb2xFbGVtZW50Lmg6CisgICAgICAgIChXZWJDb3JlOjpIVE1MRm9ybUNvbnRyb2xFbGVt ZW50Ojp0b29Mb25nKToKKyAgICAgICAgKiBodG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwOgorICAg ICAgICAoV2ViQ29yZTo6SFRNTElucHV0RWxlbWVudDo6dG9vTG9uZyk6CisgICAgICAgICogaHRt bC9IVE1MSW5wdXRFbGVtZW50Lmg6CisgICAgICAgICogaHRtbC9IVE1MVGV4dEFyZWFFbGVtZW50 LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxUZXh0QXJlYUVsZW1lbnQ6OkhUTUxUZXh0QXJl YUVsZW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFRleHRBcmVhRWxlbWVudDo6cmVzZXQp OgorICAgICAgICAoV2ViQ29yZTo6SFRNTFRleHRBcmVhRWxlbWVudDo6dXBkYXRlVmFsdWUpOgor ICAgICAgICAoV2ViQ29yZTo6SFRNTFRleHRBcmVhRWxlbWVudDo6dmFsdWUpOgorICAgICAgICAo V2ViQ29yZTo6SFRNTFRleHRBcmVhRWxlbWVudDo6dG9vTG9uZyk6CisgICAgICAgICogaHRtbC9I VE1MVGV4dEFyZWFFbGVtZW50Lmg6CisgICAgICAgICogaHRtbC9WYWxpZGl0eVN0YXRlLmg6Cisg ICAgICAgIChXZWJDb3JlOjpWYWxpZGl0eVN0YXRlOjp0b29Mb25nKToKKwogMjAwOS0wOS0yNyAg U2FtIFdlaW5pZyAgPHNhbUB3ZWJraXQub3JnPgogCiAgICAgICAgIFJldmlld2VkIGJ5IERhbiBC ZXJuc3RlaW4uCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVu dC5oIGIvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbEVsZW1lbnQuaAppbmRleCA3YjNjZmJk Li40MzIzZTFiIDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVu dC5oCisrKyBiL1dlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmgKQEAgLTExMCw2 ICsxMTAsNyBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIGJvb2wgdmFsdWVNaXNzaW5nKCkgY29u c3QgeyByZXR1cm4gZmFsc2U7IH0KICAgICB2aXJ0dWFsIGJvb2wgcGF0dGVybk1pc21hdGNoKCkg Y29uc3QgeyByZXR1cm4gZmFsc2U7IH0KKyAgICB2aXJ0dWFsIGJvb2wgdG9vTG9uZygpIGNvbnN0 IHsgcmV0dXJuIGZhbHNlOyB9CiAKICAgICB2b2lkIGZvcm1EZXN0cm95ZWQoKSB7IG1fZm9ybSA9 IDA7IH0KIApkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwIGIv V2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuY3BwCmluZGV4IDBhZWZlN2YuLjAwMzRhMmIg MTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcAorKysgYi9XZWJD b3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKQEAgLTE5NSw2ICsxOTUsMzkgQEAgYm9vbCBI VE1MSW5wdXRFbGVtZW50OjpwYXR0ZXJuTWlzbWF0Y2goKSBjb25zdAogICAgIHJldHVybiBmYWxz ZTsKIH0KIAorYm9vbCBIVE1MSW5wdXRFbGVtZW50Ojp0b29Mb25nKCkgY29uc3QKK3sKKyAgICBz d2l0Y2ggKGlucHV0VHlwZSgpKSB7CisgICAgY2FzZSBFTUFJTDoKKyAgICBjYXNlIFBBU1NXT1JE OgorICAgIGNhc2UgU0VBUkNIOgorICAgIGNhc2UgVEVMRVBIT05FOgorICAgIGNhc2UgVEVYVDoK KyAgICBjYXNlIFVSTDogeworICAgICAgICBib29sIHVzZXJFZGl0dGVkID0gIW1fZGF0YS52YWx1 ZSgpLmlzTnVsbCgpOyAvLyB0b29Mb25nIG11c3QgYmUgZmFsc2UgZm9yIHRoZSBkZWZhdWx0IHZh bHVlLgorICAgICAgICBpZiAodXNlckVkaXR0ZWQgJiYgaGFzQXR0cmlidXRlKG1heGxlbmd0aEF0 dHIpKSB7CisgICAgICAgICAgICAvLyBJdCdzIHNhZmUgdG8gY2FzdCBtYXhMZW5ndGgoKSB0byB1 bnNpZ25lZCBiZWNhdXNlIG1heExlbmd0aCgpIGNhbiBuZXZlciBiZSBuZWdhdGl2ZS4KKyAgICAg ICAgICAgIHJldHVybiB2YWx1ZSgpLmxlbmd0aCgpID4gc3RhdGljX2Nhc3Q8dW5zaWduZWQ+KG1h eExlbmd0aCgpKTsKKyAgICAgICAgfQorICAgICAgICBicmVhazsKKyAgICB9CisgICAgY2FzZSBC VVRUT046CisgICAgY2FzZSBDSEVDS0JPWDoKKyAgICBjYXNlIENPTE9SOgorICAgIGNhc2UgRklM RToKKyAgICBjYXNlIEhJRERFTjoKKyAgICBjYXNlIElNQUdFOgorICAgIGNhc2UgSVNJTkRFWDoK KyAgICBjYXNlIE5VTUJFUjoKKyAgICBjYXNlIFJBRElPOgorICAgIGNhc2UgUkFOR0U6CisgICAg Y2FzZSBSRVNFVDoKKyAgICBjYXNlIFNVQk1JVDoKKyAgICAgICAgYnJlYWs7CisgICAgfQorICAg IHJldHVybiBmYWxzZTsKK30KKwogc3RhdGljIGlubGluZSBDaGVja2VkUmFkaW9CdXR0b25zJiBj aGVja2VkUmFkaW9CdXR0b25zKGNvbnN0IEhUTUxJbnB1dEVsZW1lbnQgKmVsZW1lbnQpCiB7CiAg ICAgaWYgKEhUTUxGb3JtRWxlbWVudCogZm9ybSA9IGVsZW1lbnQtPmZvcm0oKSkKZGlmZiAtLWdp dCBhL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmggYi9XZWJDb3JlL2h0bWwvSFRNTElu cHV0RWxlbWVudC5oCmluZGV4IDYzZDE2MzQuLmRkN2IxODIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUv aHRtbC9IVE1MSW5wdXRFbGVtZW50LmgKKysrIGIvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1l bnQuaApAQCAtOTMsNiArOTMsNyBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIGJvb2wgdmFsdWVN aXNzaW5nKCkgY29uc3Q7CiAgICAgdmlydHVhbCBib29sIHBhdHRlcm5NaXNtYXRjaCgpIGNvbnN0 OworICAgIHZpcnR1YWwgYm9vbCB0b29Mb25nKCkgY29uc3Q7CiAKICAgICBib29sIGlzVGV4dEJ1 dHRvbigpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZSA9PSBTVUJNSVQgfHwgbV90eXBlID09IFJFU0VU IHx8IG1fdHlwZSA9PSBCVVRUT047IH0KICAgICB2aXJ0dWFsIGJvb2wgaXNSYWRpb0J1dHRvbigp IGNvbnN0IHsgcmV0dXJuIG1fdHlwZSA9PSBSQURJTzsgfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9o dG1sL0hUTUxUZXh0QXJlYUVsZW1lbnQuY3BwIGIvV2ViQ29yZS9odG1sL0hUTUxUZXh0QXJlYUVs ZW1lbnQuY3BwCmluZGV4IGYzOThmYzIuLmVhMDkzZTUgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRt bC9IVE1MVGV4dEFyZWFFbGVtZW50LmNwcAorKysgYi9XZWJDb3JlL2h0bWwvSFRNTFRleHRBcmVh RWxlbWVudC5jcHAKQEAgLTY5LDYgKzY5LDcgQEAgSFRNTFRleHRBcmVhRWxlbWVudDo6SFRNTFRl eHRBcmVhRWxlbWVudChjb25zdCBRdWFsaWZpZWROYW1lJiB0YWdOYW1lLCBEb2N1bWVudCoKICAg ICAsIG1fd3JhcChTb2Z0V3JhcCkKICAgICAsIG1fY2FjaGVkU2VsZWN0aW9uU3RhcnQoLTEpCiAg ICAgLCBtX2NhY2hlZFNlbGVjdGlvbkVuZCgtMSkKKyAgICAsIG1faXNEaXJ0eShmYWxzZSkKIHsK ICAgICBBU1NFUlQoaGFzVGFnTmFtZSh0ZXh0YXJlYVRhZykpOwogICAgIHNldEZvcm1Db250cm9s VmFsdWVNYXRjaGVzUmVuZGVyZXIodHJ1ZSk7CkBAIC0yMzAsNiArMjMxLDcgQEAgYm9vbCBIVE1M VGV4dEFyZWFFbGVtZW50OjphcHBlbmRGb3JtRGF0YShGb3JtRGF0YUxpc3QmIGVuY29kaW5nLCBi b29sKQogdm9pZCBIVE1MVGV4dEFyZWFFbGVtZW50OjpyZXNldCgpCiB7CiAgICAgc2V0VmFsdWUo ZGVmYXVsdFZhbHVlKCkpOworICAgIG1faXNEaXJ0eSA9IGZhbHNlOwogfQogCiBib29sIEhUTUxU ZXh0QXJlYUVsZW1lbnQ6OmlzS2V5Ym9hcmRGb2N1c2FibGUoS2V5Ym9hcmRFdmVudCopIGNvbnN0 CkBAIC0zMDYsMjAgKzMwOCwyMSBAQCB2b2lkIEhUTUxUZXh0QXJlYUVsZW1lbnQ6OnJlbmRlcmVy V2lsbEJlRGVzdHJveWVkKCkKICAgICB1cGRhdGVWYWx1ZSgpOwogfQogCi12b2lkIEhUTUxUZXh0 QXJlYUVsZW1lbnQ6OnVwZGF0ZVZhbHVlKCkgY29uc3QKK3ZvaWQgSFRNTFRleHRBcmVhRWxlbWVu dDo6dXBkYXRlVmFsdWUoKQogewogICAgIGlmIChmb3JtQ29udHJvbFZhbHVlTWF0Y2hlc1JlbmRl cmVyKCkpCiAgICAgICAgIHJldHVybjsKIAogICAgIEFTU0VSVChyZW5kZXJlcigpKTsKICAgICBt X3ZhbHVlID0gdG9SZW5kZXJUZXh0Q29udHJvbChyZW5kZXJlcigpKS0+dGV4dCgpOwotICAgIGNv bnN0X2Nhc3Q8SFRNTFRleHRBcmVhRWxlbWVudCo+KHRoaXMpLT5zZXRGb3JtQ29udHJvbFZhbHVl TWF0Y2hlc1JlbmRlcmVyKHRydWUpOworICAgIHNldEZvcm1Db250cm9sVmFsdWVNYXRjaGVzUmVu ZGVyZXIodHJ1ZSk7CiAgICAgbm90aWZ5Rm9ybVN0YXRlQ2hhbmdlZCh0aGlzKTsKKyAgICBtX2lz RGlydHkgPSB0cnVlOwogfQogCiBTdHJpbmcgSFRNTFRleHRBcmVhRWxlbWVudDo6dmFsdWUoKSBj b25zdAogewotICAgIHVwZGF0ZVZhbHVlKCk7CisgICAgY29uc3RfY2FzdDxIVE1MVGV4dEFyZWFF bGVtZW50Kj4odGhpcyktPnVwZGF0ZVZhbHVlKCk7CiAgICAgcmV0dXJuIG1fdmFsdWU7CiB9CiAK QEAgLTQxMSw2ICs0MTQsMTcgQEAgdm9pZCBIVE1MVGV4dEFyZWFFbGVtZW50OjpzZXRNYXhMZW5n dGgodW5zaWduZWQgbmV3VmFsdWUpCiAgICAgc2V0QXR0cmlidXRlKG1heGxlbmd0aEF0dHIsIFN0 cmluZzo6bnVtYmVyKG5ld1ZhbHVlKSk7CiB9CiAKK2Jvb2wgSFRNTFRleHRBcmVhRWxlbWVudDo6 dG9vTG9uZygpIGNvbnN0Cit7CisgICAgaWYgKG1faXNEaXJ0eSkgeworICAgICAgICBib29sIG9r OworICAgICAgICB1bnNpZ25lZCBtYXhMZW5ndGggPSBnZXRBdHRyaWJ1dGUobWF4bGVuZ3RoQXR0 cikuc3RyaW5nKCkudG9VSW50KCZvayk7CisgICAgICAgIGlmIChvaykKKyAgICAgICAgICAgIHJl dHVybiB2YWx1ZSgpLmxlbmd0aCgpID4gbWF4TGVuZ3RoOworICAgIH0KKyAgICByZXR1cm4gZmFs c2U7Cit9CisKIHZvaWQgSFRNTFRleHRBcmVhRWxlbWVudDo6YWNjZXNzS2V5QWN0aW9uKGJvb2wp CiB7CiAgICAgZm9jdXMoKTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRtbC9IVE1MVGV4dEFyZWFF bGVtZW50LmggYi9XZWJDb3JlL2h0bWwvSFRNTFRleHRBcmVhRWxlbWVudC5oCmluZGV4IGVmOTZm YzUuLjQyODQ3MGIgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9IVE1MVGV4dEFyZWFFbGVtZW50 LmgKKysrIGIvV2ViQ29yZS9odG1sL0hUTUxUZXh0QXJlYUVsZW1lbnQuaApAQCAtODEsNyArODEs OCBAQCBwdWJsaWM6CiAgICAgaW50IHRleHRMZW5ndGgoKSBjb25zdCB7IHJldHVybiB2YWx1ZSgp Lmxlbmd0aCgpOyB9CiAgICAgdW5zaWduZWQgbWF4TGVuZ3RoKCkgY29uc3Q7CiAgICAgdm9pZCBz ZXRNYXhMZW5ndGgodW5zaWduZWQpOwotICAgIAorICAgIHZpcnR1YWwgYm9vbCB0b29Mb25nKCkg Y29uc3Q7CisKICAgICB2b2lkIHJlbmRlcmVyV2lsbEJlRGVzdHJveWVkKCk7CiAgICAgCiAgICAg dmlydHVhbCB2b2lkIGFjY2Vzc0tleUFjdGlvbihib29sIHNlbmRUb0FueUVsZW1lbnQpOwpAQCAt MTAyLDcgKzEwMyw3IEBAIHByaXZhdGU6CiAKICAgICB2b2lkIGhhbmRsZUJlZm9yZVRleHRJbnNl cnRlZEV2ZW50KEJlZm9yZVRleHRJbnNlcnRlZEV2ZW50KikgY29uc3Q7CiAgICAgc3RhdGljIFN0 cmluZyBzYW5pdGl6ZVVzZXJJbnB1dFZhbHVlKGNvbnN0IFN0cmluZyYsIHVuc2lnbmVkIG1heExl bmd0aCk7Ci0gICAgdm9pZCB1cGRhdGVWYWx1ZSgpIGNvbnN0OworICAgIHZvaWQgdXBkYXRlVmFs dWUoKTsKIAogICAgIHZpcnR1YWwgYm9vbCBzdXBwb3J0c1BsYWNlaG9sZGVyKCkgY29uc3QgeyBy ZXR1cm4gdHJ1ZTsgfQogICAgIHZpcnR1YWwgYm9vbCBpc0VtcHR5VmFsdWUoKSBjb25zdCB7IHJl dHVybiB2YWx1ZSgpLmlzRW1wdHkoKTsgfQpAQCAtMTE2LDYgKzExNyw3IEBAIHByaXZhdGU6CiAg ICAgbXV0YWJsZSBTdHJpbmcgbV92YWx1ZTsKICAgICBpbnQgbV9jYWNoZWRTZWxlY3Rpb25TdGFy dDsKICAgICBpbnQgbV9jYWNoZWRTZWxlY3Rpb25FbmQ7CisgICAgYm9vbCBtX2lzRGlydHk7CiB9 OwogCiB9IC8vbmFtZXNwYWNlCmRpZmYgLS1naXQgYS9XZWJDb3JlL2h0bWwvVmFsaWRpdHlTdGF0 ZS5oIGIvV2ViQ29yZS9odG1sL1ZhbGlkaXR5U3RhdGUuaAppbmRleCAxYjg3Zjk5Li45YWRjOGZk IDEwMDY0NAotLS0gYS9XZWJDb3JlL2h0bWwvVmFsaWRpdHlTdGF0ZS5oCisrKyBiL1dlYkNvcmUv aHRtbC9WYWxpZGl0eVN0YXRlLmgKQEAgLTQzLDcgKzQzLDcgQEAgbmFtZXNwYWNlIFdlYkNvcmUg ewogICAgICAgICBib29sIHZhbHVlTWlzc2luZygpIHsgcmV0dXJuIGNvbnRyb2woKS0+dmFsdWVN aXNzaW5nKCk7IH0KICAgICAgICAgYm9vbCB0eXBlTWlzbWF0Y2goKTsKICAgICAgICAgYm9vbCBw YXR0ZXJuTWlzbWF0Y2goKSB7IHJldHVybiBjb250cm9sKCktPnBhdHRlcm5NaXNtYXRjaCgpOyB9 Ci0gICAgICAgIGJvb2wgdG9vTG9uZygpIHsgcmV0dXJuIGZhbHNlOyB9CisgICAgICAgIGJvb2wg dG9vTG9uZygpIHsgcmV0dXJuIGNvbnRyb2woKS0+dG9vTG9uZygpOyB9CiAgICAgICAgIGJvb2wg cmFuZ2VVbmRlcmZsb3coKSB7IHJldHVybiBmYWxzZTsgfQogICAgICAgICBib29sIHJhbmdlT3Zl cmZsb3coKSB7IHJldHVybiBmYWxzZTsgfQogICAgICAgICBib29sIHN0ZXBNaXNtYXRjaCgpIHsg cmV0dXJuIGZhbHNlOyB9Ci0tIAoxLjYuMy4zCgo= 40343 2009-09-29 22:23:04 -0700 2009-09-30 22:49:46 -0700 Proposed patch (rev.2) 0001-toolong-2.patch text/plain 16386 tkent RnJvbSBhYWQzMmMyNTdiZjNkZjI2YjMxZjYzYjNlMjg5YjQ3ZTMzYTc0ZTY2IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBLZW50IFRhbXVyYSA8dGtlbnRAY2hyb21pdW0ub3JnPgpEYXRl OiBNb24sIDI4IFNlcCAyMDA5IDEzOjEwOjA5ICswOTAwClN1YmplY3Q6IFtQQVRDSF0gdG9vbG9u Zy0yCgotLS0KIExheW91dFRlc3RzL0NoYW5nZUxvZyAgICAgICAgICAgICAgICAgICAgICAgICAg ICAgIHwgICAxNCArKysrKysKIC4uLi9mb3Jtcy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctaW5wdXQt ZXhwZWN0ZWQudHh0IHwgICAyMCArKysrKysrKysKIC4uLi9mYXN0L2Zvcm1zL1ZhbGlkaXR5U3Rh dGUtdG9vTG9uZy1pbnB1dC5odG1sICAgIHwgICAxMyArKysrKysKIC4uLi9WYWxpZGl0eVN0YXRl LXRvb0xvbmctdGV4dGFyZWEtZXhwZWN0ZWQudHh0ICAgIHwgICAxOCArKysrKysrKwogLi4uL2Zh c3QvZm9ybXMvVmFsaWRpdHlTdGF0ZS10b29Mb25nLXRleHRhcmVhLmh0bWwgfCAgIDEzICsrKysr KwogLi4uL3NjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctaW5wdXQuanMgICAgfCAg IDQ0ICsrKysrKysrKysrKysrKysrKysrCiAuLi4vc2NyaXB0LXRlc3RzL1ZhbGlkaXR5U3RhdGUt dG9vTG9uZy10ZXh0YXJlYS5qcyB8ICAgMzcgKysrKysrKysrKysrKysrKwogV2ViQ29yZS9DaGFu Z2VMb2cgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgICAgfCAgIDM1ICsrKysrKysrKysr KysrKysKIFdlYkNvcmUvaHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmggICAgICAgICAgICAg IHwgICAgMSArCiBXZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAgICAgICAgICAgICAg ICAgICB8ICAgNDQgKysrKysrKysrKysrKysrKysrLS0KIFdlYkNvcmUvaHRtbC9IVE1MSW5wdXRF bGVtZW50LmggICAgICAgICAgICAgICAgICAgIHwgICAgMSArCiBXZWJDb3JlL2h0bWwvSFRNTFRl eHRBcmVhRWxlbWVudC5jcHAgICAgICAgICAgICAgICB8ICAgMTkgKysrKysrKystCiBXZWJDb3Jl L2h0bWwvSFRNTFRleHRBcmVhRWxlbWVudC5oICAgICAgICAgICAgICAgICB8ICAgIDIgKwogV2Vi Q29yZS9odG1sL1ZhbGlkaXR5U3RhdGUuaCAgICAgICAgICAgICAgICAgICAgICAgfCAgICAyICst CiAxNCBmaWxlcyBjaGFuZ2VkLCAyNTYgaW5zZXJ0aW9ucygrKSwgNyBkZWxldGlvbnMoLSkKIGNy ZWF0ZSBtb2RlIDEwMDY0NCBMYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdG9v TG9uZy1pbnB1dC1leHBlY3RlZC50eHQKIGNyZWF0ZSBtb2RlIDEwMDY0NCBMYXlvdXRUZXN0cy9m YXN0L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy1pbnB1dC5odG1sCiBjcmVhdGUgbW9kZSAx MDA2NDQgTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFy ZWEtZXhwZWN0ZWQudHh0CiBjcmVhdGUgbW9kZSAxMDA2NDQgTGF5b3V0VGVzdHMvZmFzdC9mb3Jt cy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFyZWEuaHRtbAogY3JlYXRlIG1vZGUgMTAwNjQ0 IExheW91dFRlc3RzL2Zhc3QvZm9ybXMvc2NyaXB0LXRlc3RzL1ZhbGlkaXR5U3RhdGUtdG9vTG9u Zy1pbnB1dC5qcwogY3JlYXRlIG1vZGUgMTAwNjQ0IExheW91dFRlc3RzL2Zhc3QvZm9ybXMvc2Ny aXB0LXRlc3RzL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy10ZXh0YXJlYS5qcwoKZGlmZiAtLWdpdCBh L0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA0NmY0 MDRjLi41NTM4NTZlIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKKysrIGIvTGF5 b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTcgQEAKKzIwMDktMDktMjcgIEtlbnQgVGFt dXJhICA8dGtlbnRAY2hyb21pdW0ub3JnPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAo T09QUyEpLgorCisgICAgICAgIEFkZCBWYWxpZGl0eVN0YXRlLnRvb0xvbmcgc3VwcG9ydCBmb3Ig PGlucHV0PiBhbmQgPHRleHRhcmVhPi4KKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcv c2hvd19idWcuY2dpP2lkPTI3NDU0CisKKyAgICAgICAgKiBmYXN0L2Zvcm1zL1ZhbGlkaXR5U3Rh dGUtdG9vTG9uZy1pbnB1dC1leHBlY3RlZC50eHQ6IEFkZGVkLgorICAgICAgICAqIGZhc3QvZm9y bXMvVmFsaWRpdHlTdGF0ZS10b29Mb25nLWlucHV0Lmh0bWw6IEFkZGVkLgorICAgICAgICAqIGZh c3QvZm9ybXMvVmFsaWRpdHlTdGF0ZS10b29Mb25nLXRleHRhcmVhLWV4cGVjdGVkLnR4dDogQWRk ZWQuCisgICAgICAgICogZmFzdC9mb3Jtcy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFyZWEu aHRtbDogQWRkZWQuCisgICAgICAgICogZmFzdC9mb3Jtcy9zY3JpcHQtdGVzdHMvVmFsaWRpdHlT dGF0ZS10b29Mb25nLWlucHV0LmpzOiBBZGRlZC4KKyAgICAgICAgKiBmYXN0L2Zvcm1zL3Njcmlw dC10ZXN0cy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFyZWEuanM6IEFkZGVkLgorCiAyMDA5 LTA5LTI5ICBCcmFkeSBFaWRzb24gIDxiZWlkc29uQGFwcGxlLmNvbT4KIAogICAgICAgICBSZXZp ZXdlZCBieSBKb2huIFN1bGxpdmFuLgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvZmFzdC9mb3Jt cy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctaW5wdXQtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMv ZmFzdC9mb3Jtcy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctaW5wdXQtZXhwZWN0ZWQudHh0Cm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjk0NWI5YjMKLS0tIC9kZXYvbnVsbAorKysg Yi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy1pbnB1dC1leHBl Y3RlZC50eHQKQEAgLTAsMCArMSwyMCBAQAorVGVzdHMgZm9yIHRvb0xvbmcgZmxhZyB3aXRoIDxp bnB1dD4gZWxlbWVudHMuCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNlcmllcyBvZiAi UEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKworCitQQVNTIGlu cHV0LnZhbGlkaXR5LnRvb0xvbmcgaXMgZmFsc2UKK1BBU1MgaW5wdXQudmFsdWUubGVuZ3RoIGlz IDUKK1BBU1MgaW5wdXQudmFsaWRpdHkudG9vTG9uZyBpcyBmYWxzZQorUEFTUyBpbnB1dC52YWx1 ZS5sZW5ndGggaXMgNgorUEFTUyBpbnB1dC52YWxpZGl0eS50b29Mb25nIGlzIGZhbHNlCitQQVNT IGlucHV0LnZhbHVlLmxlbmd0aCBpcyA0CitQQVNTIGlucHV0LnZhbGlkaXR5LnRvb0xvbmcgaXMg dHJ1ZQorUEFTUyBpbnB1dC52YWxpZGl0eS50b29Mb25nIGlzIGZhbHNlCitQQVNTIGlucHV0LnZh bGlkaXR5LnRvb0xvbmcgaXMgdHJ1ZQorUEFTUyBpbnB1dC52YWxpZGl0eS50b29Mb25nIGlzIHRy dWUKK1BBU1MgaW5wdXQudmFsaWRpdHkudG9vTG9uZyBpcyBmYWxzZQorUEFTUyBzdWNjZXNzZnVs bHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKZGlmZiAtLWdpdCBhL0xheW91dFRl c3RzL2Zhc3QvZm9ybXMvVmFsaWRpdHlTdGF0ZS10b29Mb25nLWlucHV0Lmh0bWwgYi9MYXlvdXRU ZXN0cy9mYXN0L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy1pbnB1dC5odG1sCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAuLjgyNmY4YjIKLS0tIC9kZXYvbnVsbAorKysgYi9M YXlvdXRUZXN0cy9mYXN0L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy1pbnB1dC5odG1sCkBA IC0wLDAgKzEsMTMgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vSUVURi8vRFREIEhUTUwv L0VOIj4KKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uLy4u L2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQgc3JjPSIuLi8u Li9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXByZS5qcyI+PC9zY3JpcHQ+Cis8L2hlYWQ+Cis8 Ym9keT4KKzxwIGlkPSJkZXNjcmlwdGlvbiI+PC9wPgorPGRpdiBpZD0iY29uc29sZSI+PC9kaXY+ Cis8c2NyaXB0IHNyYz0ic2NyaXB0LXRlc3RzL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy1pbnB1dC5q cyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vLi4vZmFzdC9qcy9yZXNvdXJjZXMvanMtdGVz dC1wb3N0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4KKzwvaHRtbD4KZGlmZiAtLWdpdCBhL0xheW91 dFRlc3RzL2Zhc3QvZm9ybXMvVmFsaWRpdHlTdGF0ZS10b29Mb25nLXRleHRhcmVhLWV4cGVjdGVk LnR4dCBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvVmFsaWRpdHlTdGF0ZS10b29Mb25nLXRleHRh cmVhLWV4cGVjdGVkLnR4dApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwLi5kOWU1 YmI1Ci0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9WYWxpZGl0eVN0 YXRlLXRvb0xvbmctdGV4dGFyZWEtZXhwZWN0ZWQudHh0CkBAIC0wLDAgKzEsMTggQEAKK1Rlc3Rz IGZvciB0b29Mb25nIGZsYWcgd2l0aCA8dGV4dGFyZWE+IGVsZW1lbnRzLgorCitPbiBzdWNjZXNz LCB5b3Ugd2lsbCBzZWUgYSBzZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAi VEVTVCBDT01QTEVURSIuCisKKworUEFTUyB0ZXh0YXJlYS52YWxpZGl0eS50b29Mb25nIGlzIGZh bHNlCitQQVNTIHRleHRhcmVhLnZhbHVlLmxlbmd0aCBpcyA1CitQQVNTIHRleHRhcmVhLnZhbGlk aXR5LnRvb0xvbmcgaXMgZmFsc2UKK1BBU1MgdGV4dGFyZWEudmFsdWUubGVuZ3RoIGlzIDYKK1BB U1MgdGV4dGFyZWEudmFsaWRpdHkudG9vTG9uZyBpcyBmYWxzZQorUEFTUyB0ZXh0YXJlYS52YWx1 ZS5sZW5ndGggaXMgNAorUEFTUyB0ZXh0YXJlYS52YWxpZGl0eS50b29Mb25nIGlzIHRydWUKK1BB U1MgdGV4dGFyZWEudmFsaWRpdHkudG9vTG9uZyBpcyBmYWxzZQorUEFTUyB0ZXh0YXJlYS52YWxp ZGl0eS50b29Mb25nIGlzIHRydWUKK1BBU1Mgc3VjY2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKwor VEVTVCBDT01QTEVURQorCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL1ZhbGlk aXR5U3RhdGUtdG9vTG9uZy10ZXh0YXJlYS5odG1sIGIvTGF5b3V0VGVzdHMvZmFzdC9mb3Jtcy9W YWxpZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFyZWEuaHRtbApuZXcgZmlsZSBtb2RlIDEwMDY0NApp bmRleCAwMDAwMDAwLi5iMWQ4MDMwCi0tLSAvZGV2L251bGwKKysrIGIvTGF5b3V0VGVzdHMvZmFz dC9mb3Jtcy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFyZWEuaHRtbApAQCAtMCwwICsxLDEz IEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0vL0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRt bD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNoZWV0IiBocmVmPSIuLi8uLi9mYXN0L2pzL3Jl c291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2NyaXB0IHNyYz0iLi4vLi4vZmFzdC9qcy9y ZXNvdXJjZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8cCBp ZD0iZGVzY3JpcHRpb24iPjwvcD4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBz cmM9InNjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFyZWEuanMiPjwvc2Ny aXB0PgorPHNjcmlwdCBzcmM9Ii4uLy4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcG9zdC5q cyI+PC9zY3JpcHQ+Cis8L2JvZHk+Cis8L2h0bWw+CmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9m YXN0L2Zvcm1zL3NjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctaW5wdXQuanMgYi9M YXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3NjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRlLXRvb0xvbmct aW5wdXQuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4uZGM2MTA5ZQotLS0g L2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvc2NyaXB0LXRlc3RzL1ZhbGlk aXR5U3RhdGUtdG9vTG9uZy1pbnB1dC5qcwpAQCAtMCwwICsxLDQ0IEBACitkZXNjcmlwdGlvbign VGVzdHMgZm9yIHRvb0xvbmcgZmxhZyB3aXRoICZsdDtpbnB1dD4gZWxlbWVudHMuJyk7CisKK3Zh ciBpbnB1dCA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ2lucHV0Jyk7Citkb2N1bWVudC5ib2R5 LmFwcGVuZENoaWxkKGlucHV0KTsKKworLy8gTm8gbWF4bGVuZ3RoIGFuZCBubyB2YWx1ZQorc2hv dWxkQmVGYWxzZSgnaW5wdXQudmFsaWRpdHkudG9vTG9uZycpOworCisvLyBOb24tZGlydHkgdmFs dWUuCitpbnB1dC5zZXRBdHRyaWJ1dGUoJ3ZhbHVlJywgJ2FiY2RlJyk7CitpbnB1dC5tYXhMZW5n dGggPSAzOworc2hvdWxkQmUoJ2lucHV0LnZhbHVlLmxlbmd0aCcsICc1Jyk7CitzaG91bGRCZUZh bHNlKCdpbnB1dC52YWxpZGl0eS50b29Mb25nJyk7CisKK2lucHV0LnNldEF0dHJpYnV0ZSgndmFs dWUnLCAnYWJjZGVmJyk7CitzaG91bGRCZSgnaW5wdXQudmFsdWUubGVuZ3RoJywgJzYnKTsKK3No b3VsZEJlRmFsc2UoJ2lucHV0LnZhbGlkaXR5LnRvb0xvbmcnKTsKKworLy8gRGlydHkgdmFsdWUg YW5kIGxvbmdlciB0aGFuIG1heExlbmd0aC4KK2lucHV0ID0gZG9jdW1lbnQuY3JlYXRlRWxlbWVu dCgnaW5wdXQnKTsKK2RvY3VtZW50LmJvZHkuYXBwZW5kQ2hpbGQoaW5wdXQpOworaW5wdXQuc2V0 QXR0cmlidXRlKCd2YWx1ZScsICdhYmNkZScpOworaW5wdXQubWF4TGVuZ3RoID0gMzsKK2lucHV0 LmZvY3VzKCk7CitpbnB1dC5zZXRTZWxlY3Rpb25SYW5nZSg1LCA1KTsgIC8vIE1vdmUgdGhlIGN1 cnNvciBhdCB0aGUgZW5kLgorZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ2RlbGV0ZScpOworc2hvdWxk QmUoJ2lucHV0LnZhbHVlLmxlbmd0aCcsICc0Jyk7CitzaG91bGRCZVRydWUoJ2lucHV0LnZhbGlk aXR5LnRvb0xvbmcnKTsKKy8vIE1ha2UgdGhlIHZhbHVlIDw9bWF4TGVuZ3RoLgorZG9jdW1lbnQu ZXhlY0NvbW1hbmQoJ2RlbGV0ZScpOworc2hvdWxkQmVGYWxzZSgnaW5wdXQudmFsaWRpdHkudG9v TG9uZycpOworCisvLyBTZXRzIGEgdmFsdWUgdmlhIERPTSBwcm9wZXJ0eS4KK2lucHV0LnZhbHVl ID0gJ2FiY2RlJzsKK3Nob3VsZEJlVHJ1ZSgnaW5wdXQudmFsaWRpdHkudG9vTG9uZycpOworCisv LyBDaGFuZ2UgdGhlIHR5cGUgd2l0aCBhIHRvbyBsb25nIHZhbHVlLgoraW5wdXQudHlwZSA9ICdz ZWFyY2gnOworc2hvdWxkQmVUcnVlKCdpbnB1dC52YWxpZGl0eS50b29Mb25nJyk7CisKK2lucHV0 LnR5cGUgPSAnbnVtYmVyJzsKK3Nob3VsZEJlRmFsc2UoJ2lucHV0LnZhbGlkaXR5LnRvb0xvbmcn KTsKKwordmFyIHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7CmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy9mYXN0L2Zvcm1zL3NjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRlLXRvb0xvbmctdGV4dGFy ZWEuanMgYi9MYXlvdXRUZXN0cy9mYXN0L2Zvcm1zL3NjcmlwdC10ZXN0cy9WYWxpZGl0eVN0YXRl LXRvb0xvbmctdGV4dGFyZWEuanMKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMC4u NGExZmUxNwotLS0gL2Rldi9udWxsCisrKyBiL0xheW91dFRlc3RzL2Zhc3QvZm9ybXMvc2NyaXB0 LXRlc3RzL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy10ZXh0YXJlYS5qcwpAQCAtMCwwICsxLDM3IEBA CitkZXNjcmlwdGlvbignVGVzdHMgZm9yIHRvb0xvbmcgZmxhZyB3aXRoICZsdDt0ZXh0YXJlYT4g ZWxlbWVudHMuJyk7CisKK3ZhciB0ZXh0YXJlYSA9IGRvY3VtZW50LmNyZWF0ZUVsZW1lbnQoJ3Rl eHRhcmVhJyk7Citkb2N1bWVudC5ib2R5LmFwcGVuZENoaWxkKHRleHRhcmVhKTsKKworLy8gTm8g bWF4bGVuZ3RoIGFuZCBubyB2YWx1ZQorc2hvdWxkQmVGYWxzZSgndGV4dGFyZWEudmFsaWRpdHku dG9vTG9uZycpOworCisvLyBOb24tZGlydHkgdmFsdWUuCit0ZXh0YXJlYS5kZWZhdWx0VmFsdWUg PSAnYWJjZGUnOwordGV4dGFyZWEubWF4TGVuZ3RoID0gMzsKK3Nob3VsZEJlKCd0ZXh0YXJlYS52 YWx1ZS5sZW5ndGgnLCAnNScpOworc2hvdWxkQmVGYWxzZSgndGV4dGFyZWEudmFsaWRpdHkudG9v TG9uZycpOworCit0ZXh0YXJlYS5kZWZhdWx0VmFsdWUgPSAnYWJjZGVmJzsKK3Nob3VsZEJlKCd0 ZXh0YXJlYS52YWx1ZS5sZW5ndGgnLCAnNicpOworc2hvdWxkQmVGYWxzZSgndGV4dGFyZWEudmFs aWRpdHkudG9vTG9uZycpOworCisvLyBEaXJ0eSB2YWx1ZSBhbmQgbG9uZ2VyIHRoYW4gbWF4TGVu Z3RoLgordGV4dGFyZWEgPSBkb2N1bWVudC5jcmVhdGVFbGVtZW50KCd0ZXh0YXJlYScpOworZG9j dW1lbnQuYm9keS5hcHBlbmRDaGlsZCh0ZXh0YXJlYSk7Cit0ZXh0YXJlYS5kZWZhdWx0VmFsdWUg PSAnYWJjZGUnOwordGV4dGFyZWEubWF4TGVuZ3RoID0gMzsKK3RleHRhcmVhLmZvY3VzKCk7Cit0 ZXh0YXJlYS5zZXRTZWxlY3Rpb25SYW5nZSg1LCA1KTsgIC8vIE1vdmUgdGhlIGN1cnNvciBhdCB0 aGUgZW5kLgorZG9jdW1lbnQuZXhlY0NvbW1hbmQoJ2RlbGV0ZScpOworc2hvdWxkQmUoJ3RleHRh cmVhLnZhbHVlLmxlbmd0aCcsICc0Jyk7CitzaG91bGRCZVRydWUoJ3RleHRhcmVhLnZhbGlkaXR5 LnRvb0xvbmcnKTsKKy8vIE1ha2UgdGhlIHZhbHVlIDw9bWF4TGVuZ3RoLgorZG9jdW1lbnQuZXhl Y0NvbW1hbmQoJ2RlbGV0ZScpOworc2hvdWxkQmVGYWxzZSgndGV4dGFyZWEudmFsaWRpdHkudG9v TG9uZycpOworCisvLyBTZXRzIGEgdmFsdWUgdmlhIERPTSBwcm9wZXJ0eS4KK3RleHRhcmVhLnZh bHVlID0gJ2FiY2RlJzsKK3Nob3VsZEJlVHJ1ZSgndGV4dGFyZWEudmFsaWRpdHkudG9vTG9uZycp OworCit2YXIgc3VjY2Vzc2Z1bGx5UGFyc2VkID0gdHJ1ZTsKZGlmZiAtLWdpdCBhL1dlYkNvcmUv Q2hhbmdlTG9nIGIvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggYmMzMzUxZi4uNDVhMzBkZiAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9DaGFuZ2VMb2cKKysrIGIvV2ViQ29yZS9DaGFuZ2VMb2cKQEAgLTEs MyArMSwzOCBAQAorMjAwOS0wOS0yNyAgS2VudCBUYW11cmEgIDx0a2VudEBjaHJvbWl1bS5vcmc+ CisKKyAgICAgICAgUmV2aWV3ZWQgYnkgTk9CT0RZIChPT1BTISkuCisKKyAgICAgICAgQWRkcyBW YWxpZGl0eVN0YXRlLnRvb0xvbmcgc3VwcG9ydCBmb3IgPGlucHV0PiBhbmQgPHRleHRhcmVhPi4K KworICAgICAgICBJbnRyb2R1Y2VzIHRvb0xvbmcoKSBpbiBIVE1MRm9ybUNvbnRyb2xFbGVtZW50 IGFuZCBpdCBhbHdheXMgcmV0dXJucyBmYWxzZS4KKyAgICAgICAgSFRNTElucHV0RWxlbWVudCBh bmQgSFRNTFRleHRBcmVhRWxlbWVudCBvdmVycmlkZXMgaXQgYW5kIGNoZWNrcyB0aGUgdGV4dAor ICAgICAgICBsZW5ndGggYW5kIG1heExlbmd0aC4gIHRvb0xvbmcoKSBzaG91bGQgd29yayBvbmx5 IGZvciBgZGlydHknIHZhbHVlcy4KKyAgICAgICAgU28sIGludHJvZHVjZXMgbV9pc0RpcnR5IGZs YWcgZm9yIEhUTUxUZXh0QXJlYUVsZW1lbnQsIGFuZAorICAgICAgICAhbV9kYXRhLnZhbHVlKCku aXNOdWxsKCkgd29ya3MgYXMgYSBkaXJ0eSBmbGFnIGZvciBIVE1MSW5wdXRFbGVtZW50LgorCisg ICAgICAgIFJlbmFtZXMgcGFyYW1ldGVyIG5hbWVzIG9mIHNldE1heExlbmd0aCgpLgorCisgICAg ICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yNzQ1NAorCisgICAg ICAgIFRlc3RzOiBmYXN0L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy1pbnB1dC5odG1sCisg ICAgICAgICAgICAgICBmYXN0L2Zvcm1zL1ZhbGlkaXR5U3RhdGUtdG9vTG9uZy10ZXh0YXJlYS5o dG1sCisKKyAgICAgICAgKiBodG1sL0hUTUxGb3JtQ29udHJvbEVsZW1lbnQuaDoKKyAgICAgICAg KFdlYkNvcmU6OkhUTUxGb3JtQ29udHJvbEVsZW1lbnQ6OnRvb0xvbmcpOgorICAgICAgICAqIGh0 bWwvSFRNTElucHV0RWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpIVE1MSW5wdXRFbGVt ZW50Ojp0b29Mb25nKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxJbnB1dEVsZW1lbnQ6OnNldE1h eExlbmd0aCk6CisgICAgICAgICogaHRtbC9IVE1MSW5wdXRFbGVtZW50Lmg6CisgICAgICAgICog aHRtbC9IVE1MVGV4dEFyZWFFbGVtZW50LmNwcDoKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxUZXh0 QXJlYUVsZW1lbnQ6OkhUTUxUZXh0QXJlYUVsZW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6SFRN TFRleHRBcmVhRWxlbWVudDo6cmVzZXQpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFRleHRBcmVh RWxlbWVudDo6dXBkYXRlVmFsdWUpOgorICAgICAgICAoV2ViQ29yZTo6SFRNTFRleHRBcmVhRWxl bWVudDo6c2V0TWF4TGVuZ3RoKToKKyAgICAgICAgKFdlYkNvcmU6OkhUTUxUZXh0QXJlYUVsZW1l bnQ6OnRvb0xvbmcpOgorICAgICAgICAqIGh0bWwvSFRNTFRleHRBcmVhRWxlbWVudC5oOgorICAg ICAgICAqIGh0bWwvVmFsaWRpdHlTdGF0ZS5oOgorICAgICAgICAoV2ViQ29yZTo6VmFsaWRpdHlT dGF0ZTo6dG9vTG9uZyk6CisKIDIwMDktMDktMjkgIEFsZXhleSBQcm9za3VyeWFrb3YgIDxhcEBh cHBsZS5jb20+CiAKICAgICAgICAgUnViYmVyLXN0YW1wZWQgYnkgQnJhZHkgRWlkc29uLgpkaWZm IC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbEVsZW1lbnQuaCBiL1dlYkNvcmUv aHRtbC9IVE1MRm9ybUNvbnRyb2xFbGVtZW50LmgKaW5kZXggN2IzY2ZiZC4uNDMyM2UxYiAxMDA2 NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hUTUxGb3JtQ29udHJvbEVsZW1lbnQuaAorKysgYi9XZWJD b3JlL2h0bWwvSFRNTEZvcm1Db250cm9sRWxlbWVudC5oCkBAIC0xMTAsNiArMTEwLDcgQEAgcHVi bGljOgogCiAgICAgdmlydHVhbCBib29sIHZhbHVlTWlzc2luZygpIGNvbnN0IHsgcmV0dXJuIGZh bHNlOyB9CiAgICAgdmlydHVhbCBib29sIHBhdHRlcm5NaXNtYXRjaCgpIGNvbnN0IHsgcmV0dXJu IGZhbHNlOyB9CisgICAgdmlydHVhbCBib29sIHRvb0xvbmcoKSBjb25zdCB7IHJldHVybiBmYWxz ZTsgfQogCiAgICAgdm9pZCBmb3JtRGVzdHJveWVkKCkgeyBtX2Zvcm0gPSAwOyB9CiAKZGlmZiAt LWdpdCBhL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRFbGVtZW50LmNwcCBiL1dlYkNvcmUvaHRtbC9I VE1MSW5wdXRFbGVtZW50LmNwcAppbmRleCBlNmI4MjI4Li43Y2M1NTY1IDEwMDY0NAotLS0gYS9X ZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5jcHAKKysrIGIvV2ViQ29yZS9odG1sL0hUTUxJ bnB1dEVsZW1lbnQuY3BwCkBAIC0xOTYsNiArMTk2LDQyIEBAIGJvb2wgSFRNTElucHV0RWxlbWVu dDo6cGF0dGVybk1pc21hdGNoKCkgY29uc3QKICAgICByZXR1cm4gZmFsc2U7CiB9CiAKK2Jvb2wg SFRNTElucHV0RWxlbWVudDo6dG9vTG9uZygpIGNvbnN0Cit7CisgICAgc3dpdGNoIChpbnB1dFR5 cGUoKSkgeworICAgIGNhc2UgRU1BSUw6CisgICAgY2FzZSBQQVNTV09SRDoKKyAgICBjYXNlIFNF QVJDSDoKKyAgICBjYXNlIFRFTEVQSE9ORToKKyAgICBjYXNlIFRFWFQ6CisgICAgY2FzZSBVUkw6 IHsKKyAgICAgICAgaW50IG1heCA9IG1heExlbmd0aCgpOworICAgICAgICBpZiAobWF4IDwgMCkK KyAgICAgICAgICAgIHJldHVybiBmYWxzZTsKKyAgICAgICAgLy8gUmV0dXJuIGZhbHNlIGZvciB0 aGUgZGVmYXVsdCB2YWx1ZSBldmVuIGlmIGl0IGlzIGxvbmdlciB0aGFuIG1heExlbmd0aC4KKyAg ICAgICAgYm9vbCB1c2VyRWRpdGVkID0gIW1fZGF0YS52YWx1ZSgpLmlzTnVsbCgpOworICAgICAg ICBpZiAoIXVzZXJFZGl0ZWQpCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgICAgIHJl dHVybiB2YWx1ZSgpLmxlbmd0aCgpID4gc3RhdGljX2Nhc3Q8dW5zaWduZWQ+KG1heCk7CisgICAg fQorICAgIGNhc2UgQlVUVE9OOgorICAgIGNhc2UgQ0hFQ0tCT1g6CisgICAgY2FzZSBDT0xPUjoK KyAgICBjYXNlIEZJTEU6CisgICAgY2FzZSBISURERU46CisgICAgY2FzZSBJTUFHRToKKyAgICBj YXNlIElTSU5ERVg6CisgICAgY2FzZSBOVU1CRVI6CisgICAgY2FzZSBSQURJTzoKKyAgICBjYXNl IFJBTkdFOgorICAgIGNhc2UgUkVTRVQ6CisgICAgY2FzZSBTVUJNSVQ6CisgICAgICAgIHJldHVy biBmYWxzZTsKKyAgICB9CisgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgcmV0dXJuIGZh bHNlOworfQorCiBzdGF0aWMgaW5saW5lIENoZWNrZWRSYWRpb0J1dHRvbnMmIGNoZWNrZWRSYWRp b0J1dHRvbnMoY29uc3QgSFRNTElucHV0RWxlbWVudCAqZWxlbWVudCkKIHsKICAgICBpZiAoSFRN TEZvcm1FbGVtZW50KiBmb3JtID0gZWxlbWVudC0+Zm9ybSgpKQpAQCAtMTYxMCwxMiArMTY0Niwx MiBAQCBpbnQgSFRNTElucHV0RWxlbWVudDo6bWF4TGVuZ3RoKCkgY29uc3QKICAgICByZXR1cm4g bV9kYXRhLm1heExlbmd0aCgpOwogfQogCi12b2lkIEhUTUxJbnB1dEVsZW1lbnQ6OnNldE1heExl bmd0aChpbnQgX21heExlbmd0aCwgRXhjZXB0aW9uQ29kZSYgZXhjZXB0aW9uQ29kZSkKK3ZvaWQg SFRNTElucHV0RWxlbWVudDo6c2V0TWF4TGVuZ3RoKGludCBtYXhMZW5ndGgsIEV4Y2VwdGlvbkNv ZGUmIGVjKQogewotICAgIGlmIChfbWF4TGVuZ3RoIDwgMCkKLSAgICAgICAgZXhjZXB0aW9uQ29k ZSA9IElOREVYX1NJWkVfRVJSOworICAgIGlmIChtYXhMZW5ndGggPCAwKQorICAgICAgICBlYyA9 IElOREVYX1NJWkVfRVJSOwogICAgIGVsc2UKLSAgICAgICAgc2V0QXR0cmlidXRlKG1heGxlbmd0 aEF0dHIsIFN0cmluZzo6bnVtYmVyKF9tYXhMZW5ndGgpKTsKKyAgICAgICAgc2V0QXR0cmlidXRl KG1heGxlbmd0aEF0dHIsIFN0cmluZzo6bnVtYmVyKG1heExlbmd0aCkpOwogfQogCiBib29sIEhU TUxJbnB1dEVsZW1lbnQ6Om11bHRpcGxlKCkgY29uc3QKZGlmZiAtLWdpdCBhL1dlYkNvcmUvaHRt bC9IVE1MSW5wdXRFbGVtZW50LmggYi9XZWJDb3JlL2h0bWwvSFRNTElucHV0RWxlbWVudC5oCmlu ZGV4IDE2ZTNiNTguLjBlN2RmNzMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9IVE1MSW5wdXRF bGVtZW50LmgKKysrIGIvV2ViQ29yZS9odG1sL0hUTUxJbnB1dEVsZW1lbnQuaApAQCAtOTMsNiAr OTMsNyBAQCBwdWJsaWM6CiAKICAgICB2aXJ0dWFsIGJvb2wgdmFsdWVNaXNzaW5nKCkgY29uc3Q7 CiAgICAgdmlydHVhbCBib29sIHBhdHRlcm5NaXNtYXRjaCgpIGNvbnN0OworICAgIHZpcnR1YWwg Ym9vbCB0b29Mb25nKCkgY29uc3Q7CiAKICAgICBib29sIGlzVGV4dEJ1dHRvbigpIGNvbnN0IHsg cmV0dXJuIG1fdHlwZSA9PSBTVUJNSVQgfHwgbV90eXBlID09IFJFU0VUIHx8IG1fdHlwZSA9PSBC VVRUT047IH0KICAgICB2aXJ0dWFsIGJvb2wgaXNSYWRpb0J1dHRvbigpIGNvbnN0IHsgcmV0dXJu IG1fdHlwZSA9PSBSQURJTzsgfQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL0hUTUxUZXh0QXJl YUVsZW1lbnQuY3BwIGIvV2ViQ29yZS9odG1sL0hUTUxUZXh0QXJlYUVsZW1lbnQuY3BwCmluZGV4 IGI1ZTRjZWQuLjZmNjBhZTMgMTAwNjQ0Ci0tLSBhL1dlYkNvcmUvaHRtbC9IVE1MVGV4dEFyZWFF bGVtZW50LmNwcAorKysgYi9XZWJDb3JlL2h0bWwvSFRNTFRleHRBcmVhRWxlbWVudC5jcHAKQEAg LTcwLDYgKzcwLDcgQEAgSFRNTFRleHRBcmVhRWxlbWVudDo6SFRNTFRleHRBcmVhRWxlbWVudChj b25zdCBRdWFsaWZpZWROYW1lJiB0YWdOYW1lLCBEb2N1bWVudCoKICAgICAsIG1fd3JhcChTb2Z0 V3JhcCkKICAgICAsIG1fY2FjaGVkU2VsZWN0aW9uU3RhcnQoLTEpCiAgICAgLCBtX2NhY2hlZFNl bGVjdGlvbkVuZCgtMSkKKyAgICAsIG1faXNEaXJ0eShmYWxzZSkKIHsKICAgICBBU1NFUlQoaGFz VGFnTmFtZSh0ZXh0YXJlYVRhZykpOwogICAgIHNldEZvcm1Db250cm9sVmFsdWVNYXRjaGVzUmVu ZGVyZXIodHJ1ZSk7CkBAIC0yMzEsNiArMjMyLDcgQEAgYm9vbCBIVE1MVGV4dEFyZWFFbGVtZW50 OjphcHBlbmRGb3JtRGF0YShGb3JtRGF0YUxpc3QmIGVuY29kaW5nLCBib29sKQogdm9pZCBIVE1M VGV4dEFyZWFFbGVtZW50OjpyZXNldCgpCiB7CiAgICAgc2V0VmFsdWUoZGVmYXVsdFZhbHVlKCkp OworICAgIG1faXNEaXJ0eSA9IGZhbHNlOwogfQogCiBib29sIEhUTUxUZXh0QXJlYUVsZW1lbnQ6 OmlzS2V5Ym9hcmRGb2N1c2FibGUoS2V5Ym9hcmRFdmVudCopIGNvbnN0CkBAIC0zMTYsNiArMzE4 LDcgQEAgdm9pZCBIVE1MVGV4dEFyZWFFbGVtZW50Ojp1cGRhdGVWYWx1ZSgpIGNvbnN0CiAgICAg bV92YWx1ZSA9IHRvUmVuZGVyVGV4dENvbnRyb2wocmVuZGVyZXIoKSktPnRleHQoKTsKICAgICBj b25zdF9jYXN0PEhUTUxUZXh0QXJlYUVsZW1lbnQqPih0aGlzKS0+c2V0Rm9ybUNvbnRyb2xWYWx1 ZU1hdGNoZXNSZW5kZXJlcih0cnVlKTsKICAgICBub3RpZnlGb3JtU3RhdGVDaGFuZ2VkKHRoaXMp OworICAgIG1faXNEaXJ0eSA9IHRydWU7CiB9CiAKIFN0cmluZyBIVE1MVGV4dEFyZWFFbGVtZW50 Ojp2YWx1ZSgpIGNvbnN0CkBAIC00MDksMTQgKzQxMiwyNiBAQCBpbnQgSFRNTFRleHRBcmVhRWxl bWVudDo6bWF4TGVuZ3RoKCkgY29uc3QKICAgICByZXR1cm4gb2sgJiYgdmFsdWUgPj0gMCA/IHZh bHVlIDogLTE7CiB9CiAKLXZvaWQgSFRNTFRleHRBcmVhRWxlbWVudDo6c2V0TWF4TGVuZ3RoKGlu dCBuZXdWYWx1ZSwgRXhjZXB0aW9uQ29kZSYgZXhjZXB0aW9uQ29kZSkKK3ZvaWQgSFRNTFRleHRB cmVhRWxlbWVudDo6c2V0TWF4TGVuZ3RoKGludCBuZXdWYWx1ZSwgRXhjZXB0aW9uQ29kZSYgZWMp CiB7CiAgICAgaWYgKG5ld1ZhbHVlIDwgMCkKLSAgICAgICAgZXhjZXB0aW9uQ29kZSA9IElOREVY X1NJWkVfRVJSOworICAgICAgICBlYyA9IElOREVYX1NJWkVfRVJSOwogICAgIGVsc2UKICAgICAg ICAgc2V0QXR0cmlidXRlKG1heGxlbmd0aEF0dHIsIFN0cmluZzo6bnVtYmVyKG5ld1ZhbHVlKSk7 CiB9CiAKK2Jvb2wgSFRNTFRleHRBcmVhRWxlbWVudDo6dG9vTG9uZygpIGNvbnN0Cit7CisgICAg Ly8gUmV0dXJuIGZhbHNlIGZvciB0aGUgZGVmYXVsdCB2YWx1ZSBldmVuIGlmIGl0IGlzIGxvbmdl ciB0aGFuIG1heExlbmd0aC4KKyAgICBpZiAoIW1faXNEaXJ0eSkKKyAgICAgICAgcmV0dXJuIGZh bHNlOworCisgICAgaW50IG1heCA9IG1heExlbmd0aCgpOworICAgIGlmIChtYXggPCAwKQorICAg ICAgICByZXR1cm4gZmFsc2U7CisgICAgcmV0dXJuIHZhbHVlKCkubGVuZ3RoKCkgPiBzdGF0aWNf Y2FzdDx1bnNpZ25lZD4obWF4KTsKK30KKwogdm9pZCBIVE1MVGV4dEFyZWFFbGVtZW50OjphY2Nl c3NLZXlBY3Rpb24oYm9vbCkKIHsKICAgICBmb2N1cygpOwpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9o dG1sL0hUTUxUZXh0QXJlYUVsZW1lbnQuaCBiL1dlYkNvcmUvaHRtbC9IVE1MVGV4dEFyZWFFbGVt ZW50LmgKaW5kZXggY2ZkNDcxYS4uYmFmN2M3MCAxMDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL0hU TUxUZXh0QXJlYUVsZW1lbnQuaAorKysgYi9XZWJDb3JlL2h0bWwvSFRNTFRleHRBcmVhRWxlbWVu dC5oCkBAIC04MSw2ICs4MSw3IEBAIHB1YmxpYzoKICAgICBpbnQgdGV4dExlbmd0aCgpIGNvbnN0 IHsgcmV0dXJuIHZhbHVlKCkubGVuZ3RoKCk7IH0KICAgICBpbnQgbWF4TGVuZ3RoKCkgY29uc3Q7 CiAgICAgdm9pZCBzZXRNYXhMZW5ndGgoaW50LCBFeGNlcHRpb25Db2RlJik7CisgICAgdmlydHVh bCBib29sIHRvb0xvbmcoKSBjb25zdDsKICAgICAKICAgICB2b2lkIHJlbmRlcmVyV2lsbEJlRGVz dHJveWVkKCk7CiAgICAgCkBAIC0xMTYsNiArMTE3LDcgQEAgcHJpdmF0ZToKICAgICBtdXRhYmxl IFN0cmluZyBtX3ZhbHVlOwogICAgIGludCBtX2NhY2hlZFNlbGVjdGlvblN0YXJ0OwogICAgIGlu dCBtX2NhY2hlZFNlbGVjdGlvbkVuZDsKKyAgICBtdXRhYmxlIGJvb2wgbV9pc0RpcnR5OwogfTsK IAogfSAvL25hbWVzcGFjZQpkaWZmIC0tZ2l0IGEvV2ViQ29yZS9odG1sL1ZhbGlkaXR5U3RhdGUu aCBiL1dlYkNvcmUvaHRtbC9WYWxpZGl0eVN0YXRlLmgKaW5kZXggMWI4N2Y5OS4uOWFkYzhmZCAx MDA2NDQKLS0tIGEvV2ViQ29yZS9odG1sL1ZhbGlkaXR5U3RhdGUuaAorKysgYi9XZWJDb3JlL2h0 bWwvVmFsaWRpdHlTdGF0ZS5oCkBAIC00Myw3ICs0Myw3IEBAIG5hbWVzcGFjZSBXZWJDb3JlIHsK ICAgICAgICAgYm9vbCB2YWx1ZU1pc3NpbmcoKSB7IHJldHVybiBjb250cm9sKCktPnZhbHVlTWlz c2luZygpOyB9CiAgICAgICAgIGJvb2wgdHlwZU1pc21hdGNoKCk7CiAgICAgICAgIGJvb2wgcGF0 dGVybk1pc21hdGNoKCkgeyByZXR1cm4gY29udHJvbCgpLT5wYXR0ZXJuTWlzbWF0Y2goKTsgfQot ICAgICAgICBib29sIHRvb0xvbmcoKSB7IHJldHVybiBmYWxzZTsgfQorICAgICAgICBib29sIHRv b0xvbmcoKSB7IHJldHVybiBjb250cm9sKCktPnRvb0xvbmcoKTsgfQogICAgICAgICBib29sIHJh bmdlVW5kZXJmbG93KCkgeyByZXR1cm4gZmFsc2U7IH0KICAgICAgICAgYm9vbCByYW5nZU92ZXJm bG93KCkgeyByZXR1cm4gZmFsc2U7IH0KICAgICAgICAgYm9vbCBzdGVwTWlzbWF0Y2goKSB7IHJl dHVybiBmYWxzZTsgfQotLSAKMS42LjMuMwoK