203898 2019-11-06 06:23:21 -0800 Add FuzzerAgent that reads predictions from a file 2022-02-12 19:49:45 -0800 1 1 1 Unclassified WebKit JavaScriptCore Other Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 1 tuomas.webkit webkit-unassigned commit-queue ews-watchlist keith_miller mark.lam msaboff saam tuomas.webkit tzagallo webkit-bug-importer ysuzuki oldest_to_newest 1587759 0 tuomas.webkit 2019-11-06 06:23:21 -0800 Add FuzzerAgent that reads predictions from a file 1587760 1 382922 tuomas.webkit 2019-11-06 06:28:53 -0800 Created attachment 382922 proposed patch 1588400 2 382922 saam 2019-11-07 14:11:06 -0800 Comment on attachment 382922 proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=382922&action=review > Source/JavaScriptCore/runtime/FileBasedFuzzerAgent.cpp:59 > + BytecodeIndex bytecodeIndex = codeOrigin.bytecodeIndex(); > + codeBlock->expressionRangeForBytecodeIndex(bytecodeIndex, divot, startOffset, endOffset, line, column); I think you need to handle inline call frames here, right? 1588408 3 382922 saam 2019-11-07 14:21:28 -0800 Comment on attachment 382922 proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=382922&action=review > Source/JavaScriptCore/ChangeLog:7 > + you should describe the details of what this patch is doing here. > Source/JavaScriptCore/runtime/FileBasedFuzzerAgent.cpp:167 > +String FileBasedFuzzerAgent::createLookupKey(const String& sourceFilename, OpcodeID opcodeId, int startLocation, int endLocation) > +{ > + StringBuilder lookupKey; > + lookupKey.append(sourceFilename); > + lookupKey.append("|"); > + lookupKey.append(toString(opcodeAliasForLookupKey(opcodeId))); > + lookupKey.append("|"); > + lookupKey.append(startLocation); > + lookupKey.append("|"); > + lookupKey.append(endLocation); > + return lookupKey.toString(); > +} nit: This is slightly hokey. We tend to define a struct for hash map keys, and use a custom hash and equality function. Turning it into a String is convenient, but slightly weird. I guess since we don't care about perf, maybe this is ok. > Source/JavaScriptCore/runtime/FuzzerPredictions.cpp:50 > + while ((line = fgets(buffer, sizeof(buffer), f))) { > + SpeculatedType prediction; > + char lookupKey[BUFSIZ]; > + int numberOfItemsFound = sscanf(line, "%[^:]:%llx\n", lookupKey, &prediction); > + RELEASE_ASSERT(numberOfItemsFound == 2); > + const String& functionNameString = String(lookupKey, strlen(lookupKey)); > + m_predictions.set(functionNameString, prediction); > + } can you comment on the format of this file? Also, how do you produce this file? > Source/JavaScriptCore/runtime/FuzzerPredictions.cpp:61 > + RELEASE_ASSERT((predicted & SpecFullTop) != SpecNone); why can't we sometimes produce SpecNone? > Source/JavaScriptCore/runtime/FuzzerPredictions.h:32 > +#define NO_PREDICTION_FOUND 1ull << 55 Why does this work? This seems slightly wrong. Maybe we should just fall back to random fuzzer when we don't have the key? 1588569 4 tuomas.webkit 2019-11-07 21:57:14 -0800 (In reply to Saam Barati from comment #3) > Comment on attachment 382922 [details] > proposed patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=382922&action=review > > Source/JavaScriptCore/runtime/FuzzerPredictions.cpp:61 > > + RELEASE_ASSERT((predicted & SpecFullTop) != SpecNone); > > why can't we sometimes produce SpecNone? I had some issues with the fuzzer producing a predictions file that was parsed wrong which resulted in a predictions of SpecNone when I hadn't intended it. And currently the fuzzer never produces SpecNone. I should rework this. And if I keep this check I should move it to where the file is read in. > > Source/JavaScriptCore/runtime/FuzzerPredictions.h:32 > > +#define NO_PREDICTION_FOUND 1ull << 55 > > Why does this work? This seems slightly wrong. I just picked something larger than SpecDataViewObject (1<<42) and I made it a lot larger in case there are other speculated types added later on. I would like to detect the case of no prediction being found. What would be a good way to let the FuzzerAgent know that no prediction was found? > Maybe we should just fall back to random fuzzer when we don't have the key? I want to detect when I have a missing key for sanity checking purposes, and if we were to fall back to random predictions in this case I would to it in the FuzzerAgent rather than in FuzzerPredictions. One idea behind reading predictions from a file is to make the predictions stabler, that's why it's returning the original prediction when none is found rather than a random one. 1588611 5 tuomas.webkit 2019-11-08 06:00:30 -0800 (In reply to Saam Barati from comment #3) > Comment on attachment 382922 [details] > proposed patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=382922&action=review > > > Source/JavaScriptCore/ChangeLog:7 > > + > > you should describe the details of what this patch is doing here. I'll add a description for this. > > Source/JavaScriptCore/runtime/FuzzerPredictions.cpp:50 > > + while ((line = fgets(buffer, sizeof(buffer), f))) { > > + SpeculatedType prediction; > > + char lookupKey[BUFSIZ]; > > + int numberOfItemsFound = sscanf(line, "%[^:]:%llx\n", lookupKey, &prediction); > > + RELEASE_ASSERT(numberOfItemsFound == 2); > > + const String& functionNameString = String(lookupKey, strlen(lookupKey)); > > + m_predictions.set(functionNameString, prediction); > > + } > > can you comment on the format of this file? > > Also, how do you produce this file? I'll add a comment describing the format. The file is produced by the fuzzer, which is not part of the WebKit repo. > > Source/JavaScriptCore/runtime/FileBasedFuzzerAgent.cpp:167 > > +String FileBasedFuzzerAgent::createLookupKey(const String& sourceFilename, OpcodeID opcodeId, int startLocation, int endLocation) > > +{ > > + StringBuilder lookupKey; > > + lookupKey.append(sourceFilename); > > + lookupKey.append("|"); > > + lookupKey.append(toString(opcodeAliasForLookupKey(opcodeId))); > > + lookupKey.append("|"); > > + lookupKey.append(startLocation); > > + lookupKey.append("|"); > > + lookupKey.append(endLocation); > > + return lookupKey.toString(); > > +} > > nit: This is slightly hokey. We tend to define a struct for hash map keys, > and use a custom hash and equality function. Turning it into a String is > convenient, but slightly weird. I guess since we don't care about perf, > maybe this is ok. I figured since this is only for fuzzing I wouldn't spend too much effort on parsing the config file. The string here matches the format of the file containing the predictions, which I will document. 1588612 6 tuomas.webkit 2019-11-08 06:01:14 -0800 (In reply to Saam Barati from comment #2) > Comment on attachment 382922 [details] > proposed patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=382922&action=review > > > Source/JavaScriptCore/runtime/FileBasedFuzzerAgent.cpp:59 > > + BytecodeIndex bytecodeIndex = codeOrigin.bytecodeIndex(); > > + codeBlock->expressionRangeForBytecodeIndex(bytecodeIndex, divot, startOffset, endOffset, line, column); > > I think you need to handle inline call frames here, right? Yeah. I have to study the whole concept and I will post an updated patch once I understand it better. 1589836 7 383452 tuomas.webkit 2019-11-13 06:28:56 -0800 Created attachment 383452 update patch updated patch that addresses the concerns from the review. 1589838 8 tuomas.webkit 2019-11-13 06:30:43 -0800 (In reply to Saam Barati from comment #2) > Comment on attachment 382922 [details] > proposed patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=382922&action=review > > > Source/JavaScriptCore/runtime/FileBasedFuzzerAgent.cpp:59 > > + BytecodeIndex bytecodeIndex = codeOrigin.bytecodeIndex(); > > + codeBlock->expressionRangeForBytecodeIndex(bytecodeIndex, divot, startOffset, endOffset, line, column); > > I think you need to handle inline call frames here, right? As discussed offline, it turns out that codeBlock->expressionRangeForBytecodeIndex(codeOrigin.bytecodeIndex()) returns the correct source range even for inline call frames. 1590210 9 383545 tuomas.webkit 2019-11-13 23:52:45 -0800 Created attachment 383545 proposed patch adds a second FuzzerAgent that can be used to generate the prediction files. 1591118 10 383545 saam 2019-11-18 11:02:48 -0800 Comment on attachment 383545 proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=383545&action=review > Source/JavaScriptCore/runtime/FileBasedFuzzerAgent.cpp:79 > + // FIXME: these can not be targeted at all due to the bugs below style nit: indentation should be four spaces to the left > Source/JavaScriptCore/runtime/FileBasedFuzzerAgent.cpp:85 > + // FIXME: the output of codeBlock->expressionRangeForBytecodeIndex() allows for some of > + // these opcodes to have predictions, but not all instances can be reliably targeted. style nit: indentation should be four spaces to the left > Source/JavaScriptCore/runtime/FuzzerPredictions.cpp:49 > + size_t length = strlen(line); > + if (line[length - 1] == '\n') { > + line[length - 1] = '\0'; > + length--; > + } this processing might be nicer if you just read the entire file into a WTF string, which has a split function > Source/JavaScriptCore/runtime/PredictionFileCreatingFuzzerAgent.cpp:95 > + default: > + RELEASE_ASSERT_WITH_MESSAGE(false, "unhandled opcode: %s", toString(opcodeId).utf8().data()); why so few opcodes above? 1591126 11 383545 saam 2019-11-18 11:12:20 -0800 Comment on attachment 383545 proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=383545&action=review >> Source/JavaScriptCore/runtime/PredictionFileCreatingFuzzerAgent.cpp:95 >> + RELEASE_ASSERT_WITH_MESSAGE(false, "unhandled opcode: %s", toString(opcodeId).utf8().data()); > > why so few opcodes above? never mind, these are just opcodes with heap predictions. Is still seems like we should just include all opcodes unconditionally since anytime someone adds a new opcode with a heap prediction, they'll need to fill in a case in this switch statement. However, we don't do anything special for different opcodes. 1591130 12 383545 saam 2019-11-18 11:14:44 -0800 Comment on attachment 383545 proposed patch r=me 1591134 13 tuomas.webkit 2019-11-18 11:22:21 -0800 (In reply to Saam Barati from comment #11) > Comment on attachment 383545 [details] > proposed patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=383545&action=review > > >> Source/JavaScriptCore/runtime/PredictionFileCreatingFuzzerAgent.cpp:95 > >> + RELEASE_ASSERT_WITH_MESSAGE(false, "unhandled opcode: %s", toString(opcodeId).utf8().data()); > > > > why so few opcodes above? > > never mind, these are just opcodes with heap predictions. Is still seems > like we should just include all opcodes unconditionally since anytime > someone adds a new opcode with a heap prediction, they'll need to fill in a > case in this switch statement. However, we don't do anything special for > different opcodes. I want to map the JavaScript source code to the opcode and prediction. Therefore I want to know which opcodes occur, and what the source range is for those opcodes, and 1) It turned out that there were bugs in getting the source range for a number of opcodes 2) I need code in the fuzzer to target a specific prediction location. If someone adds a new opcode that has a heap prediction, this FuzzerAgent will crash and that’s how I will immediately find out about the opcode and I’ll be able to add code to handle it. 1591510 14 383865 tuomas.webkit 2019-11-19 07:04:09 -0800 Created attachment 383865 proposed patch address comments from review 1591565 15 383865 mark.lam 2019-11-19 09:30:37 -0800 Comment on attachment 383865 proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=383865&action=review Drive by comment. > Source/JavaScriptCore/runtime/VM.cpp:460 > setFuzzerAgent(makeUnique<RandomizingFuzzerAgent>(*this)); > else if (Options::useDoublePredictionFuzzerAgent()) > setFuzzerAgent(makeUnique<DoublePredictionFuzzerAgent>(*this)); > + else if (Options::useFileBasedFuzzerAgent()) > + setFuzzerAgent(makeUnique<FileBasedFuzzerAgent>(*this)); > + else if (Options::usePredictionFileCreatingFuzzerAgent()) > + setFuzzerAgent(makeUnique<PredictionFileCreatingFuzzerAgent>(*this)); Since these fuzzer agent settings are mutually exclusive, I think it would be beneficial to let the user know if more of these options are enabled at the same time rather than failing silently. I'm thinking something like this: if (UNLIKELY(Options::useRandomizingFuzzerAgent() || Options::useDoublePredictionFuzzerAgent() || Options::useFileBasedFuzzerAgent() || Options::usePredictionFileCreatingFuzzerAgent())) { size_t numberOfFuzzerAgentsEnabled = 0; if (Options::useRandomizingFuzzerAgent()) { setFuzzerAgent(makeUnique<RandomizingFuzzerAgent>(*this)); numberOfFuzzerAgentsEnabled++; } if (Options::useDoublePredictionFuzzerAgent()) { setFuzzerAgent(makeUnique<DoublePredictionFuzzerAgent>(*this)); numberOfFuzzerAgentsEnabled++; } if (Options::useFileBasedFuzzerAgent()) { setFuzzerAgent(makeUnique<FileBasedFuzzerAgent>(*this)); numberOfFuzzerAgentsEnabled++; } if (Options::usePredictionFileCreatingFuzzerAgent()) { setFuzzerAgent(makeUnique<PredictionFileCreatingFuzzerAgent>(*this)); numberOfFuzzerAgentsEnabled++; } RELEASE_ASSERT_WITH_MESSAGE(numberOfFuzzerAgentsEnabled == 1, "Cannot use more than one fuzzer agent at the same time"); } 1591683 16 383865 mark.lam 2019-11-19 13:59:30 -0800 Comment on attachment 383865 proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=383865&action=review > Source/JavaScriptCore/runtime/FileBasedFuzzerAgent.cpp:74 > + ScriptExecutable* ownerExecutable = codeBlock->ownerExecutable(); > + auto sourceURL = ownerExecutable->sourceURL(); > + if (sourceURL.isEmpty()) > + return original; > + > + int divot = 0; > + int startOffset = -1; > + int endOffset = -1; > + unsigned line = 0; > + unsigned column = 0; > + BytecodeIndex bytecodeIndex = codeOrigin.bytecodeIndex(); > + codeBlock->expressionRangeForBytecodeIndex(bytecodeIndex, divot, startOffset, endOffset, line, column); > + > + SourceProvider* provider = codeBlock->source().provider(); > + auto sourceUpToDivot = provider->source().substring(divot - startOffset, startOffset); > + auto sourceAfterDivot = provider->source().substring(divot, endOffset); > + > + Vector<String> urlParts = sourceURL.split('/'); > + auto sourceFilename = urlParts.isEmpty() ? sourceURL : urlParts.last(); > + > + const InstructionStream& instructions = codeBlock->instructions(); > + const Instruction* anInstruction = instructions.at(bytecodeIndex).ptr(); > + OpcodeID opcodeId = anInstruction->opcodeID(); > + int startLocation = divot - startOffset; > + int endLocation = divot + endOffset; > + String key = createLookupKey(sourceFilename, opcodeId, startLocation, endLocation); nit: A lot of this is common to the version in PredictionFileCreatingFuzzerAgent::getPrediction(). Since both PredictionFileCreatingFuzzerAgent and FileBasedFuzzerAgent derives from FileBasedFuzzerAgentBase, would it be possible and make sense to factor out this code into a common utility function in FileBasedFuzzerAgentBase? > Source/JavaScriptCore/runtime/FileBasedFuzzerAgent.cpp:150 > +#if PLATFORM(COCOA) > + StringBuilder missingPredictionCrashLogMessage; > + missingPredictionCrashLogMessage.append("missing prediction for: ", key); > + WTF::setCrashLogMessage(missingPredictionCrashLogMessage.toString().utf8().data()); > +#endif > + RELEASE_ASSERT_NOT_REACHED(); Instead of adding PLATFORM(COCOA) specific code here, how about adding a RELEASE_ASSERT_NOT_REACHED_WITH_MESSAGE() to Assertions.h, so that this can this functionality can be re-used. For the implementation of RELEASE_ASSERT_NOT_REACHED_WITH_MESSAGE(), I think you can just define it as RELEASE_ASSERT_WITH_MESSAGE(assertionFailureDueToUnreachableCode, __VA_ARGS__), and define "constexpr bool assertionFailureDueToUnreachableCode = false;" in Assertions.h. > Source/JavaScriptCore/runtime/FuzzerPredictions.cpp:53 > + FILE* f = fopen(fileName, "r"); > + if (!f) > + return WTF::nullopt; > + > + auto readContents = [&]() -> Optional<String> { > + if (fseek(f, 0, SEEK_END) == -1) > + return WTF::nullopt; > + > + long bufferCapacity = ftell(f); > + if (bufferCapacity == -1) > + return WTF::nullopt; > + > + if (fseek(f, 0, SEEK_SET) == -1) > + return WTF::nullopt; > + > + Vector<char> buffer; > + buffer.resize(bufferCapacity); > + size_t readSize = fread(buffer.data(), 1, buffer.size(), f); > + if (readSize == buffer.size()) > + return String(buffer.data(), buffer.size()); > + return WTF::nullopt; In all of these error cases, I suggest that you print a short message about the error that occurred. This will help the user diagnose what went wrong instead of a silent failure where the user may not realize that a prediction file was never loaded at all (and hence, hours of test runs may have been in vain). Better yet, do a RELEASE_ASSERT_WITH_MESSAGE so that the user is guaranteed to notice the error. I can't think of any reason why we would want to allow the test to proceed if the user asked for a predictions file to be loaded but we failed to do so. > Source/JavaScriptCore/runtime/FuzzerPredictions.cpp:65 > + if (!filename) > + return; FuzzerPredictions is only used by FileBasedFuzzerAgent::getPrediction(), right? I think it's a misconfiguration if the user specifies the option to use a FileBasedFuzzerAgent but fails to specify a predictions file to use. You should just RELEASE_ASSERT_WITH_MESSAGE here and let the user know that he/she forgot to specify a predictions file. > Source/JavaScriptCore/runtime/FuzzerPredictions.cpp:71 > + if (!predictions) { > + dataLogF("Failed to read file %s\n", filename); > + return; > + } I think you can remove this after adding the RELEASE_ASSERTs in readFileIntoString(). It's better to assert it in readFileIntoString() than here because we can get a more fine grain error message as to what went wrong there. > Source/JavaScriptCore/runtime/FuzzerPredictions.cpp:81 > + // The start and end offsets are 7-bit unsigned integers. > + // If start offset > 127, then both start and end offsets are 0. > + // If end offset > 127, then the end offset is 0. Why are start and end 7-bit ints? They came from the character position in the source string. Given a long enough source string, they can be greater than 7-bits. Am I missing something? > Source/JavaScriptCore/runtime/FuzzerPredictions.cpp:109 > + if (m_predictions.contains(key)) > + return m_predictions.get(key); I think you can just call get() directly, and check whether it returns the emptyValue(). That way, you don't do the look up twice for each successful case. 1591892 17 tuomas.webkit 2019-11-19 22:04:55 -0800 (In reply to Mark Lam from comment #16) > Comment on attachment 383865 [details] > proposed patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=383865&action=review > > > Source/JavaScriptCore/runtime/FuzzerPredictions.cpp:81 > > + // The start and end offsets are 7-bit unsigned integers. > > + // If start offset > 127, then both start and end offsets are 0. > > + // If end offset > 127, then the end offset is 0. > > Why are start and end 7-bit ints? They came from the character position in > the source string. Given a long enough source string, they can be greater > than 7-bits. Am I missing something? They are defined as 7-bit unsigned integers in ExpressionRangeInfo.h. The behavior described is implemented in UnlinkedCodeBlock::addExpressionInfo(). (There's 25 bits worth of instructionOffset and divotPoint each.) 1591903 18 mark.lam 2019-11-19 23:13:37 -0800 (In reply to Tuomas Karkkainen from comment #17) > (In reply to Mark Lam from comment #16) > > Comment on attachment 383865 [details] > > proposed patch > > > > View in context: > > https://bugs.webkit.org/attachment.cgi?id=383865&action=review > > > > > Source/JavaScriptCore/runtime/FuzzerPredictions.cpp:81 > > > + // The start and end offsets are 7-bit unsigned integers. > > > + // If start offset > 127, then both start and end offsets are 0. > > > + // If end offset > 127, then the end offset is 0. > > > > Why are start and end 7-bit ints? They came from the character position in > > the source string. Given a long enough source string, they can be greater > > than 7-bits. Am I missing something? > > They are defined as 7-bit unsigned integers in ExpressionRangeInfo.h. The > behavior described is implemented in UnlinkedCodeBlock::addExpressionInfo(). > (There's 25 bits worth of instructionOffset and divotPoint each.) Ah, thanks. I worked with this code many years ago, but I've since forgotten about it. The comments in UnlinkedCodeBlock::addExpressionInfo() explains why 7 bits is fine: ... } else if (startOffset > ExpressionRangeInfo::MaxOffset) { // If the start offset is out of bounds we clear both offsets // so we only get the divot marker. Error message will have to be reduced // to line and charPosition number. startOffset = 0; endOffset = 0; } else if (endOffset > ExpressionRangeInfo::MaxOffset) { // The end offset is only used for additional context, and is much more likely // to overflow (eg. function call arguments) so we are willing to drop it without // dropping the rest of the range. endOffset = 0; } 1. startOffset and endOffset is always relative to the divot of an expression string, not absolute positions. Hence, it is likely that they will fit within 7 bits. 2. startOffset and endOffset are only used for helping to get more intelligent error strings. Hence, it is not critical for them to be accurate. They are a best effort attempt, and we're willing to drop them (set to 0) if we can't record the actual offsets. What this means is that you shouldn't be using the start and end offsets in your lookup key. Instead, just use the line and column values that are fetched by expressionRangeForBytecodeIndex(). But maybe I'm not getting your intent. Why are you using the start and end positions anyway? 1591909 19 383865 mark.lam 2019-11-19 23:39:14 -0800 Comment on attachment 383865 proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=383865&action=review >>>> Source/JavaScriptCore/runtime/FuzzerPredictions.cpp:81 >>>> + // If end offset > 127, then the end offset is 0. >>> >>> Why are start and end 7-bit ints? They came from the character position in the source string. Given a long enough source string, they can be greater than 7-bits. Am I missing something? >> >> They are defined as 7-bit unsigned integers in ExpressionRangeInfo.h. The behavior described is implemented in UnlinkedCodeBlock::addExpressionInfo(). (There's 25 bits worth of instructionOffset and divotPoint each.) > > Ah, thanks. I worked with this code many years ago, but I've since forgotten about it. The comments in UnlinkedCodeBlock::addExpressionInfo() explains why 7 bits is fine: > > ... > } else if (startOffset > ExpressionRangeInfo::MaxOffset) { > // If the start offset is out of bounds we clear both offsets > // so we only get the divot marker. Error message will have to be reduced > // to line and charPosition number. > startOffset = 0; > endOffset = 0; > } else if (endOffset > ExpressionRangeInfo::MaxOffset) { > // The end offset is only used for additional context, and is much more likely > // to overflow (eg. function call arguments) so we are willing to drop it without > // dropping the rest of the range. > endOffset = 0; > } > > 1. startOffset and endOffset is always relative to the divot of an expression string, not absolute positions. Hence, it is likely that they will fit within 7 bits. > 2. startOffset and endOffset are only used for helping to get more intelligent error strings. Hence, it is not critical for them to be accurate. They are a best effort attempt, and we're willing to drop them (set to 0) if we can't record the actual offsets. > > What this means is that you shouldn't be using the start and end offsets in your lookup key. Instead, just use the line and column values that are fetched by expressionRangeForBytecodeIndex(). But maybe I'm not getting your intent. Why are you using the start and end positions anyway? Tuomas explained to me offline that this is not an issue. For the purpose of the predictions generator, this works adequately. We don't need something more accurate. Carry on. 1593643 20 384346 tuomas.webkit 2019-11-26 04:57:31 -0800 Created attachment 384346 proposed patch address concerns from review. 1594361 21 384346 saam 2019-11-30 16:23:35 -0800 Comment on attachment 384346 proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=384346&action=review r=me with a couple nits > Source/JavaScriptCore/runtime/FuzzerPredictions.cpp:33 > + FILE* f = fopen(fileName, "r"); Nit: in WebKit style, we tend to avoid single letter variable names. I think a name more inline with the style guide would be “file” > Source/JavaScriptCore/runtime/OptionsList.h:402 > + v(OptionString, fuzzerPredictions, nullptr, Normal, "file with list of predictions for FileBasedFuzzerAgent") \ Maybe “fuzzerPredictionsPath” or “fuzzerPredictionsFile”? > Source/WTF/ChangeLog:3 > + add ASSERT_NOT_REACHED_WITH_MESSAGE and RELEASE_ASSERT_NOT_REACHED_WITH_MESSAGE Delete this changelog in your diff. I think you already did this in another patch 1594495 22 384592 tuomas.webkit 2019-12-01 21:22:39 -0800 Created attachment 384592 proposed patch resolve issues raised by Saam 1594497 23 384592 mark.lam 2019-12-01 21:37:07 -0800 Comment on attachment 384592 proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=384592&action=review > Source/JavaScriptCore/runtime/VM.cpp:471 > setFuzzerAgent(makeUnique<RandomizingFuzzerAgent>(*this)); > if (Options::useDoublePredictionFuzzerAgent()) > setFuzzerAgent(makeUnique<DoublePredictionFuzzerAgent>(*this)); > + if (Options::useFileBasedFuzzerAgent()) > + setFuzzerAgent(makeUnique<FileBasedFuzzerAgent>(*this)); > + if (Options::usePredictionFileCreatingFuzzerAgent()) > + setFuzzerAgent(makeUnique<PredictionFileCreatingFuzzerAgent>(*this)); If the user sets more than 1 fuzzer agent, only the last fuzzer agent will take effect, and we'll silently fail to use the earlier fuzzer agents. I think we should not be silently failing, and commented about this in https://bugs.webkit.org/show_bug.cgi?id=203898#c15. Did you disagree with that assessment? 1594499 24 tuomas.webkit 2019-12-01 21:53:52 -0800 (In reply to Mark Lam from comment #23) > Comment on attachment 384592 [details] > proposed patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=384592&action=review > > > Source/JavaScriptCore/runtime/VM.cpp:471 > > setFuzzerAgent(makeUnique<RandomizingFuzzerAgent>(*this)); > > if (Options::useDoublePredictionFuzzerAgent()) > > setFuzzerAgent(makeUnique<DoublePredictionFuzzerAgent>(*this)); > > + if (Options::useFileBasedFuzzerAgent()) > > + setFuzzerAgent(makeUnique<FileBasedFuzzerAgent>(*this)); > > + if (Options::usePredictionFileCreatingFuzzerAgent()) > > + setFuzzerAgent(makeUnique<PredictionFileCreatingFuzzerAgent>(*this)); > > If the user sets more than 1 fuzzer agent, only the last fuzzer agent will > take effect, and we'll silently fail to use the earlier fuzzer agents. I > think we should not be silently failing, and commented about this in > https://bugs.webkit.org/show_bug.cgi?id=203898#c15. Did you disagree with > that assessment? I made that into a separate patch at https://bugs.webkit.org/show_bug.cgi?id=204607 1594500 25 384592 mark.lam 2019-12-01 22:00:18 -0800 Comment on attachment 384592 proposed patch View in context: https://bugs.webkit.org/attachment.cgi?id=384592&action=review r=me >>> Source/JavaScriptCore/runtime/VM.cpp:471 >>> + setFuzzerAgent(makeUnique<PredictionFileCreatingFuzzerAgent>(*this)); >> >> If the user sets more than 1 fuzzer agent, only the last fuzzer agent will take effect, and we'll silently fail to use the earlier fuzzer agents. I think we should not be silently failing, and commented about this in https://bugs.webkit.org/show_bug.cgi?id=203898#c15. Did you disagree with that assessment? > > I made that into a separate patch at https://bugs.webkit.org/show_bug.cgi?id=204607 OK. That works. 1594501 26 384592 commit-queue 2019-12-01 22:44:24 -0800 Comment on attachment 384592 proposed patch Clearing flags on attachment: 384592 Committed r252978: <https://trac.webkit.org/changeset/252978> 1594502 27 commit-queue 2019-12-01 22:44:26 -0800 All reviewed patches have been landed. Closing bug. 1594503 28 webkit-bug-importer 2019-12-01 22:45:22 -0800 <rdar://problem/57550508> 1840819 29 bfulgham 2022-02-12 19:49:45 -0800 *** Bug 197098 has been marked as a duplicate of this bug. *** 382922 2019-11-06 06:28:53 -0800 2019-11-13 06:28:56 -0800 proposed patch webkit_203898.patch text/plain 27529 tuomas.webkit ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQ2hhbmdlTG9nCmluZGV4IDZkYjc5MWM3ODEwLi4xZjIyNjQwODE1ZCAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzEgQEAKKzIwMTktMTEtMDYgIFR1b21h cyBLYXJra2FpbmVuICA8dHVvbWFzLndlYmtpdEBhcHBsZS5jb20+CisKKyAgICAgICAgQWRkIEZ1 enplckFnZW50IHRoYXQgcmVhZHMgcHJlZGljdGlvbnMgZnJvbSBhIGZpbGUKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzg5OAorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgICogSmF2YVNjcmlwdENvcmUueGNv ZGVwcm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiBTb3VyY2VzLnR4dDoKKyAgICAgICAg KiBydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50LmNwcDogQWRkZWQuCisgICAgICAgIChKU0M6 OkZpbGVCYXNlZEZ1enplckFnZW50OjpGaWxlQmFzZWRGdXp6ZXJBZ2VudCk6CisgICAgICAgIChK U0M6OkZpbGVCYXNlZEZ1enplckFnZW50OjpnZXRQcmVkaWN0aW9uKToKKyAgICAgICAgKEpTQzo6 RmlsZUJhc2VkRnV6emVyQWdlbnQ6OmNyZWF0ZUxvb2t1cEtleSk6CisgICAgICAgIChKU0M6OkZp bGVCYXNlZEZ1enplckFnZW50OjpvcGNvZGVBbGlhc0Zvckxvb2t1cEtleSk6CisgICAgICAgICog cnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudC5oOiBDb3BpZWQgZnJvbSBTb3VyY2UvSmF2YVNj cmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFnZW50LmNwcC4KKyAgICAgICAgKiBy dW50aW1lL0Z1enplclByZWRpY3Rpb25zLmNwcDogQWRkZWQuCisgICAgICAgIChKU0M6OkZ1enpl clByZWRpY3Rpb25zOjpGdXp6ZXJQcmVkaWN0aW9ucyk6CisgICAgICAgIChKU0M6OkZ1enplclBy ZWRpY3Rpb25zOjpwcmVkaWN0aW9uRm9yKToKKyAgICAgICAgKEpTQzo6ZW5zdXJlR2xvYmFsRnV6 emVyUHJlZGljdGlvbnMpOgorICAgICAgICAqIHJ1bnRpbWUvRnV6emVyUHJlZGljdGlvbnMuaDog Q29waWVkIGZyb20gU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUmFuZG9taXppbmdGdXp6 ZXJBZ2VudC5jcHAuCisgICAgICAgICogcnVudGltZS9PcHRpb25zLmNwcDoKKyAgICAgICAgKEpT Qzo6cmVjb21wdXRlRGVwZW5kZW50T3B0aW9ucyk6CisgICAgICAgICogcnVudGltZS9PcHRpb25z TGlzdC5oOgorICAgICAgICAqIHJ1bnRpbWUvUmFuZG9taXppbmdGdXp6ZXJBZ2VudC5jcHA6Cisg ICAgICAgIChKU0M6OlJhbmRvbWl6aW5nRnV6emVyQWdlbnQ6OmdldFByZWRpY3Rpb24pOgorICAg ICAgICAqIHJ1bnRpbWUvVk0uY3BwOgorICAgICAgICAoSlNDOjpWTTo6Vk0pOgorCiAyMDE5LTEx LTA1ICBUYWRldSBaYWdhbGxvICA8dHphZ2FsbG9AYXBwbGUuY29tPgogCiAgICAgICAgIFtXZWJB c3NlbWJseV0gQWxsb3cgdGllcmluZyB1cCBmcm9tIExMSW50IHRvIEJCUQpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBi eHByb2ogYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3By b2plY3QucGJ4cHJvagppbmRleCBhZDA3ZjY4MGFiNi4uNjBiNDNhMmE0ZDUgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5w Ynhwcm9qCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS54Y29kZXBy b2ovcHJvamVjdC5wYnhwcm9qCkBAIC0xNzQxLDYgKzE3NDEsOCBAQAogCQlDNEY0QjZGNTFBMDVD OTg0MDA1Q0FCNzYgLyogZ2VuZXJhdGVfb2JqY19wcm90b2NvbF90eXBlc19pbXBsZW1lbnRhdGlv bi5weSBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEM0RjRC NkQ3MUEwNUM3NkYwMDVDQUI3NiAvKiBnZW5lcmF0ZV9vYmpjX3Byb3RvY29sX3R5cGVzX2ltcGxl bWVudGF0aW9uLnB5ICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07 IH07CiAJCUM0RjRCNkY2MUEwNUM5ODQwMDVDQUI3NiAvKiBvYmpjX2dlbmVyYXRvcl90ZW1wbGF0 ZXMucHkgaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDNEY0 QjZEODFBMDVDNzZGMDA1Q0FCNzYgLyogb2JqY19nZW5lcmF0b3JfdGVtcGxhdGVzLnB5ICovOyBz ZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUNFQUU3RDdCODg5 QjQ3N0JBOTNBQkE2QyAvKiBTY3JpcHRGZXRjaGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4ODUyMTUxQTlDMzg0MjM4OUIzMjE1QjcgLyogU2NyaXB0 RmV0Y2hlci5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07 CisJCUNFQ0ZBRDM2MjM3MkRBRDAwMDI5MTU5OSAvKiBGdXp6ZXJQcmVkaWN0aW9ucy5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQ0VDRkFEMzQyMzcyREFB NzAwMjkxNTk5IC8qIEZ1enplclByZWRpY3Rpb25zLmggKi87IH07CisJCUNFQ0ZBRDM3MjM3MkRB RDQwMDI5MTU5OSAvKiBGaWxlQmFzZWRGdXp6ZXJBZ2VudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQ0VDRkFEMzIyMzcyREFBNzAwMjkxNTk5IC8qIEZp bGVCYXNlZEZ1enplckFnZW50LmggKi87IH07CiAJCUQ5NzIyNzUyREM1NDQ1OUI5MTI1QjUzOSAv KiBKU01vZHVsZUxvYWRlci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gNzdCMjVDQjJDMzA5NEE5MkEzOEUxREIzIC8qIEpTTW9kdWxlTG9hZGVyLmggKi87 IH07CiAJCURDMDAwMzkzMTlEOEJFNkYwMDAyM0VCMCAvKiBERkdQcmVjaXNlTG9jYWxDbG9iYmVy aXplLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBEQzAw MDM5MDE5RDhCRTZGMDAwMjNFQjAgLyogREZHUHJlY2lzZUxvY2FsQ2xvYmJlcml6ZS5oICovOyB9 OwogCQlEQzAxODQxOTFEMTBDMTg5MDA1N0IwNTMgLyogSklUV29ya2xpc3QuaCBpbiBIZWFkZXJz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IERDMDE4NDE4MUQxMEMxODcwMDU3 QjA1MyAvKiBKSVRXb3JrbGlzdC5oICovOyB9OwpAQCAtNDgyNSw2ICs0ODI3LDEwIEBACiAJCUM0 RjRCNkQ2MUEwNUM3NkYwMDVDQUI3NiAvKiBnZW5lcmF0ZV9jcHBfcHJvdG9jb2xfdHlwZXNfaW1w bGVtZW50YXRpb24ucHkgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0LnNjcmlwdC5weXRob247IHBhdGggPSBnZW5l cmF0ZV9jcHBfcHJvdG9jb2xfdHlwZXNfaW1wbGVtZW50YXRpb24ucHk7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCUM0RjRCNkQ3MUEwNUM3NkYwMDVDQUI3NiAvKiBnZW5lcmF0ZV9vYmpj X3Byb3RvY29sX3R5cGVzX2ltcGxlbWVudGF0aW9uLnB5ICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dC5zY3JpcHQu cHl0aG9uOyBwYXRoID0gZ2VuZXJhdGVfb2JqY19wcm90b2NvbF90eXBlc19pbXBsZW1lbnRhdGlv bi5weTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQzRGNEI2RDgxQTA1Qzc2RjAwNUNB Qjc2IC8qIG9iamNfZ2VuZXJhdG9yX3RlbXBsYXRlcy5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuc2NyaXB0 LnB5dGhvbjsgcGF0aCA9IG9iamNfZ2VuZXJhdG9yX3RlbXBsYXRlcy5weTsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKKwkJQ0VDRkFEMzIyMzcyREFBNzAwMjkxNTk5IC8qIEZpbGVCYXNlZEZ1 enplckFnZW50LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEZpbGVCYXNlZEZ1enplckFnZW50Lmg7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUNFQ0ZBRDMzMjM3MkRBQTcwMDI5MTU5OSAvKiBGaWxl QmFzZWRGdXp6ZXJBZ2VudC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBGaWxlQmFzZWRGdXp6ZXJB Z2VudC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUNFQ0ZBRDM0MjM3MkRBQTcw MDI5MTU5OSAvKiBGdXp6ZXJQcmVkaWN0aW9ucy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVu Y2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBGdXp6ZXJQcmVk aWN0aW9ucy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDRUNGQUQzNTIzNzJEQUE3 MDAyOTE1OTkgLyogRnV6emVyUHJlZGljdGlvbnMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRnV6 emVyUHJlZGljdGlvbnMuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlEMjEyMDIy ODBBRDQzMTBDMDBFRDc5QjYgLyogRGF0ZUNvbnZlcnNpb24uY3BwICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJj ZWNvZGUuY3BwLmNwcDsgcGF0aCA9IERhdGVDb252ZXJzaW9uLmNwcDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKIAkJRDIxMjAyMjkwQUQ0MzEwQzAwRUQ3OUI2IC8qIERhdGVDb252ZXJzaW9u LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RL bm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBEYXRlQ29udmVyc2lvbi5oOyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlEQzAwMDM5MDE5RDhCRTZGMDAwMjNFQjAgLyog REZHUHJlY2lzZUxvY2FsQ2xvYmJlcml6ZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7 IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IG5h bWUgPSBERkdQcmVjaXNlTG9jYWxDbG9iYmVyaXplLmg7IHBhdGggPSBkZmcvREZHUHJlY2lzZUxv Y2FsQ2xvYmJlcml6ZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtNzA4Myw2ICs3 MDg5LDggQEAKIAkJCQkxNDczNDFFOTFEQzJDRjI1MDBBQTI5QkEgLyogRXhlY3V0YWJsZUJhc2Uu Y3BwICovLAogCQkJCTE0NzM0MUNCMURDMDJENzIwMEFBMjlCQSAvKiBFeGVjdXRhYmxlQmFzZS5o ICovLAogCQkJCUUzNUEwQjlDMjIwQUQ4N0EwMEFDNDQ3NCAvKiBFeGVjdXRhYmxlQmFzZUlubGlu ZXMuaCAqLywKKwkJCQlDRUNGQUQzMzIzNzJEQUE3MDAyOTE1OTkgLyogRmlsZUJhc2VkRnV6emVy QWdlbnQuY3BwICovLAorCQkJCUNFQ0ZBRDMyMjM3MkRBQTcwMDI5MTU5OSAvKiBGaWxlQmFzZWRG dXp6ZXJBZ2VudC5oICovLAogCQkJCUE3QThBRjI5MTdBREI1RjMwMDVBQjE3NCAvKiBGbG9hdDMy QXJyYXkuaCAqLywKIAkJCQlBN0E4QUYyQTE3QURCNUYzMDA1QUIxNzQgLyogRmxvYXQ2NEFycmF5 LmggKi8sCiAJCQkJQkMyNjgwQzAwRTE2RDRFOTAwQTA2RTkyIC8qIEZ1bmN0aW9uQ29uc3RydWN0 b3IuY3BwICovLApAQCAtNzEwMCw2ICs3MTA4LDggQEAKIAkJCQk2MkQyRDM4RTFBREYxMDNGMDAw MjA2QzEgLyogRnVuY3Rpb25SYXJlRGF0YS5oICovLAogCQkJCUUzM0E5NDk1MjI1NTMyMkEwMEQ0 MkIwNiAvKiBGdXp6ZXJBZ2VudC5jcHAgKi8sCiAJCQkJRTMzQTk0OTIyMjU1MzIyOTAwRDQyQjA2 IC8qIEZ1enplckFnZW50LmggKi8sCisJCQkJQ0VDRkFEMzUyMzcyREFBNzAwMjkxNTk5IC8qIEZ1 enplclByZWRpY3Rpb25zLmNwcCAqLywKKwkJCQlDRUNGQUQzNDIzNzJEQUE3MDAyOTE1OTkgLyog RnV6emVyUHJlZGljdGlvbnMuaCAqLywKIAkJCQk3MEI3OTE4NTFDMDI0NDMyMDAyNDgxRTIgLyog R2VuZXJhdG9yRnVuY3Rpb25Db25zdHJ1Y3Rvci5jcHAgKi8sCiAJCQkJNzBCNzkxODYxQzAyNDQz MjAwMjQ4MUUyIC8qIEdlbmVyYXRvckZ1bmN0aW9uQ29uc3RydWN0b3IuaCAqLywKIAkJCQk3MEI3 OTE4NzFDMDI0NDMyMDAyNDgxRTIgLyogR2VuZXJhdG9yRnVuY3Rpb25Qcm90b3R5cGUuY3BwICov LApAQCAtMTAwMDQsNiArMTAwMTQsNyBAQAogCQkJCTUzNEUwMzU2MUU1M0JFREUwMDIxM0Y2NCAv KiBQcm94eWFibGVBY2Nlc3NDYXNlLmggaW4gSGVhZGVycyAqLywKIAkJCQk3OUIwMENCRDFDNkFC MDdFMDA4OEM2NUQgLyogUHJveHlDb25zdHJ1Y3Rvci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNzlC MDBDQkYxQzZBQjA3RTAwODhDNjVEIC8qIFByb3h5T2JqZWN0LmggaW4gSGVhZGVycyAqLywKKwkJ CQlDRUNGQUQzNzIzNzJEQUQ0MDAyOTE1OTkgLyogRmlsZUJhc2VkRnV6emVyQWdlbnQuaCBpbiBI ZWFkZXJzICovLAogCQkJCTc5MTYwREJFMUM4RTNFQzgwMDhDMDg1QSAvKiBQcm94eVJldm9rZS5o IGluIEhlYWRlcnMgKi8sCiAJCQkJMEY1NzgwQTIxOEZFMUU5ODAwMUU3MkQ5IC8qIFB1cmVOYU4u aCBpbiBIZWFkZXJzICovLAogCQkJCTBGMTVDRDIzMUJBNUY5ODYwMDMxRkZEMyAvKiBQdXRCeUlk RmxhZ3MuaCBpbiBIZWFkZXJzICovLApAQCAtMTAwODIsNiArMTAwOTMsNyBAQAogCQkJCUZFMzAy MkQzMUUzRDczQTUwMEJBQzQ5MyAvKiBTaWdpbGxDcmFzaEFuYWx5emVyLmggaW4gSGVhZGVycyAq LywKIAkJCQkwRjREOEM3ODFGQ0EzQ0ZBMDAxRDMyQUMgLyogU2ltcGxlTWFya2luZ0NvbnN0cmFp bnQuaCBpbiBIZWFkZXJzICovLAogCQkJCTBGMkI2NzA1MTdCNkI1QUIwMEE3QUUzRiAvKiBTaW1w bGVUeXBlZEFycmF5Q29udHJvbGxlci5oIGluIEhlYWRlcnMgKi8sCisJCQkJQ0VDRkFEMzYyMzcy REFEMDAwMjkxNTk5IC8qIEZ1enplclByZWRpY3Rpb25zLmggaW4gSGVhZGVycyAqLywKIAkJCQkx NEJBNzhGMTEzQUFCODhGMDA1QjdDMkMgLyogU2xvdFZpc2l0b3IuaCBpbiBIZWFkZXJzICovLAog CQkJCUMyMTYwRkU3MTVGN0U5NUUwMDk0MkRGQyAvKiBTbG90VmlzaXRvcklubGluZXMuaCBpbiBI ZWFkZXJzICovLAogCQkJCUE3MDlGMkYwMTdBMEFDMDQwMDUxMkU5OCAvKiBTbG93UGF0aENhbGwu aCBpbiBIZWFkZXJzICovLApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL1NvdXJj ZXMudHh0IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL1NvdXJjZXMudHh0CmluZGV4IDUxOTIxZDcx ODYwLi5mNjllYmUyMTc5ZSAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL1NvdXJj ZXMudHh0CisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9Tb3VyY2VzLnR4dApAQCAtNzY2LDYg Kzc2Niw3IEBAIHJ1bnRpbWUvRXhjZXB0aW9uRnV6ei5jcHAKIHJ1bnRpbWUvRXhjZXB0aW9uSGVs cGVycy5jcHAKIHJ1bnRpbWUvRXhjZXB0aW9uU2NvcGUuY3BwCiBydW50aW1lL0V4ZWN1dGFibGVC YXNlLmNwcAorcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudC5jcHAKIHJ1bnRpbWUvRnVuY3Rp b25Db25zdHJ1Y3Rvci5jcHAKIHJ1bnRpbWUvRnVuY3Rpb25FeGVjdXRhYmxlLmNwcAogcnVudGlt ZS9GdW5jdGlvbkV4ZWN1dGFibGVEdW1wLmNwcApAQCAtNzczLDYgKzc3NCw3IEBAIHJ1bnRpbWUv RnVuY3Rpb25IYXNFeGVjdXRlZENhY2hlLmNwcAogcnVudGltZS9GdW5jdGlvblByb3RvdHlwZS5j cHAKIHJ1bnRpbWUvRnVuY3Rpb25SYXJlRGF0YS5jcHAKIHJ1bnRpbWUvRnV6emVyQWdlbnQuY3Bw CitydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmNwcAogcnVudGltZS9HZW5lcmF0b3JGdW5jdGlv bkNvbnN0cnVjdG9yLmNwcAogcnVudGltZS9HZW5lcmF0b3JGdW5jdGlvblByb3RvdHlwZS5jcHAK IHJ1bnRpbWUvR2VuZXJhdG9yUHJvdG90eXBlLmNwcApkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnQuY3BwIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnQuY3BwCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi40YTBkY2FmNTU4ZQotLS0gL2Rldi9udWxsCisrKyBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50LmNwcApA QCAtMCwwICsxLDE4MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxOSBBcHBsZSBJbmMuIEFs bCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3Vy Y2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFy ZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFy ZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4g dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGlu IGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92 aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9W SURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJ RUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1Q TElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJU SUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQ TEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5E SVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJ QUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVO VCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IK KyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5E IE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RS SUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVS V0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRX QVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgor ICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJGaWxlQmFzZWRGdXp6ZXJBZ2Vu dC5oIgorCisjaW5jbHVkZSAiQ29kZUJsb2NrLmgiCisjaW5jbHVkZSAiRnV6emVyUHJlZGljdGlv bnMuaCIKKyNpbmNsdWRlIDx3dGYvQW5zaUNvbG9ycy5oPgorI2luY2x1ZGUgPHd0Zi9Mb2NrZXIu aD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+CisjaWYgUExBVEZPUk0oQ09D T0EpCisjaW5jbHVkZSA8d3RmL2NvY29hL0NyYXNoUmVwb3J0ZXIuaD4KKyNlbmRpZgorCituYW1l c3BhY2UgSlNDIHsKKworRmlsZUJhc2VkRnV6emVyQWdlbnQ6OkZpbGVCYXNlZEZ1enplckFnZW50 KFZNJikKK3sKK30KKworU3BlY3VsYXRlZFR5cGUgRmlsZUJhc2VkRnV6emVyQWdlbnQ6OmdldFBy ZWRpY3Rpb24oQ29kZUJsb2NrKiBjb2RlQmxvY2ssIGNvbnN0IENvZGVPcmlnaW4mIGNvZGVPcmln aW4sIFNwZWN1bGF0ZWRUeXBlIG9yaWdpbmFsKQoreworICAgIGF1dG8gbG9ja2VyID0gaG9sZExv Y2sobV9sb2NrKTsKKworICAgIFNjcmlwdEV4ZWN1dGFibGUqIG93bmVyRXhlY3V0YWJsZSA9IGNv ZGVCbG9jay0+b3duZXJFeGVjdXRhYmxlKCk7CisgICAgYXV0byBzb3VyY2VVUkwgPSBvd25lckV4 ZWN1dGFibGUtPnNvdXJjZVVSTCgpOworICAgIGlmIChzb3VyY2VVUkwuaXNFbXB0eSgpKQorICAg ICAgICByZXR1cm4gb3JpZ2luYWw7CisKKyAgICBpbnQgZGl2b3QgPSAwOworICAgIGludCBzdGFy dE9mZnNldCA9IC0xOworICAgIGludCBlbmRPZmZzZXQgPSAtMTsKKyAgICB1bnNpZ25lZCBsaW5l ID0gMDsKKyAgICB1bnNpZ25lZCBjb2x1bW4gPSAwOworICAgIEJ5dGVjb2RlSW5kZXggYnl0ZWNv ZGVJbmRleCA9IGNvZGVPcmlnaW4uYnl0ZWNvZGVJbmRleCgpOworICAgIGNvZGVCbG9jay0+ZXhw cmVzc2lvblJhbmdlRm9yQnl0ZWNvZGVJbmRleChieXRlY29kZUluZGV4LCBkaXZvdCwgc3RhcnRP ZmZzZXQsIGVuZE9mZnNldCwgbGluZSwgY29sdW1uKTsKKworICAgIFNvdXJjZVByb3ZpZGVyKiBw cm92aWRlciA9IGNvZGVCbG9jay0+c291cmNlKCkucHJvdmlkZXIoKTsKKyAgICBhdXRvIHNvdXJj ZVVwVG9EaXZvdCA9IHByb3ZpZGVyLT5zb3VyY2UoKS5zdWJzdHJpbmcoZGl2b3QgLSBzdGFydE9m ZnNldCwgc3RhcnRPZmZzZXQpOworICAgIGF1dG8gc291cmNlQWZ0ZXJEaXZvdCA9IHByb3ZpZGVy LT5zb3VyY2UoKS5zdWJzdHJpbmcoZGl2b3QsIGVuZE9mZnNldCk7CisKKyAgICBWZWN0b3I8U3Ry aW5nPiB1cmxQYXJ0cyA9IHNvdXJjZVVSTC5zcGxpdCgnLycpOworICAgIGF1dG8gc291cmNlRmls ZW5hbWUgPSB1cmxQYXJ0cy5pc0VtcHR5KCkgPyBzb3VyY2VVUkwgOiB1cmxQYXJ0cy5sYXN0KCk7 CisKKyAgICBjb25zdCBJbnN0cnVjdGlvblN0cmVhbSYgaW5zdHJ1Y3Rpb25zID0gY29kZUJsb2Nr LT5pbnN0cnVjdGlvbnMoKTsKKyAgICBjb25zdCBJbnN0cnVjdGlvbiogYW5JbnN0cnVjdGlvbiA9 IGluc3RydWN0aW9ucy5hdChieXRlY29kZUluZGV4KS5wdHIoKTsKKyAgICBPcGNvZGVJRCBvcGNv ZGVJZCA9IGFuSW5zdHJ1Y3Rpb24tPm9wY29kZUlEKCk7CisgICAgaW50IHN0YXJ0TG9jYXRpb24g PSBkaXZvdCAtIHN0YXJ0T2Zmc2V0OworICAgIGludCBlbmRMb2NhdGlvbiA9IGRpdm90ICsgZW5k T2Zmc2V0OworICAgIFN0cmluZyBrZXkgPSBjcmVhdGVMb29rdXBLZXkoc291cmNlRmlsZW5hbWUs IG9wY29kZUlkLCBzdGFydExvY2F0aW9uLCBlbmRMb2NhdGlvbik7CisgICAgRnV6emVyUHJlZGlj dGlvbnMmIGZ1enplclByZWRpY3Rpb25zID0gZW5zdXJlR2xvYmFsRnV6emVyUHJlZGljdGlvbnMo KTsKKyAgICBTcGVjdWxhdGVkVHlwZSBnZW5lcmF0ZWQgPSBmdXp6ZXJQcmVkaWN0aW9ucy5wcmVk aWN0aW9uRm9yKGtleSk7CisKKyAgICBzd2l0Y2ggKG9wY29kZUlkKSB7CisgICAgY2FzZSBvcF90 b190aGlzOiAvLyBicm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lk PTIwMzU1NQorICAgIGNhc2Ugb3BfZ2V0X2FyZ3VtZW50OiAvLyBicm9rZW4gaHR0cHM6Ly9idWdz LndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzU1NAorICAgICAgICByZXR1cm4gb3JpZ2lu YWw7CisKKyAgICBjYXNlIG9wX2JpdGFuZDogLy8gcGFydGlhbGx5IGJyb2tlbiBodHRwczovL2J1 Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAzNjA0CisgICAgY2FzZSBvcF9iaXRvcjog Ly8gcGFydGlhbGx5IGJyb2tlbiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/ aWQ9MjAzNjA0CisgICAgY2FzZSBvcF9iaXR4b3I6IC8vIHBhcnRpYWxseSBicm9rZW4gaHR0cHM6 Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzYwNAorICAgIGNhc2Ugb3BfYml0 bm90OiAvLyBwYXJ0aWFsbHkgYnJva2VuCisKKyAgICBjYXNlIG9wX3RvX251bWJlcjogLy8gaW5j b21wbGV0ZSAtLSBjYW4gYmUgZS5nLiBNZW1iZXJFeHByZXNzaW9uCisgICAgY2FzZSBvcF9nZXRf YnlfaWQ6IC8vIHNvbWV0aW1lcyBvY2N1cnMgZm9yIHRoaW5ncyByZWxhdGVkIHRvIFN5bWJvbC5p dGVyYXRvcgorICAgIGNhc2Ugb3BfZ2V0X2Zyb21fc2NvcGU6IC8vIHBhcnRpYWxseSBicm9rZW4g aHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzYwMworICAgIGNhc2Ug b3BfZ2V0X2Zyb21fYXJndW1lbnRzOiAvLyBwYXJ0aWFsbHkgYnJva2VuIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM2MDgKKyAgICBjYXNlIG9wX2dldF9ieV92YWw6 IC8vIHBhcnRpYWxseSBicm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTIwMzY2NQorICAgIGNhc2Ugb3BfcnNoaWZ0OiAvLyBwYXJ0aWFsbHkgYnJva2VuIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM2NjQKKyAgICBjYXNlIG9wX2xz aGlmdDogLy8gcGFydGlhbGx5IGJyb2tlbiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjAzNjY0CisgICAgICAgIGlmIChnZW5lcmF0ZWQgPT0gTk9fUFJFRElDVElPTl9G T1VORCkKKyAgICAgICAgICAgIHJldHVybiBvcmlnaW5hbDsKKyAgICAgICAgYnJlYWs7CisKKyAg ICBjYXNlIG9wX2NhbGw6CisgICAgICAgIGlmIChnZW5lcmF0ZWQgPT0gTk9fUFJFRElDVElPTl9G T1VORCkgeworICAgICAgICAgICAgaWYgKHNvdXJjZUFmdGVyRGl2b3QuY29udGFpbnNJZ25vcmlu Z0FTQ0lJQ2FzZSgib2YgIikpCisgICAgICAgICAgICAgICAgcmV0dXJuIG9yaWdpbmFsOworICAg ICAgICAgICAgaWYgKHNvdXJjZUFmdGVyRGl2b3QuY29udGFpbnNJZ25vcmluZ0FTQ0lJQ2FzZSgi Li4uIikpCisgICAgICAgICAgICAgICAgcmV0dXJuIG9yaWdpbmFsOworICAgICAgICAgICAgaWYg KHNvdXJjZUFmdGVyRGl2b3QuY29udGFpbnNJZ25vcmluZ0FTQ0lJQ2FzZSgieWllbGQiKSkKKyAg ICAgICAgICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAgICAgICAgICBpZiAoc291cmNlVXBU b0Rpdm90LmNvbnRhaW5zSWdub3JpbmdBU0NJSUNhc2UoInlpZWxkIikpCisgICAgICAgICAgICAg ICAgcmV0dXJuIG9yaWdpbmFsOworICAgICAgICAgICAgaWYgKHNvdXJjZVVwVG9EaXZvdCA9PSAi Li4uIikKKyAgICAgICAgICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAgICAgICAgICBpZiAo IXN0YXJ0T2Zmc2V0ICYmICFlbmRPZmZzZXQpCisgICAgICAgICAgICAgICAgcmV0dXJuIG9yaWdp bmFsOworICAgICAgICB9CisgICAgICAgIGJyZWFrOworCisgICAgY2FzZSBvcF9wdXRfYnlfaWQ6 CisgICAgY2FzZSBvcF9nZXRfYnlfdmFsX3dpdGhfdGhpczoKKyAgICBjYXNlIG9wX2dldF9kaXJl Y3RfcG5hbWU6CisgICAgY2FzZSBvcF9jb25zdHJ1Y3Q6CisgICAgY2FzZSBvcF9jb25zdHJ1Y3Rf dmFyYXJnczoKKyAgICBjYXNlIG9wX2NhbGxfdmFyYXJnczoKKyAgICBjYXNlIG9wX2NhbGxfZXZh bDoKKyAgICBjYXNlIG9wX3RhaWxfY2FsbDoKKyAgICBjYXNlIG9wX3RhaWxfY2FsbF92YXJhcmdz OgorICAgIGNhc2Ugb3BfZ2V0X2J5X2lkX3dpdGhfdGhpczoKKyAgICAgICAgYnJlYWs7CisKKyAg ICBkZWZhdWx0OgorICAgICAgICBkYXRhTG9nTG4oInVuaGFuZGxlZCBvcGNvZGU6ICIsIFJFRChC T0xEKG9wY29kZUlkKSkpOworI2lmIFBMQVRGT1JNKENPQ09BKQorICAgICAgICBTdHJpbmdCdWls ZGVyIGNyYXNoTG9nTWVzc2FnZTsKKyAgICAgICAgY3Jhc2hMb2dNZXNzYWdlLmFwcGVuZCgidW5o YW5kbGVkIG9wY29kZTogIiwgdG9TdHJpbmcob3Bjb2RlSWQpKTsKKyAgICAgICAgV1RGOjpzZXRD cmFzaExvZ01lc3NhZ2UoY3Jhc2hMb2dNZXNzYWdlLnRvU3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7 CisjZW5kaWYKKyAgICAgICAgQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgfQorICAgIGlmIChn ZW5lcmF0ZWQgPT0gTk9fUFJFRElDVElPTl9GT1VORCkgeworICAgICAgICBpZiAoT3B0aW9uczo6 ZHVtcEZ1enplckFnZW50UHJlZGljdGlvbnMoKSkKKyAgICAgICAgICAgIGRhdGFMb2dMbihNQUdF TlRBKEJPTEQoYnl0ZWNvZGVJbmRleCkpLCAiICIsIEJPTEQoWUVMTE9XKG9wY29kZUlkKSksICIg bWlzc2luZyBwcmVkaWN0aW9uIGZvcjogIiwgUkVEKEJPTEQoa2V5KSksICIgIiwgR1JFRU4oc291 cmNlRmlsZW5hbWUpLCAiOiIsIENZQU4obGluZSksICI6IiwgQ1lBTihjb2x1bW4pLCAiIGRpdm90 OiAiLCBkaXZvdCwgIiAtIiwgc3RhcnRPZmZzZXQsICIgKyIsIGVuZE9mZnNldCwgIiBuYW1lOiAn IiwgWUVMTE9XKGNvZGVCbG9jay0+aW5mZXJyZWROYW1lKCkpLCAiJyBzb3VyY2U6ICciLCBCTFVF KHNvdXJjZVVwVG9EaXZvdCksIEJMVUUoQk9MRChzb3VyY2VBZnRlckRpdm90KSksICInIik7CisK KyAgICAgICAgaWYgKE9wdGlvbnM6OnJlcXVpcmVQcmVkaWN0aW9uRm9yRmlsZUJhc2VkRnV6emVy QWdlbnQoKSkgeworI2lmIFBMQVRGT1JNKENPQ09BKQorICAgICAgICAgICAgU3RyaW5nQnVpbGRl ciBtaXNzaW5nUHJlZGljdGlvbkNyYXNoTG9nTWVzc2FnZTsKKyAgICAgICAgICAgIG1pc3NpbmdQ cmVkaWN0aW9uQ3Jhc2hMb2dNZXNzYWdlLmFwcGVuZCgibWlzc2luZyBwcmVkaWN0aW9uIGZvcjog Iiwga2V5KTsKKyAgICAgICAgICAgIFdURjo6c2V0Q3Jhc2hMb2dNZXNzYWdlKG1pc3NpbmdQcmVk aWN0aW9uQ3Jhc2hMb2dNZXNzYWdlLnRvU3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisjZW5kaWYK KyAgICAgICAgICAgIFJFTEVBU0VfQVNTRVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgIH0KKwor ICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAgfQorICAgIGlmIChPcHRpb25zOjpkdW1wRnV6 emVyQWdlbnRQcmVkaWN0aW9ucygpKQorICAgICAgICBkYXRhTG9nTG4oWUVMTE9XKG9wY29kZUlk KSwgIiAiLCBDWUFOKGtleSksICIgb3JpZ2luYWw6ICIsIENZQU4oQk9MRChTcGVjdWxhdGlvbkR1 bXAob3JpZ2luYWwpKSksICIgZ2VuZXJhdGVkOiAiLCBNQUdFTlRBKEJPTEQoU3BlY3VsYXRpb25E dW1wKGdlbmVyYXRlZCkpKSk7CisgICAgcmV0dXJuIGdlbmVyYXRlZDsKK30KKworU3RyaW5nIEZp bGVCYXNlZEZ1enplckFnZW50OjpjcmVhdGVMb29rdXBLZXkoY29uc3QgU3RyaW5nJiBzb3VyY2VG aWxlbmFtZSwgT3Bjb2RlSUQgb3Bjb2RlSWQsIGludCBzdGFydExvY2F0aW9uLCBpbnQgZW5kTG9j YXRpb24pCit7CisgICAgU3RyaW5nQnVpbGRlciBsb29rdXBLZXk7CisgICAgbG9va3VwS2V5LmFw cGVuZChzb3VyY2VGaWxlbmFtZSk7CisgICAgbG9va3VwS2V5LmFwcGVuZCgifCIpOworICAgIGxv b2t1cEtleS5hcHBlbmQodG9TdHJpbmcob3Bjb2RlQWxpYXNGb3JMb29rdXBLZXkob3Bjb2RlSWQp KSk7CisgICAgbG9va3VwS2V5LmFwcGVuZCgifCIpOworICAgIGxvb2t1cEtleS5hcHBlbmQoc3Rh cnRMb2NhdGlvbik7CisgICAgbG9va3VwS2V5LmFwcGVuZCgifCIpOworICAgIGxvb2t1cEtleS5h cHBlbmQoZW5kTG9jYXRpb24pOworICAgIHJldHVybiBsb29rdXBLZXkudG9TdHJpbmcoKTsKK30K KworT3Bjb2RlSUQgRmlsZUJhc2VkRnV6emVyQWdlbnQ6Om9wY29kZUFsaWFzRm9yTG9va3VwS2V5 KGNvbnN0IE9wY29kZUlEJiBvcGNvZGVJZCkKK3sKKyAgICBpZiAob3Bjb2RlSWQgPT0gb3BfY2Fs bF92YXJhcmdzIHx8IG9wY29kZUlkID09IG9wX2NhbGxfZXZhbCB8fCBvcGNvZGVJZCA9PSBvcF90 YWlsX2NhbGwgfHwgb3Bjb2RlSWQgPT0gb3BfdGFpbF9jYWxsX3ZhcmFyZ3MpCisgICAgICAgIHJl dHVybiBvcF9jYWxsOworICAgIGlmIChvcGNvZGVJZCA9PSBvcF9nZXRfZGlyZWN0X3BuYW1lIHx8 IG9wY29kZUlkID09IG9wX2dldF9ieV92YWxfd2l0aF90aGlzKQorICAgICAgICByZXR1cm4gb3Bf Z2V0X2J5X3ZhbDsKKyAgICBpZiAob3Bjb2RlSWQgPT0gb3BfY29uc3RydWN0X3ZhcmFyZ3MpCisg ICAgICAgIHJldHVybiBvcF9jb25zdHJ1Y3Q7CisgICAgcmV0dXJuIG9wY29kZUlkOworfQorCit9 IC8vIG5hbWVzcGFjZSBKU0MKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50 aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGlt ZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwLi41ZjI2NGRiYjBlMwotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50LmgKQEAgLTAsMCArMSw1MiBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAxOSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisg KgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmli dXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBg QVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFS RSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJ QlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQ RUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RT IE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lO RVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9S VAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkg V0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQg T0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25jZQor CisjaW5jbHVkZSAiRnV6emVyQWdlbnQuaCIKKyNpbmNsdWRlICJPcGNvZGUuaCIKKyNpbmNsdWRl IDx3dGYvTG9jay5oPgorI2luY2x1ZGUgPHd0Zi9XZWFrUmFuZG9tLmg+CisKK25hbWVzcGFjZSBK U0MgeworCitjbGFzcyBWTTsKKworY2xhc3MgRmlsZUJhc2VkRnV6emVyQWdlbnQgZmluYWwgOiBw dWJsaWMgRnV6emVyQWdlbnQgeworICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOworCitwdWJs aWM6CisgICAgRmlsZUJhc2VkRnV6emVyQWdlbnQoVk0mKTsKKworICAgIFNwZWN1bGF0ZWRUeXBl IGdldFByZWRpY3Rpb24oQ29kZUJsb2NrKiwgY29uc3QgQ29kZU9yaWdpbiYsIFNwZWN1bGF0ZWRU eXBlKSBvdmVycmlkZTsKKworcHJpdmF0ZToKKyAgICBMb2NrIG1fbG9jazsKKworICAgIHN0YXRp YyBTdHJpbmcgY3JlYXRlTG9va3VwS2V5KGNvbnN0IFN0cmluZyYgc291cmNlRmlsZW5hbWUsIE9w Y29kZUlELCBpbnQgc3RhcnRMb2NhdGlvbiwgaW50IGVuZExvY2F0aW9uKTsKKyAgICBzdGF0aWMg T3Bjb2RlSUQgb3Bjb2RlQWxpYXNGb3JMb29rdXBLZXkoY29uc3QgT3Bjb2RlSUQmKTsKK307CisK K30gLy8gbmFtZXNwYWNlIEpTQwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1 bnRpbWUvRnV6emVyUHJlZGljdGlvbnMuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRp bWUvRnV6emVyUHJlZGljdGlvbnMuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwLi5lY2ZjNDFjNTNlOAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmNwcApAQCAtMCwwICsxLDc4IEBACisvKgor ICogQ29weXJpZ2h0IChDKSAyMDE5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAq CisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3 aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0 aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJp YnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXBy b2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1l bnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1 dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBB UyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVS Q0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJF IERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklC VVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BF Q0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcs IEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMg T1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5F U1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0Yg TElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JU CisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBX QVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBP RiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZp Zy5oIgorI2luY2x1ZGUgIkZ1enplclByZWRpY3Rpb25zLmgiCisKK25hbWVzcGFjZSBKU0Mgewor RnV6emVyUHJlZGljdGlvbnM6OkZ1enplclByZWRpY3Rpb25zKGNvbnN0IGNoYXIqIGZpbGVuYW1l KQoreworICAgIGlmICghZmlsZW5hbWUpCisgICAgICAgIHJldHVybjsKKworICAgIEZJTEUqIGYg PSBmb3BlbihmaWxlbmFtZSwgInIiKTsKKyAgICBpZiAoIWYpIHsKKyAgICAgICAgZGF0YUxvZ0Yo IkZhaWxlZCB0byBvcGVuIGZpbGUgJXMuXG4iLCBmaWxlbmFtZSk7CisgICAgICAgIHJldHVybjsK KyAgICB9CisKKyAgICBjaGFyKiBsaW5lOworICAgIGNoYXIgYnVmZmVyW0JVRlNJWl07CisgICAg d2hpbGUgKChsaW5lID0gZmdldHMoYnVmZmVyLCBzaXplb2YoYnVmZmVyKSwgZikpKSB7CisgICAg ICAgIFNwZWN1bGF0ZWRUeXBlIHByZWRpY3Rpb247CisgICAgICAgIGNoYXIgbG9va3VwS2V5W0JV RlNJWl07CisgICAgICAgIGludCBudW1iZXJPZkl0ZW1zRm91bmQgPSBzc2NhbmYobGluZSwgIiVb XjpdOiVsbHhcbiIsIGxvb2t1cEtleSwgJnByZWRpY3Rpb24pOworICAgICAgICBSRUxFQVNFX0FT U0VSVChudW1iZXJPZkl0ZW1zRm91bmQgPT0gMik7CisgICAgICAgIGNvbnN0IFN0cmluZyYgZnVu Y3Rpb25OYW1lU3RyaW5nID0gU3RyaW5nKGxvb2t1cEtleSwgc3RybGVuKGxvb2t1cEtleSkpOwor ICAgICAgICBtX3ByZWRpY3Rpb25zLnNldChmdW5jdGlvbk5hbWVTdHJpbmcsIHByZWRpY3Rpb24p OworICAgIH0KKworICAgIGludCByZXN1bHQgPSBmY2xvc2UoZik7CisgICAgaWYgKHJlc3VsdCkK KyAgICAgICAgZGF0YUxvZ0YoIkZhaWxlZCB0byBjbG9zZSBmaWxlICVzOiAlc1xuIiwgZmlsZW5h bWUsIHN0cmVycm9yKGVycm5vKSk7Cit9CisKK1NwZWN1bGF0ZWRUeXBlIEZ1enplclByZWRpY3Rp b25zOjpwcmVkaWN0aW9uRm9yKGNvbnN0IFN0cmluZyYga2V5KQoreworICAgIGlmIChtX3ByZWRp Y3Rpb25zLmNvbnRhaW5zKGtleSkpIHsKKyAgICAgICAgU3BlY3VsYXRlZFR5cGUgcHJlZGljdGVk ID0gbV9wcmVkaWN0aW9ucy5nZXQoa2V5KTsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQoKHByZWRp Y3RlZCAmIFNwZWNGdWxsVG9wKSAhPSBTcGVjTm9uZSk7CisgICAgICAgIHJldHVybiBwcmVkaWN0 ZWQ7CisgICAgfQorICAgIHJldHVybiBOT19QUkVESUNUSU9OX0ZPVU5EOworfQorCitGdXp6ZXJQ cmVkaWN0aW9ucyYgZW5zdXJlR2xvYmFsRnV6emVyUHJlZGljdGlvbnMoKQoreworICAgIHN0YXRp YyBMYXp5TmV2ZXJEZXN0cm95ZWQ8RnV6emVyUHJlZGljdGlvbnM+IGZ1enplclByZWRpY3Rpb25z OworICAgIHN0YXRpYyBzdGQ6Om9uY2VfZmxhZyBpbml0aWFsaXplRnV6emVyUHJlZGljdGlvbnNG bGFnOworICAgIHN0ZDo6Y2FsbF9vbmNlKGluaXRpYWxpemVGdXp6ZXJQcmVkaWN0aW9uc0ZsYWcs IFtdIHsKKyAgICAgICAgY29uc3QgY2hhciogZnV6emVyUHJlZGljdGlvbnNGaWxlbmFtZSA9IE9w dGlvbnM6OmZ1enplclByZWRpY3Rpb25zKCk7CisgICAgICAgIGZ1enplclByZWRpY3Rpb25zLmNv bnN0cnVjdChmdXp6ZXJQcmVkaWN0aW9uc0ZpbGVuYW1lKTsKKyAgICB9KTsKKyAgICByZXR1cm4g ZnV6emVyUHJlZGljdGlvbnM7Cit9CisKK30gLy8gbmFtZXNwYWNlIEpTQwpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRnV6emVyUHJlZGljdGlvbnMuaCBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmgKbmV3IGZpbGUgbW9k ZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmUwYTJkZDdjYzY1Ci0tLSAvZGV2L251bGwKKysr IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRnV6emVyUHJlZGljdGlvbnMuaApAQCAt MCwwICsxLDQ4IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE5IEFwcGxlIEluYy4gQWxsIHJp Z2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBh bmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBl cm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1l dDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUg YWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFu ZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmlu YXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGlu IHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVk IHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVE IEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBX QVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVE IFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VM QVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJ TkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVD VCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBE QU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9G IFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICog UFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04g QU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1Qg TElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNF KSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUs IEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8K KworI3ByYWdtYSBvbmNlCisKKyNpbmNsdWRlIDxieXRlY29kZS9Db2RlQmxvY2suaD4KKyNpbmNs dWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgorCisj ZGVmaW5lIE5PX1BSRURJQ1RJT05fRk9VTkQgMXVsbCA8PCA1NQorCituYW1lc3BhY2UgSlNDIHsK KworY2xhc3MgRnV6emVyUHJlZGljdGlvbnMgeworcHVibGljOgorICAgIEpTX0VYUE9SVF9QUklW QVRFIEZ1enplclByZWRpY3Rpb25zKGNvbnN0IGNoYXIqKTsKKworICAgIFNwZWN1bGF0ZWRUeXBl IHByZWRpY3Rpb25Gb3IoY29uc3QgU3RyaW5nJik7CisKK3ByaXZhdGU6CisgICAgSGFzaE1hcDxT dHJpbmcsIFNwZWN1bGF0ZWRUeXBlPiBtX3ByZWRpY3Rpb25zOworfTsKKworSlNfRVhQT1JUX1BS SVZBVEUgRnV6emVyUHJlZGljdGlvbnMmIGVuc3VyZUdsb2JhbEZ1enplclByZWRpY3Rpb25zKCk7 CisKK30gLy8gbmFtZXNwYWNlIEpTQwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3J1bnRpbWUvT3B0aW9ucy5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9PcHRp b25zLmNwcAppbmRleCAzYjdiNmRiNDA1Ni4uNTRmMDBjMTJhNjYgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL09wdGlvbnMuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL09wdGlvbnMuY3BwCkBAIC00NDAsNyArNDQwLDcgQEAgc3RhdGljIHZv aWQgcmVjb21wdXRlRGVwZW5kZW50T3B0aW9ucygpCiAgICAgICAgIHx8IE9wdGlvbnM6OnZlcmJv c2VDRkEoKQogICAgICAgICB8fCBPcHRpb25zOjp2ZXJib3NlREZHRmFpbHVyZSgpCiAgICAgICAg IHx8IE9wdGlvbnM6OnZlcmJvc2VGVExGYWlsdXJlKCkKLSAgICAgICAgfHwgT3B0aW9uczo6ZHVt cFJhbmRvbWl6aW5nRnV6emVyQWdlbnRQcmVkaWN0aW9ucygpKQorICAgICAgICB8fCBPcHRpb25z OjpkdW1wRnV6emVyQWdlbnRQcmVkaWN0aW9ucygpKQogICAgICAgICBPcHRpb25zOjphbHdheXND b21wdXRlSGFzaCgpID0gdHJ1ZTsKICAgICAKICAgICBpZiAoIU9wdGlvbnM6OnVzZUNvbmN1cnJl bnRHQygpKQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvT3B0aW9u c0xpc3QuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL09wdGlvbnNMaXN0LmgKaW5k ZXggNTMyMGZjMTIwZjAuLmVjYTViMWE3ZjFkIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvcnVudGltZS9PcHRpb25zTGlzdC5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9y dW50aW1lL09wdGlvbnNMaXN0LmgKQEAgLTM3Myw4ICszNzMsMTEgQEAgbmFtZXNwYWNlIEpTQyB7 CiAgICAgdihVbnNpZ25lZCwgc2VlZE9mVk1SYW5kb21Gb3JGdXp6ZXIsIDAsIE5vcm1hbCwgIjAg bWVhbnMgbm90IGZ1enppbmcgdGhpczsgdXNlIGEgY3J5cHRvZ3JhcGhpY2FsbHkgcmFuZG9tIHNl ZWQiKSBcCiAgICAgdihCb29sLCB1c2VSYW5kb21pemluZ0Z1enplckFnZW50LCBmYWxzZSwgTm9y bWFsLCBudWxscHRyKSBcCiAgICAgdihVbnNpZ25lZCwgc2VlZE9mUmFuZG9taXppbmdGdXp6ZXJB Z2VudCwgMSwgTm9ybWFsLCBudWxscHRyKSBcCi0gICAgdihCb29sLCBkdW1wUmFuZG9taXppbmdG dXp6ZXJBZ2VudFByZWRpY3Rpb25zLCBmYWxzZSwgTm9ybWFsLCBudWxscHRyKSBcCisgICAgdihC b29sLCBkdW1wRnV6emVyQWdlbnRQcmVkaWN0aW9ucywgZmFsc2UsIE5vcm1hbCwgbnVsbHB0cikg XAogICAgIHYoQm9vbCwgdXNlRG91YmxlUHJlZGljdGlvbkZ1enplckFnZW50LCBmYWxzZSwgTm9y bWFsLCBudWxscHRyKSBcCisgICAgdihCb29sLCB1c2VGaWxlQmFzZWRGdXp6ZXJBZ2VudCwgZmFs c2UsIE5vcm1hbCwgbnVsbHB0cikgXAorICAgIHYoQm9vbCwgcmVxdWlyZVByZWRpY3Rpb25Gb3JG aWxlQmFzZWRGdXp6ZXJBZ2VudCwgZmFsc2UsIE5vcm1hbCwgbnVsbHB0cikgXAorICAgIHYoT3B0 aW9uU3RyaW5nLCBmdXp6ZXJQcmVkaWN0aW9ucywgbnVsbHB0ciwgTm9ybWFsLCAiZmlsZSB3aXRo IGxpc3Qgb2YgcHJlZGljdGlvbnMgZm9yIEZpbGVCYXNlZEZ1enplckFnZW50IikgXAogICAgIFwK ICAgICB2KEJvb2wsIGxvZ1BoYXNlVGltZXMsIGZhbHNlLCBOb3JtYWwsIG51bGxwdHIpIFwKICAg ICB2KERvdWJsZSwgcmFyZUJsb2NrUGVuYWx0eSwgMC4wMDEsIE5vcm1hbCwgbnVsbHB0cikgXApk aWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUmFuZG9taXppbmdGdXp6 ZXJBZ2VudC5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1 enplckFnZW50LmNwcAppbmRleCAzZDIyNTk1MWIyOS4uYzljNTRlN2UzY2MgMTAwNjQ0Ci0tLSBh L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1JhbmRvbWl6aW5nRnV6emVyQWdlbnQuY3Bw CisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1JhbmRvbWl6aW5nRnV6emVyQWdl bnQuY3BwCkBAIC00Miw3ICs0Miw3IEBAIFNwZWN1bGF0ZWRUeXBlIFJhbmRvbWl6aW5nRnV6emVy QWdlbnQ6OmdldFByZWRpY3Rpb24oQ29kZUJsb2NrKiBjb2RlQmxvY2ssIGNvbnN0CiAgICAgdWlu dDMyX3QgaGlnaCA9IG1fcmFuZG9tLmdldFVpbnQzMigpOwogICAgIHVpbnQzMl90IGxvdyA9IG1f cmFuZG9tLmdldFVpbnQzMigpOwogICAgIFNwZWN1bGF0ZWRUeXBlIGdlbmVyYXRlZCA9IHN0YXRp Y19jYXN0PFNwZWN1bGF0ZWRUeXBlPigoc3RhdGljX2Nhc3Q8dWludDY0X3Q+KGhpZ2gpIDw8IDMy KSB8IGxvdykgJiBTcGVjRnVsbFRvcDsKLSAgICBpZiAoT3B0aW9uczo6ZHVtcFJhbmRvbWl6aW5n RnV6emVyQWdlbnRQcmVkaWN0aW9ucygpKQorICAgIGlmIChPcHRpb25zOjpkdW1wRnV6emVyQWdl bnRQcmVkaWN0aW9ucygpKQogICAgICAgICBkYXRhTG9nTG4oImdldFByZWRpY3Rpb24gbmFtZToo IiwgY29kZUJsb2NrLT5pbmZlcnJlZE5hbWUoKSwgIiMiLCBjb2RlQmxvY2stPmhhc2hBc1N0cmlu Z0lmUG9zc2libGUoKSwgIiksYnl0ZWNvZGVJbmRleDooIiwgY29kZU9yaWdpbi5ieXRlY29kZUlu ZGV4KCksICIpLG9yaWdpbmFsOigiLCBTcGVjdWxhdGlvbkR1bXAob3JpZ2luYWwpLCAiKSxnZW5l cmF0ZWQ6KCIsIFNwZWN1bGF0aW9uRHVtcChnZW5lcmF0ZWQpLCAiKSIpOwogICAgIHJldHVybiBn ZW5lcmF0ZWQ7CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9W TS5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9WTS5jcHAKaW5kZXggNDU1OWFh N2FhM2IuLjRlYzg2NTlhZWE5IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVu dGltZS9WTS5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVk0uY3BwCkBA IC01MCw2ICs1MCw3IEBACiAjaW5jbHVkZSAiRXhlY3V0YWJsZVRvQ29kZUJsb2NrRWRnZS5oIgog I2luY2x1ZGUgIkZUTFRodW5rcy5oIgogI2luY2x1ZGUgIkZhc3RNYWxsb2NBbGlnbmVkTWVtb3J5 QWxsb2NhdG9yLmgiCisjaW5jbHVkZSAiRmlsZUJhc2VkRnV6emVyQWdlbnQuaCIKICNpbmNsdWRl ICJGdW5jdGlvbkNvZGVCbG9jay5oIgogI2luY2x1ZGUgIkZ1bmN0aW9uQ29uc3RydWN0b3IuaCIK ICNpbmNsdWRlICJGdW5jdGlvbkV4ZWN1dGFibGUuaCIKQEAgLTQ0Niw2ICs0NDcsOCBAQCBWTTo6 Vk0oVk1UeXBlIHZtVHlwZSwgSGVhcFR5cGUgaGVhcFR5cGUpCiAgICAgICAgIHNldEZ1enplckFn ZW50KG1ha2VVbmlxdWU8UmFuZG9taXppbmdGdXp6ZXJBZ2VudD4oKnRoaXMpKTsKICAgICBlbHNl IGlmIChPcHRpb25zOjp1c2VEb3VibGVQcmVkaWN0aW9uRnV6emVyQWdlbnQoKSkKICAgICAgICAg c2V0RnV6emVyQWdlbnQobWFrZVVuaXF1ZTxEb3VibGVQcmVkaWN0aW9uRnV6emVyQWdlbnQ+KCp0 aGlzKSk7CisgICAgZWxzZSBpZiAoT3B0aW9uczo6dXNlRmlsZUJhc2VkRnV6emVyQWdlbnQoKSkK KyAgICAgICAgc2V0RnV6emVyQWdlbnQobWFrZVVuaXF1ZTxGaWxlQmFzZWRGdXp6ZXJBZ2VudD4o KnRoaXMpKTsKIAogICAgIGlmIChPcHRpb25zOjphbHdheXNHZW5lcmF0ZVBDVG9Db2RlT3JpZ2lu TWFwKCkpCiAgICAgICAgIHNldFNob3VsZEJ1aWxkUENUb0NvZGVPcmlnaW5NYXBwaW5nKCk7Cg== 383452 2019-11-13 06:28:56 -0800 2019-11-13 23:52:45 -0800 update patch webkit_203898_c.patch text/plain 29187 tuomas.webkit ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQ2hhbmdlTG9nCmluZGV4IGQ1OTlkMjZiMTc0Li5lYWExN2UxZjA3MyAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMjUgQEAKKzIwMTktMTEtMTMgIFR1b21h cyBLYXJra2FpbmVuICA8dHVvbWFzLndlYmtpdEBhcHBsZS5jb20+CisKKyAgICAgICAgQWRkIEZ1 enplckFnZW50IHRoYXQgcmVhZHMgcHJlZGljdGlvbnMgZnJvbSBhIGZpbGUKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzg5OAorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2ggYWRkcyBhIEZ1 enplckFnZW50IHRoYXQgcmVhZHMgcHJlZGljdGlvbnMgZnJvbSBhIGZpbGUuIFRoZSBwcmVkaWN0 aW9ucyBpbiB0aGUgZmlsZSBhcmUKKyAgICAgICAgY29ycmVsYXRlZCB3aXRoIHRoZSBwcmVkaWN0 aW9uIHNpdGVzIHVzaW5nIHRoZSBuYW1lIG9mIHRoZSBKYXZhU2NyaXB0IHNvdXJjZSBmaWxlLCB0 aGUgb3Bjb2RlLCBhbmQKKyAgICAgICAgc3RhcnQgYW5kIGVuZCBvZmZzZXRzIGluIHRoZSBzb3Vy Y2UuCisKKyAgICAgICAgKiBKYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9q OgorICAgICAgICAqIFNvdXJjZXMudHh0OgorICAgICAgICAqIHJ1bnRpbWUvRmlsZUJhc2VkRnV6 emVyQWdlbnQuY3BwOiBBZGRlZC4KKyAgICAgICAgKiBydW50aW1lL0ZpbGVCYXNlZEZ1enplckFn ZW50Lmg6IENvcGllZCBmcm9tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1JhbmRvbWl6 aW5nRnV6emVyQWdlbnQuY3BwLgorICAgICAgICAqIHJ1bnRpbWUvRnV6emVyUHJlZGljdGlvbnMu Y3BwOiBBZGRlZC4KKyAgICAgICAgKiBydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmg6IENvcGll ZCBmcm9tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1JhbmRvbWl6aW5nRnV6emVyQWdl bnQuY3BwLgorICAgICAgICAqIHJ1bnRpbWUvT3B0aW9ucy5jcHA6CisgICAgICAgICogcnVudGlt ZS9PcHRpb25zTGlzdC5oOgorICAgICAgICAqIHJ1bnRpbWUvUmFuZG9taXppbmdGdXp6ZXJBZ2Vu dC5jcHA6CisgICAgICAgICogcnVudGltZS9WTS5jcHA6CisKIDIwMTktMTEtMTIgIFl1c3VrZSBT dXp1a2kgIDx5c3V6dWtpQGFwcGxlLmNvbT4KIAogICAgICAgICBbSlNDXSBQdXQgbW9yZSB0aGlu Z3MgaW4gSXNvU3Vic3BhY2UKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9KYXZh U2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggNGQyN2Q5 ODEwMTQuLjg1NDkxZWQ2YjJlIDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2 YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvSmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMTc0 MSw2ICsxNzQxLDggQEAKIAkJQzRGNEI2RjUxQTA1Qzk4NDAwNUNBQjc2IC8qIGdlbmVyYXRlX29i amNfcHJvdG9jb2xfdHlwZXNfaW1wbGVtZW50YXRpb24ucHkgaW4gSGVhZGVycyAqLyA9IHtpc2Eg PSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDNEY0QjZENzFBMDVDNzZGMDA1Q0FCNzYgLyogZ2Vu ZXJhdGVfb2JqY19wcm90b2NvbF90eXBlc19pbXBsZW1lbnRhdGlvbi5weSAqLzsgc2V0dGluZ3Mg PSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlDNEY0QjZGNjFBMDVDOTg0MDA1 Q0FCNzYgLyogb2JqY19nZW5lcmF0b3JfdGVtcGxhdGVzLnB5IGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzRGNEI2RDgxQTA1Qzc2RjAwNUNBQjc2IC8qIG9i amNfZ2VuZXJhdG9yX3RlbXBsYXRlcy5weSAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQ cml2YXRlLCApOyB9OyB9OwogCQlDRUFFN0Q3Qjg4OUI0NzdCQTkzQUJBNkMgLyogU2NyaXB0RmV0 Y2hlci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gODg1 MjE1MUE5QzM4NDIzODlCMzIxNUI3IC8qIFNjcmlwdEZldGNoZXIuaCAqLzsgc2V0dGluZ3MgPSB7 QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQlDRUNGQUQzNjIzNzJEQUQwMDAyOTE1 OTkgLyogRnV6emVyUHJlZGljdGlvbnMuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IENFQ0ZBRDM0MjM3MkRBQTcwMDI5MTU5OSAvKiBGdXp6ZXJQcmVkaWN0 aW9ucy5oICovOyB9OworCQlDRUNGQUQzNzIzNzJEQUQ0MDAyOTE1OTkgLyogRmlsZUJhc2VkRnV6 emVyQWdlbnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9 IENFQ0ZBRDMyMjM3MkRBQTcwMDI5MTU5OSAvKiBGaWxlQmFzZWRGdXp6ZXJBZ2VudC5oICovOyB9 OwogCQlEOTcyMjc1MkRDNTQ0NTlCOTEyNUI1MzkgLyogSlNNb2R1bGVMb2FkZXIuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDc3QjI1Q0IyQzMwOTRBOTJB MzhFMURCMyAvKiBKU01vZHVsZUxvYWRlci5oICovOyB9OwogCQlEQzAwMDM5MzE5RDhCRTZGMDAw MjNFQjAgLyogREZHUHJlY2lzZUxvY2FsQ2xvYmJlcml6ZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gREMwMDAzOTAxOUQ4QkU2RjAwMDIzRUIwIC8qIERG R1ByZWNpc2VMb2NhbENsb2JiZXJpemUuaCAqLzsgfTsKIAkJREMwMTg0MTkxRDEwQzE4OTAwNTdC MDUzIC8qIEpJVFdvcmtsaXN0LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBEQzAxODQxODFEMTBDMTg3MDA1N0IwNTMgLyogSklUV29ya2xpc3QuaCAqLzsg fTsKQEAgLTQ4MjYsNiArNDgyOCwxMCBAQAogCQlDNEY0QjZENjFBMDVDNzZGMDA1Q0FCNzYgLyog Z2VuZXJhdGVfY3BwX3Byb3RvY29sX3R5cGVzX2ltcGxlbWVudGF0aW9uLnB5ICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g dGV4dC5zY3JpcHQucHl0aG9uOyBwYXRoID0gZ2VuZXJhdGVfY3BwX3Byb3RvY29sX3R5cGVzX2lt cGxlbWVudGF0aW9uLnB5OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlDNEY0QjZENzFB MDVDNzZGMDA1Q0FCNzYgLyogZ2VuZXJhdGVfb2JqY19wcm90b2NvbF90eXBlc19pbXBsZW1lbnRh dGlvbi5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBs YXN0S25vd25GaWxlVHlwZSA9IHRleHQuc2NyaXB0LnB5dGhvbjsgcGF0aCA9IGdlbmVyYXRlX29i amNfcHJvdG9jb2xfdHlwZXNfaW1wbGVtZW50YXRpb24ucHk7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CiAJCUM0RjRCNkQ4MUEwNUM3NkYwMDVDQUI3NiAvKiBvYmpjX2dlbmVyYXRvcl90ZW1w bGF0ZXMucHkgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsg bGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0LnNjcmlwdC5weXRob247IHBhdGggPSBvYmpjX2dlbmVy YXRvcl90ZW1wbGF0ZXMucHk7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUNFQ0ZBRDMy MjM3MkRBQTcwMDI5MTU5OSAvKiBGaWxlQmFzZWRGdXp6ZXJBZ2VudC5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGgg PSBGaWxlQmFzZWRGdXp6ZXJBZ2VudC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlD RUNGQUQzMzIzNzJEQUE3MDAyOTE1OTkgLyogRmlsZUJhc2VkRnV6emVyQWdlbnQuY3BwICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5j cHAuY3BwOyBwYXRoID0gRmlsZUJhc2VkRnV6emVyQWdlbnQuY3BwOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OworCQlDRUNGQUQzNDIzNzJEQUE3MDAyOTE1OTkgLyogRnV6emVyUHJlZGljdGlv bnMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNv dXJjZWNvZGUuYy5oOyBwYXRoID0gRnV6emVyUHJlZGljdGlvbnMuaDsgc291cmNlVHJlZSA9ICI8 Z3JvdXA+IjsgfTsKKwkJQ0VDRkFEMzUyMzcyREFBNzAwMjkxNTk5IC8qIEZ1enplclByZWRpY3Rp b25zLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9 IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEZ1enplclByZWRpY3Rpb25zLmNwcDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRDIxMjAyMjgwQUQ0MzEwQzAwRUQ3OUI2IC8qIERhdGVD b252ZXJzaW9uLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2Rpbmcg PSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBEYXRl Q29udmVyc2lvbi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUQyMTIwMjI5MEFE NDMxMEMwMEVENzlCNiAvKiBEYXRlQ29udmVyc2lvbi5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUu Yy5oOyBwYXRoID0gRGF0ZUNvbnZlcnNpb24uaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJREMwMDAzOTAxOUQ4QkU2RjAwMDIzRUIwIC8qIERGR1ByZWNpc2VMb2NhbENsb2JiZXJpemUu aCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1lID0gREZHUHJlY2lzZUxvY2FsQ2xvYmJl cml6ZS5oOyBwYXRoID0gZGZnL0RGR1ByZWNpc2VMb2NhbENsb2JiZXJpemUuaDsgc291cmNlVHJl ZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTcwODUsNiArNzA5MSw4IEBACiAJCQkJMTQ3MzQxRTkxREMy Q0YyNTAwQUEyOUJBIC8qIEV4ZWN1dGFibGVCYXNlLmNwcCAqLywKIAkJCQkxNDczNDFDQjFEQzAy RDcyMDBBQTI5QkEgLyogRXhlY3V0YWJsZUJhc2UuaCAqLywKIAkJCQlFMzVBMEI5QzIyMEFEODdB MDBBQzQ0NzQgLyogRXhlY3V0YWJsZUJhc2VJbmxpbmVzLmggKi8sCisJCQkJQ0VDRkFEMzMyMzcy REFBNzAwMjkxNTk5IC8qIEZpbGVCYXNlZEZ1enplckFnZW50LmNwcCAqLywKKwkJCQlDRUNGQUQz MjIzNzJEQUE3MDAyOTE1OTkgLyogRmlsZUJhc2VkRnV6emVyQWdlbnQuaCAqLywKIAkJCQlBN0E4 QUYyOTE3QURCNUYzMDA1QUIxNzQgLyogRmxvYXQzMkFycmF5LmggKi8sCiAJCQkJQTdBOEFGMkEx N0FEQjVGMzAwNUFCMTc0IC8qIEZsb2F0NjRBcnJheS5oICovLAogCQkJCUJDMjY4MEMwMEUxNkQ0 RTkwMEEwNkU5MiAvKiBGdW5jdGlvbkNvbnN0cnVjdG9yLmNwcCAqLywKQEAgLTcxMDIsNiArNzEx MCw4IEBACiAJCQkJNjJEMkQzOEUxQURGMTAzRjAwMDIwNkMxIC8qIEZ1bmN0aW9uUmFyZURhdGEu aCAqLywKIAkJCQlFMzNBOTQ5NTIyNTUzMjJBMDBENDJCMDYgLyogRnV6emVyQWdlbnQuY3BwICov LAogCQkJCUUzM0E5NDkyMjI1NTMyMjkwMEQ0MkIwNiAvKiBGdXp6ZXJBZ2VudC5oICovLAorCQkJ CUNFQ0ZBRDM1MjM3MkRBQTcwMDI5MTU5OSAvKiBGdXp6ZXJQcmVkaWN0aW9ucy5jcHAgKi8sCisJ CQkJQ0VDRkFEMzQyMzcyREFBNzAwMjkxNTk5IC8qIEZ1enplclByZWRpY3Rpb25zLmggKi8sCiAJ CQkJNzBCNzkxODUxQzAyNDQzMjAwMjQ4MUUyIC8qIEdlbmVyYXRvckZ1bmN0aW9uQ29uc3RydWN0 b3IuY3BwICovLAogCQkJCTcwQjc5MTg2MUMwMjQ0MzIwMDI0ODFFMiAvKiBHZW5lcmF0b3JGdW5j dGlvbkNvbnN0cnVjdG9yLmggKi8sCiAJCQkJNzBCNzkxODcxQzAyNDQzMjAwMjQ4MUUyIC8qIEdl bmVyYXRvckZ1bmN0aW9uUHJvdG90eXBlLmNwcCAqLywKQEAgLTEwMDA2LDYgKzEwMDE2LDcgQEAK IAkJCQk1MzRFMDM1NjFFNTNCRURFMDAyMTNGNjQgLyogUHJveHlhYmxlQWNjZXNzQ2FzZS5oIGlu IEhlYWRlcnMgKi8sCiAJCQkJNzlCMDBDQkQxQzZBQjA3RTAwODhDNjVEIC8qIFByb3h5Q29uc3Ry dWN0b3IuaCBpbiBIZWFkZXJzICovLAogCQkJCTc5QjAwQ0JGMUM2QUIwN0UwMDg4QzY1RCAvKiBQ cm94eU9iamVjdC5oIGluIEhlYWRlcnMgKi8sCisJCQkJQ0VDRkFEMzcyMzcyREFENDAwMjkxNTk5 IC8qIEZpbGVCYXNlZEZ1enplckFnZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQk3OTE2MERCRTFD OEUzRUM4MDA4QzA4NUEgLyogUHJveHlSZXZva2UuaCBpbiBIZWFkZXJzICovLAogCQkJCTBGNTc4 MEEyMThGRTFFOTgwMDFFNzJEOSAvKiBQdXJlTmFOLmggaW4gSGVhZGVycyAqLywKIAkJCQkwRjE1 Q0QyMzFCQTVGOTg2MDAzMUZGRDMgLyogUHV0QnlJZEZsYWdzLmggaW4gSGVhZGVycyAqLywKQEAg LTEwMDg0LDYgKzEwMDk1LDcgQEAKIAkJCQlGRTMwMjJEMzFFM0Q3M0E1MDBCQUM0OTMgLyogU2ln aWxsQ3Jhc2hBbmFseXplci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMEY0RDhDNzgxRkNBM0NGQTAw MUQzMkFDIC8qIFNpbXBsZU1hcmtpbmdDb25zdHJhaW50LmggaW4gSGVhZGVycyAqLywKIAkJCQkw RjJCNjcwNTE3QjZCNUFCMDBBN0FFM0YgLyogU2ltcGxlVHlwZWRBcnJheUNvbnRyb2xsZXIuaCBp biBIZWFkZXJzICovLAorCQkJCUNFQ0ZBRDM2MjM3MkRBRDAwMDI5MTU5OSAvKiBGdXp6ZXJQcmVk aWN0aW9ucy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMTRCQTc4RjExM0FBQjg4RjAwNUI3QzJDIC8q IFNsb3RWaXNpdG9yLmggaW4gSGVhZGVycyAqLywKIAkJCQlDMjE2MEZFNzE1RjdFOTVFMDA5NDJE RkMgLyogU2xvdFZpc2l0b3JJbmxpbmVzLmggaW4gSGVhZGVycyAqLywKIAkJCQlBNzA5RjJGMDE3 QTBBQzA0MDA1MTJFOTggLyogU2xvd1BhdGhDYWxsLmggaW4gSGVhZGVycyAqLywKZGlmZiAtLWdp dCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9Tb3VyY2VzLnR4dCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9Tb3VyY2VzLnR4dAppbmRleCAyZDdkYTQyYWVkZC4uZWQ2YTBlZGFhMmUgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9Tb3VyY2VzLnR4dAorKysgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvU291cmNlcy50eHQKQEAgLTc2Niw2ICs3NjYsNyBAQCBydW50aW1lL0V4Y2VwdGlv bkZ1enouY3BwCiBydW50aW1lL0V4Y2VwdGlvbkhlbHBlcnMuY3BwCiBydW50aW1lL0V4Y2VwdGlv blNjb3BlLmNwcAogcnVudGltZS9FeGVjdXRhYmxlQmFzZS5jcHAKK3J1bnRpbWUvRmlsZUJhc2Vk RnV6emVyQWdlbnQuY3BwCiBydW50aW1lL0Z1bmN0aW9uQ29uc3RydWN0b3IuY3BwCiBydW50aW1l L0Z1bmN0aW9uRXhlY3V0YWJsZS5jcHAKIHJ1bnRpbWUvRnVuY3Rpb25FeGVjdXRhYmxlRHVtcC5j cHAKQEAgLTc3Myw2ICs3NzQsNyBAQCBydW50aW1lL0Z1bmN0aW9uSGFzRXhlY3V0ZWRDYWNoZS5j cHAKIHJ1bnRpbWUvRnVuY3Rpb25Qcm90b3R5cGUuY3BwCiBydW50aW1lL0Z1bmN0aW9uUmFyZURh dGEuY3BwCiBydW50aW1lL0Z1enplckFnZW50LmNwcAorcnVudGltZS9GdXp6ZXJQcmVkaWN0aW9u cy5jcHAKIHJ1bnRpbWUvR2VuZXJhdG9yRnVuY3Rpb25Db25zdHJ1Y3Rvci5jcHAKIHJ1bnRpbWUv R2VuZXJhdG9yRnVuY3Rpb25Qcm90b3R5cGUuY3BwCiBydW50aW1lL0dlbmVyYXRvclByb3RvdHlw ZS5jcHAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNl ZEZ1enplckFnZW50LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNl ZEZ1enplckFnZW50LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4u YjhjMTMwN2RlNWIKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVu dGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudC5jcHAKQEAgLTAsMCArMSwxODMgQEAKKy8qCisgKiBD b3B5cmlnaHQgKEMpIDIwMTkgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAq IFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGgg b3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQg dGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRp b25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVj ZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRp b25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0 aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9u LgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElT JycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywg QlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFO VEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElT Q0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9S UyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFM LAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBT RVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJ TlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFC SUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAq IChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBP VVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRI RSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgi CisjaW5jbHVkZSAiRmlsZUJhc2VkRnV6emVyQWdlbnQuaCIKKworI2luY2x1ZGUgIkNvZGVCbG9j ay5oIgorI2luY2x1ZGUgIkZ1enplclByZWRpY3Rpb25zLmgiCisjaW5jbHVkZSA8d3RmL0Fuc2lD b2xvcnMuaD4KKyNpbmNsdWRlIDx3dGYvTG9ja2VyLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvU3Ry aW5nQnVpbGRlci5oPgorI2lmIFBMQVRGT1JNKENPQ09BKQorI2luY2x1ZGUgPHd0Zi9jb2NvYS9D cmFzaFJlcG9ydGVyLmg+CisjZW5kaWYKKworbmFtZXNwYWNlIEpTQyB7CisKK0ZpbGVCYXNlZEZ1 enplckFnZW50OjpGaWxlQmFzZWRGdXp6ZXJBZ2VudChWTSYpCit7Cit9CisKK1NwZWN1bGF0ZWRU eXBlIEZpbGVCYXNlZEZ1enplckFnZW50OjpnZXRQcmVkaWN0aW9uKENvZGVCbG9jayogY29kZUJs b2NrLCBjb25zdCBDb2RlT3JpZ2luJiBjb2RlT3JpZ2luLCBTcGVjdWxhdGVkVHlwZSBvcmlnaW5h bCkKK3sKKyAgICBhdXRvIGxvY2tlciA9IGhvbGRMb2NrKG1fbG9jayk7CisKKyAgICBTY3JpcHRF eGVjdXRhYmxlKiBvd25lckV4ZWN1dGFibGUgPSBjb2RlQmxvY2stPm93bmVyRXhlY3V0YWJsZSgp OworICAgIGF1dG8gc291cmNlVVJMID0gb3duZXJFeGVjdXRhYmxlLT5zb3VyY2VVUkwoKTsKKyAg ICBpZiAoc291cmNlVVJMLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIG9yaWdpbmFsOworCisg ICAgaW50IGRpdm90ID0gMDsKKyAgICBpbnQgc3RhcnRPZmZzZXQgPSAtMTsKKyAgICBpbnQgZW5k T2Zmc2V0ID0gLTE7CisgICAgdW5zaWduZWQgbGluZSA9IDA7CisgICAgdW5zaWduZWQgY29sdW1u ID0gMDsKKyAgICBCeXRlY29kZUluZGV4IGJ5dGVjb2RlSW5kZXggPSBjb2RlT3JpZ2luLmJ5dGVj b2RlSW5kZXgoKTsKKyAgICBjb2RlQmxvY2stPmV4cHJlc3Npb25SYW5nZUZvckJ5dGVjb2RlSW5k ZXgoYnl0ZWNvZGVJbmRleCwgZGl2b3QsIHN0YXJ0T2Zmc2V0LCBlbmRPZmZzZXQsIGxpbmUsIGNv bHVtbik7CisKKyAgICBTb3VyY2VQcm92aWRlciogcHJvdmlkZXIgPSBjb2RlQmxvY2stPnNvdXJj ZSgpLnByb3ZpZGVyKCk7CisgICAgYXV0byBzb3VyY2VVcFRvRGl2b3QgPSBwcm92aWRlci0+c291 cmNlKCkuc3Vic3RyaW5nKGRpdm90IC0gc3RhcnRPZmZzZXQsIHN0YXJ0T2Zmc2V0KTsKKyAgICBh dXRvIHNvdXJjZUFmdGVyRGl2b3QgPSBwcm92aWRlci0+c291cmNlKCkuc3Vic3RyaW5nKGRpdm90 LCBlbmRPZmZzZXQpOworCisgICAgVmVjdG9yPFN0cmluZz4gdXJsUGFydHMgPSBzb3VyY2VVUkwu c3BsaXQoJy8nKTsKKyAgICBhdXRvIHNvdXJjZUZpbGVuYW1lID0gdXJsUGFydHMuaXNFbXB0eSgp ID8gc291cmNlVVJMIDogdXJsUGFydHMubGFzdCgpOworCisgICAgY29uc3QgSW5zdHJ1Y3Rpb25T dHJlYW0mIGluc3RydWN0aW9ucyA9IGNvZGVCbG9jay0+aW5zdHJ1Y3Rpb25zKCk7CisgICAgY29u c3QgSW5zdHJ1Y3Rpb24qIGFuSW5zdHJ1Y3Rpb24gPSBpbnN0cnVjdGlvbnMuYXQoYnl0ZWNvZGVJ bmRleCkucHRyKCk7CisgICAgT3Bjb2RlSUQgb3Bjb2RlSWQgPSBhbkluc3RydWN0aW9uLT5vcGNv ZGVJRCgpOworICAgIGludCBzdGFydExvY2F0aW9uID0gZGl2b3QgLSBzdGFydE9mZnNldDsKKyAg ICBpbnQgZW5kTG9jYXRpb24gPSBkaXZvdCArIGVuZE9mZnNldDsKKyAgICBTdHJpbmcga2V5ID0g Y3JlYXRlTG9va3VwS2V5KHNvdXJjZUZpbGVuYW1lLCBvcGNvZGVJZCwgc3RhcnRMb2NhdGlvbiwg ZW5kTG9jYXRpb24pOworICAgIEZ1enplclByZWRpY3Rpb25zJiBmdXp6ZXJQcmVkaWN0aW9ucyA9 IGVuc3VyZUdsb2JhbEZ1enplclByZWRpY3Rpb25zKCk7CisgICAgU3BlY3VsYXRlZFR5cGUgZ2Vu ZXJhdGVkID0gZnV6emVyUHJlZGljdGlvbnMucHJlZGljdGlvbkZvcihrZXkpOworCisgICAgc3dp dGNoIChvcGNvZGVJZCkgeworICAgICAgICAvLyBGSVhNRTogdGhlc2UgY2FuIG5vdCBiZSB0YXJn ZXRlZCBhdCBhbGwgZHVlIHRvIHRoZSBidWdzIGJlbG93CisgICAgY2FzZSBvcF90b190aGlzOiAv LyBicm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzU1NQor ICAgIGNhc2Ugb3BfZ2V0X2FyZ3VtZW50OiAvLyBicm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTIwMzU1NAorICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisKKyAg ICAgICAgLy8gRklYTUU6IHRoZSBvdXRwdXQgb2YgY29kZUJsb2NrLT5leHByZXNzaW9uUmFuZ2VG b3JCeXRlY29kZUluZGV4KCkgYWxsb3dzIGZvciBzb21lIG9mCisgICAgICAgIC8vIHRoZXNlIG9w Y29kZXMgdG8gaGF2ZSBwcmVkaWN0aW9ucywgYnV0IG5vdCBhbGwgaW5zdGFuY2VzIGNhbiBiZSBy ZWxpYWJseSB0YXJnZXRlZC4KKyAgICBjYXNlIG9wX2JpdGFuZDogLy8gcGFydGlhbGx5IGJyb2tl biBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAzNjA0CisgICAgY2Fz ZSBvcF9iaXRvcjogLy8gcGFydGlhbGx5IGJyb2tlbiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MjAzNjA0CisgICAgY2FzZSBvcF9iaXR4b3I6IC8vIHBhcnRpYWxseSBi cm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzYwNAorICAg IGNhc2Ugb3BfYml0bm90OiAvLyBwYXJ0aWFsbHkgYnJva2VuCisgICAgY2FzZSBvcF9nZXRfZnJv bV9zY29wZTogLy8gcGFydGlhbGx5IGJyb2tlbiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93 X2J1Zy5jZ2k/aWQ9MjAzNjAzCisgICAgY2FzZSBvcF9nZXRfZnJvbV9hcmd1bWVudHM6IC8vIHBh cnRpYWxseSBicm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIw MzYwOAorICAgIGNhc2Ugb3BfZ2V0X2J5X3ZhbDogLy8gcGFydGlhbGx5IGJyb2tlbiBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAzNjY1CisgICAgY2FzZSBvcF9yc2hp ZnQ6IC8vIHBhcnRpYWxseSBicm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcu Y2dpP2lkPTIwMzY2NAorICAgIGNhc2Ugb3BfbHNoaWZ0OiAvLyBwYXJ0aWFsbHkgYnJva2VuIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM2NjQKKyAgICBjYXNlIG9w X3RvX251bWJlcjogLy8gcGFydGlhbGx5IGJyb2tlbgorICAgIGNhc2Ugb3BfZ2V0X2J5X2lkOiAv LyBzb21ldGltZXMgb2NjdXJzIGltcGxpY2l0bHkgZm9yIHRoaW5ncyByZWxhdGVkIHRvIFN5bWJv bC5pdGVyYXRvcgorICAgICAgICBpZiAoZ2VuZXJhdGVkID09IE5PX1BSRURJQ1RJT05fRk9VTkQp CisgICAgICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAgICAgIGJyZWFrOworCisgICAgY2Fz ZSBvcF9jYWxsOiAvLyBvcF9jYWxsIGFwcGVhcnMgaW1wbGljaXRseSBpbiBmb3Itb2YgbG9vcHMs IGdlbmVyYXRvcnMsIHNwcmVhZC9yZXN0IGVsZW1lbnRzLCBkZXN0cnVjdHVyaW5nIGFzc2lnbm1l bnQKKyAgICAgICAgaWYgKGdlbmVyYXRlZCA9PSBOT19QUkVESUNUSU9OX0ZPVU5EKSB7CisgICAg ICAgICAgICBpZiAoc291cmNlQWZ0ZXJEaXZvdC5jb250YWluc0lnbm9yaW5nQVNDSUlDYXNlKCJv ZiAiKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAgICAgICAgICBpZiAo c291cmNlQWZ0ZXJEaXZvdC5jb250YWluc0lnbm9yaW5nQVNDSUlDYXNlKCIuLi4iKSkKKyAgICAg ICAgICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAgICAgICAgICBpZiAoc291cmNlQWZ0ZXJE aXZvdC5jb250YWluc0lnbm9yaW5nQVNDSUlDYXNlKCJ5aWVsZCIpKQorICAgICAgICAgICAgICAg IHJldHVybiBvcmlnaW5hbDsKKyAgICAgICAgICAgIGlmIChzb3VyY2VBZnRlckRpdm90LnN0YXJ0 c1dpdGgoJ1snKSAmJiBzb3VyY2VBZnRlckRpdm90LmVuZHNXaXRoKCJdIikpCisgICAgICAgICAg ICAgICAgcmV0dXJuIG9yaWdpbmFsOworICAgICAgICAgICAgaWYgKHNvdXJjZVVwVG9EaXZvdC5j b250YWluc0lnbm9yaW5nQVNDSUlDYXNlKCJ5aWVsZCIpKQorICAgICAgICAgICAgICAgIHJldHVy biBvcmlnaW5hbDsKKyAgICAgICAgICAgIGlmIChzb3VyY2VVcFRvRGl2b3QgPT0gIi4uLiIpCisg ICAgICAgICAgICAgICAgcmV0dXJuIG9yaWdpbmFsOworICAgICAgICAgICAgaWYgKCFzdGFydE9m ZnNldCAmJiAhZW5kT2Zmc2V0KQorICAgICAgICAgICAgICAgIHJldHVybiBvcmlnaW5hbDsKKyAg ICAgICAgfQorICAgICAgICBicmVhazsKKworICAgIGNhc2Ugb3BfZ2V0X2J5X3ZhbF93aXRoX3Ro aXM6CisgICAgY2FzZSBvcF9nZXRfZGlyZWN0X3BuYW1lOgorICAgIGNhc2Ugb3BfY29uc3RydWN0 OgorICAgIGNhc2Ugb3BfY29uc3RydWN0X3ZhcmFyZ3M6CisgICAgY2FzZSBvcF9jYWxsX3ZhcmFy Z3M6CisgICAgY2FzZSBvcF9jYWxsX2V2YWw6CisgICAgY2FzZSBvcF90YWlsX2NhbGw6CisgICAg Y2FzZSBvcF90YWlsX2NhbGxfdmFyYXJnczoKKyAgICBjYXNlIG9wX2dldF9ieV9pZF93aXRoX3Ro aXM6CisgICAgICAgIGJyZWFrOworCisgICAgZGVmYXVsdDoKKyAgICAgICAgZGF0YUxvZ0xuKCJ1 bmhhbmRsZWQgb3Bjb2RlOiAiLCBSRUQoQk9MRChvcGNvZGVJZCkpKTsKKyNpZiBQTEFURk9STShD T0NPQSkKKyAgICAgICAgU3RyaW5nQnVpbGRlciBjcmFzaExvZ01lc3NhZ2U7CisgICAgICAgIGNy YXNoTG9nTWVzc2FnZS5hcHBlbmQoInVuaGFuZGxlZCBvcGNvZGU6ICIsIHRvU3RyaW5nKG9wY29k ZUlkKSk7CisgICAgICAgIFdURjo6c2V0Q3Jhc2hMb2dNZXNzYWdlKGNyYXNoTG9nTWVzc2FnZS50 b1N0cmluZygpLnV0ZjgoKS5kYXRhKCkpOworI2VuZGlmCisgICAgICAgIFJFTEVBU0VfQVNTRVJU X05PVF9SRUFDSEVEKCk7CisgICAgfQorICAgIGlmIChnZW5lcmF0ZWQgPT0gTk9fUFJFRElDVElP Tl9GT1VORCkgeworICAgICAgICBpZiAoT3B0aW9uczo6ZHVtcEZ1enplckFnZW50UHJlZGljdGlv bnMoKSkKKyAgICAgICAgICAgIGRhdGFMb2dMbihNQUdFTlRBKEJPTEQoYnl0ZWNvZGVJbmRleCkp LCAiICIsIEJPTEQoWUVMTE9XKG9wY29kZUlkKSksICIgbWlzc2luZyBwcmVkaWN0aW9uIGZvcjog IiwgUkVEKEJPTEQoa2V5KSksICIgIiwgR1JFRU4oc291cmNlRmlsZW5hbWUpLCAiOiIsIENZQU4o bGluZSksICI6IiwgQ1lBTihjb2x1bW4pLCAiIGRpdm90OiAiLCBkaXZvdCwgIiAtIiwgc3RhcnRP ZmZzZXQsICIgKyIsIGVuZE9mZnNldCwgIiBuYW1lOiAnIiwgWUVMTE9XKGNvZGVCbG9jay0+aW5m ZXJyZWROYW1lKCkpLCAiJyBzb3VyY2U6ICciLCBCTFVFKHNvdXJjZVVwVG9EaXZvdCksIEJMVUUo Qk9MRChzb3VyY2VBZnRlckRpdm90KSksICInIik7CisKKyAgICAgICAgaWYgKE9wdGlvbnM6OnJl cXVpcmVQcmVkaWN0aW9uRm9yRmlsZUJhc2VkRnV6emVyQWdlbnQoKSkgeworI2lmIFBMQVRGT1JN KENPQ09BKQorICAgICAgICAgICAgU3RyaW5nQnVpbGRlciBtaXNzaW5nUHJlZGljdGlvbkNyYXNo TG9nTWVzc2FnZTsKKyAgICAgICAgICAgIG1pc3NpbmdQcmVkaWN0aW9uQ3Jhc2hMb2dNZXNzYWdl LmFwcGVuZCgibWlzc2luZyBwcmVkaWN0aW9uIGZvcjogIiwga2V5KTsKKyAgICAgICAgICAgIFdU Rjo6c2V0Q3Jhc2hMb2dNZXNzYWdlKG1pc3NpbmdQcmVkaWN0aW9uQ3Jhc2hMb2dNZXNzYWdlLnRv U3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisjZW5kaWYKKyAgICAgICAgICAgIFJFTEVBU0VfQVNT RVJUX05PVF9SRUFDSEVEKCk7CisgICAgICAgIH0KKworICAgICAgICByZXR1cm4gb3JpZ2luYWw7 CisgICAgfQorICAgIGlmIChPcHRpb25zOjpkdW1wRnV6emVyQWdlbnRQcmVkaWN0aW9ucygpKQor ICAgICAgICBkYXRhTG9nTG4oWUVMTE9XKG9wY29kZUlkKSwgIiAiLCBDWUFOKGtleSksICIgb3Jp Z2luYWw6ICIsIENZQU4oQk9MRChTcGVjdWxhdGlvbkR1bXAob3JpZ2luYWwpKSksICIgZ2VuZXJh dGVkOiAiLCBNQUdFTlRBKEJPTEQoU3BlY3VsYXRpb25EdW1wKGdlbmVyYXRlZCkpKSk7CisgICAg cmV0dXJuIGdlbmVyYXRlZDsKK30KKworU3RyaW5nIEZpbGVCYXNlZEZ1enplckFnZW50OjpjcmVh dGVMb29rdXBLZXkoY29uc3QgU3RyaW5nJiBzb3VyY2VGaWxlbmFtZSwgT3Bjb2RlSUQgb3Bjb2Rl SWQsIGludCBzdGFydExvY2F0aW9uLCBpbnQgZW5kTG9jYXRpb24pCit7CisgICAgU3RyaW5nQnVp bGRlciBsb29rdXBLZXk7CisgICAgbG9va3VwS2V5LmFwcGVuZChzb3VyY2VGaWxlbmFtZSk7Cisg ICAgbG9va3VwS2V5LmFwcGVuZCgifCIpOworICAgIGxvb2t1cEtleS5hcHBlbmQodG9TdHJpbmco b3Bjb2RlQWxpYXNGb3JMb29rdXBLZXkob3Bjb2RlSWQpKSk7CisgICAgbG9va3VwS2V5LmFwcGVu ZCgifCIpOworICAgIGxvb2t1cEtleS5hcHBlbmQoc3RhcnRMb2NhdGlvbik7CisgICAgbG9va3Vw S2V5LmFwcGVuZCgifCIpOworICAgIGxvb2t1cEtleS5hcHBlbmQoZW5kTG9jYXRpb24pOworICAg IHJldHVybiBsb29rdXBLZXkudG9TdHJpbmcoKTsKK30KKworT3Bjb2RlSUQgRmlsZUJhc2VkRnV6 emVyQWdlbnQ6Om9wY29kZUFsaWFzRm9yTG9va3VwS2V5KGNvbnN0IE9wY29kZUlEJiBvcGNvZGVJ ZCkKK3sKKyAgICBpZiAob3Bjb2RlSWQgPT0gb3BfY2FsbF92YXJhcmdzIHx8IG9wY29kZUlkID09 IG9wX2NhbGxfZXZhbCB8fCBvcGNvZGVJZCA9PSBvcF90YWlsX2NhbGwgfHwgb3Bjb2RlSWQgPT0g b3BfdGFpbF9jYWxsX3ZhcmFyZ3MpCisgICAgICAgIHJldHVybiBvcF9jYWxsOworICAgIGlmIChv cGNvZGVJZCA9PSBvcF9nZXRfZGlyZWN0X3BuYW1lIHx8IG9wY29kZUlkID09IG9wX2dldF9ieV92 YWxfd2l0aF90aGlzKQorICAgICAgICByZXR1cm4gb3BfZ2V0X2J5X3ZhbDsKKyAgICBpZiAob3Bj b2RlSWQgPT0gb3BfY29uc3RydWN0X3ZhcmFyZ3MpCisgICAgICAgIHJldHVybiBvcF9jb25zdHJ1 Y3Q7CisgICAgcmV0dXJuIG9wY29kZUlkOworfQorCit9IC8vIG5hbWVzcGFjZSBKU0MKZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50 LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudC5o Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi41ZjI2NGRiYjBlMwotLS0g L2Rldi9udWxsCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1 enplckFnZW50LmgKQEAgLTAsMCArMSw1MiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxOSBB cHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBS RVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s IFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZF TlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5Z IERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9S IENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisg KiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVT RSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZF UiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdF TkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBP RiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNV Q0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisjaW5jbHVkZSAiRnV6emVyQWdlbnQu aCIKKyNpbmNsdWRlICJPcGNvZGUuaCIKKyNpbmNsdWRlIDx3dGYvTG9jay5oPgorI2luY2x1ZGUg PHd0Zi9XZWFrUmFuZG9tLmg+CisKK25hbWVzcGFjZSBKU0MgeworCitjbGFzcyBWTTsKKworY2xh c3MgRmlsZUJhc2VkRnV6emVyQWdlbnQgZmluYWwgOiBwdWJsaWMgRnV6emVyQWdlbnQgeworICAg IFdURl9NQUtFX0ZBU1RfQUxMT0NBVEVEOworCitwdWJsaWM6CisgICAgRmlsZUJhc2VkRnV6emVy QWdlbnQoVk0mKTsKKworICAgIFNwZWN1bGF0ZWRUeXBlIGdldFByZWRpY3Rpb24oQ29kZUJsb2Nr KiwgY29uc3QgQ29kZU9yaWdpbiYsIFNwZWN1bGF0ZWRUeXBlKSBvdmVycmlkZTsKKworcHJpdmF0 ZToKKyAgICBMb2NrIG1fbG9jazsKKworICAgIHN0YXRpYyBTdHJpbmcgY3JlYXRlTG9va3VwS2V5 KGNvbnN0IFN0cmluZyYgc291cmNlRmlsZW5hbWUsIE9wY29kZUlELCBpbnQgc3RhcnRMb2NhdGlv biwgaW50IGVuZExvY2F0aW9uKTsKKyAgICBzdGF0aWMgT3Bjb2RlSUQgb3Bjb2RlQWxpYXNGb3JM b29rdXBLZXkoY29uc3QgT3Bjb2RlSUQmKTsKK307CisKK30gLy8gbmFtZXNwYWNlIEpTQwpkaWZm IC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRnV6emVyUHJlZGljdGlvbnMu Y3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRnV6emVyUHJlZGljdGlvbnMuY3Bw Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi5iNzliOWU3NjM5MwotLS0g L2Rldi9udWxsCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Z1enplclByZWRp Y3Rpb25zLmNwcApAQCAtMCwwICsxLDEwNiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxOSBB cHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5k IHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2Rp ZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRp dGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUg bXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0 cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmln aHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dp bmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1h dGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZU V0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBS RVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s IFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVT UyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZF TlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5Z IERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9S IENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisg KiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVT RSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZF UiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBD T05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdF TkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBP RiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNV Q0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJGdXp6ZXJQ cmVkaWN0aW9ucy5oIgorCituYW1lc3BhY2UgSlNDIHsKK0Z1enplclByZWRpY3Rpb25zOjpGdXp6 ZXJQcmVkaWN0aW9ucyhjb25zdCBjaGFyKiBmaWxlbmFtZSkKK3sKKyAgICBpZiAoIWZpbGVuYW1l KQorICAgICAgICByZXR1cm47CisKKyAgICBGSUxFKiBmID0gZm9wZW4oZmlsZW5hbWUsICJyIik7 CisgICAgaWYgKCFmKSB7CisgICAgICAgIGRhdGFMb2dGKCJGYWlsZWQgdG8gb3BlbiBmaWxlICVz LlxuIiwgZmlsZW5hbWUpOworICAgICAgICByZXR1cm47CisgICAgfQorCisgICAgY2hhciogbGlu ZTsKKyAgICBjaGFyIGJ1ZmZlcltCVUZTSVpdOworICAgIHdoaWxlICgobGluZSA9IGZnZXRzKGJ1 ZmZlciwgc2l6ZW9mKGJ1ZmZlciksIGYpKSkgeworICAgICAgICAvLyBHZXQgcmlkIG9mIG5ld2xp bmVzIGF0IHRoZSBlbmRzIG9mIHRoZSBzdHJpbmdzLgorICAgICAgICBzaXplX3QgbGVuZ3RoID0g c3RybGVuKGxpbmUpOworICAgICAgICBpZiAobGluZVtsZW5ndGggLSAxXSA9PSAnXG4nKSB7Cisg ICAgICAgICAgICBsaW5lW2xlbmd0aCAtIDFdID0gJ1wwJzsKKyAgICAgICAgICAgIGxlbmd0aC0t OworICAgICAgICB9CisKKyAgICAgICAgLy8gUHJlZGljdGlvbnMgYXJlIHN0b3JlZCBpbiBhIHRl eHQgZmlsZSwgb25lIHByZWRpY3Rpb24gcGVyIGxpbmUgaW4gdGhlIGNvbG9uIGRlbGltaXRlZCBm b3JtYXQ6CisgICAgICAgIC8vIDxsb29rdXAga2V5Pjo8cHJlZGljdGlvbiBpbiBoZXggd2l0aG91 dCBsZWFkaW5nIDB4PgorICAgICAgICAvLyBUaGUgbG9va3VwIGtleSBpcyBhIHBpcGUgc2VwYXJh dGVkIHN0cmluZyB3aXRoIHRoZSBmb3JtYXQ6CisgICAgICAgIC8vIDxmaWxlbmFtZT58PG9wY29k ZT58PHN0YXJ0IG9mZnNldD58PGVuZCBvZmZzZXQ+CisKKyAgICAgICAgLy8gVGhlIHN0YXJ0IGFu ZCBlbmQgb2Zmc2V0cyBhcmUgNy1iaXQgdW5zaWduZWQgaW50ZWdlcnMuCisgICAgICAgIC8vIElm IHN0YXJ0IG9mZnNldCA+IDEyNywgdGhlbiBib3RoIHN0YXJ0IGFuZCBlbmQgb2Zmc2V0cyBhcmUg MC4KKyAgICAgICAgLy8gSWYgZW5kIG9mZnNldCA+IDEyNywgdGhlbiB0aGUgZW5kIG9mZnNldCBp cyAwLgorCisgICAgICAgIC8vIEV4YW1wbGUgcHJlZGljdGlvbnM6CisgICAgICAgIC8vIGZvby5q c3xvcF9jb25zdHJ1Y3R8NzAyfDcyMToxMDAwMDg0CisgICAgICAgIC8vIGZvby5qc3xvcF9jYWxs fDc0OHw3NjA6NDA4ODAwCisgICAgICAgIC8vIGZvby5qc3xvcF9iaXRub3R8NzcwfDc3MDoyODAw MDAwMDAKKworICAgICAgICAvLyBUaGVyZSBhcmUgY3VycmVudGx5IG5vIHB1YmxpYyB0b29scyB0 byBnZW5lcmF0ZSBwcmVkaWN0aW9ucy4KKyAgICAgICAgLy8gU29tZSBvcGNvZGVzIGFyZSBhbGlh c2VkIHRvZ2V0aGVyIHRvIG1ha2UgZ2VuZXJhdGluZyB0aGUgcHJlZGljdGlvbnMgbW9yZSBzdHJh aWdodGZvcndhcmQuCisgICAgICAgIC8vIEZvciB0aGUgYWxpYXNlcyBzZWU6IEZpbGVCYXNlZEZ1 enplckFnZW50OjpvcGNvZGVBbGlhc0Zvckxvb2t1cEtleSgpCisKKyAgICAgICAgLy8gRklYTUU6 IFRoZSBjdXJyZW50IGltcGxlbWVudGF0aW9uIG9ubHkgc3VwcG9ydHMgb25lIHByZWRpY3Rpb24g cGVyIGxvb2t1cCBrZXkuCisKKyAgICAgICAgY29uc3QgVmVjdG9yPFN0cmluZz4mIGxpbmVQYXJ0 cyA9IFN0cmluZyhsaW5lLCBsZW5ndGgpLnNwbGl0KCc6Jyk7CisgICAgICAgIFJFTEVBU0VfQVNT RVJUX1dJVEhfTUVTU0FHRShsaW5lUGFydHMuc2l6ZSgpID09IDIsICJFeHBlY3RlZCBsaW5lIHdp dGggdHdvIHBhcnRzIGRlbGltaXRlZCBieSBhIGNvbG9uLiBGb3VuZCBsaW5lIHdpdGggJWx1IHBh cnRzLiIsIGxpbmVQYXJ0cy5zaXplKCkpOworICAgICAgICBjb25zdCBTdHJpbmcmIGxvb2t1cEtl eSA9IGxpbmVQYXJ0c1swXTsKKyAgICAgICAgY29uc3QgU3RyaW5nJiBwcmVkaWN0aW9uU3RyaW5n ID0gbGluZVBhcnRzWzFdOworICAgICAgICBib29sIG9rOworICAgICAgICBTcGVjdWxhdGVkVHlw ZSBwcmVkaWN0aW9uID0gcHJlZGljdGlvblN0cmluZy50b1VJbnQ2NFN0cmljdCgmb2ssIDB4MTAp OworICAgICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0Uob2ssICJDb3VsZCBub3QgcGFy c2UgcHJlZGljdGlvbiBmcm9tICclcyciLCBwcmVkaWN0aW9uU3RyaW5nLnV0ZjgoKS5kYXRhKCkp OworICAgICAgICBSRUxFQVNFX0FTU0VSVChzcGVjdWxhdGlvbkNoZWNrZWQocHJlZGljdGlvbiwg U3BlY0Z1bGxUb3ApKTsKKyAgICAgICAgbV9wcmVkaWN0aW9ucy5zZXQobG9va3VwS2V5LCBwcmVk aWN0aW9uKTsKKyAgICB9CisKKyAgICBpbnQgcmVzdWx0ID0gZmNsb3NlKGYpOworICAgIGlmIChy ZXN1bHQpCisgICAgICAgIGRhdGFMb2dGKCJGYWlsZWQgdG8gY2xvc2UgZmlsZSAlczogJXNcbiIs IGZpbGVuYW1lLCBzdHJlcnJvcihlcnJubykpOworfQorCitTcGVjdWxhdGVkVHlwZSBGdXp6ZXJQ cmVkaWN0aW9uczo6cHJlZGljdGlvbkZvcihjb25zdCBTdHJpbmcmIGtleSkKK3sKKyAgICBpZiAo bV9wcmVkaWN0aW9ucy5jb250YWlucyhrZXkpKQorICAgICAgICByZXR1cm4gbV9wcmVkaWN0aW9u cy5nZXQoa2V5KTsKKworICAgIHJldHVybiBOT19QUkVESUNUSU9OX0ZPVU5EOworfQorCitGdXp6 ZXJQcmVkaWN0aW9ucyYgZW5zdXJlR2xvYmFsRnV6emVyUHJlZGljdGlvbnMoKQoreworICAgIHN0 YXRpYyBMYXp5TmV2ZXJEZXN0cm95ZWQ8RnV6emVyUHJlZGljdGlvbnM+IGZ1enplclByZWRpY3Rp b25zOworICAgIHN0YXRpYyBzdGQ6Om9uY2VfZmxhZyBpbml0aWFsaXplRnV6emVyUHJlZGljdGlv bnNGbGFnOworICAgIHN0ZDo6Y2FsbF9vbmNlKGluaXRpYWxpemVGdXp6ZXJQcmVkaWN0aW9uc0Zs YWcsIFtdIHsKKyAgICAgICAgY29uc3QgY2hhciogZnV6emVyUHJlZGljdGlvbnNGaWxlbmFtZSA9 IE9wdGlvbnM6OmZ1enplclByZWRpY3Rpb25zKCk7CisgICAgICAgIGZ1enplclByZWRpY3Rpb25z LmNvbnN0cnVjdChmdXp6ZXJQcmVkaWN0aW9uc0ZpbGVuYW1lKTsKKyAgICB9KTsKKyAgICByZXR1 cm4gZnV6emVyUHJlZGljdGlvbnM7Cit9CisKK30gLy8gbmFtZXNwYWNlIEpTQwpkaWZmIC0tZ2l0 IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRnV6emVyUHJlZGljdGlvbnMuaCBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmgKbmV3IGZpbGUg bW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLjU2MTc1YzNmNThlCi0tLSAvZGV2L251bGwK KysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRnV6emVyUHJlZGljdGlvbnMuaApA QCAtMCwwICsxLDQ4IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE5IEFwcGxlIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJl IG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy IGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3Zp ZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJ REVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElF RCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBM SUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBM RSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJ UkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElB TCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5U IE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgor ICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQg T04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJ Q1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJX SVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisg Ki8KKworI3ByYWdtYSBvbmNlCisKKyNpbmNsdWRlIDxieXRlY29kZS9Db2RlQmxvY2suaD4KKyNp bmNsdWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgor CisjZGVmaW5lIE5PX1BSRURJQ1RJT05fRk9VTkQgflNwZWNGdWxsVG9wCisKK25hbWVzcGFjZSBK U0MgeworCitjbGFzcyBGdXp6ZXJQcmVkaWN0aW9ucyB7CitwdWJsaWM6CisgICAgSlNfRVhQT1JU X1BSSVZBVEUgRnV6emVyUHJlZGljdGlvbnMoY29uc3QgY2hhciopOworCisgICAgU3BlY3VsYXRl ZFR5cGUgcHJlZGljdGlvbkZvcihjb25zdCBTdHJpbmcmKTsKKworcHJpdmF0ZToKKyAgICBIYXNo TWFwPFN0cmluZywgU3BlY3VsYXRlZFR5cGU+IG1fcHJlZGljdGlvbnM7Cit9OworCitKU19FWFBP UlRfUFJJVkFURSBGdXp6ZXJQcmVkaWN0aW9ucyYgZW5zdXJlR2xvYmFsRnV6emVyUHJlZGljdGlv bnMoKTsKKworfSAvLyBuYW1lc3BhY2UgSlNDCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvcnVudGltZS9PcHRpb25zLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L09wdGlvbnMuY3BwCmluZGV4IDNiN2I2ZGI0MDU2Li41NGYwMGMxMmE2NiAxMDA2NDQKLS0tIGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvT3B0aW9ucy5jcHAKKysrIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL3J1bnRpbWUvT3B0aW9ucy5jcHAKQEAgLTQ0MCw3ICs0NDAsNyBAQCBzdGF0 aWMgdm9pZCByZWNvbXB1dGVEZXBlbmRlbnRPcHRpb25zKCkKICAgICAgICAgfHwgT3B0aW9uczo6 dmVyYm9zZUNGQSgpCiAgICAgICAgIHx8IE9wdGlvbnM6OnZlcmJvc2VERkdGYWlsdXJlKCkKICAg ICAgICAgfHwgT3B0aW9uczo6dmVyYm9zZUZUTEZhaWx1cmUoKQotICAgICAgICB8fCBPcHRpb25z OjpkdW1wUmFuZG9taXppbmdGdXp6ZXJBZ2VudFByZWRpY3Rpb25zKCkpCisgICAgICAgIHx8IE9w dGlvbnM6OmR1bXBGdXp6ZXJBZ2VudFByZWRpY3Rpb25zKCkpCiAgICAgICAgIE9wdGlvbnM6OmFs d2F5c0NvbXB1dGVIYXNoKCkgPSB0cnVlOwogICAgIAogICAgIGlmICghT3B0aW9uczo6dXNlQ29u Y3VycmVudEdDKCkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9P cHRpb25zTGlzdC5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvT3B0aW9uc0xpc3Qu aAppbmRleCBjZjE0NWYxZWJmNS4uZTJlZGRlYWIwMmQgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9ydW50aW1lL09wdGlvbnNMaXN0LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL3J1bnRpbWUvT3B0aW9uc0xpc3QuaApAQCAtMzc0LDggKzM3NCwxMSBAQCBuYW1lc3BhY2Ug SlNDIHsKICAgICB2KFVuc2lnbmVkLCBzZWVkT2ZWTVJhbmRvbUZvckZ1enplciwgMCwgTm9ybWFs LCAiMCBtZWFucyBub3QgZnV6emluZyB0aGlzOyB1c2UgYSBjcnlwdG9ncmFwaGljYWxseSByYW5k b20gc2VlZCIpIFwKICAgICB2KEJvb2wsIHVzZVJhbmRvbWl6aW5nRnV6emVyQWdlbnQsIGZhbHNl LCBOb3JtYWwsIG51bGxwdHIpIFwKICAgICB2KFVuc2lnbmVkLCBzZWVkT2ZSYW5kb21pemluZ0Z1 enplckFnZW50LCAxLCBOb3JtYWwsIG51bGxwdHIpIFwKLSAgICB2KEJvb2wsIGR1bXBSYW5kb21p emluZ0Z1enplckFnZW50UHJlZGljdGlvbnMsIGZhbHNlLCBOb3JtYWwsIG51bGxwdHIpIFwKKyAg ICB2KEJvb2wsIGR1bXBGdXp6ZXJBZ2VudFByZWRpY3Rpb25zLCBmYWxzZSwgTm9ybWFsLCBudWxs cHRyKSBcCiAgICAgdihCb29sLCB1c2VEb3VibGVQcmVkaWN0aW9uRnV6emVyQWdlbnQsIGZhbHNl LCBOb3JtYWwsIG51bGxwdHIpIFwKKyAgICB2KEJvb2wsIHVzZUZpbGVCYXNlZEZ1enplckFnZW50 LCBmYWxzZSwgTm9ybWFsLCBudWxscHRyKSBcCisgICAgdihCb29sLCByZXF1aXJlUHJlZGljdGlv bkZvckZpbGVCYXNlZEZ1enplckFnZW50LCBmYWxzZSwgTm9ybWFsLCBudWxscHRyKSBcCisgICAg dihPcHRpb25TdHJpbmcsIGZ1enplclByZWRpY3Rpb25zLCBudWxscHRyLCBOb3JtYWwsICJmaWxl IHdpdGggbGlzdCBvZiBwcmVkaWN0aW9ucyBmb3IgRmlsZUJhc2VkRnV6emVyQWdlbnQiKSBcCiAg ICAgXAogICAgIHYoQm9vbCwgbG9nUGhhc2VUaW1lcywgZmFsc2UsIE5vcm1hbCwgbnVsbHB0cikg XAogICAgIHYoRG91YmxlLCByYXJlQmxvY2tQZW5hbHR5LCAwLjAwMSwgTm9ybWFsLCBudWxscHRy KSBcCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemlu Z0Z1enplckFnZW50LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1JhbmRvbWl6 aW5nRnV6emVyQWdlbnQuY3BwCmluZGV4IDNkMjI1OTUxYjI5Li5jOWM1NGU3ZTNjYyAxMDA2NDQK LS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUmFuZG9taXppbmdGdXp6ZXJBZ2Vu dC5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUmFuZG9taXppbmdGdXp6 ZXJBZ2VudC5jcHAKQEAgLTQyLDcgKzQyLDcgQEAgU3BlY3VsYXRlZFR5cGUgUmFuZG9taXppbmdG dXp6ZXJBZ2VudDo6Z2V0UHJlZGljdGlvbihDb2RlQmxvY2sqIGNvZGVCbG9jaywgY29uc3QKICAg ICB1aW50MzJfdCBoaWdoID0gbV9yYW5kb20uZ2V0VWludDMyKCk7CiAgICAgdWludDMyX3QgbG93 ID0gbV9yYW5kb20uZ2V0VWludDMyKCk7CiAgICAgU3BlY3VsYXRlZFR5cGUgZ2VuZXJhdGVkID0g c3RhdGljX2Nhc3Q8U3BlY3VsYXRlZFR5cGU+KChzdGF0aWNfY2FzdDx1aW50NjRfdD4oaGlnaCkg PDwgMzIpIHwgbG93KSAmIFNwZWNGdWxsVG9wOwotICAgIGlmIChPcHRpb25zOjpkdW1wUmFuZG9t aXppbmdGdXp6ZXJBZ2VudFByZWRpY3Rpb25zKCkpCisgICAgaWYgKE9wdGlvbnM6OmR1bXBGdXp6 ZXJBZ2VudFByZWRpY3Rpb25zKCkpCiAgICAgICAgIGRhdGFMb2dMbigiZ2V0UHJlZGljdGlvbiBu YW1lOigiLCBjb2RlQmxvY2stPmluZmVycmVkTmFtZSgpLCAiIyIsIGNvZGVCbG9jay0+aGFzaEFz U3RyaW5nSWZQb3NzaWJsZSgpLCAiKSxieXRlY29kZUluZGV4OigiLCBjb2RlT3JpZ2luLmJ5dGVj b2RlSW5kZXgoKSwgIiksb3JpZ2luYWw6KCIsIFNwZWN1bGF0aW9uRHVtcChvcmlnaW5hbCksICIp LGdlbmVyYXRlZDooIiwgU3BlY3VsYXRpb25EdW1wKGdlbmVyYXRlZCksICIpIik7CiAgICAgcmV0 dXJuIGdlbmVyYXRlZDsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50 aW1lL1ZNLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNLmNwcAppbmRleCBi ZDFlOWZmNjZhNS4uYjIzMGJlNjQ3NDEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9ydW50aW1lL1ZNLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9WTS5j cHAKQEAgLTUwLDYgKzUwLDcgQEAKICNpbmNsdWRlICJFeGVjdXRhYmxlVG9Db2RlQmxvY2tFZGdl LmgiCiAjaW5jbHVkZSAiRlRMVGh1bmtzLmgiCiAjaW5jbHVkZSAiRmFzdE1hbGxvY0FsaWduZWRN ZW1vcnlBbGxvY2F0b3IuaCIKKyNpbmNsdWRlICJGaWxlQmFzZWRGdXp6ZXJBZ2VudC5oIgogI2lu Y2x1ZGUgIkZ1bmN0aW9uQ29kZUJsb2NrLmgiCiAjaW5jbHVkZSAiRnVuY3Rpb25Db25zdHJ1Y3Rv ci5oIgogI2luY2x1ZGUgIkZ1bmN0aW9uRXhlY3V0YWJsZS5oIgpAQCAtNDQ4LDYgKzQ0OSw4IEBA IFZNOjpWTShWTVR5cGUgdm1UeXBlLCBIZWFwVHlwZSBoZWFwVHlwZSkKICAgICAgICAgc2V0RnV6 emVyQWdlbnQobWFrZVVuaXF1ZTxSYW5kb21pemluZ0Z1enplckFnZW50PigqdGhpcykpOwogICAg IGVsc2UgaWYgKE9wdGlvbnM6OnVzZURvdWJsZVByZWRpY3Rpb25GdXp6ZXJBZ2VudCgpKQogICAg ICAgICBzZXRGdXp6ZXJBZ2VudChtYWtlVW5pcXVlPERvdWJsZVByZWRpY3Rpb25GdXp6ZXJBZ2Vu dD4oKnRoaXMpKTsKKyAgICBlbHNlIGlmIChPcHRpb25zOjp1c2VGaWxlQmFzZWRGdXp6ZXJBZ2Vu dCgpKQorICAgICAgICBzZXRGdXp6ZXJBZ2VudChtYWtlVW5pcXVlPEZpbGVCYXNlZEZ1enplckFn ZW50PigqdGhpcykpOwogCiAgICAgaWYgKE9wdGlvbnM6OmFsd2F5c0dlbmVyYXRlUENUb0NvZGVP cmlnaW5NYXAoKSkKICAgICAgICAgc2V0U2hvdWxkQnVpbGRQQ1RvQ29kZU9yaWdpbk1hcHBpbmco KTsK 383545 2019-11-13 23:52:45 -0800 2019-11-19 07:04:09 -0800 proposed patch webkit_203898_d.patch text/plain 43350 tuomas.webkit ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQ2hhbmdlTG9nCmluZGV4IGQ1OTlkMjZiMTc0Li41MjU4MjI1YWFkYyAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTktMTEtMTMgIFR1b21h cyBLYXJra2FpbmVuICA8dHVvbWFzLndlYmtpdEBhcHBsZS5jb20+CisKKyAgICAgICAgQWRkIEZ1 enplckFnZW50IHRoYXQgcmVhZHMgcHJlZGljdGlvbnMgZnJvbSBhIGZpbGUKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzg5OAorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2ggYWRkcyBhIEZ1 enplckFnZW50IHRoYXQgcmVhZHMgcHJlZGljdGlvbnMgZnJvbSBhIGZpbGUuIFRoZSBwcmVkaWN0 aW9ucyBpbiB0aGUgZmlsZSBhcmUKKyAgICAgICAgY29ycmVsYXRlZCB3aXRoIHRoZSBwcmVkaWN0 aW9uIHNpdGVzIHVzaW5nIHRoZSBuYW1lIG9mIHRoZSBKYXZhU2NyaXB0IHNvdXJjZSBmaWxlLCB0 aGUgb3Bjb2RlLCBhbmQKKyAgICAgICAgc3RhcnQgYW5kIGVuZCBvZmZzZXRzIGluIHRoZSBzb3Vy Y2UuIFRoZXJlIGlzIGFsc28gYSBzZXBhcmF0ZSBGdXp6ZXJBZ2VudCB0aGF0IGNhbiBiZSB1c2Vk IHRvIGNyZWF0ZQorICAgICAgICB0aGUgcHJlZGljdGlvbiBmaWxlcy4KKworICAgICAgICAqIEph dmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogU291cmNl cy50eHQ6CisgICAgICAgICogcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudC5jcHA6IEFkZGVk LgorICAgICAgICAqIHJ1bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnQuaDogQ29waWVkIGZyb20g U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUmFuZG9taXppbmdGdXp6ZXJBZ2VudC5jcHAu CisgICAgICAgICogcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UuY3BwOiBDb3BpZWQg ZnJvbSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFnZW50 LmNwcC4KKyAgICAgICAgKiBydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5oOiBDb3Bp ZWQgZnJvbSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFn ZW50LmNwcC4KKyAgICAgICAgKiBydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmNwcDogQWRkZWQu CisgICAgICAgICogcnVudGltZS9GdXp6ZXJQcmVkaWN0aW9ucy5oOiBDb3BpZWQgZnJvbSBTb3Vy Y2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFnZW50LmNwcC4KKyAg ICAgICAgKiBydW50aW1lL09wdGlvbnMuY3BwOgorICAgICAgICAqIHJ1bnRpbWUvT3B0aW9uc0xp c3QuaDoKKyAgICAgICAgKiBydW50aW1lL1ByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2Vu dC5jcHA6IEFkZGVkLgorICAgICAgICAqIHJ1bnRpbWUvUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1 enplckFnZW50Lmg6IENvcGllZCBmcm9tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1Jh bmRvbWl6aW5nRnV6emVyQWdlbnQuY3BwLgorICAgICAgICAqIHJ1bnRpbWUvUmFuZG9taXppbmdG dXp6ZXJBZ2VudC5jcHA6CisgICAgICAgICogcnVudGltZS9WTS5jcHA6CisKIDIwMTktMTEtMTIg IFl1c3VrZSBTdXp1a2kgIDx5c3V6dWtpQGFwcGxlLmNvbT4KIAogICAgICAgICBbSlNDXSBQdXQg bW9yZSB0aGluZ3MgaW4gSXNvU3Vic3BhY2UKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9KYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5k ZXggNGQyN2Q5ODEwMTQuLjE2ZWRhYjI2Yjk2IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvSmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJv agpAQCAtMTc0MCw3ICsxNzQwLDExIEBACiAJCUM0RjRCNkY0MUEwNUM5NDQwMDVDQUI3NiAvKiBj cHBfZ2VuZXJhdG9yLnB5IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxl UmVmID0gQzRGNEI2RDAxQTA1Qzc2RjAwNUNBQjc2IC8qIGNwcF9nZW5lcmF0b3IucHkgKi87IHNl dHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJQzRGNEI2RjUxQTA1 Qzk4NDAwNUNBQjc2IC8qIGdlbmVyYXRlX29iamNfcHJvdG9jb2xfdHlwZXNfaW1wbGVtZW50YXRp b24ucHkgaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDNEY0 QjZENzFBMDVDNzZGMDA1Q0FCNzYgLyogZ2VuZXJhdGVfb2JqY19wcm90b2NvbF90eXBlc19pbXBs ZW1lbnRhdGlvbi5weSAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9 OyB9OwogCQlDNEY0QjZGNjFBMDVDOTg0MDA1Q0FCNzYgLyogb2JqY19nZW5lcmF0b3JfdGVtcGxh dGVzLnB5IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzRG NEI2RDgxQTA1Qzc2RjAwNUNBQjc2IC8qIG9iamNfZ2VuZXJhdG9yX3RlbXBsYXRlcy5weSAqLzsg c2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OworCQlDRTIwQkQwNTIz N0QzRTIzMDA0NkU1MjAgLyogRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmggaW4gSGVhZGVycyAq LyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDRTIwQkQwMzIzN0QzQUQ0MDA0NkU1 MjAgLyogRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmggKi87IH07CisJCUNFMjBCRDA3MjM3RDNF NDgwMDQ2RTUyMCAvKiBQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IENFMjBCRDAxMjM3RDNBRDQw MDQ2RTUyMCAvKiBQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuaCAqLzsgfTsKIAkJ Q0VBRTdEN0I4ODlCNDc3QkE5M0FCQTZDIC8qIFNjcmlwdEZldGNoZXIuaCBpbiBIZWFkZXJzICov ID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IDg4NTIxNTFBOUMzODQyMzg5QjMyMTVC NyAvKiBTY3JpcHRGZXRjaGVyLmggKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0 ZSwgKTsgfTsgfTsKKwkJQ0VDRkFEMzYyMzcyREFEMDAwMjkxNTk5IC8qIEZ1enplclByZWRpY3Rp b25zLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDRUNG QUQzNDIzNzJEQUE3MDAyOTE1OTkgLyogRnV6emVyUHJlZGljdGlvbnMuaCAqLzsgfTsKKwkJQ0VD RkFEMzcyMzcyREFENDAwMjkxNTk5IC8qIEZpbGVCYXNlZEZ1enplckFnZW50LmggaW4gSGVhZGVy cyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDRUNGQUQzMjIzNzJEQUE3MDAy OTE1OTkgLyogRmlsZUJhc2VkRnV6emVyQWdlbnQuaCAqLzsgfTsKIAkJRDk3MjI3NTJEQzU0NDU5 QjkxMjVCNTM5IC8qIEpTTW9kdWxlTG9hZGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhC dWlsZEZpbGU7IGZpbGVSZWYgPSA3N0IyNUNCMkMzMDk0QTkyQTM4RTFEQjMgLyogSlNNb2R1bGVM b2FkZXIuaCAqLzsgfTsKIAkJREMwMDAzOTMxOUQ4QkU2RjAwMDIzRUIwIC8qIERGR1ByZWNpc2VM b2NhbENsb2JiZXJpemUuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IERDMDAwMzkwMTlEOEJFNkYwMDAyM0VCMCAvKiBERkdQcmVjaXNlTG9jYWxDbG9iYmVy aXplLmggKi87IH07CiAJCURDMDE4NDE5MUQxMEMxODkwMDU3QjA1MyAvKiBKSVRXb3JrbGlzdC5o IGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gREMwMTg0MTgx RDEwQzE4NzAwNTdCMDUzIC8qIEpJVFdvcmtsaXN0LmggKi87IH07CkBAIC00ODI2LDYgKzQ4MzAs MTQgQEAKIAkJQzRGNEI2RDYxQTA1Qzc2RjAwNUNBQjc2IC8qIGdlbmVyYXRlX2NwcF9wcm90b2Nv bF90eXBlc19pbXBsZW1lbnRhdGlvbi5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuc2NyaXB0LnB5dGhvbjsg cGF0aCA9IGdlbmVyYXRlX2NwcF9wcm90b2NvbF90eXBlc19pbXBsZW1lbnRhdGlvbi5weTsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQzRGNEI2RDcxQTA1Qzc2RjAwNUNBQjc2IC8qIGdl bmVyYXRlX29iamNfcHJvdG9jb2xfdHlwZXNfaW1wbGVtZW50YXRpb24ucHkgKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0 ZXh0LnNjcmlwdC5weXRob247IHBhdGggPSBnZW5lcmF0ZV9vYmpjX3Byb3RvY29sX3R5cGVzX2lt cGxlbWVudGF0aW9uLnB5OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlDNEY0QjZEODFB MDVDNzZGMDA1Q0FCNzYgLyogb2JqY19nZW5lcmF0b3JfdGVtcGxhdGVzLnB5ICovID0ge2lzYSA9 IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0g dGV4dC5zY3JpcHQucHl0aG9uOyBwYXRoID0gb2JqY19nZW5lcmF0b3JfdGVtcGxhdGVzLnB5OyBz b3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDRTIwQkQwMTIzN0QzQUQ0MDA0NkU1MjAgLyog UHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50LmggKi8gPSB7aXNhID0gUEJYRmlsZVJl ZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFByZWRp Y3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OworCQlDRTIwQkQwMjIzN0QzQUQ0MDA0NkU1MjAgLyogUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1 enplckFnZW50LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxl VHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFByZWRpY3Rpb25GaWxlQ3JlYXRpbmdG dXp6ZXJBZ2VudC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUNFMjBCRDAzMjM3 RDNBRDQwMDQ2RTUyMCAvKiBGaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UuaCAqLyA9IHtpc2EgPSBQ QlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRo ID0gRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07 CisJCUNFMjBCRDA0MjM3RDNBRDQwMDQ2RTUyMCAvKiBGaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2Uu Y3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmNwcDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJQ0VDRkFEMzIyMzcyREFBNzAwMjkxNTk5IC8qIEZp bGVCYXNlZEZ1enplckFnZW50LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtu b3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEZpbGVCYXNlZEZ1enplckFnZW50 Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUNFQ0ZBRDMzMjM3MkRBQTcwMDI5MTU5 OSAvKiBGaWxlQmFzZWRGdXp6ZXJBZ2VudC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBGaWxlQmFz ZWRGdXp6ZXJBZ2VudC5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUNFQ0ZBRDM0 MjM3MkRBQTcwMDI5MTU5OSAvKiBGdXp6ZXJQcmVkaWN0aW9ucy5oICovID0ge2lzYSA9IFBCWEZp bGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBG dXp6ZXJQcmVkaWN0aW9ucy5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDRUNGQUQz NTIzNzJEQUE3MDAyOTE1OTkgLyogRnV6emVyUHJlZGljdGlvbnMuY3BwICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBw YXRoID0gRnV6emVyUHJlZGljdGlvbnMuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9Owog CQlEMjEyMDIyODBBRDQzMTBDMDBFRDc5QjYgLyogRGF0ZUNvbnZlcnNpb24uY3BwICovID0ge2lz YSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlw ZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IERhdGVDb252ZXJzaW9uLmNwcDsgc291cmNl VHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRDIxMjAyMjkwQUQ0MzEwQzAwRUQ3OUI2IC8qIERhdGVD b252ZXJzaW9uLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0g MzA7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBEYXRlQ29udmVy c2lvbi5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlEQzAwMDM5MDE5RDhCRTZGMDAw MjNFQjAgLyogREZHUHJlY2lzZUxvY2FsQ2xvYmJlcml6ZS5oICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jLmg7IG5hbWUgPSBERkdQcmVjaXNlTG9jYWxDbG9iYmVyaXplLmg7IHBhdGggPSBkZmcvREZH UHJlY2lzZUxvY2FsQ2xvYmJlcml6ZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAt NzA4NSw2ICs3MDk3LDEwIEBACiAJCQkJMTQ3MzQxRTkxREMyQ0YyNTAwQUEyOUJBIC8qIEV4ZWN1 dGFibGVCYXNlLmNwcCAqLywKIAkJCQkxNDczNDFDQjFEQzAyRDcyMDBBQTI5QkEgLyogRXhlY3V0 YWJsZUJhc2UuaCAqLywKIAkJCQlFMzVBMEI5QzIyMEFEODdBMDBBQzQ0NzQgLyogRXhlY3V0YWJs ZUJhc2VJbmxpbmVzLmggKi8sCisJCQkJQ0VDRkFEMzMyMzcyREFBNzAwMjkxNTk5IC8qIEZpbGVC YXNlZEZ1enplckFnZW50LmNwcCAqLywKKwkJCQlDRUNGQUQzMjIzNzJEQUE3MDAyOTE1OTkgLyog RmlsZUJhc2VkRnV6emVyQWdlbnQuaCAqLywKKwkJCQlDRTIwQkQwNDIzN0QzQUQ0MDA0NkU1MjAg LyogRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmNwcCAqLywKKwkJCQlDRTIwQkQwMzIzN0QzQUQ0 MDA0NkU1MjAgLyogRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmggKi8sCiAJCQkJQTdBOEFGMjkx N0FEQjVGMzAwNUFCMTc0IC8qIEZsb2F0MzJBcnJheS5oICovLAogCQkJCUE3QThBRjJBMTdBREI1 RjMwMDVBQjE3NCAvKiBGbG9hdDY0QXJyYXkuaCAqLywKIAkJCQlCQzI2ODBDMDBFMTZENEU5MDBB MDZFOTIgLyogRnVuY3Rpb25Db25zdHJ1Y3Rvci5jcHAgKi8sCkBAIC03MTAyLDYgKzcxMTgsOCBA QAogCQkJCTYyRDJEMzhFMUFERjEwM0YwMDAyMDZDMSAvKiBGdW5jdGlvblJhcmVEYXRhLmggKi8s CiAJCQkJRTMzQTk0OTUyMjU1MzIyQTAwRDQyQjA2IC8qIEZ1enplckFnZW50LmNwcCAqLywKIAkJ CQlFMzNBOTQ5MjIyNTUzMjI5MDBENDJCMDYgLyogRnV6emVyQWdlbnQuaCAqLywKKwkJCQlDRUNG QUQzNTIzNzJEQUE3MDAyOTE1OTkgLyogRnV6emVyUHJlZGljdGlvbnMuY3BwICovLAorCQkJCUNF Q0ZBRDM0MjM3MkRBQTcwMDI5MTU5OSAvKiBGdXp6ZXJQcmVkaWN0aW9ucy5oICovLAogCQkJCTcw Qjc5MTg1MUMwMjQ0MzIwMDI0ODFFMiAvKiBHZW5lcmF0b3JGdW5jdGlvbkNvbnN0cnVjdG9yLmNw cCAqLywKIAkJCQk3MEI3OTE4NjFDMDI0NDMyMDAyNDgxRTIgLyogR2VuZXJhdG9yRnVuY3Rpb25D b25zdHJ1Y3Rvci5oICovLAogCQkJCTcwQjc5MTg3MUMwMjQ0MzIwMDI0ODFFMiAvKiBHZW5lcmF0 b3JGdW5jdGlvblByb3RvdHlwZS5jcHAgKi8sCkBAIC03NDI1LDYgKzc0NDMsOCBAQAogCQkJCTBG RTIyOEVCMTQzNkFCMjMwMDE5NkM0OCAvKiBPcHRpb25zLmggKi8sCiAJCQkJRkUzODQyMzEyMzI0 RDUxQjAwOURENDQ1IC8qIE9wdGlvbnNMaXN0LmggKi8sCiAJCQkJMzdDNzM4RDExRURCNTY3MjAw M0YyQjBCIC8qIFBhcnNlSW50LmggKi8sCisJCQkJQ0UyMEJEMDIyMzdEM0FENDAwNDZFNTIwIC8q IFByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5jcHAgKi8sCisJCQkJQ0UyMEJEMDEy MzdEM0FENDAwNDZFNTIwIC8qIFByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5oICov LAogCQkJCTg2ODkxNkE5MTU1RjI4NTQwMENCMkI5QSAvKiBQcml2YXRlTmFtZS5oICovLAogCQkJ CTE0NzM0MURGMURDMkNFOTYwMEFBMjlCQSAvKiBQcm9ncmFtRXhlY3V0YWJsZS5jcHAgKi8sCiAJ CQkJMTQ3MzQxRDMxREMwMkU2RDAwQUEyOUJBIC8qIFByb2dyYW1FeGVjdXRhYmxlLmggKi8sCkBA IC05NTkyLDYgKzk2MTIsNyBAQAogCQkJCUExODE5M0U0MUI0RTBDREIwMEZDMTAyOSAvKiBJbnRs Q29sbGF0b3JQcm90b3R5cGUubHV0LmggaW4gSGVhZGVycyAqLywKIAkJCQlBMTU4N0Q2RTFCNERD MTQxMDBENjk4NDkgLyogSW50bERhdGVUaW1lRm9ybWF0LmggaW4gSGVhZGVycyAqLywKIAkJCQlB MTU4N0Q3MDFCNERDMTQxMDBENjk4NDkgLyogSW50bERhdGVUaW1lRm9ybWF0Q29uc3RydWN0b3Iu aCBpbiBIZWFkZXJzICovLAorCQkJCUNFMjBCRDA1MjM3RDNFMjMwMDQ2RTUyMCAvKiBGaWxlQmFz ZWRGdXp6ZXJBZ2VudEJhc2UuaCBpbiBIZWFkZXJzICovLAogCQkJCUExNTg3RDc1MUI0REMxQzYw MEQ2OTg0OSAvKiBJbnRsRGF0ZVRpbWVGb3JtYXRDb25zdHJ1Y3Rvci5sdXQuaCBpbiBIZWFkZXJz ICovLAogCQkJCUExNTg3RDcyMUI0REMxNDEwMEQ2OTg0OSAvKiBJbnRsRGF0ZVRpbWVGb3JtYXRQ cm90b3R5cGUuaCBpbiBIZWFkZXJzICovLAogCQkJCUExNTg3RDc2MUI0REMxQzYwMEQ2OTg0OSAv KiBJbnRsRGF0ZVRpbWVGb3JtYXRQcm90b3R5cGUubHV0LmggaW4gSGVhZGVycyAqLywKQEAgLTk4 ODksNiArOTkxMCw3IEBACiAJCQkJMEY3QzVGQjgxRDg4OEEwQzAwNDRGNUUyIC8qIE1hcmtlZEJs b2NrSW5saW5lcy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMTQxNDQ4Q0IxM0ExNzZFQzAwRjVCQTFB IC8qIE1hcmtlZEJsb2NrU2V0LmggaW4gSGVhZGVycyAqLywKIAkJCQkxNEQyRjNEQjEzOUY0QkUy MDA0OTEwMzEgLyogTWFya2VkU3BhY2UuaCBpbiBIZWFkZXJzICovLAorCQkJCUNFMjBCRDA3MjM3 RDNFNDgwMDQ2RTUyMCAvKiBQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuaCBpbiBI ZWFkZXJzICovLAogCQkJCTBGN0RGMTM1MUUyOTcwREMwMDk1OTUxQiAvKiBNYXJrZWRTcGFjZUlu bGluZXMuaCBpbiBIZWFkZXJzICovLAogCQkJCTBGNjYwRTM4MUUwNTE3QkIwMDMxNDYyQyAvKiBN YXJraW5nQ29uc3RyYWludC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMEY2NjBFM0ExRTA1MTdDMTAw MzE0NjJDIC8qIE1hcmtpbmdDb25zdHJhaW50U2V0LmggaW4gSGVhZGVycyAqLywKQEAgLTEwMDA2 LDYgKzEwMDI4LDcgQEAKIAkJCQk1MzRFMDM1NjFFNTNCRURFMDAyMTNGNjQgLyogUHJveHlhYmxl QWNjZXNzQ2FzZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNzlCMDBDQkQxQzZBQjA3RTAwODhDNjVE IC8qIFByb3h5Q29uc3RydWN0b3IuaCBpbiBIZWFkZXJzICovLAogCQkJCTc5QjAwQ0JGMUM2QUIw N0UwMDg4QzY1RCAvKiBQcm94eU9iamVjdC5oIGluIEhlYWRlcnMgKi8sCisJCQkJQ0VDRkFEMzcy MzcyREFENDAwMjkxNTk5IC8qIEZpbGVCYXNlZEZ1enplckFnZW50LmggaW4gSGVhZGVycyAqLywK IAkJCQk3OTE2MERCRTFDOEUzRUM4MDA4QzA4NUEgLyogUHJveHlSZXZva2UuaCBpbiBIZWFkZXJz ICovLAogCQkJCTBGNTc4MEEyMThGRTFFOTgwMDFFNzJEOSAvKiBQdXJlTmFOLmggaW4gSGVhZGVy cyAqLywKIAkJCQkwRjE1Q0QyMzFCQTVGOTg2MDAzMUZGRDMgLyogUHV0QnlJZEZsYWdzLmggaW4g SGVhZGVycyAqLywKQEAgLTEwMDg0LDYgKzEwMTA3LDcgQEAKIAkJCQlGRTMwMjJEMzFFM0Q3M0E1 MDBCQUM0OTMgLyogU2lnaWxsQ3Jhc2hBbmFseXplci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMEY0 RDhDNzgxRkNBM0NGQTAwMUQzMkFDIC8qIFNpbXBsZU1hcmtpbmdDb25zdHJhaW50LmggaW4gSGVh ZGVycyAqLywKIAkJCQkwRjJCNjcwNTE3QjZCNUFCMDBBN0FFM0YgLyogU2ltcGxlVHlwZWRBcnJh eUNvbnRyb2xsZXIuaCBpbiBIZWFkZXJzICovLAorCQkJCUNFQ0ZBRDM2MjM3MkRBRDAwMDI5MTU5 OSAvKiBGdXp6ZXJQcmVkaWN0aW9ucy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMTRCQTc4RjExM0FB Qjg4RjAwNUI3QzJDIC8qIFNsb3RWaXNpdG9yLmggaW4gSGVhZGVycyAqLywKIAkJCQlDMjE2MEZF NzE1RjdFOTVFMDA5NDJERkMgLyogU2xvdFZpc2l0b3JJbmxpbmVzLmggaW4gSGVhZGVycyAqLywK IAkJCQlBNzA5RjJGMDE3QTBBQzA0MDA1MTJFOTggLyogU2xvd1BhdGhDYWxsLmggaW4gSGVhZGVy cyAqLywKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9Tb3VyY2VzLnR4dCBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9Tb3VyY2VzLnR4dAppbmRleCAyZDdkYTQyYWVkZC4uNjk1ZTkz OTQ5NTIgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9Tb3VyY2VzLnR4dAorKysg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvU291cmNlcy50eHQKQEAgLTc2Niw2ICs3NjYsOCBAQCBy dW50aW1lL0V4Y2VwdGlvbkZ1enouY3BwCiBydW50aW1lL0V4Y2VwdGlvbkhlbHBlcnMuY3BwCiBy dW50aW1lL0V4Y2VwdGlvblNjb3BlLmNwcAogcnVudGltZS9FeGVjdXRhYmxlQmFzZS5jcHAKK3J1 bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnQuY3BwCitydW50aW1lL0ZpbGVCYXNlZEZ1enplckFn ZW50QmFzZS5jcHAKIHJ1bnRpbWUvRnVuY3Rpb25Db25zdHJ1Y3Rvci5jcHAKIHJ1bnRpbWUvRnVu Y3Rpb25FeGVjdXRhYmxlLmNwcAogcnVudGltZS9GdW5jdGlvbkV4ZWN1dGFibGVEdW1wLmNwcApA QCAtNzczLDYgKzc3NSw3IEBAIHJ1bnRpbWUvRnVuY3Rpb25IYXNFeGVjdXRlZENhY2hlLmNwcAog cnVudGltZS9GdW5jdGlvblByb3RvdHlwZS5jcHAKIHJ1bnRpbWUvRnVuY3Rpb25SYXJlRGF0YS5j cHAKIHJ1bnRpbWUvRnV6emVyQWdlbnQuY3BwCitydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmNw cAogcnVudGltZS9HZW5lcmF0b3JGdW5jdGlvbkNvbnN0cnVjdG9yLmNwcAogcnVudGltZS9HZW5l cmF0b3JGdW5jdGlvblByb3RvdHlwZS5jcHAKIHJ1bnRpbWUvR2VuZXJhdG9yUHJvdG90eXBlLmNw cApAQCAtOTA0LDYgKzkwNyw3IEBAIHJ1bnRpbWUvT2JqZWN0UHJvdG90eXBlLmNwcAogcnVudGlt ZS9PYmplY3RUb1N0cmluZ0FkYXB0aXZlU3RydWN0dXJlV2F0Y2hwb2ludC5jcHAKIHJ1bnRpbWUv T3BlcmF0aW9ucy5jcHAKIHJ1bnRpbWUvT3B0aW9ucy5jcHAKK3J1bnRpbWUvUHJlZGljdGlvbkZp bGVDcmVhdGluZ0Z1enplckFnZW50LmNwcAogcnVudGltZS9Qcm9ncmFtRXhlY3V0YWJsZS5jcHAK IHJ1bnRpbWUvUHJvbWlzZVRpbWVyLmNwcAogcnVudGltZS9Qcm9wZXJ0eURlc2NyaXB0b3IuY3Bw CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6 ZXJBZ2VudC5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6 ZXJBZ2VudC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmMwMTMx ZmQ5MzYxCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUv RmlsZUJhc2VkRnV6emVyQWdlbnQuY3BwCkBAIC0wLDAgKzEsMTYwIEBACisvKgorICogQ29weXJp Z2h0IChDKSAyMDE5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRp c3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdp dGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBm b2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBv ZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3Rp Y2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIu CisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBh bmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAq CisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFO RCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklM SVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlN RUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUg TElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAq IEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklD RVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJS VVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZ LCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5D TFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9G IFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9T U0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2lu Y2x1ZGUgIkZpbGVCYXNlZEZ1enplckFnZW50LmgiCisKKyNpbmNsdWRlICJDb2RlQmxvY2suaCIK KyNpbmNsdWRlICJGdXp6ZXJQcmVkaWN0aW9ucy5oIgorI2luY2x1ZGUgPHd0Zi9BbnNpQ29sb3Jz Lmg+CisjaW5jbHVkZSA8d3RmL0xvY2tlci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0J1 aWxkZXIuaD4KKyNpZiBQTEFURk9STShDT0NPQSkKKyNpbmNsdWRlIDx3dGYvY29jb2EvQ3Jhc2hS ZXBvcnRlci5oPgorI2VuZGlmCisKK25hbWVzcGFjZSBKU0MgeworCitGaWxlQmFzZWRGdXp6ZXJB Z2VudDo6RmlsZUJhc2VkRnV6emVyQWdlbnQoVk0mIHZtKQorICAgIDogRmlsZUJhc2VkRnV6emVy QWdlbnRCYXNlKHZtKQoreworfQorCitTcGVjdWxhdGVkVHlwZSBGaWxlQmFzZWRGdXp6ZXJBZ2Vu dDo6Z2V0UHJlZGljdGlvbihDb2RlQmxvY2sqIGNvZGVCbG9jaywgY29uc3QgQ29kZU9yaWdpbiYg Y29kZU9yaWdpbiwgU3BlY3VsYXRlZFR5cGUgb3JpZ2luYWwpCit7CisgICAgYXV0byBsb2NrZXIg PSBob2xkTG9jayhtX2xvY2spOworCisgICAgU2NyaXB0RXhlY3V0YWJsZSogb3duZXJFeGVjdXRh YmxlID0gY29kZUJsb2NrLT5vd25lckV4ZWN1dGFibGUoKTsKKyAgICBhdXRvIHNvdXJjZVVSTCA9 IG93bmVyRXhlY3V0YWJsZS0+c291cmNlVVJMKCk7CisgICAgaWYgKHNvdXJjZVVSTC5pc0VtcHR5 KCkpCisgICAgICAgIHJldHVybiBvcmlnaW5hbDsKKworICAgIGludCBkaXZvdCA9IDA7CisgICAg aW50IHN0YXJ0T2Zmc2V0ID0gLTE7CisgICAgaW50IGVuZE9mZnNldCA9IC0xOworICAgIHVuc2ln bmVkIGxpbmUgPSAwOworICAgIHVuc2lnbmVkIGNvbHVtbiA9IDA7CisgICAgQnl0ZWNvZGVJbmRl eCBieXRlY29kZUluZGV4ID0gY29kZU9yaWdpbi5ieXRlY29kZUluZGV4KCk7CisgICAgY29kZUJs b2NrLT5leHByZXNzaW9uUmFuZ2VGb3JCeXRlY29kZUluZGV4KGJ5dGVjb2RlSW5kZXgsIGRpdm90 LCBzdGFydE9mZnNldCwgZW5kT2Zmc2V0LCBsaW5lLCBjb2x1bW4pOworCisgICAgU291cmNlUHJv dmlkZXIqIHByb3ZpZGVyID0gY29kZUJsb2NrLT5zb3VyY2UoKS5wcm92aWRlcigpOworICAgIGF1 dG8gc291cmNlVXBUb0Rpdm90ID0gcHJvdmlkZXItPnNvdXJjZSgpLnN1YnN0cmluZyhkaXZvdCAt IHN0YXJ0T2Zmc2V0LCBzdGFydE9mZnNldCk7CisgICAgYXV0byBzb3VyY2VBZnRlckRpdm90ID0g cHJvdmlkZXItPnNvdXJjZSgpLnN1YnN0cmluZyhkaXZvdCwgZW5kT2Zmc2V0KTsKKworICAgIFZl Y3RvcjxTdHJpbmc+IHVybFBhcnRzID0gc291cmNlVVJMLnNwbGl0KCcvJyk7CisgICAgYXV0byBz b3VyY2VGaWxlbmFtZSA9IHVybFBhcnRzLmlzRW1wdHkoKSA/IHNvdXJjZVVSTCA6IHVybFBhcnRz Lmxhc3QoKTsKKworICAgIGNvbnN0IEluc3RydWN0aW9uU3RyZWFtJiBpbnN0cnVjdGlvbnMgPSBj b2RlQmxvY2stPmluc3RydWN0aW9ucygpOworICAgIGNvbnN0IEluc3RydWN0aW9uKiBhbkluc3Ry dWN0aW9uID0gaW5zdHJ1Y3Rpb25zLmF0KGJ5dGVjb2RlSW5kZXgpLnB0cigpOworICAgIE9wY29k ZUlEIG9wY29kZUlkID0gYW5JbnN0cnVjdGlvbi0+b3Bjb2RlSUQoKTsKKyAgICBpbnQgc3RhcnRM b2NhdGlvbiA9IGRpdm90IC0gc3RhcnRPZmZzZXQ7CisgICAgaW50IGVuZExvY2F0aW9uID0gZGl2 b3QgKyBlbmRPZmZzZXQ7CisgICAgU3RyaW5nIGtleSA9IGNyZWF0ZUxvb2t1cEtleShzb3VyY2VG aWxlbmFtZSwgb3Bjb2RlSWQsIHN0YXJ0TG9jYXRpb24sIGVuZExvY2F0aW9uKTsKKyAgICBGdXp6 ZXJQcmVkaWN0aW9ucyYgZnV6emVyUHJlZGljdGlvbnMgPSBlbnN1cmVHbG9iYWxGdXp6ZXJQcmVk aWN0aW9ucygpOworICAgIFNwZWN1bGF0ZWRUeXBlIGdlbmVyYXRlZCA9IGZ1enplclByZWRpY3Rp b25zLnByZWRpY3Rpb25Gb3Ioa2V5KTsKKworICAgIHN3aXRjaCAob3Bjb2RlSWQpIHsKKyAgICAg ICAgLy8gRklYTUU6IHRoZXNlIGNhbiBub3QgYmUgdGFyZ2V0ZWQgYXQgYWxsIGR1ZSB0byB0aGUg YnVncyBiZWxvdworICAgIGNhc2Ugb3BfdG9fdGhpczogLy8gYnJva2VuIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTUKKyAgICBjYXNlIG9wX2dldF9hcmd1bWVu dDogLy8gYnJva2VuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1 NTQKKyAgICAgICAgcmV0dXJuIG9yaWdpbmFsOworCisgICAgICAgIC8vIEZJWE1FOiB0aGUgb3V0 cHV0IG9mIGNvZGVCbG9jay0+ZXhwcmVzc2lvblJhbmdlRm9yQnl0ZWNvZGVJbmRleCgpIGFsbG93 cyBmb3Igc29tZSBvZgorICAgICAgICAvLyB0aGVzZSBvcGNvZGVzIHRvIGhhdmUgcHJlZGljdGlv bnMsIGJ1dCBub3QgYWxsIGluc3RhbmNlcyBjYW4gYmUgcmVsaWFibHkgdGFyZ2V0ZWQuCisgICAg Y2FzZSBvcF9iaXRhbmQ6IC8vIHBhcnRpYWxseSBicm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5v cmcvc2hvd19idWcuY2dpP2lkPTIwMzYwNAorICAgIGNhc2Ugb3BfYml0b3I6IC8vIHBhcnRpYWxs eSBicm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzYwNAor ICAgIGNhc2Ugb3BfYml0eG9yOiAvLyBwYXJ0aWFsbHkgYnJva2VuIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM2MDQKKyAgICBjYXNlIG9wX2JpdG5vdDogLy8gcGFy dGlhbGx5IGJyb2tlbgorICAgIGNhc2Ugb3BfZ2V0X2Zyb21fc2NvcGU6IC8vIHBhcnRpYWxseSBi cm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzYwMworICAg IGNhc2Ugb3BfZ2V0X2Zyb21fYXJndW1lbnRzOiAvLyBwYXJ0aWFsbHkgYnJva2VuIGh0dHBzOi8v YnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM2MDgKKyAgICBjYXNlIG9wX2dldF9i eV92YWw6IC8vIHBhcnRpYWxseSBicm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19i dWcuY2dpP2lkPTIwMzY2NQorICAgIGNhc2Ugb3BfcnNoaWZ0OiAvLyBwYXJ0aWFsbHkgYnJva2Vu IGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM2NjQKKyAgICBjYXNl IG9wX2xzaGlmdDogLy8gcGFydGlhbGx5IGJyb2tlbiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9z aG93X2J1Zy5jZ2k/aWQ9MjAzNjY0CisgICAgY2FzZSBvcF90b19udW1iZXI6IC8vIHBhcnRpYWxs eSBicm9rZW4KKyAgICBjYXNlIG9wX2dldF9ieV9pZDogLy8gc29tZXRpbWVzIG9jY3VycyBpbXBs aWNpdGx5IGZvciB0aGluZ3MgcmVsYXRlZCB0byBTeW1ib2wuaXRlcmF0b3IKKyAgICAgICAgaWYg KGdlbmVyYXRlZCA9PSBOT19QUkVESUNUSU9OX0ZPVU5EKQorICAgICAgICAgICAgcmV0dXJuIG9y aWdpbmFsOworICAgICAgICBicmVhazsKKworICAgIGNhc2Ugb3BfY2FsbDogLy8gb3BfY2FsbCBh cHBlYXJzIGltcGxpY2l0bHkgaW4gZm9yLW9mIGxvb3BzLCBnZW5lcmF0b3JzLCBzcHJlYWQvcmVz dCBlbGVtZW50cywgZGVzdHJ1Y3R1cmluZyBhc3NpZ25tZW50CisgICAgICAgIGlmIChnZW5lcmF0 ZWQgPT0gTk9fUFJFRElDVElPTl9GT1VORCkgeworICAgICAgICAgICAgaWYgKHNvdXJjZUFmdGVy RGl2b3QuY29udGFpbnNJZ25vcmluZ0FTQ0lJQ2FzZSgib2YgIikpCisgICAgICAgICAgICAgICAg cmV0dXJuIG9yaWdpbmFsOworICAgICAgICAgICAgaWYgKHNvdXJjZUFmdGVyRGl2b3QuY29udGFp bnNJZ25vcmluZ0FTQ0lJQ2FzZSgiLi4uIikpCisgICAgICAgICAgICAgICAgcmV0dXJuIG9yaWdp bmFsOworICAgICAgICAgICAgaWYgKHNvdXJjZUFmdGVyRGl2b3QuY29udGFpbnNJZ25vcmluZ0FT Q0lJQ2FzZSgieWllbGQiKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAg ICAgICAgICBpZiAoc291cmNlQWZ0ZXJEaXZvdC5zdGFydHNXaXRoKCdbJykgJiYgc291cmNlQWZ0 ZXJEaXZvdC5lbmRzV2l0aCgiXSIpKQorICAgICAgICAgICAgICAgIHJldHVybiBvcmlnaW5hbDsK KyAgICAgICAgICAgIGlmIChzb3VyY2VVcFRvRGl2b3QuY29udGFpbnNJZ25vcmluZ0FTQ0lJQ2Fz ZSgieWllbGQiKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAgICAgICAg ICBpZiAoc291cmNlVXBUb0Rpdm90ID09ICIuLi4iKQorICAgICAgICAgICAgICAgIHJldHVybiBv cmlnaW5hbDsKKyAgICAgICAgICAgIGlmICghc3RhcnRPZmZzZXQgJiYgIWVuZE9mZnNldCkKKyAg ICAgICAgICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAgICAgIH0KKyAgICAgICAgYnJlYWs7 CisKKyAgICBjYXNlIG9wX2dldF9ieV92YWxfd2l0aF90aGlzOgorICAgIGNhc2Ugb3BfZ2V0X2Rp cmVjdF9wbmFtZToKKyAgICBjYXNlIG9wX2NvbnN0cnVjdDoKKyAgICBjYXNlIG9wX2NvbnN0cnVj dF92YXJhcmdzOgorICAgIGNhc2Ugb3BfY2FsbF92YXJhcmdzOgorICAgIGNhc2Ugb3BfY2FsbF9l dmFsOgorICAgIGNhc2Ugb3BfdGFpbF9jYWxsOgorICAgIGNhc2Ugb3BfdGFpbF9jYWxsX3ZhcmFy Z3M6CisgICAgY2FzZSBvcF9nZXRfYnlfaWRfd2l0aF90aGlzOgorICAgICAgICBicmVhazsKKwor ICAgIGRlZmF1bHQ6CisgICAgICAgIGRhdGFMb2dMbigidW5oYW5kbGVkIG9wY29kZTogIiwgUkVE KEJPTEQob3Bjb2RlSWQpKSk7CisjaWYgUExBVEZPUk0oQ09DT0EpCisgICAgICAgIFN0cmluZ0J1 aWxkZXIgY3Jhc2hMb2dNZXNzYWdlOworICAgICAgICBjcmFzaExvZ01lc3NhZ2UuYXBwZW5kKCJ1 bmhhbmRsZWQgb3Bjb2RlOiAiLCB0b1N0cmluZyhvcGNvZGVJZCkpOworICAgICAgICBXVEY6OnNl dENyYXNoTG9nTWVzc2FnZShjcmFzaExvZ01lc3NhZ2UudG9TdHJpbmcoKS51dGY4KCkuZGF0YSgp KTsKKyNlbmRpZgorICAgICAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAgIH0K KyAgICBpZiAoZ2VuZXJhdGVkID09IE5PX1BSRURJQ1RJT05fRk9VTkQpIHsKKyAgICAgICAgaWYg KE9wdGlvbnM6OmR1bXBGdXp6ZXJBZ2VudFByZWRpY3Rpb25zKCkpCisgICAgICAgICAgICBkYXRh TG9nTG4oTUFHRU5UQShCT0xEKGJ5dGVjb2RlSW5kZXgpKSwgIiAiLCBCT0xEKFlFTExPVyhvcGNv ZGVJZCkpLCAiIG1pc3NpbmcgcHJlZGljdGlvbiBmb3I6ICIsIFJFRChCT0xEKGtleSkpLCAiICIs IEdSRUVOKHNvdXJjZUZpbGVuYW1lKSwgIjoiLCBDWUFOKGxpbmUpLCAiOiIsIENZQU4oY29sdW1u KSwgIiBkaXZvdDogIiwgZGl2b3QsICIgLSIsIHN0YXJ0T2Zmc2V0LCAiICsiLCBlbmRPZmZzZXQs ICIgbmFtZTogJyIsIFlFTExPVyhjb2RlQmxvY2stPmluZmVycmVkTmFtZSgpKSwgIicgc291cmNl OiAnIiwgQkxVRShzb3VyY2VVcFRvRGl2b3QpLCBCTFVFKEJPTEQoc291cmNlQWZ0ZXJEaXZvdCkp LCAiJyIpOworCisgICAgICAgIGlmIChPcHRpb25zOjpyZXF1aXJlUHJlZGljdGlvbkZvckZpbGVC YXNlZEZ1enplckFnZW50KCkpIHsKKyNpZiBQTEFURk9STShDT0NPQSkKKyAgICAgICAgICAgIFN0 cmluZ0J1aWxkZXIgbWlzc2luZ1ByZWRpY3Rpb25DcmFzaExvZ01lc3NhZ2U7CisgICAgICAgICAg ICBtaXNzaW5nUHJlZGljdGlvbkNyYXNoTG9nTWVzc2FnZS5hcHBlbmQoIm1pc3NpbmcgcHJlZGlj dGlvbiBmb3I6ICIsIGtleSk7CisgICAgICAgICAgICBXVEY6OnNldENyYXNoTG9nTWVzc2FnZSht aXNzaW5nUHJlZGljdGlvbkNyYXNoTG9nTWVzc2FnZS50b1N0cmluZygpLnV0ZjgoKS5kYXRhKCkp OworI2VuZGlmCisgICAgICAgICAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRCgpOworICAg ICAgICB9CisKKyAgICAgICAgcmV0dXJuIG9yaWdpbmFsOworICAgIH0KKyAgICBpZiAoT3B0aW9u czo6ZHVtcEZ1enplckFnZW50UHJlZGljdGlvbnMoKSkKKyAgICAgICAgZGF0YUxvZ0xuKFlFTExP VyhvcGNvZGVJZCksICIgIiwgQ1lBTihrZXkpLCAiIG9yaWdpbmFsOiAiLCBDWUFOKEJPTEQoU3Bl Y3VsYXRpb25EdW1wKG9yaWdpbmFsKSkpLCAiIGdlbmVyYXRlZDogIiwgTUFHRU5UQShCT0xEKFNw ZWN1bGF0aW9uRHVtcChnZW5lcmF0ZWQpKSkpOworICAgIHJldHVybiBnZW5lcmF0ZWQ7Cit9CisK K30gLy8gbmFtZXNwYWNlIEpTQwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1 bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnQuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50 aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50LmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAuLjgyZWQ2MzFmNGJmCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3J1bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnQuaApAQCAtMCwwICsxLDQzIEBACisv KgorICogQ29weXJpZ2h0IChDKSAyMDE5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4K KyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1z LCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRl ZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlz dHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCBy ZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9j dW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3Ry aWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4g YGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0Yg TUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0Ug QVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05U UklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwg U1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJ TkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09P RFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVT SU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICog T0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBU T1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFO WSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNF RCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI3ByYWdtYSBvbmNl CisKKyNpbmNsdWRlICJGaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UuaCIKKworbmFtZXNwYWNlIEpT QyB7CisKK2NsYXNzIFZNOworCitjbGFzcyBGaWxlQmFzZWRGdXp6ZXJBZ2VudCBmaW5hbCA6IHB1 YmxpYyBGaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UgeworICAgIFdURl9NQUtFX0ZBU1RfQUxMT0NB VEVEOworCitwdWJsaWM6CisgICAgRmlsZUJhc2VkRnV6emVyQWdlbnQoVk0mKTsKKworICAgIFNw ZWN1bGF0ZWRUeXBlIGdldFByZWRpY3Rpb24oQ29kZUJsb2NrKiwgY29uc3QgQ29kZU9yaWdpbiYs IFNwZWN1bGF0ZWRUeXBlKSBvdmVycmlkZTsKK307CisKK30gLy8gbmFtZXNwYWNlIEpTQwpkaWZm IC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdl bnRCYXNlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1enpl ckFnZW50QmFzZS5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLjAw MTMxMjdjNjFjCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRp bWUvRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmNwcApAQCAtMCwwICsxLDYyIEBACisvKgorICog Q29weXJpZ2h0IChDKSAyMDE5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisg KiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRo IG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0 IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0 aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAg ICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2Ns YWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1 Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRh dGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlv bi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJ UycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcs IEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hB TlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJ U0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRP UlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lB TCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1Ig U0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1Mg SU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElB QklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisg KiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkg T1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBU SEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5o IgorI2luY2x1ZGUgIkZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5oIgorCisjaW5jbHVkZSAiQ29k ZUJsb2NrLmgiCisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRlci5oPgorCituYW1lc3Bh Y2UgSlNDIHsKKworRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlOjpGaWxlQmFzZWRGdXp6ZXJBZ2Vu dEJhc2UoVk0mKQoreworfQorCitTdHJpbmcgRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlOjpjcmVh dGVMb29rdXBLZXkoY29uc3QgU3RyaW5nJiBzb3VyY2VGaWxlbmFtZSwgT3Bjb2RlSUQgb3Bjb2Rl SWQsIGludCBzdGFydExvY2F0aW9uLCBpbnQgZW5kTG9jYXRpb24pCit7CisgICAgU3RyaW5nQnVp bGRlciBsb29rdXBLZXk7CisgICAgbG9va3VwS2V5LmFwcGVuZChzb3VyY2VGaWxlbmFtZSk7Cisg ICAgbG9va3VwS2V5LmFwcGVuZCgifCIpOworICAgIGxvb2t1cEtleS5hcHBlbmQodG9TdHJpbmco b3Bjb2RlQWxpYXNGb3JMb29rdXBLZXkob3Bjb2RlSWQpKSk7CisgICAgbG9va3VwS2V5LmFwcGVu ZCgifCIpOworICAgIGxvb2t1cEtleS5hcHBlbmQoc3RhcnRMb2NhdGlvbik7CisgICAgbG9va3Vw S2V5LmFwcGVuZCgifCIpOworICAgIGxvb2t1cEtleS5hcHBlbmQoZW5kTG9jYXRpb24pOworICAg IHJldHVybiBsb29rdXBLZXkudG9TdHJpbmcoKTsKK30KKworT3Bjb2RlSUQgRmlsZUJhc2VkRnV6 emVyQWdlbnRCYXNlOjpvcGNvZGVBbGlhc0Zvckxvb2t1cEtleShjb25zdCBPcGNvZGVJRCYgb3Bj b2RlSWQpCit7CisgICAgaWYgKG9wY29kZUlkID09IG9wX2NhbGxfdmFyYXJncyB8fCBvcGNvZGVJ ZCA9PSBvcF9jYWxsX2V2YWwgfHwgb3Bjb2RlSWQgPT0gb3BfdGFpbF9jYWxsIHx8IG9wY29kZUlk ID09IG9wX3RhaWxfY2FsbF92YXJhcmdzKQorICAgICAgICByZXR1cm4gb3BfY2FsbDsKKyAgICBp ZiAob3Bjb2RlSWQgPT0gb3BfZ2V0X2RpcmVjdF9wbmFtZSB8fCBvcGNvZGVJZCA9PSBvcF9nZXRf YnlfdmFsX3dpdGhfdGhpcykKKyAgICAgICAgcmV0dXJuIG9wX2dldF9ieV92YWw7CisgICAgaWYg KG9wY29kZUlkID09IG9wX2NvbnN0cnVjdF92YXJhcmdzKQorICAgICAgICByZXR1cm4gb3BfY29u c3RydWN0OworICAgIHJldHVybiBvcGNvZGVJZDsKK30KKworfSAvLyBuYW1lc3BhY2UgSlNDCmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJB Z2VudEJhc2UuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1enpl ckFnZW50QmFzZS5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi5kMzE2 YzI5YzE1NAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L0ZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5oCkBAIC0wLDAgKzEsNDkgQEAKKy8qCisgKiBDb3B5 cmlnaHQgKEMpIDIwMTkgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJl ZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Ig d2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhl IGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25z IG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5v dGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1l ci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9u IGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgor ICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycg QU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVU IE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFC SUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xB SU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBC RSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAor ICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5P VCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJW SUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRF UlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJ VFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJ TkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQg T0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQ T1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2luY2x1 ZGUgIkZ1enplckFnZW50LmgiCisjaW5jbHVkZSAiT3Bjb2RlLmgiCisjaW5jbHVkZSA8d3RmL0xv Y2suaD4KKworbmFtZXNwYWNlIEpTQyB7CisKK2NsYXNzIFZNOworCitjbGFzcyBGaWxlQmFzZWRG dXp6ZXJBZ2VudEJhc2UgOiBwdWJsaWMgRnV6emVyQWdlbnQgeworICAgIFdURl9NQUtFX0ZBU1Rf QUxMT0NBVEVEOworCitwdWJsaWM6CisgICAgRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlKFZNJik7 CisKK3Byb3RlY3RlZDoKKyAgICBMb2NrIG1fbG9jazsKKworICAgIHN0YXRpYyBTdHJpbmcgY3Jl YXRlTG9va3VwS2V5KGNvbnN0IFN0cmluZyYgc291cmNlRmlsZW5hbWUsIE9wY29kZUlELCBpbnQg c3RhcnRMb2NhdGlvbiwgaW50IGVuZExvY2F0aW9uKTsKKyAgICBzdGF0aWMgT3Bjb2RlSUQgb3Bj b2RlQWxpYXNGb3JMb29rdXBLZXkoY29uc3QgT3Bjb2RlSUQmKTsKK307CisKK30gLy8gbmFtZXNw YWNlIEpTQwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRnV6emVy UHJlZGljdGlvbnMuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRnV6emVyUHJl ZGljdGlvbnMuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi42Zjhm NGJhNGY4MAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L0Z1enplclByZWRpY3Rpb25zLmNwcApAQCAtMCwwICsxLDEwNiBAQAorLyoKKyAqIENvcHlyaWdo dCAoQykgMjAxOSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Yg c291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQg QU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJ QUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBF WEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQ VElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBU SEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNs dWRlICJGdXp6ZXJQcmVkaWN0aW9ucy5oIgorCituYW1lc3BhY2UgSlNDIHsKK0Z1enplclByZWRp Y3Rpb25zOjpGdXp6ZXJQcmVkaWN0aW9ucyhjb25zdCBjaGFyKiBmaWxlbmFtZSkKK3sKKyAgICBp ZiAoIWZpbGVuYW1lKQorICAgICAgICByZXR1cm47CisKKyAgICBGSUxFKiBmID0gZm9wZW4oZmls ZW5hbWUsICJyIik7CisgICAgaWYgKCFmKSB7CisgICAgICAgIGRhdGFMb2dGKCJGYWlsZWQgdG8g b3BlbiBmaWxlICVzLlxuIiwgZmlsZW5hbWUpOworICAgICAgICByZXR1cm47CisgICAgfQorCisg ICAgY2hhciogbGluZTsKKyAgICBjaGFyIGJ1ZmZlcltCVUZTSVpdOworICAgIHdoaWxlICgobGlu ZSA9IGZnZXRzKGJ1ZmZlciwgc2l6ZW9mKGJ1ZmZlciksIGYpKSkgeworICAgICAgICAvLyBHZXQg cmlkIG9mIG5ld2xpbmVzIGF0IHRoZSBlbmRzIG9mIHRoZSBzdHJpbmdzLgorICAgICAgICBzaXpl X3QgbGVuZ3RoID0gc3RybGVuKGxpbmUpOworICAgICAgICBpZiAobGluZVtsZW5ndGggLSAxXSA9 PSAnXG4nKSB7CisgICAgICAgICAgICBsaW5lW2xlbmd0aCAtIDFdID0gJ1wwJzsKKyAgICAgICAg ICAgIGxlbmd0aC0tOworICAgICAgICB9CisKKyAgICAgICAgLy8gUHJlZGljdGlvbnMgYXJlIHN0 b3JlZCBpbiBhIHRleHQgZmlsZSwgb25lIHByZWRpY3Rpb24gcGVyIGxpbmUgaW4gdGhlIGNvbG9u IGRlbGltaXRlZCBmb3JtYXQ6CisgICAgICAgIC8vIDxsb29rdXAga2V5Pjo8cHJlZGljdGlvbiBp biBoZXggd2l0aG91dCBsZWFkaW5nIDB4PgorICAgICAgICAvLyBUaGUgbG9va3VwIGtleSBpcyBh IHBpcGUgc2VwYXJhdGVkIHN0cmluZyB3aXRoIHRoZSBmb3JtYXQ6CisgICAgICAgIC8vIDxmaWxl bmFtZT58PG9wY29kZT58PHN0YXJ0IG9mZnNldD58PGVuZCBvZmZzZXQ+CisKKyAgICAgICAgLy8g VGhlIHN0YXJ0IGFuZCBlbmQgb2Zmc2V0cyBhcmUgNy1iaXQgdW5zaWduZWQgaW50ZWdlcnMuCisg ICAgICAgIC8vIElmIHN0YXJ0IG9mZnNldCA+IDEyNywgdGhlbiBib3RoIHN0YXJ0IGFuZCBlbmQg b2Zmc2V0cyBhcmUgMC4KKyAgICAgICAgLy8gSWYgZW5kIG9mZnNldCA+IDEyNywgdGhlbiB0aGUg ZW5kIG9mZnNldCBpcyAwLgorCisgICAgICAgIC8vIEV4YW1wbGUgcHJlZGljdGlvbnM6CisgICAg ICAgIC8vIGZvby5qc3xvcF9jb25zdHJ1Y3R8NzAyfDcyMToxMDAwMDg0CisgICAgICAgIC8vIGZv by5qc3xvcF9jYWxsfDc0OHw3NjA6NDA4ODAwCisgICAgICAgIC8vIGZvby5qc3xvcF9iaXRub3R8 NzcwfDc3MDoyODAwMDAwMDAKKworICAgICAgICAvLyBQcmVkaWN0aW9ucyBjYW4gYmUgZ2VuZXJh dGVkIHVzaW5nIFByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC4KKyAgICAgICAgLy8g U29tZSBvcGNvZGVzIGFyZSBhbGlhc2VkIHRvZ2V0aGVyIHRvIG1ha2UgZ2VuZXJhdGluZyB0aGUg cHJlZGljdGlvbnMgbW9yZSBzdHJhaWdodGZvcndhcmQuCisgICAgICAgIC8vIEZvciB0aGUgYWxp YXNlcyBzZWU6IEZpbGVCYXNlZEZ1enplckFnZW50QmFzZTo6b3Bjb2RlQWxpYXNGb3JMb29rdXBL ZXkoKQorCisgICAgICAgIC8vIEZJWE1FOiBUaGUgY3VycmVudCBpbXBsZW1lbnRhdGlvbiBvbmx5 IHN1cHBvcnRzIG9uZSBwcmVkaWN0aW9uIHBlciBsb29rdXAga2V5LgorCisgICAgICAgIGNvbnN0 IFZlY3RvcjxTdHJpbmc+JiBsaW5lUGFydHMgPSBTdHJpbmcobGluZSwgbGVuZ3RoKS5zcGxpdCgn OicpOworICAgICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0UobGluZVBhcnRzLnNpemUo KSA9PSAyLCAiRXhwZWN0ZWQgbGluZSB3aXRoIHR3byBwYXJ0cyBkZWxpbWl0ZWQgYnkgYSBjb2xv bi4gRm91bmQgbGluZSB3aXRoICVsdSBwYXJ0cy4iLCBsaW5lUGFydHMuc2l6ZSgpKTsKKyAgICAg ICAgY29uc3QgU3RyaW5nJiBsb29rdXBLZXkgPSBsaW5lUGFydHNbMF07CisgICAgICAgIGNvbnN0 IFN0cmluZyYgcHJlZGljdGlvblN0cmluZyA9IGxpbmVQYXJ0c1sxXTsKKyAgICAgICAgYm9vbCBv azsKKyAgICAgICAgU3BlY3VsYXRlZFR5cGUgcHJlZGljdGlvbiA9IHByZWRpY3Rpb25TdHJpbmcu dG9VSW50NjRTdHJpY3QoJm9rLCAweDEwKTsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9N RVNTQUdFKG9rLCAiQ291bGQgbm90IHBhcnNlIHByZWRpY3Rpb24gZnJvbSAnJXMnIiwgcHJlZGlj dGlvblN0cmluZy51dGY4KCkuZGF0YSgpKTsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQoc3BlY3Vs YXRpb25DaGVja2VkKHByZWRpY3Rpb24sIFNwZWNGdWxsVG9wKSk7CisgICAgICAgIG1fcHJlZGlj dGlvbnMuc2V0KGxvb2t1cEtleSwgcHJlZGljdGlvbik7CisgICAgfQorCisgICAgaW50IHJlc3Vs dCA9IGZjbG9zZShmKTsKKyAgICBpZiAocmVzdWx0KQorICAgICAgICBkYXRhTG9nRigiRmFpbGVk IHRvIGNsb3NlIGZpbGUgJXM6ICVzXG4iLCBmaWxlbmFtZSwgc3RyZXJyb3IoZXJybm8pKTsKK30K KworU3BlY3VsYXRlZFR5cGUgRnV6emVyUHJlZGljdGlvbnM6OnByZWRpY3Rpb25Gb3IoY29uc3Qg U3RyaW5nJiBrZXkpCit7CisgICAgaWYgKG1fcHJlZGljdGlvbnMuY29udGFpbnMoa2V5KSkKKyAg ICAgICAgcmV0dXJuIG1fcHJlZGljdGlvbnMuZ2V0KGtleSk7CisKKyAgICByZXR1cm4gTk9fUFJF RElDVElPTl9GT1VORDsKK30KKworRnV6emVyUHJlZGljdGlvbnMmIGVuc3VyZUdsb2JhbEZ1enpl clByZWRpY3Rpb25zKCkKK3sKKyAgICBzdGF0aWMgTGF6eU5ldmVyRGVzdHJveWVkPEZ1enplclBy ZWRpY3Rpb25zPiBmdXp6ZXJQcmVkaWN0aW9uczsKKyAgICBzdGF0aWMgc3RkOjpvbmNlX2ZsYWcg aW5pdGlhbGl6ZUZ1enplclByZWRpY3Rpb25zRmxhZzsKKyAgICBzdGQ6OmNhbGxfb25jZShpbml0 aWFsaXplRnV6emVyUHJlZGljdGlvbnNGbGFnLCBbXSB7CisgICAgICAgIGNvbnN0IGNoYXIqIGZ1 enplclByZWRpY3Rpb25zRmlsZW5hbWUgPSBPcHRpb25zOjpmdXp6ZXJQcmVkaWN0aW9ucygpOwor ICAgICAgICBmdXp6ZXJQcmVkaWN0aW9ucy5jb25zdHJ1Y3QoZnV6emVyUHJlZGljdGlvbnNGaWxl bmFtZSk7CisgICAgfSk7CisgICAgcmV0dXJuIGZ1enplclByZWRpY3Rpb25zOworfQorCit9IC8v IG5hbWVzcGFjZSBKU0MKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L0Z1enplclByZWRpY3Rpb25zLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GdXp6 ZXJQcmVkaWN0aW9ucy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi41 NjE3NWMzZjU4ZQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50 aW1lL0Z1enplclByZWRpY3Rpb25zLmgKQEAgLTAsMCArMSw0OCBAQAorLyoKKyAqIENvcHlyaWdo dCAoQykgMjAxOSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Yg c291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQg QU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJ QUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBF WEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQ VElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBU SEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisjaW5jbHVkZSA8 Ynl0ZWNvZGUvQ29kZUJsb2NrLmg+CisjaW5jbHVkZSA8d3RmL0hhc2hNYXAuaD4KKyNpbmNsdWRl IDx3dGYvdGV4dC9XVEZTdHJpbmcuaD4KKworI2RlZmluZSBOT19QUkVESUNUSU9OX0ZPVU5EIH5T cGVjRnVsbFRvcAorCituYW1lc3BhY2UgSlNDIHsKKworY2xhc3MgRnV6emVyUHJlZGljdGlvbnMg eworcHVibGljOgorICAgIEpTX0VYUE9SVF9QUklWQVRFIEZ1enplclByZWRpY3Rpb25zKGNvbnN0 IGNoYXIqKTsKKworICAgIFNwZWN1bGF0ZWRUeXBlIHByZWRpY3Rpb25Gb3IoY29uc3QgU3RyaW5n Jik7CisKK3ByaXZhdGU6CisgICAgSGFzaE1hcDxTdHJpbmcsIFNwZWN1bGF0ZWRUeXBlPiBtX3By ZWRpY3Rpb25zOworfTsKKworSlNfRVhQT1JUX1BSSVZBVEUgRnV6emVyUHJlZGljdGlvbnMmIGVu c3VyZUdsb2JhbEZ1enplclByZWRpY3Rpb25zKCk7CisKK30gLy8gbmFtZXNwYWNlIEpTQwpkaWZm IC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvT3B0aW9ucy5jcHAgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9PcHRpb25zLmNwcAppbmRleCAzYjdiNmRiNDA1Ni4u NTRmMDBjMTJhNjYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL09w dGlvbnMuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL09wdGlvbnMuY3Bw CkBAIC00NDAsNyArNDQwLDcgQEAgc3RhdGljIHZvaWQgcmVjb21wdXRlRGVwZW5kZW50T3B0aW9u cygpCiAgICAgICAgIHx8IE9wdGlvbnM6OnZlcmJvc2VDRkEoKQogICAgICAgICB8fCBPcHRpb25z Ojp2ZXJib3NlREZHRmFpbHVyZSgpCiAgICAgICAgIHx8IE9wdGlvbnM6OnZlcmJvc2VGVExGYWls dXJlKCkKLSAgICAgICAgfHwgT3B0aW9uczo6ZHVtcFJhbmRvbWl6aW5nRnV6emVyQWdlbnRQcmVk aWN0aW9ucygpKQorICAgICAgICB8fCBPcHRpb25zOjpkdW1wRnV6emVyQWdlbnRQcmVkaWN0aW9u cygpKQogICAgICAgICBPcHRpb25zOjphbHdheXNDb21wdXRlSGFzaCgpID0gdHJ1ZTsKICAgICAK ICAgICBpZiAoIU9wdGlvbnM6OnVzZUNvbmN1cnJlbnRHQygpKQpkaWZmIC0tZ2l0IGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvT3B0aW9uc0xpc3QuaCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL09wdGlvbnNMaXN0LmgKaW5kZXggY2YxNDVmMWViZjUuLjUyYTk2NjhjOWNi IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9PcHRpb25zTGlzdC5o CisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL09wdGlvbnNMaXN0LmgKQEAgLTM3 NCw4ICszNzQsMTIgQEAgbmFtZXNwYWNlIEpTQyB7CiAgICAgdihVbnNpZ25lZCwgc2VlZE9mVk1S YW5kb21Gb3JGdXp6ZXIsIDAsIE5vcm1hbCwgIjAgbWVhbnMgbm90IGZ1enppbmcgdGhpczsgdXNl IGEgY3J5cHRvZ3JhcGhpY2FsbHkgcmFuZG9tIHNlZWQiKSBcCiAgICAgdihCb29sLCB1c2VSYW5k b21pemluZ0Z1enplckFnZW50LCBmYWxzZSwgTm9ybWFsLCBudWxscHRyKSBcCiAgICAgdihVbnNp Z25lZCwgc2VlZE9mUmFuZG9taXppbmdGdXp6ZXJBZ2VudCwgMSwgTm9ybWFsLCBudWxscHRyKSBc Ci0gICAgdihCb29sLCBkdW1wUmFuZG9taXppbmdGdXp6ZXJBZ2VudFByZWRpY3Rpb25zLCBmYWxz ZSwgTm9ybWFsLCBudWxscHRyKSBcCisgICAgdihCb29sLCBkdW1wRnV6emVyQWdlbnRQcmVkaWN0 aW9ucywgZmFsc2UsIE5vcm1hbCwgbnVsbHB0cikgXAogICAgIHYoQm9vbCwgdXNlRG91YmxlUHJl ZGljdGlvbkZ1enplckFnZW50LCBmYWxzZSwgTm9ybWFsLCBudWxscHRyKSBcCisgICAgdihCb29s LCB1c2VGaWxlQmFzZWRGdXp6ZXJBZ2VudCwgZmFsc2UsIE5vcm1hbCwgbnVsbHB0cikgXAorICAg IHYoQm9vbCwgdXNlUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50LCBmYWxzZSwgTm9y bWFsLCBudWxscHRyKSBcCisgICAgdihCb29sLCByZXF1aXJlUHJlZGljdGlvbkZvckZpbGVCYXNl ZEZ1enplckFnZW50LCBmYWxzZSwgTm9ybWFsLCBudWxscHRyKSBcCisgICAgdihPcHRpb25TdHJp bmcsIGZ1enplclByZWRpY3Rpb25zLCBudWxscHRyLCBOb3JtYWwsICJmaWxlIHdpdGggbGlzdCBv ZiBwcmVkaWN0aW9ucyBmb3IgRmlsZUJhc2VkRnV6emVyQWdlbnQiKSBcCiAgICAgXAogICAgIHYo Qm9vbCwgbG9nUGhhc2VUaW1lcywgZmFsc2UsIE5vcm1hbCwgbnVsbHB0cikgXAogICAgIHYoRG91 YmxlLCByYXJlQmxvY2tQZW5hbHR5LCAwLjAwMSwgTm9ybWFsLCBudWxscHRyKSBcCmRpZmYgLS1n aXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9QcmVkaWN0aW9uRmlsZUNyZWF0aW5n RnV6emVyQWdlbnQuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUHJlZGljdGlv bkZpbGVDcmVhdGluZ0Z1enplckFnZW50LmNwcApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAw MDAwMDAwMDAwMC4uZmY0ZTE2OTg2ZTMKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvcnVudGltZS9QcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuY3BwCkBA IC0wLDAgKzEsMTAwIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE5IEFwcGxlIEluYy4gQWxs IHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJj ZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJl IHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJl IG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0 aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25z IGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4g YmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy IGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3Zp ZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJ REVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElF RCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBM SUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJ Q1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBM RSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJ UkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElB TCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5U IE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgor ICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQg T04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJ Q1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJX SVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdB UkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisg Ki8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlByZWRpY3Rpb25GaWxlQ3JlYXRp bmdGdXp6ZXJBZ2VudC5oIgorCisjaW5jbHVkZSAiQ29kZUJsb2NrLmgiCisjaW5jbHVkZSA8d3Rm L0xvY2tlci5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1N0cmluZ0J1aWxkZXIuaD4KKworbmFtZXNw YWNlIEpTQyB7CisKK1ByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudDo6UHJlZGljdGlv bkZpbGVDcmVhdGluZ0Z1enplckFnZW50KFZNJiB2bSkKKyAgICA6IEZpbGVCYXNlZEZ1enplckFn ZW50QmFzZSh2bSkKK3sKK30KKworU3BlY3VsYXRlZFR5cGUgUHJlZGljdGlvbkZpbGVDcmVhdGlu Z0Z1enplckFnZW50OjpnZXRQcmVkaWN0aW9uKENvZGVCbG9jayogY29kZUJsb2NrLCBjb25zdCBD b2RlT3JpZ2luJiBjb2RlT3JpZ2luLCBTcGVjdWxhdGVkVHlwZSBvcmlnaW5hbCkKK3sKKyAgICBh dXRvIGxvY2tlciA9IGhvbGRMb2NrKG1fbG9jayk7CisKKyAgICBTY3JpcHRFeGVjdXRhYmxlKiBv d25lckV4ZWN1dGFibGUgPSBjb2RlQmxvY2stPm93bmVyRXhlY3V0YWJsZSgpOworICAgIGF1dG8g c291cmNlVVJMID0gb3duZXJFeGVjdXRhYmxlLT5zb3VyY2VVUkwoKTsKKyAgICBpZiAoc291cmNl VVJMLmlzRW1wdHkoKSkKKyAgICAgICAgcmV0dXJuIG9yaWdpbmFsOworCisgICAgaW50IGRpdm90 ID0gMDsKKyAgICBpbnQgc3RhcnRPZmZzZXQgPSAtMTsKKyAgICBpbnQgZW5kT2Zmc2V0ID0gLTE7 CisgICAgdW5zaWduZWQgbGluZSA9IDA7CisgICAgdW5zaWduZWQgY29sdW1uID0gMDsKKyAgICBC eXRlY29kZUluZGV4IGJ5dGVjb2RlSW5kZXggPSBjb2RlT3JpZ2luLmJ5dGVjb2RlSW5kZXgoKTsK KyAgICBjb2RlQmxvY2stPmV4cHJlc3Npb25SYW5nZUZvckJ5dGVjb2RlSW5kZXgoYnl0ZWNvZGVJ bmRleCwgZGl2b3QsIHN0YXJ0T2Zmc2V0LCBlbmRPZmZzZXQsIGxpbmUsIGNvbHVtbik7CisKKyAg ICBWZWN0b3I8U3RyaW5nPiB1cmxQYXJ0cyA9IHNvdXJjZVVSTC5zcGxpdCgnLycpOworICAgIGF1 dG8gc291cmNlRmlsZW5hbWUgPSB1cmxQYXJ0cy5pc0VtcHR5KCkgPyBzb3VyY2VVUkwgOiB1cmxQ YXJ0cy5sYXN0KCk7CisKKyAgICBjb25zdCBJbnN0cnVjdGlvblN0cmVhbSYgaW5zdHJ1Y3Rpb25z ID0gY29kZUJsb2NrLT5pbnN0cnVjdGlvbnMoKTsKKyAgICBjb25zdCBJbnN0cnVjdGlvbiogYW5J bnN0cnVjdGlvbiA9IGluc3RydWN0aW9ucy5hdChieXRlY29kZUluZGV4KS5wdHIoKTsKKyAgICBP cGNvZGVJRCBvcGNvZGVJZCA9IGFuSW5zdHJ1Y3Rpb24tPm9wY29kZUlEKCk7CisgICAgaW50IHN0 YXJ0TG9jYXRpb24gPSBkaXZvdCAtIHN0YXJ0T2Zmc2V0OworICAgIGludCBlbmRMb2NhdGlvbiA9 IGRpdm90ICsgZW5kT2Zmc2V0OworICAgIFN0cmluZyBrZXkgPSBjcmVhdGVMb29rdXBLZXkoc291 cmNlRmlsZW5hbWUsIG9wY29kZUlkLCBzdGFydExvY2F0aW9uLCBlbmRMb2NhdGlvbik7CisKKyAg ICBzd2l0Y2ggKG9wY29kZUlkKSB7CisgICAgY2FzZSBvcF90b190aGlzOgorICAgIGNhc2Ugb3Bf Yml0YW5kOgorICAgIGNhc2Ugb3BfYml0b3I6CisgICAgY2FzZSBvcF9iaXR4b3I6CisgICAgY2Fz ZSBvcF9iaXRub3Q6CisgICAgY2FzZSBvcF9sc2hpZnQ6CisgICAgY2FzZSBvcF9yc2hpZnQ6Cisg ICAgY2FzZSBvcF9nZXRfYnlfdmFsOgorICAgIGNhc2Ugb3BfZ2V0X2FyZ3VtZW50OgorICAgIGNh c2Ugb3BfZ2V0X2Zyb21fYXJndW1lbnRzOgorICAgIGNhc2Ugb3BfZ2V0X2Zyb21fc2NvcGU6Cisg ICAgY2FzZSBvcF90b19udW1iZXI6CisgICAgY2FzZSBvcF9nZXRfYnlfaWQ6CisgICAgY2FzZSBv cF9nZXRfYnlfaWRfd2l0aF90aGlzOgorICAgIGNhc2Ugb3BfZ2V0X2J5X3ZhbF93aXRoX3RoaXM6 CisgICAgY2FzZSBvcF9nZXRfZGlyZWN0X3BuYW1lOgorICAgIGNhc2Ugb3BfY29uc3RydWN0Ogor ICAgIGNhc2Ugb3BfY29uc3RydWN0X3ZhcmFyZ3M6CisgICAgY2FzZSBvcF9jYWxsOgorICAgIGNh c2Ugb3BfY2FsbF9ldmFsOgorICAgIGNhc2Ugb3BfY2FsbF92YXJhcmdzOgorICAgIGNhc2Ugb3Bf dGFpbF9jYWxsOgorICAgIGNhc2Ugb3BfdGFpbF9jYWxsX3ZhcmFyZ3M6CisgICAgICAgIGRhdGFM b2dGKCIlczolbGx4XG4iLCBrZXkudXRmOCgpLmRhdGEoKSwgb3JpZ2luYWwpOworICAgICAgICBi cmVhazsKKworICAgIGRlZmF1bHQ6CisgICAgICAgIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FH RShmYWxzZSwgInVuaGFuZGxlZCBvcGNvZGU6ICVzIiwgdG9TdHJpbmcob3Bjb2RlSWQpLnV0Zjgo KS5kYXRhKCkpOworICAgIH0KKyAgICByZXR1cm4gb3JpZ2luYWw7Cit9CisKK30gLy8gbmFtZXNw YWNlIEpTQwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUHJlZGlj dGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVu dGltZS9QcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuaApuZXcgZmlsZSBtb2RlIDEw MDY0NAppbmRleCAwMDAwMDAwMDAwMC4uMDM4NzE4YzQ1M2MKLS0tIC9kZXYvbnVsbAorKysgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9QcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVy QWdlbnQuaApAQCAtMCwwICsxLDQzIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE5IEFwcGxl IEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNl IGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNh dGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9u cworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0 IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1 dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJp YWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJF IElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1Mg T1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhF CisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZP UiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBT SEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElS RUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09O U0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBS T0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBE QVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENB VVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRS QUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0Ug T1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRI SVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBE QU1BR0UuCisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNpbmNsdWRlICJGaWxlQmFzZWRGdXp6ZXJB Z2VudEJhc2UuaCIKKworbmFtZXNwYWNlIEpTQyB7CisKK2NsYXNzIFZNOworCitjbGFzcyBQcmVk aWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQgZmluYWwgOiBwdWJsaWMgRmlsZUJhc2VkRnV6 emVyQWdlbnRCYXNlIHsKKyAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKKworcHVibGljOgor ICAgIFByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudChWTSYpOworCisgICAgU3BlY3Vs YXRlZFR5cGUgZ2V0UHJlZGljdGlvbihDb2RlQmxvY2sqLCBjb25zdCBDb2RlT3JpZ2luJiwgU3Bl Y3VsYXRlZFR5cGUpIG92ZXJyaWRlOworfTsKKworfSAvLyBuYW1lc3BhY2UgSlNDCmRpZmYgLS1n aXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFnZW50 LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1JhbmRvbWl6aW5nRnV6emVyQWdl bnQuY3BwCmluZGV4IDNkMjI1OTUxYjI5Li5jOWM1NGU3ZTNjYyAxMDA2NDQKLS0tIGEvU291cmNl L0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUmFuZG9taXppbmdGdXp6ZXJBZ2VudC5jcHAKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUmFuZG9taXppbmdGdXp6ZXJBZ2VudC5jcHAK QEAgLTQyLDcgKzQyLDcgQEAgU3BlY3VsYXRlZFR5cGUgUmFuZG9taXppbmdGdXp6ZXJBZ2VudDo6 Z2V0UHJlZGljdGlvbihDb2RlQmxvY2sqIGNvZGVCbG9jaywgY29uc3QKICAgICB1aW50MzJfdCBo aWdoID0gbV9yYW5kb20uZ2V0VWludDMyKCk7CiAgICAgdWludDMyX3QgbG93ID0gbV9yYW5kb20u Z2V0VWludDMyKCk7CiAgICAgU3BlY3VsYXRlZFR5cGUgZ2VuZXJhdGVkID0gc3RhdGljX2Nhc3Q8 U3BlY3VsYXRlZFR5cGU+KChzdGF0aWNfY2FzdDx1aW50NjRfdD4oaGlnaCkgPDwgMzIpIHwgbG93 KSAmIFNwZWNGdWxsVG9wOwotICAgIGlmIChPcHRpb25zOjpkdW1wUmFuZG9taXppbmdGdXp6ZXJB Z2VudFByZWRpY3Rpb25zKCkpCisgICAgaWYgKE9wdGlvbnM6OmR1bXBGdXp6ZXJBZ2VudFByZWRp Y3Rpb25zKCkpCiAgICAgICAgIGRhdGFMb2dMbigiZ2V0UHJlZGljdGlvbiBuYW1lOigiLCBjb2Rl QmxvY2stPmluZmVycmVkTmFtZSgpLCAiIyIsIGNvZGVCbG9jay0+aGFzaEFzU3RyaW5nSWZQb3Nz aWJsZSgpLCAiKSxieXRlY29kZUluZGV4OigiLCBjb2RlT3JpZ2luLmJ5dGVjb2RlSW5kZXgoKSwg Iiksb3JpZ2luYWw6KCIsIFNwZWN1bGF0aW9uRHVtcChvcmlnaW5hbCksICIpLGdlbmVyYXRlZDoo IiwgU3BlY3VsYXRpb25EdW1wKGdlbmVyYXRlZCksICIpIik7CiAgICAgcmV0dXJuIGdlbmVyYXRl ZDsKIH0KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNLmNwcCBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNLmNwcAppbmRleCBiZDFlOWZmNjZhNS4u ODBjNzQxYzI5MmEgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZN LmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9WTS5jcHAKQEAgLTUwLDYg KzUwLDcgQEAKICNpbmNsdWRlICJFeGVjdXRhYmxlVG9Db2RlQmxvY2tFZGdlLmgiCiAjaW5jbHVk ZSAiRlRMVGh1bmtzLmgiCiAjaW5jbHVkZSAiRmFzdE1hbGxvY0FsaWduZWRNZW1vcnlBbGxvY2F0 b3IuaCIKKyNpbmNsdWRlICJGaWxlQmFzZWRGdXp6ZXJBZ2VudC5oIgogI2luY2x1ZGUgIkZ1bmN0 aW9uQ29kZUJsb2NrLmgiCiAjaW5jbHVkZSAiRnVuY3Rpb25Db25zdHJ1Y3Rvci5oIgogI2luY2x1 ZGUgIkZ1bmN0aW9uRXhlY3V0YWJsZS5oIgpAQCAtMTE4LDYgKzExOSw3IEBACiAjaW5jbHVkZSAi Tm9kZXMuaCIKICNpbmNsdWRlICJPYmpDQ2FsbGJhY2tGdW5jdGlvbi5oIgogI2luY2x1ZGUgIlBh cnNlci5oIgorI2luY2x1ZGUgIlByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5oIgog I2luY2x1ZGUgIlByb2ZpbGVyRGF0YWJhc2UuaCIKICNpbmNsdWRlICJQcm9ncmFtQ29kZUJsb2Nr LmgiCiAjaW5jbHVkZSAiUHJvZ3JhbUV4ZWN1dGFibGUuaCIKQEAgLTQ0OCw2ICs0NTAsMTAgQEAg Vk06OlZNKFZNVHlwZSB2bVR5cGUsIEhlYXBUeXBlIGhlYXBUeXBlKQogICAgICAgICBzZXRGdXp6 ZXJBZ2VudChtYWtlVW5pcXVlPFJhbmRvbWl6aW5nRnV6emVyQWdlbnQ+KCp0aGlzKSk7CiAgICAg ZWxzZSBpZiAoT3B0aW9uczo6dXNlRG91YmxlUHJlZGljdGlvbkZ1enplckFnZW50KCkpCiAgICAg ICAgIHNldEZ1enplckFnZW50KG1ha2VVbmlxdWU8RG91YmxlUHJlZGljdGlvbkZ1enplckFnZW50 PigqdGhpcykpOworICAgIGVsc2UgaWYgKE9wdGlvbnM6OnVzZUZpbGVCYXNlZEZ1enplckFnZW50 KCkpCisgICAgICAgIHNldEZ1enplckFnZW50KG1ha2VVbmlxdWU8RmlsZUJhc2VkRnV6emVyQWdl bnQ+KCp0aGlzKSk7CisgICAgZWxzZSBpZiAoT3B0aW9uczo6dXNlUHJlZGljdGlvbkZpbGVDcmVh dGluZ0Z1enplckFnZW50KCkpCisgICAgICAgIHNldEZ1enplckFnZW50KG1ha2VVbmlxdWU8UHJl ZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50PigqdGhpcykpOwogCiAgICAgaWYgKE9wdGlv bnM6OmFsd2F5c0dlbmVyYXRlUENUb0NvZGVPcmlnaW5NYXAoKSkKICAgICAgICAgc2V0U2hvdWxk QnVpbGRQQ1RvQ29kZU9yaWdpbk1hcHBpbmcoKTsK 383865 2019-11-19 07:04:09 -0800 2019-11-26 04:57:31 -0800 proposed patch webkit_203898_e.patch text/plain 43918 tuomas.webkit ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQ2hhbmdlTG9nCmluZGV4IGI0YTE2ZWVjMzE0Li4xZTU1NzVmY2RmNCAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTktMTEtMTkgIFR1b21h cyBLYXJra2FpbmVuICA8dHVvbWFzLndlYmtpdEBhcHBsZS5jb20+CisKKyAgICAgICAgQWRkIEZ1 enplckFnZW50IHRoYXQgcmVhZHMgcHJlZGljdGlvbnMgZnJvbSBhIGZpbGUKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzg5OAorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2ggYWRkcyBhIEZ1 enplckFnZW50IHRoYXQgcmVhZHMgcHJlZGljdGlvbnMgZnJvbSBhIGZpbGUuIFRoZSBwcmVkaWN0 aW9ucyBpbiB0aGUgZmlsZSBhcmUKKyAgICAgICAgY29ycmVsYXRlZCB3aXRoIHRoZSBwcmVkaWN0 aW9uIHNpdGVzIHVzaW5nIHRoZSBuYW1lIG9mIHRoZSBKYXZhU2NyaXB0IHNvdXJjZSBmaWxlLCB0 aGUgb3Bjb2RlLCBhbmQKKyAgICAgICAgc3RhcnQgYW5kIGVuZCBvZmZzZXRzIGluIHRoZSBzb3Vy Y2UuIFRoZXJlIGlzIGFsc28gYSBzZXBhcmF0ZSBGdXp6ZXJBZ2VudCB0aGF0IGNhbiBiZSB1c2Vk IHRvIGNyZWF0ZQorICAgICAgICB0aGUgcHJlZGljdGlvbiBmaWxlcy4KKworICAgICAgICAqIEph dmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogU291cmNl cy50eHQ6CisgICAgICAgICogcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudC5jcHA6IEFkZGVk LgorICAgICAgICAqIHJ1bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnQuaDogQ29waWVkIGZyb20g U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUmFuZG9taXppbmdGdXp6ZXJBZ2VudC5jcHAu CisgICAgICAgICogcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UuY3BwOiBDb3BpZWQg ZnJvbSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFnZW50 LmNwcC4KKyAgICAgICAgKiBydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5oOiBDb3Bp ZWQgZnJvbSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFn ZW50LmNwcC4KKyAgICAgICAgKiBydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmNwcDogQWRkZWQu CisgICAgICAgICogcnVudGltZS9GdXp6ZXJQcmVkaWN0aW9ucy5oOiBDb3BpZWQgZnJvbSBTb3Vy Y2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFnZW50LmNwcC4KKyAg ICAgICAgKiBydW50aW1lL09wdGlvbnMuY3BwOgorICAgICAgICAqIHJ1bnRpbWUvT3B0aW9uc0xp c3QuaDoKKyAgICAgICAgKiBydW50aW1lL1ByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2Vu dC5jcHA6IEFkZGVkLgorICAgICAgICAqIHJ1bnRpbWUvUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1 enplckFnZW50Lmg6IENvcGllZCBmcm9tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1Jh bmRvbWl6aW5nRnV6emVyQWdlbnQuY3BwLgorICAgICAgICAqIHJ1bnRpbWUvUmFuZG9taXppbmdG dXp6ZXJBZ2VudC5jcHA6CisgICAgICAgICogcnVudGltZS9WTS5jcHA6CisKIDIwMTktMTEtMTgg IE1hcmsgTGFtICA8bWFyay5sYW1AYXBwbGUuY29tPgogCiAgICAgICAgIEFsd2F5cyBlbmFibGUg T3B0aW9uYWw8T3B0aW9uc1N0b3JhZ2U6OlNpemU+IHBhcnNlKGNvbnN0IGNoYXIqIHN0cmluZykg Zm9yIE9TKERBUldJTikuCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2YVNj cmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9KYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDExMDkxYTY4 Zjc3Li42ODY3NmFjM2E1ZiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0phdmFT Y3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTE3NDEs NyArMTc0MSwxMSBAQAogCQlDNEY0QjZGNDFBMDVDOTQ0MDA1Q0FCNzYgLyogY3BwX2dlbmVyYXRv ci5weSBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEM0RjRC NkQwMUEwNUM3NkYwMDVDQUI3NiAvKiBjcHBfZ2VuZXJhdG9yLnB5ICovOyBzZXR0aW5ncyA9IHtB VFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUM0RjRCNkY1MUEwNUM5ODQwMDVDQUI3 NiAvKiBnZW5lcmF0ZV9vYmpjX3Byb3RvY29sX3R5cGVzX2ltcGxlbWVudGF0aW9uLnB5IGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzRGNEI2RDcxQTA1Qzc2 RjAwNUNBQjc2IC8qIGdlbmVyYXRlX29iamNfcHJvdG9jb2xfdHlwZXNfaW1wbGVtZW50YXRpb24u cHkgKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJQzRG NEI2RjYxQTA1Qzk4NDAwNUNBQjc2IC8qIG9iamNfZ2VuZXJhdG9yX3RlbXBsYXRlcy5weSBpbiBI ZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEM0RjRCNkQ4MUEwNUM3 NkYwMDVDQUI3NiAvKiBvYmpjX2dlbmVyYXRvcl90ZW1wbGF0ZXMucHkgKi87IHNldHRpbmdzID0g e0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKKwkJQ0UyMEJEMDUyMzdEM0UyMzAwNDZF NTIwIC8qIEZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQ0UyMEJEMDMyMzdEM0FENDAwNDZFNTIwIC8qIEZpbGVC YXNlZEZ1enplckFnZW50QmFzZS5oICovOyB9OworCQlDRTIwQkQwNzIzN0QzRTQ4MDA0NkU1MjAg LyogUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50LmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDRTIwQkQwMTIzN0QzQUQ0MDA0NkU1MjAgLyog UHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50LmggKi87IH07CiAJCUNFQUU3RDdCODg5 QjQ3N0JBOTNBQkE2QyAvKiBTY3JpcHRGZXRjaGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4ODUyMTUxQTlDMzg0MjM4OUIzMjE1QjcgLyogU2NyaXB0 RmV0Y2hlci5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07 CisJCUNFQ0ZBRDM2MjM3MkRBRDAwMDI5MTU5OSAvKiBGdXp6ZXJQcmVkaWN0aW9ucy5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQ0VDRkFEMzQyMzcyREFB NzAwMjkxNTk5IC8qIEZ1enplclByZWRpY3Rpb25zLmggKi87IH07CisJCUNFQ0ZBRDM3MjM3MkRB RDQwMDI5MTU5OSAvKiBGaWxlQmFzZWRGdXp6ZXJBZ2VudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQ0VDRkFEMzIyMzcyREFBNzAwMjkxNTk5IC8qIEZp bGVCYXNlZEZ1enplckFnZW50LmggKi87IH07CiAJCUQ5NzIyNzUyREM1NDQ1OUI5MTI1QjUzOSAv KiBKU01vZHVsZUxvYWRlci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gNzdCMjVDQjJDMzA5NEE5MkEzOEUxREIzIC8qIEpTTW9kdWxlTG9hZGVyLmggKi87 IH07CiAJCURDMDAwMzkzMTlEOEJFNkYwMDAyM0VCMCAvKiBERkdQcmVjaXNlTG9jYWxDbG9iYmVy aXplLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBEQzAw MDM5MDE5RDhCRTZGMDAwMjNFQjAgLyogREZHUHJlY2lzZUxvY2FsQ2xvYmJlcml6ZS5oICovOyB9 OwogCQlEQzAxODQxOTFEMTBDMTg5MDA1N0IwNTMgLyogSklUV29ya2xpc3QuaCBpbiBIZWFkZXJz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IERDMDE4NDE4MUQxMEMxODcwMDU3 QjA1MyAvKiBKSVRXb3JrbGlzdC5oICovOyB9OwpAQCAtNDgyNyw2ICs0ODMxLDE0IEBACiAJCUM0 RjRCNkQ2MUEwNUM3NkYwMDVDQUI3NiAvKiBnZW5lcmF0ZV9jcHBfcHJvdG9jb2xfdHlwZXNfaW1w bGVtZW50YXRpb24ucHkgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0LnNjcmlwdC5weXRob247IHBhdGggPSBnZW5l cmF0ZV9jcHBfcHJvdG9jb2xfdHlwZXNfaW1wbGVtZW50YXRpb24ucHk7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCUM0RjRCNkQ3MUEwNUM3NkYwMDVDQUI3NiAvKiBnZW5lcmF0ZV9vYmpj X3Byb3RvY29sX3R5cGVzX2ltcGxlbWVudGF0aW9uLnB5ICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dC5zY3JpcHQu cHl0aG9uOyBwYXRoID0gZ2VuZXJhdGVfb2JqY19wcm90b2NvbF90eXBlc19pbXBsZW1lbnRhdGlv bi5weTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQzRGNEI2RDgxQTA1Qzc2RjAwNUNB Qjc2IC8qIG9iamNfZ2VuZXJhdG9yX3RlbXBsYXRlcy5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuc2NyaXB0 LnB5dGhvbjsgcGF0aCA9IG9iamNfZ2VuZXJhdG9yX3RlbXBsYXRlcy5weTsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKKwkJQ0UyMEJEMDEyMzdEM0FENDAwNDZFNTIwIC8qIFByZWRpY3Rpb25G aWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBQcmVkaWN0aW9uRmlsZUNy ZWF0aW5nRnV6emVyQWdlbnQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJQ0UyMEJE MDIyMzdEM0FENDAwNDZFNTIwIC8qIFByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5j cHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQu Y3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDRTIwQkQwMzIzN0QzQUQ0MDA0NkU1 MjAgLyogRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEZpbGVCYXNl ZEZ1enplckFnZW50QmFzZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDRTIwQkQw NDIzN0QzQUQ0MDA0NkU1MjAgLyogRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmNwcCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgcGF0aCA9IEZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5jcHA7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CisJCUNFQ0ZBRDMyMjM3MkRBQTcwMDI5MTU5OSAvKiBGaWxlQmFzZWRGdXp6 ZXJBZ2VudC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBGaWxlQmFzZWRGdXp6ZXJBZ2VudC5oOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OworCQlDRUNGQUQzMzIzNzJEQUE3MDAyOTE1OTkgLyogRmlsZUJh c2VkRnV6emVyQWdlbnQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRmlsZUJhc2VkRnV6emVyQWdl bnQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDRUNGQUQzNDIzNzJEQUE3MDAy OTE1OTkgLyogRnV6emVyUHJlZGljdGlvbnMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRnV6emVyUHJlZGlj dGlvbnMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJQ0VDRkFEMzUyMzcyREFBNzAw MjkxNTk5IC8qIEZ1enplclByZWRpY3Rpb25zLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEZ1enpl clByZWRpY3Rpb25zLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRDIxMjAyMjgw QUQ0MzEwQzAwRUQ3OUI2IC8qIERhdGVDb252ZXJzaW9uLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmNwcC5jcHA7IHBhdGggPSBEYXRlQ29udmVyc2lvbi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCUQyMTIwMjI5MEFENDMxMEMwMEVENzlCNiAvKiBEYXRlQ29udmVyc2lvbi5o ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRGF0ZUNvbnZlcnNpb24uaDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJREMwMDAzOTAxOUQ4QkU2RjAwMDIzRUIwIC8qIERG R1ByZWNpc2VMb2NhbENsb2JiZXJpemUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1l ID0gREZHUHJlY2lzZUxvY2FsQ2xvYmJlcml6ZS5oOyBwYXRoID0gZGZnL0RGR1ByZWNpc2VMb2Nh bENsb2JiZXJpemUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTcwODcsNiArNzA5 OSwxMCBAQAogCQkJCTE0NzM0MUU5MURDMkNGMjUwMEFBMjlCQSAvKiBFeGVjdXRhYmxlQmFzZS5j cHAgKi8sCiAJCQkJMTQ3MzQxQ0IxREMwMkQ3MjAwQUEyOUJBIC8qIEV4ZWN1dGFibGVCYXNlLmgg Ki8sCiAJCQkJRTM1QTBCOUMyMjBBRDg3QTAwQUM0NDc0IC8qIEV4ZWN1dGFibGVCYXNlSW5saW5l cy5oICovLAorCQkJCUNFQ0ZBRDMzMjM3MkRBQTcwMDI5MTU5OSAvKiBGaWxlQmFzZWRGdXp6ZXJB Z2VudC5jcHAgKi8sCisJCQkJQ0VDRkFEMzIyMzcyREFBNzAwMjkxNTk5IC8qIEZpbGVCYXNlZEZ1 enplckFnZW50LmggKi8sCisJCQkJQ0UyMEJEMDQyMzdEM0FENDAwNDZFNTIwIC8qIEZpbGVCYXNl ZEZ1enplckFnZW50QmFzZS5jcHAgKi8sCisJCQkJQ0UyMEJEMDMyMzdEM0FENDAwNDZFNTIwIC8q IEZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5oICovLAogCQkJCUE3QThBRjI5MTdBREI1RjMwMDVB QjE3NCAvKiBGbG9hdDMyQXJyYXkuaCAqLywKIAkJCQlBN0E4QUYyQTE3QURCNUYzMDA1QUIxNzQg LyogRmxvYXQ2NEFycmF5LmggKi8sCiAJCQkJQkMyNjgwQzAwRTE2RDRFOTAwQTA2RTkyIC8qIEZ1 bmN0aW9uQ29uc3RydWN0b3IuY3BwICovLApAQCAtNzEwNCw2ICs3MTIwLDggQEAKIAkJCQk2MkQy RDM4RTFBREYxMDNGMDAwMjA2QzEgLyogRnVuY3Rpb25SYXJlRGF0YS5oICovLAogCQkJCUUzM0E5 NDk1MjI1NTMyMkEwMEQ0MkIwNiAvKiBGdXp6ZXJBZ2VudC5jcHAgKi8sCiAJCQkJRTMzQTk0OTIy MjU1MzIyOTAwRDQyQjA2IC8qIEZ1enplckFnZW50LmggKi8sCisJCQkJQ0VDRkFEMzUyMzcyREFB NzAwMjkxNTk5IC8qIEZ1enplclByZWRpY3Rpb25zLmNwcCAqLywKKwkJCQlDRUNGQUQzNDIzNzJE QUE3MDAyOTE1OTkgLyogRnV6emVyUHJlZGljdGlvbnMuaCAqLywKIAkJCQk3MEI3OTE4NTFDMDI0 NDMyMDAyNDgxRTIgLyogR2VuZXJhdG9yRnVuY3Rpb25Db25zdHJ1Y3Rvci5jcHAgKi8sCiAJCQkJ NzBCNzkxODYxQzAyNDQzMjAwMjQ4MUUyIC8qIEdlbmVyYXRvckZ1bmN0aW9uQ29uc3RydWN0b3Iu aCAqLywKIAkJCQk3MEI3OTE4NzFDMDI0NDMyMDAyNDgxRTIgLyogR2VuZXJhdG9yRnVuY3Rpb25Q cm90b3R5cGUuY3BwICovLApAQCAtNzQyNiw2ICs3NDQ0LDggQEAKIAkJCQkwRkUyMjhFQjE0MzZB QjIzMDAxOTZDNDggLyogT3B0aW9ucy5oICovLAogCQkJCUZFMzg0MjMxMjMyNEQ1MUIwMDlERDQ0 NSAvKiBPcHRpb25zTGlzdC5oICovLAogCQkJCTM3QzczOEQxMUVEQjU2NzIwMDNGMkIwQiAvKiBQ YXJzZUludC5oICovLAorCQkJCUNFMjBCRDAyMjM3RDNBRDQwMDQ2RTUyMCAvKiBQcmVkaWN0aW9u RmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuY3BwICovLAorCQkJCUNFMjBCRDAxMjM3RDNBRDQwMDQ2 RTUyMCAvKiBQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuaCAqLywKIAkJCQk4Njg5 MTZBOTE1NUYyODU0MDBDQjJCOUEgLyogUHJpdmF0ZU5hbWUuaCAqLywKIAkJCQkxNDczNDFERjFE QzJDRTk2MDBBQTI5QkEgLyogUHJvZ3JhbUV4ZWN1dGFibGUuY3BwICovLAogCQkJCTE0NzM0MUQz MURDMDJFNkQwMEFBMjlCQSAvKiBQcm9ncmFtRXhlY3V0YWJsZS5oICovLApAQCAtOTU5NCw2ICs5 NjE0LDcgQEAKIAkJCQlBMTgxOTNFNDFCNEUwQ0RCMDBGQzEwMjkgLyogSW50bENvbGxhdG9yUHJv dG90eXBlLmx1dC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTE1ODdENkUxQjREQzE0MTAwRDY5ODQ5 IC8qIEludGxEYXRlVGltZUZvcm1hdC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTE1ODdENzAxQjRE QzE0MTAwRDY5ODQ5IC8qIEludGxEYXRlVGltZUZvcm1hdENvbnN0cnVjdG9yLmggaW4gSGVhZGVy cyAqLywKKwkJCQlDRTIwQkQwNTIzN0QzRTIzMDA0NkU1MjAgLyogRmlsZUJhc2VkRnV6emVyQWdl bnRCYXNlLmggaW4gSGVhZGVycyAqLywKIAkJCQlBMTU4N0Q3NTFCNERDMUM2MDBENjk4NDkgLyog SW50bERhdGVUaW1lRm9ybWF0Q29uc3RydWN0b3IubHV0LmggaW4gSGVhZGVycyAqLywKIAkJCQlB MTU4N0Q3MjFCNERDMTQxMDBENjk4NDkgLyogSW50bERhdGVUaW1lRm9ybWF0UHJvdG90eXBlLmgg aW4gSGVhZGVycyAqLywKIAkJCQlBMTU4N0Q3NjFCNERDMUM2MDBENjk4NDkgLyogSW50bERhdGVU aW1lRm9ybWF0UHJvdG90eXBlLmx1dC5oIGluIEhlYWRlcnMgKi8sCkBAIC05ODkxLDYgKzk5MTIs NyBAQAogCQkJCTBGN0M1RkI4MUQ4ODhBMEMwMDQ0RjVFMiAvKiBNYXJrZWRCbG9ja0lubGluZXMu aCBpbiBIZWFkZXJzICovLAogCQkJCTE0MTQ0OENCMTNBMTc2RUMwMEY1QkExQSAvKiBNYXJrZWRC bG9ja1NldC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMTREMkYzREIxMzlGNEJFMjAwNDkxMDMxIC8q IE1hcmtlZFNwYWNlLmggaW4gSGVhZGVycyAqLywKKwkJCQlDRTIwQkQwNzIzN0QzRTQ4MDA0NkU1 MjAgLyogUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50LmggaW4gSGVhZGVycyAqLywK IAkJCQkwRjdERjEzNTFFMjk3MERDMDA5NTk1MUIgLyogTWFya2VkU3BhY2VJbmxpbmVzLmggaW4g SGVhZGVycyAqLywKIAkJCQkwRjY2MEUzODFFMDUxN0JCMDAzMTQ2MkMgLyogTWFya2luZ0NvbnN0 cmFpbnQuaCBpbiBIZWFkZXJzICovLAogCQkJCTBGNjYwRTNBMUUwNTE3QzEwMDMxNDYyQyAvKiBN YXJraW5nQ29uc3RyYWludFNldC5oIGluIEhlYWRlcnMgKi8sCkBAIC0xMDAwNyw2ICsxMDAyOSw3 IEBACiAJCQkJNTM0RTAzNTYxRTUzQkVERTAwMjEzRjY0IC8qIFByb3h5YWJsZUFjY2Vzc0Nhc2Uu aCBpbiBIZWFkZXJzICovLAogCQkJCTc5QjAwQ0JEMUM2QUIwN0UwMDg4QzY1RCAvKiBQcm94eUNv bnN0cnVjdG9yLmggaW4gSGVhZGVycyAqLywKIAkJCQk3OUIwMENCRjFDNkFCMDdFMDA4OEM2NUQg LyogUHJveHlPYmplY3QuaCBpbiBIZWFkZXJzICovLAorCQkJCUNFQ0ZBRDM3MjM3MkRBRDQwMDI5 MTU5OSAvKiBGaWxlQmFzZWRGdXp6ZXJBZ2VudC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNzkxNjBE QkUxQzhFM0VDODAwOEMwODVBIC8qIFByb3h5UmV2b2tlLmggaW4gSGVhZGVycyAqLywKIAkJCQkw RjU3ODBBMjE4RkUxRTk4MDAxRTcyRDkgLyogUHVyZU5hTi5oIGluIEhlYWRlcnMgKi8sCiAJCQkJ MEYxNUNEMjMxQkE1Rjk4NjAwMzFGRkQzIC8qIFB1dEJ5SWRGbGFncy5oIGluIEhlYWRlcnMgKi8s CkBAIC0xMDA4NSw2ICsxMDEwOCw3IEBACiAJCQkJRkUzMDIyRDMxRTNENzNBNTAwQkFDNDkzIC8q IFNpZ2lsbENyYXNoQW5hbHl6ZXIuaCBpbiBIZWFkZXJzICovLAogCQkJCTBGNEQ4Qzc4MUZDQTND RkEwMDFEMzJBQyAvKiBTaW1wbGVNYXJraW5nQ29uc3RyYWludC5oIGluIEhlYWRlcnMgKi8sCiAJ CQkJMEYyQjY3MDUxN0I2QjVBQjAwQTdBRTNGIC8qIFNpbXBsZVR5cGVkQXJyYXlDb250cm9sbGVy LmggaW4gSGVhZGVycyAqLywKKwkJCQlDRUNGQUQzNjIzNzJEQUQwMDAyOTE1OTkgLyogRnV6emVy UHJlZGljdGlvbnMuaCBpbiBIZWFkZXJzICovLAogCQkJCTE0QkE3OEYxMTNBQUI4OEYwMDVCN0My QyAvKiBTbG90VmlzaXRvci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQzIxNjBGRTcxNUY3RTk1RTAw OTQyREZDIC8qIFNsb3RWaXNpdG9ySW5saW5lcy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTcwOUYy RjAxN0EwQUMwNDAwNTEyRTk4IC8qIFNsb3dQYXRoQ2FsbC5oIGluIEhlYWRlcnMgKi8sCmRpZmYg LS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvU291cmNlcy50eHQgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvU291cmNlcy50eHQKaW5kZXggMmQ3ZGE0MmFlZGQuLjY5NWU5Mzk0OTUyIDEwMDY0 NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvU291cmNlcy50eHQKKysrIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL1NvdXJjZXMudHh0CkBAIC03NjYsNiArNzY2LDggQEAgcnVudGltZS9FeGNl cHRpb25GdXp6LmNwcAogcnVudGltZS9FeGNlcHRpb25IZWxwZXJzLmNwcAogcnVudGltZS9FeGNl cHRpb25TY29wZS5jcHAKIHJ1bnRpbWUvRXhlY3V0YWJsZUJhc2UuY3BwCitydW50aW1lL0ZpbGVC YXNlZEZ1enplckFnZW50LmNwcAorcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UuY3Bw CiBydW50aW1lL0Z1bmN0aW9uQ29uc3RydWN0b3IuY3BwCiBydW50aW1lL0Z1bmN0aW9uRXhlY3V0 YWJsZS5jcHAKIHJ1bnRpbWUvRnVuY3Rpb25FeGVjdXRhYmxlRHVtcC5jcHAKQEAgLTc3Myw2ICs3 NzUsNyBAQCBydW50aW1lL0Z1bmN0aW9uSGFzRXhlY3V0ZWRDYWNoZS5jcHAKIHJ1bnRpbWUvRnVu Y3Rpb25Qcm90b3R5cGUuY3BwCiBydW50aW1lL0Z1bmN0aW9uUmFyZURhdGEuY3BwCiBydW50aW1l L0Z1enplckFnZW50LmNwcAorcnVudGltZS9GdXp6ZXJQcmVkaWN0aW9ucy5jcHAKIHJ1bnRpbWUv R2VuZXJhdG9yRnVuY3Rpb25Db25zdHJ1Y3Rvci5jcHAKIHJ1bnRpbWUvR2VuZXJhdG9yRnVuY3Rp b25Qcm90b3R5cGUuY3BwCiBydW50aW1lL0dlbmVyYXRvclByb3RvdHlwZS5jcHAKQEAgLTkwNCw2 ICs5MDcsNyBAQCBydW50aW1lL09iamVjdFByb3RvdHlwZS5jcHAKIHJ1bnRpbWUvT2JqZWN0VG9T dHJpbmdBZGFwdGl2ZVN0cnVjdHVyZVdhdGNocG9pbnQuY3BwCiBydW50aW1lL09wZXJhdGlvbnMu Y3BwCiBydW50aW1lL09wdGlvbnMuY3BwCitydW50aW1lL1ByZWRpY3Rpb25GaWxlQ3JlYXRpbmdG dXp6ZXJBZ2VudC5jcHAKIHJ1bnRpbWUvUHJvZ3JhbUV4ZWN1dGFibGUuY3BwCiBydW50aW1lL1By b21pc2VUaW1lci5jcHAKIHJ1bnRpbWUvUHJvcGVydHlEZXNjcmlwdG9yLmNwcApkaWZmIC0tZ2l0 IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnQuY3Bw IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnQuY3Bw Cm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi5jYTkxNjgzNjRhOAotLS0g L2Rldi9udWxsCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1 enplckFnZW50LmNwcApAQCAtMCwwICsxLDE2MCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAx OSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8g RVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s CisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisg KiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJGaWxl QmFzZWRGdXp6ZXJBZ2VudC5oIgorCisjaW5jbHVkZSAiQ29kZUJsb2NrLmgiCisjaW5jbHVkZSAi RnV6emVyUHJlZGljdGlvbnMuaCIKKyNpbmNsdWRlIDx3dGYvQW5zaUNvbG9ycy5oPgorI2luY2x1 ZGUgPHd0Zi9Mb2NrZXIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+Cisj aWYgUExBVEZPUk0oQ09DT0EpCisjaW5jbHVkZSA8d3RmL2NvY29hL0NyYXNoUmVwb3J0ZXIuaD4K KyNlbmRpZgorCituYW1lc3BhY2UgSlNDIHsKKworRmlsZUJhc2VkRnV6emVyQWdlbnQ6OkZpbGVC YXNlZEZ1enplckFnZW50KFZNJiB2bSkKKyAgICA6IEZpbGVCYXNlZEZ1enplckFnZW50QmFzZSh2 bSkKK3sKK30KKworU3BlY3VsYXRlZFR5cGUgRmlsZUJhc2VkRnV6emVyQWdlbnQ6OmdldFByZWRp Y3Rpb24oQ29kZUJsb2NrKiBjb2RlQmxvY2ssIGNvbnN0IENvZGVPcmlnaW4mIGNvZGVPcmlnaW4s IFNwZWN1bGF0ZWRUeXBlIG9yaWdpbmFsKQoreworICAgIGF1dG8gbG9ja2VyID0gaG9sZExvY2so bV9sb2NrKTsKKworICAgIFNjcmlwdEV4ZWN1dGFibGUqIG93bmVyRXhlY3V0YWJsZSA9IGNvZGVC bG9jay0+b3duZXJFeGVjdXRhYmxlKCk7CisgICAgYXV0byBzb3VyY2VVUkwgPSBvd25lckV4ZWN1 dGFibGUtPnNvdXJjZVVSTCgpOworICAgIGlmIChzb3VyY2VVUkwuaXNFbXB0eSgpKQorICAgICAg ICByZXR1cm4gb3JpZ2luYWw7CisKKyAgICBpbnQgZGl2b3QgPSAwOworICAgIGludCBzdGFydE9m ZnNldCA9IC0xOworICAgIGludCBlbmRPZmZzZXQgPSAtMTsKKyAgICB1bnNpZ25lZCBsaW5lID0g MDsKKyAgICB1bnNpZ25lZCBjb2x1bW4gPSAwOworICAgIEJ5dGVjb2RlSW5kZXggYnl0ZWNvZGVJ bmRleCA9IGNvZGVPcmlnaW4uYnl0ZWNvZGVJbmRleCgpOworICAgIGNvZGVCbG9jay0+ZXhwcmVz c2lvblJhbmdlRm9yQnl0ZWNvZGVJbmRleChieXRlY29kZUluZGV4LCBkaXZvdCwgc3RhcnRPZmZz ZXQsIGVuZE9mZnNldCwgbGluZSwgY29sdW1uKTsKKworICAgIFNvdXJjZVByb3ZpZGVyKiBwcm92 aWRlciA9IGNvZGVCbG9jay0+c291cmNlKCkucHJvdmlkZXIoKTsKKyAgICBhdXRvIHNvdXJjZVVw VG9EaXZvdCA9IHByb3ZpZGVyLT5zb3VyY2UoKS5zdWJzdHJpbmcoZGl2b3QgLSBzdGFydE9mZnNl dCwgc3RhcnRPZmZzZXQpOworICAgIGF1dG8gc291cmNlQWZ0ZXJEaXZvdCA9IHByb3ZpZGVyLT5z b3VyY2UoKS5zdWJzdHJpbmcoZGl2b3QsIGVuZE9mZnNldCk7CisKKyAgICBWZWN0b3I8U3RyaW5n PiB1cmxQYXJ0cyA9IHNvdXJjZVVSTC5zcGxpdCgnLycpOworICAgIGF1dG8gc291cmNlRmlsZW5h bWUgPSB1cmxQYXJ0cy5pc0VtcHR5KCkgPyBzb3VyY2VVUkwgOiB1cmxQYXJ0cy5sYXN0KCk7CisK KyAgICBjb25zdCBJbnN0cnVjdGlvblN0cmVhbSYgaW5zdHJ1Y3Rpb25zID0gY29kZUJsb2NrLT5p bnN0cnVjdGlvbnMoKTsKKyAgICBjb25zdCBJbnN0cnVjdGlvbiogYW5JbnN0cnVjdGlvbiA9IGlu c3RydWN0aW9ucy5hdChieXRlY29kZUluZGV4KS5wdHIoKTsKKyAgICBPcGNvZGVJRCBvcGNvZGVJ ZCA9IGFuSW5zdHJ1Y3Rpb24tPm9wY29kZUlEKCk7CisgICAgaW50IHN0YXJ0TG9jYXRpb24gPSBk aXZvdCAtIHN0YXJ0T2Zmc2V0OworICAgIGludCBlbmRMb2NhdGlvbiA9IGRpdm90ICsgZW5kT2Zm c2V0OworICAgIFN0cmluZyBrZXkgPSBjcmVhdGVMb29rdXBLZXkoc291cmNlRmlsZW5hbWUsIG9w Y29kZUlkLCBzdGFydExvY2F0aW9uLCBlbmRMb2NhdGlvbik7CisgICAgRnV6emVyUHJlZGljdGlv bnMmIGZ1enplclByZWRpY3Rpb25zID0gZW5zdXJlR2xvYmFsRnV6emVyUHJlZGljdGlvbnMoKTsK KyAgICBTcGVjdWxhdGVkVHlwZSBnZW5lcmF0ZWQgPSBmdXp6ZXJQcmVkaWN0aW9ucy5wcmVkaWN0 aW9uRm9yKGtleSk7CisKKyAgICBzd2l0Y2ggKG9wY29kZUlkKSB7CisgICAgLy8gRklYTUU6IHRo ZXNlIGNhbiBub3QgYmUgdGFyZ2V0ZWQgYXQgYWxsIGR1ZSB0byB0aGUgYnVncyBiZWxvdworICAg IGNhc2Ugb3BfdG9fdGhpczogLy8gYnJva2VuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3df YnVnLmNnaT9pZD0yMDM1NTUKKyAgICBjYXNlIG9wX2dldF9hcmd1bWVudDogLy8gYnJva2VuIGh0 dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTQKKyAgICAgICAgcmV0 dXJuIG9yaWdpbmFsOworCisgICAgLy8gRklYTUU6IHRoZSBvdXRwdXQgb2YgY29kZUJsb2NrLT5l eHByZXNzaW9uUmFuZ2VGb3JCeXRlY29kZUluZGV4KCkgYWxsb3dzIGZvciBzb21lIG9mCisgICAg Ly8gdGhlc2Ugb3Bjb2RlcyB0byBoYXZlIHByZWRpY3Rpb25zLCBidXQgbm90IGFsbCBpbnN0YW5j ZXMgY2FuIGJlIHJlbGlhYmx5IHRhcmdldGVkLgorICAgIGNhc2Ugb3BfYml0YW5kOiAvLyBwYXJ0 aWFsbHkgYnJva2VuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM2 MDQKKyAgICBjYXNlIG9wX2JpdG9yOiAvLyBwYXJ0aWFsbHkgYnJva2VuIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM2MDQKKyAgICBjYXNlIG9wX2JpdHhvcjogLy8g cGFydGlhbGx5IGJyb2tlbiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjAzNjA0CisgICAgY2FzZSBvcF9iaXRub3Q6IC8vIHBhcnRpYWxseSBicm9rZW4KKyAgICBjYXNl IG9wX2dldF9mcm9tX3Njb3BlOiAvLyBwYXJ0aWFsbHkgYnJva2VuIGh0dHBzOi8vYnVncy53ZWJr aXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM2MDMKKyAgICBjYXNlIG9wX2dldF9mcm9tX2FyZ3Vt ZW50czogLy8gcGFydGlhbGx5IGJyb2tlbiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1 Zy5jZ2k/aWQ9MjAzNjA4CisgICAgY2FzZSBvcF9nZXRfYnlfdmFsOiAvLyBwYXJ0aWFsbHkgYnJv a2VuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM2NjUKKyAgICBj YXNlIG9wX3JzaGlmdDogLy8gcGFydGlhbGx5IGJyb2tlbiBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjAzNjY0CisgICAgY2FzZSBvcF9sc2hpZnQ6IC8vIHBhcnRpYWxs eSBicm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzY2NAor ICAgIGNhc2Ugb3BfdG9fbnVtYmVyOiAvLyBwYXJ0aWFsbHkgYnJva2VuCisgICAgY2FzZSBvcF9n ZXRfYnlfaWQ6IC8vIHNvbWV0aW1lcyBvY2N1cnMgaW1wbGljaXRseSBmb3IgdGhpbmdzIHJlbGF0 ZWQgdG8gU3ltYm9sLml0ZXJhdG9yCisgICAgICAgIGlmIChnZW5lcmF0ZWQgPT0gTk9fUFJFRElD VElPTl9GT1VORCkKKyAgICAgICAgICAgIHJldHVybiBvcmlnaW5hbDsKKyAgICAgICAgYnJlYWs7 CisKKyAgICBjYXNlIG9wX2NhbGw6IC8vIG9wX2NhbGwgYXBwZWFycyBpbXBsaWNpdGx5IGluIGZv ci1vZiBsb29wcywgZ2VuZXJhdG9ycywgc3ByZWFkL3Jlc3QgZWxlbWVudHMsIGRlc3RydWN0dXJp bmcgYXNzaWdubWVudAorICAgICAgICBpZiAoZ2VuZXJhdGVkID09IE5PX1BSRURJQ1RJT05fRk9V TkQpIHsKKyAgICAgICAgICAgIGlmIChzb3VyY2VBZnRlckRpdm90LmNvbnRhaW5zSWdub3JpbmdB U0NJSUNhc2UoIm9mICIpKQorICAgICAgICAgICAgICAgIHJldHVybiBvcmlnaW5hbDsKKyAgICAg ICAgICAgIGlmIChzb3VyY2VBZnRlckRpdm90LmNvbnRhaW5zSWdub3JpbmdBU0NJSUNhc2UoIi4u LiIpKQorICAgICAgICAgICAgICAgIHJldHVybiBvcmlnaW5hbDsKKyAgICAgICAgICAgIGlmIChz b3VyY2VBZnRlckRpdm90LmNvbnRhaW5zSWdub3JpbmdBU0NJSUNhc2UoInlpZWxkIikpCisgICAg ICAgICAgICAgICAgcmV0dXJuIG9yaWdpbmFsOworICAgICAgICAgICAgaWYgKHNvdXJjZUFmdGVy RGl2b3Quc3RhcnRzV2l0aCgnWycpICYmIHNvdXJjZUFmdGVyRGl2b3QuZW5kc1dpdGgoIl0iKSkK KyAgICAgICAgICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAgICAgICAgICBpZiAoc291cmNl VXBUb0Rpdm90LmNvbnRhaW5zSWdub3JpbmdBU0NJSUNhc2UoInlpZWxkIikpCisgICAgICAgICAg ICAgICAgcmV0dXJuIG9yaWdpbmFsOworICAgICAgICAgICAgaWYgKHNvdXJjZVVwVG9EaXZvdCA9 PSAiLi4uIikKKyAgICAgICAgICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAgICAgICAgICBp ZiAoIXN0YXJ0T2Zmc2V0ICYmICFlbmRPZmZzZXQpCisgICAgICAgICAgICAgICAgcmV0dXJuIG9y aWdpbmFsOworICAgICAgICB9CisgICAgICAgIGJyZWFrOworCisgICAgY2FzZSBvcF9nZXRfYnlf dmFsX3dpdGhfdGhpczoKKyAgICBjYXNlIG9wX2dldF9kaXJlY3RfcG5hbWU6CisgICAgY2FzZSBv cF9jb25zdHJ1Y3Q6CisgICAgY2FzZSBvcF9jb25zdHJ1Y3RfdmFyYXJnczoKKyAgICBjYXNlIG9w X2NhbGxfdmFyYXJnczoKKyAgICBjYXNlIG9wX2NhbGxfZXZhbDoKKyAgICBjYXNlIG9wX3RhaWxf Y2FsbDoKKyAgICBjYXNlIG9wX3RhaWxfY2FsbF92YXJhcmdzOgorICAgIGNhc2Ugb3BfZ2V0X2J5 X2lkX3dpdGhfdGhpczoKKyAgICAgICAgYnJlYWs7CisKKyAgICBkZWZhdWx0OgorICAgICAgICBk YXRhTG9nTG4oInVuaGFuZGxlZCBvcGNvZGU6ICIsIFJFRChCT0xEKG9wY29kZUlkKSkpOworI2lm IFBMQVRGT1JNKENPQ09BKQorICAgICAgICBTdHJpbmdCdWlsZGVyIGNyYXNoTG9nTWVzc2FnZTsK KyAgICAgICAgY3Jhc2hMb2dNZXNzYWdlLmFwcGVuZCgidW5oYW5kbGVkIG9wY29kZTogIiwgdG9T dHJpbmcob3Bjb2RlSWQpKTsKKyAgICAgICAgV1RGOjpzZXRDcmFzaExvZ01lc3NhZ2UoY3Jhc2hM b2dNZXNzYWdlLnRvU3RyaW5nKCkudXRmOCgpLmRhdGEoKSk7CisjZW5kaWYKKyAgICAgICAgUkVM RUFTRV9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICB9CisgICAgaWYgKGdlbmVyYXRlZCA9PSBO T19QUkVESUNUSU9OX0ZPVU5EKSB7CisgICAgICAgIGlmIChPcHRpb25zOjpkdW1wRnV6emVyQWdl bnRQcmVkaWN0aW9ucygpKQorICAgICAgICAgICAgZGF0YUxvZ0xuKE1BR0VOVEEoQk9MRChieXRl Y29kZUluZGV4KSksICIgIiwgQk9MRChZRUxMT1cob3Bjb2RlSWQpKSwgIiBtaXNzaW5nIHByZWRp Y3Rpb24gZm9yOiAiLCBSRUQoQk9MRChrZXkpKSwgIiAiLCBHUkVFTihzb3VyY2VGaWxlbmFtZSks ICI6IiwgQ1lBTihsaW5lKSwgIjoiLCBDWUFOKGNvbHVtbiksICIgZGl2b3Q6ICIsIGRpdm90LCAi IC0iLCBzdGFydE9mZnNldCwgIiArIiwgZW5kT2Zmc2V0LCAiIG5hbWU6ICciLCBZRUxMT1coY29k ZUJsb2NrLT5pbmZlcnJlZE5hbWUoKSksICInIHNvdXJjZTogJyIsIEJMVUUoc291cmNlVXBUb0Rp dm90KSwgQkxVRShCT0xEKHNvdXJjZUFmdGVyRGl2b3QpKSwgIiciKTsKKworICAgICAgICBpZiAo T3B0aW9uczo6cmVxdWlyZVByZWRpY3Rpb25Gb3JGaWxlQmFzZWRGdXp6ZXJBZ2VudCgpKSB7Cisj aWYgUExBVEZPUk0oQ09DT0EpCisgICAgICAgICAgICBTdHJpbmdCdWlsZGVyIG1pc3NpbmdQcmVk aWN0aW9uQ3Jhc2hMb2dNZXNzYWdlOworICAgICAgICAgICAgbWlzc2luZ1ByZWRpY3Rpb25DcmFz aExvZ01lc3NhZ2UuYXBwZW5kKCJtaXNzaW5nIHByZWRpY3Rpb24gZm9yOiAiLCBrZXkpOworICAg ICAgICAgICAgV1RGOjpzZXRDcmFzaExvZ01lc3NhZ2UobWlzc2luZ1ByZWRpY3Rpb25DcmFzaExv Z01lc3NhZ2UudG9TdHJpbmcoKS51dGY4KCkuZGF0YSgpKTsKKyNlbmRpZgorICAgICAgICAgICAg UkVMRUFTRV9BU1NFUlRfTk9UX1JFQUNIRUQoKTsKKyAgICAgICAgfQorCisgICAgICAgIHJldHVy biBvcmlnaW5hbDsKKyAgICB9CisgICAgaWYgKE9wdGlvbnM6OmR1bXBGdXp6ZXJBZ2VudFByZWRp Y3Rpb25zKCkpCisgICAgICAgIGRhdGFMb2dMbihZRUxMT1cob3Bjb2RlSWQpLCAiICIsIENZQU4o a2V5KSwgIiBvcmlnaW5hbDogIiwgQ1lBTihCT0xEKFNwZWN1bGF0aW9uRHVtcChvcmlnaW5hbCkp KSwgIiBnZW5lcmF0ZWQ6ICIsIE1BR0VOVEEoQk9MRChTcGVjdWxhdGlvbkR1bXAoZ2VuZXJhdGVk KSkpKTsKKyAgICByZXR1cm4gZ2VuZXJhdGVkOworfQorCit9IC8vIG5hbWVzcGFjZSBKU0MKZGlm ZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1enplckFn ZW50LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2Vu dC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi44MmVkNjMxZjRiZgot LS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNl ZEZ1enplckFnZW50LmgKQEAgLTAsMCArMSw0MyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAx OSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24g YW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBt b2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNv bmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNv ZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxp c3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVk aXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5 cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xs b3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVy IG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBT T0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBF WFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQg VE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklU TkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8g RVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1Ig QU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlks IE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8s CisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9G IFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9X RVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJ TiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdM SUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisg KiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9G IFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisjaW5jbHVkZSAiRmlsZUJhc2Vk RnV6emVyQWdlbnRCYXNlLmgiCisKK25hbWVzcGFjZSBKU0MgeworCitjbGFzcyBWTTsKKworY2xh c3MgRmlsZUJhc2VkRnV6emVyQWdlbnQgZmluYWwgOiBwdWJsaWMgRmlsZUJhc2VkRnV6emVyQWdl bnRCYXNlIHsKKyAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKKworcHVibGljOgorICAgIEZp bGVCYXNlZEZ1enplckFnZW50KFZNJik7CisKKyAgICBTcGVjdWxhdGVkVHlwZSBnZXRQcmVkaWN0 aW9uKENvZGVCbG9jayosIGNvbnN0IENvZGVPcmlnaW4mLCBTcGVjdWxhdGVkVHlwZSkgb3ZlcnJp ZGU7Cit9OworCit9IC8vIG5hbWVzcGFjZSBKU0MKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5jcHAgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UuY3BwCm5ldyBmaWxl IG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi4wMDEzMTI3YzYxYwotLS0gL2Rldi9udWxs CisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50 QmFzZS5jcHAKQEAgLTAsMCArMSw2MiBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxOSBBcHBs ZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVz ZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmlj YXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlv bnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVz dCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2Yg Y29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmli dXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVy aWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FS RSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNT IE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRI RQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBG T1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQg U0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJ UkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENP TlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQ Uk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwg REFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBD QVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05U UkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNF IE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBU SElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0gg REFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJGaWxlQmFzZWRG dXp6ZXJBZ2VudEJhc2UuaCIKKworI2luY2x1ZGUgIkNvZGVCbG9jay5oIgorI2luY2x1ZGUgPHd0 Zi90ZXh0L1N0cmluZ0J1aWxkZXIuaD4KKworbmFtZXNwYWNlIEpTQyB7CisKK0ZpbGVCYXNlZEZ1 enplckFnZW50QmFzZTo6RmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlKFZNJikKK3sKK30KKworU3Ry aW5nIEZpbGVCYXNlZEZ1enplckFnZW50QmFzZTo6Y3JlYXRlTG9va3VwS2V5KGNvbnN0IFN0cmlu ZyYgc291cmNlRmlsZW5hbWUsIE9wY29kZUlEIG9wY29kZUlkLCBpbnQgc3RhcnRMb2NhdGlvbiwg aW50IGVuZExvY2F0aW9uKQoreworICAgIFN0cmluZ0J1aWxkZXIgbG9va3VwS2V5OworICAgIGxv b2t1cEtleS5hcHBlbmQoc291cmNlRmlsZW5hbWUpOworICAgIGxvb2t1cEtleS5hcHBlbmQoInwi KTsKKyAgICBsb29rdXBLZXkuYXBwZW5kKHRvU3RyaW5nKG9wY29kZUFsaWFzRm9yTG9va3VwS2V5 KG9wY29kZUlkKSkpOworICAgIGxvb2t1cEtleS5hcHBlbmQoInwiKTsKKyAgICBsb29rdXBLZXku YXBwZW5kKHN0YXJ0TG9jYXRpb24pOworICAgIGxvb2t1cEtleS5hcHBlbmQoInwiKTsKKyAgICBs b29rdXBLZXkuYXBwZW5kKGVuZExvY2F0aW9uKTsKKyAgICByZXR1cm4gbG9va3VwS2V5LnRvU3Ry aW5nKCk7Cit9CisKK09wY29kZUlEIEZpbGVCYXNlZEZ1enplckFnZW50QmFzZTo6b3Bjb2RlQWxp YXNGb3JMb29rdXBLZXkoY29uc3QgT3Bjb2RlSUQmIG9wY29kZUlkKQoreworICAgIGlmIChvcGNv ZGVJZCA9PSBvcF9jYWxsX3ZhcmFyZ3MgfHwgb3Bjb2RlSWQgPT0gb3BfY2FsbF9ldmFsIHx8IG9w Y29kZUlkID09IG9wX3RhaWxfY2FsbCB8fCBvcGNvZGVJZCA9PSBvcF90YWlsX2NhbGxfdmFyYXJn cykKKyAgICAgICAgcmV0dXJuIG9wX2NhbGw7CisgICAgaWYgKG9wY29kZUlkID09IG9wX2dldF9k aXJlY3RfcG5hbWUgfHwgb3Bjb2RlSWQgPT0gb3BfZ2V0X2J5X3ZhbF93aXRoX3RoaXMpCisgICAg ICAgIHJldHVybiBvcF9nZXRfYnlfdmFsOworICAgIGlmIChvcGNvZGVJZCA9PSBvcF9jb25zdHJ1 Y3RfdmFyYXJncykKKyAgICAgICAgcmV0dXJuIG9wX2NvbnN0cnVjdDsKKyAgICByZXR1cm4gb3Bj b2RlSWQ7Cit9CisKK30gLy8gbmFtZXNwYWNlIEpTQwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmggYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UuaApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uZDMxNmMyOWMxNTQKLS0tIC9kZXYvbnVsbAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudEJh c2UuaApAQCAtMCwwICsxLDQ5IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE5IEFwcGxlIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwor ICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1Ig SU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisg KiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFM TCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NV UkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRB LCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1Ig T1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNpbmNsdWRlICJGdXp6ZXJBZ2VudC5oIgorI2lu Y2x1ZGUgIk9wY29kZS5oIgorI2luY2x1ZGUgPHd0Zi9Mb2NrLmg+CisKK25hbWVzcGFjZSBKU0Mg eworCitjbGFzcyBWTTsKKworY2xhc3MgRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlIDogcHVibGlj IEZ1enplckFnZW50IHsKKyAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKKworcHVibGljOgor ICAgIEZpbGVCYXNlZEZ1enplckFnZW50QmFzZShWTSYpOworCitwcm90ZWN0ZWQ6CisgICAgTG9j ayBtX2xvY2s7CisKKyAgICBzdGF0aWMgU3RyaW5nIGNyZWF0ZUxvb2t1cEtleShjb25zdCBTdHJp bmcmIHNvdXJjZUZpbGVuYW1lLCBPcGNvZGVJRCwgaW50IHN0YXJ0TG9jYXRpb24sIGludCBlbmRM b2NhdGlvbik7CisgICAgc3RhdGljIE9wY29kZUlEIG9wY29kZUFsaWFzRm9yTG9va3VwS2V5KGNv bnN0IE9wY29kZUlEJik7Cit9OworCit9IC8vIG5hbWVzcGFjZSBKU0MKZGlmZiAtLWdpdCBhL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmNwcCBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmNwcApuZXcgZmlsZSBt b2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uMjFlNDFhMzUzOTAKLS0tIC9kZXYvbnVsbAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GdXp6ZXJQcmVkaWN0aW9ucy5jcHAK QEAgLTAsMCArMSwxMjUgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTkgQXBwbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBh cmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElN UExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQ UExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9S CisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiRnV6emVyUHJlZGljdGlvbnMu aCIKKworbmFtZXNwYWNlIEpTQyB7CisKK3N0YXRpYyBPcHRpb25hbDxTdHJpbmc+IHJlYWRGaWxl SW50b1N0cmluZyhjb25zdCBjaGFyKiBmaWxlTmFtZSkKK3sKKyAgICBGSUxFKiBmID0gZm9wZW4o ZmlsZU5hbWUsICJyIik7CisgICAgaWYgKCFmKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0 OworCisgICAgYXV0byByZWFkQ29udGVudHMgPSBbJl0oKSAtPiBPcHRpb25hbDxTdHJpbmc+IHsK KyAgICAgICAgaWYgKGZzZWVrKGYsIDAsIFNFRUtfRU5EKSA9PSAtMSkKKyAgICAgICAgICAgIHJl dHVybiBXVEY6Om51bGxvcHQ7CisKKyAgICAgICAgbG9uZyBidWZmZXJDYXBhY2l0eSA9IGZ0ZWxs KGYpOworICAgICAgICBpZiAoYnVmZmVyQ2FwYWNpdHkgPT0gLTEpCisgICAgICAgICAgICByZXR1 cm4gV1RGOjpudWxsb3B0OworCisgICAgICAgIGlmIChmc2VlayhmLCAwLCBTRUVLX1NFVCkgPT0g LTEpCisgICAgICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworCisgICAgICAgIFZlY3Rvcjxj aGFyPiBidWZmZXI7CisgICAgICAgIGJ1ZmZlci5yZXNpemUoYnVmZmVyQ2FwYWNpdHkpOworICAg ICAgICBzaXplX3QgcmVhZFNpemUgPSBmcmVhZChidWZmZXIuZGF0YSgpLCAxLCBidWZmZXIuc2l6 ZSgpLCBmKTsKKyAgICAgICAgaWYgKHJlYWRTaXplID09IGJ1ZmZlci5zaXplKCkpCisgICAgICAg ICAgICByZXR1cm4gU3RyaW5nKGJ1ZmZlci5kYXRhKCksIGJ1ZmZlci5zaXplKCkpOworICAgICAg ICByZXR1cm4gV1RGOjpudWxsb3B0OworICAgIH07CisKKyAgICBhdXRvIHJlc3VsdCA9IHJlYWRD b250ZW50cygpOworICAgIGZjbG9zZShmKTsKKworICAgIHJldHVybiByZXN1bHQ7Cit9CisKK0Z1 enplclByZWRpY3Rpb25zOjpGdXp6ZXJQcmVkaWN0aW9ucyhjb25zdCBjaGFyKiBmaWxlbmFtZSkK K3sKKyAgICBpZiAoIWZpbGVuYW1lKQorICAgICAgICByZXR1cm47CisKKyAgICBhdXRvIHByZWRp Y3Rpb25zID0gcmVhZEZpbGVJbnRvU3RyaW5nKGZpbGVuYW1lKTsKKyAgICBpZiAoIXByZWRpY3Rp b25zKSB7CisgICAgICAgIGRhdGFMb2dGKCJGYWlsZWQgdG8gcmVhZCBmaWxlICVzXG4iLCBmaWxl bmFtZSk7CisgICAgICAgIHJldHVybjsKKyAgICB9CisgICAgY29uc3QgVmVjdG9yPFN0cmluZz4m IGxpbmVzID0gcHJlZGljdGlvbnMtPnNwbGl0KCdcbicpOworICAgIGZvciAoY29uc3QgYXV0byYg bGluZSA6IGxpbmVzKSB7CisgICAgICAgIC8vIFByZWRpY3Rpb25zIGFyZSBzdG9yZWQgaW4gYSB0 ZXh0IGZpbGUsIG9uZSBwcmVkaWN0aW9uIHBlciBsaW5lIGluIHRoZSBjb2xvbiBkZWxpbWl0ZWQg Zm9ybWF0OgorICAgICAgICAvLyA8bG9va3VwIGtleT46PHByZWRpY3Rpb24gaW4gaGV4IHdpdGhv dXQgbGVhZGluZyAweD4KKyAgICAgICAgLy8gVGhlIGxvb2t1cCBrZXkgaXMgYSBwaXBlIHNlcGFy YXRlZCBzdHJpbmcgd2l0aCB0aGUgZm9ybWF0OgorICAgICAgICAvLyA8ZmlsZW5hbWU+fDxvcGNv ZGU+fDxzdGFydCBvZmZzZXQ+fDxlbmQgb2Zmc2V0PgorCisgICAgICAgIC8vIFRoZSBzdGFydCBh bmQgZW5kIG9mZnNldHMgYXJlIDctYml0IHVuc2lnbmVkIGludGVnZXJzLgorICAgICAgICAvLyBJ ZiBzdGFydCBvZmZzZXQgPiAxMjcsIHRoZW4gYm90aCBzdGFydCBhbmQgZW5kIG9mZnNldHMgYXJl IDAuCisgICAgICAgIC8vIElmIGVuZCBvZmZzZXQgPiAxMjcsIHRoZW4gdGhlIGVuZCBvZmZzZXQg aXMgMC4KKworICAgICAgICAvLyBFeGFtcGxlIHByZWRpY3Rpb25zOgorICAgICAgICAvLyBmb28u anN8b3BfY29uc3RydWN0fDcwMnw3MjE6MTAwMDA4NAorICAgICAgICAvLyBmb28uanN8b3BfY2Fs bHw3NDh8NzYwOjQwODgwMAorICAgICAgICAvLyBmb28uanN8b3BfYml0bm90fDc3MHw3NzA6Mjgw MDAwMDAwCisKKyAgICAgICAgLy8gUHJlZGljdGlvbnMgY2FuIGJlIGdlbmVyYXRlZCB1c2luZyBQ cmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuCisgICAgICAgIC8vIFNvbWUgb3Bjb2Rl cyBhcmUgYWxpYXNlZCB0b2dldGhlciB0byBtYWtlIGdlbmVyYXRpbmcgdGhlIHByZWRpY3Rpb25z IG1vcmUgc3RyYWlnaHRmb3J3YXJkLgorICAgICAgICAvLyBGb3IgdGhlIGFsaWFzZXMgc2VlOiBG aWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2U6Om9wY29kZUFsaWFzRm9yTG9va3VwS2V5KCkKKworICAg ICAgICAvLyBGSVhNRTogVGhlIGN1cnJlbnQgaW1wbGVtZW50YXRpb24gb25seSBzdXBwb3J0cyBv bmUgcHJlZGljdGlvbiBwZXIgbG9va3VwIGtleS4KKworICAgICAgICBjb25zdCBWZWN0b3I8U3Ry aW5nPiYgbGluZVBhcnRzID0gbGluZS5zcGxpdCgnOicpOworICAgICAgICBSRUxFQVNFX0FTU0VS VF9XSVRIX01FU1NBR0UobGluZVBhcnRzLnNpemUoKSA9PSAyLCAiRXhwZWN0ZWQgbGluZSB3aXRo IHR3byBwYXJ0cyBkZWxpbWl0ZWQgYnkgYSBjb2xvbi4gRm91bmQgbGluZSB3aXRoICVsdSBwYXJ0 cy4iLCBsaW5lUGFydHMuc2l6ZSgpKTsKKyAgICAgICAgY29uc3QgU3RyaW5nJiBsb29rdXBLZXkg PSBsaW5lUGFydHNbMF07CisgICAgICAgIGNvbnN0IFN0cmluZyYgcHJlZGljdGlvblN0cmluZyA9 IGxpbmVQYXJ0c1sxXTsKKyAgICAgICAgYm9vbCBvazsKKyAgICAgICAgU3BlY3VsYXRlZFR5cGUg cHJlZGljdGlvbiA9IHByZWRpY3Rpb25TdHJpbmcudG9VSW50NjRTdHJpY3QoJm9rLCAweDEwKTsK KyAgICAgICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKG9rLCAiQ291bGQgbm90IHBhcnNl IHByZWRpY3Rpb24gZnJvbSAnJXMnIiwgcHJlZGljdGlvblN0cmluZy51dGY4KCkuZGF0YSgpKTsK KyAgICAgICAgUkVMRUFTRV9BU1NFUlQoc3BlY3VsYXRpb25DaGVja2VkKHByZWRpY3Rpb24sIFNw ZWNGdWxsVG9wKSk7CisgICAgICAgIG1fcHJlZGljdGlvbnMuc2V0KGxvb2t1cEtleSwgcHJlZGlj dGlvbik7CisgICAgfQorfQorCitTcGVjdWxhdGVkVHlwZSBGdXp6ZXJQcmVkaWN0aW9uczo6cHJl ZGljdGlvbkZvcihjb25zdCBTdHJpbmcmIGtleSkKK3sKKyAgICBpZiAobV9wcmVkaWN0aW9ucy5j b250YWlucyhrZXkpKQorICAgICAgICByZXR1cm4gbV9wcmVkaWN0aW9ucy5nZXQoa2V5KTsKKwor ICAgIHJldHVybiBOT19QUkVESUNUSU9OX0ZPVU5EOworfQorCitGdXp6ZXJQcmVkaWN0aW9ucyYg ZW5zdXJlR2xvYmFsRnV6emVyUHJlZGljdGlvbnMoKQoreworICAgIHN0YXRpYyBMYXp5TmV2ZXJE ZXN0cm95ZWQ8RnV6emVyUHJlZGljdGlvbnM+IGZ1enplclByZWRpY3Rpb25zOworICAgIHN0YXRp YyBzdGQ6Om9uY2VfZmxhZyBpbml0aWFsaXplRnV6emVyUHJlZGljdGlvbnNGbGFnOworICAgIHN0 ZDo6Y2FsbF9vbmNlKGluaXRpYWxpemVGdXp6ZXJQcmVkaWN0aW9uc0ZsYWcsIFtdIHsKKyAgICAg ICAgY29uc3QgY2hhciogZnV6emVyUHJlZGljdGlvbnNGaWxlbmFtZSA9IE9wdGlvbnM6OmZ1enpl clByZWRpY3Rpb25zKCk7CisgICAgICAgIGZ1enplclByZWRpY3Rpb25zLmNvbnN0cnVjdChmdXp6 ZXJQcmVkaWN0aW9uc0ZpbGVuYW1lKTsKKyAgICB9KTsKKyAgICByZXR1cm4gZnV6emVyUHJlZGlj dGlvbnM7Cit9CisKK30gLy8gbmFtZXNwYWNlIEpTQwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvRnV6emVyUHJlZGljdGlvbnMuaCBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5k ZXggMDAwMDAwMDAwMDAuLjU2MTc1YzNmNThlCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL0ph dmFTY3JpcHRDb3JlL3J1bnRpbWUvRnV6emVyUHJlZGljdGlvbnMuaApAQCAtMCwwICsxLDQ4IEBA CisvKgorICogQ29weXJpZ2h0IChDKSAyMDE5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJl ZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJp Z2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVz dCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAg ZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRp c3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElO Qy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBD T05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUg R09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1Ig QlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQor ICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBP UiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElO IEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI3ByYWdtYSBv bmNlCisKKyNpbmNsdWRlIDxieXRlY29kZS9Db2RlQmxvY2suaD4KKyNpbmNsdWRlIDx3dGYvSGFz aE1hcC5oPgorI2luY2x1ZGUgPHd0Zi90ZXh0L1dURlN0cmluZy5oPgorCisjZGVmaW5lIE5PX1BS RURJQ1RJT05fRk9VTkQgflNwZWNGdWxsVG9wCisKK25hbWVzcGFjZSBKU0MgeworCitjbGFzcyBG dXp6ZXJQcmVkaWN0aW9ucyB7CitwdWJsaWM6CisgICAgSlNfRVhQT1JUX1BSSVZBVEUgRnV6emVy UHJlZGljdGlvbnMoY29uc3QgY2hhciopOworCisgICAgU3BlY3VsYXRlZFR5cGUgcHJlZGljdGlv bkZvcihjb25zdCBTdHJpbmcmKTsKKworcHJpdmF0ZToKKyAgICBIYXNoTWFwPFN0cmluZywgU3Bl Y3VsYXRlZFR5cGU+IG1fcHJlZGljdGlvbnM7Cit9OworCitKU19FWFBPUlRfUFJJVkFURSBGdXp6 ZXJQcmVkaWN0aW9ucyYgZW5zdXJlR2xvYmFsRnV6emVyUHJlZGljdGlvbnMoKTsKKworfSAvLyBu YW1lc3BhY2UgSlNDCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9P cHRpb25zLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL09wdGlvbnMuY3BwCmlu ZGV4IGMxOTZiMzA3ZmI4Li5iZDMxNmI1YmE5NiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3Jp cHRDb3JlL3J1bnRpbWUvT3B0aW9ucy5jcHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1 bnRpbWUvT3B0aW9ucy5jcHAKQEAgLTQ0OCw3ICs0NDgsNyBAQCBzdGF0aWMgdm9pZCByZWNvbXB1 dGVEZXBlbmRlbnRPcHRpb25zKCkKICAgICAgICAgfHwgT3B0aW9uczo6dmVyYm9zZUNGQSgpCiAg ICAgICAgIHx8IE9wdGlvbnM6OnZlcmJvc2VERkdGYWlsdXJlKCkKICAgICAgICAgfHwgT3B0aW9u czo6dmVyYm9zZUZUTEZhaWx1cmUoKQotICAgICAgICB8fCBPcHRpb25zOjpkdW1wUmFuZG9taXpp bmdGdXp6ZXJBZ2VudFByZWRpY3Rpb25zKCkpCisgICAgICAgIHx8IE9wdGlvbnM6OmR1bXBGdXp6 ZXJBZ2VudFByZWRpY3Rpb25zKCkpCiAgICAgICAgIE9wdGlvbnM6OmFsd2F5c0NvbXB1dGVIYXNo KCkgPSB0cnVlOwogICAgIAogICAgIGlmICghT3B0aW9uczo6dXNlQ29uY3VycmVudEdDKCkpCmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9PcHRpb25zTGlzdC5oIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvT3B0aW9uc0xpc3QuaAppbmRleCA5ZDZiNTYx MjRjNC4uZWYxMmEzZGZiY2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50 aW1lL09wdGlvbnNMaXN0LmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvT3B0 aW9uc0xpc3QuaApAQCAtMzk0LDggKzM5NCwxMiBAQCBjb25zdGV4cHIgYm9vbCBlbmFibGVXZWJB c3NlbWJseVN0cmVhbWluZ0FwaSA9IGZhbHNlOwogICAgIHYoVW5zaWduZWQsIHNlZWRPZlZNUmFu ZG9tRm9yRnV6emVyLCAwLCBOb3JtYWwsICIwIG1lYW5zIG5vdCBmdXp6aW5nIHRoaXM7IHVzZSBh IGNyeXB0b2dyYXBoaWNhbGx5IHJhbmRvbSBzZWVkIikgXAogICAgIHYoQm9vbCwgdXNlUmFuZG9t aXppbmdGdXp6ZXJBZ2VudCwgZmFsc2UsIE5vcm1hbCwgbnVsbHB0cikgXAogICAgIHYoVW5zaWdu ZWQsIHNlZWRPZlJhbmRvbWl6aW5nRnV6emVyQWdlbnQsIDEsIE5vcm1hbCwgbnVsbHB0cikgXAot ICAgIHYoQm9vbCwgZHVtcFJhbmRvbWl6aW5nRnV6emVyQWdlbnRQcmVkaWN0aW9ucywgZmFsc2Us IE5vcm1hbCwgbnVsbHB0cikgXAorICAgIHYoQm9vbCwgZHVtcEZ1enplckFnZW50UHJlZGljdGlv bnMsIGZhbHNlLCBOb3JtYWwsIG51bGxwdHIpIFwKICAgICB2KEJvb2wsIHVzZURvdWJsZVByZWRp Y3Rpb25GdXp6ZXJBZ2VudCwgZmFsc2UsIE5vcm1hbCwgbnVsbHB0cikgXAorICAgIHYoQm9vbCwg dXNlRmlsZUJhc2VkRnV6emVyQWdlbnQsIGZhbHNlLCBOb3JtYWwsIG51bGxwdHIpIFwKKyAgICB2 KEJvb2wsIHVzZVByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudCwgZmFsc2UsIE5vcm1h bCwgbnVsbHB0cikgXAorICAgIHYoQm9vbCwgcmVxdWlyZVByZWRpY3Rpb25Gb3JGaWxlQmFzZWRG dXp6ZXJBZ2VudCwgZmFsc2UsIE5vcm1hbCwgbnVsbHB0cikgXAorICAgIHYoT3B0aW9uU3RyaW5n LCBmdXp6ZXJQcmVkaWN0aW9ucywgbnVsbHB0ciwgTm9ybWFsLCAiZmlsZSB3aXRoIGxpc3Qgb2Yg cHJlZGljdGlvbnMgZm9yIEZpbGVCYXNlZEZ1enplckFnZW50IikgXAogICAgIFwKICAgICB2KEJv b2wsIGxvZ1BoYXNlVGltZXMsIGZhbHNlLCBOb3JtYWwsIG51bGxwdHIpIFwKICAgICB2KERvdWJs ZSwgcmFyZUJsb2NrUGVuYWx0eSwgMC4wMDEsIE5vcm1hbCwgbnVsbHB0cikgXApkaWZmIC0tZ2l0 IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1 enplckFnZW50LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ByZWRpY3Rpb25G aWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAw MDAwMDAwMDAuLmZmNGUxNjk4NmUzCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3J1bnRpbWUvUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50LmNwcApAQCAt MCwwICsxLDEwMCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxOSBBcHBsZSBJbmMuIEFsbCBy aWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2Ug YW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBw ZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBt ZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhl IGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBh bmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJp bmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGlj ZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBp biB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRl ZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURF RCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQg V0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElF RCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNV TEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUg SU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJF Q1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwg REFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBP RiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAq IFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9O IEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNU IExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lT RSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJF LCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICov CisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJQcmVkaWN0aW9uRmlsZUNyZWF0aW5n RnV6emVyQWdlbnQuaCIKKworI2luY2x1ZGUgIkNvZGVCbG9jay5oIgorI2luY2x1ZGUgPHd0Zi9M b2NrZXIuaD4KKyNpbmNsdWRlIDx3dGYvdGV4dC9TdHJpbmdCdWlsZGVyLmg+CisKK25hbWVzcGFj ZSBKU0MgeworCitQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQ6OlByZWRpY3Rpb25G aWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudChWTSYgdm0pCisgICAgOiBGaWxlQmFzZWRGdXp6ZXJBZ2Vu dEJhc2Uodm0pCit7Cit9CisKK1NwZWN1bGF0ZWRUeXBlIFByZWRpY3Rpb25GaWxlQ3JlYXRpbmdG dXp6ZXJBZ2VudDo6Z2V0UHJlZGljdGlvbihDb2RlQmxvY2sqIGNvZGVCbG9jaywgY29uc3QgQ29k ZU9yaWdpbiYgY29kZU9yaWdpbiwgU3BlY3VsYXRlZFR5cGUgb3JpZ2luYWwpCit7CisgICAgYXV0 byBsb2NrZXIgPSBob2xkTG9jayhtX2xvY2spOworCisgICAgU2NyaXB0RXhlY3V0YWJsZSogb3du ZXJFeGVjdXRhYmxlID0gY29kZUJsb2NrLT5vd25lckV4ZWN1dGFibGUoKTsKKyAgICBhdXRvIHNv dXJjZVVSTCA9IG93bmVyRXhlY3V0YWJsZS0+c291cmNlVVJMKCk7CisgICAgaWYgKHNvdXJjZVVS TC5pc0VtcHR5KCkpCisgICAgICAgIHJldHVybiBvcmlnaW5hbDsKKworICAgIGludCBkaXZvdCA9 IDA7CisgICAgaW50IHN0YXJ0T2Zmc2V0ID0gLTE7CisgICAgaW50IGVuZE9mZnNldCA9IC0xOwor ICAgIHVuc2lnbmVkIGxpbmUgPSAwOworICAgIHVuc2lnbmVkIGNvbHVtbiA9IDA7CisgICAgQnl0 ZWNvZGVJbmRleCBieXRlY29kZUluZGV4ID0gY29kZU9yaWdpbi5ieXRlY29kZUluZGV4KCk7Cisg ICAgY29kZUJsb2NrLT5leHByZXNzaW9uUmFuZ2VGb3JCeXRlY29kZUluZGV4KGJ5dGVjb2RlSW5k ZXgsIGRpdm90LCBzdGFydE9mZnNldCwgZW5kT2Zmc2V0LCBsaW5lLCBjb2x1bW4pOworCisgICAg VmVjdG9yPFN0cmluZz4gdXJsUGFydHMgPSBzb3VyY2VVUkwuc3BsaXQoJy8nKTsKKyAgICBhdXRv IHNvdXJjZUZpbGVuYW1lID0gdXJsUGFydHMuaXNFbXB0eSgpID8gc291cmNlVVJMIDogdXJsUGFy dHMubGFzdCgpOworCisgICAgY29uc3QgSW5zdHJ1Y3Rpb25TdHJlYW0mIGluc3RydWN0aW9ucyA9 IGNvZGVCbG9jay0+aW5zdHJ1Y3Rpb25zKCk7CisgICAgY29uc3QgSW5zdHJ1Y3Rpb24qIGFuSW5z dHJ1Y3Rpb24gPSBpbnN0cnVjdGlvbnMuYXQoYnl0ZWNvZGVJbmRleCkucHRyKCk7CisgICAgT3Bj b2RlSUQgb3Bjb2RlSWQgPSBhbkluc3RydWN0aW9uLT5vcGNvZGVJRCgpOworICAgIGludCBzdGFy dExvY2F0aW9uID0gZGl2b3QgLSBzdGFydE9mZnNldDsKKyAgICBpbnQgZW5kTG9jYXRpb24gPSBk aXZvdCArIGVuZE9mZnNldDsKKyAgICBTdHJpbmcga2V5ID0gY3JlYXRlTG9va3VwS2V5KHNvdXJj ZUZpbGVuYW1lLCBvcGNvZGVJZCwgc3RhcnRMb2NhdGlvbiwgZW5kTG9jYXRpb24pOworCisgICAg c3dpdGNoIChvcGNvZGVJZCkgeworICAgIGNhc2Ugb3BfdG9fdGhpczoKKyAgICBjYXNlIG9wX2Jp dGFuZDoKKyAgICBjYXNlIG9wX2JpdG9yOgorICAgIGNhc2Ugb3BfYml0eG9yOgorICAgIGNhc2Ug b3BfYml0bm90OgorICAgIGNhc2Ugb3BfbHNoaWZ0OgorICAgIGNhc2Ugb3BfcnNoaWZ0OgorICAg IGNhc2Ugb3BfZ2V0X2J5X3ZhbDoKKyAgICBjYXNlIG9wX2dldF9hcmd1bWVudDoKKyAgICBjYXNl IG9wX2dldF9mcm9tX2FyZ3VtZW50czoKKyAgICBjYXNlIG9wX2dldF9mcm9tX3Njb3BlOgorICAg IGNhc2Ugb3BfdG9fbnVtYmVyOgorICAgIGNhc2Ugb3BfZ2V0X2J5X2lkOgorICAgIGNhc2Ugb3Bf Z2V0X2J5X2lkX3dpdGhfdGhpczoKKyAgICBjYXNlIG9wX2dldF9ieV92YWxfd2l0aF90aGlzOgor ICAgIGNhc2Ugb3BfZ2V0X2RpcmVjdF9wbmFtZToKKyAgICBjYXNlIG9wX2NvbnN0cnVjdDoKKyAg ICBjYXNlIG9wX2NvbnN0cnVjdF92YXJhcmdzOgorICAgIGNhc2Ugb3BfY2FsbDoKKyAgICBjYXNl IG9wX2NhbGxfZXZhbDoKKyAgICBjYXNlIG9wX2NhbGxfdmFyYXJnczoKKyAgICBjYXNlIG9wX3Rh aWxfY2FsbDoKKyAgICBjYXNlIG9wX3RhaWxfY2FsbF92YXJhcmdzOgorICAgICAgICBkYXRhTG9n RigiJXM6JWxseFxuIiwga2V5LnV0ZjgoKS5kYXRhKCksIG9yaWdpbmFsKTsKKyAgICAgICAgYnJl YWs7CisKKyAgICBkZWZhdWx0OgorICAgICAgICBSRUxFQVNFX0FTU0VSVF9XSVRIX01FU1NBR0Uo ZmFsc2UsICJ1bmhhbmRsZWQgb3Bjb2RlOiAlcyIsIHRvU3RyaW5nKG9wY29kZUlkKS51dGY4KCku ZGF0YSgpKTsKKyAgICB9CisgICAgcmV0dXJuIG9yaWdpbmFsOworfQorCit9IC8vIG5hbWVzcGFj ZSBKU0MKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ByZWRpY3Rp b25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRp bWUvUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50LmgKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMDAwMDAuLjAzODcxOGM0NTNjCi0tLSAvZGV2L251bGwKKysrIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFn ZW50LmgKQEAgLTAsMCArMSw0MyBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxOSBBcHBsZSBJ bmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBp biBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRp b24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMK KyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCBy ZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29u ZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRp b25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAq ICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlz Y2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFs cyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJ UyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9S IElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQor ICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1Ig QSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hB TEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVD VCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNF UVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9D VVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFU QSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVT RUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFD VCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9S IE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElT IFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFN QUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisjaW5jbHVkZSAiRmlsZUJhc2VkRnV6emVyQWdl bnRCYXNlLmgiCisKK25hbWVzcGFjZSBKU0MgeworCitjbGFzcyBWTTsKKworY2xhc3MgUHJlZGlj dGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50IGZpbmFsIDogcHVibGljIEZpbGVCYXNlZEZ1enpl ckFnZW50QmFzZSB7CisgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7CisKK3B1YmxpYzoKKyAg ICBQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQoVk0mKTsKKworICAgIFNwZWN1bGF0 ZWRUeXBlIGdldFByZWRpY3Rpb24oQ29kZUJsb2NrKiwgY29uc3QgQ29kZU9yaWdpbiYsIFNwZWN1 bGF0ZWRUeXBlKSBvdmVycmlkZTsKK307CisKK30gLy8gbmFtZXNwYWNlIEpTQwpkaWZmIC0tZ2l0 IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUmFuZG9taXppbmdGdXp6ZXJBZ2VudC5j cHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFnZW50 LmNwcAppbmRleCAzZDIyNTk1MWIyOS4uYzljNTRlN2UzY2MgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS9ydW50aW1lL1JhbmRvbWl6aW5nRnV6emVyQWdlbnQuY3BwCisrKyBiL1Nv dXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1JhbmRvbWl6aW5nRnV6emVyQWdlbnQuY3BwCkBA IC00Miw3ICs0Miw3IEBAIFNwZWN1bGF0ZWRUeXBlIFJhbmRvbWl6aW5nRnV6emVyQWdlbnQ6Omdl dFByZWRpY3Rpb24oQ29kZUJsb2NrKiBjb2RlQmxvY2ssIGNvbnN0CiAgICAgdWludDMyX3QgaGln aCA9IG1fcmFuZG9tLmdldFVpbnQzMigpOwogICAgIHVpbnQzMl90IGxvdyA9IG1fcmFuZG9tLmdl dFVpbnQzMigpOwogICAgIFNwZWN1bGF0ZWRUeXBlIGdlbmVyYXRlZCA9IHN0YXRpY19jYXN0PFNw ZWN1bGF0ZWRUeXBlPigoc3RhdGljX2Nhc3Q8dWludDY0X3Q+KGhpZ2gpIDw8IDMyKSB8IGxvdykg JiBTcGVjRnVsbFRvcDsKLSAgICBpZiAoT3B0aW9uczo6ZHVtcFJhbmRvbWl6aW5nRnV6emVyQWdl bnRQcmVkaWN0aW9ucygpKQorICAgIGlmIChPcHRpb25zOjpkdW1wRnV6emVyQWdlbnRQcmVkaWN0 aW9ucygpKQogICAgICAgICBkYXRhTG9nTG4oImdldFByZWRpY3Rpb24gbmFtZTooIiwgY29kZUJs b2NrLT5pbmZlcnJlZE5hbWUoKSwgIiMiLCBjb2RlQmxvY2stPmhhc2hBc1N0cmluZ0lmUG9zc2li bGUoKSwgIiksYnl0ZWNvZGVJbmRleDooIiwgY29kZU9yaWdpbi5ieXRlY29kZUluZGV4KCksICIp LG9yaWdpbmFsOigiLCBTcGVjdWxhdGlvbkR1bXAob3JpZ2luYWwpLCAiKSxnZW5lcmF0ZWQ6KCIs IFNwZWN1bGF0aW9uRHVtcChnZW5lcmF0ZWQpLCAiKSIpOwogICAgIHJldHVybiBnZW5lcmF0ZWQ7 CiB9CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9WTS5jcHAgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9WTS5jcHAKaW5kZXggZjViZTIzOTNhYjguLjQw ODU1OTMyZDI0IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9WTS5j cHAKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVk0uY3BwCkBAIC01MCw2ICs1 MCw3IEBACiAjaW5jbHVkZSAiRXhlY3V0YWJsZVRvQ29kZUJsb2NrRWRnZS5oIgogI2luY2x1ZGUg IkZUTFRodW5rcy5oIgogI2luY2x1ZGUgIkZhc3RNYWxsb2NBbGlnbmVkTWVtb3J5QWxsb2NhdG9y LmgiCisjaW5jbHVkZSAiRmlsZUJhc2VkRnV6emVyQWdlbnQuaCIKICNpbmNsdWRlICJGdW5jdGlv bkNvZGVCbG9jay5oIgogI2luY2x1ZGUgIkZ1bmN0aW9uQ29uc3RydWN0b3IuaCIKICNpbmNsdWRl ICJGdW5jdGlvbkV4ZWN1dGFibGUuaCIKQEAgLTExOCw2ICsxMTksNyBAQAogI2luY2x1ZGUgIk5v ZGVzLmgiCiAjaW5jbHVkZSAiT2JqQ0NhbGxiYWNrRnVuY3Rpb24uaCIKICNpbmNsdWRlICJQYXJz ZXIuaCIKKyNpbmNsdWRlICJQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuaCIKICNp bmNsdWRlICJQcm9maWxlckRhdGFiYXNlLmgiCiAjaW5jbHVkZSAiUHJvZ3JhbUNvZGVCbG9jay5o IgogI2luY2x1ZGUgIlByb2dyYW1FeGVjdXRhYmxlLmgiCkBAIC00NTIsNiArNDU0LDEwIEBAIFZN OjpWTShWTVR5cGUgdm1UeXBlLCBIZWFwVHlwZSBoZWFwVHlwZSkKICAgICAgICAgc2V0RnV6emVy QWdlbnQobWFrZVVuaXF1ZTxSYW5kb21pemluZ0Z1enplckFnZW50PigqdGhpcykpOwogICAgIGVs c2UgaWYgKE9wdGlvbnM6OnVzZURvdWJsZVByZWRpY3Rpb25GdXp6ZXJBZ2VudCgpKQogICAgICAg ICBzZXRGdXp6ZXJBZ2VudChtYWtlVW5pcXVlPERvdWJsZVByZWRpY3Rpb25GdXp6ZXJBZ2VudD4o KnRoaXMpKTsKKyAgICBlbHNlIGlmIChPcHRpb25zOjp1c2VGaWxlQmFzZWRGdXp6ZXJBZ2VudCgp KQorICAgICAgICBzZXRGdXp6ZXJBZ2VudChtYWtlVW5pcXVlPEZpbGVCYXNlZEZ1enplckFnZW50 PigqdGhpcykpOworICAgIGVsc2UgaWYgKE9wdGlvbnM6OnVzZVByZWRpY3Rpb25GaWxlQ3JlYXRp bmdGdXp6ZXJBZ2VudCgpKQorICAgICAgICBzZXRGdXp6ZXJBZ2VudChtYWtlVW5pcXVlPFByZWRp Y3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudD4oKnRoaXMpKTsKIAogICAgIGlmIChPcHRpb25z OjphbHdheXNHZW5lcmF0ZVBDVG9Db2RlT3JpZ2luTWFwKCkpCiAgICAgICAgIHNldFNob3VsZEJ1 aWxkUENUb0NvZGVPcmlnaW5NYXBwaW5nKCk7Cg== 384346 2019-11-26 04:57:31 -0800 2019-12-01 21:22:39 -0800 proposed patch webkit_203898_f.patch text/plain 43629 tuomas.webkit ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQ2hhbmdlTG9nCmluZGV4IDRjYWQwMTViYzNhLi5hOTdjNTQxM2NhMyAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTktMTEtMjYgIFR1b21h cyBLYXJra2FpbmVuICA8dHVvbWFzLndlYmtpdEBhcHBsZS5jb20+CisKKyAgICAgICAgQWRkIEZ1 enplckFnZW50IHRoYXQgcmVhZHMgcHJlZGljdGlvbnMgZnJvbSBhIGZpbGUKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzg5OAorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2ggYWRkcyBhIEZ1 enplckFnZW50IHRoYXQgcmVhZHMgcHJlZGljdGlvbnMgZnJvbSBhIGZpbGUuIFRoZSBwcmVkaWN0 aW9ucyBpbiB0aGUgZmlsZSBhcmUKKyAgICAgICAgY29ycmVsYXRlZCB3aXRoIHRoZSBwcmVkaWN0 aW9uIHNpdGVzIHVzaW5nIHRoZSBuYW1lIG9mIHRoZSBKYXZhU2NyaXB0IHNvdXJjZSBmaWxlLCB0 aGUgb3Bjb2RlLCBhbmQKKyAgICAgICAgc3RhcnQgYW5kIGVuZCBvZmZzZXRzIGluIHRoZSBzb3Vy Y2UuIFRoZXJlIGlzIGFsc28gYSBzZXBhcmF0ZSBGdXp6ZXJBZ2VudCB0aGF0IGNhbiBiZSB1c2Vk IHRvIGNyZWF0ZQorICAgICAgICB0aGUgcHJlZGljdGlvbiBmaWxlcy4KKworICAgICAgICAqIEph dmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogU291cmNl cy50eHQ6CisgICAgICAgICogcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudC5jcHA6IEFkZGVk LgorICAgICAgICAqIHJ1bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnQuaDogQ29waWVkIGZyb20g U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUmFuZG9taXppbmdGdXp6ZXJBZ2VudC5jcHAu CisgICAgICAgICogcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UuY3BwOiBBZGRlZC4K KyAgICAgICAgKiBydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5oOiBDb3BpZWQgZnJv bSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFnZW50LmNw cC4KKyAgICAgICAgKiBydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmNwcDogQWRkZWQuCisgICAg ICAgICogcnVudGltZS9GdXp6ZXJQcmVkaWN0aW9ucy5oOiBDb3BpZWQgZnJvbSBTb3VyY2UvSmF2 YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFnZW50LmNwcC4KKyAgICAgICAg KiBydW50aW1lL09wdGlvbnMuY3BwOgorICAgICAgICAqIHJ1bnRpbWUvT3B0aW9uc0xpc3QuaDoK KyAgICAgICAgKiBydW50aW1lL1ByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5jcHA6 IENvcGllZCBmcm9tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1JhbmRvbWl6aW5nRnV6 emVyQWdlbnQuY3BwLgorICAgICAgICAqIHJ1bnRpbWUvUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1 enplckFnZW50Lmg6IENvcGllZCBmcm9tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1Jh bmRvbWl6aW5nRnV6emVyQWdlbnQuY3BwLgorICAgICAgICAqIHJ1bnRpbWUvUmFuZG9taXppbmdG dXp6ZXJBZ2VudC5jcHA6CisgICAgICAgICogcnVudGltZS9WTS5jcHA6CisKIDIwMTktMTEtMjYg IFR1b21hcyBLYXJra2FpbmVuICA8dHVvbWFzLndlYmtpdEBhcHBsZS5jb20+CiAKICAgICAgICAg QXR0ZW1wdGluZyB0byBlbmFibGUgbW9yZSB0aGFuIG9uZSBGdXp6ZXJBZ2VudCBzaG91bGQgcmVz dWx0IGluIGFuIGVycm9yCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2YVNj cmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9KYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDVlODc3M2Iw NmFkLi5kOWU3OWE4ZWQyOCAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0phdmFT Y3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTE3Mzks NyArMTczOSwxMSBAQAogCQlDNEY0QjZGNDFBMDVDOTQ0MDA1Q0FCNzYgLyogY3BwX2dlbmVyYXRv ci5weSBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEM0RjRC NkQwMUEwNUM3NkYwMDVDQUI3NiAvKiBjcHBfZ2VuZXJhdG9yLnB5ICovOyBzZXR0aW5ncyA9IHtB VFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07CiAJCUM0RjRCNkY1MUEwNUM5ODQwMDVDQUI3 NiAvKiBnZW5lcmF0ZV9vYmpjX3Byb3RvY29sX3R5cGVzX2ltcGxlbWVudGF0aW9uLnB5IGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzRGNEI2RDcxQTA1Qzc2 RjAwNUNBQjc2IC8qIGdlbmVyYXRlX29iamNfcHJvdG9jb2xfdHlwZXNfaW1wbGVtZW50YXRpb24u cHkgKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJQzRG NEI2RjYxQTA1Qzk4NDAwNUNBQjc2IC8qIG9iamNfZ2VuZXJhdG9yX3RlbXBsYXRlcy5weSBpbiBI ZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEM0RjRCNkQ4MUEwNUM3 NkYwMDVDQUI3NiAvKiBvYmpjX2dlbmVyYXRvcl90ZW1wbGF0ZXMucHkgKi87IHNldHRpbmdzID0g e0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKKwkJQ0UyMEJEMDUyMzdEM0UyMzAwNDZF NTIwIC8qIEZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQ0UyMEJEMDMyMzdEM0FENDAwNDZFNTIwIC8qIEZpbGVC YXNlZEZ1enplckFnZW50QmFzZS5oICovOyB9OworCQlDRTIwQkQwNzIzN0QzRTQ4MDA0NkU1MjAg LyogUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50LmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDRTIwQkQwMTIzN0QzQUQ0MDA0NkU1MjAgLyog UHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50LmggKi87IH07CiAJCUNFQUU3RDdCODg5 QjQ3N0JBOTNBQkE2QyAvKiBTY3JpcHRGZXRjaGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA4ODUyMTUxQTlDMzg0MjM4OUIzMjE1QjcgLyogU2NyaXB0 RmV0Y2hlci5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0gKFByaXZhdGUsICk7IH07IH07 CisJCUNFQ0ZBRDM2MjM3MkRBRDAwMDI5MTU5OSAvKiBGdXp6ZXJQcmVkaWN0aW9ucy5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQ0VDRkFEMzQyMzcyREFB NzAwMjkxNTk5IC8qIEZ1enplclByZWRpY3Rpb25zLmggKi87IH07CisJCUNFQ0ZBRDM3MjM3MkRB RDQwMDI5MTU5OSAvKiBGaWxlQmFzZWRGdXp6ZXJBZ2VudC5oIGluIEhlYWRlcnMgKi8gPSB7aXNh ID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQ0VDRkFEMzIyMzcyREFBNzAwMjkxNTk5IC8qIEZp bGVCYXNlZEZ1enplckFnZW50LmggKi87IH07CiAJCUQ5NzIyNzUyREM1NDQ1OUI5MTI1QjUzOSAv KiBKU01vZHVsZUxvYWRlci5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gNzdCMjVDQjJDMzA5NEE5MkEzOEUxREIzIC8qIEpTTW9kdWxlTG9hZGVyLmggKi87 IH07CiAJCURDMDAwMzkzMTlEOEJFNkYwMDAyM0VCMCAvKiBERkdQcmVjaXNlTG9jYWxDbG9iYmVy aXplLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBEQzAw MDM5MDE5RDhCRTZGMDAwMjNFQjAgLyogREZHUHJlY2lzZUxvY2FsQ2xvYmJlcml6ZS5oICovOyB9 OwogCQlEQzAxODQxOTFEMTBDMTg5MDA1N0IwNTMgLyogSklUV29ya2xpc3QuaCBpbiBIZWFkZXJz ICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IERDMDE4NDE4MUQxMEMxODcwMDU3 QjA1MyAvKiBKSVRXb3JrbGlzdC5oICovOyB9OwpAQCAtNDgyMSw2ICs0ODI1LDE0IEBACiAJCUM0 RjRCNkQ2MUEwNUM3NkYwMDVDQUI3NiAvKiBnZW5lcmF0ZV9jcHBfcHJvdG9jb2xfdHlwZXNfaW1w bGVtZW50YXRpb24ucHkgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5n ID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0LnNjcmlwdC5weXRob247IHBhdGggPSBnZW5l cmF0ZV9jcHBfcHJvdG9jb2xfdHlwZXNfaW1wbGVtZW50YXRpb24ucHk7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCUM0RjRCNkQ3MUEwNUM3NkYwMDVDQUI3NiAvKiBnZW5lcmF0ZV9vYmpj X3Byb3RvY29sX3R5cGVzX2ltcGxlbWVudGF0aW9uLnB5ICovID0ge2lzYSA9IFBCWEZpbGVSZWZl cmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dC5zY3JpcHQu cHl0aG9uOyBwYXRoID0gZ2VuZXJhdGVfb2JqY19wcm90b2NvbF90eXBlc19pbXBsZW1lbnRhdGlv bi5weTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJQzRGNEI2RDgxQTA1Qzc2RjAwNUNB Qjc2IC8qIG9iamNfZ2VuZXJhdG9yX3RlbXBsYXRlcy5weSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVm ZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHRleHQuc2NyaXB0 LnB5dGhvbjsgcGF0aCA9IG9iamNfZ2VuZXJhdG9yX3RlbXBsYXRlcy5weTsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKKwkJQ0UyMEJEMDEyMzdEM0FENDAwNDZFNTIwIC8qIFByZWRpY3Rpb25G aWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBQcmVkaWN0aW9uRmlsZUNy ZWF0aW5nRnV6emVyQWdlbnQuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJQ0UyMEJE MDIyMzdEM0FENDAwNDZFNTIwIC8qIFByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5j cHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3Vy Y2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQu Y3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDRTIwQkQwMzIzN0QzQUQ0MDA0NkU1 MjAgLyogRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVy ZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEZpbGVCYXNl ZEZ1enplckFnZW50QmFzZS5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDRTIwQkQw NDIzN0QzQUQ0MDA0NkU1MjAgLyogRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmNwcCAqLyA9IHtp c2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgcGF0aCA9IEZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5jcHA7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CisJCUNFQ0ZBRDMyMjM3MkRBQTcwMDI5MTU5OSAvKiBGaWxlQmFzZWRGdXp6 ZXJBZ2VudC5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBl ID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBGaWxlQmFzZWRGdXp6ZXJBZ2VudC5oOyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OworCQlDRUNGQUQzMzIzNzJEQUE3MDAyOTE1OTkgLyogRmlsZUJh c2VkRnV6emVyQWdlbnQuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRmlsZUJhc2VkRnV6emVyQWdl bnQuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDRUNGQUQzNDIzNzJEQUE3MDAy OTE1OTkgLyogRnV6emVyUHJlZGljdGlvbnMuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNl OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRnV6emVyUHJlZGlj dGlvbnMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKKwkJQ0VDRkFEMzUyMzcyREFBNzAw MjkxNTk5IC8qIEZ1enplclByZWRpY3Rpb25zLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IEZ1enpl clByZWRpY3Rpb25zLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJRDIxMjAyMjgw QUQ0MzEwQzAwRUQ3OUI2IC8qIERhdGVDb252ZXJzaW9uLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxl UmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSAzMDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmNwcC5jcHA7IHBhdGggPSBEYXRlQ29udmVyc2lvbi5jcHA7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CiAJCUQyMTIwMjI5MEFENDMxMEMwMEVENzlCNiAvKiBEYXRlQ29udmVyc2lvbi5o ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDMwOyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRGF0ZUNvbnZlcnNpb24uaDsgc291 cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJREMwMDAzOTAxOUQ4QkU2RjAwMDIzRUIwIC8qIERG R1ByZWNpc2VMb2NhbENsb2JiZXJpemUuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBm aWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBuYW1l ID0gREZHUHJlY2lzZUxvY2FsQ2xvYmJlcml6ZS5oOyBwYXRoID0gZGZnL0RGR1ByZWNpc2VMb2Nh bENsb2JiZXJpemUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTcwODMsNiArNzA5 NSwxMCBAQAogCQkJCTE0NzM0MUU5MURDMkNGMjUwMEFBMjlCQSAvKiBFeGVjdXRhYmxlQmFzZS5j cHAgKi8sCiAJCQkJMTQ3MzQxQ0IxREMwMkQ3MjAwQUEyOUJBIC8qIEV4ZWN1dGFibGVCYXNlLmgg Ki8sCiAJCQkJRTM1QTBCOUMyMjBBRDg3QTAwQUM0NDc0IC8qIEV4ZWN1dGFibGVCYXNlSW5saW5l cy5oICovLAorCQkJCUNFQ0ZBRDMzMjM3MkRBQTcwMDI5MTU5OSAvKiBGaWxlQmFzZWRGdXp6ZXJB Z2VudC5jcHAgKi8sCisJCQkJQ0VDRkFEMzIyMzcyREFBNzAwMjkxNTk5IC8qIEZpbGVCYXNlZEZ1 enplckFnZW50LmggKi8sCisJCQkJQ0UyMEJEMDQyMzdEM0FENDAwNDZFNTIwIC8qIEZpbGVCYXNl ZEZ1enplckFnZW50QmFzZS5jcHAgKi8sCisJCQkJQ0UyMEJEMDMyMzdEM0FENDAwNDZFNTIwIC8q IEZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5oICovLAogCQkJCUE3QThBRjI5MTdBREI1RjMwMDVB QjE3NCAvKiBGbG9hdDMyQXJyYXkuaCAqLywKIAkJCQlBN0E4QUYyQTE3QURCNUYzMDA1QUIxNzQg LyogRmxvYXQ2NEFycmF5LmggKi8sCiAJCQkJQkMyNjgwQzAwRTE2RDRFOTAwQTA2RTkyIC8qIEZ1 bmN0aW9uQ29uc3RydWN0b3IuY3BwICovLApAQCAtNzEwMCw2ICs3MTE2LDggQEAKIAkJCQk2MkQy RDM4RTFBREYxMDNGMDAwMjA2QzEgLyogRnVuY3Rpb25SYXJlRGF0YS5oICovLAogCQkJCUUzM0E5 NDk1MjI1NTMyMkEwMEQ0MkIwNiAvKiBGdXp6ZXJBZ2VudC5jcHAgKi8sCiAJCQkJRTMzQTk0OTIy MjU1MzIyOTAwRDQyQjA2IC8qIEZ1enplckFnZW50LmggKi8sCisJCQkJQ0VDRkFEMzUyMzcyREFB NzAwMjkxNTk5IC8qIEZ1enplclByZWRpY3Rpb25zLmNwcCAqLywKKwkJCQlDRUNGQUQzNDIzNzJE QUE3MDAyOTE1OTkgLyogRnV6emVyUHJlZGljdGlvbnMuaCAqLywKIAkJCQk3MEI3OTE4NTFDMDI0 NDMyMDAyNDgxRTIgLyogR2VuZXJhdG9yRnVuY3Rpb25Db25zdHJ1Y3Rvci5jcHAgKi8sCiAJCQkJ NzBCNzkxODYxQzAyNDQzMjAwMjQ4MUUyIC8qIEdlbmVyYXRvckZ1bmN0aW9uQ29uc3RydWN0b3Iu aCAqLywKIAkJCQk3MEI3OTE4NzFDMDI0NDMyMDAyNDgxRTIgLyogR2VuZXJhdG9yRnVuY3Rpb25Q cm90b3R5cGUuY3BwICovLApAQCAtNzQyMCw2ICs3NDM4LDggQEAKIAkJCQkwRkUyMjhFQjE0MzZB QjIzMDAxOTZDNDggLyogT3B0aW9ucy5oICovLAogCQkJCUZFMzg0MjMxMjMyNEQ1MUIwMDlERDQ0 NSAvKiBPcHRpb25zTGlzdC5oICovLAogCQkJCTM3QzczOEQxMUVEQjU2NzIwMDNGMkIwQiAvKiBQ YXJzZUludC5oICovLAorCQkJCUNFMjBCRDAyMjM3RDNBRDQwMDQ2RTUyMCAvKiBQcmVkaWN0aW9u RmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuY3BwICovLAorCQkJCUNFMjBCRDAxMjM3RDNBRDQwMDQ2 RTUyMCAvKiBQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuaCAqLywKIAkJCQk4Njg5 MTZBOTE1NUYyODU0MDBDQjJCOUEgLyogUHJpdmF0ZU5hbWUuaCAqLywKIAkJCQkxNDczNDFERjFE QzJDRTk2MDBBQTI5QkEgLyogUHJvZ3JhbUV4ZWN1dGFibGUuY3BwICovLAogCQkJCTE0NzM0MUQz MURDMDJFNkQwMEFBMjlCQSAvKiBQcm9ncmFtRXhlY3V0YWJsZS5oICovLApAQCAtOTU4Niw2ICs5 NjA2LDcgQEAKIAkJCQlBMTgxOTNFNDFCNEUwQ0RCMDBGQzEwMjkgLyogSW50bENvbGxhdG9yUHJv dG90eXBlLmx1dC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTE1ODdENkUxQjREQzE0MTAwRDY5ODQ5 IC8qIEludGxEYXRlVGltZUZvcm1hdC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJQTE1ODdENzAxQjRE QzE0MTAwRDY5ODQ5IC8qIEludGxEYXRlVGltZUZvcm1hdENvbnN0cnVjdG9yLmggaW4gSGVhZGVy cyAqLywKKwkJCQlDRTIwQkQwNTIzN0QzRTIzMDA0NkU1MjAgLyogRmlsZUJhc2VkRnV6emVyQWdl bnRCYXNlLmggaW4gSGVhZGVycyAqLywKIAkJCQlBMTU4N0Q3NTFCNERDMUM2MDBENjk4NDkgLyog SW50bERhdGVUaW1lRm9ybWF0Q29uc3RydWN0b3IubHV0LmggaW4gSGVhZGVycyAqLywKIAkJCQlB MTU4N0Q3MjFCNERDMTQxMDBENjk4NDkgLyogSW50bERhdGVUaW1lRm9ybWF0UHJvdG90eXBlLmgg aW4gSGVhZGVycyAqLywKIAkJCQlBMTU4N0Q3NjFCNERDMUM2MDBENjk4NDkgLyogSW50bERhdGVU aW1lRm9ybWF0UHJvdG90eXBlLmx1dC5oIGluIEhlYWRlcnMgKi8sCkBAIC05ODgyLDYgKzk5MDMs NyBAQAogCQkJCTBGN0M1RkI4MUQ4ODhBMEMwMDQ0RjVFMiAvKiBNYXJrZWRCbG9ja0lubGluZXMu aCBpbiBIZWFkZXJzICovLAogCQkJCTE0MTQ0OENCMTNBMTc2RUMwMEY1QkExQSAvKiBNYXJrZWRC bG9ja1NldC5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMTREMkYzREIxMzlGNEJFMjAwNDkxMDMxIC8q IE1hcmtlZFNwYWNlLmggaW4gSGVhZGVycyAqLywKKwkJCQlDRTIwQkQwNzIzN0QzRTQ4MDA0NkU1 MjAgLyogUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50LmggaW4gSGVhZGVycyAqLywK IAkJCQkwRjdERjEzNTFFMjk3MERDMDA5NTk1MUIgLyogTWFya2VkU3BhY2VJbmxpbmVzLmggaW4g SGVhZGVycyAqLywKIAkJCQkwRjY2MEUzODFFMDUxN0JCMDAzMTQ2MkMgLyogTWFya2luZ0NvbnN0 cmFpbnQuaCBpbiBIZWFkZXJzICovLAogCQkJCTBGNjYwRTNBMUUwNTE3QzEwMDMxNDYyQyAvKiBN YXJraW5nQ29uc3RyYWludFNldC5oIGluIEhlYWRlcnMgKi8sCkBAIC05OTk4LDYgKzEwMDIwLDcg QEAKIAkJCQk1MzRFMDM1NjFFNTNCRURFMDAyMTNGNjQgLyogUHJveHlhYmxlQWNjZXNzQ2FzZS5o IGluIEhlYWRlcnMgKi8sCiAJCQkJNzlCMDBDQkQxQzZBQjA3RTAwODhDNjVEIC8qIFByb3h5Q29u c3RydWN0b3IuaCBpbiBIZWFkZXJzICovLAogCQkJCTc5QjAwQ0JGMUM2QUIwN0UwMDg4QzY1RCAv KiBQcm94eU9iamVjdC5oIGluIEhlYWRlcnMgKi8sCisJCQkJQ0VDRkFEMzcyMzcyREFENDAwMjkx NTk5IC8qIEZpbGVCYXNlZEZ1enplckFnZW50LmggaW4gSGVhZGVycyAqLywKIAkJCQk3OTE2MERC RTFDOEUzRUM4MDA4QzA4NUEgLyogUHJveHlSZXZva2UuaCBpbiBIZWFkZXJzICovLAogCQkJCTBG NTc4MEEyMThGRTFFOTgwMDFFNzJEOSAvKiBQdXJlTmFOLmggaW4gSGVhZGVycyAqLywKIAkJCQkw RjE1Q0QyMzFCQTVGOTg2MDAzMUZGRDMgLyogUHV0QnlJZEZsYWdzLmggaW4gSGVhZGVycyAqLywK QEAgLTEwMDc2LDYgKzEwMDk5LDcgQEAKIAkJCQlGRTMwMjJEMzFFM0Q3M0E1MDBCQUM0OTMgLyog U2lnaWxsQ3Jhc2hBbmFseXplci5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMEY0RDhDNzgxRkNBM0NG QTAwMUQzMkFDIC8qIFNpbXBsZU1hcmtpbmdDb25zdHJhaW50LmggaW4gSGVhZGVycyAqLywKIAkJ CQkwRjJCNjcwNTE3QjZCNUFCMDBBN0FFM0YgLyogU2ltcGxlVHlwZWRBcnJheUNvbnRyb2xsZXIu aCBpbiBIZWFkZXJzICovLAorCQkJCUNFQ0ZBRDM2MjM3MkRBRDAwMDI5MTU5OSAvKiBGdXp6ZXJQ cmVkaWN0aW9ucy5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMTRCQTc4RjExM0FBQjg4RjAwNUI3QzJD IC8qIFNsb3RWaXNpdG9yLmggaW4gSGVhZGVycyAqLywKIAkJCQlDMjE2MEZFNzE1RjdFOTVFMDA5 NDJERkMgLyogU2xvdFZpc2l0b3JJbmxpbmVzLmggaW4gSGVhZGVycyAqLywKIAkJCQlBNzA5RjJG MDE3QTBBQzA0MDA1MTJFOTggLyogU2xvd1BhdGhDYWxsLmggaW4gSGVhZGVycyAqLywKZGlmZiAt LWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9Tb3VyY2VzLnR4dCBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9Tb3VyY2VzLnR4dAppbmRleCBlYzAzNzI3YWIzMy4uOGQ3MDZjOTUyMWMgMTAwNjQ0 Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9Tb3VyY2VzLnR4dAorKysgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvU291cmNlcy50eHQKQEAgLTc2Niw2ICs3NjYsOCBAQCBydW50aW1lL0V4Y2Vw dGlvbkZ1enouY3BwCiBydW50aW1lL0V4Y2VwdGlvbkhlbHBlcnMuY3BwCiBydW50aW1lL0V4Y2Vw dGlvblNjb3BlLmNwcAogcnVudGltZS9FeGVjdXRhYmxlQmFzZS5jcHAKK3J1bnRpbWUvRmlsZUJh c2VkRnV6emVyQWdlbnQuY3BwCitydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5jcHAK IHJ1bnRpbWUvRnVuY3Rpb25Db25zdHJ1Y3Rvci5jcHAKIHJ1bnRpbWUvRnVuY3Rpb25FeGVjdXRh YmxlLmNwcAogcnVudGltZS9GdW5jdGlvbkV4ZWN1dGFibGVEdW1wLmNwcApAQCAtNzczLDYgKzc3 NSw3IEBAIHJ1bnRpbWUvRnVuY3Rpb25IYXNFeGVjdXRlZENhY2hlLmNwcAogcnVudGltZS9GdW5j dGlvblByb3RvdHlwZS5jcHAKIHJ1bnRpbWUvRnVuY3Rpb25SYXJlRGF0YS5jcHAKIHJ1bnRpbWUv RnV6emVyQWdlbnQuY3BwCitydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmNwcAogcnVudGltZS9H ZW5lcmF0b3JGdW5jdGlvbkNvbnN0cnVjdG9yLmNwcAogcnVudGltZS9HZW5lcmF0b3JGdW5jdGlv blByb3RvdHlwZS5jcHAKIHJ1bnRpbWUvR2VuZXJhdG9yUHJvdG90eXBlLmNwcApAQCAtOTAzLDYg KzkwNiw3IEBAIHJ1bnRpbWUvT2JqZWN0UHJvdG90eXBlLmNwcAogcnVudGltZS9PYmplY3RUb1N0 cmluZ0FkYXB0aXZlU3RydWN0dXJlV2F0Y2hwb2ludC5jcHAKIHJ1bnRpbWUvT3BlcmF0aW9ucy5j cHAKIHJ1bnRpbWUvT3B0aW9ucy5jcHAKK3J1bnRpbWUvUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1 enplckFnZW50LmNwcAogcnVudGltZS9Qcm9ncmFtRXhlY3V0YWJsZS5jcHAKIHJ1bnRpbWUvUHJv bWlzZVRpbWVyLmNwcAogcnVudGltZS9Qcm9wZXJ0eURlc2NyaXB0b3IuY3BwCmRpZmYgLS1naXQg YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudC5jcHAg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudC5jcHAK bmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmE3Y2Q0YzFjMjQ3Ci0tLSAv ZGV2L251bGwKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRmlsZUJhc2VkRnV6 emVyQWdlbnQuY3BwCkBAIC0wLDAgKzEsMTE3IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE5 IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBh bmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1v ZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29u ZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29k ZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlz dCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRp c3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHly aWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIg bWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNP RlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVY UFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBU TywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRO RVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBF VkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBB TlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwg T1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywK KyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0Yg VVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dF VkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElO IENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJ R0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAq IE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0Yg U1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkZpbGVC YXNlZEZ1enplckFnZW50LmgiCisKKyNpbmNsdWRlICJDb2RlQmxvY2suaCIKKyNpbmNsdWRlICJG dXp6ZXJQcmVkaWN0aW9ucy5oIgorI2luY2x1ZGUgPHd0Zi9BbnNpQ29sb3JzLmg+CisKK25hbWVz cGFjZSBKU0MgeworCitGaWxlQmFzZWRGdXp6ZXJBZ2VudDo6RmlsZUJhc2VkRnV6emVyQWdlbnQo Vk0mIHZtKQorICAgIDogRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlKHZtKQoreworfQorCitTcGVj dWxhdGVkVHlwZSBGaWxlQmFzZWRGdXp6ZXJBZ2VudDo6Z2V0UHJlZGljdGlvbkludGVybmFsKENv ZGVCbG9jayogY29kZUJsb2NrLCBQcmVkaWN0aW9uVGFyZ2V0JiB0YXJnZXQsIFNwZWN1bGF0ZWRU eXBlIG9yaWdpbmFsKQoreworICAgIEZ1enplclByZWRpY3Rpb25zJiBmdXp6ZXJQcmVkaWN0aW9u cyA9IGVuc3VyZUdsb2JhbEZ1enplclByZWRpY3Rpb25zKCk7CisgICAgT3B0aW9uYWw8U3BlY3Vs YXRlZFR5cGU+IGdlbmVyYXRlZCA9IGZ1enplclByZWRpY3Rpb25zLnByZWRpY3Rpb25Gb3IodGFy Z2V0Lmxvb2t1cEtleSk7CisKKyAgICBTb3VyY2VQcm92aWRlciogcHJvdmlkZXIgPSBjb2RlQmxv Y2stPnNvdXJjZSgpLnByb3ZpZGVyKCk7CisgICAgYXV0byBzb3VyY2VVcFRvRGl2b3QgPSBwcm92 aWRlci0+c291cmNlKCkuc3Vic3RyaW5nKHRhcmdldC5kaXZvdCAtIHRhcmdldC5zdGFydE9mZnNl dCwgdGFyZ2V0LnN0YXJ0T2Zmc2V0KTsKKyAgICBhdXRvIHNvdXJjZUFmdGVyRGl2b3QgPSBwcm92 aWRlci0+c291cmNlKCkuc3Vic3RyaW5nKHRhcmdldC5kaXZvdCwgdGFyZ2V0LmVuZE9mZnNldCk7 CisKKyAgICBzd2l0Y2ggKHRhcmdldC5vcGNvZGVJZCkgeworICAgIC8vIEZJWE1FOiB0aGVzZSBj YW4gbm90IGJlIHRhcmdldGVkIGF0IGFsbCBkdWUgdG8gdGhlIGJ1Z3MgYmVsb3cKKyAgICBjYXNl IG9wX3RvX3RoaXM6IC8vIGJyb2tlbiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5j Z2k/aWQ9MjAzNTU1CisgICAgY2FzZSBvcF9nZXRfYXJndW1lbnQ6IC8vIGJyb2tlbiBodHRwczov L2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAzNTU0CisgICAgICAgIHJldHVybiBv cmlnaW5hbDsKKworICAgIC8vIEZJWE1FOiB0aGUgb3V0cHV0IG9mIGNvZGVCbG9jay0+ZXhwcmVz c2lvblJhbmdlRm9yQnl0ZWNvZGVJbmRleCgpIGFsbG93cyBmb3Igc29tZSBvZgorICAgIC8vIHRo ZXNlIG9wY29kZXMgdG8gaGF2ZSBwcmVkaWN0aW9ucywgYnV0IG5vdCBhbGwgaW5zdGFuY2VzIGNh biBiZSByZWxpYWJseSB0YXJnZXRlZC4KKyAgICBjYXNlIG9wX2JpdGFuZDogLy8gcGFydGlhbGx5 IGJyb2tlbiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAzNjA0Cisg ICAgY2FzZSBvcF9iaXRvcjogLy8gcGFydGlhbGx5IGJyb2tlbiBodHRwczovL2J1Z3Mud2Via2l0 Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAzNjA0CisgICAgY2FzZSBvcF9iaXR4b3I6IC8vIHBhcnRp YWxseSBicm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzYw NAorICAgIGNhc2Ugb3BfYml0bm90OiAvLyBwYXJ0aWFsbHkgYnJva2VuCisgICAgY2FzZSBvcF9n ZXRfZnJvbV9zY29wZTogLy8gcGFydGlhbGx5IGJyb2tlbiBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MjAzNjAzCisgICAgY2FzZSBvcF9nZXRfZnJvbV9hcmd1bWVudHM6 IC8vIHBhcnRpYWxseSBicm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dp P2lkPTIwMzYwOAorICAgIGNhc2Ugb3BfZ2V0X2J5X3ZhbDogLy8gcGFydGlhbGx5IGJyb2tlbiBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAzNjY1CisgICAgY2FzZSBv cF9yc2hpZnQ6IC8vIHBhcnRpYWxseSBicm9rZW4gaHR0cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hv d19idWcuY2dpP2lkPTIwMzY2NAorICAgIGNhc2Ugb3BfbHNoaWZ0OiAvLyBwYXJ0aWFsbHkgYnJv a2VuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM2NjQKKyAgICBj YXNlIG9wX3RvX251bWJlcjogLy8gcGFydGlhbGx5IGJyb2tlbgorICAgIGNhc2Ugb3BfZ2V0X2J5 X2lkOiAvLyBzb21ldGltZXMgb2NjdXJzIGltcGxpY2l0bHkgZm9yIHRoaW5ncyByZWxhdGVkIHRv IFN5bWJvbC5pdGVyYXRvcgorICAgICAgICBpZiAoIWdlbmVyYXRlZCkKKyAgICAgICAgICAgIHJl dHVybiBvcmlnaW5hbDsKKyAgICAgICAgYnJlYWs7CisKKyAgICBjYXNlIG9wX2NhbGw6IC8vIG9w X2NhbGwgYXBwZWFycyBpbXBsaWNpdGx5IGluIGZvci1vZiBsb29wcywgZ2VuZXJhdG9ycywgc3By ZWFkL3Jlc3QgZWxlbWVudHMsIGRlc3RydWN0dXJpbmcgYXNzaWdubWVudAorICAgICAgICBpZiAo IWdlbmVyYXRlZCkgeworICAgICAgICAgICAgaWYgKHNvdXJjZUFmdGVyRGl2b3QuY29udGFpbnNJ Z25vcmluZ0FTQ0lJQ2FzZSgib2YgIikpCisgICAgICAgICAgICAgICAgcmV0dXJuIG9yaWdpbmFs OworICAgICAgICAgICAgaWYgKHNvdXJjZUFmdGVyRGl2b3QuY29udGFpbnNJZ25vcmluZ0FTQ0lJ Q2FzZSgiLi4uIikpCisgICAgICAgICAgICAgICAgcmV0dXJuIG9yaWdpbmFsOworICAgICAgICAg ICAgaWYgKHNvdXJjZUFmdGVyRGl2b3QuY29udGFpbnNJZ25vcmluZ0FTQ0lJQ2FzZSgieWllbGQi KSkKKyAgICAgICAgICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAgICAgICAgICBpZiAoc291 cmNlQWZ0ZXJEaXZvdC5zdGFydHNXaXRoKCdbJykgJiYgc291cmNlQWZ0ZXJEaXZvdC5lbmRzV2l0 aCgiXSIpKQorICAgICAgICAgICAgICAgIHJldHVybiBvcmlnaW5hbDsKKyAgICAgICAgICAgIGlm IChzb3VyY2VVcFRvRGl2b3QuY29udGFpbnNJZ25vcmluZ0FTQ0lJQ2FzZSgieWllbGQiKSkKKyAg ICAgICAgICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAgICAgICAgICBpZiAoc291cmNlVXBU b0Rpdm90ID09ICIuLi4iKQorICAgICAgICAgICAgICAgIHJldHVybiBvcmlnaW5hbDsKKyAgICAg ICAgICAgIGlmICghdGFyZ2V0LnN0YXJ0T2Zmc2V0ICYmICF0YXJnZXQuZW5kT2Zmc2V0KQorICAg ICAgICAgICAgICAgIHJldHVybiBvcmlnaW5hbDsKKyAgICAgICAgfQorICAgICAgICBicmVhazsK KworICAgIGNhc2Ugb3BfZ2V0X2J5X3ZhbF93aXRoX3RoaXM6CisgICAgY2FzZSBvcF9nZXRfZGly ZWN0X3BuYW1lOgorICAgIGNhc2Ugb3BfY29uc3RydWN0OgorICAgIGNhc2Ugb3BfY29uc3RydWN0 X3ZhcmFyZ3M6CisgICAgY2FzZSBvcF9jYWxsX3ZhcmFyZ3M6CisgICAgY2FzZSBvcF9jYWxsX2V2 YWw6CisgICAgY2FzZSBvcF90YWlsX2NhbGw6CisgICAgY2FzZSBvcF90YWlsX2NhbGxfdmFyYXJn czoKKyAgICBjYXNlIG9wX2dldF9ieV9pZF93aXRoX3RoaXM6CisgICAgICAgIGJyZWFrOworCisg ICAgZGVmYXVsdDoKKyAgICAgICAgUkVMRUFTRV9BU1NFUlRfTk9UX1JFQUNIRURfV0lUSF9NRVNT QUdFKCJVbmhhbmRsZWQgb3Bjb2RlICVzIiwgdG9TdHJpbmcodGFyZ2V0Lm9wY29kZUlkKS51dGY4 KCkuZGF0YSgpKTsKKyAgICB9CisgICAgaWYgKCFnZW5lcmF0ZWQpIHsKKyAgICAgICAgaWYgKE9w dGlvbnM6OmR1bXBGdXp6ZXJBZ2VudFByZWRpY3Rpb25zKCkpCisgICAgICAgICAgICBkYXRhTG9n TG4oTUFHRU5UQShCT0xEKHRhcmdldC5ieXRlY29kZUluZGV4KSksICIgIiwgQk9MRChZRUxMT1co dGFyZ2V0Lm9wY29kZUlkKSksICIgbWlzc2luZyBwcmVkaWN0aW9uIGZvcjogIiwgUkVEKEJPTEQo dGFyZ2V0Lmxvb2t1cEtleSkpLCAiICIsIEdSRUVOKHRhcmdldC5zb3VyY2VGaWxlbmFtZSksICI6 IiwgQ1lBTih0YXJnZXQubGluZSksICI6IiwgQ1lBTih0YXJnZXQuY29sdW1uKSwgIiBkaXZvdDog IiwgdGFyZ2V0LmRpdm90LCAiIC0iLCB0YXJnZXQuc3RhcnRPZmZzZXQsICIgKyIsIHRhcmdldC5l bmRPZmZzZXQsICIgbmFtZTogJyIsIFlFTExPVyhjb2RlQmxvY2stPmluZmVycmVkTmFtZSgpKSwg Iicgc291cmNlOiAnIiwgQkxVRShzb3VyY2VVcFRvRGl2b3QpLCBCTFVFKEJPTEQoc291cmNlQWZ0 ZXJEaXZvdCkpLCAiJyIpOworCisgICAgICAgIFJFTEVBU0VfQVNTRVJUX1dJVEhfTUVTU0FHRSgh T3B0aW9uczo6cmVxdWlyZVByZWRpY3Rpb25Gb3JGaWxlQmFzZWRGdXp6ZXJBZ2VudCgpLCAiTWlz c2luZyBleHBlY3RlZCBwcmVkaWN0aW9uIGluIEZ1enplckFnZW50Iik7CisgICAgICAgIHJldHVy biBvcmlnaW5hbDsKKyAgICB9CisgICAgaWYgKE9wdGlvbnM6OmR1bXBGdXp6ZXJBZ2VudFByZWRp Y3Rpb25zKCkpCisgICAgICAgIGRhdGFMb2dMbihZRUxMT1codGFyZ2V0Lm9wY29kZUlkKSwgIiAi LCBDWUFOKHRhcmdldC5sb29rdXBLZXkpLCAiIG9yaWdpbmFsOiAiLCBDWUFOKEJPTEQoU3BlY3Vs YXRpb25EdW1wKG9yaWdpbmFsKSkpLCAiIGdlbmVyYXRlZDogIiwgTUFHRU5UQShCT0xEKFNwZWN1 bGF0aW9uRHVtcCgqZ2VuZXJhdGVkKSkpKTsKKyAgICByZXR1cm4gKmdlbmVyYXRlZDsKK30KKwor fSAvLyBuYW1lc3BhY2UgSlNDCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVu dGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudC5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRp bWUvRmlsZUJhc2VkRnV6emVyQWdlbnQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAw MDAwMDAwMC4uYzkyOTExZmQ0MzkKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudC5oCkBAIC0wLDAgKzEsNDQgQEAKKy8q CisgKiBDb3B5cmlnaHQgKEMpIDIwMTkgQXBwbGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgor ICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMs IHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVk IHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0 cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQK KyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcg ZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJl cHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBj b25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1 bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJp YnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBg YEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xV RElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBN RVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBB UkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRS SUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBT UEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElO RywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09E UyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJ TkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBP RiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRP UlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5Z IFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VE IE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UK KworI2luY2x1ZGUgIkZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5oIgorCituYW1lc3BhY2UgSlND IHsKKworY2xhc3MgVk07CisKK2NsYXNzIEZpbGVCYXNlZEZ1enplckFnZW50IGZpbmFsIDogcHVi bGljIEZpbGVCYXNlZEZ1enplckFnZW50QmFzZSB7CisgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FU RUQ7CisKK3B1YmxpYzoKKyAgICBGaWxlQmFzZWRGdXp6ZXJBZ2VudChWTSYpOworCitwcm90ZWN0 ZWQ6CisgICAgU3BlY3VsYXRlZFR5cGUgZ2V0UHJlZGljdGlvbkludGVybmFsKENvZGVCbG9jayos IFByZWRpY3Rpb25UYXJnZXQmLCBTcGVjdWxhdGVkVHlwZSBvcmlnaW5hbCkgb3ZlcnJpZGU7Cit9 OworCit9IC8vIG5hbWVzcGFjZSBKU0MKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9ydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UuY3BwCm5ldyBmaWxlIG1vZGUg MTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi40NzE4MDk3ZDRlNQotLS0gL2Rldi9udWxsCisrKyBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5j cHAKQEAgLTAsMCArMSw4OCBAQAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxOSBBcHBsZSBJbmMu IEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBz b3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24s IGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAq IGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRh aW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0 aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25z IGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAg IG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xh aW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBw cm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQ Uk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElN UExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICog SU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQ QVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwg QVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwg SU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVF TlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJF TUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwg T1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQg QU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwg U1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9U SEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNP RlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdF LgorICovCisKKyNpbmNsdWRlICJjb25maWcuaCIKKyNpbmNsdWRlICJGaWxlQmFzZWRGdXp6ZXJB Z2VudEJhc2UuaCIKKworI2luY2x1ZGUgIkNvZGVCbG9jay5oIgorI2luY2x1ZGUgPHd0Zi90ZXh0 L1N0cmluZ0J1aWxkZXIuaD4KKworbmFtZXNwYWNlIEpTQyB7CisKK0ZpbGVCYXNlZEZ1enplckFn ZW50QmFzZTo6RmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlKFZNJikKK3sKK30KKworU3RyaW5nIEZp bGVCYXNlZEZ1enplckFnZW50QmFzZTo6Y3JlYXRlTG9va3VwS2V5KGNvbnN0IFN0cmluZyYgc291 cmNlRmlsZW5hbWUsIE9wY29kZUlEIG9wY29kZUlkLCBpbnQgc3RhcnRMb2NhdGlvbiwgaW50IGVu ZExvY2F0aW9uKQoreworICAgIFN0cmluZ0J1aWxkZXIgbG9va3VwS2V5OworICAgIGxvb2t1cEtl eS5hcHBlbmQoc291cmNlRmlsZW5hbWUpOworICAgIGxvb2t1cEtleS5hcHBlbmQoInwiKTsKKyAg ICBsb29rdXBLZXkuYXBwZW5kKHRvU3RyaW5nKG9wY29kZUFsaWFzRm9yTG9va3VwS2V5KG9wY29k ZUlkKSkpOworICAgIGxvb2t1cEtleS5hcHBlbmQoInwiKTsKKyAgICBsb29rdXBLZXkuYXBwZW5k KHN0YXJ0TG9jYXRpb24pOworICAgIGxvb2t1cEtleS5hcHBlbmQoInwiKTsKKyAgICBsb29rdXBL ZXkuYXBwZW5kKGVuZExvY2F0aW9uKTsKKyAgICByZXR1cm4gbG9va3VwS2V5LnRvU3RyaW5nKCk7 Cit9CisKK09wY29kZUlEIEZpbGVCYXNlZEZ1enplckFnZW50QmFzZTo6b3Bjb2RlQWxpYXNGb3JM b29rdXBLZXkoY29uc3QgT3Bjb2RlSUQmIG9wY29kZUlkKQoreworICAgIGlmIChvcGNvZGVJZCA9 PSBvcF9jYWxsX3ZhcmFyZ3MgfHwgb3Bjb2RlSWQgPT0gb3BfY2FsbF9ldmFsIHx8IG9wY29kZUlk ID09IG9wX3RhaWxfY2FsbCB8fCBvcGNvZGVJZCA9PSBvcF90YWlsX2NhbGxfdmFyYXJncykKKyAg ICAgICAgcmV0dXJuIG9wX2NhbGw7CisgICAgaWYgKG9wY29kZUlkID09IG9wX2dldF9kaXJlY3Rf cG5hbWUgfHwgb3Bjb2RlSWQgPT0gb3BfZ2V0X2J5X3ZhbF93aXRoX3RoaXMpCisgICAgICAgIHJl dHVybiBvcF9nZXRfYnlfdmFsOworICAgIGlmIChvcGNvZGVJZCA9PSBvcF9jb25zdHJ1Y3RfdmFy YXJncykKKyAgICAgICAgcmV0dXJuIG9wX2NvbnN0cnVjdDsKKyAgICByZXR1cm4gb3Bjb2RlSWQ7 Cit9CisKK1NwZWN1bGF0ZWRUeXBlIEZpbGVCYXNlZEZ1enplckFnZW50QmFzZTo6Z2V0UHJlZGlj dGlvbihDb2RlQmxvY2sqIGNvZGVCbG9jaywgY29uc3QgQ29kZU9yaWdpbiYgY29kZU9yaWdpbiwg U3BlY3VsYXRlZFR5cGUgb3JpZ2luYWwpCit7CisgICAgYXV0byBsb2NrZXIgPSBob2xkTG9jayht X2xvY2spOworCisgICAgU2NyaXB0RXhlY3V0YWJsZSogb3duZXJFeGVjdXRhYmxlID0gY29kZUJs b2NrLT5vd25lckV4ZWN1dGFibGUoKTsKKyAgICBjb25zdCBhdXRvJiBzb3VyY2VVUkwgPSBvd25l ckV4ZWN1dGFibGUtPnNvdXJjZVVSTCgpOworICAgIGlmIChzb3VyY2VVUkwuaXNFbXB0eSgpKQor ICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisKKyAgICBQcmVkaWN0aW9uVGFyZ2V0IHByZWRpY3Rp b25UYXJnZXQ7CisgICAgQnl0ZWNvZGVJbmRleCBieXRlY29kZUluZGV4ID0gY29kZU9yaWdpbi5i eXRlY29kZUluZGV4KCk7CisgICAgY29kZUJsb2NrLT5leHByZXNzaW9uUmFuZ2VGb3JCeXRlY29k ZUluZGV4KGJ5dGVjb2RlSW5kZXgsIHByZWRpY3Rpb25UYXJnZXQuZGl2b3QsIHByZWRpY3Rpb25U YXJnZXQuc3RhcnRPZmZzZXQsIHByZWRpY3Rpb25UYXJnZXQuZW5kT2Zmc2V0LCBwcmVkaWN0aW9u VGFyZ2V0LmxpbmUsIHByZWRpY3Rpb25UYXJnZXQuY29sdW1uKTsKKworICAgIFZlY3RvcjxTdHJp bmc+IHVybFBhcnRzID0gc291cmNlVVJMLnNwbGl0KCcvJyk7CisgICAgcHJlZGljdGlvblRhcmdl dC5zb3VyY2VGaWxlbmFtZSA9IHVybFBhcnRzLmlzRW1wdHkoKSA/IHNvdXJjZVVSTCA6IHVybFBh cnRzLmxhc3QoKTsKKworICAgIGNvbnN0IEluc3RydWN0aW9uU3RyZWFtJiBpbnN0cnVjdGlvbnMg PSBjb2RlQmxvY2stPmluc3RydWN0aW9ucygpOworICAgIGNvbnN0IEluc3RydWN0aW9uKiBhbklu c3RydWN0aW9uID0gaW5zdHJ1Y3Rpb25zLmF0KGJ5dGVjb2RlSW5kZXgpLnB0cigpOworICAgIHBy ZWRpY3Rpb25UYXJnZXQub3Bjb2RlSWQgPSBhbkluc3RydWN0aW9uLT5vcGNvZGVJRCgpOworCisg ICAgaW50IHN0YXJ0TG9jYXRpb24gPSBwcmVkaWN0aW9uVGFyZ2V0LmRpdm90IC0gcHJlZGljdGlv blRhcmdldC5zdGFydE9mZnNldDsKKyAgICBpbnQgZW5kTG9jYXRpb24gPSBwcmVkaWN0aW9uVGFy Z2V0LmRpdm90ICsgcHJlZGljdGlvblRhcmdldC5lbmRPZmZzZXQ7CisgICAgcHJlZGljdGlvblRh cmdldC5sb29rdXBLZXkgPSBjcmVhdGVMb29rdXBLZXkocHJlZGljdGlvblRhcmdldC5zb3VyY2VG aWxlbmFtZSwgcHJlZGljdGlvblRhcmdldC5vcGNvZGVJZCwgc3RhcnRMb2NhdGlvbiwgZW5kTG9j YXRpb24pOworICAgIHJldHVybiBnZXRQcmVkaWN0aW9uSW50ZXJuYWwoY29kZUJsb2NrLCBwcmVk aWN0aW9uVGFyZ2V0LCBvcmlnaW5hbCk7Cit9CisKK30gLy8gbmFtZXNwYWNlIEpTQwpkaWZmIC0t Z2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnRC YXNlLmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2Vu dEJhc2UuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uNzZmMGRkOWVm OGMKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GaWxl QmFzZWRGdXp6ZXJBZ2VudEJhc2UuaApAQCAtMCwwICsxLDY2IEBACisvKgorICogQ29weXJpZ2h0 IChDKSAyMDE5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBz b3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisg KiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFi b3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQv b3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBB TlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu ICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNpbmNsdWRlICJG dXp6ZXJBZ2VudC5oIgorI2luY2x1ZGUgIk9wY29kZS5oIgorI2luY2x1ZGUgPHd0Zi9Mb2NrLmg+ CisKK25hbWVzcGFjZSBKU0MgeworCitjbGFzcyBWTTsKKworc3RydWN0IFByZWRpY3Rpb25UYXJn ZXQgeworICAgIEJ5dGVjb2RlSW5kZXggYnl0ZWNvZGVJbmRleDsKKyAgICBpbnQgZGl2b3Q7Cisg ICAgaW50IHN0YXJ0T2Zmc2V0OworICAgIGludCBlbmRPZmZzZXQ7CisgICAgdW5zaWduZWQgbGlu ZTsKKyAgICB1bnNpZ25lZCBjb2x1bW47CisgICAgT3Bjb2RlSUQgb3Bjb2RlSWQ7CisgICAgU3Ry aW5nIHNvdXJjZUZpbGVuYW1lOworICAgIFN0cmluZyBsb29rdXBLZXk7Cit9OworCitjbGFzcyBG aWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UgOiBwdWJsaWMgRnV6emVyQWdlbnQgeworICAgIFdURl9N QUtFX0ZBU1RfQUxMT0NBVEVEOworCitwdWJsaWM6CisgICAgRmlsZUJhc2VkRnV6emVyQWdlbnRC YXNlKFZNJik7CisKK3Byb3RlY3RlZDoKKyAgICBMb2NrIG1fbG9jazsKKyAgICB2aXJ0dWFsIFNw ZWN1bGF0ZWRUeXBlIGdldFByZWRpY3Rpb25JbnRlcm5hbChDb2RlQmxvY2sqLCBQcmVkaWN0aW9u VGFyZ2V0JiwgU3BlY3VsYXRlZFR5cGUgb3JpZ2luYWwpID0gMDsKKworcHVibGljOgorICAgIFNw ZWN1bGF0ZWRUeXBlIGdldFByZWRpY3Rpb24oQ29kZUJsb2NrKiwgY29uc3QgQ29kZU9yaWdpbiYs IFNwZWN1bGF0ZWRUeXBlIG9yaWdpbmFsKSBmaW5hbDsKKworcHJvdGVjdGVkOgorICAgIHN0YXRp YyBTdHJpbmcgY3JlYXRlTG9va3VwS2V5KGNvbnN0IFN0cmluZyYgc291cmNlRmlsZW5hbWUsIE9w Y29kZUlELCBpbnQgc3RhcnRMb2NhdGlvbiwgaW50IGVuZExvY2F0aW9uKTsKKyAgICBzdGF0aWMg T3Bjb2RlSUQgb3Bjb2RlQWxpYXNGb3JMb29rdXBLZXkoY29uc3QgT3Bjb2RlSUQmKTsKK307CisK K30gLy8gbmFtZXNwYWNlIEpTQwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1 bnRpbWUvRnV6emVyUHJlZGljdGlvbnMuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRp bWUvRnV6emVyUHJlZGljdGlvbnMuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAw MDAwMDAwLi42ZjcyZTQzYjE3ZAotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS9ydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmNwcApAQCAtMCwwICsxLDEwNSBAQAorLyoK KyAqIENvcHlyaWdodCAoQykgMjAxOSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisg KgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywg d2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQg dGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3Ry aWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAor ICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBk aXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVw cm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3Vt ZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmli dXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBg QVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVE SU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1F UkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFS RSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJ QlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQ RUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5H LCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RT IE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lO RVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9G IExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9S VAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkg V0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQg T0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRlICJjb25m aWcuaCIKKyNpbmNsdWRlICJGdXp6ZXJQcmVkaWN0aW9ucy5oIgorCituYW1lc3BhY2UgSlNDIHsK Kworc3RhdGljIFN0cmluZyByZWFkRmlsZUludG9TdHJpbmcoY29uc3QgY2hhciogZmlsZU5hbWUp Cit7CisgICAgRklMRSogZiA9IGZvcGVuKGZpbGVOYW1lLCAiciIpOworICAgIFJFTEVBU0VfQVNT RVJUX1dJVEhfTUVTU0FHRShmLCAiRmFpbGVkIHRvIG9wZW4gZmlsZSAlcyIsIGZpbGVOYW1lKTsK KyAgICBSRUxFQVNFX0FTU0VSVChmc2VlayhmLCAwLCBTRUVLX0VORCkgIT0gLTEpOworICAgIGxv bmcgYnVmZmVyQ2FwYWNpdHkgPSBmdGVsbChmKTsKKyAgICBSRUxFQVNFX0FTU0VSVChidWZmZXJD YXBhY2l0eSAhPSAtMSk7CisgICAgUkVMRUFTRV9BU1NFUlQoZnNlZWsoZiwgMCwgU0VFS19TRVQp ICE9IC0xKTsKKyAgICBWZWN0b3I8Y2hhcj4gYnVmZmVyOworICAgIGJ1ZmZlci5yZXNpemUoYnVm ZmVyQ2FwYWNpdHkpOworICAgIHNpemVfdCByZWFkU2l6ZSA9IGZyZWFkKGJ1ZmZlci5kYXRhKCks IDEsIGJ1ZmZlci5zaXplKCksIGYpOworICAgIGZjbG9zZShmKTsKKyAgICBSRUxFQVNFX0FTU0VS VChyZWFkU2l6ZSA9PSBidWZmZXIuc2l6ZSgpKTsKKyAgICByZXR1cm4gU3RyaW5nKGJ1ZmZlci5k YXRhKCksIGJ1ZmZlci5zaXplKCkpOworfQorCitGdXp6ZXJQcmVkaWN0aW9uczo6RnV6emVyUHJl ZGljdGlvbnMoY29uc3QgY2hhciogZmlsZW5hbWUpCit7CisgICAgUkVMRUFTRV9BU1NFUlRfV0lU SF9NRVNTQUdFKGZpbGVuYW1lLCAicHJlZGljdGlvbiBmaWxlIG11c3QgYmUgc3BlY2lmaWVkIHVz aW5nIC0tZnV6emVyUHJlZGljdGlvbnM9Iik7CisKKyAgICBTdHJpbmcgcHJlZGljdGlvbnMgPSBy ZWFkRmlsZUludG9TdHJpbmcoZmlsZW5hbWUpOworICAgIGNvbnN0IFZlY3RvcjxTdHJpbmc+JiBs aW5lcyA9IHByZWRpY3Rpb25zLnNwbGl0KCdcbicpOworICAgIGZvciAoY29uc3QgYXV0byYgbGlu ZSA6IGxpbmVzKSB7CisgICAgICAgIC8vIFByZWRpY3Rpb25zIGFyZSBzdG9yZWQgaW4gYSB0ZXh0 IGZpbGUsIG9uZSBwcmVkaWN0aW9uIHBlciBsaW5lIGluIHRoZSBjb2xvbiBkZWxpbWl0ZWQgZm9y bWF0OgorICAgICAgICAvLyA8bG9va3VwIGtleT46PHByZWRpY3Rpb24gaW4gaGV4IHdpdGhvdXQg bGVhZGluZyAweD4KKyAgICAgICAgLy8gVGhlIGxvb2t1cCBrZXkgaXMgYSBwaXBlIHNlcGFyYXRl ZCBzdHJpbmcgd2l0aCB0aGUgZm9ybWF0OgorICAgICAgICAvLyA8ZmlsZW5hbWU+fDxvcGNvZGU+ fDxzdGFydCBvZmZzZXQ+fDxlbmQgb2Zmc2V0PgorCisgICAgICAgIC8vIFRoZSBzdGFydCBhbmQg ZW5kIG9mZnNldHMgYXJlIDctYml0IHVuc2lnbmVkIGludGVnZXJzLgorICAgICAgICAvLyBJZiBz dGFydCBvZmZzZXQgPiAxMjcsIHRoZW4gYm90aCBzdGFydCBhbmQgZW5kIG9mZnNldHMgYXJlIDAu CisgICAgICAgIC8vIElmIGVuZCBvZmZzZXQgPiAxMjcsIHRoZW4gdGhlIGVuZCBvZmZzZXQgaXMg MC4KKworICAgICAgICAvLyBFeGFtcGxlIHByZWRpY3Rpb25zOgorICAgICAgICAvLyBmb28uanN8 b3BfY29uc3RydWN0fDcwMnw3MjE6MTAwMDA4NAorICAgICAgICAvLyBmb28uanN8b3BfY2FsbHw3 NDh8NzYwOjQwODgwMAorICAgICAgICAvLyBmb28uanN8b3BfYml0bm90fDc3MHw3NzA6MjgwMDAw MDAwCisKKyAgICAgICAgLy8gUHJlZGljdGlvbnMgY2FuIGJlIGdlbmVyYXRlZCB1c2luZyBQcmVk aWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuCisgICAgICAgIC8vIFNvbWUgb3Bjb2RlcyBh cmUgYWxpYXNlZCB0b2dldGhlciB0byBtYWtlIGdlbmVyYXRpbmcgdGhlIHByZWRpY3Rpb25zIG1v cmUgc3RyYWlnaHRmb3J3YXJkLgorICAgICAgICAvLyBGb3IgdGhlIGFsaWFzZXMgc2VlOiBGaWxl QmFzZWRGdXp6ZXJBZ2VudEJhc2U6Om9wY29kZUFsaWFzRm9yTG9va3VwS2V5KCkKKworICAgICAg ICAvLyBGSVhNRTogVGhlIGN1cnJlbnQgaW1wbGVtZW50YXRpb24gb25seSBzdXBwb3J0cyBvbmUg cHJlZGljdGlvbiBwZXIgbG9va3VwIGtleS4KKworICAgICAgICBjb25zdCBWZWN0b3I8U3RyaW5n PiYgbGluZVBhcnRzID0gbGluZS5zcGxpdCgnOicpOworICAgICAgICBSRUxFQVNFX0FTU0VSVF9X SVRIX01FU1NBR0UobGluZVBhcnRzLnNpemUoKSA9PSAyLCAiRXhwZWN0ZWQgbGluZSB3aXRoIHR3 byBwYXJ0cyBkZWxpbWl0ZWQgYnkgYSBjb2xvbi4gRm91bmQgbGluZSB3aXRoICVsdSBwYXJ0cy4i LCBsaW5lUGFydHMuc2l6ZSgpKTsKKyAgICAgICAgY29uc3QgU3RyaW5nJiBsb29rdXBLZXkgPSBs aW5lUGFydHNbMF07CisgICAgICAgIGNvbnN0IFN0cmluZyYgcHJlZGljdGlvblN0cmluZyA9IGxp bmVQYXJ0c1sxXTsKKyAgICAgICAgYm9vbCBvazsKKyAgICAgICAgU3BlY3VsYXRlZFR5cGUgcHJl ZGljdGlvbiA9IHByZWRpY3Rpb25TdHJpbmcudG9VSW50NjRTdHJpY3QoJm9rLCAweDEwKTsKKyAg ICAgICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKG9rLCAiQ291bGQgbm90IHBhcnNlIHBy ZWRpY3Rpb24gZnJvbSAnJXMnIiwgcHJlZGljdGlvblN0cmluZy51dGY4KCkuZGF0YSgpKTsKKyAg ICAgICAgUkVMRUFTRV9BU1NFUlQoc3BlY3VsYXRpb25DaGVja2VkKHByZWRpY3Rpb24sIFNwZWNG dWxsVG9wKSk7CisgICAgICAgIG1fcHJlZGljdGlvbnMuc2V0KGxvb2t1cEtleSwgcHJlZGljdGlv bik7CisgICAgfQorfQorCitPcHRpb25hbDxTcGVjdWxhdGVkVHlwZT4gRnV6emVyUHJlZGljdGlv bnM6OnByZWRpY3Rpb25Gb3IoY29uc3QgU3RyaW5nJiBrZXkpCit7CisgICAgYXV0byBpdCA9IG1f cHJlZGljdGlvbnMuZmluZChrZXkpOworICAgIGlmIChpdCA9PSBtX3ByZWRpY3Rpb25zLmVuZCgp KQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworICAgIHJldHVybiBpdC0+dmFsdWU7Cit9 CisKK0Z1enplclByZWRpY3Rpb25zJiBlbnN1cmVHbG9iYWxGdXp6ZXJQcmVkaWN0aW9ucygpCit7 CisgICAgc3RhdGljIExhenlOZXZlckRlc3Ryb3llZDxGdXp6ZXJQcmVkaWN0aW9ucz4gZnV6emVy UHJlZGljdGlvbnM7CisgICAgc3RhdGljIHN0ZDo6b25jZV9mbGFnIGluaXRpYWxpemVGdXp6ZXJQ cmVkaWN0aW9uc0ZsYWc7CisgICAgc3RkOjpjYWxsX29uY2UoaW5pdGlhbGl6ZUZ1enplclByZWRp Y3Rpb25zRmxhZywgW10geworICAgICAgICBjb25zdCBjaGFyKiBmdXp6ZXJQcmVkaWN0aW9uc0Zp bGVuYW1lID0gT3B0aW9uczo6ZnV6emVyUHJlZGljdGlvbnMoKTsKKyAgICAgICAgZnV6emVyUHJl ZGljdGlvbnMuY29uc3RydWN0KGZ1enplclByZWRpY3Rpb25zRmlsZW5hbWUpOworICAgIH0pOwor ICAgIHJldHVybiBmdXp6ZXJQcmVkaWN0aW9uczsKK30KKworfSAvLyBuYW1lc3BhY2UgSlNDCmRp ZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GdXp6ZXJQcmVkaWN0aW9u cy5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRnV6emVyUHJlZGljdGlvbnMuaApu ZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uMGRiOTZhNDg5Y2IKLS0tIC9k ZXYvbnVsbAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GdXp6ZXJQcmVkaWN0 aW9ucy5oCkBAIC0wLDAgKzEsNDYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTkgQXBwbGUg SW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2Ug aW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0 aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25z CisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3Qg cmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNv bmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0 aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0Cisg KiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRp c2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlh bHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUg SVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBP UiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUK KyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9S IEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNI QUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJF Q1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05T RVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJP Q1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERB VEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FV U0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJB Q1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBP UiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJ UyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERB TUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2luY2x1ZGUgPGJ5dGVjb2RlL0NvZGVCbG9j ay5oPgorI2luY2x1ZGUgPHd0Zi9IYXNoTWFwLmg+CisjaW5jbHVkZSA8d3RmL3RleHQvV1RGU3Ry aW5nLmg+CisKK25hbWVzcGFjZSBKU0MgeworCitjbGFzcyBGdXp6ZXJQcmVkaWN0aW9ucyB7Citw dWJsaWM6CisgICAgSlNfRVhQT1JUX1BSSVZBVEUgRnV6emVyUHJlZGljdGlvbnMoY29uc3QgY2hh ciopOworCisgICAgT3B0aW9uYWw8U3BlY3VsYXRlZFR5cGU+IHByZWRpY3Rpb25Gb3IoY29uc3Qg U3RyaW5nJik7CisKK3ByaXZhdGU6CisgICAgSGFzaE1hcDxTdHJpbmcsIFNwZWN1bGF0ZWRUeXBl PiBtX3ByZWRpY3Rpb25zOworfTsKKworSlNfRVhQT1JUX1BSSVZBVEUgRnV6emVyUHJlZGljdGlv bnMmIGVuc3VyZUdsb2JhbEZ1enplclByZWRpY3Rpb25zKCk7CisKK30gLy8gbmFtZXNwYWNlIEpT QwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvT3B0aW9ucy5jcHAg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9PcHRpb25zLmNwcAppbmRleCBjMTk2YjMw N2ZiOC4uYmQzMTZiNWJhOTYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50 aW1lL09wdGlvbnMuY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL09wdGlv bnMuY3BwCkBAIC00NDgsNyArNDQ4LDcgQEAgc3RhdGljIHZvaWQgcmVjb21wdXRlRGVwZW5kZW50 T3B0aW9ucygpCiAgICAgICAgIHx8IE9wdGlvbnM6OnZlcmJvc2VDRkEoKQogICAgICAgICB8fCBP cHRpb25zOjp2ZXJib3NlREZHRmFpbHVyZSgpCiAgICAgICAgIHx8IE9wdGlvbnM6OnZlcmJvc2VG VExGYWlsdXJlKCkKLSAgICAgICAgfHwgT3B0aW9uczo6ZHVtcFJhbmRvbWl6aW5nRnV6emVyQWdl bnRQcmVkaWN0aW9ucygpKQorICAgICAgICB8fCBPcHRpb25zOjpkdW1wRnV6emVyQWdlbnRQcmVk aWN0aW9ucygpKQogICAgICAgICBPcHRpb25zOjphbHdheXNDb21wdXRlSGFzaCgpID0gdHJ1ZTsK ICAgICAKICAgICBpZiAoIU9wdGlvbnM6OnVzZUNvbmN1cnJlbnRHQygpKQpkaWZmIC0tZ2l0IGEv U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvT3B0aW9uc0xpc3QuaCBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9ydW50aW1lL09wdGlvbnNMaXN0LmgKaW5kZXggNDcxNGM5MWY5NmEuLmMyZDhj ZjkwYWU1IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9PcHRpb25z TGlzdC5oCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL09wdGlvbnNMaXN0LmgK QEAgLTM5NCw4ICszOTQsMTIgQEAgY29uc3RleHByIGJvb2wgZW5hYmxlV2ViQXNzZW1ibHlTdHJl YW1pbmdBcGkgPSBmYWxzZTsKICAgICB2KFVuc2lnbmVkLCBzZWVkT2ZWTVJhbmRvbUZvckZ1enpl ciwgMCwgTm9ybWFsLCAiMCBtZWFucyBub3QgZnV6emluZyB0aGlzOyB1c2UgYSBjcnlwdG9ncmFw aGljYWxseSByYW5kb20gc2VlZCIpIFwKICAgICB2KEJvb2wsIHVzZVJhbmRvbWl6aW5nRnV6emVy QWdlbnQsIGZhbHNlLCBOb3JtYWwsIG51bGxwdHIpIFwKICAgICB2KFVuc2lnbmVkLCBzZWVkT2ZS YW5kb21pemluZ0Z1enplckFnZW50LCAxLCBOb3JtYWwsIG51bGxwdHIpIFwKLSAgICB2KEJvb2ws IGR1bXBSYW5kb21pemluZ0Z1enplckFnZW50UHJlZGljdGlvbnMsIGZhbHNlLCBOb3JtYWwsIG51 bGxwdHIpIFwKKyAgICB2KEJvb2wsIGR1bXBGdXp6ZXJBZ2VudFByZWRpY3Rpb25zLCBmYWxzZSwg Tm9ybWFsLCBudWxscHRyKSBcCiAgICAgdihCb29sLCB1c2VEb3VibGVQcmVkaWN0aW9uRnV6emVy QWdlbnQsIGZhbHNlLCBOb3JtYWwsIG51bGxwdHIpIFwKKyAgICB2KEJvb2wsIHVzZUZpbGVCYXNl ZEZ1enplckFnZW50LCBmYWxzZSwgTm9ybWFsLCBudWxscHRyKSBcCisgICAgdihCb29sLCB1c2VQ cmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQsIGZhbHNlLCBOb3JtYWwsIG51bGxwdHIp IFwKKyAgICB2KEJvb2wsIHJlcXVpcmVQcmVkaWN0aW9uRm9yRmlsZUJhc2VkRnV6emVyQWdlbnQs IGZhbHNlLCBOb3JtYWwsIG51bGxwdHIpIFwKKyAgICB2KE9wdGlvblN0cmluZywgZnV6emVyUHJl ZGljdGlvbnMsIG51bGxwdHIsIE5vcm1hbCwgImZpbGUgd2l0aCBsaXN0IG9mIHByZWRpY3Rpb25z IGZvciBGaWxlQmFzZWRGdXp6ZXJBZ2VudCIpIFwKICAgICBcCiAgICAgdihCb29sLCBsb2dQaGFz ZVRpbWVzLCBmYWxzZSwgTm9ybWFsLCBudWxscHRyKSBcCiAgICAgdihEb3VibGUsIHJhcmVCbG9j a1BlbmFsdHksIDAuMDAxLCBOb3JtYWwsIG51bGxwdHIpIFwKZGlmZiAtLWdpdCBhL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS9ydW50aW1lL1ByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5j cHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9QcmVkaWN0aW9uRmlsZUNyZWF0aW5n RnV6emVyQWdlbnQuY3BwCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi4z MTljNTMyNzJkOQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50 aW1lL1ByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5jcHAKQEAgLTAsMCArMSw3MSBA QAorLyoKKyAqIENvcHlyaWdodCAoQykgMjAxOSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2 ZWQuCisgKgorICogUmVkaXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBm b3Jtcywgd2l0aCBvciB3aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJv dmlkZWQgdGhhdCB0aGUgZm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBS ZWRpc3RyaWJ1dGlvbnMgb2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHly aWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxv d2luZyBkaXNjbGFpbWVyLgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11 c3QgcmVwcm9kdWNlIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0 IG9mIGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAg IGRvY3VtZW50YXRpb24gYW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBk aXN0cmlidXRpb24uCisgKgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJ TkMuIGBgQVMgSVMnJyBBTkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywg SU5DTFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVT IE9GIE1FUkNIQU5UQUJJTElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQ T1NFIEFSRSBESVNDTEFJTUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICog Q09OVFJJQlVUT1JTIEJFIExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5U QUwsIFNQRUNJQUwsCisgKiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5D TFVESU5HLCBCVVQgTk9UIExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRF IEdPT0RTIE9SIFNFUlZJQ0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9S IEJVU0lORVNTIElOVEVSUlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkK KyAqIE9GIExJQUJJTElUWSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwg T1IgVE9SVAorICogKElOQ0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJ TiBBTlkgV0FZIE9VVCBPRiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFE VklTRUQgT0YgVEhFIFBPU1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNpbmNsdWRl ICJjb25maWcuaCIKKyNpbmNsdWRlICJQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQu aCIKKworbmFtZXNwYWNlIEpTQyB7CisKK1ByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2Vu dDo6UHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50KFZNJiB2bSkKKyAgICA6IEZpbGVC YXNlZEZ1enplckFnZW50QmFzZSh2bSkKK3sKK30KKworU3BlY3VsYXRlZFR5cGUgUHJlZGljdGlv bkZpbGVDcmVhdGluZ0Z1enplckFnZW50OjpnZXRQcmVkaWN0aW9uSW50ZXJuYWwoQ29kZUJsb2Nr KiwgUHJlZGljdGlvblRhcmdldCYgcHJlZGljdGlvblRhcmdldCwgU3BlY3VsYXRlZFR5cGUgb3Jp Z2luYWwpCit7CisgICAgc3dpdGNoIChwcmVkaWN0aW9uVGFyZ2V0Lm9wY29kZUlkKSB7CisgICAg Y2FzZSBvcF90b190aGlzOgorICAgIGNhc2Ugb3BfYml0YW5kOgorICAgIGNhc2Ugb3BfYml0b3I6 CisgICAgY2FzZSBvcF9iaXR4b3I6CisgICAgY2FzZSBvcF9iaXRub3Q6CisgICAgY2FzZSBvcF9s c2hpZnQ6CisgICAgY2FzZSBvcF9yc2hpZnQ6CisgICAgY2FzZSBvcF9nZXRfYnlfdmFsOgorICAg IGNhc2Ugb3BfZ2V0X2FyZ3VtZW50OgorICAgIGNhc2Ugb3BfZ2V0X2Zyb21fYXJndW1lbnRzOgor ICAgIGNhc2Ugb3BfZ2V0X2Zyb21fc2NvcGU6CisgICAgY2FzZSBvcF90b19udW1iZXI6CisgICAg Y2FzZSBvcF9nZXRfYnlfaWQ6CisgICAgY2FzZSBvcF9nZXRfYnlfaWRfd2l0aF90aGlzOgorICAg IGNhc2Ugb3BfZ2V0X2J5X3ZhbF93aXRoX3RoaXM6CisgICAgY2FzZSBvcF9nZXRfZGlyZWN0X3Bu YW1lOgorICAgIGNhc2Ugb3BfY29uc3RydWN0OgorICAgIGNhc2Ugb3BfY29uc3RydWN0X3ZhcmFy Z3M6CisgICAgY2FzZSBvcF9jYWxsOgorICAgIGNhc2Ugb3BfY2FsbF9ldmFsOgorICAgIGNhc2Ug b3BfY2FsbF92YXJhcmdzOgorICAgIGNhc2Ugb3BfdGFpbF9jYWxsOgorICAgIGNhc2Ugb3BfdGFp bF9jYWxsX3ZhcmFyZ3M6CisgICAgICAgIGRhdGFMb2dGKCIlczolbGx4XG4iLCBwcmVkaWN0aW9u VGFyZ2V0Lmxvb2t1cEtleS51dGY4KCkuZGF0YSgpLCBvcmlnaW5hbCk7CisgICAgICAgIGJyZWFr OworCisgICAgZGVmYXVsdDoKKyAgICAgICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKGZh bHNlLCAidW5oYW5kbGVkIG9wY29kZTogJXMiLCB0b1N0cmluZyhwcmVkaWN0aW9uVGFyZ2V0Lm9w Y29kZUlkKS51dGY4KCkuZGF0YSgpKTsKKyAgICB9CisgICAgcmV0dXJuIG9yaWdpbmFsOworfQor Cit9IC8vIG5hbWVzcGFjZSBKU0MKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9y dW50aW1lL1ByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5oIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50LmgKbmV3 IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmQ0MjJlYWQwNTE1Ci0tLSAvZGV2 L251bGwKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUHJlZGljdGlvbkZpbGVD cmVhdGluZ0Z1enplckFnZW50LmgKQEAgLTAsMCArMSw0NCBAQAorLyoKKyAqIENvcHlyaWdodCAo QykgMjAxOSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0cmli dXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRob3V0 CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9sbG93 aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Ygc291 cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0 aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgorICog Mi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBhYm92 ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5kIHRo ZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5kL29y IG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgorICog VEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQgQU5Z CisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElUWSBB TkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVELiAg SU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJQUJM RSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBFWEVN UExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJTUlU RUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VTOyBM T1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQVElP TikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwgV0hF VEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xVRElO RyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBUSEUg VVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJQklM SVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisjaW5jbHVkZSAiRmls ZUJhc2VkRnV6emVyQWdlbnRCYXNlLmgiCisKK25hbWVzcGFjZSBKU0MgeworCitjbGFzcyBWTTsK KworY2xhc3MgUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50IGZpbmFsIDogcHVibGlj IEZpbGVCYXNlZEZ1enplckFnZW50QmFzZSB7CisgICAgV1RGX01BS0VfRkFTVF9BTExPQ0FURUQ7 CisKK3B1YmxpYzoKKyAgICBQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQoVk0mKTsK KworcHJvdGVjdGVkOgorICAgIFNwZWN1bGF0ZWRUeXBlIGdldFByZWRpY3Rpb25JbnRlcm5hbChD b2RlQmxvY2sqLCBQcmVkaWN0aW9uVGFyZ2V0JiwgU3BlY3VsYXRlZFR5cGUgb3JpZ2luYWwpIG92 ZXJyaWRlOworfTsKKworfSAvLyBuYW1lc3BhY2UgSlNDCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFnZW50LmNwcCBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS9ydW50aW1lL1JhbmRvbWl6aW5nRnV6emVyQWdlbnQuY3BwCmluZGV4IDNk MjI1OTUxYjI5Li5jOWM1NGU3ZTNjYyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3J1bnRpbWUvUmFuZG9taXppbmdGdXp6ZXJBZ2VudC5jcHAKKysrIGIvU291cmNlL0phdmFTY3Jp cHRDb3JlL3J1bnRpbWUvUmFuZG9taXppbmdGdXp6ZXJBZ2VudC5jcHAKQEAgLTQyLDcgKzQyLDcg QEAgU3BlY3VsYXRlZFR5cGUgUmFuZG9taXppbmdGdXp6ZXJBZ2VudDo6Z2V0UHJlZGljdGlvbihD b2RlQmxvY2sqIGNvZGVCbG9jaywgY29uc3QKICAgICB1aW50MzJfdCBoaWdoID0gbV9yYW5kb20u Z2V0VWludDMyKCk7CiAgICAgdWludDMyX3QgbG93ID0gbV9yYW5kb20uZ2V0VWludDMyKCk7CiAg ICAgU3BlY3VsYXRlZFR5cGUgZ2VuZXJhdGVkID0gc3RhdGljX2Nhc3Q8U3BlY3VsYXRlZFR5cGU+ KChzdGF0aWNfY2FzdDx1aW50NjRfdD4oaGlnaCkgPDwgMzIpIHwgbG93KSAmIFNwZWNGdWxsVG9w OwotICAgIGlmIChPcHRpb25zOjpkdW1wUmFuZG9taXppbmdGdXp6ZXJBZ2VudFByZWRpY3Rpb25z KCkpCisgICAgaWYgKE9wdGlvbnM6OmR1bXBGdXp6ZXJBZ2VudFByZWRpY3Rpb25zKCkpCiAgICAg ICAgIGRhdGFMb2dMbigiZ2V0UHJlZGljdGlvbiBuYW1lOigiLCBjb2RlQmxvY2stPmluZmVycmVk TmFtZSgpLCAiIyIsIGNvZGVCbG9jay0+aGFzaEFzU3RyaW5nSWZQb3NzaWJsZSgpLCAiKSxieXRl Y29kZUluZGV4OigiLCBjb2RlT3JpZ2luLmJ5dGVjb2RlSW5kZXgoKSwgIiksb3JpZ2luYWw6KCIs IFNwZWN1bGF0aW9uRHVtcChvcmlnaW5hbCksICIpLGdlbmVyYXRlZDooIiwgU3BlY3VsYXRpb25E dW1wKGdlbmVyYXRlZCksICIpIik7CiAgICAgcmV0dXJuIGdlbmVyYXRlZDsKIH0KZGlmZiAtLWdp dCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNLmNwcCBiL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS9ydW50aW1lL1ZNLmNwcAppbmRleCA1ZjNmODQ5ZDgyYi4uMjE2YmY5MTAyM2IgMTAw NjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNLmNwcAorKysgYi9Tb3Vy Y2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9WTS5jcHAKQEAgLTUwLDYgKzUwLDcgQEAKICNpbmNs dWRlICJFeGVjdXRhYmxlVG9Db2RlQmxvY2tFZGdlLmgiCiAjaW5jbHVkZSAiRlRMVGh1bmtzLmgi CiAjaW5jbHVkZSAiRmFzdE1hbGxvY0FsaWduZWRNZW1vcnlBbGxvY2F0b3IuaCIKKyNpbmNsdWRl ICJGaWxlQmFzZWRGdXp6ZXJBZ2VudC5oIgogI2luY2x1ZGUgIkZ1bmN0aW9uQ29kZUJsb2NrLmgi CiAjaW5jbHVkZSAiRnVuY3Rpb25Db25zdHJ1Y3Rvci5oIgogI2luY2x1ZGUgIkZ1bmN0aW9uRXhl Y3V0YWJsZS5oIgpAQCAtMTE3LDYgKzExOCw3IEBACiAjaW5jbHVkZSAiTm9kZXMuaCIKICNpbmNs dWRlICJPYmpDQ2FsbGJhY2tGdW5jdGlvbi5oIgogI2luY2x1ZGUgIlBhcnNlci5oIgorI2luY2x1 ZGUgIlByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5oIgogI2luY2x1ZGUgIlByb2Zp bGVyRGF0YWJhc2UuaCIKICNpbmNsdWRlICJQcm9ncmFtQ29kZUJsb2NrLmgiCiAjaW5jbHVkZSAi UHJvZ3JhbUV4ZWN1dGFibGUuaCIKQEAgLTQ2Myw2ICs0NjUsMTAgQEAgVk06OlZNKFZNVHlwZSB2 bVR5cGUsIEhlYXBUeXBlIGhlYXBUeXBlKQogICAgICAgICBzZXRGdXp6ZXJBZ2VudChtYWtlVW5p cXVlPFJhbmRvbWl6aW5nRnV6emVyQWdlbnQ+KCp0aGlzKSk7CiAgICAgaWYgKE9wdGlvbnM6OnVz ZURvdWJsZVByZWRpY3Rpb25GdXp6ZXJBZ2VudCgpKQogICAgICAgICBzZXRGdXp6ZXJBZ2VudCht YWtlVW5pcXVlPERvdWJsZVByZWRpY3Rpb25GdXp6ZXJBZ2VudD4oKnRoaXMpKTsKKyAgICBpZiAo T3B0aW9uczo6dXNlRmlsZUJhc2VkRnV6emVyQWdlbnQoKSkKKyAgICAgICAgc2V0RnV6emVyQWdl bnQobWFrZVVuaXF1ZTxGaWxlQmFzZWRGdXp6ZXJBZ2VudD4oKnRoaXMpKTsKKyAgICBpZiAoT3B0 aW9uczo6dXNlUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50KCkpCisgICAgICAgIHNl dEZ1enplckFnZW50KG1ha2VVbmlxdWU8UHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50 PigqdGhpcykpOwogCiAgICAgaWYgKE9wdGlvbnM6OmFsd2F5c0dlbmVyYXRlUENUb0NvZGVPcmln aW5NYXAoKSkKICAgICAgICAgc2V0U2hvdWxkQnVpbGRQQ1RvQ29kZU9yaWdpbk1hcHBpbmcoKTsK ZGlmZiAtLWdpdCBhL1NvdXJjZS9XVEYvQ2hhbmdlTG9nIGIvU291cmNlL1dURi9DaGFuZ2VMb2cK aW5kZXggN2NmNTJmZmIyZDAuLmIxYjg1ZmNhYzU2IDEwMDY0NAotLS0gYS9Tb3VyY2UvV1RGL0No YW5nZUxvZworKysgYi9Tb3VyY2UvV1RGL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE0IEBACisyMDE5 LTExLTIxICBUdW9tYXMgS2Fya2thaW5lbiAgPHR1b21hcy53ZWJraXRAYXBwbGUuY29tPgorCisg ICAgICAgIGFkZCBBU1NFUlRfTk9UX1JFQUNIRURfV0lUSF9NRVNTQUdFIGFuZCBSRUxFQVNFX0FT U0VSVF9OT1RfUkVBQ0hFRF9XSVRIX01FU1NBR0UKKyAgICAgICAgaHR0cHM6Ly9idWdzLndlYmtp dC5vcmcvc2hvd19idWcuY2dpP2lkPTIwNDQ0NQorCisgICAgICAgIFJldmlld2VkIGJ5IE5PQk9E WSAoT09QUyEpLgorCisgICAgICAgIEFkZCBhc3NlcnRpb25zIHRoYXQgY29tYmluZSBBU1NFUlRf Tk9UX1JFQUNIRUQgYW5kIEFTU0VSVF9XSVRIX01FU1NBR0UuCisKKyAgICAgICAgKiB3dGYvQXNz ZXJ0aW9ucy5oOgorCiAyMDE5LTExLTI1ICBGdWppaSBIaXJvbm9yaSAgPEhpcm9ub3JpLkZ1amlp QHNvbnkuY29tPgogCiAgICAgICAgIFtXaW5dIFVwZGF0ZSBLZXlib2FyZEV2ZW50IGFzIHBlciB0 aGUgbGF0ZXN0IHNwZWNpZmljYXRpb24K 384592 2019-12-01 21:22:39 -0800 2019-12-01 22:44:24 -0800 proposed patch webkit_203898_g.patch text/plain 42998 tuomas.webkit ZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQ2hhbmdlTG9nCmluZGV4IDNjYjg1NTg1NWI4Li4xNmI3YTFlMjQzYiAxMDA2 NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZworKysgYi9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvQ2hhbmdlTG9nCkBAIC0xLDMgKzEsMzAgQEAKKzIwMTktMTItMDEgIFR1b21h cyBLYXJra2FpbmVuICA8dHVvbWFzLndlYmtpdEBhcHBsZS5jb20+CisKKyAgICAgICAgQWRkIEZ1 enplckFnZW50IHRoYXQgcmVhZHMgcHJlZGljdGlvbnMgZnJvbSBhIGZpbGUKKyAgICAgICAgaHR0 cHM6Ly9idWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzg5OAorCisgICAgICAgIFJl dmlld2VkIGJ5IE5PQk9EWSAoT09QUyEpLgorCisgICAgICAgIFRoaXMgcGF0Y2ggYWRkcyBhIEZ1 enplckFnZW50IHRoYXQgcmVhZHMgcHJlZGljdGlvbnMgZnJvbSBhIGZpbGUuIFRoZSBwcmVkaWN0 aW9ucyBpbiB0aGUgZmlsZSBhcmUKKyAgICAgICAgY29ycmVsYXRlZCB3aXRoIHRoZSBwcmVkaWN0 aW9uIHNpdGVzIHVzaW5nIHRoZSBuYW1lIG9mIHRoZSBKYXZhU2NyaXB0IHNvdXJjZSBmaWxlLCB0 aGUgb3Bjb2RlLCBhbmQKKyAgICAgICAgc3RhcnQgYW5kIGVuZCBvZmZzZXRzIGluIHRoZSBzb3Vy Y2UuIFRoZXJlIGlzIGFsc28gYSBzZXBhcmF0ZSBGdXp6ZXJBZ2VudCB0aGF0IGNhbiBiZSB1c2Vk IHRvIGNyZWF0ZQorICAgICAgICB0aGUgcHJlZGljdGlvbiBmaWxlcy4KKworICAgICAgICAqIEph dmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogU291cmNl cy50eHQ6CisgICAgICAgICogcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudC5jcHA6IEFkZGVk LgorICAgICAgICAqIHJ1bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnQuaDogQ29waWVkIGZyb20g U291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUmFuZG9taXppbmdGdXp6ZXJBZ2VudC5jcHAu CisgICAgICAgICogcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UuY3BwOiBBZGRlZC4K KyAgICAgICAgKiBydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5oOiBDb3BpZWQgZnJv bSBTb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFnZW50LmNw cC4KKyAgICAgICAgKiBydW50aW1lL0Z1enplclByZWRpY3Rpb25zLmNwcDogQWRkZWQuCisgICAg ICAgICogcnVudGltZS9GdXp6ZXJQcmVkaWN0aW9ucy5oOiBDb3BpZWQgZnJvbSBTb3VyY2UvSmF2 YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFnZW50LmNwcC4KKyAgICAgICAg KiBydW50aW1lL09wdGlvbnMuY3BwOgorICAgICAgICAqIHJ1bnRpbWUvT3B0aW9uc0xpc3QuaDoK KyAgICAgICAgKiBydW50aW1lL1ByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5jcHA6 IENvcGllZCBmcm9tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1JhbmRvbWl6aW5nRnV6 emVyQWdlbnQuY3BwLgorICAgICAgICAqIHJ1bnRpbWUvUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1 enplckFnZW50Lmg6IENvcGllZCBmcm9tIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1Jh bmRvbWl6aW5nRnV6emVyQWdlbnQuY3BwLgorICAgICAgICAqIHJ1bnRpbWUvUmFuZG9taXppbmdG dXp6ZXJBZ2VudC5jcHA6CisgICAgICAgICogcnVudGltZS9WTS5jcHA6CisKIDIwMTktMTItMDEg IENhaW8gTGltYSAgPHRpY2Fpb2xpbWFAZ21haWwuY29tPgogCiAgICAgICAgIFtKU0NdW01JUFNd IENhbGxGcmFtZSBpcyBiZWluZyBjbG9iYmVyZWQgb24gSW50ZXJuYWxGdW5jdGlvbiBleGVjdXRp b24KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29yZS54Y29k ZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRD b3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggNWU4NzczYjA2YWQuLmQ5ZTc5YThl ZDI4IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2YVNjcmlwdENvcmUueGNv ZGVwcm9qL3Byb2plY3QucGJ4cHJvagorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2YVNj cmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvagpAQCAtMTczOSw3ICsxNzM5LDExIEBA CiAJCUM0RjRCNkY0MUEwNUM5NDQwMDVDQUI3NiAvKiBjcHBfZ2VuZXJhdG9yLnB5IGluIEhlYWRl cnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzRGNEI2RDAxQTA1Qzc2RjAw NUNBQjc2IC8qIGNwcF9nZW5lcmF0b3IucHkgKi87IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAo UHJpdmF0ZSwgKTsgfTsgfTsKIAkJQzRGNEI2RjUxQTA1Qzk4NDAwNUNBQjc2IC8qIGdlbmVyYXRl X29iamNfcHJvdG9jb2xfdHlwZXNfaW1wbGVtZW50YXRpb24ucHkgaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDNEY0QjZENzFBMDVDNzZGMDA1Q0FCNzYgLyog Z2VuZXJhdGVfb2JqY19wcm90b2NvbF90eXBlc19pbXBsZW1lbnRhdGlvbi5weSAqLzsgc2V0dGlu Z3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlDNEY0QjZGNjFBMDVDOTg0 MDA1Q0FCNzYgLyogb2JqY19nZW5lcmF0b3JfdGVtcGxhdGVzLnB5IGluIEhlYWRlcnMgKi8gPSB7 aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQzRGNEI2RDgxQTA1Qzc2RjAwNUNBQjc2IC8q IG9iamNfZ2VuZXJhdG9yX3RlbXBsYXRlcy5weSAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9 IChQcml2YXRlLCApOyB9OyB9OworCQlDRTIwQkQwNTIzN0QzRTIzMDA0NkU1MjAgLyogRmlsZUJh c2VkRnV6emVyQWdlbnRCYXNlLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBDRTIwQkQwMzIzN0QzQUQ0MDA0NkU1MjAgLyogRmlsZUJhc2VkRnV6emVyQWdl bnRCYXNlLmggKi87IH07CisJCUNFMjBCRDA3MjM3RDNFNDgwMDQ2RTUyMCAvKiBQcmVkaWN0aW9u RmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxk RmlsZTsgZmlsZVJlZiA9IENFMjBCRDAxMjM3RDNBRDQwMDQ2RTUyMCAvKiBQcmVkaWN0aW9uRmls ZUNyZWF0aW5nRnV6emVyQWdlbnQuaCAqLzsgfTsKIAkJQ0VBRTdEN0I4ODlCNDc3QkE5M0FCQTZD IC8qIFNjcmlwdEZldGNoZXIuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IDg4NTIxNTFBOUMzODQyMzg5QjMyMTVCNyAvKiBTY3JpcHRGZXRjaGVyLmggKi87 IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKKwkJQ0VDRkFEMzYy MzcyREFEMDAwMjkxNTk5IC8qIEZ1enplclByZWRpY3Rpb25zLmggaW4gSGVhZGVycyAqLyA9IHtp c2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBDRUNGQUQzNDIzNzJEQUE3MDAyOTE1OTkgLyog RnV6emVyUHJlZGljdGlvbnMuaCAqLzsgfTsKKwkJQ0VDRkFEMzcyMzcyREFENDAwMjkxNTk5IC8q IEZpbGVCYXNlZEZ1enplckFnZW50LmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZp bGU7IGZpbGVSZWYgPSBDRUNGQUQzMjIzNzJEQUE3MDAyOTE1OTkgLyogRmlsZUJhc2VkRnV6emVy QWdlbnQuaCAqLzsgfTsKIAkJRDk3MjI3NTJEQzU0NDU5QjkxMjVCNTM5IC8qIEpTTW9kdWxlTG9h ZGVyLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSA3N0Iy NUNCMkMzMDk0QTkyQTM4RTFEQjMgLyogSlNNb2R1bGVMb2FkZXIuaCAqLzsgfTsKIAkJREMwMDAz OTMxOUQ4QkU2RjAwMDIzRUIwIC8qIERGR1ByZWNpc2VMb2NhbENsb2JiZXJpemUuaCBpbiBIZWFk ZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IERDMDAwMzkwMTlEOEJFNkYw MDAyM0VCMCAvKiBERkdQcmVjaXNlTG9jYWxDbG9iYmVyaXplLmggKi87IH07CiAJCURDMDE4NDE5 MUQxMEMxODkwMDU3QjA1MyAvKiBKSVRXb3JrbGlzdC5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0g UEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gREMwMTg0MTgxRDEwQzE4NzAwNTdCMDUzIC8qIEpJVFdv cmtsaXN0LmggKi87IH07CkBAIC00ODIxLDYgKzQ4MjUsMTQgQEAKIAkJQzRGNEI2RDYxQTA1Qzc2 RjAwNUNBQjc2IC8qIGdlbmVyYXRlX2NwcF9wcm90b2NvbF90eXBlc19pbXBsZW1lbnRhdGlvbi5w eSAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25v d25GaWxlVHlwZSA9IHRleHQuc2NyaXB0LnB5dGhvbjsgcGF0aCA9IGdlbmVyYXRlX2NwcF9wcm90 b2NvbF90eXBlc19pbXBsZW1lbnRhdGlvbi5weTsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK IAkJQzRGNEI2RDcxQTA1Qzc2RjAwNUNBQjc2IC8qIGdlbmVyYXRlX29iamNfcHJvdG9jb2xfdHlw ZXNfaW1wbGVtZW50YXRpb24ucHkgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSB0ZXh0LnNjcmlwdC5weXRob247IHBhdGgg PSBnZW5lcmF0ZV9vYmpjX3Byb3RvY29sX3R5cGVzX2ltcGxlbWVudGF0aW9uLnB5OyBzb3VyY2VU cmVlID0gIjxncm91cD4iOyB9OwogCQlDNEY0QjZEODFBMDVDNzZGMDA1Q0FCNzYgLyogb2JqY19n ZW5lcmF0b3JfdGVtcGxhdGVzLnB5ICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVF bmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gdGV4dC5zY3JpcHQucHl0aG9uOyBwYXRo ID0gb2JqY19nZW5lcmF0b3JfdGVtcGxhdGVzLnB5OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9 OworCQlDRTIwQkQwMTIzN0QzQUQ0MDA0NkU1MjAgLyogUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1 enplckFnZW50LmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5 cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJB Z2VudC5oOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDRTIwQkQwMjIzN0QzQUQ0MDA0 NkU1MjAgLyogUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50LmNwcCAqLyA9IHtpc2Eg PSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNw cDsgcGF0aCA9IFByZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5jcHA7IHNvdXJjZVRy ZWUgPSAiPGdyb3VwPiI7IH07CisJCUNFMjBCRDAzMjM3RDNBRDQwMDQ2RTUyMCAvKiBGaWxlQmFz ZWRGdXp6ZXJBZ2VudEJhc2UuaCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBsYXN0S25v d25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuYy5oOyBwYXRoID0gRmlsZUJhc2VkRnV6emVyQWdlbnRC YXNlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUNFMjBCRDA0MjM3RDNBRDQwMDQ2 RTUyMCAvKiBGaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UuY3BwICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0g RmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsK KwkJQ0VDRkFEMzIyMzcyREFBNzAwMjkxNTk5IC8qIEZpbGVCYXNlZEZ1enplckFnZW50LmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2Rl LmMuaDsgcGF0aCA9IEZpbGVCYXNlZEZ1enplckFnZW50Lmg7IHNvdXJjZVRyZWUgPSAiPGdyb3Vw PiI7IH07CisJCUNFQ0ZBRDMzMjM3MkRBQTcwMDI5MTU5OSAvKiBGaWxlQmFzZWRGdXp6ZXJBZ2Vu dC5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmNwcC5jcHA7IHBhdGggPSBGaWxlQmFzZWRGdXp6ZXJBZ2VudC5jcHA7IHNvdXJj ZVRyZWUgPSAiPGdyb3VwPiI7IH07CisJCUNFQ0ZBRDM0MjM3MkRBQTcwMDI5MTU5OSAvKiBGdXp6 ZXJQcmVkaWN0aW9ucy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZp bGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBGdXp6ZXJQcmVkaWN0aW9ucy5oOyBzb3Vy Y2VUcmVlID0gIjxncm91cD4iOyB9OworCQlDRUNGQUQzNTIzNzJEQUE3MDAyOTE1OTkgLyogRnV6 emVyUHJlZGljdGlvbnMuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93 bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gRnV6emVyUHJlZGljdGlvbnMu Y3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlEMjEyMDIyODBBRDQzMTBDMDBFRDc5 QjYgLyogRGF0ZUNvbnZlcnNpb24uY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZp bGVFbmNvZGluZyA9IDMwOyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsg cGF0aCA9IERhdGVDb252ZXJzaW9uLmNwcDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ RDIxMjAyMjkwQUQ0MzEwQzAwRUQ3OUI2IC8qIERhdGVDb252ZXJzaW9uLmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gMzA7IGxhc3RLbm93bkZpbGVUeXBlID0g c291cmNlY29kZS5jLmg7IHBhdGggPSBEYXRlQ29udmVyc2lvbi5oOyBzb3VyY2VUcmVlID0gIjxn cm91cD4iOyB9OwogCQlEQzAwMDM5MDE5RDhCRTZGMDAwMjNFQjAgLyogREZHUHJlY2lzZUxvY2Fs Q2xvYmJlcml6ZS5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9 IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IG5hbWUgPSBERkdQcmVjaXNl TG9jYWxDbG9iYmVyaXplLmg7IHBhdGggPSBkZmcvREZHUHJlY2lzZUxvY2FsQ2xvYmJlcml6ZS5o OyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwpAQCAtNzA4Myw2ICs3MDk1LDEwIEBACiAJCQkJ MTQ3MzQxRTkxREMyQ0YyNTAwQUEyOUJBIC8qIEV4ZWN1dGFibGVCYXNlLmNwcCAqLywKIAkJCQkx NDczNDFDQjFEQzAyRDcyMDBBQTI5QkEgLyogRXhlY3V0YWJsZUJhc2UuaCAqLywKIAkJCQlFMzVB MEI5QzIyMEFEODdBMDBBQzQ0NzQgLyogRXhlY3V0YWJsZUJhc2VJbmxpbmVzLmggKi8sCisJCQkJ Q0VDRkFEMzMyMzcyREFBNzAwMjkxNTk5IC8qIEZpbGVCYXNlZEZ1enplckFnZW50LmNwcCAqLywK KwkJCQlDRUNGQUQzMjIzNzJEQUE3MDAyOTE1OTkgLyogRmlsZUJhc2VkRnV6emVyQWdlbnQuaCAq LywKKwkJCQlDRTIwQkQwNDIzN0QzQUQ0MDA0NkU1MjAgLyogRmlsZUJhc2VkRnV6emVyQWdlbnRC YXNlLmNwcCAqLywKKwkJCQlDRTIwQkQwMzIzN0QzQUQ0MDA0NkU1MjAgLyogRmlsZUJhc2VkRnV6 emVyQWdlbnRCYXNlLmggKi8sCiAJCQkJQTdBOEFGMjkxN0FEQjVGMzAwNUFCMTc0IC8qIEZsb2F0 MzJBcnJheS5oICovLAogCQkJCUE3QThBRjJBMTdBREI1RjMwMDVBQjE3NCAvKiBGbG9hdDY0QXJy YXkuaCAqLywKIAkJCQlCQzI2ODBDMDBFMTZENEU5MDBBMDZFOTIgLyogRnVuY3Rpb25Db25zdHJ1 Y3Rvci5jcHAgKi8sCkBAIC03MTAwLDYgKzcxMTYsOCBAQAogCQkJCTYyRDJEMzhFMUFERjEwM0Yw MDAyMDZDMSAvKiBGdW5jdGlvblJhcmVEYXRhLmggKi8sCiAJCQkJRTMzQTk0OTUyMjU1MzIyQTAw RDQyQjA2IC8qIEZ1enplckFnZW50LmNwcCAqLywKIAkJCQlFMzNBOTQ5MjIyNTUzMjI5MDBENDJC MDYgLyogRnV6emVyQWdlbnQuaCAqLywKKwkJCQlDRUNGQUQzNTIzNzJEQUE3MDAyOTE1OTkgLyog RnV6emVyUHJlZGljdGlvbnMuY3BwICovLAorCQkJCUNFQ0ZBRDM0MjM3MkRBQTcwMDI5MTU5OSAv KiBGdXp6ZXJQcmVkaWN0aW9ucy5oICovLAogCQkJCTcwQjc5MTg1MUMwMjQ0MzIwMDI0ODFFMiAv KiBHZW5lcmF0b3JGdW5jdGlvbkNvbnN0cnVjdG9yLmNwcCAqLywKIAkJCQk3MEI3OTE4NjFDMDI0 NDMyMDAyNDgxRTIgLyogR2VuZXJhdG9yRnVuY3Rpb25Db25zdHJ1Y3Rvci5oICovLAogCQkJCTcw Qjc5MTg3MUMwMjQ0MzIwMDI0ODFFMiAvKiBHZW5lcmF0b3JGdW5jdGlvblByb3RvdHlwZS5jcHAg Ki8sCkBAIC03NDIwLDYgKzc0MzgsOCBAQAogCQkJCTBGRTIyOEVCMTQzNkFCMjMwMDE5NkM0OCAv KiBPcHRpb25zLmggKi8sCiAJCQkJRkUzODQyMzEyMzI0RDUxQjAwOURENDQ1IC8qIE9wdGlvbnNM aXN0LmggKi8sCiAJCQkJMzdDNzM4RDExRURCNTY3MjAwM0YyQjBCIC8qIFBhcnNlSW50LmggKi8s CisJCQkJQ0UyMEJEMDIyMzdEM0FENDAwNDZFNTIwIC8qIFByZWRpY3Rpb25GaWxlQ3JlYXRpbmdG dXp6ZXJBZ2VudC5jcHAgKi8sCisJCQkJQ0UyMEJEMDEyMzdEM0FENDAwNDZFNTIwIC8qIFByZWRp Y3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5oICovLAogCQkJCTg2ODkxNkE5MTU1RjI4NTQw MENCMkI5QSAvKiBQcml2YXRlTmFtZS5oICovLAogCQkJCTE0NzM0MURGMURDMkNFOTYwMEFBMjlC QSAvKiBQcm9ncmFtRXhlY3V0YWJsZS5jcHAgKi8sCiAJCQkJMTQ3MzQxRDMxREMwMkU2RDAwQUEy OUJBIC8qIFByb2dyYW1FeGVjdXRhYmxlLmggKi8sCkBAIC05NTg2LDYgKzk2MDYsNyBAQAogCQkJ CUExODE5M0U0MUI0RTBDREIwMEZDMTAyOSAvKiBJbnRsQ29sbGF0b3JQcm90b3R5cGUubHV0Lmgg aW4gSGVhZGVycyAqLywKIAkJCQlBMTU4N0Q2RTFCNERDMTQxMDBENjk4NDkgLyogSW50bERhdGVU aW1lRm9ybWF0LmggaW4gSGVhZGVycyAqLywKIAkJCQlBMTU4N0Q3MDFCNERDMTQxMDBENjk4NDkg LyogSW50bERhdGVUaW1lRm9ybWF0Q29uc3RydWN0b3IuaCBpbiBIZWFkZXJzICovLAorCQkJCUNF MjBCRDA1MjM3RDNFMjMwMDQ2RTUyMCAvKiBGaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UuaCBpbiBI ZWFkZXJzICovLAogCQkJCUExNTg3RDc1MUI0REMxQzYwMEQ2OTg0OSAvKiBJbnRsRGF0ZVRpbWVG b3JtYXRDb25zdHJ1Y3Rvci5sdXQuaCBpbiBIZWFkZXJzICovLAogCQkJCUExNTg3RDcyMUI0REMx NDEwMEQ2OTg0OSAvKiBJbnRsRGF0ZVRpbWVGb3JtYXRQcm90b3R5cGUuaCBpbiBIZWFkZXJzICov LAogCQkJCUExNTg3RDc2MUI0REMxQzYwMEQ2OTg0OSAvKiBJbnRsRGF0ZVRpbWVGb3JtYXRQcm90 b3R5cGUubHV0LmggaW4gSGVhZGVycyAqLywKQEAgLTk4ODIsNiArOTkwMyw3IEBACiAJCQkJMEY3 QzVGQjgxRDg4OEEwQzAwNDRGNUUyIC8qIE1hcmtlZEJsb2NrSW5saW5lcy5oIGluIEhlYWRlcnMg Ki8sCiAJCQkJMTQxNDQ4Q0IxM0ExNzZFQzAwRjVCQTFBIC8qIE1hcmtlZEJsb2NrU2V0LmggaW4g SGVhZGVycyAqLywKIAkJCQkxNEQyRjNEQjEzOUY0QkUyMDA0OTEwMzEgLyogTWFya2VkU3BhY2Uu aCBpbiBIZWFkZXJzICovLAorCQkJCUNFMjBCRDA3MjM3RDNFNDgwMDQ2RTUyMCAvKiBQcmVkaWN0 aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuaCBpbiBIZWFkZXJzICovLAogCQkJCTBGN0RGMTM1 MUUyOTcwREMwMDk1OTUxQiAvKiBNYXJrZWRTcGFjZUlubGluZXMuaCBpbiBIZWFkZXJzICovLAog CQkJCTBGNjYwRTM4MUUwNTE3QkIwMDMxNDYyQyAvKiBNYXJraW5nQ29uc3RyYWludC5oIGluIEhl YWRlcnMgKi8sCiAJCQkJMEY2NjBFM0ExRTA1MTdDMTAwMzE0NjJDIC8qIE1hcmtpbmdDb25zdHJh aW50U2V0LmggaW4gSGVhZGVycyAqLywKQEAgLTk5OTgsNiArMTAwMjAsNyBAQAogCQkJCTUzNEUw MzU2MUU1M0JFREUwMDIxM0Y2NCAvKiBQcm94eWFibGVBY2Nlc3NDYXNlLmggaW4gSGVhZGVycyAq LywKIAkJCQk3OUIwMENCRDFDNkFCMDdFMDA4OEM2NUQgLyogUHJveHlDb25zdHJ1Y3Rvci5oIGlu IEhlYWRlcnMgKi8sCiAJCQkJNzlCMDBDQkYxQzZBQjA3RTAwODhDNjVEIC8qIFByb3h5T2JqZWN0 LmggaW4gSGVhZGVycyAqLywKKwkJCQlDRUNGQUQzNzIzNzJEQUQ0MDAyOTE1OTkgLyogRmlsZUJh c2VkRnV6emVyQWdlbnQuaCBpbiBIZWFkZXJzICovLAogCQkJCTc5MTYwREJFMUM4RTNFQzgwMDhD MDg1QSAvKiBQcm94eVJldm9rZS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJMEY1NzgwQTIxOEZFMUU5 ODAwMUU3MkQ5IC8qIFB1cmVOYU4uaCBpbiBIZWFkZXJzICovLAogCQkJCTBGMTVDRDIzMUJBNUY5 ODYwMDMxRkZEMyAvKiBQdXRCeUlkRmxhZ3MuaCBpbiBIZWFkZXJzICovLApAQCAtMTAwNzYsNiAr MTAwOTksNyBAQAogCQkJCUZFMzAyMkQzMUUzRDczQTUwMEJBQzQ5MyAvKiBTaWdpbGxDcmFzaEFu YWx5emVyLmggaW4gSGVhZGVycyAqLywKIAkJCQkwRjREOEM3ODFGQ0EzQ0ZBMDAxRDMyQUMgLyog U2ltcGxlTWFya2luZ0NvbnN0cmFpbnQuaCBpbiBIZWFkZXJzICovLAogCQkJCTBGMkI2NzA1MTdC NkI1QUIwMEE3QUUzRiAvKiBTaW1wbGVUeXBlZEFycmF5Q29udHJvbGxlci5oIGluIEhlYWRlcnMg Ki8sCisJCQkJQ0VDRkFEMzYyMzcyREFEMDAwMjkxNTk5IC8qIEZ1enplclByZWRpY3Rpb25zLmgg aW4gSGVhZGVycyAqLywKIAkJCQkxNEJBNzhGMTEzQUFCODhGMDA1QjdDMkMgLyogU2xvdFZpc2l0 b3IuaCBpbiBIZWFkZXJzICovLAogCQkJCUMyMTYwRkU3MTVGN0U5NUUwMDk0MkRGQyAvKiBTbG90 VmlzaXRvcklubGluZXMuaCBpbiBIZWFkZXJzICovLAogCQkJCUE3MDlGMkYwMTdBMEFDMDQwMDUx MkU5OCAvKiBTbG93UGF0aENhbGwuaCBpbiBIZWFkZXJzICovLApkaWZmIC0tZ2l0IGEvU291cmNl L0phdmFTY3JpcHRDb3JlL1NvdXJjZXMudHh0IGIvU291cmNlL0phdmFTY3JpcHRDb3JlL1NvdXJj ZXMudHh0CmluZGV4IGVjMDM3MjdhYjMzLi44ZDcwNmM5NTIxYyAxMDA2NDQKLS0tIGEvU291cmNl L0phdmFTY3JpcHRDb3JlL1NvdXJjZXMudHh0CisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9T b3VyY2VzLnR4dApAQCAtNzY2LDYgKzc2Niw4IEBAIHJ1bnRpbWUvRXhjZXB0aW9uRnV6ei5jcHAK IHJ1bnRpbWUvRXhjZXB0aW9uSGVscGVycy5jcHAKIHJ1bnRpbWUvRXhjZXB0aW9uU2NvcGUuY3Bw CiBydW50aW1lL0V4ZWN1dGFibGVCYXNlLmNwcAorcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2Vu dC5jcHAKK3J1bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmNwcAogcnVudGltZS9GdW5j dGlvbkNvbnN0cnVjdG9yLmNwcAogcnVudGltZS9GdW5jdGlvbkV4ZWN1dGFibGUuY3BwCiBydW50 aW1lL0Z1bmN0aW9uRXhlY3V0YWJsZUR1bXAuY3BwCkBAIC03NzMsNiArNzc1LDcgQEAgcnVudGlt ZS9GdW5jdGlvbkhhc0V4ZWN1dGVkQ2FjaGUuY3BwCiBydW50aW1lL0Z1bmN0aW9uUHJvdG90eXBl LmNwcAogcnVudGltZS9GdW5jdGlvblJhcmVEYXRhLmNwcAogcnVudGltZS9GdXp6ZXJBZ2VudC5j cHAKK3J1bnRpbWUvRnV6emVyUHJlZGljdGlvbnMuY3BwCiBydW50aW1lL0dlbmVyYXRvckZ1bmN0 aW9uQ29uc3RydWN0b3IuY3BwCiBydW50aW1lL0dlbmVyYXRvckZ1bmN0aW9uUHJvdG90eXBlLmNw cAogcnVudGltZS9HZW5lcmF0b3JQcm90b3R5cGUuY3BwCkBAIC05MDMsNiArOTA2LDcgQEAgcnVu dGltZS9PYmplY3RQcm90b3R5cGUuY3BwCiBydW50aW1lL09iamVjdFRvU3RyaW5nQWRhcHRpdmVT dHJ1Y3R1cmVXYXRjaHBvaW50LmNwcAogcnVudGltZS9PcGVyYXRpb25zLmNwcAogcnVudGltZS9P cHRpb25zLmNwcAorcnVudGltZS9QcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuY3Bw CiBydW50aW1lL1Byb2dyYW1FeGVjdXRhYmxlLmNwcAogcnVudGltZS9Qcm9taXNlVGltZXIuY3Bw CiBydW50aW1lL1Byb3BlcnR5RGVzY3JpcHRvci5jcHAKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50LmNwcCBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50LmNwcApuZXcgZmlsZSBtb2Rl IDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4uYTdjZDRjMWMyNDcKLS0tIC9kZXYvbnVsbAorKysg Yi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudC5jcHAK QEAgLTAsMCArMSwxMTcgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTkgQXBwbGUgSW5jLiBB bGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1c2UgaW4gc291 cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZpY2F0aW9uLCBh cmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRpb25zCisgKiBh cmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11c3QgcmV0YWlu IHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlv bnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJpYnV0aW9ucyBp biBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRlcmlhbHMgcHJv dmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdBUkUgSVMgUFJP VklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVTUyBPUiBJTVBM SUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBUSEUKKyAqIElN UExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1MgRk9SIEEgUEFS VElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5UIFNIQUxMIEFQ UExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBESVJFQ1QsIElO RElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBDT05TRVFVRU5U SUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICogUFJPQ1VSRU1F TlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0UsIERBVEEsIE9S CisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIgQ0FVU0VEIEFO RCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09OVFJBQ1QsIFNU UklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5DRSBPUiBPVEhF UldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0YgVEhJUyBTT0ZU V0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNIIERBTUFHRS4K KyAqLworCisjaW5jbHVkZSAiY29uZmlnLmgiCisjaW5jbHVkZSAiRmlsZUJhc2VkRnV6emVyQWdl bnQuaCIKKworI2luY2x1ZGUgIkNvZGVCbG9jay5oIgorI2luY2x1ZGUgIkZ1enplclByZWRpY3Rp b25zLmgiCisjaW5jbHVkZSA8d3RmL0Fuc2lDb2xvcnMuaD4KKworbmFtZXNwYWNlIEpTQyB7CisK K0ZpbGVCYXNlZEZ1enplckFnZW50OjpGaWxlQmFzZWRGdXp6ZXJBZ2VudChWTSYgdm0pCisgICAg OiBGaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2Uodm0pCit7Cit9CisKK1NwZWN1bGF0ZWRUeXBlIEZp bGVCYXNlZEZ1enplckFnZW50OjpnZXRQcmVkaWN0aW9uSW50ZXJuYWwoQ29kZUJsb2NrKiBjb2Rl QmxvY2ssIFByZWRpY3Rpb25UYXJnZXQmIHRhcmdldCwgU3BlY3VsYXRlZFR5cGUgb3JpZ2luYWwp Cit7CisgICAgRnV6emVyUHJlZGljdGlvbnMmIGZ1enplclByZWRpY3Rpb25zID0gZW5zdXJlR2xv YmFsRnV6emVyUHJlZGljdGlvbnMoKTsKKyAgICBPcHRpb25hbDxTcGVjdWxhdGVkVHlwZT4gZ2Vu ZXJhdGVkID0gZnV6emVyUHJlZGljdGlvbnMucHJlZGljdGlvbkZvcih0YXJnZXQubG9va3VwS2V5 KTsKKworICAgIFNvdXJjZVByb3ZpZGVyKiBwcm92aWRlciA9IGNvZGVCbG9jay0+c291cmNlKCku cHJvdmlkZXIoKTsKKyAgICBhdXRvIHNvdXJjZVVwVG9EaXZvdCA9IHByb3ZpZGVyLT5zb3VyY2Uo KS5zdWJzdHJpbmcodGFyZ2V0LmRpdm90IC0gdGFyZ2V0LnN0YXJ0T2Zmc2V0LCB0YXJnZXQuc3Rh cnRPZmZzZXQpOworICAgIGF1dG8gc291cmNlQWZ0ZXJEaXZvdCA9IHByb3ZpZGVyLT5zb3VyY2Uo KS5zdWJzdHJpbmcodGFyZ2V0LmRpdm90LCB0YXJnZXQuZW5kT2Zmc2V0KTsKKworICAgIHN3aXRj aCAodGFyZ2V0Lm9wY29kZUlkKSB7CisgICAgLy8gRklYTUU6IHRoZXNlIGNhbiBub3QgYmUgdGFy Z2V0ZWQgYXQgYWxsIGR1ZSB0byB0aGUgYnVncyBiZWxvdworICAgIGNhc2Ugb3BfdG9fdGhpczog Ly8gYnJva2VuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTUK KyAgICBjYXNlIG9wX2dldF9hcmd1bWVudDogLy8gYnJva2VuIGh0dHBzOi8vYnVncy53ZWJraXQu b3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM1NTQKKyAgICAgICAgcmV0dXJuIG9yaWdpbmFsOworCisg ICAgLy8gRklYTUU6IHRoZSBvdXRwdXQgb2YgY29kZUJsb2NrLT5leHByZXNzaW9uUmFuZ2VGb3JC eXRlY29kZUluZGV4KCkgYWxsb3dzIGZvciBzb21lIG9mCisgICAgLy8gdGhlc2Ugb3Bjb2RlcyB0 byBoYXZlIHByZWRpY3Rpb25zLCBidXQgbm90IGFsbCBpbnN0YW5jZXMgY2FuIGJlIHJlbGlhYmx5 IHRhcmdldGVkLgorICAgIGNhc2Ugb3BfYml0YW5kOiAvLyBwYXJ0aWFsbHkgYnJva2VuIGh0dHBz Oi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM2MDQKKyAgICBjYXNlIG9wX2Jp dG9yOiAvLyBwYXJ0aWFsbHkgYnJva2VuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVn LmNnaT9pZD0yMDM2MDQKKyAgICBjYXNlIG9wX2JpdHhvcjogLy8gcGFydGlhbGx5IGJyb2tlbiBo dHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAzNjA0CisgICAgY2FzZSBv cF9iaXRub3Q6IC8vIHBhcnRpYWxseSBicm9rZW4KKyAgICBjYXNlIG9wX2dldF9mcm9tX3Njb3Bl OiAvLyBwYXJ0aWFsbHkgYnJva2VuIGh0dHBzOi8vYnVncy53ZWJraXQub3JnL3Nob3dfYnVnLmNn aT9pZD0yMDM2MDMKKyAgICBjYXNlIG9wX2dldF9mcm9tX2FyZ3VtZW50czogLy8gcGFydGlhbGx5 IGJyb2tlbiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9MjAzNjA4Cisg ICAgY2FzZSBvcF9nZXRfYnlfdmFsOiAvLyBwYXJ0aWFsbHkgYnJva2VuIGh0dHBzOi8vYnVncy53 ZWJraXQub3JnL3Nob3dfYnVnLmNnaT9pZD0yMDM2NjUKKyAgICBjYXNlIG9wX3JzaGlmdDogLy8g cGFydGlhbGx5IGJyb2tlbiBodHRwczovL2J1Z3Mud2Via2l0Lm9yZy9zaG93X2J1Zy5jZ2k/aWQ9 MjAzNjY0CisgICAgY2FzZSBvcF9sc2hpZnQ6IC8vIHBhcnRpYWxseSBicm9rZW4gaHR0cHM6Ly9i dWdzLndlYmtpdC5vcmcvc2hvd19idWcuY2dpP2lkPTIwMzY2NAorICAgIGNhc2Ugb3BfdG9fbnVt YmVyOiAvLyBwYXJ0aWFsbHkgYnJva2VuCisgICAgY2FzZSBvcF9nZXRfYnlfaWQ6IC8vIHNvbWV0 aW1lcyBvY2N1cnMgaW1wbGljaXRseSBmb3IgdGhpbmdzIHJlbGF0ZWQgdG8gU3ltYm9sLml0ZXJh dG9yCisgICAgICAgIGlmICghZ2VuZXJhdGVkKQorICAgICAgICAgICAgcmV0dXJuIG9yaWdpbmFs OworICAgICAgICBicmVhazsKKworICAgIGNhc2Ugb3BfY2FsbDogLy8gb3BfY2FsbCBhcHBlYXJz IGltcGxpY2l0bHkgaW4gZm9yLW9mIGxvb3BzLCBnZW5lcmF0b3JzLCBzcHJlYWQvcmVzdCBlbGVt ZW50cywgZGVzdHJ1Y3R1cmluZyBhc3NpZ25tZW50CisgICAgICAgIGlmICghZ2VuZXJhdGVkKSB7 CisgICAgICAgICAgICBpZiAoc291cmNlQWZ0ZXJEaXZvdC5jb250YWluc0lnbm9yaW5nQVNDSUlD YXNlKCJvZiAiKSkKKyAgICAgICAgICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAgICAgICAg ICBpZiAoc291cmNlQWZ0ZXJEaXZvdC5jb250YWluc0lnbm9yaW5nQVNDSUlDYXNlKCIuLi4iKSkK KyAgICAgICAgICAgICAgICByZXR1cm4gb3JpZ2luYWw7CisgICAgICAgICAgICBpZiAoc291cmNl QWZ0ZXJEaXZvdC5jb250YWluc0lnbm9yaW5nQVNDSUlDYXNlKCJ5aWVsZCIpKQorICAgICAgICAg ICAgICAgIHJldHVybiBvcmlnaW5hbDsKKyAgICAgICAgICAgIGlmIChzb3VyY2VBZnRlckRpdm90 LnN0YXJ0c1dpdGgoJ1snKSAmJiBzb3VyY2VBZnRlckRpdm90LmVuZHNXaXRoKCJdIikpCisgICAg ICAgICAgICAgICAgcmV0dXJuIG9yaWdpbmFsOworICAgICAgICAgICAgaWYgKHNvdXJjZVVwVG9E aXZvdC5jb250YWluc0lnbm9yaW5nQVNDSUlDYXNlKCJ5aWVsZCIpKQorICAgICAgICAgICAgICAg IHJldHVybiBvcmlnaW5hbDsKKyAgICAgICAgICAgIGlmIChzb3VyY2VVcFRvRGl2b3QgPT0gIi4u LiIpCisgICAgICAgICAgICAgICAgcmV0dXJuIG9yaWdpbmFsOworICAgICAgICAgICAgaWYgKCF0 YXJnZXQuc3RhcnRPZmZzZXQgJiYgIXRhcmdldC5lbmRPZmZzZXQpCisgICAgICAgICAgICAgICAg cmV0dXJuIG9yaWdpbmFsOworICAgICAgICB9CisgICAgICAgIGJyZWFrOworCisgICAgY2FzZSBv cF9nZXRfYnlfdmFsX3dpdGhfdGhpczoKKyAgICBjYXNlIG9wX2dldF9kaXJlY3RfcG5hbWU6Cisg ICAgY2FzZSBvcF9jb25zdHJ1Y3Q6CisgICAgY2FzZSBvcF9jb25zdHJ1Y3RfdmFyYXJnczoKKyAg ICBjYXNlIG9wX2NhbGxfdmFyYXJnczoKKyAgICBjYXNlIG9wX2NhbGxfZXZhbDoKKyAgICBjYXNl IG9wX3RhaWxfY2FsbDoKKyAgICBjYXNlIG9wX3RhaWxfY2FsbF92YXJhcmdzOgorICAgIGNhc2Ug b3BfZ2V0X2J5X2lkX3dpdGhfdGhpczoKKyAgICAgICAgYnJlYWs7CisKKyAgICBkZWZhdWx0Ogor ICAgICAgICBSRUxFQVNFX0FTU0VSVF9OT1RfUkVBQ0hFRF9XSVRIX01FU1NBR0UoIlVuaGFuZGxl ZCBvcGNvZGUgJXMiLCB0b1N0cmluZyh0YXJnZXQub3Bjb2RlSWQpLnV0ZjgoKS5kYXRhKCkpOwor ICAgIH0KKyAgICBpZiAoIWdlbmVyYXRlZCkgeworICAgICAgICBpZiAoT3B0aW9uczo6ZHVtcEZ1 enplckFnZW50UHJlZGljdGlvbnMoKSkKKyAgICAgICAgICAgIGRhdGFMb2dMbihNQUdFTlRBKEJP TEQodGFyZ2V0LmJ5dGVjb2RlSW5kZXgpKSwgIiAiLCBCT0xEKFlFTExPVyh0YXJnZXQub3Bjb2Rl SWQpKSwgIiBtaXNzaW5nIHByZWRpY3Rpb24gZm9yOiAiLCBSRUQoQk9MRCh0YXJnZXQubG9va3Vw S2V5KSksICIgIiwgR1JFRU4odGFyZ2V0LnNvdXJjZUZpbGVuYW1lKSwgIjoiLCBDWUFOKHRhcmdl dC5saW5lKSwgIjoiLCBDWUFOKHRhcmdldC5jb2x1bW4pLCAiIGRpdm90OiAiLCB0YXJnZXQuZGl2 b3QsICIgLSIsIHRhcmdldC5zdGFydE9mZnNldCwgIiArIiwgdGFyZ2V0LmVuZE9mZnNldCwgIiBu YW1lOiAnIiwgWUVMTE9XKGNvZGVCbG9jay0+aW5mZXJyZWROYW1lKCkpLCAiJyBzb3VyY2U6ICci LCBCTFVFKHNvdXJjZVVwVG9EaXZvdCksIEJMVUUoQk9MRChzb3VyY2VBZnRlckRpdm90KSksICIn Iik7CisKKyAgICAgICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKCFPcHRpb25zOjpyZXF1 aXJlUHJlZGljdGlvbkZvckZpbGVCYXNlZEZ1enplckFnZW50KCksICJNaXNzaW5nIGV4cGVjdGVk IHByZWRpY3Rpb24gaW4gRnV6emVyQWdlbnQiKTsKKyAgICAgICAgcmV0dXJuIG9yaWdpbmFsOwor ICAgIH0KKyAgICBpZiAoT3B0aW9uczo6ZHVtcEZ1enplckFnZW50UHJlZGljdGlvbnMoKSkKKyAg ICAgICAgZGF0YUxvZ0xuKFlFTExPVyh0YXJnZXQub3Bjb2RlSWQpLCAiICIsIENZQU4odGFyZ2V0 Lmxvb2t1cEtleSksICIgb3JpZ2luYWw6ICIsIENZQU4oQk9MRChTcGVjdWxhdGlvbkR1bXAob3Jp Z2luYWwpKSksICIgZ2VuZXJhdGVkOiAiLCBNQUdFTlRBKEJPTEQoU3BlY3VsYXRpb25EdW1wKCpn ZW5lcmF0ZWQpKSkpOworICAgIHJldHVybiAqZ2VuZXJhdGVkOworfQorCit9IC8vIG5hbWVzcGFj ZSBKU0MKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNl ZEZ1enplckFnZW50LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GaWxlQmFzZWRG dXp6ZXJBZ2VudC5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi5jOTI5 MTFmZDQzOQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L0ZpbGVCYXNlZEZ1enplckFnZW50LmgKQEAgLTAsMCArMSw0NCBAQAorLyoKKyAqIENvcHlyaWdo dCAoQykgMjAxOSBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVkaXN0 cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3aXRo b3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUgZm9s bG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMgb2Yg c291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNl LCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyLgor ICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRoZSBh Ym92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMgYW5k IHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24gYW5k L29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisgKgor ICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBBTkQg QU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJTElU WSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJTUVE LiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJFIExJ QUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisgKiBF WEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9UIExJ TUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJQ0VT OyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVSUlVQ VElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElUWSwg V0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElOQ0xV RElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBPRiBU SEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBPU1NJ QklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisjaW5jbHVkZSAi RmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmgiCisKK25hbWVzcGFjZSBKU0MgeworCitjbGFzcyBW TTsKKworY2xhc3MgRmlsZUJhc2VkRnV6emVyQWdlbnQgZmluYWwgOiBwdWJsaWMgRmlsZUJhc2Vk RnV6emVyQWdlbnRCYXNlIHsKKyAgICBXVEZfTUFLRV9GQVNUX0FMTE9DQVRFRDsKKworcHVibGlj OgorICAgIEZpbGVCYXNlZEZ1enplckFnZW50KFZNJik7CisKK3Byb3RlY3RlZDoKKyAgICBTcGVj dWxhdGVkVHlwZSBnZXRQcmVkaWN0aW9uSW50ZXJuYWwoQ29kZUJsb2NrKiwgUHJlZGljdGlvblRh cmdldCYsIFNwZWN1bGF0ZWRUeXBlIG9yaWdpbmFsKSBvdmVycmlkZTsKK307CisKK30gLy8gbmFt ZXNwYWNlIEpTQwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvRmls ZUJhc2VkRnV6emVyQWdlbnRCYXNlLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1l L0ZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXgg MDAwMDAwMDAwMDAuLjQ3MTgwOTdkNGU1Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL0phdmFT Y3JpcHRDb3JlL3J1bnRpbWUvRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlLmNwcApAQCAtMCwwICsx LDg4IEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyBy ZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmlu YXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRl ZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAq IDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUg Y29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUg Zm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZv cm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlz IGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQor ICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGgg dGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQ UExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5U SUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJB TlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAq IFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9S CisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5D SURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VT IChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNU SVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklU UzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRI RU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklM SVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklT SU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4g SUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2lu Y2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIkZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5oIgor CisjaW5jbHVkZSAiQ29kZUJsb2NrLmgiCisjaW5jbHVkZSA8d3RmL3RleHQvU3RyaW5nQnVpbGRl ci5oPgorCituYW1lc3BhY2UgSlNDIHsKKworRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlOjpGaWxl QmFzZWRGdXp6ZXJBZ2VudEJhc2UoVk0mKQoreworfQorCitTdHJpbmcgRmlsZUJhc2VkRnV6emVy QWdlbnRCYXNlOjpjcmVhdGVMb29rdXBLZXkoY29uc3QgU3RyaW5nJiBzb3VyY2VGaWxlbmFtZSwg T3Bjb2RlSUQgb3Bjb2RlSWQsIGludCBzdGFydExvY2F0aW9uLCBpbnQgZW5kTG9jYXRpb24pCit7 CisgICAgU3RyaW5nQnVpbGRlciBsb29rdXBLZXk7CisgICAgbG9va3VwS2V5LmFwcGVuZChzb3Vy Y2VGaWxlbmFtZSk7CisgICAgbG9va3VwS2V5LmFwcGVuZCgifCIpOworICAgIGxvb2t1cEtleS5h cHBlbmQodG9TdHJpbmcob3Bjb2RlQWxpYXNGb3JMb29rdXBLZXkob3Bjb2RlSWQpKSk7CisgICAg bG9va3VwS2V5LmFwcGVuZCgifCIpOworICAgIGxvb2t1cEtleS5hcHBlbmQoc3RhcnRMb2NhdGlv bik7CisgICAgbG9va3VwS2V5LmFwcGVuZCgifCIpOworICAgIGxvb2t1cEtleS5hcHBlbmQoZW5k TG9jYXRpb24pOworICAgIHJldHVybiBsb29rdXBLZXkudG9TdHJpbmcoKTsKK30KKworT3Bjb2Rl SUQgRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlOjpvcGNvZGVBbGlhc0Zvckxvb2t1cEtleShjb25z dCBPcGNvZGVJRCYgb3Bjb2RlSWQpCit7CisgICAgaWYgKG9wY29kZUlkID09IG9wX2NhbGxfdmFy YXJncyB8fCBvcGNvZGVJZCA9PSBvcF9jYWxsX2V2YWwgfHwgb3Bjb2RlSWQgPT0gb3BfdGFpbF9j YWxsIHx8IG9wY29kZUlkID09IG9wX3RhaWxfY2FsbF92YXJhcmdzKQorICAgICAgICByZXR1cm4g b3BfY2FsbDsKKyAgICBpZiAob3Bjb2RlSWQgPT0gb3BfZ2V0X2RpcmVjdF9wbmFtZSB8fCBvcGNv ZGVJZCA9PSBvcF9nZXRfYnlfdmFsX3dpdGhfdGhpcykKKyAgICAgICAgcmV0dXJuIG9wX2dldF9i eV92YWw7CisgICAgaWYgKG9wY29kZUlkID09IG9wX2NvbnN0cnVjdF92YXJhcmdzKQorICAgICAg ICByZXR1cm4gb3BfY29uc3RydWN0OworICAgIHJldHVybiBvcGNvZGVJZDsKK30KKworU3BlY3Vs YXRlZFR5cGUgRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlOjpnZXRQcmVkaWN0aW9uKENvZGVCbG9j ayogY29kZUJsb2NrLCBjb25zdCBDb2RlT3JpZ2luJiBjb2RlT3JpZ2luLCBTcGVjdWxhdGVkVHlw ZSBvcmlnaW5hbCkKK3sKKyAgICBhdXRvIGxvY2tlciA9IGhvbGRMb2NrKG1fbG9jayk7CisKKyAg ICBTY3JpcHRFeGVjdXRhYmxlKiBvd25lckV4ZWN1dGFibGUgPSBjb2RlQmxvY2stPm93bmVyRXhl Y3V0YWJsZSgpOworICAgIGNvbnN0IGF1dG8mIHNvdXJjZVVSTCA9IG93bmVyRXhlY3V0YWJsZS0+ c291cmNlVVJMKCk7CisgICAgaWYgKHNvdXJjZVVSTC5pc0VtcHR5KCkpCisgICAgICAgIHJldHVy biBvcmlnaW5hbDsKKworICAgIFByZWRpY3Rpb25UYXJnZXQgcHJlZGljdGlvblRhcmdldDsKKyAg ICBCeXRlY29kZUluZGV4IGJ5dGVjb2RlSW5kZXggPSBjb2RlT3JpZ2luLmJ5dGVjb2RlSW5kZXgo KTsKKyAgICBjb2RlQmxvY2stPmV4cHJlc3Npb25SYW5nZUZvckJ5dGVjb2RlSW5kZXgoYnl0ZWNv ZGVJbmRleCwgcHJlZGljdGlvblRhcmdldC5kaXZvdCwgcHJlZGljdGlvblRhcmdldC5zdGFydE9m ZnNldCwgcHJlZGljdGlvblRhcmdldC5lbmRPZmZzZXQsIHByZWRpY3Rpb25UYXJnZXQubGluZSwg cHJlZGljdGlvblRhcmdldC5jb2x1bW4pOworCisgICAgVmVjdG9yPFN0cmluZz4gdXJsUGFydHMg PSBzb3VyY2VVUkwuc3BsaXQoJy8nKTsKKyAgICBwcmVkaWN0aW9uVGFyZ2V0LnNvdXJjZUZpbGVu YW1lID0gdXJsUGFydHMuaXNFbXB0eSgpID8gc291cmNlVVJMIDogdXJsUGFydHMubGFzdCgpOwor CisgICAgY29uc3QgSW5zdHJ1Y3Rpb25TdHJlYW0mIGluc3RydWN0aW9ucyA9IGNvZGVCbG9jay0+ aW5zdHJ1Y3Rpb25zKCk7CisgICAgY29uc3QgSW5zdHJ1Y3Rpb24qIGFuSW5zdHJ1Y3Rpb24gPSBp bnN0cnVjdGlvbnMuYXQoYnl0ZWNvZGVJbmRleCkucHRyKCk7CisgICAgcHJlZGljdGlvblRhcmdl dC5vcGNvZGVJZCA9IGFuSW5zdHJ1Y3Rpb24tPm9wY29kZUlEKCk7CisKKyAgICBpbnQgc3RhcnRM b2NhdGlvbiA9IHByZWRpY3Rpb25UYXJnZXQuZGl2b3QgLSBwcmVkaWN0aW9uVGFyZ2V0LnN0YXJ0 T2Zmc2V0OworICAgIGludCBlbmRMb2NhdGlvbiA9IHByZWRpY3Rpb25UYXJnZXQuZGl2b3QgKyBw cmVkaWN0aW9uVGFyZ2V0LmVuZE9mZnNldDsKKyAgICBwcmVkaWN0aW9uVGFyZ2V0Lmxvb2t1cEtl eSA9IGNyZWF0ZUxvb2t1cEtleShwcmVkaWN0aW9uVGFyZ2V0LnNvdXJjZUZpbGVuYW1lLCBwcmVk aWN0aW9uVGFyZ2V0Lm9wY29kZUlkLCBzdGFydExvY2F0aW9uLCBlbmRMb2NhdGlvbik7CisgICAg cmV0dXJuIGdldFByZWRpY3Rpb25JbnRlcm5hbChjb2RlQmxvY2ssIHByZWRpY3Rpb25UYXJnZXQs IG9yaWdpbmFsKTsKK30KKworfSAvLyBuYW1lc3BhY2UgSlNDCmRpZmYgLS1naXQgYS9Tb3VyY2Uv SmF2YVNjcmlwdENvcmUvcnVudGltZS9GaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UuaCBiL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1enplckFnZW50QmFzZS5oCm5ldyBm aWxlIG1vZGUgMTAwNjQ0CmluZGV4IDAwMDAwMDAwMDAwLi43NmYwZGQ5ZWY4YwotLS0gL2Rldi9u dWxsCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0ZpbGVCYXNlZEZ1enplckFn ZW50QmFzZS5oCkBAIC0wLDAgKzEsNjYgQEAKKy8qCisgKiBDb3B5cmlnaHQgKEMpIDIwMTkgQXBw bGUgSW5jLiBBbGwgcmlnaHRzIHJlc2VydmVkLgorICoKKyAqIFJlZGlzdHJpYnV0aW9uIGFuZCB1 c2UgaW4gc291cmNlIGFuZCBiaW5hcnkgZm9ybXMsIHdpdGggb3Igd2l0aG91dAorICogbW9kaWZp Y2F0aW9uLCBhcmUgcGVybWl0dGVkIHByb3ZpZGVkIHRoYXQgdGhlIGZvbGxvd2luZyBjb25kaXRp b25zCisgKiBhcmUgbWV0OgorICogMS4gUmVkaXN0cmlidXRpb25zIG9mIHNvdXJjZSBjb2RlIG11 c3QgcmV0YWluIHRoZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9m IGNvbmRpdGlvbnMgYW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lci4KKyAqIDIuIFJlZGlzdHJp YnV0aW9ucyBpbiBiaW5hcnkgZm9ybSBtdXN0IHJlcHJvZHVjZSB0aGUgYWJvdmUgY29weXJpZ2h0 CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5n IGRpc2NsYWltZXIgaW4gdGhlCisgKiAgICBkb2N1bWVudGF0aW9uIGFuZC9vciBvdGhlciBtYXRl cmlhbHMgcHJvdmlkZWQgd2l0aCB0aGUgZGlzdHJpYnV0aW9uLgorICoKKyAqIFRISVMgU09GVFdB UkUgSVMgUFJPVklERUQgQlkgQVBQTEUgSU5DLiBgYEFTIElTJycgQU5EIEFOWQorICogRVhQUkVT UyBPUiBJTVBMSUVEIFdBUlJBTlRJRVMsIElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLCBU SEUKKyAqIElNUExJRUQgV0FSUkFOVElFUyBPRiBNRVJDSEFOVEFCSUxJVFkgQU5EIEZJVE5FU1Mg Rk9SIEEgUEFSVElDVUxBUgorICogUFVSUE9TRSBBUkUgRElTQ0xBSU1FRC4gIElOIE5PIEVWRU5U IFNIQUxMIEFQUExFIElOQy4gT1IKKyAqIENPTlRSSUJVVE9SUyBCRSBMSUFCTEUgRk9SIEFOWSBE SVJFQ1QsIElORElSRUNULCBJTkNJREVOVEFMLCBTUEVDSUFMLAorICogRVhFTVBMQVJZLCBPUiBD T05TRVFVRU5USUFMIERBTUFHRVMgKElOQ0xVRElORywgQlVUIE5PVCBMSU1JVEVEIFRPLAorICog UFJPQ1VSRU1FTlQgT0YgU1VCU1RJVFVURSBHT09EUyBPUiBTRVJWSUNFUzsgTE9TUyBPRiBVU0Us IERBVEEsIE9SCisgKiBQUk9GSVRTOyBPUiBCVVNJTkVTUyBJTlRFUlJVUFRJT04pIEhPV0VWRVIg Q0FVU0VEIEFORCBPTiBBTlkgVEhFT1JZCisgKiBPRiBMSUFCSUxJVFksIFdIRVRIRVIgSU4gQ09O VFJBQ1QsIFNUUklDVCBMSUFCSUxJVFksIE9SIFRPUlQKKyAqIChJTkNMVURJTkcgTkVHTElHRU5D RSBPUiBPVEhFUldJU0UpIEFSSVNJTkcgSU4gQU5ZIFdBWSBPVVQgT0YgVEhFIFVTRQorICogT0Yg VEhJUyBTT0ZUV0FSRSwgRVZFTiBJRiBBRFZJU0VEIE9GIFRIRSBQT1NTSUJJTElUWSBPRiBTVUNI IERBTUFHRS4KKyAqLworCisjcHJhZ21hIG9uY2UKKworI2luY2x1ZGUgIkZ1enplckFnZW50Lmgi CisjaW5jbHVkZSAiT3Bjb2RlLmgiCisjaW5jbHVkZSA8d3RmL0xvY2suaD4KKworbmFtZXNwYWNl IEpTQyB7CisKK2NsYXNzIFZNOworCitzdHJ1Y3QgUHJlZGljdGlvblRhcmdldCB7CisgICAgQnl0 ZWNvZGVJbmRleCBieXRlY29kZUluZGV4OworICAgIGludCBkaXZvdDsKKyAgICBpbnQgc3RhcnRP ZmZzZXQ7CisgICAgaW50IGVuZE9mZnNldDsKKyAgICB1bnNpZ25lZCBsaW5lOworICAgIHVuc2ln bmVkIGNvbHVtbjsKKyAgICBPcGNvZGVJRCBvcGNvZGVJZDsKKyAgICBTdHJpbmcgc291cmNlRmls ZW5hbWU7CisgICAgU3RyaW5nIGxvb2t1cEtleTsKK307CisKK2NsYXNzIEZpbGVCYXNlZEZ1enpl ckFnZW50QmFzZSA6IHB1YmxpYyBGdXp6ZXJBZ2VudCB7CisgICAgV1RGX01BS0VfRkFTVF9BTExP Q0FURUQ7CisKK3B1YmxpYzoKKyAgICBGaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UoVk0mKTsKKwor cHJvdGVjdGVkOgorICAgIExvY2sgbV9sb2NrOworICAgIHZpcnR1YWwgU3BlY3VsYXRlZFR5cGUg Z2V0UHJlZGljdGlvbkludGVybmFsKENvZGVCbG9jayosIFByZWRpY3Rpb25UYXJnZXQmLCBTcGVj dWxhdGVkVHlwZSBvcmlnaW5hbCkgPSAwOworCitwdWJsaWM6CisgICAgU3BlY3VsYXRlZFR5cGUg Z2V0UHJlZGljdGlvbihDb2RlQmxvY2sqLCBjb25zdCBDb2RlT3JpZ2luJiwgU3BlY3VsYXRlZFR5 cGUgb3JpZ2luYWwpIGZpbmFsOworCitwcm90ZWN0ZWQ6CisgICAgc3RhdGljIFN0cmluZyBjcmVh dGVMb29rdXBLZXkoY29uc3QgU3RyaW5nJiBzb3VyY2VGaWxlbmFtZSwgT3Bjb2RlSUQsIGludCBz dGFydExvY2F0aW9uLCBpbnQgZW5kTG9jYXRpb24pOworICAgIHN0YXRpYyBPcGNvZGVJRCBvcGNv ZGVBbGlhc0Zvckxvb2t1cEtleShjb25zdCBPcGNvZGVJRCYpOworfTsKKworfSAvLyBuYW1lc3Bh Y2UgSlNDCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GdXp6ZXJQ cmVkaWN0aW9ucy5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9GdXp6ZXJQcmVk aWN0aW9ucy5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLmFiOWIx ZDJhODBiCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUv RnV6emVyUHJlZGljdGlvbnMuY3BwCkBAIC0wLDAgKzEsMTA1IEBACisvKgorICogQ29weXJpZ2h0 IChDKSAyMDE5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBz b3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisg KiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFi b3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQv b3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBB TlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu ICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1 ZGUgIkZ1enplclByZWRpY3Rpb25zLmgiCisKK25hbWVzcGFjZSBKU0MgeworCitzdGF0aWMgU3Ry aW5nIHJlYWRGaWxlSW50b1N0cmluZyhjb25zdCBjaGFyKiBmaWxlTmFtZSkKK3sKKyAgICBGSUxF KiBmaWxlID0gZm9wZW4oZmlsZU5hbWUsICJyIik7CisgICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9N RVNTQUdFKGZpbGUsICJGYWlsZWQgdG8gb3BlbiBmaWxlICVzIiwgZmlsZU5hbWUpOworICAgIFJF TEVBU0VfQVNTRVJUKGZzZWVrKGZpbGUsIDAsIFNFRUtfRU5EKSAhPSAtMSk7CisgICAgbG9uZyBi dWZmZXJDYXBhY2l0eSA9IGZ0ZWxsKGZpbGUpOworICAgIFJFTEVBU0VfQVNTRVJUKGJ1ZmZlckNh cGFjaXR5ICE9IC0xKTsKKyAgICBSRUxFQVNFX0FTU0VSVChmc2VlayhmaWxlLCAwLCBTRUVLX1NF VCkgIT0gLTEpOworICAgIFZlY3RvcjxjaGFyPiBidWZmZXI7CisgICAgYnVmZmVyLnJlc2l6ZShi dWZmZXJDYXBhY2l0eSk7CisgICAgc2l6ZV90IHJlYWRTaXplID0gZnJlYWQoYnVmZmVyLmRhdGEo KSwgMSwgYnVmZmVyLnNpemUoKSwgZmlsZSk7CisgICAgZmNsb3NlKGZpbGUpOworICAgIFJFTEVB U0VfQVNTRVJUKHJlYWRTaXplID09IGJ1ZmZlci5zaXplKCkpOworICAgIHJldHVybiBTdHJpbmco YnVmZmVyLmRhdGEoKSwgYnVmZmVyLnNpemUoKSk7Cit9CisKK0Z1enplclByZWRpY3Rpb25zOjpG dXp6ZXJQcmVkaWN0aW9ucyhjb25zdCBjaGFyKiBmaWxlbmFtZSkKK3sKKyAgICBSRUxFQVNFX0FT U0VSVF9XSVRIX01FU1NBR0UoZmlsZW5hbWUsICJwcmVkaWN0aW9uIGZpbGUgbXVzdCBiZSBzcGVj aWZpZWQgdXNpbmcgLS1mdXp6ZXJQcmVkaWN0aW9uc0ZpbGU9Iik7CisKKyAgICBTdHJpbmcgcHJl ZGljdGlvbnMgPSByZWFkRmlsZUludG9TdHJpbmcoZmlsZW5hbWUpOworICAgIGNvbnN0IFZlY3Rv cjxTdHJpbmc+JiBsaW5lcyA9IHByZWRpY3Rpb25zLnNwbGl0KCdcbicpOworICAgIGZvciAoY29u c3QgYXV0byYgbGluZSA6IGxpbmVzKSB7CisgICAgICAgIC8vIFByZWRpY3Rpb25zIGFyZSBzdG9y ZWQgaW4gYSB0ZXh0IGZpbGUsIG9uZSBwcmVkaWN0aW9uIHBlciBsaW5lIGluIHRoZSBjb2xvbiBk ZWxpbWl0ZWQgZm9ybWF0OgorICAgICAgICAvLyA8bG9va3VwIGtleT46PHByZWRpY3Rpb24gaW4g aGV4IHdpdGhvdXQgbGVhZGluZyAweD4KKyAgICAgICAgLy8gVGhlIGxvb2t1cCBrZXkgaXMgYSBw aXBlIHNlcGFyYXRlZCBzdHJpbmcgd2l0aCB0aGUgZm9ybWF0OgorICAgICAgICAvLyA8ZmlsZW5h bWU+fDxvcGNvZGU+fDxzdGFydCBvZmZzZXQ+fDxlbmQgb2Zmc2V0PgorCisgICAgICAgIC8vIFRo ZSBzdGFydCBhbmQgZW5kIG9mZnNldHMgYXJlIDctYml0IHVuc2lnbmVkIGludGVnZXJzLgorICAg ICAgICAvLyBJZiBzdGFydCBvZmZzZXQgPiAxMjcsIHRoZW4gYm90aCBzdGFydCBhbmQgZW5kIG9m ZnNldHMgYXJlIDAuCisgICAgICAgIC8vIElmIGVuZCBvZmZzZXQgPiAxMjcsIHRoZW4gdGhlIGVu ZCBvZmZzZXQgaXMgMC4KKworICAgICAgICAvLyBFeGFtcGxlIHByZWRpY3Rpb25zOgorICAgICAg ICAvLyBmb28uanN8b3BfY29uc3RydWN0fDcwMnw3MjE6MTAwMDA4NAorICAgICAgICAvLyBmb28u anN8b3BfY2FsbHw3NDh8NzYwOjQwODgwMAorICAgICAgICAvLyBmb28uanN8b3BfYml0bm90fDc3 MHw3NzA6MjgwMDAwMDAwCisKKyAgICAgICAgLy8gUHJlZGljdGlvbnMgY2FuIGJlIGdlbmVyYXRl ZCB1c2luZyBQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuCisgICAgICAgIC8vIFNv bWUgb3Bjb2RlcyBhcmUgYWxpYXNlZCB0b2dldGhlciB0byBtYWtlIGdlbmVyYXRpbmcgdGhlIHBy ZWRpY3Rpb25zIG1vcmUgc3RyYWlnaHRmb3J3YXJkLgorICAgICAgICAvLyBGb3IgdGhlIGFsaWFz ZXMgc2VlOiBGaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2U6Om9wY29kZUFsaWFzRm9yTG9va3VwS2V5 KCkKKworICAgICAgICAvLyBGSVhNRTogVGhlIGN1cnJlbnQgaW1wbGVtZW50YXRpb24gb25seSBz dXBwb3J0cyBvbmUgcHJlZGljdGlvbiBwZXIgbG9va3VwIGtleS4KKworICAgICAgICBjb25zdCBW ZWN0b3I8U3RyaW5nPiYgbGluZVBhcnRzID0gbGluZS5zcGxpdCgnOicpOworICAgICAgICBSRUxF QVNFX0FTU0VSVF9XSVRIX01FU1NBR0UobGluZVBhcnRzLnNpemUoKSA9PSAyLCAiRXhwZWN0ZWQg bGluZSB3aXRoIHR3byBwYXJ0cyBkZWxpbWl0ZWQgYnkgYSBjb2xvbi4gRm91bmQgbGluZSB3aXRo ICVsdSBwYXJ0cy4iLCBsaW5lUGFydHMuc2l6ZSgpKTsKKyAgICAgICAgY29uc3QgU3RyaW5nJiBs b29rdXBLZXkgPSBsaW5lUGFydHNbMF07CisgICAgICAgIGNvbnN0IFN0cmluZyYgcHJlZGljdGlv blN0cmluZyA9IGxpbmVQYXJ0c1sxXTsKKyAgICAgICAgYm9vbCBvazsKKyAgICAgICAgU3BlY3Vs YXRlZFR5cGUgcHJlZGljdGlvbiA9IHByZWRpY3Rpb25TdHJpbmcudG9VSW50NjRTdHJpY3QoJm9r LCAweDEwKTsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlRfV0lUSF9NRVNTQUdFKG9rLCAiQ291bGQg bm90IHBhcnNlIHByZWRpY3Rpb24gZnJvbSAnJXMnIiwgcHJlZGljdGlvblN0cmluZy51dGY4KCku ZGF0YSgpKTsKKyAgICAgICAgUkVMRUFTRV9BU1NFUlQoc3BlY3VsYXRpb25DaGVja2VkKHByZWRp Y3Rpb24sIFNwZWNGdWxsVG9wKSk7CisgICAgICAgIG1fcHJlZGljdGlvbnMuc2V0KGxvb2t1cEtl eSwgcHJlZGljdGlvbik7CisgICAgfQorfQorCitPcHRpb25hbDxTcGVjdWxhdGVkVHlwZT4gRnV6 emVyUHJlZGljdGlvbnM6OnByZWRpY3Rpb25Gb3IoY29uc3QgU3RyaW5nJiBrZXkpCit7CisgICAg YXV0byBpdCA9IG1fcHJlZGljdGlvbnMuZmluZChrZXkpOworICAgIGlmIChpdCA9PSBtX3ByZWRp Y3Rpb25zLmVuZCgpKQorICAgICAgICByZXR1cm4gV1RGOjpudWxsb3B0OworICAgIHJldHVybiBp dC0+dmFsdWU7Cit9CisKK0Z1enplclByZWRpY3Rpb25zJiBlbnN1cmVHbG9iYWxGdXp6ZXJQcmVk aWN0aW9ucygpCit7CisgICAgc3RhdGljIExhenlOZXZlckRlc3Ryb3llZDxGdXp6ZXJQcmVkaWN0 aW9ucz4gZnV6emVyUHJlZGljdGlvbnM7CisgICAgc3RhdGljIHN0ZDo6b25jZV9mbGFnIGluaXRp YWxpemVGdXp6ZXJQcmVkaWN0aW9uc0ZsYWc7CisgICAgc3RkOjpjYWxsX29uY2UoaW5pdGlhbGl6 ZUZ1enplclByZWRpY3Rpb25zRmxhZywgW10geworICAgICAgICBjb25zdCBjaGFyKiBmdXp6ZXJQ cmVkaWN0aW9uc0ZpbGVuYW1lID0gT3B0aW9uczo6ZnV6emVyUHJlZGljdGlvbnNGaWxlKCk7Cisg ICAgICAgIGZ1enplclByZWRpY3Rpb25zLmNvbnN0cnVjdChmdXp6ZXJQcmVkaWN0aW9uc0ZpbGVu YW1lKTsKKyAgICB9KTsKKyAgICByZXR1cm4gZnV6emVyUHJlZGljdGlvbnM7Cit9CisKK30gLy8g bmFtZXNwYWNlIEpTQwpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUv RnV6emVyUHJlZGljdGlvbnMuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL0Z1enpl clByZWRpY3Rpb25zLmgKbmV3IGZpbGUgbW9kZSAxMDA2NDQKaW5kZXggMDAwMDAwMDAwMDAuLjBk Yjk2YTQ4OWNiCi0tLSAvZGV2L251bGwKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRp bWUvRnV6emVyUHJlZGljdGlvbnMuaApAQCAtMCwwICsxLDQ2IEBACisvKgorICogQ29weXJpZ2h0 IChDKSAyMDE5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3Ry aWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhv dXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xs b3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBz b3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2Us IHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisg KiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFi b3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQg dGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQv b3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisg KiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBB TlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1Qg TElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZ IEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQu ICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElB QkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVY RU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElN SVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7 IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBU SU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBX SEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVE SU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRI RSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lC SUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNpbmNsdWRlIDxi eXRlY29kZS9Db2RlQmxvY2suaD4KKyNpbmNsdWRlIDx3dGYvSGFzaE1hcC5oPgorI2luY2x1ZGUg PHd0Zi90ZXh0L1dURlN0cmluZy5oPgorCituYW1lc3BhY2UgSlNDIHsKKworY2xhc3MgRnV6emVy UHJlZGljdGlvbnMgeworcHVibGljOgorICAgIEpTX0VYUE9SVF9QUklWQVRFIEZ1enplclByZWRp Y3Rpb25zKGNvbnN0IGNoYXIqKTsKKworICAgIE9wdGlvbmFsPFNwZWN1bGF0ZWRUeXBlPiBwcmVk aWN0aW9uRm9yKGNvbnN0IFN0cmluZyYpOworCitwcml2YXRlOgorICAgIEhhc2hNYXA8U3RyaW5n LCBTcGVjdWxhdGVkVHlwZT4gbV9wcmVkaWN0aW9uczsKK307CisKK0pTX0VYUE9SVF9QUklWQVRF IEZ1enplclByZWRpY3Rpb25zJiBlbnN1cmVHbG9iYWxGdXp6ZXJQcmVkaWN0aW9ucygpOworCit9 IC8vIG5hbWVzcGFjZSBKU0MKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50 aW1lL09wdGlvbnMuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvT3B0aW9ucy5j cHAKaW5kZXggYzE5NmIzMDdmYjguLmJkMzE2YjViYTk2IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2 YVNjcmlwdENvcmUvcnVudGltZS9PcHRpb25zLmNwcAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENv cmUvcnVudGltZS9PcHRpb25zLmNwcApAQCAtNDQ4LDcgKzQ0OCw3IEBAIHN0YXRpYyB2b2lkIHJl Y29tcHV0ZURlcGVuZGVudE9wdGlvbnMoKQogICAgICAgICB8fCBPcHRpb25zOjp2ZXJib3NlQ0ZB KCkKICAgICAgICAgfHwgT3B0aW9uczo6dmVyYm9zZURGR0ZhaWx1cmUoKQogICAgICAgICB8fCBP cHRpb25zOjp2ZXJib3NlRlRMRmFpbHVyZSgpCi0gICAgICAgIHx8IE9wdGlvbnM6OmR1bXBSYW5k b21pemluZ0Z1enplckFnZW50UHJlZGljdGlvbnMoKSkKKyAgICAgICAgfHwgT3B0aW9uczo6ZHVt cEZ1enplckFnZW50UHJlZGljdGlvbnMoKSkKICAgICAgICAgT3B0aW9uczo6YWx3YXlzQ29tcHV0 ZUhhc2goKSA9IHRydWU7CiAgICAgCiAgICAgaWYgKCFPcHRpb25zOjp1c2VDb25jdXJyZW50R0Mo KSkKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL09wdGlvbnNMaXN0 LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9PcHRpb25zTGlzdC5oCmluZGV4IDQ3 MTRjOTFmOTZhLi4wM2YyODUyNDRkYiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3J1bnRpbWUvT3B0aW9uc0xpc3QuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGlt ZS9PcHRpb25zTGlzdC5oCkBAIC0zOTQsOCArMzk0LDEyIEBAIGNvbnN0ZXhwciBib29sIGVuYWJs ZVdlYkFzc2VtYmx5U3RyZWFtaW5nQXBpID0gZmFsc2U7CiAgICAgdihVbnNpZ25lZCwgc2VlZE9m Vk1SYW5kb21Gb3JGdXp6ZXIsIDAsIE5vcm1hbCwgIjAgbWVhbnMgbm90IGZ1enppbmcgdGhpczsg dXNlIGEgY3J5cHRvZ3JhcGhpY2FsbHkgcmFuZG9tIHNlZWQiKSBcCiAgICAgdihCb29sLCB1c2VS YW5kb21pemluZ0Z1enplckFnZW50LCBmYWxzZSwgTm9ybWFsLCBudWxscHRyKSBcCiAgICAgdihV bnNpZ25lZCwgc2VlZE9mUmFuZG9taXppbmdGdXp6ZXJBZ2VudCwgMSwgTm9ybWFsLCBudWxscHRy KSBcCi0gICAgdihCb29sLCBkdW1wUmFuZG9taXppbmdGdXp6ZXJBZ2VudFByZWRpY3Rpb25zLCBm YWxzZSwgTm9ybWFsLCBudWxscHRyKSBcCisgICAgdihCb29sLCBkdW1wRnV6emVyQWdlbnRQcmVk aWN0aW9ucywgZmFsc2UsIE5vcm1hbCwgbnVsbHB0cikgXAogICAgIHYoQm9vbCwgdXNlRG91Ymxl UHJlZGljdGlvbkZ1enplckFnZW50LCBmYWxzZSwgTm9ybWFsLCBudWxscHRyKSBcCisgICAgdihC b29sLCB1c2VGaWxlQmFzZWRGdXp6ZXJBZ2VudCwgZmFsc2UsIE5vcm1hbCwgbnVsbHB0cikgXAor ICAgIHYoQm9vbCwgdXNlUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50LCBmYWxzZSwg Tm9ybWFsLCBudWxscHRyKSBcCisgICAgdihCb29sLCByZXF1aXJlUHJlZGljdGlvbkZvckZpbGVC YXNlZEZ1enplckFnZW50LCBmYWxzZSwgTm9ybWFsLCBudWxscHRyKSBcCisgICAgdihPcHRpb25T dHJpbmcsIGZ1enplclByZWRpY3Rpb25zRmlsZSwgbnVsbHB0ciwgTm9ybWFsLCAiZmlsZSB3aXRo IGxpc3Qgb2YgcHJlZGljdGlvbnMgZm9yIEZpbGVCYXNlZEZ1enplckFnZW50IikgXAogICAgIFwK ICAgICB2KEJvb2wsIGxvZ1BoYXNlVGltZXMsIGZhbHNlLCBOb3JtYWwsIG51bGxwdHIpIFwKICAg ICB2KERvdWJsZSwgcmFyZUJsb2NrUGVuYWx0eSwgMC4wMDEsIE5vcm1hbCwgbnVsbHB0cikgXApk aWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUHJlZGljdGlvbkZpbGVD cmVhdGluZ0Z1enplckFnZW50LmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1By ZWRpY3Rpb25GaWxlQ3JlYXRpbmdGdXp6ZXJBZ2VudC5jcHAKbmV3IGZpbGUgbW9kZSAxMDA2NDQK aW5kZXggMDAwMDAwMDAwMDAuLjMxOWM1MzI3MmQ5Ci0tLSAvZGV2L251bGwKKysrIGIvU291cmNl L0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50 LmNwcApAQCAtMCwwICsxLDcxIEBACisvKgorICogQ29weXJpZ2h0IChDKSAyMDE5IEFwcGxlIElu Yy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGlu IHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlv biwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucwor ICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJl dGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25k aXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlv bnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICog ICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNj bGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxz IHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElT IFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1Ig SU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisg KiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBB IFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFM TCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNU LCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VR VUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NV UkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRB LCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNF RCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNU LCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1Ig T1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMg U09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1B R0UuCisgKi8KKworI2luY2x1ZGUgImNvbmZpZy5oIgorI2luY2x1ZGUgIlByZWRpY3Rpb25GaWxl Q3JlYXRpbmdGdXp6ZXJBZ2VudC5oIgorCituYW1lc3BhY2UgSlNDIHsKKworUHJlZGljdGlvbkZp bGVDcmVhdGluZ0Z1enplckFnZW50OjpQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQo Vk0mIHZtKQorICAgIDogRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlKHZtKQoreworfQorCitTcGVj dWxhdGVkVHlwZSBQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQ6OmdldFByZWRpY3Rp b25JbnRlcm5hbChDb2RlQmxvY2sqLCBQcmVkaWN0aW9uVGFyZ2V0JiBwcmVkaWN0aW9uVGFyZ2V0 LCBTcGVjdWxhdGVkVHlwZSBvcmlnaW5hbCkKK3sKKyAgICBzd2l0Y2ggKHByZWRpY3Rpb25UYXJn ZXQub3Bjb2RlSWQpIHsKKyAgICBjYXNlIG9wX3RvX3RoaXM6CisgICAgY2FzZSBvcF9iaXRhbmQ6 CisgICAgY2FzZSBvcF9iaXRvcjoKKyAgICBjYXNlIG9wX2JpdHhvcjoKKyAgICBjYXNlIG9wX2Jp dG5vdDoKKyAgICBjYXNlIG9wX2xzaGlmdDoKKyAgICBjYXNlIG9wX3JzaGlmdDoKKyAgICBjYXNl IG9wX2dldF9ieV92YWw6CisgICAgY2FzZSBvcF9nZXRfYXJndW1lbnQ6CisgICAgY2FzZSBvcF9n ZXRfZnJvbV9hcmd1bWVudHM6CisgICAgY2FzZSBvcF9nZXRfZnJvbV9zY29wZToKKyAgICBjYXNl IG9wX3RvX251bWJlcjoKKyAgICBjYXNlIG9wX2dldF9ieV9pZDoKKyAgICBjYXNlIG9wX2dldF9i eV9pZF93aXRoX3RoaXM6CisgICAgY2FzZSBvcF9nZXRfYnlfdmFsX3dpdGhfdGhpczoKKyAgICBj YXNlIG9wX2dldF9kaXJlY3RfcG5hbWU6CisgICAgY2FzZSBvcF9jb25zdHJ1Y3Q6CisgICAgY2Fz ZSBvcF9jb25zdHJ1Y3RfdmFyYXJnczoKKyAgICBjYXNlIG9wX2NhbGw6CisgICAgY2FzZSBvcF9j YWxsX2V2YWw6CisgICAgY2FzZSBvcF9jYWxsX3ZhcmFyZ3M6CisgICAgY2FzZSBvcF90YWlsX2Nh bGw6CisgICAgY2FzZSBvcF90YWlsX2NhbGxfdmFyYXJnczoKKyAgICAgICAgZGF0YUxvZ0YoIiVz OiVsbHhcbiIsIHByZWRpY3Rpb25UYXJnZXQubG9va3VwS2V5LnV0ZjgoKS5kYXRhKCksIG9yaWdp bmFsKTsKKyAgICAgICAgYnJlYWs7CisKKyAgICBkZWZhdWx0OgorICAgICAgICBSRUxFQVNFX0FT U0VSVF9XSVRIX01FU1NBR0UoZmFsc2UsICJ1bmhhbmRsZWQgb3Bjb2RlOiAlcyIsIHRvU3RyaW5n KHByZWRpY3Rpb25UYXJnZXQub3Bjb2RlSWQpLnV0ZjgoKS5kYXRhKCkpOworICAgIH0KKyAgICBy ZXR1cm4gb3JpZ2luYWw7Cit9CisKK30gLy8gbmFtZXNwYWNlIEpTQwpkaWZmIC0tZ2l0IGEvU291 cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFn ZW50LmggYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9QcmVkaWN0aW9uRmlsZUNyZWF0 aW5nRnV6emVyQWdlbnQuaApuZXcgZmlsZSBtb2RlIDEwMDY0NAppbmRleCAwMDAwMDAwMDAwMC4u ZDQyMmVhZDA1MTUKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVu dGltZS9QcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVyQWdlbnQuaApAQCAtMCwwICsxLDQ0IEBA CisvKgorICogQ29weXJpZ2h0IChDKSAyMDE5IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZl ZC4KKyAqCisgKiBSZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZv cm1zLCB3aXRoIG9yIHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92 aWRlZCB0aGF0IHRoZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJl ZGlzdHJpYnV0aW9ucyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJp Z2h0CisgKiAgICBub3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93 aW5nIGRpc2NsYWltZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVz dCByZXByb2R1Y2UgdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qg b2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAg ZG9jdW1lbnRhdGlvbiBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRp c3RyaWJ1dGlvbi4KKyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElO Qy4gYGBBUyBJUycnIEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJ TkNMVURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMg T0YgTUVSQ0hBTlRBQklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBP U0UgQVJFIERJU0NMQUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBD T05UUklCVVRPUlMgQkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRB TCwgU1BFQ0lBTCwKKyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNM VURJTkcsIEJVVCBOT1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUg R09PRFMgT1IgU0VSVklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1Ig QlVTSU5FU1MgSU5URVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQor ICogT0YgTElBQklMSVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBP UiBUT1JUCisgKiAoSU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElO IEFOWSBXQVkgT1VUIE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURW SVNFRCBPRiBUSEUgUE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI3ByYWdtYSBv bmNlCisKKyNpbmNsdWRlICJGaWxlQmFzZWRGdXp6ZXJBZ2VudEJhc2UuaCIKKworbmFtZXNwYWNl IEpTQyB7CisKK2NsYXNzIFZNOworCitjbGFzcyBQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVy QWdlbnQgZmluYWwgOiBwdWJsaWMgRmlsZUJhc2VkRnV6emVyQWdlbnRCYXNlIHsKKyAgICBXVEZf TUFLRV9GQVNUX0FMTE9DQVRFRDsKKworcHVibGljOgorICAgIFByZWRpY3Rpb25GaWxlQ3JlYXRp bmdGdXp6ZXJBZ2VudChWTSYpOworCitwcm90ZWN0ZWQ6CisgICAgU3BlY3VsYXRlZFR5cGUgZ2V0 UHJlZGljdGlvbkludGVybmFsKENvZGVCbG9jayosIFByZWRpY3Rpb25UYXJnZXQmLCBTcGVjdWxh dGVkVHlwZSBvcmlnaW5hbCkgb3ZlcnJpZGU7Cit9OworCit9IC8vIG5hbWVzcGFjZSBKU0MKZGlm ZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1JhbmRvbWl6aW5nRnV6emVy QWdlbnQuY3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvUmFuZG9taXppbmdGdXp6 ZXJBZ2VudC5jcHAKaW5kZXggM2QyMjU5NTFiMjkuLmM5YzU0ZTdlM2NjIDEwMDY0NAotLS0gYS9T b3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFnZW50LmNwcAor KysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvcnVudGltZS9SYW5kb21pemluZ0Z1enplckFnZW50 LmNwcApAQCAtNDIsNyArNDIsNyBAQCBTcGVjdWxhdGVkVHlwZSBSYW5kb21pemluZ0Z1enplckFn ZW50OjpnZXRQcmVkaWN0aW9uKENvZGVCbG9jayogY29kZUJsb2NrLCBjb25zdAogICAgIHVpbnQz Ml90IGhpZ2ggPSBtX3JhbmRvbS5nZXRVaW50MzIoKTsKICAgICB1aW50MzJfdCBsb3cgPSBtX3Jh bmRvbS5nZXRVaW50MzIoKTsKICAgICBTcGVjdWxhdGVkVHlwZSBnZW5lcmF0ZWQgPSBzdGF0aWNf Y2FzdDxTcGVjdWxhdGVkVHlwZT4oKHN0YXRpY19jYXN0PHVpbnQ2NF90PihoaWdoKSA8PCAzMikg fCBsb3cpICYgU3BlY0Z1bGxUb3A7Ci0gICAgaWYgKE9wdGlvbnM6OmR1bXBSYW5kb21pemluZ0Z1 enplckFnZW50UHJlZGljdGlvbnMoKSkKKyAgICBpZiAoT3B0aW9uczo6ZHVtcEZ1enplckFnZW50 UHJlZGljdGlvbnMoKSkKICAgICAgICAgZGF0YUxvZ0xuKCJnZXRQcmVkaWN0aW9uIG5hbWU6KCIs IGNvZGVCbG9jay0+aW5mZXJyZWROYW1lKCksICIjIiwgY29kZUJsb2NrLT5oYXNoQXNTdHJpbmdJ ZlBvc3NpYmxlKCksICIpLGJ5dGVjb2RlSW5kZXg6KCIsIGNvZGVPcmlnaW4uYnl0ZWNvZGVJbmRl eCgpLCAiKSxvcmlnaW5hbDooIiwgU3BlY3VsYXRpb25EdW1wKG9yaWdpbmFsKSwgIiksZ2VuZXJh dGVkOigiLCBTcGVjdWxhdGlvbkR1bXAoZ2VuZXJhdGVkKSwgIikiKTsKICAgICByZXR1cm4gZ2Vu ZXJhdGVkOwogfQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVk0u Y3BwIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRpbWUvVk0uY3BwCmluZGV4IDVmM2Y4NDlk ODJiLi4yMTZiZjkxMDIzYiAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3J1bnRp bWUvVk0uY3BwCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9ydW50aW1lL1ZNLmNwcApAQCAt NTAsNiArNTAsNyBAQAogI2luY2x1ZGUgIkV4ZWN1dGFibGVUb0NvZGVCbG9ja0VkZ2UuaCIKICNp bmNsdWRlICJGVExUaHVua3MuaCIKICNpbmNsdWRlICJGYXN0TWFsbG9jQWxpZ25lZE1lbW9yeUFs bG9jYXRvci5oIgorI2luY2x1ZGUgIkZpbGVCYXNlZEZ1enplckFnZW50LmgiCiAjaW5jbHVkZSAi RnVuY3Rpb25Db2RlQmxvY2suaCIKICNpbmNsdWRlICJGdW5jdGlvbkNvbnN0cnVjdG9yLmgiCiAj aW5jbHVkZSAiRnVuY3Rpb25FeGVjdXRhYmxlLmgiCkBAIC0xMTcsNiArMTE4LDcgQEAKICNpbmNs dWRlICJOb2Rlcy5oIgogI2luY2x1ZGUgIk9iakNDYWxsYmFja0Z1bmN0aW9uLmgiCiAjaW5jbHVk ZSAiUGFyc2VyLmgiCisjaW5jbHVkZSAiUHJlZGljdGlvbkZpbGVDcmVhdGluZ0Z1enplckFnZW50 LmgiCiAjaW5jbHVkZSAiUHJvZmlsZXJEYXRhYmFzZS5oIgogI2luY2x1ZGUgIlByb2dyYW1Db2Rl QmxvY2suaCIKICNpbmNsdWRlICJQcm9ncmFtRXhlY3V0YWJsZS5oIgpAQCAtNDYzLDYgKzQ2NSwx MCBAQCBWTTo6Vk0oVk1UeXBlIHZtVHlwZSwgSGVhcFR5cGUgaGVhcFR5cGUpCiAgICAgICAgIHNl dEZ1enplckFnZW50KG1ha2VVbmlxdWU8UmFuZG9taXppbmdGdXp6ZXJBZ2VudD4oKnRoaXMpKTsK ICAgICBpZiAoT3B0aW9uczo6dXNlRG91YmxlUHJlZGljdGlvbkZ1enplckFnZW50KCkpCiAgICAg ICAgIHNldEZ1enplckFnZW50KG1ha2VVbmlxdWU8RG91YmxlUHJlZGljdGlvbkZ1enplckFnZW50 PigqdGhpcykpOworICAgIGlmIChPcHRpb25zOjp1c2VGaWxlQmFzZWRGdXp6ZXJBZ2VudCgpKQor ICAgICAgICBzZXRGdXp6ZXJBZ2VudChtYWtlVW5pcXVlPEZpbGVCYXNlZEZ1enplckFnZW50Pigq dGhpcykpOworICAgIGlmIChPcHRpb25zOjp1c2VQcmVkaWN0aW9uRmlsZUNyZWF0aW5nRnV6emVy QWdlbnQoKSkKKyAgICAgICAgc2V0RnV6emVyQWdlbnQobWFrZVVuaXF1ZTxQcmVkaWN0aW9uRmls ZUNyZWF0aW5nRnV6emVyQWdlbnQ+KCp0aGlzKSk7CiAKICAgICBpZiAoT3B0aW9uczo6YWx3YXlz R2VuZXJhdGVQQ1RvQ29kZU9yaWdpbk1hcCgpKQogICAgICAgICBzZXRTaG91bGRCdWlsZFBDVG9D b2RlT3JpZ2luTWFwcGluZygpOwo=