165833 2016-12-13 17:36:08 -0800 WebAssembly: enforce size limits 2017-05-16 22:49:36 -0700 1 1 1 Unclassified WebKit JavaScriptCore WebKit Nightly Build Unspecified Unspecified RESOLVED FIXED InRadar P2 Normal --- 165862 163919 165957 159775 1 jfbastien jfbastien commit-queue fpizlo ggaren jfbastien keith_miller mark.lam msaboff oliver saam webkit-bug-importer oldest_to_newest 1259599 0 jfbastien 2016-12-13 17:36:08 -0800 In bug #163919 patch I've been checking that indices and such never exceed UINT_MAX, but I think we want to have a hard-coded lower number: there are a bunch of places where we just do `index * sizeof(something)` and checking for overflow in these cases is annoying. We should use Checked<> there, but we should also just early-reject bad code. 1261071 1 jfbastien 2016-12-18 18:02:16 -0800 We should probably adopt the same limits as other browsers. They're fairly conservative, and having the same limits means one of us doesn't reject an odd binary whereas another does, reducing the risk that a developer tries it out in browser X and it fails in Y. 1261072 2 oliver 2016-12-18 18:10:37 -0800 Checked<> is indeed your friend -- you could also just make a specific override for the webasm case (one that takes a failure block or some such). The implementation actually predates blocks, etc. 1261761 3 webkit-bug-importer 2016-12-20 14:24:35 -0800 <rdar://problem/29760219> 1309011 4 310233 jfbastien 2017-05-15 23:51:08 -0700 Created attachment 310233 patch 1309016 5 310233 keith_miller 2017-05-16 00:04:29 -0700 Comment on attachment 310233 patch r=me. 1309032 6 310233 jfbastien 2017-05-16 00:22:10 -0700 Comment on attachment 310233 patch Makes some benchmark sad. Weird that V8 uses this... 1309042 7 310240 jfbastien 2017-05-16 00:32:03 -0700 Created attachment 310240 patch Drop function size limit, it was ridiculously low. 1309043 8 310240 commit-queue 2017-05-16 00:34:48 -0700 Comment on attachment 310240 patch Rejecting attachment 310240 from commit-queue. Failed to run "['/Volumes/Data/EWS/WebKit/Tools/Scripts/webkit-patch', '--status-host=webkit-queues.webkit.org', '--bot-id=webkit-cq-03', 'validate-changelog', '--check-oops', '--non-interactive', 310240, '--port=mac']" exit_code: 1 cwd: /Volumes/Data/EWS/WebKit ChangeLog entry in Source/JavaScriptCore/ChangeLog contains OOPS!. Full output: http://webkit-queues.webkit.org/results/3749015 1309061 9 310240 jfbastien 2017-05-16 01:15:49 -0700 Comment on attachment 310240 patch >From 3d44a3ee1dc1f9dd20bd1dc2588c42ac70e3f424 Mon Sep 17 00:00:00 2001 >From: JF Bastien <jfbastien@apple.com> >Date: Mon, 15 May 2017 23:50:37 -0700 >Subject: [PATCH] WebAssembly: enforce size limits > >--- > Source/JavaScriptCore/ChangeLog | 16 +++++++ > .../JavaScriptCore.xcodeproj/project.pbxproj | 4 ++ > Source/JavaScriptCore/wasm/WasmLimits.h | 55 ++++++++++++++++++++++ > Source/JavaScriptCore/wasm/WasmModuleParser.cpp | 17 ++++--- > Source/JavaScriptCore/wasm/WasmParser.h | 3 ++ > 5 files changed, 88 insertions(+), 7 deletions(-) > create mode 100644 Source/JavaScriptCore/wasm/WasmLimits.h > >diff --git a/Source/JavaScriptCore/ChangeLog b/Source/JavaScriptCore/ChangeLog >index 6954d9b..f7694af 100644 >--- a/Source/JavaScriptCore/ChangeLog >+++ b/Source/JavaScriptCore/ChangeLog >@@ -1,3 +1,19 @@ >+2017-05-15 JF Bastien <jfbastien@apple.com> >+ >+ WebAssembly: enforce size limits >+ https://bugs.webkit.org/show_bug.cgi?id=165833 >+ <rdar://problem/29760219> >+ >+ Reviewed by Keith Miller. >+ >+ Use the same limits as V8. >+ >+ * JavaScriptCore.xcodeproj/project.pbxproj: >+ * wasm/WasmLimits.h: Added. >+ * wasm/WasmModuleParser.cpp: >+ * wasm/WasmParser.h: >+ (JSC::Wasm::Parser<SuccessType>::consumeUTF8String): >+ > 2017-05-15 Mark Lam <mark.lam@apple.com> > > Rolling out r214038 and r213697: Crashes when using computed properties with rest destructuring and object spread. >diff --git a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj b/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj >index 58d1829..19aa6e7 100644 >--- a/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj >+++ b/Source/JavaScriptCore/JavaScriptCore.xcodeproj/project.pbxproj >@@ -2080,6 +2080,7 @@ > A7FB61001040C38B0017A286 /* PropertyDescriptor.h in Headers */ = {isa = PBXBuildFile; fileRef = A7FB604B103F5EAB0017A286 /* PropertyDescriptor.h */; settings = {ATTRIBUTES = (Private, ); }; }; > A7FCC26D17A0B6AA00786D1A /* FTLSwitchCase.h in Headers */ = {isa = PBXBuildFile; fileRef = A7FCC26C17A0B6AA00786D1A /* FTLSwitchCase.h */; settings = {ATTRIBUTES = (Private, ); }; }; > A8A4748E151A8306004123FF /* libWTF.a in Frameworks */ = {isa = PBXBuildFile; fileRef = A8A4748D151A8306004123FF /* libWTF.a */; }; >+ AD00659E1ECAC812000CA926 /* WasmLimits.h in Headers */ = {isa = PBXBuildFile; fileRef = AD00659D1ECAC7FE000CA926 /* WasmLimits.h */; settings = {ATTRIBUTES = (Private, ); }; }; > AD2FCBE21DB58DAD00B3E736 /* JSWebAssemblyCompileError.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AD2FCBA61DB58DA400B3E736 /* JSWebAssemblyCompileError.cpp */; }; > AD2FCBE31DB58DAD00B3E736 /* JSWebAssemblyCompileError.h in Headers */ = {isa = PBXBuildFile; fileRef = AD2FCBA71DB58DA400B3E736 /* JSWebAssemblyCompileError.h */; }; > AD2FCBE41DB58DAD00B3E736 /* JSWebAssemblyInstance.cpp in Sources */ = {isa = PBXBuildFile; fileRef = AD2FCBA81DB58DA400B3E736 /* JSWebAssemblyInstance.cpp */; }; >@@ -4711,6 +4712,7 @@ > A8A4748D151A8306004123FF /* libWTF.a */ = {isa = PBXFileReference; lastKnownFileType = archive.ar; path = libWTF.a; sourceTree = BUILT_PRODUCTS_DIR; }; > A8E894310CD0602400367179 /* JSCallbackObjectFunctions.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSCallbackObjectFunctions.h; sourceTree = "<group>"; }; > A8E894330CD0603F00367179 /* JSGlobalObject.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = JSGlobalObject.h; sourceTree = "<group>"; }; >+ AD00659D1ECAC7FE000CA926 /* WasmLimits.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; path = WasmLimits.h; sourceTree = "<group>"; }; > AD1CF06816DCAB2D00B97123 /* PropertyTable.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; path = PropertyTable.cpp; sourceTree = "<group>"; }; > AD2FCB8C1DB5844000B3E736 /* JSWebAssemblyModule.cpp */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.cpp.cpp; name = JSWebAssemblyModule.cpp; path = js/JSWebAssemblyModule.cpp; sourceTree = "<group>"; }; > AD2FCB8D1DB5844000B3E736 /* JSWebAssemblyModule.h */ = {isa = PBXFileReference; fileEncoding = 4; lastKnownFileType = sourcecode.c.h; name = JSWebAssemblyModule.h; path = js/JSWebAssemblyModule.h; sourceTree = "<group>"; }; >@@ -6430,6 +6432,7 @@ > 53F40E8A1D5901BB0099A1B6 /* WasmFunctionParser.h */, > AD8FF3961EB5BD850087FF82 /* WasmIndexOrName.cpp */, > AD8FF3951EB5BD850087FF82 /* WasmIndexOrName.h */, >+ AD00659D1ECAC7FE000CA926 /* WasmLimits.h */, > 53E9E0A91EAE83DE00FEE251 /* WasmMachineThreads.cpp */, > 53E9E0AA1EAE83DE00FEE251 /* WasmMachineThreads.h */, > 535557151D9DFA32006D583B /* WasmMemory.cpp */, >@@ -9469,6 +9472,7 @@ > 0F1FB38F1E173A6700A9BE50 /* SynchronousStopTheWorldMutatorScheduler.h in Headers */, > A784A26411D16622005776AC /* SyntaxChecker.h in Headers */, > DC7997831CDE9FA0004D4A09 /* TagRegistersMode.h in Headers */, >+ AD00659E1ECAC812000CA926 /* WasmLimits.h in Headers */, > 70ECA6081AFDBEA200449739 /* TemplateRegistry.h in Headers */, > 70ECA6091AFDBEA200449739 /* TemplateRegistryKey.h in Headers */, > 95D4261AF4C84CE2ACBAC981 /* TemplateRegistryKeyTable.h in Headers */, >diff --git a/Source/JavaScriptCore/wasm/WasmLimits.h b/Source/JavaScriptCore/wasm/WasmLimits.h >new file mode 100644 >index 0000000..92a6e85 >--- /dev/null >+++ b/Source/JavaScriptCore/wasm/WasmLimits.h >@@ -0,0 +1,55 @@ >+/* >+ * Copyright (C) 2017 Apple Inc. All rights reserved. >+ * >+ * Redistribution and use in source and binary forms, with or without >+ * modification, are permitted provided that the following conditions >+ * are met: >+ * 1. Redistributions of source code must retain the above copyright >+ * notice, this list of conditions and the following disclaimer. >+ * 2. Redistributions in binary form must reproduce the above copyright >+ * notice, this list of conditions and the following disclaimer in the >+ * documentation and/or other materials provided with the distribution. >+ * >+ * THIS SOFTWARE IS PROVIDED BY APPLE INC. ``AS IS'' AND ANY >+ * EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE >+ * IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR >+ * PURPOSE ARE DISCLAIMED. IN NO EVENT SHALL APPLE INC. OR >+ * CONTRIBUTORS BE LIABLE FOR ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, >+ * EXEMPLARY, OR CONSEQUENTIAL DAMAGES (INCLUDING, BUT NOT LIMITED TO, >+ * PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES; LOSS OF USE, DATA, OR >+ * PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND ON ANY THEORY >+ * OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT >+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE >+ * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE. >+ */ >+ >+#pragma once >+ >+#if ENABLE(WEBASSEMBLY) >+ >+#include <cstdint> >+ >+namespace JSC { >+ >+namespace Wasm { >+ >+// These limits are arbitrary except that they match the limits imposed >+// by other browsers' implementation of WebAssembly. It is desirable for >+// us to accept at least the same inputs. >+ >+constexpr size_t maxTypes = 1000000; >+constexpr size_t maxFunctions = 1000000; >+constexpr size_t maxImports = 100000; >+constexpr size_t maxExports = 100000; >+constexpr size_t maxGlobals = 1000000; >+constexpr size_t maxDataSegments = 100000; >+ >+constexpr size_t maxStringSize = 100000; >+constexpr size_t maxModuleSize = 1024 * 1024 * 1024; >+constexpr size_t maxFunctionParams = 1000; >+ >+constexpr size_t maxTableEntries = 10000000; >+ >+} } // namespace JSC::Wasm >+ >+#endif // ENABLE(WEBASSEMBLY) >diff --git a/Source/JavaScriptCore/wasm/WasmModuleParser.cpp b/Source/JavaScriptCore/wasm/WasmModuleParser.cpp >index 7a6a1f5..7d07500 100644 >--- a/Source/JavaScriptCore/wasm/WasmModuleParser.cpp >+++ b/Source/JavaScriptCore/wasm/WasmModuleParser.cpp >@@ -51,6 +51,7 @@ auto ModuleParser::parse() -> Result > uint32_t versionNumber; > > WASM_PARSER_FAIL_IF(length() < minSize, "expected a module of at least ", minSize, " bytes"); >+ WASM_PARSER_FAIL_IF(length() > maxModuleSize, "module size ", length(), " is too large, maximum ", maxModuleSize); > WASM_PARSER_FAIL_IF(!consumeCharacter(0) || !consumeString("asm"), "modules doesn't start with '\\0asm'"); > WASM_PARSER_FAIL_IF(!parseUInt32(versionNumber), "can't parse version number"); > WASM_PARSER_FAIL_IF(versionNumber != expectedVersionNumber, "unexpected version number ", versionNumber, " expected ", expectedVersionNumber); >@@ -102,7 +103,7 @@ auto ModuleParser::parseType() -> PartialResult > uint32_t count; > > WASM_PARSER_FAIL_IF(!parseVarUInt32(count), "can't get Type section's count"); >- WASM_PARSER_FAIL_IF(count == std::numeric_limits<uint32_t>::max(), "Type section's count is too big ", count); >+ WASM_PARSER_FAIL_IF(count > maxTypes, "Type section's count is too big ", count, " maximum ", maxTypes); > WASM_PARSER_FAIL_IF(!m_info->usedSignatures.tryReserveCapacity(count), "can't allocate enough memory for Type section's ", count, " entries"); > > for (uint32_t i = 0; i < count; ++i) { >@@ -113,7 +114,7 @@ auto ModuleParser::parseType() -> PartialResult > WASM_PARSER_FAIL_IF(!parseInt7(type), "can't get ", i, "th Type's type"); > WASM_PARSER_FAIL_IF(type != Func, i, "th Type is non-Func ", type); > WASM_PARSER_FAIL_IF(!parseVarUInt32(argumentCount), "can't get ", i, "th Type's argument count"); >- WASM_PARSER_FAIL_IF(argumentCount == std::numeric_limits<uint32_t>::max(), i, "th argument count is too big ", argumentCount); >+ WASM_PARSER_FAIL_IF(argumentCount > maxFunctionParams, i, "th argument count is too big ", argumentCount, " maximum ", maxFunctionParams); > RefPtr<Signature> maybeSignature = Signature::tryCreate(argumentCount); > WASM_PARSER_FAIL_IF(!maybeSignature, "can't allocate enough memory for Type section's ", i, "th signature"); > Ref<Signature> signature = maybeSignature.releaseNonNull(); >@@ -145,7 +146,7 @@ auto ModuleParser::parseImport() -> PartialResult > { > uint32_t importCount; > WASM_PARSER_FAIL_IF(!parseVarUInt32(importCount), "can't get Import section's count"); >- WASM_PARSER_FAIL_IF(importCount == std::numeric_limits<uint32_t>::max(), "Import section's count is too big ", importCount); >+ WASM_PARSER_FAIL_IF(importCount > maxImports, "Import section's count is too big ", importCount, " maximum ", maxImports); > WASM_PARSER_FAIL_IF(!m_info->globals.tryReserveCapacity(importCount), "can't allocate enough memory for ", importCount, " globals"); // FIXME this over-allocates when we fix the FIXMEs below. > WASM_PARSER_FAIL_IF(!m_info->imports.tryReserveCapacity(importCount), "can't allocate enough memory for ", importCount, " imports"); // FIXME this over-allocates when we fix the FIXMEs below. > WASM_PARSER_FAIL_IF(!m_info->importFunctionSignatureIndices.tryReserveCapacity(importCount), "can't allocate enough memory for ", importCount, " import function signatures"); // FIXME this over-allocates when we fix the FIXMEs below. >@@ -211,7 +212,7 @@ auto ModuleParser::parseFunction() -> PartialResult > { > uint32_t count; > WASM_PARSER_FAIL_IF(!parseVarUInt32(count), "can't get Function section's count"); >- WASM_PARSER_FAIL_IF(count == std::numeric_limits<uint32_t>::max(), "Function section's count is too big ", count); >+ WASM_PARSER_FAIL_IF(count > maxFunctions, "Function section's count is too big ", count, " maximum ", maxFunctions); > WASM_PARSER_FAIL_IF(!m_info->internalFunctionSignatureIndices.tryReserveCapacity(count), "can't allocate enough memory for ", count, " Function signatures"); > WASM_PARSER_FAIL_IF(!m_info->functionLocationInBinary.tryReserveCapacity(count), "can't allocate enough memory for ", count, "Function locations"); > >@@ -334,6 +335,7 @@ auto ModuleParser::parseGlobal() -> PartialResult > { > uint32_t globalCount; > WASM_PARSER_FAIL_IF(!parseVarUInt32(globalCount), "can't get Global section's count"); >+ WASM_PARSER_FAIL_IF(globalCount > maxGlobals, "Global section's count is too big ", globalCount, " maximum ", maxGlobals); > WASM_PARSER_FAIL_IF(!m_info->globals.tryReserveCapacity(globalCount + m_info->firstInternalGlobal), "can't allocate memory for ", globalCount + m_info->firstInternalGlobal, " globals"); > > for (uint32_t globalIndex = 0; globalIndex < globalCount; ++globalIndex) { >@@ -359,7 +361,7 @@ auto ModuleParser::parseExport() -> PartialResult > { > uint32_t exportCount; > WASM_PARSER_FAIL_IF(!parseVarUInt32(exportCount), "can't get Export section's count"); >- WASM_PARSER_FAIL_IF(exportCount == std::numeric_limits<uint32_t>::max(), "Export section's count is too big ", exportCount); >+ WASM_PARSER_FAIL_IF(exportCount > maxExports, "Export section's count is too big ", exportCount, " maximum ", maxExports); > WASM_PARSER_FAIL_IF(!m_info->exports.tryReserveCapacity(exportCount), "can't allocate enough memory for ", exportCount, " exports"); > > HashSet<String> exportNames; >@@ -424,7 +426,7 @@ auto ModuleParser::parseElement() -> PartialResult > > uint32_t elementCount; > WASM_PARSER_FAIL_IF(!parseVarUInt32(elementCount), "can't get Element section's count"); >- WASM_PARSER_FAIL_IF(elementCount == std::numeric_limits<uint32_t>::max(), "Element section's count is too big ", elementCount); >+ WASM_PARSER_FAIL_IF(elementCount > maxTableEntries, "Element section's count is too big ", elementCount, " maximum ", maxTableEntries); > WASM_PARSER_FAIL_IF(!m_info->elements.tryReserveCapacity(elementCount), "can't allocate memory for ", elementCount, " Elements"); > for (unsigned elementNum = 0; elementNum < elementCount; ++elementNum) { > uint32_t tableIndex; >@@ -471,6 +473,7 @@ auto ModuleParser::parseCode() -> PartialResult > WASM_PARSER_FAIL_IF(!parseVarUInt32(functionSize), "can't get ", i, "th Code function's size"); > WASM_PARSER_FAIL_IF(functionSize > length(), "Code function's size ", functionSize, " exceeds the module's size ", length()); > WASM_PARSER_FAIL_IF(functionSize > length() - m_offset, "Code function's size ", functionSize, " exceeds the module's remaining size", length() - m_offset); >+ WASM_PARSER_FAIL_IF(functionSize > std::numeric_limits<uint32_t>::max(), "Code function's size ", functionSize, " is too big"); > > m_info->functionLocationInBinary[i].start = m_offset; > m_info->functionLocationInBinary[i].end = m_offset + functionSize; >@@ -555,7 +558,7 @@ auto ModuleParser::parseData() -> PartialResult > uint32_t segmentCount; > WASM_PARSER_FAIL_IF(!m_info->memory, "Data section cannot exist without a Memory section or Import"); > WASM_PARSER_FAIL_IF(!parseVarUInt32(segmentCount), "can't get Data section's count"); >- WASM_PARSER_FAIL_IF(segmentCount == std::numeric_limits<uint32_t>::max(), "Data section's count is too big ", segmentCount); >+ WASM_PARSER_FAIL_IF(segmentCount > maxDataSegments, "Data section's count is too big ", segmentCount, " maximum ", maxDataSegments); > WASM_PARSER_FAIL_IF(!m_info->data.tryReserveCapacity(segmentCount), "can't allocate enough memory for Data section's ", segmentCount, " segments"); > > for (uint32_t segmentNumber = 0; segmentNumber < segmentCount; ++segmentNumber) { >diff --git a/Source/JavaScriptCore/wasm/WasmParser.h b/Source/JavaScriptCore/wasm/WasmParser.h >index c2a8c14..b8bf0c6 100644 >--- a/Source/JavaScriptCore/wasm/WasmParser.h >+++ b/Source/JavaScriptCore/wasm/WasmParser.h >@@ -30,6 +30,7 @@ > #include "B3Compilation.h" > #include "B3Procedure.h" > #include "WasmFormat.h" >+#include "WasmLimits.h" > #include "WasmModuleInformation.h" > #include "WasmOps.h" > #include "WasmSections.h" >@@ -146,6 +147,8 @@ ALWAYS_INLINE bool Parser<SuccessType>::consumeUTF8String(Name& result, size_t s > { > if (length() < stringLength || m_offset > length() - stringLength) > return false; >+ if (stringLength > maxStringSize) >+ return false; > if (!result.tryReserveCapacity(stringLength)) > return false; > >-- >2.9.3 > 1309064 10 310240 commit-queue 2017-05-16 01:17:30 -0700 Comment on attachment 310240 patch Rejecting attachment 310240 from commit-queue. Failed to run "['/Volumes/Data/EWS/WebKit/Tools/Scripts/webkit-patch', '--status-host=webkit-queues.webkit.org', '--bot-id=webkit-cq-01', 'validate-changelog', '--check-oops', '--non-interactive', 310240, '--port=mac']" exit_code: 1 cwd: /Volumes/Data/EWS/WebKit ChangeLog entry in Source/JavaScriptCore/ChangeLog contains OOPS!. Full output: http://webkit-queues.webkit.org/results/3749203 1309065 11 310242 jfbastien 2017-05-16 01:18:27 -0700 Created attachment 310242 patch Fix oops properly. 1309081 12 310242 commit-queue 2017-05-16 02:24:16 -0700 Comment on attachment 310242 patch Clearing flags on attachment: 310242 Committed r216921: <http://trac.webkit.org/changeset/216921> 1309082 13 commit-queue 2017-05-16 02:24:18 -0700 All reviewed patches have been landed. Closing bug. 1309199 14 310242 saam 2017-05-16 11:07:32 -0700 Comment on attachment 310242 patch View in context: https://bugs.webkit.org/attachment.cgi?id=310242&action=review > Source/JavaScriptCore/wasm/WasmLimits.h:45 > +constexpr size_t maxTypes = 1000000; > +constexpr size_t maxFunctions = 1000000; > +constexpr size_t maxImports = 100000; > +constexpr size_t maxExports = 100000; > +constexpr size_t maxGlobals = 1000000; > +constexpr size_t maxDataSegments = 100000; Some of these don't seem that big, are we sure we want to introduce this artificial limitation? 1309477 15 jfbastien 2017-05-16 22:49:36 -0700 (In reply to Saam Barati from comment #14) > Comment on attachment 310242 [details] > patch > > View in context: > https://bugs.webkit.org/attachment.cgi?id=310242&action=review > > > Source/JavaScriptCore/wasm/WasmLimits.h:45 > > +constexpr size_t maxTypes = 1000000; > > +constexpr size_t maxFunctions = 1000000; > > +constexpr size_t maxImports = 100000; > > +constexpr size_t maxExports = 100000; > > +constexpr size_t maxGlobals = 1000000; > > +constexpr size_t maxDataSegments = 100000; > > Some of these don't seem that big, are we sure we want to introduce this > artificial limitation? I'm happy to revisit, but we need to reach out to other browser folks who we agreed on these limits with. It's easy to bump them up for them I guess, but presumably they're not hitting the limits? 310233 2017-05-15 23:51:08 -0700 2017-05-16 00:32:03 -0700 patch 0001-WebAssembly-enforce-size-limits.patch text/plain 16242 jfbastien RnJvbSBhYjgxNjc5ZThlMjY1ZjY5ZGJlYWQ2YWE3NjY3YjM5Y2Q5NzdiMWQzIE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBNb24sIDE1IE1heSAyMDE3IDIzOjUwOjM3IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gV2ViQXNz ZW1ibHk6IGVuZm9yY2Ugc2l6ZSBsaW1pdHMKCi0tLQogU291cmNlL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZyAgICAgICAgICAgICAgICAgICAgfCAxNiArKysrKysrCiAuLi4vSmF2YVNjcmlwdENv cmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiAgICAgICB8ICA0ICsrCiBTb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtTGltaXRzLmggICAgICAgICAgICB8IDU2ICsrKysrKysrKysrKysr KysrKysrKysKIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3Bw ICAgIHwgMTcgKysrKy0tLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBhcnNlci5o ICAgICAgICAgICAgfCAgMyArKwogNSBmaWxlcyBjaGFuZ2VkLCA4OSBpbnNlcnRpb25zKCspLCA3 IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21MaW1pdHMuaAoKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFu Z2VMb2cgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCmluZGV4IDY5NTRkOWIuLmY3 Njk0YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDE3LTA1 LTE1ICBKRiBCYXN0aWVuICA8amZiYXN0aWVuQGFwcGxlLmNvbT4KKworICAgICAgICBXZWJBc3Nl bWJseTogZW5mb3JjZSBzaXplIGxpbWl0cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTY1ODMzCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS8yOTc2MDIx OT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVc2Ug dGhlIHNhbWUgbGltaXRzIGFzIFY4LgorCisgICAgICAgICogSmF2YVNjcmlwdENvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiB3YXNtL1dhc21MaW1pdHMuaDogQWRkZWQu CisgICAgICAgICogd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNwcDoKKyAgICAgICAgKiB3YXNtL1dh c21QYXJzZXIuaDoKKyAgICAgICAgKEpTQzo6V2FzbTo6UGFyc2VyPFN1Y2Nlc3NUeXBlPjo6Y29u c3VtZVVURjhTdHJpbmcpOgorCiAyMDE3LTA1LTE1ICBNYXJrIExhbSAgPG1hcmsubGFtQGFwcGxl LmNvbT4KIAogICAgICAgICBSb2xsaW5nIG91dCByMjE0MDM4IGFuZCByMjEzNjk3OiBDcmFzaGVz IHdoZW4gdXNpbmcgY29tcHV0ZWQgcHJvcGVydGllcyB3aXRoIHJlc3QgZGVzdHJ1Y3R1cmluZyBh bmQgb2JqZWN0IHNwcmVhZC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9KYXZh U2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggNThkMTgy OS4uMTlhYTZlNyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRD b3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTIwODAsNiArMjA4 MCw3IEBACiAJCUE3RkI2MTAwMTA0MEMzOEIwMDE3QTI4NiAvKiBQcm9wZXJ0eURlc2NyaXB0b3Iu aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEE3RkI2MDRC MTAzRjVFQUIwMDE3QTI4NiAvKiBQcm9wZXJ0eURlc2NyaXB0b3IuaCAqLzsgc2V0dGluZ3MgPSB7 QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlBN0ZDQzI2RDE3QTBCNkFBMDA3ODZE MUEgLyogRlRMU3dpdGNoQ2FzZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gQTdGQ0MyNkMxN0EwQjZBQTAwNzg2RDFBIC8qIEZUTFN3aXRjaENhc2UuaCAq Lzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlBOEE0NzQ4 RTE1MUE4MzA2MDA0MTIzRkYgLyogbGliV1RGLmEgaW4gRnJhbWV3b3JrcyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBOEE0NzQ4RDE1MUE4MzA2MDA0MTIzRkYgLyogbGliV1RG LmEgKi87IH07CisJCUFEMDA2NTlFMUVDQUM4MTIwMDBDQTkyNiAvKiBXYXNtTGltaXRzLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBRDAwNjU5RDFFQ0FD N0ZFMDAwQ0E5MjYgLyogV2FzbUxpbWl0cy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0g KFByaXZhdGUsICk7IH07IH07CiAJCUFEMkZDQkUyMURCNThEQUQwMEIzRTczNiAvKiBKU1dlYkFz c2VtYmx5Q29tcGlsZUVycm9yLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IEFEMkZDQkE2MURCNThEQTQwMEIzRTczNiAvKiBKU1dlYkFzc2VtYmx5Q29t cGlsZUVycm9yLmNwcCAqLzsgfTsKIAkJQUQyRkNCRTMxREI1OERBRDAwQjNFNzM2IC8qIEpTV2Vi QXNzZW1ibHlDb21waWxlRXJyb3IuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IEFEMkZDQkE3MURCNThEQTQwMEIzRTczNiAvKiBKU1dlYkFzc2VtYmx5Q29t cGlsZUVycm9yLmggKi87IH07CiAJCUFEMkZDQkU0MURCNThEQUQwMEIzRTczNiAvKiBKU1dlYkFz c2VtYmx5SW5zdGFuY2UuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gQUQyRkNCQTgxREI1OERBNDAwQjNFNzM2IC8qIEpTV2ViQXNzZW1ibHlJbnN0YW5j ZS5jcHAgKi87IH07CkBAIC00NzExLDYgKzQ3MTIsNyBAQAogCQlBOEE0NzQ4RDE1MUE4MzA2MDA0 MTIzRkYgLyogbGliV1RGLmEgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3du RmlsZVR5cGUgPSBhcmNoaXZlLmFyOyBwYXRoID0gbGliV1RGLmE7IHNvdXJjZVRyZWUgPSBCVUlM VF9QUk9EVUNUU19ESVI7IH07CiAJCUE4RTg5NDMxMENEMDYwMjQwMDM2NzE3OSAvKiBKU0NhbGxi YWNrT2JqZWN0RnVuY3Rpb25zLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpT Q2FsbGJhY2tPYmplY3RGdW5jdGlvbnMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ QThFODk0MzMwQ0QwNjAzRjAwMzY3MTc5IC8qIEpTR2xvYmFsT2JqZWN0LmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpTR2xvYmFsT2JqZWN0Lmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CisJCUFEMDA2NTlEMUVDQUM3RkUwMDBDQTkyNiAvKiBXYXNtTGltaXRzLmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdhc21MaW1pdHMuaDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJQUQxQ0YwNjgxNkRDQUIyRDAwQjk3MTIzIC8qIFByb3BlcnR5VGFi bGUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUHJvcGVydHlUYWJs ZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUFEMkZDQjhDMURCNTg0NDAwMEIz RTczNiAvKiBKU1dlYkFzc2VtYmx5TW9kdWxlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgbmFtZSA9IEpTV2ViQXNzZW1ibHlNb2R1bGUuY3BwOyBwYXRoID0ganMvSlNXZWJBc3Nl bWJseU1vZHVsZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUFEMkZDQjhEMURC NTg0NDAwMEIzRTczNiAvKiBKU1dlYkFzc2VtYmx5TW9kdWxlLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgbmFtZSA9IEpTV2ViQXNzZW1ibHlNb2R1bGUuaDsgcGF0aCA9IGpzL0pTV2ViQXNz ZW1ibHlNb2R1bGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTY0MzAsNiArNjQz Miw3IEBACiAJCQkJNTNGNDBFOEExRDU5MDFCQjAwOTlBMUI2IC8qIFdhc21GdW5jdGlvblBhcnNl ci5oICovLAogCQkJCUFEOEZGMzk2MUVCNUJEODUwMDg3RkY4MiAvKiBXYXNtSW5kZXhPck5hbWUu Y3BwICovLAogCQkJCUFEOEZGMzk1MUVCNUJEODUwMDg3RkY4MiAvKiBXYXNtSW5kZXhPck5hbWUu aCAqLywKKwkJCQlBRDAwNjU5RDFFQ0FDN0ZFMDAwQ0E5MjYgLyogV2FzbUxpbWl0cy5oICovLAog CQkJCTUzRTlFMEE5MUVBRTgzREUwMEZFRTI1MSAvKiBXYXNtTWFjaGluZVRocmVhZHMuY3BwICov LAogCQkJCTUzRTlFMEFBMUVBRTgzREUwMEZFRTI1MSAvKiBXYXNtTWFjaGluZVRocmVhZHMuaCAq LywKIAkJCQk1MzU1NTcxNTFEOURGQTMyMDA2RDU4M0IgLyogV2FzbU1lbW9yeS5jcHAgKi8sCkBA IC05NDY5LDYgKzk0NzIsNyBAQAogCQkJCTBGMUZCMzhGMUUxNzNBNjcwMEE5QkU1MCAvKiBTeW5j aHJvbm91c1N0b3BUaGVXb3JsZE11dGF0b3JTY2hlZHVsZXIuaCBpbiBIZWFkZXJzICovLAogCQkJ CUE3ODRBMjY0MTFEMTY2MjIwMDU3NzZBQyAvKiBTeW50YXhDaGVja2VyLmggaW4gSGVhZGVycyAq LywKIAkJCQlEQzc5OTc4MzFDREU5RkEwMDA0RDRBMDkgLyogVGFnUmVnaXN0ZXJzTW9kZS5oIGlu IEhlYWRlcnMgKi8sCisJCQkJQUQwMDY1OUUxRUNBQzgxMjAwMENBOTI2IC8qIFdhc21MaW1pdHMu aCBpbiBIZWFkZXJzICovLAogCQkJCTcwRUNBNjA4MUFGREJFQTIwMDQ0OTczOSAvKiBUZW1wbGF0 ZVJlZ2lzdHJ5LmggaW4gSGVhZGVycyAqLywKIAkJCQk3MEVDQTYwOTFBRkRCRUEyMDA0NDk3Mzkg LyogVGVtcGxhdGVSZWdpc3RyeUtleS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJOTVENDI2MUFGNEM4 NENFMkFDQkFDOTgxIC8qIFRlbXBsYXRlUmVnaXN0cnlLZXlUYWJsZS5oIGluIEhlYWRlcnMgKi8s CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTGltaXRzLmggYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTGltaXRzLmgKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMC4uZjQ1Y2Q4ZgotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21MaW1pdHMuaApAQCAtMCwwICsxLDU2IEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDE3IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2Ug dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4K KyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycn IEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwK KyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNpZiBF TkFCTEUoV0VCQVNTRU1CTFkpCisKKyNpbmNsdWRlIDxjc3RkaW50PgorCituYW1lc3BhY2UgSlND IHsKKworbmFtZXNwYWNlIFdhc20geworCisvLyBUaGVzZSBsaW1pdHMgYXJlIGFyYml0cmFyeSBl eGNlcHQgdGhhdCB0aGV5IG1hdGNoIHRoZSBsaW1pdHMgaW1wb3NlZAorLy8gYnkgb3RoZXIgYnJv d3NlcnMnIGltcGxlbWVudGF0aW9uIG9mIFdlYkFzc2VtYmx5LiBJdCBpcyBkZXNpcmFibGUgZm9y CisvLyB1cyB0byBhY2NlcHQgYXQgbGVhc3QgdGhlIHNhbWUgaW5wdXRzLgorCitjb25zdGV4cHIg c2l6ZV90IG1heFR5cGVzID0gMTAwMDAwMDsKK2NvbnN0ZXhwciBzaXplX3QgbWF4RnVuY3Rpb25z ID0gMTAwMDAwMDsKK2NvbnN0ZXhwciBzaXplX3QgbWF4SW1wb3J0cyA9IDEwMDAwMDsKK2NvbnN0 ZXhwciBzaXplX3QgbWF4RXhwb3J0cyA9IDEwMDAwMDsKK2NvbnN0ZXhwciBzaXplX3QgbWF4R2xv YmFscyA9IDEwMDAwMDA7Citjb25zdGV4cHIgc2l6ZV90IG1heERhdGFTZWdtZW50cyA9IDEwMDAw MDsKKworY29uc3RleHByIHNpemVfdCBtYXhTdHJpbmdTaXplID0gMTAwMDAwOworY29uc3RleHBy IHNpemVfdCBtYXhNb2R1bGVTaXplID0gMTAyNCAqIDEwMjQgKiAxMDI0OworY29uc3RleHByIHNp emVfdCBtYXhGdW5jdGlvblNpemUgPSAxMjggKiAxMDI0OworY29uc3RleHByIHNpemVfdCBtYXhG dW5jdGlvblBhcmFtcyA9IDEwMDA7CisKK2NvbnN0ZXhwciBzaXplX3QgbWF4VGFibGVFbnRyaWVz ID0gMTAwMDAwMDA7CisKK30gfSAvLyBuYW1lc3BhY2UgSlNDOjpXYXNtCisKKyNlbmRpZiAvLyBF TkFCTEUoV0VCQVNTRU1CTFkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtTW9kdWxlUGFyc2VyLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21N b2R1bGVQYXJzZXIuY3BwCmluZGV4IDdhNmExZjUuLjBjODhjOWQgMTAwNjQ0Ci0tLSBhL1NvdXJj ZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCisrKyBiL1NvdXJjZS9K YXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCkBAIC01MSw2ICs1MSw3IEBA IGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZSgpIC0+IFJlc3VsdAogICAgIHVpbnQzMl90IHZlcnNp b25OdW1iZXI7CiAKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGxlbmd0aCgpIDwgbWluU2l6ZSwg ImV4cGVjdGVkIGEgbW9kdWxlIG9mIGF0IGxlYXN0ICIsIG1pblNpemUsICIgYnl0ZXMiKTsKKyAg ICBXQVNNX1BBUlNFUl9GQUlMX0lGKGxlbmd0aCgpID4gbWF4TW9kdWxlU2l6ZSwgIm1vZHVsZSBz aXplICIsIGxlbmd0aCgpLCAiIGlzIHRvbyBsYXJnZSwgbWF4aW11bSAiLCBtYXhNb2R1bGVTaXpl KTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFjb25zdW1lQ2hhcmFjdGVyKDApIHx8ICFjb25z dW1lU3RyaW5nKCJhc20iKSwgIm1vZHVsZXMgZG9lc24ndCBzdGFydCB3aXRoICdcXDBhc20nIik7 CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VVSW50MzIodmVyc2lvbk51bWJlciksICJj YW4ndCBwYXJzZSB2ZXJzaW9uIG51bWJlciIpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYodmVy c2lvbk51bWJlciAhPSBleHBlY3RlZFZlcnNpb25OdW1iZXIsICJ1bmV4cGVjdGVkIHZlcnNpb24g bnVtYmVyICIsIHZlcnNpb25OdW1iZXIsICIgZXhwZWN0ZWQgIiwgZXhwZWN0ZWRWZXJzaW9uTnVt YmVyKTsKQEAgLTEwMiw3ICsxMDMsNyBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VUeXBlKCkg LT4gUGFydGlhbFJlc3VsdAogICAgIHVpbnQzMl90IGNvdW50OwogCiAgICAgV0FTTV9QQVJTRVJf RkFJTF9JRighcGFyc2VWYXJVSW50MzIoY291bnQpLCAiY2FuJ3QgZ2V0IFR5cGUgc2VjdGlvbidz IGNvdW50Iik7Ci0gICAgV0FTTV9QQVJTRVJfRkFJTF9JRihjb3VudCA9PSBzdGQ6Om51bWVyaWNf bGltaXRzPHVpbnQzMl90Pjo6bWF4KCksICJUeXBlIHNlY3Rpb24ncyBjb3VudCBpcyB0b28gYmln ICIsIGNvdW50KTsKKyAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGNvdW50ID4gbWF4VHlwZXMsICJU eXBlIHNlY3Rpb24ncyBjb3VudCBpcyB0b28gYmlnICIsIGNvdW50LCAiIG1heGltdW0gIiwgbWF4 VHlwZXMpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1faW5mby0+dXNlZFNpZ25hdHVyZXMu dHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkg Zm9yIFR5cGUgc2VjdGlvbidzICIsIGNvdW50LCAiIGVudHJpZXMiKTsKIAogICAgIGZvciAodWlu dDMyX3QgaSA9IDA7IGkgPCBjb3VudDsgKytpKSB7CkBAIC0xMTMsNyArMTE0LDcgQEAgYXV0byBN b2R1bGVQYXJzZXI6OnBhcnNlVHlwZSgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgV0FTTV9Q QVJTRVJfRkFJTF9JRighcGFyc2VJbnQ3KHR5cGUpLCAiY2FuJ3QgZ2V0ICIsIGksICJ0aCBUeXBl J3MgdHlwZSIpOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHR5cGUgIT0gRnVuYywgaSwg InRoIFR5cGUgaXMgbm9uLUZ1bmMgIiwgdHlwZSk7CiAgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYoIXBhcnNlVmFyVUludDMyKGFyZ3VtZW50Q291bnQpLCAiY2FuJ3QgZ2V0ICIsIGksICJ0aCBU eXBlJ3MgYXJndW1lbnQgY291bnQiKTsKLSAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihhcmd1 bWVudENvdW50ID09IHN0ZDo6bnVtZXJpY19saW1pdHM8dWludDMyX3Q+OjptYXgoKSwgaSwgInRo IGFyZ3VtZW50IGNvdW50IGlzIHRvbyBiaWcgIiwgYXJndW1lbnRDb3VudCk7CisgICAgICAgIFdB U01fUEFSU0VSX0ZBSUxfSUYoYXJndW1lbnRDb3VudCA+IG1heEZ1bmN0aW9uUGFyYW1zLCBpLCAi dGggYXJndW1lbnQgY291bnQgaXMgdG9vIGJpZyAiLCBhcmd1bWVudENvdW50LCAiIG1heGltdW0g IiwgbWF4RnVuY3Rpb25QYXJhbXMpOwogICAgICAgICBSZWZQdHI8U2lnbmF0dXJlPiBtYXliZVNp Z25hdHVyZSA9IFNpZ25hdHVyZTo6dHJ5Q3JlYXRlKGFyZ3VtZW50Q291bnQpOwogICAgICAgICBX QVNNX1BBUlNFUl9GQUlMX0lGKCFtYXliZVNpZ25hdHVyZSwgImNhbid0IGFsbG9jYXRlIGVub3Vn aCBtZW1vcnkgZm9yIFR5cGUgc2VjdGlvbidzICIsIGksICJ0aCBzaWduYXR1cmUiKTsKICAgICAg ICAgUmVmPFNpZ25hdHVyZT4gc2lnbmF0dXJlID0gbWF5YmVTaWduYXR1cmUucmVsZWFzZU5vbk51 bGwoKTsKQEAgLTE0NSw3ICsxNDYsNyBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VJbXBvcnQo KSAtPiBQYXJ0aWFsUmVzdWx0CiB7CiAgICAgdWludDMyX3QgaW1wb3J0Q291bnQ7CiAgICAgV0FT TV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoaW1wb3J0Q291bnQpLCAiY2FuJ3QgZ2V0 IEltcG9ydCBzZWN0aW9uJ3MgY291bnQiKTsKLSAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGltcG9y dENvdW50ID09IHN0ZDo6bnVtZXJpY19saW1pdHM8dWludDMyX3Q+OjptYXgoKSwgIkltcG9ydCBz ZWN0aW9uJ3MgY291bnQgaXMgdG9vIGJpZyAiLCBpbXBvcnRDb3VudCk7CisgICAgV0FTTV9QQVJT RVJfRkFJTF9JRihpbXBvcnRDb3VudCA+IG1heEltcG9ydHMsICJJbXBvcnQgc2VjdGlvbidzIGNv dW50IGlzIHRvbyBiaWcgIiwgaW1wb3J0Q291bnQsICIgbWF4aW11bSAiLCBtYXhJbXBvcnRzKTsK ICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX2luZm8tPmdsb2JhbHMudHJ5UmVzZXJ2ZUNhcGFj aXR5KGltcG9ydENvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGlt cG9ydENvdW50LCAiIGdsb2JhbHMiKTsgLy8gRklYTUUgdGhpcyBvdmVyLWFsbG9jYXRlcyB3aGVu IHdlIGZpeCB0aGUgRklYTUVzIGJlbG93LgogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1faW5m by0+aW1wb3J0cy50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2Nh dGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgaW1wb3J0cyIpOyAvLyBGSVhN RSB0aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBGSVhNRXMgYmVsb3cuCiAgICAg V0FTTV9QQVJTRVJfRkFJTF9JRighbV9pbmZvLT5pbXBvcnRGdW5jdGlvblNpZ25hdHVyZUluZGlj ZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGltcG9ydENvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3Vn aCBtZW1vcnkgZm9yICIsIGltcG9ydENvdW50LCAiIGltcG9ydCBmdW5jdGlvbiBzaWduYXR1cmVz Iik7IC8vIEZJWE1FIHRoaXMgb3Zlci1hbGxvY2F0ZXMgd2hlbiB3ZSBmaXggdGhlIEZJWE1FcyBi ZWxvdy4KQEAgLTIxMSw3ICsyMTIsNyBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VGdW5jdGlv bigpIC0+IFBhcnRpYWxSZXN1bHQKIHsKICAgICB1aW50MzJfdCBjb3VudDsKICAgICBXQVNNX1BB UlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihjb3VudCksICJjYW4ndCBnZXQgRnVuY3Rpb24g c2VjdGlvbidzIGNvdW50Iik7Ci0gICAgV0FTTV9QQVJTRVJfRkFJTF9JRihjb3VudCA9PSBzdGQ6 Om51bWVyaWNfbGltaXRzPHVpbnQzMl90Pjo6bWF4KCksICJGdW5jdGlvbiBzZWN0aW9uJ3MgY291 bnQgaXMgdG9vIGJpZyAiLCBjb3VudCk7CisgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihjb3VudCA+ IG1heEZ1bmN0aW9ucywgIkZ1bmN0aW9uIHNlY3Rpb24ncyBjb3VudCBpcyB0b28gYmlnICIsIGNv dW50LCAiIG1heGltdW0gIiwgbWF4RnVuY3Rpb25zKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lG KCFtX2luZm8tPmludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnRyeVJlc2VydmVDYXBh Y2l0eShjb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBjb3VudCwg IiBGdW5jdGlvbiBzaWduYXR1cmVzIik7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9pbmZv LT5mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwgImNh bid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGNvdW50LCAiRnVuY3Rpb24gbG9jYXRp b25zIik7CiAKQEAgLTMzNCw2ICszMzUsNyBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VHbG9i YWwoKSAtPiBQYXJ0aWFsUmVzdWx0CiB7CiAgICAgdWludDMyX3QgZ2xvYmFsQ291bnQ7CiAgICAg V0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoZ2xvYmFsQ291bnQpLCAiY2FuJ3Qg Z2V0IEdsb2JhbCBzZWN0aW9uJ3MgY291bnQiKTsKKyAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGds b2JhbENvdW50ID4gbWF4R2xvYmFscywgIkdsb2JhbCBzZWN0aW9uJ3MgY291bnQgaXMgdG9vIGJp ZyAiLCBnbG9iYWxDb3VudCwgIiBtYXhpbXVtICIsIG1heEdsb2JhbHMpOwogICAgIFdBU01fUEFS U0VSX0ZBSUxfSUYoIW1faW5mby0+Z2xvYmFscy50cnlSZXNlcnZlQ2FwYWNpdHkoZ2xvYmFsQ291 bnQgKyBtX2luZm8tPmZpcnN0SW50ZXJuYWxHbG9iYWwpLCAiY2FuJ3QgYWxsb2NhdGUgbWVtb3J5 IGZvciAiLCBnbG9iYWxDb3VudCArIG1faW5mby0+Zmlyc3RJbnRlcm5hbEdsb2JhbCwgIiBnbG9i YWxzIik7CiAKICAgICBmb3IgKHVpbnQzMl90IGdsb2JhbEluZGV4ID0gMDsgZ2xvYmFsSW5kZXgg PCBnbG9iYWxDb3VudDsgKytnbG9iYWxJbmRleCkgewpAQCAtMzU5LDcgKzM2MSw3IEBAIGF1dG8g TW9kdWxlUGFyc2VyOjpwYXJzZUV4cG9ydCgpIC0+IFBhcnRpYWxSZXN1bHQKIHsKICAgICB1aW50 MzJfdCBleHBvcnRDb3VudDsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQz MihleHBvcnRDb3VudCksICJjYW4ndCBnZXQgRXhwb3J0IHNlY3Rpb24ncyBjb3VudCIpOwotICAg IFdBU01fUEFSU0VSX0ZBSUxfSUYoZXhwb3J0Q291bnQgPT0gc3RkOjpudW1lcmljX2xpbWl0czx1 aW50MzJfdD46Om1heCgpLCAiRXhwb3J0IHNlY3Rpb24ncyBjb3VudCBpcyB0b28gYmlnICIsIGV4 cG9ydENvdW50KTsKKyAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGV4cG9ydENvdW50ID4gbWF4RXhw b3J0cywgIkV4cG9ydCBzZWN0aW9uJ3MgY291bnQgaXMgdG9vIGJpZyAiLCBleHBvcnRDb3VudCwg IiBtYXhpbXVtICIsIG1heEV4cG9ydHMpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1faW5m by0+ZXhwb3J0cy50cnlSZXNlcnZlQ2FwYWNpdHkoZXhwb3J0Q291bnQpLCAiY2FuJ3QgYWxsb2Nh dGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgZXhwb3J0Q291bnQsICIgZXhwb3J0cyIpOwogCiAgICAg SGFzaFNldDxTdHJpbmc+IGV4cG9ydE5hbWVzOwpAQCAtNDI0LDcgKzQyNiw3IEBAIGF1dG8gTW9k dWxlUGFyc2VyOjpwYXJzZUVsZW1lbnQoKSAtPiBQYXJ0aWFsUmVzdWx0CiAKICAgICB1aW50MzJf dCBlbGVtZW50Q291bnQ7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIo ZWxlbWVudENvdW50KSwgImNhbid0IGdldCBFbGVtZW50IHNlY3Rpb24ncyBjb3VudCIpOwotICAg IFdBU01fUEFSU0VSX0ZBSUxfSUYoZWxlbWVudENvdW50ID09IHN0ZDo6bnVtZXJpY19saW1pdHM8 dWludDMyX3Q+OjptYXgoKSwgIkVsZW1lbnQgc2VjdGlvbidzIGNvdW50IGlzIHRvbyBiaWcgIiwg ZWxlbWVudENvdW50KTsKKyAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGVsZW1lbnRDb3VudCA+IG1h eFRhYmxlRW50cmllcywgIkVsZW1lbnQgc2VjdGlvbidzIGNvdW50IGlzIHRvbyBiaWcgIiwgZWxl bWVudENvdW50LCAiIG1heGltdW0gIiwgbWF4VGFibGVFbnRyaWVzKTsKICAgICBXQVNNX1BBUlNF Ul9GQUlMX0lGKCFtX2luZm8tPmVsZW1lbnRzLnRyeVJlc2VydmVDYXBhY2l0eShlbGVtZW50Q291 bnQpLCAiY2FuJ3QgYWxsb2NhdGUgbWVtb3J5IGZvciAiLCBlbGVtZW50Q291bnQsICIgRWxlbWVu dHMiKTsKICAgICBmb3IgKHVuc2lnbmVkIGVsZW1lbnROdW0gPSAwOyBlbGVtZW50TnVtIDwgZWxl bWVudENvdW50OyArK2VsZW1lbnROdW0pIHsKICAgICAgICAgdWludDMyX3QgdGFibGVJbmRleDsK QEAgLTQ3MSw2ICs0NzMsNyBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VDb2RlKCkgLT4gUGFy dGlhbFJlc3VsdAogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihm dW5jdGlvblNpemUpLCAiY2FuJ3QgZ2V0ICIsIGksICJ0aCBDb2RlIGZ1bmN0aW9uJ3Mgc2l6ZSIp OwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGZ1bmN0aW9uU2l6ZSA+IGxlbmd0aCgpLCAi Q29kZSBmdW5jdGlvbidzIHNpemUgIiwgZnVuY3Rpb25TaXplLCAiIGV4Y2VlZHMgdGhlIG1vZHVs ZSdzIHNpemUgIiwgbGVuZ3RoKCkpOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGZ1bmN0 aW9uU2l6ZSA+IGxlbmd0aCgpIC0gbV9vZmZzZXQsICJDb2RlIGZ1bmN0aW9uJ3Mgc2l6ZSAiLCBm dW5jdGlvblNpemUsICIgZXhjZWVkcyB0aGUgbW9kdWxlJ3MgcmVtYWluaW5nIHNpemUiLCBsZW5n dGgoKSAtIG1fb2Zmc2V0KTsKKyAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvblNp emUgPiBtYXhGdW5jdGlvblNpemUsICJDb2RlIGZ1bmN0aW9uJ3Mgc2l6ZSAiLCBmdW5jdGlvblNp emUsICIgaXMgdG9vIGJpZywgbWF4aW11bSAiLCBtYXhGdW5jdGlvblNpemUpOwogCiAgICAgICAg IG1faW5mby0+ZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5W2ldLnN0YXJ0ID0gbV9vZmZzZXQ7CiAg ICAgICAgIG1faW5mby0+ZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5W2ldLmVuZCA9IG1fb2Zmc2V0 ICsgZnVuY3Rpb25TaXplOwpAQCAtNTU1LDcgKzU1OCw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpw YXJzZURhdGEoKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgdWludDMyX3Qgc2VnbWVudENvdW50Owog ICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1faW5mby0+bWVtb3J5LCAiRGF0YSBzZWN0aW9uIGNh bm5vdCBleGlzdCB3aXRob3V0IGEgTWVtb3J5IHNlY3Rpb24gb3IgSW1wb3J0Iik7CiAgICAgV0FT TV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoc2VnbWVudENvdW50KSwgImNhbid0IGdl dCBEYXRhIHNlY3Rpb24ncyBjb3VudCIpOwotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc2VnbWVu dENvdW50ID09IHN0ZDo6bnVtZXJpY19saW1pdHM8dWludDMyX3Q+OjptYXgoKSwgIkRhdGEgc2Vj dGlvbidzIGNvdW50IGlzIHRvbyBiaWcgIiwgc2VnbWVudENvdW50KTsKKyAgICBXQVNNX1BBUlNF Ul9GQUlMX0lGKHNlZ21lbnRDb3VudCA+IG1heERhdGFTZWdtZW50cywgIkRhdGEgc2VjdGlvbidz IGNvdW50IGlzIHRvbyBiaWcgIiwgc2VnbWVudENvdW50LCAiIG1heGltdW0gIiwgbWF4RGF0YVNl Z21lbnRzKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX2luZm8tPmRhdGEudHJ5UmVzZXJ2 ZUNhcGFjaXR5KHNlZ21lbnRDb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZv ciBEYXRhIHNlY3Rpb24ncyAiLCBzZWdtZW50Q291bnQsICIgc2VnbWVudHMiKTsKIAogICAgIGZv ciAodWludDMyX3Qgc2VnbWVudE51bWJlciA9IDA7IHNlZ21lbnROdW1iZXIgPCBzZWdtZW50Q291 bnQ7ICsrc2VnbWVudE51bWJlcikgewpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3Jl L3dhc20vV2FzbVBhcnNlci5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBhcnNl ci5oCmluZGV4IGMyYThjMTQuLmI4YmYwYzYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0 Q29yZS93YXNtL1dhc21QYXJzZXIuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9X YXNtUGFyc2VyLmgKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlICJCM0NvbXBpbGF0aW9uLmgi CiAjaW5jbHVkZSAiQjNQcm9jZWR1cmUuaCIKICNpbmNsdWRlICJXYXNtRm9ybWF0LmgiCisjaW5j bHVkZSAiV2FzbUxpbWl0cy5oIgogI2luY2x1ZGUgIldhc21Nb2R1bGVJbmZvcm1hdGlvbi5oIgog I2luY2x1ZGUgIldhc21PcHMuaCIKICNpbmNsdWRlICJXYXNtU2VjdGlvbnMuaCIKQEAgLTE0Niw2 ICsxNDcsOCBAQCBBTFdBWVNfSU5MSU5FIGJvb2wgUGFyc2VyPFN1Y2Nlc3NUeXBlPjo6Y29uc3Vt ZVVURjhTdHJpbmcoTmFtZSYgcmVzdWx0LCBzaXplX3QgcwogewogICAgIGlmIChsZW5ndGgoKSA8 IHN0cmluZ0xlbmd0aCB8fCBtX29mZnNldCA+IGxlbmd0aCgpIC0gc3RyaW5nTGVuZ3RoKQogICAg ICAgICByZXR1cm4gZmFsc2U7CisgICAgaWYgKHN0cmluZ0xlbmd0aCA+IG1heFN0cmluZ1NpemUp CisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICBpZiAoIXJlc3VsdC50cnlSZXNlcnZlQ2FwYWNp dHkoc3RyaW5nTGVuZ3RoKSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwogCi0tIAoyLjkuMwoK 310240 2017-05-16 00:32:03 -0700 2017-05-16 01:18:27 -0700 patch 0001-WebAssembly-enforce-size-limits.patch text/plain 16188 jfbastien RnJvbSAzZDQ0YTNlZTFkYzFmOWRkMjBiZDFkYzI1ODhjNDJhYzcwZTNmNDI0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBNb24sIDE1IE1heSAyMDE3IDIzOjUwOjM3IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gV2ViQXNz ZW1ibHk6IGVuZm9yY2Ugc2l6ZSBsaW1pdHMKCi0tLQogU291cmNlL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZyAgICAgICAgICAgICAgICAgICAgfCAxNiArKysrKysrCiAuLi4vSmF2YVNjcmlwdENv cmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiAgICAgICB8ICA0ICsrCiBTb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtTGltaXRzLmggICAgICAgICAgICB8IDU1ICsrKysrKysrKysrKysr KysrKysrKysKIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3Bw ICAgIHwgMTcgKysrKy0tLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBhcnNlci5o ICAgICAgICAgICAgfCAgMyArKwogNSBmaWxlcyBjaGFuZ2VkLCA4OCBpbnNlcnRpb25zKCspLCA3 IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21MaW1pdHMuaAoKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFu Z2VMb2cgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCmluZGV4IDY5NTRkOWIuLmY3 Njk0YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDE3LTA1 LTE1ICBKRiBCYXN0aWVuICA8amZiYXN0aWVuQGFwcGxlLmNvbT4KKworICAgICAgICBXZWJBc3Nl bWJseTogZW5mb3JjZSBzaXplIGxpbWl0cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTY1ODMzCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS8yOTc2MDIx OT4KKworICAgICAgICBSZXZpZXdlZCBieSBOT0JPRFkgKE9PUFMhKS4KKworICAgICAgICBVc2Ug dGhlIHNhbWUgbGltaXRzIGFzIFY4LgorCisgICAgICAgICogSmF2YVNjcmlwdENvcmUueGNvZGVw cm9qL3Byb2plY3QucGJ4cHJvajoKKyAgICAgICAgKiB3YXNtL1dhc21MaW1pdHMuaDogQWRkZWQu CisgICAgICAgICogd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNwcDoKKyAgICAgICAgKiB3YXNtL1dh c21QYXJzZXIuaDoKKyAgICAgICAgKEpTQzo6V2FzbTo6UGFyc2VyPFN1Y2Nlc3NUeXBlPjo6Y29u c3VtZVVURjhTdHJpbmcpOgorCiAyMDE3LTA1LTE1ICBNYXJrIExhbSAgPG1hcmsubGFtQGFwcGxl LmNvbT4KIAogICAgICAgICBSb2xsaW5nIG91dCByMjE0MDM4IGFuZCByMjEzNjk3OiBDcmFzaGVz IHdoZW4gdXNpbmcgY29tcHV0ZWQgcHJvcGVydGllcyB3aXRoIHJlc3QgZGVzdHJ1Y3R1cmluZyBh bmQgb2JqZWN0IHNwcmVhZC4KZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9KYXZh U2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qIGIvU291cmNlL0phdmFTY3JpcHRD b3JlL0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKaW5kZXggNThkMTgy OS4uMTlhYTZlNyAxMDA2NDQKLS0tIGEvU291cmNlL0phdmFTY3JpcHRDb3JlL0phdmFTY3JpcHRD b3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3Jl L0phdmFTY3JpcHRDb3JlLnhjb2RlcHJvai9wcm9qZWN0LnBieHByb2oKQEAgLTIwODAsNiArMjA4 MCw3IEBACiAJCUE3RkI2MTAwMTA0MEMzOEIwMDE3QTI4NiAvKiBQcm9wZXJ0eURlc2NyaXB0b3Iu aCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmlsZVJlZiA9IEE3RkI2MDRC MTAzRjVFQUIwMDE3QTI4NiAvKiBQcm9wZXJ0eURlc2NyaXB0b3IuaCAqLzsgc2V0dGluZ3MgPSB7 QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlBN0ZDQzI2RDE3QTBCNkFBMDA3ODZE MUEgLyogRlRMU3dpdGNoQ2FzZS5oIGluIEhlYWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxl OyBmaWxlUmVmID0gQTdGQ0MyNkMxN0EwQjZBQTAwNzg2RDFBIC8qIEZUTFN3aXRjaENhc2UuaCAq Lzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQcml2YXRlLCApOyB9OyB9OwogCQlBOEE0NzQ4 RTE1MUE4MzA2MDA0MTIzRkYgLyogbGliV1RGLmEgaW4gRnJhbWV3b3JrcyAqLyA9IHtpc2EgPSBQ QlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBOEE0NzQ4RDE1MUE4MzA2MDA0MTIzRkYgLyogbGliV1RG LmEgKi87IH07CisJCUFEMDA2NTlFMUVDQUM4MTIwMDBDQTkyNiAvKiBXYXNtTGltaXRzLmggaW4g SGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBRDAwNjU5RDFFQ0FD N0ZFMDAwQ0E5MjYgLyogV2FzbUxpbWl0cy5oICovOyBzZXR0aW5ncyA9IHtBVFRSSUJVVEVTID0g KFByaXZhdGUsICk7IH07IH07CiAJCUFEMkZDQkUyMURCNThEQUQwMEIzRTczNiAvKiBKU1dlYkFz c2VtYmx5Q29tcGlsZUVycm9yLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IEFEMkZDQkE2MURCNThEQTQwMEIzRTczNiAvKiBKU1dlYkFzc2VtYmx5Q29t cGlsZUVycm9yLmNwcCAqLzsgfTsKIAkJQUQyRkNCRTMxREI1OERBRDAwQjNFNzM2IC8qIEpTV2Vi QXNzZW1ibHlDb21waWxlRXJyb3IuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmls ZTsgZmlsZVJlZiA9IEFEMkZDQkE3MURCNThEQTQwMEIzRTczNiAvKiBKU1dlYkFzc2VtYmx5Q29t cGlsZUVycm9yLmggKi87IH07CiAJCUFEMkZDQkU0MURCNThEQUQwMEIzRTczNiAvKiBKU1dlYkFz c2VtYmx5SW5zdGFuY2UuY3BwIGluIFNvdXJjZXMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBm aWxlUmVmID0gQUQyRkNCQTgxREI1OERBNDAwQjNFNzM2IC8qIEpTV2ViQXNzZW1ibHlJbnN0YW5j ZS5jcHAgKi87IH07CkBAIC00NzExLDYgKzQ3MTIsNyBAQAogCQlBOEE0NzQ4RDE1MUE4MzA2MDA0 MTIzRkYgLyogbGliV1RGLmEgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgbGFzdEtub3du RmlsZVR5cGUgPSBhcmNoaXZlLmFyOyBwYXRoID0gbGliV1RGLmE7IHNvdXJjZVRyZWUgPSBCVUlM VF9QUk9EVUNUU19ESVI7IH07CiAJCUE4RTg5NDMxMENEMDYwMjQwMDM2NzE3OSAvKiBKU0NhbGxi YWNrT2JqZWN0RnVuY3Rpb25zLmggKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVu Y29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpT Q2FsbGJhY2tPYmplY3RGdW5jdGlvbnMuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKIAkJ QThFODk0MzMwQ0QwNjAzRjAwMzY3MTc5IC8qIEpTR2xvYmFsT2JqZWN0LmggKi8gPSB7aXNhID0g UEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBz b3VyY2Vjb2RlLmMuaDsgcGF0aCA9IEpTR2xvYmFsT2JqZWN0Lmg7IHNvdXJjZVRyZWUgPSAiPGdy b3VwPiI7IH07CisJCUFEMDA2NTlEMUVDQUM3RkUwMDBDQTkyNiAvKiBXYXNtTGltaXRzLmggKi8g PSB7aXNhID0gUEJYRmlsZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmls ZVR5cGUgPSBzb3VyY2Vjb2RlLmMuaDsgcGF0aCA9IFdhc21MaW1pdHMuaDsgc291cmNlVHJlZSA9 ICI8Z3JvdXA+IjsgfTsKIAkJQUQxQ0YwNjgxNkRDQUIyRDAwQjk3MTIzIC8qIFByb3BlcnR5VGFi bGUuY3BwICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxh c3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jcHAuY3BwOyBwYXRoID0gUHJvcGVydHlUYWJs ZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUFEMkZDQjhDMURCNTg0NDAwMEIz RTczNiAvKiBKU1dlYkFzc2VtYmx5TW9kdWxlLmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJl bmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3Bw LmNwcDsgbmFtZSA9IEpTV2ViQXNzZW1ibHlNb2R1bGUuY3BwOyBwYXRoID0ganMvSlNXZWJBc3Nl bWJseU1vZHVsZS5jcHA7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUFEMkZDQjhEMURC NTg0NDAwMEIzRTczNiAvKiBKU1dlYkFzc2VtYmx5TW9kdWxlLmggKi8gPSB7aXNhID0gUEJYRmls ZVJlZmVyZW5jZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vj b2RlLmMuaDsgbmFtZSA9IEpTV2ViQXNzZW1ibHlNb2R1bGUuaDsgcGF0aCA9IGpzL0pTV2ViQXNz ZW1ibHlNb2R1bGUuaDsgc291cmNlVHJlZSA9ICI8Z3JvdXA+IjsgfTsKQEAgLTY0MzAsNiArNjQz Miw3IEBACiAJCQkJNTNGNDBFOEExRDU5MDFCQjAwOTlBMUI2IC8qIFdhc21GdW5jdGlvblBhcnNl ci5oICovLAogCQkJCUFEOEZGMzk2MUVCNUJEODUwMDg3RkY4MiAvKiBXYXNtSW5kZXhPck5hbWUu Y3BwICovLAogCQkJCUFEOEZGMzk1MUVCNUJEODUwMDg3RkY4MiAvKiBXYXNtSW5kZXhPck5hbWUu aCAqLywKKwkJCQlBRDAwNjU5RDFFQ0FDN0ZFMDAwQ0E5MjYgLyogV2FzbUxpbWl0cy5oICovLAog CQkJCTUzRTlFMEE5MUVBRTgzREUwMEZFRTI1MSAvKiBXYXNtTWFjaGluZVRocmVhZHMuY3BwICov LAogCQkJCTUzRTlFMEFBMUVBRTgzREUwMEZFRTI1MSAvKiBXYXNtTWFjaGluZVRocmVhZHMuaCAq LywKIAkJCQk1MzU1NTcxNTFEOURGQTMyMDA2RDU4M0IgLyogV2FzbU1lbW9yeS5jcHAgKi8sCkBA IC05NDY5LDYgKzk0NzIsNyBAQAogCQkJCTBGMUZCMzhGMUUxNzNBNjcwMEE5QkU1MCAvKiBTeW5j aHJvbm91c1N0b3BUaGVXb3JsZE11dGF0b3JTY2hlZHVsZXIuaCBpbiBIZWFkZXJzICovLAogCQkJ CUE3ODRBMjY0MTFEMTY2MjIwMDU3NzZBQyAvKiBTeW50YXhDaGVja2VyLmggaW4gSGVhZGVycyAq LywKIAkJCQlEQzc5OTc4MzFDREU5RkEwMDA0RDRBMDkgLyogVGFnUmVnaXN0ZXJzTW9kZS5oIGlu IEhlYWRlcnMgKi8sCisJCQkJQUQwMDY1OUUxRUNBQzgxMjAwMENBOTI2IC8qIFdhc21MaW1pdHMu aCBpbiBIZWFkZXJzICovLAogCQkJCTcwRUNBNjA4MUFGREJFQTIwMDQ0OTczOSAvKiBUZW1wbGF0 ZVJlZ2lzdHJ5LmggaW4gSGVhZGVycyAqLywKIAkJCQk3MEVDQTYwOTFBRkRCRUEyMDA0NDk3Mzkg LyogVGVtcGxhdGVSZWdpc3RyeUtleS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJOTVENDI2MUFGNEM4 NENFMkFDQkFDOTgxIC8qIFRlbXBsYXRlUmVnaXN0cnlLZXlUYWJsZS5oIGluIEhlYWRlcnMgKi8s CmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTGltaXRzLmggYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTGltaXRzLmgKbmV3IGZpbGUgbW9kZSAxMDA2 NDQKaW5kZXggMDAwMDAwMC4uOTJhNmU4NQotLS0gL2Rldi9udWxsCisrKyBiL1NvdXJjZS9KYXZh U2NyaXB0Q29yZS93YXNtL1dhc21MaW1pdHMuaApAQCAtMCwwICsxLDU1IEBACisvKgorICogQ29w eXJpZ2h0IChDKSAyMDE3IEFwcGxlIEluYy4gQWxsIHJpZ2h0cyByZXNlcnZlZC4KKyAqCisgKiBS ZWRpc3RyaWJ1dGlvbiBhbmQgdXNlIGluIHNvdXJjZSBhbmQgYmluYXJ5IGZvcm1zLCB3aXRoIG9y IHdpdGhvdXQKKyAqIG1vZGlmaWNhdGlvbiwgYXJlIHBlcm1pdHRlZCBwcm92aWRlZCB0aGF0IHRo ZSBmb2xsb3dpbmcgY29uZGl0aW9ucworICogYXJlIG1ldDoKKyAqIDEuIFJlZGlzdHJpYnV0aW9u cyBvZiBzb3VyY2UgY29kZSBtdXN0IHJldGFpbiB0aGUgYWJvdmUgY29weXJpZ2h0CisgKiAgICBu b3RpY2UsIHRoaXMgbGlzdCBvZiBjb25kaXRpb25zIGFuZCB0aGUgZm9sbG93aW5nIGRpc2NsYWlt ZXIuCisgKiAyLiBSZWRpc3RyaWJ1dGlvbnMgaW4gYmluYXJ5IGZvcm0gbXVzdCByZXByb2R1Y2Ug dGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9u cyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVyIGluIHRoZQorICogICAgZG9jdW1lbnRhdGlv biBhbmQvb3Igb3RoZXIgbWF0ZXJpYWxzIHByb3ZpZGVkIHdpdGggdGhlIGRpc3RyaWJ1dGlvbi4K KyAqCisgKiBUSElTIFNPRlRXQVJFIElTIFBST1ZJREVEIEJZIEFQUExFIElOQy4gYGBBUyBJUycn IEFORCBBTlkKKyAqIEVYUFJFU1MgT1IgSU1QTElFRCBXQVJSQU5USUVTLCBJTkNMVURJTkcsIEJV VCBOT1QgTElNSVRFRCBUTywgVEhFCisgKiBJTVBMSUVEIFdBUlJBTlRJRVMgT0YgTUVSQ0hBTlRB QklMSVRZIEFORCBGSVRORVNTIEZPUiBBIFBBUlRJQ1VMQVIKKyAqIFBVUlBPU0UgQVJFIERJU0NM QUlNRUQuICBJTiBOTyBFVkVOVCBTSEFMTCBBUFBMRSBJTkMuIE9SCisgKiBDT05UUklCVVRPUlMg QkUgTElBQkxFIEZPUiBBTlkgRElSRUNULCBJTkRJUkVDVCwgSU5DSURFTlRBTCwgU1BFQ0lBTCwK KyAqIEVYRU1QTEFSWSwgT1IgQ09OU0VRVUVOVElBTCBEQU1BR0VTIChJTkNMVURJTkcsIEJVVCBO T1QgTElNSVRFRCBUTywKKyAqIFBST0NVUkVNRU5UIE9GIFNVQlNUSVRVVEUgR09PRFMgT1IgU0VS VklDRVM7IExPU1MgT0YgVVNFLCBEQVRBLCBPUgorICogUFJPRklUUzsgT1IgQlVTSU5FU1MgSU5U RVJSVVBUSU9OKSBIT1dFVkVSIENBVVNFRCBBTkQgT04gQU5ZIFRIRU9SWQorICogT0YgTElBQklM SVRZLCBXSEVUSEVSIElOIENPTlRSQUNULCBTVFJJQ1QgTElBQklMSVRZLCBPUiBUT1JUCisgKiAo SU5DTFVESU5HIE5FR0xJR0VOQ0UgT1IgT1RIRVJXSVNFKSBBUklTSU5HIElOIEFOWSBXQVkgT1VU IE9GIFRIRSBVU0UKKyAqIE9GIFRISVMgU09GVFdBUkUsIEVWRU4gSUYgQURWSVNFRCBPRiBUSEUg UE9TU0lCSUxJVFkgT0YgU1VDSCBEQU1BR0UuCisgKi8KKworI3ByYWdtYSBvbmNlCisKKyNpZiBF TkFCTEUoV0VCQVNTRU1CTFkpCisKKyNpbmNsdWRlIDxjc3RkaW50PgorCituYW1lc3BhY2UgSlND IHsKKworbmFtZXNwYWNlIFdhc20geworCisvLyBUaGVzZSBsaW1pdHMgYXJlIGFyYml0cmFyeSBl eGNlcHQgdGhhdCB0aGV5IG1hdGNoIHRoZSBsaW1pdHMgaW1wb3NlZAorLy8gYnkgb3RoZXIgYnJv d3NlcnMnIGltcGxlbWVudGF0aW9uIG9mIFdlYkFzc2VtYmx5LiBJdCBpcyBkZXNpcmFibGUgZm9y CisvLyB1cyB0byBhY2NlcHQgYXQgbGVhc3QgdGhlIHNhbWUgaW5wdXRzLgorCitjb25zdGV4cHIg c2l6ZV90IG1heFR5cGVzID0gMTAwMDAwMDsKK2NvbnN0ZXhwciBzaXplX3QgbWF4RnVuY3Rpb25z ID0gMTAwMDAwMDsKK2NvbnN0ZXhwciBzaXplX3QgbWF4SW1wb3J0cyA9IDEwMDAwMDsKK2NvbnN0 ZXhwciBzaXplX3QgbWF4RXhwb3J0cyA9IDEwMDAwMDsKK2NvbnN0ZXhwciBzaXplX3QgbWF4R2xv YmFscyA9IDEwMDAwMDA7Citjb25zdGV4cHIgc2l6ZV90IG1heERhdGFTZWdtZW50cyA9IDEwMDAw MDsKKworY29uc3RleHByIHNpemVfdCBtYXhTdHJpbmdTaXplID0gMTAwMDAwOworY29uc3RleHBy IHNpemVfdCBtYXhNb2R1bGVTaXplID0gMTAyNCAqIDEwMjQgKiAxMDI0OworY29uc3RleHByIHNp emVfdCBtYXhGdW5jdGlvblBhcmFtcyA9IDEwMDA7CisKK2NvbnN0ZXhwciBzaXplX3QgbWF4VGFi bGVFbnRyaWVzID0gMTAwMDAwMDA7CisKK30gfSAvLyBuYW1lc3BhY2UgSlNDOjpXYXNtCisKKyNl bmRpZiAvLyBFTkFCTEUoV0VCQVNTRU1CTFkpCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNwcCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCmluZGV4IDdhNmExZjUuLjdkMDc1MDAgMTAwNjQ0Ci0t LSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCisrKyBi L1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3BwCkBAIC01MSw2 ICs1MSw3IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZSgpIC0+IFJlc3VsdAogICAgIHVpbnQz Ml90IHZlcnNpb25OdW1iZXI7CiAKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGxlbmd0aCgpIDwg bWluU2l6ZSwgImV4cGVjdGVkIGEgbW9kdWxlIG9mIGF0IGxlYXN0ICIsIG1pblNpemUsICIgYnl0 ZXMiKTsKKyAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGxlbmd0aCgpID4gbWF4TW9kdWxlU2l6ZSwg Im1vZHVsZSBzaXplICIsIGxlbmd0aCgpLCAiIGlzIHRvbyBsYXJnZSwgbWF4aW11bSAiLCBtYXhN b2R1bGVTaXplKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFjb25zdW1lQ2hhcmFjdGVyKDAp IHx8ICFjb25zdW1lU3RyaW5nKCJhc20iKSwgIm1vZHVsZXMgZG9lc24ndCBzdGFydCB3aXRoICdc XDBhc20nIik7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VVSW50MzIodmVyc2lvbk51 bWJlciksICJjYW4ndCBwYXJzZSB2ZXJzaW9uIG51bWJlciIpOwogICAgIFdBU01fUEFSU0VSX0ZB SUxfSUYodmVyc2lvbk51bWJlciAhPSBleHBlY3RlZFZlcnNpb25OdW1iZXIsICJ1bmV4cGVjdGVk IHZlcnNpb24gbnVtYmVyICIsIHZlcnNpb25OdW1iZXIsICIgZXhwZWN0ZWQgIiwgZXhwZWN0ZWRW ZXJzaW9uTnVtYmVyKTsKQEAgLTEwMiw3ICsxMDMsNyBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFy c2VUeXBlKCkgLT4gUGFydGlhbFJlc3VsdAogICAgIHVpbnQzMl90IGNvdW50OwogCiAgICAgV0FT TV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoY291bnQpLCAiY2FuJ3QgZ2V0IFR5cGUg c2VjdGlvbidzIGNvdW50Iik7Ci0gICAgV0FTTV9QQVJTRVJfRkFJTF9JRihjb3VudCA9PSBzdGQ6 Om51bWVyaWNfbGltaXRzPHVpbnQzMl90Pjo6bWF4KCksICJUeXBlIHNlY3Rpb24ncyBjb3VudCBp cyB0b28gYmlnICIsIGNvdW50KTsKKyAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGNvdW50ID4gbWF4 VHlwZXMsICJUeXBlIHNlY3Rpb24ncyBjb3VudCBpcyB0b28gYmlnICIsIGNvdW50LCAiIG1heGlt dW0gIiwgbWF4VHlwZXMpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1faW5mby0+dXNlZFNp Z25hdHVyZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3Vn aCBtZW1vcnkgZm9yIFR5cGUgc2VjdGlvbidzICIsIGNvdW50LCAiIGVudHJpZXMiKTsKIAogICAg IGZvciAodWludDMyX3QgaSA9IDA7IGkgPCBjb3VudDsgKytpKSB7CkBAIC0xMTMsNyArMTE0LDcg QEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlVHlwZSgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICAg ICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VJbnQ3KHR5cGUpLCAiY2FuJ3QgZ2V0ICIsIGks ICJ0aCBUeXBlJ3MgdHlwZSIpOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHR5cGUgIT0g RnVuYywgaSwgInRoIFR5cGUgaXMgbm9uLUZ1bmMgIiwgdHlwZSk7CiAgICAgICAgIFdBU01fUEFS U0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKGFyZ3VtZW50Q291bnQpLCAiY2FuJ3QgZ2V0ICIs IGksICJ0aCBUeXBlJ3MgYXJndW1lbnQgY291bnQiKTsKLSAgICAgICAgV0FTTV9QQVJTRVJfRkFJ TF9JRihhcmd1bWVudENvdW50ID09IHN0ZDo6bnVtZXJpY19saW1pdHM8dWludDMyX3Q+OjptYXgo KSwgaSwgInRoIGFyZ3VtZW50IGNvdW50IGlzIHRvbyBiaWcgIiwgYXJndW1lbnRDb3VudCk7Cisg ICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoYXJndW1lbnRDb3VudCA+IG1heEZ1bmN0aW9uUGFy YW1zLCBpLCAidGggYXJndW1lbnQgY291bnQgaXMgdG9vIGJpZyAiLCBhcmd1bWVudENvdW50LCAi IG1heGltdW0gIiwgbWF4RnVuY3Rpb25QYXJhbXMpOwogICAgICAgICBSZWZQdHI8U2lnbmF0dXJl PiBtYXliZVNpZ25hdHVyZSA9IFNpZ25hdHVyZTo6dHJ5Q3JlYXRlKGFyZ3VtZW50Q291bnQpOwog ICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtYXliZVNpZ25hdHVyZSwgImNhbid0IGFsbG9j YXRlIGVub3VnaCBtZW1vcnkgZm9yIFR5cGUgc2VjdGlvbidzICIsIGksICJ0aCBzaWduYXR1cmUi KTsKICAgICAgICAgUmVmPFNpZ25hdHVyZT4gc2lnbmF0dXJlID0gbWF5YmVTaWduYXR1cmUucmVs ZWFzZU5vbk51bGwoKTsKQEAgLTE0NSw3ICsxNDYsNyBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFy c2VJbXBvcnQoKSAtPiBQYXJ0aWFsUmVzdWx0CiB7CiAgICAgdWludDMyX3QgaW1wb3J0Q291bnQ7 CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoaW1wb3J0Q291bnQpLCAi Y2FuJ3QgZ2V0IEltcG9ydCBzZWN0aW9uJ3MgY291bnQiKTsKLSAgICBXQVNNX1BBUlNFUl9GQUlM X0lGKGltcG9ydENvdW50ID09IHN0ZDo6bnVtZXJpY19saW1pdHM8dWludDMyX3Q+OjptYXgoKSwg IkltcG9ydCBzZWN0aW9uJ3MgY291bnQgaXMgdG9vIGJpZyAiLCBpbXBvcnRDb3VudCk7CisgICAg V0FTTV9QQVJTRVJfRkFJTF9JRihpbXBvcnRDb3VudCA+IG1heEltcG9ydHMsICJJbXBvcnQgc2Vj dGlvbidzIGNvdW50IGlzIHRvbyBiaWcgIiwgaW1wb3J0Q291bnQsICIgbWF4aW11bSAiLCBtYXhJ bXBvcnRzKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX2luZm8tPmdsb2JhbHMudHJ5UmVz ZXJ2ZUNhcGFjaXR5KGltcG9ydENvdW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkg Zm9yICIsIGltcG9ydENvdW50LCAiIGdsb2JhbHMiKTsgLy8gRklYTUUgdGhpcyBvdmVyLWFsbG9j YXRlcyB3aGVuIHdlIGZpeCB0aGUgRklYTUVzIGJlbG93LgogICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYoIW1faW5mby0+aW1wb3J0cy50cnlSZXNlcnZlQ2FwYWNpdHkoaW1wb3J0Q291bnQpLCAiY2Fu J3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgaW1wb3J0Q291bnQsICIgaW1wb3J0cyIp OyAvLyBGSVhNRSB0aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBGSVhNRXMgYmVs b3cuCiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9pbmZvLT5pbXBvcnRGdW5jdGlvblNpZ25h dHVyZUluZGljZXMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGltcG9ydENvdW50KSwgImNhbid0IGFsbG9j YXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGltcG9ydENvdW50LCAiIGltcG9ydCBmdW5jdGlvbiBz aWduYXR1cmVzIik7IC8vIEZJWE1FIHRoaXMgb3Zlci1hbGxvY2F0ZXMgd2hlbiB3ZSBmaXggdGhl IEZJWE1FcyBiZWxvdy4KQEAgLTIxMSw3ICsyMTIsNyBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFy c2VGdW5jdGlvbigpIC0+IFBhcnRpYWxSZXN1bHQKIHsKICAgICB1aW50MzJfdCBjb3VudDsKICAg ICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihjb3VudCksICJjYW4ndCBnZXQg RnVuY3Rpb24gc2VjdGlvbidzIGNvdW50Iik7Ci0gICAgV0FTTV9QQVJTRVJfRkFJTF9JRihjb3Vu dCA9PSBzdGQ6Om51bWVyaWNfbGltaXRzPHVpbnQzMl90Pjo6bWF4KCksICJGdW5jdGlvbiBzZWN0 aW9uJ3MgY291bnQgaXMgdG9vIGJpZyAiLCBjb3VudCk7CisgICAgV0FTTV9QQVJTRVJfRkFJTF9J Rihjb3VudCA+IG1heEZ1bmN0aW9ucywgIkZ1bmN0aW9uIHNlY3Rpb24ncyBjb3VudCBpcyB0b28g YmlnICIsIGNvdW50LCAiIG1heGltdW0gIiwgbWF4RnVuY3Rpb25zKTsKICAgICBXQVNNX1BBUlNF Ul9GQUlMX0lGKCFtX2luZm8tPmludGVybmFsRnVuY3Rpb25TaWduYXR1cmVJbmRpY2VzLnRyeVJl c2VydmVDYXBhY2l0eShjb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciAi LCBjb3VudCwgIiBGdW5jdGlvbiBzaWduYXR1cmVzIik7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9J RighbV9pbmZvLT5mdW5jdGlvbkxvY2F0aW9uSW5CaW5hcnkudHJ5UmVzZXJ2ZUNhcGFjaXR5KGNv dW50KSwgImNhbid0IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGNvdW50LCAiRnVuY3Rp b24gbG9jYXRpb25zIik7CiAKQEAgLTMzNCw2ICszMzUsNyBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6 cGFyc2VHbG9iYWwoKSAtPiBQYXJ0aWFsUmVzdWx0CiB7CiAgICAgdWludDMyX3QgZ2xvYmFsQ291 bnQ7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoZ2xvYmFsQ291bnQp LCAiY2FuJ3QgZ2V0IEdsb2JhbCBzZWN0aW9uJ3MgY291bnQiKTsKKyAgICBXQVNNX1BBUlNFUl9G QUlMX0lGKGdsb2JhbENvdW50ID4gbWF4R2xvYmFscywgIkdsb2JhbCBzZWN0aW9uJ3MgY291bnQg aXMgdG9vIGJpZyAiLCBnbG9iYWxDb3VudCwgIiBtYXhpbXVtICIsIG1heEdsb2JhbHMpOwogICAg IFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1faW5mby0+Z2xvYmFscy50cnlSZXNlcnZlQ2FwYWNpdHko Z2xvYmFsQ291bnQgKyBtX2luZm8tPmZpcnN0SW50ZXJuYWxHbG9iYWwpLCAiY2FuJ3QgYWxsb2Nh dGUgbWVtb3J5IGZvciAiLCBnbG9iYWxDb3VudCArIG1faW5mby0+Zmlyc3RJbnRlcm5hbEdsb2Jh bCwgIiBnbG9iYWxzIik7CiAKICAgICBmb3IgKHVpbnQzMl90IGdsb2JhbEluZGV4ID0gMDsgZ2xv YmFsSW5kZXggPCBnbG9iYWxDb3VudDsgKytnbG9iYWxJbmRleCkgewpAQCAtMzU5LDcgKzM2MSw3 IEBAIGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUV4cG9ydCgpIC0+IFBhcnRpYWxSZXN1bHQKIHsK ICAgICB1aW50MzJfdCBleHBvcnRDb3VudDsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJz ZVZhclVJbnQzMihleHBvcnRDb3VudCksICJjYW4ndCBnZXQgRXhwb3J0IHNlY3Rpb24ncyBjb3Vu dCIpOwotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZXhwb3J0Q291bnQgPT0gc3RkOjpudW1lcmlj X2xpbWl0czx1aW50MzJfdD46Om1heCgpLCAiRXhwb3J0IHNlY3Rpb24ncyBjb3VudCBpcyB0b28g YmlnICIsIGV4cG9ydENvdW50KTsKKyAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGV4cG9ydENvdW50 ID4gbWF4RXhwb3J0cywgIkV4cG9ydCBzZWN0aW9uJ3MgY291bnQgaXMgdG9vIGJpZyAiLCBleHBv cnRDb3VudCwgIiBtYXhpbXVtICIsIG1heEV4cG9ydHMpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYoIW1faW5mby0+ZXhwb3J0cy50cnlSZXNlcnZlQ2FwYWNpdHkoZXhwb3J0Q291bnQpLCAiY2Fu J3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwgZXhwb3J0Q291bnQsICIgZXhwb3J0cyIp OwogCiAgICAgSGFzaFNldDxTdHJpbmc+IGV4cG9ydE5hbWVzOwpAQCAtNDI0LDcgKzQyNiw3IEBA IGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZUVsZW1lbnQoKSAtPiBQYXJ0aWFsUmVzdWx0CiAKICAg ICB1aW50MzJfdCBlbGVtZW50Q291bnQ7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VW YXJVSW50MzIoZWxlbWVudENvdW50KSwgImNhbid0IGdldCBFbGVtZW50IHNlY3Rpb24ncyBjb3Vu dCIpOwotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZWxlbWVudENvdW50ID09IHN0ZDo6bnVtZXJp Y19saW1pdHM8dWludDMyX3Q+OjptYXgoKSwgIkVsZW1lbnQgc2VjdGlvbidzIGNvdW50IGlzIHRv byBiaWcgIiwgZWxlbWVudENvdW50KTsKKyAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGVsZW1lbnRD b3VudCA+IG1heFRhYmxlRW50cmllcywgIkVsZW1lbnQgc2VjdGlvbidzIGNvdW50IGlzIHRvbyBi aWcgIiwgZWxlbWVudENvdW50LCAiIG1heGltdW0gIiwgbWF4VGFibGVFbnRyaWVzKTsKICAgICBX QVNNX1BBUlNFUl9GQUlMX0lGKCFtX2luZm8tPmVsZW1lbnRzLnRyeVJlc2VydmVDYXBhY2l0eShl bGVtZW50Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgbWVtb3J5IGZvciAiLCBlbGVtZW50Q291bnQs ICIgRWxlbWVudHMiKTsKICAgICBmb3IgKHVuc2lnbmVkIGVsZW1lbnROdW0gPSAwOyBlbGVtZW50 TnVtIDwgZWxlbWVudENvdW50OyArK2VsZW1lbnROdW0pIHsKICAgICAgICAgdWludDMyX3QgdGFi bGVJbmRleDsKQEAgLTQ3MSw2ICs0NzMsNyBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VDb2Rl KCkgLT4gUGFydGlhbFJlc3VsdAogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFwYXJzZVZh clVJbnQzMihmdW5jdGlvblNpemUpLCAiY2FuJ3QgZ2V0ICIsIGksICJ0aCBDb2RlIGZ1bmN0aW9u J3Mgc2l6ZSIpOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGZ1bmN0aW9uU2l6ZSA+IGxl bmd0aCgpLCAiQ29kZSBmdW5jdGlvbidzIHNpemUgIiwgZnVuY3Rpb25TaXplLCAiIGV4Y2VlZHMg dGhlIG1vZHVsZSdzIHNpemUgIiwgbGVuZ3RoKCkpOwogICAgICAgICBXQVNNX1BBUlNFUl9GQUlM X0lGKGZ1bmN0aW9uU2l6ZSA+IGxlbmd0aCgpIC0gbV9vZmZzZXQsICJDb2RlIGZ1bmN0aW9uJ3Mg c2l6ZSAiLCBmdW5jdGlvblNpemUsICIgZXhjZWVkcyB0aGUgbW9kdWxlJ3MgcmVtYWluaW5nIHNp emUiLCBsZW5ndGgoKSAtIG1fb2Zmc2V0KTsKKyAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihm dW5jdGlvblNpemUgPiBzdGQ6Om51bWVyaWNfbGltaXRzPHVpbnQzMl90Pjo6bWF4KCksICJDb2Rl IGZ1bmN0aW9uJ3Mgc2l6ZSAiLCBmdW5jdGlvblNpemUsICIgaXMgdG9vIGJpZyIpOwogCiAgICAg ICAgIG1faW5mby0+ZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5W2ldLnN0YXJ0ID0gbV9vZmZzZXQ7 CiAgICAgICAgIG1faW5mby0+ZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5W2ldLmVuZCA9IG1fb2Zm c2V0ICsgZnVuY3Rpb25TaXplOwpAQCAtNTU1LDcgKzU1OCw3IEBAIGF1dG8gTW9kdWxlUGFyc2Vy OjpwYXJzZURhdGEoKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgdWludDMyX3Qgc2VnbWVudENvdW50 OwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1faW5mby0+bWVtb3J5LCAiRGF0YSBzZWN0aW9u IGNhbm5vdCBleGlzdCB3aXRob3V0IGEgTWVtb3J5IHNlY3Rpb24gb3IgSW1wb3J0Iik7CiAgICAg V0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoc2VnbWVudENvdW50KSwgImNhbid0 IGdldCBEYXRhIHNlY3Rpb24ncyBjb3VudCIpOwotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoc2Vn bWVudENvdW50ID09IHN0ZDo6bnVtZXJpY19saW1pdHM8dWludDMyX3Q+OjptYXgoKSwgIkRhdGEg c2VjdGlvbidzIGNvdW50IGlzIHRvbyBiaWcgIiwgc2VnbWVudENvdW50KTsKKyAgICBXQVNNX1BB UlNFUl9GQUlMX0lGKHNlZ21lbnRDb3VudCA+IG1heERhdGFTZWdtZW50cywgIkRhdGEgc2VjdGlv bidzIGNvdW50IGlzIHRvbyBiaWcgIiwgc2VnbWVudENvdW50LCAiIG1heGltdW0gIiwgbWF4RGF0 YVNlZ21lbnRzKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX2luZm8tPmRhdGEudHJ5UmVz ZXJ2ZUNhcGFjaXR5KHNlZ21lbnRDb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5 IGZvciBEYXRhIHNlY3Rpb24ncyAiLCBzZWdtZW50Q291bnQsICIgc2VnbWVudHMiKTsKIAogICAg IGZvciAodWludDMyX3Qgc2VnbWVudE51bWJlciA9IDA7IHNlZ21lbnROdW1iZXIgPCBzZWdtZW50 Q291bnQ7ICsrc2VnbWVudE51bWJlcikgewpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbVBhcnNlci5oIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBh cnNlci5oCmluZGV4IGMyYThjMTQuLmI4YmYwYzYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2Ny aXB0Q29yZS93YXNtL1dhc21QYXJzZXIuaAorKysgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtUGFyc2VyLmgKQEAgLTMwLDYgKzMwLDcgQEAKICNpbmNsdWRlICJCM0NvbXBpbGF0aW9u LmgiCiAjaW5jbHVkZSAiQjNQcm9jZWR1cmUuaCIKICNpbmNsdWRlICJXYXNtRm9ybWF0LmgiCisj aW5jbHVkZSAiV2FzbUxpbWl0cy5oIgogI2luY2x1ZGUgIldhc21Nb2R1bGVJbmZvcm1hdGlvbi5o IgogI2luY2x1ZGUgIldhc21PcHMuaCIKICNpbmNsdWRlICJXYXNtU2VjdGlvbnMuaCIKQEAgLTE0 Niw2ICsxNDcsOCBAQCBBTFdBWVNfSU5MSU5FIGJvb2wgUGFyc2VyPFN1Y2Nlc3NUeXBlPjo6Y29u c3VtZVVURjhTdHJpbmcoTmFtZSYgcmVzdWx0LCBzaXplX3QgcwogewogICAgIGlmIChsZW5ndGgo KSA8IHN0cmluZ0xlbmd0aCB8fCBtX29mZnNldCA+IGxlbmd0aCgpIC0gc3RyaW5nTGVuZ3RoKQog ICAgICAgICByZXR1cm4gZmFsc2U7CisgICAgaWYgKHN0cmluZ0xlbmd0aCA+IG1heFN0cmluZ1Np emUpCisgICAgICAgIHJldHVybiBmYWxzZTsKICAgICBpZiAoIXJlc3VsdC50cnlSZXNlcnZlQ2Fw YWNpdHkoc3RyaW5nTGVuZ3RoKSkKICAgICAgICAgcmV0dXJuIGZhbHNlOwogCi0tIAoyLjkuMwoK 310242 2017-05-16 01:18:27 -0700 2017-05-16 02:24:16 -0700 patch 0001-WebAssembly-enforce-size-limits.patch text/plain 16186 jfbastien RnJvbSAzZDQ0YTNlZTFkYzFmOWRkMjBiZDFkYzI1ODhjNDJhYzcwZTNmNDI0IE1vbiBTZXAgMTcg MDA6MDA6MDAgMjAwMQpGcm9tOiBKRiBCYXN0aWVuIDxqZmJhc3RpZW5AYXBwbGUuY29tPgpEYXRl OiBNb24sIDE1IE1heSAyMDE3IDIzOjUwOjM3IC0wNzAwClN1YmplY3Q6IFtQQVRDSF0gV2ViQXNz ZW1ibHk6IGVuZm9yY2Ugc2l6ZSBsaW1pdHMKCi0tLQogU291cmNlL0phdmFTY3JpcHRDb3JlL0No YW5nZUxvZyAgICAgICAgICAgICAgICAgICAgfCAxNiArKysrKysrCiAuLi4vSmF2YVNjcmlwdENv cmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiAgICAgICB8ICA0ICsrCiBTb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtTGltaXRzLmggICAgICAgICAgICB8IDU1ICsrKysrKysrKysrKysr KysrKysrKysKIFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21Nb2R1bGVQYXJzZXIuY3Bw ICAgIHwgMTcgKysrKy0tLQogU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbVBhcnNlci5o ICAgICAgICAgICAgfCAgMyArKwogNSBmaWxlcyBjaGFuZ2VkLCA4OCBpbnNlcnRpb25zKCspLCA3 IGRlbGV0aW9ucygtKQogY3JlYXRlIG1vZGUgMTAwNjQ0IFNvdXJjZS9KYXZhU2NyaXB0Q29yZS93 YXNtL1dhc21MaW1pdHMuaAoKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFu Z2VMb2cgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvQ2hhbmdlTG9nCmluZGV4IDY5NTRkOWIuLmY3 Njk0YWYgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9DaGFuZ2VMb2cKKysrIGIv U291cmNlL0phdmFTY3JpcHRDb3JlL0NoYW5nZUxvZwpAQCAtMSwzICsxLDE5IEBACisyMDE3LTA1 LTE1ICBKRiBCYXN0aWVuICA8amZiYXN0aWVuQGFwcGxlLmNvbT4KKworICAgICAgICBXZWJBc3Nl bWJseTogZW5mb3JjZSBzaXplIGxpbWl0cworICAgICAgICBodHRwczovL2J1Z3Mud2Via2l0Lm9y Zy9zaG93X2J1Zy5jZ2k/aWQ9MTY1ODMzCisgICAgICAgIDxyZGFyOi8vcHJvYmxlbS8yOTc2MDIx OT4KKworICAgICAgICBSZXZpZXdlZCBieSBLZWl0aCBNaWxsZXIuCisKKyAgICAgICAgVXNlIHRo ZSBzYW1lIGxpbWl0cyBhcyBWOC4KKworICAgICAgICAqIEphdmFTY3JpcHRDb3JlLnhjb2RlcHJv ai9wcm9qZWN0LnBieHByb2o6CisgICAgICAgICogd2FzbS9XYXNtTGltaXRzLmg6IEFkZGVkLgor ICAgICAgICAqIHdhc20vV2FzbU1vZHVsZVBhcnNlci5jcHA6CisgICAgICAgICogd2FzbS9XYXNt UGFyc2VyLmg6CisgICAgICAgIChKU0M6Oldhc206OlBhcnNlcjxTdWNjZXNzVHlwZT46OmNvbnN1 bWVVVEY4U3RyaW5nKToKKwogMjAxNy0wNS0xNSAgTWFyayBMYW0gIDxtYXJrLmxhbUBhcHBsZS5j b20+CiAKICAgICAgICAgUm9sbGluZyBvdXQgcjIxNDAzOCBhbmQgcjIxMzY5NzogQ3Jhc2hlcyB3 aGVuIHVzaW5nIGNvbXB1dGVkIHByb3BlcnRpZXMgd2l0aCByZXN0IGRlc3RydWN0dXJpbmcgYW5k IG9iamVjdCBzcHJlYWQuCmRpZmYgLS1naXQgYS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvSmF2YVNj cmlwdENvcmUueGNvZGVwcm9qL3Byb2plY3QucGJ4cHJvaiBiL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS9KYXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCmluZGV4IDU4ZDE4Mjku LjE5YWE2ZTcgMTAwNjQ0Ci0tLSBhL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9KYXZhU2NyaXB0Q29y ZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCisrKyBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS9K YXZhU2NyaXB0Q29yZS54Y29kZXByb2ovcHJvamVjdC5wYnhwcm9qCkBAIC0yMDgwLDYgKzIwODAs NyBAQAogCQlBN0ZCNjEwMDEwNDBDMzhCMDAxN0EyODYgLyogUHJvcGVydHlEZXNjcmlwdG9yLmgg aW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7IGZpbGVSZWYgPSBBN0ZCNjA0QjEw M0Y1RUFCMDAxN0EyODYgLyogUHJvcGVydHlEZXNjcmlwdG9yLmggKi87IHNldHRpbmdzID0ge0FU VFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJQTdGQ0MyNkQxN0EwQjZBQTAwNzg2RDFB IC8qIEZUTFN3aXRjaENhc2UuaCBpbiBIZWFkZXJzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsg ZmlsZVJlZiA9IEE3RkNDMjZDMTdBMEI2QUEwMDc4NkQxQSAvKiBGVExTd2l0Y2hDYXNlLmggKi87 IHNldHRpbmdzID0ge0FUVFJJQlVURVMgPSAoUHJpdmF0ZSwgKTsgfTsgfTsKIAkJQThBNDc0OEUx NTFBODMwNjAwNDEyM0ZGIC8qIGxpYldURi5hIGluIEZyYW1ld29ya3MgKi8gPSB7aXNhID0gUEJY QnVpbGRGaWxlOyBmaWxlUmVmID0gQThBNDc0OEQxNTFBODMwNjAwNDEyM0ZGIC8qIGxpYldURi5h ICovOyB9OworCQlBRDAwNjU5RTFFQ0FDODEyMDAwQ0E5MjYgLyogV2FzbUxpbWl0cy5oIGluIEhl YWRlcnMgKi8gPSB7aXNhID0gUEJYQnVpbGRGaWxlOyBmaWxlUmVmID0gQUQwMDY1OUQxRUNBQzdG RTAwMENBOTI2IC8qIFdhc21MaW1pdHMuaCAqLzsgc2V0dGluZ3MgPSB7QVRUUklCVVRFUyA9IChQ cml2YXRlLCApOyB9OyB9OwogCQlBRDJGQ0JFMjFEQjU4REFEMDBCM0U3MzYgLyogSlNXZWJBc3Nl bWJseUNvbXBpbGVFcnJvci5jcHAgaW4gU291cmNlcyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBBRDJGQ0JBNjFEQjU4REE0MDBCM0U3MzYgLyogSlNXZWJBc3NlbWJseUNvbXBp bGVFcnJvci5jcHAgKi87IH07CiAJCUFEMkZDQkUzMURCNThEQUQwMEIzRTczNiAvKiBKU1dlYkFz c2VtYmx5Q29tcGlsZUVycm9yLmggaW4gSGVhZGVycyAqLyA9IHtpc2EgPSBQQlhCdWlsZEZpbGU7 IGZpbGVSZWYgPSBBRDJGQ0JBNzFEQjU4REE0MDBCM0U3MzYgLyogSlNXZWJBc3NlbWJseUNvbXBp bGVFcnJvci5oICovOyB9OwogCQlBRDJGQ0JFNDFEQjU4REFEMDBCM0U3MzYgLyogSlNXZWJBc3Nl bWJseUluc3RhbmNlLmNwcCBpbiBTb3VyY2VzICovID0ge2lzYSA9IFBCWEJ1aWxkRmlsZTsgZmls ZVJlZiA9IEFEMkZDQkE4MURCNThEQTQwMEIzRTczNiAvKiBKU1dlYkFzc2VtYmx5SW5zdGFuY2Uu Y3BwICovOyB9OwpAQCAtNDcxMSw2ICs0NzEyLDcgQEAKIAkJQThBNDc0OEQxNTFBODMwNjAwNDEy M0ZGIC8qIGxpYldURi5hICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGxhc3RLbm93bkZp bGVUeXBlID0gYXJjaGl2ZS5hcjsgcGF0aCA9IGxpYldURi5hOyBzb3VyY2VUcmVlID0gQlVJTFRf UFJPRFVDVFNfRElSOyB9OwogCQlBOEU4OTQzMTBDRDA2MDI0MDAzNjcxNzkgLyogSlNDYWxsYmFj a09iamVjdEZ1bmN0aW9ucy5oICovID0ge2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNv ZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBKU0Nh bGxiYWNrT2JqZWN0RnVuY3Rpb25zLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CiAJCUE4 RTg5NDMzMENEMDYwM0YwMDM2NzE3OSAvKiBKU0dsb2JhbE9iamVjdC5oICovID0ge2lzYSA9IFBC WEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291 cmNlY29kZS5jLmg7IHBhdGggPSBKU0dsb2JhbE9iamVjdC5oOyBzb3VyY2VUcmVlID0gIjxncm91 cD4iOyB9OworCQlBRDAwNjU5RDFFQ0FDN0ZFMDAwQ0E5MjYgLyogV2FzbUxpbWl0cy5oICovID0g e2lzYSA9IFBCWEZpbGVSZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVU eXBlID0gc291cmNlY29kZS5jLmg7IHBhdGggPSBXYXNtTGltaXRzLmg7IHNvdXJjZVRyZWUgPSAi PGdyb3VwPiI7IH07CiAJCUFEMUNGMDY4MTZEQ0FCMkQwMEI5NzEyMyAvKiBQcm9wZXJ0eVRhYmxl LmNwcCAqLyA9IHtpc2EgPSBQQlhGaWxlUmVmZXJlbmNlOyBmaWxlRW5jb2RpbmcgPSA0OyBsYXN0 S25vd25GaWxlVHlwZSA9IHNvdXJjZWNvZGUuY3BwLmNwcDsgcGF0aCA9IFByb3BlcnR5VGFibGUu Y3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBRDJGQ0I4QzFEQjU4NDQwMDBCM0U3 MzYgLyogSlNXZWJBc3NlbWJseU1vZHVsZS5jcHAgKi8gPSB7aXNhID0gUEJYRmlsZVJlZmVyZW5j ZTsgZmlsZUVuY29kaW5nID0gNDsgbGFzdEtub3duRmlsZVR5cGUgPSBzb3VyY2Vjb2RlLmNwcC5j cHA7IG5hbWUgPSBKU1dlYkFzc2VtYmx5TW9kdWxlLmNwcDsgcGF0aCA9IGpzL0pTV2ViQXNzZW1i bHlNb2R1bGUuY3BwOyBzb3VyY2VUcmVlID0gIjxncm91cD4iOyB9OwogCQlBRDJGQ0I4RDFEQjU4 NDQwMDBCM0U3MzYgLyogSlNXZWJBc3NlbWJseU1vZHVsZS5oICovID0ge2lzYSA9IFBCWEZpbGVS ZWZlcmVuY2U7IGZpbGVFbmNvZGluZyA9IDQ7IGxhc3RLbm93bkZpbGVUeXBlID0gc291cmNlY29k ZS5jLmg7IG5hbWUgPSBKU1dlYkFzc2VtYmx5TW9kdWxlLmg7IHBhdGggPSBqcy9KU1dlYkFzc2Vt Ymx5TW9kdWxlLmg7IHNvdXJjZVRyZWUgPSAiPGdyb3VwPiI7IH07CkBAIC02NDMwLDYgKzY0MzIs NyBAQAogCQkJCTUzRjQwRThBMUQ1OTAxQkIwMDk5QTFCNiAvKiBXYXNtRnVuY3Rpb25QYXJzZXIu aCAqLywKIAkJCQlBRDhGRjM5NjFFQjVCRDg1MDA4N0ZGODIgLyogV2FzbUluZGV4T3JOYW1lLmNw cCAqLywKIAkJCQlBRDhGRjM5NTFFQjVCRDg1MDA4N0ZGODIgLyogV2FzbUluZGV4T3JOYW1lLmgg Ki8sCisJCQkJQUQwMDY1OUQxRUNBQzdGRTAwMENBOTI2IC8qIFdhc21MaW1pdHMuaCAqLywKIAkJ CQk1M0U5RTBBOTFFQUU4M0RFMDBGRUUyNTEgLyogV2FzbU1hY2hpbmVUaHJlYWRzLmNwcCAqLywK IAkJCQk1M0U5RTBBQTFFQUU4M0RFMDBGRUUyNTEgLyogV2FzbU1hY2hpbmVUaHJlYWRzLmggKi8s CiAJCQkJNTM1NTU3MTUxRDlERkEzMjAwNkQ1ODNCIC8qIFdhc21NZW1vcnkuY3BwICovLApAQCAt OTQ2OSw2ICs5NDcyLDcgQEAKIAkJCQkwRjFGQjM4RjFFMTczQTY3MDBBOUJFNTAgLyogU3luY2hy b25vdXNTdG9wVGhlV29ybGRNdXRhdG9yU2NoZWR1bGVyLmggaW4gSGVhZGVycyAqLywKIAkJCQlB Nzg0QTI2NDExRDE2NjIyMDA1Nzc2QUMgLyogU3ludGF4Q2hlY2tlci5oIGluIEhlYWRlcnMgKi8s CiAJCQkJREM3OTk3ODMxQ0RFOUZBMDAwNEQ0QTA5IC8qIFRhZ1JlZ2lzdGVyc01vZGUuaCBpbiBI ZWFkZXJzICovLAorCQkJCUFEMDA2NTlFMUVDQUM4MTIwMDBDQTkyNiAvKiBXYXNtTGltaXRzLmgg aW4gSGVhZGVycyAqLywKIAkJCQk3MEVDQTYwODFBRkRCRUEyMDA0NDk3MzkgLyogVGVtcGxhdGVS ZWdpc3RyeS5oIGluIEhlYWRlcnMgKi8sCiAJCQkJNzBFQ0E2MDkxQUZEQkVBMjAwNDQ5NzM5IC8q IFRlbXBsYXRlUmVnaXN0cnlLZXkuaCBpbiBIZWFkZXJzICovLAogCQkJCTk1RDQyNjFBRjRDODRD RTJBQ0JBQzk4MSAvKiBUZW1wbGF0ZVJlZ2lzdHJ5S2V5VGFibGUuaCBpbiBIZWFkZXJzICovLApk aWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUxpbWl0cy5oIGIvU291 cmNlL0phdmFTY3JpcHRDb3JlL3dhc20vV2FzbUxpbWl0cy5oCm5ldyBmaWxlIG1vZGUgMTAwNjQ0 CmluZGV4IDAwMDAwMDAuLjkyYTZlODUKLS0tIC9kZXYvbnVsbAorKysgYi9Tb3VyY2UvSmF2YVNj cmlwdENvcmUvd2FzbS9XYXNtTGltaXRzLmgKQEAgLTAsMCArMSw1NSBAQAorLyoKKyAqIENvcHly aWdodCAoQykgMjAxNyBBcHBsZSBJbmMuIEFsbCByaWdodHMgcmVzZXJ2ZWQuCisgKgorICogUmVk aXN0cmlidXRpb24gYW5kIHVzZSBpbiBzb3VyY2UgYW5kIGJpbmFyeSBmb3Jtcywgd2l0aCBvciB3 aXRob3V0CisgKiBtb2RpZmljYXRpb24sIGFyZSBwZXJtaXR0ZWQgcHJvdmlkZWQgdGhhdCB0aGUg Zm9sbG93aW5nIGNvbmRpdGlvbnMKKyAqIGFyZSBtZXQ6CisgKiAxLiBSZWRpc3RyaWJ1dGlvbnMg b2Ygc291cmNlIGNvZGUgbXVzdCByZXRhaW4gdGhlIGFib3ZlIGNvcHlyaWdodAorICogICAgbm90 aWNlLCB0aGlzIGxpc3Qgb2YgY29uZGl0aW9ucyBhbmQgdGhlIGZvbGxvd2luZyBkaXNjbGFpbWVy LgorICogMi4gUmVkaXN0cmlidXRpb25zIGluIGJpbmFyeSBmb3JtIG11c3QgcmVwcm9kdWNlIHRo ZSBhYm92ZSBjb3B5cmlnaHQKKyAqICAgIG5vdGljZSwgdGhpcyBsaXN0IG9mIGNvbmRpdGlvbnMg YW5kIHRoZSBmb2xsb3dpbmcgZGlzY2xhaW1lciBpbiB0aGUKKyAqICAgIGRvY3VtZW50YXRpb24g YW5kL29yIG90aGVyIG1hdGVyaWFscyBwcm92aWRlZCB3aXRoIHRoZSBkaXN0cmlidXRpb24uCisg KgorICogVEhJUyBTT0ZUV0FSRSBJUyBQUk9WSURFRCBCWSBBUFBMRSBJTkMuIGBgQVMgSVMnJyBB TkQgQU5ZCisgKiBFWFBSRVNTIE9SIElNUExJRUQgV0FSUkFOVElFUywgSU5DTFVESU5HLCBCVVQg Tk9UIExJTUlURUQgVE8sIFRIRQorICogSU1QTElFRCBXQVJSQU5USUVTIE9GIE1FUkNIQU5UQUJJ TElUWSBBTkQgRklUTkVTUyBGT1IgQSBQQVJUSUNVTEFSCisgKiBQVVJQT1NFIEFSRSBESVNDTEFJ TUVELiAgSU4gTk8gRVZFTlQgU0hBTEwgQVBQTEUgSU5DLiBPUgorICogQ09OVFJJQlVUT1JTIEJF IExJQUJMRSBGT1IgQU5ZIERJUkVDVCwgSU5ESVJFQ1QsIElOQ0lERU5UQUwsIFNQRUNJQUwsCisg KiBFWEVNUExBUlksIE9SIENPTlNFUVVFTlRJQUwgREFNQUdFUyAoSU5DTFVESU5HLCBCVVQgTk9U IExJTUlURUQgVE8sCisgKiBQUk9DVVJFTUVOVCBPRiBTVUJTVElUVVRFIEdPT0RTIE9SIFNFUlZJ Q0VTOyBMT1NTIE9GIFVTRSwgREFUQSwgT1IKKyAqIFBST0ZJVFM7IE9SIEJVU0lORVNTIElOVEVS UlVQVElPTikgSE9XRVZFUiBDQVVTRUQgQU5EIE9OIEFOWSBUSEVPUlkKKyAqIE9GIExJQUJJTElU WSwgV0hFVEhFUiBJTiBDT05UUkFDVCwgU1RSSUNUIExJQUJJTElUWSwgT1IgVE9SVAorICogKElO Q0xVRElORyBORUdMSUdFTkNFIE9SIE9USEVSV0lTRSkgQVJJU0lORyBJTiBBTlkgV0FZIE9VVCBP RiBUSEUgVVNFCisgKiBPRiBUSElTIFNPRlRXQVJFLCBFVkVOIElGIEFEVklTRUQgT0YgVEhFIFBP U1NJQklMSVRZIE9GIFNVQ0ggREFNQUdFLgorICovCisKKyNwcmFnbWEgb25jZQorCisjaWYgRU5B QkxFKFdFQkFTU0VNQkxZKQorCisjaW5jbHVkZSA8Y3N0ZGludD4KKworbmFtZXNwYWNlIEpTQyB7 CisKK25hbWVzcGFjZSBXYXNtIHsKKworLy8gVGhlc2UgbGltaXRzIGFyZSBhcmJpdHJhcnkgZXhj ZXB0IHRoYXQgdGhleSBtYXRjaCB0aGUgbGltaXRzIGltcG9zZWQKKy8vIGJ5IG90aGVyIGJyb3dz ZXJzJyBpbXBsZW1lbnRhdGlvbiBvZiBXZWJBc3NlbWJseS4gSXQgaXMgZGVzaXJhYmxlIGZvcgor Ly8gdXMgdG8gYWNjZXB0IGF0IGxlYXN0IHRoZSBzYW1lIGlucHV0cy4KKworY29uc3RleHByIHNp emVfdCBtYXhUeXBlcyA9IDEwMDAwMDA7Citjb25zdGV4cHIgc2l6ZV90IG1heEZ1bmN0aW9ucyA9 IDEwMDAwMDA7Citjb25zdGV4cHIgc2l6ZV90IG1heEltcG9ydHMgPSAxMDAwMDA7Citjb25zdGV4 cHIgc2l6ZV90IG1heEV4cG9ydHMgPSAxMDAwMDA7Citjb25zdGV4cHIgc2l6ZV90IG1heEdsb2Jh bHMgPSAxMDAwMDAwOworY29uc3RleHByIHNpemVfdCBtYXhEYXRhU2VnbWVudHMgPSAxMDAwMDA7 CisKK2NvbnN0ZXhwciBzaXplX3QgbWF4U3RyaW5nU2l6ZSA9IDEwMDAwMDsKK2NvbnN0ZXhwciBz aXplX3QgbWF4TW9kdWxlU2l6ZSA9IDEwMjQgKiAxMDI0ICogMTAyNDsKK2NvbnN0ZXhwciBzaXpl X3QgbWF4RnVuY3Rpb25QYXJhbXMgPSAxMDAwOworCitjb25zdGV4cHIgc2l6ZV90IG1heFRhYmxl RW50cmllcyA9IDEwMDAwMDAwOworCit9IH0gLy8gbmFtZXNwYWNlIEpTQzo6V2FzbQorCisjZW5k aWYgLy8gRU5BQkxFKFdFQkFTU0VNQkxZKQpkaWZmIC0tZ2l0IGEvU291cmNlL0phdmFTY3JpcHRD b3JlL3dhc20vV2FzbU1vZHVsZVBhcnNlci5jcHAgYi9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2Fz bS9XYXNtTW9kdWxlUGFyc2VyLmNwcAppbmRleCA3YTZhMWY1Li43ZDA3NTAwIDEwMDY0NAotLS0g YS9Tb3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNwcAorKysgYi9T b3VyY2UvSmF2YVNjcmlwdENvcmUvd2FzbS9XYXNtTW9kdWxlUGFyc2VyLmNwcApAQCAtNTEsNiAr NTEsNyBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2UoKSAtPiBSZXN1bHQKICAgICB1aW50MzJf dCB2ZXJzaW9uTnVtYmVyOwogCiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihsZW5ndGgoKSA8IG1p blNpemUsICJleHBlY3RlZCBhIG1vZHVsZSBvZiBhdCBsZWFzdCAiLCBtaW5TaXplLCAiIGJ5dGVz Iik7CisgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihsZW5ndGgoKSA+IG1heE1vZHVsZVNpemUsICJt b2R1bGUgc2l6ZSAiLCBsZW5ndGgoKSwgIiBpcyB0b28gbGFyZ2UsIG1heGltdW0gIiwgbWF4TW9k dWxlU2l6ZSk7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighY29uc3VtZUNoYXJhY3RlcigwKSB8 fCAhY29uc3VtZVN0cmluZygiYXNtIiksICJtb2R1bGVzIGRvZXNuJ3Qgc3RhcnQgd2l0aCAnXFww YXNtJyIpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVUludDMyKHZlcnNpb25OdW1i ZXIpLCAiY2FuJ3QgcGFyc2UgdmVyc2lvbiBudW1iZXIiKTsKICAgICBXQVNNX1BBUlNFUl9GQUlM X0lGKHZlcnNpb25OdW1iZXIgIT0gZXhwZWN0ZWRWZXJzaW9uTnVtYmVyLCAidW5leHBlY3RlZCB2 ZXJzaW9uIG51bWJlciAiLCB2ZXJzaW9uTnVtYmVyLCAiIGV4cGVjdGVkICIsIGV4cGVjdGVkVmVy c2lvbk51bWJlcik7CkBAIC0xMDIsNyArMTAzLDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNl VHlwZSgpIC0+IFBhcnRpYWxSZXN1bHQKICAgICB1aW50MzJfdCBjb3VudDsKIAogICAgIFdBU01f UEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKGNvdW50KSwgImNhbid0IGdldCBUeXBlIHNl Y3Rpb24ncyBjb3VudCIpOwotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoY291bnQgPT0gc3RkOjpu dW1lcmljX2xpbWl0czx1aW50MzJfdD46Om1heCgpLCAiVHlwZSBzZWN0aW9uJ3MgY291bnQgaXMg dG9vIGJpZyAiLCBjb3VudCk7CisgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihjb3VudCA+IG1heFR5 cGVzLCAiVHlwZSBzZWN0aW9uJ3MgY291bnQgaXMgdG9vIGJpZyAiLCBjb3VudCwgIiBtYXhpbXVt ICIsIG1heFR5cGVzKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX2luZm8tPnVzZWRTaWdu YXR1cmVzLnRyeVJlc2VydmVDYXBhY2l0eShjb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2gg bWVtb3J5IGZvciBUeXBlIHNlY3Rpb24ncyAiLCBjb3VudCwgIiBlbnRyaWVzIik7CiAKICAgICBm b3IgKHVpbnQzMl90IGkgPSAwOyBpIDwgY291bnQ7ICsraSkgewpAQCAtMTEzLDcgKzExNCw3IEBA IGF1dG8gTW9kdWxlUGFyc2VyOjpwYXJzZVR5cGUoKSAtPiBQYXJ0aWFsUmVzdWx0CiAgICAgICAg IFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlSW50Nyh0eXBlKSwgImNhbid0IGdldCAiLCBpLCAi dGggVHlwZSdzIHR5cGUiKTsKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRih0eXBlICE9IEZ1 bmMsIGksICJ0aCBUeXBlIGlzIG5vbi1GdW5jICIsIHR5cGUpOwogICAgICAgICBXQVNNX1BBUlNF Ul9GQUlMX0lGKCFwYXJzZVZhclVJbnQzMihhcmd1bWVudENvdW50KSwgImNhbid0IGdldCAiLCBp LCAidGggVHlwZSdzIGFyZ3VtZW50IGNvdW50Iik7Ci0gICAgICAgIFdBU01fUEFSU0VSX0ZBSUxf SUYoYXJndW1lbnRDb3VudCA9PSBzdGQ6Om51bWVyaWNfbGltaXRzPHVpbnQzMl90Pjo6bWF4KCks IGksICJ0aCBhcmd1bWVudCBjb3VudCBpcyB0b28gYmlnICIsIGFyZ3VtZW50Q291bnQpOworICAg ICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGFyZ3VtZW50Q291bnQgPiBtYXhGdW5jdGlvblBhcmFt cywgaSwgInRoIGFyZ3VtZW50IGNvdW50IGlzIHRvbyBiaWcgIiwgYXJndW1lbnRDb3VudCwgIiBt YXhpbXVtICIsIG1heEZ1bmN0aW9uUGFyYW1zKTsKICAgICAgICAgUmVmUHRyPFNpZ25hdHVyZT4g bWF5YmVTaWduYXR1cmUgPSBTaWduYXR1cmU6OnRyeUNyZWF0ZShhcmd1bWVudENvdW50KTsKICAg ICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbWF5YmVTaWduYXR1cmUsICJjYW4ndCBhbGxvY2F0 ZSBlbm91Z2ggbWVtb3J5IGZvciBUeXBlIHNlY3Rpb24ncyAiLCBpLCAidGggc2lnbmF0dXJlIik7 CiAgICAgICAgIFJlZjxTaWduYXR1cmU+IHNpZ25hdHVyZSA9IG1heWJlU2lnbmF0dXJlLnJlbGVh c2VOb25OdWxsKCk7CkBAIC0xNDUsNyArMTQ2LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNl SW1wb3J0KCkgLT4gUGFydGlhbFJlc3VsdAogewogICAgIHVpbnQzMl90IGltcG9ydENvdW50Owog ICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKGltcG9ydENvdW50KSwgImNh bid0IGdldCBJbXBvcnQgc2VjdGlvbidzIGNvdW50Iik7Ci0gICAgV0FTTV9QQVJTRVJfRkFJTF9J RihpbXBvcnRDb3VudCA9PSBzdGQ6Om51bWVyaWNfbGltaXRzPHVpbnQzMl90Pjo6bWF4KCksICJJ bXBvcnQgc2VjdGlvbidzIGNvdW50IGlzIHRvbyBiaWcgIiwgaW1wb3J0Q291bnQpOworICAgIFdB U01fUEFSU0VSX0ZBSUxfSUYoaW1wb3J0Q291bnQgPiBtYXhJbXBvcnRzLCAiSW1wb3J0IHNlY3Rp b24ncyBjb3VudCBpcyB0b28gYmlnICIsIGltcG9ydENvdW50LCAiIG1heGltdW0gIiwgbWF4SW1w b3J0cyk7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9pbmZvLT5nbG9iYWxzLnRyeVJlc2Vy dmVDYXBhY2l0eShpbXBvcnRDb3VudCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZv ciAiLCBpbXBvcnRDb3VudCwgIiBnbG9iYWxzIik7IC8vIEZJWE1FIHRoaXMgb3Zlci1hbGxvY2F0 ZXMgd2hlbiB3ZSBmaXggdGhlIEZJWE1FcyBiZWxvdy4KICAgICBXQVNNX1BBUlNFUl9GQUlMX0lG KCFtX2luZm8tPmltcG9ydHMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGltcG9ydENvdW50KSwgImNhbid0 IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGltcG9ydENvdW50LCAiIGltcG9ydHMiKTsg Ly8gRklYTUUgdGhpcyBvdmVyLWFsbG9jYXRlcyB3aGVuIHdlIGZpeCB0aGUgRklYTUVzIGJlbG93 LgogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIW1faW5mby0+aW1wb3J0RnVuY3Rpb25TaWduYXR1 cmVJbmRpY2VzLnRyeVJlc2VydmVDYXBhY2l0eShpbXBvcnRDb3VudCksICJjYW4ndCBhbGxvY2F0 ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBpbXBvcnRDb3VudCwgIiBpbXBvcnQgZnVuY3Rpb24gc2ln bmF0dXJlcyIpOyAvLyBGSVhNRSB0aGlzIG92ZXItYWxsb2NhdGVzIHdoZW4gd2UgZml4IHRoZSBG SVhNRXMgYmVsb3cuCkBAIC0yMTEsNyArMjEyLDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNl RnVuY3Rpb24oKSAtPiBQYXJ0aWFsUmVzdWx0CiB7CiAgICAgdWludDMyX3QgY291bnQ7CiAgICAg V0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJVSW50MzIoY291bnQpLCAiY2FuJ3QgZ2V0IEZ1 bmN0aW9uIHNlY3Rpb24ncyBjb3VudCIpOwotICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoY291bnQg PT0gc3RkOjpudW1lcmljX2xpbWl0czx1aW50MzJfdD46Om1heCgpLCAiRnVuY3Rpb24gc2VjdGlv bidzIGNvdW50IGlzIHRvbyBiaWcgIiwgY291bnQpOworICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYo Y291bnQgPiBtYXhGdW5jdGlvbnMsICJGdW5jdGlvbiBzZWN0aW9uJ3MgY291bnQgaXMgdG9vIGJp ZyAiLCBjb3VudCwgIiBtYXhpbXVtICIsIG1heEZ1bmN0aW9ucyk7CiAgICAgV0FTTV9QQVJTRVJf RkFJTF9JRighbV9pbmZvLT5pbnRlcm5hbEZ1bmN0aW9uU2lnbmF0dXJlSW5kaWNlcy50cnlSZXNl cnZlQ2FwYWNpdHkoY291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBmb3IgIiwg Y291bnQsICIgRnVuY3Rpb24gc2lnbmF0dXJlcyIpOwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYo IW1faW5mby0+ZnVuY3Rpb25Mb2NhdGlvbkluQmluYXJ5LnRyeVJlc2VydmVDYXBhY2l0eShjb3Vu dCksICJjYW4ndCBhbGxvY2F0ZSBlbm91Z2ggbWVtb3J5IGZvciAiLCBjb3VudCwgIkZ1bmN0aW9u IGxvY2F0aW9ucyIpOwogCkBAIC0zMzQsNiArMzM1LDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBh cnNlR2xvYmFsKCkgLT4gUGFydGlhbFJlc3VsdAogewogICAgIHVpbnQzMl90IGdsb2JhbENvdW50 OwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKGdsb2JhbENvdW50KSwg ImNhbid0IGdldCBHbG9iYWwgc2VjdGlvbidzIGNvdW50Iik7CisgICAgV0FTTV9QQVJTRVJfRkFJ TF9JRihnbG9iYWxDb3VudCA+IG1heEdsb2JhbHMsICJHbG9iYWwgc2VjdGlvbidzIGNvdW50IGlz IHRvbyBiaWcgIiwgZ2xvYmFsQ291bnQsICIgbWF4aW11bSAiLCBtYXhHbG9iYWxzKTsKICAgICBX QVNNX1BBUlNFUl9GQUlMX0lGKCFtX2luZm8tPmdsb2JhbHMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGds b2JhbENvdW50ICsgbV9pbmZvLT5maXJzdEludGVybmFsR2xvYmFsKSwgImNhbid0IGFsbG9jYXRl IG1lbW9yeSBmb3IgIiwgZ2xvYmFsQ291bnQgKyBtX2luZm8tPmZpcnN0SW50ZXJuYWxHbG9iYWws ICIgZ2xvYmFscyIpOwogCiAgICAgZm9yICh1aW50MzJfdCBnbG9iYWxJbmRleCA9IDA7IGdsb2Jh bEluZGV4IDwgZ2xvYmFsQ291bnQ7ICsrZ2xvYmFsSW5kZXgpIHsKQEAgLTM1OSw3ICszNjEsNyBA QCBhdXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VFeHBvcnQoKSAtPiBQYXJ0aWFsUmVzdWx0CiB7CiAg ICAgdWludDMyX3QgZXhwb3J0Q291bnQ7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VW YXJVSW50MzIoZXhwb3J0Q291bnQpLCAiY2FuJ3QgZ2V0IEV4cG9ydCBzZWN0aW9uJ3MgY291bnQi KTsKLSAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGV4cG9ydENvdW50ID09IHN0ZDo6bnVtZXJpY19s aW1pdHM8dWludDMyX3Q+OjptYXgoKSwgIkV4cG9ydCBzZWN0aW9uJ3MgY291bnQgaXMgdG9vIGJp ZyAiLCBleHBvcnRDb3VudCk7CisgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihleHBvcnRDb3VudCA+ IG1heEV4cG9ydHMsICJFeHBvcnQgc2VjdGlvbidzIGNvdW50IGlzIHRvbyBiaWcgIiwgZXhwb3J0 Q291bnQsICIgbWF4aW11bSAiLCBtYXhFeHBvcnRzKTsKICAgICBXQVNNX1BBUlNFUl9GQUlMX0lG KCFtX2luZm8tPmV4cG9ydHMudHJ5UmVzZXJ2ZUNhcGFjaXR5KGV4cG9ydENvdW50KSwgImNhbid0 IGFsbG9jYXRlIGVub3VnaCBtZW1vcnkgZm9yICIsIGV4cG9ydENvdW50LCAiIGV4cG9ydHMiKTsK IAogICAgIEhhc2hTZXQ8U3RyaW5nPiBleHBvcnROYW1lczsKQEAgLTQyNCw3ICs0MjYsNyBAQCBh dXRvIE1vZHVsZVBhcnNlcjo6cGFyc2VFbGVtZW50KCkgLT4gUGFydGlhbFJlc3VsdAogCiAgICAg dWludDMyX3QgZWxlbWVudENvdW50OwogICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFy VUludDMyKGVsZW1lbnRDb3VudCksICJjYW4ndCBnZXQgRWxlbWVudCBzZWN0aW9uJ3MgY291bnQi KTsKLSAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKGVsZW1lbnRDb3VudCA9PSBzdGQ6Om51bWVyaWNf bGltaXRzPHVpbnQzMl90Pjo6bWF4KCksICJFbGVtZW50IHNlY3Rpb24ncyBjb3VudCBpcyB0b28g YmlnICIsIGVsZW1lbnRDb3VudCk7CisgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihlbGVtZW50Q291 bnQgPiBtYXhUYWJsZUVudHJpZXMsICJFbGVtZW50IHNlY3Rpb24ncyBjb3VudCBpcyB0b28gYmln ICIsIGVsZW1lbnRDb3VudCwgIiBtYXhpbXVtICIsIG1heFRhYmxlRW50cmllcyk7CiAgICAgV0FT TV9QQVJTRVJfRkFJTF9JRighbV9pbmZvLT5lbGVtZW50cy50cnlSZXNlcnZlQ2FwYWNpdHkoZWxl bWVudENvdW50KSwgImNhbid0IGFsbG9jYXRlIG1lbW9yeSBmb3IgIiwgZWxlbWVudENvdW50LCAi IEVsZW1lbnRzIik7CiAgICAgZm9yICh1bnNpZ25lZCBlbGVtZW50TnVtID0gMDsgZWxlbWVudE51 bSA8IGVsZW1lbnRDb3VudDsgKytlbGVtZW50TnVtKSB7CiAgICAgICAgIHVpbnQzMl90IHRhYmxl SW5kZXg7CkBAIC00NzEsNiArNDczLDcgQEAgYXV0byBNb2R1bGVQYXJzZXI6OnBhcnNlQ29kZSgp IC0+IFBhcnRpYWxSZXN1bHQKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighcGFyc2VWYXJV SW50MzIoZnVuY3Rpb25TaXplKSwgImNhbid0IGdldCAiLCBpLCAidGggQ29kZSBmdW5jdGlvbidz IHNpemUiKTsKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRihmdW5jdGlvblNpemUgPiBsZW5n dGgoKSwgIkNvZGUgZnVuY3Rpb24ncyBzaXplICIsIGZ1bmN0aW9uU2l6ZSwgIiBleGNlZWRzIHRo ZSBtb2R1bGUncyBzaXplICIsIGxlbmd0aCgpKTsKICAgICAgICAgV0FTTV9QQVJTRVJfRkFJTF9J RihmdW5jdGlvblNpemUgPiBsZW5ndGgoKSAtIG1fb2Zmc2V0LCAiQ29kZSBmdW5jdGlvbidzIHNp emUgIiwgZnVuY3Rpb25TaXplLCAiIGV4Y2VlZHMgdGhlIG1vZHVsZSdzIHJlbWFpbmluZyBzaXpl IiwgbGVuZ3RoKCkgLSBtX29mZnNldCk7CisgICAgICAgIFdBU01fUEFSU0VSX0ZBSUxfSUYoZnVu Y3Rpb25TaXplID4gc3RkOjpudW1lcmljX2xpbWl0czx1aW50MzJfdD46Om1heCgpLCAiQ29kZSBm dW5jdGlvbidzIHNpemUgIiwgZnVuY3Rpb25TaXplLCAiIGlzIHRvbyBiaWciKTsKIAogICAgICAg ICBtX2luZm8tPmZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeVtpXS5zdGFydCA9IG1fb2Zmc2V0Owog ICAgICAgICBtX2luZm8tPmZ1bmN0aW9uTG9jYXRpb25JbkJpbmFyeVtpXS5lbmQgPSBtX29mZnNl dCArIGZ1bmN0aW9uU2l6ZTsKQEAgLTU1NSw3ICs1NTgsNyBAQCBhdXRvIE1vZHVsZVBhcnNlcjo6 cGFyc2VEYXRhKCkgLT4gUGFydGlhbFJlc3VsdAogICAgIHVpbnQzMl90IHNlZ21lbnRDb3VudDsK ICAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKCFtX2luZm8tPm1lbW9yeSwgIkRhdGEgc2VjdGlvbiBj YW5ub3QgZXhpc3Qgd2l0aG91dCBhIE1lbW9yeSBzZWN0aW9uIG9yIEltcG9ydCIpOwogICAgIFdB U01fUEFSU0VSX0ZBSUxfSUYoIXBhcnNlVmFyVUludDMyKHNlZ21lbnRDb3VudCksICJjYW4ndCBn ZXQgRGF0YSBzZWN0aW9uJ3MgY291bnQiKTsKLSAgICBXQVNNX1BBUlNFUl9GQUlMX0lGKHNlZ21l bnRDb3VudCA9PSBzdGQ6Om51bWVyaWNfbGltaXRzPHVpbnQzMl90Pjo6bWF4KCksICJEYXRhIHNl Y3Rpb24ncyBjb3VudCBpcyB0b28gYmlnICIsIHNlZ21lbnRDb3VudCk7CisgICAgV0FTTV9QQVJT RVJfRkFJTF9JRihzZWdtZW50Q291bnQgPiBtYXhEYXRhU2VnbWVudHMsICJEYXRhIHNlY3Rpb24n cyBjb3VudCBpcyB0b28gYmlnICIsIHNlZ21lbnRDb3VudCwgIiBtYXhpbXVtICIsIG1heERhdGFT ZWdtZW50cyk7CiAgICAgV0FTTV9QQVJTRVJfRkFJTF9JRighbV9pbmZvLT5kYXRhLnRyeVJlc2Vy dmVDYXBhY2l0eShzZWdtZW50Q291bnQpLCAiY2FuJ3QgYWxsb2NhdGUgZW5vdWdoIG1lbW9yeSBm b3IgRGF0YSBzZWN0aW9uJ3MgIiwgc2VnbWVudENvdW50LCAiIHNlZ21lbnRzIik7CiAKICAgICBm b3IgKHVpbnQzMl90IHNlZ21lbnROdW1iZXIgPSAwOyBzZWdtZW50TnVtYmVyIDwgc2VnbWVudENv dW50OyArK3NlZ21lbnROdW1iZXIpIHsKZGlmZiAtLWdpdCBhL1NvdXJjZS9KYXZhU2NyaXB0Q29y ZS93YXNtL1dhc21QYXJzZXIuaCBiL1NvdXJjZS9KYXZhU2NyaXB0Q29yZS93YXNtL1dhc21QYXJz ZXIuaAppbmRleCBjMmE4YzE0Li5iOGJmMGM2IDEwMDY0NAotLS0gYS9Tb3VyY2UvSmF2YVNjcmlw dENvcmUvd2FzbS9XYXNtUGFyc2VyLmgKKysrIGIvU291cmNlL0phdmFTY3JpcHRDb3JlL3dhc20v V2FzbVBhcnNlci5oCkBAIC0zMCw2ICszMCw3IEBACiAjaW5jbHVkZSAiQjNDb21waWxhdGlvbi5o IgogI2luY2x1ZGUgIkIzUHJvY2VkdXJlLmgiCiAjaW5jbHVkZSAiV2FzbUZvcm1hdC5oIgorI2lu Y2x1ZGUgIldhc21MaW1pdHMuaCIKICNpbmNsdWRlICJXYXNtTW9kdWxlSW5mb3JtYXRpb24uaCIK ICNpbmNsdWRlICJXYXNtT3BzLmgiCiAjaW5jbHVkZSAiV2FzbVNlY3Rpb25zLmgiCkBAIC0xNDYs NiArMTQ3LDggQEAgQUxXQVlTX0lOTElORSBib29sIFBhcnNlcjxTdWNjZXNzVHlwZT46OmNvbnN1 bWVVVEY4U3RyaW5nKE5hbWUmIHJlc3VsdCwgc2l6ZV90IHMKIHsKICAgICBpZiAobGVuZ3RoKCkg PCBzdHJpbmdMZW5ndGggfHwgbV9vZmZzZXQgPiBsZW5ndGgoKSAtIHN0cmluZ0xlbmd0aCkKICAg ICAgICAgcmV0dXJuIGZhbHNlOworICAgIGlmIChzdHJpbmdMZW5ndGggPiBtYXhTdHJpbmdTaXpl KQorICAgICAgICByZXR1cm4gZmFsc2U7CiAgICAgaWYgKCFyZXN1bHQudHJ5UmVzZXJ2ZUNhcGFj aXR5KHN0cmluZ0xlbmd0aCkpCiAgICAgICAgIHJldHVybiBmYWxzZTsKIAotLSAKMi45LjMKCg==