23499 2009-01-23 04:02:22 -0800 Add WML specific logic for WML <input> 2009-02-02 11:29:43 -0800 1 1 1 Unclassified WebKit XML 528+ (Nightly build) PC Linux RESOLVED FIXED P2 Normal --- 20393 0 yichao.yin webkit-unassigned staikos yichao.yin zimmermann oldest_to_newest 106734 0 yichao.yin 2009-01-23 04:02:22 -0800 The upcoming patch implements the WML specific attributes of WMLInputElement, such as format, emptyok. 106735 1 26967 yichao.yin 2009-01-23 04:04:17 -0800 Created attachment 26967 initial patch 106756 2 26967 zimmermann 2009-01-23 08:33:01 -0800 Comment on attachment 26967 initial patch Hey Yichao, nice work - especially the new testcase :-) Though I think it will need to handle a lot more 'corner cases' especially in the input mask validation. I'll show my issues using the code below: I don't have time for a full review, only talking about validateInputMask() now: > +String WMLInputElement::validateInputMask(const String& inputMask) > +{ > + bool isValid = true; > + bool hasWildcard = false; > + unsigned escapeCharCnts = 0; > + unsigned maskLen = inputMask.length(); > + UChar formatCode; Naming, why not use "maskLength" and "escapeCharCount" :-) > + > + for (unsigned i = 0; i < maskLen; ++i) { > + formatCode = inputMask[i]; > + if (s_formatCodes.find(formatCode) == -1) { > + if (formatCode == '*' || (WTF::isASCIIDigit(formatCode) && formatCode != '0')) { > + // validate codes which ends with '*f' or 'nf' > + formatCode = inputMask[++i]; What happens if we're at i == maskLen - 1, then inputMask[maskLen] would crash, no? > + if ((i + 1 != maskLen) || s_formatCodes.find(formatCode) == -1) { > + isValid = false; > + break; > + } Okay this takes care of only allowing the "*f' or "nf" to appear at the end of the string, fine. The WML spec says these format codes are only allowed to appear _once_ though. So maybe you could add the following, before the last 'if' above: if (hasWildcard) { isValid = false; break; } > + hasWildcard = true; > + } else if (formatCode == '\\') { > + //skip over the next mask character > + i++; > + escapeCharCnts++; > + } else { > + isValid = false; > + break; > + } > + } > + } > + > + // calculate the number of characters allowed to be entered by input mask > + if (isValid) { Use early exit here: if (!isValid) return String(); > + m_numOfCharsAllowedByMask = maskLen; > + > + if (escapeCharCnts) > + m_numOfCharsAllowedByMask -= escapeCharCnts; > + > + if (hasWildcard) { > + formatCode = inputMask[maskLen - 2]; > + if (formatCode == '*') > + m_numOfCharsAllowedByMask = m_data.maxLength(); > + else { > + unsigned leftLen = String(&formatCode).toInt(); > + m_numOfCharsAllowedByMask = leftLen + m_numOfCharsAllowedByMask - 2; > + } > + } > + > + return inputMask; > + } > + > + return String(); > +} Okay, this method is mostly correct, but all of the corner cases need to be tested in your wml/input-formal.html test: - 'nf' / '*f' statements in the beginning/middle of the input mask (should fail) - 'nf' statements, with n>9, should fail - invalid mask characters 'YyKkQq', should be tested in all variations (combined with valid mask chars, as well) - 'escape characters' should be tested I hope that's it for now :-) I'll continue the review tonight. 106762 3 26967 zimmermann 2009-01-23 09:02:38 -0800 Comment on attachment 26967 initial patch Review, part 2: > @@ -215,6 +235,9 @@ void WMLInputElement::attach() > + // Here we initialize the WML <input> element > + init(); I'm not sure if it's desired to call init() from attach(). How about calling it from 'finishedParsingChildren()' ? The drawback using attach() would be that I could force the renderer to be attached, detach and re-attached. This way we'd store the variable state twice, that's not what we want I fear. > + else if (renderer() && !isConformedToInputMask(textEvent->data()[0], static_cast<RenderTextControl*>(renderer())->text().length() + 1)) > + // If the inputed char doesn't conform to the input mask, stop handling > + return; > + } Why length() + 1 here? > +void WMLInputElement::init() > +{ > + String nameVar = name(); > + String varValue; > + WMLPageState* pageSate = wmlPageStateForDocument(document()); > + ASSERT(pageSate); > + if (!nameVar.isEmpty()) > + varValue = pageSate->getVariable(nameVar); > + > + if (varValue.isEmpty() || !isConformedToInputMask(varValue)) { > + String val = value(); > + if (isConformedToInputMask(val)) > + varValue = val; > + else > + varValue = ""; > + > + pageSate->storeVariable(nameVar, varValue); > + } > + setValue(varValue); > + > + if (getAttribute(WMLNames::emptyokAttr).isEmpty()) { You can use if (!hasAttribute(WMLNames::emptyokAttr)) here. > + if (m_formatMask.isEmpty() || > + // check if the format codes is a "*f" code > + (m_formatMask.length() == 2 && m_formatMask[0] == '*' && s_formatCodes.find(m_formatMask[1]) != -1)) > + m_isEmptyOk = true; > + } This only takes care of the 'f' format code, what about the others? > +bool WMLInputElement::isConformedToInputMask(const String& inputChars) > +{ > + bool ok = true; > + for (unsigned i = 0; i < inputChars.length(); ++i) { > + ok = isConformedToInputMask(inputChars[i], i + 1, false); > + if (!ok) > + break; > + } You can rewrite as follows, to save a line: if (ok = isConformedToInputMask(inputChars[i], i + 1, false)) continue; > +bool WMLInputElement::isConformedToInputMask(UChar inChar, unsigned inputCharCounts, bool isInputedByUsr) s/isInputedByUsr/isUserInput/ s/inputCharCounts/inputCharCount/ > +{ > + bool ok = true; > + if (m_formatMask.isEmpty()) > + return ok; Just 'return true' here, and save the 'ok' variable declaration. Move it below 'UChar mask = ..' where it's atually needed. > + unsigned idxOfMask = 0; s/idxOfMask/maskIndex/ > + if (isInputedByUsr) { > + int cursorPos = 0; > + if (renderer()) > + cursorPos = static_cast<RenderTextControl*>(renderer())->selectionStart(); > + else > + cursorPos = m_data.cachedSelectionStart(); > + > + idxOfMask = cursorPosToIdxOfMask(cursorPos); > + } else > + idxOfMask = cursorPosToIdxOfMask(inputCharCounts - 1); s/cursorPosToIdxOfMask/cursorPositionToMaskIndex/ > + > + UChar mask = m_formatMask[idxOfMask]; You should be able to use switch (mask) here - should read more cleanly: > + // match the inputed character with input mask > + if (mask == 'A') > + ok = !WTF::isASCIIDigit(inChar) && !WTF::isASCIILower(inChar) && WTF::isASCIIPrintable(inChar); > + else if (mask == 'a') > + ok = !WTF::isASCIIDigit(inChar) && !WTF::isASCIIUpper(inChar) && WTF::isASCIIPrintable(inChar); > + else if (mask == 'N') > + ok = WTF::isASCIIDigit(inChar); > + else if (mask == 'n') > + ok = !WTF::isASCIIAlpha(inChar) && WTF::isASCIIPrintable(inChar); > + else if (mask == 'X') > + ok = !WTF::isASCIILower(inChar) && WTF::isASCIIPrintable(inChar); > + else if (mask == 'x') > + ok = !WTF::isASCIIUpper(inChar) && WTF::isASCIIPrintable(inChar); > + else if (mask == 'M') > + ok = WTF::isASCIIPrintable(inChar); > + else if (mask == 'm') > + ok = WTF::isASCIIPrintable(inChar); > + else > + ok = (mask == inChar); > + > + return ok; > +} > + > +unsigned WMLInputElement::cursorPosToIdxOfMask(unsigned cursorPos) > +{ > + UChar mask; > + int idx = -1; > + do { > + mask = m_formatMask[++idx]; > + if (mask == '\\') > + idx++; > + else if (mask == '*' || (WTF::isASCIIDigit(mask) && mask != '0')) { > + idx = m_formatMask.length() - 1; > + break; > + } > + } while (cursorPos--); > + > + return idx; > +} s/idx++/++idx/ s/idx/index/ > + > } > > #endif > Index: WebCore/wml/WMLInputElement.h > =================================================================== > --- WebCore/wml/WMLInputElement.h (revision 40084) > +++ WebCore/wml/WMLInputElement.h (working copy) > @@ -89,10 +89,21 @@ public: > virtual void willMoveToNewOwnerDocument(); > virtual void didMoveToNewOwnerDocument(); > > + bool isConformedToInputMask(const String&); > + bool isConformedToInputMask(UChar, unsigned, bool isInputedByUsr = true); > + > + static const String s_formatCodes; I'm not sure wheter it's wise to declare a static const String. What you could do is add a private function: "static const AtomicString& formatCodes();" const AtomicString& WMLInputElement::formatCodes() { DEFINE_STATIC_LOCAL(AtomicString, codes, ("AaNnXxMm")); return codes; } Okay, really need to leave now :-) Have fun! 106809 4 zimmermann 2009-01-23 15:31:35 -0800 Fix bug dependencies, WML master bug 20393 should depend on this, not the other way round. 106843 5 yichao.yin 2009-01-23 18:54:54 -0800 (In reply to comment #2) > I don't have time for a full review, only talking about validateInputMask() > now: > > +String WMLInputElement::validateInputMask(const String& inputMask) > > +{ > > + bool isValid = true; > > + bool hasWildcard = false; > > + unsigned escapeCharCnts = 0; > > + unsigned maskLen = inputMask.length(); > > + UChar formatCode; > Naming, why not use "maskLength" and "escapeCharCount" :-) Just for saving several bytes :). Okay, I will name it more readable > > + > > + for (unsigned i = 0; i < maskLen; ++i) { > > + formatCode = inputMask[i]; > > + if (s_formatCodes.find(formatCode) == -1) { > > + if (formatCode == '*' || (WTF::isASCIIDigit(formatCode) && formatCode != '0')) { > > + // validate codes which ends with '*f' or 'nf' > > + formatCode = inputMask[++i]; > > + if ((i + 1 != maskLen) || s_formatCodes.find(formatCode) == -1) { > > + isValid = false; > > + break; > > + } > Okay this takes care of only allowing the "*f' or "nf" to appear at the end of > the string, fine. > The WML spec says these format codes are only allowed to appear _once_ though. > So maybe you could add the following, before the last 'if' above: > if (hasWildcard) { isValid = false; break; } No need, "if (i + 1 != MaskLen)" is used to check this since we search the "*" from left to right. If there are more than one "*f" or "nf", the if statement will be true and break the for loop with isValid = false. > > + hasWildcard = true; > > + } else if (formatCode == '\\') { > > + //skip over the next mask character > > + i++; > > + escapeCharCnts++; > > + } else { > > + isValid = false; > > + break; > > + } > > + } > > + } > > + > > + // calculate the number of characters allowed to be entered by input mask > > + if (isValid) { > Use early exit here: if (!isValid) return String(); Yes, that's better, will fix it. > > + m_numOfCharsAllowedByMask = maskLen; > > + > > + if (escapeCharCnts) > > + m_numOfCharsAllowedByMask -= escapeCharCnts; > > + > > + if (hasWildcard) { > > + formatCode = inputMask[maskLen - 2]; > > + if (formatCode == '*') > > + m_numOfCharsAllowedByMask = m_data.maxLength(); > > + else { > > + unsigned leftLen = String(&formatCode).toInt(); > > + m_numOfCharsAllowedByMask = leftLen + m_numOfCharsAllowedByMask - 2; > > + } > > + } > > + > > + return inputMask; > > + } > > + > > + return String(); > > +} > Okay, this method is mostly correct, but all of the corner cases need to be > tested in your wml/input-formal.html test: > - 'nf' / '*f' statements in the beginning/middle of the input mask (should > fail) > - 'nf' statements, with n>9, should fail > - invalid mask characters 'YyKkQq', should be tested in all variations > (combined with valid mask chars, as well) > - 'escape characters' should be tested You are right, I should add more test cases for it. Thanks a lot for your good comments. I will update the patch following them ASAP. 106845 6 yichao.yin 2009-01-23 19:34:59 -0800 (In reply to comment #3) > (From update of attachment 26967 [review]) > Review, part 2: > > @@ -215,6 +235,9 @@ void WMLInputElement::attach() > > + // Here we initialize the WML <input> element > > + init(); > I'm not sure if it's desired to call init() from attach(). > How about calling it from 'finishedParsingChildren()' ? > The drawback using attach() would be that I could force the renderer to be > attached, detach and re-attached. > This way we'd store the variable state twice, that's not what we want I fear. You are right, finishParsingChildren() is a better place to do this. > > + else if (renderer() && !isConformedToInputMask(textEvent->data()[0], static_cast<RenderTextControl*>(renderer())->text().length() + 1)) > > + // If the inputed char doesn't conform to the input mask, stop handling > > + return; > > + } > Why length() + 1 here? the second parameter of isConformedToInputMask(UChar inChar, unsigned inputCharCount, bool isInputedByUsr) is used to specify the character number user has inputed, including current one, which has not been stored in RenderTextControl::text(). > > + > > + if (getAttribute(WMLNames::emptyokAttr).isEmpty()) { > You can use if (!hasAttribute(WMLNames::emptyokAttr)) here. Good, better solution. will fix. > > + if (m_formatMask.isEmpty() || > > + // check if the format codes is a "*f" code > > + (m_formatMask.length() == 2 && m_formatMask[0] == '*' && s_formatCodes.find(m_formatMask[1]) != -1)) > > + m_isEmptyOk = true; > > + } > This only takes care of the 'f' format code, what about the others? That piece of code is to check the input mask with value of "*f" only. so we need to check the length and whole string. > > +bool WMLInputElement::isConformedToInputMask(const String& inputChars) > > +{ > > + bool ok = true; > > + for (unsigned i = 0; i < inputChars.length(); ++i) { > > + ok = isConformedToInputMask(inputChars[i], i + 1, false); > > + if (!ok) > > + break; > > + } > You can rewrite as follows, to save a line: > if (ok = isConformedToInputMask(inputChars[i], i + 1, false)) > continue; Exactly, Thanks. :) > > +bool WMLInputElement::isConformedToInputMask(UChar inChar, unsigned inputCharCounts, bool isInputedByUsr) > s/isInputedByUsr/isUserInput/ > s/inputCharCounts/inputCharCount/ > > +{ > > + bool ok = true; > > + if (m_formatMask.isEmpty()) > > + return ok; > Just 'return true' here, and save the 'ok' variable declaration. Move it below > 'UChar mask = ..' where it's atually needed. Good, will fix. > > + unsigned idxOfMask = 0; > s/idxOfMask/maskIndex/ > > + if (isInputedByUsr) { > > + int cursorPos = 0; > > + if (renderer()) > > + cursorPos = static_cast<RenderTextControl*>(renderer())->selectionStart(); > > + else > > + cursorPos = m_data.cachedSelectionStart(); > > + > > + idxOfMask = cursorPosToIdxOfMask(cursorPos); > > + } else > > + idxOfMask = cursorPosToIdxOfMask(inputCharCounts - 1); > s/cursorPosToIdxOfMask/cursorPositionToMaskIndex/ > > + > > + UChar mask = m_formatMask[idxOfMask]; > You should be able to use switch (mask) here - should read more cleanly: Sounds better. Agreed. > > + // match the inputed character with input mask > > + if (mask == 'A') > > + ok = !WTF::isASCIIDigit(inChar) && !WTF::isASCIILower(inChar) && WTF::isASCIIPrintable(inChar); > > + else if (mask == 'a') > > + ok = !WTF::isASCIIDigit(inChar) && !WTF::isASCIIUpper(inChar) && WTF::isASCIIPrintable(inChar); > > + else if (mask == 'N') > > + ok = WTF::isASCIIDigit(inChar); > > + else if (mask == 'n') > > + ok = !WTF::isASCIIAlpha(inChar) && WTF::isASCIIPrintable(inChar); > > + else if (mask == 'X') > > + ok = !WTF::isASCIILower(inChar) && WTF::isASCIIPrintable(inChar); > > + else if (mask == 'x') > > + ok = !WTF::isASCIIUpper(inChar) && WTF::isASCIIPrintable(inChar); > > + else if (mask == 'M') > > + ok = WTF::isASCIIPrintable(inChar); > > + else if (mask == 'm') > > + ok = WTF::isASCIIPrintable(inChar); > > + else > > + ok = (mask == inChar); > > + > > + return ok; > > +} > > + > > +unsigned WMLInputElement::cursorPosToIdxOfMask(unsigned cursorPos) > > +{ > > + UChar mask; > > + int idx = -1; > > + do { > > + mask = m_formatMask[++idx]; > > + if (mask == '\\') > > + idx++; > > + else if (mask == '*' || (WTF::isASCIIDigit(mask) && mask != '0')) { > > + idx = m_formatMask.length() - 1; > > + break; > > + } > > + } while (cursorPos--); > > + > > + return idx; > > +} > s/idx++/++idx/ > s/idx/index/ Will fix. > > } > > > > #endif > > Index: WebCore/wml/WMLInputElement.h > > =================================================================== > > --- WebCore/wml/WMLInputElement.h (revision 40084) > > +++ WebCore/wml/WMLInputElement.h (working copy) > > @@ -89,10 +89,21 @@ public: > > virtual void willMoveToNewOwnerDocument(); > > virtual void didMoveToNewOwnerDocument(); > > > > + bool isConformedToInputMask(const String&); > > + bool isConformedToInputMask(UChar, unsigned, bool isInputedByUsr = true); > > + > > + static const String s_formatCodes; > I'm not sure wheter it's wise to declare a static const String. > What you could do is add a private function: "static const AtomicString& > formatCodes();" > const AtomicString& WMLInputElement::formatCodes() > { > DEFINE_STATIC_LOCAL(AtomicString, codes, ("AaNnXxMm")); > return codes; > } Good idea! It should be more like Webkit-style code. Thanks a lot to let me learn more. 106846 7 zimmermann 2009-01-23 20:11:45 -0800 (In reply to comment #6) > > > + if (m_formatMask.isEmpty() || > > > + // check if the format codes is a "*f" code > > > + (m_formatMask.length() == 2 && m_formatMask[0] == '*' && s_formatCodes.find(m_formatMask[1]) != -1)) > > > + m_isEmptyOk = true; > > > + } > > This only takes care of the 'f' format code, what about the others? > > That piece of code is to check the input mask with value of "*f" only. so we > need to check the length and whole string. Yeah, it's just fine - but emptyok has to be handled as well for *A, *A, etc.. So I think we need to iterate over all possible combinations here, no? > Good idea! It should be more like Webkit-style code. > > Thanks a lot to let me learn more. You're welcome! 106854 8 26994 yichao.yin 2009-01-24 01:17:49 -0800 Created attachment 26994 updated patch updated patch which fixes some issues Niko points out. Addtional explain for Niko's comments > > + static const String s_formatCodes; > I'm not sure wheter it's wise to declare a static const String. > What you could do is add a private function: "static const AtomicString& > formatCodes();" > const AtomicString& WMLInputElement::formatCodes() > { > DEFINE_STATIC_LOCAL(AtomicString, codes, ("AaNnXxMm")); > return codes; > } Since formatCodes() is private and independent, I think it's better add the function "static const AtomicString& formatCodes() const" in the source file instead of defining it as a member of HTMLInputElement. > > @@ -215,6 +235,9 @@ void WMLInputElement::attach() > > + // Here we initialize the WML <input> element > > + init(); > I'm not sure if it's desired to call init() from attach(). > How about calling it from 'finishedParsingChildren()' ? > The drawback using attach() would be that I could force the renderer to be > attached, detach and re-attached. > This way we'd store the variable state twice, that's not what we want I fear. From functionality, placing it in finishedParsingChildren() is ok under most situations. but the run-webkit-tests script can't get the expected rendering result similar with that QtLauncher gets. As a result some cases will fail. But if I place it in attach(), both of them works well. It seems the layout test frameworks for WML needs calling init() multiple times to make sure the rendering tree is right. exactly, ensure the vaiable value is correct. Anyway I still keep it in attach() to make everthing is ok for now. 106855 9 yichao.yin 2009-01-24 01:28:47 -0800 (In reply to comment #7) > (In reply to comment #6) > > > > + if (m_formatMask.isEmpty() || > > > > + // check if the format codes is a "*f" code > > > > + (m_formatMask.length() == 2 && m_formatMask[0] == '*' && s_formatCodes.find(m_formatMask[1]) != -1)) > > > > + m_isEmptyOk = true; > > > > + } > > > This only takes care of the 'f' format code, what about the others? > > > > That piece of code is to check the input mask with value of "*f" only. so we > > need to check the length and whole string. > Yeah, it's just fine - but emptyok has to be handled as well for *A, *A, etc.. > So I think we need to iterate over all possible combinations here, no? Seems my comment in the code is not exactly, Here 'f' stands for any one code of the format codes "AaNnXxMm". that is, it already contains all possible comination that you meant. :) 107967 10 zimmermann 2009-02-02 08:06:51 -0800 (In reply to comment #9) > > Yeah, it's just fine - but emptyok has to be handled as well for *A, *A, etc.. > > So I think we need to iterate over all possible combinations here, no? > > Seems my comment in the code is not exactly, Here 'f' stands for any one code > of the format codes "AaNnXxMm". that is, it already contains all possible > comination that you meant. :) Yes, I misread, it's fine :-) 107968 11 26994 zimmermann 2009-02-02 08:07:46 -0800 Comment on attachment 26994 updated patch Thanks for CC'in me George, I forgot to r+ last week already! 107989 12 staikos 2009-02-02 11:29:43 -0800 Committed in r40482. 26967 2009-01-23 04:04:17 -0800 2009-01-24 01:17:49 -0800 initial patch wmlinputsupplement.patch text/plain 15814 yichao.yin SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0MDE1NCkKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjEgQEAKKzIwMDktMDEtMjMgIFlpY2hhbyBZaW4gPHlpY2hhby55aW5AdG9yY2ht b2JpbGUuY29tLmNuPgorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisg ICAgICAgIFRlc3Q6IHdtbC9pbnB1dC1mb3JtYXQuaHRtbAorCisgICAgICAgICogd21sL1dNTElu cHV0RWxlbWVudC5jcHA6CisgICAgICAgIChXZWJDb3JlOjpXTUxJbnB1dEVsZW1lbnQ6OldNTElu cHV0RWxlbWVudCk6CisgICAgICAgIChXZWJDb3JlOjpXTUxJbnB1dEVsZW1lbnQ6OmRpc3BhdGNo Qmx1ckV2ZW50KToKKyAgICAgICAgKFdlYkNvcmU6OldNTElucHV0RWxlbWVudDo6cGFyc2VNYXBw ZWRBdHRyaWJ1dGUpOgorICAgICAgICAoV2ViQ29yZTo6V01MSW5wdXRFbGVtZW50OjphdHRhY2gp OgorICAgICAgICAoV2ViQ29yZTo6V01MSW5wdXRFbGVtZW50OjpkZWZhdWx0RXZlbnRIYW5kbGVy KToKKyAgICAgICAgKFdlYkNvcmU6OldNTElucHV0RWxlbWVudDo6aW5pdCk6CisgICAgICAgIChX ZWJDb3JlOjpXTUxJbnB1dEVsZW1lbnQ6OnZhbGlkYXRlSW5wdXRNYXNrKToKKyAgICAgICAgKFdl YkNvcmU6OldNTElucHV0RWxlbWVudDo6aXNDb25mb3JtZWRUb0lucHV0TWFzayk6CisgICAgICAg IChXZWJDb3JlOjpXTUxJbnB1dEVsZW1lbnQ6OmN1cnNvclBvc1RvSWR4T2ZNYXNrKToKKyAgICAg ICAgKiB3bWwvV01MSW5wdXRFbGVtZW50Lmg6CisKIDIwMDktMDEtMjIgIERhdmlkIEh5YXR0ICA8 aHlhdHRAYXBwbGUuY29tPgogCiAgICAgICAgIE1vdmUgdGhlIGJvcmRlciBhbmQgcGFkZGluZyBt ZXRob2RzIGZyb20gUmVuZGVyT2JqZWN0IHRvIFJlbmRlckJveC4KSW5kZXg6IFdlYkNvcmUvd21s L1dNTElucHV0RWxlbWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS93bWwvV01MSW5wdXRF bGVtZW50LmNwcAkocmV2aXNpb24gNDAwODQpCisrKyBXZWJDb3JlL3dtbC9XTUxJbnB1dEVsZW1l bnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yMyw3ICsyMyw2IEBACiAjaWYgRU5BQkxFKFdNTCkK ICNpbmNsdWRlICJXTUxJbnB1dEVsZW1lbnQuaCIKIAotI2luY2x1ZGUgIkRvY3VtZW50LmgiCiAj aW5jbHVkZSAiRXZlbnROYW1lcy5oIgogI2luY2x1ZGUgIkZvcm1EYXRhTGlzdC5oIgogI2luY2x1 ZGUgIkZyYW1lLmgiCkBAIC0zMSwxNCArMzAsMjEgQEAKICNpbmNsdWRlICJLZXlib2FyZEV2ZW50 LmgiCiAjaW5jbHVkZSAiUmVuZGVyVGV4dENvbnRyb2xTaW5nbGVMaW5lLmgiCiAjaW5jbHVkZSAi VGV4dEV2ZW50LmgiCisjaW5jbHVkZSAiV01MRG9jdW1lbnQuaCIKKyNpbmNsdWRlICJXTUxOYW1l cy5oIgorI2luY2x1ZGUgIldNTFBhZ2VTdGF0ZS5oIgogCiBuYW1lc3BhY2UgV2ViQ29yZSB7CiAK K2NvbnN0IFN0cmluZyBXTUxJbnB1dEVsZW1lbnQ6OnNfZm9ybWF0Q29kZXMgPSAiQWFOblh4TW0i OworCiBXTUxJbnB1dEVsZW1lbnQ6OldNTElucHV0RWxlbWVudChjb25zdCBRdWFsaWZpZWROYW1l JiB0YWdOYW1lLCBEb2N1bWVudCogZG9jKQogICAgIDogV01MRWxlbWVudCh0YWdOYW1lLCBkb2Mp CiAgICAgLCBtX2RhdGEodGhpcywgdGhpcykKICAgICAsIG1faXNQYXNzd29yZEZpZWxkKGZhbHNl KQogICAgICwgbV92YWx1ZU1hdGNoZXNSZW5kZXJlcihmYWxzZSkKKyAgICAsIG1faXNFbXB0eU9r KGZhbHNlKQorICAgICwgbV9udW1PZkNoYXJzQWxsb3dlZEJ5TWFzaygwKQogewogfQogCkBAIC04 Miw2ICs4OCwxOCBAQCB2b2lkIFdNTElucHV0RWxlbWVudDo6ZGlzcGF0Y2hGb2N1c0V2ZW50CiAK IHZvaWQgV01MSW5wdXRFbGVtZW50OjpkaXNwYXRjaEJsdXJFdmVudCgpCiB7CisgICAgLy8gRmly c3RseSBjaGVjayBpZiBpdCBpcyBhbGxvd2VkIHRvIGxlYXZlIHRoaXMgaW5wdXQgZmllbGQKKyAg ICBTdHJpbmcgdmFsID0gdmFsdWUoKTsKKyAgICBpZiAoKCFtX2lzRW1wdHlPayAmJiB2YWwuaXNF bXB0eSgpKSB8fCAhaXNDb25mb3JtZWRUb0lucHV0TWFzayh2YWwpKSB7CisgICAgICAgIHVwZGF0 ZUZvY3VzQXBwZWFyYW5jZSh0cnVlKTsKKyAgICAgICAgcmV0dXJuOworICAgIH0KKworICAgIC8v IHVwZGF0ZSB0aGUgbmFtZSB2YXJpYWJsZSBvZiBXTUwgaW5wdXQgZWxtZW5ldAorICAgIFN0cmlu ZyBuYW1lVmFyID0gbmFtZSgpOworICAgIGlmICghbmFtZVZhci5pc0VtcHR5KCkpCisgICAgICAg IHdtbFBhZ2VTdGF0ZUZvckRvY3VtZW50KGRvY3VtZW50KCkpLT5zdG9yZVZhcmlhYmxlKG5hbWVW YXIsIHZhbCk7IAorCiAgICAgSW5wdXRFbGVtZW50OjpkaXNwYXRjaEJsdXJFdmVudChtX2RhdGEs IGRvY3VtZW50KCkpOwogICAgIFdNTEVsZW1lbnQ6OmRpc3BhdGNoQmx1ckV2ZW50KCk7CiB9CkBA IC0xODMsMTIgKzIwMSwxNCBAQCB2b2lkIFdNTElucHV0RWxlbWVudDo6cGFyc2VNYXBwZWRBdHRy aWJ1CiAgICAgICAgIElucHV0RWxlbWVudDo6cGFyc2VNYXhMZW5ndGhBdHRyaWJ1dGUobV9kYXRh LCBhdHRyKTsKICAgICBlbHNlIGlmIChhdHRyLT5uYW1lKCkgPT0gSFRNTE5hbWVzOjpzaXplQXR0 cikKICAgICAgICAgSW5wdXRFbGVtZW50OjpwYXJzZVNpemVBdHRyaWJ1dGUobV9kYXRhLCBhdHRy KTsKKyAgICBlbHNlIGlmIChhdHRyLT5uYW1lKCkgPT0gV01MTmFtZXM6OmZvcm1hdEF0dHIpCisg ICAgICAgIG1fZm9ybWF0TWFzayA9IHZhbGlkYXRlSW5wdXRNYXNrKHBhcnNlVmFsdWVGb3JiaWRk aW5nVmFyaWFibGVSZWZlcmVuY2VzKGF0dHItPnZhbHVlKCkpKTsKKyAgICBlbHNlIGlmIChhdHRy LT5uYW1lKCkgPT0gV01MTmFtZXM6OmVtcHR5b2tBdHRyKQorICAgICAgICBtX2lzRW1wdHlPayA9 IChhdHRyLT52YWx1ZSgpID09ICJ0cnVlIik7CiAgICAgZWxzZQogICAgICAgICBXTUxFbGVtZW50 OjpwYXJzZU1hcHBlZEF0dHJpYnV0ZShhdHRyKTsKIAogICAgIC8vIEZJWE1FOiBIYW5kbGUgJ2Fj Y2Vzc2tleScgYXR0cmlidXRlCi0gICAgLy8gRklYTUU6IEhhbmRsZSAnZm9ybWF0JyBhdHRyaWJ1 dGUKLSAgICAvLyBGSVhNRTogSGFuZGxlICdlbXB0eW9rJyBhdHRyaWJ1dGUKICAgICAvLyBGSVhN RTogSGFuZGxlICd0YWJpbmRleCcgYXR0cmlidXRlCiAgICAgLy8gRklYTUU6IEhhbmRsZSAndGl0 bGUnIGF0dHJpYnV0ZQogfQpAQCAtMjE1LDYgKzIzNSw5IEBAIHZvaWQgV01MSW5wdXRFbGVtZW50 OjphdHRhY2goKQogICAgIC8vIG9uIHRoZSByZW5kZXJlci4KICAgICBpZiAocmVuZGVyZXIoKSkK ICAgICAgICAgcmVuZGVyZXIoKS0+dXBkYXRlRnJvbUVsZW1lbnQoKTsKKworICAgIC8vIEhlcmUg d2UgaW5pdGlhbGl6ZSB0aGUgV01MIDxpbnB1dD4gZWxlbWVudAorICAgIGluaXQoKTsKIH0gIAog CiB2b2lkIFdNTElucHV0RWxlbWVudDo6ZGV0YWNoKCkKQEAgLTI0MSw4ICsyNjQsMTQgQEAgdm9p ZCBXTUxJbnB1dEVsZW1lbnQ6OmRlZmF1bHRFdmVudEhhbmRsZQogewogICAgIGJvb2wgY2xpY2tE ZWZhdWx0Rm9ybUJ1dHRvbiA9IGZhbHNlOwogCi0gICAgaWYgKGV2dC0+dHlwZSgpID09IGV2ZW50 TmFtZXMoKS50ZXh0SW5wdXRFdmVudCAmJiBldnQtPmlzVGV4dEV2ZW50KCkgJiYgc3RhdGljX2Nh c3Q8VGV4dEV2ZW50Kj4oZXZ0KS0+ZGF0YSgpID09ICJcbiIpCi0gICAgICAgIGNsaWNrRGVmYXVs dEZvcm1CdXR0b24gPSB0cnVlOworICAgIGlmIChldnQtPnR5cGUoKSA9PSBldmVudE5hbWVzKCku dGV4dElucHV0RXZlbnQgJiYgZXZ0LT5pc1RleHRFdmVudCgpKSB7CisgICAgICAgIFRleHRFdmVu dCogdGV4dEV2ZW50ID0gc3RhdGljX2Nhc3Q8VGV4dEV2ZW50Kj4oZXZ0KTsKKyAgICAgICAgaWYg KHRleHRFdmVudC0+ZGF0YSgpID09ICJcbiIpCisgICAgICAgICAgICBjbGlja0RlZmF1bHRGb3Jt QnV0dG9uID0gdHJ1ZTsKKyAgICAgICAgZWxzZSBpZiAocmVuZGVyZXIoKSAmJiAhaXNDb25mb3Jt ZWRUb0lucHV0TWFzayh0ZXh0RXZlbnQtPmRhdGEoKVswXSwgc3RhdGljX2Nhc3Q8UmVuZGVyVGV4 dENvbnRyb2wqPihyZW5kZXJlcigpKS0+dGV4dCgpLmxlbmd0aCgpICsgMSkpCisgICAgICAgICAg ICAvLyBJZiB0aGUgaW5wdXRlZCBjaGFyIGRvZXNuJ3QgY29uZm9ybSB0byB0aGUgaW5wdXQgbWFz aywgc3RvcCBoYW5kbGluZyAKKyAgICAgICAgICAgIHJldHVybjsKKyAgICB9CiAKICAgICBpZiAo ZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLmtleWRvd25FdmVudCAmJiBldnQtPmlzS2V5Ym9h cmRFdmVudCgpICYmIGZvY3VzZWQoKSAmJiBkb2N1bWVudCgpLT5mcmFtZSgpCiAgICAgICAgICYm IGRvY3VtZW50KCktPmZyYW1lKCktPmRvVGV4dEZpZWxkQ29tbWFuZEZyb21FdmVudCh0aGlzLCBz dGF0aWNfY2FzdDxLZXlib2FyZEV2ZW50Kj4oZXZ0KSkpIHsKQEAgLTMyNyw2ICszNTYsMTYxIEBA IHZvaWQgV01MSW5wdXRFbGVtZW50OjpkaWRNb3ZlVG9OZXdPd25lckQKICAgICBXTUxFbGVtZW50 OjpkaWRNb3ZlVG9OZXdPd25lckRvY3VtZW50KCk7CiB9CiAKK3ZvaWQgV01MSW5wdXRFbGVtZW50 Ojppbml0KCkKK3sKKyAgICBTdHJpbmcgbmFtZVZhciA9IG5hbWUoKTsKKyAgICBTdHJpbmcgdmFy VmFsdWU7CisgICAgV01MUGFnZVN0YXRlKiBwYWdlU2F0ZSA9IHdtbFBhZ2VTdGF0ZUZvckRvY3Vt ZW50KGRvY3VtZW50KCkpOyAKKyAgICBBU1NFUlQocGFnZVNhdGUpOworICAgIGlmICghbmFtZVZh ci5pc0VtcHR5KCkpCisgICAgICAgIHZhclZhbHVlID0gcGFnZVNhdGUtPmdldFZhcmlhYmxlKG5h bWVWYXIpOworCisgICAgaWYgKHZhclZhbHVlLmlzRW1wdHkoKSB8fCAhaXNDb25mb3JtZWRUb0lu cHV0TWFzayh2YXJWYWx1ZSkpIHsKKyAgICAgICAgU3RyaW5nIHZhbCA9IHZhbHVlKCk7CisgICAg ICAgIGlmIChpc0NvbmZvcm1lZFRvSW5wdXRNYXNrKHZhbCkpCisgICAgICAgICAgICB2YXJWYWx1 ZSA9IHZhbDsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgdmFyVmFsdWUgPSAiIjsKKyAKKyAg ICAgICAgcGFnZVNhdGUtPnN0b3JlVmFyaWFibGUobmFtZVZhciwgdmFyVmFsdWUpOworICAgIH0K KyAgICBzZXRWYWx1ZSh2YXJWYWx1ZSk7CisgCisgICAgaWYgKGdldEF0dHJpYnV0ZShXTUxOYW1l czo6ZW1wdHlva0F0dHIpLmlzRW1wdHkoKSkgeworICAgICAgICBpZiAobV9mb3JtYXRNYXNrLmlz RW1wdHkoKSB8fCAKKyAgICAgICAgICAgIC8vIGNoZWNrIGlmIHRoZSBmb3JtYXQgY29kZXMgaXMg YSAiKmYiIGNvZGUKKyAgICAgICAgICAgKG1fZm9ybWF0TWFzay5sZW5ndGgoKSA9PSAyICYmIG1f Zm9ybWF0TWFza1swXSA9PSAnKicgJiYgc19mb3JtYXRDb2Rlcy5maW5kKG1fZm9ybWF0TWFza1sx XSkgIT0gLTEpKQorICAgICAgICAgICAgbV9pc0VtcHR5T2sgPSB0cnVlOworICAgIH0KK30KKwor U3RyaW5nIFdNTElucHV0RWxlbWVudDo6dmFsaWRhdGVJbnB1dE1hc2soY29uc3QgU3RyaW5nJiBp bnB1dE1hc2spCit7CisgICAgYm9vbCBpc1ZhbGlkID0gdHJ1ZTsKKyAgICBib29sIGhhc1dpbGRj YXJkID0gZmFsc2U7CisgICAgdW5zaWduZWQgZXNjYXBlQ2hhckNudHMgPSAwOworICAgIHVuc2ln bmVkIG1hc2tMZW4gPSBpbnB1dE1hc2subGVuZ3RoKCk7CisgICAgVUNoYXIgZm9ybWF0Q29kZTsK KyAKKyAgICBmb3IgKHVuc2lnbmVkIGkgPSAwOyBpIDwgbWFza0xlbjsgKytpKSB7CisgICAgICAg IGZvcm1hdENvZGUgPSBpbnB1dE1hc2tbaV07CisgICAgICAgIGlmIChzX2Zvcm1hdENvZGVzLmZp bmQoZm9ybWF0Q29kZSkgPT0gLTEpIHsKKyAgICAgICAgICAgIGlmIChmb3JtYXRDb2RlID09ICcq JyB8fCAoV1RGOjppc0FTQ0lJRGlnaXQoZm9ybWF0Q29kZSkgJiYgZm9ybWF0Q29kZSAhPSAnMCcp KSB7CisgICAgICAgICAgICAgICAgLy8gdmFsaWRhdGUgY29kZXMgd2hpY2ggZW5kcyB3aXRoICcq Zicgb3IgJ25mJworICAgICAgICAgICAgICAgIGZvcm1hdENvZGUgPSBpbnB1dE1hc2tbKytpXTsK KyAgICAgICAgICAgICAgICBpZiAoKGkgKyAxICE9IG1hc2tMZW4pIHx8IHNfZm9ybWF0Q29kZXMu ZmluZChmb3JtYXRDb2RlKSA9PSAtMSkgeworICAgICAgICAgICAgICAgICAgICBpc1ZhbGlkID0g ZmFsc2U7CisgICAgICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgICAgIH0KKyAg ICAgICAgICAgICAgICBoYXNXaWxkY2FyZCA9IHRydWU7CisgICAgICAgICAgICB9IGVsc2UgaWYg KGZvcm1hdENvZGUgPT0gJ1xcJykgeworICAgICAgICAgICAgICAgIC8vc2tpcCBvdmVyIHRoZSBu ZXh0IG1hc2sgY2hhcmFjdGVyCisgICAgICAgICAgICAgICAgaSsrOworICAgICAgICAgICAgICAg IGVzY2FwZUNoYXJDbnRzKys7CisgICAgICAgICAgICB9IGVsc2UgeworICAgICAgICAgICAgICAg IGlzVmFsaWQgPSBmYWxzZTsKKyAgICAgICAgICAgICAgICBicmVhazsKKyAgICAgICAgICAgIH0K KyAgICAgICAgfQorICAgIH0KKyAKKyAgICAvLyBjYWxjdWxhdGUgdGhlIG51bWJlciBvZiBjaGFy YWN0ZXJzIGFsbG93ZWQgdG8gYmUgZW50ZXJlZCBieSBpbnB1dCBtYXNrCisgICAgaWYgKGlzVmFs aWQpIHsKKyAgICAgICAgbV9udW1PZkNoYXJzQWxsb3dlZEJ5TWFzayA9IG1hc2tMZW47CisgCisg ICAgICAgIGlmIChlc2NhcGVDaGFyQ250cykKKyAgICAgICAgICAgIG1fbnVtT2ZDaGFyc0FsbG93 ZWRCeU1hc2sgLT0gZXNjYXBlQ2hhckNudHM7CisgCisgICAgICAgIGlmIChoYXNXaWxkY2FyZCkg eworICAgICAgICAgICAgZm9ybWF0Q29kZSA9IGlucHV0TWFza1ttYXNrTGVuIC0gMl07CisgICAg ICAgICAgICBpZiAoZm9ybWF0Q29kZSA9PSAnKicpCisgICAgICAgICAgICAgICAgbV9udW1PZkNo YXJzQWxsb3dlZEJ5TWFzayA9IG1fZGF0YS5tYXhMZW5ndGgoKTsKKyAgICAgICAgICAgIGVsc2Ug eworICAgICAgICAgICAgICAgIHVuc2lnbmVkIGxlZnRMZW4gPSBTdHJpbmcoJmZvcm1hdENvZGUp LnRvSW50KCk7CisgICAgICAgICAgICAgICAgbV9udW1PZkNoYXJzQWxsb3dlZEJ5TWFzayA9IGxl ZnRMZW4gKyBtX251bU9mQ2hhcnNBbGxvd2VkQnlNYXNrIC0gMjsKKyAgICAgICAgICAgIH0KKyAg ICAgICAgfQorCisgICAgICAgIHJldHVybiBpbnB1dE1hc2s7CisgICAgfQorIAorICAgIHJldHVy biBTdHJpbmcoKTsKK30KKworYm9vbCBXTUxJbnB1dEVsZW1lbnQ6OmlzQ29uZm9ybWVkVG9JbnB1 dE1hc2soY29uc3QgU3RyaW5nJiBpbnB1dENoYXJzKQoreworICAgIGJvb2wgb2sgPSB0cnVlOwor ICAgIGZvciAodW5zaWduZWQgaSA9IDA7IGkgPCBpbnB1dENoYXJzLmxlbmd0aCgpOyArK2kpIHsK KyAgICAgICAgb2sgPSBpc0NvbmZvcm1lZFRvSW5wdXRNYXNrKGlucHV0Q2hhcnNbaV0sIGkgKyAx LCBmYWxzZSk7CisgICAgICAgIGlmICghb2spCisgICAgICAgICAgICBicmVhazsKKyAgICB9Cisg CisgICAgcmV0dXJuIG9rOworfQorIAorYm9vbCBXTUxJbnB1dEVsZW1lbnQ6OmlzQ29uZm9ybWVk VG9JbnB1dE1hc2soVUNoYXIgaW5DaGFyLCB1bnNpZ25lZCBpbnB1dENoYXJDb3VudHMsIGJvb2wg aXNJbnB1dGVkQnlVc3IpCit7CisgICAgYm9vbCBvayA9IHRydWU7CisgICAgaWYgKG1fZm9ybWF0 TWFzay5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybiBvazsKKyAKKyAgICBpZiAoaW5wdXRDaGFy Q291bnRzID4gbV9udW1PZkNoYXJzQWxsb3dlZEJ5TWFzaykKKyAgICAgICAgcmV0dXJuIGZhbHNl OworCisgICAgdW5zaWduZWQgaWR4T2ZNYXNrID0gMDsKKyAgICBpZiAoaXNJbnB1dGVkQnlVc3Ip IHsKKyAgICAgICAgaW50IGN1cnNvclBvcyA9IDA7CisgICAgICAgIGlmIChyZW5kZXJlcigpKQor ICAgICAgICAgICAgY3Vyc29yUG9zID0gc3RhdGljX2Nhc3Q8UmVuZGVyVGV4dENvbnRyb2wqPihy ZW5kZXJlcigpKS0+c2VsZWN0aW9uU3RhcnQoKTsgCisgICAgICAgIGVsc2UKKyAgICAgICAgICAg IGN1cnNvclBvcyA9IG1fZGF0YS5jYWNoZWRTZWxlY3Rpb25TdGFydCgpOworCisgICAgICAgIGlk eE9mTWFzayA9IGN1cnNvclBvc1RvSWR4T2ZNYXNrKGN1cnNvclBvcyk7CisgICAgfSBlbHNlCisg ICAgICAgIGlkeE9mTWFzayA9IGN1cnNvclBvc1RvSWR4T2ZNYXNrKGlucHV0Q2hhckNvdW50cyAt IDEpOworCisgICAgVUNoYXIgbWFzayA9IG1fZm9ybWF0TWFza1tpZHhPZk1hc2tdOworICAgIC8v IG1hdGNoIHRoZSBpbnB1dGVkIGNoYXJhY3RlciB3aXRoIGlucHV0IG1hc2sKKyAgICBpZiAobWFz ayA9PSAnQScpCisgICAgICAgIG9rID0gIVdURjo6aXNBU0NJSURpZ2l0KGluQ2hhcikgJiYgIVdU Rjo6aXNBU0NJSUxvd2VyKGluQ2hhcikgJiYgV1RGOjppc0FTQ0lJUHJpbnRhYmxlKGluQ2hhcik7 CisgICAgZWxzZSBpZiAobWFzayA9PSAnYScpCisgICAgICAgIG9rID0gIVdURjo6aXNBU0NJSURp Z2l0KGluQ2hhcikgJiYgIVdURjo6aXNBU0NJSVVwcGVyKGluQ2hhcikgJiYgV1RGOjppc0FTQ0lJ UHJpbnRhYmxlKGluQ2hhcik7CisgICAgZWxzZSBpZiAobWFzayA9PSAnTicpCisgICAgICAgIG9r ID0gV1RGOjppc0FTQ0lJRGlnaXQoaW5DaGFyKTsKKyAgICBlbHNlIGlmIChtYXNrID09ICduJykK KyAgICAgICAgb2sgPSAhV1RGOjppc0FTQ0lJQWxwaGEoaW5DaGFyKSAmJiBXVEY6OmlzQVNDSUlQ cmludGFibGUoaW5DaGFyKTsKKyAgICBlbHNlIGlmIChtYXNrID09ICdYJykKKyAgICAgICAgb2sg PSAhV1RGOjppc0FTQ0lJTG93ZXIoaW5DaGFyKSAmJiBXVEY6OmlzQVNDSUlQcmludGFibGUoaW5D aGFyKTsKKyAgICBlbHNlIGlmIChtYXNrID09ICd4JykKKyAgICAgICAgb2sgPSAhV1RGOjppc0FT Q0lJVXBwZXIoaW5DaGFyKSAmJiBXVEY6OmlzQVNDSUlQcmludGFibGUoaW5DaGFyKTsKKyAgICBl bHNlIGlmIChtYXNrID09ICdNJykKKyAgICAgICAgb2sgPSBXVEY6OmlzQVNDSUlQcmludGFibGUo aW5DaGFyKTsKKyAgICBlbHNlIGlmIChtYXNrID09ICdtJykKKyAgICAgICAgb2sgPSBXVEY6Omlz QVNDSUlQcmludGFibGUoaW5DaGFyKTsKKyAgICBlbHNlCisgICAgICAgIG9rID0gKG1hc2sgPT0g aW5DaGFyKTsKKworICAgIHJldHVybiBvazsKK30KKwordW5zaWduZWQgV01MSW5wdXRFbGVtZW50 OjpjdXJzb3JQb3NUb0lkeE9mTWFzayh1bnNpZ25lZCBjdXJzb3JQb3MpCit7CisgICAgVUNoYXIg bWFzazsKKyAgICBpbnQgaWR4ID0gLTE7CisgICAgZG8geworICAgICAgICBtYXNrID0gbV9mb3Jt YXRNYXNrWysraWR4XTsKKyAgICAgICAgaWYgKG1hc2sgPT0gJ1xcJykKKyAgICAgICAgICAgIGlk eCsrOworICAgICAgICBlbHNlIGlmIChtYXNrID09ICcqJyB8fCAoV1RGOjppc0FTQ0lJRGlnaXQo bWFzaykgJiYgbWFzayAhPSAnMCcpKSB7CisgICAgICAgICAgICBpZHggPSBtX2Zvcm1hdE1hc2su bGVuZ3RoKCkgLSAxOworICAgICAgICAgICAgYnJlYWs7CisgICAgICAgIH0KKyAgICB9IHdoaWxl IChjdXJzb3JQb3MtLSk7CisgCisgICAgcmV0dXJuIGlkeDsKK30KKwogfQogCiAjZW5kaWYKSW5k ZXg6IFdlYkNvcmUvd21sL1dNTElucHV0RWxlbWVudC5oCj09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUv d21sL1dNTElucHV0RWxlbWVudC5oCShyZXZpc2lvbiA0MDA4NCkKKysrIFdlYkNvcmUvd21sL1dN TElucHV0RWxlbWVudC5oCSh3b3JraW5nIGNvcHkpCkBAIC04OSwxMCArODksMjEgQEAgcHVibGlj OgogICAgIHZpcnR1YWwgdm9pZCB3aWxsTW92ZVRvTmV3T3duZXJEb2N1bWVudCgpOwogICAgIHZp cnR1YWwgdm9pZCBkaWRNb3ZlVG9OZXdPd25lckRvY3VtZW50KCk7CiAKKyAgICBib29sIGlzQ29u Zm9ybWVkVG9JbnB1dE1hc2soY29uc3QgU3RyaW5nJik7CisgICAgYm9vbCBpc0NvbmZvcm1lZFRv SW5wdXRNYXNrKFVDaGFyLCB1bnNpZ25lZCwgYm9vbCBpc0lucHV0ZWRCeVVzciA9IHRydWUpOwor CisgICAgc3RhdGljIGNvbnN0IFN0cmluZyBzX2Zvcm1hdENvZGVzOwogcHJpdmF0ZToKKyAgICB2 b2lkIGluaXQoKTsKKyAgICBTdHJpbmcgdmFsaWRhdGVJbnB1dE1hc2soY29uc3QgU3RyaW5nJik7 CisgICAgdW5zaWduZWQgY3Vyc29yUG9zVG9JZHhPZk1hc2sodW5zaWduZWQpOworCiAgICAgSW5w dXRFbGVtZW50RGF0YSBtX2RhdGE7CiAgICAgYm9vbCBtX2lzUGFzc3dvcmRGaWVsZDsKICAgICBi b29sIG1fdmFsdWVNYXRjaGVzUmVuZGVyZXI7CisgICAgYm9vbCBtX2lzRW1wdHlPazsKKyAgICBT dHJpbmcgbV9mb3JtYXRNYXNrOworICAgIHVuc2lnbmVkIG1fbnVtT2ZDaGFyc0FsbG93ZWRCeU1h c2s7CiB9OwogCiB9CkluZGV4OiBMYXlvdXRUZXN0cy9DaGFuZ2VMb2cKPT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0g TGF5b3V0VGVzdHMvQ2hhbmdlTG9nCShyZXZpc2lvbiA0MDE1NCkKKysrIExheW91dFRlc3RzL0No YW5nZUxvZwkod29ya2luZyBjb3B5KQpAQCAtMSwzICsxLDE0IEBACisyMDA5LTAxLTIzICBZaWNo YW8gWWluIDx5aWNoYW8ueWluQHRvcmNobW9iaWxlLmNvbS5jbj4KKworICAgICAgICBSZXZpZXdl ZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICAqIHdtbC9pbnB1dC1mb3JtYXQtZXhwZWN0 ZWQudHh0OiBBZGRlZC4KKyAgICAgICAgKiB3bWwvaW5wdXQtZm9ybWF0Lmh0bWw6IEFkZGVkLgor ICAgICAgICAqIHdtbC9yZXNvdXJjZXMvaW5wdXQtZm9ybWF0LmpzOiBBZGRlZC4KKyAgICAgICAg KHNldHVwVGVzdERvY3VtZW50KToKKyAgICAgICAgKHByZXBhcmVUZXN0KToKKyAgICAgICAgKGV4 ZWN1dGVUZXN0KToKKwogMjAwOS0wMS0yMiAgRXJpYyBTZWlkZWwgIDxlcmljQHdlYmtpdC5vcmc+ CiAKICAgICAgICAgUmV2aWV3ZWQgYnkgSnVzdGluIEdhcmNpYS4KSW5kZXg6IExheW91dFRlc3Rz L3dtbC9pbnB1dC1mb3JtYXQtZXhwZWN0ZWQudHh0Cj09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIExheW91dFRlc3Rz L3dtbC9pbnB1dC1mb3JtYXQtZXhwZWN0ZWQudHh0CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVz dHMvd21sL2lucHV0LWZvcm1hdC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEs MjkgQEAKK1dNTCBsYXlvdXQgdGVzdHMgLSB1c2luZyBYSFRNTCBzY3JpcHRpbmcKKworCitUZXN0 cyBpbnB1dCBmb3JtYXQgdmFsaWRhdGlvbgorCitPbiBzdWNjZXNzLCB5b3Ugd2lsbCBzZWUgYSBz ZXJpZXMgb2YgIlBBU1MiIG1lc3NhZ2VzLCBmb2xsb3dlZCBieSAiVEVTVCBDT01QTEVURSIuCisK KworUEFTUyBwRWxlbWVudDEudGV4dENvbnRlbnQgaXMgIlJlc3VsdDogJGlucHV0MSIKK1BBU1Mg cEVsZW1lbnQyLnRleHRDb250ZW50IGlzICJSZXN1bHQ6ICRpbnB1dDIiCitQQVNTIHBFbGVtZW50 My50ZXh0Q29udGVudCBpcyAiUmVzdWx0OiAkaW5wdXQzIgorUEFTUyBwRWxlbWVudDQudGV4dENv bnRlbnQgaXMgIlJlc3VsdDogJGlucHV0NCIKK1BBU1MgcEVsZW1lbnQxLnRleHRDb250ZW50IGlz ICJSZXN1bHQ6IFRlU3QwLTAxIgorUEFTUyBwRWxlbWVudDIudGV4dENvbnRlbnQgaXMgIlJlc3Vs dDogVGVTdDAtMDIiCitQQVNTIHBFbGVtZW50My50ZXh0Q29udGVudCBpcyAiUmVzdWx0OiBUZVN0 MC0wMyIKK1BBU1MgcEVsZW1lbnQ0LnRleHRDb250ZW50IGlzICJSZXN1bHQ6ICIKK1BBU1Mgc3Vj Y2Vzc2Z1bGx5UGFyc2VkIGlzIHRydWUKKworVEVTVCBDT01QTEVURQorCisKKy0tLS0tLS0tCitG cmFtZTogJzwhLS1mcmFtZVBhdGggLy88IS0tZnJhbWUwLS0+LS0+JworLS0tLS0tLS0KK1N0YXJ0 IHRlc3QKK1Jlc3VsdDogVGVTdDAtMDEKK1Jlc3VsdDogVGVTdDAtMDIKK1Jlc3VsdDogVGVTdDAt MDMKK1Jlc3VsdDoKSW5kZXg6IExheW91dFRlc3RzL3dtbC9pbnB1dC1mb3JtYXQuaHRtbAo9PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09Ci0tLSBMYXlvdXRUZXN0cy93bWwvaW5wdXQtZm9ybWF0Lmh0bWwJKHJldmlzaW9uIDAp CisrKyBMYXlvdXRUZXN0cy93bWwvaW5wdXQtZm9ybWF0Lmh0bWwJKHJldmlzaW9uIDApCkBAIC0w LDAgKzEsMTUgQEAKKzwhRE9DVFlQRSBIVE1MIFBVQkxJQyAiLS8vSUVURi8vRFREIEhUTUwvL0VO Ij4KKzxodG1sPgorPGhlYWQ+Cis8bGluayByZWw9InN0eWxlc2hlZXQiIGhyZWY9Ii4uL2Zhc3Qv anMvcmVzb3VyY2VzL2pzLXRlc3Qtc3R5bGUuY3NzIj4KKzxzY3JpcHQ+dmFyIHJlbGF0aXZlUGF0 aFRvTGF5b3V0VGVzdHMgPSAiLi4iOzwvc2NyaXB0PgorPHNjcmlwdCBzcmM9InJlc291cmNlcy9X TUxUZXN0Q2FzZS5qcyI+PC9zY3JpcHQ+Cis8c2NyaXB0IHNyYz0iLi4vZmFzdC9qcy9yZXNvdXJj ZXMvanMtdGVzdC1wcmUuanMiPjwvc2NyaXB0PgorPC9oZWFkPgorPGJvZHk+Cis8aDE+V01MIGxh eW91dCB0ZXN0cyAtIHVzaW5nIFhIVE1MIHNjcmlwdGluZzwvaDE+Cis8cCBpZD0iZGVzY3JpcHRp b24iPjwvcD4KKzxkaXYgaWQ9ImNvbnNvbGUiPjwvZGl2PgorPHNjcmlwdCBzcmM9InJlc291cmNl cy9pbnB1dC1mb3JtYXQuanMiPjwvc2NyaXB0PgorPC9ib2R5PgorPC9odG1sPgpJbmRleDogTGF5 b3V0VGVzdHMvd21sL3Jlc291cmNlcy9pbnB1dC1mb3JtYXQuanMKPT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5 b3V0VGVzdHMvd21sL3Jlc291cmNlcy9pbnB1dC1mb3JtYXQuanMJKHJldmlzaW9uIDApCisrKyBM YXlvdXRUZXN0cy93bWwvcmVzb3VyY2VzL2lucHV0LWZvcm1hdC5qcwkocmV2aXNpb24gMCkKQEAg LTAsMCArMSw4MCBAQAorLy8gW05hbWVdIGlucHV0LWZvcm1hdC5qcyAKKworY3JlYXRlV01MVGVz dENhc2UoIlRlc3RzIGlucHV0IGZvcm1hdCB2YWxpZGF0aW9uIik7CisKK3ZhciBwRWxlbWVudDE7 Cit2YXIgcEVsZW1lbnQyOwordmFyIHBFbGVtZW50MzsKK3ZhciBwRWxlbWVudDQ7CisKK2Z1bmN0 aW9uIHNldHVwVGVzdERvY3VtZW50KCkgeworICAgIHZhciBjYXJkRWxlbWVudCA9IHRlc3REb2N1 bWVudC5kb2N1bWVudEVsZW1lbnQuZmlyc3RDaGlsZDsKKworICAgIHZhciBhbmNob3JFbGVtZW50 ID0gY3JlYXRlV01MRWxlbWVudCgiYW5jaG9yIik7CisgICAgYW5jaG9yRWxlbWVudC5hcHBlbmRD aGlsZCh0ZXN0RG9jdW1lbnQuY3JlYXRlVGV4dE5vZGUoIlN0YXJ0IHRlc3QiKSk7CisgICAgY2Fy ZEVsZW1lbnQuYXBwZW5kQ2hpbGQoYW5jaG9yRWxlbWVudCk7CisKKyAgICB2YXIgcmVmcmVzaEVs ZW1lbnQgPSBjcmVhdGVXTUxFbGVtZW50KCJyZWZyZXNoIik7CisgICAgYW5jaG9yRWxlbWVudC5h cHBlbmRDaGlsZChyZWZyZXNoRWxlbWVudCk7CisKKyAgICB2YXIgaW5wdXRFbGVtZW50MSA9IGNy ZWF0ZVdNTEVsZW1lbnQoImlucHV0Iik7CisgICAgaW5wdXRFbGVtZW50MS5zZXRBdHRyaWJ1dGUo Im5hbWUiLCAiaW5wdXQxIik7CisgICAgaW5wdXRFbGVtZW50MS5zZXRBdHRyaWJ1dGUoInZhbHVl IiwgIlRlU3QwLTAxIik7CisgICAgaW5wdXRFbGVtZW50MS5zZXRBdHRyaWJ1dGUoImZvcm1hdCIs ICJBYVh4TW1ObiIpOworICAgIGNhcmRFbGVtZW50LmFwcGVuZENoaWxkKGlucHV0RWxlbWVudDEp OworCisgICAgdmFyIGlucHV0RWxlbWVudDIgPSBjcmVhdGVXTUxFbGVtZW50KCJpbnB1dCIpOwor ICAgIGlucHV0RWxlbWVudDIuc2V0QXR0cmlidXRlKCJuYW1lIiwgImlucHV0MiIpOworICAgIGlu cHV0RWxlbWVudDIuc2V0QXR0cmlidXRlKCJ2YWx1ZSIsICJUZVN0MC0wMiIpOworICAgIGlucHV0 RWxlbWVudDIuc2V0QXR0cmlidXRlKCJmb3JtYXQiLCAiQWFYeG5cLTJOIik7CisgICAgY2FyZEVs ZW1lbnQuYXBwZW5kQ2hpbGQoaW5wdXRFbGVtZW50Mik7CisKKyAgICB2YXIgaW5wdXRFbGVtZW50 MyA9IGNyZWF0ZVdNTEVsZW1lbnQoImlucHV0Iik7CisgICAgaW5wdXRFbGVtZW50My5zZXRBdHRy aWJ1dGUoIm5hbWUiLCAiaW5wdXQzIik7CisgICAgaW5wdXRFbGVtZW50My5zZXRBdHRyaWJ1dGUo InZhbHVlIiwgIlRlU3QwLTAzIik7CisgICAgaW5wdXRFbGVtZW50My5zZXRBdHRyaWJ1dGUoImZv cm1hdCIsICJYYW0qeCIpOworICAgIGNhcmRFbGVtZW50LmFwcGVuZENoaWxkKGlucHV0RWxlbWVu dDMpOworCisgICAgdmFyIGlucHV0RWxlbWVudDQgPSBjcmVhdGVXTUxFbGVtZW50KCJpbnB1dCIp OworICAgIGlucHV0RWxlbWVudDQuc2V0QXR0cmlidXRlKCJuYW1lIiwgImlucHV0NCIpOworICAg IGlucHV0RWxlbWVudDQuc2V0QXR0cmlidXRlKCJ2YWx1ZSIsICJUZVN0MC0wNCIpOworICAgIC8v IGRvZXNuJ3QgbWF0Y2ggdGhlIG1hc2ssIHRoZSAndmFsdWUnIHdpbGwgYmUgc2V0ICcnCisgICAg aW5wdXRFbGVtZW50NC5zZXRBdHRyaWJ1dGUoImZvcm1hdCIsICJBQUFBIik7CisgICAgY2FyZEVs ZW1lbnQuYXBwZW5kQ2hpbGQoaW5wdXRFbGVtZW50NCk7CisKKyAgICBwRWxlbWVudDEgPSBjcmVh dGVXTUxFbGVtZW50KCJwIik7CisgICAgcEVsZW1lbnQxLnRleHRDb250ZW50ID0gIlJlc3VsdDog JGlucHV0MSI7CisgICAgY2FyZEVsZW1lbnQuYXBwZW5kQ2hpbGQocEVsZW1lbnQxKTsKKworICAg IHBFbGVtZW50MiA9IGNyZWF0ZVdNTEVsZW1lbnQoInAiKTsKKyAgICBwRWxlbWVudDIudGV4dENv bnRlbnQgPSAiUmVzdWx0OiAkaW5wdXQyIjsKKyAgICBjYXJkRWxlbWVudC5hcHBlbmRDaGlsZChw RWxlbWVudDIpOworCisgICAgcEVsZW1lbnQzID0gY3JlYXRlV01MRWxlbWVudCgicCIpOworICAg IHBFbGVtZW50My50ZXh0Q29udGVudCA9ICJSZXN1bHQ6ICRpbnB1dDMiOworICAgIGNhcmRFbGVt ZW50LmFwcGVuZENoaWxkKHBFbGVtZW50Myk7CisKKyAgICBwRWxlbWVudDQgPSBjcmVhdGVXTUxF bGVtZW50KCJwIik7CisgICAgcEVsZW1lbnQ0LnRleHRDb250ZW50ID0gIlJlc3VsdDogJGlucHV0 NCI7CisgICAgY2FyZEVsZW1lbnQuYXBwZW5kQ2hpbGQocEVsZW1lbnQ0KTsKK30KKworZnVuY3Rp b24gcHJlcGFyZVRlc3QoKSB7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCJwRWxlbWVudDEu dGV4dENvbnRlbnQiLCAiUmVzdWx0OiAkaW5wdXQxIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3Ry aW5nKCJwRWxlbWVudDIudGV4dENvbnRlbnQiLCAiUmVzdWx0OiAkaW5wdXQyIik7CisgICAgc2hv dWxkQmVFcXVhbFRvU3RyaW5nKCJwRWxlbWVudDMudGV4dENvbnRlbnQiLCAiUmVzdWx0OiAkaW5w dXQzIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCJwRWxlbWVudDQudGV4dENvbnRlbnQi LCAiUmVzdWx0OiAkaW5wdXQ0Iik7CisgCisgICAgc3RhcnRUZXN0KDI1LCAxNSk7Cit9CisKK2Z1 bmN0aW9uIGV4ZWN1dGVUZXN0KCkgeworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygicEVsZW1l bnQxLnRleHRDb250ZW50IiwgIlJlc3VsdDogVGVTdDAtMDEiKTsKKyAgICBzaG91bGRCZUVxdWFs VG9TdHJpbmcoInBFbGVtZW50Mi50ZXh0Q29udGVudCIsICJSZXN1bHQ6IFRlU3QwLTAyIik7Cisg ICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCJwRWxlbWVudDMudGV4dENvbnRlbnQiLCAiUmVzdWx0 OiBUZVN0MC0wMyIpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygicEVsZW1lbnQ0LnRleHRD b250ZW50IiwgIlJlc3VsdDogIik7CisKKyAgICBjb21wbGV0ZVRlc3QoKTsKK30KKwordmFyIHN1 Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cg== 26994 2009-01-24 01:17:49 -0800 2009-02-02 08:07:46 -0800 updated patch wmlinputsupplement.patch.v2 text/plain 22030 yichao.yin SW5kZXg6IFdlYkNvcmUvQ2hhbmdlTG9nCj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT0KLS0tIFdlYkNvcmUvQ2hhbmdlTG9n CShyZXZpc2lvbiA0MDIxMikKKysrIFdlYkNvcmUvQ2hhbmdlTG9nCSh3b3JraW5nIGNvcHkpCkBA IC0xLDMgKzEsMjIgQEAKKzIwMDktMDEtMjQgIFlpY2hhbyBZaW4gIDx5aWNoYW8ueWluQHRvcmNo bW9iaWxlLmNvbS5jbj4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKwor ICAgICAgICBUZXN0OiB3bWwvaW5wdXQtZm9ybWF0Lmh0bWwKKworICAgICAgICAqIHdtbC9XTUxJ bnB1dEVsZW1lbnQuY3BwOgorICAgICAgICAoV2ViQ29yZTo6V01MSW5wdXRFbGVtZW50OjpXTUxJ bnB1dEVsZW1lbnQpOgorICAgICAgICAoV2ViQ29yZTo6Zm9ybWF0Q29kZXMpOgorICAgICAgICAo V2ViQ29yZTo6V01MSW5wdXRFbGVtZW50OjpkaXNwYXRjaEJsdXJFdmVudCk6CisgICAgICAgIChX ZWJDb3JlOjpXTUxJbnB1dEVsZW1lbnQ6OnBhcnNlTWFwcGVkQXR0cmlidXRlKToKKyAgICAgICAg KFdlYkNvcmU6OldNTElucHV0RWxlbWVudDo6YXR0YWNoKToKKyAgICAgICAgKFdlYkNvcmU6OldN TElucHV0RWxlbWVudDo6ZGVmYXVsdEV2ZW50SGFuZGxlcik6CisgICAgICAgIChXZWJDb3JlOjpX TUxJbnB1dEVsZW1lbnQ6OmluaXQpOgorICAgICAgICAoV2ViQ29yZTo6V01MSW5wdXRFbGVtZW50 Ojp2YWxpZGF0ZUlucHV0TWFzayk6CisgICAgICAgIChXZWJDb3JlOjpXTUxJbnB1dEVsZW1lbnQ6 OmlzQ29uZm9ybWVkVG9JbnB1dE1hc2spOgorICAgICAgICAoV2ViQ29yZTo6V01MSW5wdXRFbGVt ZW50OjpjdXJzb3JQb3NpdGlvblRvTWFza0luZGV4KToKKyAgICAgICAgKiB3bWwvV01MSW5wdXRF bGVtZW50Lmg6CisKIDIwMDktMDEtMjQgIEphbiBNaWNoYWVsIEFsb256byAgPGptYWxvbnpvQHdl YmtpdC5vcmc+CiAKICAgICAgICAgR3RrIGJ1aWxkIGZpeCBhZnRlciByNDAxNzAKSW5kZXg6IFdl YkNvcmUvd21sL1dNTElucHV0RWxlbWVudC5jcHAKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gV2ViQ29yZS93bWwv V01MSW5wdXRFbGVtZW50LmNwcAkocmV2aXNpb24gNDAwODQpCisrKyBXZWJDb3JlL3dtbC9XTUxJ bnB1dEVsZW1lbnQuY3BwCSh3b3JraW5nIGNvcHkpCkBAIC0yMyw3ICsyMyw2IEBACiAjaWYgRU5B QkxFKFdNTCkKICNpbmNsdWRlICJXTUxJbnB1dEVsZW1lbnQuaCIKIAotI2luY2x1ZGUgIkRvY3Vt ZW50LmgiCiAjaW5jbHVkZSAiRXZlbnROYW1lcy5oIgogI2luY2x1ZGUgIkZvcm1EYXRhTGlzdC5o IgogI2luY2x1ZGUgIkZyYW1lLmgiCkBAIC0zMSw2ICszMCw5IEBACiAjaW5jbHVkZSAiS2V5Ym9h cmRFdmVudC5oIgogI2luY2x1ZGUgIlJlbmRlclRleHRDb250cm9sU2luZ2xlTGluZS5oIgogI2lu Y2x1ZGUgIlRleHRFdmVudC5oIgorI2luY2x1ZGUgIldNTERvY3VtZW50LmgiCisjaW5jbHVkZSAi V01MTmFtZXMuaCIKKyNpbmNsdWRlICJXTUxQYWdlU3RhdGUuaCIKIAogbmFtZXNwYWNlIFdlYkNv cmUgewogCkBAIC0zOSw2ICs0MSw4IEBAIFdNTElucHV0RWxlbWVudDo6V01MSW5wdXRFbGVtZW50 KGNvbnN0IFEKICAgICAsIG1fZGF0YSh0aGlzLCB0aGlzKQogICAgICwgbV9pc1Bhc3N3b3JkRmll bGQoZmFsc2UpCiAgICAgLCBtX3ZhbHVlTWF0Y2hlc1JlbmRlcmVyKGZhbHNlKQorICAgICwgbV9p c0VtcHR5T2soZmFsc2UpCisgICAgLCBtX251bU9mQ2hhcnNBbGxvd2VkQnlNYXNrKDApCiB7CiB9 CiAKQEAgLTY0LDYgKzY4LDEyIEBAIHN0YXRpYyBpbmxpbmUgYm9vbCBpc0lucHV0Rm9jdXNhYmxl KFJlbmQKICAgICByZXR1cm4gdHJ1ZTsKIH0KIAorc3RhdGljIGNvbnN0IEF0b21pY1N0cmluZyYg Zm9ybWF0Q29kZXMoKQoreworICAgIERFRklORV9TVEFUSUNfTE9DQUwoQXRvbWljU3RyaW5nLCBj b2RlcywgKCJBYU5uWHhNbSIpKTsKKyAgICByZXR1cm4gY29kZXM7Cit9CisKIGJvb2wgV01MSW5w dXRFbGVtZW50Ojppc0tleWJvYXJkRm9jdXNhYmxlKEtleWJvYXJkRXZlbnQqKSBjb25zdAogewog ICAgIHJldHVybiBpc0lucHV0Rm9jdXNhYmxlKHJlbmRlcmVyKCkpOwpAQCAtODIsNiArOTIsMTgg QEAgdm9pZCBXTUxJbnB1dEVsZW1lbnQ6OmRpc3BhdGNoRm9jdXNFdmVudAogCiB2b2lkIFdNTElu cHV0RWxlbWVudDo6ZGlzcGF0Y2hCbHVyRXZlbnQoKQogeworICAgIC8vIEZpcnN0bHkgY2hlY2sg aWYgaXQgaXMgYWxsb3dlZCB0byBsZWF2ZSB0aGlzIGlucHV0IGZpZWxkCisgICAgU3RyaW5nIHZh bCA9IHZhbHVlKCk7CisgICAgaWYgKCghbV9pc0VtcHR5T2sgJiYgdmFsLmlzRW1wdHkoKSkgfHwg IWlzQ29uZm9ybWVkVG9JbnB1dE1hc2sodmFsKSkgeworICAgICAgICB1cGRhdGVGb2N1c0FwcGVh cmFuY2UodHJ1ZSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisKKyAgICAvLyB1cGRhdGUgdGhl IG5hbWUgdmFyaWFibGUgb2YgV01MIGlucHV0IGVsbWVuZXQKKyAgICBTdHJpbmcgbmFtZVZhcmlh YmxlID0gbmFtZSgpOworICAgIGlmICghbmFtZVZhcmlhYmxlLmlzRW1wdHkoKSkKKyAgICAgICAg d21sUGFnZVN0YXRlRm9yRG9jdW1lbnQoZG9jdW1lbnQoKSktPnN0b3JlVmFyaWFibGUobmFtZVZh cmlhYmxlLCB2YWwpOyAKKwogICAgIElucHV0RWxlbWVudDo6ZGlzcGF0Y2hCbHVyRXZlbnQobV9k YXRhLCBkb2N1bWVudCgpKTsKICAgICBXTUxFbGVtZW50OjpkaXNwYXRjaEJsdXJFdmVudCgpOwog fQpAQCAtMTgzLDEyICsyMDUsMTQgQEAgdm9pZCBXTUxJbnB1dEVsZW1lbnQ6OnBhcnNlTWFwcGVk QXR0cmlidQogICAgICAgICBJbnB1dEVsZW1lbnQ6OnBhcnNlTWF4TGVuZ3RoQXR0cmlidXRlKG1f ZGF0YSwgYXR0cik7CiAgICAgZWxzZSBpZiAoYXR0ci0+bmFtZSgpID09IEhUTUxOYW1lczo6c2l6 ZUF0dHIpCiAgICAgICAgIElucHV0RWxlbWVudDo6cGFyc2VTaXplQXR0cmlidXRlKG1fZGF0YSwg YXR0cik7CisgICAgZWxzZSBpZiAoYXR0ci0+bmFtZSgpID09IFdNTE5hbWVzOjpmb3JtYXRBdHRy KQorICAgICAgICBtX2Zvcm1hdE1hc2sgPSB2YWxpZGF0ZUlucHV0TWFzayhwYXJzZVZhbHVlRm9y YmlkZGluZ1ZhcmlhYmxlUmVmZXJlbmNlcyhhdHRyLT52YWx1ZSgpKSk7CisgICAgZWxzZSBpZiAo YXR0ci0+bmFtZSgpID09IFdNTE5hbWVzOjplbXB0eW9rQXR0cikKKyAgICAgICAgbV9pc0VtcHR5 T2sgPSAoYXR0ci0+dmFsdWUoKSA9PSAidHJ1ZSIpOwogICAgIGVsc2UKICAgICAgICAgV01MRWxl bWVudDo6cGFyc2VNYXBwZWRBdHRyaWJ1dGUoYXR0cik7CiAKICAgICAvLyBGSVhNRTogSGFuZGxl ICdhY2Nlc3NrZXknIGF0dHJpYnV0ZQotICAgIC8vIEZJWE1FOiBIYW5kbGUgJ2Zvcm1hdCcgYXR0 cmlidXRlCi0gICAgLy8gRklYTUU6IEhhbmRsZSAnZW1wdHlvaycgYXR0cmlidXRlCiAgICAgLy8g RklYTUU6IEhhbmRsZSAndGFiaW5kZXgnIGF0dHJpYnV0ZQogICAgIC8vIEZJWE1FOiBIYW5kbGUg J3RpdGxlJyBhdHRyaWJ1dGUKIH0KQEAgLTIxNSw2ICsyMzksMTMgQEAgdm9pZCBXTUxJbnB1dEVs ZW1lbnQ6OmF0dGFjaCgpCiAgICAgLy8gb24gdGhlIHJlbmRlcmVyLgogICAgIGlmIChyZW5kZXJl cigpKQogICAgICAgICByZW5kZXJlcigpLT51cGRhdGVGcm9tRWxlbWVudCgpOworCisgICAgLy8g RklYTUU6IG1heWJlIHRoaXMgaXMgbm90IGEgZ29vZCBwbGFjZSB0byBkbyB0aGlzIHNpbmNlIGl0 IGlzIHBvc3NpYmxlIAorICAgIC8vIHRvIGNhdXNlIHVuZXhwZWN0ZWQgc2V2ZXJhbCB0aW1lcyBp bml0aWFsaXNlIG9mIDxpbnB1dD4gaWYgd2UgZm9yY2UgdGhlCisgICAgLy8gbm9kZSB0byBiZSBy ZWF0dGFjaGVkLiBCdXQgcGxhY2luZyBpdCBoZXJlIGNhbiBlbnN1cmUgdGhlIHJ1bi13ZWJraXQt dGVzdHMKKyAgICAvLyBnZXQgZXhwZWN0ZWQgcmVzdWx0LGkuZS4gbXVsdGlwbGUtdGltZXMgaW5p dGlhbGlzZSBpcyBleHBlY3RlZCB3aGVuIG1ha2luZworICAgIC8vIGxheW91dCB0ZXN0IGZvciBX TUxJbnB1dEVsZW1lbnQgCisgICAgaW5pdCgpOwogfSAgCiAKIHZvaWQgV01MSW5wdXRFbGVtZW50 OjpkZXRhY2goKQpAQCAtMjQxLDggKzI3MiwxNCBAQCB2b2lkIFdNTElucHV0RWxlbWVudDo6ZGVm YXVsdEV2ZW50SGFuZGxlCiB7CiAgICAgYm9vbCBjbGlja0RlZmF1bHRGb3JtQnV0dG9uID0gZmFs c2U7CiAKLSAgICBpZiAoZXZ0LT50eXBlKCkgPT0gZXZlbnROYW1lcygpLnRleHRJbnB1dEV2ZW50 ICYmIGV2dC0+aXNUZXh0RXZlbnQoKSAmJiBzdGF0aWNfY2FzdDxUZXh0RXZlbnQqPihldnQpLT5k YXRhKCkgPT0gIlxuIikKLSAgICAgICAgY2xpY2tEZWZhdWx0Rm9ybUJ1dHRvbiA9IHRydWU7Cisg ICAgaWYgKGV2dC0+dHlwZSgpID09IGV2ZW50TmFtZXMoKS50ZXh0SW5wdXRFdmVudCAmJiBldnQt PmlzVGV4dEV2ZW50KCkpIHsKKyAgICAgICAgVGV4dEV2ZW50KiB0ZXh0RXZlbnQgPSBzdGF0aWNf Y2FzdDxUZXh0RXZlbnQqPihldnQpOworICAgICAgICBpZiAodGV4dEV2ZW50LT5kYXRhKCkgPT0g IlxuIikKKyAgICAgICAgICAgIGNsaWNrRGVmYXVsdEZvcm1CdXR0b24gPSB0cnVlOworICAgICAg ICBlbHNlIGlmIChyZW5kZXJlcigpICYmICFpc0NvbmZvcm1lZFRvSW5wdXRNYXNrKHRleHRFdmVu dC0+ZGF0YSgpWzBdLCBzdGF0aWNfY2FzdDxSZW5kZXJUZXh0Q29udHJvbCo+KHJlbmRlcmVyKCkp LT50ZXh0KCkubGVuZ3RoKCkgKyAxKSkKKyAgICAgICAgICAgIC8vIElmIHRoZSBpbnB1dGVkIGNo YXIgZG9lc24ndCBjb25mb3JtIHRvIHRoZSBpbnB1dCBtYXNrLCBzdG9wIGhhbmRsaW5nIAorICAg ICAgICAgICAgcmV0dXJuOworICAgIH0KIAogICAgIGlmIChldnQtPnR5cGUoKSA9PSBldmVudE5h bWVzKCkua2V5ZG93bkV2ZW50ICYmIGV2dC0+aXNLZXlib2FyZEV2ZW50KCkgJiYgZm9jdXNlZCgp ICYmIGRvY3VtZW50KCktPmZyYW1lKCkKICAgICAgICAgJiYgZG9jdW1lbnQoKS0+ZnJhbWUoKS0+ ZG9UZXh0RmllbGRDb21tYW5kRnJvbUV2ZW50KHRoaXMsIHN0YXRpY19jYXN0PEtleWJvYXJkRXZl bnQqPihldnQpKSkgewpAQCAtMzI3LDYgKzM2NCwxNjggQEAgdm9pZCBXTUxJbnB1dEVsZW1lbnQ6 OmRpZE1vdmVUb05ld093bmVyRAogICAgIFdNTEVsZW1lbnQ6OmRpZE1vdmVUb05ld093bmVyRG9j dW1lbnQoKTsKIH0KIAordm9pZCBXTUxJbnB1dEVsZW1lbnQ6OmluaXQoKQoreworICAgIFN0cmlu ZyBuYW1lVmFyaWFibGUgPSBuYW1lKCk7CisgICAgU3RyaW5nIHZhcmlhYmxlVmFsdWU7CisgICAg V01MUGFnZVN0YXRlKiBwYWdlU2F0ZSA9IHdtbFBhZ2VTdGF0ZUZvckRvY3VtZW50KGRvY3VtZW50 KCkpOyAKKyAgICBBU1NFUlQocGFnZVNhdGUpOworICAgIGlmICghbmFtZVZhcmlhYmxlLmlzRW1w dHkoKSkKKyAgICAgICAgdmFyaWFibGVWYWx1ZSA9IHBhZ2VTYXRlLT5nZXRWYXJpYWJsZShuYW1l VmFyaWFibGUpOworCisgICAgaWYgKHZhcmlhYmxlVmFsdWUuaXNFbXB0eSgpIHx8ICFpc0NvbmZv cm1lZFRvSW5wdXRNYXNrKHZhcmlhYmxlVmFsdWUpKSB7CisgICAgICAgIFN0cmluZyB2YWwgPSB2 YWx1ZSgpOworICAgICAgICBpZiAoaXNDb25mb3JtZWRUb0lucHV0TWFzayh2YWwpKQorICAgICAg ICAgICAgdmFyaWFibGVWYWx1ZSA9IHZhbDsKKyAgICAgICAgZWxzZQorICAgICAgICAgICAgdmFy aWFibGVWYWx1ZSA9ICIiOworIAorICAgICAgICBwYWdlU2F0ZS0+c3RvcmVWYXJpYWJsZShuYW1l VmFyaWFibGUsIHZhcmlhYmxlVmFsdWUpOworICAgIH0KKyAgICBzZXRWYWx1ZSh2YXJpYWJsZVZh bHVlKTsKKyAKKyAgICBpZiAoIWhhc0F0dHJpYnV0ZShXTUxOYW1lczo6ZW1wdHlva0F0dHIpKSB7 CisgICAgICAgIGlmIChtX2Zvcm1hdE1hc2suaXNFbXB0eSgpIHx8IAorICAgICAgICAgICAgLy8g Y2hlY2sgaWYgdGhlIGZvcm1hdCBjb2RlcyBpcyBqdXN0ICIqZiIKKyAgICAgICAgICAgKG1fZm9y bWF0TWFzay5sZW5ndGgoKSA9PSAyICYmIG1fZm9ybWF0TWFza1swXSA9PSAnKicgJiYgZm9ybWF0 Q29kZXMoKS5maW5kKG1fZm9ybWF0TWFza1sxXSkgIT0gLTEpKQorICAgICAgICAgICAgbV9pc0Vt cHR5T2sgPSB0cnVlOworICAgIH0KK30KKworU3RyaW5nIFdNTElucHV0RWxlbWVudDo6dmFsaWRh dGVJbnB1dE1hc2soY29uc3QgU3RyaW5nJiBpbnB1dE1hc2spCit7CisgICAgYm9vbCBpc1ZhbGlk ID0gdHJ1ZTsKKyAgICBib29sIGhhc1dpbGRjYXJkID0gZmFsc2U7CisgICAgdW5zaWduZWQgZXNj YXBlQ2hhckNvdW50ID0gMDsKKyAgICB1bnNpZ25lZCBtYXNrTGVuZ3RoID0gaW5wdXRNYXNrLmxl bmd0aCgpOworICAgIFVDaGFyIGZvcm1hdENvZGU7CisgCisgICAgZm9yICh1bnNpZ25lZCBpID0g MDsgaSA8IG1hc2tMZW5ndGg7ICsraSkgeworICAgICAgICBmb3JtYXRDb2RlID0gaW5wdXRNYXNr W2ldOworICAgICAgICBpZiAoZm9ybWF0Q29kZXMoKS5maW5kKGZvcm1hdENvZGUpID09IC0xKSB7 CisgICAgICAgICAgICBpZiAoZm9ybWF0Q29kZSA9PSAnKicgfHwgKFdURjo6aXNBU0NJSURpZ2l0 KGZvcm1hdENvZGUpICYmIGZvcm1hdENvZGUgIT0gJzAnKSkgeworICAgICAgICAgICAgICAgIC8v IHZhbGlkYXRlIGNvZGVzIHdoaWNoIGVuZHMgd2l0aCAnKmYnIG9yICduZicKKyAgICAgICAgICAg ICAgICBmb3JtYXRDb2RlID0gaW5wdXRNYXNrWysraV07CisgICAgICAgICAgICAgICAgaWYgKChp ICsgMSAhPSBtYXNrTGVuZ3RoKSB8fCBmb3JtYXRDb2RlcygpLmZpbmQoZm9ybWF0Q29kZSkgPT0g LTEpIHsKKyAgICAgICAgICAgICAgICAgICAgaXNWYWxpZCA9IGZhbHNlOworICAgICAgICAgICAg ICAgICAgICBicmVhazsKKyAgICAgICAgICAgICAgICB9CisgICAgICAgICAgICAgICAgaGFzV2ls ZGNhcmQgPSB0cnVlOworICAgICAgICAgICAgfSBlbHNlIGlmIChmb3JtYXRDb2RlID09ICdcXCcp IHsKKyAgICAgICAgICAgICAgICAvL3NraXAgb3ZlciB0aGUgbmV4dCBtYXNrIGNoYXJhY3Rlcgor ICAgICAgICAgICAgICAgICsraTsKKyAgICAgICAgICAgICAgICArK2VzY2FwZUNoYXJDb3VudDsK KyAgICAgICAgICAgIH0gZWxzZSB7CisgICAgICAgICAgICAgICAgaXNWYWxpZCA9IGZhbHNlOwor ICAgICAgICAgICAgICAgIGJyZWFrOworICAgICAgICAgICAgfQorICAgICAgICB9CisgICAgfQor CisgICAgaWYgKCFpc1ZhbGlkKQorICAgICAgICByZXR1cm4gU3RyaW5nKCk7CisgCisgICAgLy8g Y2FsY3VsYXRlIHRoZSBudW1iZXIgb2YgY2hhcmFjdGVycyBhbGxvd2VkIHRvIGJlIGVudGVyZWQg YnkgaW5wdXQgbWFzaworICAgIG1fbnVtT2ZDaGFyc0FsbG93ZWRCeU1hc2sgPSBtYXNrTGVuZ3Ro OworCisgICAgaWYgKGVzY2FwZUNoYXJDb3VudCkKKyAgICAgICAgbV9udW1PZkNoYXJzQWxsb3dl ZEJ5TWFzayAtPSBlc2NhcGVDaGFyQ291bnQ7CisKKyAgICBpZiAoaGFzV2lsZGNhcmQpIHsKKyAg ICAgICAgZm9ybWF0Q29kZSA9IGlucHV0TWFza1ttYXNrTGVuZ3RoIC0gMl07CisgICAgICAgIGlm IChmb3JtYXRDb2RlID09ICcqJykKKyAgICAgICAgICAgIG1fbnVtT2ZDaGFyc0FsbG93ZWRCeU1h c2sgPSBtX2RhdGEubWF4TGVuZ3RoKCk7CisgICAgICAgIGVsc2UgeworICAgICAgICAgICAgdW5z aWduZWQgbGVmdExlbiA9IFN0cmluZygmZm9ybWF0Q29kZSkudG9JbnQoKTsKKyAgICAgICAgICAg IG1fbnVtT2ZDaGFyc0FsbG93ZWRCeU1hc2sgPSBsZWZ0TGVuICsgbV9udW1PZkNoYXJzQWxsb3dl ZEJ5TWFzayAtIDI7CisgICAgICAgIH0KKyAgICB9CisKKyAgICByZXR1cm4gaW5wdXRNYXNrOwor fQorCitib29sIFdNTElucHV0RWxlbWVudDo6aXNDb25mb3JtZWRUb0lucHV0TWFzayhjb25zdCBT dHJpbmcmIGlucHV0Q2hhcnMpCit7CisgICAgZm9yICh1bnNpZ25lZCBpID0gMDsgaSA8IGlucHV0 Q2hhcnMubGVuZ3RoKCk7ICsraSkKKyAgICAgICAgaWYgKCFpc0NvbmZvcm1lZFRvSW5wdXRNYXNr KGlucHV0Q2hhcnNbaV0sIGkgKyAxLCBmYWxzZSkpCisgICAgICAgICAgICByZXR1cm4gZmFsc2U7 CisKKyAgICByZXR1cm4gdHJ1ZTsKK30KKyAKK2Jvb2wgV01MSW5wdXRFbGVtZW50Ojppc0NvbmZv cm1lZFRvSW5wdXRNYXNrKFVDaGFyIGluQ2hhciwgdW5zaWduZWQgaW5wdXRDaGFyQ291bnQsIGJv b2wgaXNVc2VySW5wdXQpCit7CisgICAgaWYgKG1fZm9ybWF0TWFzay5pc0VtcHR5KCkpCisgICAg ICAgIHJldHVybiB0cnVlOworIAorICAgIGlmIChpbnB1dENoYXJDb3VudCA+IG1fbnVtT2ZDaGFy c0FsbG93ZWRCeU1hc2spCisgICAgICAgIHJldHVybiBmYWxzZTsKKworICAgIHVuc2lnbmVkIG1h c2tJbmRleCA9IDA7CisgICAgaWYgKGlzVXNlcklucHV0KSB7CisgICAgICAgIHVuc2lnbmVkIGN1 cnNvclBvc2l0aW9uID0gMDsKKyAgICAgICAgaWYgKHJlbmRlcmVyKCkpCisgICAgICAgICAgICBj dXJzb3JQb3NpdGlvbiA9IHN0YXRpY19jYXN0PFJlbmRlclRleHRDb250cm9sKj4ocmVuZGVyZXIo KSktPnNlbGVjdGlvblN0YXJ0KCk7IAorICAgICAgICBlbHNlCisgICAgICAgICAgICBjdXJzb3JQ b3NpdGlvbiA9IG1fZGF0YS5jYWNoZWRTZWxlY3Rpb25TdGFydCgpOworCisgICAgICAgIG1hc2tJ bmRleCA9IGN1cnNvclBvc2l0aW9uVG9NYXNrSW5kZXgoY3Vyc29yUG9zaXRpb24pOworICAgIH0g ZWxzZQorICAgICAgICBtYXNrSW5kZXggPSBjdXJzb3JQb3NpdGlvblRvTWFza0luZGV4KGlucHV0 Q2hhckNvdW50IC0gMSk7CisKKyAgICBib29sIG9rID0gdHJ1ZTsKKyAgICBVQ2hhciBtYXNrID0g bV9mb3JtYXRNYXNrW21hc2tJbmRleF07CisgICAgLy8gbWF0Y2ggdGhlIGlucHV0ZWQgY2hhcmFj dGVyIHdpdGggaW5wdXQgbWFzaworICAgIHN3aXRjaCAobWFzaykgeworICAgIGNhc2UgJ0EnOgor ICAgICAgICBvayA9ICFXVEY6OmlzQVNDSUlEaWdpdChpbkNoYXIpICYmICFXVEY6OmlzQVNDSUlM b3dlcihpbkNoYXIpICYmIFdURjo6aXNBU0NJSVByaW50YWJsZShpbkNoYXIpOworICAgICAgICBi cmVhazsKKyAgICBjYXNlICdhJzoKKyAgICAgICAgb2sgPSAhV1RGOjppc0FTQ0lJRGlnaXQoaW5D aGFyKSAmJiAhV1RGOjppc0FTQ0lJVXBwZXIoaW5DaGFyKSAmJiBXVEY6OmlzQVNDSUlQcmludGFi bGUoaW5DaGFyKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSAnTic6CisgICAgICAgIG9rID0g V1RGOjppc0FTQ0lJRGlnaXQoaW5DaGFyKTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSAnbic6 CisgICAgICAgIG9rID0gIVdURjo6aXNBU0NJSUFscGhhKGluQ2hhcikgJiYgV1RGOjppc0FTQ0lJ UHJpbnRhYmxlKGluQ2hhcik7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgJ1gnOgorICAgICAg ICBvayA9ICFXVEY6OmlzQVNDSUlMb3dlcihpbkNoYXIpICYmIFdURjo6aXNBU0NJSVByaW50YWJs ZShpbkNoYXIpOworICAgICAgICBicmVhazsKKyAgICBjYXNlICd4JzoKKyAgICAgICAgb2sgPSAh V1RGOjppc0FTQ0lJVXBwZXIoaW5DaGFyKSAmJiBXVEY6OmlzQVNDSUlQcmludGFibGUoaW5DaGFy KTsKKyAgICAgICAgYnJlYWs7CisgICAgY2FzZSAnTSc6CisgICAgICAgIG9rID0gV1RGOjppc0FT Q0lJUHJpbnRhYmxlKGluQ2hhcik7CisgICAgICAgIGJyZWFrOworICAgIGNhc2UgJ20nOgorICAg ICAgICBvayA9IFdURjo6aXNBU0NJSVByaW50YWJsZShpbkNoYXIpOworICAgICAgICBicmVhazsK KyAgICBkZWZhdWx0OgorICAgICAgICBvayA9IChtYXNrID09IGluQ2hhcik7CisgICAgICAgIGJy ZWFrOworICAgIH0KKworICAgIHJldHVybiBvazsKK30KKwordW5zaWduZWQgV01MSW5wdXRFbGVt ZW50OjpjdXJzb3JQb3NpdGlvblRvTWFza0luZGV4KHVuc2lnbmVkIGN1cnNvclBvc2l0aW9uKQor eworICAgIFVDaGFyIG1hc2s7CisgICAgaW50IGluZGV4ID0gLTE7CisgICAgZG8geworICAgICAg ICBtYXNrID0gbV9mb3JtYXRNYXNrWysraW5kZXhdOworICAgICAgICBpZiAobWFzayA9PSAnXFwn KQorICAgICAgICAgICAgKytpbmRleDsKKyAgICAgICAgZWxzZSBpZiAobWFzayA9PSAnKicgfHwg KFdURjo6aXNBU0NJSURpZ2l0KG1hc2spICYmIG1hc2sgIT0gJzAnKSkgeworICAgICAgICAgICAg aW5kZXggPSBtX2Zvcm1hdE1hc2subGVuZ3RoKCkgLSAxOworICAgICAgICAgICAgYnJlYWs7Cisg ICAgICAgIH0KKyAgICB9IHdoaWxlIChjdXJzb3JQb3NpdGlvbi0tKTsKKyAKKyAgICByZXR1cm4g aW5kZXg7Cit9CisKIH0KIAogI2VuZGlmCkluZGV4OiBXZWJDb3JlL3dtbC9XTUxJbnB1dEVsZW1l bnQuaAo9PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09Ci0tLSBXZWJDb3JlL3dtbC9XTUxJbnB1dEVsZW1lbnQuaAkocmV2aXNp b24gNDAwODQpCisrKyBXZWJDb3JlL3dtbC9XTUxJbnB1dEVsZW1lbnQuaAkod29ya2luZyBjb3B5 KQpAQCAtODksMTAgKzg5LDIwIEBAIHB1YmxpYzoKICAgICB2aXJ0dWFsIHZvaWQgd2lsbE1vdmVU b05ld093bmVyRG9jdW1lbnQoKTsKICAgICB2aXJ0dWFsIHZvaWQgZGlkTW92ZVRvTmV3T3duZXJE b2N1bWVudCgpOwogCisgICAgYm9vbCBpc0NvbmZvcm1lZFRvSW5wdXRNYXNrKGNvbnN0IFN0cmlu ZyYpOworICAgIGJvb2wgaXNDb25mb3JtZWRUb0lucHV0TWFzayhVQ2hhciwgdW5zaWduZWQsIGJv b2wgaXNVc2VySW5wdXQgPSB0cnVlKTsKKwogcHJpdmF0ZToKKyAgICB2b2lkIGluaXQoKTsKKyAg ICBTdHJpbmcgdmFsaWRhdGVJbnB1dE1hc2soY29uc3QgU3RyaW5nJik7CisgICAgdW5zaWduZWQg Y3Vyc29yUG9zaXRpb25Ub01hc2tJbmRleCh1bnNpZ25lZCk7CisKICAgICBJbnB1dEVsZW1lbnRE YXRhIG1fZGF0YTsKICAgICBib29sIG1faXNQYXNzd29yZEZpZWxkOwogICAgIGJvb2wgbV92YWx1 ZU1hdGNoZXNSZW5kZXJlcjsKKyAgICBib29sIG1faXNFbXB0eU9rOworICAgIFN0cmluZyBtX2Zv cm1hdE1hc2s7CisgICAgdW5zaWduZWQgbV9udW1PZkNoYXJzQWxsb3dlZEJ5TWFzazsKIH07CiAK IH0KSW5kZXg6IExheW91dFRlc3RzL0NoYW5nZUxvZwo9PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09Ci0tLSBMYXlvdXRUZXN0 cy9DaGFuZ2VMb2cJKHJldmlzaW9uIDQwMjEyKQorKysgTGF5b3V0VGVzdHMvQ2hhbmdlTG9nCSh3 b3JraW5nIGNvcHkpCkBAIC0xLDMgKzEsMTQgQEAKKzIwMDktMDEtMjQgIFlpY2hhbyBZaW4gIDx5 aWNoYW8ueWluQHRvcmNobW9iaWxlLmNvbS5jbj4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JP RFkgKE9PUFMhKS4KKworICAgICAgICAqIHdtbC9pbnB1dC1mb3JtYXQtZXhwZWN0ZWQudHh0OiBB ZGRlZC4KKyAgICAgICAgKiB3bWwvaW5wdXQtZm9ybWF0Lmh0bWw6IEFkZGVkLgorICAgICAgICAq IHdtbC9yZXNvdXJjZXMvaW5wdXQtZm9ybWF0LmpzOiBBZGRlZC4KKyAgICAgICAgKHNldHVwVGVz dERvY3VtZW50KToKKyAgICAgICAgKHByZXBhcmVUZXN0KToKKyAgICAgICAgKGV4ZWN1dGVUZXN0 KToKKwogMjAwOS0wMS0yMyAgRXJpYyBDYXJsc29uICA8ZXJpYy5jYXJsc29uQGFwcGxlLmNvbT4K IAogICAgICAgICBSZXZpZXdlZCBieSBBZGVsZSBQZXRlcnNvbgpJbmRleDogTGF5b3V0VGVzdHMv d21sL2lucHV0LWZvcm1hdC1leHBlY3RlZC50eHQKPT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMv d21sL2lucHV0LWZvcm1hdC1leHBlY3RlZC50eHQJKHJldmlzaW9uIDApCisrKyBMYXlvdXRUZXN0 cy93bWwvaW5wdXQtZm9ybWF0LWV4cGVjdGVkLnR4dAkocmV2aXNpb24gMCkKQEAgLTAsMCArMSw1 MyBAQAorV01MIGxheW91dCB0ZXN0cyAtIHVzaW5nIFhIVE1MIHNjcmlwdGluZworCisKK1Rlc3Rz IGlucHV0IGZvcm1hdCB2YWxpZGF0aW9uCisKK09uIHN1Y2Nlc3MsIHlvdSB3aWxsIHNlZSBhIHNl cmllcyBvZiAiUEFTUyIgbWVzc2FnZXMsIGZvbGxvd2VkIGJ5ICJURVNUIENPTVBMRVRFIi4KKwor CitQQVNTIHBFbGVtZW50MS50ZXh0Q29udGVudCBpcyAiUmVzdWx0OiAkaW5wdXQxIgorUEFTUyBw RWxlbWVudDIudGV4dENvbnRlbnQgaXMgIlJlc3VsdDogJGlucHV0MiIKK1BBU1MgcEVsZW1lbnQz LnRleHRDb250ZW50IGlzICJSZXN1bHQ6ICRpbnB1dDMiCitQQVNTIHBFbGVtZW50NC50ZXh0Q29u dGVudCBpcyAiUmVzdWx0OiAkaW5wdXQ0IgorUEFTUyBwRWxlbWVudDUudGV4dENvbnRlbnQgaXMg IlJlc3VsdDogJGlucHV0NSIKK1BBU1MgcEVsZW1lbnQ2LnRleHRDb250ZW50IGlzICJSZXN1bHQ6 ICRpbnB1dDYiCitQQVNTIHBFbGVtZW50Ny50ZXh0Q29udGVudCBpcyAiUmVzdWx0OiAkaW5wdXQ3 IgorUEFTUyBwRWxlbWVudDgudGV4dENvbnRlbnQgaXMgIlJlc3VsdDogJGlucHV0OCIKK1BBU1Mg cEVsZW1lbnQ5LnRleHRDb250ZW50IGlzICJSZXN1bHQ6ICRpbnB1dDkiCitQQVNTIHBFbGVtZW50 MTAudGV4dENvbnRlbnQgaXMgIlJlc3VsdDogJGlucHV0MTAiCitQQVNTIHBFbGVtZW50MTEudGV4 dENvbnRlbnQgaXMgIlJlc3VsdDogJGlucHV0MTEiCitQQVNTIHBFbGVtZW50MTIudGV4dENvbnRl bnQgaXMgIlJlc3VsdDogJGlucHV0MTIiCitQQVNTIHBFbGVtZW50MS50ZXh0Q29udGVudCBpcyAi UmVzdWx0OiBUZVN0MC0wMSIKK1BBU1MgcEVsZW1lbnQyLnRleHRDb250ZW50IGlzICJSZXN1bHQ6 IFRlU3QwLTAyIgorUEFTUyBwRWxlbWVudDMudGV4dENvbnRlbnQgaXMgIlJlc3VsdDogVGVTdC0r MDMiCitQQVNTIHBFbGVtZW50NC50ZXh0Q29udGVudCBpcyAiUmVzdWx0OiBUZVN0MC0wNCIKK1BB U1MgcEVsZW1lbnQ1LnRleHRDb250ZW50IGlzICJSZXN1bHQ6IFRlU3QwLTA1IgorUEFTUyBwRWxl bWVudDYudGV4dENvbnRlbnQgaXMgIlJlc3VsdDogIgorUEFTUyBwRWxlbWVudDcudGV4dENvbnRl bnQgaXMgIlJlc3VsdDogIgorUEFTUyBwRWxlbWVudDgudGV4dENvbnRlbnQgaXMgIlJlc3VsdDog VGVTdDAtMDgiCitQQVNTIHBFbGVtZW50OS50ZXh0Q29udGVudCBpcyAiUmVzdWx0OiBUZVN0MC0w OSIKK1BBU1MgcEVsZW1lbnQxMC50ZXh0Q29udGVudCBpcyAiUmVzdWx0OiAwMTIzNDU2Nzg5Igor UEFTUyBwRWxlbWVudDExLnRleHRDb250ZW50IGlzICJSZXN1bHQ6IFRlU3QwLTExIgorUEFTUyBw RWxlbWVudDEyLnRleHRDb250ZW50IGlzICJSZXN1bHQ6IFRlU3QwLTEyIgorUEFTUyBzdWNjZXNz ZnVsbHlQYXJzZWQgaXMgdHJ1ZQorCitURVNUIENPTVBMRVRFCisKKworLS0tLS0tLS0KK0ZyYW1l OiAnPCEtLWZyYW1lUGF0aCAvLzwhLS1mcmFtZTAtLT4tLT4nCistLS0tLS0tLQorU3RhcnQgdGVz dAorUmVzdWx0OiBUZVN0MC0wMQorUmVzdWx0OiBUZVN0MC0wMgorUmVzdWx0OiBUZVN0LSswMwor UmVzdWx0OiBUZVN0MC0wNAorUmVzdWx0OiBUZVN0MC0wNQorUmVzdWx0OgorUmVzdWx0OgorUmVz dWx0OiBUZVN0MC0wOAorUmVzdWx0OiBUZVN0MC0wOQorUmVzdWx0OiAwMTIzNDU2Nzg5CitSZXN1 bHQ6IFRlU3QwLTExCitSZXN1bHQ6IFRlU3QwLTEyCkluZGV4OiBMYXlvdXRUZXN0cy93bWwvaW5w dXQtZm9ybWF0Lmh0bWwKPT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT09PT09PT09PT09PT09PQotLS0gTGF5b3V0VGVzdHMvd21sL2lucHV0LWZvcm1h dC5odG1sCShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvd21sL2lucHV0LWZvcm1hdC5odG1s CShyZXZpc2lvbiAwKQpAQCAtMCwwICsxLDE1IEBACis8IURPQ1RZUEUgSFRNTCBQVUJMSUMgIi0v L0lFVEYvL0RURCBIVE1MLy9FTiI+Cis8aHRtbD4KKzxoZWFkPgorPGxpbmsgcmVsPSJzdHlsZXNo ZWV0IiBocmVmPSIuLi9mYXN0L2pzL3Jlc291cmNlcy9qcy10ZXN0LXN0eWxlLmNzcyI+Cis8c2Ny aXB0PnZhciByZWxhdGl2ZVBhdGhUb0xheW91dFRlc3RzID0gIi4uIjs8L3NjcmlwdD4KKzxzY3Jp cHQgc3JjPSJyZXNvdXJjZXMvV01MVGVzdENhc2UuanMiPjwvc2NyaXB0PgorPHNjcmlwdCBzcmM9 Ii4uL2Zhc3QvanMvcmVzb3VyY2VzL2pzLXRlc3QtcHJlLmpzIj48L3NjcmlwdD4KKzwvaGVhZD4K Kzxib2R5PgorPGgxPldNTCBsYXlvdXQgdGVzdHMgLSB1c2luZyBYSFRNTCBzY3JpcHRpbmc8L2gx PgorPHAgaWQ9ImRlc2NyaXB0aW9uIj48L3A+Cis8ZGl2IGlkPSJjb25zb2xlIj48L2Rpdj4KKzxz Y3JpcHQgc3JjPSJyZXNvdXJjZXMvaW5wdXQtZm9ybWF0LmpzIj48L3NjcmlwdD4KKzwvYm9keT4K KzwvaHRtbD4KSW5kZXg6IExheW91dFRlc3RzL3dtbC9yZXNvdXJjZXMvaW5wdXQtZm9ybWF0Lmpz Cj09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09PT09 PT09PT09PT09PT0KLS0tIExheW91dFRlc3RzL3dtbC9yZXNvdXJjZXMvaW5wdXQtZm9ybWF0Lmpz CShyZXZpc2lvbiAwKQorKysgTGF5b3V0VGVzdHMvd21sL3Jlc291cmNlcy9pbnB1dC1mb3JtYXQu anMJKHJldmlzaW9uIDApCkBAIC0wLDAgKzEsMTg3IEBACisvLyBbTmFtZV0gaW5wdXQtZm9ybWF0 LmpzIAorCitjcmVhdGVXTUxUZXN0Q2FzZSgiVGVzdHMgaW5wdXQgZm9ybWF0IHZhbGlkYXRpb24i KTsKKwordmFyIHBFbGVtZW50MTsKK3ZhciBwRWxlbWVudDI7Cit2YXIgcEVsZW1lbnQzOwordmFy IHBFbGVtZW50NDsKK3ZhciBwRWxlbWVudDU7Cit2YXIgcEVsZW1lbnQ2OwordmFyIHBFbGVtZW50 NzsKK3ZhciBwRWxlbWVudDg7Cit2YXIgcEVsZW1lbnQ5OwordmFyIHBFbGVtZW50MTA7Cit2YXIg cEVsZW1lbnQxMTsKK3ZhciBwRWxlbWVudDEyOworCitmdW5jdGlvbiBzZXR1cFRlc3REb2N1bWVu dCgpIHsKKyAgICB2YXIgY2FyZEVsZW1lbnQgPSB0ZXN0RG9jdW1lbnQuZG9jdW1lbnRFbGVtZW50 LmZpcnN0Q2hpbGQ7CisKKyAgICB2YXIgYW5jaG9yRWxlbWVudCA9IGNyZWF0ZVdNTEVsZW1lbnQo ImFuY2hvciIpOworICAgIGFuY2hvckVsZW1lbnQuYXBwZW5kQ2hpbGQodGVzdERvY3VtZW50LmNy ZWF0ZVRleHROb2RlKCJTdGFydCB0ZXN0IikpOworICAgIGNhcmRFbGVtZW50LmFwcGVuZENoaWxk KGFuY2hvckVsZW1lbnQpOworCisgICAgdmFyIHJlZnJlc2hFbGVtZW50ID0gY3JlYXRlV01MRWxl bWVudCgicmVmcmVzaCIpOworICAgIGFuY2hvckVsZW1lbnQuYXBwZW5kQ2hpbGQocmVmcmVzaEVs ZW1lbnQpOworCisgICAgLy8gVGVzdCBjYXNlcyBmb3Igc3VjY2Vzc2Z1bCBtYXRjaGluZywgdGhl ICd2YWx1ZScgY2FuIGRpc3BsYXkgY29ycmVjbHR5CisgICAgdmFyIGlucHV0RWxlbWVudDEgPSBj cmVhdGVXTUxFbGVtZW50KCJpbnB1dCIpOworICAgIGlucHV0RWxlbWVudDEuc2V0QXR0cmlidXRl KCJuYW1lIiwgImlucHV0MSIpOworICAgIGlucHV0RWxlbWVudDEuc2V0QXR0cmlidXRlKCJ2YWx1 ZSIsICJUZVN0MC0wMSIpOworICAgIGlucHV0RWxlbWVudDEuc2V0QXR0cmlidXRlKCJmb3JtYXQi LCAiQWFYeE1tTm4iKTsKKyAgICBjYXJkRWxlbWVudC5hcHBlbmRDaGlsZChpbnB1dEVsZW1lbnQx KTsKKworICAgIHZhciBpbnB1dEVsZW1lbnQyID0gY3JlYXRlV01MRWxlbWVudCgiaW5wdXQiKTsK KyAgICBpbnB1dEVsZW1lbnQyLnNldEF0dHJpYnV0ZSgibmFtZSIsICJpbnB1dDIiKTsKKyAgICBp bnB1dEVsZW1lbnQyLnNldEF0dHJpYnV0ZSgidmFsdWUiLCAiVGVTdDAtMDIiKTsKKyAgICBpbnB1 dEVsZW1lbnQyLnNldEF0dHJpYnV0ZSgiZm9ybWF0IiwgIkFhWHhuXC0yTiIpOworICAgIGNhcmRF bGVtZW50LmFwcGVuZENoaWxkKGlucHV0RWxlbWVudDIpOworCisgICAgdmFyIGlucHV0RWxlbWVu dDMgPSBjcmVhdGVXTUxFbGVtZW50KCJpbnB1dCIpOworICAgIGlucHV0RWxlbWVudDMuc2V0QXR0 cmlidXRlKCJuYW1lIiwgImlucHV0MyIpOworICAgIGlucHV0RWxlbWVudDMuc2V0QXR0cmlidXRl KCJ2YWx1ZSIsICJUZVN0LSswMyIpOworICAgIGlucHV0RWxlbWVudDMuc2V0QXR0cmlidXRlKCJm b3JtYXQiLCAiQWFYeFwtXCtuTiIpOworICAgIGNhcmRFbGVtZW50LmFwcGVuZENoaWxkKGlucHV0 RWxlbWVudDMpOworCisgICAgdmFyIGlucHV0RWxlbWVudDQgPSBjcmVhdGVXTUxFbGVtZW50KCJp bnB1dCIpOworICAgIGlucHV0RWxlbWVudDQuc2V0QXR0cmlidXRlKCJuYW1lIiwgImlucHV0NCIp OworICAgIGlucHV0RWxlbWVudDQuc2V0QXR0cmlidXRlKCJ2YWx1ZSIsICJUZVN0MC0wNCIpOwor ICAgIGlucHV0RWxlbWVudDQuc2V0QXR0cmlidXRlKCJmb3JtYXQiLCAiKm0iKTsKKyAgICBjYXJk RWxlbWVudC5hcHBlbmRDaGlsZChpbnB1dEVsZW1lbnQ0KTsKKworICAgIHZhciBpbnB1dEVsZW1l bnQ1ID0gY3JlYXRlV01MRWxlbWVudCgiaW5wdXQiKTsKKyAgICBpbnB1dEVsZW1lbnQ1LnNldEF0 dHJpYnV0ZSgibmFtZSIsICJpbnB1dDUiKTsKKyAgICBpbnB1dEVsZW1lbnQ1LnNldEF0dHJpYnV0 ZSgidmFsdWUiLCAiVGVTdDAtMDUiKTsKKyAgICBpbnB1dEVsZW1lbnQ1LnNldEF0dHJpYnV0ZSgi Zm9ybWF0IiwgIlhhbSp4Iik7CisgICAgY2FyZEVsZW1lbnQuYXBwZW5kQ2hpbGQoaW5wdXRFbGVt ZW50NSk7CisKKyAgICAvLyBUZXN0IGNhc2VzIGZvciBmYWlsZWQgbWF0Y2hpbmcsIGlmIGZhaWxl ZCwgdGhlICd2YWx1ZScgc2hvdWxkIGJlIHNldCB0byBlbXB0eQorICAgIHZhciBpbnB1dEVsZW1l bnQ2ID0gY3JlYXRlV01MRWxlbWVudCgiaW5wdXQiKTsKKyAgICBpbnB1dEVsZW1lbnQ2LnNldEF0 dHJpYnV0ZSgibmFtZSIsICJpbnB1dDYiKTsKKyAgICBpbnB1dEVsZW1lbnQ2LnNldEF0dHJpYnV0 ZSgidmFsdWUiLCAiVGVTdDAtMDYiKTsKKyAgICBpbnB1dEVsZW1lbnQ2LnNldEF0dHJpYnV0ZSgi Zm9ybWF0IiwgIk1hWHhhM24iKTsKKyAgICBjYXJkRWxlbWVudC5hcHBlbmRDaGlsZChpbnB1dEVs ZW1lbnQ2KTsKKyAKKyAgICB2YXIgaW5wdXRFbGVtZW50NyA9IGNyZWF0ZVdNTEVsZW1lbnQoImlu cHV0Iik7CisgICAgaW5wdXRFbGVtZW50Ny5zZXRBdHRyaWJ1dGUoIm5hbWUiLCAiaW5wdXQ3Iik7 CisgICAgaW5wdXRFbGVtZW50Ny5zZXRBdHRyaWJ1dGUoInZhbHVlIiwgIlRlU3QwLTA3Iik7Cisg ICAgaW5wdXRFbGVtZW50Ny5zZXRBdHRyaWJ1dGUoImZvcm1hdCIsICJhYXh4bW1ubiIpOworICAg IGNhcmRFbGVtZW50LmFwcGVuZENoaWxkKGlucHV0RWxlbWVudDcpOworCisgICAgLy8gVGVzdCBj YXNlcyBmb3IgaW52YWxpZCBpbnB1dCBtYXNrIHdoaWNoIHNob3VsZCBiZSBpZ25vcmVkLCAKKyAg ICAvLyBhbmQgdGhlICd2YWx1ZScgY2FuIGRpc3BsYXkgY29ycmVjbHR5CisgICAgdmFyIGlucHV0 RWxlbWVudDggPSBjcmVhdGVXTUxFbGVtZW50KCJpbnB1dCIpOworICAgIGlucHV0RWxlbWVudDgu c2V0QXR0cmlidXRlKCJuYW1lIiwgImlucHV0OCIpOworICAgIGlucHV0RWxlbWVudDguc2V0QXR0 cmlidXRlKCJ2YWx1ZSIsICJUZVN0MC0wOCIpOworICAgIGlucHV0RWxlbWVudDguc2V0QXR0cmli dXRlKCJmb3JtYXQiLCAiVGVTdDAwMDgiKTsKKyAgICBjYXJkRWxlbWVudC5hcHBlbmRDaGlsZChp bnB1dEVsZW1lbnQ4KTsKKworICAgIHZhciBpbnB1dEVsZW1lbnQ5ID0gY3JlYXRlV01MRWxlbWVu dCgiaW5wdXQiKTsKKyAgICBpbnB1dEVsZW1lbnQ5LnNldEF0dHJpYnV0ZSgibmFtZSIsICJpbnB1 dDkiKTsKKyAgICBpbnB1dEVsZW1lbnQ5LnNldEF0dHJpYnV0ZSgidmFsdWUiLCAiVGVTdDAtMDki KTsKKyAgICBpbnB1dEVsZW1lbnQ5LnNldEF0dHJpYnV0ZSgiZm9ybWF0IiwgIk1NTU1NTU1NMG4i KTsKKyAgICBjYXJkRWxlbWVudC5hcHBlbmRDaGlsZChpbnB1dEVsZW1lbnQ5KTsKKworICAgIHZh ciBpbnB1dEVsZW1lbnQxMCA9IGNyZWF0ZVdNTEVsZW1lbnQoImlucHV0Iik7CisgICAgaW5wdXRF bGVtZW50MTAuc2V0QXR0cmlidXRlKCJuYW1lIiwgImlucHV0MTAiKTsKKyAgICBpbnB1dEVsZW1l bnQxMC5zZXRBdHRyaWJ1dGUoInZhbHVlIiwgIjAxMjM0NTY3ODkiKTsKKyAgICBpbnB1dEVsZW1l bnQxMC5zZXRBdHRyaWJ1dGUoImZvcm1hdCIsICIxMG4iKTsKKyAgICBjYXJkRWxlbWVudC5hcHBl bmRDaGlsZChpbnB1dEVsZW1lbnQxMCk7CisKKyAgICB2YXIgaW5wdXRFbGVtZW50MTEgPSBjcmVh dGVXTUxFbGVtZW50KCJpbnB1dCIpOworICAgIGlucHV0RWxlbWVudDExLnNldEF0dHJpYnV0ZSgi bmFtZSIsICJpbnB1dDExIik7CisgICAgaW5wdXRFbGVtZW50MTEuc2V0QXR0cmlidXRlKCJ2YWx1 ZSIsICJUZVN0MC0xMSIpOworICAgIGlucHV0RWxlbWVudDExLnNldEF0dHJpYnV0ZSgiZm9ybWF0 IiwgIipBTU1NTU1NIik7CisgICAgY2FyZEVsZW1lbnQuYXBwZW5kQ2hpbGQoaW5wdXRFbGVtZW50 MTEpOworCisgICAgdmFyIGlucHV0RWxlbWVudDEyPSBjcmVhdGVXTUxFbGVtZW50KCJpbnB1dCIp OworICAgIGlucHV0RWxlbWVudDEyLnNldEF0dHJpYnV0ZSgibmFtZSIsICJpbnB1dDEyIik7Cisg ICAgaW5wdXRFbGVtZW50MTIuc2V0QXR0cmlidXRlKCJ2YWx1ZSIsICJUZVN0MC0xMiIpOworICAg IGlucHV0RWxlbWVudDEyLnNldEF0dHJpYnV0ZSgiZm9ybWF0IiwgIk0qYSpNIik7CisgICAgY2Fy ZEVsZW1lbnQuYXBwZW5kQ2hpbGQoaW5wdXRFbGVtZW50MTIpOworCisgICAgcEVsZW1lbnQxID0g Y3JlYXRlV01MRWxlbWVudCgicCIpOworICAgIHBFbGVtZW50MS50ZXh0Q29udGVudCA9ICJSZXN1 bHQ6ICRpbnB1dDEiOworICAgIGNhcmRFbGVtZW50LmFwcGVuZENoaWxkKHBFbGVtZW50MSk7CisK KyAgICBwRWxlbWVudDIgPSBjcmVhdGVXTUxFbGVtZW50KCJwIik7CisgICAgcEVsZW1lbnQyLnRl eHRDb250ZW50ID0gIlJlc3VsdDogJGlucHV0MiI7CisgICAgY2FyZEVsZW1lbnQuYXBwZW5kQ2hp bGQocEVsZW1lbnQyKTsKKworICAgIHBFbGVtZW50MyA9IGNyZWF0ZVdNTEVsZW1lbnQoInAiKTsK KyAgICBwRWxlbWVudDMudGV4dENvbnRlbnQgPSAiUmVzdWx0OiAkaW5wdXQzIjsKKyAgICBjYXJk RWxlbWVudC5hcHBlbmRDaGlsZChwRWxlbWVudDMpOworCisgICAgcEVsZW1lbnQ0ID0gY3JlYXRl V01MRWxlbWVudCgicCIpOworICAgIHBFbGVtZW50NC50ZXh0Q29udGVudCA9ICJSZXN1bHQ6ICRp bnB1dDQiOworICAgIGNhcmRFbGVtZW50LmFwcGVuZENoaWxkKHBFbGVtZW50NCk7CisKKyAgICBw RWxlbWVudDUgPSBjcmVhdGVXTUxFbGVtZW50KCJwIik7CisgICAgcEVsZW1lbnQ1LnRleHRDb250 ZW50ID0gIlJlc3VsdDogJGlucHV0NSI7CisgICAgY2FyZEVsZW1lbnQuYXBwZW5kQ2hpbGQocEVs ZW1lbnQ1KTsKKworICAgIHBFbGVtZW50NiA9IGNyZWF0ZVdNTEVsZW1lbnQoInAiKTsKKyAgICBw RWxlbWVudDYudGV4dENvbnRlbnQgPSAiUmVzdWx0OiAkaW5wdXQ2IjsKKyAgICBjYXJkRWxlbWVu dC5hcHBlbmRDaGlsZChwRWxlbWVudDYpOworCisgICAgcEVsZW1lbnQ3ID0gY3JlYXRlV01MRWxl bWVudCgicCIpOworICAgIHBFbGVtZW50Ny50ZXh0Q29udGVudCA9ICJSZXN1bHQ6ICRpbnB1dDci OworICAgIGNhcmRFbGVtZW50LmFwcGVuZENoaWxkKHBFbGVtZW50Nyk7CisKKyAgICBwRWxlbWVu dDggPSBjcmVhdGVXTUxFbGVtZW50KCJwIik7CisgICAgcEVsZW1lbnQ4LnRleHRDb250ZW50ID0g IlJlc3VsdDogJGlucHV0OCI7CisgICAgY2FyZEVsZW1lbnQuYXBwZW5kQ2hpbGQocEVsZW1lbnQ4 KTsKKworICAgIHBFbGVtZW50OSA9IGNyZWF0ZVdNTEVsZW1lbnQoInAiKTsKKyAgICBwRWxlbWVu dDkudGV4dENvbnRlbnQgPSAiUmVzdWx0OiAkaW5wdXQ5IjsKKyAgICBjYXJkRWxlbWVudC5hcHBl bmRDaGlsZChwRWxlbWVudDkpOworCisgICAgcEVsZW1lbnQxMCA9IGNyZWF0ZVdNTEVsZW1lbnQo InAiKTsKKyAgICBwRWxlbWVudDEwLnRleHRDb250ZW50ID0gIlJlc3VsdDogJGlucHV0MTAiOwor ICAgIGNhcmRFbGVtZW50LmFwcGVuZENoaWxkKHBFbGVtZW50MTApOworCisgICAgcEVsZW1lbnQx MSA9IGNyZWF0ZVdNTEVsZW1lbnQoInAiKTsKKyAgICBwRWxlbWVudDExLnRleHRDb250ZW50ID0g IlJlc3VsdDogJGlucHV0MTEiOworICAgIGNhcmRFbGVtZW50LmFwcGVuZENoaWxkKHBFbGVtZW50 MTEpOworCisgICAgcEVsZW1lbnQxMiA9IGNyZWF0ZVdNTEVsZW1lbnQoInAiKTsKKyAgICBwRWxl bWVudDEyLnRleHRDb250ZW50ID0gIlJlc3VsdDogJGlucHV0MTIiOworICAgIGNhcmRFbGVtZW50 LmFwcGVuZENoaWxkKHBFbGVtZW50MTIpOworfQorCitmdW5jdGlvbiBwcmVwYXJlVGVzdCgpIHsK KyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoInBFbGVtZW50MS50ZXh0Q29udGVudCIsICJSZXN1 bHQ6ICRpbnB1dDEiKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoInBFbGVtZW50Mi50ZXh0 Q29udGVudCIsICJSZXN1bHQ6ICRpbnB1dDIiKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmco InBFbGVtZW50My50ZXh0Q29udGVudCIsICJSZXN1bHQ6ICRpbnB1dDMiKTsKKyAgICBzaG91bGRC ZUVxdWFsVG9TdHJpbmcoInBFbGVtZW50NC50ZXh0Q29udGVudCIsICJSZXN1bHQ6ICRpbnB1dDQi KTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoInBFbGVtZW50NS50ZXh0Q29udGVudCIsICJS ZXN1bHQ6ICRpbnB1dDUiKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoInBFbGVtZW50Ni50 ZXh0Q29udGVudCIsICJSZXN1bHQ6ICRpbnB1dDYiKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJp bmcoInBFbGVtZW50Ny50ZXh0Q29udGVudCIsICJSZXN1bHQ6ICRpbnB1dDciKTsKKyAgICBzaG91 bGRCZUVxdWFsVG9TdHJpbmcoInBFbGVtZW50OC50ZXh0Q29udGVudCIsICJSZXN1bHQ6ICRpbnB1 dDgiKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoInBFbGVtZW50OS50ZXh0Q29udGVudCIs ICJSZXN1bHQ6ICRpbnB1dDkiKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoInBFbGVtZW50 MTAudGV4dENvbnRlbnQiLCAiUmVzdWx0OiAkaW5wdXQxMCIpOworICAgIHNob3VsZEJlRXF1YWxU b1N0cmluZygicEVsZW1lbnQxMS50ZXh0Q29udGVudCIsICJSZXN1bHQ6ICRpbnB1dDExIik7Cisg ICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCJwRWxlbWVudDEyLnRleHRDb250ZW50IiwgIlJlc3Vs dDogJGlucHV0MTIiKTsKKworICAgIHN0YXJ0VGVzdCgyNSwgMTUpOworfQorCitmdW5jdGlvbiBl eGVjdXRlVGVzdCgpIHsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoInBFbGVtZW50MS50ZXh0 Q29udGVudCIsICJSZXN1bHQ6IFRlU3QwLTAxIik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5n KCJwRWxlbWVudDIudGV4dENvbnRlbnQiLCAiUmVzdWx0OiBUZVN0MC0wMiIpOworICAgIHNob3Vs ZEJlRXF1YWxUb1N0cmluZygicEVsZW1lbnQzLnRleHRDb250ZW50IiwgIlJlc3VsdDogVGVTdC0r MDMiKTsKKyAgICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoInBFbGVtZW50NC50ZXh0Q29udGVudCIs ICJSZXN1bHQ6IFRlU3QwLTA0Iik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCJwRWxlbWVu dDUudGV4dENvbnRlbnQiLCAiUmVzdWx0OiBUZVN0MC0wNSIpOworICAgIHNob3VsZEJlRXF1YWxU b1N0cmluZygicEVsZW1lbnQ2LnRleHRDb250ZW50IiwgIlJlc3VsdDogIik7CisgICAgc2hvdWxk QmVFcXVhbFRvU3RyaW5nKCJwRWxlbWVudDcudGV4dENvbnRlbnQiLCAiUmVzdWx0OiAiKTsKKyAg ICBzaG91bGRCZUVxdWFsVG9TdHJpbmcoInBFbGVtZW50OC50ZXh0Q29udGVudCIsICJSZXN1bHQ6 IFRlU3QwLTA4Iik7CisgICAgc2hvdWxkQmVFcXVhbFRvU3RyaW5nKCJwRWxlbWVudDkudGV4dENv bnRlbnQiLCAiUmVzdWx0OiBUZVN0MC0wOSIpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygi cEVsZW1lbnQxMC50ZXh0Q29udGVudCIsICJSZXN1bHQ6IDAxMjM0NTY3ODkiKTsKKyAgICBzaG91 bGRCZUVxdWFsVG9TdHJpbmcoInBFbGVtZW50MTEudGV4dENvbnRlbnQiLCAiUmVzdWx0OiBUZVN0 MC0xMSIpOworICAgIHNob3VsZEJlRXF1YWxUb1N0cmluZygicEVsZW1lbnQxMi50ZXh0Q29udGVu dCIsICJSZXN1bHQ6IFRlU3QwLTEyIik7CisKKyAgICBjb21wbGV0ZVRlc3QoKTsKK30KKwordmFy IHN1Y2Nlc3NmdWxseVBhcnNlZCA9IHRydWU7Cg==