105058 2012-12-14 15:21:52 -0800 Implement WebIDL-style string constants in WebAudio 2013-01-02 12:29:12 -0800 1 1 1 Unclassified WebKit Web Audio 528+ (Nightly build) Unspecified Unspecified RESOLVED FIXED P2 Normal --- 1 crogers crogers abarth crogers eric.carlson feature-media-reviews ggaren gyuyoung.kim haraken japhet nbarth ojan.autocc rakuco sam webkit.review.bot oldest_to_newest 791900 0 crogers 2012-12-14 15:21:52 -0800 See Deprecation Notes for more detail: https://dvcs.w3.org/hg/audio/raw-file/tip/webaudio/specification.html#DeprecationNotes PannerNode, BiquadFilterNode, OscillatorNode constants must support WebIDL-style string constants. Legacy support in the setters for the old integer values should be supported. 791906 1 crogers 2012-12-14 15:24:28 -0800 Kentaro, do you have any suggestions for how to implement both string and integer values in the setters for these attributes? I'm assuming this will require custom setters and we have no way to auto-generate? If so, do you have any suggestions for examples of custom bindings in WebKit which solve a similar problem to get me started - thanks for any advice! 792389 2 haraken 2012-12-16 16:24:43 -0800 (In reply to comment #1) > Kentaro, do you have any suggestions for how to implement both string and integer values in the setters for these attributes? I'm assuming this will require custom setters and we have no way to auto-generate? If so, do you have any suggestions for examples of custom bindings in WebKit which solve a similar problem to get me started - thanks for any advice! Hmm, that sounds like a bunch of work. For now, let me describe just the overall idea. I can support you more in detail if you have more specific questions. (1) Currently the WebKit IDL doesn't support 'enum'. So you need to implement 'enum' in code generators. (2) You need to implement DOM attribute overloading. Specifically, you need to improve code generators so that the following IDL works: attribute unsigned short type; attribute BiquadFilterType type; 792403 3 crogers 2012-12-16 17:44:35 -0800 (In reply to comment #2) > (In reply to comment #1) > > Kentaro, do you have any suggestions for how to implement both string and integer values in the setters for these attributes? I'm assuming this will require custom setters and we have no way to auto-generate? If so, do you have any suggestions for examples of custom bindings in WebKit which solve a similar problem to get me started - thanks for any advice! > > Hmm, that sounds like a bunch of work. For now, let me describe just the overall idea. I can support you more in detail if you have more specific questions. Kentaro, thanks for the info. > > (1) Currently the WebKit IDL doesn't support 'enum'. So you need to implement 'enum' in code generators. > I'm not so worried about supporting 'enum'. We already deal with string constants in several other places, such as the .responseType attribute of XMLHttpRequest. I'm not sure (for now at least) that we have to "formally" use enum. > (2) You need to implement DOM attribute overloading. Specifically, you need to improve code generators so that the following IDL works: > > attribute unsigned short type; > attribute BiquadFilterType type; One tricky aspect here is that the return value of the attribute will be a BiquadFilterType (effectively a DOMString). So how do we specify that the 2nd one (for BiquadFilterType) is to be used for the return value, while both should be allowed for setters? As an alternative, isn't it possible to avoid changing the code generators and write the custom bindings code by hand? I don't know which way would be harder and more time-consuming. But I do understand in principle how to write them by hand. What do you think? 792409 4 haraken 2012-12-16 17:59:24 -0800 (In reply to comment #3) > > (1) Currently the WebKit IDL doesn't support 'enum'. So you need to implement 'enum' in code generators. > > > > I'm not so worried about supporting 'enum'. We already deal with string constants in several other places, such as the .responseType attribute of XMLHttpRequest. I'm not sure (for now at least) that we have to "formally" use enum. OK, that sounds reasonable, though we want to support an enum eventually to make the WebKit IDL comformed to the spec. > > (2) You need to implement DOM attribute overloading. Specifically, you need to improve code generators so that the following IDL works: > > > > attribute unsigned short type; > > attribute BiquadFilterType type; > > One tricky aspect here is that the return value of the attribute will be a BiquadFilterType (effectively a DOMString). So how do we specify that the 2nd one (for BiquadFilterType) is to be used for the return value, while both should be allowed for setters? You can switch behaviors depending on types. For example, look at bindings/v8/custom/V8BlobCustom.cpp. V8BlobCustom.cpp switches behaviors depending on IsObject(), IsArray(), etc. > As an alternative, isn't it possible to avoid changing the code generators and write the custom bindings code by hand? I don't know which way would be harder and more time-consuming. But I do understand in principle how to write them by hand. What do you think? Custom bindings would be less time-consuming for you. However, custom bindings are strongly discouraged (and we've been trying to kill custom bindings). Unless you have a strong reason to use custom bindings, you should try best to solve your problem by improving code generators. For how many DOM attributes are you going to use the DOM attribute overloading? 792445 5 crogers 2012-12-16 19:28:10 -0800 (In reply to comment #4) > (In reply to comment #3) > > > (1) Currently the WebKit IDL doesn't support 'enum'. So you need to implement 'enum' in code generators. > > > > > > > I'm not so worried about supporting 'enum'. We already deal with string constants in several other places, such as the .responseType attribute of XMLHttpRequest. I'm not sure (for now at least) that we have to "formally" use enum. > > OK, that sounds reasonable, though we want to support an enum eventually to make the WebKit IDL comformed to the spec. > > > > (2) You need to implement DOM attribute overloading. Specifically, you need to improve code generators so that the following IDL works: > > > > > > attribute unsigned short type; > > > attribute BiquadFilterType type; > > > > One tricky aspect here is that the return value of the attribute will be a BiquadFilterType (effectively a DOMString). So how do we specify that the 2nd one (for BiquadFilterType) is to be used for the return value, while both should be allowed for setters? > > You can switch behaviors depending on types. For example, look at bindings/v8/custom/V8BlobCustom.cpp. V8BlobCustom.cpp switches behaviors depending on IsObject(), IsArray(), etc. > > > As an alternative, isn't it possible to avoid changing the code generators and write the custom bindings code by hand? I don't know which way would be harder and more time-consuming. But I do understand in principle how to write them by hand. What do you think? > > Custom bindings would be less time-consuming for you. However, custom bindings are strongly discouraged (and we've been trying to kill custom bindings). Unless you have a strong reason to use custom bindings, you should try best to solve your problem by improving code generators. > > For how many DOM attributes are you going to use the DOM attribute overloading? It's for the four attributes described here: https://dvcs.w3.org/hg/audio/raw-file/tip/webaudio/specification.html#DeprecationNotes I'm not quite sure how it can be possible to make this automatically generated, could you please provide some more details about your idea? For each string value, there will be a corresponding integer value, and that correspondance must be mapped somehow. I'm not sure how that information/mapping would look like in terms of the IDL. Thanks for your help. 792448 6 crogers 2012-12-16 19:51:11 -0800 (In reply to comment #4) > (In reply to comment #3) > > > (1) Currently the WebKit IDL doesn't support 'enum'. So you need to implement 'enum' in code generators. > > > > > > > I'm not so worried about supporting 'enum'. We already deal with string constants in several other places, such as the .responseType attribute of XMLHttpRequest. I'm not sure (for now at least) that we have to "formally" use enum. > > OK, that sounds reasonable, though we want to support an enum eventually to make the WebKit IDL comformed to the spec. > > > > (2) You need to implement DOM attribute overloading. Specifically, you need to improve code generators so that the following IDL works: > > > > > > attribute unsigned short type; > > > attribute BiquadFilterType type; > > > > One tricky aspect here is that the return value of the attribute will be a BiquadFilterType (effectively a DOMString). So how do we specify that the 2nd one (for BiquadFilterType) is to be used for the return value, while both should be allowed for setters? > > You can switch behaviors depending on types. For example, look at bindings/v8/custom/V8BlobCustom.cpp. V8BlobCustom.cpp switches behaviors depending on IsObject(), IsArray(), etc. Sure, I understand how to switch behaviors for the setters. The main question is how to specify the "getter" return value, since specifying the attribute twice with two different types makes this ambiguous. 792452 7 haraken 2012-12-16 20:29:11 -0800 (In reply to comment #6) > Sure, I understand how to switch behaviors for the setters. The main question is how to specify the "getter" return value, since specifying the attribute twice with two different types makes this ambiguous. hmm, maybe custom bindings would make sense in this case, because (1) it will anyway mess up code generators, (2) DOM attribute overloading is not a mechanism in the spec, and (3) the mechanism will be used by Web Audio only. 793240 8 179849 crogers 2012-12-17 18:33:18 -0800 Created attachment 179849 Patch 793242 9 crogers 2012-12-17 18:37:12 -0800 I've tried out custom bindings to see how they would look. This first patch handles the custom bindings for OscillatorNode. I can add the other ones if this approach looks reasonable. 793294 10 179849 haraken 2012-12-17 20:13:18 -0800 Comment on attachment 179849 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179849&action=review > Source/WebCore/ChangeLog:12 > + PannerNode, BiquadFilterNode, OscillatorNode constants must support WebIDL-style string constants. > + Legacy support in the setters for the old integer values should be supported. Actually I don't fully understand why we want to support the old integer values for setters only. What's the rationale for keeping the behavior for setters only? Given that getters return strings anyway, it wouldn't make sense to support integer values for setters. > Source/WebCore/Modules/webaudio/OscillatorNode.cpp:88 > + switch (m_type) { How about changing the type of m_type from unsigned short to AtomicString, because we're deprecating the unsigned short m_type? > Source/WebCore/Modules/webaudio/OscillatorNode.cpp:91 > + break; break is not needed. Ditto for other breaks. > Source/WebCore/bindings/js/JSOscillatorNodeCustom.cpp:62 > + if (value.isString()) { > + ExceptionCode ec = 0; > + imp->setType(value.toString(exec)->value(exec), ec); > + if (ec) > + setDOMException(exec, ec); > + return; > + } > + > +#if ENABLE(LEGACY_WEB_AUDIO) > + if (value.isNumber()) { > + uint32_t type = value.toUInt32(exec); > + ExceptionCode ec = 0; > + imp->setType(type, ec); > + if (ec) > + setDOMException(exec, ec); > + return; > + } > +#endif > + > + setDOMException(exec, NOT_SUPPORTED_ERR); Maybe this logic should be: #if ENABLE(LEGACY_WEB_AUDIO) if (value.isNumber()) { ...; } #endif String type = value.toString(exec)0->value(exec); if (exec->hadException()) { ...; // Depends on the spec. return; } ExceptionCode ec = 0; imp->setType(value.toString(exec)->value(exec), ec); ...; } Please confirm the spec. > Source/WebCore/bindings/v8/custom/V8OscillatorNodeCustom.cpp:66 > + if (value->IsString()) { > + String type = toWebCoreString(value); > + ExceptionCode ec = 0; > + imp->setType(type, ec); > + if (ec) > + setDOMException(ec, info.GetIsolate()); > + return; > + } > + > +#if ENABLE(LEGACY_WEB_AUDIO) > + if (value->IsNumber()) { > + bool ok = false; > + uint32_t type = toUInt32(value, ok); > + if (ok) { > + ExceptionCode ec = 0; > + imp->setType(type, ec); > + if (ec) > + setDOMException(ec, info.GetIsolate()); > + return; > + } > + } > +#endif > + > + setDOMException(NOT_SUPPORTED_ERR, info.GetIsolate()); Ditto. 794053 11 180028 crogers 2012-12-18 14:28:53 -0800 Created attachment 180028 Patch 794058 12 179849 crogers 2012-12-18 14:31:51 -0800 Comment on attachment 179849 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=179849&action=review >> Source/WebCore/ChangeLog:12 >> + Legacy support in the setters for the old integer values should be supported. > > Actually I don't fully understand why we want to support the old integer values for setters only. What's the rationale for keeping the behavior for setters only? Given that getters return strings anyway, it wouldn't make sense to support integer values for setters. The reason is so that we don't break all of the Web Audio pages (out in the wild) that use these attributes. Since they're currently setting these attributes to integers, these pages would break if we suddenly switched to only accepting strings in the setters. We consider that this breaking behavior would be severe, so need to carefully support both. The getters are very much less commonly used than the setters, so although getting the attribute value has the potential to break pages since it will now return a string, we feel this will hurt very few pages using Web Audio. >> Source/WebCore/Modules/webaudio/OscillatorNode.cpp:88 >> + switch (m_type) { > > How about changing the type of m_type from unsigned short to AtomicString, because we're deprecating the unsigned short m_type? For efficiency (memory-wise and execution-wise for some of these constants), I think it's better to keep track of the value as an integer. This is also how we handle the .responseType attribute in XMLHttpRequest::responseType() >> Source/WebCore/Modules/webaudio/OscillatorNode.cpp:91 >> + break; > > break is not needed. Ditto for other breaks. Fixed >> Source/WebCore/bindings/js/JSOscillatorNodeCustom.cpp:62 >> + setDOMException(exec, NOT_SUPPORTED_ERR); > > Maybe this logic should be: > > #if ENABLE(LEGACY_WEB_AUDIO) > if (value.isNumber()) { > ...; > } > #endif > > String type = value.toString(exec)0->value(exec); > if (exec->hadException()) { > ...; // Depends on the spec. > return; > } > ExceptionCode ec = 0; > imp->setType(value.toString(exec)->value(exec), ec); > ...; > } > > Please confirm the spec. I've switched the order as you suggest. I also added in the check for exec->hadException(), although I'm unsure why it's needed since we can already check/know that this is a string since we were calling value.isString(). Are you suggesting we remove the value.isString() check?? This is what I've assumed from your code above. >> Source/WebCore/bindings/v8/custom/V8OscillatorNodeCustom.cpp:66 >> + setDOMException(NOT_SUPPORTED_ERR, info.GetIsolate()); > > Ditto. I've made the same change of order as you suggested for JS bindings, and I've removed the check for value->IsString(). I'm assuming that in the case where the value cannot be converted to a string, then it will be equal to the empty string "", in which case imp->setType(...) will see this as an invalid value and the exception will be returned. 794134 13 haraken 2012-12-18 16:09:58 -0800 (In reply to comment #12) > We consider that this breaking behavior would be severe, so need to carefully support both. The getters are very much less commonly used than the setters, so although getting the attribute value has the potential to break pages since it will now return a string, we feel this will hurt very few pages using Web Audio. Makes sense. Thanks for the clarification! > >> Source/WebCore/Modules/webaudio/OscillatorNode.cpp:88 > >> + switch (m_type) { > > > > How about changing the type of m_type from unsigned short to AtomicString, because we're deprecating the unsigned short m_type? > > For efficiency (memory-wise and execution-wise for some of these constants), I think it's better to keep track of the value as an integer. This is also how we handle the .responseType attribute in XMLHttpRequest::responseType() The implementation of XMLHttpRequest::responseType() is just a legacy. My co-worker is trying to implement 'enum' in WebKit IDLs and replace the integers with AtomicStrings. As long as we use an AtomicString, I don't think it will cause any memory-wise or execution-wise problem. > >> Source/WebCore/bindings/js/JSOscillatorNodeCustom.cpp:62 > >> + setDOMException(exec, NOT_SUPPORTED_ERR); > > > > Maybe this logic should be: > > > > #if ENABLE(LEGACY_WEB_AUDIO) > > if (value.isNumber()) { > > ...; > > } > > #endif > > > > String type = value.toString(exec)0->value(exec); > > if (exec->hadException()) { > > ...; // Depends on the spec. > > return; > > } > > ExceptionCode ec = 0; > > imp->setType(value.toString(exec)->value(exec), ec); > > ...; > > } > > > > Please confirm the spec. > > I've switched the order as you suggest. I also added in the check for exec->hadException(), although I'm unsure why it's needed since we can already check/know that this is a string since we were calling value.isString(). Are you suggesting we remove the value.isString() check?? This is what I've assumed from your code above. I was assuming that removing the value.isString() check would be the expected behavior, but I'm not sure. I'd be happy you could check the spec. 794144 14 180028 haraken 2012-12-18 16:18:50 -0800 Comment on attachment 180028 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=180028&action=review > Source/WebCore/Modules/webaudio/OscillatorNode.cpp:116 > + else > + ec = NOT_SUPPORTED_ERR; According to the spec (http://www.w3.org/TR/WebIDL/#idl-enums), this error should be caught in the binding layer and should throw a TypeError. However, we cannot do it because we're not yet supporting 'enum' in the WebKit IDL. (My co-worker is implementing it.) For the time being, could you use context->addConsoleMessage(...) just like XMLHttpRequest::responseType() does? We'll fix the behavior once we implement 'enum'. > Source/WebCore/Modules/webaudio/OscillatorNode.h:65 > + void setType(unsigned, ExceptionCode&); > + void setType(const String&, ExceptionCode&); So ExceptionCode& is not needed. > Source/WebCore/Modules/webaudio/OscillatorNode.idl:39 > + setter raises(DOMException); 'setter raises(DOMException)' is not needed. According to the spec, the setter should not throw a DOMException to begin with. > Source/WebCore/bindings/js/JSOscillatorNodeCustom.cpp:56 > + setDOMException(exec, NOT_SUPPORTED_ERR); Shouldn't this be a JavaScript TypeError? http://www.w3.org/TR/WebIDL/#idl-enums > Source/WebCore/bindings/v8/custom/V8OscillatorNodeCustom.cpp:54 > + setDOMException(NOT_SUPPORTED_ERR, info.GetIsolate()); Ditto. 794154 15 crogers 2012-12-18 16:27:01 -0800 (In reply to comment #13) > (In reply to comment #12) > > We consider that this breaking behavior would be severe, so need to carefully support both. The getters are very much less commonly used than the setters, so although getting the attribute value has the potential to break pages since it will now return a string, we feel this will hurt very few pages using Web Audio. > > Makes sense. Thanks for the clarification! > > > >> Source/WebCore/Modules/webaudio/OscillatorNode.cpp:88 > > >> + switch (m_type) { > > > > > > How about changing the type of m_type from unsigned short to AtomicString, because we're deprecating the unsigned short m_type? > > > > For efficiency (memory-wise and execution-wise for some of these constants), I think it's better to keep track of the value as an integer. This is also how we handle the .responseType attribute in XMLHttpRequest::responseType() > > The implementation of XMLHttpRequest::responseType() is just a legacy. My co-worker is trying to implement 'enum' in WebKit IDLs and replace the integers with AtomicStrings. As long as we use an AtomicString, I don't think it will cause any memory-wise or execution-wise problem. > > > >> Source/WebCore/bindings/js/JSOscillatorNodeCustom.cpp:62 > > >> + setDOMException(exec, NOT_SUPPORTED_ERR); > > > > > > Maybe this logic should be: > > > > > > #if ENABLE(LEGACY_WEB_AUDIO) > > > if (value.isNumber()) { > > > ...; > > > } > > > #endif > > > > > > String type = value.toString(exec)0->value(exec); > > > if (exec->hadException()) { > > > ...; // Depends on the spec. > > > return; > > > } > > > ExceptionCode ec = 0; > > > imp->setType(value.toString(exec)->value(exec), ec); > > > ...; > > > } > > > > > > Please confirm the spec. > > > > I've switched the order as you suggest. I also added in the check for exec->hadException(), although I'm unsure why it's needed since we can already check/know that this is a string since we were calling value.isString(). Are you suggesting we remove the value.isString() check?? This is what I've assumed from your code above. > > I was assuming that removing the value.isString() check would be the expected behavior, but I'm not sure. I'd be happy you could check the spec. Actually I'm the spec editor, but I'm not sure I understand what the distinction is. I'm expecting either an integer value or a string value will be assigned to these attributes. Is this code supposed to handle more cases, where non-string objects could potentially be converted to strings which would be meaningful here? Are there such cases with Web APIs where this is useful? A concrete example using some other API might be helpful to help me understand, so I can see what the idea is - thanks :) 794172 16 haraken 2012-12-18 16:35:40 -0800 (In reply to comment #15) > Actually I'm the spec editor, but I'm not sure I understand what the distinction is. I'm expecting either an integer value or a string value will be assigned to these attributes. Is this code supposed to handle more cases, where non-string objects could potentially be converted to strings which would be meaningful here? Are there such cases with Web APIs where this is useful? A concrete example using some other API might be helpful to help me understand, so I can see what the idea is - thanks :) I rechecked the Web IDL spec (http://www.w3.org/TR/WebIDL/#idl-enums)... sorry, you're right. Then a right way to implement it would be: #if LEGACY if (value.isInteger()) { ...; } #endif if (value.isString()) { String type = value.toString(exec)0->value(exec); if (type == "sine" || type == "square" || ...) { imp->setType(type); return; } } throwVMTypeError(...); return; What do you think? 795020 17 180242 crogers 2012-12-19 16:20:35 -0800 Created attachment 180242 Patch 795023 18 crogers 2012-12-19 16:23:52 -0800 (In reply to comment #16) > (In reply to comment #15) > > Actually I'm the spec editor, but I'm not sure I understand what the distinction is. I'm expecting either an integer value or a string value will be assigned to these attributes. Is this code supposed to handle more cases, where non-string objects could potentially be converted to strings which would be meaningful here? Are there such cases with Web APIs where this is useful? A concrete example using some other API might be helpful to help me understand, so I can see what the idea is - thanks :) > > I rechecked the Web IDL spec (http://www.w3.org/TR/WebIDL/#idl-enums)... sorry, you're right. > > Then a right way to implement it would be: > > #if LEGACY > if (value.isInteger()) { > ...; > } > #endif > > if (value.isString()) { > String type = value.toString(exec)0->value(exec); > if (type == "sine" || type == "square" || ...) { > imp->setType(type); > return; > } > } > throwVMTypeError(...); > return; > > > What do you think? Sounds good to me - patch updated. The m_type I still feel is better as an integer value, since these values (not the OscillatorNode, but the other ones) have concurrency issues and are accessed by another thread (real-time audio thread). Although the AtomicString footprint might be small, it is still inefficient and more cumbersome to deal with internally where these values are used. I've discussed this with Ken Russell and he agrees, so leaving this part as is. 795027 19 180242 haraken 2012-12-19 16:33:34 -0800 Comment on attachment 180242 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=180242&action=review Thanks for updating the patch. Looks almost OK to me. I understood that m_type should be integers, which sounds reasonable to me. > Source/WebCore/Modules/webaudio/OscillatorNode.cpp:115 > + if (type == "sine") > + setType(SINE); > + else if (type == "square") > + setType(SQUARE); > + else if (type == "sawtooth") > + setType(SAWTOOTH); > + else if (type == "triangle") > + setType(TRIANGLE); > + else > + return false; Would you do this validation in JSOscillatorNodeCustom.cpp and V8OscillatorNodeCustom.cpp, because the validation is a concept defined in the Web IDL spec and thus should be resolved in the binding layer not in the WebCore layer? The signature of OscillatorNode::setType should be 'void OscillatorNode::setType(const String& type)'. I know it will lead to code duplication (i.e. we need to write 'if (type == ...)' in three places), but I think it would be the right thing to do. (Though the right thing to do is to auto-generate the binding code:-) 795028 20 180242 haraken 2012-12-19 16:34:34 -0800 Comment on attachment 180242 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=180242&action=review > Source/WebCore/bindings/v8/custom/V8OscillatorNodeCustom.cpp:48 > + throwError(v8TypeError, "Illegal OscillatorNode type", info.GetIsolate()); Would you make the error message identical between JSC and V8? > Source/WebCore/bindings/v8/custom/V8OscillatorNodeCustom.cpp:59 > + throwError(v8TypeError, "Illegal OscillatorNode type", info.GetIsolate()); Ditto. > LayoutTests/webaudio/oscillator-basic-expected.txt:12 > +PASS Oscillator correctly set to SINE type using legacy integer value. > +PASS Oscillator correctly set to SQUARE type using legacy integer value. > +PASS Oscillator correctly set to SAWTOOTH type using legacy integer value. > +PASS Oscillator correctly set to TRIANGLE type using legacy integer value. Would you add a test case that throws a TypeError? 796471 21 180559 crogers 2012-12-21 14:46:06 -0800 Created attachment 180559 Patch 796474 22 crogers 2012-12-21 14:47:30 -0800 (In reply to comment #19) > (From update of attachment 180242 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=180242&action=review > > Thanks for updating the patch. Looks almost OK to me. I understood that m_type should be integers, which sounds reasonable to me. > > > Source/WebCore/Modules/webaudio/OscillatorNode.cpp:115 > > + if (type == "sine") > > + setType(SINE); > > + else if (type == "square") > > + setType(SQUARE); > > + else if (type == "sawtooth") > > + setType(SAWTOOTH); > > + else if (type == "triangle") > > + setType(TRIANGLE); > > + else > > + return false; > > Would you do this validation in JSOscillatorNodeCustom.cpp and V8OscillatorNodeCustom.cpp, because the validation is a concept defined in the Web IDL spec and thus should be resolved in the binding layer not in the WebCore layer? The signature of OscillatorNode::setType should be 'void OscillatorNode::setType(const String& type)'. > > I know it will lead to code duplication (i.e. we need to write 'if (type == ...)' in three places), but I think it would be the right thing to do. (Though the right thing to do is to auto-generate the binding code:-) Fixed. 796477 23 crogers 2012-12-21 14:51:13 -0800 (In reply to comment #20) > (From update of attachment 180242 [details]) > View in context: https://bugs.webkit.org/attachment.cgi?id=180242&action=review > > > Source/WebCore/bindings/v8/custom/V8OscillatorNodeCustom.cpp:48 > > + throwError(v8TypeError, "Illegal OscillatorNode type", info.GetIsolate()); > > Would you make the error message identical between JSC and V8? JSC error message has been fixed to be consistent. > > > Source/WebCore/bindings/v8/custom/V8OscillatorNodeCustom.cpp:59 > > + throwError(v8TypeError, "Illegal OscillatorNode type", info.GetIsolate()); > > Ditto. JSC error message has been fixed to be consistent. > > > LayoutTests/webaudio/oscillator-basic-expected.txt:12 > > +PASS Oscillator correctly set to SINE type using legacy integer value. > > +PASS Oscillator correctly set to SQUARE type using legacy integer value. > > +PASS Oscillator correctly set to SAWTOOTH type using legacy integer value. > > +PASS Oscillator correctly set to TRIANGLE type using legacy integer value. > > Would you add a test case that throws a TypeError? Fixed: added two new tests to check that illegal string value and illegal type (non-string object) throws TypeError specifically. Kentaro, thanks for having a look so far. If this looks OK, then I'd like to land this patch and address the other attributes in a "part 2" followup patch. 796562 24 180559 haraken 2012-12-21 17:25:35 -0800 Comment on attachment 180559 Patch View in context: https://bugs.webkit.org/attachment.cgi?id=180559&action=review LGTM. Thanks for the patch! > Source/WebCore/Modules/webaudio/OscillatorNode.cpp:113 > + else if (type == "triangle") > + setType(TRIANGLE); Let's add: else ASSERT_NOT_REACHED(); 798802 25 crogers 2013-01-02 12:29:12 -0800 Committed r138631: <http://trac.webkit.org/changeset/138631> 179849 2012-12-17 18:33:18 -0800 2012-12-18 14:31:51 -0800 Patch bug-105058-20121217183035.patch text/plain 22057 crogers U3VidmVyc2lvbiBSZXZpc2lvbjogMTM3OTU4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZTAwZDk4YTM3MjRhNjhm ZDAyNGViOGJkYTQzODRhNjk3YjdlMTc5MC4uYjZiOTBmYTk2MDBiNWQwNWYzYWEyYzBhOGZlYmM3 ZGM5MTU2ZDEwMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEyLTEyLTE3ICBDaHJp cyBSb2dlcnMgIDxjcm9nZXJzQGdvb2dsZS5jb20+CisKKyAgICAgICAgSW1wbGVtZW50IFdlYklE TC1zdHlsZSBzdHJpbmcgY29uc3RhbnRzIGluIFdlYkF1ZGlvCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDUwNTgKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTZWUgRGVwcmVjYXRpb24gTm90ZXMgZm9yIG1v cmUgZGV0YWlsOgorICAgICAgICBodHRwczovL2R2Y3MudzMub3JnL2hnL2F1ZGlvL3Jhdy1maWxl L3RpcC93ZWJhdWRpby9zcGVjaWZpY2F0aW9uLmh0bWwjRGVwcmVjYXRpb25Ob3RlcworCisgICAg ICAgIFBhbm5lck5vZGUsIEJpcXVhZEZpbHRlck5vZGUsIE9zY2lsbGF0b3JOb2RlIGNvbnN0YW50 cyBtdXN0IHN1cHBvcnQgV2ViSURMLXN0eWxlIHN0cmluZyBjb25zdGFudHMuCisgICAgICAgIExl Z2FjeSBzdXBwb3J0IGluIHRoZSBzZXR0ZXJzIGZvciB0aGUgb2xkIGludGVnZXIgdmFsdWVzIHNo b3VsZCBiZSBzdXBwb3J0ZWQuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFtOgorICAg ICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6T3NjaWxsYXRvck5vZGU6OnR5cGUpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAg IChXZWJDb3JlOjpPc2NpbGxhdG9yTm9kZTo6c2V0VHlwZSk6CisgICAgICAgICogTW9kdWxlcy93 ZWJhdWRpby9Pc2NpbGxhdG9yTm9kZS5oOgorICAgICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vT3Nj aWxsYXRvck5vZGUuaWRsOgorICAgICAgICAqIFRhcmdldC5wcmk6CisgICAgICAgICogVXNlSlND LmNtYWtlOgorICAgICAgICAqIFVzZVY4LmNtYWtlOgorICAgICAgICAqIFdlYkNvcmUuZ3lwaToK KyAgICAgICAgKiBXZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICog YmluZGluZ3MvanMvSlNPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHA6IENvcGllZCBmcm9tIFNvdXJj ZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuaWRsLgorICAgICAgICAo V2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpKU09zY2lsbGF0b3JOb2RlOjpzZXRUeXBlKToK KyAgICAgICAgKiBiaW5kaW5ncy92OC9jdXN0b20vVjhPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHA6 IENvcGllZCBmcm9tIFNvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5v ZGUuaWRsLgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpWOE9zY2lsbGF0 b3JOb2RlOjp0eXBlQWNjZXNzb3JTZXR0ZXIpOgorCiAyMDEyLTEyLTE3ICBTaW1vbiBGcmFzZXIg IDxzaW1vbi5mcmFzZXJAYXBwbGUuY29tPgogCiAgICAgICAgIEZpeCByZXBvc2l0aW9uaW5nIG9m IGZpeGVkIGVsZW1lbnRzIG9uIHpvb21pbmcKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL0dO VW1ha2VmaWxlLmxpc3QuYW0gYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmlsZS5saXN0LmFtCmlu ZGV4IGI3YTZhMmM4NDM0ZjI3ZmJiNWEyMTRjMjQxNDE4ODNkNTVjZmFhNjkuLjRiYzVhZTk1MzUw OWVkNzNjMzRjN2FhMDI0ZTBkNTQxODBmMDRmYzIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L0dOVW1ha2VmaWxlLmxpc3QuYW0KKysrIGIvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlz dC5hbQpAQCAtMjM3OCw2ICsyMzc4LDcgQEAgd2ViY29yZV9zb3VyY2VzICs9IFwKIAlTb3VyY2Uv V2ViQ29yZS9iaW5kaW5ncy9qcy9KU05vZGVGaWx0ZXJDdXN0b20uY3BwIFwKIAlTb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9qcy9KU05vZGVJdGVyYXRvckN1c3RvbS5jcHAgXAogCVNvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL2pzL0pTTm9kZUxpc3RDdXN0b20uY3BwIFwKKwlTb3VyY2UvV2ViQ29yZS9i aW5kaW5ncy9qcy9KU09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcCBcCiAJU291cmNlL1dlYkNvcmUv YmluZGluZ3MvanMvSlNQbHVnaW5FbGVtZW50RnVuY3Rpb25zLmNwcCBcCiAJU291cmNlL1dlYkNv cmUvYmluZGluZ3MvanMvSlNQbHVnaW5FbGVtZW50RnVuY3Rpb25zLmggXAogCVNvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL2pzL0pTUG9wU3RhdGVFdmVudEN1c3RvbS5jcHAgXApkaWZmIC0tZ2l0IGEv U291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9Pc2NpbGxhdG9yTm9kZS5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmNwcAppbmRleCA2OGRm OWEzYmZiMjM0OTkzYWJhMGRhNWY4NzQ2Mzc0MGM3OGE0OGQzLi41NzcwMTQ1MGRlMmRiODBkNDU2 NDY5ZWFiYzcwMTYyN2UwYTBiY2JkIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVz L3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmNwcAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVz L3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmNwcApAQCAtODMsNyArODMsNDYgQEAgT3NjaWxsYXRv ck5vZGU6On5Pc2NpbGxhdG9yTm9kZSgpCiAgICAgdW5pbml0aWFsaXplKCk7CiB9CiAKLXZvaWQg T3NjaWxsYXRvck5vZGU6OnNldFR5cGUodW5zaWduZWQgc2hvcnQgdHlwZSwgRXhjZXB0aW9uQ29k ZSYgZWMpCitTdHJpbmcgT3NjaWxsYXRvck5vZGU6OnR5cGUoKSBjb25zdAoreworICAgIHN3aXRj aCAobV90eXBlKSB7CisgICAgY2FzZSBTSU5FOgorICAgICAgICByZXR1cm4gInNpbmUiOworICAg ICAgICBicmVhazsKKyAgICBjYXNlIFNRVUFSRToKKyAgICAgICAgcmV0dXJuICJzcXVhcmUiOwor ICAgICAgICBicmVhazsKKyAgICBjYXNlIFNBV1RPT1RIOgorICAgICAgICByZXR1cm4gInNhd3Rv b3RoIjsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSBUUklBTkdMRToKKyAgICAgICAgcmV0dXJu ICJ0cmlhbmdsZSI7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgQ1VTVE9NOgorICAgICAgICBy ZXR1cm4gImN1c3RvbSI7CisgICAgICAgIGJyZWFrOworICAgIGRlZmF1bHQ6CisgICAgICAgIEFT U0VSVF9OT1RfUkVBQ0hFRCgpOworICAgICAgICByZXR1cm4gImN1c3RvbSI7CisgICAgICAgIGJy ZWFrOworICAgIH0KK30KKwordm9pZCBPc2NpbGxhdG9yTm9kZTo6c2V0VHlwZShjb25zdCBTdHJp bmcmIHR5cGUsIEV4Y2VwdGlvbkNvZGUmIGVjKQoreworICAgIGlmICh0eXBlID09ICJzaW5lIikK KyAgICAgICAgc2V0VHlwZShTSU5FLCBlYyk7CisgICAgZWxzZSBpZiAodHlwZSA9PSAic3F1YXJl IikKKyAgICAgICAgc2V0VHlwZShTUVVBUkUsIGVjKTsKKyAgICBlbHNlIGlmICh0eXBlID09ICJz YXd0b290aCIpCisgICAgICAgIHNldFR5cGUoU0FXVE9PVEgsIGVjKTsKKyAgICBlbHNlIGlmICh0 eXBlID09ICJ0cmlhbmdsZSIpCisgICAgICAgIHNldFR5cGUoVFJJQU5HTEUsIGVjKTsKKyAgICBl bHNlCisgICAgICAgIGVjID0gTk9UX1NVUFBPUlRFRF9FUlI7Cit9CisKK3ZvaWQgT3NjaWxsYXRv ck5vZGU6OnNldFR5cGUodW5zaWduZWQgdHlwZSwgRXhjZXB0aW9uQ29kZSYgZWMpCiB7CiAgICAg V2F2ZVRhYmxlKiB3YXZlVGFibGUgPSAwOwogICAgIGZsb2F0IHNhbXBsZVJhdGUgPSB0aGlzLT5z YW1wbGVSYXRlKCk7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlv L09zY2lsbGF0b3JOb2RlLmggYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL09zY2ls bGF0b3JOb2RlLmgKaW5kZXggMWQ2YjE1MjM2MDhlMWRjMGI4YmY1MTA4Y2Q5OTg5NTBmYjE3NzA0 ZC4uYjhlYTI0OTJkYTkzMTc0M2I3NzcwMjAxNzQ4NDIzNzQ5YzZmMzAzZiAxMDA2NDQKLS0tIGEv U291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9Pc2NpbGxhdG9yTm9kZS5oCisrKyBiL1Nv dXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuaApAQCAtNjAsOCAr NjAsOSBAQCBwdWJsaWM6CiAgICAgdmlydHVhbCB2b2lkIHByb2Nlc3Moc2l6ZV90IGZyYW1lc1Rv UHJvY2Vzcyk7CiAgICAgdmlydHVhbCB2b2lkIHJlc2V0KCk7CiAKLSAgICB1bnNpZ25lZCBzaG9y dCB0eXBlKCkgY29uc3QgeyByZXR1cm4gbV90eXBlOyB9Ci0gICAgdm9pZCBzZXRUeXBlKHVuc2ln bmVkIHNob3J0LCBFeGNlcHRpb25Db2RlJik7CisgICAgU3RyaW5nIHR5cGUoKSBjb25zdDsKKyAg ICB2b2lkIHNldFR5cGUodW5zaWduZWQsIEV4Y2VwdGlvbkNvZGUmKTsKKyAgICB2b2lkIHNldFR5 cGUoY29uc3QgU3RyaW5nJiwgRXhjZXB0aW9uQ29kZSYpOwogCiAgICAgQXVkaW9QYXJhbSogZnJl cXVlbmN5KCkgeyByZXR1cm4gbV9mcmVxdWVuY3kuZ2V0KCk7IH0KICAgICBBdWRpb1BhcmFtKiBk ZXR1bmUoKSB7IHJldHVybiBtX2RldHVuZS5nZXQoKTsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvTW9kdWxlcy93ZWJhdWRpby9Pc2NpbGxhdG9yTm9kZS5pZGwgYi9Tb3VyY2UvV2ViQ29y ZS9Nb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmlkbAppbmRleCAzNGVjMzc2ZTJkMzI5 NGQ4MjgwOTU1ZDU3Yzc1NTI1YzU2MDVhZjczLi4xZDllNmFiM2VjMjVkMjEzOGY3YjA3OTRhNWE2 MmQ3NzZkNzllMDIwIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlv L09zY2lsbGF0b3JOb2RlLmlkbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlv L09zY2lsbGF0b3JOb2RlLmlkbApAQCAtMzUsOCArMzUsOCBAQAogICAgIGNvbnN0IHVuc2lnbmVk IHNob3J0IFRSSUFOR0xFID0gMzsKICAgICBjb25zdCB1bnNpZ25lZCBzaG9ydCBDVVNUT00gPSA0 OwogCi0gICAgYXR0cmlidXRlIHVuc2lnbmVkIHNob3J0IHR5cGUKLSAgICAgICAgc2V0dGVyIHJh aXNlcyhET01FeGNlcHRpb24pOyAgICAgICAgCisgICAgW0N1c3RvbVNldHRlcl0gYXR0cmlidXRl IERPTVN0cmluZyB0eXBlCisgICAgICAgIHNldHRlciByYWlzZXMoRE9NRXhjZXB0aW9uKTsKIAog ICAgIC8vIFBsYXliYWNrIHN0YXRlIGNvbnN0YW50cy4KICAgICBjb25zdCB1bnNpZ25lZCBzaG9y dCBVTlNDSEVEVUxFRF9TVEFURSA9IDA7CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9UYXJn ZXQucHJpIGIvU291cmNlL1dlYkNvcmUvVGFyZ2V0LnByaQppbmRleCBhNjhhZDg0ZjQzNTlmZDE3 ZjY3NTkxNzQyZjQ1OGQ3ODFjMDNmMjg4Li5iOGJiNzc0OTFjMGNiMGRjNWJmNmIxMmI0YzIyYzEz NDdmN2VmMzg2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9UYXJnZXQucHJpCisrKyBiL1Nv dXJjZS9XZWJDb3JlL1RhcmdldC5wcmkKQEAgLTM0MTQsNiArMzQxNCw3IEBAIGVuYWJsZT8oV0VC X0FVRElPKSB7CiAgICAgICAgIGJpbmRpbmdzL2pzL0pTQXVkaW9CdWZmZXJTb3VyY2VOb2RlQ3Vz dG9tLmNwcCBcCiAgICAgICAgIGJpbmRpbmdzL2pzL0pTQXVkaW9Db250ZXh0Q3VzdG9tLmNwcCBc CiAgICAgICAgIGJpbmRpbmdzL2pzL0pTRE9NV2luZG93V2ViQXVkaW9DdXN0b20uY3BwIFwKKyAg ICAgICAgYmluZGluZ3MvanMvSlNPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHAgXAogICAgICAgICBi aW5kaW5ncy9qcy9KU1NjcmlwdFByb2Nlc3Nvck5vZGVDdXN0b20uY3BwIFwKICAgICAgICAgTW9k dWxlcy93ZWJhdWRpby9Bc3luY0F1ZGlvRGVjb2Rlci5jcHAgXAogICAgICAgICBNb2R1bGVzL3dl YmF1ZGlvL0F1ZGlvQmFzaWNJbnNwZWN0b3JOb2RlLmNwcCBcCmRpZmYgLS1naXQgYS9Tb3VyY2Uv V2ViQ29yZS9Vc2VKU0MuY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9Vc2VKU0MuY21ha2UKaW5kZXgg ODlmZjhjYjJkOTcxYmY1ZjI1ZjJiMzNhZGRlYTQ1NDY3MWRiZDkyNS4uYTY5NTQxZDE4MTMyZWM3 MjNiZjgzNjNmMTY2NTFiOWNhMjA1ODU3ZSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvVXNl SlNDLmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1VzZUpTQy5jbWFrZQpAQCAtMjcxLDYgKzI3 MSw3IEBAIGlmIChFTkFCTEVfV0VCX0FVRElPKQogICAgIGxpc3QoQVBQRU5EIFdlYkNvcmVfU09V UkNFUwogICAgICAgICBiaW5kaW5ncy9qcy9KU0F1ZGlvQnVmZmVyU291cmNlTm9kZUN1c3RvbS5j cHAKICAgICAgICAgYmluZGluZ3MvanMvSlNBdWRpb0NvbnRleHRDdXN0b20uY3BwCisgICAgICAg IGJpbmRpbmdzL2pzL0pTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwCiAgICAgICAgIGJpbmRpbmdz L2pzL0pTU2NyaXB0UHJvY2Vzc29yTm9kZUN1c3RvbS5jcHAKICAgICApCiBlbmRpZiAoKQpkaWZm IC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvVXNlVjguY21ha2UgYi9Tb3VyY2UvV2ViQ29yZS9Vc2VW OC5jbWFrZQppbmRleCBkZTRlNzE1M2ZhMDVlMWYyMmUyNjZhYzUzYTMyYzM1ZmM2Mjc3N2Y1Li40 YTA4MTQ4N2ZkMGQ2YjE5MDI5NWUyMDU2OWRlMDRlMjgwNmI0NjJjIDEwMDY0NAotLS0gYS9Tb3Vy Y2UvV2ViQ29yZS9Vc2VWOC5jbWFrZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9Vc2VWOC5jbWFrZQpA QCAtMTM3LDYgKzEzNyw3IEBAIGxpc3QoQVBQRU5EIFdlYkNvcmVfU09VUkNFUwogICAgIGJpbmRp bmdzL3Y4L2N1c3RvbS9WOE5vZGVMaXN0Q3VzdG9tLmNwcAogICAgIGJpbmRpbmdzL3Y4L2N1c3Rv bS9WOE5vdGlmaWNhdGlvbkN1c3RvbS5jcHAKICAgICBiaW5kaW5ncy92OC9jdXN0b20vVjhOb3Rp ZmljYXRpb25DZW50ZXJDdXN0b20uY3BwCisgICAgYmluZGluZ3MvdjgvY3VzdG9tL1Y4T3NjaWxs YXRvck5vZGVDdXN0b20uY3BwCiAgICAgYmluZGluZ3MvdjgvY3VzdG9tL1Y4UGVyZm9ybWFuY2VF bnRyeUN1c3RvbS5jcHAKICAgICBiaW5kaW5ncy92OC9jdXN0b20vVjhQb3BTdGF0ZUV2ZW50Q3Vz dG9tLmNwcAogICAgIGJpbmRpbmdzL3Y4L2N1c3RvbS9WOFNRTFJlc3VsdFNldFJvd0xpc3RDdXN0 b20uY3BwCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkgYi9Tb3VyY2Uv V2ViQ29yZS9XZWJDb3JlLmd5cGkKaW5kZXggYTBmZGJkNjBlYmUxYWQyMWExY2FhOThjNjE0ZTg0 YTY3YmZlOGJiMC4uMDEwZDY5NDEyMmRiZmJlYTQ5OGQ2M2QxMmEwZDU0OWM4YTcxZDFjMyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCisrKyBiL1NvdXJjZS9XZWJDb3Jl L1dlYkNvcmUuZ3lwaQpAQCAtMTM2OSw2ICsxMzY5LDcgQEAKICAgICAgICAgICAgICdiaW5kaW5n cy92OC9jdXN0b20vVjhOb2RlTGlzdEN1c3RvbS5jcHAnLAogICAgICAgICAgICAgJ2JpbmRpbmdz L3Y4L2N1c3RvbS9WOE5vdGlmaWNhdGlvbkN1c3RvbS5jcHAnLAogICAgICAgICAgICAgJ2JpbmRp bmdzL3Y4L2N1c3RvbS9WOE5vdGlmaWNhdGlvbkNlbnRlckN1c3RvbS5jcHAnLAorICAgICAgICAg ICAgJ2JpbmRpbmdzL3Y4L2N1c3RvbS9WOE9zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcCcsCiAgICAg ICAgICAgICAnYmluZGluZ3MvdjgvY3VzdG9tL1Y4UGVyZm9ybWFuY2VFbnRyeUN1c3RvbS5jcHAn LAogICAgICAgICAgICAgJ2JpbmRpbmdzL3Y4L2N1c3RvbS9WOFBvcFN0YXRlRXZlbnRDdXN0b20u Y3BwJywKICAgICAgICAgICAgICdiaW5kaW5ncy92OC9jdXN0b20vVjhTUUxSZXN1bHRTZXRSb3dM aXN0Q3VzdG9tLmNwcCcsCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2Rl cHJvai9wcm9qZWN0LnBieHByb2ogYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9w cm9qZWN0LnBieHByb2oKaW5kZXggMjFkZDE4MDUzYTJmZDczZWQxYjA0ZjFiM2Q3NWFiMzVjMjM0 ZDg5OS4uYjJhYjBmMDI1M2EwYjE1MWU3ZGYwNWM0YTIzMDg0MjdlMDRlYTYxOSAxMDA2NDQKLS0t IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBi L1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtNjYz MCw2ICs2NjMwLDcgQEAKIAkJRkRCMDUyRTAxNTYxQTQyQzAwQjUwMEQ2IC8qIEF1ZGlvU3VtbWlu Z0p1bmN0aW9uLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYg PSBGREIwNTJERTE1NjFBNDJDMDBCNTAwRDYgLyogQXVkaW9TdW1taW5nSnVuY3Rpb24uaCAqLzsg fTsKIAkJRkRCMTcwMDUxNEEyQkFCMjAwQTJCNUQ5IC8qIE11bHRpQ2hhbm5lbFJlc2FtcGxlci5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGREIxNzAw MzE0QTJCQUIyMDBBMkI1RDkgLyogTXVsdGlDaGFubmVsUmVzYW1wbGVyLmNwcCAqLzsgfTsKIAkJ RkRCMTcwMDYxNEEyQkFCMjAwQTJCNUQ5IC8qIE11bHRpQ2hhbm5lbFJlc2FtcGxlci5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkRCMTcwMDQxNEEyQkFC MjAwQTJCNUQ5IC8qIE11bHRpQ2hhbm5lbFJlc2FtcGxlci5oICovOyB9OworCQlGREJEMURGQzE2 N0ZFMjdEMDA1MUExMUUgLyogSlNPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHAgaW4gU291cmNlcyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGREJEMURGQjE2N0ZFMjdEMDA1MUEx MUUgLyogSlNPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHAgKi87IH07CiAJCUZEQkQ0ODBDMTU5QkM2 ODcwMDkzRUI0RiAvKiBKU01lZGlhU3RyZWFtQXVkaW9Tb3VyY2VOb2RlLmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZEQkQ0ODBBMTU5QkM2ODcwMDkz RUI0RiAvKiBKU01lZGlhU3RyZWFtQXVkaW9Tb3VyY2VOb2RlLmNwcCAqLzsgfTsKIAkJRkRCRDQ4 MEQxNTlCQzY4NzAwOTNFQjRGIC8qIEpTTWVkaWFTdHJlYW1BdWRpb1NvdXJjZU5vZGUuaCBpbiBI ZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZEQkQ0ODBCMTU5QkM2 ODcwMDkzRUI0RiAvKiBKU01lZGlhU3RyZWFtQXVkaW9Tb3VyY2VOb2RlLmggKi87IH07CiAJCUZE QzU0RjA0MTM5OUIwREEwMDhEOTExNyAvKiBCaXF1YWRGaWx0ZXJOb2RlLmNwcCBpbiBTb3VyY2Vz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZEQzU0RjAxMTM5OUIwREEwMDhE OTExNyAvKiBCaXF1YWRGaWx0ZXJOb2RlLmNwcCAqLzsgfTsKQEAgLTE0MTk0LDYgKzE0MTk1LDcg QEAKIAkJRkRCMDUyREUxNTYxQTQyQzAwQjUwMEQ2IC8qIEF1ZGlvU3VtbWluZ0p1bmN0aW9uLmgg Ki8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3du RmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEF1ZGlvU3VtbWluZ0p1bmN0aW9uLmg7 IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZEQjE3MDAzMTRBMkJBQjIwMEEyQjVEOSAv KiBNdWx0aUNoYW5uZWxSZXNhbXBsZXIuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3Bw OyBwYXRoID0gTXVsdGlDaGFubmVsUmVzYW1wbGVyLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+ IjsgfTsKIAkJRkRCMTcwMDQxNEEyQkFCMjAwQTJCNUQ5IC8qIE11bHRpQ2hhbm5lbFJlc2FtcGxl ci5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBNdWx0aUNoYW5uZWxSZXNhbXBs ZXIuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJRkRCRDFERkIxNjdGRTI3RDAwNTFB MTFFIC8qIEpTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBwYXRoID0gSlNPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHA7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCUZEQkQ0ODBBMTU5QkM2ODcwMDkzRUI0RiAvKiBKU01lZGlhU3RyZWFt QXVkaW9Tb3VyY2VOb2RlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9 IEpTTWVkaWFTdHJlYW1BdWRpb1NvdXJjZU5vZGUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4i OyB9OwogCQlGREJENDgwQjE1OUJDNjg3MDA5M0VCNEYgLyogSlNNZWRpYVN0cmVhbUF1ZGlvU291 cmNlTm9kZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBKU01lZGlhU3RyZWFt QXVkaW9Tb3VyY2VOb2RlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZEQzU0RjAx MTM5OUIwREEwMDhEOTExNyAvKiBCaXF1YWRGaWx0ZXJOb2RlLmNwcCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEJpcXVhZEZpbHRlck5vZGUuY3BwOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwpAQCAtMjA2OTcsNiArMjA2OTksNyBAQAogCQkJCTFBNzUwREQzMEE5MEU3 MjkwMDBGRjIxNSAvKiBKU05vZGVJdGVyYXRvckN1c3RvbS5jcHAgKi8sCiAJCQkJQkNEOUMyNjEw QzE3QUE2NzAwNUM5MEEyIC8qIEpTTm9kZUxpc3RDdXN0b20uY3BwICovLAogCQkJCTMxRkU2RTZD MTUwMUEzQkYwMDA0RUJDNCAvKiBKU05vdGlmaWNhdGlvbkN1c3RvbS5jcHAgKi8sCisJCQkJRkRC RDFERkIxNjdGRTI3RDAwNTFBMTFFIC8qIEpTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwICovLAog CQkJCUE4NUYyMjA4MTQzMDM3N0QwMDdDQzg4NCAvKiBKU1BvcFN0YXRlRXZlbnRDdXN0b20uY3Bw ICovLAogCQkJCUUxQUQxMkQ1MTI5NUQwQkQwMEFDQTk4OSAvKiBKU1Byb2Nlc3NpbmdJbnN0cnVj dGlvbkN1c3RvbS5jcHAgKi8sCiAJCQkJNDk5OEFFRDMxM0ZDNDE3RjAwOTBCMUFBIC8qIEpTUmVx dWVzdEFuaW1hdGlvbkZyYW1lQ2FsbGJhY2tDdXN0b20uY3BwICovLApAQCAtMjkwNzUsNiArMjkw NzgsNyBAQAogCQkJCUYzN0E1NjIyMTY3OUNGN0IwMEM1NzA0NiAvKiBIZWFwR3JhcGhTZXJpYWxp emVyLmNwcCBpbiBTb3VyY2VzICovLAogCQkJCUNEMUU3MzQ3MTY3QkM3OEUwMDlBODg1RCAvKiBU ZXh0VHJhY2tSZXByZXNlbnRhdGlvbi5jcHAgaW4gU291cmNlcyAqLywKIAkJCQk5QTlDRUY4RDE2 M0IzRUExMDBERTdFRkUgLyogRXhjbHVzaW9uU2hhcGVPdXRzaWRlSW5mby5jcHAgaW4gU291cmNl cyAqLywKKwkJCQlGREJEMURGQzE2N0ZFMjdEMDA1MUExMUUgLyogSlNPc2NpbGxhdG9yTm9kZUN1 c3RvbS5jcHAgaW4gU291cmNlcyAqLywKIAkJCSk7CiAJCQlydW5Pbmx5Rm9yRGVwbG95bWVudFBv c3Rwcm9jZXNzaW5nID0gMDsKIAkJfTsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRp bmdzL2pzL0pTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGlu Z3MvanMvSlNPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMC4uYzkzNThmM2NmZDEw MDQ2NzFjNzgzZmJiNDRkZjRlYjUwYzIzNTYwZAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9X ZWJDb3JlL2JpbmRpbmdzL2pzL0pTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwCkBAIC0wLDAgKzEs NjcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIsIEdvb2dsZSBJbmMuIEFsbCByaWdodHMg cmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJp bmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0 ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6Cisg KiAxLiAgUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5 IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRo ZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdp dGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZ IEFQUExFIElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORCBBTlkKKyAqIEVY UFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywgVEhFIElNUExJRUQKKyAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKKyAqIERJU0NMQUlNRUQuIElOIE5PIEVW RU5UIFNIQUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFO WQorICogRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBP UiBDT05TRVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywgUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1Mg T0YgVVNFLCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VW RVIgQ0FVU0VEIEFORCBPTgorICogQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4g Q09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElH RU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBU SElTCisgKiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBT VUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpZiBFTkFCTEUoV0VC X0FVRElPKQorCisjaW5jbHVkZSAiSlNPc2NpbGxhdG9yTm9kZS5oIgorCisjaW5jbHVkZSAiRXhj ZXB0aW9uQ29kZS5oIgorI2luY2x1ZGUgIk9zY2lsbGF0b3JOb2RlLmgiCisjaW5jbHVkZSA8cnVu dGltZS9FcnJvci5oPgorCit1c2luZyBuYW1lc3BhY2UgSlNDOworCituYW1lc3BhY2UgV2ViQ29y ZSB7CisKK3ZvaWQgSlNPc2NpbGxhdG9yTm9kZTo6c2V0VHlwZShFeGVjU3RhdGUqIGV4ZWMsIEpT VmFsdWUgdmFsdWUpCit7CisgICAgT3NjaWxsYXRvck5vZGUqIGltcCA9IHN0YXRpY19jYXN0PE9z Y2lsbGF0b3JOb2RlKj4oaW1wbCgpKTsKKworICAgIGlmICh2YWx1ZS5pc1N0cmluZygpKSB7Cisg ICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOworICAgICAgICBpbXAtPnNldFR5cGUodmFsdWUu dG9TdHJpbmcoZXhlYyktPnZhbHVlKGV4ZWMpLCBlYyk7CisgICAgICAgIGlmIChlYykKKyAgICAg ICAgICAgIHNldERPTUV4Y2VwdGlvbihleGVjLCBlYyk7CisgICAgICAgIHJldHVybjsKKyAgICB9 CisKKyNpZiBFTkFCTEUoTEVHQUNZX1dFQl9BVURJTykKKyAgICBpZiAodmFsdWUuaXNOdW1iZXIo KSkgeworICAgICAgICB1aW50MzJfdCB0eXBlID0gdmFsdWUudG9VSW50MzIoZXhlYyk7CisgICAg ICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOworICAgICAgICBpbXAtPnNldFR5cGUodHlwZSwgZWMp OworICAgICAgICBpZiAoZWMpCisgICAgICAgICAgICBzZXRET01FeGNlcHRpb24oZXhlYywgZWMp OworICAgICAgICByZXR1cm47CisgICAgfQorI2VuZGlmCisKKyAgICBzZXRET01FeGNlcHRpb24o ZXhlYywgTk9UX1NVUFBPUlRFRF9FUlIpOworfQorCit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisK KyNlbmRpZiAvLyBFTkFCTEUoV0VCX0FVRElPKQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv YmluZGluZ3MvdjgvY3VzdG9tL1Y4T3NjaWxsYXRvck5vZGVDdXN0b20uY3BwIGIvU291cmNlL1dl YkNvcmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4T3NjaWxsYXRvck5vZGVDdXN0b20uY3BwCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAuLjc2NDVmNTc2MGU1NDYxZGYwMzQ5ZWIyYzE1NzI5YjRjODNmMWFlMWMKLS0tIC9kZXYv bnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhPc2NpbGxhdG9y Tm9kZUN1c3RvbS5jcHAKQEAgLTAsMCArMSw3MSBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAx MiwgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlv biBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAq IG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcg Y29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNl IGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4g IFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBv dGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRI SVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9S UyBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElO Q0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBP RiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFS RQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09O VFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVO VEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUworICogKElO Q0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdP T0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJV U0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OCisgKiBBTlkgVEhFT1JZ IE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1Ig VE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBB TlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMKKyAqIFNPRlRXQVJFLCBFVkVOIElGIEFEVklT RUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJj b25maWcuaCIKKworI2lmIEVOQUJMRShXRUJfQVVESU8pCisKKyNpbmNsdWRlICJWOE9zY2lsbGF0 b3JOb2RlLmgiCisKKyNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCisjaW5jbHVkZSAiT3NjaWxs YXRvck5vZGUuaCIKKyNpbmNsdWRlICJWOEJpbmRpbmcuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUg eworCit2b2lkIFY4T3NjaWxsYXRvck5vZGU6OnR5cGVBY2Nlc3NvclNldHRlcih2ODo6TG9jYWw8 djg6OlN0cmluZz4gbmFtZSwgdjg6OkxvY2FsPHY4OjpWYWx1ZT4gdmFsdWUsIGNvbnN0IHY4OjpB Y2Nlc3NvckluZm8mIGluZm8pCit7CisgICAgSU5DX1NUQVRTKCJET00uT3NjaWxsYXRvck5vZGUu dHlwZS5fc2V0Iik7CisgICAgdjg6OkhhbmRsZTx2ODo6T2JqZWN0PiBob2xkZXIgPSBpbmZvLkhv bGRlcigpOworICAgIE9zY2lsbGF0b3JOb2RlKiBpbXAgPSBWOE9zY2lsbGF0b3JOb2RlOjp0b05h dGl2ZShob2xkZXIpOworCisgICAgaWYgKHZhbHVlLT5Jc1N0cmluZygpKSB7CisgICAgICAgIFN0 cmluZyB0eXBlID0gdG9XZWJDb3JlU3RyaW5nKHZhbHVlKTsKKyAgICAgICAgRXhjZXB0aW9uQ29k ZSBlYyA9IDA7CisgICAgICAgIGltcC0+c2V0VHlwZSh0eXBlLCBlYyk7CisgICAgICAgIGlmIChl YykKKyAgICAgICAgICAgIHNldERPTUV4Y2VwdGlvbihlYywgaW5mby5HZXRJc29sYXRlKCkpOwor ICAgICAgICByZXR1cm47CisgICAgfQorCisjaWYgRU5BQkxFKExFR0FDWV9XRUJfQVVESU8pICAg IAorICAgIGlmICh2YWx1ZS0+SXNOdW1iZXIoKSkgeworICAgICAgICBib29sIG9rID0gZmFsc2U7 CisgICAgICAgIHVpbnQzMl90IHR5cGUgPSB0b1VJbnQzMih2YWx1ZSwgb2spOworICAgICAgICBp ZiAob2spIHsKKyAgICAgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAwOworICAgICAgICAgICAg aW1wLT5zZXRUeXBlKHR5cGUsIGVjKTsKKyAgICAgICAgICAgIGlmIChlYykKKyAgICAgICAgICAg ICAgICBzZXRET01FeGNlcHRpb24oZWMsIGluZm8uR2V0SXNvbGF0ZSgpKTsKKyAgICAgICAgICAg IHJldHVybjsKKyAgICAgICAgfQorICAgIH0KKyNlbmRpZgorCisgICAgc2V0RE9NRXhjZXB0aW9u KE5PVF9TVVBQT1JURURfRVJSLCBpbmZvLkdldElzb2xhdGUoKSk7Cit9CisKK30gLy8gbmFtZXNw YWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShXRUJfQVVESU8pCmRpZmYgLS1naXQgYS9M YXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggNjEyZTA2 ZGU2MzViZWU3MzMzY2YzNTgyZWVhYjMxYTRiNjAxNjUwMi4uZjAyYzY0NmFmY2MzMzBkODExZTNl MWY3YjIzMWVmZTA2MjNkNzg1NCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisr KyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEyLTEyLTE3ICBD aHJpcyBSb2dlcnMgIDxjcm9nZXJzQGdvb2dsZS5jb20+CisKKyAgICAgICAgSW1wbGVtZW50IFdl YklETC1zdHlsZSBzdHJpbmcgY29uc3RhbnRzIGluIFdlYkF1ZGlvCisgICAgICAgIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDUwNTgKKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVcGRhdGUgT3NjaWxsYXRvck5vZGUgdGVz dCB0byBoYW5kbGUgV2ViSURMIC50eXBlCisKKyAgICAgICAgKiB3ZWJhdWRpby9vc2NpbGxhdG9y LWJhc2ljLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiB3ZWJhdWRpby9vc2NpbGxhdG9yLWJhc2lj Lmh0bWw6CisKIDIwMTItMTItMTcgIFNpbW9uIEZyYXNlciAgPHNpbW9uLmZyYXNlckBhcHBsZS5j b20+CiAKICAgICAgICAgRml4IHJlcG9zaXRpb25pbmcgb2YgZml4ZWQgZWxlbWVudHMgb24gem9v bWluZwpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvd2ViYXVkaW8vb3NjaWxsYXRvci1iYXNpYy1l eHBlY3RlZC50eHQgYi9MYXlvdXRUZXN0cy93ZWJhdWRpby9vc2NpbGxhdG9yLWJhc2ljLWV4cGVj dGVkLnR4dAppbmRleCAxNWRlZjQzNmM0ZTllNWFkZGNjMDgzMzE5MDBjYTBkNGE3NWZhNjljLi5i YjdlZGRhNmY3NGE3YWE4NTE5MDI4ODhiNmM0NTg3NDg0ZWU0ZGRkIDEwMDY0NAotLS0gYS9MYXlv dXRUZXN0cy93ZWJhdWRpby9vc2NpbGxhdG9yLWJhc2ljLWV4cGVjdGVkLnR4dAorKysgYi9MYXlv dXRUZXN0cy93ZWJhdWRpby9vc2NpbGxhdG9yLWJhc2ljLWV4cGVjdGVkLnR4dApAQCAtNiw2ICs2 LDEwIEBAIFBBU1MgT3NjaWxsYXRvciBjb3JyZWN0bHkgc2V0IHRvIFNJTkUgdHlwZS4KIFBBU1Mg T3NjaWxsYXRvciBjb3JyZWN0bHkgc2V0IHRvIFNRVUFSRSB0eXBlLgogUEFTUyBPc2NpbGxhdG9y IGNvcnJlY3RseSBzZXQgdG8gU0FXVE9PVEggdHlwZS4KIFBBU1MgT3NjaWxsYXRvciBjb3JyZWN0 bHkgc2V0IHRvIFRSSUFOR0xFIHR5cGUuCitQQVNTIE9zY2lsbGF0b3IgY29ycmVjdGx5IHNldCB0 byBTSU5FIHR5cGUgdXNpbmcgbGVnYWN5IGludGVnZXIgdmFsdWUuCitQQVNTIE9zY2lsbGF0b3Ig Y29ycmVjdGx5IHNldCB0byBTUVVBUkUgdHlwZSB1c2luZyBsZWdhY3kgaW50ZWdlciB2YWx1ZS4K K1BBU1MgT3NjaWxsYXRvciBjb3JyZWN0bHkgc2V0IHRvIFNBV1RPT1RIIHR5cGUgdXNpbmcgbGVn YWN5IGludGVnZXIgdmFsdWUuCitQQVNTIE9zY2lsbGF0b3IgY29ycmVjdGx5IHNldCB0byBUUklB TkdMRSB0eXBlIHVzaW5nIGxlZ2FjeSBpbnRlZ2VyIHZhbHVlLgogUEFTUyBPc2NpbGxhdG9yIGNv cnJlY3RseSBzZXQgdG8gQ1VTVE9NIHR5cGUgdXNpbmcgc2V0V2F2ZVRhYmxlLgogUEFTUyBEaXJl Y3RseSBzZXR0aW5nIG9zY2lsbGF0b3IgdHlwZSB0byBDVVNUT00gY29ycmVjdGx5IHRocm93cyBl eGNlcHRpb24uCiBQQVNTIFNldHRpbmcgb3NjaWxsYXRvciB0byBpbnZhbGlkIHR5cGUgNSBjb3Jy ZWN0bHkgdGhyb3dzIGV4Y2VwdGlvbi4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3dlYmF1ZGlv L29zY2lsbGF0b3ItYmFzaWMuaHRtbCBiL0xheW91dFRlc3RzL3dlYmF1ZGlvL29zY2lsbGF0b3It YmFzaWMuaHRtbAppbmRleCA0NGViOGY2MTVmN2JhNjgxN2IwYjdiOThkYTU5OWY5MThiZDhiZWQy Li42ODE4NzY5MWI5N2U5MjZjMTQ4OGZlNDliYWVmNzNiMTE3ZjY3MzNkIDEwMDY0NAotLS0gYS9M YXlvdXRUZXN0cy93ZWJhdWRpby9vc2NpbGxhdG9yLWJhc2ljLmh0bWwKKysrIGIvTGF5b3V0VGVz dHMvd2ViYXVkaW8vb3NjaWxsYXRvci1iYXNpYy5odG1sCkBAIC0yMCwxMSArMjAsMTEgQEAgZGVz Y3JpcHRpb24oIkJhc2ljIHRlc3Qgb2Ygc2V0dGluZyBPc2NpbGxhdG9yIG5vZGUgdHlwZXMuIik7 CiB2YXIgc2FtcGxlUmF0ZSA9IDQ0MTAwOwogdmFyIHJlbmRlckxlbmd0aFNlY29uZHMgPSAwLjI1 OwogCi12YXIgb3NjVHlwZXMgPSBbe3R5cGU6IDAsIG5hbWU6ICJTSU5FIn0sCi0gICAgICAgICAg ICAgICAge3R5cGU6IDEsIG5hbWU6ICJTUVVBUkUifSwKLSAgICAgICAgICAgICAgICB7dHlwZTog MiwgbmFtZTogIlNBV1RPT1RIIn0sCi0gICAgICAgICAgICAgICAge3R5cGU6IDMsIG5hbWU6ICJU UklBTkdMRSJ9LAotICAgICAgICAgICAgICAgIHt0eXBlOiA0LCBuYW1lOiAiQ1VTVE9NIn1dOwor dmFyIG9zY1R5cGVzID0gW3t0eXBlOiAic2luZSIsIGludGVnZXJUeXBlOiAwLCBuYW1lOiAiU0lO RSJ9LAorICAgICAgICAgICAgICAgIHt0eXBlOiAic3F1YXJlIiwgaW50ZWdlclR5cGU6IDEsIG5h bWU6ICJTUVVBUkUifSwKKyAgICAgICAgICAgICAgICB7dHlwZTogInNhd3Rvb3RoIiwgaW50ZWdl clR5cGU6IDIsIG5hbWU6ICJTQVdUT09USCJ9LAorICAgICAgICAgICAgICAgIHt0eXBlOiAidHJp YW5nbGUiLCBpbnRlZ2VyVHlwZTogMywgbmFtZTogIlRSSUFOR0xFIn0sCisgICAgICAgICAgICAg ICAge3R5cGU6ICJjdXN0b20iLCBpbnRlZ2VyVHlwZTogNCwgbmFtZTogIkNVU1RPTSJ9XTsKIAog ZnVuY3Rpb24gcnVuVGVzdCgpIAogewpAQCAtNDAsMjcgKzQwLDM4IEBAIGZ1bmN0aW9uIHJ1blRl c3QoKQogICAgIHZhciBvc2MgPSBjb250ZXh0LmNyZWF0ZU9zY2lsbGF0b3IoKTsKIAogICAgIC8v IFNldCBlYWNoIHBvc3NpYmxlIG9zY2lsbGF0b3IgdHlwZSAoZXhjZXB0IENVU1RPTSkgYW5kIHZl cmlmeSB0aGF0IHRoZSB0eXBlIGlzIGNvcnJlY3QuCisgICAgLy8gSGVyZSB3ZSdyZSBzZXR0aW5n IHRoZSB0eXBlIHVzaW5nIFdlYklETCBlbnVtIHZhbHVlcyB3aGljaCBhcmUgc3RyaW5ncy4KICAg ICBmb3IgKHZhciBrID0gMDsgayA8IG9zY1R5cGVzLmxlbmd0aCAtIDE7ICsraykgewotICAgICAg ICBvc2MudHlwZSA9IG9zY1R5cGVzW2tdLnR5cGUKKyAgICAgICAgb3NjLnR5cGUgPSBvc2NUeXBl c1trXS50eXBlOwogICAgICAgICBpZiAob3NjLnR5cGUgPT0gb3NjVHlwZXNba10udHlwZSkKICAg ICAgICAgICAgIHRlc3RQYXNzZWQoIk9zY2lsbGF0b3IgY29ycmVjdGx5IHNldCB0byAiICsgb3Nj VHlwZXNba10ubmFtZSArICIgdHlwZS4iKTsKICAgICAgICAgZWxzZQogICAgICAgICAgICAgdGVz dEZhaWxlZCgiT3NjaWxsYXRvciBzZXQgdG8gIiArIG9zY1R5cGVzW2tdLm5hbWUgKyAiIHR5cGUs IGJ1dCByZXR1cm5zICIgKyBvc2NUeXBlc1tvc2MudHlwZV0ubmFtZSArICIgdHlwZS4iKTsKICAg ICB9CiAKKyAgICAvLyBGb3IgbGVnYWN5IHN1cHBvcnQsIHZlcmlmeSB0aGF0IHdlIGNhbiBzZXQg dGhlIHR5cGUgYXR0cmlidXRlIGFzIGFuIGludGVnZXIgdmFsdWUgYW5kCisgICAgLy8gdmVyaWZ5 IHRoYXQgdGhpcyB0cmFuc2xhdGVzIGNvcnJlY3RseSB0byB0aGUgV2ViSURMIGVudW0gdmFsdWUu CisgICAgZm9yICh2YXIgayA9IDA7IGsgPCBvc2NUeXBlcy5sZW5ndGggLSAxOyArK2spIHsKKyAg ICAgICAgb3NjLnR5cGUgPSBvc2NUeXBlc1trXS5pbnRlZ2VyVHlwZTsKKyAgICAgICAgaWYgKG9z Yy50eXBlID09IG9zY1R5cGVzW2tdLnR5cGUpCisgICAgICAgICAgICB0ZXN0UGFzc2VkKCJPc2Np bGxhdG9yIGNvcnJlY3RseSBzZXQgdG8gIiArIG9zY1R5cGVzW2tdLm5hbWUgKyAiIHR5cGUgdXNp bmcgbGVnYWN5IGludGVnZXIgdmFsdWUuIik7CisgICAgICAgIGVsc2UKKyAgICAgICAgICAgIHRl c3RGYWlsZWQoIk9zY2lsbGF0b3Igc2V0IHRvICIgKyBvc2NUeXBlc1trXS5uYW1lICsgIiB0eXBl LCBidXQgcmV0dXJucyAiICsgb3NjVHlwZXNbb3NjLnR5cGVdLm5hbWUgKyAiIHR5cGUgdXNpbmcg bGVnYWN5IGludGVnZXIgdmFsdWUuIik7CisgICAgfQorCiAgICAgLy8gTm93IHNldCBhIGN1c3Rv bSBvc2NpbGxhdG9yCiAgICAgdmFyIGNvZWZmQSA9IG5ldyBGbG9hdDMyQXJyYXkoWzAsIDEsIDAu NV0pOwogICAgIHZhciBjb2VmZkIgPSBuZXcgRmxvYXQzMkFycmF5KFswLCAwLCAwXSk7ICAgICAg ICAKICAgICB2YXIgd2F2ZXRhYmxlID0gY29udGV4dC5jcmVhdGVXYXZlVGFibGUoY29lZmZBLCBj b2VmZkIpOwogICAgIG9zYy5zZXRXYXZlVGFibGUod2F2ZXRhYmxlKTsKLSAgICBpZiAob3NjLnR5 cGUgPT0gb3NjLkNVU1RPTSkKKyAgICBpZiAob3NjLnR5cGUgPT0gImN1c3RvbSIpCiAgICAgICAg IHRlc3RQYXNzZWQoIk9zY2lsbGF0b3IgY29ycmVjdGx5IHNldCB0byBDVVNUT00gdHlwZSB1c2lu ZyBzZXRXYXZlVGFibGUuIik7CiAgICAgZWxzZQogICAgICAgICB0ZXN0RmFpbGVkKCJPc2NpbGxh dG9yIHNldCB0byBDVVNUT00gdHlwZSwgYnV0IHJldHVybnMgIiArIG9zY1R5cGVzW29zYy50eXBl XS5uYW1lICsgIiB0eXBlLiIpOwogCiAgICAgLy8gVHJ5IHNldHRpbmcgc29tZSBpbnZhbGlkIHR5 cGVzCiAgICAgdHJ5IHsKLSAgICAgICAgb3NjLnR5cGUgPSBvc2MuQ1VTVE9NOworICAgICAgICBv c2MudHlwZSA9ICJjdXN0b20iOwogICAgICAgICB0ZXN0RmFpbGVkKCJEaXJlY3RseSBzZXR0aW5n IG9zY2lsbGF0b3IgdHlwZSB0byBDVVNUT00gZGlkIG5vdCB0aHJvdyBleGNlcHRpb24uIik7CiAg ICAgfSBjYXRjaCAoZSkgewogICAgICAgICB0ZXN0UGFzc2VkKCJEaXJlY3RseSBzZXR0aW5nIG9z Y2lsbGF0b3IgdHlwZSB0byBDVVNUT00gY29ycmVjdGx5IHRocm93cyBleGNlcHRpb24uIik7Cg== 180028 2012-12-18 14:28:53 -0800 2012-12-19 16:20:31 -0800 Patch bug-105058-20121218142610.patch text/plain 21956 crogers U3VidmVyc2lvbiBSZXZpc2lvbjogMTM4MDY4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggODhhOTUwZjc0YzRlY2Rk ZTVkNmRlZWIzOGZiYTQ3Y2I1ZjRkYTI4YS4uZWNhYjM1YjEwYTg4MWVhNGRmZWI2NmI4MzU4MjNi NGI5YjA2MWNlNSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM1IEBACisyMDEyLTEyLTE4ICBDaHJp cyBSb2dlcnMgIDxjcm9nZXJzQGdvb2dsZS5jb20+CisKKyAgICAgICAgSW1wbGVtZW50IFdlYklE TC1zdHlsZSBzdHJpbmcgY29uc3RhbnRzIGluIFdlYkF1ZGlvCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDUwNTgKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTZWUgRGVwcmVjYXRpb24gTm90ZXMgZm9yIG1v cmUgZGV0YWlsOgorICAgICAgICBodHRwczovL2R2Y3MudzMub3JnL2hnL2F1ZGlvL3Jhdy1maWxl L3RpcC93ZWJhdWRpby9zcGVjaWZpY2F0aW9uLmh0bWwjRGVwcmVjYXRpb25Ob3RlcworCisgICAg ICAgIFBhbm5lck5vZGUsIEJpcXVhZEZpbHRlck5vZGUsIE9zY2lsbGF0b3JOb2RlIGNvbnN0YW50 cyBtdXN0IHN1cHBvcnQgV2ViSURMLXN0eWxlIHN0cmluZyBjb25zdGFudHMuCisgICAgICAgIExl Z2FjeSBzdXBwb3J0IGluIHRoZSBzZXR0ZXJzIGZvciB0aGUgb2xkIGludGVnZXIgdmFsdWVzIHNo b3VsZCBiZSBzdXBwb3J0ZWQuCisgICAgICAgICAgICAgCisgICAgICAgICogR05VbWFrZWZpbGUu bGlzdC5hbToKKyAgICAgICAgKiBNb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmNwcDoK KyAgICAgICAgKFdlYkNvcmU6Ok9zY2lsbGF0b3JOb2RlOjp0eXBlKToKKyAgICAgICAgKFdlYkNv cmUpOgorICAgICAgICAoV2ViQ29yZTo6T3NjaWxsYXRvck5vZGU6OnNldFR5cGUpOgorICAgICAg ICAqIE1vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuaDoKKyAgICAgICAgKiBNb2R1bGVz L3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmlkbDoKKyAgICAgICAgKiBUYXJnZXQucHJpOgorICAg ICAgICAqIFVzZUpTQy5jbWFrZToKKyAgICAgICAgKiBVc2VWOC5jbWFrZToKKyAgICAgICAgKiBX ZWJDb3JlLmd5cGk6CisgICAgICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q OgorICAgICAgICAqIGJpbmRpbmdzL2pzL0pTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwOiBDb3Bp ZWQgZnJvbSBTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmlk bC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6SlNPc2NpbGxhdG9yTm9k ZTo6c2V0VHlwZSk6CisgICAgICAgICogYmluZGluZ3MvdjgvY3VzdG9tL1Y4T3NjaWxsYXRvck5v ZGVDdXN0b20uY3BwOiBDb3BpZWQgZnJvbSBTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlv L09zY2lsbGF0b3JOb2RlLmlkbC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29y ZTo6VjhPc2NpbGxhdG9yTm9kZTo6dHlwZUFjY2Vzc29yU2V0dGVyKToKKwogMjAxMi0xMi0xOCAg Sm9zZXBoIFBlY29yYXJvICA8cGVjb3Jhcm9AYXBwbGUuY29tPgogCiAgICAgICAgIFtNYWNdIEFk ZCBCdWlsZCBQaGFzZSB0byBDaGVjayBIZWFkZXJzIGZvciBJbmFwcHJvcHJpYXRlIE1hY3JvcyAo UGxhdGZvcm0uaCBtYWNyb3MpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmls ZS5saXN0LmFtIGIvU291cmNlL1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQppbmRleCBiN2E2 YTJjODQzNGYyN2ZiYjVhMjE0YzI0MTQxODgzZDU1Y2ZhYTY5Li40YmM1YWU5NTM1MDllZDczYzM0 YzdhYTAyNGUwZDU0MTgwZjA0ZmMyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtl ZmlsZS5saXN0LmFtCisrKyBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3QuYW0KQEAg LTIzNzgsNiArMjM3OCw3IEBAIHdlYmNvcmVfc291cmNlcyArPSBcCiAJU291cmNlL1dlYkNvcmUv YmluZGluZ3MvanMvSlNOb2RlRmlsdGVyQ3VzdG9tLmNwcCBcCiAJU291cmNlL1dlYkNvcmUvYmlu ZGluZ3MvanMvSlNOb2RlSXRlcmF0b3JDdXN0b20uY3BwIFwKIAlTb3VyY2UvV2ViQ29yZS9iaW5k aW5ncy9qcy9KU05vZGVMaXN0Q3VzdG9tLmNwcCBcCisJU291cmNlL1dlYkNvcmUvYmluZGluZ3Mv anMvSlNPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL2JpbmRpbmdz L2pzL0pTUGx1Z2luRWxlbWVudEZ1bmN0aW9ucy5jcHAgXAogCVNvdXJjZS9XZWJDb3JlL2JpbmRp bmdzL2pzL0pTUGx1Z2luRWxlbWVudEZ1bmN0aW9ucy5oIFwKIAlTb3VyY2UvV2ViQ29yZS9iaW5k aW5ncy9qcy9KU1BvcFN0YXRlRXZlbnRDdXN0b20uY3BwIFwKZGlmZiAtLWdpdCBhL1NvdXJjZS9X ZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuY3BwIGIvU291cmNlL1dlYkNv cmUvTW9kdWxlcy93ZWJhdWRpby9Pc2NpbGxhdG9yTm9kZS5jcHAKaW5kZXggNjhkZjlhM2JmYjIz NDk5M2FiYTBkYTVmODc0NjM3NDBjNzhhNDhkMy4uZjcyNzI1ODQ3ZTllZDY5ZmFiYmViMzBjZDM4 ZDlhY2U0Y2I5YmI0NCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRp by9Pc2NpbGxhdG9yTm9kZS5jcHAKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRp by9Pc2NpbGxhdG9yTm9kZS5jcHAKQEAgLTgzLDcgKzgzLDQwIEBAIE9zY2lsbGF0b3JOb2RlOjp+ T3NjaWxsYXRvck5vZGUoKQogICAgIHVuaW5pdGlhbGl6ZSgpOwogfQogCi12b2lkIE9zY2lsbGF0 b3JOb2RlOjpzZXRUeXBlKHVuc2lnbmVkIHNob3J0IHR5cGUsIEV4Y2VwdGlvbkNvZGUmIGVjKQor U3RyaW5nIE9zY2lsbGF0b3JOb2RlOjp0eXBlKCkgY29uc3QKK3sKKyAgICBzd2l0Y2ggKG1fdHlw ZSkgeworICAgIGNhc2UgU0lORToKKyAgICAgICAgcmV0dXJuICJzaW5lIjsKKyAgICBjYXNlIFNR VUFSRToKKyAgICAgICAgcmV0dXJuICJzcXVhcmUiOworICAgIGNhc2UgU0FXVE9PVEg6CisgICAg ICAgIHJldHVybiAic2F3dG9vdGgiOworICAgIGNhc2UgVFJJQU5HTEU6CisgICAgICAgIHJldHVy biAidHJpYW5nbGUiOworICAgIGNhc2UgQ1VTVE9NOgorICAgICAgICByZXR1cm4gImN1c3RvbSI7 CisgICAgZGVmYXVsdDoKKyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgIHJl dHVybiAiY3VzdG9tIjsKKyAgICB9Cit9CisKK3ZvaWQgT3NjaWxsYXRvck5vZGU6OnNldFR5cGUo Y29uc3QgU3RyaW5nJiB0eXBlLCBFeGNlcHRpb25Db2RlJiBlYykKK3sKKyAgICBpZiAodHlwZSA9 PSAic2luZSIpCisgICAgICAgIHNldFR5cGUoU0lORSwgZWMpOworICAgIGVsc2UgaWYgKHR5cGUg PT0gInNxdWFyZSIpCisgICAgICAgIHNldFR5cGUoU1FVQVJFLCBlYyk7CisgICAgZWxzZSBpZiAo dHlwZSA9PSAic2F3dG9vdGgiKQorICAgICAgICBzZXRUeXBlKFNBV1RPT1RILCBlYyk7CisgICAg ZWxzZSBpZiAodHlwZSA9PSAidHJpYW5nbGUiKQorICAgICAgICBzZXRUeXBlKFRSSUFOR0xFLCBl Yyk7CisgICAgZWxzZQorICAgICAgICBlYyA9IE5PVF9TVVBQT1JURURfRVJSOworfQorCit2b2lk IE9zY2lsbGF0b3JOb2RlOjpzZXRUeXBlKHVuc2lnbmVkIHR5cGUsIEV4Y2VwdGlvbkNvZGUmIGVj KQogewogICAgIFdhdmVUYWJsZSogd2F2ZVRhYmxlID0gMDsKICAgICBmbG9hdCBzYW1wbGVSYXRl ID0gdGhpcy0+c2FtcGxlUmF0ZSgpOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxl cy93ZWJhdWRpby9Pc2NpbGxhdG9yTm9kZS5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJh dWRpby9Pc2NpbGxhdG9yTm9kZS5oCmluZGV4IDFkNmIxNTIzNjA4ZTFkYzBiOGJmNTEwOGNkOTk4 OTUwZmIxNzcwNGQuLmI4ZWEyNDkyZGE5MzE3NDNiNzc3MDIwMTc0ODQyMzc0OWM2ZjMwM2YgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUu aAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmgK QEAgLTYwLDggKzYwLDkgQEAgcHVibGljOgogICAgIHZpcnR1YWwgdm9pZCBwcm9jZXNzKHNpemVf dCBmcmFtZXNUb1Byb2Nlc3MpOwogICAgIHZpcnR1YWwgdm9pZCByZXNldCgpOwogCi0gICAgdW5z aWduZWQgc2hvcnQgdHlwZSgpIGNvbnN0IHsgcmV0dXJuIG1fdHlwZTsgfQotICAgIHZvaWQgc2V0 VHlwZSh1bnNpZ25lZCBzaG9ydCwgRXhjZXB0aW9uQ29kZSYpOworICAgIFN0cmluZyB0eXBlKCkg Y29uc3Q7CisgICAgdm9pZCBzZXRUeXBlKHVuc2lnbmVkLCBFeGNlcHRpb25Db2RlJik7CisgICAg dm9pZCBzZXRUeXBlKGNvbnN0IFN0cmluZyYsIEV4Y2VwdGlvbkNvZGUmKTsKIAogICAgIEF1ZGlv UGFyYW0qIGZyZXF1ZW5jeSgpIHsgcmV0dXJuIG1fZnJlcXVlbmN5LmdldCgpOyB9CiAgICAgQXVk aW9QYXJhbSogZGV0dW5lKCkgeyByZXR1cm4gbV9kZXR1bmUuZ2V0KCk7IH0KZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuaWRsIGIvU291 cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9Pc2NpbGxhdG9yTm9kZS5pZGwKaW5kZXggMzRl YzM3NmUyZDMyOTRkODI4MDk1NWQ1N2M3NTUyNWM1NjA1YWY3My4uMWQ5ZTZhYjNlYzI1ZDIxMzhm N2IwNzk0YTVhNjJkNzc2ZDc5ZTAyMCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9kdWxl cy93ZWJhdWRpby9Pc2NpbGxhdG9yTm9kZS5pZGwKKysrIGIvU291cmNlL1dlYkNvcmUvTW9kdWxl cy93ZWJhdWRpby9Pc2NpbGxhdG9yTm9kZS5pZGwKQEAgLTM1LDggKzM1LDggQEAKICAgICBjb25z dCB1bnNpZ25lZCBzaG9ydCBUUklBTkdMRSA9IDM7CiAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQg Q1VTVE9NID0gNDsKIAotICAgIGF0dHJpYnV0ZSB1bnNpZ25lZCBzaG9ydCB0eXBlCi0gICAgICAg IHNldHRlciByYWlzZXMoRE9NRXhjZXB0aW9uKTsgICAgICAgIAorICAgIFtDdXN0b21TZXR0ZXJd IGF0dHJpYnV0ZSBET01TdHJpbmcgdHlwZQorICAgICAgICBzZXR0ZXIgcmFpc2VzKERPTUV4Y2Vw dGlvbik7CiAKICAgICAvLyBQbGF5YmFjayBzdGF0ZSBjb25zdGFudHMuCiAgICAgY29uc3QgdW5z aWduZWQgc2hvcnQgVU5TQ0hFRFVMRURfU1RBVEUgPSAwOwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvVGFyZ2V0LnByaSBiL1NvdXJjZS9XZWJDb3JlL1RhcmdldC5wcmkKaW5kZXggYTY4YWQ4 NGY0MzU5ZmQxN2Y2NzU5MTc0MmY0NThkNzgxYzAzZjI4OC4uYjhiYjc3NDkxYzBjYjBkYzViZjZi MTJiNGMyMmMxMzQ3ZjdlZjM4NiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvVGFyZ2V0LnBy aQorKysgYi9Tb3VyY2UvV2ViQ29yZS9UYXJnZXQucHJpCkBAIC0zNDE0LDYgKzM0MTQsNyBAQCBl bmFibGU/KFdFQl9BVURJTykgewogICAgICAgICBiaW5kaW5ncy9qcy9KU0F1ZGlvQnVmZmVyU291 cmNlTm9kZUN1c3RvbS5jcHAgXAogICAgICAgICBiaW5kaW5ncy9qcy9KU0F1ZGlvQ29udGV4dEN1 c3RvbS5jcHAgXAogICAgICAgICBiaW5kaW5ncy9qcy9KU0RPTVdpbmRvd1dlYkF1ZGlvQ3VzdG9t LmNwcCBcCisgICAgICAgIGJpbmRpbmdzL2pzL0pTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwIFwK ICAgICAgICAgYmluZGluZ3MvanMvSlNTY3JpcHRQcm9jZXNzb3JOb2RlQ3VzdG9tLmNwcCBcCiAg ICAgICAgIE1vZHVsZXMvd2ViYXVkaW8vQXN5bmNBdWRpb0RlY29kZXIuY3BwIFwKICAgICAgICAg TW9kdWxlcy93ZWJhdWRpby9BdWRpb0Jhc2ljSW5zcGVjdG9yTm9kZS5jcHAgXApkaWZmIC0tZ2l0 IGEvU291cmNlL1dlYkNvcmUvVXNlSlNDLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvVXNlSlNDLmNt YWtlCmluZGV4IDg5ZmY4Y2IyZDk3MWJmNWYyNWYyYjMzYWRkZWE0NTQ2NzFkYmQ5MjUuLmE2OTU0 MWQxODEzMmVjNzIzYmY4MzYzZjE2NjUxYjljYTIwNTg1N2UgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9X ZWJDb3JlL1VzZUpTQy5jbWFrZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9Vc2VKU0MuY21ha2UKQEAg LTI3MSw2ICsyNzEsNyBAQCBpZiAoRU5BQkxFX1dFQl9BVURJTykKICAgICBsaXN0KEFQUEVORCBX ZWJDb3JlX1NPVVJDRVMKICAgICAgICAgYmluZGluZ3MvanMvSlNBdWRpb0J1ZmZlclNvdXJjZU5v ZGVDdXN0b20uY3BwCiAgICAgICAgIGJpbmRpbmdzL2pzL0pTQXVkaW9Db250ZXh0Q3VzdG9tLmNw cAorICAgICAgICBiaW5kaW5ncy9qcy9KU09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcAogICAgICAg ICBiaW5kaW5ncy9qcy9KU1NjcmlwdFByb2Nlc3Nvck5vZGVDdXN0b20uY3BwCiAgICAgKQogZW5k aWYgKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1VzZVY4LmNtYWtlIGIvU291cmNlL1dl YkNvcmUvVXNlVjguY21ha2UKaW5kZXggZGU0ZTcxNTNmYTA1ZTFmMjJlMjY2YWM1M2EzMmMzNWZj NjI3NzdmNS4uNGEwODE0ODdmZDBkNmIxOTAyOTVlMjA1NjlkZTA0ZTI4MDZiNDYyYyAxMDA2NDQK LS0tIGEvU291cmNlL1dlYkNvcmUvVXNlVjguY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvVXNl VjguY21ha2UKQEAgLTEzNyw2ICsxMzcsNyBAQCBsaXN0KEFQUEVORCBXZWJDb3JlX1NPVVJDRVMK ICAgICBiaW5kaW5ncy92OC9jdXN0b20vVjhOb2RlTGlzdEN1c3RvbS5jcHAKICAgICBiaW5kaW5n cy92OC9jdXN0b20vVjhOb3RpZmljYXRpb25DdXN0b20uY3BwCiAgICAgYmluZGluZ3MvdjgvY3Vz dG9tL1Y4Tm90aWZpY2F0aW9uQ2VudGVyQ3VzdG9tLmNwcAorICAgIGJpbmRpbmdzL3Y4L2N1c3Rv bS9WOE9zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcAogICAgIGJpbmRpbmdzL3Y4L2N1c3RvbS9WOFBl cmZvcm1hbmNlRW50cnlDdXN0b20uY3BwCiAgICAgYmluZGluZ3MvdjgvY3VzdG9tL1Y4UG9wU3Rh dGVFdmVudEN1c3RvbS5jcHAKICAgICBiaW5kaW5ncy92OC9jdXN0b20vVjhTUUxSZXN1bHRTZXRS b3dMaXN0Q3VzdG9tLmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBp IGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCmluZGV4IGEwZmRiZDYwZWJlMWFkMjFhMWNh YTk4YzYxNGU4NGE2N2JmZThiYjAuLjAxMGQ2OTQxMjJkYmZiZWE0OThkNjNkMTJhMGQ1NDljOGE3 MWQxYzMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9Tb3Vy Y2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKQEAgLTEzNjksNiArMTM2OSw3IEBACiAgICAgICAgICAg ICAnYmluZGluZ3MvdjgvY3VzdG9tL1Y4Tm9kZUxpc3RDdXN0b20uY3BwJywKICAgICAgICAgICAg ICdiaW5kaW5ncy92OC9jdXN0b20vVjhOb3RpZmljYXRpb25DdXN0b20uY3BwJywKICAgICAgICAg ICAgICdiaW5kaW5ncy92OC9jdXN0b20vVjhOb3RpZmljYXRpb25DZW50ZXJDdXN0b20uY3BwJywK KyAgICAgICAgICAgICdiaW5kaW5ncy92OC9jdXN0b20vVjhPc2NpbGxhdG9yTm9kZUN1c3RvbS5j cHAnLAogICAgICAgICAgICAgJ2JpbmRpbmdzL3Y4L2N1c3RvbS9WOFBlcmZvcm1hbmNlRW50cnlD dXN0b20uY3BwJywKICAgICAgICAgICAgICdiaW5kaW5ncy92OC9jdXN0b20vVjhQb3BTdGF0ZUV2 ZW50Q3VzdG9tLmNwcCcsCiAgICAgICAgICAgICAnYmluZGluZ3MvdjgvY3VzdG9tL1Y4U1FMUmVz dWx0U2V0Um93TGlzdEN1c3RvbS5jcHAnLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2Vi Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54 Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDM0NmRmNzhhMTkyZTY5NmE2NmMyOTUwMmFm ODU5NWY4YjMxNTJmNDYuLjNiNzAxOGQzODEyNmQyOTQwOGE4NTc3ZDJjMDA2MWUyMjhlNzlkOTQg MTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4 cHJvagorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2oKQEAgLTY2MzAsNiArNjYzMCw3IEBACiAJCUZEQjA1MkUwMTU2MUE0MkMwMEI1MDBENiAvKiBB dWRpb1N1bW1pbmdKdW5jdGlvbi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gRkRCMDUyREUxNTYxQTQyQzAwQjUwMEQ2IC8qIEF1ZGlvU3VtbWluZ0p1bmN0 aW9uLmggKi87IH07CiAJCUZEQjE3MDA1MTRBMkJBQjIwMEEyQjVEOSAvKiBNdWx0aUNoYW5uZWxS ZXNhbXBsZXIuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVm ID0gRkRCMTcwMDMxNEEyQkFCMjAwQTJCNUQ5IC8qIE11bHRpQ2hhbm5lbFJlc2FtcGxlci5jcHAg Ki87IH07CiAJCUZEQjE3MDA2MTRBMkJBQjIwMEEyQjVEOSAvKiBNdWx0aUNoYW5uZWxSZXNhbXBs ZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZEQjE3 MDA0MTRBMkJBQjIwMEEyQjVEOSAvKiBNdWx0aUNoYW5uZWxSZXNhbXBsZXIuaCAqLzsgfTsKKwkJ RkRCRDFERkMxNjdGRTI3RDAwNTFBMTFFIC8qIEpTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkRCRDFERkIxNjdG RTI3RDAwNTFBMTFFIC8qIEpTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwICovOyB9OwogCQlGREJE NDgwQzE1OUJDNjg3MDA5M0VCNEYgLyogSlNNZWRpYVN0cmVhbUF1ZGlvU291cmNlTm9kZS5jcHAg aW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGREJENDgwQTE1 OUJDNjg3MDA5M0VCNEYgLyogSlNNZWRpYVN0cmVhbUF1ZGlvU291cmNlTm9kZS5jcHAgKi87IH07 CiAJCUZEQkQ0ODBEMTU5QkM2ODcwMDkzRUI0RiAvKiBKU01lZGlhU3RyZWFtQXVkaW9Tb3VyY2VO b2RlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGREJE NDgwQjE1OUJDNjg3MDA5M0VCNEYgLyogSlNNZWRpYVN0cmVhbUF1ZGlvU291cmNlTm9kZS5oICov OyB9OwogCQlGREM1NEYwNDEzOTlCMERBMDA4RDkxMTcgLyogQmlxdWFkRmlsdGVyTm9kZS5jcHAg aW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGREM1NEYwMTEz OTlCMERBMDA4RDkxMTcgLyogQmlxdWFkRmlsdGVyTm9kZS5jcHAgKi87IH07CkBAIC0xNDE5NCw2 ICsxNDE5NSw3IEBACiAJCUZEQjA1MkRFMTU2MUE0MkMwMEI1MDBENiAvKiBBdWRpb1N1bW1pbmdK dW5jdGlvbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7 IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBBdWRpb1N1bW1pbmdK dW5jdGlvbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGREIxNzAwMzE0QTJCQUIy MDBBMkI1RDkgLyogTXVsdGlDaGFubmVsUmVzYW1wbGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNv ZGUuY3BwLmNwcDsgcGF0aCA9IE11bHRpQ2hhbm5lbFJlc2FtcGxlci5jcHA7IHNvdXJjZVRyZWUg PSAiPGdyb3VwPiI7IH07CiAJCUZEQjE3MDA0MTRBMkJBQjIwMEEyQjVEOSAvKiBNdWx0aUNoYW5u ZWxSZXNhbXBsZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTXVsdGlDaGFu bmVsUmVzYW1wbGVyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUZEQkQxREZCMTY3 RkUyN0QwMDUxQTExRSAvKiBKU09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEpTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGREJENDgwQTE1OUJDNjg3MDA5M0VCNEYgLyogSlNN ZWRpYVN0cmVhbUF1ZGlvU291cmNlTm9kZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5j cHA7IHBhdGggPSBKU01lZGlhU3RyZWFtQXVkaW9Tb3VyY2VOb2RlLmNwcDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJRkRCRDQ4MEIxNTlCQzY4NzAwOTNFQjRGIC8qIEpTTWVkaWFTdHJl YW1BdWRpb1NvdXJjZU5vZGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5j b2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gSlNN ZWRpYVN0cmVhbUF1ZGlvU291cmNlTm9kZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQlGREM1NEYwMTEzOTlCMERBMDA4RDkxMTcgLyogQmlxdWFkRmlsdGVyTm9kZS5jcHAgKi8gPSB7 aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBCaXF1YWRGaWx0ZXJOb2RlLmNwcDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTIwNjk3LDYgKzIwNjk5LDcgQEAKIAkJCQkxQTc1 MEREMzBBOTBFNzI5MDAwRkYyMTUgLyogSlNOb2RlSXRlcmF0b3JDdXN0b20uY3BwICovLAogCQkJ CUJDRDlDMjYxMEMxN0FBNjcwMDVDOTBBMiAvKiBKU05vZGVMaXN0Q3VzdG9tLmNwcCAqLywKIAkJ CQkzMUZFNkU2QzE1MDFBM0JGMDAwNEVCQzQgLyogSlNOb3RpZmljYXRpb25DdXN0b20uY3BwICov LAorCQkJCUZEQkQxREZCMTY3RkUyN0QwMDUxQTExRSAvKiBKU09zY2lsbGF0b3JOb2RlQ3VzdG9t LmNwcCAqLywKIAkJCQlBODVGMjIwODE0MzAzNzdEMDA3Q0M4ODQgLyogSlNQb3BTdGF0ZUV2ZW50 Q3VzdG9tLmNwcCAqLywKIAkJCQlFMUFEMTJENTEyOTVEMEJEMDBBQ0E5ODkgLyogSlNQcm9jZXNz aW5nSW5zdHJ1Y3Rpb25DdXN0b20uY3BwICovLAogCQkJCTQ5OThBRUQzMTNGQzQxN0YwMDkwQjFB QSAvKiBKU1JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrQ3VzdG9tLmNwcCAqLywKQEAgLTI5 MDc2LDYgKzI5MDc5LDcgQEAKIAkJCQlGMzdBNTYyMjE2NzlDRjdCMDBDNTcwNDYgLyogSGVhcEdy YXBoU2VyaWFsaXplci5jcHAgaW4gU291cmNlcyAqLywKIAkJCQlDRDFFNzM0NzE2N0JDNzhFMDA5 QTg4NUQgLyogVGV4dFRyYWNrUmVwcmVzZW50YXRpb24uY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkJ OUE5Q0VGOEQxNjNCM0VBMTAwREU3RUZFIC8qIEV4Y2x1c2lvblNoYXBlT3V0c2lkZUluZm8uY3Bw IGluIFNvdXJjZXMgKi8sCisJCQkJRkRCRDFERkMxNjdGRTI3RDAwNTFBMTFFIC8qIEpTT3NjaWxs YXRvck5vZGVDdXN0b20uY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRl cGxveW1lbnRQb3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9qcy9KU09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcCBiL1NvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL2pzL0pTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmU3 ZWIwNDQxY2I5NmZjODNmNWYxZmUwZDA1MzMzOTlkYThlOTNjMzYKLS0tIC9kZXYvbnVsbAorKysg Yi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcApA QCAtMCwwICsxLDY3IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyLCBHb29nbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBh cmUgbWV0OgorICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFp biB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQg QU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFRIRSBJTVBMSUVECisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVE LiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkKKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAoSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 CisgKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04KKyAqIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UgT0YgVEhJUworICogU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYg RU5BQkxFKFdFQl9BVURJTykKKworI2luY2x1ZGUgIkpTT3NjaWxsYXRvck5vZGUuaCIKKworI2lu Y2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKKyNpbmNsdWRlICJPc2NpbGxhdG9yTm9kZS5oIgorI2lu Y2x1ZGUgPHJ1bnRpbWUvRXJyb3IuaD4KKwordXNpbmcgbmFtZXNwYWNlIEpTQzsKKworbmFtZXNw YWNlIFdlYkNvcmUgeworCit2b2lkIEpTT3NjaWxsYXRvck5vZGU6OnNldFR5cGUoRXhlY1N0YXRl KiBleGVjLCBKU1ZhbHVlIHZhbHVlKQoreworICAgIE9zY2lsbGF0b3JOb2RlKiBpbXAgPSBzdGF0 aWNfY2FzdDxPc2NpbGxhdG9yTm9kZSo+KGltcGwoKSk7CisKKyNpZiBFTkFCTEUoTEVHQUNZX1dF Ql9BVURJTykKKyAgICBpZiAodmFsdWUuaXNOdW1iZXIoKSkgeworICAgICAgICB1aW50MzJfdCB0 eXBlID0gdmFsdWUudG9VSW50MzIoZXhlYyk7CisgICAgICAgIEV4Y2VwdGlvbkNvZGUgZWMgPSAw OworICAgICAgICBpbXAtPnNldFR5cGUodHlwZSwgZWMpOworICAgICAgICBpZiAoZWMpCisgICAg ICAgICAgICBzZXRET01FeGNlcHRpb24oZXhlYywgZWMpOworICAgICAgICByZXR1cm47CisgICAg fQorI2VuZGlmCisKKyAgICBTdHJpbmcgdHlwZSA9IHZhbHVlLnRvU3RyaW5nKGV4ZWMpLT52YWx1 ZShleGVjKTsKKyAgICBpZiAoZXhlYy0+aGFkRXhjZXB0aW9uKCkpIHsKKyAgICAgICAgc2V0RE9N RXhjZXB0aW9uKGV4ZWMsIE5PVF9TVVBQT1JURURfRVJSKTsKKyAgICAgICAgcmV0dXJuOworICAg IH0KKyAgICBFeGNlcHRpb25Db2RlIGVjID0gMDsKKyAgICBpbXAtPnNldFR5cGUodHlwZSwgZWMp OworICAgIGlmIChlYykKKyAgICAgICAgc2V0RE9NRXhjZXB0aW9uKGV4ZWMsIGVjKTsKK30KKwor fSAvLyBuYW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKFdFQl9BVURJTykKZGlm ZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9WOE9zY2lsbGF0b3JO b2RlQ3VzdG9tLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9WOE9zY2ls bGF0b3JOb2RlQ3VzdG9tLmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwLi42ZDcxNzllZjIwYTFiZTJjM2M2Y2QwMGM4 MWVlZmJkZDNlNmMzOWU5Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGlu Z3MvdjgvY3VzdG9tL1Y4T3NjaWxsYXRvck5vZGVDdXN0b20uY3BwCkBAIC0wLDAgKzEsNjggQEAK Ky8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTIsIEdvb2dsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiAg UmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuICBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0g bXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICog ICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhl IGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExF IElOQy4gQU5EIElUUyBDT05UUklCVVRPUlMgYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1Mg T1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhF IElNUExJRUQKKyAqIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIgUFVSUE9TRSBBUkUKKyAqIERJU0NMQUlNRUQuIElOIE5PIEVWRU5UIFNI QUxMIEFQUExFIElOQy4gT1IgSVRTIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWQorICog RElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwgRVhFTVBMQVJZLCBPUiBDT05T RVFVRU5USUFMIERBTUFHRVMKKyAqIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgUFJP Q1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsKKyAqIExPU1MgT0YgVVNF LCBEQVRBLCBPUiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FV U0VEIEFORCBPTgorICogQU5ZIFRIRU9SWSBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJB Q1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBP UiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRSBPRiBUSElTCisg KiBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB TUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisKKyNpZiBFTkFCTEUoV0VCX0FVRElP KQorCisjaW5jbHVkZSAiVjhPc2NpbGxhdG9yTm9kZS5oIgorCisjaW5jbHVkZSAiRXhjZXB0aW9u Q29kZS5oIgorI2luY2x1ZGUgIk9zY2lsbGF0b3JOb2RlLmgiCisjaW5jbHVkZSAiVjhCaW5kaW5n LmgiCisKK25hbWVzcGFjZSBXZWJDb3JlIHsKKwordm9pZCBWOE9zY2lsbGF0b3JOb2RlOjp0eXBl QWNjZXNzb3JTZXR0ZXIodjg6OkxvY2FsPHY4OjpTdHJpbmc+IG5hbWUsIHY4OjpMb2NhbDx2ODo6 VmFsdWU+IHZhbHVlLCBjb25zdCB2ODo6QWNjZXNzb3JJbmZvJiBpbmZvKQoreworICAgIElOQ19T VEFUUygiRE9NLk9zY2lsbGF0b3JOb2RlLnR5cGUuX3NldCIpOworICAgIHY4OjpIYW5kbGU8djg6 Ok9iamVjdD4gaG9sZGVyID0gaW5mby5Ib2xkZXIoKTsKKyAgICBPc2NpbGxhdG9yTm9kZSogaW1w ID0gVjhPc2NpbGxhdG9yTm9kZTo6dG9OYXRpdmUoaG9sZGVyKTsKKworI2lmIEVOQUJMRShMRUdB Q1lfV0VCX0FVRElPKSAgICAKKyAgICBpZiAodmFsdWUtPklzTnVtYmVyKCkpIHsKKyAgICAgICAg Ym9vbCBvayA9IGZhbHNlOworICAgICAgICB1aW50MzJfdCB0eXBlID0gdG9VSW50MzIodmFsdWUs IG9rKTsKKyAgICAgICAgaWYgKG9rKSB7CisgICAgICAgICAgICBFeGNlcHRpb25Db2RlIGVjID0g MDsKKyAgICAgICAgICAgIGltcC0+c2V0VHlwZSh0eXBlLCBlYyk7CisgICAgICAgICAgICBpZiAo ZWMpCisgICAgICAgICAgICAgICAgc2V0RE9NRXhjZXB0aW9uKGVjLCBpbmZvLkdldElzb2xhdGUo KSk7CisgICAgICAgICAgICByZXR1cm47CisgICAgICAgIH0KKyAgICAgICAgc2V0RE9NRXhjZXB0 aW9uKE5PVF9TVVBQT1JURURfRVJSLCBpbmZvLkdldElzb2xhdGUoKSk7CisgICAgICAgIHJldHVy bjsKKyAgICB9CisjZW5kaWYKKworICAgIFN0cmluZyB0eXBlID0gdG9XZWJDb3JlU3RyaW5nKHZh bHVlKTsKKyAgICBFeGNlcHRpb25Db2RlIGVjID0gMDsKKyAgICBpbXAtPnNldFR5cGUodHlwZSwg ZWMpOworICAgIGlmIChlYykKKyAgICAgICAgc2V0RE9NRXhjZXB0aW9uKGVjLCBpbmZvLkdldElz b2xhdGUoKSk7Cit9CisKK30gLy8gbmFtZXNwYWNlIFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJM RShXRUJfQVVESU8pCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRU ZXN0cy9DaGFuZ2VMb2cKaW5kZXggOTM3ZjQ3YTYwNmQ1ZGIxNWQ5ZGVmNGZkMjRhOGExMWExZWM0 Yjg0Yi4uNThiMzBhNWVkYzk3NTgzOTUxNGYzNDY5MzU0YTc2MDhhNzJkOTMyMiAxMDA2NDQKLS0t IGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAt MSwzICsxLDE1IEBACisyMDEyLTEyLTE4ICBDaHJpcyBSb2dlcnMgIDxjcm9nZXJzQGdvb2dsZS5j b20+CisKKyAgICAgICAgSW1wbGVtZW50IFdlYklETC1zdHlsZSBzdHJpbmcgY29uc3RhbnRzIGlu IFdlYkF1ZGlvCisgICAgICAgIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9p ZD0xMDUwNTgKKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAg ICBVcGRhdGUgT3NjaWxsYXRvck5vZGUgdGVzdCB0byBoYW5kbGUgV2ViSURMIC50eXBlCisKKyAg ICAgICAgKiB3ZWJhdWRpby9vc2NpbGxhdG9yLWJhc2ljLWV4cGVjdGVkLnR4dDoKKyAgICAgICAg KiB3ZWJhdWRpby9vc2NpbGxhdG9yLWJhc2ljLmh0bWw6CisKIDIwMTItMTItMTggIERvbWluaWMg TWF6em9uaSAgPGRtYXp6b25pQGdvb2dsZS5jb20+CiAKICAgICAgICAgW2Nocm9taXVtXSBVbnJl dmlld2VkIGdhcmRlbmluZy4KZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3dlYmF1ZGlvL29zY2ls bGF0b3ItYmFzaWMtZXhwZWN0ZWQudHh0IGIvTGF5b3V0VGVzdHMvd2ViYXVkaW8vb3NjaWxsYXRv ci1iYXNpYy1leHBlY3RlZC50eHQKaW5kZXggMTVkZWY0MzZjNGU5ZTVhZGRjYzA4MzMxOTAwY2Ew ZDRhNzVmYTY5Yy4uYmI3ZWRkYTZmNzRhN2FhODUxOTAyODg4YjZjNDU4NzQ4NGVlNGRkZCAxMDA2 NDQKLS0tIGEvTGF5b3V0VGVzdHMvd2ViYXVkaW8vb3NjaWxsYXRvci1iYXNpYy1leHBlY3RlZC50 eHQKKysrIGIvTGF5b3V0VGVzdHMvd2ViYXVkaW8vb3NjaWxsYXRvci1iYXNpYy1leHBlY3RlZC50 eHQKQEAgLTYsNiArNiwxMCBAQCBQQVNTIE9zY2lsbGF0b3IgY29ycmVjdGx5IHNldCB0byBTSU5F IHR5cGUuCiBQQVNTIE9zY2lsbGF0b3IgY29ycmVjdGx5IHNldCB0byBTUVVBUkUgdHlwZS4KIFBB U1MgT3NjaWxsYXRvciBjb3JyZWN0bHkgc2V0IHRvIFNBV1RPT1RIIHR5cGUuCiBQQVNTIE9zY2ls bGF0b3IgY29ycmVjdGx5IHNldCB0byBUUklBTkdMRSB0eXBlLgorUEFTUyBPc2NpbGxhdG9yIGNv cnJlY3RseSBzZXQgdG8gU0lORSB0eXBlIHVzaW5nIGxlZ2FjeSBpbnRlZ2VyIHZhbHVlLgorUEFT UyBPc2NpbGxhdG9yIGNvcnJlY3RseSBzZXQgdG8gU1FVQVJFIHR5cGUgdXNpbmcgbGVnYWN5IGlu dGVnZXIgdmFsdWUuCitQQVNTIE9zY2lsbGF0b3IgY29ycmVjdGx5IHNldCB0byBTQVdUT09USCB0 eXBlIHVzaW5nIGxlZ2FjeSBpbnRlZ2VyIHZhbHVlLgorUEFTUyBPc2NpbGxhdG9yIGNvcnJlY3Rs eSBzZXQgdG8gVFJJQU5HTEUgdHlwZSB1c2luZyBsZWdhY3kgaW50ZWdlciB2YWx1ZS4KIFBBU1Mg T3NjaWxsYXRvciBjb3JyZWN0bHkgc2V0IHRvIENVU1RPTSB0eXBlIHVzaW5nIHNldFdhdmVUYWJs ZS4KIFBBU1MgRGlyZWN0bHkgc2V0dGluZyBvc2NpbGxhdG9yIHR5cGUgdG8gQ1VTVE9NIGNvcnJl Y3RseSB0aHJvd3MgZXhjZXB0aW9uLgogUEFTUyBTZXR0aW5nIG9zY2lsbGF0b3IgdG8gaW52YWxp ZCB0eXBlIDUgY29ycmVjdGx5IHRocm93cyBleGNlcHRpb24uCmRpZmYgLS1naXQgYS9MYXlvdXRU ZXN0cy93ZWJhdWRpby9vc2NpbGxhdG9yLWJhc2ljLmh0bWwgYi9MYXlvdXRUZXN0cy93ZWJhdWRp by9vc2NpbGxhdG9yLWJhc2ljLmh0bWwKaW5kZXggNDRlYjhmNjE1ZjdiYTY4MTdiMGI3Yjk4ZGE1 OTlmOTE4YmQ4YmVkMi4uNjgxODc2OTFiOTdlOTI2YzE0ODhmZTQ5YmFlZjczYjExN2Y2NzMzZCAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvd2ViYXVkaW8vb3NjaWxsYXRvci1iYXNpYy5odG1sCisr KyBiL0xheW91dFRlc3RzL3dlYmF1ZGlvL29zY2lsbGF0b3ItYmFzaWMuaHRtbApAQCAtMjAsMTEg KzIwLDExIEBAIGRlc2NyaXB0aW9uKCJCYXNpYyB0ZXN0IG9mIHNldHRpbmcgT3NjaWxsYXRvciBu b2RlIHR5cGVzLiIpOwogdmFyIHNhbXBsZVJhdGUgPSA0NDEwMDsKIHZhciByZW5kZXJMZW5ndGhT ZWNvbmRzID0gMC4yNTsKIAotdmFyIG9zY1R5cGVzID0gW3t0eXBlOiAwLCBuYW1lOiAiU0lORSJ9 LAotICAgICAgICAgICAgICAgIHt0eXBlOiAxLCBuYW1lOiAiU1FVQVJFIn0sCi0gICAgICAgICAg ICAgICAge3R5cGU6IDIsIG5hbWU6ICJTQVdUT09USCJ9LAotICAgICAgICAgICAgICAgIHt0eXBl OiAzLCBuYW1lOiAiVFJJQU5HTEUifSwKLSAgICAgICAgICAgICAgICB7dHlwZTogNCwgbmFtZTog IkNVU1RPTSJ9XTsKK3ZhciBvc2NUeXBlcyA9IFt7dHlwZTogInNpbmUiLCBpbnRlZ2VyVHlwZTog MCwgbmFtZTogIlNJTkUifSwKKyAgICAgICAgICAgICAgICB7dHlwZTogInNxdWFyZSIsIGludGVn ZXJUeXBlOiAxLCBuYW1lOiAiU1FVQVJFIn0sCisgICAgICAgICAgICAgICAge3R5cGU6ICJzYXd0 b290aCIsIGludGVnZXJUeXBlOiAyLCBuYW1lOiAiU0FXVE9PVEgifSwKKyAgICAgICAgICAgICAg ICB7dHlwZTogInRyaWFuZ2xlIiwgaW50ZWdlclR5cGU6IDMsIG5hbWU6ICJUUklBTkdMRSJ9LAor ICAgICAgICAgICAgICAgIHt0eXBlOiAiY3VzdG9tIiwgaW50ZWdlclR5cGU6IDQsIG5hbWU6ICJD VVNUT00ifV07CiAKIGZ1bmN0aW9uIHJ1blRlc3QoKSAKIHsKQEAgLTQwLDI3ICs0MCwzOCBAQCBm dW5jdGlvbiBydW5UZXN0KCkKICAgICB2YXIgb3NjID0gY29udGV4dC5jcmVhdGVPc2NpbGxhdG9y KCk7CiAKICAgICAvLyBTZXQgZWFjaCBwb3NzaWJsZSBvc2NpbGxhdG9yIHR5cGUgKGV4Y2VwdCBD VVNUT00pIGFuZCB2ZXJpZnkgdGhhdCB0aGUgdHlwZSBpcyBjb3JyZWN0LgorICAgIC8vIEhlcmUg d2UncmUgc2V0dGluZyB0aGUgdHlwZSB1c2luZyBXZWJJREwgZW51bSB2YWx1ZXMgd2hpY2ggYXJl IHN0cmluZ3MuCiAgICAgZm9yICh2YXIgayA9IDA7IGsgPCBvc2NUeXBlcy5sZW5ndGggLSAxOyAr K2spIHsKLSAgICAgICAgb3NjLnR5cGUgPSBvc2NUeXBlc1trXS50eXBlCisgICAgICAgIG9zYy50 eXBlID0gb3NjVHlwZXNba10udHlwZTsKICAgICAgICAgaWYgKG9zYy50eXBlID09IG9zY1R5cGVz W2tdLnR5cGUpCiAgICAgICAgICAgICB0ZXN0UGFzc2VkKCJPc2NpbGxhdG9yIGNvcnJlY3RseSBz ZXQgdG8gIiArIG9zY1R5cGVzW2tdLm5hbWUgKyAiIHR5cGUuIik7CiAgICAgICAgIGVsc2UKICAg ICAgICAgICAgIHRlc3RGYWlsZWQoIk9zY2lsbGF0b3Igc2V0IHRvICIgKyBvc2NUeXBlc1trXS5u YW1lICsgIiB0eXBlLCBidXQgcmV0dXJucyAiICsgb3NjVHlwZXNbb3NjLnR5cGVdLm5hbWUgKyAi IHR5cGUuIik7CiAgICAgfQogCisgICAgLy8gRm9yIGxlZ2FjeSBzdXBwb3J0LCB2ZXJpZnkgdGhh dCB3ZSBjYW4gc2V0IHRoZSB0eXBlIGF0dHJpYnV0ZSBhcyBhbiBpbnRlZ2VyIHZhbHVlIGFuZAor ICAgIC8vIHZlcmlmeSB0aGF0IHRoaXMgdHJhbnNsYXRlcyBjb3JyZWN0bHkgdG8gdGhlIFdlYklE TCBlbnVtIHZhbHVlLgorICAgIGZvciAodmFyIGsgPSAwOyBrIDwgb3NjVHlwZXMubGVuZ3RoIC0g MTsgKytrKSB7CisgICAgICAgIG9zYy50eXBlID0gb3NjVHlwZXNba10uaW50ZWdlclR5cGU7Cisg ICAgICAgIGlmIChvc2MudHlwZSA9PSBvc2NUeXBlc1trXS50eXBlKQorICAgICAgICAgICAgdGVz dFBhc3NlZCgiT3NjaWxsYXRvciBjb3JyZWN0bHkgc2V0IHRvICIgKyBvc2NUeXBlc1trXS5uYW1l ICsgIiB0eXBlIHVzaW5nIGxlZ2FjeSBpbnRlZ2VyIHZhbHVlLiIpOworICAgICAgICBlbHNlCisg ICAgICAgICAgICB0ZXN0RmFpbGVkKCJPc2NpbGxhdG9yIHNldCB0byAiICsgb3NjVHlwZXNba10u bmFtZSArICIgdHlwZSwgYnV0IHJldHVybnMgIiArIG9zY1R5cGVzW29zYy50eXBlXS5uYW1lICsg IiB0eXBlIHVzaW5nIGxlZ2FjeSBpbnRlZ2VyIHZhbHVlLiIpOworICAgIH0KKwogICAgIC8vIE5v dyBzZXQgYSBjdXN0b20gb3NjaWxsYXRvcgogICAgIHZhciBjb2VmZkEgPSBuZXcgRmxvYXQzMkFy cmF5KFswLCAxLCAwLjVdKTsKICAgICB2YXIgY29lZmZCID0gbmV3IEZsb2F0MzJBcnJheShbMCwg MCwgMF0pOyAgICAgICAgCiAgICAgdmFyIHdhdmV0YWJsZSA9IGNvbnRleHQuY3JlYXRlV2F2ZVRh YmxlKGNvZWZmQSwgY29lZmZCKTsKICAgICBvc2Muc2V0V2F2ZVRhYmxlKHdhdmV0YWJsZSk7Ci0g ICAgaWYgKG9zYy50eXBlID09IG9zYy5DVVNUT00pCisgICAgaWYgKG9zYy50eXBlID09ICJjdXN0 b20iKQogICAgICAgICB0ZXN0UGFzc2VkKCJPc2NpbGxhdG9yIGNvcnJlY3RseSBzZXQgdG8gQ1VT VE9NIHR5cGUgdXNpbmcgc2V0V2F2ZVRhYmxlLiIpOwogICAgIGVsc2UKICAgICAgICAgdGVzdEZh aWxlZCgiT3NjaWxsYXRvciBzZXQgdG8gQ1VTVE9NIHR5cGUsIGJ1dCByZXR1cm5zICIgKyBvc2NU eXBlc1tvc2MudHlwZV0ubmFtZSArICIgdHlwZS4iKTsKIAogICAgIC8vIFRyeSBzZXR0aW5nIHNv bWUgaW52YWxpZCB0eXBlcwogICAgIHRyeSB7Ci0gICAgICAgIG9zYy50eXBlID0gb3NjLkNVU1RP TTsKKyAgICAgICAgb3NjLnR5cGUgPSAiY3VzdG9tIjsKICAgICAgICAgdGVzdEZhaWxlZCgiRGly ZWN0bHkgc2V0dGluZyBvc2NpbGxhdG9yIHR5cGUgdG8gQ1VTVE9NIGRpZCBub3QgdGhyb3cgZXhj ZXB0aW9uLiIpOwogICAgIH0gY2F0Y2ggKGUpIHsKICAgICAgICAgdGVzdFBhc3NlZCgiRGlyZWN0 bHkgc2V0dGluZyBvc2NpbGxhdG9yIHR5cGUgdG8gQ1VTVE9NIGNvcnJlY3RseSB0aHJvd3MgZXhj ZXB0aW9uLiIpOwo= 180242 2012-12-19 16:20:35 -0800 2012-12-21 14:46:01 -0800 Patch bug-105058-20121219161751.patch text/plain 22719 crogers U3VidmVyc2lvbiBSZXZpc2lvbjogMTM4MTk5CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggZGJkYmUxYmJjZjFmOWM0 MTYzZWI0MDRjNzAzYzcyMjJiNDBlN2Y4Zi4uMzM1ZDdiOTkxZGI5NTlhNTBhNjE3NDRjNzBjYTk5 MGI2NDQxOGRiMSAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM2IEBACisyMDEyLTEyLTE5ICBDaHJp cyBSb2dlcnMgIDxjcm9nZXJzQGdvb2dsZS5jb20+CisKKyAgICAgICAgSW1wbGVtZW50IFdlYklE TC1zdHlsZSBzdHJpbmcgY29uc3RhbnRzIGluIFdlYkF1ZGlvCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDUwNTgKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBTZWUgRGVwcmVjYXRpb24gTm90ZXMgZm9yIG1v cmUgZGV0YWlsOgorICAgICAgICBodHRwczovL2R2Y3MudzMub3JnL2hnL2F1ZGlvL3Jhdy1maWxl L3RpcC93ZWJhdWRpby9zcGVjaWZpY2F0aW9uLmh0bWwjRGVwcmVjYXRpb25Ob3RlcworCisgICAg ICAgIFBhbm5lck5vZGUsIEJpcXVhZEZpbHRlck5vZGUsIE9zY2lsbGF0b3JOb2RlIGNvbnN0YW50 cyBtdXN0IHN1cHBvcnQgV2ViSURMLXN0eWxlIHN0cmluZyBjb25zdGFudHMuCisgICAgICAgIExl Z2FjeSBzdXBwb3J0IGluIHRoZSBzZXR0ZXJzIGZvciB0aGUgb2xkIGludGVnZXIgdmFsdWVzIHNo b3VsZCBiZSBzdXBwb3J0ZWQuCisKKyAgICAgICAgKiBHTlVtYWtlZmlsZS5saXN0LmFtOgorICAg ICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuY3BwOgorICAgICAgICAoV2Vi Q29yZTo6T3NjaWxsYXRvck5vZGU6Ok9zY2lsbGF0b3JOb2RlKToKKyAgICAgICAgKFdlYkNvcmU6 Ok9zY2lsbGF0b3JOb2RlOjp0eXBlKToKKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2Vi Q29yZTo6T3NjaWxsYXRvck5vZGU6OnNldFR5cGUpOgorICAgICAgICAqIE1vZHVsZXMvd2ViYXVk aW8vT3NjaWxsYXRvck5vZGUuaDoKKyAgICAgICAgKiBNb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0 b3JOb2RlLmlkbDoKKyAgICAgICAgKiBUYXJnZXQucHJpOgorICAgICAgICAqIFVzZUpTQy5jbWFr ZToKKyAgICAgICAgKiBVc2VWOC5jbWFrZToKKyAgICAgICAgKiBXZWJDb3JlLmd5cGk6CisgICAg ICAgICogV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qOgorICAgICAgICAqIGJpbmRp bmdzL2pzL0pTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwOiBDb3BpZWQgZnJvbSBTb3VyY2UvV2Vi Q29yZS9Nb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmlkbC4KKyAgICAgICAgKFdlYkNv cmUpOgorICAgICAgICAoV2ViQ29yZTo6SlNPc2NpbGxhdG9yTm9kZTo6c2V0VHlwZSk6CisgICAg ICAgICogYmluZGluZ3MvdjgvY3VzdG9tL1Y4T3NjaWxsYXRvck5vZGVDdXN0b20uY3BwOiBDb3Bp ZWQgZnJvbSBTb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmlk bC4KKyAgICAgICAgKFdlYkNvcmUpOgorICAgICAgICAoV2ViQ29yZTo6VjhPc2NpbGxhdG9yTm9k ZTo6dHlwZUFjY2Vzc29yU2V0dGVyKToKKwogMjAxMi0xMi0xOSAgRW1pbCBBIEVrbHVuZCAgPGVh ZUBjaHJvbWl1bS5vcmc+CiAKICAgICAgICAgW1JlZ3Jlc3Npb25dIHRleHQtb3ZlcmZsb3cgZWxs aXBzaXMgY2xpcHMgY29udGVudCB3aGVuIHpvb21lZApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNv cmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxpc3Qu YW0KaW5kZXggNWVhM2FmMjkyNzFiNDE3ZjFiMjFiN2Q1ZGM2MzY3NDhmMzBlNzFlMC4uYjcwMWM5 MTYxOTJjMDlkNWFlNmY0N2FmMGU1Yzc1YjM0MDlmYzY3MyAxMDA2NDQKLS0tIGEvU291cmNlL1dl YkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtlZmls ZS5saXN0LmFtCkBAIC0yMzgxLDYgKzIzODEsNyBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAogCVNv dXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTTm9kZUZpbHRlckN1c3RvbS5jcHAgXAogCVNvdXJj ZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTTm9kZUl0ZXJhdG9yQ3VzdG9tLmNwcCBcCiAJU291cmNl L1dlYkNvcmUvYmluZGluZ3MvanMvSlNOb2RlTGlzdEN1c3RvbS5jcHAgXAorCVNvdXJjZS9XZWJD b3JlL2JpbmRpbmdzL2pzL0pTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwIFwKIAlTb3VyY2UvV2Vi Q29yZS9iaW5kaW5ncy9qcy9KU1BsdWdpbkVsZW1lbnRGdW5jdGlvbnMuY3BwIFwKIAlTb3VyY2Uv V2ViQ29yZS9iaW5kaW5ncy9qcy9KU1BsdWdpbkVsZW1lbnRGdW5jdGlvbnMuaCBcCiAJU291cmNl L1dlYkNvcmUvYmluZGluZ3MvanMvSlNQb3BTdGF0ZUV2ZW50Q3VzdG9tLmNwcCBcCmRpZmYgLS1n aXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmNwcCBi L1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuY3BwCmluZGV4 IDY4ZGY5YTNiZmIyMzQ5OTNhYmEwZGE1Zjg3NDYzNzQwYzc4YTQ4ZDMuLjEwMzYzNjQzNDc3NWE2 NzQwOTdjY2FiYWQwYjE0Y2RlNzg2MjU4MTggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01v ZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3JlL01v ZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuY3BwCkBAIC02OSw4ICs2OSw3IEBAIE9zY2ls bGF0b3JOb2RlOjpPc2NpbGxhdG9yTm9kZShBdWRpb0NvbnRleHQqIGNvbnRleHQsIGZsb2F0IHNh bXBsZVJhdGUpCiAgICAgbV9kZXR1bmUgPSBBdWRpb1BhcmFtOjpjcmVhdGUoY29udGV4dCwgImRl dHVuZSIsIDAsIC00ODAwLCA0ODAwKTsKIAogICAgIC8vIFNldHMgdXAgZGVmYXVsdCB3YXZldGFi bGUuCi0gICAgRXhjZXB0aW9uQ29kZSBlYzsKLSAgICBzZXRUeXBlKG1fdHlwZSwgZWMpOworICAg IHNldFR5cGUobV90eXBlKTsKIAogICAgIC8vIEFuIG9zY2lsbGF0b3IgaXMgYWx3YXlzIG1vbm8u CiAgICAgYWRkT3V0cHV0KGFkb3B0UHRyKG5ldyBBdWRpb05vZGVPdXRwdXQodGhpcywgMSkpKTsK QEAgLTgzLDcgKzgyLDQyIEBAIE9zY2lsbGF0b3JOb2RlOjp+T3NjaWxsYXRvck5vZGUoKQogICAg IHVuaW5pdGlhbGl6ZSgpOwogfQogCi12b2lkIE9zY2lsbGF0b3JOb2RlOjpzZXRUeXBlKHVuc2ln bmVkIHNob3J0IHR5cGUsIEV4Y2VwdGlvbkNvZGUmIGVjKQorU3RyaW5nIE9zY2lsbGF0b3JOb2Rl Ojp0eXBlKCkgY29uc3QKK3sKKyAgICBzd2l0Y2ggKG1fdHlwZSkgeworICAgIGNhc2UgU0lORToK KyAgICAgICAgcmV0dXJuICJzaW5lIjsKKyAgICBjYXNlIFNRVUFSRToKKyAgICAgICAgcmV0dXJu ICJzcXVhcmUiOworICAgIGNhc2UgU0FXVE9PVEg6CisgICAgICAgIHJldHVybiAic2F3dG9vdGgi OworICAgIGNhc2UgVFJJQU5HTEU6CisgICAgICAgIHJldHVybiAidHJpYW5nbGUiOworICAgIGNh c2UgQ1VTVE9NOgorICAgICAgICByZXR1cm4gImN1c3RvbSI7CisgICAgZGVmYXVsdDoKKyAgICAg ICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgIHJldHVybiAiY3VzdG9tIjsKKyAgICB9 Cit9CisKK2Jvb2wgT3NjaWxsYXRvck5vZGU6OnNldFR5cGUoY29uc3QgU3RyaW5nJiB0eXBlKQor eworICAgIGlmICh0eXBlID09ICJzaW5lIikKKyAgICAgICAgc2V0VHlwZShTSU5FKTsKKyAgICBl bHNlIGlmICh0eXBlID09ICJzcXVhcmUiKQorICAgICAgICBzZXRUeXBlKFNRVUFSRSk7CisgICAg ZWxzZSBpZiAodHlwZSA9PSAic2F3dG9vdGgiKQorICAgICAgICBzZXRUeXBlKFNBV1RPT1RIKTsK KyAgICBlbHNlIGlmICh0eXBlID09ICJ0cmlhbmdsZSIpCisgICAgICAgIHNldFR5cGUoVFJJQU5H TEUpOworICAgIGVsc2UKKyAgICAgICAgcmV0dXJuIGZhbHNlOworCisgICAgcmV0dXJuIHRydWU7 Cit9CisKK2Jvb2wgT3NjaWxsYXRvck5vZGU6OnNldFR5cGUodW5zaWduZWQgdHlwZSkKIHsKICAg ICBXYXZlVGFibGUqIHdhdmVUYWJsZSA9IDA7CiAgICAgZmxvYXQgc2FtcGxlUmF0ZSA9IHRoaXMt PnNhbXBsZVJhdGUoKTsKQEAgLTExMSwxNCArMTQ1LDE0IEBAIHZvaWQgT3NjaWxsYXRvck5vZGU6 OnNldFR5cGUodW5zaWduZWQgc2hvcnQgdHlwZSwgRXhjZXB0aW9uQ29kZSYgZWMpCiAgICAgICAg IGJyZWFrOwogICAgIGNhc2UgQ1VTVE9NOgogICAgIGRlZmF1bHQ6Ci0gICAgICAgIC8vIFRocm93 IGV4Y2VwdGlvbiBmb3IgaW52YWxpZCB0eXBlcywgaW5jbHVkaW5nIENVU1RPTSBzaW5jZSBzZXRX YXZlVGFibGUoKSBtZXRob2QgbXVzdCBiZQorICAgICAgICAvLyBSZXR1cm4gZXJyb3IgZm9yIGlu dmFsaWQgdHlwZXMsIGluY2x1ZGluZyBDVVNUT00gc2luY2Ugc2V0V2F2ZVRhYmxlKCkgbWV0aG9k IG11c3QgYmUKICAgICAgICAgLy8gY2FsbGVkIGV4cGxpY2l0bHkuCi0gICAgICAgIGVjID0gTk9U X1NVUFBPUlRFRF9FUlI7Ci0gICAgICAgIHJldHVybjsKKyAgICAgICAgcmV0dXJuIGZhbHNlOwog ICAgIH0KIAogICAgIHNldFdhdmVUYWJsZSh3YXZlVGFibGUpOwogICAgIG1fdHlwZSA9IHR5cGU7 CisgICAgcmV0dXJuIHRydWU7CiB9CiAKIGJvb2wgT3NjaWxsYXRvck5vZGU6OmNhbGN1bGF0ZVNh bXBsZUFjY3VyYXRlUGhhc2VJbmNyZW1lbnRzKHNpemVfdCBmcmFtZXNUb1Byb2Nlc3MpCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmgg Yi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmgKaW5kZXgg MWQ2YjE1MjM2MDhlMWRjMGI4YmY1MTA4Y2Q5OTg5NTBmYjE3NzA0ZC4uNTI2ZTc0MmVmMmE3NWUw NzZlZjNkNDk0MTYyMTkwOGVmN2QzNWQxNyAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvTW9k dWxlcy93ZWJhdWRpby9Pc2NpbGxhdG9yTm9kZS5oCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVs ZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuaApAQCAtNjAsOCArNjAsMTEgQEAgcHVibGljOgog ICAgIHZpcnR1YWwgdm9pZCBwcm9jZXNzKHNpemVfdCBmcmFtZXNUb1Byb2Nlc3MpOwogICAgIHZp cnR1YWwgdm9pZCByZXNldCgpOwogCi0gICAgdW5zaWduZWQgc2hvcnQgdHlwZSgpIGNvbnN0IHsg cmV0dXJuIG1fdHlwZTsgfQotICAgIHZvaWQgc2V0VHlwZSh1bnNpZ25lZCBzaG9ydCwgRXhjZXB0 aW9uQ29kZSYpOworICAgIFN0cmluZyB0eXBlKCkgY29uc3Q7CisKKyAgICAvLyBTZXR0ZXJzIHJl dHVybiB0cnVlIG9uIHN1Y2Nlc3MuCisgICAgYm9vbCBzZXRUeXBlKHVuc2lnbmVkKTsKKyAgICBi b29sIHNldFR5cGUoY29uc3QgU3RyaW5nJik7CiAKICAgICBBdWRpb1BhcmFtKiBmcmVxdWVuY3ko KSB7IHJldHVybiBtX2ZyZXF1ZW5jeS5nZXQoKTsgfQogICAgIEF1ZGlvUGFyYW0qIGRldHVuZSgp IHsgcmV0dXJuIG1fZGV0dW5lLmdldCgpOyB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9N b2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmlkbCBiL1NvdXJjZS9XZWJDb3JlL01vZHVs ZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuaWRsCmluZGV4IDM0ZWMzNzZlMmQzMjk0ZDgyODA5 NTVkNTdjNzU1MjVjNTYwNWFmNzMuLjdhOTRkZjU4NzM2ZDVlOTMyZjVkZmM1ODljYmFkMDJiOTQz NDkzMGYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vT3NjaWxs YXRvck5vZGUuaWRsCisrKyBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vT3NjaWxs YXRvck5vZGUuaWRsCkBAIC0zNSw4ICszNSw3IEBACiAgICAgY29uc3QgdW5zaWduZWQgc2hvcnQg VFJJQU5HTEUgPSAzOwogICAgIGNvbnN0IHVuc2lnbmVkIHNob3J0IENVU1RPTSA9IDQ7CiAKLSAg ICBhdHRyaWJ1dGUgdW5zaWduZWQgc2hvcnQgdHlwZQotICAgICAgICBzZXR0ZXIgcmFpc2VzKERP TUV4Y2VwdGlvbik7ICAgICAgICAKKyAgICBbQ3VzdG9tU2V0dGVyXSBhdHRyaWJ1dGUgRE9NU3Ry aW5nIHR5cGU7CiAKICAgICAvLyBQbGF5YmFjayBzdGF0ZSBjb25zdGFudHMuCiAgICAgY29uc3Qg dW5zaWduZWQgc2hvcnQgVU5TQ0hFRFVMRURfU1RBVEUgPSAwOwpkaWZmIC0tZ2l0IGEvU291cmNl L1dlYkNvcmUvVGFyZ2V0LnByaSBiL1NvdXJjZS9XZWJDb3JlL1RhcmdldC5wcmkKaW5kZXggZTZk NDdmNmNhZjI4MmI4MWRmMGZlZWQ0YWFiYjY0OTI0YzY4NjE4ZS4uNmNkMzA1MjdjMjRhNTcwMDYy NTcyOTkwYzE0MGRjNGM2ODE0NzE1MCAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvVGFyZ2V0 LnByaQorKysgYi9Tb3VyY2UvV2ViQ29yZS9UYXJnZXQucHJpCkBAIC0zNDE1LDYgKzM0MTUsNyBA QCBlbmFibGU/KFdFQl9BVURJTykgewogICAgICAgICBiaW5kaW5ncy9qcy9KU0F1ZGlvQnVmZmVy U291cmNlTm9kZUN1c3RvbS5jcHAgXAogICAgICAgICBiaW5kaW5ncy9qcy9KU0F1ZGlvQ29udGV4 dEN1c3RvbS5jcHAgXAogICAgICAgICBiaW5kaW5ncy9qcy9KU0RPTVdpbmRvd1dlYkF1ZGlvQ3Vz dG9tLmNwcCBcCisgICAgICAgIGJpbmRpbmdzL2pzL0pTT3NjaWxsYXRvck5vZGVDdXN0b20uY3Bw IFwKICAgICAgICAgYmluZGluZ3MvanMvSlNTY3JpcHRQcm9jZXNzb3JOb2RlQ3VzdG9tLmNwcCBc CiAgICAgICAgIE1vZHVsZXMvd2ViYXVkaW8vQXN5bmNBdWRpb0RlY29kZXIuY3BwIFwKICAgICAg ICAgTW9kdWxlcy93ZWJhdWRpby9BdWRpb0Jhc2ljSW5zcGVjdG9yTm9kZS5jcHAgXApkaWZmIC0t Z2l0IGEvU291cmNlL1dlYkNvcmUvVXNlSlNDLmNtYWtlIGIvU291cmNlL1dlYkNvcmUvVXNlSlND LmNtYWtlCmluZGV4IDU2NDRhZjVkYWRmODE2MGQ3OWNiZGE3YWMyYWE3MDFhY2NhZmJlZjguLmRk MjdkMTFmODgzZjY5MmQ3NjZmMDkyNjM2ZTRhZDQ2ODYwYTM1NmQgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9XZWJDb3JlL1VzZUpTQy5jbWFrZQorKysgYi9Tb3VyY2UvV2ViQ29yZS9Vc2VKU0MuY21ha2UK QEAgLTI2Nyw2ICsyNjcsNyBAQCBpZiAoRU5BQkxFX1dFQl9BVURJTykKICAgICBsaXN0KEFQUEVO RCBXZWJDb3JlX1NPVVJDRVMKICAgICAgICAgYmluZGluZ3MvanMvSlNBdWRpb0J1ZmZlclNvdXJj ZU5vZGVDdXN0b20uY3BwCiAgICAgICAgIGJpbmRpbmdzL2pzL0pTQXVkaW9Db250ZXh0Q3VzdG9t LmNwcAorICAgICAgICBiaW5kaW5ncy9qcy9KU09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcAogICAg ICAgICBiaW5kaW5ncy9qcy9KU1NjcmlwdFByb2Nlc3Nvck5vZGVDdXN0b20uY3BwCiAgICAgKQog ZW5kaWYgKCkKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1VzZVY4LmNtYWtlIGIvU291cmNl L1dlYkNvcmUvVXNlVjguY21ha2UKaW5kZXggZGU0ZTcxNTNmYTA1ZTFmMjJlMjY2YWM1M2EzMmMz NWZjNjI3NzdmNS4uNGEwODE0ODdmZDBkNmIxOTAyOTVlMjA1NjlkZTA0ZTI4MDZiNDYyYyAxMDA2 NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvVXNlVjguY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUv VXNlVjguY21ha2UKQEAgLTEzNyw2ICsxMzcsNyBAQCBsaXN0KEFQUEVORCBXZWJDb3JlX1NPVVJD RVMKICAgICBiaW5kaW5ncy92OC9jdXN0b20vVjhOb2RlTGlzdEN1c3RvbS5jcHAKICAgICBiaW5k aW5ncy92OC9jdXN0b20vVjhOb3RpZmljYXRpb25DdXN0b20uY3BwCiAgICAgYmluZGluZ3Mvdjgv Y3VzdG9tL1Y4Tm90aWZpY2F0aW9uQ2VudGVyQ3VzdG9tLmNwcAorICAgIGJpbmRpbmdzL3Y4L2N1 c3RvbS9WOE9zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcAogICAgIGJpbmRpbmdzL3Y4L2N1c3RvbS9W OFBlcmZvcm1hbmNlRW50cnlDdXN0b20uY3BwCiAgICAgYmluZGluZ3MvdjgvY3VzdG9tL1Y4UG9w U3RhdGVFdmVudEN1c3RvbS5jcHAKICAgICBiaW5kaW5ncy92OC9jdXN0b20vVjhTUUxSZXN1bHRT ZXRSb3dMaXN0Q3VzdG9tLmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5n eXBpIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS5neXBpCmluZGV4IDkzYjc1NTQzOTc5ZjY3OThm NzZkOTVjMjNlZTFkYTkxZmY5YmNmNTAuLjdlYTUxZGY0ODk1YWYyNzQxMWZiYzY5OGJiNTI1MzBk M2Y2YWEzMmUgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQorKysgYi9T b3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKQEAgLTEzNzAsNiArMTM3MCw3IEBACiAgICAgICAg ICAgICAnYmluZGluZ3MvdjgvY3VzdG9tL1Y4Tm9kZUxpc3RDdXN0b20uY3BwJywKICAgICAgICAg ICAgICdiaW5kaW5ncy92OC9jdXN0b20vVjhOb3RpZmljYXRpb25DdXN0b20uY3BwJywKICAgICAg ICAgICAgICdiaW5kaW5ncy92OC9jdXN0b20vVjhOb3RpZmljYXRpb25DZW50ZXJDdXN0b20uY3Bw JywKKyAgICAgICAgICAgICdiaW5kaW5ncy92OC9jdXN0b20vVjhPc2NpbGxhdG9yTm9kZUN1c3Rv bS5jcHAnLAogICAgICAgICAgICAgJ2JpbmRpbmdzL3Y4L2N1c3RvbS9WOFBlcmZvcm1hbmNlRW50 cnlDdXN0b20uY3BwJywKICAgICAgICAgICAgICdiaW5kaW5ncy92OC9jdXN0b20vVjhQb3BTdGF0 ZUV2ZW50Q3VzdG9tLmNwcCcsCiAgICAgICAgICAgICAnYmluZGluZ3MvdjgvY3VzdG9tL1Y4U1FM UmVzdWx0U2V0Um93TGlzdEN1c3RvbS5jcHAnLApkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUv V2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL1dlYkNvcmUvV2ViQ29y ZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IGQ1ZWZjZDJjOGU1ZDYwZTQyZTdhZmRi NTFhOGNhY2Q1ZWY2NGQyYjguLmZjMjY0Zjk0YjM0ZjE5MDM3ODNmNzdhMjRjMGI4NTI2NDI1Y2Zm ZmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNvZGVwcm9qL3Byb2plY3Qu cGJ4cHJvagorKysgYi9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2oKQEAgLTY2MzMsNiArNjYzMyw3IEBACiAJCUZEQjA1MkUwMTU2MUE0MkMwMEI1MDBENiAv KiBBdWRpb1N1bW1pbmdKdW5jdGlvbi5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRG aWxlOyBmaWxlUmVmID0gRkRCMDUyREUxNTYxQTQyQzAwQjUwMEQ2IC8qIEF1ZGlvU3VtbWluZ0p1 bmN0aW9uLmggKi87IH07CiAJCUZEQjE3MDA1MTRBMkJBQjIwMEEyQjVEOSAvKiBNdWx0aUNoYW5u ZWxSZXNhbXBsZXIuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gRkRCMTcwMDMxNEEyQkFCMjAwQTJCNUQ5IC8qIE11bHRpQ2hhbm5lbFJlc2FtcGxlci5j cHAgKi87IH07CiAJCUZEQjE3MDA2MTRBMkJBQjIwMEEyQjVEOSAvKiBNdWx0aUNoYW5uZWxSZXNh bXBsZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZE QjE3MDA0MTRBMkJBQjIwMEEyQjVEOSAvKiBNdWx0aUNoYW5uZWxSZXNhbXBsZXIuaCAqLzsgfTsK KwkJRkRCRDFERkMxNjdGRTI3RDAwNTFBMTFFIC8qIEpTT3NjaWxsYXRvck5vZGVDdXN0b20uY3Bw IGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkRCRDFERkIx NjdGRTI3RDAwNTFBMTFFIC8qIEpTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwICovOyB9OwogCQlG REJENDgwQzE1OUJDNjg3MDA5M0VCNEYgLyogSlNNZWRpYVN0cmVhbUF1ZGlvU291cmNlTm9kZS5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGREJENDgw QTE1OUJDNjg3MDA5M0VCNEYgLyogSlNNZWRpYVN0cmVhbUF1ZGlvU291cmNlTm9kZS5jcHAgKi87 IH07CiAJCUZEQkQ0ODBEMTU5QkM2ODcwMDkzRUI0RiAvKiBKU01lZGlhU3RyZWFtQXVkaW9Tb3Vy Y2VOb2RlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBG REJENDgwQjE1OUJDNjg3MDA5M0VCNEYgLyogSlNNZWRpYVN0cmVhbUF1ZGlvU291cmNlTm9kZS5o ICovOyB9OwogCQlGREM1NEYwNDEzOTlCMERBMDA4RDkxMTcgLyogQmlxdWFkRmlsdGVyTm9kZS5j cHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGREM1NEYw MTEzOTlCMERBMDA4RDkxMTcgLyogQmlxdWFkRmlsdGVyTm9kZS5jcHAgKi87IH07CkBAIC0xNDIw Miw2ICsxNDIwMyw3IEBACiAJCUZEQjA1MkRFMTU2MUE0MkMwMEI1MDBENiAvKiBBdWRpb1N1bW1p bmdKdW5jdGlvbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBBdWRpb1N1bW1p bmdKdW5jdGlvbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGREIxNzAwMzE0QTJC QUIyMDBBMkI1RDkgLyogTXVsdGlDaGFubmVsUmVzYW1wbGVyLmNwcCAqLyA9IHtpc2EgPSBQQlhG aWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLmNwcDsgcGF0aCA9IE11bHRpQ2hhbm5lbFJlc2FtcGxlci5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CiAJCUZEQjE3MDA0MTRBMkJBQjIwMEEyQjVEOSAvKiBNdWx0aUNo YW5uZWxSZXNhbXBsZXIuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rp bmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gTXVsdGlD aGFubmVsUmVzYW1wbGVyLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUZEQkQxREZC MTY3RkUyN0QwMDUxQTExRSAvKiBKU09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEpTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlGREJENDgwQTE1OUJDNjg3MDA5M0VCNEYgLyog SlNNZWRpYVN0cmVhbUF1ZGlvU291cmNlTm9kZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNw cC5jcHA7IHBhdGggPSBKU01lZGlhU3RyZWFtQXVkaW9Tb3VyY2VOb2RlLmNwcDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRkRCRDQ4MEIxNTlCQzY4NzAwOTNFQjRGIC8qIEpTTWVkaWFT dHJlYW1BdWRpb1NvdXJjZU5vZGUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxl RW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0g SlNNZWRpYVN0cmVhbUF1ZGlvU291cmNlTm9kZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OwogCQlGREM1NEYwMTEzOTlCMERBMDA4RDkxMTcgLyogQmlxdWFkRmlsdGVyTm9kZS5jcHAgKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBCaXF1YWRGaWx0ZXJOb2RlLmNwcDsg c291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTIwNzEzLDYgKzIwNzE1LDcgQEAKIAkJCQkx QTc1MEREMzBBOTBFNzI5MDAwRkYyMTUgLyogSlNOb2RlSXRlcmF0b3JDdXN0b20uY3BwICovLAog CQkJCUJDRDlDMjYxMEMxN0FBNjcwMDVDOTBBMiAvKiBKU05vZGVMaXN0Q3VzdG9tLmNwcCAqLywK IAkJCQkzMUZFNkU2QzE1MDFBM0JGMDAwNEVCQzQgLyogSlNOb3RpZmljYXRpb25DdXN0b20uY3Bw ICovLAorCQkJCUZEQkQxREZCMTY3RkUyN0QwMDUxQTExRSAvKiBKU09zY2lsbGF0b3JOb2RlQ3Vz dG9tLmNwcCAqLywKIAkJCQlBODVGMjIwODE0MzAzNzdEMDA3Q0M4ODQgLyogSlNQb3BTdGF0ZUV2 ZW50Q3VzdG9tLmNwcCAqLywKIAkJCQlFMUFEMTJENTEyOTVEMEJEMDBBQ0E5ODkgLyogSlNQcm9j ZXNzaW5nSW5zdHJ1Y3Rpb25DdXN0b20uY3BwICovLAogCQkJCTQ5OThBRUQzMTNGQzQxN0YwMDkw QjFBQSAvKiBKU1JlcXVlc3RBbmltYXRpb25GcmFtZUNhbGxiYWNrQ3VzdG9tLmNwcCAqLywKQEAg LTI5MDk2LDYgKzI5MDk5LDcgQEAKIAkJCQk5QTlDRUY4RDE2M0IzRUExMDBERTdFRkUgLyogRXhj bHVzaW9uU2hhcGVPdXRzaWRlSW5mby5jcHAgaW4gU291cmNlcyAqLywKIAkJCQkwRkI4ODkwQjE2 N0QyRkExMDAxMENEQTUgLyogU2Nyb2xsaW5nVHJlZVN0aWNreU5vZGUubW0gaW4gU291cmNlcyAq LywKIAkJCQkwRkI4ODkwRTE2N0QzMDE2MDAxMENEQTUgLyogU2Nyb2xsaW5nU3RhdGVTdGlja3lO b2RlLmNwcCBpbiBTb3VyY2VzICovLAorCQkJCUZEQkQxREZDMTY3RkUyN0QwMDUxQTExRSAvKiBK U09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcCBpbiBTb3VyY2VzICovLAogCQkJKTsKIAkJCXJ1bk9u bHlGb3JEZXBsb3ltZW50UG9zdHByb2Nlc3NpbmcgPSAwOwogCQl9OwpkaWZmIC0tZ2l0IGEvU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHAgYi9Tb3Vy Y2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcApuZXcgZmls ZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwLi41Y2M5NDcxMDJmNzFiOGJkNjg1MTc2YTM2NDY1ZDg2MTIzZGE3Zjk4Ci0tLSAvZGV2L251 bGwKKysrIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNPc2NpbGxhdG9yTm9kZUN1c3Rv bS5jcHAKQEAgLTAsMCArMSw2MyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMiwgR29vZ2xl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNl IGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cworICogYXJlIG1ldDoKKyAqIDEuICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElT JycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElT Q0xBSU1FRC4gSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JT IEJFIExJQUJMRSBGT1IgQU5ZCisgKiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVD SUFMLCBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUworICogKElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNF UlZJQ0VTOworICogTE9TUyBPRiBVU0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElO VEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OCisgKiBBTlkgVEhFT1JZIE9GIExJQUJJ TElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICog KElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9V VCBPRiBUSEUgVVNFIE9GIFRISVMKKyAqIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhF IFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIK KworI2lmIEVOQUJMRShXRUJfQVVESU8pCisKKyNpbmNsdWRlICJKU09zY2lsbGF0b3JOb2RlLmgi CisKKyNpbmNsdWRlICJFeGNlcHRpb25Db2RlLmgiCisjaW5jbHVkZSAiT3NjaWxsYXRvck5vZGUu aCIKKyNpbmNsdWRlIDxydW50aW1lL0Vycm9yLmg+CisKK3VzaW5nIG5hbWVzcGFjZSBKU0M7CisK K25hbWVzcGFjZSBXZWJDb3JlIHsKKwordm9pZCBKU09zY2lsbGF0b3JOb2RlOjpzZXRUeXBlKEV4 ZWNTdGF0ZSogZXhlYywgSlNWYWx1ZSB2YWx1ZSkKK3sKKyAgICBPc2NpbGxhdG9yTm9kZSogaW1w ID0gc3RhdGljX2Nhc3Q8T3NjaWxsYXRvck5vZGUqPihpbXBsKCkpOworCisjaWYgRU5BQkxFKExF R0FDWV9XRUJfQVVESU8pCisgICAgaWYgKHZhbHVlLmlzTnVtYmVyKCkpIHsKKyAgICAgICAgdWlu dDMyX3QgdHlwZSA9IHZhbHVlLnRvVUludDMyKGV4ZWMpOworICAgICAgICBpZiAoaW1wLT5zZXRU eXBlKHR5cGUpKQorICAgICAgICAgICAgcmV0dXJuOworICAgICAgICB0aHJvd1ZNVHlwZUVycm9y KGV4ZWMpOworICAgIH0KKyNlbmRpZgorCisgICAgaWYgKHZhbHVlLmlzU3RyaW5nKCkpIHsKKyAg ICAgICAgU3RyaW5nIHR5cGUgPSB2YWx1ZS50b1N0cmluZyhleGVjKS0+dmFsdWUoZXhlYyk7Cisg ICAgICAgIGlmIChpbXAtPnNldFR5cGUodHlwZSkpCisgICAgICAgICAgICByZXR1cm47CisgICAg fQorICAgIAorICAgIHRocm93Vk1UeXBlRXJyb3IoZXhlYyk7Cit9CisKK30gLy8gbmFtZXNwYWNl IFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShXRUJfQVVESU8pCmRpZmYgLS1naXQgYS9Tb3Vy Y2UvV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHAg Yi9Tb3VyY2UvV2ViQ29yZS9iaW5kaW5ncy92OC9jdXN0b20vVjhPc2NpbGxhdG9yTm9kZUN1c3Rv bS5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMC4uZmRhMWQyNDE0ZDAyOThkMTgzY2MzZGFiYTIzOTc3NjY3MmM5Yjkx ZQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL3Y4L2N1c3RvbS9W OE9zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcApAQCAtMCwwICsxLDY0IEBACisvKgorICogQ29weXJp Z2h0IChDKSAyMDEyLCBHb29nbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNl IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRp b24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24u CisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIEFORCBJVFMg Q09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FS UkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRSBJTVBMSUVECisgKiBX QVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFS IFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMu IE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkKKyAqIERJUkVDVCwgSU5ESVJF Q1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1B R0VTCisgKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFBST0NVUkVNRU5UIE9GIFNV QlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7CisgKiBMT1NTIE9GIFVTRSwgREFUQSwgT1IgUFJP RklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04KKyAq IEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElB QklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBB UklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0YgVEhJUworICogU09GVFdBUkUsIEVW RU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKwor I2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgRU5BQkxFKFdFQl9BVURJTykKKworI2luY2x1ZGUg IlY4T3NjaWxsYXRvck5vZGUuaCIKKworI2luY2x1ZGUgIkV4Y2VwdGlvbkNvZGUuaCIKKyNpbmNs dWRlICJPc2NpbGxhdG9yTm9kZS5oIgorI2luY2x1ZGUgIlY4QmluZGluZy5oIgorCituYW1lc3Bh Y2UgV2ViQ29yZSB7CisKK3ZvaWQgVjhPc2NpbGxhdG9yTm9kZTo6dHlwZUFjY2Vzc29yU2V0dGVy KHY4OjpMb2NhbDx2ODo6U3RyaW5nPiBuYW1lLCB2ODo6TG9jYWw8djg6OlZhbHVlPiB2YWx1ZSwg Y29uc3Qgdjg6OkFjY2Vzc29ySW5mbyYgaW5mbykKK3sKKyAgICBJTkNfU1RBVFMoIkRPTS5Pc2Np bGxhdG9yTm9kZS50eXBlLl9zZXQiKTsKKyAgICB2ODo6SGFuZGxlPHY4OjpPYmplY3Q+IGhvbGRl ciA9IGluZm8uSG9sZGVyKCk7CisgICAgT3NjaWxsYXRvck5vZGUqIGltcCA9IFY4T3NjaWxsYXRv ck5vZGU6OnRvTmF0aXZlKGhvbGRlcik7CisKKyNpZiBFTkFCTEUoTEVHQUNZX1dFQl9BVURJTykg ICAgCisgICAgaWYgKHZhbHVlLT5Jc051bWJlcigpKSB7CisgICAgICAgIGJvb2wgb2sgPSBmYWxz ZTsKKyAgICAgICAgdWludDMyX3QgdHlwZSA9IHRvVUludDMyKHZhbHVlLCBvayk7CisgICAgICAg IGlmICghb2sgfHwgIWltcC0+c2V0VHlwZSh0eXBlKSkKKyAgICAgICAgICAgIHRocm93RXJyb3Io djhUeXBlRXJyb3IsICJJbGxlZ2FsIE9zY2lsbGF0b3JOb2RlIHR5cGUiLCBpbmZvLkdldElzb2xh dGUoKSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisjZW5kaWYKKworICAgIGlmICh2YWx1ZS0+ SXNTdHJpbmcoKSkgeworICAgICAgICBTdHJpbmcgdHlwZSA9IHRvV2ViQ29yZVN0cmluZyh2YWx1 ZSk7CisgICAgICAgIGlmIChpbXAtPnNldFR5cGUodHlwZSkpCisgICAgICAgICAgICByZXR1cm47 CisgICAgfQorICAgIAorICAgIHRocm93RXJyb3IodjhUeXBlRXJyb3IsICJJbGxlZ2FsIE9zY2ls bGF0b3JOb2RlIHR5cGUiLCBpbmZvLkdldElzb2xhdGUoKSk7Cit9CisKK30gLy8gbmFtZXNwYWNl IFdlYkNvcmUKKworI2VuZGlmIC8vIEVOQUJMRShXRUJfQVVESU8pCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy9DaGFuZ2VMb2cgYi9MYXlvdXRUZXN0cy9DaGFuZ2VMb2cKaW5kZXggNGUzYjNiMGJk NTQ3YTYwZjRhZWNjNGE5NTAzMmRkMGM5OTk1NjRjYS4uMzUyMTJmNzMxMTY2YTllMWZhMjY2NDY0 OTJjOTJkYmQ0OGI1NTJkNCAxMDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCisrKyBi L0xheW91dFRlc3RzL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE1IEBACisyMDEyLTEyLTE5ICBDaHJp cyBSb2dlcnMgIDxjcm9nZXJzQGdvb2dsZS5jb20+CisKKyAgICAgICAgSW1wbGVtZW50IFdlYklE TC1zdHlsZSBzdHJpbmcgY29uc3RhbnRzIGluIFdlYkF1ZGlvCisgICAgICAgIGh0dHBzOi8vYnVn cy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDUwNTgKKworICAgICAgICBSZXZpZXdlZCBi eSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVcGRhdGUgT3NjaWxsYXRvck5vZGUgdGVzdCB0 byBoYW5kbGUgV2ViSURMIC50eXBlCisKKyAgICAgICAgKiB3ZWJhdWRpby9vc2NpbGxhdG9yLWJh c2ljLWV4cGVjdGVkLnR4dDoKKyAgICAgICAgKiB3ZWJhdWRpby9vc2NpbGxhdG9yLWJhc2ljLmh0 bWw6CisKIDIwMTItMTItMTkgIFcuIEphbWVzIE1hY0xlYW4gIDx3am1hY2xlYW5AY2hyb21pdW0u b3JnPgogCiAgICAgICAgIFtjaHJvbWl1bV0gcGx1Z2lucy9ucHAtc2V0LXdpbmRvdy1jYWxsZWQt ZHVyaW5nLWRlc3RydWN0aW9uLmh0bWwgaXMgZmxha3kgb24gV2luCmRpZmYgLS1naXQgYS9MYXlv dXRUZXN0cy93ZWJhdWRpby9vc2NpbGxhdG9yLWJhc2ljLWV4cGVjdGVkLnR4dCBiL0xheW91dFRl c3RzL3dlYmF1ZGlvL29zY2lsbGF0b3ItYmFzaWMtZXhwZWN0ZWQudHh0CmluZGV4IDE1ZGVmNDM2 YzRlOWU1YWRkY2MwODMzMTkwMGNhMGQ0YTc1ZmE2OWMuLmJiN2VkZGE2Zjc0YTdhYTg1MTkwMjg4 OGI2YzQ1ODc0ODRlZTRkZGQgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3dlYmF1ZGlvL29zY2ls bGF0b3ItYmFzaWMtZXhwZWN0ZWQudHh0CisrKyBiL0xheW91dFRlc3RzL3dlYmF1ZGlvL29zY2ls bGF0b3ItYmFzaWMtZXhwZWN0ZWQudHh0CkBAIC02LDYgKzYsMTAgQEAgUEFTUyBPc2NpbGxhdG9y IGNvcnJlY3RseSBzZXQgdG8gU0lORSB0eXBlLgogUEFTUyBPc2NpbGxhdG9yIGNvcnJlY3RseSBz ZXQgdG8gU1FVQVJFIHR5cGUuCiBQQVNTIE9zY2lsbGF0b3IgY29ycmVjdGx5IHNldCB0byBTQVdU T09USCB0eXBlLgogUEFTUyBPc2NpbGxhdG9yIGNvcnJlY3RseSBzZXQgdG8gVFJJQU5HTEUgdHlw ZS4KK1BBU1MgT3NjaWxsYXRvciBjb3JyZWN0bHkgc2V0IHRvIFNJTkUgdHlwZSB1c2luZyBsZWdh Y3kgaW50ZWdlciB2YWx1ZS4KK1BBU1MgT3NjaWxsYXRvciBjb3JyZWN0bHkgc2V0IHRvIFNRVUFS RSB0eXBlIHVzaW5nIGxlZ2FjeSBpbnRlZ2VyIHZhbHVlLgorUEFTUyBPc2NpbGxhdG9yIGNvcnJl Y3RseSBzZXQgdG8gU0FXVE9PVEggdHlwZSB1c2luZyBsZWdhY3kgaW50ZWdlciB2YWx1ZS4KK1BB U1MgT3NjaWxsYXRvciBjb3JyZWN0bHkgc2V0IHRvIFRSSUFOR0xFIHR5cGUgdXNpbmcgbGVnYWN5 IGludGVnZXIgdmFsdWUuCiBQQVNTIE9zY2lsbGF0b3IgY29ycmVjdGx5IHNldCB0byBDVVNUT00g dHlwZSB1c2luZyBzZXRXYXZlVGFibGUuCiBQQVNTIERpcmVjdGx5IHNldHRpbmcgb3NjaWxsYXRv ciB0eXBlIHRvIENVU1RPTSBjb3JyZWN0bHkgdGhyb3dzIGV4Y2VwdGlvbi4KIFBBU1MgU2V0dGlu ZyBvc2NpbGxhdG9yIHRvIGludmFsaWQgdHlwZSA1IGNvcnJlY3RseSB0aHJvd3MgZXhjZXB0aW9u LgpkaWZmIC0tZ2l0IGEvTGF5b3V0VGVzdHMvd2ViYXVkaW8vb3NjaWxsYXRvci1iYXNpYy5odG1s IGIvTGF5b3V0VGVzdHMvd2ViYXVkaW8vb3NjaWxsYXRvci1iYXNpYy5odG1sCmluZGV4IDQ0ZWI4 ZjYxNWY3YmE2ODE3YjBiN2I5OGRhNTk5ZjkxOGJkOGJlZDIuLjY4MTg3NjkxYjk3ZTkyNmMxNDg4 ZmU0OWJhZWY3M2IxMTdmNjczM2QgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3dlYmF1ZGlvL29z Y2lsbGF0b3ItYmFzaWMuaHRtbAorKysgYi9MYXlvdXRUZXN0cy93ZWJhdWRpby9vc2NpbGxhdG9y LWJhc2ljLmh0bWwKQEAgLTIwLDExICsyMCwxMSBAQCBkZXNjcmlwdGlvbigiQmFzaWMgdGVzdCBv ZiBzZXR0aW5nIE9zY2lsbGF0b3Igbm9kZSB0eXBlcy4iKTsKIHZhciBzYW1wbGVSYXRlID0gNDQx MDA7CiB2YXIgcmVuZGVyTGVuZ3RoU2Vjb25kcyA9IDAuMjU7CiAKLXZhciBvc2NUeXBlcyA9IFt7 dHlwZTogMCwgbmFtZTogIlNJTkUifSwKLSAgICAgICAgICAgICAgICB7dHlwZTogMSwgbmFtZTog IlNRVUFSRSJ9LAotICAgICAgICAgICAgICAgIHt0eXBlOiAyLCBuYW1lOiAiU0FXVE9PVEgifSwK LSAgICAgICAgICAgICAgICB7dHlwZTogMywgbmFtZTogIlRSSUFOR0xFIn0sCi0gICAgICAgICAg ICAgICAge3R5cGU6IDQsIG5hbWU6ICJDVVNUT00ifV07Cit2YXIgb3NjVHlwZXMgPSBbe3R5cGU6 ICJzaW5lIiwgaW50ZWdlclR5cGU6IDAsIG5hbWU6ICJTSU5FIn0sCisgICAgICAgICAgICAgICAg e3R5cGU6ICJzcXVhcmUiLCBpbnRlZ2VyVHlwZTogMSwgbmFtZTogIlNRVUFSRSJ9LAorICAgICAg ICAgICAgICAgIHt0eXBlOiAic2F3dG9vdGgiLCBpbnRlZ2VyVHlwZTogMiwgbmFtZTogIlNBV1RP T1RIIn0sCisgICAgICAgICAgICAgICAge3R5cGU6ICJ0cmlhbmdsZSIsIGludGVnZXJUeXBlOiAz LCBuYW1lOiAiVFJJQU5HTEUifSwKKyAgICAgICAgICAgICAgICB7dHlwZTogImN1c3RvbSIsIGlu dGVnZXJUeXBlOiA0LCBuYW1lOiAiQ1VTVE9NIn1dOwogCiBmdW5jdGlvbiBydW5UZXN0KCkgCiB7 CkBAIC00MCwyNyArNDAsMzggQEAgZnVuY3Rpb24gcnVuVGVzdCgpCiAgICAgdmFyIG9zYyA9IGNv bnRleHQuY3JlYXRlT3NjaWxsYXRvcigpOwogCiAgICAgLy8gU2V0IGVhY2ggcG9zc2libGUgb3Nj aWxsYXRvciB0eXBlIChleGNlcHQgQ1VTVE9NKSBhbmQgdmVyaWZ5IHRoYXQgdGhlIHR5cGUgaXMg Y29ycmVjdC4KKyAgICAvLyBIZXJlIHdlJ3JlIHNldHRpbmcgdGhlIHR5cGUgdXNpbmcgV2ViSURM IGVudW0gdmFsdWVzIHdoaWNoIGFyZSBzdHJpbmdzLgogICAgIGZvciAodmFyIGsgPSAwOyBrIDwg b3NjVHlwZXMubGVuZ3RoIC0gMTsgKytrKSB7Ci0gICAgICAgIG9zYy50eXBlID0gb3NjVHlwZXNb a10udHlwZQorICAgICAgICBvc2MudHlwZSA9IG9zY1R5cGVzW2tdLnR5cGU7CiAgICAgICAgIGlm IChvc2MudHlwZSA9PSBvc2NUeXBlc1trXS50eXBlKQogICAgICAgICAgICAgdGVzdFBhc3NlZCgi T3NjaWxsYXRvciBjb3JyZWN0bHkgc2V0IHRvICIgKyBvc2NUeXBlc1trXS5uYW1lICsgIiB0eXBl LiIpOwogICAgICAgICBlbHNlCiAgICAgICAgICAgICB0ZXN0RmFpbGVkKCJPc2NpbGxhdG9yIHNl dCB0byAiICsgb3NjVHlwZXNba10ubmFtZSArICIgdHlwZSwgYnV0IHJldHVybnMgIiArIG9zY1R5 cGVzW29zYy50eXBlXS5uYW1lICsgIiB0eXBlLiIpOwogICAgIH0KIAorICAgIC8vIEZvciBsZWdh Y3kgc3VwcG9ydCwgdmVyaWZ5IHRoYXQgd2UgY2FuIHNldCB0aGUgdHlwZSBhdHRyaWJ1dGUgYXMg YW4gaW50ZWdlciB2YWx1ZSBhbmQKKyAgICAvLyB2ZXJpZnkgdGhhdCB0aGlzIHRyYW5zbGF0ZXMg Y29ycmVjdGx5IHRvIHRoZSBXZWJJREwgZW51bSB2YWx1ZS4KKyAgICBmb3IgKHZhciBrID0gMDsg ayA8IG9zY1R5cGVzLmxlbmd0aCAtIDE7ICsraykgeworICAgICAgICBvc2MudHlwZSA9IG9zY1R5 cGVzW2tdLmludGVnZXJUeXBlOworICAgICAgICBpZiAob3NjLnR5cGUgPT0gb3NjVHlwZXNba10u dHlwZSkKKyAgICAgICAgICAgIHRlc3RQYXNzZWQoIk9zY2lsbGF0b3IgY29ycmVjdGx5IHNldCB0 byAiICsgb3NjVHlwZXNba10ubmFtZSArICIgdHlwZSB1c2luZyBsZWdhY3kgaW50ZWdlciB2YWx1 ZS4iKTsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgdGVzdEZhaWxlZCgiT3NjaWxsYXRvciBz ZXQgdG8gIiArIG9zY1R5cGVzW2tdLm5hbWUgKyAiIHR5cGUsIGJ1dCByZXR1cm5zICIgKyBvc2NU eXBlc1tvc2MudHlwZV0ubmFtZSArICIgdHlwZSB1c2luZyBsZWdhY3kgaW50ZWdlciB2YWx1ZS4i KTsKKyAgICB9CisKICAgICAvLyBOb3cgc2V0IGEgY3VzdG9tIG9zY2lsbGF0b3IKICAgICB2YXIg Y29lZmZBID0gbmV3IEZsb2F0MzJBcnJheShbMCwgMSwgMC41XSk7CiAgICAgdmFyIGNvZWZmQiA9 IG5ldyBGbG9hdDMyQXJyYXkoWzAsIDAsIDBdKTsgICAgICAgIAogICAgIHZhciB3YXZldGFibGUg PSBjb250ZXh0LmNyZWF0ZVdhdmVUYWJsZShjb2VmZkEsIGNvZWZmQik7CiAgICAgb3NjLnNldFdh dmVUYWJsZSh3YXZldGFibGUpOwotICAgIGlmIChvc2MudHlwZSA9PSBvc2MuQ1VTVE9NKQorICAg IGlmIChvc2MudHlwZSA9PSAiY3VzdG9tIikKICAgICAgICAgdGVzdFBhc3NlZCgiT3NjaWxsYXRv ciBjb3JyZWN0bHkgc2V0IHRvIENVU1RPTSB0eXBlIHVzaW5nIHNldFdhdmVUYWJsZS4iKTsKICAg ICBlbHNlCiAgICAgICAgIHRlc3RGYWlsZWQoIk9zY2lsbGF0b3Igc2V0IHRvIENVU1RPTSB0eXBl LCBidXQgcmV0dXJucyAiICsgb3NjVHlwZXNbb3NjLnR5cGVdLm5hbWUgKyAiIHR5cGUuIik7CiAK ICAgICAvLyBUcnkgc2V0dGluZyBzb21lIGludmFsaWQgdHlwZXMKICAgICB0cnkgewotICAgICAg ICBvc2MudHlwZSA9IG9zYy5DVVNUT007CisgICAgICAgIG9zYy50eXBlID0gImN1c3RvbSI7CiAg ICAgICAgIHRlc3RGYWlsZWQoIkRpcmVjdGx5IHNldHRpbmcgb3NjaWxsYXRvciB0eXBlIHRvIENV U1RPTSBkaWQgbm90IHRocm93IGV4Y2VwdGlvbi4iKTsKICAgICB9IGNhdGNoIChlKSB7CiAgICAg ICAgIHRlc3RQYXNzZWQoIkRpcmVjdGx5IHNldHRpbmcgb3NjaWxsYXRvciB0eXBlIHRvIENVU1RP TSBjb3JyZWN0bHkgdGhyb3dzIGV4Y2VwdGlvbi4iKTsK 180559 2012-12-21 14:46:06 -0800 2012-12-21 17:25:35 -0800 Patch bug-105058-20121221144324.patch text/plain 24524 crogers U3VidmVyc2lvbiBSZXZpc2lvbjogMTM4Mzk4CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9D aGFuZ2VMb2cgYi9Tb3VyY2UvV2ViQ29yZS9DaGFuZ2VMb2cKaW5kZXggMWEwNDA0ZjEwNTAwN2Rj ODA0N2JiZDA3ZjYxZDdlYTYyNjM1ZTAzZi4uM2ZiZDc5NWFlY2Q3OGZjYTljYTY3MDcyM2UzYzQ1 OTIwZjMwZTkxMiAxMDA2NDQKLS0tIGEvU291cmNlL1dlYkNvcmUvQ2hhbmdlTG9nCisrKyBiL1Nv dXJjZS9XZWJDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDM4IEBACisyMDEyLTEyLTIxICBDaHJp cyBSb2dlcnMgIDxjcm9nZXJzQGdvb2dsZS5jb20+CisKKyAgICAgICAgSW1wbGVtZW50IFdlYklE TC1zdHlsZSBzdHJpbmcgY29uc3RhbnRzIGluIFdlYkF1ZGlvIChwYXJ0IDEpCisgICAgICAgIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0xMDUwNTgKKworICAgICAgICBS ZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKyAgICAgICAgCisgICAgICAgIFNlZSBEZXByZWNh dGlvbiBOb3RlcyBmb3IgbW9yZSBkZXRhaWw6CisgICAgICAgIGh0dHBzOi8vZHZjcy53My5vcmcv aGcvYXVkaW8vcmF3LWZpbGUvdGlwL3dlYmF1ZGlvL3NwZWNpZmljYXRpb24uaHRtbCNEZXByZWNh dGlvbk5vdGVzCisgICAgICAgIAorICAgICAgICBQYW5uZXJOb2RlLCBCaXF1YWRGaWx0ZXJOb2Rl LCBPc2NpbGxhdG9yTm9kZSBjb25zdGFudHMgbXVzdCBzdXBwb3J0IFdlYklETC1zdHlsZSBzdHJp bmcgY29uc3RhbnRzLgorICAgICAgICBMZWdhY3kgc3VwcG9ydCBpbiB0aGUgc2V0dGVycyBmb3Ig dGhlIG9sZCBpbnRlZ2VyIHZhbHVlcyBzaG91bGQgYmUgc3VwcG9ydGVkLgorICAgICAgICAKKyAg ICAgICAgVGhpcyBwYXRjaCBoYW5kbGVzIHRoZSBjaGFuZ2VzIGZvciBPc2NpbGxhdG9yTm9kZS4K KworICAgICAgICAqIEdOVW1ha2VmaWxlLmxpc3QuYW06CisgICAgICAgICogTW9kdWxlcy93ZWJh dWRpby9Pc2NpbGxhdG9yTm9kZS5jcHA6CisgICAgICAgIChXZWJDb3JlOjpPc2NpbGxhdG9yTm9k ZTo6T3NjaWxsYXRvck5vZGUpOgorICAgICAgICAoV2ViQ29yZTo6T3NjaWxsYXRvck5vZGU6OnR5 cGUpOgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJDb3JlOjpPc2NpbGxhdG9yTm9k ZTo6c2V0VHlwZSk6CisgICAgICAgICogTW9kdWxlcy93ZWJhdWRpby9Pc2NpbGxhdG9yTm9kZS5o OgorICAgICAgICAqIE1vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuaWRsOgorICAgICAg ICAqIFRhcmdldC5wcmk6CisgICAgICAgICogVXNlSlNDLmNtYWtlOgorICAgICAgICAqIFVzZVY4 LmNtYWtlOgorICAgICAgICAqIFdlYkNvcmUuZ3lwaToKKyAgICAgICAgKiBXZWJDb3JlLnhjb2Rl cHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogYmluZGluZ3MvanMvSlNPc2NpbGxhdG9y Tm9kZUN1c3RvbS5jcHA6IENvcGllZCBmcm9tIFNvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVk aW8vT3NjaWxsYXRvck5vZGUuaWRsLgorICAgICAgICAoV2ViQ29yZSk6CisgICAgICAgIChXZWJD b3JlOjpKU09zY2lsbGF0b3JOb2RlOjpzZXRUeXBlKToKKyAgICAgICAgKiBiaW5kaW5ncy92OC9j dXN0b20vVjhPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHA6IENvcGllZCBmcm9tIFNvdXJjZS9XZWJD b3JlL01vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuaWRsLgorICAgICAgICAoV2ViQ29y ZSk6CisgICAgICAgIChXZWJDb3JlOjpWOE9zY2lsbGF0b3JOb2RlOjp0eXBlQWNjZXNzb3JTZXR0 ZXIpOgorCiAyMDEyLTEyLTIxICBCcmFkeSBFaWRzb24gIDxiZWlkc29uQGFwcGxlLmNvbT4KIAog ICAgICAgICBVcGRhdGUgbG9jYWxpemFibGUgc3RyaW5ncyBhcyBhIGZvbGxvd3VwIHRvIGh0dHA6 Ly90cmFjLndlYmtpdC5vcmcvY2hhbmdlc2V0LzEzODM4NwpkaWZmIC0tZ2l0IGEvU291cmNlL1dl YkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbSBiL1NvdXJjZS9XZWJDb3JlL0dOVW1ha2VmaWxlLmxp c3QuYW0KaW5kZXggMThmMDQ4NzRjMDVmMWY4NDcyZDMwMWRjYWVmMDMzZjc1ZjA1YzA4Yi4uODMw NDQ2OTdhZTU4ZWViYTBmYTQxNTU2YTk4Y2QwNWE2MjQ2OWZiNyAxMDA2NDQKLS0tIGEvU291cmNl L1dlYkNvcmUvR05VbWFrZWZpbGUubGlzdC5hbQorKysgYi9Tb3VyY2UvV2ViQ29yZS9HTlVtYWtl ZmlsZS5saXN0LmFtCkBAIC0yMzgyLDYgKzIzODIsNyBAQCB3ZWJjb3JlX3NvdXJjZXMgKz0gXAog CVNvdXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTTm9kZUZpbHRlckN1c3RvbS5jcHAgXAogCVNv dXJjZS9XZWJDb3JlL2JpbmRpbmdzL2pzL0pTTm9kZUl0ZXJhdG9yQ3VzdG9tLmNwcCBcCiAJU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNOb2RlTGlzdEN1c3RvbS5jcHAgXAorCVNvdXJjZS9X ZWJDb3JlL2JpbmRpbmdzL2pzL0pTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwIFwKIAlTb3VyY2Uv V2ViQ29yZS9iaW5kaW5ncy9qcy9KU1BsdWdpbkVsZW1lbnRGdW5jdGlvbnMuY3BwIFwKIAlTb3Vy Y2UvV2ViQ29yZS9iaW5kaW5ncy9qcy9KU1BsdWdpbkVsZW1lbnRGdW5jdGlvbnMuaCBcCiAJU291 cmNlL1dlYkNvcmUvYmluZGluZ3MvanMvSlNQb3BTdGF0ZUV2ZW50Q3VzdG9tLmNwcCBcCmRpZmYg LS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmNw cCBiL1NvdXJjZS9XZWJDb3JlL01vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuY3BwCmlu ZGV4IDY4ZGY5YTNiZmIyMzQ5OTNhYmEwZGE1Zjg3NDYzNzQwYzc4YTQ4ZDMuLmUyYjU4MDE0NDJl NTI2YTFjMTA5NThlYzgzNTY0NGRmMzZjNTY4YjggMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuY3BwCisrKyBiL1NvdXJjZS9XZWJDb3Jl L01vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuY3BwCkBAIC02OSw4ICs2OSw3IEBAIE9z Y2lsbGF0b3JOb2RlOjpPc2NpbGxhdG9yTm9kZShBdWRpb0NvbnRleHQqIGNvbnRleHQsIGZsb2F0 IHNhbXBsZVJhdGUpCiAgICAgbV9kZXR1bmUgPSBBdWRpb1BhcmFtOjpjcmVhdGUoY29udGV4dCwg ImRldHVuZSIsIDAsIC00ODAwLCA0ODAwKTsKIAogICAgIC8vIFNldHMgdXAgZGVmYXVsdCB3YXZl dGFibGUuCi0gICAgRXhjZXB0aW9uQ29kZSBlYzsKLSAgICBzZXRUeXBlKG1fdHlwZSwgZWMpOwor ICAgIHNldFR5cGUobV90eXBlKTsKIAogICAgIC8vIEFuIG9zY2lsbGF0b3IgaXMgYWx3YXlzIG1v bm8uCiAgICAgYWRkT3V0cHV0KGFkb3B0UHRyKG5ldyBBdWRpb05vZGVPdXRwdXQodGhpcywgMSkp KTsKQEAgLTgzLDcgKzgyLDM4IEBAIE9zY2lsbGF0b3JOb2RlOjp+T3NjaWxsYXRvck5vZGUoKQog ICAgIHVuaW5pdGlhbGl6ZSgpOwogfQogCi12b2lkIE9zY2lsbGF0b3JOb2RlOjpzZXRUeXBlKHVu c2lnbmVkIHNob3J0IHR5cGUsIEV4Y2VwdGlvbkNvZGUmIGVjKQorU3RyaW5nIE9zY2lsbGF0b3JO b2RlOjp0eXBlKCkgY29uc3QKK3sKKyAgICBzd2l0Y2ggKG1fdHlwZSkgeworICAgIGNhc2UgU0lO RToKKyAgICAgICAgcmV0dXJuICJzaW5lIjsKKyAgICBjYXNlIFNRVUFSRToKKyAgICAgICAgcmV0 dXJuICJzcXVhcmUiOworICAgIGNhc2UgU0FXVE9PVEg6CisgICAgICAgIHJldHVybiAic2F3dG9v dGgiOworICAgIGNhc2UgVFJJQU5HTEU6CisgICAgICAgIHJldHVybiAidHJpYW5nbGUiOworICAg IGNhc2UgQ1VTVE9NOgorICAgICAgICByZXR1cm4gImN1c3RvbSI7CisgICAgZGVmYXVsdDoKKyAg ICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgIHJldHVybiAiY3VzdG9tIjsKKyAg ICB9Cit9CisKK3ZvaWQgT3NjaWxsYXRvck5vZGU6OnNldFR5cGUoY29uc3QgU3RyaW5nJiB0eXBl KQoreworICAgIGlmICh0eXBlID09ICJzaW5lIikKKyAgICAgICAgc2V0VHlwZShTSU5FKTsKKyAg ICBlbHNlIGlmICh0eXBlID09ICJzcXVhcmUiKQorICAgICAgICBzZXRUeXBlKFNRVUFSRSk7Cisg ICAgZWxzZSBpZiAodHlwZSA9PSAic2F3dG9vdGgiKQorICAgICAgICBzZXRUeXBlKFNBV1RPT1RI KTsKKyAgICBlbHNlIGlmICh0eXBlID09ICJ0cmlhbmdsZSIpCisgICAgICAgIHNldFR5cGUoVFJJ QU5HTEUpOworfQorCitib29sIE9zY2lsbGF0b3JOb2RlOjpzZXRUeXBlKHVuc2lnbmVkIHR5cGUp CiB7CiAgICAgV2F2ZVRhYmxlKiB3YXZlVGFibGUgPSAwOwogICAgIGZsb2F0IHNhbXBsZVJhdGUg PSB0aGlzLT5zYW1wbGVSYXRlKCk7CkBAIC0xMTEsMTQgKzE0MSwxNCBAQCB2b2lkIE9zY2lsbGF0 b3JOb2RlOjpzZXRUeXBlKHVuc2lnbmVkIHNob3J0IHR5cGUsIEV4Y2VwdGlvbkNvZGUmIGVjKQog ICAgICAgICBicmVhazsKICAgICBjYXNlIENVU1RPTToKICAgICBkZWZhdWx0OgotICAgICAgICAv LyBUaHJvdyBleGNlcHRpb24gZm9yIGludmFsaWQgdHlwZXMsIGluY2x1ZGluZyBDVVNUT00gc2lu Y2Ugc2V0V2F2ZVRhYmxlKCkgbWV0aG9kIG11c3QgYmUKKyAgICAgICAgLy8gUmV0dXJuIGVycm9y IGZvciBpbnZhbGlkIHR5cGVzLCBpbmNsdWRpbmcgQ1VTVE9NIHNpbmNlIHNldFdhdmVUYWJsZSgp IG1ldGhvZCBtdXN0IGJlCiAgICAgICAgIC8vIGNhbGxlZCBleHBsaWNpdGx5LgotICAgICAgICBl YyA9IE5PVF9TVVBQT1JURURfRVJSOwotICAgICAgICByZXR1cm47CisgICAgICAgIHJldHVybiBm YWxzZTsKICAgICB9CiAKICAgICBzZXRXYXZlVGFibGUod2F2ZVRhYmxlKTsKICAgICBtX3R5cGUg PSB0eXBlOworICAgIHJldHVybiB0cnVlOwogfQogCiBib29sIE9zY2lsbGF0b3JOb2RlOjpjYWxj dWxhdGVTYW1wbGVBY2N1cmF0ZVBoYXNlSW5jcmVtZW50cyhzaXplX3QgZnJhbWVzVG9Qcm9jZXNz KQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9Pc2NpbGxhdG9y Tm9kZS5oIGIvU291cmNlL1dlYkNvcmUvTW9kdWxlcy93ZWJhdWRpby9Pc2NpbGxhdG9yTm9kZS5o CmluZGV4IDFkNmIxNTIzNjA4ZTFkYzBiOGJmNTEwOGNkOTk4OTUwZmIxNzcwNGQuLmU5ZTlhNzlh ZTU5ZWVjMTVhOWM4N2U1ZmQ3NmU1OTA3NzdjYmQzZGMgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJD b3JlL01vZHVsZXMvd2ViYXVkaW8vT3NjaWxsYXRvck5vZGUuaAorKysgYi9Tb3VyY2UvV2ViQ29y ZS9Nb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JOb2RlLmgKQEAgLTYwLDggKzYwLDEwIEBAIHB1 YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgcHJvY2VzcyhzaXplX3QgZnJhbWVzVG9Qcm9jZXNzKTsK ICAgICB2aXJ0dWFsIHZvaWQgcmVzZXQoKTsKIAotICAgIHVuc2lnbmVkIHNob3J0IHR5cGUoKSBj b25zdCB7IHJldHVybiBtX3R5cGU7IH0KLSAgICB2b2lkIHNldFR5cGUodW5zaWduZWQgc2hvcnQs IEV4Y2VwdGlvbkNvZGUmKTsKKyAgICBTdHJpbmcgdHlwZSgpIGNvbnN0OworCisgICAgYm9vbCBz ZXRUeXBlKHVuc2lnbmVkKTsgLy8gUmV0dXJucyB0cnVlIG9uIHN1Y2Nlc3MuCisgICAgdm9pZCBz ZXRUeXBlKGNvbnN0IFN0cmluZyYpOwogCiAgICAgQXVkaW9QYXJhbSogZnJlcXVlbmN5KCkgeyBy ZXR1cm4gbV9mcmVxdWVuY3kuZ2V0KCk7IH0KICAgICBBdWRpb1BhcmFtKiBkZXR1bmUoKSB7IHJl dHVybiBtX2RldHVuZS5nZXQoKTsgfQpkaWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvTW9kdWxl cy93ZWJhdWRpby9Pc2NpbGxhdG9yTm9kZS5pZGwgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dl YmF1ZGlvL09zY2lsbGF0b3JOb2RlLmlkbAppbmRleCAzNGVjMzc2ZTJkMzI5NGQ4MjgwOTU1ZDU3 Yzc1NTI1YzU2MDVhZjczLi43YTk0ZGY1ODczNmQ1ZTkzMmY1ZGZjNTg5Y2JhZDAyYjk0MzQ5MzBm IDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JO b2RlLmlkbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9Nb2R1bGVzL3dlYmF1ZGlvL09zY2lsbGF0b3JO b2RlLmlkbApAQCAtMzUsOCArMzUsNyBAQAogICAgIGNvbnN0IHVuc2lnbmVkIHNob3J0IFRSSUFO R0xFID0gMzsKICAgICBjb25zdCB1bnNpZ25lZCBzaG9ydCBDVVNUT00gPSA0OwogCi0gICAgYXR0 cmlidXRlIHVuc2lnbmVkIHNob3J0IHR5cGUKLSAgICAgICAgc2V0dGVyIHJhaXNlcyhET01FeGNl cHRpb24pOyAgICAgICAgCisgICAgW0N1c3RvbVNldHRlcl0gYXR0cmlidXRlIERPTVN0cmluZyB0 eXBlOwogCiAgICAgLy8gUGxheWJhY2sgc3RhdGUgY29uc3RhbnRzLgogICAgIGNvbnN0IHVuc2ln bmVkIHNob3J0IFVOU0NIRURVTEVEX1NUQVRFID0gMDsKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJD b3JlL1RhcmdldC5wcmkgYi9Tb3VyY2UvV2ViQ29yZS9UYXJnZXQucHJpCmluZGV4IGIxYmI4ZjNj OGI1ODc5MWIzZWNkNjcxMThhMWIxM2YxMDM0ZDRlZDEuLjExODAwNGE4MjJlMDdlNzRjNzAwYTQ1 ODFmOTFmOTE1NzA4ZTljMjIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9XZWJDb3JlL1RhcmdldC5wcmkK KysrIGIvU291cmNlL1dlYkNvcmUvVGFyZ2V0LnByaQpAQCAtMzQxNiw2ICszNDE2LDcgQEAgZW5h YmxlPyhXRUJfQVVESU8pIHsKICAgICAgICAgYmluZGluZ3MvanMvSlNBdWRpb0J1ZmZlclNvdXJj ZU5vZGVDdXN0b20uY3BwIFwKICAgICAgICAgYmluZGluZ3MvanMvSlNBdWRpb0NvbnRleHRDdXN0 b20uY3BwIFwKICAgICAgICAgYmluZGluZ3MvanMvSlNET01XaW5kb3dXZWJBdWRpb0N1c3RvbS5j cHAgXAorICAgICAgICBiaW5kaW5ncy9qcy9KU09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcCBcCiAg ICAgICAgIGJpbmRpbmdzL2pzL0pTU2NyaXB0UHJvY2Vzc29yTm9kZUN1c3RvbS5jcHAgXAogICAg ICAgICBNb2R1bGVzL3dlYmF1ZGlvL0FzeW5jQXVkaW9EZWNvZGVyLmNwcCBcCiAgICAgICAgIE1v ZHVsZXMvd2ViYXVkaW8vQXVkaW9CYXNpY0luc3BlY3Rvck5vZGUuY3BwIFwKZGlmZiAtLWdpdCBh L1NvdXJjZS9XZWJDb3JlL1VzZUpTQy5jbWFrZSBiL1NvdXJjZS9XZWJDb3JlL1VzZUpTQy5jbWFr ZQppbmRleCBjMGNhZjg3ZjY2YWIxYTJlYWQ5NGJhODI3NzJlMjJhYzIyZGQ4YjQ3Li5lZGFjMmU0 YTk0NjBjMmE3MTY3YTkzMDFkMjgzY2ZmZTdkMTczOWQxIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2Vi Q29yZS9Vc2VKU0MuY21ha2UKKysrIGIvU291cmNlL1dlYkNvcmUvVXNlSlNDLmNtYWtlCkBAIC0y NjgsNiArMjY4LDcgQEAgaWYgKEVOQUJMRV9XRUJfQVVESU8pCiAgICAgbGlzdChBUFBFTkQgV2Vi Q29yZV9TT1VSQ0VTCiAgICAgICAgIGJpbmRpbmdzL2pzL0pTQXVkaW9CdWZmZXJTb3VyY2VOb2Rl Q3VzdG9tLmNwcAogICAgICAgICBiaW5kaW5ncy9qcy9KU0F1ZGlvQ29udGV4dEN1c3RvbS5jcHAK KyAgICAgICAgYmluZGluZ3MvanMvSlNPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHAKICAgICAgICAg YmluZGluZ3MvanMvSlNTY3JpcHRQcm9jZXNzb3JOb2RlQ3VzdG9tLmNwcAogICAgICkKIGVuZGlm ICgpCmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9Vc2VWOC5jbWFrZSBiL1NvdXJjZS9XZWJD b3JlL1VzZVY4LmNtYWtlCmluZGV4IGRlNGU3MTUzZmEwNWUxZjIyZTI2NmFjNTNhMzJjMzVmYzYy Nzc3ZjUuLjRhMDgxNDg3ZmQwZDZiMTkwMjk1ZTIwNTY5ZGUwNGUyODA2YjQ2MmMgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9XZWJDb3JlL1VzZVY4LmNtYWtlCisrKyBiL1NvdXJjZS9XZWJDb3JlL1VzZVY4 LmNtYWtlCkBAIC0xMzcsNiArMTM3LDcgQEAgbGlzdChBUFBFTkQgV2ViQ29yZV9TT1VSQ0VTCiAg ICAgYmluZGluZ3MvdjgvY3VzdG9tL1Y4Tm9kZUxpc3RDdXN0b20uY3BwCiAgICAgYmluZGluZ3Mv djgvY3VzdG9tL1Y4Tm90aWZpY2F0aW9uQ3VzdG9tLmNwcAogICAgIGJpbmRpbmdzL3Y4L2N1c3Rv bS9WOE5vdGlmaWNhdGlvbkNlbnRlckN1c3RvbS5jcHAKKyAgICBiaW5kaW5ncy92OC9jdXN0b20v VjhPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHAKICAgICBiaW5kaW5ncy92OC9jdXN0b20vVjhQZXJm b3JtYW5jZUVudHJ5Q3VzdG9tLmNwcAogICAgIGJpbmRpbmdzL3Y4L2N1c3RvbS9WOFBvcFN0YXRl RXZlbnRDdXN0b20uY3BwCiAgICAgYmluZGluZ3MvdjgvY3VzdG9tL1Y4U1FMUmVzdWx0U2V0Um93 TGlzdEN1c3RvbS5jcHAKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaSBi L1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUuZ3lwaQppbmRleCAzNjg1YTk4ODQ5MzdkZDNmNzIxMmUy MTc2ZmFmMjY5ODk4NjViYTBjLi4xMzRiYWI1Y2JiZTgyZjJmZGMyZTYyMDc2NDk0YmE3MjJlZDQ3 NGMyIDEwMDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLmd5cGkKKysrIGIvU291cmNl L1dlYkNvcmUvV2ViQ29yZS5neXBpCkBAIC0xMzcxLDYgKzEzNzEsNyBAQAogICAgICAgICAgICAg J2JpbmRpbmdzL3Y4L2N1c3RvbS9WOE5vZGVMaXN0Q3VzdG9tLmNwcCcsCiAgICAgICAgICAgICAn YmluZGluZ3MvdjgvY3VzdG9tL1Y4Tm90aWZpY2F0aW9uQ3VzdG9tLmNwcCcsCiAgICAgICAgICAg ICAnYmluZGluZ3MvdjgvY3VzdG9tL1Y4Tm90aWZpY2F0aW9uQ2VudGVyQ3VzdG9tLmNwcCcsCisg ICAgICAgICAgICAnYmluZGluZ3MvdjgvY3VzdG9tL1Y4T3NjaWxsYXRvck5vZGVDdXN0b20uY3Bw JywKICAgICAgICAgICAgICdiaW5kaW5ncy92OC9jdXN0b20vVjhQZXJmb3JtYW5jZUVudHJ5Q3Vz dG9tLmNwcCcsCiAgICAgICAgICAgICAnYmluZGluZ3MvdjgvY3VzdG9tL1Y4UG9wU3RhdGVFdmVu dEN1c3RvbS5jcHAnLAogICAgICAgICAgICAgJ2JpbmRpbmdzL3Y4L2N1c3RvbS9WOFNRTFJlc3Vs dFNldFJvd0xpc3RDdXN0b20uY3BwJywKZGlmZiAtLWdpdCBhL1NvdXJjZS9XZWJDb3JlL1dlYkNv cmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJjZS9XZWJDb3JlL1dlYkNvcmUueGNv ZGVwcm9qL3Byb2plY3QucGJ4cHJvagppbmRleCBjY2ZiODk0ZTVhYzJmYWU5ZjBkMzk0OTgyN2U1 ZGIyZjkyY2IyYWY1Li5mZmMzOWYxMzUwYmM3NTA5Njg3M2QxOTgxZDRiOWY4YTBlYTQ0YjY5IDEw MDY0NAotLS0gYS9Tb3VyY2UvV2ViQ29yZS9XZWJDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHBy b2oKKysrIGIvU291cmNlL1dlYkNvcmUvV2ViQ29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q CkBAIC02NjM0LDYgKzY2MzQsNyBAQAogCQlGREIwNTJFMDE1NjFBNDJDMDBCNTAwRDYgLyogQXVk aW9TdW1taW5nSnVuY3Rpb24uaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IEZEQjA1MkRFMTU2MUE0MkMwMEI1MDBENiAvKiBBdWRpb1N1bW1pbmdKdW5jdGlv bi5oICovOyB9OwogCQlGREIxNzAwNTE0QTJCQUIyMDBBMkI1RDkgLyogTXVsdGlDaGFubmVsUmVz YW1wbGVyLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IEZEQjE3MDAzMTRBMkJBQjIwMEEyQjVEOSAvKiBNdWx0aUNoYW5uZWxSZXNhbXBsZXIuY3BwICov OyB9OwogCQlGREIxNzAwNjE0QTJCQUIyMDBBMkI1RDkgLyogTXVsdGlDaGFubmVsUmVzYW1wbGVy LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBGREIxNzAw NDE0QTJCQUIyMDBBMkI1RDkgLyogTXVsdGlDaGFubmVsUmVzYW1wbGVyLmggKi87IH07CisJCUZE QkQxREZDMTY3RkUyN0QwMDUxQTExRSAvKiBKU09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcCBpbiBT b3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEZEQkQxREZCMTY3RkUy N0QwMDUxQTExRSAvKiBKU09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcCAqLzsgfTsKIAkJRkRCRDQ4 MEMxNTlCQzY4NzAwOTNFQjRGIC8qIEpTTWVkaWFTdHJlYW1BdWRpb1NvdXJjZU5vZGUuY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkRCRDQ4MEExNTlC QzY4NzAwOTNFQjRGIC8qIEpTTWVkaWFTdHJlYW1BdWRpb1NvdXJjZU5vZGUuY3BwICovOyB9Owog CQlGREJENDgwRDE1OUJDNjg3MDA5M0VCNEYgLyogSlNNZWRpYVN0cmVhbUF1ZGlvU291cmNlTm9k ZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkRCRDQ4 MEIxNTlCQzY4NzAwOTNFQjRGIC8qIEpTTWVkaWFTdHJlYW1BdWRpb1NvdXJjZU5vZGUuaCAqLzsg fTsKIAkJRkRDNTRGMDQxMzk5QjBEQTAwOEQ5MTE3IC8qIEJpcXVhZEZpbHRlck5vZGUuY3BwIGlu IFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gRkRDNTRGMDExMzk5 QjBEQTAwOEQ5MTE3IC8qIEJpcXVhZEZpbHRlck5vZGUuY3BwICovOyB9OwpAQCAtMTQyMDQsNiAr MTQyMDUsNyBAQAogCQlGREIwNTJERTE1NjFBNDJDMDBCNTAwRDYgLyogQXVkaW9TdW1taW5nSnVu Y3Rpb24uaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gQXVkaW9TdW1taW5nSnVu Y3Rpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRkRCMTcwMDMxNEEyQkFCMjAw QTJCNUQ5IC8qIE11bHRpQ2hhbm5lbFJlc2FtcGxlci5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmNwcC5jcHA7IHBhdGggPSBNdWx0aUNoYW5uZWxSZXNhbXBsZXIuY3BwOyBzb3VyY2VUcmVlID0g Ijxncm91cD4iOyB9OwogCQlGREIxNzAwNDE0QTJCQUIyMDBBMkI1RDkgLyogTXVsdGlDaGFubmVs UmVzYW1wbGVyLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g NDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IE11bHRpQ2hhbm5l bFJlc2FtcGxlci5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlGREJEMURGQjE2N0ZF MjdEMDA1MUExMUUgLyogSlNPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHAgKi8gPSB7aXNhID0gUEJY RmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBKU09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRkRCRDQ4MEExNTlCQzY4NzAwOTNFQjRGIC8qIEpTTWVk aWFTdHJlYW1BdWRpb1NvdXJjZU5vZGUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3Bw OyBwYXRoID0gSlNNZWRpYVN0cmVhbUF1ZGlvU291cmNlTm9kZS5jcHA7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCUZEQkQ0ODBCMTU5QkM2ODcwMDkzRUI0RiAvKiBKU01lZGlhU3RyZWFt QXVkaW9Tb3VyY2VOb2RlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29k aW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpTTWVk aWFTdHJlYW1BdWRpb1NvdXJjZU5vZGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ RkRDNTRGMDExMzk5QjBEQTAwOEQ5MTE3IC8qIEJpcXVhZEZpbHRlck5vZGUuY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gQmlxdWFkRmlsdGVyTm9kZS5jcHA7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC0yMDcxNiw2ICsyMDcxOCw3IEBACiAJCQkJMUE3NTBE RDMwQTkwRTcyOTAwMEZGMjE1IC8qIEpTTm9kZUl0ZXJhdG9yQ3VzdG9tLmNwcCAqLywKIAkJCQlC Q0Q5QzI2MTBDMTdBQTY3MDA1QzkwQTIgLyogSlNOb2RlTGlzdEN1c3RvbS5jcHAgKi8sCiAJCQkJ MzFGRTZFNkMxNTAxQTNCRjAwMDRFQkM0IC8qIEpTTm90aWZpY2F0aW9uQ3VzdG9tLmNwcCAqLywK KwkJCQlGREJEMURGQjE2N0ZFMjdEMDA1MUExMUUgLyogSlNPc2NpbGxhdG9yTm9kZUN1c3RvbS5j cHAgKi8sCiAJCQkJQTg1RjIyMDgxNDMwMzc3RDAwN0NDODg0IC8qIEpTUG9wU3RhdGVFdmVudEN1 c3RvbS5jcHAgKi8sCiAJCQkJRTFBRDEyRDUxMjk1RDBCRDAwQUNBOTg5IC8qIEpTUHJvY2Vzc2lu Z0luc3RydWN0aW9uQ3VzdG9tLmNwcCAqLywKIAkJCQk0OTk4QUVEMzEzRkM0MTdGMDA5MEIxQUEg LyogSlNSZXF1ZXN0QW5pbWF0aW9uRnJhbWVDYWxsYmFja0N1c3RvbS5jcHAgKi8sCkBAIC0yOTEw MCw2ICsyOTEwMyw3IEBACiAJCQkJMEZCODg5MEIxNjdEMkZBMTAwMTBDREE1IC8qIFNjcm9sbGlu Z1RyZWVTdGlja3lOb2RlLm1tIGluIFNvdXJjZXMgKi8sCiAJCQkJMEZCODg5MEUxNjdEMzAxNjAw MTBDREE1IC8qIFNjcm9sbGluZ1N0YXRlU3RpY2t5Tm9kZS5jcHAgaW4gU291cmNlcyAqLywKIAkJ CQkyMDlCNDU2QjE2Nzk2QTdFMDBFNTRFNEUgLyogSlNDcnlwdG9DdXN0b20uY3BwIGluIFNvdXJj ZXMgKi8sCisJCQkJRkRCRDFERkMxNjdGRTI3RDAwNTFBMTFFIC8qIEpTT3NjaWxsYXRvck5vZGVD dXN0b20uY3BwIGluIFNvdXJjZXMgKi8sCiAJCQkpOwogCQkJcnVuT25seUZvckRlcGxveW1lbnRQ b3N0cHJvY2Vzc2luZyA9IDA7CiAJCX07CmRpZmYgLS1naXQgYS9Tb3VyY2UvV2ViQ29yZS9iaW5k aW5ncy9qcy9KU09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcCBiL1NvdXJjZS9XZWJDb3JlL2JpbmRp bmdzL2pzL0pTT3NjaWxsYXRvck5vZGVDdXN0b20uY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0Cmlu ZGV4IDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLjA0YmJjYzRkMTY0 ZjdiYmZhNjQ2OGNiZWRlZmY1OWU2MDA0ODVjYWIKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2Uv V2ViQ29yZS9iaW5kaW5ncy9qcy9KU09zY2lsbGF0b3JOb2RlQ3VzdG9tLmNwcApAQCAtMCwwICsx LDY1IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDEyLCBHb29nbGUgSW5jLiBBbGwgcmlnaHRz IHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBi aW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0 dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0Ogor ICogMS4gIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJv dmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0 aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiAgUmVkaXN0cmlidXRpb25zIGluIGJpbmFy eSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwg dGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0 aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3 aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBC WSBBUFBMRSBJTkMuIEFORCBJVFMgQ09OVFJJQlVUT1JTIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFRIRSBJTVBMSUVECisgKiBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSIFBVUlBPU0UgQVJFCisgKiBESVNDTEFJTUVELiBJTiBOTyBF VkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SIElUUyBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBB TlkKKyAqIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsIEVYRU1QTEFSWSwg T1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTCisgKiAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7CisgKiBMT1NT IE9GIFVTRSwgREFUQSwgT1IgUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQgT04KKyAqIEFOWSBUSEVPUlkgT0YgTElBQklMSVRZLCBXSEVUSEVSIElO IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJ R0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UgT0Yg VEhJUworICogU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorCisjaWYgRU5BQkxFKFdF Ql9BVURJTykKKworI2luY2x1ZGUgIkpTT3NjaWxsYXRvck5vZGUuaCIKKworI2luY2x1ZGUgIkV4 Y2VwdGlvbkNvZGUuaCIKKyNpbmNsdWRlICJPc2NpbGxhdG9yTm9kZS5oIgorI2luY2x1ZGUgPHJ1 bnRpbWUvRXJyb3IuaD4KKwordXNpbmcgbmFtZXNwYWNlIEpTQzsKKworbmFtZXNwYWNlIFdlYkNv cmUgeworCit2b2lkIEpTT3NjaWxsYXRvck5vZGU6OnNldFR5cGUoRXhlY1N0YXRlKiBleGVjLCBK U1ZhbHVlIHZhbHVlKQoreworICAgIE9zY2lsbGF0b3JOb2RlKiBpbXAgPSBzdGF0aWNfY2FzdDxP c2NpbGxhdG9yTm9kZSo+KGltcGwoKSk7CisKKyNpZiBFTkFCTEUoTEVHQUNZX1dFQl9BVURJTykK KyAgICBpZiAodmFsdWUuaXNOdW1iZXIoKSkgeworICAgICAgICB1aW50MzJfdCB0eXBlID0gdmFs dWUudG9VSW50MzIoZXhlYyk7CisgICAgICAgIGlmICghaW1wLT5zZXRUeXBlKHR5cGUpKQorICAg ICAgICAgICAgdGhyb3dFcnJvcihleGVjLCBjcmVhdGVUeXBlRXJyb3IoZXhlYywgIklsbGVnYWwg T3NjaWxsYXRvck5vZGUgdHlwZSIpKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKyNlbmRpZgor CisgICAgaWYgKHZhbHVlLmlzU3RyaW5nKCkpIHsKKyAgICAgICAgU3RyaW5nIHR5cGUgPSB2YWx1 ZS50b1N0cmluZyhleGVjKS0+dmFsdWUoZXhlYyk7CisgICAgICAgIGlmICh0eXBlID09ICJzaW5l IiB8fCB0eXBlID09ICJzcXVhcmUiIHx8IHR5cGUgPT0gInNhd3Rvb3RoIiB8fCB0eXBlID09ICJ0 cmlhbmdsZSIpIHsKKyAgICAgICAgICAgIGltcC0+c2V0VHlwZSh0eXBlKTsKKyAgICAgICAgICAg IHJldHVybjsKKyAgICAgICAgfQorICAgIH0KKyAgICAKKyAgICB0aHJvd0Vycm9yKGV4ZWMsIGNy ZWF0ZVR5cGVFcnJvcihleGVjLCAiSWxsZWdhbCBPc2NpbGxhdG9yTm9kZSB0eXBlIikpOworfQor Cit9IC8vIG5hbWVzcGFjZSBXZWJDb3JlCisKKyNlbmRpZiAvLyBFTkFCTEUoV0VCX0FVRElPKQpk aWZmIC0tZ2l0IGEvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4T3NjaWxsYXRv ck5vZGVDdXN0b20uY3BwIGIvU291cmNlL1dlYkNvcmUvYmluZGluZ3MvdjgvY3VzdG9tL1Y4T3Nj aWxsYXRvck5vZGVDdXN0b20uY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAw MDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAwMDAuLmE3N2FlOTIzYzJlYWJhYmQxZTJjNjAx NmZjNDI4OWZkYjhiNGNkNGIKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvV2ViQ29yZS9iaW5k aW5ncy92OC9jdXN0b20vVjhPc2NpbGxhdG9yTm9kZUN1c3RvbS5jcHAKQEAgLTAsMCArMSw2NiBA QAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxMiwgR29vZ2xlIEluYy4gQWxsIHJpZ2h0cyByZXNl cnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5 IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBw cm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEu ICBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNv cHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZv bGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9y bSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMg bGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisg KiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0 aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQ TEUgSU5DLiBBTkQgSVRTIENPTlRSSUJVVE9SUyBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVT UyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBU SEUgSU1QTElFRAorICogV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUiBQVVJQT1NFIEFSRQorICogRElTQ0xBSU1FRC4gSU4gTk8gRVZFTlQg U0hBTEwgQVBQTEUgSU5DLiBPUiBJVFMgQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZCisg KiBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLCBFWEVNUExBUlksIE9SIENP TlNFUVVFTlRJQUwgREFNQUdFUworICogKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBQ Uk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOworICogTE9TUyBPRiBV U0UsIERBVEEsIE9SIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBD QVVTRUQgQU5EIE9OCisgKiBBTlkgVEhFT1JZIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05U UkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFIE9GIFRISVMK KyAqIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0gg REFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKworI2lmIEVOQUJMRShXRUJfQVVE SU8pCisKKyNpbmNsdWRlICJWOE9zY2lsbGF0b3JOb2RlLmgiCisKKyNpbmNsdWRlICJFeGNlcHRp b25Db2RlLmgiCisjaW5jbHVkZSAiT3NjaWxsYXRvck5vZGUuaCIKKyNpbmNsdWRlICJWOEJpbmRp bmcuaCIKKworbmFtZXNwYWNlIFdlYkNvcmUgeworCit2b2lkIFY4T3NjaWxsYXRvck5vZGU6OnR5 cGVBY2Nlc3NvclNldHRlcih2ODo6TG9jYWw8djg6OlN0cmluZz4gbmFtZSwgdjg6OkxvY2FsPHY4 OjpWYWx1ZT4gdmFsdWUsIGNvbnN0IHY4OjpBY2Nlc3NvckluZm8mIGluZm8pCit7CisgICAgSU5D X1NUQVRTKCJET00uT3NjaWxsYXRvck5vZGUudHlwZS5fc2V0Iik7CisgICAgdjg6OkhhbmRsZTx2 ODo6T2JqZWN0PiBob2xkZXIgPSBpbmZvLkhvbGRlcigpOworICAgIE9zY2lsbGF0b3JOb2RlKiBp bXAgPSBWOE9zY2lsbGF0b3JOb2RlOjp0b05hdGl2ZShob2xkZXIpOworCisjaWYgRU5BQkxFKExF R0FDWV9XRUJfQVVESU8pICAgIAorICAgIGlmICh2YWx1ZS0+SXNOdW1iZXIoKSkgeworICAgICAg ICBib29sIG9rID0gZmFsc2U7CisgICAgICAgIHVpbnQzMl90IHR5cGUgPSB0b1VJbnQzMih2YWx1 ZSwgb2spOworICAgICAgICBpZiAoIW9rIHx8ICFpbXAtPnNldFR5cGUodHlwZSkpCisgICAgICAg ICAgICB0aHJvd0Vycm9yKHY4VHlwZUVycm9yLCAiSWxsZWdhbCBPc2NpbGxhdG9yTm9kZSB0eXBl IiwgaW5mby5HZXRJc29sYXRlKCkpOworICAgICAgICByZXR1cm47CisgICAgfQorI2VuZGlmCisK KyAgICBpZiAodmFsdWUtPklzU3RyaW5nKCkpIHsKKyAgICAgICAgU3RyaW5nIHR5cGUgPSB0b1dl YkNvcmVTdHJpbmcodmFsdWUpOworICAgICAgICBpZiAodHlwZSA9PSAic2luZSIgfHwgdHlwZSA9 PSAic3F1YXJlIiB8fCB0eXBlID09ICJzYXd0b290aCIgfHwgdHlwZSA9PSAidHJpYW5nbGUiKSB7 CisgICAgICAgICAgICBpbXAtPnNldFR5cGUodHlwZSk7CisgICAgICAgICAgICByZXR1cm47Cisg ICAgICAgIH0KKyAgICB9CisgICAgCisgICAgdGhyb3dFcnJvcih2OFR5cGVFcnJvciwgIklsbGVn YWwgT3NjaWxsYXRvck5vZGUgdHlwZSIsIGluZm8uR2V0SXNvbGF0ZSgpKTsKK30KKworfSAvLyBu YW1lc3BhY2UgV2ViQ29yZQorCisjZW5kaWYgLy8gRU5BQkxFKFdFQl9BVURJTykKZGlmZiAtLWdp dCBhL0xheW91dFRlc3RzL0NoYW5nZUxvZyBiL0xheW91dFRlc3RzL0NoYW5nZUxvZwppbmRleCA4 ZDNmYjg0ZTZhNjQ4ZDc4Y2IyMjdjNjU1YjQ2Y2YyMjU1MDc5ZDk2Li5lNmZiZjFiMWE5NTI4NDM4 ZGZlMGVmZGJiZmE2ZWVlMTEzMzZjM2VkIDEwMDY0NAotLS0gYS9MYXlvdXRUZXN0cy9DaGFuZ2VM b2cKKysrIGIvTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMTQgQEAKKzIwMTItMTIt MjEgIENocmlzIFJvZ2VycyAgPGNyb2dlcnNAZ29vZ2xlLmNvbT4KKworICAgICAgICBJbXBsZW1l bnQgV2ViSURMLXN0eWxlIHN0cmluZyBjb25zdGFudHMgaW4gV2ViQXVkaW8KKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTEwNTA1OAorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogd2ViYXVkaW8vb3NjaWxsYXRv ci1iYXNpYy1leHBlY3RlZC50eHQ6CisgICAgICAgICogd2ViYXVkaW8vb3NjaWxsYXRvci1iYXNp Yy5odG1sOgorICAgICAgICAqIHdlYmF1ZGlvL3Jlc291cmNlcy9hdWRpby10ZXN0aW5nLmpzOgor CiAyMDEyLTEyLTIxICBBYXJvbiBDb2x3ZWxsICA8YWNvbHdlbGxAY2hyb21pdW0ub3JnPgogCiAg ICAgICAgIFVucmV2aWV3ZWQuIFJlbW92aW5nIENSQVNIIGV4cGVjdGF0aW9ucyBmb3IgbWVkaWEg bGF5b3V0IHRlc3RzCmRpZmYgLS1naXQgYS9MYXlvdXRUZXN0cy93ZWJhdWRpby9vc2NpbGxhdG9y LWJhc2ljLWV4cGVjdGVkLnR4dCBiL0xheW91dFRlc3RzL3dlYmF1ZGlvL29zY2lsbGF0b3ItYmFz aWMtZXhwZWN0ZWQudHh0CmluZGV4IDE1ZGVmNDM2YzRlOWU1YWRkY2MwODMzMTkwMGNhMGQ0YTc1 ZmE2OWMuLmIwNzZkNzZlNTRjZjY5NTcyYzJjZTZlMWZmNjdlNjJiMTFlNDljMjkgMTAwNjQ0Ci0t LSBhL0xheW91dFRlc3RzL3dlYmF1ZGlvL29zY2lsbGF0b3ItYmFzaWMtZXhwZWN0ZWQudHh0Cisr KyBiL0xheW91dFRlc3RzL3dlYmF1ZGlvL29zY2lsbGF0b3ItYmFzaWMtZXhwZWN0ZWQudHh0CkBA IC02LDkgKzYsMTUgQEAgUEFTUyBPc2NpbGxhdG9yIGNvcnJlY3RseSBzZXQgdG8gU0lORSB0eXBl LgogUEFTUyBPc2NpbGxhdG9yIGNvcnJlY3RseSBzZXQgdG8gU1FVQVJFIHR5cGUuCiBQQVNTIE9z Y2lsbGF0b3IgY29ycmVjdGx5IHNldCB0byBTQVdUT09USCB0eXBlLgogUEFTUyBPc2NpbGxhdG9y IGNvcnJlY3RseSBzZXQgdG8gVFJJQU5HTEUgdHlwZS4KK1BBU1MgT3NjaWxsYXRvciBjb3JyZWN0 bHkgc2V0IHRvIFNJTkUgdHlwZSB1c2luZyBsZWdhY3kgaW50ZWdlciB2YWx1ZS4KK1BBU1MgT3Nj aWxsYXRvciBjb3JyZWN0bHkgc2V0IHRvIFNRVUFSRSB0eXBlIHVzaW5nIGxlZ2FjeSBpbnRlZ2Vy IHZhbHVlLgorUEFTUyBPc2NpbGxhdG9yIGNvcnJlY3RseSBzZXQgdG8gU0FXVE9PVEggdHlwZSB1 c2luZyBsZWdhY3kgaW50ZWdlciB2YWx1ZS4KK1BBU1MgT3NjaWxsYXRvciBjb3JyZWN0bHkgc2V0 IHRvIFRSSUFOR0xFIHR5cGUgdXNpbmcgbGVnYWN5IGludGVnZXIgdmFsdWUuCiBQQVNTIE9zY2ls bGF0b3IgY29ycmVjdGx5IHNldCB0byBDVVNUT00gdHlwZSB1c2luZyBzZXRXYXZlVGFibGUuCiBQ QVNTIERpcmVjdGx5IHNldHRpbmcgb3NjaWxsYXRvciB0eXBlIHRvIENVU1RPTSBjb3JyZWN0bHkg dGhyb3dzIGV4Y2VwdGlvbi4KIFBBU1MgU2V0dGluZyBvc2NpbGxhdG9yIHRvIGludmFsaWQgdHlw ZSA1IGNvcnJlY3RseSB0aHJvd3MgZXhjZXB0aW9uLgorUEFTUyBTZXR0aW5nIC50eXBlIHRvIGls bGVnYWwgc3RyaW5nIHZhbHVlIHRocmV3IFR5cGVFcnJvci4KK1BBU1MgU2V0dGluZyAudHlwZSB0 byBpbGxlZ2FsIHR5cGUgb2YgRmxvYXQzMkFycmF5IHRocmV3IFR5cGVFcnJvci4KIFBBU1Mgc3Vj Y2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKIAogVEVTVCBDT01QTEVURQpkaWZmIC0tZ2l0IGEvTGF5 b3V0VGVzdHMvd2ViYXVkaW8vb3NjaWxsYXRvci1iYXNpYy5odG1sIGIvTGF5b3V0VGVzdHMvd2Vi YXVkaW8vb3NjaWxsYXRvci1iYXNpYy5odG1sCmluZGV4IDQ0ZWI4ZjYxNWY3YmE2ODE3YjBiN2I5 OGRhNTk5ZjkxOGJkOGJlZDIuLjAyMGFiNzMzZWYxYWQ0MTRiZTFmODQ1YTY5MzE2MGRmMmM0ODk3 N2UgMTAwNjQ0Ci0tLSBhL0xheW91dFRlc3RzL3dlYmF1ZGlvL29zY2lsbGF0b3ItYmFzaWMuaHRt bAorKysgYi9MYXlvdXRUZXN0cy93ZWJhdWRpby9vc2NpbGxhdG9yLWJhc2ljLmh0bWwKQEAgLTIw LDExICsyMCwxMSBAQCBkZXNjcmlwdGlvbigiQmFzaWMgdGVzdCBvZiBzZXR0aW5nIE9zY2lsbGF0 b3Igbm9kZSB0eXBlcy4iKTsKIHZhciBzYW1wbGVSYXRlID0gNDQxMDA7CiB2YXIgcmVuZGVyTGVu Z3RoU2Vjb25kcyA9IDAuMjU7CiAKLXZhciBvc2NUeXBlcyA9IFt7dHlwZTogMCwgbmFtZTogIlNJ TkUifSwKLSAgICAgICAgICAgICAgICB7dHlwZTogMSwgbmFtZTogIlNRVUFSRSJ9LAotICAgICAg ICAgICAgICAgIHt0eXBlOiAyLCBuYW1lOiAiU0FXVE9PVEgifSwKLSAgICAgICAgICAgICAgICB7 dHlwZTogMywgbmFtZTogIlRSSUFOR0xFIn0sCi0gICAgICAgICAgICAgICAge3R5cGU6IDQsIG5h bWU6ICJDVVNUT00ifV07Cit2YXIgb3NjVHlwZXMgPSBbe3R5cGU6ICJzaW5lIiwgaW50ZWdlclR5 cGU6IDAsIG5hbWU6ICJTSU5FIn0sCisgICAgICAgICAgICAgICAge3R5cGU6ICJzcXVhcmUiLCBp bnRlZ2VyVHlwZTogMSwgbmFtZTogIlNRVUFSRSJ9LAorICAgICAgICAgICAgICAgIHt0eXBlOiAi c2F3dG9vdGgiLCBpbnRlZ2VyVHlwZTogMiwgbmFtZTogIlNBV1RPT1RIIn0sCisgICAgICAgICAg ICAgICAge3R5cGU6ICJ0cmlhbmdsZSIsIGludGVnZXJUeXBlOiAzLCBuYW1lOiAiVFJJQU5HTEUi fSwKKyAgICAgICAgICAgICAgICB7dHlwZTogImN1c3RvbSIsIGludGVnZXJUeXBlOiA0LCBuYW1l OiAiQ1VTVE9NIn1dOwogCiBmdW5jdGlvbiBydW5UZXN0KCkgCiB7CkBAIC00MCwyNyArNDAsMzgg QEAgZnVuY3Rpb24gcnVuVGVzdCgpCiAgICAgdmFyIG9zYyA9IGNvbnRleHQuY3JlYXRlT3NjaWxs YXRvcigpOwogCiAgICAgLy8gU2V0IGVhY2ggcG9zc2libGUgb3NjaWxsYXRvciB0eXBlIChleGNl cHQgQ1VTVE9NKSBhbmQgdmVyaWZ5IHRoYXQgdGhlIHR5cGUgaXMgY29ycmVjdC4KKyAgICAvLyBI ZXJlIHdlJ3JlIHNldHRpbmcgdGhlIHR5cGUgdXNpbmcgV2ViSURMIGVudW0gdmFsdWVzIHdoaWNo IGFyZSBzdHJpbmdzLgogICAgIGZvciAodmFyIGsgPSAwOyBrIDwgb3NjVHlwZXMubGVuZ3RoIC0g MTsgKytrKSB7Ci0gICAgICAgIG9zYy50eXBlID0gb3NjVHlwZXNba10udHlwZQorICAgICAgICBv c2MudHlwZSA9IG9zY1R5cGVzW2tdLnR5cGU7CiAgICAgICAgIGlmIChvc2MudHlwZSA9PSBvc2NU eXBlc1trXS50eXBlKQogICAgICAgICAgICAgdGVzdFBhc3NlZCgiT3NjaWxsYXRvciBjb3JyZWN0 bHkgc2V0IHRvICIgKyBvc2NUeXBlc1trXS5uYW1lICsgIiB0eXBlLiIpOwogICAgICAgICBlbHNl CiAgICAgICAgICAgICB0ZXN0RmFpbGVkKCJPc2NpbGxhdG9yIHNldCB0byAiICsgb3NjVHlwZXNb a10ubmFtZSArICIgdHlwZSwgYnV0IHJldHVybnMgIiArIG9zY1R5cGVzW29zYy50eXBlXS5uYW1l ICsgIiB0eXBlLiIpOwogICAgIH0KIAorICAgIC8vIEZvciBsZWdhY3kgc3VwcG9ydCwgdmVyaWZ5 IHRoYXQgd2UgY2FuIHNldCB0aGUgdHlwZSBhdHRyaWJ1dGUgYXMgYW4gaW50ZWdlciB2YWx1ZSBh bmQKKyAgICAvLyB2ZXJpZnkgdGhhdCB0aGlzIHRyYW5zbGF0ZXMgY29ycmVjdGx5IHRvIHRoZSBX ZWJJREwgZW51bSB2YWx1ZS4KKyAgICBmb3IgKHZhciBrID0gMDsgayA8IG9zY1R5cGVzLmxlbmd0 aCAtIDE7ICsraykgeworICAgICAgICBvc2MudHlwZSA9IG9zY1R5cGVzW2tdLmludGVnZXJUeXBl OworICAgICAgICBpZiAob3NjLnR5cGUgPT0gb3NjVHlwZXNba10udHlwZSkKKyAgICAgICAgICAg IHRlc3RQYXNzZWQoIk9zY2lsbGF0b3IgY29ycmVjdGx5IHNldCB0byAiICsgb3NjVHlwZXNba10u bmFtZSArICIgdHlwZSB1c2luZyBsZWdhY3kgaW50ZWdlciB2YWx1ZS4iKTsKKyAgICAgICAgZWxz ZQorICAgICAgICAgICAgdGVzdEZhaWxlZCgiT3NjaWxsYXRvciBzZXQgdG8gIiArIG9zY1R5cGVz W2tdLm5hbWUgKyAiIHR5cGUsIGJ1dCByZXR1cm5zICIgKyBvc2NUeXBlc1tvc2MudHlwZV0ubmFt ZSArICIgdHlwZSB1c2luZyBsZWdhY3kgaW50ZWdlciB2YWx1ZS4iKTsKKyAgICB9CisKICAgICAv LyBOb3cgc2V0IGEgY3VzdG9tIG9zY2lsbGF0b3IKICAgICB2YXIgY29lZmZBID0gbmV3IEZsb2F0 MzJBcnJheShbMCwgMSwgMC41XSk7CiAgICAgdmFyIGNvZWZmQiA9IG5ldyBGbG9hdDMyQXJyYXko WzAsIDAsIDBdKTsgICAgICAgIAogICAgIHZhciB3YXZldGFibGUgPSBjb250ZXh0LmNyZWF0ZVdh dmVUYWJsZShjb2VmZkEsIGNvZWZmQik7CiAgICAgb3NjLnNldFdhdmVUYWJsZSh3YXZldGFibGUp OwotICAgIGlmIChvc2MudHlwZSA9PSBvc2MuQ1VTVE9NKQorICAgIGlmIChvc2MudHlwZSA9PSAi Y3VzdG9tIikKICAgICAgICAgdGVzdFBhc3NlZCgiT3NjaWxsYXRvciBjb3JyZWN0bHkgc2V0IHRv IENVU1RPTSB0eXBlIHVzaW5nIHNldFdhdmVUYWJsZS4iKTsKICAgICBlbHNlCiAgICAgICAgIHRl c3RGYWlsZWQoIk9zY2lsbGF0b3Igc2V0IHRvIENVU1RPTSB0eXBlLCBidXQgcmV0dXJucyAiICsg b3NjVHlwZXNbb3NjLnR5cGVdLm5hbWUgKyAiIHR5cGUuIik7CiAKICAgICAvLyBUcnkgc2V0dGlu ZyBzb21lIGludmFsaWQgdHlwZXMKICAgICB0cnkgewotICAgICAgICBvc2MudHlwZSA9IG9zYy5D VVNUT007CisgICAgICAgIG9zYy50eXBlID0gImN1c3RvbSI7CiAgICAgICAgIHRlc3RGYWlsZWQo IkRpcmVjdGx5IHNldHRpbmcgb3NjaWxsYXRvciB0eXBlIHRvIENVU1RPTSBkaWQgbm90IHRocm93 IGV4Y2VwdGlvbi4iKTsKICAgICB9IGNhdGNoIChlKSB7CiAgICAgICAgIHRlc3RQYXNzZWQoIkRp cmVjdGx5IHNldHRpbmcgb3NjaWxsYXRvciB0eXBlIHRvIENVU1RPTSBjb3JyZWN0bHkgdGhyb3dz IGV4Y2VwdGlvbi4iKTsKQEAgLTc0LDYgKzg1LDEwIEBAIGZ1bmN0aW9uIHJ1blRlc3QoKQogICAg ICAgICB0ZXN0UGFzc2VkKCJTZXR0aW5nIG9zY2lsbGF0b3IgdG8gaW52YWxpZCB0eXBlICIgKyBv c2NUeXBlICsgIiBjb3JyZWN0bHkgdGhyb3dzIGV4Y2VwdGlvbi4iKTsKICAgICB9CiAKKyAgICAv LyBDaGVjayBzcGVjaWZpY2FsbHkgdGhhdCB3ZSB0aHJvdyBhIFR5cGVFcnJvci4KKyAgICBzaG91 bGRUaHJvd1R5cGVFcnJvcihmdW5jdGlvbigpIHsgb3NjLnR5cGUgPSAieHl6MTIzNDlqZmtzZCI7 IH0sICJTZXR0aW5nIC50eXBlIHRvIGlsbGVnYWwgc3RyaW5nIHZhbHVlIik7CisgICAgc2hvdWxk VGhyb3dUeXBlRXJyb3IoZnVuY3Rpb24oKSB7IG9zYy50eXBlID0gbmV3IEZsb2F0MzJBcnJheSgx KTsgfSwgIlNldHRpbmcgLnR5cGUgdG8gaWxsZWdhbCB0eXBlIG9mIEZsb2F0MzJBcnJheSIpOwor CiAgICAgZmluaXNoSlNUZXN0KCk7CiB9CiAKZGlmZiAtLWdpdCBhL0xheW91dFRlc3RzL3dlYmF1 ZGlvL3Jlc291cmNlcy9hdWRpby10ZXN0aW5nLmpzIGIvTGF5b3V0VGVzdHMvd2ViYXVkaW8vcmVz b3VyY2VzL2F1ZGlvLXRlc3RpbmcuanMKaW5kZXggNTM3MTMwYjM5ZDIxNmQ4NmIwYTM1OTgyZjIz ZWYzMGIwOTllMjFiZS4uMmVhOTdhZTQ4YjcwYTIxZjg5NzY4YjQzNDhkYTNjY2FjNjMzZWQzMyAx MDA2NDQKLS0tIGEvTGF5b3V0VGVzdHMvd2ViYXVkaW8vcmVzb3VyY2VzL2F1ZGlvLXRlc3Rpbmcu anMKKysrIGIvTGF5b3V0VGVzdHMvd2ViYXVkaW8vcmVzb3VyY2VzL2F1ZGlvLXRlc3RpbmcuanMK QEAgLTE3NCwzICsxNzQsMTkgQEAgZnVuY3Rpb24gZ3JhaW5MZW5ndGhJblNhbXBsZUZyYW1lcyhn cmFpbk9mZnNldCwgZHVyYXRpb24sIHNhbXBsZVJhdGUpIHsKIGZ1bmN0aW9uIGlzVmFsaWROdW1i ZXIoeCkgewogICAgIHJldHVybiAhaXNOYU4oeCkgJiYgKHggIT0gSW5maW5pdHkpICYmICh4ICE9 IC1JbmZpbml0eSk7CiB9CisKK2Z1bmN0aW9uIHNob3VsZFRocm93VHlwZUVycm9yKGZ1bmMsIHRl eHQpIHsKKyAgICB2YXIgb2sgPSBmYWxzZTsKKyAgICB0cnkgeworICAgICAgICBmdW5jKCk7Cisg ICAgfSBjYXRjaCAoZSkgeworICAgICAgICBpZiAoZSBpbnN0YW5jZW9mIFR5cGVFcnJvcikgewor ICAgICAgICAgICAgb2sgPSB0cnVlOworICAgICAgICB9CisgICAgfQorICAgIGlmIChvaykgewor ICAgICAgICB0ZXN0UGFzc2VkKHRleHQgKyAiIHRocmV3IFR5cGVFcnJvci4iKTsKKyAgICB9IGVs c2UgeworICAgICAgICB0ZXN0RmFpbGVkKHRleHQgKyAiIHNob3VsZCB0aHJvdyBUeXBlRXJyb3Iu Iik7CisgICAgfQorfQo=